// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_covovoc_expression0::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])
            {
               // (c0 o0 v0) o1 (v1 o2 c1)
               const details::cov_base_node<Type>* cov = static_cast<details::cov_base_node<Type>*>(branch[0]);
               const details::voc_base_node<Type>* voc = static_cast<details::voc_base_node<Type>*>(branch[1]);
               const Type  c0 = cov->c();
               const Type& v0 = cov->v();
               const Type  c1 = voc->c();
               const Type& v1 = voc->v();
               const details::operator_type o0 = cov->operation();
               const details::operator_type o1 = operation;
               const details::operator_type o2 = voc->operation();

               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);

               expression_node_ptr result = error_node();

               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // (c0 + v0) + (v1 + c1) --> (covov) (c0 + c1) + v0 + v1
                  if ((details::e_add == o0) && (details::e_add == o1) && (details::e_add == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t+t)+t", (c0 + c1), v0, v1, result);

                     exprtk_debug(("(c0 + v0) + (v1 + c1) --> (covov) (c0 + c1) + v0 + v1\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 + v0) - (v1 + c1) --> (covov) (c0 - c1) + v0 - v1
                  else if ((details::e_add == o0) && (details::e_sub == o1) && (details::e_add == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t+t)-t", (c0 - c1), v0, v1, result);

                     exprtk_debug(("(c0 + v0) - (v1 + c1) --> (covov) (c0 - c1) + v0 - v1\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 - v0) - (v1 - c1) --> (covov) (c0 + c1) - v0 - v1
                  else if ((details::e_sub == o0) && (details::e_sub == o1) && (details::e_sub == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "t-(t+t)", (c0 + c1), v0, v1, result);

                     exprtk_debug(("(c0 - v0) - (v1 - c1) --> (covov) (c0 + c1) - v0 - v1\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 * v0) * (v1 * c1) --> (covov) (c0 * c1) * v0 * v1
                  else if ((details::e_mul == o0) && (details::e_mul == o1) && (details::e_mul == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)*t", (c0 * c1), v0, v1, result);

                     exprtk_debug(("(c0 * v0) * (v1 * c1) --> (covov) (c0 * c1) * v0 * v1\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 * v0) / (v1 * c1) --> (covov) (c0 / c1) * (v0 / v1)
                  else if ((details::e_mul == o0) && (details::e_div == o1) && (details::e_mul == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)/t", (c0 / c1), v0, v1, result);

                     exprtk_debug(("(c0 * v0) / (v1 * c1) --> (covov) (c0 / c1) * (v0 / v1)\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 / v0) * (v1 / c1) --> (covov) (c0 / c1) * (v1 / v0)
                  else if ((details::e_div == o0) && (details::e_mul == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "t*(t/t)", (c0 / c1), v1, v0, result);

                     exprtk_debug(("(c0 / v0) * (v1 / c1) --> (covov) (c0 / c1) * (v1 / v0)\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 / v0) / (v1 / c1) --> (covov) (c0 * c1) / (v0 * v1)
                  else if ((details::e_div == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "t/(t*t)", (c0 * c1), v0, v1, result);

                     exprtk_debug(("(c0 / v0) / (v1 / c1) --> (covov) (c0 * c1) / (v0 * v1)\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 * v0) / (v1 / c1) --> (covov) (c0 * c1) * (v0 / v1)
                  else if ((details::e_mul == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)/t", (c0 * c1), v0, v1, result);

                     exprtk_debug(("(c0 * v0) / (v1 / c1) --> (covov) (c0 * c1) * (v0 / v1)\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 / v0) / (v1 * c1) --> (covov) (c0 / c1) / (v0 * v1)
                  else if ((details::e_div == o0) && (details::e_div == o1) && (details::e_mul == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "t/(t*t)", (c0 / c1), v0, v1, result);

                     exprtk_debug(("(c0 / v0) / (v1 * c1) --> (covov) (c0 / c1) / (v0 * v1)\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c * v0) +/- (v1 * c) --> (covov) c * (v0 +/- v1)
                  else if (
                            (std::equal_to<T>()(c0,c1)) &&
                            (details::e_mul == o0)      &&
                            (details::e_mul == o2)      &&
                            (
                              (details::e_add == o1) ||
                              (details::e_sub == o1)
                            )
                          )
                  {
                     std::string specfunc;

                     switch (o1)
                     {
                        case details::e_add : specfunc = "t*(t+t)"; break;
                        case details::e_sub : specfunc = "t*(t-t)"; break;
                        default             : return error_node();
                     }

                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, specfunc, c0, v0, v1, result);

                     exprtk_debug(("(c * v0) +/- (v1 * c) --> (covov) c * (v0 +/- v1)\n"));

                     return (synthesis_result) ? result : error_node();
                  }
               }

               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, v1, c1, result);

               if (synthesis_result)
                  return result;

               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);

               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, v1, c1, f0, f1, f2);
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x8(%rdx), %rax
movq %rax, 0x60(%rsp)
movq (%rdx), %r12
movq 0x8(%rdx), %r15
movq (%r12), %rax
movq %r12, %rdi
callq *0x40(%rax)
movsd %xmm0, 0x8(%rsp)
movq (%r12), %rax
movq %r12, %rdi
callq *0x48(%rax)
movq %rax, 0x58(%rsp)
movq (%r15), %rax
movq %r15, %rdi
callq *0x40(%rax)
movsd %xmm0, 0x10(%rsp)
movq (%r15), %rax
movq %r15, %rdi
callq *0x48(%rax)
movq %rax, %rbp
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
movl %eax, %r12d
movl %eax, 0x4c(%rsp)
movl (%r13), %r13d
movl %r13d, 0x48(%rsp)
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movl %eax, %r15d
movl %eax, 0x44(%rsp)
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x1ad9c8
movq 0x8(%rbx), %rdi
movq 0x60(%rsp), %rsi
callq 0x1ad9c8
movl %r13d, %ecx
movq %rbp, %r13
movq 0x58(%rsp), %rbp
movl %r12d, %edx
andq $0x0, (%rsp)
movq %rbx, %r12
movq 0x68(%rbx), %rax
cmpb $0x1, 0xd6(%rax)
jne 0x1a940b
movq %r13, %r14
movq %rbp, %rbx
movl %edx, %eax
xorl $0x2, %eax
movl %ecx, %esi
xorl $0x2, %esi
orl %eax, %esi
movl %r15d, %edi
xorl $0x2, %edi
orl %edi, %esi
jne 0x1a90f3
leaq 0x13057a(%rip), %rsi    # 0x2d9637
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x127016
movsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
leaq 0x20(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1b833a
jmp 0x1a9361
movl %ecx, %esi
xorl $0x3, %esi
orl %esi, %eax
orl %edi, %eax
jne 0x1a913b
leaq 0x13052a(%rip), %rsi    # 0x2d962f
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x127016
movsd 0x8(%rsp), %xmm0
subsd 0x10(%rsp), %xmm0
leaq 0x20(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1b833a
jmp 0x1a9361
movl %edx, %eax
xorl $0x3, %eax
orl %esi, %eax
movl %r15d, %esi
xorl $0x3, %esi
orl %eax, %esi
jne 0x1a9189
leaq 0x130584(%rip), %rsi    # 0x2d96d7
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x127016
movsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
leaq 0x20(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1b833a
jmp 0x1a9361
movl %edx, %eax
xorl $0x4, %eax
movl %ecx, %esi
xorl $0x4, %esi
movl %eax, %edi
orl %esi, %edi
movl %r15d, %r11d
xorl $0x4, %r11d
orl %r11d, %edi
jne 0x1a91e0
leaq 0x1304c5(%rip), %rsi    # 0x2d966f
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x127016
movsd 0x8(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
leaq 0x20(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1b833a
jmp 0x1a9361
movl %ecx, %edi
xorl $0x5, %edi
movl %eax, %r8d
orl %edi, %r8d
sete %r10b
orl %r11d, %r8d
jne 0x1a9231
leaq 0x13046c(%rip), %rsi    # 0x2d9667
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x127016
movsd 0x8(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
leaq 0x20(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1b833a
jmp 0x1a9361
movl %edx, %r8d
xorl $0x5, %r8d
orl %r8d, %esi
movl %r15d, %r9d
xorl $0x5, %r9d
orl %r9d, %esi
jne 0x1a9284
leaq 0x130481(%rip), %rsi    # 0x2d96cf
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x127016
movsd 0x8(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
leaq 0x20(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1b833a
jmp 0x1a9361
orl %edi, %r8d
sete %sil
orl %r9d, %r8d
jne 0x1a92cd
leaq 0x130410(%rip), %rsi    # 0x2d96a7
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x127016
movsd 0x8(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
leaq 0x20(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1b833a
jmp 0x1a9361
cmpl $0x5, %r15d
setne %dil
xorb $0x1, %r10b
orb %dil, %r10b
jne 0x1a9318
leaq 0x130382(%rip), %rsi    # 0x2d9667
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x127016
movsd 0x8(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
leaq 0x20(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1b833a
jmp 0x1a9361
cmpl $0x4, %r15d
setne %dil
xorb $0x1, %sil
orb %dil, %sil
jne 0x1a937a
leaq 0x130377(%rip), %rsi    # 0x2d96a7
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x127016
movsd 0x8(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
leaq 0x20(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1b833a
movl %eax, %ebx
leaq 0x20(%rsp), %rdi
callq 0x118648
testb %bl, %bl
jne 0x1a9451
jmp 0x1a94dc
movsd 0x8(%rsp), %xmm0
ucomisd 0x10(%rsp), %xmm0
setnp %dil
sete %sil
andb %dil, %sil
orl %r11d, %eax
movl %ecx, %edi
andl $-0x2, %edi
xorl $0x2, %edi
orl %eax, %edi
sete %al
andb %sil, %al
cmpb $0x1, %al
movq %rbx, %rbp
movq %r14, %r13
jne 0x1a940b
leaq 0x30(%rsp), %rax
andq $0x0, -0x8(%rax)
cmpl $0x2, %ecx
movq %rax, -0x10(%rax)
movb $0x0, (%rax)
leaq 0x1302ee(%rip), %rax    # 0x2d96b7
leaq 0x1302ef(%rip), %rsi    # 0x2d96bf
cmoveq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0x118600
leaq 0x20(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1b833a
testb %al, %al
je 0x1a94f0
movq (%rsp), %rbx
jmp 0x1a94f2
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %r8d
callq 0x1e0dc4
movq %rsp, %r8
movq %r12, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
movq %rbp, %rdx
movq %r13, %rcx
movsd 0x10(%rsp), %xmm1
callq 0x1e0d5e
movl %eax, %ebx
movq %rbp, %r14
leaq 0x20(%rsp), %rdi
callq 0x118648
testb %bl, %bl
je 0x1a945a
movq (%rsp), %rbx
jmp 0x1a94de
leaq 0x20(%rsp), %rdx
andq $0x0, (%rdx)
andq $0x0, 0x18(%rsp)
andq $0x0, 0x50(%rsp)
leaq 0x4c(%rsp), %rsi
movq %r12, %rdi
callq 0x1b28a2
testb %al, %al
je 0x1a94dc
leaq 0x48(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0x1b28a2
testb %al, %al
je 0x1a94dc
leaq 0x44(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %r12, %rdi
callq 0x1b28a2
testb %al, %al
je 0x1a94dc
movq 0x8(%r12), %rdi
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x50(%rsp), %r9
movsd 0x8(%rsp), %xmm0
movq %r14, %rsi
movq %r13, %rdx
movsd 0x10(%rsp), %xmm1
callq 0x1e56ca
movq %rax, %rbx
jmp 0x1a94de
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
leaq 0x20(%rsp), %rdi
callq 0x118648
jmp 0x1a94de
jmp 0x1a9529
jmp 0x1a9529
jmp 0x1a9529
jmp 0x1a9524
jmp 0x1a9529
jmp 0x1a9524
jmp 0x1a9529
jmp 0x1a9524
jmp 0x1a9529
jmp 0x1a9524
jmp 0x1a9529
jmp 0x1a9524
jmp 0x1a9529
jmp 0x1a9524
jmp 0x1a9529
jmp 0x1a9524
jmp 0x1a9529
jmp 0x1a9524
jmp 0x1a9529
movq %rax, %rbx
jmp 0x1a9536
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360