LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
movlpd %xmm0, -0x20(%rbp)
movlpd %xmm1, -0x18(%rbp)
movlpd %xmm2, -0x30(%rbp)
movlpd %xmm3, -0x28(%rbp)
movq %rdi, -0x38(%rbp)
movss -0x20(%rbp), %xmm0
movss -0x1c(%rbp), %xmm1
movss -0x30(%rbp), %xmm2
movss -0x2c(%rbp), %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
subss %xmm1, %xmm0
movss -0x18(%rbp), %xmm1
movss -0x28(%rbp), %xmm2
mulss %xmm2, %xmm1
subss %xmm1, %xmm0
movss -0x14(%rbp), %xmm1
movss -0x24(%rbp), %xmm2
mulss %xmm2, %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x30(%rbp), %xmm3
movss -0x2c(%rbp), %xmm2
movss -0x20(%rbp), %xmm1
movss -0x1c(%rbp), %xmm0
mulss %xmm3, %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss -0x18(%rbp), %xmm0
movss -0x24(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x14(%rbp), %xmm1
movss -0x28(%rbp), %xmm2
mulss %xmm2, %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x28(%rbp), %xmm4
movss -0x18(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
movss -0x2c(%rbp), %xmm3
mulss %xmm1, %xmm0
movss -0x20(%rbp), %xmm2
movss -0x1c(%rbp), %xmm1
mulss %xmm4, %xmm2
addss %xmm0, %xmm2
movss -0x14(%rbp), %xmm0
mulss %xmm3, %xmm0
addss %xmm2, %xmm0
movss -0x24(%rbp), %xmm2
mulss %xmm2, %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x24(%rbp), %xmm4
movss -0x14(%rbp), %xmm3
movss -0x30(%rbp), %xmm0
movss -0x2c(%rbp), %xmm2
mulss %xmm0, %xmm3
movss -0x20(%rbp), %xmm1
movss -0x1c(%rbp), %xmm0
mulss %xmm4, %xmm1
addss %xmm3, %xmm1
movss -0x28(%rbp), %xmm3
mulss %xmm3, %xmm0
addss %xmm1, %xmm0
movss -0x18(%rbp), %xmm1
mulss %xmm2, %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
popq %rbp
retq
nopl (%rax)
// File: jingdao[P]PointCloudApp/pcd.cpp
// Function: PCD::quaternionInv(PCD::Quaternion)
PCD::Quaternion PCD::quaternionInv(Quaternion q) {
	Quaternion qc;
	qc.r = q.r;
	qc.i = -q.i;
	qc.j = -q.j;
	qc.k = -q.k;
	return qc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movlpd %xmm0, -0x20(%rbp)
movlpd %xmm1, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x1c(%rbp), %xmm0
movaps 0xab68(%rip), %xmm1     # 0x13390
pxor %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x18(%rbp), %xmm0
pxor %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x14(%rbp), %xmm0
pxor %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x98(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x60(%rcx), %eax
jge 0x89f1
movq -0x98(%rbp), %rdi
movl $0x0, -0x2c(%rbp)
movq 0x58(%rdi), %rax
movl -0x1c(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x28(%rbp)
movq 0x58(%rdi), %rax
movl -0x1c(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movss 0x4(%rax,%rcx,4), %xmm0
movss %xmm0, -0x24(%rbp)
movq 0x58(%rdi), %rax
movl -0x1c(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movss 0x8(%rax,%rcx,4), %xmm0
movss %xmm0, -0x20(%rbp)
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0x60(%rbp)
movups -0x2c(%rbp), %xmm0
movaps %xmm0, -0x70(%rbp)
movsd -0x60(%rbp), %xmm0
movsd -0x58(%rbp), %xmm1
movsd -0x70(%rbp), %xmm2
movsd -0x68(%rbp), %xmm3
callq 0x86b0
movq -0x98(%rbp), %rdi
movlpd %xmm0, -0x4c(%rbp)
movlpd %xmm1, -0x44(%rbp)
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0x90(%rbp)
movsd -0x90(%rbp), %xmm0
movsd -0x88(%rbp), %xmm1
callq 0x8800
movq -0x98(%rbp), %rdi
movlpd %xmm0, -0x80(%rbp)
movlpd %xmm1, -0x78(%rbp)
movsd -0x4c(%rbp), %xmm0
movsd -0x44(%rbp), %xmm1
movsd -0x80(%rbp), %xmm2
movsd -0x78(%rbp), %xmm3
callq 0x86b0
movq -0x98(%rbp), %rax
movlpd %xmm0, -0x3c(%rbp)
movlpd %xmm1, -0x34(%rbp)
movq -0x3c(%rbp), %rcx
movq %rcx, -0x2c(%rbp)
movq -0x34(%rbp), %rcx
movq %rcx, -0x24(%rbp)
movss -0x28(%rbp), %xmm0
movq 0x58(%rax), %rcx
movl -0x1c(%rbp), %edx
shll $0x2, %edx
movslq %edx, %rdx
movss %xmm0, (%rcx,%rdx,4)
movss -0x24(%rbp), %xmm0
movq 0x58(%rax), %rcx
movl -0x1c(%rbp), %edx
shll $0x2, %edx
addl $0x1, %edx
movslq %edx, %rdx
movss %xmm0, (%rcx,%rdx,4)
movss -0x20(%rbp), %xmm0
movq 0x58(%rax), %rax
movl -0x1c(%rbp), %ecx
shll $0x2, %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x888b
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jingdao[P]PointCloudApp/pcd.cpp
// Function: compare(void const*, void const*)
int compare(const void* v1,const void* v2) {
	Ind* i1 = (Ind*) v1;
	Ind* i2 = (Ind*) v2;
	if (i1->val < i2->val)
		return -1;
	else if (i1->val > i2->val)
		return 1;
	else
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movss (%rax), %xmm1
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x9e6a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9e8b
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
movq -0x28(%rbp), %rax
ucomiss (%rax), %xmm0
jbe 0x9e84
movl $0x1, -0x4(%rbp)
jmp 0x9e8b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x3c(%rbp)
testb $0x1, -0x21(%rbp)
je 0x9f40
jmp 0x9ee3
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x9f3b
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x3c(%rbp), %ecx
imull -0x18(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rsi
callq *%rax
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jle 0x9f1a
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x9f28
cmpl $0x0, -0x40(%rbp)
jg 0x9f26
movl -0x3c(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x9f28
movl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x3c(%rbp)
jmp 0x9ee3
jmp 0x9fd9
jmp 0x9f42
movl -0x34(%rbp), %eax
movl -0x38(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x9f9f
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x3c(%rbp), %ecx
imull -0x18(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rsi
callq *%rax
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jl 0x9f7b
movl -0x3c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x9f8c
cmpl $0x0, -0x40(%rbp)
jge 0x9f8a
movl -0x3c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x9f8c
movl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x3c(%rbp)
jmp 0x9f42
movl -0x34(%rbp), %eax
movl -0x38(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x9fd7
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x38(%rbp), %ecx
imull -0x18(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rsi
callq *%rax
cmpl $0x0, %eax
jl 0x9fd5
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x9fd7
jmp 0x9fd9
movq -0x30(%rbp), %rax
movl -0x3c(%rbp), %ecx
imull -0x18(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x40, %rsp
popq %rbp
retq
// File: jingdao[P]PointCloudApp/kdtree.cpp
// Function: KdTree::KdTree(PCD*)
KdTree::KdTree(PCD* pointcloud) {
	if (!pointcloud || pointcloud->numPoints == 0)
		return;
	kdtreeLeaves = (KdTreeNode*) calloc(pointcloud->numPoints, sizeof(KdTreeNode));
	int* pointList = (int*) malloc(pointcloud->numPoints * sizeof(int));
	for (int i=0;i<pointcloud->numPoints;i++) {
		pointList[i] = i;
		kdtreeLeaves[i].index = i;
		kdtreeLeaves[i].isLeaf = true;
	}
	this->kdtreeDepth = 0;
	this->float_data = pointcloud->float_data;
	this->cloud = pointcloud;
	kdtreeRoot = buildKdTreeNode(pointList,pointcloud->numPoints,0);
	free(pointList);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0xebf0
cmpq $0x0, -0x10(%rbp)
je 0xdec6
movq -0x10(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0xdecb
jmp 0xdf9d
movq -0x10(%rbp), %rax
movslq 0x60(%rax), %rdi
movl $0x18, %esi
callq 0x2120
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movslq 0x60(%rax), %rdi
shlq $0x2, %rdi
callq 0x2260
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jge 0xdf51
movq -0x40(%rbp), %rax
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movl %esi, (%rcx,%rdx,4)
movl -0x1c(%rbp), %edx
movq (%rax), %rcx
movslq -0x1c(%rbp), %rsi
imulq $0x18, %rsi, %rsi
addq %rsi, %rcx
movl %edx, 0x4(%rcx)
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movb $0x1, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xdf03
movq -0x40(%rbp), %rdi
movl $0x0, 0x28(%rdi)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x30(%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x38(%rdi)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x60(%rax), %edx
xorl %ecx, %ecx
callq 0xdfd0
movq %rax, -0x48(%rbp)
jmp 0xdf88
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rdi
callq 0x2240
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xec10
movq -0x28(%rbp), %rdi
callq 0x2380
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xeb95
jmp 0xebdb
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0xebb1
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0xae30
jmp 0xebdb
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xeb70
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xeb70
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x140(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x4123(%rip), %rsi      # 0x1378c
callq 0x2230
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xf690
movq -0x10(%rbp), %rsi
leaq 0x3d2c(%rip), %rdi      # 0x133b0
movb $0x0, %al
callq 0x2050
jmp 0xf835
jmp 0xf692
leaq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x2300
cmpq $0x0, %rax
je 0xf71f
movq -0x140(%rbp), %rdx
leaq -0x120(%rbp), %rdi
leaq 0x3d02(%rip), %rsi      # 0x133c4
movb $0x0, %al
callq 0x21e0
cmpl $0x1, %eax
jne 0xf6d0
jmp 0xf71a
movq -0x140(%rbp), %rdx
leaq -0x120(%rbp), %rdi
addq $0x4, %rdx
leaq 0x3d7f(%rip), %rsi      # 0x13468
movb $0x0, %al
callq 0x21e0
cmpl $0x1, %eax
jne 0xf6f7
jmp 0xf718
leaq -0x120(%rbp), %rdi
leaq 0x3ce8(%rip), %rsi      # 0x133ed
movl $0xa, %edx
callq 0x20d0
cmpl $0x0, %eax
jne 0xf716
jmp 0xf71f
jmp 0xf718
jmp 0xf71a
jmp 0xf692
movq -0x140(%rbp), %rcx
movl (%rcx), %eax
imull 0x4(%rcx), %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2040
movq %rax, %rcx
movq -0x140(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x134(%rbp)
movq -0x140(%rbp), %rcx
movl -0x134(%rbp), %eax
cmpl (%rcx), %eax
jge 0xf82c
leaq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x2300
leaq -0x120(%rbp), %rax
movq %rax, -0x130(%rbp)
movl $0x0, -0x138(%rbp)
movq -0x140(%rbp), %rcx
movl -0x138(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0xf816
movq -0x130(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x2150
movq -0x140(%rbp), %rdx
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x124(%rbp)
movss -0x124(%rbp), %xmm0
movq 0x8(%rdx), %rax
movl -0x134(%rbp), %ecx
imull 0x4(%rdx), %ecx
addl -0x138(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x138(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x138(%rbp)
jmp 0xf7a9
jmp 0xf818
movl -0x134(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x134(%rbp)
jmp 0xf767
movq -0x18(%rbp), %rdi
callq 0x21f0
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movq 0x10(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8a00
movlpd %xmm0, -0x50(%rbp)
movlpd %xmm1, -0x48(%rbp)
movl $0x0, -0x54(%rbp)
movq -0x78(%rbp), %rcx
movl -0x54(%rbp), %eax
movq 0x10(%rcx), %rcx
cmpl 0x60(%rcx), %eax
jge 0xfd11
movq -0x78(%rbp), %rax
movq 0x10(%rax), %rcx
movq 0x58(%rcx), %rcx
movl -0x54(%rbp), %edx
shll $0x2, %edx
movslq %edx, %rdx
movss (%rcx,%rdx,4), %xmm0
subss -0x4c(%rbp), %xmm0
movss %xmm0, -0x5c(%rbp)
movq 0x10(%rax), %rax
movq 0x58(%rax), %rax
movl -0x54(%rbp), %ecx
shll $0x2, %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
subss -0x48(%rbp), %xmm0
movss %xmm0, -0x58(%rbp)
movss -0x5c(%rbp), %xmm0
mulss -0x5c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movss -0x58(%rbp), %xmm0
mulss -0x5c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movss -0x5c(%rbp), %xmm0
mulss -0x58(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movss -0x58(%rbp), %xmm0
mulss -0x58(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0xfc48
leaq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x70(%rbp), %rcx
movq -0x18(%rbp), %r8
movl $0x2, %edi
callq 0x11cd0
movq -0x10(%rbp), %rax
movsd 0x3ba9(%rip), %xmm0     # 0x138e0
movsd %xmm0, 0x10(%rax)
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x18(%rbp), %rax
movsd 0x34bc(%rip), %xmm0     # 0x13258
movsd %xmm0, 0x40(%rax)
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x10314
jmp 0x10402
movq -0x10(%rbp), %rdi
leaq 0x3152(%rip), %rsi      # 0x13471
callq 0x2230
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x10346
movq -0x10(%rbp), %rsi
leaq 0x3139(%rip), %rdi      # 0x13473
movb $0x0, %al
callq 0x2050
jmp 0x10402
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
movl 0x4(%rax), %edx
movl (%rax), %ecx
movl (%rax), %r8d
leaq 0x3598(%rip), %rsi      # 0x138f5
movb $0x0, %al
callq 0x2280
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x103e1
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x103c4
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rdi
movq 0x8(%rdx), %rax
movl -0x1c(%rbp), %ecx
imull 0x4(%rdx), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x2db5(%rip), %rsi      # 0x13167
movb $0x1, %al
callq 0x2280
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1037d
movq -0x18(%rbp), %rdi
leaq 0x3616(%rip), %rsi      # 0x139e5
movb $0x0, %al
callq 0x2280
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1036b
movq -0x18(%rbp), %rdi
callq 0x21f0
movq -0x28(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rdx
leaq 0x314f(%rip), %rdi      # 0x1354a
movb $0x0, %al
callq 0x2050
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movl %edi, -0x24(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
movq %r8, -0x48(%rbp)
movl $0x1, -0x50(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x54(%rbp)
imull $0xf, -0x24(%rbp), %eax
movl %eax, -0x58(%rbp)
movslq -0x58(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, -0x78(%rbp)
callq 0x2040
movq -0x78(%rbp), %rdx
movq %rax, %rdi
movq %rdi, -0x70(%rbp)
xorl %esi, %esi
callq 0x2100
movq -0x70(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x4e, -0x61(%rbp)
movb $0x56, -0x62(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r9
movq -0x40(%rbp), %r12
movq -0x48(%rbp), %r14
movq -0x60(%rbp), %r11
leaq -0x61(%rbp), %rdi
leaq -0x62(%rbp), %rsi
leaq -0x24(%rbp), %r8
xorl %eax, %eax
leaq -0x50(%rbp), %r15
leaq -0x54(%rbp), %rbx
leaq -0x58(%rbp), %r10
leaq -0x4c(%rbp), %rax
movq %r8, %rdx
movq %r12, (%rsp)
movq $0x0, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq %r14, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movq %r11, 0x28(%rsp)
movq %r10, 0x30(%rsp)
movq %rax, 0x38(%rsp)
callq 0x2140
cmpl $0x0, -0x4c(%rbp)
je 0x11dd0
movl -0x4c(%rbp), %esi
leaq 0x1bb4(%rip), %rdi      # 0x1397d
movb $0x0, %al
callq 0x2050
movq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x11de7
movq -0x80(%rbp), %rdi
callq 0x2250
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edi, -0x2c(%rbp)
movl %esi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
movq %r8, -0x48(%rbp)
movq %r9, -0x50(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jle 0x11eaa
movl -0x30(%rbp), %eax
movl %eax, -0x68(%rbp)
jmp 0x11eb0
movl -0x2c(%rbp), %eax
movl %eax, -0x68(%rbp)
movl -0x68(%rbp), %eax
imull $0x5, %eax, %eax
movl %eax, -0x58(%rbp)
movslq -0x58(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2040
movq %rax, -0x60(%rbp)
movb $0x41, -0x61(%rbp)
movb $0x41, -0x62(%rbp)
movq -0x38(%rbp), %r8
movq -0x48(%rbp), %r13
movq -0x40(%rbp), %r12
movq -0x50(%rbp), %r14
movq -0x60(%rbp), %r11
leaq -0x61(%rbp), %rdi
leaq -0x62(%rbp), %rsi
leaq -0x2c(%rbp), %r15
leaq -0x30(%rbp), %rbx
leaq -0x58(%rbp), %r10
leaq -0x54(%rbp), %rax
movq %r15, %rdx
movq %rbx, %rcx
movq %r15, %r9
movq %r13, (%rsp)
movq %r12, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq %r14, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movq %r11, 0x28(%rsp)
movq %r10, 0x30(%rsp)
movq %rax, 0x38(%rsp)
callq 0x22c0
cmpl $0x0, -0x54(%rbp)
je 0x11f62
movl -0x54(%rbp), %esi
leaq 0x1a48(%rip), %rdi      # 0x139a3
movb $0x0, %al
callq 0x2050
movq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x11f79
movq -0x70(%rbp), %rdi
callq 0x2250
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x4, %edi
callq 0x2260
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movslq 0x8259(%rip), %rdi      # 0x1a218
shlq $0x2, %rdi
callq 0x2260
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movslq 0x823e(%rip), %rdi      # 0x1a218
shlq $0x3, %rdi
callq 0x2260
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl 0x8224(%rip), %ecx      # 0x1a218
movl %ecx, 0x18(%rax)
movl $0x0, 0x1c(%rax)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x1202f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x12005
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movslq 0x18(%rax), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x2100
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl 0x18(%rdi), %esi
movl -0x14(%rbp), %edx
callq 0x121c0
movq -0x38(%rbp), %rdi
movl %eax, -0x24(%rbp)
movl 0x18(%rdi), %esi
movl -0x14(%rbp), %edx
callq 0x12230
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x121a3
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1210a
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rax
movslq -0x24(%rbp), %rdx
movq (%rax,%rdx,8), %rax
cmpq (%rcx), %rax
jne 0x1215e
movq -0x38(%rbp), %rax
movl -0x14(%rbp), %esi
movq 0x8(%rax), %rcx
movslq -0x24(%rbp), %rdx
movl %esi, (%rcx,%rdx,4)
movq -0x20(%rbp), %rsi
movq 0x10(%rax), %rcx
movslq -0x24(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movl 0x1c(%rax), %ecx
movl %ecx, -0x3c(%rbp)
movl 0x18(%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jle 0x12158
movq -0x38(%rbp), %rdi
callq 0x122c0
movb $0x1, -0x1(%rbp)
jmp 0x121b5
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x12178
movb $0x0, -0x1(%rbp)
jmp 0x121b5
movq -0x38(%rbp), %rax
movl -0x28(%rbp), %ecx
addl -0x24(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movl 0x18(%rax), %ecx
movl -0x24(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0x24(%rbp)
jmp 0x12193
jmp 0x12195
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x120d2
leaq 0x1820(%rip), %rdi      # 0x139ca
movb $0x0, %al
callq 0x2050
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl 0x18(%rax), %eax
shll %eax
movl %eax, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
callq 0x2260
movq %rax, -0x18(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
callq 0x2260
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x30(%rbp)
movl 0x18(%rax), %eax
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12329
cmpq $0x0, -0x18(%rbp)
jne 0x1233c
leaq 0x16b7(%rip), %rdi      # 0x139e7
movb $0x0, %al
callq 0x2050
jmp 0x12417
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x18(%rax)
movl $0x0, 0x1c(%rax)
movl $0x0, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movl -0x38(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x1238e
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x38(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x12364
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rdi
movslq 0x18(%rax), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x2100
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x12405
movq -0x30(%rbp), %rax
movslq -0x38(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x123f8
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movslq -0x38(%rbp), %rdx
movq (%rax,%rdx,8), %rax
cmpq (%rcx), %rax
je 0x123f8
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movq -0x30(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x12090
jmp 0x123fa
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x123ac
movq -0x28(%rbp), %rdi
callq 0x2240
movq -0x30(%rbp), %rdi
callq 0x2240
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl 0x18(%rdi), %esi
movl -0x14(%rbp), %edx
callq 0x121c0
movq -0x28(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl 0x18(%rdi), %esi
movl -0x14(%rbp), %edx
callq 0x12230
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x124d9
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x12487
movq $0x0, -0x8(%rbp)
jmp 0x124ef
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x124b1
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x124ef
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x18(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movl 0x18(%rax), %ecx
movl -0x18(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
jmp 0x124cc
jmp 0x124ce
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1245e
leaq 0x14ea(%rip), %rdi      # 0x139ca
movb $0x0, %al
callq 0x2050
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl 0x18(%rdi), %esi
movl -0x14(%rbp), %edx
callq 0x121c0
movq -0x30(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl 0x18(%rdi), %esi
movl -0x14(%rbp), %edx
callq 0x12230
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x12607
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1256e
movq $0x0, -0x8(%rbp)
jmp 0x1261d
movq -0x30(%rbp), %rcx
movq 0x10(%rcx), %rax
movslq -0x18(%rbp), %rdx
movq (%rax,%rdx,8), %rax
cmpq (%rcx), %rax
je 0x125dc
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x125dc
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x18(%rbp), %rdx
movl $0xffffffff, (%rcx,%rdx,4) # imm = 0xFFFFFFFF
movq 0x10(%rax), %rcx
movslq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, -0x28(%rbp)
movq (%rax), %rsi
movq 0x10(%rax), %rcx
movslq -0x18(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movl 0x1c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1c(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1261d
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x18(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movl 0x18(%rax), %ecx
movl -0x18(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
jmp 0x125f7
jmp 0x125f9
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1253e
leaq 0x13bc(%rip), %rdi      # 0x139ca
movb $0x0, %al
callq 0x2050
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jingdao[P]PointCloudApp/hashtable.cpp
// Function: HashTable::getIntKey(char*, int)
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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl 0x7b6b(%rip), %eax      # 0x1a200
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x126d6
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
shll $0x5, %eax
addl -0x18(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1269f
cmpl $0x0, -0x18(%rbp)
jge 0x126e4
xorl %eax, %eax
subl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x4e, %eax
je 0x24ab
jmp 0x24a1
movl -0xc(%rbp), %eax
subl $0x53, %eax
je 0x24ad
jmp 0x24d4
jmp 0x24f3
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x20e0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x22a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
jmp 0x24f3
leaq 0x848c(%rip), %rdi      # 0xa967
leaq 0x801a(%rip), %rsi      # 0xa4fc
movl $0x20, %edx
leaq 0x7c72(%rip), %rcx      # 0xa160
callq 0x2140
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x24, %eax
je 0x2563
jmp 0x2521
movl -0x2c(%rbp), %eax
subl $0x4e, %eax
je 0x2535
jmp 0x252b
movl -0x2c(%rbp), %eax
subl $0x53, %eax
je 0x2561
jmp 0x2577
movq -0x38(%rbp), %rax
movl 0x28(%rax), %esi
leaq -0x28(%rbp), %rdi
callq 0x4190
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
leaq -0x28(%rbp), %rsi
callq 0x2250
leaq -0x28(%rbp), %rdi
callq 0x2130
jmp 0x2596
jmp 0x2596
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movl $0x24, %esi
callq 0x2300
jmp 0x2596
leaq 0x83e9(%rip), %rdi      # 0xa967
leaq 0x7f77(%rip), %rsi      # 0xa4fc
movl $0x29, %edx
leaq 0x7be2(%rip), %rcx      # 0xa173
callq 0x2140
movq -0x38(%rbp), %rax
addq $0x8, %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4250
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2700
jmp 0x26a8
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2ce0
movq %rax, -0x58(%rbp)
jmp 0x26bb
movq -0x58(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4270
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4270
movq -0x30(%rbp), %rdi
callq 0x2330
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2d52
movl $0x10, %edi
callq 0x2120
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x7551(%rip), %rsi      # 0xa26b
callq 0x22b0
jmp 0x2d21
movq -0x38(%rbp), %rdi
movq 0xb2b4(%rip), %rsi      # 0xdfe0
movq 0xb29d(%rip), %rdx      # 0xdfd0
callq 0x2310
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2170
jmp 0x2e44
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2d5e
jmp 0x2d7d
leaq 0x7522(%rip), %rdi      # 0xa287
leaq 0x7790(%rip), %rsi      # 0xa4fc
movl $0x67, %edx
leaq 0x7517(%rip), %rcx      # 0xa28f
callq 0x2140
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3160
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x39(%rbp)
jne 0x2da7
jmp 0x2dbf
movq -0x30(%rbp), %rdi
movl $0x24, %esi
movl $0x1, %edx
callq 0x3190
xorb $-0x1, %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x2dc8
jmp 0x2dfc
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x2ded
movq -0x48(%rbp), %rdi
callq 0x4480
movq -0x48(%rbp), %rdi
movl $0x30, %esi
callq 0x21d0
movq -0x30(%rbp), %rdi
callq 0x3290
movq %rax, -0x28(%rbp)
jmp 0x2d90
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x44a0
testb $0x1, %al
jne 0x2e0e
jmp 0x2e10
jmp 0x2e2f
leaq 0x74a5(%rip), %rdi      # 0xa2bc
leaq 0x76de(%rip), %rsi      # 0xa4fc
movl $0x6e, %edx
leaq 0x7465(%rip), %rcx      # 0xa28f
callq 0x2140
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2330
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq (%rax), %rdi
callq 0x44a0
testb $0x1, %al
jne 0x31bf
jmp 0x320f
movl $0x10, %edi
callq 0x2120
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x710a(%rip), %rsi      # 0xa2e4
callq 0x20c0
jmp 0x31e1
movq -0x40(%rbp), %rdi
movq 0xae0c(%rip), %rsi      # 0xdff8
movq 0xadd5(%rip), %rdx      # 0xdfc8
callq 0x2310
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2170
jmp 0x3281
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x44c0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movsbl -0x9(%rbp), %eax
movq -0x28(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x29(%rbp)
testb $0x1, -0xa(%rbp)
je 0x3276
testb $0x1, -0x29(%rbp)
je 0x3276
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x44f0
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x3274
movq -0x48(%rbp), %rdi
callq 0x4480
movq -0x48(%rbp), %rdi
movl $0x30, %esi
callq 0x21d0
jmp 0x3276
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2330
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x3530
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3160
testb $0x1, %al
jne 0x32bf
jmp 0x33b2
movq -0x28(%rbp), %rdi
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x2b, %esi
movl $0x1, %edx
callq 0x3190
testb $0x1, %al
jne 0x32e8
jmp 0x3317
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x18(%rbp)
callq 0x3530
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
movq %rdx, -0x20(%rbp)
callq 0x37f0
movq %rax, -0x10(%rbp)
jmp 0x3363
movq -0x28(%rbp), %rdi
movl $0x2d, %esi
movl $0x1, %edx
callq 0x3190
testb $0x1, %al
jne 0x3330
jmp 0x335f
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rax, -0x18(%rbp)
callq 0x3530
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
movq %rdx, -0x20(%rbp)
callq 0x39d0
movq %rax, -0x10(%rbp)
jmp 0x3361
jmp 0x33b2
jmp 0x3363
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x3388
movq -0x40(%rbp), %rdi
callq 0x4480
movq -0x40(%rbp), %rdi
movl $0x30, %esi
callq 0x21d0
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x33ad
movq -0x48(%rbp), %rdi
callq 0x4480
movq -0x48(%rbp), %rdi
movl $0x30, %esi
callq 0x21d0
jmp 0x32ad
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rdi
callq 0x44a0
testb $0x1, %al
jne 0x33e2
jmp 0x3432
movl $0x10, %edi
callq 0x2120
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x6ecd(%rip), %rsi      # 0xa2ca
callq 0x20c0
jmp 0x3404
movq -0x30(%rbp), %rdi
movq 0xabe9(%rip), %rsi      # 0xdff8
movq 0xabb2(%rip), %rdx      # 0xdfc8
callq 0x2310
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x2170
jmp 0x345e
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x44c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rdi
callq 0x44f0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x2330
nopw (%rax,%rax)
// File: yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::add(obj_t*, obj_t*)
obj_t* tscrpt_t::add(obj_t* l, obj_t* r) {
	obj_t* o(0);
	verbose(VTRACE,"parse: %s+%s\n",l->str().c_str(), r->str().c_str());
	if(l->type=='N'){
		o = new obj_t('N', l->value() + r->value());
	}else if(l->type=='S'){
		o = new obj_t('S', l->str() + r->str());
	}else assert(0);
	return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpl $0x9, 0xa9ba(%rip)      # 0xe1d0
jl 0x3853
movq -0x10(%rbp), %rdi
callq 0x2500
movq %rax, %rdi
callq 0x20e0
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2500
movq %rax, %rdi
callq 0x20e0
movq -0x60(%rbp), %rsi
movq %rax, %rdx
leaq 0x6af9(%rip), %rdi      # 0xa345
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4e, %eax
jne 0x38c7
movl $0x30, %edi
callq 0x21c0
movq %rax, -0x68(%rbp)
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2480
movl %eax, -0x6c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2480
movl -0x6c(%rbp), %edx
movq -0x68(%rbp), %rdi
addl %eax, %edx
movl $0x4e, %esi
callq 0x42d0
jmp 0x389b
movq -0x78(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x39b3
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x30, %esi
callq 0x21d0
jmp 0x39c0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x53, %eax
jne 0x3992
movl $0x30, %edi
callq 0x21c0
movq %rax, -0x88(%rbp)
movb $0x1, -0x51(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2500
movq %rax, -0x80(%rbp)
jmp 0x38fb
movq -0x18(%rbp), %rdi
callq 0x2500
movq %rax, -0x90(%rbp)
jmp 0x390d
movq -0x90(%rbp), %rdx
movq -0x80(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x4520
jmp 0x3923
movq -0x88(%rbp), %rdi
movl $0x53, %esi
leaq -0x50(%rbp), %rdx
callq 0x45a0
jmp 0x393a
movq -0x88(%rbp), %rax
movb $0x0, -0x51(%rbp)
movq %rax, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2130
jmp 0x39b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x3977
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2130
testb $0x1, -0x51(%rbp)
jne 0x397f
jmp 0x3990
movq -0x88(%rbp), %rdi
movl $0x30, %esi
callq 0x21d0
jmp 0x39c0
leaq 0x6fce(%rip), %rdi      # 0xa967
leaq 0x6b5c(%rip), %rsi      # 0xa4fc
movl $0xcd, %edx
leaq 0x69a7(%rip), %rcx      # 0xa353
callq 0x2140
jmp 0x39b3
movq -0x20(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2330
nopl (%rax)