// File: /workspace/github_cpp_makefile_star2_O1/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, (%rsp)
movzbl (%rsi), %eax
cmpq $0x20, %rax
ja 0x3733
movabsq $0x100002600, %rcx      # imm = 0x100002600
btq %rax, %rcx
jb 0x3b5a
movsbl %al, %edi
callq 0x6c0f
testb %al, %al
je 0x3776
movq (%rsp), %r15
movsbl 0x1(%r15), %edi
incq %r15
callq 0x6c34
testb %al, %al
jne 0x3743
movq %r15, (%rsp)
movb (%r15), %bpl
testb %bpl, %bpl
je 0x37b9
movb $0x0, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3e94
movb %bpl, (%r15)
jmp 0x37c9
movzbl (%rbx), %eax
cmpl $0x27, %eax
je 0x3783
cmpl $0x22, %eax
jne 0x37fc
movsbl %al, %esi
leaq 0x1(%rbx), %r15
movq %r15, %rdi
callq 0x2060
movq %rax, %r12
movb $0x0, (%rax)
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x3e94
incq %r12
movq %r12, (%rsp)
movl $0x3, 0xc(%r14)
jmp 0x37e6
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x3e94
leaq 0x9c70(%rip), %rdi      # 0xd440
movq %r14, %rsi
callq 0x4370
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
addl %ecx, %ecx
movl %ecx, 0xc(%r14)
movl (%rsp), %eax
subl %ebx, %eax
movl %eax, 0x8(%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jae 0x388d
cmpb $0x30, %al
jne 0x38fd
movzbl 0x1(%rbx), %eax
orl $0x20, %eax
cmpl $0x78, %eax
jne 0x38fd
leaq 0x2(%rbx), %rax
movq %rax, (%rsp)
movq $0x0, (%r14)
xorpd %xmm0, %xmm0
movsd 0x47e5(%rip), %xmm1     # 0x8020
movb (%rax), %cl
leal -0x30(%rcx), %esi
movl $0xffffffd0, %edx       # imm = 0xFFFFFFD0
cmpb $0xa, %sil
jb 0x386a
leal -0x61(%rcx), %esi
movl $0xffffffa9, %edx       # imm = 0xFFFFFFA9
cmpb $0x6, %sil
jb 0x386a
addb $-0x41, %cl
movl $0xffffffc4, %edx       # imm = 0xFFFFFFC4
cmpb $0x5, %cl
ja 0x390f
mulsd %xmm1, %xmm0
movsd %xmm0, (%r14)
movsbl (%rax), %ecx
addl %edx, %ecx
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
addsd %xmm2, %xmm0
movsd %xmm0, (%r14)
incq %rax
jmp 0x383b
cmpb $0x2e, %al
jne 0x38a0
movb 0x1(%rbx), %cl
addb $-0x30, %cl
cmpb $0x9, %cl
jbe 0x3808
leaq 0x98d9(%rip), %rcx      # 0xd180
movq (%rcx), %rcx
movb (%rcx), %dl
cmpb %al, %dl
je 0x38b7
incq %rcx
testb %dl, %dl
jne 0x38aa
testb %dl, %dl
je 0x3994
movzbl %al, %eax
cmpl $0x5d, %eax
jg 0x39e1
addl $-0x21, %eax
cmpl $0x1e, %eax
ja 0x3b1b
leaq 0x474a(%rip), %rcx      # 0x8028
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x3d, 0x1(%rbx)
jne 0x3ae7
leaq 0x9a30(%rip), %rax      # 0xd328
jmp 0x3b15
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2120
movsd %xmm0, (%r14)
jmp 0x3913
movq %rax, (%rsp)
movq (%rsp), %r15
leaq 0xf(%rsp), %rdx
movb $0x2e, (%rdx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4401
movl $0x5, %ecx
cmpq %r15, %rax
jne 0x3968
movsd (%r14), %xmm0
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
cvttsd2si %xmm0, %rax
movl %eax, %eax
xorps %xmm2, %xmm2
cvtsi2sd %rax, %xmm2
cmpeqpd %xmm0, %xmm1
cmpeqpd %xmm0, %xmm2
orpd %xmm1, %xmm2
movd %xmm2, %ecx
andl $0x1, %ecx
xorl $0x5, %ecx
movl %ecx, 0xc(%r14)
cmpq %rbx, %r15
ja 0x37e6
leaq 0x48ff(%rip), %rdi      # 0x827b
leaq 0x4874(%rip), %rsi      # 0x81f7
leaq 0x4881(%rip), %rcx      # 0x820b
movl $0xef, %edx
callq 0x2100
leaq 0x97ed(%rip), %rcx      # 0xd188
movq (%rcx), %rcx
movb (%rcx), %dl
cmpb %al, %dl
je 0x39ab
incq %rcx
testb %dl, %dl
jne 0x399e
testb %dl, %dl
je 0x3bb7
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 0x3e94
movb %bpl, 0x1(%rbx)
movq %r15, (%rsp)
jmp 0x37e6
cmpl $0x5e, %eax
je 0x3ac8
cmpl $0x7c, %eax
je 0x3abf
cmpl $0x7e, %eax
jne 0x3b1b
leaq 0x98f5(%rip), %rax      # 0xd2f8
jmp 0x3b15
cmpb $0x3d, 0x1(%rbx)
jne 0x3ad1
leaq 0x9907(%rip), %rax      # 0xd320
jmp 0x3b15
leaq 0x99eb(%rip), %rax      # 0xd410
jmp 0x3b15
movb 0x1(%rbx), %al
cmpb $0x3e, %al
jne 0x3ada
cmpb $0x3e, 0x2(%rbx)
jne 0x3b05
leaq 0x9912(%rip), %rax      # 0xd358
jmp 0x3b15
leaq 0x998e(%rip), %rax      # 0xd3e0
jmp 0x3b15
leaq 0x9872(%rip), %rax      # 0xd2d0
jmp 0x3b15
leaq 0x98d6(%rip), %rax      # 0xd340
jmp 0x3b15
leaq 0x9852(%rip), %rax      # 0xd2c8
jmp 0x3b15
leaq 0x98ae(%rip), %rax      # 0xd330
jmp 0x3b15
leaq 0x9852(%rip), %rax      # 0xd2e0
jmp 0x3b15
leaq 0x989e(%rip), %rax      # 0xd338
jmp 0x3b15
leaq 0x994d(%rip), %rax      # 0xd3f0
jmp 0x3b15
movb 0x1(%rbx), %cl
cmpb $0x3d, %cl
jne 0x3af0
leaq 0x985c(%rip), %rax      # 0xd310
jmp 0x3af7
leaq 0x992b(%rip), %rax      # 0xd3e8
jmp 0x3b15
leaq 0x9812(%rip), %rax      # 0xd2d8
jmp 0x3b15
leaq 0x9819(%rip), %rax      # 0xd2e8
jmp 0x3b15
leaq 0x9960(%rip), %rax      # 0xd438
jmp 0x3b15
cmpb $0x3d, %al
jne 0x3b0e
leaq 0x9823(%rip), %rax      # 0xd308
jmp 0x3b15
leaq 0x9802(%rip), %rax      # 0xd2f0
jmp 0x3b15
leaq 0x9809(%rip), %rax      # 0xd300
cmpb $0x3c, %cl
jne 0x3b15
leaq 0x984d(%rip), %rax      # 0xd350
jmp 0x3b15
leaq 0x983c(%rip), %rax      # 0xd348
jmp 0x3b15
leaq 0x9803(%rip), %rax      # 0xd318
movq (%rax), %rax
movq %rax, (%r14)
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3b79
callq 0x2090
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 0x3b98
movslq 0x8(%r14), %rax
movb %bpl, (%rbx,%rax)
movl $0x1, 0xc(%r14)
jmp 0x37ef
leaq 0x4687(%rip), %rdi      # 0x81e8
leaq 0x468f(%rip), %rsi      # 0x81f7
leaq 0x469c(%rip), %rcx      # 0x820b
movl $0xc1, %edx
callq 0x2100
leaq 0x4707(%rip), %rdi      # 0x8287
leaq 0x4670(%rip), %rsi      # 0x81f7
leaq 0x467d(%rip), %rcx      # 0x820b
movl $0x104, %edx            # imm = 0x104
callq 0x2100
leaq 0x46f6(%rip), %rdi      # 0x8295
leaq 0x4651(%rip), %rsi      # 0x81f7
leaq 0x465e(%rip), %rcx      # 0x820b
movl $0x109, %edx            # imm = 0x109
callq 0x2100
leaq 0x46f3(%rip), %rdi      # 0x82b1
movq %rbx, %rsi
callq 0x22c0
leaq 0x4edb(%rip), %rdi      # 0x8aa8
leaq 0x4623(%rip), %rsi      # 0x81f7
leaq 0x4630(%rip), %rcx      # 0x820b
movl $0x117, %edx            # imm = 0x117
callq 0x2100
nop