// File: /workspace/github_cpp_makefile_star2_O1/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:
movq (%rdi), %rax
cmpq %rsi, %rax
je 0x1fc272
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rax, 0x8(%rsp)
movzbl (%rax), %ebp
cmpl $0x2d, %ebp
je 0x1fc248
cmpl $0x2b, %ebp
jne 0x1fc259
incq %rax
movq %rax, 0x8(%rsp)
cmpq %r14, %rax
je 0x1fc6ba
movq 0x8(%rsp), %rax
xorl %r15d, %r15d
cmpb $0x2e, (%rax)
jne 0x1fc275
xorpd %xmm2, %xmm2
xorl %r12d, %r12d
jmp 0x1fc326
xorl %eax, %eax
retq
movq 0x8(%rsp), %rcx
cmpq %r14, %rcx
je 0x1fc28f
cmpb $0x30, (%rcx)
jne 0x1fc28f
incq %rcx
cmpq %r14, %rcx
jne 0x1fc27f
movq %r14, %rcx
movq %rcx, 0x8(%rsp)
xorpd %xmm2, %xmm2
movsd 0x1b5db0(%rip), %xmm0   # 0x3b2050
cmpq %r14, %rcx
je 0x1fc31a
movsbl (%rcx), %edx
addl $-0x30, %edx
cmpl $0x9, %edx
ja 0x1fc30d
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
leaq 0x1(%rcx), %rsi
cmpq %r14, %rsi
je 0x1fc311
movsbl (%rsi), %edx
addl $-0x30, %edx
cmpl $0x9, %edx
ja 0x1fc311
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
leaq 0x2(%rcx), %rsi
cmpq %r14, %rsi
je 0x1fc311
movsbl (%rsi), %edx
addl $-0x30, %edx
cmpl $0x9, %edx
ja 0x1fc311
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
addq $0x3, %rcx
movb $0x1, %dl
jmp 0x1fc316
xorl %edx, %edx
jmp 0x1fc316
xorl %edx, %edx
movq %rsi, %rcx
testb %dl, %dl
jne 0x1fc2a0
movq %rcx, 0x8(%rsp)
cmpq %rcx, %rax
setne %r12b
movq 0x8(%rsp), %rcx
cmpq %r14, %rcx
je 0x1fc6b3
cmpb $0x2e, (%rcx)
jne 0x1fc4a4
leaq 0x1(%rcx), %rax
movq %rax, 0x8(%rsp)
xorpd %xmm3, %xmm3
movl $0x1, %eax
movsd 0x1b5cf9(%rip), %xmm0   # 0x3b2050
leaq (%rcx,%rax), %rdx
cmpq %r14, %rdx
je 0x1fc3ec
movsbl (%rdx), %edx
addl $-0x30, %edx
cmpl $0x9, %edx
ja 0x1fc3db
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
mulsd %xmm0, %xmm3
addsd %xmm1, %xmm3
leaq 0x1(%rax), %rsi
leaq (%rcx,%rax), %rdx
incq %rdx
cmpq %r14, %rdx
je 0x1fc3df
movsbl (%rdx), %edx
addl $-0x30, %edx
cmpl $0x9, %edx
ja 0x1fc3df
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
mulsd %xmm0, %xmm3
addsd %xmm1, %xmm3
leaq 0x2(%rax), %rsi
leaq (%rcx,%rax), %rdx
addq $0x2, %rdx
cmpq %r14, %rdx
je 0x1fc3df
movsbl (%rdx), %edx
addl $-0x30, %edx
cmpl $0x9, %edx
ja 0x1fc3df
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
mulsd %xmm0, %xmm3
addsd %xmm1, %xmm3
addq $0x3, %rax
movb $0x1, %dl
jmp 0x1fc3e4
xorl %edx, %edx
jmp 0x1fc3e4
xorl %edx, %edx
movq %rsi, %rax
testb %dl, %dl
jne 0x1fc357
addq %rax, %rcx
movq %rcx, 0x8(%rsp)
movb $0x1, %r13b
cmpq $0x1, %rax
je 0x1fc49b
leal 0x133(%rax), %ecx
movb $0x1, %r12b
cmpl $0x269, %ecx            # imm = 0x269
setb %r13b
jae 0x1fc49b
movl $0x1, %ecx
subl %eax, %ecx
movl %ecx, %edx
negl %edx
cmovsl %ecx, %edx
cmpl $0xfffffecd, %ecx       # imm = 0xFFFFFECD
jl 0x1fc450
cmpl $0x134, %edx            # imm = 0x134
ja 0x1fc46b
movl %edx, %eax
leaq 0x1f3c6f(%rip), %rdx    # 0x3f00b0
movsd (%rdx,%rax,8), %xmm0
testl %ecx, %ecx
jg 0x1fc493
divsd %xmm0, %xmm3
jmp 0x1fc497
divsd 0x1b5dc0(%rip), %xmm3   # 0x3b2218
addl $0xfffffecc, %eax       # imm = 0xFFFFFECC
leaq 0x1f3c4c(%rip), %rcx    # 0x3f00b0
divsd (%rcx,%rax,8), %xmm3
jmp 0x1fc497
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm2, 0x10(%rsp)
movsd %xmm3, 0x20(%rsp)
callq 0x1201b0
movsd 0x20(%rsp), %xmm3
movapd 0x10(%rsp), %xmm2
mulsd %xmm0, %xmm3
addsd %xmm3, %xmm2
testb %r13b, %r13b
je 0x1fc6ba
movq 0x8(%rsp), %rdx
cmpq %r14, %rdx
je 0x1fc6b3
movb (%rdx), %al
movl %eax, %ecx
andb $-0x21, %cl
xorl %r15d, %r15d
cmpb $0x45, %cl
jne 0x1fc646
leaq 0x1(%rdx), %rcx
movq %rcx, 0x8(%rsp)
cmpq %r14, %rcx
je 0x1fc519
movzbl (%rcx), %ecx
cmpl $0x2d, %ecx
je 0x1fc4e0
cmpl $0x2b, %ecx
jne 0x1fc4ee
addq $0x2, %rdx
movq %rdx, 0x8(%rsp)
cmpq %r14, %rdx
je 0x1fc519
movq 0x8(%rsp), %rdx
cmpq %r14, %rdx
je 0x1fc535
cmpb $0x30, (%rdx)
jne 0x1fc523
incq %rdx
cmpq %r14, %rdx
je 0x1fc52a
leaq 0x1(%rdx), %rsi
cmpb $0x30, (%rdx)
movq %rsi, %rdx
je 0x1fc500
decq %rsi
movq %rsi, %rdx
jmp 0x1fc530
xorl %r15d, %r15d
xorl %edi, %edi
jmp 0x1fc628
movq 0x8(%rsp), %rsi
jmp 0x1fc530
movq %r14, %rsi
movq %r14, %rdx
movq %rsi, 0x8(%rsp)
movq %r14, %r9
subq %rdx, %r9
xorl %r8d, %r8d
movl $0x0, %edi
movl $0x0, %esi
cmpq $0x4, %r9
ja 0x1fc604
xorl %esi, %esi
decq %r9
cmpq $0x3, %r9
ja 0x1fc5fe
leaq 0x1b5fa0(%rip), %rdi    # 0x3b2508
movslq (%rdi,%r9,4), %r8
addq %rdi, %r8
jmpq *%r8
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%rsp)
movsbl (%rdx), %esi
addl $-0x30, %esi
xorl %r8d, %r8d
movl $0x0, %edi
cmpl $0x9, %esi
ja 0x1fc604
movq 0x8(%rsp), %rdi
leaq 0x1(%rdi), %r8
movq %r8, 0x8(%rsp)
movsbl (%rdi), %r9d
addl $-0x30, %r9d
cmpl $0x9, %r9d
ja 0x1fc5f4
leal (%rsi,%rsi,4), %esi
leal (%r9,%rsi,2), %esi
movq 0x8(%rsp), %rdi
leaq 0x1(%rdi), %r8
movq %r8, 0x8(%rsp)
movsbl (%rdi), %r9d
addl $-0x30, %r9d
cmpl $0x9, %r9d
ja 0x1fc5f4
leal (%rsi,%rsi,4), %esi
leal (%r9,%rsi,2), %esi
movq 0x8(%rsp), %rdi
movsbl (%rdi), %r9d
addl $-0x30, %r9d
movl %esi, %r8d
xorl %esi, %esi
cmpl $0xa, %r9d
setb %dil
cmovbl %r9d, %esi
jmp 0x1fc604
xorl %edi, %edi
movl %esi, %r8d
movl %r9d, %esi
jmp 0x1fc604
movb $0x1, %dil
xorl %r8d, %r8d
cmpq %r14, %rdx
je 0x1fc61b
testb %dil, %dil
je 0x1fc61b
leal (%r8,%r8,4), %edx
leal (%rsi,%rdx,2), %r8d
incq 0x8(%rsp)
movl %r8d, %r15d
negl %r15d
cmpb $0x2d, %cl
cmovnel %r8d, %r15d
movb $0x1, %cl
testb %dil, %dil
jne 0x1fc642
movq 0x8(%rsp), %rdx
cmpq %r14, %rdx
je 0x1fc63d
movb (%rdx), %al
jmp 0x1fc642
xorl %ecx, %ecx
xorl %r15d, %r15d
testb %cl, %cl
je 0x1fc6ab
movq 0x8(%rsp), %rdx
movb $0x1, %cl
cmpq %r14, %rdx
je 0x1fc6ad
movzbl %al, %eax
leal -0x46(%rax), %esi
cmpl $0x26, %esi
ja 0x1fc677
movabsq $0x4100000041, %rdi     # imm = 0x4100000041
btq %rsi, %rdi
jae 0x1fc677
incq %rdx
movq %rdx, 0x8(%rsp)
jmp 0x1fc6ad
cmpl $0x23, %eax
jne 0x1fc689
incq %rdx
movq %rdx, 0x8(%rsp)
cmpq %r14, %rdx
je 0x1fc6ab
movzbl (%rdx), %eax
leal -0x49(%rax), %ecx
cmpb $0x25, %cl
ja 0x1fc6ab
xorl %ecx, %ecx
cmpl $0x68, %eax
jg 0x1fc70c
cmpl $0x49, %eax
je 0x1fc716
cmpl $0x4e, %eax
je 0x1fc737
jmp 0x1fc6ad
xorl %ecx, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0x1fc6bc
cmpq %r14, 0x8(%rsp)
je 0x1fc6cb
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
testb %r12b, %r12b
je 0x1fc6bc
leal 0x134(%r15), %ecx
cmpl $0x268, %ecx            # imm = 0x268
ja 0x1fc6bc
testl %r15d, %r15d
je 0x1fc6f6
movapd %xmm2, %xmm0
movl %r15d, %edi
callq 0x1fc75a
movapd %xmm0, %xmm2
cmpb $0x2d, %bpl
jne 0x1fc704
xorpd 0x1b5d3c(%rip), %xmm2   # 0x3b2440
movsd %xmm2, (%rbx)
movb $0x1, %al
jmp 0x1fc6bc
cmpl $0x6e, %eax
je 0x1fc737
cmpl $0x69, %eax
jne 0x1fc6ad
xorl %ecx, %ecx
cmpb $0x2d, %bpl
sete %cl
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movapd %xmm2, 0x10(%rsp)
callq 0x13540a
jmp 0x1fc74d
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movapd %xmm2, 0x10(%rsp)
callq 0x135473
movapd 0x10(%rsp), %xmm2
xorl %ecx, %ecx
jmp 0x1fc6af