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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
je 0x27a2
movq %rdi, %rbx
leaq 0x1ace(%rip), %rsi      # 0x4235
xorl %edx, %edx
callq 0x20c0
movq %rax, %rdx
shlq $0x20, %rdx
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
cmpq %rcx, %rdx
sete %cl
testl %eax, %eax
sete %al
orb %cl, %al
jne 0x27a2
sarq $0x20, %rdx
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2030
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
cmpq $0x0, 0x8(%rdi)
je 0x27f8
movq %rdi, %rbx
leaq 0x1a74(%rip), %rsi      # 0x4235
pushq $-0x1
popq %rdx
callq 0x21d0
movq %rax, %r14
movq 0x3805(%rip), %rdi      # 0x5fd8
leaq 0x182a(%rip), %rsi      # 0x4004
callq 0x2110
movq %rax, %rdi
movl %r14d, %esi
callq 0x21b0
movq %rax, %rdi
callq 0x2090
cmpl $-0x1, %r14d
jne 0x27fd
popq %rbx
popq %r14
popq %rbp
retq
incl %r14d
movslq %r14d, %rsi
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2030
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0xa8, %rsp
movq 0x37a2(%rip), %rdi      # 0x5fd8
leaq 0x17d0(%rip), %rsi      # 0x400d
callq 0x2110
movq %rax, %rdi
callq 0x2090
leaq 0x17e4(%rip), %rsi      # 0x4035
leaq -0xa0(%rbp), %rbx
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2060
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq -0x80(%rbp), %rdi
movq %rbx, %rsi
callq 0x2160
leaq 0x19af(%rip), %rsi      # 0x4235
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x2060
leaq -0xb8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x2594
leaq -0x40(%rbp), %rbx
leaq -0xb8(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x330c
movq %r14, %rdi
callq 0x31a6
leaq -0x60(%rbp), %rdi
callq 0x2080
leaq -0x80(%rbp), %rdi
callq 0x2080
movq (%rbx), %r14
movq 0x8(%rbx), %r15
movq 0x36f3(%rip), %rbx      # 0x5fd8
cmpq %r15, %r14
je 0x2903
movl (%r14), %esi
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x2090
addq $0x4, %r14
jmp 0x28e5
movq 0x36ce(%rip), %rdi      # 0x5fd8
leaq 0x1747(%rip), %rsi      # 0x4058
callq 0x2110
movq %rax, %rdi
callq 0x2090
leaq -0x40(%rbp), %rdi
callq 0x31a6
leaq -0xa0(%rbp), %rdi
callq 0x2080
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2080
jmp 0x2952
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x2080
jmp 0x2964
jmp 0x2961
jmp 0x2961
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x31a6
leaq -0xa0(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq 0x3647(%rip), %rdi      # 0x5fd8
leaq 0x16e6(%rip), %rsi      # 0x407e
callq 0x2110
movq %rax, %rdi
callq 0x2090
leaq 0x1689(%rip), %rsi      # 0x4035
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x2060
leaq 0x1695(%rip), %rsi      # 0x4055
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x2060
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2625
leaq -0x50(%rbp), %rdi
callq 0x2080
movq 0x35ee(%rip), %rdi      # 0x5fd8
leaq -0x30(%rbp), %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x2090
movq 0x35d6(%rip), %rdi      # 0x5fd8
leaq 0x169f(%rip), %rsi      # 0x40a8
callq 0x2110
movq %rax, %rdi
callq 0x2090
leaq -0x30(%rbp), %rdi
callq 0x2080
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2080
jmp 0x2a39
jmp 0x2a36
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq 0x357e(%rip), %rdi      # 0x5fd8
leaq 0x166f(%rip), %rsi      # 0x40d0
callq 0x2110
movq %rax, %rdi
callq 0x2090
leaq 0x15c0(%rip), %rsi      # 0x4035
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x2060
leaq 0x15cc(%rip), %rsi      # 0x4055
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x2060
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2684
leaq -0x50(%rbp), %rdi
callq 0x2080
movq 0x3525(%rip), %rdi      # 0x5fd8
leaq -0x30(%rbp), %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x2090
movq 0x350d(%rip), %rdi      # 0x5fd8
leaq 0x162a(%rip), %rsi      # 0x40fc
callq 0x2110
movq %rax, %rdi
callq 0x2090
leaq -0x30(%rbp), %rdi
callq 0x2080
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2080
jmp 0x2b02
jmp 0x2aff
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq 0x34b5(%rip), %rdi      # 0x5fd8
leaq 0x15fc(%rip), %rsi      # 0x4126
callq 0x2110
movq %rax, %rdi
callq 0x2090
leaq 0x14f7(%rip), %rsi      # 0x4035
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x2060
leaq 0x1503(%rip), %rsi      # 0x4055
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x2060
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x26d4
leaq -0x50(%rbp), %rdi
callq 0x2080
movq 0x345c(%rip), %rdi      # 0x5fd8
leaq -0x30(%rbp), %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x2090
movq 0x3444(%rip), %rdi      # 0x5fd8
leaq 0x15b6(%rip), %rsi      # 0x4151
callq 0x2110
movq %rax, %rdi
callq 0x2090
leaq -0x30(%rbp), %rdi
callq 0x2080
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2080
jmp 0x2bcb
jmp 0x2bc8
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq 0x33ec(%rip), %rdi      # 0x5fd8
leaq 0x1587(%rip), %rsi      # 0x417a
callq 0x2110
movq %rax, %rdi
callq 0x2090
leaq 0x159b(%rip), %rsi      # 0x41a2
leaq -0x50(%rbp), %rbx
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2750
movq 0x33b2(%rip), %rdi      # 0x5fd8
leaq 0x158b(%rip), %rsi      # 0x41b8
callq 0x2110
leaq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
callq 0x2090
leaq 0x15ee(%rip), %rsi      # 0x423b
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x2060
leaq -0x30(%rbp), %rdi
callq 0x2750
movq 0x336e(%rip), %rdi      # 0x5fd8
leaq 0x1547(%rip), %rsi      # 0x41b8
callq 0x2110
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
callq 0x2090
movq 0x3347(%rip), %rdi      # 0x5fd8
leaq 0x153b(%rip), %rsi      # 0x41d3
callq 0x2110
movq %rax, %rdi
callq 0x2090
leaq -0x30(%rbp), %rdi
callq 0x2080
leaq -0x50(%rbp), %rdi
callq 0x2080
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
jmp 0x2cc0
movq %rax, %rbx
jmp 0x2cd1
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2080
leaq -0x50(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq 0x32e6(%rip), %rdi      # 0x5fd8
leaq 0x1500(%rip), %rsi      # 0x41f9
callq 0x2110
movq %rax, %rdi
callq 0x2090
leaq 0x1515(%rip), %rsi      # 0x4222
leaq -0x50(%rbp), %rbx
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x27a9
movq 0x32ac(%rip), %rdi      # 0x5fd8
leaq 0x1485(%rip), %rsi      # 0x41b8
callq 0x2110
leaq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
callq 0x2090
leaq 0x14e4(%rip), %rsi      # 0x4237
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x2060
leaq -0x30(%rbp), %rdi
callq 0x27a9
movq 0x3268(%rip), %rdi      # 0x5fd8
leaq 0x1441(%rip), %rsi      # 0x41b8
callq 0x2110
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
callq 0x2090
movq 0x3241(%rip), %rdi      # 0x5fd8
leaq 0x14ba(%rip), %rsi      # 0x4258
callq 0x2110
movq %rax, %rdi
callq 0x2090
leaq -0x30(%rbp), %rdi
callq 0x2080
leaq -0x50(%rbp), %rdi
callq 0x2080
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
jmp 0x2dc6
movq %rax, %rbx
jmp 0x2dd7
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2080
leaq -0x50(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2bcc(%rip), %xmm2     # 0x5010
cvtss2sd %xmm2, %xmm2
movsd 0x2bd0(%rip), %xmm3     # 0x5020
ucomisd %xmm2, %xmm3
jbe 0x246c
movq 0x40(%rsi), %rax
cmpq %rax, 0x40(%rdi)
jne 0x2468
movq 0x50(%rdi), %rax
cmpq 0x50(%rsi), %rax
setl %al
retq
ucomiss %xmm1, %xmm0
seta %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x3682
testb %al, %al
je 0x24ad
movq 0x40(%rbx), %rax
cmpq %rax, 0x40(%r14)
jne 0x24a2
movq 0x50(%rbx), %rax
cmpq %rax, 0x50(%r14)
jne 0x24a2
movq 0x70(%r14), %rax
cmpq 0x70(%rbx), %rax
setl %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x36ab
// File: /workspace/github_cpp_makefile_star2_O2/Altius[P]hotspot2/src/findVarWidthPeaks.cpp
// Function: main
int main(int argc, const char* argv[])
{
  if (2 != argc)
    {
      cerr << "Usage:  [stdin] | " << argv[0] << " minWidth | [stdout],\n"
	   << "where minWidth is the minimum width (in bp) that a variable-width peak must have to be reported.\n"
	   << "6-column input is required, NOT in sort-bed order, but instead, sorted by column 6, then by column 3.\n"
	   << "The input columns are:  chr, pos-1, pos, ID, score, posSummit,\n"
	   << "where \"score\" is the score (e.g., normalized density) at site \"pos\" on chromosome \"chr\"."
	   << "Rows MUST be grouped by column 6 (i.e., sorted by posSummit);\n"
	   << "the sort order of posSummit can be anything (typicaly numeric, but alphabetic would also work).\n"
	   << "All rows with the same posSummit value (column 6) MUST be sorted in ascending order by pos (column 3).\n"
	   << "There will be 7 columns of output:\n"
	   << "chr, beg, end, ID, maxScore, posWithMaxScore, posSummit,\n"
	   << "where (beg, end] are the coordinates of each output variable-width peak (0-based),\n"
	   << "ID and posSummit echo their input values, posWithMaxScore is the central bp within (beg,end]\n"
	   << "where the maximum score was found, and maxScore is that score.\n"
	   << "**YOU MUST CALL sort-bed ON THE OUTPUT BEFORE USING IT IN bedmap/bedops OPERATIONS**."
	   << endl << endl;
      return -1;
    }

  ios_base::sync_with_stdio(false); // calling this static method in this way turns off checks, and can speed up I/O
  
  if (!parseInputFindPeaksWriteOutput(argv[0], atol(argv[1])))
    return -1;

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x2, %edi
jne 0x3577
xorl %edi, %edi
callq 0x2090
movq (%rbx), %r14
movq 0x8(%rbx), %rdi
callq 0x21d0
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x2d30
movzbl %al, %eax
decl %eax
jmp 0x367a
movq 0x4a72(%rip), %rdi      # 0x7ff0
leaq 0x1c99(%rip), %rsi      # 0x521e
callq 0x2190
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x2190
leaq 0x1c95(%rip), %rsi      # 0x5231
movq %rax, %rdi
callq 0x2190
leaq 0x1c9d(%rip), %rsi      # 0x5248
movq %rax, %rdi
callq 0x2190
leaq 0x1cf0(%rip), %rsi      # 0x52aa
movq %rax, %rdi
callq 0x2190
leaq 0x1d48(%rip), %rsi      # 0x5311
movq %rax, %rdi
callq 0x2190
leaq 0x1d79(%rip), %rsi      # 0x5351
movq %rax, %rdi
callq 0x2190
leaq 0x1dc3(%rip), %rsi      # 0x53aa
movq %rax, %rdi
callq 0x2190
leaq 0x1df3(%rip), %rsi      # 0x53e9
movq %rax, %rdi
callq 0x2190
leaq 0x1e45(%rip), %rsi      # 0x544a
movq %rax, %rdi
callq 0x2190
leaq 0x1e9e(%rip), %rsi      # 0x54b2
movq %rax, %rdi
callq 0x2190
leaq 0x1eb3(%rip), %rsi      # 0x54d6
movq %rax, %rdi
callq 0x2190
leaq 0x1ede(%rip), %rsi      # 0x5510
movq %rax, %rdi
callq 0x2190
leaq 0x1f23(%rip), %rsi      # 0x5564
movq %rax, %rdi
callq 0x2190
leaq 0x1f72(%rip), %rsi      # 0x55c2
movq %rax, %rdi
callq 0x2190
leaq 0x1fa3(%rip), %rsi      # 0x5602
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x20d0
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2090
movslq %eax, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x20d0
testl %eax, %eax
jne 0x2687
movq %rbx, %rdi
callq 0x2090
movb $0x0, -0x1(%rbx,%rax)
leaq (%rbx,%r14), %rax
addq $0x2, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x29f9(%rip), %rdi      # 0x5087
leaq 0x2999(%rip), %rsi      # 0x502e
leaq 0x2a10(%rip), %rcx      # 0x50ac
pushq $0x5b
popq %rdx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3ab6
testq %rax, %rax
je 0x29fe
movl 0x28(%rax), %ebp
jmp 0x2a1a
movl 0x18(%r15), %ebp
movq %r15, %rdi
movq %r14, %rsi
callq 0x3bd2
movl %ebp, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33fe
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3da4
popq %rax
popq %rcx
addq $0x38, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x2250
movq %r12, %rdi
callq 0x2110
leaq 0x8(%rsp), %rdi
pushq $0x15
popq %rdx
movq %r15, %rsi
callq 0x2330
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x21f0
leaq 0x8(%rsp), %rdi
callq 0x2040
testb %bpl, %bpl
je 0x3c43
movq 0x439c(%rip), %rdi      # 0x7fd0
movq %rbx, %rsi
callq 0x21f0
movl $0x3c0, %esi            # imm = 0x3C0
jmp 0x3c57
movq 0x4386(%rip), %rdi      # 0x7fd0
movq %rbx, %rsi
callq 0x21f0
movl $0x3a0, %esi            # imm = 0x3A0
addq (%r13), %rsi
movq %rax, %rdi
callq 0x21f0
leaq 0x8(%rsp), %rdi
callq 0x2060
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 0x2060
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14d
cmpl $0x0, 0x8064(%rip)      # 0xa428
jne 0x23d4
leaq 0x4cbb(%rip), %rdi      # 0x7088
xorl %eax, %eax
callq 0x2030
movq 0x7e35(%rip), %rdi      # 0xa210
leaq 0x4cb9(%rip), %rsi      # 0x709b
callq 0x21a0
testq %rax, %rax
je 0x245b
movq %rax, %r15
xorl %r12d, %r12d
testl %r14d, %r14d
cmovlel %r12d, %r14d
cmpq $0x3e7, %r12            # imm = 0x3E7
ja 0x244b
movslq 0x801f(%rip), %rax      # 0xa428
cmpq %rax, %r12
jge 0x244b
leaq 0x80cb(%rip), %rax      # 0xa4e0
movl (%rax,%r12,4), %ebp
movslq %ebp, %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x2190
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x2446
movq %r15, %rdi
callq 0x2220
movl (%rbx,%r13,4), %esi
movzbl %al, %edx
incq %r13
cmpl %edx, %esi
je 0x2429
jmp 0x2482
incq %r12
jmp 0x23f9
leaq 0x4f7e(%rip), %rdi      # 0x73d0
callq 0x2210
xorl %eax, %eax
jmp 0x2473
movq 0x7dae(%rip), %rsi      # 0xa210
leaq 0x4c34(%rip), %rdi      # 0x709d
xorl %eax, %eax
callq 0x2030
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4c31(%rip), %rdi      # 0x70ba
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2030
pushq $0x1
popq %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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:
testl %edi, %edi
je 0x24bc
pushq $0x1
popq %rcx
pushq $0x2
popq %rax
cmpl $0x1f, %ecx
ja 0x24b3
cmpl %edi, %eax
ja 0x24b3
addl %eax, %eax
incl %ecx
jmp 0x24a4
xorl %eax, %eax
cmpl $0x20, %ecx
cmovbl %ecx, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/TooruAkagi[P]GCIS_Index/gcis_uni_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 0x25a0
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
callq 0x249a
movslq 0x7d23(%rip), %rdx      # 0xa290
leal 0x1(%rdx), %ecx
addq %rbx, %rdx
xorl %esi, %esi
leal 0x1(%rsi), %edi
cmpl %eax, %edi
jge 0x258e
movb $0x0, (%rdx,%rsi)
leal (%rcx,%rsi), %edi
movl %edi, 0x7d07(%rip)      # 0xa290
incq %rsi
jmp 0x2575
movl %ebp, %edi
movl %eax, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x24f2
leaq 0x4b24(%rip), %rdi      # 0x70cb
xorl %esi, %esi
xorl %eax, %eax
jmp 0x2030
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rcx, %rbx
movl %edx, %r14d
andl $0x0, 0x7ccb(%rip)      # 0xa290
movslq %esi, %rax
xorl %r15d, %r15d
testl %edx, %edx
cmovlel %r15d, %r14d
leaq (%rdi,%rax,4), %r12
xorl %ebp, %ebp
cmpq %r15, %r14
je 0x260d
testq %r15, %r15
je 0x2608
movl (%r12,%r15,4), %eax
subl -0x4(%r12,%r15,4), %eax
testl %ebp, %ebp
movl %r15d, %ecx
cmovnel %ebp, %ecx
testl %eax, %eax
cmovsl %ecx, %ebp
movl %eax, %edi
negl %edi
cmovsl %eax, %edi
incl %edi
movq %rbx, %rsi
callq 0x2555
incq %r15
jmp 0x25d7
cmpl $0x2, %ebp
pushq $0x1
popq %rax
cmovgel %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: gread(int, bool*)
int gread(int p,bool *ar){
    //配列kの位置pからガンマ符号化でどのようなもじが存在するのかを読み解く
    int i = 0;
    while(1){
        if(ar[p+i]==1){break;}
        i++;
    }
    int u = i;
    int a = 0;
    while(u>=0){
        a*=2;
        a+=ar[p+i];
        i++;u--;
    }
    return a;
}

// Assembly:
movslq %edi, %rax
leaq (%rsi,%rax), %rdx
pushq $-0x2
popq %rdi
xorl %ecx, %ecx
addl $0x2, %edi
cmpb $0x1, (%rdx,%rcx)
leaq 0x1(%rcx), %rcx
jne 0x262b
leaq (%rax,%rsi), %rdx
decq %rdx
movl %edi, %esi
addq $0x2, %rsi
xorl %eax, %eax
cmpq %rcx, %rsi
je 0x2658
movzbl (%rdx,%rcx), %edi
leal (%rdi,%rax,2), %eax
incq %rcx
jmp 0x2647
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2696
movq %rdx, %r8
incl 0x7e6e(%rip)            # 0xa4d4
movl 0x7b33(%rip), %r9d      # 0xa1a0
movl %edi, %eax
cltd
idivl %r9d
movl %eax, %r10d
movl %edx, %eax
movl 0x7b25(%rip), %r11d     # 0xa1a4
cltd
idivl %r11d
testl %r10d, %r10d
jle 0x269b
imull %r10d, %r9d
movl %r10d, %edx
movl -0x4(%r8,%rdx,4), %r8d
jmp 0x26a1
xorl %r8d, %r8d
jmp 0x270c
xorl %r9d, %r9d
xorl %r8d, %r8d
testl %eax, %eax
jle 0x26c1
imull %eax, %r11d
addl %r11d, %r9d
imull 0x7d80(%rip), %r10d     # 0xa434
addl %eax, %r10d
movslq %r10d, %rax
movzwl (%rcx,%rax,2), %eax
addl %eax, %r8d
movl %edi, %r10d
subl %r9d, %r10d
pushq $0x8
popq %r11
leaq 0x8dbe(%rip), %rcx      # 0xb490
cmpl %edi, %r9d
jge 0x270c
movl %r9d, %eax
cltd
idivl %r11d
cltq
movzbl (%rsi,%rax), %eax
cmpl $0x9, %r10d
jl 0x26fc
shll $0x5, %eax
addl 0x1c(%rax,%rcx), %r8d
addl $0x8, %r9d
addl $-0x8, %r10d
jmp 0x26d2
decl %r10d
movslq %r10d, %rdx
shll $0x5, %eax
addq %rax, %rcx
addl (%rcx,%rdx,4), %r8d
movl %r8d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r8d, 0xc(%rsp)
movl %ecx, %r14d
movq %rdx, %r15
leaq 0x8(%rsp), %rsi
movl %r9d, (%rsi)
movq %rdi, 0x10(%rsp)
callq 0x6c24
xorl %ebp, %ebp
xorl %ebx, %ebx
cmpl $0x3e8, %ebx            # imm = 0x3E8
je 0x2ac6
movl %r14d, %edi
movq %r15, %rsi
callq 0x261f
movl %eax, %r12d
movl %eax, %edi
callq 0x249a
movl %eax, %r13d
testl %ebx, %ebx
je 0x2a88
cmpl %ebp, %ebx
jge 0x2a9a
movl 0x8(%rsp), %eax
addl %r12d, %eax
decl %eax
jmp 0x2aa3
cmpl $0x1, %r12d
movl $0xffff, %eax           # imm = 0xFFFF
cmovel %eax, %r12d
movl %r12d, %ebp
jmp 0x2ab6
movl 0x8(%rsp), %eax
subl %r12d, %eax
incl %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6c24
leal (%r14,%r13,2), %r14d
decl %r14d
incl %ebx
cmpl 0xc(%rsp), %r14d
jl 0x2a55
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %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_O2/TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: getd2(int)
int getd2(int tgm){
    int tgm2 = selectnew0(d2topx,d2topsub,d2topsub2,tgm+1,Sizelist[9],Sizelist[5],Sizelist[6]); //tgm2 = その位置までの1の数を見る．
    int tgm3 = sranknew1(tgm2,d2topx,d2topsub,d2topsub2,Sizelist[5],Sizelist[6]);
    int tgm4 = bread(d2under,tgm*6,6);
    return tgm3*64+tgm4;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movq 0x79c3(%rip), %r14      # 0xa4c0
movq 0x7954(%rip), %r15      # 0xa458
movq 0x7935(%rip), %r12      # 0xa440
leal 0x1(%rbx), %ecx
movl 0x76bf(%rip), %r8d      # 0xa1d4
movl 0x76a8(%rip), %r9d      # 0xa1c4
movl 0x76a6(%rip), %eax      # 0xa1c8
movl %eax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2880
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x2659
movl %eax, %ebp
movq 0x795c(%rip), %rdi      # 0xa4a8
imull $0x6, %ebx, %esi
pushq $0x6
popq %rdx
callq 0x24bf
shll $0x6, %ebp
addl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/TooruAkagi[P]GCIS_Index/gcis_uni_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 0x7940(%rip), %r14      # 0xa4b8
movq 0x78e1(%rip), %r15      # 0xa460
movq 0x78c2(%rip), %r12      # 0xa448
leal 0x1(%rdi), %ecx
movl 0x7640(%rip), %r8d      # 0xa1d0
movl 0x7625(%rip), %r9d      # 0xa1bc
movl 0x7623(%rip), %eax      # 0xa1c0
movl %eax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2880
movl %eax, %ebx
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x2659
movl 0x75d6(%rip), %edx      # 0xa19c
leaq 0x7773(%rip), %rcx      # 0xa340
leaq (%rcx,%rdx,4), %rcx
leaq 0x77b8(%rip), %rsi      # 0xa390
cmpl $0x2, %edx
jl 0x2bf0
leaq -0x1(%rdx), %rdi
addq $-0x4, %rcx
cmpl -0x4(%rsi,%rdx,4), %ebx
movq %rdi, %rdx
jl 0x2bd8
subl (%rcx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/TooruAkagi[P]GCIS_Index/gcis_uni_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 0x2ae8
movl %eax, %ebp
leal 0x1(%rbx), %edi
callq 0x2ae8
movl %eax, %r15d
movl %ebx, %edi
callq 0x2b69
movq 0x7844(%rip), %rdx      # 0xa498
movq %r14, %rdi
movl %ebp, %ecx
movl %r15d, %r8d
movl %eax, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2a26
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movl 0x48(%rsp), %r10d
movl 0x40(%rsp), %eax
movl 0x38(%rsp), %r11d
cmpl %r8d, %r10d
movl %r8d, %ebx
cmovll %r10d, %ebx
movslq %ecx, %r14
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
movslq %edx, %rdx
addq %rdi, %rdx
addq %rsi, %r14
movl $0x1, %edi
xorl %esi, %esi
xorl %r12d, %r12d
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpq %rcx, %rbx
je 0x314c
movb (%rdx,%rcx), %r13b
cmpb (%r14,%rcx), %r13b
jne 0x315d
testl %r12d, %r12d
sete %r12b
andb %r12b, %r13b
movzbl %r13b, %r13d
addl %r13d, %r15d
cmpb %r13b, %r12b
je 0x3109
incl %r15d
xorl %r12d, %r12d
jmp 0x3147
decl %r15d
je 0x3113
movl %edi, %r12d
jmp 0x3147
incl %ebp
cmpl %r11d, %ebp
jge 0x314c
xorl %r15d, %r15d
cmpl %r9d, %ebp
sete %r15b
leal 0x2(%rsi), %r12d
cmpl %eax, %ebp
cmovnel %esi, %r12d
movl %r15d, %esi
addl %r12d, %esi
cmpl $0x1, %esi
je 0x3180
xorl %r12d, %r12d
movl $0x0, %r15d
cmpl $0x2, %esi
je 0x3184
incq %rcx
jmp 0x30dc
xorl %eax, %eax
cmpl %r8d, %r10d
jl 0x318f
setle %al
movzbl %al, %eax
incl %eax
jmp 0x318f
cmpl $0x1, %r12d
setne %cl
movl %r13d, %eax
xorb %cl, %al
movzbl %al, %eax
cmpl $0x3, %esi
jne 0x318f
decl %eax
cmpb %cl, %r13b
movl $0x1, %ecx
cmovel %ecx, %eax
jmp 0x318f
xorl %eax, %eax
jmp 0x318f
decl %r10d
xorl %eax, %eax
cmpl %ecx, %r10d
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: mkkmpc(int*, int, int, int*)
void mkkmpc(int *m,int startm,int mrlen,int *kmpc){
    //2文字一致の時 [0]と[1]が一緒なら，次は1文字進めて1文字一致してる前提で進める
    //3文字一致の時 [0]と[2]が一緒なら，次は2文字進めて1文字一致してる前提で進める
    //            [0-1]と[1-2]が一緒なら，次は1文字進めて2文字一致してる前提で進める．
    for(int i2 = 2;i2<mrlen;i2++){ //i2文字一緒の時
        kmpc[i2] = 0;
        for(int i3 = 1; i3 <i2;i3++){
            int i4 = 0;
            while(i4<i3){
                if(m[startm+i4]==m[startm+(i2-i3)+i4]){
                    i4++;
                    //printf("[%d==%d]",i4,i2-i3+i4);
                }
                else{break;}
            }
            if(i4==i3){kmpc[i2]=i4;}
        }
    }
    
    return;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movslq %esi, %rax
movslq %edx, %rdx
leaq (%rdi,%rax,4), %rsi
incl %eax
movabsq $0x2, %r8
movabsq $0x1, %r9
cmpq %rdx, %r8
jge 0x3820
andl $0x0, (%rcx,%r8,4)
movl %eax, %r10d
movq %r9, %r11
cmpq %r8, %r11
je 0x3819
movslq %r10d, %rbx
leaq (%rdi,%rbx,4), %r14
xorl %ebx, %ebx
cmpq %rbx, %r11
je 0x3802
movl (%rsi,%rbx,4), %ebp
cmpl (%r14,%rbx,4), %ebp
jne 0x3805
incq %rbx
jmp 0x37ef
movl %r11d, %ebx
movl %ebx, %r14d
cmpq %r14, %r11
jne 0x3811
movl %ebx, (%rcx,%r8,4)
incq %r11
decl %r10d
jmp 0x37e1
incq %r8
incl %eax
jmp 0x37d1
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3d51
leal -0x1(%r14), %eax
leaq 0x65a3(%rip), %rcx      # 0xa2f0
movl (%rcx,%rax,4), %r12d
movslq %ebx, %rax
imulq $0x28, %rax, %r15
leaq 0x9761(%rip), %r13      # 0xd4c0
movl (%r15,%r13), %esi
testl %esi, %esi
js 0x3db6
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x2c26
addq %r15, %r13
movq 0x18(%rsp), %rax
addl -0x4(%rax), %r12d
movl %r12d, (%r13)
cmpl $0x2, %ebp
jl 0x3dac
decl %r14d
decl %ebp
movq 0x8(%rsp), %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x3d25
leaq 0x10(%rsp), %rdi
callq 0x6e42
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6e42
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/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 %edx, %ebp
movl %esi, %r14d
xorl %r12d, %r12d
cmpl $0x2, %esi
jl 0x3e04
leal -0x1(%r14), %eax
leaq 0x64f0(%rip), %rdx      # 0xa2f0
movl (%rdx,%rax,4), %r12d
movslq %ecx, %rax
imulq $0x28, %rax, %r15
leaq 0x96ae(%rip), %r13      # 0xd4c0
movl 0x4(%r15,%r13), %esi
testl %esi, %esi
js 0x3e85
movl %ecx, 0xc(%rsp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x2c26
addq %r15, %r13
movq 0x18(%rsp), %rcx
movl -0x4(%rcx), %eax
addl %r12d, %eax
cmpl $0x2, %ebp
jge 0x3e61
movq 0x10(%rsp), %rdx
subq %rdx, %rcx
addl -0x8(%rdx,%rcx), %r12d
movl %eax, 0x4(%r13)
movl %r12d, (%r13)
jmp 0x3e7b
movl %eax, 0x4(%r13)
decl %r14d
decl %ebp
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
movl 0xc(%rsp), %ecx
callq 0x3dda
leaq 0x10(%rsp), %rdi
callq 0x6e42
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3e98
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6e42
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl 0x5df3(%rip), %r14d     # 0xa1b0
leaq 0x5f2c(%rip), %r15      # 0xa2f0
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq %r14d, %rax
cmpq %rax, %r12
jge 0x4434
movq 0x605f(%rip), %rax      # 0xa438
movl (%rax,%r12,4), %edi
movslq 0x5db8(%rip), %rax      # 0xa19c
movl %ebp, %ecx
subl -0x4(%r15,%rax,4), %ecx
cmpl %ecx, %edi
jne 0x4420
leal (%rbx,%r13), %esi
leaq 0x2e4c(%rip), %rdi      # 0x7246
xorl %eax, %eax
callq 0x2030
incl 0x6021(%rip)            # 0xa428
movl 0x5da2(%rip), %r14d     # 0xa1b0
movq 0x6023(%rip), %rax      # 0xa438
movl (%rax,%r12,4), %edi
movslq 0x5d7c(%rip), %rax      # 0xa19c
decq %rax
addl (%r15,%rax,4), %edi
callq 0x3770
addl %eax, %r13d
incq %r12
jmp 0x43ca
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/TooruAkagi[P]GCIS_Index/gcis_uni_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, 0x5d43(%rip)      # 0xa19c
jne 0x4472
movl %ebp, %edi
movl %edx, %esi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x43a7
movl %esi, %r14d
movq %rdx, 0x30(%rsp)
xorl %r13d, %r13d
leaq 0x5e6c(%rip), %rcx      # 0xa2f0
cmpl $0x2, %esi
jl 0x4491
leal -0x1(%r14), %eax
movl (%rcx,%rax,4), %r13d
movslq %r14d, %rax
movl (%rcx,%rax,4), %r15d
leal 0x1(%r14), %eax
movl %eax, 0xc(%rsp)
cltq
movq %rax, 0x28(%rsp)
leaq 0x10(%rsp), %rbx
movq 0x28(%rsp), %rax
cmpl (%rcx,%rax,4), %r15d
jge 0x454c
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2c26
xorl %r12d, %r12d
xorl %ebx, %ebx
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x4530
movl (%rax,%r12,4), %eax
addl %r13d, %eax
cmpl %ebp, %eax
jne 0x450e
movq 0x30(%rsp), %rax
leal (%rbx,%rax), %edx
movl %r15d, %edi
movl 0xc(%rsp), %esi
callq 0x4443
pushq $0x1
popq %rax
testl %r14d, %r14d
jle 0x4527
movq 0x10(%rsp), %rax
movl (%rax,%r12,4), %edi
addl %r13d, %edi
callq 0x3770
addl %ebx, %eax
incq %r12
movl %eax, %ebx
jmp 0x44d9
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x6e42
incl %r15d
leaq 0x5da9(%rip), %rcx      # 0xa2f0
jmp 0x44ac
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x455d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6e42
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4b2c(%rip), %rsi      # 0xa210
movq %rsp, %r14
pushq $0x2
popq %rdx
movq %r14, %rdi
callq 0x6c42
movq %r14, %rdi
callq 0x21e0
movq %rax, %r14
movq %rsp, %rdi
callq 0x6cae
movq 0x4b04(%rip), %rdi      # 0xa210
leaq 0x1988(%rip), %rsi      # 0x709b
callq 0x21a0
testq %rax, %rax
je 0x5785
movq %rax, %r15
movslq 0x4a3d(%rip), %rcx      # 0xa164
movq %r14, %rax
cqto
idivq %rcx
movq %rax, %r14
imull %r14d, %ebp
movslq %ebp, %rsi
xorl %r12d, %r12d
movq %r15, %rdi
xorl %edx, %edx
callq 0x2190
testl %r14d, %r14d
movl $0x0, %r13d
cmovgl %r14d, %r13d
cmpq %r12, %r13
je 0x577b
movq %r15, %rdi
callq 0x2220
movzbl %al, %eax
movl %eax, (%rbx,%r12,4)
cmpl $0xa, %eax
jne 0x5776
movl $0x1, 0x4d5a(%rip)      # 0xa4d0
incq %r12
jmp 0x5753
pushq $0x5d
popq %rdi
callq 0x21f0
jmp 0x579e
movq 0x4a84(%rip), %rsi      # 0xa210
leaq 0x190a(%rip), %rdi      # 0x709d
xorl %eax, %eax
callq 0x2030
pushq $-0x1
popq %r14
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 0x6cae
movq %rbx, %rdi
callq 0x2240