LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: khedoros[P]khednes/compositor.cpp
// Function: compositor::erase_nt(int, int)
void compositor::erase_nt(int x,int y) {
    if(!nt) return;
    SDL_Rect all;
    all.x=x; all.y=y; all.w=8; all.h=8;
    SDL_FillRect(nt,&all,NES_TRANSPARENT);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x30(%rax)
jne 0x261b3
jmp 0x261ea
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x8(%rsp)
movl 0x18(%rsp), %ecx
movl %ecx, 0xc(%rsp)
movl $0x8, 0x10(%rsp)
movl $0x8, 0x14(%rsp)
movq 0x30(%rax), %rdi
leaq 0x8(%rsp), %rsi
movl $0x4a, %edx
callq 0x4070
addq $0x28, %rsp
retq
nop
// File: khedoros[P]khednes/compositor.cpp
// Function: compositor::add_nt_area(int, int, int, int)
void compositor::add_nt_area(int sx, int sy, int ex, int ey) {
    if(nt_regions.size() > 1000) return;
    SDL_Rect * temp = new SDL_Rect;
    temp->x = sx;
    temp->y = sy;
    temp->w = ex - sx;
    temp->h = ey - sy;
    nt_regions.push_back(temp);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x190, %rdi            # imm = 0x190
callq 0x262d0
cmpq $0x3e8, %rax            # imm = 0x3E8
jbe 0x26249
jmp 0x262a4
movl $0x10, %edi
callq 0x43d0
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl 0x18(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x14(%rsp), %ecx
subl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0x10(%rsp), %ecx
subl 0x18(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xc(%rax)
addq $0x190, %rdi            # imm = 0x190
leaq 0x8(%rsp), %rsi
callq 0x26360
addq $0x28, %rsp
retq
nopl (%rax)
// File: khedoros[P]khednes/mapper.cpp
// Function: mapper::get_pbyte(unsigned int)
const unsigned int mapper::get_pbyte(const unsigned int addr) {
    if(cart->prom_pages > 1) return cart->prom[addr-0x8000];
    else if(addr < 0xC000)
        return cart->prom[addr-0x8000];
    else
        return cart->prom[addr-0xC000];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rax
cmpl $0x1, 0x78(%rax)
jle 0x26ac9
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x28, %rdi
movl 0x14(%rsp), %eax
subl $0x8000, %eax           # imm = 0x8000
movl %eax, %eax
movl %eax, %esi
callq 0x114a0
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x26b21
cmpl $0xc000, 0x14(%rsp)     # imm = 0xC000
jae 0x26afb
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x28, %rdi
movl 0x14(%rsp), %eax
subl $0x8000, %eax           # imm = 0x8000
movl %eax, %eax
movl %eax, %esi
callq 0x114a0
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x26b21
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x28, %rdi
movl 0x14(%rsp), %eax
subl $0xc000, %eax           # imm = 0xC000
movl %eax, %eax
movl %eax, %esi
callq 0x114a0
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: khedoros[P]khednes/mapper.cpp
// Function: mapper::get_pword(unsigned int)
const unsigned int mapper::get_pword(const unsigned int addr) {
    if(cart->prom_pages > 1) return cart->prom_w[addr-0x8000];
    else if(addr < 0xC000) {
        //std::cout<<"Reading: 0x"<<std::hex<<addr<<" (0x"<<(addr-0x8000+prg_lo_offset)<<")"<<std::endl;
        return cart->prom_w[addr-0x8000];
    }
    else {
        //std::cout<<"Reading: 0x"<<std::hex<<addr<<" (0x"<<(addr-0xc000+prg_hi_offset)<<")"<<std::endl;
        return cart->prom_w[addr-0xC000];
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rax
cmpl $0x1, 0x78(%rax)
jle 0x26b78
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x40, %rdi
movl 0x14(%rsp), %eax
subl $0x8000, %eax           # imm = 0x8000
movl %eax, %eax
movl %eax, %esi
callq 0x11600
movl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x26bce
cmpl $0xc000, 0x14(%rsp)     # imm = 0xC000
jae 0x26ba9
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x40, %rdi
movl 0x14(%rsp), %eax
subl $0x8000, %eax           # imm = 0x8000
movl %eax, %eax
movl %eax, %esi
callq 0x11600
movl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x26bce
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x40, %rdi
movl 0x14(%rsp), %eax
subl $0xc000, %eax           # imm = 0xC000
movl %eax, %eax
movl %eax, %esi
callq 0x11600
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: khedoros[P]khednes/mapper.cpp
// Function: mapper::get_cbyte(unsigned int)
const unsigned int mapper::get_cbyte(const unsigned int addr) {
    if(addr>=8192) {
        std::cout<<"Trying to get CHR byte at address: "<<addr<<std::endl;
        return 0;
    }
    return cart->crom[addr];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x2000, 0x14(%rsp)     # imm = 0x2000
jb 0x26c39
movq 0x103a8(%rip), %rdi     # 0x36fb0
leaq 0x6951(%rip), %rsi      # 0x2d560
callq 0x43c0
movq %rax, %rdi
movl 0x14(%rsp), %esi
callq 0x44c0
movq %rax, %rdi
movq 0x10366(%rip), %rsi     # 0x36f90
callq 0x4400
movl $0x0, 0x24(%rsp)
jmp 0x26c58
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x58, %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x114a0
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: khedoros[P]khednes/mapper.cpp
// Function: mapper::get_page(unsigned int)
const unsigned int mapper::get_page(const unsigned int addr) {
    if(addr < 0xc000) {
        return 0;
    }
    else {
        return 1;
    }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
cmpl $0xc000, -0x14(%rsp)    # imm = 0xC000
jae 0x26d2d
movl $0x0, -0x4(%rsp)
jmp 0x26d35
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: khedoros[P]khednes/mapper_001_mmc1.cpp
// Function: mapper_001::mapper_001(rom*)
mapper_001::mapper_001(rom * r): mapper(r) {
    prg_lo_offset=0;
    prg_hi_offset=(cart->prom_pages - 1) * PRG_PAGE_SIZE;
    chr_lo_offset = 0;
    chr_hi_offset = 0x1000;

    mmc1_reg.reg0.val = 0x0c;
    mmc1_reg.reg1.val = 0;
    mmc1_reg.reg2.val = 0;
    mmc1_reg.reg3.val = 0;
    mmc1_reg.counter = 0;
    for(int i=0;i<5;++i) {
        mmc1_reg.temp[i]=false;
    }

    if(0x01 & (cart->header[6])) {
        mmc1_reg.reg0.mirror=false;
        mmc1_reg.reg0.obey_mirror=true;
    }
    else if(0x08 & (cart->header[6])) {
        mmc1_reg.reg0.mirror=false;
        mmc1_reg.reg0.obey_mirror=false;
    }
    else {
        mmc1_reg.reg0.mirror=true;
        mmc1_reg.reg0.obey_mirror=true;
    }
    mmc1_reg.reg0.high_low = true;
    mmc1_reg.reg0.large_small_prg = true;
    mmc1_reg.reg0.large_small_chr = false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x26a50
movq 0x8(%rsp), %rdi
leaq 0xfd8a(%rip), %rax      # 0x36af8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x10, %rdi
callq 0x278e0
movq 0x8(%rsp), %rax
movl $0x0, 0x44(%rax)
movq 0x8(%rax), %rcx
movl 0x78(%rcx), %ecx
subl $0x1, %ecx
shll $0xe, %ecx
movl %ecx, 0x48(%rax)
movl $0x0, 0x4c(%rax)
movl $0x1000, 0x50(%rax)     # imm = 0x1000
movb 0x28(%rax), %cl
andb $-0x20, %cl
orb $0xc, %cl
movb %cl, 0x28(%rax)
movb 0x2c(%rax), %cl
andb $-0x20, %cl
orb $0x0, %cl
movb %cl, 0x2c(%rax)
movb 0x30(%rax), %cl
andb $-0x20, %cl
orb $0x0, %cl
movb %cl, 0x30(%rax)
movb 0x34(%rax), %cl
andb $-0x10, %cl
orb $0x0, %cl
movb %cl, 0x34(%rax)
movl $0x0, 0x38(%rax)
movl $0x0, 0x14(%rsp)
cmpl $0x5, 0x14(%rsp)
jge 0x26e0a
movq 0x8(%rsp), %rax
movslq 0x14(%rsp), %rcx
movb $0x0, 0x3c(%rax,%rcx)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x26de7
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x10, %rdi
movl $0x6, %esi
callq 0x114a0
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x26e4b
movq 0x8(%rsp), %rax
movb 0x28(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0x28(%rax)
movb 0x28(%rax), %cl
andb $-0x3, %cl
orb $0x2, %cl
movb %cl, 0x28(%rax)
jmp 0x26eab
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x10, %rdi
movl $0x6, %esi
callq 0x114a0
movzbl (%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x26e8c
movq 0x8(%rsp), %rax
movb 0x28(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0x28(%rax)
movb 0x28(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0x28(%rax)
jmp 0x26ea9
movq 0x8(%rsp), %rax
movb 0x28(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x28(%rax)
movb 0x28(%rax), %cl
andb $-0x3, %cl
orb $0x2, %cl
movb %cl, 0x28(%rax)
jmp 0x26eab
movq 0x8(%rsp), %rax
movb 0x28(%rax), %cl
andb $-0x5, %cl
orb $0x4, %cl
movb %cl, 0x28(%rax)
movb 0x28(%rax), %cl
andb $-0x9, %cl
orb $0x8, %cl
movb %cl, 0x28(%rax)
movb 0x28(%rax), %cl
andb $-0x11, %cl
orb $0x0, %cl
movb %cl, 0x28(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: khedoros[P]khednes/mapper_001_mmc1.cpp
// Function: mapper_001::get_pbyte(unsigned int)
const unsigned int mapper_001::get_pbyte(const unsigned int addr) {
    if(addr < 0xC000) {
        //std::cout<<std::hex<<"Addr: "<<addr<<"("<<addr-0x8000+prg_lo_offset<<")"<<std::endl;
        return cart->prom[addr-0x8000 + prg_lo_offset];
    }
    else {
        //std::cout<<std::hex<<"Addr: "<<addr<<"("<<addr-0xc000+prg_hi_offset<<")"<<std::endl;
        //std::cout<<"Cart: "<<cart<<std::endl;
        return cart->prom[addr-0xC000 + prg_hi_offset];
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0xc000, 0x14(%rsp)     # imm = 0xC000
jae 0x26f2c
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rdi
addq $0x28, %rdi
movl 0x14(%rsp), %eax
subl $0x8000, %eax           # imm = 0x8000
addl 0x44(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x114a0
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x26f55
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rdi
addq $0x28, %rdi
movl 0x14(%rsp), %eax
subl $0xc000, %eax           # imm = 0xC000
addl 0x48(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x114a0
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: khedoros[P]khednes/mapper_001_mmc1.cpp
// Function: mapper_001::get_pword(unsigned int)
const unsigned int mapper_001::get_pword(const unsigned int addr) {
    if(addr < 0xC000) {
        //std::cout<<"Reading: 0x"<<std::hex<<addr<<" (0x"<<(addr-0x8000+prg_lo_offset)<<")"<<std::endl;
        return cart->prom_w[addr-0x8000 + prg_lo_offset];
    }
    else {
        //std::cout<<"Reading: 0x"<<std::hex<<addr<<" (0x"<<(addr-0xc000+prg_hi_offset)<<")"<<std::endl;
        return cart->prom_w[addr-0xC000 + prg_hi_offset];
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0xc000, 0x14(%rsp)     # imm = 0xC000
jae 0x26fab
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rdi
addq $0x40, %rdi
movl 0x14(%rsp), %eax
subl $0x8000, %eax           # imm = 0x8000
addl 0x44(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x11600
movl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x26fd3
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rdi
addq $0x40, %rdi
movl 0x14(%rsp), %eax
subl $0xc000, %eax           # imm = 0xC000
addl 0x48(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x11600
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: khedoros[P]khednes/mapper_001_mmc1.cpp
// Function: mapper_001::get_cbyte(unsigned int)
const unsigned int mapper_001::get_cbyte(const unsigned int addr) {
    if(addr>=8192) {
        std::cout<<"Trying to get CHR byte at address: "<<addr<<std::endl;
        return 0;
    }
    if(addr < 0x1000) return cart->crom[addr+chr_lo_offset];
    else return cart->crom[addr-0x1000+chr_hi_offset];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x2000, 0x14(%rsp)     # imm = 0x2000
jb 0x27039
movq 0xffa8(%rip), %rdi      # 0x36fb0
leaq 0x6551(%rip), %rsi      # 0x2d560
callq 0x43c0
movq %rax, %rdi
movl 0x14(%rsp), %esi
callq 0x44c0
movq %rax, %rdi
movq 0xff66(%rip), %rsi      # 0x36f90
callq 0x4400
movl $0x0, 0x24(%rsp)
jmp 0x27092
cmpl $0x1000, 0x14(%rsp)     # imm = 0x1000
jae 0x27069
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rdi
addq $0x58, %rdi
movl 0x14(%rsp), %eax
addl 0x4c(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x114a0
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x27092
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rdi
addq $0x58, %rdi
movl 0x14(%rsp), %eax
subl $0x1000, %eax           # imm = 0x1000
addl 0x50(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x114a0
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: khedoros[P]khednes/mapper_001_mmc1.cpp
// Function: mapper_001::tempval(bool*)
int mapper_001::tempval(bool * val) {
    int retval = 0;
    for(int i = 4; i >= 0; --i) {
        retval<<=(1);
        retval |= int(val[i]);
    }
    return retval;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x4, -0x18(%rsp)
cmpl $0x0, -0x18(%rsp)
jl 0x27762
movl -0x14(%rsp), %eax
shll %eax
movl %eax, -0x14(%rsp)
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
orl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
movl -0x18(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x2772a
movl -0x14(%rsp), %eax
retq
nopw (%rax,%rax)
// File: khedoros[P]khednes/mapper_001_mmc1.cpp
// Function: mapper_001::put_cbyte(unsigned int, unsigned int)
bool mapper_001::put_cbyte(const unsigned int val,const unsigned int addr) {
    if(cart->crom_pages == 0) {
        cart->crom[addr]=val;
        return true;
    }
    else return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rax
cmpl $0x0, 0x7c(%rax)
jne 0x277c2
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movb %cl, 0x7(%rsp)
movq 0x8(%rax), %rdi
addq $0x58, %rdi
movl 0x10(%rsp), %eax
movl %eax, %esi
callq 0x114a0
movb 0x7(%rsp), %cl
movb %cl, (%rax)
movb $0x1, 0x27(%rsp)
jmp 0x277c7
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: khedoros[P]khednes/mapper_001_mmc1.cpp
// Function: mapper_001::get_page(unsigned int)
const unsigned int mapper_001::get_page(const unsigned int addr) {
    if(addr < 0xc000) {
        return prg_lo_offset / PRG_PAGE_SIZE;
    }   
    else {
        return prg_hi_offset / PRG_PAGE_SIZE;
    }   
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpl $0xc000, -0x14(%rsp)    # imm = 0xC000
jae 0x278be
movq -0x20(%rsp), %rax
movl 0x44(%rax), %eax
shrl $0xe, %eax
movl %eax, -0x4(%rsp)
jmp 0x278cd
movq -0x20(%rsp), %rax
movl 0x48(%rax), %eax
shrl $0xe, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: khedoros[P]khednes/mapper_002_unrom.cpp
// Function: mapper_002::get_pbyte(unsigned int)
const unsigned int mapper_002::get_pbyte(const unsigned int addr) {
    if(addr < 0xC000)
        return cart->prom[addr-0x8000+prg_lo_offset];
    else
        return cart->prom[addr-0xC000+prg_hi_offset];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0xc000, 0x14(%rsp)     # imm = 0xC000
jae 0x27f1c
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rdi
addq $0x28, %rdi
movl 0x14(%rsp), %eax
subl $0x8000, %eax           # imm = 0x8000
addl 0x10(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x114a0
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x27f45
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rdi
addq $0x28, %rdi
movl 0x14(%rsp), %eax
subl $0xc000, %eax           # imm = 0xC000
addl 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x114a0
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: khedoros[P]khednes/mapper_002_unrom.cpp
// Function: mapper_002::get_pword(unsigned int)
const unsigned int mapper_002::get_pword(const unsigned int addr) {
    if(addr < 0xC000) {
        //std::cout<<"Reading: 0x"<<std::hex<<addr<<" (0x"<<(addr-0x8000+prg_lo_offset)<<")"<<std::endl;
        return cart->prom_w[addr-0x8000+prg_lo_offset];
    }
    else {
        //std::cout<<"Reading: 0x"<<std::hex<<addr<<" (0x"<<(addr-0xc000+prg_hi_offset)<<")"<<std::endl;
        return cart->prom_w[addr-0xC000+prg_hi_offset];
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0xc000, 0x14(%rsp)     # imm = 0xC000
jae 0x27f9b
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rdi
addq $0x40, %rdi
movl 0x14(%rsp), %eax
subl $0x8000, %eax           # imm = 0x8000
addl 0x10(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x11600
movl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x27fc3
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rdi
addq $0x40, %rdi
movl 0x14(%rsp), %eax
subl $0xc000, %eax           # imm = 0xC000
addl 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x11600
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: khedoros[P]khednes/mapper_002_unrom.cpp
// Function: mapper_002::put_cbyte(unsigned int, unsigned int)
bool mapper_002::put_cbyte(const unsigned int val,const unsigned int addr) {
    if(cart->crom_pages == 0) {
        cart->crom[addr]=val;
        cart->updated_crom = 3;
        return true;
    }
    else return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rax
cmpl $0x0, 0x7c(%rax)
jne 0x28088
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movb %cl, 0x7(%rsp)
movq 0x8(%rax), %rdi
addq $0x58, %rdi
movl 0x10(%rsp), %eax
movl %eax, %esi
callq 0x114a0
movb 0x7(%rsp), %dl
movq %rax, %rcx
movq 0x8(%rsp), %rax
movb %dl, (%rcx)
movq 0x8(%rax), %rax
movl $0x3, 0xa4(%rax)
movb $0x1, 0x27(%rsp)
jmp 0x2808d
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: khedoros[P]khednes/mapper_002_unrom.cpp
// Function: mapper_002::get_page(unsigned int)
const unsigned int mapper_002::get_page(const unsigned int addr) {
    if(addr < 0xc000) {
        return prg_lo_offset / PRG_PAGE_SIZE;
    }
    else {
        return prg_hi_offset / PRG_PAGE_SIZE;
    }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpl $0xc000, -0x14(%rsp)    # imm = 0xC000
jae 0x280fe
movq -0x20(%rsp), %rax
movl 0x10(%rax), %eax
shrl $0xe, %eax
movl %eax, -0x4(%rsp)
jmp 0x2810d
movq -0x20(%rsp), %rax
movl 0x14(%rax), %eax
shrl $0xe, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: khedoros[P]khednes/mapper_003_cnrom.cpp
// Function: mapper_003::get_pbyte(unsigned int)
const unsigned int mapper_003::get_pbyte(const unsigned int addr) {
    if(cart->prom_pages > 1) return cart->prom[addr-0x8000];
    else if(addr < 0xC000)
        return cart->prom[addr-0x8000];
    else
        return cart->prom[addr-0xC000];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rax
cmpl $0x1, 0x78(%rax)
jle 0x281c9
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x28, %rdi
movl 0x14(%rsp), %eax
subl $0x8000, %eax           # imm = 0x8000
movl %eax, %eax
movl %eax, %esi
callq 0x114a0
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x28221
cmpl $0xc000, 0x14(%rsp)     # imm = 0xC000
jae 0x281fb
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x28, %rdi
movl 0x14(%rsp), %eax
subl $0x8000, %eax           # imm = 0x8000
movl %eax, %eax
movl %eax, %esi
callq 0x114a0
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x28221
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x28, %rdi
movl 0x14(%rsp), %eax
subl $0xc000, %eax           # imm = 0xC000
movl %eax, %eax
movl %eax, %esi
callq 0x114a0
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: khedoros[P]khednes/mapper_003_cnrom.cpp
// Function: mapper_003::get_pword(unsigned int)
const unsigned int mapper_003::get_pword(const unsigned int addr) {
    if(cart->prom_pages > 1) return cart->prom_w[addr-0x8000];
    else if(addr < 0xC000) {
        //std::cout<<"Reading: 0x"<<std::hex<<addr<<" (0x"<<(addr-0x8000+prg_lo_offset)<<")"<<std::endl;
        return cart->prom_w[addr-0x8000];
    }
    else {
        //std::cout<<"Reading: 0x"<<std::hex<<addr<<" (0x"<<(addr-0xc000+prg_hi_offset)<<")"<<std::endl;
        return cart->prom_w[addr-0xC000];
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rax
cmpl $0x1, 0x78(%rax)
jle 0x28278
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x40, %rdi
movl 0x14(%rsp), %eax
subl $0x8000, %eax           # imm = 0x8000
movl %eax, %eax
movl %eax, %esi
callq 0x11600
movl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x282ce
cmpl $0xc000, 0x14(%rsp)     # imm = 0xC000
jae 0x282a9
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x40, %rdi
movl 0x14(%rsp), %eax
subl $0x8000, %eax           # imm = 0x8000
movl %eax, %eax
movl %eax, %esi
callq 0x11600
movl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x282ce
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x40, %rdi
movl 0x14(%rsp), %eax
subl $0xc000, %eax           # imm = 0xC000
movl %eax, %eax
movl %eax, %esi
callq 0x11600
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: khedoros[P]khednes/mapper_003_cnrom.cpp
// Function: mapper_003::get_cbyte(unsigned int)
const unsigned int mapper_003::get_cbyte(const unsigned int addr) {
    if(addr>=8192) {
        std::cout<<"Trying to get CHR byte at address: "<<addr<<std::endl;
        return 0;
    }
    return cart->crom[addr];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x2000, 0x14(%rsp)     # imm = 0x2000
jb 0x28339
movq 0xeca8(%rip), %rdi      # 0x36fb0
leaq 0x5251(%rip), %rsi      # 0x2d560
callq 0x43c0
movq %rax, %rdi
movl 0x14(%rsp), %esi
callq 0x44c0
movq %rax, %rdi
movq 0xec66(%rip), %rsi      # 0x36f90
callq 0x4400
movl $0x0, 0x24(%rsp)
jmp 0x28358
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x58, %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x114a0
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: khedoros[P]khednes/mapper_003_cnrom.cpp
// Function: mapper_003::put_pbyte(unsigned int, unsigned int, unsigned int)
void mapper_003::put_pbyte(const unsigned int cycle, const unsigned int val,const unsigned int addr) {
        cart->updated_crom = 3;
        int real_val = ((val & get_pbyte(addr))&0x3);
        int new_chr_lo_offset = CHR_PAGE_SIZE * real_val;
        int new_chr_hi_offset = new_chr_lo_offset + 0x1000;
        ppu_change(cycle, lo_crom, new_chr_lo_offset);
        ppu_change(cycle, hi_crom, new_chr_hi_offset);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x8(%rdi), %rax
movl $0x3, 0xa4(%rax)
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x24(%rsp), %esi
movq (%rdi), %rax
callq *(%rax)
movq 0x10(%rsp), %rdi
movl %eax, %ecx
movl 0xc(%rsp), %eax
andl %ecx, %eax
andl $0x3, %eax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
shll $0xd, %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1000, %eax           # imm = 0x1000
movl %eax, 0x18(%rsp)
movl 0x2c(%rsp), %esi
movl 0x1c(%rsp), %ecx
movq (%rdi), %rax
xorl %edx, %edx
callq *0x50(%rax)
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x18(%rsp), %ecx
movq (%rdi), %rax
movl $0x1, %edx
callq *0x50(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: khedoros[P]khednes/mapper_011_color_dreams.cpp
// Function: mapper_011::mapper_011(rom*)
mapper_011::mapper_011(rom* r) : mapper(r) {
    prg_hi_offset = (r->prom_pages - 1) * PRG_PAGE_SIZE;
    prg_lo_offset = (r->prom_pages - 2) * PRG_PAGE_SIZE;
    chr_lo_offset = 0;
    chr_hi_offset = 0x1000;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0x26a50
movq (%rsp), %rdi
leaq 0xdd34(%rip), %rax      # 0x36c70
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x10, %rdi
callq 0x295e0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movl 0x78(%rcx), %ecx
subl $0x1, %ecx
shll $0xe, %ecx
movl %ecx, 0x28(%rax)
movq 0x8(%rsp), %rcx
movl 0x78(%rcx), %ecx
subl $0x2, %ecx
shll $0xe, %ecx
movl %ecx, 0x2c(%rax)
movl $0x0, 0x30(%rax)
movl $0x1000, 0x34(%rax)     # imm = 0x1000
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: khedoros[P]khednes/mapper_011_color_dreams.cpp
// Function: mapper_011::get_pbyte(unsigned int)
const unsigned int mapper_011::get_pbyte(const unsigned int addr) {
    if(cart->prom_pages > 1) return cart->prom[addr-0x8000];
    else if(addr < 0xC000)
        return cart->prom[addr-0x8000];
    else
        return cart->prom[addr-0xC000];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rax
cmpl $0x1, 0x78(%rax)
jle 0x28fd9
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x28, %rdi
movl 0x14(%rsp), %eax
subl $0x8000, %eax           # imm = 0x8000
movl %eax, %eax
movl %eax, %esi
callq 0x114a0
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x29031
cmpl $0xc000, 0x14(%rsp)     # imm = 0xC000
jae 0x2900b
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x28, %rdi
movl 0x14(%rsp), %eax
subl $0x8000, %eax           # imm = 0x8000
movl %eax, %eax
movl %eax, %esi
callq 0x114a0
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x29031
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x28, %rdi
movl 0x14(%rsp), %eax
subl $0xc000, %eax           # imm = 0xC000
movl %eax, %eax
movl %eax, %esi
callq 0x114a0
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: khedoros[P]khednes/mapper_011_color_dreams.cpp
// Function: mapper_011::get_cbyte(unsigned int)
const unsigned int mapper_011::get_cbyte(const unsigned int addr) {
    if(addr>=8192) {
        std::cout<<"Trying to get CHR byte at address: "<<addr<<std::endl;
        return 0;
    }
    return cart->crom[addr];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x2000, 0x14(%rsp)     # imm = 0x2000
jb 0x29149
movq 0xde98(%rip), %rdi      # 0x36fb0
leaq 0x4441(%rip), %rsi      # 0x2d560
callq 0x43c0
movq %rax, %rdi
movl 0x14(%rsp), %esi
callq 0x44c0
movq %rax, %rdi
movq 0xde56(%rip), %rsi      # 0x36f90
callq 0x4400
movl $0x0, 0x24(%rsp)
jmp 0x29168
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x58, %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x114a0
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: khedoros[P]khednes/mapper_011_color_dreams.cpp
// Function: mapper_011::put_pbyte(unsigned int, unsigned int, unsigned int)
void mapper_011::put_pbyte(const unsigned int cycle, const unsigned int val,const unsigned int addr) {
    int real_val = val & get_pbyte(addr);
    int prg_page = (real_val & 3);
    int chr_page = real_val / 16;
    //std::cout<<"Switch to PRG page "<<prg_page<<", CHR page "<<chr_page<<std::endl;
    prg_lo_offset = 2 * prg_page * PRG_PAGE_SIZE;
    prg_hi_offset = ((2 * prg_page) + 1) * PRG_PAGE_SIZE;
    int new_chr_lo_offset = chr_page * CHR_PAGE_SIZE;
    int new_chr_hi_offset = new_chr_lo_offset + 0x1000;
    ppu_change(cycle, lo_crom, new_chr_lo_offset);
    ppu_change(cycle, hi_crom, new_chr_hi_offset);
    cart->updated_crom = 3;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x24(%rsp), %esi
movq (%rdi), %rax
callq *(%rax)
movq 0x8(%rsp), %rdi
movl %eax, %ecx
movl 0x4(%rsp), %eax
andl %ecx, %eax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
andl $0x3, %eax
movl %eax, 0x1c(%rsp)
movl 0x20(%rsp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
shll %eax
shll $0xe, %eax
movl %eax, 0x2c(%rdi)
movl 0x1c(%rsp), %eax
shll %eax
addl $0x1, %eax
shll $0xe, %eax
movl %eax, 0x28(%rdi)
movl 0x18(%rsp), %eax
shll $0xd, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addl $0x1000, %eax           # imm = 0x1000
movl %eax, 0x10(%rsp)
movl 0x2c(%rsp), %esi
movl 0x14(%rsp), %ecx
movq (%rdi), %rax
xorl %edx, %edx
callq *0x50(%rax)
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x10(%rsp), %ecx
movq (%rdi), %rax
movl $0x1, %edx
callq *0x50(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl $0x3, 0xa4(%rax)
addq $0x38, %rsp
retq
nop
// File: khedoros[P]khednes/mapper_011_color_dreams.cpp
// Function: mapper_011::get_page(unsigned int)
const unsigned int mapper_011::get_page(const unsigned int addr) {
    if(addr < 0xc000) {
        return prg_lo_offset / PRG_PAGE_SIZE;
    }
    else {
        return prg_hi_offset / PRG_PAGE_SIZE;
    }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpl $0xc000, -0x14(%rsp)    # imm = 0xC000
jae 0x295be
movq -0x20(%rsp), %rax
movl 0x2c(%rax), %eax
shrl $0xe, %eax
movl %eax, -0x4(%rsp)
jmp 0x295cd
movq -0x20(%rsp), %rax
movl 0x28(%rax), %eax
shrl $0xe, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: khedoros[P]khednes/mapper_nsf.cpp
// Function: mapper_nsf::reset_map()
void mapper_nsf::reset_map() {
    if(cart->uses_banks) {
        for(int i=0;i<8;++i)
            bank[i] = cart->get_header(0x70+i);
    }
    else {
        for(int i=0;i<8;++i)
            bank[i] = i;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rax), %rax
testb $0x1, 0xcf(%rax)
je 0x29fe0
movl $0x0, 0xc(%rsp)
cmpl $0x8, 0xc(%rsp)
jge 0x29fde
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movl 0xc(%rsp), %esi
addl $0x70, %esi
callq 0x10fe0
movl %eax, %edx
movq (%rsp), %rax
movslq 0xc(%rsp), %rcx
movl %edx, 0x18(%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x29fa7
jmp 0x2a00f
movl $0x0, 0x8(%rsp)
cmpl $0x8, 0x8(%rsp)
jge 0x2a00d
movq (%rsp), %rax
movl 0x8(%rsp), %edx
movslq 0x8(%rsp), %rcx
movl %edx, 0x18(%rax,%rcx,4)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x29fe8
jmp 0x2a00f
addq $0x18, %rsp
retq
// File: rom1v[P]metahanoi/hanoi.cpp
// Function: Hanoi::solveRec(unsigned int, unsigned int)
void solveRec(size disks, tower target) {
        if (disks == 0) {
            return;
        }
        // the tower of the largest disk at this depth of recursion
        tower &largest = state[state.size() - disks];
        if (largest == target) {
            // the largest disk is already on the target tower
            solveRec(disks - 1, target);
        } else {
            // move disks above the largest to the intermediate tower
            solveRec(disks - 1, other(largest, target));
            // move the largest disk to the target
            largest = target;
            printState();
            // move back the disks on the largest
            solveRec(disks - 1, target);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x1d35
jmp 0x1dbc
movq -0x20(%rbp), %rdi
callq 0x1dd0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movl -0xc(%rbp), %eax
subq %rax, %rsi
callq 0x22b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x1d73
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
subl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x1d10
jmp 0x1dbc
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
movl -0x10(%rbp), %esi
callq 0x22d0
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdi
movl %eax, %edx
callq 0x1d10
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
callq 0x1ca0
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
subl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x1d10
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: fpavetic[P]lcskpp/./random_strings.h
// Function: generate_similar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&)
std::string generate_similar(const std::string& a, 
                             const double& p_err) {
  std::string b = a;
  for (int i = 0; i < b.size(); ++i) {
    if (1.0*rand()/RAND_MAX <= p_err) {
      b[i] = get_random_base();
    }
  }
  return b;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movb $0x0, 0x3f(%rsp)
movq 0x48(%rsp), %rsi
callq 0x20a0
movl $0x0, 0x38(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x2110
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x25b4
callq 0x2060
cvtsi2sd %eax, %xmm0
movsd 0xfad3(%rip), %xmm1     # 0x12010
mulsd %xmm0, %xmm1
movsd 0xfabf(%rip), %xmm0     # 0x12008
divsd %xmm0, %xmm1
movq 0x40(%rsp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x25a2
callq 0x24a0
movq 0x18(%rsp), %rdi
movb %al, 0x7(%rsp)
movslq 0x38(%rsp), %rsi
callq 0x2290
movq %rax, 0x8(%rsp)
jmp 0x257b
movq 0x8(%rsp), %rax
movb 0x7(%rsp), %cl
movb %cl, (%rax)
jmp 0x25a2
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x22a8
jmp 0x25d4
jmp 0x25a4
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x2507
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x25ca
movq 0x18(%rsp), %rdi
callq 0x22a8
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x2270
nop
// File: fpavetic[P]lcskpp/./random_strings.h
// Function: generate_string[abi:cxx11](int const&)
std::string generate_string(const int& len) {
  std::string ret;
  for (int i = 0; i < len; ++i) {
    ret += get_random_base();
  }
  assert(ret.size() == len);
  return ret;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb $0x0, 0x27(%rsp)
callq 0x21f0
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x2654
callq 0x24a0
movq (%rsp), %rdi
movsbl %al, %esi
callq 0x20e0
jmp 0x262c
jmp 0x262e
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x260c
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x22a8
jmp 0x26aa
movq (%rsp), %rdi
callq 0x2110
movq 0x28(%rsp), %rcx
movslq (%rcx), %rcx
cmpq %rcx, %rax
jne 0x266c
jmp 0x268b
leaq 0xf9ca(%rip), %rdi      # 0x1203d
leaq 0xf9d5(%rip), %rsi      # 0x1204f
movl $0x27, %edx
leaq 0xf9dc(%rip), %rcx      # 0x12062
callq 0x20f0
movb $0x1, 0x27(%rsp)
testb $0x1, 0x27(%rsp)
jne 0x26a0
movq (%rsp), %rdi
callq 0x22a8
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x2270
nopw %cs:(%rax,%rax)
// File: fpavetic[P]lcskpp/test_lcskpp.cpp
// Function: run_one_simulation()
int run_one_simulation() {
  pair<string, string> ab;
  ab.first = generate_string(kStringLen);
  ab.second = kPerr < 0 ? 
                      generate_string(kStringLen) : 
                      generate_similar(ab.first, kPerr);
  const string& a = ab.first;
  const string& b = ab.second;
  return test_lcskpp(a, b, kK);
}

// Assembly:
subq $0xb8, %rsp
leaq 0x78(%rsp), %rdi
callq 0x2c90
leaq 0xf9a8(%rip), %rsi      # 0x12280
leaq 0x58(%rsp), %rdi
callq 0x25e0
jmp 0x28e4
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x21c0
leaq 0x58(%rsp), %rdi
callq 0x22a8
xorl %eax, %eax
testb $0x1, %al
jne 0x2905
jmp 0x291a
leaq 0xf974(%rip), %rsi      # 0x12280
leaq 0x28(%rsp), %rdi
callq 0x25e0
jmp 0x2918
jmp 0x2934
leaq 0xf967(%rip), %rdx      # 0x12288
leaq 0x28(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x24d0
jmp 0x2932
jmp 0x2934
leaq 0x98(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x28(%rsp), %rsi
movq %rsi, (%rsp)
callq 0x21c0
movq (%rsp), %rdi
callq 0x22a8
movq 0x8(%rsp), %rax
leaq 0x78(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0xa, %edx
callq 0x26c0
movl %eax, 0x14(%rsp)
jmp 0x2986
leaq 0x78(%rsp), %rdi
callq 0x2cc0
movl 0x14(%rsp), %eax
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x2cc0
movq 0x50(%rsp), %rdi
callq 0x2270
nop
// File: fpavetic[P]lcskpp/test_lcskpp.cpp
// Function: main
int main(int argc, char* argv[]) {
  printf("Running tests on %d random pairs ", kSimulationRuns);
  printf("with the following parameters:\n");
  printf("  string length=%d\n", kStringLen);
  printf("  k=%d\n", kK);
  printf("  pErr=%0.2lf\n", kPerr);

  srand(1603);

  map<int, double> distr;
  calculate_distribution(distr);

  double sum_prob = 0;
  double e_lcs = 0;

  for (int i = 0; i <= kStringLen; ++i) {
    double p = distr[i];
    sum_prob += p;
    e_lcs += p*i;
  }

  assert(0.99999 <= sum_prob <= 1.00001);
  printf("Expected LCSk++=%0.3lf\n", e_lcs);
  printf("Test PASSED!\n");
  return 0;
}

// Assembly:
subq $0x88, %rsp
movl $0x0, 0x84(%rsp)
movl %edi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
leaq 0xf761(%rip), %rdi      # 0x121b6
xorl %eax, %eax
movb %al, 0xf(%rsp)
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x2030
movb 0xf(%rsp), %al
leaq 0xf768(%rip), %rdi      # 0x121d8
callq 0x2030
movb 0xf(%rsp), %al
leaq 0xf778(%rip), %rdi      # 0x121f8
movl $0x64, %esi
callq 0x2030
movb 0xf(%rsp), %al
leaq 0xf777(%rip), %rdi      # 0x1220c
movl $0xa, %esi
callq 0x2030
leaq 0xf76e(%rip), %rdi      # 0x12214
movsd 0xf572(%rip), %xmm0     # 0x12020
movb $0x1, %al
callq 0x2030
movl $0x643, %edi            # imm = 0x643
callq 0x2160
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2df0
movq 0x10(%rsp), %rdi
callq 0x29c0
jmp 0x2ada
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
cmpl $0x64, 0x24(%rsp)
jg 0x2b7a
leaq 0x48(%rsp), %rdi
leaq 0x24(%rsp), %rsi
callq 0x2e00
movq %rax, (%rsp)
jmp 0x2b10
movq (%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
addsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x18(%rsp), %xmm0
cvtsi2sdl 0x24(%rsp), %xmm2
movsd 0x28(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x2af4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2ef0
jmp 0x2c11
movsd 0x30(%rsp), %xmm0
movsd 0xf4a8(%rip), %xmm1     # 0x12030
ucomisd %xmm1, %xmm0
setae %al
andb $0x1, %al
movzbl %al, %eax
cvtsi2sd %eax, %xmm1
movsd 0xf488(%rip), %xmm0     # 0x12028
ucomisd %xmm1, %xmm0
jb 0x2ba8
jmp 0x2bc7
leaq 0xf674(%rip), %rdi      # 0x12223
leaq 0xf4fd(%rip), %rsi      # 0x120b3
movl $0x6b, %edx
leaq 0xf680(%rip), %rcx      # 0x12242
callq 0x20f0
movsd 0x28(%rsp), %xmm0
leaq 0xf685(%rip), %rdi      # 0x12259
movb $0x1, %al
callq 0x2030
jmp 0x2bdd
leaq 0xf68d(%rip), %rdi      # 0x12271
xorl %eax, %eax
callq 0x2030
jmp 0x2bed
movl $0x0, 0x84(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2ef0
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x2270
nopl (%rax,%rax)
// File: fpavetic[P]lcskpp/lcskpp.cpp
// Function: lcskpp_sparse_slow(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>*)
void lcskpp_sparse_slow(
    const string& a, const string& b,
    const int k, int* lcskpp_length,
    vector<pair<int, int> >* lcskpp_reconstruction) {
  vector<pair<int, int> > matches;
  get_matches(a, b, k, &matches);
  lcskpp_sparse_slow(matches, k, lcskpp_length, 
                     lcskpp_reconstruction);  
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
leaq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x2c20
movq (%rsp), %rcx
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movl 0x44(%rsp), %edx
callq 0x4a70
jmp 0x4a23
movl 0x44(%rsp), %esi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
leaq 0x18(%rsp), %rdi
callq 0x5060
jmp 0x4a3d
leaq 0x18(%rsp), %rdi
callq 0x2c30
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x2c30
movq 0x10(%rsp), %rdi
callq 0x2270
nop
// File: fpavetic[P]lcskpp/lcskpp.cpp
// Function: lcskpp_sparse_fast(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>*)
void lcskpp_sparse_fast(
    const string& a, const string& b,
    const int k, int* lcskpp_length,
    vector<pair<int, int> >* lcskpp_reconstruction) {
  vector<pair<int, int> > matches;
  get_matches(a, b, k, &matches);
  lcskpp_sparse_fast(matches, k, lcskpp_length, 
                     lcskpp_reconstruction);  
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
leaq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x2c20
movq (%rsp), %rcx
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movl 0x44(%rsp), %edx
callq 0x4a70
jmp 0x5683
movl 0x44(%rsp), %esi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
leaq 0x18(%rsp), %rdi
callq 0x56d0
jmp 0x569d
leaq 0x18(%rsp), %rdi
callq 0x2c30
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x2c30
movq 0x10(%rsp), %rdi
callq 0x2270
nop
// File: fpavetic[P]lcskpp/lcskpp.cpp
// Function: lcskpp(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&, int, int*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>*)
void lcskpp(const vector<pair<int, int> >& matches,
          const int k, int* lcskpp_length,
          vector<pair<int, int> >* lcskpp_reconstruction) {
  if (matches.size() < 700) {
    lcskpp_sparse_slow(matches, k, lcskpp_length, 
                       lcskpp_reconstruction);
  } else {
    lcskpp_sparse_fast(matches, k, lcskpp_length, 
                       lcskpp_reconstruction);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x7350
cmpq $0x2bc, %rax            # imm = 0x2BC
jae 0x62a3
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x5060
jmp 0x62bb
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x56d0
addq $0x28, %rsp
retq
// File: fpavetic[P]lcskpp/lcskpp.cpp
// Function: prepare_alphabet(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<char, std::allocator<char>>&, int&)
static void prepare_alphabet(
    const string& a, const string& b,
    vector<char>& aid, int& alphabet_size) {
  aid = vector<char>(256, -1);
  alphabet_size = 0;

  for (size_t i = 0; i < a.size(); ++i) {
    if (aid[a[i]] == -1) {
      aid[a[i]] = alphabet_size++;
    }
  }
  for (size_t i = 0; i < b.size(); ++i) {
    if (aid[b[i]] == -1) {
      aid[b[i]] = alphabet_size++;
    }
  }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movb $-0x1, 0x6f(%rsp)
leaq 0x6e(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x2280
movq 0x40(%rsp), %rcx
leaq 0x70(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
leaq 0x6f(%rsp), %rdx
callq 0x7b40
jmp 0x6db6
movq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x7bc0
leaq 0x70(%rsp), %rdi
callq 0x7a10
leaq 0x6e(%rsp), %rdi
callq 0x2190
movq 0x88(%rsp), %rax
movl $0x0, (%rax)
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x2110
movq %rax, %rcx
movq 0x38(%rsp), %rax
cmpq %rcx, %rax
jae 0x6ecc
movq 0x90(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x21a0
movq 0x30(%rsp), %rdi
movsbq (%rax), %rsi
callq 0x7770
movsbl (%rax), %eax
cmpl $-0x1, %eax
jne 0x6eb7
movq 0x88(%rsp), %rcx
movl (%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, (%rcx)
movb %al, 0x2f(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x21a0
movq 0x20(%rsp), %rdi
movsbq (%rax), %rsi
callq 0x7770
movb 0x2f(%rsp), %cl
movb %cl, (%rax)
jmp 0x6eb7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x6e(%rsp), %rdi
callq 0x2190
jmp 0x6f95
jmp 0x6eb9
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0x6df3
movq $0x0, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x98(%rsp), %rdi
callq 0x2110
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x6f8d
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x21a0
movq 0x10(%rsp), %rdi
movsbq (%rax), %rsi
callq 0x7770
movsbl (%rax), %eax
cmpl $-0x1, %eax
jne 0x6f78
movq 0x88(%rsp), %rcx
movl (%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, (%rcx)
movb %al, 0xf(%rsp)
movq 0x90(%rsp), %rax
movq %rax, (%rsp)
movq 0x98(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x21a0
movq (%rsp), %rdi
movsbq (%rax), %rsi
callq 0x7770
movb 0xf(%rsp), %cl
movb %cl, (%rax)
jmp 0x6f7a
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x6ed5
addq $0xa8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x2270
nop
// File: fpavetic[P]lcskpp/./fenwick.h
// Function: FenwickMax<std::pair<int, int>>::get(unsigned long)
T get(size_t pos) {
    ++pos;
    T ret = T();
    for ( ; pos > 0; pos -= lobit(pos)) {
      ret = std::max(ret, elements_[pos]);
    }
    return ret;
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xf910
cmpq $0x0, 0x10(%rsp)
jbe 0xcb02
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x10500
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0x104c0
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0x10520
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10550
movq %rax, %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0xcab0
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: Thomas1995[P]Rentz/src/score.cpp
// Function: Table::ScoreTotals(int&)
void Table::ScoreTotals(int& scoreToAdd) {
    ScoreKingOfHearts(scoreToAdd);
    ScoreQueens(scoreToAdd);
    ScoreDiamonds(scoreToAdd);
    ScoreAcool(scoreToAdd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x5350
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x53f0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5480
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5510
addq $0x20, %rsp
popq %rbp
retq
nop