LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/UnlabeledMultiArg.h
// Function: TCLAP::UnlabeledMultiArg<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::processArg(int*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
bool UnlabeledMultiArg<T>::processArg(int *i, std::vector<std::string>& args) 
{

	if ( _hasBlanks( args[*i] ) )
		return false;

	// never ignore an unlabeled multi arg


	// always take the first value, regardless of the start string 
	_extractValue( args[(*i)] );

	/*
	// continue taking args until we hit the end or a start string 
	while ( (unsigned int)(*i)+1 < args.size() &&
			args[(*i)+1].find_first_of( Arg::flagStartString() ) != 0 &&
            args[(*i)+1].find_first_of( Arg::nameStartString() ) != 0 ) 
		_extractValue( args[++(*i)] );
	*/

	_alreadySet = true;

	return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq (%rsi), %rax
movq (%rdx), %rcx
shlq $0x5, %rax
leaq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rax
cmpq $0x2, %rax
jb 0xfd7c
movq (%rsi), %rcx
cmpb $0x7, 0x1(%rcx)
je 0xfd78
movl $0x2, %edi
movq %rdi, %rdx
cmpq %rdi, %rax
je 0xfd73
leaq 0x1(%rdx), %rdi
cmpb $0x7, (%rcx,%rdx)
jne 0xfd61
cmpq %rdx, %rax
jbe 0xfd7c
xorl %eax, %eax
jmp 0xfd8d
movq %rbx, %rdi
callq 0xcd58
movb $0x1, 0x91(%rbx)
movb $0x1, %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/UnlabeledMultiArg.h
// Function: TCLAP::UnlabeledMultiArg<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator==(TCLAP::Arg const&) const
bool UnlabeledMultiArg<T>::operator==(const Arg& a) const
{
	if ( _name == a.getName() || _description == a.getDescription() )
		return true;
	else
		return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x30(%rdi), %rdx
cmpq 0x30(%rsi), %rdx
jne 0xfdc1
movb $0x1, %bl
testq %rdx, %rdx
je 0xfe19
movq 0x28(%r15), %rsi
movq 0x28(%r14), %rdi
callq 0x41d0
testl %eax, %eax
je 0xfe19
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa57c
movq 0x50(%r14), %rdx
cmpq 0x8(%rbx), %rdx
jne 0xfdf5
movq (%rsp), %r15
testq %rdx, %rdx
je 0xfdfd
movq 0x48(%r14), %rdi
movq %r15, %rsi
callq 0x41d0
testl %eax, %eax
sete %bl
jmp 0xfdff
movq (%rsp), %r15
xorl %ebx, %ebx
jmp 0xfdff
movb $0x1, %bl
leaq 0x10(%rsp), %rax
cmpq %rax, %r15
je 0xfe19
movq 0x10(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x41c0
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/deepaktabraham[P]BPlus-Tree/src/tree.cpp
// Function: BPlusTree::Search_Path(Node*, float, std::stack<Node*, std::deque<Node*, std::allocator<Node*>>>*)
void BPlusTree :: Search_Path(Node* node, float key, stack<Node*>* path)
{
	// push node to stack
        path->push(node);

	// check if the node pushed to stack is an internal node
	if(!node->Get_IsLeaf())
        {
		// search for the given key in the current node
		vector<float> keys = node->Get_Keys();
		vector<Node*> children = node->Get_Children();
                vector<float>::iterator index = lower_bound(keys.begin(), keys.end(), key);

		// check if key is found
		if(key == keys[index - keys.begin()])
		{
			// recursively repeat by searching the path through the corresponding right child index
                	Search_Path(children[(index - keys.begin()) + 1], key, path);
		}

		// if key is not found
		else
		{
			// recursively repeat by searching the path through the corresponding left child index
			Search_Path(children[index - keys.begin()], key, path);
		}
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movss %xmm0, -0x24(%rbp)
movq %rdi, %r14
movq %rsi, -0x20(%rbp)
movq 0x30(%rdx), %rax
movq 0x40(%rdx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x2d3b
movq %rsi, (%rax)
addq $0x8, 0x30(%rbx)
jmp 0x2d4d
leaq -0x20(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3aa6
movq (%r15), %rsi
movq %rsi, %rdi
callq 0x3ed4
testb %al, %al
jne 0x2e0f
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x3ede
movq -0x20(%rbp), %rsi
movq (%rsi), %rax
leaq -0x58(%rbp), %rdi
callq *0x30(%rax)
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
movq %rax, %rcx
testq %rdx, %rdx
movss -0x24(%rbp), %xmm0
jle 0x2db9
movq %rax, %rcx
movq %rdx, %rsi
shrq %rsi
ucomiss (%rcx,%rsi,4), %xmm0
jbe 0x2db1
leaq (%rcx,%rsi,4), %rcx
addq $0x4, %rcx
notq %rsi
addq %rdx, %rsi
movq %rsi, %rdx
testq %rsi, %rsi
jg 0x2d9a
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
movss (%rcx), %xmm1
ucomiss %xmm0, %xmm1
movq -0x58(%rbp), %rax
jne 0x2de4
jp 0x2de4
movq 0x8(%rax,%rdx,8), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2d04
jmp 0x2df3
movq (%rax,%rdx,8), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2d04
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x2e01
callq 0x2150
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x2e0f
callq 0x2150
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e1c
movq %rax, %rbx
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x2e32
callq 0x2150
jmp 0x2e32
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x2e40
callq 0x2150
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/deepaktabraham[P]BPlus-Tree/src/tree.cpp
// Function: BPlusTree::Destroy(Node*)
void BPlusTree :: Destroy(Node* node)
{
	// recursively repeat the function to delete all the nodes level by level, starting with the leaf nodes
	if (!node->Get_IsLeaf())
	{
  	        vector<Node*> children = node->Get_Children();
                for(vector<Node*>::iterator index = children.begin(); index != children.end(); index++)
                {
                        Destroy(*index);
        	}
	}
	delete(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3ed4
testb %al, %al
jne 0x2eaa
movq (%rbx), %rax
leaq -0x38(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq *0x30(%rax)
movq (%r12), %r15
cmpq 0x8(%r12), %r15
je 0x2e9d
movq (%r15), %rsi
movq %r14, %rdi
callq 0x2e48
addq $0x8, %r15
cmpq -0x30(%rbp), %r15
jne 0x2e84
movq -0x38(%rbp), %r15
testq %r15, %r15
je 0x2eaa
movq %r15, %rdi
callq 0x2150
leaq 0x5dc7(%rip), %rax      # 0x8c78
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2ec2
callq 0x2150
movq %rbx, %rdi
callq 0x2150
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x2ee8
callq 0x2150
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/deepaktabraham[P]BPlus-Tree/src/internalnode.cpp
// Function: InternalNode::Insert(float, Node*)
void InternalNode :: Insert(float key, Node* rightChild)
{
	// insert key in to suitable position in the given internal node
	vector<float>::iterator index = lower_bound(keys.begin(), keys.end(), key);
	keys.insert(index, key);

	// insert right child in the immediately next index in the children vector
	index = lower_bound(keys.begin(), keys.end(), key);
	children.insert(children.begin() + (index - keys.begin() + 1), rightChild);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
addq $0x10, %rdi
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rcx
subq %rsi, %rcx
sarq $0x2, %rcx
testq %rcx, %rcx
jle 0x4011
movq %rcx, %rax
shrq %rax
ucomiss (%rsi,%rax,4), %xmm0
jbe 0x4009
leaq (%rsi,%rax,4), %rsi
addq $0x4, %rsi
notq %rax
addq %rcx, %rax
movq %rax, %rcx
testq %rax, %rax
jg 0x3ff2
leaq -0xc(%rbp), %rdx
callq 0x422e
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
testq %rdx, %rdx
jle 0x405a
movss -0xc(%rbp), %xmm0
movq %rax, %rcx
movq %rdx, %rsi
shrq %rsi
ucomiss (%rcx,%rsi,4), %xmm0
jbe 0x4050
leaq (%rcx,%rsi,4), %rcx
addq $0x4, %rcx
notq %rsi
addq %rdx, %rsi
movq %rsi, %rdx
testq %rsi, %rsi
jg 0x4039
jmp 0x405d
movq %rax, %rcx
movq 0x28(%rbx), %rdx
addq $0x28, %rbx
subq %rax, %rcx
leaq (%rdx,%rcx,2), %rsi
addq $0x8, %rsi
leaq -0x18(%rbp), %rdx
movq %rbx, %rdi
callq 0x42c2
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/deepaktabraham[P]BPlus-Tree/src/internalnode.cpp
// Function: InternalNode::Insert(float, Node*, Node*)
void InternalNode :: Insert(float key, Node* leftChild, Node* rightChild)
{
	// insert key, left child and right child
	keys.push_back(key);
	children.push_back(leftChild);
	children.push_back(rightChild);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movss %xmm0, -0x24(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq 0x18(%rdi), %rsi
cmpq 0x20(%rdi), %rsi
je 0x40c1
movss %xmm0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%r14)
jmp 0x40ce
leaq 0x10(%r14), %rdi
leaq -0x24(%rbp), %rdx
callq 0x43c4
leaq 0x28(%r14), %r12
movq 0x30(%r14), %rsi
cmpq 0x38(%r14), %rsi
je 0x40ed
movq %r15, (%rsi)
movq 0x30(%r14), %rsi
addq $0x8, %rsi
movq %rsi, 0x30(%r14)
jmp 0x40fd
leaq -0x38(%rbp), %rdx
movq %r12, %rdi
callq 0x44e2
movq 0x30(%r14), %rsi
cmpq 0x38(%r14), %rsi
je 0x410d
movq %rbx, (%rsi)
addq $0x8, 0x30(%r14)
jmp 0x4119
leaq -0x30(%rbp), %rdx
movq %r12, %rdi
callq 0x44e2
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/deepaktabraham[P]BPlus-Tree/src/internalnode.cpp
// Function: InternalNode::Split(float*)
Node* InternalNode :: Split(float* keyToParent)
{
	int length = keys.size();

	// create a new right internal node
	InternalNode* rightNode = new InternalNode;

	// key to be moved up to the parent is the middle element in the current internal node
	*keyToParent = keys[length/2];

	// Copy the second half of the current internal node excluding the middle element to the 
	// new right internal node. Erase the second half of the current internal node including 
	// the middle element, and thus current internal node becomes the left internal node.
	rightNode->keys.assign(keys.begin() + (length/2 + 1), keys.end());
	rightNode->children.assign(children.begin() + (length/2 + 1), children.end());
	keys.erase(keys.begin() + length/2, keys.end());
	children.erase(children.begin() + (length/2 + 1), children.end());

	// return the new right internal node
	return rightNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rbx
movq 0x10(%rdi), %r12
movq 0x18(%rdi), %r13
movq %r13, -0x40(%rbp)
subq %r12, %r13
shrq $0x2, %r13
movl $0x40, %edi
callq 0x2170
movq %rax, %r14
leaq 0x10(%rax), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %eax, %eax
movq %rax, 0x20(%r14)
leaq 0x4b6a(%rip), %rcx      # 0x8ce0
movq %rcx, (%r14)
leaq 0x28(%r14), %rcx
movq %rcx, -0x30(%rbp)
movups %xmm0, 0x28(%r14)
movq %rax, 0x38(%r14)
movb $0x0, 0x8(%r14)
movl %r13d, %eax
shrl $0x1f, %eax
addl %r13d, %eax
sarl %eax
movslq %eax, %r15
leaq (,%r15,4), %r13
leaq (%r12,%r15,4), %rsi
addq $0x4, %rsi
movss -0x4(%rsi), %xmm0
movq -0x38(%rbp), %rax
movss %xmm0, (%rax)
leaq 0x1(%r15), %r12
movq -0x40(%rbp), %rdx
callq 0x461c
leaq 0x8(,%r15,8), %rsi
addq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq -0x30(%rbp), %rdi
callq 0x472a
addq 0x10(%rbx), %r13
cmpq 0x18(%rbx), %r13
je 0x41ee
movq %r13, 0x18(%rbx)
shlq $0x3, %r12
addq 0x28(%rbx), %r12
cmpq 0x30(%rbx), %r12
je 0x4200
movq %r12, 0x30(%rbx)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/deepaktabraham[P]BPlus-Tree/src/leafnode.cpp
// Function: LeafNode::Insert(float, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void LeafNode :: Insert(float key, string value)
{
	// search for the key in the given leaf node
	vector<float>::iterator index = lower_bound(keys.begin(), keys.end(), key);

	// check if inserting a duplicate value for an existing key
	if((0 != keys.size()) && (key == keys[index - keys.begin()]))
	{
		// add the duplicate value for the given key
		values[index - keys.begin()].push_back(value);
	}

	// if inserting a new key and value
	else
	{
		// insert the new key
		keys.insert(index, key);

		//insert the corresponding value
		vector<string> newValue;
		newValue.push_back(value);
		index = lower_bound(keys.begin(), keys.end(), key);	
		values.insert(values.begin() + (index - keys.begin()), newValue);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movss %xmm0, -0x14(%rbp)
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
movq %rax, %rsi
testq %rdx, %rdx
jle 0x48bf
movq %rax, %rsi
movq %rdx, %rdi
shrq %rdi
ucomiss (%rsi,%rdi,4), %xmm0
jbe 0x48b7
leaq (%rsi,%rdi,4), %rsi
addq $0x4, %rsi
notq %rdi
addq %rdx, %rdi
movq %rdi, %rdx
testq %rdi, %rdi
jg 0x48a0
cmpq %rax, %rcx
je 0x48f2
movss (%rsi), %xmm1
ucomiss %xmm0, %xmm1
jne 0x48f2
jp 0x48f2
subq %rax, %rsi
shrq $0x2, %rsi
leaq (%rsi,%rsi,2), %rdi
shlq $0x3, %rdi
addq 0x38(%rbx), %rdi
movq %r14, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x4af2
leaq 0x10(%rbx), %rdi
leaq -0x14(%rbp), %rdx
callq 0x422e
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %r14, %rsi
callq 0x4af2
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
movq %rax, %rcx
testq %rdx, %rdx
jle 0x495a
movss -0x14(%rbp), %xmm0
movq %rax, %rcx
movq %rdx, %rsi
shrq %rsi
ucomiss (%rcx,%rsi,4), %xmm0
jbe 0x4952
leaq (%rcx,%rsi,4), %rcx
addq $0x4, %rcx
notq %rsi
addq %rdx, %rsi
movq %rsi, %rdx
testq %rsi, %rsi
jg 0x493b
subq %rax, %rcx
shrq $0x2, %rcx
leaq (%rcx,%rcx,2), %rsi
shlq $0x3, %rsi
addq 0x38(%rbx), %rsi
addq $0x38, %rbx
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x4b3e
leaq -0x30(%rbp), %rdi
callq 0x3e7c
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4991
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3e7c
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/deepaktabraham[P]BPlus-Tree/src/leafnode.cpp
// Function: LeafNode::Split(float*)
Node* LeafNode :: Split(float* keyToParent)
{
	// create a new right leaf node
	LeafNode* rightNode = new LeafNode;

	// key to be moved up to the parent is the middle element in the current leaf node
	*keyToParent = keys[keys.size()/2];

	// Copy the second half of the current leaf node to the new right leaf node. Erase the second
	// half of the current leaf node, and thus the current leaf node becomes the left leaf node.
	rightNode->keys.assign(keys.begin() + keys.size()/2, keys.end());
	rightNode->values.assign(values.begin() + values.size()/2, values.end());
	keys.erase(keys.begin() + keys.size()/2, keys.end());
	values.erase(values.begin() + values.size()/2, values.end());

	// link the leaf nodes to form a doubly linked list
	rightNode->next = next;
	rightNode->prev = this;
	next = rightNode;
	(rightNode->next)->prev = rightNode;

	// return the right leaf node
	return rightNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl $0x50, %edi
callq 0x2170
movq %rax, %r14
leaq 0x10(%rax), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %eax, %eax
movq %rax, 0x20(%r14)
leaq 0x4371(%rip), %rcx      # 0x8d50
movq %rcx, (%r14)
leaq 0x38(%r14), %r12
movups %xmm0, 0x38(%r14)
movq %rax, 0x48(%r14)
movb $0x1, 0x8(%r14)
movq %r14, 0x28(%r14)
movq %r14, 0x30(%r14)
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rdx
movq %rdx, %rcx
subq %rax, %rcx
sarq %rcx
andq $-0x4, %rcx
leaq (%rax,%rcx), %rsi
movss (%rax,%rcx), %xmm0
movss %xmm0, (%r15)
callq 0x461c
leaq 0x38(%rbx), %r15
movq 0x38(%rbx), %rax
movq 0x40(%rbx), %rdx
movq %rdx, %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r13, %rcx
shrq %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rsi
movq %r12, %rdi
callq 0x5300
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq %rax
andq $-0x4, %rax
addq %rcx, %rax
cmpq %rdx, %rax
je 0x4a7c
movq %rax, 0x18(%rbx)
movq 0x38(%rbx), %rax
movq 0x40(%rbx), %rdx
movq %rdx, %rcx
subq %rax, %rcx
sarq $0x3, %rcx
imulq %r13, %rcx
shrq %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rsi
movq %r15, %rdi
callq 0x5814
movq 0x30(%rbx), %rax
movq %rax, 0x30(%r14)
movq %rbx, 0x28(%r14)
movq %r14, 0x30(%rbx)
movq %r14, 0x28(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/src/kcp_remote.cpp
// Function: remote_kcpin_create(tun_remote_t*)
static int
_remote_kcpin_create(tun_remote_t *tun) {
   ikcp_allocator(kcp_malloc, kcp_free);

   tun->kcpin = ikcp_create(tun->kcpconv, tun);
   if (tun->kcpin == NULL) {
      cerr << "Fail to create kcp in !" << endl;
      return 0;
   }

   ikcp_setoutput(tun->kcpin, _remote_kcpin_callback);
   ikcp_nodelay(tun->kcpin, tun->conf->nodelay, tun->conf->interval, tun->conf->resend, tun->conf->nc);
   ikcp_wndsize(tun->kcpin, tun->conf->snd_wndsize, tun->conf->rcv_wndsize);
   ikcp_setmtu(tun->kcpin, tun->conf->mtu);

   if (tun->conf->fast == 3) {
      tun->kcpin->rx_minrto = 20;
   } else if (tun->conf->fast == 2) {
      tun->kcpin->rx_minrto = 40;
   }
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x92a(%rip), %rdi      # 0x8205
leaq -0x91b(%rip), %rsi      # 0x821b
callq 0x260c
movl 0x50(%rbx), %edi
movq %rbx, %rsi
callq 0x26e3
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x8bda
leaq 0x1ce(%rip), %rsi       # 0x8d28
movq %rax, %rdi
callq 0x2a70
movq 0x48(%rbx), %rdi
movq 0x78(%rbx), %rax
movl 0x130(%rax), %esi
movl 0x134(%rax), %edx
movl 0x138(%rax), %ecx
movl 0x13c(%rax), %r8d
callq 0x3e37
movq 0x48(%rbx), %rdi
movq 0x78(%rbx), %rax
movl 0x128(%rax), %edx
movl 0x12c(%rax), %esi
callq 0x3e88
movq 0x48(%rbx), %rdi
movq 0x78(%rbx), %rax
movl 0x140(%rax), %esi
callq 0x3d96
movq 0x78(%rbx), %rax
movl 0x144(%rax), %ecx
movl $0x1, %eax
cmpl $0x2, %ecx
je 0x8c20
cmpl $0x3, %ecx
jne 0x8c2b
movq 0x48(%rbx), %rcx
movl $0x14, 0x34(%rcx)
jmp 0x8c2b
movq 0x740f(%rip), %rbx      # 0xfff0
leaq 0x3482(%rip), %rsi      # 0xc06a
movl $0x17, %edx
movq %rbx, %rdi
callq 0x22e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x21d0
xorl %eax, %eax
jmp 0x8c2b
movq 0x48(%rbx), %rcx
movl $0x28, 0x34(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/src/kcp_remote.cpp
// Function: remote_kcpin_reset(tun_remote_t*, unsigned int)
static void
_remote_kcpin_reset(tun_remote_t *tun, uint32_t kcpconv) {
   
   cout << "udp & kcp reset " << kcpconv << endl;
   tun->kcpconv = kcpconv;

   _remote_kcpin_destroy(tun);
   _remote_kcpin_create(tun);

   while (skt_count(tun->session_lst) > 0) {
      session_unit_t *u = (session_unit_t*)skt_popf(tun->session_lst);
      mnet_chann_close(u->tcp);
      session_destroy(NULL, u);
   }
   skt_destroy(tun->session_lst);
   tun->session_lst = skt_create();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq 0x735e(%rip), %r15      # 0xffd0
leaq 0x33e0(%rip), %rsi      # 0xc059
movl $0x10, %edx
movq %r15, %rdi
callq 0x22e0
movl %r14d, %esi
movq %r15, %rdi
callq 0x21c0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2270
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x21d0
movl %r14d, 0x50(%rbx)
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x8cd5
callq 0x286a
movq $0x0, 0x48(%rbx)
movq %rbx, %rdi
callq 0x8b1f
movq 0x58(%rbx), %rdi
callq 0x6d1c
testl %eax, %eax
jle 0x8d0b
movq 0x58(%rbx), %rdi
callq 0x6fb4
movq %rax, %r14
movq 0x8(%rax), %rdi
callq 0x45ce
xorl %edi, %edi
movq %r14, %rsi
callq 0x83ae
jmp 0x8cdd
movq 0x58(%rbx), %rdi
callq 0x6c90
callq 0x6be0
movq %rax, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tokuhirom[P]nanouri/nanouri.c
// Function: nanouri_parse_uri(char const*, unsigned long, char const**, unsigned long*, char const**, unsigned long*, int*, char const**, int*)
int nanouri_parse_uri(const char* _buf, size_t len, const char** scheme, size_t *scheme_len, const char **host, size_t *host_len, int *port, const char **path_query, int*path_query_len) {
  const char * buf = _buf, * buf_end = buf + len;

  *scheme = buf;
  for (;;++buf) {
    CHECK_EOF();
    if (':' == *buf) {
      break;
    }
  }
  *scheme_len = buf - *scheme;

  EXPECT(':'); EXPECT('/'); EXPECT('/');

  *host = buf;
  *port = 0;
  *host_len = 0;
  *path_query_len = 0;
  for (;;++buf) {
    if (buf == buf_end) {
      *host_len = buf - *host;
      return 0;
    }
    if (':' == *buf) { /* with port */
      *host_len = buf - *host;
      buf++;

      *port = 0;
      for (;'0' <= *buf && *buf <= '9';buf++) {
        if (buf == buf_end) {
          return 0;
        }
        *port = *port * 10 + (*buf - '0');
      }
      if (buf == buf_end) {
        return 0;
      }
      break;
    }
    if ('/' == *buf) { /* no port */
      *host_len = buf - *host;
      break;
    }
  }

  *path_query = buf;
  *path_query_len = buf_end - buf;
  return 0;
}

// Assembly:
movq %rdi, (%rdx)
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
testq %rsi, %rsi
je 0x33e2
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %r11
movq 0x28(%rsp), %rbx
leaq (%rdi,%rsi), %r10
xorl %r14d, %r14d
cmpb $0x3a, (%rdi,%r14)
je 0x3354
incq %r14
cmpq %r14, %rsi
jne 0x3340
jmp 0x33dc
movq %r14, (%rcx)
cmpb $0x3a, (%rdi,%r14)
jne 0x33d7
leaq -0x1(%rsi), %rcx
cmpq %r14, %rcx
je 0x33dc
cmpb $0x2f, 0x1(%rdi,%r14)
jne 0x33d7
leaq -0x2(%rsi), %rcx
cmpq %r14, %rcx
je 0x33dc
cmpb $0x2f, 0x2(%rdi,%r14)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x33dc
leaq -0x3(%rsi), %rcx
leaq (%rdi,%r14), %rax
addq $0x3, %rax
movq %rax, (%r8)
xorl %eax, %eax
movl %eax, (%rbx)
movq $0x0, (%r9)
movl %eax, (%rdx)
cmpq %r14, %rcx
je 0x33cb
xorl %r15d, %r15d
movq %r14, %r8
movzbl 0x3(%rdi,%r8), %ebp
cmpl $0x2f, %ebp
je 0x343d
cmpl $0x3a, %ebp
je 0x33e3
incq %r8
incq %r15
cmpq %r8, %rcx
jne 0x33ac
subq %r14, %rsi
addq $-0x3, %rsi
movq %rsi, (%r9)
jmp 0x33dc
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, (%r9)
movl $0x0, (%rbx)
leaq (%rdi,%r8), %rcx
addq $0x4, %rcx
movb (%rcx), %dil
leal -0x30(%rdi), %eax
cmpb $0x9, %al
ja 0x3436
subq %r8, %rsi
addq $-0x4, %rsi
xorl %eax, %eax
xorl %r8d, %r8d
testq %rsi, %rsi
je 0x33dc
leal (%r8,%r8,4), %r8d
addb $-0x30, %dil
movzbl %dil, %edi
leal (%rdi,%r8,2), %r8d
movl %r8d, (%rbx)
movb 0x1(%rcx), %dil
incq %rcx
leal -0x30(%rdi), %r9d
decq %rsi
cmpb $0xa, %r9b
jb 0x340a
cmpq %r10, %rcx
jne 0x3448
jmp 0x3451
leaq (%rdi,%r8), %rcx
addq $0x3, %rcx
movq %r15, (%r9)
movq %rcx, (%r11)
subl %ecx, %r10d
movl %r10d, (%rdx)
xorl %eax, %eax
jmp 0x33dc
// File: /workspace/github_cpp_makefile_star2_O3/akw0088[P]openssl/huffman_enc.c
// Function: get_file
char *get_file(char *filename, unsigned int *size)
{
	FILE	*file;
	char	*buffer;
	int	file_size, bytes_read;

	file = fopen(filename, "rb");
	if (file == NULL)
		return 0;
	fseek(file, 0, SEEK_END);
	file_size = ftell(file);
	fseek(file, 0, SEEK_SET);
	buffer = malloc(file_size + 1);
	bytes_read = (int)fread(buffer, sizeof(char), file_size, file);
	if (bytes_read != file_size)
	{
		free((void *)buffer);
		fclose(file);
		return 0;
	}
	fclose(file);
	buffer[file_size] = '\0';

	if (size != NULL)
	{
		*size = file_size;
	}
	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xde0(%rip), %rsi       # 0x2004
callq 0x10e0
testq %rax, %rax
je 0x12a9
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x10d0
movq %r14, %rdi
callq 0x10b0
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10d0
leal 0x1(%r12), %eax
movslq %eax, %rdi
callq 0x10c0
movq %rax, %r15
movslq %r12d, %r13
movl $0x1, %esi
movq %rax, %rdi
movq %r13, %rdx
movq %r14, %rcx
callq 0x1050
cmpl %r13d, %eax
jne 0x1299
movq %r14, %rdi
callq 0x1060
movb $0x0, (%r15,%r13)
testq %rbx, %rbx
je 0x12ac
movl %r12d, (%rbx)
jmp 0x12ac
movq %r15, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1060
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/akw0088[P]openssl/huffman_enc.c
// Function: write_file
int write_file(char *filename, const char *bytes, int size)
{
	FILE *fp = fopen(filename, "wb");
	int ret;

	if (fp == NULL)
	{
		perror("Unable to open file for writing");
		return -1;
	}

	ret = fwrite(bytes, sizeof(char), size, fp);

	if (ret != size)
	{
		printf("fwrite didnt write all data\n");
		fclose(fp);
		return -1;
	}
	fclose(fp);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
leaq 0xd32(%rip), %rsi       # 0x2007
callq 0x10e0
testq %rax, %rax
je 0x132d
movq %rax, %rbx
movslq %r15d, %r15
movl $0x1, %esi
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
callq 0x1100
cmpl %r15d, %eax
jne 0x1309
movq %rbx, %rdi
callq 0x1060
xorl %eax, %eax
jmp 0x1322
leaq 0xd6b(%rip), %rdi       # 0x207b
callq 0x1040
movq %rbx, %rdi
callq 0x1060
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcd6(%rip), %rdi       # 0x200a
callq 0x10f0
jmp 0x131d
// File: /workspace/github_cpp_makefile_star2_O3/akw0088[P]openssl/huffman_enc.c
// Function: main
int main(int argc, char *argv[])
{
	if (argc < 2)
	{
		printf("Usage: huffman_enc file.bin\r\n");
		return -1;
	}

	char filename[256] = {0};

	unsigned int size = 0;

	char *encode = get_file(argv[1], &size);

	char *buffer = (char *)malloc(2 * size);
	if (buffer == NULL)
	{
		perror("malloc failed");
		return -1;
	}

	memset(buffer, 0, 2 * size);
	printf("Compressing %s\r\n", argv[1]);
	if (size == 0)
	{
		printf("Error: input file is 0 bytes\r\n");
		return -1;
	}

	unsigned int compressed_size = huffman_compress((unsigned char *)encode, size, (unsigned char *)buffer, size, huffbuf);
	if (compressed_size == 0)
	{
		printf("huffman_compress failed (file became larger)\r\n");
		return -1;
	}
	printf("Original size %d compressed %d ratio %f\r\n", size, compressed_size, (float) compressed_size / size);

	snprintf(filename, 255, "%s.huff", argv[1]);

	write_file(filename, buffer, compressed_size);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
cmpl $0x1, %edi
jg 0x135e
leaq 0xd8a(%rip), %rdi       # 0x20e3
jmp 0x144c
movq %rsi, %rbx
leaq -0x130(%rbp), %rdi
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x1090
leaq -0x24(%rbp), %r14
movl $0x0, (%r14)
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x120c
movq %rax, %r15
movl (%r14), %esi
addl %esi, %esi
movl $0x1, %edi
callq 0x10a0
testq %rax, %rax
je 0x1468
movq %rax, %r14
movq 0x8(%rbx), %rsi
leaq 0xc84(%rip), %rdi       # 0x2038
xorl %eax, %eax
callq 0x1070
movl -0x24(%rbp), %ecx
testq %rcx, %rcx
je 0x143c
leaq 0x2ce6(%rip), %r8       # 0x40b0
movq %r15, %rdi
movq %rcx, %rsi
movq %r14, %rdx
callq 0x1478
movq %rax, %r15
testl %r15d, %r15d
je 0x1445
movl %r15d, %eax
cvtsi2ss %rax, %xmm0
movl -0x24(%rbp), %esi
cvtsi2ss %rsi, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xc4a(%rip), %rdi       # 0x2049
movl %r15d, %edx
movb $0x1, %al
callq 0x1070
movq 0x8(%rbx), %rcx
leaq 0xc5f(%rip), %rdx       # 0x2073
xorl %ebx, %ebx
leaq -0x130(%rbp), %r12
movl $0xff, %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x1080
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x12be
jmp 0x1456
leaq 0xc82(%rip), %rdi       # 0x20c5
jmp 0x144c
leaq 0xc4b(%rip), %rdi       # 0x2097
callq 0x1040
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbbb(%rip), %rdi       # 0x202a
callq 0x10f0
jmp 0x1451
nop
// File: /workspace/github_cpp_makefile_star2_O3/akw0088[P]openssl/huffman.c
// Function: huffman_write_tree_and_make_encode_table
static void _huffman_write_tree_and_make_encode_table(unsigned char *out, unsigned long *outbitctr, unsigned long outlen,
 struct _huffman_encode_table *et,unsigned long code,unsigned int bits,struct _huffman_node *t)
{
	struct _huffman_encode_table *eti;
	unsigned int i;
	unsigned long byte_index;

	byte_index = (*outbitctr)++ >> 3;
	byte_index *= (byte_index < outlen);
	if (t->lr[0])
	{
		out[byte_index] <<= 1;
		_huffman_write_tree_and_make_encode_table(out,outbitctr,outlen,et,code,bits + 1,t->lr[0]);
		_huffman_write_tree_and_make_encode_table(out,outbitctr,outlen,et,code | (1 << bits),bits + 1,t->lr[1]);
	}
	else
	{
		out[byte_index] = (out[byte_index] << 1) | 1;
		for(i = 0; i < 9; ++i)
		{
			byte_index = (*outbitctr)++ >> 3;
			if (byte_index >= outlen)
				return;
			out[byte_index] = (out[byte_index] << 1) | ((unsigned char)((t->c >> i) & 1));
		}
		eti = &(et[t->c]);
		eti->code = code;
		eti->bits = bits;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r12
movq %rdi, %r13
movq 0x10(%rbp), %r11
movq (%rsi), %rcx
leaq 0x1(%rcx), %rax
movq %rax, (%rsi)
shrq $0x3, %rcx
xorl %eax, %eax
cmpq %rdx, %rcx
cmovbq %rcx, %rax
cmpq $0x0, (%r11)
je 0x17f0
movq %rbx, -0x38(%rbp)
movq %rsi, -0x30(%rbp)
movq %r9, -0x40(%rbp)
shlb (%r13,%rax)
leal 0x1(%r9), %r14d
movq (%r11), %rax
movq %rax, (%rsp)
movq %r13, %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq %r15, %r8
movl %r14d, %r9d
movq %r11, %rbx
callq 0x173a
movq %rbx, %r11
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rbx
movl $0x1, %eax
movq -0x40(%rbp), %rcx
shll %cl, %eax
cltq
orq %rax, %r15
movq 0x8(%r11), %r11
movq (%rsi), %rax
leaq 0x1(%rax), %rcx
shrq $0x3, %rax
cmpq %r12, %rax
movl $0x0, %r9d
cmovaeq %r9, %rax
movq %rcx, (%rsi)
cmpq $0x0, (%r11)
movl %r14d, %r9d
jne 0x1780
jmp 0x17f3
movl %r9d, %r14d
movb (%r13,%rax), %cl
addb %cl, %cl
incb %cl
movb %cl, (%r13,%rax)
xorl %eax, %eax
movq (%rsi), %rcx
leaq 0x1(%rcx), %r9
movq %r9, (%rsi)
shrq $0x3, %rcx
cmpq %r12, %rcx
jae 0x184f
movb (%r13,%rcx), %r10b
addb %r10b, %r10b
movq 0x28(%r11), %r9
btq %rax, %r9
setb %r9b
orb %r10b, %r9b
movb %r9b, (%r13,%rcx)
incq %rax
cmpq $0x9, %rax
jne 0x1803
movq 0x28(%r11), %rax
shlq $0x4, %rax
movq %r15, (%rbx,%rax)
movl %r14d, %ecx
movq %rcx, 0x8(%rbx,%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/akw0088[P]openssl/huffman.c
// Function: huffman_decompress
unsigned long huffman_decompress(const unsigned char *in,unsigned long inlen,unsigned char *out,unsigned long outlen,void *huffheap)
{
	struct _huffman_node *t,*n;
	unsigned char *heapptr = (unsigned char *)huffheap;
	unsigned long inbitctr,outptr,byte_index = 0;

	inbitctr = 0;
	t = _huffman_read_tree(in,&inbitctr,inlen,&heapptr,heapptr + HUFFHEAP_SIZE);
	if (!t) return 0;
	outptr = 0;
	for(;;)
	{
		n = t;
		while (n->lr[0])
		{
			byte_index = inbitctr >> 3;
			if (byte_index >= inlen)
				return 0;
			n = n->lr[((unsigned long)(in[byte_index] >> (~(inbitctr++) & 7))) & 1];
		}
		if (n->c == 256)
			return outptr;
		if (outptr == outlen)
			return 0;
		out[outptr++] = (unsigned char)n->c;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq -0x30(%rbp), %rcx
movq %r8, (%rcx)
leaq -0x28(%rbp), %rsi
movq $0x0, (%rsi)
addq $0xa8a8, %r8            # imm = 0xA8A8
movq %r15, %rdx
callq 0x191d
testq %rax, %rax
je 0x190e
movq %rax, %rcx
movq -0x28(%rbp), %rdi
xorl %eax, %eax
cmpq $0x0, (%rcx)
je 0x18ea
movq %rcx, %rsi
movq %rdi, %rdx
shrq $0x3, %rdx
cmpq %r15, %rdx
jae 0x190e
movzbl (%r12,%rdx), %r8d
leaq 0x1(%rdi), %rdx
notb %dil
movzbl %dil, %edi
andl $0x7, %edi
xorl %r9d, %r9d
btl %edi, %r8d
setb %r9b
movq (%rsi,%r9,8), %rsi
cmpq $0x0, (%rsi)
movq %rdx, %rdi
jne 0x18b1
jmp 0x18f0
movq %rdi, %rdx
movq %rcx, %rsi
movq 0x28(%rsi), %rsi
cmpq $0x100, %rsi            # imm = 0x100
je 0x1910
cmpq %rbx, %rax
je 0x190e
movb %sil, (%r14,%rax)
incq %rax
movq %rdx, %rdi
jmp 0x18a8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/akw0088[P]openssl/huffman.c
// Function: huffman_read_tree
static struct _huffman_node *_huffman_read_tree(const unsigned char *in,unsigned long *inbitctr,unsigned long inlen,unsigned char **heapptr,unsigned char *heapend)
{
	struct _huffman_node *n;
	unsigned int i;
	unsigned long byte_index;

	n = (struct _huffman_node *)(*heapptr);
	*heapptr += sizeof(struct _huffman_node);
	if (*heapptr > heapend)
		 return (struct _huffman_node *)0;

	byte_index = *inbitctr >> 3;
	byte_index *= (byte_index < inlen);
	if (((in[byte_index] >> (~((*inbitctr)++) & 7)) & 1))
	{
		n->lr[0] = (struct _huffman_node *)0;
		n->lr[1] = (struct _huffman_node *)0;
		n->c = 0;
		for(i = 0; i < 9; ++i)
		{
			byte_index = *inbitctr >> 3;
			if (byte_index >= inlen)
				return (struct _huffman_node *)0;
			n->c |= (((unsigned int)(in[byte_index] >> (~((*inbitctr)++) & 7))) & 1) << i;
		}
	}
	else
	{
		n->lr[0] = _huffman_read_tree(in,inbitctr,inlen,heapptr,heapend);
		n->lr[1] = _huffman_read_tree(in,inbitctr,inlen,heapptr,heapend);
		if (!((n->lr[0])&&(n->lr[1])))
			return (struct _huffman_node *)0;
	}

	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rcx), %rbx
leaq 0x30(%rbx), %rax
movq %rax, (%rcx)
cmpq %r8, %rax
jbe 0x194e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rsi), %rax
movq %rax, %rcx
shrq $0x3, %rcx
xorl %edx, %edx
cmpq %r14, %rcx
cmovaeq %rdx, %rcx
movzbl (%rdi,%rcx), %ecx
leaq 0x1(%rax), %rdx
movq %rdx, (%rsi)
notb %al
movzbl %al, %eax
andl $0x7, %eax
btl %eax, %ecx
jae 0x19d3
movq $0x0, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %ecx, %ecx
movq (%r15), %rax
movq %rax, %rdx
shrq $0x3, %rdx
cmpq %r14, %rdx
jae 0x193a
movzbl (%r12,%rdx), %edx
leaq 0x1(%rax), %rsi
notb %al
movzbl %al, %eax
andl $0x7, %eax
xorl %edi, %edi
btl %eax, %edx
setb %dil
shll %cl, %edi
movq %rsi, (%r15)
orq %rdi, 0x28(%rbx)
incl %ecx
cmpl $0x9, %ecx
jne 0x1995
jmp 0x193c
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
movq %r8, -0x30(%rbp)
callq 0x191d
movq %rax, (%rbx)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
movq -0x30(%rbp), %r8
callq 0x191d
movq %rax, 0x8(%rbx)
cmpq $0x0, (%rbx)
sete %cl
testq %rax, %rax
sete %al
orb %cl, %al
jne 0x193a
jmp 0x193c
// File: /workspace/github_cpp_makefile_star2_O3/hzy1754785321[P]warehouse-manage-system/product.cpp
// Function: Products::addProduct()
void Products::addProduct()
{
		Product *p;
		char buf[1000];
		p=new Product;
		p->setId();
		p->setName();
		p->setType();
		p->setPrice();
		p->setLoginTime();
		push_back(p);
	//	return *p;
		sprintf(buf,"qrencode \"name=%s\ttype=%s\tprice=%f\ttime=%s\" -o %d.png",p->getName(),p->getType(),p->getPrice(),p->getLoginTime(),p->getId());
		system(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3f8, %rsp            # imm = 0x3F8
movq %rdi, %r14
pushq $0x7c
popq %r15
movq %r15, %rdi
callq 0x21e0
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
andq $0x0, 0x40(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups 0x7e8e(%rip), %xmm0     # 0xa4d0
movups %xmm0, 0x48(%rax)
movups 0x7e93(%rip), %xmm0     # 0xa4e0
movups %xmm0, 0x58(%rax)
movups 0x7e98(%rip), %xmm0     # 0xa4f0
movups %xmm0, 0x68(%rax)
andw $0x0, 0x78(%rax)
movq %rax, -0x38(%rbp)
movq %rax, %rdi
callq 0x5daa
leaq 0xcb7c(%rip), %rax      # 0xf1f0
movl $0x1, (%rax)
movq 0xc94f(%rip), %rdi      # 0xefd0
leaq 0x7a5b(%rip), %rsi      # 0xa0e3
pushq $0x1b
popq %rdx
callq 0x2240
movq 0xc949(%rip), %r12      # 0xefe0
movq (%r12), %rax
movq -0x18(%rax), %rax
movq 0x10(%r12,%rax), %r13
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2330
movq (%r12), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r12,%rax)
jne 0x26e2
addq $-0x7d, %r13
cmpq $-0x7d, %r13
ja 0x26e2
movq 0xe8(%r12,%rax), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x27bc
movq %rbx, %rdi
callq 0x5eb2
leaq 0xcaff(%rip), %rax      # 0xf1f0
movl $0x1, (%rax)
movq 0xc8d2(%rip), %rdi      # 0xefd0
leaq 0x7e46(%rip), %rsi      # 0xa54b
pushq $0x1c
popq %rdx
callq 0x2240
movq %rbx, %rsi
addq $0x40, %rsi
movq 0xc8c5(%rip), %rdi      # 0xefe0
callq 0x2380
movq %rbx, %rdi
callq 0x6236
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x273c
movq %rbx, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x274e
leaq -0x38(%rbp), %rbx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x7378
movq (%rbx), %rbx
leaq 0x20(%rbx), %r14
cvtss2sd 0x40(%rbx), %xmm0
movsd %xmm0, -0x30(%rbp)
leaq 0x48(%rbx), %r15
leaq 0x7b74(%rip), %rsi      # 0xa2db
pushq $0x5
popq %rdx
movq %r15, %rdi
callq 0x2200
xorl %r8d, %r8d
testl %eax, %eax
cmovneq %r15, %r8
movl 0x44(%rbx), %r9d
leaq 0x7de2(%rip), %rsi      # 0xa568
leaq -0x420(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
movsd -0x30(%rbp), %xmm0
movb $0x1, %al
callq 0x2050
movq %r15, %rdi
callq 0x2170
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rdi), %rax
callq *0x48(%rax)
cmpl $-0x1, %eax
jne 0x26e2
movq (%r12), %rax
movq -0x18(%rax), %rax
leaq (%r12,%rax), %rdi
movl 0x20(%r12,%rax), %esi
orl $0x2, %esi
callq 0x2310
jmp 0x26e2
// File: /workspace/github_cpp_makefile_star2_O3/hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Person::Person(Person*)
Person::Person(Person *ps)
{
		//passwd=ps->getPasswd();
		strcpy(passwd,ps->getPasswd());
		id=ps->getNumber();
		stop=ps->getStop();
//		name=ps->getName();
		strcpy(name,ps->getName());
		if(ps->pp!=NULL)
				pp=ps->pp;
		if(ps->temp!=NULL)
				temp=ps->temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb70a(%rip), %rax      # 0xeb90
movq %rax, (%rdi)
addq $0x28, %rdi
addq $0x28, %rsi
callq 0x21a0
movl 0x68(%r14), %eax
movl %eax, 0x68(%rbx)
movl 0x6c(%r14), %eax
movl %eax, 0x6c(%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x8(%r14), %rsi
callq 0x21a0
movq 0xb0(%r14), %rax
testq %rax, %rax
je 0x34c4
movq %rax, 0xb0(%rbx)
movq 0xa8(%r14), %rax
testq %rax, %rax
je 0x34d7
movq %rax, 0xa8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Person::setNumber()
void Person::setNumber()
{
		peopleMax++;
		changeFlag=1;
		vector<int>::iterator it;
		for(int i=1;i<peopleMax+1;i++)
		{
				it=find(number.begin(),number.end(),i);
				if(it==number.end())
				{
						id=i;
						number.push_back(i);
						return;
				}
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl 0xbcd7(%rip), %eax      # 0xf1ec
leal 0x1(%rax), %ecx
movl %ecx, 0xbcce(%rip)      # 0xf1ec
movl $0x1, %ecx
movl %ecx, 0xbcc7(%rip)      # 0xf1f0
movl %ecx, -0x14(%rbp)
testl %eax, %eax
js 0x3597
movq %rdi, %rbx
movq 0xbcc6(%rip), %rsi      # 0xf200
leaq -0x14(%rbp), %r14
movq 0xbcb3(%rip), %rdi      # 0xf1f8
movq %r14, %rdx
callq 0x596e
movq 0xbcac(%rip), %rsi      # 0xf200
movl -0x14(%rbp), %ecx
cmpq %rsi, %rax
je 0x356c
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl 0xbc84(%rip), %ecx      # 0xf1ec
jl 0x353e
jmp 0x3597
movl %ecx, 0x68(%rbx)
cmpq 0xbc92(%rip), %rax      # 0xf208
je 0x3587
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xbc7b(%rip)      # 0xf200
jmp 0x3597
leaq 0xbc6a(%rip), %rdi      # 0xf1f8
leaq -0x14(%rbp), %rdx
callq 0x5a1c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Person::deleteId()
void Person::deleteId()
{
		vector<int>::iterator it;
		it=find(number.begin(),number.end(),id);
		if(it!=number.end())
		{
				number.erase(it);
				peopleMax--;
		}
		else
		{
				cout << "\t\t\t\t\tdelete error!" << endl;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0xbc4b(%rip), %rax      # 0xf1f8
movq 0xbc4c(%rip), %rsi      # 0xf200
leaq 0x68(%rdi), %rdx
movq %rax, %rdi
callq 0x596e
movq 0xbc39(%rip), %rdx      # 0xf200
cmpq %rdx, %rax
je 0x35ff
leaq 0x4(%rax), %rsi
cmpq %rdx, %rsi
je 0x35e7
subq %rsi, %rdx
movq %rax, %rdi
callq 0x2300
movq 0xbc19(%rip), %rdx      # 0xf200
addq $-0x4, %rdx
movq %rdx, 0xbc0e(%rip)      # 0xf200
decl 0xbbf4(%rip)            # 0xf1ec
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xb9ca(%rip), %rbx      # 0xefd0
leaq 0x6ac3(%rip), %rsi      # 0xa0d0
movl $0x12, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Person::changeInfo()
void Person::changeInfo()
{
		int flag;
		cout << "\t\t\t\t\t1:change the name." << endl << "\t\t\t\t\t2:change the Number." << endl << "\t\t\t\t\t3:exit." << endl <<  "\t\t\t\t\tplease choice:" ;
		cin >> flag;
		switch(flag)
		{
				case 1: setName();
						break;
				case 2:	setNumber();
						break;
				case 3: return ;
				default:cout << "\t\t\t\t\tinput error!" << endl;
						break;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb7cc(%rip), %r14      # 0xefd0
leaq 0x692b(%rip), %rsi      # 0xa136
movl $0x17, %edx
movq %r14, %rdi
callq 0x2240
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq %rax, %r15
leaq 0x6905(%rip), %rsi      # 0xa14e
movl $0x19, %edx
movq %rax, %rdi
callq 0x2240
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq %rax, %r15
leaq 0x68e1(%rip), %rsi      # 0xa168
movl $0xc, %edx
movq %rax, %rdi
callq 0x2240
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
leaq 0x68b3(%rip), %rsi      # 0xa175
movl $0x13, %edx
movq %rax, %rdi
callq 0x2240
movq 0xb70a(%rip), %rdi      # 0xefe0
leaq -0x1c(%rbp), %r15
movq %r15, %rsi
callq 0x20f0
movl (%r15), %eax
cmpl $0x3, %eax
je 0x397e
cmpl $0x2, %eax
je 0x3939
cmpl $0x1, %eax
jne 0x3943
movl $0x1, 0xb8ee(%rip)      # 0xf1f0
movq 0xb6c7(%rip), %rdi      # 0xefd0
leaq 0x67d3(%rip), %rsi      # 0xa0e3
movl $0x1b, %edx
callq 0x2240
addq $0x8, %rbx
movq 0xb6bb(%rip), %rdi      # 0xefe0
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
movq %rbx, %rsi
callq 0x2330
jmp 0x397e
movq %rbx, %rdi
callq 0x3504
jmp 0x397e
leaq 0x683f(%rip), %rsi      # 0xa189
movl $0x11, %edx
movq %r14, %rdi
callq 0x2240
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Person::writeStop()
void Person::writeStop()
{
		ofstream st;
		st.open("stop",ios::out);
		if(st.is_open())
		{
				st << stop;
		}
		else
				cout << "open failed!" << endl;
		st.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
leaq -0x210(%rbp), %r14
movq %r14, %rdi
callq 0x2320
leaq 0x6469(%rip), %rsi      # 0xa212
movq %r14, %rdi
movl $0x10, %edx
callq 0x2040
leaq -0x1a0(%rbp), %rdi
callq 0x2070
testb %al, %al
je 0x3dd7
movl 0x6c(%rbx), %esi
leaq -0x210(%rbp), %rdi
callq 0x2340
jmp 0x3e1d
movq 0xb1f2(%rip), %rbx      # 0xefd0
leaq 0x6500(%rip), %rsi      # 0xa2e5
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq 0xb1c0(%rip), %rdi      # 0xefd0
callq 0x2030
movq %rax, %rdi
callq 0x2110
leaq -0x210(%rbp), %rdi
callq 0x22b0
movq 0xb198(%rip), %rax      # 0xefc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x208(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x210(%rbp,%rcx)
callq 0x2160
leaq -0x118(%rbp), %rdi
callq 0x20a0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
callq 0x22c0
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Person::readStop()
void Person::readStop()
{
		ifstream st;
		st.open("stop",ios::in);
		while(!st.eof())
		{
				st >> stop;
				st.close();
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
leaq -0x218(%rbp), %r14
movq %r14, %rdi
callq 0x2230
leaq 0x6369(%rip), %rsi      # 0xa212
movq %r14, %rdi
movl $0x8, %edx
callq 0x2100
addq $0x6c, %rbx
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x1f8(%rbp,%rax)
jne 0x3ee4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq %r14, %rdi
callq 0x2060
jmp 0x3eba
leaq -0x218(%rbp), %rdi
callq 0x2080
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3efe
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Person::writestop()
void Person::writestop()
{
		ofstream st;
		st.open("stop1",ios::out);
		if(st.is_open())
		{
				st << stop;
		}
		else
				cout << "open failed!" << endl;
		st.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
leaq -0x210(%rbp), %r14
movq %r14, %rdi
callq 0x2320
leaq 0x62da(%rip), %rsi      # 0xa217
movq %r14, %rdi
movl $0x10, %edx
callq 0x2040
leaq -0x1a0(%rbp), %rdi
callq 0x2070
testb %al, %al
je 0x3f6b
movl 0x6c(%rbx), %esi
leaq -0x210(%rbp), %rdi
callq 0x2340
jmp 0x3fb1
movq 0xb05e(%rip), %rbx      # 0xefd0
leaq 0x636c(%rip), %rsi      # 0xa2e5
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq 0xb02c(%rip), %rdi      # 0xefd0
callq 0x2030
movq %rax, %rdi
callq 0x2110
leaq -0x210(%rbp), %rdi
callq 0x22b0
movq 0xb004(%rip), %rax      # 0xefc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x208(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x210(%rbp,%rcx)
callq 0x2160
leaq -0x118(%rbp), %rdi
callq 0x20a0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
callq 0x22c0
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Person::readstop()
void Person::readstop()
{
		ifstream st;
		st.open("stop1",ios::in);
		while(!st.eof())
		{
				st >> stop;
				st.close();
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
leaq -0x218(%rbp), %r14
movq %r14, %rdi
callq 0x2230
leaq 0x61da(%rip), %rsi      # 0xa217
movq %r14, %rdi
movl $0x8, %edx
callq 0x2100
addq $0x6c, %rbx
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x1f8(%rbp,%rax)
jne 0x4078
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq %r14, %rdi
callq 0x2060
jmp 0x404e
leaq -0x218(%rbp), %rdi
callq 0x2080
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4092
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2350
nop