LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0xd370
movq -0x108(%rbp), %rdi
leaq 0x9312(%rip), %rsi      # 0x1624f
callq 0x3330
jmp 0xcf44
leaq -0x40(%rbp), %rdi
leaq 0x90ff(%rip), %rsi      # 0x1604e
callq 0x3330
jmp 0xcf56
leaq -0x20(%rbp), %rax
movq %rax, -0x110(%rbp)
leaq 0x92a6(%rip), %rdx      # 0x1620e
leaq -0xb0(%rbp), %rdi
movq %rdx, %rsi
callq 0xd3b0
jmp 0xcf79
movq -0x110(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x75f0
jmp 0xcf8e
leaq -0xb0(%rbp), %rdi
callq 0x7660
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x3360
leaq -0x100(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0xd490
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x130(%rbp)
callq 0xba00
movq -0x130(%rbp), %rsi
movslq (%rax), %rax
movq %rax, -0x128(%rbp)
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
callq 0xba00
movq -0x128(%rbp), %rdi
movq -0x120(%rbp), %rcx
movq -0x118(%rbp), %r9
movslq 0x4(%rax), %rsi
movq -0x8(%rbp), %rdx
addq $0x38, %rdx
leaq -0x60(%rbp), %r8
callq 0x4520
jmp 0xd022
leaq 0x922b(%rip), %rsi      # 0x16254
leaq -0xd0(%rbp), %rdi
callq 0x3420
jmp 0xd037
movq -0x8(%rbp), %rdi
subq $-0x80, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd4b0
movq %rax, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x3040
jmp 0xd059
movq -0x8(%rbp), %rdi
subq $-0x80, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd4b0
movq %rax, %rdi
addq $0x20, %rdi
leaq -0x60(%rbp), %rsi
callq 0xd4d0
jmp 0xd07c
leaq -0x100(%rbp), %rdi
callq 0xd530
leaq -0xd0(%rbp), %rdi
callq 0x3170
leaq -0x60(%rbp), %rdi
callq 0xd550
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xd0f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x7660
jmp 0xd0f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x100(%rbp), %rdi
callq 0xd530
leaq -0xd0(%rbp), %rdi
callq 0x3170
leaq -0x60(%rbp), %rdi
callq 0xd550
movq -0x68(%rbp), %rdi
callq 0x33f0
nopw %cs:(%rax,%rax)
// File: 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 %dil, %al
movb %al, -0x2(%rbp)
movq 0x4f0f(%rip), %rax      # 0x161b0
movq %rax, -0x20(%rbp)
movq 0x4f0c(%rip), %rax      # 0x161b8
movq %rax, -0x18(%rbp)
movq 0x4f09(%rip), %rax      # 0x161c0
movq %rax, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movsbl -0x20(%rbp,%rax), %eax
cmpl $0x23, %eax
je 0x112f4
movslq -0x24(%rbp), %rax
movsbl -0x20(%rbp,%rax), %eax
movsbl -0x2(%rbp), %ecx
cmpl %ecx, %eax
jne 0x112e7
movb $0x1, -0x1(%rbp)
jmp 0x112f8
jmp 0x112e9
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x112c2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x68, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb7b0
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
callq 0xb840
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
callq 0xb8b0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xb870
testb $0x1, %al
jne 0x15549
jmp 0x156a2
leaq -0x10(%rbp), %rdi
callq 0xb8e0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3450
movsbl (%rax), %eax
cmpl $0x63, %eax
jne 0x1568e
leaq -0x10(%rbp), %rdi
callq 0xb8e0
movq %rax, %rdi
movl $0x1, %esi
callq 0x3450
movsbl (%rax), %eax
cmpl $0x6c, %eax
jne 0x1568e
leaq -0x10(%rbp), %rdi
callq 0xb8e0
movq %rax, %rdi
movl $0x2, %esi
callq 0x3450
movsbl (%rax), %eax
cmpl $0x61, %eax
jne 0x1568e
leaq -0x10(%rbp), %rdi
callq 0xb8e0
movq %rax, %rdi
movl $0x3, %esi
callq 0x3450
movsbl (%rax), %eax
cmpl $0x73, %eax
jne 0x1568e
leaq -0x10(%rbp), %rdi
callq 0xb8e0
movq %rax, %rdi
movl $0x4, %esi
callq 0x3450
movsbl (%rax), %eax
cmpl $0x73, %eax
jne 0x1568e
leaq -0x10(%rbp), %rdi
callq 0xb8e0
movq -0x50(%rbp), %rdi
movl 0x20(%rax), %eax
movl %eax, -0x1c(%rbp)
addq $0x38, %rdi
callq 0xb840
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xb900
movl %eax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xb950
movq %rax, %rdi
callq 0xb8e0
movl 0x20(%rax), %eax
cmpl -0x1c(%rbp), %eax
jle 0x15662
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
callq 0xb840
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb900
subq $0x1, %rax
movl %eax, -0x24(%rbp)
jmp 0x15622
movq -0x50(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0xb9a0
movq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xb970
jmp 0x1569d
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x156b0
movq %rax, -0x48(%rbp)
jmp 0x15522
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x35d40
movq -0x10(%rbp), %rax
leaq 0x31dac(%rip), %rcx     # 0x67660
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x3, 0x98(%rax)
movq $0x0, 0x88(%rax)
movq $0x0, 0x80(%rax)
movq $0x0, 0x90(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x35d40
movq -0x30(%rbp), %rax
leaq 0x31d3c(%rip), %rcx     # 0x67660
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x80(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x88(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x90(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x98(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x2ff0
cmpl $0x0, %eax
jne 0x24a6
movq 0x5b3d(%rip), %rdi      # 0x7fd0
leaq 0x2b6a(%rip), %rsi      # 0x5004
callq 0x2130
xorl %edi, %edi
callq 0x2170
leaq -0x4(%rbp), %rdi
callq 0x2ff0
movl %eax, -0xc(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x2ff0
movl %eax, %ecx
movl -0xc(%rbp), %eax
cltd
idivl %ecx
movl %edx, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tobias93[P]piano/rtmidi_build/tests/sysextest.cpp
// Function: mycallback(double, std::vector<unsigned char, std::allocator<unsigned char>>*, void*)
void mycallback( double deltatime, std::vector< unsigned char > *message, void * /*userData*/ )
{
  unsigned int nBytes = message->size();
  for ( unsigned int i=0; i<nBytes; i++ )
    std::cout << "Byte " << i << " = " << (int)message->at(i) << ", ";
  if ( nBytes > 0 )
    std::cout << "stamp = " << deltatime << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4010
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x3555
movq 0x5ad9(%rip), %rdi      # 0x8fd0
leaq 0x2b57(%rip), %rsi      # 0x6055
callq 0x3170
movq %rax, %rdi
movl -0x20(%rbp), %esi
callq 0x3240
movq %rax, %rdi
leaq 0x2b4b(%rip), %rsi      # 0x6063
callq 0x3170
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x4030
movq -0x28(%rbp), %rdi
movzbl (%rax), %esi
callq 0x32e0
movq %rax, %rdi
leaq 0x2b16(%rip), %rsi      # 0x605b
callq 0x3170
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x34e8
cmpl $0x0, -0x1c(%rbp)
jbe 0x358a
movq 0x5a6e(%rip), %rdi      # 0x8fd0
leaq 0x2af5(%rip), %rsi      # 0x605e
callq 0x3170
movq %rax, %rdi
movsd -0x8(%rbp), %xmm0
callq 0x3320
movq %rax, %rdi
movq 0x5a3b(%rip), %rsi      # 0x8fc0
callq 0x31a0
addq $0x30, %rsp
popq %rbp
retq
// File: 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
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x1, 0x1c(%rax)
movl 0x20(%rax), %ecx
movl %ecx, 0x28(%rax)
movl 0x24(%rax), %ecx
movl %ecx, 0x2c(%rax)
cmpq $0x0, (%rax)
je 0x2591
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl 0x1c(%rcx), %ecx
addl 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rax)
movq (%rax), %rcx
movl 0x28(%rcx), %ecx
addl 0x28(%rax), %ecx
movl %ecx, 0x28(%rax)
movq (%rax), %rcx
movl 0x2c(%rcx), %ecx
addl 0x2c(%rax), %ecx
movl %ecx, 0x2c(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x25c7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movl 0x1c(%rcx), %ecx
addl 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rax)
movq 0x8(%rax), %rcx
movl 0x28(%rcx), %ecx
addl 0x28(%rax), %ecx
movl %ecx, 0x28(%rax)
movq 0x8(%rax), %rcx
movl 0x2c(%rcx), %ecx
addl 0x2c(%rax), %ecx
movl %ecx, 0x2c(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2625
movl $0x30, %edi
callq 0x2170
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x24f0
jmp 0x25fe
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x26b5
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2140
jmp 0x26bf
movq -0x10(%rbp), %rdi
callq 0x26d0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2647
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x262e
movl $0x30, %edi
callq 0x2170
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x24f0
jmp 0x2662
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x2540
movq -0x28(%rbp), %rdi
callq 0x26d0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x26b5
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2140
jmp 0x26bf
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2250
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x26e8
jmp 0x2779
jmp 0x26ea
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2779
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2723
movq -0x8(%rbp), %rdi
callq 0x2900
jmp 0x2779
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
cmpq (%rdx), %rcx
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x2762
movq -0x10(%rbp), %rdi
callq 0x2900
movq -0x8(%rbp), %rdi
callq 0x2900
jmp 0x2774
movq -0x8(%rbp), %rdi
callq 0x2900
movq -0x8(%rbp), %rdi
callq 0x2900
jmp 0x26ea
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x27ea
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x27dc
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x27e8
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x27ea
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x2820
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x2540
movq -0x8(%rbp), %rdi
callq 0x2540
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x28ab
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x289d
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x28a9
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x28ab
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x28e1
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x2540
movq -0x8(%rbp), %rdi
callq 0x2540
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2921
jmp 0x2942
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x2939
movq -0x8(%rbp), %rdi
callq 0x2840
jmp 0x2942
movq -0x8(%rbp), %rdi
callq 0x2780
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2971
jmp 0x29ac
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x298b
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
jmp 0x2997
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x2540
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x26d0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x29fc
cmpq $0x0, -0x18(%rbp)
jne 0x29fc
jmp 0x2a57
cmpq $0x0, -0x10(%rbp)
jne 0x2a0e
movq -0x18(%rbp), %rdi
callq 0x2950
jmp 0x2a55
cmpq $0x0, -0x18(%rbp)
jne 0x2a20
movq -0x10(%rbp), %rdi
callq 0x2950
jmp 0x2a53
movq -0x10(%rbp), %rdi
callq 0x2950
movq -0x18(%rbp), %rdi
callq 0x2950
movq -0x18(%rbp), %rdi
callq 0x2a60
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x2540
jmp 0x2a55
jmp 0x2a57
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x26d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2a8c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2a75
movq -0x8(%rbp), %rdi
callq 0x26d0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2ad2
movq $0x0, -0x8(%rbp)
jmp 0x2afc
jmp 0x2ad4
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2aeb
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2ad4
movq -0x10(%rbp), %rdi
callq 0x26d0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x26d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2b3e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2b25
movq -0x8(%rbp), %rdi
callq 0x26d0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3520
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x70, %rdi
leaq -0x20(%rbp), %rsi
callq 0x3550
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x70, %rdi
callq 0x35b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3580
testb $0x1, %al
jne 0x2c14
jmp 0x2c1e
movq $0x0, -0x8(%rbp)
jmp 0x2c2f
leaq -0x28(%rbp), %rdi
callq 0x35e0
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x26d0
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
leaq -0xc(%rbp), %rsi
callq 0x3610
movq %rax, %rdi
leaq -0x18(%rbp), %rsi
callq 0x3640
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movb %dl, -0x20(%rbp)
leaq -0xc(%rbp), %rsi
callq 0x34c0
cmpq $0x0, %rax
jne 0x2cf5
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0xc(%rbp), %rsi
callq 0x34f0
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rdi
movq %rcx, (%rax)
addq $0xa8, %rdi
leaq -0xc(%rbp), %rsi
callq 0x3690
movq -0x30(%rbp), %rdi
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
addq $0xa8, %rdi
addq $0x38, %rdi
leaq -0xc(%rbp), %rsi
callq 0x3690
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rdi
callq 0x2540
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x24(%rax), %eax
movl %eax, -0x20(%rbp)
addq $0x38, %rdi
leaq -0xc(%rbp), %rsi
callq 0x3610
movq %rax, %rdi
leaq -0x18(%rbp), %rsi
callq 0x36f0
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
leaq -0xc(%rbp), %rsi
callq 0x3610
movq %rax, %rdi
callq 0x3720
testb $0x1, %al
jne 0x2dd7
jmp 0x2de6
movq -0x38(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x3740
jmp 0x2e55
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
leaq -0xc(%rbp), %rsi
callq 0x3610
movq %rax, %rdi
callq 0x3770
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x37a0
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0xc(%rbp), %rsi
callq 0x34f0
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x26d0
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x28(%rbp), %rdi
callq 0x2540
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26d0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2ed5
jmp 0x2f1f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2950
movq -0x18(%rbp), %rdi
callq 0x2a60
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rdi
callq 0x2540
movq -0x10(%rbp), %rdi
callq 0x26d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x3070
testb $0x1, %al
jne 0x2f5b
jmp 0x2f64
movb $0x0, -0x1(%rbp)
jmp 0x305d
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2b60
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %esi
callq 0x2b60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2f98
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2eb0
cmpq $0x0, -0x28(%rbp)
je 0x2fac
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2eb0
movq -0x20(%rbp), %rdi
callq 0x25d0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x25d0
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x18(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x14(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x2c40
movq -0x40(%rbp), %rdi
movl -0x18(%rbp), %esi
movq -0x38(%rbp), %rdx
callq 0x2c40
cmpq $0x0, -0x28(%rbp)
jne 0x3009
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x26d0
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rdi
callq 0x2540
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x30(%rbp), %rcx
callq 0x2d10
movq -0x40(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
movq -0x38(%rbp), %rcx
callq 0x2d10
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x309b
movb $0x1, -0x1(%rbp)
jmp 0x312b
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2b60
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %esi
callq 0x2b60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x30c9
cmpq $0x0, -0x28(%rbp)
jne 0x30cf
movb $0x0, -0x1(%rbp)
jmp 0x312b
movq -0x20(%rbp), %rdi
callq 0x26d0
movq -0x28(%rbp), %rdi
callq 0x26d0
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x10(%rcx)
movb %al, -0x31(%rbp)
je 0x3103
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x28(%rbp), %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x310c
jmp 0x3117
movq -0x20(%rbp), %rdi
callq 0x2900
jmp 0x30e1
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x28(%rbp), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x2bb0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3179
movb $0x0, -0x1(%rbp)
jmp 0x3265
movq -0x48(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x2bb0
movq -0x48(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rsi
callq 0x2eb0
movq -0x28(%rbp), %rdi
callq 0x26d0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x28(%rbp), %rax
je 0x31bb
movq -0x20(%rbp), %rdi
callq 0x2900
jmp 0x31a2
movq -0x20(%rbp), %rdi
callq 0x2950
movq -0x28(%rbp), %rdi
callq 0x2aa0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3211
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2b10
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
movl -0x18(%rbp), %esi
movl -0x34(%rbp), %edx
callq 0x2e60
movq -0x48(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x34(%rbp), %edx
movq -0x40(%rbp), %rcx
callq 0x2d10
movq -0x48(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x2d70
movq -0x48(%rbp), %rdi
movl -0x18(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x2d70
movq -0x48(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x2e60
movq -0x48(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x2e60
movq -0x20(%rbp), %rdi
callq 0x29c0
movq -0x28(%rbp), %rdi
callq 0x29c0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2b60
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x329f
movl $0x1, -0x4(%rbp)
jmp 0x32bd
movq -0x20(%rbp), %rdi
callq 0x26d0
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0x14(%rbp), %esi
callq 0x2b60
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3346
movq -0x38(%rbp), %rdi
addq $0xa8, %rdi
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
imulq $0x38, %rax, %rax
addq %rax, %rdi
leaq -0x14(%rbp), %rsi
callq 0x3690
cmpl $0x0, (%rax)
jle 0x3331
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x333b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x3c(%rbp)
jmp 0x333b
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3416
movq -0x20(%rbp), %rdi
callq 0x26d0
movq -0x20(%rbp), %rax
movb -0x15(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl $0x0, 0x28(%rax,%rcx,4)
jg 0x336f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3416
jmp 0x3371
movq -0x38(%rbp), %rdi
addq $0xa8, %rdi
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
imulq $0x38, %rax, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
addq $0x18, %rsi
callq 0x3690
cmpl $0x0, (%rax)
jne 0x3403
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x33d9
movq -0x28(%rbp), %rax
movb -0x15(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl $0x0, 0x28(%rax,%rcx,4)
jle 0x33d9
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x33fe
cmpq $0x0, -0x30(%rbp)
je 0x33fc
movq -0x30(%rbp), %rax
movb -0x15(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl $0x0, 0x28(%rax,%rcx,4)
jle 0x33fc
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x33fe
jmp 0x3371
movq -0x20(%rbp), %rdi
callq 0x26d0
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0xa8, %rdi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
imulq $0x38, %rax, %rax
addq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x3690
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rdi
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0xc(%rbp), %esi
callq 0x2b60
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3486
jmp 0x34b0
movq -0x20(%rbp), %rdi
callq 0x26d0
movl -0x10(%rbp), %edx
movq -0x20(%rbp), %rax
movb -0x11(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl 0x20(%rax,%rcx,4), %edx
movl %edx, 0x20(%rax,%rcx,4)
movq -0x20(%rbp), %rdi
callq 0x2540
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
leaq -0xc(%rbp), %rsi
callq 0xa7c0
movq %rax, %rcx
movq -0x1d8(%rbp), %rax
movq %rcx, -0x20(%rbp)
movb %dl, -0x18(%rbp)
addq $0x30, %rax
movq %rax, -0x1d0(%rbp)
leaq -0x138(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
xorl %esi, %esi
movl $0x118, %edx            # imm = 0x118
callq 0x20c0
movq -0x1c8(%rbp), %rdi
callq 0xa840
movq -0x1d0(%rbp), %rdi
movq -0x1c8(%rbp), %rsi
callq 0xa810
jmp 0x9c6d
leaq -0x138(%rbp), %rdi
callq 0xa8c0
movq -0x1d8(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x1e8(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x160(%rbp)
movaps %xmm0, -0x170(%rbp)
movaps %xmm0, -0x180(%rbp)
movq $0x0, -0x150(%rbp)
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1e0(%rbp)
callq 0xa970
movq -0x1e8(%rbp), %rdi
movq -0x1e0(%rbp), %rsi
callq 0xa940
jmp 0x9cd6
leaq -0x180(%rbp), %rdi
callq 0xa990
movq -0x1d8(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x1f8(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x1a0(%rbp)
movaps %xmm0, -0x1b0(%rbp)
movaps %xmm0, -0x1c0(%rbp)
movq $0x0, -0x190(%rbp)
leaq -0x1c0(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0xa970
movq -0x1f8(%rbp), %rdi
movq -0x1f0(%rbp), %rsi
callq 0xa940
jmp 0x9d3f
leaq -0x1c0(%rbp), %rdi
callq 0xa990
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
leaq -0x138(%rbp), %rdi
callq 0xa8c0
jmp 0x9db2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
leaq -0x180(%rbp), %rdi
callq 0xa990
jmp 0x9db2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0xa990
movq -0x140(%rbp), %rdi
callq 0x2250
nop
// File: 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
subq $0x60, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x9dfa
leaq -0xc(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xa9b0
movq -0x50(%rbp), %rax
addq $0x78, %rax
movq %rax, -0x58(%rbp)
leaq -0xc(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x3520
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0xa9e0
movq %rax, %rdi
leaq -0x14(%rbp), %rsi
callq 0xaa10
movq %rax, -0x28(%rbp)
testb $0x1, -0x15(%rbp)
je 0x9e96
movq -0x50(%rbp), %rdi
addq $0x60, %rdi
movslq -0x14(%rbp), %rsi
callq 0xaa50
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0xaa70
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0xaaa0
movq -0x50(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x60, %rdi
movslq -0x14(%rbp), %rsi
callq 0xaa50
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0xaa70
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0xaaa0
movq %rax, -0x38(%rbp)
jmp 0x9ef0
movq -0x50(%rbp), %rdi
addq $0x48, %rdi
movslq -0x14(%rbp), %rsi
callq 0xaa50
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0xaa70
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0xaaa0
movq -0x50(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x48, %rdi
movslq -0x14(%rbp), %rsi
callq 0xaa50
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0xaa70
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0xaaa0
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
movslq -0x14(%rbp), %rsi
callq 0xaad0
movq %rax, %rdi
movl -0xc(%rbp), %esi
movb -0x15(%rbp), %al
movl $0x1, %edx
andb $0x1, %al
movzbl %al, %ecx
callq 0x3420
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
movslq -0x14(%rbp), %rsi
callq 0xaad0
movq %rax, %rdi
movl -0x10(%rbp), %esi
movb -0x15(%rbp), %al
movl $0x1, %edx
andb $0x1, %al
movzbl %al, %ecx
callq 0x3420
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0xa21f
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xa9b0
movq -0x40(%rbp), %rax
addq $0x78, %rax
movq %rax, -0x48(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3520
movq -0x48(%rbp), %rdi
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0xac10
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x78, %rdi
callq 0xac70
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xac40
testb $0x1, %al
jne 0xa271
jmp 0xa27a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa2a1
leaq -0x20(%rbp), %rdi
callq 0xaca0
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x38(%rbp), %rdi
callq 0xacd0
leaq -0x38(%rbp), %rdi
callq 0xad00
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq -0x14(%rbp), %rsi
callq 0xad30
cmpq $0x0, %rax
je 0xa2ec
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xad30
cmpq $0x0, %rax
jne 0xa2f2
movb $0x0, -0x1(%rbp)
jmp 0xa366
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xaad0
movq %rax, %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x3070
testb $0x1, %al
jne 0xa34d
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xaad0
movq %rax, %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x2f30
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x9dc0
jmp 0xa362
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x9dc0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq -0x14(%rbp), %rsi
callq 0xad30
cmpq $0x0, %rax
je 0xa77c
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xad30
cmpq $0x0, %rax
jne 0xa782
movb $0x0, -0x1(%rbp)
jmp 0xa7b4
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0xa790
movb $0x1, -0x1(%rbp)
jmp 0xa7b4
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xaad0
movq %rax, %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x3070
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop