LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::checkLayerSeparation()
void Graph::checkLayerSeparation(){
	int u,v;
	bool flag=false;

	for (u=0; u<vsize; u++){
		for(int j=0; j<graph[u].outList.size(); j++){
			v=graph[u].outList[j];
			if(vl[v].layer<=vl[u].layer || vl[v].topoID <= vl[u].topoID ){
				cout << " checkLayerSeparation: Error" << endl;
				quit();
			}
		}

		for (int j=0; j<graph[u].inList.size(); j++){
			v=graph[u].inList[j];
			if(vl[u].layer-vl[v].layer==1)
				flag=true;
		}
		if(flag||graph[u].inList.size()==0)
			flag=false;
		else{
			cout << " checkLayerSeparation: No good separation" << endl;
			quit();
		}
	}
}

// Assembly:
cmpl $0x0, 0xc(%rdi)
jle 0x7546
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0xec08(%rip), %r14      # 0x15fd8
movq 0x48(%rbx), %rax
leaq (%r15,%r15,2), %rbp
shlq $0x4, %rbp
movq 0x18(%rax,%rbp), %rcx
cmpq %rcx, 0x20(%rax,%rbp)
je 0x747c
movq %r15, %r13
shlq $0x4, %r13
xorl %r12d, %r12d
movslq (%rcx,%r12,4), %rcx
movq 0x30(%rbx), %rdx
shlq $0x4, %rcx
movzwl (%rdx,%rcx), %esi
cmpw (%rdx,%r13), %si
jbe 0x741b
addq %rdx, %rcx
addq %r13, %rdx
movl 0x4(%rcx), %ecx
cmpl 0x4(%rdx), %ecx
jg 0x745f
movl $0x1c, %edx
movq %r14, %rdi
leaq 0x90b0(%rip), %rsi      # 0x104da
callq 0x32e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
callq 0x4948
movq 0x48(%rbx), %rax
incq %r12
movq 0x18(%rax,%rbp), %rcx
movq 0x20(%rax,%rbp), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %r12, %rdx
ja 0x73f6
addq %rbp, %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq %rax, %rdx
subq %rcx, %rdx
je 0x7528
sarq $0x2, %rdx
movq 0x30(%rbx), %rsi
movq %r15, %rdi
shlq $0x4, %rdi
movzwl (%rsi,%rdi), %edi
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %r9d, %r9d
xorl %r8d, %r8d
movslq (%rcx,%r9,4), %r10
shlq $0x4, %r10
movzwl (%rsi,%r10), %r10d
movl %edi, %r11d
subl %r10d, %r11d
cmpl $0x1, %r11d
sete %r10b
orb %r10b, %r8b
incq %r9
cmpq %r9, %rdx
jne 0x74b3
cmpq %rcx, %rax
sete %al
orb %al, %r8b
testb $0x1, %r8b
jne 0x7528
movl $0x29, %edx
movq %r14, %rdi
leaq 0x9000(%rip), %rsi      # 0x104f7
callq 0x32e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
callq 0x4948
incq %r15
movslq 0xc(%rbx), %rax
cmpq %rax, %r15
jl 0x73d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $0x0, 0xc(%rdi)
jle 0x76c9
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0xea6e(%rip), %r14      # 0x15fd8
movq 0x48(%rbx), %rax
leaq (%r15,%r15,2), %rbp
shlq $0x4, %rbp
movq (%rax,%rbp), %rcx
cmpq %rcx, 0x8(%rax,%rbp)
je 0x75fe
movq %r15, %r13
shlq $0x4, %r13
xorl %r12d, %r12d
movslq (%rcx,%r12,4), %rcx
movq 0x30(%rbx), %rdx
shlq $0x4, %rcx
movzwl (%rdx,%rcx), %ecx
cmpw (%rdx,%r13), %cx
ja 0x75e6
movl $0x1c, %edx
movq %r14, %rdi
leaq 0x8f29(%rip), %rsi      # 0x104da
callq 0x32e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
callq 0x4948
movq 0x48(%rbx), %rax
incq %r12
movq (%rax,%rbp), %rcx
movq 0x8(%rax,%rbp), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %r12, %rdx
ja 0x758b
addq %rbp, %rax
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rax
movq %rax, %rdx
subq %rcx, %rdx
je 0x76ab
sarq $0x2, %rdx
movq 0x30(%rbx), %rsi
movq %r15, %rdi
shlq $0x4, %rdi
movzwl (%rsi,%rdi), %edi
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %r9d, %r9d
xorl %r8d, %r8d
movslq (%rcx,%r9,4), %r10
shlq $0x4, %r10
movzwl (%rsi,%r10), %r10d
movl %edi, %r11d
subl %r10d, %r11d
cmpl $0x1, %r11d
sete %r10b
orb %r10b, %r8b
incq %r9
cmpq %r9, %rdx
jne 0x7636
cmpq %rcx, %rax
sete %al
orb %al, %r8b
testb $0x1, %r8b
jne 0x76ab
movl $0x29, %edx
movq %r14, %rdi
leaq 0x8e7d(%rip), %rsi      # 0x104f7
callq 0x32e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
callq 0x4948
incq %r15
movslq 0xc(%rbx), %rax
cmpq %rax, %r15
jl 0x756a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rax, 0x10(%rsi)
movl $0x0, 0x18(%rsi)
movslq 0xc(%rdi), %rsi
movl $0x0, 0x4(%rsp)
movq %rbx, %rdi
xorl %edx, %edx
callq 0xc782
movl 0xc(%r14), %eax
testl %eax, %eax
jle 0x7d79
xorl %r13d, %r13d
movl $0x1, %ecx
movq %rcx, 0x8(%rsp)
movl $0x30, %ebp
movl $0x0, 0x4(%rsp)
imull $0x26e978d5, %r13d, %ecx # imm = 0x26E978D5
rorl $0x3, %ecx
cmpl $0x418937, %ecx         # imm = 0x418937
ja 0x7cc4
movq 0xe36d(%rip), %rdi      # 0x15fd8
movl %r13d, %esi
callq 0x3440
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
leaq 0x871b(%rip), %rsi      # 0x103a0
callq 0x32e0
movq %r15, %rdi
movl 0x4(%rsp), %esi
callq 0x3440
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
movl 0xc(%r14), %eax
movq (%rbx), %rcx
movl %r13d, %edx
shrl $0x6, %edx
movq (%rcx,%rdx,8), %rcx
leaq 0x1(%r13), %rdx
btq %r13, %rcx
movq %rbp, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
jb 0x7d5a
movslq %eax, %rcx
cmpq %rcx, %rdx
jge 0x7d5a
leaq (,%r13,2), %rax
addq %r13, %rax
shlq $0x4, %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %r13
movq (%rbx), %rax
movl $0x1, %r12d
movl %r13d, %ecx
shlq %cl, %r12
movl %r13d, %r15d
shrl $0x6, %r15d
movq (%rax,%r15,8), %rax
btq %r13, %rax
jb 0x7d4a
movq 0x48(%r14), %rsi
movq 0x20(%rsp), %rax
leaq (%rsi,%rax), %rdi
addq %rbp, %rsi
callq 0xc7f0
testb %al, %al
je 0x7d4a
incl 0x4(%rsp)
movq (%rbx), %rax
orq %r12, (%rax,%r15,8)
incq %r13
movl 0xc(%r14), %eax
addq $0x30, %rbp
cmpl %r13d, %eax
jg 0x7d06
movslq %eax, %rcx
incq 0x8(%rsp)
movq 0x18(%rsp), %rbp
addq $0x30, %rbp
movq 0x10(%rsp), %r13
cmpq %rcx, %r13
jl 0x7c52
movl 0x4(%rsp), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
xorl %r15d, %r15d
cmpl %edx, %esi
je 0x8bcb
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movslq 0xc(%rdi), %rsi
leaq 0x10(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x40(%rsp), %r15
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
callq 0xc71a
leaq 0x18(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq (%r15), %rax
movl %ebp, %edx
movl $0x1, %esi
movl %ebp, %ecx
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
movl %ebp, %eax
movq 0x48(%r14), %rcx
leaq (%rax,%rax,2), %r13
shlq $0x4, %r13
movq 0x18(%rcx,%r13), %rax
cmpq %rax, 0x20(%rcx,%r13)
je 0x8b96
xorl %ebp, %ebp
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movl (%rax,%rbp,4), %eax
movl %eax, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xeba2
incq %rbp
movq 0x48(%r14), %rcx
movq 0x18(%rcx,%r13), %rax
movq 0x20(%rcx,%r13), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rbp, %rcx
ja 0x8b67
leaq 0x10(%rsp), %rsi
leaq 0x40(%rsp), %r8
movq %r14, %rdi
movl %ebx, %edx
movl $0x1, %ecx
callq 0x8c04
movl %eax, %r15d
leaq 0x10(%rsp), %rdi
callq 0xcc3e
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x8bcb
callq 0x3260
movl %r15d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8bdf
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xcc3e
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x8bfb
callq 0x3260
movq %rbx, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::BFSSubQuery(std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int>>&, unsigned int, unsigned int, std::vector<bool, std::allocator<bool>>&)
unsigned int Graph::BFSSubQuery(set<unsigned int>& qvertice, const unsigned int v, unsigned int depth, vector<bool>& flag){
	unsigned int tmpu, tmpv;
	set<unsigned int> nextset;
	set<unsigned int>::iterator sit;

	if(qvertice.empty()){
		return INT_MAX;
	}

	for(sit=qvertice.begin(); sit!=qvertice.end(); sit++){
		tmpu=*sit;
		if(tmpu==v)
			return depth;
		flag[tmpu]=true;

		for(int i=0; i<graph[tmpu].outList.size(); i++){
			tmpv=graph[tmpu].outList[i];
			if(flag[tmpv]==false && nextset.find(tmpv)==nextset.end() ){
				nextset.insert(tmpv);
			}
		}
	}

	qvertice=nextset;
	nextset.clear();

	return BFSSubQuery(qvertice, v, depth+1, flag);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, 0x10(%rsp)
leaq 0x30(%rsp), %rbp
movl $0x0, (%rbp)
xorl %eax, %eax
movq %rax, 0x8(%rbp)
movq %rbp, 0x10(%rbp)
movq %rbp, 0x18(%rbp)
movq %rax, 0x20(%rbp)
cmpq %rax, 0x28(%rsi)
je 0x8d81
movq %r8, %r14
movq %rdi, %r12
movl %ecx, 0xc(%rsp)
movq 0x18(%rsi), %r13
movq %rsi, 0x18(%rsp)
leaq 0x8(%rsi), %rax
movq %rax, 0x20(%rsp)
cmpq %rax, %r13
je 0x8d47
movl 0x20(%r13), %ecx
cmpl 0x10(%rsp), %ecx
je 0x8d88
movq (%r14), %rax
movl %ecx, %edx
movl $0x1, %esi
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
movq 0x48(%r12), %rax
leaq (%rcx,%rcx,2), %rbx
shlq $0x4, %rbx
movq 0x18(%rax,%rbx), %rcx
cmpq %rcx, 0x20(%rax,%rbx)
je 0x8d31
xorl %r15d, %r15d
movl (%rcx,%r15,4), %ecx
movl %ecx, 0x14(%rsp)
movq (%r14), %rdx
movl %ecx, %esi
shrl $0x6, %esi
movq (%rdx,%rsi,8), %rdx
btq %rcx, %rdx
jb 0x8d14
movq 0x38(%rsp), %r8
testq %r8, %r8
je 0x8d00
movq %rbp, %r9
movq %r9, %rdx
movq %r8, %rsi
movl 0x20(%r8), %edi
xorl %r8d, %r8d
cmpl %ecx, %edi
setb %r8b
movq %rsi, %r9
cmovbq %rdx, %r9
movq 0x10(%rsi,%r8,8), %r8
testq %r8, %r8
jne 0x8ccc
cmpq %rbp, %r9
je 0x8d00
cmpl %ecx, %edi
cmovbq %rdx, %rsi
cmpl 0x20(%rsi), %ecx
jae 0x8d14
leaq 0x28(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0xeba2
movq 0x48(%r12), %rax
incq %r15
movq 0x18(%rax,%rbx), %rcx
movq 0x20(%rax,%rbx), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %r15, %rdx
ja 0x8ca5
movq %r13, %rdi
callq 0x32f0
movq %rax, %r13
cmpq 0x20(%rsp), %rax
jne 0x8c63
leaq 0x28(%rsp), %rsi
movq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0xcc88
movl 0xc(%rsp), %ebx
leaq 0x28(%rsp), %rdi
callq 0xecb0
incl %ebx
movq %r12, %rdi
movq %r15, %rsi
movl 0x10(%rsp), %edx
movl %ebx, %ecx
movq %r14, %r8
callq 0x8c04
movl %eax, %ebx
jmp 0x8d8c
movl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
jmp 0x8d8c
movl 0xc(%rsp), %ebx
leaq 0x28(%rsp), %rdi
callq 0xcc3e
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8da9
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xcc3e
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
movq %rdx, %rdi
movq %rax, %rsi
callq 0xeba2
testb $0x1, %dl
je 0x8e3b
movl 0xc(%rsp), %eax
movq 0x48(%r14), %rcx
leaq (%rax,%rax,2), %rdx
shlq $0x4, %rdx
movq 0x18(%rcx,%rdx), %rax
cmpq %rax, 0x20(%rcx,%rdx)
je 0x8e3b
xorl %r15d, %r15d
movl (%rax,%r15,4), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8dbe
incq %r15
movl 0xc(%rsp), %eax
movq 0x48(%r14), %rcx
leaq (%rax,%rax,2), %rdx
shlq $0x4, %rdx
movq 0x18(%rcx,%rdx), %rax
movq 0x20(%rcx,%rdx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
ja 0x8e03
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
movq %rdx, %rdi
movq %rax, %rsi
callq 0xeba2
testb $0x1, %dl
je 0x8ec1
movl 0xc(%rsp), %eax
movq 0x48(%r14), %rcx
leaq (%rax,%rax,2), %rdx
shlq $0x4, %rdx
movq (%rcx,%rdx), %rax
cmpq %rax, 0x8(%rcx,%rdx)
je 0x8ec1
xorl %r15d, %r15d
movl (%rax,%r15,4), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8e46
incq %r15
movl 0xc(%rsp), %eax
movq 0x48(%r14), %rcx
leaq (%rax,%rax,2), %rdx
shlq $0x4, %rdx
movq (%rcx,%rdx), %rax
movq 0x8(%rcx,%rdx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
ja 0x8e8a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x3250
movl %eax, %edi
callq 0x3270
movslq 0xc(%rbx), %rsi
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0xc8b8
leaq 0x78(%rbx), %r14
movq 0x10(%r15), %rax
movups 0x78(%rbx), %xmm0
movq 0x88(%rbx), %rcx
movq %rcx, 0x10(%r15)
movaps (%r15), %xmm1
movaps %xmm0, (%r15)
movups %xmm1, 0x78(%rbx)
movq %rax, 0x88(%rbx)
movq %r15, %rdi
callq 0xbe3e
movl $0x0, (%r15)
cmpl $0x0, 0xc(%rbx)
jle 0x8feb
leaq 0x10(%rsp), %r15
movslq %r12d, %rax
movq (%r14), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x8f71
movl %r12d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x8f79
movq %r15, %rdx
callq 0xdd36
movl 0x10(%rsp), %r12d
incl %r12d
movl %r12d, 0x10(%rsp)
movl 0xc(%rbx), %r13d
cmpl %r13d, %r12d
jl 0x8f4c
cmpl $0x2, %r13d
jl 0x8feb
leaq (,%r13,2), %rax
addq %r13, %rax
leaq -0x18(,%rax,8), %r15
leaq -0x1(%r13), %r12
callq 0x30a0
movslq %eax, %rbp
callq 0x30a0
cltq
shlq $0x1f, %rax
orq %rbp, %rax
xorl %edx, %edx
divq %r13
movq (%r14), %rax
leaq (%rdx,%rdx,2), %rcx
movq (%rax,%rcx,8), %rcx
movq (%rax,%r15), %rax
movl (%rcx), %edx
movl (%rax), %esi
movl %esi, (%rcx)
movl %edx, (%rax)
addq $-0x18, %r15
cmpq $0x2, %r13
movq %r12, %r13
ja 0x8fa8
addq $0x90, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc936
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movslq 0xc(%rdi), %r15
testq %r15, %r15
jle 0x90d9
movq %rdi, %rbx
incq %r15
movq 0x48(%rbx), %rdx
movq 0x60(%rbx), %rax
movslq -0x8(%rax,%r15,4), %rsi
leaq (%rsi,%rsi,2), %rax
movq %rax, %r12
shlq $0x4, %r12
movq 0x18(%rdx,%r12), %rcx
movq 0x20(%rdx,%r12), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
testl %edx, %edx
je 0x90cc
cmpl $0x2, %edx
je 0x9076
cmpl $0x1, %edx
jne 0x90c4
movq 0x78(%rbx), %rdx
leaq (%rdx,%rax,8), %rsi
movslq (%rcx), %rax
leaq (%rax,%rax,2), %rax
leaq (%rdx,%rax,8), %rdx
movq %rbx, %rdi
jmp 0x90bd
movq 0x78(%rbx), %rax
shlq $0x3, %rsi
leaq (%rsi,%rsi,2), %r14
movslq (%rcx), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdx
addq %r14, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x90e6
movq 0x48(%rbx), %rax
movq 0x78(%rbx), %rcx
addq %rcx, %r14
movq 0x18(%rax,%r12), %rax
movslq 0x4(%rax), %rax
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x90e6
jmp 0x90cc
movq %rbx, %rdi
callq 0x94a0
decq %r15
cmpq $0x1, %r15
ja 0x9027
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $0x0, 0xc(%rdi)
jle 0x9ac2
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x48(%rbx), %rdx
movq 0x60(%rbx), %rax
movslq (%rax,%r15,4), %rsi
leaq (%rsi,%rsi,2), %rax
movq %rax, %r12
shlq $0x4, %r12
movq (%rdx,%r12), %rcx
movq 0x8(%rdx,%r12), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
testl %edx, %edx
je 0x9aa7
cmpl $0x2, %edx
je 0x9a4c
cmpl $0x1, %edx
jne 0x9a9f
movq 0x90(%rbx), %rdx
leaq (%rdx,%rax,8), %rsi
movslq (%rcx), %rax
leaq (%rax,%rax,2), %rax
leaq (%rdx,%rax,8), %rdx
movq %rbx, %rdi
jmp 0x9a98
movq 0x90(%rbx), %rax
shlq $0x3, %rsi
leaq (%rsi,%rsi,2), %r14
movslq (%rcx), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdx
addq %r14, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x90e6
movq 0x48(%rbx), %rax
movq 0x90(%rbx), %rcx
addq %rcx, %r14
movq (%rax,%r12), %rax
movslq 0x4(%rax), %rax
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x90e6
jmp 0x9aa7
movq %rbx, %rdi
callq 0x9ac4
incq %r15
movslq 0xc(%rbx), %rax
cmpq %rax, %r15
jl 0x99f8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movslq 0xc(%rdi), %rsi
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0xc8b8
movq 0x10(%r14), %rax
movups 0xf0(%rbx), %xmm0
movq 0x100(%rbx), %rcx
movq %rcx, 0x10(%r14)
movaps (%r14), %xmm1
movaps %xmm0, (%r14)
movups %xmm1, 0xf0(%rbx)
movq %rax, 0x100(%rbx)
movq %r14, %rdi
callq 0xbe3e
cmpl $0x0, 0x4(%rbx)
je 0xae16
movl $0x0, 0x10(%rsp)
cmpl $0x0, 0xc(%rbx)
jle 0xae16
xorl %ecx, %ecx
leaq 0x10(%rsp), %r14
movslq %ecx, %rax
movq 0x30(%rbx), %rdx
movq %rax, %rsi
shlq $0x4, %rsi
movl 0xc(%rdx,%rsi), %edx
cmpl 0x8(%rbx), %edx
jle 0xad84
movq 0xf0(%rbx), %rdx
leaq (%rax,%rax,2), %rax
leaq (%rdx,%rax,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xad7c
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0xad84
movq %r14, %rdx
callq 0xdd36
movl 0x10(%rsp), %ecx
incl %ecx
movl %ecx, 0x10(%rsp)
movl 0xc(%rbx), %eax
cmpl %eax, %ecx
jl 0xad40
testl %eax, %eax
jle 0xae16
xorl %r14d, %r14d
movq 0x48(%rbx), %rcx
movq 0x60(%rbx), %rdx
movslq (%rdx,%r14,4), %rdx
leaq (%rdx,%rdx,2), %r15
movq %r15, %r12
shlq $0x4, %r12
movq 0x8(%rcx,%r12), %r13
subq (%rcx,%r12), %r13
shrq $0x2, %r13
testl %r13d, %r13d
jle 0xae0b
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
movq 0x48(%rbx), %rcx
movq 0xf0(%rbx), %rax
movq (%rcx,%r12), %rcx
movslq (%rcx,%rbp,4), %rcx
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %rdx
cmpq 0x8(%rax,%rcx,8), %rdx
je 0xae00
leaq (%rax,%rcx,8), %rdx
leaq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0xae26
incq %rbp
cmpq %rbp, %r13
jne 0xadce
movl 0xc(%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0xad9c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::IPtest(int, int)
bool Graph::IPtest(const int u, const int v){
	int it1=0, it2=0;

	if(reachindex[u].Label[ reachindex[u].OutLimit-1 ] > reachindex[v].Label[0] ){
		while(it1!=reachindex[u].OutLimit && it2!=reachindex[v].OutLimit){
			if(reachindex[u].Label[it1] == reachindex[v].Label[it2]){
				it1++;
				it2++;
			}else if(reachindex[u].Label[it1] < reachindex[v].Label[it2]){
				it1++;
			}else
				return true;
		}
	}
	
	if(reachindex[v].Label[ reachindex[v].InLimit-1 ] <= reachindex[u].Label[ reachindex[u].OutLimit ])
		return false;

	it1=reachindex[v].OutLimit;
	it2=reachindex[u].OutLimit;

	while(it1!= reachindex[v].InLimit && it2!=reachindex[u].InLimit){
		if(reachindex[v].Label[it1] == reachindex[u].Label[it2]){
			it1++;
			it2++;
		}else if(reachindex[v].Label[it1] < reachindex[u].Label[it2]){
			it1++;
		}else
			return true;
	}

	return false;
}

// Assembly:
pushq %rbx
movslq %esi, %r8
movq 0xa8(%rdi), %rsi
shlq $0x4, %r8
movq 0x8(%rsi,%r8), %rax
movzbl 0x4(%rsi,%r8), %ecx
movl -0x4(%rax,%rcx,4), %r9d
movslq %edx, %rdx
shlq $0x4, %rdx
leaq (%rsi,%rdx), %rdi
movq 0x8(%rsi,%rdx), %rdx
cmpl (%rdx), %r9d
jle 0xbc3b
testb %cl, %cl
je 0xbc3b
movzbl 0x4(%rdi), %r9d
xorl %r10d, %r10d
xorl %r11d, %r11d
cmpl %r9d, %r11d
je 0xbc3b
movslq %r11d, %rbx
movl (%rdx,%rbx,4), %ebx
cmpl %ebx, (%rax,%r10,4)
jne 0xbc31
incl %r11d
jmp 0xbc33
jge 0xbc7e
incq %r10
cmpq %r10, %rcx
jne 0xbc1b
movzbl 0x5(%rdi), %r9d
movl -0x4(%rdx,%r9,4), %r10d
cmpl (%rax,%rcx,4), %r10d
jle 0xbc7a
movzbl 0x4(%rdi), %edi
cmpb %r9b, %dil
je 0xbc7a
addq %r8, %rsi
movzbl 0x5(%rsi), %esi
cmpl %esi, %ecx
je 0xbc7a
movslq %ecx, %r8
movl (%rax,%r8,4), %r8d
cmpl %r8d, (%rdx,%rdi,4)
jne 0xbc70
incl %ecx
jmp 0xbc72
jge 0xbc7e
incq %rdi
cmpq %rdi, %r9
jne 0xbc5b
xorl %eax, %eax
popq %rbx
retq
movb $0x1, %al
jmp 0xbc7c
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movq (%rsi), %rcx
movq %rdi, -0x30(%rbp)
movq %rcx, (%rdi)
movq 0x18(%rsi), %rsi
subq 0x10(%r15), %rsi
sarq $0x4, %rsi
decq %rsi
leaq -0x40(%rbp), %rdx
movq %rax, (%rdx)
movq $0x1, 0x8(%rdx)
movq %rbx, %rdi
callq 0x3f72
movq 0x18(%r15), %rax
subq 0x10(%r15), %rax
shrq $0x4, %rax
leal -0x1(%rax), %ecx
testl %ecx, %ecx
jle 0x2881
movl %ecx, %r13d
movl %eax, %eax
movl $0xfffffffe, %r14d      # imm = 0xFFFFFFFE
addq %rax, %r14
leaq 0x1(%r13), %r12
shlq $0x4, %r13
decq %r12
movq 0x10(%r15), %rdi
addq %r13, %rdi
movq %r12, -0x40(%rbp)
movq $0x1, -0x38(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x3fb0
movl %r14d, %ecx
movq (%rbx), %rsi
shlq $0x4, %rcx
movq %rax, (%rsi,%rcx)
movq %rdx, 0x8(%rsi,%rcx)
decq %r14
addq $-0x10, %r13
cmpq $0x1, %r12
jg 0x2842
movq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x401c
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28a3
jmp 0x28a3
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x28b3
callq 0x2180
movq %r14, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: PolynomialSpecialized<quotient::FracType, quotient::fraction>::toIntCoef() const
Polynomial<prime::IntType,int>
PolynomialSpecialized<quotient::FracType,quotient::fraction>::toIntCoef()const{
    auto This = static_cast<Polynomial<quotient::FracType,quotient::fraction>const*>(this);
    Polynomial<prime::IntType,int> out;
    out.canonicalType.scalar = &prime::intType;
    out.coef.resize(This->coef.size(),0 );

    auto lcm = [](long long l, long long r)->long long{
        return l*r/std::__gcd(l,r);
    };
    long long multi=1, g=0;
    for(int i=0;i<This->coef.size();++i){
        if(This->coef[i].en == 0) continue;
        g = std::__gcd(g, This->coef[i].en);
        multi = lcm(multi,This->coef[i].dn);
    }
    for(int i=0;i<out.coef.size();++i){
        out.coef[i] = (This->coef[i].en/g)*(multi/This->coef[i].dn);
    }
    out.reduce();
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x1000a8ce(%rip), %rax  # 0x1000d1b4
movq %rax, (%rdi)
movq 0x18(%rsi), %rsi
subq 0x10(%r14), %rsi
leaq 0x10(%rdi), %r15
sarq $0x4, %rsi
leaq -0x1c(%rbp), %rdx
movl $0x0, (%rdx)
movq %r15, %rdi
callq 0x406a
movq 0x10(%r14), %rdi
movq 0x18(%r14), %r9
subq %rdi, %r9
je 0x2997
sarq $0x4, %r9
cmpq $0x1, %r9
adcq $0x0, %r9
movl $0x1, %ecx
xorl %r10d, %r10d
xorl %esi, %esi
movq %r10, %r11
shlq $0x4, %r11
movq (%rdi,%r11), %rdx
testq %rdx, %rdx
je 0x298a
addq %rdi, %r11
movq %rdx, %r8
movq %rsi, %rax
cqto
idivq %r8
movq %r8, %rsi
testq %rdx, %rdx
jne 0x2941
movq 0x8(%r11), %rsi
movq %rcx, %r11
testq %rsi, %rsi
je 0x2976
movq %rcx, %rax
movq %rsi, %rdx
movq %rdx, %r11
cqto
idivq %r11
movq %r11, %rax
testq %rdx, %rdx
jne 0x2966
imulq %rcx, %rsi
movq %rsi, %rax
cqto
idivq %r11
movq %r8, %rsi
movq %rax, %rcx
jmp 0x298d
movq %rsi, %r8
incq %r10
cmpq %r9, %r10
jne 0x292e
jmp 0x299f
movl $0x1, %ecx
xorl %r8d, %r8d
movq 0x10(%rbx), %r11
movq 0x18(%rbx), %r9
movq %r9, %r10
subq %r11, %r10
je 0x29ec
movq %r10, %r14
sarq $0x2, %r14
cmpq $0x1, %r14
adcq $0x0, %r14
addq $0x8, %rdi
xorl %r15d, %r15d
movq -0x8(%rdi), %rax
cqto
idivq %r8
movq %rax, %rsi
movq %rcx, %rax
cqto
idivq (%rdi)
imull %eax, %esi
movl %esi, (%r11,%r15,4)
incq %r15
addq $0x10, %rdi
cmpq %r15, %r14
jne 0x29c5
cmpq $0x5, %r10
jb 0x2a0e
addq $-0x4, %r9
cmpl $0x0, (%r9)
jne 0x2a0e
movq %r9, 0x18(%rbx)
addq $-0x4, %r10
addq $-0x4, %r9
cmpq $0x4, %r10
ja 0x29f6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2a2c
callq 0x2180
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: testMod()
void testMod(){
    using namespace std;
    using namespace prime;
    Polynomial<prime::IntType, int> x(
        &intType,
        vector<int>{2,0,0,0,0,1}
    );
    Polynomial<prime::IntType, int> y(
        &intType,
        vector<int>{0,0,0,1}
    );
    Zp zp(7);
    auto xp = x % zp, yp = y % zp;
    auto z = gcd(xp,yp);
    std::cout<<"("<<xp<<") / ("<<yp<<") = ("<<z<<")\n";


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xd8, %rsp
movups 0x5f56(%rip), %xmm0     # 0x9030
leaq -0x30(%rbp), %rsi
movaps %xmm0, (%rsi)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x10(%rsi)
leaq -0x60(%rbp), %rdi
leaq -0x88(%rbp), %rcx
movl $0x6, %edx
callq 0x40a4
leaq 0x1000a0a9(%rip), %rsi  # 0x1000d1b4
leaq -0xd8(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x40e2
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x3129
callq 0x2180
movaps 0x5ef0(%rip), %xmm0     # 0x9020
leaq -0x88(%rbp), %rsi
movups %xmm0, (%rsi)
leaq -0x30(%rbp), %rdi
leaq -0xb0(%rbp), %rcx
movl $0x4, %edx
callq 0x40a4
leaq 0x1000a05e(%rip), %rsi  # 0x1000d1b4
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x40e2
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x3171
callq 0x2180
leaq -0x38(%rbp), %rdx
movq $0x7, (%rdx)
leaq -0x30(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x26e4
leaq -0x88(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x26e4
leaq -0xb0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x442f
movq 0x9dfa(%rip), %rdi      # 0xcfb8
leaq 0x5e88(%rip), %rsi      # 0x904d
movl $0x1, %edx
callq 0x21c0
movq 0x9de2(%rip), %rdi      # 0xcfb8
leaq -0x30(%rbp), %rsi
callq 0x4b0f
movq %rax, %rbx
leaq 0x5e60(%rip), %rsi      # 0x9049
movl $0x5, %edx
movq %rax, %rdi
callq 0x21c0
leaq -0x88(%rbp), %rsi
movq %rbx, %rdi
callq 0x4b0f
movq %rax, %rbx
leaq 0x5e40(%rip), %rsi      # 0x904f
movl $0x5, %edx
movq %rax, %rdi
callq 0x21c0
leaq -0xb0(%rbp), %rsi
movq %rbx, %rdi
callq 0x4b0f
leaq 0x5e23(%rip), %rsi      # 0x9055
movl $0x2, %edx
movq %rax, %rdi
callq 0x21c0
movq -0xa0(%rbp), %rdi
testq %rdi, %rdi
je 0x3250
callq 0x2180
movq -0x78(%rbp), %rdi
testq %rdi, %rdi
je 0x325e
callq 0x2180
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x326c
callq 0x2180
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x327a
callq 0x2180
movq -0xc8(%rbp), %rdi
testq %rdi, %rdi
je 0x328b
callq 0x2180
addq $0xd8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x32d4
movq %rax, %rbx
jmp 0x32e2
movq %rax, %rbx
jmp 0x32f0
movq %rax, %rbx
movq -0x30(%rbp), %rdi
jmp 0x32f4
movq %rax, %rbx
jmp 0x32fe
movq %rax, %rbx
movq -0x60(%rbp), %rdi
jmp 0x3305
movq %rax, %rbx
jmp 0x330f
movq %rax, %rbx
movq -0xa0(%rbp), %rdi
testq %rdi, %rdi
je 0x32d4
callq 0x2180
movq -0x78(%rbp), %rdi
testq %rdi, %rdi
je 0x32e2
callq 0x2180
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x32f0
callq 0x2180
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x32fe
callq 0x2180
movq -0xc8(%rbp), %rdi
testq %rdi, %rdi
je 0x330f
callq 0x2180
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
subq $0xa8, %rsp
leaq -0x30(%rbp), %rsi
movq %rsi, 0x8(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsi)
xorl %eax, %eax
movq %rax, 0x20(%rsi)
leaq -0xa8(%rbp), %rcx
movq %rcx, 0x8(%rcx)
movups %xmm0, 0x10(%rcx)
movq %rax, 0x20(%rcx)
leaq 0x10009e63(%rip), %rax  # 0x1000d1b5
movq %rax, (%rsi)
movq %rax, (%rcx)
movq 0x9c71(%rip), %rdi      # 0xcfd0
callq 0x4c2b
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x27c0
leaq -0x80(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4eda
movq 0x9c2f(%rip), %rdi      # 0xcfb8
leaq -0x80(%rbp), %rsi
callq 0x4dda
leaq 0x5cbd(%rip), %rsi      # 0x9056
movl $0x1, %edx
movq %rax, %rdi
callq 0x21c0
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x33b4
callq 0x2180
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x33c2
callq 0x2180
movq -0x98(%rbp), %rdi
testq %rdi, %rdi
je 0x33d3
callq 0x2180
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x33e1
callq 0x2180
addq $0xa8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x3408
jmp 0x33f2
movq %rax, %rbx
jmp 0x3416
movq %rax, %rbx
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x3408
callq 0x2180
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x3416
callq 0x2180
movq -0x98(%rbp), %rdi
testq %rdi, %rdi
je 0x3427
callq 0x2180
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x3435
callq 0x2180
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x54e1
imulq %rax, %r14
imulq %rbx, %rdx
addq %r14, %rdx
cmpq $0x1, %rdx
jne 0x3ea7
testq %rax, %rax
jns 0x3ea2
cqto
idivq %rbx
movq %rdx, %rax
addq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20d0
movq %rax, %rbx
leaq 0x51da(%rip), %rsi      # 0x9095
movq %rax, %rdi
callq 0x2200
movq 0x90fe(%rip), %rsi      # 0xcfc8
movq 0x90df(%rip), %rdx      # 0xcfb0
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: Polynomial<prime::Zp, prime::ZpElement>::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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x18(%rdi), %rax
subq 0x10(%rdi), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %ebx # imm = 0xAAAAAAAB
leaq -0x30(%rbp), %r15
decq %rbx
testl %ebx, %ebx
jle 0x4193
movl %ebx, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
leaq (%rax,%rax,2), %rdi
shlq $0x3, %rdi
addq 0x10(%r14), %rdi
movq (%r14), %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq %r15, %rsi
callq 0x5734
testb %al, %al
jne 0x4158
jmp 0x4195
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/asd00012334[P]Abstract-Algebra-2018/./prime.hpp
// Function: Polynomial<prime::Zp, prime::ZpElement> prime::powerMod<Polynomial<prime::Zp, prime::ZpElement>>(Polynomial<prime::Zp, prime::ZpElement>, long long, Polynomial<prime::Zp, prime::ZpElement> const&)
inline ringElement powerMod(ringElement base, ll expo, ringElement const& m){
    ringElement out = base.canonicalType.__unit__() % m;
    for(;expo;expo>>=1, base = base*base%m){
        if(expo&1) out = out * base % m;
    }
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r15
leaq -0x60(%rbp), %rdi
callq 0x5e2c
leaq -0xb8(%rbp), %rdi
movq %rbx, -0x38(%rbp)
movq %rbx, %rsi
callq 0x43e6
leaq -0x60(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
movq %r15, %rdi
callq 0x5eae
movq -0xa8(%rbp), %rdi
testq %rdi, %rdi
je 0x4202
callq 0x2180
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4210
callq 0x2180
testq %r13, %r13
je 0x4336
leaq 0x10(%r15), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%r12), %rax
movq %rax, -0x68(%rbp)
leaq -0x90(%rbp), %rbx
testb $0x1, %r13b
je 0x42ac
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x60ba
leaq -0x108(%rbp), %r14
movq %r14, %rdi
movq -0x38(%rbp), %rsi
callq 0x43e6
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x5eae
movq -0x60(%rbp), %rax
movq %rax, (%r15)
movq %r15, 0x8(%r15)
movq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x62ce
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x428d
callq 0x2180
movq -0xf8(%rbp), %rdi
testq %rdi, %rdi
je 0x429e
callq 0x2180
movq -0x80(%rbp), %rdi
testq %rdi, %rdi
je 0x42ac
callq 0x2180
movq %rbx, %rdi
movq %r12, %rsi
movq %r12, %rdx
callq 0x60ba
leaq -0xe0(%rbp), %r14
movq %r14, %rdi
movq -0x38(%rbp), %rsi
callq 0x43e6
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x5eae
movq -0x60(%rbp), %rax
movq %rax, (%r12)
movq %r12, 0x8(%r12)
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x62ce
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4304
callq 0x2180
movq -0xd0(%rbp), %rdi
testq %rdi, %rdi
je 0x4315
callq 0x2180
movq -0x80(%rbp), %rdi
testq %rdi, %rdi
je 0x4323
callq 0x2180
movq %r13, %rax
sarq %rax
cmpq $0x2, %r13
movq %rax, %r13
jae 0x4231
movq %r15, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0xa8(%rbp), %rdi
testq %rdi, %rdi
je 0x4364
callq 0x2180
jmp 0x4364
movq %rax, %rbx
movq -0x50(%rbp), %rdi
jmp 0x43d3
jmp 0x438d
movq %rax, %rbx
jmp 0x4384
jmp 0x4392
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4384
callq 0x2180
movq -0xf8(%rbp), %rdi
jmp 0x43b4
movq %rax, %rbx
jmp 0x43cc
movq %rax, %rbx
jmp 0x43be
movq %rax, %rbx
jmp 0x43ad
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x43ad
callq 0x2180
movq -0xd0(%rbp), %rdi
testq %rdi, %rdi
je 0x43be
callq 0x2180
movq -0x80(%rbp), %rdi
testq %rdi, %rdi
je 0x43cc
callq 0x2180
movq -0x30(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x43dd
callq 0x2180
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: Polynomial<prime::Zp, prime::ZpElement>::operator-(Polynomial<prime::Zp, prime::ZpElement> const&) const
Polynomial operator-(Polynomial const& p2)const{
        Polynomial out;
        out.canonicalType.scalar = canonicalType.scalar;
        int siz = std::max(coef.size(), p2.coef.size());
        out.coef.resize(siz,canonicalType.scalar->__zero__());
        for(int i=0;i<coef.size();++i) out.coef[i] = out.coef[i]+coef[i];
        for(int i=0;i<p2.coef.size();++i) out.coef[i] = out.coef[i]-p2.coef[i];
        out.reduce();
        return out;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rdi, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movq (%rsi), %rcx
movq %rcx, (%rdi)
movq 0x18(%rsi), %rdx
subq 0x10(%rsi), %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
movq 0x18(%r15), %rsi
subq 0x10(%r15), %rsi
imulq %rdi, %rdx
sarq $0x3, %rsi
imulq %rdi, %rsi
cmpq %rsi, %rdx
cmovaq %rdx, %rsi
leaq -0x40(%rbp), %rdx
movq %rcx, (%rdx)
movq %rcx, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movslq %esi, %rsi
movq %rbx, %rdi
callq 0x6544
movq %r14, -0x48(%rbp)
movq 0x10(%r12), %rdx
cmpq %rdx, 0x18(%r12)
je 0x45fc
xorl %r14d, %r14d
xorl %r13d, %r13d
movq (%rbx), %rsi
addq %r14, %rsi
addq %r14, %rdx
leaq -0x40(%rbp), %rdi
callq 0x6590
movq (%rbx), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax,%r14)
movups -0x40(%rbp), %xmm0
movups %xmm0, (%rax,%r14)
incq %r13
movq 0x10(%r12), %rdx
movq 0x18(%r12), %rax
subq %rdx, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
addq $0x18, %r14
cmpq %r13, %rax
ja 0x45aa
movq 0x10(%r15), %rdx
cmpq %rdx, 0x18(%r15)
je 0x465f
xorl %r14d, %r14d
leaq -0x40(%rbp), %r12
xorl %r13d, %r13d
movq (%rbx), %rsi
addq %r14, %rsi
addq %r14, %rdx
movq %r12, %rdi
callq 0x647a
movq (%rbx), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax,%r14)
movups -0x40(%rbp), %xmm0
movups %xmm0, (%rax,%r14)
incq %r13
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rax
subq %rdx, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
addq $0x18, %r14
cmpq %r13, %rax
ja 0x4610
movq -0x48(%rbp), %r14
movq %r14, %rdi
callq 0x3eec
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4683
jmp 0x4683
jmp 0x4683
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4693
callq 0x2180
movq %r14, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: operator<<(std::ostream&, Polynomial<prime::Zp, prime::ZpElement> const&)
std::ostream& operator<<(std::ostream& out, Polynomial const& f){
        if(f.degree()==0) return out<<f.coef[0];
        for(int i=f.coef.size()-1;i>=0;--i){
            if(i<f.coef.size()-1) out<<" + ";
            out<<f.coef[i];
            if(i>1) out<<" x^"<<i; else if(i==1) out<<" x";
        }
        return out;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4132
testl %eax, %eax
je 0x4c0d
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
decl %eax
js 0x4bfb
movl %eax, %r15d
leaq (,%r15,8), %rax
leaq (%rax,%rax,2), %r12
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
imulq %r13, %rcx
decq %rcx
cmpq %r15, %rcx
jbe 0x4b99
movl $0x3, %edx
movq %rbx, %rdi
leaq 0x46c7(%rip), %rsi      # 0x9257
callq 0x21c0
movq 0x10(%r14), %rax
movq 0x10(%rax,%r12), %rsi
movq %rbx, %rdi
callq 0x20a0
cmpq $0x2, %r15
jb 0x4bcd
movl $0x3, %edx
movq %rbx, %rdi
leaq 0x46a0(%rip), %rsi      # 0x925b
callq 0x21c0
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2290
jmp 0x4be7
cmpq $0x1, %r15
jne 0x4bfb
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x467d(%rip), %rsi      # 0x925f
callq 0x21c0
leaq -0x1(%r15), %rax
addq $-0x18, %r12
testq %r15, %r15
movq %rax, %r15
jg 0x4b66
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r14), %rax
movq 0x10(%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20a0
// File: /workspace/github_cpp_makefile_star2_O3/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: operator>>(std::istream&, Polynomial<quotient::FracType, quotient::fraction>&)
std::istream& operator>>(std::istream& in, Polynomial& f){
        std::string str;
        getline(in,str);
        std::stringstream ss(str);
        for(int tmp;ss>>tmp;)
            f.coef.push_back(tmp);
        std::reverse(f.coef.begin(),f.coef.end());
        f.reduce();
        return in;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %edx
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x22c0
movq %rbx, -0x48(%rbp)
leaq -0x1f0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x18, %edx
callq 0x2250
leaq 0x10(%r14), %r15
leaq -0x1f0(%rbp), %r12
leaq -0x2c(%rbp), %r13
leaq -0x40(%rbp), %rbx
movq %r12, %rdi
movq %r13, %rsi
callq 0x20f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4cf5
movslq -0x2c(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x1, -0x38(%rbp)
movq 0x18(%r14), %rsi
cmpq 0x20(%r14), %rsi
je 0x4ce8
movups -0x40(%rbp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x18(%r14)
jmp 0x4ca7
movq %r15, %rdi
movq %rbx, %rdx
callq 0x6ffa
jmp 0x4ca7
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
cmpq %rcx, %rax
setne %dl
addq $-0x10, %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x4d41
addq $0x10, %rax
movups -0x10(%rax), %xmm0
movaps %xmm0, -0x40(%rbp)
movups (%rcx), %xmm0
movups %xmm0, -0x10(%rax)
movaps -0x40(%rbp), %xmm0
movups %xmm0, (%rcx)
addq $-0x10, %rcx
leaq 0x10(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x4d1b
movq %r14, %rdi
callq 0x401c
movq -0x48(%rbp), %rbx
movq 0x823c(%rip), %rsi      # 0xcf90
leaq -0x1f0(%rbp), %rdi
callq 0x2140
leaq -0x170(%rbp), %rdi
callq 0x2080
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x4d7e
callq 0x2180
movq %rbx, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4d9e
jmp 0x4d97
movq %rax, %rbx
jmp 0x4dc0
jmp 0x4d9e
movq %rax, %rbx
movq 0x81e8(%rip), %rsi      # 0xcf90
leaq -0x1f0(%rbp), %rdi
callq 0x2140
leaq -0x170(%rbp), %rdi
callq 0x2080
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x4dd2
callq 0x2180
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: operator<<(std::ostream&, DegreeList const&)
std::ostream& operator<<(std::ostream& out, DegreeList const& x){
        out<<"[ ";
        for(int i=0;i<x.size();++i){
            if(i&&i<x.size()) out<<", ";
            out<<x[i];
        }
        out<<" ]";
        return out;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3f48(%rip), %rsi      # 0x908c
movl $0x2, %edx
callq 0x21c0
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x519b
xorl %r12d, %r12d
leaq 0x3f2e(%rip), %r15      # 0x908f
testq %r12, %r12
je 0x5179
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21c0
movq (%r14), %rax
movl (%rax,%r12,4), %esi
movq %rbx, %rdi
callq 0x2290
incq %r12
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
ja 0x5161
leaq 0x3ef0(%rip), %rsi      # 0x9092
movl $0x2, %edx
movq %rbx, %rdi
callq 0x21c0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq