LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x30, %rsi
callq 0x8588
movq 0x38(%r14), %r15
subq 0x30(%r14), %r15
shrq $0x3, %r15
xorl %r14d, %r14d
testl %r15d, %r15d
cmovlel %r14d, %r15d
cmpq %r14, %r15
je 0x84d7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x71fe
addl %ebp, (%rax)
incq %r14
jmp 0x84c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7c3a
movq %r14, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O2/EstherJin[P]TetrisRemake/block1.cc
// Function: Block1::notifCurrPos()
void Block1::notifCurrPos(){
  int size = coords.size();
  for (int i = 0; i < size; ++i){
    State stat = {c, coords[i], true};
    setState(stat);
    notifyObservers();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %r12
subq 0x30(%rdi), %r12
shrq $0x3, %r12
leaq 0x8(%rdi), %r14
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
movabsq $-0x10000000000, %rbp   # imm = 0xFFFFFF0000000000
cmpq %r13, %r12
je 0x856a
movzbl 0x4c(%rbx), %eax
movq 0x30(%rbx), %rcx
movl (%rcx,%r13,8), %esi
movl 0x4(%rcx,%r13,8), %ecx
shlq $0x20, %rsi
orq %rax, %rsi
andq %rbp, %r15
orq %rcx, %r15
btsq $0x20, %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0xf2c8
movq %r14, %rdi
callq 0xf29c
incq %r13
jmp 0x852a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf2c8
movq %rbx, %rdi
popq %rbx
jmp 0xf29c
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf2c8
movq %rbx, %rdi
popq %rbx
jmp 0xf29c
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf2c8
movq %rbx, %rdi
callq 0xf29c
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 0xf2c8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf29c
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8bc9
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x30(%rax)
pushq $0x8
popq %rdi
callq 0x5170
leaq 0x8555(%rip), %rcx      # 0x1112d
movq %rcx, (%rax)
movq 0x113c6(%rip), %rsi     # 0x19fa8
movq %rax, %rdi
xorl %edx, %edx
callq 0x5440
// File: /workspace/github_cpp_makefile_star2_O2/EstherJin[P]TetrisRemake/game.cc
// Function: Game::Game(int, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
Game::Game(int startLevel, bool textOnly, string script1, string script2, unsigned seed): defaultLevel{startLevel}, textOnly{textOnly}, script1{script1}, script2{script2}, seed{seed} {
	brd1 = make_shared <BasicBoard> (1, startLevel, startLevel, textOnly, script1, seed);
	brd2 = make_shared <BasicBoard> (2, startLevel, startLevel, textOnly, script2, seed);
	if (startLevel >= 3) {
		brd1 = make_shared<Heavy> (brd1);
		brd2 = make_shared<Heavy> (brd2);
	}
	brd1->getNextBlock();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebp
movq %r8, %r13
movq %rcx, %r12
movq %rdi, %r14
movl %esi, 0xc(%rsp)
movb %dl, 0xb(%rsp)
movl %r9d, 0x24(%rsp)
movq $0x12, (%rdi)
movl %esi, 0x8(%rdi)
movb %dl, 0xc(%rdi)
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x5380
leaq 0x30(%r14), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x5380
movl %ebp, 0x50(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x68(%r14)
leaq 0x20(%rsp), %rsi
movl $0x1, (%rsi)
leaq 0x24(%rsp), %rbp
movq %rbp, (%rsp)
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rcx
leaq 0xb(%rsp), %r8
movq %rcx, %rdx
movq %r12, %r9
callq 0x971d
leaq 0x58(%r14), %r12
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x9a16
leaq 0x18(%rsp), %rdi
callq 0x5e60
leaq 0x20(%rsp), %rsi
movl $0x2, (%rsi)
movq %rbp, (%rsp)
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rcx
leaq 0xb(%rsp), %r8
movq %rcx, %rdx
movq %r13, %r9
callq 0x971d
leaq 0x68(%r14), %r13
leaq 0x10(%rsp), %rsi
movq %r13, %rdi
callq 0x9a16
leaq 0x18(%rsp), %rdi
callq 0x5e60
cmpl $0x3, 0xc(%rsp)
jl 0x8d43
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x974e
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x9c06
leaq 0x18(%rsp), %rdi
callq 0x5e60
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x974e
leaq 0x10(%rsp), %rsi
movq %r13, %rdi
callq 0x9c06
leaq 0x18(%rsp), %rdi
callq 0x5e60
movq (%r12), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8d64
jmp 0x8d64
jmp 0x8d64
jmp 0x8d64
movq %rax, %r12
leaq 0x70(%r14), %rdi
callq 0x5e60
addq $0x60, %r14
movq %r14, %rdi
callq 0x5e60
movq %r15, %rdi
callq 0x5140
jmp 0x8d89
movq %rax, %r12
movq %rbx, %rdi
callq 0x5140
movq %r12, %rdi
callq 0x5450
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x14(%rsp), %rax
movl $0x1, (%rax)
movq %rax, %rsi
leaq 0x8(%rdi), %r15
leaq 0xc(%rdi), %r12
leaq 0x10(%rdi), %r9
leaq 0x50(%rdi), %r13
movq %r13, (%rsp)
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x971d
leaq 0x58(%r14), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x9a16
leaq 0x20(%rsp), %rdi
callq 0x5e60
leaq 0x14(%rsp), %rax
movl $0x2, (%rax)
leaq 0x30(%r14), %r9
movq %r13, (%rsp)
leaq 0x18(%rsp), %r13
leaq 0x14(%rsp), %rsi
movq %r13, %rdi
movq %r15, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x971d
leaq 0x68(%r14), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x9a16
leaq 0x20(%rsp), %rdi
callq 0x5e60
cmpl $0x3, 0x8(%r14)
jl 0x8e94
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x974e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9c06
leaq 0x20(%rsp), %rdi
callq 0x5e60
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x974e
movq %r15, %rdi
movq %r14, %rsi
callq 0x9c06
leaq 0x20(%rsp), %rdi
callq 0x5e60
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8fb3
leaq 0x8232(%rip), %rsi      # 0x111e3
jmp 0x8fdd
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %ebp
movq 0x58(%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cmpl %eax, %ebp
leaq 0x822a(%rip), %rax      # 0x111fc
leaq 0x823c(%rip), %rsi      # 0x11215
cmovgq %rax, %rsi
movq 0x10fdc(%rip), %rdi     # 0x19fc0
callq 0x52b0
movq %rax, %rdi
callq 0x5160
pushq $0x8
popq %rdi
callq 0x5170
leaq 0x8230(%rip), %rcx      # 0x11230
movq %rcx, (%rax)
movq 0x10f9e(%rip), %rsi     # 0x19fa8
movq %rax, %rdi
xorl %edx, %edx
callq 0x5440
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rsi, %rax
cmpl $0x2, %r8d
je 0x96c3
cmpl $0x1, %r8d
jne 0x96c7
movq 0x58(%rdi), %r14
jmp 0x96c7
movq 0x68(%rdi), %r14
leaq 0x7bec(%rip), %rsi      # 0x112ba
movq %rax, %rdi
callq 0x5d3d
testb %al, %al
je 0x9700
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5380
movq (%r14), %rax
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq *0x38(%rax)
movq %rsp, %rdi
callq 0x5140
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5140
movq %rbx, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, %r14d
negl %r14d
cmovsl %esi, %r14d
pushq $0x1
popq %rbp
subl $0x1, %r14d
jb 0xa100
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq 0x8(%rbx), %rdi
movq (%rdi), %rcx
testb %al, %al
je 0xa105
movl %ebp, %esi
callq *0x28(%rcx)
jmp 0xa0de
popq %rbx
popq %r14
popq %rbp
retq
callq *0x30(%rcx)
movl %eax, %ebx
pushq $0x4
popq %rdi
callq 0x5170
movl %ebx, (%rax)
movq 0xfe7d(%rip), %rsi      # 0x19f98
movq %rax, %rdi
xorl %edx, %edx
callq 0x5440
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x49
popq %rdx
xorl %esi, %esi
callq 0x81a4
leaq 0xf75c(%rip), %rax      # 0x198b0
movq %rax, (%rbx)
leaq 0x30(%rbx), %r14
movq %rsp, %rsi
movq $0x3, (%rsi)
movq %r14, %rdi
callq 0x89d8
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x89d8
movabsq $0x200000003, %rax      # imm = 0x200000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x89d8
movabsq $0x300000003, %rax      # imm = 0x300000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x89d8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xa1c3
jmp 0xa1c3
jmp 0xa1c3
movq %rax, %r14
movq %rbx, %rdi
callq 0x81ca
movq %r14, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x30, %rsi
callq 0x8588
testb $0x1, %bpl
je 0xa478
cmpl $0x0, 0x48(%r14)
je 0xa421
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x71fe
incl (%rax)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x71fe
incl 0x4(%rax)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x71fe
addl $0x2, (%rax)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x71fe
addl $0x2, 0x4(%rax)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x71fe
addl $0x3, (%rax)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x71fe
pushq $0x3
jmp 0xa474
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x71fe
decl (%rax)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x71fe
decl 0x4(%rax)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x71fe
addl $-0x2, (%rax)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x71fe
addl $-0x2, 0x4(%rax)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x71fe
addl $-0x3, (%rax)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x71fe
pushq $-0x3
popq %rcx
addl %ecx, 0x4(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7c3a
movq %r14, %rdi
callq 0x5450
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x4a
popq %rdx
xorl %esi, %esi
callq 0x81a4
leaq 0xd3b0(%rip), %rax      # 0x19910
movq %rax, (%rbx)
leaq 0x30(%rbx), %r14
movq %rsp, %rsi
movq $0x2, (%rsi)
movq %r14, %rdi
callq 0x89d8
movq %rsp, %rsi
movq $0x3, (%rsi)
movq %r14, %rdi
callq 0x89d8
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x89d8
movabsq $0x200000003, %rax      # imm = 0x200000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x89d8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xc5c9
jmp 0xc5c9
jmp 0xc5c9
movq %rax, %r14
movq %rbx, %rdi
callq 0x81ca
movq %r14, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O2/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, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x30, %rsi
callq 0x8588
andl $0x3, %ebp
movl 0x48(%r14), %r12d
pushq $0x2
popq %r15
pushq $0x4
popq %r14
pushq $0x3
popq %r13
testl %ebp, %ebp
jle 0xcf93
cmpl $0x2, %r12d
je 0xcf01
cmpl $0x1, %r12d
je 0xced2
testl %r12d, %r12d
jne 0xcf37
movq %rbx, %rdi
movq %r15, %rsi
callq 0x71fe
addl $-0x2, (%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x71fe
addl $-0x2, (%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x71fe
pushq $-0x2
jmp 0xcf7b
movq %rbx, %rdi
pushq $0x1
popq %rsi
callq 0x71fe
addl $0x2, 0x4(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x71fe
incl (%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x71fe
addq $0x4, %rax
pushq $0x1
jmp 0xcf5e
movq %rbx, %rdi
xorl %esi, %esi
callq 0x71fe
incl (%rax)
movq %rbx, %rdi
pushq $0x1
popq %rsi
callq 0x71fe
decl 0x4(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x71fe
decl (%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x71fe
pushq $-0x1
jmp 0xcf7b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x71fe
decl (%rax)
movq %rbx, %rdi
pushq $0x1
popq %rsi
callq 0x71fe
decl 0x4(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x71fe
pushq $0x2
popq %rcx
addl %ecx, (%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x71fe
incl (%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x71fe
pushq $0x1
popq %rcx
addl %ecx, 0x4(%rax)
incl %r12d
movl %r12d, %eax
cltd
idivl %r14d
decl %ebp
movl %edx, %r12d
jmp 0xce87
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7c3a
movq %r14, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x4c
popq %rdx
xorl %esi, %esi
callq 0x81a4
leaq 0xc988(%rip), %rax      # 0x19970
movq %rax, (%rbx)
leaq 0x30(%rbx), %r14
movabsq $0x200000002, %rax      # imm = 0x200000002
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x89d8
movq %rsp, %rsi
movq $0x3, (%rsi)
movq %r14, %rdi
callq 0x89d8
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x89d8
movabsq $0x200000003, %rax      # imm = 0x200000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x89d8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xd057
jmp 0xd057
jmp 0xd057
movq %rax, %r14
movq %rbx, %rdi
callq 0x81ca
movq %r14, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O2/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, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x30, %rsi
callq 0x8588
andl $0x3, %ebp
movl 0x48(%r14), %r15d
pushq $0x2
popq %r12
pushq $0x4
popq %r14
pushq $0x3
popq %r13
testl %ebp, %ebp
jle 0xd980
cmpl $0x2, %r15d
je 0xd8e0
cmpl $0x1, %r15d
je 0xd8c0
testl %r15d, %r15d
jne 0xd916
movq %rbx, %rdi
xorl %esi, %esi
callq 0x71fe
addl $-0x2, 0x4(%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x71fe
addl $-0x2, (%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x71fe
pushq $-0x2
jmp 0xd968
movq %rbx, %rdi
movq %r12, %rsi
callq 0x71fe
decl (%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x71fe
addq $0x4, %rax
pushq $0x1
jmp 0xd94b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x71fe
decl (%rax)
movq %rbx, %rdi
pushq $0x1
popq %rsi
callq 0x71fe
incl 0x4(%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x71fe
decl (%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x71fe
pushq $-0x1
jmp 0xd968
movq %rbx, %rdi
xorl %esi, %esi
callq 0x71fe
incl (%rax)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x71fe
addl $0x2, 0x4(%rax)
movq %rbx, %rdi
pushq $0x1
popq %rsi
callq 0x71fe
decl 0x4(%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x71fe
pushq $0x2
popq %rcx
addl %ecx, (%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x71fe
incl (%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x71fe
pushq $0x1
popq %rcx
addl %ecx, 0x4(%rax)
decl %ebp
incl %r15d
movl %r15d, %eax
cltd
idivl %r14d
movl %edx, %r15d
jmp 0xd875
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7c3a
movq %r14, %rdi
callq 0x5450
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x52a0
callq 0x50a0
pushq $0xc
popq %rcx
cltd
idivl %ecx
testl %edx, %edx
je 0xda13
cmpl $0x1, %edx
jne 0xda17
movb $0x5a, %al
jmp 0xda15
movb $0x53, %al
popq %rcx
retq
andl $-0x2, %edx
cmpl $0x2, %edx
je 0xda31
cmpl $0x4, %edx
je 0xda2d
cmpl $0x6, %edx
jne 0xda35
movb $0x4a, %al
jmp 0xda15
movb $0x54, %al
jmp 0xda15
movb $0x49, %al
jmp 0xda15
xorl %eax, %eax
cmpl $0x8, %edx
setne %al
leal (%rax,%rax,2), %eax
orl $0x4c, %eax
jmp 0xda15
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x52a0
callq 0x50a0
pushq $0x9
popq %rcx
cltd
idivl %ecx
cmpl $0x5, %edx
jae 0xdb07
shll $0x3, %edx
movabsq $0x4f4c4a5449, %rax     # imm = 0x4F4C4A5449
movl %edx, %ecx
shrq %cl, %rax
jmp 0xdb16
addl $-0x5, %edx
cmpl $0x2, %edx
pushq $0x53
popq %rcx
pushq $0x5a
popq %rax
cmovbl %ecx, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10(%rsp), %r15
pushq $0x8
popq %rbp
leaq 0x190(%rsp), %r13
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x5430
movq %r15, %rdi
leaq 0xf(%rsp), %rsi
callq 0x5360
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rax,%rcx), %r12d
testb $0x5, %r12b
je 0xdcd6
movq %r13, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x53f0
movq %r13, %rdi
movq %r14, %rsi
callq 0x5060
movq %r13, %rdi
callq 0x5080
jmp 0xdcfa
movq %r13, %rdi
movq %r14, %rsi
pushq $0x1
popq %rdx
pushq $-0x1
popq %rcx
callq 0x52f0
movq %r14, %rdi
movq %r13, %rsi
callq 0x5330
movq %r13, %rdi
callq 0x5140
movq %r15, %rdi
callq 0x5150
testb $0x5, %r12b
jne 0xdc88
movb 0xf(%rsp), %al
addq $0x398, %rsp            # imm = 0x398
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xdd34
jmp 0xdd34
movq %rax, %rbx
leaq 0x190(%rsp), %rdi
callq 0x5080
jmp 0xdd37
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5150
movq %rbx, %rdi
callq 0x5450
nop
// File: /workspace/github_cpp_makefile_star2_O2/EstherJin[P]TetrisRemake/o.cc
// Function: O::O()
O::O(): Block1{0, 'O'} {
  coords.emplace_back(Coordinates {2,0});
  coords.emplace_back(Coordinates {2,1});
  coords.emplace_back(Coordinates {3,0});
  coords.emplace_back(Coordinates {3,1});
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x4f
popq %rdx
xorl %esi, %esi
callq 0x81a4
leaq 0xbdbc(%rip), %rax      # 0x19b60
movq %rax, (%rbx)
leaq 0x30(%rbx), %r14
movq %rsp, %rsi
movq $0x2, (%rsi)
movq %r14, %rdi
callq 0x89d8
movabsq $0x100000002, %rax      # imm = 0x100000002
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x89d8
movq %rsp, %rsi
movq $0x3, (%rsi)
movq %r14, %rdi
callq 0x89d8
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x89d8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xde0d
jmp 0xde0d
jmp 0xde0d
movq %rax, %r14
movq %rbx, %rdi
callq 0x81ca
movq %r14, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O2/EstherJin[P]TetrisRemake/row.cc
// Function: Row::Row(int, Observer*, Observer*)
Row::Row(int rowNum,  Observer *ob, Observer *ob2): rowNum{rowNum}{
  for(int i = 0; i < 11; ++i){
    Cell c = {' ', rowNum, i};
    c.attach(ob);
	  c.attach(ob2);
    roww.emplace_back(c);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movl %esi, 0x18(%rdi)
xorl %r12d, %r12d
movq %rsp, %r13
cmpl $0xb, %r12d
je 0xdee5
movq %r13, %rdi
pushq $0x20
popq %rsi
movl %ebp, %edx
movl %r12d, %ecx
callq 0x8688
movq %r13, %rdi
movq %r15, %rsi
callq 0xf284
movq %r13, %rdi
movq %r14, %rsi
callq 0xf284
movq %rbx, %rdi
movq %r13, %rsi
callq 0xe006
movq %r13, %rdi
callq 0x75ca
incl %r12d
jmp 0xdea1
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xdf04
movq %rax, %r14
movq %rsp, %rdi
callq 0x75ca
movq %rbx, %rdi
callq 0x755c
movq %r14, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O2/EstherJin[P]TetrisRemake/row.cc
// Function: Row::checkFull()
bool Row::checkFull(){
  for(int i = 0; i < 11; ++i){
    if (roww.at(i).getChar() == ' '){
      return false;
    }
  }
  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ecx, %ecx
movq %rcx, %r14
cmpq $0xb, %rcx
je 0xdf41
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe042
movq %rax, %rdi
callq 0x8744
leaq 0x1(%r14), %rcx
cmpb $0x20, %al
jne 0xdf1d
cmpq $0xb, %r14
setae %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/EstherJin[P]TetrisRemake/s.cc
// Function: S::S()
S::S(): Block1{0, 'S'} {
  coords.emplace_back(Coordinates {2,1});
  coords.emplace_back(Coordinates {2,2});
  coords.emplace_back(Coordinates {3,0});
  coords.emplace_back(Coordinates {3,1});
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x53
popq %rdx
xorl %esi, %esi
callq 0x81a4
leaq 0xb964(%rip), %rax      # 0x19be8
movq %rax, (%rbx)
leaq 0x30(%rbx), %r14
movabsq $0x100000002, %rax      # imm = 0x100000002
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x89d8
movabsq $0x200000002, %rax      # imm = 0x200000002
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x89d8
movq %rsp, %rsi
movq $0x3, (%rsi)
movq %r14, %rdi
callq 0x89d8
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x89d8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xe2f3
jmp 0xe2f3
jmp 0xe2f3
movq %rax, %r14
movq %rbx, %rdi
callq 0x81ca
movq %r14, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O2/EstherJin[P]TetrisRemake/s.cc
// Function: S::turnPos(int)
vector<Coordinates> S::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).col -= 2;
      cds.at(2).row -= 2;
    } else {
      cds.at(1).col += 2;
      cds.at(2).row += 2;
    }
  }
  return cds;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x30, %rsi
callq 0x8588
testb $0x1, %bpl
je 0xe48d
cmpl $0x0, 0x48(%r14)
je 0xe46e
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x71fe
addl $0x2, 0x4(%rax)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x71fe
pushq $0x2
jmp 0xe48a
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x71fe
addl $-0x2, 0x4(%rax)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x71fe
pushq $-0x2
popq %rcx
addl %ecx, (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7c3a
movq %r14, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O2/EstherJin[P]TetrisRemake/stringGenerator.cc
// Function: StringGenerator::StringGenerator()
StringGenerator::StringGenerator() {
	vector<vector<char>> newGrid;

	for (int i = 0; i < gridRows; ++i) {
		vector<char> row;
		newGrid.emplace_back(row);
		for (int j = 0; j < gridCols; ++j) {
			newGrid[i].emplace_back(' ');
		}
	}

	grid = newGrid;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0xb770(%rip), %rax      # 0x19c48
movq %rax, (%rdi)
leaq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
andq $0x0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
movabsq $0xb00000012, %rax      # imm = 0xB00000012
movq %rax, 0x20(%rdi)
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
pushq $0x12
popq %rax
xorl %ebp, %ebp
leaq 0x30(%rsp), %r12
leaq 0x7(%rsp), %r13
cltq
cmpq %rax, %rbp
jge 0xe572
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0xe8e2
xorl %ebx, %ebx
imulq $0x18, %rbp, %r15
cmpl 0x24(%r14), %ebx
jge 0xe561
movq 0x10(%rsp), %rdi
addq %r15, %rdi
movb $0x20, 0x7(%rsp)
movq %r13, %rsi
callq 0xe91e
incl %ebx
jmp 0xe542
movq %r12, %rdi
callq 0x76bc
incq %rbp
movl 0x20(%r14), %eax
jmp 0xe51a
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xe952
leaq 0x10(%rsp), %rdi
callq 0x764e
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xe5b6
jmp 0xe5a4
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x76bc
movq 0x8(%rsp), %rbx
leaq 0x10(%rsp), %rdi
callq 0x764e
movq %rbx, %rdi
callq 0x764e
movq %r14, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O2/EstherJin[P]TetrisRemake/stringGenerator.cc
// Function: StringGenerator::notify(Subject&)
void StringGenerator::notify(Subject &whoNotified) { // update the display for one cell
	State st = whoNotified.getState();
	if (st.add) {
		grid[st.coords.row][st.coords.col] = st.type;
	}
	else {
		grid[st.coords.row][st.coords.col] = ' ';
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xf2d2
btq $0x20, %rdx
pushq $0x20
popq %rcx
cmovbl %eax, %ecx
sarq $0x20, %rax
movq 0x8(%rbx), %rsi
imulq $0x18, %rax, %rax
movslq %edx, %rdx
movq (%rsi,%rax), %rax
movb %cl, (%rax,%rdx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/EstherJin[P]TetrisRemake/t.cc
// Function: T::T()
T::T(): Block1{0, 'T'} {
  coords.emplace_back(Coordinates {2,0});
  coords.emplace_back(Coordinates {2,1});
  coords.emplace_back(Coordinates {2,2});
  coords.emplace_back(Coordinates {3,1});
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x54
popq %rdx
xorl %esi, %esi
callq 0x81a4
leaq 0xa854(%rip), %rax      # 0x19c88
movq %rax, (%rbx)
leaq 0x30(%rbx), %r14
movq %rsp, %rsi
movq $0x2, (%rsi)
movq %r14, %rdi
callq 0x89d8
movabsq $0x100000002, %rax      # imm = 0x100000002
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x89d8
movabsq $0x200000002, %rax      # imm = 0x200000002
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x89d8
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x89d8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xf4a3
jmp 0xf4a3
jmp 0xf4a3
movq %rax, %r14
movq %rbx, %rdi
callq 0x81ca
movq %r14, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O2/EstherJin[P]TetrisRemake/t.cc
// Function: T::turnPos(int)
vector<Coordinates> T::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 -= 1;
      cds.at(2).col -= 1;
    } else if (pos == 1) {
      cds.at(0).row += 1;
      cds.at(2).row += 2;
      cds.at(2).col += 1;
    } else if (pos == 2) {
      cds.at(0).row -= 1;
      cds.at(2).row -= 2;
      cds.at(2).col -= 2;
      cds.at(3).col -= 1;
    } else {
      cds.at(2).row += 1;
      cds.at(2).col += 2;
      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, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x30, %rsi
callq 0x8588
andl $0x3, %ebp
movl 0x48(%r14), %r15d
pushq $0x2
popq %r14
pushq $-0x1
popq %r13
pushq $0x4
popq %r12
testl %ebp, %ebp
jle 0xfb95
cmpl $0x2, %r15d
je 0xfb13
cmpl $0x1, %r15d
je 0xfaf7
testl %r15d, %r15d
jne 0xfb51
movq %rbx, %rdi
movq %r14, %rsi
callq 0x71fe
movl %r13d, %ecx
movq %r14, %rsi
jmp 0xfb42
movq %rbx, %rdi
xorl %esi, %esi
callq 0x71fe
incl (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x71fe
movq %r14, %rsi
jmp 0xfb70
movq %rbx, %rdi
xorl %esi, %esi
callq 0x71fe
decl (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x71fe
addl $-0x2, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x71fe
addq $0x4, %rax
pushq $-0x2
popq %rcx
pushq $0x3
popq %rsi
addl %ecx, (%rax)
movq %rbx, %rdi
callq 0x71fe
movl %r13d, %ecx
jmp 0xfb7e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x71fe
incl (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x71fe
addq $0x4, %rax
pushq $0x3
popq %rsi
addl $0x2, (%rax)
movq %rbx, %rdi
callq 0x71fe
pushq $0x1
popq %rcx
addl %ecx, 0x4(%rax)
incl %r15d
movl %r15d, %eax
cltd
idivl %r12d
decl %ebp
movl %edx, %r15d
jmp 0xfacb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7c3a
movq %r14, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O2/EstherJin[P]TetrisRemake/textDisplay.cc
// Function: TextDisplay::print(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void TextDisplay::print (ostream &out, string str1, string str2) {
    istringstream ss1 {str1};
    istringstream ss2 {str2};

    string board1;
    string board2;

    while (getline(ss1, board1) && getline(ss2, board2)) {
        out << board1;
        out << "          ";
        out << board2;
        out << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x348, %rsp            # imm = 0x348
movq %rcx, %r14
movq %rsi, %rbx
leaq 0x1c8(%rsp), %rdi
pushq $0x8
popq %rbp
movq %rdx, %rsi
movl %ebp, %edx
callq 0x5430
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x5430
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
xorl %edx, %edx
movb %dl, (%rax)
movb %dl, (%rcx)
leaq 0x1c8(%rsp), %r14
leaq 0x28(%rsp), %r15
leaq 0x48(%rsp), %r12
leaq 0x8(%rsp), %r13
leaq 0x1cb8(%rip), %rbp      # 0x11903
movq %r14, %rdi
movq %r15, %rsi
callq 0x5060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xfca8
movq %r12, %rdi
movq %r13, %rsi
callq 0x5060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xfca8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5290
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x52b0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5290
movq %rbx, %rdi
callq 0x5160
jmp 0xfc4b
leaq 0x8(%rsp), %rdi
callq 0x5140
leaq 0x28(%rsp), %rdi
callq 0x5140
leaq 0x48(%rsp), %rdi
callq 0x5150
leaq 0x1c8(%rsp), %rdi
callq 0x5150
addq $0x348, %rsp            # imm = 0x348
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xfd0b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5140
leaq 0x28(%rsp), %rdi
callq 0x5140
leaq 0x48(%rsp), %rdi
callq 0x5150
leaq 0x1c8(%rsp), %rdi
callq 0x5150
movq %rbx, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O2/EstherJin[P]TetrisRemake/z.cc
// Function: Z::Z()
Z::Z(): Block1{0, 'Z'} {
  coords.emplace_back(Coordinates {2,0});
  coords.emplace_back(Coordinates {2,1});
  coords.emplace_back(Coordinates {3,1});
  coords.emplace_back(Coordinates {3,2});
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x5a
popq %rdx
xorl %esi, %esi
callq 0x81a4
leaq 0x9fb0(%rip), %rax      # 0x19ce8
movq %rax, (%rbx)
leaq 0x30(%rbx), %r14
movq %rsp, %rsi
movq $0x2, (%rsi)
movq %r14, %rdi
callq 0x89d8
movabsq $0x100000002, %rax      # imm = 0x100000002
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x89d8
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x89d8
movabsq $0x200000003, %rax      # imm = 0x200000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x89d8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xfda7
jmp 0xfda7
jmp 0xfda7
movq %rax, %r14
movq %rbx, %rdi
callq 0x81ca
movq %r14, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O2/EstherJin[P]TetrisRemake/z.cc
// Function: Z::turnPos(int)
vector<Coordinates> Z::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(2).row -= 2;
      cds.at(3).col -= 2;
    } else {
      cds.at(2).row += 2;
      cds.at(3).col += 2;
    }
  }
  return cds;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x30, %rsi
callq 0x8588
testb $0x1, %bpl
je 0xff40
cmpl $0x0, 0x48(%r14)
je 0xff21
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x71fe
addl $0x2, (%rax)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x71fe
pushq $0x2
jmp 0xff3c
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x71fe
addl $-0x2, (%rax)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x71fe
pushq $-0x2
popq %rcx
addl %ecx, 0x4(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7c3a
movq %r14, %rdi
callq 0x5450
nop
// File: /workspace/github_cpp_makefile_star2_O2/EstherJin[P]TetrisRemake/graphicsDisplay.cc
// Function: GraphicsDisplay::GraphicsDisplay()
GraphicsDisplay::GraphicsDisplay ()  {

    window = make_unique<Xwindow> ();

    window->fillRectangle(0,0,405,780,0);
    window->fillRectangle(0,50,405,642,9);
    window->fillRectangle(15,65,375,612,0);
    for (int i = 1; i < row; i++) {
        window->fillRectangle(xmar,ymar+i*34,375,1,10);
    }
    for (int j = 1; j < col; j++) {
        window->fillRectangle(xmar+j*34,ymar,1,612,10);
    }
    // window->fillRectangle(0, 0, 100, 100, 4);

    string nt = "Next:";
    window->drawString (15, 700, nt);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x9dbc(%rip), %rax      # 0x19d48
movq %rax, (%rdi)
movaps 0x18ba(%rip), %xmm0     # 0x11850
movups %xmm0, 0x8(%rdi)
movl $0x41, 0x18(%rdi)
leaq 0x20(%rdi), %rbx
andq $0x0, 0x20(%rdi)
leaq 0x8(%rsp), %rdi
callq 0x1067e
leaq 0x8(%rsp), %r15
movq (%r15), %rsi
andq $0x0, (%r15)
movq %rbx, %rdi
callq 0x106e4
movq %r15, %rdi
callq 0x7614
movq (%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x195, %ecx            # imm = 0x195
movl $0x30c, %r8d            # imm = 0x30C
xorl %r9d, %r9d
callq 0x108f0
movq (%rbx), %rdi
pushq $0x32
popq %rdx
pushq $0x9
popq %r9
xorl %esi, %esi
movl $0x195, %ecx            # imm = 0x195
movl $0x282, %r8d            # imm = 0x282
callq 0x108f0
movq (%rbx), %rdi
pushq $0xf
popq %rsi
pushq $0x41
popq %rdx
movl $0x177, %ecx            # imm = 0x177
movl $0x264, %r8d            # imm = 0x264
xorl %r9d, %r9d
callq 0x108f0
pushq $0x1
popq %rbp
pushq $0x22
popq %r12
pushq $0xa
popq %r15
movl %ebp, %r13d
cmpl 0xc(%r14), %r13d
jge 0x1005e
movq 0x20(%r14), %rdi
movl 0x14(%r14), %esi
movl 0x18(%r14), %edx
addl %r12d, %edx
movl $0x177, %ecx            # imm = 0x177
movl %ebp, %r8d
movl %r15d, %r9d
callq 0x108f0
incl %r13d
addl $0x22, %r12d
jmp 0x10030
pushq $0x1
popq %rbp
pushq $0x22
popq %r12
pushq $0xa
popq %r15
movl %ebp, %r13d
cmpl 0x10(%r14), %r13d
jge 0x1009a
movq 0x20(%r14), %rdi
movl 0x14(%r14), %esi
addl %r12d, %esi
movl 0x18(%r14), %edx
movl %ebp, %ecx
movl $0x264, %r8d            # imm = 0x264
movl %r15d, %r9d
callq 0x108f0
incl %r13d
addl $0x22, %r12d
jmp 0x1006c
leaq 0x1831(%rip), %rsi      # 0x118d2
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5d02
movq (%rbx), %r14
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5380
pushq $0xf
popq %rsi
leaq 0x28(%rsp), %rcx
movq %r14, %rdi
movl $0x2bc, %edx            # imm = 0x2BC
callq 0x10954
leaq 0x28(%rsp), %rdi
callq 0x5140
leaq 0x8(%rsp), %rdi
callq 0x5140
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5140
jmp 0x1010c
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5140
jmp 0x10123
jmp 0x10120
jmp 0x10120
jmp 0x10120
jmp 0x10120
movq %rax, %r14
movq %rbx, %rdi
callq 0x7614
movq %r14, %rdi
callq 0x5450
nop
// File: /workspace/github_cpp_makefile_star2_O2/EstherJin[P]TetrisRemake/graphicsDisplay.cc
// Function: GraphicsDisplay::printLevel(int)
void GraphicsDisplay::printLevel(int level) {
    window->fillRectangle(0,0,405,15,0);
    string lvl = "Level:                    ";
    lvl += to_string(level);
    window->drawString(50, xmar, lvl);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
pushq $0xf
popq %r8
xorl %esi, %esi
xorl %edx, %edx
movl $0x195, %ecx            # imm = 0x195
xorl %r9d, %r9d
callq 0x108f0
leaq 0x1675(%rip), %rsi      # 0x118d8
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x5d02
movq %rsp, %rdi
movl %ebp, %esi
callq 0xea73
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x54c0
movq %rsp, %rdi
callq 0x5140
movq 0x20(%rbx), %r14
movl 0x14(%rbx), %ebx
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x5380
pushq $0x32
popq %rsi
leaq 0x40(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %edx
callq 0x10954
leaq 0x40(%rsp), %rdi
callq 0x5140
leaq 0x20(%rsp), %rdi
callq 0x5140
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
jmp 0x102e6
jmp 0x102ed
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5140
jmp 0x102f0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5140
movq %rbx, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O2/EstherJin[P]TetrisRemake/graphicsDisplay.cc
// Function: GraphicsDisplay::printScore(int)
void GraphicsDisplay::printScore(int score) {
    window->fillRectangle(0,17,405,15,0);
    string sc = "Score:                    ";
    sc += to_string(score);
    window->drawString(50, 30, sc);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
pushq $0x11
popq %rdx
pushq $0xf
popq %r8
xorl %esi, %esi
movl $0x195, %ecx            # imm = 0x195
xorl %r9d, %r9d
callq 0x108f0
leaq 0x15c5(%rip), %rsi      # 0x118f3
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x5d02
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0xea73
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x54c0
leaq 0x8(%rsp), %rdi
callq 0x5140
movq 0x20(%rbx), %rbx
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x5380
pushq $0x32
popq %rsi
pushq $0x1e
popq %rdx
leaq 0x48(%rsp), %rcx
movq %rbx, %rdi
callq 0x10954
leaq 0x48(%rsp), %rdi
callq 0x5140
leaq 0x28(%rsp), %rdi
callq 0x5140
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x103b7
jmp 0x103be
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5140
jmp 0x103c1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5140
movq %rbx, %rdi
callq 0x5450
nop