LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4f3c
movl %eax, (%r14)
movq 0x200(%rbx), %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x4f8c
movslq (%r14), %r14
movq %r15, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x20e0
cmpl $-0x1, %eax
je 0x47af
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_O3/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 0x4992
movq 0x10(%rdi), %rdx
movslq %eax, %rdi
cmpl %esi, (%rdx,%rdi,8)
jne 0x4989
cmpl %ecx, 0x4(%rdx,%rdi,8)
je 0x4997
movl (%r8,%rdi,8), %eax
cmpl %eax, %r9d
jg 0x497b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r10
movl %edx, %r8d
movl %esi, %r9d
movq %rdi, %r15
movq 0x18(%rdi), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rax
movl (%rcx), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,8), %r12d
movslq %r12d, %r14
movl 0x4(%rax,%r14,8), %edx
cmpl %r14d, %edx
je 0x49e8
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)
movslq 0x4(%rax,%rcx,8), %rdx
movl %r14d, (%rax,%rdx,8)
movl %edx, 0x4(%rax,%r14,8)
movl %ecx, (%rax,%r14,8)
movl %r14d, 0x4(%rax,%rcx,8)
movl %r14d, (%r10)
movq 0x28(%r15), %r13
movq (%r13,%r14,8), %rbx
testq %rbx, %rbx
je 0x4a59
movq 0x20(%r15), %rax
cmpb $0x1, (%rax,%r14)
jne 0x4a79
movq 0x8(%r15), %rdi
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movl (%rax,%r14,8), %esi
movl 0x4(%rax,%r14,8), %edx
movq %rbx, %rcx
movl %r8d, %r14d
xorl %r8d, %r8d
movl %r9d, %r12d
movq %r10, %r13
callq 0x47bc
movl %r12d, %r9d
movl %r14d, %r8d
movq 0x20(%r15), %rax
movslq (%r13), %r12
movb $0x0, (%rax,%r12)
jmp 0x4a79
movl $0x2000, %edi           # imm = 0x2000
movl %r8d, -0x2c(%rbp)
movl %r9d, %ebx
callq 0x2030
movl %ebx, %r9d
movl -0x2c(%rbp), %r8d
movq %rax, %rbx
movq %rax, (%r13,%r14,8)
movq 0x10(%r15), %rdi
movl %r12d, %esi
movl %r9d, %edx
movl %r8d, %ecx
callq 0x4af4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
sarl $0x5, %r14d
movl %r14d, 0x8(%rdi)
leaq (,%r14,4), %rax
testl %r14d, %r14d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
xorl %ecx, %ecx
cmpl $0x1, %r15d
sete %dl
movq %rax, (%rbx)
testl %r14d, %r14d
jle 0x4bb6
movb %dl, %cl
negl %ecx
xorl %edx, %edx
movl %ecx, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %r14
jne 0x4bab
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4bc8
// File: /workspace/github_cpp_makefile_star2_O3/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), %edx
movl %edx, %eax
negl %eax
xorl %r8d, %r8d
cmpl $0x21, %edx
jl 0x4caa
leaq 0x18(%rdi), %rsi
movl %edx, %ecx
shrl $0x5, %ecx
movl %edx, -0x2c(%rbp)
movl %ecx, %edx
movl %ecx, %r8d
xorl %r10d, %r10d
xorl %r11d, %r11d
movslq %r10d, %r14
shlq $0x2, %r14
movslq 0x14(%rdi), %rbx
leal (%rbx,%rax), %r15d
addq (%rdi), %r14
xorl %ecx, %ecx
xorl %r12d, %r12d
leal (%r15,%rcx), %r13d
testl %ebx, %ebx
movslq %r13d, %r13
leaq (%rsi,%r13,4), %r13
cmoveq %r14, %r13
movl $0x1, %r9d
shll %cl, %r9d
movl (%r13), %r13d
testl %r13d, %r13d
cmovel %r13d, %r9d
addl %r9d, %r12d
incq %rcx
addq $0x4, %r14
cmpq $0x20, %rcx
jne 0x4c1e
addq %r11, %rbx
movl %r12d, (%rsi,%rbx,4)
incq %r11
addl $0x20, %eax
addl $0x20, %r10d
cmpq %r8, %r11
jne 0x4c07
movl 0x10(%rdi), %r10d
leal 0x1(%r10), %eax
movl %eax, 0x10(%rdi)
movl 0x14(%rdi), %r8d
addl %edx, %r8d
movl %edx, %eax
negl %eax
movl %r8d, 0x14(%rdi)
cmpl $0x41f, -0x2c(%rbp)     # imm = 0x41F
jbe 0x4caa
movl %edx, %ecx
shrl $0x5, %ecx
cmpl $0x1f, %edx
ja 0x4bf9
addl $0x2, %r10d
movl %r10d, 0x10(%rdi)
movl %r8d, 0x14(%rdi)
xorl %eax, %eax
jmp 0x4cac
movl %edx, %ecx
movl %ecx, 0xc(%rdi)
testl %ecx, %ecx
jle 0x4d25
movl %ecx, %edx
movq (%rdi), %rsi
addl %r8d, %eax
cltq
leaq (%rdi,%rax,4), %rax
addq $0x18, %rax
xorl %ecx, %ecx
xorl %r9d, %r9d
testl %r8d, %r8d
movq %rax, %r10
cmoveq %rsi, %r10
movl (%r10), %r10d
movl $0x1, %r11d
shll %cl, %r11d
testl %r10d, %r10d
cmovel %r10d, %r11d
addl %r11d, %r9d
incq %rcx
addq $0x4, %rax
addq $0x4, %rsi
cmpq %rcx, %rdx
jne 0x4cca
movslq %r8d, %rax
movl %r9d, 0x18(%rdi,%rax,4)
movl $0x1f, 0x124(%rdi)
testl %edx, %edx
jle 0x4d3a
xorl %ecx, %ecx
xorl %eax, %eax
movl $0x1, %esi
shll %cl, %esi
addl %esi, %eax
incl %ecx
cmpl %ecx, %edx
jne 0x4d14
jmp 0x4d3c
movslq %r8d, %rax
movl $0x0, 0x18(%rdi,%rax,4)
movl $0x1f, 0x124(%rdi)
xorl %eax, %eax
movl %eax, 0x128(%rdi)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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)
movl %esi, %r12d
shlq $0x3, %r12
testl %esi, %esi
movq $-0x1, %rdi
cmovnsq %r12, %rdi
callq 0x2030
movq %rax, 0x10(%rbx)
testl %r15d, %r15d
jle 0x4d99
movq %rax, %rdi
movl $0xff, %esi
movq %r12, %rdx
callq 0x20a0
movl $0x10, %edi
callq 0x2150
movq %rax, %r12
movq %rax, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x4e7c
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4e7c
movq %rbx, (%r14)
movslq 0x8(%r14), %rax
testq %rax, %rax
jle 0x4e59
movq 0x8(%rbx), %rcx
movl (%rbx), %edx
movslq %edx, %rdx
xorl %esi, %esi
movl 0x4(%rcx,%rsi,8), %edi
cmpq %rdi, %rsi
je 0x4e3e
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)
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 0x4e21
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
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
addl %esi, %ebx
leaq (,%rbx,8), %rax
testl %ebx, %ebx
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x8(%r14)
testl %ebx, %ebx
jle 0x4ec2
xorl %ecx, %ecx
movl %ecx, (%rax,%rcx,8)
movl %ecx, 0x4(%rax,%rcx,8)
incq %rcx
cmpq %rcx, %rbx
jne 0x4eb3
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1486(%rip), %rsi      # 0x635e
callq 0x2180
testq %rax, %rax
je 0x4eee
movq %rax, %rdi
callq 0x2140
xorl %eax, %eax
jmp 0x4f35
movq 0x40e3(%rip), %rbx      # 0x8fd8
leaq 0x1465(%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_O3/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 0x4fd2
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 0x41f5(%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_O3/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
leal (%rax,%rdx), %ecx
movslq %ecx, %rcx
movl 0x18(%rdi,%rcx,4), %ecx
movl %ecx, %r9d
negl %r9d
andl %ecx, %r9d
imulq $0x4325c53f, %r9, %rcx  # imm = 0x4325C53F
shrq $0x24, %rcx
imull $0x3d, %ecx, %ecx
subl %ecx, %r9d
leaq 0x416d(%rip), %rcx      # 0x9170
movzbl (%r9,%rcx), %r9d
shll $0x5, %eax
addl %r9d, %eax
testl %esi, %esi
je 0x504f
subl %r8d, %edx
shll $0x5, %r8d
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
decl %esi
jne 0x5012
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movslq %edx, %r10
movl %ecx, %eax
movl $0x1, %r11d
shll %cl, %r11d
sarl $0x5, %eax
testl %r9d, %r9d
cmovel %r9d, %r11d
leaq (%rdi,%r10,4), %r10
addq $0x18, %r10
movslq %eax, %rbx
movl (%r10,%rbx,4), %r9d
btrl %ecx, %r9d
orl %r11d, %r9d
movl %r9d, (%r10,%rbx,4)
cmpl %esi, 0x10(%rdi)
je 0x50d5
leaq 0x18(%rdi), %r10
movl %eax, %r11d
incl %esi
addl %r8d, %edx
sarl $0x5, %r8d
sarl $0x5, %r11d
movl $0x1, %ebx
movl %eax, %ecx
shll %cl, %ebx
testl %r9d, %r9d
movslq %edx, %rcx
leaq (%r10,%rcx,4), %rcx
cmovel %r9d, %ebx
movslq %r11d, %r14
movl (%rcx,%r14,4), %r9d
btrl %eax, %r9d
orl %ebx, %r9d
movl %r9d, (%rcx,%r14,4)
movl %r11d, %eax
cmpl 0x10(%rdi), %esi
jne 0x5097
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5120
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 0x47bc
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 0x5147
movslq %edx, %rsi
movslq (%rax,%r14,8), %rdi
movl %edi, (%rax,%rsi,8)
movl %edx, 0x4(%rax,%rdi,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 0x518d
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
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4c42
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 0x936e(%rip), %rsi      # 0xdfc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8591(%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_O3/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 0x5c1f
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x4aba
cmpl $0x0, (%r15)
jns 0x5c3b
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 0x7dc7(%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 0x20e0
movq %rax, %r14
callq 0x2100
jmp 0x5cad
movq %rax, %rdi
callq 0x496a
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %eax
cmpl $0x2, %ecx
jb 0x138d
movl $0x2, %r8d
movl $0x1, %eax
movl %eax, %r9d
leal 0x1(%r9), %eax
cmpl $0x1e, %r9d
ja 0x1382
addl %r8d, %r8d
cmpl %ecx, %r8d
jbe 0x136d
xorl %r8d, %r8d
cmpl $0x1f, %r9d
cmovael %r8d, %eax
testl %edx, %edx
jle 0x13c0
addl %esi, %edx
movslq %edx, %r8
subl %eax, %edx
movslq %edx, %rax
movslq %esi, %rdx
cmpq %rax, %r8
jle 0x13b2
movl %ecx, %esi
andb $0x1, %sil
movb %sil, -0x1(%rdi,%r8)
sarl %ecx
jmp 0x13b8
movb $0x0, -0x1(%rdi,%r8)
decq %r8
cmpq %rdx, %r8
jg 0x139e
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1420
leaq 0x1(%rax), %rcx
movl %edi, %r8d
andb $0x1, %r8b
movb %r8b, -0x2(%rsi,%rcx)
shrl %edi
decq %rcx
cmpq $0x1, %rcx
ja 0x13e7
testl %ebx, %ebx
jle 0x1420
movslq 0x3da3(%rip), %r14      # 0x51ac
addq %r14, %rdx
movq %rdx, %rdi
movq %rax, %rdx
callq 0x10a0
addl %r14d, %ebx
movl %ebx, 0x3d8c(%rip)      # 0x51ac
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x149a
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movl %edi, %r15d
cmpl $0x1, %edi
je 0x1485
movl $0x2, %eax
xorl %r14d, %r14d
incq %r14
cmpl $0x1e, %r14d
ja 0x1459
addl %eax, %eax
cmpl %ebp, %eax
jbe 0x144a
xorl %r15d, %r15d
cmpl $0x1e, %r14d
ja 0x1485
leaq 0x1(%r14), %r15
movslq 0x3d3f(%rip), %r12      # 0x51ac
leaq (%rbx,%r12), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1070
addl %r12d, %r14d
movl %r14d, 0x3d27(%rip)     # 0x51ac
movl %ebp, %edi
movl %r15d, %esi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x13c3
leaq 0x1b83(%rip), %rdi      # 0x3024
xorl %esi, %esi
xorl %eax, %eax
jmp 0x1030
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1522
addl $-0x2, %edx
movslq %esi, %rax
leaq (%rdi,%rax,4), %rax
incq %rdx
movl (%rax,%rdx,4), %ecx
movl -0x4(%rax,%rdx,4), %esi
movl %ecx, %edi
subl %esi, %edi
negl %edi
subl %esi, %ecx
cmovbl %edi, %ecx
movl %ecx, (%rax,%rdx,4)
decq %rdx
jne 0x1508
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl 0x3c66(%rip), %r14d     # 0x51b0
testl %edi, %edi
je 0x1566
movl %edi, %ebp
movslq %r14d, %r14
leaq (%rbx,%r14), %rdi
movl %ebp, %edx
movl $0x1, %esi
callq 0x1070
addl %ebp, %r14d
movslq %r14d, %rax
movb $0x0, (%rbx,%rax)
incl %eax
movl %eax, 0x3c3b(%rip)      # 0x51b0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x20(%rsp)
movl %edx, %ebx
movl %esi, %r13d
movq %rdi, %r15
xorl %r14d, %r14d
movl %r14d, 0x3c06(%rip)     # 0x51ac
movl %r14d, 0x3c03(%rip)     # 0x51b0
movl %ecx, 0xc(%rsp)
movl %ecx, %edi
callq 0x1523
movl $0x0, %ecx
subl %r13d, %ebx
movq %rbx, 0x18(%rsp)
jle 0x1659
movl %eax, %r12d
movslq %r13d, %rax
leaq (%r15,%rax,4), %rbp
xorl %r15d, %r15d
xorl %r13d, %r13d
movl (%rbp,%r15,4), %eax
cltd
idivl %r12d
movl %eax, %r14d
movl 0x3bc3(%rip), %ebx      # 0x51b0
subl %r13d, %r14d
jne 0x15f9
movq 0x10(%rsp), %r13
jmp 0x1615
movslq %ebx, %rbx
movq 0x10(%rsp), %r13
leaq (%rbx,%r13), %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x1070
addl %r14d, %ebx
movslq %ebx, %rax
movb $0x0, (%r13,%rax)
incl %eax
movl %eax, 0x3b8a(%rip)      # 0x51b0
movl (%rbp,%r15,4), %eax
cltd
idivl %r12d
movl %edx, %edi
movl %eax, %r13d
movl 0xc(%rsp), %esi
movq 0x20(%rsp), %rdx
callq 0x13c3
incq %r15
cmpl %r15d, 0x18(%rsp)
jne 0x15db
movl 0x3b5e(%rip), %ecx      # 0x51b0
movl 0x3b53(%rip), %r14d     # 0x51ac
movl %ecx, 0x3b05(%rip)      # 0x5164
leal 0x7(%r14), %edx
testl %r14d, %r14d
cmovnsl %r14d, %edx
sarl $0x3, %edx
leal 0x7(%rcx), %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
movl %r14d, 0x3aec(%rip)     # 0x5168
sarl $0x3, %eax
addl %edx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x18, %rsp
xorl %r12d, %r12d
movl %r12d, 0x3bb8(%rip)     # 0x5260
movl %r12d, 0x3c01(%rip)     # 0x52b0
movl $0x1, 0x3af3(%rip)      # 0x51ac
movslq 0x3a6c(%rip), %rax      # 0x512c
leaq 0x3b49(%rip), %rcx      # 0x5210
movslq (%rcx,%rax,4), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
jle 0x178c
movq %rdx, %r15
movq %rsi, %rbp
movl $0x1, %eax
movq %rax, (%rsp)
movl 0x3ac1(%rip), %r13d     # 0x51b0
xorl %ebx, %ebx
movq %rdi, 0x8(%rsp)
movslq (%rbp,%rbx,4), %rax
movl (%rdi,%rax,4), %r14d
movl %r14d, %eax
testq %rbx, %rbx
je 0x1712
movslq -0x4(%rbp,%rbx,4), %rcx
movl %r14d, %eax
subl (%rdi,%rcx,4), %eax
testl %eax, %eax
js 0x171b
movl %eax, %r14d
jmp 0x1748
leal (%rbx,%r12), %eax
movq (%rsp), %rcx
movslq %ecx, %rcx
leaq 0x3b83(%rip), %r8       # 0x52b0
movl %eax, (%r8,%rcx,4)
leaq 0x3b28(%rip), %rax      # 0x5260
movl %r12d, (%rax,%rcx,4)
incl %ecx
movq %rcx, (%rsp)
movl %ecx, 0x3a64(%rip)      # 0x51ac
testl %r14d, %r14d
je 0x1769
movslq %r13d, %r13
leaq (%r15,%r13), %rdi
movl %r14d, %edx
movl $0x1, %esi
callq 0x1070
movq 0x8(%rsp), %rdi
addl %r14d, %r13d
movslq %r13d, %r13
movb $0x0, (%r15,%r13)
incl %r13d
movl %r13d, 0x3a35(%rip)     # 0x51b0
addl %r14d, %r12d
incq %rbx
cmpq %rbx, 0x10(%rsp)
jne 0x16f6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17d1
leaq (%rsi,%rax,4), %rsi
movl %r8d, %r10d
subl %eax, %r10d
xorl %r9d, %r9d
testq %r9, %r9
je 0x17c9
movl (%rsi,%r9,4), %r11d
cmpl -0x4(%rsi,%r9,4), %r11d
jb 0x1824
incq %r9
cmpl %r9d, %r10d
jne 0x17b9
xorl %esi, %esi
notl %eax
addl %eax, %r8d
cmpl %r8d, %esi
jne 0x1810
movl 0x3948(%rip), %r8d      # 0x512c
leaq 0x3b15(%rip), %rax      # 0x5300
leaq (%rax,%r8,4), %rax
leaq 0x3a1a(%rip), %r9       # 0x5210
cmpl $0x2, %r8d
jl 0x1810
leaq -0x1(%r8), %r10
addq $-0x4, %rax
cmpl %edi, -0x4(%r9,%r8,4)
movq %r10, %r8
jg 0x17f6
movl %edi, (%rax)
testl %esi, %esi
jle 0x181e
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 0x17d3
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x396c(%rip)      # 0x51ac
testl %edx, %edx
jle 0x188c
movq %rcx, %rbx
movslq %esi, %rax
movl %edx, %r14d
leaq (%rdi,%rax,4), %r15
xorl %r12d, %r12d
xorl %ebp, %ebp
testq %r12, %r12
je 0x1882
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 0x1429
incq %r12
cmpq %r12, %r14
jne 0x1856
jmp 0x188e
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_O3/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 0x18b0
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 0x18cc
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1902
testl %esi, %esi
jle 0x18fe
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 0x18ee
jmp 0x1900
xorl %eax, %eax
popq %rcx
retq
leaq 0x181d(%rip), %rdi      # 0x3126
callq 0x1160
xorl %edi, %edi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O3/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 0x194e
movq %rdx, %r9
movl 0x380d(%rip), %r10d     # 0x5130
movl %edi, %eax
cltd
idivl %r10d
movl %eax, %r8d
movl %edx, %eax
movl 0x37ff(%rip), %r11d     # 0x5134
cltd
idivl %r11d
movl %eax, %edx
testl %r8d, %r8d
jle 0x1951
imull %r8d, %r10d
movl %r8d, %eax
movl -0x4(%r9,%rax,4), %eax
jmp 0x1956
xorl %eax, %eax
retq
xorl %r10d, %r10d
xorl %eax, %eax
testl %edx, %edx
jle 0x1976
imull 0x39ee(%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 0x198e
movslq %r10d, %rcx
movl %edi, %edx
movzbl (%rsi,%rcx), %edi
addl %edi, %eax
incq %rcx
cmpq %rcx, %rdx
jne 0x1980
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3896(%rip), %r14      # 0x53b0
movq 0x3857(%rip), %r15      # 0x5378
movq 0x3838(%rip), %r12      # 0x5360
leal 0x1(%rbx), %ecx
movl 0x3632(%rip), %r8d      # 0x5164
movl 0x361b(%rip), %r9d      # 0x5154
movl 0x3619(%rip), %eax      # 0x5158
movl %eax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x198f
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x1915
testl %ebx, %ebx
js 0x1b9c
addl %ebx, %ebx
leal (%rbx,%rbx,2), %edx
leal (%rbx,%rbx,2), %edi
addl $0x6, %edi
movl 0x3633(%rip), %esi      # 0x51a8
movq 0x382c(%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 0x1b81
movl %esi, 0x360e(%rip)      # 0x51a8
jmp 0x1b9e
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_O3/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 0x37e2(%rip), %r14      # 0x53a0
movq 0x37bb(%rip), %r15      # 0x5380
movq 0x379c(%rip), %r12      # 0x5368
leal 0x1(%rdi), %ecx
movl 0x358a(%rip), %r8d      # 0x5160
movl 0x356f(%rip), %r9d      # 0x514c
movl 0x356d(%rip), %eax      # 0x5150
movl %eax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x198f
movl %eax, %ebx
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x1915
movl 0x3520(%rip), %edx      # 0x512c
leaq 0x364d(%rip), %rcx      # 0x5260
leaq (%rcx,%rdx,4), %rcx
leaq 0x3692(%rip), %rsi      # 0x52b0
cmpl $0x2, %edx
jl 0x1c36
leaq -0x1(%rdx), %rdi
addq $-0x4, %rcx
cmpl -0x4(%rsi,%rdx,4), %ebx
movq %rdi, %rdx
jl 0x1c1e
subl (%rcx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13ef(%rip), %rdi      # 0x3052
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), %rdx
movq $-0x1, %r8
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edi
addl $0x2, %esi
cmpb $0x1, 0x1(%rdx,%r8)
movq %rdi, %rcx
leaq 0x1(%r8), %r8
leaq 0x1(%rdi), %rdi
jne 0x1c9f
movl %esi, %edx
addq $0x2, %rdx
addq 0x8(%rsp), %rax
xorl %r13d, %r13d
movzbl (%rax,%rcx), %esi
leal (%rsi,%r13,2), %r13d
incq %rcx
cmpq %rcx, %rdx
jne 0x1cc3
testl %r13d, %r13d
je 0x1ce6
cmpl $0x1, %r13d
jne 0x1cee
movl $0x1, %r12d
jmp 0x1d1f
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
jmp 0x1d1f
movl $0x2, %eax
movl $0x1, %r12d
movl $0x1, %edx
movl %edx, %ecx
addl $0x2, %r12d
cmpl $0x1e, %edx
ja 0x1d13
addl %eax, %eax
leal 0x1(%rcx), %edx
cmpl %r13d, %eax
jbe 0x1cfe
cmpl $0x1f, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovael %eax, %r12d
testl %ebx, %ebx
je 0x1d4e
movl $0x1, %eax
subl %r13d, %eax
decl %r13d
cmpl %r14d, %ebx
cmovgel %eax, %r13d
addl %r15d, %r13d
leaq 0x1317(%rip), %rdi      # 0x3056
movl %r13d, %esi
xorl %eax, %eax
callq 0x1030
movl %r13d, %r15d
jmp 0x1d5e
cmpl $0x1, %r13d
movl $0xffff, %eax           # imm = 0xFFFF
cmovel %eax, %r13d
movl %r13d, %r14d
addl %r12d, %ebp
cmpl 0x4(%rsp), %ebp
jge 0x1d75
incl %ebx
cmpl $0x3e8, %ebx            # imm = 0x3E8
jne 0x1c82
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_O3/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 0x12c7(%rip), %rdi      # 0x305a
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
movl %ebx, %edi
callq 0x1b09
movl %eax, %ebp
leal 0x1(%rbx), %edi
callq 0x1b09
movl %eax, %r14d
movl %ebx, %edi
callq 0x1baf
movq 0x35da(%rip), %rsi      # 0x5398
movl %ebp, %edx
movl %r14d, %ecx
movl %eax, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0x1c42
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2cd8
movq %r14, %rdi
callq 0x1130
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x2d60
leaq 0x10af(%rip), %rsi      # 0x30a5
movq %rsp, %rdi
callq 0x10e0
testq %rax, %rax
je 0x2027
testq %r14, %r14
jle 0x203e
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 0x200e
jmp 0x203e
leaq 0x1079(%rip), %rdi      # 0x30a7
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 0x2d60
movq %rbx, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: bfwrite(bool*, int, _IO_FILE*)
void bfwrite(bool *ar,int mx,FILE *fp){ //ビット列arをmx個書き込む
    int ps = 0;
    unsigned char a;
    while(ps<mx){
        a = ar[ps]*128;
        if(ps+1<mx){a += ar[ps+1]*64;}
        if(ps+2<mx){a += ar[ps+2]*32;}
        if(ps+3<mx){a += ar[ps+3]*16;}
        if(ps+4<mx){a += ar[ps+4]*8;}
        if(ps+5<mx){a += ar[ps+5]*4;}
        if(ps+6<mx){a += ar[ps+6]*2;}
        if(ps+7<mx){a += ar[ps+7]*1;}
        fwrite(&a, sizeof(unsigned char),1,fp);
        ps+=8;
    }
}

// Assembly:
testl %esi, %esi
jle 0x212f
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %r15d
movl $0x3, %r12d
movb -0x3(%r14,%r12), %al
shlb $0x7, %al
leaq -0x2(%r12), %rcx
cmpq %r15, %rcx
jae 0x209f
movb -0x2(%r14,%r12), %cl
shlb $0x6, %cl
orb %cl, %al
leaq -0x1(%r12), %rcx
cmpq %r15, %rcx
jae 0x20b3
movb -0x1(%r14,%r12), %cl
shlb $0x5, %cl
addb %cl, %al
cmpq %r15, %r12
jae 0x20c1
movb (%r14,%r12), %cl
shlb $0x4, %cl
addb %cl, %al
leaq 0x1(%r12), %rcx
cmpq %r15, %rcx
jae 0x20d5
movb 0x1(%r14,%r12), %cl
shlb $0x3, %cl
addb %cl, %al
leaq 0x2(%r12), %rcx
cmpq %r15, %rcx
jae 0x20e9
movb 0x2(%r14,%r12), %cl
shlb $0x2, %cl
addb %cl, %al
leaq 0x3(%r12), %rcx
cmpq %r15, %rcx
jae 0x20fc
movb 0x3(%r14,%r12), %cl
addb %cl, %cl
addb %cl, %al
leaq 0x4(%r12), %rcx
cmpq %r15, %rcx
jae 0x210b
addb 0x4(%r14,%r12), %al
movsbl %al, %edi
movq %rbx, %rsi
callq 0x1110
addq $0x8, %r12
leal -0x3(%r12), %eax
cmpl %ebp, %eax
jl 0x2083
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: shelp()
int shelp(){
    printf("--Simple Usage------------------\n");
    printf("\nRead 'index' and make 'codeindex'. \n");
    printf("This file needs for locating in idx_uni. \n");
    printf("Make sure that running 'gcis' and make file 'index' first before running 'gcis_uni'. \n");
    printf(": ./gcis_uni_build \n");
    printf("\nYou can set the name of inputfile by using option -i. \n");
    printf(": ./gcis_uni_build -i <inputfile>\n");
    printf("\nYou can set the name of outputfile by using option -o. \n");
    printf(": ./gcis_uni_build -o <outputfile>\n");
    printf("\n");
    printf("\n");
    return 0;
}

// Assembly:
pushq %rax
leaq 0xdda(%rip), %rdi       # 0x3145
callq 0x1160
leaq 0xdef(%rip), %rdi       # 0x3166
callq 0x1160
leaq 0xe08(%rip), %rdi       # 0x318b
callq 0x1160
leaq 0xe26(%rip), %rdi       # 0x31b5
callq 0x1160
leaq 0xe70(%rip), %rdi       # 0x320b
callq 0x1160
leaq 0xe78(%rip), %rdi       # 0x321f
callq 0x1160
leaq 0xea4(%rip), %rdi       # 0x3257
callq 0x1160
leaq 0xeba(%rip), %rdi       # 0x3279
callq 0x1160
leaq 0xee7(%rip), %rdi       # 0x32b2
callq 0x1160
movl $0xa, %edi
callq 0x1140
movl $0xa, %edi
callq 0x1140
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/pstuifzand[P]magento-tools/src/magento-config.cpp
// Function: parse_module_config::operator()(char const*)
void operator()(const char* filename) {
        XML_SetUserData(parser.handle(), &data);
        XML_SetElementHandler(parser.handle(), root_start_element_handler, root_end_element_handler);
        XML_SetCharacterDataHandler(parser.handle(), character_data_handler);

        data.filename = filename;

        std::ifstream in{data.filename};
        if (in) parse_xml(parser, in, &data);
        else std::cerr << "Can't open " << data.filename << "\n";

        parser.reset();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x8(%rbx), %r14
movq %r14, %rsi
callq 0x2050
movq (%rbx), %rdi
leaq -0x76b(%rip), %rsi      # 0x243c
leaq -0x512(%rip), %rdx      # 0x269c
callq 0x2160
movq (%rbx), %rdi
leaq -0x42d(%rip), %rsi      # 0x2790
callq 0x21c0
movq %r15, 0x10(%rbx)
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x22b0
movq (%r12), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
je 0x2c28
movq 0x3401(%rip), %r14      # 0x5ff0
leaq 0x14cd(%rip), %rsi      # 0x40c3
movl $0xb, %edx
movq %r14, %rdi
callq 0x21b0
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0x2c38
movq %r15, %rdi
callq 0x20b0
movq 0x33d5(%rip), %rdi      # 0x5ff0
movq %r15, %rsi
movq %rax, %rdx
callq 0x21b0
jmp 0x2c50
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2d0e
jmp 0x2c68
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2250
movq 0x3399(%rip), %rdi      # 0x5ff0
leaq 0x1458(%rip), %rsi      # 0x40b6
movl $0x1, %edx
callq 0x21b0
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x21a0
movq %rsp, %rdi
callq 0x2060
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/pstuifzand[P]magento-tools/src/xml.hpp
// Function: void parse_xml<user_data>(xml_parser&, std::basic_ifstream<char, std::char_traits<char>>&, user_data*)
void parse_xml(xml_parser& parser, std::ifstream& in, T* data) {
    const int size = 1024;
    char buf[size];
    while (in) {
        in.read(buf, size);
        XML_Status ret = XML_Parse(parser.handle(), buf, in.gcount(), in ? 0 : 1);
        if (!ret) {
            XML_Error error = XML_GetErrorCode(parser.handle());
            int line = XML_GetCurrentLineNumber(parser.handle());
            std::cerr << data->filename << ":" << line << ": error: " << XML_ErrorString(error) << "\n";
            break;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rsp, %r12
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x2e57
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
movq %r12, %rsi
callq 0x21f0
movq (%r15), %rdi
movl 0x8(%rbx), %edx
movq (%rbx), %rax
movq -0x18(%rax), %rax
xorl %ecx, %ecx
testb $0x5, 0x20(%rbx,%rax)
setne %cl
movq %r12, %rsi
callq 0x22a0
testl %eax, %eax
jne 0x2d28
movq (%r15), %rdi
callq 0x2200
movl %eax, %ebx
movq (%r15), %rdi
callq 0x20d0
movq %rax, %r15
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x2da7
movq %r14, %rdi
callq 0x20b0
movq 0x3256(%rip), %rdi      # 0x5ff0
movq %r14, %rsi
movq %rax, %rdx
callq 0x21b0
jmp 0x2dc5
movq 0x3242(%rip), %rax      # 0x5ff0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x2250
movq 0x3224(%rip), %r14      # 0x5ff0
leaq 0x12fc(%rip), %rsi      # 0x40cf
movl $0x1, %edx
movq %r14, %rdi
callq 0x21b0
movq %r14, %rdi
movl %r15d, %esi
callq 0x2260
movq %rax, %r14
leaq 0x12dc(%rip), %rsi      # 0x40d1
movl $0x9, %edx
movq %rax, %rdi
callq 0x21b0
movl %ebx, %edi
callq 0x2040
testq %rax, %rax
je 0x2e29
movq %rax, %rbx
movq %rax, %rdi
callq 0x20b0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21b0
jmp 0x2e43
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2250
leaq 0x126c(%rip), %rsi      # 0x40b6
movl $0x1, %edx
movq %r14, %rdi
callq 0x21b0
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r14
popq %r15
retq