LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/mikeakohn[P]drumsplusplus/build/../src/Song.cxx
// Function: Song::print()
void Song::print()
{
  printf("Defines:\n");

  for (auto it = defines.begin(); it != defines.end(); it++)
  {
    printf("  %s = %s\n", it->first.c_str(), it->second.c_str());
  }

  printf("Patterns:\n");

  for (auto it = pattern_names.begin(); it != pattern_names.end(); it++)
  {
    printf("  %d) %s\n", it->first, it->second.c_str());
  }

  const int count = pattern_names.size();

  for (int n = 0; n < count; n++)
  {
    std::string &pattern_name = pattern_names[n];

    patterns[pattern_name].print();
  }

  printf("Sections:\n");

  for (auto it = sections.begin(); it != sections.end(); it++)
  {
    printf("  name: %s\n", it->first.c_str());
    it->second.print();
  }

  printf("song_name=%s\n", song_info.get_song_name());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x3095(%rip), %rdi      # 0x794f
callq 0x22e0
movq 0xc0(%rbx), %r15
leaq 0xb0(%rbx), %r12
leaq 0x2a89(%rip), %r14      # 0x735d
cmpq %r12, %r15
je 0x48f8
movq 0x20(%r15), %rsi
movq 0x40(%r15), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
movq %r15, %rdi
callq 0x2120
movq %rax, %r15
jmp 0x48d4
leaq 0x3059(%rip), %rdi      # 0x7958
callq 0x22e0
movq 0xf0(%rbx), %r15
leaq 0xe0(%rbx), %r12
leaq 0x2a4f(%rip), %r14      # 0x7368
cmpq %r12, %r15
je 0x493d
movl 0x20(%r15), %esi
movq 0x28(%r15), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
movq %r15, %rdi
callq 0x2120
movq %rax, %r15
jmp 0x4919
leaq 0xd8(%rbx), %r14
movl 0x100(%rbx), %ebp
leaq 0x78(%rbx), %r15
xorl %eax, %eax
leaq 0xc(%rsp), %r12
movl %eax, 0xc(%rsp)
cmpl %ebp, %eax
jge 0x4983
movq %r14, %rdi
movq %r12, %rsi
callq 0x4fc8
movq %r15, %rdi
movq %rax, %rsi
callq 0x5016
movq %rax, %rdi
callq 0x309c
movl 0xc(%rsp), %eax
incl %eax
jmp 0x4955
leaq 0x2fd8(%rip), %rdi      # 0x7962
callq 0x22e0
movq 0x60(%rbx), %r15
leaq 0x50(%rbx), %r12
leaq 0x29d4(%rip), %r14      # 0x7372
cmpq %r12, %r15
je 0x49c7
movq 0x20(%r15), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
leaq 0x40(%r15), %rdi
callq 0x32d8
movq %r15, %rdi
callq 0x2120
movq %rax, %r15
jmp 0x499e
movq (%rbx), %rsi
leaq 0x29ad(%rip), %rdi      # 0x737e
xorl %eax, %eax
callq 0x2050
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mikeakohn[P]drumsplusplus/build/../src/Song.cxx
// Function: Song::dirname_m(char*)
char *Song::dirname_m(char *dir)
{
  int i;

  i = strlen(dir);

  while (i >= 0)
  {
    if (dir[i] == '/' || dir[i] == '\\') { break; }
    i--;
  }

  if (i < 0) { return NULL; }

  dir[i] = 0;

  return dir + i;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x20e0
movq %rax, %rcx
xorl %eax, %eax
testl %ecx, %ecx
js 0x4a37
movl %ecx, %edx
movzbl (%rbx,%rdx), %esi
cmpl $0x2f, %esi
je 0x4a2f
cmpl $0x5c, %esi
je 0x4a2f
decl %ecx
jmp 0x4a17
leaq (%rbx,%rdx), %rax
movb $0x0, (%rbx,%rdx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mikeakohn[P]drumsplusplus/build/../src/Song.cxx
// Function: Song::play_section(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int Song::play_section(std::string &section_name)
{
  if (sections.find(section_name) == sections.end())
  {
    printf("Could not find section %s\n", section_name.c_str());
    return -1;
  }

  Section &section = sections[section_name];

  if (interactive == 1)
  {
    printf("Section: %s\n", section_name.c_str());
  }

#ifdef DEBUG
printf("playing section: %s\n", section_name.c_str());
#endif

  std::vector<int> &patterns = section.get_patterns();

  for (auto it = patterns.begin(); it != patterns.end(); it++)
  {
    if (pattern_names.find(*it) == pattern_names.end())
    {
      printf("Error: Unknown pattern '%d'.\n", *it);
      return -1;
    }

    std::string &pattern_name = pattern_names[*it];

    play_pattern(pattern_name);
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
movq %r14, %rdi
callq 0x64ec
leaq 0x50(%rbx), %rcx
cmpq %rcx, %rax
je 0x4dba
movq %r14, %rdi
movq %r15, %rsi
callq 0x5184
movq %rax, %r14
cmpl $0x1, 0x128(%rbx)
jne 0x4d74
movq (%r15), %rsi
leaq 0x2b4d(%rip), %rdi      # 0x78ba
xorl %eax, %eax
callq 0x2050
movq (%r14), %r15
leaq 0xd8(%rbx), %r12
leaq 0xe0(%rbx), %r13
movq 0x8(%r14), %rbp
cmpq %rbp, %r15
je 0x4de1
movq %r12, %rdi
movq %r15, %rsi
callq 0x652a
cmpq %r13, %rax
je 0x4dd0
movq %r12, %rdi
movq %r15, %rsi
callq 0x4fc8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4dfa
addq $0x4, %r15
jmp 0x4d85
movq (%r15), %rsi
leaq 0x2adb(%rip), %rdi      # 0x789f
xorl %eax, %eax
callq 0x2050
pushq $-0x1
popq %rax
jmp 0x4deb
movl (%r15), %esi
leaq 0x2aed(%rip), %rdi      # 0x78c7
xorl %eax, %eax
callq 0x2050
xorl %eax, %eax
cmpq %rbp, %r15
setne %al
negl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mikeakohn[P]drumsplusplus/build/../src/SongInfo.cxx
// Function: SongInfo::print()
void SongInfo::print()
{
  printf("     Song Name: %s\n", song_name.c_str());
  printf("           BMP: %d\n", bpm);
  printf("Default Volume: %d\n", default_volume);
  printf("         Drift: %d\n", drift);
  printf(" Timesignature: %d/%d\n", time_signature_beats, time_signature_base);
  printf("  MIDI Channel: %d\n", midi_channel);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0x13be(%rip), %rdi      # 0x798a
xorl %eax, %eax
callq 0x2050
movl 0x20(%rbx), %esi
leaq 0x13c1(%rip), %rdi      # 0x799e
xorl %eax, %eax
callq 0x2050
movl 0x24(%rbx), %esi
leaq 0x13c4(%rip), %rdi      # 0x79b2
xorl %eax, %eax
callq 0x2050
movl 0x28(%rbx), %esi
leaq 0x13c7(%rip), %rdi      # 0x79c6
xorl %eax, %eax
callq 0x2050
movl 0x2c(%rbx), %esi
movl 0x30(%rbx), %edx
leaq 0x13c7(%rip), %rdi      # 0x79da
xorl %eax, %eax
callq 0x2050
movl 0x34(%rbx), %esi
leaq 0x13cd(%rip), %rdi      # 0x79f1
xorl %eax, %eax
popq %rbx
jmp 0x2050
// File: /workspace/github_cpp_makefile_star2_O2/mikeakohn[P]drumsplusplus/build/../src/Utility.cxx
// Function: Utility::is_number(char*)
bool Utility::is_number(char *s)
{
  int r = 0;

  while ((s[r] != ' '  && s[r] != '\t') &&
        ((s[r] != '\n' && s[r] != '\r') && s[r] != 0))
  {
    if (s[r] < '0' || s[r] > '9') { return 0; }
    r++;
  }

  return r == 0 ? false : true;
}

// Assembly:
xorl %eax, %eax
movabsq $0x100002601, %rcx      # imm = 0x100002601
movzbl (%rdi,%rax), %edx
cmpq $0x20, %rdx
ja 0x6648
btq %rdx, %rcx
jb 0x6655
addb $-0x3a, %dl
cmpb $-0xa, %dl
jb 0x665c
incq %rax
jmp 0x6638
testq %rax, %rax
setne %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndreiBarsan[P]uShell/hello.cc
// Function: main
int main(int argc, char **argv) {
  using namespace std;
  cout << "Hello, I am the child program!" << endl;
  cout << "argc = " << argc << endl;
  cout << "argv[0] = " << argv[0] << endl;

  int rc = 0;
  if(argc > 1) {
    rc = atoi(argv[1]);
    for(int i = 1; i < argc; ++i) {
      cout << "argv[" << i << "] = " << argv[i] << endl;
    }    
  }

  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movq 0x2df1(%rip), %r15      # 0x3fd8
leaq 0xe16(%rip), %rsi       # 0x2004
movq %r15, %rdi
callq 0x1050
movq %rax, %rdi
callq 0x1030
leaq 0xe1e(%rip), %rsi       # 0x2023
movq %r15, %rdi
callq 0x1050
movq %rax, %rdi
movl %r14d, %esi
callq 0x1080
movq %rax, %rdi
callq 0x1030
leaq 0xe04(%rip), %rsi       # 0x202b
movq %r15, %rdi
callq 0x1050
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x1050
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
cmpl $0x2, %r14d
jl 0x12b1
movq 0x8(%rbx), %rdi
callq 0x1070
movl %eax, -0x2c(%rbp)
movl %r14d, %r12d
pushq $0x1
popq %r14
leaq 0xdd2(%rip), %r13       # 0x2036
leaq 0xdc6(%rip), %r15       # 0x2031
cmpq %r14, %r12
je 0x12ae
movq 0x2d61(%rip), %rdi      # 0x3fd8
movq %r13, %rsi
callq 0x1050
movq %rax, %rdi
movl %r14d, %esi
callq 0x1080
movq %rax, %rdi
movq %r15, %rsi
callq 0x1050
movq (%rbx,%r14,8), %rsi
movq %rax, %rdi
callq 0x1050
movq %rax, %rdi
callq 0x1030
incq %r14
jmp 0x126b
movl -0x2c(%rbp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/VitorCorreaSilva[P]sistemaControle/source/data.cpp
// Function: Data::now()
Data Data::now(){
	struct tm* dataHoraAtual;
	time_t segundos;
	time(&segundos);   

	dataHoraAtual = localtime(&segundos);  

	Data data(dataHoraAtual->tm_mday, dataHoraAtual->tm_mon + 1, dataHoraAtual->tm_year + 1900);

	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0x10(%rbp), %rbx
movq %rbx, %rdi
callq 0x2130
movq %rbx, %rdi
callq 0x20d0
movl 0xc(%rax), %esi
movl 0x10(%rax), %ecx
incl %ecx
movl $0x76c, %edx            # imm = 0x76C
addl 0x14(%rax), %edx
shlq $0x20, %rcx
orq %rsi, %rcx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/VitorCorreaSilva[P]sistemaControle/source/empresa.cpp
// Function: Empresa::listaJogadores()
void Empresa::listaJogadores(){
	int numTimes = times.size();
	for (int i = 0; i < numTimes; ++i)
	{
		vector<Jogador> jogadores = times[i].getJogadores();
		int numJogadores = jogadores.size();
		for (int j = 0; j < numJogadores; ++j)
		{
			cout << "ID: " << jogadores[j].getId();
			cout << " Nome: " << jogadores[j].getNome() << endl;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0x28(%rdi), %rax
movq %rdi, -0x48(%rbp)
subq 0x20(%rdi), %rax
pushq $0x48
popq %rcx
cqto
idivq %rcx
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movq %rax, -0x50(%rbp)
movq 0x625d(%rip), %r12      # 0x8fd8
leaq -0x78(%rbp), %r15
xorl %eax, %eax
cmpq -0x50(%rbp), %rax
je 0x2e48
movq %rax, -0x58(%rbp)
imulq $0x48, %rax, %rsi
movq -0x48(%rbp), %rax
addq 0x20(%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x5158
movq -0x38(%rbp), %rax
subq -0x40(%rbp), %rax
cqto
pushq $0x68
popq %rcx
idivq %rcx
testl %eax, %eax
movl $0x0, %ecx
cmovlel %ecx, %eax
imulq $0x68, %rax, %r13
xorl %ebx, %ebx
cmpq %rbx, %r13
je 0x2e33
movq %r12, %rdi
leaq 0x3341(%rip), %rsi      # 0x6114
callq 0x2140
movq %rax, %r14
movq -0x40(%rbp), %rdi
addq %rbx, %rdi
callq 0x38c2
movq %r14, %rdi
movl %eax, %esi
callq 0x21f0
movq %r12, %rdi
leaq 0x331e(%rip), %rsi      # 0x6119
callq 0x2140
movq %rax, %r14
movq -0x40(%rbp), %rsi
addq %rbx, %rsi
movq %r15, %rdi
callq 0x38a6
movq %r14, %rdi
movq %r15, %rsi
callq 0x2120
movq %rax, %rdi
callq 0x2090
movq %r15, %rdi
callq 0x2080
addq $0x68, %rbx
jmp 0x2dc4
leaq -0x40(%rbp), %rdi
callq 0x311c
movq -0x58(%rbp), %rax
incq %rax
jmp 0x2d81
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e67
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x2080
jmp 0x2e6a
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x311c
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O2/VitorCorreaSilva[P]sistemaControle/source/jogador.cpp
// Function: Jogador::Jogador(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Data, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Categorias, float)
Jogador::Jogador(string nome, Data nascimento, string nacionalidade, Categorias categoria, float salarioBruto){
	this->nome = nome;
	this->id = gerarIdJogador();
	this->dataNascimento = nascimento;
	this->nacionalidade = nacionalidade;
	this->categoria = categoria;
	this->salarioBruto = salarioBruto;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movss %xmm0, -0x30(%rbp)
movl %r9d, -0x2c(%rbp)
movq %r8, -0x48(%rbp)
movl %ecx, -0x34(%rbp)
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %r12
leaq 0x8(%rdi), %r13
movb $0x0, 0x18(%rdi)
addq $0x28, %rdi
movq %r13, -0x40(%rbp)
callq 0x242c
leaq 0x38(%r15), %r14
leaq 0x48(%r15), %rax
movq %rax, 0x38(%r15)
andq $0x0, 0x40(%r15)
movb $0x0, 0x48(%r15)
movq %r13, %rdi
movq %r12, %rsi
callq 0x20b0
movl 0x590b(%rip), %eax      # 0x9138
incl %eax
movl %eax, 0x5903(%rip)      # 0x9138
movl %eax, (%r15)
movq %rbx, 0x28(%r15)
movl -0x34(%rbp), %eax
movl %eax, 0x30(%r15)
movq %r14, %rdi
movq -0x48(%rbp), %rsi
callq 0x20b0
movl -0x2c(%rbp), %eax
movl %eax, 0x58(%r15)
movss -0x30(%rbp), %xmm0
movss %xmm0, 0x5c(%r15)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3880
movq %rax, %rbx
movq %r14, %rdi
callq 0x2080
movq -0x40(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O2/VitorCorreaSilva[P]sistemaControle/source/jogador.cpp
// Function: Jogador::calcularDescontoInss(float)
float Jogador::calcularDescontoInss(float salarioBruto){
	float inss;

	if(salarioBruto < 0){
		cout << "Insira um Salario Válido." << endl;
	}
	else if(salarioBruto <= 1100){
		inss = 7.5;
	}
	else if(salarioBruto <= 2000){
		inss = 9;
	}
	else if(salarioBruto <= 3100){
		inss = 12;
	}
	else if(salarioBruto <= 4100){
		inss = 14;
	}
	else{
		inss = 14;
	}

	return salarioBruto * (inss/100);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x39fe
movq 0x55fa(%rip), %rdi      # 0x8fd8
leaq 0x27b3(%rip), %rsi      # 0x6198
movss %xmm1, -0x4(%rbp)
callq 0x2140
movq %rax, %rdi
callq 0x2090
movss -0x4(%rbp), %xmm1
jmp 0x3a4b
movss 0x2766(%rip), %xmm0     # 0x616c
ucomiss %xmm1, %xmm0
jae 0x3a2f
movss 0x2761(%rip), %xmm0     # 0x6174
ucomiss %xmm1, %xmm0
jae 0x3a39
movss 0x275c(%rip), %xmm0     # 0x617c
ucomiss %xmm1, %xmm0
jae 0x3a43
movss 0x2753(%rip), %xmm0     # 0x6180
jmp 0x3a4b
movss 0x2731(%rip), %xmm0     # 0x6168
jmp 0x3a4b
movss 0x272f(%rip), %xmm0     # 0x6170
jmp 0x3a4b
movss 0x272d(%rip), %xmm0     # 0x6178
divss 0x2731(%rip), %xmm0     # 0x6184
mulss %xmm1, %xmm0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/VitorCorreaSilva[P]sistemaControle/source/jogador.cpp
// Function: Jogador::calcularDescontoIrrf(float)
float Jogador::calcularDescontoIrrf(float salarioSemInss){
	float irrf;

	if(salarioSemInss < 0){
		cout << "Insira um Salario Válido." << endl;
	}
	else if(salarioSemInss <= 1100){
		irrf = 0;
	}
	else if(salarioSemInss <= 2000){
		irrf = 7.5;
	}
	else if(salarioSemInss <= 3100){
		irrf = 15;
	}
	else if(salarioSemInss <= 4100){
		irrf = 22;
	}
	else{
		irrf = 27;
	}

	return salarioSemInss * (irrf/100);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movaps %xmm0, %xmm2
xorps %xmm0, %xmm0
ucomiss %xmm2, %xmm0
jbe 0x3a98
movq 0x5560(%rip), %rdi      # 0x8fd8
leaq 0x2719(%rip), %rsi      # 0x6198
movss %xmm2, -0x4(%rbp)
callq 0x2140
movq %rax, %rdi
callq 0x2090
movss -0x4(%rbp), %xmm2
jmp 0x3aef
movss 0x26cc(%rip), %xmm1     # 0x616c
ucomiss %xmm2, %xmm1
jae 0x3aef
movss 0x26c7(%rip), %xmm0     # 0x6174
ucomiss %xmm2, %xmm0
jae 0x3add
movss 0x26c2(%rip), %xmm0     # 0x617c
ucomiss %xmm2, %xmm0
jae 0x3ae7
movss 0x26c5(%rip), %xmm0     # 0x618c
xorl %eax, %eax
ucomiss %xmm2, %xmm0
setb %al
leaq 0x26ba(%rip), %rcx      # 0x6190
movss (%rcx,%rax,4), %xmm0
jmp 0x3aef
movss 0x2683(%rip), %xmm0     # 0x6168
jmp 0x3aef
movss 0x2699(%rip), %xmm0     # 0x6188
divss 0x268d(%rip), %xmm0     # 0x6184
mulss %xmm2, %xmm0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/VitorCorreaSilva[P]sistemaControle/source/jogador.cpp
// Function: Jogador::calcularIdade(Data)
int Jogador::calcularIdade(Data dataNascimento){
	Data agora = Data::now();
	int idade = agora.getAno() - dataNascimento.getAno();
	int meses = agora.getMes() - dataNascimento.getMes();
	int dias = agora.getDia() - dataNascimento.getDia();

	if(meses < 0){
		idade--;
	}
	else if(meses == 0){
		if(dias < 0){
			idade--;
		}
	}

	return idade;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq -0x48(%rbp), %r14
movq %rsi, (%r14)
movl %edx, 0x8(%r14)
callq 0x25b8
leaq -0x38(%rbp), %r15
movq %rax, (%r15)
movl %edx, 0x8(%r15)
movq %r15, %rdi
callq 0x2452
movl %eax, %ebx
movq %r14, %rdi
callq 0x2452
subl %eax, %ebx
movq %r15, %rdi
callq 0x2448
movl %eax, %r12d
movq %r14, %rdi
callq 0x2448
movl %eax, %r13d
movq %r15, %rdi
callq 0x2440
movl %eax, %r15d
movq %r14, %rdi
callq 0x2440
cmpl %r13d, %r12d
setl %cl
sete %dl
cmpl %eax, %r15d
setl %al
andb %dl, %al
orb %cl, %al
movzbl %al, %eax
subl %eax, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/VitorCorreaSilva[P]sistemaControle/source/jogador.cpp
// Function: Jogador::mostrarDados()
void Jogador::mostrarDados(){
	cout << id << " - ";
	cout << nome << " - ";
	cout << nacionalidade << " - ";
	cout << dataNascimento.toString() << " - ";
	cout << categoria << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl (%rdi), %esi
movq 0x540b(%rip), %r14      # 0x8fd8
movq %r14, %rdi
callq 0x21f0
leaq 0x25d7(%rip), %r15      # 0x61b3
movq %rax, %rdi
movq %r15, %rsi
callq 0x2140
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x2120
movq %rax, %rdi
movq %r15, %rsi
callq 0x2140
leaq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0x2120
movq %rax, %rdi
movq %r15, %rsi
callq 0x2140
leaq 0x28(%rbx), %rsi
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x2478
movq %r14, %rdi
movq %r15, %rsi
callq 0x2120
leaq 0x257c(%rip), %rsi      # 0x61b3
movq %rax, %rdi
callq 0x2140
leaq -0x38(%rbp), %rdi
callq 0x2080
movl 0x58(%rbx), %esi
movq 0x5386(%rip), %rdi      # 0x8fd8
callq 0x21f0
movq %rax, %rdi
callq 0x2090
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O2/VitorCorreaSilva[P]sistemaControle/source/time.cpp
// Function: Time::relatorioGeral()
void Time::relatorioGeral(){
	int numeroJogadores = jogadores.size();

	cout << nome << endl;
	for (int i = 0; i < numeroJogadores; ++i)
	{
		jogadores[i].mostrarDados();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rax
subq 0x30(%rdi), %rax
pushq $0x68
popq %rcx
cqto
idivq %rcx
movq %rax, %r14
leaq 0x8(%rdi), %rsi
movq 0x3dfd(%rip), %rdi      # 0x8fd8
callq 0x2120
movq %rax, %rdi
callq 0x2090
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
imulq $0x68, %r14, %r14
cmpq %r15, %r14
je 0x520d
movq 0x30(%rbx), %rdi
addq %r15, %rdi
callq 0x3bb4
addq $0x68, %r15
jmp 0x51f6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/VitorCorreaSilva[P]sistemaControle/source/time.cpp
// Function: Time::buscarJogador(int)
void Time::buscarJogador(int id){
	int numJogadores = jogadores.size();
	for (int i = 0; i < numJogadores; ++i)
	{
		if(jogadores[i].getId() == id){
			jogadores[i].mostrarDados();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x38(%rdi), %rax
subq 0x30(%rdi), %rax
pushq $0x68
popq %rcx
cqto
idivq %rcx
xorl %r15d, %r15d
testl %eax, %eax
cmovlel %r15d, %eax
imulq $0x68, %rax, %r12
cmpq %r15, %r12
je 0x526c
movq 0x30(%r14), %rdi
addq %r15, %rdi
callq 0x38c2
cmpl %ebx, %eax
jne 0x5266
movq 0x30(%r14), %rdi
addq %r15, %rdi
callq 0x3bb4
addq $0x68, %r15
jmp 0x5245
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/VitorCorreaSilva[P]sistemaControle/source/time.cpp
// Function: Time::buscarJogador(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Time::buscarJogador(string nome){
	int numJogadores = jogadores.size();
	for (int i = 0; i < numJogadores; ++i)
	{
		if(jogadores[i].getNome() == nome){
			jogadores[i].mostrarDados();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
subq 0x30(%rdi), %rax
movq %rsi, -0x30(%rbp)
pushq $0x68
popq %rcx
cqto
idivq %rcx
xorl %r13d, %r13d
testl %eax, %eax
cmovlel %r13d, %eax
imulq $0x68, %rax, %r14
leaq -0x50(%rbp), %r15
cmpq %r13, %r14
je 0x52f1
movq 0x30(%rbx), %rsi
addq %r13, %rsi
movq %r15, %rdi
callq 0x38a6
movq %r15, %rdi
movq -0x30(%rbp), %rsi
callq 0x3147
movl %eax, %r12d
movq %r15, %rdi
callq 0x2080
testb %r12b, %r12b
je 0x52eb
movq 0x30(%rbx), %rdi
addq %r13, %rdi
callq 0x3bb4
addq $0x68, %r13
jmp 0x52af
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/VitorCorreaSilva[P]sistemaControle/source/time.cpp
// Function: Time::relatorioFinanceiro()
void Time::relatorioFinanceiro(){
	int numeroJogadores = jogadores.size();

	for (int i = 0; i < numeroJogadores; ++i)
	{
		cout << jogadores[i].getNome() << " - ";
		cout << jogadores[i].getSalarioBruto() << " - ";
		cout << jogadores[i].calcularSalarioLiquido(jogadores[i].getSalarioBruto()) << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
subq 0x30(%rdi), %rax
pushq $0x68
popq %rcx
cqto
idivq %rcx
xorl %r12d, %r12d
testl %eax, %eax
cmovlel %r12d, %eax
imulq $0x68, %rax, %rax
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %r14
movq 0x3c98(%rip), %r15      # 0x8fd8
cmpq %r12, -0x30(%rbp)
je 0x53cd
movq 0x30(%rbx), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0x38a6
movq %r15, %rdi
movq %r14, %rsi
callq 0x2120
leaq 0xe48(%rip), %r13       # 0x61b3
movq %rax, %rdi
movq %r13, %rsi
callq 0x2140
movq %r14, %rdi
callq 0x2080
movq 0x30(%rbx), %rdi
addq %r12, %rdi
callq 0x38fe
movq %r15, %rdi
callq 0x20e0
movq %rax, %rdi
movq %r13, %rsi
callq 0x2140
movq 0x30(%rbx), %r13
addq %r12, %r13
movq %r13, %rdi
callq 0x38fe
movq %r13, %rdi
callq 0x398a
movq %r15, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x2090
addq $0x68, %r12
jmp 0x5340
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/readmapping[P]alfalfa/src/main.cpp
// Function: readBatch(int, std::vector<read_t, std::allocator<read_t>>&)
int readBatch(int bpCount, vector<read_t> & reads){
    int curCount = 0;
    bool hasRead = true;
    while(curCount < bpCount && hasRead){
        read_t read;
        hasRead = queryReader->nextRead(read.qname, read.sequence, read.qual);
        if(hasRead){
            curCount += read.sequence.length();
            reads.push_back(read);
        }
    }
    return reads.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movl %edi, %ebp
xorl %r14d, %r14d
movb $0x1, %r13b
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %r12
testb $0x1, %r13b
je 0x79dd
cmpl %ebp, %r14d
jge 0x79dd
movq %r12, %rdi
callq 0x9200
movq 0x42a4c(%rip), %rdi     # 0x4a3f8
movq %r12, %rsi
leaq 0x28(%rsp), %rdx
movq %r15, %rcx
callq 0x15036
movl %eax, %r13d
testb %al, %al
je 0x79d3
addl 0x30(%rsp), %r14d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x92f2
movq %r12, %rdi
callq 0x9322
jmp 0x7992
movq 0x8(%rbx), %rax
subq (%rbx), %rax
movl $0xd0, %ecx
cqto
idivq %rcx
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9322
movq %rbx, %rdi
callq 0x75e0
// File: /workspace/github_cpp_makefile_star2_O2/readmapping[P]alfalfa/src/main.cpp
// Function: map_unpaired(void*, int, int)
static void map_unpaired(void * unpairedData, int i, int threadid)
{
    unpaired_data * data = (unpaired_data*) unpairedData;
    read_t & read = data->reads->at(i);
    if (read.qname.length() > 2 && read.qname[read.qname.length() - 2] == '/')
        read.qname.erase(read.qname.length() - 2);
    read.init(data->opt->nucleotidesOnly);
    if (data->opt->alnOptions.print >= 3) cerr << "match " << read.qname << " with length " << read.sequence.length() << endl;
    if (data->opt->alnOptions.print >= 2) cerr << "#READ" << endl;
#ifndef NDEBUG
    if (data->opt->alnOptions.debugFile != NULL && data->opt->query_threads == 1) {
        fprintf(data->opt->alnOptions.debugFile, ">%s\n", read.qname.c_str());
        fprintf(data->opt->alnOptions.debugFile, "%lu\n", read.sequence.size());
    }
#endif
    unpairedMatch(*data->ssa, read, data->opt->alnOptions);
    read.postprocess(*data->ssa, data->opt->alnOptions, false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movslq %esi, %rsi
callq 0xa002
movq %rax, %r14
movq 0x8(%rax), %rsi
cmpq $0x3, %rsi
jb 0x7d45
movq (%r14), %rax
cmpb $0x2f, -0x2(%rax,%rsi)
jne 0x7d45
addq $-0x2, %rsi
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0x70c0
movq (%rbx), %rax
movzbl 0xf8(%rax), %esi
movq %r14, %rdi
callq 0xa024
movq (%rbx), %rdx
movl 0x178(%rdx), %eax
cmpl $0x3, %eax
jl 0x7daf
movq 0x4227c(%rip), %rdi     # 0x49fe8
leaq 0x2a6a6(%rip), %rsi     # 0x32419
callq 0x72b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x7280
leaq 0x2a696(%rip), %rsi     # 0x32420
movq %rax, %rdi
callq 0x72b0
movq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x71d0
movq %rax, %rdi
callq 0x7160
movq (%rbx), %rdx
movl 0x178(%rdx), %eax
cmpl $0x2, %eax
jl 0x7dd2
movq 0x4222d(%rip), %rdi     # 0x49fe8
leaq 0x2a66c(%rip), %rsi     # 0x3242e
callq 0x72b0
movq %rax, %rdi
callq 0x7160
movq (%rbx), %rdx
movq 0x8(%rbx), %rdi
movl $0x100, %r15d           # imm = 0x100
addq %r15, %rdx
movq %r14, %rsi
callq 0x1d52e
movq 0x8(%rbx), %rsi
addq (%rbx), %r15
movq %r14, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x1a43c
// File: /workspace/github_cpp_makefile_star2_O2/readmapping[P]alfalfa/src/main.cpp
// Function: readBatchPaired(int, std::vector<read_t, std::allocator<read_t>>&, std::vector<read_t, std::allocator<read_t>>&)
int readBatchPaired(int bpCount, vector<read_t> & mates1, vector<read_t> & mates2){
    int curCount = 0;
    bool hasRead = true;
    while(curCount < bpCount && hasRead){
        read_t mate1;
        read_t mate2;
        hasRead = mate1Reader->nextRead(mate1.qname, mate1.sequence, mate1.qual);
        hasRead = mate2Reader->nextRead(mate2.qname, mate2.sequence, mate2.qual);
        if(hasRead){
            curCount += mate1.sequence.length();
            mates1.push_back(mate1);
            mates2.push_back(mate2);
        }
    }
    return mates1.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edi, %ebp
movb $0x1, %r13b
xorl %r15d, %r15d
leaq 0x18(%rsp), %r14
leaq 0xe8(%rsp), %r12
cmpl %ebp, %r15d
jge 0x7ec9
testb $0x1, %r13b
je 0x7ec9
movq %r14, %rdi
callq 0x9200
movq %r12, %rdi
callq 0x9200
movq 0x425b6(%rip), %rdi     # 0x4a410
movq %r14, %rsi
leaq 0x38(%rsp), %rdx
leaq 0x58(%rsp), %rcx
callq 0x15036
movq 0x425a5(%rip), %rdi     # 0x4a418
movq %r12, %rsi
leaq 0x108(%rsp), %rdx
leaq 0x128(%rsp), %rcx
callq 0x15036
movl %eax, %r13d
testb %al, %al
je 0x7eb4
movq 0x40(%rsp), %rbx
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x92f2
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x92f2
addl %ebx, %r15d
movq %r12, %rdi
callq 0x9322
movq %r14, %rdi
callq 0x9322
jmp 0x7e30
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
movl $0xd0, %ecx
cqto
idivq %rcx
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x7f06
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0x9322
leaq 0x18(%rsp), %rdi
callq 0x9322
movq %rbx, %rdi
callq 0x75e0
// File: /workspace/github_cpp_makefile_star2_O2/readmapping[P]alfalfa/src/main.cpp
// Function: map_paired(void*, int, int)
static void map_paired(void * pairedData, int i, int threadid)
{
    paired_data * data = (paired_data*) pairedData;
    read_t & mate1 = data->mates1->at(i);
    read_t & mate2 = data->mates2->at(i);
    if (mate1.qname.length() > 2 && mate1.qname[mate1.qname.length() - 2] == '/')
        mate1.qname.erase(mate1.qname.length() - 2);
    if (mate2.qname.length() > 2 && mate2.qname[mate2.qname.length() - 2] == '/')
        mate2.qname.erase(mate2.qname.length() - 2);
    mate1.init(data->opt->nucleotidesOnly);
    mate2.init(data->opt->nucleotidesOnly);
    if (data->opt->alnOptions.print >= 3) cerr << "match " << mate1.qname << " with lengths " << mate1.sequence.length() << " and " << mate2.sequence.length() << endl;
    if (data->opt->alnOptions.print >= 2) cerr << "#READ" << endl;
    pairedMatch(*data->ssa, mate1, mate2, data->opt->alnOptions, data->opt->pairedOpt);
    mate1.postprocess(*data->ssa, data->opt->alnOptions, true);
    mate2.postprocess(*data->ssa, data->opt->alnOptions, true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movslq %esi, %r14
movq %r14, %rsi
callq 0xa002
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xa002
movq %rax, %r14
movq 0x8(%r15), %rsi
cmpq $0x3, %rsi
jb 0x8404
movq (%r15), %rax
cmpb $0x2f, -0x2(%rax,%rsi)
jne 0x8404
addq $-0x2, %rsi
pushq $-0x1
popq %rdx
movq %r15, %rdi
callq 0x70c0
movq 0x8(%r14), %rsi
cmpq $0x3, %rsi
jb 0x8427
movq (%r14), %rax
cmpb $0x2f, -0x2(%rax,%rsi)
jne 0x8427
addq $-0x2, %rsi
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0x70c0
movq (%rbx), %rax
movzbl 0xf8(%rax), %esi
movq %r15, %rdi
callq 0xa024
movq (%rbx), %rax
movzbl 0xf8(%rax), %esi
movq %r14, %rdi
callq 0xa024
movq (%rbx), %r8
movl 0x178(%r8), %eax
cmpl $0x3, %eax
jl 0x84c0
movq 0x41b87(%rip), %rdi     # 0x49fe8
leaq 0x29fb1(%rip), %rsi     # 0x32419
callq 0x72b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x7280
leaq 0x2a065(%rip), %rsi     # 0x324e4
movq %rax, %rdi
callq 0x72b0
movq 0x28(%r15), %rsi
movq %rax, %rdi
callq 0x71d0
leaq 0x2ed16(%rip), %rsi     # 0x371b0
movq %rax, %rdi
callq 0x72b0
movq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x71d0
movq %rax, %rdi
callq 0x7160
movq (%rbx), %r8
movl 0x178(%r8), %eax
cmpl $0x2, %eax
jl 0x84e3
movq 0x41b1c(%rip), %rdi     # 0x49fe8
leaq 0x29f5b(%rip), %rsi     # 0x3242e
callq 0x72b0
movq %rax, %rdi
callq 0x7160
movq (%rbx), %r8
movq 0x8(%rbx), %rdi
movl $0x100, %r12d           # imm = 0x100
leaq (%r8,%r12), %rcx
addq $0x198, %r8             # imm = 0x198
movq %r15, %rsi
movq %r14, %rdx
callq 0x2161f
movq 0x8(%rbx), %rsi
movq (%rbx), %rdx
addq %r12, %rdx
pushq $0x1
popq %rbp
movq %r15, %rdi
movl %ebp, %ecx
callq 0x1a43c
movq 0x8(%rbx), %rsi
addq (%rbx), %r12
movq %r14, %rdi
movq %r12, %rdx
movl %ebp, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1a43c
// File: /workspace/github_cpp_makefile_star2_O2/readmapping[P]alfalfa/src/mapper.h
// Function: read_t::~read_t()
~read_t() {
        if(readP != NULL){
            std::free(readP); readP = NULL;
            std::free(rcReadP); rcReadP = NULL;
        }
        for(size_t i=0; i < alignments.size(); i++){
            delete alignments[i];
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xa0(%rdi), %rdi
testq %rdi, %rdi
je 0x935a
callq 0x7360
andq $0x0, 0xa0(%rbx)
movq 0xa8(%rbx), %rdi
callq 0x7360
andq $0x0, 0xa8(%rbx)
leaq 0xb0(%rbx), %r14
xorl %r12d, %r12d
movq 0xb0(%rbx), %rax
movq 0xb8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jae 0x93a1
movq (%rax,%r12,8), %r15
testq %r15, %r15
je 0x938f
movq %r15, %rdi
callq 0x9f92
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
callq 0x72e0
incq %r12
jmp 0x9364
movq %r14, %rdi
callq 0x9eac
leaq 0x80(%rbx), %rdi
callq 0x76a8
leaq 0x60(%rbx), %rdi
callq 0x76a8
leaq 0x40(%rbx), %rdi
callq 0x76a8
leaq 0x20(%rbx), %rdi
callq 0x76a8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x76a8
nop
// File: /workspace/github_cpp_makefile_star2_O2/readmapping[P]alfalfa/src/mapper.h
// Function: read_t::emptyAlingment[abi:cxx11](bool, bool, bool)
std::string emptyAlingment(bool paired, bool mateFailed, bool upstream){
        std::stringstream ss;
        int flag = 4;
        if(paired) flag += 1;
        if(mateFailed) flag += 8;
        if(paired && upstream) flag += 64;
        if(paired && !upstream) flag += 128;
        ss << qname << "\t" << flag << "\t*\t0\t0\t*\t*\t0\t0\t" << sequence << "\t" << qual << std::endl;
        return ss.str();
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
leal (%rdx,%rcx,8), %eax
addl $0x4, %eax
leal (%rdx,%rcx,8), %ecx
addl $0x44, %ecx
testl %r8d, %r8d
cmovel %eax, %ecx
movq %rsi, %r14
testl %edx, %edx
cmovel %eax, %ecx
leal 0x80(%rcx), %ebp
testl %r8d, %r8d
cmovnel %ecx, %ebp
movq %rdi, %rbx
testl %edx, %edx
cmovel %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x71e0
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x7280
leaq 0x29662(%rip), %rsi     # 0x32a9d
movq %rax, %rdi
callq 0x72b0
movq %rax, %rdi
movl %ebp, %esi
callq 0x75c0
leaq 0x2902a(%rip), %rsi     # 0x3247e
movq %rax, %rdi
callq 0x72b0
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x7280
leaq 0x2962e(%rip), %rsi     # 0x32a9d
movq %rax, %rdi
callq 0x72b0
addq $0x40, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x7280
movq %rax, %rdi
callq 0x7160
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0x8(%rsp), %rdi
callq 0x7210
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7210
movq %rbx, %rdi
callq 0x75e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/readmapping[P]alfalfa/src/mapper.h
// Function: read_t::printUnpairedAlignment[abi:cxx11](int)
std::string printUnpairedAlignment(int i){
        std::stringstream ss;
        alignment_t * a = alignments[i];
        ss << qname << "\t" << a->flag.to_ulong() << "\t"
            << a->rname << "\t" << a->pos << "\t" << 
            a->mapq << "\t" << a->cigar << "\t" << 
            "*" << "\t" << 0 << "\t" << 
            0 << "\t" << (a->flag.test(4) ? rcSequence : sequence) <<
            "\t" << (a->flag.test(4) ? rQual : qual) << "\tAS:i:" << 
            a->alignmentScore << "\tNM:i:" << a->editDist << "\tX0:Z:" << 
            a->NMtag << std::endl;
        return ss.str();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x71e0
movslq %ebp, %rax
movq 0xb0(%r15), %rcx
movq (%rcx,%rax,8), %r14
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x7280
leaq 0x29590(%rip), %rsi     # 0x32a9d
movq %rax, %rdi
callq 0x72b0
movq 0x40(%r14), %rsi
movq %rax, %rdi
callq 0x71d0
leaq 0x29575(%rip), %rsi     # 0x32a9d
movq %rax, %rdi
callq 0x72b0
leaq 0x48(%r14), %rsi
movq %rax, %rdi
callq 0x7280
leaq 0x2955a(%rip), %rsi     # 0x32a9d
movq %rax, %rdi
callq 0x72b0
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x72a0
leaq 0x2953f(%rip), %rsi     # 0x32a9d
movq %rax, %rdi
callq 0x72b0
movl 0x68(%r14), %esi
movq %rax, %rdi
callq 0x75c0
leaq 0x29524(%rip), %rsi     # 0x32a9d
movq %rax, %rdi
callq 0x72b0
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x7280
leaq 0x29509(%rip), %rsi     # 0x32a9d
movq %rax, %rdi
callq 0x72b0
leaq 0x28adf(%rip), %rsi     # 0x32082
movq %rax, %rdi
callq 0x72b0
leaq 0x294eb(%rip), %rsi     # 0x32a9d
movq %rax, %rdi
callq 0x72b0
movq %rax, %rdi
xorl %esi, %esi
callq 0x75c0
leaq 0x294d2(%rip), %rsi     # 0x32a9d
movq %rax, %rdi
callq 0x72b0
movq %rax, %rdi
xorl %esi, %esi
callq 0x75c0
leaq 0x294b9(%rip), %rsi     # 0x32a9d
movq %rax, %rdi
callq 0x72b0
movq %rax, %r13
leaq 0x40(%r14), %r12
pushq $0x4
popq %rsi
movq %r12, %rdi
callq 0xa11c
movzbl %al, %eax
shll $0x6, %eax
leaq (%r15,%rax), %rsi
addq $0x20, %rsi
movq %r13, %rdi
callq 0x7280
leaq 0x29482(%rip), %rsi     # 0x32a9d
movq %rax, %rdi
callq 0x72b0
movq %rax, %r13
pushq $0x4
popq %rsi
movq %r12, %rdi
callq 0xa11c
movzbl %al, %eax
shll $0x6, %eax
leaq (%rax,%r15), %rsi
addq $0x40, %rsi
movq %r13, %rdi
callq 0x7280
leaq 0x28e40(%rip), %rsi     # 0x3248e
movq %rax, %rdi
callq 0x72b0
movl 0x70(%r14), %esi
movq %rax, %rdi
callq 0x75c0
leaq 0x28e2c(%rip), %rsi     # 0x32495
movq %rax, %rdi
callq 0x72b0
movl 0x6c(%r14), %esi
movq %rax, %rdi
callq 0x75c0
leaq 0x28e18(%rip), %rsi     # 0x3249c
movq %rax, %rdi
callq 0x72b0
addq $0x78, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x7280
movq %rax, %rdi
callq 0x7160
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
movq %rsp, %rdi
callq 0x7210
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7210
movq %rbx, %rdi
callq 0x75e0
// File: /workspace/github_cpp_makefile_star2_O2/readmapping[P]alfalfa/src/performanceUtils.h
// Function: samCheckOptions_t::initOptions()
void initOptions(){
        subcommand = SUMMARY;
        outputFile = "";
        oracleSam = "";
        refString = "";
        paired = false;
        querySam = "";
        qtag = "NM";
        otag = "XE";
        numReads=0;
        print = false;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, (%rdi)
addq $0x8, %rdi
leaq 0x28f1c(%rip), %r14     # 0x32a9e
movq %r14, %rsi
callq 0x7660
leaq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0x7660
leaq 0x48(%rbx), %rdi
movq %r14, %rsi
callq 0x7660
xorl %ebp, %ebp
movb %bpl, 0x68(%rbx)
leaq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x7660
leaq 0xd8(%rbx), %rdi
leaq 0x28b9f(%rip), %rsi     # 0x32761
callq 0x7660
leaq 0xf8(%rbx), %rdi
leaq 0x28b8f(%rip), %rsi     # 0x32764
callq 0x7660
andq $0x0, 0x118(%rbx)
movb %bpl, 0x69(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/readmapping[P]alfalfa/src/mapper.h
// Function: read_t::init(bool)
void init(bool nucleotidesOnly){
        rcSequence = sequence;//copy
        Utils::reverse_complement(rcSequence, nucleotidesOnly);
        rQual = qual;
        std::reverse(rQual.begin(),rQual.end());
        readP = (uint8_t *)std::malloc(sequence.length());
        rcReadP = (uint8_t *)std::malloc(sequence.length());
        for (size_t i = 0; i < sequence.length(); ++i){ // convert to the nt4 encoding
            readP[i] = Utils::ORDVALUE[(size_t)sequence[i]];
            rcReadP[i] = Utils::ORDVALUE[(size_t)rcSequence[i]];
        }
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x20(%rdi), %rsi
leaq 0x60(%rdi), %r14
movq %r14, %rdi
callq 0x7180
movq %r14, %rdi
movl %ebp, %esi
callq 0x18f73
leaq 0x40(%rbx), %rsi
leaq 0x80(%rbx), %rdi
callq 0x7180
movq 0x80(%rbx), %rdi
movq 0x88(%rbx), %rsi
addq %rdi, %rsi
callq 0xa101
movq 0x28(%rbx), %r14
movq %r14, %rdi
callq 0x7430
movq %rax, 0xa0(%rbx)
movq %r14, %rdi
callq 0x7430
movq %rax, 0xa8(%rbx)
xorl %eax, %eax
leaq 0x286f8(%rip), %rcx     # 0x32790
cmpq %r14, %rax
jae 0xa0d2
movq 0x20(%rbx), %rdx
movq 0xa0(%rbx), %rsi
movsbq (%rdx,%rax), %rdx
movb (%rdx,%rcx), %dl
movb %dl, (%rsi,%rax)
movq 0x60(%rbx), %rdx
movq 0xa8(%rbx), %rsi
movsbq (%rdx,%rax), %rdx
movb (%rdx,%rcx), %dl
movb %dl, (%rsi,%rax)
incq %rax
movq 0x28(%rbx), %r14
jmp 0xa098
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/readmapping[P]alfalfa/src/mapper.h
// Function: alignment_t::setUnPaired(bool)
void setUnPaired(bool upstream){
    flag.set(0,true);
    flag.set(6,upstream);
    flag.set(7,!upstream);
    flag.set(3,true);
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
addq $0x40, %rbx
pushq $0x1
popq %r14
movq %rbx, %rdi
xorl %esi, %esi
movl %r14d, %edx
callq 0xa1f6
pushq $0x6
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0xa1f6
xorb $0x1, %bpl
movzbl %bpl, %edx
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0xa1f6
pushq $0x3
popq %rsi
movq %rbx, %rdi
movl %r14d, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0xa1f6
// File: /workspace/github_cpp_makefile_star2_O2/readmapping[P]alfalfa/src/options.cpp
// Function: align_opt::fill_m()
void align_opt::fill_m() {
    int i, j, k;
    for (i = k = 0; i < 4; ++i) {
        for (j = 0; j < 4; ++j)
            mat[k++] = i == j ? match : mismatch;
        mat[k++] = -1; // ambiguous base
    }
    for (j = 0; j < 5; ++j) mat[k++] = -1;
}

// Assembly:
leaq 0x10(%rdi), %rax
xorl %ecx, %ecx
movabsq $0x100000000, %rdx      # imm = 0x100000000
xorl %r8d, %r8d
cmpl $0x4, %ecx
je 0xb2ed
movslq %r8d, %r8
movq %r8, %rsi
shlq $0x20, %rsi
leaq (%rax,%r8), %r9
xorl %r10d, %r10d
cmpl $0x4, %r10d
je 0xb2d9
xorl %r11d, %r11d
cmpl %r10d, %ecx
setne %r11b
movb (%rdi,%r11,4), %r11b
movb %r11b, (%r9,%r10)
incq %r10
addq %rdx, %rsi
jmp 0xb2b9
addq %r10, %r8
incq %r8
sarq $0x20, %rsi
movb $-0x1, 0x10(%rdi,%rsi)
incq %rcx
jmp 0xb2a3
movslq %r8d, %rax
addq %rdi, %rax
addq $0x10, %rax
xorl %ecx, %ecx
cmpl $0x5, %ecx
je 0xb307
movb $-0x1, (%rax,%rcx)
incq %rcx
jmp 0xb2f9
retq
// File: /workspace/github_cpp_makefile_star2_O2/readmapping[P]alfalfa/src/options.cpp
// Function: parseSeedType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
mum_t parseSeedType(string type) {
    if (type.compare("MEM") == 0)
        return MEM;
    else if (type.compare("MAM") == 0)
        return MAM;
    else if (type.compare("MUM") == 0)
        return MUM;
    else if (type.compare("SMEM") == 0)
        return SMAM;
    else if (type.compare("SMAM") == 0)
        return SMAM;
    else if (type.compare("PSMEM") == 0)
        return SMEM;
    else {
        cerr << "WARNING: unrecognized seed type. SMEMs are used instead." << endl;
        return SMAM;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x27160(%rip), %rsi     # 0x32e3a
callq 0x7100
testl %eax, %eax
je 0xbd62
leaq 0x2714a(%rip), %rsi     # 0x32e34
movq %r14, %rdi
callq 0x7100
testl %eax, %eax
je 0xbd66
leaq 0x27132(%rip), %rsi     # 0x32e2f
movq %r14, %rdi
callq 0x7100
testl %eax, %eax
je 0xbd73
leaq 0x27129(%rip), %rsi     # 0x32e39
movq %r14, %rdi
callq 0x7100
pushq $0x4
popq %rbx
testl %eax, %eax
je 0xbd69
leaq 0x2710d(%rip), %rsi     # 0x32e33
movq %r14, %rdi
callq 0x7100
testl %eax, %eax
je 0xbd69
leaq 0x270ff(%rip), %rsi     # 0x32e38
movq %r14, %rdi
callq 0x7100
testl %eax, %eax
je 0xbd77
movq 0x3e29c(%rip), %rdi     # 0x49fe8
leaq 0x270eb(%rip), %rsi     # 0x32e3e
callq 0x72b0
movq %rax, %rdi
callq 0x7160
jmp 0xbd69
pushq $0x2
jmp 0xbd68
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %ebx, %ebx
jmp 0xbd69
pushq $0x3
jmp 0xbd68
// File: /workspace/github_cpp_makefile_star2_O2/readmapping[P]alfalfa/src/options.cpp
// Function: parseOrientation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
orientation_t parseOrientation(string type) {
    if (type.compare("fr") == 0)
        return PAIR_FR;
    else if (type.compare("rf") == 0)
        return PAIR_RF;
    else if (type.compare("ff") == 0)
        return PAIR_FF;
    else {
        cerr << "WARNING: unrecognized orientation. fr is used instead." << endl;
        return PAIR_FR;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x270ee(%rip), %rsi     # 0x32e77
callq 0x7100
xorl %ebx, %ebx
testl %eax, %eax
je 0xbdde
leaq 0x270df(%rip), %rsi     # 0x32e7a
movq %r14, %rdi
callq 0x7100
testl %eax, %eax
je 0xbdd7
leaq 0x270cf(%rip), %rsi     # 0x32e7d
movq %r14, %rdi
callq 0x7100
testl %eax, %eax
je 0xbddb
movq 0x3e227(%rip), %rdi     # 0x49fe8
leaq 0x270b8(%rip), %rsi     # 0x32e80
callq 0x72b0
movq %rax, %rdi
callq 0x7160
jmp 0xbdde
pushq $0x1
jmp 0xbddd
pushq $0x2
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/readmapping[P]alfalfa/src/optionparser.h
// Function: option::Option::first()
Option* first()
  {
    Option* p = this;
    while (!p->isFirst())
      p = p->prev_;
    return p;
  }

// Assembly:
movq %rdi, %rax
movq 0x8(%rdi), %rdi
testb $0x1, %dil
je 0xd024
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/readmapping[P]alfalfa/src/sparseSA.cpp
// Function: sparseSA::index_size_in_bytes()
long sparseSA::index_size_in_bytes(){
      long indexSize = 0L;
      indexSize += sizeof(sparseMult);
      indexSize += sizeof(hasSufLink);
      indexSize += sizeof(hasChild);
      indexSize += sizeof(K);
      indexSize += sizeof(NKm1);
      indexSize += sizeof(logN);
      indexSize += sizeof(N);
      indexSize += sizeof(maxdescrlen);
      indexSize += sizeof(descr);
      for(size_t i = 0; i < descr.size(); i++){
          indexSize += descr[i].capacity();
      }
      indexSize += sizeof(startpos) + startpos.capacity()*sizeof(long);
      indexSize += S.capacity();
      indexSize += sizeof(SA) + SA.capacity()*sizeof(unsigned int);
      indexSize += sizeof(ISA) + ISA.capacity()*sizeof(int);
      indexSize += sizeof(CHILD) + CHILD.capacity()*sizeof(int);
      indexSize += LCP.index_size_in_bytes();
      indexSize += sizeof(hasKmer);
      indexSize += sizeof(KMR) + KMR.capacity()*sizeof(saTuple_t);
      return indexSize;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x10, %rax
pushq $0x46
popq %r14
pushq $0xf
popq %rdx
subq $0x1, %rcx
jb 0xd161
movq %rdx, %rsi
cmpq -0x10(%rax), %rax
je 0xd158
movq (%rax), %rsi
addq %rsi, %r14
addq $0x20, %rax
jmp 0xd146
leaq 0x60(%rbx), %rcx
movq 0x70(%rbx), %rax
cmpq %rcx, 0x50(%rbx)
je 0xd175
movq 0x60(%rbx), %rcx
jmp 0xd178
pushq $0xf
popq %rcx
addq 0x28(%rbx), %r14
subq 0x18(%rbx), %r14
addq %rcx, %r14
addq 0x80(%rbx), %r14
addq 0x98(%rbx), %r14
addq 0xe0(%rbx), %r14
addq 0x88(%rbx), %rax
leaq 0xa0(%rbx), %rdi
addq 0xd0(%rbx), %rax
subq %rax, %r14
callq 0xd106
addq %r14, %rax
addq 0x110(%rbx), %rax
subq 0x100(%rbx), %rax
addq $0x79, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/readmapping[P]alfalfa/src/sparseSA.cpp
// Function: sparseSA::init(long, bool, bool, bool)
void sparseSA::init(long K_, bool _hasSufLink, bool _hasChild, bool _hasKmer){
  hasSufLink = _hasSufLink;
  hasChild = _hasChild;
  hasKmer = _hasKmer;
  K = K_;

  // Increase string length so divisible by K.
  // Don't forget to count $ termination character.
  S.reserve(S.length()+2*K);
  if(S.length() % K != 0) {
    long appendK = K - S.length() % K ;
    for(long i = 0; i < appendK; i++) S += '$';
  }
  // Make sure last K-sampled characeter is this special character as well!!
  for(long i = 0; i < K; i++) S += '$'; // Append "special" end character. Note: It must be lexicographically less.
  N = S.length();
  std::string(S.data(), S.size()).swap(S);

  // Adjust to "sampled" size.
  logN = (long)ceil(log(N/K) / log(2.0));
  NKm1 = N/K-1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movb %dl, 0xf1(%rdi)
movb %cl, 0xf0(%rdi)
movb %r8b, 0xf8(%rdi)
movq %rsi, 0xe8(%rdi)
leaq 0x50(%rdi), %r14
addq %rsi, %rsi
addq 0x58(%rdi), %rsi
movq %r14, %rdi
callq 0x7530
movq 0x58(%rbx), %rax
movq 0xe8(%rbx), %r15
xorl %edx, %edx
divq %r15
testq %rdx, %rdx
je 0xd240
subq %rdx, %r15
xorl %r12d, %r12d
pushq $0x24
popq %rbp
cmpq %r15, %r12
jge 0xd240
movq %r14, %rdi
movl %ebp, %esi
callq 0x7260
incq %r12
jmp 0xd22c
xorl %r15d, %r15d
pushq $0x24
popq %rbp
cmpq 0xe8(%rbx), %r15
jge 0xd25e
movq %r14, %rdi
movl %ebp, %esi
callq 0x7260
incq %r15
jmp 0xd246
movq 0x58(%rbx), %rdx
movq %rdx, 0x38(%rbx)
movq 0x50(%rbx), %rsi
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0xa408
movq %r15, %rdi
movq %r14, %rsi
callq 0x7200
movq %r15, %rdi
callq 0x76a8
movq 0x38(%rbx), %rax
cqto
idivq 0xe8(%rbx)
movq %rax, %rdi
callq 0x10e4c
divsd 0x29017(%rip), %xmm0    # 0x362c8
callq 0x7090
cvttsd2si %xmm0, %rax
movq %rax, 0x40(%rbx)
movq 0x38(%rbx), %rax
cqto
idivq 0xe8(%rbx)
decq %rax
movq %rax, 0x48(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq