LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x361e(%rip), %rbx      # 0x5fd8
leaq 0x164c(%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 0x1631(%rip), %rsi      # 0x4035
leaq 0x164c(%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 0x349c
leaq -0x70(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x17ee(%rip), %rsi      # 0x4235
leaq 0x17e8(%rip), %rdx      # 0x4236
leaq -0x80(%rbp), %rdi
callq 0x3536
leaq -0x40(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x2661
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 0x2a90
callq 0x2100
movq -0xa0(%rbp), %rdi
cmpq %r15, %rdi
je 0x2aa1
callq 0x2100
cmpq %r13, %r12
je 0x2aed
movq 0x352b(%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 0x2ab0
movq 0x34e4(%rip), %r14      # 0x5fd8
leaq 0x155d(%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 0x34b2(%rip), %rdi      # 0x5fd8
callq 0x2030
movq %rax, %rdi
callq 0x20b0
testq %r12, %r12
je 0x2b40
movq %r12, %rdi
callq 0x2100
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x2b52
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 0x2b77
callq 0x2100
jmp 0x2b77
movq %rax, %r14
movq -0xa0(%rbp), %rdi
cmpq %r15, %rdi
je 0x2b8d
callq 0x2100
jmp 0x2b8d
movq %rax, %r14
xorl %r12d, %r12d
jmp 0x2b97
jmp 0x2b94
movq %rax, %r14
testq %r12, %r12
je 0x2ba4
movq %r12, %rdi
callq 0x2100
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x2bb6
callq 0x2100
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3406(%rip), %rbx      # 0x5fd8
leaq 0x14a5(%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 0x1419(%rip), %rsi      # 0x4035
leaq 0x1434(%rip), %rdx      # 0x4057
leaq -0x38(%rbp), %rdi
callq 0x3536
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x141a(%rip), %rsi      # 0x4055
leaq 0x1415(%rip), %rdx      # 0x4057
leaq -0x58(%rbp), %rdi
callq 0x3536
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x271d
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x2c66
callq 0x2100
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x3363(%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 0x332d(%rip), %rbx      # 0x5fd8
leaq 0x13f6(%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 0x32fb(%rip), %rdi      # 0x5fd8
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x2cf8
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 0x2d1b
callq 0x2100
jmp 0x2d1b
jmp 0x2d18
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x2d29
callq 0x2100
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3293(%rip), %rbx      # 0x5fd8
leaq 0x1384(%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 0x12a6(%rip), %rsi      # 0x4035
leaq 0x12c1(%rip), %rdx      # 0x4057
leaq -0x38(%rbp), %rdi
callq 0x3536
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x12a7(%rip), %rsi      # 0x4055
leaq 0x12a2(%rip), %rdx      # 0x4057
leaq -0x58(%rbp), %rdi
callq 0x3536
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2795
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x2dd9
callq 0x2100
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x31f0(%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 0x31ba(%rip), %rbx      # 0x5fd8
leaq 0x12d7(%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 0x3188(%rip), %rdi      # 0x5fd8
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x2e6b
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 0x2e8e
callq 0x2100
jmp 0x2e8e
jmp 0x2e8b
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x2e9c
callq 0x2100
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3120(%rip), %rbx      # 0x5fd8
leaq 0x1267(%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 0x1133(%rip), %rsi      # 0x4035
leaq 0x114e(%rip), %rdx      # 0x4057
leaq -0x38(%rbp), %rdi
callq 0x3536
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1134(%rip), %rsi      # 0x4055
leaq 0x112f(%rip), %rdx      # 0x4057
leaq -0x58(%rbp), %rdi
callq 0x3536
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x27e9
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x2f4c
callq 0x2100
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x307d(%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 0x3047(%rip), %rbx      # 0x5fd8
leaq 0x11b9(%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 0x3015(%rip), %rdi      # 0x5fd8
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x2fde
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 0x3001
callq 0x2100
jmp 0x3001
jmp 0x2ffe
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x300f
callq 0x2100
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fad(%rip), %rbx      # 0x5fd8
leaq 0x1148(%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 0x112d(%rip), %rsi      # 0x41a2
leaq 0x113b(%rip), %rdx      # 0x41b7
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
callq 0x3536
movq %rbx, %rdi
callq 0x288c
movq 0x2f41(%rip), %rdi      # 0x5fd8
leaq 0x111a(%rip), %rsi      # 0x41b8
movl $0x1a, %edx
callq 0x2140
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq 0x2f21(%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 0x1146(%rip), %rsi      # 0x423b
leaq 0x115b(%rip), %rdx      # 0x4257
leaq -0x38(%rbp), %rdi
callq 0x3536
leaq -0x38(%rbp), %rdi
callq 0x288c
movq 0x2ec3(%rip), %rdi      # 0x5fd8
leaq 0x109c(%rip), %rsi      # 0x41b8
movl $0x1a, %edx
callq 0x2140
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x2ea3(%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 0x2e6d(%rip), %rbx      # 0x5fd8
leaq 0x1061(%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 0x2e3b(%rip), %rdi      # 0x5fd8
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x31b8
callq 0x2100
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x31c6
callq 0x2100
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x31d3
movq %rax, %rbx
jmp 0x31e9
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x31e9
callq 0x2100
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x31f7
callq 0x2100
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2dc5(%rip), %rbx      # 0x5fd8
leaq 0xfdf(%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 0xfc5(%rip), %rsi       # 0x4222
leaq 0xfd2(%rip), %rdx       # 0x4236
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
callq 0x3536
movq %rbx, %rdi
callq 0x28ea
movq 0x2d59(%rip), %rdi      # 0x5fd8
leaq 0xf32(%rip), %rsi       # 0x41b8
movl $0x1a, %edx
callq 0x2140
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq 0x2d39(%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 0xf5a(%rip), %rsi       # 0x4237
leaq 0xf73(%rip), %rdx       # 0x4257
leaq -0x38(%rbp), %rdi
callq 0x3536
leaq -0x38(%rbp), %rdi
callq 0x28ea
movq 0x2cdb(%rip), %rdi      # 0x5fd8
leaq 0xeb4(%rip), %rsi       # 0x41b8
movl $0x1a, %edx
callq 0x2140
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x2cbb(%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 0x2c85(%rip), %rbx      # 0x5fd8
leaq 0xefe(%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 0x2c53(%rip), %rdi      # 0x5fd8
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x33a0
callq 0x2100
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x33ae
callq 0x2100
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x33bb
movq %rax, %rbx
jmp 0x33d1
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x33d1
callq 0x2100
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x33df
callq 0x2100
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/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:
movss 0x60(%rdi), %xmm0
movss 0x60(%rsi), %xmm1
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
andps 0x3b8c(%rip), %xmm2     # 0x6010
cvtss2sd %xmm2, %xmm2
movsd 0x3b90(%rip), %xmm3     # 0x6020
ucomisd %xmm2, %xmm3
jbe 0x24ac
movq 0x40(%rsi), %rax
cmpq %rax, 0x40(%rdi)
jne 0x24a8
movq 0x50(%rdi), %rax
cmpq 0x50(%rsi), %rax
setl %al
retq
ucomiss %xmm1, %xmm0
seta %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdx
cmpq 0x8(%rsi), %rdx
jne 0x24db
testq %rdx, %rdx
je 0x24eb
movq (%rbx), %rsi
movq (%r14), %rdi
callq 0x21b0
testl %eax, %eax
je 0x24eb
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2040
shrl $0x1f, %eax
jmp 0x250a
movq 0x40(%rbx), %rax
cmpq %rax, 0x40(%r14)
jne 0x2507
movq 0x50(%rbx), %rax
cmpq %rax, 0x50(%r14)
jne 0x2507
movq 0x70(%r14), %rax
cmpq 0x70(%rbx), %rax
setl %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x4338
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x20a0
movslq %eax, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x20b0
testl %eax, %eax
jne 0x2762
movq %rbx, %rdi
callq 0x20a0
movb $0x0, -0x1(%rbx,%rax)
leaq (%rbx,%r14), %rax
addq $0x2, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x394e(%rip), %rdi      # 0x60b7
leaq 0x38ee(%rip), %rsi      # 0x605e
leaq 0x3965(%rip), %rcx      # 0x60dc
movl $0x5b, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3e64
testq %rax, %rax
je 0x2bc8
movl 0x28(%rax), %ebp
jmp 0x2be4
movl 0x18(%r15), %ebp
movq %r15, %rdi
movq %r14, %rsi
callq 0x3f7c
movl %ebp, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3830
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4a98
addq $0x10, %rsp
leaq 0x38(%r14), %rdi
movq %r12, %rsi
callq 0x2270
movq (%r12), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4935
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 0x4987
movq 0x565a(%rip), %rdi      # 0x9fd0
callq 0x2240
movl $0x3c8, %ecx            # imm = 0x3C8
movl $0x3c0, %edx            # imm = 0x3C0
jmp 0x499d
movq 0x5642(%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_O1/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 0x5c9a(%rip), %rdi      # 0x8058
xorl %eax, %eax
callq 0x2030
movq 0x8e34(%rip), %rdi      # 0xb200
leaq 0x5c98(%rip), %rsi      # 0x806b
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 0x5f55(%rip), %rdi      # 0x83a0
callq 0x21f0
xorl %eax, %eax
jmp 0x246e
movq 0x8da5(%rip), %rsi      # 0xb200
leaq 0x5c0b(%rip), %rdi      # 0x806d
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 0x5c06(%rip), %rdi      # 0x808a
movl %r15d, %ecx
xorl %eax, %eax
callq 0x2030
movl $0x1, %edi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl %edi, %eax
cmpl $0x2, %edi
jb 0x24c3
movl $0x2, %edx
movl $0x1, %ecx
movl %ecx, %esi
leal 0x1(%rsi), %ecx
cmpl $0x1e, %esi
ja 0x24b9
addl %edx, %edx
cmpl %eax, %edx
jbe 0x24a9
xorl %eax, %eax
cmpl $0x1f, %esi
cmovael %eax, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_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 0x25dc
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl %edi, %r14d
cmpl $0x1, %edi
je 0x259b
movl $0x2, %eax
movl $0x1, %r14d
movl %r14d, %ecx
leal 0x1(%rcx), %r14d
cmpl $0x1e, %ecx
ja 0x2592
addl %eax, %eax
cmpl %ebp, %eax
jbe 0x2580
xorl %eax, %eax
cmpl $0x1f, %ecx
cmovael %eax, %r14d
cmpl $0x2, %r14d
jl 0x25c5
movslq 0x8cd8(%rip), %r15      # 0xb280
movq %r15, %rdi
addq %rbx, %rdi
leal -0x1(%r14), %edx
xorl %esi, %esi
callq 0x20a0
leal (%r14,%r15), %eax
decl %eax
movl %eax, 0x8cbb(%rip)      # 0xb280
movl %ebp, %edi
movl %r14d, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x24f7
leaq 0x5ab8(%rip), %rdi      # 0x809b
xorl %esi, %esi
xorl %eax, %eax
jmp 0x2030
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x8c82(%rip)      # 0xb280
testl %edx, %edx
jle 0x264a
movq %rcx, %rbx
movslq %esi, %rax
movl %edx, %r14d
leaq (%rdi,%rax,4), %r15
xorl %r12d, %r12d
xorl %ebp, %ebp
testq %r12, %r12
je 0x2640
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 0x2614
jmp 0x264c
xorl %ebp, %ebp
cmpl $0x2, %ebp
movl $0x1, %eax
cmovgel %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_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 0x26d9
movq %rdx, %r9
incl 0x8e1d(%rip)            # 0xb4c4
movl 0x8ae2(%rip), %r10d     # 0xb190
movl %edi, %eax
cltd
idivl %r10d
movl %eax, %r8d
movl %edx, %eax
movl 0x8ad4(%rip), %r11d     # 0xb194
cltd
idivl %r11d
movl %eax, %edx
testl %r8d, %r8d
jle 0x26dc
imull %r8d, %r10d
movl %r8d, %eax
movl -0x4(%r9,%rax,4), %eax
jmp 0x26e1
xorl %eax, %eax
retq
xorl %r10d, %r10d
xorl %eax, %eax
testl %edx, %edx
jle 0x2700
imull %edx, %r11d
addl %r11d, %r10d
imull 0x8d30(%rip), %r8d      # 0xb424
addl %edx, %r8d
movslq %r8d, %rdx
movzwl (%rcx,%rdx,2), %ecx
addl %ecx, %eax
movl %edi, %edx
subl %r10d, %edx
jle 0x273f
leaq 0x9d72(%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 0x2740
shll $0x5, %r8d
addl 0x1c(%r8,%rcx), %eax
addl $0x8, %r10d
addl $-0x8, %edx
cmpl %edi, %r10d
jl 0x270e
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_O1/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 0x2b7d
movl %r8d, %r10d
movl %r9d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2b94
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x72cc
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %r10d
leaq -0x1(%rdx), %r13
xorl %r12d, %r12d
xorl %ebp, %ebp
movslq %r14d, %rcx
leaq (%rdx,%rcx), %rsi
movq $-0x1, %r8
movl $0x1, %edi
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addl $0x2, %eax
cmpb $0x1, 0x1(%rsi,%r8)
movq %rdi, %r9
leaq 0x1(%r8), %r8
leaq 0x1(%rdi), %rdi
jne 0x2bb5
addq %r13, %rcx
movl %eax, %esi
addq $0x2, %rsi
xorl %eax, %eax
movzbl (%rcx,%r9), %edi
leal (%rdi,%rax,2), %eax
incq %r9
cmpq %r9, %rsi
jne 0x2bd6
testl %eax, %eax
je 0x2bf7
cmpl $0x1, %eax
jne 0x2bff
movl $0x1, %r15d
jmp 0x2c2f
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x2c2f
movl $0x2, %ecx
movl $0x1, %r15d
movl $0x1, %esi
movl %esi, %edi
addl $0x2, %r15d
cmpl $0x1e, %esi
ja 0x2c23
addl %ecx, %ecx
leal 0x1(%rdi), %esi
cmpl %eax, %ecx
jbe 0x2c0f
cmpl $0x1f, %edi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmovael %ecx, %r15d
testl %r12d, %r12d
je 0x2c43
cmpl %ebp, %r12d
jge 0x2c52
movl 0x8(%rsp), %ecx
addl %eax, %ecx
decl %ecx
jmp 0x2c5a
cmpl $0x1, %eax
movl $0xffff, %ecx           # imm = 0xFFFF
cmovel %ecx, %eax
movl %eax, %ebp
jmp 0x2c8b
movl 0x8(%rsp), %ecx
subl %eax, %ecx
incl %ecx
movl %ecx, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2c74
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2c8b
movq %rbx, %rdi
leaq 0x8(%rsp), %rdx
callq 0x72cc
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %r10d
addl %r15d, %r14d
cmpl %r10d, %r14d
jge 0x2ca3
incl %r12d
cmpl $0x3e8, %r12d           # imm = 0x3E8
jne 0x2b9d
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_O1/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 0x87df(%rip), %r14      # 0xb4b0
movq 0x8770(%rip), %r15      # 0xb448
movq 0x8751(%rip), %r12      # 0xb430
leal 0x1(%rbx), %ecx
movl 0x84db(%rip), %r8d      # 0xb1c4
movl 0x84c4(%rip), %r9d      # 0xb1b4
movl 0x84c2(%rip), %eax      # 0xb1b8
movl %eax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x293a
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x269a
testl %ebx, %ebx
js 0x2d53
addl %ebx, %ebx
leal (%rbx,%rbx,2), %edx
leal (%rbx,%rbx,2), %edi
addl $0x6, %edi
movl 0x84f8(%rip), %esi      # 0xb224
movq 0x8765(%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 0x2d38
movl %esi, 0x84d3(%rip)      # 0xb224
jmp 0x2d55
xorl %ecx, %ecx
shll $0x6, %eax
addl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_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 0x8733(%rip), %r14      # 0xb4a8
movq 0x86d4(%rip), %r15      # 0xb450
movq 0x86b5(%rip), %r12      # 0xb438
leal 0x1(%rdi), %ecx
movl 0x8433(%rip), %r8d      # 0xb1c0
movl 0x8418(%rip), %r9d      # 0xb1ac
movl 0x8416(%rip), %eax      # 0xb1b0
movl %eax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x293a
movl %eax, %ebx
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x269a
movl 0x83c9(%rip), %edx      # 0xb18c
leaq 0x8566(%rip), %rcx      # 0xb330
leaq (%rcx,%rdx,4), %rcx
leaq 0x85ab(%rip), %rsi      # 0xb380
cmpl $0x2, %edx
jl 0x2ded
leaq -0x1(%rdx), %rdi
addq $-0x4, %rcx
cmpl -0x4(%rsi,%rdx,4), %ebx
movq %rdi, %rdx
jl 0x2dd5
subl (%rcx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_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 0x2cc0
movl %eax, %ebp
leal 0x1(%rbx), %edi
callq 0x2cc0
movl %eax, %r15d
movl %ebx, %edi
callq 0x2d66
movq 0x8637(%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 0x2b40
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33c2
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 %ebx, %ebx
xorl %ebp, %ebp
xorl %r15d, %r15d
xorl %r14d, %r14d
movb (%rdi,%rdx), %r12b
cmpb (%rsi,%rdx), %r12b
jne 0x33d3
testl %r15d, %r15d
sete %r15b
andb %r15b, %r12b
movzbl %r12b, %r12d
addl %r12d, %ebp
cmpb %r12b, %r15b
je 0x337c
incl %ebp
xorl %r15d, %r15d
jmp 0x33ba
movl $0x1, %r15d
decl %ebp
jne 0x33ba
incl %ebx
cmpl %r11d, %ebx
jge 0x33c2
xorl %ebp, %ebp
cmpl %r9d, %ebx
sete %bpl
leal 0x2(%r14), %r15d
cmpl %eax, %ebx
cmovnel %r14d, %r15d
movl %ebp, %r14d
addl %r15d, %r14d
cmpl $0x1, %r14d
je 0x33f3
xorl %r15d, %r15d
movl $0x0, %ebp
cmpl $0x2, %r14d
je 0x33f7
incq %rdx
cmpq %rdx, %rcx
jne 0x3355
xorl %eax, %eax
cmpl %r8d, %r10d
jl 0x33ea
setle %al
movzbl %al, %eax
incl %eax
jmp 0x33ea
cmpl $0x1, %r15d
setne %al
cmpl $0x3, %r14d
sete %cl
xorb %al, %cl
xorb %cl, %r12b
movzbl %r12b, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x33ea
decl %r10d
xorl %eax, %eax
cmpl %edx, %r10d
setne %al
jmp 0x33ea
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3c17
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 0x3bf4
incq %r11
cmpq %r11, %r9
jne 0x3bdf
movq %r9, %r11
movl %r11d, %ebx
cmpq %r9, %rbx
jne 0x3c00
movl %r11d, (%rcx,%r8,4)
incq %r9
decl %r10d
cmpq %r8, %r9
jne 0x3bd5
incq %r8
incl %eax
cmpq %rdx, %r8
jne 0x3bc4
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x41b7
leal -0x1(%r14), %eax
leaq 0x712d(%rip), %rcx      # 0xb2e0
movl (%rcx,%rax,4), %r12d
movslq %ebx, %rax
leaq (%rax,%rax,4), %r13
leaq 0xa2eb(%rip), %r15      # 0xe4b0
movl (%r15,%r13,8), %esi
testl %esi, %esi
js 0x4229
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x2e23
leaq (%r15,%r13,8), %rax
movq 0x8(%rsp), %rcx
addl -0x4(%rcx), %r12d
movl %r12d, (%rax)
cmpl $0x2, %ebp
jl 0x4213
decl %r14d
decl %ebp
movq 0x20(%rsp), %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x418b
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4229
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 0x4251
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4285
leal -0x1(%r14), %eax
leaq 0x705f(%rip), %rcx      # 0xb2e0
movl (%rcx,%rax,4), %r12d
movslq %ebx, %rax
leaq (%rax,%rax,4), %r13
leaq 0xa21d(%rip), %r15      # 0xe4b0
movl 0x4(%r15,%r13,8), %esi
testl %esi, %esi
js 0x430e
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x2e23
leaq (%r15,%r13,8), %rax
movq 0x8(%rsp), %rdx
movl -0x4(%rdx), %ecx
addl %r12d, %ecx
cmpl $0x2, %ebp
jge 0x42df
movq (%rsp), %rsi
subq %rsi, %rdx
addl -0x8(%rsi,%rdx), %r12d
movl %ecx, 0x4(%rax)
movl %r12d, (%rax)
jmp 0x42f8
movl %ecx, 0x4(%rax)
decl %r14d
decl %ebp
movq 0x20(%rsp), %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x4259
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x430e
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 0x4321
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x433a
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x0, 0x6903(%rip)      # 0xb1a0
jle 0x4931
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
leaq 0x6a27(%rip), %r15      # 0xb2e0
leaq 0x3956(%rip), %r14      # 0x8216
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x6b5b(%rip), %rax      # 0xb428
movslq 0x68b8(%rip), %rcx      # 0xb18c
movl %ebp, %edx
subl -0x4(%r15,%rcx,4), %edx
cmpl %edx, (%rax,%r12,4)
jne 0x48f5
leal (%rbx,%r13), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2030
incl 0x6b23(%rip)            # 0xb418
movq 0x6b2c(%rip), %rax      # 0xb428
movslq 0x6889(%rip), %rcx      # 0xb18c
movl -0x4(%r15,%rcx,4), %edi
addl (%rax,%r12,4), %edi
callq 0x3b6f
addl %eax, %r13d
incq %r12
movslq 0x6882(%rip), %rax      # 0xb1a0
cmpq %rax, %r12
jl 0x48c6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_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
movl %edi, %ebp
cmpl %esi, 0x6844(%rip)      # 0xb18c
jne 0x4961
movl %ebp, %edi
movl %edx, %esi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4896
movl %esi, %r14d
movq %rdx, 0x30(%rsp)
xorl %r13d, %r13d
leaq 0x696d(%rip), %rcx      # 0xb2e0
cmpl $0x2, %esi
jl 0x4980
leal -0x1(%r14), %eax
movl (%rcx,%rax,4), %r13d
movslq %r14d, %rax
movl (%rcx,%rax,4), %r12d
movq %rax, 0x8(%rsp)
cmpl 0x4(%rcx,%rax,4), %r12d
jge 0x4a4e
incq 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
movl %r12d, %esi
callq 0x2e23
movq 0x10(%rsp), %rdi
cmpq %rdi, 0x18(%rsp)
je 0x4a23
xorl %ebx, %ebx
xorl %r15d, %r15d
movl (%rdi,%rbx,4), %eax
addl %r13d, %eax
cmpl %ebp, %eax
jne 0x49eb
movq 0x30(%rsp), %rax
leal (%r15,%rax), %edx
movl %r12d, %edi
movq 0x8(%rsp), %rsi
callq 0x4932
testl %r14d, %r14d
jle 0x4a02
movq 0x10(%rsp), %rax
movl (%rax,%rbx,4), %edi
addl %r13d, %edi
callq 0x3b6f
jmp 0x4a07
movl $0x1, %eax
addl %eax, %r15d
incq %rbx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
subq %rdi, %rax
sarq $0x2, %rax
cmpq %rbx, %rax
ja 0x49cb
testq %rdi, %rdi
je 0x4a35
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
incl %r12d
leaq 0x68a1(%rip), %rax      # 0xb2e0
movq 0x8(%rsp), %rcx
cmpl (%rax,%rcx,4), %r12d
jl 0x499c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4a5f
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4a79
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2220