LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/markondej[P]phase_correl/phase_correl.cpp
// Function: main
GrayscaleImage(std::size_t width, std::size_t height, unsigned char fill) {
        data = new unsigned char[width * height];
        memset(data, fill, sizeof(unsigned char) * width * height);
        this->width = width;
        this->height = height;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl $0x8000, %edi           # imm = 0x8000
callq 0x1030
movq %rax, 0x30(%rsp)
movl $0x8000, %edx           # imm = 0x8000
movq %rax, %rdi
xorl %esi, %esi
callq 0x10a0
movl $0x100, %ebx            # imm = 0x100
movq %rbx, 0x20(%rsp)
movl $0x80, %r14d
movq %r14, 0x28(%rsp)
movl $0x8000, %edi           # imm = 0x8000
callq 0x1030
movq %rax, 0x18(%rsp)
movl $0x8000, %edx           # imm = 0x8000
movq %rax, %rdi
movl $0xff, %esi
callq 0x10a0
movq %rbx, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movl $0x20, %eax
movl $0x10, %ecx
movq 0x20(%rsp), %rdx
cmpq %rdx, %rcx
jae 0x138b
cmpq 0x28(%rsp), %rax
jae 0x138b
imulq %rax, %rdx
addq 0x30(%rsp), %rdx
movb $-0x80, (%rcx,%rdx)
incq %rcx
cmpq $0x4c, %rcx
jne 0x136d
incq %rax
cmpq $0x5c, %rax
jne 0x1368
movl $0x28, %eax
movl $0x8, %ecx
movq 0x8(%rsp), %rdx
cmpq %rdx, %rcx
jae 0x13c5
cmpq 0x10(%rsp), %rax
jae 0x13c5
imulq %rax, %rdx
addq 0x18(%rsp), %rdx
movb $0x10, (%rcx,%rdx)
incq %rcx
cmpq $0x44, %rcx
jne 0x13a7
incq %rax
cmpq $0x64, %rax
jne 0x13a2
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x3c(%rsp), %r14
leaq 0x38(%rsp), %rbx
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1488
movq 0x3bd3(%rip), %r15      # 0x4fd0
leaq 0x1c64(%rip), %rsi      # 0x3068
movl $0x13, %edx
movq %r15, %rdi
callq 0x1140
movl (%r14), %esi
movq %r15, %rdi
callq 0x1180
movq %rax, %r14
leaq 0x1c56(%rip), %rsi      # 0x307c
movl $0x2, %edx
movq %rax, %rdi
callq 0x1140
movl (%rbx), %esi
movq %r14, %rdi
callq 0x1180
movq %rax, %rbx
leaq 0x1c38(%rip), %rsi      # 0x307f
movl $0x1, %edx
movq %rax, %rdi
callq 0x1140
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x10b0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/markondej[P]phase_correl/phase_correl.cpp
// Function: PhaseCorrelation::ComputeNormalized(std::complex<double> const&, std::complex<double> const&, std::complex<double>&)
static void ComputeNormalized(const std::complex<double> &input1, const std::complex<double> &input2, std::complex<double> &output) {
        double a1 = (input1.imag() != 0.0) ? ((input1.real() != 0.0) ? atan(input1.imag() / input1.real()) : std::copysign(M_PI, input1.imag()) / 2.0) : 0.0;
        if (input1.real() < 0.0) {
            a1 = std::copysign(M_PI, input1.imag()) + a1;
        }

        double a2 = (input2.imag() != 0.0) ? ((input2.real() != 0.0) ? atan(input2.imag() / input2.real()) : std::copysign(M_PI, input2.imag()) / 2.0) : 0.0;
        if (input2.real() < 0.0) {
            a2 = std::copysign(M_PI, input2.imag()) + a2;
        }

        output.real(cos(a1 - a2));
        output.imag(sin(a1 - a2));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd 0x8(%rdi), %xmm0
xorpd %xmm5, %xmm5
ucomisd %xmm5, %xmm0
xorpd %xmm4, %xmm4
jne 0x1871
jnp 0x18ad
movsd (%r15), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jne 0x1882
jnp 0x1891
divsd %xmm1, %xmm0
callq 0x10f0
xorpd %xmm5, %xmm5
jmp 0x18a9
andpd 0x1777(%rip), %xmm0     # 0x3010
orpd 0x177f(%rip), %xmm0     # 0x3020
mulsd 0x17a7(%rip), %xmm0     # 0x3050
movapd %xmm0, %xmm4
movsd (%r15), %xmm3
movsd 0x8(%r15), %xmm6
movsd 0x8(%r14), %xmm0
ucomisd %xmm5, %xmm0
jne 0x18c6
jnp 0x1920
movsd (%r14), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jne 0x18d7
jnp 0x1904
divsd %xmm1, %xmm0
movapd %xmm3, (%rsp)
movapd %xmm4, 0x20(%rsp)
movapd %xmm6, 0x10(%rsp)
callq 0x10f0
movapd 0x10(%rsp), %xmm6
movapd 0x20(%rsp), %xmm4
movapd (%rsp), %xmm3
jmp 0x191c
andpd 0x1704(%rip), %xmm0     # 0x3010
orpd 0x170c(%rip), %xmm0     # 0x3020
mulsd 0x1734(%rip), %xmm0     # 0x3050
movapd %xmm0, %xmm5
movapd 0x16e8(%rip), %xmm0     # 0x3010
andpd %xmm0, %xmm6
movapd 0x16ec(%rip), %xmm1     # 0x3020
orpd %xmm1, %xmm6
addsd %xmm4, %xmm6
xorpd %xmm2, %xmm2
cmpltsd %xmm2, %xmm3
andpd %xmm3, %xmm6
andnpd %xmm4, %xmm3
orpd %xmm6, %xmm3
movapd %xmm3, %xmm6
movsd (%r14), %xmm3
movsd 0x8(%r14), %xmm4
andpd %xmm0, %xmm4
orpd %xmm1, %xmm4
addsd %xmm5, %xmm4
cmpltsd %xmm2, %xmm3
andpd %xmm3, %xmm4
andnpd %xmm5, %xmm3
orpd %xmm4, %xmm3
movapd %xmm6, %xmm0
subsd %xmm3, %xmm0
movapd %xmm0, (%rsp)
callq 0x11a0
movsd %xmm0, (%rbx)
movaps (%rsp), %xmm0
callq 0x1050
movsd %xmm0, 0x8(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/markondej[P]phase_correl/phase_correl.cpp
// Function: PhaseCorrelation::GenInputOrder(unsigned long)
static std::vector<std::size_t> GenInputOrder(std::size_t size) {
        std::size_t stride = 1;
        std::vector<std::size_t> offset;
        offset.resize(size);

        std::memset(offset.data(), 0xff, sizeof(std::size_t) * size);
        offset[0] = 0;

        for (std::size_t step = size >> 1; step > 0; step >>= 1) {
            std::size_t base = 0;
            for (std::size_t i = 0; i < size; i += step) {
                if (offset[i] != SIZE_MAX) {
                    base = offset[i];
                } else {
                    offset[i] = base + stride;
                }
            }
            stride <<= 1;
        }

        return offset;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x210a
movq (%rbx), %rdi
leaq (,%r14,8), %rdx
movl $0xff, %esi
callq 0x10a0
movq (%rbx), %rax
movq $0x0, (%rax)
cmpq $0x2, %r14
jb 0x1fcb
movl $0x1, %ecx
movq %r14, %rdx
movq %r14, %rsi
shrq %rsi
xorl %edi, %edi
xorl %r8d, %r8d
movq (%rax,%rdi,8), %r9
cmpq $-0x1, %r9
jne 0x1fb4
leaq (%r8,%rcx), %r9
movq %r9, (%rax,%rdi,8)
movq %r8, %r9
addq %rsi, %rdi
movq %r9, %r8
cmpq %r14, %rdi
jb 0x1f9f
addq %rcx, %rcx
cmpq $0x4, %rdx
movq %rsi, %rdx
jae 0x1f97
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1fe6
callq 0x1110
movq %r14, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O1/markondej[P]phase_correl/phase_correl.cpp
// Function: PhaseCorrelation::Sum2FFT(std::complex<double> const*, std::complex<double>*, unsigned long, bool)
static void Sum2FFT(const std::complex<double> *input, std::complex<double> *output, std::size_t size, bool inverse) {
        double dfi = (inverse ? 2.0 : -2.0) * M_PI / static_cast<double>(size << 1),
            kfi = 0.0;

        for (std::size_t k = 0; k < size; k++) {
            double cosfi = cos(kfi), sinfi = sin(kfi);
            std::complex<double> temp[] = { input[k], input[k + size] };

            output[k].real(temp[0].real() + cosfi * temp[1].real() - sinfi * temp[1].imag());
            output[k].imag(temp[0].imag() + sinfi * temp[1].real() + cosfi * temp[1].imag());
            output[k + size].real(temp[0].real() - cosfi * temp[1].real() + sinfi * temp[1].imag());
            output[k + size].imag(temp[0].imag() - sinfi * temp[1].real() - cosfi * temp[1].imag());
            kfi += dfi;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testl %ecx, %ecx
jne 0x2010
movsd 0x1052(%rip), %xmm2     # 0x3060
jmp 0x2018
movsd 0x1040(%rip), %xmm2     # 0x3058
testq %rbx, %rbx
je 0x20fd
leaq (%rbx,%rbx), %rax
movq %rax, %xmm0
punpckldq 0xffe(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1006(%rip), %xmm0     # 0x3040
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd %xmm1, %xmm2
movq %rbx, %r12
shlq $0x4, %r12
xorpd %xmm0, %xmm0
movsd %xmm2, 0x8(%rsp)
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
callq 0x11a0
movaps %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
callq 0x1050
movupd (%r15), %xmm1
movapd 0x10(%rsp), %xmm6
movapd %xmm6, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
movsd (%r15,%r12), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm2, %xmm3
xorpd 0xf6e(%rip), %xmm2      # 0x3010
movsd 0x8(%r15,%r12), %xmm4
movapd %xmm3, %xmm5
addpd %xmm1, %xmm5
unpcklpd %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0]
shufpd $0x1, %xmm6, %xmm2      # xmm2 = xmm2[1],xmm6[0]
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
mulpd %xmm4, %xmm2
addpd %xmm5, %xmm2
movupd %xmm2, (%r14)
movsd 0x8(%rsp), %xmm2
subpd %xmm3, %xmm1
mulpd %xmm0, %xmm4
movsd (%rsp), %xmm0
addpd %xmm1, %xmm4
movupd %xmm4, (%r14,%r12)
addsd %xmm2, %xmm0
addq $0x10, %r14
addq $0x10, %r15
decq %rbx
jne 0x205b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/JohnWoodman[P]SHellNo/listener.cpp
// Function: listener::test()
void listener::test(){
	printf("server: waiting for connections...\n");
	sin_size = sizeof their_addr;
	new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);
	if (new_fd == -1) {
		cout<<"accepted error"<<endl;
	}
	cout<<"got connection"<<endl;
	status = 1;
	inet_ntop(their_addr.ss_family, get_in_addr((struct sockaddr *)&their_addr), s, sizeof s);
	//postExploitMenu(this);

	//close(sockfd);
	//close(new_fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2f46(%rip), %rdi      # 0x1715e
callq 0x55a0
leaq 0xe0(%rbx), %rdx
movl $0x80, 0xe0(%rbx)
movl 0x10(%rbx), %edi
leaq 0x60(%rbx), %r14
movq %r14, %rsi
callq 0x5130
movl %eax, 0x14(%rbx)
cmpl $-0x1, %eax
jne 0x14287
movq 0xad5c(%rip), %r15      # 0x1efa8
leaq 0x2e77(%rip), %rsi      # 0x170ca
movl $0xe, %edx
movq %r15, %rdi
callq 0x5400
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5350
movsbl %al, %esi
movq %r15, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5280
movq 0xad1a(%rip), %r15      # 0x1efa8
leaq 0x2e44(%rip), %rsi      # 0x170d9
movl $0xe, %edx
movq %r15, %rdi
callq 0x5400
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5350
movsbl %al, %esi
movq %r15, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5280
movl $0x1, 0x184(%rbx)
movzwl 0x60(%rbx), %edi
xorl %eax, %eax
cmpl $0x2, %edi
setne %al
leaq (%r14,%rax,4), %rsi
addq $0x4, %rsi
addq $0x188, %rbx            # imm = 0x188
movq %rbx, %rdx
movl $0x2e, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x53b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/JohnWoodman[P]SHellNo/listener.cpp
// Function: listener::injectShellcode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int listener::injectShellcode(string l_path) {
	printf("Injecting Shellcode...\n");
	std::streampos filesize = 0;
	ifstream in(l_path, std::ios::binary);
	char* sendbuf = new char[1024];
	int sendbuflen = 1024;
	memset(sendbuf, '\0', sendbuflen);
	
	string cmd = "shellcode:";
	send(new_fd, cmd.c_str(), cmd.length(), 0);

	while (in.is_open()) {
		printf("File is open\n");
		in.read(sendbuf, sendbuflen);
		if (in.eof()) {
			printf("End of file\n");
			send(new_fd, sendbuf, sendbuflen, 0);
			memset(sendbuf, '\0', sendbuflen);
			in.close();
		} else {
			printf("Sending file\n");
			send(new_fd, sendbuf, sendbuflen, 0);
			memset(sendbuf, '\0', sendbuflen);
		}
	}
	printf("Finished Uploading Shellcode!\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2abc(%rip), %rdi      # 0x171f3
callq 0x55a0
leaq -0x250(%rbp), %rdi
movq %r14, %rsi
movl $0x4, %edx
callq 0x55d0
movl $0x400, %edi            # imm = 0x400
callq 0x5030
movq %rax, %r14
movl $0x400, %edx            # imm = 0x400
movq %rax, %rdi
xorl %esi, %esi
callq 0x5230
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x29c6(%rip), %rsi      # 0x17141
leaq 0x29c9(%rip), %rdx      # 0x1714b
leaq -0x48(%rbp), %rdi
callq 0x14ee0
movl 0x14(%rbx), %edi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
xorl %ecx, %ecx
callq 0x51f0
leaq -0x1d8(%rbp), %r15
movq %r15, %rdi
callq 0x50c0
testb %al, %al
je 0x14863
leaq 0x2a6d(%rip), %r12      # 0x17228
leaq -0x250(%rbp), %r13
movq %r12, %rdi
callq 0x55a0
movl $0x400, %edx            # imm = 0x400
movq %r13, %rdi
movq %r14, %rsi
callq 0x5480
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x230(%rbp,%rax)
jne 0x1481e
leaq 0x2a3f(%rip), %rdi      # 0x17235
callq 0x55a0
movl 0x14(%rbx), %edi
movl $0x400, %edx            # imm = 0x400
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x51f0
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x5230
jmp 0x14853
leaq 0x2a1d(%rip), %rdi      # 0x17242
callq 0x55a0
movl 0x14(%rbx), %edi
movl $0x400, %edx            # imm = 0x400
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x51f0
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x5230
movq %r13, %rdi
callq 0x50b0
movq %r15, %rdi
callq 0x50c0
testb %al, %al
jne 0x147c2
leaq 0x29a0(%rip), %rdi      # 0x1720a
callq 0x55a0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x14888
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x5370
leaq -0x250(%rbp), %rdi
callq 0x50e0
xorl %eax, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x148b1
jmp 0x148ac
movq %rax, %rbx
jmp 0x148cd
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x148cd
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x5370
leaq -0x250(%rbp), %rdi
callq 0x50e0
movq %rbx, %rdi
callq 0x5630
// File: /workspace/github_cpp_makefile_star2_O1/JohnWoodman[P]SHellNo/listener.cpp
// Function: printingThing(void*)
void 
*printingThing(void* in){
	int new_fd = *(int*)in;
	char* recvbuf = new char[2048];
	int n = 1000;
	int buflen = 2048;
	int byte_recv;
	do{
		byte_recv = recv(new_fd, recvbuf, buflen, 0);
		for(int i=0;i<byte_recv;i++){
			printf("%c",recvbuf[i]);
		}
		n--;
	}while(n>0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl (%rdi), %ebx
movl $0x800, %edi            # imm = 0x800
callq 0x5030
movq %rax, %r14
movl $0x800, %edx            # imm = 0x800
movl %ebx, %edi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x5140
movq %rax, %r15
testl %r15d, %r15d
jle 0x148fb
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movsbl (%r14,%r12), %edi
callq 0x54f0
incq %r12
cmpq %r12, %r15
jne 0x1491e
jmp 0x148fb
// File: /workspace/github_cpp_makefile_star2_O1/JohnWoodman[P]SHellNo/listener.cpp
// Function: listener::dropIntoShell()
int listener::dropIntoShell() {
	printf("Dropping into Shell...\n");

	char* sendbuf = new char[2048];
	char* recvbuf = new char[2048];
	int buflen = 2048;
	memset(sendbuf, '\0', buflen);
	memset(recvbuf, '\0', buflen);

	char cmd[] = "dropshell:";
	send(new_fd, cmd, strlen(cmd), 0);

	printf("Dropped into shell!\n");

	int bytes;
	int byte_recv;
	int n;
	pthread_attr_t attr;
	void* status;
    	// Initialize and set thread joinable
    	pthread_attr_init(&attr);
    	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
	pthread_t t;
	pthread_create(&t,&attr,printingThing,(void*)&new_fd);

	do {
		n = 0;
		fgets(sendbuf,1024,stdin);

		n = strlen(sendbuf);
		sendbuf[n]='\n'; sendbuf[n+1]='\0';

		bytes = send(new_fd, sendbuf, strlen(sendbuf), 0);

	} while (true);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x2903(%rip), %rdi      # 0x1724e
callq 0x55a0
movl $0x800, %edi            # imm = 0x800
callq 0x5030
movq %rax, %r14
movl $0x800, %edx            # imm = 0x800
movq %rax, %rdi
xorl %esi, %esi
callq 0x5230
movabsq $0x6c656873706f7264, %rax # imm = 0x6C656873706F7264
leaq -0x38(%rbp), %r15
movq %rax, (%r15)
movl $0x3a6c6c, 0x7(%r15)    # imm = 0x3A6C6C
movl 0x14(%rbx), %r12d
addq $0x14, %rbx
movq %r15, %rdi
callq 0x51c0
movl %r12d, %edi
movq %r15, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x51f0
leaq 0x28b9(%rip), %rdi      # 0x17265
callq 0x55a0
leaq -0x70(%rbp), %r15
movq %r15, %rdi
callq 0x5430
movq %r15, %rdi
xorl %esi, %esi
callq 0x54d0
leaq -0xed(%rip), %rdx       # 0x148e1
leaq -0x28(%rbp), %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x5670
movq 0xa5a4(%rip), %r12      # 0x1ef88
movq (%r12), %rdx
movq %r14, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x55c0
movq %r14, %rdi
callq 0x51c0
cltq
movb $0xa, (%r14,%rax)
incl %eax
cltq
movb $0x0, (%r14,%rax)
movl (%rbx), %r15d
movq %r14, %rdi
callq 0x51c0
movl %r15d, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x51f0
jmp 0x149e4
// File: /workspace/github_cpp_makefile_star2_O1/JohnWoodman[P]SHellNo/listenerManager.cpp
// Function: listenerManager::addListener(int)
int
listenerManager::addListener(int port){
    listener* newListener = new listener(port);
    listeners.push_back(newListener);
    thread t1(&listener::test,newListener);
    t1.detach();
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %r15d
movq %rdi, %rbx
movl $0x1c0, %edi            # imm = 0x1C0
callq 0x5360
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
callq 0x13f8a
movq %r14, -0x28(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x153db
movq %r14, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x153e7
leaq -0x28(%rbp), %rdx
movq %rbx, %rdi
callq 0x155d0
leaq -0x11ea(%rip), %rax     # 0x14204
leaq -0x38(%rbp), %rsi
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
leaq -0x20(%rbp), %rbx
leaq -0x28(%rbp), %rdx
movq %rbx, %rdi
callq 0x1553e
movq %rbx, %rdi
callq 0x5620
cmpq $0x0, -0x20(%rbp)
jne 0x15438
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, -0x20(%rbp)
jne 0x15438
movq %rax, %rbx
jmp 0x1544d
callq 0x50f0
movq %rax, %rbx
movl $0x1c0, %esi            # imm = 0x1C0
movq %r14, %rdi
callq 0x5370
movq %rbx, %rdi
callq 0x5630
nop
// File: /workspace/github_cpp_makefile_star2_O1/ushitora-anqou[P]aqtfhe2/main.cpp
// Function: aqtfhe2::detail::nd_array<bool, 1000ul> (anonymous namespace)::random_bool_array<1000ul, std::random_device>(std::random_device&)
nd_array<bool, N> random_bool_array(RandomEngine& rand)
{
    nd_array<bool, N> ret;
    std::binomial_distribution<int> binary;
    for (bool& v : ret)
        v = binary(rand);
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movl $0x1, (%r15)
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
movq %rax, 0x8(%r15)
movq %r15, %rdi
callq 0x5084
vxorps %xmm0, %xmm0, %xmm0
vmovhps 0x5348(%rip), %xmm0, %xmm0 # xmm0 = xmm0[0,1],mem[0,1]
vmovups %xmm0, 0x70(%r15)
movq $0x0, 0x80(%r15)
movb $0x0, 0x88(%r15)
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x53b2
testl %eax, %eax
setne (%rbx,%r12)
incq %r12
cmpq $0x3e8, %r12            # imm = 0x3E8
jne 0x2cec
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: aqtfhe2::secret_key<aqtfhe2::params::CGGI16> aqtfhe2::secret_key<aqtfhe2::params::CGGI16>::make<std::random_device>(std::random_device&)
static secret_key make(RandomEngine &rand)
    {
        std::binomial_distribution<uint32_t> binary;

        container_key_lvl0 key_lvl0;
        for (uint32_t &v : key_lvl0)
            v = binary(rand);

        container_key_lvl1 key_lvl1;
        for (uint32_t &v : key_lvl1)
            v = binary(rand);

        return secret_key{std::move(key_lvl0), std::move(key_lvl1)};
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1868, %rsp           # imm = 0x1868
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movl $0x1, (%r15)
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
movq %rax, 0x8(%r15)
movq %r15, %rdi
callq 0x304a
vxorps %xmm0, %xmm0, %xmm0
vmovhps 0x523c(%rip), %xmm0, %xmm0 # xmm0 = xmm0[0,1],mem[0,1]
vmovups %xmm0, 0x70(%r15)
movq $0x0, 0x80(%r15)
movb $0x0, 0x88(%r15)
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3380
movl %eax, 0x98(%rsp,%r12)
addq $0x4, %r12
cmpq $0x7d0, %r12            # imm = 0x7D0
jne 0x2df8
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3380
movl %eax, 0x868(%rsp,%r12)
addq $0x4, %r12
cmpq $0x1000, %r12           # imm = 0x1000
jne 0x2e23
leaq 0x98(%rsp), %rsi
movl $0x7d0, %edx            # imm = 0x7D0
movq %rbx, %rdi
callq 0x2140
movq %rbx, %rdi
addq $0x7d0, %rdi            # imm = 0x7D0
leaq 0x868(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2140
movq %rbx, %rax
addq $0x1868, %rsp           # imm = 0x1868
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: aqtfhe2::cloud_key<aqtfhe2::params::CGGI16>::cloud_key<std::random_device>(std::random_device&, aqtfhe2::detail::nd_array<unsigned int, 500ul> const&, aqtfhe2::detail::nd_array<unsigned int, 1024ul> const&)
cloud_key(RandomEngine &rand,
              const typename secret_key<P>::container_key_lvl0 &key_lvl0,
              const typename secret_key<P>::container_key_lvl1 &key_lvl1)
        : ksk_(std::make_unique<key_switching_key<P>>(rand, key_lvl0, key_lvl1))
    {
        // Fill bkfftlvl01_
        bkfftlvl01_.reserve(P::n());
        for (size_t i = 0; i < P::n(); i++) {
            bkfftlvl01_.push_back(trgswfft_lvl1<P>::sym_encrypt(
                rand, key_lvl1, P::alphabk(),
                static_cast<uint32_t>(key_lvl0[i])));
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10008, %rsp          # imm = 0x10008
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x2ef8000, %edi        # imm = 0x2EF8000
callq 0x2180
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3eb6
movq %r13, (%rbx)
leaq 0x8(%rbx), %rdi
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movl $0x1f4, %esi            # imm = 0x1F4
movq %rdi, (%rsp)
callq 0x3b8a
xorl %r13d, %r13d
leaq 0x8(%rsp), %rbp
movl (%r15,%r13,4), %ecx
movq %rbp, %rdi
movq %r12, %rsi
movq %r14, %rdx
vmovsd 0x45b2(%rip), %xmm0     # 0x8098
callq 0x3c64
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x3b0f
movl $0x10000, %edx          # imm = 0x10000
movq %rsi, %rdi
movq %rbp, %rsi
callq 0x2140
addq $0x10000, 0x10(%rbx)    # imm = 0x10000
jmp 0x3b1b
movq (%rsp), %rdi
movq %rbp, %rdx
callq 0x409c
incq %r13
cmpq $0x1f4, %r13            # imm = 0x1F4
jne 0x3ad1
addq $0x10008, %rsp          # imm = 0x10008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b4d
movq %rax, %r14
movl $0x2ef8000, %esi        # imm = 0x2EF8000
movq %r13, %rdi
callq 0x2190
jmp 0x3b81
movq %rax, %r14
movq (%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3b68
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x2190
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3b7a
movl $0x2ef8000, %esi        # imm = 0x2EF8000
callq 0x2190
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: aqtfhe2::key_switching_key<aqtfhe2::params::CGGI16>::key_switching_key<std::random_device>(std::random_device&, aqtfhe2::detail::nd_array<unsigned int, 500ul> const&, aqtfhe2::detail::nd_array<unsigned int, 1024ul> const&)
key_switching_key<P>::key_switching_key(
    RandomEngine &rand,
    const typename secret_key<P>::container_key_lvl0 &key_lvl0,
    const typename secret_key<P>::container_key_lvl1 &key_lvl1)
{
    for (size_t i = 0; i < P::N(); i++) {
        for (size_t j = 0; j < P::t(); j++) {
            for (size_t k = 0; k < (1u << P::basebit()) - 1; k++) {
                uint32_t val = key_lvl1[i] * (k + 1) *
                               (1U << (32 - (j + 1) * P::basebit()));
                tlwe_lvl0<P>::sym_encrypt(data_.slice(i, j, k), rand, key_lvl0,
                                          P::alphaks(), val);
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %r13
xorl %r12d, %r12d
movq %r13, 0x8(%rsp)
xorl %edi, %edi
movq %rdi, 0x10(%rsp)
addq %rdi, %rdi
xorq $0x1e, %rdi
movq %rdi, 0x20(%rsp)
movl $0x1, %ebx
movq %r13, 0x18(%rsp)
movl (%r14,%r12,4), %eax
imull %ebx, %eax
movq 0x20(%rsp), %rcx
shlxq %rcx, %rax, %rcx
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
vmovsd 0x40f1(%rip), %xmm0     # 0x8008
callq 0x3f72
incq %rbx
addq $0x7d4, %r13            # imm = 0x7D4
cmpq $0x4, %rbx
jne 0x3ef5
movq 0x10(%rsp), %rdi
incq %rdi
movq 0x18(%rsp), %r13
addq $0x177c, %r13           # imm = 0x177C
cmpq $0x8, %rdi
jne 0x3eda
incq %r12
movq 0x8(%rsp), %r13
addq $0xbbe0, %r13           # imm = 0xBBE0
cmpq $0x400, %r12            # imm = 0x400
jne 0x3ed3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: void aqtfhe2::tlwe_lvl0<aqtfhe2::params::CGGI16>::sym_encrypt<std::random_device>(aqtfhe2::detail::array_slice<unsigned int, 501ul>, std::random_device&, aqtfhe2::detail::nd_array<unsigned int, 500ul> const&, double, unsigned int)
static void sym_encrypt(
        detail::array_slice<uint32_t, P::n() + 1> out, RandomEngine &rand,
        const typename secret_key<P>::container_key_lvl0 &key, double alpha,
        uint32_t plain)
    {
        std::uniform_int_distribution<uint32_t> torus(
            0, std::numeric_limits<uint32_t>::max());
        std::normal_distribution<double> gaussian(0.0, alpha);

        out[P::n()] = plain + detail::double2torus32(gaussian(rand));
        for (size_t i = 0; i < P::n(); i++) {
            out[i] = torus(rand);
            out[P::n()] += out[i] * key[i];
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rsp, %r12
movq %rax, (%r12)
xorl %r13d, %r13d
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
vmovsd %xmm0, 0x8(%rdi)
movq %r13, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movq %rdi, %rdx
callq 0x398a
vroundsd $0x9, %xmm0, %xmm0, %xmm1
vsubsd %xmm1, %xmm0, %xmm0
vmulsd 0x40d2(%rip), %xmm0, %xmm0 # 0x80a0
vcvttsd2usi %xmm0, %eax
addl %ebp, %eax
movl %eax, 0x7d0(%r15)
movq %r12, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4016
movl %eax, (%r15,%r13,4)
imull (%rbx,%r13,4), %eax
addl %eax, 0x7d0(%r15)
incq %r13
cmpq $0x1f4, %r13            # imm = 0x1F4
jne 0x3fdd
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: aqtfhe2::trlwe_lvl1<aqtfhe2::params::CGGI16> aqtfhe2::trlwe_lvl1<aqtfhe2::params::CGGI16>::sym_encrypt_zero<std::random_device>(std::random_device&, aqtfhe2::detail::nd_array<unsigned int, 1024ul> const&, double)
static trlwe_lvl1 sym_encrypt_zero(
        RandomEngine &rand,
        const typename secret_key<P>::container_key_lvl1 &key, double alpha)
    {
        std::uniform_int_distribution<uint32_t> torus(
            0, std::numeric_limits<uint32_t>::max());
        std::normal_distribution<double> gaussian(0.0, alpha);

        container poly0;
        for (uint32_t &v : poly0)
            v = torus(rand);

        container poly1 = poly_mul_lvl1(poly0, key);
        for (uint32_t &v : poly1)
            v += detail::double2torus32(gaussian(rand));

        return trlwe_lvl1{poly0, poly1};
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2030, %rsp           # imm = 0x2030
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
leaq 0x28(%rsp), %r12
movq %rax, (%r12)
xorl %r13d, %r13d
movq %r13, 0x8(%rsp)
vmovsd %xmm0, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4016
movl %eax, 0x1030(%rsp,%r13)
addq $0x4, %r13
cmpq $0x1000, %r13           # imm = 0x1000
jne 0x4334
leaq 0x30(%rsp), %rdi
leaq 0x1030(%rsp), %rsi
movq %r15, %rdx
callq 0x4a82
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x398a
vroundsd $0x9, %xmm0, %xmm0, %xmm1
vsubsd %xmm1, %xmm0, %xmm0
vmulsd 0x3d0c(%rip), %xmm0, %xmm0 # 0x80a0
vcvttsd2usi %xmm0, %eax
addl %eax, 0x30(%rsp,%r12)
addq $0x4, %r12
cmpq $0x1000, %r12           # imm = 0x1000
jne 0x4374
leaq 0x1030(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rdi
callq 0x2140
movq %rbx, %rdi
addq $0x1000, %rdi           # imm = 0x1000
leaq 0x30(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2140
movq %rbx, %rax
addq $0x2030, %rsp           # imm = 0x2030
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: aqtfhe2::trlwe_lvl1<aqtfhe2::params::CGGI16>::poly_mul_lvl1(aqtfhe2::detail::nd_array<unsigned int, 1024ul> const&, aqtfhe2::detail::nd_array<unsigned int, 1024ul> const&)
static container poly_mul_lvl1(const container &a, const container &b)
    {
        thread_local detail::fft_processor<P::N()> fftproc;
        const detail::nd_array<double, P::N()> ffta =
                                                   fftproc.twist_ifft_lvl1(a),
                                               fftb =
                                                   fftproc.twist_ifft_lvl1(b);
        return fftproc.twist_fft_lvl1(
            detail::mul_in_fd(ffta.slice(), fftb.slice()));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x6008, %rsp           # imm = 0x6008
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, %fs:-0x20028
je 0x4bd8
xorl %eax, %eax
vcvtdq2pd (%r14,%rax,4), %zmm0
vmovupd %zmm0, 0x8(%rsp,%rax,8)
addq $0x8, %rax
cmpq $0x400, %rax            # imm = 0x400
jne 0x4aaa
movq %fs:0x0, %rax
leaq -0x28028(%rax), %r14
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
vzeroupper
callq 0x4e6e
leaq 0x4008(%rsp), %rdi
movl $0x2000, %edx           # imm = 0x2000
movq %r12, %rsi
callq 0x2140
xorl %eax, %eax
vcvtdq2pd (%r15,%rax,4), %zmm0
vmovupd %zmm0, 0x8(%rsp,%rax,8)
addq $0x8, %rax
cmpq $0x400, %rax            # imm = 0x400
jne 0x4b02
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
vzeroupper
callq 0x4e6e
leaq 0x2008(%rsp), %rdi
movl $0x2000, %edx           # imm = 0x2000
movq %r15, %rsi
callq 0x2140
movl $0x200, %eax            # imm = 0x200
vmovupd 0x4008(%rsp,%rax,8), %zmm0
vmovupd 0x2008(%rsp,%rax,8), %zmm1
vmulpd %zmm0, %zmm1, %zmm2
vmovupd 0x3008(%rsp,%rax,8), %zmm3
vmulpd %zmm1, %zmm3, %zmm1
vmovupd 0x1008(%rsp,%rax,8), %zmm4
vfmsub231pd %zmm3, %zmm4, %zmm2 # zmm2 = (zmm4 * zmm3) - zmm2
vmovupd %zmm2, -0xff8(%rsp,%rax,8)
vfmadd231pd %zmm0, %zmm4, %zmm1 # zmm1 = (zmm4 * zmm0) + zmm1
vmovupd %zmm1, 0x8(%rsp,%rax,8)
addq $0x8, %rax
cmpq $0x400, %rax            # imm = 0x400
jne 0x4b4d
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
vzeroupper
callq 0x4be2
movq %rbx, %rax
addq $0x6008, %rsp           # imm = 0x6008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2252
jmp 0x4aa8
// File: /workspace/github_cpp_makefile_star2_O1/ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: aqtfhe2::detail::fft_processor<1024ul>::twist_fft_lvl1(aqtfhe2::detail::array_slice<unsigned int, 1024ul>, aqtfhe2::detail::const_array_slice<double, 1024ul>)
void twist_fft_lvl1(array_slice<uint32_t, N> out,
                        const_array_slice<double, N> a)
    {
        nd_array<double, N> tmp;
        for (size_t i = 0; i < N; i++)
            tmp[i] = a[i] * (2.0 / N);
        fft(tmp.slice());
        for (size_t i = 0; i < N; i++)
            out[i] = static_cast<uint32_t>(static_cast<int64_t>(tmp[i]));
    }

// Assembly:
pushq %rbx
subq $0x2000, %rsp           # imm = 0x2000
movq %rsi, %rbx
xorl %eax, %eax
vbroadcastsd 0x34bf(%rip), %zmm0 # 0x80b8
vmulpd (%rdx,%rax,8), %zmm0, %zmm1
vmovupd %zmm1, (%rsp,%rax,8)
addq $0x8, %rax
cmpq $0x400, %rax            # imm = 0x400
jne 0x4bf9
movq %rsp, %rsi
vzeroupper
callq 0x4c46
xorl %eax, %eax
vcvttpd2qq (%rsp,%rax,8), %zmm0
vpmovqd %zmm0, (%rbx,%rax,4)
addq $0x8, %rax
cmpq $0x400, %rax            # imm = 0x400
jne 0x4c20
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: aqtfhe2::tlwe_lvl0<aqtfhe2::params::CGGI16>::nand(aqtfhe2::tlwe_lvl0<aqtfhe2::params::CGGI16> const&, std::vector<aqtfhe2::trgswfft_lvl1<aqtfhe2::params::CGGI16>, std::allocator<aqtfhe2::trgswfft_lvl1<aqtfhe2::params::CGGI16>>> const&, aqtfhe2::key_switching_key<aqtfhe2::params::CGGI16> const&) const
tlwe_lvl0 nand(const tlwe_lvl0 &rhs,
                   const std::vector<trgswfft_lvl1<P>> &bkfftlvl01,
                   const key_switching_key<P> &ksk) const
    {
        container ret;
        for (size_t i = 0; i <= P::n(); i++)
            ret[i] = -data_[i] - rhs.data_[i];
        ret[P::n()] += 1U << 29;

        return tlwe_lvl0{std::move(ret)}.gate_bootstrapping(bkfftlvl01, ksk);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1fb0, %rsp           # imm = 0x1FB0
movq %r8, %rbx
movq %rcx, %r15
movq %rdi, %r14
xorl %eax, %eax
vpmovsxbq 0x264b(%rip), %zmm0 # 0x80d0
vpmovsxbq 0x2649(%rip), %zmm1 # 0x80d8
vpbroadcastq 0x262f(%rip), %zmm2 # 0x80c8
vpxor %xmm3, %xmm3, %xmm3
vpbroadcastq %rax, %zmm4
vporq %zmm0, %zmm4, %zmm5
vporq %zmm1, %zmm4, %zmm4
vpcmpltuq %zmm2, %zmm4, %k0
vpcmpltuq %zmm2, %zmm5, %k1
kunpckbw %k0, %k1, %k1
vmovdqu32 (%rsi,%rax,4), %zmm4 {%k1} {z}
vmovdqu32 (%rdx,%rax,4), %zmm5 {%k1} {z}
vpaddd %zmm5, %zmm4, %zmm4
vpsubd %zmm4, %zmm3, %zmm4
vmovdqu32 %zmm4, (%rsp,%rax,4) {%k1}
addq $0x10, %rax
cmpq $0x200, %rax            # imm = 0x200
jne 0x5a9d
movq %rsp, %rsi
addl $0x20000000, 0x7d0(%rsi) # imm = 0x20000000
leaq 0x7d8(%rsp), %r12
movl $0x7d4, %edx            # imm = 0x7D4
movq %r12, %rdi
vzeroupper
callq 0x2140
leaq 0xfac(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x5b4c
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x5d5a
movq %r14, %rax
addq $0x1fb0, %rsp           # imm = 0x1FB0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: aqtfhe2::tlwe_lvl1<aqtfhe2::params::CGGI16>::identity_key_switch(aqtfhe2::key_switching_key<aqtfhe2::params::CGGI16> const&) const
tlwe_lvl0<P> tlwe_lvl1<P>::identity_key_switch(
    const key_switching_key<P> &ksk) const
{
    const uint32_t prec_offset = 1U << (32 - (1 + P::basebit() * P::t()));
    const uint32_t mask = (1U << P::basebit()) - 1;

    typename tlwe_lvl0<P>::container ret = {};
    ret[P::n()] = data_[P::N()];
    for (size_t i = 0; i < P::N(); i++) {
        uint32_t aibar = data_[i] + prec_offset;
        for (size_t j = 0; j < P::t(); j++) {
            uint32_t aij = (aibar >> (32 - (j + 1) * P::basebit())) & mask;
            if (aij == 0)
                continue;
            for (size_t k = 0; k <= P::n(); k++)
                ret[k] -= ksk(i, j, aij - 1, k);
        }
    }

    return tlwe_lvl0<P>{std::move(ret)};
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7e0, %rsp            # imm = 0x7E0
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r12
xorl %r13d, %r13d
movl $0x7d4, %edx            # imm = 0x7D4
movq %r12, %rdi
xorl %esi, %esi
callq 0x20b0
movl 0x1000(%r15), %eax
movl %eax, 0x7d0(%r12)
movl $0x8000, %eax           # imm = 0x8000
vpmovsxbq 0x2328(%rip), %zmm0 # 0x80d0
vpmovsxbq 0x2326(%rip), %zmm1 # 0x80d8
vpbroadcastq 0x230c(%rip), %zmm2 # 0x80c8
movl (%r15,%r13,4), %ecx
addl %eax, %ecx
movq %r14, %rdx
xorl %esi, %esi
incq %rsi
leal (%rsi,%rsi), %edi
negb %dil
shrxl %edi, %ecx, %edi
andl $0x3, %edi
je 0x5e3d
decl %edi
imulq $0x7d4, %rdi, %rdi      # imm = 0x7D4
addq %rdx, %rdi
xorl %r8d, %r8d
vpbroadcastq %r8, %zmm3
vporq %zmm0, %zmm3, %zmm4
vporq %zmm1, %zmm3, %zmm3
vpcmpltuq %zmm2, %zmm3, %k0
vpcmpltuq %zmm2, %zmm4, %k1
kunpckbw %k0, %k1, %k1
vmovdqu32 (%rdi,%r8,4), %zmm3 {%k1} {z}
vmovdqu32 0x8(%rsp,%r8,4), %zmm4 {%k1} {z}
vpsubd %zmm3, %zmm4, %zmm3
vmovdqu32 %zmm3, 0x8(%rsp,%r8,4) {%k1}
addq $0x10, %r8
cmpq $0x200, %r8             # imm = 0x200
jne 0x5de9
addq $0x177c, %rdx           # imm = 0x177C
cmpq $0x8, %rsi
jne 0x5dc7
incq %r13
addq $0xbbe0, %r14           # imm = 0xBBE0
cmpq $0x400, %r13            # imm = 0x400
jne 0x5dbc
leaq 0x8(%rsp), %rsi
movl $0x7d4, %edx            # imm = 0x7D4
movq %rbx, %rdi
vzeroupper
callq 0x2140
movq %rbx, %rax
addq $0x7e0, %rsp            # imm = 0x7E0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: aqtfhe2::tlwe_lvl0<aqtfhe2::params::CGGI16>::rotated_test_vector(unsigned int) const
trlwe_lvl1<P> rotated_test_vector(uint32_t bara) const
    {
        constexpr uint32_t N = P::N(), mu = P::mu();

        typename trlwe_lvl1<P>::container poly1;

        if (bara < N) {
            for (uint32_t i = 0; i < bara; i++)
                poly1[i] = -mu;
            for (uint32_t i = bara; i < N; i++)
                poly1[i] = mu;
        }
        else {
            const uint32_t baraa = bara - N;
            for (uint32_t i = 0; i < baraa; i++)
                poly1[i] = mu;
            for (uint32_t i = baraa; i < N; i++)
                poly1[i] = -mu;
        }

        return trlwe_lvl1<P>{typename trlwe_lvl1<P>::container{{}},
                             std::move(poly1)};
    }

// Assembly:
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdi, %rbx
cmpl $0x3ff, %edx            # imm = 0x3FF
ja 0x5f32
movl %edx, %eax
testl %edx, %edx
je 0x5f12
addl $0xf, %edx
andl $0x7f0, %edx            # imm = 0x7F0
leaq -0x1(%rax), %rcx
vpbroadcastq %rcx, %zmm0
xorl %ecx, %ecx
vpmovsxbq 0x2206(%rip), %zmm1 # 0x80d0
vpmovsxbq 0x2204(%rip), %zmm2 # 0x80d8
vpbroadcastd 0x2292(%rip), %zmm3 # 0x8170
vpbroadcastq %rcx, %zmm4
vporq %zmm1, %zmm4, %zmm5
vporq %zmm2, %zmm4, %zmm4
vpcmpleuq %zmm0, %zmm4, %k0
vpcmpleuq %zmm0, %zmm5, %k1
kunpckbw %k0, %k1, %k1
vmovdqu32 %zmm3, (%rsp,%rcx,4) {%k1}
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x5ede
incq %rax
movq %rax, %rcx
movl $0x20000000, -0x4(%rsp,%rax,4) # imm = 0x20000000
incq %rcx
cmpl $0x400, %eax            # imm = 0x400
movq %rcx, %rax
jne 0x5f18
jmp 0x5fc5
addl $0xfffffc00, %edx       # imm = 0xFFFFFC00
movl %edx, %eax
je 0x5fa2
leaq 0xf(%rax), %rcx
andq $-0x10, %rcx
leaq -0x1(%rax), %rsi
vpbroadcastq %rsi, %zmm0
xorl %esi, %esi
vpmovsxbq 0x2176(%rip), %zmm1 # 0x80d0
vpmovsxbq 0x2174(%rip), %zmm2 # 0x80d8
vpbroadcastd 0x21fe(%rip), %zmm3 # 0x816c
vpbroadcastq %rsi, %zmm4
vporq %zmm1, %zmm4, %zmm5
vporq %zmm2, %zmm4, %zmm4
vpcmpleuq %zmm0, %zmm4, %k0
vpcmpleuq %zmm0, %zmm5, %k1
kunpckbw %k0, %k1, %k1
vmovdqu32 %zmm3, (%rsp,%rsi,4) {%k1}
addq $0x10, %rsi
cmpq %rsi, %rcx
jne 0x5f6e
cmpl $0x3ff, %edx            # imm = 0x3FF
ja 0x5fc5
incq %rax
movq %rax, %rcx
movl $0xe0000000, -0x4(%rsp,%rax,4) # imm = 0xE0000000
incq %rcx
cmpl $0x400, %eax            # imm = 0x400
movq %rcx, %rax
jne 0x5fb0
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rdi
xorl %esi, %esi
vzeroupper
callq 0x20b0
movq %rbx, %rdi
addq $0x1000, %rdi           # imm = 0x1000
movq %rsp, %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2140
movq %rbx, %rax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: aqtfhe2::trlwe_lvl1<aqtfhe2::params::CGGI16>::polynomial_mul_by_xai_minus_one_impl(aqtfhe2::detail::nd_array<unsigned int, 1024ul>&, unsigned int, aqtfhe2::detail::nd_array<unsigned int, 1024ul> const&)
static void polynomial_mul_by_xai_minus_one_impl(container &out, uint32_t a,
                                                     const container &poly)
    {
        if (a == 0) {
            out = poly;
            return;
        }

        constexpr uint32_t N = P::N();
        if (a < N) {
            for (size_t i = 0; i < a; i++)
                out[i] = -poly[i - a + N] - poly[i];
            for (size_t i = a; i < N; i++)
                out[i] = poly[i - a] - poly[i];
        }
        else {
            const uint32_t aa = a - N;
            for (size_t i = 0; i < aa; i++)
                out[i] = poly[i - aa + N] - poly[i];
            for (size_t i = aa; i < N; i++)
                out[i] = -poly[i - aa] - poly[i];
        }
    }

// Assembly:
movq %rdx, %rax
testl %esi, %esi
je 0x6400
cmpl $0x3ff, %esi            # imm = 0x3FF
ja 0x640d
movl %esi, %ecx
leaq (,%rcx,4), %rsi
movq %rax, %rdx
subq %rsi, %rdx
addq $0x1000, %rdx           # imm = 0x1000
xorl %esi, %esi
movl (%rdx,%rsi,4), %r8d
addl (%rax,%rsi,4), %r8d
negl %r8d
movl %r8d, (%rdi,%rsi,4)
incq %rsi
cmpq %rsi, %rcx
jne 0x63c4
movq $-0x400, %rdx           # imm = 0xFC00
movl 0x1000(%rax,%rdx,4), %esi
subl (%rax,%rcx,4), %esi
movl %esi, (%rdi,%rcx,4)
incq %rcx
incq %rdx
cmpq $0x400, %rcx            # imm = 0x400
jne 0x63e2
jmp 0x646d
movl $0x1000, %edx           # imm = 0x1000
movq %rax, %rsi
jmp 0x2140
addl $0xfffffc00, %esi       # imm = 0xFFFFFC00
je 0x6440
leaq (,%rsi,4), %rdx
movq %rax, %rcx
subq %rdx, %rcx
addq $0x1000, %rcx           # imm = 0x1000
xorl %edx, %edx
movl (%rcx,%rdx,4), %r8d
subl (%rax,%rdx,4), %r8d
movl %r8d, (%rdi,%rdx,4)
incq %rdx
cmpq %rdx, %rsi
jne 0x642c
cmpl $0x3ff, %esi            # imm = 0x3FF
ja 0x646d
movq $-0x400, %rcx           # imm = 0xFC00
movl 0x1000(%rax,%rcx,4), %edx
addl (%rax,%rsi,4), %edx
negl %edx
movl %edx, (%rdi,%rsi,4)
incq %rsi
incq %rcx
cmpq $0x400, %rsi            # imm = 0x400
jne 0x644f
retq
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/instruction.cpp
// Function: printStackElementType[abi:cxx11](StackElementType)
string printStackElementType(StackElementType type)
{
	switch(type)
	{
		case integer:
			return "i";
			break;
		case real:
			return "r";
			break;
		case character:
			return "c";
			break;
		case boolean:
			return "b";
			break;
		case address:
			return "a";
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movl %esi, %eax
leaq 0x1bc19(%rip), %rcx     # 0x23004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1f65e(%rip), %rsi     # 0x26a59
leaq 0x1f658(%rip), %rdx     # 0x26a5a
jmp 0x7442
leaq 0x1d265(%rip), %rsi     # 0x24670
leaq 0x1d25f(%rip), %rdx     # 0x24671
jmp 0x7442
leaq 0x1ec30(%rip), %rsi     # 0x2604b
leaq 0x1ec2a(%rip), %rdx     # 0x2604c
jmp 0x7442
leaq 0x1d38d(%rip), %rsi     # 0x247b8
leaq 0x1d387(%rip), %rdx     # 0x247b9
jmp 0x7442
leaq 0x1ede3(%rip), %rsi     # 0x2621e
leaq 0x1eddd(%rip), %rdx     # 0x2621f
movq %rbx, %rdi
callq 0x746c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/pop.cpp
// Function: Pop::execute(StackMachine*)
void Pop::execute(StackMachine *stack)
{
    // SP := SP - 1
    delete stack->fStore[stack->fSP];
    stack->fStore[stack->fSP] = 0;
    stack->fStore.pop_back();
    --stack->fSP;

    stack->fTime.count("pop");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movslq 0xb4(%rsi), %rax
movq 0x18(%rsi), %rcx
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0x758d
movq %r14, %rdi
callq 0x1a5cc
movl $0x8, %esi
movq %r14, %rdi
callq 0x6210
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
addq $-0x8, 0x20(%rbx)
decl %eax
movl %eax, 0xb4(%rbx)
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ba94(%rip), %rsi     # 0x23050
leaq 0x1ba90(%rip), %rdx     # 0x23053
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x746c
addq $0x78, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ce78
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x75f3
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x6210
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x7616
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x6210
movq %rbx, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/chk.cpp
// Function: Chk::execute(StackMachine*)
void Chk::execute(StackMachine *stack)
{
	StackInteger p;
	if(typeid(p) != typeid(*(stack->fStore[stack->fSP])))
	{
		throw ExecutionError("instruction chk: STORE[SP] does not contain element of type integer.");
	}
	
	if((stack->fStore[stack->fSP]->getValue() < fP) || (stack->fStore[stack->fSP]->getValue() > fQ))
	{
		throw ExecutionError("instruction chk: value out of range.");
	}
	
	// adding cost of this instruction
	stack->fTime.count("chk");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x1aca0
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0x87c5
movq (%r15), %r12
movq -0x8(%r12), %rax
leaq 0x2b485(%rip), %rcx     # 0x33af8
movq 0x8(%rcx), %rdi
movq 0x8(%rax), %rsi
cmpq %rsi, %rdi
je 0x8696
cmpb $0x2a, (%rdi)
je 0x8770
callq 0x6310
testl %eax, %eax
jne 0x8770
movq %r15, %rdi
callq *0x68(%r12)
cmpl 0x8(%r14), %eax
jl 0x8719
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
cmpl 0xc(%r14), %eax
jg 0x8719
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1ad84(%rip), %rsi     # 0x23452
leaq 0x1ad80(%rip), %rdx     # 0x23455
leaq -0x40(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1ce78
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x8703
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
leaq -0x50(%rbp), %rdi
callq 0x1acc4
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x6100
movq %rax, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x1acf7(%rip), %rsi     # 0x2342d
leaq 0x1ad14(%rip), %rdx     # 0x23451
leaq -0x40(%rbp), %rdi
callq 0x746c
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x1b418
xorl %r15d, %r15d
leaq 0x2a329(%rip), %rsi     # 0x32a88
leaq 0x12cd0(%rip), %rdx     # 0x1b436
movq %r14, %rdi
callq 0x63e0
jmp 0x87c5
movl $0x20, %edi
callq 0x6100
movq %rax, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x1ac5b(%rip), %rsi     # 0x233e8
leaq 0x1ac98(%rip), %rdx     # 0x2342c
leaq -0x40(%rbp), %rdi
callq 0x746c
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x1b418
xorl %r15d, %r15d
leaq 0x2a2d2(%rip), %rsi     # 0x32a88
leaq 0x12c79(%rip), %rdx     # 0x1b436
movq %r14, %rdi
callq 0x63e0
callq 0x6250
jmp 0x87ea
jmp 0x8804
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x881c
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0x881c
jmp 0x8819
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x880a
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0x880a
movq %rax, %rbx
movb $0x1, %r15b
testb %r15b, %r15b
je 0x881c
movq %r14, %rdi
callq 0x6170
jmp 0x881c
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x1acc4
movq %rbx, %rdi
callq 0x6410
nop