LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x6008, %rsp           # imm = 0x6008
movl 0x7d0(%rsi), %eax
movabsq $0x10000000000000, %rbx # imm = 0x10000000000000
movq %rdx, %r14
movl $0x800, %edx            # imm = 0x800
movq %rdi, (%rsp)
leaq 0x8(%rsp), %rdi
movq %rsi, %r15
shlq $0x20, %rax
addq %rbx, %rax
shrq $0x35, %rax
subl %eax, %edx
callq 0x5ac0
leaq 0x4008(%rsp), %r13
leaq 0x2008(%rsp), %rbp
xorl %r12d, %r12d
cmpq $0x1f4, %r12            # imm = 0x1F4
je 0x59c5
movl (%r15,%r12,4), %edx
shlq $0x20, %rdx
addq %rbx, %rdx
shrq $0x35, %rdx
jne 0x5975
incq %r12
jmp 0x5956
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x5b5a
movq %r12, %rdx
shlq $0x10, %rdx
addq (%r14), %rdx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x5b92
movq $-0x1000, %rax          # imm = 0xF000
testq %rax, %rax
je 0x5970
movl 0x3008(%rsp,%rax), %ecx
movl 0x4008(%rsp,%rax), %edx
addl %ecx, 0x1008(%rsp,%rax)
addl %edx, 0x2008(%rsp,%rax)
addq $0x4, %rax
jmp 0x599e
movq (%rsp), %rbx
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
movq %rbx, %rdi
callq 0x5d86
movq %rbx, %rax
addq $0x6008, %rsp           # imm = 0x6008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20d0
movl 0x1000(%r15), %eax
movl %eax, 0x7d0(%r12)
movl $0x8000, %eax           # imm = 0x8000
cmpq $0x400, %r13            # imm = 0x400
je 0x5a9a
movl (%r15,%r13,4), %ecx
movq %r14, %rdx
xorl %esi, %esi
addl %eax, %ecx
cmpq $0x8, %rsi
je 0x5a8e
incq %rsi
leal (%rsi,%rsi), %edi
negb %dil
shrxl %edi, %ecx, %edi
andl $0x3, %edi
je 0x5a85
decl %edi
xorl %r8d, %r8d
imulq $0x7d4, %rdi, %rdi      # imm = 0x7D4
addq %rdx, %rdi
cmpq $0x1f5, %r8             # imm = 0x1F5
je 0x5a85
movl (%rdi,%r8,4), %r9d
subl %r9d, 0x8(%rsp,%r8,4)
incq %r8
jmp 0x5a6e
addq $0x177c, %rdx           # imm = 0x177C
jmp 0x5a46
incq %r13
addq $0xbbe0, %r14           # imm = 0xBBE0
jmp 0x5a32
leaq 0x8(%rsp), %rsi
movl $0x7d4, %edx            # imm = 0x7D4
movq %rbx, %rdi
callq 0x2140
movq %rbx, %rax
addq $0x7e0, %rsp            # imm = 0x7E0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5afc
movl %edx, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x5af2
movl $0xe0000000, (%rsp,%rcx,4) # imm = 0xE0000000
incq %rcx
jmp 0x5ad7
movl $0x20000000, (%rsp,%rax,4) # imm = 0x20000000
incq %rax
cmpq $0x400, %rax            # imm = 0x400
jne 0x5ae8
jmp 0x5b28
addl $0xfffffc00, %edx       # imm = 0xFFFFFC00
xorl %eax, %eax
cmpq %rax, %rdx
je 0x5b1f
movl $0x20000000, (%rsp,%rax,4) # imm = 0x20000000
incq %rax
jmp 0x5b04
movl $0xe0000000, (%rsp,%rdx,4) # imm = 0xE0000000
incq %rdx
cmpq $0x3ff, %rdx            # imm = 0x3FF
jbe 0x5b15
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20d0
movq %rbx, %rdi
addq $0x1000, %rdi           # imm = 0x1000
movl $0x1000, %edx           # imm = 0x1000
movq %rsp, %rsi
callq 0x2140
movq %rbx, %rax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
subq $0x1010, %rsp           # imm = 0x1010
movl %edx, %eax
movq %rdi, %rbx
leaq (%rsi,%rax,4), %rdi
leaq 0x1(%rax), %rcx
xorl %r8d, %r8d
cmpq %r8, %rcx
je 0x5db4
movl (%rdi), %r9d
addq $-0x4, %rdi
movl %r9d, 0x8(%rsp,%r8,4)
incq %r8
jmp 0x5d9e
leal 0x1(%rdx), %ecx
addl $0x400, %edx            # imm = 0x400
leaq (,%rcx,4), %rdi
shlq $0x2, %rdx
subq %rdi, %rdx
addq %rsi, %rdx
cmpq $0x400, %rcx            # imm = 0x400
jae 0x5de9
xorl %edi, %edi
subl (%rdx), %edi
addq $-0x4, %rdx
movl %edi, 0x8(%rsp,%rcx,4)
incq %rcx
jmp 0x5dcf
movl 0x1000(%rsi,%rax,4), %eax
leaq 0x8(%rsp), %rsi
movl $0x1004, %edx           # imm = 0x1004
movq %rbx, %rdi
movl %eax, 0x1000(%rsi)
callq 0x2140
movq %rbx, %rax
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e55
cmpl $0x3ff, %esi            # imm = 0x3FF
ja 0x5e62
movl %esi, %ecx
leaq (,%rcx,4), %rsi
movq %rax, %rdx
subq %rsi, %rdx
xorl %esi, %esi
addq $0x1000, %rdx           # imm = 0x1000
cmpq %rsi, %rcx
je 0x5e95
movl (%rdx,%rsi,4), %r8d
addl (%rax,%rsi,4), %r8d
negl %r8d
movl %r8d, (%rdi,%rsi,4)
incq %rsi
jmp 0x5e3c
movl $0x1000, %edx           # imm = 0x1000
movq %rax, %rsi
jmp 0x2140
addl $0xfffffc00, %esi       # imm = 0xFFFFFC00
movq %rax, %rcx
leaq (,%rsi,4), %rdx
subq %rdx, %rcx
xorl %edx, %edx
addq $0x1000, %rcx           # imm = 0x1000
cmpq %rdx, %rsi
je 0x5ebd
movl (%rcx,%rdx,4), %r8d
subl (%rax,%rdx,4), %r8d
movl %r8d, (%rdi,%rdx,4)
incq %rdx
jmp 0x5e7f
movl $0x400, %edx            # imm = 0x400
leaq (%rdi,%rcx,4), %rsi
xorl %edi, %edi
subq %rcx, %rdx
leaq (%rax,%rcx,4), %rcx
cmpq %rdi, %rdx
je 0x5edc
movl (%rax,%rdi,4), %r8d
subl (%rcx,%rdi,4), %r8d
movl %r8d, (%rsi,%rdi,4)
incq %rdi
jmp 0x5ea7
xorl %ecx, %ecx
cmpq $0x3ff, %rsi            # imm = 0x3FF
ja 0x5edc
movl (%rax,%rcx), %edx
addq $0x4, %rcx
addl (%rax,%rsi,4), %edx
negl %edx
movl %edx, (%rdi,%rsi,4)
incq %rsi
jmp 0x5ebf
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq $-0x1000, %rax          # imm = 0xF000
testq %rax, %rax
je 0x5f78
vmovsd 0x2000(%rsi,%rax), %xmm0
vmovsd 0x2000(%rdx,%rax), %xmm1
vfmsub213sd 0x1000(%rdi,%rax), %xmm0, %xmm1 # xmm1 = (xmm0 * xmm1) - mem
vmovsd %xmm1, 0x1000(%rdi,%rax)
vmovsd 0x1000(%rdx,%rax), %xmm0
vfmsub132sd 0x1000(%rsi,%rax), %xmm1, %xmm0 # xmm0 = (xmm0 * mem) - xmm1
vmovsd %xmm0, 0x1000(%rdi,%rax)
vmovsd 0x1000(%rsi,%rax), %xmm0
vmovsd 0x2000(%rdx,%rax), %xmm1
vfmadd213sd 0x2000(%rdi,%rax), %xmm0, %xmm1 # xmm1 = (xmm0 * xmm1) + mem
vmovsd %xmm1, 0x2000(%rdi,%rax)
vmovsd 0x1000(%rdx,%rax), %xmm0
vfmadd132sd 0x2000(%rsi,%rax), %xmm1, %xmm0 # xmm0 = (xmm0 * mem) + xmm1
vmovsd %xmm0, 0x2000(%rdi,%rax)
addq $0x8, %rax
jmp 0x5ee4
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/zerolfx[P]P-Machine/instruction.cpp
// Function: printStackElementType[abi:cxx11](StackElementType)
string printStackElementType(StackElementType type)
{
	switch(type)
	{
		case integer:
			return "i";
			break;
		case real:
			return "r";
			break;
		case character:
			return "c";
			break;
		case boolean:
			return "b";
			break;
		case address:
			return "a";
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %eax
leaq 0x16dd0(%rip), %rcx     # 0x1e004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1a815(%rip), %rsi     # 0x21a59
leaq -0xc(%rbp), %rdx
jmp 0x727c
leaq 0x1841f(%rip), %rsi     # 0x1f670
leaq -0x9(%rbp), %rdx
jmp 0x727c
leaq 0x19ded(%rip), %rsi     # 0x2104b
leaq -0xa(%rbp), %rdx
jmp 0x727c
leaq 0x1854d(%rip), %rsi     # 0x1f7b8
leaq -0xb(%rbp), %rdx
jmp 0x727c
leaq 0x19fa6(%rip), %rsi     # 0x2121e
leaq -0xd(%rbp), %rdx
movq %rbx, %rdi
callq 0x72a6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movslq 0xb4(%rsi), %rax
movq 0x18(%rsi), %rcx
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0x73f4
movq %r14, %rdi
callq 0x17248
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x61e0
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
andq $0x0, (%rcx,%rax,8)
addq $-0x8, 0x20(%rbx)
decl %eax
movl %eax, 0xb4(%rbx)
leaq 0x16c2d(%rip), %rsi     # 0x1e050
leaq -0x38(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0x72a6
addq $0x78, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1925e
leaq -0x38(%rbp), %rdi
callq 0x60d0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x60d0
movq %rbx, %rdi
callq 0x63f0
// File: /workspace/github_cpp_makefile_star2_O2/zerolfx[P]P-Machine/mod.cpp
// Function: Mod::execute(StackMachine*)
void Mod::execute(StackMachine *stack) {
    if(typeid(StackInteger) != typeid(*(stack->fStore[stack->fSP])))
        throw ExecutionError("instruction mod: SP does not point to element of type integer.");
    if(typeid(StackInteger) != typeid(*(stack->fStore[stack->fSP - 1])))
        throw ExecutionError("instruction mod: SP - 1 does not point to element of type integer.");


    // actual addition
    stack->fStore[stack->fSP - 1]->mod(stack->fStore[stack->fSP]);

    // SP := SP - 1
    delete stack->fStore[stack->fSP];
    stack->fStore[stack->fSP] = 0;
    stack->fStore.pop_back();
    --stack->fSP;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movslq 0xb4(%rsi), %rax
movq 0x18(%rsi), %rcx
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x75d3
movq %rsi, %rbx
movq (%rax), %rax
movq -0x8(%rax), %rsi
leaq 0x275fc(%rip), %rdi     # 0x2eaf8
callq 0x76ba
testb %al, %al
jne 0x75d8
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq -0x8(%rcx,%rax,8), %rax
testq %rax, %rax
je 0x75d3
movq (%rax), %rax
movq -0x8(%rax), %rsi
leaq 0x275c8(%rip), %rdi     # 0x2eaf8
callq 0x76ba
testb %al, %al
jne 0x7621
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq -0x8(%rcx,%rax,8), %rdi
movq (%rcx,%rax,8), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0x7573
movq %r14, %rdi
callq 0x17248
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x61e0
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
andq $0x0, (%rcx,%rax,8)
addq $-0x8, 0x20(%rbx)
decl %eax
movl %eax, 0xb4(%rbx)
leaq 0x16b39(%rip), %rsi     # 0x1e0db
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x72a6
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1925e
leaq -0x40(%rbp), %rdi
callq 0x60d0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x6220
pushq $0x20
popq %rdi
callq 0x60f0
movq %rax, %r14
leaq 0x16a6f(%rip), %rsi     # 0x1e059
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x72a6
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x17d10
xorl %r15d, %r15d
leaq 0x26478(%rip), %rsi     # 0x2da88
leaq 0x10703(%rip), %rdx     # 0x17d1a
movq %r14, %rdi
callq 0x63c0
jmp 0x7668
pushq $0x20
popq %rdi
callq 0x60f0
movq %rax, %r14
leaq 0x16a65(%rip), %rsi     # 0x1e098
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x72a6
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x17d10
xorl %r15d, %r15d
leaq 0x2642f(%rip), %rsi     # 0x2da88
leaq 0x106ba(%rip), %rdx     # 0x17d1a
movq %r14, %rdi
callq 0x63c0
jmp 0x766c
jmp 0x767f
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x60d0
testb %r15b, %r15b
jne 0x7682
jmp 0x769d
movq %rax, %rbx
movq %r14, %rdi
callq 0x6150
jmp 0x769d
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x60d0
jmp 0x769d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x63f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x175ac
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x82db
movq (%rax), %rax
movq -0x8(%rax), %rsi
leaq 0x268ea(%rip), %rdi     # 0x2eaf8
callq 0x76ba
testb %al, %al
jne 0x82e0
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
cmpl 0x8(%r14), %eax
jl 0x8292
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
cmpl 0xc(%r14), %eax
jg 0x8292
leaq 0x161fa(%rip), %rsi     # 0x1e452
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x72a6
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1925e
leaq -0x40(%rbp), %rdi
callq 0x60d0
leaq -0x50(%rbp), %rdi
callq 0x175d0
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x60f0
movq %rax, %r14
leaq 0x16189(%rip), %rsi     # 0x1e42d
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x72a6
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x17d10
xorl %r15d, %r15d
leaq 0x257be(%rip), %rsi     # 0x2da88
leaq 0xfa49(%rip), %rdx      # 0x17d1a
movq %r14, %rdi
callq 0x63c0
jmp 0x8327
callq 0x6220
pushq $0x20
popq %rdi
callq 0x60f0
movq %rax, %r14
leaq 0x160f6(%rip), %rsi     # 0x1e3e8
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x72a6
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x17d10
xorl %r15d, %r15d
leaq 0x25770(%rip), %rsi     # 0x2da88
leaq 0xf9fb(%rip), %rdx      # 0x17d1a
movq %r14, %rdi
callq 0x63c0
jmp 0x833b
jmp 0x834e
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x60d0
jmp 0x835e
jmp 0x835b
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x60d0
testb %r15b, %r15b
jne 0x8351
jmp 0x835e
movq %rax, %rbx
movq %r14, %rdi
callq 0x6150
jmp 0x835e
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x175d0
movq %rbx, %rdi
callq 0x63f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %r15
movl 0xb0(%rbx), %esi
movq %rax, %rdi
callq 0x1704c
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 0x17d92
movl %eax, 0xb0(%rbx)
leaq 0x15f9f(%rip), %rsi     # 0x1e460
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x72a6
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1925e
leaq -0x40(%rbp), %rdi
callq 0x60d0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x60d0
jmp 0x8513
movq %rax, %rbx
jmp 0x8513
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x61e0
movq %rbx, %rdi
callq 0x63f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %r15
movl 0xb0(%rbx), %esi
movq %rax, %rdi
callq 0x1704c
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 0x1995a
addl 0xc(%r14), %eax
cmpl 0xb4(%rbx), %eax
jg 0x86ae
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 0x1995a
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 0x15e35(%rip), %rsi     # 0x1e4b2
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x72a6
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1925e
leaq -0x40(%rbp), %rdi
callq 0x60d0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x60f0
movq %rax, %rbx
leaq 0x15dae(%rip), %rsi     # 0x1e46e
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x72a6
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x17d10
xorl %r15d, %r15d
leaq 0x253a2(%rip), %rsi     # 0x2da88
leaq 0xf62d(%rip), %rdx      # 0x17d1a
movq %rbx, %rdi
callq 0x63c0
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x60d0
testb %r15b, %r15b
jne 0x870b
jmp 0x8736
movq %rax, %r14
movq %rbx, %rdi
callq 0x6150
jmp 0x8736
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x60d0
jmp 0x8736
movq %rax, %r14
jmp 0x8736
movq %rax, %r14
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x61e0
movq %r14, %rdi
callq 0x63f0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movq %rsi, %rbx
movl 0xb4(%rsi), %r12d
movl 0xc0(%rsi), %eax
movq %rdi, -0x38(%rbp)
movl 0xc(%rdi), %ecx
addl %ecx, %eax
decl %eax
movl %eax, 0xb4(%rsi)
leaq 0x18(%rsi), %r15
leaq -0x58(%rbp), %r13
cmpl %eax, %r12d
jge 0x9c26
pushq $0x8
popq %rdi
callq 0x61d0
movq %rax, %r14
movq %rax, %rdi
callq 0x17238
movq %r14, -0x58(%rbp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x99a0
movl 0xb4(%rbx), %eax
incl %r12d
jmp 0x9bf4
movq -0x38(%rbp), %rcx
addl 0x8(%rcx), %eax
movl %eax, 0xbc(%rbx)
leaq 0x17a3c(%rip), %rsi     # 0x21676
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x72a6
addq $0x78, %rbx
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x1925e
leaq -0x58(%rbp), %rdi
callq 0x60d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x60d0
jmp 0x9c90
movq %rax, %rbx
jmp 0x9c90
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x61e0
movq %rbx, %rdi
callq 0x63f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x17a18
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0xa781
movq (%rax), %rax
movq -0x8(%rax), %rsi
leaq 0x245c6(%rip), %rdi     # 0x2ec98
callq 0x76ba
testb %al, %al
jne 0xa786
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
testb %al, %al
jne 0xa70e
leaq 0x48(%rbx), %rdi
addq $0x8, %r14
movq %r14, %rsi
callq 0x17d92
movl %eax, 0xb0(%rbx)
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0xa72a
movq %r14, %rdi
callq 0x17248
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x61e0
addq $-0x8, 0x20(%rbx)
decl 0xb4(%rbx)
leaq 0x144f3(%rip), %rsi     # 0x1ec3a
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x72a6
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1925e
leaq -0x40(%rbp), %rdi
callq 0x60d0
leaq -0x50(%rbp), %rdi
callq 0x17a3c
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x6220
pushq $0x20
popq %rdi
callq 0x60f0
movq %rax, %rbx
leaq 0x14463(%rip), %rsi     # 0x1ebfb
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x72a6
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x17d10
xorl %r15d, %r15d
leaq 0x232ca(%rip), %rsi     # 0x2da88
leaq 0xd555(%rip), %rdx      # 0x17d1a
movq %rbx, %rdi
callq 0x63c0
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x60d0
testb %r15b, %r15b
jne 0xa7e3
jmp 0xa800
movq %rax, %r14
movq %rbx, %rdi
callq 0x6150
jmp 0xa800
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x60d0
jmp 0xa800
jmp 0xa7fd
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x17a3c
movq %r14, %rdi
callq 0x63f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x175ac
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0xceaf
movq (%rax), %rax
movq -0x8(%rax), %rsi
leaq 0x21cfa(%rip), %rdi     # 0x2eaf8
callq 0x76ba
testb %al, %al
jne 0xceb4
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movl %eax, %r15d
leaq 0x48(%rbx), %rdi
addq $0x8, %r14
movq %r14, %rsi
callq 0x17d92
addl %r15d, %eax
movl %eax, 0xb0(%rbx)
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0xce58
movq %r14, %rdi
callq 0x17248
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x61e0
addq $-0x8, 0x20(%rbx)
decl 0xb4(%rbx)
leaq 0x127eb(%rip), %rsi     # 0x1f660
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x72a6
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1925e
leaq -0x40(%rbp), %rdi
callq 0x60d0
leaq -0x50(%rbp), %rdi
callq 0x175d0
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x6220
pushq $0x20
popq %rdi
callq 0x60f0
movq %rax, %rbx
leaq 0x12752(%rip), %rsi     # 0x1f618
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x72a6
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x17d10
xorl %r15d, %r15d
leaq 0x20b9c(%rip), %rsi     # 0x2da88
leaq 0xae27(%rip), %rdx      # 0x17d1a
movq %rbx, %rdi
callq 0x63c0
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x60d0
testb %r15b, %r15b
jne 0xcf11
jmp 0xcf2e
movq %rax, %r14
movq %rbx, %rdi
callq 0x6150
jmp 0xcf2e
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x60d0
jmp 0xcf2e
jmp 0xcf2b
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x175d0
movq %r14, %rdi
callq 0x63f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %r14
movl 0x8(%r15), %esi
movl 0xc0(%rbx), %edx
movq %rbx, %rdi
callq 0x1995a
addl 0xc(%r15), %eax
movq %r14, %rdi
movl %eax, %esi
callq 0x1704c
leaq 0x18(%rbx), %rdi
leaq -0x40(%rbp), %rsi
movq %r14, (%rsi)
callq 0x99a0
incl 0xb4(%rbx)
leaq 0x12641(%rip), %rsi     # 0x1f66e
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x72a6
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1925e
leaq -0x40(%rbp), %rdi
callq 0x60d0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x60d0
jmp 0xd07f
movq %rax, %rbx
jmp 0xd07f
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x61e0
movq %rbx, %rdi
callq 0x63f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
leaq 0x18(%rsi), %r15
pushq $0x5
popq %rbx
pushq $0x8
popq %r12
leaq -0x60(%rbp), %r13
subl $0x1, %ebx
jb 0x1114f
movq %r12, %rdi
callq 0x61d0
movq %rax, %r14
movq %rax, %rdi
callq 0x17238
movq %r14, -0x60(%rbp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x99a0
jmp 0x11126
movq -0x40(%rbp), %rbx
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq 0x10(%rcx,%rax,8), %r14
testq %r14, %r14
je 0x11170
movq %r14, %rdi
callq 0x17248
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x61e0
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %r15
movq -0x38(%rbp), %rax
movl 0x8(%rax), %esi
movl 0xc0(%rbx), %edx
movq %rbx, %rdi
callq 0x1995a
movq %r15, %rdi
movl %eax, %esi
callq 0x1704c
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 0x111cb
movq %r14, %rdi
callq 0x17248
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x61e0
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %r14
movl 0xc0(%rbx), %esi
movq %rax, %rdi
callq 0x1704c
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 0x11215
movq %r14, %rdi
callq 0x17248
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x61e0
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %r14
movl 0xbc(%rbx), %esi
movq %rax, %rdi
callq 0x1704c
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r14, 0x20(%rcx,%rax,8)
addl $0x5, %eax
movl %eax, 0xb4(%rbx)
leaq 0xee29(%rip), %rsi      # 0x20082
leaq -0x60(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x72a6
addq $0x78, %rbx
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x1925e
leaq -0x60(%rbp), %rdi
callq 0x60d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x60d0
jmp 0x112c3
movq %rax, %rbx
jmp 0x112c3
jmp 0x112a3
movq %rax, %rbx
pushq $0x10
jmp 0x112ba
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r15, %rdi
jmp 0x112be
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x61e0
movq %rbx, %rdi
callq 0x63f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
leaq 0x18(%rsi), %r14
pushq $0x5
popq %rbx
pushq $0x8
popq %r12
leaq -0x60(%rbp), %r13
subl $0x1, %ebx
jb 0x113ab
movq %r12, %rdi
callq 0x61d0
movq %rax, %r15
movq %rax, %rdi
callq 0x17238
movq %r15, -0x60(%rbp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x99a0
jmp 0x11382
movq -0x40(%rbp), %rbx
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq 0x10(%rcx,%rax,8), %r15
testq %r15, %r15
je 0x113cc
movq %r15, %rdi
callq 0x17248
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x61e0
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %r12
movq -0x38(%rbp), %r15
movl 0x8(%r15), %esi
movl 0xc0(%rbx), %edx
movq %rbx, %rdi
callq 0x1995a
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 0x1704c
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 0x1143f
movq %r14, %rdi
callq 0x17248
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x61e0
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %r14
movl 0xc0(%rbx), %esi
movq %rax, %rdi
callq 0x1704c
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 0x11489
movq %r14, %rdi
callq 0x17248
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x61e0
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %r14
movl 0xbc(%rbx), %esi
movq %rax, %rdi
callq 0x1704c
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r14, 0x20(%rcx,%rax,8)
addl $0x5, %eax
movl %eax, 0xb4(%rbx)
leaq 0xebc3(%rip), %rsi      # 0x20090
leaq -0x60(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x72a6
addq $0x78, %rbx
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x1925e
leaq -0x60(%rbp), %rdi
callq 0x60d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x60d0
jmp 0x1153b
movq %rax, %rbx
jmp 0x1153b
jmp 0x11517
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
jmp 0x11536
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r12, %rdi
jmp 0x11536
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x61e0
movq %rbx, %rdi
callq 0x63f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x38, %rsp
cmpl $0x0, 0xb4(%rsi)
js 0x12c4b
movq %rsi, %rbx
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x17a18
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x12c94
movq (%rax), %rax
movq -0x8(%rax), %rsi
leaq 0x1c0b0(%rip), %rdi     # 0x2ec98
callq 0x76ba
testb %al, %al
jne 0x12c99
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
leaq 0xda53(%rip), %rsi      # 0x20664
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x72a6
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1925e
leaq -0x40(%rbp), %rdi
callq 0x60d0
leaq -0x50(%rbp), %rdi
callq 0x17a3c
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x60f0
movq %rax, %r14
leaq 0xd990(%rip), %rsi      # 0x205ed
leaq -0x40(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x72a6
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x17d10
xorl %r15d, %r15d
leaq 0x1ae05(%rip), %rsi     # 0x2da88
leaq 0x5090(%rip), %rdx      # 0x17d1a
movq %r14, %rdi
callq 0x63c0
jmp 0x12ce0
callq 0x6220
pushq $0x20
popq %rdi
callq 0x60f0
movq %rax, %r14
leaq 0xd97a(%rip), %rsi      # 0x20625
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x72a6
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x17d10
xorl %r15d, %r15d
leaq 0x1adb7(%rip), %rsi     # 0x2da88
leaq 0x5042(%rip), %rdx      # 0x17d1a
movq %r14, %rdi
callq 0x63c0
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x60d0
testb %r15b, %r15b
jne 0x12cf6
jmp 0x12d33
movq %rax, %rbx
movq %r14, %rdi
callq 0x6150
jmp 0x12d33
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x60d0
testb %r15b, %r15b
jne 0x12d16
jmp 0x12d3c
movq %rax, %rbx
movq %r14, %rdi
callq 0x6150
jmp 0x12d3c
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x60d0
jmp 0x12d33
jmp 0x12d30
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x17a3c
movq %rbx, %rdi
callq 0x63f0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movslq 0xc0(%rsi), %rax
movslq 0x8(%rdi), %r13
addq %rax, %r13
leal -0x1(%r13), %eax
movl %eax, -0x30(%rbp)
movl 0xb4(%rsi), %r12d
leaq 0x18(%rsi), %r14
cmpl %r12d, %r13d
jle 0x144c9
pushq $0x8
popq %r15
cmpl -0x30(%rbp), %r12d
jge 0x14503
movq %r15, %rdi
callq 0x61d0
movq %rax, %r13
movq %rax, %rdi
callq 0x17238
movq %r13, -0x50(%rbp)
movq %r14, %rdi
leaq -0x50(%rbp), %rsi
callq 0x99a0
incl %r12d
jmp 0x1449b
movslq %r12d, %r15
cmpq %r13, %r15
jl 0x14503
movq (%r14), %rax
movq (%rax,%r15,8), %r12
testq %r12, %r12
je 0x144e5
movq %r12, %rdi
callq 0x17248
movq %r12, %rdi
pushq $0x8
popq %rsi
callq 0x61e0
movq 0x18(%rbx), %rax
andq $0x0, (%rax,%r15,8)
addq $-0x8, 0x20(%rbx)
decq %r15
jmp 0x144cc
movl -0x30(%rbp), %eax
movl %eax, 0xb4(%rbx)
leaq 0xc5e9(%rip), %rsi      # 0x20afc
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x72a6
addq $0x78, %rbx
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x1925e
leaq -0x50(%rbp), %rdi
callq 0x60d0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x60d0
jmp 0x14569
movq %rax, %rbx
jmp 0x14569
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %r13, %rdi
callq 0x61e0
movq %rbx, %rdi
callq 0x63f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/zerolfx[P]P-Machine/in.cpp
// Function: In::execute(StackMachine*)
void In::execute(StackMachine *stack) 
{	
	switch(fType)
	{
		case integer:
		{
			int inputvalue;
			cin >> inputvalue;
			stack->fStore.push_back(new StackInteger(inputvalue));
			break;
		}	
		case real:
		{
			double inputvalue;
			cin >> inputvalue;
			stack->fStore.push_back(new StackReal(inputvalue));
			break;
		}
		case character:
		{
			char inputvalue;
			cin >> inputvalue;
			stack->fStore.push_back(new StackCharacter(inputvalue));
			break;
		}
		case boolean:
		{
			bool inputvalue;
			cin >> inputvalue;
			stack->fStore.push_back(new StackBoolean(inputvalue));
			break;
		}
		case address:
		{
			throw ExecutionError("instruction in: input of address at runtime is not allowed");
		}
	}
	
	// SP := SP + 1
	++stack->fSP;
	
	// adding cost of this instruction
	stack->fTime.count("in");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl 0x8(%rdi), %eax
cmpq $0x4, %rax
ja 0x15b6c
leaq 0xb5ce(%rip), %rcx      # 0x21068
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x1952e(%rip), %rdi     # 0x2efd8
leaq -0x40(%rbp), %r15
movq %r15, %rsi
callq 0x6120
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %r14
movsd (%r15), %xmm0
movq %rax, %rdi
callq 0x177d4
leaq 0x18(%rbx), %rdi
leaq -0x20(%rbp), %rsi
jmp 0x15b64
movq 0x194f6(%rip), %rdi     # 0x2efd8
leaq -0x20(%rbp), %r15
movq %r15, %rsi
callq 0x6180
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %r14
movzbl (%r15), %esi
movq %rax, %rdi
callq 0x17a18
jmp 0x15b5c
movq 0x194ca(%rip), %rdi     # 0x2efd8
leaq -0x20(%rbp), %r15
movq %r15, %rsi
callq 0x62c0
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %r14
movsbl (%r15), %esi
movq %rax, %rdi
callq 0x17c08
jmp 0x15b5c
movq 0x1949e(%rip), %rdi     # 0x2efd8
leaq -0x20(%rbp), %r15
movq %r15, %rsi
callq 0x6110
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %r14
movl (%r15), %esi
movq %rax, %rdi
callq 0x175ac
leaq 0x18(%rbx), %rdi
leaq -0x40(%rbp), %rsi
movq %r14, (%rsi)
callq 0x99a0
incl 0xb4(%rbx)
leaq 0xb542(%rip), %rsi      # 0x210bb
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rdx
callq 0x72a6
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1925e
leaq -0x40(%rbp), %rdi
callq 0x60d0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x60f0
movq %rax, %r14
leaq 0xb4c4(%rip), %rsi      # 0x21080
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rdx
callq 0x72a6
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x17d10
xorl %r15d, %r15d
leaq 0x17ea6(%rip), %rsi     # 0x2da88
leaq 0x2131(%rip), %rdx      # 0x17d1a
movq %r14, %rdi
callq 0x63c0
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x60d0
testb %r15b, %r15b
jne 0x15c07
jmp 0x15c38
movq %rax, %rbx
movq %r14, %rdi
callq 0x6150
jmp 0x15c38
jmp 0x15c17
jmp 0x15c17
jmp 0x15c17
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x61e0
jmp 0x15c38
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x60d0
jmp 0x15c38
movq %rax, %rbx
movq %rbx, %rdi
callq 0x63f0
// File: /workspace/github_cpp_makefile_star2_O2/zerolfx[P]P-Machine/out.cpp
// Function: Out::print(std::ostream&) const
ostream& Out::print(ostream &os) const
{
	if(fPrecisionMarker)
		os << "out r i";
	else
		os << "out " << printStackElementType(fType);
	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
cmpb $0x1, 0xc(%rdi)
jne 0x164f5
leaq 0xad2d(%rip), %rsi      # 0x21218
movq %rbx, %rdi
callq 0x61b0
jmp 0x1652e
movq %rdi, %r14
leaq 0xad21(%rip), %rsi      # 0x21220
movq %rbx, %rdi
callq 0x61b0
movq %rax, %r15
movl 0x8(%r14), %esi
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x7222
movq %r15, %rdi
movq %r14, %rsi
callq 0x61a0
leaq -0x38(%rbp), %rdi
callq 0x60d0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x60d0
movq %rbx, %rdi
callq 0x63f0
// File: /workspace/github_cpp_makefile_star2_O2/zerolfx[P]P-Machine/ldd.cpp
// Function: Ldd::execute(StackMachine*)
void Ldd::execute(StackMachine *stack) 
{
	if(stack->fSP < 2)
		throw ExecutionError("instruction ldd: requires 3 stackelements to be present.");
	
	StackAddress p1;
	if(typeid(p1) != typeid(*(stack->fStore[stack->fSP - 2])))
		throw ExecutionError("instruction add: SP-2 does not point to element of type address.");
		
	++stack->fSP;
	
	stack->fStore.push_back(new StackInteger(stack->fStore[stack->fSP -3]->getValue() + fQ));
	
	// adding cost of this instruction
	stack->fTime.count("ldd");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x1, 0xb4(%rsi)
jle 0x16692
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
callq 0x1704c
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq -0x10(%rcx,%rax,8), %rax
testq %rax, %rax
je 0x166db
movq (%rax), %rax
movq -0x8(%rax), %rsi
leaq 0x1836c(%rip), %rdi     # 0x2e960
callq 0x76ba
testb %al, %al
jne 0x166e0
movslq 0xb4(%rbx), %r13
leal 0x1(%r13), %eax
movl %eax, 0xb4(%rbx)
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %r15
leaq 0x18(%rbx), %r12
movq (%r12), %rax
movq -0x10(%rax,%r13,8), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
addl 0x8(%r14), %eax
movq %r15, %rdi
movl %eax, %esi
callq 0x175ac
leaq -0x50(%rbp), %rsi
movq %r15, (%rsi)
movq %r12, %rdi
callq 0x99a0
leaq 0xac4b(%rip), %rsi      # 0x2129f
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x72a6
addq $0x78, %rbx
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x1925e
leaq -0x50(%rbp), %rdi
callq 0x60d0
leaq -0x60(%rbp), %rdi
callq 0x17070
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x60f0
movq %rax, %r14
leaq 0xab81(%rip), %rsi      # 0x21225
leaq -0x50(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x72a6
movb $0x1, %r15b
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x17d10
xorl %r15d, %r15d
leaq 0x173be(%rip), %rsi     # 0x2da88
leaq 0x1649(%rip), %rdx      # 0x17d1a
movq %r14, %rdi
callq 0x63c0
jmp 0x16727
callq 0x6220
pushq $0x20
popq %rdi
callq 0x60f0
movq %rax, %r14
leaq 0xab6c(%rip), %rsi      # 0x2125e
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x72a6
movb $0x1, %r15b
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x17d10
xorl %r15d, %r15d
leaq 0x17370(%rip), %rsi     # 0x2da88
leaq 0x15fb(%rip), %rdx      # 0x17d1a
movq %r14, %rdi
callq 0x63c0
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x60d0
testb %r15b, %r15b
jne 0x1673d
jmp 0x1678c
movq %rax, %rbx
movq %r14, %rdi
callq 0x6150
jmp 0x1678c
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x60d0
testb %r15b, %r15b
jne 0x1675d
jmp 0x16795
movq %rax, %rbx
movq %r14, %rdi
callq 0x6150
jmp 0x16795
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x60d0
jmp 0x1678c
jmp 0x16779
jmp 0x16779
movq %rax, %rbx
jmp 0x1678c
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x61e0
leaq -0x60(%rbp), %rdi
callq 0x17070
movq %rbx, %rdi
callq 0x63f0
nop