LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mikeakohn[P]drumsplusplus/build/../src/Song.cxx
// Function: Song::parse_include(Tokens*)
int Song::parse_include(Tokens *tokens)
{
  int token_type;
  char token[1024];
  char filename[1024];
  char lastfilename[1024];
  Tokens *tokens_include;

  tokens_include = new Tokens();

  token_type = tokens->get(token);

  if (token_type != TOKEN_STRING)
  {
    print_error(tokens, "filename", token);
    return -1;
  }

  filename[0] = 0;

  if (token[0] != '/')
  {
    strcpy(lastfilename, tokens->get_filename());

    if (dirname_m(lastfilename) != 0)
    {
      strcpy(filename, lastfilename);
      strcat(filename, "/");
    }
  }

  strcat(filename, token);

  if (tokens_include->open(filename) != 0)
  {
    printf("Error: included file not found: %s at %s:%d.\n",
      filename, tokens->get_filename(), tokens->get_line());

    delete tokens_include;

    return -1;
  }
    else
  {
    if (parse(tokens_include) == -1) { return -1; }
  }

  tokens_include->close();
  delete tokens_include;

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc08, %rsp            # imm = 0xC08
movq %rsi, %r14
movq %rdi, %r15
movl $0x30, %edi
callq 0x21a0
movq %rax, %rbx
movq %rax, %rdi
callq 0x27cc
leaq 0x400(%rsp), %rsi
movq %r14, %rdi
callq 0x2884
cmpl $0x4, %eax
jne 0x3d28
movb $0x0, (%rsp)
cmpb $0x2f, 0x400(%rsp)
je 0x3cd6
movq 0x8(%r14), %rsi
leaq 0x800(%rsp), %r12
movq %r12, %rdi
callq 0x2170
movq %r12, %rsi
callq 0x4f4c
testq %rax, %rax
je 0x3cd6
movq %rsp, %r12
leaq 0x800(%rsp), %rsi
movq %r12, %rdi
callq 0x2170
movq %r12, %rdi
callq 0x20e0
movw $0x2f, (%rsp,%rax)
movq %rsp, %r12
leaq 0x400(%rsp), %rsi
movq %r12, %rdi
callq 0x2310
movq %rbx, %rdi
movq %r12, %rsi
callq 0x280c
testl %eax, %eax
je 0x3d61
movq 0x8(%r14), %rdx
movl 0x2c(%r14), %ecx
leaq 0x3830(%rip), %rdi      # 0x7537
movq %rsp, %rsi
xorl %eax, %eax
callq 0x2050
movq %rbx, %rdi
callq 0x27f0
movl $0x30, %esi
movq %rbx, %rdi
callq 0x21b0
jmp 0x3d4d
movq 0x8(%r14), %rcx
movl 0x2c(%r14), %r8d
leaq 0x3ba9(%rip), %rdi      # 0x78e0
leaq 0x37f0(%rip), %rsi      # 0x752e
leaq 0x400(%rsp), %rdx
xorl %eax, %eax
callq 0x2050
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0xc08, %rsp            # imm = 0xC08
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %rbx, %rsi
callq 0x35e4
cmpl $-0x1, %eax
je 0x3d4d
movq %rbx, %rdi
callq 0x286e
movq %rbx, %rdi
callq 0x27f0
movl $0x30, %esi
movq %rbx, %rdi
callq 0x21b0
xorl %eax, %eax
jmp 0x3d52
movq %rax, %r14
movl $0x30, %esi
movq %rbx, %rdi
callq 0x21b0
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2b47(%rip), %rdi      # 0x7937
callq 0x22a0
movq 0xc0(%rbx), %r14
leaq 0xb0(%rbx), %r12
cmpq %r12, %r14
je 0x4e31
leaq 0x2536(%rip), %r15      # 0x7345
movq 0x20(%r14), %rsi
movq 0x40(%r14), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x2050
movq %r14, %rdi
callq 0x2110
movq %rax, %r14
cmpq %r12, %rax
jne 0x4e0f
leaq 0x2b08(%rip), %rdi      # 0x7940
callq 0x22a0
movq 0xf0(%rbx), %r14
leaq 0xe0(%rbx), %r12
cmpq %r12, %r14
je 0x4e79
leaq 0x24f9(%rip), %r15      # 0x7350
movl 0x20(%r14), %esi
movq 0x28(%r14), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x2050
movq %r14, %rdi
callq 0x2110
movq %rax, %r14
cmpq %r12, %rax
jne 0x4e57
movl 0x100(%rbx), %ebp
movl $0x0, 0xc(%rsp)
testl %ebp, %ebp
jle 0x4ec7
leaq 0xd8(%rbx), %r14
leaq 0x78(%rbx), %r15
leaq 0xc(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x55b0
movq %r15, %rdi
movq %rax, %rsi
callq 0x5616
movq %rax, %rdi
callq 0x3162
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
cmpl %ebp, %eax
jl 0x4e9b
leaq 0x2a7c(%rip), %rdi      # 0x794a
callq 0x22a0
movq 0x60(%rbx), %r14
leaq 0x50(%rbx), %r12
cmpq %r12, %r14
je 0x4f0e
leaq 0x2473(%rip), %r15      # 0x735a
movq 0x20(%r14), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2050
leaq 0x40(%r14), %rdi
callq 0x3376
movq %r14, %rdi
callq 0x2110
movq %rax, %r14
cmpq %r12, %rax
jne 0x4ee7
movq (%rbx), %rsi
leaq 0x244e(%rip), %rdi      # 0x7366
xorl %eax, %eax
callq 0x2050
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
testl %ecx, %ecx
js 0x4f83
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %eax, %eax
movzbl (%rbx,%rcx), %edx
cmpl $0x2f, %edx
je 0x4f87
cmpl $0x5c, %edx
je 0x4f87
leaq -0x1(%rcx), %rdx
testq %rcx, %rcx
movq %rdx, %rcx
jg 0x4f67
jmp 0x4f91
xorl %eax, %eax
jmp 0x4f91
movl %ecx, %ecx
leaq (%rbx,%rcx), %rax
movb $0x0, (%rbx,%rcx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6afe
leaq 0x50(%rbx), %rcx
cmpq %rcx, %rax
je 0x53a5
movq %r14, %rdi
movq %r15, %rsi
callq 0x578a
movq %rax, %r14
cmpl $0x1, 0x128(%rbx)
jne 0x5334
movq (%r15), %rsi
leaq 0x2575(%rip), %rdi      # 0x78a2
xorl %eax, %eax
callq 0x2050
movq (%r14), %r15
xorl %ebp, %ebp
cmpq 0x8(%r14), %r15
je 0x53cb
leaq 0xd8(%rbx), %r12
leaq 0xe0(%rbx), %r13
movq 0xe8(%rbx), %rax
movl (%r15), %esi
testq %rax, %rax
je 0x53b8
movq %r13, %rcx
xorl %edx, %edx
cmpl %esi, 0x20(%rax)
setl %dl
cmovgeq %rax, %rcx
movq 0x10(%rax,%rdx,8), %rax
testq %rax, %rax
jne 0x5363
cmpq %r13, %rcx
je 0x53b8
cmpl 0x20(%rcx), %esi
jl 0x53b8
movq %r12, %rdi
movq %r15, %rsi
callq 0x55b0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x53dc
addq $0x4, %r15
cmpq 0x8(%r14), %r15
jne 0x5351
jmp 0x53cb
movq (%r15), %rsi
leaq 0x24d8(%rip), %rdi      # 0x7887
xorl %eax, %eax
callq 0x2050
jmp 0x53c6
leaq 0x24f0(%rip), %rdi      # 0x78af
xorl %eax, %eax
callq 0x2050
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd9e(%rip), %rdi       # 0x797a
xorl %eax, %eax
callq 0x2050
movl 0x20(%rbx), %esi
leaq 0xda1(%rip), %rdi       # 0x798e
xorl %eax, %eax
callq 0x2050
movl 0x24(%rbx), %esi
leaq 0xda4(%rip), %rdi       # 0x79a2
xorl %eax, %eax
callq 0x2050
movl 0x28(%rbx), %esi
leaq 0xda7(%rip), %rdi       # 0x79b6
xorl %eax, %eax
callq 0x2050
movl 0x2c(%rbx), %esi
movl 0x30(%rbx), %edx
leaq 0xda7(%rip), %rdi       # 0x79ca
xorl %eax, %eax
callq 0x2050
movl 0x34(%rbx), %esi
leaq 0xdad(%rip), %rdi       # 0x79e1
xorl %eax, %eax
popq %rbx
jmp 0x2050
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6c58
btq %rdx, %rcx
jb 0x6c65
addb $-0x3a, %dl
cmpb $-0xa, %dl
jb 0x6c6c
incq %rax
jmp 0x6c48
testq %rax, %rax
setne %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, -0x70(%rbp)
subq 0x20(%rdi), %rax
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %rcx # imm = 0x8E38E38E38E38E39
imulq %rax, %rcx
movq %rcx, -0x30(%rbp)
testl %ecx, %ecx
jle 0x3486
movq -0x30(%rbp), %rax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, -0x30(%rbp)
xorl %eax, %eax
leaq -0x48(%rbp), %rbx
movq 0x7c69(%rip), %r15      # 0xafd8
leaq -0x68(%rbp), %r14
movq %rax, -0x78(%rbp)
leaq (%rax,%rax,8), %rsi
shlq $0x3, %rsi
movq -0x70(%rbp), %rax
addq 0x20(%rax), %rsi
movq %rbx, %rdi
callq 0x7098
movq -0x40(%rbp), %r12
subq -0x48(%rbp), %r12
sarq $0x3, %r12
movabsq $0x4ec4ec4ec4ec4ec5, %rax # imm = 0x4EC4EC4EC4EC4EC5
imulq %rax, %r12
testl %r12d, %r12d
jle 0x3469
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movl $0x4, %edx
movq %r15, %rdi
leaq 0x4d49(%rip), %rsi      # 0x8114
callq 0x2160
movq -0x48(%rbp), %rdi
addq %r13, %rdi
callq 0x4106
movq %r15, %rdi
movl %eax, %esi
callq 0x21c0
movl $0x7, %edx
movq %r15, %rdi
leaq 0x4d24(%rip), %rsi      # 0x8119
callq 0x2160
movq -0x48(%rbp), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0x40d8
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %r15, %rdi
callq 0x2160
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x345c
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2130
addq $0x68, %r13
decq %r12
jne 0x33bc
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0x38a8
movq -0x78(%rbp), %rax
incq %rax
cmpq -0x30(%rbp), %rax
jne 0x3373
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x34b5
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x34b8
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2130
jmp 0x34b8
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x38a8
movq %rbx, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x4279
movq 0x6da6(%rip), %rbx      # 0xafd8
leaq 0x3f87(%rip), %rsi      # 0x81c0
movl $0x1a, %edx
movq %rbx, %rdi
movss %xmm1, -0xc(%rbp)
callq 0x2160
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movss -0xc(%rbp), %xmm1
jmp 0x42c6
movss 0x3f13(%rip), %xmm0     # 0x8194
ucomiss %xmm1, %xmm0
jae 0x42aa
movss 0x3f0e(%rip), %xmm0     # 0x819c
ucomiss %xmm1, %xmm0
jae 0x42b4
movss 0x3f09(%rip), %xmm0     # 0x81a4
ucomiss %xmm1, %xmm0
jae 0x42be
movss 0x3f00(%rip), %xmm0     # 0x81a8
jmp 0x42c6
movss 0x3ede(%rip), %xmm0     # 0x8190
jmp 0x42c6
movss 0x3edc(%rip), %xmm0     # 0x8198
jmp 0x42c6
movss 0x3eda(%rip), %xmm0     # 0x81a0
divss 0x3ede(%rip), %xmm0     # 0x81ac
mulss %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movaps %xmm0, %xmm2
xorps %xmm0, %xmm0
ucomiss %xmm2, %xmm0
jbe 0x4339
movq 0x6ce6(%rip), %rbx      # 0xafd8
leaq 0x3ec7(%rip), %rsi      # 0x81c0
movl $0x1a, %edx
movq %rbx, %rdi
movss %xmm2, -0xc(%rbp)
callq 0x2160
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movss -0xc(%rbp), %xmm2
jmp 0x4390
movss 0x3e53(%rip), %xmm1     # 0x8194
ucomiss %xmm2, %xmm1
jae 0x4390
movss 0x3e4e(%rip), %xmm0     # 0x819c
ucomiss %xmm2, %xmm0
jae 0x437e
movss 0x3e49(%rip), %xmm0     # 0x81a4
ucomiss %xmm2, %xmm0
jae 0x4388
movss 0x3e4c(%rip), %xmm0     # 0x81b4
xorl %eax, %eax
ucomiss %xmm2, %xmm0
setb %al
leaq 0x3e41(%rip), %rcx      # 0x81b8
movss (%rcx,%rax,4), %xmm0
jmp 0x4390
movss 0x3e0a(%rip), %xmm0     # 0x8190
jmp 0x4390
movss 0x3e20(%rip), %xmm0     # 0x81b0
divss 0x3e14(%rip), %xmm0     # 0x81ac
mulss %xmm2, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a44
leaq -0x38(%rbp), %r15
movq %rax, (%r15)
movl %edx, 0x8(%r15)
movq %r15, %rdi
callq 0x2492
movl %eax, %ebx
movq %r14, %rdi
callq 0x2492
subl %eax, %ebx
movq %r15, %rdi
callq 0x2488
movl %eax, %r12d
movq %r14, %rdi
callq 0x2488
movl %eax, %r13d
movq %r15, %rdi
callq 0x2480
movl %eax, %r15d
movq %r14, %rdi
callq 0x2480
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_O3/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 0x6b69(%rip), %r14      # 0xafd8
movq %r14, %rdi
callq 0x21c0
leaq 0x3d5d(%rip), %r15      # 0x81db
movl $0x3, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x2160
movl $0x3, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rdx
movq %r14, %rdi
callq 0x2160
movl $0x3, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
leaq 0x28(%rbx), %rsi
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x24b8
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x2160
leaq 0x3ce7(%rip), %rsi      # 0x81db
movl $0x3, %edx
movq %rax, %rdi
callq 0x2160
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x451a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2130
movl 0x58(%rbx), %esi
movq 0x6ab4(%rip), %rdi      # 0xafd8
callq 0x21c0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x457a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
sarq $0x3, %rax
movabsq $0x4ec4ec4ec4ec4ec5, %r15 # imm = 0x4EC4EC4EC4EC4EC5
imulq %rax, %r15
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
movq 0x3e74(%rip), %rdi      # 0xafd8
callq 0x2160
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
testl %r15d, %r15d
jle 0x71b7
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movq 0x30(%rbx), %rdi
addq %r14, %rdi
callq 0x4456
addq $0x68, %r14
decq %r15
jne 0x71a2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x38(%rdi), %rax
subq 0x30(%rdi), %rax
sarq $0x3, %rax
movabsq $0x4ec4ec4ec4ec4ec5, %r15 # imm = 0x4EC4EC4EC4EC4EC5
imulq %rax, %r15
testl %r15d, %r15d
jle 0x7220
movl %esi, %ebx
movq %rdi, %r14
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movq 0x30(%r14), %rdi
addq %r12, %rdi
callq 0x4106
cmpl %ebx, %eax
jne 0x7217
movq 0x30(%r14), %rdi
addq %r12, %rdi
callq 0x4456
addq $0x68, %r12
decq %r15
jne 0x71fb
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rsi, -0x30(%rbp)
movq 0x38(%rdi), %rax
subq 0x30(%rdi), %rax
sarq $0x3, %rax
movabsq $0x4ec4ec4ec4ec4ec5, %r13 # imm = 0x4EC4EC4EC4EC4EC5
imulq %rax, %r13
testl %r13d, %r13d
jle 0x72e7
movq %rdi, %r14
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
movq 0x30(%r14), %rsi
addq %r15, %rsi
leaq -0x50(%rbp), %rdi
callq 0x40d8
movq -0x48(%rbp), %rdx
movq -0x30(%rbp), %rax
cmpq 0x8(%rax), %rdx
jne 0x72ac
movq -0x50(%rbp), %r12
testq %rdx, %rdx
je 0x72b4
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq %r12, %rdi
callq 0x2140
testl %eax, %eax
sete %bl
jmp 0x72b6
movq -0x50(%rbp), %r12
xorl %ebx, %ebx
jmp 0x72b6
movb $0x1, %bl
leaq -0x40(%rbp), %rax
cmpq %rax, %r12
je 0x72ce
movq -0x40(%rbp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x2130
testb %bl, %bl
je 0x72de
movq 0x30(%r14), %rdi
addq %r15, %rdi
callq 0x4456
addq $0x68, %r15
decq %r13
jne 0x726f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x38(%rdi), %rax
subq 0x30(%rdi), %rax
sarq $0x3, %rax
movabsq $0x4ec4ec4ec4ec4ec5, %r14 # imm = 0x4EC4EC4EC4EC4EC5
imulq %rax, %r14
testl %r14d, %r14d
jle 0x7417
movq %rdi, %rbx
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movq 0x3c9a(%rip), %r15      # 0xafd8
leaq 0xe96(%rip), %r13       # 0x81db
movq 0x30(%rbx), %rsi
addq %r12, %rsi
leaq -0x48(%rbp), %rdi
callq 0x40d8
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x2160
movl $0x3, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2160
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x738e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2130
movq 0x30(%rbx), %rdi
addq %r12, %rdi
callq 0x4154
cvtss2sd %xmm0, %xmm0
movq %r15, %rdi
callq 0x21a0
movl $0x3, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2160
movq 0x30(%rbx), %r13
addq %r12, %r13
movq %r13, %rdi
callq 0x4154
movq %r13, %rdi
callq 0x41e0
cvtss2sd %xmm0, %xmm0
movq %r15, %rdi
callq 0x21a0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %r13, %rdi
leaq 0xdde(%rip), %r13       # 0x81db
callq 0x2030
movq %rax, %rdi
callq 0x20a0
addq $0x68, %r12
decq %r14
jne 0x7345
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x7442
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/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
testl %edi, %edi
jle 0x8c08
movl %edi, %ebp
xorl %r14d, %r14d
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xae98
movq 0x4b843(%rip), %rdi     # 0x54400
movq %r12, %rsi
leaq 0x28(%rsp), %rdx
leaq 0x48(%rsp), %rcx
callq 0x19d66
movl %eax, %r13d
testb %al, %al
je 0x8bfe
movq 0x30(%rsp), %r15
movq %rbx, %rdi
movq %r12, %rsi
callq 0xafe6
addl %r15d, %r14d
movq %r12, %rdi
callq 0xb016
cmpl %ebp, %r14d
setl %al
testb %al, %r13b
jne 0x8bae
jmp 0x8c08
leaq 0x8(%rsp), %rdi
callq 0xb016
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x4, %rax
imull $0xc4ec4ec5, %eax, %eax # imm = 0xC4EC4EC5
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb016
movq %rbx, %rdi
callq 0x7600
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10(%rdi), %rcx
movslq %esi, %rsi
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $0x4ec4ec4ec4ec4ec5, %rdx # imm = 0x4EC4EC4EC4EC4EC5
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x919b
movq %rdi, %rbx
imulq $0xd0, %rsi, %rcx
leaq (%rax,%rcx), %r14
movq 0x8(%rax,%rcx), %rax
cmpq $0x3, %rax
jb 0x907f
movq (%r14), %rcx
cmpb $0x2f, -0x2(%rcx,%rax)
jne 0x907f
addq $-0x2, %rax
movq %rax, 0x8(%r14)
movb $0x0, (%rcx,%rax)
movq (%rbx), %rax
movzbl 0xf8(%rax), %esi
movq %r14, %rdi
callq 0xc0f2
movq (%rbx), %rdx
movl 0x178(%rdx), %eax
cmpl $0x3, %eax
jl 0x9123
movq 0x4af3e(%rip), %r15     # 0x53fe8
leaq 0x37337(%rip), %rsi     # 0x403e8
movl $0x6, %edx
movq %r15, %rdi
callq 0x7340
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x7340
movq %rax, %r15
leaq 0x37318(%rip), %rsi     # 0x403ef
movl $0xd, %edx
movq %rax, %rdi
callq 0x7340
movq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0x71c0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x72b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x71d0
movq (%rbx), %rdx
movl 0x178(%rdx), %eax
cmpl $0x2, %eax
jl 0x916d
movq 0x4aeb9(%rip), %r15     # 0x53fe8
leaq 0x372c7(%rip), %rsi     # 0x403fd
movl $0x5, %edx
movq %r15, %rdi
callq 0x7340
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x72b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x71d0
movq (%rbx), %rdx
movq 0x8(%rbx), %rdi
movl $0x100, %r15d           # imm = 0x100
addq %r15, %rdx
movq %r14, %rsi
callq 0x2512f
movq 0x8(%rbx), %rsi
addq (%rbx), %r15
movq %r14, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x205ac
leaq 0x37261(%rip), %rdi     # 0x40403
xorl %eax, %eax
callq 0x74e0
// File: /workspace/github_cpp_makefile_star2_O3/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)
testl %edi, %edi
jle 0x926e
movl %edi, %ebp
xorl %r15d, %r15d
leaq 0x18(%rsp), %r14
leaq 0xe8(%rsp), %r12
movq %r14, %rdi
callq 0xae98
movq %r12, %rdi
callq 0xae98
movq 0x4b223(%rip), %rdi     # 0x54418
movq %r14, %rsi
leaq 0x38(%rsp), %rdx
leaq 0x58(%rsp), %rcx
callq 0x19d66
movq 0x4b212(%rip), %rdi     # 0x54420
movq %r12, %rsi
leaq 0x108(%rsp), %rdx
leaq 0x128(%rsp), %rcx
callq 0x19d66
movl %eax, %r13d
testb %al, %al
je 0x924f
movq 0x40(%rsp), %rbx
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xafe6
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0xafe6
addl %ebx, %r15d
movq %r12, %rdi
callq 0xb016
movq %r14, %rdi
callq 0xb016
cmpl %ebp, %r15d
setl %al
testb %r13b, %al
jne 0x91de
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
shrq $0x4, %rax
imull $0xc4ec4ec5, %eax, %eax # imm = 0xC4EC4EC5
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x92ab
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0xb016
leaq 0x18(%rsp), %rdi
callq 0xb016
movq %rbx, %rdi
callq 0x7600
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0xa0(%rdi), %rdi
testq %rdi, %rdi
je 0xb04c
callq 0x7380
xorl %r14d, %r14d
movq %r14, 0xa0(%rbx)
movq 0xa8(%rbx), %rdi
callq 0x7380
movq %r14, 0xa8(%rbx)
movq 0xb0(%rbx), %rdi
cmpq %rdi, 0xb8(%rbx)
je 0xb122
xorl %r15d, %r15d
movq (%rdi,%r15,8), %r14
testq %r14, %r14
je 0xb0f4
movq 0xe8(%r14), %rdi
testq %rdi, %rdi
je 0xb08b
movq 0xf8(%r14), %rsi
subq %rdi, %rsi
callq 0x72f0
movq 0xa8(%r14), %rdi
leaq 0xb8(%r14), %rax
cmpq %rax, %rdi
je 0xb0a9
movq (%rax), %rsi
incq %rsi
callq 0x72f0
movq 0x78(%r14), %rdi
leaq 0x88(%r14), %rax
cmpq %rax, %rdi
je 0xb0c4
movq (%rax), %rsi
incq %rsi
callq 0x72f0
movq 0x48(%r14), %rdi
leaq 0x58(%r14), %rax
cmpq %rax, %rdi
je 0xb0dc
movq (%rax), %rsi
incq %rsi
callq 0x72f0
movq 0x20(%r14), %rdi
leaq 0x30(%r14), %rax
cmpq %rax, %rdi
je 0xb0f4
movq (%rax), %rsi
incq %rsi
callq 0x72f0
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
callq 0x72f0
incq %r15
movq 0xb0(%rbx), %rdi
movq 0xb8(%rbx), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %rax, %r15
jb 0xb063
testq %rdi, %rdi
je 0xb136
movq 0xc0(%rbx), %rsi
subq %rdi, %rsi
callq 0x72f0
movq 0x80(%rbx), %rdi
leaq 0x90(%rbx), %rax
cmpq %rax, %rdi
je 0xb154
movq (%rax), %rsi
incq %rsi
callq 0x72f0
movq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0xb16c
movq (%rax), %rsi
incq %rsi
callq 0x72f0
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0xb184
movq (%rax), %rsi
incq %rsi
callq 0x72f0
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0xb19c
movq (%rax), %rsi
incq %rsi
callq 0x72f0
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0xb1b8
movq (%rbx), %rsi
incq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x72f0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
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
movq %rsp, %rdi
callq 0x71e0
leaq 0x10(%rsp), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x7340
movq %rax, %r15
leaq 0x35801(%rip), %rsi     # 0x40a1d
movl $0x1, %edx
movq %rax, %rdi
callq 0x7340
movq %r15, %rdi
movl %ebp, %esi
callq 0x75d0
movq %rax, %r15
leaq 0x35210(%rip), %rsi     # 0x4044d
movl $0xf, %edx
movq %rax, %rdi
callq 0x7340
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %r15, %rdi
callq 0x7340
movq %rax, %r15
leaq 0x357b9(%rip), %rsi     # 0x40a1d
movl $0x1, %edx
movq %rax, %rdi
callq 0x7340
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
movq %r15, %rdi
callq 0x7340
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x72b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x71d0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
movq 0x48cd9(%rip), %rsi     # 0x53f98
movq %rsp, %rdi
callq 0x7210
leaq 0x80(%rsp), %rdi
callq 0x7100
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48ca9(%rip), %rsi     # 0x53f98
movq %rsp, %rdi
callq 0x7210
leaq 0x80(%rsp), %rdi
callq 0x7100
movq %rbx, %rdi
callq 0x7600
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, (%rdi)
addq $0x8, %rdi
movq 0x10(%rbx), %rdx
leaq 0x34e2b(%rip), %r14     # 0x40a1e
xorl %r15d, %r15d
xorl %esi, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x7510
leaq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rdx
xorl %esi, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x7510
leaq 0x48(%rbx), %rdi
movq 0x50(%rbx), %rdx
xorl %esi, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x7510
movb %r15b, 0x68(%rbx)
leaq 0x70(%rbx), %rdi
movq 0x78(%rbx), %rdx
xorl %esi, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x7510
leaq 0xd8(%rbx), %rdi
movq 0xe0(%rbx), %rdx
leaq 0x34a88(%rip), %rcx     # 0x406e3
movl $0x2, %r8d
xorl %esi, %esi
callq 0x7510
leaq 0xf8(%rbx), %rdi
movq 0x100(%rbx), %rdx
leaq 0x34a69(%rip), %rcx     # 0x406e6
movl $0x2, %r8d
xorl %esi, %esi
callq 0x7510
movq $0x0, 0x118(%rbx)
movb %r15b, 0x69(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7170
movq %r14, %rdi
movl %ebp, %esi
callq 0x1eb23
leaq 0x40(%rbx), %rsi
leaq 0x80(%rbx), %rdi
callq 0x7170
movq 0x80(%rbx), %rax
movq 0x88(%rbx), %rcx
testq %rcx, %rcx
setne %dl
addq %rax, %rcx
decq %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0xc16d
incq %rax
movb -0x1(%rax), %dl
movb (%rcx), %sil
movb %sil, -0x1(%rax)
movb %dl, (%rcx)
decq %rcx
leaq 0x1(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0xc152
movq 0x28(%rbx), %r14
movq %r14, %rdi
callq 0x7430
movq %rax, 0xa0(%rbx)
movq %r14, %rdi
callq 0x7430
movq %rax, 0xa8(%rbx)
testq %r14, %r14
je 0xc1d2
xorl %eax, %eax
leaq 0x34573(%rip), %rcx     # 0x40710
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
cmpq 0x28(%rbx), %rax
jb 0xc19d
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
leaq 0x10(%rdi), %rax
xorl %edx, %edx
movabsq $0x100000000, %rcx      # imm = 0x100000000
xorl %esi, %esi
movslq %edx, %r8
leaq (%rax,%r8), %r9
shlq $0x20, %r8
xorl %r10d, %r10d
xorl %r11d, %r11d
movl %esi, %ebx
addl %r10d, %ebx
setne %r11b
movb (%rdi,%r11,4), %r11b
movb %r11b, (%r9)
decl %r10d
incq %r9
addq %rcx, %r8
cmpl $-0x4, %r10d
jne 0xd35d
movl %edx, %r9d
subl %r10d, %r9d
leal 0x1(%r9), %edx
sarq $0x20, %r8
movb $-0x1, (%rax,%r8)
incl %esi
cmpl $0x4, %esi
jne 0xd34f
incl %r9d
movslq %r9d, %rcx
movb $-0x1, 0x4(%rax,%rcx)
movl $0xffffffff, (%rax,%rcx) # imm = 0xFFFFFFFF
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3285c(%rip), %rsi     # 0x40dba
callq 0x70f0
testl %eax, %eax
je 0xe61b
leaq 0x32842(%rip), %rsi     # 0x40db4
movq %r14, %rdi
callq 0x70f0
testl %eax, %eax
je 0xe622
leaq 0x32826(%rip), %rsi     # 0x40daf
movq %r14, %rdi
callq 0x70f0
testl %eax, %eax
je 0xe629
leaq 0x32819(%rip), %rsi     # 0x40db9
movq %r14, %rdi
callq 0x70f0
movl $0x4, %ebx
testl %eax, %eax
je 0xe62b
leaq 0x327fb(%rip), %rsi     # 0x40db3
movq %r14, %rdi
callq 0x70f0
testl %eax, %eax
je 0xe62b
leaq 0x327ed(%rip), %rsi     # 0x40db8
movq %r14, %rdi
callq 0x70f0
testl %eax, %eax
je 0xe635
movq 0x45a0a(%rip), %r14     # 0x53fe8
leaq 0x327d9(%rip), %rsi     # 0x40dbe
movl $0x38, %edx
movq %r14, %rdi
callq 0x7340
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x72b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x71d0
jmp 0xe62b
movl $0x2, %ebx
jmp 0xe62b
movl $0x1, %ebx
jmp 0xe62b
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x3, %ebx
jmp 0xe62b
// File: /workspace/github_cpp_makefile_star2_O3/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 0x327ad(%rip), %rsi     # 0x40df7
callq 0x70f0
xorl %ebx, %ebx
testl %eax, %eax
je 0xe6cb
leaq 0x3279e(%rip), %rsi     # 0x40dfa
movq %r14, %rdi
callq 0x70f0
testl %eax, %eax
je 0xe6bf
leaq 0x3278e(%rip), %rsi     # 0x40dfd
movq %r14, %rdi
callq 0x70f0
testl %eax, %eax
je 0xe6c6
movq 0x45966(%rip), %r14     # 0x53fe8
leaq 0x32777(%rip), %rsi     # 0x40e00
movl $0x36, %edx
movq %r14, %rdi
callq 0x7340
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x72b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x71d0
jmp 0xe6cb
movl $0x1, %ebx
jmp 0xe6cb
movl $0x2, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
je 0xfc4d
sarq $0x5, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
addq $0x10, %rcx
movl $0x46, %eax
movl $0xf, %esi
cmpq -0x10(%rcx), %rcx
je 0xfc39
movq (%rcx), %rsi
addq %rsi, %rax
addq $0x20, %rcx
decq %rdx
jne 0xfc2b
addq $0xa9, %rax
jmp 0xfc52
movl $0xef, %eax
leaq 0x60(%rdi), %rdx
movq 0x70(%rdi), %rcx
movl $0xf, %esi
cmpq %rdx, 0x50(%rdi)
je 0xfc69
movq 0x60(%rdi), %rsi
movq 0xc8(%rdi), %rdx
subq 0xb8(%rdi), %rdx
addq 0x28(%rdi), %rax
subq 0x18(%rdi), %rax
sarq $0x4, %rdx
addq %rsi, %rax
addq 0x80(%rdi), %rax
addq 0x98(%rdi), %rax
addq 0x88(%rdi), %rcx
addq 0xe0(%rdi), %rax
addq 0xd0(%rdi), %rcx
addq 0xb0(%rdi), %rax
addq 0xa0(%rdi), %rcx
addq 0x110(%rdi), %rax
addq 0x100(%rdi), %rcx
leaq (%rdx,%rdx,2), %rdx
subq %rcx, %rax
leaq (%rax,%rdx,4), %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %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), %rcx
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
je 0xfd4c
movq %rcx, %r15
subq %rdx, %r15
testq %r15, %r15
jle 0xfd4c
xorl %r12d, %r12d
movq %r14, %rdi
movl $0x24, %esi
callq 0x7270
incq %r12
cmpq %r15, %r12
jl 0xfd30
movq 0xe8(%rbx), %rcx
testq %rcx, %rcx
jle 0xfd6d
xorl %r15d, %r15d
movq %r14, %rdi
movl $0x24, %esi
callq 0x7270
incq %r15
cmpq 0xe8(%rbx), %r15
jl 0xfd54
movq 0x58(%rbx), %rdx
movq %rdx, 0x38(%rbx)
movq 0x50(%rbx), %rsi
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xc2d0
movq %r15, %rdi
movq %r14, %rsi
callq 0x7200
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xfdb3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x72f0
movq 0x38(%rbx), %rax
cqto
idivq 0xe8(%rbx)
cvtsi2sd %rax, %xmm0
callq 0x7240
divsd 0x34476(%rip), %xmm0    # 0x44248
callq 0x70a0
cvttsd2si %xmm0, %rax
movq %rax, 0x40(%rbx)
movq 0x38(%rbx), %rax
cqto
idivq 0xe8(%rbx)
decq %rax
movq %rax, 0x48(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/readmapping[P]alfalfa/src/sparseSA.cpp
// Function: sparseSA::computeLCP()
void sparseSA::computeLCP() {
  long h=0;
  for(long i = 0; i < N; i+=K) {
    long m = ISA[i/K];
    if(m==0) LCP.set(m, 0); // LCP[m]=0;
    else {
      long j = SA[m-1];
      while(i+h < N && j+h < N && S[i+h] == S[j+h])  h++;
      LCP.set(m, h); //LCP[m] = h;
    }
    h = max(0L, h - K);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
jle 0x10480
movq %rdi, %rbx
leaq 0xa0(%rdi), %r14
movq 0xe8(%rdi), %rsi
xorl %r13d, %r13d
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %r15, %rax
cqto
idivq %rsi
movq 0x88(%rbx), %rdx
movslq (%rdx,%rax,4), %rsi
testq %rsi, %rsi
je 0x1044c
leaq (%r12,%r15), %rax
cmpq %rcx, %rax
jge 0x1043f
movq 0x70(%rbx), %rax
movl -0x4(%rax,%rsi,4), %eax
movq 0x50(%rbx), %rdi
movq %rcx, %rdx
subq %r15, %rdx
leaq (%rdi,%r15), %r8
addq %rax, %rdi
leaq (%rax,%r12), %r9
cmpq %rcx, %r9
jge 0x1043f
movb (%r8,%r12), %r9b
cmpb (%rdi,%r12), %r9b
jne 0x1043f
leaq (%r15,%r12), %r9
incq %r9
incq %r12
cmpq %rcx, %r9
jl 0x1041a
movq %rdx, %r12
movq %r14, %rdi
movl %r12d, %edx
callq 0x159a0
jmp 0x1045f
movq 0xa0(%rbx), %rax
cmpq %rax, 0xa8(%rbx)
je 0x1048a
movb $0x0, (%rax)
movq 0x38(%rbx), %rcx
movq 0xe8(%rbx), %rsi
subq %rsi, %r12
testq %r12, %r12
cmovleq %r13, %r12
addq %rsi, %r15
cmpq %rcx, %r15
jl 0x103e0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2ff72(%rip), %rdi     # 0x40403
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x74e0