LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl %esi, (%rdi)
je 0x467c
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rdi), %rax
movq (%rax), %rdx
movq 0x8(%rdx), %rax
movslq %esi, %rcx
movl 0x4(%rax,%rcx,8), %esi
cmpl %ecx, %esi
je 0x4663
movslq %esi, %r8
movslq (%rax,%rcx,8), %r9
movl %r9d, (%rax,%r8,8)
movl %esi, 0x4(%rax,%r9,8)
movl %ecx, 0x4(%rax,%rcx,8)
movl %ecx, (%rax,%rcx,8)
movslq (%rdx), %rdx
movslq 0x4(%rax,%rdx,8), %rsi
movl %ecx, (%rax,%rsi,8)
movl %esi, 0x4(%rax,%rcx,8)
movl %edx, (%rax,%rcx,8)
movl %ecx, 0x4(%rax,%rdx,8)
movl %ecx, (%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, (%rdi)
jne 0x4714
movq 0x48ff(%rip), %r15      # 0x8fd8
leaq 0x1c5d(%rip), %rsi      # 0x633d
movl $0x20, %edx
movq %r15, %rdi
callq 0x2170
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20c0
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x2120
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
movq %rsi, 0x8(%rdi)
movl $0xea60, %edi           # imm = 0xEA60
callq 0x2030
movq %rax, 0x20(%rbx)
movl $0x75300, %edi          # imm = 0x75300
callq 0x2030
movq %rax, 0x28(%rbx)
movl $0x18, %edi
callq 0x2150
movq %rax, %r14
movq %rax, %rdi
movl $0xea60, %esi           # imm = 0xEA60
movl $0xea60, %edx           # imm = 0xEA60
callq 0x4e30
movq %r14, 0x10(%rbx)
movl $0x10, %edi
callq 0x2150
movq %rax, %r14
movq %rax, %rdi
movl $0xea60, %esi           # imm = 0xEA60
callq 0x4ec4
movq %r14, 0x18(%rbx)
xorl %eax, %eax
movq 0x20(%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq 0x28(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq $0xea60, %rax           # imm = 0xEA60
jne 0x4815
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movl $0x10, %esi
jmp 0x484b
movq %rax, %rbx
movl $0x18, %esi
movq %r14, %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x200(%rdi), %rdi
callq 0x507c
movl %eax, (%r14)
movq 0x200(%rbx), %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x50cc
movslq (%r14), %r14
movq %r15, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x20e0
cmpl $-0x1, %eax
je 0x48a9
movl %eax, (%rbx,%r14,4)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r15d
movq %rcx, %r14
movslq %esi, %rax
movl (%rdi,%rax,4), %ebx
movslq %edx, %r12
shlq $0xd, %r12
movl %ebx, %edi
movq %r12, %rsi
xorl %edx, %edx
callq 0x2240
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r12, %rcx
jne 0x4902
movslq %r15d, %rax
leaq (%r14,%rax,4), %rsi
movl $0x2000, %edx           # imm = 0x2000
movl %ebx, %edi
callq 0x2050
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %edx, %ecx
leal (%rcx,%rsi), %eax
cltd
idivl 0x4(%rdi)
movq 0x8(%rdi), %rax
movq 0x8(%rax), %r8
movl (%rax), %r9d
addl %r9d, %edx
movslq %edx, %rax
movl (%r8,%rax,8), %eax
cmpl %eax, %r9d
jle 0x4a8a
movq 0x10(%rdi), %rdx
movslq %eax, %rdi
cmpl %esi, (%rdx,%rdi,8)
jne 0x4a81
cmpl %ecx, 0x4(%rdx,%rdi,8)
je 0x4a8f
movl (%r8,%rdi,8), %eax
cmpl %eax, %r9d
jg 0x4a73
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, -0x30(%rbp)
movl %esi, -0x2c(%rbp)
movq %rdi, %r12
movq 0x18(%rdi), %rdi
callq 0x4b8e
movl %eax, (%r15)
movq 0x28(%r12), %r14
movslq %eax, %rbx
movq (%r14,%rbx,8), %r13
testq %r13, %r13
je 0x4b02
movq 0x20(%r12), %rax
cmpb $0x1, (%rax,%rbx)
jne 0x4b13
movq 0x8(%r12), %rdi
movq 0x10(%r12), %rax
movq 0x10(%rax), %rax
movl (%rax,%rbx,8), %esi
movl 0x4(%rax,%rbx,8), %edx
movq %r13, %rcx
xorl %r8d, %r8d
callq 0x48b6
movq 0x20(%r12), %rax
movslq (%r15), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x4b13
movl $0x2000, %edi           # imm = 0x2000
callq 0x2030
movq %rax, %r13
movq %rax, (%r14,%rbx,8)
movq 0x10(%r12), %rdi
movl (%r15), %esi
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %ecx
callq 0x4bf6
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq (%rdi), %rax
movq 0x8(%rax), %rcx
movl (%rax), %eax
movslq %eax, %rdx
movl (%rcx,%rdx,8), %eax
cltq
movl 0x4(%rcx,%rax,8), %esi
cmpl %eax, %esi
je 0x4bc2
movslq %esi, %rdi
movslq (%rcx,%rax,8), %r8
movl %r8d, (%rcx,%rdi,8)
movl %esi, 0x4(%rcx,%r8,8)
movl %eax, 0x4(%rcx,%rax,8)
movl %eax, (%rcx,%rax,8)
movl 0x4(%rcx,%rax,8), %esi
cmpl %eax, %esi
je 0x4be1
movslq %esi, %rdi
movslq (%rcx,%rax,8), %r8
movl %r8d, (%rcx,%rdi,8)
movl %esi, 0x4(%rcx,%r8,8)
movl %eax, 0x4(%rcx,%rax,8)
movl %eax, (%rcx,%rax,8)
movslq 0x4(%rcx,%rdx,8), %rsi
movl %eax, (%rcx,%rsi,8)
movl %esi, 0x4(%rcx,%rax,8)
movl %edx, (%rcx,%rax,8)
movl %eax, 0x4(%rcx,%rdx,8)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
movl %edx, %r8d
movl 0x4(%rdi), %r11d
movq 0x8(%rdi), %r10
movq 0x8(%r10), %r9
movslq %esi, %rsi
movl 0x4(%r9,%rsi,8), %eax
cmpl %esi, %eax
je 0x4c2f
movslq %eax, %rdx
movslq (%r9,%rsi,8), %rbx
movl %ebx, (%r9,%rdx,8)
movl %eax, 0x4(%r9,%rbx,8)
movl %esi, 0x4(%r9,%rsi,8)
movl %esi, (%r9,%rsi,8)
leal (%rcx,%r8), %eax
cltd
idivl %r11d
movslq (%r10), %rax
movslq %edx, %rdx
addq %rax, %rdx
movslq (%r9,%rdx,8), %rax
movl %esi, (%r9,%rdx,8)
movl %edx, 0x4(%r9,%rsi,8)
movl %eax, (%r9,%rsi,8)
movl %esi, 0x4(%r9,%rax,8)
movq 0x10(%rdi), %rax
movl %r8d, (%rax,%rsi,8)
movl %ecx, 0x4(%rax,%rsi,8)
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rdi, %rbx
sarl $0x5, %esi
movl %esi, 0x8(%rdi)
movslq %esi, %rax
leaq (,%rax,4), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x2030
movq %rax, (%rbx)
xorl %ecx, %ecx
cmpl $0x1, %r14d
sete %dl
cmpl $0x0, 0x8(%rbx)
jle 0x4cc7
movb %dl, %cl
negl %ecx
movl 0x8(%rbx), %esi
cmpl $0x2, %esi
movl $0x1, %edx
cmovgel %esi, %edx
xorl %esi, %esi
movl %ecx, (%rax,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0x4cbc
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4cd4
nop
// File: /workspace/github_cpp_makefile_star2_O1/wwdatabase[P]database/./rcdmana/../bufmanager/../utils/MyBitMap.h
// Function: MyBitMap::init()
void init() {
		rootLevel = 0;
		int s = size;
		rootIndex = 0;
		while (s > LEAF_BIT) {
			int wordNum = (s >> BIAS);
			//cout << rootIndex << " " << s << " " << wordNum << endl;
			for (int i = 0; i < wordNum; ++ i) {
				uint w = 0;
				//cout << "---------------------------------------" << endl;
				for (int j = 0; j < LEAF_BIT; ++ j) {
					//cout << i << endl;
					uint k = (1 << j);
					uint c = childWord(rootIndex, s, i, j);
					if (c != 0) {
						w += k;
					}
				}
				inner[rootIndex + i] = w;
			}
			rootLevel ++;
			rootIndex += wordNum;
			s = wordNum;
		}
		rootBit = s;
		int i = 0;
		uint w = 0;
		for (int j = 0; j < rootBit; ++ j) {
			uint k = (1 << j);
			uint c = childWord(rootIndex, s, i, j);
			if (c != 0) {
				w += k;
			}
		}
		inner[rootIndex] = w;
		innerMask = getMask(BIAS);
		rootMask = getMask(s);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq $0x0, 0x10(%rdi)
movl 0x8(%rdi), %eax
movl %eax, %esi
negl %esi
xorl %edx, %edx
cmpl $0x21, %eax
jl 0x4da2
leaq 0x18(%rdi), %r9
movl %eax, %ebx
shrl $0x5, %ebx
movl %ebx, -0x2c(%rbp)
movl %eax, -0x30(%rbp)
cmpl $0x20, %eax
jb 0x4d7c
movl -0x2c(%rbp), %r10d
xorl %r11d, %r11d
xorl %ebx, %ebx
movslq %r11d, %r14
shlq $0x2, %r14
movl 0x14(%rdi), %r15d
leal (%r15,%rsi), %r12d
addq (%rdi), %r14
xorl %ecx, %ecx
xorl %r13d, %r13d
leal (%r12,%rcx), %eax
testl %r15d, %r15d
cltq
leaq (%r9,%rax,4), %rax
cmoveq %r14, %rax
movl $0x1, %r8d
shll %cl, %r8d
movl (%rax), %eax
testl %eax, %eax
cmovel %eax, %r8d
addl %r8d, %r13d
incq %rcx
addq $0x4, %r14
cmpq $0x20, %rcx
jne 0x4d2f
movslq 0x14(%rdi), %rcx
addq %rbx, %rcx
movl %r13d, 0x18(%rdi,%rcx,4)
incq %rbx
addl $0x20, %esi
addl $0x20, %r11d
cmpq %r10, %rbx
jne 0x4d18
incl 0x10(%rdi)
movl 0x14(%rdi), %r10d
movl -0x2c(%rbp), %ebx
addl %ebx, %r10d
movl %ebx, %esi
negl %esi
movl %r10d, 0x14(%rdi)
cmpl $0x41f, -0x30(%rbp)     # imm = 0x41F
movl %ebx, %eax
ja 0x4d01
jmp 0x4da7
xorl %r10d, %r10d
movl %eax, %ebx
movl %ebx, 0xc(%rdi)
testl %ebx, %ebx
jle 0x4df3
movq (%rdi), %r8
addl %r10d, %esi
movslq %esi, %rax
movl %ebx, %esi
leaq (%rdi,%rax,4), %r9
addq $0x18, %r9
xorl %ecx, %ecx
xorl %edx, %edx
testl %r10d, %r10d
movq %r9, %rax
cmoveq %r8, %rax
movl (%rax), %eax
movl $0x1, %r11d
shll %cl, %r11d
testl %eax, %eax
cmovel %eax, %r11d
addl %r11d, %edx
incq %rcx
addq $0x4, %r9
addq $0x4, %r8
cmpq %rcx, %rsi
jne 0x4dc5
movslq %r10d, %rax
movl %edx, 0x18(%rdi,%rax,4)
movl $0x1f, 0x124(%rdi)
testl %ebx, %ebx
jle 0x4e1d
xorl %ecx, %ecx
xorl %edx, %edx
movl $0x1, %eax
shll %cl, %eax
addl %eax, %edx
incl %ecx
cmpl %ecx, %ebx
jne 0x4e0c
jmp 0x4e1f
xorl %edx, %edx
movl %edx, 0x128(%rdi)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movslq %esi, %r12
leaq (,%r12,8), %rax
testl %r12d, %r12d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x10(%rbx)
testl %r12d, %r12d
jle 0x4e84
movl %r15d, %edx
shlq $0x3, %rdx
movq %rax, %rdi
movl $0xff, %esi
callq 0x20a0
movl $0x10, %edi
callq 0x2150
movq %rax, %r12
movq %rax, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x4f6a
movq %r12, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r12, %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %r14
movl %esi, 0x8(%rdi)
movl $0x10, %edi
callq 0x2150
movq %rax, %rbx
movq %rax, %rdi
movl %r15d, %esi
movl $0x1, %edx
callq 0x4f6a
movq %rbx, (%r14)
movslq 0x8(%r14), %rax
testq %rax, %rax
jle 0x4f46
movq 0x8(%rbx), %rcx
movl (%rbx), %edx
movslq %edx, %rdx
xorl %esi, %esi
movl 0x4(%rcx,%rsi,8), %edi
cmpq %rdi, %rsi
je 0x4f2b
movslq %edi, %rdi
movslq (%rcx,%rsi,8), %r8
movl %r8d, (%rcx,%rdi,8)
movl %edi, 0x4(%rcx,%r8,8)
movl %esi, 0x4(%rcx,%rsi,8)
movl %esi, (%rcx,%rsi,8)
movslq 0x4(%rcx,%rdx,8), %rdi
movl %esi, (%rcx,%rdi,8)
movl %edi, 0x4(%rcx,%rsi,8)
movl %edx, (%rcx,%rsi,8)
movl %esi, 0x4(%rcx,%rdx,8)
incq %rsi
cmpq %rsi, %rax
jne 0x4f0b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
addl %esi, %ebx
movslq %ebx, %r15
leaq (,%r15,8), %rax
testl %r15d, %r15d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x8(%r14)
testl %r15d, %r15d
jle 0x4fba
movl %ebx, %ecx
xorl %edx, %edx
movl %edx, (%rax,%rdx,8)
movl %edx, 0x4(%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x4fab
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rsi, %rdi
leaq 0x1346(%rip), %rsi      # 0x635e
callq 0x2180
testq %rax, %rax
je 0x502e
movq %rax, %rdi
callq 0x2140
xorl %eax, %eax
jmp 0x5075
movq 0x3fa3(%rip), %rbx      # 0x8fd8
leaq 0x1325(%rip), %rsi      # 0x6361
movl $0x4, %edx
movq %rbx, %rdi
callq 0x2170
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20c0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rdi), %r8d
movl 0x10(%rdi), %esi
movl 0x14(%rdi), %edx
xorl %ecx, %ecx
callq 0x5112
movq (%rbx), %rcx
cltq
movl (%rcx,%rax,4), %ecx
movl %ecx, %edx
negl %edx
andl %ecx, %edx
imulq $0x4325c53f, %rdx, %rcx # imm = 0x4325C53F
shrq $0x24, %rcx
imull $0x3d, %ecx, %ecx
subl %ecx, %edx
leaq 0x40b5(%rip), %rcx      # 0x9170
movzbl (%rdx,%rcx), %ecx
shll $0x5, %eax
addl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %esi, %ecx
movl %esi, %eax
movl $0x1, %esi
shll %cl, %esi
sarl $0x5, %eax
testl %edx, %edx
cmovel %edx, %esi
movq (%rdi), %rdx
cltq
movl (%rdx,%rax,4), %r8d
btrl %ecx, %r8d
xorl %r9d, %r9d
orl %esi, %r8d
movl %r8d, (%rdx,%rax,4)
setne %r9b
movl 0x8(%rdi), %r8d
sarl $0x5, %r8d
xorl %esi, %esi
xorl %edx, %edx
movl %eax, %ecx
popq %rbp
jmp 0x5162
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %ecx, %eax
leaq 0x4051(%rip), %rcx      # 0x9170
leal (%rax,%rdx), %r9d
movslq %r9d, %r9
movl 0x18(%rdi,%r9,4), %r9d
movl %r9d, %r10d
negl %r10d
andl %r9d, %r10d
imulq $0x4325c53f, %r10, %r9  # imm = 0x4325C53F
shrq $0x24, %r9
imull $0x3d, %r9d, %r9d
subl %r9d, %r10d
movzbl (%r10,%rcx), %r9d
shll $0x5, %eax
addl %r9d, %eax
subl $0x1, %esi
jb 0x515f
subl %r8d, %edx
shll $0x5, %r8d
jmp 0x511f
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
movl %ecx, %eax
movl %eax, %ecx
movslq %edx, %r10
movl $0x1, %r11d
shll %cl, %r11d
sarl $0x5, %eax
testl %r9d, %r9d
cmovel %r9d, %r11d
leaq (%rdi,%r10,4), %r9
movslq %eax, %rbx
movl 0x18(%r9,%rbx,4), %r10d
btrl %ecx, %r10d
orl %r11d, %r10d
movl %r10d, 0x18(%r9,%rbx,4)
cmpl 0x10(%rdi), %esi
je 0x51b3
xorl %r9d, %r9d
testl %r10d, %r10d
setne %r9b
incl %esi
addl %r8d, %edx
sarl $0x5, %r8d
jmp 0x5169
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movslq %esi, %r14
cmpb $0x1, (%rax,%r14)
jne 0x51fc
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
movl (%rax,%r14,8), %esi
movl 0x4(%rax,%r14,8), %edx
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rcx
xorl %r8d, %r8d
callq 0x48b6
movq 0x20(%rbx), %rax
movb $0x0, (%rax,%r14)
movq 0x18(%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rax
movl 0x4(%rax,%r14,8), %edx
cmpl %r14d, %edx
je 0x5228
movslq %edx, %rsi
movslq (%rax,%r14,8), %rdi
movl %edi, (%rax,%rsi,8)
movl %edx, 0x4(%rax,%rdi,8)
movl %r14d, 0x4(%rax,%r14,8)
movl %r14d, (%rax,%r14,8)
movslq (%rcx), %rcx
movslq (%rax,%rcx,8), %rdx
movl %r14d, (%rax,%rcx,8)
movl %ecx, 0x4(%rax,%r14,8)
movl %edx, (%rax,%r14,8)
movl %r14d, 0x4(%rax,%rdx,8)
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rcx), %rcx
movl 0x4(%rcx,%r14,8), %edx
cmpl %r14d, %edx
je 0x526e
movslq %edx, %rsi
movslq (%rcx,%r14,8), %rdi
movl %edi, (%rcx,%rsi,8)
movl %edx, 0x4(%rcx,%rdi,8)
movl %r14d, 0x4(%rcx,%r14,8)
movl %r14d, (%rcx,%r14,8)
movq 0x10(%rax), %rax
movq $-0x1, (%rax,%r14,8)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movb (%rsi), %al
cmpb $0x1, %al
je 0x4d50
movl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rdi)
movb %al, (%rdi)
movq %rdi, %rax
retq
pushq %rax
movl $0x4, %edi
callq 0x2060
movl $0x0, (%rax)
movq 0x9260(%rip), %rsi      # 0xdfc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O1/dechimal[P]TaggedUnion/include/desalt/datatypes/sum.hpp
// Function: void desalt::datatypes::detail::sum::visitor_table<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>), std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul>>::visit<0ul>(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>)&)
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
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rbx
movl 0x8(%rax), %ebp
movq %rsp, %rdi
movq %rbx, (%rdi)
movl (%rbx), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
leaq 0x8483(%rip), %rcx      # 0xd850
callq *(%rcx,%rax,8)
movl %ebp, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq (%rdi), %r15
movl $0x8, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x8(%r15), %r12
cmpl $0x0, (%r15)
movq %r12, %rsi
jns 0x5d2d
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x4bc8
cmpl $0x0, (%r15)
jns 0x5d49
movq (%r12), %rdi
movl $0x8, %esi
callq 0x20c0
movq 0x8(%r14), %rax
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
movq %rax, 0x8(%rdi)
movl (%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
leaq 0x7cb9(%rip), %rcx      # 0xda20
callq *(%rcx,%rax,8)
movl $0x8, %esi
movq %rbx, %rdi
callq 0x20c0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x2050
movq %rbx, 0x8(%r15)
orb $-0x80, 0x3(%r15)
callq 0x20f0
movq %rax, %r14
callq 0x2110
jmp 0x5dbb
movq %rax, %rdi
callq 0x4a50
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl %edi, %eax
cmpl $0x2, %edi
jb 0x1327
movl $0x2, %edx
movl $0x1, %ecx
movl %ecx, %esi
leal 0x1(%rsi), %ecx
cmpl $0x1e, %esi
ja 0x131d
addl %edx, %edx
cmpl %eax, %edx
jbe 0x130d
xorl %eax, %eax
cmpl $0x1f, %esi
cmovael %eax, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %eax, %eax
testl %esi, %esi
js 0x135a
testl %edx, %edx
jle 0x135a
addl %esi, %edx
movl 0x3e6e(%rip), %ecx      # 0x51a8
movl %esi, %eax
addq %rax, %rdi
xorl %eax, %eax
movzbl (%rdi), %r8d
leal (%r8,%rax,2), %eax
incl %ecx
incq %rdi
incl %esi
cmpl %esi, %edx
jg 0x1341
movl %ecx, 0x3e4e(%rip)      # 0x51a8
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: bwrite(bool*, int, int, int)
int bwrite(bool *u,int s,int l,int a){ 
    int c = s+l-loga(a);
    int e=a;
    for(int i=s+l-1;i>=s;i--){
        if(i<c){u[i]=0;continue;}
        if(e%2==0){u[i]=0;}else{u[i]=1;e--;}
        e/=2;
    }
    return 0;
}

// Assembly:
movl %ecx, %r8d
cmpl $0x2, %ecx
jb 0x138b
movl $0x2, %eax
movl $0x1, %r8d
movl %r8d, %r9d
leal 0x1(%r9), %r8d
cmpl $0x1e, %r9d
ja 0x1381
addl %eax, %eax
cmpl %ecx, %eax
jbe 0x136e
xorl %eax, %eax
cmpl $0x1f, %r9d
cmovael %eax, %r8d
testl %edx, %edx
jle 0x13d4
addl %esi, %edx
movslq %edx, %rax
subl %r8d, %edx
movslq %edx, %rdx
movslq %esi, %rsi
cmpq %rdx, %rax
jle 0x13ae
testb $0x1, %cl
jne 0x13b5
movb $0x0, -0x1(%rdi,%rax)
jmp 0x13bc
movb $0x0, -0x1(%rdi,%rax)
jmp 0x13cc
movb $0x1, -0x1(%rdi,%rax)
decl %ecx
movl %ecx, %r8d
shrl $0x1f, %r8d
addl %ecx, %r8d
sarl %r8d
movl %r8d, %ecx
decq %rax
cmpq %rsi, %rax
jg 0x139d
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: logb(unsigned int, int, bool*)
void logb(unsigned int u,int n,bool *ar){
    unsigned int e = u;
    bool c[n];
    for(int i=n-1;i>=0;i--){
        c[i] = e%2;
        e /=2;
    }
    for(int i=0;i<n;i++){ar[kad]=c[i];kad++;}
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %esi, %eax
movq %rsp, %rsi
leaq 0xf(%rax), %rcx
andq $-0x10, %rcx
subq %rcx, %rsi
movq %rsi, %rsp
testl %ebx, %ebx
jle 0x1412
leaq 0x1(%rax), %rcx
movl %edi, %r8d
andb $0x1, %r8b
movb %r8b, -0x2(%rsi,%rcx)
shrl %edi
decq %rcx
cmpq $0x1, %rcx
jg 0x13fb
testl %ebx, %ebx
jle 0x1434
movslq 0x3d8f(%rip), %r14      # 0x51ac
addq %r14, %rdx
movq %rdx, %rdi
movq %rax, %rdx
callq 0x10a0
addl %r14d, %ebx
movl %ebx, 0x3d78(%rip)      # 0x51ac
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: logg(unsigned int, bool*)
void logg(unsigned int u, bool *ar){ 
    if(u<1){printf("under 0(%d) cannot be express in elias ganma\n",u);return;}
    int l = loga(u);
    for(int i=1;i<l;i++){ar[kad]=0;kad++;}
    logb(u,l,ar);
    return;
}

// Assembly:
testl %edi, %edi
je 0x14bc
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl %edi, %r14d
cmpl $0x1, %edi
je 0x147b
movl $0x2, %eax
movl $0x1, %r14d
movl %r14d, %ecx
leal 0x1(%rcx), %r14d
cmpl $0x1e, %ecx
ja 0x1472
addl %eax, %eax
cmpl %ebp, %eax
jbe 0x1460
xorl %eax, %eax
cmpl $0x1f, %ecx
cmovael %eax, %r14d
cmpl $0x2, %r14d
jl 0x14a5
movslq 0x3d24(%rip), %r15      # 0x51ac
movq %r15, %rdi
addq %rbx, %rdi
leal -0x1(%r14), %edx
xorl %esi, %esi
callq 0x1070
leal (%r14,%r15), %eax
decl %eax
movl %eax, 0x3d07(%rip)      # 0x51ac
movl %ebp, %edi
movl %r14d, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x13d7
leaq 0x1b41(%rip), %rdi      # 0x3004
xorl %esi, %esi
xorl %eax, %eax
jmp 0x1030
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: diff(unsigned int*, int, int)
void diff(unsigned int *T,int s,int n){
    for(int i=n-2;i>=0;i--){
        if(T[s+i+1]>=T[s+i]){T[s+i+1] = T[s+i+1] - T[s+i];}
        else{T[s+i+1] = T[s+i] - T[s+i+1];}
    }
    return;
}

// Assembly:
cmpl $0x2, %edx
jl 0x1544
movslq %edx, %rax
movslq %esi, %rcx
leaq (%rdi,%rcx,4), %rcx
decq %rax
movl (%rcx,%rax,4), %edx
movl -0x4(%rcx,%rax,4), %esi
movl %edx, %edi
subl %esi, %edi
negl %edi
subl %esi, %edx
cmovbl %edi, %edx
movl %edx, (%rcx,%rax,4)
decq %rax
jg 0x152a
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: cd1(int, bool*)
int cd1(int x,bool *ar){ //unary x
    if(x==0){ar[kad2]=0;kad2++;return 0;}
    ar[kad2]=1;kad2++;
    return cd1(x-1,ar);
}

// Assembly:
xorl %eax, %eax
xorl %edx, %edx
movslq 0x3c47(%rip), %r8       # 0x51b0
leal 0x1(%r8), %r9d
subl $0x1, %edi
jb 0x1588
movb $0x1, (%rsi,%r8)
movl %r9d, 0x3c32(%rip)      # 0x51b0
testb $0x1, %dl
cmovel %eax, %ecx
movb $0x1, %dl
jmp 0x1562
movb $0x0, (%rsi,%r8)
movl %r9d, 0x3c1c(%rip)      # 0x51b0
xorl %eax, %eax
testb $0x1, %dl
cmovnel %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: fano(int*, int, int, int, bool*, bool*)
int fano(int *T,int s,int n,int p,bool *ar,bool *ar2){
    kad = 0;
    kad2 = 0;
    int topofs = 0;
    int t = ppow(p);
    //printf("\np=%d / t=%d",p,t);
    for(int i=s;i<n;i++){
        cd1(T[i]/t-topofs,ar2);
        topofs = T[i]/t;
        logb(T[i]%t,p,ar);
    }
    Sizelist[9] = kad2;
    Sizelist[10] = kad;
    return kad/8 + kad2/8;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
xorl %r13d, %r13d
movl %r13d, 0x3be2(%rip)     # 0x51ac
movl %r13d, 0x3bdf(%rip)     # 0x51b0
movl %ecx, %edi
callq 0x1545
subl %r14d, %r15d
jle 0x1622
movl %eax, %r12d
movslq %r14d, %rax
leaq (%rbx,%rax,4), %rbx
xorl %r14d, %r14d
movl (%rbx,%r14,4), %eax
cltd
idivl %r12d
subl %r13d, %eax
movl %eax, %edi
movq 0x10(%rsp), %rsi
callq 0x155e
movl (%rbx,%r14,4), %eax
cltd
idivl %r12d
movl %edx, %edi
movl %eax, %r13d
movl %ebp, %esi
movq 0x8(%rsp), %rdx
callq 0x13d7
incq %r14
cmpl %r14d, %r15d
jne 0x15ea
movl 0x3b88(%rip), %ecx      # 0x51b0
movl %ecx, 0x3b36(%rip)      # 0x5164
movl 0x3b78(%rip), %edx      # 0x51ac
leal 0x7(%rdx), %esi
testl %edx, %edx
cmovnsl %edx, %esi
sarl $0x3, %esi
leal 0x7(%rcx), %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
movl %edx, 0x3b1b(%rip)      # 0x5168
sarl $0x3, %eax
addl %esi, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: fano0(unsigned int*, int*, bool*)
void fano0(unsigned int *D,int *D_2,bool *ar){
    kad = 0;
    ccs[kad]=0;cc2s[kad]=0;kad++;
    int r = 0;
    for(int i=0;i<dc2s[loops];i++){
        int h = D[D_2[i]];
        if(i>0){h = D[D_2[i]]-D[D_2[i-1]];}
        if(h<0){h=D[D_2[i]];cc2s[kad]=i+r;ccs[kad]=r;kad++;}
        cd1(h,ar); 
        r+=h;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r12d, %r12d
movl %r12d, 0x3bea(%rip)     # 0x5260
movl %r12d, 0x3c33(%rip)     # 0x52b0
movl $0x1, 0x3b25(%rip)      # 0x51ac
movslq 0x3a9e(%rip), %rax      # 0x512c
leaq 0x3b7b(%rip), %rcx      # 0x5210
cmpl %r12d, (%rcx,%rax,4)
jle 0x1717
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
movslq (%r14,%r13,4), %rax
movl (%r15,%rax,4), %eax
movl %eax, %ebp
testq %r13, %r13
je 0x16c1
movslq -0x4(%r14,%r13,4), %rcx
movl %eax, %ebp
subl (%r15,%rcx,4), %ebp
testl %ebp, %ebp
jns 0x16f0
leal (%r12,%r13), %ecx
movslq 0x3adc(%rip), %rdx      # 0x51ac
leaq 0x3bd9(%rip), %rsi      # 0x52b0
movl %ecx, (%rsi,%rdx,4)
leaq 0x3b7f(%rip), %rcx      # 0x5260
movl %r12d, (%rcx,%rdx,4)
leal 0x1(%rdx), %ecx
movl %ecx, 0x3abe(%rip)      # 0x51ac
movl %eax, %ebp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x155e
addl %ebp, %r12d
incq %r13
movslq 0x3a25(%rip), %rax      # 0x512c
leaq 0x3b02(%rip), %rcx      # 0x5210
movslq (%rcx,%rax,4), %rax
cmpq %rax, %r13
jl 0x16a7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: dmlen(int, unsigned int*, int*)
int dmlen(int p,unsigned int *D,int *D_2){
    int u = 0;
    for(int i=D_2[p];i<D_2[p+1];i++){
        if(i!=D_2[p]){
            if(D[i]<D[i-1] && u==0){u=D_2[p+1]-i;break;}
        }
    }
    if(u==D_2[p+1]-D_2[p]-1){ //set for some exception
        for(int o = loops-1;o>0;o--){
            if(p>=dc2s[o]){
                exceptr[o] = p;
                break;
            }
        }
    }
    if(u>0){u = D_2[p+1]-D_2[p]-u;}
    else{u=1;}
    return u;
}

// Assembly:
movslq %edi, %rcx
movslq (%rdx,%rcx,4), %rax
movl 0x4(%rdx,%rcx,4), %r8d
cmpl %eax, %r8d
jle 0x175c
leaq (%rsi,%rax,4), %rsi
movl %r8d, %r10d
subl %eax, %r10d
xorl %r9d, %r9d
testq %r9, %r9
je 0x1754
movl (%rsi,%r9,4), %r11d
cmpl -0x4(%rsi,%r9,4), %r11d
jb 0x17af
incq %r9
cmpl %r9d, %r10d
jne 0x1744
xorl %esi, %esi
notl %eax
addl %eax, %r8d
cmpl %r8d, %esi
jne 0x179b
movl 0x39bd(%rip), %r8d      # 0x512c
leaq 0x3b8a(%rip), %rax      # 0x5300
leaq (%rax,%r8,4), %rax
leaq 0x3a8f(%rip), %r9       # 0x5210
cmpl $0x2, %r8d
jl 0x179b
leaq -0x1(%r8), %r10
addq $-0x4, %rax
cmpl %edi, -0x4(%r9,%r8,4)
movq %r10, %r8
jg 0x1781
movl %edi, (%rax)
testl %esi, %esi
jle 0x17a9
movl 0x4(%rdx,%rcx,4), %eax
addl (%rdx,%rcx,4), %esi
subl %esi, %eax
retq
movl $0x1, %eax
retq
movl %r8d, %esi
subl %eax, %esi
subl %r9d, %esi
jmp 0x175e
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: cmlen(int*, int, int, bool*)
int cmlen(int *m,int p,int l,bool *ar){ 
    kad = 0;
    int u = 0;
    for(int i=0;i<l;i++){
        if(i!=0){
            int tm = m[p+i]-m[p+i-1];
            if(tm<0){
                if(u==0){u=i;}
                tm=-tm;
            }
            logg(tm+1,ar);
        }
    }
    if(u<=0){u=1;}
    return u;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x0, 0x39e1(%rip)      # 0x51ac
testl %edx, %edx
jle 0x1817
movq %rcx, %rbx
movslq %esi, %rax
movl %edx, %r14d
leaq (%rdi,%rax,4), %r15
xorl %r12d, %r12d
xorl %ebp, %ebp
testq %r12, %r12
je 0x180d
movl (%r15,%r12,4), %eax
subl -0x4(%r15,%r12,4), %eax
testl %ebp, %ebp
movl %r12d, %ecx
cmovnel %ebp, %ecx
testl %eax, %eax
cmovsl %ecx, %ebp
movl %eax, %edi
negl %edi
cmovsl %eax, %edi
incl %edi
movq %rbx, %rsi
callq 0x143d
incq %r12
cmpq %r12, %r14
jne 0x17e1
jmp 0x1819
xorl %ebp, %ebp
cmpl $0x2, %ebp
movl $0x1, %eax
cmovgel %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: gread(int, bool*)
int gread(int p,bool *ar){
    int i = 0;
    while(1){
        if(ar[p+i]==1){break;}
        i++;}
    int u = i;
    int a = 0;
    while(u>=0){
        a*=2;a+=ar[p+i];i++;u--;}
    return a;
}

// Assembly:
movslq %edi, %rax
leaq (%rsi,%rax), %rdx
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
xorl %ecx, %ecx
addl $0x2, %edi
cmpb $0x1, (%rdx,%rcx)
leaq 0x1(%rcx), %rcx
jne 0x183b
leaq (%rax,%rsi), %rdx
decq %rdx
movl %edi, %esi
addq $0x2, %rsi
xorl %eax, %eax
movzbl (%rdx,%rcx), %edi
leal (%rdi,%rax,2), %eax
incq %rcx
cmpq %rcx, %rsi
jne 0x1857
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: rank1(bool*, int, int)
int rank1(bool *u,int ar,int s){ //bool配列u上の，sから始まってar文字までの1の個数を返す()．
    if(s<0){printf("[Error]rank1() with position s\n");exit(0);}
    if(ar<=0){return 0;}
    int e = 0;
    for(int i=s;i<s+ar;i++){
        if(u[i]==1){e++;}
    }
    return e;
}

// Assembly:
pushq %rax
testl %edx, %edx
js 0x188d
testl %esi, %esi
jle 0x1889
addl %edx, %esi
movl %edx, %eax
addq %rax, %rdi
xorl %eax, %eax
movzbl (%rdi), %ecx
addl %ecx, %eax
incq %rdi
incl %edx
cmpl %edx, %esi
jg 0x1879
jmp 0x188b
xorl %eax, %eax
popq %rcx
retq
leaq 0x1872(%rip), %rdi      # 0x3106
callq 0x1160
xorl %edi, %edi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: srank1(int, bool*, int*, unsigned short*, int, int)
int srank1(int c,bool *u,int *u2,unsigned short int *u3,int t2,int t3){
    if(c<=0){return 0;}
    int r = c/lpurse;
    int nk = (c - r*lpurse)/spurse;
    int s =0;int e = 0;
    if(r>0){
        s = lpurse*r;
        e = u2[r-1];}
    if(nk>0){
        e+=u3[r*spursesuu+nk];
        s+=nk*spurse;}
    for(int i=s;i<c;i++){if(u[i]==1){e++;}}
    return e;
}

// Assembly:
testl %edi, %edi
jle 0x18d9
movq %rdx, %r9
movl 0x3882(%rip), %r10d     # 0x5130
movl %edi, %eax
cltd
idivl %r10d
movl %eax, %r8d
movl %edx, %eax
movl 0x3874(%rip), %r11d     # 0x5134
cltd
idivl %r11d
movl %eax, %edx
testl %r8d, %r8d
jle 0x18dc
imull %r8d, %r10d
movl %r8d, %eax
movl -0x4(%r9,%rax,4), %eax
jmp 0x18e1
xorl %eax, %eax
retq
xorl %r10d, %r10d
xorl %eax, %eax
testl %edx, %edx
jle 0x1901
imull 0x3a63(%rip), %r8d      # 0x5350
addl %edx, %r8d
movslq %r8d, %r8
movzwl (%rcx,%r8,2), %ecx
addl %ecx, %eax
imull %edx, %r11d
addl %r11d, %r10d
cmpl %edi, %r10d
jge 0x1919
movslq %r10d, %rcx
movl %edi, %edx
movzbl (%rsi,%rcx), %edi
addl %edi, %eax
incq %rcx
cmpq %rcx, %rdx
jne 0x190b
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: getd2(int)
int getd2(int tgm){
    int tgm2 = select0(d2top,d2topsub,d2topsub2,tgm+1,Sizelist[9],Sizelist[5],Sizelist[6]); //tgm2 = その位置までの1の数を見る．
    int tgm3 = srank1(tgm2,d2top,d2topsub,d2topsub2,Sizelist[5],Sizelist[6]);
    int tgm4 = bread(d2under,tgm*6,6);
    return tgm3*64+tgm4;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x38ef(%rip), %r14      # 0x53b0
movq 0x38b0(%rip), %r15      # 0x5378
movq 0x3891(%rip), %r12      # 0x5360
leal 0x1(%rbx), %ecx
movl 0x368b(%rip), %r8d      # 0x5164
movl 0x3674(%rip), %r9d      # 0x5154
movl 0x3672(%rip), %eax      # 0x5158
movl %eax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x191a
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x18a0
testl %ebx, %ebx
js 0x1b43
addl %ebx, %ebx
leal (%rbx,%rbx,2), %edx
leal (%rbx,%rbx,2), %edi
addl $0x6, %edi
movl 0x368c(%rip), %esi      # 0x51a8
movq 0x3885(%rip), %r8       # 0x53a8
addq %rdx, %r8
xorl %ecx, %ecx
movzbl (%r8), %r9d
leal (%r9,%rcx,2), %ecx
incl %esi
incl %edx
incq %r8
cmpl %edx, %edi
jg 0x1b28
movl %esi, 0x3667(%rip)      # 0x51a8
jmp 0x1b45
xorl %ecx, %ecx
shll $0x6, %eax
addl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: gethead(int)
int gethead(int tgm){
    int tgm2 = select0(k3,k3sub,k3sub2,tgm+1,Sizelist[8],Sizelist[3],Sizelist[4]); //tgm2 = その位置までの1の数を見る．
    int tgm3 = srank1(tgm2,k3,k3sub,k3sub2,Sizelist[3],Sizelist[4]); //その位置までの1の数 = 開始文字.
    for(int o = loops-1;o>0;o--){
            if(tgm2>=cc2s[o]){tgm3-=ccs[o];break;}
    }
    return tgm3;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x383b(%rip), %r14      # 0x53a0
movq 0x3814(%rip), %r15      # 0x5380
movq 0x37f5(%rip), %r12      # 0x5368
leal 0x1(%rdi), %ecx
movl 0x35e3(%rip), %r8d      # 0x5160
movl 0x35c8(%rip), %r9d      # 0x514c
movl 0x35c6(%rip), %eax      # 0x5150
movl %eax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x191a
movl %eax, %ebx
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x18a0
movl 0x3579(%rip), %edx      # 0x512c
leaq 0x36a6(%rip), %rcx      # 0x5260
leaq (%rcx,%rdx,4), %rcx
leaq 0x36eb(%rip), %rsi      # 0x52b0
cmpl $0x2, %edx
jl 0x1bdd
leaq -0x1(%rdx), %rdi
addq $-0x4, %rcx
cmpl -0x4(%rsi,%rdx,4), %ebx
movq %rdi, %rdx
jl 0x1bc5
subl (%rcx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: psread(int, bool*, int, int, int)
int psread(int p,bool *ar,int D2start,int D2end,int basekey){
    printf("[%d]%d ",D2start,basekey);
    int a;
    int turnsl = 0;
    int st = D2start;
    for(int i = 0;i<1000;i++){
        a = gread(st,ar);
        st += 2*loga(a)-1;
        if(i>0){
            if(i>=turnsl){basekey-=a-1;}
            else{basekey += a-1;}
            printf("%d ",basekey);
        }
        else{
            turnsl = a;
            if(a==1){turnsl=65535;}
        }
        if(st>=D2end){break;}
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r15d
movl %ecx, 0x4(%rsp)
movl %edx, %ebp
movq %rsi, %rbx
leaq 0x1428(%rip), %rdi      # 0x3032
movl %edx, %esi
movl %r8d, %edx
xorl %eax, %eax
callq 0x1030
movq %rbx, 0x10(%rsp)
leaq -0x1(%rbx), %rax
movq %rax, 0x8(%rsp)
xorl %ebx, %ebx
xorl %r14d, %r14d
movslq %ebp, %rax
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax), %rsi
movq $-0x1, %r8
movl $0x1, %edi
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
addl $0x2, %edx
cmpb $0x1, 0x1(%rsi,%r8)
movq %rdi, %rcx
leaq 0x1(%r8), %r8
leaq 0x1(%rdi), %rdi
jne 0x1c46
addq 0x8(%rsp), %rax
movl %edx, %edx
addq $0x2, %rdx
xorl %r13d, %r13d
movzbl (%rax,%rcx), %esi
leal (%rsi,%r13,2), %r13d
incq %rcx
cmpq %rcx, %rdx
jne 0x1c6a
testl %r13d, %r13d
je 0x1c8d
cmpl $0x1, %r13d
jne 0x1c95
movl $0x1, %r12d
jmp 0x1cc6
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
jmp 0x1cc6
movl $0x2, %eax
movl $0x1, %r12d
movl $0x1, %edx
movl %edx, %ecx
addl $0x2, %r12d
cmpl $0x1e, %edx
ja 0x1cba
addl %eax, %eax
leal 0x1(%rcx), %edx
cmpl %r13d, %eax
jbe 0x1ca5
cmpl $0x1f, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovael %eax, %r12d
testl %ebx, %ebx
je 0x1cf5
movl $0x1, %eax
subl %r13d, %eax
decl %r13d
cmpl %r14d, %ebx
cmovgel %eax, %r13d
addl %r15d, %r13d
leaq 0x1350(%rip), %rdi      # 0x3036
movl %r13d, %esi
xorl %eax, %eax
callq 0x1030
movl %r13d, %r15d
jmp 0x1d05
cmpl $0x1, %r13d
movl $0xffff, %eax           # imm = 0xFFFF
cmovel %eax, %r13d
movl %r13d, %r14d
addl %r12d, %ebp
cmpl 0x4(%rsp), %ebp
jge 0x1d1c
incl %ebx
cmpl $0x3e8, %ebx            # imm = 0x3E8
jne 0x1c29
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: uhdisp(int)
void uhdisp(int tgm){
    printf("\n%d:",tgm);
    int D2start = getd2(tgm);
    int D2end = getd2(tgm+1);
    int tgm3 = gethead(tgm);
    psread(tgm,k,D2start,D2end,tgm3);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x1300(%rip), %rdi      # 0x303a
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
movl %ebx, %edi
callq 0x1ab0
movl %eax, %ebp
leal 0x1(%rbx), %edi
callq 0x1ab0
movl %eax, %r14d
movl %ebx, %edi
callq 0x1b56
movq 0x3633(%rip), %rsi      # 0x5398
movl %ebp, %edx
movl %r14d, %ecx
movl %eax, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0x1be9
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: queryload(int*)
int queryload(int *m){
    char qname[] = "query.txt";
    char chr;
    FILE *fp;
    long long int qsize = std::filesystem::file_size(qname);
    fp = fopen(qname, "r"); // open file or return null
    if(fp == NULL) {
        printf("%s such file doesn't exist!\n", qname);
        return -1;
    }
    int i = 0;
    for(i=0;i<qsize;i++) {
        chr = fgetc(fp);
        m[i] = chr;
        if(chr<0){m[i]=chr + 256;}
    }
    return (int)qsize;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movabsq $0x78742e7972657571, %rax # imm = 0x78742E7972657571
movq %rsp, %rsi
movq %rax, (%rsi)
movw $0x74, 0x8(%rsi)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x2, %edx
callq 0x2c40
movq %r14, %rdi
callq 0x1130
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x2cc8
leaq 0x10de(%rip), %rsi      # 0x3085
movq %rsp, %rdi
callq 0x10e0
testq %rax, %rax
je 0x1fd8
testq %r14, %r14
jle 0x1fef
movq %rax, %r15
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x1170
movzbl %al, %eax
movl %eax, (%rbx,%r12,4)
incq %r12
cmpq %r12, %r14
jne 0x1fbf
jmp 0x1fef
leaq 0x10a8(%rip), %rdi      # 0x3087
movq %rsp, %rsi
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2cc8
movq %rbx, %rdi
callq 0x1180