LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sagardesd[P]CoolString/include/stringops.hpp
// Function: cool::stringops::trim_leading_spaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void trim_leading_spaces(std::string& sourceString)
	{
		if(sourceString.empty())
		{
			return;
		}
		int found = sourceString.find_first_not_of(" ");
		if(found != std::string::npos && found != 0)
		{
			sourceString.erase(0, found);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2200
testb $0x1, %al
jne 0x2afb
jmp 0x2afd
jmp 0x2b35
movq -0x8(%rbp), %rdi
leaq 0x372d(%rip), %rsi      # 0x6235
xorl %eax, %eax
movl %eax, %edx
callq 0x20a0
movl %eax, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq $-0x1, %rax
je 0x2b35
cmpl $0x0, -0xc(%rbp)
je 0x2b35
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sagardesd[P]CoolString/include/stringops.hpp
// Function: cool::stringops::trim_trailing_spaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void trim_trailing_spaces(std::string& sourceString)
	{
		if(sourceString.empty())
		{
			return;
		}
		int found = sourceString.find_last_not_of(" ");
		std::cout << "found - " << found << std::endl;
		if(found != std::string::npos)
		{
			sourceString.erase(found + 1, sourceString.size());
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2200
testb $0x1, %al
jne 0x2b5b
jmp 0x2b5d
jmp 0x2bdb
movq -0x8(%rbp), %rdi
leaq 0x36cd(%rip), %rsi      # 0x6235
movq $-0x1, %rdx
callq 0x2240
movl %eax, -0xc(%rbp)
movq 0x645a(%rip), %rdi      # 0x8fd8
leaq 0x347f(%rip), %rsi      # 0x6004
callq 0x2120
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2210
movq %rax, %rdi
movq 0x6429(%rip), %rsi      # 0x8fc8
callq 0x2150
movslq -0xc(%rbp), %rax
cmpq $-0x1, %rax
je 0x2bdb
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
cltq
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20d0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sagardesd[P]CoolString/src/mainTest.cpp
// Function: test_find_all_occourance()
void test_find_all_occourance()
{
	std::cout << "TEST : test_find_all_occourance : START" << std::endl;
	std::string sourceString("is sagar is his job doing properis");
	IntVector posVect;
	posVect = cool::stringops::find_all_occourance(sourceString, " ");
	std::for_each(posVect.begin(), posVect.end(), [](int item){std::cout << item << std::endl;});
	std::cout << "TEST : test_find_all_occourance : END" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq 0x63b6(%rip), %rdi      # 0x8fd8
leaq 0x33e4(%rip), %rsi      # 0x600d
callq 0x2120
movq %rax, %rdi
movq 0x6390(%rip), %rsi      # 0x8fc8
callq 0x2150
leaq -0x21(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x2230
movq -0xd0(%rbp), %rdx
leaq 0x33da(%rip), %rsi      # 0x6035
leaq -0x20(%rbp), %rdi
callq 0x21a0
jmp 0x2c66
leaq -0x21(%rbp), %rdi
callq 0x2160
leaq -0x50(%rbp), %rdi
callq 0x3800
leaq -0x88(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2080
jmp 0x2c8a
leaq -0xa9(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x2230
movq -0xd8(%rbp), %rdx
leaq 0x358a(%rip), %rsi      # 0x6235
leaq -0xa8(%rbp), %rdi
callq 0x21a0
jmp 0x2cb9
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x2790
jmp 0x2cd2
leaq -0x50(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
leaq -0x68(%rbp), %rsi
movq %rsi, -0xe8(%rbp)
callq 0x38f0
movq -0xe8(%rbp), %rdi
callq 0x3890
leaq -0xa8(%rbp), %rdi
callq 0x20c0
leaq -0xa9(%rbp), %rdi
callq 0x2160
leaq -0x88(%rbp), %rdi
callq 0x20c0
movq -0xe0(%rbp), %rdi
callq 0x3920
movq -0xe0(%rbp), %rdi
movq %rax, -0xb8(%rbp)
callq 0x3950
movq %rax, -0xc0(%rbp)
movq -0xb8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x2e30
jmp 0x2d58
movq 0x6279(%rip), %rdi      # 0x8fd8
leaq 0x32f2(%rip), %rsi      # 0x6058
callq 0x2120
movq %rax, -0xf0(%rbp)
jmp 0x2d74
movq -0xf0(%rbp), %rdi
movq 0x6246(%rip), %rsi      # 0x8fc8
callq 0x2150
jmp 0x2d89
leaq -0x50(%rbp), %rdi
callq 0x3890
leaq -0x20(%rbp), %rdi
callq 0x20c0
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x2160
jmp 0x2e19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2e07
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2def
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x20c0
leaq -0xa9(%rbp), %rdi
callq 0x2160
leaq -0x88(%rbp), %rdi
callq 0x20c0
leaq -0x50(%rbp), %rdi
callq 0x3890
leaq -0x20(%rbp), %rdi
callq 0x20c0
movq -0x30(%rbp), %rdi
callq 0x2220
nopw %cs:(%rax,%rax)
// File: sagardesd[P]CoolString/src/mainTest.cpp
// Function: test_remove_all_occourance()
void test_remove_all_occourance()
{
	std::cout << "TEST : test_remove_all_occourance : START" << std::endl;
	std::string sourceString("is sagar is his job doing properis");
	cool::stringops::remove_all_occourance(sourceString, "is");
	std::cout << sourceString << std::endl;
	std::cout << "TEST : test_remove_all_occourance : END" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x6146(%rip), %rdi      # 0x8fd8
leaq 0x31e5(%rip), %rsi      # 0x607e
callq 0x2120
movq %rax, %rdi
movq 0x6120(%rip), %rsi      # 0x8fc8
callq 0x2150
leaq -0x21(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2230
movq -0x68(%rbp), %rdx
leaq 0x3170(%rip), %rsi      # 0x6035
leaq -0x20(%rbp), %rdi
callq 0x21a0
jmp 0x2ed0
leaq -0x21(%rbp), %rdi
callq 0x2160
leaq -0x59(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x2230
movq -0x70(%rbp), %rdx
leaq 0x3164(%rip), %rsi      # 0x6055
leaq -0x58(%rbp), %rdi
callq 0x21a0
jmp 0x2efc
leaq -0x20(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x28a0
jmp 0x2f0b
leaq -0x58(%rbp), %rdi
callq 0x20c0
leaq -0x59(%rbp), %rdi
callq 0x2160
movq 0x60b4(%rip), %rdi      # 0x8fd8
leaq -0x20(%rbp), %rsi
callq 0x2100
movq %rax, -0x78(%rbp)
jmp 0x2f33
movq -0x78(%rbp), %rdi
movq 0x608a(%rip), %rsi      # 0x8fc8
callq 0x2150
jmp 0x2f45
movq 0x608c(%rip), %rdi      # 0x8fd8
leaq 0x3155(%rip), %rsi      # 0x60a8
callq 0x2120
movq %rax, -0x80(%rbp)
jmp 0x2f5e
movq -0x80(%rbp), %rdi
movq 0x605f(%rip), %rsi      # 0x8fc8
callq 0x2150
jmp 0x2f70
leaq -0x20(%rbp), %rdi
callq 0x20c0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x2160
jmp 0x2fdc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2fbc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x20c0
leaq -0x59(%rbp), %rdi
callq 0x2160
jmp 0x2fd3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x20c0
movq -0x30(%rbp), %rdi
callq 0x2220
nopw %cs:(%rax,%rax)
// File: sagardesd[P]CoolString/src/mainTest.cpp
// Function: test_remove_first_occourance()
void test_remove_first_occourance()
{
	std::cout << "TEST : test_remove_first_occourance : START" << std::endl;
	std::string sourceString("is sagar is his job doing properis");
	cool::stringops::remove_first_occourance(sourceString, "is");
	std::cout << sourceString << std::endl;
	std::cout << "TEST : test_remove_first_occourance : END" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x5fd6(%rip), %rdi      # 0x8fd8
leaq 0x30c7(%rip), %rsi      # 0x60d0
callq 0x2120
movq %rax, %rdi
movq 0x5fb0(%rip), %rsi      # 0x8fc8
callq 0x2150
leaq -0x21(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2230
movq -0x68(%rbp), %rdx
leaq 0x3000(%rip), %rsi      # 0x6035
leaq -0x20(%rbp), %rdi
callq 0x21a0
jmp 0x3040
leaq -0x21(%rbp), %rdi
callq 0x2160
leaq -0x59(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x2230
movq -0x70(%rbp), %rdx
leaq 0x2ff4(%rip), %rsi      # 0x6055
leaq -0x58(%rbp), %rdi
callq 0x21a0
jmp 0x306c
leaq -0x20(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2940
jmp 0x307b
leaq -0x58(%rbp), %rdi
callq 0x20c0
leaq -0x59(%rbp), %rdi
callq 0x2160
movq 0x5f44(%rip), %rdi      # 0x8fd8
leaq -0x20(%rbp), %rsi
callq 0x2100
movq %rax, -0x78(%rbp)
jmp 0x30a3
movq -0x78(%rbp), %rdi
movq 0x5f1a(%rip), %rsi      # 0x8fc8
callq 0x2150
jmp 0x30b5
movq 0x5f1c(%rip), %rdi      # 0x8fd8
leaq 0x3039(%rip), %rsi      # 0x60fc
callq 0x2120
movq %rax, -0x80(%rbp)
jmp 0x30ce
movq -0x80(%rbp), %rdi
movq 0x5eef(%rip), %rsi      # 0x8fc8
callq 0x2150
jmp 0x30e0
leaq -0x20(%rbp), %rdi
callq 0x20c0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x2160
jmp 0x314c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x312c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x20c0
leaq -0x59(%rbp), %rdi
callq 0x2160
jmp 0x3143
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x20c0
movq -0x30(%rbp), %rdi
callq 0x2220
nopw %cs:(%rax,%rax)
// File: sagardesd[P]CoolString/src/mainTest.cpp
// Function: test_remove_last_occourance()
void test_remove_last_occourance()
{
	std::cout << "TEST : test_remove_last_occourance : START" << std::endl;
	std::string sourceString("is sagar is his job doing properis");
	cool::stringops::remove_last_occourance(sourceString, "is");
	std::cout << sourceString << std::endl;
	std::cout << "TEST : test_remove_last_occourance : END" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x5e66(%rip), %rdi      # 0x8fd8
leaq 0x2fad(%rip), %rsi      # 0x6126
callq 0x2120
movq %rax, %rdi
movq 0x5e40(%rip), %rsi      # 0x8fc8
callq 0x2150
leaq -0x21(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2230
movq -0x68(%rbp), %rdx
leaq 0x2e90(%rip), %rsi      # 0x6035
leaq -0x20(%rbp), %rdi
callq 0x21a0
jmp 0x31b0
leaq -0x21(%rbp), %rdi
callq 0x2160
leaq -0x59(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x2230
movq -0x70(%rbp), %rdx
leaq 0x2e84(%rip), %rsi      # 0x6055
leaq -0x58(%rbp), %rdi
callq 0x21a0
jmp 0x31dc
leaq -0x20(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x29e0
jmp 0x31eb
leaq -0x58(%rbp), %rdi
callq 0x20c0
leaq -0x59(%rbp), %rdi
callq 0x2160
movq 0x5dd4(%rip), %rdi      # 0x8fd8
leaq -0x20(%rbp), %rsi
callq 0x2100
movq %rax, -0x78(%rbp)
jmp 0x3213
movq -0x78(%rbp), %rdi
movq 0x5daa(%rip), %rsi      # 0x8fc8
callq 0x2150
jmp 0x3225
movq 0x5dac(%rip), %rdi      # 0x8fd8
leaq 0x2f1e(%rip), %rsi      # 0x6151
callq 0x2120
movq %rax, -0x80(%rbp)
jmp 0x323e
movq -0x80(%rbp), %rdi
movq 0x5d7f(%rip), %rsi      # 0x8fc8
callq 0x2150
jmp 0x3250
leaq -0x20(%rbp), %rdi
callq 0x20c0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x2160
jmp 0x32bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x329c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x20c0
leaq -0x59(%rbp), %rdi
callq 0x2160
jmp 0x32b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x20c0
movq -0x30(%rbp), %rdi
callq 0x2220
nopw %cs:(%rax,%rax)
// File: sagardesd[P]CoolString/src/mainTest.cpp
// Function: test_trim_leading_spaces()
void test_trim_leading_spaces()
{
	std::cout << "TEST : test_trim_leading_spaces : START" << std::endl;
	std::string sourceString1("     is sagar is dumb");
	cool::stringops::trim_leading_spaces(sourceString1);
	std::cout << "Source string after trim :" << sourceString1 << std::endl;
	std::string sourceString2("This string is without space");
	cool::stringops::trim_leading_spaces(sourceString2);
	std::cout << "Source string after trim :" << sourceString2 << std::endl;
	std::cout << "TEST : test_trim_leading_spaces : END" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0x5cf6(%rip), %rdi      # 0x8fd8
leaq 0x2e91(%rip), %rsi      # 0x617a
callq 0x2120
movq %rax, %rdi
movq 0x5cd0(%rip), %rsi      # 0x8fc8
callq 0x2150
leaq -0x21(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2230
movq -0x68(%rbp), %rdx
leaq 0x2e8d(%rip), %rsi      # 0x61a2
leaq -0x20(%rbp), %rdi
callq 0x21a0
jmp 0x3320
leaq -0x21(%rbp), %rdi
callq 0x2160
leaq -0x20(%rbp), %rdi
callq 0x2ae0
jmp 0x3334
movq 0x5c9d(%rip), %rdi      # 0x8fd8
leaq 0x2e76(%rip), %rsi      # 0x61b8
callq 0x2120
movq %rax, -0x70(%rbp)
jmp 0x334d
movq -0x70(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2100
movq %rax, -0x78(%rbp)
jmp 0x3360
movq -0x78(%rbp), %rdi
movq 0x5c5d(%rip), %rsi      # 0x8fc8
callq 0x2150
jmp 0x3372
leaq -0x59(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x2230
movq -0x80(%rbp), %rdx
leaq 0x2eb1(%rip), %rsi      # 0x623b
leaq -0x58(%rbp), %rdi
callq 0x21a0
jmp 0x3395
leaq -0x59(%rbp), %rdi
callq 0x2160
leaq -0x58(%rbp), %rdi
callq 0x2ae0
jmp 0x33a9
movq 0x5c28(%rip), %rdi      # 0x8fd8
leaq 0x2e01(%rip), %rsi      # 0x61b8
callq 0x2120
movq %rax, -0x88(%rbp)
jmp 0x33c5
movq -0x88(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2100
movq %rax, -0x90(%rbp)
jmp 0x33de
movq -0x90(%rbp), %rdi
movq 0x5bdc(%rip), %rsi      # 0x8fc8
callq 0x2150
jmp 0x33f3
movq 0x5bde(%rip), %rdi      # 0x8fd8
leaq 0x2dd2(%rip), %rsi      # 0x61d3
callq 0x2120
movq %rax, -0x98(%rbp)
jmp 0x340f
movq -0x98(%rbp), %rdi
movq 0x5bab(%rip), %rsi      # 0x8fc8
callq 0x2150
jmp 0x3424
leaq -0x58(%rbp), %rdi
callq 0x20c0
leaq -0x20(%rbp), %rdi
callq 0x20c0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x2160
jmp 0x3499
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x3490
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x2160
jmp 0x3490
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x20c0
leaq -0x20(%rbp), %rdi
callq 0x20c0
movq -0x30(%rbp), %rdi
callq 0x2220
nopw %cs:(%rax,%rax)
// File: sagardesd[P]CoolString/src/mainTest.cpp
// Function: test_trim_trailing_spaces()
void test_trim_trailing_spaces()
{
	std::cout << "TEST : test_trim_trailing_spaces : START" << std::endl;
	std::string sourceString1("is sagar is dumb    ");
	cool::stringops::trim_trailing_spaces(sourceString1);
	std::cout << "Source string after trim :" << sourceString1 << std::endl;
	std::string sourceString2("    This string is without space");
	cool::stringops::trim_trailing_spaces(sourceString2);
	std::cout << "Source string after trim :" << sourceString2 << std::endl;
	std::cout << "TEST : test_trim_trailing_spaces : END" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0x5b16(%rip), %rdi      # 0x8fd8
leaq 0x2d30(%rip), %rsi      # 0x61f9
callq 0x2120
movq %rax, %rdi
movq 0x5af0(%rip), %rsi      # 0x8fc8
callq 0x2150
leaq -0x21(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2230
movq -0x68(%rbp), %rdx
leaq 0x2d2d(%rip), %rsi      # 0x6222
leaq -0x20(%rbp), %rdi
callq 0x21a0
jmp 0x3500
leaq -0x21(%rbp), %rdi
callq 0x2160
leaq -0x20(%rbp), %rdi
callq 0x2b40
jmp 0x3514
movq 0x5abd(%rip), %rdi      # 0x8fd8
leaq 0x2c96(%rip), %rsi      # 0x61b8
callq 0x2120
movq %rax, -0x70(%rbp)
jmp 0x352d
movq -0x70(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2100
movq %rax, -0x78(%rbp)
jmp 0x3540
movq -0x78(%rbp), %rdi
movq 0x5a7d(%rip), %rsi      # 0x8fc8
callq 0x2150
jmp 0x3552
leaq -0x59(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x2230
movq -0x80(%rbp), %rdx
leaq 0x2ccd(%rip), %rsi      # 0x6237
leaq -0x58(%rbp), %rdi
callq 0x21a0
jmp 0x3575
leaq -0x59(%rbp), %rdi
callq 0x2160
leaq -0x58(%rbp), %rdi
callq 0x2b40
jmp 0x3589
movq 0x5a48(%rip), %rdi      # 0x8fd8
leaq 0x2c21(%rip), %rsi      # 0x61b8
callq 0x2120
movq %rax, -0x88(%rbp)
jmp 0x35a5
movq -0x88(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2100
movq %rax, -0x90(%rbp)
jmp 0x35be
movq -0x90(%rbp), %rdi
movq 0x59fc(%rip), %rsi      # 0x8fc8
callq 0x2150
jmp 0x35d3
movq 0x59fe(%rip), %rdi      # 0x8fd8
leaq 0x2c77(%rip), %rsi      # 0x6258
callq 0x2120
movq %rax, -0x98(%rbp)
jmp 0x35ef
movq -0x98(%rbp), %rdi
movq 0x59cb(%rip), %rsi      # 0x8fc8
callq 0x2150
jmp 0x3604
leaq -0x58(%rbp), %rdi
callq 0x20c0
leaq -0x20(%rbp), %rdi
callq 0x20c0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x2160
jmp 0x3679
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x3670
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x2160
jmp 0x3670
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x20c0
leaq -0x20(%rbp), %rdi
callq 0x20c0
movq -0x30(%rbp), %rdi
callq 0x2220
nopw %cs:(%rax,%rax)
// File: Altius[P]hotspot2/src/findVarWidthPeaks.cpp
// Function: Height_GT(Range const&, Range const&)
bool Height_GT(const Range& a, const Range& b)
{
  if (fabs(a.maxY - b.maxY) < 0.0001) // == on floating-point numbers
    {
      if (a.beg.x == b.beg.x)
	return a.end.x < b.end.x;
      return a.beg.x < b.beg.x;
    }
  return a.maxY > b.maxY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movss 0x60(%rax), %xmm0
movq -0x18(%rbp), %rax
subss 0x60(%rax), %xmm0
callq 0x49e0
cvtss2sd %xmm0, %xmm1
movsd 0x7a95(%rip), %xmm0     # 0xa008
ucomisd %xmm1, %xmm0
jbe 0x25bf
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jne 0x25a5
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x50(%rcx), %rax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x25d8
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x40(%rcx), %rax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x25d8
movq -0x10(%rbp), %rax
movss 0x60(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomiss 0x60(%rax), %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Altius[P]hotspot2/src/findVarWidthPeaks.cpp
// Function: GenomicOrder_LT(Range const&, Range const&)
bool GenomicOrder_LT(const Range& a, const Range& b)
{
  if (a.chrom == b.chrom)
    {
      if (a.beg.x == b.beg.x)
	{
	  if (a.end.x == b.end.x)
	    return a.inputSummit < b.inputSummit;
	  return a.end.x < b.end.x;
	}
      return a.beg.x < b.beg.x;
    }
  return a.chrom < b.chrom;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4a00
testb $0x1, %al
jne 0x2613
jmp 0x2685
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jne 0x266b
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jne 0x2651
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x70(%rcx), %rax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2697
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x50(%rcx), %rax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2697
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x40(%rcx), %rax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2697
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4a90
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wenleix[P]EdgePPR/src/CreateObjGraph.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void split(const std::string &s, char delim, std::vector<std::string> &elems) {
    assert(elems.empty());

    std::stringstream ss(s);
    std::string item;
    while (std::getline(ss, item, delim)) {
        elems.push_back(item);
    }
}

// Assembly:
subq $0x1e8, %rsp            # imm = 0x1E8
movb %sil, %al
movq %rdi, 0x1e0(%rsp)
movb %al, 0x1df(%rsp)
movq %rdx, 0x1d0(%rsp)
movq 0x1d0(%rsp), %rdi
callq 0x4520
testb $0x1, %al
jne 0x2694
jmp 0x2696
jmp 0x26b5
leaq 0xa96b(%rip), %rdi      # 0xd008
leaq 0xa972(%rip), %rsi      # 0xd016
movl $0x4f, %edx
leaq 0xa97d(%rip), %rcx      # 0xd02d
callq 0x2130
movq 0x1e0(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x4570
movq 0x10(%rsp), %rsi
movl %eax, %edx
leaq 0x48(%rsp), %rdi
callq 0x2280
leaq 0x28(%rsp), %rdi
callq 0x2220
movsbl 0x1df(%rsp), %edx
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x22e0
movq %rax, 0x8(%rsp)
jmp 0x270a
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x21e0
movb %al, 0x7(%rsp)
jmp 0x2724
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x272e
jmp 0x2768
movq 0x1d0(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x4590
jmp 0x2742
jmp 0x26ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2120
leaq 0x48(%rsp), %rdi
callq 0x2150
jmp 0x2784
leaq 0x28(%rsp), %rdi
callq 0x2120
leaq 0x48(%rsp), %rdi
callq 0x2150
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq 0x20(%rsp), %rdi
callq 0x22c0
nop
// File: wenleix[P]EdgePPR/src/CreateObjGraph.cpp
// Function: ParseAttrLine(char*, char const*)
char* ParseAttrLine(char *lineBuf, const char *attr) {
	int attrLen = strlen(attr);
    assert(strncmp(lineBuf, attr, attrLen) == 0);
    lineBuf[strlen(lineBuf) - 1] = 0;   //  Delete the last '\n'

    return lineBuf + attrLen + 2;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x20a0
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movslq 0x14(%rsp), %rdx
callq 0x20d0
cmpl $0x0, %eax
jne 0x27c7
jmp 0x27e6
leaq 0xa8a1(%rip), %rdi      # 0xd06f
leaq 0xa841(%rip), %rsi      # 0xd016
movl $0x5b, %edx
leaq 0xa8b3(%rip), %rcx      # 0xd094
callq 0x2130
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x20a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq 0x20(%rsp), %rax
movslq 0x14(%rsp), %rcx
addq %rcx, %rax
addq $0x2, %rax
addq $0x28, %rsp
retq
// File: wenleix[P]EdgePPR/src/CreateObjGraph.cpp
// Function: GetOrCreateID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
int GetOrCreateID(const string& st, unordered_map<string, int>& dict, vector<string>& namelist) {
	auto it = dict.find(st);
	if (it == conf_id.end()) {
		int newId = dict.size();
		dict[st] = newId;
		namelist.push_back(st);
		return newId;
	} else {
		return it->second;
	}

	assert(false);
	return -1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x47d0
movq %rax, 0x10(%rsp)
leaq 0x10459a(%rip), %rdi    # 0x107428
callq 0x4820
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x4800
testb $0x1, %al
jne 0x2ead
jmp 0x2eef
movq 0x20(%rsp), %rdi
callq 0x4850
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x4860
movl (%rsp), %ecx
movl %ecx, (%rax)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x4590
movl 0x4(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x2f00
leaq 0x10(%rsp), %rdi
callq 0x4890
movl 0x20(%rax), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: anscheck(int, int*)
int anscheck(int msize,int *m){ //msizeに持っているデータと比較し，答えが合っているかを確認する．
    if(ans==0){printf("[特殊]答え0個");}
    int ckt = 0;
    int huseiresult = 0;
    unsigned char chr;FILE *fp;fp = fopen(qname, "r");
    if(fp == NULL) {
        printf("%s such file doesn't exist!\n", qname);
        return -1;
    }
    for(int j = 0;j<ans;j++){
        if(j>999){break;}
        int c = checkans[j];
        fseek(fp,c,SEEK_SET);   
        if(DEBUGFLAG==1){printf("\nCK%d:rlen[%d]から\n[",j+1,c);}
        for(int i=0;i<msize;i++) { //c文字
            chr = fgetc(fp);
            if(DEBUGFLAG==1){printf("%c",chr);}
            if(m[i]!=chr){
                printf("[%d != %d] in %d",m[i],chr,c);exit(1);
                ckt++;
            }
        }
        if(DEBUGFLAG==1){printf("]\n");}
        if(ckt!=0){
            printf("[不正結果出力]");
            huseiresult++;
        }
    }
    if(huseiresult>0){printf("\n不正数:%d",huseiresult);exit(1);}
    printf("\n結果：出力された位置は全て正しい\n(過剰な出力はない)\n");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0xc032(%rip)      # 0xe428
jne 0x2406
leaq 0x8c29(%rip), %rdi      # 0xb028
movb $0x0, %al
callq 0x2030
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq 0xbdf5(%rip), %rdi      # 0xe210
leaq 0x8c19(%rip), %rsi      # 0xb03b
callq 0x21c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2453
movq 0xbdd7(%rip), %rsi      # 0xe210
leaq 0x8bfd(%rip), %rdi      # 0xb03d
movb $0x0, %al
callq 0x2030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x255f
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl 0xbfc5(%rip), %eax      # 0xe428
jge 0x2529
cmpl $0x3e7, -0x2c(%rbp)     # imm = 0x3E7
jle 0x2477
jmp 0x2529
movslq -0x2c(%rbp), %rcx
leaq 0xc05e(%rip), %rax      # 0xe4e0
movl (%rax,%rcx,4), %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x21b0
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x24fc
movq -0x28(%rbp), %rdi
callq 0x2230
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movzbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
je 0x24ef
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movzbl -0x19(%rbp), %edx
movl -0x30(%rbp), %ecx
leaq 0x8b7c(%rip), %rdi      # 0xb05a
movb $0x0, %al
callq 0x2030
movl $0x1, %edi
callq 0x21e0
jmp 0x24f1
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x249e
cmpl $0x0, -0x14(%rbp)
je 0x2519
leaq 0x8b62(%rip), %rdi      # 0xb06b
movb $0x0, %al
callq 0x2030
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x251b
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x245a
cmpl $0x0, -0x18(%rbp)
jle 0x254a
movl -0x18(%rbp), %esi
leaq 0x8b47(%rip), %rdi      # 0xb080
movb $0x0, %al
callq 0x2030
movl $0x1, %edi
callq 0x21e0
leaq 0x8b3d(%rip), %rdi      # 0xb08e
movb $0x0, %al
callq 0x2030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: loga(unsigned int)
int loga(unsigned int u){ //指定の数字uがn桁の二進数で表せる時，nを返す．
    if(u<1){/*printf("(%d)",u);*/return 0;}
    unsigned int e = 2;
    for(int i=1;i<32;i++){
        if(e>u){return i;}
        e *=2;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x1, -0x8(%rbp)
jae 0x2586
movl $0x0, -0x4(%rbp)
jmp 0x25c4
movl $0x2, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
cmpl $0x20, -0x10(%rbp)
jge 0x25bd
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jbe 0x25aa
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x25c4
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2594
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: logg(unsigned int, bool*)
void logg(unsigned int u, bool *ar){ //指定の数字uのガンマ符号を二進数で表す，配列kにその値を保存．
    if(u<1){printf("0以下の数(%d)はlogg表現不可\n",u);return;}
    int l = loga(u);
    for(int i=1;i<l;i++){ar[kad]=0;kad++;}
    logb(u,l,ar);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x4(%rbp)
jae 0x2748
movl -0x4(%rbp), %esi
leaq 0x899d(%rip), %rdi      # 0xb0dc
movb $0x0, %al
callq 0x2030
jmp 0x279a
movl -0x4(%rbp), %edi
callq 0x2570
movl %eax, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x278b
movq -0x10(%rbp), %rax
movslq 0xbb23(%rip), %rcx      # 0xe290
movb $0x0, (%rax,%rcx)
movl 0xbb19(%rip), %eax      # 0xe290
addl $0x1, %eax
movl %eax, 0xbb10(%rip)      # 0xe290
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x275a
movl -0x4(%rbp), %edi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x2650
addq $0x20, %rsp
popq %rbp
retq
// File: TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: cmlen(int*, int, int, bool*)
int cmlen(int *m,int p,int l,bool *ar){ //配列arの先頭から分割mを保存する．
    kad = 0; //必ず位置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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, 0xbad0(%rip)      # 0xe290
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2838
cmpl $0x0, -0x20(%rbp)
je 0x282b
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
addl -0x20(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
subl (%rcx,%rdx,4), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x281c
cmpl $0x0, -0x1c(%rbp)
jne 0x2814
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
subl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
addl $0x1, %edi
movq -0x18(%rbp), %rsi
callq 0x2720
jmp 0x282d
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x27ce
cmpl $0x0, -0x1c(%rbp)
jg 0x2845
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: gread(int, bool*)
int gread(int p,bool *ar){
    //配列kの位置pからガンマ符号化でどのようなもじが存在するのかを読み解く
    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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x287e
jmp 0x2889
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2862
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x28d3
movl -0x1c(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2896
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: sranknew1(int, unsigned char*, int*, unsigned short*, int, int)
int sranknew1(int c,unsigned char *u,int *u2,unsigned short int *u3,int t2,int t3){ //0から始まってk番目までの1の個数を返す．．
    if(c<=0){return 0;}
    gate++;
    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){s+=nk*spurse;e+=u3[r*spursesuu+nk];}
    for(int i=s;i<c;i++){
        //printf("\n<%d-%d-%d-[%d]>",i,c,e,u[i/8]);
        //for(int y=0;y<8;y++){printf("%d",rankct[u[i/8]][y]);}
        if(c-i>8){e+=rankct[u[i/8]][7];i+=7;}
        else{
            e+=rankct[u[i/8]][c-i-1];return e;
        }
    }
    return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
cmpl $0x0, -0x8(%rbp)
jg 0x290d
movl $0x0, -0x4(%rbp)
jmp 0x2a6e
movl 0xbbc1(%rip), %eax      # 0xe4d4
addl $0x1, %eax
movl %eax, 0xbbb8(%rip)      # 0xe4d4
movl -0x8(%rbp), %eax
cltd
idivl 0xb87a(%rip)            # 0xe1a0
movl %eax, -0x2c(%rbp)
movl -0x8(%rbp), %eax
movl -0x2c(%rbp), %ecx
imull 0xb86a(%rip), %ecx      # 0xe1a0
subl %ecx, %eax
cltd
idivl 0xb865(%rip)            # 0xe1a4
movl %eax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x2976
movl 0xb844(%rip), %eax      # 0xe1a0
imull -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x30(%rbp)
jle 0x29aa
movl -0x30(%rbp), %eax
imull 0xb81e(%rip), %eax      # 0xe1a4
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
imull 0xba9a(%rip), %ecx      # 0xe434
addl -0x30(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x2a68
movl -0x8(%rbp), %eax
subl -0x3c(%rbp), %eax
cmpl $0x8, %eax
jle 0x2a0b
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x3c(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x48(%rbp), %rax
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0xcaa0(%rip), %rax      # 0xf490
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x1c(%rax), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x7, %eax
movl %eax, -0x3c(%rbp)
jmp 0x2a58
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x3c(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x50(%rbp), %rax
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0xca5c(%rip), %rax      # 0xf490
shlq $0x5, %rcx
addq %rcx, %rax
movl -0x8(%rbp), %ecx
subl -0x3c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2a6e
jmp 0x2a5a
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x29b0
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: psreadx(std::vector<int, std::allocator<int>>&, int, bool*, int, int, int)
int psreadx(std::vector<int>& x,int p,bool *ar,int D2start,int D2end,int basekey){
    //tx[p]からtx[p+1]までの差分を読んで配列xに再生．再生した文字数を返却
    //if(DEBUGFLAG==1){printf("[%d]%d ",D2start,basekey);}
    int a;
    x.push_back(basekey); //先頭はbasekey
    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;}
            x.push_back(basekey);
            //if(DEBUGFLAG==1){printf("%d ",basekey);}
        }
        else{
            turnsl = a;
            if(a==1){turnsl=65535;}
        }
        if(st>=D2end){break;}
    }
    return x.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x9d20
movl $0x0, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x3e8, -0x34(%rbp)     # imm = 0x3E8
jge 0x3216
movl -0x30(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x2850
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
callq 0x2570
shll %eax
subl $0x1, %eax
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x34(%rbp)
jle 0x31e7
movl -0x34(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jl 0x31cc
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movl -0x24(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0x31d8
movl -0x28(%rbp), %eax
subl $0x1, %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x9d20
jmp 0x31fc
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x1, -0x28(%rbp)
jne 0x31fa
movl $0xffff, -0x2c(%rbp)    # imm = 0xFFFF
jmp 0x31fc
movl -0x30(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0x3206
jmp 0x3216
jmp 0x3208
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x317f
movq -0x8(%rbp), %rdi
callq 0x9d90
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: psread(int, bool*, int, int, int)
int psread(int p,bool *ar,int D2start,int D2end,int basekey){
    //tx[p]からtx[p+1]までの差分を読んで分割を再生．
    if(DEBUGFLAG==1){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;}
            if(DEBUGFLAG==1){printf("%d ",basekey);}
        }
        else{
            turnsl = a;
            if(a==1){turnsl=65535;}
        }
        if(st>=D2end){break;}
    }
    if(DEBUGFLAG==1){
        printf("(");
        for(int y8 = D2start;y8<D2end;y8++){printf("%d",ar[y8]);}
        printf(")");
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x3e8, -0x2c(%rbp)     # imm = 0x3E8
jge 0x32e3
movl -0x28(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x2850
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
callq 0x2570
shll %eax
subl $0x1, %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x32b4
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jl 0x32a6
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
jmp 0x32b2
movl -0x20(%rbp), %eax
subl $0x1, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x32c9
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x20(%rbp)
jne 0x32c7
movl $0xffff, -0x24(%rbp)    # imm = 0xFFFF
jmp 0x32c9
movl -0x28(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x32d3
jmp 0x32e3
jmp 0x32d5
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x325d
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: getd2(int)
int getd2(int tgm){
    int tgm2 = selectnew0(d2topx,d2topsub,d2topsub2,tgm+1,Sizelist[9],Sizelist[5],Sizelist[6]); //tgm2 = その位置までの1の数を見る．
    int tgm3 = sranknew1(tgm2,d2topx,d2topsub,d2topsub2,Sizelist[5],Sizelist[6]);
    int tgm4 = bread(d2under,tgm*6,6);
    return tgm3*64+tgm4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0xb1be(%rip), %rdi      # 0xe4c0
movq 0xb14f(%rip), %rsi      # 0xe458
movq 0xb130(%rip), %rdx      # 0xe440
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
movl 0xaeb7(%rip), %r8d      # 0xe1d4
movl 0xaea0(%rip), %r9d      # 0xe1c4
movl 0xae9e(%rip), %eax      # 0xe1c8
movl %eax, (%rsp)
callq 0x2de0
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
movq 0xb181(%rip), %rsi      # 0xe4c0
movq 0xb112(%rip), %rdx      # 0xe458
movq 0xb0f3(%rip), %rcx      # 0xe440
movl 0xae70(%rip), %r8d      # 0xe1c4
movl 0xae6d(%rip), %r9d      # 0xe1c8
callq 0x28e0
movl %eax, -0xc(%rbp)
movq 0xb13e(%rip), %rdi      # 0xe4a8
imull $0x6, -0x4(%rbp), %esi
movl $0x6, %edx
callq 0x25d0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
shll $0x6, %eax
addl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: gethead(int)
int gethead(int tgm){
    int tgm2 = selectnew0(k3x,k3sub,k3sub2,tgm+1,Sizelist[8],Sizelist[3],Sizelist[4]); //tgm2 = その位置までの1の数を見る．
    //printf("\n<%d>",tgm2);
    int tgm3 = sranknew1(tgm2,k3x,k3sub,k3sub2,Sizelist[3],Sizelist[4]); //その位置までの1の数 = 開始文字.
    //printf("\n<%d>",tgm3);
    for(int o = loops-1;o>0;o--){
            if(tgm2>=cc2s[o]){tgm3-=ccs[o];break;}
    }
    //printf("\n<%d>",tgm3);
    return tgm3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0xb116(%rip), %rdi      # 0xe4b8
movq 0xb0b7(%rip), %rsi      # 0xe460
movq 0xb098(%rip), %rdx      # 0xe448
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
movl 0xae13(%rip), %r8d      # 0xe1d0
movl 0xadf8(%rip), %r9d      # 0xe1bc
movl 0xadf6(%rip), %eax      # 0xe1c0
movl %eax, (%rsp)
callq 0x2de0
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
movq 0xb0d9(%rip), %rsi      # 0xe4b8
movq 0xb07a(%rip), %rdx      # 0xe460
movq 0xb05b(%rip), %rcx      # 0xe448
movl 0xadc8(%rip), %r8d      # 0xe1bc
movl 0xadc5(%rip), %r9d      # 0xe1c0
callq 0x28e0
movl %eax, -0xc(%rbp)
movl 0xad93(%rip), %eax      # 0xe19c
subl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x344d
movl -0x8(%rbp), %eax
movslq -0x10(%rbp), %rdx
leaq 0xaf6d(%rip), %rcx      # 0xe390
cmpl (%rcx,%rdx,4), %eax
jl 0x3440
movslq -0x10(%rbp), %rcx
leaq 0xaf0d(%rip), %rax      # 0xe340
movl (%rax,%rcx,4), %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x344d
jmp 0x3442
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x340f
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: xdisp(std::vector<int, std::allocator<int>>&, int)
int xdisp(std::vector<int>& x,int tgm){ //tgm番の分割をxに蘇生
        //printf("\n%d:",tgm);
        int D2start = getd2(tgm);
        int D2end = getd2(tgm+1);
        int tgm3 = gethead(tgm);
        return psreadx(x,tgm,k,D2start,D2end,tgm3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x32f0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
addl $0x1, %edi
callq 0x32f0
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %edi
callq 0x3390
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq 0xaf97(%rip), %rdx      # 0xe498
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
movl -0x18(%rbp), %r9d
callq 0x3140
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: D3access(int)
int D3access(int c){ //c番目のD_3の値を返す
    if(c<Sizelist[1]){return D_3s[c];}
    if(c<Sizelist[2]){return D_3m[c-Sizelist[1]];}
    return D_3[c-Sizelist[2]];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x9ab4(%rip), %eax      # 0xe1b4
jge 0x4716
movq 0x9d87(%rip), %rax      # 0xe490
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x4756
movl -0x8(%rbp), %eax
cmpl 0x9a99(%rip), %eax      # 0xe1b8
jge 0x473d
movq 0x9d28(%rip), %rax      # 0xe450
movl -0x8(%rbp), %ecx
subl 0x9a83(%rip), %ecx      # 0xe1b4
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x4756
movq 0x9d24(%rip), %rax      # 0xe468
movl -0x8(%rbp), %ecx
subl 0x9a6b(%rip), %ecx      # 0xe1b8
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: mkkmpc(int*, int, int, int*)
void mkkmpc(int *m,int startm,int mrlen,int *kmpc){
    //2文字一致の時 [0]と[1]が一緒なら，次は1文字進めて1文字一致してる前提で進める
    //3文字一致の時 [0]と[2]が一緒なら，次は2文字進めて1文字一致してる前提で進める
    //            [0-1]と[1-2]が一緒なら，次は1文字進めて2文字一致してる前提で進める．
    for(int i2 = 2;i2<mrlen;i2++){ //i2文字一緒の時
        kmpc[i2] = 0;
        for(int i3 = 1; i3 <i2;i3++){
            int i4 = 0;
            while(i4<i3){
                if(m[startm+i4]==m[startm+(i2-i3)+i4]){
                    i4++;
                    //printf("[%d==%d]",i4,i2-i3+i4);
                }
                else{break;}
            }
            if(i4==i3){kmpc[i2]=i4;}
        }
    }
    
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x2, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x481e
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl $0x1, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x480e
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x47eb
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
movl -0x1c(%rbp), %esi
subl -0x20(%rbp), %esi
addl %esi, %edx
addl -0x24(%rbp), %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x47e7
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x47e9
jmp 0x47eb
jmp 0x47aa
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0x4801
movl -0x24(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x4803
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x479b
jmp 0x4810
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4779
popq %rbp
retq
// File: TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: leftopen(int*, int, int, int)
void leftopen(int *m,int round,int count,int tround){ //左の[0]をcount回開ける
    if(DEBUGFLAG==1){
         printf("\n[1-左%dオープン(%d)]",count,round);
         if(occart2[tround][0] > -1){uhdisp(occart2[tround][0]);}
    }
    int rofs=0;
    if(round>1){rofs=dc2s[round-1];}
    if(occart2[tround][0] > -1){
        std::vector<int> x;
        xdisp(x,occart2[tround][0]);
       occart2[tround][0] = rofs+x[x.size()-1];
       if(DEBUGFLAG==1){printf(" >> %d ",occart2[tround][0]);}
       if(count>1){leftopen(m,round-1,count-1,tround);}
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jle 0x4ea8
movl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x944e(%rip), %rax      # 0xe2f0
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0xc60d(%rip), %rax      # 0x114c0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $-0x1, (%rax)
jle 0x4f65
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x9db0
movq -0x48(%rbp), %rdi
movslq -0x14(%rbp), %rax
leaq (%rax,%rax,4), %rcx
leaq 0xc5dd(%rip), %rax      # 0x114c0
movl (%rax,%rcx,8), %esi
callq 0x34c0
jmp 0x4eed
movl -0x18(%rbp), %eax
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9d90
movq %rax, %rsi
subq $0x1, %rsi
leaq -0x30(%rbp), %rdi
callq 0x9dd0
movl -0x4c(%rbp), %ecx
addl (%rax), %ecx
movslq -0x14(%rbp), %rdx
leaq 0xc5a4(%rip), %rax      # 0x114c0
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
cmpl $0x1, -0x10(%rbp)
jle 0x4f5c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
decl %esi
movl -0x10(%rbp), %edx
decl %edx
movl -0x14(%rbp), %ecx
callq 0x4e70
jmp 0x4f43
jmp 0x4f5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9df0
jmp 0x4f6b
leaq -0x30(%rbp), %rdi
callq 0x9df0
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2250
nopw %cs:(%rax,%rax)