LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::global_variable_replace(std::unique_ptr<internal_data::expr, std::default_delete<internal_data::expr>>&)
void global_variable_replace(std::unique_ptr<expr> &e){
        if(e->get_kind() == expr::kind::variable){
            variable *var = static_cast<variable*>(e.get());
            auto iter = assignment_table.find(var->str);
            if(iter != assignment_table.end()){
                e.reset(iter->second->copy());
                global_variable_replace(e);
            }
        }else if(e->get_kind() == expr::kind::lambda){
            lambda *lam = static_cast<lambda*>(e.get());
            global_variable_replace(lam->seq);
        }else if(e->get_kind() == expr::kind::sequence){
            sequence *seq = static_cast<sequence*>(e.get());
            for(auto &i : seq->vec){
                global_variable_replace(i);
            }
        }
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0xb9c0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x0, %eax
jne 0x6d46
movq 0x50(%rsp), %rdi
callq 0xb9d0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rsi
addq $0x8, %rsi
leaq 0x1f6cd(%rip), %rdi     # 0x263a0
callq 0xba00
movq %rax, 0x40(%rsp)
leaq 0x1f6bc(%rip), %rdi     # 0x263a0
callq 0xba50
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xba30
testb $0x1, %al
jne 0x6d03
jmp 0x6d41
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
leaq 0x40(%rsp), %rdi
callq 0xbab0
movq %rax, %rdi
addq $0x20, %rdi
callq 0xb9c0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xba80
movq 0x50(%rsp), %rdi
callq 0x6c90
jmp 0x6e11
movq 0x50(%rsp), %rdi
callq 0xb9c0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x2, %eax
jne 0x6d7f
movq 0x50(%rsp), %rdi
callq 0xb9d0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
callq 0x6c90
jmp 0x6e0f
movq 0x50(%rsp), %rdi
callq 0xb9c0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x1, %eax
jne 0x6e0d
movq 0x50(%rsp), %rdi
callq 0xb9d0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xbad0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0xbb00
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xbb30
testb $0x1, %al
jne 0x6de6
jmp 0x6e0b
leaq 0x18(%rsp), %rdi
callq 0xbb70
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x6c90
leaq 0x18(%rsp), %rdi
callq 0xbb80
jmp 0x6dd1
jmp 0x6e0d
jmp 0x6e0f
jmp 0x6e11
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: parsing_phase::line(__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 line(token_seq_type::const_iterator first){
        std::unique_ptr<internal_data::expr> e;
        auto result = assignment(e, first);
        if(result == first){
            result = expr(e, first);
            if(result == first){
                throw parsing_error(first->line);
            }
            internal_data::lines.push_back(std::move(e));
        }
        return result;
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xc290
movq 0x18(%rsp), %rdi
movq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rsi
callq 0x7980
movq %rax, 0x20(%rsp)
jmp 0x84f8
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xc2c0
testb $0x1, %al
jne 0x851a
jmp 0x85e7
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x7cf0
movq %rax, 0x10(%rsp)
jmp 0x853a
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xc2c0
testb $0x1, %al
jne 0x8563
jmp 0x85d2
movl $0x10, %edi
callq 0x5180
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
leaq 0x58(%rsp), %rdi
callq 0xc1d0
movq 0x8(%rsp), %rdi
movq 0x18(%rax), %rsi
callq 0xc3c0
jmp 0x8590
movq (%rsp), %rdi
leaq 0x1d365(%rip), %rsi     # 0x25900
leaq 0x3ede(%rip), %rdx      # 0xc480
callq 0x5590
jmp 0x860f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x85fb
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x52a0
jmp 0x85fb
leaq 0x1ddf7(%rip), %rdi     # 0x263d0
leaq 0x50(%rsp), %rsi
callq 0xbfe0
jmp 0x85e5
jmp 0x85e7
leaq 0x50(%rsp), %rdi
callq 0xbee0
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
leaq 0x50(%rsp), %rdi
callq 0xbee0
movq 0x40(%rsp), %rdi
callq 0x55c0
nop
// File: pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: parsing_phase::sequence(__gnu_cxx::__normal_iterator<tokenize_phase2::token_t const*, std::vector<tokenize_phase2::token_t, std::allocator<tokenize_phase2::token_t>>>, std::unique_ptr<internal_data::expr, std::default_delete<internal_data::expr>>&)
token_seq_type::const_iterator sequence(token_seq_type::const_iterator first, std::unique_ptr<internal_data::expr> &seq){
        token_seq_type::const_iterator iter = first;
        token_seq_type::const_iterator result = expr(seq, iter);
        if(result != first && seq->get_kind() != internal_data::expr::kind::sequence){
            internal_data::sequence *wrapper_seq = new internal_data::sequence;
            std::unique_ptr<internal_data::expr> wrapper(wrapper_seq);
            wrapper_seq->push_back(std::move(seq));
            seq.swap(wrapper);
        }
        return result;
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rsi
callq 0x7cf0
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xc490
testb $0x1, %al
jne 0x865e
jmp 0x871f
movq 0x50(%rsp), %rdi
callq 0xb9c0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x1, %eax
je 0x871f
movl $0x20, %edi
callq 0x5380
movq %rax, %rdi
movq %rdi, (%rsp)
callq 0xc4d0
movq (%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0xbeb0
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xbf40
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xc510
jmp 0x86d6
leaq 0x28(%rsp), %rdi
callq 0xbee0
movq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xbbc0
leaq 0x30(%rsp), %rdi
callq 0xbee0
jmp 0x871f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xbee0
leaq 0x30(%rsp), %rdi
callq 0xbee0
jmp 0x8729
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x55c0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x98(%rsp)
leaq 0x98(%rsp), %rdi
callq 0xc1d0
cmpl $0x1, (%rax)
je 0x878e
movq 0xa8(%rsp), %rax
movq %rax, 0xb0(%rsp)
jmp 0x8934
leaq 0x98(%rsp), %rdi
callq 0xc270
leaq 0x98(%rsp), %rdi
callq 0xc1d0
cmpl $0x0, (%rax)
jne 0x88a4
leaq 0x70(%rsp), %rdi
callq 0xc540
leaq 0x98(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xc1d0
movq 0x8(%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, 0x48(%rsp)
callq 0xc1d0
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x55d0
movq 0x10(%rsp), %rcx
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0xc1e0
jmp 0x8813
leaq 0x78(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movq %rsi, (%rsp)
callq 0x5420
movq (%rsp), %rdi
callq 0x5210
leaq 0x3f(%rsp), %rdi
callq 0x53c0
movq 0xa0(%rsp), %rdi
addq $0x8, %rdi
leaq 0x70(%rsp), %rsi
callq 0xc580
jmp 0x8851
leaq 0x98(%rsp), %rdi
callq 0xc270
leaq 0x70(%rsp), %rdi
callq 0xc5f0
jmp 0x879b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x53c0
jmp 0x8895
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xc5f0
jmp 0x8944
leaq 0x98(%rsp), %rdi
callq 0xc1d0
cmpl $0x3, (%rax)
je 0x88c8
movq 0xa8(%rsp), %rax
movq %rax, 0xb0(%rsp)
jmp 0x8934
leaq 0x98(%rsp), %rdi
callq 0xc270
movq 0x98(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xa0(%rsp), %rsi
addq $0x20, %rsi
movq 0x18(%rsp), %rdi
callq 0x8610
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0xc2c0
testb $0x1, %al
jne 0x8915
jmp 0x8927
movq 0xa8(%rsp), %rax
movq %rax, 0xb0(%rsp)
jmp 0x8934
movq 0x20(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x55c0
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xc1d0
cmpl $0x0, (%rax)
jne 0x8a23
leaq 0x58(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xc1d0
movq (%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
callq 0xc1d0
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x55d0
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0xc1e0
jmp 0x89ce
movq 0x60(%rsp), %rdi
addq $0x8, %rdi
leaq 0x38(%rsp), %rsi
callq 0x5420
leaq 0x38(%rsp), %rdi
callq 0x5210
leaq 0x27(%rsp), %rdi
callq 0x53c0
leaq 0x58(%rsp), %rdi
callq 0xc270
movq (%rax), %rax
movq %rax, 0x70(%rsp)
jmp 0x8a2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x27(%rsp), %rdi
callq 0x53c0
jmp 0x8a37
movq 0x68(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x55c0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x84c0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xc490
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x8e8e
jmp 0x8ea2
leaq 0x18(%rsp), %rdi
callq 0xc1d0
cmpl $0x6, (%rax)
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x8eac
jmp 0x8ed6
leaq 0x18(%rsp), %rdi
callq 0xc1d0
cmpl $0x3, (%rax)
jne 0x8ec5
leaq 0x18(%rsp), %rdi
callq 0xc270
jmp 0x8ec7
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x8e4d
leaq 0x18(%rsp), %rdi
callq 0xc1d0
cmpl $0x6, (%rax)
jne 0x8eec
movb $0x1, 0x37(%rsp)
jmp 0x8ef1
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x20, %edi
callq 0x5380
movq %rax, %rdi
movq %rdi, 0x18(%rsp)
callq 0xc4d0
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdi
movq %rax, 0x58(%rsp)
addq $0x8, %rdi
callq 0x10b60
movq %rax, 0x50(%rsp)
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
callq 0x10bd0
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x10b90
testb $0x1, %al
jne 0x10402
jmp 0x104a6
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x10c00
movq %rax, %rdi
callq 0xb9c0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xbeb0
movq (%rsp), %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xbf40
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xc510
jmp 0x1045f
leaq 0x40(%rsp), %rdi
callq 0xbee0
leaq 0x38(%rsp), %rdi
callq 0xbee0
leaq 0x50(%rsp), %rdi
callq 0x10c10
jmp 0x103d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xbee0
leaq 0x38(%rsp), %rdi
callq 0xbee0
jmp 0x104b0
movq 0x58(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x55c0
nopw (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x20, %edi
callq 0x5380
movq %rax, %rdi
movq %rdi, 0x20(%rsp)
callq 0xc4d0
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rdi
movq %rax, 0x60(%rsp)
addq $0x8, %rdi
callq 0x10b60
movq %rax, 0x58(%rsp)
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x10bd0
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x10b90
testb $0x1, %al
jne 0x1054a
jmp 0x105ff
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x10c00
movq %rax, %rdi
callq 0xb9c0
movq %rax, %rdi
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xbeb0
movq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xbf40
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xc510
jmp 0x105b8
leaq 0x48(%rsp), %rdi
callq 0xbee0
leaq 0x40(%rsp), %rdi
callq 0xbee0
leaq 0x58(%rsp), %rdi
callq 0x10c10
jmp 0x1051f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xbee0
leaq 0x40(%rsp), %rdi
callq 0xbee0
jmp 0x1060c
movq 0x60(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x55c0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x20, %edi
callq 0x5380
movq %rax, %rdi
movq %rdi, 0x18(%rsp)
callq 0xc4d0
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdi
movq %rax, 0x58(%rsp)
addq $0x8, %rdi
callq 0x10b60
movq %rax, 0x50(%rsp)
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
callq 0x10bd0
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x10b90
testb $0x1, %al
jne 0x1069c
jmp 0x1074a
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x10c00
movq %rax, %rdi
callq 0xb9c0
movq %rax, %rdi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xbeb0
movq (%rsp), %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xbf40
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xc510
jmp 0x10703
leaq 0x40(%rsp), %rdi
callq 0xbee0
leaq 0x38(%rsp), %rdi
callq 0xbee0
leaq 0x50(%rsp), %rdi
callq 0x10c10
jmp 0x10671
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xbee0
leaq 0x38(%rsp), %rdi
callq 0xbee0
jmp 0x10754
movq 0x58(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x55c0
nop
// File: pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::sequence::to_str[abi:cxx11]() const
std::string to_str() const override{
            std::string r;
            std::size_t count = 0;
            for(auto &i : vec){
                bool nest = i->get_kind() == kind::sequence || i->get_kind() == kind::lambda;
                if(nest){
                    r += "(";
                }
                r += i->to_str();
                if(nest){
                    r += ")";
                }
                if(count < vec.size() - 1){
                    r += " ";
                }
                ++count;
            }
            return std::move(r);
        }

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x54e0
movq 0x30(%rsp), %rax
movq $0x0, 0x90(%rsp)
addq $0x8, %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rdi
callq 0x10b60
movq %rax, 0x80(%rsp)
movq 0x88(%rsp), %rdi
callq 0x10bd0
movq %rax, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x10b90
testb $0x1, %al
jne 0x107fd
jmp 0x1097f
leaq 0x80(%rsp), %rdi
callq 0x10c00
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0xb9c0
movq %rax, %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, 0x1c(%rsp)
jmp 0x1082a
movl 0x1c(%rsp), %ecx
movb $0x1, %al
cmpl $0x1, %ecx
movb %al, 0x1b(%rsp)
je 0x10862
movq 0x70(%rsp), %rdi
callq 0xb9c0
movq %rax, %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, 0x14(%rsp)
jmp 0x10854
movl 0x14(%rsp), %eax
cmpl $0x2, %eax
sete %al
movb %al, 0x1b(%rsp)
movb 0x1b(%rsp), %al
andb $0x1, %al
movb %al, 0x6f(%rsp)
testb $0x1, 0x6f(%rsp)
je 0x1089e
leaq 0xaaa8(%rip), %rsi      # 0x1b322
leaq 0x98(%rsp), %rdi
callq 0x5360
jmp 0x10889
jmp 0x1089e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x109ab
movq 0x70(%rsp), %rdi
callq 0xb9c0
movq %rax, %rsi
movq (%rsi), %rax
movq 0x20(%rax), %rax
leaq 0x38(%rsp), %rdi
callq *%rax
jmp 0x108bb
leaq 0x98(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5470
jmp 0x108cf
leaq 0x38(%rsp), %rdi
callq 0x5210
testb $0x1, 0x6f(%rsp)
je 0x10915
leaq 0xaaa9(%rip), %rsi      # 0x1b390
leaq 0x98(%rsp), %rdi
callq 0x5360
jmp 0x108f6
jmp 0x10915
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5210
jmp 0x109ab
movq 0x30(%rsp), %rdi
movq 0x90(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0xbba0
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x10959
leaq 0xa9df(%rip), %rsi      # 0x1b327
leaq 0x98(%rsp), %rdi
callq 0x5360
jmp 0x10957
jmp 0x10959
movq 0x90(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x90(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x10c10
jmp 0x107e2
movq 0x20(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x51f0
leaq 0x98(%rsp), %rdi
callq 0x5210
movq 0x28(%rsp), %rax
addq $0xc8, %rsp
retq
leaq 0x98(%rsp), %rdi
callq 0x5210
movq 0x60(%rsp), %rdi
callq 0x55c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x1, %eax
je 0x10a01
movb $0x0, 0x57(%rsp)
jmp 0x10ab9
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rsp)
addq $0x8, %rdi
callq 0x10b60
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x10b60
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x10bd0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x10b90
testb $0x1, %al
jne 0x10a5f
jmp 0x10ab4
leaq 0x20(%rsp), %rdi
callq 0x10c00
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xb9c0
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x10c60
movq (%rsp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0x10a9e
movb $0x0, 0x57(%rsp)
jmp 0x10ab9
leaq 0x30(%rsp), %rdi
callq 0x10c10
leaq 0x20(%rsp), %rdi
callq 0x10c10
jmp 0x10a4a
movb $0x1, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x48(%rsp), %rsi
movq %rsi, 0x8(%rsp)
movq 0x40(%rsp), %rdi
addq $0x8, %rsi
callq 0x10f50
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0x10fa0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x10f80
testb $0x1, %al
jne 0x10d59
jmp 0x10d7c
movq 0x30(%rsp), %rax
movb $0x1, (%rax)
leaq 0x28(%rsp), %rdi
callq 0x10fd0
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, 0x50(%rsp)
jmp 0x10df6
movq 0x8(%rsp), %rsi
movq 0x38(%rsp), %rdi
addq $0x8, %rsi
callq 0x10ff0
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x11040
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x11020
testb $0x1, %al
jne 0x10db8
jmp 0x10de6
movq 0x30(%rsp), %rax
movb $0x1, (%rax)
leaq 0x18(%rsp), %rdi
callq 0x11070
movq %rax, %rdi
addq $0x20, %rdi
callq 0xb9c0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, 0x50(%rsp)
jmp 0x10df6
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rsi
movq %rsi, (%rsp)
movq 0x20(%rsp), %rdi
addq $0x8, %rsi
callq 0x10f50
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x10fa0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x10f80
testb $0x1, %al
jne 0x10e53
jmp 0x10e76
movq 0x18(%rsp), %rax
movb $0x1, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x10fd0
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, 0x30(%rsp)
jmp 0x10e85
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x28, %edi
callq 0x5380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x28(%rsp)
callq 0xc630
jmp 0x117c8
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x98(%rsp)
addq $0x8, %rdi
callq 0x124c0
movq %rax, 0x80(%rsp)
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
callq 0x12530
movq %rax, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x124f0
testb $0x1, %al
jne 0x11819
jmp 0x118bd
leaq 0x50(%rsp), %rdi
callq 0xc540
leaq 0x80(%rsp), %rdi
callq 0x12560
movq %rax, %rsi
addq $0x8, %rsi
leaq 0x58(%rsp), %rdi
callq 0x5040
jmp 0x11843
movq 0x98(%rsp), %rdi
addq $0x8, %rdi
leaq 0x50(%rsp), %rsi
callq 0xc580
jmp 0x1185b
leaq 0x50(%rsp), %rdi
callq 0xc5f0
leaq 0x80(%rsp), %rdi
callq 0x12570
jmp 0x117eb
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
callq 0x5350
jmp 0x119cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xc5f0
jmp 0x119cf
movq 0x20(%rsp), %rdi
callq 0xbfa0
movq %rax, %rdi
addq $0x8, %rdi
callq 0xbad0
movq %rax, 0x48(%rsp)
movq 0x20(%rsp), %rdi
callq 0xbfa0
movq %rax, %rdi
addq $0x8, %rdi
callq 0xbb00
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xbb30
testb $0x1, %al
jne 0x1190b
jmp 0x119bf
movq 0x98(%rsp), %rdi
callq 0xbfa0
movq %rax, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xbb70
movq %rax, %rdi
callq 0xb9c0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xbeb0
movq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xbf40
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xc510
jmp 0x11972
leaq 0x38(%rsp), %rdi
callq 0xbee0
leaq 0x30(%rsp), %rdi
callq 0xbee0
leaq 0x48(%rsp), %rdi
callq 0xbb80
jmp 0x118d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xbee0
leaq 0x30(%rsp), %rdi
callq 0xbee0
jmp 0x119cf
movq 0x98(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x90(%rsp), %rdi
callq 0x55c0
nopl (%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq 0xa0(%rsp), %rsi
movq %rsi, 0x20(%rsp)
movq 0x98(%rsp), %rdx
leaq 0x58(%rsp), %rdi
callq 0x125c0
movl $0x28, %edi
callq 0x5380
movq %rax, 0x28(%rsp)
jmp 0x11a37
movq 0x28(%rsp), %rdi
callq 0xc630
jmp 0x11a43
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
addq $0x8, %rsi
movq 0x50(%rsp), %rdi
addq $0x8, %rdi
callq 0x12750
jmp 0x11a66
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
callq 0xb9c0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movq %rax, 0x18(%rsp)
jmp 0x11a87
movq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xbeb0
movq 0x8(%rsp), %rsi
movq 0x50(%rsp), %rdi
addq $0x20, %rdi
callq 0xbbc0
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
callq 0xb9c0
movq %rax, %rdi
movq 0x90(%rsp), %rdx
movq 0x88(%rsp), %rcx
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq 0x58(%rsp), %rsi
callq *%rax
movq %rax, 0x10(%rsp)
jmp 0x11ae4
movq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0xbeb0
movq 0x50(%rsp), %rsi
addq $0x20, %rsi
leaq 0x30(%rsp), %rdi
callq 0xbbc0
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rdi
callq 0xbee0
leaq 0x38(%rsp), %rdi
callq 0xbee0
leaq 0x58(%rsp), %rdi
callq 0xbc20
movq (%rsp), %rax
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x11b7b
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x5350
jmp 0x11b7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xbee0
leaq 0x58(%rsp), %rdi
callq 0xbc20
movq 0x48(%rsp), %rdi
callq 0x55c0
nop
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rsi
movq %rsi, 0x28(%rsp)
movq 0x98(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x125c0
movl $0x28, %edi
callq 0x5380
movq %rax, 0x30(%rsp)
jmp 0x11bdf
movq 0x30(%rsp), %rdi
callq 0xc630
jmp 0x11beb
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rax
movq %rax, 0x58(%rsp)
addq $0x8, %rsi
movq 0x58(%rsp), %rdi
addq $0x8, %rdi
callq 0x12750
jmp 0x11c0e
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
callq 0xb9c0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movq %rax, 0x20(%rsp)
jmp 0x11c2f
movq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xbeb0
movq 0x10(%rsp), %rsi
movq 0x58(%rsp), %rdi
addq $0x20, %rdi
callq 0xbbc0
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
callq 0xb9c0
movq %rax, %rdi
movq 0x90(%rsp), %rdx
movq (%rdi), %rax
movq 0x18(%rax), %rax
leaq 0x60(%rsp), %rsi
callq *%rax
movq %rax, 0x18(%rsp)
jmp 0x11c84
movq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0xbeb0
movq 0x58(%rsp), %rsi
addq $0x20, %rsi
leaq 0x38(%rsp), %rdi
callq 0xbbc0
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xbee0
leaq 0x40(%rsp), %rdi
callq 0xbee0
leaq 0x60(%rsp), %rdi
callq 0xbc20
movq 0x8(%rsp), %rax
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x11d1d
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x5350
jmp 0x11d1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xbee0
leaq 0x60(%rsp), %rdi
callq 0xbc20
movq 0x50(%rsp), %rdi
callq 0x55c0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0xa8(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x54e0
movq 0x28(%rsp), %rdi
leaq 0x9595(%rip), %rsi      # 0x1b324
callq 0x5360
jmp 0x11d96
movq 0x20(%rsp), %rax
movq $0x0, 0x90(%rsp)
addq $0x8, %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rdi
callq 0x124c0
movq %rax, 0x80(%rsp)
movq 0x88(%rsp), %rdi
callq 0x12530
movq %rax, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x124f0
testb $0x1, %al
jne 0x11df5
jmp 0x11ee0
leaq 0x80(%rsp), %rdi
callq 0x12a40
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rsi
movq (%rsi), %rax
movq 0x20(%rax), %rax
leaq 0x50(%rsp), %rdi
callq *%rax
jmp 0x11e1c
leaq 0xa8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x5470
jmp 0x11e30
leaq 0x50(%rsp), %rdi
callq 0x5210
movq 0x20(%rsp), %rdi
movq 0x90(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0xbc70
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x11eba
leaq 0x94ba(%rip), %rsi      # 0x1b327
leaq 0xa8(%rsp), %rdi
callq 0x5360
jmp 0x11e7c
jmp 0x11eba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x11f7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5210
jmp 0x11f7f
movq 0x90(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x90(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x12570
jmp 0x11dda
leaq 0x943f(%rip), %rsi      # 0x1b326
leaq 0xa8(%rsp), %rdi
callq 0x5360
jmp 0x11ef6
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
callq 0xb9c0
movq %rax, %rsi
movq (%rsi), %rax
movq 0x20(%rax), %rax
leaq 0x30(%rsp), %rdi
callq *%rax
jmp 0x11f17
leaq 0xa8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x5470
jmp 0x11f2b
leaq 0x30(%rsp), %rdi
callq 0x5210
movq 0x10(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x51f0
leaq 0xa8(%rsp), %rdi
callq 0x5210
movq 0x18(%rsp), %rax
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5210
leaq 0xa8(%rsp), %rdi
callq 0x5210
movq 0xa0(%rsp), %rdi
callq 0x55c0
nopl (%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xb0(%rsp), %rsi
leaq 0x80(%rsp), %rdi
callq 0x12a10
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0x124c0
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x12530
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x124f0
testb $0x1, %al
jne 0x12652
jmp 0x1270c
leaq 0x70(%rsp), %rdi
callq 0x12a40
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rsi
addq $0x8, %rsi
leaq 0x80(%rsp), %rdi
callq 0x12a50
movq %rax, 0x10(%rsp)
jmp 0x1267e
movq 0x10(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x12aa0
movq %rax, 0x40(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x12a80
testb $0x1, %al
jne 0x126af
jmp 0x126fb
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x80(%rsp), %rdi
callq 0x12ad0
movq %rax, 0x8(%rsp)
jmp 0x126d2
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x126fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xbc20
jmp 0x12738
jmp 0x126fd
leaq 0x70(%rsp), %rdi
callq 0x12570
jmp 0x1263a
movq 0x18(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x12b10
leaq 0x80(%rsp), %rdi
callq 0xbc20
movq 0x20(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x55c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: UTSASRG[P]Guarder/real.cpp
// Function: Real::initializer()
void initializer() {
		INIT_WRAPPER(free, RTLD_NEXT);
//		INIT_WRAPPER(calloc, RTLD_NEXT);
		INIT_WRAPPER(malloc, RTLD_NEXT);
//		INIT_WRAPPER(realloc, RTLD_NEXT);
		
		// FIXME about the flags
		void *pthread_handle = dlopen("libpthread.so.0", RTLD_NOW | RTLD_GLOBAL | RTLD_NOLOAD);
		INIT_WRAPPER(pthread_create, pthread_handle);
		INIT_WRAPPER(pthread_join, pthread_handle);
		INIT_WRAPPER(pthread_kill, pthread_handle);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $-0x1, %rdi
leaq 0x655a(%rip), %rsi      # 0xc000
callq 0x5460
movq %rax, %rcx
movq 0xb503(%rip), %rax      # 0x10fb8
movq %rcx, (%rax)
movq $-0x1, %rdi
leaq 0x653f(%rip), %rsi      # 0xc005
callq 0x5460
movq %rax, %rcx
movq 0xb44b(%rip), %rax      # 0x10f20
movq %rcx, (%rax)
leaq 0x652d(%rip), %rdi      # 0xc00c
movl $0x106, %esi            # imm = 0x106
callq 0x56c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x6524(%rip), %rsi      # 0xc01c
callq 0x5460
movq %rax, %rcx
movq 0xb3f9(%rip), %rax      # 0x10f00
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
leaq 0x6516(%rip), %rsi      # 0xc02b
callq 0x5460
movq %rax, %rcx
movq 0xb4b4(%rip), %rax      # 0x10fd8
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
leaq 0x6506(%rip), %rsi      # 0xc038
callq 0x5460
movq %rax, %rcx
movq 0xb3ef(%rip), %rax      # 0x10f30
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa40, %rsp            # imm = 0xA40
leaq -0x800(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x5730
movl %eax, -0x804(%rbp)
leaq -0x910(%rbp), %rsi
leaq 0x6358(%rip), %rdi      # 0xc058
movl $0x100, %edx            # imm = 0x100
callq 0x5500
xorl %eax, %eax
movl %eax, %edi
callq 0x53d0
movl %eax, -0x914(%rbp)
movl $0x0, -0xa24(%rbp)
movl -0xa24(%rbp), %eax
cmpl -0x804(%rbp), %eax
jge 0x5dee
movslq -0xa24(%rbp), %rax
movq -0x800(%rbp,%rax,8), %rax
subq $0x1, %rax
movq %rax, -0xa30(%rbp)
callq 0x52d0
movq %rax, %rdi
movl -0x914(%rbp), %ecx
movl -0xa24(%rbp), %r8d
movq -0xa30(%rbp), %r9
movl $0x1000, %esi           # imm = 0x1000
leaq 0x62f0(%rip), %rdx      # 0xc067
movb $0x0, %al
callq 0x57e0
callq 0x52d0
movq %rax, -0xa38(%rbp)
callq 0x52d0
movq %rax, %rdi
callq 0x51e0
movq -0xa38(%rbp), %rsi
movq %rax, %rdx
movl $0x2, %edi
callq 0x5160
leaq -0xa20(%rbp), %rdi
leaq -0x910(%rbp), %rdx
movq -0xa30(%rbp), %rcx
leaq 0x62d2(%rip), %rsi      # 0xc099
movb $0x0, %al
callq 0x50a0
leaq -0xa20(%rbp), %rdi
callq 0x53e0
movl -0xa24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa24(%rbp)
jmp 0x5d23
addq $0xa40, %rsp            # imm = 0xA40
popq %rbp
retq
nopw (%rax,%rax)
// File: UTSASRG[P]Guarder/libguarder.cpp
// Function: heapinitialize()
void heapinitialize() {
	if(heapInitStatus == E_HEAP_INIT_NOT) {
		heapInitStatus = E_HEAP_INIT_WORKING;
		parseEnvOpts();
		#ifndef NDEBUG
		debugPrintOptions();
		#endif
    SRAND(time(NULL));
		BibopHeap::getInstance().initialize();
		heapInitStatus = E_HEAP_INIT_DONE;
		// The following function will invoke dlopen and will call malloc in the end.
		// Thus, it is putted in the end so that it won't fail
		Real::initializer();
		xthread::getInstance().initialize();
		BigHeap::getInstance().initBigHeap();
	} else {
			while(heapInitStatus != E_HEAP_INIT_DONE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb135(%rip), %rax      # 0x10f50
cmpl $0x0, (%rax)
jne 0x5e82
movq 0xb129(%rip), %rax      # 0x10f50
movl $0x1, (%rax)
callq 0x5230
callq 0x5270
xorl %eax, %eax
movl %eax, %edi
callq 0x5440
movl %eax, %edi
callq 0x54a0
callq 0x5170
movq %rax, %rdi
callq 0x5830
movq 0xb0f5(%rip), %rax      # 0x10f50
movl $0x2, (%rax)
callq 0x5450
callq 0x5370
movq %rax, %rdi
callq 0x5620
callq 0x5130
movq %rax, %rdi
callq 0x50f0
jmp 0x5e94
jmp 0x5e84
movq 0xb0c5(%rip), %rax      # 0x10f50
cmpl $0x2, (%rax)
je 0x5e92
jmp 0x5e84
jmp 0x5e94
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5ebf
movq 0xb096(%rip), %rax      # 0x10f50
cmpl $0x2, (%rax)
je 0x5ec4
jmp 0x5f81
callq 0x5170
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x50d0
testb $0x1, %al
jne 0x5edb
jmp 0x5ef1
callq 0x5170
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x54f0
jmp 0x5f81
callq 0x5130
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x5650
testb $0x1, %al
jne 0x5f08
jmp 0x5f1b
callq 0x5130
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x5790
jmp 0x5f7f
callq 0x52d0
movq %rax, -0x18(%rbp)
callq 0x5400
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movq -0x8(%rbp), %rax
movl $0x1000, %esi           # imm = 0x1000
leaq 0x6488(%rip), %rdx      # 0xc3c8
leaq 0x61b2(%rip), %r8       # 0xc0f9
movl $0x116, %r9d            # imm = 0x116
movq %rax, (%rsp)
movb $0x0, %al
callq 0x57e0
callq 0x52d0
movq %rax, -0x10(%rbp)
callq 0x52d0
movq %rax, %rdi
callq 0x51e0
movq -0x10(%rbp), %rsi
movq %rax, %rdx
movl $0x2, %edi
callq 0x5160
jmp 0x5f81
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: UTSASRG[P]Guarder/libguarder.cpp
// Function: xxmalloc
void * xxmalloc(size_t size) {
    if(heapInitStatus != E_HEAP_INIT_DONE) {
			heapinitialize();
    }

		// Calculate the proper bag size needed to fulfill this request
		if(IF_CANARY_CONDITION) {
			numLargeObjects++;
			return BigHeap::getInstance().allocateAtBigHeap(size);
		} else {
			return BibopHeap::getInstance().allocateSmallObject(size);
		}

		return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq 0xafad(%rip), %rax      # 0x10f50
cmpl $0x2, (%rax)
je 0x5fad
callq 0x54b0
cmpq $0x80000, -0x10(%rbp)   # imm = 0x80000
jbe 0x5fe6
movq 0xaf32(%rip), %rax      # 0x10ef0
movq (%rax), %rcx
addq $0x1, %rcx
movq 0xaf24(%rip), %rax      # 0x10ef0
movq %rcx, (%rax)
callq 0x5130
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x57c0
movq %rax, -0x8(%rbp)
jmp 0x5ffb
callq 0x5170
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x56f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)