LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jingdao[P]PointCloudApp/hashtable.cpp
// Function: HashTable::HashTable()
HashTable::HashTable() {
	//claims a section of the heap to be used as dummy variable
	this->dummy = (int*)malloc(sizeof(int));
	this->keys = (int*)malloc(INITIAL_TABLE_SIZE*sizeof(int));
	this->entries = (void**)malloc(INITIAL_TABLE_SIZE*sizeof(void*));
	this->size = INITIAL_TABLE_SIZE;
	this->load = 0;
	int i;
	for (i = 0; i < this->size; i++) {
		this->keys[i] = -1;
	}
	memset(this->entries,'\0',this->size*sizeof(void*));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r13
movl $0x4, %edi
callq 0x2270
movq %rax, (%r13)
movslq 0x50fd(%rip), %rbp      # 0xf228
leaq (,%rbp,4), %rbx
movq %rbx, %rdi
callq 0x2270
movq %rax, %r15
movq %rax, 0x8(%r13)
leaq (,%rbp,8), %r14
movq %r14, %rdi
callq 0x2270
movq %rax, %r12
movq %rax, 0x10(%r13)
movl %ebp, 0x18(%r13)
movl $0x0, 0x1c(%r13)
testq %rbp, %rbp
jle 0xa17a
movq %r15, %rdi
movl $0xff, %esi
movq %rbx, %rdx
callq 0x2100
movq %r12, %rdi
xorl %esi, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/jingdao[P]PointCloudApp/hashtable.cpp
// Function: HashTable::insert(int, void*)
bool HashTable::insert(int intKey, void* entry) {
	int h = baseHash(this->size, intKey);
	int step = stepHash(this->size, intKey);
	int i;
	for (i = 0; i < this->size; i++) {
		//printf("key: %d hash: %d\n", intKey, h);
		if (!this->entries[h] || this->entries[h] == this->dummy) {
			this->keys[h] = intKey;
			this->entries[h] = entry;
			this->load++;
			if (this->load>this->size / 4) {
				//printf("current load: %u/%u\n", this->load, this->size);
				doubleSize();
			}
			return true;
		}
		else if (this->keys[h] == intKey){
			return false;
		}
		else {
			h += step;
			h %= this->size;
		}
	}
	printf("Table overload (HashTable)!\n");
	return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x18(%rdi), %r8d
testl %r8d, %r8d
jle 0xa242
movq %rdx, %rcx
cvtsi2sd %r8d, %xmm0
cvtsi2sd %esi, %xmm1
movsd 0x5049(%rip), %xmm2     # 0xf220
mulsd %xmm1, %xmm2
cvttpd2dq %xmm2, %xmm3
cvtdq2pd %xmm3, %xmm3
subsd %xmm3, %xmm2
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %r9d
orl $0x1, %r9d
mulsd 0x501c(%rip), %xmm1     # 0xf218
cvttpd2dq %xmm1, %xmm2
cvtdq2pd %xmm2, %xmm2
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
movq 0x10(%rdi), %r10
movq (%rdi), %rbx
movq 0x8(%rdi), %r11
movl %r8d, %ebp
movslq %edx, %rax
movq (%r10,%rax,8), %r14
testq %r14, %r14
je 0xa257
cmpq %rbx, %r14
je 0xa257
cmpl %esi, (%r11,%rax,4)
je 0xa24e
addl %r9d, %edx
movl %edx, %eax
cltd
idivl %r8d
decl %ebp
jne 0xa21e
leaq 0x18c1(%rip), %rdi      # 0xbb0a
callq 0x2310
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl %esi, (%r11,%rax,4)
movq %rcx, (%r10,%rax,8)
movl 0x18(%rdi), %eax
movl 0x1c(%rdi), %ecx
leal 0x1(%rcx), %edx
leal 0x3(%rax), %esi
testl %eax, %eax
cmovnsl %eax, %esi
movl %edx, 0x1c(%rdi)
sarl $0x2, %esi
movb $0x1, %bl
cmpl %esi, %ecx
jl 0xa250
callq 0xa2d2
jmp 0xa250
nop
// File: /workspace/github_cpp_makefile_star2_O3/jingdao[P]PointCloudApp/hashtable.cpp
// Function: HashTable::doubleSize()
void HashTable::doubleSize() {
	//printf("Now doubling size of hash table\n");
	int newSize = this->size*2;
	int* newKeys = (int*)malloc(newSize * sizeof(int));
	void** newEntries = (void**)malloc(newSize*sizeof(void*));
	//printf("malloc double HashTable: %d\n",newSize * sizeof(int)+sizeof(void*));
	int* oldKeys = this->keys;
	void** oldEntries = this->entries;
	int oldSize = this->size;
	if (!newEntries||!newKeys) {
		printf("Warning(HashTable): Unable to resize table!\n");
		return;
	}
	this->keys = newKeys;
	this->entries = newEntries;
	this->size =newSize;
	this->load = 0;
	int i;
	for (i = 0; i < this->size; i++) {
		this->keys[i] = -1;
	}
	memset(this->entries,'\0',this->size*sizeof(void*));
	for (i = 0; i < oldSize; i++) {
		if (oldEntries[i] && oldEntries[i] != this->dummy)
			insert(oldKeys[i], oldEntries[i]);
	}
	free(oldKeys);
	free(oldEntries);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x18(%rdi), %r12
leaq (,%r12,8), %rdi
callq 0x2270
movq %rax, %r13
movq %r12, %rbp
shlq $0x4, %rbp
movq %rbp, %rdi
callq 0x2270
movq %rax, %rdi
testq %rax, %rax
setne %al
testq %r13, %r13
setne %cl
testb %al, %cl
je 0xa385
leal (%r12,%r12), %eax
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %r14
movq %r13, 0x8(%rbx)
movq %rdi, 0x10(%rbx)
movl %eax, 0x18(%rbx)
movl $0x0, 0x1c(%rbx)
testl %r12d, %r12d
jle 0xa39f
movl %eax, %edx
shlq $0x2, %rdx
movq %rdi, (%rsp)
movq %r13, %rdi
movl $0xff, %esi
callq 0x2100
xorl %r13d, %r13d
movq (%rsp), %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x2100
movq (%r14,%r13,8), %rdx
testq %rdx, %rdx
je 0xa37b
cmpq (%rbx), %rdx
je 0xa37b
movl (%r15,%r13,4), %esi
movq %rbx, %rdi
callq 0xa1b6
incq %r13
cmpq %r13, %r12
jne 0xa361
jmp 0xa3a9
leaq 0x1752(%rip), %rdi      # 0xbade
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2310
xorl %esi, %esi
movq %rbp, %rdx
callq 0x2100
movq %r15, %rdi
callq 0x2240
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O3/jingdao[P]PointCloudApp/hashtable.cpp
// Function: HashTable::find(int)
void* HashTable::find(int intKey) {
	int h = baseHash(this->size, intKey);
	int step = stepHash(this->size, intKey);
	int i;
	for (i = 0; i < this->size; i++) {
		//printf("key: %d hash: %d\n", intKey, h);
		if (!this->entries[h]) {
			return NULL;
		}
		else if (this->keys[h] == intKey){
			return this->entries[h];
		}
		else {
			h += step;
			h %= this->size;
		}
	}
	printf("Table overload (HashTable)!\n");
	return NULL;
}

// Assembly:
pushq %rax
movl 0x18(%rdi), %ecx
testl %ecx, %ecx
jle 0xa443
cvtsi2sd %ecx, %xmm0
cvtsi2sd %esi, %xmm1
movsd 0x4e40(%rip), %xmm2     # 0xf220
mulsd %xmm1, %xmm2
cvttpd2dq %xmm2, %xmm3
cvtdq2pd %xmm3, %xmm3
subsd %xmm3, %xmm2
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %r8d
mulsd 0x4e17(%rip), %xmm1     # 0xf218
cvttpd2dq %xmm1, %xmm2
cvtdq2pd %xmm2, %xmm2
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
orl $0x1, %r8d
movq 0x8(%rdi), %r9
movq 0x10(%rdi), %rdi
movl %ecx, %r10d
movslq %edx, %r11
movq (%rdi,%r11,8), %rax
testq %rax, %rax
je 0xa44f
cmpl %esi, (%r9,%r11,4)
je 0xa451
addl %r8d, %edx
movl %edx, %eax
cltd
idivl %ecx
decl %r10d
jne 0xa424
leaq 0x16c0(%rip), %rdi      # 0xbb0a
callq 0x2310
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jingdao[P]PointCloudApp/hashtable.cpp
// Function: HashTable::remove(int)
void* HashTable::remove(int intKey) {
	int h = baseHash(this->size, intKey);
	int step = stepHash(this->size, intKey);
	int i;
	void* removedItem;
	for (i = 0; i < this->size; i++) {
		//printf("key: %d hash: %d\n", intKey, h);
		if (!this->entries[h]) {
			return NULL;
		}
		else if (this->entries[h]!=this->dummy && this->keys[h] == intKey ){
			this->keys[h] = -1;
			removedItem = this->entries[h];
			this->entries[h] = this->dummy;
			this->load--;
			return removedItem;
		}
		else {
			h += step;
			h %= this->size;
		}
	}
	printf("Table overload (HashTable)!\n");
	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x18(%rdi), %ecx
testl %ecx, %ecx
jle 0xa4d8
cvtsi2sd %ecx, %xmm0
cvtsi2sd %esi, %xmm1
movsd 0x4db1(%rip), %xmm2     # 0xf220
mulsd %xmm1, %xmm2
cvttpd2dq %xmm2, %xmm3
cvtdq2pd %xmm3, %xmm3
subsd %xmm3, %xmm2
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %r8d
orl $0x1, %r8d
mulsd 0x4d84(%rip), %xmm1     # 0xf218
cvttpd2dq %xmm1, %xmm2
cvtdq2pd %xmm2, %xmm2
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
movq 0x10(%rdi), %r9
movq (%rdi), %r10
movq 0x8(%rdi), %r11
movl %ecx, %ebx
movslq %edx, %r14
movq (%r9,%r14,8), %rax
testq %rax, %rax
je 0xa4e4
cmpq %r10, %rax
je 0xa4cc
cmpl %esi, (%r11,%r14,4)
je 0xa4ee
addl %r8d, %edx
movl %edx, %eax
cltd
idivl %ecx
decl %ebx
jne 0xa4b5
leaq 0x162b(%rip), %rdi      # 0xbb0a
callq 0x2310
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xffffffff, (%r11,%r14,4) # imm = 0xFFFFFFFF
movq %r10, (%r9,%r14,8)
decl 0x1c(%rdi)
jmp 0xa4e6
nop
// File: /workspace/github_cpp_makefile_star2_O3/jingdao[P]PointCloudApp/hashtable.cpp
// Function: HashTable::insert(void*, int, void*)
int HashTable::getIntKey(char* inputString, int len) {
	//djb2 algorithm http://www.cse.yorku.ca/~oz/hash.html
	int h = STRING_HASH_CONSTANT;
	for (int i=0;i<len;i++) {
		unsigned int c = *inputString++;
		h = (h << 5) + h + c;
	}
	if (h<0) h=-h;
	return h;
}

// Assembly:
movl 0x4d09(%rip), %r9d      # 0xf210
testl %edx, %edx
jle 0xa52e
movl %edx, %edx
xorl %r8d, %r8d
movl %r9d, %eax
movsbl (%rsi,%r8), %r10d
shll $0x5, %eax
addl %r9d, %eax
addl %r10d, %eax
incq %r8
movl %eax, %r9d
cmpl %r8d, %edx
jne 0xa513
jmp 0xa531
movl %r9d, %eax
movl %eax, %esi
negl %esi
cmovsl %eax, %esi
movq %rcx, %rdx
jmp 0xa1b6
// File: /workspace/github_cpp_makefile_star2_O3/yukioc[P]tscrpt/tscrpt.cpp
// Function: obj_t::value()
int obj_t::value(){
	switch(type){
		case 'N': break;
		case 'S': num=(int)strtol(_str.c_str(),NULL,0); break;
		default: assert(0);
	}
	return num;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzbl (%rdi), %eax
cmpl $0x53, %eax
je 0x2622
cmpl $0x4e, %eax
jne 0x2634
movl 0x28(%rbx), %eax
jmp 0x2632
movq 0x8(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21a0
movl %eax, 0x28(%rbx)
popq %rbx
retq
leaq 0x51f7(%rip), %rdi      # 0x7832
leaq 0x4d85(%rip), %rsi      # 0x73c7
leaq 0x49e7(%rip), %rcx      # 0x7030
movl $0x20, %edx
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/yukioc[P]tscrpt/tscrpt.cpp
// Function: obj_t::str[abi:cxx11]()
std::string& obj_t::str(){
	switch(type){
		case 'N': _str=itos(num); break;
		case 'S': break;
		case '$': _str='$'; break;
		default: assert(0); break;
	}
	return _str;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
movzbl (%rdi), %eax
cmpl $0x24, %eax
je 0x26f4
cmpl $0x53, %eax
je 0x270e
cmpl $0x4e, %eax
jne 0x2721
movl 0x28(%rbx), %ebp
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x2180
movq %r14, %rdi
movl %ebp, %esi
callq 0x2230
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x21e0
movq 0x7918(%rip), %rsi      # 0x9fc8
leaq 0x28(%rsp), %rdi
callq 0x20f0
leaq 0x98(%rsp), %rdi
callq 0x20a0
leaq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x2170
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x270e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
jmp 0x270e
leaq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rdx
movl $0x1, %ecx
xorl %esi, %esi
movl $0x24, %r8d
callq 0x2260
addq $0x8, %rbx
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x510a(%rip), %rdi      # 0x7832
leaq 0x4c98(%rip), %rsi      # 0x73c7
leaq 0x490d(%rip), %rcx      # 0x7043
movl $0x29, %edx
callq 0x2100
movq %rax, %rbx
movq 0x787e(%rip), %rsi      # 0x9fc8
leaq 0x28(%rsp), %rdi
callq 0x20f0
leaq 0x98(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O3/yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::eval(char const*)
obj_t* tscrpt_t::eval(const char* s) {
	std::list<obj_t*> objs;
	scan(&objs,s);
	obj_t* o=parse(&objs);
	return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rdx
movq %rdi, %r15
leaq 0x8(%rsp), %rbx
movq %rbx, 0x8(%rbx)
movq %rbx, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rsi
callq 0x2878
leaq 0x8(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x2cbe
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x283f
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x2150
movq %rbx, %rdi
cmpq %r14, %rbx
jne 0x282a
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x284e
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x2870
movq (%rdi), %r15
movl $0x18, %esi
callq 0x2150
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x285b
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::parse(std::__cxx11::list<obj_t*, std::allocator<obj_t*>>*)
obj_t* tscrpt_t::parse(std::list<obj_t*>* olist) {
	if(olist==0) throw std::logic_error("parse: received obj is null");
	assert(objs==0);
	objs=olist;
	obj_t* ret=0;
	while(more() && !is('$')){
		delete ret;
		ret=expr();
	}
	assert(objs->empty());
	objs=0;
	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x2d57
movq %rdi, %rbx
cmpq $0x0, (%rdi)
jne 0x2d89
movq %rsi, (%rbx)
cmpq %rsi, (%rsi)
je 0x2d38
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x24, %esi
movl $0x1, %edx
callq 0x2ff2
testb %al, %al
jne 0x2d3d
testq %r14, %r14
je 0x2d16
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x2d16
movq (%rax), %rsi
incq %rsi
callq 0x2150
movl $0x30, %esi
movq %r14, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x30aa
movq %rax, %r14
movq (%rbx), %rax
cmpq %rax, (%rax)
jne 0x2ce3
jmp 0x2d45
xorl %r14d, %r14d
jmp 0x2d45
movq (%rbx), %rax
cmpq %rax, (%rax)
jne 0x2da8
movq $0x0, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x439d(%rip), %rsi      # 0x7108
movq %rax, %rdi
callq 0x21b0
movq 0x7266(%rip), %rsi      # 0x9fe0
movq 0x724f(%rip), %rdx      # 0x9fd0
movq %rbx, %rdi
callq 0x2220
leaq 0x4394(%rip), %rdi      # 0x7124
leaq 0x4630(%rip), %rsi      # 0x73c7
leaq 0x438e(%rip), %rcx      # 0x712c
movl $0x67, %edx
callq 0x2100
leaq 0x43aa(%rip), %rdi      # 0x7159
leaq 0x4611(%rip), %rsi      # 0x73c7
leaq 0x436f(%rip), %rcx      # 0x712c
movl $0x6e, %edx
callq 0x2100
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::is(char, bool)
bool tscrpt_t::is(char c,bool eat) {
	if (objs->empty()) throw std::runtime_error( "is: not found next token" );
	obj_t* o=objs->front();
	bool chk(c==o->type);
	if (eat && chk){
		objs->pop_front();
		delete o;
	}
	return chk;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq (%rax), %r15
cmpq %rax, %r15
je 0x3065
movl %esi, %ebx
movq 0x10(%r15), %r14
movb (%r14), %bpl
testb %dl, %dl
je 0x3054
cmpb %bl, %bpl
jne 0x3054
decq 0x10(%rax)
movq %r15, %rdi
callq 0x2200
movl $0x18, %esi
movq %r15, %rdi
callq 0x2150
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x3047
movq (%rax), %rsi
incq %rsi
callq 0x2150
movl $0x30, %esi
movq %r14, %rdi
callq 0x2150
cmpb %bl, %bpl
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x4108(%rip), %rsi      # 0x7181
movq %rax, %rdi
callq 0x20b0
movq 0x6f70(%rip), %rsi      # 0x9ff8
movq 0x6f31(%rip), %rdx      # 0x9fc0
movq %rbx, %rdi
callq 0x2220
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::expr()
obj_t* tscrpt_t::expr() {
	obj_t *o=term();
	while(more()){ // add,sub
		obj_t *l(0),*r(0);
		if     (is('+')){ o=add(l=o, r=term()); }
		else if(is('-')){ o=sub(l=o, r=term()); }
		else break;
		delete l;
		delete r;
	}
	return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x327a
movq %rax, %r14
movq (%rbx), %rax
cmpq %rax, (%rax)
je 0x3184
movq %r14, %r15
movq %rbx, %rdi
movl $0x2b, %esi
movl $0x1, %edx
callq 0x2ff2
movq %rbx, %rdi
testb %al, %al
je 0x30fa
callq 0x327a
movq %rax, %r12
movq %r15, %rsi
movq %rax, %rdx
callq 0x3412
jmp 0x3123
movl $0x2d, %esi
movl $0x1, %edx
callq 0x2ff2
testb %al, %al
je 0x3181
movq %rbx, %rdi
callq 0x327a
movq %rax, %r12
movq %r15, %rsi
movq %rax, %rdx
callq 0x357c
movq %rax, %r14
testq %r15, %r15
je 0x3143
movq 0x8(%r15), %rdi
leaq 0x18(%r15), %rax
cmpq %rax, %rdi
je 0x3143
movq (%rax), %rsi
incq %rsi
callq 0x2150
movl $0x30, %esi
movq %r15, %rdi
callq 0x2150
testq %r12, %r12
je 0x316f
movq 0x8(%r12), %rdi
leaq 0x18(%r12), %rax
cmpq %rax, %rdi
je 0x316f
movq (%rax), %rsi
incq %rsi
callq 0x2150
movl $0x30, %esi
movq %r12, %rdi
callq 0x2150
jmp 0x30bd
movq %r15, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::obj()
obj_t* tscrpt_t::obj() {
	if (objs->empty()) throw std::runtime_error( "obj: not found next token" );
	obj_t* o(objs->front());
	objs->pop_front();
	return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq (%rax), %rbx
cmpq %rax, %rbx
je 0x31cb
movq 0x10(%rbx), %r14
decq 0x10(%rax)
movq %rbx, %rdi
callq 0x2200
movl $0x18, %esi
movq %rbx, %rdi
callq 0x2150
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x3f88(%rip), %rsi      # 0x7167
movq %rax, %rdi
callq 0x20b0
movq 0x6e0a(%rip), %rsi      # 0x9ff8
movq 0x6dcb(%rip), %rdx      # 0x9fc0
movq %rbx, %rdi
callq 0x2220
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::term()
obj_t* tscrpt_t::term() {
	obj_t *o(factor());
	while(more()){ // mul,div
		obj_t *l(0),*r(0);
		try {
			if     (is('*')){ o=mul(l=o, r=factor()); }
			else if(is('/')){ o=div(l=o, r=factor()); }
			else if(is('%')){ o=rem(l=o, r=factor()); }
			else break;
		}catch(std::runtime_error& e){
			delete l;
			delete r;
			clear();
			throw;
		}
		delete l;
		delete r;
	}
	return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3632
movq %rax, %r12
movq (%rbx), %rax
cmpq %rax, (%rax)
je 0x33b6
movq %r12, %r14
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x2a, %esi
movl $0x1, %edx
callq 0x2ff2
testb %al, %al
je 0x32dd
movq %r14, %r13
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x3632
movq %rax, %r15
movq %r14, %r13
movq %rax, %rbp
movq %r14, %rsi
movq %rax, %rdx
callq 0x37ec
jmp 0x3357
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x2f, %esi
movl $0x1, %edx
callq 0x2ff2
testb %al, %al
je 0x331b
movq %r14, %r13
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x3632
movq %rax, %r15
movq %r14, %r13
movq %rax, %rbp
movq %r14, %rsi
movq %rax, %rdx
callq 0x392c
jmp 0x3357
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x25, %esi
movl $0x1, %edx
callq 0x2ff2
testb %al, %al
je 0x33b3
movq %r14, %r13
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x3632
movq %rax, %r15
movq %r14, %r13
movq %rax, %rbp
movq %r14, %rsi
movq %rax, %rdx
callq 0x3a3c
movq %rax, %r12
testq %r14, %r14
je 0x3377
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x3377
movq (%rax), %rsi
incq %rsi
callq 0x2150
movl $0x30, %esi
movq %r14, %rdi
callq 0x2150
testq %r15, %r15
je 0x33a1
movq 0x8(%r15), %rdi
leaq 0x18(%r15), %rax
cmpq %rax, %rdi
je 0x33a1
movq (%rax), %rsi
incq %rsi
callq 0x2150
movl $0x30, %esi
movq %r15, %rdi
callq 0x2150
jmp 0x3290
movq %r14, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x3402
movq %r14, %rdi
movl %edx, %esi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x2280
movl $0x30, %esi
movq %rbp, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2782
callq 0x21c0
movq %rax, %r14
callq 0x2210
movq %r14, %rdi
callq 0x2240
movq %rax, %rdi
callq 0x3b4c
// File: /workspace/github_cpp_makefile_star2_O3/yukioc[P]tscrpt/tscrpt.cpp
// Function: tscrpt_t::add(obj_t*, obj_t*)
obj_t* tscrpt_t::add(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', l->str() + r->str());
	}else assert(0);
	return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
cmpl $0x9, 0x6d1f(%rip)      # 0xa148
jl 0x3452
movq %r15, %rdi
callq 0x2654
movq (%rax), %rbx
movq %r14, %rdi
callq 0x2654
movq (%rax), %rdx
leaq 0x3d9a(%rip), %rdi      # 0x71e2
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2040
movzbl (%r15), %eax
cmpl $0x53, %eax
je 0x34a1
cmpl $0x4e, %eax
jne 0x3525
movl $0x30, %edi
callq 0x2140
movq %rax, %rbx
movq %r15, %rdi
callq 0x260c
movl %eax, %ebp
movq %r14, %rdi
callq 0x260c
addl %ebp, %eax
movb $0x4e, (%rbx)
leaq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movl %eax, 0x28(%rbx)
jmp 0x3517
movl $0x30, %edi
callq 0x2140
movq %rax, %rbx
movq %r15, %rdi
callq 0x2654
movq %rax, %r15
movq %r14, %rdi
callq 0x2654
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3b57
movb $0x53, (%rbx)
leaq 0x8(%rbx), %rdi
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x8(%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
callq 0x3c86
movl $0x0, 0x28(%rbx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3517
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4306(%rip), %rdi      # 0x7832
leaq 0x3e94(%rip), %rsi      # 0x73c7
leaq 0x3cb6(%rip), %rcx      # 0x71f0
movl $0xcd, %edx
callq 0x2100
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3567
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
jmp 0x3567
movq %rax, %r14
movl $0x30, %esi
movq %rbx, %rdi
callq 0x2150
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x9, 0x6bb8(%rip)      # 0xa148
jl 0x35b9
movq %r14, %rdi
callq 0x2654
movq (%rax), %r15
movq %rbx, %rdi
callq 0x2654
movq (%rax), %rdx
leaq 0x3c68(%rip), %rdi      # 0x7217
movq %r15, %rsi
xorl %eax, %eax
callq 0x2040
movzbl (%r14), %eax
cmpl $0x53, %eax
je 0x35c7
cmpl $0x4e, %eax
jne 0x3613
movl $0x30, %edi
callq 0x2140
movq %rax, %r15
movq %r14, %rdi
callq 0x260c
movl %eax, %ebp
movq %rbx, %rdi
callq 0x260c
subl %eax, %ebp
movb $0x4e, (%r15)
leaq 0x18(%r15), %rax
movq %rax, 0x8(%r15)
movq $0x0, 0x10(%r15)
movb $0x0, 0x18(%r15)
movl %ebp, 0x28(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4218(%rip), %rdi      # 0x7832
leaq 0x3da6(%rip), %rsi      # 0x73c7
leaq 0x3bfd(%rip), %rcx      # 0x7225
movl $0xd5, %edx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl $0x2b, %esi
movl $0x1, %edx
callq 0x2ff2
testb %al, %al
je 0x3656
xorl %ebp, %ebp
jmp 0x366a
movq %rbx, %rdi
movl $0x2d, %esi
movl $0x1, %edx
callq 0x2ff2
movl %eax, %ebp
movq %rbx, %rdi
movl $0x28, %esi
movl $0x1, %edx
callq 0x2ff2
movq %rbx, %rdi
testb %al, %al
je 0x369a
callq 0x30aa
movq %rax, %r14
movq %rbx, %rdi
movl $0x29, %esi
callq 0x3218
jmp 0x36e3
movl $0x49, %esi
xorl %edx, %edx
callq 0x2ff2
testb %al, %al
jne 0x376c
movq %rbx, %rdi
movl $0x4e, %esi
xorl %edx, %edx
callq 0x2ff2
testb %al, %al
jne 0x36d8
movq %rbx, %rdi
movl $0x53, %esi
xorl %edx, %edx
callq 0x2ff2
testb %al, %al
je 0x378b
movq %rbx, %rdi
callq 0x3194
movq %rax, %r14
testb %bpl, %bpl
je 0x375e
leaq 0x20(%rsp), %r15
movb $0x4e, -0x18(%r15)
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movl $0xffffffff, 0x10(%r15) # imm = 0xFFFFFFFF
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x37ec
movq %rax, %rbx
testq %r14, %r14
je 0x3737
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x3737
movq (%rax), %rsi
incq %rsi
callq 0x2150
movl $0x30, %esi
movq %r14, %rdi
callq 0x2150
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x375b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %r14
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x40bf(%rip), %rdi      # 0x7832
leaq 0x3c4d(%rip), %rsi      # 0x73c7
leaq 0x3a32(%rip), %rcx      # 0x71b3
movl $0xbb, %edx
callq 0x2100
movl $0x10, %edi
callq 0x20e0
movq %rax, %r14
leaq 0x3a2e(%rip), %rsi      # 0x71cd
movq %rax, %rdi
callq 0x20b0
movq 0x684a(%rip), %rsi      # 0x9ff8
movq 0x680b(%rip), %rdx      # 0x9fc0
movq %r14, %rdi
callq 0x2220
movq %rax, %rbx
movq %r14, %rdi
callq 0x2120
jmp 0x37e4
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x37e4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
cmpl $0x9, 0x6947(%rip)      # 0xa148
jl 0x382a
movq %rbx, %rdi
callq 0x2654
movq (%rax), %r14
movq %r15, %rdi
callq 0x2654
movq (%rax), %rdx
leaq 0x3a2c(%rip), %rdi      # 0x724c
movq %r14, %rsi
xorl %eax, %eax
callq 0x2040
movzbl (%rbx), %eax
cmpl $0x53, %eax
je 0x387c
cmpl $0x4e, %eax
jne 0x38f4
movl $0x30, %edi
callq 0x2140
movq %rax, %r14
movq %rbx, %rdi
callq 0x260c
movl %eax, %ebx
movq %r15, %rdi
callq 0x260c
imull %ebx, %eax
movb $0x4e, (%r14)
leaq 0x18(%r14), %rcx
movq %rcx, 0x8(%r14)
movq $0x0, 0x10(%r14)
movb $0x0, 0x18(%r14)
movl %eax, 0x28(%r14)
jmp 0x38e8
movl $0x30, %edi
callq 0x2140
movq %rax, %r14
movb $0x53, (%rax)
leaq 0x8(%rax), %rdi
addq $0x18, %rax
movq %rax, 0x8(%r14)
leaq 0x3b25(%rip), %rdx      # 0x73c4
movq %rdx, %rsi
callq 0x3bb2
movl $0x0, 0x28(%r14)
movq %r14, %rdi
callq 0x2654
movq %rax, %r12
movq %r15, %rdi
callq 0x260c
testl %eax, %eax
jle 0x38e8
movl %eax, %ebp
incl %ebp
movq %rbx, %rdi
callq 0x2654
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r12, %rdi
callq 0x2090
decl %ebp
cmpl $0x1, %ebp
ja 0x38ca
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3f37(%rip), %rdi      # 0x7832
leaq 0x3ac5(%rip), %rsi      # 0x73c7
leaq 0x3951(%rip), %rcx      # 0x725a
movl $0xe1, %edx
callq 0x2100
movq %rax, %rbx
movl $0x30, %esi
movq %r14, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x9, 0x6808(%rip)      # 0xa148
jl 0x3969
movq %r14, %rdi
callq 0x2654
movq (%rax), %r15
movq %rbx, %rdi
callq 0x2654
movq (%rax), %rdx
leaq 0x3922(%rip), %rdi      # 0x7281
movq %r15, %rsi
xorl %eax, %eax
callq 0x2040
movzbl (%r14), %eax
cmpl $0x53, %eax
je 0x397b
cmpl $0x4e, %eax
jne 0x3a0a
movq %rbx, %rdi
callq 0x260c
testl %eax, %eax
je 0x39d8
movl $0x30, %edi
callq 0x2140
movq %rax, %r15
movq %r14, %rdi
callq 0x260c
movl %eax, %ebp
movq %rbx, %rdi
callq 0x260c
movl %eax, %ecx
movl %ebp, %eax
cltd
idivl %ecx
movb $0x4e, (%r15)
leaq 0x18(%r15), %rcx
movq %rcx, 0x8(%r15)
movq $0x0, 0x10(%r15)
movb $0x0, 0x18(%r15)
movl %eax, 0x28(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x38a3(%rip), %rsi      # 0x728f
movq %rax, %rdi
callq 0x20b0
movq 0x65fd(%rip), %rsi      # 0x9ff8
movq 0x65be(%rip), %rdx      # 0x9fc0
movq %rbx, %rdi
callq 0x2220
leaq 0x3e21(%rip), %rdi      # 0x7832
leaq 0x39af(%rip), %rsi      # 0x73c7
leaq 0x3884(%rip), %rcx      # 0x72a3
movl $0xea, %edx
callq 0x2100
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x9, 0x66f8(%rip)      # 0xa148
jl 0x3a79
movq %r14, %rdi
callq 0x2654
movq (%rax), %r15
movq %rbx, %rdi
callq 0x2654
movq (%rax), %rdx
leaq 0x385b(%rip), %rdi      # 0x72ca
movq %r15, %rsi
xorl %eax, %eax
callq 0x2040
movzbl (%r14), %eax
cmpl $0x53, %eax
je 0x3a8b
cmpl $0x4e, %eax
jne 0x3b1a
movq %rbx, %rdi
callq 0x260c
testl %eax, %eax
je 0x3ae8
movl $0x30, %edi
callq 0x2140
movq %rax, %r15
movq %r14, %rdi
callq 0x260c
movl %eax, %ebp
movq %rbx, %rdi
callq 0x260c
movl %eax, %ecx
movl %ebp, %eax
cltd
idivl %ecx
movb $0x4e, (%r15)
leaq 0x18(%r15), %rax
movq %rax, 0x8(%r15)
movq $0x0, 0x10(%r15)
movb $0x0, 0x18(%r15)
movl %edx, 0x28(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x3793(%rip), %rsi      # 0x728f
movq %rax, %rdi
callq 0x20b0
movq 0x64ed(%rip), %rsi      # 0x9ff8
movq 0x64ae(%rip), %rdx      # 0x9fc0
movq %rbx, %rdi
callq 0x2220
leaq 0x3d11(%rip), %rdi      # 0x7832
leaq 0x389f(%rip), %rsi      # 0x73c7
leaq 0x37aa(%rip), %rcx      # 0x72d9
movl $0xf3, %edx
callq 0x2100
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/yukioc[P]tscrpt/t-tscrpt.cpp
// Function: main
int main(int argc, char* argv[])
{
//	symbol_table.insert(symbol(":"));

	mu_run_test(t_estrndup);
	mu_run_test(t_number);
	mu_run_test(t_string);
	mu_run_test(t_unaryop);
	mu_run_test(t_mul);
	mu_run_test(t_div);
	mu_run_test(t_rem);
	mu_run_test(t_add);
	mu_run_test(t_sub);
	mu_show_failures();
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x343b(%rip), %ebx      # 0xa16c
incl 0x3439(%rip)            # 0xa170
callq 0x3d1c
cmpl 0x342a(%rip), %ebx      # 0xa16c
leaq 0xc8b(%rip), %r15       # 0x79d4
leaq 0xc8b(%rip), %rbx       # 0x79db
movq %rbx, %rdx
cmoveq %r15, %rdx
leaq 0xc57(%rip), %r14       # 0x79b5
leaq 0xc64(%rip), %rsi       # 0x79c9
movq %r14, %rdi
xorl %eax, %eax
callq 0x2040
movl 0x33f7(%rip), %ebp      # 0xa16c
incl 0x33f5(%rip)            # 0xa170
callq 0x45d5
cmpl 0x33e6(%rip), %ebp      # 0xa16c
movq %rbx, %rdx
cmoveq %r15, %rdx
leaq 0xc4e(%rip), %rsi       # 0x79e2
movq %r14, %rdi
xorl %eax, %eax
callq 0x2040
movl 0x33c8(%rip), %ebp      # 0xa16c
incl 0x33c6(%rip)            # 0xa170
callq 0x491f
cmpl 0x33b7(%rip), %ebp      # 0xa16c
movq %rbx, %rdx
cmoveq %r15, %rdx
leaq 0xc28(%rip), %rsi       # 0x79eb
movq %r14, %rdi
xorl %eax, %eax
callq 0x2040
movl 0x3399(%rip), %ebp      # 0xa16c
incl 0x3397(%rip)            # 0xa170
callq 0x4c4b
cmpl 0x3388(%rip), %ebp      # 0xa16c
movq %rbx, %rdx
cmoveq %r15, %rdx
leaq 0xc02(%rip), %rsi       # 0x79f4
movq %r14, %rdi
xorl %eax, %eax
callq 0x2040
movl 0x336a(%rip), %ebp      # 0xa16c
incl 0x3368(%rip)            # 0xa170
callq 0x4f4d
cmpl 0x3359(%rip), %ebp      # 0xa16c
movq %rbx, %rdx
cmoveq %r15, %rdx
leaq 0xbdd(%rip), %rsi       # 0x79fe
movq %r14, %rdi
xorl %eax, %eax
callq 0x2040
movl 0x333b(%rip), %ebp      # 0xa16c
incl 0x3339(%rip)            # 0xa170
callq 0x561b
cmpl 0x332a(%rip), %ebp      # 0xa16c
movq %rbx, %rdx
cmoveq %r15, %rdx
leaq 0xbb4(%rip), %rsi       # 0x7a04
movq %r14, %rdi
xorl %eax, %eax
callq 0x2040
movl 0x330c(%rip), %ebp      # 0xa16c
incl 0x330a(%rip)            # 0xa170
callq 0x59f3
cmpl 0x32fb(%rip), %ebp      # 0xa16c
movq %rbx, %rdx
cmoveq %r15, %rdx
leaq 0xb8b(%rip), %rsi       # 0x7a0a
movq %r14, %rdi
xorl %eax, %eax
callq 0x2040
movl 0x32dd(%rip), %ebp      # 0xa16c
incl 0x32db(%rip)            # 0xa170
callq 0x5f68
cmpl 0x32cc(%rip), %ebp      # 0xa16c
movq %rbx, %rdx
cmoveq %r15, %rdx
leaq 0xb62(%rip), %rsi       # 0x7a10
movq %r14, %rdi
xorl %eax, %eax
callq 0x2040
movl 0x32ae(%rip), %ebp      # 0xa16c
incl 0x32ac(%rip)            # 0xa170
callq 0x6662
cmpl 0x329d(%rip), %ebp      # 0xa16c
cmoveq %r15, %rbx
leaq 0xb3c(%rip), %rsi       # 0x7a16
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2040
movl 0x327f(%rip), %esi      # 0xa16c
movl 0x3281(%rip), %edx      # 0xa174
movl 0x3277(%rip), %ecx      # 0xa170
leaq 0xb1c(%rip), %rdi       # 0x7a1c
xorl %eax, %eax
callq 0x2040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r12
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rax, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq 0x8(%rsi), %rbp
subq (%rsi), %rbp
movq %rdi, 0x20(%rsp)
je 0x3f85
movq %rsi, %r14
sarq $0x5, %rbp
cmpq $0x1, %rbp
adcq $0x0, %rbp
xorl %ebx, %ebx
movq %rbx, %r13
shlq $0x5, %r13
movq (%r14), %rdi
addq %r13, %rdi
leaq 0x22cd(%rip), %rsi      # 0x61df
callq 0x20b0
testl %eax, %eax
je 0x3f2b
addq (%r14), %r13
movq %rsp, %rdi
movq %r13, %rsi
callq 0x4008
jmp 0x3f79
movq %r12, %rdi
movq %rsp, %rsi
callq 0x4046
movq (%rsp), %r13
movq 0x8(%rsp), %r15
cmpq %r13, %r15
je 0x3f79
leaq 0x10(%r13), %r12
movq -0x10(%r12), %rdi
cmpq %rdi, %r12
je 0x3f5e
movq (%r12), %rsi
incq %rsi
callq 0x2290
leaq 0x20(%r12), %rax
addq $0x10, %r12
cmpq %r15, %r12
movq %rax, %r12
jne 0x3f48
movq %r13, 0x8(%rsp)
movq 0x20(%rsp), %r12
incq %rbx
cmpq %rbp, %rbx
jne 0x3efe
movq %rsp, %rsi
movq %r12, %rdi
callq 0x4046
movq %rsp, %rdi
callq 0x366c
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3fac
movq %rax, %r14
movq %rsp, %rdi
callq 0x366c
movq 0x20(%rsp), %rdi
callq 0x3754
movq %r14, %rdi
callq 0x2490
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x400, %edi            # imm = 0x400
callq 0x2380
movq %rax, %rbx
cmpq $0x400, %r14            # imm = 0x400
jg 0x4524
leaq 0x1db4(%rip), %rsi      # 0x62d0
movq %rbx, %rdi
movl %r14d, %edx
jmp 0x455d
cvtsi2sd %r14, %xmm0
cmpq $0x100000, %r14         # imm = 0x100000
ja 0x4547
mulsd 0x1d8e(%rip), %xmm0     # 0x62c8
cvttsd2si %xmm0, %edx
leaq 0x1d8f(%rip), %rsi      # 0x62d4
jmp 0x455a
mulsd 0x1d71(%rip), %xmm0     # 0x62c0
cvttsd2si %xmm0, %edx
leaq 0x1d7f(%rip), %rsi      # 0x62d9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2070
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movabsq $0x1845c8a0ce512957, %rcx # imm = 0x1845C8A0CE512957
movq %rdi, %rax
imulq %rcx
movq %rdx, %r12
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xd, %r12
addq %rax, %r12
movabsq $0x1518000000000, %rcx  # imm = 0x1518000000000
imulq %r12, %rcx
sarq $0x20, %rcx
movq %rdi, %rax
subq %rcx, %rax
movabsq $0x48d159e26af37c05, %rcx # imm = 0x48D159E26AF37C05
imulq %rcx
movq %rdx, %r14
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xa, %r14
addq %rax, %r14
movabsq $0xe1000000000, %rax    # imm = 0xE1000000000
imulq %r14, %rax
sarq $0x20, %rax
subq %rax, %rdi
movabsq $-0x7777777777777777, %rcx # imm = 0x8888888888888889
movq %rdi, %rax
imulq %rcx
movq %rdx, %r15
addq %rdi, %r15
movq %r15, %rax
shrq $0x3f, %rax
shrq $0x5, %r15
addl %eax, %r15d
movl $0x400, %edi            # imm = 0x400
callq 0x2380
movq %rax, %rbx
testl %r14d, %r14d
je 0x463b
cmpl $0x1, %r12d
je 0x4651
testl %r12d, %r12d
jne 0x4662
cmpl $0x1, %r14d
jne 0x467e
leaq 0x1cad(%rip), %rsi      # 0x62de
movq %rbx, %rdi
movl $0x1, %edx
jmp 0x468b
leaq 0x1ca5(%rip), %rsi      # 0x62e7
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x2070
jmp 0x4695
leaq 0x1c9a(%rip), %rsi      # 0x62f2
movq %rbx, %rdi
movl $0x1, %edx
jmp 0x466f
leaq 0x1ca6(%rip), %rsi      # 0x630f
movq %rbx, %rdi
movl %r12d, %edx
movl %r14d, %ecx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x2070
jmp 0x4695
leaq 0x1c93(%rip), %rsi      # 0x6318
movq %rbx, %rdi
movl %r14d, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x2070
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
callq 0x2170
movl %eax, %edi
callq 0x22d0
movq 0x20(%rax), %rbx
movl $0x1000, %edi           # imm = 0x1000
callq 0x2380
movq %rax, %r14
leaq 0x1c61(%rip), %rsi      # 0x632d
leaq 0x1c60(%rip), %rcx      # 0x6333
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2070
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x2170
movl %eax, %edi
callq 0x22d0
movq (%rax), %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x3fca
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1000, %edi           # imm = 0x1000
callq 0x2380
movq %rax, %r14
movl $0x1000, %esi           # imm = 0x1000
movq %rax, %rdi
callq 0x2410
testl %eax, %eax
leaq 0x2144(%rip), %rsi      # 0x6886
cmovnsq %r14, %rsi
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x3fca
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rdi, %rbx
leaq 0x1bce(%rip), %rsi      # 0x6342
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x24b0
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x48(%rsp,%rax)
je 0x47b6
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1bb2(%rip), %rsi      # 0x6354
leaq 0x1bc5(%rip), %rdx      # 0x636e
movq %rbx, %rdi
callq 0x4072
jmp 0x483f
leaq (%rsp,%rax), %rdi
addq $0x28, %rdi
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movl $0xa, %esi
callq 0x2270
movsbl %al, %edx
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x24c0
leaq 0x1b5c(%rip), %rsi      # 0x6352
leaq 0x8(%rsp), %r14
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x2480
leaq 0x2(%rax), %rdx
movq 0x8(%r14), %rcx
decq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22b0
movq %rbx, %rdi
callq 0x2330
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x483f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2290
leaq 0x28(%rsp), %rdi
callq 0x2080
movq %rbx, %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x4878
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4878
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2290
leaq 0x28(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2490
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x2470
testq %rax, %rax
je 0x527f
movq 0x3da9(%rip), %rbx      # 0x8fd8
cmpl $0x0, (%rbx)
jle 0x527b
movq %rax, %r14
leaq 0x1714(%rip), %r15      # 0x6952
leaq 0xf5f(%rip), %r12       # 0x61a4
leaq 0xf47(%rip), %r13       # 0x6193
xorl %ebp, %ebp
movq 0x3d9b(%rip), %rax      # 0x8ff0
movl (%rax), %edx
addl %ebp, %edx
movq (%r14,%rbp,8), %rax
movq (%rax), %r8
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rcx
xorl %eax, %eax
callq 0x2030
incq %rbp
movslq (%rbx), %rax
cmpq %rax, %rbp
jl 0x524e
xorl %eax, %eax
jmp 0x5284
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x20, %edi
callq 0x2040
movq (%rbx), %r14
testq %r14, %r14
jle 0x2e91
movq 0x8(%rbx), %r15
addq %r15, %r14
callq 0x2460
movq %rax, %rbx
leaq 0xc412(%rip), %r12      # 0xf260
movq (%rbx), %rax
movzbl (%r15), %edi
testb $0x40, 0x1(%rax,%rdi,2)
jne 0x2e84
movl $0x5c, %edi
callq 0x2040
movzbl (%r15), %r13d
movl %r13d, %eax
shrl $0x4, %eax
movsbl (%rax,%r12), %edi
callq 0x2040
andl $0xf, %r13d
movsbl (%r13,%r12), %edi
callq 0x2040
incq %r15
cmpq %r14, %r15
jb 0x2e4e
movl $0xa, %edi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2040
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x20, %edi
callq 0x2040
movq (%rbx), %r14
testq %r14, %r14
jle 0x2ef9
movq 0x8(%rbx), %rbx
addq %rbx, %r14
leaq 0xc391(%rip), %r15      # 0xf260
movzbl (%rbx), %r12d
incq %rbx
movl %r12d, %eax
shrl $0x4, %eax
movsbl (%rax,%r15), %edi
callq 0x2040
andl $0xf, %r12d
movsbl (%r12,%r15), %edi
callq 0x2040
cmpq %r14, %rbx
jb 0x2ecf
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2040
nop