LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5e62
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x7580
testb $0x1, %al
jne 0x5d5b
jmp 0x5d69
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x5d3c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x5ddd
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0x5ddd
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x9(%rbp)
je 0x5dac
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x5db5
jmp 0x5dc3
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x5d8e
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5dd8
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x5d3c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x5e60
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2a, %eax
jne 0x5e60
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0xa(%rbp)
je 0x5e38
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2a, %ecx
movb %al, -0xb(%rbp)
jne 0x5e32
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
testb $0x1, %al
jne 0x5e41
jmp 0x5e4f
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x5e02
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x5d3c
jmp 0x5e62
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0x6712
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x28, %rdi
callq 0x5cf0
movq %rax, -0x8(%rbp)
jmp 0x6777
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x9850
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0x676f
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq -0x28(%rbp), %rsi
callq 0x9b10
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x20(%rax), %rax
cmpq -0x10(%rbp), %rax
jae 0x68db
movq $0x10000, -0x18(%rbp)   # imm = 0x10000
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x5730
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x20(%rax)
movq 0x20(%rax), %rdi
callq 0x2030
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x6910
movq -0x30(%rbp), %rdi
callq 0x6990
movq %rax, %rdi
callq 0x69d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdx
movq 0x20(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpb $0x0, 0x1abd7(%rip)     # 0x221d0
jne 0x764c
leaq 0x1abce(%rip), %rdi     # 0x221d0
callq 0x22d0
cmpl $0x0, %eax
je 0x764c
movl $0x38, %edi
callq 0x21b0
movq %rax, -0x80(%rbp)
jmp 0x761c
movq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x20e0
movq -0x80(%rbp), %rdi
callq 0x7940
movq -0x80(%rbp), %rax
movq %rax, 0x1ab88(%rip)     # 0x221c8
leaq 0x1ab89(%rip), %rdi     # 0x221d0
callq 0x2120
testb $0x1, -0x11(%rbp)
je 0x76af
movq 0x1ab6f(%rip), %rdi     # 0x221c8
leaq -0x10(%rbp), %rsi
callq 0x7960
movb %dl, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movb -0x40(%rbp), %al
movb %al, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x79a0
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, (%rax)
jmp 0x774b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq 0x1ab2b(%rip), %rdi     # 0x221d0
callq 0x2110
jmp 0x7754
movq 0x1ab12(%rip), %rdi     # 0x221c8
leaq -0x10(%rbp), %rsi
callq 0x79d0
movq %rax, -0x50(%rbp)
movq 0x1aafe(%rip), %rdi     # 0x221c8
callq 0x7a30
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x7a00
testb $0x1, %al
jne 0x76e6
jmp 0x7716
movq -0x10(%rbp), %rdi
callq 0x20b0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2210
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2180
movq -0x60(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x7726
leaq -0x50(%rbp), %rdi
callq 0x79a0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq 0x1aa9b(%rip), %rdi     # 0x221c8
leaq -0x10(%rbp), %rsi
callq 0x7960
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq %rcx, -0x70(%rbp)
movb %dl, -0x68(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22b0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x1a729(%rip), %rax     # 0x21fc0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xdb29(%rip), %rsi      # 0x153ce
movb $0x0, %al
callq 0x2250
movl $0x2, -0x14(%rbp)
movl $0xc8, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x791f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x78e2
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x78e0
jmp 0x791f
jmp 0x78e2
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x78f3
jmp 0x791f
movq 0x1a6c6(%rip), %rax     # 0x21fc0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %edx
leaq 0xdac8(%rip), %rsi      # 0x153de
movb $0x0, %al
callq 0x2250
jmp 0x78ba
movq 0x1a69a(%rip), %rax     # 0x21fc0
movq (%rax), %rdi
leaq 0xdab1(%rip), %rsi      # 0x153e1
movb $0x0, %al
callq 0x2250
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x1505, -0xc(%rbp)     # imm = 0x1505
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
je 0x817a
movl -0xc(%rbp), %eax
shll $0x5, %eax
addl -0xc(%rbp), %eax
xorl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x814f
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x3, %eax
ja 0xafc2
movq -0x30(%rbp), %rax
leaq 0xa294(%rip), %rcx      # 0x151d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0xf160
movq %rax, -0x8(%rbp)
jmp 0xafe1
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0xf1b0
movq %rax, -0x8(%rbp)
jmp 0xafe1
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rax
cvttsd2si (%rax), %rax
movl %eax, %esi
callq 0xf200
movq %rax, -0x8(%rbp)
jmp 0xafe1
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
callq 0xf240
movq %rax, -0x8(%rbp)
jmp 0xafe1
leaq 0xabf2(%rip), %rdi      # 0x15bbb
leaq 0xa337(%rip), %rsi      # 0x15307
movl $0x143, %edx            # imm = 0x143
leaq 0xaf46(%rip), %rcx      # 0x15f22
callq 0x2130
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x4ff0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x4eb0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
leaq 0xa1be(%rip), %rdx      # 0x15220
callq 0x9850
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
jne 0xb092
jmp 0xb0b1
leaq 0xa547(%rip), %rdi      # 0x155e0
leaq 0xa267(%rip), %rsi      # 0x15307
movl $0x24f, %edx            # imm = 0x24F
leaq 0xaeed(%rip), %rcx      # 0x15f99
callq 0x2130
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0xd640
movq %rax, %rdi
callq 0xd680
cmpq $0x0, %rax
jne 0xb0d8
jmp 0xb0f7
leaq 0xaab6(%rip), %rdi      # 0x15b95
leaq 0xa221(%rip), %rsi      # 0x15307
movl $0x251, %edx            # imm = 0x251
leaq 0xaea7(%rip), %rcx      # 0x15f99
callq 0x2130
movq -0x20(%rbp), %rdi
callq 0xd840
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x4ff0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x4eb0
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0xf380
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0xb172
jmp 0xb191
leaq 0xae9e(%rip), %rdi      # 0x16017
leaq 0xa187(%rip), %rsi      # 0x15307
movl $0x25b, %edx            # imm = 0x25B
leaq 0xae90(%rip), %rcx      # 0x1601c
callq 0x2130
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0xb1a5
jmp 0xb241
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0xaee6(%rip), %rdx      # 0x1609a
callq 0x9850
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xf3c0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0xb20a
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xb14e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0xb21b
jmp 0xb23a
leaq 0xaa2c(%rip), %rdi      # 0x15c4e
leaq 0xa0de(%rip), %rsi      # 0x15307
movl $0x263, %edx            # imm = 0x263
leaq 0xade7(%rip), %rcx      # 0x1601c
callq 0x2130
jmp 0xb23c
jmp 0xb14e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0xb252
jmp 0xb271
leaq 0xa9f5(%rip), %rdi      # 0x15c4e
leaq 0xa0a7(%rip), %rsi      # 0x15307
movl $0x265, %edx            # imm = 0x265
leaq 0xadb0(%rip), %rcx      # 0x1601c
callq 0x2130
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %esi
callq 0x5e70
testb $0x1, %al
jne 0xb9f4
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x9850
movq %rax, -0x38(%rbp)
jmp 0xb9fc
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xb9fc
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %esi
callq 0x5e70
testb $0x1, %al
jne 0xba33
jmp 0xba35
jmp 0xba54
leaq 0x9d33(%rip), %rdi      # 0x1576f
leaq 0x98c4(%rip), %rsi      # 0x15307
movl $0x19d, %edx            # imm = 0x19D
leaq 0x9d34(%rip), %rcx      # 0x15783
callq 0x2130
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0xba71
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq -0x28(%rbp), %rsi
callq 0xc870
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x18(%rbp), %rsi
callq 0xc8f0
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xc9e0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0xbb61
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %esi
callq 0x5e70
testb $0x1, %al
jne 0xbb61
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x48(%rbp), %rdi
callq 0x5f00
cmpl $0x0, -0x3c(%rbp)
jne 0xbb5f
leaq -0x48(%rbp), %rdi
leaq 0x1671c(%rip), %rsi     # 0x22248
callq 0x6680
testb $0x1, %al
jne 0xbb37
jmp 0xbb5f
movq -0x50(%rbp), %rdi
movl -0x40(%rbp), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xc9e0
movq %rax, -0x38(%rbp)
jmp 0xbb61
movq -0x50(%rbp), %rdi
addq $0x28, %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0xca60
addq $0x50, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xc9e0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x38(%rbp), %rdi
callq 0x5f00
xorl %eax, %eax
cmpl $0x0, -0x2c(%rbp)
movb %al, -0x41(%rbp)
jne 0xbbf5
leaq -0x38(%rbp), %rdi
leaq 0x16663(%rip), %rsi     # 0x22250
callq 0x6680
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xbbfe
jmp 0xbc00
jmp 0xbc1f
leaq 0x9c88(%rip), %rdi      # 0x1588f
leaq 0x96f9(%rip), %rsi      # 0x15307
movl $0x1b5, %edx            # imm = 0x1B5
leaq 0x9c9f(%rip), %rcx      # 0x158b9
callq 0x2130
movq -0x50(%rbp), %rdi
movl -0x30(%rbp), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rsi
callq 0xc8f0
movq -0x50(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x28, %rdi
movq -0x28(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xcb00
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5f00
cmpl $0x2, -0x24(%rbp)
jne 0xbd1f
movl -0x28(%rbp), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x48(%rbp)
cmpl $0x2, -0x24(%rbp)
jne 0xbd3b
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xbd44
leaq -0x38(%rbp), %rdi
callq 0x5cd0
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xcc20
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5f00
cmpl $0x2, -0x24(%rbp)
jne 0xbdbf
movl -0x28(%rbp), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x48(%rbp)
cmpl $0x2, -0x24(%rbp)
jne 0xbddb
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xbde4
leaq -0x38(%rbp), %rdi
callq 0x5cd0
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xccb0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xc434
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x5cf0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x7b, %eax
jne 0xc45b
jmp 0xc47a
leaq 0x918a(%rip), %rdi      # 0x155ec
leaq 0x8e9e(%rip), %rsi      # 0x15307
movl $0x32f, %edx            # imm = 0x32F
leaq 0x9183(%rip), %rcx      # 0x155f8
callq 0x2130
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5cd0
leaq -0x28(%rbp), %rdi
callq 0x5cd0
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
leaq 0x91be(%rip), %rcx      # 0x15683
callq 0x5b40
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x7d, %eax
jne 0xc4db
jmp 0xc4fa
leaq 0x91a4(%rip), %rdi      # 0x15686
leaq 0x8e1e(%rip), %rsi      # 0x15307
movl $0x332, %edx            # imm = 0x332
leaq 0x9103(%rip), %rcx      # 0x155f8
callq 0x2130
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: lukewagner[P]asmjs2wasm/src/list.h
// Function: List<asmjs_ast::Param>::append(asmjs_ast::Param&)
void append(T& n)
  {
    if (!first_) {
      first_ = last_ = &n;
    } else {
      last_->next = &n;
      last_ = &n;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, (%rax)
jne 0xc5bb
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq %rcx, (%rax)
jmp 0xc5d2
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x8(%rax), %rcx
movq %rdx, (%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0xc92f
jmp 0xc94e
leaq 0x8c8c(%rip), %rdi      # 0x155c2
leaq 0x89ca(%rip), %rsi      # 0x15307
movl $0x352, %edx            # imm = 0x352
leaq 0x8eca(%rip), %rcx      # 0x15813
callq 0x2130
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
leaq 0x88b5(%rip), %rdx      # 0x15220
callq 0x9850
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
jne 0xc99b
jmp 0xc9ba
leaq 0x8c3e(%rip), %rdi      # 0x155e0
leaq 0x895e(%rip), %rsi      # 0x15307
movl $0x356, %edx            # imm = 0x356
leaq 0x8e5e(%rip), %rcx      # 0x15813
callq 0x2130
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x4ff0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x4eb0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0xd372
jmp 0xd391
leaq 0x8249(%rip), %rdi      # 0x155c2
leaq 0x7f87(%rip), %rsi      # 0x15307
movl $0x21f, %edx            # imm = 0x21F
leaq 0x8785(%rip), %rcx      # 0x15b11
callq 0x2130
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0xd7c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
jne 0xd3de
jmp 0xd495
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x8792(%rip), %rdx      # 0x15b92
callq 0x9850
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0xd800
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0xd448
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
jne 0xd448
jmp 0xd495
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0xd476
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0xd476
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xd3b4
leaq 0x873e(%rip), %rdi      # 0x15bbb
leaq 0x7e83(%rip), %rsi      # 0x15307
movl $0x22c, %edx            # imm = 0x22C
leaq 0x8681(%rip), %rcx      # 0x15b11
callq 0x2130
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0xd640
movq %rax, %rdi
callq 0xd680
cmpq $0x0, %rax
jne 0xd4bc
jmp 0xd4db
leaq 0x86d2(%rip), %rdi      # 0x15b95
leaq 0x7e3d(%rip), %rsi      # 0x15307
movl $0x22f, %edx            # imm = 0x22F
leaq 0x863b(%rip), %rcx      # 0x15b11
callq 0x2130
movq -0x28(%rbp), %rdi
callq 0xd840
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x4ff0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x4eb0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x5b, %eax
jne 0xd532
jmp 0xd551
leaq 0x8684(%rip), %rdi      # 0x15bbd
leaq 0x7dc7(%rip), %rsi      # 0x15307
movl $0x236, %edx            # imm = 0x236
leaq 0x867d(%rip), %rcx      # 0x15bc9
callq 0x2130
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x8b1a(%rip), %rdx      # 0x1609b
callq 0x9850
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0xd8b0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0xd5c1
jmp 0xd5e0
leaq 0x8686(%rip), %rdi      # 0x15c4e
leaq 0x7d38(%rip), %rsi      # 0x15307
movl $0x23a, %edx            # imm = 0x23A
leaq 0x85ee(%rip), %rcx      # 0x15bc9
callq 0x2130
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0xd640
movq %rax, %rdi
callq 0xd680
cmpq $0x0, %rax
jne 0xd607
jmp 0xd626
leaq 0x8587(%rip), %rdi      # 0x15b95
leaq 0x7cf2(%rip), %rsi      # 0x15307
movl $0x23c, %edx            # imm = 0x23C
leaq 0x85a8(%rip), %rcx      # 0x15bc9
callq 0x2130
movq -0x28(%rbp), %rdi
callq 0xd840
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0xd71d
jmp 0xd73c
leaq 0x8536(%rip), %rdi      # 0x15c5a
leaq 0x7bdc(%rip), %rsi      # 0x15307
movl $0x242, %edx            # imm = 0x242
leaq 0x852f(%rip), %rcx      # 0x15c66
callq 0x2130
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x5f00
cmpl $0x2, -0x1c(%rbp)
jne 0xd762
jmp 0xd781
leaq 0x8581(%rip), %rdi      # 0x15cea
leaq 0x7b97(%rip), %rsi      # 0x15307
movl $0x245, %edx            # imm = 0x245
leaq 0x84ea(%rip), %rcx      # 0x15c66
callq 0x2130
movq -0x38(%rbp), %rdi
movl -0x20(%rbp), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
callq 0xda30
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::makeBinary(asmjs_ast::Node*, cashew::IString, asmjs_ast::Node*)
NodeRef makeBinary(NodeRef left, IString op, NodeRef right) {
    if (op == PERIOD) {
      return builder.makeDot(left, right);
    } else {
      return builder.makeBinary(left, op ,right);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
leaq 0x1471d(%rip), %rsi     # 0x22438
callq 0x6680
testb $0x1, %al
jne 0xdd26
jmp 0xdd41
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xea40
movq %rax, -0x8(%rbp)
jmp 0xdd66
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rdx
callq 0xeaa0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x101c0
movq -0x10(%rbp), %rdi
callq 0x20b0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
incl %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, -0x58(%rbp)
jmp 0xf97c
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2180
jmp 0xf993
movq -0x20(%rbp), %rdi
movl $0x20, %esi
callq 0x2080
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xf9cc
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
jmp 0xf9cc
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x10220
jmp 0xfa24
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movl $0x1, %edx
callq 0xf900
jmp 0xf9e0
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x101e0
movb %dl, -0x69(%rbp)
movq %rax, -0x68(%rbp)
jmp 0xf9f6
movb -0x69(%rbp), %al
movq -0x68(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movb %al, -0x48(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xfa0d
jmp 0xfa1e
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xf991
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x22b0
nopl (%rax)
// File: 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
subq $0x420, %rsp            # imm = 0x420
movq %rsi, -0x3f8(%rbp)
movq %rdi, %rax
movq -0x3f8(%rbp), %rdi
movq %rax, -0x3f0(%rbp)
movq %rax, %rcx
movq %rcx, -0x3e8(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x6e50
testb $0x1, %al
jne 0x6c63
jmp 0x6d17
movq -0x3f8(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movq %rdi, -0x400(%rbp)
movl $0x8, %edx
callq 0x4560
movq -0x3f0(%rbp), %rdi
movb $0x0, -0x219(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x6ea0
movq -0x400(%rbp), %rdi
movq -0x3f0(%rbp), %rsi
callq 0x6ee0
jmp 0x6cae
movb $0x1, -0x219(%rbp)
testb $0x1, -0x219(%rbp)
jne 0x6cfb
jmp 0x6cef
movq -0x3f0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
callq 0x6fd0
leaq -0x218(%rbp), %rdi
callq 0x40f0
jmp 0x6e40
movq -0x3f0(%rbp), %rdi
callq 0x6fd0
leaq -0x218(%rbp), %rdi
callq 0x40f0
movq -0x3e8(%rbp), %rax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
leaq -0x3b8(%rbp), %rdi
callq 0x4290
leaq -0x3a8(%rbp), %rdi
leaq 0x2f597(%rip), %rsi     # 0x362c8
callq 0x43a0
movq %rax, -0x408(%rbp)
jmp 0x6d3f
movq -0x3f8(%rbp), %rsi
movq -0x408(%rbp), %rdi
callq 0x4360
movq %rax, -0x410(%rbp)
jmp 0x6d5b
movq -0x410(%rbp), %rdi
leaq 0x2f599(%rip), %rsi     # 0x36302
callq 0x43a0
jmp 0x6d70
movb $0x1, -0x3d9(%rbp)
movl $0x10, %edi
callq 0x41b0
movq %rax, -0x418(%rbp)
leaq -0x3d8(%rbp), %rdi
leaq -0x3b8(%rbp), %rsi
callq 0x4390
jmp 0x6d9d
movq -0x418(%rbp), %rdi
leaq -0x3d8(%rbp), %rsi
callq 0x4570
jmp 0x6db2
movq -0x418(%rbp), %rdi
movb $0x0, -0x3d9(%rbp)
movq 0x48229(%rip), %rsi     # 0x4eff0
movq 0x481d2(%rip), %rdx     # 0x4efa0
callq 0x45b0
jmp 0x6e4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x6e34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x6e1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x3d8(%rbp), %rdi
callq 0x4220
testb $0x1, -0x3d9(%rbp)
jne 0x6e26
jmp 0x6e32
movq -0x418(%rbp), %rdi
callq 0x42b0
jmp 0x6e34
leaq -0x3b8(%rbp), %rdi
callq 0x42c0
movq -0x228(%rbp), %rdi
callq 0x45e0
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4180
movq %rax, %rdi
leaq 0x30b16(%rip), %rsi     # 0x37985
callq 0x4450
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6e8e
movq -0x18(%rbp), %rdi
callq 0x43b0
movb $0x1, -0x1(%rbp)
jmp 0x6e92
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: TBody[P]atomicpp/atomicpp/ImpuritySpecies.cpp
// Function: atomicpp::ImpuritySpecies::makeRateCoefficients()
void ImpuritySpecies::makeRateCoefficients(){
	// # Calls the RateCoefficient constructor method for each entry in the .adas_files_dict
	// # Generates a dictionary smart pointer to RateCoefficient objects as .rate_coefficients
	// See http://umich.edu/~eecs381/handouts/C++11_smart_ptrs.pdf for information on smart pointers (memory-managed)

	for (auto& kv : get_adas_files_dict()) {
		std::string physics_process = kv.first;
		std::string filename = kv.second;
		// Make a new RateCoefficient object by calling the RateCoefficient constructor on 'filename'
		// Create a smart pointer 'RC' that points to this object
		std::shared_ptr<RateCoefficient> RC(new RateCoefficient(filename));
		// Add 'RC' to the rate_coefficients attribute of ImpuritySpecies
		// (n.b. this is a std::map from a std::string 'physics_process' to a smart pointer which points to a RateCoefficient object)
		rate_coefficients[physics_process] = RC;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xc0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x11e60
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13240
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13270
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x132a0
testb $0x1, %al
jne 0x11ce4
leaq -0x40(%rbp), %rdi
callq 0x6090
jmp 0x11e40
leaq -0x48(%rbp), %rdi
callq 0x132d0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x4190
jmp 0x11d00
movq -0x58(%rbp), %rsi
addq $0x20, %rsi
leaq -0xa8(%rbp), %rdi
callq 0x4190
jmp 0x11d16
movl $0x60, %edi
callq 0x43c0
movq %rax, -0xc8(%rbp)
jmp 0x11d29
movq -0xc8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1a4a0
jmp 0x11d3e
movq -0xc8(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x137c0
jmp 0x11d53
movq -0xc0(%rbp), %rdi
addq $0x88, %rdi
leaq -0x78(%rbp), %rsi
callq 0x137f0
movq %rax, -0xd0(%rbp)
jmp 0x11d73
movq -0xd0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x138d0
leaq -0xb8(%rbp), %rdi
callq 0x5990
leaq -0xa8(%rbp), %rdi
callq 0x4220
leaq -0x78(%rbp), %rdi
callq 0x4220
leaq -0x48(%rbp), %rdi
callq 0x133d0
jmp 0x11cc5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x11e35
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x11e2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x11e20
movq -0xc8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
callq 0x4370
jmp 0x11e20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x5990
leaq -0xa8(%rbp), %rdi
callq 0x4220
leaq -0x78(%rbp), %rdi
callq 0x4220
leaq -0x40(%rbp), %rdi
callq 0x6090
jmp 0x11e49
addq $0xd0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: TBody[P]atomicpp/atomicpp/RateCoefficient.cpp
// Function: atomicpp::RateCoefficient::RateCoefficient(std::shared_ptr<atomicpp::RateCoefficient>)
RateCoefficient::RateCoefficient(const std::shared_ptr<RateCoefficient> source_RC){
	// # Create an instance of a blank RateCoefficient by copying from another RateCoefficient object

	atomic_number   = source_RC->get_atomic_number();
	element         = source_RC->get_element();
	adf11_file      = source_RC->get_adf11_file();

	interpolator = source_RC->get_interpolator();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x8, %rdi
movq %rdi, -0xa8(%rbp)
callq 0x44e0
movq -0x98(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x44e0
movq -0x98(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x90(%rbp)
callq 0x1abd0
movq -0x88(%rbp), %rdi
callq 0x5970
movq %rax, %rdi
callq 0x1a9a0
movl %eax, -0x7c(%rbp)
jmp 0x1a88c
movq -0x88(%rbp), %rdi
movq -0x98(%rbp), %rax
movl -0x7c(%rbp), %ecx
movl %ecx, (%rax)
callq 0x5970
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x1a9b0
jmp 0x1a8b2
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
leaq -0x40(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
callq 0x4470
movq -0xb0(%rbp), %rdi
callq 0x4220
movq -0x88(%rbp), %rdi
callq 0x5970
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x1a9e0
jmp 0x1a8f3
movq -0x98(%rbp), %rdi
addq $0x28, %rdi
leaq -0x60(%rbp), %rsi
movq %rsi, -0xb8(%rbp)
callq 0x4470
movq -0xb8(%rbp), %rdi
callq 0x4220
movq -0x88(%rbp), %rdi
callq 0x5970
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
callq 0x1aa10
jmp 0x1a934
movq -0x98(%rbp), %rdi
addq $0x48, %rdi
leaq -0x78(%rbp), %rsi
callq 0x1ad00
leaq -0x78(%rbp), %rdi
callq 0x18f70
addq $0xc0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x18f70
movq -0xa0(%rbp), %rdi
callq 0x4220
movq -0xa8(%rbp), %rdi
callq 0x4220
movq -0x18(%rbp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: TBody[P]atomicpp/atomicpp/RateCoefficient.cpp
// Function: atomicpp::RateCoefficient::call0D(int, double, double)
double RateCoefficient::call0D(const int k, const double eval_Te, const double eval_Ne){

	double eval_log_Te = log10(eval_Te);
	double eval_log_Ne = log10(eval_Ne);

	double eval_log_rate = interpolator[k].call0D(eval_log_Te, eval_log_Ne);

	return pow(10, eval_log_rate);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x41c0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x41c0
movq -0x40(%rbp), %rdi
movsd %xmm0, -0x30(%rbp)
addq $0x48, %rdi
movslq -0xc(%rbp), %rsi
callq 0x1ad30
movq %rax, %rdi
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
callq 0x2d8f0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm1
movsd 0x1d67c(%rip), %xmm0    # 0x38130
callq 0x45d0
addq $0x40, %rsp
popq %rbp
retq
nop