LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/8igMac[P]random-forest/src/decision_tree.cpp
// Function: rdmSelectSet(int, int, int)
vector<int> rdmSelectSet(int begin, int end, int n)
{
	int size = end-begin+1;
	// implement Kruth shuffle algorithm
	vector<int> list(size);

	// init list 
	for (int i=begin; i<=end; i++)
		list[i] = i;

	// shuffle
	for (int i=size-1; i>=0; i--)
	{
		int j = rand()%(i+1);
		swap(list[i], list[j]);
	}

	return vector<int>(list.begin(), list.begin()+n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl %edx, %r13d
subl %esi, %r13d
leal 0x1(%r13), %eax
movslq %eax, %rsi
leaq 0x10(%rsp), %r12
leaq 0xf(%rsp), %rdx
movq %r12, %rdi
callq 0x460e
movq (%r12), %rsi
movslq %r15d, %rax
movslq %r14d, %rcx
cmpq %rcx, %rax
jg 0x2d51
movl %eax, (%rsi,%rax,4)
incq %rax
jmp 0x2d1e
callq 0x2060
leal 0x1(%r13), %ecx
cltd
idivl %ecx
movl %r13d, %eax
movq 0x10(%rsp), %rsi
movslq %edx, %rcx
movl (%rsi,%rax,4), %edx
movl (%rsi,%rcx,4), %edi
movl %edi, (%rsi,%rax,4)
movl %edx, (%rsi,%rcx,4)
decl %r13d
testl %r13d, %r13d
jns 0x2d2b
movslq %ebp, %rax
leaq (%rsi,%rax,4), %rdx
leaq 0xf(%rsp), %rcx
movq %rbx, %rdi
callq 0x4660
leaq 0x10(%rsp), %rdi
callq 0x4b42
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4b42
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/8igMac[P]random-forest/src/decision_tree.cpp
// Function: dataSet::split_data(std::vector<data_inst, std::allocator<data_inst>>&, std::vector<data_inst, std::allocator<data_inst>>&)
void dataSet::split_data(vector<data_inst> &trainSet, vector<data_inst> &valiSet)
{
	vector<int> rdmPermutation(rdmSelectSet(0,dataSet.size()-1, dataSet.size()));
	int trainSize = TRAINPERCENT * (dataSet.size()/100);
	for (int i=0; i<(int)dataSet.size(); i++)
	{
		if (i<trainSize)
			trainSet.push_back(dataSet.at(rdmPermutation[i]));
		else
			valiSet.push_back(dataSet.at(rdmPermutation[i]));
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
subq (%rdi), %rax
pushq $0x28
popq %r12
cqto
idivq %r12
leal -0x1(%rax), %edx
movq %rsp, %rdi
xorl %r13d, %r13d
xorl %esi, %esi
movl %eax, %ecx
callq 0x2cdc
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %rcx, %rax
subq %rsi, %rax
cqto
idivq %r12
pushq $0x64
popq %rdi
xorl %edx, %edx
divq %rdi
movabsq $0x4600000000, %rbp     # imm = 0x4600000000
imulq %rax, %rbp
sarq $0x20, %rbp
subq %rsi, %rcx
movq %rcx, %rax
cqto
idivq %r12
cltq
cmpq %rax, %r13
jge 0x3200
movq (%rsp), %rax
movslq (%rax,%r13,4), %rsi
cmpq %rbp, %r13
jge 0x31e1
movq %r15, %rdi
callq 0x4732
movq %r14, %rdi
jmp 0x31ec
movq %r15, %rdi
callq 0x4732
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4706
incq %r13
movq (%r15), %rsi
movq 0x8(%r15), %rcx
jmp 0x31b5
movq %rsp, %rdi
callq 0x4b42
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4b42
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/8igMac[P]random-forest/src/decision_tree.cpp
// Function: decision_tree::destory_tree(node*)
void decision_tree::destory_tree(node* leaf)
{
	if (leaf != NULL)
	{
		destory_tree(leaf->leftChild);
		destory_tree(leaf->rightChild);
		delete leaf;
	}
}

// Assembly:
testq %rsi, %rsi
je 0x33e6
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rsi), %rsi
callq 0x33a8
movq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0x33a8
movq %rbx, %rdi
callq 0x4992
pushq $0x58
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2170
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/8igMac[P]random-forest/src/decision_tree.cpp
// Function: decision_tree::impurity(std::vector<data_inst, std::allocator<data_inst>>)
float decision_tree::impurity(vector<data_inst> sampleSet)
{
	vector<int> sizeClass(sampleSet.at(0).num_cls, 0);

	for (auto sample: sampleSet)
		sizeClass[sample.cls]++;

	// sum of square of probability of each class
	float sum_square_of_p = 0;
	for (auto size: sizeClass)
		sum_square_of_p += pow(((double)size/(double)sampleSet.size()), 2.0);
	
	return 1-sum_square_of_p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x4732
movslq 0x24(%rax), %rsi
leaq 0x28(%rsp), %r14
andl $0x0, (%r14)
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rcx
movq %r14, %rdx
callq 0x4750
movq (%rbx), %r15
movq 0x8(%rbx), %r13
leaq 0x30(%rsp), %r12
cmpq %r13, %r15
je 0x3c78
movq %r14, %rdi
movq %r15, %rsi
callq 0x2c00
movslq 0x48(%rsp), %rax
movq 0x10(%rsp), %rcx
incl (%rcx,%rax,4)
movq %r12, %rdi
callq 0x2878
addq $0x28, %r15
jmp 0x3c4d
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rsi
xorps %xmm0, %xmm0
pushq $0x28
popq %rdi
movq 0x2410(%rip), %xmm1     # 0x60a0
movapd 0x2418(%rip), %xmm2     # 0x60b0
cmpq %rsi, %rcx
je 0x3ce0
cvtsi2sdl (%rcx), %xmm3
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %rdi
movq %rax, %xmm4
punpckldq %xmm1, %xmm4    # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1]
subpd %xmm2, %xmm4
movapd %xmm4, %xmm5
unpckhpd %xmm4, %xmm5            # xmm5 = xmm5[1],xmm4[1]
addsd %xmm4, %xmm5
divsd %xmm5, %xmm3
mulsd %xmm3, %xmm3
cvtss2sd %xmm0, %xmm0
addsd %xmm3, %xmm0
cvtsd2ss %xmm0, %xmm0
addq $0x4, %rcx
jmp 0x3c98
movss 0x23a8(%rip), %xmm1     # 0x6090
subss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x4b42
movss 0xc(%rsp), %xmm0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4b42
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/8igMac[P]random-forest/src/decision_tree.cpp
// Function: decision_tree::classify(node*, data_inst)
int decision_tree::classify(node* nodePtr, data_inst valiInst)
{
	if (nodePtr->leftChild == NULL && nodePtr->rightChild == NULL)
		return nodePtr->majClass();
	else
		return classify(nodePtr->traceNextNode(valiInst), valiInst);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
cmpq $0x0, 0x48(%rsi)
jne 0x3da2
cmpq $0x0, 0x50(%r12)
je 0x3e0d
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x2c00
leaq 0x30(%rsp), %rbx
movslq 0x20(%r12), %rax
movq (%rbx), %rcx
movss 0x24(%r12), %xmm0
xorl %edx, %edx
ucomiss (%rcx,%rax,4), %xmm0
setb %dl
movq 0x48(%r12,%rdx,8), %r12
movq %rsp, %rdi
movq %r15, %rsi
callq 0x2c00
movq %rsp, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x3d7e
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x2878
movq %rbx, %rdi
callq 0x2878
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3262
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2878
jmp 0x3e33
movq %rax, %r14
movq %rbx, %rdi
callq 0x2878
movq %r14, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/8igMac[P]random-forest/src/decision_tree.cpp
// Function: random_forest::build_forest(std::vector<data_inst, std::allocator<data_inst>>)
void random_forest::build_forest(vector<data_inst> trainSet)
{
	int idx = 1;
	for (vector<decision_tree>::iterator itr = treeSet.begin();
		 	 itr != treeSet.end(); itr++)
	{
		//debug
		cout << "building tree " << idx << "... " << flush;
		itr->build_tree(treeBagging(trainSet));
		cout << "finished." << endl;
		idx++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, (%rsp)
movq %rdi, %r14
movq (%rdi), %r15
pushq $0x1
popq %rbp
movq 0x6162(%rip), %r12      # 0x9fd8
leaq 0x8(%rsp), %r13
leaq 0x20(%rsp), %rbx
cmpq 0x8(%r14), %r15
je 0x3f0e
movq %r12, %rdi
leaq 0x222c(%rip), %rsi      # 0x60c0
callq 0x2150
movq %rax, %rdi
movl %ebp, %esi
callq 0x2220
movq %rax, %rdi
leaq 0x21be(%rip), %rsi      # 0x606b
callq 0x2150
movq %rax, %rdi
callq 0x20e0
movq %r13, %rdi
movq (%rsp), %rsi
callq 0x276e
movq %rbx, %rdi
movq %r13, %rdx
callq 0x3f42
movq %r15, %rdi
movq %rbx, %rsi
callq 0x33e8
movq %rbx, %rdi
callq 0x27c8
movq %r13, %rdi
callq 0x27c8
movq %r12, %rdi
leaq 0x21d9(%rip), %rsi      # 0x60cf
callq 0x2150
movq %rax, %rdi
callq 0x20b0
incl %ebp
addq $0x8, %r15
jmp 0x3e80
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3f2f
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x27c8
leaq 0x8(%rsp), %rdi
callq 0x27c8
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/8igMac[P]random-forest/src/decision_tree.cpp
// Function: random_forest::treeBagging(std::vector<data_inst, std::allocator<data_inst>>)
vector<data_inst> random_forest::treeBagging(vector<data_inst> trainSet)
{
	vector<data_inst> newTrainSet;
	int sample;

	for(int i=0; i<(int)trainSet.size(); i++)
	{
		sample = rand()%(trainSet.size());
		newTrainSet.push_back(trainSet.at(sample));
	}
	return newTrainSet;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r15d, %r15d
pushq $0x28
popq %r12
movq 0x8(%r14), %rax
subq (%r14), %rax
cqto
idivq %r12
cmpl %eax, %r15d
jge 0x3fad
callq 0x2060
movslq %eax, %rcx
movq 0x8(%r14), %rax
subq (%r14), %rax
cqto
idivq %r12
movq %rax, %rsi
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
movslq %edx, %rsi
movq %r14, %rdi
callq 0x4732
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4706
incl %r15d
jmp 0x3f62
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x27c8
movq %r14, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/8igMac[P]random-forest/src/decision_tree.cpp
// Function: random_forest::classify(data_inst)
int random_forest::classify(data_inst valiInst)
{
	// vote
	vector<int> vote(valiInst.num_cls,0);
	for (vector<decision_tree>::iterator itr = treeSet.begin();
			 itr != treeSet.end(); itr++)
		vote.at(itr->classify(valiInst))++;

	// reach consensus among trees
	int majorVote=0;
	for (int i=1; i<(int)vote.size(); i++)
	{
		if (vote[majorVote] < vote[i])
			majorVote = i;
		else if (vote[majorVote] == vote[i])
		{
			// break tie by select random
			if (rand()%2 == 0)
				majorVote = i;
		}
	}

	return majorVote;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x24(%rsi), %rsi
leaq 0x4(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x8(%rsp), %r15
leaq 0x3(%rsp), %rcx
movq %r15, %rdi
callq 0x4750
movq (%r14), %r13
leaq 0x28(%rsp), %r12
leaq 0x20(%rsp), %rbp
cmpq 0x8(%r14), %r13
je 0x4046
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x2c00
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3d26
movslq %eax, %rsi
movq %r15, %rdi
callq 0x49fe
incl (%rax)
movq %r12, %rdi
callq 0x2878
addq $0x8, %r13
jmp 0x400f
xorl %ebx, %ebx
pushq $0x1
popq %r14
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r14
jge 0x4088
movslq %ebx, %rcx
movl (%rax,%r14,4), %edx
cmpl %edx, (%rax,%rcx,4)
jge 0x4076
movl %r14d, %ebx
jmp 0x4083
jne 0x4083
callq 0x2060
testb $0x1, %al
cmovel %r14d, %ebx
incq %r14
jmp 0x404c
leaq 0x8(%rsp), %rdi
callq 0x4b42
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x40b3
movq %rax, %rbx
movq %r12, %rdi
callq 0x2878
leaq 0x8(%rsp), %rdi
callq 0x4b42
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/8igMac[P]random-forest/src/decision_tree.cpp
// Function: analyser::analyse(random_forest&, std::vector<data_inst, std::allocator<data_inst>>)
void analyser::analyse(random_forest &forest, vector<data_inst> valiSet)
{
	int clsfyResult;
	for (int i=0; i<(int)valiSet.size(); i++)
	{
		clsfyResult = forest.classify(valiSet.at(i));
		confusionMtrx.at(clsfyResult).at(valiSet.at(i).cls)++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movq %rsp, %rbp
movq 0x8(%r14), %rax
subq (%r14), %rax
cqto
pushq $0x28
popq %rcx
idivq %rcx
cltq
cmpq %rax, %r13
jge 0x41f0
movq %r14, %rdi
movq %r13, %rsi
callq 0x4732
movq %rbp, %rdi
movq %rax, %rsi
callq 0x2c00
movq %r15, %rdi
movq %rbp, %rsi
callq 0x3fd0
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x2878
movslq %ebx, %rsi
movq %r12, %rdi
callq 0x4acc
movq %rax, %rbx
movq %r14, %rdi
movq %r13, %rsi
callq 0x4732
movslq 0x20(%rax), %rsi
movq %rbx, %rdi
callq 0x494e
movss (%rax), %xmm0
addss 0x1ea9(%rip), %xmm0     # 0x6090
movss %xmm0, (%rax)
incq %r13
jmp 0x4173
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2878
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/8igMac[P]random-forest/src/decision_tree.cpp
// Function: analyser::get_precision(int)
float analyser::get_precision(int cls)
{
	// precision = true positive / positive
	float positive = 0;
	float true_positive = confusionMtrx.at(cls).at(cls);

	for (int i=0; i<(int)confusionMtrx.at(cls).size(); i++)
		positive += confusionMtrx.at(cls).at(i);

	return true_positive / positive;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq %esi, %r14
movq %r14, %rsi
callq 0x4acc
movq %rax, %rdi
movq %r14, %rsi
callq 0x494e
movss (%rax), %xmm0
movss %xmm0, 0xc(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4acc
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x2, %rcx
movslq %ecx, %rax
cmpq %rax, %r15
jge 0x4295
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4acc
movq %rax, %rdi
movq %r15, %rsi
callq 0x494e
movss 0x8(%rsp), %xmm0
addss (%rax), %xmm0
movss %xmm0, 0x8(%rsp)
incq %r15
jmp 0x424c
movss 0xc(%rsp), %xmm0
divss 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/8igMac[P]random-forest/src/decision_tree.cpp
// Function: analyser::print_result(int)
void analyser::print_result(int num_inst)
{
	int trainSize = TRAINPERCENT * (num_inst/100);
	cout << "tran size: " << trainSize << endl;
	cout << "validation size: " << num_inst-trainSize << endl;
	cout << "number of trees: " << NUMTREE << endl;
	cout << "attribute bagging: " << ATTRBAGGING << endl;
	cout << "decision tree max depth:  : " << MAXDEPTH << endl;
	cout << "mininum samples of a node: " << MINSAMPLE << endl;
	cout << endl; 

	for (int i=0; i<(int)formatTb.size(); i++)
	{
		cout << formatTb.at(i) << "\t"
				 << "precision: " << get_precision(i) << " "
				 << "recall: " << get_recall(i) << "\n" << endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x64
popq %rcx
movl %esi, %eax
cltd
idivl %ecx
imull $0x46, %eax, %r14d
movq 0x5c71(%rip), %r15      # 0x9fd8
leaq 0x1d6b(%rip), %rsi      # 0x60d9
movq %r15, %rdi
callq 0x2150
movq %rax, %rdi
movl %r14d, %esi
callq 0x2220
movq %rax, %rdi
callq 0x20b0
leaq 0x1d55(%rip), %rsi      # 0x60e5
movq %r15, %rdi
callq 0x2150
subl %r14d, %ebp
movq %rax, %rdi
movl %ebp, %esi
callq 0x2220
movq %rax, %rdi
callq 0x20b0
leaq 0x1d43(%rip), %rsi      # 0x60f7
movq %r15, %rdi
callq 0x2150
pushq $0x1e
popq %rsi
movq %rax, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x20b0
leaq 0x1d33(%rip), %rsi      # 0x6109
movq %r15, %rdi
callq 0x2150
pushq $0x2
popq %rsi
movq %rax, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x20b0
leaq 0x1d25(%rip), %rsi      # 0x611d
movq %r15, %rdi
callq 0x2150
pushq $0xc
popq %rsi
movq %rax, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x20b0
leaq 0x1d20(%rip), %rsi      # 0x613a
movq %r15, %rdi
callq 0x2150
pushq $0x5
popq %rsi
movq %rax, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x20b0
movq %r15, %rdi
callq 0x20b0
leaq 0x18(%rbx), %r15
xorl %r12d, %r12d
leaq 0x1d19(%rip), %r13      # 0x6164
leaq 0x1d1b(%rip), %rbp      # 0x616d
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
shrq $0x5, %rax
cltq
cmpq %rax, %r12
jge 0x4502
movq %r15, %rdi
movq %r12, %rsi
callq 0x46e4
movq 0x5b5d(%rip), %rdi      # 0x9fd8
movq %rax, %rsi
callq 0x2140
movq %rax, %rdi
leaq 0x1cc9(%rip), %rsi      # 0x6156
callq 0x2150
movq %rax, %rdi
leaq 0x1cbc(%rip), %rsi      # 0x6158
callq 0x2150
movq %rax, %r14
movq %rbx, %rdi
movl %r12d, %esi
callq 0x4214
movq %r14, %rdi
callq 0x2100
movq %rax, %rdi
leaq 0x1bad(%rip), %rsi      # 0x606e
callq 0x2150
movq %rax, %rdi
movq %r13, %rsi
callq 0x2150
movq %rax, %r14
movq %rbx, %rdi
movl %r12d, %esi
callq 0x42ac
movq %r14, %rdi
callq 0x2100
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x20b0
incq %r12
jmp 0x4452
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/8igMac[P]random-forest/src/decision_tree.cpp
// Function: formatHandler::handle_format[abi:cxx11](char*)
vector<string> formatHandler::handle_format(char* fileName)
{
	ifstream ifs(fileName, ifstream::in);
	string buffer;
	vector<string> formatTb;
	
	// set number of attrubutes 
	// and number of classes(labels)
	ifs >> num_attr >> num_cls >> num_inst;

	// set format table
	while (ifs >> buffer)
		formatTb.push_back(buffer);

	ifs.close();
	return formatTb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
pushq $0x8
popq %rax
movq %r15, %rdi
movq %rdx, %rsi
movl %eax, %edx
callq 0x2240
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x20d0
leaq 0x4(%r14), %rsi
movq %rax, %rdi
callq 0x20d0
addq $0x8, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x20d0
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x45ab
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4aea
jmp 0x4585
leaq 0x28(%rsp), %rdi
callq 0x2040
leaq 0x8(%rsp), %rdi
callq 0x20a0
leaq 0x28(%rsp), %rdi
callq 0x2050
movq %rbx, %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %r15
retq
jmp 0x45db
movq %rax, %r14
movq %rbx, %rdi
callq 0x26f8
leaq 0x8(%rsp), %rdi
callq 0x20a0
leaq 0x28(%rsp), %rdi
callq 0x2050
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH06_Functions/examples/arrRet.cc
// Function: main
int main()
{
	int *p = elemPtr(6);         // p points to an int
	int (*arrP)[5] = arrPtr(5);  // arrP points to an array of five ints
	int (&arrR)[5] = arrRef(4);  // arrR refers to an array of five ints

	for (size_t i = 0; i < 5; ++i)
		// p points to an element in an array, which we subscript
		cout << p[i] << endl;  

	for (size_t i = 0; i < 5; ++i)
		// arrP points to an array, 
		// we must dereference the pointer to get the array itself
		cout << (*arrP)[i] << endl;

	for (size_t i = 0; i < 5; ++i)
		// arrR refers to an array, which we can subscript
		cout << arrR[i] << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %r15d, %r15d
leaq 0x2e6b(%rip), %r14      # 0x4080
movq 0x2dbc(%rip), %rbx      # 0x3fd8
cmpq $0x14, %r15
je 0x123c
movl (%r15,%r14), %esi
movq %rbx, %rdi
callq 0x1060
movq %rax, %rdi
callq 0x1030
addq $0x4, %r15
jmp 0x121c
xorl %r15d, %r15d
leaq 0x2e1a(%rip), %r12      # 0x4060
movq 0x2d8b(%rip), %rbx      # 0x3fd8
cmpq $0x14, %r15
je 0x126d
movl (%r15,%r12), %esi
movq %rbx, %rdi
callq 0x1060
movq %rax, %rdi
callq 0x1030
addq $0x4, %r15
jmp 0x124d
xorl %r15d, %r15d
movq 0x2d61(%rip), %rbx      # 0x3fd8
cmpq $0x14, %r15
je 0x1297
movl (%r15,%r14), %esi
movq %rbx, %rdi
callq 0x1060
movq %rax, %rdi
callq 0x1030
addq $0x4, %r15
jmp 0x1277
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mrexodia[P]AsmParser/AsmParser.cpp
// Function: AsmParser::appendToken(AsmParser::Token::Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void appendToken(Token::Type type, const std::string & data)
    {
        Token t;
        t.type = type;
        t.data = data;
        mTokens.push_back(t);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r14
leaq -0x30(%rbp), %rbx
movb $0x0, (%rax)
movl %esi, -0x18(%rax)
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x10d0
addq $0x40, %r14
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x231e
movq %rbx, %rdi
callq 0x10b0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x10b0
movq %r14, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O2/mrexodia[P]AsmParser/AsmParser.cpp
// Function: AsmParser::getTokenType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Token::Type getTokenType(const std::string & data)
    {
        if(mSegments.count(data))
            return Token::Segment;
        if(mMemsizes.count(data))
            return Token::Memsize;
        if(mRegisters.count(data))
            return Token::Register;
        if(mPrefixes.count(data))
            return Token::Prefix;
        if(data == "ptr")
            return Token::Ptr;
        if(mTokens.empty() || mTokens[mTokens.size() - 1].type == Token::Prefix)
            return Token::Mnemonic;        
        return Token::Unknown;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x100, %rdi            # imm = 0x100
callq 0x22da
testq %rax, %rax
je 0x224e
pushq $0x7
jmp 0x22c3
leaq 0xc8(%rbx), %rdi
movq %r14, %rsi
callq 0x22da
testq %rax, %rax
je 0x2266
pushq $0x5
jmp 0x22c3
leaq 0x58(%rbx), %rdi
movq %r14, %rsi
callq 0x22da
testq %rax, %rax
je 0x227b
pushq $0x3
jmp 0x22c3
leaq 0x90(%rbx), %rdi
movq %r14, %rsi
callq 0x22da
testq %rax, %rax
je 0x2293
pushq $0x1
jmp 0x22c3
leaq 0xe51(%rip), %rsi       # 0x30eb
movq %r14, %rdi
callq 0x22c9
testb %al, %al
je 0x22aa
pushq $0x6
jmp 0x22c3
movq 0x48(%rbx), %rcx
cmpq %rcx, 0x40(%rbx)
je 0x22c1
xorl %eax, %eax
cmpl $0x1, -0x28(%rcx)
sete %al
addl %eax, %eax
jmp 0x22c4
pushq $0x2
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH19_SpecializedToolsAndTechniques/examples/useScreen.cc
// Function: xfcn()
void xfcn()
{
	function<int (X*, int)> f;
	f = &X::foo;		// pointer to member

	X x;
	int v = f(&x, 5);
	cout << "v = " << v << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rbx
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
leaq 0x1ac(%rip), %rax       # 0x1406
leaq -0x18(%rbp), %rsi
movq %rax, (%rsi)
andq $0x0, 0x8(%rsi)
movq %rbx, %rdi
callq 0x144c
leaq -0x18(%rbp), %rsi
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0x14c6
movl %eax, %ebx
movq 0x2d52(%rip), %rdi      # 0x3fd8
leaq 0xd77(%rip), %rsi       # 0x2004
callq 0x10a0
movq %rax, %rdi
movl %ebx, %esi
callq 0x10e0
movq %rax, %rdi
callq 0x1070
leaq -0x40(%rbp), %rdi
callq 0x156e
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x156e
movq %rbx, %rdi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O2/wkohlenberg[P]simple_NN/src/createTrainData.cpp
// Function: main
int main()
{
  ofstream trainData ("input/xor_train_data.txt", ios::out);
  if (trainData.is_open())
  {
    // Real random
    random_device rd;
    mt19937 gen(rd());
    uniform_int_distribution<> dis(0, 1);

    int input1, input2;

    for (int i = 0; i < TRAINING_INPUT; i++)
    {
      input1 = dis(gen);
      input2 = dis(gen);
      trainData << "in: " << input1 << " " << input2 << endl;
      trainData << "out: " << (input1^input2) << endl;
    }

    trainData.close();
  }
  else
  {
    cout << "Could not open file..." << endl;
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2918, %rsp           # imm = 0x2918
leaq 0xd50(%rip), %rsi       # 0x2004
leaq 0x8(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0x10e0
leaq 0x78(%rsp), %rdi
callq 0x1030
testb %al, %al
je 0x13a9
leaq 0x208(%rsp), %rdi
callq 0x1428
leaq 0x208(%rsp), %rdi
callq 0x10f0
movl %eax, %esi
leaq 0x1590(%rsp), %rdi
callq 0x1572
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rsp, %rbx
movq %rax, (%rbx)
movl $0x7d0, %ebp            # imm = 0x7D0
leaq 0x1590(%rsp), %r14
leaq 0x8(%rsp), %r12
subl $0x1, %ebp
jb 0x13c6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x147e
movl %eax, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x147e
movl %eax, %r13d
movq %r12, %rdi
leaq 0xcd0(%rip), %rsi       # 0x201d
callq 0x10d0
movq %rax, %rdi
movl %r15d, %esi
callq 0x1140
movq %rax, %rdi
leaq 0xcb9(%rip), %rsi       # 0x2020
callq 0x10d0
movq %rax, %rdi
movl %r13d, %esi
callq 0x1140
movq %rax, %rdi
callq 0x1080
movq %r12, %rdi
leaq 0xc99(%rip), %rsi       # 0x2022
callq 0x10d0
xorl %r15d, %r13d
movq %rax, %rdi
movl %r13d, %esi
callq 0x1140
movq %rax, %rdi
callq 0x1080
jmp 0x131e
movq 0x2c28(%rip), %rdi      # 0x3fd8
leaq 0xc71(%rip), %rsi       # 0x2028
callq 0x10d0
movq %rax, %rdi
callq 0x1080
jmp 0x13dd
leaq 0x8(%rsp), %rdi
callq 0x1100
leaq 0x208(%rsp), %rdi
callq 0x1486
leaq 0x8(%rsp), %rdi
callq 0x1110
xorl %eax, %eax
addq $0x2918, %rsp           # imm = 0x2918
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1406
jmp 0x1401
jmp 0x1406
movq %rax, %rbx
jmp 0x1416
movq %rax, %rbx
leaq 0x208(%rsp), %rdi
callq 0x1486
leaq 0x8(%rsp), %rdi
callq 0x1110
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsepp/test-1.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	spp::sparse_hash_map<uint32_t, uint32_t, Hash32> h;
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
		auto p = h.emplace(get_key(n, x), 0);
		z += ++p.first->second;
	}
	fprintf(stderr, "# unique keys: %ld; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %r14d
movl %edi, %r12d
xorl %ebx, %ebx
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x4(%rsp), %rcx
movq %rsp, %r8
xorl %esi, %esi
movq %rcx, %r13
movq %r8, %r15
callq 0x15f4
movl %r12d, %ebp
subl $0x1, %ebp
jb 0x159e
movl %r14d, %edi
callq 0x12ac
movl %eax, %r14d
movl %r12d, %edi
movl %eax, %esi
callq 0x12d7
movl %eax, 0x4(%rsp)
andl $0x0, (%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x19d0
movq 0x10(%rsp), %rax
movl 0x4(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x4(%rax)
addl %ecx, %ebx
incl %ebx
jmp 0x1553
movq 0x5a33(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
leaq 0x50(%rsp), %r14
movq 0x18(%r14), %rdx
leaq 0x1ad1(%rip), %rsi      # 0x3089
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1100
movl 0x18(%r14), %ebx
movq %r14, %rdi
callq 0x1610
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x1610
movq %rbx, %rdi
callq 0x1150
nop
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparsetable<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_free_groups()
void _free_groups()
    {
        if (_first_group)
        {
            for (group_type *g = _first_group; g != _last_group; ++g)
                g->destruct(_alloc);
            _free_group_array(_first_group, _last_group);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x166a
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
leaq 0x21(%rdi), %r12
cmpq (%r15), %r14
je 0x1651
movq %r14, %rdi
movq %r12, %rsi
callq 0x1682
addq $0x18, %r14
jmp 0x163b
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x168c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparsehash_internal::sh_hashtable_settings<unsigned int, Hash32, unsigned long, 4>::min_buckets(unsigned long, unsigned long)
size_type min_buckets(size_type num_elts, size_type min_buckets_wanted)
        {
            float enlarge = enlarge_factor();
            size_type sz = HT_MIN_BUCKETS;             // min buckets allowed
            while (sz < min_buckets_wanted ||
                   num_elts >= static_cast<size_type>(sz * enlarge))
            {
                // This just prevents overflowing size_type, since sz can exceed
                // max_size() here.
                // -------------------------------------------------------------
                if (static_cast<size_type>(sz * 2) < sz)
                    throw_exception(std::length_error("resize overflow"));  // protect against overflow
                sz *= 2;
            }
            return sz;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movss 0x10(%rdi), %xmm0
movss %xmm0, 0xc(%rsp)
pushq $0x4
popq %rax
leaq 0x193f(%rip), %r15      # 0x30ab
leaq 0x10(%rsp), %r12
cmpq %rbx, %rax
jb 0x17c3
testq %rax, %rax
js 0x1782
cvtsi2ss %rax, %xmm0
jmp 0x1799
movq %rax, %rcx
shrq %rcx
movl %eax, %edx
andl $0x1, %edx
orq %rcx, %rdx
cvtsi2ss %rdx, %xmm0
addss %xmm0, %xmm0
mulss 0xc(%rsp), %xmm0
cvttss2si %xmm0, %rcx
movq %rcx, %rdx
subss 0x1881(%rip), %xmm0     # 0x3030
cvttss2si %xmm0, %rsi
sarq $0x3f, %rdx
andq %rdx, %rsi
orq %rcx, %rsi
cmpq %r14, %rsi
ja 0x17ef
leaq (%rax,%rax), %r13
testq %rax, %rax
movq %r13, %rax
jns 0x1771
movq %r12, %rdi
movq %r15, %rsi
callq 0x10c0
movq %r12, %rdi
callq 0x18b7
movq %r12, %rdi
callq 0x1178
movq %r13, %rax
jmp 0x1771
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1178
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparsetable<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_alloc_group_array(unsigned long, spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>*&, spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>*&)
void _alloc_group_array(group_size_type sz, group_type *&first, group_type *&last)
    {
        if (sz)
        {
            first = _group_alloc.allocate((size_type)(sz + 1)); // + 1 for end marker
            first[sz].mark();                      // for the ne_iterator
            last = first + sz;
        }
    }

// Assembly:
testq %rsi, %rsi
je 0x1989
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
imulq $0x18, %rsi, %r15
leaq 0x18(%r15), %rdi
callq 0x10f0
movq %rax, (%r14)
leaq (%rax,%r15), %rcx
orq $-0x1, (%rax,%r15)
movq %rcx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: std::pair<spp::Two_d_iterator<std::pair<unsigned int const, unsigned int>, spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>*, std::pair<unsigned int const, unsigned int>*, std::bidirectional_iterator_tag>, bool> spp::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SelectKey, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_insert_noresize<std::pair<unsigned int const, unsigned int>>(std::pair<unsigned int const, unsigned int>&)
std::pair<iterator, bool> _insert_noresize(T& obj)
    {
        Position pos = _find_position(get_key(obj));
        bool already_there = (pos._t == pt_full);

        if (!already_there)
        {
            reference ref(_insert_at(obj, pos._idx, pos._t == pt_erased));
            return std::pair<iterator, bool>(_mk_iterator(table.get_iter(pos._idx, &ref)), true);
        }
        return std::pair<iterator,bool>(_mk_iterator(table.get_iter(pos._idx)), false);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x249c
movq %rdx, %r15
cmpl $0x2, %eax
jne 0x1bb5
addq $0x30, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x267a
xorl %ecx, %ecx
jmp 0x1bdf
xorl %ecx, %ecx
cmpl $0x1, %eax
sete %cl
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x25a2
addq $0x30, %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2652
movb $0x1, %cl
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movb %cl, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SelectKey, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::swap(spp::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SelectKey, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>&)
void swap(sparse_hashtable& ht)
    {
        using std::swap;

        swap(settings, ht.settings);
        swap(key_info, ht.key_info);
        swap(num_deleted, ht.num_deleted);
        table.swap(ht.table);
        settings.reset_thresholds(bucket_count());  // also resets consider_shrink
        ht.settings.reset_thresholds(ht.bucket_count());
        // we purposefully don't swap the allocator, which may not be swap-able
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
movq 0x28(%rdi), %rax
movq 0x28(%rsi), %rcx
movq %rcx, 0x28(%rdi)
movq %rax, 0x28(%rsi)
addq $0x30, %rdi
addq $0x30, %rsi
callq 0x219a
movq 0x40(%r14), %rsi
movq %r14, %rdi
callq 0x183e
movq 0x40(%rbx), %rsi
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x183e
nop
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SelectKey, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::clear()
void clear()
    {
        if (!empty() || num_deleted != 0)
        {
            table.clear();
            table = Table(HT_DEFAULT_STARTING_BUCKETS, table.get_allocator());
        }
        settings.reset_thresholds(bucket_count());
        num_deleted = 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
orq 0x48(%rdi), %rax
je 0x1f92
leaq 0x30(%rbx), %r14
movq %r14, %rdi
callq 0x2150
leaq 0x8(%rsp), %r15
pushq $0x20
popq %rsi
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x1812
movq %r14, %rdi
movq %r15, %rsi
callq 0x2162
leaq 0x8(%rsp), %rdi
callq 0x1610
movq 0x40(%rbx), %rsi
movq %rbx, %rdi
callq 0x183e
andq $0x0, 0x28(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1610
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::Two_d_destructive_iterator<std::pair<unsigned int const, unsigned int>, spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>*, std::pair<unsigned int const, unsigned int>*, std::input_iterator_tag, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::Two_d_destructive_iterator(spp::libc_allocator<std::pair<unsigned int const, unsigned int>>&, spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>*)
Two_d_destructive_iterator(Alloc &alloc, row_it curr) :
        _alloc(alloc)
    {
        this->row_current = curr;
        this->col_current = 0;
        if (this->row_current && !this->row_current->is_marked())
        {
            this->col_current = this->row_current->ne_begin();
            advance_past_end();                 // in case cur->begin() == cur->end()
        }
    }

// Assembly:
movq %rsi, 0x10(%rdi)
movq %rdx, (%rdi)
andq $0x0, 0x8(%rdi)
testq %rdx, %rdx
je 0x2211
movq (%rdx), %rax
cmpq $-0x1, %rax
je 0x2211
movq %rax, 0x8(%rdi)
jmp 0x2212
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::Two_d_destructive_iterator<std::pair<unsigned int const, unsigned int>, spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>*, std::pair<unsigned int const, unsigned int>*, std::input_iterator_tag, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::advance_past_end()
void advance_past_end()
    {
        // used when col_current points to end()
        while (this->col_current == this->row_current->ne_end())
        {
            this->row_current->clear(_alloc, true);  // This is what differs from non-destructive iterators above

            // end of current row
            // ------------------
            ++this->row_current;                          // go to beginning of next
            if (!this->row_current->is_marked())          // col is irrelevant at end
                this->col_current = this->row_current->ne_begin();
            else
                break;                                    // don't go past row_end
        }
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rcx
movq (%rdi), %rax
pushq $0x1
popq %rbp
movzbl 0x10(%rdi), %edx
leaq (%rax,%rdx,8), %rax
cmpq %rax, %rcx
jne 0x225a
movq 0x10(%rbx), %rsi
movl %ebp, %edx
callq 0x2262
movq (%rbx), %rax
leaq 0x18(%rax), %rdi
movq %rdi, (%rbx)
movq 0x18(%rax), %rax
cmpq $-0x1, %rax
je 0x225a
movq %rax, 0x8(%rbx)
movq %rax, %rcx
jmp 0x2225
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::clear(spp::libc_allocator<std::pair<unsigned int const, unsigned int>>&, bool)
void clear(allocator_type &alloc, bool erased)
    {
        _free_group(alloc, _num_alloc());
        _bitmap = 0;
        if (erased)
            _bm_erased = 0;
        _set_num_items(0);
        _set_num_alloc(0);
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movzbl 0x11(%rdi), %edx
callq 0x16b4
andl $0x0, 0x8(%rbx)
testl %ebp, %ebp
je 0x227f
andl $0x0, 0xc(%rbx)
andw $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: std::pair<unsigned int const, unsigned int>* spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::set<std::pair<unsigned int const, unsigned int>>(spp::libc_allocator<std::pair<unsigned int const, unsigned int>>&, unsigned char, std::pair<unsigned int const, unsigned int>&)
pointer set(allocator_type &alloc, size_type i, Val &val)
    {
        _bme_clear(i); // in case this was an "erased" location

        size_type offset = pos_to_offset(i);
        _set(alloc, i, offset, val);            // may change _group pointer
        return (pointer)(_group + offset);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r8
movl %edx, %ecx
movq %rdi, %rbx
pushq $-0x2
popq %rax
roll %cl, %eax
andl %eax, 0xc(%rdi)
pushq $-0x1
popq %rax
shll %cl, %eax
notl %eax
andl 0x8(%rdi), %eax
movl %eax, %edx
shrl %edx
andl $0x15555555, %edx       # imm = 0x15555555
subl %edx, %eax
movl $0x33333333, %edx       # imm = 0x33333333
movl %eax, %edi
andl %edx, %edi
shrl $0x2, %eax
andl %edx, %eax
addl %edi, %eax
movl %eax, %edx
shrl $0x4, %edx
addl %eax, %edx
andl $0xf0f0f0f, %edx        # imm = 0xF0F0F0F
imull $0x1010101, %edx, %r14d # imm = 0x1010101
shrl $0x18, %r14d
movq %rbx, %rdi
movl %ecx, %edx
movl %r14d, %ecx
callq 0x2338
shll $0x3, %r14d
addq (%rbx), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: void spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_set<std::pair<unsigned int const, unsigned int>>(spp::libc_allocator<std::pair<unsigned int const, unsigned int>>&, unsigned char, unsigned char, std::pair<unsigned int const, unsigned int>&)
void _set(allocator_type &alloc, size_type i, size_type offset, Val &val)
    {
        if (!_bmtest(i))
        {
            _set_aux(alloc, offset, val, check_alloc_type());
            _incr_num_items();
            _bmset(i);
        }
        else
            _set_val(&_group[offset], val);
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %ecx, %eax
movl %edx, %ecx
movq %rdi, %rbx
movl 0x8(%rdi), %edx
pushq $0x1
popq %rbp
shll %cl, %ebp
btl %ecx, %edx
jae 0x2365
movq (%rbx), %rcx
movzbl %al, %eax
movl (%r8), %edx
movl %edx, (%rcx,%rax,8)
movl 0x4(%r8), %edx
movl %edx, 0x4(%rcx,%rax,8)
jmp 0x2379
movzbl %al, %edx
movq %rbx, %rdi
movq %r8, %rcx
callq 0x2380
incb 0x10(%rbx)
orl %ebp, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: void spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_set_aux<std::pair<unsigned int const, unsigned int>>(spp::libc_allocator<std::pair<unsigned int const, unsigned int>>&, unsigned char, std::pair<unsigned int const, unsigned int>&, spp::integral_constant<bool, true>)
void _set_aux(allocator_type &alloc, size_type offset, Val &val, realloc_ok_type)
    {
        //static int x=0;  if (++x < 10) printf("x\n"); // check we are getting here

        uint32_t  num_items = _num_items();
        uint32_t  num_alloc = _sizing(num_items);

        if (num_items == num_alloc)
        {
            num_alloc = _sizing(num_items + 1);
            _group = alloc.reallocate(_group, num_alloc);
            _set_num_alloc(num_alloc);
        }

        for (uint32_t i = num_items; i > offset; --i)
            memcpy(_group + i, _group + i-1, sizeof(*_group));

        _init_val((mutable_pointer)(_group + offset), val);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
movzbl 0x10(%rdi), %r15d
movl %r15d, %edi
callq 0x23f0
cmpl %r15d, %eax
jne 0x23c3
leal 0x1(%r15), %edi
callq 0x23f0
movl %eax, %r12d
movq (%r14), %rdi
movl %eax, %esi
shlq $0x3, %rsi
callq 0x1120
movq %rax, (%r14)
movb %r12b, 0x11(%r14)
movl %r15d, %ecx
movzbl %bpl, %eax
movq (%r14), %rdx
cmpq %rax, %rcx
jbe 0x23e0
movq -0x8(%rdx,%rcx,8), %rsi
movq %rsi, (%rdx,%rcx,8)
decq %rcx
jmp 0x23ca
movq (%rbx), %rcx
movq %rcx, (%rdx,%rax,8)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_sizing(unsigned int)::alloc_batch_size::alloc_batch_size()
SPP_CXX14_CONSTEXPR alloc_batch_size()
                : data()
            {
                uint8_t group_sz          = SPP_GROUP_SIZE / 4;
                uint8_t group_start_alloc = SPP_GROUP_SIZE / 8; //4;
                uint8_t alloc_sz          = group_start_alloc;
                for (int i=0; i<4; ++i)
                {
                    for (int j=0; j<group_sz; ++j)
                    {
                        if (j && j % group_start_alloc == 0)
                            alloc_sz += group_start_alloc;
                        data[i * group_sz + j] = alloc_sz;
                    }
                    if (group_start_alloc > 2)
                        group_start_alloc /= 2;
                    alloc_sz += group_start_alloc;
                }
            }

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movb $0x4, %al
xorl %edx, %edx
xorl %esi, %esi
movb $0x4, %r8b
cmpq $0x4, %rsi
je 0x249a
leal 0x7(%rax), %ecx
movzbl %al, %r9d
xorl %r10d, %r10d
cmpq $0x8, %r10
je 0x2487
testb %r10b, %cl
movl $0x0, %r11d
cmovel %r9d, %r11d
testq %r10, %r10
cmovel %edx, %r11d
addb %r11b, %r8b
movb %r8b, (%rdi,%r10)
incq %r10
jmp 0x2461
cmpb $0x3, %al
setae %cl
shrb %cl, %al
addb %al, %r8b
incq %rsi
addq $0x8, %rdi
jmp 0x2451
retq
nop