LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::sub(obj_t*, obj_t*)
obj_t* tscrpt_t::sub(obj_t* l, obj_t* r){
	obj_t* o(0);
	verbose(VTRACE,"parse: %s-%s\n",l->str().c_str(), r->str().c_str());
	if(l->type=='N'||l->type=='S'){
		o = new obj_t('N', l->value() - r->value());
	}else assert(0);
	return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpl $0x9, 0xa7dd(%rip)      # 0xe1d0
jl 0x3a30
movq -0x10(%rbp), %rdi
callq 0x2500
movq %rax, %rdi
callq 0x20e0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2500
movq %rax, %rdi
callq 0x20e0
movq -0x38(%rbp), %rsi
movq %rax, %rdx
leaq 0x6951(%rip), %rdi      # 0xa37a
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4e, %eax
je 0x3a48
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x53, %eax
jne 0x3aaa
movl $0x30, %edi
callq 0x21c0
movq %rax, -0x40(%rbp)
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2480
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2480
movl -0x44(%rbp), %edx
movq -0x40(%rbp), %rdi
subl %eax, %edx
movl $0x4e, %esi
callq 0x42d0
jmp 0x3a84
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x3ac9
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x30, %esi
callq 0x21d0
jmp 0x3ad3
leaq 0x6eb6(%rip), %rdi      # 0xa967
leaq 0x6a44(%rip), %rsi      # 0xa4fc
movl $0xd5, %edx
leaq 0x68c4(%rip), %rcx      # 0xa388
callq 0x2140
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2330
nopl (%rax)
// File: yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::factor()
obj_t* tscrpt_t::factor() {
	obj_t *o(0);
	bool minus=false;
	if     (is('+')){ } // unary-operator
	else if(is('-')){ minus=true; }
//	else if(is('!')){ assert(0); }
//	else if(is('~')){ assert(0); }
//	else if(is('*')){ assert(0); }
//	else if(is('&')){ assert(0); }
	if      (is('(')){ o=expr(); be(')'); }
	else if (eq('I')){ assert(0); }
	else if (eq('N')||eq('S')){ o=obj(); }
	else throw std::runtime_error("factor: syntax error");
	if (minus) {
		obj_t l('N',-1), *r;
		o=mul(&l,r=o);
		delete r;
	}
	return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq $0x0, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x2b, %esi
movl $0x1, %edx
callq 0x3190
testb $0x1, %al
jne 0x3b18
jmp 0x3b1a
jmp 0x3b39
movq -0x68(%rbp), %rdi
movl $0x2d, %esi
movl $0x1, %edx
callq 0x3190
testb $0x1, %al
jne 0x3b33
jmp 0x3b37
movb $0x1, -0x11(%rbp)
jmp 0x3b39
movq -0x68(%rbp), %rdi
movl $0x28, %esi
movl $0x1, %edx
callq 0x3190
testb $0x1, %al
jne 0x3b52
jmp 0x3b72
movq -0x68(%rbp), %rdi
callq 0x3290
movq -0x68(%rbp), %rdi
movq %rax, -0x10(%rbp)
movl $0x29, %esi
callq 0x34a0
jmp 0x3c31
movq -0x68(%rbp), %rdi
movl $0x49, %esi
callq 0x3470
testb $0x1, %al
jne 0x3b86
jmp 0x3ba5
leaq 0x6dda(%rip), %rdi      # 0xa967
leaq 0x6968(%rip), %rsi      # 0xa4fc
movl $0xbb, %edx
leaq 0x6776(%rip), %rcx      # 0xa316
callq 0x2140
movq -0x68(%rbp), %rdi
movl $0x4e, %esi
callq 0x3470
testb $0x1, %al
jne 0x3bcb
movq -0x68(%rbp), %rdi
movl $0x53, %esi
callq 0x3470
testb $0x1, %al
jne 0x3bcb
jmp 0x3bda
movq -0x68(%rbp), %rdi
callq 0x33c0
movq %rax, -0x10(%rbp)
jmp 0x3c2d
movl $0x10, %edi
callq 0x2120
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
leaq 0x673b(%rip), %rsi      # 0xa330
callq 0x20c0
jmp 0x3bfc
movq -0x70(%rbp), %rdi
movq 0xa3f1(%rip), %rsi      # 0xdff8
movq 0xa3ba(%rip), %rdx      # 0xdfc8
callq 0x2310
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2170
jmp 0x3cd2
jmp 0x3c2f
jmp 0x3c31
testb $0x1, -0x11(%rbp)
je 0x3cc5
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0x4e, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x42d0
movq -0x68(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq %rdx, -0x60(%rbp)
callq 0x3ce0
movq %rax, -0x78(%rbp)
jmp 0x3c6d
movq -0x78(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, %rax
je 0x3ca3
movq -0x88(%rbp), %rdi
callq 0x4480
movq -0x88(%rbp), %rdi
movl $0x30, %esi
callq 0x21d0
leaq -0x58(%rbp), %rdi
callq 0x4480
jmp 0x3cc5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4480
jmp 0x3cd2
movq -0x10(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2330
nopl (%rax,%rax)
// File: yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::mul(obj_t*, obj_t*)
obj_t* tscrpt_t::mul(obj_t* l, obj_t* r){
	obj_t* o(0);
	verbose(VTRACE,"parse: %s*%s\n",l->str().c_str(), r->str().c_str());
	if(l->type=='N'){
		o = new obj_t('N', l->value() * r->value());
	}else if(l->type=='S'){
		o = new obj_t('S', "");
		std::string& s=o->str();
		for(int i=r->value();i>0;--i) s.append(l->str());
	}else assert(0);
	return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpl $0x9, 0xa4cd(%rip)      # 0xe1d0
jl 0x3d40
movq -0x10(%rbp), %rdi
callq 0x2500
movq %rax, %rdi
callq 0x20e0
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2500
movq %rax, %rdi
callq 0x20e0
movq -0x48(%rbp), %rsi
movq %rax, %rdx
leaq 0x6676(%rip), %rdi      # 0xa3af
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4e, %eax
jne 0x3db5
movl $0x30, %edi
callq 0x21c0
movq %rax, -0x50(%rbp)
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2480
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2480
movl -0x54(%rbp), %edx
movq -0x50(%rbp), %rdi
imull %eax, %edx
movl $0x4e, %esi
callq 0x42d0
jmp 0x3d89
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x3e7a
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x30, %esi
callq 0x21d0
jmp 0x3e84
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x53, %eax
jne 0x3e59
movl $0x30, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
leaq 0x6719(%rip), %rdx      # 0xa4f9
movl $0x53, %esi
callq 0x43f0
jmp 0x3dec
movq -0x68(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2500
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2480
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jle 0x3e57
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2500
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x2360
movl -0x3c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x3e0d
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x30, %esi
callq 0x21d0
jmp 0x3e84
jmp 0x3e78
leaq 0x6b07(%rip), %rdi      # 0xa967
leaq 0x6695(%rip), %rsi      # 0xa4fc
movl $0xe1, %edx
leaq 0x654a(%rip), %rcx      # 0xa3bd
callq 0x2140
jmp 0x3e7a
movq -0x20(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2330
nopl (%rax)
// File: yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::div(obj_t*, obj_t*)
obj_t* tscrpt_t::div(obj_t* l, obj_t* r){
	obj_t* o(0);
	verbose(VTRACE,"parse: %s/%s\n",l->str().c_str(), r->str().c_str());
	if(l->type=='N'||l->type=='S'){
		if(r->value()==0) throw std::runtime_error("div: divide by zero");
		o = new obj_t('N', l->value() / r->value());
	}else assert(0);
	return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpl $0x9, 0xa31d(%rip)      # 0xe1d0
jl 0x3ef0
movq -0x10(%rbp), %rdi
callq 0x2500
movq %rax, %rdi
callq 0x20e0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2500
movq %rax, %rdi
callq 0x20e0
movq -0x38(%rbp), %rsi
movq %rax, %rdx
leaq 0x64fb(%rip), %rdi      # 0xa3e4
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4e, %eax
je 0x3f0c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x53, %eax
jne 0x3fd4
movq -0x18(%rbp), %rdi
callq 0x2480
cmpl $0x0, %eax
jne 0x3f6d
movl $0x10, %edi
callq 0x2120
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x64bd(%rip), %rsi      # 0xa3f2
callq 0x20c0
jmp 0x3f3c
movq -0x40(%rbp), %rdi
movq 0xa0b1(%rip), %rsi      # 0xdff8
movq 0xa07a(%rip), %rdx      # 0xdfc8
callq 0x2310
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2170
jmp 0x3ffd
movl $0x30, %edi
callq 0x21c0
movq %rax, -0x50(%rbp)
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2480
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2480
movq -0x50(%rbp), %rdi
movl %eax, %ecx
movl -0x44(%rbp), %eax
cltd
idivl %ecx
movl %eax, %edx
movl $0x4e, %esi
callq 0x42d0
jmp 0x3fae
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x3ff3
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x30, %esi
callq 0x21d0
jmp 0x3ffd
leaq 0x698c(%rip), %rdi      # 0xa967
leaq 0x651a(%rip), %rsi      # 0xa4fc
movl $0xea, %edx
leaq 0x6418(%rip), %rcx      # 0xa406
callq 0x2140
movq -0x20(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2330
nopw %cs:(%rax,%rax)
// File: yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::rem(obj_t*, obj_t*)
obj_t* tscrpt_t::rem(obj_t* l, obj_t* r){
	obj_t* o(0);
	verbose(VTRACE,"parse: %s%%%s\n",l->str().c_str(), r->str().c_str());
	if(l->type=='N'||l->type=='S'){
		if(r->value()==0) throw std::runtime_error("div: divide by zero");
		o = new obj_t('N', l->value() % r->value());
	}else assert(0);
	return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpl $0x9, 0xa19d(%rip)      # 0xe1d0
jl 0x4070
movq -0x10(%rbp), %rdi
callq 0x2500
movq %rax, %rdi
callq 0x20e0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2500
movq %rax, %rdi
callq 0x20e0
movq -0x38(%rbp), %rsi
movq %rax, %rdx
leaq 0x63c4(%rip), %rdi      # 0xa42d
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4e, %eax
je 0x408c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x53, %eax
jne 0x4152
movq -0x18(%rbp), %rdi
callq 0x2480
cmpl $0x0, %eax
jne 0x40ed
movl $0x10, %edi
callq 0x2120
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x633d(%rip), %rsi      # 0xa3f2
callq 0x20c0
jmp 0x40bc
movq -0x40(%rbp), %rdi
movq 0x9f31(%rip), %rsi      # 0xdff8
movq 0x9efa(%rip), %rdx      # 0xdfc8
callq 0x2310
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2170
jmp 0x417b
movl $0x30, %edi
callq 0x21c0
movq %rax, -0x50(%rbp)
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2480
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2480
movq -0x50(%rbp), %rdi
movl %eax, %ecx
movl -0x44(%rbp), %eax
cltd
idivl %ecx
movl $0x4e, %esi
callq 0x42d0
jmp 0x412c
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x4171
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x30, %esi
callq 0x21d0
jmp 0x417b
leaq 0x680e(%rip), %rdi      # 0xa967
leaq 0x639c(%rip), %rsi      # 0xa4fc
movl $0xf3, %edx
leaq 0x62d0(%rip), %rcx      # 0xa43c
callq 0x2140
movq -0x20(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2330
nopw %cs:(%rax,%rax)
nop
// File: mukul-mehta[P]meta/shell.cc
// Function: checkBuiltin(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
int checkBuiltin(vector<string> tokens) {
    // Iterate over builtins and check if the command is same as the first token. If found, return index else -1
    string command = tokens[0];
    size_t n = builtins.size();

    for (size_t i = 0; i < n; i++) {
        if (builtins[i].command == command)
            return i;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x50c0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x3130
leaq 0xbfe8(%rip), %rdi      # 0x10320
callq 0x50e0
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x4399
movq -0x40(%rbp), %rsi
leaq 0xbfc2(%rip), %rdi      # 0x10320
callq 0x51a0
movq %rax, %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x5110
testb $0x1, %al
jne 0x4379
jmp 0x4389
movq -0x40(%rbp), %rax
movl %eax, -0x4(%rbp)
movl $0x1, -0x44(%rbp)
jmp 0x43a7
jmp 0x438b
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x4349
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31e0
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: mukul-mehta[P]meta/tokenizer.cc
// Function: parsePipeTokens(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
vector<vector<string>> parsePipeTokens(vector<string> tokens) {
    vector<vector<string>> parsedTokens;
    // Create a temporary vector for a single token group. Fill it and add it to parsedTokens on pipe character
    vector<string> temp;
    size_t num_tokens = tokens.size();

    for (size_t i = 0; i < num_tokens; i++) {
        if (tokens[i] != "|") {
            temp.push_back(tokens[i]);
        } else {
            parsedTokens.push_back(temp);
            temp.clear();
        }
    }
    parsedTokens.push_back(temp);

    return parsedTokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x7640
leaq -0x30(%rbp), %rdi
callq 0x5230
movq -0x58(%rbp), %rdi
callq 0x5450
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x7556
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0x3d23(%rip), %rsi      # 0xb1fe
callq 0x7660
movb %al, -0x69(%rbp)
jmp 0x74e5
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x74ee
jmp 0x752b
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x50c0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x75a0
jmp 0x7509
jmp 0x7543
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5250
movq -0x68(%rbp), %rdi
callq 0x55e0
jmp 0x758b
movq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7690
jmp 0x753a
leaq -0x30(%rbp), %rdi
callq 0x5640
jmp 0x7545
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x74b6
movq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7690
jmp 0x7565
movb $0x1, -0x11(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5250
testb $0x1, -0x11(%rbp)
jne 0x7581
movq -0x68(%rbp), %rdi
callq 0x55e0
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3570
nopw %cs:(%rax,%rax)
nop
// File: mukul-mehta[P]meta/utils.cc
// Function: parse_memory(long)
char* parse_memory(long int memory) {
    char* response = (char*)malloc(1024 * sizeof(char));
    if (memory <= 1024) {
        int mem = (int)memory;
        sprintf(response, "%dB", mem);
    } else if (memory <= 1024 * 1024) {
        int mem = (int)(memory / 1024.0);
        sprintf(response, "%dKB", mem);
    } else {
        int mem = (int)(memory / (1024.0 * 1024.0));
        sprintf(response, "%dMB", mem);
    }
    return response;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x400, %edi            # imm = 0x400
callq 0x3460
movq %rax, -0x10(%rbp)
cmpq $0x400, -0x8(%rbp)      # imm = 0x400
jg 0x87a2
movq -0x8(%rbp), %rax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x2b3f(%rip), %rsi      # 0xb2d8
movb $0x0, %al
callq 0x3090
jmp 0x880c
cmpq $0x100000, -0x8(%rbp)   # imm = 0x100000
jg 0x87dc
cvtsi2sdq -0x8(%rbp), %xmm0
movsd 0x2b16(%rip), %xmm1     # 0xb2d0
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x2b09(%rip), %rsi      # 0xb2dc
movb $0x0, %al
callq 0x3090
jmp 0x880a
cvtsi2sdq -0x8(%rbp), %xmm0
movsd 0x2ade(%rip), %xmm1     # 0xb2c8
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0x2ade(%rip), %rsi      # 0xb2e1
movb $0x0, %al
callq 0x3090
jmp 0x880c
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mukul-mehta[P]meta/utils.cc
// Function: parse_time(long)
char* parse_time(long int time) {
    int days = time / (24 * 3600);
    int hours = (time - (days * 24 * 3600)) / 3600;
    int minutes = (time - hours * 3600) / 60;

    char* response = (char*)malloc(1024 * sizeof(char));

    if (hours == 0) {
        sprintf(response, "%d minutes", minutes);
    } else if (days == 0) {
        if (hours == 1)
            sprintf(response, "%d hour, %d minutes", hours, minutes);
        else
            sprintf(response, "%d hours, %d minutes", hours, minutes);
    } else {
        if (days == 1)
            sprintf(response, "%d day, %d hours, %d minutes", days, hours, minutes);
        else
            sprintf(response, "%d days, %d hours, %d minutes", days, hours, minutes);
    }
    return response;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x15180, %ecx          # imm = 0x15180
cqto
idivq %rcx
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
imull $0x18, -0xc(%rbp), %ecx
imull $0xe10, %ecx, %ecx      # imm = 0xE10
movslq %ecx, %rcx
subq %rcx, %rax
movl $0xe10, %ecx            # imm = 0xE10
cqto
idivq %rcx
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
imull $0xe10, -0x10(%rbp), %ecx # imm = 0xE10
movslq %ecx, %rcx
subq %rcx, %rax
movl $0x3c, %ecx
cqto
idivq %rcx
movl %eax, -0x14(%rbp)
movl $0x400, %edi            # imm = 0x400
callq 0x3460
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x88aa
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x2a51(%rip), %rsi      # 0xb2ef
movb $0x0, %al
callq 0x3090
jmp 0x892e
cmpl $0x0, -0xc(%rbp)
jne 0x88ea
cmpl $0x1, -0x10(%rbp)
jne 0x88d0
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0x2a1f(%rip), %rsi      # 0xb2e6
movb $0x0, %al
callq 0x3090
jmp 0x88e8
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0x2a3f(%rip), %rsi      # 0xb320
movb $0x0, %al
callq 0x3090
jmp 0x892c
cmpl $0x1, -0xc(%rbp)
jne 0x890e
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0x29f5(%rip), %rsi      # 0xb2fa
movb $0x0, %al
callq 0x3090
jmp 0x892a
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0x29f4(%rip), %rsi      # 0xb317
movb $0x0, %al
callq 0x3090
jmp 0x892c
jmp 0x892e
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mukul-mehta[P]meta/utils.cc
// Function: getHistoryFilename()
char* getHistoryFilename() {
    char* histfile = (char*)malloc(BUFSIZE * sizeof(char));
    uid_t uid = geteuid();
    struct passwd* pw = getpwuid(uid);
    if (!pw) {
        histfile = NULL;
    }
    histfile = pw->pw_dir;

    char* fullFilePath = (char*)malloc(BUFSIZE * sizeof(char));
    sprintf(fullFilePath, "%s/%s", histfile, HISTORYFILENAME);
    return fullFilePath;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x1000, %edi           # imm = 0x1000
callq 0x3460
movq %rax, -0x8(%rbp)
callq 0x31c0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x3390
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8979
movq $0x0, -0x8(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x1000, %edi           # imm = 0x1000
callq 0x3460
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x2993(%rip), %rsi      # 0xb335
leaq 0x2992(%rip), %rcx      # 0xb33b
movb $0x0, %al
callq 0x3090
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mukul-mehta[P]meta/utils.cc
// Function: getUsername[abi:cxx11]()
string getUsername() {
    char* username = (char*)malloc(BUFSIZE * sizeof(char));
    uid_t uid = geteuid();
    struct passwd* pw = getpwuid(uid);
    if (!pw) {
        username = (char*)"";
    }
    username = pw->pw_name;

    return string(username);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x1000, %edi           # imm = 0x1000
callq 0x3460
movq %rax, -0x10(%rbp)
callq 0x31c0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x3390
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8a0b
leaq 0x2eba(%rip), %rax      # 0xb8c1
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x21(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3580
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x4ec0
jmp 0x8a3e
leaq -0x21(%rbp), %rdi
callq 0x3350
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x3350
movq -0x30(%rbp), %rdi
callq 0x3570
nop
// File: mukul-mehta[P]meta/utils.cc
// Function: getHostname[abi:cxx11]()
string getHostname() {
    char* hostname = (char*)malloc(BUFSIZE * sizeof(char));
    int ret = gethostname(hostname, BUFSIZE);
    if (ret < 0) {
        hostname = (char*)"";
    }
    return string(hostname);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x1000, %edi           # imm = 0x1000
callq 0x3460
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x3500
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x8ab7
leaq 0x2e0e(%rip), %rax      # 0xb8c1
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x15(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x3580
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x4ec0
jmp 0x8adf
leaq -0x15(%rbp), %rdi
callq 0x3350
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x15(%rbp), %rdi
callq 0x3350
movq -0x20(%rbp), %rdi
callq 0x3570
// File: mukul-mehta[P]meta/utils.cc
// Function: getOSName[abi:cxx11]()
string getOSName() {
    ifstream infile("/etc/os-release");

    if (infile.good()) {
        string temp;
        getline(infile, temp);
        string OSName = temp.substr(temp.find("=") + 2, temp.size() - 1);
        OSName.pop_back();
        return OSName;
    }
    return "Unknown Linux Distribution";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x260(%rbp)
movq %rdi, %rax
movq %rax, -0x258(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x2813(%rip), %rsi      # 0xb34a
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x35a0
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x3560
movb %al, -0x24a(%rbp)
jmp 0x8b68
movb -0x24a(%rbp), %al
testb $0x1, %al
jne 0x8b77
jmp 0x8c79
leaq -0x240(%rbp), %rdi
movq %rdi, -0x268(%rbp)
callq 0x34a0
movq -0x268(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0x30a0
jmp 0x8b9f
movb $0x0, -0x241(%rbp)
leaq 0x27ad(%rip), %rsi      # 0xb35a
xorl %eax, %eax
movl %eax, %edx
leaq -0x240(%rbp), %rdi
movq %rdi, -0x278(%rbp)
callq 0x35e0
movq -0x278(%rbp), %rdi
addq $0x2, %rax
movq %rax, -0x270(%rbp)
callq 0x3200
movq -0x260(%rbp), %rdi
movq -0x278(%rbp), %rsi
movq -0x270(%rbp), %rdx
movq %rax, %rcx
decq %rcx
callq 0x3330
jmp 0x8bfd
movq -0x260(%rbp), %rdi
callq 0x33f0
movb $0x1, -0x241(%rbp)
movl $0x1, -0x248(%rbp)
testb $0x1, -0x241(%rbp)
jne 0x8c6b
jmp 0x8c5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x8cfc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x31e0
jmp 0x8cfc
movq -0x260(%rbp), %rdi
callq 0x31e0
leaq -0x240(%rbp), %rdi
callq 0x31e0
jmp 0x8ce0
leaq -0x249(%rbp), %rdi
movq %rdi, -0x280(%rbp)
callq 0x3580
movq -0x260(%rbp), %rdi
movq -0x280(%rbp), %rdx
leaq 0x26bb(%rip), %rsi      # 0xb35c
callq 0x4ec0
jmp 0x8ca8
leaq -0x249(%rbp), %rdi
callq 0x3350
movl $0x1, -0x248(%rbp)
jmp 0x8ce0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x249(%rbp), %rdi
callq 0x3350
jmp 0x8cfc
leaq -0x210(%rbp), %rdi
callq 0x30b0
movq -0x258(%rbp), %rax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
leaq -0x210(%rbp), %rdi
callq 0x30b0
movq -0x218(%rbp), %rdi
callq 0x3570
nopw %cs:(%rax,%rax)
nop
// File: mukul-mehta[P]meta/builtins.cc
// Function: metash_pwd(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
int metash_pwd(vector<string> tokens) {
    size_t num_tokens = tokens.size();
    if (num_tokens >= 2) {
        printf("pwd: too many arguments\n");
        return -1;
    }

    char* current_directory = (char*)malloc(BUFSIZE * sizeof(char));
    string pwd = getcwd(current_directory, BUFSIZE);
    if (!pwd.empty()) {
        printf("%s\n", pwd.c_str());
        return 0;
    }
    perror("Error in fetching current working directory");
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
callq 0x5450
movq %rax, -0x18(%rbp)
cmpq $0x2, -0x18(%rbp)
jb 0x8fc6
leaq 0x282c(%rip), %rdi      # 0xb7df
movb $0x0, %al
callq 0x3040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x909e
movl $0x1000, %edi           # imm = 0x1000
movq %rdi, -0x70(%rbp)
callq 0x3460
movq -0x70(%rbp), %rsi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3170
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3580
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x4ec0
jmp 0x9009
leaq -0x41(%rbp), %rdi
callq 0x3350
leaq -0x40(%rbp), %rdi
callq 0x3550
testb $0x1, %al
jne 0x9079
leaq -0x40(%rbp), %rdi
callq 0x3120
movq %rax, %rsi
leaq 0x288c(%rip), %rdi      # 0xb8be
xorl %eax, %eax
callq 0x3040
jmp 0x903b
movl $0x0, -0x4(%rbp)
movl $0x1, -0x58(%rbp)
jmp 0x9095
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x3350
jmp 0x90a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31e0
jmp 0x90a7
leaq 0x2778(%rip), %rdi      # 0xb7f8
callq 0x32a0
jmp 0x9087
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31e0
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3570
// File: mukul-mehta[P]meta/builtins.cc
// Function: metash_cd(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
int metash_cd(vector<string> tokens) {
    size_t num_tokens = tokens.size();
    if (num_tokens >= 3) {
        printf("cd: too many arguments\n");
        return -1;
    }

    string new_directory_rel;
    char* new_directory = (char*)malloc(BUFSIZE * sizeof(char));
    // If no argument is passed, assume cd to home directory of user. Fetch home directory path
    if (num_tokens == 1) {
        uid_t uid = getuid();
        struct passwd* pw = getpwuid(uid);
        new_directory_rel =
            pw->pw_dir; // Stores the home direcoty path of the user executing the program
    } else {
        new_directory_rel = tokens[1];
    }
    // In case of links, or if a relative path is specified, generate the real path
    char* temp = realpath(new_directory_rel.c_str(), new_directory);
    if (!temp)
        perror("Couldn't get realpath");

    int ret = chdir(new_directory);
    if (ret < 0) {
        printf("Error in changing current directory. pwd not changed");
        return -1;
    }
    strcpy(__CWD, new_directory);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x5450
movq %rax, -0x18(%rbp)
cmpq $0x3, -0x18(%rbp)
jb 0x90ed
leaq 0x274a(%rip), %rdi      # 0xb824
movb $0x0, %al
callq 0x3040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x91ff
leaq -0x38(%rbp), %rdi
callq 0x34a0
movl $0x1000, %edi           # imm = 0x1000
callq 0x3460
movq %rax, -0x40(%rbp)
cmpq $0x1, -0x18(%rbp)
jne 0x9158
callq 0x3160
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %edi
callq 0x3390
movq %rax, -0x80(%rbp)
jmp 0x9121
movq -0x80(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3470
jmp 0x913c
jmp 0x9176
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31e0
jmp 0x920b
movq -0x78(%rbp), %rdi
movl $0x1, %esi
callq 0x50c0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x3030
jmp 0x9174
jmp 0x9176
leaq -0x38(%rbp), %rdi
callq 0x3120
movq %rax, %rdi
movq -0x40(%rbp), %rsi
callq 0x30f0
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
jne 0x91a6
leaq 0x269f(%rip), %rdi      # 0xb83c
callq 0x32a0
jmp 0x91a4
jmp 0x91a6
movq -0x40(%rbp), %rdi
callq 0x34f0
movl %eax, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
jge 0x91d8
leaq 0x2693(%rip), %rdi      # 0xb852
xorl %eax, %eax
callq 0x3040
jmp 0x91c8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x70(%rbp)
jmp 0x91f6
movq -0x40(%rbp), %rsi
leaq 0x755d(%rip), %rdi      # 0x10740
callq 0x3300
movl $0x0, -0x4(%rbp)
movl $0x1, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31e0
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3570
nopw %cs:(%rax,%rax)
// File: mukul-mehta[P]meta/builtins.cc
// Function: metash_history(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
int metash_history(unused vector<string> tokens) {
    HIST_ENTRY** hist_list = history_list();

    if (!hist_list)
        return 1;

    for (int i = 0; i < history_length; i++)
        printf("%s%d%s: %s\n", RED, i + history_base, NORM, hist_list[i]->line);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x3540
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9a95
movl $0x1, -0x4(%rbp)
jmp 0x9af3
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq 0x6532(%rip), %rcx      # 0xffd8
cmpl (%rcx), %eax
jge 0x9aec
movl -0x1c(%rbp), %edx
movq 0x653c(%rip), %rax      # 0xfff0
addl (%rax), %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %r8
leaq 0x1ec1(%rip), %rdi      # 0xb98d
leaq 0x16f0(%rip), %rsi      # 0xb1c3
leaq 0x16d8(%rip), %rcx      # 0xb1b2
movb $0x0, %al
callq 0x3040
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9a9c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mukul-mehta[P]meta/builtins.cc
// Function: metash_setenv(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
int metash_setenv(vector<string> tokens) {
    size_t num_tokens = tokens.size();
    if (num_tokens >= 4) {
        printf("setenv: too many arguments\n");
        return -1;
    }

    if (num_tokens == 1) {
        printf("setenv: too few arguments\n");
        return -1;
    }

    string value;
    if (num_tokens == 2)
        value = "\0";
    else
        value = tokens[num_tokens - 1];

    string key = tokens[1];

    int status = setenv(key.c_str(), value.c_str(), 69);
    if (status == -1)
        return -1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x5450
movq %rax, -0x18(%rbp)
cmpq $0x4, -0x18(%rbp)
jb 0x9b3d
leaq 0x1e71(%rip), %rdi      # 0xb99b
movb $0x0, %al
callq 0x3040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9c38
cmpq $0x1, -0x18(%rbp)
jne 0x9b5e
leaq 0x1e6e(%rip), %rdi      # 0xb9b9
movb $0x0, %al
callq 0x3040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9c38
leaq -0x38(%rbp), %rdi
callq 0x34a0
cmpq $0x2, -0x18(%rbp)
jne 0x9b9c
leaq 0x1e96(%rip), %rsi      # 0xba0b
leaq -0x38(%rbp), %rdi
callq 0x3470
jmp 0x9b80
jmp 0x9bbc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31e0
jmp 0x9c44
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rsi
decq %rsi
callq 0x50c0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x3030
jmp 0x9bba
jmp 0x9bbc
movq -0x78(%rbp), %rdi
movl $0x1, %esi
callq 0x50c0
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
callq 0x3130
jmp 0x9bd8
leaq -0x68(%rbp), %rdi
callq 0x3120
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3120
movq -0x80(%rbp), %rdi
movq %rax, %rsi
movl $0x45, %edx
callq 0x3510
movl %eax, -0x6c(%rbp)
cmpl $-0x1, -0x6c(%rbp)
jne 0x9c18
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x70(%rbp)
jmp 0x9c26
movl $0x0, -0x4(%rbp)
movl $0x1, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x31e0
leaq -0x38(%rbp), %rdi
callq 0x31e0
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3570
nopl (%rax)
// File: mukul-mehta[P]meta/builtins.cc
// Function: metash_unsetenv(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
int metash_unsetenv(vector<string> tokens) {
    size_t num_tokens = tokens.size();
    if (num_tokens >= 3) {
        printf("unsetenv: too many arguments\n");
        return -1;
    }

    if (num_tokens == 1) {
        printf("unsetenv: too few arguments\n");
        return -1;
    }

    string key = tokens[1];

    int status = unsetenv(key.c_str());
    if (status == -1)
        return -1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x5450
movq %rax, -0x18(%rbp)
cmpq $0x3, -0x18(%rbp)
jb 0x9c87
leaq 0x1d22(%rip), %rdi      # 0xb999
movb $0x0, %al
callq 0x3040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9d00
cmpq $0x1, -0x18(%rbp)
jne 0x9ca5
leaq 0x1d22(%rip), %rdi      # 0xb9b7
movb $0x0, %al
callq 0x3040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9d00
movq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x50c0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x3130
leaq -0x38(%rbp), %rdi
callq 0x3120
movq %rax, %rdi
callq 0x3490
movl %eax, -0x3c(%rbp)
cmpl $-0x1, -0x3c(%rbp)
jne 0x9ce9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x40(%rbp)
jmp 0x9cf7
movl $0x0, -0x4(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31e0
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: mukul-mehta[P]meta/builtins.cc
// Function: metash_getenv(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
int metash_getenv(vector<string> tokens) {
    size_t num_tokens = tokens.size();
    if (num_tokens >= 3) {
        printf("getenv: too many arguments\n");
        return -1;
    }

    if (num_tokens == 1) {
        printf("getenv: too few arguments\n");
        return -1;
    }

    string key = tokens[1];

    char* value = (char*)malloc(BUFSIZE * sizeof(char));
    value = getenv(key.c_str());

    if (value == NULL)
        value = (char*)"\0";

    printf("%s\n", value);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x5450
movq %rax, -0x18(%rbp)
cmpq $0x3, -0x18(%rbp)
jb 0x9d4a
leaq 0x1c9d(%rip), %rdi      # 0xb9d4
movb $0x0, %al
callq 0x3040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9df7
cmpq $0x1, -0x18(%rbp)
jne 0x9d6b
leaq 0x1c98(%rip), %rdi      # 0xb9f0
movb $0x0, %al
callq 0x3040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9df7
movq -0x58(%rbp), %rdi
movl $0x1, %esi
callq 0x50c0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x3130
movl $0x1000, %edi           # imm = 0x1000
callq 0x3460
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3120
movq %rax, %rdi
callq 0x33e0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x9dba
leaq 0x1c55(%rip), %rax      # 0xba0b
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
leaq 0x1af9(%rip), %rdi      # 0xb8be
xorl %eax, %eax
callq 0x3040
jmp 0x9dce
movl $0x0, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31e0
jmp 0x9df7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31e0
jmp 0x9e00
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3570
nopl (%rax)
// File: jvanns[P]verbatim/sub/lmdb/libraries/liblmdb/mdb_dump.c
// Function: text
static void text(MDB_val *v)
{
	unsigned char *c, *end;

	putchar(' ');
	c = v->mv_data;
	end = c + v->mv_size;
	while (c < end) {
		if (isprint(*c)) {
			putchar(*c);
		} else {
			putchar('\\');
			hex(*c);
		}
		c++;
	}
	putchar('\n');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
addq (%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2f8d
callq 0x2450
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x2f69
movq -0x10(%rbp), %rax
movzbl (%rax), %edi
callq 0x2040
jmp 0x2f7f
movl $0x5c, %edi
callq 0x2040
movq -0x10(%rbp), %rax
movzbl (%rax), %edi
callq 0x3010
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2f31
movl $0xa, %edi
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jvanns[P]verbatim/sub/lmdb/libraries/liblmdb/mdb_dump.c
// Function: byte
static void byte(MDB_val *v)
{
	unsigned char *c, *end;

	putchar(' ');
	c = v->mv_data;
	end = c + v->mv_size;
	while (c < end) {
		hex(*c++);
	}
	putchar('\n');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
addq (%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2ff4
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %edi
callq 0x3010
jmp 0x2fd1
movl $0xa, %edi
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wx-csy[P]librmq/main.cpp
// Function: main
int main() {
    functional_test<rmq_zkw>();
    functional_test<rmq_ind>();
    functional_test<rmq_block>();
    performance_test<rmq_zkw>(10000000, 10000000, 10);
    performance_test<rmq_st>(10000000, 10000000, 10);
    performance_test<rmq_ind>(10000000, 10000000, 10);
    performance_test<rmq_block>(10000000, 10000000, 10);
    return 0;
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
callq 0x1300
callq 0x1400
callq 0x1500
movl $0x989680, %esi         # imm = 0x989680
movl $0xa, %edx
movq %rsi, %rdi
callq 0x1600
movl $0x989680, %esi         # imm = 0x989680
movl $0xa, %edx
movq %rsi, %rdi
callq 0x1980
movl $0x989680, %esi         # imm = 0x989680
movl $0xa, %edx
movq %rsi, %rdi
callq 0x1d10
movl $0x989680, %esi         # imm = 0x989680
movl $0xa, %edx
movq %rsi, %rdi
callq 0x20a0
xorl %eax, %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
nop
// File: wx-csy[P]librmq/main.cpp
// Function: void functional_test<librmq::rmq_zkw>()
void functional_test() {
    for (int i = 0; i < 100; i++) 
        functional_test_instance<TSolver<int>>(gen() % 10 + 1);
    for (int i = 0; i < 100; i++) 
        functional_test_instance<TSolver<int>>(gen() % 50 + 1);
    for (int i = 0; i < 20; i++) 
        functional_test_instance<TSolver<int>>(gen() % 100000 + 1);
    for (int i = 0; i < 10; i++) 
        functional_test_instance<TSolver<int>>(gen() % 1000000 + 1);
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
cmpl $0x64, 0x14(%rsp)
jge 0x1341
leaq 0xf5d9e(%rip), %rdi     # 0xf70b8
callq 0x28e0
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
addq $0x1, %rdx
movl %edx, %edi
callq 0x25e0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x130c
movl $0x0, 0x10(%rsp)
cmpl $0x64, 0x10(%rsp)
jge 0x137e
leaq 0xf5d61(%rip), %rdi     # 0xf70b8
callq 0x28e0
movl $0x32, %ecx
xorl %edx, %edx
divq %rcx
addq $0x1, %rdx
movl %edx, %edi
callq 0x25e0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1349
movl $0x0, 0xc(%rsp)
cmpl $0x14, 0xc(%rsp)
jge 0x13bb
leaq 0xf5d24(%rip), %rdi     # 0xf70b8
callq 0x28e0
movl $0x186a0, %ecx          # imm = 0x186A0
xorl %edx, %edx
divq %rcx
addq $0x1, %rdx
movl %edx, %edi
callq 0x25e0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1386
movl $0x0, 0x8(%rsp)
cmpl $0xa, 0x8(%rsp)
jge 0x13f8
leaq 0xf5ce7(%rip), %rdi     # 0xf70b8
callq 0x28e0
movl $0xf4240, %ecx          # imm = 0xF4240
xorl %edx, %edx
divq %rcx
addq $0x1, %rdx
movl %edx, %edi
callq 0x25e0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x13c3
addq $0x18, %rsp
retq
nopl (%rax)
// File: wx-csy[P]librmq/./librmq/zkw.h
// Function: librmq::rmq_zkw<int>::rmq_zkw(unsigned long, int const*)
rmq_zkw(size_t n, const T *data) : n(n), data(data) {
        ntot = n;
        while (ntot & (ntot - 1)) ntot += ntot & -ntot;
        tr = new size_t[ntot << 1];
        std::iota(tr + ntot, tr + ntot + n, 0);
        std::fill(tr + ntot + n, tr + ntot + ntot, 0);
        for (size_t i = ntot - 1; i > 0; i--)
            tr[i] = data[tr[i<<1]] < data[tr[i<<1|1]] ? tr[i<<1] : tr[i<<1|1];
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x2a9d
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
xorl %edx, %edx
subq 0x8(%rax), %rdx
andq %rdx, %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
jmp 0x2a67
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
shlq %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rax), %rdi
movq 0x8(%rax), %rcx
shlq $0x3, %rcx
addq %rcx, %rdi
movq 0x18(%rax), %rsi
movq 0x8(%rax), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq 0x28(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
xorl %edx, %edx
callq 0x3150
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rax), %rcx
shlq $0x3, %rcx
addq %rcx, %rdi
movq 0x28(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rdi
movq 0x18(%rax), %rsi
movq 0x8(%rax), %rcx
shlq $0x3, %rcx
addq %rcx, %rsi
movq 0x8(%rax), %rax
shlq $0x3, %rax
addq %rax, %rsi
movl $0x0, 0x1c(%rsp)
leaq 0x1c(%rsp), %rdx
callq 0x31a0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jbe 0x2c0d
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x18(%rdx), %rcx
movq 0x10(%rsp), %rsi
shlq %rsi
movq (%rcx,%rsi,8), %rcx
movl (%rax,%rcx,4), %eax
movq 0x20(%rsp), %rcx
movq 0x18(%rdx), %rdx
movq 0x10(%rsp), %rsi
shlq %rsi
orq $0x1, %rsi
movq (%rdx,%rsi,8), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x2bc7
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
shlq %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x2be4
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
shlq %rcx
orq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rsp), %rdx
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2b65
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wx-csy[P]librmq/./librmq/zkw.h
// Function: librmq::rmq_zkw<int>::query(unsigned long, unsigned long)
size_t query(size_t l, size_t r) {
        size_t ret = l;
        l += ntot - 1;
        r += ntot;
        while (l ^ r ^ 1) {
            if ((~l & 1) && data[tr[l ^ 1]] < data[ret]) ret = tr[l ^ 1]; 
            if (( r & 1) && data[tr[r ^ 1]] < data[ret]) ret = tr[r ^ 1];
            l >>= 1;
            r >>= 1;
        }
        return ret;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rcx
movq %rcx, -0x20(%rsp)
movq 0x8(%rax), %rcx
subq $0x1, %rcx
addq -0x10(%rsp), %rcx
movq %rcx, -0x10(%rsp)
movq 0x8(%rax), %rax
addq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
xorq -0x18(%rsp), %rax
xorq $0x1, %rax
cmpq $0x0, %rax
je 0x2e38
movq -0x10(%rsp), %rax
xorq $-0x1, %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x2dc4
movq -0x28(%rsp), %rcx
movq 0x10(%rcx), %rax
movq 0x18(%rcx), %rdx
movq -0x10(%rsp), %rsi
xorq $0x1, %rsi
movq (%rdx,%rsi,8), %rdx
movl (%rax,%rdx,4), %eax
movq 0x10(%rcx), %rcx
movq -0x20(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x2dc4
movq -0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rsp), %rcx
xorq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x2e19
movq -0x28(%rsp), %rcx
movq 0x10(%rcx), %rax
movq 0x18(%rcx), %rdx
movq -0x18(%rsp), %rsi
xorq $0x1, %rsi
movq (%rdx,%rsi,8), %rdx
movl (%rax,%rdx,4), %eax
movq 0x10(%rcx), %rcx
movq -0x20(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x2e19
movq -0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rsp), %rcx
xorq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
shrq %rax
movq %rax, -0x10(%rsp)
movq -0x18(%rsp), %rax
shrq %rax
movq %rax, -0x18(%rsp)
jmp 0x2d53
movq -0x20(%rsp), %rax
retq
nop