LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: wwdatabase[P]database/./rcdmana/../bufmanager/BufPageManager.h
// Function: BufPageManager::getPage(int, int, int&)
BufType getPage(int fileID, int pageID, int& index) {
		index = hash->findIndex(fileID, pageID);
		if (index != -1) {
			access(index);
			return addr[index];
		} else {
			BufType b = fetchPage(fileID, pageID, index);
			fileManager->readPage(fileID, pageID, b, 0);
			return b;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x5b90
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x4f06
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0x5000
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x4f42
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x5c40
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x28(%rbp), %rcx
xorl %r8d, %r8d
callq 0x5d40
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: wwdatabase[P]database/./rcdmana/rm_record.h
// Function: RM_Record::setData(char const*)
RC setData(const char *pData) {
        if (this->data != NULL) {
            delete [] this->data;
            this->data = NULL;
        }
        if (pData == NULL)
            return 0;
        int len = strlen(pData);
        this->data = new char[len];
        strcpy(this->data, pData);
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
je 0x4fb3
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x4fa8
movq -0x30(%rbp), %rdi
callq 0x2280
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x0, -0x18(%rbp)
jne 0x4fc3
movl $0x0, -0x4(%rbp)
jmp 0x4ff5
movq -0x18(%rbp), %rdi
callq 0x20c0
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rdi
callq 0x2030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x21b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: wwdatabase[P]database/./rcdmana/../bufmanager/BufPageManager.h
// Function: BufPageManager::access(int)
void access(int index) {
		if (index == last) {
			return;
		}
		replace->access(index);
		last = index;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jne 0x5020
jmp 0x5039
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x6120
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: wwdatabase[P]database/./rcdmana/rm_record.h
// Function: RM_Record::getData(char*) const
RC getData(char *pData) const{
        if (data == NULL) {
            cout << "Error with record, get data func" << endl;
        }
    	strcpy(pData, data);
    	return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, (%rax)
jne 0x5160
movq 0x8e93(%rip), %rdi      # 0xdfd8
leaq 0x4220(%rip), %rsi      # 0x936c
callq 0x21c0
movq %rax, %rdi
movq 0x8e6d(%rip), %rsi      # 0xdfc8
callq 0x2200
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq (%rax), %rsi
callq 0x21b0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wwdatabase[P]database/./rcdmana/../bufmanager/BufPageManager.h
// Function: BufPageManager::BufPageManager(FileManager*)
BufPageManager(FileManager* fm) {
		int c = CAP;
		int m = MOD;
		last = -1;
		fileManager = fm;
		//bpl = new MyLinkList(CAP, MAX_FILE_NUM);
		dirty = new bool[CAP];
		addr = new BufType[CAP];
		hash = new MyHashMap(c, m);
	    replace = new FindReplace(c);
		for (int i = 0; i < CAP; ++ i) {
			dirty[i] = false;
			addr[i] = NULL;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0xea60, -0x14(%rbp)    # imm = 0xEA60
movl $0xea60, -0x18(%rbp)    # imm = 0xEA60
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0xea60, %edi           # imm = 0xEA60
callq 0x2030
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x75300, %edi          # imm = 0x75300
callq 0x2030
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x18, %edi
callq 0x21e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x6480
jmp 0x534f
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x10, %edi
callq 0x21e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %esi
callq 0x6570
jmp 0x5379
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl $0x0, -0x28(%rbp)
cmpl $0xea60, -0x28(%rbp)    # imm = 0xEA60
jge 0x53f8
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rcx
movslq -0x28(%rbp), %rdx
movb $0x0, (%rcx,%rdx)
movq 0x28(%rax), %rax
movslq -0x28(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x538c
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x18, %esi
callq 0x21f0
jmp 0x53fe
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x21f0
jmp 0x53fe
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2310
nopw (%rax,%rax)
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../fileio/FileManager.h
// Function: FileManager::openFile(char const*, int&)
bool openFile(const char* name, int& fileID) {
		fileID = fm->findLeftOne();
		fm->setBit(fileID, 0);
		_openFile(name, fileID);
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x200(%rax), %rdi
callq 0x67b0
movl %eax, %edx
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl %edx, (%rcx)
movq 0x200(%rax), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
xorl %edx, %edx
callq 0x6820
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %edx
callq 0x6890
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../fileio/FileManager.h
// Function: FileManager::writePage(int, int, unsigned int*, int)
int writePage(int fileID, int pageID, BufType buf, int off) {
		int f = fd[fileID];
		off_t offset = pageID;
		offset = (offset << PAGE_SIZE_IDX);
		off_t error = lseek(f, offset, SEEK_SET);
		if (error != offset) {
			return -1;
		}
		BufType b = buf + off;
		error = write(f, (void*) b, PAGE_SIZE);
		return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
shlq $0xd, %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %edi
movq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x2370
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x5581
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x55b0
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movl -0x28(%rbp), %edi
movq -0x40(%rbp), %rsi
movl $0x2000, %edx           # imm = 0x2000
callq 0x2080
movq %rax, -0x38(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../fileio/FileManager.h
// Function: FileManager::closeFile(int)
int closeFile(int fileID) {
		fm->setBit(fileID, 1);
		int f = fd[fileID];
		close(f);
		return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x200(%rax), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
callq 0x6820
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
callq 0x2380
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: wwdatabase[P]database/./rcdmana/rm_record.h
// Function: RM_Record::clean()
RC clean() {
        if (this->data != NULL) {
            delete [] this->data;
            this->data = NULL;
        }
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x590f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x5904
movq -0x18(%rbp), %rdi
callq 0x2280
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../utils/MyHashMap.h
// Function: MyHashMap::findIndex(int, int)
int findIndex(int k1, int k2) {
		int h = hash(k1, k2);
		int p = list->getFirst(h);
		while (!list->isHead(p)) {
			if (a[p].key1 == k1 && a[p].key2 == k2) {
				/*
				list.del(p);
				list.insertFirst(p);
				*/
				return p;
			}
			p = list->next(p);
		}
		return -1;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x5de0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movq 0x8(%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x5e10
movl %eax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x20(%rbp), %esi
callq 0x5e30
xorb $-0x1, %al
testb $0x1, %al
jne 0x5be5
jmp 0x5c2b
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,8), %eax
cmpl -0x14(%rbp), %eax
jne 0x5c16
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %eax
cmpl -0x18(%rbp), %eax
jne 0x5c16
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5c32
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x20(%rbp), %esi
callq 0x5e60
movl %eax, -0x20(%rbp)
jmp 0x5bcd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wwdatabase[P]database/./rcdmana/../bufmanager/BufPageManager.h
// Function: BufPageManager::fetchPage(int, int, int&)
BufType fetchPage(int typeID, int pageID, int& index) {
		BufType b;
		index = replace->find();
		b = addr[index];
		if (b == NULL) {
			b = allocMem();
			addr[index] = b;
		} else {
			if (dirty[index]) {
				int k1, k2;
				hash->getKeys(index, k1, k2);
				fileManager->writePage(k1, k2, b, 0);
				dirty[index] = false;
			}
		}
		hash->replace(index, typeID, pageID);
		return b;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x18(%rax), %rdi
callq 0x5e80
movl %eax, %edx
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movl %edx, (%rcx)
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5cb6
movq -0x30(%rbp), %rdi
callq 0x5ed0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x5d15
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
testb $0x1, (%rax,%rcx)
je 0x5d13
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
leaq -0x24(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x5ef0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movq -0x20(%rbp), %rcx
xorl %r8d, %r8d
callq 0x5520
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x5d15
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
callq 0x5f30
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../fileio/FileManager.h
// Function: FileManager::readPage(int, int, unsigned int*, int)
int readPage(int fileID, int pageID, BufType buf, int off) {
		//int f = fd[fID[type]];
		int f = fd[fileID];
		off_t offset = pageID;
		offset = (offset << PAGE_SIZE_IDX);
		off_t error = lseek(f, offset, SEEK_SET);
		if (error != offset) {
			return -1;
		}
		BufType b = buf + off;
		error = read(f, (void*) b, PAGE_SIZE);
		return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
shlq $0xd, %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %edi
movq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x2370
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x5da1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5dd0
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movl -0x28(%rbp), %edi
movq -0x40(%rbp), %rsi
movl $0x2000, %edx           # imm = 0x2000
callq 0x22b0
movq %rax, -0x38(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../utils/MyLinkList.h
// Function: MyLinkList::isHead(int)
bool isHead(int index) {
		if (index < cap) {
			return false;
		} else {
			return true;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jge 0x5e4c
movb $0x0, -0x1(%rbp)
jmp 0x5e50
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: wwdatabase[P]database/./rcdmana/../bufmanager/FindReplace.h
// Function: FindReplace::find()
int find() {
		int index = list->getFirst(0);
		list->del(index);
		list->insert(0, index);
		return index;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rdi
xorl %esi, %esi
callq 0x5e10
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0xc(%rbp)
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x5fa0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %edx
xorl %esi, %esi
callq 0x6020
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../utils/MyHashMap.h
// Function: MyHashMap::replace(int, int, int)
void replace(int index, int k1, int k2) {
		int h = hash(k1, k2);
		//cout << h << endl;
		list->insertFirst(h, index);
		a[index].key1 = k1;
		a[index].key2 = k2;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x5de0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x18(%rbp)
movq 0x8(%rax), %rdi
movl -0x18(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x60c0
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %esi
movq 0x10(%rax), %rcx
movslq -0xc(%rbp), %rdx
movl %esi, (%rcx,%rdx,8)
movl -0x14(%rbp), %edx
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movl %edx, 0x4(%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../utils/MyLinkList.h
// Function: MyLinkList::del(int)
void del(int index) {
		if (a[index].prev == index) {
			return;
		}
		link(a[index].prev, a[index].next);
		a[index].prev = index;
		a[index].next = index;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %eax
cmpl -0xc(%rbp), %eax
jne 0x5fca
jmp 0x600b
movq -0x18(%rbp), %rdi
movq 0x8(%rdi), %rax
movslq -0xc(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %esi
movq 0x8(%rdi), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,8), %edx
callq 0x6080
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %esi
movq 0x8(%rax), %rcx
movslq -0xc(%rbp), %rdx
movl %esi, 0x4(%rcx,%rdx,8)
movl -0xc(%rbp), %edx
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../utils/MyLinkList.h
// Function: MyLinkList::insert(int, int)
void insert(int listID, int ele) {
		del(ele);
		int node = listID + cap;
		int prev = a[node].prev;
		link(prev, ele);
		link(ele, node);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0x10(%rbp), %esi
callq 0x5fa0
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
addl (%rdi), %eax
movl %eax, -0x14(%rbp)
movq 0x8(%rdi), %rax
movslq -0x14(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x6080
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x6080
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../utils/MyBitMap.h
// Function: MyBitMap::MyBitMap(int, unsigned int)
MyBitMap(int cap, uint k) {
		size = (cap >> BIAS);
		data = new uint[size];
		uint fill = 0;
		if (k == 1) {
			fill = 0xffffffff;
		}
		for (int i = 0; i < size; ++ i) {
			data[i] = fill;
		}
		init();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
sarl $0x5, %ecx
movl %ecx, 0x8(%rax)
movslq 0x8(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x1, -0x10(%rbp)
jne 0x61d6
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x6205
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %edx
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x61dd
movq -0x20(%rbp), %rdi
callq 0x6220
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../utils/MyBitMap.h
// Function: MyBitMap::childWord(int, int, int, int)
uint childWord(int start, int bitNum, int i, int j) {
		//cout << start << " " << bitNum << " " << i << " " << j << endl;
		int index = (i << BIAS) + j;
		if (start == 0) {
			return getLeafData(index);
		} else {
			//cout << start - bitNum + index << endl;
			return inner[start - bitNum + index];
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
shll $0x5, %eax
addl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x63f4
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x6460
movl %eax, -0x4(%rbp)
jmp 0x640b
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
subl -0x18(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movl 0x18(%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../utils/MyBitMap.h
// Function: MyBitMap::getMask(int)
static uint getMask(int k) {
		uint s = 0;
		for (int i = 0; i < k; ++ i) {
			s += (1 << i);
		}
		return s;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x6458
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6435
movl -0x8(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../utils/MyHashMap.h
// Function: MyHashMap::MyHashMap(int, int)
MyHashMap(int c, int m) {
		CAP_ = c;
		MOD_ = m;
		a = new DataNode[c];
		for (int i = 0; i < CAP_; ++ i) {
			a[i].key1 = -1;
			a[i].key2 = -1;
		}
		list = new MyLinkList(CAP_, MOD_);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movslq -0xc(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jge 0x6515
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x14(%rbp), %rdx
movl $0xffffffff, (%rcx,%rdx,8) # imm = 0xFFFFFFFF
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movl $0xffffffff, 0x4(%rax,%rcx,8) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x64dc
movl $0x10, %edi
callq 0x21e0
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %esi
movl 0x4(%rax), %edx
callq 0x6620
jmp 0x6539
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x21f0
movq -0x20(%rbp), %rdi
callq 0x2310
nop
// File: wwdatabase[P]database/./rcdmana/../bufmanager/FindReplace.h
// Function: FindReplace::FindReplace(int)
FindReplace(int c) {
		CAP_ = c;
		list = new MyLinkList(c, 1);
		for (int i = 0; i < CAP_; ++ i) {
			list->insert(0, i);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl $0x10, %edi
callq 0x21e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %esi
movl $0x1, %edx
callq 0x6620
jmp 0x65b0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x6606
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl -0x20(%rbp), %edx
xorl %esi, %esi
callq 0x6020
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x65c2
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x21f0
jmp 0x660c
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
nop
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../utils/MyLinkList.h
// Function: MyLinkList::MyLinkList(int, int)
MyLinkList(int c, int n) {
		cap = c;
		LIST_NUM = n;
		a = new ListNode[n + c]; 
		for (int i = 0; i < cap + LIST_NUM; ++ i) {
			a[i].next = i;
			a[i].prev = i;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x10(%rbp), %eax
addl -0xc(%rbp), %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdx
movl -0x14(%rbp), %eax
movl (%rdx), %ecx
addl 0x4(%rdx), %ecx
cmpl %ecx, %eax
jge 0x66bc
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %esi
movq 0x8(%rax), %rcx
movslq -0x14(%rbp), %rdx
movl %esi, (%rcx,%rdx,8)
movl -0x14(%rbp), %edx
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movl %edx, 0x4(%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6680
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../fileio/FileManager.h
// Function: FileManager::_createFile(char const*)
int _createFile(const char* name) {
		FILE* f = fopen(name, "a+");
		if (f == NULL) {
			cout << "fail" << endl;
			return -1;
		}
		fclose(f);
		return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x2c32(%rip), %rsi      # 0x938d
callq 0x2260
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6796
movq 0x7866(%rip), %rdi      # 0xdfd8
leaq 0x2c17(%rip), %rsi      # 0x9390
callq 0x21c0
movq %rax, %rdi
movq 0x7840(%rip), %rsi      # 0xdfc8
callq 0x2200
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x67a6
movq -0x20(%rbp), %rdi
callq 0x21d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../utils/MyBitMap.h
// Function: MyBitMap::findLeftOne()
int findLeftOne() {
		int i = _findLeftOne(rootLevel, rootIndex, 0, rootBit);
		/*
		for (i = 0; i < size;++i){
			if (data[i] !=0)break;
		}*/
		//cout << "nPosi " << i << " " << getLeafData(i) << endl;
		//cout << i << endl;
		//cout << data[0] << endl;
		uint lb = lowbit(getLeafData(i));
		int index = h[_hash(lb)];
		return (i << BIAS) + index;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl 0x10(%rdi), %esi
movl 0x14(%rdi), %edx
movl 0xc(%rdi), %r8d
xorl %ecx, %ecx
callq 0x68f0
movq -0x20(%rbp), %rdi
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
callq 0x6460
movl %eax, %edi
callq 0x6990
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
callq 0x6150
movslq %eax, %rcx
leaq 0x7a10(%rip), %rax      # 0xe210
movzbl (%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
shll $0x5, %eax
addl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../utils/MyBitMap.h
// Function: MyBitMap::setBit(int, unsigned int)
void setBit(int index, uint k) {
		//cout << data[0]<<endl;
		int p = setLeafBit(index, k);
		//cout <<"seting "<<data[0]<<endl;
		//cout << "ok" << endl;
		uint c = 1;
		if (getLeafData(p) == 0) {
			c = 0;
		}
		//cout << p << " " << c << endl;
		updateInner(0, 0, p, (size >> BIAS), c);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x69b0
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x14(%rbp), %esi
callq 0x6460
cmpl $0x0, %eax
jne 0x6867
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %ecx
movl 0x8(%rdi), %r8d
sarl $0x5, %r8d
movl -0x18(%rbp), %r9d
xorl %edx, %edx
movl %edx, %esi
callq 0x6a30
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../fileio/FileManager.h
// Function: FileManager::_openFile(char const*, int)
int _openFile(const char* name, int fileID) {
		int f = open(name, O_RDWR);
		if (f == -1) {
			return -1;
		}
		fd[fileID] = f;
		return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2, %esi
movb $0x0, %al
callq 0x2150
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x68cd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x68e2
movq -0x28(%rbp), %rax
movl -0x20(%rbp), %edx
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../utils/MyBitMap.h
// Function: MyBitMap::_findLeftOne(int, int, int, int)
int _findLeftOne(int level, int offset, int pos, int prevLevelCap) {
		uint lb = lowbit(inner[offset + pos]);
		int index = h[_hash(lb)];
		/*if (level == 0) {
			cout << "level0:" << index << " " << pos << endl;
		}*/
		int nPos = (pos << BIAS) + index;
		if (level == 0) {
		//	cout << "npos " << nPos << endl;
			return nPos;
		}
		return _findLeftOne(level - 1, offset - prevLevelCap, nPos, (prevLevelCap << BIAS));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x18(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movl 0x18(%rax,%rcx,4), %edi
callq 0x6990
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
callq 0x6150
movslq %eax, %rcx
leaq 0x78d8(%rip), %rax      # 0xe210
movzbl (%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
shll $0x5, %eax
addl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x6959
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x697c
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
movl -0x18(%rbp), %edx
subl -0x20(%rbp), %edx
movl -0x2c(%rbp), %ecx
movl -0x20(%rbp), %r8d
shll $0x5, %r8d
callq 0x68f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../utils/MyBitMap.h
// Function: MyBitMap::setLeafBit(int, unsigned int)
int setLeafBit(int index, uint k) {
		int pos, bit;
		getPos(index, pos, bit);
		uint umask = (1 << bit);
		uint mask = (~umask);
		if (k == 0) {
			umask = 0;
		}
		uint w = ((getLeafData(pos) & mask) | umask);
		setLeafData(pos, w);
		return pos;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %edi
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x6ae0
movl -0x18(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x69fd
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6460
movq -0x30(%rbp), %rdi
andl -0x20(%rbp), %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x6b20
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../utils/MyBitMap.h
// Function: MyBitMap::updateInner(int, int, int, int, unsigned int)
void updateInner(int level, int offset, int index, int levelCap, uint k) {
		//cout << level << " " << rootLevel << endl;
		uint* start = (&inner[offset]);
		int pos = _setBit(start, index, k);
		if (level == rootLevel) {
			return;
		}
		uint c = 1;
		if (start[pos] == 0) {
			c = 0;
		}
		/*
		if (level == 1) {
			cout << "level1:" << start[index] << " " << c << endl;
		}*/
		updateInner(level + 1, offset + levelCap, pos, (levelCap >> BIAS), c);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
addq $0x18, %rax
movslq -0x10(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x6b50
movq -0x38(%rbp), %rcx
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
jne 0x6a8b
jmp 0x6acb
movl $0x1, -0x30(%rbp)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x6aa7
movl $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
addl -0x18(%rbp), %edx
movl -0x2c(%rbp), %ecx
movl -0x18(%rbp), %r8d
sarl $0x5, %r8d
movl -0x30(%rbp), %r9d
callq 0x6a30
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: wwdatabase[P]database/./rcdmana/../bufmanager/../utils/MyBitMap.h
// Function: MyBitMap::_setBit(unsigned int*, int, unsigned int)
int _setBit(uint* start, int index, uint k) {
		int pos, bit;
		getPos(index, pos, bit);
		uint umask = (1 << bit);
		uint mask = (~umask);
		if (k == 0) {
			umask = 0;
		}
		start[pos] = ((start[pos] & mask) | umask);
		return pos;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %edi
leaq -0x1c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x6ae0
movl -0x20(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x6b99
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
andl -0x28(%rbp), %edx
orl -0x24(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: wwdatabase[P]database/./rcdmana/../bufmanager/BufPageManager.h
// Function: BufPageManager::writeBack(int)
void writeBack(int index) {
		if (dirty[index]) {
			int f, p;
			hash->getKeys(index, f, p);
			fileManager->writePage(f, p, addr[index], 0);
			dirty[index] = false;
		}
		replace->free(index);
		hash->remove(index);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
testb $0x1, (%rax,%rcx)
je 0x715f
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
leaq -0x10(%rbp), %rdx
leaq -0x14(%rbp), %rcx
callq 0x5ef0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
xorl %r8d, %r8d
callq 0x5520
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x7190
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x71c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: dechimal[P]TaggedUnion/include/desalt/datatypes/sum.hpp
// Function: void desalt::datatypes::detail::sum::sum<int, double, hoge, hoge>::assign<desalt::datatypes::detail::sum::sum<int, double, hoge, hoge> const&>(desalt::datatypes::detail::sum::sum<int, double, hoge, hoge> const&)
void assign(Union && other) {
        if (which_ == other.which_) {
            this->copy_or_move_assign(std::forward<Union>(other));
        } else {
            if (this->nothrow_constructible(std::forward<Union>(other))) {
                this->construct_using_nothrow_constructor(std::forward<Union>(other));
            } else {
                bool fallback;
                if constexpr (std::is_lvalue_reference_v<Union&&>) {
                    bool nothrow_move_constructible = other.nothrow_move_constructible();
                    if (nothrow_move_constructible) {
                        this->construct_using_right_hand_move_constructor(other);
                    }
                    fallback = !nothrow_move_constructible;
                } else {
                    fallback = true;
                }
                if (fallback) {
                    if (this->nothrow_move_constructible()) {
                        this->construct_using_auto_storage_save(std::forward<Union>(other));
                    } else if constexpr (enable_fallback) {
                        this->construct_using_fallback_type(std::forward<Union>(other));
                    } else {
                        this->construct_using_dynamic_storage_save(std::forward<Union>(other));
                    }
                }
            }
            this->set_which(other.which());
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xed64
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xee00
jmp 0xedfa
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xee40
testb $0x1, %al
jne 0xed77
jmp 0xed86
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xee70
jmp 0xede6
movq -0x10(%rbp), %rdi
callq 0xd4a0
andb $0x1, %al
movb %al, -0x12(%rbp)
testb $0x1, -0x12(%rbp)
je 0xeda7
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xeea0
movb -0x12(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0xede4
movq -0x20(%rbp), %rdi
callq 0xd4a0
testb $0x1, %al
jne 0xedc6
jmp 0xedd5
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xeee0
jmp 0xede2
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xef20
jmp 0xede4
jmp 0xede6
movq -0x10(%rbp), %rdi
callq 0xc8f0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0xd540
addq $0x20, %rsp
popq %rbp
retq
// File: dechimal[P]TaggedUnion/test_sum.cpp
// Function: hoge::operator=(hoge const&)
hoge & operator=(hoge const & other) {
        if (other.b) throw 0;
        x = other.x;
        b = other.b;
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0xd924
movl $0x4, %edi
callq 0x3080
movq %rax, %rdi
movl $0x0, (%rdi)
movq 0x236ad(%rip), %rsi     # 0x30fc8
xorl %eax, %eax
movl %eax, %edx
callq 0x3130
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movb %cl, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dechimal[P]TaggedUnion/include/desalt/datatypes/sum.hpp
// Function: auto void desalt::datatypes::detail::sum::sum<int, double, hoge, hoge>::construct_using_auto_storage_save<desalt::datatypes::detail::sum::sum<int, double, hoge, hoge>>(desalt::datatypes::detail::sum::sum<int, double, hoge, hoge>&&)::'lambda'(desalt::datatypes::detail::sum::sum<int, double, hoge, hoge>)::operator()<desalt::datatypes::detail::utils::tag<0ul>>(desalt::datatypes::detail::sum::sum<int, double, hoge, hoge>) const
void construct_using_auto_storage_save(Union && other) {
        this->dispatch([&] (auto t) {
            storage<t.value> tmp(std::move(this->get_unchecked(t)));
            this->destroy(t);
            try {
                this->construct(std::forward<Union>(other));
            } catch (...) {
                this->construct_directly(t, std::move(tmp));
                throw;
            }
        });
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq (%rax), %rdi
movq %rdi, -0x30(%rbp)
callq 0xd6a0
movq -0x30(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x14(%rbp)
callq 0xc9d0
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0xdca0
jmp 0xe3f1
jmp 0xe431
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3060
movq -0x30(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0xd330
callq 0x3100
jmp 0xe448
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3120
jmp 0xe42f
jmp 0xe437
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3140
movq %rax, %rdi
callq 0xbd10
nopl (%rax,%rax)
// File: dechimal[P]TaggedUnion/include/desalt/datatypes/sum.hpp
// Function: auto void desalt::datatypes::detail::sum::sum<int, double, hoge, hoge>::construct_using_fallback_type<desalt::datatypes::detail::sum::sum<int, double, hoge, hoge>, desalt::datatypes::detail::utils::tag<0ul>>(desalt::datatypes::detail::sum::sum<int, double, hoge, hoge>&&)::'lambda'(desalt::datatypes::detail::sum::sum<int, double, hoge, hoge>)::operator()<desalt::datatypes::detail::utils::tag<0ul>>(desalt::datatypes::detail::sum::sum<int, double, hoge, hoge>) const
void construct_using_fallback_type(Union && other) {
        this->dispatch([&] (auto t) {
            try {
                this->destroy(t);
                this->construct(std::forward<Union>(other));
            } catch (...) {
                this->construct_directly(FallbackTag{});
                this->set_which(FallbackTag::value);
                throw;
            }
        });
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq (%rax), %rdi
movq %rdi, -0x30(%rbp)
callq 0xc9d0
jmp 0xe872
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xdca0
jmp 0xe885
jmp 0xe8d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3060
movq -0x30(%rbp), %rdi
callq 0xe8f0
jmp 0xe8a7
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xd540
jmp 0xe8b4
callq 0x3100
jmp 0xe8e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3120
jmp 0xe8ce
jmp 0xe8d6
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3140
movq %rax, %rdi
callq 0xbd10
nopw (%rax,%rax)
// File: dechimal[P]TaggedUnion/include/desalt/datatypes/sum.hpp
// Function: auto void desalt::datatypes::detail::sum::sum<int, double, hoge, hoge>::construct_using_right_hand_move_constructor<desalt::datatypes::detail::sum::sum<int, double, hoge, hoge>>(desalt::datatypes::detail::sum::sum<int, double, hoge, hoge> const&)::'lambda'(desalt::datatypes::detail::sum::sum<int, double, hoge, hoge>)::operator()<desalt::datatypes::detail::utils::tag<0ul>>(desalt::datatypes::detail::sum::sum<int, double, hoge, hoge>) const
void construct_using_right_hand_move_constructor(Union const & other) {
        other.dispatch([&] (auto t) {
            using other_storage = typename std::decay_t<Union>::template storage<t.value>;
            other_storage tmp(other.get_unchecked(t));
            this->destroy();
            this->construct_directly(t, std::move(tmp));
        });
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rdi
callq 0xcef0
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x14(%rbp)
callq 0xc880
movq -0x20(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0xd330
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: dechimal[P]TaggedUnion/include/desalt/datatypes/sum.hpp
// Function: auto void desalt::datatypes::detail::sum::sum<hoge, hoge>::construct_using_dynamic_storage_save<desalt::datatypes::detail::sum::sum<hoge, hoge> const&>(desalt::datatypes::detail::sum::sum<hoge, hoge> const&)::'lambda'(desalt::datatypes::detail::sum::sum<hoge, hoge> const&)::operator()<desalt::datatypes::detail::utils::tag<0ul>>(desalt::datatypes::detail::sum::sum<hoge, hoge> const&) const
void construct_using_dynamic_storage_save(Union && other) {
        this->dispatch([&] (auto t) {
            auto p = new storage<t.value>(std::move_if_noexcept(this->get_unchecked(t)));
            try {
                this->destroy(t);
                this->construct(std::forward<Union>(other));
                delete p;
            } catch (...) {
                *reinterpret_cast<void **>(&this->storage_) = p;
                this->mark_as_backup();
                throw;
            }
        });
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movl $0x8, %edi
callq 0x30d0
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x10910
movq %rax, -0x38(%rbp)
jmp 0x113d8
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0xd140
jmp 0x113e7
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x102d0
jmp 0x113fa
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x10c50
jmp 0x1140d
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x11429
movq -0x58(%rbp), %rdi
movl $0x8, %esi
callq 0x30e0
jmp 0x1148b
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x8, %esi
callq 0x30e0
jmp 0x11491
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3060
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
callq 0x114b0
jmp 0x1146f
callq 0x3100
jmp 0x114a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3120
jmp 0x11489
jmp 0x11491
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3140
movq %rax, %rdi
callq 0xbd10
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: loga(unsigned int)
int loga(unsigned int u){ //log u
    if(u<1){/*printf("(%d)",u);*/return 0;}
    unsigned int e = 2;
    for(int i=1;i<32;i++){
        if(e>u){return i;}
        e *=2;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x1, -0x8(%rbp)
jae 0x1336
movl $0x0, -0x4(%rbp)
jmp 0x1374
movl $0x2, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
cmpl $0x20, -0x10(%rbp)
jge 0x136d
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jbe 0x135a
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1374
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1344
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: bread(bool*, int, int)
int bread(bool *u,int s,int l){
    if(s<0){return 0;}
    int e=0;
    for(int i=s;i<s+l;i++){
        e*=2;
        e += u[i];
        vain++;
    }
    return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x139d
movl $0x0, -0x4(%rbp)
jmp 0x13f5
movl $0x0, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jge 0x13ef
movl -0x1c(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl 0x4dcd(%rip), %eax      # 0x61a8
addl $0x1, %eax
movl %eax, 0x4dc4(%rip)      # 0x61a8
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x13aa
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)