LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::bracket_checker::result()
bool result() exprtk_override
            {
               if (!stack_.empty())
               {
                  lexer::token t;
                  t.value      = stack_.top().first;
                  t.position   = stack_.top().second;
                  error_token_ = t;
                  state_       = false;

                  return false;
               }
               else
                  return state_;
            }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x18, %rdi
callq 0x259440
testb $0x1, %al
jne 0x257fd1
leaq 0x28(%rsp), %rdi
callq 0x251250
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x259460
movq %rax, 0x8(%rsp)
jmp 0x257f53
movq 0x8(%rsp), %rax
movsbl (%rax), %esi
leaq 0x30(%rsp), %rdi
callq 0x11b720
jmp 0x257f67
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x259460
movq %rax, (%rsp)
jmp 0x257f7b
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
addq $0x68, %rdi
leaq 0x28(%rsp), %rsi
callq 0x259470
jmp 0x257f9d
movq 0x10(%rsp), %rax
movb $0x0, 0x10(%rax)
movb $0x0, 0x67(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2512e0
jmp 0x257fdf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2512e0
jmp 0x257fea
movq 0x10(%rsp), %rax
movb 0x10(%rax), %al
andb $0x1, %al
movb %al, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::numeric_checker<double>::operator()(exprtk::lexer::token const&)
bool operator() (const lexer::token& t) exprtk_override
            {
               if (token::e_number == t.type)
               {
                  T v;

                  if (!exprtk::details::string_to_real(t.value,v))
                  {
                     error_list_.push_back(current_index_);
                  }
               }

               ++current_index_;

               return true;
            }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movl $0x7, %eax
cmpl (%rcx), %eax
jne 0x25a184
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
leaq 0x10(%rsp), %rsi
callq 0x25a480
testb $0x1, %al
jne 0x25a182
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0x18, %rdi
addq $0x10, %rsi
callq 0x25a4f0
jmp 0x25a184
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::details::string_to_real<double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double&)
inline bool string_to_real(const std::string& s, T& t)
      {
         const typename numeric::details::number_type<T>::type num_type;

         char_cptr begin = s.data();
         char_cptr end   = s.data() + s.size();

         return string_to_real(begin, end, t, num_type);
      }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
leaq 0x27(%rsp), %rdi
callq 0x233dd0
movq 0x30(%rsp), %rdi
callq 0x11b230
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x11b230
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x11b270
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x18(%rsp), %rdi
callq 0x25a560
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::sequence_validator::add_invalid_set1(exprtk::lexer::token::token_type)
void add_invalid_set1(const lexer::token::token_type t)
            {
               add_invalid(t, lexer::token::e_assign);
               add_invalid(t, lexer::token::e_shr   );
               add_invalid(t, lexer::token::e_shl   );
               add_invalid(t, lexer::token::e_lte   );
               add_invalid(t, lexer::token::e_ne    );
               add_invalid(t, lexer::token::e_gte   );
               add_invalid(t, lexer::token::e_lt    );
               add_invalid(t, lexer::token::e_gt    );
               add_invalid(t, lexer::token::e_eq    );
               add_invalid(t, lexer::token::e_comma );
               add_invalid(t, lexer::token::e_div   );
               add_invalid(t, lexer::token::e_mul   );
               add_invalid(t, lexer::token::e_mod   );
               add_invalid(t, lexer::token::e_pow   );
               add_invalid(t, lexer::token::e_colon );
            }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl 0xc(%rsp), %esi
movl $0xa, %edx
callq 0x25b870
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x10, %edx
callq 0x25b870
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x11, %edx
callq 0x25b870
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x12, %edx
callq 0x25b870
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x13, %edx
callq 0x25b870
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x14, %edx
callq 0x25b870
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x3c, %edx
callq 0x25b870
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x3e, %edx
callq 0x25b870
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x3d, %edx
callq 0x25b870
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x2c, %edx
callq 0x25b870
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x2f, %edx
callq 0x25b870
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x2a, %edx
callq 0x25b870
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x25, %edx
callq 0x25b870
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x5e, %edx
callq 0x25b870
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x3a, %edx
callq 0x25b870
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::sequence_validator::operator()(exprtk::lexer::token const&, exprtk::lexer::token const&)
bool operator() (const lexer::token& t0, const lexer::token& t1) exprtk_override
            {
               const set_t::value_type p = std::make_pair(t0.type,t1.type);

               if (invalid_bracket_check(t0.type,t1.type))
               {
                  error_list_.push_back(std::make_pair(t0,t1));
               }
               else if (invalid_comb_.find(p) != invalid_comb_.end())
               {
                  error_list_.push_back(std::make_pair(t0,t1));
               }

               return true;
            }

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq 0x120(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x118(%rsp), %rdi
movq 0x110(%rsp), %rsi
callq 0x25bde0
movq 0x20(%rsp), %rdi
movq %rax, 0x108(%rsp)
movq 0x118(%rsp), %rax
movl (%rax), %esi
movq 0x110(%rsp), %rax
movl (%rax), %edx
callq 0x25cc70
testb $0x1, %al
jne 0x25bb1d
jmp 0x25bb96
movq 0x20(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x10(%rsp)
movq 0x118(%rsp), %rsi
movq 0x110(%rsp), %rdx
leaq 0xa8(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x25cec0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x25ce90
jmp 0x25bb5e
leaq 0xa8(%rsp), %rdi
callq 0x25c8b0
jmp 0x25bc4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x25c8b0
jmp 0x25bc5b
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0x108(%rsp), %rsi
callq 0x25cf20
movq 0x20(%rsp), %rdi
movq %rax, 0x90(%rsp)
addq $0x10, %rdi
callq 0x25cf60
movq %rax, 0x88(%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x25cf00
testb $0x1, %al
jne 0x25bbe5
jmp 0x25bc4d
movq 0x20(%rsp), %rax
addq $0x40, %rax
movq %rax, (%rsp)
movq 0x118(%rsp), %rsi
movq 0x110(%rsp), %rdx
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x25cec0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x25ce90
jmp 0x25bc21
leaq 0x28(%rsp), %rdi
callq 0x25c8b0
jmp 0x25bc4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x25c8b0
jmp 0x25bc5b
jmp 0x25bc4f
movb $0x1, %al
andb $0x1, %al
addq $0x128, %rsp            # imm = 0x128
retq
movq 0xa0(%rsp), %rdi
callq 0x11b4e0
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::sequence_validator_3tokens::operator()(exprtk::lexer::token const&, exprtk::lexer::token const&, exprtk::lexer::token const&)
bool operator() (const lexer::token& t0, const lexer::token& t1, const lexer::token& t2) exprtk_override
            {
               const set_t::value_type p = std::make_pair(t0.type,std::make_pair(t1.type,t2.type));

               if (invalid_comb_.find(p) != invalid_comb_.end())
               {
                  error_list_.push_back(std::make_pair(t0,t1));
               }

               return true;
            }

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rcx, 0xc8(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
callq 0x25bde0
movq 0x10(%rsp), %rdi
movq %rax, 0xb4(%rsp)
leaq 0xb4(%rsp), %rsi
callq 0x25ddf0
movq 0x18(%rsp), %rdi
movl %edx, 0xa8(%rsp)
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0xbc(%rsp)
movl 0xa8(%rsp), %eax
movl %eax, 0xc4(%rsp)
addq $0x10, %rdi
leaq 0xbc(%rsp), %rsi
callq 0x25e9b0
movq 0x18(%rsp), %rdi
movq %rax, 0x98(%rsp)
addq $0x10, %rdi
callq 0x25e9f0
movq %rax, 0x90(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x25e990
testb $0x1, %al
jne 0x25dc8c
jmp 0x25dcee
movq 0x18(%rsp), %rax
addq $0x40, %rax
movq %rax, (%rsp)
movq 0xd8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x25cec0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x25ce90
jmp 0x25dcc8
leaq 0x30(%rsp), %rdi
callq 0x25c8b0
jmp 0x25dcee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x25c8b0
jmp 0x25dcfa
movb $0x1, %al
andb $0x1, %al
addq $0xe8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::symbol_replacer::add_replace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::lexer::token::token_type)
bool add_replace(const std::string& target_symbol,
                             const std::string& replace_symbol,
                             const lexer::token::token_type token_type = lexer::token::e_symbol)
            {
               const replace_map_t::iterator itr = replace_map_.find(target_symbol);

               if (replace_map_.end() != itr)
               {
                  return false;
               }

               replace_map_[target_symbol] = std::make_pair(replace_symbol,token_type);

               return true;
            }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movl %ecx, 0x64(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x8, %rdi
movq 0x70(%rsp), %rsi
callq 0x2579f0
movq 0x10(%rsp), %rdi
movq %rax, 0x58(%rsp)
addq $0x8, %rdi
callq 0x257a40
movq %rax, 0x50(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x257a20
testb $0x1, %al
jne 0x25ecdf
jmp 0x25ece9
movb $0x0, 0x87(%rsp)
jmp 0x25ed54
movq 0x68(%rsp), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x64(%rsp), %rdx
callq 0x25f3b0
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movq 0x70(%rsp), %rsi
callq 0x25f3f0
movq %rax, 0x8(%rsp)
jmp 0x25ed17
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x25f4e0
leaq 0x28(%rsp), %rdi
callq 0x25f340
movb $0x1, 0x87(%rsp)
jmp 0x25ed54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x25f340
jmp 0x25ed65
movb 0x87(%rsp), %al
andb $0x1, %al
addq $0x88, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x11b4e0
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::helper_assembly::register_modifier(exprtk::lexer::token_modifier*)
inline bool register_modifier(lexer::token_modifier* modifier)
            {
               if (token_modifier_list.end() != std::find(token_modifier_list.begin(),
                                                          token_modifier_list.end  (),
                                                          modifier))
               {
                  return false;
               }

               token_modifier_list.push_back(modifier);

               return true;
            }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
callq 0x260360
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x18, %rdi
callq 0x2603f0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x18, %rdi
callq 0x260360
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x260390
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x260320
testb $0x1, %al
jne 0x25ee0a
jmp 0x25ee11
movb $0x0, 0x47(%rsp)
jmp 0x25ee29
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
leaq 0x30(%rsp), %rsi
callq 0x260420
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::helper_assembly::register_inserter(exprtk::lexer::token_inserter*)
inline bool register_inserter(lexer::token_inserter* inserter)
            {
               if (token_inserter_list.end() != std::find(token_inserter_list.begin(),
                                                          token_inserter_list.end  (),
                                                          inserter))
               {
                  return false;
               }

               token_inserter_list.push_back(inserter);

               return true;
            }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x48, %rdi
callq 0x261410
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x48, %rdi
callq 0x2614a0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x48, %rdi
callq 0x261410
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x261440
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2613d0
testb $0x1, %al
jne 0x25ef1a
jmp 0x25ef21
movb $0x0, 0x47(%rsp)
jmp 0x25ef39
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
leaq 0x30(%rsp), %rsi
callq 0x2614d0
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::helper_assembly::register_joiner(exprtk::lexer::token_joiner*)
inline bool register_joiner(lexer::token_joiner* joiner)
            {
               if (token_joiner_list.end() != std::find(token_joiner_list.begin(),
                                                        token_joiner_list.end  (),
                                                        joiner))
               {
                  return false;
               }

               token_joiner_list.push_back(joiner);

               return true;
            }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x30, %rdi
callq 0x2620f0
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x30, %rdi
callq 0x262180
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x30, %rdi
callq 0x2620f0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x262120
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2620b0
testb $0x1, %al
jne 0x25effa
jmp 0x25f001
movb $0x0, 0x47(%rsp)
jmp 0x25f019
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
leaq 0x30(%rsp), %rsi
callq 0x2621b0
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::helper_assembly::register_scanner(exprtk::lexer::token_scanner*)
inline bool register_scanner(lexer::token_scanner* scanner)
            {
               if (token_scanner_list.end() != std::find(token_scanner_list.begin(),
                                                         token_scanner_list.end  (),
                                                         scanner))
               {
                  return false;
               }

               token_scanner_list.push_back(scanner);

               return true;
            }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x262dd0
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
callq 0x262e60
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x262dd0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x262e00
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x262d90
testb $0x1, %al
jne 0x25f0ee
jmp 0x25f0f5
movb $0x0, 0x47(%rsp)
jmp 0x25f109
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x262e90
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::numeric::details::xnor_impl<double>(double, double, exprtk::details::numeric::details::real_type_tag)
inline T xnor_impl(const T v0, const T v1, real_type_tag)
            {
               const bool v0_true = is_true_impl(v0);
               const bool v1_true = is_true_impl(v1);

               if ((v0_true &&  v1_true) || (!v0_true && !v1_true))
                  return T(1);
               else
                  return T(0);
            }

// Assembly:
subq $0x28, %rsp
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x2670e0
andb $0x1, %al
movb %al, 0x7(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2670e0
andb $0x1, %al
movb %al, 0x6(%rsp)
testb $0x1, 0x7(%rsp)
je 0x2670a0
testb $0x1, 0x6(%rsp)
jne 0x2670ae
testb $0x1, 0x7(%rsp)
jne 0x2670be
testb $0x1, 0x6(%rsp)
jne 0x2670be
movsd 0x333f8a(%rip), %xmm0   # 0x59b040
movsd %xmm0, 0x20(%rsp)
jmp 0x2670c7
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::vov_node<double, exprtk::details::add_op<double>>::value_type>* exprtk::details::node_allocator::allocate_rr<exprtk::details::vov_node<double, exprtk::details::add_op<double>>, double const, double const>(double const&, double const&) const
inline expression_node<typename node_type::value_type>* allocate_rr(T1& t1, T2& t2) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2));
            result->node_depth();
            return result;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x30, %edi
callq 0x11b180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x282200
jmp 0x281808
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movl $0x30, %esi
callq 0x11b130
movq 0x10(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: void exprtk::details::free_node<exprtk::details::node_allocator, double>(exprtk::details::node_allocator&, exprtk::details::expression_node<double>*&)
inline void free_node(NodeAllocator&, expression_node<T>*& node)
      {
         if ((0 == node) || is_variable_node(node) || is_string_node(node))
         {
            return;
         }

         node_collection_destructor<expression_node<T> >
            ::delete_nodes(node);
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x284c0e
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x23c960
testb $0x1, %al
jne 0x284c0e
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x23c9a0
testb $0x1, %al
jne 0x284c0e
jmp 0x284c10
jmp 0x284c1a
movq 0x8(%rsp), %rdi
callq 0x23c9e0
addq $0x18, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::cov_node<double, exprtk::details::add_op<double>>::value_type>* exprtk::details::node_allocator::allocate_cr<exprtk::details::cov_node<double, exprtk::details::add_op<double>>, double, double const>(double const&, double const&) const
inline expression_node<typename node_type::value_type>* allocate_cr(const T1& t1, T2& t2) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2));
            result->node_depth();
            return result;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x30, %edi
callq 0x11b180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x2857e0
jmp 0x284c88
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movl $0x30, %esi
callq 0x11b130
movq 0x10(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::literal_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::literal_node<double>, double const>(double const&) const
inline expression_node<typename node_type::value_type>* allocate(T1& t1) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1));
            result->node_depth();
            return result;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x28, %edi
callq 0x11b180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rsi
callq 0x2856f0
jmp 0x28569f
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x28, %esi
callq 0x11b130
movq 0x18(%rsp), %rdi
callq 0x11b4e0
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::cardinal_pow_optimisation(double const&, double const&)
inline expression_node_ptr cardinal_pow_optimisation(const T& v, const T& c)
         {
            const bool not_recipricol = (c >= T(0));
            const unsigned int p = static_cast<unsigned int>(details::numeric::to_int32(details::numeric::abs(c)));

            if (0 == p)
               return node_allocator_->allocate_c<literal_node_t>(T(1));
            else if (std::equal_to<T>()(T(2),c))
            {
               return node_allocator_->
                  template allocate_rr<typename details::vov_node<Type,details::mul_op<Type> > >(v,v);
            }
            else
            {
               if (not_recipricol)
                  return cardinal_pow_optimisation_impl<T,details::ipow_node>(v,p);
               else
                  return cardinal_pow_optimisation_impl<T,details::ipowinv_node>(v,p);
            }
         }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
setae %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x28(%rsp), %rax
movsd (%rax), %xmm0
callq 0x2651a0
callq 0x287b30
movl %eax, 0x20(%rsp)
xorl %eax, %eax
cmpl 0x20(%rsp), %eax
jne 0x286ffb
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movsd 0x31405c(%rip), %xmm0   # 0x59b040
movsd %xmm0, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x287b60
movq %rax, 0x40(%rsp)
jmp 0x28707a
movsd 0x31407d(%rip), %xmm0   # 0x59b080
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rdx
leaq 0x17(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x266f00
testb $0x1, %al
jne 0x287023
jmp 0x287041
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x30(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x2818f0
movq %rax, 0x40(%rsp)
jmp 0x28707a
testb $0x1, 0x27(%rsp)
je 0x287062
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x287be0
movq %rax, 0x40(%rsp)
jmp 0x28707a
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x288300
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::string_literal_node<double>::value_type>* exprtk::details::node_allocator::allocate_c<exprtk::details::string_literal_node<double>, char [1]>(char const (&) [1]) const
inline expression_node<typename node_type::value_type>* allocate_c(const T1& t1) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1));
            result->node_depth();
            return result;
         }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl $0xa0, %edi
callq 0x11b180
movq %rax, (%rsp)
movb $0x1, 0x1b(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x11b6f0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x134520
jmp 0x4e3630
movq (%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x44b820
jmp 0x4e3640
movb $0x0, 0x1b(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11b838
leaq 0x2f(%rsp), %rdi
callq 0x11b820
movq (%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x50(%rsp), %rax
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x4e36a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11b838
leaq 0x2f(%rsp), %rdi
callq 0x11b820
testb $0x1, 0x1b(%rsp)
jne 0x4e36ba
jmp 0x4e36c8
movq (%rsp), %rdi
movl $0xa0, %esi
callq 0x11b130
jmp 0x4e36ca
movq 0x20(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::numeric::fast_exp<double, 11u>::result(double)
static inline T result(T v)
            {
               unsigned int k = N;
               T l = T(1);

               while (k)
               {
                  if (1 == (k % 2))
                  {
                     l *= v;
                     --k;
                  }

                  v *= v;
                  k /= 2;
               }

               return l;
            }

// Assembly:
movsd %xmm0, -0x8(%rsp)
movl $0xb, -0xc(%rsp)
movsd 0x30fb8a(%rip), %xmm0   # 0x59b040
movsd %xmm0, -0x18(%rsp)
cmpl $0x0, -0xc(%rsp)
je 0x28b50e
movl -0xc(%rsp), %ecx
andl $0x1, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x28b4f0
movsd -0x8(%rsp), %xmm0
mulsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x18(%rsp)
movl -0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rsp)
movsd -0x8(%rsp), %xmm0
mulsd -0x8(%rsp), %xmm0
movsd %xmm0, -0x8(%rsp)
movl -0xc(%rsp), %eax
shrl %eax
movl %eax, -0xc(%rsp)
jmp 0x28b4bc
movsd -0x18(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::parser<double>::expression_generator<double>::synthesize_sf3ext_expression::compile<double const&, double const&, double const&>(exprtk::parser<double>::expression_generator<double>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&, double const&, double const&, exprtk::details::expression_node<double>*&)
static inline bool compile(expression_generator<Type>& expr_gen, const std::string& id,
                                       T0 t0, T1 t1, T2 t2,
                                       expression_node_ptr& result)
            {
               details::operator_type sf3opr;

               if (!expr_gen.sf3_optimisable(id,sf3opr))
                  return false;
               else
                  result = synthesize_sf3ext_expression::template process<T0, T1, T2>
                              (expr_gen, sf3opr, t0, t1, t2);

               return true;
            }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x297590
testb $0x1, %al
jne 0x2972b1
movb $0x0, 0x47(%rsp)
jmp 0x2972df
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
leaq 0xc(%rsp), %rsi
callq 0x297630
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_vovov_expression0::id[abi:cxx11](exprtk::parser<double>::expression_generator<double>&, exprtk::details::operator_type, exprtk::details::operator_type)
static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "t)" << expr_gen.to_str(o1)
                  << "t";
            }

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movl %edx, 0xc4(%rsp)
movl %ecx, 0xc0(%rsp)
movq $0x40, 0x98(%rsp)
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x38(%rsp)
leaq 0x98(%rsp), %rsi
callq 0x29cb30
movq 0x38(%rsp), %rdi
leaq 0x30fb9c(%rip), %rsi    # 0x5a6ef0
callq 0x29cb90
movq %rax, 0x40(%rsp)
jmp 0x297360
movq 0xc8(%rsp), %rsi
leaq 0x68(%rsp), %rdi
leaq 0xc4(%rsp), %rdx
callq 0x29cc80
jmp 0x29737c
movq 0x40(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x29cc50
movq %rax, 0x20(%rsp)
jmp 0x297392
movq 0x20(%rsp), %rdi
leaq 0x30f6d6(%rip), %rsi    # 0x5a6a74
callq 0x29cb90
movq %rax, 0x18(%rsp)
jmp 0x2973aa
movq 0xc8(%rsp), %rsi
leaq 0x48(%rsp), %rdi
leaq 0xc0(%rsp), %rdx
callq 0x29cc80
jmp 0x2973c6
movq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x29cc50
movq %rax, 0x10(%rsp)
jmp 0x2973dc
movq 0x10(%rsp), %rdi
leaq 0x31b1f4(%rip), %rsi    # 0x5b25dc
callq 0x29cb90
movq %rax, 0x8(%rsp)
jmp 0x2973f4
movq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0x29d4a0
jmp 0x297405
leaq 0x48(%rsp), %rdi
callq 0x11b838
leaq 0x68(%rsp), %rdi
callq 0x11b838
leaq 0xa0(%rsp), %rdi
callq 0x29d4d0
movq 0x30(%rsp), %rax
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x297487
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x29747d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x11b838
leaq 0x68(%rsp), %rdi
callq 0x11b838
leaq 0xa0(%rsp), %rdi
callq 0x29d4d0
movq 0x90(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::valid_operator(exprtk::details::operator_type const&, double (*&)(double const&, double const&))
inline bool valid_operator(const details::operator_type& operation, binary_functor_t& bop)
         {
            typename binary_op_map_t::iterator bop_itr = binary_op_map_->find(operation);

            if (binary_op_map_->end() == bop_itr)
               return false;

            bop = bop_itr->second;

            return true;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x29d4e0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rsp)
movq 0x48(%rax), %rdi
callq 0x29d510
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2669f0
testb $0x1, %al
jne 0x297509
jmp 0x297510
movb $0x0, 0x37(%rsp)
jmp 0x29752b
leaq 0x10(%rsp), %rdi
callq 0x29d540
movq 0x8(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::sf3_optimisable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::details::operator_type&) const
inline bool sf3_optimisable(const std::string& sf3id, details::operator_type& operation) const
         {
            typename sf3_map_t::const_iterator itr = sf3_map_->find(sf3id);

            if (sf3_map_->end() == itr)
               return false;
            else
               operation = itr->second.second;

            return true;
         }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x297b40
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x269370
movq (%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x269190
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x269370
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x297b70
testb $0x1, %al
jne 0x297604
jmp 0x29760b
movb $0x0, 0x47(%rsp)
jmp 0x297624
leaq 0x20(%rsp), %rdi
callq 0x297b90
movl 0x28(%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::sosos_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::details::inrange_op<double>>::value_type>* exprtk::details::node_allocator::allocate_type<exprtk::details::sosos_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::details::inrange_op<double>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
inline expression_node<typename node_type::value_type>* allocate_type(T1 t1, T2 t2, T3 t3) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3));
            result->node_depth();
            return result;
         }

// Assembly:
subq $0xa8, %rsp
movq %rsi, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movl $0x68, %edi
callq 0x11b180
movq 0x18(%rsp), %rsi
movq %rax, 0x20(%rsp)
movb $0x1, 0x2f(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x11b140
jmp 0x4dc9d6
movq 0x10(%rsp), %rsi
movq 0x90(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11b140
jmp 0x4dc9f4
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x30(%rsp), %rcx
callq 0x4dd040
jmp 0x4dca0f
movb $0x0, 0x2f(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11b838
leaq 0x60(%rsp), %rdi
callq 0x11b838
movq 0x20(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x80(%rsp), %rax
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x4dca9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x4dca93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11b838
leaq 0x60(%rsp), %rdi
callq 0x11b838
testb $0x1, 0x2f(%rsp)
jne 0x4dcaa6
jmp 0x4dcab5
movq 0x20(%rsp), %rdi
movl $0x68, %esi
callq 0x11b130
jmp 0x4dcab7
movq 0x58(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::T0oT1oT2<double, double const&, double const&, double const&, exprtk::details::T0oT1oT2process<double>::mode0>::value_type>* exprtk::details::node_allocator::allocate_type<exprtk::details::T0oT1oT2<double, double const&, double const&, double const&, exprtk::details::T0oT1oT2process<double>::mode0>, double const&, double const&, double const&, double (*)(double const&, double const&), double (*)(double const&, double const&)>(double const&, double const&, double const&, double (*)(double const&, double const&), double (*)(double const&, double const&)) const
inline expression_node<typename node_type::value_type>* allocate_type(T1 t1, T2 t2,
                                                                               T3 t3, T4 t4,
                                                                               T5 t5) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3, t4, t5));
            result->node_depth();
            return result;
         }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movl $0x48, %edi
callq 0x11b180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
callq 0x29d790
jmp 0x29d737
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x48, %esi
callq 0x11b130
movq 0x18(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::parser<double>::expression_generator<double>::synthesize_sf4ext_expression::compile<double const&, double const&, double const&, double const&>(exprtk::parser<double>::expression_generator<double>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&, double const&, double const&, double const&, exprtk::details::expression_node<double>*&)
static inline bool compile(expression_generator<Type>& expr_gen, const std::string& id,
                                       T0 t0, T1 t1, T2 t2, T3 t3,
                                       expression_node_ptr& result)
            {
               details::operator_type sf4opr;

               if (!expr_gen.sf4_optimisable(id,sf4opr))
                  return false;
               else
                  result = synthesize_sf4ext_expression::template process<T0, T1, T2, T3>
                              (expr_gen, sf4opr, t0, t1, t2, t3);

               return true;
            }

// Assembly:
subq $0x48, %rsp
movq 0x50(%rsp), %rax
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x2c2930
testb $0x1, %al
jne 0x2c2636
movb $0x0, 0x47(%rsp)
jmp 0x2c2669
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %r9
leaq 0xc(%rsp), %rsi
callq 0x2c29d0
movq %rax, %rcx
movq 0x50(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_vovovov_expression0::id[abi:cxx11](exprtk::parser<double>::expression_generator<double>&, exprtk::details::operator_type, exprtk::details::operator_type, exprtk::details::operator_type)
static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "t)" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t)";
            }

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movl %edx, 0xf4(%rsp)
movl %ecx, 0xf0(%rsp)
movl %r8d, 0xec(%rsp)
movq $0x40, 0xc0(%rsp)
leaq 0xc8(%rsp), %rdi
movq %rdi, 0x40(%rsp)
leaq 0xc0(%rsp), %rsi
callq 0x29cb30
movq 0x40(%rsp), %rdi
leaq 0x2e4804(%rip), %rsi    # 0x5a6ef0
callq 0x29cb90
movq %rax, 0x48(%rsp)
jmp 0x2c26f8
movq 0xf8(%rsp), %rsi
leaq 0x90(%rsp), %rdi
leaq 0xf4(%rsp), %rdx
callq 0x29cc80
jmp 0x2c2717
movq 0x48(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x29cc50
movq %rax, 0x28(%rsp)
jmp 0x2c2730
movq 0x28(%rsp), %rdi
leaq 0x2e4338(%rip), %rsi    # 0x5a6a74
callq 0x29cb90
movq %rax, 0x20(%rsp)
jmp 0x2c2748
movq 0xf8(%rsp), %rsi
leaq 0x70(%rsp), %rdi
leaq 0xf0(%rsp), %rdx
callq 0x29cc80
jmp 0x2c2764
movq 0x20(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x29cc50
movq %rax, 0x18(%rsp)
jmp 0x2c277a
movq 0x18(%rsp), %rdi
leaq 0x2e476a(%rip), %rsi    # 0x5a6ef0
callq 0x29cb90
movq %rax, 0x10(%rsp)
jmp 0x2c2792
movq 0xf8(%rsp), %rsi
leaq 0x50(%rsp), %rdi
leaq 0xec(%rsp), %rdx
callq 0x29cc80
jmp 0x2c27ae
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x29cc50
movq %rax, 0x8(%rsp)
jmp 0x2c27c4
movq 0x8(%rsp), %rdi
leaq 0x2e42a4(%rip), %rsi    # 0x5a6a74
callq 0x29cb90
movq %rax, (%rsp)
jmp 0x2c27db
movq (%rsp), %rsi
movq 0x30(%rsp), %rdi
callq 0x29d4a0
jmp 0x2c27eb
leaq 0x50(%rsp), %rdi
callq 0x11b838
leaq 0x70(%rsp), %rdi
callq 0x11b838
leaq 0x90(%rsp), %rdi
callq 0x11b838
leaq 0xc8(%rsp), %rdi
callq 0x29d4d0
movq 0x38(%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x2c289d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x2c2890
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x2c2886
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x11b838
leaq 0x70(%rsp), %rdi
callq 0x11b838
leaq 0x90(%rsp), %rdi
callq 0x11b838
leaq 0xc8(%rsp), %rdi
callq 0x29d4d0
movq 0xb8(%rsp), %rdi
callq 0x11b4e0
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::sf4_optimisable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::details::operator_type&) const
inline bool sf4_optimisable(const std::string& sf4id, details::operator_type& operation) const
         {
            typename sf4_map_t::const_iterator itr = sf4_map_->find(sf4id);

            if (sf4_map_->end() == itr)
               return false;
            else
               operation = itr->second.second;

            return true;
         }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x60(%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x2c4170
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x26f290
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x26f0b0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x26f290
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2c41a0
testb $0x1, %al
jne 0x2c29a4
jmp 0x2c29ab
movb $0x0, 0x47(%rsp)
jmp 0x2c29c4
leaq 0x20(%rsp), %rdi
callq 0x2c41c0
movl 0x28(%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::T0oT1oT2oT3_sf4ext<double, double const&, double const&, double const&, double const&, exprtk::details::sf48_op<double>>::value_type>* exprtk::details::node_allocator::allocate_type<exprtk::details::T0oT1oT2oT3_sf4ext<double, double const&, double const&, double const&, double const&, exprtk::details::sf48_op<double>>, double const&, double const&, double const&, double const&>(double const&, double const&, double const&, double const&) const
inline expression_node<typename node_type::value_type>* allocate_type(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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movl $0x40, %edi
callq 0x11b180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0x2c5bc0
jmp 0x2c5b6c
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movl $0x40, %esi
callq 0x11b130
movq 0x10(%rsp), %rdi
callq 0x11b4e0
nopl (%rax,%rax)