LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/block.cc
// Function: Block::Block(CellType, int, std::vector<Cell*, std::allocator<Cell*>>)
Block::Block(CellType t, int l, std::vector<Cell*> cells): cells { cells }, btmLft { Coordinate { 3, 0 } } {
    std::vector<Cell*> sq;
    for(auto &c : cells){
        if(!c->isEmpty()){
            throw "Game Over";
        }
        for(auto &ci : cells){
            if(ci != c){
                sq.emplace_back(ci);
            }
        }
        c->set(t, l, sq);
        sq.clear();
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movl %edx, 0xc(%rsp)
movl %esi, 0x8(%rsp)
movq %rdi, %rbx
movq %rcx, %rsi
callq 0x7cb2
movq $0x3, 0x18(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq (%r14), %rbp
movq 0x8(%r14), %rax
movq %rax, 0x38(%rsp)
cmpq %rax, %rbp
je 0x7c23
movq %rbx, 0x30(%rsp)
leaq 0x40(%rsp), %r15
leaq 0x10(%rsp), %r13
movq (%rbp), %rdi
callq 0x8760
testb %al, %al
je 0x7c32
movq (%r14), %rbx
movq 0x8(%r14), %r12
cmpq %r12, %rbx
je 0x7bb8
movq (%rbx), %rax
cmpq (%rbp), %rax
je 0x7bb2
movq %r13, %rdi
movq %rbx, %rsi
callq 0x7d32
addq $0x8, %rbx
jmp 0x7b99
movq (%rbp), %rbx
movq %r15, %rdi
movq %r13, %rsi
callq 0x7cb2
movq %rbx, %rdi
movl 0x8(%rsp), %esi
movl 0xc(%rsp), %edx
movq %r15, %rcx
callq 0x85da
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x7bf1
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x52e0
movq 0x10(%rsp), %rdi
cmpq %rdi, 0x18(%rsp)
je 0x7c02
movq %rdi, 0x18(%rsp)
addq $0x8, %rbp
cmpq 0x38(%rsp), %rbp
jne 0x7b81
testq %rdi, %rdi
je 0x7c23
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x52e0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x5180
leaq 0xb6ee(%rip), %rcx      # 0x13331
movq %rcx, (%rax)
movq 0x14343(%rip), %rsi     # 0x1bf90
movq %rax, %rdi
xorl %edx, %edx
callq 0x54c0
jmp 0x7c77
movq %rax, %r14
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x7c7a
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x52e0
jmp 0x7c7a
jmp 0x7c77
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x7c91
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x52e0
movq 0x30(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x7caa
movq 0x10(%rax), %rsi
subq %rdi, %rsi
callq 0x52e0
movq %r14, %rdi
callq 0x54e0
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/cell.cc
// Function: Cell::notify(Subject&)
void Cell::notify(Subject& s) {
    Cell & c = dynamic_cast<Cell&>(s);
    CellInfo & info = dynamic_cast<CellInfo&>(c.getInfo());

	if (c.cellState.cellStatus == CellStatus::Dead) {
		if (info.pos.row == pos.row + 1) {
			c.cellState = CellState{CellStatus::Down};
			notifyObservers();
		}
	}
	else {
		if (info.pos.row == pos.row - 1) {
			blockLevel = info.blockLevel;
			type = info.type;
			squad = info.squad;

			// update squad
			for (auto& cell : squad) {
				for (unsigned i = 0; i < cell->squad.size(); ++i) {
					if (cell->squad.at(i)->pos == c.pos) {
						cell->squad.at(i) = this;
						break;
					}
				}
			}
		} else {
			c.cellState = CellState{CellStatus::Down};
			notifyObservers();
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x12c01(%rip), %rsi     # 0x1b208
leaq 0x12da2(%rip), %rdx     # 0x1b3b0
movl $0x8, %ecx
movq %rax, %rdi
callq 0x5300
testq %rax, %rax
je 0x874a
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x13379(%rip), %rsi     # 0x1b9b0
leaq 0x12dda(%rip), %rdx     # 0x1b418
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x5300
testq %rax, %rax
je 0x874a
cmpl $0x0, 0x88(%r14)
movl 0x8(%rax), %ecx
movl 0x58(%rbx), %edx
je 0x8704
decl %edx
cmpl %edx, %ecx
jne 0x870a
movq 0x10(%rax), %rcx
movq %rcx, 0x60(%rbx)
addq $0x18, %rax
leaq 0x68(%rbx), %rdi
movq %rax, %rsi
callq 0x87a8
movq 0x68(%rbx), %r12
movq 0x70(%rbx), %r13
cmpq %r13, %r12
je 0x873b
movq (%r12), %rcx
movq 0x68(%rcx), %rax
cmpq %rax, 0x70(%rcx)
je 0x86fe
movl $0x1, %ebp
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
addq $0x58, %rdi
movq 0x58(%r14), %rsi
callq 0xbf58
testb %al, %al
jne 0x86e2
movl %ebp, %r15d
movq (%r12), %rcx
movq 0x68(%rcx), %rax
movq 0x70(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
incl %ebp
cmpq %r15, %rcx
ja 0x86ae
jmp 0x86fe
movq (%r12), %rcx
movq 0x68(%rcx), %rax
movq 0x70(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r15, %rdx
jbe 0x874f
movq %rbx, (%rax,%r15,8)
addq $0x8, %r12
jmp 0x868f
incl %edx
cmpl %edx, %ecx
jne 0x873b
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x1, %esi
callq 0x8922
movl 0x8(%r15), %eax
movl %eax, 0x88(%r14)
movq %r15, %rdi
callq 0xeb2c
addq $0x8, %rbx
movq %rbx, %rdi
callq 0xeb4e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5530
leaq 0xac3c(%rip), %rdi      # 0x13392
movq %r15, %rsi
xorl %eax, %eax
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/cell.cc
// Function: Cell::getInfo()
Info& Cell::getInfo() {
	cellInfo.pos = pos;
	cellInfo.blockLevel = blockLevel;
	cellInfo.type = type;
	cellInfo.squad = squad;
	return cellInfo;
}

// Assembly:
pushq %rbx
leaq 0x28(%rdi), %rbx
movups 0x58(%rdi), %xmm0
movups %xmm0, 0x30(%rdi)
leaq 0x68(%rdi), %rsi
addq $0x40, %rdi
callq 0x87a8
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/concreteboard.cc
// Function: ConcreteBoard::levelUp()
void ConcreteBoard::levelUp(){
    level = level->levelUp();
    if (level->getLevel() == 3) {
        countTurn = 0;
    }
    notifyObservers();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rsi
movq (%rsi), %rax
movq %rsp, %r14
movq %r14, %rdi
callq *0x10(%rax)
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x68(%rbx), %rdi
movups %xmm0, 0x60(%rbx)
testq %rdi, %rdi
je 0x8d12
callq 0x5f5e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8d12
callq 0x5f5e
movq 0x60(%rbx), %rdi
callq 0xe9ac
cmpl $0x3, %eax
jne 0x8d27
movl $0x0, 0x70(%rbx)
movq %rbx, %rdi
callq 0xeb4e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/concreteboard.cc
// Function: ConcreteBoard::levelDown()
void ConcreteBoard::levelDown(){
    level = level->levelDown();
    if (level->getLevel() == 4) {
        countTurn = 0;
    }
    notifyObservers();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rsi
movq (%rsi), %rax
movq %rsp, %r14
movq %r14, %rdi
callq *0x8(%rax)
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x68(%rbx), %rdi
movups %xmm0, 0x60(%rbx)
testq %rdi, %rdi
je 0x8d7e
callq 0x5f5e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8d7e
callq 0x5f5e
movq 0x60(%rbx), %rdi
callq 0xe9ac
cmpl $0x4, %eax
jne 0x8d93
movl $0x0, 0x70(%rbx)
movq %rbx, %rdi
callq 0xeb4e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/concreteboard.cc
// Function: ConcreteBoard::getInfo()
Info& ConcreteBoard::getInfo()  {
    boardInfo.player = boardNum;
    boardInfo.level = level->getLevel();
    boardInfo.score = score;
    boardInfo.boardData = display();
    boardInfo.nextType = nextType;
    return boardInfo;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movl 0x44(%rdi), %eax
leaq 0x98(%rdi), %r14
movl %eax, 0xa0(%rdi)
movq 0x60(%rdi), %rdi
callq 0xe9ac
movl %eax, 0xa4(%rbx)
movl 0x5c(%rbx), %eax
movl %eax, 0xa8(%rbx)
movq (%rbx), %rax
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq *0x50(%rax)
movq 0xc0(%rbx), %rax
movaps (%r15), %xmm0
movq 0x10(%r15), %rcx
movq %rcx, 0xc0(%rbx)
movups 0xb0(%rbx), %xmm1
movups %xmm0, 0xb0(%rbx)
leaq 0x20(%rsp), %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
callq 0x8192
movq %r15, %rdi
callq 0x8192
movl 0x58(%rbx), %eax
movl %eax, 0xc8(%rbx)
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/concreteboard.cc
// Function: ConcreteBoard::display()
std::vector<std::vector<char>> ConcreteBoard::display() {
	std::vector<std::vector<char>> displayBoard;
	std::vector<char> temp;
	for (int i = 0; i < 18; ++i) {
		for (int j = 0; j < 11; ++j) {
			switch(allCells[i][j].type) {
				case CellType::I:
					temp.emplace_back('I');
					break;
				case CellType::J:
					temp.emplace_back('J');
					break;
				case CellType::L:
					temp.emplace_back('L');
					break;
				case CellType::O:
					temp.emplace_back('O');
					break;
				case CellType::S:
					temp.emplace_back('S');
					break;
				case CellType::Z:
					temp.emplace_back('Z');
					break;
				case CellType::T:
					temp.emplace_back('T');
					break;
				case CellType::E:
					temp.emplace_back(' ');
					break;
				case CellType::Star:
					temp.emplace_back('*');
					break;
			}
		}
		displayBoard.emplace_back(temp);
		temp.clear();
	}
	return displayBoard;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movq %rdi, 0x8(%rsp)
movups %xmm0, (%rdi)
leaq 0x10(%rsp), %r15
movq %rax, 0x10(%r15)
movaps %xmm0, (%r15)
leaq 0x8bb6(%rip), %rbp      # 0x1342c
leaq 0x7(%rsp), %r12
movl $0x64, %ebx
movq %rax, 0x30(%rsp)
leaq (%rax,%rax,2), %r13
movq 0x78(%r14), %rax
movq (%rax,%r13,8), %rax
movl (%rax,%rbx), %eax
cmpq $0x8, %rax
ja 0xa94b
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
movb $0x49, 0x7(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xacd8
jmp 0xa94b
movb $0x53, 0x7(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xacd8
jmp 0xa94b
movb $0x4c, 0x7(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xacd8
jmp 0xa94b
movb $0x4f, 0x7(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xacd8
jmp 0xa94b
movb $0x20, 0x7(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xacd8
jmp 0xa94b
movb $0x4a, 0x7(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xacd8
jmp 0xa94b
movb $0x5a, 0x7(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xacd8
jmp 0xa94b
movb $0x54, 0x7(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xacd8
jmp 0xa94b
movb $0x2a, 0x7(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xacd8
addq $0x90, %rbx
cmpq $0x694, %rbx            # imm = 0x694
jne 0xa889
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xad0c
movq 0x10(%rsp), %rdi
cmpq %rdi, 0x18(%rsp)
movq 0x30(%rsp), %rax
je 0xa982
movq %rdi, 0x18(%rsp)
incq %rax
cmpq $0x12, %rax
jne 0xa87b
testq %rdi, %rdi
je 0xa9a1
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x52e0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa9c7
jmp 0xa9c7
jmp 0xa9c7
jmp 0xa9c7
jmp 0xa9c7
jmp 0xa9c7
jmp 0xa9c7
jmp 0xa9c7
jmp 0xa9c7
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xa9e1
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x52e0
movq 0x8(%rsp), %rdi
callq 0x8192
movq %r14, %rdi
callq 0x54e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/concreteboard.cc
// Function: ConcreteBoard::replaceBlock(CellType)
void ConcreteBoard::replaceBlock(CellType newType) {
    for(auto& c: thisBlock->cells){
        c->restore();
    }
    thisBlock->cells.clear();
	CellType temp = nextType;
	nextType = newType;
	genThis();
	nextType = temp;
	notifyObservers();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0xaabe
movq (%r14), %rdi
callq 0x85bc
addq $0x8, %r14
cmpq %r15, %r14
jne 0xaa9c
movq 0x48(%rbx), %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0xaabe
movq %rcx, 0x8(%rax)
movl 0x58(%rbx), %r14d
movl %ebp, 0x58(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
movl %r14d, 0x58(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xeb4e
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/forcedecorator.cc
// Function: ForceDecorator::ForceDecorator(std::shared_ptr<Board>, CellType)
ForceDecorator::ForceDecorator(std::shared_ptr<Board> board, CellType giventype): BoardDecorator { board }, giventype{giventype} {
	for (auto &i : board->observers) {
              attach(i);
        }
	board->replaceBlock(giventype);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xbfaa
movq 0x1000c(%rip), %rcx     # 0x1bfa8
cmpb $0x0, (%rcx)
je 0xbfa6
incl 0x8(%rax)
jmp 0xbfaa
lock
incl 0x8(%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7ea8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xbfc4
callq 0x5f5e
leaq 0xf635(%rip), %rax      # 0x1b600
movq %rax, (%rbx)
movl %ebp, 0x40(%rbx)
movq (%r14), %rdi
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r12
cmpq %r12, %r15
je 0xbff8
movq (%r15), %rsi
movq %rbx, %rdi
callq 0xeb38
addq $0x8, %r15
cmpq %r12, %r15
jne 0xbfe1
movq (%r14), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x90(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc026
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xc031
callq 0x5f5e
jmp 0xc031
movq %rax, %r14
movq %rbx, %rdi
callq 0x7a3e
movq %r14, %rdi
callq 0x54e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/game.cc
// Function: Game::heavy()
void Game::heavy() {
    if (playerTurn == 1) {
        board1 = std::make_shared<HeavyDecorator>(board1);
    }
    else if (playerTurn == 0) {
        board2 = std::make_shared<HeavyDecorator>(board2);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x44(%rdi), %eax
testl %eax, %eax
je 0xc3ad
cmpl $0x1, %eax
jne 0xc3ef
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xd2e6
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x8(%rbx), %rdi
movups %xmm0, (%rbx)
jmp 0xc3d6
leaq 0x10(%rbx), %rdx
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rsi
movq %r14, %rdi
callq 0xd2e6
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x18(%rbx), %rdi
movups %xmm0, 0x10(%rbx)
testq %rdi, %rdi
je 0xc3ef
callq 0x5f5e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xc3ef
callq 0x5f5e
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/game.cc
// Function: Game::blind()
void Game::blind() {
    if (playerTurn == 1) {
        board1 = std::make_shared<BlindDecorator>(board1);
        board1->notifyObservers();
    }
    else if (playerTurn == 0) {
        board2 = std::make_shared<BlindDecorator>(board2);
        board2->notifyObservers();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x44(%rdi), %eax
testl %eax, %eax
je 0xc456
cmpl $0x1, %eax
jne 0xc4a6
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xd48c
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x8(%rbx), %rdi
movups %xmm0, (%rbx)
testq %rdi, %rdi
je 0xc49e
callq 0x5f5e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xc49e
callq 0x5f5e
jmp 0xc49e
leaq 0x10(%rbx), %r14
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0xd48c
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x18(%rbx), %rdi
movups %xmm0, 0x10(%rbx)
testq %rdi, %rdi
je 0xc49b
callq 0x5f5e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xc49b
callq 0x5f5e
movq %r14, %rbx
movq (%rbx), %rdi
callq 0xeb4e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/game.cc
// Function: Game::force(CellType)
void Game::force(CellType type) {
    if (playerTurn == 1) {
        board1 = std::make_shared<ForceDecorator>(board1, type);
	board1->notifyObservers();
    }
    else if (playerTurn == 0) {
        board2 = std::make_shared<ForceDecorator>(board2, type);
	board2->notifyObservers();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl 0x44(%rdi), %eax
testl %eax, %eax
je 0xc517
cmpl $0x1, %eax
jne 0xc56c
leaq 0x10(%rsp), %r14
leaq 0xb(%rsp), %rsi
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0xd632
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x8(%rbx), %rdi
movups %xmm0, (%rbx)
testq %rdi, %rdi
je 0xc564
callq 0x5f5e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xc564
callq 0x5f5e
jmp 0xc564
leaq 0x10(%rbx), %r14
leaq 0x10(%rsp), %r15
leaq 0xb(%rsp), %rsi
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0xd632
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x18(%rbx), %rdi
movups %xmm0, 0x10(%rbx)
testq %rdi, %rdi
je 0xc561
callq 0x5f5e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xc561
callq 0x5f5e
movq %r14, %rbx
movq (%rbx), %rdi
callq 0xeb4e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/game.cc
// Function: Game::recover()
void Game::recover() {
    if (playerTurn == 0) {
        board1 = board1->getBoard();
    }
    else if (playerTurn == 1) {
        board2 = board2->getBoard();
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x44(%rdi), %eax
cmpl $0x1, %eax
je 0xc5af
testl %eax, %eax
jne 0xc5eb
movq (%rbx), %rsi
movq (%rsi), %rax
movq %rsp, %r14
movq %r14, %rdi
callq *0x58(%rax)
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x8(%rbx), %rdi
movups %xmm0, (%rbx)
jmp 0xc5d2
movq 0x10(%rbx), %rsi
movq (%rsi), %rax
movq %rsp, %r14
movq %r14, %rdi
callq *0x58(%rax)
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x18(%rbx), %rdi
movups %xmm0, 0x10(%rbx)
testq %rdi, %rdi
je 0xc5eb
callq 0x5f5e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xc5eb
callq 0x5f5e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/game.cc
// Function: Game::left(std::istream&, int)
void Game::left(std::istream & in, int n) {
    int numberOfRowsRemoved = 0;
    if (playerTurn == 0) {
        numberOfRowsRemoved = board1->left(n);

        // special actions
        if (numberOfRowsRemoved >= 2) {
            execAction(in);
        }

        if (board1->isTurnOver()) {
            board1->setTurnOver();
            recover();
            switchTurn();
        }
    }
    else if (playerTurn == 1) {
        numberOfRowsRemoved = board2->left(n);

        // special actions
        if (numberOfRowsRemoved >= 2) {
            execAction(in);
        }

        if (board2->isTurnOver()) {
            board2->setTurnOver();
            recover();
            switchTurn();
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x44(%rdi), %eax
cmpl $0x1, %eax
je 0xc634
testl %eax, %eax
jne 0xc67f
movq (%rbx), %rdi
movq (%rdi), %rax
movl %edx, %esi
callq *0x8(%rax)
cmpl $0x2, %eax
jl 0xc626
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc686
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq %rbx, %r15
jmp 0xc65d
leaq 0x10(%rbx), %r15
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movl %edx, %esi
callq *0x8(%rax)
cmpl $0x2, %eax
jl 0xc654
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc686
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
testb %al, %al
je 0xc67f
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq %rbx, %rdi
callq 0xc576
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc8f0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/game.cc
// Function: Game::switchTurn()
void Game::switchTurn() {
    if (playerTurn == 0) {
        board1->genThis();
        board2->setNext(board2->genNext());
        playerTurn = 1;
    }
    else if (playerTurn == 1) {
        board2->genThis();
        board1->setNext(board1->genNext());
        playerTurn = 0;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x44(%rdi), %eax
cmpl $0x1, %eax
je 0xc917
testl %eax, %eax
jne 0xc940
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
leaq 0x10(%rbx), %rax
movl $0x1, %ebp
jmp 0xc926
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
xorl %ebp, %ebp
movq %rbx, %rax
movq (%rax), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x48(%rax)
movq (%r14), %rcx
movq %r14, %rdi
movl %eax, %esi
callq *0x68(%rcx)
movl %ebp, 0x44(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/game.cc
// Function: Game::right(std::istream&, int)
void Game::right(std::istream & in, int n) {
    int numberOfRowsRemoved = 0;
    if (playerTurn == 0) {
        numberOfRowsRemoved = board1->right(n);

        // special actions
        if (numberOfRowsRemoved >= 2) {
            execAction(in);
        }

        if (board1->isTurnOver()) {
            board1->setTurnOver();
            recover();
            switchTurn();
        }
    }
    else if (playerTurn == 1) {
        numberOfRowsRemoved = board2->right(n);

        // special actions
        if (numberOfRowsRemoved >= 2) {
            execAction(in);
        }

        if (board2->isTurnOver()) {
            board2->setTurnOver();
            recover();
            switchTurn();
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x44(%rdi), %eax
cmpl $0x1, %eax
je 0xc986
testl %eax, %eax
jne 0xc9d1
movq (%rbx), %rdi
movq (%rdi), %rax
movl %edx, %esi
callq *0x10(%rax)
cmpl $0x2, %eax
jl 0xc978
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc686
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq %rbx, %r15
jmp 0xc9af
leaq 0x10(%rbx), %r15
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movl %edx, %esi
callq *0x10(%rax)
cmpl $0x2, %eax
jl 0xc9a6
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc686
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
testb %al, %al
je 0xc9d1
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq %rbx, %rdi
callq 0xc576
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc8f0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/game.cc
// Function: Game::drop(std::istream&, int)
void Game::drop(std::istream & in, int n) {
    int numberOfRowsRemoved = 0;
    if (playerTurn == 0) {
        if(n > 1){
            board1->setCountD(n - 1);
        } else if (board1->getCountD() > 0) {
            board1->setCountD(board1->getCountD() - 1);
        }

        numberOfRowsRemoved = board1->drop();

        // special actions
        if (numberOfRowsRemoved >= 2) {
            execAction(in);
        }

        if (board1->isTurnOver()) {
            board1->setTurnOver();
            recover();
            switchTurn();
        }
    }
    else if (playerTurn == 1) {
        if(n > 1){
            board2->setCountD(n - 1);
        } else if (board2->getCountD() > 0){
            board2->setCountD(board2->getCountD() - 1);
        }

        numberOfRowsRemoved = board2->drop();

        // special actions
        if (numberOfRowsRemoved >= 2) {
            execAction(in);
        }

        if (board2->isTurnOver()) {
            board2->setTurnOver();
            recover();
            switchTurn();
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x44(%rdi), %eax
cmpl $0x1, %eax
je 0xca93
testl %eax, %eax
jne 0xcb17
movq (%rbx), %r15
cmpl $0x1, %edx
jg 0xca5c
movq (%r15), %rax
movq %r15, %rdi
callq *0x98(%rax)
testl %eax, %eax
jle 0xca6c
movq (%rbx), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x98(%rax)
movl %eax, %edx
decl %edx
movq (%r15), %rax
movq %r15, %rdi
movl %edx, %esi
callq *0xa0(%rax)
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x2, %eax
jl 0xca85
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc686
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq %rbx, %r15
jmp 0xcaf5
movq 0x10(%rbx), %r15
cmpl $0x1, %edx
jg 0xcabe
movq (%r15), %rax
movq %r15, %rdi
callq *0x98(%rax)
testl %eax, %eax
jle 0xcace
movq 0x10(%rbx), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x98(%rax)
movl %eax, %edx
decl %edx
movq (%r15), %rax
movq %r15, %rdi
movl %edx, %esi
callq *0xa0(%rax)
leaq 0x10(%rbx), %r15
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x2, %eax
jl 0xcaec
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc686
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
testb %al, %al
je 0xcb17
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq %rbx, %rdi
callq 0xc576
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc8f0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/game.cc
// Function: Game::levelup(int)
void Game::levelup(int n) {
    if (playerTurn == 0) {
        for (int i = 0; i < n; ++i) {
            board1->levelUp();
        }
    }
    else {
        for (int i = 0; i < n; ++i) {
            board2->levelUp();
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x0, 0x44(%rdi)
je 0xcb41
testl %ebx, %ebx
jle 0xcb52
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
decl %ebx
jne 0xcb31
jmp 0xcb52
testl %ebx, %ebx
jle 0xcb52
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
decl %ebx
jne 0xcb45
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/game.cc
// Function: Game::leveldown(int)
void Game::leveldown(int n) {
    if (playerTurn == 0) {
        for (int i = 0; i < n; ++i) {
            board1->levelDown();
        }
    }
    else {
        for (int i = 0; i < n; ++i) {
            board2->levelDown();
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x0, 0x44(%rdi)
je 0xcb7d
testl %ebx, %ebx
jle 0xcb8e
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
decl %ebx
jne 0xcb6d
jmp 0xcb8e
testl %ebx, %ebx
jle 0xcb8e
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
decl %ebx
jne 0xcb81
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/game.cc
// Function: Game::norandom(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Game::norandom(std::string file) {
    if (playerTurn == 0) {
        board1->noRandom(file);
    }
    else if (playerTurn == 1) {
        board2->noRandom(file);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl 0x44(%rdi), %eax
cmpl $0x1, %eax
je 0xcbeb
testl %eax, %eax
jne 0xcc33
movq (%rdi), %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x6248
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x80(%rax)
movq 0x20(%rsp), %rdi
jmp 0xcc23
movq 0x10(%rdi), %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x6248
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x80(%rax)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xcc33
movq (%r15), %rsi
incq %rsi
callq 0x52e0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0xcc4e
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xcc5e
movq (%r15), %rsi
incq %rsi
callq 0x52e0
movq %rbx, %rdi
callq 0x54e0
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/game.cc
// Function: Game::replaceBlock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Game::replaceBlock(std::string cmd) {
    CellType type = CellType::E;

    if (cmd == "I") {
        type = CellType::I;
    }
    else if (cmd == "J") {
        type = CellType::J;
    }
    else if (cmd == "L") {
        type = CellType::L;
    }
    else if (cmd == "O") {
        type = CellType::O;
    }
    else if (cmd == "S") {
        type = CellType::S;
    }
    else if (cmd == "Z") {
        type = CellType::Z;
    }
    else if (cmd == "T") {
        type = CellType::T;
    }

    if (playerTurn == 0) {
        board1->replaceBlock(type);
    } else {
        board2->replaceBlock(type);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6ccb(%rip), %rsi      # 0x13960
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xcd1c
leaq 0x6cbc(%rip), %rsi      # 0x13964
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xcd20
leaq 0x6c95(%rip), %rsi      # 0x13950
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xcd27
leaq 0x6c85(%rip), %rsi      # 0x13953
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xcd2e
leaq 0x6c76(%rip), %rsi      # 0x13957
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xcd35
leaq 0x6c78(%rip), %rsi      # 0x1396c
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xcd3c
leaq 0x6c68(%rip), %rsi      # 0x1396f
movq %r14, %rdi
callq 0x50d0
cmpl $0x1, %eax
movl $0x7, %esi
sbbl $0x0, %esi
jmp 0xcd41
xorl %esi, %esi
jmp 0xcd41
movl $0x1, %esi
jmp 0xcd41
movl $0x2, %esi
jmp 0xcd41
movl $0x3, %esi
jmp 0xcd41
movl $0x4, %esi
jmp 0xcd41
movl $0x5, %esi
xorl %eax, %eax
cmpl $0x0, 0x44(%rbx)
setne %al
shll $0x4, %eax
movq (%rbx,%rax), %rdi
movq (%rdi), %rax
movq 0x90(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/heavydecorator.cc
// Function: HeavyDecorator::left(int)
int HeavyDecorator::left(int time) {
	board->left(time);
	int lineRemove = 0;
	if (!board->down(1) || !board->down(1)) {
		lineRemove = board->drop();
	}
	notifyObservers();
	return lineRemove;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x20(%rax)
testb %al, %al
je 0xd81c
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x20(%rax)
xorl %ebp, %ebp
testb %al, %al
jne 0xd828
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ebp
movq %rbx, %rdi
callq 0xeb4e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/heavydecorator.cc
// Function: HeavyDecorator::right(int)
int HeavyDecorator::right(int time) {
	board->right(time);
	int lineRemove = 0;
	if (!board->down(1) || !board->down(1)) {
		lineRemove = board->drop();
	}
	notifyObservers();
	return lineRemove;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x20(%rax)
testb %al, %al
je 0xd872
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x20(%rax)
xorl %ebp, %ebp
testb %al, %al
jne 0xd87e
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ebp
movq %rbx, %rdi
callq 0xeb4e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/level.cc
// Function: Level::setReadFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Level::setReadFromFile(std::string fileName) {
	readFromFile = true;

	std::ifstream fin;
	fin.open(fileName.c_str());

	sequence.clear();
	char c;
	CellType type = CellType::I;
	while (fin >> c) {
		switch (c) {
			case 'I':
				type = CellType::I;
				break;
			case 'J':
				type = CellType::J;
				break;
			case 'L':
				type = CellType::L;
				break;
			case 'O':
				type = CellType::O;
				break;
			case 'S':
				type = CellType::S;
				break;
			case 'Z':
				type = CellType::Z;
				break;
			case 'T':
				type = CellType::T;
				break;
		}
		sequence.emplace_back(type);
	}
	nextLine = 0;

	fin.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %r14
movq %rdi, %rbx
movb $0x1, 0x30(%rdi)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x5310
movq (%r14), %rsi
movq %r15, %rdi
movl $0x8, %edx
callq 0x5200
movq 0x38(%rbx), %rax
cmpq %rax, 0x40(%rbx)
je 0xe880
movq %rax, 0x40(%rbx)
leaq 0x38(%rbx), %r14
leaq 0x8(%rsp), %r15
movl $0x0, (%r15)
leaq 0x10(%rsp), %r12
leaq 0xf(%rsp), %r13
leaq 0x505b(%rip), %rbp      # 0x138fc
movq %r12, %rdi
movq %r13, %rsi
callq 0x5380
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xe94b
movzbl 0xf(%rsp), %eax
leal -0x49(%rax), %ecx
cmpl $0xb, %ecx
ja 0xe8df
movslq (%rbp,%rcx,4), %rax
addq %rbp, %rax
jmpq *%rax
movl $0x0, 0x8(%rsp)
jmp 0xe91e
cmpl $0x5a, %eax
jne 0xe91e
movl $0x5, 0x8(%rsp)
jmp 0xe91e
movl $0x2, 0x8(%rsp)
jmp 0xe91e
movl $0x6, 0x8(%rsp)
jmp 0xe91e
movl $0x3, 0x8(%rsp)
jmp 0xe91e
movl $0x1, 0x8(%rsp)
jmp 0xe91e
movl $0x4, 0x8(%rsp)
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0xe93b
movl 0x8(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x40(%rbx)
jmp 0xe8a1
movq %r14, %rdi
movq %r15, %rdx
callq 0xe9f0
jmp 0xe8a1
movl $0x0, 0x50(%rbx)
leaq 0x10(%rsp), %rdi
callq 0x5070
leaq 0x10(%rsp), %rdi
callq 0x5090
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe97c
jmp 0xe97c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5090
movq %rbx, %rdi
callq 0x54e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/textdisplay.cc
// Function: TextDisplay::notify(Subject&)
void TextDisplay::notify(Subject & s) {
	Board & b = dynamic_cast<Board&>(s);
	BoardInfo &bi = dynamic_cast<BoardInfo&>(b.getInfo());

	int player = bi.player;
	level.at(player) = bi.level;
	score.at(player) = bi.score;
	boardData.at(player) = bi.boardData;
	nextType.at(player) = bi.nextType;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
leaq 0xc214(%rip), %rsi      # 0x1b208
leaq 0xc30d(%rip), %rdx      # 0x1b308
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x5300
testq %rax, %rax
je 0xf0df
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
leaq 0xc993(%rip), %rsi      # 0x1b9b0
leaq 0xc33c(%rip), %rdx      # 0x1b360
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x5300
testq %rax, %rax
je 0xf0df
movq %rax, %r15
movslq 0x8(%rax), %r14
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r14, %rdx
jbe 0xf0ce
movl 0xc(%r15), %ecx
movl %ecx, (%rax,%r14,4)
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r14, %rdx
jbe 0xf0ce
movl 0x10(%r15), %ecx
movl %ecx, (%rax,%r14,4)
movq 0x38(%rbx), %rax
movq 0x40(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %r14, %rdx
jbe 0xf0ce
movq %r15, %rsi
addq $0x18, %rsi
leaq (%r14,%r14,2), %rcx
leaq (%rax,%rcx,8), %rdi
callq 0xfa8a
movq 0x50(%rbx), %rax
movq 0x58(%rbx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r14, %rdx
jbe 0xf0ce
movl 0x30(%r15), %ecx
movl %ecx, (%rax,%r14,4)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x42bd(%rip), %rdi      # 0x13392
movq %r14, %rsi
xorl %eax, %eax
callq 0x5410
callq 0x5530
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/window.cc
// Function: Xwindow::fillPolygon(int, int, int, int, int, int)
void Xwindow::fillPolygon(int x, int y, int vertices, int side, int rotate, int colour){
	XPoint* point = new XPoint[vertices];

	point[0] = XPoint{(short int)x, (short int)y};

	double angle = rotate + pi/2;

	for ( int i = 1; i < vertices; ++i ){
		short int X = side * sin(angle);
		short int Y = side * cos(angle);
		point[i] = XPoint{X,Y};
		angle += 2*pi - pi* 2/vertices;
	}

	XSetForeground(d, gc, colours[colour]);
	XFillPolygon(d, w, gc, point, vertices, Convex, CoordModePrevious);
	XSetForeground(d, gc, colours[Black]);

	delete[] point;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, 0x20(%rsp)
movl %r8d, 0x10(%rsp)
movl %ecx, %ebp
movl %edx, %r13d
movl %esi, %r15d
movq %rdi, %rbx
movl 0x90(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl %ecx, %r12d
leaq (,%r12,4), %rax
testl %ecx, %ecx
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x5030
movq %rax, %r14
movw %r15w, (%rax)
movw %r13w, 0x2(%rax)
cmpl $0x2, %ebp
jl 0x11c9d
cvtsi2sdl 0x20(%rsp), %xmm1
movsd 0xa6e6(%rip), %xmm0     # 0x1c2e8
mulsd 0x1fd6(%rip), %xmm0     # 0x13be0
cvtsi2sdl 0x10(%rsp), %xmm2
cvtsi2sd %ebp, %xmm3
movsd %xmm3, 0x38(%rsp)
addsd %xmm1, %xmm0
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
movapd %xmm2, 0x40(%rsp)
movl $0x1, %r15d
movsd %xmm0, 0x10(%rsp)
callq 0x5080
movapd %xmm0, 0x20(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x5520
movapd 0x20(%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
mulpd 0x40(%rsp), %xmm1
cvttpd2dq %xmm1, %xmm0
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
movd %xmm0, (%r14,%r15,4)
movsd 0xa677(%rip), %xmm2     # 0x1c2e8
movapd %xmm2, %xmm1
mulsd 0x1f6b(%rip), %xmm1     # 0x13be8
divsd 0x38(%rsp), %xmm1
addsd %xmm2, %xmm2
addsd %xmm1, %xmm2
movsd 0x10(%rsp), %xmm0
addsd %xmm2, %xmm0
incq %r15
cmpq %r15, %r12
jne 0x11c2e
movq (%rbx), %rdi
movq 0x18(%rbx), %rsi
movslq 0x1c(%rsp), %rax
movq 0x20(%rbx,%rax,8), %rdx
callq 0x5130
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rdx
movl $0x1, (%rsp)
movq %r14, %rcx
movl %ebp, %r8d
movl $0x2, %r9d
callq 0x5510
movq (%rbx), %rdi
movq 0x18(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0x5130
movq %r14, %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5370
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/window.cc
// Function: Xwindow::drawStringFont(int, int, 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)
void Xwindow::drawStringFont(int x, int y, string msg, string font, int colour) {
  XFontStruct * f = XLoadQueryFont(d, font.c_str());
  
	if ( f == nullptr ){
		f = XLoadQueryFont(d, "6x13");
	}

	printMessage(x, y, msg, colour, *f);
	delete f;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r12
movq (%rdi), %rdi
movq (%r8), %rsi
callq 0x54f0
movq %rax, %r13
testq %rax, %rax
jne 0x11f6f
movq (%r12), %rdi
leaq 0x1cbd(%rip), %rsi      # 0x13c24
callq 0x54f0
movq %rax, %r13
movq %r12, %rdi
movl %r15d, %esi
movl %ebp, %edx
movq %r14, %rcx
movl %ebx, %r8d
movq %r13, %r9
callq 0x11e9c
movl $0x60, %esi
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x52e0
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/window.cc
// Function: Xwindow::drawBigString(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void Xwindow::drawBigString(int x, int y, string msg, int colour) {
  // Font f = XLoadFont(d, "-*-helvetica-bold-r-normal--*-240-*-*-*-*-*");
  ostringstream name;
  name << "-*-helvetica-bold-r-*-*-*-240-" << width/5 << "-" << height/5 << "-*-*-*-*";

	drawStringFont(x, y, msg, name.str(), colour);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movl %r8d, %ebx
movq %rcx, %r12
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
leaq 0x40(%rsp), %r13
movq %r13, %rdi
callq 0x5390
leaq 0x1c56(%rip), %rsi      # 0x13c29
movl $0x1e, %edx
movq %r13, %rdi
callq 0x5320
movslq 0x78(%r15), %rax
imulq $0x66666667, %rax, %rsi # imm = 0x66666667
movq %rsi, %rax
shrq $0x3f, %rax
sarq $0x21, %rsi
addl %eax, %esi
leaq 0x40(%rsp), %rdi
callq 0x54d0
movq %rax, %r13
leaq 0x1c3a(%rip), %rsi      # 0x13c46
movl $0x1, %edx
movq %rax, %rdi
callq 0x5320
movslq 0x7c(%r15), %rax
imulq $0x66666667, %rax, %rsi # imm = 0x66666667
movq %rsi, %rax
shrq $0x3f, %rax
sarq $0x21, %rsi
addl %eax, %esi
movq %r13, %rdi
callq 0x54d0
leaq 0x1bdb(%rip), %rsi      # 0x13c1b
movl $0x8, %edx
movq %rax, %rdi
callq 0x5320
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x6248
leaq 0x48(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x5470
movq %rsp, %rcx
leaq 0x20(%rsp), %r8
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %ebx, %r9d
callq 0x11f30
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x120ac
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x52e0
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x120c2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52e0
movq 0x9ed7(%rip), %rsi      # 0x1bfa0
leaq 0x40(%rsp), %rdi
callq 0x51a0
leaq 0xb0(%rsp), %rdi
callq 0x5120
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12115
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x52e0
jmp 0x12115
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x12130
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52e0
jmp 0x12130
movq %rax, %rbx
movq 0x9e69(%rip), %rsi      # 0x1bfa0
leaq 0x40(%rsp), %rdi
callq 0x51a0
leaq 0xb0(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x54e0
// File: /workspace/github_cpp_makefile_star2_O3/Altius[P]hotspot2/src/resolveOverlapsInSummit-CenteredPeaks.cpp
// Function: resolveOverlaps(std::__cxx11::list<Peak, std::allocator<Peak>>&)
void resolveOverlaps(list<Peak>& peaks)
{
  peaks.sort(Peak_scoreGT);

  for (list<Peak>::iterator it1 = peaks.begin(); it1 != peaks.end(); it1++)
    {
      list<Peak>::iterator it2(it1);
      it2++;
      while (it2 != peaks.end())
	{
	  if (it2->beg < it1->end && it2->end > it1->beg)
	    {
	      list<Peak>::iterator it3(it2);
	      it2++;
	      peaks.erase(it3);
	    }
	  else
	    it2++;
	}
    }
  // restore to genomic, sort-bed order
  peaks.sort(Peak_coordLT);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq -0x1c(%rip), %rsi       # 0x242b
callq 0x2c48
movq (%rbx), %r14
cmpq %rbx, %r14
je 0x2493
movq (%r14), %rsi
cmpq %rbx, %rsi
je 0x248b
movq 0x30(%rsi), %rax
cmpq 0x38(%r14), %rax
jge 0x2480
movq 0x38(%rsi), %rax
cmpq 0x30(%r14), %rax
jle 0x2480
movq (%rsi), %r15
movq %rbx, %rdi
callq 0x30ae
movq %r15, %rsi
jmp 0x2483
movq (%rsi), %rsi
cmpq %rbx, %rsi
jne 0x245c
movq (%r14), %rsi
movq %rsi, %r14
cmpq %rbx, %rsi
jne 0x2454
leaq -0xee(%rip), %rsi       # 0x23ac
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2c48
// File: /workspace/github_cpp_makefile_star2_O3/WayfireWM[P]wf-utils/wayfire/condition/logic_condition.cpp
// Function: wf::or_condition_t::evaluate(wf::access_interface_t&, bool&)
bool or_condition_t::evaluate(access_interface_t &interface, bool &error)
{
    if ((error) || (left == nullptr) || (right == nullptr))
    {
        error = true;
        return false;
    }

    return left->evaluate(interface, error) | right->evaluate(interface, error);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, (%rdx)
movq %rdx, %rbx
jne 0x64df
movq %rdi, %r15
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x64df
cmpq $0x0, 0x18(%r15)
je 0x64df
movq (%rdi), %rax
movq %rbx, %rdx
movq %rsi, %r14
callq *0x10(%rax)
movq 0x18(%r15), %rdi
movl %eax, %ebp
movq %r14, %rsi
movq %rbx, %rdx
movq (%rdi), %rax
callq *0x10(%rax)
orb %bpl, %al
jmp 0x64e4
movb $0x1, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/WayfireWM[P]wf-utils/wayfire/condition/logic_condition.cpp
// Function: wf::or_condition_t::to_string[abi:cxx11]() const
std::string or_condition_t::to_string() const
{
    std::string out = "(";
    if (left != nullptr)
    {
        out.append(left->to_string());
    }
    else
    {
        out.append("nullptr");
    }
    out.append(" | ");
    if (right != nullptr)
    {
        out.append(right->to_string());
    }
    else
    {
        out.append("nullptr");
    }
    out.append(")");
    return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
leaq 0x10(%rdi), %r15
leaq 0x6947(%rip), %rsi      # 0xce4e
leaq 0x6941(%rip), %rdx      # 0xce4f
movq %rdi, %rbx
movq %r15, (%rdi)
callq 0x6386
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x6559
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x18(%rax)
movq 0x8(%rsp), %rdx
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x5090
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6568
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5230
jmp 0x6568
leaq 0x5afc(%rip), %rsi      # 0xc05c
movq %rbx, %rdi
callq 0x53b0
leaq 0x5af5(%rip), %rsi      # 0xc064
movq %rbx, %rdi
callq 0x53b0
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x65b7
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x18(%rax)
movq 0x8(%rsp), %rdx
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x5090
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x65c6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5230
jmp 0x65c6
leaq 0x5a9e(%rip), %rsi      # 0xc05c
movq %rbx, %rdi
callq 0x53b0
leaq 0x6856(%rip), %rsi      # 0xce23
movq %rbx, %rdi
callq 0x53b0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x65e6
jmp 0x6608
leaq 0x10(%rsp), %rcx
movq %rax, %r14
movq -0x10(%rcx), %rdi
cmpq %rcx, %rdi
je 0x660b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5230
jmp 0x660b
jmp 0x6608
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x661e
movq (%r15), %rsi
incq %rsi
callq 0x5230
movq %r14, %rdi
callq 0x5390
// File: /workspace/github_cpp_makefile_star2_O3/WayfireWM[P]wf-utils/wayfire/condition/logic_condition.cpp
// Function: wf::and_condition_t::evaluate(wf::access_interface_t&, bool&)
bool and_condition_t::evaluate(access_interface_t &interface, bool &error)
{
    if ((error) || (left == nullptr) || (right == nullptr))
    {
        error = true;
        return false;
    }

    return left->evaluate(interface, error) & right->evaluate(interface, error);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, (%rdx)
movq %rdx, %rbx
jne 0x66d9
movq %rdi, %r15
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x66d9
cmpq $0x0, 0x18(%r15)
je 0x66d9
movq (%rdi), %rax
movq %rbx, %rdx
movq %rsi, %r14
callq *0x10(%rax)
movq 0x18(%r15), %rdi
movl %eax, %ebp
movq %r14, %rsi
movq %rbx, %rdx
movq (%rdi), %rax
callq *0x10(%rax)
andb %bpl, %al
jmp 0x66de
movb $0x1, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/WayfireWM[P]wf-utils/wayfire/condition/logic_condition.cpp
// Function: wf::and_condition_t::to_string[abi:cxx11]() const
std::string and_condition_t::to_string() const
{
    std::string out = "(";
    if (left != nullptr)
    {
        out.append(left->to_string());
    }
    else
    {
        out.append("nullptr");
    }
    out.append(" & ");
    if (right != nullptr)
    {
        out.append(right->to_string());
    }
    else
    {
        out.append("nullptr");
    }
    out.append(")");
    return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
leaq 0x10(%rdi), %r15
leaq 0x674d(%rip), %rsi      # 0xce4e
leaq 0x6747(%rip), %rdx      # 0xce4f
movq %rdi, %rbx
movq %r15, (%rdi)
callq 0x6386
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x6753
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x18(%rax)
movq 0x8(%rsp), %rdx
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x5090
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6762
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5230
jmp 0x6762
leaq 0x5902(%rip), %rsi      # 0xc05c
movq %rbx, %rdi
callq 0x53b0
leaq 0x58ff(%rip), %rsi      # 0xc068
movq %rbx, %rdi
callq 0x53b0
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x67b1
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x18(%rax)
movq 0x8(%rsp), %rdx
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x5090
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67c0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5230
jmp 0x67c0
leaq 0x58a4(%rip), %rsi      # 0xc05c
movq %rbx, %rdi
callq 0x53b0
leaq 0x665c(%rip), %rsi      # 0xce23
movq %rbx, %rdi
callq 0x53b0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x67e0
jmp 0x6802
leaq 0x10(%rsp), %rcx
movq %rax, %r14
movq -0x10(%rcx), %rdi
cmpq %rcx, %rdi
je 0x6805
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5230
jmp 0x6805
jmp 0x6802
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6818
movq (%r15), %rsi
incq %rsi
callq 0x5230
movq %r14, %rdi
callq 0x5390