LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/nikhilYadala[P]Python_to_cpp/Source/src/generate_cpp_code.cpp
// Function: main_func(source_code&)
void main_func(source_code& src)
{
	function_declaration _function;
	_function.name="main";
	_function.return_type="int";
	_function.args.push_back(string_pair("",""));
	
	std::string converted_code;
	std::map< std::string,std::string > variables;	//name -> type
	convert_to_cpp(src.functions[0].first,src.functions[0].second,src.lines,converted_code,&_function,variables);
	converted_code.append(" \nreturn 0;");
	src.generated_cpp_code[0].first=converted_code;	//Only 1 line of sparse code maybe extend later
	src.generated_cpp_code[0].second=_function;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq -0xd0(%rbp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq -0xb0(%rbp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movq %rax, 0x20(%r13)
leaq 0x476c(%rip), %rcx      # 0xb270
leaq -0xe0(%rbp), %rdi
movl $0x4, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x2310
leaq -0xc0(%rbp), %r14
movq 0x8(%r14), %rdx
leaq 0x4512(%rip), %rcx      # 0xb03e
movl $0x3, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x2310
leaq 0x46db(%rip), %rdx      # 0xb21e
leaq -0x88(%rbp), %rdi
movq %rdx, %rsi
callq 0x6f02
leaq -0xa0(%rbp), %r15
leaq -0x88(%rbp), %rsi
movq %r15, %rdi
callq 0x57da
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b7a
callq 0x21c0
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b8c
callq 0x21c0
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
leaq -0x80(%rbp), %rcx
movl $0x0, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
movq 0x50(%rbx), %rax
movslq (%rax), %rdi
movslq 0x4(%rax), %rsi
leaq 0x38(%rbx), %rdx
leaq -0x48(%rbp), %rcx
leaq -0xe0(%rbp), %r8
leaq -0x88(%rbp), %r9
callq 0x2f41
leaq 0x468d(%rip), %rsi      # 0xb275
leaq -0x48(%rbp), %rdi
callq 0x23c0
movq 0x80(%rbx), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2110
movq 0x80(%rbx), %rbx
leaq 0x20(%rbx), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x2110
leaq 0x40(%rbx), %rdi
movq %r14, %rsi
callq 0x2110
addq $0x60, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6ffc
leaq -0x88(%rbp), %rdi
callq 0x73c6
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x6c4d
callq 0x21c0
movq %r15, %rdi
callq 0x742a
movq -0xc0(%rbp), %rdi
cmpq %r13, %rdi
leaq -0xd0(%rbp), %rbx
je 0x6c6d
callq 0x21c0
movq -0xe0(%rbp), %rdi
cmpq %rbx, %rdi
je 0x6c7e
callq 0x21c0
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x4d66
jmp 0x6cc5
jmp 0x6ca3
movq %rax, %rbx
jmp 0x6cc5
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x73c6
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x6cc5
callq 0x21c0
leaq -0xe0(%rbp), %rdi
callq 0x6f78
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O1/nikhilYadala[P]Python_to_cpp/Source/src/convert_to_cpp_classes.cpp
// Function: is_symbol_(char)
bool is_symbol_(char c){
	char symbols[]=" =:;(){}[]|,.&+-<>*/'\n#";

	for(int i=0;symbols[i]!='#';++i)
		if(symbols[i]==c)
			return 1;
	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x1, %al
cmpb $0x20, %dil
je 0x83e1
movl $0x1, %edx
leaq 0x2df5(%rip), %rcx      # 0xb1c0
cmpq $0x16, %rdx
setne %al
je 0x83e1
leaq 0x1(%rdx), %rsi
cmpb %dil, (%rdx,%rcx)
movq %rsi, %rdx
jne 0x83cb
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nikhilYadala[P]Python_to_cpp/Source/src/make_classes.cpp
// Function: source_code::make_classes()
void source_code::make_classes()
{
 //splitting of the code into lines has already been done while functionizing
	classes.resize(0); 

	for(std::vector <line_pair>::iterator classes_itr=lines.begin();classes_itr!=lines.end();)
	{

		//itr incrementing to be done in the following code.
		if(classes_itr->first[0]=='c'&&classes_itr->first[1]=='l'&&classes_itr->first[2]=='a'&&classes_itr->first[3]=='s'&&classes_itr->first[4]=='s')
	        {

	            //classes inherited are taken care off in convert_to_cpp_classes.cpp
	            
	        	int space_count=classes_itr->second;
	        	int i1,i2;
	        	i1=classes_itr-lines.begin();
	        	while((((++classes_itr)->second)) > space_count)
					i2=classes_itr-lines.begin()-1;
				classes.push_back(int_pair(i1,i2));

            }
        else
           {
                   classes_itr++;
           }
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x68(%rdi), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x6586
movq 0x38(%rbx), %r12
cmpq 0x40(%rbx), %r12
je 0xa659
leaq -0x30(%rbp), %r15
movq (%r12), %rax
cmpb $0x63, (%rax)
jne 0xa613
cmpb $0x6c, 0x1(%rax)
jne 0xa613
cmpb $0x61, 0x2(%rax)
jne 0xa613
cmpb $0x73, 0x3(%rax)
jne 0xa613
cmpb $0x73, 0x4(%rax)
jne 0xa613
movl 0x20(%r12), %ecx
movq %r12, %rax
subq 0x38(%rbx), %rax
cmpl %ecx, 0x48(%r12)
jle 0xa61f
addq $0x70, %r12
movq %rax, %rdx
movq %r12, %rsi
addq $0x28, %rdx
addq $0x28, %r12
cmpl %ecx, (%rsi)
jg 0xa5f0
shrq $0x3, %rdx
imull $0xcccccccd, %edx, %r13d # imm = 0xCCCCCCCD
decl %r13d
addq $-0x48, %r12
jmp 0xa623
addq $0x28, %r12
cmpq 0x40(%rbx), %r12
jne 0xa5b5
jmp 0xa659
addq $0x28, %r12
shrq $0x3, %rax
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
movl %eax, -0x30(%rbp)
movl %r13d, -0x2c(%rbp)
movq 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0xa64c
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x70(%rbx)
jmp 0xa617
movq %r14, %rdi
movq %r15, %rdx
callq 0x69dc
jmp 0xa617
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/panosfoto[P]NGramGraphParallel/src/GraphSimilarity.cpp
// Function: GraphSimilarity::getSimilarityComponents[abi:cxx11]()
std::map<std::string, double> GraphSimilarity::getSimilarityComponents()
{
    // Init result map
    std::map<std::string, double> resultMap;
    // Update components
    resultMap["valueSimilarity"] = this->valueSimilarity;
    resultMap["containmentSimilarity"] = this->containmentSimilarity;
    resultMap["sizeSimilarity"] = this->sizeSimilarity;
    // Return
    return resultMap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movsd 0x8(%rsi), %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x7df0(%rip), %rsi      # 0x1b6c5
leaq 0x7df8(%rip), %rdx      # 0x1b6d4
leaq -0x40(%rbp), %rdi
callq 0x6fa8
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x6e86
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x13908
callq 0x6290
movsd 0x10(%r14), %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x7db4(%rip), %rsi      # 0x1b6d5
leaq 0x7dc2(%rip), %rdx      # 0x1b6ea
callq 0x6fa8
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x6e86
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x13950
callq 0x6290
movsd 0x18(%r14), %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x2754(%rip), %rsi      # 0x160bd
leaq 0x275b(%rip), %rdx      # 0x160cb
callq 0x6fa8
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x6e86
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x13998
callq 0x6290
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x139ae
jmp 0x139c1
jmp 0x139ae
jmp 0x139c1
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x139c4
callq 0x6290
jmp 0x139c4
movq %rax, %r14
movq %rbx, %rdi
callq 0x6f06
movq %r14, %rdi
callq 0x6490
// File: /workspace/github_cpp_makefile_star2_O1/panosfoto[P]NGramGraphParallel/src/NGramGraph.cpp
// Function: NGramGraph::NGramGraph()
NGramGraph::NGramGraph()
{
    CorrelationWindow = CORRELATIONWINDOW_DEFAULT_VALUE;
    splitter = nullptr;
    evaluator = nullptr;
    payload = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x11184(%rip), %rax     # 0x24b80
movq %rax, (%rdi)
addq $0x8, %rdi
leaq -0x9(%rbp), %rsi
callq 0x141ca
leaq 0x70(%rbx), %rax
movq %rax, 0x40(%rbx)
movq $0x1, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movl $0x3f800000, 0x60(%rbx) # imm = 0x3F800000
movups %xmm0, 0x68(%rbx)
movl $0x0, 0x78(%rbx)
movups %xmm0, 0x80(%rbx)
movq $0x0, 0x90(%rbx)
leaq 0x1109a(%rip), %rax     # 0x24ae8
movq %rax, (%rbx)
movl $0x3, 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/panosfoto[P]NGramGraphParallel/src/NGramGraph.cpp
// Function: NGramGraph::NGramGraph(ProximityEvaluator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, StringSplitter*, StringPayload*, unsigned int)
NGramGraph::NGramGraph(ProximityEvaluator<std::string> *newProximityEvaluator, StringSplitter *newSplitter, StringPayload *newPayload, unsigned int CorrelationWindowValue)
{
    evaluator = newProximityEvaluator;
    splitter = newSplitter;
    payload = newPayload;
    CorrelationWindow = CorrelationWindowValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x110fa(%rip), %rax     # 0x24b80
movq %rax, (%rdi)
addq $0x8, %rdi
leaq -0x29(%rbp), %rsi
callq 0x141ca
leaq 0x70(%r13), %rax
movq %rax, 0x40(%r13)
movq $0x1, 0x48(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r13)
movl $0x3f800000, 0x60(%r13) # imm = 0x3F800000
movups %xmm0, 0x68(%r13)
movl $0x0, 0x78(%r13)
movups %xmm0, 0x80(%r13)
leaq 0x11016(%rip), %rax     # 0x24ae8
movq %rax, (%r13)
movq %r12, 0x80(%r13)
movq %r15, 0x88(%r13)
movq %r14, 0x90(%r13)
movl %ebx, 0x98(%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/toxemicsquire4[P]csci41_calc/main.cc
// Function: modulate(Number, Number)
int modulate ( Number x, Number y ) { //modulus, checks for 0
	if ( !y.get_value() ) {
		cout << "INVALID INPUT!\n";
		exit(0);
	}
	else return x.get_value() % y.get_value();
}

// Assembly:
testl %esi, %esi
je 0x1345
movl %edi, %eax
cltd
idivl %esi
movl %edx, %eax
retq
pushq %rbp
movq %rsp, %rbp
movq 0x2c80(%rip), %rdi      # 0x3fd0
leaq 0xcda(%rip), %rsi       # 0x2031
callq 0x1100
xorl %edi, %edi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: node::update()
void node::update() {
    size = 1;
    sum_adjacent_nodes[0] = adjacent_nodes[0];
    sum_adjacent_nodes[1] = adjacent_nodes[1];
    if(left) {
        size += left->size;
        sum_adjacent_nodes[0] += left->sum_adjacent_nodes[0];
        sum_adjacent_nodes[1] += left->sum_adjacent_nodes[1];
    }
    if(right) {
        size += right->size;
        sum_adjacent_nodes[0] += right->sum_adjacent_nodes[0];
        sum_adjacent_nodes[1] += right->sum_adjacent_nodes[1];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, 0x1c(%rdi)
movl 0x20(%rdi), %ecx
movl %ecx, 0x28(%rdi)
movl 0x24(%rdi), %eax
movl %eax, 0x2c(%rdi)
movq (%rdi), %rdx
testq %rdx, %rdx
je 0x263b
movl 0x1c(%rdx), %esi
incl %esi
movl %esi, 0x1c(%rdi)
addl 0x28(%rdx), %ecx
movl %ecx, 0x28(%rdi)
addl 0x2c(%rdx), %eax
movl %eax, 0x2c(%rdi)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2656
movl 0x1c(%rax), %ecx
addl %ecx, 0x1c(%rdi)
movl 0x28(%rax), %ecx
addl %ecx, 0x28(%rdi)
movl 0x2c(%rax), %eax
addl %eax, 0x2c(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::insert_new(node*)
node * BinarySearchTree::insert_new(node *nn) {
    if(!nn)
        return new node();
    change_root(nn);
    while(nn->right)
        nn = nn->right;
    node * newnode = new node();
    newnode->par = nn;
    nn->right = newnode;
    nn->update();
    change_root(newnode);
    return newnode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x26b4
movq %rdi, %rbx
callq 0x26de
movq %rbx, %r14
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x266c
movl $0x30, %edi
callq 0x21a0
movq %rax, %rbx
movl $0x1, 0x1c(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rax)
movups %xmm0, (%rax)
movups %xmm0, 0x20(%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x2608
movq %rbx, %rdi
callq 0x26de
jmp 0x26d6
movl $0x30, %edi
callq 0x21a0
movq %rax, %rbx
movl $0x1, 0x1c(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0xc(%rax)
movups %xmm0, 0x20(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::change_root(node*)
void BinarySearchTree::change_root(node * nn) {
    if(!nn)
        return;
    while(nn->par) {
        node * p = nn->par;
        node * gp = p->par;
        if(!gp) {
            rotate(nn);
            break;
        }

        if((nn == p->left) == (p == gp->left)) {
            rotate(p);          //left child, left child case
            rotate(nn);             //or right, right case
        }
        else {
            rotate(nn);         //zig zag 
            rotate(nn);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2720
movq %rdi, %rbx
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2720
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x2727
cmpq %rbx, (%rdi)
sete %cl
cmpq (%rax), %rdi
setne %al
xorb %cl, %al
jne 0x2711
movq %rbx, %rdi
callq 0x27d8
movq %rbx, %rdi
callq 0x27d8
jmp 0x26ec
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x27d8
nop
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::rotate_left(node*)
void BinarySearchTree::rotate_left(node* nn) {
    node * p = nn->par;
    node * gp = p->par;
    node * lc = nn->left;
    nn->par = gp;

    if(gp) {
        if(p == gp->left)
            gp->left = nn;
        else
            gp->right = nn;
    }

    nn->left = p;
    p->par = nn;

    p->right = lc;
    if(lc)
        lc->par = p;
    p->update();
    nn->update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x10(%rdi), %rdi
movq 0x10(%rdi), %rcx
movq %rcx, 0x10(%rbx)
testq %rcx, %rcx
je 0x275f
xorl %edx, %edx
cmpq (%rcx), %rdi
setne %dl
movq %rbx, (%rcx,%rdx,8)
movq %rdi, (%rbx)
movq %rbx, 0x10(%rdi)
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x2773
movq %rdi, 0x10(%rax)
callq 0x2608
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2608
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::rotate_right(node*)
void BinarySearchTree::rotate_right(node * nn) {
    node * p = nn->par;
    node * gp = p->par;
    node * rc = nn->right;
    nn->par = gp;

    if(gp) {
        if(p == gp->left)
            gp->left = nn;
        else
            gp->right = nn;
    }

    nn->right = p;
    p->par = nn;

    p->left = rc;
    if(rc)
        rc->par = p;
    p->update();
    nn->update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
movq 0x10(%rdi), %rcx
movq %rcx, 0x10(%rbx)
testq %rcx, %rcx
je 0x27b0
xorl %edx, %edx
cmpq (%rcx), %rdi
setne %dl
movq %rbx, (%rcx,%rdx,8)
movq %rdi, 0x8(%rbx)
movq %rbx, 0x10(%rdi)
movq %rax, (%rdi)
testq %rax, %rax
je 0x27c4
movq %rdi, 0x10(%rax)
callq 0x2608
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2608
nop
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::rotate(node*)
void BinarySearchTree::rotate(node * nn) {
    node * p = nn->par;
    if(!p)
        return;
    if(nn == p->left)
        rotate_right(nn);
    else
        rotate_left(nn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x27f0
cmpq %rdi, (%rax)
je 0x27f2
popq %rbp
jmp 0x2736
popq %rbp
retq
popq %rbp
jmp 0x2786
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::remove_child(node*)
void BinarySearchTree::remove_child(node * nn) {
    node * p = nn->par;
    if(!p)
        return;
    if(nn == p->left)
        p->left = NULL;
    else
        p->right = NULL;
    nn->par = NULL;
    p->update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x2820
xorl %ecx, %ecx
cmpq %rax, (%rdi)
setne %cl
xorl %edx, %edx
movq %rdx, (%rdi,%rcx,8)
movq %rdx, 0x10(%rax)
popq %rbp
jmp 0x2608
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::delete_node(node*)
void BinarySearchTree::delete_node(node * nn) {
    change_root(nn);

    node * l = nn->left;
    node * r = nn->right;

    if(!l && !r) {
        return;
    }
    else if(!l) {
        remove_child(r);
    }
    else if(!r) {
        remove_child(l);
    }
    else {
        remove_child(l);
        remove_child(r);
        node * newroot = leftmost(r);
        newroot->left = l;
        newroot->update();
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x26de
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
movq %r14, %rax
orq %rbx, %rax
je 0x28db
testq %r14, %r14
je 0x289e
movq 0x10(%r14), %rdi
testq %rbx, %rbx
je 0x28bb
testq %rdi, %rdi
je 0x286e
xorl %eax, %eax
cmpq %r14, (%rdi)
setne %al
xorl %ecx, %ecx
movq %rcx, (%rdi,%rax,8)
movq %rcx, 0x10(%r14)
callq 0x2608
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x288e
xorl %eax, %eax
cmpq %rbx, (%rdi)
setne %al
xorl %ecx, %ecx
movq %rcx, (%rdi,%rax,8)
movq %rcx, 0x10(%rbx)
callq 0x2608
movq %rbx, %rdi
callq 0x28e0
movq %rax, %rdi
movq %r14, (%rax)
jmp 0x28d2
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x28db
xorl %eax, %eax
cmpq %rbx, (%rdi)
setne %al
xorl %ecx, %ecx
movq %rcx, (%rdi,%rax,8)
movq %rcx, 0x10(%rbx)
jmp 0x28d2
testq %rdi, %rdi
je 0x28db
xorl %eax, %eax
cmpq %r14, (%rdi)
setne %al
xorl %ecx, %ecx
movq %rcx, (%rdi,%rax,8)
movq %rcx, 0x10(%r14)
popq %rbx
popq %r14
popq %rbp
jmp 0x2608
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::leftmost(node*)
node * BinarySearchTree::leftmost(node * nn) {
    change_root(nn);
    while(nn->left)
        nn = nn->left;
    change_root(nn);
    return nn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x26de
movq %rbx, %r14
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x28ef
movq %r14, %rdi
callq 0x26de
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::next_in_seq(node*)
node * BinarySearchTree::next_in_seq(node * nn) {
    change_root(nn);
    nn = nn->right;
    if(!nn)
        return NULL;
    while(nn->left)
        nn = nn->left;
    change_root(nn);
    return nn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x26de
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x2936
movq %rax, %rbx
movq (%rax), %rax
testq %rax, %rax
jne 0x2921
movq %rbx, %rdi
callq 0x26de
jmp 0x2938
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::rightmost(node*)
node * BinarySearchTree::rightmost(node * nn) {
    change_root(nn);
    while(nn->right)
        nn=nn->right;
    change_root(nn);
    return nn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x26de
movq %rbx, %r14
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x2951
movq %r14, %rdi
callq 0x26de
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::get_edge(int, int)
node * EulerTourTree::get_edge(int u, int v) {
    pair <int ,int> p = make_pair(u, v);
    auto it = edgemap.find(p);
    if(it == edgemap.end())
        return NULL;
    return it->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
shlq $0x20, %rdx
movl %esi, %eax
orq %rdx, %rax
leaq -0x8(%rbp), %rsi
movq %rax, (%rsi)
addq $0x70, %rdi
callq 0x33ba
testq %rax, %rax
je 0x29d2
movq 0x10(%rax), %rax
jmp 0x29d4
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::add_node(int, node*)
void EulerTourTree::add_node(int u, node * nn) {
    BinarySearchTree::change_root(nn);
    NodeSet[u].insert(nn);
    if(!IDtoNode.count(u)) {
        IDtoNode[u]=nn;
        nn->adjacent_nodes[0] = adj_map[0][u];
        nn->adjacent_nodes[1] = adj_map[1][u];
    }
    nn->update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x24(%rbp), %r14
movl %esi, (%r14)
leaq -0x20(%rbp), %r15
movq %rdx, (%r15)
movq %rdx, %rdi
callq 0x26de
leaq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0x3456
movq %rax, %rdi
movq %r15, %rsi
callq 0x37d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3080
testq %rax, %rax
jne 0x2a6c
movq -0x20(%rbp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3118
movq %r15, (%rax)
leaq 0xa8(%rbx), %rdi
movq %r14, %rsi
callq 0x38fc
movl (%rax), %eax
movq -0x20(%rbp), %rcx
movl %eax, 0x20(%rcx)
addq $0xe0, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x38fc
movl (%rax), %eax
movq -0x20(%rbp), %rcx
movl %eax, 0x24(%rcx)
movq -0x20(%rbp), %rdi
callq 0x2608
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::remove_node(int, node*)
void EulerTourTree::remove_node(int u, node * nn) {
    int n0 = nn->adjacent_nodes[0];
    int n1 = nn->adjacent_nodes[1];
    NodeSet[u].erase(nn);
    if(NodeSet[u].empty())
        IDtoNode.erase(u);
    else {
        node * next = *NodeSet[u].begin();
        IDtoNode[u] = next;
        BinarySearchTree::change_root(next);
        next->adjacent_nodes[0] = n0;
        next->adjacent_nodes[1] = n1;
        next->update();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x2c(%rbp), %r15
movl %esi, (%r15)
leaq -0x40(%rbp), %r12
movq %rdx, (%r12)
movl 0x20(%rdx), %eax
movl %eax, -0x34(%rbp)
movl 0x24(%rdx), %eax
movl %eax, -0x30(%rbp)
leaq 0x38(%rdi), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3456
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x3e66
movq %r13, %rdi
movq %rax, %rsi
callq 0x3ee8
movq %r14, %rdi
movq %r15, %rsi
callq 0x3456
cmpq $0x0, 0x28(%rax)
je 0x2b56
movq %r14, %rdi
movq %r15, %rsi
callq 0x3456
movq 0x18(%rax), %rax
movq 0x20(%rax), %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3118
movq %r14, (%rax)
movq %r14, %rdi
callq 0x26de
movl -0x34(%rbp), %eax
movl %eax, 0x20(%r14)
movl -0x30(%rbp), %eax
movl %eax, 0x24(%r14)
movq %r14, %rdi
callq 0x2608
jmp 0x2b62
leaq -0x2c(%rbp), %rsi
movq %rbx, %rdi
callq 0x3fa2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::re_root(node*)
void EulerTourTree::re_root(node * nn) {
    BinarySearchTree::change_root(nn);
    
    if(!nn->left) //nn already in front of the tree
        return;

    node * l = nn->left;
    BinarySearchTree::remove_child(l);
    node * front = BinarySearchTree::leftmost(l);
    front->left = nn;
    nn->par = front;
    front->update();
    BinarySearchTree::change_root(nn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x26de
movq (%rbx), %r14
testq %r14, %r14
je 0x2bdf
movq %r14, %rdi
callq 0x27f8
movq %r14, %rdi
callq 0x28e0
movq %rbx, (%rax)
movq %rax, 0x10(%rbx)
movq %rax, %rdi
callq 0x2608
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x26de
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::link(int, int)
bool EulerTourTree::link(int u, int v) {
    if(is_connected(u,v))
        return false;
    node * x = get_node(u);
    node * y = get_node(v);
    if(x)
        re_root(x);
    if(y)
        re_root(y);
    node * utemp = BinarySearchTree::insert_new(x);
   // cout << "ok,y=" << v << endl;
    node * vtemp = BinarySearchTree::insert_new(y);
    utemp->value = u;
    vtemp->value = v;
    add_node(u, utemp);
    add_node(v, vtemp);
    if(!y)
        y = vtemp;
    BinarySearchTree::change_root(y);
    utemp->right = y;
    y->par = utemp;
    utemp->update();

    add_edge(u, v, utemp);
    add_edge(v, u, vtemp);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
callq 0x2cf2
testb %al, %al
jne 0x2ce0
movb %al, -0x29(%rbp)
movq %r14, %rdi
movl %r12d, -0x30(%rbp)
movl %r12d, %esi
callq 0x2970
movq %rax, %r12
movq %r14, %rdi
movl %r15d, %esi
callq 0x2970
movq %rax, %r13
testq %r12, %r12
je 0x2c3b
movq %r12, %rsi
callq 0x2b9a
testq %r13, %r13
je 0x2c48
movq %r13, %rsi
callq 0x2b9a
movq %r12, %rdi
callq 0x2658
movq %rax, %r12
movq %r13, %rdi
callq 0x2658
movq %rax, %rbx
movl -0x30(%rbp), %esi
movl %esi, 0x18(%r12)
movl %r15d, 0x18(%rax)
movq %r14, %rdi
movq %r12, %rdx
callq 0x29da
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x29da
testq %r13, %r13
cmoveq %rbx, %r13
movq %r13, %rdi
callq 0x26de
movq %r13, 0x8(%r12)
movq %r12, 0x10(%r13)
movq %r12, %rdi
callq 0x2608
shlq $0x20, %r15
movl -0x30(%rbp), %r13d
orq %r15, %r13
leaq -0x38(%rbp), %r15
movq %r13, (%r15)
addq $0x70, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3bd2
movq %r12, (%rax)
rolq $0x20, %r13
movq %r13, (%r15)
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x3bd2
movq %rbx, (%rax)
movb -0x29(%rbp), %al
xorb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::is_connected(int, int)
bool EulerTourTree::is_connected(int u, int v) {
    if(u == v)
        return true;
    node * x = get_node(u);
    node * y = get_node(v);
    if(!x || !y)
        return false;

    BinarySearchTree::change_root(x);
    BinarySearchTree::change_root(y);

    while(x->par && x->par!=y)
        BinarySearchTree::rotate(x);

    return x->par == y;

}

// Assembly:
movb $0x1, %al
cmpl %edx, %esi
je 0x2d80
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %r15
callq 0x2970
movq %rax, %rbx
movq %r15, %rdi
movl %r14d, %esi
callq 0x2970
movq %rax, %r14
testq %rbx, %rbx
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x2d74
movq %rbx, %rdi
callq 0x26de
movq %r14, %rdi
callq 0x26de
movq 0x10(%rbx), %rax
testq %rax, %rax
sete %cl
cmpq %r14, %rax
sete %al
orb %al, %cl
jne 0x2d76
movq %rbx, %rdi
callq 0x27d8
movq 0x10(%rbx), %rcx
cmpq %r14, %rcx
sete %al
testq %rcx, %rcx
je 0x2d76
cmpq %r14, %rcx
jne 0x2d56
jmp 0x2d76
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::cut(int, int)
bool EulerTourTree::cut(int u, int v) {
    node * x = get_edge(u, v);
    if(!x)
        return false;

    node * y = get_edge(v, u);
    re_root(x);
    BinarySearchTree::change_root(y);
    while(x->par != y)
        BinarySearchTree::rotate(x);
    BinarySearchTree::remove_child(x);

    node * next = BinarySearchTree::next_in_seq(y);
    if(next) {
        int temp = next->value;
        node * t = BinarySearchTree::rightmost(next);
        remove_edge(v,temp);
        add_edge(v, temp, t);
    }

    remove_node(u, x);
    remove_node(v, y);
    remove_edge(u, v);
    remove_edge(v, u);
    BinarySearchTree::delete_node(x);
    BinarySearchTree::delete_node(y);

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %r12d
movq %rdi, %r15
movl %edx, -0x38(%rbp)
movl %edx, %eax
movq %rax, -0x58(%rbp)
shlq $0x20, %rax
movl %esi, %r13d
orq %rax, %r13
leaq -0x30(%rbp), %rsi
movq %r13, (%rsi)
leaq 0x70(%rdi), %r14
movq %r14, %rdi
callq 0x33ba
testq %rax, %rax
je 0x2dca
movq 0x10(%rax), %rbx
jmp 0x2dcc
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x2ed2
movq %r15, -0x50(%rbp)
movq %r13, %rax
rolq $0x20, %rax
leaq -0x30(%rbp), %rsi
movq %rax, -0x48(%rbp)
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x33ba
testq %rax, %rax
je 0x2dfe
movq 0x10(%rax), %r15
jmp 0x2e01
xorl %r15d, %r15d
movq %rbx, %rsi
callq 0x2b9a
movq %r15, %rdi
callq 0x26de
cmpq %r15, 0x10(%rbx)
je 0x2e21
movq %rbx, %rdi
callq 0x27d8
jmp 0x2e11
movl %r12d, -0x34(%rbp)
movq %rbx, %rdi
callq 0x27f8
movq %r15, %rdi
callq 0x290a
testq %rax, %rax
je 0x2e7b
movl 0x18(%rax), %r12d
movq %rax, %rdi
callq 0x2942
movq %rax, -0x40(%rbp)
shlq $0x20, %r12
addq -0x58(%rbp), %r12
leaq -0x30(%rbp), %rsi
movq %r12, (%rsi)
movq %r14, %rdi
callq 0x408e
leaq -0x30(%rbp), %rax
movq %r12, (%rax)
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x3bd2
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %r12
movq %r12, %rdi
movl -0x34(%rbp), %esi
movq %rbx, %rdx
callq 0x2aac
movq %r12, %rdi
movl -0x38(%rbp), %esi
movq %r15, %rdx
callq 0x2aac
leaq -0x30(%rbp), %r12
movq %r13, (%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0x408e
movq -0x48(%rbp), %rax
movq %rax, (%r12)
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x408e
movq %rbx, %rdi
callq 0x2822
movq %r15, %rdi
callq 0x2822
testq %rbx, %rbx
setne %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::size(int)
int EulerTourTree::size(int u) {
    node * x = get_node(u);
    if(!x)
        return 1;
    BinarySearchTree::change_root(x);
    return x->size/2 + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x2970
testq %rax, %rax
je 0x2f13
movq %rax, %rbx
movq %rax, %rdi
callq 0x26de
movl 0x1c(%rbx), %ecx
movl %ecx, %eax
shrl $0x1f, %eax
addl %ecx, %eax
sarl %eax
incl %eax
jmp 0x2f18
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::get_adjacent(int, bool)
int EulerTourTree::get_adjacent(int u, bool is_treeedge) {
    node * x = get_node(u);
    if(!x)
        return adj_map[is_treeedge][u] > 0 ? u : -1;
    BinarySearchTree::change_root(x);
    if(x->sum_adjacent_nodes[is_treeedge] <= 0)
        return -1;
    while(adj_map[is_treeedge][x->value] == 0) {
        node * l = x->left;
        node * r = x->right;
        if(l && l->sum_adjacent_nodes[is_treeedge] > 0)
            x = l;
        else if(r && r->sum_adjacent_nodes[is_treeedge] > 0)
            x = r;
    }

    BinarySearchTree::change_root(x);
    return x->value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r15d
movq %rdi, %r14
movl %esi, -0x24(%rbp)
callq 0x2970
testq %rax, %rax
je 0x2fd6
movq %rax, %rbx
movq %rax, %rdi
callq 0x26de
movzbl %r15b, %r12d
cmpl $0x0, 0x28(%rbx,%r12,4)
jle 0x3001
imulq $0x38, %r12, %rax
addq %rax, %r14
addq $0xa8, %r14
movq %rbx, %rsi
addq $0x18, %rsi
movq %r14, %rdi
callq 0x38fc
cmpl $0x0, (%rax)
je 0x2f88
movq %rbx, %r15
jmp 0x2fc8
movq (%rbx), %r15
movq 0x8(%rbx), %rax
testq %r15, %r15
je 0x2f9c
cmpl $0x0, 0x28(%r15,%r12,4)
jg 0x2fb4
testq %rax, %rax
je 0x2fb1
cmpl $0x0, 0x28(%rax,%r12,4)
jg 0x2fac
movq %rbx, %rax
movq %rax, %r15
jmp 0x2fb4
movq %rbx, %r15
leaq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x38fc
cmpl $0x0, (%rax)
movq %r15, %rbx
je 0x2f88
movq %r15, %rdi
callq 0x26de
movl 0x18(%r15), %eax
jmp 0x3006
movzbl %r15b, %eax
imulq $0x38, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xa8, %rdi
leaq -0x24(%rbp), %rsi
callq 0x38fc
cmpl $0x0, (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jle 0x3006
movl -0x24(%rbp), %eax
jmp 0x3006
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::update_adjacent(int, int, bool)
void EulerTourTree::update_adjacent(int u, int add_adj, bool is_treeedge) {
    adj_map[is_treeedge][u] += add_adj;
    node * x = get_node(u);
    if(!x)
        return;
    BinarySearchTree::change_root(x);
    x->adjacent_nodes[is_treeedge] += add_adj;
    x->update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rdi, %r14
leaq -0x24(%rbp), %r15
movl %esi, (%r15)
movl %ecx, %r12d
imulq $0x38, %r12, %rax
addq %rax, %rdi
addq $0xa8, %rdi
movq %r15, %rsi
callq 0x38fc
addl %ebx, (%rax)
movl (%r15), %esi
movq %r14, %rdi
callq 0x2970
testq %rax, %rax
je 0x3072
movq %rax, %r14
movq %rax, %rdi
callq 0x26de
addl %ebx, 0x20(%r14,%r12,4)
movq %r14, %rdi
callq 0x2608
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/connectivity.cpp
// Function: connectivity::add_vertex(int)
void connectivity::add_vertex(int u) {
	vertices.insert(u);
	spf.push_back(EulerTourTree());
	adj.push_back(unordered_map<int, unordered_multiset<int> >());
	treeadj.push_back(unordered_map<int, unordered_multiset<int> >());
	//cout << "OK tested add_vertex" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
leaq -0x2c(%rbp), %rax
movl %esi, (%rax)
movq %rax, %rsi
callq 0x50c6
leaq -0x150(%rbp), %rdi
movl $0x118, %edx            # imm = 0x118
xorl %esi, %esi
callq 0x20d0
leaq -0x120(%rbp), %r12
movq %r12, -0x30(%r12)
movl $0x1, %eax
movq %rax, -0x28(%r12)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%r12)
movl $0x3f800000, %ecx       # imm = 0x3F800000
movl %ecx, -0x10(%r12)
movups %xmm0, -0x8(%r12)
leaq -0x118(%rbp), %r14
leaq -0xe8(%rbp), %rdx
movq %rdx, -0x30(%rdx)
movq %rax, -0x28(%rdx)
movups %xmm0, -0x20(%rdx)
movl %ecx, -0x10(%rdx)
movups %xmm0, -0x8(%rdx)
leaq -0xe0(%rbp), %r15
leaq -0xb0(%rbp), %rdx
movq %rdx, -0x30(%rdx)
movq %rax, -0x28(%rdx)
movups %xmm0, -0x20(%rdx)
movl %ecx, -0x10(%rdx)
movups %xmm0, -0x8(%rdx)
movl $0x70, %eax
leaq -0x78(%rbp), %rcx
movq %rcx, -0x30(%rcx)
movq $0x1, -0x28(%rcx)
movups %xmm0, -0x20(%rcx)
movl $0x3f800000, -0x10(%rcx) # imm = 0x3F800000
movups %xmm0, -0x8(%rcx)
addq $0x38, %rcx
addq $-0x38, %rax
jne 0x423e
leaq 0x30(%rbx), %rdi
leaq -0x150(%rbp), %rsi
callq 0x51ee
movl $0xe0, %r13d
leaq -0x150(,%r13), %rdi
addq %rbp, %rdi
callq 0x4dc2
addq $-0x38, %r13
cmpq $0x70, %r13
jne 0x4279
movq %r15, %rdi
callq 0x4e38
movq %r14, %rdi
callq 0x4eae
leaq -0x150(%rbp), %r14
movq %r14, %rdi
callq 0x4f44
leaq 0x48(%rbx), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movq $0x0, 0x30(%r14)
movq %r12, (%r14)
movq $0x1, 0x8(%r14)
movl $0x3f800000, 0x20(%r14) # imm = 0x3F800000
movups %xmm0, 0x28(%r14)
leaq -0x150(%rbp), %rsi
callq 0x568a
movq %r14, %rdi
callq 0x4fba
addq $0x60, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movq $0x0, 0x30(%r14)
movq %r12, (%r14)
movq $0x1, 0x8(%r14)
movl $0x3f800000, 0x20(%r14) # imm = 0x3F800000
movups %xmm0, 0x28(%r14)
leaq -0x150(%rbp), %rsi
movq %rbx, %rdi
callq 0x568a
leaq -0x150(%rbp), %rdi
callq 0x4fba
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x435f
movq %rax, %rbx
leaq -0x150(%rbp), %rdi
callq 0x4fba
jmp 0x437f
movq %rax, %rbx
leaq -0x150(%rbp), %rdi
callq 0x4d80
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/connectivity.cpp
// Function: connectivity::add_edge_level(int, int, int, bool)
void connectivity::add_edge_level(int u, int v, int level, bool is_treeedge) {
	if(u > v)
		swap(u, v);
	edge_level[make_pair(u,v)].insert(level);

	if(is_treeedge){
		treeadj[level][u].insert(v);
		treeadj[level][v].insert(u);
	}
	else {
		adj[level][u].insert(v);
		adj[level][v].insert(u);
	}

	spf[level].update_adjacent(u, 1, is_treeedge);
	spf[level].update_adjacent(v, 1, is_treeedge);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r14d
movq %rdi, %rbx
movl %esi, -0x34(%rbp)
movl %edx, -0x30(%rbp)
movl %ecx, -0x2c(%rbp)
cmpl %edx, %esi
jle 0x43b2
movl %edx, -0x34(%rbp)
movl %esi, -0x30(%rbp)
leaq 0x78(%rbx), %rdi
movl -0x34(%rbp), %eax
movl -0x30(%rbp), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq -0x40(%rbp), %rsi
movq %rcx, (%rsi)
callq 0x58dc
leaq -0x2c(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x5c74
movslq (%r15), %rax
imulq $0x38, %rax, %rdi
testb %r14b, %r14b
je 0x4424
addq 0x60(%rbx), %rdi
leaq -0x34(%rbp), %r15
movq %r15, %rsi
callq 0x5cb8
leaq -0x40(%rbp), %r12
movq %rax, (%r12)
leaq -0x30(%rbp), %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
callq 0x5fe8
movslq -0x2c(%rbp), %rax
imulq $0x38, %rax, %rdi
addq 0x60(%rbx), %rdi
jmp 0x445c
addq 0x48(%rbx), %rdi
leaq -0x34(%rbp), %r15
movq %r15, %rsi
callq 0x5cb8
leaq -0x40(%rbp), %r12
movq %rax, (%r12)
leaq -0x30(%rbp), %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
callq 0x5fe8
movslq -0x2c(%rbp), %rax
imulq $0x38, %rax, %rdi
addq 0x48(%rbx), %rdi
movq %r13, %rsi
callq 0x5cb8
movq %rax, (%r12)
leaq -0x40(%rbp), %rcx
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x5fe8
movslq -0x2c(%rbp), %rax
imulq $0x118, %rax, %rdi      # imm = 0x118
addq 0x30(%rbx), %rdi
movl -0x34(%rbp), %esi
movzbl %r14b, %r14d
movl $0x1, %edx
movl %r14d, %ecx
callq 0x3014
movslq -0x2c(%rbp), %rax
imulq $0x118, %rax, %rdi      # imm = 0x118
addq 0x30(%rbx), %rdi
movl -0x30(%rbp), %esi
movl $0x1, %edx
movl %r14d, %ecx
callq 0x3014
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/connectivity.cpp
// Function: connectivity::level(int, int)
int connectivity::level(int u, int v) {
	if(u > v)
		swap(u, v);
	auto it = edge_level.find(make_pair(u,v));
	if(it == edge_level.end())
		return -1;
	return *it->second.rbegin();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl %edx, %esi
movl %edx, %eax
cmovgl %esi, %eax
cmovll %esi, %edx
addq $0x78, %rdi
shlq $0x20, %rax
orq %rax, %rdx
leaq -0x8(%rbp), %rsi
movq %rdx, (%rsi)
callq 0x6542
testq %rax, %rax
je 0x487d
addq $0x18, %rax
movq %rax, %rdi
callq 0x20f0
movl 0x20(%rax), %eax
jmp 0x4882
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/connectivity.cpp
// Function: connectivity::add_edge(int, int)
bool connectivity::add_edge(int u, int v) {
	if(!vertices.count(u) || !vertices.count(v)) {
		//cout<<"F"<<endl;
		return false;		//if u or v are absent in graph
	}
	if(!spf[0].is_connected(u, v)) {
		//cout << u <<"," << v << endl;
		spf[0].link(u, v);
		add_edge_level(u, v, 0, true);
	}
	else
		add_edge_level(u, v, 0, false);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
movq 0x10(%rdi), %rcx
leaq 0x8(%rdi), %rax
movq %rax, %rdx
testq %rcx, %rcx
je 0x48c9
movq %rcx, %rsi
movq %rax, %rdx
xorl %edi, %edi
cmpl %r14d, 0x20(%rsi)
setl %dil
cmovgeq %rsi, %rdx
movq 0x10(%rsi,%rdi,8), %rsi
testq %rsi, %rsi
jne 0x48b1
movq %rax, %rsi
cmpq %rax, %rdx
je 0x48dc
cmpl %r14d, 0x20(%rdx)
cmovgq %rax, %rdx
movq %rdx, %rsi
cmpq %rax, %rsi
je 0x4958
movq %rax, %rdx
testq %rcx, %rcx
je 0x4903
movq %rax, %rdx
xorl %esi, %esi
cmpl %ebx, 0x20(%rcx)
setl %sil
cmovgeq %rcx, %rdx
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x48ec
movq %rax, %rcx
cmpq %rax, %rdx
je 0x4915
cmpl %ebx, 0x20(%rdx)
cmovgq %rax, %rdx
movq %rdx, %rcx
cmpq %rax, %rcx
je 0x4958
movq 0x30(%r15), %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0x2cf2
movl %eax, %r12d
testb %al, %al
jne 0x493d
movq 0x30(%r15), %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0x2be4
xorb $0x1, %r12b
movzbl %r12b, %r8d
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x4388
movb $0x1, %al
jmp 0x495a
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/connectivity.cpp
// Function: connectivity::is_connected(int, int)
bool connectivity::is_connected(int u, int v) {
	if(!vertices.count(u) || !vertices.count(v))
		return false;
	if(u == v)
		return true;
	return spf[0].is_connected(u, v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rcx
leaq 0x8(%rdi), %rax
movq %rax, %r8
testq %rcx, %rcx
je 0x4d19
movq %rcx, %r9
movq %rax, %r8
xorl %r10d, %r10d
cmpl %esi, 0x20(%r9)
setl %r10b
cmovgeq %r9, %r8
movq 0x10(%r9,%r10,8), %r9
testq %r9, %r9
jne 0x4d00
movq %rax, %r9
cmpq %rax, %r8
je 0x4d2c
cmpl %esi, 0x20(%r8)
cmovgq %rax, %r8
movq %r8, %r9
cmpq %rax, %r9
je 0x4d7c
movq %rax, %r8
testq %rcx, %rcx
je 0x4d54
movq %rax, %r8
xorl %r9d, %r9d
cmpl %edx, 0x20(%rcx)
setl %r9b
cmovgeq %rcx, %r8
movq 0x10(%rcx,%r9,8), %rcx
testq %rcx, %rcx
jne 0x4d3c
movq %rax, %rcx
cmpq %rax, %r8
je 0x4d67
cmpl %edx, 0x20(%r8)
cmovgq %rax, %r8
movq %r8, %rcx
cmpq %rax, %rcx
je 0x4d7c
movb $0x1, %al
cmpl %edx, %esi
je 0x4d7e
movq 0x30(%rdi), %rdi
popq %rbp
jmp 0x2cf2
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/MST.cpp
// Function: MST::add_vertex(int)
void MST::add_vertex(int u) {
	vertices.insert(u);
	min_spf.push_back(EulerTourTree());
	adj.push_back(unordered_map<int, multiset<pair<int,int>>>());
	treeadj.push_back(unordered_map<int, multiset<pair<int,int>>>());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
leaq -0x2c(%rbp), %rax
movl %esi, (%rax)
addq $0x38, %rdi
movq %rax, %rsi
callq 0x50c6
leaq -0x150(%rbp), %rdi
movl $0x118, %edx            # imm = 0x118
xorl %esi, %esi
callq 0x20d0
leaq -0x120(%rbp), %r12
movq %r12, -0x30(%r12)
movl $0x1, %eax
movq %rax, -0x28(%r12)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%r12)
movl $0x3f800000, %ecx       # imm = 0x3F800000
movl %ecx, -0x10(%r12)
movups %xmm0, -0x8(%r12)
leaq -0x118(%rbp), %r14
leaq -0xe8(%rbp), %rdx
movq %rdx, -0x30(%rdx)
movq %rax, -0x28(%rdx)
movups %xmm0, -0x20(%rdx)
movl %ecx, -0x10(%rdx)
movups %xmm0, -0x8(%rdx)
leaq -0xe0(%rbp), %r15
leaq -0xb0(%rbp), %rdx
movq %rdx, -0x30(%rdx)
movq %rax, -0x28(%rdx)
movups %xmm0, -0x20(%rdx)
movl %ecx, -0x10(%rdx)
movups %xmm0, -0x8(%rdx)
movl $0x70, %eax
leaq -0x78(%rbp), %rcx
movq %rcx, -0x30(%rcx)
movq $0x1, -0x28(%rcx)
movups %xmm0, -0x20(%rcx)
movl $0x3f800000, -0x10(%rcx) # imm = 0x3F800000
movups %xmm0, -0x8(%rcx)
addq $0x38, %rcx
addq $-0x38, %rax
jne 0x663a
leaq 0x68(%rbx), %rdi
leaq -0x150(%rbp), %rsi
callq 0x51ee
movl $0xe0, %r13d
leaq -0x150(,%r13), %rdi
addq %rbp, %rdi
callq 0x4dc2
addq $-0x38, %r13
cmpq $0x70, %r13
jne 0x6675
movq %r15, %rdi
callq 0x4e38
movq %r14, %rdi
callq 0x4eae
leaq -0x150(%rbp), %r14
movq %r14, %rdi
callq 0x4f44
leaq 0xb8(%rbx), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movq $0x0, 0x30(%r14)
movq %r12, (%r14)
movq $0x1, 0x8(%r14)
movl $0x3f800000, 0x20(%r14) # imm = 0x3F800000
movups %xmm0, 0x28(%r14)
leaq -0x150(%rbp), %rsi
callq 0x79a8
movq %r14, %rdi
callq 0x7862
addq $0xd0, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movq $0x0, 0x30(%r14)
movq %r12, (%r14)
movq $0x1, 0x8(%r14)
movl $0x3f800000, 0x20(%r14) # imm = 0x3F800000
movups %xmm0, 0x28(%r14)
leaq -0x150(%rbp), %rsi
movq %rbx, %rdi
callq 0x79a8
leaq -0x150(%rbp), %rdi
callq 0x7862
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6761
movq %rax, %rbx
leaq -0x150(%rbp), %rdi
callq 0x7862
jmp 0x6781
movq %rax, %rbx
leaq -0x150(%rbp), %rdi
callq 0x4d80
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O1/yogesh1q2w[P]Dynamic-Graph-Algorithms/MST.cpp
// Function: MST::add_edge(int, int, int)
bool MST::add_edge(int u, int v, int wt) {
	if(!vertices.count(u) || !vertices.count(v)) {
        return false;
    }

    adj_list[u].push_back(make_pair(v,wt));
	adj_list[v].push_back(make_pair(u,wt));
    weight[make_pair(u,v)] = wt;
	weight[make_pair(v,u)] = wt;

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movq %rdi, %r14
movl %esi, -0x28(%rbp)
movl %edx, -0x24(%rbp)
movq 0x48(%rdi), %rcx
leaq 0x40(%rdi), %rax
movq %rax, %rdi
testq %rcx, %rcx
je 0x6dc1
movq %rcx, %r8
movq %rax, %rdi
xorl %r9d, %r9d
cmpl %esi, 0x20(%r8)
setl %r9b
cmovgeq %r8, %rdi
movq 0x10(%r8,%r9,8), %r8
testq %r8, %r8
jne 0x6da8
movq %rax, %r8
cmpq %rax, %rdi
je 0x6dd3
cmpl %esi, 0x20(%rdi)
cmovgq %rax, %rdi
movq %rdi, %r8
cmpq %rax, %r8
je 0x6e49
movq %rax, %rsi
testq %rcx, %rcx
je 0x6dfa
movq %rax, %rsi
xorl %edi, %edi
cmpl %edx, 0x20(%rcx)
setl %dil
cmovgeq %rcx, %rsi
movq 0x10(%rcx,%rdi,8), %rcx
testq %rcx, %rcx
jne 0x6de3
movq %rax, %rcx
cmpq %rax, %rsi
je 0x6e0c
cmpl %edx, 0x20(%rsi)
cmovgq %rax, %rsi
movq %rsi, %rcx
cmpq %rax, %rcx
je 0x6e49
leaq 0x80(%r14), %r15
leaq -0x28(%rbp), %rsi
movq %r15, %rdi
callq 0x834e
movl -0x24(%rbp), %ecx
movq %rbx, %r12
shlq $0x20, %r12
orq %r12, %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x6e50
movq %rcx, (%rsi)
addq $0x8, 0x8(%rax)
jmp 0x6e5c
xorl %eax, %eax
jmp 0x6ed3
leaq -0x30(%rbp), %rdx
movq %rax, %rdi
callq 0x8676
leaq -0x24(%rbp), %rsi
movq %r15, %rdi
callq 0x834e
movl -0x28(%rbp), %ecx
orq %rcx, %r12
movq %r12, -0x30(%rbp)
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x6e86
movq %r12, (%rsi)
addq $0x8, 0x8(%rax)
jmp 0x6e92
leaq -0x30(%rbp), %rdx
movq %rax, %rdi
callq 0x8676
movl -0x28(%rbp), %eax
movl -0x24(%rbp), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq -0x30(%rbp), %r15
movq %rcx, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x7f1c
movl %ebx, (%rax)
movl -0x24(%rbp), %eax
movl -0x28(%rbp), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, (%r15)
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x7f1c
movl %ebx, (%rax)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq