LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]Dsuite/Dsuite_common.cpp
// Function: SetInformation::checkIfTreeNamesMatch(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<int, std::allocator<int>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<int, std::allocator<int>>>>>&)
void SetInformation::checkIfTreeNamesMatch(std::map<string,std::vector<int>>& treeTaxonNamesToLoc) {
        for (int i = 0; i != populations.size(); i++) {
            try { treeTaxonNamesToLoc.at(populations[i]);
            } catch (const std::out_of_range& oor) {
                std::cerr << "Out of Range error: " << oor.what() << '\n';
                std::cerr << "species[i]: " << populations[i] << '\n';
                std::cerr << CHECK_TREE_ERROR_MSG << '\n';
                exit(1);
    }}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq (%rdi), %rsi
cmpq %rsi, 0x8(%rdi)
je 0x3b826
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r12d, %r12d
addq %r15, %rsi
movq %r14, %rdi
callq 0xd754
incq %r12
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x5, %rax
addq $0x20, %r15
cmpq %rax, %r12
jne 0x3b801
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x3b90e
movq %r14, %rdi
callq 0x7170
movq %rax, %r14
movq 0x1b798(%rip), %rdi     # 0x56fe8
leaq 0x989e(%rip), %rsi      # 0x450f5
movl $0x14, %edx
callq 0x74b0
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq 0x1b777(%rip), %rdi     # 0x56fe8
movq %rax, %rsi
callq 0x7400
leaq 0x6(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x74b0
movq 0x1b753(%rip), %rdi     # 0x56fe8
leaq 0x986e(%rip), %rsi      # 0x4510a
movl $0xc, %edx
callq 0x74b0
movq (%rbx), %rax
movq (%rax,%r15), %rsi
movq 0x8(%rax,%r15), %rdx
movq 0x1b72f(%rip), %rdi     # 0x56fe8
callq 0x74b0
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x74b0
movq 0x1b70e(%rip), %rdi     # 0x56fe8
leaq 0x9836(%rip), %rsi      # 0x45117
movl $0x90, %edx
callq 0x74b0
movq 0x1b6f6(%rip), %rdi     # 0x56fe8
movl $0xa, %esi
callq 0x74f0
movl $0x1, %edi
callq 0x7510
movq %rax, %r14
callq 0x76a0
movq %r14, %rdi
callq 0x7740
movq %rax, %rdi
callq 0xd650
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]Dsuite/Dsuite_common.cpp
// Function: makeHeader[abi:cxx11](bool, bool, bool)
string makeHeader(bool quartet, bool includeFstats, bool includeKSstats) {
    string header = "P1\tP2\tP3"; if (quartet) header += "\tP4";
    header += "\tDstatistic\tZ-score\tp-value";
    if (includeFstats) { header += "\t"; header += F4HEADER; }
    if (includeKSstats) { header += "\t"; header += "clustering_sensitive"; header += "\t"; header += "clustering_robust";}
    header += "\tBBAA\tABBA\tBABA";
    return header;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
leaq 0x9869(%rip), %rsi      # 0x451a8
leaq 0x986a(%rip), %rdx      # 0x451b0
callq 0x88ba
testl %r15d, %r15d
je 0x3b95f
leaq 0x985a(%rip), %rsi      # 0x451b1
movq %rbx, %rdi
callq 0x77f0
leaq 0x984f(%rip), %rsi      # 0x451b5
movq %rbx, %rdi
callq 0x77f0
testb %r14b, %r14b
je 0x3b991
leaq 0x7636(%rip), %rsi      # 0x42fb0
movq %rbx, %rdi
callq 0x77f0
leaq 0x5e3e(%rip), %rsi      # 0x417c7
movq %rbx, %rdi
callq 0x77f0
testb %bpl, %bpl
je 0x3b9d2
leaq 0x7613(%rip), %rsi      # 0x42fb0
movq %rbx, %rdi
callq 0x77f0
leaq 0x9825(%rip), %rsi      # 0x451d1
movq %rbx, %rdi
callq 0x77f0
leaq 0x75f5(%rip), %rsi      # 0x42fb0
movq %rbx, %rdi
callq 0x77f0
leaq 0x981c(%rip), %rsi      # 0x451e6
movq %rbx, %rdi
callq 0x77f0
leaq 0x981f(%rip), %rsi      # 0x451f8
movq %rbx, %rdi
callq 0x77f0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x3ba04
movq (%r12), %rsi
incq %rsi
callq 0x7420
movq %r14, %rdi
callq 0x7740
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]Dsuite/Dsuite_common.cpp
// Function: assignNumLinesToAnalyse(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int assignNumLinesToAnalyse(const int providedNumLinesOpt, const int regionLengthOpt,const string& vcfFileOpt) {
    int VCFlineCount;
    if (providedNumLinesOpt > 0) {
        VCFlineCount = providedNumLinesOpt;
    } else if (regionLengthOpt > 0) {
        VCFlineCount = regionLengthOpt;
    } else { // Block to find the number of lines in the VCF file
        std::istream* vcfFile = createReader(vcfFileOpt.c_str());
        // See how big is the VCF file
        vcfFile->unsetf(std::ios_base::skipws); // new lines will be skipped unless we stop it from happening:
        // count the newlines with an algorithm specialized for counting:
        VCFlineCount = (int)std::count(std::istream_iterator<char>(*vcfFile),std::istream_iterator<char>(),'\n');
        //std::cout << "VCF Lines: " << VCFlineCount << "\n";
    }
    return VCFlineCount;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebx
testl %edi, %edi
jg 0x3c78b
movl %esi, %ebx
testl %esi, %esi
jg 0x3c78b
movq (%rdx), %rsi
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x887c
movq %rbx, %rdi
movl $0x8, %esi
callq 0xcfb2
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c728
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7420
movq (%rbx), %rax
movq -0x18(%rax), %rax
andl $0xffffefff, 0x18(%rbx,%rax) # imm = 0xFFFFEFFF
leaq 0x28(%rsp), %r14
movq %rbx, (%r14)
movb $0x1, 0x9(%r14)
movq %r14, %rdi
callq 0x3cfea
movq (%r14), %rax
movq %rax, 0x8(%rsp)
movb 0x8(%r14), %al
movb %al, 0x10(%rsp)
movb 0x9(%r14), %al
movb %al, 0x11(%rsp)
xorl %ebx, %ebx
testb %al, %al
je 0x3c78b
leaq 0x8(%rsp), %r14
xorl %eax, %eax
cmpb $0xa, 0x10(%rsp)
sete %al
addq %rax, %rbx
movq %r14, %rdi
callq 0x3cfea
cmpb $0x0, 0x11(%rsp)
jne 0x3c76f
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c7b3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7420
movq %rbx, %rdi
callq 0x7740
nop
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]Dsuite/KolmogorovSmirnovDist.cpp
// Function: KSfbar(int, double)
double KSfbar (int n, double x)
{
   double w = n * x * x;
   double v = fbarSpecial (n, x);
   if (v >= 0.0)
      return v;

   if (n <= NEXACT) {
      if (w < 4.0)
         return 1.0 - KScdf (n, x);
      else
         return 2.0 * KSPlusbarUpper (n, x);
   }

   if (w >= 2.2)
      return 2.0 * KSPlusbarUpper (n, x);

   return 1.0 - KScdf (n, x);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movapd %xmm0, %xmm2
movl %edi, %ebx
cvtsi2sd %edi, %xmm1
movapd %xmm1, %xmm3
ucomisd 0x11e2(%rip), %xmm0     # 0x40470
mulsd %xmm0, %xmm3
mulsd %xmm0, %xmm3
xorpd %xmm5, %xmm5
xorpd %xmm4, %xmm4
jae 0x3f3e5
ucomisd 0x6224(%rip), %xmm3     # 0x454d0
jae 0x3f3e5
movsd 0x11be(%rip), %xmm0     # 0x40478
divsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
movsd 0x11a6(%rip), %xmm4     # 0x40470
jae 0x3f3e5
movsd 0x6200(%rip), %xmm0     # 0x454d8
ucomisd %xmm3, %xmm0
jae 0x3f3e5
cmpl $0x1, %ebx
jne 0x3f300
movapd %xmm2, %xmm0
addsd %xmm2, %xmm0
movsd 0x60f1(%rip), %xmm4     # 0x453e8
subsd %xmm0, %xmm4
jmp 0x3f3e5
movsd 0x1168(%rip), %xmm0     # 0x40470
movapd %xmm0, %xmm4
divsd %xmm1, %xmm4
ucomisd %xmm2, %xmm4
jae 0x3f331
movapd %xmm0, %xmm6
subsd %xmm4, %xmm6
ucomisd %xmm6, %xmm2
jae 0x3f365
movsd 0x1164(%rip), %xmm4     # 0x40490
jmp 0x3f3e5
movsd %xmm3, 0x8(%rsp)
movsd %xmm2, 0x10(%rsp)
addsd %xmm2, %xmm2
subsd %xmm4, %xmm2
cmpl $0x14, %ebx
jg 0x3f394
movslq %ebx, %r14
leaq 0x61dc(%rip), %r15      # 0x45530
movapd %xmm2, %xmm0
callq 0x7730
mulsd (%r15,%r14,8), %xmm0
jmp 0x3f3c9
subsd %xmm2, %xmm0
movsd %xmm2, 0x10(%rsp)
movsd %xmm3, 0x8(%rsp)
callq 0x7730
xorpd %xmm5, %xmm5
movsd 0x8(%rsp), %xmm3
movsd 0x10(%rsp), %xmm2
movapd %xmm0, %xmm4
addsd %xmm0, %xmm4
jmp 0x3f3e5
movl %ebx, %edi
movsd %xmm1, 0x28(%rsp)
movsd %xmm2, 0x18(%rsp)
callq 0x3f823
movsd %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x7360
mulsd 0x28(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
callq 0x7750
movsd 0x109f(%rip), %xmm4     # 0x40470
subsd %xmm0, %xmm4
movsd 0x10(%rsp), %xmm2
movsd 0x8(%rsp), %xmm3
xorpd %xmm5, %xmm5
ucomisd %xmm5, %xmm4
jae 0x3f437
cmpl $0x8c, %ebx
jg 0x3f416
movsd 0x60ad(%rip), %xmm0     # 0x454a8
ucomisd %xmm3, %xmm0
ja 0x3f420
movl %ebx, %edi
movapd %xmm2, %xmm0
callq 0x3f445
movapd %xmm0, %xmm4
addsd %xmm0, %xmm4
jmp 0x3f437
ucomisd 0x60c2(%rip), %xmm3     # 0x454e0
jae 0x3f401
movl %ebx, %edi
movapd %xmm2, %xmm0
callq 0x3dec0
movsd 0x103d(%rip), %xmm4     # 0x40470
subsd %xmm0, %xmm4
movapd %xmm4, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]Dsuite/KolmogorovSmirnovDist.cpp
// Function: getLogFactorial(int)
static double getLogFactorial (int n)
{
   /* Returns the natural logarithm of factorial n! */
   if (n <= MFACT) {
      return LnFactorial[n];

   } else {
      double x = (double) (n + 1);
      double y = 1.0 / (x * x);
      double z = ((-(5.95238095238E-4 * y) + 7.936500793651E-4) * y -
         2.7777777777778E-3) * y + 8.3333333333333E-2;
      z = ((x - 0.5) * log (x) - x) + 9.1893853320467E-1 + z / x;
      return z;
   }
}

// Assembly:
cmpl $0x1e, %edi
jg 0x3f838
movslq %edi, %rax
leaq 0x5dae(%rip), %rcx      # 0x455e0
movsd (%rcx,%rax,8), %xmm0
retq
subq $0x18, %rsp
incl %edi
cvtsi2sd %edi, %xmm2
movapd %xmm2, %xmm0
mulsd %xmm2, %xmm0
movsd 0xc1e(%rip), %xmm1      # 0x40470
divsd %xmm0, %xmm1
movsd 0x5c9a(%rip), %xmm0     # 0x454f8
mulsd %xmm1, %xmm0
addsd 0x5c96(%rip), %xmm0     # 0x45500
mulsd %xmm1, %xmm0
addsd 0x5c92(%rip), %xmm0     # 0x45508
mulsd %xmm1, %xmm0
addsd 0x5c8e(%rip), %xmm0     # 0x45510
movsd %xmm0, 0x10(%rsp)
movsd 0x5c88(%rip), %xmm1     # 0x45518
movapd %xmm2, %xmm0
movsd %xmm2, (%rsp)
addsd %xmm2, %xmm1
movsd %xmm1, 0x8(%rsp)
callq 0x7360
mulsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm2
subsd %xmm2, %xmm0
addsd 0x5c61(%rip), %xmm0     # 0x45520
movsd 0x10(%rsp), %xmm1
divsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]Dsuite/KolmogorovSmirnovDist.cpp
// Function: CreateMatrixD(int, int)
static double **CreateMatrixD (int N, int M)
{
   int i;
   double **T2;

   T2 = (double **) malloc (N * sizeof (double *));
   T2[0] = (double *) malloc (N * M * sizeof (double));
   for (i = 1; i < N; i++)
      T2[i] = T2[0] + i * M;
   return T2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %r14d
movl %edi, %r15d
leaq (,%r15,8), %rdi
callq 0x7570
movq %rax, %rbx
movl %ebp, %eax
imull %r14d, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x7570
movq %rax, (%rbx)
cmpl $0x2, %r14d
jl 0x3f92f
movslq %ebp, %rcx
leaq (%rax,%rcx,8), %rax
shlq $0x3, %rcx
movl $0x1, %edx
movq %rax, (%rbx,%rdx,8)
incq %rdx
addq %rcx, %rax
cmpq %rdx, %r15
jne 0x3f920
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/MatthewZMD[P]TetrisDual/interface.cc
// Function: Interface::cmdExtract(int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Interface::cmdExtract(int& step, std::string& cmd){
    step = 1;
    int lastDiIndex = -1;
    for(unsigned i = 0; i < cmd.size(); i++){
        if(cmd.at(i) >= '0' && cmd.at(i) <= '9'){
            lastDiIndex = i;
        }
        else {
            break;
        }
    }
    if(lastDiIndex >= 0){
        step = std::stoi(cmd);
        cmd = cmd.substr(lastDiIndex + 1);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movl $0x1, (%rsi)
movq 0x8(%rdx), %rax
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x6a66
movq (%rbx), %rcx
movb (%rcx), %dl
addb $-0x30, %dl
cmpb $0x9, %dl
ja 0x6a66
xorl %edx, %edx
movl %edx, %r14d
leal 0x1(%r14), %edx
cmpq %rdx, %rax
jbe 0x6a66
movb (%rcx,%rdx), %sil
addb $-0x30, %sil
cmpb $0xa, %sil
jb 0x6a4c
testl %r14d, %r14d
js 0x6b05
movq (%rbx), %r13
callq 0x5050
movq %rax, %r12
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movl $0x0, (%r12)
leaq 0x8(%rsp), %rbp
movq %r13, %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x53d0
cmpq %r13, (%rbp)
je 0x6b14
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x6b20
movl (%r12), %ecx
cmpl $0x22, %ecx
je 0x6b20
testl %ecx, %ecx
jne 0x6ac0
movl 0x4(%rsp), %ecx
movl %ecx, (%r12)
movl %eax, (%r15)
incl %r14d
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq $-0x1, %rcx
callq 0x52f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5350
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6b05
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc59c(%rip), %rdi      # 0x130b7
callq 0x51e0
leaq 0xc590(%rip), %rdi      # 0x130b7
callq 0x53f0
cmpl $0x0, (%r12)
jne 0x6b3b
movl 0x4(%rsp), %ecx
movl %ecx, (%r12)
movq %rax, %rdi
callq 0x54e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/MatthewZMD[P]TetrisDual/blinddecorator.cc
// Function: BlindDecorator::display()
std::vector<std::vector<char>> BlindDecorator::display() {
	std::vector<std::vector<char>> a = board->display();
	for (int i = 6; i < 16; ++i) {
		for (int j = 0; j < 11; ++j) {
			a[i][j] = '?';
		}		
	}
	for (int i = 0; i < 18; ++i) {
		for (int j = 2; j < 9; ++j) {
			a[i][j] = '?';
		}
	}
	return a;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rsi), %rsi
movq (%rsi), %rax
callq *0x50(%rax)
movl $0x6, %eax
leaq (%rax,%rax,2), %rcx
xorl %edx, %edx
movq (%rbx), %rsi
movq (%rsi,%rcx,8), %rsi
movb $0x3f, (%rsi,%rdx)
incq %rdx
cmpq $0xb, %rdx
jne 0x7955
incq %rax
cmpq $0x10, %rax
jne 0x794f
xorl %eax, %eax
leaq (%rax,%rax,2), %rcx
xorl %edx, %edx
movq (%rbx), %rsi
movq (%rsi,%rcx,8), %rsi
movb $0x3f, 0x2(%rsi,%rdx)
incq %rdx
cmpq $0x7, %rdx
jne 0x797a
incq %rax
cmpq $0x12, %rax
jne 0x7974
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/MatthewZMD[P]TetrisDual/block.cc
// Function: Block::recaliBtmLft()
void Block::recaliBtmLft(){
    Coordinate newBtmLft = Coordinate{0, 200};
    Coordinate cellPos;
    for(unsigned i = 0; i < cells.size(); ++i) {
        cellPos = cells.at(i)->pos;
        if(cellPos.col < newBtmLft.col) newBtmLft.col = cellPos.col;
        if(cellPos.row > newBtmLft.row) newBtmLft.row = cellPos.row;
    }
    btmLft = newBtmLft;
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x7b21
sarq $0x3, %rcx
xorl %r8d, %r8d
movl $0xc8, %edx
xorl %esi, %esi
movq (%rax,%r8,8), %r9
movl 0x5c(%r9), %r10d
cmpl %edx, %r10d
cmovll %r10d, %edx
movl 0x58(%r9), %r9d
cmpl %esi, %r9d
cmovgl %r9d, %esi
incq %r8
movl %r8d, %r9d
cmpq %r9, %rcx
ja 0x7afa
jmp 0x7b28
xorl %esi, %esi
movl $0xc8, %edx
movl %esi, 0x18(%rdi)
movl %edx, 0x1c(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/MatthewZMD[P]TetrisDual/block.cc
// Function: Block::Block(CellType, int, std::vector<Cell*, std::allocator<Cell*>>)
Block::Block(CellType t, int l, std::vector<Cell*> cells): cells { cells }, btmLft { Coordinate { 3, 0 } } {
    std::vector<Cell*> sq;
    for(auto &c : cells){
        if(!c->isEmpty()){
            throw "Game Over";
        }
        for(auto &ci : cells){
            if(ci != c){
                sq.emplace_back(ci);
            }
        }
        c->set(t, l, sq);
        sq.clear();
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movl %edx, 0xc(%rsp)
movl %esi, 0x8(%rsp)
movq %rdi, %rbx
movq %rcx, %rsi
callq 0x7cc8
movq %rbx, 0x30(%rsp)
movq $0x3, 0x18(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq (%r14), %rbp
movq 0x8(%r14), %rax
movq %rax, 0x38(%rsp)
cmpq %rax, %rbp
je 0x7c21
leaq 0x40(%rsp), %r15
leaq 0x10(%rsp), %r13
movq (%rbp), %rdi
callq 0x8784
testb %al, %al
je 0x7c47
movq (%r14), %rbx
movq 0x8(%r14), %r12
cmpq %r12, %rbx
je 0x7bc8
movq (%rbx), %rax
cmpq (%rbp), %rax
je 0x7bc2
movq %r13, %rdi
movq %rbx, %rsi
callq 0x7d48
addq $0x8, %rbx
jmp 0x7ba9
movq (%rbp), %rbx
movq %r15, %rdi
movq %r13, %rsi
callq 0x7cc8
movq %rbx, %rdi
movl 0x8(%rsp), %esi
movl 0xc(%rsp), %edx
movq %r15, %rcx
callq 0x85fa
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x7c01
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x52e0
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x7c12
movq %rax, 0x18(%rsp)
addq $0x8, %rbp
cmpq 0x38(%rsp), %rbp
jne 0x7b91
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x7c38
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x52e0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x5180
leaq 0xb6d9(%rip), %rcx      # 0x13331
movq %rcx, (%rax)
movq 0x1432e(%rip), %rsi     # 0x1bf90
movq %rax, %rdi
xorl %edx, %edx
callq 0x54c0
jmp 0x7c8c
movq %rax, %r14
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x7c8f
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x52e0
jmp 0x7c8f
jmp 0x7c8c
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x7ca6
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x52e0
movq 0x30(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x7cbf
movq 0x10(%rax), %rsi
subq %rdi, %rsi
callq 0x52e0
movq %r14, %rdi
callq 0x54e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/MatthewZMD[P]TetrisDual/cell.cc
// Function: Cell::notify(Subject&)
void Cell::notify(Subject& s) {
    Cell & c = dynamic_cast<Cell&>(s);
    CellInfo & info = dynamic_cast<CellInfo&>(c.getInfo());

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x12be1(%rip), %rsi     # 0x1b208
leaq 0x12d82(%rip), %rdx     # 0x1b3b0
movl $0x8, %ecx
movq %rax, %rdi
callq 0x5300
testq %rax, %rax
je 0x876e
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x13359(%rip), %rsi     # 0x1b9b0
leaq 0x12dd2(%rip), %rdx     # 0x1b430
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x5300
testq %rax, %rax
je 0x876e
cmpl $0x0, 0x88(%r14)
movl 0x8(%rax), %ecx
movl 0x58(%rbx), %edx
je 0x8728
decl %edx
cmpl %edx, %ecx
jne 0x872e
movl 0x10(%rax), %ecx
movl %ecx, 0x60(%rbx)
movl 0x14(%rax), %ecx
movl %ecx, 0x64(%rbx)
addq $0x18, %rax
leaq 0x68(%rbx), %rdi
movq %rax, %rsi
callq 0x87cc
movq 0x68(%rbx), %r12
movq 0x70(%rbx), %r13
cmpq %r13, %r12
je 0x875f
movq (%r12), %rcx
movq 0x68(%rcx), %rax
cmpq %rax, 0x70(%rcx)
je 0x8722
movl $0x1, %ebp
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
addq $0x58, %rdi
movq 0x58(%r14), %rsi
callq 0xc0dc
testb %al, %al
jne 0x8706
movl %ebp, %r15d
movq (%r12), %rcx
movq 0x68(%rcx), %rax
movq 0x70(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
incl %ebp
cmpq %r15, %rcx
ja 0x86d2
jmp 0x8722
movq (%r12), %rcx
movq 0x68(%rcx), %rax
movq 0x70(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r15, %rdx
jbe 0x8773
movq %rbx, (%rax,%r15,8)
addq $0x8, %r12
jmp 0x86b3
incl %edx
cmpl %edx, %ecx
jne 0x875f
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x1, %esi
callq 0x893a
movl 0x8(%r15), %eax
movl %eax, 0x88(%r14)
movq %r15, %rdi
callq 0xeddc
addq $0x8, %rbx
movq %rbx, %rdi
callq 0xedfe
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5530
leaq 0xac18(%rip), %rdi      # 0x13392
movq %r15, %rsi
xorl %eax, %eax
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O1/MatthewZMD[P]TetrisDual/cell.cc
// Function: Cell::getInfo()
Info& Cell::getInfo() {
	cellInfo.pos = pos;
	cellInfo.blockLevel = blockLevel;
	cellInfo.type = type;
	cellInfo.squad = squad;
	return cellInfo;
}

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

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xc12e
movq 0xfe88(%rip), %rcx      # 0x1bfa8
cmpb $0x0, (%rcx)
je 0xc12a
incl 0x8(%rax)
jmp 0xc12e
lock
incl 0x8(%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7eb4
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xc148
callq 0x5f3e
leaq 0xf4b1(%rip), %rax      # 0x1b600
movq %rax, (%rbx)
movl %ebp, 0x40(%rbx)
movq (%r14), %rax
movq 0x8(%rax), %r15
movq 0x10(%rax), %r12
cmpq %r12, %r15
je 0xc176
movq (%r15), %rsi
movq %rbx, %rdi
callq 0xede8
addq $0x8, %r15
jmp 0xc160
movq (%r14), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x90(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc1a7
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xc1b2
callq 0x5f3e
jmp 0xc1b2
movq %rax, %r14
movq %rbx, %rdi
callq 0x7a4e
movq %r14, %rdi
callq 0x54e0
// File: /workspace/github_cpp_makefile_star2_O1/MatthewZMD[P]TetrisDual/game.cc
// Function: Game::heavy()
void Game::heavy() {
    if (playerTurn == 1) {
        board1 = std::make_shared<HeavyDecorator>(board1);
    }
    else if (playerTurn == 0) {
        board2 = std::make_shared<HeavyDecorator>(board2);
    }
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x44(%rdi), %eax
testl %eax, %eax
je 0xc65c
cmpl $0x1, %eax
jne 0xc6c4
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
movq %rbx, %rcx
callq 0xd69a
movq (%r14), %rsi
movq %r14, %rdi
callq 0xd718
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x8(%rbx), %rdi
movups %xmm0, (%rbx)
testq %rdi, %rdi
je 0xc64b
callq 0x5f3e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xc6bc
callq 0x5f3e
jmp 0xc6bc
leaq 0x10(%rbx), %r14
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rsi
movq %r14, %rcx
callq 0xd69a
movq (%r15), %rsi
movq %r15, %rdi
callq 0xd718
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x18(%rbx), %rdi
movups %xmm0, 0x10(%rbx)
testq %rdi, %rdi
je 0xc6aa
callq 0x5f3e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xc6b9
callq 0x5f3e
movq %r14, %rbx
movq (%rbx), %rdi
callq 0xedfe
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/MatthewZMD[P]TetrisDual/game.cc
// Function: Game::force(CellType)
void Game::force(CellType type) {
    if (playerTurn == 1) {
        board1 = std::make_shared<ForceDecorator>(board1, type);
	board1->notifyObservers();
    }
    else if (playerTurn == 0) {
        board2 = std::make_shared<ForceDecorator>(board2, type);
	board2->notifyObservers();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl 0x44(%rdi), %eax
testl %eax, %eax
je 0xc74d
cmpl $0x1, %eax
jne 0xc7ba
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r14
leaq 0xb(%rsp), %rdx
leaq 0xc(%rsp), %r8
movq %r14, %rsi
movq %rbx, %rcx
callq 0xd820
movq (%r14), %rsi
movq %r14, %rdi
callq 0xd8a4
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x8(%rbx), %rdi
movups %xmm0, (%rbx)
testq %rdi, %rdi
je 0xc73c
callq 0x5f3e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xc7b2
callq 0x5f3e
jmp 0xc7b2
leaq 0x10(%rbx), %r14
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r15
leaq 0xb(%rsp), %rdx
leaq 0xc(%rsp), %r8
movq %r15, %rsi
movq %r14, %rcx
callq 0xd820
movq (%r15), %rsi
movq %r15, %rdi
callq 0xd8a4
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x18(%rbx), %rdi
movups %xmm0, 0x10(%rbx)
testq %rdi, %rdi
je 0xc7a0
callq 0x5f3e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xc7af
callq 0x5f3e
movq %r14, %rbx
movq (%rbx), %rdi
callq 0xedfe
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/MatthewZMD[P]TetrisDual/game.cc
// Function: Game::recover()
void Game::recover() {
    if (playerTurn == 0) {
        board1 = board1->getBoard();
    }
    else if (playerTurn == 1) {
        board2 = board2->getBoard();
    }
}

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x44(%rdi), %eax
cmpl $0x1, %eax
je 0xc882
testl %eax, %eax
jne 0xc8cd
movq (%rbx), %rdi
movq (%rdi), %rax
movl %edx, %esi
callq *0x8(%rax)
cmpl $0x2, %eax
jl 0xc874
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc8d4
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq %rbx, %r15
jmp 0xc8ab
leaq 0x10(%rbx), %r15
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movl %edx, %esi
callq *0x8(%rax)
cmpl $0x2, %eax
jl 0xc8a2
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc8d4
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
testb %al, %al
je 0xc8cd
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq %rbx, %rdi
callq 0xc7c4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xcb3e
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/MatthewZMD[P]TetrisDual/game.cc
// Function: Game::switchTurn()
void Game::switchTurn() {
    if (playerTurn == 0) {
        board1->genThis();
        board2->setNext(board2->genNext());
        playerTurn = 1;
    }
    else if (playerTurn == 1) {
        board2->genThis();
        board1->setNext(board1->genNext());
        playerTurn = 0;
    }
}

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

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

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

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

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

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

        numberOfRowsRemoved = board1->drop();

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

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

        numberOfRowsRemoved = board2->drop();

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x44(%rdi), %eax
cmpl $0x1, %eax
je 0xcce1
testl %eax, %eax
jne 0xcd65
movq (%rbx), %r15
cmpl $0x1, %edx
jg 0xccaa
movq (%r15), %rax
movq %r15, %rdi
callq *0x98(%rax)
testl %eax, %eax
jle 0xccba
movq (%rbx), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x98(%rax)
movl %eax, %edx
decl %edx
movq (%r15), %rax
movq %r15, %rdi
movl %edx, %esi
callq *0xa0(%rax)
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x2, %eax
jl 0xccd3
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc8d4
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq %rbx, %r15
jmp 0xcd43
movq 0x10(%rbx), %r15
cmpl $0x1, %edx
jg 0xcd0c
movq (%r15), %rax
movq %r15, %rdi
callq *0x98(%rax)
testl %eax, %eax
jle 0xcd1c
movq 0x10(%rbx), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x98(%rax)
movl %eax, %edx
decl %edx
movq (%r15), %rax
movq %r15, %rdi
movl %edx, %esi
callq *0xa0(%rax)
leaq 0x10(%rbx), %r15
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x2, %eax
jl 0xcd3a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc8d4
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
testb %al, %al
je 0xcd65
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq %rbx, %rdi
callq 0xc7c4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xcb3e
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/MatthewZMD[P]TetrisDual/game.cc
// Function: Game::levelup(int)
void Game::levelup(int n) {
    if (playerTurn == 0) {
        for (int i = 0; i < n; ++i) {
            board1->levelUp();
        }
    }
    else {
        for (int i = 0; i < n; ++i) {
            board2->levelUp();
        }
    }
}

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

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

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6a69(%rip), %rsi      # 0x1394c
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xcf6a
leaq 0x6a5a(%rip), %rsi      # 0x13950
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xcf6e
leaq 0x6a33(%rip), %rsi      # 0x1393c
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xcf75
leaq 0x6a23(%rip), %rsi      # 0x1393f
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xcf7c
leaq 0x6a14(%rip), %rsi      # 0x13943
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xcf83
leaq 0x6a16(%rip), %rsi      # 0x13958
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xcf8a
leaq 0x6a06(%rip), %rsi      # 0x1395b
movq %r14, %rdi
callq 0x50d0
cmpl $0x1, %eax
movl $0x7, %esi
sbbl $0x0, %esi
jmp 0xcf8f
xorl %esi, %esi
jmp 0xcf8f
movl $0x1, %esi
jmp 0xcf8f
movl $0x2, %esi
jmp 0xcf8f
movl $0x3, %esi
jmp 0xcf8f
movl $0x4, %esi
jmp 0xcf8f
movl $0x5, %esi
xorl %eax, %eax
cmpl $0x0, 0x44(%rbx)
setne %al
shll $0x4, %eax
movq (%rbx,%rax), %rdi
movq (%rdi), %rax
movq 0x90(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/MatthewZMD[P]TetrisDual/heavydecorator.cc
// Function: HeavyDecorator::left(int)
int HeavyDecorator::left(int time) {
	board->left(time);
	int lineRemove = 0;
	if (!board->down(1) || !board->down(1)) {
		lineRemove = board->drop();
	}
	notifyObservers();
	return lineRemove;
}

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x20(%rax)
testb %al, %al
je 0xda3e
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x20(%rax)
xorl %ebp, %ebp
testb %al, %al
jne 0xda4a
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ebp
movq %rbx, %rdi
callq 0xedfe
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop