LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::num_edges()
int Graph::num_edges() {
	EdgeList el;
	GRA::iterator git;
	int num = 0;
	for (git = graph.begin(); git != graph.end(); git++) {
		el = git->outList;
		num += el.size();
	}
	return num;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x11160
leaq 0x40(%rsp), %rdi
callq 0x11f50
movq 0x8(%rsp), %rdi
movl $0x0, 0x3c(%rsp)
addq $0x48, %rdi
callq 0x12490
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0x12500
movq %rax, 0x28(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x124c0
testb $0x1, %al
jne 0x7194
jmp 0x71f7
leaq 0x40(%rsp), %rdi
callq 0x12570
movq %rax, %rsi
addq $0x18, %rsi
leaq 0x48(%rsp), %rdi
callq 0x11fb0
jmp 0x71b1
leaq 0x48(%rsp), %rdi
callq 0x4c10
movq %rax, %rcx
movslq 0x3c(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x3c(%rsp)
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x12580
movq %rax, 0x10(%rsp)
jmp 0x716c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x115a0
jmp 0x7212
movl 0x3c(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x115a0
movl 0x4(%rsp), %eax
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x34e0
nopl (%rax)
// File: datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::getRoots()
vector<int> Graph::getRoots() {
	vector<int> roots;

	for(int i=0; i<vsize; i++){
		if(vl[i].indegree==0)
			roots.push_back(i);
	}
	
	return roots;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x37(%rsp)
callq 0x11160
movl $0x0, 0x30(%rsp)
movq 0x18(%rsp), %rcx
movl 0x30(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x731a
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movslq 0x30(%rsp), %rsi
callq 0x11d40
cmpl $0x0, 0x8(%rax)
jne 0x730b
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x12660
jmp 0x72ef
jmp 0x730b
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x115a0
jmp 0x733a
jmp 0x730d
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x72b7
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x7330
movq 0x8(%rsp), %rdi
callq 0x115a0
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::getTails()
vector<int> Graph::getTails(){
	vector<int> tails;

	for(int i=0; i<vsize; i++){
		if(vl[i].outdegree==0)
			tails.push_back(i);
	}

	return tails;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x37(%rsp)
callq 0x11160
movl $0x0, 0x30(%rsp)
movq 0x18(%rsp), %rcx
movl 0x30(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x73ea
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movslq 0x30(%rsp), %rsi
callq 0x11d40
cmpl $0x0, 0xc(%rax)
jne 0x73db
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x12660
jmp 0x73bf
jmp 0x73db
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x115a0
jmp 0x740a
jmp 0x73dd
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x7387
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x7400
movq 0x8(%rsp), %rdi
callq 0x115a0
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::hasEdge(int, int)
bool Graph::hasEdge(int src, int trg) {
	EdgeList el = graph[src].outList;
	EdgeList::iterator ei;
	for (ei = el.begin(); ei != el.end(); ei++)
		if ((*ei) == trg)
			return true;
	return false;

}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movl %edx, 0x40(%rsp)
movq 0x48(%rsp), %rdi
addq $0x48, %rdi
movslq 0x44(%rsp), %rsi
callq 0x11d60
movq %rax, %rsi
addq $0x18, %rsi
leaq 0x28(%rsp), %rdi
callq 0x126d0
leaq 0x20(%rsp), %rdi
callq 0x11f70
leaq 0x28(%rsp), %rdi
callq 0x12270
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x122e0
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x122a0
testb $0x1, %al
jne 0x749c
jmp 0x74d1
leaq 0x20(%rsp), %rdi
callq 0x12310
movl (%rax), %eax
cmpl 0x40(%rsp), %eax
jne 0x74bd
movb $0x1, 0x57(%rsp)
movl $0x1, 0xc(%rsp)
jmp 0x74de
jmp 0x74bf
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x12320
movq %rax, (%rsp)
jmp 0x7478
movb $0x0, 0x57(%rsp)
movl $0x1, 0xc(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x115a0
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::Graph(Graph const&)
Graph::Graph(const Graph& g) {
	if (this != &g) {
		this->graph = g.graph;
		this->vl = g.vl;
		this->vsize = g.vsize;
		this->name=g.name;
	}
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x50(%rsp)
addq $0x10, %rdi
movq %rdi, (%rsp)
callq 0x33e0
movq 0x50(%rsp), %rdi
addq $0x30, %rdi
movq %rdi, 0x8(%rsp)
callq 0x11140
movq 0x50(%rsp), %rdi
addq $0x48, %rdi
movq %rdi, 0x10(%rsp)
callq 0x11150
movq 0x50(%rsp), %rdi
addq $0x60, %rdi
movq %rdi, 0x18(%rsp)
callq 0x11160
movq 0x50(%rsp), %rdi
addq $0x78, %rdi
movq %rdi, 0x20(%rsp)
callq 0x11170
movq 0x50(%rsp), %rdi
addq $0x90, %rdi
movq %rdi, 0x28(%rsp)
callq 0x11170
movq 0x50(%rsp), %rdi
addq $0xa8, %rdi
movq %rdi, 0x30(%rsp)
callq 0x11180
movq 0x50(%rsp), %rdi
addq $0xc0, %rdi
movq %rdi, 0x38(%rsp)
callq 0x11190
movq 0x50(%rsp), %rdi
addq $0xd8, %rdi
movq %rdi, 0x40(%rsp)
callq 0x11190
movq 0x50(%rsp), %rdi
addq $0xf0, %rdi
movq %rdi, 0x48(%rsp)
callq 0x11170
movq 0x50(%rsp), %rax
cmpq 0x68(%rsp), %rax
je 0x76ca
movq 0x50(%rsp), %rdi
movq 0x68(%rsp), %rsi
addq $0x48, %rsi
addq $0x48, %rdi
callq 0x11620
jmp 0x7618
movq 0x50(%rsp), %rdi
movq 0x68(%rsp), %rsi
addq $0x30, %rsi
addq $0x30, %rdi
callq 0x118e0
jmp 0x7631
movq 0x50(%rsp), %rdi
movq 0x68(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rdi)
movq 0x68(%rsp), %rsi
addq $0x10, %rsi
addq $0x10, %rdi
callq 0x3040
jmp 0x7655
jmp 0x76ca
movq 0x48(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x11480
movq 0x40(%rsp), %rdi
callq 0x114e0
movq 0x38(%rsp), %rdi
callq 0x114e0
movq 0x30(%rsp), %rdi
callq 0x11540
movq 0x28(%rsp), %rdi
callq 0x11480
movq 0x20(%rsp), %rdi
callq 0x11480
movq 0x18(%rsp), %rdi
callq 0x115a0
movq 0x10(%rsp), %rdi
callq 0x111e0
movq 0x8(%rsp), %rdi
callq 0x11280
movq (%rsp), %rdi
callq 0x31b0
jmp 0x76cf
addq $0x78, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x34e0
nopl (%rax)
// File: datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::operator=(Graph const&)
Graph& Graph::operator=(const Graph& g) {
	if (this != &g) {
		graph = g.graph;
		vl = g.vl;
		vsize = g.vsize;
		name=g.name;
	}
	return *this;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq 0x8(%rsp), %rax
je 0x774b
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x48, %rsi
addq $0x48, %rdi
callq 0x11620
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x30, %rsi
addq $0x30, %rdi
callq 0x118e0
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rdi)
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
addq $0x10, %rdi
callq 0x3040
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::countIndegree() const
void Graph::countIndegree() const {
	vector<int> count(100, 0);
	int i;
	string name="data\\"+name+"_count.txt";

	for(i=0; i<vsize; i++){
		if(vl[i].indegree<100){
			count[vl[i].indegree]++;
		}else
			count[99]++;
	}

	ofstream output(name.c_str());
	for(i=0;i<100;i++){
		output << count[i] << endl;
	}

	output.close();
}

// Assembly:
subq $0x298, %rsp            # imm = 0x298
movq %rdi, 0x290(%rsp)
movq 0x290(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x274(%rsp)
leaq 0x273(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x12990
movq 0x18(%rsp), %rcx
leaq 0x278(%rsp), %rdi
movl $0x64, %esi
leaq 0x274(%rsp), %rdx
callq 0x12bf0
jmp 0x8d1a
leaq 0x273(%rsp), %rdi
callq 0x12a20
leaq 0x1f73b(%rip), %rsi     # 0x28469
leaq 0x220(%rsp), %rdi
leaq 0x240(%rsp), %rdx
callq 0x12cc0
jmp 0x8d45
leaq 0x1f723(%rip), %rdx     # 0x2846f
leaq 0x240(%rsp), %rdi
leaq 0x220(%rsp), %rsi
callq 0x12c70
jmp 0x8d63
leaq 0x220(%rsp), %rdi
callq 0x31b0
movl $0x0, 0x260(%rsp)
movq 0x10(%rsp), %rcx
movl 0x260(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x8e76
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
movslq 0x260(%rsp), %rsi
callq 0x12df0
cmpl $0x64, 0x8(%rax)
jge 0x8e45
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
movslq 0x260(%rsp), %rsi
callq 0x12df0
movslq 0x8(%rax), %rsi
leaq 0x278(%rsp), %rdi
callq 0x12960
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x8e5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x268(%rsp)
movl %eax, 0x264(%rsp)
leaq 0x273(%rsp), %rdi
callq 0x12a20
jmp 0x8f88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x268(%rsp)
movl %eax, 0x264(%rsp)
jmp 0x8f7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x268(%rsp)
movl %eax, 0x264(%rsp)
leaq 0x220(%rsp), %rdi
callq 0x31b0
jmp 0x8f7b
leaq 0x278(%rsp), %rdi
movl $0x63, %esi
callq 0x12960
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x8e60
movl 0x260(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x260(%rsp)
jmp 0x8d7b
leaq 0x240(%rsp), %rdi
callq 0x3120
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
movl $0x10, %edx
callq 0x3320
jmp 0x8e97
movl $0x0, 0x260(%rsp)
cmpl $0x64, 0x260(%rsp)
jge 0x8f36
movslq 0x260(%rsp), %rsi
leaq 0x278(%rsp), %rdi
callq 0x12960
movl (%rax), %esi
leaq 0x20(%rsp), %rdi
callq 0x34d0
movq %rax, 0x8(%rsp)
jmp 0x8ed8
movq 0x8(%rsp), %rdi
movq 0x2c0e4(%rip), %rsi     # 0x34fc8
callq 0x3300
jmp 0x8eeb
jmp 0x8eed
movl 0x260(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x260(%rsp)
jmp 0x8ea2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x268(%rsp)
movl %eax, 0x264(%rsp)
jmp 0x8f6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x268(%rsp)
movl %eax, 0x264(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x3420
jmp 0x8f6e
leaq 0x20(%rsp), %rdi
callq 0x3400
jmp 0x8f42
leaq 0x20(%rsp), %rdi
callq 0x3420
leaq 0x240(%rsp), %rdi
callq 0x31b0
leaq 0x278(%rsp), %rdi
callq 0x115a0
addq $0x298, %rsp            # imm = 0x298
retq
leaq 0x240(%rsp), %rdi
callq 0x31b0
leaq 0x278(%rsp), %rdi
callq 0x115a0
movq 0x268(%rsp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::checkReverseLayerSeparation()
void Graph::checkReverseLayerSeparation(){
	int u,v;
	bool flag=false;

	for (u=0; u<vsize; u++){
		for(int j=0; j<graph[u].inList.size(); j++){
			v=graph[u].inList[j];
			if(vl[v].layer<=vl[u].layer){
				cout << " checkLayerSeparation: Error" << endl;
				quit();
			}
		}

		for (int j=0; j<graph[u].outList.size(); j++){
			v=graph[u].outList[j];
			if(vl[u].layer-vl[v].layer==1)
				flag=true;
		}
		if(flag||graph[u].outList.size()==0)
			flag=false;
		else{
			cout << " checkLayerSeparation: No good separation" << endl;
			quit();
		}
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x37(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x20(%rsp), %rcx
movl 0x3c(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x9443
movl $0x0, 0x30(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x48, %rdi
movslq 0x3c(%rsp), %rsi
callq 0x11d60
movq %rax, %rdi
callq 0x4c10
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x931a
movq 0x20(%rsp), %rdi
addq $0x48, %rdi
movslq 0x3c(%rsp), %rsi
callq 0x11d60
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0x12960
movq 0x20(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x38(%rsp)
addq $0x30, %rdi
movslq 0x38(%rsp), %rsi
callq 0x11d40
movq 0x20(%rsp), %rdi
movzwl (%rax), %eax
movl %eax, 0x14(%rsp)
addq $0x30, %rdi
movslq 0x3c(%rsp), %rsi
callq 0x11d40
movq %rax, %rcx
movl 0x14(%rsp), %eax
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jg 0x9308
movq 0x2bcf0(%rip), %rdi     # 0x34fd8
leaq 0x1f18b(%rip), %rsi     # 0x2847a
callq 0x32c0
movq %rax, %rdi
movq 0x2bcca(%rip), %rsi     # 0x34fc8
callq 0x3300
callq 0x4da0
jmp 0x930a
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x924a
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x2c(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x48, %rdi
movslq 0x3c(%rsp), %rsi
callq 0x11d60
movq %rax, %rdi
addq $0x18, %rdi
callq 0x4c10
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x93d7
movq 0x20(%rsp), %rdi
addq $0x48, %rdi
movslq 0x3c(%rsp), %rsi
callq 0x11d60
movq %rax, %rdi
addq $0x18, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x12960
movq 0x20(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x38(%rsp)
addq $0x30, %rdi
movslq 0x3c(%rsp), %rsi
callq 0x11d40
movq 0x20(%rsp), %rdi
movzwl (%rax), %eax
movl %eax, 0x4(%rsp)
addq $0x30, %rdi
movslq 0x38(%rsp), %rsi
callq 0x11d40
movq %rax, %rcx
movl 0x4(%rsp), %eax
movzwl (%rcx), %ecx
subl %ecx, %eax
cmpl $0x1, %eax
jne 0x93c5
movb $0x1, 0x37(%rsp)
jmp 0x93c7
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x9322
testb $0x1, 0x37(%rsp)
jne 0x9403
movq 0x20(%rsp), %rdi
addq $0x48, %rdi
movslq 0x3c(%rsp), %rsi
callq 0x11d60
movq %rax, %rdi
addq $0x18, %rdi
callq 0x4c10
cmpq $0x0, %rax
jne 0x940a
movb $0x0, 0x37(%rsp)
jmp 0x9431
movq 0x2bbc7(%rip), %rdi     # 0x34fd8
leaq 0x1f07f(%rip), %rsi     # 0x28497
callq 0x32c0
movq %rax, %rdi
movq 0x2bba1(%rip), %rsi     # 0x34fc8
callq 0x3300
callq 0x4da0
jmp 0x9433
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x9230
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::FindStructureEq(std::vector<bool, std::allocator<bool>>&)
int Graph::FindStructureEq(vector<bool>& SEflag){
	SEflag.clear();
	SEflag.resize(vsize,false);
	int secount=0;

	for(int i=0; i<vsize; i++){
		if(i%1000==0)
			cout << i << ": " << secount << endl;
		if(SEflag[i]==false){
			for(int j=i+1; j<vsize; j++){
				if(SEflag[j]==false){
					if(graph[i]==graph[j]){
						secount++;
						SEflag[j]=true;
					}
				}
			}
		}
	}

	return secount;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0x13050
movq 0x10(%rsp), %rax
movq 0x58(%rsp), %rdi
movslq 0xc(%rax), %rsi
xorl %edx, %edx
callq 0x130b0
movl $0x0, 0x54(%rsp)
movl $0x0, 0x50(%rsp)
movq 0x10(%rsp), %rcx
movl 0x50(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x9df8
movl 0x50(%rsp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x9ce4
movl 0x50(%rsp), %esi
movq 0x2b323(%rip), %rdi     # 0x34fd8
callq 0x34d0
movq %rax, %rdi
leaq 0x1e6e8(%rip), %rsi     # 0x283ac
callq 0x32c0
movq %rax, %rdi
movl 0x54(%rsp), %esi
callq 0x34d0
movq %rax, %rdi
movq 0x2b2e9(%rip), %rsi     # 0x34fc8
callq 0x3300
movq 0x58(%rsp), %rdi
movslq 0x50(%rsp), %rsi
callq 0x12f10
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x12fc0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x9de6
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x3c(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x9de4
movq 0x58(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0x12f10
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x12fc0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x9dd2
movq 0x10(%rsp), %rdi
addq $0x48, %rdi
movslq 0x50(%rsp), %rsi
callq 0x11d60
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x48, %rdi
movslq 0x3c(%rsp), %rsi
callq 0x11d60
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x13200
testb $0x1, %al
jne 0x9d9d
jmp 0x9dd0
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
movq 0x58(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0x12f10
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x12f70
jmp 0x9dd2
jmp 0x9dd4
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x9d20
jmp 0x9de6
jmp 0x9de8
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x9c87
movl 0x54(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::BFSQuery(unsigned int, unsigned int)
unsigned int Graph::BFSQuery(const unsigned int u, const unsigned int v){
	if(u==v)
		return 0;

	vector<bool> flag(vsize, false);
	set<unsigned int> qvertice;
	unsigned int tmpv;

	flag[u]=true;
	for(int i=0; i<graph[u].outList.size(); i++){
		tmpv=graph[u].outList[i];
		qvertice.insert(tmpv);
	}

	return BFSSubQuery(qvertice, v, 1, flag);
}

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0xe8(%rsp)
movl %esi, 0xe4(%rsp)
movl %edx, 0xe0(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0xe4(%rsp), %eax
cmpl 0xe0(%rsp), %eax
jne 0xb16a
movl $0x0, 0xf4(%rsp)
jmp 0xb35b
movq 0x38(%rsp), %rax
movslq 0xc(%rax), %rax
movq %rax, 0x28(%rsp)
movb $0x0, 0xb7(%rsp)
leaq 0xb6(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x12e40
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rcx
leaq 0xb8(%rsp), %rdi
leaq 0xb7(%rsp), %rdx
callq 0x12e50
jmp 0xb1b3
leaq 0xb6(%rsp), %rdi
callq 0x12ed0
leaq 0x70(%rsp), %rdi
callq 0x13320
movl 0xe4(%rsp), %eax
movl %eax, %esi
leaq 0xb8(%rsp), %rdi
callq 0x12f10
movq %rdx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
jmp 0xb1ec
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x58(%rsp)
movq %rax, 0x60(%rsp)
leaq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0x12f70
movl $0x0, 0x54(%rsp)
movq 0x38(%rsp), %rdi
movslq 0x54(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x48, %rdi
movl 0xe4(%rsp), %eax
movl %eax, %esi
callq 0x11d60
movq %rax, %rdi
addq $0x18, %rdi
callq 0x4c10
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0xb312
movq 0x38(%rsp), %rdi
addq $0x48, %rdi
movl 0xe4(%rsp), %eax
movl %eax, %esi
callq 0x11d60
movq %rax, %rdi
addq $0x18, %rdi
movslq 0x54(%rsp), %rsi
callq 0x12960
movl (%rax), %eax
movl %eax, 0x6c(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x6c(%rsp), %rsi
callq 0x13330
movb %dl, 0x7(%rsp)
movq %rax, 0x8(%rsp)
jmp 0xb29d
movb 0x7(%rsp), %al
movq 0x8(%rsp), %rcx
movq %rcx, 0x40(%rsp)
movb %al, 0x48(%rsp)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0xb217
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0xb6(%rsp), %rdi
callq 0x12ed0
jmp 0xb36a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x13390
leaq 0xb8(%rsp), %rdi
callq 0x13030
jmp 0xb36a
movq 0x38(%rsp), %rdi
movl 0xe0(%rsp), %edx
leaq 0x70(%rsp), %rsi
movl $0x1, %ecx
leaq 0xb8(%rsp), %r8
callq 0xb380
movl %eax, (%rsp)
jmp 0xb33a
movl (%rsp), %eax
movl %eax, 0xf4(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x13390
leaq 0xb8(%rsp), %rdi
callq 0x13030
movl 0xf4(%rsp), %eax
addq $0xf8, %rsp
retq
movq 0xa8(%rsp), %rdi
callq 0x34e0
nopw (%rax,%rax)
// File: datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::ComputeOutSet(unsigned int, std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int>>&)
void Graph::ComputeOutSet(const unsigned int u, set<unsigned int>& out){
	unsigned int v;
	pair< set<unsigned int>::iterator, bool > flag;

	flag=out.insert(u);
	if(flag.second){
		for(int i=0; i<graph[u].outList.size(); i++){
			v=graph[u].outList[i];
			ComputeOutSet(v, out);
		}
	}
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x13560
movq 0x50(%rsp), %rdi
leaq 0x5c(%rsp), %rsi
callq 0x13330
movb %dl, 0x20(%rsp)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x28(%rsp)
movb 0x20(%rsp), %al
movb %al, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x13590
testb $0x1, 0x40(%rsp)
je 0xb834
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movslq 0x14(%rsp), %rax
movq %rax, (%rsp)
addq $0x48, %rdi
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x11d60
movq %rax, %rdi
addq $0x18, %rdi
callq 0x4c10
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0xb832
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x11d60
movq %rax, %rdi
addq $0x18, %rdi
movslq 0x14(%rsp), %rsi
callq 0x12960
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %esi
movq 0x50(%rsp), %rdx
callq 0xb740
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xb7b2
jmp 0xb834
addq $0x68, %rsp
retq
nopl (%rax)
// File: datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::ComputeInSet(unsigned int, std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int>>&)
void Graph::ComputeInSet(const unsigned int v, set<unsigned int>& in){
	unsigned int u;
	pair< set<unsigned int>::iterator, bool > flag;

	flag=in.insert(v);
	if(flag.second){
		for(int i=0; i<graph[v].inList.size(); i++){
			u=graph[v].inList[i];
			ComputeInSet(u, in);
		}
	}
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x13560
movq 0x50(%rsp), %rdi
leaq 0x5c(%rsp), %rsi
callq 0x13330
movb %dl, 0x20(%rsp)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x28(%rsp)
movb 0x20(%rsp), %al
movb %al, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x13590
testb $0x1, 0x40(%rsp)
je 0xb92c
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movslq 0x14(%rsp), %rax
movq %rax, (%rsp)
addq $0x48, %rdi
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x11d60
movq %rax, %rdi
callq 0x4c10
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0xb92a
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x11d60
movq %rax, %rdi
movslq 0x14(%rsp), %rsi
callq 0x12960
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %esi
movq 0x50(%rsp), %rdx
callq 0xb840
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xb8b2
jmp 0xb92c
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::InitialProLabel()
void Graph::InitialProLabel(){
	int i, j;

	srand(time(0));
	vector< vector<int> > (vsize).swap(ProLabelOut);

	for(int u=0; u<vsize; u++){
		ProLabelOut[u].push_back(u);
	}

	for(i=vsize-1; i>=1; i--){
		j=Rand64()%(i+1);
		swap(ProLabelOut[j][0], ProLabelOut[i][0]);
	}

	ProLabelIn=ProLabelOut;

}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x3280
movl %eax, %edi
callq 0x32b0
movq 0x10(%rsp), %rax
movslq 0xc(%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x13260
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x135c0
jmp 0xb996
movq 0x10(%rsp), %rsi
addq $0x78, %rsi
leaq 0x40(%rsp), %rdi
callq 0x13640
leaq 0x40(%rsp), %rdi
callq 0x11480
leaq 0x3f(%rsp), %rdi
callq 0x132f0
movl $0x0, 0x28(%rsp)
movq 0x10(%rsp), %rcx
movl 0x28(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0xba1d
movq 0x10(%rsp), %rdi
addq $0x78, %rdi
movslq 0x28(%rsp), %rsi
callq 0x4bf0
movq %rax, %rdi
leaq 0x28(%rsp), %rsi
callq 0x12660
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0xb9c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x132f0
jmp 0xbac7
movq 0x10(%rsp), %rax
movl 0xc(%rax), %eax
subl $0x1, %eax
movl %eax, 0x5c(%rsp)
cmpl $0x1, 0x5c(%rsp)
jl 0xbaaa
callq 0x127e0
movq 0x10(%rsp), %rdi
movl 0x5c(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0x58(%rsp)
addq $0x78, %rdi
movslq 0x58(%rsp), %rsi
callq 0x4bf0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12960
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x78, %rdi
movslq 0x5c(%rsp), %rsi
callq 0x4bf0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12960
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x12810
movl 0x5c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0xba2c
movq 0x10(%rsp), %rdi
movq %rdi, %rsi
addq $0x78, %rsi
addq $0x90, %rdi
callq 0x136a0
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::ComputeProLabelOut()
void Graph::ComputeProLabelOut(){
	int u;
	unsigned int tmpsize;

	for(int i=vsize-1; i>=0; i--){
		u=TopoOrder[i];
		tmpsize=graph[u].outList.size();

		if(tmpsize==0){
			continue;
		}else if(tmpsize==1){
			VectorUnion(ProLabelOut[u], ProLabelOut[graph[u].outList[0]]);
		}else if(tmpsize==2){
			VectorUnion(ProLabelOut[u], ProLabelOut[graph[u].outList[0]]);
			VectorUnion(ProLabelOut[u], ProLabelOut[graph[u].outList[1]]);
		}else{
			SubComputeProLabelOut(u);
		}

	}

}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0xc(%rax), %eax
subl $0x1, %eax
movl %eax, 0x44(%rsp)
cmpl $0x0, 0x44(%rsp)
jl 0xbcc0
movq 0x38(%rsp), %rdi
addq $0x60, %rdi
movslq 0x44(%rsp), %rsi
callq 0x12960
movq 0x38(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x4c(%rsp)
addq $0x48, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x11d60
movq %rax, %rdi
addq $0x18, %rdi
callq 0x4c10
movl %eax, 0x48(%rsp)
cmpl $0x0, 0x48(%rsp)
jne 0xbb50
jmp 0xbcb0
cmpl $0x1, 0x48(%rsp)
jne 0xbbc2
movq 0x38(%rsp), %rdi
addq $0x78, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x4bf0
movq 0x38(%rsp), %rdi
movq %rax, 0x30(%rsp)
movq %rdi, %rax
addq $0x78, %rax
movq %rax, 0x28(%rsp)
addq $0x48, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x11d60
movq %rax, %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12960
movq 0x28(%rsp), %rdi
movslq (%rax), %rsi
callq 0x4bf0
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %rax, %rdx
callq 0xbcd0
jmp 0xbcac
cmpl $0x2, 0x48(%rsp)
jne 0xbc9c
movq 0x38(%rsp), %rdi
addq $0x78, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x4bf0
movq 0x38(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq %rdi, %rax
addq $0x78, %rax
movq %rax, 0x8(%rsp)
addq $0x48, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x11d60
movq %rax, %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12960
movq 0x8(%rsp), %rdi
movslq (%rax), %rsi
callq 0x4bf0
movq 0x10(%rsp), %rsi
movq 0x38(%rsp), %rdi
movq %rax, %rdx
callq 0xbcd0
movq 0x38(%rsp), %rdi
addq $0x78, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x4bf0
movq 0x38(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq %rdi, %rax
addq $0x78, %rax
movq %rax, 0x18(%rsp)
addq $0x48, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x11d60
movq %rax, %rdi
addq $0x18, %rdi
movl $0x1, %esi
callq 0x12960
movq 0x18(%rsp), %rdi
movslq (%rax), %rsi
callq 0x4bf0
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
callq 0xbcd0
jmp 0xbcaa
movq 0x38(%rsp), %rdi
movl 0x4c(%rsp), %esi
callq 0xca90
jmp 0xbcac
jmp 0xbcae
jmp 0xbcb0
movl 0x44(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0xbafd
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::ComputeProLabelIn()
void Graph::ComputeProLabelIn(){
	int v;
	unsigned int tmpsize;

	for(int i=0; i<vsize; i++){
		v=TopoOrder[i];
		tmpsize=graph[v].inList.size();

		if(tmpsize==0){
			continue;
		}else if(tmpsize==1){
			VectorUnion(ProLabelIn[v], ProLabelIn[graph[v].inList[0]]);
		}else if(tmpsize==2){
			VectorUnion(ProLabelIn[v], ProLabelIn[graph[v].inList[0]]);
			VectorUnion(ProLabelIn[v], ProLabelIn[graph[v].inList[1]]);
		}else{
			SubComputeProLabelIn(v);
		}

	}
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x44(%rsp)
movq 0x38(%rsp), %rcx
movl 0x44(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0xd434
movq 0x38(%rsp), %rdi
addq $0x60, %rdi
movslq 0x44(%rsp), %rsi
callq 0x12960
movq 0x38(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x4c(%rsp)
addq $0x48, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x11d60
movq %rax, %rdi
callq 0x4c10
movl %eax, 0x48(%rsp)
cmpl $0x0, 0x48(%rsp)
jne 0xd2c1
jmp 0xd424
cmpl $0x1, 0x48(%rsp)
jne 0xd334
movq 0x38(%rsp), %rdi
addq $0x90, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x4bf0
movq 0x38(%rsp), %rdi
movq %rax, 0x30(%rsp)
movq %rdi, %rax
addq $0x90, %rax
movq %rax, 0x28(%rsp)
addq $0x48, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x11d60
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12960
movq 0x28(%rsp), %rdi
movslq (%rax), %rsi
callq 0x4bf0
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %rax, %rdx
callq 0xbcd0
jmp 0xd420
cmpl $0x2, 0x48(%rsp)
jne 0xd410
movq 0x38(%rsp), %rdi
addq $0x90, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x4bf0
movq 0x38(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq %rdi, %rax
addq $0x90, %rax
movq %rax, 0x8(%rsp)
addq $0x48, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x11d60
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12960
movq 0x8(%rsp), %rdi
movslq (%rax), %rsi
callq 0x4bf0
movq 0x10(%rsp), %rsi
movq 0x38(%rsp), %rdi
movq %rax, %rdx
callq 0xbcd0
movq 0x38(%rsp), %rdi
addq $0x90, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x4bf0
movq 0x38(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq %rdi, %rax
addq $0x90, %rax
movq %rax, 0x18(%rsp)
addq $0x48, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x11d60
movq %rax, %rdi
movl $0x1, %esi
callq 0x12960
movq 0x18(%rsp), %rdi
movslq (%rax), %rsi
callq 0x4bf0
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
callq 0xbcd0
jmp 0xd41e
movq 0x38(%rsp), %rdi
movl 0x4c(%rsp), %esi
callq 0xd440
jmp 0xd420
jmp 0xd422
jmp 0xd424
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0xd26b
addq $0x58, %rsp
retq
nopl (%rax)
// File: datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::ComputeHugeNodeList()
void Graph::ComputeHugeNodeList(){
	vector< vector<int> > (vsize).swap(HugeNodeList);

	if(HUGENODENUM==0)
		return ;

	for(int i=0; i<vsize; i++){
		if(vl[i].outdegree > hugenode){
			HugeNodeList[i].push_back(i);
		}
	}

	int u, v;
	int tmpsize;

	for(int i=0; i<vsize; i++){
		v=TopoOrder[i];
		tmpsize=graph[v].inList.size();
		for(int j=0; j<tmpsize; j++){
			u=graph[v].inList[j];
			if(HugeNodeList[u].empty()==false){
				HugeNodeListUnion(HugeNodeList[v], HugeNodeList[u]);
			}
		}

	}

}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movslq 0xc(%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x13260
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x58(%rsp), %rdi
callq 0x135c0
jmp 0xec71
movq 0x10(%rsp), %rsi
addq $0xf0, %rsi
leaq 0x58(%rsp), %rdi
callq 0x13640
leaq 0x58(%rsp), %rdi
callq 0x11480
leaq 0x57(%rsp), %rdi
callq 0x132f0
movq 0x10(%rsp), %rax
cmpl $0x0, 0x4(%rax)
jne 0xecc8
jmp 0xee4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x57(%rsp), %rdi
callq 0x132f0
jmp 0xee52
movl $0x0, 0x40(%rsp)
movq 0x10(%rsp), %rcx
movl 0x40(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0xed30
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
movslq 0x40(%rsp), %rsi
callq 0x11d40
movq 0x10(%rsp), %rcx
movl 0xc(%rax), %eax
cmpl 0x8(%rcx), %eax
jle 0xed21
movq 0x10(%rsp), %rdi
addq $0xf0, %rdi
movslq 0x40(%rsp), %rsi
callq 0x4bf0
movq %rax, %rdi
leaq 0x40(%rsp), %rsi
callq 0x12660
jmp 0xed23
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0xecd0
movl $0x0, 0x30(%rsp)
movq 0x10(%rsp), %rcx
movl 0x30(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0xee4d
movq 0x10(%rsp), %rdi
addq $0x60, %rdi
movslq 0x30(%rsp), %rsi
callq 0x12960
movq 0x10(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x38(%rsp)
addq $0x48, %rdi
movslq 0x38(%rsp), %rsi
callq 0x11d60
movq %rax, %rdi
callq 0x4c10
movl %eax, 0x34(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0xee3b
movq 0x10(%rsp), %rdi
addq $0x48, %rdi
movslq 0x38(%rsp), %rsi
callq 0x11d60
movq %rax, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x12960
movq 0x10(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x3c(%rsp)
addq $0xf0, %rdi
movslq 0x3c(%rsp), %rsi
callq 0x4bf0
movq %rax, %rdi
callq 0x142d0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xee29
movq 0x10(%rsp), %rdi
addq $0xf0, %rdi
movslq 0x38(%rsp), %rsi
callq 0x4bf0
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0xf0, %rdi
movslq 0x3c(%rsp), %rsi
callq 0x4bf0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0xee60
jmp 0xee2b
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xed8a
jmp 0xee3d
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0xed38
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x34e0
nopl (%rax)
// File: datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::IsContradict(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
bool Graph::IsContradict(vector<int>& v1, vector<int>& v2){
        vector<int>::iterator it1=v1.begin(), it2=v2.begin();

        if(*(v1.end()-1) < *it2)
                return false;

        while(it1!=v1.end()&&it2!=v2.end()){
                if(*it1 == *it2){
                        it1++;
                        it2++;
                }else if(*it1 < *it2){
                        it1++;
                }else{
                        return true;
                }
        }

        return false;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x12270
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x12270
movq %rax, 0x48(%rsp)
movq 0x60(%rsp), %rdi
callq 0x122e0
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x13c10
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x12310
movl (%rax), %eax
movl %eax, 0xc(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x12310
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jge 0x11043
movb $0x0, 0x77(%rsp)
jmp 0x11133
jmp 0x11045
movq 0x60(%rsp), %rdi
callq 0x122e0
movq %rax, 0x30(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x122a0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xb(%rsp)
jne 0x11072
jmp 0x11094
movq 0x58(%rsp), %rdi
callq 0x122e0
movq %rax, 0x28(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x122a0
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x110a1
jmp 0x1112e
leaq 0x50(%rsp), %rdi
callq 0x12310
movl (%rax), %eax
movl %eax, 0x4(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x12310
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl (%rcx), %eax
jne 0x110ea
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0x12320
movq %rax, 0x20(%rsp)
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x12320
movq %rax, 0x18(%rsp)
jmp 0x11129
leaq 0x50(%rsp), %rdi
callq 0x12310
movl (%rax), %eax
movl %eax, (%rsp)
leaq 0x48(%rsp), %rdi
callq 0x12310
movq %rax, %rcx
movl (%rsp), %eax
cmpl (%rcx), %eax
jge 0x11120
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0x12320
movq %rax, 0x10(%rsp)
jmp 0x11127
movb $0x1, 0x77(%rsp)
jmp 0x11133
jmp 0x11129
jmp 0x11045
movb $0x0, 0x77(%rsp)
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
nop
// File: datourat[P]IP-label-for-graph-reachability/./Graph.h
// Function: Vertex::Vertex()
Vertex(){
		layer=0;
		indegree=0;
		outdegree=0;
		topoID=0;
//		id=INT_MAX;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movw $0x0, (%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x4(%rax)
retq
nopw %cs:(%rax,%rax)
nop
// File: datourat[P]IP-label-for-graph-reachability/./Util.h
// Function: bool VectorEq<int>(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&)
bool VectorEq(const vector<T>& v1, const vector<T>& v2){
	if(v1.size()!=v2.size())
		return false;

	for(int i=0; i<v1.size(); i++){
		if(v1[i]!=v2[i])
			return false;
	}

	return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4c10
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4c10
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x14efb
movb $0x0, 0x37(%rsp)
jmp 0x14f6e
movl $0x0, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4c10
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x14f69
movq 0x28(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x13300
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x13300
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl (%rcx), %eax
je 0x14f5a
movb $0x0, 0x37(%rsp)
jmp 0x14f6e
jmp 0x14f5c
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x14f03
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: asd00012334[P]Abstract-Algebra-2018/./prime.hpp
// Function: prime::buildPrimeList()
void buildPrimeList(){
    sieve[0]=true; sieve[1]=true;
    for(int i=2;i<primeRange;++i){
        if(!sieve[i]) primeList[primeListSize++]=i;
        for(int j=0;j<primeListSize && (ll)i*primeList[j]<primeRange;++j){
            sieve[(ll)i*primeList[j]]=true;
            if(i%primeList[j]==0) break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, 0x1dd72(%rip)     # 0x201c0
movl $0x1, 0x1dd6c(%rip)     # 0x201c4
movl $0x2, -0x4(%rbp)
cmpl $0x2000000, -0x4(%rbp)  # imm = 0x2000000
jge 0x253f
movslq -0x4(%rbp), %rcx
leaq 0x1dd49(%rip), %rax     # 0x201c0
cmpl $0x0, (%rax,%rcx,4)
jne 0x249e
movl -0x4(%rbp), %edx
movl 0x1001dd3a(%rip), %eax  # 0x100201c0
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x1001dd2f(%rip)  # 0x100201c0
movslq %eax, %rcx
leaq 0x801dd25(%rip), %rax   # 0x80201c0
movl %edx, (%rax,%rcx,4)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %ecx
xorl %eax, %eax
cmpl 0x1001dd10(%rip), %ecx  # 0x100201c0
movb %al, -0x9(%rbp)
jge 0x24d8
movslq -0x4(%rbp), %rax
movslq -0x8(%rbp), %rdx
leaq 0x801dcfc(%rip), %rcx   # 0x80201c0
movslq (%rcx,%rdx,4), %rcx
imulq %rcx, %rax
cmpq $0x2000000, %rax        # imm = 0x2000000
setl %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x24e1
jmp 0x252f
movslq -0x4(%rbp), %rcx
movslq -0x8(%rbp), %rdx
leaq 0x801dcd0(%rip), %rax   # 0x80201c0
movslq (%rax,%rdx,4), %rax
imulq %rax, %rcx
leaq 0x1dcc1(%rip), %rax     # 0x201c0
movl $0x1, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
movslq -0x8(%rbp), %rsi
leaq 0x801dcac(%rip), %rcx   # 0x80201c0
cltd
idivl (%rcx,%rsi,4)
cmpl $0x0, %edx
jne 0x251f
jmp 0x252f
jmp 0x2521
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x24a5
jmp 0x2531
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x245f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: PolynomialSpecialized<prime::IntType, int>::operator%(prime::Zp const&) const
Polynomial<prime::Zp,prime::ZpElement>
PolynomialSpecialized<prime::IntType,int>::operator%(prime::Zp const& zp)const{
    Polynomial<prime::Zp,prime::ZpElement> out;
    auto This = static_cast<Polynomial<prime::IntType,int>const*>(this);
    out.canonicalType.scalar = &zp;

    for(int i=0;i<This->coef.size();++i)
        out.coef.push_back(prime::ZpElement(&zp,This->coef[i]));
    out.reduce();
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x4870
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, (%rdi)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
callq 0x48b0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x291e
movq -0x60(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x4900
movq -0x80(%rbp), %rsi
movslq (%rax), %rdx
leaq -0x48(%rbp), %rdi
callq 0x27b0
jmp 0x28e8
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x48d0
jmp 0x28fa
jmp 0x28fc
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x288d
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x49b0
jmp 0x2949
movq -0x60(%rbp), %rdi
callq 0x4920
jmp 0x2929
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x293c
movq -0x60(%rbp), %rdi
callq 0x49b0
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
// File: asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: PolynomialSpecialized<quotient::FracType, quotient::fraction>::diff() const
Polynomial<quotient::FracType,quotient::fraction>
PolynomialSpecialized<quotient::FracType,quotient::fraction>::diff()const{
    Polynomial<quotient::FracType,quotient::fraction> out;
    auto This = static_cast<Polynomial<quotient::FracType,quotient::fraction>const*>(this);
    out.canonicalType.scalar = This->canonicalType.scalar;
    out.coef.resize(This->coef.size()-1,0);
    for(int i=This->coef.size()-1;i>0;--i)
        out.coef[i-1] = This->coef[i]*i;
    out.reduce();
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x49d0
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
addq $0x10, %rdi
movq %rdi, -0x70(%rbp)
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x4ac0
decq %rax
movq %rax, -0x68(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x4ae0
jmp 0x29d3
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x4a10
jmp 0x29e6
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x4ac0
subq $0x1, %rax
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jle 0x2aab
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movslq -0x40(%rbp), %rsi
callq 0x4b10
movq %rax, -0x90(%rbp)
movslq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x4ae0
jmp 0x2a2b
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4b30
movq %rdx, -0xa0(%rbp)
movq %rax, -0x98(%rbp)
jmp 0x2a4b
movq -0x78(%rbp), %rdi
movq -0xa0(%rbp), %rax
movq -0x98(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq %rax, -0x48(%rbp)
addq $0x10, %rdi
movl -0x40(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x4b90
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x40(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x29fa
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x4c40
jmp 0x2ad9
movq -0x78(%rbp), %rdi
callq 0x4bb0
jmp 0x2ab6
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2ac9
movq -0x78(%rbp), %rdi
callq 0x4c40
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
// File: asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: testFraction()
void testFraction(){
    using namespace std;
    using namespace quotient;
    Polynomial<FracType,fraction> pfrac1, pfrac2;
    pfrac1.canonicalType.scalar = &fracType;
    pfrac2.canonicalType.scalar = &fracType;
    cin>>pfrac1;
    cout<<prime::gcd(pfrac1.diff(),pfrac1)<<"\n";

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq -0x28(%rbp), %rdi
callq 0x49d0
leaq -0x50(%rbp), %rdi
callq 0x49d0
jmp 0x39df
leaq 0x1001c7df(%rip), %rax  # 0x100201c5
movq %rax, -0x28(%rbp)
movq %rax, -0x50(%rbp)
movq 0x1c5db(%rip), %rdi     # 0x1ffd0
leaq -0x28(%rbp), %rsi
callq 0x6310
jmp 0x3a00
leaq -0xb0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2960
jmp 0x3a12
leaq -0x88(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x65e0
jmp 0x3a2b
movq 0x1c586(%rip), %rdi     # 0x1ffb8
leaq -0x88(%rbp), %rsi
callq 0x64b0
movq %rax, -0xb8(%rbp)
jmp 0x3a47
movq -0xb8(%rbp), %rdi
leaq 0x115d5(%rip), %rsi     # 0x1502a
callq 0x21c0
jmp 0x3a5c
leaq -0x88(%rbp), %rdi
callq 0x4c40
leaq -0xb0(%rbp), %rdi
callq 0x4c40
leaq -0x50(%rbp), %rdi
callq 0x4c40
leaq -0x28(%rbp), %rdi
callq 0x4c40
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3ae6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3add
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3ad1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x4c40
leaq -0xb0(%rbp), %rdi
callq 0x4c40
leaq -0x50(%rbp), %rdi
callq 0x4c40
leaq -0x28(%rbp), %rdi
callq 0x4c40
movq -0x58(%rbp), %rdi
callq 0x22f0
nopl (%rax,%rax)
// File: asd00012334[P]Abstract-Algebra-2018/./prime.hpp
// Function: long long prime::modulusInverse<long long>(long long, long long)
type modulusInverse(type input, type mod){
    std::pair<type,type> p = extGCD(input,mod);
    if(input*p.first+mod*p.second!=1)
        throw std::logic_error("Return value does not exist.\n");
    if(p.first<0) p.first = p.first%mod+mod;
    return p.first;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8d80
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
imulq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq -0x18(%rbp), %rcx
addq %rcx, %rax
cmpq $0x1, %rax
je 0x47d0
movl $0x10, %edi
callq 0x20d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x108ce(%rip), %rsi     # 0x15069
callq 0x2250
jmp 0x47a2
movq -0x38(%rbp), %rdi
movq 0x1b81b(%rip), %rsi     # 0x1ffc8
movq 0x1b7fc(%rip), %rdx     # 0x1ffb0
callq 0x22d0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2160
jmp 0x47f3
cmpq $0x0, -0x20(%rbp)
jge 0x47e9
movq -0x20(%rbp), %rax
cqto
idivq -0x10(%rbp)
addq -0x10(%rbp), %rdx
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x22f0
nopl (%rax)
// File: asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: Polynomial<prime::IntType, int>::degree() const
int degree()const{
        for(int out = coef.size()-1;out>0;--out)
            if( !(coef[out]==canonicalType.scalar->__zero__()) )
               return out;
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x10, %rdi
callq 0x48b0
subq $0x1, %rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x4ebd
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4900
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x24(%rbp)
movq (%rax), %rdi
callq 0xc600
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
je 0x4eb0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4ec4
jmp 0x4eb2
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4e74
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: Polynomial<prime::Zp, prime::ZpElement>::operator=(Polynomial<prime::Zp, prime::ZpElement> const&)
Polynomial& operator=(Polynomial const& p2){
        canonicalType = p2.canonicalType;
        r = &canonicalType;
        coef = p2.coef;
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
movq %rdi, 0x8(%rdi)
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x10, %rdi
callq 0xd190
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)