LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Obj::copy() const
Obj* Obj::copy() const {
	Obj* res = new Obj(*this);
	for(int i=0; i<objs.size(); ++i) res->objs[i] = res->objs[i]->copy();
	for(int i=0; i<motions.size(); ++i) res->motions[i] = res->motions[i]->copy();
	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x78, %edi
callq 0x31c0
movq %rax, %r15
movq %rax, %rbx
leaq 0x1108d(%rip), %rax     # 0x146e0
movq %rax, (%r15)
leaq 0x8(%r15), %r12
leaq 0x18(%r15), %rbp
movq %rbp, 0x8(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x7bd6
movups 0x28(%r14), %xmm0
movups 0x38(%r14), %xmm1
movups %xmm1, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
leaq 0x48(%r15), %r13
leaq 0x48(%r14), %rsi
movq %r13, %rdi
callq 0x794e
addq $0x60, %r15
leaq 0x60(%r14), %rsi
movq %r15, %rdi
callq 0x79ce
movq 0x50(%r14), %rax
cmpq 0x48(%r14), %rax
je 0x36de
xorl %r12d, %r12d
movq (%r13), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r13), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
movq 0x50(%r14), %rax
subq 0x48(%r14), %rax
sarq $0x3, %rax
cmpq %r12, %rax
ja 0x36b4
movq 0x68(%r14), %rax
cmpq 0x60(%r14), %rax
je 0x3713
xorl %r12d, %r12d
movq (%r15), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r15), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
movq 0x68(%r14), %rax
subq 0x60(%r14), %rax
sarq $0x3, %rax
cmpq %r12, %rax
ja 0x36eb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r13), %rdi
testq %rdi, %rdi
je 0x3742
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x31d0
jmp 0x3742
movq %rax, %r14
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x375c
movq (%rbp), %rsi
incq %rsi
callq 0x31d0
jmp 0x375c
movq %rax, %r14
movl $0x78, %esi
movq %rbx, %rdi
callq 0x31d0
movq %r14, %rdi
callq 0x32f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Obj::judge(std::pair<float, float> const&, bool*) const
bool Obj::judge(const Fpair& pt, bool *val) const { // returned value: if pt=(x,y) is in the governing region; val: if pt=(x,y) gets solid printed.
	if(tlim.first <= TimeNow && TimeNow < tlim.second)
		if(lower <= pt && pt <= upper) for(auto rit = objs.rbegin(); rit != objs.rend(); ++rit) if((*rit)->judge(pt, val)) return true;
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movss 0x114c8(%rip), %xmm0    # 0x151d4
xorl %ebp, %ebp
ucomiss 0x40(%rdi), %xmm0
jb 0x3d80
movq %rdi, %r15
movss 0x44(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x3d80
movq %rsi, %r14
movss (%rsi), %xmm0
xorl %ebp, %ebp
ucomiss 0x30(%r15), %xmm0
jb 0x3d80
movss 0x4(%r14), %xmm1
ucomiss 0x34(%r15), %xmm1
jb 0x3d80
movss 0x38(%r15), %xmm2
xorl %ebp, %ebp
ucomiss %xmm0, %xmm2
jb 0x3d80
movss 0x3c(%r15), %xmm0
ucomiss %xmm1, %xmm0
jb 0x3d80
movq %rdx, %rbx
movq 0x50(%r15), %r12
cmpq 0x48(%r15), %r12
setne %bpl
je 0x3d80
movq -0x8(%r12), %rdi
addq $-0x8, %r12
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x20(%rax)
testb %al, %al
je 0x3d5d
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Obj::update()
void Obj::update(void) {
	if(TimeNow < tlim.second) {
		for(auto p: motions) p->act(this);
		lower = {wid_ht,1}; upper = {-wid_ht,-1};
		for(auto p: objs) {
			p->update();
			union_pt(lower, upper, p->lower, p->upper);
		}
	}
}

// Assembly:
movss 0x44(%rdi), %xmm0
ucomiss 0x1143c(%rip), %xmm0    # 0x151d4
jbe 0x3e65
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %r14
movq 0x68(%rdi), %r15
cmpq %r15, %r14
je 0x3dc8
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
addq $0x8, %r14
jmp 0x3db1
movss 0x11400(%rip), %xmm0    # 0x151d0
movss %xmm0, 0x30(%rbx)
movl $0x3f800000, 0x34(%rbx) # imm = 0x3F800000
xorps 0xc22d(%rip), %xmm0     # 0x10010
movss %xmm0, 0x38(%rbx)
movl $0xbf800000, 0x3c(%rbx) # imm = 0xBF800000
movq 0x48(%rbx), %r15
movq 0x50(%rbx), %r12
cmpq %r12, %r15
je 0x3e5a
movq (%r15), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
movss 0x30(%r14), %xmm0
movss 0x30(%rbx), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x3e1d
movss %xmm0, 0x30(%rbx)
movss 0x34(%r14), %xmm0
movss 0x34(%rbx), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x3e32
movss %xmm0, 0x34(%rbx)
movss 0x38(%r14), %xmm0
ucomiss 0x38(%rbx), %xmm0
jbe 0x3e43
movss %xmm0, 0x38(%rbx)
movss 0x3c(%r14), %xmm0
ucomiss 0x3c(%rbx), %xmm0
jbe 0x3e54
movss %xmm0, 0x3c(%rbx)
addq $0x8, %r15
jmp 0x3df7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: IntObj::copy() const
Obj* IntObj::copy() const {
	IntObj* res = new IntObj(*this);
	for(int i=0; i<objs.size(); ++i) res->objs[i] = res->objs[i]->copy();
	for(int i=0; i<motions.size(); ++i) res->motions[i] = res->motions[i]->copy();
	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x80, %edi
callq 0x31c0
movq %rax, %r15
movq %rax, %rbx
leaq 0x10643(%rip), %rax     # 0x146e0
movq %rax, (%r15)
leaq 0x8(%r15), %r12
leaq 0x18(%r15), %rbp
movq %rbp, 0x8(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x7bd6
movups 0x28(%r14), %xmm0
movups 0x38(%r14), %xmm1
movups %xmm1, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
leaq 0x48(%r15), %r13
leaq 0x48(%r14), %rsi
movq %r13, %rdi
callq 0x794e
addq $0x60, %r15
leaq 0x60(%r14), %rsi
movq %r15, %rdi
callq 0x79ce
leaq 0x10658(%rip), %rax     # 0x14750
movq %rax, (%rbx)
movb 0x78(%r14), %al
movb %al, 0x78(%rbx)
movq 0x50(%r14), %rax
cmpq 0x48(%r14), %rax
je 0x4139
xorl %r12d, %r12d
movq (%r13), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r13), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
movq 0x50(%r14), %rax
subq 0x48(%r14), %rax
sarq $0x3, %rax
cmpq %r12, %rax
ja 0x410f
movq 0x68(%r14), %rax
cmpq 0x60(%r14), %rax
je 0x416e
xorl %r12d, %r12d
movq (%r15), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r15), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
movq 0x68(%r14), %rax
subq 0x60(%r14), %rax
sarq $0x3, %rax
cmpq %r12, %rax
ja 0x4146
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r13), %rdi
testq %rdi, %rdi
je 0x419d
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x31d0
jmp 0x419d
movq %rax, %r14
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x41b7
movq (%rbp), %rsi
incq %rsi
callq 0x31d0
jmp 0x41b7
movq %rax, %r14
movl $0x80, %esi
movq %rbx, %rdi
callq 0x31d0
movq %r14, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: IntObj::judge(std::pair<float, float> const&, bool*) const
bool IntObj::judge(const Fpair& pt, bool *val) const { // returned value: if pt=(x,y) is in the governing region; val: if pt=(x,y) gets solid printed.
	bool gov = false;
	if(tlim.first <= TimeNow && TimeNow < tlim.second)
		if(lower <= pt && pt <= upper) {
			auto rit = objs.rbegin();
			for(; rit != objs.rend(); ++rit) if(!((*rit)->judge(pt))) break;
			if(rit == objs.rend()) gov = true;
		}
	if(val!=nullptr) *val = !(gov^solid);
	return gov;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movss 0x10ff1(%rip), %xmm0    # 0x151d4
xorl %eax, %eax
ucomiss 0x40(%rdi), %xmm0
jb 0x4260
movss 0x44(%r14), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x4260
movq %rsi, %r15
movss (%rsi), %xmm0
xorl %eax, %eax
ucomiss 0x30(%r14), %xmm0
jb 0x4260
movss 0x4(%r15), %xmm1
ucomiss 0x34(%r14), %xmm1
jb 0x4260
movss 0x38(%r14), %xmm2
xorl %eax, %eax
ucomiss %xmm0, %xmm2
jb 0x4260
movss 0x3c(%r14), %xmm0
ucomiss %xmm1, %xmm0
jb 0x4260
movq 0x50(%r14), %r13
movq %r13, %r12
cmpq 0x48(%r14), %r13
je 0x4257
leaq -0x8(%r12), %r13
movq -0x8(%r12), %rdi
movq (%rdi), %rax
movq %r15, %rsi
xorl %edx, %edx
callq *0x20(%rax)
testb %al, %al
jne 0x422f
movq 0x48(%r14), %rax
jmp 0x425a
movq %r12, %rax
cmpq %rax, %r12
sete %al
testq %rbx, %rbx
je 0x426c
cmpb %al, 0x78(%r14)
sete (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: IntObj::update()
void IntObj::update(void) {
	if(TimeNow < tlim.second) {
		for(auto p: motions) p->act(this);
		lower = {-wid_ht,-1}; upper = {wid_ht,1};
		for(auto p: objs) {
			p->update();
			intersect_pt(lower, upper, p->lower, p->upper);
		}
	}
}

// Assembly:
movss 0x44(%rdi), %xmm0
ucomiss 0x10f52(%rip), %xmm0    # 0x151d4
jbe 0x4352
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %r14
movq 0x68(%rdi), %r15
cmpq %r15, %r14
je 0x42b2
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
addq $0x8, %r14
jmp 0x429b
movss 0x10f16(%rip), %xmm0    # 0x151d0
movaps 0xbd4f(%rip), %xmm1     # 0x10010
xorps %xmm0, %xmm1
movss %xmm1, 0x30(%rbx)
movl $0xbf800000, 0x34(%rbx) # imm = 0xBF800000
movss %xmm0, 0x38(%rbx)
movl $0x3f800000, 0x3c(%rbx) # imm = 0x3F800000
movq 0x48(%rbx), %r15
movq 0x50(%rbx), %r12
cmpq %r12, %r15
je 0x4347
movq (%r15), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
movss 0x30(%r14), %xmm0
ucomiss 0x30(%rbx), %xmm0
jbe 0x4306
movss %xmm0, 0x30(%rbx)
movss 0x34(%r14), %xmm0
ucomiss 0x34(%rbx), %xmm0
jbe 0x4317
movss %xmm0, 0x34(%rbx)
movss 0x38(%r14), %xmm0
movss 0x38(%rbx), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x432c
movss %xmm0, 0x38(%rbx)
movss 0x3c(%r14), %xmm0
movss 0x3c(%rbx), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x4341
movss %xmm0, 0x3c(%rbx)
addq $0x8, %r15
jmp 0x42e4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Frame::play(float)
void Frame::play(float time_end) {
	int c; bool val; float x, y;
	do {
		TimeNow += time_intv;
		this->update();
		y = 1;
		for(int j=0; j<FrameHeight; ++j) {
			x = -wid_ht;
			for(int i=0; i<FrameWidth; ++i) {
				c = 0;
				for(int n=0; n<3; ++n) {
					if(!this->judge({x, y-n*y_intv}, &val)) val = false;
					c ^= val<<n;
				}
				cout << c[" ''*.'u$"]; // cout << c[" ''\".$u$"];
				x += x_intv;
			}
			cout << '\n';
			y -= 3*y_intv;
		}
		usleep(time_intv*1000000); cout << rewindstr;
	} while(TimeNow < time_end);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movss %xmm0, 0x10(%rsp)
movq %rdi, %rbx
movss 0x10b73(%rip), %xmm0    # 0x151d4
leaq 0x18(%rsp), %r14
leaq 0x9(%rsp), %r15
addss 0x78(%rbx), %xmm0
movss %xmm0, 0x10b5c(%rip)    # 0x151d4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x0, 0x10b44(%rip)     # 0x151cc
jle 0x47b7
xorl %eax, %eax
movss 0xb9d8(%rip), %xmm0     # 0x10070
movss %xmm0, 0xc(%rsp)
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x10b1f(%rip)     # 0x151c8
jle 0x476a
movss 0x10b19(%rip), %xmm0    # 0x151d0
xorps 0xb952(%rip), %xmm0     # 0x10010
movaps %xmm0, 0x20(%rsp)
xorl %r13d, %r13d
xorl %ebp, %ebp
xorl %r12d, %r12d
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
mulss 0x80(%rbx), %xmm0
movss 0xc(%rsp), %xmm1
subss %xmm0, %xmm1
movaps 0x20(%rsp), %xmm0
movss %xmm0, 0x18(%rsp)
movss %xmm1, 0x1c(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x20(%rax)
testb %al, %al
je 0x470f
movzbl 0x9(%rsp), %eax
jmp 0x4716
movb $0x0, 0x9(%rsp)
xorl %eax, %eax
movl %ebp, %ecx
shll %cl, %eax
xorl %eax, %r12d
incl %ebp
cmpl $0x3, %ebp
jne 0x46cb
movslq %r12d, %rax
leaq 0xb98d(%rip), %rcx      # 0x100bb
movb (%rax,%rcx), %al
movb %al, 0xb(%rsp)
movl $0x1, %edx
movq 0x10877(%rip), %rdi     # 0x14fb8
leaq 0xb(%rsp), %rsi
callq 0x3210
movaps 0x20(%rsp), %xmm0
addss 0x7c(%rbx), %xmm0
movaps %xmm0, 0x20(%rsp)
incl %r13d
cmpl 0x10a64(%rip), %r13d    # 0x151c8
jl 0x46c6
movb $0xa, 0xa(%rsp)
movl $0x1, %edx
movq 0x1083d(%rip), %rdi     # 0x14fb8
leaq 0xa(%rsp), %rsi
callq 0x3210
movss 0x80(%rbx), %xmm0
mulss 0xb8df(%rip), %xmm0     # 0x10074
movss 0xc(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movl 0x14(%rsp), %eax
incl %eax
cmpl 0x10a1b(%rip), %eax     # 0x151cc
jl 0x469e
movss 0x78(%rbx), %xmm0
mulss 0xb8b4(%rip), %xmm0     # 0x10078
cvttss2si %xmm0, %rdi
callq 0x3250
movq 0x88(%rbx), %rsi
movq 0x90(%rbx), %rdx
movq 0x107d5(%rip), %rdi     # 0x14fb8
callq 0x3210
movss 0x109e4(%rip), %xmm0    # 0x151d4
movss 0x10(%rsp), %xmm1
ucomiss %xmm0, %xmm1
ja 0x466b
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Line::judge(std::pair<float, float> const&, bool*) const
bool Line::judge(const Fpair& pt, bool *val) const {
	bool gov = false;
	if(tlim.first <= TimeNow && TimeNow < tlim.second) {
		float dist = v*pt;
		gov = (dist > intsc) && (dist <= intsc+width);
	}
	if(val!=nullptr) *val = !(gov^solid);
	return gov;
}

// Assembly:
movss 0x107f2(%rip), %xmm0    # 0x151d4
xorl %eax, %eax
ucomiss 0x40(%rdi), %xmm0
jb 0x4a31
movss 0x44(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x4a31
movss 0x84(%rdi), %xmm0
movss 0x88(%rdi), %xmm1
mulss 0x4(%rsi), %xmm1
mulss (%rsi), %xmm0
movss 0x7c(%rdi), %xmm2
addss %xmm1, %xmm0
movss 0x80(%rdi), %xmm1
addss %xmm2, %xmm1
cmpltps %xmm0, %xmm2
cmpleps %xmm1, %xmm0
andps %xmm2, %xmm0
movd %xmm0, %eax
testq %rdx, %rdx
je 0x4a44
movl %eax, %ecx
andb $0x1, %cl
cmpb %cl, 0x8c(%rdi)
sete (%rdx)
andb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Line::rotate(float, std::pair<float, float> const&)
Line* Line::rotate(float dangle, const Fpair& pr) {
	rot_pt_pt(pc, pr, dangle);
	angle += dangle;
	dangle = v*pr - intsc;
	v = {cos(angle), sin(angle)};
	intsc = v*pr - dangle;
	return this;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rdi), %xmm1
movsd (%rsi), %xmm2
subps %xmm2, %xmm1
movaps %xmm1, 0x10(%rsp)
callq 0x3320
movsd %xmm0, 0x30(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x3050
xorps %xmm1, %xmm1
cvtsd2ss 0x30(%rsp), %xmm1
cvtsd2ss %xmm0, %xmm0
movaps 0xb4f6(%rip), %xmm2     # 0x10010
xorps %xmm0, %xmm2
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
movaps 0x10(%rsp), %xmm3
movaps %xmm3, %xmm0
shufps $0xe1, %xmm3, %xmm0     # xmm0 = xmm0[1,0],xmm3[2,3]
mulps %xmm2, %xmm0
unpcklps %xmm1, %xmm1            # xmm1 = xmm1[0,0,1,1]
mulps %xmm3, %xmm1
addps %xmm0, %xmm1
movsd (%r14), %xmm0
addps %xmm1, %xmm0
movlps %xmm0, 0x28(%rbx)
movss 0xc(%rsp), %xmm0
addss 0x78(%rbx), %xmm0
movss %xmm0, 0x78(%rbx)
movss 0x84(%rbx), %xmm2
movss 0x88(%rbx), %xmm1
mulss 0x4(%r14), %xmm1
mulss (%r14), %xmm2
addss %xmm1, %xmm2
subss 0x7c(%rbx), %xmm2
movss %xmm2, 0xc(%rsp)
callq 0x3150
movss %xmm0, 0x10(%rsp)
movss 0x78(%rbx), %xmm0
callq 0x3180
movss 0x10(%rsp), %xmm1
movss %xmm1, 0x84(%rbx)
movss %xmm0, 0x88(%rbx)
mulss 0x4(%r14), %xmm0
mulss (%r14), %xmm1
addss %xmm0, %xmm1
subss 0xc(%rsp), %xmm1
movss %xmm1, 0x7c(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Line::scale(float, std::pair<float, float> const&)
Line* Line::scale(float rate, const Fpair& ps) {
	scl_pt_pt(pc, ps, rate);
	intsc = (1-rate)*(v*ps) + intsc*rate;
	width *= rate;
	return this;
}

// Assembly:
movq %rdi, %rax
movss 0xb497(%rip), %xmm1     # 0x10070
subss %xmm0, %xmm1
movsd 0x28(%rdi), %xmm2
movaps %xmm0, %xmm3
unpcklps %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1]
mulps %xmm2, %xmm3
movsd (%rsi), %xmm2
movaps %xmm1, %xmm4
unpcklps %xmm1, %xmm4            # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1]
mulps %xmm2, %xmm4
addps %xmm3, %xmm4
movlps %xmm4, 0x28(%rdi)
movss 0x84(%rdi), %xmm2
movss 0x88(%rdi), %xmm3
mulss 0x4(%rsi), %xmm3
mulss (%rsi), %xmm2
addss %xmm3, %xmm2
movss 0x7c(%rdi), %xmm3
mulss %xmm0, %xmm3
mulss %xmm1, %xmm2
addss %xmm3, %xmm2
movss %xmm2, 0x7c(%rdi)
mulss 0x80(%rdi), %xmm0
movss %xmm0, 0x80(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Line::scale(float)
Line* Line::scale(float rate) { // expand/shrink wrt the centerline
	intsc += (1-rate)/2*width;
	width *= rate;
	return this;
}

// Assembly:
movq %rdi, %rax
movss 0xb421(%rip), %xmm1     # 0x10070
subss %xmm0, %xmm1
mulss 0xb421(%rip), %xmm1     # 0x1007c
movss 0x80(%rdi), %xmm2
mulss %xmm2, %xmm1
addss 0x7c(%rdi), %xmm1
movss %xmm1, 0x7c(%rdi)
mulss %xmm0, %xmm2
movss %xmm2, 0x80(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Triangle::judge(std::pair<float, float> const&, bool*) const
bool Triangle::judge(const Fpair& pt, bool *val) const {
	bool gov = false;
	if(tlim.first <= TimeNow && TimeNow < tlim.second)
		if(lower <= pt && pt <= upper) {
			Fpair v = pt - p0;
			float v1v_v1v2 = cross(v1, v) / v1v2,
				  vv2_v1v2 = cross(v, v2) / v1v2;
			gov = ((v1v_v1v2 >= 0) && (vv2_v1v2 >= 0) && (v1v_v1v2 + vv2_v1v2 <= 1));
		}
	if(val!=nullptr) *val = !(gov^solid);
	return gov;
}

// Assembly:
movss 0x1010c(%rip), %xmm0    # 0x151d4
xorl %eax, %eax
ucomiss 0x40(%rdi), %xmm0
jb 0x51a7
movss 0x44(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x51a7
movsd (%rsi), %xmm0
xorl %eax, %eax
ucomiss 0x30(%rdi), %xmm0
jb 0x51a7
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
ucomiss 0x34(%rdi), %xmm1
jb 0x51a7
movss 0x38(%rdi), %xmm2
xorl %eax, %eax
ucomiss %xmm0, %xmm2
jb 0x51a7
movss 0x3c(%rdi), %xmm2
ucomiss %xmm1, %xmm2
jb 0x51a7
movsd 0x78(%rdi), %xmm1
subps %xmm1, %xmm0
movaps %xmm0, %xmm2
shufps $0xe1, %xmm0, %xmm2     # xmm2 = xmm2[1,0],xmm0[2,3]
movss 0x94(%rdi), %xmm1
shufps $0xd4, %xmm0, %xmm1     # xmm1 = xmm1[0,1],xmm0[1,3]
shufps $0xe2, %xmm0, %xmm1     # xmm1 = xmm1[2,0],xmm0[2,3]
movss 0x98(%rdi), %xmm3
movss %xmm3, %xmm2            # xmm2 = xmm3[0],xmm2[1,2,3]
mulps %xmm1, %xmm2
movss 0x90(%rdi), %xmm3
movss 0x9c(%rdi), %xmm1
unpcklps %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
mulps %xmm0, %xmm1
subps %xmm2, %xmm1
movss 0xa0(%rdi), %xmm0
shufps $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
divps %xmm0, %xmm1
xorps %xmm0, %xmm0
cmpleps %xmm1, %xmm0
unpcklps %xmm0, %xmm0            # xmm0 = xmm0[0,0,1,1]
movmskpd %xmm0, %eax
cmpl $0x3, %eax
jne 0x51a5
movaps %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm0     # xmm0 = xmm0[1,1],xmm1[1,1]
addss %xmm1, %xmm0
movss 0xaed3(%rip), %xmm1     # 0x10070
ucomiss %xmm0, %xmm1
setae %al
jmp 0x51a7
xorl %eax, %eax
testq %rdx, %rdx
je 0x51b5
cmpb %al, 0xa4(%rdi)
sete (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Triangle::rotate(float, std::pair<float, float> const&)
Triangle* Triangle::rotate(float dangle, const Fpair& pr) {
	rot_pt_pt({&p0, &p1, &p2, &pc}, pr, dangle);
	v1 = p1 - p0; v2 = p2 - p0;
	// v1v2 is unchanged
	this->set_lim(); return this;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x78(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x80(%rdi), %rax
movq %rax, 0x20(%rsp)
leaq 0x88(%rdi), %rax
movq %rax, 0x28(%rsp)
leaq 0x28(%rdi), %rax
movq %rax, 0x30(%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x3320
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x3050
cvtsd2ss 0x10(%rsp), %xmm1
cvtsd2ss %xmm0, %xmm0
movaps 0xad46(%rip), %xmm2     # 0x10010
xorps %xmm0, %xmm2
shufps $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
xorl %eax, %eax
movq 0x18(%rsp,%rax), %rcx
movsd (%rcx), %xmm2
movsd (%r14), %xmm3
subps %xmm3, %xmm2
movaps %xmm1, %xmm4
mulps %xmm2, %xmm4
mulps %xmm0, %xmm2
shufps $0xe1, %xmm2, %xmm2     # xmm2 = xmm2[1,0,2,3]
addps %xmm4, %xmm2
addps %xmm3, %xmm2
movlps %xmm2, (%rcx)
addq $0x8, %rax
cmpq $0x20, %rax
jne 0x52d6
movsd 0x78(%rbx), %xmm0
movlhps %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movups 0x80(%rbx), %xmm1
subps %xmm0, %xmm1
movups %xmm1, 0x90(%rbx)
movq %rbx, %rdi
callq 0x4c7e
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Triangle::scale(float, std::pair<float, float> const&)
Triangle* Triangle::scale(float rate, const Fpair& ps) {
	scl_pt_pt({&p0, &p1, &p2, &pc, &lower, &upper}, ps, rate);
	if(rate < 0) swap(lower, upper);
	v1 *= rate; v2 *= rate; v1v2 *= (rate*rate);
	return this;
}

// Assembly:
movq %rdi, %rax
leaq 0x78(%rdi), %rcx
movq %rcx, -0x30(%rsp)
leaq 0x80(%rdi), %rcx
movq %rcx, -0x28(%rsp)
leaq 0x88(%rdi), %rcx
movq %rcx, -0x20(%rsp)
leaq 0x28(%rdi), %rcx
movq %rcx, -0x18(%rsp)
leaq 0x30(%rdi), %rcx
movq %rcx, -0x10(%rsp)
leaq 0x38(%rdi), %rdx
movq %rdx, -0x8(%rsp)
movss 0xacf5(%rip), %xmm2     # 0x10070
subss %xmm0, %xmm2
movsd (%rsi), %xmm1
shufps $0x0, %xmm2, %xmm2      # xmm2 = xmm2[0,0,0,0]
mulps %xmm1, %xmm2
movaps %xmm0, %xmm1
shufps $0x0, %xmm0, %xmm1      # xmm1 = xmm1[0,0],xmm0[0,0]
xorl %edx, %edx
movq -0x30(%rsp,%rdx), %rsi
movsd (%rsi), %xmm3
mulps %xmm1, %xmm3
addps %xmm2, %xmm3
movlps %xmm3, (%rsi)
addq $0x8, %rdx
cmpq $0x30, %rdx
jne 0x5393
xorps %xmm2, %xmm2
ucomiss %xmm0, %xmm2
jbe 0x53c1
movups (%rcx), %xmm2
shufps $0x4e, %xmm2, %xmm2     # xmm2 = xmm2[2,3,0,1]
movups %xmm2, (%rcx)
movups 0x90(%rax), %xmm2
mulps %xmm1, %xmm2
movups %xmm2, 0x90(%rax)
mulss %xmm0, %xmm0
mulss 0xa0(%rax), %xmm0
movss %xmm0, 0xa0(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Rectangle::judge(std::pair<float, float> const&, bool*) const
bool Rectangle::judge(const Fpair& pt, bool *val) const {
	bool gov = false;
	if(tlim.first <= TimeNow && TimeNow < tlim.second)
		if(lower <= pt && pt <= upper) gov = (l1.judge(pt) && l2.judge(pt));
	if(val!=nullptr) *val = !(gov^solid);
	return gov;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movss 0xf692(%rip), %xmm0     # 0x151d4
xorl %r15d, %r15d
ucomiss 0x40(%rdi), %xmm0
jb 0x5bba
movss 0x44(%r14), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x5bba
movq %rsi, %r12
movss (%rsi), %xmm0
xorl %r15d, %r15d
ucomiss 0x30(%r14), %xmm0
jb 0x5bba
movss 0x4(%r12), %xmm1
ucomiss 0x34(%r14), %xmm1
jb 0x5bba
movss 0x38(%r14), %xmm2
xorl %r15d, %r15d
ucomiss %xmm0, %xmm2
jb 0x5bba
movss 0x3c(%r14), %xmm0
ucomiss %xmm1, %xmm0
jb 0x5bba
leaq 0x98(%r14), %rdi
xorl %r15d, %r15d
movq %r12, %rsi
xorl %edx, %edx
callq 0x49da
testb %al, %al
je 0x5bba
leaq 0x128(%r14), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x49da
movl %eax, %r15d
testq %rbx, %rbx
je 0x5bc9
cmpb %r15b, 0x1b8(%r14)
sete (%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Rectangle::rotate(float, std::pair<float, float> const&)
Rectangle* Rectangle::rotate(float dangle, const Fpair& pr) {
	rot_pt_pt({&pc0, &pc}, pr, dangle);
	l1.rotate(dangle, pr); l2.rotate(dangle, pr);
	angle += dangle;
	v = {cos(angle), sin(angle)};
	this->set_lim();
	return this;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x78(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x28(%rdi), %rax
movq %rax, 0x20(%rsp)
movss %xmm0, 0x4(%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x3320
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x3050
cvtsd2ss 0x10(%rsp), %xmm1
cvtsd2ss %xmm0, %xmm0
movaps 0xa2d8(%rip), %xmm2     # 0x10010
xorps %xmm0, %xmm2
shufps $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
xorl %eax, %eax
movq 0x18(%rsp,%rax), %rcx
movsd (%rcx), %xmm2
movsd (%r14), %xmm3
subps %xmm3, %xmm2
movaps %xmm1, %xmm4
mulps %xmm2, %xmm4
mulps %xmm0, %xmm2
shufps $0xe1, %xmm2, %xmm2     # xmm2 = xmm2[1,0,2,3]
addps %xmm4, %xmm2
addps %xmm3, %xmm2
movlps %xmm2, (%rcx)
addq $0x8, %rax
cmpq $0x10, %rax
jne 0x5d44
leaq 0x98(%rbx), %rdi
movss 0x4(%rsp), %xmm0
movq %r14, %rsi
callq 0x4ac2
leaq 0x128(%rbx), %rdi
movss 0x4(%rsp), %xmm0
movq %r14, %rsi
callq 0x4ac2
movss 0x4(%rsp), %xmm0
addss 0x90(%rbx), %xmm0
movss %xmm0, 0x90(%rbx)
callq 0x3150
movss %xmm0, 0x4(%rsp)
movss 0x90(%rbx), %xmm0
callq 0x3180
movss 0x4(%rsp), %xmm1
movss %xmm1, 0x80(%rbx)
movss %xmm0, 0x84(%rbx)
movq %rbx, %rdi
callq 0x568a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Rectangle::scale(float, std::pair<float, float> const&)
Rectangle* Rectangle::scale(float rate, const Fpair& ps) {
	scl_pt_pt({&pc0, &pc, &lower, &upper}, ps, rate);
	if(rate < 0) swap(lower, upper);
	wid1 *= rate; wid2 *= rate;
	l1.scale(rate, ps); l2.scale(rate, ps);
	return this;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x78(%rdi), %rax
movq %rax, (%rsp)
leaq 0x28(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x18(%rsp)
movss 0xa242(%rip), %xmm1     # 0x10070
subss %xmm0, %xmm1
movsd (%rsi), %xmm2
shufps $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
mulps %xmm2, %xmm1
movaps %xmm0, %xmm3
shufps $0x0, %xmm0, %xmm3      # xmm3 = xmm3[0,0],xmm0[0,0]
xorl %ecx, %ecx
movq (%rsp,%rcx), %rdx
movsd (%rdx), %xmm2
mulps %xmm3, %xmm2
addps %xmm1, %xmm2
movlps %xmm2, (%rdx)
addq $0x8, %rcx
cmpq $0x20, %rcx
jne 0x5e46
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x5e73
movups (%rax), %xmm1
shufps $0x4e, %xmm1, %xmm1     # xmm1 = xmm1[2,3,0,1]
movups %xmm1, (%rax)
movsd 0x88(%rbx), %xmm1
mulps %xmm3, %xmm1
movlps %xmm1, 0x88(%rbx)
leaq 0x98(%rbx), %rdi
movq %r14, %rsi
movaps %xmm0, 0x20(%rsp)
callq 0x4bce
leaq 0x128(%rbx), %rdi
movaps 0x20(%rsp), %xmm0
movq %r14, %rsi
callq 0x4bce
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Ellipse::set_lim()
void Ellipse::set_lim(void) {
	float delta = sqrt(asq*v.first*v.first + bsq*v.second*v.second);
	lower.first = pc0.first - delta; upper.first = pc0.first + delta;
	delta = sqrt(asq*v.second*v.second + bsq*v.first*v.first);
	lower.second = pc0.second - delta; upper.second = pc0.second + delta;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movss 0x80(%rdi), %xmm1
movss 0x84(%rdi), %xmm2
movss 0x88(%rdi), %xmm0
mulss %xmm1, %xmm0
movss 0x8c(%rdi), %xmm3
mulss %xmm2, %xmm3
mulss %xmm2, %xmm3
mulss %xmm1, %xmm0
addss %xmm3, %xmm0
xorps %xmm4, %xmm4
ucomiss %xmm4, %xmm0
jb 0x5efe
sqrtss %xmm0, %xmm0
jmp 0x5f06
callq 0x3310
xorps %xmm4, %xmm4
movss 0x78(%rbx), %xmm1
movss 0x80(%rbx), %xmm2
movaps %xmm1, %xmm3
subss %xmm0, %xmm3
movss %xmm3, 0x30(%rbx)
addss %xmm1, %xmm0
movss %xmm0, 0x38(%rbx)
movss 0x84(%rbx), %xmm1
movss 0x88(%rbx), %xmm0
mulss %xmm1, %xmm0
movss 0x8c(%rbx), %xmm3
mulss %xmm2, %xmm3
mulss %xmm2, %xmm3
mulss %xmm1, %xmm0
addss %xmm3, %xmm0
ucomiss %xmm4, %xmm0
jb 0x5f5f
sqrtss %xmm0, %xmm0
jmp 0x5f64
callq 0x3310
movss 0x7c(%rbx), %xmm1
movaps %xmm1, %xmm2
subss %xmm0, %xmm2
movss %xmm2, 0x34(%rbx)
addss %xmm1, %xmm0
movss %xmm0, 0x3c(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Ellipse::judge(std::pair<float, float> const&, bool*) const
bool Ellipse::judge(const Fpair& pt, bool *val) const {
	bool gov = false;
	if(tlim.first <= TimeNow && TimeNow < tlim.second)
		if(lower <= pt && pt <= upper) {
			float dx = pt.first - pc0.first, dy = pt.second - pc0.second;
			gov = (pow(dx*v.first + dy*v.second, 2)/asq + pow(-dx*v.second + dy*v.first, 2)/bsq < 1);
		}
	if(val!=nullptr) *val = !(gov^solid);
	return gov;
}

// Assembly:
movss 0xef80(%rip), %xmm0     # 0x151d4
xorl %eax, %eax
ucomiss 0x40(%rdi), %xmm0
jb 0x62f8
movss 0x44(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x62f8
movss (%rsi), %xmm0
xorl %eax, %eax
ucomiss 0x30(%rdi), %xmm0
jb 0x62f8
movss 0x4(%rsi), %xmm1
ucomiss 0x34(%rdi), %xmm1
jb 0x62f8
movss 0x38(%rdi), %xmm2
xorl %eax, %eax
ucomiss %xmm0, %xmm2
jb 0x62f8
movss 0x3c(%rdi), %xmm2
ucomiss %xmm1, %xmm2
jb 0x62f8
subss 0x78(%rdi), %xmm0
subss 0x7c(%rdi), %xmm1
movaps 0x9d64(%rip), %xmm2     # 0x10010
xorps %xmm0, %xmm2
movsd 0x80(%rdi), %xmm3
shufps $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
mulps %xmm3, %xmm0
shufps $0xe1, %xmm3, %xmm3     # xmm3 = xmm3[1,0,2,3]
mulps %xmm1, %xmm3
addps %xmm3, %xmm0
cvtps2pd %xmm0, %xmm0
mulpd %xmm0, %xmm0
cvtps2pd 0x88(%rdi), %xmm1
divpd %xmm1, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x9d9f(%rip), %xmm0     # 0x10090
ucomisd %xmm1, %xmm0
seta %al
testq %rdx, %rdx
je 0x6306
cmpb %al, 0x94(%rdi)
sete (%rdx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Ellipse::rotate(float, std::pair<float, float> const&)
Ellipse* Ellipse::rotate(float dangle, const Fpair& pr) {
	rot_pt_pt({&pc0, &pc}, pr, dangle);
	angle += dangle;
	v = {cos(angle), sin(angle)};
	this->set_lim();
	return this;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x78(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x28(%rdi), %rax
movq %rax, 0x20(%rsp)
movss %xmm0, 0x4(%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x3320
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x3050
cvtsd2ss 0x10(%rsp), %xmm1
cvtsd2ss %xmm0, %xmm0
movaps 0x9c32(%rip), %xmm2     # 0x10010
xorps %xmm0, %xmm2
shufps $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
xorl %eax, %eax
movq 0x18(%rsp,%rax), %rcx
movsd (%rcx), %xmm2
movsd (%r14), %xmm3
subps %xmm3, %xmm2
movaps %xmm1, %xmm4
mulps %xmm2, %xmm4
mulps %xmm0, %xmm2
shufps $0xe1, %xmm2, %xmm2     # xmm2 = xmm2[1,0,2,3]
addps %xmm4, %xmm2
addps %xmm3, %xmm2
movlps %xmm2, (%rcx)
addq $0x8, %rax
cmpq $0x10, %rax
jne 0x63ea
movss 0x4(%rsp), %xmm0
addss 0x90(%rbx), %xmm0
movss %xmm0, 0x90(%rbx)
callq 0x3150
movss %xmm0, 0x4(%rsp)
movss 0x90(%rbx), %xmm0
callq 0x3180
movss 0x4(%rsp), %xmm1
movss %xmm1, 0x80(%rbx)
movss %xmm0, 0x84(%rbx)
movq %rbx, %rdi
callq 0x5eb8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Ellipse::scale(float, std::pair<float, float> const&)
Ellipse* Ellipse::scale(float rate, const Fpair& ps) {
	float rate2 = rate*rate;
	asq *= rate2; bsq *= rate2;
	scl_pt_pt({&pc0, &pc, &lower, &upper}, ps, rate);
	if(rate < 0) swap(lower, upper);
	return this;
}

// Assembly:
movq %rdi, %rax
movaps %xmm0, %xmm1
mulss %xmm0, %xmm1
movsd 0x88(%rdi), %xmm2
unpcklps %xmm1, %xmm1            # xmm1 = xmm1[0,0,1,1]
mulps %xmm2, %xmm1
movlps %xmm1, 0x88(%rdi)
leaq 0x78(%rdi), %rcx
movq %rcx, -0x20(%rsp)
leaq 0x28(%rdi), %rcx
movq %rcx, -0x18(%rsp)
leaq 0x30(%rdi), %rcx
movq %rcx, -0x10(%rsp)
leaq 0x38(%rdi), %rdx
movq %rdx, -0x8(%rsp)
movss 0x9bb3(%rip), %xmm1     # 0x10070
subss %xmm0, %xmm1
movsd (%rsi), %xmm2
shufps $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
mulps %xmm2, %xmm1
movaps %xmm0, %xmm2
shufps $0x0, %xmm0, %xmm2      # xmm2 = xmm2[0,0],xmm0[0,0]
xorl %edx, %edx
movq -0x20(%rsp,%rdx), %rsi
movsd (%rsi), %xmm3
mulps %xmm2, %xmm3
addps %xmm1, %xmm3
movlps %xmm3, (%rsi)
addq $0x8, %rdx
cmpq $0x20, %rdx
jne 0x64d5
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x6503
movups (%rcx), %xmm0
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movups %xmm0, (%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: EllArc::judge(std::pair<float, float> const&, bool*) const
bool EllArc::judge(const Fpair& pt, bool *val) const {
	bool gov = false;
	if(tlim.first <= TimeNow && TimeNow < tlim.second)
		if(lower <= pt && pt <= upper) {
			float dx = pt.first - pc0.first, dy = pt.second - pc0.second, x = dx*v.first + dy*v.second, y = -dx*v.second + dy*v.first, dist2 = x*x/asq + y*y/bsq, ang;
			if(dist2 < 1 && dist2 >= 1-width) {
				ang = atan2(y, x);
				if(ang >= anglim1 && ang <= anglim2) gov = true;
			}
		}
	if(val!=nullptr) *val = !(gov^solid);
	return gov;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movss 0xe7da(%rip), %xmm0     # 0x151d4
xorl %eax, %eax
ucomiss 0x40(%rdi), %xmm0
jb 0x6af2
movss 0x44(%r14), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x6af2
movss (%rsi), %xmm1
xorl %eax, %eax
ucomiss 0x30(%r14), %xmm1
jb 0x6af2
movss 0x4(%rsi), %xmm0
ucomiss 0x34(%r14), %xmm0
jb 0x6af2
movss 0x38(%r14), %xmm2
xorl %eax, %eax
ucomiss %xmm1, %xmm2
jb 0x6af2
movss 0x3c(%r14), %xmm2
ucomiss %xmm0, %xmm2
jb 0x6af2
subss 0x78(%r14), %xmm1
subss 0x7c(%r14), %xmm0
movaps 0x95a7(%rip), %xmm2     # 0x10010
xorps %xmm1, %xmm2
shufps $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movsd 0x80(%r14), %xmm3
movsd 0x88(%r14), %xmm4
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
mulps %xmm3, %xmm1
shufps $0xe1, %xmm3, %xmm3     # xmm3 = xmm3[1,0,2,3]
mulps %xmm0, %xmm3
addps %xmm3, %xmm1
movaps %xmm1, %xmm2
mulps %xmm1, %xmm2
divps %xmm4, %xmm2
movaps %xmm2, %xmm0
shufps $0x55, %xmm2, %xmm0     # xmm0 = xmm0[1,1],xmm2[1,1]
addss %xmm2, %xmm0
movss 0x95c2(%rip), %xmm2     # 0x10070
ucomiss %xmm0, %xmm2
jbe 0x6ac1
subss 0x98(%r14), %xmm2
ucomiss %xmm2, %xmm0
jae 0x6ac5
xorl %eax, %eax
jmp 0x6af2
movaps %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm0     # xmm0 = xmm0[1,1],xmm1[1,1]
callq 0x3240
movss 0xa0(%r14), %xmm1
movss 0x9c(%r14), %xmm2
cmpleps %xmm0, %xmm2
cmpleps %xmm1, %xmm0
andps %xmm2, %xmm0
movd %xmm0, %eax
testq %rbx, %rbx
je 0x6b06
movl %eax, %ecx
andb $0x1, %cl
cmpb %cl, 0x94(%r14)
sete (%rbx)
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Displace::act(Obj*)
void Displace::act(Obj* p) {
	if(tlim.first < TimeNow && TimeNow < tlim.second) {
		switch(motor_type) {
			case Type::incre:
				p->displace(motor(TimeNow - tlim.first));
				break;
			case Type::relpos:
				state2 = motor(TimeNow - tlim.first);
				p->displace(state2 - state1);
				state1 = state2;
				break;
			case Type::abspos:
				p->place(motor(TimeNow - tlim.first));
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movss 0x8(%rdi), %xmm1
movss 0xe5a4(%rip), %xmm0     # 0x151d4
ucomiss %xmm1, %xmm0
jbe 0x6d25
movq %rdi, %r14
movss 0xc(%rdi), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x6d25
movq %rsi, %rbx
movl 0x30(%r14), %eax
cmpl $0x2, %eax
je 0x6cf2
cmpl $0x1, %eax
je 0x6ca3
testl %eax, %eax
jne 0x6d25
subss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
cmpq $0x0, 0x20(%r14)
je 0x6d2f
leaq 0x10(%r14), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq *0x28(%r14)
movlps %xmm0, (%r15)
movq (%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *0x30(%rax)
jmp 0x6d25
subss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
cmpq $0x0, 0x20(%r14)
je 0x6d2f
leaq 0x10(%r14), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq *0x28(%r14)
movlps %xmm0, 0x3c(%r14)
movsd 0x34(%r14), %xmm1
subps %xmm1, %xmm0
movlps %xmm0, (%r15)
movq (%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *0x30(%rax)
movsd 0x3c(%r14), %xmm0
movsd %xmm0, 0x34(%r14)
jmp 0x6d25
subss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
cmpq $0x0, 0x20(%r14)
je 0x6d2f
leaq 0x10(%r14), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq *0x28(%r14)
movlps %xmm0, (%r15)
movq (%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *0x38(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x30a0
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Rotate::act(Obj*)
void Rotate::act(Obj* p) {
	if(tlim.first < TimeNow && TimeNow < tlim.second) {
		if(motor_type == Type::incre) p->rotate(motor(TimeNow - tlim.first));
		else if(motor_type == Type::relpos) {
			state2 = motor(TimeNow - tlim.first);
			p->rotate(state2 - state1);
			state1 = state2;
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movss 0x8(%rdi), %xmm1
movss 0xe343(%rip), %xmm0     # 0x151d4
ucomiss %xmm1, %xmm0
jbe 0x6f1c
movq %rdi, %r14
movss 0xc(%rdi), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x6f1c
movq %rsi, %rbx
movl 0x30(%r14), %eax
cmpl $0x1, %eax
je 0x6edd
testl %eax, %eax
jne 0x6f1c
subss %xmm1, %xmm0
movss %xmm0, (%rsp)
cmpq $0x0, 0x20(%r14)
je 0x6f24
leaq 0x10(%r14), %rdi
movq %rsp, %rsi
callq *0x28(%r14)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
jmp 0x6f1c
subss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
cmpq $0x0, 0x20(%r14)
je 0x6f24
leaq 0x10(%r14), %rdi
leaq 0x4(%rsp), %rsi
callq *0x28(%r14)
movss %xmm0, 0x38(%r14)
subss 0x34(%r14), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
movss 0x38(%r14), %xmm0
movss %xmm0, 0x34(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x30a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Scale::act(Obj*)
void Scale::act(Obj* p) {
	if(tlim.first < TimeNow && TimeNow < tlim.second) {
		if(motor_type == Type::incre) p->scale(motor(TimeNow - tlim.first));
		else {
			state2 = motor(TimeNow - tlim.first);
			p->scale(state2 / state1);
			state1 = state2;
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movss 0x8(%rdi), %xmm1
movss 0xe189(%rip), %xmm0     # 0x151d4
ucomiss %xmm1, %xmm0
jbe 0x70c8
movq %rdi, %r14
movss 0xc(%rdi), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x70c8
movq %rsi, %rbx
cmpl $0x0, 0x30(%r14)
subss %xmm1, %xmm0
je 0x70a8
movss %xmm0, 0x4(%rsp)
cmpq $0x0, 0x20(%r14)
je 0x70d0
leaq 0x10(%r14), %rdi
leaq 0x4(%rsp), %rsi
callq *0x28(%r14)
movss %xmm0, 0x38(%r14)
divss 0x34(%r14), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
movss 0x38(%r14), %xmm0
movss %xmm0, 0x34(%r14)
jmp 0x70c8
movss %xmm0, (%rsp)
cmpq $0x0, 0x20(%r14)
je 0x70d0
leaq 0x10(%r14), %rdi
movq %rsp, %rsi
callq *0x28(%r14)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x30a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/MITRECND[P]snugglefish/src/snugglefish.cpp
// Function: search(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int, unsigned int)
vector<string>* search(string indexFileName, string searchString, uint32_t ngramSize, uint32_t threads){
	vector<string>* ret;
	nGramSearch searcher(ngramSize, indexFileName, threads);
    vector<uint64_t>* ngrams = searcher.stringToNGrams(searchString);
	ret = searcher.searchNGrams(*ngrams);

    delete ngrams;
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %rbx
leaq -0x70(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %r12
movq %r12, %rdi
callq 0x7096
leaq -0xd0(%rbp), %rdi
movl %r15d, %esi
movq %r12, %rdx
movl %r14d, %ecx
callq 0x7a3e
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0x6a67
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x5290
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x7096
leaq -0xd0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x7bd8
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x6aaa
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x5290
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0x7016
leaq -0xd0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x7ca6
movq %rax, %r14
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x6ade
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x5290
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6af2
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x5290
movl $0x18, %esi
movq %rbx, %rdi
callq 0x5290
leaq -0xd0(%rbp), %rdi
callq 0x7b8e
movq %r14, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x6b6c
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
jmp 0x6b48
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x6b6c
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x5290
jmp 0x6b6c
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0x6b78
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x5290
jmp 0x6b78
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x7b8e
movq %rbx, %rdi
callq 0x54e0
// File: /workspace/github_cpp_makefile_star2_O3/MITRECND[P]snugglefish/src/snugglefish.cpp
// Function: printStats(snugglefish::nGramIndex*, unsigned long, unsigned long)
void printStats(nGramIndex* indexer, uint64_t processed, uint64_t listsize){
    uint64_t total;
    uint64_t session;
    uint64_t indexes;
    bool flushing;
    indexer->getStats(total, session, indexes, flushing);

    uint64_t percent = ((double) processed / listsize) * 100;

    cerr << "\r";
    cerr << "Processed: " << percent << "% -- " << processed << "/" << listsize;

    if(flushing){
        cerr << " (Flushing ... )"; 
    }else{
        cerr << "                "; 
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
leaq -0x48(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x38(%rbp), %rcx
leaq -0x29(%rbp), %r14
movq %r14, %r8
callq 0x8a8a
movq %r15, %xmm0
movq 0x4494(%rip), %xmm1     # 0xb050
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x4498(%rip), %xmm2     # 0xb060
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
movq %rbx, %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
subpd %xmm2, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd %xmm1, %xmm3
mulsd 0x4473(%rip), %xmm3     # 0xb070
cvttsd2si %xmm3, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x4467(%rip), %xmm3     # 0xb078
cvttsd2si %xmm3, %r13
andq %rcx, %r13
orq %rax, %r13
movq 0x83c5(%rip), %r12      # 0xefe8
leaq 0x4a15(%rip), %rsi      # 0xb63f
movl $0x1, %edx
movq %r12, %rdi
callq 0x52c0
leaq 0x4a03(%rip), %rsi      # 0xb641
movl $0xb, %edx
movq %r12, %rdi
callq 0x52c0
movq %r12, %rdi
movq %r13, %rsi
callq 0x5190
movq %rax, %r13
leaq 0x49ed(%rip), %rsi      # 0xb64d
movl $0x5, %edx
movq %rax, %rdi
callq 0x52c0
movq %r13, %rdi
movq %r15, %rsi
callq 0x5190
movq %rax, %r15
leaq 0x49d1(%rip), %rsi      # 0xb653
movl $0x1, %edx
movq %rax, %rdi
callq 0x52c0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5190
leaq 0x49b4(%rip), %rax      # 0xb655
leaq 0x49be(%rip), %rsi      # 0xb666
cmpb $0x0, (%r14)
cmovneq %rax, %rsi
movl $0x10, %edx
movq %r12, %rdi
callq 0x52c0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/MITRECND[P]snugglefish/src/snugglefish.cpp
// Function: indexerThread(void*)
void* indexerThread(void* input){
    mi_data* midata = (mi_data*) input;
    nGramIndex* ngramindex = (nGramIndex*) midata->ngramindex;
    fileIndexer indexer(midata->ngramSize);

    while(1){
        pthread_mutex_lock(& midata->filesMutex);
        if (midata->queue >= midata->fileList->size()){
            pthread_mutex_unlock(& midata->filesMutex);
            break;
        }
        uint32_t i = midata->queue++; 
        pthread_mutex_unlock(& midata->filesMutex); 

        try{
            vector<uint32_t>* processedFile = indexer.processFile((*(midata->fileList))[i].c_str());
            if(processedFile != 0){
                pthread_mutex_lock(& midata->nGramIndexMutex);
                ngramindex->addNGrams(processedFile, (*(midata->fileList))[i]);
                pthread_mutex_unlock(& midata->nGramIndexMutex);
            }
        }catch(exception& e){
            cout << "Error in thread:" << e.what() << endl;
            handler(SIGSEGV);
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq %rax, -0x50(%rbp)
movzbl 0x18(%rdi), %esi
leaq -0x70(%rbp), %rdi
callq 0x8b04
leaq 0x20(%rbx), %r15
movq %r15, %rdi
callq 0x53d0
movl 0x8(%rbx), %r13d
movq (%rbx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x5, %rcx
cmpq %r13, %rcx
jbe 0x6dd1
leaq 0x48(%rbx), %r12
movl %r13d, %eax
incl %eax
movl %eax, 0x8(%rbx)
movq %r15, %rdi
callq 0x5200
movq (%rbx), %rax
movq (%rax), %rax
shlq $0x5, %r13
movq (%rax,%r13), %rsi
leaq -0x70(%rbp), %rdi
callq 0x8b84
movq %rax, %r14
testq %rax, %rax
je 0x6dab
movq %r12, %rdi
callq 0x53d0
movq (%rbx), %rax
movq (%rax), %rax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq (%rax,%r13), %rsi
movq 0x8(%rax,%r13), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x7096
movq -0x50(%rbp), %rdi
movq %r14, %rsi
leaq -0x48(%rbp), %rdx
callq 0x87be
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x6da3
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x5290
movq %r12, %rdi
callq 0x5200
movq %r15, %rdi
callq 0x53d0
movq (%rbx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
movl 0x8(%rbx), %r13d
sarq $0x5, %rcx
movl %r13d, %eax
cmpq %r13, %rcx
ja 0x6d23
movq %r15, %rdi
callq 0x5200
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x6e11
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x5290
jmp 0x6e11
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x6e6c
movq %rbx, %rdi
callq 0x50e0
movq %rax, %rbx
movq 0x8187(%rip), %rdi      # 0xefb0
leaq 0x4847(%rip), %rsi      # 0xb677
movl $0x10, %edx
callq 0x52c0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x8166(%rip), %rdi      # 0xefb0
movq %rax, %rsi
callq 0x5270
movq %rax, %rdi
callq 0x5100
movl $0xb, %edi
callq 0x58e9
movq %rax, %rbx
callq 0x5460
movq %rbx, %rdi
callq 0x54e0
movq %rax, %rdi
callq 0x7007
// File: /workspace/github_cpp_makefile_star2_O3/MITRECND[P]snugglefish/src/nGramSearch.cpp
// Function: snugglefish::nGramSearch::nGramSearch(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
nGramSearch::nGramSearch( uint32_t ngramLength, string indexFileName)
    :nGramBase(ngramLength, indexFileName),numThreads(1) {

    masterFile = new smFile(baseFileName, ngramLength);

    if (!masterFile->exists()){
        //some error
    }else{
        masterFile->open('r');
    }


    numIndexFiles = masterFile->getNumIndexFiles();
    numFiles = masterFile->getNumFiles();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %esi, %r15d
movq %rdi, %rbx
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %r14
movq %r14, %rdi
callq 0x7096
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x7700
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x7947
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x5290
movl $0x1, 0x38(%rbx)
movl $0x58, %edi
callq 0x5280
movq %rax, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x7096
movzbl %r15b, %edx
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0xa240
movq %r14, 0x40(%rbx)
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x79a5
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x5290
movq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0x9aea
testb %al, %al
je 0x79bf
movq 0x40(%rbx), %rdi
movl $0x72, %esi
callq 0xa438
movq 0x40(%rbx), %rax
movl 0x48(%rax), %ecx
movl %ecx, 0x48(%rbx)
movl 0x4c(%rax), %eax
movl %eax, 0x4c(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x79f9
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x5290
jmp 0x79f9
movq %rax, %r15
movl $0x58, %esi
movq %r14, %rdi
callq 0x5290
jmp 0x7a19
movq %rax, %r15
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
jne 0x7a29
jmp 0x7a35
movq %rax, %r15
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
movq %rbx, %r12
cmpq %rbx, %rdi
je 0x7a35
movq (%r12), %rsi
incq %rsi
callq 0x5290
movq %r15, %rdi
callq 0x54e0
nop