// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::Frag::Frag(char*)
explicit Frag(char* src) {
      assert(!isSpace(*src));
      char *start = src;
      if (isIdentInit(*src)) {
        // read an identifier or a keyword
        src++;
        while (isIdentPart(*src)) {
          src++;
        }
        if (*src == 0) {
          str.set(start);
        } else {
          char temp = *src;
          *src = 0;
          str.set(start, false);
          *src = temp;
        }
        type = keywords.has(str) ? KEYWORD : IDENT;
      } else if (*src == '"' || *src == '\'') {
        char *end = strchr(src+1, *src);
        *end = 0;
        str.set(src+1);
        src = end+1;
        type = STRING;
      } else if (isDigit(*src) || (src[0] == '.' && isDigit(src[1]))) {
        if (src[0] == '0' && (src[1] == 'x' || src[1] == 'X')) {
          // Explicitly parse hex numbers of form "0x...", because strtod
          // supports hex number strings only in C++11, and Visual Studio 2013 does
          // not yet support that functionality.
          src += 2;
          num = 0;
          while (1) {
            if (*src >= '0' && *src <= '9') { num *= 16; num += *src - '0'; }
            else if (*src >= 'a' && *src <= 'f') { num *= 16; num += *src - 'a' + 10; }
            else if (*src >= 'A' && *src <= 'F') { num *= 16; num += *src - 'F' + 10; }
            else break;
            src++;
          }
        } else {
          num = strtod(start, &src);
        }
        // asm.js must have a '.' for double values. however, we also tolerate
        // uglify's tendency to emit without a '.' (and fix it later with a +).
        // for valid asm.js input, the '.' should be enough, and for uglify
        // in the emscripten optimizer pipeline, we use simple_ast where INT/DOUBLE
        // is quite the same at this point anyhow
        type = (std::find(start, src, '.') == src && is32Bit(num)) ? INT : DOUBLE;
        assert(src > start);
      } else if (hasChar(OPERATOR_INITS, *src)) {
        switch (*src) {
          case '!': str = src[1] == '=' ? NE : L_NOT; break;
          case '%': str = MOD; break;
          case '&': str = AND; break;
          case '*': str = MUL; break;
          case '+': str = PLUS; break;
          case ',': str = COMMA; break;
          case '-': str = MINUS; break;
          case '.': str = PERIOD; break;
          case '/': str = DIV; break;
          case ':': str = COLON; break;
          case '<': str = src[1] == '<' ? LSHIFT : (src[1] == '=' ? LE : LT); break;
          case '=': str = src[1] == '=' ? EQ : SET; break;
          case '>': str = src[1] == '>' ? (src[2] == '>' ? TRSHIFT : RSHIFT) : (src[1] == '=' ? GE : GT); break;
          case '?': str = QUESTION; break;
          case '^': str = XOR; break;
          case '|': str = OR; break;
          case '~': str = B_NOT; break;
        }
        assert(!str.isNull());
        size = strlen(str.str);
#ifndef NDEBUG
        char temp = start[size];
        start[size] = 0;
        assert(strcmp(str.str, start) == 0);
        start[size] = temp;
#endif
        type = OPERATOR;
        return;
      } else if (hasChar(SEPARATORS, *src)) {
        type = SEPARATOR;
        char temp = src[1];
        src[1] = 0;
        str.set(src, false);
        src[1] = temp;
        src++;
      } else {
        dump("frag parsing", src);
        assert(0);
      }
      size = src - start;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
movzbl (%rsi), %eax
cmpq $0x20, %rax
ja 0x3600
movabsq $0x100002600, %rcx      # imm = 0x100002600
btq %rax, %rcx
jb 0x39dc
movsbl %al, %edi
callq 0x6b87
testb %al, %al
je 0x363e
movq %rbx, %r15
movsbl 0x1(%r15), %edi
incq %r15
callq 0x6bac
testb %al, %al
jne 0x360f
movb (%r15), %bpl
testb %bpl, %bpl
je 0x3678
movb $0x0, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3d58
movb %bpl, (%r15)
jmp 0x3686
movzbl (%rbx), %esi
cmpl $0x27, %esi
je 0x364b
cmpl $0x22, %esi
jne 0x36b4
leaq 0x1(%rbx), %r12
movq %r12, %rdi
callq 0x2070
movq %rax, %r15
movb $0x0, (%rax)
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x3d58
incq %r15
movl $0x3, 0xc(%r14)
jmp 0x36a0
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3d58
leaq 0xadab(%rip), %rdi      # 0xe438
movq %r14, %rsi
callq 0x3e72
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %eax
movl %eax, 0xc(%r14)
subl %ebx, %r15d
movl %r15d, 0x8(%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leal -0x30(%rsi), %eax
cmpb $0xa, %al
jae 0x3739
cmpl $0x30, %esi
jne 0x3747
movzbl 0x1(%rbx), %eax
orl $0x20, %eax
cmpl $0x78, %eax
jne 0x3747
leaq 0x2(%rbx), %r15
andq $0x0, (%r14)
xorpd %xmm0, %xmm0
pushq $-0x30
popq %rax
movsd 0x4939(%rip), %xmm1     # 0x8020
pushq $-0x57
popq %rcx
pushq $-0x3c
popq %rdx
movb (%r15), %sil
leal -0x30(%rsi), %r8d
movl %eax, %edi
cmpb $0xa, %r8b
jb 0x3718
leal -0x61(%rsi), %r8d
movl %ecx, %edi
cmpb $0x6, %r8b
jb 0x3718
addb $-0x41, %sil
movl %edx, %edi
cmpb $0x5, %sil
ja 0x37f4
mulsd %xmm1, %xmm0
movsd %xmm0, (%r14)
movsbl (%r15), %esi
addl %edi, %esi
cvtsi2sd %esi, %xmm2
addsd %xmm2, %xmm0
movsd %xmm0, (%r14)
incq %r15
jmp 0x36ed
cmpl $0x2e, %esi
jne 0x3764
movb 0x1(%rbx), %al
addb $-0x30, %al
cmpb $0xa, %al
jae 0x3764
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2140
movsd %xmm0, (%r14)
movq (%r15), %r15
jmp 0x37f9
leaq 0xaa0d(%rip), %rax      # 0xe178
movq (%rax), %rdi
movsbl %sil, %esi
callq 0x35b8
testb %al, %al
je 0x37b0
movzbl (%rbx), %eax
leal -0x21(%rax), %ecx
cmpl $0x1e, %ecx
ja 0x385e
leaq 0x4897(%rip), %rax      # 0x8028
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
cmpb $0x3d, 0x1(%rbx)
jne 0x3970
leaq 0xab75(%rip), %rax      # 0xe320
jmp 0x3992
leaq 0xa9c9(%rip), %rax      # 0xe180
movq (%rax), %rdi
movsbl (%rbx), %esi
callq 0x35b8
testb %al, %al
je 0x3a1a
movl $0x6, 0xc(%r14)
leaq 0x1(%rbx), %r15
movb 0x1(%rbx), %bpl
movb $0x0, 0x1(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3d58
movb %bpl, 0x1(%rbx)
jmp 0x36a0
movq %r15, 0x8(%rsp)
leaq 0x7(%rsp), %rdx
movb $0x2e, (%rdx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x43ed
cmpq %r15, %rax
je 0x3816
pushq $0x5
popq %rax
jmp 0x3847
movsd (%r14), %xmm0
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
cvttsd2si %xmm0, %rax
movl %eax, %eax
cvtsi2sd %rax, %xmm2
cmpeqpd %xmm0, %xmm1
cmpeqpd %xmm0, %xmm2
orpd %xmm1, %xmm2
movd %xmm2, %eax
andl $0x1, %eax
xorl $0x5, %eax
movl %eax, 0xc(%r14)
cmpq %rbx, %r15
jbe 0x39fb
movq 0x8(%rsp), %r15
jmp 0x36a0
cmpl $0x5e, %eax
je 0x3945
cmpl $0x7c, %eax
je 0x393c
cmpl $0x7e, %eax
jne 0x3881
leaq 0xaa74(%rip), %rax      # 0xe2f0
jmp 0x3992
movq (%r14), %rdi
jmp 0x3998
movb 0x1(%rbx), %cl
cmpb $0x3d, %cl
jne 0x394e
leaq 0xaa6c(%rip), %rax      # 0xe308
jmp 0x3955
leaq 0xaa18(%rip), %rax      # 0xe2c0
jmp 0x3992
leaq 0xaa24(%rip), %rax      # 0xe2d8
jmp 0x3992
leaq 0xaa68(%rip), %rax      # 0xe328
jmp 0x3992
leaq 0xaa6c(%rip), %rax      # 0xe338
jmp 0x3992
leaq 0xaa58(%rip), %rax      # 0xe330
jmp 0x3992
movb 0x1(%rbx), %al
cmpb $0x3e, %al
jne 0x3963
cmpb $0x3e, 0x2(%rbx)
jne 0x3982
leaq 0xaa5b(%rip), %rax      # 0xe350
jmp 0x3992
leaq 0xa9c7(%rip), %rax      # 0xe2c8
jmp 0x3992
leaq 0xaafb(%rip), %rax      # 0xe408
jmp 0x3992
leaq 0xaabf(%rip), %rax      # 0xe3d8
jmp 0x3992
cmpb $0x3d, 0x1(%rbx)
jne 0x3979
leaq 0xa9f0(%rip), %rax      # 0xe318
jmp 0x3992
leaq 0xaab7(%rip), %rax      # 0xe3e8
jmp 0x3992
leaq 0xaaa6(%rip), %rax      # 0xe3e0
jmp 0x3992
leaq 0xa98d(%rip), %rax      # 0xe2d0
jmp 0x3992
leaq 0xa994(%rip), %rax      # 0xe2e0
jmp 0x3992
leaq 0xa9a3(%rip), %rax      # 0xe2f8
cmpb $0x3c, %cl
jne 0x3992
leaq 0xa9e7(%rip), %rax      # 0xe348
jmp 0x3992
cmpb $0x3d, %al
jne 0x398b
leaq 0xa992(%rip), %rax      # 0xe300
jmp 0x3992
leaq 0xa971(%rip), %rax      # 0xe2e8
jmp 0x3992
leaq 0xaab0(%rip), %rax      # 0xe430
jmp 0x3992
leaq 0xa9b7(%rip), %rax      # 0xe340
jmp 0x3992
leaq 0xa97e(%rip), %rax      # 0xe310
movq (%rax), %rdi
movq %rdi, (%r14)
testq %rdi, %rdi
je 0x3a48
callq 0x20a0
movl %eax, 0x8(%r14)
cltq
movb (%rbx,%rax), %bpl
movb $0x0, (%rbx,%rax)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x21f0
testl %eax, %eax
jne 0x3a67
movslq 0x8(%r14), %rax
movb %bpl, (%rbx,%rax)
movl $0x1, 0xc(%r14)
jmp 0x36a7
leaq 0x4805(%rip), %rdi      # 0x81e8
leaq 0x480d(%rip), %rsi      # 0x81f7
leaq 0x481a(%rip), %rcx      # 0x820b
movl $0xc1, %edx
callq 0x2120
leaq 0x4879(%rip), %rdi      # 0x827b
leaq 0x47ee(%rip), %rsi      # 0x81f7
leaq 0x47fb(%rip), %rcx      # 0x820b
movl $0xef, %edx
callq 0x2120
leaq 0x4890(%rip), %rdi      # 0x82b1
movq %rbx, %rsi
callq 0x3e80
leaq 0x5078(%rip), %rdi      # 0x8aa8
leaq 0x47c0(%rip), %rsi      # 0x81f7
leaq 0x47cd(%rip), %rcx      # 0x820b
movl $0x117, %edx            # imm = 0x117
callq 0x2120
leaq 0x4838(%rip), %rdi      # 0x8287
leaq 0x47a1(%rip), %rsi      # 0x81f7
leaq 0x47ae(%rip), %rcx      # 0x820b
movl $0x104, %edx            # imm = 0x104
callq 0x2120
leaq 0x4827(%rip), %rdi      # 0x8295
leaq 0x4782(%rip), %rsi      # 0x81f7
leaq 0x478f(%rip), %rcx      # 0x820b
movl $0x109, %edx            # imm = 0x109
callq 0x2120