LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: parsing_phase::lambda(__gnu_cxx::__normal_iterator<tokenize_phase2::token_t const*, std::vector<tokenize_phase2::token_t, std::allocator<tokenize_phase2::token_t>>>, internal_data::lambda&)
token_seq_type::const_iterator lambda(token_seq_type::const_iterator first, internal_data::lambda &lam){
        token_seq_type::const_iterator iter = first;
        if(iter->kind != kind_t::lambda){
            return first;
        }
        ++iter;
        while(iter->kind == kind_t::variable){
            internal_data::variable v;
            v.str = std::string(iter->beg, iter->end);
            lam.variable_seq.push_back(v);
            ++iter;
        }
        if(iter->kind != kind_t::dot){
            return first;
        }
        ++iter;
        token_seq_type::const_iterator result = sequence(iter, lam.seq);
        if(result == iter){
            // sequence�̃p�[�X���s�D
            return first;
        }
        return result;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpl $0x1, (%rdi)
jne 0x4e94
leaq 0x20(%rsp), %rbx
leaq 0x48(%rsp), %r14
movq %rsi, 0x30(%rsp)
leaq 0x8(%rsi), %r13
movq %rdi, (%rsp)
leaq 0x50(%rdi), %r15
leaq 0x9ea8(%rip), %r12      # 0xec98
leaq 0x38(%rsp), %rbp
movl -0x28(%r15), %eax
testl %eax, %eax
jne 0x4e6d
movq %r12, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movq -0x20(%r15), %rsi
movq -0x18(%r15), %rdx
movq %r14, 0x38(%rsp)
movq %rbp, %rdi
callq 0x8a66
leaq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x3280
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0x4e46
callq 0x31f0
movq %r13, %rdi
leaq 0x8(%rsp), %rsi
callq 0x64e2
movq %r12, 0x8(%rsp)
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x4e67
callq 0x31f0
addq $0x28, %r15
jmp 0x4df5
cmpl $0x3, %eax
jne 0x4e90
movq 0x30(%rsp), %rsi
addq $0x20, %rsi
movq %r15, %rdi
callq 0x4ce8
cmpq %rax, %r15
movq (%rsp), %rdi
cmovneq %rax, %rdi
jmp 0x4e94
movq (%rsp), %rdi
movq %rdi, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4ea8
movq %rax, %r14
movq %r12, 0x8(%rsp)
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x4ebf
callq 0x31f0
movq %r14, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: parsing_phase::variable(__gnu_cxx::__normal_iterator<tokenize_phase2::token_t const*, std::vector<tokenize_phase2::token_t, std::allocator<tokenize_phase2::token_t>>>, internal_data::variable&)
token_seq_type::const_iterator variable(token_seq_type::const_iterator first, internal_data::variable &var){
        token_seq_type::const_iterator iter = first;
        if(iter->kind == kind_t::variable){
            var.str = std::string(iter->beg, iter->end);
            return ++iter;
        }else{
            return first;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jne 0x4f1c
movq %rsi, %r14
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x8a66
addq $0x8, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3280
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x4f18
callq 0x31f0
addq $0x28, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: parsing_phase::expr_no_sequence(std::unique_ptr<internal_data::expr, std::default_delete<internal_data::expr>>&, __gnu_cxx::__normal_iterator<tokenize_phase2::token_t const*, std::vector<tokenize_phase2::token_t, std::allocator<tokenize_phase2::token_t>>>)
token_seq_type::const_iterator expr_no_sequence(std::unique_ptr<internal_data::expr> &e, token_seq_type::const_iterator first){
        token_seq_type::const_iterator iter = first;
        token_seq_type::const_iterator r = first;
        if(iter->kind == kind_t::lambda){
            internal_data::lambda *ptr = new internal_data::lambda();
            iter = lambda(iter, *ptr);
            e.reset(ptr);
            r = iter;
        }else if(iter->kind == kind_t::variable){
            internal_data::variable *ptr = new internal_data::variable();
            iter = variable(iter, *ptr);
            e.reset(ptr);
            r = iter;
        }else if(iter->kind == kind_t::lparen){
            ++iter;
            std::unique_ptr<internal_data::expr> f;
            token_seq_type::const_iterator s = expr(f, iter);
            if(s != first){
                iter = s;
                if(iter->kind == kind_t::rparen){
                    ++s;
                    e.swap(f);
                    r = s;
                }else{
                    throw parsing_error(first->line);
                }
            }
        }
        return r;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %eax
testl %eax, %eax
je 0x4fa3
cmpl $0x4, %eax
je 0x4f70
cmpl $0x1, %eax
jne 0x4ff5
movl $0x28, %edi
callq 0x3220
movq %rax, %r15
movq %rax, %rdi
callq 0x654a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4db7
jmp 0x4fe1
leaq 0x28(%rbx), %rsi
leaq 0x8(%rsp), %rdi
movq $0x0, (%rdi)
callq 0x473f
cmpq %rbx, %rax
je 0x5002
cmpl $0x5, (%rax)
jne 0x5009
addq $0x28, %rax
movq (%r14), %rdi
movq 0x8(%rsp), %rcx
movq %rcx, (%r14)
movq %rax, %rbx
jmp 0x4fea
movl $0x28, %edi
callq 0x3220
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
leaq 0x9cd2(%rip), %rax      # 0xec98
movq %rax, (%r15)
leaq 0x18(%r15), %rax
movq %rax, 0x8(%r15)
movb $0x0, 0x18(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4ec7
movq %rax, %rbx
movq (%r14), %rdi
movq %r15, (%r14)
testq %rdi, %rdi
je 0x4ff5
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rsp), %rdi
jmp 0x4fea
movl $0x10, %edi
callq 0x3130
movq %rax, %r14
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x637c
leaq 0x9adf(%rip), %rsi      # 0xeb08
movq 0x9f90(%rip), %rdx      # 0xefc0
movq %r14, %rdi
callq 0x3350
movq %rax, %rbx
movq %r14, %rdi
callq 0x31a0
jmp 0x5055
movq %rax, %rbx
movq %r15, %rdi
callq 0x31f0
jmp 0x5065
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5065
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: parsing_phase::lines(__gnu_cxx::__normal_iterator<tokenize_phase2::token_t const*, std::vector<tokenize_phase2::token_t, std::allocator<tokenize_phase2::token_t>>>)
bool lines(token_seq_type::const_iterator first){
        token_seq_type::const_iterator iter = first;
        token_seq_type::const_iterator jter = iter;
        for(; (jter = line(iter)) != iter && jter->kind != kind_t::end; iter = jter){
            if(jter->kind == kind_t::dot){
                ++jter;
            }
        }
        if(jter->kind == kind_t::end){
            return true;
        }else{
            return false;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x4c24
movq %rax, %rbx
cmpq %r14, %rax
je 0x50a3
movl (%rbx), %eax
cmpl $0x3, %eax
je 0x508f
cmpl $0x6, %eax
jne 0x5093
jmp 0x50a3
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x4c24
cmpq %rbx, %rax
movq %rax, %rbx
jne 0x5081
cmpl $0x6, (%rbx)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::sequence::copy() const
expr *copy() const override{
            sequence *r = new sequence;
            for(auto iter = vec.begin(); iter != vec.end(); ++iter){
                r->push_back(std::move(std::unique_ptr<expr>((*iter)->copy())));
            }
            return r;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x20, %edi
callq 0x3220
movq %rax, %r14
leaq 0x81dc(%rip), %rax      # 0xec20
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq $0x0, 0x18(%r14)
movq 0x8(%rbx), %r13
cmpq 0x10(%rbx), %r13
je 0x6aa7
leaq 0x8(%r14), %r15
leaq 0x8(%rsp), %r12
movq (%r13), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x8210
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6a94
movq (%rdi), %rax
callq *0x38(%rax)
movq $0x0, 0x8(%rsp)
addq $0x8, %r13
cmpq 0x10(%rbx), %r13
jne 0x6a6a
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6acb
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rdi
callq 0x3360
nop
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::sequence::replace(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, internal_data::expr const*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, internal_data::expr const*>>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::unique_ptr<internal_data::expr, std::default_delete<internal_data::expr>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::unique_ptr<internal_data::expr, std::default_delete<internal_data::expr>>>>> const&, bool&) const
expr *replace(const variable_map &map, const expr_lookup_table &global_map, bool &mod) const override{
            sequence *r = new sequence;
            for(auto iter = vec.begin(); iter != vec.end(); ++iter){
                r->push_back(std::move(std::unique_ptr<expr>((*iter)->replace(map, global_map, mod))));
            }
            return r;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x20, %edi
callq 0x3220
leaq 0x8121(%rip), %rcx      # 0xec20
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rax)
movq 0x8(%r12), %r13
cmpq 0x10(%r12), %r13
je 0x6b74
movq 0x10(%rsp), %rax
leaq 0x8(%rax), %rbp
movq (%r13), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
movq %rbp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x8210
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6b60
movq (%rdi), %rax
callq *0x38(%rax)
movq $0x0, 0x8(%rsp)
addq $0x8, %r13
cmpq 0x10(%r12), %r13
jne 0x6b2b
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6b9b
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rdi
callq 0x3360
nop
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::sequence::local_replace(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, internal_data::expr const*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, internal_data::expr const*>>> const&, bool&) const
virtual expr *local_replace(const variable_map &map, bool &mod) const{
            sequence *r = new sequence;
            for(auto iter = vec.begin(); iter != vec.end(); ++iter){
                r->push_back(std::move(std::unique_ptr<expr>((*iter)->local_replace(map, mod))));
            }
            return r;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x20, %edi
callq 0x3220
leaq 0x8054(%rip), %rcx      # 0xec20
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rax)
movq 0x8(%r15), %r12
cmpq 0x10(%r15), %r12
je 0x6c3e
movq 0x10(%rsp), %rax
leaq 0x8(%rax), %r13
leaq 0x8(%rsp), %rbp
movq (%r12), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq %rax, 0x8(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x8210
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6c2b
movq (%rdi), %rax
callq *0x38(%rax)
movq $0x0, 0x8(%rsp)
addq $0x8, %r12
cmpq 0x10(%r15), %r12
jne 0x6bfb
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6c65
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rdi
callq 0x3360
nop
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::sequence::equal(internal_data::expr const*) const
virtual bool equal(const expr *other) const{
            if(other->get_kind() != expr::kind::sequence){
                return false;
            }
            const sequence *other_seq = static_cast<const sequence*>(other);
            auto iter = vec.begin();
            for(auto &i : other_seq->vec){
                if(!i->equal(&*i)){
                    return false;
                }
                ++iter;
            }
            return true;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
cmpl $0x1, %eax
jne 0x6e44
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %rbx
cmpq %rbx, %r14
je 0x6e48
addq $0x8, %r14
movq -0x8(%r14), %rdi
movq (%rdi), %rax
movq %rdi, %rsi
callq *0x28(%rax)
testb %al, %al
je 0x6e4a
leaq 0x8(%r14), %rcx
cmpq %rbx, %r14
movq %rcx, %r14
jne 0x6e25
jmp 0x6e4a
xorl %eax, %eax
jmp 0x6e4a
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::variable::replace(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, internal_data::expr const*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, internal_data::expr const*>>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::unique_ptr<internal_data::expr, std::default_delete<internal_data::expr>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::unique_ptr<internal_data::expr, std::default_delete<internal_data::expr>>>>> const&, bool&) const
expr *replace(const variable_map &map, const expr_lookup_table &global_map, bool &mod) const override{
            auto iter = map.find(str);
            if(iter != map.end()){
                mod = true;
                return iter->second->copy();
            }else{
                auto jter = global_map.find(str);
                if(jter != global_map.end()){
                    mod = true;
                    return jter->second->copy();
                }else{
                    return copy();
                }
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
leaq 0x8(%rdi), %r12
movq %rsi, %rdi
movq %r12, %rsi
callq 0x700c
addq $0x8, %r13
cmpq %r13, %rax
jne 0x6f19
movq %r15, %rdi
movq %r12, %rsi
callq 0x7096
addq $0x8, %r15
cmpq %r15, %rax
je 0x6f2f
movb $0x1, (%rbx)
movq 0x40(%rax), %rdi
movq (%rdi), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *0x8(%rax)
movq (%r14), %rax
movq %r14, %rdi
jmp 0x6f23
nop
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::variable::local_replace(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, internal_data::expr const*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, internal_data::expr const*>>> const&, bool&) const
expr *local_replace(const variable_map &map, bool &mod) const{
            auto iter = map.find(str);
            if(iter != map.end()){
                mod = true;
                return iter->second->copy();
            }else{
                return copy();
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rdi), %rsi
movq %r15, %rdi
callq 0x700c
addq $0x8, %r15
cmpq %r15, %rax
je 0x6f67
movb $0x1, (%rbx)
movq 0x40(%rax), %rdi
movq (%rdi), %rax
jmp 0x6f6d
movq (%r14), %rax
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x8(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::lambda::copy() const
expr *copy() const{
            lambda *r = new lambda;
            for(auto iter = variable_seq.begin(); iter != variable_seq.end(); ++iter){
                variable v;
                v.str = iter->str;
                r->variable_seq.push_back(v);
            }
            for(auto iter = get_seq()->vec.begin(); iter != get_seq()->vec.end(); ++iter){
                r->get_seq()->push_back(std::move(std::unique_ptr<expr>((*iter)->copy())));
            }
            return r;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
movl $0x28, %edi
callq 0x3220
movq %rax, %rbx
movq %rax, %rdi
callq 0x654a
movq 0x8(%r14), %rbp
cmpq 0x10(%r14), %rbp
je 0x71fc
leaq 0x28(%rsp), %r15
movq %rbx, %r12
addq $0x8, %r12
leaq 0x7aed(%rip), %r13      # 0xec98
movq %r13, 0x10(%rsp)
movq %r15, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movb $0x0, 0x28(%rsp)
leaq 0x8(%rbp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x3150
movq %r12, %rdi
leaq 0x10(%rsp), %rsi
callq 0x64e2
movq %r13, 0x10(%rsp)
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x71f2
callq 0x31f0
addq $0x28, %rbp
cmpq 0x10(%r14), %rbp
jne 0x71ab
movq 0x20(%r14), %rax
movq 0x8(%rax), %r13
cmpq 0x10(%rax), %r13
je 0x7258
leaq 0x8(%rsp), %r15
movq 0x20(%rbx), %r12
movq (%r13), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, 0x8(%rsp)
addq $0x8, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x8210
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7241
movq (%rdi), %rax
callq *0x38(%rax)
movq $0x0, 0x8(%rsp)
addq $0x8, %r13
movq 0x20(%r14), %rax
cmpq 0x10(%rax), %r13
jne 0x720f
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
jmp 0x7299
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x729e
movq (%rdi), %rax
callq *0x38(%rax)
jmp 0x729e
movq %rax, %r14
movq %r13, 0x10(%rsp)
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x729e
callq 0x31f0
movq %r14, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::lambda::replace(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, internal_data::expr const*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, internal_data::expr const*>>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::unique_ptr<internal_data::expr, std::default_delete<internal_data::expr>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::unique_ptr<internal_data::expr, std::default_delete<internal_data::expr>>>>> const&, bool&) const
expr *replace(const variable_map &map, const expr_lookup_table &global_map, bool &mod) const{
            variable_map dropped_map = make_dropped_map(map);
            lambda *lam = new lambda;
            lam->variable_seq = variable_seq;
            std::unique_ptr<expr> seq_prime(seq->copy());
            lam->seq.swap(seq_prime);
            std::unique_ptr<expr> f(seq->replace(dropped_map, global_map, mod));
            f.swap(lam->seq);
            return lam;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %r12
movq %rsp, %rdi
movq %r12, %rsi
callq 0x7702
movl $0x28, %edi
callq 0x3220
movq %rax, %rbx
movq %rax, %rdi
callq 0x654a
leaq 0x8(%r12), %rsi
movq %rbx, %rdi
addq $0x8, %rdi
callq 0x77f0
movq 0x20(%r12), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %r13
movq %rax, 0x20(%rbx)
movq 0x20(%r12), %rdi
movq (%rdi), %rax
movq %rsp, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *0x10(%rax)
movq 0x20(%rbx), %rdi
movq %rax, 0x20(%rbx)
testq %rdi, %rdi
je 0x732a
movq (%rdi), %rax
callq *0x38(%rax)
testq %r13, %r13
je 0x7339
movq (%r13), %rax
movq %r13, %rdi
callq *0x38(%rax)
movq %rsp, %rdi
callq 0x687a
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
testq %r13, %r13
je 0x7378
movq (%r13), %rax
movq %r13, %rdi
callq *0x38(%rax)
jmp 0x7378
jmp 0x7375
movq %rax, %r14
movq %rbx, %rdi
callq 0x31f0
jmp 0x7378
movq %rax, %r14
movq %rsp, %rdi
callq 0x687a
movq %r14, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::lambda::local_replace(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, internal_data::expr const*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, internal_data::expr const*>>> const&, bool&) const
virtual expr *local_replace(const variable_map &map, bool &mod) const{
            variable_map dropped_map = make_dropped_map(map);
            lambda *lam = new lambda;
            lam->variable_seq = variable_seq;
            std::unique_ptr<expr> seq_prime(seq->copy());
            lam->seq.swap(seq_prime);
            std::unique_ptr<expr> f(seq->local_replace(dropped_map, mod));
            f.swap(lam->seq);
            return lam;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x7702
movl $0x28, %edi
callq 0x3220
movq %rax, %rbx
movq %rax, %rdi
callq 0x654a
leaq 0x8(%r15), %rsi
movq %rbx, %rdi
addq $0x8, %rdi
callq 0x77f0
movq 0x20(%r15), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %r12
movq %rax, 0x20(%rbx)
movq 0x20(%r15), %rdi
movq (%rdi), %rax
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq *0x18(%rax)
movq 0x20(%rbx), %rdi
movq %rax, 0x20(%rbx)
testq %rdi, %rdi
je 0x7405
movq (%rdi), %rax
callq *0x38(%rax)
testq %r12, %r12
je 0x7414
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
leaq 0x8(%rsp), %rdi
callq 0x687a
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
testq %r12, %r12
je 0x7453
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
jmp 0x7453
jmp 0x7450
movq %rax, %r14
movq %rbx, %rdi
callq 0x31f0
jmp 0x7453
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x687a
movq %r14, %rdi
callq 0x3360
nop
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::lambda::to_str[abi:cxx11]() const
std::string to_str() const{
            std::string r;
            r += "/";
            std::size_t count = 0;
            for(auto &i : variable_seq){
                r += i.to_str();
                if(count < variable_seq.size() - 1){
                    r += " ";
                }
                ++count;
            }
            r += ". ";
            r += seq->to_str();
            return std::move(r);
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, 0x40(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x2e0d(%rip), %rsi      # 0xa2a4
leaq 0x20(%rsp), %rdi
callq 0x33b0
movq 0x8(%r14), %r15
movq 0x10(%r14), %rbp
cmpq %rbp, %r15
je 0x7522
xorl %ebx, %ebx
leaq 0x20(%rsp), %r13
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
movq (%r15), %rax
movq %rsp, %rdi
movq %r15, %rsi
callq *0x20(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r13, %rdi
callq 0x30d0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x74ef
callq 0x31f0
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
sarq $0x3, %rax
imulq %r12, %rax
decq %rax
cmpq %rax, %rbx
jae 0x7516
movq %r13, %rdi
leaq 0x2d96(%rip), %rsi      # 0xa2a7
callq 0x33b0
incq %rbx
addq $0x28, %r15
cmpq %rbp, %r15
jne 0x74bf
leaq 0x2d7d(%rip), %rsi      # 0xa2a6
leaq 0x20(%rsp), %rdi
callq 0x33b0
movq 0x20(%r14), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x20(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0x30d0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7566
callq 0x31f0
movq 0x40(%rsp), %rax
leaq 0x10(%rax), %rsi
movq %rsi, (%rax)
movq 0x20(%rsp), %rcx
leaq 0x30(%rsp), %rdx
cmpq %rdx, %rcx
je 0x758f
movq %rcx, (%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x7595
movups (%rdx), %xmm0
movups %xmm0, (%rsi)
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
jmp 0x75d4
jmp 0x75c3
jmp 0x75c3
jmp 0x75c3
jmp 0x75c3
movq %rax, %r14
jmp 0x75de
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x75de
callq 0x31f0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x75f2
callq 0x31f0
movq %r14, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::lambda::equal(internal_data::expr const*) const
bool equal(const expr *other) const{
            if(other->get_kind() != expr::kind::lambda){
                return false;
            }
            const lambda *other_seq = static_cast<const lambda*>(other);
            if(variable_seq.size() != other_seq->variable_seq.size()){
                return false;
            }
            {
                auto iter = variable_seq.begin();
                for(auto &i : other_seq->variable_seq){
                    if(!iter->equal(&i)){
                        return false;
                    }
                    ++iter;
                }
            }
            const sequence *s = static_cast<const sequence*>(seq.get());
            const sequence *other_s = static_cast<const sequence*>(other_seq->seq.get());
            auto iter = s->vec.begin();
            for(auto &i : other_s->vec){
                if(!i->equal(&*i)){
                    return false;
                }
                ++iter;
            }
            return true;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
cmpl $0x2, %eax
jne 0x7652
movq 0x8(%r15), %r14
movq 0x10(%r15), %rax
subq %r14, %rax
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %r12
movq %r12, %rcx
subq %r15, %rcx
cmpq %rcx, %rax
jne 0x7652
cmpq %r12, %r15
je 0x7660
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x28(%rax)
testb %al, %al
je 0x7652
addq $0x28, %r14
addq $0x28, %r15
jmp 0x7633
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x20(%rbx), %rax
movq 0x8(%rax), %r14
movq 0x10(%rax), %rbx
cmpq %rbx, %r14
je 0x7694
addq $0x8, %r14
movq -0x8(%r14), %rdi
movq (%rdi), %rax
movq %rdi, %rsi
callq *0x28(%rax)
testb %al, %al
je 0x7654
leaq 0x8(%r14), %rcx
cmpq %rbx, %r14
movq %rcx, %r14
jne 0x7675
jmp 0x7654
movb $0x1, %al
jmp 0x7654
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::lambda::make_dropped_map(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, internal_data::expr const*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, internal_data::expr const*>>> const&) const
variable_map make_dropped_map(const variable_map &map) const{
            variable_map dropped_map = map;
            for(const variable &var_seq_iter : variable_seq){
                auto iter = dropped_map.find(var_seq_iter.str);
                if(iter != dropped_map.end()){
                    dropped_map.erase(iter);
                }
            }
            return std::move(dropped_map);
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x797e
movq 0x8(%r14), %r15
movq 0x10(%r14), %r12
cmpq %r12, %r15
je 0x775a
leaq 0x8(%rsp), %r13
movq %rsp, %r14
leaq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x7ba0
cmpq %r13, %rax
je 0x7751
movq %r14, %rdi
movq %rax, %rsi
callq 0x7c2a
addq $0x28, %r15
cmpq %r12, %r15
jne 0x7735
leaq 0x8(%rbx), %rax
movq 0x10(%rsp), %rdx
testq %rdx, %rdx
je 0x77a0
leaq 0x8(%rsp), %rdi
movl (%rdi), %ecx
movq %rdx, 0x10(%rbx)
movq 0x10(%rdi), %r8
movq 0x18(%rdi), %rsi
movq %rax, 0x8(%rdx)
leaq 0x28(%rsp), %rdx
movq (%rdx), %rax
movq %rax, 0x28(%rbx)
movq $0x0, -0x18(%rdx)
movq %rdi, -0x10(%rdx)
movq %rdi, -0x8(%rdx)
movq %r8, %rax
jmp 0x77b1
movq $0x0, 0x10(%rbx)
leaq 0x28(%rbx), %rdx
xorl %ecx, %ecx
movq %rax, %rsi
movq %rax, 0x18(%rbx)
movq %rsi, 0x20(%rbx)
movq $0x0, (%rdx)
movl %ecx, 0x8(%rbx)
movq %rsp, %rdi
callq 0x687a
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x687a
movq %rbx, %rdi
callq 0x3360
nop
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./errmsg.hh
// Function: printCallStack()
void printCallStack(){
  void* array[256];
  int frames = backtrace(array, 256);

  char main_exe[FILENAMELENGTH];
  readlink("/proc/self/exe", main_exe, FILENAMELENGTH);

#ifdef CUSTOMIZED_STACK
  int threadIndex = getThreadIndex(&frames);
#else
  int threadIndex = getThreadIndex();
#endif

  char buf[256];
  for(int i = 0; i < frames; i++) {
    void* addr = (void*)((unsigned long)array[i] - PREV_INSTRUCTION_OFFSET);
    PRINT("\tThread %d: callstack frame %d: %p\t", threadIndex, i, addr);
    sprintf(buf, "addr2line -a -i -e %s %p", main_exe, addr);
    system(buf);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa08, %rsp            # imm = 0xA08
leaq 0x200(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x4440
movl %eax, %ebp
leaq 0x47bc(%rip), %rdi      # 0x9080
movq %rsp, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x4310
leaq 0x86a7(%rip), %rdi      # 0xcf80
callq 0x44f0
testl %ebp, %ebp
jle 0x4972
movl (%rax), %ebx
movl %ebp, %r13d
leaq 0x100(%rsp), %r12
xorl %ebp, %ebp
movq 0x200(%rsp,%rbp,8), %r14
decq %r14
callq 0x41e0
movl $0x1000, %esi           # imm = 0x1000
movq %rax, %rdi
leaq 0x4778(%rip), %rdx      # 0x908f
movl %ebx, %ecx
movl %ebp, %r8d
movq %r14, %r9
xorl %eax, %eax
callq 0x4490
callq 0x41e0
movq %rax, %r15
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0x40f0
movq %r12, %rdi
leaq 0x476c(%rip), %rsi      # 0x90c1
movq %rsp, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x4070
movq %r12, %rdi
callq 0x4230
incq %rbp
cmpq %rbp, %r13
jne 0x48f8
addq $0xa08, %rsp            # imm = 0xA08
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/libguarder.cpp
// Function: xxfree
void xxfree(void * ptr) {
		if(ptr == NULL || heapInitStatus != E_HEAP_INIT_DONE) {
			return;
		}

    if(BibopHeap::getInstance().isSmallObject(ptr)) {
        BibopHeap::getInstance().freeSmallObject(ptr);
    } else if(BigHeap::getInstance().isLargeObject(ptr)) {
        BigHeap::getInstance().deallocateToBigHeap(ptr);
    } else {
        PRERR("invalid free on address %p", ptr);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x4aea
movq 0x8533(%rip), %rax      # 0xcf58
cmpl $0x2, (%rax)
jne 0x4aea
movq %rdi, %rbx
callq 0x4100
cmpq %rbx, (%rax)
ja 0x4a58
cmpq %rbx, 0x8(%rax)
jb 0x4a58
callq 0x4100
movq %rax, %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x4300
callq 0x40c0
leaq 0x10(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0x10(%rax), %rdi
leaq 0x8(%rsp), %rcx
movl $0x8, %edx
callq 0x41c0
testb %al, %al
je 0x4a8e
callq 0x40c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4460
jmp 0x4aea
callq 0x41e0
movq %rax, %r14
callq 0x4250
movq %rbx, (%rsp)
leaq 0x494a(%rip), %rdx      # 0x93f0
leaq 0x4674(%rip), %r8       # 0x9121
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
movq %rax, %rcx
movl $0x116, %r9d            # imm = 0x116
xorl %eax, %eax
callq 0x4490
callq 0x41e0
movq %rax, %rbx
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x40f0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/libguarder.cpp
// Function: xxrealloc
void * xxrealloc(void * ptr, size_t sz) {
		// We can't really support this library call when the allocator
		// is uninitialized; this is because there is no way for us to
		// determine the actual size of an object given only its
		// starting address using the temporary allocator.
    if(heapInitStatus != E_HEAP_INIT_DONE) {
        heapinitialize();
    }

		// If the pointer is null, call is equivalent to malloc(sz).
		if(ptr == NULL) {
				return xxmalloc(sz);
		}

		// If the pointer is non-null and size is zero, call is equivalent
		// to free(ptr).
		if(sz == 0) {
				xxfree(ptr);
				return NULL;
		}

		// If the object is unknown to us, return NULL to indicate error.
		size_t oldSize = -1;
    if(BibopHeap::getInstance().isSmallObject(ptr)) {
        oldSize = BibopHeap::getInstance().getObjectSize(ptr);
    } else if(BigHeap::getInstance().isLargeObject(ptr)) {
        oldSize = BigHeap::getInstance().getObjectSize(ptr);
    }

		if(oldSize == -1) {
				PRERR("realloc called with unknown object");
				return NULL;
		}

		// If the requested new size is less than
		// or equal to the old size, simply return the object as-is.
		if(oldSize >= sz) {
				return ptr;
		}

		void * newObject = xxmalloc(sz);
		memcpy(newObject, ptr, oldSize);
		xxfree(ptr);
		return newObject;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x83dc(%rip), %rax      # 0xcf58
cmpl $0x2, (%rax)
je 0x4b86
callq 0x42d0
testq %rbx, %rbx
je 0x4bef
testq %r14, %r14
je 0x4c00
callq 0x4100
cmpq %rbx, (%rax)
ja 0x4c0f
cmpq %rbx, 0x8(%rax)
jb 0x4c0f
callq 0x4100
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4130
movq %rax, %r15
cmpq $-0x1, %r15
je 0x4c60
cmpq %r14, %r15
jae 0x4cba
movq %r14, %rdi
callq 0x4260
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4220
movq %rbx, %rdi
callq 0x41a0
movq %r14, %rbx
jmp 0x4cba
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x4260
movq %rbx, %rdi
callq 0x41a0
xorl %ebx, %ebx
jmp 0x4cba
callq 0x40c0
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0x10(%rax), %rdi
movq %rsp, %rcx
movl $0x8, %edx
callq 0x41c0
testb %al, %al
je 0x4c60
callq 0x40c0
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0x10(%rax), %rdi
movq %rsp, %rcx
movl $0x8, %edx
callq 0x41c0
testb %al, %al
je 0x4cc7
movq (%rsp), %rax
movq 0x20(%rax), %r15
jmp 0x4bb3
callq 0x41e0
movq %rax, %r14
callq 0x4250
leaq 0x47bb(%rip), %rdx      # 0x942f
leaq 0x44a6(%rip), %r8       # 0x9121
xorl %ebx, %ebx
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
movq %rax, %rcx
movl $0x141, %r9d            # imm = 0x141
xorl %eax, %eax
callq 0x4490
callq 0x41e0
movq %rax, %r14
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x40f0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
xorl %r15d, %r15d
jmp 0x4bb3
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/libguarder.cpp
// Function: xxmemalign
void * xxmemalign(size_t alignment, size_t size) {
		if(size == 0) {
			return NULL;
		}

		// Calculate the proper bag size needed to fulfill this request
		if(size > LARGE_OBJECT_THRESHOLD) {
			numLargeObjects++;
			return BigHeap::getInstance().allocateAlignedAtBigHeap(alignment, size);
		} else {
			size_t allocObjectSize = alignment + size;
			uintptr_t object = (uintptr_t)BibopHeap::getInstance().allocateSmallObject(allocObjectSize);
			unsigned long residualBytes = alignment - (object % alignment);
			void * alignedObject = (void *)(object + residualBytes);
			PRDBG("memalign: original object @ 0x%lx, residual bytes=%lu, aligned object @ %p",
							object, residualBytes, alignedObject);
			return alignedObject;
		}

		return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x4df3
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x80001, %rsi          # imm = 0x80001
jb 0x4dfb
movq 0x8126(%rip), %rax      # 0xcef8
incq (%rax)
callq 0x40c0
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4400
xorl %r14d, %r14d
jmp 0x4e82
addq %rbx, %r14
callq 0x4100
movq %rax, %rdi
movq %r14, %rsi
callq 0x4410
movq %rax, %r15
xorl %edx, %edx
divq %rbx
subq %rdx, %rbx
leaq (%rbx,%r15), %r14
callq 0x41e0
movq %rax, %r12
callq 0x4250
subq $0x8, %rsp
leaq 0x4691(%rip), %rdx      # 0x94c6
leaq 0x42e5(%rip), %r8       # 0x9121
movl $0x1000, %esi           # imm = 0x1000
movq %r12, %rdi
movq %rax, %rcx
movl $0x176, %r9d            # imm = 0x176
xorl %eax, %eax
pushq %r14
pushq %rbx
pushq %r15
callq 0x4490
addq $0x20, %rsp
callq 0x41e0
movq %rax, %rbx
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x40f0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./xthread.hh
// Function: xthread::initialize()
void initialize() {
		_aliveThreads = 0;
    _threadIndex = 0;

		// Initialize the spin_lock
		pthread_spin_init(&_spin_lock, PTHREAD_PROCESS_PRIVATE);

    thread_t * thread;

    // Shared the threads information.
    memset(&_threads, 0, sizeof(_threads));

		// Initialize all 
    for(int i = 0; i < MAX_ALIVE_THREADS; i++) {
				thread = &_threads[i];

				// Those information that are only initialized once.
				thread->available = true;
				thread->index = i;
		}

		// Now we will intialize the initial thread
		initializeInitialThread();

		_xmap.initialize(HashFuncs::hashAddr, HashFuncs::compareAddr, THREAD_MAP_SIZE);
		_xmap.insert((void*)pthread_self(), sizeof(void*), 0);
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movl %r14d, 0x38(%rdi)
movl %r14d, 0x4(%rdi)
xorl %esi, %esi
callq 0x42a0
leaq 0x40(%rbx), %rdi
movl $0x81400, %edx          # imm = 0x81400
xorl %esi, %esi
callq 0x4160
leaq 0x50(%rbx), %rax
movb $0x1, -0x10(%rax)
movl %r14d, (%rax)
incq %r14
addq $0x1028, %rax           # imm = 0x1028
cmpq $0x80, %r14
jne 0x5cb1
movq %rbx, %rdi
callq 0x43d0
addq $0x8, %rbx
movq 0x720b(%rip), %rsi      # 0xcee8
movq 0x7294(%rip), %rdx      # 0xcf78
movl $0x500, %ecx            # imm = 0x500
movq %rbx, %rdi
callq 0x42b0
callq 0x4250
movq %rsp, %rsi
movq %rax, (%rsi)
movl $0x8, %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x4340
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./bibopheap.hh
// Function: BibopHeap::allocateSmallObject(unsigned long)
void * allocateSmallObject(size_t sz) {
		//PRDBG("allocateSmallObject(%zu)", sz);

		#ifdef CUSTOMIZED_STACK
		int threadIndex = getThreadIndex(&sz);
		#else
		int threadIndex = getThreadIndex();
		#endif

    #ifdef USE_CANARY
    sz++;   // make room for the buffer overflow canary
    #endif

		unsigned classSizePower;
    if(sz <= BIBOP_MIN_BLOCK_SIZE) {
      classSizePower = LOG2(BIBOP_MIN_BLOCK_SIZE);
    } else {
      classSizePower = N_64BITS - __builtin_clzl(sz - 1);
    }

		PerThreadMap& curMap = _threadMap[threadIndex]; 
		unsigned bagNum = curMap.getBagNum(classSizePower);
		BibopObjCache& curCache = _bagCache[threadIndex][bagNum]; 

		PRDBG("allocateSmallObject(%zu): threadIndex = %d, bagNum = %d, class size = %u",
						sz, threadIndex, bagNum, curCache.getClassSize());

		void * object = curCache.malloc();

		return object;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x7233(%rip), %rdi      # 0xcf80
callq 0x44f0
movslq (%rax), %r12
leaq -0x1(%rbx), %rax
bsrq %rax, %rax
xorq $-0x40, %rax
addq $0x41, %rax
imulq $0x32, %r12, %rcx
addq %r14, %rcx
cmpq $0x11, %rbx
movl $0x4, %edx
cmovaeq %rax, %rdx
movzbl 0x4c(%rdx,%rcx), %r13d
movq %r12, %rax
shlq $0xb, %rax
addq %r14, %rax
movl %r13d, %ecx
shll $0x7, %ecx
leaq (%rcx,%rax), %r14
addq $0x41980, %r14          # imm = 0x41980
callq 0x41e0
movq %rax, %r15
callq 0x4250
movl 0x10(%r14), %r10d
leaq 0x3f96(%rip), %rdx      # 0x9d4b
leaq 0x37ce(%rip), %r8       # 0x958a
movl $0x1000, %esi           # imm = 0x1000
movq %r15, %rdi
movq %rax, %rcx
movl $0x3fa, %r9d            # imm = 0x3FA
xorl %eax, %eax
pushq %r10
pushq %r13
pushq %r12
pushq %rbx
callq 0x4490
addq $0x20, %rsp
callq 0x41e0
movq %rax, %rbx
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x40f0
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x44a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./bigheap.hh
// Function: BigHeap::deallocateToBigHeap(void*)
void deallocateToBigHeap(void * ptr) {
    bigObjectStatus * objStatus;
		if(!_xmap.find(ptr, sizeof(void *), &objStatus)) {
			PRINT("invalid or double free on address %p", ptr);
      printCallStack();
      exit(-1);
		}

		//PRDBG("BigHeap freed %p (begins @ %p), size %zu (actual %zu), objStatus @ %p",
		//				ptr, objStatus->start, objStatus->size, objStatus->pageUpSize, objStatus);
		acquireGlobalLock();
		_xmap.erase(ptr, sizeof(void *));
		releaseGlobalLock();
		MM::mmapDeallocate(objStatus->actualStart, objStatus->pageUpSize);
		HeapAllocator::deallocate(objStatus);
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rsi, (%rax)
leaq 0x10(%rdi), %r14
leaq 0x8(%rsp), %rcx
movl $0x8, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x41c0
testb %al, %al
je 0x60be
addq $0xc, %rbx
movq %rbx, %rdi
callq 0x4240
leaq 0x10(%rsp), %rsi
movl $0x8, %edx
movq %r14, %rdi
callq 0x4050
movq %rbx, %rdi
callq 0x4090
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rax), %rsi
callq 0x4180
movq 0x8(%rsp), %rdi
movq 0x6f04(%rip), %rax      # 0xcfb8
callq *(%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x41e0
movq 0x10(%rsp), %rcx
leaq 0x4571(%rip), %rdx      # 0xa640
movl $0x1000, %esi           # imm = 0x1000
movq %rax, %rdi
xorl %eax, %eax
callq 0x4490
callq 0x41e0
movq %rax, %rbx
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x40f0
callq 0x4540
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x4370
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./bigheap.hh
// Function: BigHeap::allocateAlignedAtBigHeap(unsigned long, unsigned long)
void * allocateAlignedAtBigHeap(size_t alignment, size_t size) {
		assert(IF_CANARY_CONDITION);

		size_t pageUpSize = alignup(alignment + size, PageSize);
		size_t slackSize = pageUpSize - size;
		bigObjectStatus * objStatus = (bigObjectStatus *)HeapAllocator::allocate(sizeof(bigObjectStatus));
		void * ptr = MM::mmapAllocatePrivate(pageUpSize, NULL);

		uintptr_t userStartPtr = (uintptr_t)ptr + slackSize;
		size_t residualBytes = userStartPtr % alignment;
		userStartPtr -= residualBytes;

		acquireGlobalLock();
    _xmap.insert((void *)userStartPtr, sizeof(void *), objStatus);
		releaseGlobalLock();

		objStatus->actualStart = ptr;
		objStatus->userStart = (void *)userStartPtr;
		objStatus->pageUpSize = pageUpSize;
		objStatus->usableSize = size + residualBytes;
		objStatus->size = size;

		PRDBG("BigHeap returning 0x%lx (begins @ %p), size %zu (actual %zu, usable %zu)",
						userStartPtr, ptr, size, pageUpSize, objStatus->usableSize);
		return (void *)userStartPtr;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq $0x80000, %rdx          # imm = 0x80000
jbe 0x6329
movq %rsi, %r13
movq %rdi, %rbp
leaq (%rsi,%rdx), %r15
addq $0xfff, %r15            # imm = 0xFFF
andq $-0x1000, %r15          # imm = 0xF000
movq %r15, %rbx
subq %rdx, %rbx
movq 0x6d08(%rip), %rax      # 0xcf28
movl $0x28, %edi
movq %rdx, 0x8(%rsp)
callq *(%rax)
movq %rax, %r12
xorl %edi, %edi
movq %r15, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x43c0
movq %rax, (%rsp)
addq %rax, %rbx
movq %rbx, %rax
xorl %edx, %edx
divq %r13
movq %rdx, %r13
subq %rdx, %rbx
leaq 0xc(%rbp), %r14
movq %r14, %rdi
callq 0x4240
addq $0x10, %rbp
leaq 0x10(%rsp), %rsi
movq %rbx, (%rsi)
movl $0x8, %edx
movq %rbp, %rdi
movq %r12, %rcx
callq 0x41d0
movq %r14, %rdi
callq 0x4090
movq (%rsp), %rbp
movq %rbp, (%r12)
movq %rbx, 0x8(%r12)
movq %r15, 0x18(%r12)
movq 0x8(%rsp), %rax
addq %rax, %r13
movq %r13, 0x20(%r12)
movq %rax, 0x10(%r12)
movq %rax, %r13
callq 0x41e0
movq %rax, %r14
callq 0x4250
subq $0x8, %rsp
leaq 0x44bf(%rip), %rdx      # 0xa783
leaq 0x4473(%rip), %r8       # 0xa73e
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
movq %rax, %rcx
movl $0x6b, %r9d
xorl %eax, %eax
pushq 0x20(%r12)
pushq %r15
pushq %r13
pushq %rbp
pushq %rbx
callq 0x4490
addq $0x30, %rsp
callq 0x41e0
movq %rax, %r14
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x40f0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x43fa(%rip), %rdi      # 0xa72a
leaq 0x4407(%rip), %rsi      # 0xa73e
leaq 0x440d(%rip), %rcx      # 0xa74b
movl $0x55, %edx
callq 0x4200