LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/simh[P]simtools/extracters/rawtap/rawtap.c
// Function: usage
void usage(void)
{
  fprintf(stderr, "Usage: rawtap -cae container [-r len] [...]\n\n");
  fprintf(stderr,
          "   Create new container and append file(s):\n");
  fprintf(stderr,
          "     rawtap -c container [-r len] file ...\n\n");
  fprintf(stderr,
          "   Append file(s) to an existing container:\n");
  fprintf(stderr,
          "     rawtap -a container [-r len] file ...\n\n");
  fprintf(stderr,
          "   Extract files from container(s):\n");
  fprintf(stderr,
          "     rawtap -e container ...\n");
  fprintf(stderr,
          "       - Extracted files will be name 00001.dat, 00002.dat etc\n\n");
  fprintf(stderr,
          "\nSwitches:\n\n");
  fprintf(stderr,
          "-r len     - Specify max tape record size (%u <= len <= %u)\n",
          MINRECLEN, MAXRECLEN);
  fprintf(stderr,
          "             The record size applies to all following files and\n");
  fprintf(stderr,
          "             there may be several \"-r nnn\" present on the command line.\n");
  fprintf(stderr,
          "             The default record size is 10240 bytes.\n\n");
  exit(1);
}

// Assembly:
pushq %rbx
movq 0x2ca4(%rip), %rbx      # 0x3ff8
movq (%rbx), %rcx
leaq 0xca6(%rip), %rdi       # 0x2004
movl $0x2d, %esi
movl $0x1, %edx
callq 0x1120
movq (%rbx), %rcx
leaq 0xcbb(%rip), %rdi       # 0x2032
movl $0x2c, %esi
movl $0x1, %edx
callq 0x1120
movq (%rbx), %rcx
leaq 0xccf(%rip), %rdi       # 0x205f
movl $0x2c, %esi
movl $0x1, %edx
callq 0x1120
movq (%rbx), %rcx
leaq 0xce3(%rip), %rdi       # 0x208c
movl $0x2c, %esi
movl $0x1, %edx
callq 0x1120
movq (%rbx), %rcx
leaq 0xcf7(%rip), %rdi       # 0x20b9
movl $0x2c, %esi
movl $0x1, %edx
callq 0x1120
movq (%rbx), %rcx
leaq 0xd0b(%rip), %rdi       # 0x20e6
movl $0x24, %esi
movl $0x1, %edx
callq 0x1120
movq (%rbx), %rcx
leaq 0xd17(%rip), %rdi       # 0x210b
movl $0x1d, %esi
movl $0x1, %edx
callq 0x1120
movq (%rbx), %rcx
leaq 0xd1c(%rip), %rdi       # 0x2129
movl $0x40, %esi
movl $0x1, %edx
callq 0x1120
movq (%rbx), %rcx
leaq 0xd44(%rip), %rdi       # 0x216a
movl $0xc, %esi
movl $0x1, %edx
callq 0x1120
movq (%rbx), %rdi
leaq 0xd38(%rip), %rsi       # 0x2177
movl $0x1, %edx
movl $0x10000, %ecx          # imm = 0x10000
xorl %eax, %eax
callq 0x1090
movq (%rbx), %rcx
leaq 0xd5a(%rip), %rdi       # 0x21b4
movl $0x40, %esi
movl $0x1, %edx
callq 0x1120
movq (%rbx), %rcx
leaq 0xd82(%rip), %rdi       # 0x21f5
movl $0x48, %esi
movl $0x1, %edx
callq 0x1120
movq (%rbx), %rcx
leaq 0xdb2(%rip), %rdi       # 0x223e
movl $0x36, %esi
movl $0x1, %edx
callq 0x1120
movl $0x1, %edi
callq 0x1110
// File: /workspace/github_c_makefile_star2_O3/simh[P]simtools/extracters/rawtap/tapeio.c
// Function: OpenTapeForRead
int OpenTapeForRead(
  char *name
)
{
  if ((tfile = fopen(name, "rb")) != NULL) {
    int status;

    status = verifyFormat();
    rewind(tfile);
    if ((status != TIO_SUCCESS) && (status != TIO_ERROR))
      CloseTape();
    return status;
  }
  return TIO_OPENFAIL;
}

// Assembly:
pushq %rbx
leaq 0x9fd(%rip), %rsi       # 0x2285
callq 0x10f0
movq %rax, 0x1284c(%rip)     # 0x140e0
testq %rax, %rax
je 0x18d3
callq 0x18dc
movl %eax, %ebx
movq 0x12839(%rip), %rdi     # 0x140e0
callq 0x1080
movl %ebx, %eax
decl %eax
cmpl $-0x3, %eax
ja 0x18d8
movq 0x12824(%rip), %rdi     # 0x140e0
testq %rdi, %rdi
je 0x18c6
callq 0x1070
movq $0x0, 0x1280f(%rip) # 0x140e0
jmp 0x18d8
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/marcespie[P]random_run/rr.C
// Function: add_regex(std::vector<std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>>, std::allocator<std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>>>>&, char const*, options const&)
void
add_regex(vector<regex>& v, const char* arg, const options& o)
{
	try {
		using namespace std::regex_constants;
		auto flags = o.eregex ? extended : basic;
		if (o.nocase)
			flags |= icase;
		v.emplace_back(arg, flags);
	} catch (regex_error& e) {
		cerr << "Bad regex " << arg << ": " << e.what() << "\n";
		usage();
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movzbl 0x8(%rdx), %eax
shll $0x5, %eax
addl $0x20, %eax
movl %eax, 0xc(%rsp)
cmpb $0x1, 0x7(%rdx)
jne 0x5d98
orl $0x1, %eax
movl %eax, 0xc(%rsp)
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x6d0c
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x5e3b
movq %rbx, %rdi
callq 0x5160
movq %rax, %rbx
movq 0x1c21b(%rip), %rdi     # 0x21fe8
leaq 0x1249c(%rip), %rsi     # 0x18270
movl $0xa, %edx
callq 0x5410
movq 0x10(%rsp), %rsi
movq 0x1c1fe(%rip), %rdi     # 0x21fe8
callq 0x5370
movq %rax, %r14
leaq 0x123f4(%rip), %rsi     # 0x181ed
movl $0x2, %edx
movq %rax, %rdi
callq 0x5410
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x5370
leaq 0x12658(%rip), %rsi     # 0x18479
movl $0x1, %edx
movq %rax, %rdi
callq 0x5410
callq 0x5ccc
movq %rax, %rbx
callq 0x5530
movq %rbx, %rdi
callq 0x5590
movq %rax, %rdi
callq 0x6d50
// File: /workspace/github_c_makefile_star2_O3/marcespie[P]random_run/rr.C
// Function: compute_maxsize(char**, unsigned long)
size_t
compute_maxsize(char* envp[], size_t margin)
{
	// maxargs for the shell, - path lookup for argv[0]
	auto maxsize = static_cast<size_t>(
	    sysconf(_SC_ARG_MAX) - pathconf("/", _PC_PATH_MAX));

	// need to take envp into account
	for (int i = 0; envp[i] != NULL; ++i)
		maxsize -= strlen(envp[i])+1;
	return maxsize - margin;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
xorl %edi, %edi
callq 0x5250
movq %rax, %r14
leaq 0x12414(%rip), %rdi     # 0x1827b
movl $0x4, %esi
callq 0x5510
subq %rax, %r14
movq (%r15), %rdi
testq %rdi, %rdi
je 0x5e97
addq $0x8, %r15
callq 0x5180
notq %rax
addq %rax, %r14
movq (%r15), %rdi
addq $0x8, %r15
testq %rdi, %rdi
jne 0x5e80
subq %rbx, %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/marcespie[P]random_run/rr.C
// Function: add_lines_from(std::vector<std::filesystem::__cxx11::path, std::allocator<std::filesystem::__cxx11::path>>&, std::istream&, char const*)
const char *fname)
{
	for (string line; getline(f, line); )
		r.emplace_back(line);
	if (f.bad()) {
		auto e = strerror(errno);
		cerr << "Error while reading " << fname << ": " << e << "\n";
		exit(1);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq %rsp, %r12
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5360
movsbl %al, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x55d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x61bb
movq %r15, %rdi
movq %r12, %rsi
callq 0x7068
jmp 0x617e
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x61d1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5390
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x1, 0x20(%r14,%rax)
jne 0x61ee
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x5060
movl (%rax), %edi
callq 0x5110
movq %rax, %r14
movq 0x1bde4(%rip), %rdi     # 0x21fe8
leaq 0x1208f(%rip), %rsi     # 0x1829a
callq 0x5370
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5370
leaq 0x11fcb(%rip), %rsi     # 0x181ed
movq %rax, %rdi
callq 0x5370
movq %rax, %rdi
movq %r14, %rsi
callq 0x5370
leaq 0x1223d(%rip), %rsi     # 0x18479
movq %rax, %rdi
callq 0x5370
movl $0x1, %edi
callq 0x5450
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x6267
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x5590
// File: /workspace/github_c_makefile_star2_O3/marcespie[P]random_run/rr.C
// Function: add_lines(std::vector<std::filesystem::__cxx11::path, std::allocator<std::filesystem::__cxx11::path>>&, char const*)
void
add_lines(vector<path>& r, const char* fname)
{
	if (strcmp(fname, "-") == 0) {
		add_lines_from(r, cin, fname);
	} else {
		if (is_directory(fname)) {
			cerr << "Can't read directory: " << fname << "\n";
			exit(1);
		}
		ifstream f;
		f.open(fname);
		if (!f.good()) {
			auto e = strerror(errno);
			cerr << "Failed to open " << fname << ": " << e << "\n";
			exit(1);
		}
		add_lines_from(r, f, fname);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
cmpb $0x2d, (%rsi)
jne 0x6293
movq %rsi, %rdx
cmpb $0x0, 0x1(%rsi)
je 0x631b
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl $0x2, %edx
callq 0x70aa
movq %r14, %rdi
callq 0x5150
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x7132
cmpb $0x2, %r14b
je 0x6334
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x5400
movq 0x8(%rsp), %rsi
movq %r14, %rdi
movl $0x8, %edx
callq 0x5220
movq 0x10(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x30(%rsp,%rax)
jne 0x636d
movq 0x8(%rsp), %rdx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x614f
leaq 0x10(%rsp), %rdi
callq 0x5090
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
retq
movq 0x1bcae(%rip), %rsi     # 0x21fd0
movq %rbx, %rdi
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
jmp 0x614f
movq 0x1bcad(%rip), %rdi     # 0x21fe8
leaq 0x11f6d(%rip), %rsi     # 0x182af
callq 0x5370
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x5370
leaq 0x1211e(%rip), %rsi     # 0x18479
movq %rax, %rdi
callq 0x5370
movl $0x1, %edi
callq 0x5450
callq 0x5060
movl (%rax), %edi
callq 0x5110
movq %rax, %rbx
movq 0x1bc65(%rip), %rdi     # 0x21fe8
leaq 0x11f3c(%rip), %rsi     # 0x182c6
movl $0xf, %edx
callq 0x5410
movq 0x8(%rsp), %rsi
movq 0x1bc48(%rip), %rdi     # 0x21fe8
callq 0x5370
movq %rax, %r14
leaq 0x11e3e(%rip), %rsi     # 0x181ed
movl $0x2, %edx
movq %rax, %rdi
callq 0x5410
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5370
leaq 0x120ab(%rip), %rsi     # 0x18479
movq %rax, %rdi
callq 0x5370
jmp 0x6363
jmp 0x63e9
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7132
jmp 0x63f6
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5090
movq %rbx, %rdi
callq 0x5590
// File: /workspace/github_c_makefile_star2_O3/marcespie[P]random_run/rr.C
// Function: exec(std::vector<char const*, std::allocator<char const*>> const&)
void
exec(const vector<const char*>& v)
{
	// XXX paths are essentially "movable" strings, so they're const
	// let's type-pune the const, we won't ever return anyway
	execvp(v[0], const_cast<char**>(v.data()));
	string k = "can't exec ";
	k += v[0];
	system_error(k.c_str());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rsi
movq (%rsi), %rdi
callq 0x52c0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x11e0d(%rip), %rsi     # 0x182d6
leaq 0x11e11(%rip), %rdx     # 0x182e1
movq %rsp, %r14
movq %r14, %rdi
callq 0x8006
movq (%rbx), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x5630
movq (%rsp), %rdi
callq 0x5d08
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x650b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x5590
// File: /workspace/github_c_makefile_star2_O3/marcespie[P]random_run/rr.C
// Function: deal_with_child(int, bool)
void
deal_with_child(int pid, bool exitonerror)
{
	int r;
	auto e = waitpid(pid, &r, 0);
	if (e == -1)
		system_error("waitpid");
	if (e != pid) {
		cerr << "waitpid exited with " << e << 
		    "(shouldn't happen)\n";
		exit(1);
	}
		
	if (WIFEXITED(r)) {
		auto s = WEXITSTATUS(r);
		if (s != 0) {
			cerr << "Command exited with "<< s << "\n";
			if (exitonerror)
				exit(s);
		}
	} else {
		auto s = WTERMSIG(r);
		cerr << "Command exited on signal #"<< s << "\n";
		if (exitonerror) {
			kill(getpid(), s);
			// in case we didn't die
			exit(1);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %r14d
leaq 0x4(%rsp), %rsi
xorl %edx, %edx
callq 0x52f0
cmpl $-0x1, %eax
je 0x65f1
movl %eax, %ebp
cmpl %r14d, %eax
jne 0x65fd
movl 0x4(%rsp), %ebp
movl %ebp, %r14d
andl $0x7f, %r14d
je 0x659e
movq 0x1ba95(%rip), %r15     # 0x21fe8
leaq 0x11dce(%rip), %rsi     # 0x18328
movl $0x1a, %edx
movq %r15, %rdi
callq 0x5410
movq %r15, %rdi
movl %r14d, %esi
callq 0x5580
leaq 0x11f00(%rip), %rsi     # 0x18479
movl $0x1, %edx
movq %rax, %rdi
callq 0x5410
testb %bl, %bl
je 0x65e6
callq 0x54f0
movl %eax, %edi
movl %r14d, %esi
callq 0x54c0
jmp 0x6629
shrl $0x8, %ebp
andl $0xff, %ebp
je 0x65e6
movq 0x1ba38(%rip), %r14     # 0x21fe8
leaq 0x11d5c(%rip), %rsi     # 0x18313
movl $0x14, %edx
movq %r14, %rdi
callq 0x5410
movq %r14, %rdi
movl %ebp, %esi
callq 0x5580
leaq 0x11ea4(%rip), %rsi     # 0x18479
movl $0x1, %edx
movq %rax, %rdi
callq 0x5410
testb %bl, %bl
jne 0x6633
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11cea(%rip), %rdi     # 0x182e2
callq 0x5d08
movq 0x1b9e4(%rip), %rdi     # 0x21fe8
leaq 0x11cdf(%rip), %rsi     # 0x182ea
callq 0x5370
movq %rax, %rdi
movl %ebp, %esi
callq 0x5580
leaq 0x11cde(%rip), %rsi     # 0x182ff
movq %rax, %rdi
callq 0x5370
movl $0x1, %edi
callq 0x5450
movl %ebp, %edi
callq 0x5450
// File: /workspace/github_c_makefile_star2_O3/marcespie[P]random_run/rr.C
// Function: keep(char const*, options const&)
bool
keep(const char* s, const options& o)
{
	// notice the asymetry: we "exclude" anything
	if (any_match(s, o.exclude))
		return false;
	// BUT "only" doesn't kick in if it's not been mentioned
	return o.only.size() == 0 || any_match(s, o.only);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x50, %rsi
callq 0x63fe
testb %al, %al
je 0x6655
xorl %eax, %eax
jmp 0x6677
movq 0x70(%rbx), %rax
cmpq 0x68(%rbx), %rax
je 0x6675
addq $0x68, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x63fe
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/acorn128v2/opt/encrypt.c
// Function: acorn128_initialization_32bitversion
void acorn128_initialization_32bitversion(const unsigned char *key, const unsigned char *iv, unsigned long long *state)
{
        int i, j;
        unsigned int m;
        unsigned int ks=0, tem=0;

        //initialize the state to 0
        for (j = 0; j <= 6; j++) state[j] = 0;

        //run the cipher for 1792 steps
        for (j = 0;  j <= 3;  j++)
        {
            encrypt_32bits(state, ((unsigned int*)key)[j], &tem, &ks, 0xffffffff, 0xffffffff);
        }
        for (j = 4;  j <= 7;  j++)
        {
            encrypt_32bits(state, ((unsigned int*)iv)[j-4], &tem, &ks, 0xffffffff, 0xffffffff);
        }
        for (j = 8;  j <= 8; j++)
        {
            encrypt_32bits(state, ((unsigned int*)key)[j&3] ^ 1, &tem, &ks, 0xffffffff, 0xffffffff);
        }
        for (j = 9;  j <= 55; j++)
        {
            encrypt_32bits(state, ((unsigned int*)key)[j&3], &tem, &ks, 0xffffffff, 0xffffffff);
        }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x18(%rdx)
movq %rsi, %r15
movq %rdi, %r14
vmovups %ymm0, (%rdx)
xorl %ebp, %ebp
movq %rsp, %r12
leaq 0x4(%rsp), %r13
movl (%r14,%rbp,4), %esi
movq %rbx, %rdi
movq %r12, %rdx
movq %r13, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
vzeroupper
callq 0x10b0
incq %rbp
cmpq $0x4, %rbp
jne 0x1733
xorl %ebp, %ebp
movq %rsp, %r12
leaq 0x4(%rsp), %r13
movl (%r15,%rbp,4), %esi
movq %rbx, %rdi
movq %r12, %rdx
movq %r13, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
callq 0x10b0
incq %rbp
cmpq $0x4, %rbp
jne 0x1767
movl (%r14), %esi
xorl $0x1, %esi
movq %rsp, %r15
leaq 0x4(%rsp), %r12
movq %rbx, %rdi
movq %r15, %rdx
movq %r12, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
callq 0x10b0
movl $0x9, %ebp
movl %ebp, %eax
andl $0x3, %eax
movl (%r14,%rax,4), %esi
movq %rbx, %rdi
movq %r15, %rdx
movq %r12, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
callq 0x10b0
incl %ebp
cmpl $0x38, %ebp
jne 0x17bb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/acorn128v2/opt/encrypt.c
// Function: acorn128_tag_generation_32bits_version
void acorn128_tag_generation_32bits_version(unsigned long long msglen, unsigned long long adlen, unsigned char maclen, unsigned char *mac, unsigned long long *state)
{
    int i;
    unsigned int plaintextword  = 0;
    unsigned int ciphertextword = 0;
    unsigned int ksword = 0;

    for (i = 0; i < 768/32; i++)
    {
        encrypt_32bits(state, plaintextword, &ciphertextword, &ksword, 0xffffffff, 0xffffffff);
        if ( i >= (768/32 - 4) ) { ((unsigned int*)mac)[i-(768/32-4)] = ksword; }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rcx, %r14
leaq 0x8(%rsp), %r15
movl $0x0, (%r15)
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
callq 0x10b0
cmpq $0x14, %r13
jb 0x1846
movl 0x8(%rsp), %eax
movl %eax, -0x50(%r14,%r13,4)
incq %r13
cmpq $0x18, %r13
jne 0x181b
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: pkGetValueType
PkVarType pkGetValueType(const PkVar value) {
  __ASSERT(value != NULL, "Given value was NULL.");

  if (IS_NULL(*(const Var*)(value))) return PK_NULL;
  if (IS_BOOL(*(const Var*)(value))) return PK_BOOL;
  if (IS_NUM(*(const Var*)(value))) return PK_NUMBER;

  __ASSERT(IS_OBJ(*(const Var*)(value)),
           "Invalid var pointer. Might be a dangling pointer");

  const Object* obj = AS_OBJ(*(const Var*)(value));
  switch (obj->type) {
    case OBJ_STRING: return PK_STRING;
    case OBJ_LIST:   return PK_LIST;
    case OBJ_MAP:    return PK_MAP;
    case OBJ_RANGE:  return PK_RANGE;
    case OBJ_SCRIPT: return PK_SCRIPT;
    case OBJ_FUNC:   return PK_FUNCTION;
    case OBJ_FIBER:  return PK_FIBER;
    case OBJ_CLASS:  return PK_CLASS;
    case OBJ_INST:   return PK_INST;
  }

  UNREACHABLE();
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x7e97
movq (%rdi), %rcx
movabsq $-0x7ffd000000000002, %rax # imm = 0x8002FFFFFFFFFFFE
addq %rcx, %rax
cmpq $0x2, %rax
jae 0x7e4f
movl $0x1, %eax
jmp 0x7e95
xorl %eax, %eax
movabsq $0x7ffc000000000000, %rdx # imm = 0x7FFC000000000000
cmpq %rdx, %rcx
je 0x7e95
movq %rcx, %rsi
notq %rsi
movl $0x2, %eax
testq %rdx, %rsi
jne 0x7e95
movq %rcx, %rax
shrq $0x32, %rax
cmpl $0x3ffe, %eax           # imm = 0x3FFE
jbe 0x7e9c
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rax, %rcx
movl (%rcx), %eax
cmpl $0x9, %eax
jae 0x7ea1
addl $0x3, %eax
popq %rcx
retq
callq 0x2441
callq 0x23e0
callq 0x2414
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: pkNewString
PkHandle* pkNewString(PKVM* vm, const char* value) {
  String* str = newString(vm, value);
  vmPushTempRef(vm, &str->_super); // str
  PkHandle* handle = vmNewHandle(vm, VAR_OBJ(str));
  vmPopTempRef(vm); // str
  return handle;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x7ec7
movq %rsi, %r14
movq %rsi, %rdi
callq 0x2140
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
jmp 0x7ece
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7f0c
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb71b
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
orq %r14, %rsi
movq %rbx, %rdi
callq 0xb517
movq %rax, %r14
movq %rbx, %rdi
callq 0xb78e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: newStringLength
String* newStringLength(PKVM* vm, const char* text, uint32_t length) {

  ASSERT(length == 0 || text != NULL, "Unexpected NULL string.");

  String* string = _allocateString(vm, length);

  if (length != 0 && text != NULL) memcpy(string->data, text, length);
  string->hash = utilHashString(string->data);

  return string;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
sete %al
testq %rsi, %rsi
setne %cl
orb %al, %cl
je 0x7fb5
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r13
testq %rsi, %rsi
sete %bpl
movl %edx, %r15d
leaq 0x21(%r15), %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0xb4b5
movq %rax, %r12
movl $0x0, (%rax)
xorl %ecx, %ecx
movb %cl, 0x4(%rax)
movq (%r13), %rax
movq %rax, 0x8(%r12)
movq %r12, (%r13)
movl %r14d, 0x14(%r12)
leaq 0x1c(%r12), %r13
movb %cl, 0x1c(%r12,%r15)
leal 0x1(%r14), %eax
movl %eax, 0x18(%r12)
testl %r14d, %r14d
sete %al
orb %bpl, %al
jne 0x7f96
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2280
movq %r13, %rdi
callq 0xefbe
movl %eax, 0x10(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2475
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: pkNewStringLength
PkHandle* pkNewStringLength(PKVM* vm, const char* value, size_t len) {
  String* str = newStringLength(vm, value, (uint32_t)len);
  vmPushTempRef(vm, &str->_super); // str
  PkHandle* handle = vmNewHandle(vm, VAR_OBJ(str));
  vmPopTempRef(vm); // str
  return handle;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7f0c
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb71b
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
orq %r14, %rsi
movq %rbx, %rdi
callq 0xb517
movq %rax, %r14
movq %rbx, %rdi
callq 0xb78e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: pkNewList
PkHandle* pkNewList(PKVM* vm) {
  List* list = newList(vm, MIN_CAPACITY);
  vmPushTempRef(vm, &list->_super); // list
  PkHandle* handle = vmNewHandle(vm, VAR_OBJ(list));
  vmPopTempRef(vm); // list
  return handle;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x8, %esi
callq 0x8049
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb71b
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
orq %r14, %rsi
movq %rbx, %rdi
callq 0xb517
movq %rax, %r14
movq %rbx, %rdi
callq 0xb78e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: newList
List* newList(PKVM* vm, uint32_t size) {
  List* list = ALLOCATE(vm, List);
  vmPushTempRef(vm, &list->_super);
  varInitObject(&list->_super, vm, OBJ_LIST);
  pkVarBufferInit(&list->elements);
  if (size > 0) {
    pkVarBufferFill(&list->elements, vm, VAR_NULL, size);
    list->elements.count = 0;
  }
  vmPopTempRef(vm);
  return list;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl $0x20, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0xb4b5
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb71b
movl $0x1, (%r14)
movb $0x0, 0x4(%r14)
movq (%rbx), %rax
movq %rax, 0x8(%r14)
movq %r14, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
testl %ebp, %ebp
je 0x80b3
movq %r14, %rdi
addq $0x10, %rdi
movabsq $0x7ffc000000000000, %rdx # imm = 0x7FFC000000000000
movq %rbx, %rsi
movl %ebp, %ecx
callq 0x863c
movl $0x0, 0x18(%r14)
movq %rbx, %rdi
callq 0xb78e
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: newMap
Map* newMap(PKVM* vm) {
  Map* map = ALLOCATE(vm, Map);
  varInitObject(&map->_super, vm, OBJ_MAP);
  map->capacity = 0;
  map->count = 0;
  map->entries = NULL;
  return map;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x20, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0xb4b5
movl $0x2, (%rax)
movb $0x0, 0x4(%rax)
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: pkNewFiber
PkHandle* pkNewFiber(PKVM* vm, PkHandle* fn) {
  __ASSERT(IS_OBJ_TYPE(fn->value, OBJ_FUNC), "Fn should be of type function.");

  Fiber* fiber = newFiber(vm, (Function*)AS_OBJ(fn->value));
  vmPushTempRef(vm, &fiber->_super); // fiber
  PkHandle* handle = vmNewHandle(vm, VAR_OBJ(fiber));
  vmPopTempRef(vm); // fiber
  return handle;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rsi), %rsi
movq %rsi, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x81c9
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rax, %rsi
cmpl $0x5, (%rsi)
jne 0x81c9
movq %rdi, %rbx
movabsq $-0x4000000000001, %r14 # imm = 0xFFFBFFFFFFFFFFFF
callq 0x81ce
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb71b
incq %r14
orq %r15, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb517
movq %rax, %r14
movq %rbx, %rdi
callq 0xb78e
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x24ab
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: newFiber
Fiber* newFiber(PKVM* vm, Function* fn) {
  Fiber* fiber = ALLOCATE(vm, Fiber);
  memset(fiber, 0, sizeof(Fiber));
  varInitObject(&fiber->_super, vm, OBJ_FIBER);

  fiber->state = FIBER_NEW;
  fiber->func = fn;

  if (fn->is_native) {
    // For native functions, we're only using stack for parameters,
    // there won't be any locals or temps (which are belongs to the
    // native "C" stack).
    int stack_size = utilPowerOf2Ceil(fn->arity + 1);
    fiber->stack = ALLOCATE_ARRAY(vm, Var, stack_size);
    fiber->stack_size = stack_size;
    fiber->ret = fiber->stack;
    fiber->sp = fiber->stack + 1;

  } else {
    // Allocate stack.
    int stack_size = utilPowerOf2Ceil(fn->fn->stack_size + 1);
    if (stack_size < MIN_STACK_SIZE) stack_size = MIN_STACK_SIZE;
    fiber->stack = ALLOCATE_ARRAY(vm, Var, stack_size);
    fiber->stack_size = stack_size;
    fiber->ret = fiber->stack;
    fiber->sp = fiber->stack + 1;

    // Allocate call frames.
    fiber->frame_capacity = INITIAL_CALL_FRAMES;
    fiber->frames = ALLOCATE_ARRAY(vm, CallFrame, fiber->frame_capacity);
    fiber->frame_count = 1;

    // Initialize the first frame.
    fiber->frames[0].fn = fn;
    fiber->frames[0].ip = fn->fn->opcodes.data;
    fiber->frames[0].rbp = fiber->ret;
  }

  // Initialize the return value to null (doesn't really have to do that here
  // but if we're trying to debut it may crash when dumping the return value).
  *fiber->ret = VAR_NULL;

  return fiber;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl $0x60, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0xb4b5
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
movl $0x6, (%rax)
movq (%r14), %rax
movq %rax, 0x8(%rbx)
movq %rbx, (%r14)
movq %r15, 0x18(%rbx)
cmpb $0x1, 0x30(%r15)
jne 0x8260
movl 0x20(%r15), %edi
incl %edi
callq 0xeee0
movslq %eax, %r15
leaq (,%r15,8), %rcx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb4b5
movq %rax, 0x20(%rbx)
movl %r15d, 0x28(%rbx)
movq %rax, 0x38(%rbx)
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x30(%rbx)
jmp 0x82e1
movq 0x38(%r15), %rax
movl 0x20(%rax), %edi
incl %edi
callq 0xeee0
cmpl $0x81, %eax
movl $0x80, %r12d
cmovgel %eax, %r12d
leaq (,%r12,8), %rcx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb4b5
movq %rax, 0x20(%rbx)
movl %r12d, 0x28(%rbx)
movq %rax, 0x38(%rbx)
addq $0x8, %rax
movq %rax, 0x30(%rbx)
movl $0x4, 0x48(%rbx)
movl $0x60, %ecx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb4b5
movq %rax, %rcx
movq %rax, 0x40(%rbx)
movl $0x1, 0x4c(%rbx)
movq %r15, 0x8(%rax)
movq 0x38(%r15), %rax
movq (%rax), %rax
movq %rax, (%rcx)
movq 0x38(%rbx), %rax
movq %rax, 0x10(%rcx)
movabsq $0x7ffc000000000000, %rcx # imm = 0x7FFC000000000000
movq %rcx, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: pkNewInstNative
PkHandle* pkNewInstNative(PKVM* vm, void* data, uint32_t id) {
  Instance* inst = newInstanceNative(vm, data, id);
  vmPushTempRef(vm, &inst->_super); // inst
  PkHandle* handle = vmNewHandle(vm, VAR_OBJ(inst));
  vmPopTempRef(vm); // inst
  return handle;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8342
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb71b
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
orq %r14, %rsi
movq %rbx, %rdi
callq 0xb517
movq %rax, %r14
movq %rbx, %rdi
callq 0xb78e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: newInstanceNative
Instance* newInstanceNative(PKVM* vm, void* data, uint32_t id) {
  Instance* inst = ALLOCATE(vm, Instance);
  varInitObject(&inst->_super, vm, OBJ_INST);
  inst->is_native = true;
  inst->native_id = id;

  if (vm->config.inst_name_fn != NULL) {
    inst->name = vm->config.inst_name_fn(id);
  } else {
    inst->name = "$(?)";
  }

  inst->native = data;
  return inst;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movl $0x28, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0xb4b5
movq %rax, %r14
movl $0x8, (%rax)
movb $0x0, 0x4(%rax)
movq (%r15), %rax
movq %rax, 0x8(%r14)
movq %r14, (%r15)
movb $0x1, 0x18(%r14)
movl %ebp, 0x1c(%r14)
movq 0xf0(%r15), %rax
testq %rax, %rax
je 0x8391
movl %ebp, %edi
callq *%rax
jmp 0x8398
leaq 0x13ead(%rip), %rax     # 0x1c245
movq %rax, 0x10(%r14)
movq %rbx, 0x20(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: newScript
Script* newScript(PKVM* vm, String* name, bool is_core) {
  Script* script = ALLOCATE(vm, Script);
  varInitObject(&script->_super, vm, OBJ_SCRIPT);

  ASSERT(name != NULL && name->length > 0, OOPS);

  script->path = name;
  script->module = NULL;
  script->initialized = is_core;
  script->body = NULL;

  // Core modules has its name as the module name.
  if (is_core) script->module = name;

  pkVarBufferInit(&script->globals);
  pkUintBufferInit(&script->global_names);
  pkVarBufferInit(&script->literals);
  pkFunctionBufferInit(&script->functions);
  pkClassBufferInit(&script->classes);
  pkStringBufferInit(&script->names);

  // Add a implicit main function and the '__file__' global to the module, only
  // if it's not a core module.
  if (!is_core) {
    vmPushTempRef(vm, &script->_super);
    scriptAddMain(vm, script);

    // Add '__file__' variable with it's path as value. If the path starts with
    // '$' It's a special file ($(REPL) or $(TRY)) and don't define __file__.
    if (script->path->data[0] != '$') {
      scriptAddGlobal(vm, script, "__file__", 8, VAR_OBJ(script->path));
    }

    // TODO: Add ARGV as a global.

    vmPopTempRef(vm); // script.
  }

  return script;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movl $0x90, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0xb4b5
movq %rax, %rbx
movl $0x4, (%rax)
movb $0x0, 0x4(%rax)
movq (%r14), %rax
movq %rax, 0x8(%rbx)
movq %rbx, (%r14)
testq %r15, %r15
je 0x90f5
cmpl $0x0, 0x14(%r15)
je 0x90f5
movq %r15, 0x18(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb %bpl, 0x88(%rbx)
movq %rax, 0x80(%rbx)
testb %bpl, %bpl
je 0x907f
movq %r15, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
jmp 0x90e7
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb71b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x90fa
movq 0x18(%rbx), %r8
cmpb $0x24, 0x1c(%r8)
je 0x90df
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %r8
leaq 0x1314b(%rip), %rdx     # 0x1c21a
movq %r14, %rdi
movq %rbx, %rsi
movl $0x8, %ecx
callq 0x913e
movq %r14, %rdi
callq 0xb78e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x24df
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: scriptAddMain
void scriptAddMain(PKVM* vm, Script* script) {
  ASSERT(script->body == NULL, OOPS);

  const char* fn_name = PK_IMPLICIT_MAIN_NAME;
  script->body = newFunction(vm, fn_name, (int)strlen(fn_name),
                             script, false, NULL/*TODO*/);
  script->body->arity = 0;
  script->initialized = false;
}

// Assembly:
pushq %rbx
cmpq $0x0, 0x80(%rsi)
jne 0x9139
movq %rsi, %rbx
leaq 0x13168(%rip), %rsi     # 0x1c277
movl $0xd, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x91e2
movq %rax, 0x80(%rbx)
movl $0x0, 0x20(%rax)
movb $0x0, 0x88(%rbx)
popq %rbx
retq
callq 0x2515
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: scriptAddGlobal
uint32_t scriptAddGlobal(PKVM* vm, Script* script,
                    const char* name, uint32_t length,
                    Var value) {

  // If already exists update the value.
  int var_ind = scriptGetGlobals(script, name, length);
  if (var_ind != -1) {
    ASSERT(var_ind < (int)script->globals.count, OOPS);
    script->globals.data[var_ind] = value;
    return var_ind;
  }

  // If we're reached here that means we don't already have a variable with
  // that name, create new one and set the value.
  uint32_t name_ind = scriptAddName(script, vm, name, length);
  pkUintBufferWrite(&script->global_names, vm, name_ind);
  pkVarBufferWrite(&script->globals, vm, value);
  return script->globals.count - 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
movl %ecx, %edx
callq 0xa47b
cmpl $-0x1, %eax
je 0x9179
cmpl 0x28(%r14), %eax
jge 0x91dd
movq 0x20(%r14), %rcx
movslq %eax, %rdx
movq %rbx, (%rcx,%rdx,8)
jmp 0x91d4
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq 0x9306
movl %eax, %ebp
leaq 0x30(%r14), %rdi
movl 0x38(%r14), %edx
incl %edx
movq %r15, %rsi
callq 0x83d8
movq 0x30(%r14), %rax
movl 0x38(%r14), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x38(%r14)
movl %ebp, (%rax,%rcx,4)
leaq 0x20(%r14), %rdi
movl 0x28(%r14), %edx
incl %edx
movq %r15, %rsi
callq 0x85ee
movq 0x20(%r14), %rcx
movl 0x28(%r14), %eax
leal 0x1(%rax), %edx
movq %rbx, (%rcx,%rax,8)
movl %edx, 0x28(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x254b
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: newFunction
Function* newFunction(PKVM* vm, const char* name, int length, Script* owner,
                      bool is_native, const char* docstring) {

  Function* func = ALLOCATE(vm, Function);
  varInitObject(&func->_super, vm, OBJ_FUNC);

  vmPushTempRef(vm, &func->_super); // func

  if (owner == NULL) {
    ASSERT(is_native, OOPS);
    func->name = name;
    func->owner = NULL;
    func->is_native = is_native;

  } else {
    pkFunctionBufferWrite(&owner->functions, vm, func);
    uint32_t name_index = scriptAddName(owner, vm, name, length);

    func->name = owner->names.data[name_index]->data;
    func->owner = owner;
    func->arity = -2; // -1 means variadic args.
    func->is_native = is_native;
  }

  if (is_native) {
    func->native = NULL;

  } else {
    Fn* fn = ALLOCATE(vm, Fn);
    pkByteBufferInit(&fn->opcodes);
    pkUintBufferInit(&fn->oplines);
    fn->stack_size = 0;
    func->fn = fn;
  }

  // Both native and script (TODO:) functions support docstring.
  func->docstring = docstring;

  vmPopTempRef(vm); // func
  return func;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movl %r8d, %ebp
movq %rcx, %r12
movl %edx, %ebx
movq %rsi, %r13
movq %rdi, %r14
movl $0x40, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0xb4b5
movq %rax, %r15
movl $0x5, (%rax)
movb $0x0, 0x4(%rax)
movq (%r14), %rax
movq %rax, 0x8(%r15)
movq %r15, (%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0xb71b
testq %r12, %r12
je 0x92c2
leaq 0x40(%r12), %rdi
movl 0x48(%r12), %edx
incl %edx
movq %r14, %rsi
callq 0x8826
movl 0x48(%r12), %eax
movq 0x40(%r12), %rcx
leal 0x1(%rax), %edx
movq %r15, (%rcx,%rax,8)
movl %edx, 0x48(%r12)
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl %ebx, %ecx
callq 0x9306
movq 0x60(%r12), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %rax
addq $0x1c, %rax
movq %rax, 0x10(%r15)
movq %r12, 0x18(%r15)
movl $0xfffffffe, 0x20(%r15) # imm = 0xFFFFFFFE
movb %bpl, 0x30(%r15)
testb %bpl, %bpl
jne 0x92d7
movl $0x28, %ecx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb4b5
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movl $0x0, 0x20(%rax)
movq %rax, 0x38(%r15)
jmp 0x92df
testb %bpl, %bpl
je 0x9301
movq %r13, 0x10(%r15)
movq $0x0, 0x18(%r15)
movb %bpl, 0x30(%r15)
movq $0x0, 0x38(%r15)
movq (%rsp), %rax
movq %rax, 0x28(%r15)
movq %r14, %rdi
callq 0xb78e
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2581
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: scriptAddName
uint32_t scriptAddName(Script* self, PKVM* vm, const char* name,
  uint32_t length) {

  for (uint32_t i = 0; i < self->names.count; i++) {
    String* _name = self->names.data[i];
    if (_name->length == length && strncmp(_name->data, name, length) == 0) {
      // Name already exists in the buffer.
      return i;
    }
  }

  // If we reach here the name doesn't exists in the buffer, so add it and
  // return the index.
  String* new_name = newStringLength(vm, name, length);
  vmPushTempRef(vm, &new_name->_super);
  pkStringBufferWrite(&self->names, vm, new_name);
  vmPopTempRef(vm);
  return self->names.count - 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, 0x8(%rsp)
leaq 0x60(%rdi), %rax
movq %rax, (%rsp)
movq %rdi, 0x10(%rsp)
movl 0x68(%rdi), %r14d
testq %r14, %r14
je 0x9365
movq (%rsp), %rax
movq (%rax), %rbx
movl %ebp, %r15d
xorl %r13d, %r13d
movq (%rbx,%r13,8), %rdi
cmpl %ebp, 0x14(%rdi)
jne 0x935d
addq $0x1c, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2090
testl %eax, %eax
je 0x93bb
incq %r13
cmpq %r13, %r14
jne 0x9341
movq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x7f0c
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0xb71b
movq 0x10(%rsp), %rbx
movl 0x68(%rbx), %edx
incl %edx
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x870a
movl 0x68(%rbx), %eax
movq 0x60(%rbx), %rcx
leal 0x1(%rax), %edx
movq %r15, (%rcx,%rax,8)
movl %edx, 0x68(%rbx)
movq %r14, %rdi
callq 0xb78e
movl 0x68(%rbx), %r13d
decl %r13d
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: newClass
Class* newClass(PKVM* vm, Script* scr, const char* name, uint32_t length) {
  Class* type = ALLOCATE(vm, Class);
  varInitObject(&type->_super, vm, OBJ_CLASS);

  vmPushTempRef(vm, &type->_super); // type.

  pkClassBufferWrite(&scr->classes, vm, type);
  type->owner = scr;
  type->name = scriptAddName(scr, vm, name, length);
  pkUintBufferInit(&type->field_names);

  // Can't use '$' in string format. (TODO)
  String* ty_name = scr->names.data[type->name];
  String* dollar = newStringLength(vm, "$", 1);
  vmPushTempRef(vm, &dollar->_super); // dollar
  String* ctor_name = stringFormat(vm, "@(Ctor:@)", dollar, ty_name);
  vmPopTempRef(vm); // dollar

  // Constructor.
  vmPushTempRef(vm, &ctor_name->_super); // ctor_name
  type->ctor = newFunction(vm, ctor_name->data, ctor_name->length,
                           scr, false, NULL);
  vmPopTempRef(vm); // ctor_name

  vmPopTempRef(vm); // type.
  return type;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movl $0x38, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0xb4b5
movq %rax, %r14
movl $0x7, (%rax)
movb $0x0, 0x4(%rax)
movq (%rbx), %rax
movq %rax, 0x8(%r14)
movq %r14, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb71b
leaq 0x50(%r15), %rdi
movl 0x58(%r15), %edx
incl %edx
movq %rbx, %rsi
callq 0x8942
movl 0x58(%r15), %eax
movq 0x50(%r15), %rcx
leal 0x1(%rax), %edx
movq %r14, (%rcx,%rax,8)
movl %edx, 0x58(%r15)
movq %r15, 0x10(%r14)
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq 0x9306
movl %eax, 0x18(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movq 0x60(%r15), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %r12
leaq 0x1494b(%rip), %rsi     # 0x1ddb4
movq %rbx, %rdi
movl $0x1, %edx
callq 0x7f0c
movq %rax, %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb71b
leaq 0x12da4(%rip), %rsi     # 0x1c22f
movq %rbx, %rdi
movq %r13, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x94f4
movq %rax, %r12
movq %rbx, %rdi
callq 0xb78e
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb71b
movl 0x14(%r12), %edx
addq $0x1c, %r12
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x91e2
movq %rax, 0x20(%r14)
movq %rbx, %rdi
callq 0xb78e
movq %rbx, %rdi
callq 0xb78e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: newInstance
Instance* newInstance(PKVM* vm, Class* ty, bool initialize) {

  Instance* inst = ALLOCATE(vm, Instance);
  varInitObject(&inst->_super, vm, OBJ_INST);

  vmPushTempRef(vm, &inst->_super); // inst.

  ASSERT(ty->name < ty->owner->names.count, OOPS);
  inst->name = ty->owner->names.data[ty->name]->data;
  inst->is_native = false;

  Inst* ins = ALLOCATE(vm, Inst);
  inst->ins = ins;
  ins->type = ty;
  pkVarBufferInit(&ins->fields);

  if (initialize && ty->field_names.count != 0) {
    pkVarBufferFill(&ins->fields, vm, VAR_NULL, ty->field_names.count);
  }

  vmPopTempRef(vm); // inst.

  return inst;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x28, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0xb4b5
movq %rax, %r14
movl $0x8, (%rax)
movb $0x0, 0x4(%rax)
movq (%rbx), %rax
movq %rax, 0x8(%r14)
movq %r14, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb71b
movl 0x18(%r15), %eax
movq 0x10(%r15), %rcx
cmpl 0x68(%rcx), %eax
jae 0x97fd
movq 0x60(%rcx), %rcx
movq (%rcx,%rax,8), %rax
addq $0x1c, %rax
movq %rax, 0x10(%r14)
movb $0x0, 0x18(%r14)
movl $0x18, %ecx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb4b5
movq %rax, 0x20(%r14)
movq %r15, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
testb %bpl, %bpl
je 0x97e7
movl 0x30(%r15), %ecx
testl %ecx, %ecx
je 0x97e7
addq $0x8, %rax
movabsq $0x7ffc000000000000, %rdx # imm = 0x7FFC000000000000
movq %rax, %rdi
movq %rbx, %rsi
callq 0x863c
movq %rbx, %rdi
callq 0xb78e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x25b7
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: rangeAsList
List* rangeAsList(PKVM* vm, Range* self) {
  List* list;
  if (self->from < self->to) {
    list = newList(vm, (uint32_t)(self->to - self->from));
    for (double i = self->from; i < self->to; i++) {
      pkVarBufferWrite(&list->elements, vm, VAR_NUM(i));
    }
    return list;

  } else {
    list = newList(vm, 0);
  }

  return list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0x10(%rsi), %xmm0
movsd 0x18(%rsi), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x98b3
movq %rsi, %r14
subsd %xmm0, %xmm1
cvttsd2si %xmm1, %rsi
movq %rbx, %rdi
callq 0x8049
movq %rax, %r15
movsd 0x10(%r14), %xmm0
movsd 0x18(%r14), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x98a2
movq %r15, %r12
addq $0x10, %r12
movsd %xmm0, 0x8(%rsp)
callq 0xef29
movq %rax, %r13
movl 0x18(%r15), %edx
incl %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x85ee
movsd 0x8(%rsp), %xmm0
movq 0x10(%r15), %rax
movl 0x18(%r15), %ecx
leal 0x1(%rcx), %edx
movq %r13, (%rax,%rcx,8)
movl %edx, 0x18(%r15)
addsd 0x1282a(%rip), %xmm0    # 0x1c0c0
movsd 0x18(%r14), %xmm1
ucomisd %xmm0, %xmm1
ja 0x9856
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %rdi
xorl %esi, %esi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8049
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: stringLower
String* stringLower(PKVM* vm, String* self) {
  // If the string itself is already lower, don't allocate new string.
  uint32_t index = 0;
  for (const char* c = self->data; *c != '\0'; c++, index++) {
    if (isupper(*c)) {

      // It contain upper case letters, allocate new lower case string .
      String* lower = newStringLength(vm, self->data, self->length);

      // Start where the first upper case letter found.
      char* _c = lower->data + (c - self->data);
      for (; *_c != '\0'; _c++) *_c = (char)tolower(*_c);

      // Since the string is modified re-hash it.
      lower->hash = utilHashString(lower->data);
      return lower;
    }
  }
  // If we reached here the string itself is lower, return it.
  return self;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movb 0x1c(%rsi), %bpl
testb %bpl, %bpl
je 0x9959
movq %rdi, %r14
leaq 0x1c(%rbx), %r15
callq 0x23c0
movq (%rax), %rax
movl $0x1d, %r12d
movsbq %bpl, %rcx
testb $0x1, 0x1(%rax,%rcx,2)
jne 0x990c
movb (%rbx,%r12), %bpl
incq %r12
testb %bpl, %bpl
jne 0x98f3
jmp 0x9959
movl 0x14(%rbx), %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x7f0c
movq %rax, %rbx
leaq 0x1c(%rax), %r14
movb -0x1(%rax,%r12), %bpl
testb %bpl, %bpl
je 0x994e
callq 0x23b0
movq %rbx, %rcx
addq %r12, %rcx
movq (%rax), %rdx
movsbq %bpl, %rsi
movb (%rdx,%rsi,4), %dl
movb %dl, -0x1(%rcx)
movb (%rcx), %bpl
incq %rcx
testb %bpl, %bpl
jne 0x9936
movq %r14, %rdi
callq 0xefbe
movl %eax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: stringUpper
String* stringUpper(PKVM* vm, String* self) {
  // If the string itself is already upper don't allocate new string.
  uint32_t index = 0;
  for (const char* c = self->data; *c != '\0'; c++, index++) {
    if (islower(*c)) {
      // It contain lower case letters, allocate new upper case string .
      String* upper = newStringLength(vm, self->data, self->length);

      // Start where the first lower case letter found.
      char* _c = upper->data + (c - self->data);
      for (; *_c != '\0'; _c++) *_c = (char)toupper(*_c);

      // Since the string is modified re-hash it.
      upper->hash = utilHashString(upper->data);
      return upper;
    }
  }
  // If we reached here the string itself is lower, return it.
  return self;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movb 0x1c(%rsi), %bpl
testb %bpl, %bpl
je 0x99f4
movq %rdi, %r14
leaq 0x1c(%rbx), %r15
callq 0x23c0
movq (%rax), %rax
movl $0x1d, %r12d
movsbq %bpl, %rcx
testb $0x2, 0x1(%rax,%rcx,2)
jne 0x99a7
movb (%rbx,%r12), %bpl
incq %r12
testb %bpl, %bpl
jne 0x998e
jmp 0x99f4
movl 0x14(%rbx), %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x7f0c
movq %rax, %rbx
leaq 0x1c(%rax), %r14
movb -0x1(%rax,%r12), %bpl
testb %bpl, %bpl
je 0x99e9
callq 0x2030
movq %rbx, %rcx
addq %r12, %rcx
movq (%rax), %rdx
movsbq %bpl, %rsi
movb (%rdx,%rsi,4), %dl
movb %dl, -0x1(%rcx)
movb (%rcx), %bpl
incq %rcx
testb %bpl, %bpl
jne 0x99d1
movq %r14, %rdi
callq 0xefbe
movl %eax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq