LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: millanek[P]Dsuite/KolmogorovSmirnovDist.cpp
// Function: KSPlusbarAsymp(int, double)
static double KSPlusbarAsymp (int n, double x)
{
   /* Compute the probability of the KS+ distribution using an asymptotic
      formula */
   double t = (6.0 * n * x + 1);
   double z = t * t / (18.0 * n);
   double v = 1.0 - (2.0 * z * z - 4.0 * z - 1.0) / (18.0 * n);
   if (v <= 0.0)
      return 0.0;
   v = v * exp (-z);
   if (v >= 1.0)
      return 1.0;
   return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm1
movsd 0x5e53(%rip), %xmm0     # 0x8d7c0
mulsd %xmm1, %xmm0
movsd -0x18(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0xb26(%rip), %xmm1      # 0x884a8
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm2
movsd 0x5d66(%rip), %xmm1     # 0x8d708
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0xb09(%rip), %xmm1      # 0x884c0
mulsd -0x28(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
movsd 0x5d37(%rip), %xmm0     # 0x8d700
mulsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0xab3(%rip), %xmm0      # 0x884a8
subsd %xmm0, %xmm1
cvtsi2sdl -0xc(%rbp), %xmm2
movsd 0x5d02(%rip), %xmm0     # 0x8d708
mulsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movsd 0xa92(%rip), %xmm0      # 0x884a8
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x30(%rbp), %xmm0
jb 0x87a33
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x87a9b
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x8a70
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd 0xa2c(%rip), %xmm1      # 0x884a8
ucomisd %xmm1, %xmm0
jb 0x87a91
movsd 0xa1e(%rip), %xmm0      # 0x884a8
movsd %xmm0, -0x8(%rbp)
jmp 0x87a9b
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: millanek[P]Dsuite/KolmogorovSmirnovDist.cpp
// Function: mMultiply(double*, double*, double*, int)
static void mMultiply (double *A, double *B, double *C, int m)
{
   int i, j, k;
   double s;
   for (i = 0; i < m; i++)
      for (j = 0; j < m; j++) {
         s = 0.;
         for (k = 0; k < m; k++)
            s += A[i * m + k] * B[k * m + j];
         C[i * m + j] = s;
      }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x87d82
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x87d72
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x87d49
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x87cf8
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x87cdd
jmp 0x87d74
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x87cca
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: millanek[P]Dsuite/KolmogorovSmirnovDist.cpp
// Function: renormalize(double*, int, int*)
static void renormalize (double *V, int m, int *p)
{
   int i;
   for (i = 0; i < m * m; i++)
      V[i] *= INORM;
   *p += LOGNORM;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0xc(%rbp), %ecx
imull -0xc(%rbp), %ecx
cmpl %ecx, %eax
jge 0x87dd9
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd 0x58dc(%rip), %xmm0     # 0x8d6a0
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x87da6
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x8c, %ecx
movl %ecx, (%rax)
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6270
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x97cb
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x66c0
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x97bc
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x66c0
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x97bc
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x97be
jmp 0x97cb
jmp 0x97c0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x976c
cmpl $0x0, -0x1c(%rbp)
jl 0x981e
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x7260
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
leaq -0x40(%rbp), %rdi
movq $-0x1, %rcx
callq 0x6390
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6460
leaq -0x40(%rbp), %rdi
callq 0x6230
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movb $0x0, -0x11(%rbp)
addq $0x30, %rdi
callq 0xc1e0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq (%rsi), %rax
callq *0x50(%rax)
movl $0x6, -0x18(%rbp)
cmpl $0x10, -0x18(%rbp)
jge 0xc067
movl $0x0, -0x1c(%rbp)
cmpl $0xb, -0x1c(%rbp)
jge 0xc05a
movq -0x30(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0xc200
movq %rax, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xc220
movb $0x3f, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc02d
jmp 0xc05c
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xc020
movl $0x0, -0x20(%rbp)
cmpl $0x12, -0x20(%rbp)
jge 0xc0b5
movl $0x2, -0x24(%rbp)
cmpl $0x9, -0x24(%rbp)
jge 0xc0a8
movq -0x30(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0xc200
movq %rax, %rdi
movslq -0x24(%rbp), %rsi
callq 0xc220
movb $0x3f, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc07b
jmp 0xc0aa
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xc06e
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xc0c8
movq -0x30(%rbp), %rdi
callq 0xc240
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x205dd(%rip), %rax     # 0x2d338
movq %rax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x30(%rbp)
callq 0xd020
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0xcdc4
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0xd040
movq (%rax), %rax
movq 0x58(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xcda9
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0xcdb7
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0xcdb9
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xcd66
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rcx, -0xb0(%rbp)
movl %esi, %eax
movq -0xb0(%rbp), %rsi
movq %rsi, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xd080
movq -0xa8(%rbp), %rax
movl $0x3, 0x18(%rax)
movl $0x0, 0x1c(%rax)
leaq -0x30(%rbp), %rdi
callq 0xd170
movq -0xa0(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xd190
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xd1c0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xd1f0
testb $0x1, %al
jne 0xce79
jmp 0xcfe6
leaq -0x40(%rbp), %rdi
callq 0xd230
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0xffc0
movb %al, -0xb1(%rbp)
jmp 0xce9a
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0xcee3
jmp 0xcea6
movl $0x8, %edi
callq 0x61a0
movq %rax, %rdi
leaq 0x20486(%rip), %rax     # 0x2d340
movq %rax, (%rdi)
movq 0x370c4(%rip), %rsi     # 0x43f88
xorl %eax, %eax
movl %eax, %edx
callq 0x6600
jmp 0xd016
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xcff8
movq -0xa0(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0xd190
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0xd1c0
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xd1f0
testb $0x1, %al
jne 0xcf1b
jmp 0xcf56
leaq -0x70(%rbp), %rdi
callq 0xd230
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq -0x50(%rbp), %rcx
cmpq (%rcx), %rax
je 0xcf49
movq -0x80(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xd250
jmp 0xcf47
jmp 0xcf49
jmp 0xcf4b
leaq -0x70(%rbp), %rdi
callq 0xd2d0
jmp 0xcf08
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0xbc(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xb8(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xd080
jmp 0xcf88
movl -0xb8(%rbp), %edx
movl -0xbc(%rbp), %esi
movq -0xc8(%rbp), %rdi
leaq -0x98(%rbp), %rcx
callq 0xfd10
jmp 0xcfa9
leaq -0x98(%rbp), %rdi
callq 0xd2f0
leaq -0x30(%rbp), %rdi
callq 0xd350
leaq -0x40(%rbp), %rdi
callq 0xd2d0
jmp 0xce63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xd2f0
jmp 0xcff8
leaq -0x30(%rbp), %rdi
callq 0xd2f0
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0xd2f0
movq -0xa8(%rbp), %rdi
callq 0xd2f0
movq -0x58(%rbp), %rdi
callq 0x6630
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq 0x58(%rdi), %rax
movq %rax, 0x30(%rdi)
movl 0x60(%rdi), %eax
movl %eax, 0x38(%rdi)
movl 0x64(%rdi), %eax
movl %eax, 0x3c(%rdi)
movq %rdi, %rsi
addq $0x68, %rsi
addq $0x28, %rdi
addq $0x18, %rdi
callq 0x10070
movq -0x10(%rbp), %rax
addq $0x28, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: MatthewZMD[P]TetrisDual/concreteboard.cc
// Function: ConcreteBoard::levelUp()
void ConcreteBoard::levelUp(){
    level = level->levelUp();
    if (level->getLevel() == 3) {
        countTurn = 0;
    }
    notifyObservers();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x60, %rdi
callq 0x13b10
movq %rax, %rsi
movq (%rsi), %rax
leaq -0x18(%rbp), %rdi
callq *0x10(%rax)
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
leaq -0x18(%rbp), %rsi
callq 0x13b30
leaq -0x18(%rbp), %rdi
callq 0x13b60
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
callq 0x13b10
movq %rax, %rdi
callq 0x24930
cmpl $0x3, %eax
jne 0x10eb9
movq -0x20(%rbp), %rax
movl $0x0, 0x70(%rax)
movq -0x20(%rbp), %rdi
callq 0x25430
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: MatthewZMD[P]TetrisDual/concreteboard.cc
// Function: ConcreteBoard::levelDown()
void ConcreteBoard::levelDown(){
    level = level->levelDown();
    if (level->getLevel() == 4) {
        countTurn = 0;
    }
    notifyObservers();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x60, %rdi
callq 0x13b10
movq %rax, %rsi
movq (%rsi), %rax
leaq -0x18(%rbp), %rdi
callq *0x8(%rax)
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
leaq -0x18(%rbp), %rsi
callq 0x13b30
leaq -0x18(%rbp), %rdi
callq 0x13b60
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
callq 0x13b10
movq %rax, %rdi
callq 0x24930
cmpl $0x4, %eax
jne 0x10f39
movq -0x20(%rbp), %rax
movl $0x0, 0x70(%rax)
movq -0x20(%rbp), %rdi
callq 0x25430
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl 0x44(%rdi), %eax
movl %eax, 0xa0(%rdi)
addq $0x60, %rdi
callq 0x13b10
movq %rax, %rdi
callq 0x24930
movq -0x28(%rbp), %rsi
movl %eax, 0xa4(%rsi)
movl 0x5c(%rsi), %eax
movl %eax, 0xa8(%rsi)
movq (%rsi), %rax
leaq -0x20(%rbp), %rdi
callq *0x50(%rax)
movq -0x28(%rbp), %rdi
addq $0x98, %rdi
addq $0x18, %rdi
leaq -0x20(%rbp), %rsi
callq 0xe880
leaq -0x20(%rbp), %rdi
callq 0xc240
movq -0x28(%rbp), %rax
movl 0x58(%rax), %ecx
movl %ecx, 0xc8(%rax)
addq $0x98, %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x48, %rdi
callq 0x13e70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd190
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd1c0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xd1f0
testb $0x1, %al
jne 0x13941
jmp 0x13965
leaq -0x20(%rbp), %rdi
callq 0xd230
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0xfce0
leaq -0x20(%rbp), %rdi
callq 0xd2d0
jmp 0x1392e
movq -0x40(%rbp), %rdi
addq $0x48, %rdi
callq 0x13e70
movq %rax, %rdi
callq 0xd350
movq -0x40(%rbp), %rdi
movl 0x58(%rdi), %eax
movl %eax, -0x34(%rbp)
movl -0xc(%rbp), %eax
movl %eax, 0x58(%rdi)
movq (%rdi), %rax
callq *0x40(%rax)
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, 0x58(%rdi)
callq 0x25430
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xc2a0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0xe250
jmp 0x1a56b
leaq -0x28(%rbp), %rdi
callq 0xaf20
movq -0x68(%rbp), %rax
movq -0x70(%rbp), %rdi
leaq 0x2905d(%rip), %rcx     # 0x435e0
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x40(%rax)
callq 0xc1e0
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xc2d0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0xc300
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xc330
testb $0x1, %al
jne 0x1a5ca
jmp 0x1a624
leaq -0x48(%rbp), %rdi
callq 0xc370
movq -0x68(%rbp), %rdi
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %rsi
callq 0x25400
jmp 0x1a5e9
jmp 0x1a5eb
leaq -0x48(%rbp), %rdi
callq 0xc390
jmp 0x1a5b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xaf20
jmp 0x1a647
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xc3b0
jmp 0x1a647
movq -0x70(%rbp), %rdi
callq 0xc1e0
movq %rax, %rdi
movl -0x14(%rbp), %esi
movq (%rdi), %rax
movq 0x90(%rax), %rax
callq *%rax
jmp 0x1a641
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6630
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x1, 0x44(%rax)
jne 0x1aacf
movq -0x30(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x1bd20
movq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1bd90
leaq -0x18(%rbp), %rdi
callq 0x1bdc0
jmp 0x1ab06
movq -0x30(%rbp), %rax
cmpl $0x0, 0x44(%rax)
jne 0x1ab04
movq -0x30(%rbp), %rsi
addq $0x10, %rsi
leaq -0x28(%rbp), %rdi
callq 0x1bd20
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
leaq -0x28(%rbp), %rsi
callq 0x1bd90
leaq -0x28(%rbp), %rdi
callq 0x1bdc0
jmp 0x1ab06
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x1, 0x44(%rax)
jne 0x1ab60
movq -0x30(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x1bde0
movq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1be50
leaq -0x18(%rbp), %rdi
callq 0x1be80
movq -0x30(%rbp), %rdi
callq 0xc1e0
movq %rax, %rdi
callq 0x25430
jmp 0x1abac
movq -0x30(%rbp), %rax
cmpl $0x0, 0x44(%rax)
jne 0x1abaa
movq -0x30(%rbp), %rsi
addq $0x10, %rsi
leaq -0x28(%rbp), %rdi
callq 0x1bde0
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
leaq -0x28(%rbp), %rsi
callq 0x1be50
leaq -0x28(%rbp), %rdi
callq 0x1be80
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1e0
movq %rax, %rdi
callq 0x25430
jmp 0x1abac
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x1, 0x44(%rax)
jne 0x1ac17
movq -0x38(%rbp), %rsi
leaq -0x20(%rbp), %rdi
leaq -0xc(%rbp), %rdx
callq 0x1bea0
movq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1bf20
leaq -0x20(%rbp), %rdi
callq 0x1bf50
movq -0x38(%rbp), %rdi
callq 0xc1e0
movq %rax, %rdi
callq 0x25430
jmp 0x1ac67
movq -0x38(%rbp), %rax
cmpl $0x0, 0x44(%rax)
jne 0x1ac65
movq -0x38(%rbp), %rsi
addq $0x10, %rsi
leaq -0x30(%rbp), %rdi
leaq -0xc(%rbp), %rdx
callq 0x1bea0
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
leaq -0x30(%rbp), %rsi
callq 0x1bf20
leaq -0x30(%rbp), %rdi
callq 0x1bf50
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1e0
movq %rax, %rdi
callq 0x25430
jmp 0x1ac67
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, 0x44(%rax)
jne 0x1acb8
movq -0x30(%rbp), %rdi
callq 0xc1e0
movq %rax, %rsi
movq (%rsi), %rax
leaq -0x18(%rbp), %rdi
callq *0x58(%rax)
movq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1bf70
leaq -0x18(%rbp), %rdi
callq 0xaf20
jmp 0x1acf8
movq -0x30(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1acf6
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1e0
movq %rax, %rsi
movq (%rsi), %rax
leaq -0x28(%rbp), %rdi
callq *0x58(%rax)
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
leaq -0x28(%rbp), %rsi
callq 0x1bf70
leaq -0x28(%rbp), %rdi
callq 0xaf20
jmp 0x1acf8
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x0, 0x44(%rax)
jne 0x1ad94
movq -0x20(%rbp), %rdi
callq 0xc1e0
movq %rax, %rdi
movl -0x14(%rbp), %esi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, -0x18(%rbp)
cmpl $0x2, -0x18(%rbp)
jl 0x1ad53
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ae20
movq -0x20(%rbp), %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x70(%rax)
testb $0x1, %al
jne 0x1ad6b
jmp 0x1ad8f
movq -0x20(%rbp), %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq -0x20(%rbp), %rdi
callq 0x1ac70
movq -0x20(%rbp), %rdi
callq 0x1b110
jmp 0x1ae15
movq -0x20(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1ae13
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1e0
movq %rax, %rdi
movl -0x14(%rbp), %esi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, -0x18(%rbp)
cmpl $0x2, -0x18(%rbp)
jl 0x1adcd
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ae20
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x70(%rax)
testb $0x1, %al
jne 0x1ade9
jmp 0x1ae11
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq -0x20(%rbp), %rdi
callq 0x1ac70
movq -0x20(%rbp), %rdi
callq 0x1b110
jmp 0x1ae13
jmp 0x1ae15
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x44(%rax)
jne 0x1b17c
movq -0x10(%rbp), %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1e0
movq -0x10(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x10, %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq -0x18(%rbp), %rdi
movl %eax, %esi
movq (%rdi), %rax
callq *0x68(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x44(%rax)
jmp 0x1b1d4
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1b1d2
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq -0x10(%rbp), %rdi
callq 0xc1e0
movq -0x10(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq -0x20(%rbp), %rdi
movl %eax, %esi
movq (%rdi), %rax
callq *0x68(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x44(%rax)
jmp 0x1b1d4
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x0, 0x44(%rax)
jne 0x1b274
movq -0x20(%rbp), %rdi
callq 0xc1e0
movq %rax, %rdi
movl -0x14(%rbp), %esi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, -0x18(%rbp)
cmpl $0x2, -0x18(%rbp)
jl 0x1b233
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ae20
movq -0x20(%rbp), %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x70(%rax)
testb $0x1, %al
jne 0x1b24b
jmp 0x1b26f
movq -0x20(%rbp), %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq -0x20(%rbp), %rdi
callq 0x1ac70
movq -0x20(%rbp), %rdi
callq 0x1b110
jmp 0x1b2f5
movq -0x20(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1b2f3
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1e0
movq %rax, %rdi
movl -0x14(%rbp), %esi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, -0x18(%rbp)
cmpl $0x2, -0x18(%rbp)
jl 0x1b2ad
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ae20
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x70(%rax)
testb $0x1, %al
jne 0x1b2c9
jmp 0x1b2f1
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq -0x20(%rbp), %rdi
callq 0x1ac70
movq -0x20(%rbp), %rdi
callq 0x1b110
jmp 0x1b2f3
jmp 0x1b2f5
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: MatthewZMD[P]TetrisDual/game.cc
// Function: Game::down(int)
void Game::down(int n) {
    if (playerTurn == 0) {
        board1->down(n);
    }
    else if (playerTurn == 1) {
        board2->down(n);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x44(%rax)
jne 0x1b334
movq -0x18(%rbp), %rdi
callq 0xc1e0
movq %rax, %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x1b359
movq -0x18(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1b357
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1e0
movq %rax, %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x1b359
addq $0x20, %rsp
popq %rbp
retq
nop
// File: MatthewZMD[P]TetrisDual/game.cc
// Function: Game::rotate(bool, int)
void Game::rotate(bool isClockwise, int n) {
    if (playerTurn == 0) {
        board1->rotate(isClockwise, n);
    }
    else if (playerTurn == 1) {
        board2->rotate(isClockwise, n);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x44(%rax)
jne 0x1b3a5
movq -0x18(%rbp), %rdi
callq 0xc1e0
movq %rax, %rdi
movb -0x9(%rbp), %cl
movl -0x10(%rbp), %edx
movq (%rdi), %rax
andb $0x1, %cl
movzbl %cl, %esi
callq *0x18(%rax)
jmp 0x1b3d3
movq -0x18(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1b3d1
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1e0
movq %rax, %rdi
movb -0x9(%rbp), %cl
movl -0x10(%rbp), %edx
movq (%rdi), %rax
andb $0x1, %cl
movzbl %cl, %esi
callq *0x18(%rax)
jmp 0x1b3d3
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x44(%rax)
jne 0x1b64b
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1b649
movq -0x20(%rbp), %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1b624
jmp 0x1b67d
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1b67b
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1b652
jmp 0x1b67d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x44(%rax)
jne 0x1b6db
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1b6d9
movq -0x20(%rbp), %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1b6b4
jmp 0x1b70d
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1b70b
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1b6e2
jmp 0x1b70d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpl $0x0, 0x44(%rax)
jne 0x1b79e
movq -0x68(%rbp), %rdi
callq 0xc1e0
movq -0x70(%rbp), %rsi
movq %rax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x6180
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq (%rdi), %rax
movq 0x80(%rax), %rax
callq *%rax
jmp 0x1b779
leaq -0x30(%rbp), %rdi
callq 0x6230
jmp 0x1b810
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6230
jmp 0x1b819
movq -0x68(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1b80e
movq -0x68(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1e0
movq -0x70(%rbp), %rsi
movq %rax, -0x90(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x6180
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq (%rdi), %rax
movq 0x80(%rax), %rax
callq *%rax
jmp 0x1b7ec
leaq -0x60(%rbp), %rdi
callq 0x6230
jmp 0x1b80e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x6230
jmp 0x1b819
jmp 0x1b810
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6630
nopw %cs:(%rax,%rax)
// File: MatthewZMD[P]TetrisDual/game.cc
// Function: Game::random()
void Game::random() {
    if (playerTurn == 0) {
        board1->random();
    }
    else if (playerTurn == 1) {
        board2->random();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x44(%rax)
jne 0x1b861
movq -0x10(%rbp), %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x88(%rax)
jmp 0x1b886
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1b884
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x88(%rax)
jmp 0x1b886
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x7, -0x14(%rbp)
leaq 0x1205f(%rip), %rsi     # 0x2d924
callq 0x7230
testb $0x1, %al
jne 0x1b8d0
jmp 0x1b8dc
movl $0x0, -0x14(%rbp)
jmp 0x1b9a6
movq -0x28(%rbp), %rdi
leaq 0x12041(%rip), %rsi     # 0x2d928
callq 0x7230
testb $0x1, %al
jne 0x1b8f2
jmp 0x1b8fe
movl $0x1, -0x14(%rbp)
jmp 0x1b9a4
movq -0x28(%rbp), %rdi
leaq 0x1200b(%rip), %rsi     # 0x2d914
callq 0x7230
testb $0x1, %al
jne 0x1b914
jmp 0x1b920
movl $0x2, -0x14(%rbp)
jmp 0x1b9a2
movq -0x28(%rbp), %rdi
leaq 0x11fec(%rip), %rsi     # 0x2d917
callq 0x7230
testb $0x1, %al
jne 0x1b936
jmp 0x1b93f
movl $0x3, -0x14(%rbp)
jmp 0x1b9a0
movq -0x28(%rbp), %rdi
leaq 0x11fd1(%rip), %rsi     # 0x2d91b
callq 0x7230
testb $0x1, %al
jne 0x1b955
jmp 0x1b95e
movl $0x4, -0x14(%rbp)
jmp 0x1b99e
movq -0x28(%rbp), %rdi
leaq 0x11fc7(%rip), %rsi     # 0x2d930
callq 0x7230
testb $0x1, %al
jne 0x1b974
jmp 0x1b97d
movl $0x5, -0x14(%rbp)
jmp 0x1b99c
movq -0x28(%rbp), %rdi
leaq 0x11fab(%rip), %rsi     # 0x2d933
callq 0x7230
testb $0x1, %al
jne 0x1b993
jmp 0x1b99a
movl $0x6, -0x14(%rbp)
jmp 0x1b99c
jmp 0x1b99e
jmp 0x1b9a0
jmp 0x1b9a2
jmp 0x1b9a4
jmp 0x1b9a6
movq -0x20(%rbp), %rax
cmpl $0x0, 0x44(%rax)
jne 0x1b9ca
movq -0x20(%rbp), %rdi
callq 0xc1e0
movq %rax, %rdi
movl -0x14(%rbp), %esi
movq (%rdi), %rax
callq *0x90(%rax)
jmp 0x1b9e6
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1e0
movq %rax, %rdi
movl -0x14(%rbp), %esi
movq (%rdi), %rax
callq *0x90(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: MatthewZMD[P]TetrisDual/game.cc
// Function: Game::isAutoDrop() const
bool Game::isAutoDrop() const {
    if (playerTurn == 0) {
        return board1->getCountD() > 0;
    } else if (playerTurn == 1) {
        return board2->getCountD() > 0;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x44(%rax)
jne 0x1ba2c
movq -0x18(%rbp), %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x98(%rax)
cmpl $0x0, %eax
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1ba62
movq -0x18(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1ba5c
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x98(%rax)
cmpl $0x0, %eax
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1ba62
jmp 0x1ba5e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x30, %rdi
callq 0xc1e0
movq %rax, %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rdi
movl $0x0, -0x10(%rbp)
addq $0x30, %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x20(%rax)
testb $0x1, %al
jne 0x20bc4
jmp 0x20be3
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x20(%rax)
testb $0x1, %al
jne 0x20bfc
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x25430
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x30, %rdi
callq 0xc1e0
movq %rax, %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rdi
movl $0x0, -0x10(%rbp)
addq $0x30, %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x20(%rax)
testb $0x1, %al
jne 0x20c64
jmp 0x20c83
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x20(%rax)
testb $0x1, %al
jne 0x20c9c
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0xc1e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x25430
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: MatthewZMD[P]TetrisDual/level1.cc
// Function: Level1::genBlock()
CellType Level1::genBlock() {
	if (readFromFile) {
		return genBlockFromFile();
	}
	const CellType types[12] = {
		CellType::S,
		CellType::Z,
		CellType::I,
		CellType::I,
		CellType::J,
		CellType::J,
		CellType::L,
		CellType::L,
		CellType::O,
		CellType::O,
		CellType::T,
		CellType::T
	};
	return types[rand() % 12];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
testb $0x1, 0x30(%rax)
je 0x21f88
movq -0x48(%rbp), %rdi
callq 0x24950
movl %eax, -0x4(%rbp)
jmp 0x21fb4
leaq -0x40(%rbp), %rdi
leaq 0xb7bd(%rip), %rsi      # 0x2d750
movl $0x30, %edx
callq 0x62e0
callq 0x60c0
movl $0xc, %ecx
cltd
idivl %ecx
movslq %edx, %rax
movl -0x40(%rbp,%rax,4), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: MatthewZMD[P]TetrisDual/level2.cc
// Function: Level2::genBlock()
CellType Level2::genBlock() {
	if (readFromFile) {
		return genBlockFromFile();
	}
	const CellType types[7] = {
		CellType::I,
		CellType::J,
		CellType::L,
		CellType::O,
		CellType::S,
		CellType::Z,
		CellType::T
	};
	return types[rand() % 7];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, 0x30(%rax)
je 0x22c08
movq -0x38(%rbp), %rdi
callq 0x24950
movl %eax, -0x4(%rbp)
jmp 0x22c49
movq 0xabd1(%rip), %rax      # 0x2d7e0
movq %rax, -0x30(%rbp)
movq 0xabce(%rip), %rax      # 0x2d7e8
movq %rax, -0x28(%rbp)
movq 0xabcb(%rip), %rax      # 0x2d7f0
movq %rax, -0x20(%rbp)
movl 0xabc9(%rip), %eax      # 0x2d7f8
movl %eax, -0x18(%rbp)
callq 0x60c0
movl $0x7, %ecx
cltd
idivl %ecx
movslq %edx, %rax
movl -0x30(%rbp,%rax,4), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MatthewZMD[P]TetrisDual/level3.cc
// Function: Level3::genBlock()
CellType Level3::genBlock() {
	if (readFromFile) {
		return genBlockFromFile();
	}
	const CellType types[9] = {
		CellType::I,
		CellType::J,
		CellType::L,
		CellType::O,
		CellType::T,
		CellType::S,
		CellType::Z
	};
	return types[rand() % 9];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
testb $0x1, 0x30(%rax)
je 0x238a8
movq -0x48(%rbp), %rdi
callq 0x24950
movl %eax, -0x4(%rbp)
jmp 0x238f9
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x24, %edx
callq 0x61e0
movl $0x1, -0x3c(%rbp)
movl $0x2, -0x38(%rbp)
movl $0x3, -0x34(%rbp)
movl $0x6, -0x30(%rbp)
movl $0x4, -0x2c(%rbp)
movl $0x5, -0x28(%rbp)
callq 0x60c0
movl $0x9, %ecx
cltd
idivl %ecx
movslq %edx, %rax
movl -0x40(%rbp,%rax,4), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MatthewZMD[P]TetrisDual/level.cc
// Function: Level::setReadFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Level::setReadFromFile(std::string fileName) {
	readFromFile = true;

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

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

	fin.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rsi, -0x240(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x248(%rbp)
movb $0x1, 0x30(%rax)
leaq -0x218(%rbp), %rdi
movq %rdi, -0x238(%rbp)
callq 0x6400
movq -0x240(%rbp), %rdi
callq 0x6170
movq -0x238(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x6250
jmp 0x2477e
movq -0x248(%rbp), %rdi
addq $0x38, %rdi
callq 0x249d0
movl $0x0, -0x22c(%rbp)
leaq -0x218(%rbp), %rdi
leaq -0x225(%rbp), %rsi
callq 0x64b0
movq %rax, -0x250(%rbp)
jmp 0x247b4
movq -0x250(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6480
movb %al, -0x251(%rbp)
jmp 0x247d2
movb -0x251(%rbp), %al
testb $0x1, %al
jne 0x247e1
jmp 0x248a7
movsbl -0x225(%rbp), %eax
addl $-0x49, %eax
movl %eax, %ecx
movq %rcx, -0x260(%rbp)
subl $0x11, %eax
ja 0x24889
movq -0x260(%rbp), %rax
leaq 0x909d(%rip), %rcx      # 0x2d8a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x60a0
jmp 0x248d8
movl $0x0, -0x22c(%rbp)
jmp 0x24889
movl $0x1, -0x22c(%rbp)
jmp 0x24889
movl $0x2, -0x22c(%rbp)
jmp 0x24889
movl $0x3, -0x22c(%rbp)
jmp 0x24889
movl $0x4, -0x22c(%rbp)
jmp 0x24889
movl $0x5, -0x22c(%rbp)
jmp 0x24889
movl $0x6, -0x22c(%rbp)
movq -0x248(%rbp), %rdi
addq $0x38, %rdi
leaq -0x22c(%rbp), %rsi
callq 0x249f0
jmp 0x248a2
jmp 0x24798
movq -0x248(%rbp), %rax
movl $0x0, 0x50(%rax)
leaq -0x218(%rbp), %rdi
callq 0x6070
jmp 0x248c3
leaq -0x218(%rbp), %rdi
callq 0x60a0
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x6630
nopw %cs:(%rax,%rax)
// File: MatthewZMD[P]TetrisDual/textdisplay.cc
// Function: TextDisplay::notify(Subject&)
void TextDisplay::notify(Subject & s) {
	Board & b = dynamic_cast<Board&>(s);
	BoardInfo &bi = dynamic_cast<BoardInfo&>(b.getInfo());

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1d3ad(%rip), %rsi     # 0x43140
leaq 0x1d4a6(%rip), %rdx     # 0x43240
xorl %eax, %eax
movl %eax, %ecx
callq 0x63f0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x25db2
callq 0x6690
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %rdi
leaq 0x1dbd3(%rip), %rsi     # 0x439a0
leaq 0x1d57c(%rip), %rdx     # 0x43350
xorl %eax, %eax
movl %eax, %ecx
callq 0x63f0
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x25dec
callq 0x6690
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x58(%rbp)
addq $0x8, %rdi
movslq -0x24(%rbp), %rsi
callq 0x26ca0
movl -0x58(%rbp), %ecx
movq -0x38(%rbp), %rdi
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x54(%rbp)
addq $0x20, %rdi
movslq -0x24(%rbp), %rsi
callq 0x26ca0
movl -0x54(%rbp), %ecx
movq -0x38(%rbp), %rdi
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x50(%rbp)
addq $0x38, %rdi
movslq -0x24(%rbp), %rsi
callq 0x26b20
movq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x26ce0
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x44(%rbp)
addq $0x50, %rdi
movslq -0x24(%rbp), %rsi
callq 0x24a70
movl -0x44(%rbp), %ecx
movl %ecx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)