LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
je 0x13ac7
leaq 0x5d7d(%rip), %rsi      # 0x19838
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
jmp 0x13aee
movq %r14, %rdi
callq 0x13e0d
testl %eax, %eax
je 0x13b63
leaq 0x5d5a(%rip), %rsi      # 0x19838
movq %r14, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x13c6a
testl %eax, %eax
je 0x13b63
movq 0xa0(%r14), %rax
cmpq 0x98(%r14), %rax
jne 0x13b25
leaq 0xa0(%r14), %rsi
leaq 0x98(%r14), %rdx
leaq 0x90(%r14), %rdi
callq 0x20e0
testl %eax, %eax
je 0x13b5c
movq 0xa0(%r14), %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
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14371
movl $0x1, (%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x13bb3
movl %ecx, %ebp
movq (%r12), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
je 0x13c3f
addq $0x10, %r12
cmpq %r13, %r12
jne 0x13b96
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 0x13c27
leaq 0xf8(%rbx), %r12
movq 0xf8(%rbx), %rax
cmpq 0xf0(%rbx), %rax
jne 0x13c0d
leaq 0xe8(%rbx), %rdi
leaq 0xf0(%rbx), %rdx
movq %r12, %rsi
callq 0x20e0
testl %eax, %eax
je 0x13c27
movq (%r12), %rax
leaq 0x10(%rax), %rcx
movq %rcx, (%r12)
movq %r14, (%rax)
movq %r15, 0x8(%rax)
movl $0x1, %eax
jmp 0x13c5b
movl $0x1, (%rbx)
movq %r14, %rdi
callq 0x2140
movq %r15, %rdi
callq 0x2140
jmp 0x13c59
movl $0x1, %eax
testl %ebp, %ebp
jne 0x13c5b
movl $0x7, (%rbx)
leaq 0x5c2c(%rip), %rax      # 0x19881
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_O1/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 0x13cd0
cmpl $0x0, 0x120(%rbx)
jne 0x13cd0
movq 0x48(%rbx), %rax
addq $0x5, %rax
cmpq 0x40(%rbx), %rax
jb 0x13cbb
movq %rbx, %rdi
callq 0x2190
testl %eax, %eax
je 0x13dfc
movq 0x48(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x48(%rbx)
movb $0x20, (%rax)
incl 0x11c(%rbx)
testq %r12, %r12
je 0x13dca
addq %r15, %r12
movq 0x48(%rbx), %rax
addq $0x5, %rax
cmpq 0x40(%rbx), %rax
jb 0x13cfa
movq %rbx, %rdi
callq 0x2190
testl %eax, %eax
je 0x13dfc
movb (%r15), %al
testb %al, %al
js 0x13d09
incq %r15
jmp 0x13dad
movzbl %al, %ecx
movl %ecx, %edx
andl $-0x20, %edx
cmpl $0xc0, %edx
jne 0x13d31
movq 0x48(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%rbx)
movb %al, (%rcx)
movb 0x1(%r15), %al
addq $0x2, %r15
jmp 0x13dad
movl %ecx, %edx
andl $-0x10, %edx
cmpl $0xe0, %edx
jne 0x13d68
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 0x13dad
andl $-0x8, %ecx
cmpl $0xf0, %ecx
jne 0x13dbb
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 0x13cdc
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 0x13dfe
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_O1/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 0x13e31
cmpl %ebp, 0x11c(%rbx)
jle 0x13e66
movq 0x48(%rbx), %rax
addq $0x5, %rax
cmpq 0x40(%rbx), %rax
jb 0x13e4f
movq %rbx, %rdi
callq 0x2190
testl %eax, %eax
je 0x13f01
movl 0x8c(%rbx), %eax
cmpl $0x1, %eax
je 0x13e86
cmpl $0x3, %eax
je 0x13e73
cmpl $0x2, %eax
je 0x13e82
jmp 0x13e96
jne 0x13ea6
cmpl $0x0, 0x120(%rbx)
jne 0x13ea6
jmp 0x13e31
movq 0x48(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x48(%rbx)
movb $0xd, (%rax)
movb $0xa, %al
jmp 0x13e88
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)
cmpl %ebp, 0x11c(%rbx)
jge 0x13ee9
movq 0x48(%rbx), %rax
addq $0x5, %rax
cmpq 0x40(%rbx), %rax
jb 0x13ec8
movq %rbx, %rdi
callq 0x2190
testl %eax, %eax
je 0x13f01
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 0x13eae
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x120(%rbx)
movl $0x1, %eax
jmp 0x13f03
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x13f55
movq 0x48(%r14), %rax
addq $0x5, %rax
cmpq 0x40(%r14), %rax
jb 0x13f3f
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
je 0x14062
movq 0x48(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x48(%r14)
movb $0x20, (%rax)
incl 0x11c(%r14)
testq %rbx, %rbx
je 0x14050
addq %r15, %rbx
movq 0x48(%r14), %rax
addq $0x5, %rax
cmpq 0x40(%r14), %rax
jb 0x13f7f
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
je 0x14062
movb (%r15), %al
testb %al, %al
js 0x13f8e
incq %r15
jmp 0x14032
movzbl %al, %ecx
movl %ecx, %edx
andl $-0x20, %edx
cmpl $0xc0, %edx
jne 0x13fb6
movq 0x48(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%r14)
movb %al, (%rcx)
movb 0x1(%r15), %al
addq $0x2, %r15
jmp 0x14032
movl %ecx, %edx
andl $-0x10, %edx
cmpl $0xe0, %edx
jne 0x13fed
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 0x14032
andl $-0x8, %ecx
cmpl $0xf0, %ecx
jne 0x14040
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 0x13f61
movq $0x0, 0x120(%r14)
movl $0x1, %eax
jmp 0x14064
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x166d4
movq %rdi, %r14
cmpl $0x0, 0x140(%rdi)
leaq 0x38d8(%rip), %rax      # 0x19e6a
leaq 0x38cf(%rip), %rsi      # 0x19e68
cmoveq %rax, %rsi
xorl %ebx, %ebx
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x13c6a
testl %eax, %eax
je 0x166d9
movq 0x138(%r14), %r15
testq %r15, %r15
je 0x166c9
movq 0x130(%r14), %r12
addq %r12, %r15
movq 0x48(%r14), %rax
addq $0x5, %rax
cmpq 0x40(%r14), %rax
jb 0x165ee
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
je 0x166d9
movb (%r12), %al
testb %al, %al
js 0x165fe
incq %r12
jmp 0x166ab
movzbl %al, %ecx
movl %ecx, %edx
andl $-0x20, %edx
cmpl $0xc0, %edx
jne 0x1662a
movq 0x48(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%r14)
movb %al, (%rcx)
movb 0x1(%r12), %al
addq $0x2, %r12
jmp 0x166ab
movl %ecx, %edx
andl $-0x10, %edx
cmpl $0xe0, %edx
jne 0x16663
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 0x166ab
andl $-0x8, %ecx
cmpl $0xf0, %ecx
jne 0x166b9
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 0x165d0
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_O1/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 0x16735
movq 0x150(%rbx), %rdx
movq %rbx, %rdi
callq 0x13f0a
testl %eax, %eax
je 0x167a2
movq 0x158(%rbx), %rsi
testq %rsi, %rsi
je 0x1679b
movq 0x160(%rbx), %rdx
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x1406a
testl %eax, %eax
jne 0x1679b
jmp 0x167a4
cmpq $0x0, 0x158(%rbx)
je 0x1679b
testq %rsi, %rsi
jne 0x166f9
leaq 0x374e(%rip), %rsi      # 0x19e99
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x13c6a
testl %eax, %eax
je 0x167a4
movq 0x158(%rbx), %rsi
movq 0x160(%rbx), %rdx
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x1406a
testl %eax, %eax
je 0x167a4
leaq 0x309a(%rip), %rsi      # 0x19822
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x13c6a
jmp 0x1672f
movl $0x1, %ebp
jmp 0x167a4
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq 0xe0(%rdi), %rax
cmpq 0xd8(%rdi), %rax
jne 0x167e7
leaq 0xe0(%rbx), %rsi
leaq 0xd8(%rbx), %rdx
leaq 0xd0(%rbx), %rdi
callq 0x20e0
testl %eax, %eax
je 0x1682f
movl 0x100(%rbx), %eax
movq 0xe0(%rbx), %rcx
leaq 0x4(%rcx), %rdx
movq %rdx, 0xe0(%rbx)
movl %eax, (%rcx)
movl 0x100(%rbx), %ecx
testl %ecx, %ecx
js 0x16822
movl $0x1, %eax
testl %ebp, %ebp
jne 0x16846
addl 0x80(%rbx), %ecx
movl %ecx, 0x100(%rbx)
jmp 0x16846
testl %r14d, %r14d
je 0x16839
movl 0x80(%rbx), %eax
jmp 0x1683b
movl $0x1, (%rbx)
xorl %eax, %eax
jmp 0x16846
xorl %eax, %eax
movl %eax, 0x100(%rbx)
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16b66
movq %rax, %rcx
addq %r14, %rcx
movq %r14, %rdx
movzbl (%rdx), %esi
leal -0x30(%rsi), %edi
cmpb $0xa, %dil
jb 0x16afd
movl %esi, %edi
andb $-0x21, %dil
addb $-0x41, %dil
cmpb $0x1a, %dil
jb 0x16afd
cmpl $0x2d, %esi
je 0x16afd
cmpl $0x5f, %esi
jne 0x16b78
movl $0x1, %edi
testb %sil, %sil
jns 0x16b43
movl %esi, %r8d
andl $-0x20, %r8d
movl $0x2, %edi
cmpl $0xc0, %r8d
je 0x16b43
movl %esi, %r8d
andl $-0x10, %r8d
movl $0x3, %edi
cmpl $0xe0, %r8d
je 0x16b43
andl $-0x8, %esi
xorl %edi, %edi
cmpl $0xf0, %esi
sete %dil
shll $0x2, %edi
addq %rdi, %rdx
cmpq %rcx, %rdx
jne 0x16ad7
movq %r14, 0x130(%rbx)
movq %rax, 0x138(%rbx)
movl %ebp, 0x140(%rbx)
movl $0x1, %eax
jmp 0x16b98
testl %ebp, %ebp
leaq 0x3373(%rip), %rax      # 0x19ee2
leaq 0x334e(%rip), %rcx      # 0x19ec4
jmp 0x16b88
testl %ebp, %ebp
leaq 0x33b8(%rip), %rax      # 0x19f39
leaq 0x3379(%rip), %rcx      # 0x19f01
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_O1/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 0x16c26
movq %rax, %r14
movq 0xe8(%rbx), %rbp
movq %rbx, 0x10(%rsp)
movq 0xf8(%rbx), %rbx
cmpq %rbx, %rbp
je 0x16c0c
movq 0x8(%rbp), %r13
movq %r13, %rdi
callq 0x20d0
movq %r14, %r15
subq %rax, %r15
jbe 0x16c06
movq %rax, %r12
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x2050
testl %eax, %eax
je 0x16c3b
addq $0x10, %rbp
jmp 0x16bd6
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x158(%rax)
movq %r14, 0x160(%rax)
jmp 0x16c6d
movl $0x7, (%rbx)
leaq 0x333f(%rip), %rax      # 0x19f72
movq %rax, 0x8(%rbx)
xorl %eax, %eax
jmp 0x16c72
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)
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x16d01
movq %rdi, %rbx
cmpl $0x0, 0x190(%rdi)
jne 0x16d20
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movq $0x0, 0x60(%rsi)
movl $0x1, (%rsi)
movl $0x0, 0x8(%rsi)
movups %xmm0, 0x38(%rsi)
movups %xmm0, 0x48(%rsi)
movups %xmm0, 0x58(%rsi)
movq %rbx, %rdi
callq 0x20f0
testl %eax, %eax
je 0x16cf9
movl $0x1, 0x190(%rbx)
movl $0x1, %eax
jmp 0x16cfb
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
retq
leaq 0x14d5(%rip), %rdi      # 0x181dd
leaq 0x327f(%rip), %rsi      # 0x19f8e
leaq 0x3281(%rip), %rcx      # 0x19f97
movl $0x43, %edx
callq 0x2100
leaq 0x3298(%rip), %rdi      # 0x19fbf
leaq 0x3260(%rip), %rsi      # 0x19f8e
leaq 0x3262(%rip), %rcx      # 0x19f97
movl $0x44, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 0x16dc6
movq %rdi, %r14
cmpl $0x0, 0x190(%rdi)
je 0x16de5
movl $0x1, %ebx
cmpl $0x0, 0x194(%r14)
jne 0x16dbc
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movq $0x0, 0x60(%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 0x16dba
movl $0x1, 0x194(%r14)
jmp 0x16dbc
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x1410(%rip), %rdi      # 0x181dd
leaq 0x31ba(%rip), %rsi      # 0x19f8e
leaq 0x31f5(%rip), %rcx      # 0x19fd0
movl $0x5b, %edx
callq 0x2100
leaq 0x31d4(%rip), %rdi      # 0x19fc0
leaq 0x319b(%rip), %rsi      # 0x19f8e
leaq 0x31d6(%rip), %rcx      # 0x19fd0
movl $0x5c, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1a8(%rdi), %r15
cmpq $0x0, 0x198(%rdi)
movq 0x1a8(%rdi), %rdi
je 0x170a5
movq (%rdi), %rax
cmpq 0x10(%rdi), %rax
jae 0x170ac
movl $0x8, %r12d
movl $0x60, %r13d
movl (%rax), %ebp
movq 0x10(%rax), %r14
movq 0x198(%rbx), %rcx
cmpl $0x0, (%rcx,%r12)
je 0x1704a
cmpl $0x2, %ebp
je 0x17067
jmp 0x17072
movq 0x8(%rax), %rdi
callq 0x2140
cmpl $0x2, %ebp
je 0x17067
cmpl $0x1, %ebp
jne 0x17072
movq %r14, %rdi
callq 0x2140
jmp 0x17043
movq %r14, %rdi
callq 0x2140
xorl %r14d, %r14d
cmpl $0x3, %ebp
jne 0x1707f
movq %r14, %rdi
callq 0x2140
movq (%r15), %rcx
movq (%rcx), %rdi
leaq (%rdi,%r13), %rax
addq $0xc, %r12
leaq (%rdi,%r13), %rdx
addq $0x60, %rdx
addq $0x60, %r13
addq $-0x60, %rdx
cmpq 0x10(%rcx), %rdx
jb 0x1702f
jmp 0x170af
callq 0x2110
jmp 0x170e5
movq %rax, %rdi
callq 0x2140
movq 0x1a8(%rbx), %rax
xorl %r14d, %r14d
movq %r14, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq 0x198(%rbx), %rdi
callq 0x2140
movq %r14, 0x198(%rbx)
movl $0x0, 0x1a0(%rbx)
movq $0x0, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mijallen[P]SimpleHTTPServer/lib/libyaml/src/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
leaq (%rcx,%rcx,2), %r14
shlq $0x5, %r14
addq (%rax), %r14
movq 0x198(%rdi), %rax
decl %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movl (%rax,%rcx,4), %edx
leal 0x1(%rdx), %esi
movl %esi, (%rax,%rcx,4)
cmpl $0x1, %edx
je 0x17163
testl %edx, %edx
jne 0x17175
movl -0x60(%r14), %eax
cmpl $0x3, %eax
je 0x1717b
cmpl $0x2, %eax
jne 0x17175
movq -0x50(%r14), %r15
cmpq -0x40(%r14), %r15
jae 0x17175
movl (%r15), %esi
movq %rbx, %rdi
callq 0x170fb
addq $0x4, %r15
jmp 0x1714c
movl 0x1a0(%rbx), %edx
incl %edx
movl %edx, 0x1a0(%rbx)
movl %edx, 0x4(%rax,%rcx,4)
popq %rbx
popq %r14
popq %r15
retq
movq -0x50(%r14), %r15
cmpq -0x40(%r14), %r15
jae 0x17175
movl (%r15), %esi
movq %rbx, %rdi
callq 0x170fb
movl 0x4(%r15), %esi
movq %rbx, %rdi
callq 0x170fb
addq $0x8, %r15
jmp 0x1717f
// File: /workspace/github_c_makefile_star2_O1/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)
movl $0x0, 0x60(%rdi)
movq $-0x1, 0x4(%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x20(%rdi)
movl %eax, 0x30(%rdi)
movl %eax, 0x44(%rdi)
movl %eax, 0x50(%rdi)
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9a7a
movl $0x4, %r8d
subl %edx, %r8d
leal (,%rax,4), %r9d
movq 0xd5b2(%rip), %r10      # 0x16ff0
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 0x9a5f
subl %r9d, %ecx
incl %eax
addq %r11, %rsi
cmpl $0x4, %ecx
jb 0x9aa2
movl %eax, %eax
movq 0xd568(%rip), %rdx      # 0x16ff0
movl (%rdx,%rax,4), %r8d
xorl (%rsi), %r8d
movl %r8d, (%rdi,%rax,4)
addl $-0x4, %ecx
incq %rax
addq $0x4, %rsi
cmpl $0x3, %ecx
ja 0x9a88
testl %ecx, %ecx
je 0x9acd
movl %eax, %edx
movq 0xd541(%rip), %rax      # 0x16ff0
movb (%rax,%rdx,4), %al
leaq (%rdi,%rdx,4), %rdx
movl %ecx, %ecx
xorl %edi, %edi
movb (%rsi,%rdi), %r8b
xorb %al, %r8b
movb %r8b, (%rdx,%rdi)
incq %rdi
cmpq %rdi, %rcx
jne 0x9aba
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc44c(%rip), %rax      # 0x16ff0
testl %ecx, %ecx
sete %r8b
andl $0x3, %edx
sete %r9b
orb %r8b, %r9b
jne 0xabef
movl $0x4, %r8d
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 0xabd7
addq $0x4, %rdi
addq $0x4, %rax
subl %r8d, %ecx
cmpl $0x4, %ecx
jb 0xac0e
movl (%rax), %edx
xorl (%rdi), %edx
addq $0x4, %rax
addq $0x4, %rdi
movl %edx, (%rsi)
addl $-0x4, %ecx
addq $0x4, %rsi
cmpl $0x3, %ecx
ja 0xabf4
testl %ecx, %ecx
je 0xac27
movl (%rax), %eax
xorl (%rdi), %eax
movl %ecx, %ecx
xorl %edx, %edx
movb %al, (%rsi,%rdx)
shrl $0x8, %eax
incq %rdx
cmpl %edx, %ecx
jne 0xac1a
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2598
movq (%rax), %rdx
testq %rdx, %rdx
je 0x242f
movq 0x8d59(%rip), %rcx      # 0xb150
testq %rcx, %rcx
sete %dil
je 0x242f
leaq 0x8d39(%rip), %rsi      # 0xb140
cmpq %rdx, (%rsi)
jne 0x2416
movq 0x8(%rsi), %r8
cmpq 0x8(%rax), %r8
je 0x2429
movq 0x30(%rsi), %rcx
addq $0x20, %rsi
testq %rcx, %rcx
sete %dil
jne 0x2407
jmp 0x242f
testb $0x1, %dil
je 0x2431
popq %rax
retq
movl 0x18(%rsi), %edi
popq %rax
jmpq *%rcx
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x8d8, %rsp            # imm = 0x8D8
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 0x249a
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, 0x9664(%rip) # imm = 0x20000000
movslq %edi, %rax
leaq 0x91f2(%rip), %rcx      # 0xb6c0
movq -0x8(%rcx,%rax,8), %rsi
leaq 0x4d0(%rsp), %rbx
movq %rbx, %rdi
callq 0x2070
cmpb $0x0, (%rbx)
je 0x256e
leaq 0xd0(%rsp), %rbx
xorl %r12d, %r12d
leaq 0x4d0(%rsp), %r14
movb 0x4d0(%rsp,%r12), %al
cmpb $0x25, %al
jne 0x2524
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x252d
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x253b
movb %al, (%rbx)
movl $0x1, %eax
jmp 0x2559
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r15
movq %r15, %rdi
callq 0x27c8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2070
movq %r15, %rdi
callq 0x20d0
addq %rax, %rbx
incq %r12
movq %r14, %rdi
callq 0x20d0
cmpq %r12, %rax
ja 0x24ff
jmp 0x2576
leaq 0xd0(%rsp), %rbx
movb $0x0, (%rbx)
leaq 0xd0(%rsp), %rdi
callq 0x2d09
addq $0x8d8, %rsp            # imm = 0x8D8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x27a5
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %rsi
leaq 0x59cd(%rip), %rdi      # 0x8169
callq 0x2160
testl %eax, %eax
je 0x27ae
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3897(%rip), %rdx      # 0x604c
movl %ebp, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x56b8
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x27e1
cmpl $0xd, %eax
je 0x27de
cmpl $0xa, %eax
je 0x27de
incq %rdi
jmp 0x27c8
movb $0x0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x597c(%rip), %rsi      # 0x8177
callq 0x2160
testl %eax, %eax
je 0x2909
leaq 0x5960(%rip), %rsi      # 0x816f
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x2909
leaq 0x5956(%rip), %rsi      # 0x817c
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x2909
leaq 0x594c(%rip), %rsi      # 0x8189
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x2909
leaq 0x5942(%rip), %rsi      # 0x8196
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x2909
leaq 0x5938(%rip), %rsi      # 0x81a3
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x2909
leaq 0x592e(%rip), %rsi      # 0x81b0
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x2909
leaq 0x5928(%rip), %rsi      # 0x81bd
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x2909
leaq 0x5922(%rip), %rsi      # 0x81ca
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x2909
leaq 0x591c(%rip), %rsi      # 0x81d7
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x2909
leaq 0x5915(%rip), %rsi      # 0x81e3
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x2909
leaq 0x590f(%rip), %rsi      # 0x81f0
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x2909
leaq 0x5907(%rip), %rsi      # 0x81fb
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x2909
movq %rbx, %rdi
popq %rbx
jmp 0x290b
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
testl %eax, %eax
jle 0x2b24
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movzbl -0x1(%rbx,%rax), %ecx
cmpl $0xd, %ecx
je 0x2b10
cmpl $0xa, %ecx
jne 0x2b24
movb $0x0, -0x1(%rbx,%rax)
leaq -0x1(%rax), %rcx
cmpq $0x1, %rax
movq %rcx, %rax
jg 0x2b01
xorl %eax, %eax
testl %eax, %eax
jle 0x2bb7
movl %eax, %ecx
xorl %edx, %edx
leaq 0x8f99(%rip), %rsi      # 0xbad0
leaq 0x8fa2(%rip), %rdi      # 0xbae0
movl $0x9, %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
leal 0xf(%rax), %r11d
testl %eax, %eax
cmovnsl %eax, %r11d
cmpl $0x2, %r10d
cmoveq %rdi, %rsi
movb (%rbx,%r9), %bpl
incl %r10d
cmpb $0x2f, %bpl
cmovnel %edx, %r10d
cmpb $0x9, %bpl
jne 0x2b76
movb $-0x80, (%rbx,%r9)
andl $-0x10, %r11d
subl %r11d, %eax
movb (%rbx,%r9), %r11b
addb $-0x20, %r11b
js 0x2b9c
movslq %eax, %r14
movb (%rsi,%r14), %bpl
andb $0x7f, %bpl
xorb %r11b, %bpl
addb $0x20, %bpl
movl %ebp, %r11d
addl $0x7, %eax
cmpb $-0x80, %r11b
movzbl %r11b, %r11d
cmovel %r8d, %r11d
movb %r11b, (%rbx,%r9)
incq %r9
cmpl %r9d, %ecx
jne 0x2b4a
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/utility.c
// Function: DecodeLine2
void DecodeLine2(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; i++)
  {
    c = pS[i];
    if (i >= 2) {
      if (pS[i - 1] == '/' && pS[i - 2] == '/') {
        key = gOther_long_key;
      }
    }
    if (gEncryption_method == 1) 
    { 
      if ( c == '\t' ) {
        c = 0x80;
      }
      c -= 0x20;
      if (!(c & 0x80)) {
        c = (c ^ key[seed]) & 0x7f;
        c += 0x20;
      }
      seed += 7;
      seed = seed % 16;
      
      if ( c == 0x80 ) {
        c = '\t';
      }
    }
    else {
      if (c == '\t') {
        c = 0x9f;
      }
      c -= 0x20;
      c = (c ^ key[seed]) & 0x7f;
      c += 0x20;

      seed += 7;
      seed = seed % 16;
      
      if ( c == 0x9f ) {
        c = '\t';
      }
    }
    pS[i] = c;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x20d0
testl %eax, %eax
jle 0x2bf4
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movzbl -0x1(%rbx,%rax), %ecx
cmpl $0xd, %ecx
je 0x2be0
cmpl $0xa, %ecx
jne 0x2bf4
movb $0x0, -0x1(%rbx,%rax)
leaq -0x1(%rax), %rcx
cmpq $0x1, %rax
movq %rcx, %rax
jg 0x2bd1
xorl %eax, %eax
testl %eax, %eax
jle 0x2cc2
movl %eax, %ecx
leaq 0x8ecb(%rip), %rdx      # 0xbad0
xorl %esi, %esi
leaq 0x8ed2(%rip), %rdi      # 0xbae0
movl $0x60, %r8d
movl $0x9, %r9d
movl $0x7f, %r10d
leal 0xf(%rax), %r11d
testl %eax, %eax
cmovnsl %eax, %r11d
cmpq $0x2, %rsi
jb 0x2c40
cmpb $0x2f, -0x1(%rbx,%rsi)
jne 0x2c40
cmpb $0x2f, -0x2(%rbx,%rsi)
cmoveq %rdi, %rdx
andl $-0x10, %r11d
subl %r11d, %eax
movb (%rbx,%rsi), %r11b
cmpl $0x1, 0x8e6e(%rip)      # 0xbac0
jne 0x2c84
leal -0x20(%r11), %ebp
cmpb $0x9, %r11b
movzbl %bpl, %r11d
cmovel %r8d, %r11d
testb %r11b, %r11b
js 0x2c7e
movslq %eax, %r14
movb (%rdx,%r14), %bpl
andb $0x7f, %bpl
xorb %r11b, %bpl
addb $0x20, %bpl
movl %ebp, %r11d
cmpb $-0x80, %r11b
jmp 0x2ca7
leal 0x60(%r11), %ebp
cmpb $0x9, %r11b
movzbl %bpl, %r11d
cmovel %r10d, %r11d
movslq %eax, %r14
xorb (%rdx,%r14), %r11b
andb $0x7f, %r11b
addb $0x20, %r11b
cmpb $-0x61, %r11b
movzbl %r11b, %r11d
cmovel %r9d, %r11d
addl $0x7, %eax
movb %r11b, (%rbx,%rsi)
incq %rsi
cmpq %rsi, %rcx
jne 0x2c20
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/log/zf_log.c
// Function: zf_log_write_mem_d
void _zf_log_write_mem_d(
        const char *const func, const char *const file, const unsigned line,
        const int lvl, const char *const tag,
        const void *const d, const unsigned d_sz,
        const char *const fmt, ...)
{
    const src_location src = {func, file, line};
    const mem_block mem = {d, d_sz};
    va_list va;
    va_start(va, fmt);
    _zf_log_write_imp(&global_spec, &src, &mem, lvl, tag, fmt, va);
    va_end(va);
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
testb %al, %al
je 0x3c78
movaps %xmm0, 0x80(%rsp)
movaps %xmm1, 0x90(%rsp)
movaps %xmm2, 0xa0(%rsp)
movaps %xmm3, 0xb0(%rsp)
movaps %xmm4, 0xc0(%rsp)
movaps %xmm5, 0xd0(%rsp)
movaps %xmm6, 0xe0(%rsp)
movaps %xmm7, 0xf0(%rsp)
movq 0x118(%rsp), %rax
movl 0x110(%rsp), %r11d
leaq 0x38(%rsp), %r10
movq %rdi, (%r10)
movq %rsi, 0x8(%r10)
movl %edx, 0x10(%r10)
leaq 0x10(%rsp), %rdx
movq %r9, (%rdx)
movl %r11d, 0x8(%rdx)
leaq 0x50(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movq %rsi, 0x10(%rdi)
leaq 0x120(%rsp), %rsi
movq %rsi, 0x8(%rdi)
movabsq $0x3000000030, %rsi     # imm = 0x3000000030
movq %rsi, (%rdi)
movq %rdi, (%rsp)
leaq 0x70e2(%rip), %rdi      # 0xadb8
movq %r10, %rsi
movq %rax, %r9
callq 0x2e0d
addq $0x108, %rsp            # imm = 0x108
retq
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/log/zf_log.c
// Function: zf_log_write_mem_aux_d
void _zf_log_write_mem_aux_d(
        const char *const func, const char *const file, const unsigned line,
        const zf_log_spec *const log, const int lvl, const char *const tag,
        const void *const d, const unsigned d_sz,
        const char *const fmt, ...)
{
    const src_location src = {func, file, line};
    const mem_block mem = {d, d_sz};
    va_list va;
    va_start(va, fmt);
    _zf_log_write_imp(log, &src, &mem, lvl, tag, fmt, va);
    va_end(va);
}

// Assembly:
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %r9, %r10
testb %al, %al
je 0x3d38
movaps %xmm0, 0x80(%rsp)
movaps %xmm1, 0x90(%rsp)
movaps %xmm2, 0xa0(%rsp)
movaps %xmm3, 0xb0(%rsp)
movaps %xmm4, 0xc0(%rsp)
movaps %xmm5, 0xd0(%rsp)
movaps %xmm6, 0xe0(%rsp)
movaps %xmm7, 0xf0(%rsp)
movq 0x120(%rsp), %r9
movl 0x118(%rsp), %r11d
movq 0x110(%rsp), %rbx
leaq 0x38(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
movl %edx, 0x10(%rax)
leaq 0x10(%rsp), %rdx
movq %rbx, (%rdx)
movl %r11d, 0x8(%rdx)
leaq 0x50(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movq %rsi, 0x10(%rdi)
leaq 0x128(%rsp), %rsi
movq %rsi, 0x8(%rdi)
movabsq $0x3000000030, %rsi     # imm = 0x3000000030
movq %rsi, (%rdi)
movq %rdi, (%rsp)
movq %rcx, %rdi
movq %rax, %rsi
movl %r8d, %ecx
movq %r10, %r8
callq 0x2e0d
addq $0x100, %rsp            # imm = 0x100
popq %rbx
retq