LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/exrok[P]evdoublebind/./src/make_config.cc
// Function: ConfigParser::next()
bool next() {
        key = value = NULL;
        while (!end) {
            char *last; //last character in ident
            char *ident; //current token either value or key depending on state
            int state = 0;
            ident = last = c = skip_ws(c);
            while (1) {
                switch (*c) {
                    case ':':
                        if (state == 0) {
                            *(last+1) = '\0';
                            state = 1;
                            key = ident;
                            ident = c = skip_ws(c+1);
                            continue;
                        } else {
                            fprintf(stderr,"ERROR: unexpected ':' on line %d\n'", line + 1);
                            exit(1);
                        }
                        break;
                    case ' ': //Skip White Space
                    case '\t':
                        last = c-1;
                        c = skip_ws(c + 1);
                        continue;
                    case '#': //Skip Comment
                        c++;
                        while (*c && *c != '\n' ) c++; //Fallthougth
                    case '\n':
                    case '\0':
                        goto end_line;
                }
                last = c++;
            }
        end_line:
            line++;
            end = (*c == '\0');
            if (state == 1 && last != ident) {
                *(last+1) = '\0';
                value = ident;
                c++;
                return true;
            }
            c++;
        }
        return false;
    }

// Assembly:
pushq %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
cmpb $0x0, 0x1c(%rdi)
jne 0x461d
leaq 0x18(%rdi), %rax
movq (%rdi), %r9
movzbl (%r9), %ecx
cmpl $0x9, %ecx
je 0x4539
cmpl $0x20, %ecx
jne 0x453e
incq %r9
jmp 0x452b
xorl %esi, %esi
movq %r9, %r8
movq %r9, %rdx
movq %r9, (%rdi)
movq %r9, %rcx
movzbl (%rcx), %r9d
cmpl $0x3a, %r9d
jne 0x4587
testl %esi, %esi
jne 0x4631
movb $0x0, 0x1(%r8)
movq %rdx, 0x8(%rdi)
movq (%rdi), %rcx
incq %rcx
movzbl (%rcx), %edx
cmpl $0x20, %edx
je 0x456a
cmpl $0x9, %edx
je 0x456a
movq %rcx, (%rdi)
movl $0x1, %esi
movq %rcx, %rdx
jmp 0x454c
cmpl $0x9, %r9d
jle 0x45b8
cmpl $0xa, %r9d
je 0x45f5
cmpl $0x23, %r9d
je 0x45da
cmpl $0x20, %r9d
jne 0x45c3
leaq 0x1(%rcx), %r9
movzbl (%r9), %r8d
cmpl $0x20, %r8d
je 0x45b3
cmpl $0x9, %r8d
jne 0x45cf
incq %r9
jmp 0x45a3
testl %r9d, %r9d
je 0x45f5
cmpl $0x9, %r9d
je 0x459f
leaq 0x1(%rcx), %r9
movq %rcx, %r8
jmp 0x4546
decq %rcx
movq %rcx, %r8
jmp 0x4546
incq %rcx
movq %rcx, (%rdi)
movzbl (%rcx), %r9d
incq %rcx
testl %r9d, %r9d
je 0x45f2
cmpl $0xa, %r9d
jne 0x45dd
decq %rcx
incl 0x18(%rdi)
movb (%rcx), %r10b
testb %r10b, %r10b
sete 0x1c(%rdi)
testl %esi, %esi
je 0x460b
cmpq %rdx, %r8
jne 0x4621
incq %rcx
movq %rcx, (%rdi)
movq %rcx, %r9
testb %r10b, %r10b
jne 0x452b
xorl %eax, %eax
jmp 0x462f
movb $0x0, 0x1(%r8)
movq %rdx, 0x10(%rdi)
incq (%rdi)
movb $0x1, %al
popq %rcx
retq
movq %rax, %rdi
callq 0x34f8
nop
// File: /workspace/github_cpp_makefile_star2_O3/cjlin1[P]liblinear/predict.c
// Function: main
int main(int argc, char **argv)
{
	FILE *input, *output;
	int i;

	// parse options
	for(i=1;i<argc;i++)
	{
		if(argv[i][0] != '-') break;
		++i;
		switch(argv[i-1][1])
		{
			case 'b':
				flag_predict_probability = atoi(argv[i]);
				break;
			case 'q':
				info = &print_null;
				i--;
				break;
			default:
				fprintf(stderr,"unknown option: -%c\n", argv[i-1][1]);
				exit_with_help();
				break;
		}
	}
	if(i>=argc)
		exit_with_help();

	input = fopen(argv[i],"r");
	if(input == NULL)
	{
		fprintf(stderr,"can't open input file %s\n",argv[i]);
		exit(1);
	}

	output = fopen(argv[i+2],"w");
	if(output == NULL)
	{
		fprintf(stderr,"can't open output file %s\n",argv[i+2]);
		exit(1);
	}

	if((model_=load_model(argv[i+1]))==0)
	{
		fprintf(stderr,"can't open model file %s\n",argv[i+1]);
		exit(1);
	}

	x = (struct feature_node *) malloc(max_nr_attr*sizeof(struct feature_node));
	do_predict(input, output);
	free_and_destroy_model(&model_);
	free(line);
	free(x);
	fclose(input);
	fclose(output);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jl 0x2fb6
movq %rsi, %rbx
movl %edi, %ebp
movl $0x1, %r15d
leaq -0x697(%rip), %r14      # 0x28dc
movslq %r15d, %rax
movq (%rbx,%rax,8), %rdi
cmpb $0x2d, (%rdi)
jne 0x2fcc
movzbl 0x1(%rdi), %ecx
cmpl $0x71, %ecx
je 0x2fa7
cmpl $0x62, %ecx
jne 0x307c
leal 0x1(%rax), %r15d
movq 0x8(%rbx,%rax,8), %rdi
callq 0x21f0
movl %eax, 0xe203(%rip)      # 0x111a8
jmp 0x2fae
movq %r14, 0xe1c2(%rip)      # 0x11170
incl %r15d
cmpl %ebp, %r15d
jl 0x2f73
leaq 0xa1aa(%rip), %rdi      # 0xd167
callq 0x21e0
movl $0x1, %edi
callq 0x2170
leaq (%rbx,%rax,8), %r15
leaq 0xa13d(%rip), %rsi      # 0xd114
callq 0x2150
testq %rax, %rax
je 0x3084
movq %rax, %rbx
movq 0x10(%r15), %rdi
leaq 0xa13d(%rip), %rsi      # 0xd130
callq 0x2150
testq %rax, %rax
je 0x308c
movq %rax, %r14
movq 0x8(%r15), %rdi
callq 0xb0a0
movq %rax, 0xe18c(%rip)      # 0x111a0
testq %rax, %rax
je 0x3098
movslq 0xe148(%rip), %rdi      # 0x11168
shlq $0x4, %rdi
callq 0x21a0
movq %rax, 0xe168(%rip)      # 0x11198
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2904
leaq 0xe15e(%rip), %rdi      # 0x111a0
callq 0x9fa4
movq 0xe162(%rip), %rdi      # 0x111b0
callq 0x2160
movq 0xe13e(%rip), %rdi      # 0x11198
callq 0x2160
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2100
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzbl %cl, %edi
callq 0x23ee
movq %r15, %rdi
callq 0x23c7
addq $0x10, %r15
movq %r15, %rdi
callq 0x23a0
addq $0x8, %r15
movq %r15, %rdi
callq 0x2379
// File: /workspace/github_cpp_makefile_star2_O3/magmastonealex[P]fbkeyboard/src/Display.cpp
// Function: Display::set_px(RGB, int, int, int)
void Display::set_px (RGB value, int x, int y, int scale) {
	for(int xscale = 0; xscale < scale; xscale++) {
		for(int yscale=0; yscale < scale; yscale++) {
			keyboardImage->data[keyboardImage->w*(y+yscale) + x+xscale].r = value.r;
			keyboardImage->data[keyboardImage->w*(y+yscale) + x+xscale].g = value.g;
			keyboardImage->data[keyboardImage->w*(y+yscale) + x+xscale].b = value.b;				
		}
	}
}

// Assembly:
testl %r8d, %r8d
jle 0x29cd
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %eax
shrl $0x8, %eax
movl %esi, %r9d
shrl $0x10, %r9d
movq 0x30(%rdi), %r10
movq 0x8(%r10), %rdi
movl (%r10), %r10d
movl %r8d, %r11d
imull %r10d, %ecx
addl %ecx, %edx
xorl %ecx, %ecx
movq %r11, %rbx
movl %edx, %r14d
movslq %r14d, %r14
leaq (%r14,%r14,2), %r15
movb %sil, (%rdi,%r15)
movb %al, 0x1(%rdi,%r15)
movb %r9b, 0x2(%rdi,%r15)
addl %r10d, %r14d
decq %rbx
jne 0x29a2
incl %ecx
incl %edx
cmpl %r8d, %ecx
jne 0x299c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movl %ecx, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq %rdi, 0x20(%rsp)
decl %r9d
orl $0x101010, %r9d         # imm = 0x101010
movl %r9d, 0x14(%rsp)
movzbl %sil, %r14d
shll $0x3, %r14d
xorl %eax, %eax
movb $0x7, %cl
subb %al, %cl
movl $0x1, %ebx
shll %cl, %ebx
movq %rax, 0x18(%rsp)
movl %eax, %r13d
imull %ebp, %r13d
addl 0x10(%rsp), %r13d
movl 0xc(%rsp), %r15d
xorl %r12d, %r12d
leaq (%r14,%r12), %rax
leaq 0x373c(%rip), %rcx      # 0x6170
movzbl (%rcx,%rax), %eax
testl %eax, %ebx
je 0x2a53
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %r15d, %edx
movl %r13d, %ecx
movl %ebp, %r8d
callq 0x2970
incq %r12
addl %ebp, %r15d
cmpq $0x8, %r12
jne 0x2a29
movq 0x18(%rsp), %rax
incl %eax
cmpl $0x8, %eax
jne 0x2a05
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %r8d, %r8d
jle 0x2aed
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %eax
shrl $0x8, %eax
movl %r9d, %r10d
shrl $0x10, %r10d
movq 0x30(%rdi), %rdi
movslq %esi, %rsi
movl %ecx, %r11d
leaq (%r11,%r11,2), %r11
xorl %ebx, %ebx
testl %ecx, %ecx
jle 0x2add
movq 0x8(%rdi), %r14
movslq (%rdi), %r15
movslq %edx, %r12
imulq %r15, %r12
addq %rsi, %r12
leaq (%r12,%r12,2), %r15
addq %r15, %r14
addq $0x2, %r14
xorl %r15d, %r15d
movb %r9b, -0x2(%r14,%r15)
movb %al, -0x1(%r14,%r15)
movb %r10b, (%r14,%r15)
addq $0x3, %r15
cmpq %r15, %r11
jne 0x2ac6
incl %ebx
incl %edx
cmpl %r8d, %ebx
jne 0x2aa3
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq 0x30(%rdi), %r9
movslq (%r9), %rax
cmpl %esi, %eax
jle 0x2b36
movl %ecx, %edi
shrl $0x8, %edi
movl %ecx, %r8d
shrl $0x10, %r8d
movq 0x8(%r9), %r9
imull %eax, %edx
movslq %esi, %rsi
movslq %edx, %rdx
addq %rsi, %rdx
leaq (%rdx,%rdx,2), %rdx
addq %r9, %rdx
addq $0x2, %rdx
subq %rsi, %rax
movb %cl, -0x2(%rdx)
movb %dil, -0x1(%rdx)
movb %r8b, (%rdx)
addq $0x3, %rdx
decq %rax
jne 0x2b23
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq 0x30(%rdi), %r9
movslq 0x4(%r9), %rax
cmpl %edx, %eax
jle 0x2b88
movl %ecx, %edi
shrl $0x8, %edi
movl %ecx, %r8d
shrl $0x10, %r8d
movq 0x8(%r9), %r10
movslq (%r9), %r9
movslq %edx, %r11
movslq %esi, %rsi
leaq (%r9,%r9,2), %rdx
imulq %r11, %r9
addq %rsi, %r9
leaq (%r9,%r9,2), %rsi
addq %r10, %rsi
addq $0x2, %rsi
subq %r11, %rax
movb %cl, -0x2(%rsi)
movb %dil, -0x1(%rsi)
movb %r8b, (%rsi)
addq %rdx, %rsi
decq %rax
jne 0x2b76
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/magmastonealex[P]fbkeyboard/src/Display.cpp
// Function: Display::keyAt(int, int)
char Display::keyAt(int x, int y) {
	if(x < entryWidth) {
		return 0;
	}

	for(int xCheck = 1; xCheck < 5; xCheck++) {
		//determine row of touch.

		int lastRowStart = CHAR_Y_START(entryWidth, scale, xCheck - 1, rowWidth);
		int rowStart = CHAR_Y_START(entryWidth, scale, xCheck, rowWidth);

		if(x > lastRowStart && x < rowStart) {
			//std::cout << "row: " << xCheck << std::endl;
			for(int yCheck = 1; yCheck < 12; yCheck++) {
				int lastCharStart = CHAR_X_START(margin, yCheck-1, stepSizePx, scale);
				int thisCharStart = CHAR_X_START(margin, yCheck, stepSizePx, scale);
				if(y > lastCharStart && y < thisCharStart) {
					//std::cout << "col: " << yCheck << std::endl;
					if(xCheck > 3) {
						std::cout << "col: " << yCheck << std::endl;
						switch(yCheck) {
							case 10:
								toggleSym2();
								return 0;
							case 11:
								toggleSym1();
								return 0;
							default:
								toLower();
								return ' ';
						}
					}
					char touched = (*currentKeyboard)[(xCheck-1)][10-(yCheck-1)];

					if(touched == 0x0F) {
						toggleUpper();
						return 0;
					}
					else if(touched == 0x00) {
						toLower();
					}

					return touched;
				}
			}
		}
	}
	return 0;
}

// Assembly:
movl 0x14(%rdi), %ecx
cmpl %esi, %ecx
jle 0x2b94
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
movl 0xc(%rdi), %r10d
leal (%rcx,%r10,4), %ecx
movl 0x1c(%rdi), %edi
movl 0x20(%rbx), %r11d
leal (,%r10,8), %r8d
leal (%r11,%r10,8), %r9d
addl %eax, %r11d
subl %r10d, %eax
subl %r10d, %r8d
addl %r11d, %r8d
movl $0x1, %r10d
movl $0xa, %r11d
movl %r10d, %ebp
subl %edi, %ebp
addl %ecx, %ebp
cmpl %esi, %ebp
jge 0x2c14
movl %edi, %ebp
imull %r10d, %ebp
addl %ecx, %ebp
cmpl %esi, %ebp
jle 0x2c14
movl $0x1, %ebp
movl %eax, %r15d
movl %r8d, %r12d
movq %r11, %r14
cmpl %edx, %r15d
jge 0x2c04
cmpl %edx, %r12d
jg 0x2c26
incl %ebp
decq %r14
addl %r9d, %r12d
addl %r9d, %r15d
cmpl $0xc, %ebp
jne 0x2bfa
incl %r10d
addq $0xb, %r11
cmpl $0x5, %r10d
jne 0x2bd5
jmp 0x2cd9
cmpl $0x4, %r10d
jne 0x2c8e
movq 0x3395(%rip), %r14      # 0x5fc8
leaq 0x1455(%rip), %rsi      # 0x408f
movl $0x5, %edx
movq %r14, %rdi
callq 0x21c0
movq %r14, %rdi
movl %ebp, %esi
callq 0x2270
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2110
cmpl $0xb, %ebp
je 0x2cb8
cmpl $0xa, %ebp
jne 0x2ce4
leaq 0xcb(%rbx), %rax
jmp 0x2cbf
movq 0x60(%rbx), %rcx
movzbl (%rcx,%r14), %eax
testl %eax, %eax
je 0x2cd1
cmpl $0xf, %eax
jne 0x2cdb
leaq 0x89(%rbx), %rax
leaq 0x68(%rbx), %rdx
cmpq %rax, %rcx
cmovneq %rax, %rdx
movq %rdx, 0x60(%rbx)
jmp 0x2cd9
leaq 0xaa(%rbx), %rax
leaq 0x68(%rbx), %rcx
cmpq %rax, 0x60(%rbx)
cmovneq %rax, %rcx
movq %rcx, 0x60(%rbx)
jmp 0x2cd9
leaq 0x68(%rbx), %rax
movq %rax, 0x60(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x68(%rbx), %rax
movq %rax, 0x60(%rbx)
movb $0x20, %al
jmp 0x2cdb
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movl $0x18, %edx
movq %r14, %rsi
callq 0x21f0
movzwl 0x12(%r14), %eax
xorl %ebp, %ebp
movl 0x14(%r14), %ecx
movl $0x1, %r12d
movl %ebp, %edx
cmpl $-0x1, %ecx
cmovnel %r12d, %ebp
cmpw $0x39, %ax
cmovnel %edx, %ebp
cmpw $0x35, %ax
cmovel %ecx, %r13d
cmpw $0x36, %ax
cmovel %ecx, %r15d
movl $0x18, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21f0
movzwl 0x12(%rsp), %eax
movzwl 0x10(%rsp), %ecx
orw %ax, %cx
sete %dl
movl 0x14(%rsp), %ecx
testl %ecx, %ecx
sete %sil
testb %sil, %dl
je 0x30ba
xorl %ecx, %ecx
movl $0x0, %eax
testl %ebp, %ebp
movl $0x0, %ebp
je 0x30ba
shlq $0x20, %r15
movl %r13d, %eax
orq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/aadityanaik[P]LongNums/src/longnums.cpp
// Function: LongNumber::LongNumber(LongNumber const&)
LongNumber::LongNumber(const LongNumber& X) {
	//equating the two vectors
	digits = X.digits;

	//equating the booleans
	negative = X.negative;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x5412
movb 0x18(%r14), %al
movb %al, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2842
callq 0x20b0
movq %r14, %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O3/aadityanaik[P]LongNums/src/longnums.cpp
// Function: LongNumber::absolute()
LongNumber LongNumber::absolute() {
	LongNumber ans;

	ans.digits = digits;
	ans.negative = false;

	return ans;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x27ac
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5412
movb $0x0, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2c45
callq 0x20b0
movq %r14, %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq %rsp, %rsi
callq 0x2110
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2884
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2c92
callq 0x20b0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2cb0
callq 0x20b0
movq %rbx, %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
cmpb $0x1, 0x18(%rsi)
jne 0x2cfa
leaq 0x33a3(%rip), %rsi      # 0x6090
movl $0x1, %edx
movq %rbx, %rdi
callq 0x20e0
movq 0x8(%r14), %rax
movl -0x4(%rax), %esi
movq %rbx, %rdi
callq 0x2160
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x2, %rax
addl $-0x2, %eax
js 0x2e50
leaq 0x48(%rsp), %r13
movl %eax, %edx
leaq 0x38(%rsp), %r15
movq %rsp, %r12
movl $0xd1b71759, %esi       # imm = 0xD1B71759
movq %rbx, 0x28(%rsp)
movq %r14, 0x20(%rsp)
movq (%r14), %rax
movl (%rax,%rdx,4), %ebp
movl %ebp, %ebx
negl %ebx
cmovsl %ebp, %ebx
movl $0x1, %r14d
cmpl $0xa, %ebx
jb 0x2d94
movl $0x4, %r14d
movl %ebx, %eax
cmpl $0x63, %eax
jbe 0x2d8b
cmpl $0x3e7, %eax            # imm = 0x3E7
jbe 0x2d91
cmpl $0x2710, %eax           # imm = 0x2710
jb 0x2d94
movl %eax, %ecx
imulq %rsi, %rcx
shrq $0x2d, %rcx
addl $0x4, %r14d
cmpl $0x1869f, %eax          # imm = 0x1869F
movl %ecx, %eax
ja 0x2d5b
addl $-0x3, %r14d
jmp 0x2d94
addl $-0x2, %r14d
jmp 0x2d94
decl %r14d
movq %rdx, 0x30(%rsp)
shrl $0x1f, %ebp
leal (%r14,%rbp), %esi
movq %r13, 0x38(%rsp)
movq %r15, %rdi
movl $0x2d, %edx
callq 0x20f0
addq 0x38(%rsp), %rbp
movq %rbp, %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0x55aa
movq %r12, %rdi
movq %r15, %rsi
callq 0x2100
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0x2dde
callq 0x20b0
movq 0x8(%rsp), %rdx
cmpq $0x8, %rdx
movq 0x28(%rsp), %rbx
movq 0x20(%rsp), %r14
leaq 0x32b3(%rip), %rbp      # 0x60ab
ja 0x2e2d
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x54ee
movq %r12, %rdi
movq %r15, %rsi
callq 0x2100
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0x2e22
callq 0x20b0
movq 0x8(%rsp), %rdx
cmpq $0x9, %rdx
jb 0x2dfa
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x20e0
movq 0x30(%rsp), %rcx
leaq -0x1(%rcx), %rdx
testq %rcx, %rcx
movl $0xd1b71759, %esi       # imm = 0xD1B71759
jg 0x2d3b
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2e63
callq 0x20b0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e7d
jmp 0x2e7d
jmp 0x2e7d
jmp 0x2e7d
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2e93
callq 0x20b0
movq %rbx, %rdi
callq 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O3/aadityanaik[P]LongNums/src/longnums.cpp
// Function: LongNumber::operator<(LongNumber const&)
bool LongNumber::operator<(const LongNumber& X) {
	if (!negative) {
		if (X.negative) {
			return false;
		}

		else {
			if (digits.size() > X.digits.size()) {
				return false;
			} else if (digits.size() == X.digits.size()) {
				for (int i = digits.size() - 1; i >= 0; i--) {
					if (digits[i] < X.digits[i]) {
						return true;
					} else if(digits[i] > X.digits[i]){
						return false;
					}
				}

				return false;
			} else {
				return true;
			}
		}
	}

	else {
		if (!X.negative) {
			return true;
		}

		else {
			if (digits.size() > X.digits.size()) {
				return true;
			} else if (digits.size() == X.digits.size()) {
				for (int i = digits.size() - 1; i >= 0; i--) {
					if (digits[i] > X.digits[i]) {
						return true;
					} else if (digits[i] < X.digits[i]) {
						return false;
					}
				}

				return false;
			} else {
				return false;
			}
		}
	}
}

// Assembly:
movb 0x18(%rsi), %cl
cmpb $0x0, 0x18(%rdi)
je 0x2f01
movb $0x1, %al
testb %cl, %cl
je 0x2f28
movq (%rdi), %rcx
movq 0x8(%rdi), %rdi
subq %rcx, %rdi
sarq $0x2, %rdi
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
subq %rdx, %rsi
sarq $0x2, %rsi
cmpq %rsi, %rdi
ja 0x2f28
jne 0x2f26
movl %edi, %esi
decq %rsi
movq %rsi, %rax
testl %eax, %eax
js 0x2f61
movl %eax, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
shlq $0x2, %rsi
movl (%rcx,%rsi), %edi
movl (%rdx,%rsi), %r8d
cmpl %r8d, %edi
jg 0x2f5e
leaq -0x1(%rax), %rsi
cmpl %r8d, %edi
jge 0x2ed3
jmp 0x2f5a
testb %cl, %cl
jne 0x2f26
movq (%rdi), %rcx
movq 0x8(%rdi), %rdi
subq %rcx, %rdi
sarq $0x2, %rdi
movq (%rsi), %rdx
movq 0x8(%rsi), %rax
subq %rdx, %rax
sarq $0x2, %rax
cmpq %rax, %rdi
jbe 0x2f29
xorl %eax, %eax
retq
movb $0x1, %al
jne 0x2f28
movl %edi, %esi
decq %rsi
movq %rsi, %rax
testl %eax, %eax
js 0x2f61
movl %eax, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
shlq $0x2, %rsi
movl (%rcx,%rsi), %edi
movl (%rdx,%rsi), %r8d
cmpl %r8d, %edi
jl 0x2f5e
leaq -0x1(%rax), %rsi
cmpl %r8d, %edi
jle 0x2f32
xorl %esi, %esi
jmp 0x2f61
movb $0x1, %sil
testl %eax, %eax
setns %al
andb %sil, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x27ac
testq %r15, %r15
je 0x463d
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x4571
movq %rax, 0x8(%rbx)
movq (%r12), %rcx
movq 0x8(%r12), %rdi
cmpq %rcx, %rdi
je 0x463d
xorl %ebp, %ebp
leaq 0x4(%rsp), %r13
xorl %r14d, %r14d
movslq (%rcx,%rbp,4), %rax
imulq %r15, %rax
addq %r14, %rax
movslq 0x4b49(%rip), %rsi      # 0x90e8
cqto
idivq %rsi
movl %edx, 0x4(%rsp)
movq 0x8(%rbx), %rsi
movq %rax, %r14
cmpq 0x10(%rbx), %rsi
je 0x45c1
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x45d5
movq %rbx, %rdi
movq %r13, %rdx
callq 0x56c6
movq (%r12), %rcx
movq 0x8(%r12), %rdi
incq %rbp
movq %rdi, %rax
subq %rcx, %rax
sarq $0x2, %rax
cmpq %rbp, %rax
ja 0x458d
testq %r14, %r14
jle 0x463d
movl 0x4af6(%rip), %ecx      # 0x90e8
movq %rsp, %r15
movslq %ecx, %rdi
movq %r14, %rax
cqto
idivq %rdi
movl %edx, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4619
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x462d
movq %rbx, %rdi
movq %r15, %rdx
callq 0x56c6
movl 0x4abe(%rip), %ecx      # 0x90e8
movslq %ecx, %rdi
movq %r14, %rax
cqto
idivq %rdi
movq %rax, %r14
testq %rax, %rax
jg 0x45f5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4651
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4661
callq 0x20b0
movq %r14, %rdi
callq 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x27ac
movq %rbx, %rdi
callq 0x27ac
leaq 0x80(%rsp), %rdi
movq %r15, %rsi
callq 0x2806
movq %rsp, %rdi
leaq 0x80(%rsp), %rdx
movq %r14, %rsi
callq 0x466a
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x5412
movb 0x18(%rsp), %al
movb %al, 0x38(%rsp)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4e8d
callq 0x20b0
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x4e9f
callq 0x20b0
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2806
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movq %r15, %rsi
callq 0x36c4
movq %rsp, %rdi
leaq 0x60(%rsp), %rdx
movq %r14, %rsi
callq 0x3320
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5412
movb 0x18(%rsp), %al
movb %al, 0x18(%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4ef0
callq 0x20b0
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x4eff
callq 0x20b0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x4f0e
callq 0x20b0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x4f1d
callq 0x20b0
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4f43
callq 0x20b0
jmp 0x4f43
movq %rax, %r14
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x4f57
callq 0x20b0
jmp 0x4f57
movq %rax, %r14
movq 0x40(%rsp), %rdi
jmp 0x4f7e
jmp 0x4f8a
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4f76
callq 0x20b0
jmp 0x4f76
movq %rax, %r14
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x4f8d
callq 0x20b0
jmp 0x4f8d
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4f9f
callq 0x20b0
jmp 0x4f9f
movq %rax, %r14
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x4fae
callq 0x20b0
movq %r14, %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x16ad(%rip), %rsi      # 0x543c
callq 0x2160
testq %rax, %rax
je 0x3dd8
movq %rax, %r14
movq 0x3235(%rip), %r15      # 0x6fd8
leaq 0x1646(%rip), %rsi      # 0x53f0
movl $0x8, %edx
movq %r15, %rdi
callq 0x2150
testq %r12, %r12
je 0x3e1b
movq %r12, %rdi
callq 0x2090
movq 0x320d(%rip), %rdi      # 0x6fd8
movq %r12, %rsi
movq %rax, %rdx
callq 0x2150
jmp 0x3e33
movq 0x31f9(%rip), %rbx      # 0x6fd8
leaq 0x179f(%rip), %rsi      # 0x5585
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2150
testq %r12, %r12
je 0x3ebf
movq %r12, %rdi
callq 0x2090
movq 0x31cd(%rip), %rdi      # 0x6fd8
movq %r12, %rsi
movq %rax, %rdx
callq 0x2150
jmp 0x3ed6
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x21d0
leaq 0x150a(%rip), %rsi      # 0x5344
movl $0x3, %edx
movq %r15, %rdi
callq 0x2150
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x21a0
testl %eax, %eax
jne 0x3eb3
leaq 0x1741(%rip), %r15      # 0x55c2
leaq -0x28(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2210
cmpl $0x1, %eax
jne 0x3eb3
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rbx)
movq %r14, %rdi
callq 0x21a0
addq $0x8, %rbx
testl %eax, %eax
je 0x3e85
movq %r14, %rdi
callq 0x2130
xorl %eax, %eax
jmp 0x3f16
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x21d0
leaq 0x16b5(%rip), %rsi      # 0x5592
movl $0xb, %edx
movq %rbx, %rdi
callq 0x2150
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x14fd(%rip), %rsi      # 0x543c
callq 0x2160
testq %rax, %rax
je 0x3f88
movq %rax, %r14
movq 0x3085(%rip), %r15      # 0x6fd8
leaq 0x1496(%rip), %rsi      # 0x53f0
movl $0x8, %edx
movq %r15, %rdi
callq 0x2150
testq %r12, %r12
je 0x3fcb
movq %r12, %rdi
callq 0x2090
movq 0x305d(%rip), %rdi      # 0x6fd8
movq %r12, %rsi
movq %rax, %rdx
callq 0x2150
jmp 0x3fe3
movq 0x3049(%rip), %rbx      # 0x6fd8
leaq 0x15ef(%rip), %rsi      # 0x5585
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2150
testq %r12, %r12
je 0x406b
movq %r12, %rdi
callq 0x2090
movq 0x301d(%rip), %rdi      # 0x6fd8
movq %r12, %rsi
movq %rax, %rdx
callq 0x2150
jmp 0x4082
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x21d0
leaq 0x135a(%rip), %rsi      # 0x5344
movl $0x3, %edx
movq %r15, %rdi
callq 0x2150
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x21a0
testl %eax, %eax
jne 0x405f
leaq 0x13cb(%rip), %r15      # 0x53fc
leaq -0x24(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2210
cmpl $0x1, %eax
jne 0x405f
movl -0x24(%rbp), %eax
movl %eax, (%rbx)
movq %r14, %rdi
callq 0x21a0
addq $0x4, %rbx
testl %eax, %eax
je 0x4035
movq %r14, %rdi
callq 0x2130
xorl %eax, %eax
jmp 0x40c2
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x21d0
leaq 0x1509(%rip), %rsi      # 0x5592
movl $0xb, %edx
movq %rbx, %rdi
callq 0x2150
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, -0x2c(%rbp)
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl %ecx, %r13d
shlq $0x2, %r13
testl %ecx, %ecx
movq $-0x1, %rdi
cmovnsq %r13, %rdi
callq 0x2030
testl %ebx, %ebx
jle 0x5d32
movq %rax, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %rax, %r13
callq 0x2100
movq %r13, %rax
movl -0x2c(%rbp), %ecx
testl %ecx, %ecx
jle 0x5d96
movl %ecx, %r9d
xorl %ecx, %ecx
testl %ebx, %ebx
js 0x5d8e
movsd (%r14,%rcx,8), %xmm0
xorl %edx, %edx
movl %ebx, %esi
leal (%rsi,%rdx), %r8d
movl %r8d, %edi
shrl $0x1f, %edi
addl %r8d, %edi
sarl %edi
movslq %edi, %r8
movsd (%r12,%r8,8), %xmm1
ucomisd %xmm0, %xmm1
movsd (%r15,%r8,8), %xmm1
jb 0x5d76
ucomisd %xmm1, %xmm0
jae 0x5d8a
ucomisd %xmm0, %xmm1
ja 0x5d82
incl %edi
movl %edi, %edx
movl %esi, %edi
movl %edi, %esi
cmpl %edi, %edx
jle 0x5d4c
jmp 0x5d8e
incl (%rax,%r8,4)
incq %rcx
cmpq %r9, %rcx
jne 0x5d3e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movl $0x28, %edi
callq 0x1030
movq %rax, %rbx
movl $0x18, %edi
callq 0x10a0
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x2aaa(%rip), %rcx      # 0x3d48
movq %rcx, (%rax)
movq %rbx, 0x10(%rax)
xorl %ecx, %ecx
movl %ecx, (%rbx,%rcx,4)
incq %rcx
cmpq $0xa, %rcx
jne 0x12a7
movq %rax, %rdi
callq 0x1424
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x1060
movq %rbx, %rdi
callq 0x12f2
callq 0x10f0
movq %rax, %rbx
callq 0x1110
movq %rbx, %rdi
callq 0x1120
movq %rax, %rdi
callq 0x1490
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movsd 0x228(%rdi), %xmm1
movsd 0x248(%rdi), %xmm0
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
callq 0x5920
movapd %xmm0, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm3
movsd 0x268(%rbx), %xmm1
jne 0x3a2e
jp 0x3a2e
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jne 0x3a2e
jnp 0x3a45
movapd %xmm1, %xmm0
movapd %xmm3, %xmm1
movsd %xmm3, -0x18(%rbp)
callq 0x584e
movsd -0x18(%rbp), %xmm3
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm3
movsd %xmm0, 0x288(%rbx)
jne 0x3a74
jp 0x3a74
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x280(%rbx)
movsd 0x2859e(%rip), %xmm0    # 0x2c010
jmp 0x3aab
movsd 0x228(%rbx), %xmm1
movsd 0x248(%rbx), %xmm0
callq 0x584e
movsd %xmm0, 0x280(%rbx)
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x3aab
addsd 0x28565(%rip), %xmm0    # 0x2c008
movsd %xmm0, 0x280(%rbx)
testb %r14b, %r14b
je 0x3b03
movsd 0x288(%rbx), %xmm1
xorpd %xmm2, %xmm2
xorl %eax, %eax
ucomisd %xmm2, %xmm1
setb %al
leaq 0x285b4(%rip), %rcx     # 0x2c080
movsd (%rcx,%rax,8), %xmm3
subsd %xmm1, %xmm3
addsd 0x2853b(%rip), %xmm0    # 0x2c018
movsd %xmm3, 0x288(%rbx)
movsd %xmm0, 0x280(%rbx)
ucomisd %xmm0, %xmm2
jbe 0x3b03
addsd 0x2850d(%rip), %xmm0    # 0x2c008
movsd %xmm0, 0x280(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movsd 0x280(%rdi), %xmm0
movsd 0x308(%rdi), %xmm1
addsd 0x288(%rdi), %xmm1
movsd %xmm1, 0x288(%rdi)
callq 0x5858
movsd %xmm0, -0x10(%rbp)
movsd 0x288(%rbx), %xmm0
callq 0x5858
movsd %xmm0, -0x18(%rbp)
movsd 0x280(%rbx), %xmm0
callq 0x5862
mulsd 0x300(%rbx), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd -0x10(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rbp)
movsd 0x280(%rbx), %xmm0
callq 0x5862
movsd %xmm0, -0x10(%rbp)
movsd 0x288(%rbx), %xmm0
callq 0x5862
mulsd -0x10(%rbp), %xmm0
mulsd 0x2f8(%rbx), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x220(%rbx)
movsd 0x280(%rbx), %xmm0
callq 0x5862
movsd %xmm0, -0x10(%rbp)
movsd 0x288(%rbx), %xmm0
callq 0x5858
movsd %xmm0, -0x18(%rbp)
movsd 0x280(%rbx), %xmm0
callq 0x5858
mulsd 0x300(%rbx), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd -0x10(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rbp)
movsd 0x280(%rbx), %xmm0
callq 0x5858
movsd %xmm0, -0x10(%rbp)
movsd 0x288(%rbx), %xmm0
callq 0x5862
mulsd -0x10(%rbp), %xmm0
mulsd 0x2f8(%rbx), %xmm0
movsd -0x18(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x240(%rbx)
movsd 0x288(%rbx), %xmm0
callq 0x5862
movsd %xmm0, 0x260(%rbx)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movsd 0x2a0(%rdi), %xmm0
movsd 0x2b8(%rdi), %xmm1
movsd %xmm0, 0x280(%rdi)
movsd %xmm1, 0x288(%rdi)
callq 0x3b0c
movsd 0x220(%rbx), %xmm0
movsd 0x240(%rbx), %xmm1
movsd %xmm0, 0x228(%rbx)
movsd %xmm1, 0x248(%rbx)
movsd 0x260(%rbx), %xmm0
movsd %xmm0, 0x268(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x39d8
movsd 0x280(%rbx), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x288(%rbx), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x2a8(%rbx), %xmm0
movsd %xmm0, 0x280(%rbx)
movsd 0x2c0(%rbx), %xmm0
movsd %xmm0, 0x288(%rbx)
movq %rbx, %rdi
callq 0x3b0c
movsd 0x220(%rbx), %xmm0
movsd 0x240(%rbx), %xmm1
movsd %xmm0, 0x228(%rbx)
movsd %xmm1, 0x248(%rbx)
movsd 0x260(%rbx), %xmm0
movsd %xmm0, 0x268(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x39d8
movsd 0x280(%rbx), %xmm2
movsd 0x288(%rbx), %xmm3
movsd -0x18(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x3f26
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x30, %rsp
movsd %xmm3, -0x8(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm0, -0x20(%rbp)
movaps %xmm1, %xmm0
callq 0x5862
movsd %xmm0, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x5862
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x5858
movsd %xmm0, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x5858
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
callq 0x5858
movsd -0x18(%rbp), %xmm1
mulsd -0x8(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm1
addsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd 0x28061(%rip), %xmm1    # 0x2c010
jae 0x3fd5
movsd 0x28077(%rip), %xmm0    # 0x2c030
ucomisd %xmm1, %xmm0
jae 0x3fcd
movapd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
jmp 0x5830
movsd 0x28053(%rip), %xmm0    # 0x2c028
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $0x1, %esi
ja 0x45ac
pushq %rbp
movq %rsp, %rbp
movsd 0x27b13(%rip), %xmm5    # 0x2c068
subsd %xmm2, %xmm5
movsd 0x27aff(%rip), %xmm2    # 0x2c060
mulsd %xmm2, %xmm5
movl %esi, %eax
movsd %xmm5, 0x2a0(%rdi,%rax,8)
mulsd %xmm2, %xmm3
movsd %xmm3, 0x2b8(%rdi,%rax,8)
mulsd 0x27aeb(%rip), %xmm4    # 0x2c070
addsd %xmm0, %xmm4
movsd 0x27ac7(%rip), %xmm0    # 0x2c058
divsd %xmm0, %xmm4
movsd %xmm4, 0x2d0(%rdi,%rax,8)
divsd %xmm0, %xmm1
movsd %xmm1, 0x2e8(%rdi,%rax,8)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/philipperemy[P]digital-setting-circles/Calc.cpp
// Function: Calc::EqToAzEl(double, double, double, bool, double*, double*)
void Calc::EqToAzEl(double ra, double dec, double time, bool flipped, double *azptr, double *elptr)
{
  int I, J;

  double RA = ra;
  double DEC = dec;

  DEC=DEC/degPerRad;
  RA=(RA-degreesPerMinute*time)/degPerRad;
  XX[1][1]=MathLib::cos(DEC)*MathLib::cos(RA);
  XX[2][1]=MathLib::cos(DEC)*MathLib::sin(RA);
  XX[3][1]=MathLib::sin(DEC);

  YY[1][1]=0; YY[2][1]=0; YY[3][1]=0;
  for (I=1; I<=3; I++) {
    for (J=1; J<=3; J++) {
      YY[I][1] += (RR[I][J]*XX[J][1]);
    }
  }

  YY1toFH(flipped);

  TrueToApparentAzEl(flipped);

  F *= degPerRad;
  H *= degPerRad;

  // This code measures azimuth backwards!
  F = 360.0-F;

  if (azptr)
    *azptr = F;

  if (elptr)
    *elptr = H;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r14
movsd 0x27439(%rip), %xmm3    # 0x2c058
divsd %xmm3, %xmm1
movsd %xmm1, -0x38(%rbp)
mulsd 0x27440(%rip), %xmm2    # 0x2c070
addsd %xmm2, %xmm0
divsd %xmm3, %xmm0
movsd %xmm0, -0x30(%rbp)
movapd %xmm1, %xmm0
callq 0x5858
movsd %xmm0, -0x28(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x5858
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x1a8(%r14)
movsd -0x38(%rbp), %xmm0
callq 0x5858
movsd %xmm0, -0x28(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x5862
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x1c8(%r14)
movsd -0x38(%rbp), %xmm0
callq 0x5862
movsd %xmm0, 0x1e8(%r14)
leaq 0x200(%r14), %rax
xorl %ecx, %ecx
movq %rcx, 0x228(%r14)
movq %rcx, 0x248(%r14)
movq %rcx, 0x268(%r14)
leaq 0x128(%r14), %rcx
movl $0x1, %edx
movq %rdx, %rsi
shlq $0x5, %rsi
addq %rax, %rsi
addq $0x8, %rsi
movsd (%rsi), %xmm0
xorl %edi, %edi
movsd (%rcx,%rdi), %xmm1
mulsd 0x1a8(%r14,%rdi,4), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rdi
cmpq $0x18, %rdi
jne 0x4cdb
incq %rdx
addq $0x20, %rcx
cmpq $0x4, %rdx
jne 0x4cc7
movzbl %r12b, %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0x39d8
movq %r14, %rdi
callq 0x3c5a
movq %r14, %rdi
movl %r12d, %esi
callq 0x39d8
movsd 0x288(%r14), %xmm0
subsd 0x308(%r14), %xmm0
movsd 0x280(%r14), %xmm1
movsd 0x2730a(%rip), %xmm2    # 0x2c058
mulsd %xmm2, %xmm1
mulsd %xmm2, %xmm0
movsd %xmm0, 0x288(%r14)
movsd 0x27301(%rip), %xmm0    # 0x2c068
subsd %xmm1, %xmm0
movsd %xmm0, 0x280(%r14)
testq %r15, %r15
je 0x4d7e
movsd %xmm0, (%r15)
testq %rbx, %rbx
je 0x4d90
movsd 0x288(%r14), %xmm0
movsd %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/philipperemy[P]digital-setting-circles/Calc.cpp
// Function: Calc::AzElToEq(double, double, double, double*, double*)
void Calc::AzElToEq(double az, double el, double time, double *raptr, double *decptr)
{
  int I, J;

  F = 360.0 - az; // This code measures azimuth backwards!
  H = el;

  F *= radPerDeg;
  H *= radPerDeg;

  AzEltoYY0();
  XX[1][1]=YY[1][0]; XX[2][1]=YY[2][0]; XX[3][1]=YY[3][0];
  YY[1][1]=0; YY[2][1]=0; YY[3][1]=0;

  for (I=1; I<=3; I++) {
    for (J=1; J<=3; J++) {
      YY[I][1] += (QQ[I][J]*XX[J][1]);
    }
  }
  YY1toFH(false);

  F *= degPerRad;
  H *= degPerRad;

  F += degreesPerMinute*time;

  F=F-MathLib::floor(F/360)*360;
  //F = fmod(F, 360.0);

  if (raptr)
    *raptr = F;

  if (decptr)
    *decptr = H;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movsd %xmm2, -0x20(%rbp)
movq %rdi, %r14
movsd 0x272aa(%rip), %xmm2    # 0x2c068
subsd %xmm0, %xmm2
movsd 0x27296(%rip), %xmm0    # 0x2c060
mulsd %xmm0, %xmm2
movsd %xmm2, 0x280(%rdi)
mulsd %xmm0, %xmm1
movsd %xmm1, 0x288(%rdi)
callq 0x3b0c
leaq 0x200(%r14), %rax
movsd 0x220(%r14), %xmm0
movsd 0x240(%r14), %xmm1
movsd %xmm0, 0x1a8(%r14)
movsd %xmm1, 0x1c8(%r14)
movsd 0x260(%r14), %xmm0
movsd %xmm0, 0x1e8(%r14)
xorl %ecx, %ecx
movq %rcx, 0x228(%r14)
movq %rcx, 0x248(%r14)
movq %rcx, 0x268(%r14)
leaq 0x28(%r14), %rcx
movl $0x1, %edx
movq %rdx, %rsi
shlq $0x5, %rsi
addq %rax, %rsi
addq $0x8, %rsi
movsd (%rsi), %xmm0
xorl %edi, %edi
movsd (%rcx,%rdi), %xmm1
mulsd 0x1a8(%r14,%rdi,4), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rdi
cmpq $0x18, %rdi
jne 0x4e58
incq %rdx
addq $0x20, %rcx
cmpq $0x4, %rdx
jne 0x4e44
movq %r14, %rdi
xorl %esi, %esi
callq 0x39d8
movsd 0x271c0(%rip), %xmm0    # 0x2c058
movsd 0x280(%r14), %xmm1
mulsd %xmm0, %xmm1
mulsd 0x288(%r14), %xmm0
movsd %xmm0, 0x288(%r14)
movsd -0x20(%rbp), %xmm0
mulsd 0x271b4(%rip), %xmm0    # 0x2c078
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd %xmm0, 0x280(%r14)
movsd 0x2718a(%rip), %xmm1    # 0x2c068
divsd %xmm1, %xmm0
callq 0x5972
movsd -0x20(%rbp), %xmm1
mulsd 0x27174(%rip), %xmm0    # 0x2c068
subsd %xmm0, %xmm1
movsd %xmm1, 0x280(%r14)
testq %r15, %r15
je 0x4f0b
movsd %xmm1, (%r15)
testq %rbx, %rbx
je 0x4f1d
movsd 0x288(%r14), %xmm0
movsd %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq