// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::details::string_to_real<char const*, double>(char const*&, char const*, double&, exprtk::details::numeric::details::real_type_tag)
inline bool string_to_real(Iterator& itr_external, const Iterator end, T& t, numeric::details::real_type_tag)
      {
         if (end == itr_external) return false;

         Iterator itr = itr_external;

         T d = T(0);

         const bool negative = ('-' == (*itr));

         if (negative || '+' == (*itr))
         {
            if (end == ++itr)
               return false;
         }

         bool instate = false;

         static const char_t zero = static_cast<uchar_t>('0');

         #define parse_digit_1(d)          \
         if ((digit = (*itr - zero)) < 10) \
            { d = d * T(10) + digit; }     \
         else                              \
            { break; }                     \
         if (end == ++itr) break;          \

         #define parse_digit_2(d)          \
         if ((digit = (*itr - zero)) < 10) \
            { d = d * T(10) + digit; }     \
         else                              \
            { break; }                     \
            ++itr;                         \

         if ('.' != (*itr))
         {
            const Iterator curr = itr;

            while ((end != itr) && (zero == (*itr))) ++itr;

            while (end != itr)
            {
               unsigned int digit;
               parse_digit_1(d)
               parse_digit_1(d)
               parse_digit_2(d)
            }

            if (curr != itr) instate = true;
         }

         int exponent = 0;

         if (end != itr)
         {
            if ('.' == (*itr))
            {
               const Iterator curr = ++itr;
               T tmp_d = T(0);

               while (end != itr)
               {
                  unsigned int digit;
                  parse_digit_1(tmp_d)
                  parse_digit_1(tmp_d)
                  parse_digit_2(tmp_d)
               }

               if (curr != itr)
               {
                  instate = true;

                  const int frac_exponent = static_cast<int>(-std::distance(curr, itr));

                  if (!valid_exponent<T>(frac_exponent, numeric::details::real_type_tag()))
                     return false;

                  d += compute_pow10(tmp_d, frac_exponent);
               }

               #undef parse_digit_1
               #undef parse_digit_2
            }

            if (end != itr)
            {
               typename std::iterator_traits<Iterator>::value_type c = (*itr);

               if (('e' == c) || ('E' == c))
               {
                  int exp = 0;

                  if (!details::string_to_type_converter_impl_ref(++itr, end, exp))
                  {
                     if (end == itr)
                        return false;
                     else
                        c = (*itr);
                  }

                  exponent += exp;
               }

               if (end != itr)
               {
                  if (('f' == c) || ('F' == c) || ('l' == c) || ('L' == c))
                     ++itr;
                  else if ('#' == c)
                  {
                     if (end == ++itr)
                        return false;
                     else if (('I' <= (*itr)) && ((*itr) <= 'n'))
                     {
                        if (('i' == (*itr)) || ('I' == (*itr)))
                        {
                           return parse_inf(itr, end, t, negative);
                        }
                        else if (('n' == (*itr)) || ('N' == (*itr)))
                        {
                           return parse_nan(itr, end, t);
                        }
                        else
                           return false;
                     }
                     else
                        return false;
                  }
                  else if (('I' <= (*itr)) && ((*itr) <= 'n'))
                  {
                     if (('i' == (*itr)) || ('I' == (*itr)))
                     {
                        return parse_inf(itr, end, t, negative);
                     }
                     else if (('n' == (*itr)) || ('N' == (*itr)))
                     {
                        return parse_nan(itr, end, t);
                     }
                     else
                        return false;
                  }
                  else
                     return false;
               }
            }
         }

         if ((end != itr) || (!instate))
            return false;
         else if (!valid_exponent<T>(exponent, numeric::details::real_type_tag()))
            return false;
         else if (exponent)
            d = compute_pow10(d,exponent);

         t = static_cast<T>((negative) ? -d : d);
         return true;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %r12
cmpq %rsi, %r12
je 0x1a0dbf
movq %rdx, %r13
movq %rsi, %r14
movq %r12, (%rsp)
movzbl (%r12), %ebp
cmpl $0x2d, %ebp
je 0x1a0acb
cmpl $0x2b, %ebp
jne 0x1a0ae1
incq %r12
movq %r12, (%rsp)
cmpq %r14, %r12
je 0x1a0dbf
movb (%r12), %al
jmp 0x1a0ae3
movl %ebp, %eax
cmpb $0x2e, %al
jne 0x1a0af2
xorpd %xmm3, %xmm3
xorl %esi, %esi
jmp 0x1a0bb2
movq %r12, %rax
cmpq %r14, %rax
je 0x1a0b08
cmpb $0x30, (%rax)
jne 0x1a0b08
incq %rax
movq %rax, (%rsp)
jmp 0x1a0af5
leaq 0x1(%rax), %rcx
xorpd %xmm3, %xmm3
movsd 0x12d6d8(%rip), %xmm0   # 0x2ce1f0
leaq -0x1(%rcx), %rdx
cmpq %r14, %rdx
je 0x1a0b9f
movsbl (%rdx), %edx
addl $-0x30, %edx
cmpl $0x9, %edx
ja 0x1a0b9c
cvtsi2sd %edx, %xmm1
mulsd %xmm0, %xmm3
addsd %xmm1, %xmm3
movq %rcx, (%rsp)
cmpq %r14, %rcx
je 0x1a0b8e
movsbl (%rcx), %edx
addl $-0x30, %edx
cmpl $0x9, %edx
ja 0x1a0b93
cvtsi2sd %edx, %xmm1
mulsd %xmm0, %xmm3
addsd %xmm1, %xmm3
leaq 0x1(%rcx), %rdx
movq %rdx, (%rsp)
cmpq %r14, %rdx
je 0x1a0b98
movsbl (%rdx), %esi
addl $-0x30, %esi
cmpl $0x9, %esi
ja 0x1a0b9f
cvtsi2sd %esi, %xmm1
mulsd %xmm0, %xmm3
addsd %xmm1, %xmm3
addq $0x3, %rax
leaq 0x2(%rcx), %rdx
movq %rdx, (%rsp)
addq $0x3, %rcx
jmp 0x1a0b18
movq %rcx, %rdx
jmp 0x1a0b9f
incq %rax
jmp 0x1a0b9c
addq $0x2, %rax
movq %rax, %rdx
cmpq %rdx, %r12
setne %sil
cmpq %r14, %rdx
je 0x1a0d30
movq %rdx, %r12
cmpb $0x2e, (%r12)
jne 0x1a0c9f
xorpd %xmm0, %xmm0
pushq $0x1
popq %rax
pushq $0x3
popq %rcx
movsd 0x12d621(%rip), %xmm1   # 0x2ce1f0
leaq (%r12,%rcx), %rdx
addq $-0x2, %rdx
movq %rdx, (%rsp)
cmpq %r14, %rdx
je 0x1a0c5a
movsbl (%rdx), %edx
addl $-0x30, %edx
cmpl $0x9, %edx
ja 0x1a0c67
cvtsi2sd %edx, %xmm2
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
leaq (%r12,%rcx), %rdx
decq %rdx
movq %rdx, (%rsp)
cmpq %r14, %rdx
je 0x1a0c4c
movsbl (%rdx), %edx
addl $-0x30, %edx
cmpl $0x9, %edx
ja 0x1a0c4c
cvtsi2sd %edx, %xmm2
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
leaq (%r12,%rcx), %rdx
movq %rdx, (%rsp)
cmpq %r14, %rdx
je 0x1a0c5e
movsbl (%rdx), %edx
addl $-0x30, %edx
cmpl $0x9, %edx
ja 0x1a0c63
cvtsi2sd %edx, %xmm2
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
addq $0x3, %rax
addq $0x3, %rcx
jmp 0x1a0bcf
addq %rcx, %r12
decq %r12
decq %rcx
movq %rcx, %rax
jmp 0x1a0c70
addq $-0x2, %rcx
movq %rcx, %rax
jmp 0x1a0c67
addq $0x2, %rax
addq %rax, %r12
cmpq $0x1, %rax
je 0x1a0c9f
leal 0x133(%rax), %ecx
cmpl $0x268, %ecx            # imm = 0x268
ja 0x1a0dbf
pushq $0x1
popq %rdi
subl %eax, %edi
movapd %xmm3, 0x10(%rsp)
callq 0x1a0de0
movapd 0x10(%rsp), %xmm3
addsd %xmm0, %xmm3
movb $0x1, %sil
cmpq %r14, %r12
je 0x1a0d30
movb (%r12), %bl
movl %ebx, %eax
andb $-0x21, %al
xorl %edi, %edi
cmpb $0x45, %al
jne 0x1a0cfe
movl %esi, 0x8(%rsp)
movapd %xmm3, 0x10(%rsp)
leaq 0xc(%rsp), %rdx
andl $0x0, (%rdx)
incq %r12
movq %rsp, %r15
movq %r12, (%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a0e5c
movq (%r15), %r12
testb %al, %al
jne 0x1a0cf0
cmpq %r14, %r12
je 0x1a0dbf
movb (%r12), %bl
movl 0xc(%rsp), %edi
movapd 0x10(%rsp), %xmm3
movl 0x8(%rsp), %esi
cmpq %r14, %r12
je 0x1a0d32
movzbl %bl, %eax
leal -0x46(%rax), %ecx
cmpl $0x26, %ecx
ja 0x1a0d74
movabsq $0x4100000041, %rdx     # imm = 0x4100000041
btq %rcx, %rdx
jae 0x1a0d74
incq %r12
movq %r12, (%rsp)
cmpq %r14, %r12
jne 0x1a0dbf
jmp 0x1a0d32
xorl %edi, %edi
xorl %eax, %eax
testb %sil, %sil
je 0x1a0dc1
leal 0x134(%rdi), %ecx
cmpl $0x268, %ecx            # imm = 0x268
ja 0x1a0dc1
testl %edi, %edi
je 0x1a0d5c
movapd %xmm3, %xmm0
callq 0x1a0de0
movapd %xmm0, %xmm3
cmpb $0x2d, %bpl
jne 0x1a0d6a
xorpd 0x12d416(%rip), %xmm3   # 0x2ce180
movsd %xmm3, (%r13)
movb $0x1, %al
jmp 0x1a0dc1
cmpl $0x23, %eax
jne 0x1a0d85
incq %r12
movq %r12, (%rsp)
cmpq %r14, %r12
je 0x1a0dbf
movzbl (%r12), %eax
leal -0x49(%rax), %ecx
cmpb $0x25, %cl
ja 0x1a0dbf
cmpl $0x49, %eax
je 0x1a0da6
cmpl $0x4e, %eax
je 0x1a0dd0
cmpl $0x6e, %eax
je 0x1a0dd0
cmpl $0x69, %eax
jne 0x1a0dbf
xorl %ecx, %ecx
cmpb $0x2d, %bpl
sete %cl
movq %rsp, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x126f75
jmp 0x1a0dde
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x126fd7
jmp 0x1a0dc1