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

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

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

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

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

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

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

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

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

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

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

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

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

                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 * c) +/- (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(("(v0 * c) +/- (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), v0, c0, 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_), v0, c0, 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 0x1a9991
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 0x1a9663
leaq 0x13000a(%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 0x1a98e7
movl %ecx, %esi
xorl $0x3, %esi
orl %esi, %eax
orl %edi, %eax
jne 0x1a96ab
leaq 0x12ffba(%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 0x1a98e7
movl %edx, %eax
xorl $0x3, %eax
orl %esi, %eax
movl %r15d, %esi
xorl $0x3, %esi
orl %eax, %esi
jne 0x1a96f9
leaq 0x12ff6c(%rip), %rsi    # 0x2d962f
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 0x1b47e0
jmp 0x1a98e7
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 0x1a9750
leaq 0x12ff55(%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 0x1a98e7
movl %ecx, %r10d
xorl $0x5, %r10d
movl %eax, %edi
orl %r10d, %edi
sete %r8b
orl %r11d, %edi
jne 0x1a97a2
leaq 0x12fefb(%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 0x1a98e7
movl %edx, %edi
xorl $0x5, %edi
orl %edi, %esi
movl %r15d, %r9d
xorl $0x5, %r9d
orl %esi, %r9d
jne 0x1a97f2
leaq 0x12feab(%rip), %rsi    # 0x2d9667
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x127016
movsd 0x10(%rsp), %xmm0
divsd 0x8(%rsp), %xmm0
leaq 0x20(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1b833a
jmp 0x1a98e7
cmpl $0x5, %r15d
setne %sil
xorb $0x1, %r8b
orb %sil, %r8b
jne 0x1a9840
leaq 0x12fe65(%rip), %rsi    # 0x2d966f
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 0x1a98e7
orl %r10d, %edi
sete %r8b
orl %r11d, %edi
jne 0x1a9892
leaq 0x12fe14(%rip), %rsi    # 0x2d9667
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x127016
movsd 0x8(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm1
movsd 0x12494a(%rip), %xmm0   # 0x2ce1c0
divsd %xmm1, %xmm0
leaq 0x20(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1b833a
jmp 0x1a98e7
cmpl $0x5, %r15d
setne %sil
xorb $0x1, %r8b
orb %sil, %r8b
jne 0x1a9900
leaq 0x12fdc5(%rip), %rsi    # 0x2d966f
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x127016
movsd 0x8(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm1
movsd 0x1248f3(%rip), %xmm0   # 0x2ce1c0
divsd %xmm1, %xmm0
leaq 0x20(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1b47e0
movl %eax, %ebx
leaq 0x20(%rsp), %rdi
callq 0x118648
testb %bl, %bl
jne 0x1a99d7
jmp 0x1a9a62
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 0x1a9991
leaq 0x30(%rsp), %rax
andq $0x0, -0x8(%rax)
cmpl $0x2, %ecx
movq %rax, -0x10(%rax)
movb $0x0, (%rax)
leaq 0x12fd68(%rip), %rax    # 0x2d96b7
leaq 0x12fd69(%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 0x1a9a76
movq (%rsp), %rbx
jmp 0x1a9a78
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %r8d
callq 0x1e5b30
movq %rsp, %r8
movq %r12, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r13, %rcx
callq 0x1e5aca
movl %eax, %ebx
movq %rbp, %r14
leaq 0x20(%rsp), %rdi
callq 0x118648
testb %bl, %bl
je 0x1a99e0
movq (%rsp), %rbx
jmp 0x1a9a64
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 0x1a9a62
leaq 0x48(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0x1b28a2
testb %al, %al
je 0x1a9a62
leaq 0x44(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %r12, %rdi
callq 0x1b28a2
testb %al, %al
je 0x1a9a62
movq 0x8(%r12), %rdi
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x50(%rsp), %r9
movq %r14, %rsi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r13, %rdx
callq 0x1ea454
movq %rax, %rbx
jmp 0x1a9a64
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 0x1a9a64
jmp 0x1a9aaf
jmp 0x1a9aaf
jmp 0x1a9aaf
jmp 0x1a9aaa
jmp 0x1a9aaf
jmp 0x1a9aaa
jmp 0x1a9aaf
jmp 0x1a9aaa
jmp 0x1a9aaf
jmp 0x1a9aaa
jmp 0x1a9aaf
jmp 0x1a9aaa
jmp 0x1a9aaf
jmp 0x1a9aaa
jmp 0x1a9aaf
jmp 0x1a9aaa
jmp 0x1a9aaf
jmp 0x1a9aaa
jmp 0x1a9aaf
movq %rax, %rbx
jmp 0x1a9abc
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360