LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: PrarabdhJoshi[P]DatabaseImplementation/Comparison.cc
// Function: AddLitToFile(int&, _IO_FILE*, _IO_FILE*, char*, Type)
void AddLitToFile (int &numFieldsInLiteral, FILE *outRecFile, FILE *outSchemaFile, char *value, Type myType) {

        // first write out the new record field
        fprintf (outRecFile, "%s|", value);

        // now write out the new schema field
        if (myType == Int) {
                fprintf (outSchemaFile, "att%d Int\n", numFieldsInLiteral);
        } else if (myType == Double) {
                fprintf (outSchemaFile, "att%d Double\n", numFieldsInLiteral);
        } else if (myType == String) {
                fprintf (outSchemaFile, "att%d String\n", numFieldsInLiteral);
        } else {
                cerr << "I don't know that type!!\n";
                exit (1);
        }

        // and note that we have another field
        numFieldsInLiteral++;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x845d(%rip), %rsi      # 0xc0ab
movb $0x0, %al
callq 0x2210
cmpl $0x0, 0x4(%rsp)
jne 0x3c78
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movl (%rax), %edx
leaq 0x8440(%rip), %rsi      # 0xc0af
movb $0x0, %al
callq 0x2210
jmp 0x3cdf
cmpl $0x1, 0x4(%rsp)
jne 0x3c9b
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movl (%rax), %edx
leaq 0x8428(%rip), %rsi      # 0xc0ba
movb $0x0, %al
callq 0x2210
jmp 0x3cdd
cmpl $0x2, 0x4(%rsp)
jne 0x3cbe
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movl (%rax), %edx
leaq 0x8413(%rip), %rsi      # 0xc0c8
movb $0x0, %al
callq 0x2210
jmp 0x3cdb
movq 0xc323(%rip), %rdi      # 0xffe8
leaq 0x840a(%rip), %rsi      # 0xc0d6
callq 0x2140
movl $0x1, %edi
callq 0x21c0
jmp 0x3cdd
jmp 0x3cdf
movq 0x20(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x28, %rsp
retq
// File: PrarabdhJoshi[P]DatabaseImplementation/ComparisonEngine.cc
// Function: ComparisonEngine::Compare(Record*, Record*, CNF*)
int ComparisonEngine :: Compare (Record *left, Record *literal, CNF *myComparison) {

	for (int i = 0; i < myComparison->numAnds; i++) {

		for (int j = 0; j < myComparison->orLens[i]; j++) {

			// this returns a 0 if the comparison did not eval to true
			int result = Run(left, literal, &myComparison->orList[i][j]);
			
			if (result != 0) {
				break;	
			}
			
			// if we made it through all of the comparisons without a hit, return a 0
			if (j == myComparison->orLens[i] - 1) {
				return 0;
			}
		}

		// this ends the for-loop for the OR-list... if we made it this far, then we'll go on to the
		// next disjunction in the overall CNF expression
	}

	// this ends the for-loop for the AND-list... if we made it this far, then we know that we
	// have satisfied the overall CNF expression
	return 1;	
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x25d0(%rcx), %eax
jge 0x5529
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
movslq 0x1c(%rsp), %rdx
cmpl 0x2580(%rcx,%rdx,4), %eax
jge 0x5517
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movslq 0x1c(%rsp), %rax
imulq $0x1e0, %rax, %rax      # imm = 0x1E0
addq %rax, %rcx
movslq 0x18(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rcx
callq 0x5540
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x54df
jmp 0x5517
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
movslq 0x1c(%rsp), %rdx
movl 0x2580(%rcx,%rdx,4), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x5505
movl $0x0, 0x44(%rsp)
jmp 0x5531
jmp 0x5507
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x5487
jmp 0x5519
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x546a
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/Schema.cc
// Function: Schema::Find(char const*)
int Schema :: Find (const char *attName) {

	for (int i = 0; i < numAtts; i++) {
		if (!strcmp (attName, myAtts[i].name)) {
			return i;
		}
	}

	// if we made it here, the attribute was not found
	return -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jge 0x5c8a
movq (%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x2200
cmpl $0x0, %eax
jne 0x5c7b
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x5c92
jmp 0x5c7d
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5c3f
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/Schema.cc
// Function: Schema::FindType(char const*)
Type Schema :: FindType (const char *attName) {

	for (int i = 0; i < numAtts; i++) {
		if (!strcmp (attName, myAtts[i].name)) {
			return myAtts[i].myType;
		}
	}

	// if we made it here, the attribute was not found
	return Int;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jge 0x5d1d
movq (%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x2200
cmpl $0x0, %eax
jne 0x5d0e
movq (%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x5d25
jmp 0x5d10
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5cbf
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: PrarabdhJoshi[P]DatabaseImplementation/File.cc
// Function: Page::Page()
Page :: Page () {
	curSizeInBytes = sizeof (int);
	numRecs = 0;

	myRecs = new (std::nothrow) TwoWayList<Record>;
	if (myRecs == NULL)
	{
		cout << "ERROR : Not enough memory. EXIT !!!\n";
		exit(1);
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
leaq 0x9b67(%rip), %rcx      # 0xfd20
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x4, 0x14(%rax)
movl $0x0, 0x10(%rax)
movl $0x8, %edi
movq 0x9db6(%rip), %rsi      # 0xff90
callq 0x2350
movq %rax, %rcx
movq %rcx, 0x8(%rsp)
movb $0x0, 0x2f(%rsp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, 0x10(%rsp)
je 0x6216
movq 0x8(%rsp), %rdi
movb $0x1, 0x2f(%rsp)
callq 0x6c30
jmp 0x620a
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x6216
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
jne 0x6271
movq 0x9d87(%rip), %rdi      # 0xffb8
leaq 0x5dcc(%rip), %rsi      # 0xc004
callq 0x2140
movl $0x1, %edi
callq 0x21c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x625e
jmp 0x626f
movq 0x8(%rsp), %rdi
movq 0x9d26(%rip), %rsi      # 0xff90
callq 0x20e0
jmp 0x6276
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x22b0
// File: PrarabdhJoshi[P]DatabaseImplementation/File.cc
// Function: Page::EmptyItOut()
void Page :: EmptyItOut () {

	// get rid of all of the records
	while (1) {
		Record temp;
		if (!GetFirst (&temp))
			break;
	}	

	// reset the page size
	curSizeInBytes = sizeof (int);
	numRecs = 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x2660
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x63b0
movl %eax, 0xc(%rsp)
jmp 0x6335
movl 0xc(%rsp), %eax
cmpl $0x0, %eax
jne 0x6362
movl $0x3, 0x18(%rsp)
jmp 0x636a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2680
jmp 0x639a
movl $0x0, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2680
movl 0x18(%rsp), %eax
testl %eax, %eax
je 0x6380
jmp 0x637e
jmp 0x6382
jmp 0x6313
movq 0x10(%rsp), %rax
movl $0x4, 0x14(%rax)
movl $0x0, 0x10(%rax)
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/File.cc
// Function: Page::GetFirst(Record*)
int Page :: GetFirst (Record *firstOne) {

	// move to the first record
	myRecs->MoveToStart ();

	// make sure there is data 
	if (!myRecs->RightLength ()) {
		return 0;
	}

	// and remove it
	myRecs->Remove (firstOne);
	numRecs--;

	char *b = firstOne->GetBits();
	curSizeInBytes -= ((int *) b)[0];

	return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rax), %rdi
callq 0x6f90
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x6fd0
cmpl $0x0, %eax
jne 0x63ec
movl $0x0, 0x24(%rsp)
jmp 0x6438
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x6ff0
movq (%rsp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rdi
callq 0x2ad0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movl (%rcx), %edx
movl 0x14(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x14(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/File.cc
// Function: Page::Append(Record*)
int Page :: Append (Record *addMe) {
	char *b = addMe->GetBits();

	// first see if we can fit the record
	if (curSizeInBytes + ((int *) b)[0] > PAGE_SIZE) {
		return 0;
	}

	// move to the last record
	myRecs->MoveToFinish ();

	// and add it
	curSizeInBytes += ((int *) b)[0];
	myRecs->Insert(addMe);
	numRecs++;

	return 1;	
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x2ad0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rsp)
movl 0x14(%rax), %eax
movq 0x8(%rsp), %rcx
addl (%rcx), %eax
cmpl $0x20000, %eax          # imm = 0x20000
jle 0x6498
movl $0x0, 0x24(%rsp)
jmp 0x64d9
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x7090
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movl (%rcx), %ecx
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x70d0
movq (%rsp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/File.cc
// Function: Page::ToBinary(char*)
void Page :: ToBinary (char *bits) {

	// first write the number of records on the page
	((int *) bits)[0] = numRecs;

	char *curPos = bits + sizeof (int);

	// and copy the records one-by-one
	myRecs->MoveToStart ();
	for (int i = 0; i < numRecs; i++) {	
		char *b = myRecs->Current(0)->GetBits();
		
		// copy over the bits of the current record
		memcpy (curPos, b, ((int *) b)[0]);
		curPos += ((int *) b)[0];

		// and traverse the list
		myRecs->Advance ();
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x10(%rax), %edx
movq 0x28(%rsp), %rcx
movl %edx, (%rcx)
movq 0x28(%rsp), %rcx
addq $0x4, %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rdi
callq 0x6f90
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0x65b5
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x72c0
movq %rax, %rdi
callq 0x2ad0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x10(%rsp), %rax
movslq (%rax), %rdx
callq 0x2110
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movl (%rcx), %edx
movq 0x20(%rsp), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rdi
callq 0x7320
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x6541
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/File.cc
// Function: File::GetPage(Page*, long)
void File :: GetPage (Page *putItHere, off_t whichPage) {

	// this is because the first page has no data
	whichPage++;

	if (whichPage >= curLength) {
		cerr << "whichPage " << whichPage << " length " << curLength << endl;
		cerr << "BAD: you tried to read past the end of the file\n";
		exit (1);
	}

	// read in the specified page
	char *bits = new (std::nothrow) char[PAGE_SIZE];
	if (bits == NULL)
	{
		cout << "ERROR : Not enough memory. EXIT !!!\n";
		exit(1);
	}

	lseek (myFilDes, PAGE_SIZE * whichPage, SEEK_SET);
	read (myFilDes, bits, PAGE_SIZE);
	putItHere->FromBinary (bits);
	delete [] bits;
	
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x8(%rcx), %rax
jl 0x68e2
movq 0x976b(%rip), %rdi      # 0xffe8
leaq 0x5a6a(%rip), %rsi      # 0xc2ee
callq 0x2140
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x22d0
movq %rax, %rdi
leaq 0x5a59(%rip), %rsi      # 0xc2f9
callq 0x2140
movq %rax, %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x22d0
movq %rax, %rdi
movq 0x96e0(%rip), %rsi      # 0xffa0
callq 0x2180
movq 0x971c(%rip), %rdi      # 0xffe8
leaq 0x5a2f(%rip), %rsi      # 0xc302
callq 0x2140
movl $0x1, %edi
callq 0x21c0
movl $0x20000, %edi          # imm = 0x20000
movq 0x96a2(%rip), %rsi      # 0xff90
callq 0x2280
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x691d
movq 0x96b1(%rip), %rdi      # 0xffb8
leaq 0x56f6(%rip), %rsi      # 0xc004
callq 0x2140
movl $0x1, %edi
callq 0x21c0
movq 0x10(%rsp), %rax
movl (%rax), %edi
movq 0x20(%rsp), %rsi
shlq $0x11, %rsi
xorl %edx, %edx
callq 0x2300
movq 0x10(%rsp), %rax
movl (%rax), %edi
movq 0x18(%rsp), %rsi
movl $0x20000, %edx          # imm = 0x20000
callq 0x2220
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x65c0
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x6973
movq 0x8(%rsp), %rdi
callq 0x21e0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/File.cc
// Function: File::AddPage(Page*, long)
void File :: AddPage (Page *addMe, off_t whichPage) {

	// this is because the first page has no data
	whichPage++;

	// if we are trying to add past the end of the file, then
	// zero all of the pages out
	if (whichPage >= curLength) {
		
		// do the zeroing
		for (off_t i = curLength; i < whichPage; i++) {
			int foo = 0;
			lseek (myFilDes, PAGE_SIZE * i, SEEK_SET);
			write (myFilDes, &foo, sizeof (int));
		}

		// set the size
		curLength = whichPage + 1;	
	}

	// now write the page
	char *bits = new (std::nothrow) char[PAGE_SIZE];
	if (bits == NULL)
	{
		cout << "ERROR : Not enough memory. EXIT !!!\n";
		exit(1);
	}

	addMe->ToBinary (bits);
	lseek (myFilDes, PAGE_SIZE * whichPage, SEEK_SET);
	write (myFilDes, bits, PAGE_SIZE);
	delete [] bits;
#ifdef F_DEBUG
	cerr << " File: curLength " << curLength << " whichPage " << whichPage << endl;
#endif
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x8(%rcx), %rax
jl 0x6a27
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x30(%rsp), %rax
jge 0x6a15
movq 0x10(%rsp), %rax
movl $0x0, 0x24(%rsp)
movl (%rax), %edi
movq 0x28(%rsp), %rsi
shlq $0x11, %rsi
xorl %edx, %edx
callq 0x2300
movq 0x10(%rsp), %rax
movl (%rax), %edi
leaq 0x24(%rsp), %rsi
movl $0x4, %edx
callq 0x20a0
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x69c4
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movl $0x20000, %edi          # imm = 0x20000
movq 0x955d(%rip), %rsi      # 0xff90
callq 0x2280
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x6a62
movq 0x956c(%rip), %rdi      # 0xffb8
leaq 0x55b1(%rip), %rsi      # 0xc004
callq 0x2140
movl $0x1, %edi
callq 0x21c0
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x6500
movq 0x10(%rsp), %rax
movl (%rax), %edi
movq 0x30(%rsp), %rsi
shlq $0x11, %rsi
xorl %edx, %edx
callq 0x2300
movq 0x10(%rsp), %rax
movl (%rax), %edi
movq 0x18(%rsp), %rsi
movl $0x20000, %edx          # imm = 0x20000
callq 0x20a0
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x6ab8
movq 0x8(%rsp), %rdi
callq 0x21e0
addq $0x48, %rsp
retq
nopl (%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/File.cc
// Function: File::Open(int, char*)
void File :: Open (int fileLen, char *fName) {

	// figure out the flags for the system open call
        int mode;
        if (fileLen == 0)
                mode = O_TRUNC | O_RDWR | O_CREAT;
        else
                mode = O_RDWR;

	// actually do the open
        myFilDes = open (fName, mode, S_IRUSR | S_IWUSR);

#ifdef verbose
	cout << "Opening file " << fName << " with "<< curLength << " pages.\n";
#endif

	// see if there was an error
	if (myFilDes < 0) {
		cerr << "BAD!  Open did not work for " << fName << "\n";
		exit (1);
	}

	// read in the buffer if needed
	if (fileLen != 0) {

		// read in the first few bits, which is the page size
		lseek (myFilDes, 0, SEEK_SET);
		read (myFilDes, &curLength, sizeof (off_t));

	} else {
		curLength = 0;
	}

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x6aec
movl $0x242, 0xc(%rsp)       # imm = 0x242
jmp 0x6af4
movl $0x2, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x2100
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
cmpl $0x0, (%rax)
jge 0x6b4f
movq 0x94cb(%rip), %rdi      # 0xffe8
leaq 0x580f(%rip), %rsi      # 0xc333
callq 0x2140
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x2140
movq %rax, %rdi
leaq 0x6035(%rip), %rsi      # 0xcb75
callq 0x2140
movl $0x1, %edi
callq 0x21c0
cmpl $0x0, 0x1c(%rsp)
je 0x6b7d
movq (%rsp), %rax
movl (%rax), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2300
movq (%rsp), %rsi
movl (%rsi), %edi
addq $0x8, %rsi
movl $0x8, %edx
callq 0x2220
jmp 0x6b89
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
addq $0x28, %rsp
retq
nop
// File: PrarabdhJoshi[P]DatabaseImplementation/File.cc
// Function: File::Close()
int File :: Close () {

	// write out the current length in pages
	lseek (myFilDes, 0, SEEK_SET);
	write (myFilDes, &curLength, sizeof (off_t));

	// close the file
	close (myFilDes);

	// and return the size
	return curLength;
	
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2300
movq 0x8(%rsp), %rsi
movl (%rsi), %edi
addq $0x8, %rsi
movl $0x8, %edx
callq 0x20a0
movq 0x8(%rsp), %rax
movl (%rax), %edi
callq 0x2340
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x18, %rsp
retq
nop
// File: PrarabdhJoshi[P]DatabaseImplementation/File.cc
// Function: File::Getlast()
off_t File :: Getlast(){

if(!curLength)
return 0;
else
return curLength-1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, 0x8(%rax)
jne 0x6c11
movq $0x0, -0x8(%rsp)
jmp 0x6c23
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/./TwoWayList.cc
// Function: TwoWayList<Record>::~TwoWayList()
TwoWayList <Type> :: ~TwoWayList ()
{

	// remove everything
	MoveToStart ();
	while (RightLength ()>0) {
		Type temp;
		Remove (&temp);
	}

	// kill all the nodes
	for (int i = 0; i <= list->leftSize + list->rightSize; i++) {
		list->first = list->first->next;
		delete list->first->previous;
	} 
	delete list->first;
	
	// kill the header
	delete list;

}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x6f90
jmp 0x6e7a
jmp 0x6e7c
movq 0x28(%rsp), %rdi
callq 0x6fd0
movl %eax, 0x24(%rsp)
jmp 0x6e8c
movl 0x24(%rsp), %eax
cmpl $0x0, %eax
jle 0x6ebe
leaq 0x38(%rsp), %rdi
callq 0x2660
jmp 0x6ea1
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x6ff0
jmp 0x6eb2
leaq 0x38(%rsp), %rdi
callq 0x2680
jmp 0x6e7c
movl $0x0, 0x34(%rsp)
movq 0x28(%rsp), %rdx
movl 0x34(%rsp), %eax
movq (%rdx), %rcx
movl 0x18(%rcx), %ecx
movq (%rdx), %rdx
addl 0x1c(%rdx), %ecx
cmpl %ecx, %eax
jg 0x6f31
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rdx
movq (%rax), %rcx
movq %rdx, (%rcx)
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x6f22
movq 0x18(%rsp), %rdi
callq 0x73a0
movq 0x18(%rsp), %rdi
movl $0x18, %esi
callq 0x2170
jmp 0x6f24
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x6ec6
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x6f60
movq 0x10(%rsp), %rdi
callq 0x73a0
movq 0x10(%rsp), %rdi
movl $0x18, %esi
callq 0x2170
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x6f82
movq 0x8(%rsp), %rdi
movl $0x20, %esi
callq 0x2170
addq $0x48, %rsp
retq
movq %rax, %rdi
callq 0x7390
nop
// File: PrarabdhJoshi[P]DatabaseImplementation/./TwoWayList.cc
// Function: TwoWayList<Record>::Remove(Record*)
void
TwoWayList <Type> :: Remove (Type *Item)
{

	Node *temp = list->current->next;
	list->current->next = temp->next;
	temp->next->previous = list->current;
	
	Item->Consume(temp->data);

	delete temp;

	(list->rightSize)--;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rdx
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rdx, 0x8(%rcx)
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0x2b70
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x707a
movq 0x8(%rsp), %rdi
callq 0x73a0
movq 0x8(%rsp), %rdi
movl $0x18, %esi
callq 0x2170
movq (%rsp), %rax
movq (%rax), %rax
movl 0x1c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1c(%rax)
addq $0x28, %rsp
retq
nop
// File: PrarabdhJoshi[P]DatabaseImplementation/./TwoWayList.cc
// Function: TwoWayList<Record>::Insert(Record*)
void
TwoWayList <Type> :: Insert (Type *Item)
{

	Node *temp = new (std::nothrow) Node;
	if (temp == NULL)
	{
		cout << "ERROR : Not enough memory. EXIT !!!\n";
		exit(1);
	}

	Node *left = list->current;
	Node *right = list->current->next;

	left->next = temp;
	temp->previous = left;
	temp->next = right;
	temp->data = new (std::nothrow) Type;
	if (temp->data == NULL)
	{
		cout << "ERROR : Not enough memory. EXIT !!!\n";
		exit(1);
	}

	right->previous = temp;

	temp->data->Consume (Item);

	list->rightSize += 1;

}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x18, %edi
movq 0x8e9c(%rip), %rsi      # 0xff90
callq 0x2350
movq %rax, %rcx
movq %rcx, 0x18(%rsp)
movb $0x0, 0x5f(%rsp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, 0x20(%rsp)
je 0x7130
movq 0x18(%rsp), %rdi
movb $0x1, 0x5f(%rsp)
callq 0x7360
jmp 0x7124
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x7130
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0x718c
movq 0x8e6f(%rip), %rdi      # 0xffb8
leaq 0x4eb4(%rip), %rsi      # 0xc004
callq 0x2140
movl $0x1, %edi
callq 0x21c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
testb $0x1, 0x5f(%rsp)
jne 0x7176
jmp 0x7187
movq 0x18(%rsp), %rdi
movq 0x8e0e(%rip), %rsi      # 0xff90
callq 0x20e0
jmp 0x72b6
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x40(%rsp)
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x40(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x38(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x8, %edi
movq 0x8dad(%rip), %rsi      # 0xff90
callq 0x2350
movq %rax, %rcx
movq %rcx, (%rsp)
movb $0x0, 0x2f(%rsp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, 0x8(%rsp)
je 0x7221
movq (%rsp), %rdi
movq %rdi, 0x30(%rsp)
movb $0x1, 0x2f(%rsp)
callq 0x2660
jmp 0x7216
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x7221
movq 0x8(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, (%rax)
movq 0x60(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x7280
movq 0x8d78(%rip), %rdi      # 0xffb8
leaq 0x4dbd(%rip), %rsi      # 0xc004
callq 0x2140
movl $0x1, %edi
callq 0x21c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x726d
jmp 0x727e
movq 0x30(%rsp), %rdi
movq 0x8d17(%rip), %rsi      # 0xff90
callq 0x20e0
jmp 0x72b6
movq 0x60(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x60(%rsp), %rax
movq (%rax), %rdi
movq 0x68(%rsp), %rsi
callq 0x2b70
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
addq $0x78, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x22b0
// File: PrarabdhJoshi[P]DatabaseImplementation/./TwoWayList.cc
// Function: TwoWayList<Record>::Current(int)
Type* 
TwoWayList <Type> ::  Current (int offset)
{
	Node *temp = list->current->next;
	for (int i = 0; i < offset; i++) {
		temp = temp->next;
	}
	return temp->data;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0x730b
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x72e6
movq -0x18(%rsp), %rax
movq (%rax), %rax
retq
nopw %cs:(%rax,%rax)
nop
// File: PrarabdhJoshi[P]DatabaseImplementation/DBFile.cc
// Function: DBFile::DBFile()
DBFile::DBFile() {

	heapfile = new File;
	fpath = NULL;
	readbuffer = new Page;
	writebuffer = new Page;
	indicator = 0;
	verify = false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x10, %edi
callq 0x2160
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0x6820
jmp 0x740f
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movl $0x18, %edi
callq 0x2160
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x61a0
jmp 0x7440
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movl $0x18, %edi
callq 0x2160
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
callq 0x61a0
jmp 0x7469
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x18(%rax)
movl $0x0, 0x20(%rax)
movb $0x0, 0x24(%rax)
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x10, %esi
callq 0x2170
jmp 0x74e0
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x18, %esi
callq 0x2170
jmp 0x74e0
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x18, %esi
callq 0x2170
movq 0x28(%rsp), %rdi
callq 0x22b0
nopw (%rax,%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/DBFile.cc
// Function: DBFile::Create(char const*, fType, void*)
int DBFile::Create(const char *f_path, fType f_type, void *startup) {

	if (verify)
		return 0;
	fpath = strdup(f_path);
	heapfile->Open(0, fpath);
	verify = true;
	return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x24(%rax)
je 0x75a1
movl $0x0, 0x34(%rsp)
jmp 0x75d6
movq 0x20(%rsp), %rdi
callq 0x22e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rax), %rdi
movq 0x8(%rax), %rdx
xorl %esi, %esi
callq 0x6ac0
movq 0x8(%rsp), %rax
movb $0x1, 0x24(%rax)
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: PrarabdhJoshi[P]DatabaseImplementation/DBFile.cc
// Function: DBFile::Load(Schema&, char const*)
void DBFile::Load(Schema &f_schema, const char *loadpath) {
	Record temprecord;
	FILE *tempfile = new FILE;
	tempfile = fopen(loadpath, "r");
	if (!verify)
		return;
	while (temprecord.SuckNextRecord(&f_schema, tempfile))
	{
		Add(temprecord);
	}
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2660
movl $0xd8, %edi
callq 0x2160
movq %rax, 0x18(%rsp)
jmp 0x7618
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x5494(%rip), %rsi      # 0xcac2
callq 0x21a0
movq %rax, 0x8(%rsp)
jmp 0x763a
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x30(%rsp)
testb $0x1, 0x24(%rax)
jne 0x7673
movl $0x1, 0x20(%rsp)
jmp 0x76b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2680
jmp 0x76c2
jmp 0x7675
movq 0x48(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x26d0
movl %eax, 0x4(%rsp)
jmp 0x768f
movl 0x4(%rsp), %eax
cmpl $0x0, %eax
je 0x76ab
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x76d0
jmp 0x76a9
jmp 0x7675
movl $0x0, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2680
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x22b0
nopl (%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/DBFile.cc
// Function: DBFile::Add(Record&)
void DBFile::Add(Record &rec) {
	int temp = readbuffer->Append(&rec);
	if (temp == 0)
	{
		heapfile->AddPage(readbuffer, heapfile->Getlast());
		readbuffer->EmptyItOut();
		readbuffer->Append(&rec);
	}

}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x6450
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x7752
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdi
callq 0x6bf0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x6980
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x6300
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x6450
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/DBFile.cc
// Function: DBFile::Open(char const*)
int DBFile::Open(const char *f_path) {
	if (verify)
		return 0;
	fpath = strdup(f_path);
	heapfile->Open(1, fpath);
	verify = true;
	return 1;

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x24(%rax)
je 0x7788
movl $0x0, 0x24(%rsp)
jmp 0x77c0
movq 0x10(%rsp), %rdi
callq 0x22e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rax), %rdi
movq 0x8(%rax), %rdx
movl $0x1, %esi
callq 0x6ac0
movq 0x8(%rsp), %rax
movb $0x1, 0x24(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/DBFile.cc
// Function: DBFile::MoveFirst()
void DBFile::MoveFirst() {
	if (readbuffer->totalrecords() != 0) {
		heapfile->AddPage(readbuffer, heapfile->Getlast());
		readbuffer->EmptyItOut();
	}
	writebuffer->EmptyItOut();
	heapfile->GetPage(writebuffer, indicator);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rax), %rdi
callq 0x64f0
cmpl $0x0, %eax
je 0x782f
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdi
callq 0x6bf0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x6980
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x6300
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x6300
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rax), %rsi
movslq 0x20(%rax), %rdx
callq 0x6840
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/DBFile.cc
// Function: DBFile::Close()
int DBFile::Close() {
	if (!verify)
		return 0;
	if (readbuffer->totalrecords() != 0)
	{
		heapfile->AddPage(readbuffer, heapfile->Getlast());
		readbuffer->EmptyItOut();
	}
	heapfile->Close();
	verify = false;
	return 1;

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x24(%rax)
jne 0x7883
movl $0x0, 0x24(%rsp)
jmp 0x78f0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x64f0
cmpl $0x0, %eax
je 0x78d2
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdi
callq 0x6bf0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x6980
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x6300
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x6ba0
movq 0x10(%rsp), %rax
movb $0x0, 0x24(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/DBFile.cc
// Function: DBFile::GetNext(Record&)
int DBFile::GetNext(Record &fetchme) {

	if (readbuffer->totalrecords() != 0) {
		heapfile->AddPage(readbuffer, heapfile->Getlast());
		readbuffer->EmptyItOut();
	}
	while (!writebuffer->GetFirst(&fetchme))
	{
		if (++indicator == heapfile->Getlast())
			return 0;
		heapfile->GetPage(writebuffer, indicator);


	}
	return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rax), %rdi
callq 0x64f0
cmpl $0x0, %eax
je 0x7964
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdi
callq 0x6bf0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x6980
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x6300
jmp 0x7966
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x63b0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x7987
jmp 0x79d1
movq 0x18(%rsp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movslq %ecx, %rcx
movq %rcx, (%rsp)
movq (%rax), %rdi
callq 0x6bf0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jne 0x79ba
movl $0x0, 0x34(%rsp)
jmp 0x79d9
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rax), %rsi
movslq 0x20(%rax), %rdx
callq 0x6840
jmp 0x7966
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/DBFile.cc
// Function: DBFile::GetNext(Record&, CNF&, Record&)
int DBFile::GetNext(Record &fetchme, CNF &cnf, Record &literal) {

	ComparisonEngine *compeng = new ComparisonEngine();
	while (GetNext(fetchme)) {
		if (compeng->Compare(&fetchme, &literal, &cnf) != 0)
			return 1;
	}
	return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl $0x1, %edi
callq 0x2160
movq %rax, 0x8(%rsp)
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7900
cmpl $0x0, %eax
je 0x7a5d
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x5440
cmpl $0x0, %eax
je 0x7a5b
movl $0x1, 0x34(%rsp)
jmp 0x7a65
jmp 0x7a20
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: PrarabdhJoshi[P]DatabaseImplementation/lex.yy.c
// Function: yy_try_NUL_trans
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		(yy_last_accepting_state) = yy_current_state;
		(yy_last_accepting_cpos) = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 28 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 27);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x71b2(%rip), %rax      # 0x10290
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x362f(%rip), %rax      # 0xc720
cmpw $0x0, (%rax,%rcx,2)
je 0x910c
movl -0x4(%rbp), %eax
movl %eax, 0x71a3(%rip)      # 0x102a4
movq -0x10(%rbp), %rax
movq %rax, 0x719c(%rip)      # 0x102a8
jmp 0x910e
movslq -0x4(%rbp), %rcx
leaq 0x36b7(%rip), %rax      # 0xc7d0
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x3633(%rip), %rax      # 0xc760
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x9163
movslq -0x4(%rbp), %rcx
leaq 0x36cf(%rip), %rax      # 0xc810
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x1c, -0x4(%rbp)
jl 0x9161
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x36f5(%rip), %rax      # 0xc850
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
jmp 0x910e
movslq -0x4(%rbp), %rcx
leaq 0x3662(%rip), %rax      # 0xc7d0
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x36ee(%rip), %rax      # 0xc870
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x1b, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x91a5
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x91ab
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
// File: PrarabdhJoshi[P]DatabaseImplementation/test.cc
// Function: test1()
void test1 () {
cout<<"here";
	DBFile dbfile;
	cout << " DBFile will be created at " << rel->path () << endl;
	dbfile.Create (rel->path(), heap, NULL);

	char tbl_path[100]; // construct path of the tpch flat text file
	sprintf (tbl_path, "%s%s.tbl", tpch_dir, rel->name()); 
	cout << " tpch file will be loaded from " << tbl_path << endl;
      	dbfile.Load (*(rel->schema ()), tbl_path);
	dbfile.Close ();
	
}

// Assembly:
subq $0xf8, %rsp
movq 0x566a(%rip), %rdi      # 0xffb8
movq %rdi, 0x50(%rsp)
leaq 0x2242(%rip), %rsi      # 0xcb9c
callq 0x2140
leaq 0xd0(%rsp), %rdi
callq 0x73e0
movq 0x50(%rsp), %rdi
leaq 0x2229(%rip), %rsi      # 0xcba1
callq 0x2140
movq %rax, 0x58(%rsp)
jmp 0xa984
movq 0x5985(%rip), %rdi      # 0x10310
callq 0xb1c0
movq %rax, 0x48(%rsp)
jmp 0xa997
movq 0x48(%rsp), %rsi
movq 0x58(%rsp), %rdi
callq 0x2140
movq %rax, 0x40(%rsp)
jmp 0xa9ad
movq 0x40(%rsp), %rdi
movq 0x55e7(%rip), %rsi      # 0xffa0
callq 0x2180
jmp 0xa9c0
movq 0x5949(%rip), %rdi      # 0x10310
callq 0xb1c0
movq %rax, 0x38(%rsp)
jmp 0xa9d3
movq 0x38(%rsp), %rsi
xorl %edx, %edx
movl %edx, %ecx
leaq 0xd0(%rsp), %rdi
callq 0x7570
jmp 0xa9eb
leaq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x581c(%rip), %rax      # 0x10218
movq %rax, 0x28(%rsp)
movq 0x5908(%rip), %rdi      # 0x10310
callq 0xb1d0
movq %rax, 0x30(%rsp)
jmp 0xaa14
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rdi
leaq 0x2193(%rip), %rsi      # 0xcbbd
xorl %eax, %eax
callq 0x2070
movq 0x5580(%rip), %rdi      # 0xffb8
leaq 0x2187(%rip), %rsi      # 0xcbc6
callq 0x2140
movq %rax, 0x18(%rsp)
jmp 0xaa4b
movq 0x18(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x2140
movq %rax, 0x10(%rsp)
jmp 0xaa61
movq 0x10(%rsp), %rdi
movq 0x5533(%rip), %rsi      # 0xffa0
callq 0x2180
jmp 0xaa74
movq 0x5895(%rip), %rdi      # 0x10310
callq 0xb1e0
movq %rax, 0x8(%rsp)
jmp 0xaa87
movq 0x8(%rsp), %rsi
leaq 0xd0(%rsp), %rdi
leaq 0x60(%rsp), %rdx
callq 0x75e0
jmp 0xaaa0
leaq 0xd0(%rsp), %rdi
callq 0x7860
jmp 0xaaaf
leaq 0xd0(%rsp), %rdi
callq 0x74f0
addq $0xf8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x74f0
movq 0xc8(%rsp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/test.cc
// Function: test2()
void test2 () {

	DBFile dbfile;
	dbfile.Open (rel->path());
	dbfile.MoveFirst ();

	Record temp;

	int counter = 0;
	while (dbfile.GetNext (temp) == 1) {
		counter += 1;
		temp.Print (rel->schema());
		if (counter % 10000 == 0) {
			cout << counter << "\n";
		}
	}
	cout << " scanned " << counter << " recs \n";
	dbfile.Close ();
}

// Assembly:
subq $0x78, %rsp
leaq 0x50(%rsp), %rdi
callq 0x73e0
movq 0x57fb(%rip), %rdi      # 0x10310
callq 0xb1c0
movq %rax, 0x28(%rsp)
jmp 0xab21
movq 0x28(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x7760
jmp 0xab32
leaq 0x50(%rsp), %rdi
callq 0x77d0
jmp 0xab3e
leaq 0x38(%rsp), %rdi
callq 0x2660
jmp 0xab4a
movl $0x0, 0x34(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x7900
movl %eax, 0x24(%rsp)
jmp 0xab67
movl 0x24(%rsp), %eax
cmpl $0x1, %eax
jne 0xac11
movl 0x34(%rsp), %eax
incl %eax
movl %eax, 0x34(%rsp)
movq 0x578b(%rip), %rdi      # 0x10310
callq 0xb1e0
movq %rax, 0x18(%rsp)
jmp 0xab91
movq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x3200
jmp 0xaba2
movl 0x34(%rsp), %eax
movl $0x2710, %ecx           # imm = 0x2710
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0xac0c
movl 0x34(%rsp), %esi
movq 0x53fa(%rip), %rdi      # 0xffb8
callq 0x2290
movq %rax, 0x10(%rsp)
jmp 0xabca
movq 0x10(%rsp), %rdi
leaq 0x1f9f(%rip), %rsi      # 0xcb75
callq 0x2140
jmp 0xabdd
jmp 0xac0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xac76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2680
jmp 0xac76
jmp 0xab52
movq 0x53a0(%rip), %rdi      # 0xffb8
leaq 0x1fc7(%rip), %rsi      # 0xcbe6
callq 0x2140
movq %rax, 0x8(%rsp)
jmp 0xac2b
movq 0x8(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x2290
movq %rax, (%rsp)
jmp 0xac3f
movq (%rsp), %rdi
leaq 0x1fa6(%rip), %rsi      # 0xcbf0
callq 0x2140
jmp 0xac51
leaq 0x50(%rsp), %rdi
callq 0x7860
jmp 0xac5d
leaq 0x38(%rsp), %rdi
callq 0x2680
leaq 0x50(%rsp), %rdi
callq 0x74f0
addq $0x78, %rsp
retq
leaq 0x50(%rsp), %rdi
callq 0x74f0
movq 0x48(%rsp), %rdi
callq 0x22b0
nopw (%rax,%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/test.cc
// Function: test3()
void test3 () {

	cout << " Filter with CNF for : " << rel->name() << "\n";

	CNF cnf; 
	Record literal;
	rel->get_cnf (cnf, literal);

	DBFile dbfile;
	dbfile.Open (rel->path());
	dbfile.MoveFirst ();

	Record temp;

	int counter = 0;
	while (dbfile.GetNext (temp, cnf, literal) == 1) {
		counter += 1;
		temp.Print (rel->schema());
		if (counter % 10000 == 0) {
			cout << counter << "\n";
		}
	}
	cout << " selected " << counter << " recs \n";
	dbfile.Close ();
}

// Assembly:
subq $0x2678, %rsp           # imm = 0x2678
movq 0x531a(%rip), %rdi      # 0xffb8
leaq 0x1f53(%rip), %rsi      # 0xcbf8
callq 0x2140
movq %rax, 0x38(%rsp)
movq 0x565a(%rip), %rdi      # 0x10310
callq 0xb1d0
movq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0x2140
movq %rax, %rdi
leaq 0x1ea3(%rip), %rsi      # 0xcb75
callq 0x2140
leaq 0xa4(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0xb1f0
leaq 0x98(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x2660
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x5604(%rip), %rdi      # 0x10310
callq 0xb240
jmp 0xad13
leaq 0x60(%rsp), %rdi
callq 0x73e0
jmp 0xad1f
movq 0x55ea(%rip), %rdi      # 0x10310
callq 0xb1c0
movq %rax, 0x30(%rsp)
jmp 0xad32
movq 0x30(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x7760
jmp 0xad43
leaq 0x60(%rsp), %rdi
callq 0x77d0
jmp 0xad4f
leaq 0x58(%rsp), %rdi
callq 0x2660
jmp 0xad5b
movl $0x0, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0xa4(%rsp), %rdx
leaq 0x98(%rsp), %rcx
callq 0x79f0
movl %eax, 0x2c(%rsp)
jmp 0xad88
movl 0x2c(%rsp), %eax
cmpl $0x1, %eax
jne 0xae57
movl 0x54(%rsp), %eax
incl %eax
movl %eax, 0x54(%rsp)
movq 0x556a(%rip), %rdi      # 0x10310
callq 0xb1e0
movq %rax, 0x20(%rsp)
jmp 0xadb2
movq 0x20(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x3200
jmp 0xadc3
movl 0x54(%rsp), %eax
movl $0x2710, %ecx           # imm = 0x2710
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0xae52
movl 0x54(%rsp), %esi
movq 0x51d9(%rip), %rdi      # 0xffb8
callq 0x2290
movq %rax, 0x18(%rsp)
jmp 0xadeb
movq 0x18(%rsp), %rdi
leaq 0x1d7e(%rip), %rsi      # 0xcb75
callq 0x2140
jmp 0xadfe
jmp 0xae52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xaed8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xaece
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x2680
jmp 0xaece
jmp 0xad63
movq 0x515a(%rip), %rdi      # 0xffb8
leaq 0x1dab(%rip), %rsi      # 0xcc10
callq 0x2140
movq %rax, 0x10(%rsp)
jmp 0xae71
movq 0x10(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x2290
movq %rax, 0x8(%rsp)
jmp 0xae86
movq 0x8(%rsp), %rdi
leaq 0x1d5e(%rip), %rsi      # 0xcbf0
callq 0x2140
jmp 0xae99
leaq 0x60(%rsp), %rdi
callq 0x7860
jmp 0xaea5
leaq 0x58(%rsp), %rdi
callq 0x2680
leaq 0x60(%rsp), %rdi
callq 0x74f0
leaq 0x98(%rsp), %rdi
callq 0x2680
addq $0x2678, %rsp           # imm = 0x2678
retq
leaq 0x60(%rsp), %rdi
callq 0x74f0
leaq 0x98(%rsp), %rdi
callq 0x2680
movq 0x90(%rsp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/./test.h
// Function: relation::get_cnf(CNF&, Record&)
void get_cnf (CNF &cnf_pred, Record &literal) {
		cout << " Enter CNF predicate (when done press ctrl-D):\n\t";
  		if (yyparse() != 0) {
			std::cout << "Can't parse your CNF.\n";
			exit (1);
		}
		cnf_pred.GrowFromParseTree (final, schema (), literal); // constructs CNF predicate
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x4d54(%rip), %rdi      # 0xffb8
leaq 0x1a7c(%rip), %rsi      # 0xcce7
callq 0x2140
callq 0x7a70
cmpl $0x0, %eax
je 0xb297
movq 0x4d37(%rip), %rdi      # 0xffb8
leaq 0x1a90(%rip), %rsi      # 0xcd18
callq 0x2140
movl $0x1, %edi
callq 0x21c0
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x4f8b(%rip), %rax      # 0x10238
movq (%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xb1e0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
movq 0x20(%rsp), %rcx
callq 0x47b0
addq $0x38, %rsp
retq
// File: yupyub[P]PathFinding_Visual/Dijkstra.cpp
// Function: Dijkstra::Init(int, int)
Visual Dijkstra::Init(int ts,int mnum){
    if(ts<10000) timeSet = 10000;
    timeSet = ts;
    dx[0] = dx[2] = dy[1] = dy[3] = 0;
    dx[1] = dy[0] = 1;
    dx[3] = dy[2] = -1;
    Visual vv;
    vv.read_map(mnum);
    for(int i = 0;i<vv.N;i++){
        for(int j = 0;j<vv.M;j++){
            vv.state[i][j] = 0;
            dist[i][j] = INF;
            if(vv.map[i][j] == 2){
                sx = i;
                sy = j;
            }
            else if(vv.map[i][j] == 3){
                ex = i;
                ey = j;
            }
        }
    }
    return vv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x2710, -0xc(%rbp)     # imm = 0x2710
jge 0x26a9
movq -0x20(%rbp), %rax
movl $0x2710, 0x75318(%rax)  # imm = 0x2710
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x75318(%rax)
movl $0x0, 0x75338(%rax)
movl $0x0, 0x75330(%rax)
movl $0x0, 0x75324(%rax)
movl $0x0, 0x7531c(%rax)
movl $0x1, 0x7532c(%rax)
movl $0x1, 0x75320(%rax)
movl $0xffffffff, 0x75334(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x75328(%rax) # imm = 0xFFFFFFFF
movl -0x10(%rbp), %esi
callq 0x87b0
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x4e200(%rcx), %eax
jge 0x2815
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x4e204(%rcx), %eax
jge 0x2805
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rax, %rdx
addq $0x27100, %rdx          # imm = 0x27100
movslq -0x14(%rbp), %rsi
imulq $0x320, %rsi, %rsi      # imm = 0x320
addq %rsi, %rdx
movslq -0x18(%rbp), %rsi
movl $0x0, (%rdx,%rsi,4)
addq $0x4e208, %rcx          # imm = 0x4E208
movslq -0x14(%rbp), %rdx
imulq $0x320, %rdx, %rdx      # imm = 0x320
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
movl $0x3ade68b1, (%rcx,%rdx,4) # imm = 0x3ADE68B1
movslq -0x14(%rbp), %rcx
imulq $0x320, %rcx, %rcx      # imm = 0x320
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
cmpl $0x2, (%rax,%rcx,4)
jne 0x27c1
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x75308(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x7530c(%rax)
jmp 0x27f5
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x320, %rcx, %rcx      # imm = 0x320
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
cmpl $0x3, (%rax,%rcx,4)
jne 0x27f3
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x75310(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x75314(%rax)
jmp 0x27f5
jmp 0x27f7
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2733
jmp 0x2807
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2719
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop