LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Neotoxic-off[P]Zest/src/tag/img.cpp
// Function: Attributes::img::longdesc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::img::longdesc(std::string value)
{
    Logs logs;

    this->longdesc_t = value;

    if (Attributes::img::longdesc() == value) {
        logs.done("img attribute longdesc set");

        return (true);
    }
    logs.fail("img attribute longdesc not set");

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x25d0
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
addq $0x120, %rdi            # imm = 0x120
callq 0x2030
jmp 0xaa1a
movq -0xb0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xd4e0
jmp 0xaa2c
movq -0xa8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x3530
movb %al, -0xb1(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2120
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0xaa5a
jmp 0xaaf6
leaq -0x71(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x22f0
movq -0xc0(%rbp), %rdx
leaq 0x3b30(%rip), %rsi      # 0xe5a8
leaq -0x70(%rbp), %rdi
callq 0x3780
jmp 0xaa83
leaq -0x19(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2690
jmp 0xaa92
leaq -0x70(%rbp), %rdi
callq 0x2120
leaq -0x71(%rbp), %rdi
callq 0x21f0
movb $0x1, -0x1(%rbp)
movl $0x1, -0x78(%rbp)
jmp 0xab90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xaba7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xaae8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2120
leaq -0x71(%rbp), %rdi
callq 0x21f0
jmp 0xaba7
leaq -0x99(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x22f0
movq -0xc8(%rbp), %rdx
leaq 0x3aac(%rip), %rsi      # 0xe5c3
leaq -0x98(%rbp), %rdi
callq 0x3780
jmp 0xab25
leaq -0x19(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x2700
jmp 0xab37
leaq -0x98(%rbp), %rdi
callq 0x2120
leaq -0x99(%rbp), %rdi
callq 0x21f0
movb $0x0, -0x1(%rbp)
movl $0x1, -0x78(%rbp)
jmp 0xab90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xab82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x2120
leaq -0x99(%rbp), %rdi
callq 0x21f0
jmp 0xaba7
leaq -0x19(%rbp), %rdi
callq 0x25e0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x19(%rbp), %rdi
callq 0x25e0
movq -0x28(%rbp), %rdi
callq 0x22e0
nopl (%rax)
// File: Neotoxic-off[P]Zest/src/tag/img.cpp
// Function: Attributes::img::referrerpolicy(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::img::referrerpolicy(std::string value)
{
    Logs logs;

    this->referrerpolicy_t = value;

    if (Attributes::img::referrerpolicy() == value) {
        logs.done("img attribute referrerpolicy set");

        return (true);
    }
    logs.fail("img attribute referrerpolicy not set");

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x25d0
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
addq $0x140, %rdi            # imm = 0x140
callq 0x2030
jmp 0xac0a
movq -0xb0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xd520
jmp 0xac1c
movq -0xa8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x3530
movb %al, -0xb1(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2120
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0xac4a
jmp 0xace6
leaq -0x71(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x22f0
movq -0xc0(%rbp), %rdx
leaq 0x397a(%rip), %rsi      # 0xe5e2
leaq -0x70(%rbp), %rdi
callq 0x3780
jmp 0xac73
leaq -0x19(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2690
jmp 0xac82
leaq -0x70(%rbp), %rdi
callq 0x2120
leaq -0x71(%rbp), %rdi
callq 0x21f0
movb $0x1, -0x1(%rbp)
movl $0x1, -0x78(%rbp)
jmp 0xad80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xad97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xacd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2120
leaq -0x71(%rbp), %rdi
callq 0x21f0
jmp 0xad97
leaq -0x99(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x22f0
movq -0xc8(%rbp), %rdx
leaq 0x38fc(%rip), %rsi      # 0xe603
leaq -0x98(%rbp), %rdi
callq 0x3780
jmp 0xad15
leaq -0x19(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x2700
jmp 0xad27
leaq -0x98(%rbp), %rdi
callq 0x2120
leaq -0x99(%rbp), %rdi
callq 0x21f0
movb $0x0, -0x1(%rbp)
movl $0x1, -0x78(%rbp)
jmp 0xad80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xad72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x2120
leaq -0x99(%rbp), %rdi
callq 0x21f0
jmp 0xad97
leaq -0x19(%rbp), %rdi
callq 0x25e0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x19(%rbp), %rdi
callq 0x25e0
movq -0x28(%rbp), %rdi
callq 0x22e0
nopl (%rax)
// File: Neotoxic-off[P]Zest/src/tag/img.cpp
// Function: Attributes::img::sizes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::img::sizes(std::string value)
{
    Logs logs;

    this->sizes_t = value;

    if (Attributes::img::sizes() == value) {
        logs.done("img attribute sizes set");

        return (true);
    }
    logs.fail("img attribute sizes not set");

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x25d0
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
addq $0x160, %rdi            # imm = 0x160
callq 0x2030
jmp 0xadfa
movq -0xb0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xd560
jmp 0xae0c
movq -0xa8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x3530
movb %al, -0xb1(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2120
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0xae3a
jmp 0xaed6
leaq -0x71(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x22f0
movq -0xc0(%rbp), %rdx
leaq 0x37d0(%rip), %rsi      # 0xe628
leaq -0x70(%rbp), %rdi
callq 0x3780
jmp 0xae63
leaq -0x19(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2690
jmp 0xae72
leaq -0x70(%rbp), %rdi
callq 0x2120
leaq -0x71(%rbp), %rdi
callq 0x21f0
movb $0x1, -0x1(%rbp)
movl $0x1, -0x78(%rbp)
jmp 0xaf70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xaf87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xaec8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2120
leaq -0x71(%rbp), %rdi
callq 0x21f0
jmp 0xaf87
leaq -0x99(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x22f0
movq -0xc8(%rbp), %rdx
leaq 0x3749(%rip), %rsi      # 0xe640
leaq -0x98(%rbp), %rdi
callq 0x3780
jmp 0xaf05
leaq -0x19(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x2700
jmp 0xaf17
leaq -0x98(%rbp), %rdi
callq 0x2120
leaq -0x99(%rbp), %rdi
callq 0x21f0
movb $0x0, -0x1(%rbp)
movl $0x1, -0x78(%rbp)
jmp 0xaf70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xaf62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x2120
leaq -0x99(%rbp), %rdi
callq 0x21f0
jmp 0xaf87
leaq -0x19(%rbp), %rdi
callq 0x25e0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x19(%rbp), %rdi
callq 0x25e0
movq -0x28(%rbp), %rdi
callq 0x22e0
nopl (%rax)
// File: Neotoxic-off[P]Zest/src/tag/img.cpp
// Function: Attributes::img::srcset(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::img::srcset(std::string value)
{
    Logs logs;

    this->srcset_t = value;

    if (Attributes::img::srcset() == value) {
        logs.done("img attribute srcset set");

        return (true);
    }
    logs.fail("img attribute srcset not set");

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x25d0
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
addq $0x180, %rdi            # imm = 0x180
callq 0x2030
jmp 0xafea
movq -0xb0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xd5a0
jmp 0xaffc
movq -0xa8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x3530
movb %al, -0xb1(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2120
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0xb02a
jmp 0xb0c6
leaq -0x71(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x22f0
movq -0xc0(%rbp), %rdx
leaq 0x3614(%rip), %rsi      # 0xe65c
leaq -0x70(%rbp), %rdi
callq 0x3780
jmp 0xb053
leaq -0x19(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2690
jmp 0xb062
leaq -0x70(%rbp), %rdi
callq 0x2120
leaq -0x71(%rbp), %rdi
callq 0x21f0
movb $0x1, -0x1(%rbp)
movl $0x1, -0x78(%rbp)
jmp 0xb160
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xb177
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xb0b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2120
leaq -0x71(%rbp), %rdi
callq 0x21f0
jmp 0xb177
leaq -0x99(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x22f0
movq -0xc8(%rbp), %rdx
leaq 0x358e(%rip), %rsi      # 0xe675
leaq -0x98(%rbp), %rdi
callq 0x3780
jmp 0xb0f5
leaq -0x19(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x2700
jmp 0xb107
leaq -0x98(%rbp), %rdi
callq 0x2120
leaq -0x99(%rbp), %rdi
callq 0x21f0
movb $0x0, -0x1(%rbp)
movl $0x1, -0x78(%rbp)
jmp 0xb160
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xb152
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x2120
leaq -0x99(%rbp), %rdi
callq 0x21f0
jmp 0xb177
leaq -0x19(%rbp), %rdi
callq 0x25e0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x19(%rbp), %rdi
callq 0x25e0
movq -0x28(%rbp), %rdi
callq 0x22e0
nopl (%rax)
// File: Neotoxic-off[P]Zest/src/tag/img.cpp
// Function: Attributes::img::usermap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::img::usermap(std::string value)
{
    Logs logs;

    this->usermap_t = value;

    if (Attributes::img::usermap() == value) {
        logs.done("img attribute usermap set");

        return (true);
    }
    logs.fail("img attribute usermap not set");

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x25d0
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
addq $0x1a0, %rdi            # imm = 0x1A0
callq 0x2030
jmp 0xb1da
movq -0xb0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xd5e0
jmp 0xb1ec
movq -0xa8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x3530
movb %al, -0xb1(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2120
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0xb21a
jmp 0xb2b6
leaq -0x71(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x22f0
movq -0xc0(%rbp), %rdx
leaq 0x345a(%rip), %rsi      # 0xe692
leaq -0x70(%rbp), %rdi
callq 0x3780
jmp 0xb243
leaq -0x19(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2690
jmp 0xb252
leaq -0x70(%rbp), %rdi
callq 0x2120
leaq -0x71(%rbp), %rdi
callq 0x21f0
movb $0x1, -0x1(%rbp)
movl $0x1, -0x78(%rbp)
jmp 0xb350
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xb367
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xb2a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2120
leaq -0x71(%rbp), %rdi
callq 0x21f0
jmp 0xb367
leaq -0x99(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x22f0
movq -0xc8(%rbp), %rdx
leaq 0x33d5(%rip), %rsi      # 0xe6ac
leaq -0x98(%rbp), %rdi
callq 0x3780
jmp 0xb2e5
leaq -0x19(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x2700
jmp 0xb2f7
leaq -0x98(%rbp), %rdi
callq 0x2120
leaq -0x99(%rbp), %rdi
callq 0x21f0
movb $0x0, -0x1(%rbp)
movl $0x1, -0x78(%rbp)
jmp 0xb350
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xb342
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x2120
leaq -0x99(%rbp), %rdi
callq 0x21f0
jmp 0xb367
leaq -0x19(%rbp), %rdi
callq 0x25e0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x19(%rbp), %rdi
callq 0x25e0
movq -0x28(%rbp), %rdi
callq 0x22e0
nopl (%rax)
// File: Neotoxic-off[P]Zest/src/tag/img.cpp
// Function: Attributes::img::style(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::img::style(std::string value)
{
    Logs logs;

    this->style_t = value;

    if (Attributes::img::style() == value) {
        logs.done("img attribute style set");

        return (true);
    }
    logs.fail("img attribute style not set");

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x25d0
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x2030
jmp 0xb3ca
movq -0xb0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xd620
jmp 0xb3dc
movq -0xa8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x3530
movb %al, -0xb1(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2120
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0xb40a
jmp 0xb4a6
leaq -0x71(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x22f0
movq -0xc0(%rbp), %rdx
leaq 0x32a2(%rip), %rsi      # 0xe6ca
leaq -0x70(%rbp), %rdi
callq 0x3780
jmp 0xb433
leaq -0x19(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2690
jmp 0xb442
leaq -0x70(%rbp), %rdi
callq 0x2120
leaq -0x71(%rbp), %rdi
callq 0x21f0
movb $0x1, -0x1(%rbp)
movl $0x1, -0x78(%rbp)
jmp 0xb540
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xb557
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xb498
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2120
leaq -0x71(%rbp), %rdi
callq 0x21f0
jmp 0xb557
leaq -0x99(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x22f0
movq -0xc8(%rbp), %rdx
leaq 0x321b(%rip), %rsi      # 0xe6e2
leaq -0x98(%rbp), %rdi
callq 0x3780
jmp 0xb4d5
leaq -0x19(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x2700
jmp 0xb4e7
leaq -0x98(%rbp), %rdi
callq 0x2120
leaq -0x99(%rbp), %rdi
callq 0x21f0
movb $0x0, -0x1(%rbp)
movl $0x1, -0x78(%rbp)
jmp 0xb540
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xb532
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x2120
leaq -0x99(%rbp), %rdi
callq 0x21f0
jmp 0xb557
leaq -0x19(%rbp), %rdi
callq 0x25e0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x19(%rbp), %rdi
callq 0x25e0
movq -0x28(%rbp), %rdi
callq 0x22e0
nopl (%rax)
// File: Neotoxic-off[P]Zest/src/Tools.cpp
// Function: Tools::malloc(int)
char *Tools::malloc(int size)
{
    char *array = malloc(sizeof(char) * (size + 1));

    for (int i = 0; i <= size; i++)
        array[i] = '\0';

    return (array);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
addl $0x1, %eax
cltq
shlq $0x0, %rax
movl %eax, %esi
callq 0xd750
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0xd7a0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd781
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Neotoxic-off[P]Zest/src/Tools.cpp
// Function: Tools::set(char*)
char *Tools::set(char *add)
{
    int add_length = length(add);
    char *array = malloc(sizeof(char) * (add_length + 1));

    for (int i = 0; i < add_length; i++) {
        array[i] = add[i];
    }

    return (array);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0xd830
movq -0x30(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
cltq
shlq $0x0, %rax
movl %eax, %esi
callq 0xd750
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xd81f
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd7f6
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Neotoxic-off[P]Zest/src/Tools.cpp
// Function: Tools::equal(char*, char*)
bool Tools::equal(char *to_compare, char *compared_to)
{
    int compare_size = length(to_compare);
    int compared_size = length(compared_to);

    if (compare_size == compared_size) {
        for (int i = 0; i < compare_size; i++) {
            if (to_compare[i] != compared_to[i])
                return (false);
        }
        return (true);
    }

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0xd830
movq -0x38(%rbp), %rdi
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rsi
callq 0xd830
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jne 0xd8f4
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0xd8ee
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xd8e1
movb $0x0, -0x1(%rbp)
jmp 0xd8f8
jmp 0xd8e3
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xd8b7
movb $0x1, -0x1(%rbp)
jmp 0xd8f8
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Neotoxic-off[P]Zest/src/Tools.cpp
// Function: Tools::count(char*, char)
int Tools::count(char *str, char c)
{
    int count = 0;

    for (int i = 0; str[i] != '\0'; i++)
        if (str[i] == c)
            count++;

    return (count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xd96a
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0xd95d
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd95f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd92f
movl -0x18(%rbp), %eax
popq %rbp
retq
nop
// File: Neotoxic-off[P]Zest/src/Tools.cpp
// Function: Tools::mmalloc(int)
char **Tools::mmalloc(int size)
{
    char **array = (char **) malloc(sizeof(char *) * (size + 1));

    for (int i = 0; i <= size; i++)
        array[i] = NULL;

    return (array);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
addl $0x1, %eax
cltq
shlq $0x3, %rax
movl %eax, %esi
callq 0xd750
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0xd9c4
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd9a1
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Neotoxic-off[P]Zest/src/Tools.cpp
// Function: Tools::insert(char*, char)
char *Tools::insert(char *base, char add)
{
    int base_length = length(base);
    char *array = malloc(base_length + 1);
    int i = 0;

    for (; i < base_length; i++)
        array[i] = base[i];
    array[i] = add;

    return (array);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0xd830
movq -0x30(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
addl $0x1, %esi
callq 0xd750
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xda3c
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xda13
movb -0x11(%rbp), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Neotoxic-off[P]Zest/src/Tools.cpp
// Function: Tools::cnf(char*)
int Tools::cnf(char *str)
{
    if (str) {
        free(str);
        return (1);
    }

    return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xda89
movq -0x18(%rbp), %rdi
callq 0x2220
movl $0x1, -0x4(%rbp)
jmp 0xda90
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Neotoxic-off[P]Zest/src/Tools.cpp
// Function: Tools::split(char*, char)
char **Tools::split(char *array, char sep)
{
    char **split = mmalloc(count(array, sep) + 1);
    int floor = 0;
    int previous = 0;
    char *append = NULL;

    for (int i = 0; i < Tools::length(array); i++) {
        if (array[i] == sep) {
            floor++;
        } else {
            if (i == 0 || previous < floor) {
                split[floor] = Tools::malloc(1);
                previous = floor;
            }
            append = Tools::insert(split[floor], array[i]);
            Tools::cnf(split[floor]);
            split[floor] = append;
        }
    }
    return (split);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movsbl -0x11(%rbp), %edx
callq 0xd910
movq -0x40(%rbp), %rdi
movl %eax, %esi
addl $0x1, %esi
callq 0xd970
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rsi
callq 0xd830
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jge 0xdbc3
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0xdb38
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xdbb3
cmpl $0x0, -0x34(%rbp)
je 0xdb46
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0xdb69
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0xd750
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsbl (%rax,%rcx), %edx
callq 0xd9d0
movq -0x40(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xda60
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0xdbb5
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xdaf9
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: Neotoxic-off[P]Zest/src/Tools.cpp
// Function: Tools::string_to_array(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
char *Tools::string_to_array(std::string str)
{
    int size = str.length();
    char *_new_ = malloc(sizeof(char) * (size + 1));

    for (int i = 0; i < size; i++)
        _new_[i] = str[i];

    return (_new_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, %rax
movq -0x40(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x2290
movq -0x30(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
cltq
shlq $0x0, %rax
movl %eax, %esi
callq 0xd750
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xdc4e
movq -0x38(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x2340
movb (%rax), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xdc21
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: rockytriton[P]dreamsys_emu_gb/src/bus.cpp
// Function: dsemu::bus::read(unsigned short)
byte read(ushort address) {
        if (address < 0x8000) {
            return cart::read(address); // memory::read(address);
        } else if (address < 0xA000) {
            return memory::read(address);
        } else if (address < 0xFE00) {
            return memory::read(address);
        } else if (address < 0xFEA0) {
            return ppu::readOAM(address - 0xFE00);
        } else if (address < 0xFEFF) {
            return 0;
        } else if (address < 0xFF80) {
            return io::read(address);
        } else if (address < 0xFFFF) {
            return memory::read(address);
        } else {
            return cpu::getInterruptsEnableFlag();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x4(%rbp)
movzwl -0x4(%rbp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jge 0x1347b
movzwl -0x4(%rbp), %edi
callq 0x14230
movb %al, -0x1(%rbp)
jmp 0x1351c
movzwl -0x4(%rbp), %eax
cmpl $0xa000, %eax           # imm = 0xA000
jge 0x13497
movzwl -0x4(%rbp), %edi
callq 0x199b0
movb %al, -0x1(%rbp)
jmp 0x1351c
movzwl -0x4(%rbp), %eax
cmpl $0xfe00, %eax           # imm = 0xFE00
jge 0x134b0
movzwl -0x4(%rbp), %edi
callq 0x199b0
movb %al, -0x1(%rbp)
jmp 0x1351c
movzwl -0x4(%rbp), %eax
cmpl $0xfea0, %eax           # imm = 0xFEA0
jge 0x134d1
movzwl -0x4(%rbp), %eax
subl $0xfe00, %eax           # imm = 0xFE00
movzwl %ax, %edi
callq 0x21d60
movb %al, -0x1(%rbp)
jmp 0x1351c
movzwl -0x4(%rbp), %eax
cmpl $0xfeff, %eax           # imm = 0xFEFF
jge 0x134e2
movb $0x0, -0x1(%rbp)
jmp 0x1351c
movzwl -0x4(%rbp), %eax
cmpl $0xff80, %eax           # imm = 0xFF80
jge 0x134fb
movzwl -0x4(%rbp), %edi
callq 0x169e0
movb %al, -0x1(%rbp)
jmp 0x1351c
movzwl -0x4(%rbp), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jge 0x13514
movzwl -0x4(%rbp), %edi
callq 0x199b0
movb %al, -0x1(%rbp)
jmp 0x1351c
callq 0x14f50
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rockytriton[P]dreamsys_emu_gb/src/bus.cpp
// Function: dsemu::bus::write(unsigned short, unsigned char)
void write(ushort address, byte b) {

        if (address < 0x8000) {
            cart::control(address, b);
        } else if (address < 0xA000) {
            if (address == 0xDD00 || address == 0xDD01) {
                cout << "WRITING TO " << Short(address) << " = " << Byte(b) << endl;
                sleep(2);
            }
            memory::write(address, b);
        } 
        else if (address < 0xFE00) {
            memory::write(address, b);
        } else if (address < 0xFEA0) {
            ppu::writeOAM(address - 0xFE00, b);

        } else if (address < 0xFEFF) {
        } else if (address < 0xFF80) {
            io::write(address, b);
        } else if (address < 0xFFFF) {
            memory::write(address, b);
        } else {
            cpu::setInterruptsEnableFlag(b);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movw %di, %cx
movw %cx, -0x2(%rbp)
movb %al, -0x3(%rbp)
movzwl -0x2(%rbp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jge 0x135c5
movw -0x2(%rbp), %ax
movzwl %ax, %edi
movzbl -0x3(%rbp), %esi
callq 0x14260
jmp 0x13711
movzwl -0x2(%rbp), %eax
cmpl $0xa000, %eax           # imm = 0xA000
jge 0x13676
movzwl -0x2(%rbp), %eax
cmpl $0xdd00, %eax           # imm = 0xDD00
je 0x135ea
movzwl -0x2(%rbp), %eax
cmpl $0xdd01, %eax           # imm = 0xDD01
jne 0x13661
movq 0x1b9df(%rip), %rdi     # 0x2efd0
leaq 0x10a0c(%rip), %rsi     # 0x24004
callq 0x32c0
movq %rax, -0x18(%rbp)
leaq -0x6(%rbp), %rdi
movzwl -0x2(%rbp), %esi
callq 0x13840
movq -0x18(%rbp), %rdi
movzwl -0x6(%rbp), %esi
callq 0x137b0
movq %rax, %rdi
leaq 0x109eb(%rip), %rsi     # 0x24010
callq 0x32c0
movq %rax, -0x10(%rbp)
leaq -0x7(%rbp), %rdi
movzbl -0x3(%rbp), %esi
callq 0x13860
movq -0x10(%rbp), %rdi
movzbl -0x7(%rbp), %esi
callq 0x13720
movq %rax, %rdi
movq 0x1b95e(%rip), %rsi     # 0x2efb0
callq 0x3310
movl $0x2, %edi
callq 0x3210
movw -0x2(%rbp), %ax
movzwl %ax, %edi
movzbl -0x3(%rbp), %esi
callq 0x199f0
jmp 0x1370f
movzwl -0x2(%rbp), %eax
cmpl $0xfe00, %eax           # imm = 0xFE00
jge 0x13693
movw -0x2(%rbp), %ax
movzwl %ax, %edi
movzbl -0x3(%rbp), %esi
callq 0x199f0
jmp 0x1370d
movzwl -0x2(%rbp), %eax
cmpl $0xfea0, %eax           # imm = 0xFEA0
jge 0x136b5
movzwl -0x2(%rbp), %eax
subl $0xfe00, %eax           # imm = 0xFE00
movzwl %ax, %edi
movzbl -0x3(%rbp), %esi
callq 0x21da0
jmp 0x1370b
movzwl -0x2(%rbp), %eax
cmpl $0xfeff, %eax           # imm = 0xFEFF
jge 0x136c2
jmp 0x13709
movzwl -0x2(%rbp), %eax
cmpl $0xff80, %eax           # imm = 0xFF80
jge 0x136df
movw -0x2(%rbp), %ax
movzwl %ax, %edi
movzbl -0x3(%rbp), %esi
callq 0x16c00
jmp 0x13707
movzwl -0x2(%rbp), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jge 0x136fc
movw -0x2(%rbp), %ax
movzwl %ax, %edi
movzbl -0x3(%rbp), %esi
callq 0x199f0
jmp 0x13705
movzbl -0x3(%rbp), %edi
callq 0x14f70
jmp 0x13707
jmp 0x13709
jmp 0x1370b
jmp 0x1370d
jmp 0x1370f
jmp 0x13711
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rockytriton[P]dreamsys_emu_gb/src/cpu.cpp
// Function: dsemu::cpu::push(unsigned short)
void push(ushort s) {
    setReg16Value(regSP, getReg16Value(regSP) - 2);
    bus::write(getReg16Value(regSP), s);
    THESTACK.push_back(s & 0xFF);
    THESTACK.push_back((s >> 8) & 0xFF);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
leaq 0x1b226(%rip), %rdi     # 0x2f59c
callq 0x15070
movzwl %ax, %eax
subl $0x2, %eax
leaq 0x1b214(%rip), %rdi     # 0x2f59c
movzwl %ax, %esi
callq 0x15030
leaq 0x1b205(%rip), %rdi     # 0x2f59c
callq 0x15070
movzwl %ax, %edi
movzwl -0x2(%rbp), %esi
callq 0x13530
movzwl -0x2(%rbp), %eax
andl $0xff, %eax
movb %al, -0x3(%rbp)
leaq 0x1b1fd(%rip), %rdi     # 0x2f5b8
leaq -0x3(%rbp), %rsi
callq 0x15090
movzwl -0x2(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0x4(%rbp)
leaq 0x1b1de(%rip), %rdi     # 0x2f5b8
leaq -0x4(%rbp), %rsi
callq 0x15090
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: rockytriton[P]dreamsys_emu_gb/src/cpu.cpp
// Function: dsemu::cpu::pop()
byte pop() {
    byte lo = bus::read(getReg16Value(regSP));
    setReg16Value(regSP, getReg16Value(regSP) + 1);
    THESTACK.pop_back();
    
    return lo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1b13d(%rip), %rdi     # 0x2f59c
callq 0x15070
movzwl %ax, %edi
callq 0x13450
movb %al, -0x1(%rbp)
leaq 0x1b126(%rip), %rdi     # 0x2f59c
callq 0x15070
movzwl %ax, %eax
addl $0x1, %eax
leaq 0x1b114(%rip), %rdi     # 0x2f59c
movzwl %ax, %esi
callq 0x15030
leaq 0x1b121(%rip), %rdi     # 0x2f5b8
callq 0x15130
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rockytriton[P]dreamsys_emu_gb/src/cpu.cpp
// Function: dsemu::cpu::init()
void init() {
    regPC = 0x100;
    *((short *)&regAF) = 0x01B0;
    *((short *)&regBC) = 0x0013;
    *((short *)&regDE) = 0x00D8;
    *((short *)&regHL) = 0x014D;
    *((short *)&regSP) = 0xFFFE;

    init_handlers();

    //olog.open("./emu.log");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw $0x100, 0x1b0a1(%rip)   # imm = 0x100
movw $0x1b0, 0x1b08a(%rip)   # imm = 0x1B0
movw $0x13, 0x1b083(%rip)    # 0x2f592
movw $0xd8, 0x1b07c(%rip)    # 0x2f594
movw $0x14d, 0x1b075(%rip)   # imm = 0x14D
movw $0xfffe, 0x1b072(%rip)  # imm = 0xFFFE
callq 0x1d130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rockytriton[P]dreamsys_emu_gb/src/emu.cpp
// Function: dsemu::run()
void run() {
    io::init();
    cpu::init();
    ppu::init();

    while(true) {
        if (cpu::paused) {
            sleepMs(1); //500);
            continue;
        }

        cpu::tick();
        ppu::tick();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x16520
callq 0x144f0
callq 0x21c80
leaq 0x191ee(%rip), %rax     # 0x2f5a8
testb $0x1, (%rax)
je 0x163cb
movl $0x1, %edi
callq 0x163e0
jmp 0x163b3
callq 0x14540
callq 0x221d0
jmp 0x163b3
nopw (%rax,%rax)
// File: rockytriton[P]dreamsys_emu_gb/src/io.cpp
// Function: dsemu::io::writeDMA(unsigned char)
void writeDMA(byte b) {
    for (int i=0; i<0xA0; i++) {
        byte d = bus::read((b * 0x100) + i);
        bus::write(0xFE00 + i, d);
    }

    cpu::extraCycles = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0xa0, -0x8(%rbp)
jge 0x164f2
movzbl -0x1(%rbp), %eax
shll $0x8, %eax
addl -0x8(%rbp), %eax
movzwl %ax, %edi
callq 0x13450
movb %al, -0x9(%rbp)
movl -0x8(%rbp), %eax
addl $0xfe00, %eax           # imm = 0xFE00
movzwl %ax, %edi
movzbl -0x9(%rbp), %esi
callq 0x13590
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x164b5
leaq 0x1909f(%rip), %rax     # 0x2f598
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rockytriton[P]dreamsys_emu_gb/src/mappers.cpp
// Function: dsemu::mappers::MPC1::read(unsigned short)
byte MPC1::read(ushort address) {
    if (!init) {
        cout << "INIT" << endl;
        memcpy(data, cart::g_romData, 0x8000);
        init = true;
    }
/*
    if (init) {
        //cout << "READ: " << Short(address) << endl;

        if (switched && address >= 0x4000 && bank > 1) {
            cout << "READ: " << Short(address) << " to " << std::hex << (int)(address + (bank * 0x4000))<< endl;
            sleepMs(500);
        } else if (bank > 1) {
            cout << "BANK0READ: " << Short(address) << endl;
        }

        //return memory::ram[address];
        //return data[address];
    }
*/
    if (address < 0x4000) {
        return cart::g_romData[address];
    }

    if (bank > 1) {
        //cout << "BANK READ: " << (int)bank << " - " << Short(address) << " to " << std::hex << (int)(address + (bank * 0x4000)) << endl;
        //sleepMs(200);
    }

    return cart::g_romData[address + (bank * 0x4000) - 0x4000];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x15f5f(%rip)     # 0x2f631
jne 0x19718
movq 0x158f5(%rip), %rdi     # 0x2efd0
leaq 0xab0c(%rip), %rsi      # 0x241ee
callq 0x32c0
movq %rax, %rdi
movq 0x158bf(%rip), %rsi     # 0x2efb0
callq 0x3310
leaq 0x15c7b(%rip), %rax     # 0x2f378
movq (%rax), %rsi
leaq 0x15f39(%rip), %rdi     # 0x2f640
movl $0x8000, %edx           # imm = 0x8000
callq 0x3240
movb $0x1, 0x15f19(%rip)     # 0x2f631
movzwl -0x12(%rbp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jge 0x19739
leaq 0x15c4e(%rip), %rax     # 0x2f378
movq (%rax), %rax
movzwl -0x12(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0x1976e
movq -0x20(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jle 0x19745
jmp 0x19745
movq -0x20(%rbp), %rdx
leaq 0x15c28(%rip), %rax     # 0x2f378
movq (%rax), %rax
movzwl -0x12(%rbp), %ecx
movl 0x8(%rdx), %edx
shll $0xe, %edx
addl %edx, %ecx
subl $0x4000, %ecx           # imm = 0x4000
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rockytriton[P]dreamsys_emu_gb/src/mappers.cpp
// Function: dsemu::mappers::MPC1::control(unsigned short, unsigned char)
void MPC1::control(ushort address, byte b) {
    cout << "CONTROL" << endl;

    if (!init) {
        memcpy(data, cart::g_romData, 0x8000);
        init = true;
    }
/*
    if (init) {
        if (address >= 0x2000 && address <= 0x3FFF) {
            bank = b & 0x1F;
            if(bank == 0 || bank == 0x20 || bank == 0x40 || bank == 0x60)
                bank++;

            switched = true;

            cout << "SWITCHING BANK: " << (int) bank << endl;
            sleepMs(200);

            memcpy(&data[0x4000], cart::g_romData + (bank * 0x4000), 0x4000);
        }
        return;
    }
*/
    if (address >= 0x6000) {
        //TODO: Memory model select...
    } else if (address >= 0x2000 && address <= 0x3FFF) {
        bank = b & 0x1F;

        if (bank == 0 || bank == 0x20 || bank == 0x40 || bank == 0x60) {
            bank++;
        }

        if (bank * 0x4000 > cart::g_romSize - 0x4000) {
            cout << "FAILURE IN MAPPER CONTROL" << endl;
            exit(-1);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x15829(%rip), %rdi     # 0x2efd0
leaq 0xaa57(%rip), %rsi      # 0x24205
callq 0x32c0
movq %rax, %rdi
movq 0x157f3(%rip), %rsi     # 0x2efb0
callq 0x3310
testb $0x1, 0x15e68(%rip)     # 0x2f631
jne 0x197ed
leaq 0x15ba6(%rip), %rax     # 0x2f378
movq (%rax), %rsi
leaq 0x15e64(%rip), %rdi     # 0x2f640
movl $0x8000, %edx           # imm = 0x8000
callq 0x3240
movb $0x1, 0x15e44(%rip)     # 0x2f631
movzwl -0xa(%rbp), %eax
cmpl $0x6000, %eax           # imm = 0x6000
jl 0x197fd
jmp 0x198a7
movzwl -0xa(%rbp), %eax
cmpl $0x2000, %eax           # imm = 0x2000
jl 0x198a5
movzwl -0xa(%rbp), %eax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jg 0x198a5
movq -0x18(%rbp), %rax
movzbl -0xb(%rbp), %ecx
andl $0x1f, %ecx
movl %ecx, 0x8(%rax)
cmpl $0x0, 0x8(%rax)
je 0x1984d
movq -0x18(%rbp), %rax
cmpl $0x20, 0x8(%rax)
je 0x1984d
movq -0x18(%rbp), %rax
cmpl $0x40, 0x8(%rax)
je 0x1984d
movq -0x18(%rbp), %rax
cmpl $0x60, 0x8(%rax)
jne 0x1985a
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
shll $0xe, %eax
leaq 0x15b15(%rip), %rcx     # 0x2f380
movl (%rcx), %ecx
subl $0x4000, %ecx           # imm = 0x4000
cmpl %ecx, %eax
jle 0x198a3
movq 0x15752(%rip), %rdi     # 0x2efd0
leaq 0xa96e(%rip), %rsi      # 0x241f3
callq 0x32c0
movq %rax, %rdi
movq 0x1571c(%rip), %rsi     # 0x2efb0
callq 0x3310
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3390
jmp 0x198a5
jmp 0x198a7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: rockytriton[P]dreamsys_emu_gb/src/memory.cpp
// Function: dsemu::memory::init()
void init() {
        ram[0xFF05] = 0x00;
        ram[0xFF06] = 0x00;
        ram[0xFF07] = 0x00;
        ram[0xFF10] = 0x80;
        ram[0xFF11] = 0xBF;
        ram[0xFF12] = 0xF3;
        ram[0xFF14] = 0xBF;
        ram[0xFF16] = 0x3F;
        ram[0xFF17] = 0x00;
        ram[0xFF19] = 0xBF;
        ram[0xFF1A] = 0x7F;
        ram[0xFF1B] = 0xFF;
        ram[0xFF1C] = 0x9F;
        ram[0xFF1E] = 0xBF;
        ram[0xFF20] = 0xFF;
        ram[0xFF21] = 0x00;
        ram[0xFF22] = 0x00;
        ram[0xFF23] = 0xBF;
        ram[0xFF24] = 0x77;
        ram[0xFF25] = 0xf3;
        ram[0xFF26] = 0xf1;
        ram[0xFF40] = 0x91;
        ram[0xFF42] = 0x00;
        ram[0xFF43] = 0x00;
        ram[0xFF45] = 0x00;
        ram[0xFF47] = 0xfc;
        ram[0xFF48] = 0xff;
        ram[0xFF49] = 0xff;
        ram[0xFF4A] = 0x00;
        ram[0xFF4B] = 0x00;
        ram[0xFFFF] = 0x00;

        std::memset(ram, 0, sizeof(ram));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x0, 0x35c9a(%rip)     # 0x4f555
movb $0x0, 0x35c94(%rip)     # 0x4f556
movb $0x0, 0x35c8e(%rip)     # 0x4f557
movb $-0x80, 0x35c90(%rip)   # 0x4f560
movb $-0x41, 0x35c8a(%rip)   # 0x4f561
movb $-0xd, 0x35c84(%rip)    # 0x4f562
movb $-0x41, 0x35c7f(%rip)   # 0x4f564
movb $0x3f, 0x35c7a(%rip)    # 0x4f566
movb $0x0, 0x35c74(%rip)     # 0x4f567
movb $-0x41, 0x35c6f(%rip)   # 0x4f569
movb $0x7f, 0x35c69(%rip)    # 0x4f56a
movb $-0x1, 0x35c63(%rip)    # 0x4f56b
movb $-0x61, 0x35c5d(%rip)   # 0x4f56c
movb $-0x41, 0x35c58(%rip)   # 0x4f56e
movb $-0x1, 0x35c53(%rip)    # 0x4f570
movb $0x0, 0x35c4d(%rip)     # 0x4f571
movb $0x0, 0x35c47(%rip)     # 0x4f572
movb $-0x41, 0x35c41(%rip)   # 0x4f573
movb $0x77, 0x35c3b(%rip)    # 0x4f574
movb $-0xd, 0x35c35(%rip)    # 0x4f575
movb $-0xf, 0x35c2f(%rip)    # 0x4f576
movb $-0x6f, 0x35c42(%rip)   # 0x4f590
movb $0x0, 0x35c3d(%rip)     # 0x4f592
movb $0x0, 0x35c37(%rip)     # 0x4f593
movb $0x0, 0x35c32(%rip)     # 0x4f595
movb $-0x4, 0x35c2d(%rip)    # 0x4f597
movb $-0x1, 0x35c27(%rip)    # 0x4f598
movb $-0x1, 0x35c21(%rip)    # 0x4f599
movb $0x0, 0x35c1b(%rip)     # 0x4f59a
movb $0x0, 0x35c15(%rip)     # 0x4f59b
movb $0x0, 0x35cc2(%rip)     # 0x4f64f
leaq 0x25cbc(%rip), %rdi     # 0x3f650
xorl %esi, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x3180
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rockytriton[P]dreamsys_emu_gb/src/memory.cpp
// Function: dsemu::memory::write(unsigned short, unsigned char)
void write(ushort address, byte value) {
        ram[address] = value;

        if (address == 0xFFFF) {
            cout << "\t - IE EN REGISTER WRITE: " << Byte(value) << endl;
            cpu::handleInterrupt(value, false);
        } else if (address == 0xFF0F) {
            cout << "\t - IE FL REGISTER WRITE: " << Byte(value) << endl;
            
            //cpu::handleInterrupt(value, true);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movw %di, %cx
movw %cx, -0x2(%rbp)
movb %al, -0x3(%rbp)
movb -0x3(%rbp), %dl
movzwl -0x2(%rbp), %eax
movl %eax, %ecx
leaq 0x25c3b(%rip), %rax     # 0x3f650
movb %dl, (%rax,%rcx)
movzwl -0x2(%rbp), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x19a75
movq 0x155a6(%rip), %rdi     # 0x2efd0
leaq 0xa80f(%rip), %rsi      # 0x24240
callq 0x32c0
movq %rax, -0x10(%rbp)
leaq -0x4(%rbp), %rdi
movzbl -0x3(%rbp), %esi
callq 0x13860
movq -0x10(%rbp), %rdi
movzbl -0x4(%rbp), %esi
callq 0x13720
movq %rax, %rdi
movq 0x15552(%rip), %rsi     # 0x2efb0
callq 0x3310
xorl %esi, %esi
movl $0x1, %edx
movzbl -0x3(%rbp), %edi
callq 0x14cc0
jmp 0x19ac2
movzwl -0x2(%rbp), %eax
cmpl $0xff0f, %eax           # imm = 0xFF0F
jne 0x19ac0
movq 0x15549(%rip), %rdi     # 0x2efd0
leaq 0xa7cd(%rip), %rsi      # 0x2425b
callq 0x32c0
movq %rax, -0x18(%rbp)
leaq -0x5(%rbp), %rdi
movzbl -0x3(%rbp), %esi
callq 0x13860
movq -0x18(%rbp), %rdi
movzbl -0x5(%rbp), %esi
callq 0x13720
movq %rax, %rdi
movq 0x154f5(%rip), %rsi     # 0x2efb0
callq 0x3310
jmp 0x19ac2
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rockytriton[P]dreamsys_emu_gb/src/op_handler.cpp
// Function: dsemu::cpu::regFromBits(unsigned char)
byte *regFromBits(byte reg) {
    byte *pReg = nullptr;

    switch(reg) {
        case 0: pReg = &regBC.hi; break; //cout << "GOT B" << endl; break;
        case 1: pReg = &regBC.lo; break; // cout << "GOT C" << endl; break;
        case 2: pReg = &regDE.hi; break; // cout << "GOT D" << endl; break;
        case 3: pReg = &regDE.lo; break; // cout << "GOT E" << endl; break;
        case 4: pReg = &regHL.hi; break; // cout << "GOT H" << endl; break;
        case 5: pReg = &regHL.lo; break; // cout << "GOT L" << endl; break;
        case 6: pReg = &memory::ram[toShort(regHL.lo, regHL.hi)]; break;
        case 7: pReg = &regAF.hi; break;
            default:
                cout << "INVALID REG " << endl;
                exit(-1);
    }

    return pReg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq $0x0, -0x10(%rbp)
movzbl -0x1(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x7, %rax
ja 0x1a384
movq -0x18(%rbp), %rax
leaq 0x9fa5(%rip), %rcx      # 0x24278
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x152af(%rip), %rax     # 0x2f592
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1a3b0
leaq 0x1529b(%rip), %rax     # 0x2f592
movq %rax, -0x10(%rbp)
jmp 0x1a3b0
leaq 0x1528d(%rip), %rax     # 0x2f594
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1a3b0
leaq 0x15279(%rip), %rax     # 0x2f594
movq %rax, -0x10(%rbp)
jmp 0x1a3b0
leaq 0x1526b(%rip), %rax     # 0x2f596
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1a3b0
leaq 0x1525a(%rip), %rax     # 0x2f596
movq %rax, -0x10(%rbp)
jmp 0x1a3b0
leaq 0x1524d(%rip), %rax     # 0x2f596
movb (%rax), %cl
leaq 0x15244(%rip), %rax     # 0x2f596
movzbl %cl, %edi
movzbl 0x1(%rax), %esi
callq 0x19ad0
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x252e6(%rip), %rax     # 0x3f650
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x1a3b0
leaq 0x15216(%rip), %rax     # 0x2f590
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1a3b0
movq 0x14c45(%rip), %rdi     # 0x2efd0
leaq 0xa062(%rip), %rsi      # 0x243f4
callq 0x32c0
movq %rax, %rdi
movq 0x14c0f(%rip), %rsi     # 0x2efb0
callq 0x3310
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3390
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rockytriton[P]dreamsys_emu_gb/src/op_handler.cpp
// Function: dsemu::cpu::getPointer(dsemu::cpu::ParamType, bool)
byte *getPointer(ParamType pt, bool hlAsRam = true) {
    switch(pt) {
        case A: return &regAF.hi;
        case B: return &regBC.hi; 
        case C: return &regBC.lo; 
        case D: return &regDE.hi; 
        case E: return &regDE.lo; 
        case H: return &regHL.hi; 
        case L: return &regHL.lo;
        case AF: return &regAF.lo;
        case BC: return &regBC.lo;
        case DE: return &regDE.lo;
        case SP: return &regSP.lo;
        case N: {
            //byte t = memory::ram[(regPC + 1)];
            //unsigned int i = 
            return &memory::ram[(regPC + 1)]; 
        } case HL: {
            return hlAsRam ? &memory::ram[getReg16Value(regHL)] : &regHL.lo;
        }
        default:
            break;
    }

    cout << "ERROR BAD POINTER" << endl;
    exit(-1);

    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movl %edi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xe, %rax
ja 0x1a516
movq -0x18(%rbp), %rax
leaq 0x9ea9(%rip), %rcx      # 0x24298
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x15191(%rip), %rax     # 0x2f590
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1a544
leaq 0x1517f(%rip), %rax     # 0x2f592
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1a544
leaq 0x1516b(%rip), %rax     # 0x2f592
movq %rax, -0x8(%rbp)
jmp 0x1a544
leaq 0x1515d(%rip), %rax     # 0x2f594
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1a544
leaq 0x15149(%rip), %rax     # 0x2f594
movq %rax, -0x8(%rbp)
jmp 0x1a544
leaq 0x1513b(%rip), %rax     # 0x2f596
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1a544
leaq 0x15127(%rip), %rax     # 0x2f596
movq %rax, -0x8(%rbp)
jmp 0x1a544
leaq 0x15111(%rip), %rax     # 0x2f590
movq %rax, -0x8(%rbp)
jmp 0x1a544
leaq 0x15103(%rip), %rax     # 0x2f592
movq %rax, -0x8(%rbp)
jmp 0x1a544
leaq 0x150f5(%rip), %rax     # 0x2f594
movq %rax, -0x8(%rbp)
jmp 0x1a544
leaq 0x150ed(%rip), %rax     # 0x2f59c
movq %rax, -0x8(%rbp)
jmp 0x1a544
leaq 0x150df(%rip), %rax     # 0x2f59e
movzwl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x25181(%rip), %rax     # 0x3f650
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x1a544
testb $0x1, -0xd(%rbp)
je 0x1a4ff
leaq 0x150b1(%rip), %rdi     # 0x2f596
callq 0x15070
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x2515a(%rip), %rax     # 0x3f650
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x1a50c
leaq 0x15090(%rip), %rax     # 0x2f596
movq %rax, -0x20(%rbp)
jmp 0x1a50c
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1a544
jmp 0x1a518
movq 0x14ab1(%rip), %rdi     # 0x2efd0
leaq 0x9edb(%rip), %rsi      # 0x24401
callq 0x32c0
movq %rax, %rdi
movq 0x14a7b(%rip), %rsi     # 0x2efb0
callq 0x3310
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3390
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop