LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: matengyue[P]Similar_test_demo/./src/cosSimilar.h
// Function: cosSimilar(int, int*, int*)
double cosSimilar(int dimension, int vector_A[], int vector_B[]){
    double score = 0;
    double sum = 0;
    double sq_A = 0, sq_B = 0;

    for (int i = 0; i < dimension; i++){
        sum += vector_A[i] * vector_B[i];
        sq_A += vector_A[i] * vector_A[i];
        sq_B += vector_B[i] * vector_B[i];
    }

    score = sum / (sqrt(sq_A) * sqrt(sq_B));

    return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x25df
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
imull (%rcx,%rdx,4), %eax
cvtsi2sd %eax, %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
imull (%rcx,%rdx,4), %eax
cvtsi2sd %eax, %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
imull (%rcx,%rdx,4), %eax
cvtsi2sd %eax, %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x255a
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x21e0
movsd %xmm0, -0x50(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x21e0
movsd -0x50(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x48(%rbp), %xmm0
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: matengyue[P]Similar_test_demo/./src/deleteStopWords.h
// Function: ReadAllLinesFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
vector<string> ReadAllLinesFromFile(const string &fn){
    vector<string> result;
    ifstream ifs(fn);

    //文件异常
    if (!ifs){
        throw runtime_error("Cannot open file!");
    }
    string tmp;
    while (ifs){
        getline(ifs, tmp);
        result.push_back(tmp);
    }
    result.erase(result.end() - 1);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x280(%rbp)
movq %rdi, %rax
movq %rax, -0x278(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3c70
movq -0x10(%rbp), %rsi
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0x2340
jmp 0x2bb4
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x2130
movb %al, -0x281(%rbp)
jmp 0x2bd4
movb -0x281(%rbp), %al
testb $0x1, %al
jne 0x2be3
jmp 0x2c78
movl $0x10, %edi
callq 0x2140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x290(%rbp)
leaq 0x341f(%rip), %rsi      # 0x6020
callq 0x20d0
jmp 0x2c08
movq -0x290(%rbp), %rdi
movq 0x63da(%rip), %rsi      # 0x8ff0
movq 0x63ab(%rip), %rdx      # 0x8fc8
callq 0x2360
jmp 0x2dcd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x2db5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x2d8b
movq -0x290(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
callq 0x21c0
jmp 0x2d8b
leaq -0x250(%rbp), %rdi
callq 0x2300
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x22d0
movb %al, -0x291(%rbp)
jmp 0x2ca4
movb -0x291(%rbp), %al
testb $0x1, %al
jne 0x2cb0
jmp 0x2cff
leaq -0x220(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x2060
jmp 0x2cc5
movq -0x280(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x3d60
jmp 0x2cda
jmp 0x2c84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x2180
jmp 0x2d8b
movq -0x280(%rbp), %rdi
callq 0x3ea0
movq %rax, -0x268(%rbp)
leaq -0x268(%rbp), %rdi
movl $0x1, %esi
callq 0x3ed0
movq %rax, -0x260(%rbp)
leaq -0x258(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0x3f10
movq -0x280(%rbp), %rdi
movq -0x258(%rbp), %rsi
callq 0x3e30
movq %rax, -0x2a0(%rbp)
jmp 0x2d59
movq -0x2a0(%rbp), %rax
movq %rax, -0x270(%rbp)
movb $0x1, -0x11(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x2180
leaq -0x220(%rbp), %rdi
callq 0x2080
testb $0x1, -0x11(%rbp)
jne 0x2da5
jmp 0x2d99
leaq -0x220(%rbp), %rdi
callq 0x2080
jmp 0x2db5
movq -0x280(%rbp), %rdi
callq 0x3dd0
movq -0x278(%rbp), %rax
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x280(%rbp), %rdi
callq 0x3dd0
movq -0x228(%rbp), %rdi
callq 0x2380
nopl (%rax)
// File: jaldhar[P]Lets-Build-a-Simple-Interpreter/calc2.cc
// Function: operator<<(std::ostream&, TOKENTYPE const&)
ostream& operator<<(ostream& out, const TOKENTYPE& t) {
    string repr;
    switch(t) {
        case TOKENTYPE::ENDOFFILE:
            repr = "ENDOFFILE";
            break;
        case TOKENTYPE::INTEGER:
            repr = "INTEGER";
            break;
        case TOKENTYPE::PLUS:
            repr = "PLUS";
            break;
        case TOKENTYPE::MINUS:
            repr = "MINUS";
            break;
        case TOKENTYPE::TIMES:
            repr = "TIMES";
            break;
        case TOKENTYPE::DIVIDE:
            repr = "DIVIDE";
            break;
    }

    out << repr;
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2240
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x48(%rbp)
subq $0x5, %rax
ja 0x2523
movq -0x48(%rbp), %rax
leaq 0x1b7c(%rip), %rcx      # 0x4004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1b9c(%rip), %rsi      # 0x4034
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x24a3
jmp 0x2523
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20e0
jmp 0x254d
leaq 0x1b78(%rip), %rsi      # 0x403e
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x24d1
jmp 0x2523
leaq 0x1b6c(%rip), %rsi      # 0x4046
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x24e5
jmp 0x2523
leaq 0x1b5d(%rip), %rsi      # 0x404b
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x24f9
jmp 0x2523
leaq 0x1b4f(%rip), %rsi      # 0x4051
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x250d
jmp 0x2523
leaq 0x1b41(%rip), %rsi      # 0x4057
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x2521
jmp 0x2523
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2160
jmp 0x2532
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20e0
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: jaldhar[P]Lets-Build-a-Simple-Interpreter/calc2.cc
// Function: Interpreter::subtract(long)
long Interpreter::subtract(long left_value) {
    // we expect the current token to be an integer
    Token right = _current_token;
    eat(TOKENTYPE::INTEGER);
    // after the above call _current_token is set to ENDOFFILE token

    // at this point INTEGER MINUS INTEGER sequence of tokens has been
    // successfully found and the method can just return the result of
    // subtracting two integers, thus effectively interpreting client input
    return left_value - right.value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq 0x18(%rdi), %rax
movq %rax, -0x20(%rbp)
movq 0x20(%rdi), %rax
movq %rax, -0x18(%rbp)
movl $0x1, %esi
callq 0x2c10
movq -0x10(%rbp), %rax
subq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jaldhar[P]Lets-Build-a-Simple-Interpreter/calc2.cc
// Function: Interpreter::divide(long)
long  Interpreter::divide(long left_value) {
    // we expect the current token to be an integer
    Token right = _current_token;
    eat(TOKENTYPE::INTEGER);

    // Handle division by 0
    if (right.value == 0) {
        throw("Division by zero");
    }
    // after the above call _current_token is set to ENDOFFILE token

    // at this point INTEGER TIMES INTEGER sequence of tokens has been
    // successfully found and the method can just return the result of
    // dividing two integers, thus effectively interpreting client input
    return left_value / right.value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq 0x18(%rdi), %rax
movq %rax, -0x20(%rbp)
movq 0x20(%rdi), %rax
movq %rax, -0x18(%rbp)
movl $0x1, %esi
callq 0x2c10
cmpq $0x0, -0x18(%rbp)
jne 0x2eac
movl $0x8, %edi
callq 0x20c0
movq %rax, %rdi
leaq 0x11fc(%rip), %rax      # 0x4095
movq %rax, (%rdi)
movq 0x310d(%rip), %rsi      # 0x5fb0
xorl %eax, %eax
movl %eax, %edx
callq 0x22a0
movq -0x10(%rbp), %rax
cqto
idivq -0x18(%rbp)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: nmmmnu[P]HM3/hm3/test/test_pair.cc
// Function: main
int main(int argc, char **argv){
	pair_test_null();
	pair_test_raw();
	pair_test();
	pair_test_expired();

	return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
leaq 0x4d08(%rip), %rdi      # 0x6004
callq 0x1330
leaq 0x4d06(%rip), %rdi      # 0x600e
callq 0x1520
leaq 0x4d0b(%rip), %rdi      # 0x601f
callq 0x1810
leaq 0x4cf7(%rip), %rdi      # 0x6017
xorl %esi, %esi
callq 0x23c0
xorl %eax, %eax
addq $0x18, %rsp
retq
nop
// File: nmmmnu[P]HM3/hm3/test/test_pair.cc
// Function: pair_test_null(char const*)
static void pair_test_null(const char *module){
	const Pair p{};

	p.print();

	PRINTF_TEST("null bool",	p == false			);
//	PRINTF_TEST("null isNULL",	p.isNULL()			);
	PRINTF_TEST("null isTombstone",	p.isTombstone()			);
	PRINTF_TEST("null key",		p.getKey().empty()		);
	PRINTF_TEST("null val",		p.getVal().empty()		);
	PRINTF_TEST("null cmp",		p.cmp("bla") == 1		);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq $0x0, 0x68(%rsp)
leaq 0x68(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x3230
movq 0x28(%rsp), %rdi
callq 0x3c00
movq 0x28(%rsp), %rdi
movq 0x70(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0x3240
movq 0x30(%rsp), %rsi
movb %al, %dl
leaq 0x4ce8(%rip), %rax      # 0x6065
leaq 0x4cde(%rip), %rcx      # 0x6062
testb %dl, %dl
cmovneq %rax, %rcx
leaq 0x4ca9(%rip), %rdi      # 0x603a
leaq 0x4d02(%rip), %rdx      # 0x609a
xorl %eax, %eax
callq 0x1030
jmp 0x13a1
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x3b00
movq 0x20(%rsp), %rsi
movb %al, %dl
leaq 0x4c9f(%rip), %rax      # 0x6062
leaq 0x4c9b(%rip), %rcx      # 0x6065
testb %dl, %dl
cmovneq %rax, %rcx
leaq 0x4c63(%rip), %rdi      # 0x603a
leaq 0x4cc6(%rip), %rdx      # 0x60a4
xorl %eax, %eax
callq 0x1030
jmp 0x13e7
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x37a0
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x3260
movq 0x18(%rsp), %rsi
movb %al, %dl
leaq 0x4c45(%rip), %rax      # 0x6062
leaq 0x4c41(%rip), %rcx      # 0x6065
testb %dl, %dl
cmovneq %rax, %rcx
leaq 0x4c09(%rip), %rdi      # 0x603a
leaq 0x4c7d(%rip), %rdx      # 0x60b5
xorl %eax, %eax
callq 0x1030
jmp 0x1441
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x3830
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x3260
movq 0x10(%rsp), %rsi
movb %al, %dl
leaq 0x4beb(%rip), %rax      # 0x6062
leaq 0x4be7(%rip), %rcx      # 0x6065
testb %dl, %dl
cmovneq %rax, %rcx
leaq 0x4baf(%rip), %rdi      # 0x603a
leaq 0x4c2c(%rip), %rdx      # 0x60be
xorl %eax, %eax
callq 0x1030
jmp 0x149b
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x4c24(%rip), %rsi      # 0x60d0
leaq 0x68(%rsp), %rdi
callq 0x3970
movq 0x8(%rsp), %rsi
subl $0x1, %eax
leaq 0x4b9d(%rip), %rax      # 0x6062
leaq 0x4b99(%rip), %rcx      # 0x6065
cmoveq %rax, %rcx
leaq 0x4b63(%rip), %rdi      # 0x603a
leaq 0x4be9(%rip), %rdx      # 0x60c7
xorl %eax, %eax
callq 0x1030
jmp 0x14e7
leaq 0x68(%rsp), %rdi
callq 0x35c0
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x35c0
movq 0x60(%rsp), %rdi
callq 0x1170
nopl (%rax,%rax)
// File: nmmmnu[P]HM3/hm3/test/test_pair.cc
// Function: pair_test_expired(char const*, bool)
static void pair_test_expired(const char *module, bool sl){
	const Pair p1 = { "key", "val", 1 };

	PRINTF_TEST("not expired",	p1.valid()			);

	if (sl){
		printf("sleep for 2 sec...\n");
		sleep(2);
		PRINTF_TEST("expired",		! p1.valid()		);
	}

	const Pair p2 = { "key", "val", 1, 3600 * 24 /* 1970-01-02 */ };
	PRINTF_TEST("expired",		! p2.valid()			);
}

// Assembly:
subq $0xb8, %rsp
movb %sil, %al
movq %rdi, 0xb0(%rsp)
andb $0x1, %al
movb %al, 0xaf(%rsp)
leaq 0x3cd8(%rip), %rsi      # 0x60ba
leaq 0x90(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x2bd0
leaq 0x3cc8(%rip), %rsi      # 0x60c3
leaq 0x80(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x2bd0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movl $0x1, %ecx
xorl %r8d, %r8d
movl %r8d, 0x44(%rsp)
callq 0x3630
movq 0x30(%rsp), %rdi
movl 0x44(%rsp), %esi
movq 0xb0(%rsp), %rax
movq %rax, 0x38(%rsp)
callq 0x3b50
movq 0x38(%rsp), %rsi
movb %al, %dil
movl 0x44(%rsp), %eax
leaq 0x3bfe(%rip), %rdx      # 0x6062
leaq 0x3bfa(%rip), %rcx      # 0x6065
testb %dil, %dil
cmovneq %rdx, %rcx
leaq 0x3bc1(%rip), %rdi      # 0x603a
leaq 0x3cd4(%rip), %rdx      # 0x6154
callq 0x1030
jmp 0x2487
testb $0x1, 0xaf(%rsp)
je 0x251c
leaq 0x3cc4(%rip), %rdi      # 0x6160
xorl %eax, %eax
callq 0x1030
jmp 0x24a5
movl $0x2, %edi
callq 0x10e0
jmp 0x24b1
movq 0xb0(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xa0(%rsp), %rdi
xorl %esi, %esi
movl %esi, 0x1c(%rsp)
callq 0x3b50
movq 0x10(%rsp), %rsi
movb %al, %dil
movl 0x1c(%rsp), %eax
leaq 0x3b81(%rip), %rdx      # 0x6065
leaq 0x3b77(%rip), %rcx      # 0x6062
testb %dil, %dil
cmovneq %rdx, %rcx
leaq 0x3b41(%rip), %rdi      # 0x603a
leaq 0x3c58(%rip), %rdx      # 0x6158
callq 0x1030
jmp 0x2507
jmp 0x251c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x25eb
leaq 0x3b97(%rip), %rsi      # 0x60ba
leaq 0x58(%rsp), %rdi
callq 0x2bd0
jmp 0x252f
leaq 0x3b8d(%rip), %rsi      # 0x60c3
leaq 0x48(%rsp), %rdi
callq 0x2bd0
jmp 0x2542
leaq 0x68(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movl $0x1, %ecx
movl $0x15180, %r8d          # imm = 0x15180
callq 0x3630
jmp 0x2563
movq 0xb0(%rsp), %rax
movq %rax, (%rsp)
leaq 0x68(%rsp), %rdi
xorl %esi, %esi
movl %esi, 0xc(%rsp)
callq 0x3b50
movq (%rsp), %rsi
movb %al, %dil
movl 0xc(%rsp), %eax
leaq 0x3ad4(%rip), %rdx      # 0x6065
leaq 0x3aca(%rip), %rcx      # 0x6062
testb %dil, %dil
cmovneq %rdx, %rcx
leaq 0x3a94(%rip), %rdi      # 0x603a
leaq 0x3bab(%rip), %rdx      # 0x6158
callq 0x1030
jmp 0x25b4
leaq 0x68(%rsp), %rdi
callq 0x35c0
leaq 0xa0(%rsp), %rdi
callq 0x35c0
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x35c0
leaq 0xa0(%rsp), %rdi
callq 0x35c0
movq 0x78(%rsp), %rdi
callq 0x1170
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]HM3/hm3/test/test_pair.cc
// Function: pair_blob_test(char const*, hm3::PairBlob const&, StringRef const&, StringRef const&)
static void pair_blob_test(const char *module, const PairBlob & p, const StringRef &key, const StringRef &val){
	PRINTF_TEST("valid",		p.valid()			);

	PRINTF_TEST("key",		key == p.getKey()		);
	PRINTF_TEST("val",		val == p.getVal()		);

	PRINTF_TEST("cmp key",		p.cmp(key.data()) == 0		);
	PRINTF_TEST("cmp",		p.cmp("~~~ non existent") < 0	);
	PRINTF_TEST("cmp",		p.cmp("!!! non existent") > 0	);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0x4c60
movq (%rsp), %rsi
movb %al, %dl
leaq 0x3a1b(%rip), %rcx      # 0x6065
leaq 0x3a11(%rip), %rax      # 0x6062
testb $0x1, %dl
cmovneq %rax, %rcx
leaq 0x39db(%rip), %rdi      # 0x603a
leaq 0x3a04(%rip), %rdx      # 0x606a
movb $0x0, %al
callq 0x1030
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0x2ca0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2c50
movq 0x10(%rsp), %rsi
movb %al, %dl
leaq 0x39bf(%rip), %rcx      # 0x6065
leaq 0x39b5(%rip), %rax      # 0x6062
testb $0x1, %dl
cmovneq %rax, %rcx
leaq 0x397f(%rip), %rdi      # 0x603a
leaq 0x39f8(%rip), %rdx      # 0x60ba
movb $0x0, %al
callq 0x1030
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
callq 0x2cb0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x2c50
movq 0x20(%rsp), %rsi
movb %al, %dl
leaq 0x3963(%rip), %rcx      # 0x6065
leaq 0x3959(%rip), %rax      # 0x6062
testb $0x1, %dl
cmovneq %rax, %rcx
leaq 0x3923(%rip), %rdi      # 0x603a
leaq 0x39a5(%rip), %rdx      # 0x60c3
movb $0x0, %al
callq 0x1030
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
callq 0x2db0
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x2d10
movq 0x30(%rsp), %rsi
movl %eax, %edx
leaq 0x3907(%rip), %rcx      # 0x6065
leaq 0x38fd(%rip), %rax      # 0x6062
cmpl $0x0, %edx
cmoveq %rax, %rcx
leaq 0x38c7(%rip), %rdi      # 0x603a
leaq 0x38f6(%rip), %rdx      # 0x6070
movb $0x0, %al
callq 0x1030
movq 0x60(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x38e1(%rip), %rsi      # 0x6078
callq 0x2d10
movq 0x38(%rsp), %rsi
movl %eax, %edx
leaq 0x38bb(%rip), %rcx      # 0x6065
leaq 0x38b1(%rip), %rax      # 0x6062
cmpl $0x0, %edx
cmovlq %rax, %rcx
leaq 0x387b(%rip), %rdi      # 0x603a
leaq 0x3906(%rip), %rdx      # 0x60cc
movb $0x0, %al
callq 0x1030
movq 0x60(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x38a6(%rip), %rsi      # 0x6089
callq 0x2d10
movq 0x40(%rsp), %rsi
movl %eax, %edx
leaq 0x386f(%rip), %rcx      # 0x6065
leaq 0x3865(%rip), %rax      # 0x6062
cmpl $0x0, %edx
cmovgq %rax, %rcx
leaq 0x382f(%rip), %rdi      # 0x603a
leaq 0x38ba(%rip), %rdx      # 0x60cc
movb $0x0, %al
callq 0x1030
addq $0x68, %rsp
retq
nop
// File: iZhangHui[P]CppPrimer/CH19_SpecializedToolsAndTechniques/examples/bitfields.cc
// Function: File::open(File::modes)
File &File::open(File::modes m)
{
	mode |= READ;    // set the READ bit by default
	// other processing
	if (m & WRITE) // if opening READ and WRITE 
	// processing to open the file in read/write mode
	cout << "myFile.mode READ is set" << endl;
	return *this;
}

// 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)
movw (%rax), %cx
andw $0x3, %cx
movzwl %cx, %ecx
orl $0x1, %ecx
movw %cx, %dx
movw (%rax), %cx
andw $0x3, %dx
andw $-0x4, %cx
orw %dx, %cx
movw %cx, (%rax)
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1265
movq 0x2d8e(%rip), %rdi      # 0x3fd8
leaq 0xdb3(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movq 0x2d68(%rip), %rsi      # 0x3fc8
callq 0x1050
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: iZhangHui[P]CppPrimer/CH19_SpecializedToolsAndTechniques/examples/bitfields.cc
// Function: main
int main()
{
	File myFile;
	
	myFile.open(File::READ);
	if (myFile.isRead()) 
		cout << "reading" << endl;
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x1200
leaq -0x8(%rbp), %rdi
callq 0x12d0
testb $0x1, %al
jne 0x129c
jmp 0x12be
movq 0x2d35(%rip), %rdi      # 0x3fd8
leaq 0xd72(%rip), %rsi       # 0x201c
callq 0x1040
movq %rax, %rdi
movq 0x2d0f(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: allasandeep[P]LocationBoundaryFinder/./functions.cc
// Function: delSpaces(char*)
void delSpaces(char *str)
{
	int count = 0;
	//Looping the char array and searching fro empty space
	for(int i = 0; str[i]; i++)
	{
		if(str[i] != ' ')
			str[count++] = str[i];
	}

	str[count] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x2552
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x2545
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x2547
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2506
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
// File: allasandeep[P]LocationBoundaryFinder/./functions.cc
// Function: conn()
PGconn* conn()
{
	//Connecting to the Database with user credentials
	PGconn *db = PQconnectdb("host = 'courses' dbname = 'z1821331' user = 'z1821331'  password = '1996Jun06' ");
	//If the connection fails, print an error message
	if(!(CONNECTION_OK == PQstatus(db)))
	{
		cerr<<"Can't connect to db."<<endl;
		exit(EXIT_FAILURE);
	}
	cout<<"Database Connection Successfull!"<<endl;

	return db;;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x2ad9(%rip), %rdi      # 0x5048
callq 0x21a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20b0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x25b5
movq 0x4a60(%rip), %rdi      # 0x6ff0
leaq 0x2b01(%rip), %rsi      # 0x5098
callq 0x2190
movq %rax, %rdi
movq 0x4a3a(%rip), %rsi      # 0x6fe0
callq 0x2320
movl $0x1, %edi
callq 0x2200
movq 0x4a0c(%rip), %rdi      # 0x6fc8
leaq 0x2aea(%rip), %rsi      # 0x50ad
callq 0x2190
movq %rax, %rdi
movq 0x4a0e(%rip), %rsi      # 0x6fe0
callq 0x2320
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: allasandeep[P]LocationBoundaryFinder/prog1.cc
// Function: openFiles(std::basic_ifstream<char, std::char_traits<char>>&, char*)
void openFiles( ifstream& is, char *fileName)
{
	// opening the input file. 
	is.open(fileName);
	// If the file fails to open,then displays an error message. 
	if(is.fail()) 
	{
		cerr<<"Error Message:: Unable to read" <<fileName<< endl;
		exit(EXIT_FAILURE);
	}		
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x2230
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x2340
testb $0x1, %al
jne 0x2ab8
jmp 0x2af0
movq 0x4531(%rip), %rdi      # 0x6ff0
leaq 0x2697(%rip), %rsi      # 0x515d
callq 0x2190
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x2190
movq %rax, %rdi
movq 0x44ff(%rip), %rsi      # 0x6fe0
callq 0x2320
movl $0x1, %edi
callq 0x2200
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: j-faria[P]kima/examples/CoRoT7/kima_setup.cpp
// Function: main
int main(int argc, char** argv)
{
    datafile = "corot7.txt";

    load(datafile, "ms");

    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(50);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x6f0, %rsp            # imm = 0x6F0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xad598(%rip), %rdi     # 0x11a7b8
movq %rdi, -0x6e8(%rbp)
leaq 0x58783(%rip), %rsi     # 0xc59b1
callq 0x6690
movq -0x6e8(%rbp), %rdi
leaq 0x4a2a8(%rip), %rsi     # 0xb74e9
callq 0x6d950
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x6c8(%rbp), %rdi
movq %rdi, -0x6e0(%rbp)
callq 0x6da70
movq -0x6e0(%rbp), %rdi
movl $0x32, %esi
callq 0x6db10
jmp 0x6d273
movl $0x0, -0x4(%rbp)
leaq -0x6c8(%rbp), %rdi
callq 0x6df30
movl -0x4(%rbp), %eax
addq $0x6f0, %rsp            # imm = 0x6F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x6d0(%rbp)
movl %eax, -0x6d4(%rbp)
leaq -0x6c8(%rbp), %rdi
callq 0x6df30
movq -0x6d0(%rbp), %rdi
callq 0x6830
nopl (%rax)
// File: EstherJin[P]TetrisRemake/basicboard.cc
// Function: BasicBoard::validMove(std::vector<Coordinates, std::allocator<Coordinates>>)
bool BasicBoard::validMove(vector<Coordinates> newPos) {
	for (int i = 0; i < newPos.size(); ++i) {
		int roww = newPos.at(i).row;
		int coll = newPos.at(i).col;
		if ((roww < 0) || (roww > 17) || (coll < 0) || (coll > 10)){
			return false;
		}
		char c = grid.at(roww).at(coll);
		if (c != ' ') return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0xa7e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x8835
movq -0x38(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xa800
movq -0x38(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0xa800
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x87f1
cmpl $0x11, -0x20(%rbp)
jg 0x87f1
cmpl $0x0, -0x24(%rbp)
jl 0x87f1
cmpl $0xa, -0x24(%rbp)
jle 0x87f7
movb $0x0, -0x1(%rbp)
jmp 0x8839
movq -0x30(%rbp), %rdi
addq $0x70, %rdi
movslq -0x20(%rbp), %rsi
callq 0xa840
movq %rax, %rdi
movl -0x24(%rbp), %esi
callq 0x242a0
movb %al, -0x25(%rbp)
movsbl -0x25(%rbp), %eax
cmpl $0x20, %eax
je 0x8825
movb $0x0, -0x1(%rbp)
jmp 0x8839
jmp 0x8827
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8793
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: EstherJin[P]TetrisRemake/basicboard.cc
// Function: BasicBoard::turnBlock(int)
void BasicBoard::turnBlock(int amount) {
	for (int i = 0; i < abs(amount); ++i) {
		bool valid = validMove(currentBlock->turnPos(amount/abs(amount)));
	cout << valid <<endl;
		if (valid) currentBlock->turn(amount/abs(amount));
		else break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
cmpl %ecx, %eax
jge 0x898e
movq -0x48(%rbp), %rdi
addq $0xb8, %rdi
callq 0xa550
movq %rax, %rsi
movl -0xc(%rbp), %eax
movl %eax, %edx
negl %edx
movl %eax, %ecx
cmovnsl %edx, %ecx
cltd
idivl %ecx
movl %eax, %edx
movq (%rsi), %rax
movq 0x28(%rax), %rax
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq *%rax
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq (%rdi), %rax
movq 0x50(%rax), %rax
callq *%rax
movb %al, -0x49(%rbp)
jmp 0x88fe
leaq -0x30(%rbp), %rdi
callq 0xa880
movb -0x49(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movq 0x396a7(%rip), %rdi     # 0x41fc0
andb $0x1, %al
movzbl %al, %esi
callq 0x65e0
movq %rax, %rdi
movq 0x39673(%rip), %rsi     # 0x41fa0
callq 0x63c0
testb $0x1, -0x11(%rbp)
je 0x897c
movq -0x48(%rbp), %rdi
addq $0xb8, %rdi
callq 0xa550
movq %rax, %rdi
movl -0xc(%rbp), %eax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
cltd
idivl %ecx
movl %eax, %esi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x897e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa880
jmp 0x8994
jmp 0x898e
jmp 0x8980
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x889e
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x65c0
nopl (%rax)
// File: EstherJin[P]TetrisRemake/basicboard.cc
// Function: BasicBoard::moveBlock(int)
void BasicBoard::moveBlock(int amount) {
	for (int i = 0; i < abs(amount); ++i) {
		bool valid = validMove(currentBlock->movePos(amount/abs(amount)));
		if (valid) currentBlock->move(amount/abs(amount));
		else break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
cmpl %ecx, %eax
jge 0x8a8b
movq -0x48(%rbp), %rdi
addq $0xb8, %rdi
callq 0xa550
movq %rax, %rsi
movl -0xc(%rbp), %eax
movl %eax, %edx
negl %edx
movl %eax, %ecx
cmovnsl %edx, %ecx
cltd
idivl %ecx
movl %eax, %edx
movq (%rsi), %rax
movq 0x20(%rax), %rax
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq *%rax
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq (%rdi), %rax
movq 0x50(%rax), %rax
callq *%rax
movb %al, -0x49(%rbp)
jmp 0x8a1e
leaq -0x30(%rbp), %rdi
callq 0xa880
movb -0x49(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x8a79
movq -0x48(%rbp), %rdi
addq $0xb8, %rdi
callq 0xa550
movq %rax, %rdi
movl -0xc(%rbp), %eax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
cltd
idivl %ecx
movl %eax, %esi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x8a7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa880
jmp 0x8a91
jmp 0x8a8b
jmp 0x8a7d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x89be
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x65c0
nopw (%rax,%rax)
// File: EstherJin[P]TetrisRemake/basicboard.cc
// Function: BasicBoard::downBlock(int)
void BasicBoard::downBlock(int amount) {
	for (int i = 0; i < abs(amount); ++i) {
		bool valid = validMove(currentBlock->downPos(1));
		if (valid) {
			currentBlock->down(1);
		}
		else break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
cmpl %ecx, %eax
jge 0x8b6d
movq -0x48(%rbp), %rdi
addq $0xb8, %rdi
callq 0xa550
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x1, %edx
callq 0x134a0
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq (%rdi), %rax
movq 0x50(%rax), %rax
callq *%rax
movb %al, -0x49(%rbp)
jmp 0x8b0e
leaq -0x30(%rbp), %rdi
callq 0xa880
movb -0x49(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x8b5b
movq -0x48(%rbp), %rdi
addq $0xb8, %rdi
callq 0xa550
movq %rax, %rdi
movl $0x1, %esi
callq 0x13350
jmp 0x8b5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa880
jmp 0x8b73
jmp 0x8b6d
jmp 0x8b5f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8abe
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x65c0
nopl (%rax)
// File: EstherJin[P]TetrisRemake/basicboard.cc
// Function: BasicBoard::getNextBlock()
void BasicBoard::getNextBlock() {
	if (!nextBlock) {
		char type = lvl->nextBlock();
		if (type == 'I') nextBlock = make_unique<I>();
		else if (type == 'J') nextBlock = make_unique<J>();
		else if (type == 'L') nextBlock = make_unique<L>();
		else if (type == 'O') nextBlock = make_unique<O>();
		else if (type == 'S') nextBlock = make_unique<S>();
		else if (type == 'Z') nextBlock = make_unique<Z>();
		else nextBlock = make_unique<T>();
		gd.printNext(' ');
		gd.printNext(type);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x98, %rdi
callq 0xa790
testb $0x1, %al
jne 0x9969
movq -0x50(%rbp), %rdi
addq $0x90, %rdi
callq 0xa7c0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x49, %eax
jne 0x9818
leaq -0x18(%rbp), %rdi
callq 0xafb0
movq -0x50(%rbp), %rdi
addq $0x98, %rdi
leaq -0x18(%rbp), %rsi
callq 0xb020
leaq -0x18(%rbp), %rdi
callq 0xb080
jmp 0x9946
movsbl -0x9(%rbp), %eax
cmpl $0x4a, %eax
jne 0x984c
leaq -0x20(%rbp), %rdi
callq 0xb0e0
movq -0x50(%rbp), %rdi
addq $0x98, %rdi
leaq -0x20(%rbp), %rsi
callq 0xb150
leaq -0x20(%rbp), %rdi
callq 0xb1b0
jmp 0x9944
movsbl -0x9(%rbp), %eax
cmpl $0x4c, %eax
jne 0x9880
leaq -0x28(%rbp), %rdi
callq 0xb210
movq -0x50(%rbp), %rdi
addq $0x98, %rdi
leaq -0x28(%rbp), %rsi
callq 0xb280
leaq -0x28(%rbp), %rdi
callq 0xb2e0
jmp 0x9942
movsbl -0x9(%rbp), %eax
cmpl $0x4f, %eax
jne 0x98b4
leaq -0x30(%rbp), %rdi
callq 0xb340
movq -0x50(%rbp), %rdi
addq $0x98, %rdi
leaq -0x30(%rbp), %rsi
callq 0xb3b0
leaq -0x30(%rbp), %rdi
callq 0xb410
jmp 0x9940
movsbl -0x9(%rbp), %eax
cmpl $0x53, %eax
jne 0x98e5
leaq -0x38(%rbp), %rdi
callq 0xb470
movq -0x50(%rbp), %rdi
addq $0x98, %rdi
leaq -0x38(%rbp), %rsi
callq 0xb4e0
leaq -0x38(%rbp), %rdi
callq 0xb540
jmp 0x993e
movsbl -0x9(%rbp), %eax
cmpl $0x5a, %eax
jne 0x9916
leaq -0x40(%rbp), %rdi
callq 0xb5a0
movq -0x50(%rbp), %rdi
addq $0x98, %rdi
leaq -0x40(%rbp), %rsi
callq 0xb610
leaq -0x40(%rbp), %rdi
callq 0xb670
jmp 0x993c
leaq -0x48(%rbp), %rdi
callq 0xb6d0
movq -0x50(%rbp), %rdi
addq $0x98, %rdi
leaq -0x48(%rbp), %rsi
callq 0xb740
leaq -0x48(%rbp), %rdi
callq 0xb7a0
jmp 0x993e
jmp 0x9940
jmp 0x9942
jmp 0x9944
jmp 0x9946
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
movl $0x20, %esi
callq 0x2ba30
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
movsbl -0x9(%rbp), %esi
callq 0x2ba30
addq $0x50, %rsp
popq %rbp
retq
nop
// File: EstherJin[P]TetrisRemake/basicboard.cc
// Function: BasicBoard::changeCurrentBlock(char)
void BasicBoard::changeCurrentBlock(char type) {
	if (type == 'I') currentBlock = make_unique<I>();
	else if (type == 'J') currentBlock = make_unique<J>();
	else if (type == 'L') currentBlock = make_unique<L>();
	else if (type == 'O') currentBlock = make_unique<O>();
	else if (type == 'S') currentBlock = make_unique<S>();
	else if (type == 'Z') currentBlock = make_unique<Z>();
	//else if (type == '.') currentBlock = make_unique<Dot>();
	else currentBlock = make_unique<T>();
	currentBlock->attach(&sg);
	if (!textOnly) currentBlock->attach(&gd);
	currentBlock->notifCurrPos();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x49, %eax
jne 0x9b8e
leaq -0x18(%rbp), %rdi
callq 0xafb0
movq -0x50(%rbp), %rdi
addq $0xb8, %rdi
leaq -0x18(%rbp), %rsi
callq 0xb020
leaq -0x18(%rbp), %rdi
callq 0xb080
jmp 0x9cbc
movsbl -0x9(%rbp), %eax
cmpl $0x4a, %eax
jne 0x9bc2
leaq -0x20(%rbp), %rdi
callq 0xb0e0
movq -0x50(%rbp), %rdi
addq $0xb8, %rdi
leaq -0x20(%rbp), %rsi
callq 0xb150
leaq -0x20(%rbp), %rdi
callq 0xb1b0
jmp 0x9cba
movsbl -0x9(%rbp), %eax
cmpl $0x4c, %eax
jne 0x9bf6
leaq -0x28(%rbp), %rdi
callq 0xb210
movq -0x50(%rbp), %rdi
addq $0xb8, %rdi
leaq -0x28(%rbp), %rsi
callq 0xb280
leaq -0x28(%rbp), %rdi
callq 0xb2e0
jmp 0x9cb8
movsbl -0x9(%rbp), %eax
cmpl $0x4f, %eax
jne 0x9c2a
leaq -0x30(%rbp), %rdi
callq 0xb340
movq -0x50(%rbp), %rdi
addq $0xb8, %rdi
leaq -0x30(%rbp), %rsi
callq 0xb3b0
leaq -0x30(%rbp), %rdi
callq 0xb410
jmp 0x9cb6
movsbl -0x9(%rbp), %eax
cmpl $0x53, %eax
jne 0x9c5b
leaq -0x38(%rbp), %rdi
callq 0xb470
movq -0x50(%rbp), %rdi
addq $0xb8, %rdi
leaq -0x38(%rbp), %rsi
callq 0xb4e0
leaq -0x38(%rbp), %rdi
callq 0xb540
jmp 0x9cb4
movsbl -0x9(%rbp), %eax
cmpl $0x5a, %eax
jne 0x9c8c
leaq -0x40(%rbp), %rdi
callq 0xb5a0
movq -0x50(%rbp), %rdi
addq $0xb8, %rdi
leaq -0x40(%rbp), %rsi
callq 0xb610
leaq -0x40(%rbp), %rdi
callq 0xb670
jmp 0x9cb2
leaq -0x48(%rbp), %rdi
callq 0xb6d0
movq -0x50(%rbp), %rdi
addq $0xb8, %rdi
leaq -0x48(%rbp), %rsi
callq 0xb740
leaq -0x48(%rbp), %rdi
callq 0xb7a0
jmp 0x9cb4
jmp 0x9cb6
jmp 0x9cb8
jmp 0x9cba
jmp 0x9cbc
movq -0x50(%rbp), %rdi
addq $0xb8, %rdi
callq 0xa550
movq -0x50(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x29070
movq -0x50(%rbp), %rax
testb $0x1, 0xa8(%rax)
jne 0x9d11
movq -0x50(%rbp), %rdi
addq $0xb8, %rdi
callq 0xa550
movq -0x50(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rdi
addq $0x30, %rsi
callq 0x29070
movq -0x50(%rbp), %rdi
addq $0xb8, %rdi
callq 0xa550
movq %rax, %rdi
movq (%rdi), %rax
callq *0x30(%rax)
addq $0x50, %rsp
popq %rbp
retq
// File: EstherJin[P]TetrisRemake/block1.cc
// Function: Block1::~Block1()
Block1::~Block1(){
  for (int i = 0; i < coords.size(); ++i){
    State stat = {' ', coords[i], false};
    setState(stat);
    notifyObservers();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x2e2e5(%rip), %rcx     # 0x412f0
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0xc(%rbp)
movq -0x38(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x30, %rdi
callq 0xa7e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x13095
movq -0x38(%rbp), %rdi
movb $0x20, -0x1c(%rbp)
addq $0x30, %rdi
movslq -0xc(%rbp), %rsi
callq 0xfa40
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x10(%rbp)
addq $0x8, %rdi
movups -0x1c(%rbp), %xmm0
movaps %xmm0, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x29140
jmp 0x13079
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x290c0
jmp 0x13088
jmp 0x1308a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x13019
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
callq 0xa880
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0xbce0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x78a0
nopl (%rax)
// File: EstherJin[P]TetrisRemake/block1.cc
// Function: Block1::move(int)
void Block1::move(int shift){
  for (int i = 0; i < coords.size(); ++i){
    State stat = {' ', coords[i], false};
    setState(stat);
    notifyObservers();
  }
  for (int i = 0; i < coords.size(); ++i){
    coords.at(i).col += shift;
    State stat = {c, coords[i], true};
    setState(stat);
    notifyObservers();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x60(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x30, %rdi
callq 0xa7e0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x131df
movq -0x60(%rbp), %rdi
movb $0x20, -0x20(%rbp)
addq $0x30, %rdi
movslq -0x10(%rbp), %rsi
callq 0xfa40
movq -0x60(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x1c(%rbp)
movb $0x0, -0x14(%rbp)
addq $0x8, %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x29140
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x290c0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x13161
movl $0x0, -0x34(%rbp)
movq -0x60(%rbp), %rdi
movslq -0x34(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x30, %rdi
callq 0xa7e0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x1328d
movq -0x60(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x74(%rbp)
addq $0x30, %rdi
movslq -0x34(%rbp), %rsi
callq 0xa800
movl -0x74(%rbp), %ecx
movq -0x60(%rbp), %rdi
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movb 0x4c(%rdi), %al
movb %al, -0x44(%rbp)
addq $0x30, %rdi
movslq -0x34(%rbp), %rsi
callq 0xfa40
movq -0x60(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movb $0x1, -0x38(%rbp)
addq $0x8, %rdi
movq -0x44(%rbp), %rax
movq %rax, -0x54(%rbp)
movq -0x3c(%rbp), %rax
movq %rax, -0x4c(%rbp)
movq -0x54(%rbp), %rsi
movq -0x4c(%rbp), %rdx
callq 0x29140
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x290c0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x131e6
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: EstherJin[P]TetrisRemake/block1.cc
// Function: Block1::movePos(int)
vector<Coordinates> Block1::movePos(int shift){
  vector<Coordinates> cds = coords;
  for (int i = 0; i < 4; ++i){
    cds.at(i).col += shift;
  }
  return cds;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movb $0x0, -0x15(%rbp)
addq $0x30, %rsi
callq 0x13660
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x13324
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x4c(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0xa800
movq %rax, -0x48(%rbp)
jmp 0x132f5
movq -0x48(%rbp), %rax
movl -0x4c(%rbp), %ecx
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x132d6
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xa880
jmp 0x13341
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x13337
movq -0x40(%rbp), %rdi
callq 0xa880
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x65c0
nopw (%rax,%rax)
// File: EstherJin[P]TetrisRemake/block1.cc
// Function: Block1::down(int)
void Block1::down(int shift){
  int size = coords.size();
  for (int i = 0; i < size; ++i){
    State stat = {' ', coords[i], false};
    setState(stat);
    notifyObservers();
  }
  for (int i = 0; i < coords.size(); ++i){
    coords.at(i).row += shift;
    State stat = {c, coords[i], true};
    setState(stat);
    notifyObservers();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x30, %rdi
callq 0xa7e0
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x133df
movq -0x60(%rbp), %rdi
movb $0x20, -0x24(%rbp)
addq $0x30, %rdi
movslq -0x14(%rbp), %rsi
callq 0xfa40
movq -0x60(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x18(%rbp)
addq $0x8, %rdi
movq -0x24(%rbp), %rax
movq %rax, -0x34(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0x2c(%rbp)
movq -0x34(%rbp), %rsi
movq -0x2c(%rbp), %rdx
callq 0x29140
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x290c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1337a
movl $0x0, -0x38(%rbp)
movq -0x60(%rbp), %rdi
movslq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x30, %rdi
callq 0xa7e0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x1348b
movq -0x60(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x6c(%rbp)
addq $0x30, %rdi
movslq -0x38(%rbp), %rsi
callq 0xa800
movl -0x6c(%rbp), %ecx
movq -0x60(%rbp), %rdi
addl (%rax), %ecx
movl %ecx, (%rax)
movb 0x4c(%rdi), %al
movb %al, -0x48(%rbp)
addq $0x30, %rdi
movslq -0x38(%rbp), %rsi
callq 0xfa40
movq -0x60(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x44(%rbp)
movb $0x1, -0x3c(%rbp)
addq $0x8, %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x29140
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x290c0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x133e6
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: EstherJin[P]TetrisRemake/block1.cc
// Function: Block1::downPos(int)
vector<Coordinates> Block1::downPos(int shift){
  vector<Coordinates> cds = coords;
  int size = coords.size();
  for (int i = 0; i < size; ++i){
    cds.at(i).row += shift;
  }
  return cds;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movb $0x0, -0x15(%rbp)
addq $0x30, %rsi
callq 0x13660
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
callq 0xa7e0
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x13538
movq -0x48(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x54(%rbp)
movslq -0x20(%rbp), %rsi
callq 0xa800
movq %rax, -0x50(%rbp)
jmp 0x1350b
movq -0x50(%rbp), %rax
movl -0x54(%rbp), %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x134ea
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xa880
jmp 0x13555
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x1354b
movq -0x48(%rbp), %rdi
callq 0xa880
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x65c0
nop
// File: EstherJin[P]TetrisRemake/block1.cc
// Function: Block1::notifCurrPos()
void Block1::notifCurrPos(){
  int size = coords.size();
  for (int i = 0; i < size; ++i){
    State stat = {c, coords[i], true};
    setState(stat);
    notifyObservers();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x30, %rdi
callq 0xa7e0
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x135ee
movq -0x38(%rbp), %rdi
movb 0x4c(%rdi), %al
movb %al, -0x20(%rbp)
addq $0x30, %rdi
movslq -0x10(%rbp), %rsi
callq 0xfa40
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x1c(%rbp)
movb $0x1, -0x14(%rbp)
addq $0x8, %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x29140
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x290c0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x13587
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: EstherJin[P]TetrisRemake/cell.cc
// Function: Cell::clearCell()
void Cell::clearCell(){
  type = ' ';
  State stat = {' ', coords, false};
  setState(stat);
  notifyObservers();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movb $0x20, 0x28(%rdi)
movb $0x20, -0x18(%rbp)
movq 0x2c(%rdi), %rax
movq %rax, -0x14(%rbp)
movb $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x29140
movq -0x30(%rbp), %rdi
callq 0x290c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: EstherJin[P]TetrisRemake/cell.cc
// Function: Cell::changeCell(char)
void Cell::changeCell(char changeTo){
  type = changeTo;
  State stat = {changeTo, coords, true};
  setState(stat);
  notifyObservers();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movb -0x9(%rbp), %al
movb %al, 0x28(%rdi)
movb -0x9(%rbp), %al
movb %al, -0x1c(%rbp)
movq 0x2c(%rdi), %rax
movq %rax, -0x18(%rbp)
movb $0x1, -0x10(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0x2c(%rbp)
movq -0x14(%rbp), %rax
movq %rax, -0x24(%rbp)
movq -0x2c(%rbp), %rsi
movq -0x24(%rbp), %rdx
callq 0x29140
movq -0x38(%rbp), %rdi
callq 0x290c0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: EstherJin[P]TetrisRemake/cell.cc
// Function: Cell::changerow(int)
void Cell::changerow(int row){
  State stat = {' ', coords, false};
  setState(stat);
  notifyObservers();
  coords.row = row;
  stat = {type, coords, true};
  setState(stat);
  notifyObservers();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movb $0x20, -0x1c(%rbp)
movq 0x2c(%rdi), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x10(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0x2c(%rbp)
movq -0x14(%rbp), %rax
movq %rax, -0x24(%rbp)
movq -0x2c(%rbp), %rsi
movq -0x24(%rbp), %rdx
callq 0x29140
movq -0x58(%rbp), %rdi
callq 0x290c0
movq -0x58(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x2c(%rdi)
movb 0x28(%rdi), %al
movb %al, -0x3c(%rbp)
movq 0x2c(%rdi), %rax
movq %rax, -0x38(%rbp)
movb $0x1, -0x30(%rbp)
movq -0x3c(%rbp), %rax
movq %rax, -0x1c(%rbp)
movq -0x34(%rbp), %rax
movq %rax, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0x4c(%rbp)
movq -0x14(%rbp), %rax
movq %rax, -0x44(%rbp)
movq -0x4c(%rbp), %rsi
movq -0x44(%rbp), %rdx
callq 0x29140
movq -0x58(%rbp), %rdi
callq 0x290c0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: EstherJin[P]TetrisRemake/force.cc
// Function: Force::dropBlock()
int Force::dropBlock () {
	if (board->originalPos()) {
		int lines = board->dropBlock();
		return lines;
	} else {
		throw "game over";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
callq 0x12de0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x70(%rax)
testb $0x1, %al
jne 0x14f9c
jmp 0x14fbe
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x12de0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
movl $0x8, %edi
callq 0x61a0
movq %rax, %rdi
leaq 0x180c3(%rip), %rax     # 0x2d095
movq %rax, (%rdi)
movq 0x2cfcc(%rip), %rsi     # 0x41fa8
xorl %eax, %eax
movl %eax, %edx
callq 0x65b0
nopw %cs:(%rax,%rax)
nop