LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x1, -0x1c(%rbp)
movq %rax, %rdx
addq $0x8, %rdx
movq %rax, %rcx
addq $0x8, %rcx
movq %rax, %r8
addq $0xc, %r8
movq %rax, %r9
addq $0x10, %r9
addq $0x50, %rax
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
movq %rax, (%rsp)
callq 0x165c0
movq -0x60(%rbp), %rdi
addq $0x58, %rdi
leaq -0x18(%rbp), %rsi
callq 0x16660
leaq -0x18(%rbp), %rdi
callq 0x16690
movq -0x60(%rbp), %rax
movl $0x2, -0x34(%rbp)
movq %rax, %rdx
addq $0x8, %rdx
movq %rax, %rcx
addq $0x8, %rcx
movq %rax, %r8
addq $0xc, %r8
movq %rax, %r9
addq $0x30, %r9
addq $0x50, %rax
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
movq %rax, (%rsp)
callq 0x165c0
movq -0x60(%rbp), %rdi
addq $0x68, %rdi
leaq -0x30(%rbp), %rsi
callq 0x16660
leaq -0x30(%rbp), %rdi
callq 0x16690
movq -0x60(%rbp), %rax
cmpl $0x3, 0x8(%rax)
jl 0x153cc
movq -0x60(%rbp), %rsi
addq $0x58, %rsi
leaq -0x48(%rbp), %rdi
callq 0x166b0
movq -0x60(%rbp), %rdi
addq $0x58, %rdi
leaq -0x48(%rbp), %rsi
callq 0x16720
leaq -0x48(%rbp), %rdi
callq 0x16750
movq -0x60(%rbp), %rsi
addq $0x68, %rsi
leaq -0x58(%rbp), %rdi
callq 0x166b0
movq -0x60(%rbp), %rdi
addq $0x68, %rdi
leaq -0x58(%rbp), %rsi
callq 0x16720
leaq -0x58(%rbp), %rdi
callq 0x16750
movq -0x60(%rbp), %rdi
addq $0x58, %rdi
callq 0x12de0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x48(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x58, %rdi
callq 0x12de0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq -0x18(%rbp), %rdi
movl %eax, -0xc(%rbp)
addq $0x68, %rdi
callq 0x12de0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %ecx
movl -0xc(%rbp), %eax
cmpl %ecx, %eax
jle 0x155bf
movq 0x2ca21(%rip), %rdi     # 0x41fc0
leaq 0x17bb2(%rip), %rsi     # 0x2d158
callq 0x6360
movq %rax, %rdi
movq 0x2c9eb(%rip), %rsi     # 0x41fa0
callq 0x63c0
jmp 0x1563f
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
callq 0x12de0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq -0x18(%rbp), %rdi
movl %eax, -0x1c(%rbp)
addq $0x58, %rdi
callq 0x12de0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jle 0x1561b
movq 0x2c9c2(%rip), %rdi     # 0x41fc0
leaq 0x17b6c(%rip), %rsi     # 0x2d171
callq 0x6360
movq %rax, %rdi
movq 0x2c98c(%rip), %rsi     # 0x41fa0
callq 0x63c0
jmp 0x1563d
movq 0x2c99e(%rip), %rdi     # 0x41fc0
leaq 0x17b61(%rip), %rsi     # 0x2d18a
callq 0x6360
movq %rax, %rdi
movq 0x2c968(%rip), %rsi     # 0x41fa0
callq 0x63c0
jmp 0x1563f
movl $0x8, %edi
callq 0x61a0
movq %rax, %rdi
leaq 0x17b52(%rip), %rax     # 0x2d1a5
movq %rax, (%rdi)
movq 0x2c94b(%rip), %rsi     # 0x41fa8
xorl %eax, %eax
movl %eax, %edx
callq 0x65b0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpl $0x1, -0x20(%rbp)
jne 0x16507
movq -0x60(%rbp), %rdi
addq $0x58, %rdi
callq 0x12f70
movq %rax, -0x28(%rbp)
jmp 0x16520
cmpl $0x2, -0x20(%rbp)
jne 0x1651e
movq -0x60(%rbp), %rdi
addq $0x68, %rdi
callq 0x12f70
movq %rax, -0x28(%rbp)
jmp 0x16520
movq -0x70(%rbp), %rdi
leaq 0x16d04(%rip), %rsi     # 0x2d22f
callq 0x7460
testb $0x1, %al
jne 0x16536
jmp 0x16588
movq -0x68(%rbp), %rsi
movq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x6150
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rcx
movq (%rdi), %rax
movq 0x38(%rax), %rax
xorl %edx, %edx
movl %edx, %esi
callq *%rax
jmp 0x16566
leaq -0x48(%rbp), %rdi
callq 0x6230
jmp 0x16588
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6230
jmp 0x16591
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x65c0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
cmpl %ecx, %eax
jge 0x198fc
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x12de0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x78(%rax)
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x198b1
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x12de0
movq %rax, %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x28(%rax)
jmp 0x198ec
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x12de0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movl %eax, -0x18(%rbp)
movl $0x4, %edi
callq 0x61a0
movq %rax, %rdi
movl -0x18(%rbp), %eax
movl %eax, (%rdi)
movq 0x286ad(%rip), %rsi     # 0x41f90
xorl %eax, %eax
movl %eax, %edx
callq 0x65b0
jmp 0x198ee
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1985e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x49, %edx
callq 0x12f90
movq -0x40(%rbp), %rdi
leaq 0x27f1d(%rip), %rax     # 0x418a8
movq %rax, (%rdi)
addq $0x30, %rdi
movl $0x3, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x14880
jmp 0x199ab
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x3, -0x24(%rbp)
movl $0x1, -0x20(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x14880
jmp 0x199cc
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x3, -0x2c(%rbp)
movl $0x2, -0x28(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x14880
jmp 0x199ed
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x3, -0x34(%rbp)
movl $0x3, -0x30(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x14880
jmp 0x19a0e
addq $0x40, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x12ff0
movq -0x18(%rbp), %rdi
callq 0x65c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x4a, %edx
callq 0x12f90
movq -0x40(%rbp), %rdi
leaq 0x20a6d(%rip), %rax     # 0x41908
movq %rax, (%rdi)
addq $0x30, %rdi
movl $0x2, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x14880
jmp 0x20ebb
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x3, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x14880
jmp 0x20edc
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x3, -0x2c(%rbp)
movl $0x1, -0x28(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x14880
jmp 0x20efd
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x3, -0x34(%rbp)
movl $0x2, -0x30(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x14880
jmp 0x20f1e
addq $0x40, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x12ff0
movq -0x18(%rbp), %rdi
callq 0x65c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x4c, %edx
callq 0x12f90
movq -0x40(%rbp), %rdi
leaq 0x1f68d(%rip), %rax     # 0x41968
movq %rax, (%rdi)
addq $0x30, %rdi
movl $0x2, -0x10(%rbp)
movl $0x2, -0xc(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x14880
jmp 0x222fb
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x3, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x14880
jmp 0x2231c
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x3, -0x2c(%rbp)
movl $0x1, -0x28(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x14880
jmp 0x2233d
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x3, -0x34(%rbp)
movl $0x2, -0x30(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x14880
jmp 0x2235e
addq $0x40, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x12ff0
movq -0x18(%rbp), %rdi
callq 0x65c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x6350
callq 0x60c0
movl $0xc, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, -0x10(%rbp)
cmpl $0x1, -0x10(%rbp)
jne 0x236c7
movb $0x53, -0x9(%rbp)
jmp 0x23737
cmpl $0x2, -0x10(%rbp)
jne 0x236d3
movb $0x5a, -0x9(%rbp)
jmp 0x23735
cmpl $0x3, -0x10(%rbp)
jl 0x236e5
cmpl $0x4, -0x10(%rbp)
jg 0x236e5
movb $0x49, -0x9(%rbp)
jmp 0x23733
cmpl $0x5, -0x10(%rbp)
jl 0x236f7
cmpl $0x6, -0x10(%rbp)
jg 0x236f7
movb $0x54, -0x9(%rbp)
jmp 0x23731
cmpl $0x7, -0x10(%rbp)
jl 0x23709
cmpl $0x8, -0x10(%rbp)
jg 0x23709
movb $0x4a, -0x9(%rbp)
jmp 0x2372f
cmpl $0x9, -0x10(%rbp)
jl 0x2371b
cmpl $0xa, -0x10(%rbp)
jg 0x2371b
movb $0x4c, -0x9(%rbp)
jmp 0x2372d
cmpl $0xb, -0x10(%rbp)
jl 0x2372b
cmpl $0xc, -0x10(%rbp)
jg 0x2372b
movb $0x4f, -0x9(%rbp)
jmp 0x2372d
jmp 0x2372f
jmp 0x23731
jmp 0x23733
jmp 0x23735
jmp 0x23737
movb -0x9(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
// File: EstherJin[P]TetrisRemake/Level2.cc
// Function: Level2::nextBlock()
char Level2::nextBlock() {
    char next;

    srand (seed);

    int number = rand() % 7 + 1;

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

    return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x6350
callq 0x60c0
movl $0x7, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, -0x10(%rbp)
cmpl $0x1, -0x10(%rbp)
jne 0x23827
movb $0x53, -0x9(%rbp)
jmp 0x23879
cmpl $0x2, -0x10(%rbp)
jne 0x23833
movb $0x5a, -0x9(%rbp)
jmp 0x23877
cmpl $0x3, -0x10(%rbp)
jne 0x2383f
movb $0x49, -0x9(%rbp)
jmp 0x23875
cmpl $0x4, -0x10(%rbp)
jne 0x2384b
movb $0x54, -0x9(%rbp)
jmp 0x23873
cmpl $0x5, -0x10(%rbp)
jne 0x23857
movb $0x4a, -0x9(%rbp)
jmp 0x23871
cmpl $0x6, -0x10(%rbp)
jne 0x23863
movb $0x4c, -0x9(%rbp)
jmp 0x2386f
cmpl $0x7, -0x10(%rbp)
jne 0x2386d
movb $0x4f, -0x9(%rbp)
jmp 0x2386f
jmp 0x23871
jmp 0x23873
jmp 0x23875
jmp 0x23877
jmp 0x23879
movb -0x9(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x6350
callq 0x60c0
movl $0x9, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, -0x10(%rbp)
cmpl $0x1, -0x10(%rbp)
jne 0x23957
movb $0x49, -0x9(%rbp)
jmp 0x239b5
cmpl $0x2, -0x10(%rbp)
jne 0x23963
movb $0x54, -0x9(%rbp)
jmp 0x239b3
cmpl $0x3, -0x10(%rbp)
jne 0x2396f
movb $0x4a, -0x9(%rbp)
jmp 0x239b1
cmpl $0x4, -0x10(%rbp)
jne 0x2397b
movb $0x4c, -0x9(%rbp)
jmp 0x239af
cmpl $0x5, -0x10(%rbp)
jne 0x23987
movb $0x4f, -0x9(%rbp)
jmp 0x239ad
cmpl $0x6, -0x10(%rbp)
jl 0x23999
cmpl $0x7, -0x10(%rbp)
jg 0x23999
movb $0x53, -0x9(%rbp)
jmp 0x239ab
cmpl $0x8, -0x10(%rbp)
jl 0x239a9
cmpl $0x9, -0x10(%rbp)
jg 0x239a9
movb $0x5a, -0x9(%rbp)
jmp 0x239ab
jmp 0x239ad
jmp 0x239af
jmp 0x239b1
jmp 0x239b3
jmp 0x239b5
movb -0x9(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x3f0, %rsp            # imm = 0x3F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x3d8(%rbp)
movq -0x3d8(%rbp), %rsi
addq $0x30, %rsi
leaq -0x190(%rbp), %rdi
movq %rdi, -0x3e8(%rbp)
movl $0x8, %edx
callq 0x65a0
movq -0x3e8(%rbp), %rdi
leaq -0x9(%rbp), %rsi
callq 0x6490
movq %rax, -0x3e0(%rbp)
jmp 0x23cb6
movq -0x3e0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6450
movb %al, -0x3e9(%rbp)
jmp 0x23cd4
movb -0x3e9(%rbp), %al
testb $0x1, %al
jne 0x23ce0
jmp 0x23d4e
movq -0x3d8(%rbp), %rsi
addq $0x30, %rsi
leaq -0x1c0(%rbp), %rdi
movl $0x1, %edx
movq $-0x1, %rcx
callq 0x63a0
jmp 0x23d05
movq -0x3d8(%rbp), %rdi
addq $0x30, %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x6430
leaq -0x1c0(%rbp), %rdi
callq 0x6230
movl $0x3, -0x1c4(%rbp)
jmp 0x23dbd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x23ddc
movq -0x3d8(%rbp), %rsi
addq $0x10, %rsi
leaq -0x3d0(%rbp), %rdi
movl $0x8, %edx
callq 0x6560
jmp 0x23d6c
movq -0x3d8(%rbp), %rsi
addq $0x30, %rsi
leaq -0x3d0(%rbp), %rdi
callq 0x6080
jmp 0x23d85
leaq -0x3d0(%rbp), %rdi
callq 0x60a0
jmp 0x23db3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x3d0(%rbp), %rdi
callq 0x60a0
jmp 0x23ddc
movl $0x0, -0x1c4(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x6190
movl -0x1c4(%rbp), %eax
testl %eax, %eax
je 0x23dd7
jmp 0x23dd5
jmp 0x23dea
jmp 0x23c7a
leaq -0x190(%rbp), %rdi
callq 0x6190
jmp 0x23df6
movb -0x9(%rbp), %al
addq $0x3f0, %rsp            # imm = 0x3F0
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0x65c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x4f, %edx
callq 0x12f90
movq -0x40(%rbp), %rdi
leaq 0x1dc9d(%rip), %rax     # 0x41b58
movq %rax, (%rdi)
addq $0x30, %rdi
movl $0x2, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x14880
jmp 0x23edb
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x2, -0x24(%rbp)
movl $0x1, -0x20(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x14880
jmp 0x23efc
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x3, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x14880
jmp 0x23f1d
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x3, -0x34(%rbp)
movl $0x1, -0x30(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x14880
jmp 0x23f3e
addq $0x40, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x12ff0
movq -0x18(%rbp), %rdi
callq 0x65c0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x24320
movq -0x78(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x18(%rax)
movl $0x0, -0x24(%rbp)
cmpl $0xb, -0x24(%rbp)
jge 0x2411a
movl -0xc(%rbp), %edx
movl -0x24(%rbp), %ecx
leaq -0x60(%rbp), %rdi
movl $0x20, %esi
callq 0x14010
jmp 0x240b4
movq -0x18(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x29070
jmp 0x240c3
movq -0x20(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x29070
jmp 0x240d2
movq -0x78(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24340
jmp 0x240e1
leaq -0x60(%rbp), %rdi
callq 0xbcc0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x24098
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x24123
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xbcc0
jmp 0x24123
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0xbb40
movq -0x68(%rbp), %rdi
callq 0x65c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xb, -0x14(%rbp)
jge 0x24191
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x243c0
movq %rax, %rdi
callq 0x141d0
movsbl %al, %eax
cmpl $0x20, %eax
jne 0x24184
movb $0x0, -0x1(%rbp)
jmp 0x24195
jmp 0x24186
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2415b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x53, %edx
callq 0x12f90
movq -0x40(%rbp), %rdi
leaq 0x1cd25(%rip), %rax     # 0x41be0
movq %rax, (%rdi)
addq $0x30, %rdi
movl $0x2, -0x10(%rbp)
movl $0x1, -0xc(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x14880
jmp 0x24edb
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x2, -0x24(%rbp)
movl $0x2, -0x20(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x14880
jmp 0x24efc
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x3, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x14880
jmp 0x24f1d
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x3, -0x34(%rbp)
movl $0x1, -0x30(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x14880
jmp 0x24f3e
addq $0x40, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x12ff0
movq -0x18(%rbp), %rdi
callq 0x65c0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x254ac
movl -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
jmp 0x254c4
imull $0xfffffffc, -0x14(%rbp), %eax # imm = 0xFFFFFFFC
imull $-0x1, -0x14(%rbp), %ecx
subl %ecx, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
movb $0x0, -0x15(%rbp)
addq $0x30, %rsi
callq 0x13660
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x25592
movq -0x30(%rbp), %rax
cmpl $0x0, 0x48(%rax)
jne 0x25550
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0xa800
movq %rax, -0x48(%rbp)
jmp 0x2550b
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x2, %ecx
movl %ecx, 0x4(%rax)
movl $0x2, %esi
callq 0xa800
movq %rax, -0x50(%rbp)
jmp 0x2552c
movq -0x50(%rbp), %rax
movl (%rax), %ecx
subl $0x2, %ecx
movl %ecx, (%rax)
jmp 0x25590
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xa880
jmp 0x255af
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0xa800
movq %rax, -0x58(%rbp)
jmp 0x25564
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0x4(%rax)
movl $0x2, %esi
callq 0xa800
movq %rax, -0x60(%rbp)
jmp 0x25585
movq -0x60(%rbp), %rax
movl (%rax), %ecx
addl $0x2, %ecx
movl %ecx, (%rax)
jmp 0x25592
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x255a5
movq -0x40(%rbp), %rdi
callq 0xa880
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x65c0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x13fb0
movq -0x60(%rbp), %rdi
leaq 0x1c5fc(%rip), %rax     # 0x41c30
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x68(%rbp)
callq 0x25dd0
movq -0x60(%rbp), %rax
movl $0x12, 0x20(%rax)
movl $0xb, 0x24(%rax)
leaq -0x20(%rbp), %rdi
callq 0x25dd0
movl $0x0, -0x24(%rbp)
movq -0x60(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x20(%rcx), %eax
jge 0x25703
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x25df0
movq -0x70(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x25e10
jmp 0x25696
movl $0x0, -0x50(%rbp)
movq -0x60(%rbp), %rcx
movl -0x50(%rbp), %eax
cmpl 0x24(%rcx), %eax
jge 0x256ec
movslq -0x24(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x25e90
movq %rax, %rdi
movb $0x20, -0x51(%rbp)
leaq -0x51(%rbp), %rsi
callq 0x25eb0
jmp 0x256c8
jmp 0x256ca
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x2569d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc340
jmp 0x25731
leaq -0x40(%rbp), %rdi
callq 0xc340
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2566a
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
leaq -0x20(%rbp), %rsi
callq 0x25f30
jmp 0x25716
leaq -0x20(%rbp), %rdi
callq 0xc1c0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc1c0
movq -0x68(%rbp), %rdi
callq 0xc1c0
movq -0x60(%rbp), %rdi
callq 0xff30
movq -0x48(%rbp), %rdi
callq 0x65c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x29170
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
testb $0x1, -0x14(%rbp)
je 0x257b9
movq -0x28(%rbp), %rdi
movb -0x20(%rbp), %al
movb %al, -0x29(%rbp)
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x25e90
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0x26180
movb -0x29(%rbp), %cl
movb %cl, (%rax)
jmp 0x257d9
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x25e90
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0x26180
movb $0x20, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x54, %edx
callq 0x12f90
movq -0x40(%rbp), %rdi
leaq 0x18355(%rip), %rax     # 0x41c80
movq %rax, (%rdi)
addq $0x30, %rdi
movl $0x2, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x14880
jmp 0x2994b
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x2, -0x24(%rbp)
movl $0x1, -0x20(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x14880
jmp 0x2996c
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x2, -0x2c(%rbp)
movl $0x2, -0x28(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x14880
jmp 0x2998d
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x3, -0x34(%rbp)
movl $0x1, -0x30(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x14880
jmp 0x299ae
addq $0x40, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x12ff0
movq -0x18(%rbp), %rdi
callq 0x65c0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x3b0, %rsp            # imm = 0x3B0
movq %rdx, -0x388(%rbp)
movq %rsi, %rax
movq -0x388(%rbp), %rsi
movq %rcx, -0x380(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x1a0(%rbp), %rdi
movl $0x8, %edx
movl %edx, -0x374(%rbp)
callq 0x65a0
movq -0x380(%rbp), %rsi
movl -0x374(%rbp), %edx
leaq -0x320(%rbp), %rdi
callq 0x65a0
jmp 0x2a7a5
leaq -0x350(%rbp), %rdi
callq 0x64c0
leaq -0x370(%rbp), %rdi
callq 0x64c0
leaq -0x1a0(%rbp), %rdi
leaq -0x350(%rbp), %rsi
callq 0x6080
movq %rax, -0x390(%rbp)
jmp 0x2a7d9
movq -0x390(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6450
movb %al, -0x391(%rbp)
jmp 0x2a7f7
movb -0x391(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x392(%rbp)
jne 0x2a80c
jmp 0x2a854
leaq -0x320(%rbp), %rdi
leaq -0x370(%rbp), %rsi
callq 0x6080
movq %rax, -0x3a0(%rbp)
jmp 0x2a828
movq -0x3a0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6450
movb %al, -0x3a1(%rbp)
jmp 0x2a846
movb -0x3a1(%rbp), %al
movb %al, -0x392(%rbp)
jmp 0x2a854
movb -0x392(%rbp), %al
testb $0x1, %al
jne 0x2a863
jmp 0x2a8fc
movq -0x10(%rbp), %rdi
leaq -0x350(%rbp), %rsi
callq 0x6330
jmp 0x2a875
movq -0x10(%rbp), %rdi
leaq 0x2fcb(%rip), %rsi      # 0x2d84b
callq 0x6360
jmp 0x2a887
movq -0x10(%rbp), %rdi
leaq -0x370(%rbp), %rsi
callq 0x6330
jmp 0x2a899
movq -0x10(%rbp), %rdi
movq 0x176fc(%rip), %rsi     # 0x41fa0
callq 0x63c0
jmp 0x2a8ab
jmp 0x2a7bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x328(%rbp)
movl %eax, -0x32c(%rbp)
jmp 0x2a935
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x328(%rbp)
movl %eax, -0x32c(%rbp)
leaq -0x370(%rbp), %rdi
callq 0x6230
leaq -0x350(%rbp), %rdi
callq 0x6230
leaq -0x320(%rbp), %rdi
callq 0x6190
jmp 0x2a935
leaq -0x370(%rbp), %rdi
callq 0x6230
leaq -0x350(%rbp), %rdi
callq 0x6230
leaq -0x320(%rbp), %rdi
callq 0x6190
leaq -0x1a0(%rbp), %rdi
callq 0x6190
addq $0x3b0, %rsp            # imm = 0x3B0
popq %rbp
retq
leaq -0x1a0(%rbp), %rdi
callq 0x6190
movq -0x328(%rbp), %rdi
callq 0x65c0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x5a, %edx
callq 0x12f90
movq -0x40(%rbp), %rdi
leaq 0x17365(%rip), %rax     # 0x41ce0
movq %rax, (%rdi)
addq $0x30, %rdi
movl $0x2, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x14880
jmp 0x2a99b
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x2, -0x24(%rbp)
movl $0x1, -0x20(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x14880
jmp 0x2a9bc
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x3, -0x2c(%rbp)
movl $0x1, -0x28(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x14880
jmp 0x2a9dd
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl $0x3, -0x34(%rbp)
movl $0x2, -0x30(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x14880
jmp 0x2a9fe
addq $0x40, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x12ff0
movq -0x18(%rbp), %rdi
callq 0x65c0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x2af6c
movl -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
jmp 0x2af84
imull $0xfffffffc, -0x14(%rbp), %eax # imm = 0xFFFFFFFC
imull $-0x1, -0x14(%rbp), %ecx
subl %ecx, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
movb $0x0, -0x15(%rbp)
addq $0x30, %rsi
callq 0x13660
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x2b052
movq -0x30(%rbp), %rax
cmpl $0x0, 0x48(%rax)
jne 0x2b010
movq -0x40(%rbp), %rdi
movl $0x2, %esi
callq 0xa800
movq %rax, -0x48(%rbp)
jmp 0x2afcb
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rax
movl (%rax), %ecx
addl $-0x2, %ecx
movl %ecx, (%rax)
movl $0x3, %esi
callq 0xa800
movq %rax, -0x50(%rbp)
jmp 0x2afea
movq -0x50(%rbp), %rax
movl 0x4(%rax), %ecx
subl $0x2, %ecx
movl %ecx, 0x4(%rax)
jmp 0x2b050
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xa880
jmp 0x2b06f
movq -0x40(%rbp), %rdi
movl $0x2, %esi
callq 0xa800
movq %rax, -0x58(%rbp)
jmp 0x2b024
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rax
movl (%rax), %ecx
addl $0x2, %ecx
movl %ecx, (%rax)
movl $0x3, %esi
callq 0xa800
movq %rax, -0x60(%rbp)
jmp 0x2b043
movq -0x60(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0x4(%rax)
jmp 0x2b052
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x2b065
movq -0x40(%rbp), %rdi
callq 0xa880
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x65c0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x20, %rdi
callq 0x2c1c0
movq %rax, %rdi
movl $0x195, %ecx            # imm = 0x195
movl $0xf, %r8d
xorl %r9d, %r9d
movl %r9d, %esi
movl %r9d, %edx
callq 0x2c990
leaq -0x31(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x65d0
movq -0x90(%rbp), %rdx
leaq 0x2080(%rip), %rsi      # 0x2d820
leaq -0x30(%rbp), %rdi
callq 0x73b0
jmp 0x2b7ab
leaq -0x31(%rbp), %rdi
callq 0x63e0
movl -0xc(%rbp), %esi
leaq -0x68(%rbp), %rdi
callq 0x26240
jmp 0x2b7c2
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x6470
jmp 0x2b7d1
leaq -0x68(%rbp), %rdi
callq 0x6230
movq -0x98(%rbp), %rdi
addq $0x20, %rdi
callq 0x2c1c0
movq %rax, %rcx
movq -0x98(%rbp), %rax
movq %rcx, -0xa8(%rbp)
movl 0x14(%rax), %eax
movl %eax, -0x9c(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6150
jmp 0x2b816
movl -0x9c(%rbp), %edx
movq -0xa8(%rbp), %rdi
movl $0x32, %esi
leaq -0x88(%rbp), %rcx
callq 0x2ca10
jmp 0x2b836
leaq -0x88(%rbp), %rdi
callq 0x6230
leaq -0x30(%rbp), %rdi
callq 0x6230
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x63e0
jmp 0x2b8b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b8a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6230
jmp 0x2b8a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x6230
leaq -0x30(%rbp), %rdi
callq 0x6230
movq -0x40(%rbp), %rdi
callq 0x65c0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x20, %rdi
callq 0x2c1c0
movq %rax, %rdi
movl $0x11, %edx
movl $0x195, %ecx            # imm = 0x195
movl $0xf, %r8d
xorl %r9d, %r9d
movl %r9d, %esi
callq 0x2c990
leaq -0x31(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x65d0
movq -0x90(%rbp), %rdx
leaq 0x1f19(%rip), %rsi      # 0x2d83b
leaq -0x30(%rbp), %rdi
callq 0x73b0
jmp 0x2b92d
leaq -0x31(%rbp), %rdi
callq 0x63e0
movl -0xc(%rbp), %esi
leaq -0x68(%rbp), %rdi
callq 0x26240
jmp 0x2b944
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x6470
jmp 0x2b953
leaq -0x68(%rbp), %rdi
callq 0x6230
movq -0x98(%rbp), %rdi
addq $0x20, %rdi
callq 0x2c1c0
movq %rax, -0xa0(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6150
jmp 0x2b985
movq -0xa0(%rbp), %rdi
movl $0x32, %esi
movl $0x1e, %edx
leaq -0x88(%rbp), %rcx
callq 0x2ca10
jmp 0x2b9a4
leaq -0x88(%rbp), %rdi
callq 0x6230
leaq -0x30(%rbp), %rdi
callq 0x6230
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x63e0
jmp 0x2ba1f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2ba16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6230
jmp 0x2ba16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x6230
leaq -0x30(%rbp), %rdi
callq 0x6230
movq -0x40(%rbp), %rdi
callq 0x65c0
nopl (%rax,%rax)
// File: leonn[P]neuralNet/source/net.cpp
// Function: Net::feedForward(std::vector<double, std::allocator<double>> const&)
void Net::feedForward(const vector<double> &inputValues){
	assert(inputValues.size()==layers[0].size() - 1 && " the inputValues size needs to be the same of the first layer - bias");

	for (unsigned i = 0; i < inputValues.size(); i++)	{
		layers[0][i].setOutputValue(inputValues[i]);
	}

	//forward propagation
 	//loop each layer and each neuron inside the layer
 	for (unsigned layerNumber = 1; layerNumber <= layers.size(); layerNumber++){
 		Layer &prevLayer = layers[layerNumber-1];
 		for (unsigned n = 0; n < layers[layerNumber].size(); n++){
 			layers[layerNumber][n].feedForward(prevLayer);
 		}
 	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ff0
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3010
movq %rax, %rdi
callq 0x3030
movq -0x30(%rbp), %rcx
movq %rax, %rdx
subq $0x1, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x25(%rbp)
jne 0x28ba
movb $0x1, %al
movb %al, -0x25(%rbp)
jmp 0x28ba
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x28c3
jmp 0x28c5
jmp 0x28e4
leaq 0x878d(%rip), %rdi      # 0xb059
leaq 0x87f9(%rip), %rsi      # 0xb0cc
movl $0x1b, %edx
leaq 0x87fc(%rip), %rcx      # 0xb0db
callq 0x2170
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ff0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x2952
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3010
movq %rax, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3060
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3080
movq -0x48(%rbp), %rdi
fldl (%rax)
movq %rsp, %rax
fstpt (%rax)
callq 0x82b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x28eb
movl $0x1, -0x18(%rbp)
movq -0x38(%rbp), %rdi
movl -0x18(%rbp), %eax
movq %rax, -0x50(%rbp)
addq $0x20, %rdi
callq 0x30a0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
ja 0x2a12
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x3010
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %eax
movq %rax, -0x58(%rbp)
addq $0x20, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x3010
movq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x2a02
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x3010
movq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3060
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x8410
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x299f
jmp 0x2a04
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2959
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: leonn[P]neuralNet/source/neural-net.cpp
// Function: showVectorValues(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<double, std::allocator<double>>&, std::basic_ofstream<char, std::char_traits<char>>&)
void showVectorValues(string label, vector<double> &v,ofstream &file){
    file << label << " ";
    for (unsigned i = 0; i < v.size(); i++) {
        file << v[i] << " ";
    }
    file << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x21c0
movq %rax, %rdi
leaq 0x5ad8(%rip), %rsi      # 0xb125
callq 0x2200
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ff0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x56b2
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x6710
movq -0x30(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x2390
movq %rax, %rdi
leaq 0x5a83(%rip), %rsi      # 0xb125
callq 0x2200
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5659
movq -0x18(%rbp), %rdi
movq 0xb913(%rip), %rsi      # 0x10fd0
callq 0x2220
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: leonn[P]neuralNet/source/neural-net.cpp
// Function: showTestVectorValues(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<double, std::allocator<double>>&, std::basic_ofstream<char, std::char_traits<char>>&)
void showTestVectorValues(string label, vector<double> &v,ofstream &file){
    file << label << " ";
    for (unsigned i = 0; i < v.size(); i++) {
        file << v[i] <<" : "<<round(v[i]) << " ";
    }
    file << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x21c0
movq %rax, %rdi
leaq 0x5a28(%rip), %rsi      # 0xb125
callq 0x2200
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ff0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x5798
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x6710
movq -0x38(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x2390
movq %rax, %rdi
leaq 0x59d1(%rip), %rsi      # 0xb123
callq 0x2200
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x6710
movsd (%rax), %xmm0
callq 0x2100
movq -0x30(%rbp), %rdi
callq 0x2390
movq %rax, %rdi
leaq 0x59a0(%rip), %rsi      # 0xb125
callq 0x2200
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5709
movq -0x18(%rbp), %rdi
movq 0xb82d(%rip), %rsi      # 0x10fd0
callq 0x2220
addq $0x40, %rsp
popq %rbp
retq
nop
// File: leonn[P]neuralNet/source/neuron.cpp
// Function: Neuron::Neuron(unsigned int, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Neuron::Neuron(unsigned numberOutputs, unsigned index,  const string &transferFunction){
	for (unsigned c = 0; c < numberOutputs; c++){
		outputWeights.push_back(Connection());
	}
	this->index=index;
	this->transferFunction=transferFunction;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x20, %rdi
movq %rdi, -0x68(%rbp)
callq 0x22a0
movq -0x60(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x58(%rbp)
callq 0x8790
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x827e
movq -0x60(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x70(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x25e0
jmp 0x8242
movq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x87b0
jmp 0x8251
jmp 0x8253
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8223
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x32e0
movq -0x68(%rbp), %rdi
callq 0x2150
jmp 0x829d
movq -0x60(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, 0x40(%rdi)
movq -0x18(%rbp), %rsi
addq $0x20, %rdi
callq 0x2030
jmp 0x8297
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: leonn[P]neuralNet/source/neuron.cpp
// Function: Neuron::feedForward(std::vector<Neuron, std::allocator<Neuron>> const&)
void Neuron::feedForward(const Layer &prevLayer){
	long double sum=0.0;

	// Sum the previous layer's outputs (which are our inputs)
    // Include the bias node from the previous layer.
	for (unsigned n = 0; n < prevLayer.size();  n++){
		sum+=prevLayer[n].getOutputValue() * prevLayer[n].outputWeights[index].weight;
	}

	// activate function or transfer /sig /gaussian /linear/ step
	if (this->transferFunction=="th")
		outputValue = Neuron::transferFunctionTanH(sum);
	else if (this->transferFunction=="sig")
		outputValue = Neuron::transferFunctionSig(sum);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
fldz
fstpt -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3030
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x84a8
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3160
movq %rax, %rdi
callq 0x82d0
fstpt -0x44(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3160
movq %rax, %rdi
movq -0x30(%rbp), %rax
addq $0x48, %rdi
movl 0x40(%rax), %eax
movl %eax, %esi
callq 0x8880
fldt -0x44(%rbp)
fldt (%rax)
fldt -0x20(%rbp)
fxch %st(2)
fmulp %st, %st(1)
faddp %st, %st(1)
fstpt -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8434
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
leaq 0x2ce1(%rip), %rsi      # 0xb198
callq 0x88a0
testb $0x1, %al
jne 0x84c2
jmp 0x84d7
fldt -0x20(%rbp)
movq %rsp, %rax
fstpt (%rax)
callq 0x82e0
movq -0x30(%rbp), %rax
fstpt (%rax)
jmp 0x8506
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
leaq 0x2cb5(%rip), %rsi      # 0xb19b
callq 0x88a0
testb $0x1, %al
jne 0x84f1
jmp 0x8504
fldt -0x20(%rbp)
movq %rsp, %rax
fstpt (%rax)
callq 0x8350
movq -0x30(%rbp), %rax
fstpt (%rax)
jmp 0x8506
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)