LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %rbx
movl $0x2ef8000, %edi        # imm = 0x2EF8000
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
callq 0x2170
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3eae
vxorps %xmm0, %xmm0, %xmm0
movq %r13, (%rbx)
leaq 0x8(%rbx), %rdi
movq $0x0, 0x18(%rbx)
vmovups %xmm0, 0x8(%rbx)
movl $0x1f4, %esi            # imm = 0x1F4
movq %rdi, (%rsp)
callq 0x3b6c
leaq 0x8(%rsp), %rbp
xorl %r13d, %r13d
movl (%r15,%r13,4), %ecx
vmovsd 0x45d9(%rip), %xmm0     # 0x8098
movq %rbp, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3c50
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x3af1
movl $0x10000, %edx          # imm = 0x10000
movq %rsi, %rdi
movq %rbp, %rsi
callq 0x2130
addq $0x10000, 0x10(%rbx)    # imm = 0x10000
jmp 0x3afd
movq (%rsp), %rdi
movq %rbp, %rdx
callq 0x4094
incq %r13
cmpq $0x1f4, %r13            # imm = 0x1F4
jne 0x3ab3
addq $0x10008, %rsp          # imm = 0x10008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b2f
movl $0x2ef8000, %esi        # imm = 0x2EF8000
movq %r13, %rdi
movq %rax, %r14
callq 0x2180
jmp 0x3b63
movq (%rsp), %rcx
movq %rax, %r14
movq (%rcx), %rdi
testq %rdi, %rdi
je 0x3b4a
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x2180
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3b5c
movl $0x2ef8000, %esi        # imm = 0x2EF8000
callq 0x2180
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
xorl %edi, %edi
movq %r13, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
addq %rdi, %rdi
movl $0x1, %ebx
movq %r13, 0x18(%rsp)
xorq $0x1e, %rdi
movq %rdi, 0x20(%rsp)
movl (%r14,%r12,4), %eax
vmovsd 0x410f(%rip), %xmm0     # 0x8008
movq 0x20(%rsp), %rcx
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
imull %ebx, %eax
shlxq %rcx, %rax, %rcx
callq 0x3f6a
incq %rbx
addq $0x7d4, %r13            # imm = 0x7D4
cmpq $0x4, %rbx
jne 0x3eed
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %r13
incq %rdi
addq $0x177c, %r13           # imm = 0x177C
cmpq $0x8, %rdi
jne 0x3ed2
movq 0x8(%rsp), %r13
incq %r12
addq $0xbbe0, %r13           # imm = 0xBBE0
cmpq $0x400, %r12            # imm = 0x400
jne 0x3ecb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdi, %r15
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
leaq 0x8(%rsp), %rdi
movq %rdx, %rbx
movq %rsp, %r12
xorl %r13d, %r13d
movl %ecx, %ebp
movq %rsi, %r14
movq %r13, (%rdi)
vmovsd %xmm0, 0x8(%rdi)
movq %r13, 0x10(%rdi)
movq %rdi, %rdx
movq %rax, (%r12)
movb $0x0, 0x18(%rdi)
callq 0x396c
vroundsd $0x9, %xmm0, %xmm0, %xmm1
vsubsd %xmm1, %xmm0, %xmm0
vmulsd 0x40da(%rip), %xmm0, %xmm0 # 0x80a0
vcvttsd2usi %xmm0, %eax
addl %ebp, %eax
movl %eax, 0x7d0(%r15)
movq %r12, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x400e
movl %eax, (%r15,%r13,4)
imull (%rbx,%r13,4), %eax
incq %r13
addl %eax, 0x7d0(%r15)
cmpq $0x1f4, %r13            # imm = 0x1F4
jne 0x3fd5
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
leaq 0x28(%rsp), %r12
xorl %r13d, %r13d
movq %r13, 0x8(%rsp)
vmovsd %xmm0, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, 0x20(%rsp)
movq %rax, (%r12)
movq %r12, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x400e
movl %eax, 0x1030(%rsp,%r13)
addq $0x4, %r13
cmpq $0x1000, %r13           # imm = 0x1000
jne 0x4336
leaq 0x30(%rsp), %rdi
leaq 0x1030(%rsp), %rsi
movq %r15, %rdx
callq 0x4b30
leaq 0x8(%rsp), %r15
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x396c
vroundsd $0x9, %xmm0, %xmm0, %xmm1
vsubsd %xmm1, %xmm0, %xmm0
vmulsd 0x3d0a(%rip), %xmm0, %xmm0 # 0x80a0
vcvttsd2usi %xmm0, %eax
addl %eax, 0x30(%rsp,%r12)
addq $0x4, %r12
cmpq $0x1000, %r12           # imm = 0x1000
jne 0x4376
leaq 0x1030(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rdi
callq 0x2130
movq %rbx, %rdi
addq $0x1000, %rdi           # imm = 0x1000
leaq 0x30(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2130
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_O3/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
cmpb $0x0, %fs:-0x20028
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
je 0x4c86
xorl %eax, %eax
vcvtdq2pd (%r14,%rax,4), %zmm0
vmovupd %zmm0, 0x8(%rsp,%rax,8)
addq $0x8, %rax
cmpq $0x400, %rax            # imm = 0x400
jne 0x4b58
movq %fs:0x0, %rax
leaq 0x8(%rsp), %r12
movq %r12, %rsi
leaq -0x28028(%rax), %r14
movq %r14, %rdi
vzeroupper
callq 0x4f1a
leaq 0x4008(%rsp), %rdi
movl $0x2000, %edx           # imm = 0x2000
movq %r12, %rsi
callq 0x2130
xorl %eax, %eax
vcvtdq2pd (%r15,%rax,4), %zmm0
vmovupd %zmm0, 0x8(%rsp,%rax,8)
addq $0x8, %rax
cmpq $0x400, %rax            # imm = 0x400
jne 0x4bb0
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
vzeroupper
callq 0x4f1a
leaq 0x2008(%rsp), %rdi
movl $0x2000, %edx           # imm = 0x2000
movq %r15, %rsi
callq 0x2130
movl $0x200, %eax            # imm = 0x200
vmovupd 0x4008(%rsp,%rax,8), %zmm0
vmovupd 0x2008(%rsp,%rax,8), %zmm1
vmovupd 0x3008(%rsp,%rax,8), %zmm3
vmovupd 0x1008(%rsp,%rax,8), %zmm4
vmulpd %zmm0, %zmm1, %zmm2
vmulpd %zmm1, %zmm3, %zmm1
vfmsub231pd %zmm3, %zmm4, %zmm2 # zmm2 = (zmm4 * zmm3) - zmm2
vfmadd231pd %zmm0, %zmm4, %zmm1 # zmm1 = (zmm4 * zmm0) + zmm1
vmovupd %zmm2, -0xff8(%rsp,%rax,8)
vmovupd %zmm1, 0x8(%rsp,%rax,8)
addq $0x8, %rax
cmpq $0x400, %rax            # imm = 0x400
jne 0x4bfb
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
vzeroupper
callq 0x4c90
movq %rbx, %rax
addq $0x6008, %rsp           # imm = 0x6008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2242
jmp 0x4b56
// File: /workspace/github_cpp_makefile_star2_O3/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
vbroadcastsd 0x3416(%rip), %zmm0 # 0x80b8
movq %rsi, %rbx
xorl %eax, %eax
vmulpd (%rdx,%rax,8), %zmm0, %zmm1
vmovupd %zmm1, (%rsp,%rax,8)
addq $0x8, %rax
cmpq $0x400, %rax            # imm = 0x400
jne 0x4ca7
movq %rsp, %rsi
vzeroupper
callq 0x4cf4
xorl %eax, %eax
vcvttpd2qq (%rsp,%rax,8), %zmm0
vpmovqd %zmm0, (%rbx,%rax,4)
addq $0x8, %rax
cmpq $0x400, %rax            # imm = 0x400
jne 0x4cce
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
vpmovsxbq 0x25c6(%rip), %zmm0 # 0x80d0
vpmovsxbq 0x25c4(%rip), %zmm1 # 0x80d8
vpbroadcastq 0x25aa(%rip), %zmm2 # 0x80c8
vpxor %xmm3, %xmm3, %xmm3
movq %r8, %rbx
movq %rcx, %r15
movq %rdi, %r14
xorl %eax, %eax
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 0x5b2d
movq %rsp, %rsi
addl $0x20000000, 0x7d0(%rsi) # imm = 0x20000000
leaq 0x7d8(%rsp), %r12
movl $0x7d4, %edx            # imm = 0x7D4
movq %r12, %rdi
vzeroupper
callq 0x2130
leaq 0xfac(%rsp), %r13
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rdi
callq 0x5bdc
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x5dea
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_O3/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
leaq 0x8(%rsp), %r12
movl $0x7d0, %edx            # imm = 0x7D0
movq %rsi, %r15
movq %rdi, %rbx
xorl %r13d, %r13d
xorl %esi, %esi
movq %r12, %rdi
callq 0x20b0
vpmovsxbq 0x22ac(%rip), %zmm0 # 0x80d0
vpmovsxbq 0x22aa(%rip), %zmm1 # 0x80d8
vpbroadcastq 0x2290(%rip), %zmm2 # 0x80c8
movl 0x1000(%r15), %eax
movl %eax, 0x7d0(%r12)
movl $0x8000, %eax           # imm = 0x8000
movl (%r15,%r13,4), %ecx
movq %r14, %rdx
xorl %esi, %esi
addl %eax, %ecx
incq %rsi
leal (%rsi,%rsi), %edi
negb %dil
shrxl %edi, %ecx, %edi
andl $0x3, %edi
je 0x5ecd
decl %edi
xorl %r8d, %r8d
imulq $0x7d4, %rdi, %rdi      # imm = 0x7D4
addq %rdx, %rdi
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 0x5e79
addq $0x177c, %rdx           # imm = 0x177C
cmpq $0x8, %rsi
jne 0x5e57
incq %r13
addq $0xbbe0, %r14           # imm = 0xBBE0
cmpq $0x400, %r13            # imm = 0x400
jne 0x5e4c
leaq 0x8(%rsp), %rsi
movl $0x7d4, %edx            # imm = 0x7D4
movq %rbx, %rdi
vzeroupper
callq 0x2130
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_O3/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 0x5fc2
movl %edx, %eax
testl %edx, %edx
je 0x5fa2
vpmovsxbq 0x218b(%rip), %zmm1 # 0x80d0
vpmovsxbq 0x2189(%rip), %zmm2 # 0x80d8
vpbroadcastd 0x2207(%rip), %zmm3 # 0x8160
addl $0xf, %edx
leaq -0x1(%rax), %rcx
vpbroadcastq %rcx, %zmm0
andl $0x7f0, %edx            # imm = 0x7F0
xorl %ecx, %ecx
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 0x5f6e
incq %rax
movq %rax, %rcx
incq %rcx
movl $0x20000000, -0x4(%rsp,%rax,4) # imm = 0x20000000
cmpl $0x400, %eax            # imm = 0x400
movq %rcx, %rax
jne 0x5fa8
jmp 0x6055
addl $0xfffffc00, %edx       # imm = 0xFFFFFC00
movl %edx, %eax
je 0x603a
vpmovsxbq 0x20fa(%rip), %zmm1 # 0x80d0
vpmovsxbq 0x20f8(%rip), %zmm2 # 0x80d8
vpbroadcastd 0x2172(%rip), %zmm3 # 0x815c
leaq 0xf(%rax), %rcx
leaq -0x1(%rax), %rsi
vpbroadcastq %rsi, %zmm0
andq $-0x10, %rcx
xorl %esi, %esi
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 0x5ffe
cmpl $0x3ff, %edx            # imm = 0x3FF
ja 0x6055
incq %rax
movq %rax, %rcx
incq %rcx
movl $0xe0000000, -0x4(%rsp,%rax,4) # imm = 0xE0000000
cmpl $0x400, %eax            # imm = 0x400
movq %rcx, %rax
jne 0x6040
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rdi
xorl %esi, %esi
vzeroupper
callq 0x20b0
movq %rbx, %rdi
addq $0x1000, %rdi           # imm = 0x1000
movl $0x1000, %edx           # imm = 0x1000
movq %rsp, %rsi
callq 0x2130
movq %rbx, %rax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6476
cmpl $0x3ff, %esi            # imm = 0x3FF
ja 0x6483
movl %esi, %ecx
leaq (,%rcx,4), %rsi
movq %rax, %rdx
subq %rsi, %rdx
xorl %esi, %esi
addq $0x1000, %rdx           # imm = 0x1000
movl (%rdx,%rsi,4), %r8d
addl (%rax,%rsi,4), %r8d
negl %r8d
movl %r8d, (%rdi,%rsi,4)
incq %rsi
cmpq %rsi, %rcx
jne 0x643a
movq $-0x400, %rdx           # imm = 0xFC00
movl 0x1000(%rax,%rdx,4), %esi
incq %rdx
subl (%rax,%rcx,4), %esi
movl %esi, (%rdi,%rcx,4)
incq %rcx
cmpq $0x400, %rcx            # imm = 0x400
jne 0x6458
jmp 0x64e3
movl $0x1000, %edx           # imm = 0x1000
movq %rax, %rsi
jmp 0x2130
addl $0xfffffc00, %esi       # imm = 0xFFFFFC00
je 0x64be
leaq (,%rsi,4), %rdx
movq %rax, %rcx
subq %rdx, %rcx
xorl %edx, %edx
addq $0x1000, %rcx           # imm = 0x1000
movl (%rcx,%rdx,4), %r8d
subl (%rax,%rdx,4), %r8d
movl %r8d, (%rdi,%rdx,4)
incq %rdx
cmpq %rdx, %rsi
jne 0x64a2
cmpl $0x3ff, %esi            # imm = 0x3FF
ja 0x64e3
movq $-0x400, %rcx           # imm = 0xFC00
movl 0x1000(%rax,%rcx,4), %edx
incq %rcx
addl (%rax,%rsi,4), %edx
negl %edx
movl %edx, (%rdi,%rsi,4)
incq %rsi
cmpq $0x400, %rsi            # imm = 0x400
jne 0x64c5
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7584
movq %r14, %rdi
callq 0x1a300
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 0x1ba90(%rip), %rsi     # 0x23050
leaq 0x1ba8c(%rip), %rdx     # 0x23053
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x746c
addq $0x78, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1cbc8
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x75f7
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 0x761a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x6210
movq %rbx, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1a9d4
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0x87a3
movq (%r15), %r12
movq -0x8(%r12), %rax
leaq 0x2b4a5(%rip), %rcx     # 0x33af8
movq 0x8(%rcx), %rdi
movq 0x8(%rax), %rsi
cmpq %rsi, %rdi
je 0x8676
cmpb $0x2a, (%rdi)
je 0x874f
callq 0x6310
testl %eax, %eax
jne 0x874f
movq %r15, %rdi
callq *0x68(%r12)
cmpl 0x8(%r14), %eax
jl 0x86f9
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
cmpl 0xc(%r14), %eax
jg 0x86f9
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1ada4(%rip), %rsi     # 0x23452
leaq 0x1ada0(%rip), %rdx     # 0x23455
leaq -0x40(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1cbc8
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x86e3
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
leaq -0x50(%rbp), %rdi
callq 0x1a9f8
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), %r15
movq %r15, -0x10(%r15)
leaq 0x1ad18(%rip), %rsi     # 0x2342d
leaq 0x1ad35(%rip), %rdx     # 0x23451
leaq -0x40(%rbp), %rdi
callq 0x746c
movb $0x1, %r12b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x1b14c
xorl %r12d, %r12d
leaq 0x2a34a(%rip), %rsi     # 0x32a88
leaq 0x12a25(%rip), %rdx     # 0x1b16a
movq %r14, %rdi
callq 0x63e0
jmp 0x87a3
movl $0x20, %edi
callq 0x6100
movq %rax, %r14
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ac7d(%rip), %rsi     # 0x233e8
leaq 0x1acba(%rip), %rdx     # 0x2342c
leaq -0x40(%rbp), %rdi
callq 0x746c
movb $0x1, %r12b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x1b14c
xorl %r12d, %r12d
leaq 0x2a2f4(%rip), %rsi     # 0x32a88
leaq 0x129cf(%rip), %rdx     # 0x1b16a
movq %r14, %rdi
callq 0x63e0
callq 0x6250
jmp 0x87c8
jmp 0x87e7
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x87f7
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0x87f7
jmp 0x87f4
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x87e0
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
testb %r12b, %r12b
jne 0x87ea
jmp 0x87f7
movq %rax, %rbx
movq %r14, %rdi
callq 0x6170
jmp 0x87f7
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x1a9f8
movq %rbx, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0xb4(%rsi), %eax
subl 0x8(%rdi), %eax
addl $-0x4, %eax
movl %eax, 0xc0(%rsi)
movl $0x10, %edi
callq 0x6200
movq %rax, %r15
movl 0xb0(%rbx), %esi
movq %rax, %rdi
callq 0x1a104
movslq 0xc0(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r15, 0x20(%rcx,%rax,8)
leaq 0x48(%rbx), %rdi
addq $0x10, %r14
movq %r14, %rsi
callq 0x1b252
movl %eax, 0xb0(%rbx)
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1aac3(%rip), %rsi     # 0x23460
leaq 0x1aabf(%rip), %rdx     # 0x23463
leaq -0x38(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x1cbc8
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x89d2
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 %r14, %rdi
je 0x8a07
movq -0x28(%rbp), %rsi
incq %rsi
jmp 0x8a02
movq %rax, %rbx
jmp 0x8a07
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x6210
movq %rbx, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O3/zerolfx[P]P-Machine/cupi.cpp
// Function: Cupi::execute(StackMachine*)
void Cupi::execute(StackMachine *stack)
{	
	/*
	if(stack->fMP + 4 > stack->fSP)
	{
		for(int i = 0; i < stack->fMP + 4 - stack->fSP; ++i)
		{
			stack->fStore.push_back(new StackElement());
			++stack->fSP;
		}
	}
	else
	{
		delete stack->fStore[stack->fMP + 4];
		stack->fStore[stack->fMP + 4] = 0;
	}
	*/
	
	stack->fStore[stack->fMP + 4] = new StackAddress(stack->fPC);
	
	if(stack->base(fP, stack->fStore[stack->fMP + 2]->getValue()) + fQ > stack->fSP)
	{
		throw ExecutionError("instruction cupi: trying to access a memorylocation above STORE[SP]");
	}
	stack->fPC = stack->fStore[stack->base(fP, stack->fStore[stack->fMP + 2]->getValue()) + fQ]->getValue();
	
	// adding cost of this instruction
	stack->fTime.count("cupi");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x6200
movq %rax, %r15
movl 0xb0(%rbx), %esi
movq %rax, %rdi
callq 0x1a104
movslq 0xc0(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r15, 0x20(%rcx,%rax,8)
movl 0x8(%r14), %r15d
movq 0x18(%rbx), %rcx
movq 0x10(%rcx,%rax,8), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rbx, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x1d550
addl 0xc(%r14), %eax
cmpl 0xb4(%rbx), %eax
jg 0x8c79
movl 0x8(%r14), %r15d
movslq 0xc0(%rbx), %rax
movq 0x18(%rbx), %rcx
movq 0x10(%rcx,%rax,8), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rbx, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x1d550
movslq 0xc(%r14), %rcx
cltq
addq %rcx, %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movl %eax, 0xb0(%rbx)
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1a87b(%rip), %rsi     # 0x234b2
leaq 0x1a878(%rip), %rdx     # 0x234b6
leaq -0x40(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1cbc8
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x8c6c
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x6100
movq %rax, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1a7d9(%rip), %rsi     # 0x2346e
leaq 0x1a815(%rip), %rdx     # 0x234b1
leaq -0x40(%rbp), %rdi
callq 0x746c
movb $0x1, %r12b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1b14c
xorl %r12d, %r12d
leaq 0x29dca(%rip), %rsi     # 0x32a88
leaq 0x124a5(%rip), %rdx     # 0x1b16a
movq %rbx, %rdi
callq 0x63e0
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x8ce5
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
testb %r12b, %r12b
jne 0x8cef
jmp 0x8d23
movq %rax, %r14
movq %rbx, %rdi
callq 0x6170
jmp 0x8d23
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x8d23
movq -0x30(%rbp), %rsi
incq %rsi
jmp 0x8d1e
movq %rax, %r14
jmp 0x8d23
movq %rax, %r14
movl $0x10, %esi
movq %r15, %rdi
callq 0x6210
movq %r14, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl 0xb4(%rsi), %r14d
movl 0xc0(%rsi), %eax
movq %rdi, -0x50(%rbp)
movl 0xc(%rdi), %ecx
addl %ecx, %eax
decl %eax
movl %eax, 0xb4(%rsi)
cmpl %eax, %r14d
jge 0xa589
leaq 0x18(%rbx), %r15
leaq -0x48(%rbp), %r12
movl $0x8, %edi
callq 0x6200
movq %rax, %r13
movq %rax, %rdi
callq 0x1a2f0
incl %r14d
movq %r13, -0x48(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xa334
movl 0xb4(%rbx), %eax
cmpl %eax, %r14d
jl 0xa557
movq -0x50(%rbp), %rcx
addl 0x8(%rcx), %eax
movl %eax, 0xbc(%rbx)
leaq -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1c0d1(%rip), %rsi     # 0x26676
leaq 0x1c0cd(%rip), %rdx     # 0x26679
leaq -0x48(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x1cbc8
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0xa5da
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x6210
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0xa613
movq -0x38(%rbp), %rsi
incq %rsi
jmp 0xa60e
movq %rax, %rbx
jmp 0xa613
movq %rax, %rbx
movl $0x8, %esi
movq %r13, %rdi
callq 0x6210
movq %rbx, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O3/zerolfx[P]P-Machine/fjp.cpp
// Function: Fjp::execute(StackMachine*)
void Fjp::execute(StackMachine *stack)
{
	StackBoolean p;
	
	if(typeid(p) != typeid(*(stack->fStore[stack->fSP])))
		throw ExecutionError("instruction fjp: requires a boolean te be on top of the stack.");

	if(stack->fStore[stack->fSP]->getBoolean() == false)
	{
		stack->fPC = stack->fLabelCenter.getAddress(fQ);
	}
	
	delete stack->fStore[stack->fSP];
	stack->fStore.pop_back();
	--stack->fSP;
	
	// adding cost of this instruction
	stack->fTime.count("fjp");

}

// 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 0x1ae40
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0xb392
movq (%r15), %r12
movq -0x8(%r12), %rax
leaq 0x28a2d(%rip), %rcx     # 0x33c98
movq 0x8(%rcx), %rdi
movq 0x8(%rax), %rsi
cmpq %rsi, %rdi
je 0xb28e
cmpb $0x2a, (%rdi)
je 0xb33e
callq 0x6310
testl %eax, %eax
jne 0xb33e
movq %r15, %rdi
callq *0x70(%r12)
testb %al, %al
jne 0xb2b0
leaq 0x48(%rbx), %rdi
addq $0x8, %r14
movq %r14, %rsi
callq 0x1b252
movl %eax, 0xb0(%rbx)
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0xb2cc
movq %r14, %rdi
callq 0x1a300
movl $0x8, %esi
movq %r14, %rdi
callq 0x6210
addq $-0x8, 0x20(%rbx)
decl 0xb4(%rbx)
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x18947(%rip), %rsi     # 0x23c3a
leaq 0x18943(%rip), %rdx     # 0x23c3d
leaq -0x40(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1cbc8
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xb328
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
leaq -0x50(%rbp), %rdi
callq 0x1ae64
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x6100
movq %rax, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x188a1(%rip), %rsi     # 0x23bfb
leaq 0x188d8(%rip), %rdx     # 0x23c39
leaq -0x40(%rbp), %rdi
callq 0x746c
movb $0x1, %r12b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1b14c
xorl %r12d, %r12d
leaq 0x27705(%rip), %rsi     # 0x32a88
leaq 0xfde0(%rip), %rdx      # 0x1b16a
movq %rbx, %rdi
callq 0x63e0
callq 0x6250
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xb3af
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
testb %r12b, %r12b
jne 0xb3b9
jmp 0xb3e2
movq %rax, %r14
movq %rbx, %rdi
callq 0x6170
jmp 0xb3e2
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xb3e2
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0xb3e2
jmp 0xb3df
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x1ae64
movq %r14, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O3/zerolfx[P]P-Machine/ixj.cpp
// Function: Ixj::execute(StackMachine*)
void Ixj::execute(StackMachine *stack)
{
	StackInteger p1;
			
	if(typeid(p1) != typeid(*stack->fStore[stack->fSP]))
		throw ExecutionError("instruction ixj: STORE[SP] does not contain an element of type integer.");
		
	stack->fPC = stack->fStore[stack->fSP]->getValue() + stack->fLabelCenter.getAddress(fQ);
	
	delete stack->fStore[stack->fSP];
	stack->fStore.pop_back();
	
	--stack->fSP;
	
	// adding cost of this instruction
	stack->fTime.count("ixj");

}

// 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 0x1a9d4
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0xe25c
movq (%r15), %r12
movq -0x8(%r12), %rax
leaq 0x259c5(%rip), %rcx     # 0x33af8
movq 0x8(%rcx), %rdi
movq 0x8(%rax), %rsi
cmpq %rsi, %rdi
je 0xe156
cmpb $0x2a, (%rdi)
je 0xe208
callq 0x6310
testl %eax, %eax
jne 0xe208
movq %r15, %rdi
callq *0x68(%r12)
movl %eax, %r15d
leaq 0x48(%rbx), %rdi
addq $0x8, %r14
movq %r14, %rsi
callq 0x1b252
addl %r15d, %eax
movl %eax, 0xb0(%rbx)
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0xe196
movq %r14, %rdi
callq 0x1a300
movl $0x8, %esi
movq %r14, %rdi
callq 0x6210
addq $-0x8, 0x20(%rbx)
decl 0xb4(%rbx)
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x164a3(%rip), %rsi     # 0x24660
leaq 0x1649f(%rip), %rdx     # 0x24663
leaq -0x40(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1cbc8
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xe1f2
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
leaq -0x50(%rbp), %rdi
callq 0x1a9f8
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x6100
movq %rax, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x163f4(%rip), %rsi     # 0x24618
leaq 0x16434(%rip), %rdx     # 0x2465f
leaq -0x40(%rbp), %rdi
callq 0x746c
movb $0x1, %r12b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1b14c
xorl %r12d, %r12d
leaq 0x2483b(%rip), %rsi     # 0x32a88
leaq 0xcf16(%rip), %rdx      # 0x1b16a
movq %rbx, %rdi
callq 0x63e0
callq 0x6250
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xe279
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
testb %r12b, %r12b
jne 0xe283
jmp 0xe2ac
movq %rax, %r14
movq %rbx, %rdi
callq 0x6170
jmp 0xe2ac
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xe2ac
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0xe2ac
jmp 0xe2a9
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x1a9f8
movq %r14, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movl $0x10, %edi
callq 0x6200
movq %rax, %r14
movl 0x8(%r15), %esi
movl 0xc0(%rbx), %edx
movq %rbx, %rdi
callq 0x1d550
addl 0xc(%r15), %eax
movq %r14, %rdi
movl %eax, %esi
callq 0x1a104
leaq 0x18(%rbx), %rdi
leaq -0x38(%rbp), %rsi
movq %r14, (%rsi)
callq 0xa334
incl 0xb4(%rbx)
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x162b1(%rip), %rsi     # 0x2466e
leaq 0x162ad(%rip), %rdx     # 0x24671
leaq -0x38(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x1cbc8
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0xe3f2
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 %r14, %rdi
je 0xe427
movq -0x28(%rbp), %rsi
incq %rsi
jmp 0xe422
movq %rax, %rbx
jmp 0xe427
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x6210
movq %rbx, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O3/zerolfx[P]P-Machine/mst.cpp
// Function: Mst::execute(StackMachine*)
void Mst::execute(StackMachine *stack)
{	
	for(int i = 0; i < 5; ++i)
	{
		stack->fStore.push_back(new StackElement());
	}

	// static link
	delete stack->fStore[stack->fSP + 2];
	stack->fStore[stack->fSP + 2] = new StackAddress(stack->base(fP, stack->fMP));

	// dynamic link
	delete stack->fStore[stack->fSP + 3];
	stack->fStore[stack->fSP + 3] = new StackAddress(stack->fMP);

	// save EP
	delete stack->fStore[stack->fSP + 4];
	stack->fStore[stack->fSP + 4] = new StackAddress(stack->fEP);
	
	stack->fSP += 5;
	
	// adding cost of this instruction
	stack->fTime.count("mst");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, -0x50(%rbp)
leaq 0x18(%rsi), %r15
movl $0x5, %r14d
leaq -0x48(%rbp), %r12
movl $0x8, %edi
callq 0x6200
movq %rax, %r13
movq %rax, %rdi
callq 0x1a2f0
movq %r13, -0x48(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xa334
decl %r14d
jne 0x12ffe
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq 0x10(%rcx,%rax,8), %r15
testq %r15, %r15
je 0x13044
movq %r15, %rdi
callq 0x1a300
movl $0x8, %esi
movq %r15, %rdi
callq 0x6210
movl $0x10, %edi
callq 0x6200
movq %rax, %r15
movq -0x50(%rbp), %rax
movl 0x8(%rax), %esi
movl 0xc0(%rbx), %edx
movq %rbx, %rdi
callq 0x1d550
movq %r15, %rdi
movl %eax, %esi
callq 0x1a104
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r15, 0x10(%rcx,%rax,8)
movq 0x18(%rbx), %rcx
movq 0x18(%rcx,%rax,8), %r14
testq %r14, %r14
je 0x130a3
movq %r14, %rdi
callq 0x1a300
movl $0x8, %esi
movq %r14, %rdi
callq 0x6210
movl $0x10, %edi
callq 0x6200
movq %rax, %r14
movl 0xc0(%rbx), %esi
movq %rax, %rdi
callq 0x1a104
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r14, 0x18(%rcx,%rax,8)
movq 0x18(%rbx), %rcx
movq 0x20(%rcx,%rax,8), %r14
testq %r14, %r14
je 0x130f1
movq %r14, %rdi
callq 0x1a300
movl $0x8, %esi
movq %r14, %rdi
callq 0x6210
movl $0x10, %edi
callq 0x6200
movq %rax, %r14
movl 0xbc(%rbx), %esi
movq %rax, %rdi
callq 0x1a104
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r14, 0x20(%rcx,%rax,8)
addl $0x5, %eax
movl %eax, 0xb4(%rbx)
leaq -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x11f41(%rip), %rsi     # 0x25082
leaq 0x11f3d(%rip), %rdx     # 0x25085
leaq -0x48(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x1cbc8
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x13176
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x6210
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x131cb
movq -0x38(%rbp), %rsi
incq %rsi
jmp 0x131c6
movq %rax, %rbx
jmp 0x131cb
jmp 0x131a1
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
jmp 0x131c6
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
jmp 0x131c6
movq %rax, %rbx
movl $0x8, %esi
movq %r13, %rdi
callq 0x6210
movq %rbx, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O3/zerolfx[P]P-Machine/mstf.cpp
// Function: Mstf::execute(StackMachine*)
void Mstf::execute(StackMachine *stack)
{	
	for(int i = 0; i < 5; ++i)
	{
		stack->fStore.push_back(new StackElement());
	}
	
	// static link
	delete stack->fStore[stack->fSP + 2];
	stack->fStore[stack->fSP + 2] = new StackAddress(stack->fStore[stack->base(fP, stack->fMP) + fQ + 1]->getValue());
	
	// dynamic link
	delete stack->fStore[stack->fSP + 3];
	stack->fStore[stack->fSP + 3] = new StackAddress(stack->fMP);
	
	// save EP
	delete stack->fStore[stack->fSP + 4];
	stack->fStore[stack->fSP + 4] = new StackAddress(stack->fEP);
	
	stack->fSP += 5;
	
	// adding cost of this instruction
	stack->fTime.count("mstf");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, -0x50(%rbp)
leaq 0x18(%rsi), %r14
movl $0x5, %r15d
leaq -0x48(%rbp), %r12
movl $0x8, %edi
callq 0x6200
movq %rax, %r13
movq %rax, %rdi
callq 0x1a2f0
movq %r13, -0x48(%rbp)
movq %r14, %rdi
movq %r12, %rsi
callq 0xa334
decl %r15d
jne 0x13292
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq 0x10(%rcx,%rax,8), %r12
testq %r12, %r12
je 0x132d8
movq %r12, %rdi
callq 0x1a300
movl $0x8, %esi
movq %r12, %rdi
callq 0x6210
movl $0x10, %edi
callq 0x6200
movq %rax, %r12
movq -0x50(%rbp), %r15
movl 0x8(%r15), %esi
movl 0xc0(%rbx), %edx
movq %rbx, %rdi
callq 0x1d550
movslq 0xc(%r15), %rcx
cltq
addq %rcx, %rax
movq (%r14), %rcx
movq 0x8(%rcx,%rax,8), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r12, %rdi
movl %eax, %esi
callq 0x1a104
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r12, 0x10(%rcx,%rax,8)
movq 0x18(%rbx), %rcx
movq 0x18(%rcx,%rax,8), %r14
testq %r14, %r14
je 0x1334f
movq %r14, %rdi
callq 0x1a300
movl $0x8, %esi
movq %r14, %rdi
callq 0x6210
movl $0x10, %edi
callq 0x6200
movq %rax, %r14
movl 0xc0(%rbx), %esi
movq %rax, %rdi
callq 0x1a104
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r14, 0x18(%rcx,%rax,8)
movq 0x18(%rbx), %rcx
movq 0x20(%rcx,%rax,8), %r14
testq %r14, %r14
je 0x1339d
movq %r14, %rdi
callq 0x1a300
movl $0x8, %esi
movq %r14, %rdi
callq 0x6210
movl $0x10, %edi
callq 0x6200
movq %rax, %r14
movl 0xbc(%rbx), %esi
movq %rax, %rdi
callq 0x1a104
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r14, 0x20(%rcx,%rax,8)
addl $0x5, %eax
movl %eax, 0xb4(%rbx)
leaq -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x11ca3(%rip), %rsi     # 0x25090
leaq 0x11ca0(%rip), %rdx     # 0x25094
leaq -0x48(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x1cbc8
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x13422
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x6210
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x13477
movq -0x38(%rbp), %rsi
incq %rsi
jmp 0x13472
movq %rax, %rbx
jmp 0x13477
jmp 0x1344d
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
jmp 0x13472
movq %rax, %rbx
movl $0x10, %esi
movq %r12, %rdi
jmp 0x13472
movq %rax, %rbx
movl $0x8, %esi
movq %r13, %rdi
callq 0x6210
movq %rbx, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O3/zerolfx[P]P-Machine/not.cpp
// Function: Not::execute(StackMachine*)
void Not::execute(StackMachine *stack) 
{
	// check if the stack contains at least one entry
	if(stack->fSP < 0)
		throw ExecutionError("instruction not: requires 1 stackelement to be present.");
		
	StackBoolean p1;
	
	if(typeid(p1) != typeid(*(stack->fStore[stack->fSP])))
		throw ExecutionError("instruction not: SP does not point to element of type boolean.");

	
	// actual not-operation
	stack->fStore[stack->fSP]->noti();
	
	// adding cost of this instruction
	stack->fTime.count("not");

	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
cmpl $0x0, 0xb4(%rsi)
js 0x15062
movq %rsi, %rbx
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x1ae40
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0x150b6
movq (%r14), %r15
movq -0x8(%r15), %rax
leaq 0x1ed08(%rip), %rcx     # 0x33c98
movq 0x8(%rcx), %rdi
movq 0x8(%rax), %rsi
cmpq %rsi, %rdi
je 0x14fab
cmpb $0x2a, (%rdi)
je 0x1500c
callq 0x6310
testl %eax, %eax
jne 0x1500c
movq %r14, %rdi
callq *0x48(%r15)
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x106a3(%rip), %rsi     # 0x25664
leaq 0x1069f(%rip), %rdx     # 0x25667
leaq -0x40(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1cbc8
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x14ff6
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
leaq -0x50(%rbp), %rdi
callq 0x1ae64
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), %r15
movq %r15, -0x10(%r15)
leaq 0x105fd(%rip), %rsi     # 0x25625
leaq 0x10634(%rip), %rdx     # 0x25663
leaq -0x40(%rbp), %rdi
callq 0x746c
movb $0x1, %r12b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x1b14c
xorl %r12d, %r12d
leaq 0x1da37(%rip), %rsi     # 0x32a88
leaq 0x6112(%rip), %rdx      # 0x1b16a
movq %r14, %rdi
callq 0x63e0
jmp 0x150b6
movl $0x20, %edi
callq 0x6100
movq %rax, %r14
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1056f(%rip), %rsi     # 0x255ed
leaq 0x1059f(%rip), %rdx     # 0x25624
leaq -0x40(%rbp), %rdi
callq 0x746c
movb $0x1, %r12b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x1b14c
xorl %r12d, %r12d
leaq 0x1d9e1(%rip), %rsi     # 0x32a88
leaq 0x60bc(%rip), %rdx      # 0x1b16a
movq %r14, %rdi
callq 0x63e0
callq 0x6250
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x150d3
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
testb %r12b, %r12b
jne 0x150dd
jmp 0x1513b
movq %rax, %rbx
movq %r14, %rdi
callq 0x6170
jmp 0x1513b
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x150ff
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
testb %r12b, %r12b
jne 0x15109
jmp 0x15132
movq %rax, %rbx
movq %r14, %rdi
callq 0x6170
jmp 0x15132
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x15132
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0x15132
jmp 0x1512f
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x1ae64
movq %rbx, %rdi
callq 0x6410
nop