// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/json.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> efgy::json::parse<long double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, efgy::json::value<long double>&)
static inline std::string parse(std::string stream,
                                efgy::json::value<Q> &pValue) {
  pValue = value<Q>();

  enum {
    scan,
    read_object,
    read_object_colon,
    read_object_value,
    read_object_comma,
    read_array,
    read_array_comma,
    read_string,
    read_string_escape,
    read_number,
    read_t,
    read_tr,
    read_tru,
    read_f,
    read_fa,
    read_fal,
    read_fals,
    read_n,
    read_nu,
    read_nul
  } state = scan;

  std::string ss;
  std::string key;

  for (std::ptrdiff_t i = 0; i < stream.size(); i++) {
    const auto c = stream[i];
    if (state >= read_t) {
      if (state == read_t && c == 'r') {
        state = read_tr;
      } else if (state == read_tr && c == 'u') {
        state = read_tru;
      } else if (state == read_tru && c == 'e') {
        pValue.type = yes;
        return stream.substr(i + 1);
      } else if (state == read_f && c == 'a') {
        state = read_fa;
      } else if (state == read_fa && c == 'l') {
        state = read_fal;
      } else if (state == read_fal && c == 's') {
        state = read_fals;
      } else if (state == read_fals && c == 'e') {
        pValue.type = no;
        return stream.substr(i + 1);
      } else if (state == read_n && c == 'u') {
        state = read_nu;
      } else if (state == read_nu && c == 'l') {
        state = read_nul;
      } else if (state == read_nul && c == 'l') {
        pValue.type = null;
        return stream.substr(i + 1);
      } else {
        // this should raise a parse errorr
        return "";
      }
    } else
      switch (state) {
        case scan:
          switch (c) {
            case '{':
              state = read_object;
              pValue.toObject();
              break;
            case '[':
              state = read_array;
              pValue.toArray();
              break;
            case '"':
              state = read_string;
              pValue.toString();
              break;
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
            case '+':
            case '-':
              state = read_number;
              pValue.toNumber();
              ss.clear();
              ss.push_back(c);
              break;
            case 't':
              state = read_t;
              break;
            case 'f':
              state = read_f;
              break;
            case 'n':
              state = read_n;
              break;
            case ',':
              pValue.type = comma;
              return stream.substr(i + 1);
            case ':':
              pValue.type = colon;
              return stream.substr(i + 1);
            case ']':
              pValue.type = endArray;
              return stream.substr(i + 1);
            case '}':
              pValue.type = endObject;
              return stream.substr(i + 1);
            case ' ':
            case '\t':
            case '\v':
            case '\n':
            case 0:
              break;
          }
          break;
        case read_object: {
          efgy::json::value<Q> v;
          std::string nstream = parse(stream.substr(i), v);
          switch (v.type) {
            case endObject:
              return nstream;
            case string:
              key = v.asString();
              state = read_object_colon;
              break;
            default:
              break;
          }
          stream = nstream;
        }
          i = -1;
          break;
        case read_object_colon: {
          efgy::json::value<Q> v;
          std::string nstream = parse(stream.substr(i), v);
          switch (v.type) {
            case endObject:
              return nstream;
            case colon:
              state = read_object_value;
              break;
            default:
              break;
          }
          stream = nstream;
        }
          i = -1;
          break;
        case read_object_value: {
          efgy::json::value<Q> v;
          std::string nstream = parse(stream.substr(i), v);
          switch (v.type) {
            case endObject:
              return nstream;
            default:
              pValue.toObject()[key] = v;
              state = read_object_comma;
              break;
          }
          stream = nstream;
        }
          i = -1;
          break;
        case read_object_comma: {
          efgy::json::value<Q> v;
          std::string nstream = parse(stream.substr(i), v);
          switch (v.type) {
            case comma:
              state = read_object;
              break;
            case endObject:
              return nstream;
            default:
              break;
          }
          stream = nstream;
        }
          i = -1;
          break;
        case read_array:
          state = read_array_comma;
          {
            efgy::json::value<Q> v;
            std::string nstream = parse(stream.substr(i), v);
            if (v.type == endArray) {
              return nstream;
            }
            stream = nstream;
            pValue.toArray().push_back(v);
          }
          i = -1;
          break;
        case read_array_comma: {
          efgy::json::value<Q> v;
          std::string nstream = parse(stream.substr(i), v);
          switch (v.type) {
            case comma:
              state = read_array;
              break;
            case endArray:
              return nstream;
            default:
              break;
          }
          stream = nstream;
        }
          i = -1;
          break;
        case read_number:
          switch (c) {
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
            case 'e':
            case 'E':
            case '.':
            case '+':
            case '-':
              ss.push_back(c);
              break;
            default:
              pValue.toNumber() = std::stold(ss);
              return stream.substr(i);
          }
          break;
        case read_string_escape:
          switch (c) {
            case 'b':
              pValue.toString().push_back('\b');
              break;
            case 'f':
              pValue.toString().push_back('\f');
              break;
            case 'n':
              pValue.toString().push_back('\n');
              break;
            case 'r':
              pValue.toString().push_back('\r');
              break;
            case 't':
              pValue.toString().push_back('\t');
              break;
            default:
              pValue.toString().push_back(c);
              break;
          }
          state = read_string;
          break;
        case read_string:
          switch (c) {
            case '"':
              return stream.substr(i + 1);
              break;
            case '\\':
              state = read_string_escape;
              break;
            default:
              pValue.toString().push_back(c);
              break;
          }
        default:
          break;
      }
  }

  if (state == read_number) {
    pValue.toNumber() = std::stold(ss);
  }

  return "";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %rsi
movl $0x6, (%rsi)
andq $0x0, 0x8(%rsi)
movq %rdx, (%rsp)
movq %rdx, %rdi
callq 0x109c8
leaq 0x38(%rsp), %rdi
callq 0x1095e
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %r12d, %r12d
leaq 0x78(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb %r12b, (%rax)
movb %r12b, (%rcx)
xorl %ebp, %ebp
cmpq 0x8(%r14), %rbp
jae 0x5703
movq (%r14), %rax
movb (%rax,%rbp), %r13b
cmpl $0xa, %r12d
jl 0x513f
jne 0x519b
cmpb $0x72, %r13b
jne 0x519b
pushq $0xb
jmp 0x56f7
jae 0x56fb
movzbl %r13b, %eax
movsbl %al, %r15d
movl %r12d, %ecx
leaq 0xfead(%rip), %rdx      # 0x15004
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
xorl %r12d, %r12d
leal -0x22(%rax), %ecx
cmpl $0x18, %ecx
ja 0x5614
leaq 0xfede(%rip), %rdx      # 0x15054
movslq (%rdx,%rcx,4), %rax
addq %rdx, %rax
jmpq *%rax
movq (%rsp), %rdi
callq 0x10b94
andq $0x0, 0x40(%rsp)
movq 0x38(%rsp), %rax
movb $0x0, (%rax)
jmp 0x5274
cmpl $0xb, %r12d
jne 0x51ae
cmpb $0x75, %r13b
jne 0x51ae
pushq $0xc
jmp 0x56f7
cmpl $0xc, %r12d
jne 0x51be
cmpb $0x65, %r13b
je 0x5765
cmpl $0xd, %r12d
jne 0x51d1
cmpb $0x61, %r13b
jne 0x51d1
pushq $0xe
jmp 0x56f7
cmpl $0xe, %r12d
jne 0x5539
cmpb $0x6c, %r13b
jne 0x5539
pushq $0xf
jmp 0x56f7
movl $0x6, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
leaq 0xc8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
pushq $-0x1
popq %rcx
callq 0x42e0
movq %rbx, %rdi
movq %r15, %rsi
leaq 0x8(%rsp), %r13
movq %r13, %rdx
callq 0x50b5
movq %r15, %rdi
callq 0x4130
movl 0x8(%rsp), %eax
cmpl $0x7, %eax
je 0x555b
pushq $0x4
popq %rcx
movl %ecx, %r12d
cmpl $0xb, %eax
jne 0x5561
xorl %r15d, %r15d
pushq $0x4
jmp 0x54fe
addl $-0x2b, %eax
cmpl $0x3a, %eax
ja 0x57ce
movabsq $0x400000004007fed, %rcx # imm = 0x400000004007FED
btq %rax, %rcx
jae 0x57ce
leaq 0x38(%rsp), %rdi
movl %r15d, %esi
callq 0x4250
pushq $0x9
popq %rax
movl %eax, %r12d
jmp 0x56fb
movl $0x6, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x108(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
pushq $-0x1
popq %rcx
callq 0x42e0
movq %rbx, %rdi
movq %r15, %rsi
leaq 0x8(%rsp), %r13
movq %r13, %rdx
callq 0x50b5
movq %r15, %rdi
callq 0x4130
movl 0x8(%rsp), %eax
cmpl $0x8, %eax
je 0x556e
pushq $0x2
popq %rcx
movl %ecx, %r12d
cmpl $0xb, %eax
jne 0x5574
xorl %r15d, %r15d
pushq $0x2
jmp 0x54fe
movl $0x6, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
leaq 0xe8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
pushq $-0x1
popq %rcx
callq 0x42e0
movq %rbx, %rdi
movq %r12, %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x50b5
movq %r12, %rdi
callq 0x4130
cmpl $0xb, 0x8(%rsp)
je 0x5785
movq (%rsp), %rdi
callq 0x10ade
movq %rax, %rdi
leaq 0x68(%rsp), %rsi
callq 0x10bfc
movq %rax, %rdi
movq %r15, %rsi
callq 0x109c8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4180
movq %rbx, %rdi
callq 0x4130
movq %r15, %rdi
callq 0x1095e
pushq $0x4
jmp 0x548f
cmpl $0x5c, %eax
je 0x5554
cmpl $0x22, %eax
je 0x576f
movq (%rsp), %rdi
callq 0x10b58
jmp 0x568e
movl $0x6, 0x58(%rsp)
andq $0x0, 0x60(%rsp)
leaq 0x128(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
pushq $-0x1
popq %rcx
callq 0x42e0
movq %rbx, %rdi
movq %r15, %rsi
leaq 0x58(%rsp), %r13
movq %r13, %rdx
callq 0x50b5
movq %r15, %rdi
leaq 0x8(%rsp), %r15
callq 0x4130
movl 0x58(%rsp), %eax
cmpl $0x2, %eax
je 0x5581
pushq $0x1
popq %rcx
movl %ecx, %r12d
cmpl $0xb, %eax
jne 0x55a7
xorl %r15d, %r15d
pushq $0x1
jmp 0x54fe
movl $0x6, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
leaq 0xa8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
pushq $-0x1
popq %rcx
callq 0x42e0
movq %rbx, %rdi
movq %r12, %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x50b5
movq %r12, %rdi
callq 0x4130
cmpl $0xa, 0x8(%rsp)
je 0x5785
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4180
movq (%rsp), %rdi
callq 0x10b22
movq %rax, %rdi
movq %r15, %rsi
callq 0x10c62
movq %rbx, %rdi
callq 0x4130
movq %r15, %rdi
callq 0x1095e
pushq $0x6
popq %rax
movl %eax, %r12d
pushq $-0x1
popq %rbp
jmp 0x56fb
movl $0x6, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x88(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
pushq $-0x1
popq %rcx
callq 0x42e0
movq %rbx, %rdi
movq %r15, %rsi
leaq 0x8(%rsp), %r13
movq %r13, %rdx
callq 0x50b5
movq %r15, %rdi
callq 0x4130
movl 0x8(%rsp), %eax
cmpl $0x7, %eax
je 0x55b4
pushq $0x6
popq %rcx
movl %ecx, %r12d
cmpl $0xa, %eax
jne 0x55ba
xorl %r15d, %r15d
pushq $0x6
popq %rax
movl %eax, %r12d
jmp 0x55d0
addl $-0x62, %r15d
rorl %r15d
cmpl $0x9, %r15d
ja 0x5396
leaq 0xfb0d(%rip), %rcx      # 0x1502c
movslq (%rcx,%r15,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsp), %rdi
callq 0x10b58
movb $0x8, %r13b
jmp 0x568e
cmpl $0xf, %r12d
jne 0x55e9
cmpb $0x73, %r13b
jne 0x55e9
pushq $0x10
jmp 0x56f7
pushq $0x8
jmp 0x56f7
pushq $0x1
popq %rax
movl %eax, %r12d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4180
jmp 0x55c5
pushq $0x3
popq %rax
movl %eax, %r12d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4180
jmp 0x55c5
movq %r15, %rdi
movq %r13, %rsi
callq 0x10bc4
leaq 0x68(%rsp), %rdi
movq %r15, %rsi
callq 0x4180
movq %r15, %rdi
callq 0x4130
pushq $0x2
popq %rax
movl %eax, %r12d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4180
jmp 0x55c5
pushq $0x5
popq %rax
movl %eax, %r12d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4180
movq %rbx, %rdi
callq 0x4130
movb $0x1, %r15b
movq %r13, %rdi
callq 0x1095e
pushq $-0x1
popq %rbp
testb %r15b, %r15b
jne 0x56fb
jmp 0x573c
cmpl $0x10, %r12d
jne 0x55f9
cmpb $0x65, %r13b
je 0x5791
cmpl $0x11, %r12d
jne 0x56a2
cmpb $0x75, %r13b
jne 0x56a2
pushq $0x12
jmp 0x56f7
cmpl $0x5b, %eax
je 0x56d3
cmpl $0x66, %eax
je 0x56cb
cmpl $0x6e, %eax
je 0x56f5
cmpl $0x74, %eax
je 0x56cf
cmpl $0x7b, %eax
je 0x56e4
cmpl $0x5d, %eax
je 0x580d
cmpl $0x7d, %eax
jne 0x56fb
jmp 0x581c
movq (%rsp), %rdi
callq 0x10b58
movb $0xa, %r13b
jmp 0x568e
movq (%rsp), %rdi
callq 0x10b58
movb $0xc, %r13b
jmp 0x568e
movq (%rsp), %rdi
callq 0x10b58
movb $0xd, %r13b
jmp 0x568e
movq (%rsp), %rdi
callq 0x10b58
movb $0x9, %r13b
movsbl %r13b, %esi
movq %rax, %rdi
callq 0x4250
pushq $0x7
popq %rax
movl %eax, %r12d
jmp 0x56fb
cmpl $0x12, %r12d
jne 0x579d
cmpb $0x6c, %r13b
jne 0x579d
pushq $0x13
jmp 0x56f7
movq (%rsp), %rdi
callq 0x10b58
pushq $0x7
popq %rax
movl %eax, %r12d
jmp 0x56fb
pushq $0xd
jmp 0x56f7
pushq $0xa
jmp 0x56f7
movq (%rsp), %rdi
callq 0x10b22
pushq $0x5
popq %rax
movl %eax, %r12d
jmp 0x56fb
movq (%rsp), %rdi
callq 0x10ade
pushq $0x1
popq %rax
movl %eax, %r12d
jmp 0x56fb
pushq $0x11
popq %rax
movl %eax, %r12d
incq %rbp
jmp 0x5119
cmpl $0x9, %r12d
jne 0x5728
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x10c8e
fstpt 0x2c(%rsp)
movq (%rsp), %rdi
callq 0x10b94
fldt 0x2c(%rsp)
fstpt (%rax)
leaq 0xfd0b(%rip), %rsi      # 0x1543a
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6342
leaq 0x68(%rsp), %rdi
callq 0x4130
leaq 0x38(%rsp), %rdi
callq 0x4130
movq %rbx, %rax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rax
movl $0x4, (%rax)
incq %rbp
pushq $-0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x42e0
jmp 0x573c
leaq 0x8(%rsp), %rdi
callq 0x1095e
jmp 0x573c
movq (%rsp), %rax
movl $0x5, (%rax)
jmp 0x576f
cmpl $0x13, %r12d
jne 0x57b5
cmpb $0x6c, %r13b
jne 0x57b5
movq (%rsp), %rax
movl $0x6, (%rax)
jmp 0x576f
leaq 0xfc7e(%rip), %rsi      # 0x1543a
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6342
jmp 0x573c
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x10c8e
fstpt 0x2c(%rsp)
movq (%rsp), %rdi
callq 0x10b94
fldt 0x2c(%rsp)
fstpt (%rax)
jmp 0x5772
movq (%rsp), %rax
movl $0x7, (%rax)
jmp 0x576f
movq (%rsp), %rax
movl $0x8, (%rax)
jmp 0x576f
movq (%rsp), %rax
movl $0xa, (%rax)
jmp 0x576f
movq (%rsp), %rax
movl $0xb, (%rax)
jmp 0x576f
jmp 0x58f9
jmp 0x58f9
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4130
jmp 0x584e
jmp 0x584b
jmp 0x58e2
movq %rax, %r14
movq %rbx, %rdi
jmp 0x5872
jmp 0x58e2
jmp 0x58e2
jmp 0x58f9
jmp 0x58f9
movq %rax, %r14
leaq 0x128(%rsp), %rdi
callq 0x4130
jmp 0x587c
movq %rax, %r14
leaq 0x58(%rsp), %rdi
jmp 0x58f2
movq %rax, %r14
leaq 0x108(%rsp), %rdi
jmp 0x58e8
jmp 0x58cc
movq %rax, %r14
leaq 0xe8(%rsp), %rdi
jmp 0x58e8
jmp 0x58cc
movq %rax, %r14
leaq 0xc8(%rsp), %rdi
jmp 0x58e8
jmp 0x58cc
movq %rax, %r14
leaq 0xa8(%rsp), %rdi
jmp 0x58e8
jmp 0x58cc
movq %rax, %r14
leaq 0x88(%rsp), %rdi
jmp 0x58e8
movq %rax, %r14
jmp 0x58ed
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x1095e
jmp 0x5910
jmp 0x58e2
movq %rax, %r14
movq %rbx, %rdi
callq 0x4130
leaq 0x8(%rsp), %rdi
callq 0x1095e
jmp 0x58fc
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x4130
leaq 0x38(%rsp), %rdi
callq 0x4130
movq %r14, %rdi
callq 0x4470