LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7573
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r13d, %r13d
movq 0xebea(%rip), %r14      # 0x15fd8
xorl %ebp, %ebp
movq 0x48(%rbx), %rcx
leaq (,%r13,2), %r15
addq %r13, %r15
shlq $0x4, %r15
movq 0x18(%rcx,%r15), %rax
cmpq %rax, 0x20(%rcx,%r15)
je 0x74ad
movq %r13, (%rsp)
shlq $0x4, %r13
xorl %r12d, %r12d
movslq (%rax,%r12,4), %rax
movq 0x30(%rbx), %rcx
shlq $0x4, %rax
movzwl (%rcx,%rax), %edx
cmpw (%rcx,%r13), %dx
jbe 0x7443
addq %rcx, %rax
addq %r13, %rcx
movl 0x4(%rax), %eax
cmpl 0x4(%rcx), %eax
jg 0x7483
movl $0x1c, %edx
movq %r14, %rdi
leaq 0x9098(%rip), %rsi      # 0x104ea
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 0x48f8
incq %r12
movq 0x48(%rbx), %rcx
movq 0x18(%rcx,%r15), %rax
movq 0x20(%rcx,%r15), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r12, %rdx
ja 0x741e
addq %r15, %rcx
movq (%rsp), %r13
jmp 0x74b0
addq %r15, %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
je 0x7504
sarq $0x2, %rdx
movq 0x30(%rbx), %rsi
movq %r13, %rdi
shlq $0x4, %rdi
movzwl (%rsi,%rdi), %edi
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %r8d, %r8d
movslq (%rax,%r8,4), %r9
shlq $0x4, %r9
movzwl (%rsi,%r9), %r9d
movl %edi, %r10d
subl %r9d, %r10d
cmpl $0x1, %r10d
movzbl %bpl, %ebp
cmovel %r10d, %ebp
incq %r8
cmpq %r8, %rdx
jne 0x74dd
xorl %edx, %edx
cmpq %rax, %rcx
je 0x7553
testb $0x1, %bpl
jne 0x7553
movl $0x29, %edx
movq %r14, %rdi
leaq 0x8fe7(%rip), %rsi      # 0x10507
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 0x48f8
movl %ebp, %edx
incq %r13
movslq 0xc(%rbx), %rax
movl %edx, %ebp
cmpq %rax, %r13
jl 0x73f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7708
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r13d, %r13d
movq 0xea42(%rip), %r14      # 0x15fd8
xorl %ebp, %ebp
movq 0x48(%rbx), %rcx
leaq (,%r13,2), %r15
addq %r13, %r15
shlq $0x4, %r15
movq (%rcx,%r15), %rax
cmpq %rax, 0x8(%rcx,%r15)
je 0x7641
movq %r13, (%rsp)
shlq $0x4, %r13
xorl %r12d, %r12d
movslq (%rax,%r12,4), %rax
movq 0x30(%rbx), %rcx
shlq $0x4, %rax
movzwl (%rcx,%rax), %eax
cmpw (%rcx,%r13), %ax
ja 0x761c
movl $0x1c, %edx
movq %r14, %rdi
leaq 0x8eff(%rip), %rsi      # 0x104ea
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 0x48f8
incq %r12
movq 0x48(%rbx), %rcx
movq (%rcx,%r15), %rax
movq 0x8(%rcx,%r15), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r12, %rdx
ja 0x75c5
addq %r15, %rcx
movq (%rsp), %r13
jmp 0x7644
addq %r15, %rcx
movq 0x18(%rcx), %rax
movq 0x20(%rcx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
je 0x7699
sarq $0x2, %rdx
movq 0x30(%rbx), %rsi
movq %r13, %rdi
shlq $0x4, %rdi
movzwl (%rsi,%rdi), %edi
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %r8d, %r8d
movslq (%rax,%r8,4), %r9
shlq $0x4, %r9
movzwl (%rsi,%r9), %r9d
movl %edi, %r10d
subl %r9d, %r10d
cmpl $0x1, %r10d
movzbl %bpl, %ebp
cmovel %r10d, %ebp
incq %r8
cmpq %r8, %rdx
jne 0x7672
xorl %edx, %edx
cmpq %rax, %rcx
je 0x76e8
testb $0x1, %bpl
jne 0x76e8
movl $0x29, %edx
movq %r14, %rdi
leaq 0x8e52(%rip), %rsi      # 0x10507
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 0x48f8
movl %ebp, %edx
incq %r13
movslq 0xc(%rbx), %rax
movl %edx, %ebp
cmpq %rax, %r13
jl 0x7598
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rcx
movq %rdi, %r14
movq (%rsi), %rax
movq %rax, 0x10(%rsi)
movl $0x0, 0x18(%rsi)
movslq 0xc(%rdi), %rsi
movl $0x0, 0x4(%rsp)
movq %rcx, 0x8(%rsp)
movq %rcx, %rdi
xorl %edx, %edx
callq 0xc828
cmpl $0x0, 0xc(%r14)
jle 0x7de5
xorl %r15d, %r15d
movl $0x1, %eax
movq %rax, 0x10(%rsp)
movl $0x30, %ebp
movl $0x0, 0x4(%rsp)
imull $0x26e978d5, %r15d, %eax # imm = 0x26E978D5
rorl $0x3, %eax
cmpl $0x418937, %eax         # imm = 0x418937
ja 0x7d2d
movq 0xe300(%rip), %rdi      # 0x15fd8
movl %r15d, %esi
callq 0x3440
movq %rax, %r12
movl $0x2, %edx
movq %rax, %rdi
leaq 0x86ba(%rip), %rsi      # 0x103ac
callq 0x32e0
movq %r12, %rdi
movl 0x4(%rsp), %esi
callq 0x3440
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r12, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
movq 0x8(%rsp), %rdx
movq (%rdx), %rax
movq %r15, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %r15, %rax
movq %rbp, 0x18(%rsp)
jb 0x7dc7
leaq 0x1(%r15), %rax
movslq 0xc(%r14), %rcx
cmpq %rcx, %rax
jge 0x7dc7
leaq (%r15,%r15,2), %rax
shlq $0x4, %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %r12
movq (%rdx), %rax
movl $0x1, %r13d
movl %r12d, %ecx
shlq %cl, %r13
movq %r12, %rbx
shrq $0x6, %rbx
movq (%rax,%rbx,8), %rax
btq %r12, %rax
jb 0x7dba
movq 0x48(%r14), %rsi
movq 0x20(%rsp), %rax
leaq (%rsi,%rax), %rdi
addq %rbp, %rsi
callq 0xc896
testb %al, %al
je 0x7db5
incl 0x4(%rsp)
movq 0x8(%rsp), %rdx
movq (%rdx), %rax
orq %r13, (%rax,%rbx,8)
jmp 0x7dba
movq 0x8(%rsp), %rdx
incq %r12
addq $0x30, %rbp
cmpl %r12d, 0xc(%r14)
jg 0x7d6a
incq %r15
movslq 0xc(%r14), %rax
incq 0x10(%rsp)
movq 0x18(%rsp), %rbp
addq $0x30, %rbp
cmpq %rax, %r15
jl 0x7cc0
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_O1/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 0x8c18
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movslq 0xc(%rdi), %rsi
leaq 0x38(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
callq 0xc7c0
leaq 0x40(%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 0x8bca
xorl %ebp, %ebp
leaq 0x38(%rsp), %r15
leaq 0xc(%rsp), %r12
movl (%rax,%rbp,4), %eax
movl %eax, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xec5e
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 0x8b9b
leaq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %r8
movq %r14, %rdi
movl %ebx, %edx
movl $0x1, %ecx
callq 0x8c6a
movl %eax, %r15d
leaq 0x38(%rsp), %rdi
callq 0xccd0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x8c18
callq 0x3260
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movl %eax, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movl %r15d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8c2c
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xccd0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x8c61
callq 0x3260
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movl %eax, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movq %rbx, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8de4
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 0x8daa
movl 0x20(%r13), %ecx
cmpl 0x10(%rsp), %ecx
je 0x8deb
movq (%r14), %rax
movl %ecx, %edx
movl $0x1, %esi
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
movq 0x48(%r12), %rdx
leaq (%rcx,%rcx,2), %rbx
shlq $0x4, %rbx
movq 0x18(%rdx,%rbx), %rax
cmpq %rax, 0x20(%rdx,%rbx)
je 0x8d94
xorl %r15d, %r15d
movl (%rax,%r15,4), %eax
movl %eax, 0x14(%rsp)
movq (%r14), %rcx
movl %eax, %edx
shrl $0x6, %edx
movq (%rcx,%rdx,8), %rcx
btq %rax, %rcx
jb 0x8d72
movq 0x38(%rsp), %rdx
movq %rbp, %rcx
testq %rdx, %rdx
je 0x8d4c
movq %rbp, %rcx
xorl %esi, %esi
cmpl %eax, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x8d35
movq %rbp, %rdx
cmpq %rbp, %rcx
je 0x8d5e
cmpl 0x20(%rcx), %eax
cmovbq %rbp, %rcx
movq %rcx, %rdx
cmpq %rbp, %rdx
jne 0x8d72
leaq 0x28(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0xec5e
incq %r15
movq 0x48(%r12), %rcx
movq 0x18(%rcx,%rbx), %rax
movq 0x20(%rcx,%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
ja 0x8d0b
movq %r13, %rdi
callq 0x32f0
movq %rax, %r13
cmpq 0x20(%rsp), %rax
jne 0x8cc9
leaq 0x28(%rsp), %rsi
movq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0xcd1a
movl 0xc(%rsp), %ebx
leaq 0x28(%rsp), %rdi
callq 0xed6e
incl %ebx
movq %r12, %rdi
movq %r15, %rsi
movl 0x10(%rsp), %edx
movl %ebx, %ecx
movq %r14, %r8
callq 0x8c6a
movl %eax, %ebx
jmp 0x8def
movl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
jmp 0x8def
movl 0xc(%rsp), %ebx
leaq 0x28(%rsp), %rdi
callq 0xccd0
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8e0c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xccd0
movq %rbx, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xec5e
testb $0x1, %dl
je 0x8e9f
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 0x8e9f
xorl %r15d, %r15d
movl (%rax,%r15,4), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8e22
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 0x8e67
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xec5e
testb $0x1, %dl
je 0x8f25
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 0x8f25
xorl %r15d, %r15d
movl (%rax,%r15,4), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8eaa
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 0x8eee
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc95e
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 0xbf26
movl $0x0, (%r15)
movl 0xc(%rbx), %eax
testl %eax, %eax
jle 0x8fef
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 0x8fd2
movl %r12d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x8fda
movq %r15, %rdx
callq 0xdde8
movl 0x10(%rsp), %r12d
incl %r12d
movl %r12d, 0x10(%rsp)
movl 0xc(%rbx), %eax
cmpl %eax, %r12d
jl 0x8fad
cmpl $0x2, %eax
jl 0x9046
movl %eax, %r15d
leaq (%r15,%r15,2), %rax
leaq -0x18(,%rax,8), %r12
leaq -0x1(%r15), %r13
callq 0x30a0
movslq %eax, %rbp
callq 0x30a0
cltq
shlq $0x1f, %rax
orq %rbp, %rax
xorl %edx, %edx
divq %r15
movq (%r14), %rax
leaq (%rdx,%rdx,2), %rcx
movq (%rax,%rcx,8), %rcx
movq (%rax,%r12), %rax
movl (%rcx), %edx
movl (%rax), %esi
movl %esi, (%rcx)
movl %edx, (%rax)
addq $-0x18, %r12
cmpq $0x2, %r15
movq %r13, %r15
jg 0x9003
addq $0x90, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc9e6
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9135
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 0x9128
cmpl $0x2, %edx
je 0x90d2
cmpl $0x1, %edx
jne 0x9120
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 0x9119
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 0x9142
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 0x9142
jmp 0x9128
movq %rbx, %rdi
callq 0x955c
decq %r15
cmpq $0x1, %r15
jg 0x9083
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9ba6
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 0x9b8b
cmpl $0x2, %edx
je 0x9b30
cmpl $0x1, %edx
jne 0x9b83
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 0x9b7c
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 0x9142
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 0x9142
jmp 0x9b8b
movq %rbx, %rdi
callq 0x9ba8
incq %r15
movslq 0xc(%rbx), %rax
cmpq %rax, %r15
jl 0x9adc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc95e
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 0xbf26
cmpl $0x0, 0x4(%rbx)
je 0xaee4
movl $0x0, 0x10(%rsp)
cmpl $0x0, 0xc(%rbx)
jle 0xae63
xorl %eax, %eax
leaq 0x10(%rsp), %r14
movslq %eax, %rcx
movq 0x30(%rbx), %rdx
movq %rcx, %rsi
shlq $0x4, %rsi
movl 0xc(%rdx,%rsi), %edx
cmpl 0x8(%rbx), %edx
jle 0xae54
movq 0xf0(%rbx), %rdx
leaq (%rcx,%rcx,2), %rcx
leaq (%rdx,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xae4c
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0xae54
movq %r14, %rdx
callq 0xdde8
movl 0x10(%rsp), %eax
incl %eax
movl %eax, 0x10(%rsp)
cmpl 0xc(%rbx), %eax
jl 0xae10
cmpl $0x0, 0xc(%rbx)
jle 0xaee4
xorl %r14d, %r14d
movq 0x48(%rbx), %rax
movq 0x60(%rbx), %rcx
movslq (%rcx,%r14,4), %rcx
leaq (%rcx,%rcx,2), %r15
movq %r15, %r12
shlq $0x4, %r12
movq 0x8(%rax,%r12), %r13
subq (%rax,%r12), %r13
shrq $0x2, %r13
testl %r13d, %r13d
jle 0xaed8
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 0xaed0
leaq (%rax,%rcx,8), %rdx
leaq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0xaef4
incq %rbp
cmpq %rbp, %r13
jne 0xae9e
incq %r14
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jl 0xae6c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbd25
testb %cl, %cl
je 0xbd25
movzbl 0x4(%rdi), %r9d
xorl %r10d, %r10d
xorl %r11d, %r11d
cmpl %r9d, %r11d
je 0xbd25
movslq %r11d, %rbx
movl (%rdx,%rbx,4), %ebx
cmpl %ebx, (%rax,%r10,4)
jne 0xbd1b
incl %r11d
jmp 0xbd1d
jge 0xbd68
incq %r10
cmpq %r10, %rcx
jne 0xbd05
movzbl 0x5(%rdi), %r9d
movl -0x4(%rdx,%r9,4), %r10d
cmpl (%rax,%rcx,4), %r10d
jle 0xbd64
movzbl 0x4(%rdi), %edi
cmpb %r9b, %dil
je 0xbd64
addq %r8, %rsi
movzbl 0x5(%rsi), %esi
cmpl %esi, %ecx
je 0xbd64
movslq %ecx, %r8
movl (%rax,%r8,4), %r8d
cmpl %r8d, (%rdx,%rdi,4)
jne 0xbd5a
incl %ecx
jmp 0xbd5c
jge 0xbd68
incq %rdi
cmpq %rdi, %r9
jne 0xbd45
xorl %eax, %eax
popq %rbx
retq
movb $0x1, %al
jmp 0xbd66
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0xad1e(%rip)      # 0xd1b0
movl $0x2, %ecx
movl 0x1000ad12(%rip), %r8d  # 0x1000d1b0
leaq 0xad0b(%rip), %rsi      # 0xd1b0
leaq 0x800ad04(%rip), %rdi   # 0x800d1b0
cmpl $0x0, (%rsi,%rcx,4)
jne 0x24c5
movslq %r8d, %rax
leal 0x1(%r8), %edx
movl %edx, 0x1000acf1(%rip)  # 0x1000d1b0
movl %ecx, (%rdi,%rax,4)
movl %edx, %r8d
testl %r8d, %r8d
jle 0x2508
movl %r8d, %r9d
movl $0x1, %r10d
movq %rdi, %r11
movslq (%r11), %rbx
movq %rcx, %rax
imulq %rbx, %rax
cmpq $0x1ffffff, %rax        # imm = 0x1FFFFFF
jg 0x2508
movl $0x1, (%rsi,%rax,4)
movl %ecx, %eax
cltd
idivl %ebx
testl %edx, %edx
je 0x2508
addq $0x4, %r11
leaq 0x1(%r10), %rax
cmpq %r9, %r10
movq %rax, %r10
jb 0x24d6
incq %rcx
cmpq $0x2000000, %rcx        # imm = 0x2000000
jne 0x24ac
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq %rdi, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
movq %rdx, (%rdi)
movq 0x10(%rsi), %rax
cmpq %rax, 0x18(%rsi)
je 0x278b
movq %rdx, %r15
movq %rsi, %r12
xorl %r13d, %r13d
movslq (%rax,%r13,4), %rax
movq %r15, -0x40(%rbp)
movq %r15, -0x38(%rbp)
movq (%r15), %rcx
cqto
idivq %rcx
leaq (%rdx,%rcx), %rax
cqto
idivq %rcx
movq %rdx, -0x30(%rbp)
movq 0x18(%r14), %rsi
cmpq 0x20(%r14), %rsi
je 0x2766
movq -0x30(%rbp), %rax
movq %rax, 0x10(%rsi)
movups -0x40(%rbp), %xmm0
movups %xmm0, (%rsi)
addq $0x18, 0x18(%r14)
jmp 0x2772
movq %rbx, %rdi
leaq -0x40(%rbp), %rdx
callq 0x55d0
incq %r13
movq 0x10(%r12), %rax
movq 0x18(%r12), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x2725
movq %r14, %rdi
callq 0x3ee0
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27a7
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x27b7
callq 0x2180
movq %r14, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %eax, %eax
movq %rax, (%rdi)
movq %rdi, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
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 0x3f66
movq 0x18(%r15), %rax
subq 0x10(%r15), %rax
shrq $0x4, %rax
leal -0x1(%rax), %ecx
testl %ecx, %ecx
jle 0x2884
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 0x3fa4
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 0x2845
movq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x4010
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28a6
jmp 0x28a6
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x28b6
callq 0x2180
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1000a8cc(%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 0x405e
movq 0x10(%r14), %rdi
movq 0x18(%r14), %r9
subq %rdi, %r9
je 0x2999
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 0x298c
addq %rdi, %r11
movq %rdx, %r8
movq %rsi, %rax
cqto
idivq %r8
movq %r8, %rsi
testq %rdx, %rdx
jne 0x2943
movq 0x8(%r11), %rsi
movq %rcx, %r11
testq %rsi, %rsi
je 0x2978
movq %rcx, %rax
movq %rsi, %rdx
movq %rdx, %r11
cqto
idivq %r11
movq %r11, %rax
testq %rdx, %rdx
jne 0x2968
imulq %rcx, %rsi
movq %rsi, %rax
cqto
idivq %r11
movq %r8, %rsi
movq %rax, %rcx
jmp 0x298f
movq %rsi, %r8
incq %r10
cmpq %r9, %r10
jne 0x2930
jmp 0x29a1
movl $0x1, %ecx
xorl %r8d, %r8d
movq 0x10(%rbx), %r9
movq 0x18(%rbx), %r10
subq %r9, %r10
je 0x29e8
sarq $0x2, %r10
cmpq $0x1, %r10
adcq $0x0, %r10
addq $0x8, %rdi
xorl %r11d, %r11d
movq -0x8(%rdi), %rax
cqto
idivq %r8
movq %rax, %rsi
movq %rcx, %rax
cqto
idivq (%rdi)
imull %eax, %esi
movl %esi, (%r9,%r11,4)
incq %r11
addq $0x10, %rdi
cmpq %r11, %r10
jne 0x29c1
movq 0x18(%rbx), %rax
movq %rax, %rcx
subq %r9, %rcx
cmpq $0x5, %rcx
jb 0x2a13
addq $-0x4, %rax
cmpl $0x0, (%rax)
jne 0x2a13
movq %rax, 0x18(%rbx)
addq $-0x4, %rcx
addq $-0x4, %rax
cmpq $0x4, %rcx
ja 0x29fc
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 0x2a31
callq 0x2180
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5f47(%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 0x4098
leaq 0x1000a09a(%rip), %rsi  # 0x1000d1b4
leaq -0xd8(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x40d6
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x3138
callq 0x2180
movaps 0x5ee1(%rip), %xmm0     # 0x9020
leaq -0x88(%rbp), %rsi
movups %xmm0, (%rsi)
leaq -0x30(%rbp), %rdi
leaq -0xb0(%rbp), %rcx
movl $0x4, %edx
callq 0x4098
leaq 0x1000a04f(%rip), %rsi  # 0x1000d1b4
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x40d6
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x3180
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 0x4429
movq 0x9deb(%rip), %rdi      # 0xcfb8
leaq 0x5e79(%rip), %rsi      # 0x904d
movl $0x1, %edx
callq 0x21c0
movq 0x9dd3(%rip), %rdi      # 0xcfb8
leaq -0x30(%rbp), %rsi
callq 0x4b3d
movq %rax, %rbx
leaq 0x5e51(%rip), %rsi      # 0x9049
movl $0x5, %edx
movq %rax, %rdi
callq 0x21c0
leaq -0x88(%rbp), %rsi
movq %rbx, %rdi
callq 0x4b3d
movq %rax, %rbx
leaq 0x5e31(%rip), %rsi      # 0x904f
movl $0x5, %edx
movq %rax, %rdi
callq 0x21c0
leaq -0xb0(%rbp), %rsi
movq %rbx, %rdi
callq 0x4b3d
leaq 0x5e14(%rip), %rsi      # 0x9055
movl $0x2, %edx
movq %rax, %rdi
callq 0x21c0
movq -0xa0(%rbp), %rdi
testq %rdi, %rdi
je 0x325f
callq 0x2180
movq -0x78(%rbp), %rdi
testq %rdi, %rdi
je 0x326d
callq 0x2180
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x327b
callq 0x2180
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3289
callq 0x2180
movq -0xc8(%rbp), %rdi
testq %rdi, %rdi
je 0x329a
callq 0x2180
addq $0xd8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x32e3
movq %rax, %rbx
jmp 0x32f1
movq %rax, %rbx
jmp 0x32ff
movq %rax, %rbx
movq -0x30(%rbp), %rdi
jmp 0x3303
movq %rax, %rbx
jmp 0x330d
movq %rax, %rbx
movq -0x60(%rbp), %rdi
jmp 0x3314
movq %rax, %rbx
jmp 0x331e
movq %rax, %rbx
movq -0xa0(%rbp), %rdi
testq %rdi, %rdi
je 0x32e3
callq 0x2180
movq -0x78(%rbp), %rdi
testq %rdi, %rdi
je 0x32f1
callq 0x2180
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x32ff
callq 0x2180
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x330d
callq 0x2180
movq -0xc8(%rbp), %rdi
testq %rdi, %rdi
je 0x331e
callq 0x2180
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %eax, %eax
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movq %rsi, 0x8(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsi)
movq %rax, 0x20(%rsi)
leaq -0xa8(%rbp), %rcx
movq %rcx, 0x8(%rcx)
movups %xmm0, 0x10(%rcx)
movq %rax, 0x20(%rcx)
leaq 0x10009e51(%rip), %rax  # 0x1000d1b5
movq %rax, (%rsi)
movq %rax, (%rcx)
movq 0x9c5f(%rip), %rdi      # 0xcfd0
callq 0x4c56
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x27c0
leaq -0x80(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4f02
movq 0x9c1d(%rip), %rdi      # 0xcfb8
leaq -0x80(%rbp), %rsi
callq 0x4e05
leaq 0x5cab(%rip), %rsi      # 0x9056
movl $0x1, %edx
movq %rax, %rdi
callq 0x21c0
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x33c6
callq 0x2180
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x33d4
callq 0x2180
movq -0x98(%rbp), %rdi
testq %rdi, %rdi
je 0x33e5
callq 0x2180
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x33f3
callq 0x2180
addq $0xa8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x341a
jmp 0x3404
movq %rax, %rbx
jmp 0x3428
movq %rax, %rbx
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x341a
callq 0x2180
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x3428
callq 0x2180
movq -0x98(%rbp), %rdi
testq %rdi, %rdi
je 0x3439
callq 0x2180
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x3447
callq 0x2180
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x550b
imulq %rax, %r14
imulq %rbx, %rdx
addq %r14, %rdx
cmpq $0x1, %rdx
jne 0x3e9a
testq %rax, %rax
jns 0x3e95
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 0x51e7(%rip), %rsi      # 0x9095
movq %rax, %rdi
callq 0x2200
movq 0x910b(%rip), %rsi      # 0xcfc8
movq 0x90ec(%rip), %rdx      # 0xcfb0
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4187
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 0x575e
testb %al, %al
jne 0x414c
jmp 0x4189
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x58(%rbp), %rdi
callq 0x5e68
leaq -0xb8(%rbp), %rdi
movq %r14, %rsi
callq 0x43e0
leaq -0x58(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
movq %rbx, %rdi
callq 0x5f06
movq -0xa8(%rbp), %rdi
testq %rdi, %rdi
je 0x41f2
callq 0x2180
movq %rbx, -0x30(%rbp)
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x4204
callq 0x2180
testq %r12, %r12
je 0x432e
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x60(%rbp)
leaq 0x10(%r15), %rax
movq %rax, -0x68(%rbp)
leaq -0x90(%rbp), %rbx
testb $0x1, %r12b
je 0x42a7
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
movq %r15, %rdx
callq 0x610a
leaq -0x108(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x43e0
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x5f06
movq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rcx)
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x630e
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x4288
callq 0x2180
movq -0xf8(%rbp), %rdi
testq %rdi, %rdi
je 0x4299
callq 0x2180
movq -0x80(%rbp), %rdi
testq %rdi, %rdi
je 0x42a7
callq 0x2180
movq %rbx, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x610a
leaq -0xe0(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x43e0
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x5f06
movq -0x58(%rbp), %rax
movq %rax, (%r15)
movq %r15, 0x8(%r15)
movq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x630e
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x42fc
callq 0x2180
movq -0xd0(%rbp), %rdi
testq %rdi, %rdi
je 0x430d
callq 0x2180
movq -0x80(%rbp), %rdi
testq %rdi, %rdi
je 0x431b
callq 0x2180
movq %r12, %rax
sarq %rax
cmpq $0x2, %r12
movq %rax, %r12
jae 0x4228
movq -0x30(%rbp), %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0xa8(%rbp), %rdi
testq %rdi, %rdi
je 0x435d
callq 0x2180
jmp 0x435d
movq %rax, %r14
movq -0x48(%rbp), %rdi
jmp 0x43cd
jmp 0x4386
movq %rax, %r14
jmp 0x437d
jmp 0x438b
movq %rax, %r14
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x437d
callq 0x2180
movq -0xf8(%rbp), %rdi
jmp 0x43ad
movq %rax, %r14
jmp 0x43c5
movq %rax, %r14
jmp 0x43b7
movq %rax, %r14
jmp 0x43a6
movq %rax, %r14
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x43a6
callq 0x2180
movq -0xd0(%rbp), %rdi
testq %rdi, %rdi
je 0x43b7
callq 0x2180
movq -0x80(%rbp), %rdi
testq %rdi, %rdi
je 0x43c5
callq 0x2180
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x43d7
callq 0x2180
movq %r14, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %eax, %eax
movq %rax, (%rdi)
movq %rdi, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
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 0x6582
movq %r14, -0x48(%rbp)
movq 0x10(%r12), %rdx
cmpq %rdx, 0x18(%r12)
je 0x45f9
xorl %r14d, %r14d
xorl %r13d, %r13d
movq (%rbx), %rsi
addq %r14, %rsi
addq %r14, %rdx
leaq -0x40(%rbp), %rdi
callq 0x65ce
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 0x45a7
movq 0x10(%r15), %rdx
cmpq %rdx, 0x18(%r15)
je 0x465c
xorl %r14d, %r14d
leaq -0x40(%rbp), %r12
xorl %r13d, %r13d
movq (%rbx), %rsi
addq %r14, %rsi
addq %r14, %rdx
movq %r12, %rdi
callq 0x64b8
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 0x460d
movq -0x48(%rbp), %r14
movq %r14, %rdi
callq 0x3ee0
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4680
jmp 0x4680
jmp 0x4680
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4690
callq 0x2180
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: operator<<(std::ostream&, Polynomial<prime::IntType, int> 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 0x10(%rsi), %rax
movq 0x18(%rsi), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
decq %rcx
testl %ecx, %ecx
jle 0x514d
movl %ecx, %edx
movl %ecx, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
decq %rcx
cmpl $0x0, (%rax,%rsi,4)
je 0x5077
testl %edx, %edx
jle 0x514d
movq 0x18(%r14), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
decl %ecx
js 0x513b
movl %ecx, %r15d
leaq 0x41a0(%rip), %r12      # 0x9257
leaq 0x419d(%rip), %r13      # 0x925b
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
sarq $0x2, %rax
decq %rax
cmpq %r15, %rax
jbe 0x50e2
movl $0x3, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x21c0
movq 0x10(%r14), %rax
movl (%rax,%r15,4), %esi
movq %rbx, %rdi
callq 0x2290
cmpq $0x2, %r15
jl 0x5115
movl $0x3, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x21c0
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2290
jmp 0x512f
cmpq $0x1, %r15
jne 0x512f
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x4135(%rip), %rsi      # 0x925f
callq 0x21c0
leaq -0x1(%r15), %rax
testq %r15, %r15
movq %rax, %r15
jg 0x50be
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl (%rax), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2290