LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
cmpl %ecx, 0x28(%rdi)
jge 0x76cf
movl %ebx, 0x28(%r14)
cmpl $0x1, %ebp
jne 0x76e3
movslq (%r15), %rax
imulq $0x18, %rax, %rax
addq (%r14), %rax
jmp 0x77a4
pushq $0x3
popq %rcx
movl %ebx, %eax
cltd
idivl %ecx
movl %edx, %r13d
pushq $0x2
popq %rcx
movl %ebp, %eax
cltd
idivl %ecx
movl %eax, %r12d
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %eax, %ecx
movl %r13d, %r8d
callq 0x77fa
movslq %r12d, %rax
movq %rax, 0x10(%rsp)
movslq (%r15,%rax,4), %rax
movq 0x30(%r14), %rcx
movslq %r13d, %rdx
leaq (%rdx,%rax,4), %rax
movss (%rcx,%rax,4), %xmm0
movss %xmm0, 0xc(%rsp)
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x2120
movq %rsp, %rsi
movq %rax, (%rsi)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x4(%rax)
leaq 0x8(%r14), %rdi
callq 0x7d4c
movl %ebp, %r13d
subl %r12d, %r13d
cmpl $0x2, %ebp
jl 0x7776
leal 0x1(%rbx), %ecx
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x76ae
movq (%rsp), %rcx
movq %rax, 0x8(%rcx)
testl %r13d, %r13d
jle 0x77a0
movq 0x10(%rsp), %rax
leaq (%r15,%rax,4), %rsi
incl %ebx
movq %r14, %rdi
movl %r13d, %edx
movl %ebx, %ecx
callq 0x76ae
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x77a4
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_O2/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
movl %r8d, %ebx
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %r15
movl %ecx, 0xc(%rsp)
cmpl $0x2, %r12d
jl 0x7919
callq 0x2080
cltd
idivl %r12d
movslq %edx, %rax
movl (%r14,%rax,4), %edx
movq 0x30(%r15), %rcx
movq %rdx, 0x20(%rsp)
leal (%rbx,%rdx,4), %edx
movslq %edx, %rdx
movss (%rcx,%rdx,4), %xmm1
movl %r12d, %ecx
movq %rcx, 0x18(%rsp)
movl -0x4(%r14,%rcx,4), %ecx
movl %ecx, (%r14,%rax,4)
movl %r12d, %eax
addl $-0x2, %eax
movq %rax, 0x10(%rsp)
leaq 0x1(%rax), %r12
xorl %r13d, %r13d
pushq $-0x1
popq %rbp
movss %xmm1, 0x8(%rsp)
movq 0x30(%r15), %rcx
movl (%r14,%r13,4), %eax
leal (%rbx,%rax,4), %edx
movslq %edx, %rdx
movss (%rcx,%rdx,4), %xmm0
ucomiss %xmm0, %xmm1
ja 0x78a4
ucomiss %xmm1, %xmm0
jne 0x78b7
jp 0x78b7
callq 0x2080
testb $0x1, %al
jne 0x78c1
movl (%r14,%r13,4), %eax
movss 0x8(%rsp), %xmm1
movslq %ebp, %rcx
incl %ebp
movl 0x4(%r14,%rcx,4), %edx
movl %eax, 0x4(%r14,%rcx,4)
movl %edx, (%r14,%r13,4)
incq %r13
cmpq %r13, %r12
jne 0x7872
jmp 0x78c9
movss 0x8(%rsp), %xmm1
jmp 0x78b7
movslq %ebp, %rax
leal 0x1(%rax), %r12d
movl 0x4(%r14,%rax,4), %ecx
movq 0x18(%rsp), %rdx
movl %ecx, -0x4(%r14,%rdx,4)
movq 0x20(%rsp), %rcx
movl %ecx, 0x4(%r14,%rax,4)
movl 0xc(%rsp), %ecx
cmpl %ecx, %r12d
je 0x7919
cmpl %ecx, %ebp
jge 0x7818
incq %rax
leaq (%r14,%rax,4), %r14
addq $0x4, %r14
movq 0x10(%rsp), %rax
subl %ebp, %eax
subl %ebp, %ecx
addl $-0x2, %ecx
movl %eax, %r12d
jmp 0x7814
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %xmm2
movslq 0x60(%rdx), %rdx
addq $0x18, %rcx
pushq $0x1
popq %rsi
movaps %xmm0, %xmm3
movaps %xmm1, %xmm4
movaps %xmm2, %xmm5
cmpq %rdx, %rsi
jge 0x7a30
movss -0x8(%rcx), %xmm6
ucomiss %xmm6, %xmm0
jbe 0x79ef
movaps %xmm6, %xmm0
jmp 0x79f7
ucomiss %xmm3, %xmm6
jbe 0x79f7
movaps %xmm6, %xmm3
movss -0x4(%rcx), %xmm6
ucomiss %xmm6, %xmm1
jbe 0x7a06
movaps %xmm6, %xmm1
jmp 0x7a0e
ucomiss %xmm4, %xmm6
jbe 0x7a0e
movaps %xmm6, %xmm4
movss (%rcx), %xmm6
ucomiss %xmm6, %xmm2
jbe 0x7a1c
movaps %xmm6, %xmm2
jmp 0x7a21
ucomiss %xmm5, %xmm6
ja 0x7a24
movaps %xmm5, %xmm6
incq %rsi
addq $0x10, %rcx
movaps %xmm6, %xmm5
jmp 0x79db
movss %xmm0, (%rax)
movss %xmm1, 0x4(%rax)
movss %xmm2, 0x8(%rax)
movss %xmm3, 0xc(%rax)
movss %xmm4, 0x10(%rax)
movss %xmm5, 0x14(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7d32
cmpb $0x1, (%r14)
je 0x7d38
movq 0x8(%r14), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x7d04
movq 0x10(%r14), %r14
jmp 0x7d12
popq %rbx
popq %r14
popq %r15
retq
addq $0x4, %r14
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6d04
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2912(%rip), %rsi      # 0xa81c
movq %r15, %rdi
callq 0x2240
testq %rax, %rax
je 0x8033
movq %rax, %r14
leaq 0x4(%rbx), %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %r12
leaq 0x255a(%rip), %r13      # 0xa48c
leaq 0x25bf(%rip), %rbp      # 0xa4f8
leaq 0x2575(%rip), %r15      # 0xa4b5
movq %r12, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdx
callq 0x2340
testq %rax, %rax
je 0x7f92
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x21e0
cmpl $0x1, %eax
je 0x7f40
movq %r12, %rdi
movq %rbp, %rsi
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x21e0
cmpl $0x1, %eax
je 0x7f40
movq %r12, %rdi
movq %r15, %rsi
pushq $0xa
popq %rdx
callq 0x2220
testl %eax, %eax
jne 0x7f40
movslq (%rbx), %r15
movslq 0x4(%rbx), %rax
imulq %r15, %rax
movq %rax, %rcx
shlq $0x2, %rcx
testl %eax, %eax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x2040
movq %rax, 0x8(%rbx)
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
cmpl %r15d, %ebp
jge 0x8019
movq %r12, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdx
callq 0x2340
movq %r12, 0x8(%rsp)
movq (%rsp), %rax
movl (%rax), %eax
xorl %r15d, %r15d
cmpl %eax, %r15d
jge 0x8012
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x2150
cvtsd2ss %xmm0, %xmm0
movq 0x8(%rbx), %rcx
movl 0x4(%rbx), %eax
movl %ebp, %edx
imull %eax, %edx
movslq %edx, %rdx
addq %r15, %rdx
movss %xmm0, (%rcx,%rdx,4)
incq %r15
jmp 0x7fe0
incl %ebp
movl (%rbx), %r15d
jmp 0x7fbd
movq %r14, %rdi
callq 0x21f0
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x243e(%rip), %rdi      # 0xa478
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_O2/jingdao[P]PointCloudApp/descriptor.cpp
// Function: Descriptor::LoadFromDir(char const*)
Descriptor* Descriptor::LoadFromDir(const char* dir) {
	Descriptor* res = new Descriptor();

	char buffer[1024];
	int ndir = strlen(dir);
	strncpy(buffer,dir,ndir);
	char* buffer_c = buffer + ndir;
	*buffer_c++ = '/';

	std::vector<double> measurements;
	int j;
	for (j=0;;j++) {
		snprintf(buffer_c,64,"%d-cloud.pcd",j);
		PCD cloud(buffer);
		if (cloud.numPoints==0)
			break;
		Descriptor desc(&cloud);
		double lambda[3],v[9];
		desc.getPCA_XY(lambda,v);
		desc.setPCA(lambda,v);
		measurements.push_back(desc.principalLengths[0]); //length;
		measurements.push_back(desc.principalLengths[1]); //width;
		measurements.push_back(desc.principalLengths[2]); //height;
	}

	//set data
	res->numPoints = j;
	res->dimension = 3;
	res->data = new float[res->numPoints * res->dimension];
	for (size_t i=0;i<measurements.size();i++) {
		res->data[i] = measurements[i];
	}

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5b8, %rsp            # imm = 0x5B8
movq %rdi, %rbx
movl $0x90, %edi
callq 0x2200
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, 0x10(%rsp)
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
callq 0x20c0
movslq %eax, %r14
leaq 0x1b0(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x20e0
leaq (%rsp,%r14), %rax
addq $0x1b1, %rax            # imm = 0x1B1
movq %rax, 0x18(%rsp)
movb $0x2f, -0x1(%rax)
leaq 0x20(%rsp), %r12
andq $0x0, 0x10(%r12)
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
leaq 0xe8(%rsp), %rbx
leaq 0x58(%rsp), %r14
leaq 0x160(%rsp), %r15
xorl %ebp, %ebp
xorl %r13d, %r13d
movq 0x18(%rsp), %rdi
pushq $0x40
popq %rsi
leaq 0x2898(%rip), %rdx      # 0xa9ac
movl %r13d, %ecx
xorl %eax, %eax
callq 0x2350
movq %rbx, %rdi
leaq 0x1b0(%rsp), %rsi
callq 0x30f6
cmpl $0x0, 0x148(%rsp)
je 0x81b0
movl $0x1, 0x58(%rsp)
movq %rbx, 0x68(%rsp)
andq $0x0, 0x60(%rsp)
movq %r14, %rdi
leaq 0x40(%rsp), %rsi
movq %r15, %rdx
callq 0x8258
movq %r14, %rdi
leaq 0x40(%rsp), %rsi
movq %r15, %rdx
callq 0x833c
movq %r12, %rdi
leaq 0x70(%rsp), %rsi
callq 0x8a72
movq %r12, %rdi
leaq 0x78(%rsp), %rsi
callq 0x8a72
movq %r12, %rdi
leaq 0x80(%rsp), %rsi
callq 0x8a72
movq %r14, %rdi
callq 0x8066
movq %rbx, %rdi
callq 0x339e
incl %r13d
addl $0x3, %ebp
jmp 0x8105
leaq 0xe8(%rsp), %rdi
callq 0x339e
movq 0x10(%rsp), %rbx
movl %r13d, (%rbx)
movl $0x3, 0x4(%rbx)
movl %ebp, %edi
shlq $0x2, %rdi
callq 0x2040
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x8206
cvtsd2ss (%rcx,%rsi,8), %xmm0
movss %xmm0, (%rax,%rsi,4)
incq %rsi
jmp 0x81f2
leaq 0x20(%rsp), %rdi
callq 0x8a94
movq %rbx, %rax
addq $0x5b8, %rsp            # imm = 0x5B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8227
movq %rax, %rbx
jmp 0x8246
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x8066
leaq 0xe8(%rsp), %rdi
callq 0x339e
leaq 0x20(%rsp), %rdi
callq 0x8a94
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x5aa2
movq 0x10(%r15), %rax
movl 0x60(%rax), %edx
testl %edx, %edx
movl $0x0, %ecx
cmovgl %edx, %ecx
shufps $0x10, %xmm0, %xmm1     # xmm1 = xmm1[0,0],xmm0[1,0]
shufps $0xe2, %xmm0, %xmm1     # xmm1 = xmm1[2,0],xmm0[2,3]
shlq $0x4, %rcx
xorps %xmm0, %xmm0
xorpd %xmm2, %xmm2
cmpq %r12, %rcx
je 0x82db
movq 0x58(%rax), %rdx
movsd (%rdx,%r12), %xmm3
subps %xmm1, %xmm3
movaps %xmm3, %xmm4
shufps $0x0, %xmm3, %xmm4      # xmm4 = xmm4[0,0],xmm3[0,0]
mulps %xmm3, %xmm4
cvtps2pd %xmm4, %xmm4
addpd %xmm4, %xmm0
mulps %xmm3, %xmm3
shufps $0x55, %xmm3, %xmm3     # xmm3 = xmm3[1,1,1,1]
cvtss2sd %xmm3, %xmm3
shufpd $0x1, %xmm3, %xmm4      # xmm4 = xmm4[1],xmm3[0]
addpd %xmm4, %xmm2
addq $0x10, %r12
jmp 0x829e
leaq 0x10(%rsp), %rsi
movapd %xmm2, 0x10(%rsi)
movapd %xmm0, (%rsi)
pushq $0x2
popq %rdi
movq %rsp, %rcx
movq %r14, %rdx
movq %rbx, %r8
callq 0x8fb2
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x10(%r14)
movups 0x10(%rbx), %xmm0
movups %xmm0, 0x18(%rbx)
andq $0x0, 0x10(%rbx)
andq $0x0, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x40(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8654
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1f58(%rip), %rsi      # 0xa501
movq %rbx, %rdi
callq 0x2240
testq %rax, %rax
je 0x8663
movq %rax, %r15
movq %rbx, (%rsp)
movl (%r14), %ecx
movl 0x4(%r14), %edx
leaq 0x23ea(%rip), %rsi      # 0xa9b9
xorl %r13d, %r13d
movq %rax, %rdi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x22b0
leaq 0x1bb1(%rip), %r12      # 0xa197
pushq $0xa
popq %rbp
cmpl (%r14), %r13d
jge 0x8629
xorl %ebx, %ebx
movl 0x4(%r14), %eax
cmpl %eax, %ebx
jge 0x861a
movq 0x8(%r14), %rcx
imull %r13d, %eax
addl %ebx, %eax
cltq
cvtss2sd (%rcx,%rax,4), %xmm0
movq %r15, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x22b0
incl %ebx
jmp 0x85f0
movl %ebp, %edi
movq %r15, %rsi
callq 0x2260
incl %r13d
jmp 0x85e9
movq %r15, %rdi
callq 0x21f0
movl (%r14), %esi
leaq 0x1f9f(%rip), %rdi      # 0xa5da
movq (%rsp), %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 0x1e99(%rip), %rdi      # 0xa503
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_O2/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 %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x5aa2
movq 0x10(%r15), %rax
movl 0x60(%rax), %edx
movaps %xmm1, %xmm2
shufps $0x55, %xmm1, %xmm2     # xmm2 = xmm2[1,1],xmm1[1,1]
testl %edx, %edx
movl $0x0, %ecx
cmovgl %edx, %ecx
shufps $0x10, %xmm0, %xmm1     # xmm1 = xmm1[0,0],xmm0[1,0]
shufps $0xe2, %xmm0, %xmm1     # xmm1 = xmm1[2,0],xmm0[2,3]
shlq $0x4, %rcx
xorps %xmm0, %xmm0
xorpd %xmm3, %xmm3
xorpd %xmm4, %xmm4
xorpd %xmm5, %xmm5
xorpd %xmm6, %xmm6
cmpq %r12, %rcx
je 0x876a
movq 0x58(%rax), %rdx
movss 0x8(%rdx,%r12), %xmm7
subss %xmm2, %xmm7
movsd (%rdx,%r12), %xmm8
subps %xmm1, %xmm8
movaps %xmm8, %xmm9
shufps $0x0, %xmm8, %xmm9      # xmm9 = xmm9[0,0],xmm8[0,0]
mulps %xmm8, %xmm9
cvtps2pd %xmm9, %xmm9
addpd %xmm9, %xmm0
movaps %xmm8, %xmm10
movaps %xmm7, %xmm11
shufps $0xd4, %xmm8, %xmm11    # xmm11 = xmm11[0,1],xmm8[1,3]
shufps $0x52, %xmm8, %xmm11    # xmm11 = xmm11[2,0],xmm8[1,1]
mulss %xmm7, %xmm8
cvtss2sd %xmm8, %xmm8
movsd %xmm8, %xmm9            # xmm9 = xmm8[0],xmm9[1]
shufps $0x55, %xmm10, %xmm10   # xmm10 = xmm10[1,1,1,1]
mulps %xmm10, %xmm11
cvtps2pd %xmm11, %xmm10
addpd %xmm9, %xmm4
addpd %xmm10, %xmm5
movsd %xmm8, %xmm10           # xmm10 = xmm8[0],xmm10[1]
addpd %xmm10, %xmm6
mulss %xmm7, %xmm7
cvtss2sd %xmm7, %xmm7
addsd %xmm7, %xmm3
addq $0x10, %r12
jmp 0x86db
leaq 0x20(%rsp), %rsi
movapd %xmm4, 0x10(%rsi)
movapd %xmm5, 0x20(%rsi)
movapd %xmm6, 0x30(%rsi)
movsd %xmm3, 0x40(%rsi)
movapd %xmm0, (%rsi)
pushq $0x3
popq %rdi
movq %rsp, %rcx
movq %r14, %rdx
movq %rbx, %r8
callq 0x8fb2
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %r8, %r15
movq %rcx, 0x18(%rsp)
movq %rdx, %r12
movq %rsi, %r13
leaq 0x24(%rsp), %rbp
movl %edi, (%rbp)
leaq 0x14(%rsp), %rax
movl $0x1, (%rax)
leaq 0x10(%rsp), %rax
movl %edi, (%rax)
imull $0xf, %edi, %eax
leaq 0xc(%rsp), %rcx
movl %eax, (%rcx)
cltq
shlq $0x3, %rax
testl %edi, %edi
pushq $-0x1
popq %rbx
cmovnsq %rax, %rbx
movq %rbx, %rdi
callq 0x2040
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x2100
leaq 0xb(%rsp), %rdi
movb $0x4e, (%rdi)
leaq 0xa(%rsp), %rsi
movb $0x56, (%rsi)
leaq 0x20(%rsp), %rbx
movq %rbp, %rdx
movq %r13, %rcx
movq %rbp, %r8
movq %r12, %r9
pushq %rbx
leaq 0x14(%rsp), %rax
pushq %rax
pushq %r14
leaq 0x28(%rsp), %rax
pushq %rax
pushq %r15
leaq 0x3c(%rsp), %rax
pushq %rax
pushq $0x0
pushq 0x50(%rsp)
callq 0x2140
addq $0x40, %rsp
movl (%rbx), %esi
testl %esi, %esi
je 0x9074
leaq 0x19d4(%rip), %rdi      # 0xaa41
xorl %eax, %eax
callq 0x2050
movq %r14, %rdi
callq 0x2270
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $-0x1
popq %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 0x22f0
addq $0x40, %rsp
movl (%r15), %esi
testl %esi, %esi
je 0x915c
leaq 0x1912(%rip), %rdi      # 0xaa67
xorl %eax, %eax
callq 0x2050
movq %r12, %rdi
callq 0x2270
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
pushq $0x4
popq %rdi
callq 0x2280
movq %rax, (%r15)
movslq 0x609f(%rip), %r12      # 0xf230
leaq (,%r12,4), %rdi
callq 0x2280
movq %rax, %r14
movq %rax, 0x8(%r15)
movq %r12, %rbx
shlq $0x3, %rbx
movq %rbx, %rdi
callq 0x2280
movq %rax, 0x10(%r15)
movl %r12d, 0x18(%r15)
andl $0x0, 0x1c(%r15)
xorl %ecx, %ecx
testl %r12d, %r12d
movl $0x0, %edx
cmovgl %r12d, %edx
cmpq %rcx, %rdx
je 0x91de
orl $-0x1, (%r14,%rcx,4)
incq %rcx
jmp 0x91cf
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movl 0x18(%rdi), %r15d
movl %r15d, %esi
movl %ebp, %edx
callq 0x92c6
movl %eax, %r12d
movl %r15d, %esi
movl %ebp, %edx
callq 0x92ec
movl %eax, %ecx
movq 0x10(%rbx), %rsi
movq (%rbx), %r8
movq 0x8(%rbx), %rdi
xorl %r9d, %r9d
testl %r15d, %r15d
cmovgl %r15d, %r9d
subl $0x1, %r9d
jb 0x9283
movslq %r12d, %rax
movq (%rsi,%rax,8), %rdx
testq %rdx, %rdx
je 0x929c
cmpq %r8, %rdx
je 0x929c
cmpl %ebp, (%rdi,%rax,4)
je 0x928f
addl %ecx, %r12d
movl %r12d, %eax
cltd
idivl %r15d
movl %edx, %r12d
jmp 0x9258
leaq 0x1830(%rip), %rdi      # 0xaaba
callq 0x2320
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, (%rdi,%rax,4)
movq %r14, (%rsi,%rax,8)
movl 0x18(%rbx), %eax
movl 0x1c(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x1c(%rbx)
pushq $0x4
popq %rsi
cltd
idivl %esi
movb $0x1, %bpl
cmpl %eax, %ecx
jl 0x9291
movq %rbx, %rdi
callq 0x9314
jmp 0x9291
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2280
movq %rax, %r13
movq %rbp, %r12
shlq $0x4, %r12
movq %r12, %rdi
callq 0x2280
testq %rax, %rax
setne %cl
testq %r13, %r13
setne %dl
testb %cl, %dl
je 0x938a
leal (,%rbp,2), %ecx
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %r14
movq %r13, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movl %ecx, 0x18(%rbx)
andl $0x0, 0x1c(%rbx)
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rdx, %rcx
je 0x93a4
orl $-0x1, (%r13,%rdx,4)
incq %rdx
jmp 0x937a
leaq 0x16fd(%rip), %rdi      # 0xaa8e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2320
xorl %r13d, %r13d
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2100
testl %ebp, %ebp
cmovlel %r13d, %ebp
cmpq %r13, %rbp
je 0x93de
movq (%r14,%r13,8), %rdx
testq %rdx, %rdx
je 0x93d9
cmpq (%rbx), %rdx
je 0x93d9
movl (%r15,%r13,4), %esi
movq %rbx, %rdi
callq 0x9216
incq %r13
jmp 0x93ba
movq %r15, %rdi
callq 0x2250
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movl 0x18(%rdi), %ebp
movl %ebp, %esi
movl %ebx, %edx
callq 0x92c6
movl %eax, %r14d
movl %ebp, %esi
movl %ebx, %edx
callq 0x92ec
movl %eax, %ecx
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdi
xorl %r8d, %r8d
testl %ebp, %ebp
cmovgl %ebp, %r8d
subl $0x1, %r8d
jb 0x9458
movslq %r14d, %rdx
movq (%rdi,%rdx,8), %rax
testq %rax, %rax
je 0x9464
cmpl %ebx, (%rsi,%rdx,4)
je 0x9466
addl %ecx, %r14d
movl %r14d, %eax
cltd
idivl %ebp
movl %edx, %r14d
jmp 0x9433
leaq 0x165b(%rip), %rdi      # 0xaaba
callq 0x2320
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x18(%rdi), %r14d
movl %r14d, %esi
movl %ebp, %edx
callq 0x92c6
movl %eax, %r15d
movl %r14d, %esi
movl %ebp, %edx
callq 0x92ec
movl %eax, %ecx
movq 0x10(%rbx), %rsi
movq (%rbx), %rdi
movq 0x8(%rbx), %r8
xorl %r9d, %r9d
testl %r14d, %r14d
cmovgl %r14d, %r9d
subl $0x1, %r9d
jb 0x94dc
movslq %r15d, %rdx
movq (%rsi,%rdx,8), %rax
testq %rax, %rax
je 0x94e8
cmpq %rdi, %rax
je 0x94cd
cmpl %ebp, (%r8,%rdx,4)
je 0x94ec
addl %ecx, %r15d
movl %r15d, %eax
cltd
idivl %r14d
movl %edx, %r15d
jmp 0x94b0
leaq 0x15d7(%rip), %rdi      # 0xaaba
callq 0x2320
xorl %eax, %eax
jmp 0x94f8
orl $-0x1, (%r8,%rdx,4)
movq %rdi, (%rsi,%rdx,8)
decl 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x5cea(%rip), %ecx      # 0xf218
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
cmpl %eax, %edx
je 0x9547
movsbl (%rsi,%rax), %edi
imull $0x21, %ecx, %ecx
addl %edi, %ecx
incq %rax
jmp 0x9535
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x53, %eax
je 0x23c2
cmpl $0x4e, %eax
jne 0x23d4
movl 0x28(%rbx), %eax
jmp 0x23d2
movq 0x8(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21d0
movl %eax, 0x28(%rbx)
popq %rbx
retq
leaq 0x5457(%rip), %rdi      # 0x7832
leaq 0x4fe5(%rip), %rsi      # 0x73c7
leaq 0x4c47(%rip), %rcx      # 0x7030
pushq $0x20
popq %rdx
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movzbl (%rdi), %eax
cmpl $0x24, %eax
je 0x2434
cmpl $0x53, %eax
je 0x2440
cmpl $0x4e, %eax
jne 0x244f
movl 0x28(%rbx), %esi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x358d
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x2190
movq %r14, %rdi
callq 0x20e0
jmp 0x2440
leaq 0x8(%rbx), %rdi
pushq $0x24
popq %rsi
callq 0x2250
addq $0x8, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x53dc(%rip), %rdi      # 0x7832
leaq 0x4f6a(%rip), %rsi      # 0x73c7
leaq 0x4bdf(%rip), %rcx      # 0x7043
pushq $0x29
popq %rdx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rsi, 0x8(%rsi)
movq %rsi, (%rsi)
andq $0x0, 0x10(%rsi)
callq 0x252a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x28a2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x36b4
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x2514
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x36b4
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x2924
movq %rdi, %rbx
cmpq $0x0, (%rdi)
jne 0x2954
movq %rsi, (%rbx)
xorl %r14d, %r14d
pushq $0x24
popq %rbp
pushq $0x1
popq %r15
pushq $0x30
popq %r12
cmpq %rsi, (%rsi)
je 0x2914
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x2b74
testb %al, %al
jne 0x290c
testq %r14, %r14
je 0x28f1
leaq 0x8(%r14), %rdi
callq 0x20e0
movq %r14, %rdi
movq %r12, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2bfc
movq %rax, %r14
movq (%rbx), %rsi
jmp 0x28cd
movq (%rbx), %rax
cmpq %rax, (%rax)
jne 0x296d
andq $0x0, (%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x47d2(%rip), %rsi      # 0x7108
movq %rax, %rdi
callq 0x21e0
movq 0x769b(%rip), %rsi      # 0x9fe0
movq 0x7684(%rip), %rdx      # 0x9fd0
movq %rbx, %rdi
callq 0x2260
leaq 0x47c9(%rip), %rdi      # 0x7124
leaq 0x4a65(%rip), %rsi      # 0x73c7
leaq 0x47c3(%rip), %rcx      # 0x712c
pushq $0x67
jmp 0x2984
leaq 0x47e5(%rip), %rdi      # 0x7159
leaq 0x4a4c(%rip), %rsi      # 0x73c7
leaq 0x47aa(%rip), %rcx      # 0x712c
pushq $0x6e
popq %rdx
callq 0x2100
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/yukioc[P]tscrpt/tscrpt.cpp
// Function: estrndup(char const*, unsigned long)
char* estrndup(const char*s, size_t n){
	if (s==NULL)return NULL;
	char *ret(new char[n+1]),*t(ret),*p;
	const char *e(&s[n]);
	for(;*s!='\0'&&s!=e&&n>0;--n,++s,++t){
//		printf("estrndup: s=%c\n",*s);
		if(*s=='\\'){
			++s;--n;
			switch(*s){
				case 'a':*t='\a';break;
				case 'b':*t='\b';break;
				case 'f':*t='\f';break;
				case 'n':*t='\n';break;
				case 'r':*t='\r';break;
				case 't':*t='\t';break;
				case 'v':*t='\v';break;
				case '?':*t='\?';break;
				case '\\':*t='\\';break;
				case '\'':*t='\'';break;
				case '\"':*t='\"';break;
				case 'x':*t=(char)strtol(s+1,&p,16);s=p-1;break;
				default:
					if(*s>='0'&&*s<='7'){ *t=strtol(s,&p,8);s=p-1;break; }
					else {
						delete ret; 
						throw std::logic_error("estrndup: contained wrong escaped character");
					}
			}
		}else if(*s=='"'){
			delete ret;
			throw std::logic_error("estrndup: contained un-escaped '\"'");
		}else{
			*t=*s;
		}
	}
	*t='\0';
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2ade
movq %rsi, %r14
movq %rdi, %r13
leaq 0x1(%rsi), %rdi
callq 0x2030
movq %rax, %r15
leaq (%r14,%r13), %r12
leaq 0x4636(%rip), %rbp      # 0x7004
movq %rax, %rbx
movzbl (%r13), %eax
testl %eax, %eax
je 0x2ad9
cmpq %r12, %r13
je 0x2ad9
testq %r14, %r14
je 0x2ad9
cmpl $0x5c, %eax
je 0x2a11
cmpl $0x22, %eax
je 0x2af3
movb %al, (%rbx)
movq %r13, %rdi
decq %r14
incq %rdi
incq %rbx
movq %rdi, %r13
jmp 0x29d1
leaq 0x1(%r13), %rdi
decq %r14
movb 0x1(%r13), %al
movzbl %al, %ecx
leal -0x6e(%rcx), %edx
cmpl $0xa, %edx
jbe 0x2a57
cmpl $0x22, %ecx
je 0x2ad1
cmpl $0x27, %ecx
je 0x2ab1
cmpl $0x3f, %ecx
je 0x2ac9
cmpl $0x5c, %ecx
je 0x2aa9
cmpl $0x66, %ecx
je 0x2ab9
cmpl $0x62, %ecx
je 0x2ac1
cmpl $0x61, %ecx
jne 0x2a66
movb $0x7, (%rbx)
jmp 0x2a03
movslq (%rbp,%rdx,4), %rcx
addq %rbp, %rcx
jmpq *%rcx
movb $0xa, (%rbx)
jmp 0x2a03
andb $-0x8, %al
cmpb $0x30, %al
jne 0x2b2e
movq %rsp, %rsi
pushq $0x8
jmp 0x2a95
movb $0xb, (%rbx)
jmp 0x2a03
movb $0xd, (%rbx)
jmp 0x2a03
movb $0x9, (%rbx)
jmp 0x2a03
addq $0x2, %r13
movq %r13, %rdi
movq %rsp, %rsi
pushq $0x10
popq %rdx
callq 0x21d0
movb %al, (%rbx)
movq (%rsp), %rdi
decq %rdi
jmp 0x2a03
movb $0x5c, (%rbx)
jmp 0x2a03
movb $0x27, (%rbx)
jmp 0x2a03
movb $0xc, (%rbx)
jmp 0x2a03
movb $0x8, (%rbx)
jmp 0x2a03
movb $0x3f, (%rbx)
jmp 0x2a03
movb $0x22, (%rbx)
jmp 0x2a03
movb $0x0, (%rbx)
jmp 0x2ae1
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x2160
pushq $0x10
popq %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x481c(%rip), %rsi      # 0x732c
movq %rax, %rdi
callq 0x21e0
movq 0x74c1(%rip), %rsi      # 0x9fe0
movq 0x74aa(%rip), %rdx      # 0x9fd0
movq %rbx, %rdi
callq 0x2260
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x2160
pushq $0x10
popq %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x47b5(%rip), %rsi      # 0x7300
movq %rax, %rdi
callq 0x21e0
jmp 0x2b18
jmp 0x2b57
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
cmpq %rdi, %rax
je 0x2bb9
movl %esi, %ebx
movq 0x10(%rax), %r14
movb (%r14), %bpl
testb %dl, %dl
je 0x2bae
cmpb %bl, %bpl
jne 0x2bae
callq 0x365a
leaq 0x8(%r14), %rdi
callq 0x20e0
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x2160
cmpb %bl, %bpl
sete %al
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x45b6(%rip), %rsi      # 0x7181
movq %rax, %rdi
callq 0x20b0
movq 0x741e(%rip), %rsi      # 0x9ff8
movq 0x73e7(%rip), %rdx      # 0x9fc8
movq %rbx, %rdi
callq 0x2260
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2d92
movq %rax, %r13
pushq $0x1
popq %r14
pushq $0x30
popq %r15
movq (%rbx), %rax
cmpq %rax, (%rax)
je 0x2cb3
movq %rbx, %rdi
pushq $0x2b
popq %rsi
movl %r14d, %edx
callq 0x2b74
movq %rbx, %rdi
testb %al, %al
je 0x2c50
callq 0x2d92
movq %rax, %r12
movq %r13, %rsi
movq %rax, %rdx
callq 0x2f1e
jmp 0x2c75
pushq $0x2d
popq %rsi
movl %r14d, %edx
callq 0x2b74
testb %al, %al
je 0x2cb3
movq %rbx, %rdi
callq 0x2d92
movq %rax, %r12
movq %r13, %rsi
movq %rax, %rdx
callq 0x3042
movq %rax, %rbp
testq %r13, %r13
je 0x2c86
leaq 0x8(%r13), %rdi
callq 0x20e0
movq %r13, %rdi
movq %r15, %rsi
callq 0x2160
testq %r12, %r12
je 0x2ca0
leaq 0x8(%r12), %rdi
callq 0x20e0
movq %r12, %rdi
movq %r15, %rsi
callq 0x2160
movq %rbp, %r13
jmp 0x2c1a
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rdi
movq (%rdi), %rax
cmpq %rdi, %rax
je 0x2ce9
movq 0x10(%rax), %rbx
callq 0x365a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x446c(%rip), %rsi      # 0x7167
movq %rax, %rdi
callq 0x20b0
movq 0x72ee(%rip), %rsi      # 0x9ff8
movq 0x72b7(%rip), %rdx      # 0x9fc8
movq %rbx, %rdi
callq 0x2260
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::term()
obj_t* tscrpt_t::term() {
	obj_t *o(factor());
	while(more()){ // mul,div
		obj_t *l(0),*r(0);
		try {
			if     (is('*')){ o=mul(l=o, r=factor()); }
			else if(is('/')){ o=div(l=o, r=factor()); }
			else if(is('%')){ o=rem(l=o, r=factor()); }
			else break;
		}catch(std::runtime_error& e){
			delete l;
			delete r;
			clear();
			throw;
		}
		delete l;
		delete r;
	}
	return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x30f4
movq %rax, %r15
movq (%rbx), %rax
cmpq %rax, (%rax)
je 0x2ea3
xorl %r13d, %r13d
xorl %r12d, %r12d
movq %rbx, %rdi
pushq $0x2a
popq %rsi
pushq $0x1
popq %rdx
callq 0x2b74
testb %al, %al
je 0x2df0
movq %r15, %r13
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x30f4
movq %rax, %r14
movq %r15, %r13
movq %rax, %r12
movq %r15, %rsi
movq %rax, %rdx
callq 0x3262
jmp 0x2e66
xorl %r13d, %r13d
xorl %r12d, %r12d
movq %rbx, %rdi
pushq $0x2f
popq %rsi
pushq $0x1
popq %rdx
callq 0x2b74
testb %al, %al
je 0x2e2c
movq %r15, %r13
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x30f4
movq %rax, %r14
movq %r15, %r13
movq %rax, %r12
movq %r15, %rsi
movq %rax, %rdx
callq 0x337a
jmp 0x2e66
xorl %r13d, %r13d
xorl %r12d, %r12d
movq %rbx, %rdi
pushq $0x25
popq %rsi
pushq $0x1
popq %rdx
callq 0x2b74
testb %al, %al
je 0x2ea3
movq %r15, %r13
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x30f4
movq %rax, %r14
movq %r15, %r13
movq %rax, %r12
movq %r15, %rsi
movq %rax, %rdx
callq 0x3484
movq %rax, %rbp
testq %r15, %r15
je 0x2e77
leaq 0x8(%r15), %rdi
callq 0x20e0
movq %r15, %rdi
pushq $0x30
popq %rsi
callq 0x2160
testq %r14, %r14
je 0x2e90
leaq 0x8(%r14), %rdi
callq 0x20e0
movq %r14, %rdi
pushq $0x30
popq %rsi
callq 0x2160
movq %rbp, %r15
jmp 0x2da8
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x2f0d
movq %r14, %rdi
callq 0x20c0
testq %r13, %r13
je 0x2ed3
leaq 0x8(%r13), %rdi
callq 0x20e0
pushq $0x30
popq %rsi
movq %r13, %rdi
callq 0x2160
testq %r12, %r12
je 0x2eed
leaq 0x8(%r12), %rdi
callq 0x20e0
pushq $0x30
popq %rsi
movq %r12, %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2482
callq 0x21f0
movq %rax, %r14
callq 0x2240
movq %r14, %rdi
callq 0x2280
movq %rax, %rdi
callq 0x35ef
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
cmpl $0x9, 0x7233(%rip)      # 0xa168
jl 0x2f5e
movq %r15, %rdi
callq 0x23f2
movq (%rax), %rbx
movq %r14, %rdi
callq 0x23f2
movq (%rax), %rdx
leaq 0x428e(%rip), %rdi      # 0x71e2
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2040
movzbl (%r15), %eax
cmpl $0x53, %eax
je 0x2fa8
cmpl $0x4e, %eax
jne 0x2ffe
pushq $0x30
popq %rdi
callq 0x2150
movq %rax, %rbx
movq %r15, %rdi
callq 0x23ac
movl %eax, %ebp
movq %r14, %rdi
callq 0x23ac
movb $0x4e, (%rbx)
leaq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
addl %ebp, %eax
movb $0x0, 0x18(%rbx)
movl %eax, 0x28(%rbx)
jmp 0x2ff0
pushq $0x30
popq %rdi
callq 0x2150
movq %rax, %rbx
movq %r15, %rdi
callq 0x23f2
movq %rax, %r15
movq %r14, %rdi
callq 0x23f2
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3662
pushq $0x53
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x369a
leaq 0x8(%rsp), %rdi
callq 0x20e0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x482d(%rip), %rdi      # 0x7832
leaq 0x43bb(%rip), %rsi      # 0x73c7
leaq 0x41dd(%rip), %rcx      # 0x71f0
movl $0xcd, %edx
callq 0x2100
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x20e0
jmp 0x302f
movq %rax, %r14
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::sub(obj_t*, obj_t*)
obj_t* tscrpt_t::sub(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'||l->type=='S'){
		o = new obj_t('N', l->value() - r->value());
	}else assert(0);
	return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x9, 0x7112(%rip)      # 0xa168
jl 0x307f
movq %r14, %rdi
callq 0x23f2
movq (%rax), %r15
movq %rbx, %rdi
callq 0x23f2
movq (%rax), %rdx
leaq 0x41a2(%rip), %rdi      # 0x7217
movq %r15, %rsi
xorl %eax, %eax
callq 0x2040
movzbl (%r14), %eax
cmpl $0x53, %eax
je 0x308d
cmpl $0x4e, %eax
jne 0x30d4
pushq $0x30
popq %rdi
callq 0x2150
movq %rax, %r15
movq %r14, %rdi
callq 0x23ac
movl %eax, %ebp
movq %rbx, %rdi
callq 0x23ac
movb $0x4e, (%r15)
leaq 0x18(%r15), %rcx
movq %rcx, 0x8(%r15)
andq $0x0, 0x10(%r15)
subl %eax, %ebp
movb $0x0, 0x18(%r15)
movl %ebp, 0x28(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4757(%rip), %rdi      # 0x7832
leaq 0x42e5(%rip), %rsi      # 0x73c7
leaq 0x413c(%rip), %rcx      # 0x7225
movl $0xd5, %edx
callq 0x2100
nop