LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x61d4
movq %rax, %rbx
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x6268
movq %rax, %r12
movq (%r13), %rdi
callq 0x3692
movq %rax, (%r13)
movb (%rax), %cl
movq %r15, %rdx
movb (%rdx), %sil
cmpb %cl, %sil
je 0x5a2f
incq %rdx
testb %sil, %sil
jne 0x5a1f
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3704
movslq 0x8(%rbp), %rax
addq %rax, (%r13)
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x6268
movq %rax, %r15
movq 0x28(%r14), %rdi
movl $0x28, %esi
callq 0x3ca4
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_O3/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 0x6268
movq %rax, %rbx
movq (%r15), %rdi
callq 0x3692
movq %rax, (%r15)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x3704
cmpl $0x0, 0xc(%r12)
jne 0x5b29
movq 0x8(%rsp), %rax
leaq 0x774a(%rip), %rcx      # 0xd228
cmpq (%rcx), %rax
jne 0x5b29
movslq 0x10(%rsp), %rax
addq %rax, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x61d4
movq %rax, %r15
movq 0x28(%r14), %rdi
movl $0x20, %esi
callq 0x3ca4
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 0x2c4c(%rip), %rdi      # 0x877c
leaq 0x26c0(%rip), %rsi      # 0x81f7
leaq 0x2c68(%rip), %rcx      # 0x87a6
movl $0x1b5, %edx            # imm = 0x1B5
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3692
movq %rax, (%r14)
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x3704
cmpl $0x2, 0xc(%r15)
jne 0x5be3
movslq 0x8(%rsp), %rax
addq %rax, (%r14)
movq (%rsp), %r14
jmp 0x5be6
xorl %r14d, %r14d
movq 0x28(%rbx), %rdi
movl $0x18, %esi
callq 0x3ca4
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_O3/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 0x3692
movq %rax, (%r14)
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x3704
cmpl $0x2, 0xc(%r15)
jne 0x5c4d
movslq 0x8(%rsp), %rax
addq %rax, (%r14)
movq (%rsp), %r14
jmp 0x5c50
xorl %r14d, %r14d
movq 0x28(%rbx), %rdi
movl $0x18, %esi
callq 0x3ca4
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_O3/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 0x60d7
movq 0x28(%r15), %rdi
movl $0x20, %esi
callq 0x3ca4
movq %rax, %r14
movq $0x0, (%rax)
movl $0xe, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq (%rbx), %rdi
callq 0x3692
movq %rax, (%rbx)
cmpb $0x7b, (%rax)
jne 0x611f
incq %rax
movq %rax, (%rbx)
leaq 0x247c(%rip), %rcx      # 0x8570
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x356c
movq (%rbx), %rax
cmpb $0x7d, (%rax)
jne 0x613e
incq %rax
movq %rax, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x23b3(%rip), %rdi      # 0x84d9
leaq 0x20ca(%rip), %rsi      # 0x81f7
leaq 0x23b1(%rip), %rcx      # 0x84e5
movl $0x32f, %edx            # imm = 0x32F
callq 0x2100
leaq 0x242e(%rip), %rdi      # 0x8573
leaq 0x20ab(%rip), %rsi      # 0x81f7
leaq 0x2392(%rip), %rcx      # 0x84e5
movl $0x332, %edx            # imm = 0x332
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3692
movq %rax, (%rbx)
cmpb $0x28, (%rax)
jne 0x622a
incq %rax
movq %rax, (%rbx)
leaq 0x1f15(%rip), %rdx      # 0x8110
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4484
movq %rax, %r14
movq (%rbx), %rdi
callq 0x3692
movq %rax, (%rbx)
cmpb $0x29, (%rax)
jne 0x6249
incq %rax
movq %rax, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x227e(%rip), %rdi      # 0x84af
leaq 0x1fbf(%rip), %rsi      # 0x81f7
leaq 0x24c1(%rip), %rcx      # 0x8700
movl $0x352, %edx            # imm = 0x352
callq 0x2100
leaq 0x227d(%rip), %rdi      # 0x84cd
leaq 0x1fa0(%rip), %rsi      # 0x81f7
leaq 0x24a2(%rip), %rcx      # 0x8700
movl $0x356, %edx            # imm = 0x356
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3334
movq (%r14), %rax
cmpb $0x28, (%rax)
jne 0x65ac
incq %rax
movq %rax, (%r14)
movq 0x28(%rbx), %rdi
movl $0x28, %esi
callq 0x3ca4
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 0x3692
movq %rax, (%r14)
cmpb $0x29, (%rax)
je 0x6550
leaq 0x28(%rbx), %r12
leaq 0x257b(%rip), %r13      # 0x8a7f
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x4484
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x67c8
movq (%r14), %rdi
callq 0x3692
movq %rax, (%r14)
movzbl (%rax), %ecx
cmpl $0x2c, %ecx
jne 0x654b
incq %rax
movq %rax, (%r14)
movq %rax, %rdi
callq 0x3692
movq %rax, (%r14)
cmpb $0x29, (%rax)
jne 0x6504
jmp 0x6550
cmpl $0x29, %ecx
jne 0x658d
incq %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq -0x18(%rax), %rdi
movq -0x10(%rax), %rcx
cmpq %rdi, %rcx
jne 0x65cb
leaq -0x18(%rax), %rdx
movq %rdx, 0x8(%rbx)
testq %rcx, %rcx
je 0x6580
movq -0x8(%rax), %rsi
subq %rdi, %rsi
callq 0x2190
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2514(%rip), %rdi      # 0x8aa8
leaq 0x1c5c(%rip), %rsi      # 0x81f7
leaq 0x245c(%rip), %rcx      # 0x89fe
movl $0x22c, %edx            # imm = 0x22C
callq 0x2100
leaq 0x1efc(%rip), %rdi      # 0x84af
leaq 0x1c3d(%rip), %rsi      # 0x81f7
leaq 0x243d(%rip), %rcx      # 0x89fe
movl $0x21f, %edx            # imm = 0x21F
callq 0x2100
leaq 0x24b0(%rip), %rdi      # 0x8a82
leaq 0x1c1e(%rip), %rsi      # 0x81f7
leaq 0x241e(%rip), %rcx      # 0x89fe
movl $0x22f, %edx            # imm = 0x22F
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3334
movq (%r14), %rax
cmpb $0x5b, (%rax)
jne 0x66b8
incq %rax
movq %rax, (%r14)
leaq 0x2952(%rip), %rdx      # 0x8f88
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4484
movq %rax, %r13
movq 0x28(%rbx), %rdi
movl $0x20, %esi
callq 0x3ca4
movq %rax, %r12
movq $0x0, (%rax)
movl $0xc, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r13, 0x18(%rax)
movq (%r14), %rdi
callq 0x3692
movq %rax, (%r14)
cmpb $0x5d, (%rax)
jne 0x66d7
incq %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq -0x18(%rax), %rdi
movq -0x10(%rax), %rcx
cmpq %rdi, %rcx
jne 0x66f6
leaq -0x18(%rax), %rdx
movq %rdx, 0x8(%rbx)
testq %rcx, %rcx
je 0x66ab
movq -0x8(%rax), %rsi
subq %rdi, %rsi
callq 0x2190
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x23eb(%rip), %rdi      # 0x8aaa
leaq 0x1b31(%rip), %rsi      # 0x81f7
leaq 0x23e9(%rip), %rcx      # 0x8ab6
movl $0x236, %edx            # imm = 0x236
callq 0x2100
leaq 0x245d(%rip), %rdi      # 0x8b3b
leaq 0x1b12(%rip), %rsi      # 0x81f7
leaq 0x23ca(%rip), %rcx      # 0x8ab6
movl $0x23a, %edx            # imm = 0x23A
callq 0x2100
leaq 0x2385(%rip), %rdi      # 0x8a82
leaq 0x1af3(%rip), %rsi      # 0x81f7
leaq 0x23ab(%rip), %rcx      # 0x8ab6
movl $0x23c, %edx            # imm = 0x23C
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
movq %rsi, %rdi
callq 0x2090
incl %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x2160
leaq 0x8(%rsp), %r14
movq %rsp, %r15
movq %r12, %rdi
movl $0x20, %esi
callq 0x2060
movq %rax, %r13
testq %rax, %rax
je 0x6cdc
movb $0x0, (%r13)
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x3e96
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x716e
leaq 0x1(%r13), %r12
testq %r13, %r13
jne 0x6cc2
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x6d17
movq %rax, %r14
movq %rbx, %rdi
callq 0x73f0
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x5d8c
testb %al, %al
je 0x5cbb
leaq -0x240(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x4500
movq %r14, %rdi
xorl %esi, %esi
callq 0x5dc4
movq %r15, %rdi
movq %r14, %rsi
callq 0x5dea
leaq -0x240(%rbp), %rdi
callq 0x40e0
movq %r14, %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 %rbx, %rsi
callq 0x4320
leaq 0x1c4c6(%rip), %rsi     # 0x221b2
movq %rax, %rdi
callq 0x4360
movl $0x10, %edi
callq 0x41b0
movq %rax, %r14
leaq -0x38(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x4350
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x4510
movq 0x352cc(%rip), %rsi     # 0x3aff0
movq 0x35275(%rip), %rdx     # 0x3afa0
movq %r14, %rdi
callq 0x4560
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x41a0
jmp 0x5d5f
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x41a0
jmp 0x5d52
movq %rax, %rbx
movq %r14, %rdi
callq 0x4270
jmp 0x5d5f
movq %rax, %rbx
leaq -0x240(%rbp), %rdi
callq 0x4280
jmp 0x5d84
movq %rax, %rbx
movq %r14, %rdi
callq 0x5e92
leaq -0x240(%rbp), %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/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()
~basic_json()
    {
        assert_invariant();

        switch (m_type)
        {
            case value_t::object:
            {
                AllocatorType<object_t> alloc;
                alloc.destroy(m_value.object);
                alloc.deallocate(m_value.object, 1);
                break;
            }

            case value_t::array:
            {
                AllocatorType<array_t> alloc;
                alloc.destroy(m_value.array);
                alloc.deallocate(m_value.array, 1);
                break;
            }

            case value_t::string:
            {
                AllocatorType<string_t> alloc;
                alloc.destroy(m_value.string);
                alloc.deallocate(m_value.string, 1);
                break;
            }

            default:
            {
                // all other types need no specific destructor
                break;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x5fe2
movzbl (%rbx), %eax
cmpl $0x3, %eax
je 0x5f21
cmpl $0x2, %eax
je 0x5eee
cmpl $0x1, %eax
jne 0x5f52
leaq -0x13(%rbp), %r14
movq %r14, %rdi
callq 0x6086
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x6090
movq 0x8(%rbx), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x609e
movq %r14, %rdi
callq 0x60ac
jmp 0x5f52
leaq -0x12(%rbp), %r14
movq %r14, %rdi
callq 0x60b2
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x60bc
movq 0x8(%rbx), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x60ca
movq %r14, %rdi
callq 0x60d8
jmp 0x5f52
leaq -0x11(%rbp), %r14
movq %r14, %rdi
callq 0x60de
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x60e8
movq 0x8(%rbx), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x60f6
movq %r14, %rdi
callq 0x6104
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7162
movq %r15, %rdi
xorl %esi, %esi
callq 0x71da
movq %rbx, %rdi
callq 0x4240
cmpq $0x3, %rax
jb 0x7155
leaq -0x40(%rbp), %rdi
movl $0x3, %ecx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x43a0
leaq 0x1b775(%rip), %rsi     # 0x2287e
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x7449
movl %eax, %r15d
movq %r14, %rdi
callq 0x41a0
testb %r15b, %r15b
je 0x7155
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 0x1b6fb(%rip), %rsi     # 0x22871
movq %rax, %rdi
callq 0x45e0
movq 0x33e53(%rip), %rsi     # 0x3afd8
movq 0x33e34(%rip), %rdx     # 0x3afc0
movq %r12, %rdi
callq 0x4560
jmp 0x71a3
movq %rax, %r15
movq %r12, %rdi
callq 0x4270
jmp 0x71a6
movq %rax, %r15
movq %r14, %rdi
callq 0x41a0
movq %rbx, %rdi
callq 0x41a0
movq %r15, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc0b4
movq %rbx, %rdi
callq 0xcda0
leaq -0x40(%rbp), %r14
movq %rax, (%r14)
movq %rbx, %rdi
callq 0xcdaa
leaq -0x38(%rbp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0xcdb4
testb %al, %al
je 0xc044
addq $0x88, -0x30(%rbp)
leaq -0x90(%rbp), %r15
leaq -0x70(%rbp), %r12
leaq -0x50(%rbp), %r13
movq %r14, %rdi
callq 0xcdc4
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 0x10f4c
movq %r13, %rdi
movq %rbx, %rsi
callq 0xd080
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0xd08a
movq %rax, %rdi
movq %r13, %rsi
callq 0xd148
movq %r13, %rdi
callq 0x53b8
movq %r12, %rdi
callq 0x41a0
movq %r15, %rdi
callq 0x41a0
movq %r14, %rdi
callq 0xce1c
movq %r14, %rdi
leaq -0x38(%rbp), %rsi
callq 0xcdb4
testb %al, %al
jne 0xbfb1
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 0xc09f
movq %rax, %r14
jmp 0xc093
movq %rax, %r14
movq %rbx, %rdi
callq 0x4330
jmp 0xc08a
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x53b8
jmp 0xc08a
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_O3/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 0xe73a
movq (%rbx), %rax
testq %rax, %rax
je 0xe6a8
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0xe670
cmpl $0x1, %eax
jne 0xe685
leaq -0x18(%rbp), %rbx
movq %rbx, %rdi
callq 0xe76c
movq (%rbx), %rax
movq %rax, (%r14)
jmp 0xe69f
leaq -0x18(%rbp), %r14
movq %r14, %rdi
callq 0xe77a
movq (%r14), %rax
movq %rax, 0x10(%rbx)
jmp 0xe69f
leaq -0x18(%rbp), %r14
movq $0x0, (%r14)
movq %r14, %rdi
callq 0xe788
movq (%r14), %rax
movq %rax, 0x18(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x15261(%rip), %rdi     # 0x23910
leaq 0x13b3f(%rip), %rsi     # 0x221f5
leaq 0x15267(%rip), %rcx     # 0x23924
movl $0x22ab, %edx           # imm = 0x22AB
callq 0x4210
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xee9a
movzbl %al, %eax
addl $-0x4, %eax
cmpl $0x3, %eax
ja 0xee07
leaq 0x14972(%rip), %rcx     # 0x23734
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
callq 0xeec6
movzbl (%rax), %eax
jmp 0xedfa
movq %r14, %rdi
callq 0xeea2
jmp 0xedf8
movq %r14, %rdi
callq 0xeeba
cvttsd2si (%rax), %eax
jmp 0xedfa
movq %r14, %rdi
callq 0xeeae
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 0x9c50
leaq 0x14fc8(%rip), %rsi     # 0x23def
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x90fd
movb $0x1, %r15b
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x4410
xorl %r15d, %r15d
movq 0x2c13b(%rip), %rsi     # 0x3af88
movq 0x2c144(%rip), %rdx     # 0x3af98
movq %rbx, %rdi
callq 0x4560
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x41a0
leaq -0x38(%rbp), %rdi
callq 0x41a0
testb %r15b, %r15b
jne 0xee89
jmp 0xee91
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x41a0
jmp 0xee89
movq %rax, %r14
movq %rbx, %rdi
callq 0x4270
movq %r14, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xee9a
cmpb $0x5, %al
je 0xf164
movzbl %al, %eax
cmpl $0x7, %eax
je 0xf156
cmpl $0x6, %eax
jne 0xf180
movq %r14, %rdi
callq 0xeea2
movsd (%rax), %xmm1
unpcklps 0x14610(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x14618(%rip), %xmm1    # 0x23760
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
jmp 0xf171
movq %r14, %rdi
callq 0xeeba
movsd (%rax), %xmm0
jmp 0xf171
movq %r14, %rdi
callq 0xeeae
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 0x9c50
leaq 0x14c4f(%rip), %rsi     # 0x23def
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x90fd
movb $0x1, %r15b
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x4410
xorl %r15d, %r15d
movq 0x2bdc2(%rip), %rsi     # 0x3af88
movq 0x2bdcb(%rip), %rdx     # 0x3af98
movq %rbx, %rdi
callq 0x4560
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x41a0
leaq -0x38(%rbp), %rdi
callq 0x41a0
testb %r15b, %r15b
jne 0xf202
jmp 0xf20a
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x41a0
jmp 0xf202
movq %rax, %r14
movq %rbx, %rdi
callq 0x4270
movq %r14, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11416
movq %r12, %rdi
callq 0x53ae
movq %rax, %rdi
callq 0x112b6
movl %eax, (%r13)
movq %r12, %rdi
callq 0x53ae
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x112be
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 0x112da
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 0x112f6
leaq -0x48(%rbp), %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x114ae
movq %rbx, %rdi
callq 0x1030a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11293
jmp 0x11293
movq %rax, %r12
movq %r15, %rdi
callq 0x1030a
movq %r14, %rdi
callq 0x41a0
movq %rbx, %rdi
callq 0x41a0
movq %r12, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x114c6
movq %rax, %rdi
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x1c116
movaps %xmm0, %xmm1
movsd 0x12c44(%rip), %xmm0    # 0x23fb0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9b7a
testb %al, %al
jne 0x116db
movq %r14, %rdi
callq 0xa700
testb %al, %al
je 0x11732
movq %r14, %rdi
movq %rbx, %rsi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x117ca
movl $0x10, %edi
callq 0x41b0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x9c50
leaq 0x128f2(%rip), %rsi     # 0x23fed
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x90fd
movb $0x1, %r15b
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x4410
xorl %r15d, %r15d
movq 0x29867(%rip), %rsi     # 0x3af88
movq 0x29870(%rip), %rdx     # 0x3af98
movq %rbx, %rdi
callq 0x4560
jmp 0x11787
movl $0x10, %edi
callq 0x41b0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x9c50
leaq 0x1289b(%rip), %rsi     # 0x23fed
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x90fd
movb $0x1, %r15b
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x4410
xorl %r15d, %r15d
movq 0x29810(%rip), %rsi     # 0x3af88
movq 0x29819(%rip), %rdx     # 0x3af98
movq %rbx, %rdi
callq 0x4560
jmp 0x1178b
jmp 0x117a7
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x41a0
leaq -0x38(%rbp), %rdi
callq 0x41a0
testb %r15b, %r15b
jne 0x117ba
jmp 0x117c2
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x41a0
jmp 0x117ba
jmp 0x117b7
movq %rax, %r14
movq %rbx, %rdi
callq 0x4270
movq %r14, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11906
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1183e
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x119f2
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x11a0a
movq %rbx, %rdi
callq 0x11a4b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11a22
movq %rdx, %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x11936
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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> const>::operator++()
iter_impl& operator++()
        {
            assert(m_object != nullptr);

            switch (m_object->m_type)
            {
                case basic_json::value_t::object:
                {
                    std::advance(m_it.object_iterator, 1);
                    break;
                }

                case basic_json::value_t::array:
                {
                    std::advance(m_it.array_iterator, 1);
                    break;
                }

                default:
                {
                    ++m_it.primitive_iterator;
                    break;
                }
            }

            return *this;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x11f59
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x11f36
cmpl $0x1, %eax
jne 0x11f46
leaq 0x8(%rbx), %rdi
movl $0x1, %esi
callq 0x140a3
jmp 0x11f4f
leaq 0x10(%rbx), %rdi
movl $0x1, %esi
callq 0x140c4
jmp 0x11f4f
leaq 0x18(%rbx), %rdi
callq 0x140e6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x119b0(%rip), %rdi     # 0x23910
leaq 0x1028e(%rip), %rsi     # 0x221f5
leaq 0x12454(%rip), %rcx     # 0x243c2
movl $0x2391, %edx           # imm = 0x2391
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O3/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> const>::set_begin()
void set_begin() noexcept
        {
            assert(m_object != nullptr);

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

                case basic_json::value_t::array:
                {
                    m_it.array_iterator = m_object->m_value.array->begin();
                    break;
                }

                case basic_json::value_t::null:
                {
                    // set to end so begin()==end() is true: null is empty
                    m_it.primitive_iterator.set_end();
                    break;
                }

                default:
                {
                    m_it.primitive_iterator.set_begin();
                    break;
                }
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x14275
movq %rdi, %rbx
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x14251
cmpl $0x2, %ecx
je 0x1423d
cmpl $0x1, %ecx
jne 0x14263
movq 0x8(%rax), %rdi
callq 0x14294
movq %rax, 0x8(%rbx)
jmp 0x1424a
movq 0x8(%rax), %rdi
callq 0xa962
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x18, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe7a8
addq $0x18, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1429e
leaq 0xf694(%rip), %rdi      # 0x23910
leaq 0xdf72(%rip), %rsi      # 0x221f5
leaq 0x10448(%rip), %rcx     # 0x246d2
movl $0x22f9, %edx           # imm = 0x22F9
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O3/TBody[P]atomicpp/atomicpp/Spline/BilinearSpline.cpp
// Function: atomicpp::BilinearSpline::BilinearSpline(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
BilinearSpline::BilinearSpline(
	std::vector<double>& _x_values,
	std::vector<double>& _y_values,
	std::vector< std::vector<double> > & _z_values
	){
	x_values = _x_values;
	y_values = _y_values;
	z_values = _z_values;

	//Doesn't require initialisation
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, -0x30(%rbp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
callq 0x12776
leaq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x12776
leaq 0x30(%rbx), %r12
movq %r12, %rdi
callq 0x12072
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15982
movq %r14, %rdi
movq %r13, %rsi
callq 0x15982
movq %r12, %rdi
movq -0x30(%rbp), %rsi
callq 0x15ae8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r12, %rdi
callq 0x10424
movq %r14, %rdi
callq 0x53c6
movq %rbx, %rdi
callq 0x53c6
movq %r15, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/TBody[P]atomicpp/atomicpp/Spline/BilinearSpline.cpp
// Function: atomicpp::BilinearSpline::call0D_shared(std::pair<int, double>, std::pair<int, double>)
double BilinearSpline::call0D_shared(const std::pair<int, double> x_interp, const std::pair<int, double> y_interp){

	int low_x = x_interp.first;
	int low_y = y_interp.first;

	double x = x_interp.second;
	double y = y_interp.second;

	// // Construct the simple interpolation grid
	// // Find weightings based on linear distance
	// // w01 ------ w11    y
	// //  | \     / |      |
	// //  |  w(x,y) |    --/--x
	// //  | /     \ |      |
	// // w00 ------ w10

	double eval_coeff =
	 (z_values[low_x+0][low_y+0]*(1-y) + z_values[low_x+0][low_y+1]*y)*(1-x)
	+(z_values[low_x+1][low_y+0]*(1-y) + z_values[low_x+1][low_y+1]*y)*x;

	return eval_coeff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movsd %xmm1, -0x38(%rbp)
movl %edx, %r14d
movsd %xmm0, -0x40(%rbp)
movq %rdi, %rbx
addq $0x30, %rbx
movslq %esi, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15c9c
movslq %r14d, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x539c
movsd 0xc83b(%rip), %xmm0     # 0x22008
subsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd (%rax), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15c9c
leal 0x1(%r14), %ecx
movslq %ecx, %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x539c
movsd (%rax), %xmm0
mulsd -0x38(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd 0xc7f1(%rip), %xmm1     # 0x22008
subsd -0x40(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
incl %r15d
movslq %r15d, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15c9c
movq %rax, %rdi
movq %r14, %rsi
callq 0x539c
movsd -0x30(%rbp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15c9c
movq %rax, %rdi
movq %r12, %rsi
callq 0x539c
movsd -0x38(%rbp), %xmm0
mulsd (%rax), %xmm0
addsd -0x30(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq