LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: magmastonealex[P]fbkeyboard/src/Display.cpp
// Function: Display::print_letter(char, int, int, int, bool)
void Display::print_letter(char letter, int atX, int atY, int scale, bool inverted) {
	RGB white = {0xFF, 0xFF, 0xFF};
	RGB black = {0x10, 0x10, 0x10};
	for (int y=0; y < 8; y++) {
		for (int x = 0; x < 8; x++) {
			if(font8x8_basic[(uint8_t) letter][x] & (uint8_t)(1 << (7-(y)))) {
				set_px(inverted ? black : white, atX + (x*scale), atY + (y*scale), scale);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movb %sil, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movw 0x2547(%rip), %ax       # 0x5088
movw %ax, -0x1c(%rbp)
movb 0x253f(%rip), %al       # 0x508a
movb %al, -0x1a(%rbp)
movw 0x2536(%rip), %ax       # 0x508b
movw %ax, -0x1f(%rbp)
movb 0x252e(%rip), %al       # 0x508d
movb %al, -0x1d(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x8, -0x24(%rbp)
jge 0x2c46
movl $0x0, -0x28(%rbp)
cmpl $0x8, -0x28(%rbp)
jge 0x2c36
movzbl -0x9(%rbp), %eax
movl %eax, %ecx
leaq 0x465f(%rip), %rax      # 0x71f0
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl $0x7, %ecx
subl -0x24(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x2c26
testb $0x1, -0x19(%rbp)
je 0x2bcb
leaq -0x1f(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x2bd5
leaq -0x1c(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x2bd5
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rax
movb 0x2(%rax), %cl
movb %cl, -0x2a(%rbp)
movw (%rax), %ax
movw %ax, -0x2c(%rbp)
movl -0x10(%rbp), %edx
movl -0x28(%rbp), %eax
movl -0x18(%rbp), %r8d
imull %r8d, %eax
addl %eax, %edx
movl -0x14(%rbp), %ecx
movl -0x24(%rbp), %eax
imull %r8d, %eax
addl %eax, %ecx
movb -0x2a(%rbp), %al
movb %al, -0x2e(%rbp)
movw -0x2c(%rbp), %ax
movw %ax, -0x30(%rbp)
movzbl -0x2e(%rbp), %eax
shll $0x10, %eax
movzwl -0x30(%rbp), %esi
orl %eax, %esi
callq 0x2a10
jmp 0x2c28
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2b7a
jmp 0x2c38
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2b69
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: magmastonealex[P]fbkeyboard/src/Display.cpp
// Function: Display::fastRect(int, int, int, int, RGB)
void Display::fastRect(int atX, int atY, int width, int height, RGB color) {
	for(int y = 0; y < height; y++) {
		for(int x = 0; x < width; x++) {
			keyboardImage->data[((atY+y)*keyboardImage->w) + (atX + x)].r = color.r;
			keyboardImage->data[((atY+y)*keyboardImage->w) + (atX + x)].g = color.g;
			keyboardImage->data[((atY+y)*keyboardImage->w) + (atX + x)].b = color.b;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %r9w, %ax
movw %ax, -0x3(%rbp)
shrl $0x10, %r9d
movb %r9b, %al
movb %al, -0x1(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x2d4d
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2d3d
movq -0x30(%rbp), %rsi
movb -0x3(%rbp), %cl
movq 0x30(%rsi), %rax
movq 0x8(%rax), %rax
movl -0x18(%rbp), %edx
addl -0x24(%rbp), %edx
movq 0x30(%rsi), %rdi
imull (%rdi), %edx
movl -0x14(%rbp), %edi
addl -0x28(%rbp), %edi
addl %edi, %edx
movslq %edx, %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movb %cl, (%rax)
movb -0x2(%rbp), %cl
movq 0x30(%rsi), %rax
movq 0x8(%rax), %rax
movl -0x18(%rbp), %edx
addl -0x24(%rbp), %edx
movq 0x30(%rsi), %rdi
imull (%rdi), %edx
movl -0x14(%rbp), %edi
addl -0x28(%rbp), %edi
addl %edi, %edx
movslq %edx, %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x1(%rax)
movb -0x1(%rbp), %cl
movq 0x30(%rsi), %rax
movq 0x8(%rax), %rax
movl -0x18(%rbp), %edx
addl -0x24(%rbp), %edx
movq 0x30(%rsi), %rsi
imull (%rsi), %edx
movl -0x14(%rbp), %esi
addl -0x28(%rbp), %esi
addl %esi, %edx
movslq %edx, %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x2(%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2c99
jmp 0x2d3f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2c86
popq %rbp
retq
nop
// File: magmastonealex[P]fbkeyboard/src/Display.cpp
// Function: Display::xLine(int, int, RGB)
void Display::xLine(int startX, int y, RGB color) {
	for(int x = startX; x < keyboardImage->w; x++) {
		keyboardImage->data[((y)*keyboardImage->w) + x].r = color.r;
		keyboardImage->data[((y)*keyboardImage->w) + x].g = color.g;
		keyboardImage->data[((y)*keyboardImage->w) + x].b = color.b;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %cx, %ax
movw %ax, -0x3(%rbp)
shrl $0x10, %ecx
movb %cl, %al
movb %al, -0x1(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
movq 0x30(%rcx), %rcx
cmpl (%rcx), %eax
jge 0x2e0e
movq -0x28(%rbp), %rsi
movb -0x3(%rbp), %cl
movq 0x30(%rsi), %rax
movq 0x8(%rax), %rax
movl -0x18(%rbp), %edx
movq 0x30(%rsi), %rdi
imull (%rdi), %edx
addl -0x1c(%rbp), %edx
movslq %edx, %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movb %cl, (%rax)
movb -0x2(%rbp), %cl
movq 0x30(%rsi), %rax
movq 0x8(%rax), %rax
movl -0x18(%rbp), %edx
movq 0x30(%rsi), %rdi
imull (%rdi), %edx
addl -0x1c(%rbp), %edx
movslq %edx, %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x1(%rax)
movb -0x1(%rbp), %cl
movq 0x30(%rsi), %rax
movq 0x8(%rax), %rax
movl -0x18(%rbp), %edx
movq 0x30(%rsi), %rsi
imull (%rsi), %edx
addl -0x1c(%rbp), %edx
movslq %edx, %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x2(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2d7b
popq %rbp
retq
// File: magmastonealex[P]fbkeyboard/src/Display.cpp
// Function: Display::yLine(int, int, RGB)
void Display::yLine(int x, int startY, RGB color) {
	for(int y = startY; y < keyboardImage->h; y++) {
		keyboardImage->data[((y)*keyboardImage->w) + x].r = color.r;
		keyboardImage->data[((y)*keyboardImage->w) + x].g = color.g;
		keyboardImage->data[((y)*keyboardImage->w) + x].b = color.b;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %cx, %ax
movw %ax, -0x3(%rbp)
shrl $0x10, %ecx
movb %cl, %al
movb %al, -0x1(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
movq 0x30(%rcx), %rcx
cmpl 0x4(%rcx), %eax
jge 0x2ecf
movq -0x28(%rbp), %rsi
movb -0x3(%rbp), %cl
movq 0x30(%rsi), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %edx
movq 0x30(%rsi), %rdi
imull (%rdi), %edx
addl -0x14(%rbp), %edx
movslq %edx, %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movb %cl, (%rax)
movb -0x2(%rbp), %cl
movq 0x30(%rsi), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %edx
movq 0x30(%rsi), %rdi
imull (%rdi), %edx
addl -0x14(%rbp), %edx
movslq %edx, %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x1(%rax)
movb -0x1(%rbp), %cl
movq 0x30(%rsi), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %edx
movq 0x30(%rsi), %rsi
imull (%rsi), %edx
addl -0x14(%rbp), %edx
movslq %edx, %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x2(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2e3b
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: magmastonealex[P]fbkeyboard/src/Display.h
// Function: Display::toggleSym2()
void toggleSym2() {
		if(currentKeyboard == &SY2keyboard) {
			currentKeyboard = &LCkeyboard;
		}
		else {
			currentKeyboard = &SY2keyboard;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x60(%rcx), %rax
addq $0xcb, %rcx
cmpq %rcx, %rax
jne 0x36b1
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x68, %rcx
movq %rcx, 0x60(%rax)
jmp 0x36c3
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0xcb, %rcx
movq %rcx, 0x60(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: magmastonealex[P]fbkeyboard/src/Display.h
// Function: Display::toggleSym1()
void toggleSym1() {
		if(currentKeyboard == &SYkeyboard) {
			currentKeyboard = &LCkeyboard;
		}
		else {
			currentKeyboard = &SYkeyboard;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x60(%rcx), %rax
addq $0xaa, %rcx
cmpq %rcx, %rax
jne 0x3701
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x68, %rcx
movq %rcx, 0x60(%rax)
jmp 0x3713
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0xaa, %rcx
movq %rcx, 0x60(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: magmastonealex[P]fbkeyboard/src/Display.h
// Function: Display::toggleUpper()
void toggleUpper() {
		if(currentKeyboard == &UCkeyboard) {
			currentKeyboard = &LCkeyboard;
		}
		else {
			currentKeyboard = &UCkeyboard;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x60(%rcx), %rax
addq $0x89, %rcx
cmpq %rcx, %rax
jne 0x3771
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x68, %rcx
movq %rcx, 0x60(%rax)
jmp 0x3783
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x89, %rcx
movq %rcx, 0x60(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: magmastonealex[P]fbkeyboard/src/Input.cpp
// Function: Input::getNextEvent()
Touch Input::getNextEvent() {
	inputEvent event;
	eventStream.read((char*)&event, sizeof(event));
	int keepLooping = 1;
	int touchX;
	int touchY;
	int isDown = 0;
	while(isDown == 0) {
		while(keepLooping) {
			if(event.code == 57 && ((int)event.value != -1)) {
				isDown = 1;
			}
			if(event.code == 0x35) {
				touchX = event.value;
			}
			if(event.code == 0x36) {
				touchY = event.value;
			}
			eventStream.read((char*)&event, sizeof(event));
			if(event.type == 0 && event.code == 0 && event.value == 0) {
				keepLooping = 0;
			}
		}
		keepLooping = 1;
	}
	return Touch(touchX, touchY);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x28(%rbp), %rsi
movl $0x18, %edx
callq 0x2270
movl $0x1, -0x2c(%rbp)
movl $0x0, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jne 0x3b7e
jmp 0x3b08
cmpl $0x0, -0x2c(%rbp)
je 0x3b75
movzwl -0x16(%rbp), %eax
cmpl $0x39, %eax
jne 0x3b24
cmpl $-0x1, -0x14(%rbp)
je 0x3b24
movl $0x1, -0x38(%rbp)
movzwl -0x16(%rbp), %eax
cmpl $0x35, %eax
jne 0x3b33
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
movzwl -0x16(%rbp), %eax
cmpl $0x36, %eax
jne 0x3b42
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x18, %edx
callq 0x2270
movzwl -0x18(%rbp), %eax
cmpl $0x0, %eax
jne 0x3b73
movzwl -0x16(%rbp), %eax
cmpl $0x0, %eax
jne 0x3b73
cmpl $0x0, -0x14(%rbp)
jne 0x3b73
movl $0x0, -0x2c(%rbp)
jmp 0x3b08
movl $0x1, -0x2c(%rbp)
jmp 0x3b00
movl -0x30(%rbp), %esi
movl -0x34(%rbp), %edx
leaq -0x8(%rbp), %rdi
callq 0x3ab0
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: aadityanaik[P]LongNums/src/longnums.cpp
// Function: LongNumber::toLong()
long int LongNumber::toLong() {
	long int sum = 0, pow = 1;

	for(std::vector<int>::iterator digit = digits.begin(); digit < digits.end(); digit++) {
		sum += ((*digit)) * pow;
		pow *= BASE;
	}

	if(negative) {
		sum *= -1;
	}

	return sum;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movq $0x0, 0x28(%rsp)
movq $0x1, 0x20(%rsp)
callq 0x7b90
movq %rax, 0x18(%rsp)
movq (%rsp), %rdi
callq 0x7c00
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x7bc0
testb $0x1, %al
jne 0x31d1
jmp 0x3213
leaq 0x18(%rsp), %rdi
callq 0x7c30
movslq (%rax), %rax
imulq 0x20(%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movslq 0xbf83(%rip), %rax      # 0xf178
imulq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x7c40
movq %rax, 0x8(%rsp)
jmp 0x31ae
movq (%rsp), %rax
testb $0x1, 0x18(%rax)
je 0x3228
imulq $-0x1, 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: aadityanaik[P]LongNums/src/longnums.cpp
// Function: LongNumber::absolute()
LongNumber LongNumber::absolute() {
	LongNumber ans;

	ans.digits = digits;
	ans.negative = false;

	return ans;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x37(%rsp)
callq 0x2a10
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x7780
jmp 0x3280
movq 0x10(%rsp), %rax
movb $0x0, 0x18(%rax)
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x32bb
jmp 0x32b1
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x2a80
jmp 0x32c5
movq 0x10(%rsp), %rdi
callq 0x2a80
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x2260
nop
// File: aadityanaik[P]LongNums/src/longnums.cpp
// Function: operator>>(std::istream&, LongNumber&)
std::istream& operator>>(std::istream& input, LongNumber& X) {
	std::string number;
	input >> number;
	X = number;

	return input;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x21b0
movq 0x10(%rsp), %rsi
movq 0x50(%rsp), %rdi
callq 0x21a0
jmp 0x32fe
movq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2b60
jmp 0x330f
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x20e0
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x20e0
movq 0x20(%rsp), %rdi
callq 0x2260
nop
// File: aadityanaik[P]LongNums/src/longnums.cpp
// Function: operator<<(std::ostream&, LongNumber const&)
std::ostream& operator<<(std::ostream& output, const LongNumber& X) {
	std::string printed;
	if (X.negative) {
		output << "-";
	}

	output << *(X.digits.end()-1);

	for(int i = X.digits.size() - 2; i >= 0; i--) {
		printed = std::to_string(X.digits[i]);
		while(printed.length() < 9) {
			printed = "0" + printed;
		}
		output << printed;
	}

	return output;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x21b0
movq 0x98(%rsp), %rax
testb $0x1, 0x18(%rax)
je 0x33b4
movq 0xa0(%rsp), %rdi
leaq 0x7cea(%rip), %rsi      # 0xb078
callq 0x2150
jmp 0x3395
jmp 0x33b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x20e0
jmp 0x34e3
movq 0xa0(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x98(%rsp), %rdi
callq 0x7f20
movq %rax, 0x58(%rsp)
leaq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0x7f50
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x7fa0
movq 0x8(%rsp), %rdi
movl (%rax), %esi
callq 0x2240
jmp 0x33ff
movq 0x98(%rsp), %rdi
callq 0x7fb0
subq $0x2, %rax
movl %eax, 0x54(%rsp)
cmpl $0x0, 0x54(%rsp)
jl 0x34c1
movq 0x98(%rsp), %rdi
movslq 0x54(%rsp), %rsi
callq 0x7fd0
movl (%rax), %esi
leaq 0x30(%rsp), %rdi
callq 0x7590
jmp 0x343f
leaq 0x78(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2190
leaq 0x30(%rsp), %rdi
callq 0x20e0
leaq 0x78(%rsp), %rdi
callq 0x21d0
cmpq $0x9, %rax
jae 0x349b
leaq 0x7c24(%rip), %rsi      # 0xb093
leaq 0x10(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0x7ff0
jmp 0x3480
leaq 0x78(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2190
leaq 0x10(%rsp), %rdi
callq 0x20e0
jmp 0x3458
movq 0xa0(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x2130
jmp 0x34af
jmp 0x34b1
movl 0x54(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x3414
movq 0xa0(%rsp), %rax
movq %rax, (%rsp)
leaq 0x78(%rsp), %rdi
callq 0x20e0
movq (%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x2260
nopl (%rax)
// File: aadityanaik[P]LongNums/src/longnums.cpp
// Function: LongNumber::operator*(long)
LongNumber LongNumber::operator*(long int X) {
	if(X == 0) {
		return LongNumber();
	} else {
	LongNumber answer;
	long int product = 0, carry = 0;
	answer.digits.erase(answer.digits.begin(), answer.digits.end());

	for(int i = 0; i < digits.size(); i++) {
		product = X * (digits)[i] + carry;
		carry = product / BASE;
		product = product % BASE;
		answer.digits.push_back(product);
	}
	while (carry > 0) {
		answer.digits.push_back(carry % BASE);
		carry /= BASE;
	}

	return answer;
	}
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x90(%rsp)
jne 0x5c03
movq 0x18(%rsp), %rdi
callq 0x2a10
jmp 0x5dd6
movq 0x18(%rsp), %rdi
movb $0x0, 0x8f(%rsp)
callq 0x2a10
movq 0x18(%rsp), %rdi
movq $0x0, 0x80(%rsp)
movq $0x0, 0x78(%rsp)
callq 0x7b90
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x7d20
movq 0x18(%rsp), %rdi
callq 0x7c00
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x7d20
movq 0x18(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x7c80
movq %rax, 0x10(%rsp)
jmp 0x5c81
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x3c(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x7fb0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x5d6e
movq 0x28(%rsp), %rdi
movq 0x90(%rsp), %rax
movq %rax, (%rsp)
movslq 0x3c(%rsp), %rsi
callq 0x8120
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movq (%rsp), %rax
movslq (%rcx), %rcx
imulq %rcx, %rax
movq 0x78(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movslq 0x9473(%rip), %rcx      # 0xf178
cqto
idivq %rcx
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rax
movslq 0x945a(%rip), %rcx      # 0xf178
cqto
idivq %rcx
movq %rdx, 0x80(%rsp)
movl 0x80(%rsp), %eax
movl %eax, 0x38(%rsp)
leaq 0x38(%rsp), %rsi
callq 0x76f0
jmp 0x5d42
jmp 0x5d44
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x5c93
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x2a80
jmp 0x5de3
jmp 0x5d70
cmpq $0x0, 0x78(%rsp)
jle 0x5db8
movq 0x18(%rsp), %rdi
movq 0x78(%rsp), %rax
movslq 0x93ef(%rip), %rcx      # 0xf178
cqto
idivq %rcx
movl %edx, %eax
movl %eax, 0x34(%rsp)
leaq 0x34(%rsp), %rsi
callq 0x76f0
jmp 0x5da0
movslq 0x93d1(%rip), %rcx      # 0xf178
movq 0x78(%rsp), %rax
cqto
idivq %rcx
movq %rax, 0x78(%rsp)
jmp 0x5d70
movb $0x1, 0x8f(%rsp)
testb $0x1, 0x8f(%rsp)
jne 0x5dd4
movq 0x18(%rsp), %rdi
callq 0x2a80
jmp 0x5dd6
movq 0x20(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x2260
nopl (%rax)
// File: aadityanaik[P]LongNums/src/longnums.cpp
// Function: LongNumber::operator%(LongNumber)
LongNumber LongNumber::operator%(LongNumber X) {
	LongNumber quotient;
	LongNumber remainder;

	quotient = (*this) / X;
	
	remainder = (*this) - (X * quotient);

	return remainder;
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movq %rdx, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq %rdx, 0x100(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x2a10
movq 0x20(%rsp), %rdi
movb $0x0, 0xdf(%rsp)
callq 0x2a10
jmp 0x6d3f
movq 0x8(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0x2a90
jmp 0x6d53
movq 0x18(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rdx
callq 0x5df0
jmp 0x6d6f
leaq 0xe0(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x81f0
jmp 0x6d86
leaq 0xa8(%rsp), %rdi
callq 0x2a80
leaq 0x88(%rsp), %rdi
callq 0x2a80
leaq 0x28(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x2a90
jmp 0x6db4
movq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x4540
jmp 0x6dca
movq 0x18(%rsp), %rsi
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x3e20
jmp 0x6de0
movq 0x20(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x81f0
jmp 0x6df1
leaq 0x68(%rsp), %rdi
callq 0x2a80
leaq 0x48(%rsp), %rdi
callq 0x2a80
leaq 0x28(%rsp), %rdi
callq 0x2a80
movb $0x1, 0xdf(%rsp)
testb $0x1, 0xdf(%rsp)
jne 0x6f0f
jmp 0x6f05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x6f33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x6f29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x6e93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x2a80
leaq 0x88(%rsp), %rdi
callq 0x2a80
jmp 0x6f29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x6ef9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x6eef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2a80
leaq 0x48(%rsp), %rdi
callq 0x2a80
leaq 0x28(%rsp), %rdi
callq 0x2a80
jmp 0x6f29
movq 0x20(%rsp), %rdi
callq 0x2a80
leaq 0xe0(%rsp), %rdi
callq 0x2a80
movq 0x10(%rsp), %rax
addq $0x118, %rsp            # imm = 0x118
retq
movq 0x20(%rsp), %rdi
callq 0x2a80
leaq 0xe0(%rsp), %rdi
callq 0x2a80
movq 0xd0(%rsp), %rdi
callq 0x2260
nopl (%rax)
// File: WeiqiangZhou[P]BIRD/source/create_library_function.cpp
// Function: ReadVector_d(char*, double*)
int ReadVector_d(char *infile, double *data)
{
	FILE *p_in;
	int i = 0;
	double temp_double;
	p_in = fopen(infile, "r");
	if (p_in != NULL)
	{
		std::cout << "Reading " << infile << "..." << std::endl;
		while (!feof(p_in) && fscanf(p_in, "%lf", &temp_double) == 1)
		{
			data[i] = temp_double;
			i++;
		}
		fclose(p_in);
	}
	else
	{
		std::cout << "Error! File "<<infile<<" not found!" << std::endl;
		return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1dd5(%rip), %rsi      # 0x63e7
callq 0x2120
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x46c8
movq 0x39ab(%rip), %rdi      # 0x7fd8
leaq 0x1d57(%rip), %rsi      # 0x638b
callq 0x20f0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x20f0
movq %rax, %rdi
leaq 0x1cfe(%rip), %rsi      # 0x634d
callq 0x20f0
movq %rax, %rdi
movq 0x396a(%rip), %rsi      # 0x7fc8
callq 0x2110
movq -0x20(%rbp), %rdi
callq 0x2190
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
jne 0x4697
movq -0x20(%rbp), %rdi
leaq 0x1ef2(%rip), %rsi      # 0x6575
leaq -0x30(%rbp), %rdx
movb $0x0, %al
callq 0x2210
cmpl $0x1, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x46a0
jmp 0x46bd
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4663
movq -0x20(%rbp), %rdi
callq 0x2100
jmp 0x470e
movq 0x3909(%rip), %rdi      # 0x7fd8
leaq 0x1e62(%rip), %rsi      # 0x6538
callq 0x20f0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x20f0
movq %rax, %rdi
leaq 0x1e54(%rip), %rsi      # 0x6545
callq 0x20f0
movq %rax, %rdi
movq 0x38c8(%rip), %rsi      # 0x7fc8
callq 0x2110
movl $0x1, -0x4(%rbp)
jmp 0x4715
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: WeiqiangZhou[P]BIRD/source/create_library_function.cpp
// Function: ReadVector_i(char*, int*)
int ReadVector_i(char *infile, int *data)
{
	FILE *p_in;
	int i = 0;
	int temp_int;
	p_in = fopen(infile, "r");
	if (p_in != NULL)
	{
		std::cout << "Reading " << infile << "..." << std::endl;
		while (!feof(p_in) && fscanf(p_in, "%d", &temp_int) == 1)
		{
			data[i] = temp_int;
			i++;
		}
		fclose(p_in);
	}
	else
	{
		std::cout << "Error! File " << infile << " not found!" << std::endl;
		return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1ca5(%rip), %rsi      # 0x63e7
callq 0x2120
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x47f4
movq 0x387b(%rip), %rdi      # 0x7fd8
leaq 0x1c27(%rip), %rsi      # 0x638b
callq 0x20f0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x20f0
movq %rax, %rdi
leaq 0x1bce(%rip), %rsi      # 0x634d
callq 0x20f0
movq %rax, %rdi
movq 0x383a(%rip), %rsi      # 0x7fc8
callq 0x2110
movq -0x20(%rbp), %rdi
callq 0x2190
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
jne 0x47c7
movq -0x20(%rbp), %rdi
leaq 0x1bec(%rip), %rsi      # 0x639f
leaq -0x28(%rbp), %rdx
movb $0x0, %al
callq 0x2210
cmpl $0x1, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x47d0
jmp 0x47e9
movl -0x28(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4793
movq -0x20(%rbp), %rdi
callq 0x2100
jmp 0x483a
movq 0x37dd(%rip), %rdi      # 0x7fd8
leaq 0x1d36(%rip), %rsi      # 0x6538
callq 0x20f0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x20f0
movq %rax, %rdi
leaq 0x1d28(%rip), %rsi      # 0x6545
callq 0x20f0
movq %rax, %rdi
movq 0x379c(%rip), %rsi      # 0x7fc8
callq 0x2110
movl $0x1, -0x4(%rbp)
jmp 0x4841
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: WeiqiangZhou[P]BIRD/source/create_library_function.cpp
// Function: ReadName(char*, char**)
int ReadName(char *file, char **data)
{
	std::ifstream infile(file);
	std::string line_temp;
	int m = 0;
	if (infile.is_open())
	{
		std::cout << "Reading " << file << "..." << std::endl;
		while (!infile.eof())
		{
			std::getline(infile, line_temp);
			if (line_temp.empty()){ break; }
			strncpy(data[m], line_temp.c_str(), 30);
			m++;
		}
		infile.close();
	}
	else
	{
		std::cout << "Error! File " << file << " not found!" << std::endl;
		return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x220(%rbp), %rdi
movq %rdi, -0x268(%rbp)
movl $0x8, %edx
callq 0x2200
leaq -0x240(%rbp), %rdi
callq 0x2160
movq -0x268(%rbp), %rdi
movl $0x0, -0x244(%rbp)
callq 0x21c0
movb %al, -0x259(%rbp)
jmp 0x4f69
movb -0x259(%rbp), %al
testb $0x1, %al
jne 0x4f78
jmp 0x50c3
movq 0x3059(%rip), %rdi      # 0x7fd8
leaq 0x1405(%rip), %rsi      # 0x638b
callq 0x20f0
movq %rax, -0x270(%rbp)
jmp 0x4f94
movq -0x270(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x20f0
movq %rax, -0x278(%rbp)
jmp 0x4fad
movq -0x278(%rbp), %rdi
leaq 0x1392(%rip), %rsi      # 0x634d
callq 0x20f0
movq %rax, -0x280(%rbp)
jmp 0x4fc9
movq -0x280(%rbp), %rdi
movq 0x2ff1(%rip), %rsi      # 0x7fc8
callq 0x2110
jmp 0x4fde
jmp 0x4fe0
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x2220
movb %al, -0x281(%rbp)
jmp 0x5000
movb -0x281(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x5011
jmp 0x50b3
leaq -0x220(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x2040
jmp 0x5026
leaq -0x240(%rbp), %rdi
callq 0x21d0
testb $0x1, %al
jne 0x5038
jmp 0x5069
jmp 0x50b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x20a0
leaq -0x220(%rbp), %rdi
callq 0x2060
jmp 0x5171
movq -0x18(%rbp), %rax
movslq -0x244(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x290(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x2070
movq -0x290(%rbp), %rdi
movq %rax, %rsi
movl $0x1e, %edx
callq 0x2080
movl -0x244(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x244(%rbp)
jmp 0x4fe0
leaq -0x220(%rbp), %rdi
callq 0x2050
jmp 0x50c1
jmp 0x513c
movq 0x2f0e(%rip), %rdi      # 0x7fd8
leaq 0x1467(%rip), %rsi      # 0x6538
callq 0x20f0
movq %rax, -0x298(%rbp)
jmp 0x50df
movq -0x298(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x20f0
movq %rax, -0x2a0(%rbp)
jmp 0x50f8
movq -0x2a0(%rbp), %rdi
leaq 0x143f(%rip), %rsi      # 0x6545
callq 0x20f0
movq %rax, -0x2a8(%rbp)
jmp 0x5114
movq -0x2a8(%rbp), %rdi
movq 0x2ea6(%rip), %rsi      # 0x7fc8
callq 0x2110
jmp 0x5129
movl $0x1, -0x4(%rbp)
movl $0x1, -0x258(%rbp)
jmp 0x514d
movl $0x0, -0x4(%rbp)
movl $0x1, -0x258(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x20a0
leaq -0x220(%rbp), %rdi
callq 0x2060
movl -0x4(%rbp), %eax
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbp
retq
movq -0x250(%rbp), %rdi
callq 0x21f0
nopl (%rax)
// File: ashlall[P]StreamStats/Test/Chi_Square_test.cpp
// Function: get_frequencies(double*, double*, double*, int, int)
int* get_frequencies(double *upper, double *lower, double *items, int num_buckets, int stream_size)
{
  int *frequencies = new int[num_buckets];
  for (int i = 0; i < num_buckets; i++)
    frequencies[i] = 0;
  for (int i = 0; i < stream_size; i++)
  {
    //cout << "item: " << items[i] << " ***" << endl;
    int lo = 0, hi = num_buckets;
    while (lo <= hi)
    {
      int mid = (lo + hi) / 2;
      //cout << "mid: " << endl;
      if (items[i] <= upper[mid] && items[i] >= lower[mid])
      {
	frequencies[mid]++;
	break;
      }
      /*else if (items[i] < upper[0])
      {
	cout << "hello" << endl;
	frequencies[0]++;
	break;
      }
      else if (items[i] > lower[num_buckets-1])
      {
	cout << "hi" << endl;
	frequencies[num_buckets-1]++;
	break;
	}*/
      else if (items[i] < lower[mid])
	{
	  //	  cout << "lower, " << endl;
	hi = mid;
	}
      else
	lo = mid + 1;
    }
  }
  return frequencies;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movslq -0x1c(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x75dd
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x75bb
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x76b1
movl $0x0, -0x34(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
jg 0x76a1
movl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0x7669
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jb 0x7669
movq -0x28(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x76a1
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x7691
movl -0x3c(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x769a
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x769c
jmp 0x75fd
jmp 0x76a3
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x75e4
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/UP.cc
// Function: main
int main()
{
	// up points to an array of ten uninitialized ints
	unique_ptr<int[]> up(new int[10]);
	for (size_t i = 0; i != 10; ++i)
		up[i] = i;  // assign a new value to each of the elements
	up.release();   // automatically uses delete[] to destroy its pointer

	// to use a shared_ptr we must supply a deleter
	shared_ptr<int> sp(new int[10],
						[](int *p) {
							cout << "lambda call." << endl;
							delete[] p;
						});
	// shared_ptrs don't have subscript operator
	// and don't support pointer arithmetic
	for (size_t i = 0; i != 10; ++i)
		*(sp.get() + i) = i;  // use get to get a built-in pointer
	sp.reset(); // uses the lambda we supplied
	            // that uses delete[] to free the array
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl $0x28, %edi
callq 0x1030
movq %rax, %rsi
leaq -0x10(%rbp), %rdi
callq 0x1a80
movq $0x0, -0x18(%rbp)
cmpq $0xa, -0x18(%rbp)
je 0x12ed
movq -0x18(%rbp), %rsi
movl %esi, %eax
movl %eax, -0x54(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1ab0
movq %rax, -0x50(%rbp)
jmp 0x12bc
movq -0x50(%rbp), %rax
movl -0x54(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x129d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1b90
jmp 0x1370
leaq -0x10(%rbp), %rdi
callq 0x1af0
movl $0x28, %edi
callq 0x1030
movq %rax, -0x60(%rbp)
jmp 0x1306
movq -0x60(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1380
jmp 0x1315
movq $0x0, -0x48(%rbp)
cmpq $0xa, -0x48(%rbp)
je 0x134c
movq -0x48(%rbp), %rax
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1b10
movl -0x64(%rbp), %edx
movq -0x48(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x131d
leaq -0x38(%rbp), %rdi
callq 0x1b30
leaq -0x38(%rbp), %rdi
callq 0x1b70
leaq -0x10(%rbp), %rdi
callq 0x1b90
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1120
nopl (%rax)
// File: philipperemy[P]digital-setting-circles/Calc.cpp
// Function: Calc::VVtoW()
void Calc::VVtoW()
{
 W = VV[1][1]*VV[2][2]*VV[3][3]+VV[1][2]*VV[2][3]*VV[3][1];
 W = W+VV[1][3]*VV[3][2]*VV[2][1];
 W = W-VV[1][3]*VV[2][2]*VV[3][1]-VV[1][1]*VV[3][2]*VV[2][3];
 W = W-VV[1][2]*VV[2][1]*VV[3][3];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd 0xa8(%rax), %xmm0
mulsd 0xd0(%rax), %xmm0
movsd 0xf8(%rax), %xmm2
movsd 0xb0(%rax), %xmm1
mulsd 0xd8(%rax), %xmm1
mulsd 0xe8(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x290(%rax)
movsd 0x290(%rax), %xmm1
movsd 0xb8(%rax), %xmm0
mulsd 0xf0(%rax), %xmm0
movsd 0xc8(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x290(%rax)
movsd 0x290(%rax), %xmm0
movsd 0xb8(%rax), %xmm1
mulsd 0xd0(%rax), %xmm1
movsd 0xe8(%rax), %xmm2
movq %xmm1, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0xa8(%rax), %xmm0
mulsd 0xf0(%rax), %xmm0
movsd 0xd8(%rax), %xmm2
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x290(%rax)
movsd 0x290(%rax), %xmm1
movsd 0xb0(%rax), %xmm0
mulsd 0xc8(%rax), %xmm0
movsd 0xf8(%rax), %xmm2
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x290(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: philipperemy[P]digital-setting-circles/Calc.cpp
// Function: Calc::YY1toFH(bool)
void Calc::YY1toFH(bool flipped)
{
  double C = MathLib::sqrt(sqr(YY[1][1])+sqr(YY[2][1]));

  // Since C is always non-negative, H will be between -90 and 90 degrees.
  if (C==0 && YY[3][1]==0)
    H = 0;  // Undefined result!
  else
    H = MathLib::atan2(YY[3][1], C);

  if (C==0)
    F = 1; // Elevation is +-90 deg, so az is arbitrary.
  else {
    // Note: Since C>0, both YY[2][1] and YY[1][1] must be != 0.
    F = MathLib::atan2(YY[2][1], YY[1][1]);
    // The atan2() function provides a 4-quadrant result, but in
    // the -p...pi range instead of 0...2*pi.
    if (F<0)
      F += (2*pi);
  }

  // No longer any need to clip F to 0..2*pi.

  // If desired, convert the result to flipped mode.
  if (flipped) {
    // Flip the elevation to the other side of the zenith.
    if (H >= 0)
      H = pi - H;
    else
      H = -pi - H;

    // Rotate (not flip) the azimuth 180 degrees.
    F -= pi;
    if (F<0)
      F += (2*pi);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movsd 0x228(%rax), %xmm0
callq 0x3a10
movq -0x28(%rbp), %rax
movsd %xmm0, -0x20(%rbp)
movsd 0x248(%rax), %xmm0
callq 0x3a10
movaps %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
addsd %xmm1, %xmm0
callq 0x78a0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3c4d
jp 0x3c4d
movq -0x28(%rbp), %rax
movsd 0x268(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3c4d
jp 0x3c4d
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x288(%rax)
jmp 0x3c6f
movq -0x28(%rbp), %rax
movsd 0x268(%rax), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x75b0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x288(%rax)
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3c95
jp 0x3c95
movq -0x28(%rbp), %rax
movsd 0x34385(%rip), %xmm0    # 0x38010
movsd %xmm0, 0x280(%rax)
jmp 0x3ce5
movq -0x28(%rbp), %rax
movsd 0x248(%rax), %xmm0
movsd 0x228(%rax), %xmm1
callq 0x75b0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x280(%rax)
xorps %xmm0, %xmm0
ucomisd 0x280(%rax), %xmm0
jbe 0x3ce3
movq -0x28(%rbp), %rax
movsd 0x34335(%rip), %xmm0    # 0x38008
addsd 0x280(%rax), %xmm0
movsd %xmm0, 0x280(%rax)
jmp 0x3ce5
testb $0x1, -0x9(%rbp)
je 0x3d89
movq -0x28(%rbp), %rax
movsd 0x288(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3d22
movq -0x28(%rbp), %rax
movsd 0x34310(%rip), %xmm0    # 0x38020
subsd 0x288(%rax), %xmm0
movsd %xmm0, 0x288(%rax)
jmp 0x3d3e
movq -0x28(%rbp), %rax
movsd 0x342ea(%rip), %xmm0    # 0x38018
subsd 0x288(%rax), %xmm0
movsd %xmm0, 0x288(%rax)
movq -0x28(%rbp), %rax
movsd 0x280(%rax), %xmm0
movsd 0x342ce(%rip), %xmm1    # 0x38020
subsd %xmm1, %xmm0
movsd %xmm0, 0x280(%rax)
xorps %xmm0, %xmm0
ucomisd 0x280(%rax), %xmm0
jbe 0x3d87
movq -0x28(%rbp), %rax
movsd 0x34291(%rip), %xmm0    # 0x38008
addsd 0x280(%rax), %xmm0
movsd %xmm0, 0x280(%rax)
jmp 0x3d89
addq $0x30, %rsp
popq %rbp
retq
nop
// File: philipperemy[P]digital-setting-circles/Calc.cpp
// Function: Calc::AzEltoYY0()
void Calc::AzEltoYY0()
{
  H += Z3;
  YY[1][0] = MathLib::cos(F)*MathLib::cos(H) - MathLib::sin(F)*Z2 + MathLib::sin(F)*MathLib::sin(H)*Z1;
  YY[2][0] = MathLib::sin(F)*MathLib::cos(H) + MathLib::cos(F)*Z2 - MathLib::cos(F)*MathLib::sin(H)*Z1;
  YY[3][0] = MathLib::sin(H);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movsd 0x308(%rax), %xmm0
addsd 0x288(%rax), %xmm0
movsd %xmm0, 0x288(%rax)
movsd 0x280(%rax), %xmm0
callq 0x75e0
movq -0x10(%rbp), %rax
movsd %xmm0, -0x48(%rbp)
movsd 0x288(%rax), %xmm0
callq 0x75e0
movq -0x10(%rbp), %rax
movsd %xmm0, -0x50(%rbp)
movsd 0x280(%rax), %xmm0
callq 0x7600
movsd -0x50(%rbp), %xmm2
movq -0x10(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
mulsd 0x300(%rax), %xmm1
movq %xmm1, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x280(%rax), %xmm0
callq 0x7600
movq -0x10(%rbp), %rax
movsd %xmm0, -0x38(%rbp)
movsd 0x288(%rax), %xmm0
callq 0x7600
movsd -0x40(%rbp), %xmm1
movq -0x10(%rbp), %rax
movaps %xmm0, %xmm2
movsd -0x38(%rbp), %xmm0
mulsd %xmm2, %xmm0
movsd 0x2f8(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x220(%rax)
movsd 0x280(%rax), %xmm0
callq 0x7600
movq -0x10(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movsd 0x288(%rax), %xmm0
callq 0x75e0
movq -0x10(%rbp), %rax
movsd %xmm0, -0x30(%rbp)
movsd 0x280(%rax), %xmm0
callq 0x75e0
movsd -0x30(%rbp), %xmm2
movq -0x10(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
mulsd 0x300(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x280(%rax), %xmm0
callq 0x75e0
movq -0x10(%rbp), %rax
movsd %xmm0, -0x18(%rbp)
movsd 0x288(%rax), %xmm0
callq 0x7600
movsd -0x20(%rbp), %xmm1
movq -0x10(%rbp), %rax
movaps %xmm0, %xmm2
movsd -0x18(%rbp), %xmm0
mulsd %xmm2, %xmm0
movsd 0x2f8(%rax), %xmm2
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x240(%rax)
movsd 0x288(%rax), %xmm0
callq 0x7600
movq -0x10(%rbp), %rax
movsd %xmm0, 0x260(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: philipperemy[P]digital-setting-circles/Calc.cpp
// Function: Calc::ApparentToTrueAzEl()
void Calc::ApparentToTrueAzEl()
{
  int J;

  AzEltoYY0();
  for (J=1; J<=3; J++)
    YY[J][1] = YY[J][0];
  YY1toFH(false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x3d90
movl $0x1, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jg 0x41f4
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x200, %rcx            # imm = 0x200
movslq -0xc(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movsd (%rcx), %xmm0
addq $0x200, %rax            # imm = 0x200
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd %xmm0, 0x8(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x41b0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x3bc0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: philipperemy[P]digital-setting-circles/Calc.cpp
// Function: Calc::calcApparentSeparation()
double Calc::calcApparentSeparation()
{
  double corrAz1, corrAz2, corrEl1, corrEl2;

  F = alignAz[1];
  H = alignEl[1];
  ApparentToTrueAzEl();
  corrAz1 = F;
  corrEl1 = H;

  F = alignAz[2];
  H = alignEl[2];
  ApparentToTrueAzEl();
  corrAz2 = F;
  corrEl2 = H;

  return calcSeparation(corrAz1, corrEl1, corrAz2, corrEl2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movsd 0x2a0(%rdi), %xmm0
movsd %xmm0, 0x280(%rdi)
movsd 0x2b8(%rdi), %xmm0
movsd %xmm0, 0x288(%rdi)
callq 0x4190
movq -0x30(%rbp), %rdi
movsd 0x280(%rdi), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x288(%rdi), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x2a8(%rdi), %xmm0
movsd %xmm0, 0x280(%rdi)
movsd 0x2c0(%rdi), %xmm0
movsd %xmm0, 0x288(%rdi)
callq 0x4190
movq -0x30(%rbp), %rdi
movsd 0x280(%rdi), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x288(%rdi), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
movsd -0x28(%rbp), %xmm3
callq 0x42d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: philipperemy[P]digital-setting-circles/Calc.cpp
// Function: Calc::calcSeparation(double, double, double, double)
double Calc::calcSeparation(double az1, double el1, double az2, double el2)
{
  double cossep;

  cossep = (MathLib::sin(el1)*MathLib::sin(el2)) + (MathLib::cos(el1)*MathLib::cos(el2)*MathLib::cos(az1-az2));

  // Avoid a domain error for acos due to rounding.
  if (cossep >= 1.0)
    return 0.0;
  if (cossep <= -1.0)
    return pi;

  return MathLib::acos(cossep);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x7600
movsd %xmm0, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x7600
movsd %xmm0, -0x48(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x75e0
movsd %xmm0, -0x58(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x75e0
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
callq 0x75e0
movsd -0x50(%rbp), %xmm1
movsd -0x48(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x40(%rbp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd 0x33c99(%rip), %xmm1    # 0x38010
ucomisd %xmm1, %xmm0
jb 0x4387
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x43b4
movsd 0x33c99(%rip), %xmm0    # 0x38028
ucomisd -0x38(%rbp), %xmm0
jb 0x43a5
movsd 0x33c82(%rip), %xmm0    # 0x38020
movsd %xmm0, -0x8(%rbp)
jmp 0x43b4
movsd -0x38(%rbp), %xmm0
callq 0x7550
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: philipperemy[P]digital-setting-circles/Calc.cpp
// Function: Calc::setAlignmentData(int, double, double, double, double, double)
void Calc::setAlignmentData(int i, double ra, double dec,
		      double az, double el, double time)
{

  if (i<0 || i>1)
    return;

  i++;  // I must be 1 or 2 to index the arrays!

  // This entire package measures azimuth backwards!
  alignAz[i] = (360.0-az)*radPerDeg;
  alignEl[i] = el*radPerDeg;
  alignRA[i] =  (ra-degreesPerMinute*time)/degPerRad;
  alignDec[i] =  dec/degPerRad;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movsd %xmm4, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x4b68
cmpl $0x1, -0xc(%rbp)
jle 0x4b6d
jmp 0x4c0b
movq -0x40(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movsd 0x334e6(%rip), %xmm0    # 0x38068
subsd -0x28(%rbp), %xmm0
movsd 0x334c9(%rip), %xmm1    # 0x38058
mulsd %xmm1, %xmm0
movslq -0xc(%rbp), %rcx
movsd %xmm0, 0x298(%rax,%rcx,8)
movsd 0x334b0(%rip), %xmm0    # 0x38058
mulsd -0x30(%rbp), %xmm0
movslq -0xc(%rbp), %rcx
movsd %xmm0, 0x2b0(%rax,%rcx,8)
movsd -0x18(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
movsd 0x33494(%rip), %xmm2    # 0x38060
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x33474(%rip), %xmm1    # 0x38050
divsd %xmm1, %xmm0
movslq -0xc(%rbp), %rcx
movsd %xmm0, 0x2c8(%rax,%rcx,8)
movsd -0x20(%rbp), %xmm0
movsd 0x33456(%rip), %xmm1    # 0x38050
divsd %xmm1, %xmm0
movslq -0xc(%rbp), %rcx
movsd %xmm0, 0x2e0(%rax,%rcx,8)
popq %rbp
retq
nopl (%rax)
// File: philipperemy[P]digital-setting-circles/Data.cpp
// Function: Data::Data(StarData&, StarData&)
Data::Data(StarData& starData1, StarData& starData2)
: starData1(starData1), starData2(starData2),
epochReference(0), elEncoderOffset(0)
{
    //ctor
    curAz = NAN;
    curEl = NAN;

    aligned = false;

    targetRA = 0.0;
    targetDec = 0.0;

    targetAz = NAN;
    targetEl = NAN;

    //Avoid diving by 0
    azEncoderRes = 8192;

    Z1 = 0.0;
    Z2 = 0.0;
    Z3 = 0.0;

    //Default is 10
    encoderReadRate = 10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
callq 0x6700
movq -0x20(%rbp), %rdi
addq $0x348, %rdi            # imm = 0x348
callq 0x3420
movq -0x20(%rbp), %rax
movl $0x0, 0x368(%rax)
movl $0x0, 0x3ac(%rax)
movsd 0x3226c(%rip), %xmm0    # 0x38160
movsd %xmm0, 0x378(%rax)
movsd 0x3225c(%rip), %xmm0    # 0x38160
movsd %xmm0, 0x380(%rax)
movb $0x0, 0x320(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x328(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x330(%rax)
movsd 0x3222f(%rip), %xmm0    # 0x38160
movsd %xmm0, 0x338(%rax)
movsd 0x3221f(%rip), %xmm0    # 0x38160
movsd %xmm0, 0x340(%rax)
movl $0x2000, 0x388(%rax)    # imm = 0x2000
xorps %xmm0, %xmm0
movsd %xmm0, 0x390(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x398(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x3a0(%rax)
movl $0xa, 0x3a8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)