LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/reader.c
// Function: yaml_parser_update_raw_buffer
static int
yaml_parser_update_raw_buffer(yaml_parser_t *parser)
{
    size_t size_read = 0;

    /* Return if the raw buffer is full. */

    if (parser->raw_buffer.start == parser->raw_buffer.pointer
            && parser->raw_buffer.last == parser->raw_buffer.end)
        return 1;

    /* Return on EOF. */

    if (parser->eof) return 1;

    /* Move the remaining bytes in the raw buffer to the beginning. */

    if (parser->raw_buffer.start < parser->raw_buffer.pointer
            && parser->raw_buffer.pointer < parser->raw_buffer.last) {
        memmove(parser->raw_buffer.start, parser->raw_buffer.pointer,
                parser->raw_buffer.last - parser->raw_buffer.pointer);
    }
    parser->raw_buffer.last -=
        parser->raw_buffer.pointer - parser->raw_buffer.start;
    parser->raw_buffer.pointer = parser->raw_buffer.start;

    /* Call the read handler to fill the buffer. */

    if (!parser->read_handler(parser->read_handler_data, parser->raw_buffer.last,
                parser->raw_buffer.end - parser->raw_buffer.last, &size_read)) {
        return yaml_parser_set_reader_error(parser, "input error",
                parser->offset, -1);
    }
    parser->raw_buffer.last += size_read;
    if (!size_read) {
        parser->eof = 1;
    }

    return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, (%rsp)
movq 0xb0(%rdi), %rdi
movq 0xc0(%rbx), %rsi
cmpq %rsi, %rdi
jne 0x5334
movq 0xc8(%rbx), %rax
cmpq 0xb8(%rbx), %rax
je 0x53bf
movl $0x1, %ebp
cmpl $0x0, 0x80(%rbx)
jne 0x53eb
cmpq %rsi, %rdi
jae 0x536d
movq 0xc8(%rbx), %rdx
cmpq %rdx, %rsi
jae 0x536d
subq %rsi, %rdx
callq 0x21d0
movq 0xb0(%rbx), %rdi
movq 0xc0(%rbx), %rsi
movq %rdi, %rax
subq %rsi, %rax
addq 0xc8(%rbx), %rax
movq %rax, 0xc8(%rbx)
movq %rdi, 0xc0(%rbx)
movq 0x60(%rbx), %rdi
movq 0xb8(%rbx), %rdx
subq %rax, %rdx
movq %rsp, %rcx
movq %rax, %rsi
callq *0x58(%rbx)
testl %eax, %eax
je 0x53c6
movq (%rsp), %rax
addq %rax, 0xc8(%rbx)
testq %rax, %rax
jne 0x53eb
movl $0x1, 0x80(%rbx)
jmp 0x53eb
movl $0x1, %ebp
jmp 0x53eb
movq 0xd8(%rbx), %rax
movl $0x2, (%rbx)
leaq 0x12b48(%rip), %rcx     # 0x17f22
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movl $0xffffffff, 0x18(%rbx) # imm = 0xFFFFFFFF
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/scanner.c
// Function: yaml_parser_stale_simple_keys
static int
yaml_parser_stale_simple_keys(yaml_parser_t *parser)
{
    yaml_simple_key_t *simple_key;

    /* Check for a potential simple key for each flow level. */

    for (simple_key = parser->simple_keys.start;
            simple_key != parser->simple_keys.top; simple_key ++)
    {
        /*
         * The specification requires that a simple key
         *
         *  - is limited to a single line,
         *  - is shorter than 1024 characters.
         */

        if (simple_key->possible
                && (simple_key->mark.line < parser->mark.line
                    || simple_key->mark.index+1024 < parser->mark.index)) {

            /* Check if the potential simple key to be removed is required. */

            if (simple_key->required) {
                return yaml_parser_set_scanner_error(parser,
                        "while scanning a simple key", simple_key->mark,
                        "could not find expected ':'");
            }

            simple_key->possible = 0;
        }
    }

    return 1;
}

// Assembly:
movq 0x158(%rdi), %rdx
movq 0x168(%rdi), %rsi
movl $0x1, %eax
cmpq %rsi, %rdx
je 0x706a
leaq 0xe0(%rdi), %rcx
movl $0x400, %r8d            # imm = 0x400
cmpl $0x0, (%rdx)
je 0x7061
movq 0x18(%rdx), %r9
cmpq 0xe8(%rdi), %r9
jb 0x7055
movq 0x10(%rdx), %r9
addq %r8, %r9
cmpq (%rcx), %r9
jae 0x7061
cmpl $0x0, 0x4(%rdx)
jne 0x706b
movl $0x0, (%rdx)
addq $0x28, %rdx
cmpq %rsi, %rdx
jne 0x7037
retq
movq 0x20(%rdx), %rax
movq %rax, -0x8(%rsp)
movups 0x10(%rdx), %xmm0
movaps %xmm0, -0x18(%rsp)
movl $0x3, (%rdi)
leaq 0x11118(%rip), %rax     # 0x181a2
movq %rax, 0x38(%rdi)
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x40(%rdi)
movq -0x8(%rsp), %rax
movq %rax, 0x50(%rdi)
leaq 0x11117(%rip), %rax     # 0x181be
movq %rax, 0x8(%rdi)
movups (%rcx), %xmm0
movups %xmm0, 0x20(%rdi)
movq 0x10(%rcx), %rax
movq %rax, 0x30(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/scanner.c
// Function: yaml_parser_unroll_indent
static int
yaml_parser_unroll_indent(yaml_parser_t *parser, ptrdiff_t column)
{
    yaml_token_t token;

    /* In the flow context, do nothing. */

    if (parser->flow_level)
        return 1;

    /* Loop through the intendation levels in the stack. */

    while (parser->indent > column)
    {
        /* Create a token and append it to the queue. */

        TOKEN_INIT(token, YAML_BLOCK_END_TOKEN, parser->mark, parser->mark);

        if (!ENQUEUE(parser, parser->tokens, token))
            return 0;

        /* Pop the indentation level. */

        parser->indent = POP(parser, parser->indents);
    }

    return 1;
}

// Assembly:
movl $0x1, %eax
cmpl $0x0, 0x100(%rdi)
je 0x70cc
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %r14
movslq 0x150(%rdi), %rcx
cmpq %rsi, %rcx
jle 0x71f3
leaq 0xe0(%r14), %rbp
leaq 0x4c(%rsp), %rbx
leaq 0x120(%r14), %r12
leaq 0x110(%r14), %r13
leaq 0x108(%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0x118(%r14), %rax
movq %rax, (%rsp)
xorps %xmm3, %xmm3
movups %xmm3, 0x3c(%rsp)
movaps %xmm3, 0x30(%rsp)
movq 0x10(%rbp), %rax
movq %rax, 0x10(%rbx)
movups (%rbp), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rbp), %rax
movq %rax, 0x20(%rsp)
movups (%rbp), %xmm0
movaps %xmm0, 0x10(%rsp)
movq (%r12), %rax
cmpq (%r13), %rax
jne 0x7178
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x2160
testl %eax, %eax
je 0x71ea
movq (%r12), %rax
xorps %xmm3, %xmm3
leaq 0x50(%rax), %rcx
movq %rcx, 0x120(%r14)
movl $0x9, (%rax)
movl 0x60(%rsp), %ecx
movl %ecx, 0x34(%rax)
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movaps 0x50(%rsp), %xmm2
movups %xmm2, 0x24(%rax)
movups %xmm1, 0x14(%rax)
movups %xmm0, 0x4(%rax)
movaps 0x10(%rsp), %xmm0
movups %xmm0, 0x38(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x48(%rax)
movq 0x148(%r14), %rax
leaq -0x4(%rax), %rcx
movq %rcx, 0x148(%r14)
movslq -0x4(%rax), %rax
movl %eax, 0x150(%r14)
cmpq %r15, %rax
jg 0x7124
movl $0x1, %eax
jmp 0x71f3
movl $0x1, (%r14)
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/scanner.c
// Function: yaml_parser_fetch_flow_collection_start
static int
yaml_parser_fetch_flow_collection_start(yaml_parser_t *parser,
        yaml_token_type_t type)
{
    yaml_mark_t start_mark, end_mark;
    yaml_token_t token;

    /* The indicators '[' and '{' may start a simple key. */

    if (!yaml_parser_save_simple_key(parser))
        return 0;

    /* Increase the flow level. */

    if (!yaml_parser_increase_flow_level(parser))
        return 0;

    /* A simple key may follow the indicators '[' and '{'. */

    parser->simple_key_allowed = 1;

    /* Consume the token. */

    start_mark = parser->mark;
    SKIP(parser);
    end_mark = parser->mark;

    /* Create the FLOW-SEQUENCE-START of FLOW-MAPPING-START token. */

    TOKEN_INIT(token, type, start_mark, end_mark);

    /* Append the token to the queue. */

    if (!ENQUEUE(parser, parser->tokens, token))
        return 0;

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebp
movq %rdi, %r14
callq 0xcd5a
xorl %ebx, %ebx
testl %eax, %eax
je 0x76d6
movq 0x168(%r14), %rax
cmpq 0x160(%r14), %rax
jne 0x7552
leaq 0x168(%r14), %r15
leaq 0x160(%r14), %rdx
leaq 0x158(%r14), %rdi
movq %r15, %rsi
callq 0x20e0
testl %eax, %eax
je 0x757d
movq (%r15), %rax
leaq 0x28(%rax), %rcx
movq %rcx, 0x168(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x20(%rax)
movl 0x100(%r14), %eax
cmpl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
jne 0x7589
movl $0x1, (%r14)
jmp 0x76d6
incl %eax
movl %eax, 0x100(%r14)
movl $0x1, 0x154(%r14)
movq 0xf0(%r14), %rax
movq %rax, 0x30(%rsp)
movups 0xe0(%r14), %xmm0
movaps %xmm0, 0x20(%rsp)
incq 0xe0(%r14)
incq 0xf0(%r14)
leaq 0xe0(%r14), %rax
decq 0xa8(%r14)
movq 0x98(%r14), %rcx
movzbl (%rcx), %edx
movl $0x1, %esi
testb %dl, %dl
jns 0x761b
movl %edx, %edi
andl $-0x20, %edi
movl $0x2, %esi
cmpl $0xc0, %edi
je 0x761b
movl %edx, %edi
andl $-0x10, %edi
movl $0x3, %esi
cmpl $0xe0, %edi
je 0x761b
andl $-0x8, %edx
xorl %esi, %esi
cmpl $0xf0, %edx
sete %sil
shll $0x2, %esi
addq %rsi, %rcx
movq %rcx, 0x98(%r14)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movaps %xmm0, (%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movups %xmm0, 0x4c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x6c(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, 0x5c(%rsp)
leaq 0x120(%r14), %r15
movq 0x120(%r14), %rax
cmpq 0x110(%r14), %rax
jne 0x7695
leaq 0x110(%r14), %rcx
leaq 0x108(%r14), %rdi
leaq 0x118(%r14), %rsi
movq %r15, %rdx
callq 0x2160
testl %eax, %eax
je 0x757d
movq (%r15), %rax
leaq 0x50(%rax), %rcx
movq %rcx, (%r15)
movl %ebp, (%rax)
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movups %xmm0, 0x4(%rax)
movups %xmm1, 0x14(%rax)
movups %xmm2, 0x24(%rax)
movl 0x70(%rsp), %ecx
movl %ecx, 0x34(%rax)
movaps (%rsp), %xmm0
movups %xmm0, 0x38(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x48(%rax)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/scanner.c
// Function: yaml_parser_fetch_flow_entry
static int
yaml_parser_fetch_flow_entry(yaml_parser_t *parser)
{
    yaml_mark_t start_mark, end_mark;
    yaml_token_t token;

    /* Reset any potential simple keys on the current flow level. */

    if (!yaml_parser_remove_simple_key(parser))
        return 0;

    /* Simple keys are allowed after ','. */

    parser->simple_key_allowed = 1;

    /* Consume the token. */

    start_mark = parser->mark;
    SKIP(parser);
    end_mark = parser->mark;

    /* Create the FLOW-ENTRY token and append it to the queue. */

    TOKEN_INIT(token, YAML_FLOW_ENTRY_TOKEN, start_mark, end_mark);

    if (!ENQUEUE(parser, parser->tokens, token))
        return 0;

    return 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq 0x168(%rdi), %rax
cmpl $0x0, -0x28(%rax)
je 0x7951
cmpl $0x0, -0x24(%rax)
je 0x7951
movq -0x8(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups -0x18(%rax), %xmm0
movaps %xmm0, (%rsp)
movl $0x3, (%rbx)
leaq 0x1088e(%rip), %rax     # 0x181a2
movq %rax, 0x38(%rbx)
movaps (%rsp), %xmm0
movups %xmm0, 0x40(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rbx)
leaq 0x1088e(%rip), %rax     # 0x181be
movq %rax, 0x8(%rbx)
movups 0xe0(%rbx), %xmm0
movups %xmm0, 0x20(%rbx)
movq 0xf0(%rbx), %rax
movq %rax, 0x30(%rbx)
xorl %eax, %eax
jmp 0x7a9a
movl $0x0, -0x28(%rax)
movl $0x1, 0x154(%rbx)
movq 0xf0(%rbx), %rax
movq %rax, 0x70(%rsp)
movups 0xe0(%rbx), %xmm0
movaps %xmm0, 0x60(%rsp)
incq 0xe0(%rbx)
incq 0xf0(%rbx)
leaq 0xe0(%rbx), %rax
decq 0xa8(%rbx)
movq 0x98(%rbx), %rcx
movzbl (%rcx), %edx
movl $0x1, %esi
testb %dl, %dl
jns 0x79df
movl %edx, %edi
andl $-0x20, %edi
movl $0x2, %esi
cmpl $0xc0, %edi
je 0x79df
movl %edx, %edi
andl $-0x10, %edi
movl $0x3, %esi
cmpl $0xe0, %edi
je 0x79df
andl $-0x8, %edx
xorl %esi, %esi
cmpl $0xf0, %edx
sete %sil
shll $0x2, %esi
addq %rsi, %rcx
movq %rcx, 0x98(%rbx)
movq 0x10(%rax), %rcx
movq %rcx, 0x50(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x40(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movups %xmm0, 0xc(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x2c(%rsp)
movaps 0x60(%rsp), %xmm0
movups %xmm0, 0x1c(%rsp)
leaq 0x120(%rbx), %r14
movq 0x120(%rbx), %rax
cmpq 0x110(%rbx), %rax
jne 0x7a55
leaq 0x110(%rbx), %rcx
leaq 0x108(%rbx), %rdi
leaq 0x118(%rbx), %rsi
movq %r14, %rdx
callq 0x2160
testl %eax, %eax
je 0x7aa2
movq (%r14), %rax
leaq 0x50(%rax), %rcx
movq %rcx, (%r14)
movl $0xf, (%rax)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movups %xmm0, 0x4(%rax)
movups %xmm1, 0x14(%rax)
movups %xmm2, 0x24(%rax)
movl 0x30(%rsp), %ecx
movl %ecx, 0x34(%rax)
movaps 0x40(%rsp), %xmm0
movups %xmm0, 0x38(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0x48(%rax)
movl $0x1, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movl $0x1, (%rbx)
jmp 0x794a
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/scanner.c
// Function: yaml_parser_scan_version_directive_number
static int
yaml_parser_scan_version_directive_number(yaml_parser_t *parser,
        yaml_mark_t start_mark, int *number)
{
    int value = 0;
    size_t length = 0;

    /* Repeat while the next character is digit. */

    if (!CACHE(parser, 1)) return 0;

    while (IS_DIGIT(parser->buffer))
    {
        /* Check if the number is too long. */

        if (++length > MAX_NUMBER_LENGTH) {
            return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
                    start_mark, "found extremely long version number");
        }

        value = value*10 + AS_DIGIT(parser->buffer);

        SKIP(parser);

        if (!CACHE(parser, 1)) return 0;
    }

    /* Check if the number was present. */

    if (!length) {
        return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
                start_mark, "did not find expected version number");
    }

    *number = value;

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0xa8(%rdi)
jne 0xc143
movl $0x1, %esi
movq %rbx, %rdi
callq 0x2060
testl %eax, %eax
je 0xc2c7
leaq 0x50(%rsp), %r15
movq 0x98(%rbx), %rax
movb (%rax), %r13b
leal -0x3a(%r13), %ebp
cmpb $-0xa, %bpl
jae 0xc19f
movl $0x3, (%rbx)
leaq 0xc127(%rip), %rax      # 0x18290
movq %rax, 0x38(%rbx)
movups (%r15), %xmm0
movups %xmm0, 0x40(%rbx)
movq 0x10(%r15), %rax
movq %rax, 0x50(%rbx)
leaq 0xc17e(%rip), %rax      # 0x18302
movq %rax, 0x8(%rbx)
movups 0xe0(%rbx), %xmm0
movups %xmm0, 0x20(%rbx)
movq 0xf0(%rbx), %rax
jmp 0xc2c3
movq %r14, 0x8(%rsp)
leaq 0xe0(%rbx), %rcx
movq %rcx, 0x10(%rsp)
xorl %r12d, %r12d
movl $0xa, %r14d
decq %r14
je 0xc287
incq 0xe0(%rbx)
incq 0xf0(%rbx)
movq 0xa8(%rbx), %rcx
decq %rcx
movq %rcx, 0xa8(%rbx)
movzbl (%rax), %edx
movl $0x1, %esi
testb %dl, %dl
jns 0xc223
movl %edx, %edi
andl $-0x20, %edi
movl $0x2, %esi
cmpl $0xc0, %edi
je 0xc223
movl %edx, %edi
andl $-0x10, %edi
movl $0x3, %esi
cmpl $0xe0, %edi
je 0xc223
andl $-0x8, %edx
xorl %esi, %esi
cmpl $0xf0, %edx
sete %sil
shll $0x2, %esi
addq %rsi, %rax
movq %rax, 0x98(%rbx)
testq %rcx, %rcx
jne 0xc24e
movl $0x1, %esi
movq %rbx, %rdi
callq 0x2060
testl %eax, %eax
je 0xc2c7
movq 0x98(%rbx), %rax
movzbl %r13b, %ecx
leal (%r12,%r12,4), %edx
leal (%rcx,%rdx,2), %r12d
addl $-0x30, %r12d
movb (%rax), %r13b
leal -0x30(%r13), %ecx
cmpb $0xa, %cl
jb 0xc1b9
cmpb $-0xb, %bpl
movq 0x8(%rsp), %rax
jbe 0xc15c
movl %r12d, (%rax)
movl $0x1, %eax
jmp 0xc2c9
movl $0x3, (%rbx)
leaq 0xbffc(%rip), %rax      # 0x18290
movq %rax, 0x38(%rbx)
movups (%r15), %xmm0
movups %xmm0, 0x40(%rbx)
movq 0x10(%r15), %rax
movq %rax, 0x50(%rbx)
leaq 0xc02f(%rip), %rax      # 0x182de
movq %rax, 0x8(%rbx)
movq 0x10(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, 0x20(%rbx)
movq 0x10(%rax), %rax
movq %rax, 0x30(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/scanner.c
// Function: yaml_parser_save_simple_key
static int
yaml_parser_save_simple_key(yaml_parser_t *parser)
{
    /*
     * A simple key is required at the current position if the scanner is in
     * the block context and the current column coincides with the indentation
     * level.
     */

    int required = (!parser->flow_level
            && parser->indent == (ptrdiff_t)parser->mark.column);

    /*
     * A simple key is required only when it is the first token in the current
     * line.  Therefore it is always allowed.  But we add a check anyway.
     */

    /* XXX This caused:
     * https://bitbucket.org/xi/libyaml/issue/10/wrapped-strings-cause-assert-failure
    assert(parser->simple_key_allowed || !required); */    /* Impossible. */

    /*
     * If the current position may start a simple key, save it.
     */

    if (parser->simple_key_allowed)
    {
        yaml_simple_key_t simple_key;
        simple_key.possible = 1;
        simple_key.required = required;
        simple_key.token_number = 
            parser->tokens_parsed + (parser->tokens.tail - parser->tokens.head);
        simple_key.mark = parser->mark;

        if (!yaml_parser_remove_simple_key(parser)) return 0;

        *(parser->simple_keys.top-1) = simple_key;
    }

    return 1;
}

// Assembly:
xorl %ecx, %ecx
cmpl $0x0, 0x100(%rdi)
jne 0xcd78
movslq 0x150(%rdi), %rax
xorl %ecx, %ecx
cmpq %rax, 0xf0(%rdi)
sete %cl
movl $0x1, %eax
cmpl $0x0, 0x154(%rdi)
je 0xce22
movq 0x128(%rdi), %rsi
movq 0x120(%rdi), %r8
movq 0x118(%rdi), %r9
movq 0xf0(%rdi), %rdx
movq %rdx, -0x28(%rsp)
movups 0xe0(%rdi), %xmm0
movaps %xmm0, -0x38(%rsp)
movq 0x168(%rdi), %rdx
cmpl $0x0, -0x28(%rdx)
je 0xce23
cmpl $0x0, -0x24(%rdx)
je 0xce23
leaq 0xe0(%rdi), %rax
movq -0x8(%rdx), %rcx
movq %rcx, -0x8(%rsp)
movups -0x18(%rdx), %xmm0
movaps %xmm0, -0x18(%rsp)
movl $0x3, (%rdi)
leaq 0xb3b2(%rip), %rcx      # 0x181a2
movq %rcx, 0x38(%rdi)
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x40(%rdi)
movq -0x8(%rsp), %rcx
movq %rcx, 0x50(%rdi)
leaq 0xb3b1(%rip), %rcx      # 0x181be
movq %rcx, 0x8(%rdi)
movups (%rax), %xmm0
movups %xmm0, 0x20(%rdi)
movq 0x10(%rax), %rax
movq %rax, 0x30(%rdi)
xorl %eax, %eax
retq
subq %r9, %r8
sarq $0x4, %r8
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
imulq %r8, %rdi
addq %rsi, %rdi
movl $0x1, -0x28(%rdx)
movl %ecx, -0x24(%rdx)
movq %rdi, -0x20(%rdx)
movaps -0x38(%rsp), %xmm0
movups %xmm0, -0x18(%rdx)
movq -0x28(%rsp), %rcx
movq %rcx, -0x8(%rdx)
retq
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/parser.c
// Function: yaml_parser_parse_flow_mapping_value
static int
yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser,
        yaml_event_t *event, int empty)
{
    yaml_token_t *token;

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

    if (empty) {
        parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
        return yaml_parser_process_empty_scalar(parser, event,
                token->start_mark);
    }

    if (token->type == YAML_VALUE_TOKEN) {
        SKIP_TOKEN(parser);
        token = PEEK_TOKEN(parser);
        if (!token) return 0;
        if (token->type != YAML_FLOW_ENTRY_TOKEN
                && token->type != YAML_FLOW_MAPPING_END_TOKEN) {
            if (!PUSH(parser, parser->states,
                        YAML_PARSE_FLOW_MAPPING_KEY_STATE))
                return 0;
            return yaml_parser_parse_node(parser, event, 0, 0);
        }
    }

    parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
    return yaml_parser_process_empty_scalar(parser, event, token->start_mark);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x130(%rdi)
jne 0xfa81
movq %rbx, %rdi
callq 0x21b0
testl %eax, %eax
je 0xfb75
movq 0x118(%rbx), %rax
testq %rax, %rax
je 0xfb75
testl %ebp, %ebp
jne 0xfae8
cmpl $0x11, (%rax)
jne 0xfae8
xorl %ebp, %ebp
movl %ebp, 0x130(%rbx)
incq 0x128(%rbx)
movl %ebp, 0xfc(%rbx)
addq $0x50, %rax
movq %rax, 0x118(%rbx)
movq %rbx, %rdi
callq 0x21b0
testl %eax, %eax
je 0xfb81
movq 0x118(%rbx), %rax
testq %rax, %rax
je 0xfb81
movl (%rax), %ecx
orl $0x2, %ecx
cmpl $0xf, %ecx
jne 0xfb8e
movl $0x14, 0x188(%rbx)
movq 0x30(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups 0x20(%rax), %xmm0
movaps %xmm0, (%rsp)
movl $0x1, %edi
callq 0x2080
testq %rax, %rax
je 0xfb79
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x10(%r14)
movq $0x0, 0x30(%r14)
leaq 0x30(%r14), %rbx
movl $0x6, (%r14)
movaps (%rsp), %xmm1
movups %xmm1, 0x38(%r14)
movq 0x10(%rsp), %rcx
movq %rcx, 0x48(%r14)
movaps (%rsp), %xmm1
movups %xmm1, 0x50(%r14)
movq 0x10(%rsp), %rcx
movq %rcx, 0x60(%r14)
movups %xmm0, 0x8(%r14)
movq %rax, 0x18(%r14)
movl $0x1, 0x28(%r14)
movl $0x1, %ebp
jmp 0xfb7b
xorl %ebp, %ebp
jmp 0xfb81
xorl %ebp, %ebp
movl $0x1, (%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x180(%rbx), %rax
cmpq 0x178(%rbx), %rax
jne 0xfbc2
leaq 0x180(%rbx), %r15
leaq 0x178(%rbx), %rdx
leaq 0x170(%rbx), %rdi
movq %r15, %rsi
callq 0x20e0
testl %eax, %eax
je 0xfb7b
movq (%r15), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0x180(%rbx)
movl $0x14, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe20b
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/parser.c
// Function: yaml_parser_append_tag_directive
static int
yaml_parser_append_tag_directive(yaml_parser_t *parser,
        yaml_tag_directive_t value, int allow_duplicates, yaml_mark_t mark)
{
    yaml_tag_directive_t *tag_directive;
    yaml_tag_directive_t copy = { NULL, NULL };

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

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

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

    return 1;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x1a8(%rdi), %r13
movq 0x1b8(%rdi), %r12
cmpq %r12, %r13
je 0xff37
movl %ecx, %ebp
movq (%r13), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
je 0xffc3
addq $0x10, %r13
cmpq %r12, %r13
jne 0xff1a
movq %r14, %rdi
callq 0x20c0
movq %rax, %r14
movq %r15, %rdi
callq 0x20c0
movq %rax, %r15
testq %r14, %r14
setne %al
testq %r15, %r15
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xffab
leaq 0x1b8(%rbx), %r12
movq 0x1b8(%rbx), %rax
cmpq 0x1b0(%rbx), %rax
jne 0xff95
leaq 0x1a8(%rbx), %rdi
leaq 0x1b0(%rbx), %rdx
movq %r12, %rsi
callq 0x20e0
testl %eax, %eax
je 0xffab
movq (%r12), %rax
leaq 0x10(%rax), %rcx
movq %rcx, (%r12)
movq %r14, (%rax)
movq %r15, 0x8(%rax)
movl $0x1, %eax
jmp 0xfff3
movl $0x1, (%rbx)
movq %r14, %rdi
callq 0x2140
movq %r15, %rdi
callq 0x2140
jmp 0xfff1
movl $0x1, %eax
testl %ebp, %ebp
jne 0xfff3
movl $0x4, (%rbx)
leaq 0x891e(%rip), %rax      # 0x188f7
movq %rax, 0x8(%rbx)
leaq 0x40(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, 0x20(%rbx)
movq 0x10(%rax), %rax
movq %rax, 0x30(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/loader.c
// Function: yaml_parser_register_anchor
static int
yaml_parser_register_anchor(yaml_parser_t *parser,
        int index, yaml_char_t *anchor)
{
    yaml_alias_data_t data;
    yaml_alias_data_t *alias_data;

    if (!anchor) return 1;

    data.anchor = anchor;
    data.index = index;
    data.mark = parser->document->nodes.start[index-1].start_mark;

    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 yaml_parser_set_composer_error_context(parser,
                    "found duplicate anchor; first occurence",
                    alias_data->mark, "second occurence", data.mark);
        }
    }

    if (!PUSH(parser, parser->aliases, data)) {
        yaml_free(anchor);
        return 0;
    }

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl $0x1, %ebx
testq %rdx, %rdx
je 0x10b74
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
movq 0x1d8(%rdi), %rax
movq (%rax), %rax
movslq %esi, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x5, %rcx
movq -0x20(%rax,%rcx), %rdx
movq %rdx, 0x18(%rsp)
movups -0x30(%rax,%rcx), %xmm0
movups %xmm0, 0x8(%rsp)
movq 0x1c0(%rdi), %r12
movq 0x1d0(%rdi), %r13
cmpq %r13, %r12
je 0x10aa7
movq (%r12), %rdi
movq %r15, %rsi
callq 0x2150
testl %eax, %eax
je 0x10aff
addq $0x28, %r12
jmp 0x10a8c
leaq 0x1d0(%r14), %r12
cmpq 0x1c8(%r14), %r13
jne 0x10ad9
leaq 0x1c0(%r14), %rdi
leaq 0x1c8(%r14), %rdx
movq %r12, %rsi
callq 0x20e0
testl %eax, %eax
je 0x10b63
movq (%r12), %r13
leaq 0x28(%r13), %rax
movq %rax, (%r12)
movq %r15, (%r13)
movl %ebp, 0x8(%r13)
movups 0x4(%rsp), %xmm0
movups 0x10(%rsp), %xmm1
movups %xmm0, 0xc(%r13)
movups %xmm1, 0x18(%r13)
jmp 0x10b74
movq %r15, %rdi
callq 0x2140
movq 0x20(%r12), %rax
movq %rax, 0x30(%rsp)
movups 0x10(%r12), %xmm0
movaps %xmm0, 0x20(%rsp)
movl $0x5, (%r14)
leaq 0x80cf(%rip), %rax      # 0x18bf9
movq %rax, 0x38(%r14)
movaps 0x20(%rsp), %xmm0
movups %xmm0, 0x40(%r14)
movq 0x30(%rsp), %rax
movq %rax, 0x50(%r14)
leaq 0x80d9(%rip), %rax      # 0x18c21
movq %rax, 0x8(%r14)
leaq 0x8(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, 0x20(%r14)
movq 0x10(%rax), %rax
movq %rax, 0x30(%r14)
jmp 0x10b72
movl $0x1, (%r14)
movq %r15, %rdi
callq 0x2140
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
je 0x127f7
leaq 0x60c4(%rip), %rsi      # 0x188b4
movq %r14, %rdi
xorl %edx, %edx
jmp 0x1282d
cmpl $0x0, 0x7c(%r14)
jne 0x1280e
movl 0x11c(%r14), %eax
cmpl 0x84(%r14), %eax
jle 0x1281e
movq %r14, %rdi
callq 0x12ecc
testl %eax, %eax
je 0x128a4
leaq 0x608f(%rip), %rsi      # 0x188b4
movq %r14, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x12d29
testl %eax, %eax
je 0x128a4
movq 0xa0(%r14), %rax
cmpq 0x98(%r14), %rax
jne 0x1286f
leaq 0xa0(%r14), %r15
leaq 0x98(%r14), %rdx
leaq 0x90(%r14), %rdi
movq %r15, %rsi
callq 0x20e0
testl %eax, %eax
je 0x1289d
movq (%r15), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0xa0(%r14)
movl $0x8, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
popq %rbx
popq %r14
popq %r15
jmp 0x133fc
movl $0x1, (%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0x128eb
xorl %ebp, %ebp
cmpl $0x0, 0x110(%rbx)
movl $0x0, %edx
je 0x128d9
xorl %edx, %edx
cmpl $0x0, 0x124(%rbx)
sete %dl
movq %rbx, %rdi
xorl %esi, %esi
callq 0x158b3
testl %eax, %eax
je 0x129cc
cmpl $0x8, (%r14)
jne 0x12931
movq 0xa0(%rbx), %rax
movq 0xe0(%rbx), %rcx
leaq -0x4(%rcx), %rdx
movq %rdx, 0xe0(%rbx)
movl -0x4(%rcx), %ecx
movl %ecx, 0x100(%rbx)
leaq -0x4(%rax), %rcx
movq %rcx, 0xa0(%rbx)
movl -0x4(%rax), %eax
movl %eax, 0xa8(%rbx)
movl $0x1, %ebp
jmp 0x129cc
movq %rbx, %rdi
callq 0x12ecc
testl %eax, %eax
je 0x129ca
leaq 0x6465(%rip), %rsi      # 0x18dad
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x12d29
testl %eax, %eax
je 0x129cc
movq 0xa0(%rbx), %rax
cmpq 0x98(%rbx), %rax
jne 0x12997
leaq 0xa0(%rbx), %r15
leaq 0x98(%rbx), %rdx
leaq 0x90(%rbx), %rdi
movq %r15, %rsi
callq 0x20e0
testl %eax, %eax
je 0x129d9
movq (%r15), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0xa0(%rbx)
movl $0xc, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x133fc
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, (%rbx)
jmp 0x129cc
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_emit_block_mapping_key
static int
yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter,
        yaml_event_t *event, int first)
{
    if (first)
    {
        if (!yaml_emitter_increase_indent(emitter, 0, 0))
            return 0;
    }

    if (event->type == YAML_MAPPING_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_check_simple_key(emitter))
    {
        if (!PUSH(emitter, emitter->states,
                    YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE))
            return 0;

        return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1);
    }
    else
    {
        if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 1))
            return 0;
        if (!PUSH(emitter, emitter->states,
                    YAML_EMIT_BLOCK_MAPPING_VALUE_STATE))
            return 0;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0x12a08
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x158b3
testl %eax, %eax
je 0x12b5c
cmpl $0xa, (%r14)
jne 0x12a4e
movq 0xa0(%rbx), %rax
movq 0xe0(%rbx), %rcx
leaq -0x4(%rcx), %rdx
movq %rdx, 0xe0(%rbx)
movl -0x4(%rcx), %ecx
movl %ecx, 0x100(%rbx)
leaq -0x4(%rax), %rcx
movq %rcx, 0xa0(%rbx)
movl -0x4(%rax), %eax
movl %eax, 0xa8(%rbx)
movl $0x1, %ebp
jmp 0x12b5c
movq %rbx, %rdi
callq 0x12ecc
xorl %ebp, %ebp
testl %eax, %eax
je 0x12b5c
movq %rbx, %rdi
callq 0x15ae1
testl %eax, %eax
je 0x12acd
movq 0xa0(%rbx), %rax
cmpq 0x98(%rbx), %rax
jne 0x12aa4
leaq 0xa0(%rbx), %r15
leaq 0x98(%rbx), %rdx
leaq 0x90(%rbx), %rdi
movq %r15, %rsi
callq 0x20e0
testl %eax, %eax
je 0x12b56
movq (%r15), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0xa0(%rbx)
movl $0xf, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
jmp 0x12b47
leaq 0x645e(%rip), %rsi      # 0x18f32
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x12d29
testl %eax, %eax
je 0x12b5c
movq 0xa0(%rbx), %rax
cmpq 0x98(%rbx), %rax
jne 0x12b23
leaq 0xa0(%rbx), %r15
leaq 0x98(%rbx), %rdx
leaq 0x90(%rbx), %rdi
movq %r15, %rsi
callq 0x20e0
testl %eax, %eax
je 0x12b56
movq (%r15), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0xa0(%rbx)
movl $0x10, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x133fc
movl $0x1, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
je 0x12b8b
leaq 0x5d35(%rip), %rsi      # 0x188b4
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
jmp 0x12bb2
movq %r14, %rdi
callq 0x12ecc
testl %eax, %eax
je 0x12c24
leaq 0x5d12(%rip), %rsi      # 0x188b4
movq %r14, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x12d29
testl %eax, %eax
je 0x12c24
movq 0xa0(%r14), %rax
cmpq 0x98(%r14), %rax
jne 0x12bef
leaq 0xa0(%r14), %r15
leaq 0x98(%r14), %rdx
leaq 0x90(%r14), %rdi
movq %r15, %rsi
callq 0x20e0
testl %eax, %eax
je 0x12c1d
movq (%r15), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0xa0(%r14)
movl $0xe, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
popq %rbx
popq %r14
popq %r15
jmp 0x133fc
movl $0x1, (%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0xe8(%rdi), %r12
movq 0xf8(%rdi), %r13
cmpq %r13, %r12
je 0x12c72
movl %ecx, %ebp
movq (%r12), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
je 0x12cfe
addq $0x10, %r12
cmpq %r13, %r12
jne 0x12c55
movq %r14, %rdi
callq 0x20c0
movq %rax, %r14
movq %r15, %rdi
callq 0x20c0
movq %rax, %r15
testq %r14, %r14
setne %al
testq %r15, %r15
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x12ce6
leaq 0xf8(%rbx), %r12
movq 0xf8(%rbx), %rax
cmpq 0xf0(%rbx), %rax
jne 0x12cd0
leaq 0xe8(%rbx), %rdi
leaq 0xf0(%rbx), %rdx
movq %r12, %rsi
callq 0x20e0
testl %eax, %eax
je 0x12ce6
movq (%r12), %rax
leaq 0x10(%rax), %rcx
movq %rcx, (%r12)
movq %r14, (%rax)
movq %r15, 0x8(%rax)
movl $0x1, %eax
jmp 0x12d1a
movl $0x1, (%rbx)
movq %r14, %rdi
callq 0x2140
movq %r15, %rdi
callq 0x2140
jmp 0x12d18
movl $0x1, %eax
testl %ebp, %ebp
jne 0x12d1a
movl $0x7, (%rbx)
leaq 0x5be9(%rip), %rax      # 0x188fd
movq %rax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_write_indicator
static int
yaml_emitter_write_indicator(yaml_emitter_t *emitter,
        char *indicator, int need_whitespace,
        int is_whitespace, int is_indention)
{
    size_t indicator_length;
    yaml_string_t string;

    indicator_length = strlen(indicator);
    STRING_ASSIGN(string, (yaml_char_t *)indicator, indicator_length);

    if (need_whitespace && !emitter->whitespace) {
        if (!PUT(emitter, ' ')) return 0;
    }

    while (string.pointer != string.end) {
        if (!WRITE(emitter, string)) return 0;
    }

    emitter->whitespace = is_whitespace;
    emitter->indention = (emitter->indention && is_indention);
    emitter->open_ended = 0;

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x20d0
movq %rax, %r12
testl %r13d, %r13d
je 0x12d8f
cmpl $0x0, 0x120(%rbx)
jne 0x12d8f
movq 0x48(%rbx), %rax
leaq 0x5(%rax), %rcx
cmpq 0x40(%rbx), %rcx
jb 0x12d7e
movq %rbx, %rdi
callq 0x2190
testl %eax, %eax
je 0x12ebb
movq 0x48(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x48(%rbx)
movb $0x20, (%rax)
incl 0x11c(%rbx)
testq %r12, %r12
je 0x12e89
addq %r15, %r12
movq 0x48(%rbx), %rax
addq $0x5, %rax
cmpq 0x40(%rbx), %rax
jb 0x12db9
movq %rbx, %rdi
callq 0x2190
testl %eax, %eax
je 0x12ebb
movb (%r15), %al
testb %al, %al
js 0x12dc8
incq %r15
jmp 0x12e6c
movzbl %al, %ecx
movl %ecx, %edx
andl $-0x20, %edx
cmpl $0xc0, %edx
jne 0x12df0
movq 0x48(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%rbx)
movb %al, (%rcx)
movb 0x1(%r15), %al
addq $0x2, %r15
jmp 0x12e6c
movl %ecx, %edx
andl $-0x10, %edx
cmpl $0xe0, %edx
jne 0x12e27
movq 0x48(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%rbx)
movb %al, (%rcx)
movb 0x1(%r15), %al
movq 0x48(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%rbx)
movb %al, (%rcx)
movb 0x2(%r15), %al
addq $0x3, %r15
jmp 0x12e6c
andl $-0x8, %ecx
cmpl $0xf0, %ecx
jne 0x12e7a
movq 0x48(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%rbx)
movb %al, (%rcx)
movb 0x1(%r15), %al
movq 0x48(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%rbx)
movb %al, (%rcx)
movb 0x2(%r15), %al
movq 0x48(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%rbx)
movb %al, (%rcx)
movb 0x3(%r15), %al
addq $0x4, %r15
movq 0x48(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%rbx)
movb %al, (%rcx)
incl 0x11c(%rbx)
cmpq %r12, %r15
jne 0x12d9b
movl %r14d, 0x120(%rbx)
cmpl $0x0, 0x124(%rbx)
setne %al
testl %ebp, %ebp
setne %cl
andb %al, %cl
movzbl %cl, %eax
movl %eax, 0x124(%rbx)
movl $0x0, 0x128(%rbx)
movl $0x1, %eax
jmp 0x12ebd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_write_indent
static int
yaml_emitter_write_indent(yaml_emitter_t *emitter)
{
    int indent = (emitter->indent >= 0) ? emitter->indent : 0;

    if (!emitter->indention || emitter->column > indent
            || (emitter->column == indent && !emitter->whitespace)) {
        if (!PUT_BREAK(emitter)) return 0;
    }

    while (emitter->column < indent) {
        if (!PUT(emitter, ' ')) return 0;
    }

    emitter->whitespace = 1;
    emitter->indention = 1;

    return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x100(%rdi), %eax
xorl %ebp, %ebp
testl %eax, %eax
cmovgl %eax, %ebp
cmpl $0x0, 0x124(%rdi)
je 0x12ef2
movl 0x11c(%rbx), %eax
cmpl %ebp, %eax
jle 0x12f27
movq 0x48(%rbx), %rax
addq $0x5, %rax
cmpq 0x40(%rbx), %rax
jb 0x12f10
movq %rbx, %rdi
callq 0x2190
testl %eax, %eax
je 0x12fbe
movl 0x8c(%rbx), %eax
cmpl $0x1, %eax
je 0x12f47
cmpl $0x3, %eax
je 0x12f34
cmpl $0x2, %eax
je 0x12f43
jmp 0x12f57
jne 0x12fa2
cmpl $0x0, 0x120(%rbx)
jne 0x12fa6
jmp 0x12ef2
movq 0x48(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x48(%rbx)
movb $0xd, (%rax)
movb $0xa, %al
jmp 0x12f49
movb $0xd, %al
movq 0x48(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%rbx)
movb %al, (%rcx)
movl $0x0, 0x11c(%rbx)
incl 0x118(%rbx)
xorl %eax, %eax
jmp 0x12fa2
movq 0x48(%rbx), %rax
leaq 0x5(%rax), %rcx
cmpq 0x40(%rbx), %rcx
jb 0x12f89
movq %rbx, %rdi
callq 0x2190
testl %eax, %eax
je 0x12fbe
movq 0x48(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x48(%rbx)
movb $0x20, (%rax)
movl 0x11c(%rbx), %eax
incl %eax
movl %eax, 0x11c(%rbx)
cmpl %ebp, %eax
jl 0x12f6b
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x120(%rbx)
movl $0x1, %eax
jmp 0x12fc0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_write_tag_handle
static int
yaml_emitter_write_tag_handle(yaml_emitter_t *emitter,
        yaml_char_t *value, size_t length)
{
    yaml_string_t string;
    STRING_ASSIGN(string, value, length);

    if (!emitter->whitespace) {
        if (!PUT(emitter, ' ')) return 0;
    }

    while (string.pointer != string.end) {
        if (!WRITE(emitter, string)) return 0;
    }

    emitter->whitespace = 0;
    emitter->indention = 0;

    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x0, 0x120(%rdi)
jne 0x13012
movq 0x48(%r14), %rax
leaq 0x5(%rax), %rcx
cmpq 0x40(%r14), %rcx
jb 0x13000
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
je 0x1311f
movq 0x48(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x48(%r14)
movb $0x20, (%rax)
incl 0x11c(%r14)
testq %rbx, %rbx
je 0x1310d
addq %r15, %rbx
movq 0x48(%r14), %rax
addq $0x5, %rax
cmpq 0x40(%r14), %rax
jb 0x1303c
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
je 0x1311f
movb (%r15), %al
testb %al, %al
js 0x1304b
incq %r15
jmp 0x130ef
movzbl %al, %ecx
movl %ecx, %edx
andl $-0x20, %edx
cmpl $0xc0, %edx
jne 0x13073
movq 0x48(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%r14)
movb %al, (%rcx)
movb 0x1(%r15), %al
addq $0x2, %r15
jmp 0x130ef
movl %ecx, %edx
andl $-0x10, %edx
cmpl $0xe0, %edx
jne 0x130aa
movq 0x48(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%r14)
movb %al, (%rcx)
movb 0x1(%r15), %al
movq 0x48(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%r14)
movb %al, (%rcx)
movb 0x2(%r15), %al
addq $0x3, %r15
jmp 0x130ef
andl $-0x8, %ecx
cmpl $0xf0, %ecx
jne 0x130fd
movq 0x48(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%r14)
movb %al, (%rcx)
movb 0x1(%r15), %al
movq 0x48(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%r14)
movb %al, (%rcx)
movb 0x2(%r15), %al
movq 0x48(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%r14)
movb %al, (%rcx)
movb 0x3(%r15), %al
addq $0x4, %r15
movq 0x48(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%r14)
movb %al, (%rcx)
incl 0x11c(%r14)
cmpq %rbx, %r15
jne 0x1301e
movq $0x0, 0x120(%r14)
movl $0x1, %eax
jmp 0x13121
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x130(%rdi)
je 0x157e1
movq %rdi, %r14
cmpl $0x0, 0x140(%rdi)
leaq 0x383b(%rip), %rax      # 0x18eda
leaq 0x3832(%rip), %rsi      # 0x18ed8
cmoveq %rax, %rsi
xorl %ebx, %ebx
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x12d29
testl %eax, %eax
je 0x157e6
movq 0x138(%r14), %r15
testq %r15, %r15
je 0x157d6
movq 0x130(%r14), %r12
addq %r12, %r15
movq 0x48(%r14), %rax
addq $0x5, %rax
cmpq 0x40(%r14), %rax
jb 0x156fb
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
je 0x157e6
movb (%r12), %al
testb %al, %al
js 0x1570b
incq %r12
jmp 0x157b8
movzbl %al, %ecx
movl %ecx, %edx
andl $-0x20, %edx
cmpl $0xc0, %edx
jne 0x15737
movq 0x48(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%r14)
movb %al, (%rcx)
movb 0x1(%r12), %al
addq $0x2, %r12
jmp 0x157b8
movl %ecx, %edx
andl $-0x10, %edx
cmpl $0xe0, %edx
jne 0x15770
movq 0x48(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%r14)
movb %al, (%rcx)
movb 0x1(%r12), %al
movq 0x48(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%r14)
movb %al, (%rcx)
movb 0x2(%r12), %al
addq $0x3, %r12
jmp 0x157b8
andl $-0x8, %ecx
cmpl $0xf0, %ecx
jne 0x157c6
movq 0x48(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%r14)
movb %al, (%rcx)
movb 0x1(%r12), %al
movq 0x48(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%r14)
movb %al, (%rcx)
movb 0x2(%r12), %al
movq 0x48(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%r14)
movb %al, (%rcx)
movb 0x3(%r12), %al
addq $0x4, %r12
movq 0x48(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%r14)
movb %al, (%rcx)
incl 0x11c(%r14)
cmpq %r15, %r12
jne 0x156dd
movq $0x0, 0x120(%r14)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x148(%rdi), %rsi
testq %rsi, %rsi
je 0x1583e
movq 0x150(%rbx), %rdx
movq %rbx, %rdi
callq 0x12fc7
testl %eax, %eax
je 0x158a8
movq 0x158(%rbx), %rsi
testq %rsi, %rsi
je 0x158a1
movq 0x160(%rbx), %rdx
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x13127
jmp 0x1589d
cmpq $0x0, 0x158(%rbx)
je 0x158a1
leaq 0x36ba(%rip), %rsi      # 0x18f09
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x12d29
testl %eax, %eax
je 0x158aa
movq 0x158(%rbx), %rsi
movq 0x160(%rbx), %rdx
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x13127
testl %eax, %eax
je 0x158aa
leaq 0x3012(%rip), %rsi      # 0x1889e
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x12d29
testl %eax, %eax
je 0x158aa
movl $0x1, %ebp
jmp 0x158aa
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq