LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/pcd.cpp
// Function: PCD::translate(float, float, float)
void PCD::translate(float x, float y, float z) {
	for (int i=0;i<numPoints;i++) {
		float_data[i * 4] += x;
		float_data[i * 4 + 1] += y;
		float_data[i * 4 + 2] += z;
	}
}

// Assembly:
movslq 0x60(%rdi), %rax
testq %rax, %rax
jle 0x5292
movq 0x58(%rdi), %rcx
shlq $0x4, %rax
xorl %edx, %edx
movss (%rcx,%rdx), %xmm3
addss %xmm0, %xmm3
movss %xmm3, (%rcx,%rdx)
movss 0x4(%rcx,%rdx), %xmm3
addss %xmm1, %xmm3
movss %xmm3, 0x4(%rcx,%rdx)
movss 0x8(%rcx,%rdx), %xmm3
addss %xmm2, %xmm3
movss %xmm3, 0x8(%rcx,%rdx)
addq $0x10, %rdx
cmpq %rdx, %rax
jne 0x525b
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/pcd.cpp
// Function: PCD::quaternionMult(PCD::Quaternion, PCD::Quaternion)
PCD::Quaternion PCD::quaternionMult(Quaternion qa, Quaternion qb) {
	Quaternion qc;
	qc.r = qa.r*qb.r - qa.i*qb.i - qa.j*qb.j - qa.k*qb.k;
	qc.i = qa.r*qb.i + qa.i*qb.r + qa.j*qb.k - qa.k*qb.j;
	qc.j = qa.r*qb.j + qa.j*qb.r + qa.k*qb.i - qa.i*qb.k;
	qc.k = qa.r*qb.k + qa.k*qb.r + qa.i*qb.j - qa.j*qb.i;
	return qc;
}

// Assembly:
movaps %xmm0, %xmm4
movaps %xmm0, %xmm6
shufps $0x55, %xmm0, %xmm6     # xmm6 = xmm6[1,1],xmm0[1,1]
movaps %xmm0, %xmm8
mulss %xmm2, %xmm0
movaps %xmm1, %xmm7
shufps $0x55, %xmm1, %xmm7     # xmm7 = xmm7[1,1],xmm1[1,1]
movaps %xmm7, %xmm9
movaps %xmm6, %xmm10
mulss %xmm2, %xmm10
movaps %xmm7, %xmm11
movaps %xmm1, %xmm12
mulss %xmm2, %xmm12
movaps %xmm7, %xmm5
mulss %xmm2, %xmm7
shufps $0x55, %xmm2, %xmm2     # xmm2 = xmm2[1,1,1,1]
movaps %xmm2, %xmm13
mulss %xmm6, %xmm13
subss %xmm13, %xmm0
movaps %xmm3, %xmm13
shufps $0x55, %xmm3, %xmm13    # xmm13 = xmm13[1,1],xmm3[1,1]
mulss %xmm13, %xmm9
movaps %xmm1, %xmm14
mulss %xmm13, %xmm14
movaps %xmm6, %xmm15
mulss %xmm13, %xmm15
mulss %xmm4, %xmm13
mulss %xmm2, %xmm8
mulss %xmm2, %xmm5
mulss %xmm1, %xmm2
mulss %xmm3, %xmm1
subss %xmm1, %xmm0
subss %xmm9, %xmm0
addss %xmm10, %xmm8
addss %xmm8, %xmm14
mulss %xmm3, %xmm11
subss %xmm11, %xmm14
unpcklps %xmm14, %xmm0           # xmm0 = xmm0[0],xmm14[0],xmm0[1],xmm14[1]
mulss %xmm3, %xmm4
addss %xmm12, %xmm4
addss %xmm4, %xmm5
subss %xmm15, %xmm5
addss %xmm7, %xmm13
mulss %xmm3, %xmm6
addss %xmm13, %xmm6
subss %xmm2, %xmm6
unpcklps %xmm6, %xmm5            # xmm5 = xmm5[0],xmm6[0],xmm5[1],xmm6[1]
movaps %xmm5, %xmm1
retq
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/pcd.cpp
// Function: PCD::rotate(PCD::Quaternion)
void PCD::rotate(Quaternion q) {
	for (int i=0;i<numPoints;i++) {
		Quaternion vec = {0, float_data[i*4], float_data[i*4+1], float_data[i*4+2]};
		vec = quaternionMult(quaternionMult(q, vec), quaternionInv(q));
		float_data[i * 4] = vec.i;
		float_data[i * 4 + 1] = vec.j;
		float_data[i * 4 + 2] = vec.k;
	}
}

// Assembly:
movslq 0x60(%rdi), %rax
testq %rax, %rax
jle 0x635a
movq 0x58(%rdi), %rcx
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
movaps 0x51f3(%rip), %xmm3     # 0xb3b0
movaps %xmm2, %xmm4
xorps %xmm3, %xmm4
movaps %xmm1, %xmm5
xorps %xmm3, %xmm5
movaps %xmm1, %xmm10
shufps $0x55, %xmm1, %xmm10    # xmm10 = xmm10[1,1],xmm1[1,1]
xorps %xmm10, %xmm3
xorps %xmm6, %xmm6
movaps %xmm2, %xmm7
mulss %xmm6, %xmm7
movaps %xmm7, -0x18(%rsp)
movaps %xmm1, %xmm9
mulss %xmm6, %xmm9
movaps %xmm10, %xmm8
mulss %xmm6, %xmm8
shlq $0x4, %rax
xorl %edx, %edx
movss (%rcx,%rdx), %xmm11
movss 0x4(%rcx,%rdx), %xmm15
movss 0x8(%rcx,%rdx), %xmm7
movaps %xmm11, %xmm12
mulss %xmm4, %xmm12
movaps %xmm0, %xmm13
mulss 0x51ce(%rip), %xmm13    # 0xb3f4
addss %xmm12, %xmm13
movaps %xmm5, %xmm14
mulss %xmm15, %xmm14
addss %xmm13, %xmm14
movaps %xmm3, %xmm12
mulss %xmm7, %xmm12
addss %xmm14, %xmm12
movaps %xmm0, %xmm13
mulss %xmm11, %xmm13
addss -0x18(%rsp), %xmm13
movaps %xmm1, %xmm14
mulss %xmm7, %xmm14
addss %xmm13, %xmm14
movaps %xmm3, %xmm13
mulss %xmm15, %xmm13
addss %xmm14, %xmm13
movaps %xmm0, %xmm14
mulss %xmm15, %xmm14
addss %xmm9, %xmm14
movaps %xmm10, %xmm6
mulss %xmm11, %xmm6
addss %xmm14, %xmm6
movaps %xmm4, %xmm14
mulss %xmm7, %xmm14
addss %xmm6, %xmm14
mulss %xmm0, %xmm7
addss %xmm8, %xmm7
mulss %xmm2, %xmm15
addss %xmm7, %xmm15
mulss %xmm5, %xmm11
addss %xmm15, %xmm11
movaps %xmm0, %xmm6
mulss %xmm13, %xmm6
movaps %xmm12, %xmm7
mulss %xmm4, %xmm7
addss %xmm6, %xmm7
movaps %xmm14, %xmm6
mulss %xmm3, %xmm6
addss %xmm7, %xmm6
movaps %xmm11, %xmm7
mulss %xmm1, %xmm7
addss %xmm6, %xmm7
movaps %xmm0, %xmm6
mulss %xmm14, %xmm6
movaps %xmm12, %xmm15
mulss %xmm5, %xmm15
addss %xmm6, %xmm15
movaps %xmm0, %xmm6
mulss %xmm11, %xmm6
mulss %xmm4, %xmm11
addss %xmm15, %xmm11
movaps %xmm13, %xmm15
mulss %xmm10, %xmm15
addss %xmm11, %xmm15
mulss %xmm3, %xmm12
addss %xmm6, %xmm12
mulss %xmm5, %xmm13
addss %xmm12, %xmm13
mulss %xmm2, %xmm14
addss %xmm13, %xmm14
movss %xmm7, (%rcx,%rdx)
movss %xmm15, 0x4(%rcx,%rdx)
movss %xmm14, 0x8(%rcx,%rdx)
addq $0x10, %rdx
cmpq %rdx, %rax
jne 0x61fd
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/pcd.cpp
// Function: PCD::getCentroid(std::vector<int, std::allocator<int>>*)
PCD::Quaternion PCD::getCentroid(std::vector<int> *indices) {
	float sumX=0, sumY=0, sumZ=0;
	if (indices) {
		for (size_t i=0;i<indices->size();i++) {
			sumX += float_data[(*indices)[i] * 4];
			sumY += float_data[(*indices)[i] * 4 + 1];
			sumZ += float_data[(*indices)[i] * 4 + 2];
		}
	} else {
		for (int i=0;i<numPoints;i++) {
			sumX += float_data[i * 4];
			sumY += float_data[i * 4 + 1];
			sumZ += float_data[i * 4 + 2];
		}
	}
	Quaternion q = {0, sumX / numPoints, sumY / numPoints, sumZ / numPoints};
	return q;
}

// Assembly:
testq %rsi, %rsi
je 0x63c6
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
je 0x63fe
sarq $0x2, %rcx
movq 0x58(%rdi), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorps %xmm0, %xmm0
xorl %esi, %esi
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movslq (%rax,%rsi,4), %r8
leaq (,%r8,4), %r9
shlq $0x4, %r8
addss (%rdx,%r8), %xmm2
leal 0x1(%r9), %r8d
movslq %r8d, %r8
addss (%rdx,%r8,4), %xmm1
orl $0x2, %r9d
movslq %r9d, %r8
addss (%rdx,%r8,4), %xmm0
incq %rsi
cmpq %rsi, %rcx
jne 0x638c
jmp 0x6407
movslq 0x60(%rdi), %rax
testq %rax, %rax
jle 0x63fe
movq 0x58(%rdi), %rcx
shlq $0x4, %rax
xorps %xmm0, %xmm0
xorl %edx, %edx
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
addss (%rcx,%rdx), %xmm2
addss 0x4(%rcx,%rdx), %xmm1
addss 0x8(%rcx,%rdx), %xmm0
addq $0x10, %rdx
cmpq %rdx, %rax
jne 0x63e2
jmp 0x6407
xorps %xmm2, %xmm2
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
cvtsi2ssl 0x60(%rdi), %xmm3
divss %xmm3, %xmm2
divss %xmm3, %xmm1
divss %xmm3, %xmm0
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movq %xmm2, %xmm0            # xmm0 = xmm2[0],zero
xorps %xmm2, %xmm2
shufps $0xe2, %xmm2, %xmm0     # xmm0 = xmm0[2,0],xmm2[2,3]
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/pcd.cpp
// Function: closestBSearch(void*, void*, int, int, int (*)(void const*, void const*), bool)
void* closestBSearch(void* key,void* base,int num,int size,int (*compar)(const void*,const void*),bool lowerOrUpper) {
	char* A = (char*) base;
	int l = 0, h = num-1, mid=(l+h)/2, diff;
	if (lowerOrUpper) { //lower
		while (l < h) {
			diff = compar(key,A + mid * size);
			if (diff > 0)
				l = mid + 1;
			else if (diff <= 0)
				h = mid;
			mid = (l + h) / 2;
		}
	} else { //upper
		while (l < h - 1) {
			diff = compar(key,A + mid * size);
			if (diff >= 0)
				l = mid;
			else if (diff < 0)
				h = mid - 1;
			mid = (l + h) / 2;
		}
		if (l == h - 1) //edge case
			if (compar(key, A + h * size) >= 0)
				mid++;
	}
	return A + mid * size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl %ecx, 0x4(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
leal -0x1(%rdx), %r13d
movl %r13d, %eax
shrl $0x1f, %eax
leal (%rdx,%rax), %r12d
decl %r12d
sarl %r12d
testl %r9d, %r9d
je 0x733f
cmpl $0x2, %edx
jl 0x73a8
xorl %ebp, %ebp
movl %r12d, %eax
imull 0x4(%rsp), %eax
movslq %eax, %rsi
addq %rbx, %rsi
movq %r15, %rdi
callq *%r14
testl %eax, %eax
jg 0x7320
movl %r12d, %r13d
jmp 0x7326
incl %r12d
movl %r12d, %ebp
leal (%rbp,%r13), %eax
movl %eax, %r12d
shrl $0x1f, %r12d
addl %eax, %r12d
sarl %r12d
cmpl %r13d, %ebp
jl 0x7303
jmp 0x73a8
cmpl $0x3, %edx
jl 0x7385
xorl %ebp, %ebp
movl %r12d, %eax
imull 0x4(%rsp), %eax
movslq %eax, %rsi
addq %rbx, %rsi
movq %r15, %rdi
callq *%r14
testl %eax, %eax
jns 0x7366
decl %r12d
movl %r12d, %r13d
jmp 0x7369
movl %r12d, %ebp
leal (%rbp,%r13), %eax
movl %eax, %r12d
shrl $0x1f, %r12d
addl %eax, %r12d
sarl %r12d
leal -0x1(%r13), %edx
cmpl %edx, %ebp
jl 0x7346
jmp 0x738a
addl $-0x2, %edx
xorl %ebp, %ebp
cmpl %edx, %ebp
jne 0x73a8
imull 0x4(%rsp), %r13d
movslq %r13d, %rsi
addq %rbx, %rsi
movq %r15, %rdi
callq *%r14
notl %eax
shrl $0x1f, %eax
addl %eax, %r12d
imull 0x4(%rsp), %r12d
movslq %r12d, %rax
addq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/kdtree.cpp
// Function: KdTree::buildKdTreeNode(int*, int, int)
KdTree::KdTreeNode* KdTree::buildKdTreeNode(int* pointList, int n, int depth) {
	if (depth > kdtreeDepth)
		kdtreeDepth = depth;
	if (n == 1) //only one point
		return kdtreeLeaves + *pointList; 
	int dimension = depth % 3;

	//find median element
	findMedian(pointList,n,n/2,dimension); //partitions around median
	int medianIndex = n / 2;
	int median = pointList[medianIndex];
	float medianValue = float_data[median * 4 + dimension];
	KdTreeNode* currentNode = (KdTreeNode*) calloc(1,sizeof(KdTreeNode));
	currentNode->value = medianValue;
	kdtreeBranches.push_back(currentNode);

	//partition around median
	int leftSize = medianIndex, *leftPoints = pointList;
	int rightSize = n - leftSize, *rightPoints = pointList + leftSize;
//	printf("n %d i,j %d %d left %d right %d median %d\n",n,i,j,leftSize,rightSize,medianIndex);

	//get left and right children
	if (leftSize > 0)
		currentNode->left = buildKdTreeNode(leftPoints,leftSize,depth+1);
	if (rightSize > 0)
		currentNode->right = buildKdTreeNode(rightPoints,rightSize,depth+1);

//	printf("depth %d left %d right %d median %d %f\n",depth,leftSize,rightSize,medianIndex,medianValue);
	return currentNode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r14d
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
cmpl %ecx, 0x28(%rdi)
jge 0x84ca
movl %r14d, 0x28(%rbx)
cmpl $0x1, %ebp
jne 0x84e2
movslq (%r15), %rax
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq (%rbx), %rax
jmp 0x85d2
movslq %r14d, %rax
imulq $0x55555556, %rax, %rax # imm = 0x55555556
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
addl %ecx, %eax
leal (%rax,%rax,2), %eax
movl %r14d, %r13d
subl %eax, %r13d
movl %ebp, %r12d
shrl $0x1f, %r12d
addl %ebp, %r12d
sarl %r12d
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %r12d, %ecx
movl %r13d, %r8d
callq 0x8644
movslq %r12d, %rax
movq %rax, 0x10(%rsp)
movslq (%r15,%rax,4), %rax
movq 0x30(%rbx), %rcx
movslq %r13d, %rdx
leaq (%rdx,%rax,4), %rax
movss (%rcx,%rax,4), %xmm0
movss %xmm0, 0xc(%rsp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x2120
movq %rax, (%rsp)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x4(%rax)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x8576
movq %rax, (%rsi)
addq $0x8, 0x10(%rbx)
jmp 0x8582
leaq 0x8(%rbx), %rdi
movq %rsp, %rdx
callq 0x8c26
movl %ebp, %r13d
subl %r12d, %r13d
cmpl $0x2, %ebp
jl 0x85a7
leal 0x1(%r14), %ecx
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x84a8
movq (%rsp), %rcx
movq %rax, 0x8(%rcx)
testl %r13d, %r13d
jle 0x85ce
movq 0x10(%rsp), %rax
leaq (%r15,%rax,4), %rsi
incl %r14d
movq %rbx, %rdi
movl %r13d, %edx
movl %r14d, %ecx
callq 0x84a8
movq (%rsp), %rcx
movq %rax, 0x10(%rcx)
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/kdtree.cpp
// Function: KdTree::findMedian(int*, int, int, int)
void KdTree::findMedian(int* pointList, int n, int target, int dimension) {
	if (n < 2) return;
	int pivot_index = rand() % n;
	int pivot = pointList[pivot_index];
	float pivotValue = float_data[pivot * 4 + dimension];
	pointList[pivot_index] = pointList[n-1];
	int i=-1,j=-1,tmp;
	do {
		j++;
		if (float_data[pointList[j] * 4 + dimension] < pivotValue || 
			(float_data[pointList[j] * 4 + dimension] == pivotValue && rand()%2 == 0)) {
			i++;
			tmp = pointList[i];
			pointList[i] = pointList[j];
			pointList[j] = tmp;
		}
	} while (j < n - 2);
	i++;
	pointList[n-1] = pointList[i];
	pointList[i] = pivot;
	if (i == target) return;
	else if (i > target) findMedian(pointList, i , target, dimension);
	else findMedian(pointList + i + 1, n - i - 1, target - i - 1, dimension);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq %r8, 0x8(%rsp)
movslq %r8d, %r12
movl %ecx, (%rsp)
cmpl $0x2, %edx
jl 0x875a
movl %edx, %ebx
callq 0x2080
cltd
idivl %ebx
movslq %edx, %rax
movl (%r14,%rax,4), %esi
movq 0x30(%r15), %rcx
movq 0x8(%rsp), %rdx
movq %rsi, 0x18(%rsp)
leal (%rdx,%rsi,4), %edx
movslq %edx, %rdx
movss (%rcx,%rdx,4), %xmm1
movl %ebx, %ecx
movq %rcx, 0x10(%rsp)
movl -0x4(%r14,%rcx,4), %ecx
movl %ecx, (%r14,%rax,4)
movq %rbx, 0x20(%rsp)
leal -0x2(%rbx), %ebp
incq %rbp
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
xorl %r13d, %r13d
movss %xmm1, 0x4(%rsp)
movq 0x30(%r15), %rax
movslq (%r14,%r13,4), %rcx
leaq (%r12,%rcx,4), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss %xmm0, %xmm1
ja 0x86eb
ucomiss %xmm1, %xmm0
jne 0x8702
jp 0x8702
callq 0x2080
movss 0x4(%rsp), %xmm1
testb $0x1, %al
jne 0x8702
movslq %ebx, %rax
incl %ebx
movl 0x4(%r14,%rax,4), %ecx
movl (%r14,%r13,4), %edx
movl %edx, 0x4(%r14,%rax,4)
movl %ecx, (%r14,%r13,4)
incq %r13
cmpq %r13, %rbp
jne 0x86bf
leal 0x1(%rbx), %edx
movslq %ebx, %rax
movl 0x4(%r14,%rax,4), %ecx
movq 0x10(%rsp), %rsi
movl %ecx, -0x4(%r14,%rsi,4)
movq 0x18(%rsp), %rcx
movl %ecx, 0x4(%r14,%rax,4)
movl (%rsp), %ecx
cmpl %ecx, %edx
movq 0x20(%rsp), %rsi
je 0x875a
cmpl %ecx, %ebx
jge 0x8663
leaq (%r14,%rax,4), %r14
addq $0x4, %r14
addq $0x4, %r14
subl %ebx, %esi
addl $-0x2, %esi
subl %ebx, %ecx
addl $-0x2, %ecx
movl %esi, %edx
jmp 0x8660
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/kdtree.cpp
// Function: KdTree::getBoundingBox()
KdTree::Cube KdTree::getBoundingBox() {
	float minX=float_data[0],maxX=float_data[0];
	float minY=float_data[1],maxY=float_data[1];
	float minZ=float_data[2],maxZ=float_data[2];
	for (int i=1;i<cloud->numPoints;i++) {
		if (float_data[i * 4] < minX) minX = float_data[i * 4];
		else if (float_data[i * 4] > maxX) maxX = float_data[i * 4];
		if (float_data[i * 4 + 1] < minY) minY = float_data[i * 4 + 1];
		else if (float_data[i * 4 + 1] > maxY) maxY = float_data[i * 4 + 1];
		if (float_data[i * 4 + 2] < minZ) minZ = float_data[i * 4 + 2];
		else if (float_data[i * 4 + 2] > maxZ) maxZ = float_data[i * 4 + 2];
	}
	Cube res = {minX, minY, minZ, maxX, maxY, maxZ};
	return res;
}

// Assembly:
movq %rdi, %rax
movq 0x30(%rsi), %rcx
movq 0x38(%rsi), %rdx
movss (%rcx), %xmm0
movss 0x4(%rcx), %xmm1
movss 0x8(%rcx), %xmm5
movslq 0x60(%rdx), %rdx
cmpq $0x2, %rdx
jl 0x8894
shlq $0x4, %rdx
addq $-0x10, %rdx
xorl %esi, %esi
movaps %xmm5, %xmm2
movaps %xmm1, %xmm3
movaps %xmm0, %xmm4
movss 0x10(%rcx,%rsi), %xmm6
ucomiss %xmm6, %xmm4
jbe 0x884e
movaps %xmm6, %xmm4
jmp 0x8856
ucomiss %xmm0, %xmm6
jbe 0x8856
movaps %xmm6, %xmm0
movss 0x14(%rcx,%rsi), %xmm6
ucomiss %xmm6, %xmm3
jbe 0x8866
movaps %xmm6, %xmm3
jmp 0x886e
ucomiss %xmm1, %xmm6
jbe 0x886e
movaps %xmm6, %xmm1
movss 0x18(%rcx,%rsi), %xmm6
ucomiss %xmm6, %xmm2
jbe 0x887e
movaps %xmm6, %xmm2
jmp 0x8883
ucomiss %xmm5, %xmm6
ja 0x8886
movaps %xmm5, %xmm6
addq $0x10, %rsi
movaps %xmm6, %xmm5
cmpq %rsi, %rdx
jne 0x883e
jmp 0x88a0
movaps %xmm0, %xmm4
movaps %xmm1, %xmm3
movaps %xmm5, %xmm2
movaps %xmm5, %xmm6
movss %xmm4, (%rax)
movss %xmm3, 0x4(%rax)
movss %xmm2, 0x8(%rax)
movss %xmm0, 0xc(%rax)
movss %xmm1, 0x10(%rax)
movss %xmm6, 0x14(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/kdtree.cpp
// Function: KdTree::getIndexFromSubTree(KdTree::KdTreeNode*, std::vector<int, std::allocator<int>>*)
void KdTree::getIndexFromSubTree(KdTreeNode* node, std::vector<int> *indices) {
	if (!node) return;
	if (node->isLeaf)
		indices->push_back(node->index);
	else {
		getIndexFromSubTree(node->left,indices);
		getIndexFromSubTree(node->right,indices);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %r14, %r14
je 0x8c0f
cmpb $0x1, (%r14)
je 0x8bf4
movq 0x8(%r14), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x8bc6
movq 0x10(%r14), %r14
jmp 0x8bd4
addq $0x4, %r14
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x8c15
movl (%r14), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x80de
nop
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/descriptor.cpp
// Function: Descriptor::Descriptor(char const*)
Descriptor::Descriptor(const char* filename) {
	FILE* f = fopen(filename,"r");
	if (!f) {
		printf("File not found: %s\n", filename);
		return;
	}
	char buf[256];
	while (fgets(buf, 256, f)) {
		if (sscanf(buf, "POINTS %d", &numPoints) == 1) {
		} else if (sscanf(buf,"COUNT %d",&dimension)==1) {
		} else if (strncmp(buf,"DATA ascii",10)==0) 
			break;
	}
	float val;
	char* c;
	data = new float[numPoints * dimension];
	for (int i=0;i<numPoints;i++) {
		fgets(buf,256,f);
		c = buf;
		for (int j=0;j<dimension;j++) {
			val = strtod(c,&c);
			data[i * dimension + j] = val;
		}
	}
	fclose(f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x2a1a(%rip), %rsi      # 0xb7a4
movq %r15, %rdi
callq 0x2230
testq %rax, %rax
je 0x8ed9
movq %rax, %r14
leaq 0x10(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
movq %rax, %rdx
callq 0x2330
testq %rax, %rax
je 0x8e2e
leaq 0x4(%rbx), %r12
leaq 0x2654(%rip), %r13      # 0xb414
leaq 0x10(%rsp), %rbp
leaq 0x26b4(%rip), %r15      # 0xb480
movq %rbp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x21e0
cmpl $0x1, %eax
je 0x8e19
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x21e0
cmpl $0x1, %eax
je 0x8e19
movq 0x10(%rsp), %rax
movabsq $0x6373612041544144, %rcx # imm = 0x6373612041544144
xorq %rcx, %rax
movzwl 0x18(%rsp), %ecx
xorq $0x6969, %rcx           # imm = 0x6969
orq %rax, %rcx
je 0x8e2e
movq %rbp, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdx
callq 0x2330
testq %rax, %rax
jne 0x8dcc
movslq (%rbx), %rax
movslq 0x4(%rbx), %rcx
imulq %rax, %rcx
movq %rcx, %rax
shlq $0x2, %rax
testl %ecx, %ecx
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2040
movq %rax, 0x8(%rbx)
cmpl $0x0, (%rbx)
jle 0x8ebf
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdx
callq 0x2330
movq %r15, 0x8(%rsp)
cmpl $0x0, 0x4(%rbx)
jle 0x8eb7
movslq %r13d, %rbp
xorl %r15d, %r15d
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x2150
cvtsd2ss %xmm0, %xmm0
movq 0x8(%rbx), %rax
movslq 0x4(%rbx), %rcx
imulq %rbp, %rcx
addq %r15, %rcx
movss %xmm0, (%rax,%rcx,4)
incq %r15
cmpl 0x4(%rbx), %r15d
jl 0x8e89
incl %r13d
cmpl (%rbx), %r13d
jl 0x8e63
movq %r14, %rdi
callq 0x21f0
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2520(%rip), %rdi      # 0xb400
movq %r15, %rsi
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2050
nop
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/descriptor.cpp
// Function: Descriptor::getPCA_XY(double*, double*)
void Descriptor::getPCA_XY(double* lambda_real,double* v) {
	double cov[4] = {}; //column major
	PCD::Quaternion center = pointcloud->getCentroid(NULL);
	for (int j=0;j<pointcloud->numPoints;j++) {
		float deltaP[2] = {
			pointcloud->float_data[j * 4] - center.i,
			pointcloud->float_data[j * 4 + 1] - center.j,
		};
		cov[0] += deltaP[0] * deltaP[0];
		cov[1] += deltaP[1] * deltaP[0];
		cov[2] += deltaP[0] * deltaP[1];
		cov[3] += deltaP[1] * deltaP[1];
	}
	//compute PCA
	double lambda_imag[2];
	Normal::eigenvalue(2,cov,lambda_real,lambda_imag,v);
	//complete 3D structure
	lambda_real[2] = -1;
	v[4] = v[3];
	v[3] = v[2];
	v[2] = v[5] = v[6] = v[7] = 0;
	v[8] = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq 0x10(%rdi), %rdi
xorl %esi, %esi
callq 0x635c
movq 0x10(%r15), %rcx
movslq 0x60(%rcx), %rax
movsd (%rsp), %xmm2
testq %rax, %rax
jle 0x925b
movq 0x58(%rcx), %rcx
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movsd 0x8(%rsp), %xmm5
movsd 0x10(%rsp), %xmm4
movsd 0x18(%rsp), %xmm3
shlq $0x4, %rax
xorl %edx, %edx
movss (%rcx,%rdx), %xmm6
movss 0x4(%rcx,%rdx), %xmm7
subss %xmm0, %xmm6
subss %xmm1, %xmm7
movaps %xmm6, %xmm8
mulss %xmm6, %xmm8
cvtss2sd %xmm8, %xmm8
addsd %xmm8, %xmm2
mulss %xmm7, %xmm6
cvtss2sd %xmm6, %xmm6
addsd %xmm6, %xmm5
addsd %xmm6, %xmm4
mulss %xmm7, %xmm7
xorps %xmm6, %xmm6
cvtss2sd %xmm7, %xmm6
addsd %xmm6, %xmm3
addq $0x10, %rdx
cmpq %rdx, %rax
jne 0x91fb
movsd %xmm5, 0x8(%rsp)
movsd %xmm4, 0x10(%rsp)
movsd %xmm3, 0x18(%rsp)
movq %rsp, %rsi
movsd %xmm2, (%rsi)
leaq 0x20(%rsp), %rcx
movl $0x2, %edi
movq %r14, %rdx
movq %rbx, %r8
callq 0xa08e
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x10(%r14)
movups 0x10(%rbx), %xmm0
movups %xmm0, 0x18(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq %rax, 0x38(%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x40(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/descriptor.cpp
// Function: Descriptor::writeToPCD(char const*)
void Descriptor::writeToPCD(const char* filename) {
	if (!filename)
		return;
	FILE* f = fopen(filename, "w");
	if (!f) {
		printf("Cannot write to file: %s\n", filename);
		return;
	}
	fprintf(f,"# .PCD v0.7 - Point Cloud Data file format\n"
	"VERSION 0.7\n"
	"FIELDS descriptor\n"
	"SIZE 4\n"
	"TYPE F\n"
	"COUNT %d\n"
	"WIDTH %d\n"
	"HEIGHT 1\n"
	"POINTS %d\n"
	"DATA ascii\n",dimension,numPoints,numPoints);
	for (int i=0;i<numPoints;i++) {
		for (int j=0;j<dimension;j++)
			fprintf(f,"%f ",data[i*dimension+j]);
		fprintf(f,"\n");
	}
	fclose(f);
	printf("Wrote %d points to %s\n",numPoints,filename);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x960e
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1f30(%rip), %rsi      # 0xb489
movq %rbx, %rdi
callq 0x2230
testq %rax, %rax
je 0x961d
movq %rax, %r15
movl (%r14), %ecx
movl 0x4(%r14), %edx
leaq 0x23be(%rip), %rsi      # 0xb939
xorl %r13d, %r13d
movq %rax, %rdi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x22a0
cmpl $0x0, (%r14)
jle 0x95e4
leaq 0x1bff(%rip), %r12      # 0xb197
movl 0x4(%r14), %eax
testl %eax, %eax
jle 0x95cf
xorl %ebp, %ebp
movq 0x8(%r14), %rcx
imull %r13d, %eax
cltq
addq %rbp, %rax
xorps %xmm0, %xmm0
cvtss2sd (%rcx,%rax,4), %xmm0
movq %r15, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x22a0
movl 0x4(%r14), %eax
incq %rbp
cmpl %eax, %ebp
jl 0x95a2
movl $0xa, %edi
movq %r15, %rsi
callq 0x2250
incl %r13d
cmpl (%r14), %r13d
jl 0x9598
movq %r15, %rdi
callq 0x21f0
movl (%r14), %esi
leaq 0x1f6c(%rip), %rdi      # 0xb562
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2050
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e67(%rip), %rdi      # 0xb48b
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2050
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/descriptor.cpp
// Function: Descriptor::getPCA(double*, double*)
void Descriptor::getPCA(double* lambda_real,double* v) {
	double cov[9] = {}; //column major
	PCD::Quaternion center = pointcloud->getCentroid(NULL);
	for (int j=0;j<pointcloud->numPoints;j++) {
		float deltaP[3] = {
			pointcloud->float_data[j * 4] - center.i,
			pointcloud->float_data[j * 4 + 1] - center.j,
			pointcloud->float_data[j * 4 + 2] - center.k,
		};
		cov[0] += deltaP[0] * deltaP[0];
		cov[1] += deltaP[1] * deltaP[0];
		cov[2] += deltaP[2] * deltaP[0];
		cov[3] += deltaP[0] * deltaP[1];
		cov[4] += deltaP[1] * deltaP[1];
		cov[5] += deltaP[2] * deltaP[1];
		cov[6] += deltaP[0] * deltaP[2];
		cov[7] += deltaP[1] * deltaP[2];
		cov[8] += deltaP[2] * deltaP[2];
	}
	//compute PCA
	double lambda_imag[3];
	Normal::eigenvalue(3,cov,lambda_real,lambda_imag,v);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq $0x0, 0x40(%rsp)
movq 0x10(%rdi), %rdi
xorl %esi, %esi
callq 0x635c
movq 0x10(%r15), %rcx
movslq 0x60(%rcx), %rax
movsd (%rsp), %xmm2
testq %rax, %rax
jle 0x97b0
movq 0x58(%rcx), %rcx
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3     # xmm3 = xmm3[1,1],xmm1[1,1]
movsd 0x8(%rsp), %xmm11
movsd 0x10(%rsp), %xmm10
movsd 0x18(%rsp), %xmm9
movsd 0x20(%rsp), %xmm8
movsd 0x28(%rsp), %xmm7
movsd 0x30(%rsp), %xmm6
movsd 0x38(%rsp), %xmm5
movsd 0x40(%rsp), %xmm4
shlq $0x4, %rax
xorl %edx, %edx
movss (%rcx,%rdx), %xmm13
movss 0x4(%rcx,%rdx), %xmm14
subss %xmm0, %xmm13
subss %xmm1, %xmm14
movss 0x8(%rcx,%rdx), %xmm12
subss %xmm3, %xmm12
movaps %xmm13, %xmm15
mulss %xmm13, %xmm15
cvtss2sd %xmm15, %xmm15
addsd %xmm15, %xmm2
movaps %xmm13, %xmm15
mulss %xmm14, %xmm15
cvtss2sd %xmm15, %xmm15
addsd %xmm15, %xmm11
mulss %xmm12, %xmm13
cvtss2sd %xmm13, %xmm13
addsd %xmm13, %xmm10
addsd %xmm15, %xmm9
movaps %xmm14, %xmm15
mulss %xmm14, %xmm15
cvtss2sd %xmm15, %xmm15
addsd %xmm15, %xmm8
mulss %xmm12, %xmm14
cvtss2sd %xmm14, %xmm14
addsd %xmm14, %xmm7
addsd %xmm13, %xmm6
addsd %xmm14, %xmm5
mulss %xmm12, %xmm12
cvtss2sd %xmm12, %xmm12
addsd %xmm12, %xmm4
addq $0x10, %rdx
cmpq %rdx, %rax
jne 0x96d7
movsd %xmm11, 0x8(%rsp)
movsd %xmm10, 0x10(%rsp)
movsd %xmm9, 0x18(%rsp)
movsd %xmm8, 0x20(%rsp)
movsd %xmm7, 0x28(%rsp)
movsd %xmm6, 0x30(%rsp)
movsd %xmm5, 0x38(%rsp)
movsd %xmm4, 0x40(%rsp)
movq %rsp, %rsi
movsd %xmm2, (%rsi)
leaq 0x50(%rsp), %rcx
movl $0x3, %edi
movq %r14, %rdx
movq %rbx, %r8
callq 0xa08e
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/normal.cpp
// Function: Normal::eigenvalue(int, double*, double*, double*, double*)
void Normal::eigenvalue(int N,double* A,double* lambda_real,double* lambda_imag,double* v) {

	int info,ldvl=1,ldvr=N,lwork=15*N;	
	double *work = new double[lwork]();
	char jobvl = 'N', jobvr = 'V';
	dgeev_(&jobvl,&jobvr, &N, A, &N, lambda_real, lambda_imag,
	    NULL,&ldvl, v, &ldvr ,work, &lwork, &info);
//	printf("info: %d\n",info);
//	printf("optimal: %f\n",work[0]);
	if (info!=0) {
		printf("Error in subroutine dgeev_ (info=%d)\n",info);
	}
	delete[] work;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, %r12
movq %rsi, %r13
leaq 0x34(%rsp), %rbp
movl %edi, (%rbp)
leaq 0x14(%rsp), %rax
movl $0x1, (%rax)
leaq 0x10(%rsp), %rax
movl %edi, (%rax)
leal (%rdi,%rdi,4), %eax
leal (%rax,%rax,2), %eax
leaq 0x2c(%rsp), %r14
movl %eax, (%r14)
cltq
shlq $0x3, %rax
testl %edi, %edi
movq $-0x1, %rbx
cmovnsq %rax, %rbx
movq %rbx, %rdi
callq 0x2040
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x2100
leaq 0xf(%rsp), %rdi
movb $0x4e, (%rdi)
leaq 0xe(%rsp), %rsi
movb $0x56, (%rsi)
leaq 0x30(%rsp), %rbx
movq %rbp, %rdx
movq %r13, %rcx
movq %rbp, %r8
movq %r12, %r9
pushq %rbx
pushq %r14
pushq %r15
leaq 0x28(%rsp), %rax
pushq %rax
pushq 0x38(%rsp)
leaq 0x3c(%rsp), %rax
pushq %rax
pushq $0x0
pushq 0x58(%rsp)
callq 0x2140
addq $0x40, %rsp
movl (%rbx), %esi
testl %esi, %esi
je 0xa158
leaq 0x1870(%rip), %rdi      # 0xb9c1
xorl %eax, %eax
callq 0x2050
movq %r15, %rdi
callq 0x2260
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/normal.cpp
// Function: Normal::svd(int, int, double*, double*, double*, double*)
void Normal::svd(int M,int N,double* A,double *U, double* S, double* VT) {

	int info, lwork=5*(M>N?N:M);
	double* work = new double[lwork];
	char jobu = 'A', jobvt = 'A';
	dgesvd_(&jobu, &jobvt, &M, &N, A, &M, 
	     S, U, &M, VT, &N, work, &lwork, &info);
//	printf("info: %d\n",info);
//	printf("optimal: %f\n",work[0]);
	if (info!=0) {
		printf("Error in subroutine dgesvd_ (info=%d)\n",info);
	}
	delete[] work;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, %rbx
leaq 0x34(%rsp), %r13
movl %edi, (%r13)
leaq 0x30(%rsp), %rbp
movl %esi, (%rbp)
cmpl %esi, %edi
cmovll %edi, %esi
leal (%rsi,%rsi,4), %eax
leaq 0x28(%rsp), %r14
movl %eax, (%r14)
cltq
shlq $0x3, %rax
testl %esi, %esi
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2040
movq %rax, %r12
movb $0x41, %al
leaq 0xf(%rsp), %rdi
movb %al, (%rdi)
leaq 0xe(%rsp), %rsi
movb %al, (%rsi)
leaq 0x2c(%rsp), %r15
movq %r13, %rdx
movq %rbp, %rcx
movq %rbx, %r8
movq %r13, %r9
pushq %r15
pushq %r14
pushq %r12
pushq %rbp
pushq 0x30(%rsp)
pushq %r13
pushq 0x48(%rsp)
pushq 0x58(%rsp)
callq 0x22e0
addq $0x40, %rsp
movl (%r15), %esi
testl %esi, %esi
je 0xa244
leaq 0x17aa(%rip), %rdi      # 0xb9e7
xorl %eax, %eax
callq 0x2050
movq %r12, %rdi
callq 0x2260
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/hashtable.cpp
// Function: HashTable::HashTable()
HashTable::HashTable() {
	//claims a section of the heap to be used as dummy variable
	this->dummy = (int*)malloc(sizeof(int));
	this->keys = (int*)malloc(INITIAL_TABLE_SIZE*sizeof(int));
	this->entries = (void**)malloc(INITIAL_TABLE_SIZE*sizeof(void*));
	this->size = INITIAL_TABLE_SIZE;
	this->load = 0;
	int i;
	for (i = 0; i < this->size; i++) {
		this->keys[i] = -1;
	}
	memset(this->entries,'\0',this->size*sizeof(void*));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x4, %edi
callq 0x2270
movq %rax, (%rbx)
movslq 0x4fb5(%rip), %r12      # 0xf230
leaq (,%r12,4), %rdi
callq 0x2270
movq %rax, %r15
movq %rax, 0x8(%rbx)
leaq (,%r12,8), %rdi
callq 0x2270
movq %rax, %r14
movq %rax, 0x10(%rbx)
movl %r12d, 0x18(%rbx)
movl $0x0, 0x1c(%rbx)
testq %r12, %r12
jle 0xa2d5
movl 0x18(%rbx), %r12d
cmpl $0x2, %r12d
movl $0x1, %edx
cmovgel %r12d, %edx
shlq $0x2, %rdx
movq %r15, %rdi
movl $0xff, %esi
callq 0x2100
movslq %r12d, %rdx
shlq $0x3, %rdx
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/hashtable.cpp
// Function: HashTable::insert(int, void*)
bool HashTable::insert(int intKey, void* entry) {
	int h = baseHash(this->size, intKey);
	int step = stepHash(this->size, intKey);
	int i;
	for (i = 0; i < this->size; i++) {
		//printf("key: %d hash: %d\n", intKey, h);
		if (!this->entries[h] || this->entries[h] == this->dummy) {
			this->keys[h] = intKey;
			this->entries[h] = entry;
			this->load++;
			if (this->load>this->size / 4) {
				//printf("current load: %u/%u\n", this->load, this->size);
				doubleSize();
			}
			return true;
		}
		else if (this->keys[h] == intKey){
			return false;
		}
		else {
			h += step;
			h %= this->size;
		}
	}
	printf("Table overload (HashTable)!\n");
	return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x18(%rdi), %r8d
testl %r8d, %r8d
jle 0xa39d
movq %rdx, %rcx
cvtsi2sd %r8d, %xmm0
cvtsi2sd %esi, %xmm1
movsd 0x4ef5(%rip), %xmm2     # 0xf228
mulsd %xmm1, %xmm2
cvttpd2dq %xmm2, %xmm3
cvtdq2pd %xmm3, %xmm3
subsd %xmm3, %xmm2
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %r9d
orl $0x1, %r9d
mulsd 0x4ec8(%rip), %xmm1     # 0xf220
cvttpd2dq %xmm1, %xmm2
cvtdq2pd %xmm2, %xmm2
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
movq 0x10(%rdi), %r10
movq (%rdi), %r11
movq 0x8(%rdi), %rbx
movl %r8d, %ebp
movslq %edx, %rax
movq (%r10,%rax,8), %r14
testq %r14, %r14
je 0xa3b2
cmpq %r11, %r14
je 0xa3b2
cmpl %esi, (%rbx,%rax,4)
je 0xa3a9
addl %r9d, %edx
movl %edx, %eax
cltd
idivl %r8d
decl %ebp
jne 0xa37a
leaq 0x1696(%rip), %rdi      # 0xba3a
callq 0x2310
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%rdi), %rdx
movl %esi, (%rdx,%rax,4)
movq %rcx, (%r10,%rax,8)
movl 0x18(%rdi), %eax
movl 0x1c(%rdi), %ecx
leal 0x1(%rcx), %edx
leal 0x3(%rax), %esi
testl %eax, %eax
cmovnsl %eax, %esi
movl %edx, 0x1c(%rdi)
sarl $0x2, %esi
movb $0x1, %bl
cmpl %esi, %ecx
jl 0xa3ab
callq 0xa430
jmp 0xa3ab
nop
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/hashtable.cpp
// Function: HashTable::doubleSize()
void HashTable::doubleSize() {
	//printf("Now doubling size of hash table\n");
	int newSize = this->size*2;
	int* newKeys = (int*)malloc(newSize * sizeof(int));
	void** newEntries = (void**)malloc(newSize*sizeof(void*));
	//printf("malloc double HashTable: %d\n",newSize * sizeof(int)+sizeof(void*));
	int* oldKeys = this->keys;
	void** oldEntries = this->entries;
	int oldSize = this->size;
	if (!newEntries||!newKeys) {
		printf("Warning(HashTable): Unable to resize table!\n");
		return;
	}
	this->keys = newKeys;
	this->entries = newEntries;
	this->size =newSize;
	this->load = 0;
	int i;
	for (i = 0; i < this->size; i++) {
		this->keys[i] = -1;
	}
	memset(this->entries,'\0',this->size*sizeof(void*));
	for (i = 0; i < oldSize; i++) {
		if (oldEntries[i] && oldEntries[i] != this->dummy)
			insert(oldKeys[i], oldEntries[i]);
	}
	free(oldKeys);
	free(oldEntries);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x18(%rdi), %rbp
leaq (,%rbp,8), %rdi
callq 0x2270
movq %rax, %r13
movq %rbp, %rdi
shlq $0x4, %rdi
callq 0x2270
movq %rax, %r12
testq %rax, %rax
setne %al
testq %r13, %r13
setne %cl
testb %al, %cl
je 0xa514
leal (,%rbp,2), %eax
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %r14
movq %r13, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movl %eax, 0x18(%rbx)
movl $0x0, 0x1c(%rbx)
testl %ebp, %ebp
jle 0xa4bc
cmpl $0x2, %eax
movl $0x1, %edx
cmovgel %eax, %edx
shlq $0x2, %rdx
movq %r13, %rdi
movl $0xff, %esi
movl %eax, %r13d
callq 0x2100
movl %r13d, %eax
movslq %eax, %rdx
shlq $0x3, %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x2100
testl %ebp, %ebp
jle 0xa4f6
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdx
testq %rdx, %rdx
je 0xa4ee
cmpq (%rbx), %rdx
je 0xa4ee
movl (%r15,%r12,4), %esi
movq %rbx, %rdi
callq 0xa312
incq %r12
cmpq %r12, %rbp
jne 0xa4d4
movq %r15, %rdi
callq 0x2240
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2240
leaq 0x14f3(%rip), %rdi      # 0xba0e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2310
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/hashtable.cpp
// Function: HashTable::find(int)
void* HashTable::find(int intKey) {
	int h = baseHash(this->size, intKey);
	int step = stepHash(this->size, intKey);
	int i;
	for (i = 0; i < this->size; i++) {
		//printf("key: %d hash: %d\n", intKey, h);
		if (!this->entries[h]) {
			return NULL;
		}
		else if (this->keys[h] == intKey){
			return this->entries[h];
		}
		else {
			h += step;
			h %= this->size;
		}
	}
	printf("Table overload (HashTable)!\n");
	return NULL;
}

// Assembly:
pushq %rax
movl 0x18(%rdi), %ecx
testl %ecx, %ecx
jle 0xa5a9
cvtsi2sd %ecx, %xmm0
cvtsi2sd %esi, %xmm1
movsd 0x4ce2(%rip), %xmm2     # 0xf228
mulsd %xmm1, %xmm2
cvttpd2dq %xmm2, %xmm3
cvtdq2pd %xmm3, %xmm3
subsd %xmm3, %xmm2
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %r8d
mulsd 0x4cb9(%rip), %xmm1     # 0xf220
cvttpd2dq %xmm1, %xmm2
cvtdq2pd %xmm2, %xmm2
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
orl $0x1, %r8d
movq 0x8(%rdi), %r9
movq 0x10(%rdi), %rdi
movl %ecx, %r10d
movslq %edx, %r11
movq (%rdi,%r11,8), %rax
testq %rax, %rax
je 0xa5b5
cmpl %esi, (%r9,%r11,4)
je 0xa5b7
addl %r8d, %edx
movl %edx, %eax
cltd
idivl %ecx
decl %r10d
jne 0xa58a
leaq 0x148a(%rip), %rdi      # 0xba3a
callq 0x2310
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/hashtable.cpp
// Function: HashTable::remove(int)
void* HashTable::remove(int intKey) {
	int h = baseHash(this->size, intKey);
	int step = stepHash(this->size, intKey);
	int i;
	void* removedItem;
	for (i = 0; i < this->size; i++) {
		//printf("key: %d hash: %d\n", intKey, h);
		if (!this->entries[h]) {
			return NULL;
		}
		else if (this->entries[h]!=this->dummy && this->keys[h] == intKey ){
			this->keys[h] = -1;
			removedItem = this->entries[h];
			this->entries[h] = this->dummy;
			this->load--;
			return removedItem;
		}
		else {
			h += step;
			h %= this->size;
		}
	}
	printf("Table overload (HashTable)!\n");
	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x18(%rdi), %ecx
testl %ecx, %ecx
jle 0xa63e
cvtsi2sd %ecx, %xmm0
cvtsi2sd %esi, %xmm1
movsd 0x4c53(%rip), %xmm2     # 0xf228
mulsd %xmm1, %xmm2
cvttpd2dq %xmm2, %xmm3
cvtdq2pd %xmm3, %xmm3
subsd %xmm3, %xmm2
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %r8d
orl $0x1, %r8d
mulsd 0x4c26(%rip), %xmm1     # 0xf220
cvttpd2dq %xmm1, %xmm2
cvtdq2pd %xmm2, %xmm2
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
movq 0x10(%rdi), %r9
movq (%rdi), %r10
movq 0x8(%rdi), %r11
movl %ecx, %ebx
movslq %edx, %r14
movq (%r9,%r14,8), %rax
testq %rax, %rax
je 0xa64a
cmpq %r10, %rax
je 0xa632
cmpl %esi, (%r11,%r14,4)
je 0xa654
addl %r8d, %edx
movl %edx, %eax
cltd
idivl %ecx
decl %ebx
jne 0xa61b
leaq 0x13f5(%rip), %rdi      # 0xba3a
callq 0x2310
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xffffffff, (%r11,%r14,4) # imm = 0xFFFFFFFF
movq %r10, (%r9,%r14,8)
decl 0x1c(%rdi)
jmp 0xa64c
nop
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/hashtable.cpp
// Function: HashTable::insert(void*, int, void*)
int HashTable::getIntKey(char* inputString, int len) {
	//djb2 algorithm http://www.cse.yorku.ca/~oz/hash.html
	int h = STRING_HASH_CONSTANT;
	for (int i=0;i<len;i++) {
		unsigned int c = *inputString++;
		h = (h << 5) + h + c;
	}
	if (h<0) h=-h;
	return h;
}

// Assembly:
movl 0x4bab(%rip), %r9d      # 0xf218
testl %edx, %edx
jle 0xa694
movl %edx, %edx
xorl %r8d, %r8d
movl %r9d, %eax
movsbl (%rsi,%r8), %r10d
shll $0x5, %eax
addl %r9d, %eax
addl %r10d, %eax
incq %r8
movl %eax, %r9d
cmpl %r8d, %edx
jne 0xa679
jmp 0xa697
movl %r9d, %eax
movl %eax, %esi
negl %esi
cmovsl %eax, %esi
movq %rcx, %rdx
jmp 0xa312
// File: /workspace/github_cpp_makefile_star2_O1/yukioc[P]tscrpt/tscrpt.cpp
// Function: obj_t::value()
int obj_t::value(){
	switch(type){
		case 'N': break;
		case 'S': num=(int)strtol(_str.c_str(),NULL,0); break;
		default: assert(0);
	}
	return num;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzbl (%rdi), %eax
cmpl $0x4e, %eax
je 0x263d
cmpl $0x53, %eax
jne 0x2642
movq 0x8(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21a0
movl %eax, 0x28(%rbx)
movl 0x28(%rbx), %eax
popq %rbx
retq
leaq 0x51ec(%rip), %rdi      # 0x7835
leaq 0x4d7a(%rip), %rsi      # 0x73ca
leaq 0x49d9(%rip), %rcx      # 0x7030
movl $0x20, %edx
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/yukioc[P]tscrpt/tscrpt.cpp
// Function: obj_t::str[abi:cxx11]()
std::string& obj_t::str(){
	switch(type){
		case 'N': _str=itos(num); break;
		case 'S': break;
		case '$': _str='$'; break;
		default: assert(0); break;
	}
	return _str;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
movzbl (%rdi), %eax
cmpl $0x24, %eax
je 0x2702
cmpl $0x53, %eax
je 0x271c
cmpl $0x4e, %eax
jne 0x272f
movl 0x28(%rbx), %ebp
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x2180
movq %r14, %rdi
movl %ebp, %esi
callq 0x2230
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x21e0
movq 0x790a(%rip), %rsi      # 0x9fc8
leaq 0x28(%rsp), %rdi
callq 0x20f0
leaq 0x98(%rsp), %rdi
callq 0x20a0
leaq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x2170
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x271c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
jmp 0x271c
leaq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rdx
movl $0x1, %ecx
xorl %esi, %esi
movl $0x24, %r8d
callq 0x2260
addq $0x8, %rbx
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x50ff(%rip), %rdi      # 0x7835
leaq 0x4c8d(%rip), %rsi      # 0x73ca
leaq 0x48ff(%rip), %rcx      # 0x7043
movl $0x29, %edx
callq 0x2100
movq %rax, %rbx
movq 0x7870(%rip), %rsi      # 0x9fc8
leaq 0x28(%rsp), %rdi
callq 0x20f0
leaq 0x98(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::eval(char const*)
obj_t* tscrpt_t::eval(const char* s) {
	std::list<obj_t*> objs;
	scan(&objs,s);
	obj_t* o=parse(&objs);
	return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rdx
movq %rdi, %r15
leaq 0x8(%rsp), %rbx
movq %rbx, 0x8(%rbx)
movq %rbx, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rsi
callq 0x2882
leaq 0x8(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x2cd4
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2849
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x2150
movq %rbx, %rdi
cmpq %r14, %rbx
jne 0x2834
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2858
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x287a
movq (%rdi), %r15
movl $0x18, %esi
callq 0x2150
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x2865
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::parse(std::__cxx11::list<obj_t*, std::allocator<obj_t*>>*)
obj_t* tscrpt_t::parse(std::list<obj_t*>* olist) {
	if(olist==0) throw std::logic_error("parse: received obj is null");
	assert(objs==0);
	objs=olist;
	obj_t* ret=0;
	while(more() && !is('$')){
		delete ret;
		ret=expr();
	}
	assert(objs->empty());
	objs=0;
	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x2d6b
movq %rdi, %rbx
cmpq $0x0, (%rdi)
jne 0x2d9d
movq %rsi, (%rbx)
cmpq %rsi, (%rsi)
je 0x2d4e
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x24, %esi
movl $0x1, %edx
callq 0x3006
testb %al, %al
jne 0x2d51
testq %r14, %r14
je 0x2d39
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x2d2c
movq (%rax), %rsi
incq %rsi
callq 0x2150
movl $0x30, %esi
movq %r14, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x30be
movq %rax, %r14
movq (%rbx), %rax
cmpq %rax, (%rax)
jne 0x2cf9
jmp 0x2d51
xorl %r14d, %r14d
movq (%rbx), %rax
cmpq %rax, (%rax)
jne 0x2dbc
movq $0x0, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x438c(%rip), %rsi      # 0x710b
movq %rax, %rdi
callq 0x21b0
movq 0x7252(%rip), %rsi      # 0x9fe0
movq 0x723b(%rip), %rdx      # 0x9fd0
movq %rbx, %rdi
callq 0x2220
leaq 0x4383(%rip), %rdi      # 0x7127
leaq 0x461f(%rip), %rsi      # 0x73ca
leaq 0x437d(%rip), %rcx      # 0x712f
movl $0x67, %edx
callq 0x2100
leaq 0x4399(%rip), %rdi      # 0x715c
leaq 0x4600(%rip), %rsi      # 0x73ca
leaq 0x435e(%rip), %rcx      # 0x712f
movl $0x6e, %edx
callq 0x2100
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::is(char, bool)
bool tscrpt_t::is(char c,bool eat) {
	if (objs->empty()) throw std::runtime_error( "is: not found next token" );
	obj_t* o=objs->front();
	bool chk(c==o->type);
	if (eat && chk){
		objs->pop_front();
		delete o;
	}
	return chk;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq (%rax), %r15
cmpq %rax, %r15
je 0x3079
movl %esi, %ebx
movq 0x10(%r15), %r14
movb (%r14), %bpl
testb %dl, %dl
je 0x3068
cmpb %bl, %bpl
jne 0x3068
decq 0x10(%rax)
movq %r15, %rdi
callq 0x2200
movl $0x18, %esi
movq %r15, %rdi
callq 0x2150
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x305b
movq (%rax), %rsi
incq %rsi
callq 0x2150
movl $0x30, %esi
movq %r14, %rdi
callq 0x2150
cmpb %bl, %bpl
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x40f7(%rip), %rsi      # 0x7184
movq %rax, %rdi
callq 0x20b0
movq 0x6f5c(%rip), %rsi      # 0x9ff8
movq 0x6f1d(%rip), %rdx      # 0x9fc0
movq %rbx, %rdi
callq 0x2220
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::expr()
obj_t* tscrpt_t::expr() {
	obj_t *o=term();
	while(more()){ // add,sub
		obj_t *l(0),*r(0);
		if     (is('+')){ o=add(l=o, r=term()); }
		else if(is('-')){ o=sub(l=o, r=term()); }
		else break;
		delete l;
		delete r;
	}
	return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x329a
movq %rax, %r14
movq (%rbx), %rax
cmpq %rax, (%rax)
je 0x31a5
movq %rbx, %rdi
movl $0x2b, %esi
movl $0x1, %edx
callq 0x3006
movq %rbx, %rdi
testb %al, %al
je 0x310b
callq 0x329a
movq %rax, %r12
movq %r14, %rsi
movq %rax, %rdx
callq 0x343a
jmp 0x3134
movl $0x2d, %esi
movl $0x1, %edx
callq 0x3006
testb %al, %al
je 0x3192
movq %rbx, %rdi
callq 0x329a
movq %rax, %r12
movq %r14, %rsi
movq %rax, %rdx
callq 0x35a4
movq %rax, %r15
testq %r14, %r14
je 0x3161
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x3154
movq (%rax), %rsi
incq %rsi
callq 0x2150
movl $0x30, %esi
movq %r14, %rdi
callq 0x2150
movb $0x1, %bpl
testq %r12, %r12
je 0x3197
movq 0x8(%r12), %rdi
leaq 0x18(%r12), %rax
cmpq %rax, %rdi
je 0x3183
movq (%rax), %rsi
incq %rsi
callq 0x2150
movl $0x30, %esi
movq %r12, %rdi
callq 0x2150
jmp 0x3197
xorl %ebp, %ebp
movq %r14, %r15
movq %r15, %r14
testb %bpl, %bpl
jne 0x30d1
jmp 0x31a8
movq %r14, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::obj()
obj_t* tscrpt_t::obj() {
	if (objs->empty()) throw std::runtime_error( "obj: not found next token" );
	obj_t* o(objs->front());
	objs->pop_front();
	return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq (%rax), %rbx
cmpq %rax, %rbx
je 0x31eb
movq 0x10(%rbx), %r14
decq 0x10(%rax)
movq %rbx, %rdi
callq 0x2200
movl $0x18, %esi
movq %rbx, %rdi
callq 0x2150
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x3f6b(%rip), %rsi      # 0x716a
movq %rax, %rdi
callq 0x20b0
movq 0x6dea(%rip), %rsi      # 0x9ff8
movq 0x6dab(%rip), %rdx      # 0x9fc0
movq %rbx, %rdi
callq 0x2220
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2240