LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/mikeakohn[P]drumsplusplus/build/../src/Song.cxx
// Function: Song::parse_define(Tokens*)
int Song::parse_define(Tokens *tokens)
{
  int token_type;
  char name[1024];
  char value[1024];

  token_type = tokens->get(name);

  if (token_type != TOKEN_ALPHA)
  {
    print_error(tokens, "define", name);
    return -1;
  }

  token_type = tokens->get(value);

  if (defines.find(name) != defines.end())
  {
    print_error(tokens, "already defined", name);
  }

  defines[name] = value;

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x820, %rsp            # imm = 0x820
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x2880
cmpl $0x1, %eax
jne 0x3bd5
leaq 0x420(%rsp), %rsi
movq %rbx, %rdi
callq 0x2880
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x20e0
leaq (%rsp,%rax), %rdx
addq $0x20, %rdx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x6180
leaq 0xa8(%r15), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x60f6
movq %rax, %r12
addq $0xb0, %r15
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3b39
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21b0
cmpq %r15, %r12
je 0x3b60
movq 0x8(%rbx), %rcx
movl 0x2c(%rbx), %r8d
leaq 0x3d9b(%rip), %rdi      # 0x78e8
leaq 0x39d2(%rip), %rsi      # 0x7526
leaq 0x20(%rsp), %rdx
xorl %eax, %eax
callq 0x2050
movq %rsp, %rbx
movq %r13, (%rbx)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x20e0
leaq (%rsp,%rax), %rdx
addq $0x20, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6180
movq %rsp, %rsi
movq %r14, %rdi
callq 0x5646
movq %rax, %rbx
movq 0x8(%rax), %r14
leaq 0x420(%rsp), %r15
movq %r15, %rdi
callq 0x20e0
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x22b0
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3bd1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21b0
xorl %eax, %eax
jmp 0x3bfc
movq 0x8(%rbx), %rcx
movl 0x2c(%rbx), %r8d
leaq 0x3d04(%rip), %rdi      # 0x78e8
leaq 0x3731(%rip), %rsi      # 0x731c
leaq 0x20(%rsp), %rdx
xorl %eax, %eax
callq 0x2050
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x820, %rsp            # imm = 0x820
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3c11
jmp 0x3c16
movq %rax, %rbx
jmp 0x3c2f
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3c2f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x27c8
leaq 0x400(%rsp), %rsi
movq %r14, %rdi
callq 0x2880
cmpl $0x4, %eax
jne 0x3d1c
movb $0x0, (%rsp)
cmpb $0x2f, 0x400(%rsp)
je 0x3cca
movq 0x8(%r14), %rsi
leaq 0x800(%rsp), %r12
movq %r12, %rdi
callq 0x2170
movq %r12, %rsi
callq 0x4eec
testq %rax, %rax
je 0x3cca
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 0x2808
testl %eax, %eax
je 0x3d55
movq 0x8(%r14), %rdx
movl 0x2c(%r14), %ecx
leaq 0x3844(%rip), %rdi      # 0x753f
movq %rsp, %rsi
xorl %eax, %eax
callq 0x2050
movq %rbx, %rdi
callq 0x27ec
movl $0x30, %esi
movq %rbx, %rdi
callq 0x21b0
jmp 0x3d41
movq 0x8(%r14), %rcx
movl 0x2c(%r14), %r8d
leaq 0x3bbd(%rip), %rdi      # 0x78e8
leaq 0x3804(%rip), %rsi      # 0x7536
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 0x35d8
cmpl $-0x1, %eax
je 0x3d41
movq %rbx, %rdi
callq 0x286a
movq %rbx, %rdi
callq 0x27ec
movl $0x30, %esi
movq %rbx, %rdi
callq 0x21b0
xorl %eax, %eax
jmp 0x3d46
movq %rax, %r14
movl $0x30, %esi
movq %rbx, %rdi
callq 0x21b0
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2baf(%rip), %rdi      # 0x793f
callq 0x22a0
movq 0xc0(%rbx), %r14
leaq 0xb0(%rbx), %r12
cmpq %r12, %r14
je 0x4dd1
leaq 0x259e(%rip), %r15      # 0x734d
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 0x4daf
leaq 0x2b70(%rip), %rdi      # 0x7948
callq 0x22a0
movq 0xf0(%rbx), %r14
leaq 0xe0(%rbx), %r12
cmpq %r12, %r14
je 0x4e19
leaq 0x2561(%rip), %r15      # 0x7358
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 0x4df7
movl 0x100(%rbx), %ebp
movl $0x0, 0xc(%rsp)
testl %ebp, %ebp
jle 0x4e67
leaq 0xd8(%rbx), %r14
leaq 0x78(%rbx), %r15
leaq 0xc(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x5566
movq %r15, %rdi
movq %rax, %rsi
callq 0x55ca
movq %rax, %rdi
callq 0x3156
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
cmpl %ebp, %eax
jl 0x4e3b
leaq 0x2ae4(%rip), %rdi      # 0x7952
callq 0x22a0
movq 0x60(%rbx), %r14
leaq 0x50(%rbx), %r12
cmpq %r12, %r14
je 0x4eae
leaq 0x24db(%rip), %r15      # 0x7362
movq 0x20(%r14), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2050
leaq 0x40(%r14), %rdi
callq 0x336a
movq %r14, %rdi
callq 0x2110
movq %rax, %r14
cmpq %r12, %rax
jne 0x4e87
movq (%rbx), %rsi
leaq 0x24b6(%rip), %rdi      # 0x736e
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_O1/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
testl %eax, %eax
js 0x4f20
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movzbl (%rbx,%rax), %ecx
cmpl $0x2f, %ecx
je 0x4f20
cmpl $0x5c, %ecx
je 0x4f20
leaq -0x1(%rax), %rcx
testq %rax, %rax
movq %rcx, %rax
jg 0x4f01
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x4f30
movl %eax, %ecx
leaq (%rbx,%rcx), %rax
movb $0x0, (%rbx,%rcx)
jmp 0x4f32
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6a9a
leaq 0x50(%rbx), %rcx
cmpq %rcx, %rax
je 0x5351
movq %r14, %rdi
movq %r15, %rsi
callq 0x573e
movq %rax, %r14
cmpl $0x1, 0x128(%rbx)
jne 0x52c6
movq (%r15), %rsi
leaq 0x25eb(%rip), %rdi      # 0x78aa
xorl %eax, %eax
callq 0x2050
movq (%r14), %r15
cmpq 0x8(%r14), %r15
setne %bpl
je 0x537a
leaq 0xd8(%rbx), %r12
leaq 0xe0(%rbx), %r13
movq 0xe8(%rbx), %rcx
movq %r13, %rax
testq %rcx, %rcx
je 0x5311
movl (%r15), %edx
movq %r13, %rax
xorl %esi, %esi
cmpl %edx, 0x20(%rcx)
setl %sil
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x52fa
movq %r13, %rcx
cmpq %r13, %rax
je 0x5326
movl (%r15), %ecx
cmpl 0x20(%rax), %ecx
cmovlq %r13, %rax
movq %rax, %rcx
cmpq %r13, %rcx
je 0x5369
movq %r12, %rdi
movq %r15, %rsi
callq 0x5566
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5392
addq $0x4, %r15
cmpq 0x8(%r14), %r15
setne %bpl
jne 0x52e5
jmp 0x537a
movq (%r15), %rsi
leaq 0x2534(%rip), %rdi      # 0x788f
xorl %eax, %eax
callq 0x2050
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x5383
movl (%r15), %esi
leaq 0x2544(%rip), %rdi      # 0x78b7
xorl %eax, %eax
callq 0x2050
movzbl %bpl, %eax
andl $0x1, %eax
negl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe02(%rip), %rdi       # 0x797a
xorl %eax, %eax
callq 0x2050
movl 0x20(%rbx), %esi
leaq 0xe05(%rip), %rdi       # 0x798e
xorl %eax, %eax
callq 0x2050
movl 0x24(%rbx), %esi
leaq 0xe08(%rip), %rdi       # 0x79a2
xorl %eax, %eax
callq 0x2050
movl 0x28(%rbx), %esi
leaq 0xe0b(%rip), %rdi       # 0x79b6
xorl %eax, %eax
callq 0x2050
movl 0x2c(%rbx), %esi
movl 0x30(%rbx), %edx
leaq 0xe0b(%rip), %rdi       # 0x79ca
xorl %eax, %eax
callq 0x2050
movl 0x34(%rbx), %esi
leaq 0xe11(%rip), %rdi       # 0x79e1
xorl %eax, %eax
popq %rbx
jmp 0x2050
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6bf4
btq %rdx, %rcx
jb 0x6c01
addb $-0x3a, %dl
cmpb $-0xa, %dl
jb 0x6c08
incq %rax
jmp 0x6be4
testq %rax, %rax
setne %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, %r12
movl %edi, %r14d
movq 0x2dae(%rip), %r15      # 0x3fd8
leaq 0xdd3(%rip), %rsi       # 0x2004
movl $0x1e, %edx
movq %r15, %rdi
callq 0x1080
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
leaq 0xdb7(%rip), %rsi       # 0x2023
movl $0x7, %edx
movq %r15, %rdi
callq 0x1080
movq %r15, %rdi
movl %r14d, %esi
callq 0x10c0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
leaq 0xd76(%rip), %rsi       # 0x202b
movl $0xa, %edx
movq %r15, %rdi
callq 0x1080
movq %r12, -0x38(%rbp)
movq (%r12), %rbx
testq %rbx, %rbx
je 0x12eb
movq %rbx, %rdi
callq 0x1040
movq 0x2cfa(%rip), %rdi      # 0x3fd8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1080
jmp 0x1303
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x10b0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
xorl %eax, %eax
cmpl $0x2, %r14d
jl 0x1400
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10a0
movl %eax, -0x2c(%rbp)
movl %r14d, %r15d
movl $0x1, %r14d
movq 0x2c82(%rip), %r12      # 0x3fd8
movl $0x5, %edx
movq %r12, %rdi
leaq 0xcd1(%rip), %rsi       # 0x2036
callq 0x1080
movq %r12, %rdi
movl %r14d, %esi
callq 0x10c0
movq %rax, %rbx
movl $0x4, %edx
movq %rax, %rdi
leaq 0xcaa(%rip), %rsi       # 0x2031
callq 0x1080
movq -0x38(%rbp), %rax
movq (%rax,%r14,8), %r13
testq %r13, %r13
je 0x13b1
movq %r13, %rdi
callq 0x1040
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1080
jmp 0x13ca
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %rbx, %rdi
addq %rax, %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x10b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
incq %r14
cmpq %r14, %r15
jne 0x1356
movl -0x2c(%rbp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2100
movq %rbx, %rdi
callq 0x20c0
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_O1/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 0x347a
movq -0x30(%rbp), %rax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, -0x30(%rbp)
xorl %eax, %eax
leaq -0x48(%rbp), %rbx
movq 0x7c75(%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 0x7084
movq -0x40(%rbp), %r12
subq -0x48(%rbp), %r12
sarq $0x3, %r12
movabsq $0x4ec4ec4ec4ec4ec5, %rax # imm = 0x4EC4EC4EC4EC4EC5
imulq %rax, %r12
testl %r12d, %r12d
jle 0x345d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movl $0x4, %edx
movq %r15, %rdi
leaq 0x4d55(%rip), %rsi      # 0x8114
callq 0x2160
movq -0x48(%rbp), %rdi
addq %r13, %rdi
callq 0x40f6
movq %r15, %rdi
movl %eax, %esi
callq 0x21c0
movl $0x7, %edx
movq %r15, %rdi
leaq 0x4d30(%rip), %rsi      # 0x8119
callq 0x2160
movq -0x48(%rbp), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0x40c8
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 0x3450
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2130
addq $0x68, %r13
decq %r12
jne 0x33b0
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0x389c
movq -0x78(%rbp), %rax
incq %rax
cmpq -0x30(%rbp), %rax
jne 0x3367
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x34a9
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x34ac
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2130
jmp 0x34ac
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x389c
movq %rbx, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movss %xmm0, -0x30(%rbp)
movl %r9d, -0x2c(%rbp)
movq %r8, -0x58(%rbp)
movl %ecx, -0x34(%rbp)
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
leaq 0x8(%rdi), %r13
leaq 0x18(%rdi), %rax
movq %rax, -0x48(%rbp)
movq %rax, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
addq $0x28, %rdi
movq %r13, -0x50(%rbp)
callq 0x246c
leaq 0x38(%r15), %r14
leaq 0x48(%r15), %rax
movq %rax, -0x40(%rbp)
movq %rax, 0x38(%r15)
movq $0x0, 0x40(%r15)
movb $0x0, 0x48(%r15)
movq %r13, %rdi
movq %r12, %rsi
callq 0x2090
movl 0x70f3(%rip), %eax      # 0xb120
incl %eax
movl %eax, 0x70eb(%rip)      # 0xb120
movl %eax, (%r15)
movq %rbx, 0x28(%r15)
movl -0x34(%rbp), %eax
movl %eax, 0x30(%r15)
movq %r14, %rdi
movq -0x58(%rbp), %rsi
callq 0x2090
movl -0x2c(%rbp), %eax
movl %eax, 0x58(%r15)
movss -0x30(%rbp), %xmm0
movss %xmm0, 0x5c(%r15)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4090
movq %rax, %rbx
movq (%r14), %rdi
cmpq -0x40(%rbp), %rdi
je 0x4090
movq -0x40(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2130
movq -0x50(%rbp), %rax
movq (%rax), %rdi
cmpq -0x48(%rbp), %rdi
je 0x40ac
movq -0x48(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4269
movq 0x6db6(%rip), %rbx      # 0xafd8
leaq 0x3f97(%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 0x42b6
movss 0x3f23(%rip), %xmm0     # 0x8194
ucomiss %xmm1, %xmm0
jae 0x429a
movss 0x3f1e(%rip), %xmm0     # 0x819c
ucomiss %xmm1, %xmm0
jae 0x42a4
movss 0x3f19(%rip), %xmm0     # 0x81a4
ucomiss %xmm1, %xmm0
jae 0x42ae
movss 0x3f10(%rip), %xmm0     # 0x81a8
jmp 0x42b6
movss 0x3eee(%rip), %xmm0     # 0x8190
jmp 0x42b6
movss 0x3eec(%rip), %xmm0     # 0x8198
jmp 0x42b6
movss 0x3eea(%rip), %xmm0     # 0x81a0
divss 0x3eee(%rip), %xmm0     # 0x81ac
mulss %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4329
movq 0x6cf6(%rip), %rbx      # 0xafd8
leaq 0x3ed7(%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 0x4380
movss 0x3e63(%rip), %xmm1     # 0x8194
ucomiss %xmm2, %xmm1
jae 0x4380
movss 0x3e5e(%rip), %xmm0     # 0x819c
ucomiss %xmm2, %xmm0
jae 0x436e
movss 0x3e59(%rip), %xmm0     # 0x81a4
ucomiss %xmm2, %xmm0
jae 0x4378
movss 0x3e5c(%rip), %xmm0     # 0x81b4
xorl %eax, %eax
ucomiss %xmm2, %xmm0
setb %al
leaq 0x3e51(%rip), %rcx      # 0x81b8
movss (%rcx,%rax,4), %xmm0
jmp 0x4380
movss 0x3e1a(%rip), %xmm0     # 0x8190
jmp 0x4380
movss 0x3e30(%rip), %xmm0     # 0x81b0
divss 0x3e24(%rip), %xmm0     # 0x81ac
mulss %xmm2, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a48
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_O1/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 0x6b79(%rip), %r14      # 0xafd8
movq %r14, %rdi
callq 0x21c0
leaq 0x3d6d(%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 0x3cf7(%rip), %rsi      # 0x81db
movl $0x3, %edx
movq %rax, %rdi
callq 0x2160
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x450a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2130
movl 0x58(%rbx), %esi
movq 0x6ac4(%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 0x456a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3ec6(%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 0x7165
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movq 0x30(%rbx), %rdi
addq %r14, %rdi
callq 0x4446
addq $0x68, %r14
decq %r15
jne 0x7150
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x71ce
movl %esi, %ebx
movq %rdi, %r14
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movq 0x30(%r14), %rdi
addq %r12, %rdi
callq 0x40f6
cmpl %ebx, %eax
jne 0x71c5
movq 0x30(%r14), %rdi
addq %r12, %rdi
callq 0x4446
addq $0x68, %r12
decq %r15
jne 0x71a9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x38(%rdi), %rax
subq 0x30(%rdi), %rax
sarq $0x3, %rax
movabsq $0x4ec4ec4ec4ec4ec5, %r12 # imm = 0x4EC4EC4EC4EC4EC5
imulq %rax, %r12
testl %r12d, %r12d
jle 0x7286
movq %rsi, %rbx
movq %rdi, %r14
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq 0x30(%r14), %rsi
addq %r13, %rsi
leaq -0x48(%rbp), %rdi
callq 0x40c8
movq -0x40(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x724b
testq %rdx, %rdx
je 0x7250
movq (%rbx), %rsi
movq -0x48(%rbp), %rdi
callq 0x2140
testl %eax, %eax
sete %r15b
jmp 0x7253
xorl %r15d, %r15d
jmp 0x7253
movb $0x1, %r15b
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x726c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2130
testb %r15b, %r15b
je 0x727d
movq 0x30(%r14), %rdi
addq %r13, %rdi
callq 0x4446
addq $0x68, %r13
decq %r12
jne 0x7218
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x73b7
movq %rdi, %rbx
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movq 0x3cfa(%rip), %r15      # 0xafd8
leaq 0xef6(%rip), %r13       # 0x81db
movq 0x30(%rbx), %rsi
addq %r12, %rsi
leaq -0x48(%rbp), %rdi
callq 0x40c8
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 0x732e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2130
movq 0x30(%rbx), %rdi
addq %r12, %rdi
callq 0x4144
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 0x4144
movq %r13, %rdi
callq 0x41d0
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 0xe3e(%rip), %r13       # 0x81db
callq 0x2030
movq %rax, %rdi
callq 0x20a0
addq $0x68, %r12
decq %r14
jne 0x72e5
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 0x73e2
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8bdc
movl %edi, %ebp
xorl %r14d, %r14d
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xaea6
movq 0x4b85e(%rip), %rdi     # 0x54400
movq %r12, %rsi
leaq 0x28(%rsp), %rdx
movq %r15, %rcx
callq 0x1a006
movl %eax, %r13d
testb %al, %al
je 0x8bc9
addl 0x30(%rsp), %r14d
movq %rbx, %rdi
movq %r12, %rsi
callq 0xaff4
movq %r12, %rdi
callq 0xb024
cmpl %ebp, %r14d
setl %al
testb %al, %r13b
jne 0x8b93
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 0xb024
movq %rbx, %rdi
callq 0x7600
// File: /workspace/github_cpp_makefile_star2_O1/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 0x918b
movq %rdi, %rbx
imulq $0xd0, %rsi, %rcx
leaq (%rax,%rcx), %r14
movq 0x8(%rax,%rcx), %rax
cmpq $0x3, %rax
jb 0x9077
movq (%r14), %rcx
cmpb $0x2f, -0x2(%rcx,%rax)
jne 0x9077
addq $-0x2, %rax
movq %rax, 0x8(%r14)
movb $0x0, (%rcx,%rax)
movq (%rbx), %rax
movzbl 0xf8(%rax), %esi
movq %r14, %rdi
callq 0xc10c
movq (%rbx), %rax
cmpl $0x3, 0x178(%rax)
jl 0x910c
movq 0x4af4c(%rip), %r15     # 0x53fe8
leaq 0x37348(%rip), %rsi     # 0x403eb
movl $0x6, %edx
movq %r15, %rdi
callq 0x7340
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x7340
movq %rax, %r15
leaq 0x37329(%rip), %rsi     # 0x403f2
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), %rax
cmpl $0x2, 0x178(%rax)
jl 0x915a
movq 0x4aec9(%rip), %r15     # 0x53fe8
leaq 0x372da(%rip), %rsi     # 0x40400
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 0x8(%rbx), %rdi
movl $0x100, %r15d           # imm = 0x100
movq (%rbx), %rdx
addq %r15, %rdx
movq %r14, %rsi
callq 0x2522d
movq 0x8(%rbx), %rsi
addq (%rbx), %r15
movq %r14, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x20898
leaq 0x37274(%rip), %rdi     # 0x40406
xorl %eax, %eax
callq 0x74e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x925e
movl %edi, %ebp
xorl %r15d, %r15d
leaq 0x18(%rsp), %r14
leaq 0xe8(%rsp), %r12
movq %r14, %rdi
callq 0xaea6
movq %r12, %rdi
callq 0xaea6
movq 0x4b233(%rip), %rdi     # 0x54418
movq %r14, %rsi
leaq 0x38(%rsp), %rdx
leaq 0x58(%rsp), %rcx
callq 0x1a006
movq 0x4b222(%rip), %rdi     # 0x54420
movq %r12, %rsi
leaq 0x108(%rsp), %rdx
leaq 0x128(%rsp), %rcx
callq 0x1a006
movl %eax, %r13d
testb %al, %al
je 0x923f
movq 0x40(%rsp), %rbx
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xaff4
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0xaff4
addl %ebx, %r15d
movq %r12, %rdi
callq 0xb024
movq %r14, %rdi
callq 0xb024
cmpl %ebp, %r15d
setl %al
testb %r13b, %al
jne 0x91ce
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 0x929b
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0xb024
leaq 0x18(%rsp), %rdi
callq 0xb024
movq %rbx, %rdi
callq 0x7600
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb05a
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 0xb130
xorl %r15d, %r15d
movq (%rdi,%r15,8), %r14
testq %r14, %r14
je 0xb10f
movq 0xe8(%r14), %rdi
testq %rdi, %rdi
je 0xb099
movq 0xf8(%r14), %rsi
subq %rdi, %rsi
callq 0x72f0
movq 0xa8(%r14), %rdi
leaq 0xb8(%r14), %rax
cmpq %rax, %rdi
je 0xb0b7
movq (%rax), %rsi
incq %rsi
callq 0x72f0
movq 0x78(%r14), %rdi
leaq 0x88(%r14), %rax
cmpq %rax, %rdi
je 0xb0d2
movq (%rax), %rsi
incq %rsi
callq 0x72f0
movq 0x48(%r14), %rdi
leaq 0x58(%r14), %rax
cmpq %rax, %rdi
je 0xb0ea
movq (%rax), %rsi
incq %rsi
callq 0x72f0
movq 0x20(%r14), %rdi
leaq 0x30(%r14), %rax
cmpq %rax, %rdi
je 0xb102
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 0xb071
testq %rdi, %rdi
je 0xb144
movq 0xc0(%rbx), %rsi
subq %rdi, %rsi
callq 0x72f0
movq 0x80(%rbx), %rdi
leaq 0x90(%rbx), %rax
cmpq %rax, %rdi
je 0xb162
movq (%rax), %rsi
incq %rsi
callq 0x72f0
movq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0xb17a
movq (%rax), %rsi
incq %rsi
callq 0x72f0
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0xb192
movq (%rax), %rsi
incq %rsi
callq 0x72f0
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0xb1aa
movq (%rax), %rsi
incq %rsi
callq 0x72f0
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0xb1c6
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_O1/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 0x357f3(%rip), %rsi     # 0x40a1d
movl $0x1, %edx
movq %rax, %rdi
callq 0x7340
movq %r15, %rdi
movl %ebp, %esi
callq 0x75d0
movq %rax, %r15
leaq 0x35205(%rip), %rsi     # 0x40450
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 0x357ab(%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 0x48ccb(%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 0x48c9b(%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_O1/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 0x34e11(%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 0x34a71(%rip), %rcx     # 0x406e6
movl $0x2, %r8d
xorl %esi, %esi
callq 0x7510
leaq 0xf8(%rbx), %rdi
movq 0x100(%rbx), %rdx
leaq 0x34a52(%rip), %rcx     # 0x406e9
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_O1/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 0x1ee27
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 0xc187
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 0xc16c
movq 0x28(%rbx), %r14
movq %r14, %rdi
callq 0x7430
movq %rax, 0xa0(%rbx)
movq %r14, %rdi
callq 0x7430
movq %rax, 0xa8(%rbx)
cmpq $0x0, 0x28(%rbx)
je 0xc1ee
xorl %eax, %eax
leaq 0x34557(%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 0xc1b9
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd441
movl %edx, %r9d
subl %r10d, %r9d
leal 0x1(%r9), %edx
sarq $0x20, %r8
movb $-0x1, 0x10(%rdi,%r8)
incl %esi
cmpl $0x4, %esi
jne 0xd433
incl %r9d
movslq %r9d, %rax
movb $-0x1, 0x14(%rdi,%rax)
movl $0xffffffff, 0x10(%rdi,%rax) # imm = 0xFFFFFFFF
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32776(%rip), %rsi     # 0x40dba
callq 0x70f0
testl %eax, %eax
je 0xe701
leaq 0x3275c(%rip), %rsi     # 0x40db4
movq %r14, %rdi
callq 0x70f0
testl %eax, %eax
je 0xe708
leaq 0x32740(%rip), %rsi     # 0x40daf
movq %r14, %rdi
callq 0x70f0
testl %eax, %eax
je 0xe70f
leaq 0x32733(%rip), %rsi     # 0x40db9
movq %r14, %rdi
callq 0x70f0
movl $0x4, %ebx
testl %eax, %eax
je 0xe711
leaq 0x32715(%rip), %rsi     # 0x40db3
movq %r14, %rdi
callq 0x70f0
testl %eax, %eax
je 0xe711
leaq 0x32707(%rip), %rsi     # 0x40db8
movq %r14, %rdi
callq 0x70f0
testl %eax, %eax
je 0xe71b
movq 0x45924(%rip), %r14     # 0x53fe8
leaq 0x326f3(%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 0xe711
movl $0x2, %ebx
jmp 0xe711
movl $0x1, %ebx
jmp 0xe711
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x3, %ebx
jmp 0xe711