// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_covocov_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 (c1 o2 v1)
               const details::cov_base_node<Type>* cov0 = static_cast<details::cov_base_node<Type>*>(branch[0]);
               const details::cov_base_node<Type>* cov1 = static_cast<details::cov_base_node<Type>*>(branch[1]);
               const Type  c0 = cov0->c();
               const Type& v0 = cov0->v();
               const Type  c1 = cov1->c();
               const Type& v1 = cov1->v();
               const details::operator_type o0 = cov0->operation();
               const details::operator_type o1 = operation;
               const details::operator_type o2 = cov1->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) + (c1 + v1) --> (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) + (c1 + v1) --> (covov) (c0 + c1) + v0 + v1\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 + v0) - (c1 + v1) --> (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) - (c1 + v1) --> (covov) (c0 - c1) + v0 - v1\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 - v0) - (c1 - v1) --> (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) - (c1 - v1) --> (covov) (c0 - c1) - v0 + v1\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 * v0) * (c1 * v1) --> (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) * (c1 * v1) --> (covov) (c0 * c1) * v0 * v1\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 * v0) / (c1 * v1) --> (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) / (c1 * v1) --> (covov) (c0 / c1) * (v0 / v1)\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 / v0) * (c1 / v1) --> (covov) (c0 * c1) / (v0 * v1)
                  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), v0, v1, result);

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

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 / v0) / (c1 / v1) --> (covov) ((c0 / c1) * v1) / v0
                  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), v1, v0, result);

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

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 * v0) / (c1 / v1) --> (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) / (c1 / v1) --> (covov) (c0 / c1) * (v0 * v1)\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 / v0) / (c1 * v1) --> (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) / (c1 * v1) --> (covov) (c0 / c1) / (v0 * v1)\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c * v0) +/- (c * v1) --> (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) +/- (c * v1) --> (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, c1, v1, 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, c1, v1, 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 0x1a87e1
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 0x1a84c9
leaq 0x1311a4(%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 0x1a8737
movl %ecx, %esi
xorl $0x3, %esi
orl %esi, %eax
orl %edi, %eax
jne 0x1a8511
leaq 0x131154(%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 0x1a8737
movl %edx, %eax
xorl $0x3, %eax
orl %esi, %eax
movl %r15d, %esi
xorl $0x3, %esi
orl %eax, %esi
jne 0x1a855f
leaq 0x131116(%rip), %rsi    # 0x2d963f
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 0x1a8737
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 0x1a85b6
leaq 0x1310ef(%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 0x1a8737
movl %ecx, %edi
xorl $0x5, %edi
movl %eax, %r8d
orl %edi, %r8d
sete %r10b
orl %r11d, %r8d
jne 0x1a8607
leaq 0x131096(%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 0x1a8737
movl %edx, %r8d
xorl $0x5, %r8d
orl %r8d, %esi
movl %r15d, %r9d
xorl $0x5, %r9d
orl %r9d, %esi
jne 0x1a865a
leaq 0x131083(%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 0x1a8737
orl %edi, %r8d
sete %sil
orl %r9d, %r8d
jne 0x1a86a3
leaq 0x130ffa(%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 %r14, %rdx
movq %rbx, %rcx
callq 0x1b833a
jmp 0x1a8737
cmpl $0x5, %r15d
setne %dil
xorb $0x1, %r10b
orb %dil, %r10b
jne 0x1a86ee
leaq 0x13100c(%rip), %rsi    # 0x2d96c7
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 0x1a8737
cmpl $0x4, %r15d
setne %dil
xorb $0x1, %sil
orb %dil, %sil
jne 0x1a8750
leaq 0x130fa1(%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 0x1a8827
jmp 0x1a88b2
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 0x1a87e1
leaq 0x30(%rsp), %rax
andq $0x0, -0x8(%rax)
cmpl $0x2, %ecx
movq %rax, -0x10(%rax)
movb $0x0, (%rax)
leaq 0x130f18(%rip), %rax    # 0x2d96b7
leaq 0x130f19(%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 0x1a88c6
movq (%rsp), %rbx
jmp 0x1a88c8
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %r8d
callq 0x1d72ec
movq %rsp, %r8
movq %r12, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
movq %rbp, %rdx
movsd 0x10(%rsp), %xmm1
movq %r13, %rcx
callq 0x1d7286
movl %eax, %ebx
movq %rbp, %r14
leaq 0x20(%rsp), %rdi
callq 0x118648
testb %bl, %bl
je 0x1a8830
movq (%rsp), %rbx
jmp 0x1a88b4
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 0x1a88b2
leaq 0x48(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0x1b28a2
testb %al, %al
je 0x1a88b2
leaq 0x44(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %r12, %rdi
callq 0x1b28a2
testb %al, %al
je 0x1a88b2
movq 0x8(%r12), %rdi
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x50(%rsp), %r9
movsd 0x8(%rsp), %xmm0
movq %r14, %rsi
movsd 0x10(%rsp), %xmm1
movq %r13, %rdx
callq 0x1dbbf2
movq %rax, %rbx
jmp 0x1a88b4
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 0x1a88b4
jmp 0x1a88ff
jmp 0x1a88ff
jmp 0x1a88ff
jmp 0x1a88fa
jmp 0x1a88ff
jmp 0x1a88fa
jmp 0x1a88ff
jmp 0x1a88fa
jmp 0x1a88ff
jmp 0x1a88fa
jmp 0x1a88ff
jmp 0x1a88fa
jmp 0x1a88ff
jmp 0x1a88fa
jmp 0x1a88ff
jmp 0x1a88fa
jmp 0x1a88ff
jmp 0x1a88fa
jmp 0x1a88ff
movq %rax, %rbx
jmp 0x1a890c
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360