LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/o.cc
// Function: O::O()
O::O(): Block1{0, 'O'} {
  coords.emplace_back(Coordinates {2,0});
  coords.emplace_back(Coordinates {2,1});
  coords.emplace_back(Coordinates {3,0});
  coords.emplace_back(Coordinates {3,1});
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
movl $0x4f, %edx
callq 0x8554
leaq 0xb4a2(%rip), %rax      # 0x1ab60
movq %rax, (%rbx)
leaq 0x30(%rbx), %r14
movq %rsp, %rsi
movq $0x2, (%rsi)
movq %r14, %rdi
callq 0x8e56
movabsq $0x100000002, %rax      # imm = 0x100000002
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x8e56
movq %rsp, %rsi
movq $0x3, (%rsi)
movq %r14, %rdi
callq 0x8e56
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x8e56
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xf727
jmp 0xf727
jmp 0xf727
movq %rax, %r14
movq %rbx, %rdi
callq 0x857a
movq %r14, %rdi
callq 0x5480
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/row.cc
// Function: Row::Row(int, Observer*, Observer*)
Row::Row(int rowNum,  Observer *ob, Observer *ob2): rowNum{rowNum}{
  for(int i = 0; i < 11; ++i){
    Cell c = {' ', rowNum, i};
    c.attach(ob);
	  c.attach(ob2);
    roww.emplace_back(c);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl %esi, 0x18(%rdi)
xorl %r12d, %r12d
movq %rsp, %r13
movq %r13, %rdi
movl $0x20, %esi
movl %ebp, %edx
movl %r12d, %ecx
callq 0x8a78
movq %r13, %rdi
movq %r15, %rsi
callq 0x110bc
movq %r13, %rdi
movq %r14, %rsi
callq 0x110bc
movq %rbx, %rdi
movq %r13, %rsi
callq 0xfaa6
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xf805
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
incl %r12d
cmpl $0xb, %r12d
jne 0xf7bc
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xf83b
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xf83b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x7b7c
movq %r14, %rdi
callq 0x5480
nop
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/row.cc
// Function: Row::checkFull()
bool Row::checkFull(){
  for(int i = 0; i < 11; ++i){
    if (roww.at(i).getChar() == ' '){
      return false;
    }
  }
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r12d, %r12d
movabsq $0x6db6db6db6db6db7, %r13 # imm = 0x6DB6DB6DB6DB6DB7
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
cmpq %r14, %rdx
jbe 0xf8b8
addq %r12, %rdi
callq 0x8b38
cmpb $0x20, %al
je 0xf8a7
cmpq $0xa, %r14
leaq 0x1(%r14), %rax
setae %r15b
addq $0x38, %r12
movq %rax, %r14
cmpq $0xb, %rax
jne 0xf86b
andb $0x1, %r15b
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x38a5(%rip), %rdi      # 0x13164
movq %r14, %rsi
xorl %eax, %eax
callq 0x53d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/s.cc
// Function: S::S()
S::S(): Block1{0, 'S'} {
  coords.emplace_back(Coordinates {2,1});
  coords.emplace_back(Coordinates {2,2});
  coords.emplace_back(Coordinates {3,0});
  coords.emplace_back(Coordinates {3,1});
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
movl $0x53, %edx
callq 0x8554
leaq 0xaeba(%rip), %rax      # 0x1abe8
movq %rax, (%rbx)
leaq 0x30(%rbx), %r14
movabsq $0x100000002, %rax      # imm = 0x100000002
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x8e56
movabsq $0x200000002, %rax      # imm = 0x200000002
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x8e56
movq %rsp, %rsi
movq $0x3, (%rsi)
movq %r14, %rdi
callq 0x8e56
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x8e56
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xfd9d
jmp 0xfd9d
jmp 0xfd9d
movq %rax, %r14
movq %rbx, %rdi
callq 0x857a
movq %r14, %rdi
callq 0x5480
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/s.cc
// Function: S::turnPos(int)
vector<Coordinates> S::turnPos(int shift){
  if (shift > 0){
    shift = shift % 4;
  } else{
    shift = ((-4 * shift) - (shift * -1)) % 4;
  }
  vector<Coordinates> cds = coords;
  if ((shift % 2) != 0){
    if (position == 0){
      cds.at(1).col -= 2;
      cds.at(2).row -= 2;
    } else {
      cds.at(1).col += 2;
      cds.at(2).row += 2;
    }
  }
  return cds;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
jg 0x10016
leal (%r15,%r15,2), %r15d
movl $0x3, %eax
subl %r15d, %eax
negl %r15d
testl %r15d, %r15d
cmovnsl %r15d, %eax
andl $-0x4, %eax
subl %eax, %r15d
leaq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x8988
testb $0x1, %r15b
je 0x10069
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
movq %rcx, %rdx
sarq $0x3, %rdx
cmpl $0x0, 0x48(%r14)
je 0x10051
cmpq $0x2, %rdx
jb 0x10072
addl $0x2, 0xc(%rax)
movl $0x2, %esi
jmp 0x10060
cmpq $0x2, %rdx
jb 0x10072
addl $-0x2, 0xc(%rax)
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
cmpq $0x10, %rcx
je 0x10079
addl %esi, 0x10(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %esi
jmp 0x1007e
movl $0x2, %esi
leaq 0x30df(%rip), %rdi      # 0x13164
xorl %eax, %eax
callq 0x53d0
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x100a3
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %r14, %rdi
callq 0x5480
nop
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/stringGenerator.cc
// Function: StringGenerator::StringGenerator()
StringGenerator::StringGenerator() {
	vector<vector<char>> newGrid;

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

	grid = newGrid;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0xab6c(%rip), %rax      # 0x1ac48
movq %rax, (%rdi)
leaq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %ebp, %ebp
movq %rbp, 0x18(%rdi)
movabsq $0xb00000012, %rax      # imm = 0xB00000012
movq %rax, 0x20(%rdi)
leaq 0x30(%rsp), %r15
movq %rbp, 0x10(%r15)
movaps %xmm0, (%r15)
leaq 0x7(%rsp), %r13
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
callq 0x10828
cmpl $0x0, 0x24(%r14)
jle 0x10168
xorl %ebx, %ebx
leaq (,%rbp,2), %r12
addq %rbp, %r12
shlq $0x3, %r12
movq 0x30(%rsp), %rdi
addq %r12, %rdi
movb $0x20, 0x7(%rsp)
movq %r13, %rsi
callq 0x1085e
incl %ebx
cmpl 0x24(%r14), %ebx
jl 0x1014b
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1017f
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
incq %rbp
movslq 0x20(%r14), %rax
cmpq %rax, %rbp
jl 0x10115
leaq 0x30(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1088a
leaq 0x30(%rsp), %rdi
callq 0x7c32
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x101dc
jmp 0x101bd
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
movq 0x8(%rsp), %rbx
je 0x101dc
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
leaq 0x30(%rsp), %rdi
callq 0x7c32
movq %rbx, %rdi
callq 0x7c32
movq %r14, %rdi
callq 0x5480
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/stringGenerator.cc
// Function: StringGenerator::notify(Subject&)
void StringGenerator::notify(Subject &whoNotified) { // update the display for one cell
	State st = whoNotified.getState();
	if (st.add) {
		grid[st.coords.row][st.coords.col] = st.type;
	}
	else {
		grid[st.coords.row][st.coords.col] = ' ';
	}
}

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
movl $0x54, %edx
callq 0x8554
leaq 0x9a06(%rip), %rax      # 0x1ac88
movq %rax, (%rbx)
leaq 0x30(%rbx), %r14
movq %rsp, %rsi
movq $0x2, (%rsi)
movq %r14, %rdi
callq 0x8e56
movabsq $0x100000002, %rax      # imm = 0x100000002
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x8e56
movabsq $0x200000002, %rax      # imm = 0x200000002
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x8e56
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x8e56
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x112f1
jmp 0x112f1
jmp 0x112f1
movq %rax, %r14
movq %rbx, %rdi
callq 0x857a
movq %r14, %rdi
callq 0x5480
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/t.cc
// Function: T::turnPos(int)
vector<Coordinates> T::turnPos(int shift){
  vector<Coordinates> cds = coords;
  if (shift > 0){
    shift = shift % 4;
  } else{
    shift = ((-4 * shift) - (shift * -1)) % 4;
  }
  int pos = position;
  while (shift > 0){
    if (pos == 0){
      cds.at(2).row -= 1;
      cds.at(2).col -= 1;
    } else if (pos == 1) {
      cds.at(0).row += 1;
      cds.at(2).row += 2;
      cds.at(2).col += 1;
    } else if (pos == 2) {
      cds.at(0).row -= 1;
      cds.at(2).row -= 2;
      cds.at(2).col -= 2;
      cds.at(3).col -= 1;
    } else {
      cds.at(2).row += 1;
      cds.at(2).col += 2;
      cds.at(3).col += 1;
    }
    pos = (pos + 1) % 4;
    --shift;
  }
  return cds;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
addq $0x30, %rsi
callq 0x8988
testl %r14d, %r14d
jle 0x119d8
andl $0x3, %r14d
jmp 0x119f4
leal (%r14,%r14,2), %r14d
movl $0x3, %eax
subl %r14d, %eax
negl %r14d
testl %r14d, %r14d
cmovnsl %r14d, %eax
andl $-0x4, %eax
subl %eax, %r14d
testl %r14d, %r14d
jle 0x11acf
movl 0x48(%r15), %eax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdi
movq %rdi, %r8
subq %rcx, %r8
movq %r8, %rdx
sarq $0x3, %rdx
leaq 0x1c(%rcx), %r9
incl %r14d
xorl %esi, %esi
cmpl $0x2, %eax
je 0x11a6b
cmpl $0x1, %eax
je 0x11a42
testl %eax, %eax
jne 0x11a88
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
cmpq $0x2, %rdx
ja 0x11a62
jmp 0x11add
cmpq %rcx, %rdi
je 0x11ae9
incl (%rcx)
cmpq $0x2, %rdx
jbe 0x11add
movl $0x1, %r10d
movl $0x2, %ebp
leaq 0x14(%rcx), %r11
addl %ebp, 0x10(%rcx)
jmp 0x11aa4
cmpq %rcx, %rdi
je 0x11ae9
decl (%rcx)
cmpq $0x3, %rdx
jb 0x11add
addl $-0x2, 0x10(%rcx)
addl $-0x2, 0x14(%rcx)
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
jmp 0x11a9b
cmpq $0x3, %rdx
jb 0x11add
incl 0x10(%rcx)
addl $0x2, 0x14(%rcx)
movl $0x1, %r10d
movq %r9, %r11
cmpq $0x18, %r8
je 0x11ae4
addl %r10d, (%r11)
leal 0x1(%rax), %r10d
leal 0x4(%rax), %r11d
testl %r10d, %r10d
cmovnsl %r10d, %r11d
andl $-0x4, %r11d
negl %r11d
addl %r11d, %eax
incl %eax
decl %r14d
cmpl $0x1, %r14d
jg 0x11a1e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x2, %esi
jmp 0x11ae9
movl $0x3, %esi
leaq 0x1674(%rip), %rdi      # 0x13164
xorl %eax, %eax
callq 0x53d0
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x11b0e
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %r14, %rdi
callq 0x5480
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/textDisplay.cc
// Function: TextDisplay::print(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void TextDisplay::print (ostream &out, string str1, string str2) {
    istringstream ss1 {str1};
    istringstream ss2 {str2};

    string board1;
    string board2;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x348, %rsp            # imm = 0x348
movq %rcx, %rbx
movq %rsi, %r14
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
movl $0x8, %edx
callq 0x5450
leaq 0x1c8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x5450
leaq 0x38(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x28(%rsp), %r13
leaq 0x8(%rsp), %rbp
leaq 0x1d4e(%rip), %rbx      # 0x138f3
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5280
movsbl %al, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0x54a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x11c70
movq 0x1c8(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x5280
movsbl %al, %edx
movq %r12, %rdi
movq %rbp, %rsi
callq 0x54a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x11c70
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x5310
movl $0xa, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5310
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x5310
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5280
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x51c0
jmp 0x11ba5
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x11c8c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x11ca8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x9309(%rip), %rbx      # 0x1afb8
leaq 0x1c8(%rsp), %rdi
movq %rbx, %rsi
callq 0x53a0
leaq 0x240(%rsp), %rdi
callq 0x50e0
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0x53a0
leaq 0xc0(%rsp), %rdi
callq 0x50e0
addq $0x348, %rsp            # imm = 0x348
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x11d38
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x11d1c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x1c8(%rsp), %rcx
leaq 0x38(%rsp), %rdx
callq 0x5652
movq 0x9279(%rip), %rsi      # 0x1afb8
leaq 0x48(%rsp), %rdi
callq 0x53a0
leaq 0xc0(%rsp), %rdi
callq 0x50e0
movq %rbx, %rdi
callq 0x5480
nop
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/z.cc
// Function: Z::Z()
Z::Z(): Block1{0, 'Z'} {
  coords.emplace_back(Coordinates {2,0});
  coords.emplace_back(Coordinates {2,1});
  coords.emplace_back(Coordinates {3,1});
  coords.emplace_back(Coordinates {3,2});
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
movl $0x5a, %edx
callq 0x8554
leaq 0x8f6e(%rip), %rax      # 0x1ace8
movq %rax, (%rbx)
leaq 0x30(%rbx), %r14
movq %rsp, %rsi
movq $0x2, (%rsi)
movq %r14, %rdi
callq 0x8e56
movabsq $0x100000002, %rax      # imm = 0x100000002
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x8e56
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x8e56
movabsq $0x200000003, %rax      # imm = 0x200000003
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x8e56
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x11de9
jmp 0x11de9
jmp 0x11de9
movq %rax, %r14
movq %rbx, %rdi
callq 0x857a
movq %r14, %rdi
callq 0x5480
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/z.cc
// Function: Z::turnPos(int)
vector<Coordinates> Z::turnPos(int shift){
  if (shift > 0){
    shift = shift % 4;
  } else{
    shift = ((-4 * shift) - (shift * -1)) % 4;
  }
  vector<Coordinates> cds = coords;
  if ((shift % 2) != 0){
    if (position == 0){
      cds.at(2).row -= 2;
      cds.at(3).col -= 2;
    } else {
      cds.at(2).row += 2;
      cds.at(3).col += 2;
    }
  }
  return cds;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
jg 0x12062
leal (%r15,%r15,2), %r15d
movl $0x3, %eax
subl %r15d, %eax
negl %r15d
testl %r15d, %r15d
cmovnsl %r15d, %eax
andl $-0x4, %eax
subl %eax, %r15d
leaq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x8988
testb $0x1, %r15b
je 0x120b5
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
movq %rcx, %rdx
sarq $0x3, %rdx
cmpl $0x0, 0x48(%r14)
je 0x1209d
cmpq $0x3, %rdx
jb 0x120be
addl $0x2, 0x10(%rax)
movl $0x2, %esi
jmp 0x120ac
cmpq $0x3, %rdx
jb 0x120be
addl $-0x2, 0x10(%rax)
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
cmpq $0x18, %rcx
je 0x120c5
addl %esi, 0x1c(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x2, %esi
jmp 0x120ca
movl $0x3, %esi
leaq 0x1093(%rip), %rdi      # 0x13164
xorl %eax, %eax
callq 0x53d0
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x120ef
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %r14, %rdi
callq 0x5480
nop
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/graphicsDisplay.cc
// Function: GraphicsDisplay::printLevel(int)
void GraphicsDisplay::printLevel(int level) {
    window->fillRectangle(0,0,405,15,0);
    string lvl = "Level:                    ";
    lvl += to_string(level);
    window->drawString(50, xmar, lvl);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x195, %ecx            # imm = 0x195
movl $0xf, %r8d
xorl %r9d, %r9d
callq 0x12ec6
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x13e8(%rip), %rsi      # 0x138c8
leaq 0x13fb(%rip), %rdx      # 0x138e2
leaq 0x28(%rsp), %rdi
callq 0x65a0
movl %r14d, %ebp
negl %ebp
cmovsl %r14d, %ebp
movl $0x1, %r15d
cmpl $0xa, %ebp
jb 0x1254e
movl $0x4, %r15d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x12545
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x1254b
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x1254e
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r15d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x12512
addl $-0x3, %r15d
jmp 0x1254e
addl $-0x2, %r15d
jmp 0x1254e
decl %r15d
shrl $0x1f, %r14d
leal (%r15,%r14), %esi
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8(%rsp), %rdi
movl $0x2d, %edx
callq 0x5320
movl %r14d, %edi
addq 0x8(%rsp), %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x10a3b
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x50d0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x125ab
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x20(%rbx), %r14
movl 0x14(%rbx), %ebx
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x6510
leaq 0x48(%rsp), %rcx
movq %r14, %rdi
movl $0x32, %esi
movl %ebx, %edx
callq 0x12f2a
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x125fd
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x12614
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x12658
movq 0x58(%rsp), %rsi
jmp 0x1264b
jmp 0x12655
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x12658
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x12658
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1266f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5480
nop
// File: /workspace/github_cpp_makefile_star2_O1/EstherJin[P]TetrisRemake/graphicsDisplay.cc
// Function: GraphicsDisplay::printScore(int)
void GraphicsDisplay::printScore(int score) {
    window->fillRectangle(0,17,405,15,0);
    string sc = "Score:                    ";
    sc += to_string(score);
    window->drawString(50, 30, sc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
xorl %esi, %esi
movl $0x11, %edx
movl $0x195, %ecx            # imm = 0x195
movl $0xf, %r8d
xorl %r9d, %r9d
callq 0x12ec6
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1228(%rip), %rsi      # 0x138e3
leaq 0x123b(%rip), %rdx      # 0x138fd
leaq 0x28(%rsp), %rdi
callq 0x65a0
movl %r14d, %ebp
negl %ebp
cmovsl %r14d, %ebp
movl $0x1, %r15d
cmpl $0xa, %ebp
jb 0x12729
movl $0x4, %r15d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x12720
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x12726
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x12729
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r15d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x126ed
addl $-0x3, %r15d
jmp 0x12729
addl $-0x2, %r15d
jmp 0x12729
decl %r15d
shrl $0x1f, %r14d
leal (%r15,%r14), %esi
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8(%rsp), %rdi
movl $0x2d, %edx
callq 0x5320
movl %r14d, %edi
addq 0x8(%rsp), %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x10a3b
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x50d0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x12786
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x20(%rbx), %rbx
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x6510
leaq 0x48(%rsp), %rcx
movq %rbx, %rdi
movl $0x32, %esi
movl $0x1e, %edx
callq 0x12f2a
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x127d8
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x127ef
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x12833
movq 0x58(%rsp), %rsi
jmp 0x12826
jmp 0x12830
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x12833
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x12833
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1284a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5480
// File: /workspace/github_cpp_makefile_star2_O1/leonn[P]neuralNet/source/net.cpp
// Function: Net::Net(std::vector<unsigned int, std::allocator<unsigned int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Net::Net(const vector<unsigned> &topology,const string &transferFunction){
	// size
 	unsigned numberOfLayers = topology.size();

 	//create a new  Layer on each interation
 	for (unsigned layerNumber = 0; layerNumber < numberOfLayers; layerNumber++){
 		layers.push_back(Layer());

 		//number of outputs to a neuron
		unsigned numberOutputs= (layerNumber==topology.size()-1) ? 0: topology[layerNumber+1] ;

 		// fill layer wiith neurons and  add bias neuron to the layer;
 		for (unsigned neuronNumber = 0; neuronNumber <= topology[layerNumber] ; neuronNumber++){
			layers.back().push_back(Neuron(numberOutputs,neuronNumber,transferFunction));
 		}
 	}

 	// Force the bias node's output to 1.0 (it was the last neuron pushed in this layer):
    layers.back().back().setOutputValue(1.0);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, -0x50(%rbp)
leaq 0x20(%rdi), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rdi)
movq %rdi, -0x38(%rbp)
movq $0x0, 0x30(%rdi)
movq 0x8(%rsi), %rax
movq %rsi, -0x40(%rbp)
subq (%rsi), %rax
shrq $0x2, %rax
testl %eax, %eax
je 0x275d
movl %eax, %eax
movq %rax, -0x48(%rbp)
xorl %r12d, %r12d
leaq -0xb0(%rbp), %r13
xorps %xmm0, %xmm0
movaps %xmm0, -0xb0(%rbp)
movq $0x0, -0xa0(%rbp)
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x2d6a
movq %r13, %rdi
callq 0x2c68
movq -0x40(%rbp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
decq %rcx
xorl %ebx, %ebx
movl $0x0, %r14d
cmpq %r12, %rcx
je 0x26f6
movl 0x4(%rax,%r12,4), %r14d
movq -0x38(%rbp), %rax
movq 0x28(%rax), %r15
movq %r13, %rdi
movl %r14d, %esi
movl %ebx, %edx
movq -0x50(%rbp), %rcx
callq 0x45b6
addq $-0x18, %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x2f94
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x272c
callq 0x21f0
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x2741
callq 0x21f0
incl %ebx
movq -0x40(%rbp), %rax
movq (%rax), %rax
cmpl (%rax,%r12,4), %ebx
jbe 0x26f6
incq %r12
cmpq -0x48(%rbp), %r12
jne 0x26a6
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rax), %rdi
addq $-0x60, %rdi
fld1
fstpt (%rsp)
callq 0x468c
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27ad
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x2c68
jmp 0x27b0
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x2c9c
jmp 0x27b0
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x2cce
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O1/leonn[P]neuralNet/source/net.cpp
// Function: Net::feedForward(std::vector<double, std::allocator<double>> const&)
void Net::feedForward(const vector<double> &inputValues){
	assert(inputValues.size()==layers[0].size() - 1 && " the inputValues size needs to be the same of the first layer - bias");

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

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x3, %rax
movq 0x20(%rdi), %rcx
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
sarq $0x5, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
decq %rdx
cmpq %rdx, %rax
jne 0x290d
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x2851
movl $0x1, %r12d
xorl %ecx, %ecx
movq 0x20(%rbx), %rdx
leaq (%rcx,%rcx,2), %rdi
shlq $0x5, %rdi
addq (%rdx), %rdi
fldl (%rax,%rcx,8)
fstpt (%rsp)
callq 0x468c
movl %r12d, %ecx
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %r12d
cmpq %rcx, %rdx
ja 0x281e
movq 0x20(%rbx), %rax
cmpq %rax, 0x28(%rbx)
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
je 0x28fe
movl $0x1, %r12d
movl $0x1, %ecx
movq 0x20(%rbx), %rdx
leaq (%rcx,%rcx,2), %r13
movq (%rdx,%r13,8), %rcx
cmpq %rcx, 0x8(%rdx,%r13,8)
je 0x28dc
leal -0x1(%r12), %edx
leaq (%rdx,%rdx,2), %rdx
leaq (%rax,%rdx,8), %r14
movl $0x1, %r15d
xorl %eax, %eax
leaq (%rax,%rax,2), %rdi
shlq $0x5, %rdi
addq %rcx, %rdi
movq %r14, %rsi
callq 0x4758
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
movl %r15d, %eax
movq 0x20(%rbx), %rdx
movq (%rdx,%r13,8), %rcx
movq 0x8(%rdx,%r13,8), %rdx
subq %rcx, %rdx
sarq $0x5, %rdx
imulq %rsi, %rdx
incl %r15d
cmpq %rax, %rdx
ja 0x289c
incl %r12d
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %rsi, %rdx
movq %r12, %rcx
cmpq %r12, %rdx
jae 0x2874
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3710(%rip), %rdi      # 0x6024
leaq 0x377c(%rip), %rsi      # 0x6097
leaq 0x3784(%rip), %rcx      # 0x60a6
movl $0x1b, %edx
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O1/leonn[P]neuralNet/source/neural-net.cpp
// Function: showVectorValues(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<double, std::allocator<double>>&, std::basic_ofstream<char, std::char_traits<char>>&)
void showVectorValues(string label, vector<double> &v,ofstream &file){
    file << label << " ";
    for (unsigned i = 0; i < v.size(); i++) {
        file << v[i] << " ";
    }
    file << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq %rbx, %rdi
callq 0x2240
leaq 0x2d65(%rip), %rsi      # 0x60f0
movl $0x1, %edx
movq %rax, %rdi
callq 0x2240
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x33e6
movl $0x1, %r12d
xorl %ecx, %ecx
leaq 0x2d40(%rip), %r15      # 0x60f0
movsd (%rax,%rcx,8), %xmm0
movq %rbx, %rdi
callq 0x22f0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2240
movl %r12d, %ecx
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %r12d
cmpq %rcx, %rdx
ja 0x33b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2160
// File: /workspace/github_cpp_makefile_star2_O1/leonn[P]neuralNet/source/neural-net.cpp
// Function: showTestVectorValues(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<double, std::allocator<double>>&, std::basic_ofstream<char, std::char_traits<char>>&)
void showTestVectorValues(string label, vector<double> &v,ofstream &file){
    file << label << " ";
    for (unsigned i = 0; i < v.size(); i++) {
        file << v[i] <<" : "<<round(v[i]) << " ";
    }
    file << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq %rbx, %rdi
callq 0x2240
leaq 0x2cb1(%rip), %rsi      # 0x60f0
movl $0x1, %edx
movq %rax, %rdi
callq 0x2240
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x34c6
movl $0x1, %r15d
xorl %r12d, %r12d
movsd (%rax,%r12,8), %xmm0
movq %rbx, %rdi
callq 0x22f0
movq %rax, %r13
movl $0x3, %edx
movq %rax, %rdi
leaq 0x2c70(%rip), %rsi      # 0x60ee
callq 0x2240
movq (%r14), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x20e0
movq %r13, %rdi
callq 0x22f0
movl $0x1, %edx
movq %rax, %rdi
leaq 0x2c48(%rip), %rsi      # 0x60f0
callq 0x2240
movl %r15d, %r12d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
incl %r15d
cmpq %r12, %rcx
ja 0x345e
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2160
// File: /workspace/github_cpp_makefile_star2_O1/leonn[P]neuralNet/source/neuron.cpp
// Function: Neuron::Neuron(unsigned int, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Neuron::Neuron(unsigned numberOutputs, unsigned index,  const string &transferFunction){
	for (unsigned c = 0; c < numberOutputs; c++){
		outputWeights.push_back(Connection());
	}
	this->index=index;
	this->transferFunction=transferFunction;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, -0x40(%rbp)
movl %edx, %r12d
movq %rdi, %r13
leaq 0x20(%rdi), %rax
movq %rax, -0x30(%rbp)
leaq 0x30(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, 0x20(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
leaq 0x48(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rdi)
movq %rax, 0x58(%rdi)
testl %esi, %esi
je 0x463f
movl %esi, %ebx
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x261c
movq 0x50(%r13), %rsi
cmpq 0x58(%r13), %rsi
je 0x4630
movaps -0x60(%rbp), %xmm0
movaps -0x50(%rbp), %xmm1
movaps %xmm1, 0x10(%rsi)
movaps %xmm0, (%rsi)
addq $0x20, 0x50(%r13)
jmp 0x463b
movq %r14, %rdi
movq %r15, %rdx
callq 0x4a04
decl %ebx
jne 0x4608
movl %r12d, 0x40(%r13)
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x2120
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4661
movq %rax, %rbx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4671
callq 0x21f0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
cmpq -0x38(%rbp), %rdi
je 0x4683
callq 0x21f0
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O1/leonn[P]neuralNet/source/neuron.cpp
// Function: Neuron::feedForward(std::vector<Neuron, std::allocator<Neuron>> const&)
void Neuron::feedForward(const Layer &prevLayer){
	long double sum=0.0;

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

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
fldz
subq %rax, %rdx
je 0x47b0
fstp %st(0)
sarq $0x5, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
movl 0x40(%rbx), %edx
fldz
movl $0x1, %esi
shlq $0x5, %rdx
fldt (%rax)
movq 0x48(%rax), %rdi
fldt (%rdi,%rdx)
fmulp %st, %st(1)
faddp %st, %st(1)
movl %esi, %edi
addq $0x60, %rax
incl %esi
cmpq %rdi, %rcx
ja 0x4796
fstpt -0x1c(%rbp)
leaq 0x20(%rbx), %r14
leaq 0x19cf(%rip), %rsi      # 0x618d
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
je 0x47f2
leaq 0x19bf(%rip), %rsi      # 0x6190
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
jne 0x47ff
fldt -0x1c(%rbp)
fchs
fstpt (%rsp)
callq 0x2050
fld1
fadd %st, %st(1)
fdivp %st, %st(1)
jmp 0x47fd
fldt -0x1c(%rbp)
fstpt (%rsp)
callq 0x21a0
fstpt (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/leonn[P]neuralNet/source/neuron.cpp
// Function: Neuron::calculateOutputGradients(long double)
void Neuron::calculateOutputGradients(long double targetValue){
	long double delta= targetValue - outputValue;
	if (this->transferFunction=="th")
		gradient =delta * Neuron::transferFunctionTanHDerivative(outputValue);
 	else if (this->transferFunction=="sig")
		gradient =delta * Neuron::transferFunctionSigDerivative(outputValue);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
fldt 0x10(%rbp)
fldt (%rdi)
fsubrp %st, %st(1)
fstpt -0x34(%rbp)
leaq 0x20(%rdi), %r14
leaq 0x1962(%rip), %rsi      # 0x618d
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
je 0x4876
leaq 0x1952(%rip), %rsi      # 0x6190
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
jne 0x48a4
fldt (%rbx)
fchs
fld %st(0)
fstpt -0x1c(%rbp)
fstpt (%rsp)
callq 0x2050
fstpt -0x28(%rbp)
fldt -0x1c(%rbp)
fstpt (%rsp)
callq 0x2050
fld1
faddp %st, %st(1)
fmul %st, %st(0)
fldt -0x28(%rbp)
fdivp %st, %st(1)
jmp 0x489c
fldt (%rbx)
fld %st(0)
fstpt -0x1c(%rbp)
fstpt (%rsp)
callq 0x21a0
fstpt -0x28(%rbp)
fldt -0x1c(%rbp)
fstpt (%rsp)
callq 0x21a0
fldt -0x28(%rbp)
fmulp %st, %st(1)
fld1
fsubp %st, %st(1)
fldt -0x34(%rbp)
fmulp %st, %st(1)
fstpt 0x10(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/leonn[P]neuralNet/source/neuron.cpp
// Function: Neuron::sumDOW(std::vector<Neuron, std::allocator<Neuron>> const&) const
long double Neuron::sumDOW(const Layer &nextLayer) const{
	long double sum = 0.0;

	// Sum our contributions of the errors at the nodes we feed.
	for(unsigned n = 0; n < nextLayer.size() -1; n++){
		sum+=outputWeights[n].weight * nextLayer[n].gradient;
  	}

  	return sum;
}

// Assembly:
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
fldz
decq %rcx
je 0x4900
pushq %rbp
movq %rsp, %rbp
fstp %st(0)
movq 0x48(%rdi), %rdx
addq $0x10, %rax
fldz
movl $0x1, %esi
fldt (%rdx)
fldt (%rax)
fmulp %st, %st(1)
faddp %st, %st(1)
movl %esi, %edi
addq $0x20, %rdx
addq $0x60, %rax
incl %esi
cmpq %rdi, %rcx
ja 0x48e6
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/leonn[P]neuralNet/source/neuron.cpp
// Function: Neuron::updateInputWeights(std::vector<Neuron, std::allocator<Neuron>>&, long double const&, long double const&)
void Neuron::updateInputWeights(Layer &prevLayer, const long double &eta, const long double &alpha){
 	// 	The weights to be updated are in the Connection container
    // in the neurons in the preceding layer
	for(unsigned n = 0; n < prevLayer.size(); n++){
		Neuron &neuron = prevLayer[n];
		Connection &conn=neuron.outputWeights[index];

		long double oldDeltaWeight = conn.deltaWeight;
		long double newDeltaWeight =
                // Individual input, magnified by the gradient and train rate:
                eta
                * neuron.getOutputValue()
                * gradient
                // Also add momentum = a fraction of the previous delta weight;
                + alpha
                * oldDeltaWeight;

        conn.deltaWeight = newDeltaWeight;
        conn.weight += newDeltaWeight;
  	}

}

// Assembly:
movq (%rsi), %rax
movq 0x8(%rsi), %r8
subq %rax, %r8
fldz
je 0x4a01
pushq %rbp
movq %rsp, %rbp
fstp %st(0)
sarq $0x5, %r8
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %r8, %rsi
movl 0x40(%rdi), %r8d
fldt 0x10(%rdi)
movl $0x1, %edi
shlq $0x5, %r8
movq 0x48(%rax), %r9
fldt 0x10(%r9,%r8)
fldt (%rdx)
fldt (%rax)
fmulp %st, %st(1)
fmul %st(2), %st
fldt (%rcx)
fmulp %st, %st(2)
faddp %st, %st(1)
fld %st(0)
fstpt 0x10(%r9,%r8)
fldt (%r9,%r8)
faddp %st, %st(1)
fstpt (%r9,%r8)
movl %edi, %r9d
addq $0x60, %rax
incl %edi
cmpq %r9, %rsi
ja 0x49ca
popq %rbp
fstp %st(0)
retq
// File: /workspace/github_cpp_makefile_star2_O1/leonn[P]neuralNet/source/trainingdata.cpp
// Function: TrainingData::getTopology(std::vector<unsigned int, std::allocator<unsigned int>>&)
void TrainingData::getTopology(vector<unsigned> &topology){
    string line;
    string label;

    getline(trainingDataFile, line);
    stringstream ss(line);
    ss >> label;
    if (this->isEof() || label.compare("topology:") != 0) {
        abort();
    }

    while (!ss.eof()) {
        unsigned n;
        ss >> n;
        topology.push_back(n);
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb %al, (%r12)
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %edx
leaq -0x70(%rbp), %rsi
movq %r14, %rdi
callq 0x2360
leaq -0x1f8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x18, %edx
callq 0x22e0
leaq -0x1f8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2270
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x4ce4
leaq 0x1572(%rip), %rsi      # 0x6194
leaq -0x50(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x4ce4
movq -0x1f8(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x1d8(%rbp,%rax)
jne 0x4c97
leaq -0x1f8(%rbp), %r14
leaq -0x2c(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2330
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4c77
movl -0x2c(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4c82
movq %rbx, %rdi
movq %r15, %rdx
callq 0x54f4
movq -0x1f8(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x1d8(%rbp,%rax)
je 0x4c53
movq 0x4322(%rip), %rsi      # 0x8fc0
leaq -0x1f8(%rbp), %rdi
callq 0x2180
leaq -0x178(%rbp), %rdi
callq 0x20a0
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x4cc4
callq 0x21f0
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x4cd2
callq 0x21f0
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2130
jmp 0x4cf2
jmp 0x4ced
movq %rax, %rbx
jmp 0x4d14
movq %rax, %rbx
movq 0x42c4(%rip), %rsi      # 0x8fc0
leaq -0x1f8(%rbp), %rdi
callq 0x2180
leaq -0x178(%rbp), %rdi
callq 0x20a0
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x4d22
callq 0x21f0
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x4d30
callq 0x21f0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/leonn[P]neuralNet/source/trainingdata.cpp
// Function: TrainingData::getEta(long double&)
void TrainingData::getEta(long double &eta){
    string line;
    string label;

    getline(trainingDataFile, line);
    stringstream ss(line);
    ss >> label;
    if (this->isEof() || label.compare("eta:") != 0) {
        abort();
    }

    ss >> eta;

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %edx
leaq -0x60(%rbp), %rsi
movq %r14, %rdi
callq 0x2360
leaq -0x1e8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x18, %edx
callq 0x22e0
leaq -0x1e8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2270
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x4e38
leaq 0x13cd(%rip), %rsi      # 0x619e
leaq -0x40(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x4e38
leaq -0x1e8(%rbp), %rdi
movq %rbx, %rsi
callq 0x2250
movq 0x41cc(%rip), %rsi      # 0x8fc0
leaq -0x1e8(%rbp), %rdi
callq 0x2180
leaq -0x168(%rbp), %rdi
callq 0x20a0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x4e1a
callq 0x21f0
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x4e28
callq 0x21f0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2130
jmp 0x4e63
movq %rax, %rbx
movq 0x4177(%rip), %rsi      # 0x8fc0
leaq -0x1e8(%rbp), %rdi
callq 0x2180
leaq -0x168(%rbp), %rdi
callq 0x20a0
jmp 0x4e66
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x4e74
callq 0x21f0
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x4e82
callq 0x21f0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/leonn[P]neuralNet/source/trainingdata.cpp
// Function: TrainingData::getTransferFunction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void TrainingData::getTransferFunction(string &transferFunction){
    string line;
    string label;

    getline(trainingDataFile, line);
    stringstream ss(line);
    ss >> label;
    if (this->isEof() || label.compare("transfer_function:") != 0) {
        abort();
    }

    ss >> transferFunction;

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %edx
leaq -0x60(%rbp), %rsi
movq %r14, %rdi
callq 0x2360
leaq -0x1e8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x18, %edx
callq 0x22e0
leaq -0x1e8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2270
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x4f8a
leaq 0x1280(%rip), %rsi      # 0x61a3
leaq -0x40(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x4f8a
leaq -0x1e8(%rbp), %rdi
movq %rbx, %rsi
callq 0x2270
movq 0x407a(%rip), %rsi      # 0x8fc0
leaq -0x1e8(%rbp), %rdi
callq 0x2180
leaq -0x168(%rbp), %rdi
callq 0x20a0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x4f6c
callq 0x21f0
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x4f7a
callq 0x21f0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2130
jmp 0x4fb5
movq %rax, %rbx
movq 0x4025(%rip), %rsi      # 0x8fc0
leaq -0x1e8(%rbp), %rdi
callq 0x2180
leaq -0x168(%rbp), %rdi
callq 0x20a0
jmp 0x4fb8
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x4fc6
callq 0x21f0
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x4fd4
callq 0x21f0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/leonn[P]neuralNet/source/trainingdata.cpp
// Function: TrainingData::getMomentum(long double&)
void TrainingData::getMomentum(long double &momentum){
    string line;
    string label;

    getline(trainingDataFile, line);
    stringstream ss(line);
    ss >> label;
    if (this->isEof() || label.compare("momentum:") != 0) {
        abort();
    }

    ss >> momentum;

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %edx
leaq -0x60(%rbp), %rsi
movq %r14, %rdi
callq 0x2360
leaq -0x1e8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x18, %edx
callq 0x22e0
leaq -0x1e8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2270
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x50dc
leaq 0x1141(%rip), %rsi      # 0x61b6
leaq -0x40(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x50dc
leaq -0x1e8(%rbp), %rdi
movq %rbx, %rsi
callq 0x2250
movq 0x3f28(%rip), %rsi      # 0x8fc0
leaq -0x1e8(%rbp), %rdi
callq 0x2180
leaq -0x168(%rbp), %rdi
callq 0x20a0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x50be
callq 0x21f0
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x50cc
callq 0x21f0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2130
jmp 0x5107
movq %rax, %rbx
movq 0x3ed3(%rip), %rsi      # 0x8fc0
leaq -0x1e8(%rbp), %rdi
callq 0x2180
leaq -0x168(%rbp), %rdi
callq 0x20a0
jmp 0x510a
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x5118
callq 0x21f0
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x5126
callq 0x21f0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/leonn[P]neuralNet/source/trainingdata.cpp
// Function: TrainingData::getNextInputs(std::vector<double, std::allocator<double>>&)
unsigned TrainingData::getNextInputs(vector<double> &inputVals){
    inputVals.clear();

    string line;
    getline(trainingDataFile, line);
    stringstream ss(line);

    string label;
    ss >> label;
    if (label.compare("in:") == 0) {
        long double oneValue;
        while (ss >> oneValue) {
            inputVals.push_back(oneValue);
        }
    }

    return inputVals.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x518f
movq %rax, 0x8(%rbx)
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %edx
leaq -0x58(%rbp), %rsi
movq %r14, %rdi
callq 0x2360
leaq -0x218(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movl $0x18, %edx
callq 0x22e0
leaq -0x68(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq -0x218(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2270
leaq 0xfb9(%rip), %rsi       # 0x61c0
leaq -0x78(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x527b
leaq -0x218(%rbp), %r14
leaq -0x90(%rbp), %r15
leaq -0x38(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2250
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x5277
fldt -0x90(%rbp)
fstpl -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x526a
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x5226
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3226
jmp 0x5226
leaq -0x48(%rbp), %r15
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
je 0x5290
callq 0x21f0
movq 0x3d29(%rip), %rsi      # 0x8fc0
leaq -0x218(%rbp), %rdi
callq 0x2180
leaq -0x198(%rbp), %rdi
callq 0x20a0
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x52bd
callq 0x21f0
subq %r14, %rbx
shrq $0x3, %rbx
movl %ebx, %eax
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x52e3
jmp 0x52dc
movq %rax, %rbx
jmp 0x5313
jmp 0x52e3
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
je 0x52f4
callq 0x21f0
movq 0x3cc5(%rip), %rsi      # 0x8fc0
leaq -0x218(%rbp), %rdi
callq 0x2180
leaq -0x198(%rbp), %rdi
callq 0x20a0
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x5325
callq 0x21f0
movq %rbx, %rdi
callq 0x2340
nop