// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_null_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_null_expression(const details::operator_type& operation, expression_node_ptr (&branch)[2])
         {
            /*
             Note: The following are the type promotion rules
             that relate to operations that include 'null':
             0. null ==/!=     null --> true false
             1. null operation null --> null
             2. x    ==/!=     null --> true/false
             3. null ==/!=     x    --> true/false
             4. x   operation  null --> x
             5. null operation x    --> x
            */

            typedef typename details::null_eq_node<T> nulleq_node_t;

            const bool b0_null = details::is_null_node(branch[0]);
            const bool b1_null = details::is_null_node(branch[1]);

            if (b0_null && b1_null)
            {
               expression_node_ptr result = error_node();

               if (details::e_eq == operation)
                  result = node_allocator_->allocate_c<literal_node_t>(T(1));
               else if (details::e_ne == operation)
                  result = node_allocator_->allocate_c<literal_node_t>(T(0));

               if (result)
               {
                  details::free_node(*node_allocator_,branch[0]);
                  details::free_node(*node_allocator_,branch[1]);

                  return result;
               }

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

               return branch[0];
            }
            else if (details::e_eq == operation)
            {
               expression_node_ptr result = node_allocator_->
                                                allocate_rc<nulleq_node_t>(branch[b0_null ? 0 : 1],true);

               details::free_node(*node_allocator_,branch[b0_null ? 1 : 0]);

               return result;
            }
            else if (details::e_ne == operation)
            {
               expression_node_ptr result = node_allocator_->
                                                allocate_rc<nulleq_node_t>(branch[b0_null ? 0 : 1],false);

               details::free_node(*node_allocator_,branch[b0_null ? 1 : 0]);

               return result;
            }
            else if (b0_null)
            {
               details::free_node(*node_allocator_,branch[0]);
               branch[0] = branch[1];
               branch[1] = error_node();
            }
            else if (b1_null)
            {
               details::free_node(*node_allocator_,branch[1]);
               branch[1] = error_node();
            }

            if (
                 (details::e_add == operation) || (details::e_sub == operation) ||
                 (details::e_mul == operation) || (details::e_div == operation) ||
                 (details::e_mod == operation) || (details::e_pow == operation)
               )
            {
               return branch[0];
            }

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

            if (
                 (details::e_lt    == operation) || (details::e_lte  == operation) ||
                 (details::e_gt    == operation) || (details::e_gte  == operation) ||
                 (details::e_and   == operation) || (details::e_nand == operation) ||
                 (details::e_or    == operation) || (details::e_nor  == operation) ||
                 (details::e_xor   == operation) || (details::e_xnor == operation) ||
                 (details::e_in    == operation) || (details::e_like == operation) ||
                 (details::e_ilike == operation)
               )
            {
               return node_allocator_->allocate_c<literal_node_t>(T(0));
            }

            return node_allocator_->allocate<details::null_node<Type> >();
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq (%rdx), %rdi
testq %rdi, %rdi
je 0x2b851e
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x1, %eax
sete %bpl
jmp 0x2b8520
xorl %ebp, %ebp
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2b8537
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x1, %eax
sete %al
jmp 0x2b8539
xorl %eax, %eax
leaq 0x8(%rbx), %r15
movl %ebp, %edx
andb %al, %dl
movl (%r12), %ecx
cmpb $0x1, %dl
jne 0x2b855d
cmpl $0x10, %ecx
je 0x2b8594
cmpl $0x12, %ecx
jne 0x2b864b
xorps %xmm0, %xmm0
jmp 0x2b859c
movl %ebp, %edx
xorb $0x1, %dl
cmpl $0x12, %ecx
je 0x2b85de
cmpl $0x10, %ecx
jne 0x2b86ff
movzbl %dl, %r15d
movl $0x38, %edi
callq 0x1200f0
movq %rax, %r14
movq (%rbx,%r15,8), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0x30a0b4
jmp 0x2b85fd
movsd 0xf9a84(%rip), %xmm0    # 0x3b2020
movsd %xmm0, 0x8(%rsp)
movl $0x28, %edi
callq 0x1200f0
movq %rax, %r14
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
leaq 0x258cc6(%rip), %rax    # 0x511288
movq %rax, (%r14)
leaq 0x258d04(%rip), %rax    # 0x5112d0
movq %rax, 0x8(%r14)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%r14)
jmp 0x2b864e
movzbl %dl, %r15d
movl $0x38, %edi
callq 0x1200f0
movq %rax, %r14
movq (%rbx,%r15,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x30a0b4
movq %r14, %rdi
addq $0x8, %rdi
movq 0x8(%r14), %rax
callq *0x10(%rax)
movzbl %bpl, %r15d
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x2b87fd
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2b87fd
leaq (%rbx,%r15,8), %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b8646
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2b87fd
movq %rbx, %rdi
jmp 0x2b86b6
xorl %r14d, %r14d
testq %r14, %r14
je 0x2b86c0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b8681
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2b8681
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b8679
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2b8681
movq %rbx, %rdi
callq 0x1f1690
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2b87fd
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2b87fd
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2b86b3
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2b87fd
movq %r15, %rdi
callq 0x1f1690
jmp 0x2b87fd
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2b8782
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2b8782
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2b86f2
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2b8782
movq %r15, %rdi
callq 0x1f1690
jmp 0x2b8782
testb %bpl, %bpl
je 0x2b8742
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b8732
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2b8732
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b872a
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2b8732
movq %rbx, %rdi
callq 0x1f1690
movq 0x8(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, (%r15)
jmp 0x2b8776
testb %al, %al
je 0x2b8776
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2b8739
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2b8739
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2b876c
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2b8739
movq %r15, %rdi
callq 0x1f1690
jmp 0x2b8739
movl (%r12), %eax
addl $-0x2, %eax
cmpl $0x5, %eax
ja 0x2b8787
movq (%rbx), %r14
jmp 0x2b87fd
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b87b5
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2b87b5
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b87ad
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2b87b5
movq %rbx, %rdi
callq 0x1f1690
movl (%r12), %eax
cmpl $0x1b, %eax
ja 0x2b87c8
movl $0xff0c000, %ecx        # imm = 0xFF0C000
btl %eax, %ecx
jb 0x2b87d0
addl $-0x57, %eax
cmpl $0x3, %eax
jae 0x2b880d
movl $0x28, %edi
callq 0x1200f0
movq %rax, %r14
movb $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
leaq 0x258a99(%rip), %rax    # 0x511288
movq %rax, (%r14)
leaq 0x258ad7(%rip), %rax    # 0x5112d0
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2942ce
jmp 0x2b8824
movq %rax, %rbx
movl $0x38, %esi
movq %r14, %rdi
callq 0x1200c0
movq %rbx, %rdi
callq 0x120330