LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::break_node<double>::value() const
inline T value() const exprtk_override
         {
            const T result = return_.first ?
                             return_.first->value() :
                             std::numeric_limits<T>::quiet_NaN();

            throw break_exception<T>(result);

            #if !defined(_MSC_VER) && !defined(__NVCOMPILER)
            return std::numeric_limits<T>::quiet_NaN();
            #endif
         }

// Assembly:
pushq %rax
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
jne 0x352608
movsd 0x5fc0a(%rip), %xmm0    # 0x3b2210
jmp 0x35260e
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movl $0x8, %edi
callq 0x1201f0
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
leaq 0x218ec3(%rip), %rsi    # 0x56b4f0
movq %rax, %rdi
xorl %edx, %edx
callq 0x120310
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::is_reserved_symbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool is_reserved_symbol(const std::string& symbol)
      {
         for (std::size_t i = 0; i < reserved_symbols_size; ++i)
         {
            if (imatch(symbol, reserved_symbols[i]))
            {
               return true;
            }
         }

         return false;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rdi), %r15
testq %r15, %r15
sete %r14b
movb $0x1, %bl
xorl %r12d, %r12d
leaq 0x22805d(%rip), %rdx    # 0x57a780
movb %r14b, 0xf(%rsp)
movq %r12, %rax
shlq $0x5, %rax
cmpq 0x8(%rax,%rdx), %r15
jne 0x3527af
movl %r14d, %ecx
testq %r15, %r15
je 0x3527ab
addq %rdx, %rax
movq (%rax), %r13
movq 0x10(%rsp), %rax
movsbl (%rax), %edi
callq 0x120450
movl %eax, %ebp
movsbl (%r13), %edi
callq 0x120450
leaq 0x22801c(%rip), %rdx    # 0x57a780
cmpl %eax, %ebp
jne 0x3527af
movl $0x1, %ecx
movq %rcx, %r14
cmpq %rcx, %r15
je 0x352799
movq 0x10(%rsp), %rax
movsbl (%rax,%r14), %edi
callq 0x120450
movl %eax, %ebp
movsbl (%r13,%r14), %edi
callq 0x120450
leaq 0x1(%r14), %rcx
cmpl %eax, %ebp
je 0x35276d
cmpq %r15, %r14
setae %cl
movb 0xf(%rsp), %r14b
leaq 0x227fd5(%rip), %rdx    # 0x57a780
testb %cl, %cl
jne 0x3527c8
cmpq $0x58, %r12
leaq 0x1(%r12), %rax
setb %bl
movq %rax, %r12
cmpq $0x59, %rax
jne 0x352728
andb $0x1, %bl
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_element_manager::get_active_element(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
inline scope_element& get_active_element(const std::string& var_name,
                                                  const std::size_t index = std::numeric_limits<std::size_t>::max())
         {
            const std::size_t current_depth = parser_.state_.scope_depth;

            for (std::size_t i = 0; i < element_.size(); ++i)
            {
               scope_element& se = element_[i];

               if (se.depth > current_depth)
                  continue;
               else if (
                         details::imatch(se.name, var_name) &&
                         (se.index == index)                &&
                         (se.active)
                       )
                  return se;
            }

            return null_element_;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0x10(%rdi), %rax
movq 0x8(%rdi), %r8
subq %r8, %rax
setne %r15b
movq %rdi, 0x48(%rsp)
je 0x3589ca
movq (%rdi), %rcx
sarq $0x4, %rax
movabsq $0x6db6db6db6db6db7, %rdi # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rdi
movq 0x3b0(%rcx), %rcx
movq (%rsi), %rax
movq %rax, 0x40(%rsp)
movq 0x8(%rsi), %rsi
cmpq $0x1, %rdi
movq %rdi, %r9
adcq $0x0, %r9
xorl %r14d, %r14d
movq %rdx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %r9, 0x10(%rsp)
imulq $0x70, %r14, %r13
movl $0x4, %eax
cmpq %rcx, 0x30(%r8,%r13)
ja 0x3589ab
addq %r8, %r13
movq 0x8(%r13), %r12
cmpq %rsi, %r12
jne 0x35896f
testq %r12, %r12
sete %al
je 0x358993
movq (%r13), %rax
movq %rax, 0x50(%rsp)
movsbl (%rax), %edi
callq 0x120450
movl %eax, %ebp
movq 0x40(%rsp), %rax
movsbl (%rax), %edi
callq 0x120450
cmpl %eax, %ebp
jne 0x358973
movb %r15b, 0xf(%rsp)
movl $0x1, %ecx
movq %rcx, %r15
cmpq %rcx, %r12
je 0x358962
movq 0x50(%rsp), %rax
movsbl (%rax,%r15), %edi
callq 0x120450
movl %eax, %ebp
movq 0x40(%rsp), %rax
movsbl (%rax,%r15), %edi
callq 0x120450
leaq 0x1(%r15), %rcx
cmpl %eax, %ebp
je 0x358932
cmpq %r12, %r15
setae %al
movb 0xf(%rsp), %r15b
jmp 0x358975
xorl %eax, %eax
jmp 0x358993
xorl %eax, %eax
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %r9
testb %al, %al
je 0x3589a9
cmpq %rdx, 0x28(%r13)
jne 0x3589a9
movl $0x1, %eax
cmpb $0x0, 0x4c(%r13)
jne 0x3589ae
xorl %eax, %eax
movq %rbx, %r13
testb $0x3, %al
jne 0x3589ca
incq %r14
cmpq %rdi, %r14
setb %r15b
movq %r13, %rbx
cmpq %r9, %r14
jne 0x3588d8
jmp 0x3589ca
movq 0x48(%rsp), %rax
addq $0x20, %rax
testb $0x1, %r15b
cmovneq %r13, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::parser_helper::token_is(exprtk::lexer::token::token_type const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::lexer::parser_helper::token_advance_mode)
inline bool token_is(const token_t::token_type& ttype,
                              const std::string& value,
                              const token_advance_mode mode = e_advance)
         {
            if (
                 (current_token().type != ttype) ||
                 !exprtk::details::imatch(value,current_token().value)
               )
            {
               return false;
            }

            advance_token(mode);

            return true;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x70(%rdi), %eax
cmpl (%rsi), %eax
jne 0x358b1b
movq %rdi, %rbx
movq 0x8(%rdx), %r15
cmpq 0x80(%rdi), %r15
jne 0x358b1b
movl %ecx, %ebp
testq %r15, %r15
sete %al
je 0x358afb
movq (%rdx), %r12
movq 0x78(%rbx), %r13
movsbl (%r12), %edi
callq 0x120450
movl %eax, %r14d
movsbl (%r13), %edi
callq 0x120450
cmpl %eax, %r14d
jne 0x358b1b
movl %ebp, 0x4(%rsp)
movl $0x1, %ecx
movq %rcx, %rbp
cmpq %rcx, %r15
je 0x358af1
movsbl (%r12,%rbp), %edi
callq 0x120450
movl %eax, %r14d
movsbl (%r13,%rbp), %edi
callq 0x120450
leaq 0x1(%rbp), %rcx
cmpl %eax, %r14d
je 0x358ac8
cmpq %r15, %rbp
setae %al
movl 0x4(%rsp), %ebp
testb %al, %al
je 0x358b1b
movb $0x1, %r14b
cmpl $0x1, %ebp
jne 0x358b1e
movq 0x18(%rbx), %r15
cmpq %r15, 0x8(%rbx)
je 0x358b30
leaq 0x30(%r15), %rax
movq %rax, 0x18(%rbx)
jmp 0x358b34
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%rbx), %r15
movl (%r15), %eax
movl %eax, 0x70(%rbx)
leaq 0x78(%rbx), %rdi
leaq 0x8(%r15), %rsi
callq 0x1205a0
movq 0x28(%r15), %rax
movq %rax, 0x98(%rbx)
jmp 0x358b1e
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::vector_init_zero_value_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::vector_init_zero_value_node<double>, double*, unsigned long, std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>>>(double* const&, unsigned long const&, std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&) const
inline expression_node<typename node_type::value_type>* allocate(const T1& t1, const T2& t2,
                                                                          const T3& t3) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl $0x48, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r12), %rax
movb $0x0, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
leaq 0x21a18f(%rip), %rcx    # 0x572d18
movq %rcx, (%rbx)
leaq 0x21a1d5(%rip), %rcx    # 0x572d68
movq %rcx, 0x8(%rbx)
movq %rax, 0x20(%rbx)
movq (%r15), %rax
movq %rax, 0x28(%rbx)
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x358f82
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x48, %esi
movq %rbx, %rdi
callq 0x1200c0
movq %r14, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::vector_initialisation_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::vector_initialisation_node<double>, double*, unsigned long, std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>>, bool>(double* const&, unsigned long const&, std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&, bool const&) const
inline expression_node<typename node_type::value_type>* allocate(const T1& t1, const T2& t2,
                                                                          const T3& t3, const T4& t4) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3, t4));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movl $0x58, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r13), %rsi
movzbl (%r14), %r8d
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x359dba
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x58, %esi
movq %rbx, %rdi
callq 0x1200c0
movq %r14, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::details::node_depth_base<exprtk::details::expression_node<double>>::compute_node_depth<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&) const
std::size_t compute_node_depth(const Sequence<node_ptr_t, Allocator>& branch_list) const
         {
            if (!depth_set)
            {
               for (std::size_t i = 0; i < branch_list.size(); ++i)
               {
                  if (branch_list[i])
                  {
                     depth = std::max(depth, compute_node_depth(branch_list[i]));
                  }
               }

               depth_set = true;
            }

            return depth;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x8(%rdi)
jne 0x3591da
movq %rsi, %r14
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x3591d6
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x3591c0
cmpb $0x0, 0x8(%rbx)
jne 0x3591c0
movq 0x8(%rdi), %rax
addq $0x8, %rdi
callq *0x10(%rax)
incq %rax
movq %rax, 0x10(%rbx)
movb $0x1, 0x8(%rbx)
incq %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jb 0x35919b
movb $0x1, 0x8(%rbx)
movq 0x10(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_single_constvalue_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return vector_base_ &&
                   (initialiser_list_.size() == 1) &&
                   (details::is_constant_node(initialiser_list_[0])) &&
                   (single_initialiser_value_ != T(0));
         }

// Assembly:
cmpq $0x0, 0x20(%rdi)
je 0x359345
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0x35933b
movq (%rax), %r14
testq %r14, %r14
je 0x35933b
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x359327
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
jne 0x35933b
xorpd %xmm0, %xmm0
cmpneqsd 0x48(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x35933d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_single_value_node<double>::value() const
inline T value() const exprtk_override
         {
            expression_node<T>& node = *initialiser_list_[0];

            for (std::size_t i = 0; i < size_; ++i)
            {
               *(vector_base_ + i) = node.value();
            }

            return *(vector_base_);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x359433
movq 0x30(%rbx), %rax
movq (%rax), %r14
xorl %r15d, %r15d
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq 0x20(%rbx), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
cmpq 0x28(%rbx), %r15
jb 0x359417
movq 0x20(%rbx), %rax
movsd (%rax), %xmm0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_constconst_node<double>::value() const
inline T value() const exprtk_override
         {
            T value = base_value_;

            for (std::size_t i = 0; i < size_; ++i, value += increment_value_)
            {
               *(vector_base_ + i) = value;
            }

            return *(vector_base_);
         }

// Assembly:
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x3595fe
movsd 0x48(%rdi), %xmm0
movq 0x20(%rdi), %rcx
xorl %edx, %edx
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
addsd 0x50(%rdi), %xmm0
cmpq %rdx, %rax
jne 0x3595ec
movq 0x20(%rdi), %rax
movsd (%rax), %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_constconst_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return vector_base_ &&
                   (initialiser_list_.size() == 2) &&
                   (details::is_constant_node(initialiser_list_[0])) &&
                   (details::is_constant_node(initialiser_list_[1])) ;
         }

// Assembly:
cmpq $0x0, 0x20(%rdi)
je 0x35968b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rcx
subq %rax, %rcx
cmpq $0x10, %rcx
jne 0x359681
movq (%rax), %r14
testq %r14, %r14
je 0x359681
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x359651
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
jne 0x359681
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rbx
testq %rbx, %rbx
je 0x359681
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movl %eax, %ecx
movb $0x1, %al
cmpl $0x2, %ecx
je 0x359683
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
sete %al
jmp 0x359683
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_constnconst_node<double>::value() const
inline T value() const exprtk_override
         {
            T value = base_value_;
            expression_node<T>& increment = *initialiser_list_[1];

            for (std::size_t i = 0; i < size_; ++i, value += increment.value())
            {
               *(vector_base_ + i) = value;
            }

            return *(vector_base_);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x359819
movq 0x30(%rbx), %rax
movq 0x8(%rax), %r14
movsd 0x48(%rbx), %xmm0
xorl %r15d, %r15d
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rbx), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
cmpq 0x28(%rbx), %r15
jb 0x3597e1
movq 0x20(%rbx), %rax
movsd (%rax), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_nconstconst_node<double>::value() const
inline T value() const exprtk_override
         {
            T value = initialiser_list_[0]->value();
            const T increment = initialiser_list_[1]->value();

            for (std::size_t i = 0; i < size_; ++i, value += increment)
            {
               *(vector_base_ + i) = value;
            }

            return *(vector_base_);
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd 0x8(%rsp), %xmm1
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x3599b7
movq 0x20(%rbx), %rcx
xorl %edx, %edx
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
addsd %xmm0, %xmm1
cmpq %rdx, %rax
jne 0x3599a6
movq 0x20(%rbx), %rax
movsd (%rax), %xmm0
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_nconstnconst_node<double>::value() const
inline T value() const exprtk_override
         {
            T value = initialiser_list_[0]->value();
            expression_node<T>& increment = *initialiser_list_[1];

            for (std::size_t i = 0; i < size_; ++i, value += increment.value())
            {
               *(vector_base_ + i) = value;
            }

            return *(vector_base_);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpq $0x0, 0x28(%rbx)
je 0x359b65
movq 0x30(%rbx), %rax
movq 0x8(%rax), %r14
xorl %r15d, %r15d
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rbx), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
cmpq 0x28(%rbx), %r15
jb 0x359b2d
movq 0x20(%rbx), %rax
movsd (%rax), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_initialisation_node<double>::value() const
inline T value() const exprtk_override
         {
            if (single_value_initialse_)
            {
               if (zero_value_initialse_)
               {
                  details::set_zero_value(vector_base_, size_);
               }
               else if (const_nonzero_literal_value_initialse_)
               {
                  for (std::size_t i = 0; i < size_; ++i)
                  {
                     *(vector_base_ + i) = single_initialiser_value_;
                  }
               }
               else
               {
                  for (std::size_t i = 0; i < size_; ++i)
                  {
                     *(vector_base_ + i) = initialiser_list_[0]->value();
                  }
               }
            }
            else
            {
               const std::size_t initialiser_list_size = initialiser_list_.size();

               for (std::size_t i = 0; i < initialiser_list_size; ++i)
               {
                  *(vector_base_ + i) = initialiser_list_[i]->value();
               }

               if (initialiser_list_size < size_)
               {
                  details::set_zero_value(
                     vector_base_ + initialiser_list_size,
                     (size_ - initialiser_list_size));
               }
            }

            return *(vector_base_);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x48(%rdi)
jne 0x359f50
cmpb $0x1, 0x49(%rbx)
jne 0x359fc2
movq 0x20(%rbx), %r14
movq 0x40(%rbx), %rdx
jmp 0x359fa2
movq 0x30(%rbx), %r14
movq 0x28(%rbx), %rax
movq %r14, %r15
subq %rax, %r15
sarq $0x3, %r15
subq %rax, %r14
je 0x359f95
cmpq $0x1, %r15
movq %r15, %r12
adcq $0x0, %r12
xorl %r13d, %r13d
movq 0x28(%rbx), %rax
movq (%rax,%r13,8), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x20(%rbx), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x359f75
movq 0x40(%rbx), %rdx
subq %r15, %rdx
jbe 0x359fb0
addq 0x20(%rbx), %r14
shlq $0x3, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x120180
movq 0x20(%rbx), %rax
movsd (%rax), %xmm0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x40(%rbx), %rax
cmpb $0x0, 0x4a(%rbx)
je 0x359feb
testq %rax, %rax
je 0x359fb0
movq 0x20(%rbx), %rcx
xorl %edx, %edx
movsd 0x50(%rbx), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x359fd7
jmp 0x359fb0
testq %rax, %rax
je 0x359fb0
xorl %r14d, %r14d
movq 0x28(%rbx), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x20(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
cmpq 0x40(%rbx), %r14
jb 0x359ff3
jmp 0x359fb0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::stringvar_node<double>::stringvar_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
explicit stringvar_node(std::string& v)
         : value_(&v)
         {
            rp_.n0_c = std::make_pair<bool,std::size_t>(true,0);
            rp_.n1_c = std::make_pair<bool,std::size_t>(true,v.size());
            rp_.cache.first  = rp_.n0_c.second;
            rp_.cache.second = rp_.n1_c.second;
         }

// Assembly:
xorl %eax, %eax
movb %al, 0x10(%rdi)
movq %rax, 0x18(%rdi)
leaq 0x219102(%rip), %rcx    # 0x573198
movq %rcx, (%rdi)
leaq 0x219168(%rip), %rcx    # 0x573208
movq %rcx, 0x8(%rdi)
leaq 0x219185(%rip), %rcx    # 0x573230
movq %rcx, 0x20(%rdi)
leaq 0x2191b2(%rip), %rcx    # 0x573268
movq %rcx, 0x28(%rdi)
movq %rsi, 0x30(%rdi)
movb %al, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movb %al, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movq %rax, 0x60(%rdi)
movb %al, 0x68(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rdi)
movq %rax, 0x80(%rdi)
movb $0x1, %cl
movb %cl, 0x58(%rdi)
movq 0x8(%rsi), %rdx
movb %cl, 0x68(%rdi)
movq %rdx, 0x70(%rdi)
movq %rax, 0x78(%rdi)
movq %rdx, 0x80(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::interval_container_t<void const*, exprtk::parser<double>::halfopen_range_policy<void const*>>::add_interval(void const*, void const*)
bool add_interval(const interval_point_t begin, const interval_point_t end)
         {
            if ((end <= begin) || in_interval(begin) || in_interval(end))
            {
               return false;
            }

            interval_map_[end] = std::make_pair(begin, end);

            return true;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, 0x8(%rsp)
cmpq %rsi, %rdx
jbe 0x35bf0d
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
callq 0x2c057e
testb %al, %al
jne 0x35bf0d
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
xorps %xmm0, %xmm0
movaps %xmm0, (%rdx)
movq %r14, %rdi
callq 0x2c057e
testb %al, %al
je 0x35bf19
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rsi
movq (%rsi), %r15
movq %r14, %rdi
callq 0x35bf34
movq %rbx, (%rax)
movq %r15, 0x8(%rax)
movb $0x1, %al
jmp 0x35bf0f
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::rebasevector_celem_rtc_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               vector_holder_     &&
               vector_node_.first &&
               vector_node_.first->valid();
         }

// Assembly:
cmpq $0x0, 0x30(%rdi)
je 0x35e802
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x35e802
movq (%rdi), %rax
jmpq *0x30(%rax)
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::rebasevector_elem_rtc_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               vector_holder_        &&
               index_.first          &&
               vector_node_.first    &&
               index_.first->valid() &&
               vector_node_.first->valid();
         }

// Assembly:
pushq %rbx
cmpq $0x0, 0x28(%rdi)
je 0x35f2b0
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x35f2b0
cmpq $0x0, 0x30(%rbx)
je 0x35f2b0
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x35f2b0
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x30(%rax)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::generic_function_node<double, exprtk::details::null_igenfunc<double>>::~generic_function_node()
virtual ~generic_function_node()
         {
            for (std::size_t i = 0; i < vv_list_.size(); ++i)
            {
               vecview_t& vv = vv_list_[i];
               if (vv && typestore_list_[i].vec_data)
               {
                  vv->remove_ref(&typestore_list_[i].vec_data);
                  typestore_list_[i].vec_data = 0;
               }
            }
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x212fc1(%rip), %rax    # 0x573ba0
movq %rax, (%rdi)
leaq 0x213017(%rip), %rax    # 0x573c00
movq %rax, 0x8(%rdi)
movq 0x70(%rdi), %rax
cmpq %rax, 0x78(%rdi)
je 0x360c40
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x360c25
movq 0x28(%rbx), %rsi
cmpq $0x0, (%rsi,%r14)
je 0x360c25
addq %r14, %rsi
callq 0x360fbc
movq 0x28(%rbx), %rax
movq $0x0, (%rax,%r14)
incq %r15
movq 0x70(%rbx), %rax
movq 0x78(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
addq $0x18, %r14
cmpq %rcx, %r15
jb 0x360bfd
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x360c5b
movq 0xc8(%rbx), %rsi
subq %rdi, %rsi
callq 0x1200c0
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x360c76
movq 0xb0(%rbx), %rsi
subq %rdi, %rsi
callq 0x1200c0
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x360c91
movq 0x98(%rbx), %rsi
subq %rdi, %rsi
callq 0x1200c0
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x360ca9
movq 0x80(%rbx), %rsi
subq %rdi, %rsi
callq 0x1200c0
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x360cbe
movq 0x68(%rbx), %rsi
subq %rdi, %rsi
callq 0x1200c0
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x360cd3
movq 0x50(%rbx), %rsi
subq %rdi, %rsi
callq 0x1200c0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x360ced
movq 0x38(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1200c0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x1eabad
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::return_node<double>::value() const
inline T value() const exprtk_override
         {
            if (gen_function_t::populate_value_list())
            {
               typedef typename type_store<T>::parameter_list parameter_list_t;

               results_context_->
                  assign(parameter_list_t(gen_function_t::typestore_list_));

               throw return_exception();
            }

            return std::numeric_limits<T>::quiet_NaN();
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x360d9c
testb %al, %al
jne 0x360d47
movsd 0x514cf(%rip), %xmm0    # 0x3b2210
addq $0x10, %rsp
popq %rbx
retq
movq 0xd0(%rbx), %rdi
addq $0x28, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
callq 0x3610e6
movl $0x1, %edi
callq 0x1201f0
leaq 0x212ea8(%rip), %rsi    # 0x573c18
movq %rax, %rdi
xorl %edx, %edx
callq 0x120310
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::vector_view<double>::remove_ref(double**)
void remove_ref(data_ptr_t* data_ref)
      {
         data_ref_.erase(
            std::remove(data_ref_.begin(), data_ref_.end(), data_ref),
            data_ref_.end());
         exprtk_debug(("vector_view::remove_ref() - data_ref: %p data_ref_.size(): %d\n",
                       reinterpret_cast<void*>(data_ref),
                       static_cast<int>(data_ref_.size())));
      }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x18(%rdi), %rdi
movq 0x20(%rbx), %rsi
callq 0x360ffe
movq 0x20(%rbx), %rcx
cmpq %rcx, %rax
je 0x360ff8
movq 0x20(%rbx), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
addq %rsi, %rax
cmpq %rax, %rdx
je 0x360ff8
movq %rax, 0x20(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::vector_view<double>::set_ref(double**)
void set_ref(data_ptr_t* data_ref)
      {
         data_ref_.push_back(data_ref);
         exprtk_debug(("vector_view::set_ref() - data_ref: %p data_ref_.size(): %d\n",
                       reinterpret_cast<void*>(data_ref),
                       static_cast<int>(data_ref_.size())));
      }

// Assembly:
pushq %rax
movq %rsi, %rax
movq %rsi, (%rsp)
movq 0x20(%rdi), %rsi
cmpq 0x28(%rdi), %rsi
je 0x361372
movq %rax, (%rsi)
addq $0x8, 0x20(%rdi)
jmp 0x36137e
addq $0x18, %rdi
movq %rsp, %rdx
callq 0x3624ac
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::assert_call(exprtk::details::expression_node<double>*&, exprtk::details::expression_node<double>*&, exprtk::assert_check::assert_context const&)
inline expression_node_ptr assert_call(expression_node_ptr& assert_condition,
                                                expression_node_ptr& assert_message,
                                                const assert_check::assert_context& context)
         {
            typedef details::assert_node<Type> alloc_type;

            expression_node_ptr result = node_allocator_->allocate_rrrr<alloc_type>
               (assert_condition, assert_message, parser_->assert_check_, context);

            if (result && result->valid())
            {
               parser_->state_.activate_side_effect("assert_call()");
               return result;
            }

            details::free_node(*node_allocator_, result          );
            details::free_node(*node_allocator_, assert_condition);
            details::free_node(*node_allocator_, assert_message  );

            return error_node();
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movl $0x8f0, %ecx            # imm = 0x8F0
addq 0x68(%r15), %rcx
callq 0x3627f2
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x36267e
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
testb %al, %al
je 0x36267e
movq 0x68(%r15), %r14
leaq 0x20(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x5e3cc(%rip), %rsi     # 0x3c0a06
leaq 0x5e3d2(%rip), %rdx     # 0x3c0a13
leaq 0x10(%rsp), %rdi
callq 0x1eabb8
cmpb $0x0, 0x3ac(%r14)
jne 0x36265d
movb $0x1, 0x3ac(%r14)
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x362674
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq 0x8(%rsp), %rax
jmp 0x362710
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3626b2
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x3626b2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3626a8
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x3626b2
leaq 0x8(%rsp), %rdi
callq 0x1f1690
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3626e0
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x3626e0
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3626d8
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x3626e0
movq %r14, %rdi
callq 0x1f1690
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x36270e
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x36270e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x362706
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x36270e
movq %rbx, %rdi
callq 0x1f1690
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::assert_node<double>::value_type>* exprtk::details::node_allocator::allocate_rrrr<exprtk::details::assert_node<double>, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::assert_check*, exprtk::assert_check::assert_context const>(exprtk::details::expression_node<double>*&, exprtk::details::expression_node<double>*&, exprtk::assert_check*&, exprtk::assert_check::assert_context const&) const
inline expression_node<typename node_type::value_type>* allocate_rrrr(T1& t1, T2& t2, T3& t3, T4& t4) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3, t4));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r15
movl $0xb8, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r15), %r15
movq (%r12), %r12
movq (%r13), %r13
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x1eda34
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
callq 0x1eda34
leaq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
callq 0x1eda34
movq 0x60(%r14), %rax
movq %rsp, %r8
movq %rax, 0x60(%r8)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x36296c
movq 0x40(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3628ae
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
leaq 0x10(%rsp), %r14
je 0x3628cf
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3628e5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x36271a
jmp 0x362956
movq %rax, %r14
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x362936
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1200c0
jmp 0x362936
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x362956
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1200c0
jmp 0x362956
movq %rax, %r14
movl $0xb8, %esi
movq %rbx, %rdi
callq 0x1200c0
movq %r14, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::assert_node<double>::value() const
inline T value() const exprtk_override
         {
            if (details::is_true(assert_condition_node_.first->value()))
            {
               return T(1);
            }

            #ifndef exprtk_disable_string_capabilities
            if (assert_message_node_.first)
            {
               assert_message_node_.first->value();
               assert(assert_message_str_base_);
               context_.message = assert_message_str_base_->str();
            }
            #endif

            assert_check_->handle_assert(context_);
            return T(0);
         }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x362c74
jnp 0x362c7e
movsd 0x4f3a4(%rip), %xmm0    # 0x3b2020
jmp 0x362cda
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x362cc5
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x40(%rbx), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x1202b0
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x362cc5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq 0x48(%rbx), %rdi
addq $0x50, %rbx
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
xorpd %xmm0, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::assert_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return (
                     assert_check_ &&
                     assert_condition_node_.first &&
                     assert_condition_node_.first->valid()
                   ) &&
                   (
                     (0 == assert_message_node_.first) ||
                     (
                       assert_message_node_.first &&
                       assert_message_str_base_   &&
                       assert_message_node_.first->valid() &&
                       details::is_generally_string_node(assert_message_node_.first)
                     )
                   );
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x48(%rdi)
je 0x362d50
movq %rdi, %r14
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x362d50
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x362d50
movq 0x30(%r14), %rdi
movb $0x1, %bl
testq %rdi, %rdi
je 0x362d52
cmpq $0x0, 0x40(%r14)
je 0x362d50
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x362d50
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x362d50
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x21, %eax
ja 0x362d4b
movl %eax, %ecx
movabsq $0x388fc0000, %rdx      # imm = 0x388FC0000
btq %rcx, %rdx
jb 0x362d52
cmpl $0x7b, %eax
je 0x362d52
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::is_base_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool is_base_function(const std::string& function_name)
      {
         for (std::size_t i = 0; i < base_function_list_size; ++i)
         {
            if (imatch(function_name, base_function_list[i]))
            {
               return true;
            }
         }

         return false;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rdi), %r15
testq %r15, %r15
sete %r14b
movb $0x1, %bl
xorl %r12d, %r12d
leaq 0x212d81(%rip), %rdx    # 0x57b2a0
movb %r14b, 0xf(%rsp)
movq %r12, %rax
shlq $0x5, %rax
cmpq 0x8(%rax,%rdx), %r15
jne 0x3685ab
movl %r14d, %ecx
testq %r15, %r15
je 0x3685a7
addq %rdx, %rax
movq (%rax), %r13
movq 0x10(%rsp), %rax
movsbl (%rax), %edi
callq 0x120450
movl %eax, %ebp
movsbl (%r13), %edi
callq 0x120450
leaq 0x212d40(%rip), %rdx    # 0x57b2a0
cmpl %eax, %ebp
jne 0x3685ab
movl $0x1, %ecx
movq %rcx, %r14
cmpq %rcx, %r15
je 0x368595
movq 0x10(%rsp), %rax
movsbl (%rax,%r14), %edi
callq 0x120450
movl %eax, %ebp
movsbl (%r13,%r14), %edi
callq 0x120450
leaq 0x1(%r14), %rcx
cmpl %eax, %ebp
je 0x368569
cmpq %r15, %r14
setae %cl
movb 0xf(%rsp), %r14b
leaq 0x212cf9(%rip), %rdx    # 0x57b2a0
testb %cl, %cl
jne 0x3685c4
cmpq $0x39, %r12
leaq 0x1(%r12), %rax
setb %bl
movq %rax, %r12
cmpq $0x3a, %rax
jne 0x368524
andb $0x1, %bl
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::details::function_N_node<double, exprtk::ifunction<double>, 2ul>::init_branches<2ul>(exprtk::details::expression_node<double>* (&) [2ul])
bool init_branches(expression_ptr (&b)[NumBranches])
         {
            // Needed for incompetent and broken msvc compiler versions
            #ifdef _MSC_VER
             #pragma warning(push)
             #pragma warning(disable: 4127)
            #endif

            if (N != NumBranches)
            {
               return false;
            }

            for (std::size_t i = 0; i < NumBranches; ++i)
            {
               if (b[i] && b[i]->valid())
                  branch_[i] = std::make_pair(b[i],branch_deletable(b[i]));
               else
                  return false;
            }

            initialised_ = function_;
            assert(valid());
            return initialised_;

            #ifdef _MSC_VER
             #pragma warning(pop)
            #endif
         }

// Assembly:
movq %rdi, %rax
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x3829a7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rax, (%rsp)
leaq 0x30(%rax), %r12
leaq 0x8(%rsi), %r13
xorl %eax, %eax
xorl %ebx, %ebx
xorl %ebp, %ebp
movl %ebp, %r15d
movl %eax, %ebp
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x38298f
movq (%r14), %r15
testq %r15, %r15
je 0x382950
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x382954
xorl %eax, %eax
jmp 0x382963
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
setne %al
movq (%r14), %rcx
shlq $0x4, %rbx
movq %rcx, (%r12,%rbx)
movb %al, 0x8(%r12,%rbx)
testb $0x1, %bpl
jne 0x382995
movq (%r13), %rdi
movl $0x1, %ebx
movb $0x1, %al
movq %r13, %r14
movl %ebp, %r15d
testq %rdi, %rdi
jne 0x38292b
testb $0x1, %r15b
je 0x3829aa
movq (%rsp), %rcx
cmpq $0x0, 0x20(%rcx)
setne %al
setne 0x50(%rcx)
jmp 0x3829ac
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::function_N_node<double, exprtk::ifunction<double>, 6ul>::value() const
inline T value() const exprtk_override
         {
            // Needed for incompetent and broken msvc compiler versions
            #ifdef _MSC_VER
             #pragma warning(push)
             #pragma warning(disable: 4127)
            #endif

            T v[N];
            evaluate_branches<T,N>::execute(v,branch_);
            return invoke<T,N>::execute(*function_,v);

            #ifdef _MSC_VER
             #pragma warning(pop)
            #endif
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x18(%rsp), %r14
movsd %xmm0, -0x8(%r14)
movq 0x40(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%r14)
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x20(%rsp), %r15
movsd %xmm0, (%r15)
movq 0x60(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x28(%rsp), %r12
movsd %xmm0, (%r12)
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x30(%rsp), %r13
movsd %xmm0, (%r13)
movq 0x80(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x38(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x20(%rbx), %rdi
movq (%rdi), %r10
movq %rax, (%rsp)
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
movq %r13, %r9
callq *0x40(%r10)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::type_checker::allow_zero_parameters() const
bool allow_zero_parameters() const
         {

            for (std::size_t i = 0; i < function_definition_list_.size(); ++i)
            {
               if (std::string::npos != function_definition_list_[i].param_seq.find("Z"))
               {
                  return true;
               }
            }

            return false;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
cmpq %rdi, 0x40(%rbx)
setne %bpl
je 0x38f1fe
addq $0x8, %rdi
leaq 0x38085(%rip), %rsi     # 0x3c721c
movl $0x1, %ecx
xorl %edx, %edx
callq 0x1201c0
cmpq $-0x1, %rax
jne 0x38f1fe
movl $0x30, %r15d
xorl %r12d, %r12d
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
leaq 0x38059(%rip), %r14     # 0x3c721c
incq %r12
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %r13, %rax
cmpq %rax, %r12
setb %bpl
jae 0x38f1fe
addq %r15, %rdi
addq $0x28, %r15
movl $0x1, %ecx
movq %r14, %rsi
xorl %edx, %edx
callq 0x1201c0
cmpq $-0x1, %rax
je 0x38f1c3
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::type_checker::split_param_seq(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char) const
std::vector<std::string> split_param_seq(const std::string& param_seq, const details::char_t delimiter = '|') const
         {
             std::string::const_iterator current_begin = param_seq.begin();
             std::string::const_iterator iter          = param_seq.begin();

             std::vector<std::string> result;

             while (iter != param_seq.end())
             {
                 if (*iter == delimiter)
                 {
                     result.push_back(std::string(current_begin, iter));
                     current_begin = ++iter;
                 }
                 else
                     ++iter;
             }

             if (current_begin != iter)
             {
                 result.push_back(std::string(current_begin, iter));
             }

             return result;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq $0x0, 0x8(%rdx)
je 0x391d7f
movl %ecx, %ebp
movq %rdx, %r15
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r12
movq %rsi, %r14
cmpb %bpl, (%r14)
jne 0x391d6e
movq %r13, 0x8(%rsp)
movq %r12, %rdi
movq %r14, %rdx
callq 0x39213c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x391f34
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x391d66
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1200c0
incq %r14
movq %r14, %rsi
jmp 0x391d71
incq %r14
movq (%r15), %rax
addq 0x8(%r15), %rax
cmpq %rax, %r14
jne 0x391d2f
jmp 0x391d82
movq %rsi, %r14
cmpq %r14, %rsi
je 0x391dc1
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x39213c
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x391f34
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x391dc1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
jne 0x391df6
jmp 0x391e03
jmp 0x391de4
movq %rax, %r14
jmp 0x391e03
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x391e03
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %rbx, %rdi
callq 0x266c02
movq %r14, %rdi
callq 0x120330
nop