LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x38(%rsp)
movq $0x0, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0x5da0
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x5d62
movq $0x0, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x5dc0
movl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x5d4d
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x5dd0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x5d38
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x5de0
movl (%rax), %eax
movq 0x50(%rsp), %rcx
addq $0x1, %rcx
imulq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
callq 0x5dd0
movq (%rsp), %rdx
movq 0x38(%rsp), %rdi
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, %ecx
imulq %rcx, %rdx
movl $0x20, %ecx
subq %rdx, %rcx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movl %eax, 0x4c(%rsp)
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rcx
callq 0x5f50
movq %rax, 0x40(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x5fc0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl 0x4c(%rsp), %ecx
movq 0x40(%rsp), %rdi
callq 0x5e10
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0x5c48
jmp 0x5d3a
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0x5c1e
jmp 0x5d4f
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0x5bf4
addq $0x88, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
vmovsd %xmm0, 0x58(%rsp)
movl %ecx, 0x54(%rsp)
callq 0x4c00
movl %eax, %edx
leaq 0x4c(%rsp), %rdi
xorl %esi, %esi
callq 0x6030
vmovsd 0x58(%rsp), %xmm1
leaq 0x28(%rsp), %rdi
vpxor %xmm0, %xmm0, %xmm0
callq 0x6060
movl 0x54(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x4c30
callq 0x60b0
movl %eax, %ecx
movl 0x18(%rsp), %eax
addl %ecx, %eax
movl %eax, 0x1c(%rsp)
callq 0x55c0
movl %eax, %eax
movl %eax, %esi
leaq 0x70(%rsp), %rdi
callq 0x6100
movl 0x1c(%rsp), %ecx
movl %ecx, (%rax)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x55c0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x5f47
movq 0x68(%rsp), %rsi
leaq 0x4c(%rsp), %rdi
callq 0x6120
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x6100
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
movq 0x20(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x6100
movl (%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x5ad0
movq %rax, %rcx
movl 0x8(%rsp), %eax
imull (%rcx), %eax
movl %eax, 0xc(%rsp)
callq 0x55c0
movl %eax, %eax
movl %eax, %esi
leaq 0x70(%rsp), %rdi
callq 0x6100
movl 0xc(%rsp), %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x5e9e
addq $0x78, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x60a8, %rsp           # imm = 0x60A8
movq %rdi, 0x2018(%rsp)
movq %rdi, 0x2020(%rsp)
movq %rsi, 0x60a0(%rsp)
movq %rdx, 0x6098(%rsp)
vmovsd %xmm0, 0x6090(%rsp)
callq 0x4c00
movl %eax, %edx
leaq 0x6088(%rsp), %rdi
xorl %esi, %esi
callq 0x6030
vmovsd 0x6090(%rsp), %xmm1
leaq 0x6068(%rsp), %rdi
vpxor %xmm0, %xmm0, %xmm0
callq 0x6060
leaq 0x5068(%rsp), %rax
movq %rax, 0x5060(%rsp)
movq 0x5060(%rsp), %rdi
callq 0x3a40
movq %rax, 0x5058(%rsp)
movq 0x5060(%rsp), %rdi
callq 0x3a50
movq %rax, 0x5050(%rsp)
movq 0x5058(%rsp), %rax
cmpq 0x5050(%rsp), %rax
je 0x74f3
movq 0x5058(%rsp), %rax
movq %rax, 0x5048(%rsp)
movq 0x60a0(%rsp), %rsi
leaq 0x6088(%rsp), %rdi
callq 0x6120
movl %eax, %ecx
movq 0x5048(%rsp), %rax
movl %ecx, (%rax)
movq 0x5058(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x5058(%rsp)
jmp 0x749a
movq 0x6098(%rsp), %rdx
leaq 0x4048(%rsp), %rdi
leaq 0x5068(%rsp), %rsi
callq 0x87f0
leaq 0x4048(%rsp), %rax
movq %rax, 0x4040(%rsp)
movq 0x4040(%rsp), %rdi
callq 0x3a40
movq %rax, 0x4038(%rsp)
movq 0x4040(%rsp), %rdi
callq 0x3a50
movq %rax, 0x4030(%rsp)
movq 0x4038(%rsp), %rax
cmpq 0x4030(%rsp), %rax
je 0x75aa
movq 0x4038(%rsp), %rax
movq %rax, 0x4028(%rsp)
movq 0x60a0(%rsp), %rsi
leaq 0x6068(%rsp), %rdi
callq 0x4c30
callq 0x60b0
movl %eax, %ecx
movq 0x4028(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq 0x4038(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x4038(%rsp)
jmp 0x754a
leaq 0x3028(%rsp), %rdi
leaq 0x5068(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2160
leaq 0x2028(%rsp), %rdi
leaq 0x4048(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2160
movq %rsp, %rdi
movq %rdi, 0x2008(%rsp)
movl $0x200, %ecx            # imm = 0x200
movq %rcx, 0x2010(%rsp)
leaq 0x3028(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x2008(%rsp), %rdi
movq 0x2010(%rsp), %rcx
addq $0x1000, %rdi           # imm = 0x1000
leaq 0x2028(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x2018(%rsp), %rdi
callq 0x8900
movq 0x2020(%rsp), %rax
addq $0x60a8, %rsp           # imm = 0x60A8
retq
// File: ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: aqtfhe2::detail::fft_processor<1024ul>::twist_ifft_lvl1(aqtfhe2::detail::array_slice<double, 1024ul>, aqtfhe2::detail::const_array_slice<unsigned int, 1024ul>)
void twist_ifft_lvl1(array_slice<double, N> out,
                         const_array_slice<uint32_t, N> a)
    {
        nd_array<double, N> tmp;
        for (size_t i = 0; i < N; i++)
            tmp[i] = static_cast<int32_t>(a[i]);
        ifft(tmp.slice());
        for (size_t i = 0; i < N; i++)
            out[i] = tmp[i];
    }

// Assembly:
subq $0x2048, %rsp           # imm = 0x2048
movq %rsi, 0x2040(%rsp)
movq %rdx, 0x2038(%rsp)
movq %rdi, 0x2030(%rsp)
movq 0x2030(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x28(%rsp)
cmpq $0x400, 0x28(%rsp)      # imm = 0x400
jae 0x7bf5
movq 0x28(%rsp), %rsi
leaq 0x2038(%rsp), %rdi
callq 0x9eb0
vcvtsi2sdl (%rax), %xmm0, %xmm0
vmovsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x9070
vmovsd 0x8(%rsp), %xmm0
vmovsd %xmm0, (%rax)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x7ba5
leaq 0x30(%rsp), %rdi
callq 0x8c00
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x9ed0
movq $0x0, 0x18(%rsp)
cmpq $0x400, 0x18(%rsp)      # imm = 0x400
jae 0x7c6a
movq 0x18(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x9070
vmovsd (%rax), %xmm0
vmovsd %xmm0, (%rsp)
movq 0x18(%rsp), %rsi
leaq 0x2040(%rsp), %rdi
callq 0xa680
vmovsd (%rsp), %xmm0
vmovsd %xmm0, (%rax)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x7c1c
addq $0x2048, %rsp           # imm = 0x2048
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x6038, %rsp           # imm = 0x6038
movq %rdi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rsi, 0x6030(%rsp)
movq %rdx, 0x6028(%rsp)
movb %fs:-0x20028, %al
cmpb $0x0, %al
jne 0x883b
movq %fs:0x0, %rax
leaq -0x28028(%rax), %rdi
callq 0x76a0
movb $0x1, %fs:-0x20028
movq %fs:0x0, %rax
leaq -0x28028(%rax), %rsi
movq 0x6030(%rsp), %rdx
leaq 0x4028(%rsp), %rdi
callq 0x8950
movq %fs:0x0, %rax
leaq -0x28028(%rax), %rsi
movq 0x6028(%rsp), %rdx
leaq 0x2028(%rsp), %rdi
callq 0x8950
movq %fs:0x0, %rax
leaq -0x28028(%rax), %rax
movq %rax, (%rsp)
leaq 0x4028(%rsp), %rdi
callq 0x8ba0
movq %rax, 0x20(%rsp)
leaq 0x2028(%rsp), %rdi
callq 0x8ba0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x8a10
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x89b0
movq 0x10(%rsp), %rax
addq $0x6038, %rsp           # imm = 0x6038
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: aqtfhe2::detail::nd_array<double, 1024ul> aqtfhe2::detail::mul_in_fd<1024ul>(aqtfhe2::detail::const_array_slice<double, 1024ul>, aqtfhe2::detail::const_array_slice<double, 1024ul>)
inline nd_array<double, N> mul_in_fd(const_array_slice<double, N> a,
                                     const_array_slice<double, N> b)
{
    nd_array<double, N> ret;
    for (size_t i = 0; i < N / 2; i++) {
        double aimbim = a[i + N / 2] * b[i + N / 2];
        double arebim = a[i] * b[i + N / 2];
        ret[i] = a[i] * b[i] - aimbim;
        ret[i + N / 2] = a[i + N / 2] * b[i] + arebim;
    }
    return ret;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, 0x38(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq $0x0, 0x50(%rsp)
cmpq $0x200, 0x50(%rsp)      # imm = 0x200
jae 0x8b92
movq 0x50(%rsp), %rsi
addq $0x200, %rsi            # imm = 0x200
leaq 0x60(%rsp), %rdi
callq 0x9050
vmovsd (%rax), %xmm0
vmovsd %xmm0, (%rsp)
movq 0x50(%rsp), %rsi
addq $0x200, %rsi            # imm = 0x200
leaq 0x58(%rsp), %rdi
callq 0x9050
vmovsd (%rsp), %xmm0
vmulsd (%rax), %xmm0, %xmm0
vmovsd %xmm0, 0x48(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x9050
vmovsd (%rax), %xmm0
vmovsd %xmm0, 0x8(%rsp)
movq 0x50(%rsp), %rsi
addq $0x200, %rsi            # imm = 0x200
leaq 0x58(%rsp), %rdi
callq 0x9050
vmovsd 0x8(%rsp), %xmm0
vmulsd (%rax), %xmm0, %xmm0
vmovsd %xmm0, 0x40(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x9050
vmovsd (%rax), %xmm0
vmovsd %xmm0, 0x10(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x9050
vmovsd 0x10(%rsp), %xmm0
movq 0x30(%rsp), %rdi
vmulsd (%rax), %xmm0, %xmm0
vsubsd 0x48(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x18(%rsp)
movq 0x50(%rsp), %rsi
callq 0x9070
vmovsd 0x18(%rsp), %xmm0
vmovsd %xmm0, (%rax)
movq 0x50(%rsp), %rsi
addq $0x200, %rsi            # imm = 0x200
leaq 0x60(%rsp), %rdi
callq 0x9050
vmovsd (%rax), %xmm0
vmovsd %xmm0, 0x20(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x9050
vmovsd 0x20(%rsp), %xmm0
movq 0x30(%rsp), %rdi
vmulsd (%rax), %xmm0, %xmm0
vaddsd 0x40(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x28(%rsp)
movq 0x50(%rsp), %rsi
addq $0x200, %rsi            # imm = 0x200
callq 0x9070
vmovsd 0x28(%rsp), %xmm0
vmovsd %xmm0, (%rax)
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0x8a31
movq 0x38(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x2048, %rsp           # imm = 0x2048
movq %rsi, 0x2040(%rsp)
movq %rdx, 0x2038(%rsp)
movq %rdi, 0x2030(%rsp)
movq 0x2030(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x28(%rsp)
cmpq $0x400, 0x28(%rsp)      # imm = 0x400
jae 0x8fcd
movq 0x28(%rsp), %rsi
leaq 0x2038(%rsp), %rdi
callq 0x9050
vmovsd 0xd0fe(%rip), %xmm0     # 0x16098
vmulsd (%rax), %xmm0, %xmm0
vmovsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x9070
vmovsd 0x8(%rsp), %xmm0
vmovsd %xmm0, (%rax)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x8f75
leaq 0x30(%rsp), %rdi
callq 0x8c00
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x90a0
movq $0x0, 0x18(%rsp)
cmpq $0x400, 0x18(%rsp)      # imm = 0x400
jae 0x903f
movq 0x18(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x9070
vcvttsd2si (%rax), %rax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rsi
leaq 0x2040(%rsp), %rdi
callq 0x9890
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x8ff4
addq $0x2048, %rsp           # imm = 0x2048
retq
nopw (%rax,%rax)
// File: ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: aqtfhe2::detail::accurate_cos(int, int)
inline double accurate_cos(int32_t i, int32_t n)
{
    i = ((i % n) + n) % n;
    const double nd = n;
    const double pi = 3.1415926535897932384626433832795028;

    if (i >= 3 * n / 4)
        return std::cos(2. * pi * (n - i) / nd);
    if (i >= 2 * n / 4)
        return -std::cos(2. * pi * (i - n / 2) / nd);
    if (i >= 1 * n / 4)
        return -std::cos(2. * pi * (n / 2 - i) / nd);
    return std::cos(2. * pi * (i) / nd);
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x2c(%rsp)
movl %esi, 0x28(%rsp)
movl 0x2c(%rsp), %eax
cltd
idivl 0x28(%rsp)
movl %edx, %eax
addl 0x28(%rsp), %eax
cltd
idivl 0x28(%rsp)
movl %edx, 0x2c(%rsp)
vcvtsi2sdl 0x28(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x20(%rsp)
vmovsd 0xc518(%rip), %xmm0     # 0x160a0
vmovsd %xmm0, 0x18(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
imull $0x3, 0x28(%rsp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jl 0x9bdb
movl 0x28(%rsp), %eax
subl 0x2c(%rsp), %eax
vcvtsi2sd %eax, %xmm0, %xmm1
vmovsd 0xc4e7(%rip), %xmm0     # 0x160a8
vmulsd %xmm1, %xmm0, %xmm0
vdivsd 0x20(%rsp), %xmm0, %xmm0
callq 0x22d0
vmovsd %xmm0, 0x30(%rsp)
jmp 0x9ce2
movl 0x2c(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x28(%rsp), %eax
shll %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jl 0x9c54
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x28(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0xc(%rsp), %eax
subl %ecx, %eax
vcvtsi2sd %eax, %xmm0, %xmm1
vmovsd 0xc485(%rip), %xmm0     # 0x160a8
vmulsd %xmm1, %xmm0, %xmm0
vdivsd 0x20(%rsp), %xmm0, %xmm0
callq 0x22d0
vmovq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
vmovq %rax, %xmm0
vmovsd %xmm0, 0x30(%rsp)
jmp 0x9ce2
movl 0x2c(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x28(%rsp), %eax
shll $0x0, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jl 0x9cbf
movl 0x28(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
subl 0x2c(%rsp), %eax
vcvtsi2sd %eax, %xmm0, %xmm1
vmovsd 0xc417(%rip), %xmm0     # 0x160a8
vmulsd %xmm1, %xmm0, %xmm0
vdivsd 0x20(%rsp), %xmm0, %xmm0
callq 0x22d0
vmovq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
vmovq %rax, %xmm0
vmovsd %xmm0, 0x30(%rsp)
jmp 0x9ce2
vcvtsi2sdl 0x2c(%rsp), %xmm0, %xmm1
vmovsd 0xc3db(%rip), %xmm0     # 0x160a8
vmulsd %xmm1, %xmm0, %xmm0
vdivsd 0x20(%rsp), %xmm0, %xmm0
callq 0x22d0
vmovsd %xmm0, 0x30(%rsp)
vmovsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: aqtfhe2::detail::accurate_sin(int, int)
inline double accurate_sin(int32_t i, int32_t n)
{
    i = ((i % n) + n) % n;
    const double nd = n;
    const double pi = 3.1415926535897932384626433832795028;

    if (i >= 3 * n / 4)
        return -sin(2. * pi * (n - i) / nd);
    if (i >= 2 * n / 4)
        return -sin(2. * pi * (i - n / 2) / nd);
    if (i >= 1 * n / 4)
        return sin(2. * pi * (n / 2 - i) / nd);
    return sin(2. * pi * (i) / nd);
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x2c(%rsp)
movl %esi, 0x28(%rsp)
movl 0x2c(%rsp), %eax
cltd
idivl 0x28(%rsp)
movl %edx, %eax
addl 0x28(%rsp), %eax
cltd
idivl 0x28(%rsp)
movl %edx, 0x2c(%rsp)
vcvtsi2sdl 0x28(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x20(%rsp)
vmovsd 0xc378(%rip), %xmm0     # 0x160a0
vmovsd %xmm0, 0x18(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
imull $0x3, 0x28(%rsp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jl 0x9d92
movl 0x28(%rsp), %eax
subl 0x2c(%rsp), %eax
vcvtsi2sd %eax, %xmm0, %xmm1
vmovsd 0xc347(%rip), %xmm0     # 0x160a8
vmulsd %xmm1, %xmm0, %xmm0
vdivsd 0x20(%rsp), %xmm0, %xmm0
callq 0x2050
vmovq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
vmovq %rax, %xmm0
vmovsd %xmm0, 0x30(%rsp)
jmp 0x9e7f
movl 0x2c(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x28(%rsp), %eax
shll %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jl 0x9e08
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x28(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0xc(%rsp), %eax
subl %ecx, %eax
vcvtsi2sd %eax, %xmm0, %xmm1
vmovsd 0xc2ce(%rip), %xmm0     # 0x160a8
vmulsd %xmm1, %xmm0, %xmm0
vdivsd 0x20(%rsp), %xmm0, %xmm0
callq 0x2050
vmovq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
vmovq %rax, %xmm0
vmovsd %xmm0, 0x30(%rsp)
jmp 0x9e7f
movl 0x2c(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x28(%rsp), %eax
shll $0x0, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jl 0x9e5c
movl 0x28(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
subl 0x2c(%rsp), %eax
vcvtsi2sd %eax, %xmm0, %xmm1
vmovsd 0xc263(%rip), %xmm0     # 0x160a8
vmulsd %xmm1, %xmm0, %xmm0
vdivsd 0x20(%rsp), %xmm0, %xmm0
callq 0x2050
vmovsd %xmm0, 0x30(%rsp)
jmp 0x9e7f
vcvtsi2sdl 0x2c(%rsp), %xmm0, %xmm1
vmovsd 0xc23e(%rip), %xmm0     # 0x160a8
vmulsd %xmm1, %xmm0, %xmm0
vdivsd 0x20(%rsp), %xmm0, %xmm0
callq 0x2050
vmovsd %xmm0, 0x30(%rsp)
vmovsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x1fa8, %rsp           # imm = 0x1FA8
movq %rdi, 0x7e8(%rsp)
movq %rdi, 0x7f0(%rsp)
movq %rsi, 0x1fa0(%rsp)
movq %rdx, 0x1f98(%rsp)
movq %rcx, 0x1f90(%rsp)
movq %r8, 0x1f88(%rsp)
movq 0x1fa0(%rsp), %rax
movq %rax, 0x7f8(%rsp)
movq $0x0, 0x17a8(%rsp)
movq 0x17a8(%rsp), %rax
movq %rax, 0x7e0(%rsp)
callq 0x55c0
movl %eax, %ecx
movq 0x7e0(%rsp), %rax
movl %ecx, %ecx
cmpq %rcx, %rax
ja 0xcb1f
movq 0x7f8(%rsp), %rdi
movq 0x17a8(%rsp), %rsi
callq 0xcbf0
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, 0x7d8(%rsp)
movq 0x1f98(%rsp), %rdi
movq 0x17a8(%rsp), %rsi
callq 0xcbf0
movq %rax, %rcx
movl 0x7d8(%rsp), %eax
subl (%rcx), %eax
movl %eax, 0x7dc(%rsp)
movq 0x17a8(%rsp), %rsi
leaq 0x17b4(%rsp), %rdi
callq 0xcc20
movl 0x7dc(%rsp), %ecx
movl %ecx, (%rax)
movq 0x17a8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x17a8(%rsp)
jmp 0xca73
callq 0x55c0
movl %eax, %esi
leaq 0x17b4(%rsp), %rdi
callq 0xcc50
movl (%rax), %ecx
addl $0x20000000, %ecx       # imm = 0x20000000
movl %ecx, (%rax)
leaq 0x800(%rsp), %rdi
leaq 0x17b4(%rsp), %rsi
movl $0x7d4, %edx            # imm = 0x7D4
callq 0x2160
movq %rsp, %rax
movl $0xfa, %ecx
leaq 0x800(%rsp), %rsi
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0xfd0(%rsp), %ecx
movl %ecx, 0x7d0(%rax)
leaq 0xfd4(%rsp), %rdi
callq 0xc9b0
movq 0x7e8(%rsp), %rdi
movq 0x1f90(%rsp), %rdx
movq 0x1f88(%rsp), %rcx
leaq 0xfd4(%rsp), %rsi
callq 0xcc80
movq 0x7f0(%rsp), %rax
addq $0x1fa8, %rsp           # imm = 0x1FA8
retq
nopl (%rax)
// File: ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: aqtfhe2::tlwe_lvl0<aqtfhe2::params::CGGI16>::gate_bootstrapping_to_lvl1(std::vector<aqtfhe2::trgswfft_lvl1<aqtfhe2::params::CGGI16>, std::allocator<aqtfhe2::trgswfft_lvl1<aqtfhe2::params::CGGI16>>> const&) const
tlwe_lvl1<P> gate_bootstrapping_to_lvl1(
        const std::vector<trgswfft_lvl1<P>> &bkfftlvl01) const
    {
        constexpr uint32_t n = P::n(), N = P::N();

        uint32_t bara =
            2 * N - detail::mod_switch_from_torus32(2 * N, data_[n]);
        trlwe_lvl1<P> acc = rotated_test_vector(bara), tmp0, tmp1;
        for (size_t i = 0; i < n; i++) {
            bara = detail::mod_switch_from_torus32(2 * N, data_[i]);
            if (bara == 0)
                continue;
            acc.polynomial_mul_by_xai_minus_one(/* out */ tmp0, bara);
            tmp0.trgswfft_external_product(/* out */ tmp1, bkfftlvl01[i]);
            for (size_t i = 0; i < N; i++) {
                acc.poly0_[i] += tmp1.poly0_[i];
                acc.poly1_[i] += tmp1.poly1_[i];
            }
        }

        return acc.sample_extract_index(0);
    }

// Assembly:
subq $0x6058, %rsp           # imm = 0x6058
movq %rdi, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movq %rsi, 0x6050(%rsp)
movq %rdx, 0x6048(%rsp)
movq 0x6050(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movl $0x1f4, 0x6044(%rsp) # imm = 0x1F4
movl $0x400, 0x6040(%rsp) # imm = 0x400
movl $0x1f4, %esi            # imm = 0x1F4
callq 0xd290
movl (%rax), %esi
movl $0x800, %edi            # imm = 0x800
callq 0xd230
movq 0x20(%rsp), %rsi
movl %eax, %ecx
movl $0x800, %eax            # imm = 0x800
subl %ecx, %eax
movl %eax, 0x603c(%rsp)
movl 0x603c(%rsp), %edx
leaq 0x403c(%rsp), %rdi
callq 0xd2c0
leaq 0x203c(%rsp), %rdi
callq 0xd4e0
leaq 0x3c(%rsp), %rdi
callq 0xd4e0
movq $0x0, 0x30(%rsp)
cmpq $0x1f4, 0x30(%rsp)      # imm = 0x1F4
jae 0xcf3e
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xcbf0
movl (%rax), %esi
movl $0x800, %edi            # imm = 0x800
callq 0xd230
movl %eax, 0x603c(%rsp)
cmpl $0x0, 0x603c(%rsp)
jne 0xce53
jmp 0xcf2b
movl 0x603c(%rsp), %edx
leaq 0x403c(%rsp), %rdi
leaq 0x203c(%rsp), %rsi
callq 0xd4f0
movq 0x6048(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xdb80
movq %rax, %rdx
leaq 0x203c(%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0xd540
movq $0x0, 0x28(%rsp)
cmpq $0x400, 0x28(%rsp)      # imm = 0x400
jae 0xcf29
leaq 0x3c(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xdba0
movl (%rax), %eax
movl %eax, 0x8(%rsp)
leaq 0x403c(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xdba0
movl 0x8(%rsp), %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
leaq 0x3c(%rsp), %rdi
addq $0x1000, %rdi           # imm = 0x1000
movq 0x28(%rsp), %rsi
callq 0xdba0
movl (%rax), %eax
movl %eax, 0xc(%rsp)
leaq 0x403c(%rsp), %rdi
addq $0x1000, %rdi           # imm = 0x1000
movq 0x28(%rsp), %rsi
callq 0xdba0
movl 0xc(%rsp), %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0xce9f
jmp 0xcf2b
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0xce13
movq 0x10(%rsp), %rdi
leaq 0x403c(%rsp), %rsi
xorl %edx, %edx
callq 0xdbd0
movq 0x18(%rsp), %rax
addq $0x6058, %rsp           # imm = 0x6058
retq
nop
// File: ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: aqtfhe2::detail::mod_switch_from_torus32(unsigned int, unsigned int)
inline uint32_t mod_switch_from_torus32(uint32_t Msize, uint32_t phase)
{
    uint64_t interv = ((1UL << 63) / Msize) * 2;  // width of each intervall
    uint64_t half_interval = interv / 2;  // begin of the first intervall
    uint64_t phase64 = (static_cast<uint64_t>(phase) << 32) + half_interval;
    // floor to the nearest multiples of interv
    return static_cast<uint32_t>(phase64 / interv);
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl -0x4(%rsp), %eax
movl %eax, %ecx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
xorl %edx, %edx
divq %rcx
shlq %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
shrq %rax
movq %rax, -0x18(%rsp)
movl -0x8(%rsp), %eax
shlq $0x20, %rax
addq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rsp)
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x5048, %rsp           # imm = 0x5048
movq %rdi, 0x2010(%rsp)
movq %rdi, 0x2018(%rsp)
movq %rsi, 0x5040(%rsp)
movl %edx, 0x503c(%rsp)
movl $0x400, 0x5038(%rsp) # imm = 0x400
movl $0x20000000, 0x5034(%rsp) # imm = 0x20000000
cmpl $0x400, 0x503c(%rsp) # imm = 0x400
jae 0xd3a2
movl $0x0, 0x4030(%rsp)
movl 0x4030(%rsp), %eax
cmpl 0x503c(%rsp), %eax
jae 0xd355
movl 0x4030(%rsp), %esi
leaq 0x4034(%rsp), %rdi
callq 0xddc0
movl $0xe0000000, (%rax)     # imm = 0xE0000000
movl 0x4030(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4030(%rsp)
jmp 0xd318
movl 0x503c(%rsp), %eax
movl %eax, 0x402c(%rsp)
cmpl $0x400, 0x402c(%rsp) # imm = 0x400
jae 0xd39d
movl 0x402c(%rsp), %esi
leaq 0x4034(%rsp), %rdi
callq 0xddc0
movl $0x20000000, (%rax)     # imm = 0x20000000
movl 0x402c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x402c(%rsp)
jmp 0xd363
jmp 0xd447
movl 0x503c(%rsp), %eax
subl $0x400, %eax            # imm = 0x400
movl %eax, 0x4028(%rsp)
movl $0x0, 0x4024(%rsp)
movl 0x4024(%rsp), %eax
cmpl 0x4028(%rsp), %eax
jae 0xd3fd
movl 0x4024(%rsp), %esi
leaq 0x4034(%rsp), %rdi
callq 0xddc0
movl $0x20000000, (%rax)     # imm = 0x20000000
movl 0x4024(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4024(%rsp)
jmp 0xd3c0
movl 0x4028(%rsp), %eax
movl %eax, 0x4020(%rsp)
cmpl $0x400, 0x4020(%rsp) # imm = 0x400
jae 0xd445
movl 0x4020(%rsp), %esi
leaq 0x4034(%rsp), %rdi
callq 0xddc0
movl $0xe0000000, (%rax)     # imm = 0xE0000000
movl 0x4020(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4020(%rsp)
jmp 0xd40b
jmp 0xd447
leaq 0x3020(%rsp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20d0
leaq 0x2020(%rsp), %rdi
leaq 0x4034(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2160
movq %rsp, %rdi
movq %rdi, 0x2000(%rsp)
movl $0x200, %ecx            # imm = 0x200
movq %rcx, 0x2008(%rsp)
leaq 0x3020(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x2000(%rsp), %rdi
movq 0x2008(%rsp), %rcx
addq $0x1000, %rdi           # imm = 0x1000
leaq 0x2020(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x2010(%rsp), %rdi
callq 0x8900
movq 0x2018(%rsp), %rax
addq $0x5048, %rsp           # imm = 0x5048
retq
nopw (%rax,%rax)
// File: ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: aqtfhe2::trlwe_lvl1<aqtfhe2::params::CGGI16>::sample_extract_index(unsigned int) const
tlwe_lvl1<P> sample_extract_index(uint32_t index) const
    {
        typename tlwe_lvl1<P>::container ret;
        for (size_t i = 0; i <= index; i++)
            ret[i] = poly0_[index - i];
        for (size_t i = index + 1; i < P::N(); i++)
            ret[i] = -poly0_[P::N() + index - i];
        ret[P::N()] = poly1_[index];

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

// Assembly:
subq $0x3068, %rsp           # imm = 0x3068
movq %rdi, 0x1028(%rsp)
movq %rdi, 0x1030(%rsp)
movq %rsi, 0x3060(%rsp)
movl %edx, 0x305c(%rsp)
movq 0x3060(%rsp), %rax
movq %rax, 0x1038(%rsp)
movq $0x0, 0x2050(%rsp)
movq 0x2050(%rsp), %rax
movl 0x305c(%rsp), %ecx
cmpq %rcx, %rax
ja 0xdc81
movq 0x1038(%rsp), %rdi
movl 0x305c(%rsp), %eax
movl %eax, %esi
subq 0x2050(%rsp), %rsi
callq 0x5de0
movl (%rax), %eax
movl %eax, 0x1024(%rsp)
movq 0x2050(%rsp), %rsi
leaq 0x2058(%rsp), %rdi
callq 0xead0
movl 0x1024(%rsp), %ecx
movl %ecx, (%rax)
movq 0x2050(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x2050(%rsp)
jmp 0xdc12
movl 0x305c(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movq %rax, 0x2048(%rsp)
movq 0x2048(%rsp), %rax
movq %rax, 0x1018(%rsp)
callq 0x5da0
movl %eax, %ecx
movq 0x1018(%rsp), %rax
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0xdd25
callq 0x5da0
movq 0x1038(%rsp), %rdi
addl 0x305c(%rsp), %eax
movl %eax, %eax
movl %eax, %esi
subq 0x2048(%rsp), %rsi
callq 0x5de0
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, 0x1014(%rsp)
movq 0x2048(%rsp), %rsi
leaq 0x2058(%rsp), %rdi
callq 0xead0
movl 0x1014(%rsp), %ecx
movl %ecx, (%rax)
movq 0x2048(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x2048(%rsp)
jmp 0xdc95
movq 0x1038(%rsp), %rdi
addq $0x1000, %rdi           # imm = 0x1000
movl 0x305c(%rsp), %esi
callq 0xeb00
movl (%rax), %eax
movl %eax, 0x1010(%rsp)
callq 0x5da0
movl %eax, %esi
leaq 0x2058(%rsp), %rdi
callq 0xeb30
movl 0x1010(%rsp), %ecx
movl %ecx, (%rax)
leaq 0x1040(%rsp), %rdi
leaq 0x2058(%rsp), %rsi
movl $0x1004, %edx           # imm = 0x1004
callq 0x2160
movq %rsp, %rax
movl $0x200, %ecx            # imm = 0x200
leaq 0x1040(%rsp), %rsi
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq 0x1028(%rsp), %rdi
movl 0x2040(%rsp), %ecx
movl %ecx, 0x1000(%rax)
callq 0xeb60
movq 0x1030(%rsp), %rax
addq $0x3068, %rsp           # imm = 0x3068
retq
// File: ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: void aqtfhe2::detail::fma_in_fd<1024ul>(aqtfhe2::detail::array_slice<double, 1024ul>, aqtfhe2::detail::const_array_slice<double, 1024ul>, aqtfhe2::detail::const_array_slice<double, 1024ul>)
inline void fma_in_fd(array_slice<double, N> res,
                      const_array_slice<double, N> a,
                      const_array_slice<double, N> b)
{
    for (size_t i = 0; i < N / 2; i++) {
        res[i] = a[i + N / 2] * b[i + N / 2] - res[i];
        res[i] = a[i] * b[i] - res[i];
        res[i + N / 2] += a[i] * b[i + N / 2];
        res[i + N / 2] += a[i + N / 2] * b[i];
    }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq $0x0, 0x58(%rsp)
cmpq $0x200, 0x58(%rsp)      # imm = 0x200
jae 0xe442
movq 0x58(%rsp), %rsi
addq $0x200, %rsi            # imm = 0x200
leaq 0x68(%rsp), %rdi
callq 0x9050
vmovsd (%rax), %xmm0
vmovsd %xmm0, 0x8(%rsp)
movq 0x58(%rsp), %rsi
addq $0x200, %rsi            # imm = 0x200
leaq 0x60(%rsp), %rdi
callq 0x9050
vmovsd 0x8(%rsp), %xmm0
vmulsd (%rax), %xmm0, %xmm0
vmovsd %xmm0, 0x10(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0xa680
vmovsd 0x10(%rsp), %xmm0
vsubsd (%rax), %xmm0, %xmm0
vmovsd %xmm0, 0x18(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0xa680
vmovsd 0x18(%rsp), %xmm0
vmovsd %xmm0, (%rax)
movq 0x58(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x9050
vmovsd (%rax), %xmm0
vmovsd %xmm0, 0x20(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x9050
vmovsd 0x20(%rsp), %xmm0
vmulsd (%rax), %xmm0, %xmm0
vmovsd %xmm0, 0x28(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0xa680
vmovsd 0x28(%rsp), %xmm0
vsubsd (%rax), %xmm0, %xmm0
vmovsd %xmm0, 0x30(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0xa680
vmovsd 0x30(%rsp), %xmm0
vmovsd %xmm0, (%rax)
movq 0x58(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x9050
vmovsd (%rax), %xmm0
vmovsd %xmm0, 0x38(%rsp)
movq 0x58(%rsp), %rsi
addq $0x200, %rsi            # imm = 0x200
leaq 0x60(%rsp), %rdi
callq 0x9050
vmovsd 0x38(%rsp), %xmm0
vmulsd (%rax), %xmm0, %xmm0
vmovsd %xmm0, 0x40(%rsp)
movq 0x58(%rsp), %rsi
addq $0x200, %rsi            # imm = 0x200
leaq 0x70(%rsp), %rdi
callq 0xa680
vmovsd 0x40(%rsp), %xmm0
vaddsd (%rax), %xmm0, %xmm0
vmovsd %xmm0, (%rax)
movq 0x58(%rsp), %rsi
addq $0x200, %rsi            # imm = 0x200
leaq 0x68(%rsp), %rdi
callq 0x9050
vmovsd (%rax), %xmm0
vmovsd %xmm0, 0x48(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x9050
vmovsd 0x48(%rsp), %xmm0
vmulsd (%rax), %xmm0, %xmm0
vmovsd %xmm0, 0x50(%rsp)
movq 0x58(%rsp), %rsi
addq $0x200, %rsi            # imm = 0x200
leaq 0x70(%rsp), %rdi
callq 0xa680
vmovsd 0x50(%rsp), %xmm0
vaddsd (%rax), %xmm0, %xmm0
vmovsd %xmm0, (%rax)
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0xe26c
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x4, %rax
ja 0x88fa
movq -0x28(%rbp), %rax
leaq 0x2e87e(%rip), %rcx     # 0x37004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0xd(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x74f0
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x31a73(%rip), %rsi     # 0x3a21e
callq 0x8940
jmp 0x87b2
leaq -0xd(%rbp), %rdi
callq 0x72e0
jmp 0x88fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xd(%rbp), %rdi
callq 0x72e0
jmp 0x8906
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x74f0
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x3224d(%rip), %rsi     # 0x3aa43
callq 0x8940
jmp 0x87fd
leaq -0x1d(%rbp), %rdi
callq 0x72e0
jmp 0x88fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x72e0
jmp 0x8906
leaq -0x1e(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x74f0
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x2ff77(%rip), %rsi     # 0x387b8
callq 0x8940
jmp 0x8848
leaq -0x1e(%rbp), %rdi
callq 0x72e0
jmp 0x88fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1e(%rbp), %rdi
callq 0x72e0
jmp 0x8906
leaq -0x1f(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x74f0
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x317bf(%rip), %rsi     # 0x3a04b
callq 0x8940
jmp 0x8893
leaq -0x1f(%rbp), %rdi
callq 0x72e0
jmp 0x88fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1f(%rbp), %rdi
callq 0x72e0
jmp 0x8906
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x74f0
movq -0x38(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x2fd9f(%rip), %rsi     # 0x38670
callq 0x8940
jmp 0x88d8
leaq -0x20(%rbp), %rdi
callq 0x72e0
jmp 0x88fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x72e0
jmp 0x8906
ud2
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x74e0
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rax
movslq 0xb4(%rax), %rsi
callq 0x8e70
movq (%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x8d6c
movq -0x50(%rbp), %rdi
callq 0x26ca0
movq -0x50(%rbp), %rdi
movl $0x8, %esi
callq 0x7280
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movslq 0xb4(%rax), %rsi
callq 0x8e70
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x8e90
movq -0x10(%rbp), %rax
movl 0xb4(%rax), %ecx
decl %ecx
movl %ecx, 0xb4(%rax)
movq -0x10(%rbp), %rax
addq $0x78, %rax
movq %rax, -0x60(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x74f0
movq -0x58(%rbp), %rdx
leaq 0x2e283(%rip), %rsi     # 0x37050
leaq -0x30(%rbp), %rdi
callq 0x8940
jmp 0x8dd8
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2c4d0
jmp 0x8de7
leaq -0x30(%rbp), %rdi
callq 0x7170
leaq -0x31(%rbp), %rdi
callq 0x72e0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x8e22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7170
leaq -0x31(%rbp), %rdi
callq 0x72e0
movq -0x40(%rbp), %rdi
callq 0x74e0
nopw %cs:(%rax,%rax)
// File: zerolfx[P]P-Machine/cup.cpp
// Function: Cup::execute(StackMachine*)
void Cup::execute(StackMachine *stack)
{	
	stack->fMP = stack->fSP - (fP + 4);
	
	stack->fStore[stack->fMP + 4] = new StackAddress(stack->fPC);
	
	stack->fPC = stack->fLabelCenter.getAddress(fQ);
	
	// adding cost of this instruction
	stack->fTime.count("cup");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x58(%rbp)
movq -0x10(%rbp), %rax
movl 0xb4(%rax), %ecx
movl 0x8(%rdx), %edx
subl %edx, %ecx
addl $-0x4, %ecx
movl %ecx, 0xc0(%rax)
movl $0x10, %edi
callq 0x7270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movl 0xb0(%rax), %esi
callq 0x26800
jmp 0xad45
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movl 0xc0(%rax), %eax
addl $0x4, %eax
movslq %eax, %rsi
callq 0x8e70
movq -0x50(%rbp), %rcx
movq -0x58(%rbp), %rsi
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
addq $0x10, %rsi
callq 0x28510
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xb0(%rax)
movq -0x10(%rbp), %rax
addq $0x78, %rax
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x74f0
movq -0x60(%rbp), %rdx
leaq 0x2c6b3(%rip), %rsi     # 0x37460
leaq -0x40(%rbp), %rdi
callq 0x8940
jmp 0xadb8
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2c4d0
jmp 0xadc7
leaq -0x40(%rbp), %rdi
callq 0x7170
leaq -0x41(%rbp), %rdi
callq 0x72e0
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x7280
jmp 0xae27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xae1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7170
leaq -0x41(%rbp), %rdi
callq 0x72e0
movq -0x18(%rbp), %rdi
callq 0x74e0
// File: zerolfx[P]P-Machine/ent.cpp
// Function: Ent::execute(StackMachine*)
void Ent::execute(StackMachine *stack)
{	
	int oldSP = stack->fSP;
	
	// q data-area size
	stack->fSP = stack->fMP + fQ - 1;
	
	for(int i = oldSP + 1; i <= stack->fSP; ++i)
	{
		stack->fStore.push_back(new StackElement());
	}
	
	// p max depth of local stack
	stack->fEP = stack->fSP + fP;
	
	// adding cost of this instruction
	stack->fTime.count("ent");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rcx
movl 0xb4(%rcx), %ecx
movl %ecx, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movl 0xc0(%rcx), %ecx
addl 0xc(%rax), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xb4(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xb4(%rcx), %eax
jg 0xdef0
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x70(%rbp)
movl $0x8, %edi
callq 0x7270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0x26c80
jmp 0xdeb1
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0xd2a0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xde7b
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x8, %esi
callq 0x7280
jmp 0xdf8e
movq -0x60(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0xb4(%rax), %ecx
movl 0x8(%rdx), %edx
addl %edx, %ecx
movl %ecx, 0xbc(%rax)
movq -0x10(%rbp), %rax
addq $0x78, %rax
movq %rax, -0x80(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x74f0
movq -0x78(%rbp), %rdx
leaq 0x2c749(%rip), %rsi     # 0x3a676
leaq -0x50(%rbp), %rdi
callq 0x8940
jmp 0xdf38
movq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2c4d0
jmp 0xdf47
leaq -0x50(%rbp), %rdi
callq 0x7170
leaq -0x51(%rbp), %rdi
callq 0x72e0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xdf85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7170
leaq -0x51(%rbp), %rdi
callq 0x72e0
movq -0x28(%rbp), %rdi
callq 0x74e0
nopw (%rax,%rax)
// File: zerolfx[P]P-Machine/lda.cpp
// Function: Lda::execute(StackMachine*)
void Lda::execute(StackMachine *stack)
{
	stack->fStore.push_back(new StackAddress(stack->base(fP, stack->fMP) + fQ));
	
	++stack->fSP;
	
	// adding cost of this instruction
	stack->fTime.count("lda");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x68(%rbp)
movl $0x10, %edi
callq 0x7270
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movl 0x8(%rax), %esi
movl 0xc0(%rdi), %edx
callq 0x2d050
movl %eax, -0x50(%rbp)
jmp 0x13f53
movq -0x58(%rbp), %rdi
movl -0x50(%rbp), %esi
movq -0x60(%rbp), %rax
movl 0xc(%rax), %eax
addl %eax, %esi
callq 0x26800
jmp 0x13f6a
movq -0x68(%rbp), %rdi
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0xd2a0
movq -0x10(%rbp), %rax
movl 0xb4(%rax), %ecx
incl %ecx
movl %ecx, 0xb4(%rax)
movq -0x10(%rbp), %rax
addq $0x78, %rax
movq %rax, -0x78(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x74f0
movq -0x70(%rbp), %rdx
leaq 0x246b9(%rip), %rsi     # 0x3866e
leaq -0x48(%rbp), %rdi
callq 0x8940
jmp 0x13fc0
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2c4d0
jmp 0x13fcf
leaq -0x48(%rbp), %rdi
callq 0x7170
leaq -0x49(%rbp), %rdi
callq 0x72e0
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x7280
jmp 0x14032
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x14029
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x7170
leaq -0x49(%rbp), %rdi
callq 0x72e0
movq -0x20(%rbp), %rdi
callq 0x74e0
nopl (%rax,%rax)
// File: zerolfx[P]P-Machine/ssp.cpp
// Function: Ssp::execute(StackMachine*)
void Ssp::execute(StackMachine *stack)
{	
	int newSPvalue = stack->fMP + fP - 1;

	// get the stack consistent
	if(newSPvalue < stack->fSP)
	{
		for(int i = stack->fSP; i > newSPvalue; --i)
		{	
			delete stack->fStore[i];
			stack->fStore[i] = 0;
			stack->fStore.pop_back();
		}
	}
	else
	{
		for(int i = stack->fSP; i < newSPvalue; ++i)
		{
			stack->fStore.push_back(new StackElement());
		}
	}
	
	stack->fSP = newSPvalue;
	
	// adding cost of this instruction
	stack->fTime.count("ssp");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movl 0xc0(%rax), %eax
addl 0x8(%rcx), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xb4(%rcx), %eax
jge 0x216b5
movq -0x10(%rbp), %rax
movl 0xb4(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x216b3
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movslq -0x18(%rbp), %rsi
callq 0x8e70
movq (%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x21683
movq -0x68(%rbp), %rdi
callq 0x26ca0
movq -0x68(%rbp), %rdi
movl $0x8, %esi
callq 0x7280
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movslq -0x18(%rbp), %rsi
callq 0x8e70
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x8e90
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x21646
jmp 0x21732
movq -0x10(%rbp), %rax
movl 0xb4(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x21730
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x78(%rbp)
movl $0x8, %edi
callq 0x7270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
callq 0x26c80
jmp 0x216f1
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0xd2a0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x216c2
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x8, %esi
callq 0x7280
jmp 0x217ca
jmp 0x21732
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xb4(%rax)
movq -0x10(%rbp), %rax
addq $0x78, %rax
movq %rax, -0x88(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x74f0
movq -0x80(%rbp), %rdx
leaq 0x18396(%rip), %rsi     # 0x39afc
leaq -0x58(%rbp), %rdi
callq 0x8940
jmp 0x21771
movq -0x88(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2c4d0
jmp 0x21783
leaq -0x58(%rbp), %rdi
callq 0x7170
leaq -0x59(%rbp), %rdi
callq 0x72e0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x217c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x7170
leaq -0x59(%rbp), %rdi
callq 0x72e0
movq -0x30(%rbp), %rdi
callq 0x74e0
nopw %cs:(%rax,%rax)