LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
je 0x2968
movq %rdi, %rbx
leaq 0x1937(%rip), %rsi      # 0x4235
movl $0x1, %ecx
movq $-0x1, %rdx
callq 0x2190
movq %rax, %r14
movq 0x36bf(%rip), %r15      # 0x5fd8
leaq 0x16e4(%rip), %rsi      # 0x4004
movl $0x8, %edx
movq %r15, %rdi
callq 0x2140
movq %r15, %rdi
movl %r14d, %esi
callq 0x21d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
cmpl $-0x1, %r14d
jne 0x2973
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
incl %r14d
movslq %r14d, %rsi
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2040
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq 0x3625(%rip), %rbx      # 0x5fd8
leaq 0x1653(%rip), %rsi      # 0x400d
movl $0x27, %edx
movq %rbx, %rdi
callq 0x2140
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
leaq -0x50(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x1638(%rip), %rsi      # 0x4035
leaq 0x1653(%rip), %rdx      # 0x4057
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
callq 0x3536
leaq -0x90(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0xa0(%rbp), %rdi
callq 0x3498
leaq -0x70(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x17f5(%rip), %rsi      # 0x4235
leaq 0x17ef(%rip), %rdx      # 0x4236
leaq -0x80(%rbp), %rdi
callq 0x3536
leaq -0x40(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x2663
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %r13
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x80(%rbp), %rdi
cmpq %rbx, %rdi
je 0x2a89
callq 0x2100
movq -0xa0(%rbp), %rdi
cmpq %r15, %rdi
je 0x2a9a
callq 0x2100
cmpq %r13, %r12
je 0x2ae6
movq 0x3532(%rip), %r14      # 0x5fd8
movq %r12, %rbx
movl (%rbx), %esi
movq %r14, %rdi
callq 0x21d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
addq $0x4, %rbx
cmpq %r13, %rbx
jne 0x2aa9
movq 0x34eb(%rip), %r14      # 0x5fd8
leaq 0x1564(%rip), %rsi      # 0x4058
movl $0x25, %edx
movq %r14, %rdi
callq 0x2140
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq 0x34b9(%rip), %rdi      # 0x5fd8
callq 0x2030
movq %rax, %rdi
callq 0x20b0
testq %r12, %r12
je 0x2b39
movq %r12, %rdi
callq 0x2100
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x2b4b
callq 0x2100
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x80(%rbp), %rdi
cmpq %rbx, %rdi
je 0x2b70
callq 0x2100
jmp 0x2b70
movq %rax, %r14
movq -0xa0(%rbp), %rdi
cmpq %r15, %rdi
jne 0x2b90
jmp 0x2b95
movq %rax, %r14
jmp 0x2b95
jmp 0x2b85
movq %rax, %r14
testq %r12, %r12
je 0x2b95
movq %r12, %rdi
callq 0x2100
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x2ba7
callq 0x2100
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x3415(%rip), %rbx      # 0x5fd8
leaq 0x14b4(%rip), %rsi      # 0x407e
movl $0x29, %edx
movq %rbx, %rdi
callq 0x2140
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1428(%rip), %rsi      # 0x4035
leaq 0x1443(%rip), %rdx      # 0x4057
leaq -0x38(%rbp), %rdi
callq 0x3536
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1429(%rip), %rsi      # 0x4055
leaq 0x1424(%rip), %rdx      # 0x4057
leaq -0x58(%rbp), %rdi
callq 0x3536
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x271f
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x2c57
callq 0x2100
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x3372(%rip), %rdi      # 0x5fd8
callq 0x2140
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq 0x333c(%rip), %rbx      # 0x5fd8
leaq 0x1405(%rip), %rsi      # 0x40a8
movl $0x27, %edx
movq %rbx, %rdi
callq 0x2140
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq 0x330a(%rip), %rdi      # 0x5fd8
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x2ce9
callq 0x2100
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x2d0c
callq 0x2100
jmp 0x2d0c
jmp 0x2d09
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x2d1a
callq 0x2100
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x32a2(%rip), %rbx      # 0x5fd8
leaq 0x1393(%rip), %rsi      # 0x40d0
movl $0x2b, %edx
movq %rbx, %rdi
callq 0x2140
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x12b5(%rip), %rsi      # 0x4035
leaq 0x12d0(%rip), %rdx      # 0x4057
leaq -0x38(%rbp), %rdi
callq 0x3536
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x12b6(%rip), %rsi      # 0x4055
leaq 0x12b1(%rip), %rdx      # 0x4057
leaq -0x58(%rbp), %rdi
callq 0x3536
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2796
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x2dca
callq 0x2100
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x31ff(%rip), %rdi      # 0x5fd8
callq 0x2140
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq 0x31c9(%rip), %rbx      # 0x5fd8
leaq 0x12e6(%rip), %rsi      # 0x40fc
movl $0x29, %edx
movq %rbx, %rdi
callq 0x2140
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq 0x3197(%rip), %rdi      # 0x5fd8
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x2e5c
callq 0x2100
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x2e7f
callq 0x2100
jmp 0x2e7f
jmp 0x2e7c
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x2e8d
callq 0x2100
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x312f(%rip), %rbx      # 0x5fd8
leaq 0x1276(%rip), %rsi      # 0x4126
movl $0x2a, %edx
movq %rbx, %rdi
callq 0x2140
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1142(%rip), %rsi      # 0x4035
leaq 0x115d(%rip), %rdx      # 0x4057
leaq -0x38(%rbp), %rdi
callq 0x3536
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1143(%rip), %rsi      # 0x4055
leaq 0x113e(%rip), %rdx      # 0x4057
leaq -0x58(%rbp), %rdi
callq 0x3536
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x27ea
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x2f3d
callq 0x2100
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x308c(%rip), %rdi      # 0x5fd8
callq 0x2140
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq 0x3056(%rip), %rbx      # 0x5fd8
leaq 0x11c8(%rip), %rsi      # 0x4151
movl $0x28, %edx
movq %rbx, %rdi
callq 0x2140
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq 0x3024(%rip), %rdi      # 0x5fd8
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x2fcf
callq 0x2100
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x2ff2
callq 0x2100
jmp 0x2ff2
jmp 0x2fef
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x3000
callq 0x2100
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x2fbc(%rip), %rbx      # 0x5fd8
leaq 0x1157(%rip), %rsi      # 0x417a
movl $0x27, %edx
movq %rbx, %rdi
callq 0x2140
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x113c(%rip), %rsi      # 0x41a2
leaq 0x114a(%rip), %rdx      # 0x41b7
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
callq 0x3536
movq %rbx, %rdi
callq 0x2885
movq 0x2f50(%rip), %rdi      # 0x5fd8
leaq 0x1129(%rip), %rsi      # 0x41b8
movl $0x1a, %edx
callq 0x2140
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq 0x2f30(%rip), %rdi      # 0x5fd8
callq 0x2140
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1155(%rip), %rsi      # 0x423b
leaq 0x116a(%rip), %rdx      # 0x4257
leaq -0x38(%rbp), %rdi
callq 0x3536
leaq -0x38(%rbp), %rdi
callq 0x2885
movq 0x2ed2(%rip), %rdi      # 0x5fd8
leaq 0x10ab(%rip), %rsi      # 0x41b8
movl $0x1a, %edx
callq 0x2140
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x2eb2(%rip), %rdi      # 0x5fd8
callq 0x2140
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq 0x2e7c(%rip), %rbx      # 0x5fd8
leaq 0x1070(%rip), %rsi      # 0x41d3
movl $0x25, %edx
movq %rbx, %rdi
callq 0x2140
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq 0x2e4a(%rip), %rdi      # 0x5fd8
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x31a9
callq 0x2100
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x31b7
callq 0x2100
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x31c4
movq %rax, %rbx
jmp 0x31da
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x31da
callq 0x2100
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x31e8
callq 0x2100
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x2dd4(%rip), %rbx      # 0x5fd8
leaq 0xfee(%rip), %rsi       # 0x41f9
movl $0x28, %edx
movq %rbx, %rdi
callq 0x2140
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xfd4(%rip), %rsi       # 0x4222
leaq 0xfe1(%rip), %rdx       # 0x4236
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
callq 0x3536
movq %rbx, %rdi
callq 0x28e3
movq 0x2d68(%rip), %rdi      # 0x5fd8
leaq 0xf41(%rip), %rsi       # 0x41b8
movl $0x1a, %edx
callq 0x2140
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq 0x2d48(%rip), %rdi      # 0x5fd8
callq 0x2140
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xf69(%rip), %rsi       # 0x4237
leaq 0xf82(%rip), %rdx       # 0x4257
leaq -0x38(%rbp), %rdi
callq 0x3536
leaq -0x38(%rbp), %rdi
callq 0x28e3
movq 0x2cea(%rip), %rdi      # 0x5fd8
leaq 0xec3(%rip), %rsi       # 0x41b8
movl $0x1a, %edx
callq 0x2140
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x2cca(%rip), %rdi      # 0x5fd8
callq 0x2140
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq 0x2c94(%rip), %rbx      # 0x5fd8
leaq 0xf0d(%rip), %rsi       # 0x4258
movl $0x26, %edx
movq %rbx, %rdi
callq 0x2140
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq 0x2c62(%rip), %rdi      # 0x5fd8
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x3391
callq 0x2100
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x339f
callq 0x2100
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x33ac
movq %rax, %rbx
jmp 0x33c2
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x33c2
callq 0x2100
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x33d0
callq 0x2100
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x3e60
testq %rax, %rax
je 0x2bc8
movl 0x28(%rax), %ebp
jmp 0x2be4
movl 0x18(%r15), %ebp
movq %r15, %rdi
movq %r14, %rsi
callq 0x3f78
movl %ebp, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x385e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AraHaan[P]bin2c/./libs/lib2hex.hpp
// Function: void lib2hex::HexArraytofile<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>>>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<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>>>>&, bool)
void inline HexArraytofile(std::string &file1, std::string &file2, std::string &CustomVariable,
			std::string &_consolefilevar, std::string &_consolefilevar2, T &array, bool TargetCS) {
		filedata = fileToHexArray(file1, CustomVariable, _consolefilevar, _consolefilevar2,
			array, TargetCS);
		std::fstream f2(file2, std::ios::out | std::ios::binary | std::ios::app);
		f2 << filedata;
		f2.close();
		if (!TargetCS) {
			std::cout << _consolefilevar << array[29];
			#ifdef _WIN32
				std::cout << array[38];
			#endif
		} else {
			std::cout << _consolefilevar << array[30];
			#ifdef _WIN32
				std::cout << array[39];
			#endif
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %r8, %rbx
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %r14
movb 0x258(%rsp), %bpl
movq 0x250(%rsp), %r13
movzbl %bpl, %eax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
pushq %rax
pushq %r13
callq 0x4a9e
addq $0x10, %rsp
leaq 0x38(%r14), %rdi
movq %r12, %rsi
callq 0x2270
movq (%r12), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x493b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2210
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movl $0x15, %edx
callq 0x2320
leaq 0x18(%rsp), %rdi
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
callq 0x2240
leaq 0x8(%rsp), %rdi
callq 0x2050
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
testb %bpl, %bpl
je 0x498d
movq 0x5654(%rip), %rdi      # 0x9fd0
callq 0x2240
movl $0x3c8, %ecx            # imm = 0x3C8
movl $0x3c0, %edx            # imm = 0x3C0
jmp 0x49a3
movq 0x563c(%rip), %rdi      # 0x9fd0
callq 0x2240
movl $0x3a8, %ecx            # imm = 0x3A8
movl $0x3a0, %edx            # imm = 0x3A0
movq (%r13), %rdi
movq (%rdi,%rdx), %rsi
movq (%rdi,%rcx), %rdx
movq %rax, %rdi
callq 0x2240
leaq 0x8(%rsp), %rdi
callq 0x2070
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, 0x4(%rsp)
cmpl $0x0, 0x9063(%rip)      # 0xb418
jne 0x23c5
leaq 0x5cca(%rip), %rdi      # 0x8088
xorl %eax, %eax
callq 0x2030
movq 0x8e34(%rip), %rdi      # 0xb200
leaq 0x5cc8(%rip), %rsi      # 0x809b
callq 0x2180
testq %rax, %rax
je 0x2454
cmpl $0x0, 0x9034(%rip)      # 0xb418
jle 0x2444
movq %rax, %r14
movl 0x4(%rsp), %r12d
xorl %r13d, %r13d
leaq 0x90d8(%rip), %rax      # 0xb4d0
movl (%rax,%r13,4), %r15d
movslq %r15d, %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2170
cmpl $0x0, 0x4(%rsp)
jle 0x242c
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x2200
movl (%rbx,%rbp,4), %esi
movzbl %al, %edx
cmpl %edx, %esi
jne 0x247d
incq %rbp
cmpq %rbp, %r12
jne 0x2412
cmpq $0x3e6, %r13            # imm = 0x3E6
ja 0x2444
incq %r13
movslq 0x8fd9(%rip), %rax      # 0xb418
cmpq %rax, %r13
jl 0x23f1
leaq 0x5f85(%rip), %rdi      # 0x83d0
callq 0x21f0
xorl %eax, %eax
jmp 0x246e
movq 0x8da5(%rip), %rsi      # 0xb200
leaq 0x5c3b(%rip), %rdi      # 0x809d
xorl %eax, %eax
callq 0x2030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5c36(%rip), %rdi      # 0x80ba
movl %r15d, %ecx
xorl %eax, %eax
callq 0x2030
movl $0x1, %edi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %edi, %edi
je 0x25ce
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movl %edi, %r15d
cmpl $0x1, %edi
je 0x25b9
movl $0x2, %eax
xorl %r14d, %r14d
incq %r14
cmpl $0x1e, %r14d
ja 0x258d
addl %eax, %eax
cmpl %ebp, %eax
jbe 0x257e
xorl %r15d, %r15d
cmpl $0x1e, %r14d
ja 0x25b9
leaq 0x1(%r14), %r15
movslq 0x8cdf(%rip), %r12      # 0xb280
leaq (%rbx,%r12), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x20a0
addl %r12d, %r14d
movl %r14d, 0x8cc7(%rip)     # 0xb280
movl %ebp, %edi
movl %r15d, %esi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x24f7
leaq 0x5af6(%rip), %rdi      # 0x80cb
xorl %esi, %esi
xorl %eax, %eax
jmp 0x2030
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x0, 0x8c90(%rip)      # 0xb280
testl %edx, %edx
jle 0x263c
movq %rcx, %rbx
movslq %esi, %rax
movl %edx, %r14d
leaq (%rdi,%rax,4), %r15
xorl %r12d, %r12d
xorl %ebp, %ebp
testq %r12, %r12
je 0x2632
movl (%r15,%r12,4), %eax
subl -0x4(%r15,%r12,4), %eax
testl %ebp, %ebp
movl %r12d, %ecx
cmovnel %ebp, %ecx
testl %eax, %eax
cmovsl %ecx, %ebp
movl %eax, %edi
negl %edi
cmovsl %eax, %edi
incl %edi
movq %rbx, %rsi
callq 0x255d
incq %r12
cmpq %r12, %r14
jne 0x2606
jmp 0x263e
xorl %ebp, %ebp
cmpl $0x2, %ebp
movl $0x1, %eax
cmovgel %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_uni_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:
testl %edi, %edi
jle 0x26cb
movq %rdx, %r9
incl 0x8e2b(%rip)            # 0xb4c4
movl 0x8af0(%rip), %r10d     # 0xb190
movl %edi, %eax
cltd
idivl %r10d
movl %eax, %r8d
movl %edx, %eax
movl 0x8ae2(%rip), %r11d     # 0xb194
cltd
idivl %r11d
movl %eax, %edx
testl %r8d, %r8d
jle 0x26ce
imull %r8d, %r10d
movl %r8d, %eax
movl -0x4(%r9,%rax,4), %eax
jmp 0x26d3
xorl %eax, %eax
retq
xorl %r10d, %r10d
xorl %eax, %eax
testl %edx, %edx
jle 0x26f2
imull %edx, %r11d
addl %r11d, %r10d
imull 0x8d3e(%rip), %r8d      # 0xb424
addl %edx, %r8d
movslq %r8d, %rdx
movzwl (%rcx,%rdx,2), %ecx
addl %ecx, %eax
movl %edi, %edx
subl %r10d, %edx
jle 0x2731
leaq 0x9d80(%rip), %rcx      # 0xc480
leal 0x7(%r10), %r8d
testl %r10d, %r10d
cmovnsl %r10d, %r8d
sarl $0x3, %r8d
movslq %r8d, %r8
movzbl (%rsi,%r8), %r8d
cmpl $0x9, %edx
jl 0x2732
shll $0x5, %r8d
addl 0x1c(%r8,%rcx), %eax
addl $0x8, %r10d
addl $-0x8, %edx
cmpl %edi, %r10d
jl 0x2700
retq
notl %r10d
addl %edi, %r10d
movslq %r10d, %rdx
shll $0x5, %r8d
addq %r8, %rcx
addl (%rcx,%rdx,4), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r14d
movq %rdi, %rbx
movl %r9d, 0x8(%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
movl %r8d, 0xc(%rsp)
movq %rdx, 0x10(%rsp)
je 0x2aed
movl %r8d, %r10d
movl %r9d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2b04
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x7286
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %r10d
leaq -0x1(%rdx), %r13
xorl %r12d, %r12d
xorl %ebp, %ebp
movslq %r14d, %rcx
leaq (%rdx,%rcx), %rax
movq $-0x1, %r8
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edi
addl $0x2, %esi
cmpb $0x1, 0x1(%rax,%r8)
movq %rdi, %r9
leaq 0x1(%r8), %r8
leaq 0x1(%rdi), %rdi
jne 0x2b25
movl %esi, %esi
addq $0x2, %rsi
addq %r13, %rcx
xorl %eax, %eax
movzbl (%rcx,%r9), %edi
leal (%rdi,%rax,2), %eax
incq %r9
cmpq %r9, %rsi
jne 0x2b46
testl %eax, %eax
je 0x2b67
cmpl $0x1, %eax
jne 0x2b6f
movl $0x1, %r15d
jmp 0x2b9f
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x2b9f
movl $0x2, %ecx
movl $0x1, %r15d
movl $0x1, %esi
movl %esi, %edi
addl $0x2, %r15d
cmpl $0x1e, %esi
ja 0x2b93
addl %ecx, %ecx
leal 0x1(%rdi), %esi
cmpl %eax, %ecx
jbe 0x2b7f
cmpl $0x1f, %edi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmovael %ecx, %r15d
testl %r12d, %r12d
je 0x2bb3
cmpl %ebp, %r12d
jge 0x2bc2
movl 0x8(%rsp), %ecx
addl %eax, %ecx
decl %ecx
jmp 0x2bca
cmpl $0x1, %eax
movl $0xffff, %ecx           # imm = 0xFFFF
cmovel %ecx, %eax
movl %eax, %ebp
jmp 0x2bfb
movl 0x8(%rsp), %ecx
subl %eax, %ecx
incl %ecx
movl %ecx, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2be4
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2bfb
movq %rbx, %rdi
leaq 0x8(%rsp), %rdx
callq 0x7286
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %r10d
addl %r15d, %r14d
cmpl %r10d, %r14d
jge 0x2c13
incl %r12d
cmpl $0x3e8, %r12d           # imm = 0x3E8
jne 0x2b0d
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x2, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_uni_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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x886f(%rip), %r14      # 0xb4b0
movq 0x8800(%rip), %r15      # 0xb448
movq 0x87e1(%rip), %r12      # 0xb430
leal 0x1(%rbx), %ecx
movl 0x856b(%rip), %r8d      # 0xb1c4
movl 0x8554(%rip), %r9d      # 0xb1b4
movl 0x8552(%rip), %eax      # 0xb1b8
movl %eax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x28de
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x268c
testl %ebx, %ebx
js 0x2cc3
addl %ebx, %ebx
leal (%rbx,%rbx,2), %edx
leal (%rbx,%rbx,2), %edi
addl $0x6, %edi
movl 0x8588(%rip), %esi      # 0xb224
movq 0x87f5(%rip), %r8       # 0xb498
addq %rdx, %r8
xorl %ecx, %ecx
movzbl (%r8), %r9d
leal (%r9,%rcx,2), %ecx
incl %esi
incl %edx
incq %r8
cmpl %edx, %edi
jg 0x2ca8
movl %esi, 0x8563(%rip)      # 0xb224
jmp 0x2cc5
xorl %ecx, %ecx
shll $0x6, %eax
addl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_uni_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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x87c3(%rip), %r14      # 0xb4a8
movq 0x8764(%rip), %r15      # 0xb450
movq 0x8745(%rip), %r12      # 0xb438
leal 0x1(%rdi), %ecx
movl 0x84c3(%rip), %r8d      # 0xb1c0
movl 0x84a8(%rip), %r9d      # 0xb1ac
movl 0x84a6(%rip), %eax      # 0xb1b0
movl %eax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x28de
movl %eax, %ebx
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x268c
movl 0x8459(%rip), %edx      # 0xb18c
leaq 0x85f6(%rip), %rcx      # 0xb330
leaq (%rcx,%rdx,4), %rcx
leaq 0x863b(%rip), %rsi      # 0xb380
cmpl $0x2, %edx
jl 0x2d5d
leaq -0x1(%rdx), %rdi
addq $-0x4, %rcx
cmpl -0x4(%rsi,%rdx,4), %ebx
movq %rdi, %rdx
jl 0x2d45
subl (%rcx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_uni_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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
callq 0x2c30
movl %eax, %ebp
leal 0x1(%rbx), %edi
callq 0x2c30
movl %eax, %r15d
movl %ebx, %edi
callq 0x2cd6
movq 0x86c7(%rip), %rdx      # 0xb488
movq %r14, %rdi
movl %ebp, %ecx
movl %r15d, %r8d
movl %eax, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2ab0
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: pscmpr(bool*, bool*, int, int, int, int, int, int, int)
int pscmpr(bool *ar,bool *ar2,int start,int start2,int l,int bl,int plen,int y,int a){ //分割2つの長さをlまで比べる．
    int od = 0;
    int key = 0;
    int len = 0;
    int rt = l;
    if(a<l){rt = a;} //rtはlとaのうち小さいほう
    int readcount = 0;
    int x;int i;
    for(i = 0;i<rt;i++){
        if(readcount==y && y!=0 && od==1){return 1;}
        if(readcount==bl && bl!=0 && od==2){return 0;}
        //if(gate>0){printf("\n%d ? %d",ar[start+i],ar2[start2+i]);}
        if(ar[start+i]!=ar2[start2+i]){
            if(key==0){
                if(ar[start+i]==0){x = 1;}
                else{x = 0;}
            }
            if(key==1){
                if(ar[start+i]==0){x=0;}
                else{x=1;}
            }
            if(od==3){x = (x+1)%2;}
            if(od==1){return 0;}
            if(od==2){return 1;}
            return x;
        }
        if((ar[start+i] == 1) && key == 0){len+=1;key=1;}
        if(key==0){len++;}
        else{
            len--;
            if(len==0){
                readcount++;
                //if(gate>0){printf("\n%d++",readcount);}
                key=0;
                if(readcount==y){od+=2;}
                if(readcount==bl){od+=1;}
                if(readcount>=plen){break;} //分割を全て読んでしまった
                if(od==1){
                    return 0;}
                if(od==2){
                    if(i+1==a){return 0;}
                    return 1;
                }
            }
        }
    }
    if(a<l){return 0;}
    if(a>l){return 1;}
    if(a==l){return 2;}
    return 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x40(%rsp), %r10d
cmpl %r8d, %r10d
movl %r8d, %ebx
cmovll %r10d, %ebx
testl %ebx, %ebx
jle 0x3321
movl 0x38(%rsp), %eax
movl 0x30(%rsp), %r11d
movslq %edx, %rdx
movslq %ecx, %r14
movl %ebx, %ecx
addq %rdx, %rdi
addq %r14, %rsi
xorl %edx, %edx
xorl %ebp, %ebp
xorl %r14d, %r14d
xorl %r15d, %r15d
xorl %ebx, %ebx
movb (%rdi,%rdx), %r12b
cmpb (%rsi,%rdx), %r12b
jne 0x3332
testl %r15d, %r15d
sete %r15b
andb %r15b, %r12b
movzbl %r12b, %r12d
addl %r12d, %r14d
cmpb %r12b, %r15b
je 0x32da
incl %r14d
xorl %r15d, %r15d
jmp 0x3319
movl $0x1, %r15d
decl %r14d
jne 0x3319
incl %ebp
cmpl %r11d, %ebp
jge 0x3321
xorl %r14d, %r14d
cmpl %r9d, %ebp
sete %r14b
leal 0x2(%rbx), %r15d
cmpl %eax, %ebp
cmovnel %ebx, %r15d
movl %r14d, %ebx
addl %r15d, %ebx
cmpl $0x1, %ebx
je 0x3355
xorl %r15d, %r15d
movl $0x0, %r14d
cmpl $0x2, %ebx
je 0x3359
incq %rdx
cmpq %rdx, %rcx
jne 0x32b2
xorl %eax, %eax
cmpl %r8d, %r10d
jl 0x3364
setle %al
movzbl %al, %eax
incl %eax
jmp 0x3364
cmpl $0x1, %r15d
setne %cl
movl %r12d, %eax
xorb %cl, %al
movzbl %al, %eax
cmpl $0x3, %ebx
jne 0x3364
decl %eax
cmpb %cl, %r12b
movl $0x1, %ecx
cmovel %ecx, %eax
jmp 0x3364
xorl %eax, %eax
jmp 0x3364
decl %r10d
xorl %eax, %eax
cmpl %edx, %r10d
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $0x3, %edx
jl 0x3b47
pushq %rbp
pushq %rbx
movslq %esi, %rax
movl %edx, %edx
leaq (%rdi,%rax,4), %rsi
incl %eax
movl $0x2, %r8d
movl $0x0, (%rcx,%r8,4)
movl $0x1, %r9d
movl %eax, %r10d
movslq %r10d, %r11
leaq (%rdi,%r11,4), %rbx
xorl %r11d, %r11d
movl (%rsi,%r11,4), %ebp
cmpl (%rbx,%r11,4), %ebp
jne 0x3b24
incq %r11
cmpq %r11, %r9
jne 0x3b0f
movl %r9d, %r11d
movl %r11d, %ebx
cmpq %rbx, %r9
jne 0x3b30
movl %r11d, (%rcx,%r8,4)
incq %r9
decl %r10d
cmpq %r8, %r9
jne 0x3b05
incq %r8
incl %eax
cmpq %rdx, %r8
jne 0x3af4
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
xorl %r12d, %r12d
cmpl $0x2, %esi
jl 0x40be
leal -0x1(%r14), %eax
leaq 0x7226(%rip), %rcx      # 0xb2e0
movl (%rcx,%rax,4), %r12d
movslq %ebx, %rax
leaq (%rax,%rax,4), %r13
leaq 0xa3e4(%rip), %r15      # 0xe4b0
movl (%r15,%r13,8), %esi
testl %esi, %esi
js 0x4134
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x2d93
leaq (%r15,%r13,8), %rax
movq (%rsp), %rdi
movq 0x8(%rsp), %rcx
addl -0x4(%rcx), %r12d
movl %r12d, (%rax)
cmpl $0x2, %ebp
jl 0x4127
decl %r14d
decl %ebp
movq 0x20(%rsp), %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x4092
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4134
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x415c
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: leftopennd(int*, int, int, int)
int leftopennd(int *m,int round,int count,int tround){ //左の[0][1]をcount回開ける
     if(DEBUGFLAG==1){
         printf("\n[2-左%dオープン(%d)]",count,round);
         if(occart2[tround][1] > -1){uhdisp(occart2[tround][1]);}
         if(occart2[tround][0] > -1){uhdisp(occart2[tround][0]);;}
    }
    int rofs=0;
    if(round>1){rofs=dc2s[round-1];}
    if(occart2[tround][1] > -1){ //左辺文字Aが指定されていれば
        std::vector<int> x;
        xdisp(x,occart2[tround][1]);
         if(DEBUGFLAG==1){printf("open [%d,%d--%d] >>",occart2[tround][1],dc2s[round],rofs);}
        int a1 = rofs+x[x.size() - 1];
        if(DEBUGFLAG==1){printf("\na1 = %d(%d)",a1,count);}
        if(count>1){occart2[tround][1] = a1;return leftopennd(m,round-1,count-1,tround);}
        int a2;
        //if(D_2[occart2[tround][1]]<2){printf("a2を消す");a2 = -1;}
        a2 = rofs+x[x.size() - 2];
        occart2[tround][1] = a1;
        occart2[tround][0] = a2;
        if(DEBUGFLAG==1){printf("\n更新 = %d & %d",a1,a2);}
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
xorl %r12d, %r12d
cmpl $0x2, %esi
jl 0x4190
leal -0x1(%r14), %eax
leaq 0x7154(%rip), %rcx      # 0xb2e0
movl (%rcx,%rax,4), %r12d
movslq %ebx, %rax
leaq (%rax,%rax,4), %r13
leaq 0xa312(%rip), %r15      # 0xe4b0
movl 0x4(%r15,%r13,8), %esi
testl %esi, %esi
js 0x4219
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x2d93
leaq (%r15,%r13,8), %rax
movq 0x8(%rsp), %rdx
movl -0x4(%rdx), %ecx
addl %r12d, %ecx
cmpl $0x2, %ebp
jge 0x41ea
movq (%rsp), %rdi
subq %rdi, %rdx
addl -0x8(%rdi,%rdx), %r12d
movl %ecx, 0x4(%rax)
movl %r12d, (%rax)
jmp 0x420c
movl %ecx, 0x4(%rax)
decl %r14d
decl %ebp
movq 0x20(%rsp), %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x4164
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4219
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x422c
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4245
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: findintop(int, int)
void findintop(int tg,int pofs){ //NS列からtgを探す
    if(DEBUGFLAG==1){printf("\n[%d]を探す(%d)",tg,dc2s[loops-1]);}
    int len = 0;
    for(int y1 = 0;y1<Sizelist[0];y1++){
        if(DEBUGFLAG==1){printf("[%d]答え",NS[y1]);}
        if(NS[y1]==tg-dc2s[loops-1]){
            printf(" %d",len+pofs);
            if(ans<1000 && CHECKFLAG==1){checkans[ans]=len+pofs;}
            ans++;
        }
        len+= D3access(NS[y1]+dc2s[loops-1]);
    }
    //printf("\nend of searching.(%d)[%d]",len,tg);
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movl %edi, 0xc(%rsp)
movl 0x69c9(%rip), %r14d     # 0xb1a0
testl %r14d, %r14d
jle 0x4861
movq 0x6c41(%rip), %rbx      # 0xb428
movl 0x699f(%rip), %ebp      # 0xb18c
leaq 0x6aec(%rip), %r15      # 0xb2e0
xorl %r12d, %r12d
xorl %r13d, %r13d
movl (%rbx,%r12,4), %edi
movslq %ebp, %rax
movl 0xc(%rsp), %ecx
subl -0x4(%r15,%rax,4), %ecx
cmpl %ecx, %edi
jne 0x4847
movq 0x10(%rsp), %rax
leal (%rax,%r13), %esi
leaq 0x3a28(%rip), %rdi      # 0x8246
xorl %eax, %eax
callq 0x2030
incl 0x6bed(%rip)            # 0xb418
movq 0x6bf6(%rip), %rbx      # 0xb428
movslq 0x6953(%rip), %rbp      # 0xb18c
movl 0x6960(%rip), %r14d     # 0xb1a0
movl (%rbx,%r12,4), %edi
movq %rbp, %rax
decq %rax
addl (%r15,%rax,4), %edi
callq 0x3a9f
addl %eax, %r13d
incq %r12
movslq %r14d, %rax
cmpq %rax, %r12
jl 0x47fa
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: findinround1(int, int, int)
void findinround1(int tg,int round,int pofs){
    if(round==loops){return findintop(tg,pofs);}
    //あるラウンドから文字[tg]を探す
    //printf("%d(+%d)",tg,pofs); //引き継いだズレ値を記録
    int e2[2];
    int rofs = 0;
    if(round>1){rofs=dc2s[round-1];}
    for(int y8=dc2s[round];y8<dc2s[round+1];y8++){
        int ofs = 0;
        //printf("\n[%d(%d)]",y8,D_2[y8+1]-D_2[y8]);
        std::vector<int> x;
        xdisp(x,y8);
        for(int y9=0;y9<x.size();y9++){
            //printf(" %d",rofs+D[y9]);
            if(rofs+x[y9]==tg){
                //if(round>15){printf("\n発見(%d,%d[+%d])",tg,ofs+pofs,ofs);}
                findinround1(y8,round+1,pofs+ofs);
            }
            if(round>0){ofs+=D3access(rofs+x[y9]);}else{ofs++;}
        }
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl %esi, 0x6908(%rip)      # 0xb18c
jne 0x489b
movl %edx, %esi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x47b9
movl %edi, 0xc(%rsp)
movq %rdx, 0x30(%rsp)
xorl %ebx, %ebx
leaq 0x6a33(%rip), %r15      # 0xb2e0
cmpl $0x2, %esi
jl 0x48b9
leal -0x1(%rsi), %eax
movl (%r15,%rax,4), %ebx
movslq %esi, %rax
movl (%r15,%rax,4), %r12d
movq %rax, (%rsp)
cmpl 0x4(%r15,%rax,4), %r12d
jge 0x4986
movq %rsi, %r14
incq (%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
movl %r12d, %esi
callq 0x2d93
movq 0x10(%rsp), %r13
cmpq %r13, 0x18(%rsp)
je 0x4960
xorl %r15d, %r15d
xorl %ebp, %ebp
movl (%r13,%r15,4), %eax
addl %ebx, %eax
cmpl 0xc(%rsp), %eax
jne 0x492b
movq 0x30(%rsp), %rax
leal (%rax,%rbp), %edx
movl %r12d, %edi
movq (%rsp), %rsi
callq 0x4870
movq 0x10(%rsp), %r13
testl %r14d, %r14d
jle 0x493e
movl (%r13,%r15,4), %edi
addl %ebx, %edi
callq 0x3a9f
jmp 0x4943
movl $0x1, %eax
addl %eax, %ebp
incq %r15
movq 0x18(%rsp), %rax
subq %r13, %rax
sarq $0x2, %rax
cmpq %r15, %rax
ja 0x4905
leaq 0x6980(%rip), %r15      # 0xb2e0
testq %r13, %r13
je 0x4975
movq 0x20(%rsp), %rsi
subq %r13, %rsi
movq %r13, %rdi
callq 0x2160
incl %r12d
movq (%rsp), %rax
cmpl (%r15,%rax,4), %r12d
jl 0x48d6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4997
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x49b1
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: qrmloadset(int*, int)
int qrmloadset(int *m,int jo){ //c番目を読む
    FILE *fp;
    long long int qsize = std::filesystem::file_size(qname); //qsizeには，ファイルのサイズが書かれているはず
    fp = fopen(qname,"r"); // open file or return null
    if(fp == NULL) {
        printf("%s such file doesn't exist!\n", qname);
        return -1;
    }
    int c = qsize/querysuu;
    fseek(fp,jo*c,SEEK_SET); //指定したシークまで移動する
    for(int i=0;i<c;i++) { //c文字
        char chr = fgetc(fp);
        m[i] = chr;
        if(chr<0){m[i]=chr + 256;}
        if(m[i]==10){jswt=1;}
        if(DEBUGFLAG==1){printf("%c",chr);}
    }
    printf("]");
    return c;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x5616(%rip), %rsi      # 0xb200
movq %rsp, %r14
movq %r14, %rdi
movl $0x2, %edx
callq 0x71c6
movq %r14, %rdi
callq 0x21c0
movq %rax, %r14
movq %rsp, %rdi
callq 0x724e
movq 0x55ec(%rip), %rdi      # 0xb200
leaq 0x2480(%rip), %rsi      # 0x809b
callq 0x2180
testq %rax, %rax
je 0x5c8f
movq %rax, %r15
movslq 0x5525(%rip), %rcx      # 0xb154
movq %r14, %rax
cqto
idivq %rcx
movq %rax, %r14
imull %r14d, %ebp
movslq %ebp, %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x2170
testl %r14d, %r14d
jle 0x5c83
movl %r14d, %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x2200
movzbl %al, %eax
movl %eax, (%rbx,%r13,4)
cmpl $0xa, %eax
jne 0x5c7b
movl $0x1, 0x5845(%rip)      # 0xb4c0
incq %r13
cmpq %r13, %r12
jne 0x5c5d
movl $0x5d, %edi
callq 0x21d0
jmp 0x5caa
movq 0x556a(%rip), %rsi      # 0xb200
leaq 0x2400(%rip), %rdi      # 0x809d
xorl %eax, %eax
callq 0x2030
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x724e
movq %rbx, %rdi
callq 0x2220