LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: fhirschman[P]CANF-gp/source/general_functions.cc
// Function: fillCnumberMatrix(std::complex<double>**, std::complex<double>, std::complex<double>)
void fillCnumberMatrix(complex<double>** cnumber_matrix,complex<double>lower_left,complex<double> upper_right)
{	
	dx_help = (real(upper_right)-real(lower_left))/(N_X);
	dx = {dx_help,0.0};
	dy_help = (imag(upper_right)-imag(lower_left))/(N_Y);
	dy = {0.0,dy_help};
	cnumber_matrix[0][0] = lower_left;
	for(int i = 0; i < N_Y; i++){
		for(int j = 0; j < N_X; j++){
			cnumber_matrix[i][j] = lower_left + double(j)*dx +double(i)*dy;
			// cout << dy << endl;
		}
	}
	return;
}

// Assembly:
subq $0xb8, %rsp
movsd %xmm0, 0xa8(%rsp)
movsd %xmm1, 0xb0(%rsp)
movsd %xmm2, 0x98(%rsp)
movsd %xmm3, 0xa0(%rsp)
movq %rdi, 0x90(%rsp)
leaq 0x98(%rsp), %rdi
callq 0xbd10
movsd %xmm0, 0x8(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0xbd10
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
subsd %xmm1, %xmm0
leaq 0x1ee6d(%rip), %rax     # 0x298e4
cvtsi2sdl (%rax), %xmm1
divsd %xmm1, %xmm0
leaq 0x1ef3a(%rip), %rax     # 0x299c0
movsd %xmm0, (%rax)
leaq 0x1ef2f(%rip), %rax     # 0x299c0
movsd (%rax), %xmm0
leaq 0x80(%rsp), %rdi
xorps %xmm1, %xmm1
callq 0xc0c0
leaq 0x1efac(%rip), %rax     # 0x29a58
movq 0x80(%rsp), %rcx
movq %rcx, (%rax)
movq 0x88(%rsp), %rcx
movq %rcx, 0x8(%rax)
leaq 0x98(%rsp), %rdi
callq 0xbd20
movsd %xmm0, 0x10(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0xbd20
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
subsd %xmm1, %xmm0
leaq 0x1edf1(%rip), %rax     # 0x298e8
cvtsi2sdl (%rax), %xmm1
divsd %xmm1, %xmm0
leaq 0x1eec2(%rip), %rax     # 0x299c8
movsd %xmm0, (%rax)
leaq 0x1eeb7(%rip), %rax     # 0x299c8
movsd (%rax), %xmm1
leaq 0x70(%rsp), %rdi
xorps %xmm0, %xmm0
callq 0xc0c0
leaq 0x1ef3f(%rip), %rax     # 0x29a68
movq 0x70(%rsp), %rcx
movq %rcx, (%rax)
movq 0x78(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x90(%rsp), %rax
movq (%rax), %rax
movq 0xa8(%rsp), %rcx
movq %rcx, (%rax)
movq 0xb0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
leaq 0x1ed79(%rip), %rcx     # 0x298e8
cmpl (%rcx), %eax
jge 0xac6d
movl $0x0, 0x68(%rsp)
movl 0x68(%rsp), %eax
leaq 0x1ed5a(%rip), %rcx     # 0x298e4
cmpl (%rcx), %eax
jge 0xac5b
cvtsi2sdl 0x68(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x1eeae(%rip), %rsi     # 0x29a58
callq 0xc270
movsd %xmm0, 0x38(%rsp)
movsd %xmm1, 0x40(%rsp)
leaq 0xa8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xc230
movsd %xmm0, 0x48(%rsp)
movsd %xmm1, 0x50(%rsp)
cvtsi2sdl 0x6c(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x1ee77(%rip), %rsi     # 0x29a68
callq 0xc270
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x28(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xc230
movsd %xmm0, 0x58(%rsp)
movsd %xmm1, 0x60(%rsp)
movq 0x90(%rsp), %rax
movslq 0x6c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x68(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x58(%rsp), %rcx
movq %rcx, (%rax)
movq 0x60(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0xab7f
jmp 0xac5d
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0xab64
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: fhirschman[P]CANF-gp/source/./../headers/gnuplot-iostream.h
// Function: gnuplotio::Gnuplot::getLimits(double&, double&, double&, double&)
void getLimits(
		double &x_min,double&x_max,double&y_min,double&y_max) {
		allocFeedback();

		*this << "if (exists(\"GPVAL_X_MIN\")) print GPVAL_X_MIN, GPVAL_X_MAX, GPVAL_Y_MIN, GPVAL_Y_MAX; else print 0, 1, 0, 1;" << std::endl;
		if(debug_messages) {
			std::cerr << "begin scanf" << std::endl;
		}
		if(4 != fscanf(feedback->handle(), "%lf %lf %lf %lf", &x_min, &x_max, &y_min, &y_max)) {
			throw std::runtime_error("could not parse reply");
		}
		if(debug_messages) {
			std::cerr << "end scanf" << std::endl;
		}
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe720
movq 0x8(%rsp), %rdi
leaq 0x123a1(%rip), %rsi     # 0x1e349
callq 0x84e0
movq %rax, %rdi
movq 0x1cfb9(%rip), %rsi     # 0x28f70
callq 0x8560
movq 0x8(%rsp), %rax
testb $0x1, 0xc0(%rax)
je 0xbfec
movq 0x1d017(%rip), %rdi     # 0x28fe8
leaq 0x123dd(%rip), %rsi     # 0x1e3b5
callq 0x84e0
movq %rax, %rdi
movq 0x1cf89(%rip), %rsi     # 0x28f70
callq 0x8560
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %rdi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x20(%rsp), %r9
leaq 0x123a5(%rip), %rsi     # 0x1e3c1
movb $0x0, %al
callq 0x89d0
movl %eax, %ecx
movl $0x4, %eax
cmpl %ecx, %eax
je 0xc080
movl $0x10, %edi
callq 0x8280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x12388(%rip), %rsi     # 0x1e3d1
callq 0x8200
jmp 0xc050
movq (%rsp), %rdi
movq 0x1cf95(%rip), %rsi     # 0x28ff0
movq 0x1cf2e(%rip), %rdx     # 0x28f90
callq 0x8910
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x83c0
jmp 0xc0b5
movq 0x8(%rsp), %rax
testb $0x1, 0xc0(%rax)
je 0xc0b0
movq 0x1cf53(%rip), %rdi     # 0x28fe8
leaq 0x1234b(%rip), %rsi     # 0x1e3e7
callq 0x84e0
movq %rax, %rdi
movq 0x1cec5(%rip), %rsi     # 0x28f70
callq 0x8560
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x8960
nop
// File: fhirschman[P]CANF-gp/source/./../headers/gnuplot-iostream.h
// Function: gnuplotio::Gnuplot::allocFeedback()
void allocFeedback() {
		if(!feedback) {
#ifdef GNUPLOT_ENABLE_PTY
			feedback = new GnuplotFeedbackPty(debug_messages);
//#elif defined GNUPLOT_USE_TMPFILE
//// Currently this doesn't work since fscanf doesn't block (need something like "tail -f")
//			feedback = new GnuplotFeedbackTmpfile(debug_messages);
#else
			// This shouldn't happen because we are in an `#ifdef GNUPLOT_ENABLE_FEEDBACK`
			// block which should only be activated if GNUPLOT_ENABLE_PTY is defined.
			GNUPLOT_STATIC_ASSERT_MSG((sizeof(T) == 0), "No feedback mechanism defined.");
#endif
			*this << "set print \"" << feedback->filename() << "\"" << std::endl;
		}
	}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0xa0(%rax)
jne 0xe834
movl $0x38, %edi
callq 0x8500
movq %rax, %rdi
movq 0x28(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x20(%rsp)
movzbl 0xc0(%rax), %esi
andl $0x1, %esi
callq 0xe850
jmp 0xe76c
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0xa0(%rdi)
leaq 0xfc6d(%rip), %rsi      # 0x1e3f1
callq 0x84e0
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0xa0(%rax), %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq *%rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x8450
movq %rax, 0x18(%rsp)
jmp 0xe7c6
movq 0x18(%rsp), %rdi
leaq 0x109d2(%rip), %rsi     # 0x1f1a4
callq 0x84e0
movq %rax, (%rsp)
jmp 0xe7dd
movq (%rsp), %rdi
movq 0x1a788(%rip), %rsi     # 0x28f70
callq 0x8560
jmp 0xe7ef
leaq 0x30(%rsp), %rdi
callq 0x8330
jmp 0xe834
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x38, %esi
callq 0x8520
jmp 0xe839
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x8330
jmp 0xe839
addq $0x68, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x8960
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: fhirschman[P]CANF-gp/source/./../headers/gnuplot-iostream.h
// Function: boost::enable_if_c<(2ul > 1) && !gnuplotio::ModeBinfmt::is_size, void>::type gnuplotio::print_block<2ul, gnuplotio::IteratorRange<__gnu_cxx::__normal_iterator<std::vector<float, std::allocator<float>> const*, std::vector<std::vector<float, std::allocator<float>>, std::allocator<std::vector<float, std::allocator<float>>>>>, std::vector<float, std::allocator<float>>>, gnuplotio::ModeBinfmt>(std::ostream&, gnuplotio::IteratorRange<__gnu_cxx::__normal_iterator<std::vector<float, std::allocator<float>> const*, std::vector<std::vector<float, std::allocator<float>>, std::allocator<std::vector<float, std::allocator<float>>>>>, std::vector<float, std::allocator<float>>>&, gnuplotio::ModeBinfmt)
typename boost::enable_if_c<(Depth>1) && !PrintMode::is_size>::type
print_block(std::ostream &stream, T &arg, PrintMode) {
	if(PrintMode::is_binfmt && arg.is_end()) throw plotting_empty_container();
	bool first = true;
	for(; !arg.is_end(); arg.inc()) {
		if(first) {
			first = false;
		} else {
			if(PrintMode::is_text) stream << std::endl;
		}
		if(debug_array_print && PrintMode::is_text) stream << "<block>" << std::endl;
		if(arg.is_end()) throw plotting_empty_container();
		typename T::subiter_type sub = arg.deref_subiter();
		print_block<Depth-1>(stream, sub, PrintMode());
		// If asked to print the binary format string, only the first element needs to be
		// looked at.
		if(PrintMode::is_binfmt) break;
	}
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11b40
testb $0x1, %al
jne 0x1194e
jmp 0x1199f
movl $0x10, %edi
callq 0x8280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x11b60
jmp 0x1196a
movq 0x10(%rsp), %rdi
leaq 0x168a2(%rip), %rsi     # 0x28218
leaq 0x223(%rip), %rdx       # 0x11ba0
callq 0x8910
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x83c0
jmp 0x11a80
movb $0x1, 0x33(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11b40
xorb $-0x1, %al
testb $0x1, %al
jne 0x119b9
jmp 0x11a7b
testb $0x1, 0x33(%rsp)
je 0x119c7
movb $0x0, 0x33(%rsp)
jmp 0x119c9
jmp 0x119c9
testb $0x1, 0x17e72(%rip)     # 0x29842
je 0x119fa
xorl %eax, %eax
testb $0x1, %al
jne 0x119da
jmp 0x119fa
movq 0x48(%rsp), %rdi
leaq 0xcc44(%rip), %rsi      # 0x1e62a
callq 0x84e0
movq %rax, %rdi
movq 0x1757b(%rip), %rsi     # 0x28f70
callq 0x8560
movq 0x40(%rsp), %rdi
callq 0x11b40
testb $0x1, %al
jne 0x11a0a
jmp 0x11a58
movl $0x10, %edi
callq 0x8280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x11b60
jmp 0x11a26
movq 0x8(%rsp), %rdi
leaq 0x167e6(%rip), %rsi     # 0x28218
leaq 0x167(%rip), %rdx       # 0x11ba0
callq 0x8910
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x83c0
jmp 0x11a80
movq 0x40(%rsp), %rdi
callq 0x11bb0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x11c60
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x8960
nopw (%rax,%rax)
// File: fhirschman[P]CANF-gp/source/./../headers/gnuplot-iostream.h
// Function: gnuplotio::IteratorRange<__gnu_cxx::__normal_iterator<std::vector<float, std::allocator<float>> const*, std::vector<std::vector<float, std::allocator<float>>, std::allocator<std::vector<float, std::allocator<float>>>>>, std::vector<float, std::allocator<float>>>::deref_subiter() const
subiter_type deref_subiter() const {
		GNUPLOT_STATIC_ASSERT_MSG(sizeof(TV) && is_container,
			"deref_subiter called on non-nested container");
		if(is_end()) {
			throw std::runtime_error("attepted to dereference past end of iterator");
		}
		return ArrayTraits<TV>::get_range(*it);
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x11b40
testb $0x1, %al
jne 0x11bce
jmp 0x11c20
movl $0x10, %edi
callq 0x8280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0xca62(%rip), %rsi      # 0x1e64b
callq 0x8200
jmp 0x11bf0
movq (%rsp), %rdi
movq 0x173f5(%rip), %rsi     # 0x28ff0
movq 0x1738e(%rip), %rdx     # 0x28f90
callq 0x8910
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x83c0
jmp 0x11c4b
movq 0x8(%rsp), %rdi
callq 0x11de0
movq %rax, %rdi
callq 0x11d90
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x8960
nopw %cs:(%rax,%rax)
nop
// File: fhirschman[P]CANF-gp/source/./../headers/gnuplot-iostream.h
// Function: boost::enable_if_c<1ul == 1 && !gnuplotio::ModeBinfmt::is_size, void>::type gnuplotio::print_block<1ul, gnuplotio::IteratorRange<__gnu_cxx::__normal_iterator<float const*, std::vector<float, std::allocator<float>>>, float>, gnuplotio::ModeBinfmt>(std::ostream&, gnuplotio::IteratorRange<__gnu_cxx::__normal_iterator<float const*, std::vector<float, std::allocator<float>>>, float>&, gnuplotio::ModeBinfmt)
typename boost::enable_if_c<(Depth==1) && !PrintMode::is_size>::type
print_block(std::ostream &stream, T &arg, PrintMode) {
	if(PrintMode::is_binfmt && arg.is_end()) throw plotting_empty_container();
	for(; !arg.is_end(); arg.inc()) {
		//print_entry(arg.deref());
		deref_and_print(stream, arg, PrintMode());
		// If asked to print the binary format string, only the first element needs to be
		// looked at.
		if(PrintMode::is_binfmt) break;
		if(PrintMode::is_text) stream << std::endl;
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11ea0
testb $0x1, %al
jne 0x11c7e
jmp 0x11ccc
movl $0x10, %edi
callq 0x8280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x11b60
jmp 0x11c9a
movq 0x8(%rsp), %rdi
leaq 0x16572(%rip), %rsi     # 0x28218
leaq -0x10d(%rip), %rdx      # 0x11ba0
callq 0x8910
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x83c0
jmp 0x11cf4
jmp 0x11cce
movq 0x20(%rsp), %rdi
callq 0x11ea0
xorb $-0x1, %al
testb $0x1, %al
jne 0x11ce0
jmp 0x11cef
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11ec0
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x8960
nop
// File: fhirschman[P]CANF-gp/source/./../headers/gnuplot-iostream.h
// Function: gnuplotio::IteratorRange<__gnu_cxx::__normal_iterator<float const*, std::vector<float, std::allocator<float>>>, float>::deref() const
value_type deref() const {
		GNUPLOT_STATIC_ASSERT_MSG(sizeof(TV) && !is_container,
			"deref called on nested container");
		if(is_end()) {
			throw std::runtime_error("attepted to dereference past end of iterator");
		}
		return *it;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x11ea0
testb $0x1, %al
jne 0x11f7e
jmp 0x11fd0
movl $0x10, %edi
callq 0x8280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0xc6b2(%rip), %rsi      # 0x1e64b
callq 0x8200
jmp 0x11fa0
movq (%rsp), %rdi
movq 0x17045(%rip), %rsi     # 0x28ff0
movq 0x16fde(%rip), %rdx     # 0x28f90
callq 0x8910
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x83c0
jmp 0x11fe3
movq 0x8(%rsp), %rdi
callq 0x12010
movss (%rax), %xmm0
addq $0x28, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x8960
nopl (%rax)
// File: fhirschman[P]CANF-gp/source/./../headers/gnuplot-iostream.h
// Function: boost::enable_if_c<(2ul > 1) && gnuplotio::ModeSize::is_size, void>::type gnuplotio::print_block<2ul, gnuplotio::IteratorRange<__gnu_cxx::__normal_iterator<std::vector<float, std::allocator<float>> const*, std::vector<std::vector<float, std::allocator<float>>, std::allocator<std::vector<float, std::allocator<float>>>>>, std::vector<float, std::allocator<float>>>, gnuplotio::ModeSize>(std::ostream&, gnuplotio::IteratorRange<__gnu_cxx::__normal_iterator<std::vector<float, std::allocator<float>> const*, std::vector<std::vector<float, std::allocator<float>>, std::allocator<std::vector<float, std::allocator<float>>>>>, std::vector<float, std::allocator<float>>>&, gnuplotio::ModeSize)
typename boost::enable_if_c<(Depth>1) && PrintMode::is_size>::type
print_block(std::ostream &stream, T &arg, PrintMode) {
	if(arg.is_end()) throw plotting_empty_container();
	// It seems that size for two dimensional arrays needs the fastest varying index first,
	// contrary to intuition.  The gnuplot documentation is not too clear on this point.
	typename T::subiter_type sub = arg.deref_subiter();
	print_block<Depth-1>(stream, sub, PrintMode());
	stream << "," << get_range_size(arg);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11b40
testb $0x1, %al
jne 0x1210e
jmp 0x1215c
movl $0x10, %edi
callq 0x8280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x11b60
jmp 0x1212a
movq 0x10(%rsp), %rdi
leaq 0x160e2(%rip), %rsi     # 0x28218
leaq -0x59d(%rip), %rdx      # 0x11ba0
callq 0x8910
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x83c0
jmp 0x121b1
movq 0x40(%rsp), %rdi
callq 0x11bb0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x121c0
movq 0x48(%rsp), %rdi
leaq 0xbfc3(%rip), %rsi      # 0x1e14e
callq 0x84e0
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x12200
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x80e0
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x8960
nopl (%rax,%rax)
// File: fhirschman[P]CANF-gp/source/./../headers/gnuplot-iostream.h
// Function: unsigned long gnuplotio::get_range_size<gnuplotio::IteratorRange<__gnu_cxx::__normal_iterator<std::vector<float, std::allocator<float>> const*, std::vector<std::vector<float, std::allocator<float>>, std::allocator<std::vector<float, std::allocator<float>>>>>, std::vector<float, std::allocator<float>>>>(gnuplotio::IteratorRange<__gnu_cxx::__normal_iterator<std::vector<float, std::allocator<float>> const*, std::vector<std::vector<float, std::allocator<float>>, std::allocator<std::vector<float, std::allocator<float>>>>>, std::vector<float, std::allocator<float>>> const&)
size_t get_range_size(const T &arg) {
	// FIXME - not the fastest way.  Implement a size() method for range.
	size_t ret = 0;
	for(T i=arg; !i.is_end(); i.inc()) ++ret;
	return ret;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x11b40
xorb $-0x1, %al
testb $0x1, %al
jne 0x1223a
jmp 0x12254
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x11d00
jmp 0x12228
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: fhirschman[P]CANF-gp/source/./../headers/./../headers/gnuplot-iostream.h
// Function: gnuplotio::Gnuplot::get_default_cmd[abi:cxx11]()
static std::string get_default_cmd() {
		GNUPLOT_MSVC_WARNING_4996_PUSH
		char *from_env = std::getenv("GNUPLOT_IOSTREAM_CMD");
		GNUPLOT_MSVC_WARNING_4996_POP
		if(from_env && from_env[0]) {
			return from_env;
		} else {
			return GNUPLOT_DEFAULT_COMMAND;
		}
	}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x50(%rsp)
leaq 0xb7db(%rip), %rdi      # 0x1e978
callq 0x8680
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x1320e
movq 0x48(%rsp), %rax
cmpb $0x0, (%rax)
je 0x1320e
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x8970
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xbd90
jmp 0x131e8
leaq 0x47(%rsp), %rdi
callq 0x85a0
jmp 0x1325b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x47(%rsp), %rdi
callq 0x85a0
jmp 0x13265
leaq 0x33(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x8970
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0xb75f(%rip), %rsi      # 0x1e98d
callq 0xbd90
jmp 0x13235
leaq 0x33(%rsp), %rdi
callq 0x85a0
jmp 0x1325b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x33(%rsp), %rdi
callq 0x85a0
jmp 0x13265
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x8960
nop
// File: fhirschman[P]CANF-gp/source/./../headers/./../headers/gnuplot-iostream.h
// Function: gnuplotio::Gnuplot::~Gnuplot()
~Gnuplot() {
		if(debug_messages) {
			std::cerr << "ending gnuplot session" << std::endl;
		}

		// FIXME - boost's close method calls close() on the file descriptor, but we need to
		// use sometimes use pclose instead.  For now, just skip calling boost's close and use
		// flush just in case.
		do_flush();
		// Wish boost had a pclose method...
		//close();

		fh_close();

		delete feedback;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x38(%rcx), %rdx
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %rdx, (%rax,%rcx)
testb $0x1, 0xc0(%rax)
je 0x170ff
movq 0x11f11(%rip), %rdi     # 0x28fe8
leaq 0x7a15(%rip), %rsi      # 0x1eaf3
callq 0x84e0
movq %rax, 0x10(%rsp)
jmp 0x170ea
movq 0x10(%rsp), %rdi
movq 0x11e7a(%rip), %rsi     # 0x28f70
callq 0x8560
jmp 0x170fd
jmp 0x170ff
movq 0x18(%rsp), %rdi
callq 0x12330
jmp 0x1710b
movq 0x18(%rsp), %rdi
addq $0x90, %rdi
callq 0x17180
jmp 0x1711e
movq 0x18(%rsp), %rax
movq 0xa0(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x17140
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rdi
addq $0xa8, %rdi
callq 0x12f20
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdi
addq $0x8, %rsi
callq 0x12f80
addq $0x38, %rsp
retq
movq %rax, %rdi
callq 0xbb20
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: fhirschman[P]CANF-gp/source/./../headers/./../headers/gnuplot-iostream.h
// Function: gnuplotio::FileHandleWrapper::fh_close()
void fh_close() {
		if(should_use_pclose) {
			if(GNUPLOT_PCLOSE(wrapped_fh)) {
				std::cerr << "pclose returned error" << std::endl;
			}
		} else {
			if(fclose(wrapped_fh)) {
				std::cerr << "fclose returned error" << std::endl;
			}
		}
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x8(%rax)
je 0x171cf
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x87a0
cmpl $0x0, %eax
je 0x171cd
movq 0x11e36(%rip), %rdi     # 0x28fe8
leaq 0x7951(%rip), %rsi      # 0x1eb0a
callq 0x84e0
movq %rax, %rdi
movq 0x11da8(%rip), %rsi     # 0x28f70
callq 0x8560
jmp 0x17205
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x84f0
cmpl $0x0, %eax
je 0x17203
movq 0x11e00(%rip), %rdi     # 0x28fe8
leaq 0x7931(%rip), %rsi      # 0x1eb20
callq 0x84e0
movq %rax, %rdi
movq 0x11d72(%rip), %rsi     # 0x28f70
callq 0x8560
jmp 0x17205
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: fhirschman[P]CANF-gp/source/CPU_functions.cc
// Function: solve_cnewton_iter(std::complex<double>&, double, int, std::vector<double, std::allocator<double>>&, int, std::vector<double, std::allocator<double>>&)
int solve_cnewton_iter(complex<double>& start, double accuracy, int max_iterations, vector<double>& params, int n_terms, vector<double>& rationalExponents){
	int res=0;
	complex<double> z, help;
	z = start;
	for(int i = 0; i < max_iterations; i++){
		help = get_fdf(z,params,n_terms,rationalExponents);
		z = z + help;
		if(abs(help) < accuracy){
			res= i;
			break;
		}
		else{
			res= max_iterations;
		}
	}
	return res;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movsd %xmm0, 0x78(%rsp)
movl %esi, 0x74(%rsp)
movq %rdx, 0x68(%rsp)
movl %ecx, 0x64(%rsp)
movq %r8, 0x58(%rsp)
movl $0x0, 0x54(%rsp)
leaq 0x40(%rsp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xc0c0
leaq 0x30(%rsp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xc0c0
movq 0x80(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x40(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x48(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x74(%rsp), %eax
jge 0x17dd2
movq 0x68(%rsp), %rsi
movl 0x64(%rsp), %edx
movq 0x58(%rsp), %rcx
leaq 0x40(%rsp), %rdi
callq 0x17680
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xc230
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x18d00
movaps %xmm0, %xmm1
movsd 0x78(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x17db8
movl 0x2c(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0x17dd2
movl 0x74(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0x17dc2
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x17d20
movl 0x54(%rsp), %eax
addq $0x88, %rsp
retq
nop
// File: fhirschman[P]CANF-gp/source/CPU_functions.cc
// Function: getIterMatrix(std::vector<std::vector<float, std::allocator<float>>, std::allocator<std::vector<float, std::allocator<float>>>>&)
void getIterMatrix(vector<vector<float>>& iterImage){
	for(int i=0; i<N_Y; i++){
		vector<float> row;
		for(int j=0; j<N_X; j++){
			iter_matrix[i][j]=solve_cnewton_iter(cnumber_matrix[i][j], ACCURACY, N_ITER, POLY_COEFFS, POLY_N_TERMS, POLY_EXPONS);
			row.push_back(log(iter_matrix[i][j]));
		}
		iterImage.push_back(row);
	}
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
leaq 0x11aec(%rip), %rcx     # 0x298e8
cmpl (%rcx), %eax
jge 0x17f48
leaq 0x30(%rsp), %rdi
callq 0x18d40
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
leaq 0x11ac3(%rip), %rcx     # 0x298e4
cmpl (%rcx), %eax
jge 0x17f1d
leaq 0x11c48(%rip), %rax     # 0x29a78
movq (%rax), %rax
movslq 0x4c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movslq 0x2c(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
leaq 0x11b29(%rip), %rax     # 0x29978
movsd (%rax), %xmm0
leaq 0x11a86(%rip), %rax     # 0x298e0
movl (%rax), %esi
leaq 0x11a79(%rip), %rax     # 0x298dc
movl (%rax), %ecx
leaq 0x11b6c(%rip), %rdx     # 0x299d8
leaq 0x11b7d(%rip), %r8      # 0x299f0
callq 0x17cb0
movl %eax, 0x14(%rsp)
jmp 0x17e7e
movslq 0x4c(%rsp), %rsi
leaq 0x11b7e(%rip), %rdi     # 0x29a08
movq %rdi, (%rsp)
callq 0xbd50
movq %rax, %rdi
movslq 0x2c(%rsp), %rsi
callq 0xbd70
movl 0x14(%rsp), %ecx
movq (%rsp), %rdi
movl %ecx, (%rax)
movslq 0x4c(%rsp), %rsi
callq 0xbd50
movq %rax, %rdi
movslq 0x2c(%rsp), %rsi
callq 0xbd70
movl (%rax), %edi
callq 0xbd30
movsd %xmm0, 0x8(%rsp)
jmp 0x17ed0
movsd 0x8(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x18d50
jmp 0x17ef1
jmp 0x17ef3
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x17e16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x18df0
jmp 0x17f4d
movq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x18d80
jmp 0x17f2e
leaq 0x30(%rsp), %rdi
callq 0x18df0
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x17df1
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x8960
nopw (%rax,%rax)
// File: fhirschman[P]CANF-gp/source/./../headers/gnuplot-iostream.h
// Function: gnuplotio::Gnuplot::getMouse(double&, double&, int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void getMouse(
		double &mx, double &my, int &mb,
		std::string msg="Click Mouse!"
	) {
		allocFeedback();

		*this << "set mouse" << std::endl;
		*this << "pause mouse \"" << msg << "\\n\"" << std::endl;
		*this << "if (exists(\"MOUSE_X\")) print MOUSE_X, MOUSE_Y, MOUSE_BUTTON; else print 0, 0, -1;" << std::endl;
		if(debug_messages) {
			std::cerr << "begin scanf" << std::endl;
		}
		if(3 != fscanf(feedback->handle(), "%50lf %50lf %50d", &mx, &my, &mb)) {
			throw std::runtime_error("could not parse reply");
		}
		if(debug_messages) {
			std::cerr << "end scanf" << std::endl;
		}
	}

// Assembly:
subq $0x58, %rsp
movq %r8, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xe720
movq 0x18(%rsp), %rdi
leaq 0x1b41(%rip), %rsi      # 0x1f18e
callq 0x84e0
movq %rax, %rdi
movq 0xb914(%rip), %rsi      # 0x28f70
callq 0x8560
movq 0x18(%rsp), %rdi
leaq 0x1b2b(%rip), %rsi      # 0x1f198
callq 0x84e0
movq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x8450
movq %rax, %rdi
leaq 0x1b1d(%rip), %rsi      # 0x1f1a6
callq 0x84e0
movq %rax, %rdi
movq 0xb8d8(%rip), %rsi      # 0x28f70
callq 0x8560
movq 0x18(%rsp), %rdi
leaq 0x1b01(%rip), %rsi      # 0x1f1aa
callq 0x84e0
movq %rax, %rdi
movq 0xb8b8(%rip), %rsi      # 0x28f70
callq 0x8560
movq 0x18(%rsp), %rax
testb $0x1, 0xc0(%rax)
je 0x1d6ed
movq 0xb916(%rip), %rdi      # 0x28fe8
leaq 0xcdc(%rip), %rsi       # 0x1e3b5
callq 0x84e0
movq %rax, %rdi
movq 0xb888(%rip), %rsi      # 0x28f70
callq 0x8560
movq 0x18(%rsp), %rax
movq 0xa0(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %rdi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
leaq 0x1ae4(%rip), %rsi      # 0x1f1fc
movb $0x0, %al
callq 0x89d0
movl %eax, %ecx
movl $0x3, %eax
cmpl %ecx, %eax
je 0x1d77f
movl $0x10, %edi
callq 0x8280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0xc8b(%rip), %rsi       # 0x1e3d1
callq 0x8200
jmp 0x1d74d
movq 0x8(%rsp), %rdi
movq 0xb897(%rip), %rsi      # 0x28ff0
movq 0xb830(%rip), %rdx      # 0x28f90
callq 0x8910
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x83c0
jmp 0x1d7b4
movq 0x18(%rsp), %rax
testb $0x1, 0xc0(%rax)
je 0x1d7af
movq 0xb854(%rip), %rdi      # 0x28fe8
leaq 0xc4c(%rip), %rsi       # 0x1e3e7
callq 0x84e0
movq %rax, %rdi
movq 0xb7c6(%rip), %rsi      # 0x28f70
callq 0x8560
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x8960
nop
// File: arinaschwartz[P]KNN-MNIST/MNISTDataset.cpp
// Function: MNISTDataset::readUInt32(std::istream&)
uint32 MNISTDataset::readUInt32(std::istream &is)
{
	char buf[4], *p;
	uint32 v = 0;

	is.read(buf, 4);

	p = ((char*) &v);

	p[0] = buf[3];
	p[1] = buf[2];
	p[2] = buf[1];
	p[3] = buf[0];

	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
movl $0x4, %edx
callq 0x3270
leaq -0x24(%rbp), %rax
movq %rax, -0x20(%rbp)
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movb -0x12(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movb -0x13(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x2(%rax)
movb -0x14(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x3(%rax)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: arinaschwartz[P]KNN-MNIST/MNISTImageImpls.cpp
// Function: ArrayMNISTImage::distance(MNISTImage const*) const
double ArrayMNISTImage::distance(const MNISTImage *img) const
{
    const ArrayMNISTImage *arrayimg = dynamic_cast<const ArrayMNISTImage*>(img);
    double squared_distance = 0;
    double first_image_point;
    double second_image_point;
    double diff;

    for(uint32 i = 0; i < size; i++){
        first_image_point = this->data[i];
        second_image_point = arrayimg->data[i];
        diff = first_image_point - second_image_point;
        squared_distance += (diff*diff);
    }
	return sqrt(squared_distance);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x4117
movq -0x48(%rbp), %rdi
leaq 0x6aff(%rip), %rsi      # 0xac00
leaq 0x6b58(%rip), %rdx      # 0xac60
xorl %eax, %eax
movl %eax, %ecx
callq 0x3230
movq %rax, -0x58(%rbp)
jmp 0x411f
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0x411f
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x50(%rbp), %rcx
movl -0x3c(%rbp), %eax
cmpl 0x18(%rcx), %eax
jae 0x41a8
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x3c(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x3c(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x4136
movsd -0x20(%rbp), %xmm0
callq 0x3160
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: arinaschwartz[P]KNN-MNIST/MNISTImageImpls.cpp
// Function: FullArrayMNISTImage::FullArrayMNISTImage(unsigned char*, unsigned int, unsigned char)
FullArrayMNISTImage::FullArrayMNISTImage(uint8 data[], uint32 size, uint8 label):
		ArrayMNISTImage(label)
{
    
    this->data = new uint8[size];
    for(uint32 i = 0; i < size; i++){
        this->data[i] = data[i];
    }

    this->size = size;
    this->label = label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movzbl -0x15(%rbp), %esi
callq 0x4080
movq -0x38(%rbp), %rax
leaq 0x6aec(%rip), %rcx      # 0xace0
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, %edi
callq 0x3030
movq %rax, -0x30(%rbp)
jmp 0x4207
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x425c
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x28(%rbp), %edx
movb (%rcx,%rdx), %dl
movq 0x10(%rax), %rax
movl -0x28(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x421a
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4650
jmp 0x4272
movq -0x38(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x18(%rax)
movb -0x15(%rbp), %cl
movb %cl, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3310
nopl (%rax,%rax)
// File: arinaschwartz[P]KNN-MNIST/MNISTImageImpls.cpp
// Function: DownsampleMNISTImage::DownsampleMNISTImage(unsigned char*, unsigned int, unsigned char, unsigned int)
DownsampleMNISTImage::DownsampleMNISTImage(uint8 data[], uint32 size, uint8 label, uint32 factor):
		ArrayMNISTImage(label)
{
    uint32 new_size = size/factor;
	this->data = new uint8[new_size];
    for(uint32 i = 0; i < size; i++){
        if(i % factor == 0){
            this->data[i/factor] = data[i];
        }
    }
    this->size = new_size;
    this->label = label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb %al, -0x15(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movzbl -0x15(%rbp), %esi
callq 0x4080
movq -0x40(%rbp), %rax
leaq 0x6a50(%rip), %rcx      # 0xad08
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
movl -0x1c(%rbp), %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %edi
callq 0x3030
movq %rax, -0x38(%rbp)
jmp 0x42d8
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x4355
movl -0x30(%rbp), %eax
xorl %edx, %edx
divl -0x1c(%rbp)
cmpl $0x0, %edx
jne 0x4348
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x30(%rbp), %edx
movb (%rcx,%rdx), %cl
movb %cl, -0x49(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movl -0x30(%rbp), %eax
xorl %edx, %edx
divl -0x1c(%rbp)
movb -0x49(%rbp), %dl
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
jmp 0x4348
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4650
jmp 0x436b
jmp 0x434a
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x42eb
movq -0x40(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, 0x18(%rax)
movb -0x15(%rbp), %cl
movb %cl, 0x8(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3310
nopw %cs:(%rax,%rax)
// File: arinaschwartz[P]KNN-MNIST/MNISTImageImpls.cpp
// Function: ScaledMNISTImage::ScaledMNISTImage(unsigned char*, unsigned int, unsigned int, unsigned char, unsigned int)
ScaledMNISTImage::ScaledMNISTImage(uint8 data[], uint32 numRows, uint32 numCols, uint8 label, uint32 factor):
		ArrayMNISTImage(label)
{
    uint32 newNumRows = numRows/factor;
    uint32 newNumCols = numCols/factor;
    this->data = new uint8[newNumRows*newNumCols];
    for(uint32 i = 0; i < numRows; i++){
        for(uint32 j = 0; j < numCols; j++){
            this->data[(i/factor)*newNumRows + (j/factor)] +=
                        (data[(i * numRows) + j])/(factor*factor);
        }
    }
    this->size = newNumRows*newNumCols;
    this->label = label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movzbl -0x19(%rbp), %esi
callq 0x4080
movq -0x58(%rbp), %rax
leaq 0x6974(%rip), %rcx      # 0xad30
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
movl -0x20(%rbp), %ecx
xorl %edx, %edx
movl %edx, -0x4c(%rbp)
divl %ecx
movl -0x4c(%rbp), %edx
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
movl -0x20(%rbp), %ecx
divl %ecx
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl -0x28(%rbp), %ecx
imull %ecx, %eax
movl %eax, %edi
callq 0x3030
movq %rax, -0x48(%rbp)
jmp 0x43f3
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x44a9
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x4499
movq -0x10(%rbp), %rax
movl -0x38(%rbp), %ecx
imull -0x14(%rbp), %ecx
addl -0x3c(%rbp), %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl -0x20(%rbp), %ecx
imull -0x20(%rbp), %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %esi
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x60(%rbp)
movl -0x38(%rbp), %eax
xorl %edx, %edx
divl -0x20(%rbp)
movl %eax, %ecx
imull -0x24(%rbp), %ecx
movl -0x3c(%rbp), %eax
xorl %edx, %edx
divl -0x20(%rbp)
movl %eax, %edx
movq -0x60(%rbp), %rax
addl %edx, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %edx
addl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x4419
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x4650
jmp 0x44c3
jmp 0x449b
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x4406
movq -0x58(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x28(%rbp), %ecx
movl %ecx, 0x18(%rax)
movb -0x19(%rbp), %cl
movb %cl, 0x8(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3310
nopl (%rax)
// File: arinaschwartz[P]KNN-MNIST/MNISTImageImpls.cpp
// Function: SumMNISTImage::SumMNISTImage(unsigned char*, unsigned int, unsigned char)
SumMNISTImage::SumMNISTImage(uint8 data[], uint32 size, uint8 label):
		MNISTImage(label)
{
	uint32 sum = 0;
    for(uint32 i = 0; i < size; i++){
        sum += data[i];
    }
    this->sum = sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movzbl -0x15(%rbp), %esi
callq 0x3f90
movq -0x28(%rbp), %rax
leaq 0x6774(%rip), %rcx      # 0xac78
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x453d
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
movzbl (%rax,%rcx), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4519
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: arinaschwartz[P]KNN-MNIST/MNISTImageImpls.cpp
// Function: SumMNISTImage::distance(MNISTImage const*) const
double SumMNISTImage::distance(const MNISTImage *img) const
{
    const SumMNISTImage *arrayimg = dynamic_cast<const SumMNISTImage*>(img);
    double first_image_sum = this->sum;
    double second_image_sum = arrayimg->sum;
    double diff = first_image_sum - second_image_sum;
    double distance = sqrt((diff*diff));

	return distance;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x4597
movq -0x40(%rbp), %rdi
leaq 0x667f(%rip), %rsi      # 0xac00
leaq 0x6718(%rip), %rdx      # 0xaca0
xorl %eax, %eax
movl %eax, %ecx
callq 0x3230
movq %rax, -0x50(%rbp)
jmp 0x459f
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x459f
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl 0xc(%rax), %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
callq 0x3160
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rellla[P]E3DC-Rscp/RscpMain.cpp
// Function: createAuthRequest(SRscpFrameBuffer*, e3dc_config_t*)
int createAuthRequest(SRscpFrameBuffer * frameBuffer, e3dc_config_t *e3dc_config)
{
    RscpProtocol protocol;
    SRscpValue rootValue;
    // The root container is create with the TAG ID 0 which is not used by any device.
    protocol.createContainerValue(&rootValue, 0);

    //---------------------------------------------------------------------------------------------------------
    // Create a auth request frame
    //---------------------------------------------------------------------------------------------------------
    printf("\nRequest authentication\n");
    // authentication request
    SRscpValue authenContainer;
    protocol.createContainerValue(&authenContainer,
				  TAG_RSCP_REQ_AUTHENTICATION);
    protocol.appendValue(&authenContainer, TAG_RSCP_AUTHENTICATION_USER,
			 e3dc_config->e3dc_user);
    protocol.appendValue(&authenContainer,
			 TAG_RSCP_AUTHENTICATION_PASSWORD, e3dc_config->e3dc_password);
    // append sub-container to root container
    protocol.appendValue(&rootValue, authenContainer);
    // free memory of sub-container as it is now copied to rootValue
    protocol.destroyValueData(authenContainer);

    // create buffer frame to send data to the S10
    protocol.createFrameAsBuffer(frameBuffer, rootValue.data, rootValue.length, true);	// true to calculate CRC on for transfer
    // the root value object should be destroyed after the data is copied into the frameBuffer and is not needed anymore
    protocol.destroyValueData(rootValue);

    return 0;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7840
movq 0x8(%rsp), %rdi
movl $0x0, 0x3c(%rsp)
leaq 0x41(%rsp), %rsi
leaq 0x3c(%rsp), %rdx
callq 0x5b30
jmp 0x245b
leaq 0x1dc32(%rip), %rdi     # 0x20094
xorl %eax, %eax
callq 0x2040
jmp 0x246b
movl $0x1, 0x18(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x1d(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x5b30
jmp 0x2489
movl $0x2, 0x14(%rsp)
movq 0x58(%rsp), %rcx
addq $0x18, %rcx
leaq 0x50(%rsp), %rdi
leaq 0x1d(%rsp), %rsi
leaq 0x14(%rsp), %rdx
callq 0x5b70
jmp 0x24b0
movl $0x3, 0x10(%rsp)
movq 0x58(%rsp), %rcx
addq $0x98, %rcx
leaq 0x50(%rsp), %rdi
leaq 0x1d(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x5b70
jmp 0x24da
leaq 0x50(%rsp), %rdi
leaq 0x41(%rsp), %rsi
leaq 0x1d(%rsp), %rdx
callq 0x5bf0
jmp 0x24f0
leaq 0x50(%rsp), %rdi
leaq 0x1d(%rsp), %rsi
callq 0x5cc0
jmp 0x2501
movq 0x60(%rsp), %rsi
movq 0x48(%rsp), %rdx
movzwl 0x46(%rsp), %ecx
leaq 0x50(%rsp), %rdi
movl $0x1, %r8d
callq 0x7a90
jmp 0x2522
leaq 0x50(%rsp), %rdi
leaq 0x41(%rsp), %rsi
callq 0x5cc0
jmp 0x2533
leaq 0x50(%rsp), %rdi
callq 0x7860
xorl %eax, %eax
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x7860
movq 0x30(%rsp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)
// File: rellla[P]E3DC-Rscp/RscpMain.cpp
// Function: showhelp(char*)
void showhelp(char *prog)
{
    printf("Usage:\n");
    printf("%s [-hebts] [-w 0|1]\n", prog);
    printf("  --help, -h         \tshows this help\n");
    printf("  --battery, -b      \tshows battery details\n");
    printf("  --ems, -e          \tshows ems details\n");
    printf("  --time, -t         \tshows idle periods\n");
    printf("  --settime, -s      \tsets idle periods (currently hardcoded values)\n");
    printf("  --weather, -w      \tsets weather enable option [on|off]\n");
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
leaq 0x1b561(%rip), %rdi     # 0x2050d
movb $0x0, %al
callq 0x2040
movq (%rsp), %rsi
leaq 0x1b557(%rip), %rdi     # 0x20515
movb $0x0, %al
callq 0x2040
leaq 0x1b55f(%rip), %rdi     # 0x2052b
movb $0x0, %al
callq 0x2040
leaq 0x1b578(%rip), %rdi     # 0x20552
movb $0x0, %al
callq 0x2040
leaq 0x1b597(%rip), %rdi     # 0x2057f
movb $0x0, %al
callq 0x2040
leaq 0x1b5b2(%rip), %rdi     # 0x205a8
movb $0x0, %al
callq 0x2040
leaq 0x1b5ce(%rip), %rdi     # 0x205d2
movb $0x0, %al
callq 0x2040
leaq 0x1b606(%rip), %rdi     # 0x20618
movb $0x0, %al
callq 0x2040
popq %rax
retq
nopl (%rax,%rax)
// File: rellla[P]E3DC-Rscp/RscpMain.cpp
// Function: processReceiveBuffer(unsigned char const*, int, int*)
static int processReceiveBuffer(const unsigned char *ucBuffer,
				int iLength, int *isAuthRequest)
{
    RscpProtocol protocol;
    SRscpFrame frame;

    int iResult = protocol.parseFrame(ucBuffer, iLength, &frame);
    if (iResult < 0) {
	// check if frame length error occured
	// in that case the full frame length was not received yet
	// and the receive function must get more data
	if (iResult == RSCP::ERR_INVALID_FRAME_LENGTH) {
	    return 0;
	}
	// otherwise a not recoverable error occured and the connection can be closed
	else {
	    return iResult;
	}
    }

    int iProcessedBytes = iResult;

    // process each SRscpValue struct seperately
    for (unsigned int i; i < frame.data.size(); i++) {
	handleResponseValue(&protocol, &frame.data[i], isAuthRequest);
    }

    // destroy frame data and free memory
    protocol.destroyFrameData(frame);

    // returned processed amount of bytes
    return iProcessedBytes;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movl %esi, 0x94(%rsp)
movq %rdx, 0x88(%rsp)
leaq 0x80(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7840
leaq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x6cc0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq 0x98(%rsp), %rsi
movl 0x94(%rsp), %eax
movl %eax, 0x40(%rsp)
leaq 0x40(%rsp), %rdx
callq 0x8690
movl %eax, 0x24(%rsp)
jmp 0x59fc
movl 0x24(%rsp), %eax
movl %eax, 0x44(%rsp)
cmpl $0x0, 0x44(%rsp)
jge 0x5a6c
cmpl $-0x5, 0x44(%rsp)
jne 0x5a54
movl $0x0, 0xa4(%rsp)
movl $0x1, 0x30(%rsp)
jmp 0x5af8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x6d10
leaq 0x80(%rsp), %rdi
callq 0x7860
jmp 0x5b1e
movl 0x44(%rsp), %eax
movl %eax, 0xa4(%rsp)
movl $0x1, 0x30(%rsp)
jmp 0x5af8
movl 0x44(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x28(%rsp), %eax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
addq $0x18, %rdi
callq 0x5e80
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x5ad1
leaq 0x60(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0x5ea0
movq %rax, %rsi
movq 0x88(%rsp), %rdx
leaq 0x80(%rsp), %rdi
callq 0x39a0
jmp 0x5ac2
jmp 0x5ac4
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x5a74
leaq 0x80(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x6ce0
jmp 0x5ae5
movl 0x2c(%rsp), %eax
movl %eax, 0xa4(%rsp)
movl $0x1, 0x30(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x6d10
leaq 0x80(%rsp), %rdi
callq 0x7860
movl 0xa4(%rsp), %eax
addq $0xa8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x22a0
nopl (%rax,%rax)
// File: rellla[P]E3DC-Rscp/./RscpProtocol.h
// Function: unsigned int RscpProtocol::getValue<unsigned int>(SRscpValue const*)
cType getValue(const SRscpValue* value) {
    	if((value == NULL) || (value->data == NULL)) {
    		return cType();
    	}
    	// if the size is smaller than needed copy only the smaller part
    	if(sizeof(cType) <= value->length) {
    		cType tTmp;
    		memcpy(&tTmp, value->data, sizeof(cType));
    		return tTmp;
    	}
    	// if the size needed is bigger then zero out the rest
    	else {
    		cType tTmp;
    		memset(&tTmp, 0, sizeof(cType));
    		memcpy(&tTmp, value->data, value->length);
    		return tTmp;
    	}
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x69c2
movq 0x10(%rsp), %rax
cmpq $0x0, 0x7(%rax)
jne 0x69cc
movl $0x0, 0x24(%rsp)
jmp 0x6a31
movq 0x10(%rsp), %rax
movzwl 0x5(%rax), %eax
movl %eax, %ecx
movl $0x4, %eax
cmpq %rcx, %rax
ja 0x69fa
movq 0x10(%rsp), %rax
movq 0x7(%rax), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x6a31
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x20e0
movq 0x10(%rsp), %rax
movq 0x7(%rax), %rsi
movq 0x10(%rsp), %rax
movzwl 0x5(%rax), %eax
movl %eax, %edx
leaq 0x8(%rsp), %rdi
callq 0x2130
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)