LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x2a38
movq %rdi, %rbx
leaq 0xb0(%rdi), %r15
movq 0xb0(%rdi), %rdi
testq %rdi, %rdi
je 0x28c3
callq 0x2040
leaq 0x88(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x28ed
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x118(%rbx), %rdi
cmpq 0x120(%rbx), %rdi
je 0x291b
leaq 0x50(%rdi), %rax
movq %rax, 0x118(%rbx)
callq 0x2210
jmp 0x28f9
leaq 0x108(%rbx), %r15
movq 0x108(%rbx), %rdi
testq %rdi, %rdi
je 0x2933
callq 0x2040
leaq 0x138(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movups %xmm0, (%r15)
movq 0x138(%rbx), %rdi
testq %rdi, %rdi
je 0x295a
callq 0x2040
xorps %xmm0, %xmm0
leaq 0x158(%rbx), %r15
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x158(%rbx), %rdi
testq %rdi, %rdi
je 0x297e
callq 0x2040
leaq 0x170(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0x170(%rbx), %rdi
testq %rdi, %rdi
je 0x29a8
callq 0x2040
xorps %xmm0, %xmm0
leaq 0x190(%rbx), %r15
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x190(%rbx), %rdi
testq %rdi, %rdi
je 0x29cc
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0x1a8(%rbx), %rdi
movq 0x1b8(%rbx), %rax
cmpq %rax, %rdi
je 0x2a1a
leaq -0x10(%rax), %rcx
movq %rcx, 0x1b8(%rbx)
movq -0x10(%rax), %rdi
movq -0x8(%rax), %r14
testq %rdi, %rdi
je 0x2a0b
callq 0x2040
testq %r14, %r14
je 0x29db
movq %r14, %rdi
callq 0x2040
jmp 0x29db
testq %rdi, %rdi
je 0x2a24
callq 0x2040
movl $0x1e0, %edx            # imm = 0x1E0
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2120
leaq 0x145f3(%rip), %rdi     # 0x17032
leaq 0x145f3(%rip), %rsi     # 0x17039
leaq 0x1461e(%rip), %rcx     # 0x1706b
movl $0xd8, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x2ab9
movq %rdi, %rbx
movl (%rdi), %ecx
leal -0x12(%rcx), %eax
cmpl $0x3, %eax
ja 0x2a80
leaq 0x1458f(%rip), %rcx     # 0x17000
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %rdi
jmp 0x2a97
cmpl $0x4, %ecx
jne 0x2aa1
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2a93
callq 0x2040
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2aa1
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 0x156b0(%rip), %rdi     # 0x18170
leaq 0x14572(%rip), %rsi     # 0x17039
leaq 0x149d7(%rip), %rcx     # 0x174a5
movl $0x244, %edx            # imm = 0x244
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x2b0a
cmpq $0x0, 0x58(%rdi)
jne 0x2b29
testq %rsi, %rsi
je 0x2b48
leaq 0x76(%rip), %rax        # 0x2b67
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 0x14521(%rip), %rdi     # 0x17032
leaq 0x14521(%rip), %rsi     # 0x17039
leaq 0x14575(%rip), %rcx     # 0x17094
movl $0x11e, %edx            # imm = 0x11E
callq 0x2100
leaq 0x145b6(%rip), %rdi     # 0x170e6
leaq 0x14502(%rip), %rsi     # 0x17039
leaq 0x14556(%rip), %rcx     # 0x17094
movl $0x11f, %edx            # imm = 0x11F
callq 0x2100
leaq 0x145ad(%rip), %rdi     # 0x170fc
leaq 0x144e3(%rip), %rsi     # 0x17039
leaq 0x14537(%rip), %rcx     # 0x17094
movl $0x120, %edx            # imm = 0x120
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x2b9d
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 0x2ba0
xorl %r14d, %r14d
movq %r14, (%rbx)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2bd5
cmpq $0x0, 0x58(%rdi)
jne 0x2bf4
testq %rsi, %rsi
je 0x2c13
leaq 0x6b(%rip), %rax        # 0x2c32
movq %rax, 0x58(%rdi)
movq %rdi, 0x60(%rdi)
movq %rsi, 0x68(%rdi)
popq %rax
retq
leaq 0x14456(%rip), %rdi     # 0x17032
leaq 0x14456(%rip), %rsi     # 0x17039
leaq 0x14518(%rip), %rcx     # 0x17102
movl $0x131, %edx            # imm = 0x131
callq 0x2100
leaq 0x144eb(%rip), %rdi     # 0x170e6
leaq 0x14437(%rip), %rsi     # 0x17039
leaq 0x144f9(%rip), %rcx     # 0x17102
movl $0x132, %edx            # imm = 0x132
callq 0x2100
leaq 0x14521(%rip), %rdi     # 0x1713b
leaq 0x14418(%rip), %rsi     # 0x17039
leaq 0x144da(%rip), %rcx     # 0x17102
movl $0x133, %edx            # imm = 0x133
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x2c89
cmpq $0x0, 0x58(%rdi)
jne 0x2ca8
testq %rsi, %rsi
je 0x2cc7
movq %rsi, 0x58(%rdi)
movq %rdx, 0x60(%rdi)
popq %rax
retq
leaq 0x143a2(%rip), %rdi     # 0x17032
leaq 0x143a2(%rip), %rsi     # 0x17039
leaq 0x144a2(%rip), %rcx     # 0x17140
movl $0x143, %edx            # imm = 0x143
callq 0x2100
leaq 0x14437(%rip), %rdi     # 0x170e6
leaq 0x14383(%rip), %rsi     # 0x17039
leaq 0x14483(%rip), %rcx     # 0x17140
movl $0x144, %edx            # imm = 0x144
callq 0x2100
leaq 0x14426(%rip), %rdi     # 0x170f4
leaq 0x14364(%rip), %rsi     # 0x17039
leaq 0x14464(%rip), %rcx     # 0x17140
movl $0x145, %edx            # imm = 0x145
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x312f
movq %rdi, %rbx
leaq 0x38(%rdi), %r15
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x2fe7
callq 0x2040
leaq 0x58(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x300b
callq 0x2040
xorps %xmm0, %xmm0
leaq 0x90(%rbx), %r15
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x302f
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0xc0(%rbx), %rdi
cmpq 0xc8(%rbx), %rdi
je 0x3060
leaq 0x68(%rdi), %rax
movq %rax, 0xc0(%rbx)
callq 0x21e0
jmp 0x303e
leaq 0xb0(%rbx), %r15
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x3078
callq 0x2040
leaq 0xd0(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movups %xmm0, (%r15)
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x309f
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0xe8(%rbx), %rdi
movq 0xf8(%rbx), %rax
cmpq %rax, %rdi
je 0x30ea
leaq -0x10(%rax), %rcx
movq %rcx, 0xf8(%rbx)
movq -0x10(%rax), %rdi
movq -0x8(%rax), %r14
testq %rdi, %rdi
je 0x30db
callq 0x2040
testq %r14, %r14
je 0x30ab
movq %r14, %rdi
callq 0x2040
jmp 0x30ab
leaq 0xe8(%rbx), %r14
testq %rdi, %rdi
je 0x30fb
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x198(%rbx), %rdi
testq %rdi, %rdi
je 0x311b
callq 0x2040
movl $0x1b0, %edx            # imm = 0x1B0
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2120
leaq 0x140a7(%rip), %rdi     # 0x171dd
leaq 0x13efc(%rip), %rsi     # 0x17039
leaq 0x140cf(%rip), %rcx     # 0x17213
movl $0x184, %edx            # imm = 0x184
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x322c
movq %rdi, %rbx
movl (%rdi), %eax
addl $-0x3, %eax
cmpl $0x6, %eax
ja 0x3202
leaq 0x13e9d(%rip), %rcx     # 0x17010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x31eb
callq 0x2040
jmp 0x31eb
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x319a
callq 0x2040
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x31a8
callq 0x2040
movq 0x18(%rbx), %r14
jmp 0x31f5
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x31bc
callq 0x2040
movq 0x10(%rbx), %r14
cmpq 0x18(%rbx), %r14
je 0x31f5
movq (%r14), %rdi
testq %rdi, %rdi
je 0x31d3
callq 0x2040
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x31e1
callq 0x2040
addq $0x10, %r14
cmpq 0x18(%rbx), %r14
jne 0x31c6
movq 0x10(%rbx), %r14
jmp 0x31f5
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x3202
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)
movq $0x0, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x14299(%rip), %rdi     # 0x174cc
leaq 0x13dff(%rip), %rsi     # 0x17039
leaq 0x14675(%rip), %rcx     # 0x178b6
movl $0x3d7, %edx            # imm = 0x3D7
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x3281
cmpq $0x0, 0x10(%rdi)
jne 0x32a0
testq %rsi, %rsi
je 0x32bf
leaq 0x7a(%rip), %rax        # 0x32de
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 0x13f55(%rip), %rdi     # 0x171dd
leaq 0x13daa(%rip), %rsi     # 0x17039
leaq 0x13fa8(%rip), %rcx     # 0x1723e
movl $0x1c6, %edx            # imm = 0x1C6
callq 0x2100
leaq 0x13ff0(%rip), %rdi     # 0x17297
leaq 0x13d8b(%rip), %rsi     # 0x17039
leaq 0x13f89(%rip), %rcx     # 0x1723e
movl $0x1c7, %edx            # imm = 0x1C7
callq 0x2100
leaq 0x13fe9(%rip), %rdi     # 0x172af
leaq 0x13d6c(%rip), %rsi     # 0x17039
leaq 0x13f6a(%rip), %rcx     # 0x1723e
movl $0x1c8, %edx            # imm = 0x1C8
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x331a
subq %rax, %rdx
callq 0x2170
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
jmp 0x332e
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_O3/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 0x335d
cmpq $0x0, 0x10(%rdi)
jne 0x337c
testq %rsi, %rsi
je 0x339b
leaq 0x6b(%rip), %rax        # 0x33ba
movq %rax, 0x10(%rdi)
movq %rdi, 0x18(%rdi)
movq %rsi, 0x20(%rdi)
popq %rax
retq
leaq 0x13e79(%rip), %rdi     # 0x171dd
leaq 0x13cce(%rip), %rsi     # 0x17039
leaq 0x13f44(%rip), %rcx     # 0x172b6
movl $0x1da, %edx            # imm = 0x1DA
callq 0x2100
leaq 0x13f14(%rip), %rdi     # 0x17297
leaq 0x13caf(%rip), %rsi     # 0x17039
leaq 0x13f25(%rip), %rcx     # 0x172b6
movl $0x1db, %edx            # imm = 0x1DB
callq 0x2100
leaq 0x13d99(%rip), %rdi     # 0x1713b
leaq 0x13c90(%rip), %rsi     # 0x17039
leaq 0x13f06(%rip), %rcx     # 0x172b6
movl $0x1dc, %edx            # imm = 0x1DC
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x33fa
cmpq $0x0, 0x10(%rdi)
jne 0x3419
testq %rsi, %rsi
je 0x3438
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
popq %rax
retq
leaq 0x13ddc(%rip), %rdi     # 0x171dd
leaq 0x13c31(%rip), %rsi     # 0x17039
leaq 0x13ee3(%rip), %rcx     # 0x172f2
movl $0x1ec, %edx            # imm = 0x1EC
callq 0x2100
leaq 0x13e77(%rip), %rdi     # 0x17297
leaq 0x13c12(%rip), %rsi     # 0x17039
leaq 0x13ec4(%rip), %rcx     # 0x172f2
movl $0x1ed, %edx            # imm = 0x1ED
callq 0x2100
leaq 0x13cb5(%rip), %rdi     # 0x170f4
leaq 0x13bf3(%rip), %rsi     # 0x17039
leaq 0x13ea5(%rip), %rcx     # 0x172f2
movl $0x1ee, %edx            # imm = 0x1EE
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x35db
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x30(%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 0x13ee9(%rip), %rdi     # 0x174cc
leaq 0x13a4f(%rip), %rsi     # 0x17039
leaq 0x13ee1(%rip), %rcx     # 0x174d2
movl $0x29c, %edx            # imm = 0x29C
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x362e
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x30(%rdi)
movl $0x2, (%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movl $0x1, %eax
retq
pushq %rax
leaq 0x13e96(%rip), %rdi     # 0x174cc
leaq 0x139fc(%rip), %rsi     # 0x17039
leaq 0x13ed6(%rip), %rcx     # 0x1751a
movl $0x2ac, %edx            # imm = 0x2AC
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rsi, %rsi
jle 0x3a9c
pushq %rbp
pushq %r14
pushq %rbx
addq %rdi, %rsi
movl $0xf0, %ecx
movl $0x3, %edx
xorl %r8d, %r8d
movzbl (%rdi), %r9d
testb %r9b, %r9b
js 0x39c6
incq %rdi
movq %rdi, %r10
cmpq %rsi, %rdi
jbe 0x3a89
jmp 0x3aa2
movl %r9d, %eax
andl $-0x20, %eax
cmpl $0xc0, %eax
jne 0x39de
andl $0x1f, %r9d
movl $0x2, %eax
jmp 0x3a20
movl %r9d, %r11d
andl $-0x10, %r11d
movl %r9d, %r10d
andl $-0x8, %r10d
xorl %eax, %eax
cmpl %ecx, %r10d
sete %al
shll $0x2, %eax
cmpl $0xe0, %r11d
cmovel %edx, %eax
jne 0x3a09
andl $0xf, %r9d
jmp 0x3a18
andl $0x7, %r9d
cmpl $0xf0, %r10d
cmovnel %r8d, %r9d
testl %eax, %eax
je 0x3aa2
movl %eax, %r11d
leaq (%rdi,%r11), %r10
xorl %eax, %eax
cmpq %rsi, %r10
ja 0x3aa4
cmpl $0x2, %r11d
jb 0x3a89
movl $0x1, %r14d
movzbl (%rdi,%r14), %ebp
movl %ebp, %ebx
andl $-0x40, %ebx
cmpl $0x80, %ebx
jne 0x3aa4
movl %r9d, %ebx
shll $0x6, %ebx
andl $0x3f, %ebp
orl %ebx, %ebp
incq %r14
movl %ebp, %r9d
cmpq %r14, %r11
jne 0x3a3a
cmpl $0x2, %r11d
jne 0x3a6d
cmpl $0x7f, %ebx
ja 0x3a89
cmpl $0x3, %r11d
jne 0x3a7b
cmpl $0x7ff, %ebx            # imm = 0x7FF
ja 0x3a89
cmpl $0x4, %r11d
jne 0x3aa4
cmpl $0x10000, %ebx          # imm = 0x10000
jb 0x3aa4
movq %r10, %rdi
cmpq %rsi, %r10
jb 0x39a9
movl $0x1, %eax
jmp 0x3aa4
movl $0x1, %eax
retq
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3adf
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x30(%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 0x139e5(%rip), %rdi     # 0x174cc
leaq 0x1354b(%rip), %rsi     # 0x17039
leaq 0x13b6d(%rip), %rcx     # 0x17662
movl $0x30b, %edx            # imm = 0x30B
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x3b75
movq %rsi, %r14
testq %rsi, %rsi
je 0x3b94
movq %rdi, %rbx
movq %r14, %rdi
callq 0x20d0
movq %r14, %rdi
movq %rax, %rsi
callq 0x398c
xorl %ebp, %ebp
testl %eax, %eax
je 0x3b6e
movq %r14, %rdi
callq 0x2220
testq %rax, %rax
je 0x3b6e
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x30(%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 0x13950(%rip), %rdi     # 0x174cc
leaq 0x134b6(%rip), %rsi     # 0x17039
leaq 0x13b14(%rip), %rcx     # 0x1769e
movl $0x31c, %edx            # imm = 0x31C
callq 0x2100
leaq 0x149cc(%rip), %rdi     # 0x18567
leaq 0x13497(%rip), %rsi     # 0x17039
leaq 0x13af5(%rip), %rcx     # 0x1769e
movl $0x31d, %edx            # imm = 0x31D
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3e62
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
xorl %r13d, %r13d
testq %rsi, %rsi
je 0x3dcb
movq %r15, %rdi
callq 0x20d0
movq %r15, %rdi
movq %rax, %rsi
callq 0x398c
testl %eax, %eax
je 0x3e50
movq %r15, %rdi
callq 0x2220
movq %rax, %r15
testq %rax, %rax
jne 0x3dce
jmp 0x3e50
xorl %r15d, %r15d
testq %r12, %r12
je 0x3e09
movq %r12, %rdi
callq 0x20d0
movq %r12, %rdi
movq %rax, %rsi
callq 0x398c
testl %eax, %eax
je 0x3df7
movq %r12, %rdi
callq 0x2220
testq %rax, %rax
jne 0x3e0b
xorl %r13d, %r13d
testq %r15, %r15
je 0x3e50
movq %r15, %rdi
callq 0x2040
jmp 0x3e50
xorl %eax, %eax
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movups %xmm0, 0x10(%r14)
movups %xmm0, 0x20(%r14)
movq $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)
movl $0x1, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13663(%rip), %rdi     # 0x174cc
leaq 0x131c9(%rip), %rsi     # 0x17039
leaq 0x138ee(%rip), %rcx     # 0x17765
movl $0x36d, %edx            # imm = 0x36D
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x3eb4
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x30(%rdi)
movl $0x8, (%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movl $0x1, %eax
retq
pushq %rax
leaq 0x13610(%rip), %rdi     # 0x174cc
leaq 0x13176(%rip), %rsi     # 0x17039
leaq 0x1390e(%rip), %rcx     # 0x177d8
movl $0x390, %edx            # imm = 0x390
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3fc5
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
xorl %r13d, %r13d
testq %rsi, %rsi
je 0x3f2e
movq %r15, %rdi
callq 0x20d0
movq %r15, %rdi
movq %rax, %rsi
callq 0x398c
testl %eax, %eax
je 0x3fb3
movq %r15, %rdi
callq 0x2220
movq %rax, %r15
testq %rax, %rax
jne 0x3f31
jmp 0x3fb3
xorl %r15d, %r15d
testq %r12, %r12
je 0x3f6c
movq %r12, %rdi
callq 0x20d0
movq %r12, %rdi
movq %rax, %rsi
callq 0x398c
testl %eax, %eax
je 0x3f5a
movq %r12, %rdi
callq 0x2220
testq %rax, %rax
jne 0x3f6e
xorl %r13d, %r13d
testq %r15, %r15
je 0x3fb3
movq %r15, %rdi
callq 0x2040
jmp 0x3fb3
xorl %eax, %eax
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movups %xmm0, 0x10(%r14)
movups %xmm0, 0x20(%r14)
movq $0x0, 0x30(%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, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13500(%rip), %rdi     # 0x174cc
leaq 0x13066(%rip), %rsi     # 0x17039
leaq 0x13835(%rip), %rcx     # 0x1780f
movl $0x3a4, %edx            # imm = 0x3A4
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_mapping_end_event_initialize
YAML_DECLARE(int)
yaml_mapping_end_event_initialize(yaml_event_t *event)
{
    yaml_mark_t mark = { 0, 0, 0 };

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

    MAPPING_END_EVENT_INIT(*event, mark, mark);

    return 1;
}

// Assembly:
testq %rdi, %rdi
je 0x4017
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x30(%rdi)
movl $0xa, (%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movl $0x1, %eax
retq
pushq %rax
leaq 0x134ad(%rip), %rdi     # 0x174cc
leaq 0x13013(%rip), %rsi     # 0x17039
leaq 0x13853(%rip), %rcx     # 0x17880
movl $0x3c7, %edx            # imm = 0x3C7
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_document_delete
YAML_DECLARE(void)
yaml_document_delete(yaml_document_t *document)
{
    struct {
        yaml_error_type_t error;
    } context;
    yaml_tag_directive_t *tag_directive;

    context.error = YAML_NO_ERROR;  /* Eliminate a compliler warning. */

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

    while (!STACK_EMPTY(&context, document->nodes)) {
        yaml_node_t node = POP(&context, document->nodes);
        yaml_free(node.tag);
        switch (node.type) {
            case YAML_SCALAR_NODE:
                yaml_free(node.data.scalar.value);
                break;
            case YAML_SEQUENCE_NODE:
                STACK_DEL(&context, node.data.sequence.items);
                break;
            case YAML_MAPPING_NODE:
                STACK_DEL(&context, node.data.mapping.pairs);
                break;
            default:
                assert(0);  /* Should not happen. */
        }
    }
    STACK_DEL(&context, document->nodes);

    yaml_free(document->version_directive);
    for (tag_directive = document->tag_directives.start;
            tag_directive != document->tag_directives.end;
            tag_directive++) {
        yaml_free(tag_directive->handle);
        yaml_free(tag_directive->prefix);
    }
    yaml_free(document->tag_directives.start);

    memset(document, 0, sizeof(yaml_document_t));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x44ad
movq %rdi, %rbx
movq (%rbx), %rdi
movq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x4401
leaq -0x60(%rax), %rcx
movq %rcx, 0x10(%rbx)
movl -0x60(%rax), %ebp
movq -0x58(%rax), %rdi
movq -0x50(%rax), %r14
testq %rdi, %rdi
je 0x43df
callq 0x2040
cmpl $0x3, %ebp
je 0x43f2
cmpl $0x2, %ebp
je 0x43f2
cmpl $0x1, %ebp
jne 0x448e
testq %r14, %r14
je 0x43b6
movq %r14, %rdi
callq 0x2040
jmp 0x43b6
testq %rdi, %rdi
je 0x440b
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x4427
callq 0x2040
movq 0x20(%rbx), %r14
cmpq 0x28(%rbx), %r14
je 0x445a
movq (%r14), %rdi
testq %rdi, %rdi
je 0x443e
callq 0x2040
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x444c
callq 0x2040
addq $0x10, %r14
cmpq 0x28(%rbx), %r14
jne 0x4431
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x4467
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)
movq $0x0, 0x60(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1418b(%rip), %rdi     # 0x18620
leaq 0x12b9d(%rip), %rsi     # 0x17039
leaq 0x134c0(%rip), %rcx     # 0x17963
movl $0x476, %edx            # imm = 0x476
callq 0x2100
leaq 0x1443a(%rip), %rdi     # 0x188ee
leaq 0x12b7e(%rip), %rsi     # 0x17039
leaq 0x134a1(%rip), %rcx     # 0x17963
movl $0x466, %edx            # imm = 0x466
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_document_get_node
YAML_DECLARE(yaml_node_t *)
yaml_document_get_node(yaml_document_t *document, int index)
{
    assert(document);   /* Non-NULL document object is expected. */

    if (index > 0 && document->nodes.start + index <= document->nodes.top) {
        return document->nodes.start + index - 1;
    }
    return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x44f9
testl %esi, %esi
jle 0x44f6
movq (%rdi), %rcx
movl %esi, %eax
leaq (%rax,%rax,2), %rdx
shlq $0x5, %rdx
leaq (%rcx,%rdx), %rsi
xorl %eax, %eax
cmpq 0x10(%rdi), %rsi
leaq -0x60(%rcx,%rdx), %rcx
cmovbeq %rcx, %rax
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x143ed(%rip), %rdi     # 0x188ee
leaq 0x12b31(%rip), %rsi     # 0x17039
leaq 0x13481(%rip), %rcx     # 0x17990
movl $0x48e, %edx            # imm = 0x48E
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_document_add_sequence
YAML_DECLARE(int)
yaml_document_add_sequence(yaml_document_t *document,
        yaml_char_t *tag, yaml_sequence_style_t style)
{
    struct {
        yaml_error_type_t error;
    } context;
    yaml_mark_t mark = { 0, 0, 0 };
    yaml_char_t *tag_copy = NULL;
    struct {
        yaml_node_item_t *start;
        yaml_node_item_t *end;
        yaml_node_item_t *top;
    } items = { NULL, NULL, NULL };
    yaml_node_t node;

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

    if (!tag) {
        tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG;
    }

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

    if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error;

    SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
            style, mark, mark);
    if (!PUSH(&context, document->nodes, node)) goto error;

    return document->nodes.top - document->nodes.start;

error:
    STACK_DEL(&context, items);
    yaml_free(tag_copy);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x47ee
movl %edx, %ebp
movq %rdi, %rbx
testq %rsi, %rsi
leaq 0x133d6(%rip), %r15     # 0x17ade
cmovneq %rsi, %r15
movq %r15, %rdi
callq 0x20d0
movq %r15, %rdi
movq %rax, %rsi
callq 0x398c
xorl %r14d, %r14d
testl %eax, %eax
je 0x47dc
movq %r15, %rdi
callq 0x2220
testq %rax, %rax
je 0x47dc
movq %rax, %r15
movl $0x40, %edi
callq 0x21a0
testq %rax, %rax
je 0x47d4
movq %rax, %r12
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
jne 0x4779
leaq 0x10(%rbx), %r13
leaq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x20e0
testl %eax, %eax
je 0x47cc
movq (%r13), %rax
movq %r12, %rcx
addq $0x40, %rcx
leaq 0x60(%rax), %rdx
movq %rdx, 0x10(%rbx)
movq $0x2, (%rax)
movq %r15, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %r12, 0x20(%rax)
movl %ebp, 0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x2c(%rax)
movups %xmm0, 0x3c(%rax)
movups %xmm0, 0x4c(%rax)
movl $0x0, 0x5c(%rax)
movq 0x10(%rbx), %rax
subq (%rbx), %rax
shrq $0x5, %rax
imull $0xaaaaaaab, %eax, %r14d # imm = 0xAAAAAAAB
jmp 0x47dc
movq %r12, %rdi
callq 0x2040
movq %r15, %rdi
callq 0x2040
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x140f9(%rip), %rdi     # 0x188ee
leaq 0x1283d(%rip), %rsi     # 0x17039
leaq 0x13283(%rip), %rcx     # 0x17a86
movl $0x4eb, %edx            # imm = 0x4EB
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_document_add_mapping
YAML_DECLARE(int)
yaml_document_add_mapping(yaml_document_t *document,
        yaml_char_t *tag, yaml_mapping_style_t style)
{
    struct {
        yaml_error_type_t error;
    } context;
    yaml_mark_t mark = { 0, 0, 0 };
    yaml_char_t *tag_copy = NULL;
    struct {
        yaml_node_pair_t *start;
        yaml_node_pair_t *end;
        yaml_node_pair_t *top;
    } pairs = { NULL, NULL, NULL };
    yaml_node_t node;

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

    if (!tag) {
        tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG;
    }

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

    if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error;

    MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
            style, mark, mark);
    if (!PUSH(&context, document->nodes, node)) goto error;

    return document->nodes.top - document->nodes.start;

error:
    STACK_DEL(&context, pairs);
    yaml_free(tag_copy);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4916
movl %edx, %ebp
movq %rdi, %rbx
testq %rsi, %rsi
leaq 0x1331a(%rip), %r15     # 0x17b4a
cmovneq %rsi, %r15
movq %r15, %rdi
callq 0x20d0
movq %r15, %rdi
movq %rax, %rsi
callq 0x398c
xorl %r14d, %r14d
testl %eax, %eax
je 0x4904
movq %r15, %rdi
callq 0x2220
testq %rax, %rax
je 0x4904
movq %rax, %r15
movl $0x80, %edi
callq 0x21a0
testq %rax, %rax
je 0x48fc
movq %rax, %r12
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
jne 0x48a1
leaq 0x10(%rbx), %r13
leaq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x20e0
testl %eax, %eax
je 0x48f4
movq (%r13), %rax
movq %r12, %rcx
subq $-0x80, %rcx
leaq 0x60(%rax), %rdx
movq %rdx, 0x10(%rbx)
movq $0x3, (%rax)
movq %r15, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %r12, 0x20(%rax)
movl %ebp, 0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x2c(%rax)
movups %xmm0, 0x3c(%rax)
movups %xmm0, 0x4c(%rax)
movl $0x0, 0x5c(%rax)
movq 0x10(%rbx), %rax
subq (%rbx), %rax
shrq $0x5, %rax
imull $0xaaaaaaab, %eax, %r14d # imm = 0xAAAAAAAB
jmp 0x4904
movq %r12, %rdi
callq 0x2040
movq %r15, %rdi
callq 0x2040
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13fd1(%rip), %rdi     # 0x188ee
leaq 0x12715(%rip), %rsi     # 0x17039
leaq 0x131c9(%rip), %rcx     # 0x17af4
movl $0x518, %edx            # imm = 0x518
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_document_append_sequence_item
YAML_DECLARE(int)
yaml_document_append_sequence_item(yaml_document_t *document,
        int sequence, int item)
{
    struct {
        yaml_error_type_t error;
    } context;

    assert(document);       /* Non-NULL document is required. */
    assert(sequence > 0
            && document->nodes.start + sequence <= document->nodes.top);
                            /* Valid sequence id is required. */
    assert(document->nodes.start[sequence-1].type == YAML_SEQUENCE_NODE);
                            /* A sequence node is required. */
    assert(item > 0 && document->nodes.start + item <= document->nodes.top);
                            /* Valid item id is required. */

    if (!PUSH(&context,
                document->nodes.start[sequence-1].data.sequence.items, item))
        return 0;

    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x4a00
testl %esi, %esi
jle 0x49e1
movl %edx, %ebx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x10(%rdi), %rcx
movl %esi, %edx
leaq (%rdx,%rdx,2), %rdx
shlq $0x5, %rdx
addq %rax, %rdx
cmpq %rcx, %rdx
ja 0x49e1
decl %esi
leaq (%rsi,%rsi,2), %r15
shlq $0x5, %r15
cmpl $0x2, (%rax,%r15)
jne 0x4a1f
testl %ebx, %ebx
jle 0x4a3e
movl %ebx, %edx
leaq (%rdx,%rdx,2), %rdx
shlq $0x5, %rdx
addq %rax, %rdx
cmpq %rcx, %rdx
ja 0x4a3e
leaq (%rax,%r15), %rdi
movq 0x20(%rdi), %rcx
cmpq 0x18(%rdi), %rcx
jne 0x49c2
leaq 0x20(%rdi), %rsi
leaq 0x18(%rdi), %rdx
addq $0x10, %rdi
callq 0x20e0
testl %eax, %eax
je 0x49dd
movq (%r14), %rax
movq 0x20(%rax,%r15), %rcx
leaq 0x4(%rcx), %rdx
movq %rdx, 0x20(%rax,%r15)
movl %ebx, (%rcx)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x49d7
leaq 0x131bc(%rip), %rdi     # 0x17ba4
leaq 0x1264a(%rip), %rsi     # 0x17039
leaq 0x1316a(%rip), %rcx     # 0x17b60
movl $0x53f, %edx            # imm = 0x53F
callq 0x2100
leaq 0x13ee7(%rip), %rdi     # 0x188ee
leaq 0x1262b(%rip), %rsi     # 0x17039
leaq 0x1314b(%rip), %rcx     # 0x17b60
movl $0x53d, %edx            # imm = 0x53D
callq 0x2100
leaq 0x131c6(%rip), %rdi     # 0x17bec
leaq 0x1260c(%rip), %rsi     # 0x17039
leaq 0x1312c(%rip), %rcx     # 0x17b60
movl $0x541, %edx            # imm = 0x541
callq 0x2100
leaq 0x131e4(%rip), %rdi     # 0x17c29
leaq 0x125ed(%rip), %rsi     # 0x17039
leaq 0x1310d(%rip), %rcx     # 0x17b60
movl $0x543, %edx            # imm = 0x543
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_document_append_mapping_pair
YAML_DECLARE(int)
yaml_document_append_mapping_pair(yaml_document_t *document,
        int mapping, int key, int value)
{
    struct {
        yaml_error_type_t error;
    } context;

    yaml_node_pair_t pair;

    assert(document);       /* Non-NULL document is required. */
    assert(mapping > 0
            && document->nodes.start + mapping <= document->nodes.top);
                            /* Valid mapping id is required. */
    assert(document->nodes.start[mapping-1].type == YAML_MAPPING_NODE);
                            /* A mapping node is required. */
    assert(key > 0 && document->nodes.start + key <= document->nodes.top);
                            /* Valid key id is required. */
    assert(value > 0 && document->nodes.start + value <= document->nodes.top);
                            /* Valid value id is required. */

    pair.key = key;
    pair.value = value;

    if (!PUSH(&context,
                document->nodes.start[mapping-1].data.mapping.pairs, pair))
        return 0;

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4b56
testl %esi, %esi
jle 0x4b37
movl %ecx, %ebx
movl %edx, %ebp
movq %rdi, %r14
movq (%rdi), %rax
movq 0x10(%rdi), %rcx
movl %esi, %edx
leaq (%rdx,%rdx,2), %rdx
shlq $0x5, %rdx
addq %rax, %rdx
cmpq %rcx, %rdx
ja 0x4b37
decl %esi
leaq (%rsi,%rsi,2), %r15
shlq $0x5, %r15
cmpl $0x3, (%rax,%r15)
jne 0x4b75
testl %ebp, %ebp
jle 0x4b94
movl %ebp, %edx
leaq (%rdx,%rdx,2), %rdx
shlq $0x5, %rdx
addq %rax, %rdx
cmpq %rcx, %rdx
ja 0x4b94
testl %ebx, %ebx
jle 0x4bb3
movl %ebx, %edx
leaq (%rdx,%rdx,2), %rdx
shlq $0x5, %rdx
addq %rax, %rdx
cmpq %rcx, %rdx
ja 0x4bb3
leaq (%rax,%r15), %rdi
movq 0x20(%rdi), %rcx
cmpq 0x18(%rdi), %rcx
jne 0x4b10
leaq 0x20(%rdi), %rsi
leaq 0x18(%rdi), %rdx
addq $0x10, %rdi
callq 0x20e0
testl %eax, %eax
je 0x4b33
movq (%r14), %rax
movq 0x20(%rax,%r15), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x20(%rax,%r15)
movl %ebp, (%rcx)
movl %ebx, 0x4(%rcx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x4b28
leaq 0x13173(%rip), %rdi     # 0x17cb1
leaq 0x124f4(%rip), %rsi     # 0x17039
leaq 0x1311d(%rip), %rcx     # 0x17c69
movl $0x55d, %edx            # imm = 0x55D
callq 0x2100
leaq 0x13d91(%rip), %rdi     # 0x188ee
leaq 0x124d5(%rip), %rsi     # 0x17039
leaq 0x130fe(%rip), %rcx     # 0x17c69
movl $0x55b, %edx            # imm = 0x55B
callq 0x2100
leaq 0x1317b(%rip), %rdi     # 0x17cf7
leaq 0x124b6(%rip), %rsi     # 0x17039
leaq 0x130df(%rip), %rcx     # 0x17c69
movl $0x55f, %edx            # imm = 0x55F
callq 0x2100
leaq 0x13197(%rip), %rdi     # 0x17d32
leaq 0x12497(%rip), %rsi     # 0x17039
leaq 0x130c0(%rip), %rcx     # 0x17c69
movl $0x561, %edx            # imm = 0x561
callq 0x2100
leaq 0x131b6(%rip), %rdi     # 0x17d70
leaq 0x12478(%rip), %rsi     # 0x17039
leaq 0x130a1(%rip), %rcx     # 0x17c69
movl $0x563, %edx            # imm = 0x563
callq 0x2100
nop