LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movl %esi, 0x8(%rdi)
pushq $0x10
popq %rdi
callq 0x2190
movq %rax, %r14
pushq $0x1
popq %rdx
movq %rax, %rdi
movl %r15d, %esi
callq 0x4606
movq %r14, (%rbx)
xorl %r14d, %r14d
cmpl 0x8(%rbx), %r14d
jge 0x45e4
movq (%rbx), %rdi
xorl %esi, %esi
movl %r14d, %edx
callq 0x42ae
incl %r14d
jmp 0x45cc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq (,%rbx,8), %rax
xorl %r15d, %r15d
testl %ebx, %ebx
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
cmovlel %r15d, %ebx
callq 0x2030
movq %rax, 0x8(%r14)
cmpq %r15, %rbx
je 0x4650
movl %r15d, (%rax,%r15,8)
movl %r15d, 0x4(%rax,%r15,8)
incq %r15
jmp 0x463d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsi, %rdi
leaq 0xcb4(%rip), %rsi       # 0x535e
callq 0x21c0
testq %rax, %rax
je 0x46c0
movq %rax, %rdi
callq 0x2180
xorl %eax, %eax
jmp 0x46de
movq 0x3911(%rip), %rdi      # 0x7fd8
leaq 0xc93(%rip), %rsi       # 0x5361
callq 0x2170
movq %rax, %rdi
callq 0x20b0
pushq $-0x1
popq %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x47a4
movq (%rbx), %rdx
movslq %eax, %rcx
movl (%rdx,%rcx,4), %edx
movl %edx, %eax
negl %eax
andl %edx, %eax
pushq $0x3d
popq %rsi
xorl %edx, %edx
divl %esi
leaq 0x3a99(%rip), %rax      # 0x81b0
movzbl (%rdx,%rax), %eax
shll $0x5, %ecx
addl %eax, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x47ea
movq (%rbx), %rdx
movslq %eax, %rcx
xorl %r9d, %r9d
cmpl $0x0, (%rdx,%rcx,4)
setne %r9b
movl 0x8(%rbx), %r8d
sarl $0x5, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4814
nop
// File: /workspace/github_cpp_makefile_star2_O2/wwdatabase[P]database/./rcdmana/../bufmanager/../fileio/FileManager.h
// Function: FileManager::_openFile(char const*, int)
int _openFile(const char* name, int fileID) {
		int f = open(name, O_RDWR);
		if (f == -1) {
			return -1;
		}
		fd[fileID] = f;
		return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rax
movq %rdi, %r15
xorl %ebx, %ebx
pushq $0x2
popq %rsi
movq %rax, %rdi
xorl %eax, %eax
callq 0x2100
cmpl $-0x1, %eax
je 0x4794
movslq %r14d, %rcx
movl %eax, (%r15,%rcx,4)
jmp 0x4797
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %edx, %r9d
movl $0x3d, %r10d
leaq 0x39f8(%rip), %r11      # 0x81b0
leal (%rcx,%r9), %eax
cltq
movl 0x18(%rdi,%rax,4), %edx
movl %edx, %eax
negl %eax
andl %edx, %eax
xorl %edx, %edx
divl %r10d
movzbl (%rdx,%r11), %eax
shll $0x5, %ecx
addl %eax, %ecx
subl $0x1, %esi
jb 0x47e5
subl %r8d, %r9d
shll $0x5, %r8d
jmp 0x47b8
movl %ecx, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wwdatabase[P]database/./rcdmana/../bufmanager/../utils/MyBitMap.h
// Function: MyBitMap::setLeafBit(int, unsigned int)
int setLeafBit(int index, uint k) {
		int pos, bit;
		getPos(index, pos, bit);
		uint umask = (1 << bit);
		uint mask = (~umask);
		if (k == 0) {
			umask = 0;
		}
		uint w = ((getLeafData(pos) & mask) | umask);
		setLeafData(pos, w);
		return pos;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
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), %edi
btrl %ecx, %edi
orl %esi, %edi
movl %edi, (%rdx,%rax,4)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %eax
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
leaq 0x18(%rdi), %rcx
movq %rcx, -0x30(%rbp)
movslq %r14d, %rcx
movq -0x30(%rbp), %rdx
leaq (%rdx,%rcx,4), %r13
movq %r12, %rdi
movq %r13, %rsi
movl %eax, %edx
movl %r9d, %ecx
callq 0x4884
cmpl 0x10(%r12), %r15d
je 0x4875
movslq %eax, %rcx
xorl %r9d, %r9d
cmpl $0x0, (%r13,%rcx,4)
setne %r9b
incl %r15d
addl %ebx, %r14d
sarl $0x5, %ebx
jmp 0x4838
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wwdatabase[P]database/./rcdmana/../bufmanager/../utils/MyBitMap.h
// Function: MyBitMap::_setBit(unsigned int*, int, unsigned int)
int _setBit(uint* start, int index, uint k) {
		int pos, bit;
		getPos(index, pos, bit);
		uint umask = (1 << bit);
		uint mask = (~umask);
		if (k == 0) {
			umask = 0;
		}
		start[pos] = ((start[pos] & mask) | umask);
		return pos;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %ecx, %eax
movl %edx, %ecx
sarl $0x5, %edx
movl $0x1, %edi
shll %cl, %edi
testl %eax, %eax
cmovel %eax, %edi
movslq %edx, %rax
movl (%rsi,%rax,4), %edx
btrl %ecx, %edx
orl %edi, %edx
movl %edx, (%rsi,%rax,4)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x20(%rdi), %rax
movslq %esi, %r15
cmpb $0x1, (%rax,%r15)
jne 0x48f7
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movl (%rax,%r15,8), %esi
movl 0x4(%rax,%r15,8), %edx
movq 0x28(%r14), %rax
movq (%rax,%r15,8), %rcx
xorl %r8d, %r8d
callq 0x3e7e
movq 0x20(%r14), %rax
movb $0x0, (%rax,%r15)
movq 0x18(%r14), %rdi
movl %ebx, %esi
callq 0x4918
movq 0x10(%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x492a
nop
// File: /workspace/github_cpp_makefile_star2_O2/dechimal[P]TaggedUnion/include/desalt/datatypes/sum.hpp
// Function: bool desalt::datatypes::detail::sum::operator==<main::unit, std::tuple<int, desalt::datatypes::detail::rec::rec<0ul>>, main::unit, std::tuple<char, desalt::datatypes::detail::rec::rec<0ul>>>(desalt::datatypes::detail::sum::sum<main::unit, std::tuple<int, desalt::datatypes::detail::rec::rec<0ul>>> const&, desalt::datatypes::detail::sum::sum<main::unit, std::tuple<char, desalt::datatypes::detail::rec::rec<0ul>>> const&)
bool operator==(sum<Ts...> const & a, sum<Us...> const & b) {
    static_assert((utils::equality_comparable<rec::unwrap<Ts>, rec::unwrap<Us>> && ...), "each element type must be equality comparable.");
    if (a.which() != b.which()) return false;
    return a.dispatch([&] (auto t) -> bool {
        return a.get_unchecked(t) == b.get_unchecked(t);
    });
}

// Assembly:
movl (%rdi), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andl (%rsi), %eax
cmpl %eax, %ecx
jne 0x4621
subq $0x18, %rsp
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
leaq 0xa15a(%rip), %rdx      # 0xe770
movq %rax, %rdi
callq *(%rdx,%rcx,8)
addq $0x18, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/dechimal[P]TaggedUnion/include/desalt/datatypes/sum.hpp
// Function: bool desalt::datatypes::detail::sum::operator<<int, double, int, double>(desalt::datatypes::detail::sum::sum<int, double> const&, desalt::datatypes::detail::sum::sum<int, double> const&)
bool operator<(sum<Ts...> const & a, sum<Us...> const & b) {
    static_assert((utils::less_than_comparable<rec::unwrap<Ts>, rec::unwrap<Us>> && ...), "each element type must be less than comparable.");
    if (a.which() != b.which()) return a.which() < b.which();
    return a.dispatch([&] (auto t) -> bool {
        return a.get_unchecked(t) < b.get_unchecked(t);
    });
}

// Assembly:
movl (%rdi), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andl (%rsi), %eax
cmpl %eax, %ecx
jne 0x4d35
subq $0x18, %rsp
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
leaq 0x9d66(%rip), %rdx      # 0xea90
movq %rax, %rdi
callq *(%rdx,%rcx,8)
addq $0x18, %rsp
retq
setb %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dechimal[P]TaggedUnion/include/desalt/datatypes/sum.hpp
// Function: void desalt::datatypes::detail::sum::sum<int, double, hoge, hoge>::assign<desalt::datatypes::detail::sum::sum<int, double, hoge, hoge> const&>(desalt::datatypes::detail::sum::sum<int, double, hoge, hoge> const&)
void assign(Union && other) {
        if (which_ == other.which_) {
            this->copy_or_move_assign(std::forward<Union>(other));
        } else {
            if (this->nothrow_constructible(std::forward<Union>(other))) {
                this->construct_using_nothrow_constructor(std::forward<Union>(other));
            } else {
                bool fallback;
                if constexpr (std::is_lvalue_reference_v<Union&&>) {
                    bool nothrow_move_constructible = other.nothrow_move_constructible();
                    if (nothrow_move_constructible) {
                        this->construct_using_right_hand_move_constructor(other);
                    }
                    fallback = !nothrow_move_constructible;
                } else {
                    fallback = true;
                }
                if (fallback) {
                    if (this->nothrow_move_constructible()) {
                        this->construct_using_auto_storage_save(std::forward<Union>(other));
                    } else if constexpr (enable_fallback) {
                        this->construct_using_fallback_type(std::forward<Union>(other));
                    } else {
                        this->construct_using_dynamic_storage_save(std::forward<Union>(other));
                    }
                }
            }
            this->set_which(other.which());
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %eax
cmpl %eax, (%rdi)
jne 0x586f
movq %r14, %rdi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x58f8
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
leaq 0x9085(%rip), %rcx      # 0xe900
leaq 0xd(%rsp), %rdi
callq *(%rcx,%rax,8)
testb %al, %al
je 0x5894
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5922
jmp 0x58e3
movl (%rbx), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
leaq 0x8fde(%rip), %r15      # 0xe880
leaq 0xe(%rsp), %rdi
callq *(%r15,%rax,8)
testb %al, %al
je 0x58bc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5944
jmp 0x58e3
movl (%r14), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
leaq 0xf(%rsp), %rdi
callq *(%r15,%rax,8)
movq %r14, %rdi
movq %rbx, %rsi
testb %al, %al
je 0x58de
callq 0x596e
jmp 0x58e3
callq 0x5998
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andl (%rbx), %eax
movl %eax, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x53f8
movl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rdi)
movb %al, (%rdi)
movq %rdi, %rax
retq
pushq %rax
pushq $0x4
popq %rdi
callq 0x3070
andl $0x0, (%rax)
movq 0x9bbd(%rip), %rsi      # 0xefc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x3120
nop
// File: /workspace/github_cpp_makefile_star2_O2/dechimal[P]TaggedUnion/include/desalt/datatypes/sum.hpp
// Function: auto void desalt::datatypes::detail::sum::sum<int, std::vector<int, std::allocator<int>>>::construct_using_auto_storage_save<desalt::datatypes::detail::sum::sum<int, std::vector<int, std::allocator<int>>>>(desalt::datatypes::detail::sum::sum<int, std::vector<int, std::allocator<int>>>&&)::'lambda'(desalt::datatypes::detail::sum::sum<int, std::vector<int, std::allocator<int>>>)::operator()<desalt::datatypes::detail::utils::tag<1ul>>(desalt::datatypes::detail::sum::sum<int, std::vector<int, std::allocator<int>>>) const
void construct_using_auto_storage_save(Union && other) {
        this->dispatch([&] (auto t) {
            storage<t.value> tmp(std::move(this->get_unchecked(t)));
            this->destroy(t);
            try {
                this->construct(std::forward<Union>(other));
            } catch (...) {
                this->construct_directly(t, std::move(tmp));
                throw;
            }
        });
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq (%rdi), %rbx
leaq 0x8(%rbx), %rdi
movq 0x8(%rbx), %r15
movq %r15, (%rsp)
movq 0x10(%rbx), %r12
movq %r12, 0x8(%rsp)
movq 0x18(%rbx), %r13
movq %r13, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
andq $0x0, 0x18(%rbx)
callq 0x6864
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x6a9a
movq %rsp, %rdi
callq 0x6864
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x3050
movq %r15, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movq %r13, 0x18(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
callq 0x30f0
movq %rax, %rbx
callq 0x3110
movq %rsp, %rdi
callq 0x6864
movq %rbx, %rdi
callq 0x3130
movq %rax, %rdi
callq 0x4ff6
// File: /workspace/github_cpp_makefile_star2_O2/dechimal[P]TaggedUnion/include/desalt/datatypes/sum.hpp
// Function: auto void desalt::datatypes::detail::sum::sum<int, std::vector<int, std::allocator<int>>>::construct_using_fallback_type<desalt::datatypes::detail::sum::sum<int, std::vector<int, std::allocator<int>>>, desalt::datatypes::detail::utils::tag<0ul>>(desalt::datatypes::detail::sum::sum<int, std::vector<int, std::allocator<int>>>&&)::'lambda'(desalt::datatypes::detail::sum::sum<int, std::vector<int, std::allocator<int>>>)::operator()<desalt::datatypes::detail::utils::tag<1ul>>(desalt::datatypes::detail::sum::sum<int, std::vector<int, std::allocator<int>>>) const
void construct_using_fallback_type(Union && other) {
        this->dispatch([&] (auto t) {
            try {
                this->destroy(t);
                this->construct(std::forward<Union>(other));
            } catch (...) {
                this->construct_directly(FallbackTag{});
                this->set_which(FallbackTag::value);
                throw;
            }
        });
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rbx
leaq 0x8(%rbx), %rdi
callq 0x6864
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x6a9a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x3050
andl $0x0, 0x8(%rbx)
andl $0x0, (%rbx)
callq 0x30f0
movq %rax, %rbx
callq 0x3110
movq %rbx, %rdi
callq 0x3130
movq %rax, %rdi
callq 0x4ff6
nop
// File: /workspace/github_cpp_makefile_star2_O2/dechimal[P]TaggedUnion/include/desalt/datatypes/sum.hpp
// Function: auto void desalt::datatypes::detail::sum::sum<hoge, hoge>::construct_using_right_hand_move_constructor<desalt::datatypes::detail::sum::sum<hoge, hoge>>(desalt::datatypes::detail::sum::sum<hoge, hoge> const&)::'lambda'(desalt::datatypes::detail::sum::sum<hoge, hoge>)::operator()<desalt::datatypes::detail::utils::tag<0ul>>(desalt::datatypes::detail::sum::sum<hoge, hoge>) const
void construct_using_right_hand_move_constructor(Union const & other) {
        other.dispatch([&] (auto t) {
            using other_storage = typename std::decay_t<Union>::template storage<t.value>;
            other_storage tmp(other.get_unchecked(t));
            this->destroy();
            this->construct_directly(t, std::move(tmp));
        });
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
movq (%rdi), %rsi
cmpl $0x0, (%rsi)
jns 0x6152
movq 0x8(%rsi), %rsi
jmp 0x6156
addq $0x8, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x5238
movq %rbx, %rdi
callq 0x5df8
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x54ac
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %r15
movq (%rdi), %r14
pushq $0x8
popq %rdi
callq 0x30c0
movq %rax, %rbx
cmpl $0x0, (%r14)
jns 0x62f2
movq 0x8(%r14), %rsi
jmp 0x62f6
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x5238
movq %r14, %rdi
callq 0x5e2a
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x60ae
pushq $0x8
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x30d0
movq %rax, %r14
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x30d0
jmp 0x6350
movq %rax, %rdi
callq 0x3050
movq %rbx, 0x8(%r14)
orb $-0x80, 0x3(%r14)
callq 0x30f0
movq %rax, %r14
callq 0x3110
movq %r14, %rdi
callq 0x3130
movq %rax, %rdi
callq 0x4ff6
// File: /workspace/github_cpp_makefile_star2_O2/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:
testl %edi, %edi
je 0x130e
pushq $0x1
popq %rcx
pushq $0x2
popq %rax
cmpl $0x1f, %ecx
ja 0x1305
cmpl %edi, %eax
ja 0x1305
addl %eax, %eax
incl %ecx
jmp 0x12f6
xorl %eax, %eax
cmpl $0x20, %ecx
cmovbl %ecx, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
testl %esi, %esi
js 0x1341
addl %esi, %edx
movl 0x3e8b(%rip), %ecx      # 0x51a8
movl %esi, %eax
addq %rax, %rdi
incl %ecx
xorl %eax, %eax
cmpl %esi, %edx
jle 0x1343
movzbl (%rdi), %r8d
leal (%r8,%rax,2), %eax
movl %ecx, 0x3e70(%rip)      # 0x51a8
incq %rdi
incl %esi
incl %ecx
jmp 0x1326
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
addl %esi, %ebp
movl %ecx, %edi
callq 0x12ec
movslq %ebp, %rcx
subl %eax, %ebp
movslq %r15d, %rax
movslq %ebp, %rdx
cmpq %rax, %rcx
jle 0x1390
cmpq %rdx, %rcx
jg 0x137e
movb $0x0, -0x1(%r14,%rcx)
decq %rcx
jmp 0x1369
movl %ebx, %esi
andb $0x1, %sil
movb %sil, -0x1(%r14,%rcx)
sarl %ebx
decq %rcx
jmp 0x1369
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %esi, %ecx
movq %rsp, %rax
leaq 0xf(%rcx), %r8
andq $-0x10, %r8
subq %r8, %rax
movq %rax, %rsp
testl %ecx, %ecx
jle 0x13cb
movl %edi, %r8d
andb $0x1, %r8b
movb %r8b, -0x1(%rax,%rcx)
decq %rcx
shrl %edi
jmp 0x13b4
movslq 0x3dda(%rip), %rdi      # 0x51ac
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
addq %rdi, %rdx
incl %edi
cmpq %rcx, %rsi
je 0x13fb
movb (%rax,%rcx), %r8b
movb %r8b, (%rdx,%rcx)
leal (%rdi,%rcx), %r8d
movl %r8d, 0x3db6(%rip)      # 0x51ac
incq %rcx
jmp 0x13de
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x144b
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
callq 0x12ec
movslq 0x3d94(%rip), %rdx      # 0x51ac
leal 0x1(%rdx), %ecx
addq %rbx, %rdx
xorl %esi, %esi
leal 0x1(%rsi), %edi
cmpl %eax, %edi
jge 0x1439
movb $0x0, (%rdx,%rsi)
leal (%rcx,%rsi), %edi
movl %edi, 0x3d78(%rip)      # 0x51ac
incq %rsi
jmp 0x1420
movl %ebp, %edi
movl %eax, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x139d
leaq 0x1bd2(%rip), %rdi      # 0x3024
xorl %esi, %esi
xorl %eax, %eax
jmp 0x1030
// File: /workspace/github_cpp_makefile_star2_O2/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:
addl $-0x2, %edx
movslq %edx, %rax
movslq %esi, %rcx
leaq (%rdi,%rcx,4), %rcx
addq $0x4, %rcx
testq %rax, %rax
js 0x14cb
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
jmp 0x14ac
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movslq 0x3cc6(%rip), %rax      # 0x51b0
movq %rax, %rcx
addq %rsi, %rcx
movl %edi, %edx
xorl %edi, %edi
cmpl %edi, %edx
je 0x1509
movb $0x1, (%rcx,%rdi)
incl %eax
movl %eax, 0x3cac(%rip)      # 0x51b0
incq %rdi
jmp 0x14f4
movslq %eax, %rcx
movb $0x0, (%rsi,%rcx)
incl %eax
movl %eax, 0x3c98(%rip)      # 0x51b0
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14d
movl %esi, %r13d
andl $0x0, 0x3c6a(%rip)      # 0x51ac
movq %rdi, %r15
andl $0x0, 0x3c64(%rip)      # 0x51b0
movl %ecx, %edi
callq 0x14cc
movl %eax, %r12d
movslq %r13d, %rbx
movslq %r14d, %r14
xorl %r13d, %r13d
cmpq %r14, %rbx
jge 0x1599
movl (%r15,%rbx,4), %eax
cltd
idivl %r12d
subl %r13d, %eax
movl %eax, %edi
movq 0x10(%rsp), %rsi
callq 0x14e3
movl (%r15,%rbx,4), %eax
cltd
idivl %r12d
movl %edx, %edi
movl %eax, %r13d
movl %ebp, %esi
movq 0x8(%rsp), %rdx
callq 0x139d
incq %rbx
jmp 0x155f
movl 0x3c11(%rip), %ecx      # 0x51b0
movl %ecx, 0x3bbf(%rip)      # 0x5164
movl 0x3c01(%rip), %eax      # 0x51ac
movl %eax, 0x3bb7(%rip)      # 0x5168
pushq $0x8
popq %rdi
cltd
idivl %edi
movl %eax, %esi
movl %ecx, %eax
cltd
idivl %edi
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_O2/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
andl $0x0, 0x3c7f(%rip)      # 0x5260
movq %rdx, %rbx
andl $0x0, 0x3cc5(%rip)      # 0x52b0
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, 0x3bb1(%rip)      # 0x51ac
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0x3b24(%rip), %rax      # 0x512c
leaq 0x3c01(%rip), %rcx      # 0x5210
movslq (%rcx,%rax,4), %rax
cmpq %rax, %r12
jge 0x1673
movslq (%r14,%r12,4), %rax
movl (%r15,%rax,4), %eax
movl %eax, %ebp
testq %r12, %r12
je 0x1632
movslq -0x4(%r14,%r12,4), %rcx
movl %eax, %ebp
subl (%r15,%rcx,4), %ebp
testl %ebp, %ebp
jns 0x1661
leal (%r12,%r13), %ecx
movslq 0x3b6b(%rip), %rdx      # 0x51ac
leaq 0x3c68(%rip), %rsi      # 0x52b0
movl %ecx, (%rsi,%rdx,4)
leaq 0x3c0e(%rip), %rcx      # 0x5260
movl %r13d, (%rcx,%rdx,4)
leal 0x1(%rdx), %ecx
movl %ecx, 0x3b4d(%rip)      # 0x51ac
movl %eax, %ebp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x14e3
addl %ebp, %r13d
incq %r12
jmp 0x1601
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movslq 0x4(%rdx,%rcx,4), %r8
leaq (%rsi,%rax,4), %r10
xorl %esi, %esi
xorl %r9d, %r9d
leaq (%rax,%r9), %r11
cmpq %r8, %r11
jge 0x16bd
testq %r9, %r9
je 0x16b0
movl (%r10,%r9,4), %r11d
cmpl -0x4(%r10,%r9,4), %r11d
jb 0x16b5
incq %r9
jmp 0x1697
movl %r8d, %esi
subl %eax, %esi
subl %r9d, %esi
notl %eax
addl %r8d, %eax
cmpl %eax, %esi
jne 0x16f9
movl 0x3a5f(%rip), %r8d      # 0x512c
leaq 0x3c2c(%rip), %rax      # 0x5300
leaq (%rax,%r8,4), %rax
leaq 0x3b31(%rip), %r9       # 0x5210
cmpl $0x2, %r8d
jl 0x16f9
leaq -0x1(%r8), %r10
addq $-0x4, %rax
cmpl %edi, -0x4(%r9,%r8,4)
movq %r10, %r8
jg 0x16df
movl %edi, (%rax)
testl %esi, %esi
jle 0x1707
movl 0x4(%rdx,%rcx,4), %eax
addl (%rdx,%rcx,4), %esi
subl %esi, %eax
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rcx, %rbx
movl %edx, %r14d
andl $0x0, 0x3a8c(%rip)      # 0x51ac
movslq %esi, %rax
xorl %r15d, %r15d
testl %edx, %edx
cmovlel %r15d, %r14d
leaq (%rdi,%rax,4), %r12
xorl %ebp, %ebp
cmpq %r15, %r14
je 0x1768
testq %r15, %r15
je 0x1763
movl (%r12,%r15,4), %eax
subl -0x4(%r12,%r15,4), %eax
testl %ebp, %ebp
movl %r15d, %ecx
cmovnel %ebp, %ecx
testl %eax, %eax
cmovsl %ecx, %ebp
movl %eax, %edi
negl %edi
cmovsl %eax, %edi
incl %edi
movq %rbx, %rsi
callq 0x1400
incq %r15
jmp 0x1732
cmpl $0x2, %ebp
pushq $0x1
popq %rax
cmovgel %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $-0x2
popq %rdi
xorl %ecx, %ecx
addl $0x2, %edi
cmpb $0x1, (%rdx,%rcx)
leaq 0x1(%rcx), %rcx
jne 0x1786
leaq (%rax,%rsi), %rdx
decq %rdx
movl %edi, %esi
addq $0x2, %rsi
xorl %eax, %eax
cmpq %rcx, %rsi
je 0x17b3
movzbl (%rdx,%rcx), %edi
leal (%rdi,%rax,2), %eax
incq %rcx
jmp 0x17a2
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x17da
testl %esi, %esi
jle 0x17d6
addl %edx, %esi
movl %edx, %eax
addq %rax, %rdi
xorl %eax, %eax
cmpl %edx, %esi
jle 0x17d8
movzbl (%rdi), %ecx
addl %ecx, %eax
incq %rdi
incl %edx
jmp 0x17c6
xorl %eax, %eax
popq %rcx
retq
leaq 0x1945(%rip), %rdi      # 0x3126
callq 0x1150
xorl %edi, %edi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1826
movq %rdx, %r9
movl 0x3935(%rip), %r10d     # 0x5130
movl %edi, %eax
cltd
idivl %r10d
movl %eax, %r8d
movl %edx, %eax
movl 0x3927(%rip), %r11d     # 0x5134
cltd
idivl %r11d
movl %eax, %edx
testl %r8d, %r8d
jle 0x1829
imull %r8d, %r10d
movl %r8d, %eax
movl -0x4(%r9,%rax,4), %eax
jmp 0x182e
xorl %eax, %eax
retq
xorl %r10d, %r10d
xorl %eax, %eax
testl %edx, %edx
jle 0x184e
imull 0x3b16(%rip), %r8d      # 0x5350
addl %edx, %r8d
movslq %r8d, %r8
movzwl (%rcx,%r8,2), %ecx
addl %ecx, %eax
imull %edx, %r11d
addl %r11d, %r10d
movslq %r10d, %rcx
movl %edi, %edx
cmpq %rdx, %rcx
jge 0x1828
movzbl (%rsi,%rcx), %edi
addl %edi, %eax
incq %rcx
jmp 0x1853
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movq 0x39d4(%rip), %r14      # 0x53b0
movq 0x3995(%rip), %r15      # 0x5378
movq 0x3976(%rip), %r12      # 0x5360
leal 0x1(%rbx), %ecx
movl 0x3770(%rip), %r8d      # 0x5164
movl 0x3759(%rip), %r9d      # 0x5154
movl 0x3757(%rip), %eax      # 0x5158
movl %eax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1863
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x17ed
movl %eax, %ebp
movq 0x397d(%rip), %rdi      # 0x53a8
imull $0x6, %ebx, %esi
pushq $0x6
popq %rdx
callq 0x1311
shll $0x6, %ebp
addl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3949(%rip), %r14      # 0x53a0
movq 0x3922(%rip), %r15      # 0x5380
movq 0x3903(%rip), %r12      # 0x5368
leal 0x1(%rdi), %ecx
movl 0x36f1(%rip), %r8d      # 0x5160
movl 0x36d6(%rip), %r9d      # 0x514c
movl 0x36d4(%rip), %eax      # 0x5150
movl %eax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1863
movl %eax, %ebx
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x17ed
movl 0x3687(%rip), %edx      # 0x512c
leaq 0x37b4(%rip), %rcx      # 0x5260
leaq (%rcx,%rdx,4), %rcx
leaq 0x37f9(%rip), %rsi      # 0x52b0
cmpl $0x2, %edx
jl 0x1acf
leaq -0x1(%rdx), %rdi
addq $-0x4, %rcx
cmpl -0x4(%rsi,%rdx,4), %ebx
movq %rdi, %rdx
jl 0x1ab7
subl (%rcx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %ebx
movl %ecx, 0xc(%rsp)
movl %edx, %r14d
movq %rsi, 0x10(%rsp)
leaq 0x1553(%rip), %rdi      # 0x3052
movl %edx, %esi
movl %r8d, %edx
xorl %eax, %eax
callq 0x1030
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpl $0x3e8, %ebp            # imm = 0x3E8
je 0x1b7b
movl %r14d, %edi
movq 0x10(%rsp), %rsi
callq 0x177a
movl %eax, %r12d
movl %eax, %edi
callq 0x12ec
movl %eax, %r13d
testl %ebp, %ebp
je 0x1b5b
pushq $0x1
popq %rax
subl %r12d, %eax
decl %r12d
cmpl %r15d, %ebp
cmovgel %eax, %r12d
addl %r12d, %ebx
leaq 0x1506(%rip), %rdi      # 0x3056
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
jmp 0x1b6b
cmpl $0x1, %r12d
movl $0xffff, %eax           # imm = 0xFFFF
cmovel %eax, %r12d
movl %r12d, %r15d
leal (%r14,%r13,2), %r14d
decl %r14d
incl %ebp
cmpl 0xc(%rsp), %r14d
jl 0x1b10
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_O2/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 0x14c1(%rip), %rdi      # 0x305a
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
movl %ebx, %edi
callq 0x19c7
movl %eax, %ebp
leal 0x1(%rbx), %edi
callq 0x19c7
movl %eax, %r14d
movl %ebx, %edi
callq 0x1a48
movq 0x37d4(%rip), %rsi      # 0x5398
movl %ebp, %edx
movl %r14d, %ecx
movl %eax, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0x1adb
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movabsq $0x78742e7972657571, %rax # imm = 0x78742E7972657571
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movw $0x74, 0x8(%rsi)
leaq 0x18(%rsp), %r14
pushq $0x2
popq %rdx
movq %r14, %rdi
callq 0x2a3a
movq %r14, %rdi
callq 0x1120
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2aa6
leaq 0x12d0(%rip), %rsi      # 0x30a5
leaq 0x8(%rsp), %rdi
callq 0x10d0
testq %rax, %rax
je 0x1e0d
movq %rax, %r15
xorl %r12d, %r12d
testq %r14, %r14
movq %r14, %r13
cmovleq %r12, %r13
cmpq %r12, %r13
je 0x1e24
movq %r15, %rdi
callq 0x1160
movzbl %al, %eax
movl %eax, (%rbx,%r12,4)
incq %r12
jmp 0x1df4
leaq 0x1293(%rip), %rdi      # 0x30a7
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %r14
movl %r14d, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2aa6
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movslq %esi, %r15
xorl %eax, %eax
cmpq %r15, %rax
jge 0x1efc
movb (%r14,%rax), %cl
shlb $0x7, %cl
leaq 0x1(%rax), %r12
cmpq %r15, %r12
jge 0x1e80
movb 0x1(%r14,%rax), %dl
shlb $0x6, %dl
orb %dl, %cl
incq %r12
cmpq %r15, %r12
jge 0x1e92
movb 0x2(%r14,%rax), %dl
shlb $0x5, %dl
addb %dl, %cl
incq %r12
cmpq %r15, %r12
jge 0x1ea4
movb 0x3(%r14,%rax), %dl
shlb $0x4, %dl
addb %dl, %cl
incq %r12
cmpq %r15, %r12
jge 0x1eb6
movb 0x4(%r14,%rax), %dl
shlb $0x3, %dl
addb %dl, %cl
incq %r12
cmpq %r15, %r12
jge 0x1ec8
movb 0x5(%r14,%rax), %dl
shlb $0x2, %dl
addb %dl, %cl
incq %r12
cmpq %r15, %r12
jge 0x1ed9
movb 0x6(%r14,%rax), %dl
addb %dl, %dl
addb %dl, %cl
incq %r12
cmpq %r15, %r12
jge 0x1ee6
addb 0x7(%r14,%rax), %cl
movsbl %cl, %edi
movq %rbx, %rsi
callq 0x1100
incq %r12
movq %r12, %rax
jmp 0x1e5d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
leaq 0x1010(%rip), %rdi      # 0x3145
callq 0x1150
leaq 0x1025(%rip), %rdi      # 0x3166
callq 0x1150
leaq 0x103e(%rip), %rdi      # 0x318b
callq 0x1150
leaq 0x105c(%rip), %rdi      # 0x31b5
callq 0x1150
leaq 0x10a6(%rip), %rdi      # 0x320b
callq 0x1150
leaq 0x10ae(%rip), %rdi      # 0x321f
callq 0x1150
leaq 0x10da(%rip), %rdi      # 0x3257
callq 0x1150
leaq 0x10f0(%rip), %rdi      # 0x3279
callq 0x1150
leaq 0x111d(%rip), %rdi      # 0x32b2
callq 0x1150
pushq $0xa
popq %rbx
movl %ebx, %edi
callq 0x1130
movl %ebx, %edi
callq 0x1130
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/pstuifzand[P]magento-tools/src/magento-config.cpp
// Function: root_start_element_handler(void*, char const*, char const**)
void root_start_element_handler(void* udata, const XML_Char* name, const XML_Char** atts) {
    user_data* data = (user_data*)udata;
    switch (data->state) {
        case State::ROOT:
            if (strcmp(name, "config") == 0) data->state = State::IN_CONFIG;
            break;
        case State::IN_CONFIG:
            if (strcmp(name, "sections") == 0) data->state = State::IN_SECTIONS;
            break;
        case State::IN_SECTIONS:
            data->state = State::IN_SECTION;
            data->section = name;
            break;
        case State::IN_SECTION:
            if (strcmp(name, "groups") == 0) data->state = State::IN_GROUPS;
            break;
        case State::IN_GROUPS:
            data->group = name;
            data->state = State::IN_GROUP;
            break;
        case State::IN_GROUP:
            if (strcmp(name, "fields") == 0) data->state = State::IN_FIELDS;
            break;
        case State::IN_FIELDS:
            data->field = name;
            data->state = State::IN_FIELD;
            std::stringstream ss;
            ss << data->section << "/" << data->group << "/" << data->field;
            data->names.push_back(ss.str());
            break;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl (%rdi), %eax
decl %eax
cmpl $0x6, %eax
ja 0x2557
movq %rdi, %rbx
leaq 0x1c07(%rip), %rcx      # 0x4004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1c81(%rip), %rax      # 0x408e
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2220
testl %eax, %eax
jne 0x2557
movl $0x2, (%rbx)
jmp 0x2557
leaq 0x30(%rbx), %rdi
callq 0x22a0
movl $0x6, (%rbx)
jmp 0x2557
movl $0x4, (%rbx)
addq $0x10, %rbx
movq %rbx, %rdi
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
jmp 0x22a0
leaq 0x1c3c(%rip), %rax      # 0x409e
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2220
testl %eax, %eax
jne 0x2557
movl $0x5, (%rbx)
jmp 0x2557
leaq 0x1c0e(%rip), %rax      # 0x4095
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2220
testl %eax, %eax
jne 0x2557
movl $0x3, (%rbx)
jmp 0x2557
leaq 0x1bf9(%rip), %rax      # 0x40a5
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2220
testl %eax, %eax
jne 0x2557
movl $0x7, (%rbx)
jmp 0x2557
leaq 0x50(%rbx), %r14
movq %r14, %rdi
callq 0x22a0
movl $0x8, (%rbx)
leaq 0x20(%rsp), %rdi
callq 0x20e0
leaq 0x30(%rsp), %rdi
leaq 0x10(%rbx), %rsi
callq 0x2140
leaq 0x1bb1(%rip), %rsi      # 0x40ac
movq %rax, %rdi
callq 0x2160
leaq 0x30(%rbx), %rsi
movq %rax, %rdi
callq 0x2140
leaq 0x1b96(%rip), %rsi      # 0x40ac
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
movq %r14, %rsi
callq 0x2140
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x2240
addq $0x70, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2b88
movq %rsp, %rdi
callq 0x20b0
leaq 0x20(%rsp), %rdi
callq 0x2100
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20b0
jmp 0x2574
jmp 0x2571
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2270