LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/parser.cpp
// Function: parser::parse_asmjs(memory::Pool&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Func&
parser::parse_asmjs(memory::Pool& pool, const string& chars)
{
  // cashew needs to be able to mutate the chars
  vector<char> mutable_chars(chars.begin(), chars.end());

  cashew::Parser<Node*, Builder> parser(pool);
  Node* top_level = parser.parseToplevel(mutable_chars.data());

  List<Node>& top = top_level->as<Block>().stmts;
  if (top.compute_length() != 1 || !top.first().is<Func>())
    throw runtime_error("expecting single top-level asm.js module function");

  Func& func = top.first().as<Func>();
  List<Node>& body = func.body.stmts;
  if (body.empty() || !body.first().is<String>() || !body.first().as<String>().str.equals("use asm"))
    throw runtime_error("expecting single top-level asm.js module function");

  return func;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %rdi
leaq 0x18(%rsp), %rcx
movq %rax, %rsi
callq 0x2eee
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x2f20
movq (%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x2f5c
movq %rax, %rdi
callq 0x2fa4
movq %rax, %rbx
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x2fcc
cmpl $0x1, %eax
jne 0x2e88
movq (%rbx), %rdi
cmpl $0x17, 0x8(%rdi)
jne 0x2e88
callq 0x2fda
movq %rax, %rbx
movq 0x28(%rax), %rax
movq 0x10(%rax), %rdi
cmpq 0x18(%rax), %rdi
je 0x2e56
cmpl $0x2, 0x8(%rdi)
jne 0x2e56
callq 0x3002
leaq 0x10(%rax), %rdi
leaq 0x52d2(%rip), %rsi      # 0x8102
callq 0x302a
testb %al, %al
je 0x2e56
leaq 0x18(%rsp), %rdi
callq 0x303a
movq %rsp, %rdi
callq 0x314a
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20d0
movq %rax, %r14
leaq 0x5268(%rip), %rsi      # 0x80d0
movq %rax, %rdi
callq 0x2080
movq 0xb179(%rip), %rsi      # 0xdff0
movq 0xb132(%rip), %rdx      # 0xdfb0
movq %r14, %rdi
callq 0x2250
jmp 0x2eb8
pushq $0x10
popq %rdi
callq 0x20d0
movq %rax, %r14
leaq 0x5236(%rip), %rsi      # 0x80d0
movq %rax, %rdi
callq 0x2080
movq 0xb147(%rip), %rsi      # 0xdff0
movq 0xb100(%rip), %rdx      # 0xdfb0
movq %r14, %rdi
callq 0x2250
jmp 0x2ec3
jmp 0x2ed0
movq %rax, %rbx
jmp 0x2edd
jmp 0x2ed0
movq %rax, %rbx
movq %r14, %rdi
callq 0x2130
jmp 0x2ed3
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x303a
movq %rsp, %rdi
callq 0x314a
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseBlock(char*&, asmjs_ast::Node*, char const*, cashew::IString, cashew::IString)
NodeRef parseBlock(char*& src, NodeRef block=nullptr, const char* seps=";", IString keywordSep1=IString(), IString keywordSep2=IString()) {
    //dump("parseBlock", src);
    if (!block) block = builder.makeBlock();
    while (*src) {
      src = skipSpace(src);
      if (*src == 0) break;
      if (*src == ';') {
        src++; // skip a statement in this block
        continue;
      }
      if (hasChar(seps, *src)) break;
      if (!!keywordSep1) {
        Frag next(src);
        if (next.type == KEYWORD && next.str == keywordSep1) break;
      }
      if (!!keywordSep2) {
        Frag next(src);
        if (next.type == KEYWORD && next.str == keywordSep2) break;
      }
      NodeRef element = parseElementOrStatement(src, seps);
      builder.appendToBlock(block, element);
    }
    return block;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %r13
testq %rdx, %rdx
jne 0x345b
leaq 0x28(%r13), %rdi
callq 0x3526
movq %rax, %rbp
leaq 0x28(%r13), %rax
movq %rax, 0x10(%rsp)
movq (%r12), %rdi
cmpb $0x0, (%rdi)
je 0x3513
callq 0x3546
movq %rax, (%r12)
movzbl (%rax), %ecx
cmpl $0x3b, %ecx
je 0x3507
testl %ecx, %ecx
je 0x3513
movsbl %cl, %esi
movq %r15, %rdi
callq 0x35b8
testb %al, %al
jne 0x3513
testq %r14, %r14
je 0x34c1
cmpb $0x0, (%r14)
je 0x34c1
movq (%r12), %rsi
movq %rsp, %rdi
callq 0x35cc
cmpl $0x0, 0xc(%rsp)
jne 0x34c1
cmpq %r14, (%rsp)
je 0x3513
testq %rbx, %rbx
je 0x34e4
cmpb $0x0, (%rbx)
je 0x34e4
movq (%r12), %rsi
movq %rsp, %rdi
callq 0x35cc
cmpl $0x0, 0xc(%rsp)
jne 0x34e4
cmpq %rbx, (%rsp)
je 0x3513
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3a86
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x3aec
jmp 0x3464
incq %rax
movq %rax, (%r12)
jmp 0x3464
movq %rbp, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::skipSpace(char*)
static char* skipSpace(char* curr) {
    while (*curr) {
      if (isSpace(*curr)) {
        curr++;
        continue;
      }
      if (curr[0] == '/' && curr[1] == '/') {
        curr += 2;
        while (*curr && *curr != '\n') curr++;
        if (*curr) curr++;
        continue;
      }
      if (curr[0] == '/' && curr[1] == '*') {
        curr += 2;
        while (*curr && (curr[0] != '*' || curr[1] != '/')) curr++;
        curr += 2;
        continue;
      }
      break;
    }
    return curr;
  }

// Assembly:
movq %rdi, %rax
movabsq $0x100002600, %rcx      # imm = 0x100002600
movzbl (%rax), %edx
cmpq $0x2f, %rdx
ja 0x35b7
btq %rdx, %rcx
jae 0x3567
incq %rax
jmp 0x3553
cmpq $0x2f, %rdx
jne 0x35b7
movzbl 0x1(%rax), %edx
cmpl $0x2a, %edx
je 0x3590
cmpl $0x2f, %edx
jne 0x35b7
addq $0x2, %rax
movzbl (%rax), %edx
testl %edx, %edx
je 0x35ae
cmpl $0xa, %edx
je 0x35ae
incq %rax
jmp 0x357f
addq $0x4, %rax
movzbl -0x2(%rax), %edx
cmpl $0x2a, %edx
je 0x35a3
testl %edx, %edx
jne 0x35a9
jmp 0x3553
cmpb $0x2f, -0x1(%rax)
je 0x3553
incq %rax
jmp 0x3594
cmpb $0x1, %dl
sbbq $-0x1, %rax
jmp 0x3553
retq
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseElementOrStatement(char*&, char const*)
NodeRef parseElementOrStatement(char*& src, const char *seps) {
    src = skipSpace(src);
    if (*src == ';') {
      src++;
      return builder.makeBlock(); // we don't need the brackets here, but oh well
    }
    NodeRef ret = parseElement(src, seps);
    src = skipSpace(src);
    if (*src == ';') {
      ret = builder.makeStatement(ret);
      src++;
    }
    return ret;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x3546
movq %rax, (%rbx)
cmpb $0x3b, (%rax)
jne 0x3abb
incq %rax
movq %rax, (%rbx)
addq $0x28, %r14
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3526
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4474
movq %rax, %r14
movq (%rbx), %rdi
callq 0x3546
movq %rax, (%rbx)
cmpb $0x3b, (%rax)
jne 0x3ae2
incq %rax
movq %rax, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/memory.h
// Function: memory::Pool::alloc(unsigned long)
void* alloc(size_t bytes)
  {
    if (remain_ < bytes) {
      remain_ = std::max<size_t>(bytes, 64 * 1024);
      allocs_.emplace_back(new uint8_t[remain_]);
      free_ = allocs_.back().get();
    }

    uint8_t* ret = free_;
    free_ += bytes;
    remain_ -= bytes;
    return ret;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
cmpq %rsi, %rcx
jae 0x3b74
cmpq $0x10001, %r14          # imm = 0x10001
movl $0x10000, %edi          # imm = 0x10000
cmovaeq %r14, %rdi
movq %rdi, 0x20(%rbx)
callq 0x2030
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3b92
movq 0x8(%rbx), %rax
movq 0x20(%rbx), %rcx
addq $-0x8, %rax
jmp 0x3b78
leaq 0x18(%rbx), %rax
movq (%rax), %rax
leaq (%rax,%r14), %rdx
movq %rdx, 0x18(%rbx)
subq %r14, %rcx
movq %rcx, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/istring.h
// Function: cashew::IString::set(char const*, bool)
void set(const char *s, bool reuse=true) {
    typedef std::unordered_set<const char *, CStringHash, CStringEqual> StringSet;
    static StringSet* strings = new StringSet();

    if (reuse) {
      auto result = strings->insert(s); // if already present, does nothing
      str = *(result.first);
    } else {
      auto existing = strings->find(s);
      if (existing == strings->end()) {
        char *copy = (char*)malloc(strlen(s)+1); // XXX leaked
        strcpy(copy, s);
        s = copy;
      } else {
        s = *existing;
      }
      strings->insert(s);
      str = s;
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movb 0xa42c(%rip), %al       # 0xe1a0
testb %al, %al
je 0x3dfe
movq 0xa415(%rip), %rdi      # 0xe198
testb %bpl, %bpl
je 0x3d9b
leaq 0x8(%rsp), %rsi
callq 0x3efe
movq %rax, %r14
addq $0x8, %r14
jmp 0x3deb
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x431c
testq %rax, %rax
je 0x3db3
movq 0x8(%rax), %r15
jmp 0x3dd7
movq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x20a0
leaq 0x1(%rax), %rdi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x2170
movq %r15, 0x8(%rsp)
movq 0xa3b5(%rip), %rdi      # 0xe198
movq %r14, %rsi
callq 0x3efe
movq (%r14), %rax
movq %rax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa39b(%rip), %rdi      # 0xe1a0
callq 0x2270
testl %eax, %eax
je 0x3d7c
pushq $0x38
popq %rdi
callq 0x2190
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rax)
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, (%rax)
movq $0x1, 0x8(%rax)
movups %xmm0, 0x10(%rax)
movl $0x3f800000, 0x20(%rax) # imm = 0x3F800000
movups %xmm0, 0x28(%rax)
movq %rax, 0xa34f(%rip)      # 0xe198
leaq 0xa350(%rip), %rdi      # 0xe1a0
callq 0x2110
jmp 0x3d7c
movq %rax, %rbx
leaq 0xa33c(%rip), %rdi      # 0xe1a0
callq 0x2100
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::dump(char const*, char*)
static void dump(const char *where, char* curr) {
    /*
    printf("%s:\n=============\n", where);
    for (int i = 0; i < allSize; i++) printf("%c", allSource[i] ? allSource[i] : '?');
    printf("\n");
    for (int i = 0; i < (curr - allSource); i++) printf(" ");
    printf("^\n=============\n");
    */
    fprintf(stderr, "%s:\n==========\n", where);
    int newlinesLeft = 2;
    int charsLeft = 200;
    while (*curr) {
      if (*curr == '\n') {
        newlinesLeft--;
        if (newlinesLeft == 0) break;
      }
      charsLeft--;
      if (charsLeft == 0) break;
      fprintf(stderr, "%c", *curr++);
    }
    fprintf(stderr, "\n\n");
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rdx
movq 0xa12b(%rip), %r14      # 0xdfc0
movq (%r14), %rdi
leaq 0x441f(%rip), %rsi      # 0x82be
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x2200
pushq $0x2
popq %rbp
pushq $0x1
popq %r12
movzbl (%rbx,%r15), %eax
cmpl $0xa, %eax
je 0x3ec0
testl %eax, %eax
jne 0x3ec8
jmp 0x3ee1
cmpl $0x1, %ebp
movl %r12d, %ebp
je 0x3ee1
cmpl $0xc7, %r15d
je 0x3ee1
movsbl %al, %edi
movq (%r14), %rsi
callq 0x21b0
incq %r15
jmp 0x3eb0
movq (%r14), %rcx
leaq 0x43e3(%rip), %rdi      # 0x82ce
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/istring.h
// Function: cashew::IString::hash_c(char const*)
static size_t hash_c(const char *str) { // see http://www.cse.yorku.ca/~oz/hash.html
    unsigned int hash = 5381;
    int c;
    while ((c = *str++)) {
      hash = ((hash << 5) + hash) ^ c;
    }
    return (size_t)hash;
  }

// Assembly:
movl $0x1505, %eax           # imm = 0x1505
movsbl (%rdi), %ecx
testl %ecx, %ecx
je 0x407a
incq %rdi
imull $0x21, %eax, %eax
xorl %ecx, %eax
jmp 0x4069
movl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseElement(char*&, char const*)
NodeRef parseElement(char*& src, const char* seps=";") {
    //dump("parseElement", src);
    src = skipSpace(src);
    Frag frag(src);
    src += frag.size;
    switch (frag.type) {
      case KEYWORD: {
        return parseAfterKeyword(frag, src, seps);
      }
      case IDENT:
      case STRING:
      case INT:
      case DOUBLE: {
        src = skipSpace(src);
        if (frag.type == IDENT) return parseAfterIdent(frag, src, seps);
        else return parseExpression(parseFrag(frag), src, seps);
      }
      case SEPARATOR: {
        if (frag.str == OPEN_PAREN) return parseExpression(parseAfterParen(src), src, seps);
        if (frag.str == OPEN_BRACE) return parseExpression(parseAfterBrace(src), src, seps);
        if (frag.str == OPEN_CURLY) return parseExpression(parseAfterCurly(src), src, seps);
        assert(0);
      }
      case OPERATOR: {
        return parseExpression(frag.str, src, seps);
      }
      default: /* dump("parseElement", src); printf("bad frag type: %d\n", frag.type); */ assert(0);
    }
    return nullptr;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rdi
callq 0x3546
movq %rax, (%r14)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x35cc
movslq 0x8(%r12), %rdi
addq (%r14), %rdi
movq %rdi, (%r14)
movl 0xc(%r12), %eax
cmpq $0x6, %rax
ja 0x4595
leaq 0x3be0(%rip), %rcx      # 0x80a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x3546
movq %rax, (%r14)
cmpl $0x2, 0x14(%rsp)
jne 0x44f1
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x47e6
jmp 0x4533
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x4f40
pushq $0x1
popq %rsi
movq %r15, %rdi
movq %rax, %rdx
jmp 0x4528
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x45d4
jmp 0x4533
movq 0x8(%rsp), %rdx
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rcx
movq %rbx, %r8
callq 0x4920
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rsp), %rax
leaq 0x9e6d(%rip), %rcx      # 0xe3b8
cmpq (%rcx), %rax
je 0x4575
leaq 0x9e69(%rip), %rcx      # 0xe3c0
cmpq (%rcx), %rax
je 0x4585
leaq 0x9e65(%rip), %rcx      # 0xe3c8
cmpq (%rcx), %rax
jne 0x45b4
movq %r15, %rdi
movq %r14, %rsi
callq 0x5148
jmp 0x44fe
movq %r15, %rdi
movq %r14, %rsi
callq 0x4fae
jmp 0x44fe
movq %r15, %rdi
movq %r14, %rsi
callq 0x5064
jmp 0x44fe
leaq 0x450c(%rip), %rdi      # 0x8aa8
leaq 0x3c54(%rip), %rsi      # 0x81f7
leaq 0x3d27(%rip), %rcx      # 0x82d1
movl $0x138, %edx            # imm = 0x138
callq 0x2120
leaq 0x44ed(%rip), %rdi      # 0x8aa8
leaq 0x3c35(%rip), %rsi      # 0x81f7
leaq 0x3d08(%rip), %rcx      # 0x82d1
movl $0x133, %edx            # imm = 0x133
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseAfterIdent(cashew::Parser<asmjs_ast::Node*, Builder>::Frag&, char*&, char const*)
NodeRef parseAfterIdent(Frag& frag, char*& src, const char* seps) {
    assert(!isSpace(*src));
    if (*src == '(') return parseExpression(parseCall(parseFrag(frag), src), src, seps);
    if (*src == '[') return parseExpression(parseIndexing(parseFrag(frag), src), src, seps);
    if (*src == ':' && expressionPartsStack.back().size() == 0) {
      src++;
      src = skipSpace(src);
      NodeRef inner;
      if (*src == '{') { // context lets us know this is not an object, but a block
        inner = parseBracketedBlock(src);
      } else {
        inner = parseElement(src, seps);
      }
      return builder.makeLabel(frag.str, inner);
    }
    if (*src == '.') return parseExpression(parseDotting(parseFrag(frag), src), src, seps);
    return parseExpression(parseFrag(frag), src, seps);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdx), %rdi
movzbl (%rdi), %eax
cmpl $0x28, %eax
je 0x487f
cmpl $0x2e, %eax
je 0x489a
cmpl $0x3a, %eax
je 0x4849
cmpl $0x5b, %eax
je 0x4864
leal -0x9(%rax), %ecx
cmpl $0x2, %ecx
jb 0x482a
cmpl $0x20, %eax
je 0x482a
cmpl $0xd, %eax
jne 0x4857
leaq 0x39b7(%rip), %rdi      # 0x81e8
leaq 0x39bf(%rip), %rsi      # 0x81f7
leaq 0x412b(%rip), %rcx      # 0x896a
movl $0x20b, %edx            # imm = 0x20B
callq 0x2120
movq 0x8(%rbx), %rax
movq -0x10(%rax), %rcx
cmpq -0x18(%rax), %rcx
je 0x48d2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4f40
jmp 0x48b3
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4f40
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x62ce
jmp 0x48b3
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4f40
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x61a4
jmp 0x48b3
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4f40
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x63f4
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
movq %r15, %rcx
movq %r14, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4920
incq %rdi
movq %rdi, (%r15)
callq 0x3546
movq %rax, (%r15)
cmpb $0x7b, (%rax)
jne 0x48f4
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x5c72
jmp 0x4902
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4474
addq $0x28, %rbx
movq (%r12), %rsi
movq %rbx, %rdi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x63c4
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseFrag(cashew::Parser<asmjs_ast::Node*, Builder>::Frag&)
NodeRef parseFrag(Frag& frag) {
    switch (frag.type) {
      case IDENT:  return builder.makeName(frag.str);
      case STRING: return builder.makeString(frag.str);
      case INT:    return builder.makeInt(uint32_t(frag.num));
      case DOUBLE: return builder.makeDouble(frag.num);
      default: assert(0);
    }
    return nullptr;
  }

// Assembly:
movl 0xc(%rsi), %eax
addl $-0x2, %eax
cmpl $0x3, %eax
ja 0x4f8e
leaq 0x316e(%rip), %rcx      # 0x80c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x28, %rdi
movq (%rsi), %rsi
jmp 0x6996
cvttsd2si (%rsi), %rsi
addq $0x28, %rdi
jmp 0x69d6
addq $0x28, %rdi
movsd (%rsi), %xmm0
jmp 0x69f4
addq $0x28, %rdi
movq (%rsi), %rsi
jmp 0x69b6
pushq %rax
leaq 0x3b12(%rip), %rdi      # 0x8aa8
leaq 0x325a(%rip), %rsi      # 0x81f7
leaq 0x3e6b(%rip), %rcx      # 0x8e0f
movl $0x143, %edx            # imm = 0x143
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseAfterParen(char*&)
NodeRef parseAfterParen(char*& src) {
    expressionPartsStack.resize(expressionPartsStack.size()+1);
    src = skipSpace(src);
    NodeRef ret = parseElement(src, ")");
    src = skipSpace(src);
    assert(*src == ')');
    src++;
    assert(expressionPartsStack.back().size() == 0);
    expressionPartsStack.pop_back();
    return ret;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
leaq 0x1(%rax), %rsi
callq 0x31b4
movq (%r14), %rdi
callq 0x3546
movq %rax, (%r14)
leaq 0x312d(%rip), %rdx      # 0x8110
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4474
movq %rax, %r15
movq (%r14), %rdi
callq 0x3546
movq %rax, (%r14)
cmpb $0x29, (%rax)
jne 0x5026
incq %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq -0x10(%rax), %rcx
cmpq -0x18(%rax), %rcx
jne 0x5045
movq %rbx, %rdi
callq 0x64e8
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x34a0(%rip), %rdi      # 0x84cd
leaq 0x31c3(%rip), %rsi      # 0x81f7
leaq 0x3e4b(%rip), %rcx      # 0x8e86
movl $0x24f, %edx            # imm = 0x24F
callq 0x2120
leaq 0x3a36(%rip), %rdi      # 0x8a82
leaq 0x31a4(%rip), %rsi      # 0x81f7
leaq 0x3e2c(%rip), %rcx      # 0x8e86
movl $0x251, %edx            # imm = 0x251
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseAfterBrace(char*&)
NodeRef parseAfterBrace(char*& src) {
    expressionPartsStack.resize(expressionPartsStack.size()+1);
    NodeRef ret = builder.makeArray();
    while (1) {
      src = skipSpace(src);
      assert(*src);
      if (*src == ']') break;
      NodeRef element = parseElement(src, ",]");
      builder.appendToArray(ret, element);
      src = skipSpace(src);
      if (*src == ',') {
        src++;
        continue;
      } else assert(*src == ']');
    }
    assert(*src == ']');
    src++;
    return ret;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
subq (%rdi), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
leaq 0x1(%rax), %rsi
callq 0x31b4
leaq 0x28(%r14), %r15
movq %r15, %rdi
callq 0x6a1a
movq %rax, %r12
movq (%rbx), %rdi
leaq 0x3ee3(%rip), %r13      # 0x8f87
callq 0x3546
movq %rax, (%rbx)
movzbl (%rax), %ecx
cmpl $0x5d, %ecx
je 0x50f7
testl %ecx, %ecx
je 0x510a
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x4474
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x6a3a
movq (%rbx), %rdi
callq 0x3546
movq %rax, %rdi
movq %rax, (%rbx)
movzbl (%rax), %eax
cmpl $0x5d, %eax
je 0x50a4
cmpl $0x2c, %eax
jne 0x5129
incq %rdi
movq %rdi, (%rbx)
jmp 0x50a4
incq %rax
movq %rax, (%rbx)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3df3(%rip), %rdi      # 0x8f04
leaq 0x30df(%rip), %rsi      # 0x81f7
leaq 0x3dea(%rip), %rcx      # 0x8f09
movl $0x25b, %edx            # imm = 0x25B
callq 0x2120
leaq 0x3a0b(%rip), %rdi      # 0x8b3b
leaq 0x30c0(%rip), %rsi      # 0x81f7
leaq 0x3dcb(%rip), %rcx      # 0x8f09
movl $0x263, %edx            # imm = 0x263
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseAfterCurly(char*&)
NodeRef parseAfterCurly(char*& src) {
    expressionPartsStack.resize(expressionPartsStack.size()+1);
    NodeRef ret = builder.makeObject();
    while (1) {
      src = skipSpace(src);
      assert(*src);
      if (*src == '}') break;
      Frag key(src);
      assert(key.type == IDENT || key.type == STRING);
      src += key.size;
      src = skipSpace(src);
      assert(*src == ':');
      src++;
      NodeRef value = parseElement(src, ",}");
      builder.appendToObject(ret, key.str, value);
      src = skipSpace(src);
      if (*src == ',') {
        src++;
        continue;
      } else assert(*src == '}');
    }
    assert(*src == '}');
    src++;
    return ret;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
subq (%rdi), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
leaq 0x1(%rax), %rsi
callq 0x31b4
leaq 0x28(%r14), %r15
movq %r15, %rdi
callq 0x6a90
movq %rax, %r12
movq (%rbx), %rdi
leaq 0x8(%rsp), %r13
leaq 0x3ece(%rip), %rbp      # 0x9060
callq 0x3546
movq %rax, (%rbx)
movzbl (%rax), %ecx
cmpl $0x7d, %ecx
je 0x523a
testl %ecx, %ecx
je 0x5252
movq %r13, %rdi
movq %rax, %rsi
callq 0x35cc
movl 0x14(%rsp), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x5290
movslq 0x10(%rsp), %rdi
addq (%rbx), %rdi
movq %rdi, (%rbx)
callq 0x3546
movq %rax, (%rbx)
cmpb $0x3a, (%rax)
jne 0x5271
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x4474
movq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rcx
callq 0x6ab0
movq (%rbx), %rdi
callq 0x3546
movq %rax, %rdi
movq %rax, (%rbx)
movzbl (%rax), %eax
cmpl $0x7d, %eax
je 0x5192
cmpl $0x2c, %eax
jne 0x52af
incq %rdi
movq %rdi, (%rbx)
jmp 0x5192
incq %rax
movq %rax, (%rbx)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3cab(%rip), %rdi      # 0x8f04
leaq 0x2f97(%rip), %rsi      # 0x81f7
leaq 0x3d53(%rip), %rcx      # 0x8fba
movl $0x26f, %edx            # imm = 0x26F
callq 0x2120
leaq 0x3686(%rip), %rdi      # 0x88fe
leaq 0x2f78(%rip), %rsi      # 0x81f7
leaq 0x3d34(%rip), %rcx      # 0x8fba
movl $0x275, %edx            # imm = 0x275
callq 0x2120
leaq 0x3da1(%rip), %rdi      # 0x9038
leaq 0x2f59(%rip), %rsi      # 0x81f7
leaq 0x3d15(%rip), %rcx      # 0x8fba
movl $0x272, %edx            # imm = 0x272
callq 0x2120
leaq 0x32bd(%rip), %rdi      # 0x8573
leaq 0x2f3a(%rip), %rsi      # 0x81f7
leaq 0x3cf6(%rip), %rcx      # 0x8fba
movl $0x27d, %edx            # imm = 0x27D
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseFunction(cashew::Parser<asmjs_ast::Node*, Builder>::Frag&, char*&, char const*)
NodeRef parseFunction(Frag& frag, char*& src, const char* seps) {
    Frag name(src);
    if (name.type == IDENT) {
      src += name.size;
    } else {
      assert(name.type == SEPARATOR && name.str[0] == '(');
      name.str = IString();
    }
    NodeRef ret = builder.makeFunction(name.str);
    src = skipSpace(src);
    assert(*src == '(');
    src++;
    while (1) {
      src = skipSpace(src);
      if (*src == ')') break;
      Frag arg(src);
      assert(arg.type == IDENT);
      src += arg.size;
      builder.appendArgumentToFunction(ret, arg.str);
      src = skipSpace(src);
      if (*src && *src == ')') break;
      if (*src && *src == ',') {
        src++;
        continue;
      }
      assert(0);
    }
    assert(*src == ')');
    src++;
    parseBracketedBlock(src, ret);
    // TODO: parse expression?
    return ret;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdx), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x35cc
movl 0xc(%r15), %eax
cmpl $0x6, %eax
je 0x530f
cmpl $0x2, %eax
jne 0x5417
movslq 0x8(%rsp), %rax
addq %rax, (%rbx)
movq (%rsp), %rsi
jmp 0x5323
movq (%rsp), %rax
cmpb $0x28, (%rax)
jne 0x5417
andq $0x0, (%rsp)
xorl %esi, %esi
leaq 0x28(%r14), %r12
movq %r12, %rdi
callq 0x5bca
movq %rax, %r15
movq (%rbx), %rdi
callq 0x3546
movq %rax, (%rbx)
cmpb $0x28, (%rax)
jne 0x5436
incq %rax
movq %rax, (%rbx)
leaq 0x10(%rsp), %r13
movq %rax, %rdi
callq 0x3546
movq %rax, (%rbx)
cmpb $0x29, (%rax)
je 0x53b4
movq %r13, %rdi
movq %rax, %rsi
callq 0x35cc
cmpl $0x2, 0x1c(%rsp)
jne 0x53d9
movslq 0x18(%rsp), %rax
addq %rax, (%rbx)
movq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x5c22
movq (%rbx), %rdi
callq 0x3546
movq %rax, (%rbx)
movzbl (%rax), %ecx
cmpl $0x2c, %ecx
jne 0x53a6
incq %rax
movq %rax, (%rbx)
jmp 0x5351
cmpl $0x29, %ecx
jne 0x53f8
cmpb $0x29, (%rax)
jne 0x5455
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x5c72
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x30db(%rip), %rdi      # 0x84bb
leaq 0x2e10(%rip), %rsi      # 0x81f7
leaq 0x302f(%rip), %rcx      # 0x841d
movl $0x16a, %edx            # imm = 0x16A
callq 0x2120
leaq 0x36a9(%rip), %rdi      # 0x8aa8
leaq 0x2df1(%rip), %rsi      # 0x81f7
leaq 0x3010(%rip), %rcx      # 0x841d
movl $0x173, %edx            # imm = 0x173
callq 0x2120
leaq 0x2fd2(%rip), %rdi      # 0x83f0
leaq 0x2dd2(%rip), %rsi      # 0x81f7
leaq 0x2ff1(%rip), %rcx      # 0x841d
movl $0x15f, %edx            # imm = 0x15F
callq 0x2120
leaq 0x3072(%rip), %rdi      # 0x84af
leaq 0x2db3(%rip), %rsi      # 0x81f7
leaq 0x2fd2(%rip), %rcx      # 0x841d
movl $0x164, %edx            # imm = 0x164
callq 0x2120
leaq 0x3071(%rip), %rdi      # 0x84cd
leaq 0x2d94(%rip), %rsi      # 0x81f7
leaq 0x2fb3(%rip), %rcx      # 0x841d
movl $0x175, %edx            # imm = 0x175
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseVar(cashew::Parser<asmjs_ast::Node*, Builder>::Frag&, char*&, char const*)
NodeRef parseVar(Frag& frag, char*& src, const char* seps) {
    NodeRef ret = builder.makeVar(frag.str == CONST);
    while (1) {
      src = skipSpace(src);
      if (*src == ';') break;
      Frag name(src);
      assert(name.type == IDENT);
      NodeRef value;
      src += name.size;
      src = skipSpace(src);
      if (*src == '=') {
        src++;
        src = skipSpace(src);
        value = parseElement(src, ";,");
      }
      builder.appendToVar(ret, name.str, value);
      src = skipSpace(src);
      if (*src && *src == ';') break;
      if (*src && *src == ',') {
        src++;
        continue;
      }
      assert(0);
    }
    assert(*src == ';');
    src++;
    return ret;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x28(%rdi), %r12
movq (%rsi), %rax
leaq 0x8d5a(%rip), %rcx      # 0xe1f0
xorl %esi, %esi
cmpq (%rcx), %rax
sete %sil
movq %r12, %rdi
callq 0x5d18
movq %rax, %r14
movq (%rbx), %rax
leaq 0x8(%rsp), %r13
movq %rax, %rdi
callq 0x3546
movq %rax, (%rbx)
cmpb $0x3b, (%rax)
je 0x5555
movq %r13, %rdi
movq %rax, %rsi
callq 0x35cc
cmpl $0x2, 0x14(%rsp)
jne 0x556d
movslq 0x10(%rsp), %rdi
addq (%rbx), %rdi
movq %rdi, (%rbx)
callq 0x3546
movq %rax, (%rbx)
cmpb $0x3d, (%rax)
jne 0x551a
incq %rax
movq %rax, (%rbx)
movq %rax, %rdi
callq 0x3546
movq %rax, (%rbx)
movq %r15, %rdi
movq %rbx, %rsi
leaq 0x310d(%rip), %rdx      # 0x861f
callq 0x4474
movq %rax, %rbp
movq 0x8(%rsp), %rdx
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rcx
callq 0x5d38
movq (%rbx), %rdi
callq 0x3546
movq %rax, (%rbx)
movzbl (%rax), %ecx
cmpl $0x2c, %ecx
jne 0x554b
incq %rax
movq %rax, (%rbx)
jmp 0x54b2
cmpl $0x3b, %ecx
jne 0x558c
cmpb $0x3b, (%rax)
jne 0x55ab
incq %rax
movq %rax, (%rbx)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x300b(%rip), %rdi      # 0x857f
leaq 0x2c7c(%rip), %rsi      # 0x81f7
leaq 0x3010(%rip), %rcx      # 0x8592
movl $0x182, %edx            # imm = 0x182
callq 0x2120
leaq 0x3515(%rip), %rdi      # 0x8aa8
leaq 0x2c5d(%rip), %rsi      # 0x81f7
leaq 0x2ff1(%rip), %rcx      # 0x8592
movl $0x192, %edx            # imm = 0x192
callq 0x2120
leaq 0x3070(%rip), %rdi      # 0x8622
leaq 0x2c3e(%rip), %rsi      # 0x81f7
leaq 0x2fd2(%rip), %rcx      # 0x8592
movl $0x194, %edx            # imm = 0x194
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseReturn(cashew::Parser<asmjs_ast::Node*, Builder>::Frag&, char*&, char const*)
NodeRef parseReturn(Frag& frag, char*& src, const char* seps) {
    src = skipSpace(src);
    NodeRef value = !hasChar(seps, *src) ? parseElement(src, seps) : nullptr;
    src = skipSpace(src);
    assert(hasChar(seps, *src));
    if (*src == ';') src++;
    return builder.makeReturn(value);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rdi
callq 0x3546
movq %rax, (%r14)
movsbl (%rax), %esi
movq %r15, %rdi
callq 0x35b8
testb %al, %al
je 0x55fa
xorl %r12d, %r12d
jmp 0x560b
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4474
movq %rax, %r12
movq (%r14), %rdi
callq 0x3546
movq %rax, (%r14)
movsbl (%rax), %esi
movq %r15, %rdi
callq 0x35b8
testb %al, %al
je 0x564d
movq (%r14), %rax
cmpb $0x3b, (%rax)
jne 0x5633
incq %rax
movq %rax, (%r14)
addq $0x28, %rbx
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5dc0
leaq 0x3008(%rip), %rdi      # 0x865c
leaq 0x2b9c(%rip), %rsi      # 0x81f7
leaq 0x300e(%rip), %rcx      # 0x8670
movl $0x19d, %edx            # imm = 0x19D
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseIf(cashew::Parser<asmjs_ast::Node*, Builder>::Frag&, char*&, char const*)
NodeRef parseIf(Frag& frag, char*& src, const char* seps) {
    NodeRef condition = parseParenned(src);
    NodeRef ifTrue = parseMaybeBracketed(src, seps);
    src = skipSpace(src);
    NodeRef ifFalse;
    if (*src && !hasChar(seps, *src)) {
      Frag next(src);
      if (next.type == KEYWORD && next.str == ELSE) {
        src += next.size;
        ifFalse = parseMaybeBracketed(src, seps);
      }
    }
    return builder.makeIf(condition, ifTrue, ifFalse);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x5de0
movq %rax, %r15
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x5e74
movq %rax, %r13
movq (%r12), %rdi
callq 0x3546
movq %rax, (%r12)
movsbl (%rax), %esi
movq %r14, %rdi
callq 0x35b8
movq (%r12), %rsi
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x35cc
movslq 0x8(%rbp), %rax
addq %rax, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x5e74
addq $0x28, %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x5eb8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseDo(cashew::Parser<asmjs_ast::Node*, Builder>::Frag&, char*&, char const*)
NodeRef parseDo(Frag& frag, char*& src, const char* seps) {
    NodeRef body = parseMaybeBracketed(src, seps);
    src = skipSpace(src);
    Frag next(src);
    assert(next.type == KEYWORD && next.str == WHILE);
    src += next.size;
    NodeRef condition = parseParenned(src);
    return builder.makeDo(body, condition);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x5e74
movq %rax, %r15
movq (%r14), %rdi
callq 0x3546
movq %rax, (%r14)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x35cc
cmpl $0x0, 0xc(%r12)
jne 0x5786
movq 0x8(%rsp), %rax
leaq 0x8ad0(%rip), %rcx      # 0xe220
cmpq (%rcx), %rax
jne 0x5786
movslq 0x10(%rsp), %rax
addq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5de0
addq $0x28, %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x5eee
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2fef(%rip), %rdi      # 0x877c
leaq 0x2a63(%rip), %rsi      # 0x81f7
leaq 0x300b(%rip), %rcx      # 0x87a6
movl $0x1b5, %edx            # imm = 0x1B5
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseBreak(cashew::Parser<asmjs_ast::Node*, Builder>::Frag&, char*&, char const*)
NodeRef parseBreak(Frag& frag, char*& src, const char* seps) {
    src = skipSpace(src);
    Frag next(src);
    if (next.type == IDENT) src += next.size;
    return builder.makeBreak(next.type == IDENT ? next.str : IString());
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rdi
callq 0x3546
movq %rax, (%r14)
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x35cc
cmpl $0x2, 0xc(%r15)
jne 0x582b
movslq 0x8(%rsp), %rax
addq %rax, (%r14)
movq (%rsp), %rsi
jmp 0x582d
xorl %esi, %esi
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x5f4e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseContinue(cashew::Parser<asmjs_ast::Node*, Builder>::Frag&, char*&, char const*)
NodeRef parseContinue(Frag& frag, char*& src, const char* seps) {
    src = skipSpace(src);
    Frag next(src);
    if (next.type == IDENT) src += next.size;
    return builder.makeContinue(next.type == IDENT ? next.str : IString());
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rdi
callq 0x3546
movq %rax, (%r14)
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x35cc
cmpl $0x2, 0xc(%r15)
jne 0x5881
movslq 0x8(%rsp), %rax
addq %rax, (%r14)
movq (%rsp), %rsi
jmp 0x5883
xorl %esi, %esi
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x5f6e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseBracketedBlock(char*&, asmjs_ast::Node*)
NodeRef parseBracketedBlock(char*& src, NodeRef block=nullptr) {
    if (!block) block = builder.makeBlock();
    src = skipSpace(src);
    assert(*src == '{');
    src++;
    parseBlock(src, block, ";}"); // the two are not symmetrical, ; is just internally separating, } is the final one - parseBlock knows all this
    assert(*src == '}');
    src++;
    return block;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
jne 0x5c91
leaq 0x28(%r15), %rdi
callq 0x3526
movq %rax, %r14
movq (%rbx), %rdi
callq 0x3546
movq %rax, (%rbx)
cmpb $0x7b, (%rax)
jne 0x5cd9
incq %rax
movq %rax, (%rbx)
leaq 0x28c2(%rip), %rcx      # 0x8570
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x342a
movq (%rbx), %rax
cmpb $0x7d, (%rax)
jne 0x5cf8
incq %rax
movq %rax, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x27f9(%rip), %rdi      # 0x84d9
leaq 0x2510(%rip), %rsi      # 0x81f7
leaq 0x27f7(%rip), %rcx      # 0x84e5
movl $0x32f, %edx            # imm = 0x32F
callq 0x2120
leaq 0x2874(%rip), %rdi      # 0x8573
leaq 0x24f1(%rip), %rsi      # 0x81f7
leaq 0x27d8(%rip), %rcx      # 0x84e5
movl $0x332, %edx            # imm = 0x332
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseParenned(char*&)
NodeRef parseParenned(char*& src) {
    src = skipSpace(src);
    assert(*src == '(');
    src++;
    NodeRef ret = parseElement(src, ")");
    src = skipSpace(src);
    assert(*src == ')');
    src++;
    return ret;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x3546
movq %rax, (%rbx)
cmpb $0x28, (%rax)
jne 0x5e36
incq %rax
movq %rax, (%rbx)
leaq 0x2309(%rip), %rdx      # 0x8110
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4474
movq %rax, %r14
movq (%rbx), %rdi
callq 0x3546
movq %rax, (%rbx)
cmpb $0x29, (%rax)
jne 0x5e55
incq %rax
movq %rax, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2672(%rip), %rdi      # 0x84af
leaq 0x23b3(%rip), %rsi      # 0x81f7
leaq 0x28b5(%rip), %rcx      # 0x8700
movl $0x352, %edx            # imm = 0x352
callq 0x2120
leaq 0x2671(%rip), %rdi      # 0x84cd
leaq 0x2394(%rip), %rsi      # 0x81f7
leaq 0x2896(%rip), %rcx      # 0x8700
movl $0x356, %edx            # imm = 0x356
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseCall(asmjs_ast::Node*, char*&)
NodeRef parseCall(NodeRef target, char*& src) {
    expressionPartsStack.resize(expressionPartsStack.size()+1);
    assert(*src == '(');
    src++;
    NodeRef ret = builder.makeCall(target);
    while (1) {
      src = skipSpace(src);
      if (*src == ')') break;
      builder.appendToCall(ret, parseElement(src, ",)"));
      src = skipSpace(src);
      if (*src && *src == ')') break;
      if (*src && *src == ',') {
        src++;
        continue;
      }
      assert(0);
    }
    src++;
    assert(expressionPartsStack.back().size() == 0);
    expressionPartsStack.pop_back();
    return ret;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
leaq 0x1(%rax), %rsi
callq 0x31b4
movq (%r14), %rax
cmpb $0x28, (%rax)
jne 0x6290
incq %rax
movq %rax, (%r14)
leaq 0x28(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6492
movq %rax, %r15
movq (%r14), %rax
leaq 0x2883(%rip), %r13      # 0x8a7f
movq %rax, %rdi
callq 0x3546
movq %rax, (%r14)
cmpb $0x29, (%rax)
je 0x6248
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x4474
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x64ba
movq (%r14), %rdi
callq 0x3546
movq %rax, (%r14)
movzbl (%rax), %ecx
cmpl $0x2c, %ecx
jne 0x6243
incq %rax
movq %rax, (%r14)
jmp 0x61fc
cmpl $0x29, %ecx
jne 0x6271
incq %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq -0x10(%rax), %rcx
cmpq -0x18(%rax), %rcx
jne 0x62af
movq %rbx, %rdi
callq 0x64e8
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2830(%rip), %rdi      # 0x8aa8
leaq 0x1f78(%rip), %rsi      # 0x81f7
leaq 0x2778(%rip), %rcx      # 0x89fe
movl $0x22c, %edx            # imm = 0x22C
callq 0x2120
leaq 0x2218(%rip), %rdi      # 0x84af
leaq 0x1f59(%rip), %rsi      # 0x81f7
leaq 0x2759(%rip), %rcx      # 0x89fe
movl $0x21f, %edx            # imm = 0x21F
callq 0x2120
leaq 0x27cc(%rip), %rdi      # 0x8a82
leaq 0x1f3a(%rip), %rsi      # 0x81f7
leaq 0x273a(%rip), %rcx      # 0x89fe
movl $0x22f, %edx            # imm = 0x22F
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseIndexing(asmjs_ast::Node*, char*&)
NodeRef parseIndexing(NodeRef target, char*& src) {
    expressionPartsStack.resize(expressionPartsStack.size()+1);
    assert(*src == '[');
    src++;
    NodeRef ret = builder.makeIndexing(target, parseElement(src, "]"));
    src = skipSpace(src);
    assert(*src == ']');
    src++;
    assert(expressionPartsStack.back().size() == 0);
    expressionPartsStack.pop_back();
    return ret;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
leaq 0x1(%rax), %rsi
callq 0x31b4
movq (%r14), %rax
cmpb $0x5b, (%rax)
jne 0x6367
incq %rax
movq %rax, (%r14)
leaq 0x28(%rbx), %r12
leaq 0x2c78(%rip), %rdx      # 0x8f88
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4474
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x64fc
movq %rax, %r15
movq (%r14), %rdi
callq 0x3546
movq %rax, (%r14)
cmpb $0x5d, (%rax)
jne 0x6386
incq %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq -0x10(%rax), %rcx
cmpq -0x18(%rax), %rcx
jne 0x63a5
movq %rbx, %rdi
callq 0x64e8
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x273c(%rip), %rdi      # 0x8aaa
leaq 0x1e82(%rip), %rsi      # 0x81f7
leaq 0x273a(%rip), %rcx      # 0x8ab6
movl $0x236, %edx            # imm = 0x236
callq 0x2120
leaq 0x27ae(%rip), %rdi      # 0x8b3b
leaq 0x1e63(%rip), %rsi      # 0x81f7
leaq 0x271b(%rip), %rcx      # 0x8ab6
movl $0x23a, %edx            # imm = 0x23A
callq 0x2120
leaq 0x26d6(%rip), %rdi      # 0x8a82
leaq 0x1e44(%rip), %rsi      # 0x81f7
leaq 0x26fc(%rip), %rcx      # 0x8ab6
movl $0x23c, %edx            # imm = 0x23C
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseDotting(asmjs_ast::Node*, char*&)
NodeRef parseDotting(NodeRef target, char*& src) {
    assert(*src == '.');
    src++;
    Frag key(src);
    assert(key.type == IDENT);
    src += key.size;
    return builder.makeDot(target, key.str);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq (%rdx), %rsi
cmpb $0x2e, (%rsi)
jne 0x6453
movq %rdx, %r15
movq %rdi, %r14
incq %rsi
movq %rsi, (%rdx)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x35cc
cmpl $0x2, 0xc(%r12)
jne 0x6472
movslq 0x10(%rsp), %rax
addq %rax, (%r15)
addq $0x28, %r14
movq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x652c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x26ed(%rip), %rdi      # 0x8b47
leaq 0x1d96(%rip), %rsi      # 0x81f7
leaq 0x26eb(%rip), %rcx      # 0x8b53
movl $0x242, %edx            # imm = 0x242
callq 0x2120
leaq 0x275e(%rip), %rdi      # 0x8bd7
leaq 0x1d77(%rip), %rsi      # 0x81f7
leaq 0x26cc(%rip), %rcx      # 0x8b53
movl $0x245, %edx            # imm = 0x245
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O2/lukewagner[P]asmjs2wasm/src/cashew/istring.h
// Function: cashew::IStringSet::IStringSet(char const*)
IStringSet(const char *init) { // comma-delimited list
    int size = strlen(init);
    char *curr = new char[size+1]; // leaked!
    strcpy(curr, init);
    while (1) {
      char *end = strchr(curr, ' ');
      if (end) *end = 0;
      insert(curr);
      if (!end) break;
      curr = end + 1;
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
movq %rsi, %rdi
callq 0x20a0
incl %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x2170
pushq $0x20
popq %rbp
movq %rsp, %r14
pushq $0x1
popq %r15
movq %r12, %rdi
movl %ebp, %esi
callq 0x2070
movq %rax, %r13
testq %rax, %rax
je 0x6c35
movb $0x0, (%r13)
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x3d58
movq %rbx, %rdi
movq %r14, %rsi
callq 0x703e
leaq 0x1(%r13), %r12
testq %r13, %r13
jne 0x6c1e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6c68
movq %rax, %r14
movq %rbx, %rdi
callq 0x7364
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/TBody[P]atomicpp/atomicpp/sharedFunctions.cpp
// Function: atomicpp::retrieveFromJSON(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
json atomicpp::retrieveFromJSON(std::string path_to_file){
	// Do not pass path_to_file by reference - results in error!
	// Reads a .json file given at path_to_file
	// Uses the json module at https://github.com/nlohmann/json/
	// This relies upon the "json.hpp" header which must be included in the same folder as the source
	
	// Open a file-stream at path_to_file
	if (atomicpp::test_file_exists(path_to_file)){
		std::ifstream json_file(path_to_file);
		// Initialise a json file object at j_object
		json j_object;
		json_file >> j_object;
		return j_object;
	} else {
		std::stringstream errMsg;
		errMsg << "atomicpp::sharedFunctions::retrieveFromJSON error: file (" << path_to_file << ") not found";
		throw std::runtime_error(errMsg.str());
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5d61
testb %al, %al
je 0x5c95
leaq -0x240(%rbp), %r15
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x4500
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5d98
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5dbe
leaq -0x240(%rbp), %rdi
callq 0x40e0
movq %rbx, %rax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x240(%rbp), %rdi
callq 0x4250
leaq -0x230(%rbp), %rdi
leaq 0x1b4c9(%rip), %rsi     # 0x21178
callq 0x4360
movq %rax, %rdi
movq %r14, %rsi
callq 0x4320
leaq 0x1b4ec(%rip), %rsi     # 0x211b2
movq %rax, %rdi
callq 0x4360
pushq $0x10
popq %rdi
callq 0x41b0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x4350
movb $0x1, %r15b
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x4510
xorl %r15d, %r15d
movq 0x342ee(%rip), %rsi     # 0x39ff0
movq 0x34297(%rip), %rdx     # 0x39fa0
movq %rbx, %rdi
callq 0x4560
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x41a0
testb %r15b, %r15b
jne 0x5d27
jmp 0x5d34
movq %rax, %r14
movq %rbx, %rdi
callq 0x4270
jmp 0x5d34
movq %rax, %r14
leaq -0x240(%rbp), %rdi
callq 0x4280
jmp 0x5d59
movq %rax, %r14
movq %rbx, %rdi
callq 0x5e66
leaq -0x240(%rbp), %rdi
callq 0x40e0
movq %r14, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O2/TBody[P]atomicpp/atomicpp/sharedFunctions.cpp
// Function: atomicpp::test_file_exists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool atomicpp::test_file_exists (const std::string& name) {
    if (FILE *file = fopen(name.c_str(), "r")) {
        fclose(file);
        return true;
    } else {
        return false;
    }   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x4180
leaq 0x1ca92(%rip), %rsi     # 0x22805
movq %rax, %rdi
callq 0x4400
movq %rax, %rbx
testq %rax, %rax
je 0x5d8b
movq %rbx, %rdi
callq 0x4370
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq