LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x4(%rsp)
leaq 0x30(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
xorl %eax, %eax
cmpq %rax, 0x28(%rsi)
je 0x7152
movq %r8, %r14
movl %ecx, %r13d
movq %rdi, %r12
movq 0x18(%rsi), %rcx
movq %rsi, 0x10(%rsp)
leaq 0x8(%rsi), %rax
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rbx
leaq 0xc(%rsp), %r15
movl %r13d, 0x8(%rsp)
cmpq 0x18(%rsp), %rcx
je 0x715a
movq %rcx, 0x20(%rsp)
movl 0x20(%rcx), %ebp
cmpl 0x4(%rsp), %ebp
je 0x7191
movq %r14, %rdi
movq %rbp, %rsi
callq 0x9cd4
orq %rdx, (%rax)
imulq $0x30, %rbp, %rbp
xorl %r13d, %r13d
movq 0x48(%r12), %rcx
movq 0x18(%rcx,%rbp), %rax
movq 0x20(%rcx,%rbp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x713b
movl (%rax,%r13,4), %esi
movl %esi, 0xc(%rsp)
movq %r14, %rdi
callq 0x9cd4
testq %rdx, (%rax)
jne 0x7136
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc63a
leaq 0x30(%rsp), %rcx
cmpq %rcx, %rax
jne 0x7136
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc53c
incq %r13
jmp 0x70e6
movq 0x20(%rsp), %rdi
callq 0x32d0
movq %rax, %rcx
movl 0x8(%rsp), %r13d
jmp 0x70b4
movl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
jmp 0x7191
leaq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xa124
leaq 0x28(%rsp), %rdi
callq 0xc68c
incl %r13d
movq %r12, %rdi
movq %rbx, %rsi
movl 0x4(%rsp), %edx
movl %r13d, %ecx
movq %r14, %r8
callq 0x7052
movl %eax, %r13d
leaq 0x28(%rsp), %rdi
callq 0xa0dc
movl %r13d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x71b5
jmp 0x71b5
jmp 0x71b5
jmp 0x71b5
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xa0dc
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc53c
testb $0x1, %dl
je 0x7229
xorl %r15d, %r15d
movl 0xc(%rsp), %eax
movq 0x48(%r14), %rcx
imulq $0x30, %rax, %rdx
movq 0x18(%rcx,%rdx), %rax
movq 0x20(%rcx,%rdx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
jbe 0x7229
movl (%rax,%r15,4), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x71ca
incq %r15
jmp 0x71f3
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc53c
testb $0x1, %dl
je 0x7292
xorl %r15d, %r15d
movl 0xc(%rsp), %eax
movq 0x48(%r14), %rcx
imulq $0x30, %rax, %rdx
movq (%rcx,%rdx), %rax
movq 0x8(%rcx,%rdx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
jbe 0x7292
movl (%rax,%r15,4), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x7234
incq %r15
jmp 0x725d
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x3230
movl %eax, %edi
callq 0x3260
movslq 0xc(%rbx), %rsi
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x9e1a
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 0x95d6
movl %r12d, 0x10(%rsp)
movl 0xc(%rbx), %r13d
cmpl %r13d, %r12d
jge 0x732f
movslq %r12d, %rax
imulq $0x18, %rax, %rdi
addq (%r14), %rdi
movq %r15, %rsi
callq 0x9a0e
movl 0x10(%rsp), %r12d
incl %r12d
jmp 0x7305
imulq $0x18, %r13, %r15
addq $-0x18, %r15
cmpl $0x2, %r13d
jl 0x736b
leaq -0x1(%r13), %r12
callq 0x9a79
xorl %edx, %edx
divq %r13
movq (%r14), %rax
imulq $0x18, %rdx, %rcx
movq (%rax,%rcx), %rcx
movq (%rax,%r15), %rax
movl (%rcx), %edx
movl (%rax), %esi
movl %esi, (%rcx)
movl %edx, (%rax)
addq $-0x18, %r15
movq %r12, %r13
jmp 0x7337
addq $0x90, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9e6c
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
movl 0xc(%rdi), %r15d
testl %r15d, %r15d
jle 0x7444
movq 0x48(%rbx), %rcx
movq 0x60(%rbx), %rax
movslq -0x4(%rax,%r15,4), %rsi
imulq $0x30, %rsi, %r12
movq 0x18(%rcx,%r12), %rax
movq 0x20(%rcx,%r12), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
cmpl $0x2, %ecx
je 0x73f8
cmpl $0x1, %ecx
je 0x73de
testl %ecx, %ecx
je 0x743c
movq %rbx, %rdi
callq 0x7780
jmp 0x743c
movq 0x78(%rbx), %rcx
imulq $0x18, %rsi, %rsi
addq %rcx, %rsi
movslq (%rax), %rax
imulq $0x18, %rax, %rdx
addq %rcx, %rdx
movq %rbx, %rdi
jmp 0x7437
movq 0x78(%rbx), %rcx
imulq $0x18, %rsi, %r14
leaq (%rcx,%r14), %rsi
movslq (%rax), %rax
imulq $0x18, %rax, %rdx
addq %rcx, %rdx
movq %rbx, %rdi
callq 0x7450
movq 0x48(%rbx), %rax
movq 0x78(%rbx), %rcx
addq %rcx, %r14
movq 0x18(%rax,%r12), %rax
movslq 0x4(%rax), %rax
imulq $0x18, %rax, %rdx
addq %rcx, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7450
decq %r15
jmp 0x739b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
movslq 0xc(%rbx), %rax
cmpq %rax, %r15
jge 0x7bef
movq 0x48(%rbx), %rcx
movq 0x60(%rbx), %rax
movslq (%rax,%r15,4), %rsi
imulq $0x30, %rsi, %r12
movq (%rcx,%r12), %rax
movq 0x8(%rcx,%r12), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
testl %ecx, %ecx
je 0x7be7
cmpl $0x2, %ecx
je 0x7b94
cmpl $0x1, %ecx
jne 0x7bdf
movq 0x90(%rbx), %rcx
imulq $0x18, %rsi, %rsi
addq %rcx, %rsi
movslq (%rax), %rax
imulq $0x18, %rax, %rdx
addq %rcx, %rdx
movq %rbx, %rdi
jmp 0x7bd8
movq 0x90(%rbx), %rcx
imulq $0x18, %rsi, %r14
leaq (%rcx,%r14), %rsi
movslq (%rax), %rax
imulq $0x18, %rax, %rdx
addq %rcx, %rdx
movq %rbx, %rdi
callq 0x7450
movq 0x48(%rbx), %rax
movq 0x90(%rbx), %rcx
addq %rcx, %r14
movq (%rax,%r12), %rax
movslq 0x4(%rax), %rax
imulq $0x18, %rax, %rdx
addq %rcx, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7450
jmp 0x7be7
movq %rbx, %rdi
callq 0x7bfc
incq %r15
jmp 0x7b3c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9e1a
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 0x95d6
cmpl $0x0, 0x4(%rbx)
je 0x89b4
xorl %eax, %eax
leaq 0x10(%rsp), %r14
movl %eax, 0x10(%rsp)
movl 0xc(%rbx), %ecx
cmpl %ecx, %eax
jge 0x8937
movslq %eax, %rcx
movq 0x30(%rbx), %rdx
movq %rcx, %rsi
shlq $0x4, %rsi
movl 0xc(%rdx,%rsi), %edx
cmpl 0x8(%rbx), %edx
jle 0x8933
imulq $0x18, %rcx, %rdi
addq 0xf0(%rbx), %rdi
movq %r14, %rsi
callq 0x9a0e
movl 0x10(%rsp), %eax
incl %eax
jmp 0x88fa
xorl %r15d, %r15d
movslq %ecx, %rax
cmpq %rax, %r15
jge 0x89b4
movq 0x48(%rbx), %rax
movq 0x60(%rbx), %rcx
movslq (%rcx,%r15,4), %rcx
imulq $0x30, %rcx, %r12
movq 0x8(%rax,%r12), %r13
subq (%rax,%r12), %r13
shrq $0x2, %r13
testl %r13d, %r13d
movl $0x0, %eax
cmovlel %eax, %r13d
imulq $0x18, %rcx, %rbp
xorl %r14d, %r14d
cmpq %r14, %r13
je 0x89ac
movq 0x48(%rbx), %rax
movq 0xf0(%rbx), %rsi
movq (%rax,%r12), %rax
movslq (%rax,%r14,4), %rax
imulq $0x18, %rax, %rdx
movq (%rsi,%rdx), %rax
cmpq 0x8(%rsi,%rdx), %rax
je 0x89a7
addq %rsi, %rdx
addq %rbp, %rsi
movq %rbx, %rdi
callq 0x89c4
incq %r14
jmp 0x8972
incq %r15
movl 0xc(%rbx), %ecx
jmp 0x893a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movslq %esi, %r8
movq 0xa8(%rdi), %rax
shlq $0x4, %r8
movq 0x8(%rax,%r8), %rcx
movzbl 0x4(%rax,%r8), %esi
movl -0x4(%rcx,%rsi,4), %r9d
movslq %edx, %rdx
shlq $0x4, %rdx
leaq (%rax,%rdx), %rdi
movq 0x8(%rax,%rdx), %rdx
cmpl (%rdx), %r9d
jle 0x946f
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpq %r9, %rsi
je 0x946f
movzbl 0x4(%rdi), %r11d
cmpl %r11d, %r10d
je 0x946f
movslq %r10d, %r11
movl (%rdx,%r11,4), %r11d
cmpl %r11d, (%rcx,%r9,4)
jne 0x9468
incl %r10d
jmp 0x946a
jge 0x94b0
incq %r9
jmp 0x9447
movzbl 0x5(%rdi), %r9d
movl -0x4(%rdx,%r9,4), %r10d
cmpl (%rcx,%rsi,4), %r10d
jle 0x94ad
addq %r8, %rax
movzbl 0x4(%rdi), %edi
cmpq %rdi, %r9
je 0x94ad
movzbl 0x5(%rax), %r8d
cmpl %r8d, %esi
je 0x94ad
movslq %esi, %r8
movl (%rcx,%r8,4), %r8d
cmpl %r8d, (%rdx,%rdi,4)
jne 0x94a6
incl %esi
jmp 0x94a8
jge 0x94b0
incq %rdi
jmp 0x9486
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x9d8e(%rip)      # 0xc1a0
movabsq $0x2, %rcx
movl 0x10009d7d(%rip), %r8d  # 0x1000c1a0
leaq 0x9d76(%rip), %rsi      # 0xc1a0
leaq 0x8009d6f(%rip), %rdi   # 0x800c1a0
cmpq $0x2000000, %rcx        # imm = 0x2000000
je 0x248f
cmpl $0x0, (%rsi,%rcx,4)
jne 0x2453
movslq %r8d, %rax
leal 0x1(%r8), %edx
movl %edx, 0x10009d53(%rip)  # 0x1000c1a0
movl %ecx, (%rdi,%rax,4)
movl %edx, %r8d
movslq %r8d, %r9
movq %rdi, %r10
xorl %r11d, %r11d
cmpq %r9, %r11
jge 0x248a
movslq (%r10), %rbx
movq %rcx, %rax
imulq %rbx, %rax
cmpq $0x1ffffff, %rax        # imm = 0x1FFFFFF
jg 0x248a
movl $0x1, (%rsi,%rax,4)
movl %ecx, %eax
cltd
idivl %ebx
incq %r11
addq $0x4, %r10
testl %edx, %edx
jne 0x245c
incq %rcx
jmp 0x2431
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq %rdi, -0x30(%rbp)
movq %rdx, (%rdi)
xorl %r14d, %r14d
leaq -0x48(%rbp), %r13
movq 0x10(%r12), %rax
movq 0x18(%r12), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r14, %rcx
jbe 0x26d8
movslq (%rax,%r14,4), %rax
movq %r15, -0x48(%rbp)
movq %r15, -0x40(%rbp)
movq (%r15), %rcx
cqto
idivq %rcx
leaq (%rdx,%rcx), %rax
cqto
idivq %rcx
movq %rdx, -0x38(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4fd8
incq %r14
jmp 0x2691
movq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x3970
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26f8
movq %rax, %r14
movq %rbx, %rdi
callq 0x4a9e
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
andq $0x0, 0x20(%rdi)
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x18(%rsi), %rsi
subq 0x10(%r15), %rsi
movq %rdi, -0x30(%rbp)
leaq 0x10(%rdi), %rbx
sarq $0x4, %rsi
decq %rsi
leaq -0x40(%rbp), %rdx
andq $0x0, (%rdx)
movq $0x1, 0x8(%rdx)
movq %rbx, %rdi
callq 0x39d8
movq 0x18(%r15), %rax
subq 0x10(%r15), %rax
shrq $0x4, %rax
movl %eax, %r13d
movq %r13, %r14
shlq $0x4, %r14
addq $-0x18, %r14
leaq -0x40(%rbp), %r12
decq %r13
testl %r13d, %r13d
jle 0x27c4
movl %r13d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, %rdi
shlq $0x4, %rdi
addq 0x10(%r15), %rdi
movq %rax, -0x40(%rbp)
movq $0x1, -0x38(%rbp)
movq %r12, %rsi
callq 0x3a16
movq (%rbx), %rcx
movq %rax, -0x8(%rcx,%r14)
movq %rdx, (%rcx,%r14)
addq $-0x10, %r14
jmp 0x2783
movq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x3a50
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27e6
jmp 0x27e6
movq %rax, %r14
movq %rbx, %rdi
callq 0x4b14
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rdi, %r14
movq %rdi, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
andq $0x0, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
leaq 0x1000997f(%rip), %rax  # 0x1000c1a4
movq %rax, (%rdi)
movq 0x18(%rsi), %rsi
subq 0x10(%r15), %rsi
sarq $0x4, %rsi
leaq -0x1c(%rbp), %rdx
andl $0x0, (%rdx)
movq %rbx, %rdi
callq 0x3a94
movq 0x10(%r15), %r9
movq 0x18(%r15), %r10
subq %r9, %r10
sarq $0x4, %r10
pushq $0x1
popq %rcx
xorl %r11d, %r11d
xorl %esi, %esi
cmpq %r10, %r11
je 0x28ba
movq %r11, %rdi
shlq $0x4, %rdi
movq (%r9,%rdi), %rdx
testq %rdx, %rdx
je 0x28b5
addq %r9, %rdi
testq %rdx, %rdx
je 0x2887
movq %rdx, %r8
movq %rsi, %rax
cqto
idivq %r8
movq %r8, %rsi
jmp 0x2872
movq 0x8(%rdi), %rdi
movq %rdi, %rdx
movq %rcx, %r8
testq %rdx, %rdx
je 0x28a6
movq %rdx, %r15
movq %r8, %rax
cqto
idivq %r15
movq %r15, %r8
jmp 0x2891
imulq %rcx, %rdi
movq %rdi, %rax
cqto
idivq %r8
movq %rax, %rcx
incq %r11
jmp 0x285a
movq 0x10(%r14), %r8
movq 0x18(%r14), %r10
subq %r8, %r10
sarq $0x2, %r10
addq $0x8, %r9
xorl %r11d, %r11d
cmpq %r11, %r10
je 0x28f9
movq -0x8(%r9), %rax
cqto
idivq %rsi
movq %rax, %rdi
movq %rcx, %rax
cqto
idivq (%r9)
imull %eax, %edi
movl %edi, (%r8,%r11,4)
incq %r11
addq $0x10, %r9
jmp 0x28d0
movq %r14, %rdi
callq 0x3ace
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2911
movq %rax, %r14
movq %rbx, %rdi
callq 0x4b28
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x51c7(%rip), %xmm0     # 0x8030
leaq -0x30(%rbp), %rsi
movaps %xmm0, (%rsi)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x10(%rsi)
leaq -0x60(%rbp), %rdi
pushq $0x6
popq %rdx
leaq -0x88(%rbp), %rcx
callq 0x3b28
leaq 0x1000930c(%rip), %rsi  # 0x1000c1a4
leaq -0xd8(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x3b5e
leaq -0x60(%rbp), %rdi
callq 0x4b28
movaps 0x5168(%rip), %xmm0     # 0x8020
leaq -0x88(%rbp), %rsi
movups %xmm0, (%rsi)
leaq -0x30(%rbp), %rdi
pushq $0x4
popq %rdx
leaq -0xb0(%rbp), %rcx
callq 0x3b28
leaq 0x100092c8(%rip), %rsi  # 0x1000c1a4
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x3b5e
leaq -0x30(%rbp), %rdi
callq 0x4b28
leaq -0x38(%rbp), %rdx
movq $0x7, (%rdx)
leaq -0x30(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x2658
leaq -0x88(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x2658
leaq -0xb0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x3e4a
movq 0x9079(%rip), %rdi      # 0xbfb8
leaq 0x5107(%rip), %rsi      # 0x804d
callq 0x2190
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x445b
leaq 0x50eb(%rip), %rsi      # 0x8049
movq %rax, %rdi
callq 0x2190
leaq -0x88(%rbp), %rsi
movq %rax, %rdi
callq 0x445b
leaq 0x50d3(%rip), %rsi      # 0x804f
movq %rax, %rdi
callq 0x2190
leaq -0xb0(%rbp), %rsi
movq %rax, %rdi
callq 0x445b
leaq 0x50bb(%rip), %rsi      # 0x8055
movq %rax, %rdi
callq 0x2190
leaq -0xa0(%rbp), %rdi
callq 0x4a9e
leaq -0x78(%rbp), %rdi
callq 0x4a9e
leaq -0x20(%rbp), %rdi
callq 0x4a9e
leaq -0x50(%rbp), %rdi
callq 0x4b28
leaq -0xc8(%rbp), %rdi
callq 0x4b28
addq $0xd8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x3019
movq %rax, %rbx
jmp 0x3022
movq %rax, %rbx
jmp 0x302b
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x302f
movq %rax, %rbx
jmp 0x3034
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
jmp 0x303b
movq %rax, %rbx
jmp 0x3040
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x4a9e
leaq -0x78(%rbp), %rdi
callq 0x4a9e
leaq -0x20(%rbp), %rdi
callq 0x4a9e
leaq -0x50(%rbp), %rdi
callq 0x4b28
leaq -0xc8(%rbp), %rdi
callq 0x4b28
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
leaq -0x90(%rbp), %rsi
movq %rsi, 0x8(%rsi)
leaq -0x80(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq -0xb8(%rbp), %rax
movq %rax, 0x8(%rax)
leaq -0xa8(%rbp), %r14
andq $0x0, 0x10(%r14)
movups %xmm0, (%r14)
leaq 0x10009111(%rip), %rax  # 0x1000c1a5
movq %rax, -0x10(%rbx)
movq %rax, -0x10(%r14)
movq 0x8f2d(%rip), %rdi      # 0xbfd0
callq 0x454b
leaq -0x40(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x270c
leaq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x473c
movq 0x8ee5(%rip), %rdi      # 0xbfb8
leaq -0x68(%rbp), %rsi
callq 0x4649
leaq 0x4f73(%rip), %rsi      # 0x8056
movq %rax, %rdi
callq 0x2190
leaq -0x58(%rbp), %rdi
callq 0x4b14
leaq -0x30(%rbp), %rdi
callq 0x4b14
movq %r14, %rdi
callq 0x4b14
movq %rbx, %rdi
callq 0x4b14
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x3133
jmp 0x3122
movq %rax, %r15
jmp 0x313c
movq %rax, %r15
leaq -0x58(%rbp), %rdi
callq 0x4b14
leaq -0x30(%rbp), %rdi
callq 0x4b14
movq %r14, %rdi
callq 0x4b14
movq %rbx, %rdi
callq 0x4b14
movq %r15, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4f19
imulq %rax, %r14
imulq %rbx, %rdx
addq %r14, %rdx
cmpq $0x1, %rdx
jne 0x390d
testq %rax, %rax
jns 0x3908
cqto
idivq %rbx
movq %rdx, %rax
addq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x4776(%rip), %rsi      # 0x8095
movq %rax, %rdi
callq 0x2210
movq 0x869a(%rip), %rsi      # 0xbfc8
movq 0x867b(%rip), %rdx      # 0xbfb0
movq %rbx, %rdi
callq 0x2290
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq 0x18(%rdi), %rax
subq 0x10(%rdi), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movl %eax, %r14d
leaq -0x30(%rbp), %r15
decq %r14
testl %r14d, %r14d
jle 0x3bfb
movl %r14d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
imulq $0x18, %rax, %rdi
addq 0x10(%rbx), %rdi
movq (%rbx), %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x28(%rbp)
andq $0x0, -0x20(%rbp)
movq %r15, %rsi
callq 0x517e
testb %al, %al
jne 0x3bc5
jmp 0x3bfe
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xd8, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq -0x60(%rbp), %rdi
callq 0x5808
leaq -0xb0(%rbp), %rdi
movq %r14, -0x38(%rbp)
movq %r14, %rsi
callq 0x3ddc
leaq -0x60(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
movq %rbx, -0x30(%rbp)
movq %rbx, %rdi
callq 0x587a
leaq -0xa0(%rbp), %rdi
callq 0x4a9e
leaq -0x50(%rbp), %rdi
callq 0x4a9e
leaq -0x88(%rbp), %r13
leaq -0x60(%rbp), %rbx
testq %r15, %r15
je 0x3d48
testb $0x1, %r15b
je 0x3ce8
movq %r13, %rdi
movq -0x30(%rbp), %rsi
movq %r12, %rdx
callq 0x5a4e
leaq -0x100(%rbp), %r14
movq %r14, %rdi
movq -0x38(%rbp), %rsi
callq 0x3ddc
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x587a
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x3e20
leaq -0x50(%rbp), %rdi
callq 0x4a9e
leaq -0xf0(%rbp), %rdi
callq 0x4a9e
leaq -0x78(%rbp), %rdi
callq 0x4a9e
movq %r13, %rdi
movq %r12, %rsi
movq %r12, %rdx
callq 0x5a4e
leaq -0xd8(%rbp), %r14
movq %r14, %rdi
movq -0x38(%rbp), %rsi
callq 0x3ddc
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x587a
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3e20
sarq %r15
leaq -0x50(%rbp), %rdi
callq 0x4a9e
leaq -0xc8(%rbp), %rdi
callq 0x4a9e
leaq -0x78(%rbp), %rdi
callq 0x4a9e
jmp 0x3c7f
movq -0x30(%rbp), %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x4a9e
jmp 0x3d72
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x3dce
jmp 0x3d96
movq %rax, %rbx
jmp 0x3d8d
jmp 0x3d9b
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4a9e
leaq -0xf0(%rbp), %rdi
jmp 0x3db8
movq %rax, %rbx
jmp 0x3dc6
movq %rax, %rbx
jmp 0x3dbd
movq %rax, %rbx
jmp 0x3db1
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4a9e
leaq -0xc8(%rbp), %rdi
callq 0x4a9e
leaq -0x78(%rbp), %rdi
callq 0x4a9e
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
callq 0x4a9e
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: Polynomial<prime::Zp, prime::ZpElement>::operator=(Polynomial<prime::Zp, prime::ZpElement> const&)
Polynomial& operator=(Polynomial const& p2){
        canonicalType = p2.canonicalType;
        r = &canonicalType;
        coef = p2.coef;
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rdi)
movq %rdi, 0x8(%rdi)
addq $0x10, %rsi
addq $0x10, %rdi
callq 0x5c00
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
andq $0x0, 0x20(%rdi)
movq (%rsi), %rsi
movq %rsi, (%rdi)
movq 0x18(%r12), %rax
subq 0x10(%r12), %rax
pushq $0x18
popq %r8
cqto
idivq %r8
movq %rax, %rcx
movq 0x18(%r15), %rax
subq 0x10(%r15), %rax
cqto
idivq %r8
cmpq %rax, %rcx
cmovaq %rcx, %rax
movq %rdi, -0x48(%rbp)
leaq 0x10(%rdi), %r14
leaq -0x40(%rbp), %rdx
movq %rsi, (%rdx)
movq %rsi, 0x8(%rdx)
andq $0x0, 0x10(%rdx)
movslq %eax, %rsi
movq %r14, %rdi
callq 0x5e1e
xorl %ebx, %ebx
xorl %r13d, %r13d
movq 0x10(%r12), %rcx
movq 0x18(%r12), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cmpq %r13, %rax
jbe 0x3fe1
movq (%r14), %rsi
addq %rbx, %rsi
addq %rbx, %rcx
leaq -0x40(%rbp), %rdi
movq %rcx, %rdx
callq 0x5e66
movq (%r14), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax,%rbx)
movups -0x40(%rbp), %xmm0
movups %xmm0, (%rax,%rbx)
incq %r13
addq $0x18, %rbx
jmp 0x3f95
xorl %r13d, %r13d
leaq -0x40(%rbp), %r12
xorl %ebx, %ebx
movq 0x10(%r15), %rcx
movq 0x18(%r15), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cmpq %rbx, %rax
jbe 0x4034
movq (%r14), %rsi
addq %r13, %rsi
addq %r13, %rcx
movq %r12, %rdi
movq %rcx, %rdx
callq 0x5d30
movq (%r14), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax,%r13)
movups -0x40(%rbp), %xmm0
movups %xmm0, (%rax,%r13)
incq %rbx
addq $0x18, %r13
jmp 0x3fea
movq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0x3970
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4058
jmp 0x4058
jmp 0x4058
movq %rax, %rbx
movq %r14, %rdi
callq 0x4a9e
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: operator<<(std::ostream&, Polynomial<quotient::FracType, quotient::fraction> 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 0x6d38
testl %eax, %eax
je 0x4722
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
shrq $0x4, %rax
movl %eax, %r12d
decq %r12
leaq 0x3bd5(%rip), %r13      # 0x825b
testl %r12d, %r12d
js 0x4710
movl %r12d, %r15d
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
decq %rcx
cmpq %r15, %rcx
jbe 0x46c3
movq %rbx, %rdi
leaq 0x3b9d(%rip), %rsi      # 0x8257
callq 0x2190
movq 0x10(%r14), %rax
shlq $0x4, %r15
addq %rax, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6fd6
cmpl $0x2, %r12d
jb 0x46f3
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2190
movq %rax, %rdi
movl %r12d, %esi
callq 0x22a0
jmp 0x4708
cmpl $0x1, %r12d
jne 0x4708
movq %rbx, %rdi
leaq 0x3b5c(%rip), %rsi      # 0x825f
callq 0x2190
decq %r12
jmp 0x4686
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6fd6
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x68(%rbp), %rsi
callq 0x2050
movq %rbx, -0x38(%rbp)
leaq -0x1f0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
pushq $0x18
popq %rdx
callq 0x2260
leaq 0x10(%r14), %r15
leaq -0x1f0(%rbp), %r12
leaq -0x2c(%rbp), %r13
leaq -0x48(%rbp), %rbx
movq %r12, %rdi
movq %r13, %rsi
callq 0x2100
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x45de
movslq -0x2c(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x1, -0x40(%rbp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6964
jmp 0x45a8
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rsi
callq 0x6a46
movq %r14, %rdi
callq 0x3a50
leaq -0x1f0(%rbp), %rdi
callq 0x2140
leaq -0x68(%rbp), %rdi
callq 0x20d0
movq -0x38(%rbp), %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4620
movq %rax, %rbx
jmp 0x4638
jmp 0x4629
jmp 0x4629
movq %rax, %rbx
leaq -0x1f0(%rbp), %rdi
callq 0x2140
leaq -0x68(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x367e(%rip), %rsi      # 0x808c
callq 0x2190
xorl %r12d, %r12d
leaq 0x3672(%rip), %r15      # 0x808f
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x4a54
testq %r12, %r12
je 0x4a43
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2190
movq (%r14), %rax
movl (%rax,%r12,4), %esi
movq %rbx, %rdi
callq 0x22a0
incq %r12
jmp 0x4a1d
leaq 0x3637(%rip), %rsi      # 0x8092
movq %rbx, %rdi
callq 0x2190
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/asd00012334[P]Abstract-Algebra-2018/./quotient.hpp
// Function: quotient::fraction::reduce()
void reduce(){
        int alter = en>=0 ^ dn>=0;
        en = std::abs(en);
        dn = std::abs(dn);
        int g = std::__gcd(en,dn);
        en /= g, dn /= g;
        if(alter) en = -en;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %r8
movq 0x8(%rdi), %r9
movq %r8, %rsi
negq %rsi
cmovsq %r8, %rsi
movq %r9, %rcx
negq %rcx
cmovsq %r9, %rcx
movq %rcx, %rdx
movq %rsi, %rax
testq %rdx, %rdx
je 0x4ae9
movq %rdx, %r10
xorl %edx, %edx
divq %r10
movq %r10, %rax
jmp 0x4ad7
movslq %eax, %r10
movq %rsi, %rax
cqto
idivq %r10
movq %rax, %rsi
movq %rax, (%rdi)
movq %rcx, %rax
cqto
idivq %r10
movq %rax, 0x8(%rdi)
xorq %r8, %r9
jns 0x4b11
negq %rsi
movq %rsi, (%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/asd00012334[P]Abstract-Algebra-2018/./prime.hpp
// Function: std::pair<long long, long long> prime::extGCD<long long>(long long, long long)
std::pair<type,type> extGCD(type left, type right){
    if(!left && !right) throw std::logic_error("Return value does not exist.\n");
    std::pair<type,type> lCor(1,0), rCor(0,1);
    if(left<0) lCor.first = -1;
    if(right<0) rCor.second = -1;
    left = abs(left);
    right = abs(right);
    while(left){
        std::swap(lCor,rCor);
        std::swap(left,right);
        lCor.first -= left/right*rCor.first;
        lCor.second -= left/right*rCor.second;
        left %= right;
    }
    return rCor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rax
orq %rdi, %rax
je 0x4f94
movq %rdi, %r9
sarq $0x3f, %r9
orq $0x1, %r9
movq %rsi, %rcx
sarq $0x3f, %rcx
orq $0x1, %rcx
movl %edi, %r8d
negl %r8d
cmovsl %edi, %r8d
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
xorl %r11d, %r11d
xorl %esi, %esi
testq %r8, %r8
je 0x4f89
movq %r9, %r10
movq %r11, %rdi
xorl %edx, %edx
divq %r8
movq %rax, %r9
imulq %r10, %r9
subq %r9, %rsi
imulq %r11, %rax
subq %rax, %rcx
movq %rcx, %r11
movq %rsi, %r9
movq %r8, %rax
movq %rdx, %r8
movq %r10, %rsi
movq %rdi, %rcx
jmp 0x4f54
movq %rsi, %rax
movq %rcx, %rdx
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x30ef(%rip), %rsi      # 0x8095
movq %rax, %rdi
callq 0x2210
movq 0x7013(%rip), %rsi      # 0xbfc8
movq 0x6ff4(%rip), %rdx      # 0xbfb0
movq %rbx, %rdi
callq 0x2290
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: Polynomial<prime::Zp, prime::ZpElement>::CanonicalType::__unit__() const
Polynomial __unit__()const{
            Polynomial out;
            out.canonicalType.scalar = scalar;
            out.coef.push_back(scalar->__unit__());
            return out;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq %rdi, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
andq $0x0, 0x20(%rdi)
movq (%rsi), %rax
movq %rax, (%rdi)
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
movq %rax, 0x8(%rsi)
movq (%rax), %rcx
pushq $0x1
popq %rax
xorl %edx, %edx
idivq %rcx
leaq (%rdx,%rcx), %rax
cqto
idivq %rcx
movq %rdx, 0x10(%rsi)
movq %rbx, %rdi
callq 0x4fd8
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4a9e
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/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;
        out.coef.resize(coef.size()+p2.coef.size()-1,canonicalType.scalar->__zero__());
        for(int i=0;i<coef.size();++i)
        for(int j=0;j<p2.coef.size();++j){
            assert(i+j<out.coef.size());
            out.coef[i+j] = out.coef[i+j] + coef[i] * p2.coef[j];
        }
        out.reduce();
        return out;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r9
movq %rdi, 0x8(%rdi)
andq $0x0, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq (%rsi), %r8
movq %r8, (%rdi)
movq 0x18(%rsi), %rax
movq %rsi, -0x40(%rbp)
subq 0x10(%rsi), %rax
pushq $0x18
popq %rsi
cqto
idivq %rsi
movq %rax, %rcx
movq 0x18(%r9), %rax
movq %r9, -0x58(%rbp)
subq 0x10(%r9), %rax
cqto
idivq %rsi
leaq -0x70(%rbp), %rdx
movq %r8, (%rdx)
movq %r8, 0x8(%rdx)
andq $0x0, 0x10(%rdx)
movq %rdi, -0x38(%rbp)
addq $0x10, %rdi
leaq (%rcx,%rax), %rsi
decq %rsi
movq %rdi, -0x30(%rbp)
callq 0x5e1e
xorl %ebx, %ebx
leaq -0x88(%rbp), %r14
xorl %r9d, %r9d
pushq $0x18
popq %rdi
movq -0x40(%rbp), %rcx
movq 0x18(%rcx), %rax
subq 0x10(%rcx), %rax
cqto
idivq %rdi
cmpq %r9, %rax
jbe 0x5bac
imulq $0x18, %r9, %rax
movq %rax, -0x50(%rbp)
xorl %r13d, %r13d
xorl %r15d, %r15d
movq %r9, -0x48(%rbp)
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rax
subq %rcx, %rax
cqto
idivq %rdi
cmpq %r15, %rax
jbe 0x5ba0
leaq (%r9,%r15), %rsi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %r12
movq 0x18(%rax), %rax
subq %r12, %rax
cqto
idivq %rdi
cmpq %rsi, %rax
jbe 0x5bca
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rsi
addq -0x50(%rbp), %rsi
addq %r13, %rcx
movq %r14, %rdi
movq %rcx, %rdx
callq 0x5d82
addq %rbx, %r12
addq %r13, %r12
leaq -0x70(%rbp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x5e66
movq -0x30(%rbp), %rax
movq (%rax), %rax
addq %rbx, %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0x10(%r13,%rax)
movups -0x70(%rbp), %xmm0
movups %xmm0, (%r13,%rax)
incq %r15
addq $0x18, %r13
pushq $0x18
popq %rdi
movq -0x48(%rbp), %r9
jmp 0x5b03
incq %r9
addq $0x18, %rbx
jmp 0x5ad7
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x3970
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2544(%rip), %rdi      # 0x8115
leaq 0x2551(%rip), %rsi      # 0x8129
leaq 0x2553(%rip), %rcx      # 0x8132
pushq $0x51
popq %rdx
callq 0x2110
jmp 0x5beb
jmp 0x5beb
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x4a9e
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: Polynomial<prime::Zp, prime::ZpElement>::operator==(Polynomial<prime::Zp, prime::ZpElement> const&) const
bool operator==(Polynomial const& e2)const{
        int d1 = degree(), d2 = e2.degree();
        int siz = std::min(d1+1,d2+1);
        for(int i=0;i<siz;++i)
            if(!(coef[i]==e2.coef[i]))
                return false;

        return d1==d2;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3b9e
movl %eax, %r15d
movq %rbx, %rdi
callq 0x3b9e
movl %eax, %ecx
movq %r15, -0x40(%rbp)
leal 0x1(%r15), %edx
movq %rcx, -0x38(%rbp)
leal 0x1(%rcx), %eax
cmpl %edx, %eax
cmovll %eax, %edx
xorl %r15d, %r15d
testl %edx, %edx
movl $0x0, %r12d
movl %edx, -0x2c(%rbp)
cmovgl %edx, %r12d
xorl %ecx, %ecx
movq %rcx, %r13
cmpq %rcx, %r12
je 0x624c
movq 0x10(%r14), %rdi
addq %r15, %rdi
movq 0x10(%rbx), %rsi
addq %r15, %rsi
callq 0x517e
leaq 0x1(%r13), %rcx
addq $0x18, %r15
testb %al, %al
jne 0x6225
movslq -0x2c(%rbp), %rax
cmpq %rax, %r13
setge %cl
movq -0x38(%rbp), %rax
cmpl %eax, -0x40(%rbp)
sete %al
andb %cl, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: Polynomial<prime::Zp, prime::ZpElement>::CanonicalType::__zero__() const
Polynomial __zero__()const{
            Polynomial out;
            out.canonicalType.scalar = scalar;
            out.coef.push_back(scalar->__zero__());
            return out;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq %rdi, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
andq $0x0, 0x20(%rdi)
movq (%rsi), %rax
movq %rax, (%rdi)
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
movq %rax, 0x8(%rsi)
andq $0x0, 0x10(%rsi)
movq %rbx, %rdi
callq 0x4fd8
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4a9e
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: DegreeList::operator<(DegreeList) const
bool operator<(DegreeList r)const{
        int ld = degree(), rd = r.degree();
        int num = std::min(ld,rd);
        for(int i=0;i<num;++i){
            if(at(i)==r[i]) continue;
            return at(i)<r[i];
        }
        return ld<rd;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r12
callq 0x6462
movl %eax, %ebx
movq %r14, %rdi
callq 0x6462
cmpl %ebx, %eax
movl %ebx, -0x34(%rbp)
movl %ebx, %ecx
movl %eax, -0x30(%rbp)
cmovll %eax, %ecx
xorl %ebx, %ebx
testl %ecx, %ecx
movl $0x0, %r15d
movl %ecx, -0x2c(%rbp)
cmovgl %ecx, %r15d
movq %rbx, %r13
cmpq %rbx, %r15
je 0x6438
movq %r12, %rdi
movq %r13, %rsi
callq 0x6490
movl (%rax), %eax
movq (%r14), %rcx
leaq 0x1(%r13), %rbx
cmpl (%rcx,%r13,4), %eax
je 0x63fe
leaq -0x1(%rbx), %rsi
movq %r12, %rdi
callq 0x6490
movl (%rax), %eax
movq (%r14), %rcx
cmpl -0x4(%rcx,%rbx,4), %eax
setl %al
movslq -0x2c(%rbp), %rcx
xorl %edx, %edx
movl -0x30(%rbp), %esi
cmpl %esi, -0x34(%rbp)
setl %dl
cmpq %rcx, %r13
movzbl %al, %eax
cmovgel %edx, %eax
andb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: DegreeList::degree() const
int degree()const{
        int i;
        for(i=size()-1;i>0;--i)
            if(back()!=0) break;
        return i;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rcx
movq %rcx, %rax
subq (%rdi), %rax
shrq $0x2, %rax
leal -0x1(%rax), %esi
movl %esi, %edx
sarl $0x1f, %edx
andl %esi, %edx
decl %eax
testl %eax, %eax
jle 0x648c
cmpl $0x0, -0x4(%rcx)
je 0x647e
jmp 0x648e
movl %edx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/asd00012334[P]Abstract-Algebra-2018/./quotient.hpp
// Function: quotient::fraction::operator/(quotient::fraction const&) const
fraction operator/(fraction const& r)const{
        if(r==0) throw std::exception();
        fraction out(en*r.dn, dn*r.en);
        out.reduce();
        return out;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x1
popq %rdx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x54a2
testb %al, %al
jne 0x6f2f
movq (%r14), %rax
movq 0x8(%r14), %rcx
imulq (%rbx), %rcx
imulq 0x8(%rbx), %rax
leaq -0x20(%rbp), %rbx
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x4ab2
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x20e0
movq 0x506a(%rip), %rcx      # 0xbfa8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x508c(%rip), %rsi      # 0xbfd8
movq 0x509d(%rip), %rdx      # 0xbff0
movq %rax, %rdi
callq 0x2290
nop