// File: /workspace/github_cpp_makefile_star2_O3/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 (%rdx), %rdi
testq %rdi, %rdi
je 0x29b6f5
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x1, %eax
sete %bpl
jmp 0x29b6f7
xorl %ebp, %ebp
leaq 0x8(%rbx), %r15
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x29b737
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x1, %eax
sete %al
movl %ebp, %ecx
andb %al, %cl
cmpb $0x1, %cl
jne 0x29b739
movl (%r12), %eax
cmpl $0x10, %eax
je 0x29b8ed
cmpl $0x12, %eax
jne 0x29b993
xorps %xmm0, %xmm0
jmp 0x29b8f5
xorl %eax, %eax
movl %ebp, %ecx
xorb $0x1, %cl
movl (%r12), %edx
cmpl $0x12, %edx
je 0x29b774
cmpl $0x10, %edx
jne 0x29b7e4
movzbl %cl, %r15d
movl $0x38, %edi
callq 0x11e0f0
movq %rax, %r14
movq (%rbx,%r15,8), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0x2eeaf2
jmp 0x29b793
movzbl %cl, %r15d
movl $0x38, %edi
callq 0x11e0f0
movq %rax, %r14
movq (%rbx,%r15,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x2eeaf2
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 0x29b9c4
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x29b9c4
leaq (%rbx,%r15,8), %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x29b7dc
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x29b9c4
movq %rbx, %rdi
jmp 0x29b98c
testb %bpl, %bpl
je 0x29b827
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x29b817
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x29b817
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x29b80f
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x29b817
movq %rbx, %rdi
callq 0x1ea63e
movq 0x8(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, (%r15)
jmp 0x29b85b
testb %al, %al
je 0x29b85b
movq (%r15), %rdi
testq %rdi, %rdi
je 0x29b81e
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x29b81e
movq (%r15), %rdi
testq %rdi, %rdi
je 0x29b851
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x29b81e
movq %r15, %rdi
callq 0x1ea63e
jmp 0x29b81e
movl (%r12), %eax
addl $-0x2, %eax
movq (%rbx), %r14
cmpl $0x6, %eax
jb 0x29b9c4
testq %r14, %r14
je 0x29b89c
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x29b89c
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x29b894
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x29b89c
movq %rbx, %rdi
callq 0x1ea63e
movl (%r12), %eax
cmpl $0x1b, %eax
ja 0x29b8af
movl $0xff0c000, %ecx        # imm = 0xFF0C000
btl %eax, %ecx
jb 0x29b8bb
addl $-0x57, %eax
cmpl $0x3, %eax
jae 0x29b9d4
movl $0x28, %edi
callq 0x11e0f0
movq %rax, %r14
movb $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
leaq 0x23c3de(%rip), %rax    # 0x4d7cb8
movq %rax, (%r14)
leaq 0x23c41c(%rip), %rax    # 0x4d7d00
movq %rax, 0x8(%r14)
jmp 0x29b9c4
movsd 0xed72b(%rip), %xmm0    # 0x389020
movsd %xmm0, 0x8(%rsp)
movl $0x28, %edi
callq 0x11e0f0
movq %rax, %r14
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
leaq 0x23c39d(%rip), %rax    # 0x4d7cb8
movq %rax, (%r14)
leaq 0x23c3db(%rip), %rax    # 0x4d7d00
movq %rax, 0x8(%r14)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%r14)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x29b963
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x29b963
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x29b95b
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x29b963
movq %rbx, %rdi
callq 0x1ea63e
movq (%r15), %rdi
testq %rdi, %rdi
je 0x29b9c4
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x29b9c4
movq (%r15), %rdi
testq %rdi, %rdi
je 0x29b989
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x29b9c4
movq %r15, %rdi
callq 0x1ea63e
jmp 0x29b9c4
movq (%r15), %rdi
testq %rdi, %rdi
je 0x29b9c1
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x29b9c1
movq (%r15), %rdi
testq %rdi, %rdi
je 0x29b9b9
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x29b9c1
movq %r15, %rdi
callq 0x1ea63e
movq (%rbx), %r14
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x11e0f0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
leaq 0x23b249(%rip), %rax    # 0x4d6c38
movq %rax, (%r14)
leaq 0x23b287(%rip), %rax    # 0x4d6c80
jmp 0x29b8e4
jmp 0x29ba00
movq %rax, %rbx
movl $0x38, %esi
movq %r14, %rdi
callq 0x11e0c0
movq %rbx, %rdi
callq 0x11e330