LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
incq %rsi
callq 0x3324
leaq 0x28(%r14), %r15
movq 0x28(%r14), %rdi
movl $0x20, %esi
callq 0x3cb4
movq %rax, %r12
movq $0x0, (%rax)
movl $0x4, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
leaq 0x8(%rsp), %r13
leaq 0x3b9d(%rip), %rbp      # 0x9060
movq (%rbx), %rdi
callq 0x3686
movq %rax, (%rbx)
movzbl (%rax), %ecx
cmpl $0x7d, %ecx
je 0x556b
testl %ecx, %ecx
je 0x5583
movq %r13, %rdi
movq %rax, %rsi
callq 0x3700
movl 0x14(%rsp), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x55c1
movslq 0x10(%rsp), %rdi
addq (%rbx), %rdi
movq %rdi, (%rbx)
callq 0x3686
movq %rax, (%rbx)
cmpb $0x3a, (%rax)
jne 0x55a2
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x4490
movq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rcx
callq 0x6b34
movq (%rbx), %rdi
callq 0x3686
movq %rax, (%rbx)
movzbl (%rax), %ecx
cmpl $0x7d, %ecx
je 0x54c3
cmpl $0x2c, %ecx
jne 0x55e0
incq %rax
movq %rax, (%rbx)
jmp 0x54c3
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 0x397a(%rip), %rdi      # 0x8f04
leaq 0x2c66(%rip), %rsi      # 0x81f7
leaq 0x3a22(%rip), %rcx      # 0x8fba
movl $0x26f, %edx            # imm = 0x26F
callq 0x2100
leaq 0x3355(%rip), %rdi      # 0x88fe
leaq 0x2c47(%rip), %rsi      # 0x81f7
leaq 0x3a03(%rip), %rcx      # 0x8fba
movl $0x275, %edx            # imm = 0x275
callq 0x2100
leaq 0x3a70(%rip), %rdi      # 0x9038
leaq 0x2c28(%rip), %rsi      # 0x81f7
leaq 0x39e4(%rip), %rcx      # 0x8fba
movl $0x272, %edx            # imm = 0x272
callq 0x2100
leaq 0x2f8c(%rip), %rdi      # 0x8573
leaq 0x2c09(%rip), %rsi      # 0x81f7
leaq 0x39c5(%rip), %rcx      # 0x8fba
movl $0x27d, %edx            # imm = 0x27D
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x28(%rdi), %rdi
movl $0x20, %esi
callq 0x3cb4
movq %rax, %r14
movq $0x0, (%rax)
movl $0xd, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq (%rbx), %rdi
callq 0x3686
movq %rax, (%rbx)
cmpb $0x3b, (%rax)
je 0x58ac
leaq 0x28(%r15), %r12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0x3700
cmpl $0x2, 0x14(%rsp)
jne 0x58cc
movslq 0x10(%rsp), %rdi
addq (%rbx), %rdi
movq %rdi, (%rbx)
callq 0x3686
movq %rax, (%rbx)
cmpb $0x3d, (%rax)
jne 0x5865
incq %rax
movq %rax, (%rbx)
movq %rax, %rdi
callq 0x3686
movq %rax, (%rbx)
movq %r15, %rdi
movq %rbx, %rsi
leaq 0x2dc2(%rip), %rdx      # 0x861f
callq 0x4490
movq %rax, %rbp
movq 0x8(%rsp), %rdx
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rcx
callq 0x616a
movq (%rbx), %rdi
callq 0x3686
movq %rax, (%rbx)
movzbl (%rax), %ecx
cmpl $0x2c, %ecx
jne 0x58a7
incq %rax
movq %rax, (%rbx)
movq %rax, %rdi
callq 0x3686
movq %rax, (%rbx)
cmpb $0x3b, (%rax)
jne 0x5811
jmp 0x58ac
cmpl $0x3b, %ecx
jne 0x58eb
movq (%rbx), %rax
cmpb $0x3b, (%rax)
jne 0x590a
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 0x2cac(%rip), %rdi      # 0x857f
leaq 0x291d(%rip), %rsi      # 0x81f7
leaq 0x2cb1(%rip), %rcx      # 0x8592
movl $0x182, %edx            # imm = 0x182
callq 0x2100
leaq 0x31b6(%rip), %rdi      # 0x8aa8
leaq 0x28fe(%rip), %rsi      # 0x81f7
leaq 0x2c92(%rip), %rcx      # 0x8592
movl $0x192, %edx            # imm = 0x192
callq 0x2100
leaq 0x2d11(%rip), %rdi      # 0x8622
leaq 0x28df(%rip), %rsi      # 0x81f7
leaq 0x2c73(%rip), %rcx      # 0x8592
movl $0x194, %edx            # imm = 0x194
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3686
movq %rax, (%r14)
movb (%rax), %al
movq %r15, %rcx
movb (%rcx), %dl
cmpb %al, %dl
je 0x5958
incq %rcx
testb %dl, %dl
jne 0x594b
testb %dl, %dl
je 0x5961
xorl %r12d, %r12d
jmp 0x5972
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4490
movq %rax, %r12
movq (%r14), %rdi
callq 0x3686
movq %rax, (%r14)
movb (%rax), %cl
movb (%r15), %dl
cmpb %cl, %dl
je 0x598d
incq %r15
testb %dl, %dl
jne 0x597f
testb %dl, %dl
je 0x59c8
cmpb $0x3b, %cl
jne 0x599c
incq %rax
movq %rax, (%r14)
movq 0x28(%rbx), %rdi
movl $0x18, %esi
callq 0x3cb4
movq $0x0, (%rax)
movl $0xf, 0x8(%rax)
movq %r12, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2c8d(%rip), %rdi      # 0x865c
leaq 0x2821(%rip), %rsi      # 0x81f7
leaq 0x2c93(%rip), %rcx      # 0x8670
movl $0x19d, %edx            # imm = 0x19D
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdx, %r13
movq %rdi, %r14
movq %rdx, %rsi
callq 0x61e0
movq %rax, %rbx
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x6274
movq %rax, %r12
movq (%r13), %rdi
callq 0x3686
movq %rax, (%r13)
movb (%rax), %cl
movq %r15, %rdx
movb (%rdx), %sil
cmpb %cl, %sil
je 0x5a3d
incq %rdx
testb %sil, %sil
jne 0x5a2d
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3700
movslq 0x8(%rbp), %rax
addq %rax, (%r13)
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x6274
movq %rax, %r15
movq 0x28(%r14), %rdi
movl $0x28, %esi
callq 0x3cb4
movq $0x0, (%rax)
movl $0x10, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %r15, 0x20(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdi, %r14
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x6274
movq %rax, %rbx
movq (%r15), %rdi
callq 0x3686
movq %rax, (%r15)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x3700
cmpl $0x0, 0xc(%r12)
jne 0x5b37
movq 0x8(%rsp), %rax
leaq 0x773c(%rip), %rcx      # 0xd228
cmpq (%rcx), %rax
jne 0x5b37
movslq 0x10(%rsp), %rax
addq %rax, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x61e0
movq %rax, %r15
movq 0x28(%r14), %rdi
movl $0x20, %esi
callq 0x3cb4
movq $0x0, (%rax)
movl $0x12, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %r15, 0x18(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2c3e(%rip), %rdi      # 0x877c
leaq 0x26b2(%rip), %rsi      # 0x81f7
leaq 0x2c5a(%rip), %rcx      # 0x87a6
movl $0x1b5, %edx            # imm = 0x1B5
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3686
movq %rax, (%r14)
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x3700
cmpl $0x2, 0xc(%r15)
jne 0x5bf1
movslq 0x8(%rsp), %rax
addq %rax, (%r14)
movq (%rsp), %r14
jmp 0x5bf4
xorl %r14d, %r14d
movq 0x28(%rbx), %rdi
movl $0x18, %esi
callq 0x3cb4
movq $0x0, (%rax)
movl $0x14, 0x8(%rax)
movq %r14, 0x10(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3686
movq %rax, (%r14)
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x3700
cmpl $0x2, 0xc(%r15)
jne 0x5c5b
movslq 0x8(%rsp), %rax
addq %rax, (%r14)
movq (%rsp), %r14
jmp 0x5c5e
xorl %r14d, %r14d
movq 0x28(%rbx), %rdi
movl $0x18, %esi
callq 0x3cb4
movq $0x0, (%rax)
movl $0x15, 0x8(%rax)
movq %r14, 0x10(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x60e3
movq 0x28(%r15), %rdi
movl $0x20, %esi
callq 0x3cb4
movq %rax, %r14
movq $0x0, (%rax)
movl $0xe, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq (%rbx), %rdi
callq 0x3686
movq %rax, (%rbx)
cmpb $0x7b, (%rax)
jne 0x612b
incq %rax
movq %rax, (%rbx)
leaq 0x2470(%rip), %rcx      # 0x8570
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x3564
movq (%rbx), %rax
cmpb $0x7d, (%rax)
jne 0x614a
incq %rax
movq %rax, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x23a7(%rip), %rdi      # 0x84d9
leaq 0x20be(%rip), %rsi      # 0x81f7
leaq 0x23a5(%rip), %rcx      # 0x84e5
movl $0x32f, %edx            # imm = 0x32F
callq 0x2100
leaq 0x2422(%rip), %rdi      # 0x8573
leaq 0x209f(%rip), %rsi      # 0x81f7
leaq 0x2386(%rip), %rcx      # 0x84e5
movl $0x332, %edx            # imm = 0x332
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3686
movq %rax, (%rbx)
cmpb $0x28, (%rax)
jne 0x6236
incq %rax
movq %rax, (%rbx)
leaq 0x1f09(%rip), %rdx      # 0x8110
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4490
movq %rax, %r14
movq (%rbx), %rdi
callq 0x3686
movq %rax, (%rbx)
cmpb $0x29, (%rax)
jne 0x6255
incq %rax
movq %rax, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2272(%rip), %rdi      # 0x84af
leaq 0x1fb3(%rip), %rsi      # 0x81f7
leaq 0x24b5(%rip), %rcx      # 0x8700
movl $0x352, %edx            # imm = 0x352
callq 0x2100
leaq 0x2271(%rip), %rdi      # 0x84cd
leaq 0x1f94(%rip), %rsi      # 0x81f7
leaq 0x2496(%rip), %rcx      # 0x8700
movl $0x356, %edx            # imm = 0x356
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/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, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
incq %rsi
callq 0x3324
movq (%r14), %rax
cmpb $0x28, (%rax)
jne 0x65b0
incq %rax
movq %rax, (%r14)
movq 0x28(%rbx), %rdi
movl $0x28, %esi
callq 0x3cb4
movq %rax, %r15
movq $0x0, (%rax)
movl $0x9, 0x8(%rax)
movq %r12, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movq (%r14), %rdi
callq 0x3686
movq %rax, (%r14)
cmpb $0x29, (%rax)
je 0x655a
leaq 0x28(%rbx), %r12
leaq 0x2571(%rip), %r13      # 0x8a7f
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x4490
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x67c8
movq (%r14), %rdi
callq 0x3686
movq %rax, (%r14)
movzbl (%rax), %ecx
cmpl $0x2c, %ecx
jne 0x6555
incq %rax
movq %rax, (%r14)
movq %rax, %rdi
callq 0x3686
movq %rax, (%r14)
cmpb $0x29, (%rax)
jne 0x650e
jmp 0x655a
cmpl $0x29, %ecx
jne 0x6591
incq (%r14)
movq 0x8(%rbx), %rax
movq -0x18(%rax), %rdi
cmpq %rdi, -0x10(%rax)
jne 0x65cf
leaq -0x18(%rax), %rcx
movq %rcx, 0x8(%rbx)
testq %rdi, %rdi
je 0x6584
movq -0x8(%rax), %rsi
subq %rdi, %rsi
callq 0x2190
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2510(%rip), %rdi      # 0x8aa8
leaq 0x1c58(%rip), %rsi      # 0x81f7
leaq 0x2458(%rip), %rcx      # 0x89fe
movl $0x22c, %edx            # imm = 0x22C
callq 0x2100
leaq 0x1ef8(%rip), %rdi      # 0x84af
leaq 0x1c39(%rip), %rsi      # 0x81f7
leaq 0x2439(%rip), %rcx      # 0x89fe
movl $0x21f, %edx            # imm = 0x21F
callq 0x2100
leaq 0x24ac(%rip), %rdi      # 0x8a82
leaq 0x1c1a(%rip), %rsi      # 0x81f7
leaq 0x241a(%rip), %rcx      # 0x89fe
movl $0x22f, %edx            # imm = 0x22F
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
incq %rsi
callq 0x3324
movq (%r14), %rax
cmpb $0x5b, (%rax)
jne 0x66b9
incq %rax
movq %rax, (%r14)
leaq 0x294e(%rip), %rdx      # 0x8f88
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4490
movq %rax, %r13
movq 0x28(%rbx), %rdi
movl $0x20, %esi
callq 0x3cb4
movq %rax, %r12
movq $0x0, (%rax)
movl $0xc, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r13, 0x18(%rax)
movq (%r14), %rdi
callq 0x3686
movq %rax, (%r14)
cmpb $0x5d, (%rax)
jne 0x66d8
incq %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq -0x18(%rax), %rdi
cmpq %rdi, -0x10(%rax)
jne 0x66f7
leaq -0x18(%rax), %rcx
movq %rcx, 0x8(%rbx)
testq %rdi, %rdi
je 0x66ac
movq -0x8(%rax), %rsi
subq %rdi, %rsi
callq 0x2190
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x23ea(%rip), %rdi      # 0x8aaa
leaq 0x1b30(%rip), %rsi      # 0x81f7
leaq 0x23e8(%rip), %rcx      # 0x8ab6
movl $0x236, %edx            # imm = 0x236
callq 0x2100
leaq 0x245c(%rip), %rdi      # 0x8b3b
leaq 0x1b11(%rip), %rsi      # 0x81f7
leaq 0x23c9(%rip), %rcx      # 0x8ab6
movl $0x23a, %edx            # imm = 0x23A
callq 0x2100
leaq 0x2384(%rip), %rdi      # 0x8a82
leaq 0x1af2(%rip), %rsi      # 0x81f7
leaq 0x23aa(%rip), %rcx      # 0x8ab6
movl $0x23c, %edx            # imm = 0x23C
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/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 0x678a
movq %rdx, %r15
movq %rdi, %r14
incq %rsi
movq %rsi, (%rdx)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x3700
cmpl $0x2, 0xc(%r12)
jne 0x67a9
movslq 0x10(%rsp), %rax
addq %rax, (%r15)
movq 0x8(%rsp), %r15
movq 0x28(%r14), %rdi
movl $0x20, %esi
callq 0x3cb4
movq $0x0, (%rax)
movl $0xb, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %r15, 0x18(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x23b6(%rip), %rdi      # 0x8b47
leaq 0x1a5f(%rip), %rsi      # 0x81f7
leaq 0x23b4(%rip), %rcx      # 0x8b53
movl $0x242, %edx            # imm = 0x242
callq 0x2100
leaq 0x2427(%rip), %rdi      # 0x8bd7
leaq 0x1a40(%rip), %rsi      # 0x81f7
leaq 0x2395(%rip), %rcx      # 0x8b53
movl $0x245, %edx            # imm = 0x245
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
leaq 0x6bee(%rip), %rax      # 0xd410
addq $0x28, %rdi
cmpq %rdx, (%rax)
je 0x685b
movq %rdx, %r15
movq (%rdi), %rdi
movl $0x28, %esi
callq 0x3cb4
movq $0x0, (%rax)
movl $0x7, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x6a8c
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
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 0x2090
incl %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movq %r14, %rdi
movl $0x20, %esi
callq 0x2060
movq %rax, %r13
testq %rax, %rax
je 0x6cdc
movb $0x0, (%r13)
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x3e94
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x715e
leaq 0x1(%r13), %rax
testq %r13, %r13
cmovneq %rax, %r14
jne 0x6cc2
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x6d1b
movq %rax, %r14
movq %rbx, %rdi
callq 0x73f0
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5d8c
testb %al, %al
je 0x5cbb
leaq -0x240(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x4500
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5dc4
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5dea
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 0x1c4a3(%rip), %rsi     # 0x22178
callq 0x4360
movq %rax, %rdi
movq %r14, %rsi
callq 0x4320
leaq 0x1c4c6(%rip), %rsi     # 0x221b2
movq %rax, %rdi
callq 0x4360
movl $0x10, %edi
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 0x352c6(%rip), %rsi     # 0x3aff0
movq 0x3526f(%rip), %rdx     # 0x3afa0
movq %rbx, %rdi
callq 0x4560
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x41a0
jmp 0x5d4d
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x5d5f
movq %rbx, %rdi
callq 0x4270
jmp 0x5d5f
movq %rax, %r14
leaq -0x240(%rbp), %rdi
callq 0x4280
jmp 0x5d84
movq %rax, %r14
movq %rbx, %rdi
callq 0x5e92
leaq -0x240(%rbp), %rdi
callq 0x40e0
movq %r14, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1da67(%rip), %rsi     # 0x23805
movq %rax, %rdi
callq 0x4400
movq %rax, %rbx
testq %rax, %rax
je 0x5db6
movq %rbx, %rdi
callq 0x4370
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/TBody[P]atomicpp/atomicpp/ExternalModules/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::lexer::lexer(std::istream&)
explicit lexer(std::istream& s)
            : m_stream(&s), m_line_buffer()
        {
            // immediately abort if stream is erroneous
            if (s.fail())
            {
                JSON_THROW(std::invalid_argument("stream error"));
            }

            // fill buffer
            fill_line_buffer();

            // skip UTF-8 byte-order mark
            if (m_line_buffer.size() >= 3 and m_line_buffer.substr(0, 3) == "\xEF\xBB\xBF")
            {
                m_line_buffer[0] = ' ';
                m_line_buffer[1] = ' ';
                m_line_buffer[2] = ' ';
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r12
movq %rdi, %r15
movq %rsi, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x4300
leaq 0x28(%r15), %r14
movq %r14, %rdi
callq 0x4300
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%r15)
movups %xmm0, 0x48(%r15)
movq $0x0, 0x68(%r15)
movl $0xf, 0x70(%r15)
movq (%r12), %rax
addq -0x18(%rax), %r12
movq %r12, %rdi
callq 0x4030
testb %al, %al
jne 0x716e
movq %r15, %rdi
xorl %esi, %esi
callq 0x71e6
movq %rbx, %rdi
callq 0x4240
movq %rax, %r15
cmpq $0x3, %rax
jb 0x711a
leaq -0x40(%rbp), %rdi
movl $0x3, %ecx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x43a0
leaq 0x1b772(%rip), %rsi     # 0x2287e
leaq -0x40(%rbp), %rdi
callq 0x7453
movl %eax, %r14d
jmp 0x711d
xorl %r14d, %r14d
cmpq $0x3, %r15
jb 0x712c
leaq -0x40(%rbp), %rdi
callq 0x41a0
testb %r14b, %r14b
je 0x7161
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4640
movb $0x20, %r14b
movb %r14b, (%rax)
movl $0x1, %esi
movq %rbx, %rdi
callq 0x4640
movb %r14b, (%rax)
movl $0x2, %esi
movq %rbx, %rdi
callq 0x4640
movb %r14b, (%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x41b0
movq %rax, %r12
leaq 0x1b6ef(%rip), %rsi     # 0x22871
movq %rax, %rdi
callq 0x45e0
movq 0x33e47(%rip), %rsi     # 0x3afd8
movq 0x33e28(%rip), %rdx     # 0x3afc0
movq %r12, %rdi
callq 0x4560
jmp 0x71af
movq %rax, %r15
movq %r12, %rdi
callq 0x4270
jmp 0x71b2
movq %rax, %r15
movq %r14, %rdi
callq 0x41a0
movq %rbx, %rdi
callq 0x41a0
movq %r15, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O1/TBody[P]atomicpp/atomicpp/ExternalModules/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::basic_json(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>&&)
basic_json(basic_json&& other) noexcept
        : m_type(std::move(other.m_type)),
          m_value(std::move(other.m_value))
    {
        // check that passed value is valid
        other.assert_invariant();

        // invalidate payload
        other.m_type = value_t::null;
        other.m_value = {};

        assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movb (%rsi), %al
movb %al, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq %rsi, %rdi
callq 0x5fe2
movb $0x0, (%rbx)
movq $0x0, 0x8(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5fe2
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rsi
leaq -0xc0(%rbp), %rbx
movq %rbx, %rdi
movq %rsi, -0x30(%rbp)
callq 0xc136
movq %rbx, %rdi
callq 0xce1e
leaq -0x40(%rbp), %r14
movq %rax, (%r14)
movq %rbx, %rdi
callq 0xce28
leaq -0x38(%rbp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0xce32
testb %al, %al
je 0xc0c6
addq $0x88, -0x30(%rbp)
leaq -0x90(%rbp), %r15
leaq -0x70(%rbp), %r12
leaq -0x50(%rbp), %r13
movq %r14, %rdi
callq 0xce42
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
callq 0x4480
addq $0x20, %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4480
movl $0x60, %edi
callq 0x4380
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
callq 0x10fa8
movq %r13, %rdi
movq %rbx, %rsi
callq 0xd0fe
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0xd108
movq %rax, %rdi
movq %r13, %rsi
callq 0xd1c6
movq %r13, %rdi
callq 0x53b8
movq %r12, %rdi
callq 0x41a0
movq %r15, %rdi
callq 0x41a0
movq %r14, %rdi
callq 0xce9a
movq %r14, %rdi
leaq -0x38(%rbp), %rsi
callq 0xce32
testb %al, %al
jne 0xc033
leaq -0xc0(%rbp), %rdi
callq 0x5716
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xc121
movq %rax, %r14
jmp 0xc115
movq %rax, %r14
movq %rbx, %rdi
callq 0x4330
jmp 0xc10c
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x53b8
jmp 0xc10c
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x41a0
leaq -0x90(%rbp), %rdi
callq 0x41a0
leaq -0xc0(%rbp), %rdi
callq 0x5716
movq %r14, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/TBody[P]atomicpp/atomicpp/ExternalModules/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::iter_impl(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>*)
explicit iter_impl(pointer object) noexcept
            : m_object(object)
        {
            assert(m_object != nullptr);

            switch (m_object->m_type)
            {
                case basic_json::value_t::object:
                {
                    m_it.object_iterator = typename object_t::iterator();
                    break;
                }

                case basic_json::value_t::array:
                {
                    m_it.array_iterator = typename array_t::iterator();
                    break;
                }

                default:
                {
                    m_it.primitive_iterator = primitive_iterator_t();
                    break;
                }
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, (%rdi)
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0xe7ac
movq (%rbx), %rax
testq %rax, %rax
je 0xe71a
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0xe6e2
cmpl $0x1, %eax
jne 0xe6f7
leaq -0x18(%rbp), %rbx
movq %rbx, %rdi
callq 0xe7de
movq (%rbx), %rax
movq %rax, (%r14)
jmp 0xe711
leaq -0x18(%rbp), %r14
movq %r14, %rdi
callq 0xe7ec
movq (%r14), %rax
movq %rax, 0x10(%rbx)
jmp 0xe711
leaq -0x18(%rbp), %r14
movq $0x0, (%r14)
movq %r14, %rdi
callq 0xe7fa
movq (%r14), %rax
movq %rax, 0x18(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x151ef(%rip), %rdi     # 0x23910
leaq 0x13acd(%rip), %rsi     # 0x221f5
leaq 0x151f5(%rip), %rcx     # 0x23924
movl $0x22ab, %edx           # imm = 0x22AB
callq 0x4210
nop
// File: /workspace/github_cpp_makefile_star2_O1/TBody[P]atomicpp/atomicpp/ExternalModules/json.hpp
// Function: void nlohmann::detail::from_json<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>, int, 0>(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer> const&, int&)
void from_json(const BasicJsonType& j, ArithmeticType& val)
{
    switch (static_cast<value_t>(j))
    {
        case value_t::number_unsigned:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
            break;
        }
        case value_t::number_integer:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
            break;
        }
        case value_t::number_float:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
            break;
        }
        case value_t::boolean:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
            break;
        }
        default:
        {
            JSON_THROW(std::domain_error("type must be number, but is " + j.type_name()));
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xef06
movzbl %al, %eax
addl $-0x4, %eax
cmpl $0x3, %eax
ja 0xee77
leaq 0x14902(%rip), %rcx     # 0x23734
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
callq 0xef32
movzbl (%rax), %eax
jmp 0xee6a
movq %r14, %rdi
callq 0xef0e
jmp 0xee68
movq %r14, %rdi
callq 0xef26
cvttsd2si (%rax), %eax
jmp 0xee6a
movq %r14, %rdi
callq 0xef1a
movl (%rax), %eax
movl %eax, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x41b0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x9d14
leaq 0x14f58(%rip), %rsi     # 0x23def
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x91e3
movb $0x1, %r15b
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x4410
xorl %r15d, %r15d
movq 0x2c0cb(%rip), %rsi     # 0x3af88
movq 0x2c0d4(%rip), %rdx     # 0x3af98
movq %rbx, %rdi
callq 0x4560
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x41a0
jmp 0xeee0
movq %rax, %r14
movb $0x1, %r15b
leaq -0x38(%rbp), %rdi
callq 0x41a0
jmp 0xeef1
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0xeefe
movq %rbx, %rdi
callq 0x4270
movq %r14, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O1/TBody[P]atomicpp/atomicpp/ExternalModules/json.hpp
// Function: void nlohmann::detail::get_arithmetic_value<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>, double, 0>(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer> const&, double&)
void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
{
    switch (static_cast<value_t>(j))
    {
        case value_t::number_unsigned:
        {
            val = static_cast<ArithmeticType>(
                      *j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
            break;
        }
        case value_t::number_integer:
        {
            val = static_cast<ArithmeticType>(
                      *j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
            break;
        }
        case value_t::number_float:
        {
            val = static_cast<ArithmeticType>(
                      *j.template get_ptr<const typename BasicJsonType::number_float_t*>());
            break;
        }
        default:
        {
            JSON_THROW(
                std::domain_error("type must be number, but is " + j.type_name()));
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xef06
cmpb $0x5, %al
je 0xf1cc
movzbl %al, %eax
cmpl $0x7, %eax
je 0xf1be
cmpl $0x6, %eax
jne 0xf1e8
movq %r14, %rdi
callq 0xef0e
movsd (%rax), %xmm1
unpcklps 0x145a8(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x145b0(%rip), %xmm1    # 0x23760
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
jmp 0xf1d9
movq %r14, %rdi
callq 0xef26
movsd (%rax), %xmm0
jmp 0xf1d9
movq %r14, %rdi
callq 0xef1a
cvtsi2sdq (%rax), %xmm0
movsd %xmm0, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x41b0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x9d14
leaq 0x14be7(%rip), %rsi     # 0x23def
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x91e3
movb $0x1, %r15b
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x4410
xorl %r15d, %r15d
movq 0x2bd5a(%rip), %rsi     # 0x3af88
movq 0x2bd63(%rip), %rdx     # 0x3af98
movq %rbx, %rdi
callq 0x4560
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x41a0
jmp 0xf251
movq %rax, %r14
movb $0x1, %r15b
leaq -0x38(%rbp), %rdi
callq 0x41a0
jmp 0xf262
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0xf26f
movq %rbx, %rdi
callq 0x4270
movq %r14, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r12
movq %rdi, %r13
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x4300
leaq 0x28(%r13), %r14
movq %r14, %rdi
callq 0x4300
leaq 0x48(%r13), %r15
movq %r15, %rdi
callq 0x11472
movq %r12, %rdi
callq 0x53ae
movq %rax, %rdi
callq 0x11312
movl %eax, (%r13)
movq %r12, %rdi
callq 0x53ae
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x1131a
leaq -0x48(%rbp), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4420
movq %r13, %rdi
callq 0x41a0
movq %r12, %rdi
callq 0x53ae
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x11336
movq %r14, %rdi
movq %r13, %rsi
callq 0x4420
movq %r13, %rdi
callq 0x41a0
movq %r12, %rdi
callq 0x53ae
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x11352
leaq -0x48(%rbp), %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1150a
movq %rbx, %rdi
callq 0x10370
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x112ef
jmp 0x112ef
movq %rax, %r12
movq %r15, %rdi
callq 0x10370
movq %r14, %rdi
callq 0x41a0
movq %rbx, %rdi
callq 0x41a0
movq %r12, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm1, -0x18(%rbp)
movl %esi, %ebx
movq %rdi, %r14
callq 0x41c0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x41c0
movsd %xmm0, -0x18(%rbp)
addq $0x48, %r14
movslq %ebx, %rsi
movq %r14, %rdi
callq 0x11522
movq %rax, %rdi
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x1c1da
movaps %xmm0, %xmm1
movsd 0x12be8(%rip), %xmm0    # 0x23fb0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O1/TBody[P]atomicpp/atomicpp/ExternalModules/json.hpp
// Function: void nlohmann::detail::from_json<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>, std::vector<std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>, std::allocator<std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>>>, 0>(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer> const&, std::vector<std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>, std::allocator<std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>>>&)
void from_json(const BasicJsonType& j, CompatibleArrayType& arr)
{
    if (j.is_null())
    {
        JSON_THROW(std::domain_error("type must be array, but is " + j.type_name()));
    }

    // when T == BasicJsonType, do not check if value_t is correct
    if (not std::is_same<typename CompatibleArrayType::value_type, BasicJsonType>::value)
    {
        if (not j.is_array())
        {
            JSON_THROW(std::domain_error("type must be array, but is " + j.type_name()));
        }
    }
    from_json_array_impl(j, arr, priority_tag<1> {});
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x9c3e
testb %al, %al
jne 0x11737
movq %r14, %rdi
callq 0xa7ba
testb %al, %al
je 0x1178e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11823
movl $0x10, %edi
callq 0x41b0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x9d14
leaq 0x12896(%rip), %rsi     # 0x23fed
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x91e3
movb $0x1, %r15b
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x4410
xorl %r15d, %r15d
movq 0x2980b(%rip), %rsi     # 0x3af88
movq 0x29814(%rip), %rdx     # 0x3af98
movq %rbx, %rdi
callq 0x4560
jmp 0x117e3
movl $0x10, %edi
callq 0x41b0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x9d14
leaq 0x1283f(%rip), %rsi     # 0x23fed
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x91e3
movb $0x1, %r15b
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x4410
xorl %r15d, %r15d
movq 0x297b4(%rip), %rsi     # 0x3af88
movq 0x297bd(%rip), %rdx     # 0x3af98
movq %rbx, %rdi
callq 0x4560
jmp 0x117e7
jmp 0x117f5
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x41a0
jmp 0x117fb
movq %rax, %r14
movb $0x1, %r15b
leaq -0x38(%rbp), %rdi
callq 0x41a0
jmp 0x1180e
jmp 0x11808
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x1181b
movq %rbx, %rdi
callq 0x4270
movq %r14, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O1/TBody[P]atomicpp/atomicpp/ExternalModules/json.hpp
// Function: decltype(fp0.reserve(std::declval<std::vector<std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>, std::allocator<std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>>>::size_type>()), (void)()) nlohmann::detail::from_json_array_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>, std::vector<std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>, std::allocator<std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>>>>(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer> const&, std::vector<std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>, std::allocator<std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>>>&, nlohmann::detail::priority_tag<1u>)
auto from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr, priority_tag<1>)
-> decltype(
    arr.reserve(std::declval<typename CompatibleArrayType::size_type>()),
    void())
{
    using std::begin;
    using std::end;

    arr.reserve(j.size());
    std::transform(
        j.begin(), j.end(), std::inserter(arr, end(arr)), [](const BasicJsonType & i)
    {
        // get<BasicJsonType>() returns *this, this won't call a from_json
        // method when value_type is BasicJsonType
        return i.template get<typename CompatibleArrayType::value_type>();
    });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x11960
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11898
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x11a40
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x11a58
movq %rbx, %rdi
callq 0x11a99
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11a70
movq %rdx, %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x11990
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop