LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0xd8(%rcx), %rax
jne 0x22a8d
movq -0x10(%rbp), %rdi
addq $0xd0, %rdi
movq -0x10(%rbp), %rsi
addq $0xd0, %rsi
addq $0x10, %rsi
movq -0x10(%rbp), %rdx
addq $0xd0, %rdx
addq $0x8, %rdx
callq 0x20e0
cmpl $0x0, %eax
je 0x22aba
movq -0x10(%rbp), %rax
movl 0x100(%rax), %ecx
movq -0x10(%rbp), %rdx
movq 0xe0(%rdx), %rax
movq %rax, %rsi
addq $0x4, %rsi
movq %rsi, 0xe0(%rdx)
movl %ecx, (%rax)
movb $0x1, %al
testb $0x1, %al
jne 0x22ad3
jmp 0x22aca
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0x22ad3
movl $0x0, -0x4(%rbp)
jmp 0x22b34
movq -0x10(%rbp), %rax
cmpl $0x0, 0x100(%rax)
jge 0x22b0b
cmpl $0x0, -0x14(%rbp)
je 0x22af5
movq -0x10(%rbp), %rax
movl 0x80(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x22afc
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0x22afc
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x100(%rax)
jmp 0x22b2d
cmpl $0x0, -0x18(%rbp)
jne 0x22b2b
movq -0x10(%rbp), %rax
movl 0x80(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x100(%rax), %ecx
movl %ecx, 0x100(%rax)
jmp 0x22b2d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_process_scalar
static int
yaml_emitter_process_scalar(yaml_emitter_t *emitter)
{
    switch (emitter->scalar_data.style)
    {
        case YAML_PLAIN_SCALAR_STYLE:
            return yaml_emitter_write_plain_scalar(emitter,
                    emitter->scalar_data.value, emitter->scalar_data.length,
                    !emitter->simple_key_context);

        case YAML_SINGLE_QUOTED_SCALAR_STYLE:
            return yaml_emitter_write_single_quoted_scalar(emitter,
                    emitter->scalar_data.value, emitter->scalar_data.length,
                    !emitter->simple_key_context);

        case YAML_DOUBLE_QUOTED_SCALAR_STYLE:
            return yaml_emitter_write_double_quoted_scalar(emitter,
                    emitter->scalar_data.value, emitter->scalar_data.length,
                    !emitter->simple_key_context);

        case YAML_LITERAL_SCALAR_STYLE:
            return yaml_emitter_write_literal_scalar(emitter,
                    emitter->scalar_data.value, emitter->scalar_data.length);

        case YAML_FOLDED_SCALAR_STYLE:
            return yaml_emitter_write_folded_scalar(emitter,
                    emitter->scalar_data.value, emitter->scalar_data.length);

        default:
            assert(1);      /* Impossible. */
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x18c(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x4, %eax
ja 0x22c74
movq -0x18(%rbp), %rax
leaq 0xa17e(%rip), %rcx      # 0x2ccf0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x170(%rax), %rdx
movq -0x10(%rbp), %rax
cmpl $0x0, 0x114(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x22c90
movl %eax, -0x4(%rbp)
jmp 0x22c7d
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x170(%rax), %rdx
movq -0x10(%rbp), %rax
cmpl $0x0, 0x114(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x23920
movl %eax, -0x4(%rbp)
jmp 0x22c7d
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x170(%rax), %rdx
movq -0x10(%rbp), %rax
cmpl $0x0, 0x114(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x24610
movl %eax, -0x4(%rbp)
jmp 0x22c7d
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x170(%rax), %rdx
callq 0x259e0
movl %eax, -0x4(%rbp)
jmp 0x22c7d
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x170(%rax), %rdx
callq 0x26290
movl %eax, -0x4(%rbp)
jmp 0x22c7d
jmp 0x22c76
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_check_empty_sequence
static int
yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter)
{
    if (emitter->events.tail - emitter->events.head < 2)
        return 0;

    return (emitter->events.head[0].type == YAML_SEQUENCE_START_EVENT
            && emitter->events.head[1].type == YAML_SEQUENCE_END_EVENT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0xc0(%rcx), %rcx
subq %rcx, %rax
movl $0x68, %ecx
cqto
idivq %rcx
cmpq $0x2, %rax
jge 0x274ca
movl $0x0, -0x4(%rbp)
jmp 0x274ff
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rcx
xorl %eax, %eax
cmpl $0x7, (%rcx)
movb %al, -0x11(%rbp)
jne 0x274f4
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rax
cmpl $0x8, 0x68(%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_check_empty_mapping
static int
yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter)
{
    if (emitter->events.tail - emitter->events.head < 2)
        return 0;

    return (emitter->events.head[0].type == YAML_MAPPING_START_EVENT
            && emitter->events.head[1].type == YAML_MAPPING_END_EVENT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0xc0(%rcx), %rcx
subq %rcx, %rax
movl $0x68, %ecx
cqto
idivq %rcx
cmpq $0x2, %rax
jge 0x2754a
movl $0x0, -0x4(%rbp)
jmp 0x2757f
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rcx
xorl %eax, %eax
cmpl $0x9, (%rcx)
movb %al, -0x11(%rbp)
jne 0x27574
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rax
cmpl $0xa, 0x68(%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/emitter.c
// Function: yaml_emitter_check_simple_key
static int
yaml_emitter_check_simple_key(yaml_emitter_t *emitter)
{
    yaml_event_t *event = emitter->events.head;
    size_t length = 0;

    switch (event->type)
    {
        case YAML_ALIAS_EVENT:
            length += emitter->anchor_data.anchor_length;
            break;

        case YAML_SCALAR_EVENT:
            if (emitter->scalar_data.multiline)
                return 0;
            length += emitter->anchor_data.anchor_length
                + emitter->tag_data.handle_length
                + emitter->tag_data.suffix_length
                + emitter->scalar_data.length;
            break;

        case YAML_SEQUENCE_START_EVENT:
            if (!yaml_emitter_check_empty_sequence(emitter))
                return 0;
            length += emitter->anchor_data.anchor_length
                + emitter->tag_data.handle_length
                + emitter->tag_data.suffix_length;
            break;

        case YAML_MAPPING_START_EVENT:
            if (!yaml_emitter_check_empty_mapping(emitter))
                return 0;
            length += emitter->anchor_data.anchor_length
                + emitter->tag_data.handle_length
                + emitter->tag_data.suffix_length;
            break;

        default:
            return 0;
    }

    if (length > 128)
        return 0;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl $-0x5, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x4, %eax
ja 0x276d0
movq -0x28(%rbp), %rax
leaq 0x572e(%rip), %rcx      # 0x2cd04
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x276d9
movq -0x10(%rbp), %rax
cmpl $0x0, 0x178(%rax)
je 0x27610
movl $0x0, -0x4(%rbp)
jmp 0x276f3
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x150(%rcx), %rax
movq -0x10(%rbp), %rcx
addq 0x160(%rcx), %rax
movq -0x10(%rbp), %rcx
addq 0x170(%rcx), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x276d9
movq -0x10(%rbp), %rdi
callq 0x27490
cmpl $0x0, %eax
jne 0x27663
movl $0x0, -0x4(%rbp)
jmp 0x276f3
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x150(%rcx), %rax
movq -0x10(%rbp), %rcx
addq 0x160(%rcx), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x276d9
movq -0x10(%rbp), %rdi
callq 0x27510
cmpl $0x0, %eax
jne 0x276a5
movl $0x0, -0x4(%rbp)
jmp 0x276f3
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x150(%rcx), %rax
movq -0x10(%rbp), %rcx
addq 0x160(%rcx), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x276d9
movl $0x0, -0x4(%rbp)
jmp 0x276f3
cmpq $0x80, -0x20(%rbp)
jbe 0x276ec
movl $0x0, -0x4(%rbp)
jmp 0x276f3
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2120
cmpq $0x0, -0x10(%rbp)
je 0x299db
jmp 0x299fa
leaq 0x1833(%rip), %rdi      # 0x2b215
leaq 0x35cd(%rip), %rsi      # 0x2cfb6
movl $0x43, %edx
leaq 0x35ca(%rip), %rcx      # 0x2cfbf
callq 0x2100
movq -0x10(%rbp), %rax
cmpl $0x0, 0x190(%rax)
jne 0x29a09
jmp 0x29a28
leaq 0x35d7(%rip), %rdi      # 0x2cfe7
leaq 0x359f(%rip), %rsi      # 0x2cfb6
movl $0x44, %edx
leaq 0x359c(%rip), %rcx      # 0x2cfbf
callq 0x2100
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0x2120
movl $0x1, -0x78(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x70(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x29a9d
movl $0x0, -0x4(%rbp)
jmp 0x29ab2
movq -0x10(%rbp), %rax
movl $0x1, 0x190(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2120
cmpq $0x0, -0x10(%rbp)
je 0x29aeb
jmp 0x29b0a
leaq 0x1723(%rip), %rdi      # 0x2b215
leaq 0x34bd(%rip), %rsi      # 0x2cfb6
movl $0x5b, %edx
leaq 0x34f3(%rip), %rcx      # 0x2cff8
callq 0x2100
movq -0x10(%rbp), %rax
cmpl $0x0, 0x190(%rax)
je 0x29b19
jmp 0x29b38
leaq 0x34c8(%rip), %rdi      # 0x2cfe8
leaq 0x348f(%rip), %rsi      # 0x2cfb6
movl $0x5c, %edx
leaq 0x34c5(%rip), %rcx      # 0x2cff8
callq 0x2100
movq -0x10(%rbp), %rax
cmpl $0x0, 0x194(%rax)
je 0x29b51
movl $0x1, -0x4(%rbp)
jmp 0x29bd4
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0x2120
movl $0x2, -0x78(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x29bbf
movl $0x0, -0x4(%rbp)
jmp 0x29bd4
movq -0x10(%rbp), %rax
movl $0x1, 0x194(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x198(%rax)
jne 0x29f0e
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rdi
callq 0x2110
movq -0x8(%rbp), %rax
movq $0x0, 0x1a8(%rax)
jmp 0x2a085
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x1a8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x29ffe
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rax
movq (%rax), %rsi
movslq -0xc(%rbp), %rax
imulq $0x60, %rax, %rax
addq %rax, %rsi
leaq -0x70(%rbp), %rdi
movl $0x60, %edx
callq 0x2180
movq -0x8(%rbp), %rax
movq 0x198(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
jne 0x29fa0
movq -0x68(%rbp), %rdi
callq 0x2140
cmpl $0x1, -0x70(%rbp)
jne 0x29f9e
movq -0x60(%rbp), %rdi
callq 0x2140
jmp 0x29fa0
cmpl $0x2, -0x70(%rbp)
jne 0x29fc7
movq -0x60(%rbp), %rdi
callq 0x2140
movq $0x0, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x60(%rbp)
cmpl $0x3, -0x70(%rbp)
jne 0x29fee
movq -0x60(%rbp), %rdi
callq 0x2140
movq $0x0, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x60(%rbp)
jmp 0x29ff0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x29f15
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rax
movq (%rax), %rdi
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x198(%rax), %rdi
callq 0x2140
movq -0x8(%rbp), %rax
movq $0x0, 0x198(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1a0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x1a8(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/dumper.c
// Function: yaml_emitter_dump_node
static int
yaml_emitter_dump_node(yaml_emitter_t *emitter, int index)
{
    yaml_node_t *node = emitter->document->nodes.start + index - 1;
    int anchor_id = emitter->anchors[index-1].anchor;
    yaml_char_t *anchor = NULL;

    if (anchor_id) {
        anchor = yaml_emitter_generate_anchor(emitter, anchor_id);
        if (!anchor) return 0;
    }

    if (emitter->anchors[index-1].serialized) {
        return yaml_emitter_dump_alias(emitter, anchor);
    }

    emitter->anchors[index-1].serialized = 1;

    switch (node->type) {
        case YAML_SCALAR_NODE:
            return yaml_emitter_dump_scalar(emitter, node, anchor);
        case YAML_SEQUENCE_NODE:
            return yaml_emitter_dump_sequence(emitter, node, anchor);
        case YAML_MAPPING_NODE:
            return yaml_emitter_dump_mapping(emitter, node, anchor);
        default:
            assert(0);      /* Could not happen. */
            break;
    }

    return 0;       /* Could not happen. */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x1a8(%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
addq $-0x60, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x198(%rax), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x2a294
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x2a380
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2a292
movl $0x0, -0x4(%rbp)
jmp 0x2a36e
jmp 0x2a294
movq -0x10(%rbp), %rax
movq 0x198(%rax), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0x2a2ca
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2a3e0
movl %eax, -0x4(%rbp)
jmp 0x2a36e
movq -0x10(%rbp), %rax
movq 0x198(%rax), %rax
movl -0x14(%rbp), %ecx
decl %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movl $0x1, 0x8(%rax,%rcx,4)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x1, %eax
je 0x2a30d
jmp 0x2a2f9
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0x2a323
jmp 0x2a303
movl -0x34(%rbp), %eax
subl $0x3, %eax
je 0x2a339
jmp 0x2a34f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x2a480
movl %eax, -0x4(%rbp)
jmp 0x2a36e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x2a5b0
movl %eax, -0x4(%rbp)
jmp 0x2a36e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x2a790
movl %eax, -0x4(%rbp)
jmp 0x2a36e
leaq 0x22de(%rip), %rdi      # 0x2c634
leaq 0x2c59(%rip), %rsi      # 0x2cfb6
movl $0x121, %edx            # imm = 0x121
leaq 0x2cf3(%rip), %rcx      # 0x2d05c
callq 0x2100
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/dumper.c
// Function: yaml_emitter_generate_anchor
static yaml_char_t *
yaml_emitter_generate_anchor(yaml_emitter_t *emitter, int anchor_id)
{
    yaml_char_t *anchor = yaml_malloc(ANCHOR_TEMPLATE_LENGTH);

    if (!anchor) return NULL;

    sprintf((char *)anchor, ANCHOR_TEMPLATE, anchor_id);

    return anchor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x10, %edi
callq 0x2080
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2a3ae
movq $0x0, -0x8(%rbp)
jmp 0x2a3cb
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x2cd2(%rip), %rsi      # 0x2d08e
movb $0x0, %al
callq 0x2200
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/dumper.c
// Function: yaml_emitter_dump_scalar
static int
yaml_emitter_dump_scalar(yaml_emitter_t *emitter, yaml_node_t *node,
        yaml_char_t *anchor)
{
    yaml_event_t event;
    yaml_mark_t mark  = { 0, 0, 0 };

    int plain_implicit = (strcmp((char *)node->tag,
                YAML_DEFAULT_SCALAR_TAG) == 0);
    int quoted_implicit = (strcmp((char *)node->tag,
                YAML_DEFAULT_SCALAR_TAG) == 0);

    SCALAR_EVENT_INIT(event, anchor, node->tag, node->data.scalar.value,
            node->data.scalar.length, plain_implicit, quoted_implicit,
            node->data.scalar.style, mark, mark);

    return yaml_emitter_emit(emitter, &event);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2120
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x15ef(%rip), %rsi      # 0x2baa8
callq 0x2160
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x9c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x15ca(%rip), %rsi      # 0x2baa8
callq 0x2160
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xa0(%rbp)
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0x2120
movl $0x6, -0x80(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x60(%rbp)
movl -0x9c(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0xa0(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x20f0
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/dumper.c
// Function: yaml_emitter_dump_sequence
static int
yaml_emitter_dump_sequence(yaml_emitter_t *emitter, yaml_node_t *node,
        yaml_char_t *anchor)
{
    yaml_event_t event;
    yaml_mark_t mark  = { 0, 0, 0 };

    int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_SEQUENCE_TAG) == 0);

    yaml_node_item_t *item;

    SEQUENCE_START_EVENT_INIT(event, anchor, node->tag, implicit,
            node->data.sequence.style, mark, mark);
    if (!yaml_emitter_emit(emitter, &event)) return 0;

    for (item = node->data.sequence.items.start;
            item < node->data.sequence.items.top; item ++) {
        if (!yaml_emitter_dump_node(emitter, *item)) return 0;
    }

    SEQUENCE_END_EVENT_INIT(event, mark, mark);
    if (!yaml_emitter_emit(emitter, &event)) return 0;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2120
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x152d(%rip), %rsi      # 0x2bb16
callq 0x2160
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xa4(%rbp)
leaq -0x88(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0x2120
movl $0x7, -0x88(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x78(%rbp)
movl -0xa4(%rbp), %eax
movl %eax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x6c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x2a6a6
movl $0x0, -0x4(%rbp)
jmp 0x2a783
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x2a6ff
movq -0x10(%rbp), %rdi
movq -0xb0(%rbp), %rax
movl (%rax), %esi
callq 0x2a210
cmpl $0x0, %eax
jne 0x2a6e9
movl $0x0, -0x4(%rbp)
jmp 0x2a783
jmp 0x2a6eb
movq -0xb0(%rbp), %rax
addq $0x4, %rax
movq %rax, -0xb0(%rbp)
jmp 0x2a6b5
leaq -0x88(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0x2120
movl $0x8, -0x88(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x2a77c
movl $0x0, -0x4(%rbp)
jmp 0x2a783
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/dumper.c
// Function: yaml_emitter_dump_mapping
static int
yaml_emitter_dump_mapping(yaml_emitter_t *emitter, yaml_node_t *node,
        yaml_char_t *anchor)
{
    yaml_event_t event;
    yaml_mark_t mark  = { 0, 0, 0 };

    int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_MAPPING_TAG) == 0);

    yaml_node_pair_t *pair;

    MAPPING_START_EVENT_INIT(event, anchor, node->tag, implicit,
            node->data.mapping.style, mark, mark);
    if (!yaml_emitter_emit(emitter, &event)) return 0;

    for (pair = node->data.mapping.pairs.start;
            pair < node->data.mapping.pairs.top; pair ++) {
        if (!yaml_emitter_dump_node(emitter, pair->key)) return 0;
        if (!yaml_emitter_dump_node(emitter, pair->value)) return 0;
    }

    MAPPING_END_EVENT_INIT(event, mark, mark);
    if (!yaml_emitter_emit(emitter, &event)) return 0;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2120
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x13b9(%rip), %rsi      # 0x2bb82
callq 0x2160
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xa4(%rbp)
leaq -0x88(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0x2120
movl $0x9, -0x88(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x78(%rbp)
movl -0xa4(%rbp), %eax
movl %eax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x6c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x2a886
movl $0x0, -0x4(%rbp)
jmp 0x2a987
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x2a903
movq -0x10(%rbp), %rdi
movq -0xb0(%rbp), %rax
movl (%rax), %esi
callq 0x2a210
cmpl $0x0, %eax
jne 0x2a8c9
movl $0x0, -0x4(%rbp)
jmp 0x2a987
movq -0x10(%rbp), %rdi
movq -0xb0(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x2a210
cmpl $0x0, %eax
jne 0x2a8ed
movl $0x0, -0x4(%rbp)
jmp 0x2a987
jmp 0x2a8ef
movq -0xb0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xb0(%rbp)
jmp 0x2a895
leaq -0x88(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0x2120
movl $0xa, -0x88(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x2a980
movl $0x0, -0x4(%rbp)
jmp 0x2a987
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_08/exit.c
// Function: main
int main(int argc, char *argv[])
{
	if (argc >= 2)
		val = atoi(argv[1]);

	printf("this is a message");

	subfunc();

	printf("this point is unreachable!\n");

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jl 0x119f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
movl %eax, 0x2ea5(%rip)      # 0x4044
leaq 0xe5e(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
callq 0x1160
leaq 0xe5d(%rip), %rdi       # 0x2016
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x64, %edx
callq 0x5080
movq (%rsp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0xffffffff, 0x44(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0xffffffff, 0x50(%rax) # imm = 0xFFFFFFFF
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
movb $0x0, %al
callq 0x2740
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x242c
jmp 0x24e1
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xad12(%rip), %rax      # 0xd150
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x2499
movslq -0x4(%rbp), %rcx
leaq 0xacf9(%rip), %rax      # 0xd150
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x248c
movslq -0x4(%rbp), %rcx
leaq 0xacdb(%rip), %rax      # 0xd150
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x248c
jmp 0x2499
jmp 0x248e
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2433
movslq -0x4(%rbp), %rcx
leaq 0xacac(%rip), %rax      # 0xd150
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
jne 0x24b4
jmp 0x24e1
movslq -0x4(%rbp), %rcx
leaq 0xac91(%rip), %rax      # 0xd150
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x4(%rbp), %rdx
leaq 0xac7b(%rip), %rcx      # 0xd150
shlq $0x5, %rdx
addq %rdx, %rcx
movl 0x18(%rcx), %edi
callq *%rax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x920, %rsp            # imm = 0x920
testb %al, %al
je 0x2537
movaps %xmm0, -0x8d0(%rbp)
movaps %xmm1, -0x8c0(%rbp)
movaps %xmm2, -0x8b0(%rbp)
movaps %xmm3, -0x8a0(%rbp)
movaps %xmm4, -0x890(%rbp)
movaps %xmm5, -0x880(%rbp)
movaps %xmm6, -0x870(%rbp)
movaps %xmm7, -0x860(%rbp)
movq %r9, -0x8d8(%rbp)
movq %r8, -0x8e0(%rbp)
movq %rcx, -0x8e8(%rbp)
movq %rdx, -0x8f0(%rbp)
movq %rsi, -0x8f8(%rbp)
movl %edi, -0x4(%rbp)
leaq -0x810(%rbp), %rax
movq %rax, -0x818(%rbp)
leaq -0x840(%rbp), %rax
leaq -0x900(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movl $0x0, -0x844(%rbp)
movl -0x844(%rbp), %eax
addl $0x20000000, %eax       # imm = 0x20000000
movl %eax, 0xb5ab(%rip)      # 0xdb58
leaq -0x410(%rbp), %rdi
movl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xb10c(%rip), %rax      # 0xd6d0
movq (%rax,%rcx,8), %rsi
callq 0x2070
leaq -0x810(%rbp), %rax
movq %rax, -0x818(%rbp)
movl $0x0, -0x824(%rbp)
movslq -0x824(%rbp), %rax
movq %rax, -0x908(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x20d0
movq %rax, %rcx
movq -0x908(%rbp), %rax
cmpq %rcx, %rax
jae 0x2713
movslq -0x824(%rbp), %rax
movsbl -0x410(%rbp,%rax), %eax
cmpl $0x25, %eax
jne 0x26d4
leaq -0x840(%rbp), %rax
movq %rax, -0x918(%rbp)
movl -0x840(%rbp), %eax
movl %eax, -0x90c(%rbp)
cmpl $0x28, %eax
ja 0x266b
movq -0x918(%rbp), %rcx
movl -0x90c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x920(%rbp)
jmp 0x2688
movq -0x918(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x920(%rbp)
movq -0x920(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x820(%rbp)
movq -0x820(%rbp), %rdi
callq 0x2b10
movq -0x818(%rbp), %rdi
movq -0x820(%rbp), %rsi
callq 0x2070
movq -0x820(%rbp), %rdi
callq 0x20d0
addq -0x818(%rbp), %rax
movq %rax, -0x818(%rbp)
jmp 0x26fd
movslq -0x824(%rbp), %rax
movb -0x410(%rbp,%rax), %cl
movq -0x818(%rbp), %rax
movb %cl, (%rax)
movq -0x818(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x818(%rbp)
jmp 0x26ff
movl -0x824(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x824(%rbp)
jmp 0x25e5
movq -0x818(%rbp), %rax
movb $0x0, (%rax)
leaq -0x810(%rbp), %rdi
callq 0x3400
addq $0x920, %rsp            # imm = 0x920
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x2aff
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x768e(%rip), %rdi      # 0xa169
callq 0x2160
cmpl $0x0, %eax
jne 0x2afd
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x594d(%rip), %rdx      # 0x8440
callq 0x7590
movl %eax, -0x4(%rbp)
jmp 0x2b06
jmp 0x2aff
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2b5b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
je 0x2b44
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x2b4d
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
jmp 0x2b5b
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2b20
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20d0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
subl $0x4, %eax
cltq
addq %rax, %rdi
leaq 0x75e9(%rip), %rsi      # 0xa177
callq 0x2160
cmpl $0x0, %eax
jne 0x2b9d
jmp 0x2ccc
movq -0x8(%rbp), %rdi
leaq 0x75c7(%rip), %rsi      # 0xa16f
callq 0x2160
cmpl $0x0, %eax
jne 0x2bb7
jmp 0x2ccc
movq -0x8(%rbp), %rdi
leaq 0x75ba(%rip), %rsi      # 0xa17c
callq 0x2160
cmpl $0x0, %eax
jne 0x2bd1
jmp 0x2ccc
movq -0x8(%rbp), %rdi
leaq 0x75ad(%rip), %rsi      # 0xa189
callq 0x2160
cmpl $0x0, %eax
jne 0x2beb
jmp 0x2ccc
movq -0x8(%rbp), %rdi
leaq 0x75a0(%rip), %rsi      # 0xa196
callq 0x2160
cmpl $0x0, %eax
jne 0x2c05
jmp 0x2ccc
movq -0x8(%rbp), %rdi
leaq 0x7593(%rip), %rsi      # 0xa1a3
callq 0x2160
cmpl $0x0, %eax
jne 0x2c1f
jmp 0x2ccc
movq -0x8(%rbp), %rdi
leaq 0x7586(%rip), %rsi      # 0xa1b0
callq 0x2160
cmpl $0x0, %eax
jne 0x2c39
jmp 0x2ccc
movq -0x8(%rbp), %rdi
leaq 0x7579(%rip), %rsi      # 0xa1bd
callq 0x2160
cmpl $0x0, %eax
jne 0x2c50
jmp 0x2ccc
movq -0x8(%rbp), %rdi
leaq 0x756f(%rip), %rsi      # 0xa1ca
callq 0x2160
cmpl $0x0, %eax
jne 0x2c67
jmp 0x2ccc
movq -0x8(%rbp), %rdi
leaq 0x7565(%rip), %rsi      # 0xa1d7
callq 0x2160
cmpl $0x0, %eax
jne 0x2c7e
jmp 0x2ccc
movq -0x8(%rbp), %rdi
leaq 0x755a(%rip), %rsi      # 0xa1e3
callq 0x2160
cmpl $0x0, %eax
jne 0x2c95
jmp 0x2ccc
movq -0x8(%rbp), %rdi
leaq 0x7550(%rip), %rsi      # 0xa1f0
callq 0x2160
cmpl $0x0, %eax
jne 0x2cac
jmp 0x2ccc
movq -0x8(%rbp), %rdi
leaq 0x7544(%rip), %rsi      # 0xa1fb
callq 0x2160
cmpl $0x0, %eax
jne 0x2cc3
jmp 0x2ccc
movq -0x8(%rbp), %rdi
callq 0x2ce0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20d0
movl %eax, -0xc(%rbp)
movl $0x0, -0x18(%rbp)
leaq 0xaa7a(%rip), %rax      # 0xdae0
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x29(%rbp)
jle 0x30b0
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0x2a(%rbp)
je 0x30aa
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
sete %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x30b9
jmp 0x30d0
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x306a
movl -0xc(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x31b9
cmpl $0x2, -0x18(%rbp)
jne 0x3102
leaq 0xa9f2(%rip), %rax      # 0xdaf0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x3119
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3120
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x3133
movq -0x8(%rbp), %rax
movb $-0x80, (%rax)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
subl $0x20, %eax
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x3170
movzbl -0x19(%rbp), %eax
movq -0x28(%rbp), %rcx
movslq -0x10(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
andl $0x7f, %ecx
xorl %ecx, %eax
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
addl $0x20, %eax
movb %al, -0x19(%rbp)
movl -0x10(%rbp), %eax
addl $0x7, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %edx, -0x10(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x80, %eax
jne 0x3196
movb $0x9, -0x19(%rbp)
movb -0x19(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x30e5
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/pc/sys.c
// Function: PDFatalError
void PDFatalError(char *pThe_str)
{
	if (been_here) {
		exit(1);
	}
	been_here = 1;

	fprintf(stderr, "FATAL ERROR: %s\n", pThe_str);
	// wait for keypress
	// DoSaveGame() -> exit
    if (TEST_really_exit) {
	   exit(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0xa9fd(%rip)      # 0xde10
je 0x341f
movl $0x1, %edi
callq 0x2220
movl $0x1, 0xa9e7(%rip)      # 0xde10
movq 0x9bc8(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x6dd1(%rip), %rsi      # 0xa20f
movb $0x0, %al
callq 0x2170
cmpl $0x0, 0xa6b4(%rip)      # 0xdb00
je 0x3458
movl $0x1, %edi
callq 0x2220
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/log/zf_log.c
// Function: zf_log_write_imp
static void _zf_log_write_imp(
        const zf_log_spec *log,
        const src_location *const src, const mem_block *const mem,
        const int lvl, const char *const tag, const char *const fmt, va_list va)
{
    zf_log_message msg;
    char buf[ZF_LOG_BUF_SZ];
    const unsigned mask = log->output->mask;
    msg.lvl = lvl;
    msg.tag = tag;
    g_buffer_cb(&msg, buf);
    if (ZF_LOG_PUT_CTX & mask)
    {
        put_ctx(&msg);
    }
    if (ZF_LOG_PUT_TAG & mask)
    {
        put_tag(&msg, tag);
    }
    if (0 != src && ZF_LOG_PUT_SRC & mask)
    {
        put_src(&msg, src);
    }
    if (ZF_LOG_PUT_MSG & mask)
    {
        put_msg(&msg, fmt, va);
    }
    log->output->callback(&msg, log->output->arg);
    if (0 != mem && ZF_LOG_PUT_MSG & mask)
    {
        output_mem(log, &msg, mem);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, -0x274(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x70(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x270(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x3cc0
movl -0x274(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x369b
leaq -0x70(%rbp), %rdi
callq 0x3d00
movl -0x274(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x36b6
movq -0x28(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x4170
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x36d9
movl -0x274(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x36d9
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x43a0
movl -0x274(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x36f8
movq -0x30(%rbp), %rsi
movq 0x10(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x4590
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rsi
leaq -0x70(%rbp), %rdi
callq *%rax
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x373d
movl -0x274(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x373d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x70(%rbp), %rsi
callq 0x4600
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
testb %al, %al
je 0x39c4
movaps %xmm0, -0xf0(%rbp)
movaps %xmm1, -0xe0(%rbp)
movaps %xmm2, -0xd0(%rbp)
movaps %xmm3, -0xc0(%rbp)
movaps %xmm4, -0xb0(%rbp)
movaps %xmm5, -0xa0(%rbp)
movaps %xmm6, -0x90(%rbp)
movaps %xmm7, -0x80(%rbp)
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movl 0x10(%rbp), %eax
movl %eax, -0x48(%rbp)
leaq -0x120(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x30, -0x6c(%rbp)
movl $0x30, -0x70(%rbp)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %r8
movq 0x18(%rbp), %r9
movq %rsp, %rax
leaq -0x70(%rbp), %rdx
movq %rdx, (%rax)
leaq 0x9376(%rip), %rdi      # 0xcdb8
leaq -0x40(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x3630
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax,%rax)