// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdx), %rdi
testq %rdi, %rdi
je 0x227b30
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x1, %eax
sete %bpl
jmp 0x227b32
xorl %ebp, %ebp
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x227b85
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x1, %eax
sete %al
movl %ebp, %ecx
andb %al, %cl
cmpb $0x1, %cl
jne 0x227b87
movl (%r12), %eax
cmpl $0x12, %eax
je 0x227c53
cmpl $0x10, %eax
jne 0x227c87
movq 0x8(%rbx), %rdi
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
jmp 0x227c60
xorl %eax, %eax
movl %ebp, %ecx
xorb $0x1, %cl
movl (%r12), %edx
cmpl $0x12, %edx
je 0x227baf
cmpl $0x10, %edx
jne 0x227bdb
movq 0x8(%rbx), %rdi
movzbl %cl, %eax
leaq (%r14,%rax,8), %rsi
leaq 0x8(%rsp), %rdx
movb $0x1, (%rdx)
jmp 0x227bc2
movq 0x8(%rbx), %rdi
movzbl %cl, %eax
leaq (%r14,%rax,8), %rsi
leaq 0x8(%rsp), %rdx
movb $0x0, (%rdx)
callq 0x265578
movq %rax, %r12
movq 0x8(%rbx), %rdi
movzbl %bpl, %eax
leaq (%r14,%rax,8), %rsi
jmp 0x227c80
testb %bpl, %bpl
je 0x227bf5
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x1ad9c8
movq 0x8(%r14), %rax
movq %rax, (%r14)
jmp 0x227c05
testb %al, %al
je 0x227c09
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x1ad9c8
andq $0x0, (%r15)
movl (%r12), %eax
addl $-0x2, %eax
cmpl $0x5, %eax
jbe 0x227c93
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x1ad9c8
movl (%r12), %eax
cmpl $0x1b, %eax
ja 0x227c34
movl $0xff0c000, %ecx        # imm = 0xFF0C000
btl %eax, %ecx
jb 0x227c3c
addl $-0x57, %eax
cmpl $0x3, %eax
jae 0x227ca6
movq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
callq 0x1ae9f6
movq %rax, %r12
jmp 0x227c96
movq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
callq 0x1ae9f6
movq %rax, %r12
testq %rax, %rax
je 0x227c87
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x1ad9c8
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x1ad9c8
jmp 0x227c96
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x1ad9c8
movq (%r14), %r12
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x208182
nop