LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/parser.c
// Function: yaml_parser_parse_stream_start
static int
yaml_parser_parse_stream_start(yaml_parser_t *parser, yaml_event_t *event)
{
    yaml_token_t *token;

    token = PEEK_TOKEN(parser);
    if (!token) return 0;

    if (token->type != YAML_STREAM_START_TOKEN) {
        return yaml_parser_set_parser_error(parser,
                "did not find expected <stream-start>", token->start_mark);
    }

    parser->state = YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE;
    STREAM_START_EVENT_INIT(*event, token->data.stream_start.encoding,
            token->start_mark, token->start_mark);
    SKIP_TOKEN(parser);

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x130(%rax)
jne 0x18d6b
movq -0x10(%rbp), %rdi
callq 0x21c0
cmpl $0x0, %eax
je 0x18d7c
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x18d84
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x18d84
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x18d9f
movl $0x0, -0x4(%rbp)
jmp 0x18eb8
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
je 0x18de1
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
addq $0x20, %rax
leaq 0x13aa9(%rip), %rsi     # 0x2c864
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x1cb50
movl %eax, -0x4(%rbp)
jmp 0x18eb8
movq -0x10(%rbp), %rax
movl $0x1, 0x188(%rax)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0x2120
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rdx
movq %rdx, 0x38(%rax)
movq 0x28(%rcx), %rdx
movq %rdx, 0x40(%rax)
movq 0x30(%rcx), %rcx
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rax)
movq 0x28(%rcx), %rdx
movq %rdx, 0x58(%rax)
movq 0x30(%rcx), %rcx
movq %rcx, 0x60(%rax)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x130(%rax)
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x128(%rax)
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rax
cmpl $0x2, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xfc(%rax)
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rcx
addq $0x50, %rcx
movq %rcx, 0x118(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/parser.c
// Function: yaml_parser_parse_document_content
static int
yaml_parser_parse_document_content(yaml_parser_t *parser, yaml_event_t *event)
{
    yaml_token_t *token;

    token = PEEK_TOKEN(parser);
    if (!token) return 0;

    if (token->type == YAML_VERSION_DIRECTIVE_TOKEN ||
            token->type == YAML_TAG_DIRECTIVE_TOKEN ||
            token->type == YAML_DOCUMENT_START_TOKEN ||
            token->type == YAML_DOCUMENT_END_TOKEN ||
            token->type == YAML_STREAM_END_TOKEN) {
        parser->state = POP(parser, parser->states);
        return yaml_parser_process_empty_scalar(parser, event,
                token->start_mark);
    }
    else {
        return yaml_parser_parse_node(parser, event, 1, 0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x130(%rax)
jne 0x1958b
movq -0x10(%rbp), %rdi
callq 0x21c0
cmpl $0x0, %eax
je 0x1959c
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x195a4
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x195a4
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x195bf
movl $0x0, -0x4(%rbp)
jmp 0x1965c
movq -0x20(%rbp), %rax
cmpl $0x3, (%rax)
je 0x195ec
movq -0x20(%rbp), %rax
cmpl $0x4, (%rax)
je 0x195ec
movq -0x20(%rbp), %rax
cmpl $0x5, (%rax)
je 0x195ec
movq -0x20(%rbp), %rax
cmpl $0x6, (%rax)
je 0x195ec
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x19645
movq -0x10(%rbp), %rcx
movq 0x180(%rcx), %rax
movq %rax, %rdx
addq $-0x4, %rdx
movq %rdx, 0x180(%rcx)
movl -0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x188(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x1d2d0
movl %eax, -0x4(%rbp)
jmp 0x1965c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x19870
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/parser.c
// Function: yaml_parser_parse_flow_sequence_entry_mapping_end
static int
yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser,
        yaml_event_t *event)
{
    yaml_token_t *token;

    token = PEEK_TOKEN(parser);
    if (!token) return 0;

    parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE;

    MAPPING_END_EVENT_INIT(*event, token->start_mark, token->start_mark);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x130(%rax)
jne 0x1c19b
movq -0x10(%rbp), %rdi
callq 0x21c0
cmpl $0x0, %eax
je 0x1c1ac
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1c1b4
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x1c1b4
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1c1cc
movl $0x0, -0x4(%rbp)
jmp 0x1c23b
movq -0x10(%rbp), %rax
movl $0xf, 0x188(%rax)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0x2120
movq -0x18(%rbp), %rax
movl $0xa, (%rax)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rdx
movq %rdx, 0x38(%rax)
movq 0x28(%rcx), %rdx
movq %rdx, 0x40(%rax)
movq 0x30(%rcx), %rcx
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rax)
movq 0x28(%rcx), %rdx
movq %rdx, 0x58(%rax)
movq 0x30(%rcx), %rcx
movq %rcx, 0x60(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/parser.c
// Function: yaml_parser_set_parser_error
static int
yaml_parser_set_parser_error(yaml_parser_t *parser,
        const char *problem, yaml_mark_t problem_mark)
{
    parser->error = YAML_PARSER_ERROR;
    parser->problem = problem;
    parser->problem_mark = problem_mark;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rcx
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x4, (%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq %rdx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x28(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x30(%rax)
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/parser.c
// Function: yaml_parser_process_empty_scalar
static int
yaml_parser_process_empty_scalar(yaml_parser_t *parser, yaml_event_t *event,
        yaml_mark_t mark)
{
    yaml_char_t *value;

    value = yaml_malloc(1);
    if (!value) {
        parser->error = YAML_MEMORY_ERROR;
        return 0;
    }
    value[0] = '\0';

    SCALAR_EVENT_INIT(*event, NULL, NULL, value, 0,
            1, 0, YAML_PLAIN_SCALAR_STYLE, mark, mark);

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
callq 0x2080
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1d313
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1d3c6
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0x2120
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movl $0x6, (%rax)
movq -0x18(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x38(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x40(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x48(%rax)
movq -0x18(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x50(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x58(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x28(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x30(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/parser.c
// Function: yaml_parser_set_parser_error_context
static int
yaml_parser_set_parser_error_context(yaml_parser_t *parser,
        const char *context, yaml_mark_t context_mark,
        const char *problem, yaml_mark_t problem_mark)
{
    parser->error = YAML_PARSER_ERROR;
    parser->context = context;
    parser->context_mark = context_mark;
    parser->problem = problem;
    parser->problem_mark = problem_mark;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdx, %rax
leaq 0x28(%rbp), %rcx
leaq 0x10(%rbp), %rdx
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x4, (%rax)
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rsi, 0x38(%rax)
movq -0x8(%rbp), %rax
movq (%rdx), %rsi
movq %rsi, 0x40(%rax)
movq 0x8(%rdx), %rsi
movq %rsi, 0x48(%rax)
movq 0x10(%rdx), %rdx
movq %rdx, 0x50(%rax)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq %rdx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x28(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x30(%rax)
xorl %eax, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/loader.c
// Function: yaml_parser_load_document
static int
yaml_parser_load_document(yaml_parser_t *parser, yaml_event_t *first_event)
{
    yaml_event_t event;

    assert(first_event->type == YAML_DOCUMENT_START_EVENT);
                        /* DOCUMENT-START is expected. */

    parser->document->version_directive
        = first_event->data.document_start.version_directive;
    parser->document->tag_directives.start
        = first_event->data.document_start.tag_directives.start;
    parser->document->tag_directives.end
        = first_event->data.document_start.tag_directives.end;
    parser->document->start_implicit
        = first_event->data.document_start.implicit;
    parser->document->start_mark = first_event->start_mark;

    if (!yaml_parser_parse(parser, &event)) return 0;

    if (!yaml_parser_load_node(parser, &event)) return 0;

    if (!yaml_parser_parse(parser, &event)) return 0;
    assert(event.type == YAML_DOCUMENT_END_EVENT);
                        /* DOCUMENT-END is expected. */

    parser->document->end_implicit = event.data.document_end.implicit;
    parser->document->end_mark = event.end_mark;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x1d6ae
jmp 0x1d6cd
leaq 0xf46f(%rip), %rdi      # 0x2cb24
leaq 0xf400(%rip), %rsi      # 0x2cabc
movl $0xa9, %edx
leaq 0xf48b(%rip), %rcx      # 0x2cb53
callq 0x2100
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x1d8(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x1d8(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x1d8(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x1d8(%rax), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x1d8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x38(%rcx), %rdx
movq %rdx, 0x38(%rax)
movq 0x40(%rcx), %rdx
movq %rdx, 0x40(%rax)
movq 0x48(%rcx), %rcx
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2030
cmpl $0x0, %eax
jne 0x1d76c
movl $0x0, -0x4(%rbp)
jmp 0x1d804
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1d8b0
cmpl $0x0, %eax
jne 0x1d787
movl $0x0, -0x4(%rbp)
jmp 0x1d804
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2030
cmpl $0x0, %eax
jne 0x1d7a2
movl $0x0, -0x4(%rbp)
jmp 0x1d804
cmpl $0x4, -0x80(%rbp)
jne 0x1d7aa
jmp 0x1d7c9
leaq 0xf3e1(%rip), %rdi      # 0x2cb92
leaq 0xf304(%rip), %rsi      # 0x2cabc
movl $0xbb, %edx
leaq 0xf38f(%rip), %rcx      # 0x2cb53
callq 0x2100
movl -0x78(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x1d8(%rax), %rax
movl %ecx, 0x34(%rax)
movq -0x10(%rbp), %rax
movq 0x1d8(%rax), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x50(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x60(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/loader.c
// Function: yaml_parser_load_node
static int
yaml_parser_load_node(yaml_parser_t *parser, yaml_event_t *first_event)
{
    switch (first_event->type) {
        case YAML_ALIAS_EVENT:
            return yaml_parser_load_alias(parser, first_event);
        case YAML_SCALAR_EVENT:
            return yaml_parser_load_scalar(parser, first_event);
        case YAML_SEQUENCE_START_EVENT:
            return yaml_parser_load_sequence(parser, first_event);
        case YAML_MAPPING_START_EVENT:
            return yaml_parser_load_mapping(parser, first_event);
        default:
            assert(0);  /* Could not happen. */
            return 0;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl $-0x5, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x4, %eax
ja 0x1d930
movq -0x20(%rbp), %rax
leaq 0xf1c9(%rip), %rcx      # 0x2caa8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d960
movl %eax, -0x4(%rbp)
jmp 0x1d94f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1da20
movl %eax, -0x4(%rbp)
jmp 0x1d94f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1dc90
movl %eax, -0x4(%rbp)
jmp 0x1d94f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e1e0
movl %eax, -0x4(%rbp)
jmp 0x1d94f
leaq 0xecfd(%rip), %rdi      # 0x2c634
leaq 0xf17e(%rip), %rsi      # 0x2cabc
movl $0xd5, %edx
leaq 0xf26e(%rip), %rcx      # 0x2cbb8
callq 0x2100
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/loader.c
// Function: yaml_parser_load_alias
static int
yaml_parser_load_alias(yaml_parser_t *parser, yaml_event_t *first_event)
{
    yaml_char_t *anchor = first_event->data.alias.anchor;
    yaml_alias_data_t *alias_data;

    for (alias_data = parser->aliases.start;
            alias_data != parser->aliases.top; alias_data ++) {
        if (strcmp((char *)alias_data->anchor, (char *)anchor) == 0) {
            yaml_free(anchor);
            return alias_data->index;
        }
    }

    yaml_free(anchor);
    return yaml_parser_set_composer_error(parser, "found undefined alias",
            first_event->start_mark);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x1c0(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x1d0(%rcx), %rax
je 0x1d9d6
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x2160
cmpl $0x0, %eax
jne 0x1d9c6
movq -0x20(%rbp), %rdi
callq 0x2140
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1da13
jmp 0x1d9c8
movq -0x28(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x28(%rbp)
jmp 0x1d98b
movq -0x20(%rbp), %rdi
callq 0x2140
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
addq $0x38, %rax
leaq 0xf201(%rip), %rsi      # 0x2cbf3
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x1e780
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_emit
YAML_DECLARE(int)
yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event)
{
    if (!ENQUEUE(emitter, emitter->events, *event)) {
        yaml_event_delete(event);
        return 0;
    }

    while (!yaml_emitter_need_more_events(emitter)) {
        if (!yaml_emitter_analyze_event(emitter, emitter->events.head))
            return 0;
        if (!yaml_emitter_state_machine(emitter, emitter->events.head))
            return 0;
        yaml_event_delete(&DEQUEUE(emitter, emitter->events));
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0xb8(%rcx), %rax
jne 0x1ef4a
movq -0x10(%rbp), %rdi
addq $0xb0, %rdi
movq -0x10(%rbp), %rsi
addq $0xb0, %rsi
addq $0x10, %rsi
movq -0x10(%rbp), %rdx
addq $0xb0, %rdx
addq $0x18, %rdx
movq -0x10(%rbp), %rcx
addq $0xb0, %rcx
addq $0x8, %rcx
callq 0x2170
cmpl $0x0, %eax
je 0x1ef79
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rdi
movq %rdi, %rcx
addq $0x68, %rcx
movq %rcx, 0xc8(%rax)
movq -0x18(%rbp), %rsi
movl $0x68, %edx
callq 0x2180
movb $0x1, %al
testb $0x1, %al
jne 0x1ef9e
jmp 0x1ef89
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0x1ef9e
movq -0x18(%rbp), %rdi
callq 0x21f0
movl $0x0, -0x4(%rbp)
jmp 0x1f022
jmp 0x1efa0
movq -0x10(%rbp), %rdi
callq 0x1f030
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1efb7
jmp 0x1f01b
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rsi
callq 0x1f1c0
cmpl $0x0, %eax
jne 0x1efd9
movl $0x0, -0x4(%rbp)
jmp 0x1f022
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rsi
callq 0x1f460
cmpl $0x0, %eax
jne 0x1effb
movl $0x0, -0x4(%rbp)
jmp 0x1f022
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rdi
movq %rdi, %rcx
addq $0x68, %rcx
movq %rcx, 0xc0(%rax)
callq 0x21f0
jmp 0x1efa0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_emit_stream_start
static int
yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
        yaml_event_t *event)
{
    if (event->type == YAML_STREAM_START_EVENT)
    {
        if (!emitter->encoding) {
            emitter->encoding = event->data.stream_start.encoding;
        }

        if (!emitter->encoding) {
            emitter->encoding = YAML_UTF8_ENCODING;
        }

        if (emitter->best_indent < 2 || emitter->best_indent > 9) {
            emitter->best_indent  = 2;
        }

        if (emitter->best_width >= 0
                && emitter->best_width <= emitter->best_indent*2) {
            emitter->best_width = 80;
        }

        if (emitter->best_width < 0) {
            emitter->best_width = INT_MAX;
        }
        
        if (!emitter->line_break) {
            emitter->line_break = YAML_LN_BREAK;
        }

        emitter->indent = -1;

        emitter->line = 0;
        emitter->column = 0;
        emitter->whitespace = 1;
        emitter->indention = 1;

        if (emitter->encoding != YAML_UTF8_ENCODING) {
            if (!yaml_emitter_write_bom(emitter))
                return 0;
        }

        emitter->state = YAML_EMIT_FIRST_DOCUMENT_START_STATE;

        return 1;
    }

    return yaml_emitter_set_emitter_error(emitter,
            "expected STREAM-START");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x1f7ad
movq -0x10(%rbp), %rax
cmpl $0x0, 0x78(%rax)
jne 0x1f685
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x78(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x78(%rax)
jne 0x1f69a
movq -0x10(%rbp), %rax
movl $0x1, 0x78(%rax)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x80(%rax)
jl 0x1f6b4
movq -0x10(%rbp), %rax
cmpl $0x9, 0x80(%rax)
jle 0x1f6c2
movq -0x10(%rbp), %rax
movl $0x2, 0x80(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x84(%rax)
jl 0x1f6f7
movq -0x10(%rbp), %rax
movl 0x84(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x80(%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
jg 0x1f6f7
movq -0x10(%rbp), %rax
movl $0x50, 0x84(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x84(%rax)
jge 0x1f712
movq -0x10(%rbp), %rax
movl $0x7fffffff, 0x84(%rax) # imm = 0x7FFFFFFF
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8c(%rax)
jne 0x1f72d
movq -0x10(%rbp), %rax
movl $0x2, 0x8c(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x100(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl $0x0, 0x118(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x11c(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x120(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x124(%rax)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x78(%rax)
je 0x1f796
movq -0x10(%rbp), %rdi
callq 0x20bc0
cmpl $0x0, %eax
jne 0x1f794
movl $0x0, -0x4(%rbp)
jmp 0x1f7c0
jmp 0x1f796
movq -0x10(%rbp), %rax
movl $0x1, 0xa8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x1f7c0
movq -0x10(%rbp), %rdi
leaq 0xd582(%rip), %rsi      # 0x2cd3a
callq 0x20b90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_emit_document_end
static int
yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
        yaml_event_t *event)
{
    if (event->type == YAML_DOCUMENT_END_EVENT)
    {
        if (!yaml_emitter_write_indent(emitter))
            return 0;
        if (!event->data.document_end.implicit) {
            if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0))
                return 0;
            if (!yaml_emitter_write_indent(emitter))
                return 0;
        }
        if (!yaml_emitter_flush(emitter))
            return 0;

        emitter->state = YAML_EMIT_DOCUMENT_START_STATE;

        while (!STACK_EMPTY(emitter, emitter->tag_directives)) {
            yaml_tag_directive_t tag_directive = POP(emitter,
                    emitter->tag_directives);
            yaml_free(tag_directive.handle);
            yaml_free(tag_directive.prefix);
        }

        return 1;
    }

    return yaml_emitter_set_emitter_error(emitter,
            "expected DOCUMENT-END");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x1fe68
movq -0x10(%rbp), %rdi
callq 0x213e0
cmpl $0x0, %eax
jne 0x1fd87
movl $0x0, -0x4(%rbp)
jmp 0x1fe7b
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x1fdd9
movq -0x10(%rbp), %rdi
leaq 0xcfb4(%rip), %rsi      # 0x2cd50
movl $0x1, %edx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x21060
cmpl $0x0, %eax
jne 0x1fdbd
movl $0x0, -0x4(%rbp)
jmp 0x1fe7b
movq -0x10(%rbp), %rdi
callq 0x213e0
cmpl $0x0, %eax
jne 0x1fdd7
movl $0x0, -0x4(%rbp)
jmp 0x1fe7b
jmp 0x1fdd9
movq -0x10(%rbp), %rdi
callq 0x21a0
cmpl $0x0, %eax
jne 0x1fdf3
movl $0x0, -0x4(%rbp)
jmp 0x1fe7b
movq -0x10(%rbp), %rax
movl $0x2, 0xa8(%rax)
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0xf8(%rcx), %rax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1fe22
jmp 0x1fe5f
movq -0x10(%rbp), %rcx
movq 0xf8(%rcx), %rax
movq %rax, %rdx
addq $-0x10, %rdx
movq %rdx, 0xf8(%rcx)
movq -0x10(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq -0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2140
movq -0x20(%rbp), %rdi
callq 0x2140
jmp 0x1fe01
movl $0x1, -0x4(%rbp)
jmp 0x1fe7b
movq -0x10(%rbp), %rdi
leaq 0xd057(%rip), %rsi      # 0x2ceca
callq 0x20b90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_emit_flow_mapping_value
static int
yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter,
        yaml_event_t *event, int simple)
{
    if (simple) {
        if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0))
            return 0;
    }
    else {
        if (emitter->canonical || emitter->column > emitter->best_width) {
            if (!yaml_emitter_write_indent(emitter))
                return 0;
        }
        if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 0))
            return 0;
    }
    if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_MAPPING_KEY_STATE))
        return 0;
    return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x204f5
movq -0x10(%rbp), %rdi
leaq 0xc3f0(%rip), %rsi      # 0x2c8c4
xorl %r8d, %r8d
movl %r8d, %edx
movl %r8d, %ecx
callq 0x21060
cmpl $0x0, %eax
jne 0x204f3
movl $0x0, -0x4(%rbp)
jmp 0x20609
jmp 0x2055f
movq -0x10(%rbp), %rax
cmpl $0x0, 0x7c(%rax)
jne 0x20515
movq -0x10(%rbp), %rax
movl 0x11c(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x84(%rcx), %eax
jle 0x20531
movq -0x10(%rbp), %rdi
callq 0x213e0
cmpl $0x0, %eax
jne 0x2052f
movl $0x0, -0x4(%rbp)
jmp 0x20609
jmp 0x20531
movq -0x10(%rbp), %rdi
leaq 0xc388(%rip), %rsi      # 0x2c8c4
movl $0x1, %edx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x21060
cmpl $0x0, %eax
jne 0x2055d
movl $0x0, -0x4(%rbp)
jmp 0x20609
jmp 0x2055f
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x98(%rcx), %rax
jne 0x205aa
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
movq -0x10(%rbp), %rsi
addq $0x90, %rsi
addq $0x10, %rsi
movq -0x10(%rbp), %rdx
addq $0x90, %rdx
addq $0x8, %rdx
callq 0x20e0
cmpl $0x0, %eax
je 0x205d1
movq -0x10(%rbp), %rcx
movq 0xa0(%rcx), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0xa0(%rcx)
movl $0x8, (%rax)
movb $0x1, %al
testb $0x1, %al
jne 0x205ea
jmp 0x205e1
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0x205ea
movl $0x0, -0x4(%rbp)
jmp 0x20609
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %r9d, %r9d
movl $0x1, %r8d
movl %r9d, %edx
movl %r9d, %ecx
callq 0x22010
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_emit_block_sequence_item
static int
yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter,
        yaml_event_t *event, int first)
{
    if (first)
    {
        if (!yaml_emitter_increase_indent(emitter, 0,
                    (emitter->mapping_context && !emitter->indention)))
            return 0;
    }

    if (event->type == YAML_SEQUENCE_END_EVENT)
    {
        emitter->indent = POP(emitter, emitter->indents);
        emitter->state = POP(emitter, emitter->states);

        return 1;
    }

    if (!yaml_emitter_write_indent(emitter))
        return 0;
    if (!yaml_emitter_write_indicator(emitter, "-", 1, 0, 1))
        return 0;
    if (!PUSH(emitter, emitter->states,
                YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE))
        return 0;

    return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x2068c
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x110(%rcx)
movb %al, -0x1d(%rbp)
je 0x20666
movq -0x10(%rbp), %rax
cmpl $0x0, 0x124(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x1d(%rbp)
movq -0x28(%rbp), %rdi
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
xorl %esi, %esi
callq 0x22a30
cmpl $0x0, %eax
jne 0x2068a
movl $0x0, -0x4(%rbp)
jmp 0x207dc
jmp 0x2068c
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
jne 0x206ed
movq -0x10(%rbp), %rcx
movq 0xe0(%rcx), %rax
movq %rax, %rdx
addq $-0x4, %rdx
movq %rdx, 0xe0(%rcx)
movl -0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x100(%rax)
movq -0x10(%rbp), %rcx
movq 0xa0(%rcx), %rax
movq %rax, %rdx
addq $-0x4, %rdx
movq %rdx, 0xa0(%rcx)
movl -0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xa8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x207dc
movq -0x10(%rbp), %rdi
callq 0x213e0
cmpl $0x0, %eax
jne 0x20707
movl $0x0, -0x4(%rbp)
jmp 0x207dc
movq -0x10(%rbp), %rdi
leaq 0xc653(%rip), %rsi      # 0x2cd65
movl $0x1, %r8d
xorl %ecx, %ecx
movl %r8d, %edx
callq 0x21060
cmpl $0x0, %eax
jne 0x20733
movl $0x0, -0x4(%rbp)
jmp 0x207dc
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x98(%rcx), %rax
jne 0x2077e
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
movq -0x10(%rbp), %rsi
addq $0x90, %rsi
addq $0x10, %rsi
movq -0x10(%rbp), %rdx
addq $0x90, %rdx
addq $0x8, %rdx
callq 0x20e0
cmpl $0x0, %eax
je 0x207a5
movq -0x10(%rbp), %rcx
movq 0xa0(%rcx), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0xa0(%rcx)
movl $0xc, (%rax)
movb $0x1, %al
testb $0x1, %al
jne 0x207be
jmp 0x207b5
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0x207be
movl $0x0, -0x4(%rbp)
jmp 0x207dc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %r9d, %r9d
movl $0x1, %ecx
movl %r9d, %edx
movl %r9d, %r8d
callq 0x22010
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_emit_block_mapping_value
static int
yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter,
        yaml_event_t *event, int simple)
{
    if (simple) {
        if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0))
            return 0;
    }
    else {
        if (!yaml_emitter_write_indent(emitter))
            return 0;
        if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 1))
            return 0;
    }
    if (!PUSH(emitter, emitter->states,
                YAML_EMIT_BLOCK_MAPPING_KEY_STATE))
        return 0;

    return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x20a95
movq -0x10(%rbp), %rdi
leaq 0xbe50(%rip), %rsi      # 0x2c8c4
xorl %r8d, %r8d
movl %r8d, %edx
movl %r8d, %ecx
callq 0x21060
cmpl $0x0, %eax
jne 0x20a93
movl $0x0, -0x4(%rbp)
jmp 0x20b87
jmp 0x20add
movq -0x10(%rbp), %rdi
callq 0x213e0
cmpl $0x0, %eax
jne 0x20aaf
movl $0x0, -0x4(%rbp)
jmp 0x20b87
movq -0x10(%rbp), %rdi
leaq 0xbe0a(%rip), %rsi      # 0x2c8c4
movl $0x1, %r8d
xorl %ecx, %ecx
movl %r8d, %edx
callq 0x21060
cmpl $0x0, %eax
jne 0x20adb
movl $0x0, -0x4(%rbp)
jmp 0x20b87
jmp 0x20add
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x98(%rcx), %rax
jne 0x20b28
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
movq -0x10(%rbp), %rsi
addq $0x90, %rsi
addq $0x10, %rsi
movq -0x10(%rbp), %rdx
addq $0x90, %rdx
addq $0x8, %rdx
callq 0x20e0
cmpl $0x0, %eax
je 0x20b4f
movq -0x10(%rbp), %rcx
movq 0xa0(%rcx), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0xa0(%rcx)
movl $0xe, (%rax)
movb $0x1, %al
testb $0x1, %al
jne 0x20b68
jmp 0x20b5f
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0x20b68
movl $0x0, -0x4(%rbp)
jmp 0x20b87
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %r9d, %r9d
movl $0x1, %r8d
movl %r9d, %edx
movl %r9d, %ecx
callq 0x22010
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_write_bom
static int
yaml_emitter_write_bom(yaml_emitter_t *emitter)
{
    if (!FLUSH(emitter)) return 0;

    *(emitter->buffer.pointer++) = (yaml_char_t) '\xEF';
    *(emitter->buffer.pointer++) = (yaml_char_t) '\xBB';
    *(emitter->buffer.pointer++) = (yaml_char_t) '\xBF';

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
addq $0x5, %rax
movq -0x10(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jb 0x20bf9
movq -0x10(%rbp), %rdi
callq 0x21a0
cmpl $0x0, %eax
jne 0x20bf9
movl $0x0, -0x4(%rbp)
jmp 0x20c42
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x48(%rcx)
movb $-0x11, (%rax)
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x48(%rcx)
movb $-0x45, (%rax)
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x48(%rcx)
movb $-0x41, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_append_tag_directive
static int
yaml_emitter_append_tag_directive(yaml_emitter_t *emitter,
        yaml_tag_directive_t value, int allow_duplicates)
{
    yaml_tag_directive_t *tag_directive;
    yaml_tag_directive_t copy = { NULL, NULL };

    for (tag_directive = emitter->tag_directives.start;
            tag_directive != emitter->tag_directives.top; tag_directive ++) {
        if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) {
            if (allow_duplicates)
                return 1;
            return yaml_emitter_set_emitter_error(emitter,
                    "duplicate %TAG directive");
        }
    }

    copy.handle = yaml_strdup(value.handle);
    copy.prefix = yaml_strdup(value.prefix);
    if (!copy.handle || !copy.prefix) {
        emitter->error = YAML_MEMORY_ERROR;
        goto error;
    }

    if (!PUSH(emitter, emitter->tag_directives, copy))
        goto error;

    return 1;

error:
    yaml_free(copy.handle);
    yaml_free(copy.prefix);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2120
movq -0x20(%rbp), %rax
movq 0xe8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0xf8(%rcx), %rax
je 0x20f66
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
callq 0x2160
cmpl $0x0, %eax
jne 0x20f56
cmpl $0x0, -0x24(%rbp)
je 0x20f3e
movl $0x1, -0x4(%rbp)
jmp 0x2104c
movq -0x20(%rbp), %rdi
leaq 0xb9c4(%rip), %rsi      # 0x2c90d
callq 0x20b90
movl %eax, -0x4(%rbp)
jmp 0x2104c
jmp 0x20f58
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
jmp 0x20f06
movq -0x18(%rbp), %rdi
callq 0x20c0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20c0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x20f8e
cmpq $0x0, -0x38(%rbp)
jne 0x20f9d
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
jmp 0x21033
movq -0x20(%rbp), %rax
movq 0xf8(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0xf0(%rcx), %rax
jne 0x20fe8
movq -0x20(%rbp), %rdi
addq $0xe8, %rdi
movq -0x20(%rbp), %rsi
addq $0xe8, %rsi
addq $0x10, %rsi
movq -0x20(%rbp), %rdx
addq $0xe8, %rdx
addq $0x8, %rdx
callq 0x20e0
cmpl $0x0, %eax
je 0x21018
movq -0x20(%rbp), %rcx
movq 0xf8(%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, 0xf8(%rcx)
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, %al
testb $0x1, %al
jne 0x2102a
jmp 0x21028
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0x2102a
jmp 0x21033
movl $0x1, -0x4(%rbp)
jmp 0x2104c
movq -0x40(%rbp), %rdi
callq 0x2140
movq -0x38(%rbp), %rdi
callq 0x2140
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_emit_node
static int
yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event,
        int root, int sequence, int mapping, int simple_key)
{
    emitter->root_context = root;
    emitter->sequence_context = sequence;
    emitter->mapping_context = mapping;
    emitter->simple_key_context = simple_key;

    switch (event->type)
    {
        case YAML_ALIAS_EVENT:
            return yaml_emitter_emit_alias(emitter, event);

        case YAML_SCALAR_EVENT:
            return yaml_emitter_emit_scalar(emitter, event);

        case YAML_SEQUENCE_START_EVENT:
            return yaml_emitter_emit_sequence_start(emitter, event);

        case YAML_MAPPING_START_EVENT:
            return yaml_emitter_emit_mapping_start(emitter, event);

        default:
            return yaml_emitter_set_emitter_error(emitter,
                    "expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS");
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x108(%rax)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10c(%rax)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x110(%rax)
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x114(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl $-0x5, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x4, %eax
ja 0x220d2
movq -0x30(%rbp), %rax
leaq 0xac5b(%rip), %rcx      # 0x2ccdc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x220f0
movl %eax, -0x4(%rbp)
jmp 0x220e5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x22150
movl %eax, -0x4(%rbp)
jmp 0x220e5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x22250
movl %eax, -0x4(%rbp)
jmp 0x220e5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x222f0
movl %eax, -0x4(%rbp)
jmp 0x220e5
movq -0x10(%rbp), %rdi
leaq 0xad7a(%rip), %rsi      # 0x2ce57
callq 0x20b90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_emit_alias
static int
yaml_emitter_emit_alias(yaml_emitter_t *emitter, yaml_event_t *event)
{
    if (!yaml_emitter_process_anchor(emitter))
        return 0;
    emitter->state = POP(emitter, emitter->states);

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x22390
cmpl $0x0, %eax
jne 0x22117
movl $0x0, -0x4(%rbp)
jmp 0x22144
movq -0x10(%rbp), %rcx
movq 0xa0(%rcx), %rax
movq %rax, %rdx
addq $-0x4, %rdx
movq %rdx, 0xa0(%rcx)
movl -0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xa8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_emit_scalar
static int
yaml_emitter_emit_scalar(yaml_emitter_t *emitter, yaml_event_t *event)
{
    if (!yaml_emitter_select_scalar_style(emitter, event))
        return 0;
    if (!yaml_emitter_process_anchor(emitter))
        return 0;
    if (!yaml_emitter_process_tag(emitter))
        return 0;
    if (!yaml_emitter_increase_indent(emitter, 1, 0))
        return 0;
    if (!yaml_emitter_process_scalar(emitter))
        return 0;
    emitter->indent = POP(emitter, emitter->indents);
    emitter->state = POP(emitter, emitter->states);

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x226e0
cmpl $0x0, %eax
jne 0x2217e
movl $0x0, -0x4(%rbp)
jmp 0x2223a
movq -0x10(%rbp), %rdi
callq 0x22390
cmpl $0x0, %eax
jne 0x22198
movl $0x0, -0x4(%rbp)
jmp 0x2223a
movq -0x10(%rbp), %rdi
callq 0x228e0
cmpl $0x0, %eax
jne 0x221b2
movl $0x0, -0x4(%rbp)
jmp 0x2223a
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x22a30
cmpl $0x0, %eax
jne 0x221d0
movl $0x0, -0x4(%rbp)
jmp 0x2223a
movq -0x10(%rbp), %rdi
callq 0x22b40
cmpl $0x0, %eax
jne 0x221e7
movl $0x0, -0x4(%rbp)
jmp 0x2223a
movq -0x10(%rbp), %rcx
movq 0xe0(%rcx), %rax
movq %rax, %rdx
addq $-0x4, %rdx
movq %rdx, 0xe0(%rcx)
movl -0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x100(%rax)
movq -0x10(%rbp), %rcx
movq 0xa0(%rcx), %rax
movq %rax, %rdx
addq $-0x4, %rdx
movq %rdx, 0xa0(%rcx)
movl -0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xa8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_emit_sequence_start
static int
yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter, yaml_event_t *event)
{
    if (!yaml_emitter_process_anchor(emitter))
        return 0;
    if (!yaml_emitter_process_tag(emitter))
        return 0;

    if (emitter->flow_level || emitter->canonical
            || event->data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE
            || yaml_emitter_check_empty_sequence(emitter)) {
        emitter->state = YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE;
    }
    else {
        emitter->state = YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE;
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x22390
cmpl $0x0, %eax
jne 0x22277
movl $0x0, -0x4(%rbp)
jmp 0x222e2
movq -0x10(%rbp), %rdi
callq 0x228e0
cmpl $0x0, %eax
jne 0x2228e
movl $0x0, -0x4(%rbp)
jmp 0x222e2
movq -0x10(%rbp), %rax
cmpl $0x0, 0x104(%rax)
jne 0x222bd
movq -0x10(%rbp), %rax
cmpl $0x0, 0x7c(%rax)
jne 0x222bd
movq -0x18(%rbp), %rax
cmpl $0x2, 0x1c(%rax)
je 0x222bd
movq -0x10(%rbp), %rdi
callq 0x27490
cmpl $0x0, %eax
je 0x222cd
movq -0x10(%rbp), %rax
movl $0x5, 0xa8(%rax)
jmp 0x222db
movq -0x10(%rbp), %rax
movl $0xb, 0xa8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_emit_mapping_start
static int
yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, yaml_event_t *event)
{
    if (!yaml_emitter_process_anchor(emitter))
        return 0;
    if (!yaml_emitter_process_tag(emitter))
        return 0;

    if (emitter->flow_level || emitter->canonical
            || event->data.mapping_start.style == YAML_FLOW_MAPPING_STYLE
            || yaml_emitter_check_empty_mapping(emitter)) {
        emitter->state = YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE;
    }
    else {
        emitter->state = YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE;
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x22390
cmpl $0x0, %eax
jne 0x22317
movl $0x0, -0x4(%rbp)
jmp 0x22382
movq -0x10(%rbp), %rdi
callq 0x228e0
cmpl $0x0, %eax
jne 0x2232e
movl $0x0, -0x4(%rbp)
jmp 0x22382
movq -0x10(%rbp), %rax
cmpl $0x0, 0x104(%rax)
jne 0x2235d
movq -0x10(%rbp), %rax
cmpl $0x0, 0x7c(%rax)
jne 0x2235d
movq -0x18(%rbp), %rax
cmpl $0x2, 0x1c(%rax)
je 0x2235d
movq -0x10(%rbp), %rdi
callq 0x27510
cmpl $0x0, %eax
je 0x2236d
movq -0x10(%rbp), %rax
movl $0x7, 0xa8(%rax)
jmp 0x2237b
movq -0x10(%rbp), %rax
movl $0xd, 0xa8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_process_anchor
static int
yaml_emitter_process_anchor(yaml_emitter_t *emitter)
{
    if (!emitter->anchor_data.anchor)
        return 1;

    if (!yaml_emitter_write_indicator(emitter,
                (emitter->anchor_data.alias ? "*" : "&"), 1, 0, 0))
        return 0;

    return yaml_emitter_write_anchor(emitter,
            emitter->anchor_data.anchor, emitter->anchor_data.anchor_length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x130(%rax)
jne 0x223b3
movl $0x1, -0x4(%rbp)
jmp 0x22416
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x140(%rax), %ecx
leaq 0xaaca(%rip), %rsi      # 0x2ce92
leaq 0xaac1(%rip), %rax      # 0x2ce90
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movl $0x1, %edx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x21060
cmpl $0x0, %eax
jne 0x223f4
movl $0x0, -0x4(%rbp)
jmp 0x22416
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rdx
callq 0x22420
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_process_tag
static int
yaml_emitter_process_tag(yaml_emitter_t *emitter)
{
    if (!emitter->tag_data.handle && !emitter->tag_data.suffix)
        return 1;

    if (emitter->tag_data.handle)
    {
        if (!yaml_emitter_write_tag_handle(emitter, emitter->tag_data.handle,
                    emitter->tag_data.handle_length))
            return 0;
        if (emitter->tag_data.suffix) {
            if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix,
                        emitter->tag_data.suffix_length, 0))
                return 0;
        }
    }
    else
    {
        if (!yaml_emitter_write_indicator(emitter, "!<", 1, 0, 0))
            return 0;
        if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix,
                    emitter->tag_data.suffix_length, 0))
            return 0;
        if (!yaml_emitter_write_indicator(emitter, ">", 0, 0, 0))
            return 0;
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x148(%rax)
jne 0x22914
movq -0x10(%rbp), %rax
cmpq $0x0, 0x158(%rax)
jne 0x22914
movl $0x1, -0x4(%rbp)
jmp 0x22a21
movq -0x10(%rbp), %rax
cmpq $0x0, 0x148(%rax)
je 0x22999
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x150(%rax), %rdx
callq 0x21600
cmpl $0x0, %eax
jne 0x22952
movl $0x0, -0x4(%rbp)
jmp 0x22a21
movq -0x10(%rbp), %rax
cmpq $0x0, 0x158(%rax)
je 0x22994
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x158(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x160(%rax), %rdx
xorl %ecx, %ecx
callq 0x21930
cmpl $0x0, %eax
jne 0x22992
movl $0x0, -0x4(%rbp)
jmp 0x22a21
jmp 0x22994
jmp 0x22a1a
movq -0x10(%rbp), %rdi
leaq 0xa51d(%rip), %rsi      # 0x2cec1
movl $0x1, %edx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x21060
cmpl $0x0, %eax
jne 0x229c2
movl $0x0, -0x4(%rbp)
jmp 0x22a21
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x158(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x160(%rax), %rdx
xorl %ecx, %ecx
callq 0x21930
cmpl $0x0, %eax
jne 0x229f1
movl $0x0, -0x4(%rbp)
jmp 0x22a21
movq -0x10(%rbp), %rdi
leaq 0x9eb2(%rip), %rsi      # 0x2c8ae
xorl %r8d, %r8d
movl %r8d, %edx
movl %r8d, %ecx
callq 0x21060
cmpl $0x0, %eax
jne 0x22a18
movl $0x0, -0x4(%rbp)
jmp 0x22a21
jmp 0x22a1a
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)