LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Olverine[P]TerminalGraphics/./Graphics.h
// Function: DrawPoint(glm::tvec3<float, (glm::precision)0>)
void DrawPoint(vec3 point) {
	int index = pixelLocationToCharIndex(point);
	if (pointIsOutOfBounds(point) || point.z < zBuffer[index]) return;

	char c = getGreyscaleChar(point.z);
	setPixel(index, c, point.z);
	if (point.z < zBuffer[index + 1]) return;
	setPixel(index + 1, c, point.z);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movlpd %xmm0, -0x20(%rbp)
movss %xmm1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movss -0x38(%rbp), %xmm1
callq 0x2d80
movl %eax, -0x24(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
movss -0x58(%rbp), %xmm1
callq 0x2d00
testb $0x1, %al
jne 0x2f37
movss -0x8(%rbp), %xmm1
movslq -0x24(%rbp), %rcx
leaq 0x6323(%rip), %rax      # 0x9250
movss (%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2f39
jmp 0x2f90
movss -0x8(%rbp), %xmm0
callq 0x2e00
movb %al, -0x61(%rbp)
movl -0x24(%rbp), %edi
movb -0x61(%rbp), %al
movss -0x8(%rbp), %xmm0
movsbl %al, %esi
callq 0x2e40
movss -0x8(%rbp), %xmm1
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x62e2(%rip), %rax      # 0x9250
movss (%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2f7a
jmp 0x2f90
movl -0x24(%rbp), %edi
addl $0x1, %edi
movb -0x61(%rbp), %al
movss -0x8(%rbp), %xmm0
movsbl %al, %esi
callq 0x2e40
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Olverine[P]TerminalGraphics/./Graphics.h
// Function: initViewPort()
void initViewPort(){
	for(int y = 0; y < 33; y++) {
		for (int x = 0; x < 33; x++) {
			clear += "  ";
		}
		clear += "\n";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x21, -0x4(%rbp)
jge 0x3c1e
movl $0x0, -0x8(%rbp)
cmpl $0x21, -0x8(%rbp)
jge 0x3c00
leaq 0x561f(%rip), %rdi      # 0x9208
leaq 0x244c(%rip), %rsi      # 0x603c
callq 0x21c0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3bdc
leaq 0x5601(%rip), %rdi      # 0x9208
leaq 0x2431(%rip), %rsi      # 0x603f
callq 0x21c0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3bcf
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hcoona[P]POJ-Solutions/P1061.cpp
// Function: POJ::P1061::Run(std::istream&, std::ostream&)
void P1061::Run(istream &in, ostream &out)
    {
        int x, y, m, n, L;
        in >> x >> y >> m >> n >> L;
        int result = Solve(x, y, m, n, L);
        if (result != INVALID) {
            out << result << endl;
        } else {
            out << "Impossible" << endl;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x1050
movq %rax, %rdi
leaq -0x20(%rbp), %rsi
callq 0x1050
movq %rax, %rdi
leaq -0x24(%rbp), %rsi
callq 0x1050
movq %rax, %rdi
leaq -0x28(%rbp), %rsi
callq 0x1050
movq %rax, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x1050
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
movl -0x2c(%rbp), %r9d
callq 0x1300
movl %eax, -0x30(%rbp)
cmpl $-0x1, -0x30(%rbp)
je 0x12d9
movq -0x18(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x10e0
movq %rax, %rdi
movq 0x2cee(%rip), %rsi      # 0x3fc0
callq 0x10b0
jmp 0x12f8
movq -0x18(%rbp), %rdi
leaq 0xd20(%rip), %rsi       # 0x2004
callq 0x1080
movq %rax, %rdi
movq 0x2ccd(%rip), %rsi      # 0x3fc0
callq 0x10b0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: hcoona[P]POJ-Solutions/P1061.cpp
// Function: POJ::P1061::Solve(int, int, int, int, int) const
int P1061::Solve(int x, int y, int m, int n, int L) const
    {
        int a = m - n, b = L, c = y - x;
        int x0, gcd;
        tie(x0, ignore, gcd) = Extended_GCD(a, b);
        if (a && (c % gcd == 0)) {
            int scale = c / gcd;
            double t = -static_cast<double>(x0) * c / b;
            int x = x0 * scale + b / gcd * static_cast<int>(floor(t));
            return x < 0 ? (x + b / gcd) : x;
        } else if (c % L == 0) {
            return 0;
        } else {
            return INVALID;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %eax
subl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x28(%rbp), %edx
movl -0x2c(%rbp), %ecx
leaq -0x44(%rbp), %rdi
callq 0x1460
leaq -0x60(%rbp), %rdi
leaq -0x34(%rbp), %rsi
leaq 0xcb5(%rip), %rdx       # 0x200f
leaq -0x38(%rbp), %rcx
callq 0x15c0
leaq -0x60(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x1600
cmpl $0x0, -0x28(%rbp)
je 0x142a
movl -0x30(%rbp), %eax
cltd
idivl -0x38(%rbp)
cmpl $0x0, %edx
jne 0x142a
movl -0x30(%rbp), %eax
cltd
idivl -0x38(%rbp)
movl %eax, -0x64(%rbp)
cvtsi2sdl -0x34(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
cvtsi2sdl -0x30(%rbp), %xmm1
mulsd %xmm1, %xmm0
cvtsi2sdl -0x2c(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x70(%rbp)
movl -0x34(%rbp), %eax
imull -0x64(%rbp), %eax
movl %eax, -0x78(%rbp)
movl -0x2c(%rbp), %eax
cltd
idivl -0x38(%rbp)
movl %eax, -0x7c(%rbp)
movsd -0x70(%rbp), %xmm0
callq 0x10d0
movl -0x7c(%rbp), %ecx
movl -0x78(%rbp), %eax
cvttsd2si %xmm0, %edx
imull %edx, %ecx
addl %ecx, %eax
movl %eax, -0x74(%rbp)
cmpl $0x0, -0x74(%rbp)
jge 0x141c
movl -0x74(%rbp), %eax
movl %eax, -0x84(%rbp)
movl -0x2c(%rbp), %eax
cltd
idivl -0x38(%rbp)
movl %eax, %ecx
movl -0x84(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x80(%rbp)
jmp 0x1422
movl -0x74(%rbp), %eax
movl %eax, -0x80(%rbp)
movl -0x80(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1446
movl -0x30(%rbp), %eax
cltd
idivl -0x24(%rbp)
cmpl $0x0, %edx
jne 0x143f
movl $0x0, -0x4(%rbp)
jmp 0x1446
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hcoona[P]POJ-Solutions/P1061.cpp
// Function: POJ::P1061::Extended_GCD(int, int) const
tuple<int, int, int> P1061::Extended_GCD(int a, int b) const
    {
        int x = 0, y = 1;
        int lastx = 1, lasty = 0;
        while (b != 0) {
            auto qr = div(a, b);
            a = b, b = qr.rem;
            int tmpx = x, tmpy = y;
            x = lastx - qr.quot * x, lastx = tmpx;
            y = lasty - qr.quot * y, lasty = tmpy;
        }
        return make_tuple(lastx, lasty, a);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x14f6
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0x1070
movq %rax, -0x30(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x24(%rbp), %eax
movl -0x30(%rbp), %ecx
imull -0x1c(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
movl -0x30(%rbp), %ecx
imull -0x20(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x149d
movq -0x48(%rbp), %rdi
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x14(%rbp), %rcx
callq 0x1630
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: isimplyexcel[P]text-based-game/main.cpp
// Function: main
int main(){
	//	hold user choice
	int choice;

	//	loop until user decides to exit
	do{
		//  calls menu function which displays 2 options 1) play 2) quit
		displayMenu();
		choice = validate(1,2);
		actOnChoice(choice);
	}while(choice != 2);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x2640
movl $0x1, %edi
movl $0x2, %esi
callq 0x7f10
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x26d0
cmpl $0x2, -0x8(%rbp)
jne 0x260f
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: isimplyexcel[P]text-based-game/main.cpp
// Function: displayMenu()
void displayMenu(){
	std::cout << "\n\nWelcome to the train game!" << std::endl;

    std::cout << "\n\n\tMenu\n\n";
    std::cout << "1) Start game\n";
    std::cout << "2) Exit\n";
	std::cout << "Enter your choice: " << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa985(%rip), %rdi      # 0xcfd0
leaq 0x69b2(%rip), %rsi      # 0x9004
callq 0x21a0
movq %rax, %rdi
movq 0xa95f(%rip), %rsi      # 0xcfc0
callq 0x21d0
movq 0xa963(%rip), %rdi      # 0xcfd0
leaq 0x69ad(%rip), %rsi      # 0x9021
callq 0x21a0
movq 0xa950(%rip), %rdi      # 0xcfd0
leaq 0x69a4(%rip), %rsi      # 0x902b
callq 0x21a0
movq 0xa93d(%rip), %rdi      # 0xcfd0
leaq 0x69a0(%rip), %rsi      # 0x903a
callq 0x21a0
movq 0xa92a(%rip), %rdi      # 0xcfd0
leaq 0x6996(%rip), %rsi      # 0x9043
callq 0x21a0
movq %rax, %rdi
movq 0xa904(%rip), %rsi      # 0xcfc0
callq 0x21d0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: isimplyexcel[P]text-based-game/main.cpp
// Function: actOnChoice(int)
void actOnChoice(int selection){
	switch(selection){
		//	Play game
		case 1:
		{
			Game game;
			game.play();
			break;
		}
		//	Quit
		case 2:
		{
			std::cout << "Goodbye!" << std::endl;
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x78(%rbp)
subl $0x1, %eax
je 0x26f5
jmp 0x26eb
movl -0x78(%rbp), %eax
subl $0x2, %eax
je 0x272f
jmp 0x2751
leaq -0x68(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x6080
movq -0x80(%rbp), %rdi
callq 0x7260
jmp 0x270d
leaq -0x68(%rbp), %rdi
callq 0x7400
jmp 0x2751
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x7400
jmp 0x275a
movq 0xa89a(%rip), %rdi      # 0xcfd0
leaq 0x691a(%rip), %rsi      # 0x9057
callq 0x21a0
movq %rax, %rdi
movq 0xa874(%rip), %rsi      # 0xcfc0
callq 0x21d0
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: isimplyexcel[P]text-based-game/Engine.cpp
// Function: Engine::checkKey(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Engine::checkKey(std::vector<std::string>& container, std::string search){
	//	iterator used to store the position of searched element
	std::vector<std::string>::iterator it;

	//	print backpack content
	std::cout << "Backpack contents:\n";
	for(unsigned int i = 0; i < container.size(); i++){
		std::cout << "item " << i + 1 << " - " << container[i] << std::endl;
	}

    std::cout << std::endl;

	//	std::find function call
	it = std::find(container.begin(), container.end(), search);

	if(it != container.end()){
		return true;
	}
	else{
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x58(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x33e0
movq 0xa398(%rip), %rdi      # 0xcfd0
leaq 0x660e(%rip), %rsi      # 0x924d
callq 0x21a0
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3340
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x2cd2
movq 0xa362(%rip), %rdi      # 0xcfd0
leaq 0x654e(%rip), %rsi      # 0x91c3
callq 0x21a0
movq %rax, %rdi
movl -0x2c(%rbp), %esi
addl $0x1, %esi
callq 0x2250
movq %rax, %rdi
leaq 0x6537(%rip), %rsi      # 0x91c9
callq 0x21a0
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x3360
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x2190
movq %rax, %rdi
movq 0xa301(%rip), %rsi      # 0xcfc0
callq 0x21d0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2c4b
movq 0xa2f7(%rip), %rdi      # 0xcfd0
movq 0xa2e0(%rip), %rsi      # 0xcfc0
callq 0x21d0
movq -0x18(%rbp), %rdi
callq 0x3450
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3480
movq -0x58(%rbp), %rdx
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x3400
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3480
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x34b0
testb $0x1, %al
jne 0x2d3c
jmp 0x2d42
movb $0x1, -0x1(%rbp)
jmp 0x2d46
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: isimplyexcel[P]text-based-game/Game.cpp
// Function: Game::displayGoal()
void Game::displayGoal(){
	std::cout << "\n\n\t\t\t\tWelcome\n" << std::endl;
	std::cout << "You are on a train and you feel a violent earthquake shake the ground!\n";
	std::cout << "You see that the tracks up ahead are damaged.\n" << std::endl;

	std::cout << "Goal:\nStop the train from derailing! Travel through the train from the caboose to the engine.\n";
	std::cout << "Along the way you will find items. One important item is ";
	std::cout << "\"an emergency brake key\".\nYou will need this item in order to stop the train from derailing!" << std::endl;
	std::cout << "In order to win the game you will need to earn \"a hero badge\"!" << std::endl;
	std::cout << "This item is awarded once you successfully stop the train!\n" << std::endl;

	std::cout << "\nTip:\nItems can only be picked up once. If you drop an item, it's gone forever!" << std::endl;
	std::cout << "You can only carry up to 3 items at a time.\n" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x639d(%rip), %rdi      # 0xcfd0
leaq 0x295c(%rip), %rsi      # 0x9596
callq 0x21a0
movq %rax, %rdi
movq 0x6377(%rip), %rsi      # 0xcfc0
callq 0x21d0
movq 0x637b(%rip), %rdi      # 0xcfd0
leaq 0x2949(%rip), %rsi      # 0x95a5
callq 0x21a0
movq 0x6368(%rip), %rdi      # 0xcfd0
leaq 0x297e(%rip), %rsi      # 0x95ed
callq 0x21a0
movq %rax, %rdi
movq 0x6342(%rip), %rsi      # 0xcfc0
callq 0x21d0
movq 0x6346(%rip), %rdi      # 0xcfd0
leaq 0x298b(%rip), %rsi      # 0x961c
callq 0x21a0
movq 0x6333(%rip), %rdi      # 0xcfd0
leaq 0x29d7(%rip), %rsi      # 0x967b
callq 0x21a0
movq 0x6320(%rip), %rdi      # 0xcfd0
leaq 0x29fe(%rip), %rsi      # 0x96b5
callq 0x21a0
movq %rax, %rdi
movq 0x62fa(%rip), %rsi      # 0xcfc0
callq 0x21d0
movq 0x62fe(%rip), %rdi      # 0xcfd0
leaq 0x2a39(%rip), %rsi      # 0x9712
callq 0x21a0
movq %rax, %rdi
movq 0x62d8(%rip), %rsi      # 0xcfc0
callq 0x21d0
movq 0x62dc(%rip), %rdi      # 0xcfd0
leaq 0x2a56(%rip), %rsi      # 0x9751
callq 0x21a0
movq %rax, %rdi
movq 0x62b6(%rip), %rsi      # 0xcfc0
callq 0x21d0
movq 0x62ba(%rip), %rdi      # 0xcfd0
leaq 0x2a70(%rip), %rsi      # 0x978d
callq 0x21a0
movq %rax, %rdi
movq 0x6294(%rip), %rsi      # 0xcfc0
callq 0x21d0
movq 0x6298(%rip), %rdi      # 0xcfd0
leaq 0x2a9e(%rip), %rsi      # 0x97dd
callq 0x21a0
movq %rax, %rdi
movq 0x6272(%rip), %rsi      # 0xcfc0
callq 0x21d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: isimplyexcel[P]text-based-game/Game.cpp
// Function: Game::displaySteps()
void Game::displaySteps(){
	//	display steps taken and steps remaining
	std::cout << "************ Step Information ***************" << std::endl;
	std::cout << "\nSteps taken: " << steps << std::endl;
	std::cout << "Steps remaining: " << 20 - steps << std::endl;

	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x6255(%rip), %rdi      # 0xcfd0
leaq 0x2a88(%rip), %rsi      # 0x980a
callq 0x21a0
movq %rax, %rdi
movq 0x622f(%rip), %rsi      # 0xcfc0
callq 0x21d0
movq 0x6233(%rip), %rdi      # 0xcfd0
leaq 0x2a94(%rip), %rsi      # 0x9838
callq 0x21a0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x22b0
movq %rax, %rdi
movq 0x61ff(%rip), %rsi      # 0xcfc0
callq 0x21d0
movq 0x6203(%rip), %rdi      # 0xcfd0
leaq 0x2a73(%rip), %rsi      # 0x9847
callq 0x21a0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl $0x14, %esi
subl (%rax), %esi
callq 0x22b0
movq %rax, %rdi
movq 0x61ca(%rip), %rsi      # 0xcfc0
callq 0x21d0
movq 0x61ce(%rip), %rdi      # 0xcfd0
movq 0x61b7(%rip), %rsi      # 0xcfc0
callq 0x21d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: isimplyexcel[P]text-based-game/Game.cpp
// Function: Game::printContainer()
void Game::printContainer(){

	//	print backpack content
	std::cout << "Backpack contents: " << std::endl;
	if(container.empty()){
		std::cout << "You do not have any items in your backpack\n" << std::endl;
	}
	else{
		for(unsigned int i = 0; i < container.size(); i++){
			std::cout << "item " << i + 1 << " - " << container[i] << std::endl;
		}
	}

	//empty line
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x5fc5(%rip), %rdi      # 0xcfd0
leaq 0x219d(%rip), %rsi      # 0x91af
callq 0x21a0
movq %rax, %rdi
movq 0x5f9f(%rip), %rsi      # 0xcfc0
callq 0x21d0
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x7580
testb $0x1, %al
jne 0x7039
jmp 0x7060
movq 0x5f90(%rip), %rdi      # 0xcfd0
leaq 0x2891(%rip), %rsi      # 0x98d8
callq 0x21a0
movq %rax, %rdi
movq 0x5f6a(%rip), %rsi      # 0xcfc0
callq 0x21d0
jmp 0x70f8
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
addq $0x40, %rdi
callq 0x3340
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x70f6
movq 0x5f42(%rip), %rdi      # 0xcfd0
leaq 0x212e(%rip), %rsi      # 0x91c3
callq 0x21a0
movq %rax, %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x2250
movq %rax, %rdi
leaq 0x2117(%rip), %rsi      # 0x91c9
callq 0x21a0
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x40, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x3360
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x2190
movq %rax, %rdi
movq 0x5edd(%rip), %rsi      # 0xcfc0
callq 0x21d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7067
jmp 0x70f8
movq 0x5ed1(%rip), %rdi      # 0xcfd0
movq 0x5eba(%rip), %rsi      # 0xcfc0
callq 0x21d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: isimplyexcel[P]text-based-game/Game.cpp
// Function: Game::checkHero()
bool Game::checkHero(){
	//	iterator used to store the position of searched element
	std::vector<std::string>::iterator it;

	std::string search = "a hero badge";

	//	std::find function call
	it = std::find(container.begin(), container.end(), search);

	if(it != container.end()){
		return true;
	}
	else{
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x33e0
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x22d0
movq -0x80(%rbp), %rdx
leaq 0x242e(%rip), %rsi      # 0x9589
leaq -0x38(%rbp), %rdi
callq 0x3290
jmp 0x7166
leaq -0x39(%rbp), %rdi
callq 0x21f0
movq -0x88(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x98(%rbp)
callq 0x3450
movq -0x98(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x3480
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x3400
movq %rax, -0x90(%rbp)
jmp 0x71b4
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x40, %rdi
callq 0x3480
movq %rax, -0x70(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x34b0
testb $0x1, %al
jne 0x71ee
jmp 0x7229
movb $0x1, -0x1(%rbp)
movl $0x1, -0x74(%rbp)
jmp 0x7234
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x21f0
jmp 0x724b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2100
jmp 0x724b
movb $0x0, -0x1(%rbp)
movl $0x1, -0x74(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2100
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
// File: isimplyexcel[P]text-based-game/Game.cpp
// Function: Game::play()
void Game::play(){
	//	Display goal
	this->displayGoal();

	while(steps <= 20 && !hero){
		//	display steps taken and steps remaining
		this->displaySteps();
		//	display map
		displayMap(location->getCarName());
		std::cout << "**********************************************" << std::endl;

		//	special action based on car
		location->action(container);

		//	check hero status
		this->hero = this->checkHero();

		//	break out of loop if your out of steps
		if(steps == 20){
			break;
		}

		//	if you have the hero badge you won the game 
		if(hero){
			break;
		}
		//	display action menu
		this->inGameMenu();
	}

	//	if you lost the game
	if(!hero){
		std::cout << "\nYou ran out of time and the train derailed! You lost!\n" << std::endl;
		std::cout << "***********************************************" << std::endl;
	}
	//	if you won the game
	else{
		std::cout << "\nYou are a hero and saved the train from derailing! Game Won!\n" << std::endl;
		std::cout << "***********************************************" << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x6c20
movq -0x40(%rbp), %rcx
xorl %eax, %eax
cmpl $0x14, (%rcx)
movb %al, -0x41(%rbp)
jg 0x7293
movq -0x40(%rbp), %rax
movb 0x58(%rax), %al
xorb $-0x1, %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x729f
jmp 0x7354
movq -0x40(%rbp), %rdi
callq 0x6d60
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x7e80
movq -0x50(%rbp), %rdi
callq 0x7890
jmp 0x72c8
leaq -0x28(%rbp), %rdi
callq 0x2100
movq 0x5cf8(%rip), %rdi      # 0xcfd0
leaq 0x265e(%rip), %rsi      # 0x993d
callq 0x21a0
movq %rax, %rdi
movq 0x5cd2(%rip), %rsi      # 0xcfc0
callq 0x21d0
movq -0x40(%rbp), %rsi
movq 0x38(%rsi), %rdi
addq $0x40, %rsi
movq (%rdi), %rax
callq *(%rax)
movq -0x40(%rbp), %rdi
callq 0x7120
movb %al, %cl
movq -0x40(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x58(%rax)
cmpl $0x14, (%rax)
jne 0x733a
jmp 0x7354
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2100
jmp 0x73ee
movq -0x40(%rbp), %rax
testb $0x1, 0x58(%rax)
je 0x7346
jmp 0x7354
movq -0x40(%rbp), %rdi
callq 0x6e20
jmp 0x7279
movq -0x40(%rbp), %rax
testb $0x1, 0x58(%rax)
jne 0x73a4
movq 0x5c6b(%rip), %rdi      # 0xcfd0
leaq 0x2598(%rip), %rsi      # 0x9904
callq 0x21a0
movq %rax, %rdi
movq 0x5c45(%rip), %rsi      # 0xcfc0
callq 0x21d0
movq 0x5c49(%rip), %rdi      # 0xcfd0
leaq 0x25ae(%rip), %rsi      # 0x993c
callq 0x21a0
movq %rax, %rdi
movq 0x5c23(%rip), %rsi      # 0xcfc0
callq 0x21d0
jmp 0x73e8
movq 0x5c25(%rip), %rdi      # 0xcfd0
leaq 0x25ba(%rip), %rsi      # 0x996c
callq 0x21a0
movq %rax, %rdi
movq 0x5bff(%rip), %rsi      # 0xcfc0
callq 0x21d0
movq 0x5c03(%rip), %rdi      # 0xcfd0
leaq 0x2568(%rip), %rsi      # 0x993c
callq 0x21a0
movq %rax, %rdi
movq 0x5bdd(%rip), %rsi      # 0xcfc0
callq 0x21d0
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x22c0
nopw (%rax,%rax)
// File: isimplyexcel[P]text-based-game/Game.cpp
// Function: Game::~Game()
Game::~Game(){

	//	If you lose the game then set player to engine car to avoid memory leaks
	if(this->hero == false){
		while(location->getRight() != nullptr){
			location = location->getRight();
		}
	}

	//	delete cars from the engine to the caboose
	while(location->getLeft() != nullptr){
		Space* temp = location;
		location = location->getLeft();
		delete temp;
	}
	delete location;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0x58(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x7463
jmp 0x7423
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x7e60
movq %rax, -0x20(%rbp)
jmp 0x7436
movq -0x20(%rbp), %rax
cmpq $0x0, %rax
je 0x7461
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x7e60
movq %rax, -0x28(%rbp)
jmp 0x7453
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x38(%rax)
jmp 0x7423
jmp 0x7463
jmp 0x7465
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x7e40
movq %rax, -0x30(%rbp)
jmp 0x7478
movq -0x30(%rbp), %rax
cmpq $0x0, %rax
je 0x74c3
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x38(%rax), %rdi
callq 0x7e40
movq %rax, -0x38(%rbp)
jmp 0x749d
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x74c1
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x7465
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x74df
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x7520
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3800
nopw (%rax,%rax)
// File: isimplyexcel[P]text-based-game/Space.cpp
// Function: Space::Space(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Space::Space(std::string m_name, std::string m_action, std::string m_item){
	this->carName = m_name;
	this->actionName = m_action;
	this->itemName = m_item;
	this->actionTaken = false;
	this->itemTaken = false;
	this->top = nullptr;
	this->bottom = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x38(%rbp)
movq %rdx, -0x68(%rbp)
movq %rcx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq 0x4fbd(%rip), %rax      # 0xcd10
movq %rax, (%rdi)
addq $0x30, %rdi
movq %rdi, -0x40(%rbp)
callq 0x2260
movq -0x50(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x58(%rbp)
callq 0x2260
movq -0x50(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x48(%rbp)
callq 0x2260
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x2040
jmp 0x7d94
movq -0x68(%rbp), %rsi
movq -0x50(%rbp), %rdi
addq $0x50, %rdi
callq 0x2040
jmp 0x7da7
movq -0x60(%rbp), %rsi
movq -0x50(%rbp), %rdi
addq $0x70, %rdi
callq 0x2040
jmp 0x7dba
movq -0x50(%rbp), %rax
movb $0x0, 0x28(%rax)
movb $0x0, 0x29(%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x18(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2100
movq -0x58(%rbp), %rdi
callq 0x2100
movq -0x40(%rbp), %rdi
callq 0x2100
movq -0x28(%rbp), %rdi
callq 0x22c0
nopl (%rax)
// File: isimplyexcel[P]text-based-game/validate.cpp
// Function: validate(int, int)
int validate(int min, int max) {
    int choice;
    bool isValid = false;
    do {
        std::cin >> choice;

        if(!std::cin.fail() && (choice >= min && choice <= max)){
            isValid = true;
            std::cin.clear();	//	clear buffer
            std::cin.ignore(256, '\n');	// referenced stack overflow and TA james
        }
        else{
            std::cin.clear();	//	clear buffer
            std::cin.ignore(256, '\n');	// referenced stack overflow and TA james
            std::cout << "Invalid input. Please try again: " << std::endl;
                      //<< min << " and " << max << ": " << std::endl;
        }
    } while(!isValid);

    return choice;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movb $0x0, -0xd(%rbp)
movq 0x50b7(%rip), %rdi      # 0xcfe0
leaq -0xc(%rbp), %rsi
callq 0x20f0
movq 0x50a7(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movq 0x509d(%rip), %rdi      # 0xcfe0
addq -0x18(%rax), %rdi
callq 0x2030
testb $0x1, %al
jne 0x7f98
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jl 0x7f98
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jg 0x7f98
movb $0x1, -0xd(%rbp)
movq 0x5075(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movq 0x506b(%rip), %rdi      # 0xcfe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x22a0
movq 0x5059(%rip), %rdi      # 0xcfe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x2110
jmp 0x7fec
movq 0x5041(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movq 0x5037(%rip), %rdi      # 0xcfe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x22a0
movq 0x5025(%rip), %rdi      # 0xcfe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x2110
movq 0x4fff(%rip), %rdi      # 0xcfd0
leaq 0x19f3(%rip), %rsi      # 0x99cb
callq 0x21a0
movq %rax, %rdi
movq 0x4fd9(%rip), %rsi      # 0xcfc0
callq 0x21d0
jmp 0x7fee
movb -0xd(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x7f22
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: BruceHu1005[P]np-assignment1/./calcLib.c
// Function: initCalcLib_seed
int initCalcLib_seed(unsigned int seed){
  /* 
     Init the random number generator with a FIXED seed, will allow us to grab random numbers 
     in the same sequence all the time. Good when debugging, bad when running live. 

     This is 'messy' for more details see https://en.wikipedia.org/wiki/Pseudorandom_number_generator. 

     DO NOT USE rand() for production, wher you NEED good random numbers. 
  */
  
  myData_seedValue=seed;
  srand(seed);
  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq %rax, 0x3d73(%rip)      # 0x61e8
movl -0x4(%rbp), %edi
callq 0x21e0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BruceHu1005[P]np-assignment1/./calcLib.c
// Function: randomType
char *randomType(void){
  int Listitems=sizeof(arith)/(sizeof(char*)); 
  /* Figure out HOW many entries there are in the list.
     First we get the total size that the array of pointers use, sizeof(arith). Then we divide with 
     the size of a pointer (sizeof(char*)), this gives us the number of pointers in the list. 
  */
  int itemPos=rand() % Listitems;
  /* As we know the number of items, we can just draw a random number and modulo it with the number 
     of items in the list, then we will get a random number between 0 and the number of items in the list 
     
     Using that information, we just return the string found at that position arith[itemPos];
  */
  return(arith[itemPos]);
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x8, -0x4(%rbp)
callq 0x20a0
cltd
idivl -0x4(%rbp)
movl %edx, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x3cda(%rip), %rax      # 0x6190
movq (%rax,%rcx,8), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: AngelPn[P]L5R-card_game/src/main.cpp
// Function: main
int main(void){
	GameBoard Legend_of_5_Rings;
	std::cout<< "How many players? Type a number: (2-8): ";
	int no_players= 0;
	while(no_players< 2 || no_players> 8){
		std::cin>> no_players;
		std::cout<< std::endl;
	}
	Legend_of_5_Rings.initializeGameBoard(no_players);
	Legend_of_5_Rings.gameplay();

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x46e0
movq 0x209a1(%rip), %rdi     # 0x24fd0
leaq 0x139ce(%rip), %rsi     # 0x18004
callq 0x4200
jmp 0x463d
movl $0x0, -0x30(%rbp)
movb $0x1, %al
cmpl $0x2, -0x30(%rbp)
movb %al, -0x31(%rbp)
jl 0x4659
cmpl $0x8, -0x30(%rbp)
setg %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x4662
jmp 0x46a2
movq 0x20977(%rip), %rdi     # 0x24fe0
leaq -0x30(%rbp), %rsi
callq 0x4150
jmp 0x4674
movq 0x20955(%rip), %rdi     # 0x24fd0
movq 0x2093e(%rip), %rsi     # 0x24fc0
callq 0x4230
jmp 0x4689
jmp 0x4644
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc240
jmp 0x46d4
movl -0x30(%rbp), %esi
leaq -0x20(%rbp), %rdi
callq 0xc2d0
jmp 0x46b0
leaq -0x20(%rbp), %rdi
callq 0xc5a0
jmp 0x46bb
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc240
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x4340
nopl (%rax)
// File: AngelPn[P]L5R-card_game/src/DeckBuilder.cpp
// Function: DeckBuilder::~DeckBuilder()
DeckBuilder::~DeckBuilder()
{
	list<BlackCard *>::iterator it = black->begin(),it3;
	list<GreenCard *>::iterator it2 = green->begin(),it4;
	while (it != black->end())
	{
		it3 = it++;
		delete *it3;
		black->remove((*it3));
	}
	while (it2 != green->end())
	{
		it4 = it2++;
		delete *it4;
		green->remove((*it4));
	}
	delete black;
	delete green;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x8(%rax), %rdi
callq 0x6820
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6850
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0x6870
movq %rax, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x68a0
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x68f0
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x68c0
testb $0x1, %al
jne 0x48ca
jmp 0x4926
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x6920
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6950
movq (%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x4901
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6950
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x6970
jmp 0x4924
jmp 0x48a6
jmp 0x4928
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0x6a90
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6a60
testb $0x1, %al
jne 0x494b
jmp 0x49b6
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x6ac0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6af0
movq (%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x498f
movq -0x68(%rbp), %rdi
callq 0x6b10
movq -0x68(%rbp), %rdi
movl $0x68, %esi
callq 0x4220
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6af0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x6b50
jmp 0x49b1
jmp 0x4928
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0x49df
movq -0x78(%rbp), %rdi
callq 0x6c30
movq -0x78(%rbp), %rdi
movl $0x18, %esi
callq 0x4220
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x4a07
movq -0x80(%rbp), %rdi
callq 0x6c50
movq -0x80(%rbp), %rdi
movl $0x18, %esi
callq 0x4220
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x6a50
nopl (%rax,%rax)
// File: AngelPn[P]L5R-card_game/src/DeckBuilder.cpp
// Function: DeckBuilder::deckShuffler(std::__cxx11::list<BlackCard*, std::allocator<BlackCard*>>*)
void DeckBuilder::deckShuffler(list<BlackCard *> *black)
{
	vector<BlackCard *> vect;
	list<BlackCard *>::iterator it;
	for (it = black->begin(); it != black->end(); it++)
		vect.push_back((*it));

	random_shuffle(vect.begin(), vect.end());

	black->clear();

	vector<BlackCard *>::iterator it2;
	for (it2 = vect.begin(); it2 != vect.end(); it2++)
		black->push_back((*it2));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x78a0
leaq -0x30(%rbp), %rdi
callq 0x6850
movq -0x10(%rbp), %rdi
callq 0x6820
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x68f0
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x68c0
testb $0x1, %al
jne 0x655a
jmp 0x659e
leaq -0x30(%rbp), %rdi
callq 0x6950
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x78c0
jmp 0x6571
jmp 0x6573
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x6920
movq %rax, -0x58(%rbp)
jmp 0x653a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7b90
jmp 0x6665
leaq -0x28(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x7a00
movq -0x90(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x7a30
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x7930
jmp 0x65d1
movq -0x10(%rbp), %rdi
callq 0x7a60
leaq -0x70(%rbp), %rdi
callq 0x7a90
leaq -0x28(%rbp), %rdi
callq 0x7a00
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7a30
movq %rax, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7ab0
testb $0x1, %al
jne 0x6618
jmp 0x6653
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x7b30
movq -0x98(%rbp), %rdi
movq %rax, %rsi
callq 0x7af0
jmp 0x663d
jmp 0x663f
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
callq 0x7b50
movq %rax, -0x88(%rbp)
jmp 0x65f8
leaq -0x28(%rbp), %rdi
callq 0x7b90
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4340
nop
// File: AngelPn[P]L5R-card_game/src/DeckBuilder.cpp
// Function: DeckBuilder::deckShuffler(std::__cxx11::list<GreenCard*, std::allocator<GreenCard*>>*)
void DeckBuilder::deckShuffler(list<GreenCard *> *green)
{
	vector<GreenCard *> vect;
	list<GreenCard *>::iterator it;
	for (it = green->begin(); it != green->end(); it++)
		vect.push_back((*it));

	random_shuffle(vect.begin(), vect.end());

	green->clear();

	vector<GreenCard *>::iterator it2;
	for (it2 = vect.begin(); it2 != vect.end(); it2++)
		green->push_back((*it2));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7bf0
leaq -0x30(%rbp), %rdi
callq 0x68a0
movq -0x10(%rbp), %rdi
callq 0x6870
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a90
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6a60
testb $0x1, %al
jne 0x66ca
jmp 0x670e
leaq -0x30(%rbp), %rdi
callq 0x6af0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x7c10
jmp 0x66e1
jmp 0x66e3
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x6ac0
movq %rax, -0x58(%rbp)
jmp 0x66aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7ee0
jmp 0x67d5
leaq -0x28(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x7d50
movq -0x90(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x7d80
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x7c80
jmp 0x6741
movq -0x10(%rbp), %rdi
callq 0x7db0
leaq -0x70(%rbp), %rdi
callq 0x7de0
leaq -0x28(%rbp), %rdi
callq 0x7d50
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7d80
movq %rax, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7e00
testb $0x1, %al
jne 0x6788
jmp 0x67c3
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x7e80
movq -0x98(%rbp), %rdi
movq %rax, %rsi
callq 0x7e40
jmp 0x67ad
jmp 0x67af
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
callq 0x7ea0
movq %rax, -0x88(%rbp)
jmp 0x6768
leaq -0x28(%rbp), %rdi
callq 0x7ee0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4340
nop
// File: AngelPn[P]L5R-card_game/./include/Follower.hpp
// Function: Follower::Follower(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
Follower(const std::string name, int type): GreenCard(name, type)
	//constructors of GreenCard and Card will initialize the data members which are not in the .txt files
	//data members with values from the .txt file, are initialized here
	{
		switch (type)
		{
			case FOOTSOLDIER : cost= 0; attackBonus = 2; defenseBonus = 0; minimumHonor = 1; effectBonus = 1; effectCost = 2; break;
			case ARCHER      : cost= 0; attackBonus = 0; defenseBonus = 2; minimumHonor = 1; effectBonus = 1; effectCost = 2; break;
			case SIEGER      : cost= 5; attackBonus = 3; defenseBonus = 3; minimumHonor = 2; effectBonus = 2; effectCost = 3; break;
			case CAVALRY     : cost= 3; attackBonus = 4; defenseBonus = 2; minimumHonor = 3; effectBonus = 3; effectCost = 4; break;
			case NAVAL       : cost= 3; attackBonus = 2; defenseBonus = 4; minimumHonor = 3; effectBonus = 3; effectCost = 4; break;
			case BUSHIDO     : cost= 8; attackBonus = 8; defenseBonus = 8; minimumHonor = 6; effectBonus = 3; effectCost = 8; break;
		}

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x40f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x8840
jmp 0x865a
leaq -0x38(%rbp), %rdi
callq 0x4160
movq -0x58(%rbp), %rax
leaq 0x1bfca(%rip), %rcx     # 0x24638
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
movq %rax, -0x60(%rbp)
subq $0x5, %rax
ja 0x87d7
movq -0x60(%rbp), %rax
leaq 0xf9a3(%rip), %rcx      # 0x18030
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4160
jmp 0x87dd
movq -0x58(%rbp), %rax
movl $0x0, 0x28(%rax)
movl $0x2, 0x50(%rax)
movl $0x0, 0x54(%rax)
movl $0x1, 0x58(%rax)
movl $0x1, 0x5c(%rax)
movl $0x2, 0x60(%rax)
jmp 0x87d7
movq -0x58(%rbp), %rax
movl $0x0, 0x28(%rax)
movl $0x0, 0x50(%rax)
movl $0x2, 0x54(%rax)
movl $0x1, 0x58(%rax)
movl $0x1, 0x5c(%rax)
movl $0x2, 0x60(%rax)
jmp 0x87d7
movq -0x58(%rbp), %rax
movl $0x5, 0x28(%rax)
movl $0x3, 0x50(%rax)
movl $0x3, 0x54(%rax)
movl $0x2, 0x58(%rax)
movl $0x2, 0x5c(%rax)
movl $0x3, 0x60(%rax)
jmp 0x87d7
movq -0x58(%rbp), %rax
movl $0x3, 0x28(%rax)
movl $0x4, 0x50(%rax)
movl $0x2, 0x54(%rax)
movl $0x3, 0x58(%rax)
movl $0x3, 0x5c(%rax)
movl $0x4, 0x60(%rax)
jmp 0x87d7
movq -0x58(%rbp), %rax
movl $0x3, 0x28(%rax)
movl $0x2, 0x50(%rax)
movl $0x4, 0x54(%rax)
movl $0x3, 0x58(%rax)
movl $0x3, 0x5c(%rax)
movl $0x4, 0x60(%rax)
jmp 0x87d7
movq -0x58(%rbp), %rax
movl $0x8, 0x28(%rax)
movl $0x8, 0x50(%rax)
movl $0x8, 0x54(%rax)
movl $0x6, 0x58(%rax)
movl $0x3, 0x5c(%rax)
movl $0x8, 0x60(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4340
nopw %cs:(%rax,%rax)
// File: AngelPn[P]L5R-card_game/./include/Card.hpp
// Function: GreenCard::GreenCard(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
GreenCard(std::string name, int type): Card(name){
  		std::ifstream file("CardTextes.txt"); //Open file and read it

  		if(!no_cardTextes){ //In case all card textes are used
  			no_cardTextes= 12; //Reset the number of card textes
  		}
  		int i= no_cardTextes;
  		while(i){ //Get a unique card text each time a GreenCard is created
  			getline(file, this->cardText);
  			i--;
  		}
  		no_cardTextes--;
  		file.close(); //Close the file
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x268(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x260(%rbp)
callq 0x40f0
movq -0x268(%rbp), %rdi
movq -0x260(%rbp), %rsi
callq 0x8ab0
jmp 0x8886
leaq -0x38(%rbp), %rdi
callq 0x4160
movq -0x268(%rbp), %rdi
leaq 0x1bce3(%rip), %rax     # 0x24580
movq %rax, (%rdi)
addq $0x30, %rdi
movq %rdi, -0x270(%rbp)
callq 0x42d0
leaq 0xf922(%rip), %rsi      # 0x181d9
leaq -0x250(%rbp), %rdi
movl $0x8, %edx
callq 0x4370
jmp 0x88ca
cmpl $0x0, 0x1c90f(%rip)     # 0x251e0
jne 0x890a
movl $0xc, 0x1c903(%rip)     # 0x251e0
jmp 0x890a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4160
jmp 0x89ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x8994
movl 0x1c8d0(%rip), %eax     # 0x251e0
movl %eax, -0x254(%rbp)
cmpl $0x0, -0x254(%rbp)
je 0x8963
movq -0x268(%rbp), %rsi
addq $0x30, %rsi
leaq -0x250(%rbp), %rdi
callq 0x4070
jmp 0x8938
movl -0x254(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x254(%rbp)
jmp 0x8916
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x40a0
jmp 0x8994
movl 0x1c877(%rip), %eax     # 0x251e0
decl %eax
movl %eax, 0x1c86f(%rip)     # 0x251e0
leaq -0x250(%rbp), %rdi
callq 0x4080
jmp 0x897f
leaq -0x250(%rbp), %rdi
callq 0x40a0
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x270(%rbp), %rdi
callq 0x4160
movq -0x268(%rbp), %rdi
callq 0x8080
movq -0x40(%rbp), %rdi
callq 0x4340
nopw %cs:(%rax,%rax)
nop
// File: AngelPn[P]L5R-card_game/./include/Follower.hpp
// Function: Follower::print() const
virtual void print() const{
		std::cout<< "\033[1;32mCost: \033[0m"<< cost<< "\033[1;32m\nAttack Bonus: \033[0m"<< attackBonus<<
		"\033[1;32m\nDefense Bonus: \033[0m"<< defenseBonus<< "\033[1;32m\nMinimum Honor: \033[0m"<< minimumHonor
			<< "\033[1;32m\nEffect Bonus: \033[0m"<< effectBonus<< "\033[1;32m\nEffect Cost: \033[0m"<< effectCost<< "\n";
		GreenCard::print();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x1c5f5(%rip), %rdi     # 0x24fd0
leaq 0xf806(%rip), %rsi      # 0x181e8
callq 0x4200
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %esi
callq 0x42c0
movq %rax, %rdi
leaq 0xf7fa(%rip), %rsi      # 0x181fa
callq 0x4200
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x50(%rax), %esi
callq 0x42c0
movq %rax, %rdi
leaq 0xf7f7(%rip), %rsi      # 0x18215
callq 0x4200
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x54(%rax), %esi
callq 0x42c0
movq %rax, %rdi
leaq 0xf7f5(%rip), %rsi      # 0x18231
callq 0x4200
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x58(%rax), %esi
callq 0x42c0
movq %rax, %rdi
leaq 0xf7f3(%rip), %rsi      # 0x1824d
callq 0x4200
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %esi
callq 0x42c0
movq %rax, %rdi
leaq 0xf7f0(%rip), %rsi      # 0x18268
callq 0x4200
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x60(%rax), %esi
callq 0x42c0
movq %rax, %rdi
leaq 0xf7ec(%rip), %rsi      # 0x18282
callq 0x4200
movq -0x10(%rbp), %rdi
callq 0x80b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)