LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::parse_not_statement()
inline expression_node_ptr parse_not_statement()
      {
         if (settings_.logic_disabled("not"))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR063 - Invalid or disabled logic operation 'not'",
               exprtk_error_location));

            return error_node();
         }

         return parse_base_operation();
      }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
leaq 0xd4b30(%rip), %rsi     # 0x2d3241
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x127016
leaq 0xd0(%rbx), %rdi
leaq 0x70(%rsp), %rsi
callq 0x20d656
movl %eax, %ebp
leaq 0x70(%rsp), %rdi
callq 0x118648
testb %bpl, %bpl
je 0x1fe7dc
leaq 0xdbdb9(%rip), %rsi     # 0x2da506
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x127016
leaq 0x30(%rsp), %rdi
movl $0x680e, %esi           # imm = 0x680E
callq 0x1f7a3c
leaq 0xdb489(%rip), %rsi     # 0x2d9bfb
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x1b4349
leaq 0x70(%rbx), %rdx
leaq 0x70(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %rcx
leaq 0x50(%rsp), %r8
callq 0x1f7341
addq $0x308, %rbx            # imm = 0x308
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f76ce
leaq 0x70(%rsp), %rdi
callq 0x1f5c4c
leaq 0x50(%rsp), %rdi
callq 0x118648
leaq 0x30(%rsp), %rdi
callq 0x118648
leaq 0x10(%rsp), %rdi
callq 0x118648
xorl %eax, %eax
jmp 0x1fe7e4
movq %rbx, %rdi
callq 0x1fe896
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x1f5c4c
jmp 0x1fe800
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x118648
jmp 0x1fe80f
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x118648
jmp 0x1fe81e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x1fe82f
jmp 0x1fe836
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x118648
jmp 0x1fe839
movq %rax, %rbx
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::check_block_statement_closure(exprtk::details::expression_node<double>*)
inline expression_node_ptr check_block_statement_closure(expression_node_ptr expression)
      {
         if (
              expression &&
              (
                (current_token().type == token_t::e_symbol) ||
                (current_token().type == token_t::e_number)
              )
            )
         {
            free_node(node_allocator_, expression);

            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR240 - Invalid syntax '" + current_token().value  + "' possible missing operator or context",
               exprtk_error_location));

               return error_node();
         }

         return expression;
      }

// Assembly:
pushq %r14
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rsi, 0x8(%rsp)
testq %rsi, %rsi
je 0x1ff15e
movq %rdi, %rbx
movl 0x70(%rdi), %eax
addl $-0x7, %eax
cmpl $0x1, %eax
ja 0x1ff160
leaq 0x290(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1ad9c8
leaq 0x78(%rbx), %rdx
leaq 0xdc26b(%rip), %rsi     # 0x2db319
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x1f8aab
leaq 0xdad7d(%rip), %rdx     # 0x2d9e3f
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x1b42c3
leaq 0x10(%rsp), %rdi
movl $0x7a35, %esi           # imm = 0x7A35
callq 0x1f7a3c
leaq 0xdab16(%rip), %rsi     # 0x2d9bfb
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x1b4349
leaq 0x70(%rbx), %rdx
leaq 0x90(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x50(%rsp), %rcx
leaq 0x30(%rsp), %r8
callq 0x1f7341
addq $0x308, %rbx            # imm = 0x308
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f76ce
leaq 0x90(%rsp), %rdi
callq 0x1f5c4c
leaq 0x30(%rsp), %rdi
callq 0x118648
leaq 0x10(%rsp), %rdi
callq 0x118648
leaq 0x50(%rsp), %rdi
callq 0x118648
leaq 0x70(%rsp), %rdi
callq 0x118648
xorl %esi, %esi
movq %rsi, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x1f5c4c
jmp 0x1ff183
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x118648
jmp 0x1ff192
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x118648
jmp 0x1ff1a1
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x118648
jmp 0x1ff1b0
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::is_valid_sf_symbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool is_valid_sf_symbol(const std::string& symbol)
      {
         // Special function: $f12 or $F34
         return (4 == symbol.size())  &&
                ('$' == symbol[0])    &&
                imatch('f',symbol[1]) &&
                is_digit(symbol[2])   &&
                is_digit(symbol[3]);
      }

// Assembly:
cmpq $0x4, 0x8(%rdi)
jne 0x201c11
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
cmpb $0x24, (%rax)
jne 0x201c14
movsbl 0x1(%rax), %esi
pushq $0x66
popq %rdi
callq 0x1f87b8
testb %al, %al
je 0x201c14
movq (%rbx), %rax
movb 0x2(%rax), %cl
addb $-0x30, %cl
cmpb $0x9, %cl
ja 0x201c14
movb 0x3(%rax), %al
addb $-0x30, %al
cmpb $0xa, %al
setb %al
jmp 0x201c16
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::parse_continue_statement()
inline expression_node_ptr parse_continue_statement()
      {
         if (0 == state_.parsing_loop_stmt_count)
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR156 - Invalid use of 'continue', allowed only in the scope of a loop",
               exprtk_error_location));

            return error_node();
         }
         else
         {
            next_token();

            brkcnt_list_.front() = true;
            state_.activate_side_effect("parse_continue_statement()");

            return node_allocator_.allocate<details::continue_node<T> >();
         }
      }

// Assembly:
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
cmpq $0x0, 0x3c0(%rdi)
je 0x202275
movq %rbx, %rdi
callq 0x1f6d68
movq 0x368(%rbx), %rax
movb $0x1, (%rax)
leaq 0xd9b79(%rip), %rsi     # 0x2dbdb1
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x127016
cmpb $0x0, 0x3ac(%rbx)
jne 0x202257
movb $0x1, 0x3ac(%rbx)
leaq 0x68(%rsp), %rdi
callq 0x118648
addq $0x290, %rbx            # imm = 0x290
movq %rbx, %rdi
callq 0x29b296
jmp 0x202309
leaq 0xd9aed(%rip), %rsi     # 0x2dbd69
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x127016
leaq 0x28(%rsp), %rdi
movl $0x7216, %esi           # imm = 0x7216
callq 0x1f7a3c
leaq 0xd795a(%rip), %rsi     # 0x2d9bfb
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x1b4349
leaq 0x70(%rbx), %rdx
leaq 0x68(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rcx
leaq 0x48(%rsp), %r8
callq 0x1f7341
addq $0x308, %rbx            # imm = 0x308
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f76ce
leaq 0x68(%rsp), %rdi
callq 0x1f5c4c
leaq 0x48(%rsp), %rdi
callq 0x118648
leaq 0x28(%rsp), %rdi
callq 0x118648
leaq 0x8(%rsp), %rdi
callq 0x118648
xorl %eax, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x1f5c4c
jmp 0x202324
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x118648
jmp 0x202333
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x118648
jmp 0x202342
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::token::seperator_to_str[abi:cxx11](exprtk::lexer::token::token_type)
static inline std::string seperator_to_str(const token_type t)
         {
            switch (t)
            {
               case e_comma : return ",";
               case e_colon : return ":";
               case e_eof   : return ";";
               default      : return "UNKNOWN";
            }

            #if !defined(_MSC_VER) && !defined(__NVCOMPILER)
            return "UNKNOWN";
            #endif
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x6, %esi
je 0x2081dd
cmpl $0x3a, %esi
je 0x2081cf
cmpl $0x2c, %esi
jne 0x2081eb
leaq 0xd3f75(%rip), %rsi     # 0x2dc13d
leaq 0xf(%rsp), %rdx
jmp 0x2081f7
leaq 0xd1a2f(%rip), %rsi     # 0x2d9c05
leaq 0xe(%rsp), %rdx
jmp 0x2081f7
leaq 0xedcfb(%rip), %rsi     # 0x2f5edf
leaq 0xd(%rsp), %rdx
jmp 0x2081f7
leaq 0xd19c9(%rip), %rsi     # 0x2d9bbb
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x127016
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_element_manager::deactivate(unsigned long const&)
inline void deactivate(const std::size_t& scope_depth)
         {
            exprtk_debug(("deactivate() - Scope depth: %d\n",
                          static_cast<int>(parser_.state_.scope_depth)));

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

               if (se.active && (se.depth >= scope_depth))
               {
                  exprtk_debug(("deactivate() - element[%02d] '%s'\n",
                                static_cast<int>(i),
                                se.name.c_str()));

                  se.active = false;
               }
            }
         }

// Assembly:
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rax
subq %rcx, %rax
pushq $0x70
popq %rdi
cqto
idivq %rdi
movq (%rsi), %rdx
addq $0x4c, %rcx
xorl %esi, %esi
cmpq %rax, %rsi
jae 0x208266
cmpb $0x1, (%rcx)
jne 0x20825d
cmpq %rdx, -0x1c(%rcx)
jb 0x20825d
movb $0x0, (%rcx)
incq %rsi
addq $0x70, %rcx
jmp 0x20824a
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<double>* exprtk::parser<double>::expression_generator<double>::multi_switch_statement<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>>&)
inline expression_node_ptr multi_switch_statement(Sequence<expression_node_ptr,Allocator>& arg_list)
         {
            if (!all_nodes_valid(arg_list))
            {
               details::free_all_nodes(*node_allocator_,arg_list);

               return error_node();
            }
            else if (is_constant_foldable(arg_list))
               return const_optimise_mswitch(arg_list);
            else
               return node_allocator_->allocate<details::multi_switch_node<Type> >(arg_list);
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2082f4
testb %al, %al
je 0x2082cb
movq %r14, %rdi
movq %rbx, %rsi
callq 0x208372
testb %al, %al
je 0x2082e1
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2083b4
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x20831e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x208474
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::parser<double>::expression_generator<double>::is_constant_foldable<exprtk::details::expression_node<double>*, 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
inline bool is_constant_foldable(const Sequence<NodePtr,Allocator>& b) const
         {
            for (std::size_t i = 0; i < b.size(); ++i)
            {
               if (0 == b[i])
                  return false;
               else if (!details::is_constant_node(b[i]))
                  return false;
            }

            return true;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
xorl %ecx, %ecx
movq %rcx, %r14
movq (%rbx), %rax
movq 0x8(%rbx), %r15
subq %rax, %r15
sarq $0x3, %r15
cmpq %r15, %rcx
jae 0x2083a8
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x2083a8
callq 0x208267
leaq 0x1(%r14), %rcx
testb %al, %al
jne 0x20837c
cmpq %r15, %r14
setae %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<double>* exprtk::parser<double>::expression_generator<double>::const_optimise_mswitch<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>>&)
inline expression_node_ptr const_optimise_mswitch(Sequence<expression_node_ptr,Allocator>& arg_list)
         {
            expression_node_ptr result = error_node();

            for (std::size_t i = 0; i < (arg_list.size() / 2); ++i)
            {
               expression_node_ptr condition  = arg_list[(2 * i)    ];
               expression_node_ptr consequent = arg_list[(2 * i) + 1];

               if (details::is_true(condition))
               {
                  result = consequent;
               }
            }

            if (0 == result)
            {
               const T zero = T(0);
               result       = node_allocator_->allocate<literal_node_t>(zero);
            }

            for (std::size_t i = 0; i < arg_list.size(); ++i)
            {
               expression_node_ptr& current_expr = arg_list[i];

               if (current_expr && (current_expr != result))
               {
                  details::free_node(*node_allocator_,current_expr);
               }
            }

            return result;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x8
popq %r12
xorl %r13d, %r13d
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
shrq %rcx
cmpq %rcx, %r13
jae 0x20840d
movq -0x8(%rax,%r12), %rdi
movq (%rax,%r12), %rbp
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0xc5eac(%rip), %xmm0    # 0x2ce2a8
cmovneq %rbp, %r15
cmovpq %rbp, %r15
incq %r13
addq $0x10, %r12
jmp 0x2083cf
testq %r15, %r15
jne 0x208425
movq %rsp, %rsi
andq $0x0, (%rsi)
movq 0x8(%r14), %rdi
callq 0x1adef4
movq %rax, %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x3, %rax
cmpq %rax, %r13
jae 0x208461
movq (%rsi,%r12), %rax
testq %rax, %rax
je 0x208458
cmpq %r15, %rax
je 0x208458
addq %r12, %rsi
movq 0x8(%r14), %rdi
callq 0x1ad9c8
incq %r13
addq $0x8, %r12
jmp 0x20842b
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::multi_switch_node<double>::multi_switch_node<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&)
explicit multi_switch_node(const Sequence<expression_ptr,Allocator>& arg_list)
         {
            if (0 != (arg_list.size() & 1))
               return;

            arg_list_.resize(arg_list.size());

            for (std::size_t i = 0; i < arg_list.size(); ++i)
            {
               if (arg_list[i] && arg_list[i]->valid())
               {
                  construct_branch_pair(arg_list_[i], arg_list[i]);
               }
               else
               {
                  arg_list_.clear();
                  return;
               }
            }

            assert(valid());
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
leaq 0x277d04(%rip), %rax    # 0x4801e0
movq %rax, (%rdi)
leaq 0x277d4a(%rip), %rax    # 0x480230
movq %rax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
andq $0x0, 0x30(%rdi)
movq 0x8(%rsi), %rsi
subq (%r14), %rsi
testb $0x8, %sil
jne 0x20856b
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
sarq $0x3, %rsi
movq %r15, %rdi
callq 0x20858a
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jae 0x20856b
movq (%rax,%r13,8), %rdi
testq %rdi, %rdi
je 0x20855d
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x20855d
movq (%r15), %rdi
addq %r12, %rdi
movq (%r14), %rax
movq (%rax,%r13,8), %rsi
callq 0x2085be
incq %r13
addq $0x10, %r12
jmp 0x20851c
movq 0x20(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x20856b
movq %rax, 0x28(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x208577
movq %rax, %rbx
movq %r15, %rdi
callq 0x208898
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::multi_switch_node<double>::value() const
inline T value() const exprtk_override
         {
            const std::size_t upper_bound = (arg_list_.size() - 1);

            T result = T(0);

            for (std::size_t i = 0; i < upper_bound; i += 2)
            {
               expression_ptr condition  = arg_list_[i    ].first;
               expression_ptr consequent = arg_list_[i + 1].first;

               if (is_true(condition))
               {
                  result = consequent->value();
               }
            }

            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %r15
subq 0x20(%rdi), %r15
sarq $0x4, %r15
decq %r15
pushq $0x10
popq %r12
xorl %r13d, %r13d
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
cmpq %r15, %r13
jae 0x208689
movq 0x20(%rbx), %rax
movq -0x10(%rax,%r12), %rdi
movq (%rax,%r12), %r14
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0xc5c3c(%rip), %xmm0    # 0x2ce2a8
jne 0x208670
jnp 0x20867f
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
addq $0x2, %r13
addq $0x20, %r12
jmp 0x20864c
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::details::node_depth_base<exprtk::details::expression_node<double>>::compute_node_depth<std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>, std::vector>(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&) const
std::size_t compute_node_depth(const Sequence<nb_pair_t,Allocator>& branch_list) const
         {
            if (!depth_set)
            {
               for (std::size_t i = 0; i < branch_list.size(); ++i)
               {
                  if (branch_list[i].first)
                  {
                     depth = std::max(depth, compute_node_depth(branch_list[i].first));
                  }
               }

               depth_set = true;
            }

            return depth;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x8(%rdi)
jne 0x208989
movq %rsi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x4, %rax
cmpq %rax, %r12
jae 0x208985
cmpq $0x0, (%rsi,%r15)
je 0x20897c
addq %r15, %rsi
movq %rbx, %rdi
callq 0x20899a
movq 0x10(%rbx), %rcx
cmpq %rax, %rcx
cmovaq %rcx, %rax
movq %rax, 0x10(%rbx)
incq %r12
addq $0x10, %r15
jmp 0x208948
movb $0x1, 0x8(%rbx)
movq 0x10(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::node_depth_base<exprtk::details::expression_node<double>>::compute_node_depth(exprtk::details::expression_node<double> const* const&) const
std::size_t compute_node_depth(const Node* const& node) const
         {
            if (!depth_set)
            {
               depth = 1 + (node ? node->node_depth() : 0);
               depth_set = true;
            }

            return depth;
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x2089aa
movq 0x10(%rbx), %rax
jmp 0x2089cd
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x2089c2
movq 0x8(%rdi), %rax
addq $0x8, %rdi
callq *0x10(%rax)
incq %rax
jmp 0x2089c5
pushq $0x1
popq %rax
movq %rax, 0x10(%rbx)
movb $0x1, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::dependent_entity_collector::add_symbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::parser<double>::symbol_type)
inline void add_symbol(const std::string& symbol, const symbol_type st)
         {
            switch (st)
            {
               case e_st_variable       :
               case e_st_vector         :
               case e_st_string         :
               case e_st_local_variable :
               case e_st_local_vector   :
               case e_st_local_string   : if (collect_variables_)
                                             symbol_name_list_
                                                .push_back(std::make_pair(symbol, st));
                                          break;

               case e_st_function       : if (collect_functions_)
                                             symbol_name_list_
                                                .push_back(std::make_pair(symbol, st));
                                          break;

               default                  : return;
            }
         }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
cmpl $0x8, %edx
ja 0x208a1c
movl %edx, %ebp
movq %rdi, %rbx
movl $0x1d6, %eax            # imm = 0x1D6
btl %edx, %eax
jae 0x208a25
cmpb $0x1, 0x8(%rbx)
jne 0x208a1c
addq $0x10, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1182f0
movl %ebp, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x208a6e
leaq 0x8(%rsp), %rdi
callq 0x118648
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x5, %ebp
jne 0x208a1c
cmpb $0x1, 0x9(%rbx)
jne 0x208a1c
addq $0x10, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1182f0
movl $0x5, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x208a6e
jmp 0x208a12
jmp 0x208a58
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<double>* exprtk::parser<double>::expression_generator<double>::const_optimise_varargfunc<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(exprtk::details::operator_type const&, std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>>&)
inline expression_node_ptr const_optimise_varargfunc(const details::operator_type& operation, Sequence<expression_node_ptr,Allocator>& arg_list)
         {
            expression_node_ptr temp_node = error_node();

            switch (operation)
            {
               #define case_stmt(op0, op1)                                                \
               case op0 : temp_node = node_allocator_->                                   \
                                         allocate<details::vararg_node<Type,op1<Type> > > \
                                            (arg_list);                                   \
                          break;                                                          \

               case_stmt(details::e_sum   , details::vararg_add_op  )
               case_stmt(details::e_prod  , details::vararg_mul_op  )
               case_stmt(details::e_avg   , details::vararg_avg_op  )
               case_stmt(details::e_min   , details::vararg_min_op  )
               case_stmt(details::e_max   , details::vararg_max_op  )
               case_stmt(details::e_mand  , details::vararg_mand_op )
               case_stmt(details::e_mor   , details::vararg_mor_op  )
               case_stmt(details::e_multi , details::vararg_multi_op)
               #undef case_stmt
               default : return error_node();
            }

            const T v = temp_node->value();

            details::free_node(*node_allocator_,temp_node);

            return node_allocator_->allocate<literal_node_t>(v);
         }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl (%rsi), %eax
leal -0x9(%rax), %ecx
cmpl $0x4, %ecx
ja 0x208ca4
leaq 0xc6ee7(%rip), %rax     # 0x2cfb74
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x8(%rbx), %rdi
movq %rdx, %rsi
callq 0x208fd8
jmp 0x208d17
cmpl $0x1c, %eax
je 0x208ceb
cmpl $0x1d, %eax
je 0x208ccf
cmpl $0x5a, %eax
jne 0x208cf9
movq 0x8(%rbx), %rdi
movq %rdx, %rsi
callq 0x209108
jmp 0x208d17
movq 0x8(%rbx), %rdi
movq %rdx, %rsi
callq 0x208f40
jmp 0x208d17
movq 0x8(%rbx), %rdi
movq %rdx, %rsi
callq 0x2090bc
jmp 0x208d17
movq 0x8(%rbx), %rdi
movq %rdx, %rsi
callq 0x208f8c
jmp 0x208d17
movq 0x8(%rbx), %rdi
movq %rdx, %rsi
callq 0x209070
jmp 0x208d17
xorl %eax, %eax
jmp 0x208d49
movq 0x8(%rbx), %rdi
movq %rdx, %rsi
callq 0x208ef4
jmp 0x208d17
movq 0x8(%rbx), %rdi
movq %rdx, %rsi
callq 0x209024
movq %rax, 0x8(%rsp)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
leaq 0x10(%rsp), %r14
movsd %xmm0, (%r14)
movq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1ad9c8
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x1adef4
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<double>* exprtk::parser<double>::expression_generator<double>::vectorize_func<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(exprtk::details::operator_type const&, std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>>&)
inline expression_node_ptr vectorize_func(const details::operator_type& operation,
                                                   Sequence<expression_node_ptr,Allocator>& arg_list)
         {
            if (1 == arg_list.size())
            {
               switch (operation)
               {
                  #define case_stmt(op0, op1)                                                     \
                  case op0 : return node_allocator_->                                             \
                                allocate<details::vectorize_node<Type,op1<Type> > >(arg_list[0]); \

                  case_stmt(details::e_sum  , details::vec_add_op)
                  case_stmt(details::e_prod , details::vec_mul_op)
                  case_stmt(details::e_avg  , details::vec_avg_op)
                  case_stmt(details::e_min  , details::vec_min_op)
                  case_stmt(details::e_max  , details::vec_max_op)
                  #undef case_stmt
                  default : return error_node();
               }
            }
            else
               return error_node();
         }

// Assembly:
movq %rsi, %rax
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
subq %rsi, %rcx
cmpq $0x8, %rcx
jne 0x208db0
movl (%rax), %eax
addl $-0x9, %eax
cmpl $0x4, %eax
ja 0x208db0
leaq 0xc6dea(%rip), %rcx     # 0x2cfb88
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rdi
jmp 0x209238
xorl %eax, %eax
retq
movq 0x8(%rdi), %rdi
jmp 0x2091a0
movq 0x8(%rdi), %rdi
jmp 0x2091ec
movq 0x8(%rdi), %rdi
jmp 0x209154
movq 0x8(%rdi), %rdi
jmp 0x209284
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::details::all_nodes_variables<double, std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&)
inline bool all_nodes_variables(const Sequence<expression_node<T>*,Allocator>& b)
      {
         for (std::size_t i = 0; i < b.size(); ++i)
         {
            if (0 == b[i])
               return false;
            else if (!is_variable_node(b[i]))
               return false;
         }

         return true;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ecx, %ecx
movq %rcx, %r14
movq (%rbx), %rax
movq 0x8(%rbx), %r15
subq %rax, %r15
sarq $0x3, %r15
cmpq %r15, %rcx
jae 0x208e0f
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x208e0f
movq (%rdi), %rax
callq *0x28(%rax)
leaq 0x1(%r14), %rcx
cmpl $0x11, %eax
je 0x208de1
cmpq %r15, %r14
setae %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<double>* exprtk::parser<double>::expression_generator<double>::varnode_optimise_varargfunc<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(exprtk::details::operator_type const&, std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>>&)
inline expression_node_ptr varnode_optimise_varargfunc(const details::operator_type& operation,
                                                                Sequence<expression_node_ptr,Allocator>& arg_list)
         {
            switch (operation)
            {
               #define case_stmt(op0, op1)                                                  \
               case op0 : return node_allocator_->                                          \
                             allocate<details::vararg_varnode<Type,op1<Type> > >(arg_list); \

               case_stmt(details::e_sum   , details::vararg_add_op  )
               case_stmt(details::e_prod  , details::vararg_mul_op  )
               case_stmt(details::e_avg   , details::vararg_avg_op  )
               case_stmt(details::e_min   , details::vararg_min_op  )
               case_stmt(details::e_max   , details::vararg_max_op  )
               case_stmt(details::e_mand  , details::vararg_mand_op )
               case_stmt(details::e_mor   , details::vararg_mor_op  )
               case_stmt(details::e_multi , details::vararg_multi_op)
               #undef case_stmt
               default : return error_node();
            }
         }

// Assembly:
movl (%rsi), %eax
leal -0x9(%rax), %ecx
cmpl $0x4, %ecx
ja 0x208e42
leaq 0xc6d6f(%rip), %rax     # 0x2cfb9c
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x8(%rdi), %rdi
movq %rdx, %rsi
jmp 0x209f48
cmpl $0x1c, %eax
je 0x208e81
cmpl $0x1d, %eax
je 0x208e69
cmpl $0x5a, %eax
jne 0x208e8d
movq 0x8(%rdi), %rdi
movq %rdx, %rsi
jmp 0x20a078
movq 0x8(%rdi), %rdi
movq %rdx, %rsi
jmp 0x209eb0
movq 0x8(%rdi), %rdi
movq %rdx, %rsi
jmp 0x20a02c
movq 0x8(%rdi), %rdi
movq %rdx, %rsi
jmp 0x209efc
movq 0x8(%rdi), %rdi
movq %rdx, %rsi
jmp 0x209fe0
xorl %eax, %eax
retq
movq 0x8(%rdi), %rdi
movq %rdx, %rsi
jmp 0x209e64
movq 0x8(%rdi), %rdi
movq %rdx, %rsi
jmp 0x209f94
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::node_depth_base<exprtk::details::expression_node<double>>::compute_node_depth(std::pair<exprtk::details::expression_node<double>*, bool> const&) const
std::size_t compute_node_depth(const nb_pair_t& branch) const
         {
            if (!depth_set)
            {
               depth = 1 + (branch.first ? branch.first->node_depth() : 0);
               depth_set = true;
            }

            return depth;
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x209696
movq 0x10(%rbx), %rax
jmp 0x2096b9
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x2096ae
movq 0x8(%rdi), %rax
addq $0x8, %rdi
callq *0x10(%rax)
incq %rax
jmp 0x2096b1
pushq $0x1
popq %rax
movq %rax, 0x10(%rbx)
movb $0x1, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vec_min_op<double>::process(exprtk::details::vector_interface<double>*)
static inline T process(const ivector_ptr v)
         {
            const T* vec = v->vec()->vds().data();
            const std::size_t vec_size = v->vec()->size();

            T result = vec[0];

            for (std::size_t i = 1; i < vec_size; ++i)
            {
               const T v_i = vec[i];

               if (v_i < result)
                  result = v_i;
            }

            return result;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x30(%rax), %rax
movq 0x10(%rax), %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movsd (%r14), %xmm0
pushq $0x1
popq %rcx
cmpq %rax, %rcx
jae 0x209d13
movsd (%r14,%rcx,8), %xmm1
minsd %xmm0, %xmm1
incq %rcx
movapd %xmm1, %xmm0
jmp 0x209cfb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vararg_varnode<double, exprtk::details::vararg_add_op<double>>::vararg_varnode<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&)
explicit vararg_varnode(const Sequence<expression_ptr,Allocator>& arg_list)
         : initialised_(false)
         {
            arg_list_.resize(arg_list.size());

            for (std::size_t i = 0; i < arg_list.size(); ++i)
            {
               if (arg_list[i] && arg_list[i]->valid() && is_variable_node(arg_list[i]))
               {
                  variable_node<T>* var_node_ptr = static_cast<variable_node<T>*>(arg_list[i]);
                  arg_list_[i] = (&var_node_ptr->ref());
               }
               else
               {
                  arg_list_.clear();
                  return;
               }
            }

            initialised_ = (arg_list.size() == arg_list_.size());
            assert(valid());
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movb $0x0, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
leaq 0x27646e(%rip), %rax    # 0x480550
movq %rax, (%rdi)
leaq 0x2764ac(%rip), %rax    # 0x480598
movq %rax, 0x8(%rdi)
leaq 0x20(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x29(%rdi)
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
sarq $0x3, %rsi
movq %r14, %rdi
callq 0x20a1ac
xorl %r12d, %r12d
movq (%r15), %rcx
movq 0x8(%r15), %rax
subq %rcx, %rax
movq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r12
jae 0x20a17c
movq (%rcx,%r12,8), %rdi
testq %rdi, %rdi
je 0x20a16c
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x20a16c
movq (%r15), %rax
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x20a16c
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x20a16c
movq (%r15), %rax
movq (%rax,%r12,8), %rax
movq 0x28(%rax), %rax
movq (%r14), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
jmp 0x20a115
movq 0x20(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x20a18b
movq %rax, 0x28(%rbx)
jmp 0x20a18b
movq 0x28(%rbx), %rcx
subq 0x20(%rbx), %rcx
cmpq %rcx, %rax
sete 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x20a199
movq %rax, %rbx
movq %r14, %rdi
callq 0x20a3f8
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_avg_op<double>::process<double const*, std::allocator<double const*>, std::vector>(std::vector<double const*, std::allocator<double const*>> const&)
static inline T process(const Sequence<Type,Allocator>& arg_list)
         {
            switch (arg_list.size())
            {
               case 0  : return T(0);
               case 1  : return process_1(arg_list);
               case 2  : return process_2(arg_list);
               case 3  : return process_3(arg_list);
               case 4  : return process_4(arg_list);
               case 5  : return process_5(arg_list);
               default : return vararg_add_op<T>::process(arg_list) / T(arg_list.size());
            }
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq $0x5, %rcx
ja 0x20a891
leaq 0xc549b(%rip), %rdx     # 0x2cfce0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
xorpd %xmm0, %xmm0
jmp 0x20a8c9
movq %rbx, %rdi
popq %rbx
jmp 0x20a8f0
movq (%rax), %rcx
movq 0x8(%rax), %rax
movsd (%rcx), %xmm0
addsd (%rax), %xmm0
mulsd 0xc39a4(%rip), %xmm0    # 0x2ce218
jmp 0x20a8c9
movq %rbx, %rdi
popq %rbx
jmp 0x20a8cc
movq (%rax), %rax
movsd (%rax), %xmm0
jmp 0x20a8c9
movq %rbx, %rdi
popq %rbx
jmp 0x20a91c
movq %rbx, %rdi
callq 0x20a416
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
movq %rax, %xmm1
punpckldq 0xc375f(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xc3767(%rip), %xmm1    # 0x2ce020
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::str_vararg_node<double, exprtk::details::vararg_multi_op<double>>::value() const
inline T value() const exprtk_override
         {
            if (!arg_list_.empty())
            {
               VarArgFunction::process(arg_list_);
            }

            final_node_.first->value();

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rax
cmpq 0x60(%rdi), %rax
je 0x20b737
leaq 0x58(%rbx), %rdi
callq 0x20b85e
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd 0xc2b77(%rip), %xmm0    # 0x2ce2c0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_multi_op<double>::process<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>, std::vector>(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process(const Sequence<Type,Allocator>& arg_list)
         {
            switch (arg_list.size())
            {
               case 0  : return std::numeric_limits<T>::quiet_NaN();
               case 1  : return process_1(arg_list);
               case 2  : return process_2(arg_list);
               case 3  : return process_3(arg_list);
               case 4  : return process_4(arg_list);
               case 5  : return process_5(arg_list);
               case 6  : return process_6(arg_list);
               case 7  : return process_7(arg_list);
               case 8  : return process_8(arg_list);
               default :
                        {
                           for (std::size_t i = 0; i < (arg_list.size() - 1); ++i)
                           {
                              value(arg_list[i]);
                           }
                           return value(arg_list.back());
                        }
            }
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x4, %rdx
cmpq $0x8, %rdx
ja 0x20b8fb
leaq 0xc44f0(%rip), %rcx     # 0x2cfd74
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movsd 0xc2a2b(%rip), %xmm0    # 0x2ce2c0
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20b986
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20b93c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20b95a
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20ba56
movq (%rax), %rdi
jmp 0x20b931
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20b9be
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20ba04
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20bab6
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x4, %rdx
decq %rdx
cmpq %rdx, %r15
jae 0x20b92d
movq (%rax,%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
incq %r15
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
addq $0x10, %r14
jmp 0x20b901
movq -0x10(%rcx), %rdi
movq (%rdi), %rax
popq %rbx
popq %r14
popq %r15
jmpq *0x18(%rax)
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_multi_op<double>::process_4<std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>>>(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process_4(const Sequence& arg_list)
         {
                   value(arg_list[0]);
                   value(arg_list[1]);
                   value(arg_list[2]);
            return value(arg_list[3]);
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_multi_op<double>::process_5<std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>>>(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process_5(const Sequence& arg_list)
         {
                   value(arg_list[0]);
                   value(arg_list[1]);
                   value(arg_list[2]);
                   value(arg_list[3]);
            return value(arg_list[4]);
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movq 0x40(%rax), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_multi_op<double>::process_8<std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>>>(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process_8(const Sequence& arg_list)
         {
                   value(arg_list[0]);
                   value(arg_list[1]);
                   value(arg_list[2]);
                   value(arg_list[3]);
                   value(arg_list[4]);
                   value(arg_list[5]);
                   value(arg_list[6]);
            return value(arg_list[7]);
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movq 0x50(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movq 0x60(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movq 0x70(%rax), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vararg_node<double, exprtk::details::vararg_add_op<double>>::vararg_node<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&)
explicit vararg_node(const Sequence<expression_ptr,Allocator>& arg_list)
         : initialised_(false)
         {
            arg_list_.resize(arg_list.size());

            for (std::size_t i = 0; i < arg_list.size(); ++i)
            {
               if (arg_list[i] && arg_list[i]->valid())
               {
                  construct_branch_pair(arg_list_[i],arg_list[i]);
               }
               else
               {
                  arg_list_.clear();
                  return;
               }
            }

            initialised_ = (arg_list_.size() == arg_list.size());
            assert(valid());
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movb $0x0, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
leaq 0x274fbf(%rip), %rax    # 0x480b00
movq %rax, (%rdi)
leaq 0x275005(%rip), %rax    # 0x480b50
movq %rax, 0x8(%rdi)
leaq 0x20(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x29(%rdi)
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
sarq $0x3, %rsi
movq %r14, %rdi
callq 0x20858a
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%r15), %rcx
movq 0x8(%r15), %rax
subq %rcx, %rax
sarq $0x3, %rax
cmpq %rax, %r13
jae 0x20bbc8
movq (%rcx,%r13,8), %rdi
testq %rdi, %rdi
je 0x20bbb8
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x20bbb8
movq (%r14), %rdi
addq %r12, %rdi
movq (%r15), %rax
movq (%rax,%r13,8), %rsi
callq 0x2085be
incq %r13
addq $0x10, %r12
jmp 0x20bb77
movq 0x20(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x20bbdb
movq %rax, 0x28(%rbx)
jmp 0x20bbdb
movq 0x28(%rbx), %rcx
subq 0x20(%rbx), %rcx
sarq $0x4, %rcx
cmpq %rax, %rcx
sete 0x38(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x20bbe7
movq %rax, %rbx
movq %r14, %rdi
callq 0x208898
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_add_op<double>::process<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>, std::vector>(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process(const Sequence<Type,Allocator>& arg_list)
         {
            switch (arg_list.size())
            {
               case 0  : return T(0);
               case 1  : return process_1(arg_list);
               case 2  : return process_2(arg_list);
               case 3  : return process_3(arg_list);
               case 4  : return process_4(arg_list);
               case 5  : return process_5(arg_list);
               default :
                         {
                            T result = T(0);

                            for (std::size_t i = 0; i < arg_list.size(); ++i)
                            {
                               result += value(arg_list[i]);
                            }

                            return result;
                         }
            }
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x4, %rdx
cmpq $0x5, %rdx
ja 0x20bd09
leaq 0xc40fc(%rip), %rcx     # 0x2cfd98
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
xorpd %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x20bdd6
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x20bd56
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x20bd8a
movq (%rax), %rdi
movq (%rdi), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmpq *0x18(%rax)
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x20be3c
xorpd %xmm0, %xmm0
xorl %r14d, %r14d
xorl %r15d, %r15d
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rcx, %r15
jae 0x20bca9
movq (%rax,%r14), %rdi
movq (%rdi), %rax
movsd %xmm0, 0x8(%rsp)
callq *0x18(%rax)
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incq %r15
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
addq $0x10, %r14
jmp 0x20bd13
nop