// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_binary_ext_expression::process(exprtk::parser<double>::expression_generator<double>&, exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               const bool left_neg  = is_neg_unary_node(branch[0]);
               const bool right_neg = is_neg_unary_node(branch[1]);

               if (left_neg && right_neg)
               {
                  if (
                       (details::e_add == operation) ||
                       (details::e_sub == operation) ||
                       (details::e_mul == operation) ||
                       (details::e_div == operation)
                     )
                  {
                     if (
                          !expr_gen.parser_->simplify_unary_negation_branch(branch[0]) ||
                          !expr_gen.parser_->simplify_unary_negation_branch(branch[1])
                        )
                     {
                        details::free_all_nodes(*expr_gen.node_allocator_,branch);

                        return error_node();
                     }
                  }

                  switch (operation)
                  {
                                           // -f(x + 1) + -g(y + 1) --> -(f(x + 1) + g(y + 1))
                     case details::e_add : return expr_gen(details::e_neg,
                                              expr_gen.node_allocator_->
                                                 template allocate<typename details::binary_ext_node<Type,details::add_op<Type> > >
                                                    (branch[0],branch[1]));

                                           // -f(x + 1) - -g(y + 1) --> g(y + 1) - f(x + 1)
                     case details::e_sub : return expr_gen.node_allocator_->
                                              template allocate<typename details::binary_ext_node<Type,details::sub_op<Type> > >
                                                 (branch[1],branch[0]);

                     default             : break;
                  }
               }
               else if (left_neg && !right_neg)
               {
                  if (
                       (details::e_add == operation) ||
                       (details::e_sub == operation) ||
                       (details::e_mul == operation) ||
                       (details::e_div == operation)
                     )
                  {
                     if (!expr_gen.parser_->simplify_unary_negation_branch(branch[0]))
                     {
                        details::free_all_nodes(*expr_gen.node_allocator_,branch);

                        return error_node();
                     }

                     switch (operation)
                     {
                                              // -f(x + 1) + g(y + 1) --> g(y + 1) - f(x + 1)
                        case details::e_add : return expr_gen.node_allocator_->
                                                 template allocate<typename details::binary_ext_node<Type,details::sub_op<Type> > >
                                                   (branch[1], branch[0]);

                                              // -f(x + 1) - g(y + 1) --> -(f(x + 1) + g(y + 1))
                        case details::e_sub : return expr_gen(details::e_neg,
                                                 expr_gen.node_allocator_->
                                                    template allocate<typename details::binary_ext_node<Type,details::add_op<Type> > >
                                                       (branch[0], branch[1]));

                                              // -f(x + 1) * g(y + 1) --> -(f(x + 1) * g(y + 1))
                        case details::e_mul : return expr_gen(details::e_neg,
                                                 expr_gen.node_allocator_->
                                                    template allocate<typename details::binary_ext_node<Type,details::mul_op<Type> > >
                                                       (branch[0], branch[1]));

                                              // -f(x + 1) / g(y + 1) --> -(f(x + 1) / g(y + 1))
                        case details::e_div : return expr_gen(details::e_neg,
                                                 expr_gen.node_allocator_->
                                                    template allocate<typename details::binary_ext_node<Type,details::div_op<Type> > >
                                                       (branch[0], branch[1]));

                        default             : return error_node();
                     }
                  }
               }
               else if (!left_neg && right_neg)
               {
                  if (
                       (details::e_add == operation) ||
                       (details::e_sub == operation) ||
                       (details::e_mul == operation) ||
                       (details::e_div == operation)
                     )
                  {
                     if (!expr_gen.parser_->simplify_unary_negation_branch(branch[1]))
                     {
                        details::free_all_nodes(*expr_gen.node_allocator_,branch);

                        return error_node();
                     }

                     switch (operation)
                     {
                                              // f(x + 1) + -g(y + 1) --> f(x + 1) - g(y + 1)
                        case details::e_add : return expr_gen.node_allocator_->
                                                 template allocate<typename details::binary_ext_node<Type,details::sub_op<Type> > >
                                                   (branch[0], branch[1]);

                                              // f(x + 1) - - g(y + 1) --> f(x + 1) + g(y + 1)
                        case details::e_sub : return expr_gen.node_allocator_->
                                                 template allocate<typename details::binary_ext_node<Type,details::add_op<Type> > >
                                                   (branch[0], branch[1]);

                                              // f(x + 1) * -g(y + 1) --> -(f(x + 1) * g(y + 1))
                        case details::e_mul : return expr_gen(details::e_neg,
                                                 expr_gen.node_allocator_->
                                                    template allocate<typename details::binary_ext_node<Type,details::mul_op<Type> > >
                                                       (branch[0], branch[1]));

                                              // f(x + 1) / -g(y + 1) --> -(f(x + 1) / g(y + 1))
                        case details::e_div : return expr_gen(details::e_neg,
                                                 expr_gen.node_allocator_->
                                                    template allocate<typename details::binary_ext_node<Type,details::div_op<Type> > >
                                                       (branch[0], branch[1]));

                        default             : return error_node();
                     }
                  }
               }

               switch (operation)
               {
                  #define case_stmt(op0, op1)                                                          \
                  case op0 : return expr_gen.node_allocator_->                                         \
                                template allocate<typename details::binary_ext_node<Type,op1<Type> > > \
                                   (branch[0], branch[1]);                                             \

                  basic_opr_switch_statements
                  extended_opr_switch_statements
                  #undef case_stmt
                  default : return error_node();
               }
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq (%rdx), %rdi
testq %rdi, %rdi
je 0x2bb114
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x4b, %eax
sete %bpl
jmp 0x2bb116
xorl %ebp, %ebp
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x2bb12d
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x4b, %eax
sete %al
jmp 0x2bb12f
xorl %eax, %eax
leaq 0x8(%r14), %rbx
movl %ebp, %edx
xorb $0x1, %dl
movl %eax, %ecx
xorb $0x1, %cl
testb %dl, %dl
jne 0x2bb1de
testb %cl, %cl
jne 0x2bb1de
movl (%r12), %eax
addl $-0x2, %eax
cmpl $0x3, %eax
ja 0x2bb181
movq 0x68(%r15), %rdi
movq %r14, %rsi
callq 0x276f7a
testb %al, %al
je 0x2bb2d6
movq 0x68(%r15), %rdi
movq %rbx, %rsi
callq 0x276f7a
testb %al, %al
je 0x2bb2d6
movl (%r12), %eax
cmpl $0x3, %eax
je 0x2bb31d
cmpl $0x2, %eax
jne 0x2bb296
movl $0x34, 0x4(%rsp)
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x336828
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
leaq 0x4(%rsp), %rsi
movq %r15, %rdi
jmp 0x2bb675
orb %dl, %al
je 0x2bb23b
orb %cl, %bpl
jne 0x2bb296
movl (%r12), %eax
addl $-0x2, %eax
cmpl $0x3, %eax
ja 0x2bb296
movq 0x68(%r15), %rdi
movq %rbx, %rsi
callq 0x276f7a
testb %al, %al
je 0x2bb393
movl (%r12), %eax
addl $-0x2, %eax
cmpl $0x3, %eax
ja 0x2bb647
leaq 0xf9726(%rip), %rcx     # 0x3b494c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
jmp 0x2bb285
movl (%r12), %eax
addl $-0x2, %eax
cmpl $0x3, %eax
ja 0x2bb296
movq 0x68(%r15), %rdi
movq %r14, %rsi
callq 0x276f7a
testb %al, %al
je 0x2bb34c
movl (%r12), %eax
addl $-0x2, %eax
cmpl $0x3, %eax
ja 0x2bb647
leaq 0xf96ca(%rip), %rcx     # 0x3b493c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x336726
movl (%r12), %eax
xorl %ebx, %ebx
addl $-0x2, %eax
cmpl $0x19, %eax
ja 0x2bb67d
leaq 0xf96ad(%rip), %rcx     # 0x3b495c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x336828
jmp 0x2bb339
xorl %ebx, %ebx
xorl %r12d, %r12d
movq (%r14,%r12), %rdi
testq %rdi, %rdi
je 0x2bb30e
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2bb30e
leaq (%r14,%r12), %r15
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2bb306
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2bb30e
movq %r15, %rdi
callq 0x1f1690
addq $0x8, %r12
cmpq $0x8, %r12
je 0x2bb2db
jmp 0x2bb67d
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rdx
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x33698a
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
jmp 0x2bb67d
xorl %ebx, %ebx
xorl %r12d, %r12d
movq (%r14,%r12), %rdi
testq %rdi, %rdi
je 0x2bb384
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2bb384
leaq (%r14,%r12), %r15
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2bb37c
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2bb384
movq %r15, %rdi
callq 0x1f1690
addq $0x8, %r12
cmpq $0x8, %r12
je 0x2bb351
jmp 0x2bb67d
xorl %ebx, %ebx
xorl %r12d, %r12d
movq (%r14,%r12), %rdi
testq %rdi, %rdi
je 0x2bb3cb
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2bb3cb
leaq (%r14,%r12), %r15
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2bb3c3
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2bb3cb
movq %r15, %rdi
callq 0x1f1690
addq $0x8, %r12
cmpq $0x8, %r12
je 0x2bb398
jmp 0x2bb67d
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x337ab6
jmp 0x2bb339
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x3374e8
jmp 0x2bb339
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x336dc0
jmp 0x2bb339
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x337938
jmp 0x2bb339
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x33698a
jmp 0x2bb339
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x336f2a
jmp 0x2bb339
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x337378
jmp 0x2bb339
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x336c56
jmp 0x2bb339
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x336af4
jmp 0x2bb339
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x337094
jmp 0x2bb339
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x337206
jmp 0x2bb339
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x337c3c
jmp 0x2bb339
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x337dca
jmp 0x2bb339
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x3377c8
jmp 0x2bb339
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x337658
jmp 0x2bb339
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x3380d2
jmp 0x2bb339
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x337f4c
jmp 0x2bb339
leaq 0x4(%rsp), %r12
movl $0x34, (%r12)
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x33677c
jmp 0x2bb667
leaq 0x4(%rsp), %r12
movl $0x34, (%r12)
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3367d2
jmp 0x2bb667
xorl %ebx, %ebx
jmp 0x2bb67d
leaq 0x4(%rsp), %r12
movl $0x34, (%r12)
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3366d0
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %r15, %rdi
movq %r12, %rsi
callq 0x29b38c
movq %rax, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3366d0
jmp 0x2bb6ce
jmp 0x2bb6ce
jmp 0x2bb6ce
jmp 0x2bb6ce
jmp 0x2bb6ce
jmp 0x2bb6ce
jmp 0x2bb6ce
jmp 0x2bb6ce
jmp 0x2bb6ce
jmp 0x2bb6ce
jmp 0x2bb6ce
jmp 0x2bb6ce
jmp 0x2bb6ce
jmp 0x2bb6ce
jmp 0x2bb6ce
jmp 0x2bb6ce
jmp 0x2bb6ce
jmp 0x2bb6ce
jmp 0x2bb6ce
movq %rax, %r14
movl $0x40, %esi
movq %rbx, %rdi
callq 0x1200c0
movq %r14, %rdi
callq 0x120330