LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::unitPropagation()
void Formula::unitPropagation()
{
	int lit_var = -1;
	bool lit_equal = false;
	int lit_val = -1;
	int unit_clause = -1;

	//while there is no conflict and there exists a unit clause
	//find the unit literal and satisfy it
	while(!CONFLICT && !UNITLIST.empty())
	{
		unit_clause = UNITLIST.front();
		UNITCLAUSE = unit_clause;
		//if (LOG) cout<<"unit c : "<<unit_clause<<endl;
		UNITLIST.pop_front();
		if(CLAUSELIST[unit_clause]->LEVEL == -1)
		{
			for(int i=0; i<CLAUSELIST[unit_clause]->ATOM_LIST.size(); i++)
			{
				lit_var = CLAUSELIST[unit_clause]->ATOM_LIST[i].VAR;
				lit_equal = CLAUSELIST[unit_clause]->ATOM_LIST[i].EQUAL;
				lit_val = CLAUSELIST[unit_clause]->ATOM_LIST[i].VAL;
				if(VARLIST[lit_var]->ATOMASSIGN[lit_val] == 0)
				{
					UNITS++;
					reduceTheory(lit_var, lit_equal, lit_val);
					break;
				}
			}
		}
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0xffffffff, 0x2c(%rsp) # imm = 0xFFFFFFFF
movb $0x0, 0x2b(%rsp)
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x20(%rsp) # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rcx
xorl %eax, %eax
testb $0x1, 0x7c(%rcx)
movb %al, 0xf(%rsp)
jne 0x12605
movq 0x10(%rsp), %rdi
addq $0x60, %rdi
callq 0x13e10
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x12612
jmp 0x1276d
movq 0x10(%rsp), %rdi
addq $0x60, %rdi
callq 0x13e30
movq 0x10(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x78(%rdi)
addq $0x60, %rdi
callq 0x13e60
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movslq 0x20(%rsp), %rsi
callq 0x12f20
movq (%rax), %rax
cmpl $-0x1, 0x1c(%rax)
jne 0x12768
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rax
movq %rax, (%rsp)
addq $0x18, %rdi
movslq 0x20(%rsp), %rsi
callq 0x12f20
movq (%rax), %rdi
callq 0xb890
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x12766
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movslq 0x20(%rsp), %rsi
callq 0x12f20
movq (%rax), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xb8b0
movq 0x10(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
addq $0x18, %rdi
movslq 0x20(%rsp), %rsi
callq 0x12f20
movq (%rax), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xb8b0
movq 0x10(%rsp), %rdi
movb 0x8(%rax), %al
andb $0x1, %al
movb %al, 0x2b(%rsp)
addq $0x18, %rdi
movslq 0x20(%rsp), %rsi
callq 0x12f20
movq (%rax), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xb8b0
movq 0x10(%rsp), %rdi
movl 0x4(%rax), %eax
movl %eax, 0x24(%rsp)
movslq 0x2c(%rsp), %rsi
callq 0xaab0
movq (%rax), %rax
movq 0x20(%rax), %rax
movslq 0x24(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x12754
movq 0x10(%rsp), %rdi
movl 0x54(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x54(%rdi)
movl 0x2c(%rsp), %esi
movb 0x2b(%rsp), %al
movl 0x24(%rsp), %ecx
andb $0x1, %al
movzbl %al, %edx
callq 0xe470
jmp 0x12766
jmp 0x12756
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x12663
jmp 0x12768
jmp 0x125e0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: akw0088[P]openssl/huffman_dec.c
// Function: main
int main(int argc, char *argv[])
{
	if (argc < 2)
	{
		printf("Usage: huffman_dec file.huff\r\n");
		return -1;
	}

	unsigned int size = 0;

	char *buffer = get_file(argv[1], &size);
	if (buffer == NULL)
	{
		printf("Unable to open %s\r\n", argv[1]);
		return -1;
	}

	unsigned char *decode = (unsigned char *)malloc(2 * size);
	if (decode == NULL)
	{
		perror("malloc failed");
		return -1;
	}
	memset(decode, 0, 2 * size);
	size_t length = 2 * size;


	unsigned int decompressed_size = huffman_decompress((unsigned char *)buffer, size, decode, length, huffbuf);
	char filename[256] = {0};

	snprintf(filename, 256, "%s.uncompressed", argv[1]);
	write_file(filename, (char *)decode, decompressed_size);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x13b9
leaq 0xca1(%rip), %rdi       # 0x2047
movb $0x0, %al
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14bd
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x14(%rbp), %rsi
callq 0x11f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x13fe
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xc7b(%rip), %rdi       # 0x2066
movb $0x0, %al
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14bd
movl -0x14(%rbp), %eax
shll %eax
movl %eax, %eax
movl %eax, %edi
callq 0x10a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x142f
leaq 0xc5c(%rip), %rdi       # 0x207a
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14bd
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
shll %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x1080
movl -0x14(%rbp), %eax
shll %eax
movl %eax, %eax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq 0x2c3a(%rip), %r8       # 0x40a0
callq 0x1c40
movl %eax, -0x34(%rbp)
leaq -0x140(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x1080
leaq -0x140(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x100, %esi            # imm = 0x100
leaq 0xbec(%rip), %rdx       # 0x2088
movb $0x0, %al
callq 0x1070
leaq -0x140(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0x12e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopl (%rax)
// File: stevedonovan[P]outstreams/./instream.h
// Function: stream::Reader& stream::Reader::getlines<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, unsigned long)
Reader& getlines(C& c, size_t lines=-1) {
      if (fail()) return *this;
      std::string tmp;
      size_t i = 0;
      while (i < lines && getline(tmp)) {
         c.push_back(tmp);
         ++i;
      }
      return *this;
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x66e0
testb $0x1, %al
jne 0x4f7a
jmp 0x4f87
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x501e
leaq -0x40(%rbp), %rdi
callq 0x3320
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x61(%rbp)
jae 0x4fd0
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x78b0
movq %rax, -0x70(%rbp)
jmp 0x4fba
movq -0x70(%rbp), %rdi
callq 0x6700
movb %al, -0x71(%rbp)
jmp 0x4fc8
movb -0x71(%rbp), %al
movb %al, -0x61(%rbp)
jmp 0x4fd0
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x4fd9
jmp 0x500d
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5930
jmp 0x4fe8
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x4f98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3428
jmp 0x502b
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3428
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3390
nopw %cs:(%rax,%rax)
nop
// File: stevedonovan[P]outstreams/./outstream.h
// Function: stream::Writer& stream::Writer::operator()<__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>(stream::Range_<__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>> const&, char const*, char)
Writer& operator() (const Range_<It>& rr, const char *fmt=nullptr, char sepr=' ') {
        sep_out();
        char osep = reset_sep(sepr);
        It ii = rr.begin;
        for(;  ii != rr.end; ++ii) {
            (*this)(*ii,fmt);
        }
        return restore_sep(osep);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x86c0
movq -0x30(%rbp), %rdi
movsbl -0x19(%rbp), %esi
callq 0x8bc0
movb %al, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x28(%rbp), %rdi
callq 0x62d0
testb $0x1, %al
jne 0x5098
jmp 0x50bc
leaq -0x28(%rbp), %rdi
callq 0x6310
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x4eb0
leaq -0x28(%rbp), %rdi
callq 0x6330
jmp 0x5081
movq -0x30(%rbp), %rdi
movsbl -0x1a(%rbp), %esi
callq 0x8bf0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::Matrix(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>)
Matrix::Matrix( vector<vector<double> > input ){
  resize( input.size(), input[0].size() ); //Eeeehhh....
  _data = input;
  _error = 0;
  _det_up_to_date = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x5af0
movq -0x30(%rbp), %rdi
callq 0x5b70
movq -0x30(%rbp), %rdi
movl %eax, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
callq 0x5bc0
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %esi
movl %eax, %edx
callq 0x24d0
jmp 0x2a59
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x5be0
jmp 0x2a68
movq -0x38(%rbp), %rax
movb $0x0, 0x31(%rax)
movb $0x0, 0x38(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5b10
movq -0x18(%rbp), %rdi
callq 0x22a0
nopl (%rax,%rax)
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::Matrix(std::vector<double, std::allocator<double>>)
Matrix::Matrix( vector<double> input ){
  resize( 1, input.size() );
  _data[0] = input;
  _error = 0;
  _det_up_to_date = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x5af0
movq -0x30(%rbp), %rdi
callq 0x5bc0
movq -0x28(%rbp), %rdi
movl %eax, %edx
movl $0x1, %esi
callq 0x24d0
jmp 0x2ae3
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5ba0
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x5e30
jmp 0x2afe
movq -0x38(%rbp), %rax
movb $0x0, 0x31(%rax)
movb $0x0, 0x38(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5b10
movq -0x18(%rbp), %rdi
callq 0x22a0
nop
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::Matrix(Matrix const&, unsigned int)
Matrix::Matrix( const Matrix& m, uint row ){
  resize( 1, m._data[0].size() );
  _data[0] = m._data[row];
  _error = 0;
  _det_up_to_date = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x5af0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6080
movq %rax, %rdi
callq 0x5bc0
movq -0x30(%rbp), %rdi
movl %eax, %edx
movl $0x1, %esi
callq 0x24d0
jmp 0x2b7e
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x6080
movq -0x38(%rbp), %rdi
movq %rax, -0x40(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x5ba0
movq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x5e30
jmp 0x2bab
movq -0x38(%rbp), %rax
movb $0x0, 0x31(%rax)
movb $0x0, 0x38(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5b10
movq -0x20(%rbp), %rdi
callq 0x22a0
nopl (%rax,%rax)
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::operator==(Matrix const&)
bool Matrix::operator == ( const Matrix& rhs ){
  if( _m != rhs._m || _n != rhs._n || _error || rhs._error ){
    return 0;
  }
  bool result = 1;
  for( uint i = 0; i < m(); i++ ){
    for( uint j = 0; j < n(); j++ ){
      if( _data[i][j] != rhs._data[i][j] )
	result = false;
    }
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jne 0x2c98
movq -0x30(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jne 0x2c98
movq -0x30(%rbp), %rax
testb $0x1, 0x31(%rax)
jne 0x2c98
movq -0x18(%rbp), %rax
testb $0x1, 0x31(%rax)
je 0x2ca1
movb $0x0, -0x1(%rbp)
jmp 0x2d5e
movb $0x1, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x6320
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jae 0x2d56
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, -0x38(%rbp)
callq 0x6340
movl %eax, %ecx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
jae 0x2d46
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x6360
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x6080
movq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x6380
movsd -0x40(%rbp), %xmm0
ucomisd (%rax), %xmm0
jne 0x2d35
jp 0x2d35
jmp 0x2d39
movb $0x0, -0x19(%rbp)
jmp 0x2d3b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2ccf
jmp 0x2d48
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2cac
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::operator<<(double)
Matrix& Matrix::operator << ( double input ){
  //The IO iterators can be an issue here. Currently, resize() handles that.
  if( _m == 0 || _n == 0 || _error ){
    _print_error( "Attempting to input into an empty matrix." );
    _error = 1;
  }
  _data[_m_in][_n_in] = input;
  _n_in++;
  if( _n_in == _n ){
    _n_in = 0;
    _m_in++;
  }
  if( _m_in == _m ){
    _m_in = 0;
  }
  _det_up_to_date = 0;
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, 0x18(%rax)
je 0x2dd3
movq -0x50(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x2dd3
movq -0x50(%rbp), %rax
testb $0x1, 0x31(%rax)
je 0x2e52
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x22b0
movq -0x58(%rbp), %rdx
leaq 0xc235(%rip), %rsi      # 0xf020
leaq -0x30(%rbp), %rdi
callq 0x63f0
jmp 0x2df6
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x63a0
jmp 0x2e05
leaq -0x30(%rbp), %rdi
callq 0x20b0
leaq -0x31(%rbp), %rdi
callq 0x21e0
movq -0x50(%rbp), %rax
movb $0x1, 0x31(%rax)
jmp 0x2e52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2e44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20b0
leaq -0x31(%rbp), %rdi
callq 0x21e0
jmp 0x2ed2
movq -0x50(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movl 0x20(%rdi), %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movq -0x50(%rbp), %rax
movl 0x24(%rax), %eax
movl %eax, %esi
callq 0x6360
movsd -0x60(%rbp), %xmm0
movq -0x50(%rbp), %rcx
movsd %xmm0, (%rax)
movl 0x24(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x24(%rcx)
movl 0x24(%rcx), %eax
cmpl 0x1c(%rcx), %eax
jne 0x2ead
movq -0x50(%rbp), %rax
movl $0x0, 0x24(%rax)
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x50(%rbp), %rcx
movl 0x20(%rcx), %eax
cmpl 0x18(%rcx), %eax
jne 0x2ec4
movq -0x50(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x50(%rbp), %rax
movb $0x0, 0x38(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x22a0
nopl (%rax,%rax)
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::clear()
void Matrix::clear(){
  _m_in = _n_in = _m_out = _n_out = 0; //Reset all IO iterators.
  _error = 0;
  for( uint i = 0; i < _m; i++ ){
    for( uint j = 0; j < _n; j++ ){
      _data[i][j] = 0.0;
    }
  }
  _det_up_to_date = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, 0x2c(%rax)
movl $0x0, 0x28(%rax)
movl $0x0, 0x24(%rax)
movl $0x0, 0x20(%rax)
movb $0x0, 0x31(%rax)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x18(%rcx), %eax
jae 0x2f74
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jae 0x2f67
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x6360
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2f2e
jmp 0x2f69
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2f1b
movq -0x18(%rbp), %rax
movb $0x0, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::print()
void Matrix::print(){
  for( uint i = 0; i < _m; i++ ){
    for( uint j = 0; j < _n; j++ ){
      cout << _data[i][j] << " ";  
    }
    cout << endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x18(%rcx), %eax
jae 0x3030
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jae 0x300f
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x6360
movsd (%rax), %xmm0
movq 0x11fe8(%rip), %rdi     # 0x14fd8
callq 0x22d0
movq %rax, %rdi
leaq 0xc16b(%rip), %rsi      # 0xf16a
callq 0x2180
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2fbe
movq 0x11fc2(%rip), %rdi     # 0x14fd8
movq 0x11fab(%rip), %rsi     # 0x14fc8
callq 0x21c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2fab
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::print_test[abi:cxx11]()
string Matrix::print_test(){
  std::stringstream ss;
  for( uint i = 0; i < _m; i++ ){
    for( uint j = 0; j < _n; j++ ){
      ss << _data[i][j] << " ";  
    }
  }
  string s = ss.str();
  return s.substr(0, s.size()-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1e8(%rbp)
movq %rdi, %rax
movq %rax, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d8(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x20e0
movl $0x0, -0x19c(%rbp)
movq -0x1d8(%rbp), %rcx
movl -0x19c(%rbp), %eax
cmpl 0x18(%rcx), %eax
jae 0x315e
movl $0x0, -0x1a0(%rbp)
movq -0x1d8(%rbp), %rcx
movl -0x1a0(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jae 0x3148
movq -0x1d8(%rbp), %rdi
leaq -0x188(%rbp), %rax
movq %rax, -0x1f8(%rbp)
movl -0x19c(%rbp), %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x1a0(%rbp), %eax
movl %eax, %esi
callq 0x6360
movq -0x1f8(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x22d0
movq %rax, -0x1f0(%rbp)
jmp 0x3106
movq -0x1f0(%rbp), %rdi
leaq 0xc056(%rip), %rsi      # 0xf16a
callq 0x2180
jmp 0x311b
jmp 0x311d
movl -0x1a0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a0(%rbp)
jmp 0x30a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x31eb
jmp 0x314a
movl -0x19c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x19c(%rbp)
jmp 0x3085
leaq -0x1d0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x2170
jmp 0x3173
leaq -0x1d0(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x20d0
movq -0x1e8(%rbp), %rdi
movq -0x200(%rbp), %rsi
movq %rax, %rcx
decq %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x21b0
jmp 0x31a5
leaq -0x1d0(%rbp), %rdi
callq 0x20b0
leaq -0x198(%rbp), %rdi
callq 0x2100
movq -0x1e0(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x20b0
leaq -0x198(%rbp), %rdi
callq 0x2100
movq -0x1a8(%rbp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::addToRow(Matrix const&, unsigned int)
Matrix Matrix::addToRow( const Matrix& rhs, const uint row ){
  if( (row > 0 && row <= _m) || rhs._m != 1 ){
    Matrix result = *this;
    for( uint i = 0; i < _n; i++ ){
      result._data[row-1][i] = result._data[row-1][i] + rhs._data[0][i];
    }
    return result;
  }
  else {
    _error = 1;
    return *this;
  }
}

// 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)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x1c(%rbp)
jbe 0x331c
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x18(%rcx), %eax
jbe 0x332a
movq -0x18(%rbp), %rax
cmpl $0x1, 0x18(%rax)
je 0x33ef
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdi
movb $0x0, -0x1d(%rbp)
callq 0x2be0
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jae 0x33da
movq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x6360
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6080
movq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x6380
movsd -0x50(%rbp), %xmm0
movq -0x40(%rbp), %rdi
addsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x6360
movsd -0x48(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3342
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x33ed
movq -0x40(%rbp), %rdi
callq 0x2c30
jmp 0x3400
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdi
movb $0x1, 0x31(%rsi)
callq 0x2be0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::ADDToRow(Matrix const&, unsigned int)
Matrix& Matrix::ADDToRow( const Matrix& rhs, const uint row ){
  if( (row > 0 && row <= _m) || rhs._m != 1 ){
    for( uint i = 0; i < _n; i++ ){
      _data[row-1][i] = _data[row-1][i] + rhs._data[0][i];
    }
  }
  else {
    _error = 1;
  }
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jbe 0x343d
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x18(%rcx), %eax
jbe 0x344b
movq -0x10(%rbp), %rax
cmpl $0x1, 0x18(%rax)
je 0x34ec
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jae 0x34ea
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x6360
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6080
movq %rax, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x6380
movsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rdi
addsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x6360
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3452
jmp 0x34f4
movq -0x20(%rbp), %rax
movb $0x1, 0x31(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::switchRows(unsigned int, unsigned int)
Matrix Matrix::switchRows( const uint row1, const uint row2 ){
  Matrix result = *this;
  vector<double> temp = result._data[row1-1];
  result._data[row1-1] = result._data[row2-1];
  result._data[row2-1] = temp;
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movb $0x0, -0x19(%rbp)
callq 0x2be0
movq -0x50(%rbp), %rdi
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x64a0
jmp 0x354c
movq -0x50(%rbp), %rdi
movl -0x18(%rbp), %eax
decl %eax
movl %eax, %esi
callq 0x5ba0
movq -0x50(%rbp), %rdi
movq %rax, -0x60(%rbp)
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %esi
callq 0x5ba0
movq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0x5e30
jmp 0x357e
movq -0x50(%rbp), %rdi
movl -0x18(%rbp), %eax
decl %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
leaq -0x38(%rbp), %rsi
callq 0x5e30
jmp 0x359c
movb $0x1, -0x19(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x61e0
testb $0x1, -0x19(%rbp)
jne 0x35df
jmp 0x35d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x35e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x61e0
jmp 0x35e9
movq -0x50(%rbp), %rdi
callq 0x2c30
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2c30
movq -0x40(%rbp), %rdi
callq 0x22a0
nopl (%rax,%rax)
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::SWITCHRows(unsigned int, unsigned int)
Matrix& Matrix::SWITCHRows( const uint row1, const uint row2 ){
  vector<double> temp = _data[row1-1];
  _data[row1-1] = _data[row2-1];
  _data[row2-1] = temp;
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x64a0
movq -0x48(%rbp), %rdi
movl -0x10(%rbp), %eax
decl %eax
movl %eax, %esi
callq 0x5ba0
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %esi
callq 0x5ba0
movq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x5e30
jmp 0x3664
movq -0x48(%rbp), %rdi
movl -0x10(%rbp), %eax
decl %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
leaq -0x28(%rbp), %rsi
callq 0x5e30
jmp 0x3682
leaq -0x28(%rbp), %rdi
callq 0x61e0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x61e0
movq -0x30(%rbp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::multiplyRow(double, unsigned int)
Matrix Matrix::multiplyRow( const double d, const uint row ){
  if( row > 0 && row <= _m ){
    Matrix result = *this;
    for( uint i = 0; i < _n; i++ ){
      result._data[row-1][i] = result._data[row-1][i] * d;
    }
    return result;
  }
  else {
    _error = 1;
    return *this;
  }
}

// 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)
movsd %xmm0, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x1c(%rbp)
jbe 0x37a0
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x18(%rcx), %eax
ja 0x37a0
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdi
movb $0x0, -0x1d(%rbp)
callq 0x2be0
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jae 0x378b
movq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x6360
movq -0x40(%rbp), %rdi
movsd (%rax), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x6360
movsd -0x48(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x371d
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x379e
movq -0x40(%rbp), %rdi
callq 0x2c30
jmp 0x37b1
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdi
movb $0x1, 0x31(%rsi)
callq 0x2be0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::MULTIPLYRow(double, unsigned int)
Matrix& Matrix::MULTIPLYRow( const double d, const uint row ){
  if( row > 0 && row <= _m ){
    for( uint i = 0; i < _n; i++ ){
      _data[row-1][i] = _data[row-1][i] * d;
    }
  }
  else {
    _error = 1;
  }
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jbe 0x3869
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x18(%rcx), %eax
ja 0x3869
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jae 0x3867
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x6360
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x6360
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x37f9
jmp 0x3871
movq -0x20(%rbp), %rax
movb $0x1, 0x31(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::submatrix(unsigned int, unsigned int, unsigned int, unsigned int)
Matrix Matrix::submatrix( uint row, uint col, uint rows, uint cols ){
  if( row + rows - 1 <= _m && col + cols - 1 <= _n && rows != 0 && cols != 0 ){
    Matrix result( rows, cols );
    for( uint i = 0; i < rows; i++ ){
      for( uint j = 0; j < cols; j++ ){
	result._data[i][j] = _data[i+row-1][j+col-1];
      }
    }
    return result;
  }
  else {
    _error = 1;
    return *this;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movl -0x14(%rbp), %eax
addl -0x1c(%rbp), %eax
subl $0x1, %eax
cmpl 0x18(%rcx), %eax
ja 0x3dba
movq -0x38(%rbp), %rcx
movl -0x18(%rbp), %eax
addl -0x20(%rbp), %eax
subl $0x1, %eax
cmpl 0x1c(%rcx), %eax
ja 0x3dba
cmpl $0x0, -0x1c(%rbp)
je 0x3dba
cmpl $0x0, -0x20(%rbp)
je 0x3dba
movq -0x48(%rbp), %rdi
movb $0x0, -0x21(%rbp)
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x2990
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x3da5
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x3d95
movq -0x38(%rbp), %rdi
movl -0x28(%rbp), %eax
addl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x2c(%rbp), %eax
addl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x6360
movq -0x48(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x6360
movsd -0x50(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3d2a
jmp 0x3d97
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3d17
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x3db8
movq -0x48(%rbp), %rdi
callq 0x2c30
jmp 0x3dcb
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
movb $0x1, 0x31(%rsi)
callq 0x2be0
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::add(Matrix const&)
Matrix Matrix::add( const Matrix& rhs ){
  if( _m == rhs._m && _n == rhs._n ){
    Matrix result = *this;
    for( uint i = 0; i < _m; i++ ){
      for( uint j = 0; j < _n; j++ ){
	result._data[i][j] = result._data[i][j] + rhs._data[i][j];
      }
    }
    return result;
  }
  else {
    _error = 1;
    return *this;
  }
}

// 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)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jne 0x3f9a
movq -0x30(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jne 0x3f9a
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdi
movb $0x0, -0x19(%rbp)
callq 0x2be0
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x18(%rcx), %eax
jae 0x3f85
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jae 0x3f75
movq -0x40(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x6360
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x6080
movq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x6380
movsd -0x50(%rbp), %xmm0
movq -0x40(%rbp), %rdi
addsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x6360
movsd -0x48(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3eea
jmp 0x3f77
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3ed3
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x3f98
movq -0x40(%rbp), %rdi
callq 0x2c30
jmp 0x3fab
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdi
movb $0x1, 0x31(%rsi)
callq 0x2be0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::mul(Matrix const&)
Matrix Matrix::mul( const Matrix& rhs ){
  if( _n == rhs._m ){
    Matrix result( _m, rhs._n );
    for( uint i = 0; i < _m; i++ ){
      for( uint j = 0; j < rhs._n; j++ ){
	int sum = 0;
	for( uint k = 0; k < _n; k++ ){
	  sum = sum + ( _data[i][k] * rhs._data[k][j] );
	}
	result._data[i][j] = sum;
      }
    }
    return result;
  }
  else {
    _error = 1;
    return *this;
  }
}

// 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)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl 0x1c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jne 0x43cc
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rax
movb $0x0, -0x19(%rbp)
movl 0x18(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %edx
callq 0x2990
movl $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x18(%rcx), %eax
jae 0x43b7
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jae 0x43a7
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jae 0x436b
movq -0x38(%rbp), %rdi
cvtsi2sdl -0x28(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x6360
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x6080
movq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x6380
movsd -0x58(%rbp), %xmm0
movsd -0x50(%rbp), %xmm1
movsd (%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x42ee
movq -0x48(%rbp), %rdi
cvtsi2sdl -0x28(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x6360
movsd -0x60(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x42d0
jmp 0x43a9
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x42b9
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x43ca
movq -0x48(%rbp), %rdi
callq 0x2c30
jmp 0x43dd
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
movb $0x1, 0x31(%rsi)
callq 0x2be0
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::mul(double const&)
Matrix Matrix::mul( const double& in ){
  Matrix result = *this;
  for( uint i = 0; i < _m; i++ ){
    for( uint j = 0; j < _n; j++ ){
      result._data[i][j] = result._data[i][j] * in;
    }
  }
  return result;
}

// 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)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x30(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x2be0
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x18(%rcx), %eax
jae 0x44f1
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jae 0x44e1
movq -0x40(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x6360
movq -0x40(%rbp), %rdi
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x6360
movsd -0x48(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x447a
jmp 0x44e3
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4467
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x4504
movq -0x40(%rbp), %rdi
callq 0x2c30
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::exp(int)
Matrix Matrix::exp( const int power ){
  if( _m == _n && power > 0){
    Matrix result = *this;
    for( int i = 1; i < power; i++ ){
      result *= *this;
    }
    return result;
  }
  else {
    if( power == -1 ){ //Special case: Return the inverse.
      //return ~*this;
      return *this;
    }
    else {
      _error = 1;
      return *this;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %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), %rcx
movq %rcx, -0x38(%rbp)
movl 0x18(%rcx), %eax
cmpl 0x1c(%rcx), %eax
jne 0x482c
cmpl $0x0, -0x14(%rbp)
jle 0x482c
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
movb $0x0, -0x15(%rbp)
callq 0x2be0
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4817
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x4580
jmp 0x47f3
jmp 0x47f5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x47dc
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2c30
jmp 0x485c
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x482a
movq -0x48(%rbp), %rdi
callq 0x2c30
jmp 0x4852
cmpl $-0x1, -0x14(%rbp)
jne 0x4841
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x2be0
jmp 0x4852
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
movb $0x1, 0x31(%rsi)
callq 0x2be0
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::EXP(int)
Matrix& Matrix::EXP( const int power ){
  if( _m == _n && power > 0){
    Matrix result = *this;
    for( int i = 1; i < power; i++ ){
      *this *= result;
    }
    return *this;
  }
  else {
    if( power == -1 ){ //Special case: Return the inverse.
      //return !*this;
      return *this;
    }
    else {
      _error = 1;
      return *this;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movl 0x18(%rcx), %eax
cmpl 0x1c(%rcx), %eax
jne 0x492a
cmpl $0x0, -0x14(%rbp)
jle 0x492a
movq -0x78(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x2be0
movl $0x1, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4917
movq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4580
jmp 0x48f3
jmp 0x48f5
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x48dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2c30
jmp 0x4953
movq -0x78(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2c30
jmp 0x4946
cmpl $-0x1, -0x14(%rbp)
jne 0x493a
movq -0x78(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4946
movq -0x78(%rbp), %rax
movb $0x1, 0x31(%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x22a0
nopl (%rax)
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::trans()
Matrix Matrix::trans(){
  Matrix result( _n, _m );
  for( uint i = 0; i < _m; i++ ){
    for( uint j = 0; j < _n; j++ ){
      result._data[j][i] = _data[i][j];
    }
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x11(%rbp)
movl 0x1c(%rax), %esi
movl 0x18(%rax), %edx
callq 0x2990
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x18(%rcx), %eax
jae 0x5038
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jae 0x502b
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x6360
movq -0x38(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x5ba0
movq %rax, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x6360
movsd -0x40(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4fcc
jmp 0x502d
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4fb9
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x504b
movq -0x38(%rbp), %rdi
callq 0x2c30
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::det()
double Matrix::det(){
  if( _det_up_to_date )
    return _determinant;
  else {
    if( _m != _n ){
      return 0;
    }
    _det_up_to_date = true;
    _determinant = _det( *this );
    return _determinant;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
testb $0x1, 0x38(%rax)
je 0x514d
movq -0x68(%rbp), %rax
cvtsi2sdl 0x34(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x51cc
movq -0x68(%rbp), %rcx
movl 0x18(%rcx), %eax
cmpl 0x1c(%rcx), %eax
je 0x5163
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x51cc
movq -0x68(%rbp), %rsi
movb $0x1, 0x38(%rsi)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x2be0
movq -0x68(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x51f0
movsd %xmm0, -0x70(%rbp)
jmp 0x518c
movq -0x68(%rbp), %rax
movsd -0x70(%rbp), %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, 0x34(%rax)
leaq -0x50(%rbp), %rdi
callq 0x2c30
movq -0x68(%rbp), %rax
cvtsi2sdl 0x34(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x51cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2c30
jmp 0x51da
movsd -0x8(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)
// File: hitc8494[P]Matrix/test.cpp
// Function: test(bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void test( bool pass, std::string message ){
  string s; s.assign( spaces, ' ' );
  cout << s;
  if( pass ){
    cout << "Passed - "; passed++;
  }
  else {
    cout << "FAILED - "; failed++;
  }
  cout << message << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2230
movq -0x48(%rbp), %rdi
movslq 0xb2f8(%rip), %rsi      # 0x15198
movl $0x20, %edx
callq 0x2290
jmp 0x9eac
movq 0xb125(%rip), %rdi      # 0x14fd8
leaq -0x30(%rbp), %rsi
callq 0x2160
jmp 0x9ebe
testb $0x1, -0x1(%rbp)
je 0x9f01
movq 0xb10d(%rip), %rdi      # 0x14fd8
leaq 0x5286(%rip), %rsi      # 0xf158
callq 0x2180
jmp 0x9ed9
movl 0xb2bd(%rip), %eax      # 0x1519c
addl $0x1, %eax
movl %eax, 0xb2b4(%rip)      # 0x1519c
jmp 0x9f25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20b0
jmp 0x9f5c
movq 0xb0d0(%rip), %rdi      # 0x14fd8
leaq 0x5253(%rip), %rsi      # 0xf162
callq 0x2180
jmp 0x9f16
movl 0xb284(%rip), %eax      # 0x151a0
addl $0x1, %eax
movl %eax, 0xb27b(%rip)      # 0x151a0
movq -0x50(%rbp), %rsi
movq 0xb0a8(%rip), %rdi      # 0x14fd8
callq 0x2160
movq %rax, -0x58(%rbp)
jmp 0x9f3b
movq -0x58(%rbp), %rdi
movq 0xb082(%rip), %rsi      # 0x14fc8
callq 0x21c0
jmp 0x9f4d
leaq -0x30(%rbp), %rdi
callq 0x20b0
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)
// File: qian-jiahong[P]uvncrep017-ws/repeater.cpp
// Function: debug(int, char const*, ...)
void debug(int msgLevel, const char *fmt, ...)
{
    va_list args;

    if (msgLevel <= loggingLevel) {
        logLineStart("UltraVnc");

        va_start(args, fmt);
    
        vfprintf(stderr, fmt, args);
        va_end(args);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x24b8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
leaq 0xd55f(%rip), %rcx      # 0xfa44
cmpl (%rcx), %eax
jg 0x2534
leaq 0x7b14(%rip), %rdi      # 0xa004
callq 0x2540
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0xcac0(%rip), %rax      # 0xefe0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x22a0
leaq -0x30(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: qian-jiahong[P]uvncrep017-ws/repeater.cpp
// Function: logLineStart(char const*)
static void logLineStart(const char *prefix)
{
    time_t errTime;
    char buf[MY_TMP_BUF_LEN];
    char *lf;

    errTime = time(NULL);

    //ctime() adds '\n' to line end, change that to space
    strlcpy(buf, ((errTime != -1) ? ctime(&errTime) : ""), MY_TMP_BUF_LEN);
    lf = strchr(buf, '\n');
    if (NULL != lf)
        *lf = ' ';

    fprintf(stderr, "%s %s> ", prefix, buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x21e0
movq %rax, -0x10(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x120(%rbp)
cmpq $-0x1, -0x10(%rbp)
je 0x2583
leaq -0x10(%rbp), %rdi
callq 0x20d0
movq %rax, -0x128(%rbp)
jmp 0x2593
leaq 0x9050(%rip), %rax      # 0xb5da
movq %rax, -0x128(%rbp)
jmp 0x2593
movq -0x120(%rbp), %rdi
movq -0x128(%rbp), %rsi
movl $0xff, %edx
callq 0x76d0
leaq -0x110(%rbp), %rdi
movl $0xa, %esi
callq 0x20c0
movq %rax, -0x118(%rbp)
xorl %eax, %eax
cmpq -0x118(%rbp), %rax
je 0x25d8
movq -0x118(%rbp), %rax
movb $0x20, (%rax)
movq 0xca01(%rip), %rax      # 0xefe0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq -0x110(%rbp), %rcx
leaq 0x7e25(%rip), %rsi      # 0xa419
movb $0x0, %al
callq 0x22d0
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)