LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jaldhar[P]Lets-Build-a-Simple-Interpreter/calc2.cc
// Function: operator<<(std::ostream&, TOKENTYPE const&)
ostream& operator<<(ostream& out, const TOKENTYPE& t) {
    string repr;
    switch(t) {
        case TOKENTYPE::ENDOFFILE:
            repr = "ENDOFFILE";
            break;
        case TOKENTYPE::INTEGER:
            repr = "INTEGER";
            break;
        case TOKENTYPE::PLUS:
            repr = "PLUS";
            break;
        case TOKENTYPE::MINUS:
            repr = "MINUS";
            break;
        case TOKENTYPE::TIMES:
            repr = "TIMES";
            break;
        case TOKENTYPE::DIVIDE:
            repr = "DIVIDE";
            break;
    }

    out << repr;
    return out;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movl (%rsi), %eax
cmpq $0x6, %rax
jae 0x239a
leaq 0xcbe(%rip), %rdx       # 0x3038
movslq (%rdx,%rax,4), %rcx
addq %rdx, %rcx
leaq 0xcc8(%rip), %rdx       # 0x3050
movq (%rdx,%rax,8), %r8
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21b0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2160
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x23c3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x23e8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/jaldhar[P]Lets-Build-a-Simple-Interpreter/calc2.cc
// Function: Interpreter::expression()
long Interpreter::expression() {

    // set current token to the first token taken from the input
    _current_token = get_next_token();

    // we expect the current token to be an integer
    Token left = _current_token;
    eat(TOKENTYPE::INTEGER);

    long result = left.value;
    // loop while we still have tokens
    while(_current_token.type != TOKENTYPE::ENDOFFILE) {
        // we expect the current token to be an operator token
        switch(_current_token.type) {
        case TOKENTYPE::MINUS:
            eat(TOKENTYPE::MINUS);
            result = subtract(result);
            break;
        case TOKENTYPE::PLUS:
            eat(TOKENTYPE::PLUS);
            result = add(result);
            break;
        case TOKENTYPE::TIMES:
            eat(TOKENTYPE::TIMES);
            result = multiply(result);
            break;
        case TOKENTYPE::DIVIDE:
            eat(TOKENTYPE::DIVIDE);
            result = divide(result);
            break;
        case TOKENTYPE::ENDOFFILE:
            break;
        default:
            ostringstream out;
            out << "Error parsing input. Wanted operator, got: "
                << _current_token.type;
            throw(out.str().c_str());
        }
    }

    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, %r14
callq 0x25f2
movq %rdx, %r15
leaq 0x18(%r14), %rbx
movl %eax, 0x18(%r14)
movq %rdx, 0x20(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x2862
leaq 0xb5b(%rip), %r12       # 0x3008
movl (%rbx), %eax
cmpq $0x5, %rax
ja 0x2534
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq %r14, %rdi
movl $0x2, %esi
callq 0x2862
addq 0x20(%r14), %r15
jmp 0x2513
movq %r14, %rdi
movl $0x5, %esi
callq 0x2862
movq %r14, %rdi
movq %r15, %rsi
callq 0x299a
movq %rax, %r15
jmp 0x24ad
movq %r14, %rdi
movl $0x3, %esi
callq 0x2862
subq 0x20(%r14), %r15
jmp 0x2513
movq %r14, %rdi
movl $0x4, %esi
callq 0x2862
imulq 0x20(%r14), %r15
movq %r14, %rdi
movl $0x1, %esi
callq 0x2862
jmp 0x24ad
movq %r15, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x2170
leaq 0xb6d(%rip), %rsi       # 0x30b5
movl $0x2b, %edx
movq %r14, %rdi
callq 0x2160
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x234c
movl $0x8, %edi
callq 0x2090
movq %rax, %rbx
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x21c0
movq (%rsp), %rax
movq %rax, (%rbx)
movq 0x2a26(%rip), %rsi      # 0x4fb0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x21e0
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25b2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
xorl %eax, %eax
jmp 0x25bb
movq %rax, %r14
movb $0x1, %al
testb %al, %al
je 0x25cc
movq %rbx, %rdi
callq 0x20e0
jmp 0x25cc
movq %rax, %r14
movq 0x29ed(%rip), %rsi      # 0x4fc0
leaq 0x20(%rsp), %rdi
callq 0x20a0
leaq 0x90(%rsp), %rdi
callq 0x2060
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/jaldhar[P]Lets-Build-a-Simple-Interpreter/calc2.cc
// Function: Interpreter::divide(long)
long  Interpreter::divide(long left_value) {
    // we expect the current token to be an integer
    Token right = _current_token;
    eat(TOKENTYPE::INTEGER);

    // Handle division by 0
    if (right.value == 0) {
        throw("Division by zero");
    }
    // after the above call _current_token is set to ENDOFFILE token

    // at this point INTEGER TIMES INTEGER sequence of tokens has been
    // successfully found and the method can just return the result of
    // dividing two integers, thus effectively interpreting client input
    return left_value / right.value;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x20(%rdi), %r14
movl $0x1, %esi
callq 0x2862
testq %r14, %r14
je 0x29c4
movq %rbx, %rax
cqto
idivq %r14
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x8, %edi
callq 0x2090
leaq 0x70c(%rip), %rcx       # 0x30e1
movq %rcx, (%rax)
movq 0x25d1(%rip), %rsi      # 0x4fb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH19_SpecializedToolsAndTechniques/examples/bitfields.cc
// Function: File::open(File::modes)
File &File::open(File::modes m)
{
	mode |= READ;    // set the READ bit by default
	// other processing
	if (m & WRITE) // if opening READ and WRITE 
	// processing to open the file in read/write mode
	cout << "myFile.mode READ is set" << endl;
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
orb $0x1, (%rdi)
testb $0x2, %sil
je 0x1231
movq 0x2de2(%rip), %r14      # 0x3fd8
leaq 0xe07(%rip), %rsi       # 0x2004
movl $0x17, %edx
movq %r14, %rdi
callq 0x1070
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH19_SpecializedToolsAndTechniques/examples/bitfields.cc
// Function: main
int main()
{
	File myFile;
	
	myFile.open(File::READ);
	if (myFile.isRead()) 
		cout << "reading" << endl;
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x2d92(%rip), %rbx      # 0x3fd8
leaq 0xdcf(%rip), %rsi       # 0x201c
movl $0x7, %edx
movq %rbx, %rdi
callq 0x1070
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/allasandeep[P]LocationBoundaryFinder/./functions.cc
// Function: delSpaces(char*)
void delSpaces(char *str)
{
	int count = 0;
	//Looping the char array and searching fro empty space
	for(int i = 0; str[i]; i++)
	{
		if(str[i] != ' ')
			str[count++] = str[i];
	}

	str[count] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %ecx, %ecx
movq %rdi, %rax
movzbl (%rax), %edx
cmpl $0x20, %edx
je 0x240a
movslq %ecx, %rsi
testl %edx, %edx
je 0x240f
leal 0x1(%rsi), %ecx
movb %dl, (%rdi,%rsi)
incq %rax
jmp 0x23f5
movb $0x0, (%rdi,%rsi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/allasandeep[P]LocationBoundaryFinder/./functions.cc
// Function: conn()
PGconn* conn()
{
	//Connecting to the Database with user credentials
	PGconn *db = PQconnectdb("host = 'courses' dbname = 'z1821331' user = 'z1821331'  password = '1996Jun06' ");
	//If the connection fails, print an error message
	if(!(CONNECTION_OK == PQstatus(db)))
	{
		cerr<<"Can't connect to db."<<endl;
		exit(EXIT_FAILURE);
	}
	cout<<"Database Connection Successfull!"<<endl;

	return db;;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x1be1(%rip), %rdi      # 0x4004
callq 0x2160
movq %rax, %rbx
movq %rax, %rdi
callq 0x20a0
testl %eax, %eax
jne 0x2481
movq 0x3b9a(%rip), %r14      # 0x5fd8
leaq 0x1c24(%rip), %rsi      # 0x4069
movl $0x20, %edx
movq %r14, %rdi
callq 0x2230
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2290
movsbl %al, %esi
movq %r14, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x2100
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x3b68(%rip), %rdi      # 0x5ff0
leaq 0x1bc5(%rip), %rsi      # 0x4054
callq 0x2150
movq %rax, %rdi
callq 0x2250
movl $0x1, %edi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/allasandeep[P]LocationBoundaryFinder/prog1.cc
// Function: openFiles(std::basic_ifstream<char, std::char_traits<char>>&, char*)
void openFiles( ifstream& is, char *fileName)
{
	// opening the input file. 
	is.open(fileName);
	// If the file fails to open,then displays an error message. 
	if(is.fail()) 
	{
		cerr<<"Error Message:: Unable to read" <<fileName<< endl;
		exit(EXIT_FAILURE);
	}		
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x8, %edx
callq 0x21e0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
jne 0x278f
popq %rbx
popq %r14
popq %rbp
retq
movq 0x385a(%rip), %rdi      # 0x5ff0
leaq 0x197c(%rip), %rsi      # 0x4119
callq 0x2150
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x2250
movl $0x1, %edi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/examples/CoRoT7/kima_setup.cpp
// Function: main
int main(int argc, char** argv)
{
    datafile = "corot7.txt";

    load(datafile, "ms");

    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(50);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x6c0, %rsp            # imm = 0x6C0
movq %rsi, %rbx
movl %edi, %ebp
movq 0x32853(%rip), %rdx     # 0x53548
leaq 0x32844(%rip), %r14     # 0x53540
leaq 0x2468e(%rip), %rcx     # 0x45391
movl $0xa, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x6600
leaq 0x1e7cf(%rip), %rsi     # 0x3f4e9
movq %r14, %rdi
callq 0x20f11
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x2100f
movq %r14, %rdi
movl $0x32, %esi
callq 0x210e0
leaq 0x8(%rsp), %rdi
callq 0x212be
xorl %eax, %eax
addq $0x6c0, %rsp            # imm = 0x6C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x212be
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/basicboard.cc
// Function: BasicBoard::turnBlock(int)
void BasicBoard::turnBlock(int amount) {
	for (int i = 0; i < abs(amount); ++i) {
		bool valid = validMove(currentBlock->turnPos(amount/abs(amount)));
	cout << valid <<endl;
		if (valid) currentBlock->turn(amount/abs(amount));
		else break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
je 0x6ccb
movq %rdi, %rbx
movl %esi, %ebp
sarl $0x1f, %ebp
orl $0x1, %ebp
movl %esi, %r15d
negl %r15d
cmovsl %esi, %r15d
movq %rsp, %r14
movq 0xb8(%rbx), %rsi
movq (%rsi), %rax
movq %r14, %rdi
movl %ebp, %edx
callq *0x28(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x50(%rax)
movl %eax, %r12d
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6c71
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
movzbl %r12b, %r12d
movq 0x1434c(%rip), %rdi     # 0x1afc8
movl %r12d, %esi
callq 0x5440
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x5280
movsbl %al, %esi
movq %r13, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x51c0
testb %r12b, %r12b
je 0x6ccb
movq 0xb8(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x18(%rax)
decl %r15d
jne 0x6c3a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6cf3
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5480
nop
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/basicboard.cc
// Function: BasicBoard::moveBlock(int)
void BasicBoard::moveBlock(int amount) {
	for (int i = 0; i < abs(amount); ++i) {
		bool valid = validMove(currentBlock->movePos(amount/abs(amount)));
		if (valid) currentBlock->move(amount/abs(amount));
		else break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
testl %esi, %esi
je 0x6d77
movq %rdi, %rbx
movl %esi, %ebp
sarl $0x1f, %ebp
orl $0x1, %ebp
movl %esi, %r12d
negl %r12d
cmovsl %esi, %r12d
leaq 0x8(%rsp), %r14
movq 0xb8(%rbx), %rsi
movq (%rsi), %rax
movq %r14, %rdi
movl %ebp, %edx
callq *0x20(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x50(%rax)
movl %eax, %r15d
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6d5e
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
testb %r15b, %r15b
je 0x6d77
movq 0xb8(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x10(%rax)
decl %r12d
jne 0x6d26
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6d9e
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5480
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/basicboard.cc
// Function: BasicBoard::downBlock(int)
void BasicBoard::downBlock(int amount) {
	for (int i = 0; i < abs(amount); ++i) {
		bool valid = validMove(currentBlock->downPos(1));
		if (valid) {
			currentBlock->down(1);
		}
		else break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
je 0x6e17
movq %rdi, %rbx
movl %esi, %r15d
negl %r15d
cmovsl %esi, %r15d
movq %rsp, %r14
movq 0xb8(%rbx), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x8872
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x50(%rax)
movl %eax, %ebp
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6dfc
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
testb %bpl, %bpl
je 0x6e17
movq 0xb8(%rbx), %rdi
movl $0x1, %esi
callq 0x8790
decl %r15d
jne 0x6dc4
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6e3b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5480
nop
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/basicboard.cc
// Function: BasicBoard::changeCurrentBlock(char)
void BasicBoard::changeCurrentBlock(char type) {
	if (type == 'I') currentBlock = make_unique<I>();
	else if (type == 'J') currentBlock = make_unique<J>();
	else if (type == 'L') currentBlock = make_unique<L>();
	else if (type == 'O') currentBlock = make_unique<O>();
	else if (type == 'S') currentBlock = make_unique<S>();
	else if (type == 'Z') currentBlock = make_unique<Z>();
	//else if (type == '.') currentBlock = make_unique<Dot>();
	else currentBlock = make_unique<T>();
	currentBlock->attach(&sg);
	if (!textOnly) currentBlock->attach(&gd);
	currentBlock->notifCurrPos();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r15d
movq %rdi, %rbx
movl $0x50, %edi
callq 0x52b0
movq %rax, %r14
leal -0x49(%r15), %eax
cmpl $0xa, %eax
ja 0x77db
leaq 0xb92c(%rip), %rcx      # 0x130f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
callq 0xa7b4
jmp 0x781b
cmpl $0x5a, %r15d
jne 0x77eb
movq %r14, %rdi
callq 0x11d60
jmp 0x781b
movq %r14, %rdi
callq 0x11268
jmp 0x781b
movq %r14, %rdi
callq 0xfd14
jmp 0x781b
movq %r14, %rdi
callq 0xe628
jmp 0x781b
movq %r14, %rdi
callq 0xda18
jmp 0x781b
movq %r14, %rdi
callq 0xf6a4
movq 0xb8(%rbx), %rdi
movq %r14, 0xb8(%rbx)
testq %rdi, %rdi
je 0x7834
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xb8(%rbx), %rdi
addq $0x8, %rdi
leaq 0x8(%rbx), %rsi
callq 0x110bc
cmpb $0x0, 0xa8(%rbx)
jne 0x7865
movq 0xb8(%rbx), %rdi
addq $0x8, %rdi
leaq 0x30(%rbx), %rsi
callq 0x110bc
movq 0xb8(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
popq %r14
popq %r15
jmpq *0x30(%rax)
jmp 0x7883
jmp 0x7883
jmp 0x7883
jmp 0x7883
jmp 0x7883
jmp 0x7883
movq %rax, %rbx
movl $0x50, %esi
movq %r14, %rdi
callq 0x52c0
movq %rbx, %rdi
callq 0x5480
nop
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/block1.cc
// Function: Block1::~Block1()
Block1::~Block1(){
  for (int i = 0; i < coords.size(); ++i){
    State stat = {' ', coords[i], false};
    setState(stat);
    notifyObservers();
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x11d7b(%rip), %rax     # 0x1a308
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
cmpq %rdi, 0x38(%rbx)
je 0x85ef
leaq 0x8(%rbx), %r14
xorl %r12d, %r12d
movabsq $-0x10000000000, %r13   # imm = 0xFFFFFF0000000000
movq %r15, %rax
andq %r13, %rax
movl (%rdi,%r12,8), %esi
movl 0x4(%rdi,%r12,8), %r15d
shlq $0x20, %rsi
orq %rax, %r15
orq $0x20, %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x11102
movq %r14, %rdi
callq 0x110d4
incq %r12
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r12, %rax
ja 0x85ab
testq %rdi, %rdi
je 0x8600
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x52c0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x861e
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x52c0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x63b5
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/block1.cc
// Function: Block1::move(int)
void Block1::move(int shift){
  for (int i = 0; i < coords.size(); ++i){
    State stat = {' ', coords[i], false};
    setState(stat);
    notifyObservers();
  }
  for (int i = 0; i < coords.size(); ++i){
    coords.at(i).col += shift;
    State stat = {c, coords[i], true};
    setState(stat);
    notifyObservers();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movabsq $-0x10000000000, %r13   # imm = 0xFFFFFF0000000000
movq 0x30(%rdi), %rax
cmpq %rax, 0x38(%rdi)
je 0x86b9
leaq 0x8(%r14), %r15
xorl %ebp, %ebp
movl (%rax,%rbp,8), %esi
movl 0x4(%rax,%rbp,8), %eax
shlq $0x20, %rsi
andq %r13, %r12
orq %rax, %r12
orq $0x20, %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x11102
movq %r15, %rdi
callq 0x110d4
incq %rbp
movq 0x30(%r14), %rax
movq 0x38(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbp, %rcx
ja 0x867a
movq 0x30(%r14), %rax
cmpq %rax, 0x38(%r14)
je 0x8717
leaq 0x8(%r14), %r15
xorl %ebp, %ebp
movl 0x4(%rax,%rbp,8), %ecx
addl %ebx, %ecx
movl %ecx, 0x4(%rax,%rbp,8)
movzbl 0x4c(%r14), %edx
movl (%rax,%rbp,8), %esi
shlq $0x20, %rsi
orq %rdx, %rsi
andq %r13, %r12
orq %rcx, %r12
btsq $0x20, %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x11102
movq %r15, %rdi
callq 0x110d4
incq %rbp
movq 0x30(%r14), %rax
movq 0x38(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbp, %rcx
ja 0x86c9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/block1.cc
// Function: Block1::movePos(int)
vector<Coordinates> Block1::movePos(int shift){
  vector<Coordinates> cds = coords;
  for (int i = 0; i < 4; ++i){
    cds.at(i).col += shift;
  }
  return cds;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
addq $0x30, %rsi
callq 0x8988
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x8762
addl %ebp, 0x4(%rax,%rsi,8)
incq %rsi
cmpq $0x4, %rsi
jne 0x8748
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xa9fb(%rip), %rdi      # 0x13164
xorl %eax, %eax
callq 0x53d0
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8787
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %r14, %rdi
callq 0x5480
nop
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/block1.cc
// Function: Block1::down(int)
void Block1::down(int shift){
  int size = coords.size();
  for (int i = 0; i < size; ++i){
    State stat = {' ', coords[i], false};
    setState(stat);
    notifyObservers();
  }
  for (int i = 0; i < coords.size(); ++i){
    coords.at(i).row += shift;
    State stat = {c, coords[i], true};
    setState(stat);
    notifyObservers();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, 0x4(%rsp)
movq %rdi, %r14
movabsq $-0x10000000000, %rbx   # imm = 0xFFFFFF0000000000
movq 0x38(%rdi), %rbp
subq 0x30(%rdi), %rbp
shrq $0x3, %rbp
testl %ebp, %ebp
jle 0x87ff
leaq 0x8(%r14), %r15
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq 0x30(%r14), %rax
movl (%rax,%r13,8), %esi
movl 0x4(%rax,%r13,8), %eax
shlq $0x20, %rsi
andq %rbx, %r12
orq %rax, %r12
orq $0x20, %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x11102
movq %r15, %rdi
callq 0x110d4
incq %r13
cmpq %r13, %rbp
jne 0x87c9
movq 0x30(%r14), %rax
cmpq %rax, 0x38(%r14)
movq %rbx, %r13
movl 0x4(%rsp), %ebx
je 0x8863
leaq 0x8(%r14), %r15
xorl %ebp, %ebp
movl (%rax,%rbp,8), %esi
addl %ebx, %esi
movl %esi, (%rax,%rbp,8)
movzbl 0x4c(%r14), %ecx
shlq $0x20, %rsi
orq %rcx, %rsi
movl 0x4(%rax,%rbp,8), %eax
andq %r13, %r12
orq %rax, %r12
btsq $0x20, %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x11102
movq %r15, %rdi
callq 0x110d4
incq %rbp
movq 0x30(%r14), %rax
movq 0x38(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbp, %rcx
ja 0x8816
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/block1.cc
// Function: Block1::downPos(int)
vector<Coordinates> Block1::downPos(int shift){
  vector<Coordinates> cds = coords;
  int size = coords.size();
  for (int i = 0; i < size; ++i){
    cds.at(i).row += shift;
  }
  return cds;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x30, %rsi
callq 0x8988
movq 0x38(%r14), %rax
subq 0x30(%r14), %rax
shrq $0x3, %rax
testl %eax, %eax
jle 0x88bc
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x88c4
addl %ebp, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x88ac
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xa899(%rip), %rdi      # 0x13164
xorl %eax, %eax
callq 0x53d0
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x88e9
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %r14, %rdi
callq 0x5480
nop
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/cell.cc
// Function: Cell::clearCell()
void Cell::clearCell(){
  type = ' ';
  State stat = {' ', coords, false};
  setState(stat);
  notifyObservers();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb $0x20, 0x28(%rdi)
movl 0x2c(%rdi), %esi
movl 0x30(%rdi), %edx
shlq $0x20, %rsi
orq $0x20, %rsi
callq 0x11102
movq %rbx, %rdi
popq %rbx
jmp 0x110d4
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/cell.cc
// Function: Cell::changeCell(char)
void Cell::changeCell(char changeTo){
  type = changeTo;
  State stat = {changeTo, coords, true};
  setState(stat);
  notifyObservers();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb %sil, 0x28(%rdi)
movl 0x2c(%rdi), %eax
movl 0x30(%rdi), %edx
shlq $0x20, %rax
btsq $0x20, %rdx
movzbl %sil, %esi
orq %rax, %rsi
callq 0x11102
movq %rbx, %rdi
popq %rbx
jmp 0x110d4
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/cell.cc
// Function: Cell::changerow(int)
void Cell::changerow(int row){
  State stat = {' ', coords, false};
  setState(stat);
  notifyObservers();
  coords.row = row;
  stat = {type, coords, true};
  setState(stat);
  notifyObservers();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movl 0x2c(%rdi), %esi
movl 0x30(%rdi), %edx
shlq $0x20, %rsi
orq $0x20, %rsi
callq 0x11102
movq %rbx, %rdi
callq 0x110d4
movl %r14d, 0x2c(%rbx)
movzbl 0x28(%rbx), %eax
shlq $0x20, %r14
orq %rax, %r14
movl 0x30(%rbx), %edx
btsq $0x20, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11102
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x110d4
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/force.cc
// Function: Force::dropBlock()
int Force::dropBlock () {
	if (board->originalPos()) {
		int lines = board->dropBlock();
		return lines;
	} else {
		throw "game over";
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
testb %al, %al
je 0x907b
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x30(%rax)
movl $0x8, %edi
callq 0x5140
leaq 0xa0b4(%rip), %rcx      # 0x13140
movq %rcx, (%rax)
movq 0x11f12(%rip), %rsi     # 0x1afa8
movq %rax, %rdi
xorl %edx, %edx
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/game.cc
// Function: Game::restart()
void Game::restart() {
	brd1 = make_shared<BasicBoard> (1, defaultLevel, defaultLevel, textOnly, script1, seed);
	brd2 = make_shared<BasicBoard> (2, defaultLevel, defaultLevel, textOnly, script2, seed);
	if (defaultLevel >= 3) {
		brd1 = make_shared<Heavy> (brd1);
		brd2 = make_shared<Heavy> (brd2);
	}
	brd1->getNextBlock();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rcx
movl $0x1, (%rcx)
leaq 0x8(%rdi), %r14
leaq 0xc(%rdi), %r12
leaq 0x10(%rdi), %rax
leaq 0x50(%rdi), %r13
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
subq $0x8, %rsp
leaq 0x18(%rsp), %r15
leaq 0x13(%rsp), %rdx
movq %r15, %rsi
movq %r14, %r8
movq %r14, %r9
pushq %r13
pushq %rax
pushq %r12
callq 0xa0ea
addq $0x20, %rsp
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x60(%rbx), %rdi
movups %xmm0, 0x58(%rbx)
testq %rdi, %rdi
je 0x93d4
callq 0x63c0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x93e3
callq 0x63c0
leaq 0xc(%rsp), %rcx
movl $0x2, (%rcx)
leaq 0x30(%rbx), %rax
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
subq $0x8, %rsp
leaq 0x18(%rsp), %r15
leaq 0x13(%rsp), %rdx
movq %r15, %rsi
movq %r14, %r8
movq %r14, %r9
pushq %r13
pushq %rax
pushq %r12
callq 0xa0ea
addq $0x20, %rsp
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x70(%rbx), %rdi
movups %xmm0, 0x68(%rbx)
testq %rdi, %rdi
je 0x9441
callq 0x63c0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9450
callq 0x63c0
leaq 0x58(%rbx), %r15
cmpl $0x3, (%r14)
jl 0x9500
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %rdx
movq %r14, %rsi
movq %r15, %rcx
callq 0xa2b6
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x60(%rbx), %rdi
movups %xmm0, 0x58(%rbx)
testq %rdi, %rdi
je 0x949d
callq 0x63c0
leaq 0x68(%rbx), %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x94b0
callq 0x63c0
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %rdx
movq %r12, %rsi
movq %r14, %rcx
callq 0xa2b6
movaps (%r12), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r12)
movq 0x70(%rbx), %rdi
movups %xmm0, 0x68(%rbx)
testq %rdi, %rdi
je 0x94f1
callq 0x63c0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9500
callq 0x63c0
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/game.cc
// Function: Game::processWinner()
void Game::processWinner() {
	// calculate scores
	if (brd1->getScore() > brd2->getScore()) {
		cout << "Winner is Player 1!!! :)" << endl;
	} else if (brd2->getScore() > brd1->getScore()) {
		cout << "Winner is Player 2!!! :)" << endl;
	} else {
		cout << "Tie! Good game everyone :)" << endl;
	}
	throw "end game";
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %ebp
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cmpl %eax, %ebp
jle 0x96c8
leaq 0x9b35(%rip), %rsi      # 0x131f6
movl $0x18, %edx
jmp 0x96fc
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %ebp
movq 0x58(%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
xorl %ecx, %ecx
cmpl %eax, %ebp
setle %cl
leaq 0x18(%rcx,%rcx), %rdx
leaq 0x9b1e(%rip), %rax      # 0x1320f
leaq 0x9b30(%rip), %rsi      # 0x13228
cmovgq %rax, %rsi
movq 0x118c5(%rip), %rbx     # 0x1afc8
movq %rbx, %rdi
callq 0x5310
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5280
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x51c0
movl $0x8, %edi
callq 0x5140
leaq 0x9b00(%rip), %rcx      # 0x13243
movq %rcx, (%rax)
movq 0x1185b(%rip), %rsi     # 0x1afa8
movq %rax, %rdi
xorl %edx, %edx
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/game.cc
// Function: Game::processCommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
void Game::processCommand(string command, string filename, int repeat, int board) {
	Board *tmp;
	if (board == 1)
		tmp = brd1.get();
	else if (board == 2)
		tmp = brd2.get();

	if (command == "norandom")
		tmp->changeLevel(0, false, filename);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rax
cmpl $0x2, %r8d
je 0xa063
cmpl $0x1, %r8d
jne 0xa067
movq 0x58(%rdi), %rbx
jmp 0xa067
movq 0x68(%rdi), %rbx
leaq 0x925f(%rip), %rsi      # 0x132cd
movq %rax, %rdi
callq 0x50b0
testl %eax, %eax
jne 0xa0be
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x6510
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq *0x38(%rax)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xa0be
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xa0e1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5480
nop
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/heavy.cc
// Function: Heavy::downBlock(int)
void Heavy::downBlock(int amount) {
	for (int i = 0; i < abs(amount); ++i) {
		bool valid = board->validDownPos();
		if (valid) {
			board->downBlock(1);
		}
		else {
			int linesCleared = board->dropBlock();
			throw linesCleared;
		}
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
je 0xa770
movq %rdi, %rbx
movl %esi, %ebp
negl %ebp
cmovsl %esi, %ebp
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq 0x8(%rbx), %rdi
movq (%rdi), %rcx
testb %al, %al
je 0xa777
movl $0x1, %esi
callq *0x28(%rcx)
decl %ebp
jne 0xa74f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq *0x30(%rcx)
movl %eax, %ebx
movl $0x4, %edi
callq 0x5140
movl %ebx, (%rax)
movq 0x10809(%rip), %rsi     # 0x1af98
movq %rax, %rdi
xorl %edx, %edx
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/i.cc
// Function: I::I()
I::I(): Block1{0, 'I'} {
  coords.emplace_back(Coordinates {3,0});
  coords.emplace_back(Coordinates {3,1});
  coords.emplace_back(Coordinates {3,2});
  coords.emplace_back(Coordinates {3,3});
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
movl $0x49, %edx
callq 0x8554
leaq 0x100e2(%rip), %rax     # 0x1a8b0
movq %rax, (%rbx)
leaq 0x30(%rbx), %r14
movq %rsp, %rsi
movq $0x3, (%rsi)
movq %r14, %rdi
callq 0x8e56
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x8e56
movabsq $0x200000003, %rax      # imm = 0x200000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x8e56
movabsq $0x300000003, %rax      # imm = 0x300000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x8e56
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xa83d
jmp 0xa83d
jmp 0xa83d
movq %rax, %r14
movq %rbx, %rdi
callq 0x857a
movq %r14, %rdi
callq 0x5480
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/i.cc
// Function: I::turnPos(int)
vector<Coordinates> I::turnPos(int shift){
  if (shift > 0){
    shift = shift % 4;
  } else{
    shift = ((-4 * shift) - (shift * -1)) % 4;
  }
  vector<Coordinates> cds = coords;
  if ((shift % 2) != 0){
    if (position == 0){
      cds.at(1).row -= 1;
      cds.at(1).col -= 1;
      cds.at(2).row -= 2;
      cds.at(2).col -= 2;
      cds.at(3).row -= 3;
      cds.at(3).col -= 3;
    } else {
      cds.at(1).row += 1;
      cds.at(1).col += 1;
      cds.at(2).row += 2;
      cds.at(2).col += 2;
      cds.at(3).row += 3;
      cds.at(3).col += 3;
    }
  }
  return cds;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
jg 0xabd0
leal (%r15,%r15,2), %r15d
movl $0x3, %eax
subl %r15d, %eax
negl %r15d
testl %r15d, %r15d
cmovnsl %r15d, %eax
andl $-0x4, %eax
subl %eax, %r15d
leaq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x8988
testb $0x1, %r15b
je 0xac46
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
movq %rcx, %rdx
sarq $0x3, %rdx
cmpl $0x0, 0x48(%r14)
je 0xac1b
cmpq $0x2, %rdx
jb 0xac4f
incl 0x8(%rax)
incl 0xc(%rax)
cmpq $0x10, %rcx
je 0xac56
addl $0x2, 0x10(%rax)
addl $0x2, 0x14(%rax)
movl $0x3, %ecx
jmp 0xac3a
cmpq $0x2, %rdx
jb 0xac4f
decl 0x8(%rax)
decl 0xc(%rax)
cmpq $0x10, %rcx
je 0xac56
addl $-0x2, 0x10(%rax)
addl $-0x2, 0x14(%rax)
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
cmpq $0x3, %rdx
jbe 0xac5d
addl %ecx, 0x18(%rax)
addl %ecx, 0x1c(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %esi
jmp 0xac62
movl $0x2, %esi
jmp 0xac62
movl $0x3, %esi
leaq 0x84fb(%rip), %rdi      # 0x13164
xorl %eax, %eax
callq 0x53d0
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xac87
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %r14, %rdi
callq 0x5480
nop
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/j.cc
// Function: J::J()
J::J(): Block1{0, 'J'} {
  coords.emplace_back(Coordinates {2,0});
  coords.emplace_back(Coordinates {3,0});
  coords.emplace_back(Coordinates {3,1});
  coords.emplace_back(Coordinates {3,2});
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
movl $0x4a, %edx
callq 0x8554
leaq 0xcede(%rip), %rax      # 0x1a910
movq %rax, (%rbx)
leaq 0x30(%rbx), %r14
movq %rsp, %rsi
movq $0x2, (%rsi)
movq %r14, %rdi
callq 0x8e56
movq %rsp, %rsi
movq $0x3, (%rsi)
movq %r14, %rdi
callq 0x8e56
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x8e56
movabsq $0x200000003, %rax      # imm = 0x200000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x8e56
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xda9b
jmp 0xda9b
jmp 0xda9b
movq %rax, %r14
movq %rbx, %rdi
callq 0x857a
movq %r14, %rdi
callq 0x5480
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/j.cc
// Function: J::turnPos(int)
vector<Coordinates> J::turnPos(int shift){
  vector<Coordinates> cds = coords;
  if (shift > 0){
    shift = shift % 4;
  } else{
    shift = ((-4 * shift) - (shift * -1)) % 4;
  }
  int pos = position;
  while (shift > 0){
    if (pos == 0){
      cds.at(2).row -= 2;
      cds.at(3).row -= 2;
      cds.at(3).col -= 2;
    } else if (pos == 1) {
      cds.at(1).col += 2;
      cds.at(2).row += 1;
      cds.at(2).col += 1;
      cds.at(3).row += 1;
      cds.at(3).col += 1;
    } else if (pos == 2) {
      cds.at(0).row += 1;
      cds.at(1).col -= 1;
      cds.at(2).row -= 1;
      cds.at(2).col -= 1;
    } else {
      cds.at(0).row -= 1;
      cds.at(1).col -= 1;
      cds.at(2).row += 2;
      cds.at(3).row += 1;
      cds.at(3).col += 1;
    }
    pos = (pos + 1) % 4;
    --shift;
  }
  return cds;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
addq $0x30, %rsi
callq 0x8988
testl %r14d, %r14d
jle 0xe494
andl $0x3, %r14d
jmp 0xe4b0
leal (%r14,%r14,2), %r14d
movl $0x3, %eax
subl %r14d, %eax
negl %r14d
testl %r14d, %r14d
cmovnsl %r14d, %eax
andl $-0x4, %eax
subl %eax, %r14d
testl %r14d, %r14d
jle 0xe5bc
movl 0x48(%r15), %eax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdi
movq %rdi, %r8
subq %rcx, %r8
movq %r8, %rdx
sarq $0x3, %rdx
leaq 0x10(%rcx), %r9
leaq 0x14(%rcx), %r10
leaq 0x18(%rcx), %r11
leaq 0x1c(%rcx), %r15
incl %r14d
xorl %esi, %esi
cmpl $0x2, %eax
je 0xe538
cmpl $0x1, %eax
je 0xe518
testl %eax, %eax
jne 0xe563
cmpq $0x3, %rdx
jb 0xe5ce
addl $-0x2, 0x10(%rcx)
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
movq %r11, %r12
movq %r15, %r13
cmpq $0x18, %r8
jne 0xe58e
jmp 0xe5d5
cmpq $0x2, %rdx
jb 0xe5dc
addl $0x2, 0xc(%rcx)
cmpq $0x10, %r8
je 0xe5ce
incl 0x10(%rcx)
incl 0x14(%rcx)
jmp 0xe57d
cmpq %rcx, %rdi
je 0xe5e1
incl (%rcx)
cmpq $0x2, %rdx
jb 0xe5dc
decl 0xc(%rcx)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %r9, %r12
movq %r10, %r13
cmpq $0x10, %r8
jne 0xe58e
jmp 0xe5ce
cmpq %rcx, %rdi
je 0xe5e1
decl (%rcx)
cmpq $0x2, %rdx
jb 0xe5dc
decl 0xc(%rcx)
cmpq $0x10, %r8
je 0xe5ce
addl $0x2, 0x10(%rcx)
movl $0x1, %ebp
movq %r11, %r12
movq %r15, %r13
cmpq $0x3, %rdx
jbe 0xe5d5
addl %ebp, (%r12)
addl %ebp, (%r13)
leal 0x1(%rax), %ebp
leal 0x4(%rax), %r12d
testl %ebp, %ebp
cmovnsl %ebp, %r12d
andl $-0x4, %r12d
negl %r12d
addl %r12d, %eax
incl %eax
decl %r14d
cmpl $0x1, %r14d
jg 0xe4e6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x2, %esi
jmp 0xe5e1
movl $0x3, %esi
jmp 0xe5e1
movl $0x1, %esi
leaq 0x4b7c(%rip), %rdi      # 0x13164
xorl %eax, %eax
callq 0x53d0
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xe606
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %r14, %rdi
callq 0x5480
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/l.cc
// Function: L::L()
L::L(): Block1{0, 'L'} {
  coords.emplace_back(Coordinates {2,2});
  coords.emplace_back(Coordinates {3,0});
  coords.emplace_back(Coordinates {3,1});
  coords.emplace_back(Coordinates {3,2});
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
movl $0x4c, %edx
callq 0x8554
leaq 0xc32e(%rip), %rax      # 0x1a970
movq %rax, (%rbx)
leaq 0x30(%rbx), %r14
movabsq $0x200000002, %rax      # imm = 0x200000002
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x8e56
movq %rsp, %rsi
movq $0x3, (%rsi)
movq %r14, %rdi
callq 0x8e56
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x8e56
movabsq $0x200000003, %rax      # imm = 0x200000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x8e56
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xe6b1
jmp 0xe6b1
jmp 0xe6b1
movq %rax, %r14
movq %rbx, %rdi
callq 0x857a
movq %r14, %rdi
callq 0x5480
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/l.cc
// Function: L::turnPos(int)
vector<Coordinates> L::turnPos(int shift){
  vector<Coordinates> cds = coords;
  if (shift > 0){
    shift = shift % 4;
  } else{
    shift = ((-4 * shift) - (shift * -1)) % 4;
  }
  int pos = position;
  while (shift > 0){
    if (pos == 0){
      cds.at(0).col -= 2;
      cds.at(3).row -= 2;
      cds.at(3).col -= 2;
    } else if (pos == 1) {
      cds.at(2).row -= 1;
      cds.at(2).col += 1;
      cds.at(3).row += 1;
      cds.at(3).col += 1;
    } else if (pos == 2) {
      cds.at(0).row -= 1;
      cds.at(1).col += 1;
      cds.at(2).row -= 1;
      cds.at(2).col -= 1;
    } else {
      cds.at(0).row += 1;
      cds.at(0).col += 2;
      cds.at(1).col -= 1;
      cds.at(2).row += 2;
      cds.at(3).row += 1;
      cds.at(3).col += 1;
    }
    --shift;
    pos = (pos + 1) % 4;
  }
  return cds;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
addq $0x30, %rsi
callq 0x8988
testl %r14d, %r14d
jle 0xefd8
andl $0x3, %r14d
jmp 0xeff4
leal (%r14,%r14,2), %r14d
movl $0x3, %eax
subl %r14d, %eax
negl %r14d
testl %r14d, %r14d
cmovnsl %r14d, %eax
andl $-0x4, %eax
subl %eax, %r14d
testl %r14d, %r14d
jle 0xf0fa
movl 0x48(%r15), %eax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdi
movq %rdi, %r8
subq %rcx, %r8
movq %r8, %rdx
sarq $0x3, %rdx
leaq 0x10(%rcx), %r9
leaq 0x14(%rcx), %r10
leaq 0x18(%rcx), %r11
leaq 0x1c(%rcx), %r15
incl %r14d
xorl %esi, %esi
cmpl $0x2, %eax
je 0xf072
cmpl $0x1, %eax
je 0xf04c
testl %eax, %eax
jne 0xf09d
cmpq %rcx, %rdi
je 0xf11f
addl $-0x2, 0x4(%rcx)
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
jmp 0xf0c0
cmpq $0x3, %rdx
jb 0xf10c
decl 0x10(%rcx)
incl 0x14(%rcx)
movl $0x1, %ebp
movq %r11, %r12
movq %r15, %r13
cmpq $0x18, %r8
jne 0xf0cc
jmp 0xf113
cmpq %rcx, %rdi
je 0xf11f
decl (%rcx)
cmpq $0x2, %rdx
jb 0xf11a
incl 0xc(%rcx)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %r9, %r12
movq %r10, %r13
cmpq $0x10, %r8
jne 0xf0cc
jmp 0xf10c
cmpq %rcx, %rdi
je 0xf11f
incl (%rcx)
addl $0x2, 0x4(%rcx)
cmpq $0x2, %rdx
jb 0xf11a
decl 0xc(%rcx)
cmpq $0x10, %r8
je 0xf10c
addl $0x2, 0x10(%rcx)
movl $0x1, %ebp
movq %r11, %r12
movq %r15, %r13
cmpq $0x3, %rdx
jbe 0xf113
addl %ebp, (%r12)
addl %ebp, (%r13)
leal 0x1(%rax), %ebp
leal 0x4(%rax), %r12d
testl %ebp, %ebp
cmovnsl %ebp, %r12d
andl $-0x4, %r12d
negl %r12d
addl %r12d, %eax
incl %eax
decl %r14d
cmpl $0x1, %r14d
jg 0xf02a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x2, %esi
jmp 0xf11f
movl $0x3, %esi
jmp 0xf11f
movl $0x1, %esi
leaq 0x403e(%rip), %rdi      # 0x13164
xorl %eax, %eax
callq 0x53d0
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xf144
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %r14, %rdi
callq 0x5480
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/Level1.cc
// Function: Level1::nextBlock()
char Level1::nextBlock() {
    char next;

    srand (seed);

    int number = rand() % 12 + 1;

    if (number == 1) {
        next = 'S';
    } else if (number == 2) {
        next = 'Z';
    } else if (number >= 3 && number <= 4) {
        next = 'I';
    } else if (number >= 5 && number <= 6) {
        next = 'T';
    } else if (number >= 7 && number <= 8) {
        next = 'J';
    } else if (number >= 9 && number <= 10) {
        next = 'L';
    } else if (number >= 11 && number <= 12) {
        next = 'O';
    }

    return next;
}

// Assembly:
pushq %rax
movl 0xc(%rdi), %edi
callq 0x5270
callq 0x5090
cltq
imulq $0x2aaaaaab, %rax, %rcx # imm = 0x2AAAAAAB
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x21, %rcx
addl %edx, %ecx
shll $0x2, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
je 0xf1d3
cmpl $0x1, %eax
jne 0xf1d7
movb $0x5a, %al
jmp 0xf1d5
movb $0x53, %al
popq %rcx
retq
andl $-0x2, %eax
cmpl $0x2, %eax
je 0xf1f1
cmpl $0x4, %eax
je 0xf1ed
cmpl $0x6, %eax
jne 0xf1f5
movb $0x4a, %al
jmp 0xf1d5
movb $0x54, %al
jmp 0xf1d5
movb $0x49, %al
jmp 0xf1d5
xorl %ecx, %ecx
cmpl $0x8, %eax
setne %cl
leal (%rcx,%rcx,2), %eax
addl $0x4c, %eax
jmp 0xf1d5
nop
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/Level2.cc
// Function: Level2::nextBlock()
char Level2::nextBlock() {
    char next;

    srand (seed);

    int number = rand() % 7 + 1;

    if (number == 1) {
        next = 'S';
    } else if (number == 2) {
        next = 'Z';
    } else if (number == 3) {
        next = 'I';
    } else if (number == 4) {
        next = 'T';
    } else if (number == 5) {
        next = 'J';
    } else if (number == 6) {
        next = 'L';
    } else if (number == 7) {
        next = 'O';
    }

    return next;
}

// Assembly:
pushq %rax
movl 0xc(%rdi), %edi
callq 0x5270
callq 0x5090
cltq
imulq $-0x6db6db6d, %rax, %rdx # imm = 0x92492493
shrq $0x20, %rdx
addl %eax, %edx
movl %edx, %ecx
shrl $0x1f, %ecx
sarl $0x2, %edx
addl %ecx, %edx
leal (,%rdx,8), %ecx
subl %ecx, %edx
addl %eax, %edx
leal (,%rdx,8), %ecx
movabsq $0x4f4c4a54495a53, %rsi # imm = 0x4F4C4A54495A53
shrq %cl, %rsi
cmpl $0x7, %edx
movl $0x5a, %eax
cmovbl %esi, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/Level3.cc
// Function: Level3::nextBlock()
char Level3::nextBlock() {
    char next;

    srand (seed);

    int number = rand() % 9 + 1;

    if (number == 1) {
        next = 'I';
    } else if (number == 2) {
        next = 'T';
    } else if (number == 3) {
        next = 'J';
    } else if (number == 4) {
        next = 'L';
    } else if (number == 5) {
        next = 'O';
    } else if (number >= 6 && number <= 7) {
        next = 'S';
    } else if (number >= 8 && number <= 9) {
        next = 'Z';
    }

    return next;
}

// Assembly:
pushq %rax
movl 0xc(%rdi), %edi
callq 0x5270
callq 0x5090
movslq %eax, %rcx
imulq $0x38e38e39, %rcx, %rax # imm = 0x38E38E39
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rax
addl %edx, %eax
leal (%rax,%rax,8), %eax
subl %eax, %ecx
cmpl $0x5, %ecx
jae 0xf305
shll $0x3, %ecx
movabsq $0x4f4c4a5449, %rax     # imm = 0x4F4C4A5449
shrq %cl, %rax
jmp 0xf318
addl $-0x5, %ecx
cmpl $0x2, %ecx
movl $0x53, %ecx
movl $0x5a, %eax
cmovbl %ecx, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/NonRandom.cc
// Function: NonRandom::nextBlock()
char NonRandom::nextBlock() { //use istringstream to load one char at a time and substr, reload when empty
	char block;
    while (true) {
		istringstream ss{ sequence };
        if (ss >> block) {
            /*switch (block) {
                case 'L':
                    next = new L ();
                    break;
                case 'T':
                    //3,0 3,1 3,2 4,1
                    next = new T ();
                    break;
                case 'I':
                    // 4,0 4,1 4,2 4,3
                    next = new I ();
                    break;
                case 'Z':
                    // 3,0 3,1 4,1 4,2
                    next = new Z ();
                    break;
                case 'J':
                    // 3,0 4,0 4,1 4,2
                    next = new J ();
                    break;
                case 'S':
                    // 3,1 3,2 4,0 4,1
                    next = new S ();
                    break;
                case 'O':
                    // 3,0 3,1 4,0 4,1
                    next = new O ();
                    break;
            }


		}*/

            sequence = sequence.substr(1);
            break;
        } else {
            ifstream f{fileName};
			getline(f, sequence);
            // ss.str(sequence);
        }
    }

    return block;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x398, %rsp            # imm = 0x398
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
addq $0x10, %rbx
leaq 0x218(%rsp), %r12
leaq 0x10(%rsp), %rbp
movq 0xbad2(%rip), %r15      # 0x1afb8
movq %r12, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x5450
movq %r12, %rdi
leaq 0xf(%rsp), %rsi
callq 0x5360
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rax,%rcx), %r13d
testb $0x5, %r13b
je 0xf553
movq %rbp, %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x5410
movq 0x10(%rsp), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x5280
movsbl %al, %edx
movq %rbp, %rdi
movq %r14, %rsi
callq 0x54a0
movq %rbp, %rdi
callq 0x5070
jmp 0xf591
movl $0x1, %edx
movq %rbp, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x52e0
movq %r14, %rdi
movq %rbp, %rsi
callq 0x5340
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xf591
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %r12, %rdi
movq %r15, %rsi
callq 0x53a0
leaq 0x290(%rsp), %rdi
callq 0x50e0
testb $0x5, %r13b
jne 0xf4e6
movb 0xf(%rsp), %al
addq $0x398, %rsp            # imm = 0x398
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf5cd
jmp 0xf5cd
movq %rax, %rbx
jmp 0xf5df
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5070
movq 0xb9d2(%rip), %rsi      # 0x1afb8
leaq 0x218(%rsp), %rdi
callq 0x53a0
leaq 0x290(%rsp), %rdi
callq 0x50e0
movq %rbx, %rdi
callq 0x5480