LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x11cb7
xorl %ebp, %ebp
cmpl $0x0, 0x110(%rbx)
movl $0x0, %edx
je 0x11ca5
xorl %edx, %edx
cmpl $0x0, 0x124(%rbx)
sete %dl
movq %rbx, %rdi
xorl %esi, %esi
callq 0x14ad3
testl %eax, %eax
je 0x11d8f
cmpl $0x8, (%r14)
jne 0x11cfb
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)
pushq $0x1
popq %rbp
jmp 0x11d8f
movq %rbx, %rdi
callq 0x12283
testl %eax, %eax
je 0x11d8d
leaq 0x608b(%rip), %rsi      # 0x17d9d
xorl %ebp, %ebp
pushq $0x1
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
movl %edx, %r8d
callq 0x120e9
testl %eax, %eax
je 0x11d8f
movq 0xa0(%rbx), %rax
cmpq 0x98(%rbx), %rax
jne 0x11d5c
leaq 0xa0(%rbx), %r15
leaq 0x98(%rbx), %rdx
leaq 0x90(%rbx), %rdi
movq %r15, %rsi
callq 0x20e0
testl %eax, %eax
je 0x11d9c
movq (%r15), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0xa0(%rbx)
movl $0xc, (%rax)
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x127b2
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, (%rbx)
jmp 0x11d8f
// File: /workspace/github_c_makefile_star2_O2/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 0x11dcb
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x14ad3
testl %eax, %eax
je 0x11f11
cmpl $0xa, (%r14)
jne 0x11e0f
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)
pushq $0x1
popq %rbp
jmp 0x11f11
movq %rbx, %rdi
callq 0x12283
xorl %ebp, %ebp
testl %eax, %eax
je 0x11f11
movq %rbx, %rdi
callq 0x14d33
testl %eax, %eax
je 0x11e89
movq 0xa0(%rbx), %rax
cmpq 0x98(%rbx), %rax
jne 0x11e65
leaq 0xa0(%rbx), %r15
leaq 0x98(%rbx), %rdx
leaq 0x90(%rbx), %rdi
movq %r15, %rsi
callq 0x20e0
testl %eax, %eax
je 0x11f0b
movq (%r15), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0xa0(%rbx)
movl $0xf, (%rax)
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movl %r8d, %r9d
jmp 0x11efc
leaq 0x6092(%rip), %rsi      # 0x17f22
xorl %ebp, %ebp
pushq $0x1
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
movl %edx, %r8d
callq 0x120e9
testl %eax, %eax
je 0x11f11
movq 0xa0(%rbx), %rax
cmpq 0x98(%rbx), %rax
jne 0x11eda
leaq 0xa0(%rbx), %r15
leaq 0x98(%rbx), %rdx
leaq 0x90(%rbx), %rdi
movq %r15, %rsi
callq 0x20e0
testl %eax, %eax
je 0x11f0b
movq (%r15), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0xa0(%rbx)
movl $0x10, (%rax)
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r9d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x127b2
movl $0x1, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x11f40
leaq 0x5970(%rip), %rsi      # 0x178a4
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
jmp 0x11f62
movq %r14, %rdi
callq 0x12283
testl %eax, %eax
je 0x11fd2
leaq 0x594d(%rip), %rsi      # 0x178a4
pushq $0x1
popq %rdx
movq %r14, %rdi
xorl %ecx, %ecx
movl %edx, %r8d
callq 0x120e9
testl %eax, %eax
je 0x11fd2
movq 0xa0(%r14), %rax
cmpq 0x98(%r14), %rax
jne 0x11f9f
leaq 0xa0(%r14), %r15
leaq 0x98(%r14), %rdx
leaq 0x90(%r14), %rdi
movq %r15, %rsi
callq 0x20e0
testl %eax, %eax
je 0x11fcb
movq (%r15), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0xa0(%r14)
movl $0xe, (%rax)
pushq $0x1
popq %r8
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r9d, %r9d
popq %rbx
popq %r14
popq %r15
jmp 0x127b2
movl $0x1, (%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xe8(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0xe8(%rdi), %r15
movq 0xf8(%rdi), %r14
leaq 0xf8(%rdi), %rax
movq %rax, 0x8(%rsp)
cmpq %r14, %r15
je 0x1204f
movq (%r15), %rsi
movq %r12, %rdi
callq 0x2150
addq $0x10, %r15
testl %eax, %eax
jne 0x12019
testl %ebp, %ebp
jne 0x120bd
movl $0x7, (%rbx)
leaq 0x58a7(%rip), %rax      # 0x178ed
movq %rax, 0x8(%rbx)
jmp 0x120d8
movq %r12, %rdi
callq 0x20c0
movq %rax, %r12
movq %r13, %rdi
callq 0x20c0
movq %rax, %r13
testq %r12, %r12
setne %al
testq %r13, %r13
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x120c2
movq 0xf8(%rbx), %rax
cmpq 0xf0(%rbx), %rax
jne 0x120aa
leaq 0xf0(%rbx), %rdx
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x20e0
testl %eax, %eax
je 0x120c2
movq 0x8(%rsp), %rax
movq (%rax), %rax
leaq 0x10(%rax), %rcx
movq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
movq %r12, (%rax)
movq %r13, 0x8(%rax)
pushq $0x1
popq %rax
jmp 0x120da
movl $0x1, (%rbx)
movq %r12, %rdi
callq 0x2140
movq %r13, %rdi
callq 0x2140
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_O2/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 0x1214f
cmpl $0x0, 0x120(%rbx)
jne 0x1214f
movq 0x48(%rbx), %rax
leaq 0x5(%rax), %rcx
cmpq 0x40(%rbx), %rcx
jb 0x1213e
movq %rbx, %rdi
callq 0x2190
testl %eax, %eax
je 0x12272
movq 0x48(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x48(%rbx)
movb $0x20, (%rax)
incl 0x11c(%rbx)
addq %r15, %r12
cmpq %r12, %r15
je 0x12245
movq 0x48(%rbx), %rax
addq $0x5, %rax
cmpq 0x40(%rbx), %rax
jb 0x12179
movq %rbx, %rdi
callq 0x2190
testl %eax, %eax
je 0x12272
movb (%r15), %al
testb %al, %al
js 0x12188
incq %r15
jmp 0x1222c
movzbl %al, %ecx
movl %ecx, %edx
andl $-0x20, %edx
cmpl $0xc0, %edx
jne 0x121b0
movq 0x48(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%rbx)
movb %al, (%rcx)
movb 0x1(%r15), %al
addq $0x2, %r15
jmp 0x1222c
movl %ecx, %edx
andl $-0x10, %edx
cmpl $0xe0, %edx
jne 0x121e7
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 0x1222c
andl $-0x8, %ecx
cmpl $0xf0, %ecx
jne 0x1223a
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)
jmp 0x12152
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)
andl $0x0, 0x128(%rbx)
pushq $0x1
popq %rax
jmp 0x12274
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_O2/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 0x122a9
movl 0x11c(%rbx), %eax
cmpl %ebp, %eax
jle 0x122de
movq 0x48(%rbx), %rax
addq $0x5, %rax
cmpq 0x40(%rbx), %rax
jb 0x122c7
movq %rbx, %rdi
callq 0x2190
testl %eax, %eax
je 0x12372
movl 0x8c(%rbx), %eax
cmpl $0x1, %eax
je 0x12300
cmpl $0x3, %eax
je 0x122ed
cmpl $0x2, %eax
je 0x122fc
jmp 0x12310
jne 0x1231f
cmpl $0x0, 0x120(%rbx)
movl %ebp, %eax
jne 0x1231f
jmp 0x122a9
movq 0x48(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x48(%rbx)
movb $0xd, (%rax)
movb $0xa, %al
jmp 0x12302
movb $0xd, %al
movq 0x48(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%rbx)
movb %al, (%rcx)
andl $0x0, 0x11c(%rbx)
incl 0x118(%rbx)
xorl %eax, %eax
cmpl %ebp, %eax
jge 0x1235c
movq 0x48(%rbx), %rax
leaq 0x5(%rax), %rcx
cmpq 0x40(%rbx), %rcx
jb 0x12341
movq %rbx, %rdi
callq 0x2190
testl %eax, %eax
je 0x12372
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)
jmp 0x1231f
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x120(%rbx)
pushq $0x1
popq %rax
jmp 0x12374
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x123c6
movq 0x48(%r14), %rax
leaq 0x5(%rax), %rcx
cmpq 0x40(%r14), %rcx
jb 0x123b4
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
je 0x124ca
movq 0x48(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x48(%r14)
movb $0x20, (%rax)
incl 0x11c(%r14)
addq %r15, %rbx
cmpq %rbx, %r15
je 0x124bd
movq 0x48(%r14), %rax
addq $0x5, %rax
cmpq 0x40(%r14), %rax
jb 0x123f0
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
je 0x124ca
movb (%r15), %al
testb %al, %al
js 0x123ff
incq %r15
jmp 0x124a3
movzbl %al, %ecx
movl %ecx, %edx
andl $-0x20, %edx
cmpl $0xc0, %edx
jne 0x12427
movq 0x48(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%r14)
movb %al, (%rcx)
movb 0x1(%r15), %al
addq $0x2, %r15
jmp 0x124a3
movl %ecx, %edx
andl $-0x10, %edx
cmpl $0xe0, %edx
jne 0x1245e
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 0x124a3
andl $-0x8, %ecx
cmpl $0xf0, %ecx
jne 0x124b1
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)
jmp 0x123c9
andq $0x0, 0x120(%r14)
pushq $0x1
popq %rax
jmp 0x124cc
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x149f6
movq %rdi, %r14
cmpl $0x0, 0x140(%rdi)
leaq 0x35fb(%rip), %rax      # 0x17eca
leaq 0x35f2(%rip), %rsi      # 0x17ec8
cmoveq %rax, %rsi
pushq $0x1
popq %rbx
movl %ebx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x120e9
testl %eax, %eax
je 0x149fb
movq 0x130(%r14), %r15
movq 0x138(%r14), %r12
addq %r15, %r12
cmpq %r12, %r15
je 0x149ff
movq 0x48(%r14), %rax
addq $0x5, %rax
cmpq 0x40(%r14), %rax
jb 0x14929
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
je 0x149fb
movb (%r15), %al
testb %al, %al
js 0x14938
incq %r15
jmp 0x149dc
movzbl %al, %ecx
movl %ecx, %edx
andl $-0x20, %edx
cmpl $0xc0, %edx
jne 0x14960
movq 0x48(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%r14)
movb %al, (%rcx)
movb 0x1(%r15), %al
addq $0x2, %r15
jmp 0x149dc
movl %ecx, %edx
andl $-0x10, %edx
cmpl $0xe0, %edx
jne 0x14997
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 0x149dc
andl $-0x8, %ecx
cmpl $0xf0, %ecx
jne 0x149ea
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)
jmp 0x14902
pushq $0x1
popq %rbx
jmp 0x14a07
xorl %ebx, %ebx
jmp 0x14a07
andq $0x0, 0x120(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
movq 0x148(%rdi), %rsi
pushq $0x1
popq %r14
testq %rsi, %rsi
je 0x14a64
movq 0x150(%rbx), %rdx
movq %rbx, %rdi
callq 0x1237b
testl %eax, %eax
je 0x14aca
movq 0x158(%rbx), %rsi
testq %rsi, %rsi
je 0x14ac5
movq 0x160(%rbx), %rdx
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x124d2
jmp 0x14ac1
cmpq $0x0, 0x158(%rbx)
je 0x14ac5
leaq 0x3484(%rip), %rsi      # 0x17ef9
pushq $0x1
popq %rdx
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x120e9
testl %eax, %eax
je 0x14acc
movq 0x158(%rbx), %rsi
movq 0x160(%rbx), %rdx
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x124d2
testl %eax, %eax
je 0x14acc
leaq 0x2dde(%rip), %rsi      # 0x1788e
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x120e9
testl %eax, %eax
je 0x14acc
movl %r14d, %ebp
jmp 0x14acc
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_increase_indent
static int
yaml_emitter_increase_indent(yaml_emitter_t *emitter,
        int flow, int indentless)
{
    if (!PUSH(emitter, emitter->indents, emitter->indent))
        return 0;

    if (emitter->indent < 0) {
        emitter->indent = flow ? emitter->best_indent : 0;
    }
    else if (!indentless) {
        emitter->indent += emitter->best_indent;
    }

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq 0xe0(%rdi), %rax
cmpq 0xd8(%rdi), %rax
jne 0x14b16
leaq 0xe0(%rbx), %r15
leaq 0xd8(%rbx), %rdx
leaq 0xd0(%rbx), %rdi
movq %r15, %rsi
callq 0x20e0
testl %eax, %eax
je 0x14b4f
movq (%r15), %rax
movl 0x100(%rbx), %ecx
leaq 0x4(%rax), %rdx
movq %rdx, 0xe0(%rbx)
movl %ecx, (%rax)
testl %ecx, %ecx
js 0x14b42
pushq $0x1
popq %rax
testl %ebp, %ebp
jne 0x14b64
addl 0x80(%rbx), %ecx
movl %ecx, 0x100(%rbx)
jmp 0x14b64
testl %r14d, %r14d
je 0x14b59
movl 0x80(%rbx), %eax
jmp 0x14b5b
movl $0x1, (%rbx)
xorl %eax, %eax
jmp 0x14b64
xorl %eax, %eax
movl %eax, 0x100(%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_analyze_anchor
static int
yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
        yaml_char_t *anchor, int alias)
{
    size_t anchor_length;
    yaml_string_t string;
    
    anchor_length = strlen((char *)anchor);
    STRING_ASSIGN(string, anchor, anchor_length);

    if (string.start == string.end) {
        return yaml_emitter_set_emitter_error(emitter, alias ?
                "alias value must not be empty" :
                "anchor value must not be empty");
    }

    while (string.pointer != string.end) {
        if (!IS_ALPHA(string)) {
            return yaml_emitter_set_emitter_error(emitter, alias ?
                    "alias value must contain alphanumerical characters only" :
                    "anchor value must contain alphanumerical characters only");
        }
        MOVE(string);
    }

    emitter->anchor_data.anchor = string.start;
    emitter->anchor_data.anchor_length = string.end - string.start;
    emitter->anchor_data.alias = alias;

    return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x20d0
testq %rax, %rax
je 0x14e32
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x14e19
movzbl (%r14,%rcx), %edx
leal -0x30(%rdx), %esi
cmpb $0xa, %sil
jb 0x14e14
movl %edx, %esi
andb $-0x21, %sil
addb $-0x41, %sil
cmpb $0x1a, %sil
jb 0x14e14
cmpl $0x2d, %edx
je 0x14e14
cmpl $0x5f, %edx
jne 0x14e44
incq %rcx
jmp 0x14de7
movq %r14, 0x130(%rbx)
movq %rax, 0x138(%rbx)
movl %ebp, 0x140(%rbx)
pushq $0x1
popq %rax
jmp 0x14e64
testl %ebp, %ebp
leaq 0x3107(%rip), %rax      # 0x17f42
leaq 0x30e2(%rip), %rcx      # 0x17f24
jmp 0x14e54
testl %ebp, %ebp
leaq 0x314c(%rip), %rax      # 0x17f99
leaq 0x310d(%rip), %rcx      # 0x17f61
cmoveq %rax, %rcx
movl $0x7, (%rbx)
movq %rcx, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_analyze_tag
static int
yaml_emitter_analyze_tag(yaml_emitter_t *emitter,
        yaml_char_t *tag)
{
    size_t tag_length;
    yaml_string_t string;
    yaml_tag_directive_t *tag_directive;

    tag_length = strlen((char *)tag);
    STRING_ASSIGN(string, tag, tag_length);

    if (string.start == string.end) {
        return yaml_emitter_set_emitter_error(emitter,
                "tag value must not be empty");
    }

    for (tag_directive = emitter->tag_directives.start;
            tag_directive != emitter->tag_directives.top; tag_directive ++) {
        size_t prefix_length = strlen((char *)tag_directive->prefix);
        if (prefix_length < (size_t)(string.end - string.start)
                && strncmp((char *)tag_directive->prefix, (char *)string.start,
                    prefix_length) == 0)
        {
            emitter->tag_data.handle = tag_directive->handle;
            emitter->tag_data.handle_length =
                strlen((char *)tag_directive->handle);
            emitter->tag_data.suffix = string.start + prefix_length;
            emitter->tag_data.suffix_length =
                (string.end - string.start) - prefix_length;
            return 1;
        }
    }

    emitter->tag_data.suffix = string.start;
    emitter->tag_data.suffix_length = string.end - string.start;

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq %rsi, %rdi
callq 0x20d0
testq %rax, %rax
je 0x14ef2
movq %rax, %r14
movq 0xe8(%rbx), %rbp
movq %rbx, 0x10(%rsp)
movq 0xf8(%rbx), %rbx
cmpq %rbx, %rbp
je 0x14ed8
movq 0x8(%rbp), %r13
movq %r13, %rdi
callq 0x20d0
movq %r14, %r15
subq %rax, %r15
jbe 0x14ed2
movq %rax, %r12
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x2050
testl %eax, %eax
je 0x14f07
addq $0x10, %rbp
jmp 0x14ea2
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x158(%rax)
movq %r14, 0x160(%rax)
jmp 0x14f39
movl $0x7, (%rbx)
leaq 0x30d3(%rip), %rax      # 0x17fd2
movq %rax, 0x8(%rbx)
xorl %eax, %eax
jmp 0x14f3c
movq (%rbp), %rdi
movq 0x10(%rsp), %rbx
movq %rdi, 0x148(%rbx)
callq 0x20d0
movq %rax, 0x150(%rbx)
movq 0x8(%rsp), %rax
addq %r12, %rax
movq %rax, 0x158(%rbx)
movq %r15, 0x160(%rbx)
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mijallen[P]SimpleHTTPServer/lib/libyaml/src/dumper.c
// Function: yaml_emitter_open
YAML_DECLARE(int)
yaml_emitter_open(yaml_emitter_t *emitter)
{
    yaml_event_t event;
    yaml_mark_t mark = { 0, 0, 0 };

    assert(emitter);            /* Non-NULL emitter object is required. */
    assert(!emitter->opened);   /* Emitter should not be opened yet. */

    STREAM_START_EVENT_INIT(event, YAML_ANY_ENCODING, mark, mark);

    if (!yaml_emitter_emit(emitter, &event)) {
        return 0;
    }

    emitter->opened = 1;

    return 1;
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
testq %rdi, %rdi
je 0x14fad
movq %rdi, %rbx
cmpl $0x0, 0x190(%rdi)
jne 0x14fc6
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
andq $0x0, 0x30(%rsi)
movl $0x1, (%rsi)
movups %xmm0, 0x38(%rsi)
movups %xmm0, 0x48(%rsi)
movups %xmm0, 0x58(%rsi)
movq %rbx, %rdi
callq 0x20f0
testl %eax, %eax
je 0x14fa5
movl $0x1, 0x190(%rbx)
pushq $0x1
popq %rax
jmp 0x14fa7
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
retq
leaq 0x1229(%rip), %rdi      # 0x161dd
leaq 0x3033(%rip), %rsi      # 0x17fee
leaq 0x3035(%rip), %rcx      # 0x17ff7
pushq $0x43
jmp 0x14fdd
leaq 0x3052(%rip), %rdi      # 0x1801f
leaq 0x301a(%rip), %rsi      # 0x17fee
leaq 0x301c(%rip), %rcx      # 0x17ff7
pushq $0x44
popq %rdx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/mijallen[P]SimpleHTTPServer/lib/libyaml/src/dumper.c
// Function: yaml_emitter_close
YAML_DECLARE(int)
yaml_emitter_close(yaml_emitter_t *emitter)
{
    yaml_event_t event;
    yaml_mark_t mark = { 0, 0, 0 };

    assert(emitter);            /* Non-NULL emitter object is required. */
    assert(emitter->opened);    /* Emitter should be opened. */

    if (emitter->closed) return 1;

    STREAM_END_EVENT_INIT(event, mark, mark);

    if (!yaml_emitter_emit(emitter, &event)) {
        return 0;
    }

    emitter->closed = 1;

    return 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
je 0x15055
movq %rdi, %r14
cmpl $0x0, 0x190(%rdi)
je 0x1506e
pushq $0x1
popq %rbx
cmpl $0x0, 0x194(%r14)
jne 0x1504b
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
andq $0x0, 0x30(%rsi)
movl $0x2, (%rsi)
movups %xmm0, 0x38(%rsi)
movups %xmm0, 0x48(%rsi)
movups %xmm0, 0x58(%rsi)
movq %r14, %rdi
callq 0x20f0
testl %eax, %eax
je 0x15049
movl $0x1, 0x194(%r14)
jmp 0x1504b
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x1181(%rip), %rdi      # 0x161dd
leaq 0x2f8b(%rip), %rsi      # 0x17fee
leaq 0x2fc6(%rip), %rcx      # 0x18030
pushq $0x5b
jmp 0x15085
leaq 0x2fab(%rip), %rdi      # 0x18020
leaq 0x2f72(%rip), %rsi      # 0x17fee
leaq 0x2fad(%rip), %rcx      # 0x18030
pushq $0x5c
popq %rdx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/mijallen[P]SimpleHTTPServer/lib/libyaml/src/dumper.c
// Function: yaml_emitter_delete_document_and_anchors
static void
yaml_emitter_delete_document_and_anchors(yaml_emitter_t *emitter)
{
    int index;

    if (!emitter->anchors) {
        yaml_document_delete(emitter->document);
        emitter->document = NULL;
        return;
    }

    for (index = 0; emitter->document->nodes.start + index
            < emitter->document->nodes.top; index ++) {
        yaml_node_t node = emitter->document->nodes.start[index];
        if (!emitter->anchors[index].serialized) {
            yaml_free(node.tag);
            if (node.type == YAML_SCALAR_NODE) {
                yaml_free(node.data.scalar.value);
            }
        }
        if (node.type == YAML_SEQUENCE_NODE) {
            STACK_DEL(emitter, node.data.sequence.items);
        }
        if (node.type == YAML_MAPPING_NODE) {
            STACK_DEL(emitter, node.data.mapping.pairs);
        }
    }

    STACK_DEL(emitter, emitter->document->nodes);
    yaml_free(emitter->anchors);

    emitter->anchors = NULL;
    emitter->last_anchor_id = 0;
    emitter->document = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x198(%rdi)
je 0x152fa
pushq $0x8
popq %r15
xorl %r12d, %r12d
movq 0x1a8(%rbx), %rax
movq (%rax), %rdi
leaq (%rdi,%r12), %rcx
cmpq 0x10(%rax), %rcx
jae 0x152c6
movl (%rdi,%r12), %ebp
movq 0x10(%rdi,%r12), %r14
movq 0x198(%rbx), %rax
cmpl $0x0, (%rax,%r15)
je 0x152b3
andl $-0x2, %ebp
cmpl $0x2, %ebp
jne 0x152a9
movq %r14, %rdi
callq 0x2140
addq $0x60, %r12
addq $0xc, %r15
jmp 0x1526e
movq 0x8(%rdi,%r12), %rdi
callq 0x2140
decl %ebp
cmpl $0x3, %ebp
jb 0x152a1
jmp 0x152a9
callq 0x2140
movq 0x1a8(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq 0x198(%rbx), %rdi
callq 0x2140
andq $0x0, 0x198(%rbx)
andl $0x0, 0x1a0(%rbx)
jmp 0x15306
movq 0x1a8(%rbx), %rdi
callq 0x2110
andq $0x0, 0x1a8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mijallen[P]SimpleHTTPServer/lib/libyaml/src/dumper.c
// Function: yaml_emitter_anchor_node
static void
yaml_emitter_anchor_node(yaml_emitter_t *emitter, int index)
{
    yaml_node_t *node = emitter->document->nodes.start + index - 1;
    yaml_node_item_t *item;
    yaml_node_pair_t *pair;

    emitter->anchors[index-1].references ++;

    if (emitter->anchors[index-1].references == 1) {
        switch (node->type) {
            case YAML_SEQUENCE_NODE:
                for (item = node->data.sequence.items.start;
                        item < node->data.sequence.items.top; item ++) {
                    yaml_emitter_anchor_node(emitter, *item);
                }
                break;
            case YAML_MAPPING_NODE:
                for (pair = node->data.mapping.pairs.start;
                        pair < node->data.mapping.pairs.top; pair ++) {
                    yaml_emitter_anchor_node(emitter, pair->key);
                    yaml_emitter_anchor_node(emitter, pair->value);
                }
                break;
            default:
                break;
        }
    }

    else if (emitter->anchors[index-1].references == 2) {
        emitter->anchors[index-1].anchor = (++ emitter->last_anchor_id);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x1a8(%rdi), %rax
movslq %esi, %rcx
imulq $0x60, %rcx, %r14
addq (%rax), %r14
movq 0x198(%rdi), %rax
decl %ecx
movslq %ecx, %rcx
imulq $0xc, %rcx, %rcx
movl (%rax,%rcx), %edx
leal 0x1(%rdx), %esi
movl %esi, (%rax,%rcx)
cmpl $0x1, %edx
je 0x1537b
testl %edx, %edx
jne 0x1538d
movl -0x60(%r14), %eax
cmpl $0x3, %eax
je 0x15393
cmpl $0x2, %eax
jne 0x1538d
movq -0x50(%r14), %r15
cmpq -0x40(%r14), %r15
jae 0x1538d
movl (%r15), %esi
movq %rbx, %rdi
callq 0x15317
addq $0x4, %r15
jmp 0x15364
movl 0x1a0(%rbx), %edx
incl %edx
movl %edx, 0x1a0(%rbx)
movl %edx, 0x4(%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
movq -0x50(%r14), %r15
cmpq -0x40(%r14), %r15
jae 0x1538d
movl (%r15), %esi
movq %rbx, %rdi
callq 0x15317
movl 0x4(%r15), %esi
movq %rbx, %rdi
callq 0x15317
addq $0x8, %r15
jmp 0x15397
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32lc/KeccakP-800-opt32.c
// Function: KeccakP800_Initialize
void KeccakP800_Initialize(void *state)
{
    memset(state, 0, 100);
#ifdef KeccakP800_useLaneComplementing
    ((UINT32*)state)[ 1] = ~(UINT32)0;
    ((UINT32*)state)[ 2] = ~(UINT32)0;
    ((UINT32*)state)[ 8] = ~(UINT32)0;
    ((UINT32*)state)[12] = ~(UINT32)0;
    ((UINT32*)state)[17] = ~(UINT32)0;
    ((UINT32*)state)[20] = ~(UINT32)0;
#endif
}

// Assembly:
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, (%rdi)
vmovups %ymm0, 0x20(%rdi)
vmovups %ymm0, 0x40(%rdi)
andl $0x0, 0x60(%rdi)
orq $-0x1, 0x4(%rdi)
orl $-0x1, 0x20(%rdi)
orl $-0x1, 0x30(%rdi)
orl $-0x1, 0x44(%rdi)
orl $-0x1, 0x50(%rdi)
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32lc/KeccakP-800-opt32.c
// Function: KeccakP800_OverwriteBytes
void KeccakP800_OverwriteBytes(void *argState, const unsigned char *data, unsigned int offset, unsigned int length)
{
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
#ifdef KeccakP800_useLaneComplementing
    unsigned int sizeLeft = length;
    unsigned int lanePosition = offset/4;
    unsigned int offsetInLane = offset%4;
    const unsigned char *curData = data;
    UINT32 *state = (UINT32*)argState;

    if ((sizeLeft > 0) && (offsetInLane != 0)) {
        unsigned int bytesInLane = 4 - offsetInLane;
        unsigned char laneComplement = (unsigned char)KeccakP800LaneComplement[lanePosition];
        if (bytesInLane > sizeLeft)
            bytesInLane = sizeLeft;
        sizeLeft -= bytesInLane;
        do {
            *(((unsigned char *)&state[lanePosition] + offsetInLane)) = *curData++ ^ laneComplement;
            ++offsetInLane;
        }
        while ( --bytesInLane != 0);
        lanePosition++;
    }

    while(sizeLeft >= 4) {
        state[lanePosition] = READ32_UNALIGNED( curData ) ^ KeccakP800LaneComplement[lanePosition];
        sizeLeft -= 4;
        lanePosition++;
        curData += 4;
    }

    if (sizeLeft > 0) {
        unsigned char laneComplement = (unsigned char)KeccakP800LaneComplement[lanePosition];
        unsigned int i;
        for ( i = 0; i < sizeLeft; ++i ) {
            *((unsigned char *)&state[lanePosition] + i) = *curData++ ^ laneComplement;
        }
    }
#else
    memcpy((unsigned char*)argState+offset, data, length);
#endif
#else
#error "Not yet implemented"
#endif
}

// Assembly:
pushq %rbx
movl %edx, %eax
shrl $0x2, %eax
testl %ecx, %ecx
sete %r8b
andl $0x3, %edx
sete %r9b
orb %r8b, %r9b
jne 0x9508
movl $0x4, %r8d
subl %edx, %r8d
leal (,%rax,4), %r9d
movq 0xeb24(%rip), %r10      # 0x17ff0
movb (%r10,%r9), %r10b
cmpl %ecx, %r8d
movl %ecx, %r9d
cmovbl %r8d, %r9d
leal (%rdx,%rax,4), %edx
addq %rdi, %rdx
movl %ecx, %r11d
cmpq %r8, %r11
cmovbq %r11, %r8
xorl %r11d, %r11d
movb (%rsi,%r11), %bl
xorb %r10b, %bl
movb %bl, (%rdx,%r11)
incq %r11
cmpl %r11d, %r8d
jne 0x94ed
subl %r9d, %ecx
incl %eax
addq %r11, %rsi
movl %eax, %edx
leaq (%rdi,%rdx,4), %rax
shlq $0x2, %rdx
addq 0xead7(%rip), %rdx      # 0x17ff0
movl %ecx, %ecx
cmpl $0x4, %ecx
jb 0x9538
movl (%rdx), %edi
xorl (%rsi), %edi
movl %edi, (%rax)
addq $0x4, %rsi
addq $0x4, %rax
addq $0x4, %rdx
addq $-0x4, %rcx
jmp 0x951b
testl %ecx, %ecx
je 0x9557
movb (%rdx), %dl
xorl %edi, %edi
cmpq %rcx, %rdi
jae 0x9557
movb (%rsi,%rdi), %r8b
xorb %dl, %r8b
movb %r8b, (%rax)
incq %rdi
incq %rax
jmp 0x9540
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32lc/KeccakP-800-opt32.c
// Function: KeccakP800_ExtractBytes
void KeccakP800_ExtractBytes(const void *argState, unsigned char *data, unsigned int offset, unsigned int length)
{
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
#ifdef KeccakP800_useLaneComplementing
    unsigned int sizeLeft = length;
    unsigned int lanePosition = offset/4;
    unsigned int offsetInLane = offset%4;
    unsigned char *curData = data;
    const UINT32 *state = (const UINT32*)argState;
    const UINT32 *pLaneComplement;

    state += lanePosition;
    pLaneComplement = KeccakP800LaneComplement + lanePosition;
    if ((sizeLeft > 0) && (offsetInLane != 0)) {
        unsigned int bytesInLane = 4 - offsetInLane;
        UINT32  lane = (*state++ ^ *pLaneComplement++) >> (offsetInLane * 8);
        if (bytesInLane > sizeLeft)
            bytesInLane = sizeLeft;
        sizeLeft -= bytesInLane;
        do {
            *curData++ = (unsigned char)lane;
            lane >>= 8;
        }
        while ( --bytesInLane != 0);
        lanePosition++;
    }

    while(sizeLeft >= 4) {
        WRITE32_UNALIGNED( curData, *state++ ^ *pLaneComplement++ );
        sizeLeft -= 4;
        curData += 4;
    }

    if (sizeLeft > 0) {
        UINT32  lane = *state ^ *pLaneComplement;
        unsigned int i;
        for ( i = 0; i < sizeLeft; ++i ) {
            *curData++ = (unsigned char)lane;
            lane >>= 8;
        }
    }
#else
    memcpy(data, (unsigned char*)argState+offset, length);
#endif
#else
#error "Not yet implemented"
#endif
}

// Assembly:
movl %edx, %eax
andl $-0x4, %eax
addq %rax, %rdi
addq 0xda5a(%rip), %rax      # 0x17ff0
testl %ecx, %ecx
sete %r8b
andl $0x3, %edx
sete %r9b
orb %r8b, %r9b
jne 0xa5df
pushq $0x4
popq %r8
subl %edx, %r8d
movl (%rax), %r9d
xorl (%rdi), %r9d
shll $0x3, %edx
shrxl %edx, %r9d, %edx
cmpl %ecx, %r8d
cmovael %ecx, %r8d
movl %r8d, %r9d
movb %dl, (%rsi)
incq %rsi
shrl $0x8, %edx
decl %r9d
jne 0xa5c7
addq $0x4, %rdi
addq $0x4, %rax
subl %r8d, %ecx
xorl %edx, %edx
cmpl $0x4, %ecx
jb 0xa5fb
movl (%rax,%rdx), %r8d
xorl (%rdi,%rdx), %r8d
movl %r8d, (%rsi,%rdx)
addl $-0x4, %ecx
addq $0x4, %rdx
jmp 0xa5e1
testl %ecx, %ecx
je 0xa61b
movl (%rax,%rdx), %eax
xorl (%rdi,%rdx), %eax
xorl %edi, %edi
cmpl %ecx, %edi
jae 0xa61b
leaq (%rsi,%rdi), %r8
movb %al, (%r8,%rdx)
shrl $0x8, %eax
incq %rdi
jmp 0xa607
retq
// File: /workspace/github_c_makefile_star2_O2/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/controls.c
// Function: CheckKevKeys
void CheckKevKeys()
{
  int i = 0;
  tU32 *value;
  char s[128];

  value = KevKeyService();
  if (value[0] == 0) {
    return;
  }

  for (i = 0; gKev_keys[i].action_proc != 0; i++) {
    if (gKev_keys[i].code == value[0] && gKev_keys[i].code2 == value[1]) {
        break;
    }
  }

  if (gKev_keys[i].action_proc == 0) {
        return;
  }
  gKev_keys[i].action_proc(gKev_keys[i].num);
}

// Assembly:
pushq %rax
xorl %eax, %eax
callq 0x2528
movq (%rax), %rcx
testq %rcx, %rcx
je 0x23d2
leaq 0x8da5(%rip), %rdx      # 0xb158
movq -0x8(%rdx), %rsi
testq %rsi, %rsi
je 0x23d2
cmpq %rcx, -0x18(%rdx)
jne 0x23cc
movq -0x10(%rdx), %rdi
cmpq 0x8(%rax), %rdi
je 0x23d4
addq $0x20, %rdx
jmp 0x23b3
popq %rax
retq
movl (%rdx), %edi
popq %rax
jmpq *%rsi
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/errors.c
// Function: FatalError
void FatalError (int pStr_index, ...) {
	char the_str[1024];
	char temp_str[1024];
	char *sub_pt;
	char *sub_str;
	int i;
	va_list ap;
	sub_pt = temp_str;

	va_start(ap, pStr_index);

	int read_timer = 0;
	gError_code = 0x20000000 + read_timer;
	strcpy(the_str, gError_messages[pStr_index-1]);
	sub_pt = temp_str;

	for (i = 0; i < strlen(the_str); i++) {
		if (the_str[i] == '%') {
			sub_str = va_arg(ap, char*);
			StripCR(sub_str);
			strcpy(sub_pt, sub_str);
			sub_pt += strlen(sub_str);
		} else {
			*sub_pt = the_str[i];
			sub_pt++;
		}
	}
	*sub_pt = 0;
	va_end(ap);
	PDFatalError(temp_str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8d0, %rsp            # imm = 0x8D0
leaq 0x20(%rsp), %r10
movq %rsi, 0x8(%r10)
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x2440
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r10, 0x10(%rsp)
leaq 0x900(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
movl $0x20000000, 0x96be(%rip) # imm = 0x20000000
movslq %edi, %rax
leaq 0x924c(%rip), %rcx      # 0xb6c0
movq -0x8(%rcx,%rax,8), %rsi
leaq 0x4d0(%rsp), %rbx
movq %rbx, %rdi
callq 0x2070
leaq 0xd0(%rsp), %r14
xorl %r12d, %r12d
pushq $0x1
popq %r13
movq %rbx, %rdi
callq 0x20d0
cmpq %r12, %rax
jbe 0x2506
movb 0x4d0(%rsp,%r12), %al
cmpb $0x25, %al
jne 0x24ca
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x24d2
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x24e0
movb %al, (%r14)
movq %r13, %rax
jmp 0x24fe
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r15
movq %r15, %rdi
callq 0x274c
movq %r14, %rdi
movq %r15, %rsi
callq 0x2070
movq %r15, %rdi
callq 0x20d0
addq %rax, %r14
incq %r12
jmp 0x2498
movb $0x0, (%r14)
leaq 0xd0(%rsp), %rdi
callq 0x2c41
addq $0x8d0, %rsp            # imm = 0x8D0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/main.c
// Function: main
int main(int argc, const char *argv[]) {
  if (argc > 1) {
    if (strcmp("-test", argv[1]) == 0) {
      return UnityMain(argc, argv, Tests_Run); 
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jl 0x2729
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %rsi
leaq 0x4a49(%rip), %rdi      # 0x7169
callq 0x2160
testl %eax, %eax
je 0x2732
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3057(%rip), %rdx      # 0x5790
movl %ebp, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4fbc
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/utility.c
// Function: StripCR
void StripCR (char *s) {
  char *pos;
  pos = s;
  while (*pos != 0) {
    if (*pos == '\r' || *pos == '\n') {
      *pos = 0;
      break;
    }
    pos++;
  }
}

// Assembly:
movzbl (%rdi), %eax
testl %eax, %eax
je 0x2765
cmpl $0xd, %eax
je 0x2762
cmpl $0xa, %eax
je 0x2762
incq %rdi
jmp 0x274c
movb $0x0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/utility.c
// Function: EncodeFileWrapper
void EncodeFileWrapper (char *pThe_path) {
  int len = strlen(pThe_path);

  if (strcmp(&pThe_path[len - 4], ".TXT") == 0) {
    return;
  }
  if (strcmp(pThe_path, "DKEYMAP0.TXT") == 0) {
    return;
  }
  if (strcmp(pThe_path, "DKEYMAP1.TXT") == 0) {
    return;
  }
  if (strcmp(pThe_path, "DKEYMAP2.TXT") == 0) {
    return;
  }
  if (strcmp(pThe_path, "DKEYMAP3.TXT") == 0) {
    return;
  }
  if (strcmp(pThe_path, "KEYMAP_0.TXT") == 0) {
    return;
  }
  if (strcmp(pThe_path, "KEYMAP_1.TXT") == 0) {
    return;
  }
  if (strcmp(pThe_path, "KEYMAP_2.TXT") == 0) {
    return;
  }
  if (strcmp(pThe_path, "KEYMAP_3.TXT") == 0) {
    return;
  }
  if (strcmp(pThe_path, "OPTIONS.TXT") == 0) {
    return;
  }
  if (strcmp(pThe_path, "KEYNAMES.TXT") == 0) {
    return;
  }
  if (strcmp(pThe_path, "KEYMAP.TXT") == 0) {
    return;
  }
  if (strcmp(pThe_path, "PATHS.TXT") == 0) {
    return;
  }

  EncodeFile(pThe_path);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x20d0
addl $-0x4, %eax
movslq %eax, %rdi
addq %rbx, %rdi
leaq 0x49f8(%rip), %rsi      # 0x7177
callq 0x2160
testl %eax, %eax
je 0x288d
leaq 0x49dc(%rip), %rsi      # 0x716f
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x288d
leaq 0x49d2(%rip), %rsi      # 0x717c
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x288d
leaq 0x49c8(%rip), %rsi      # 0x7189
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x288d
leaq 0x49be(%rip), %rsi      # 0x7196
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x288d
leaq 0x49b4(%rip), %rsi      # 0x71a3
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x288d
leaq 0x49aa(%rip), %rsi      # 0x71b0
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x288d
leaq 0x49a4(%rip), %rsi      # 0x71bd
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x288d
leaq 0x499e(%rip), %rsi      # 0x71ca
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x288d
leaq 0x4998(%rip), %rsi      # 0x71d7
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x288d
leaq 0x4991(%rip), %rsi      # 0x71e3
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x288d
leaq 0x498b(%rip), %rsi      # 0x71f0
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x288d
leaq 0x4983(%rip), %rsi      # 0x71fb
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x288d
movq %rbx, %rdi
popq %rbx
jmp 0x288f
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/utility.c
// Function: EncodeLine2
void EncodeLine2(char *pS)
{
  int len;
  int seed;
  int i;
  int count;
  unsigned char c;
  char *key;

  len = strlen(pS);
  count = 0;
  key = gLong_key;
  while ( len > 0 && (pS[len - 1] == 13 || pS[len - 1] == 10))
  {
    --len;
    pS[len] = 0;
  }

  seed = len % 16;
  
  for ( i = 0; i < len; ++pS )
  {
    if ( count == 2 )
      key = gOther_long_key;
    if ( *pS == '/' )
    {
      ++count;
    }
    else {
      count = 0;
    }
    if ( *pS == '\t' ) {
      *pS = 0x80;
    }
    c = *pS - 0x20;
    if (!(c & 0x80)) {
      c = c ^ (key[seed] & 0x7F);
      c += 0x20;
    }
    seed += 7;
    seed = seed % 16;
    
    if ( c == 0x80 ) {
      c = '\t';
    }
    *pS = c;
    ++i;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x20d0
movl %eax, %ecx
movl %eax, %edx
sarl $0x1f, %edx
andl %eax, %edx
testl %ecx, %ecx
jle 0x2a88
movzbl -0x1(%rbx,%rcx), %eax
cmpl $0xd, %eax
je 0x2a7b
cmpl $0xa, %eax
jne 0x2a86
decq %rcx
movl %ecx, %eax
movb $0x0, (%rbx,%rax)
jmp 0x2a68
movl %ecx, %edx
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %esi
cmovgl %edx, %esi
leaq 0x9035(%rip), %rdi      # 0xbad0
pushq $0x10
popq %r8
leaq 0x903a(%rip), %r9       # 0xbae0
pushq $0x9
popq %r10
xorl %r11d, %r11d
xorl %ebp, %ebp
movl %edx, %eax
cltd
idivl %r8d
cmpl %r11d, %esi
je 0x2b07
cmpl $0x2, %ebp
cmoveq %r9, %rdi
movb (%rbx,%r11), %al
incl %ebp
cmpb $0x2f, %al
cmovnel %ecx, %ebp
cmpb $0x9, %al
jne 0x2ad9
movb $-0x80, (%rbx,%r11)
movb $0x60, %al
jmp 0x2add
addb $-0x20, %al
js 0x2af2
movslq %edx, %r14
movb (%rdi,%r14), %r14b
andb $0x7f, %r14b
xorb %al, %r14b
addb $0x20, %r14b
movl %r14d, %eax
addl $0x7, %edx
cmpb $-0x80, %al
movzbl %al, %eax
cmovel %r10d, %eax
movb %al, (%rbx,%r11)
incq %r11
jmp 0x2aaf
popq %rbx
popq %r14
popq %rbp
retq