LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: vividvilla[P]hackerrank/src/flowers.cpp
// Function: main
int main() {
    int N, K, f;
    cin >> N >> K;

    vector<int> flowers;
    for (int i = 0; i < N; i++) {
        cin >> f;
        flowers.push_back(f);
    }

    cout << getMinimumPrice(flowers, K) << endl;

    return 0;
}

// Assembly:
subq $0x68, %rsp
movl $0x0, 0x64(%rsp)
movq 0x5b6d(%rip), %rdi      # 0x6fe0
leaq 0x60(%rsp), %rsi
callq 0x1070
movq %rax, %rdi
leaq 0x5c(%rsp), %rsi
callq 0x1070
leaq 0x40(%rsp), %rdi
callq 0x1770
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x60(%rsp), %eax
jge 0x14ec
movq 0x5b33(%rip), %rdi      # 0x6fe0
leaq 0x58(%rsp), %rsi
callq 0x1070
jmp 0x14b9
leaq 0x40(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x1780
jmp 0x14ca
jmp 0x14cc
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x149c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x1576
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x17f0
jmp 0x14fd
movl 0x5c(%rsp), %esi
leaq 0x10(%rsp), %rdi
callq 0x1250
movl %eax, 0xc(%rsp)
jmp 0x1511
movl 0xc(%rsp), %esi
movq 0x5ab4(%rip), %rdi      # 0x6fd0
callq 0x10f0
movq %rax, (%rsp)
jmp 0x1527
movq (%rsp), %rdi
movq 0x5a8e(%rip), %rsi      # 0x6fc0
callq 0x10c0
jmp 0x1539
leaq 0x10(%rsp), %rdi
callq 0x1710
movl $0x0, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1710
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x1710
leaq 0x40(%rsp), %rdi
callq 0x1710
movq 0x30(%rsp), %rdi
callq 0x1100
nopw (%rax,%rax)
// File: mikeakohn[P]drumsplusplus/build/../src/Tokens.cxx
// Function: Tokens::open(char const*)
int Tokens::open(const char *filename)
{
  in = fopen(filename, "rb");

  if (in == NULL)
  {
    return -1;
  }

  this->filename = filename;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xd72d(%rip), %rsi      # 0x101c0
callq 0x22b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x2ab1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2ac9
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rdi
callq 0x2300
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mikeakohn[P]drumsplusplus/build/../src/MidiFile.cxx
// Function: MidiFile::open(char const*)
int MidiFile::open(const char *filename)
{
  out = fopen(filename, "wb");

  if (out == NULL)
  {
    printf("Couldn't open file %s for output.\n", filename);
    return -1;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xd2cd(%rip), %rsi      # 0x10280
callq 0x22b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x2fe3
movq -0x18(%rbp), %rsi
leaq 0xd2b0(%rip), %rdi      # 0x10283
movb $0x0, %al
callq 0x2060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2fea
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mikeakohn[P]drumsplusplus/build/../src/MidiFile.cxx
// Function: MidiFile::write_header(SongInfo*)
void MidiFile::write_header(SongInfo *song_info)
{
  const char *info = "Created by Drums++ 2.0 (http://dpp.mikekohn.net/).";

  if (!is_open()) { return; }

  fprintf(out, "MThd");
  write_int32(6);
  write_int16(0);
  write_int16(1);
  write_int16(DIVISIONS);

  fprintf(out,"MTrk");
  marker = ftell(out);
  write_int32(0);

  if (song_info->song_name != "")
  {
    write_var(0);
    putc(0xff, out);
    putc(0x03, out);
    write_var(song_info->song_name.size());
    fprintf(out, "%s", song_info->song_name.c_str());
  }

  write_var(0);
  putc(0xff, out);
  putc(0x01, out);
  write_var(strlen(info));
  fprintf(out,"%s", info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0xd257(%rip), %rax      # 0x102a6
movq %rax, -0x18(%rbp)
callq 0x29d0
testb $0x1, %al
jne 0x3061
jmp 0x31b5
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0xd26a(%rip), %rsi      # 0x102d9
movb $0x0, %al
callq 0x2340
movq -0x20(%rbp), %rdi
movl $0x6, %esi
callq 0x31c0
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x3240
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x3240
movq -0x20(%rbp), %rdi
movl $0xf0, %esi
callq 0x3240
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0xd225(%rip), %rsi      # 0x102de
movb $0x0, %al
callq 0x2340
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x20(%rbp), %rdi
movq %rax, 0x8(%rdi)
xorl %esi, %esi
callq 0x31c0
movq -0x10(%rbp), %rdi
leaq 0xd073(%rip), %rsi      # 0x10159
callq 0x36e0
testb $0x1, %al
jne 0x30f1
jmp 0x315b
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x3290
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl $0xff, %edi
callq 0x2400
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl $0x3, %edi
callq 0x2400
movq -0x10(%rbp), %rdi
callq 0x2180
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x3290
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2100
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0xd834(%rip), %rsi      # 0x10988
movb $0x0, %al
callq 0x2340
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x3290
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl $0xff, %edi
callq 0x2400
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl $0x1, %edi
callq 0x2400
movq -0x18(%rbp), %rdi
callq 0x2120
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x3290
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0xd7da(%rip), %rsi      # 0x10988
movb $0x0, %al
callq 0x2340
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mikeakohn[P]drumsplusplus/build/../src/MidiFile.cxx
// Function: MidiFile::write_int32(int)
int MidiFile::write_int32(int n)
{
  putc(((n >> 24) & 0xff), out);
  putc(((n >> 16) & 0xff), out);
  putc(((n >> 8) & 0xff), out);
  putc((n & 0xff), out);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
sarl $0x18, %edi
andl $0xff, %edi
movq (%rax), %rsi
callq 0x2400
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edi
sarl $0x10, %edi
andl $0xff, %edi
movq (%rax), %rsi
callq 0x2400
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edi
sarl $0x8, %edi
andl $0xff, %edi
movq (%rax), %rsi
callq 0x2400
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edi
andl $0xff, %edi
movq (%rax), %rsi
callq 0x2400
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mikeakohn[P]drumsplusplus/build/../src/MidiFile.cxx
// Function: MidiFile::write_var(int)
void MidiFile::write_var(int i)
{
  int t, k;

  t = 7;

  while ((i >> t) != 0)
  {
    t = t + 7;
  }

  t = t - 7;

  for (k = t; k >= 0; k = k - 7)
  {
    if (k != 0)
    {
      putc(((i >> k) & 127) + 128, out);
    }
      else
    {
      putc(((i >> k) & 127), out);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x7, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
sarl %cl, %eax
cmpl $0x0, %eax
je 0x32c6
movl -0x10(%rbp), %eax
addl $0x7, %eax
movl %eax, -0x10(%rbp)
jmp 0x32ae
movl -0x10(%rbp), %eax
subl $0x7, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x3324
cmpl $0x0, -0x14(%rbp)
je 0x3300
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %edi
movl -0x14(%rbp), %ecx
sarl %cl, %edi
andl $0x7f, %edi
addl $0x80, %edi
movq (%rax), %rsi
callq 0x2400
jmp 0x3317
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %edi
movl -0x14(%rbp), %ecx
sarl %cl, %edi
andl $0x7f, %edi
movq (%rax), %rsi
callq 0x2400
jmp 0x3319
movl -0x14(%rbp), %eax
subl $0x7, %eax
movl %eax, -0x14(%rbp)
jmp 0x32d5
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mikeakohn[P]drumsplusplus/build/../src/MidiFile.cxx
// Function: MidiFile::write_note(SongInfo*, Note*)
void MidiFile::write_note(SongInfo *song_info, Note *note)
{
  int d;

  if (!is_open()) { return; }

  d = (int)((float)DIVISIONS * ((float)note->duration / (float)(60000000 / song_info->bpm)));

  write_var(0);
  putc(0x90 + note->midi_channel, out);

  putc(note->value, out);
  putc(note->volume, out);

  /* if (d != 0 || 1 == 1) */
  {
    write_var(d);
    putc(0x80 + note->midi_channel, out);
    putc(note->value, out);
    /* putc(0, out); */
    putc(64, out);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x29d0
testb $0x1, %al
jne 0x335a
jmp 0x341e
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
cvtsi2ssl 0x8(%rax), %xmm1
movq -0x10(%rbp), %rcx
movl $0x3938700, %eax        # imm = 0x3938700
cltd
idivl 0x20(%rcx)
cvtsi2ss %eax, %xmm0
divss %xmm0, %xmm1
movss 0xce78(%rip), %xmm0     # 0x101fc
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
xorl %esi, %esi
callq 0x3290
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %edi
addl $0x90, %edi
movq (%rax), %rsi
callq 0x2400
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %edi
movq (%rax), %rsi
callq 0x2400
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %edi
movq (%rax), %rsi
callq 0x2400
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3290
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %edi
addl $0x80, %edi
movq (%rax), %rsi
callq 0x2400
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %edi
movq (%rax), %rsi
callq 0x2400
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movl $0x40, %edi
callq 0x2400
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mikeakohn[P]drumsplusplus/build/../src/MidiFile.cxx
// Function: MidiFile::write_footer()
void MidiFile::write_footer()
{
  int i;

  if (!is_open()) { return; }

  write_var(0);
  putc(0xff, out);
  putc(0x2f, out);
  putc(0x00, out);

  i = ftell(out);
  fseek(out, marker, 0);
  write_int32((i - marker) - 4);
  fseek(out, i, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x29d0
testb $0x1, %al
jne 0x3452
jmp 0x34da
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x3290
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl $0xff, %edi
callq 0x2400
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl $0x2f, %edi
callq 0x2400
movq -0x18(%rbp), %rax
movq (%rax), %rsi
xorl %edi, %edi
callq 0x2400
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl %ecx, -0xc(%rbp)
movq (%rax), %rdi
movq 0x8(%rax), %rsi
xorl %edx, %edx
callq 0x2290
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
subq 0x8(%rdi), %rax
subq $0x4, %rax
movl %eax, %esi
callq 0x31c0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movslq -0xc(%rbp), %rsi
xorl %edx, %edx
callq 0x2290
addq $0x20, %rsp
popq %rbp
retq
// File: mikeakohn[P]drumsplusplus/build/../src/MidiFile.cxx
// Function: MidiFile::write_bpm(SongInfo*)
void MidiFile::write_bpm(SongInfo *song_info)
{
  int d;

  if (!is_open()) { return; }

  write_var(0);
  putc(0xff, out);
  putc(0x51, out);
  putc(0x03, out);
  d = 60000000 / song_info->bpm;
  putc(d >> 16, out);
  putc((d >> 8) & 0xff,out);
  putc(d & 0xff, out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x29d0
testb $0x1, %al
jne 0x3506
jmp 0x3595
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x3290
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl $0xff, %edi
callq 0x2400
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl $0x51, %edi
callq 0x2400
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl $0x3, %edi
callq 0x2400
movq -0x10(%rbp), %rcx
movl $0x3938700, %eax        # imm = 0x3938700
cltd
idivl 0x20(%rcx)
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x14(%rbp)
movl -0x14(%rbp), %edi
sarl $0x10, %edi
movq (%rax), %rsi
callq 0x2400
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %edi
sarl $0x8, %edi
andl $0xff, %edi
movq (%rax), %rsi
callq 0x2400
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %edi
andl $0xff, %edi
movq (%rax), %rsi
callq 0x2400
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mikeakohn[P]drumsplusplus/build/../src/MidiFile.cxx
// Function: MidiFile::write_time_signature(SongInfo*)
void MidiFile::write_time_signature(SongInfo *song_info)
{
  int d;

  if (!is_open()) { return; }

  d = song_info->time_signature_base;

  switch (song_info->time_signature_base)
  {
    case 32: d = 5; break;
    case 16: d = 4; break;
    case  8: d = 3; break;
    case  4: d = 2; break;
    case  2: d = 1; break;
    case  1: d = 0; break;
    default: return;
  }

  write_var(0);
  putc(0xff, out);
  putc(0x58, out);
  putc(0x04, out);

  putc(song_info->time_signature_beats, out);
  putc(d, out);

  if (d == 3)
  {
    putc(DIVISIONS / 3, out);
  }
    else
  {
    putc(DIVISIONS, out);
  }

  putc(8, out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x29d0
testb $0x1, %al
jne 0x35c6
jmp 0x36ce
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x1f, %eax
ja 0x362e
movq -0x28(%rbp), %rax
leaq 0xcc11(%rip), %rcx      # 0x10200
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x5, -0x14(%rbp)
jmp 0x3633
movl $0x4, -0x14(%rbp)
jmp 0x3633
movl $0x3, -0x14(%rbp)
jmp 0x3633
movl $0x2, -0x14(%rbp)
jmp 0x3633
movl $0x1, -0x14(%rbp)
jmp 0x3633
movl $0x0, -0x14(%rbp)
jmp 0x3633
jmp 0x36ce
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x3290
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl $0xff, %edi
callq 0x2400
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl $0x58, %edi
callq 0x2400
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl $0x4, %edi
callq 0x2400
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x2c(%rcx), %edi
movq (%rax), %rsi
callq 0x2400
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %edi
movq (%rax), %rsi
callq 0x2400
cmpl $0x3, -0x14(%rbp)
jne 0x36ac
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl $0x50, %edi
callq 0x2400
jmp 0x36bd
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl $0xf0, %edi
callq 0x2400
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl $0x8, %edi
callq 0x2400
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: mikeakohn[P]drumsplusplus/build/../src/MidiPlayer.cxx
// Function: MidiPlayer::open(char const*)
int MidiPlayer::open(const char *filename)
{
#ifndef WINDOWS
    midiout = ::open(filename, O_WRONLY, 0);

    if (midiout < 0)
    {
      printf("Error opening up sequencer.\n");
      return -1;
    }
#else
    int result = midiOutOpen(&inHandle, (UINT) -1, 0, 0, CALLBACK_NULL);

    if (result)
    {
      printf("Couldn't open MIDI device.\n");
      return -1;
    }
#endif

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x21a0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, (%rax)
jge 0x37be
leaq 0xcb35(%rip), %rdi      # 0x102e3
movb $0x0, %al
callq 0x2060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37c5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: mikeakohn[P]drumsplusplus/build/../src/MidiPlayer.cxx
// Function: MidiPlayer::play(unsigned char*, int)
void MidiPlayer::play(uint8_t *midi_data, int length)
{
#ifndef WINDOWS
  //if (pattern_volume[ptr] != 0)
  {
    int n = 0;

    while (n < length)
    {
      int i = write(midiout, midi_data + n, length - n);
      if (i < 0) { break; }
      n += i;
    }
  }
#else
  for (r = 0; r < length; r = r + 3)
  {
    n = midi_data[r] + (midi_data[r + 1] << 8) + (midi_data[r + 2] << 16);
    midiOutShortMsg(inHandle, n);
  }
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x382f
movq -0x28(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rax
addq %rax, %rsi
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
movslq %eax, %rdx
callq 0x20d0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x3824
jmp 0x382f
movl -0x1c(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x37f2
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mikeakohn[P]drumsplusplus/build/../src/Pattern.cxx
// Function: Pattern::add(unsigned char, unsigned char, unsigned char, unsigned int)
void Pattern::add(
  uint8_t value,
  uint8_t volume,
  uint8_t channel,
  uint32_t duration)
{
  Data current;

  current.value = value;
  current.volume = volume;
  current.channel = channel;
  current.duration = duration;

  data.push_back(current);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x8(%rbp)
movb %dl, -0x9(%rbp)
movb %cl, -0xa(%rbp)
movb %al, -0xb(%rbp)
movl %r8d, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3a70
movq -0x20(%rbp), %rdi
movb -0x9(%rbp), %al
movb %al, -0x18(%rbp)
movb -0xa(%rbp), %al
movb %al, -0x17(%rbp)
movb -0xb(%rbp), %al
movb %al, -0x16(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
addq $0x20, %rdi
leaq -0x18(%rbp), %rsi
callq 0x3a90
addq $0x20, %rsp
popq %rbp
retq
// File: mikeakohn[P]drumsplusplus/build/../src/Pattern.cxx
// Function: Pattern::print()
void Pattern::print()
{
  printf("  -- Pattern %s -- \n", name.c_str());

  for (auto it = data.begin(); it != data.end(); it++)
  {
    printf("   value: %d, volume: %d, channel: %d, duration: %d\n",
      it->value,
      it->volume,
      it->channel,
      it->duration);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x2100
movq %rax, %rsi
leaq 0xc9bd(%rip), %rdi      # 0x10300
movb $0x0, %al
callq 0x2060
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x3b00
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x3b70
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3b30
testb $0x1, %al
jne 0x397f
jmp 0x39e6
leaq -0x10(%rbp), %rdi
callq 0x3ba0
movzbl (%rax), %eax
movl %eax, -0x34(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3ba0
movzbl 0x1(%rax), %eax
movl %eax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3ba0
movzbl 0x2(%rax), %eax
movl %eax, -0x2c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3ba0
movl -0x34(%rbp), %esi
movl -0x30(%rbp), %edx
movl -0x2c(%rbp), %ecx
movl 0x4(%rax), %r8d
leaq 0xc94a(%rip), %rdi      # 0x10315
movb $0x0, %al
callq 0x2060
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3bc0
movq %rax, -0x20(%rbp)
jmp 0x395b
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mikeakohn[P]drumsplusplus/build/../src/Section.cxx
// Function: Section::print()
void Section::print()
{
  printf("  -- Section -- \n");

  for (auto it = patterns.begin(); it != patterns.end(); it++)
  {
    printf(" %d", *it);
  }

  printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0xbc99(%rip), %rdi      # 0x10364
movb $0x0, %al
callq 0x2060
movq -0x28(%rbp), %rdi
callq 0x4830
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
callq 0x48a0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4860
testb $0x1, %al
jne 0x46ff
jmp 0x4729
leaq -0x10(%rbp), %rdi
callq 0x48d0
movl (%rax), %esi
leaq 0xbc65(%rip), %rdi      # 0x10376
movb $0x0, %al
callq 0x2060
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x48f0
movq %rax, -0x20(%rbp)
jmp 0x46df
leaq 0xba28(%rip), %rdi      # 0x10158
movb $0x0, %al
callq 0x2060
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x8e0, %rsp            # imm = 0x8E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x898(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x2b10
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
je 0x5aa1
movq -0x898(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x420(%rbp), %rcx
leaq 0xa8f4(%rip), %rdx      # 0x10384
callq 0x7e10
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5cc0
movq -0x18(%rbp), %rdi
leaq -0x820(%rbp), %rsi
callq 0x2b10
movl %eax, %ecx
movq -0x898(%rbp), %rax
movl %ecx, -0x1c(%rbp)
addq $0xa8, %rax
movq %rax, -0x8a8(%rbp)
leaq -0x849(%rbp), %rdi
movq %rdi, -0x8a0(%rbp)
callq 0x23d0
movq -0x8a0(%rbp), %rdx
leaq -0x848(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x8f10
jmp 0x5af9
movq -0x8a8(%rbp), %rdi
leaq -0x848(%rbp), %rsi
callq 0x8ee0
movq %rax, -0x8b0(%rbp)
jmp 0x5b15
movq -0x898(%rbp), %rdi
movq -0x8b0(%rbp), %rax
movq %rax, -0x828(%rbp)
addq $0xa8, %rdi
callq 0x8a70
movq %rax, -0x868(%rbp)
leaq -0x828(%rbp), %rdi
leaq -0x868(%rbp), %rsi
callq 0x8a40
movb %al, -0x8b1(%rbp)
leaq -0x848(%rbp), %rdi
callq 0x2150
leaq -0x849(%rbp), %rdi
callq 0x2260
movb -0x8b1(%rbp), %al
testb $0x1, %al
jne 0x5b7a
jmp 0x5bdd
movq -0x898(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x420(%rbp), %rcx
leaq 0xaa37(%rip), %rdx      # 0x105ca
callq 0x7e10
jmp 0x5bdd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
jmp 0x5bcc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
leaq -0x848(%rbp), %rdi
callq 0x2150
leaq -0x849(%rbp), %rdi
callq 0x2260
jmp 0x5ccc
movq -0x898(%rbp), %rax
leaq -0x820(%rbp), %rcx
movq %rcx, -0x8d0(%rbp)
addq $0xa8, %rax
movq %rax, -0x8c8(%rbp)
leaq -0x889(%rbp), %rdi
movq %rdi, -0x8c0(%rbp)
callq 0x23d0
movq -0x8c0(%rbp), %rdx
leaq -0x888(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x8f10
jmp 0x5c2e
movq -0x8c8(%rbp), %rdi
leaq -0x888(%rbp), %rsi
callq 0x8fc0
movq %rax, -0x8d8(%rbp)
jmp 0x5c4a
movq -0x8d0(%rbp), %rsi
movq -0x8d8(%rbp), %rdi
callq 0x2300
jmp 0x5c5f
leaq -0x888(%rbp), %rdi
callq 0x2150
leaq -0x889(%rbp), %rdi
callq 0x2260
movl $0x0, -0x4(%rbp)
jmp 0x5cc0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
jmp 0x5cb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
leaq -0x888(%rbp), %rdi
callq 0x2150
leaq -0x889(%rbp), %rdi
callq 0x2260
jmp 0x5ccc
movl -0x4(%rbp), %eax
addq $0x8e0, %rsp            # imm = 0x8E0
popq %rbp
retq
movq -0x858(%rbp), %rdi
callq 0x23c0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2120
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x7ed1
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x7ec4
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x7ec6
jmp 0x7ed1
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7e9c
cmpl $0x0, -0x1c(%rbp)
jge 0x7ee1
movq $0x0, -0x8(%rbp)
jmp 0x7efc
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x48, %rdi
movq -0x18(%rbp), %rsi
callq 0x9440
movq -0x70(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x48, %rdi
callq 0x8e30
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9470
testb $0x1, %al
jne 0x8450
jmp 0x8476
movq -0x18(%rbp), %rdi
callq 0x2100
movq %rax, %rsi
leaq 0x84d6(%rip), %rdi      # 0x10939
movb $0x0, %al
callq 0x2060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x85b1
movq -0x70(%rbp), %rdi
addq $0x48, %rdi
movq -0x18(%rbp), %rsi
callq 0x9300
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x30(%rbp)
cmpl $0x1, 0x128(%rax)
jne 0x84b5
movq -0x18(%rbp), %rdi
callq 0x2100
movq %rax, %rsi
leaq 0x84a6(%rip), %rdi      # 0x10954
movb $0x0, %al
callq 0x2060
movq -0x30(%rbp), %rdi
callq 0x94a0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4830
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x48a0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4860
testb $0x1, %al
jne 0x84f2
jmp 0x85aa
movq -0x70(%rbp), %rax
addq $0xd8, %rax
movq %rax, -0x78(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x48d0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x94e0
movq -0x70(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0xd8, %rdi
callq 0x8b60
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x94b0
testb $0x1, %al
jne 0x8540
jmp 0x8562
leaq -0x40(%rbp), %rdi
callq 0x48d0
movl (%rax), %esi
leaq 0x840f(%rip), %rdi      # 0x10961
movb $0x0, %al
callq 0x2060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x85b1
movq -0x70(%rbp), %rax
addq $0xd8, %rax
movq %rax, -0x80(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x48d0
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x8c10
movq -0x70(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
callq 0x85c0
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x48f0
movq %rax, -0x68(%rbp)
jmp 0x84cf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2100
movq %rax, %rsi
leaq 0x15f1(%rip), %rdi      # 0x109f4
movb $0x0, %al
callq 0x2060
movq -0x10(%rbp), %rax
movl 0x20(%rax), %esi
leaq 0x15f0(%rip), %rdi      # 0x10a08
movb $0x0, %al
callq 0x2060
movq -0x10(%rbp), %rax
movl 0x24(%rax), %esi
leaq 0x15ef(%rip), %rdi      # 0x10a1c
movb $0x0, %al
callq 0x2060
movq -0x10(%rbp), %rax
movl 0x28(%rax), %esi
leaq 0x15ee(%rip), %rdi      # 0x10a30
movb $0x0, %al
callq 0x2060
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %esi
movl 0x30(%rax), %edx
leaq 0x15ea(%rip), %rdi      # 0x10a44
movb $0x0, %al
callq 0x2060
movq -0x10(%rbp), %rax
movl 0x34(%rax), %esi
leaq 0x15ec(%rip), %rdi      # 0x10a5b
movb $0x0, %al
callq 0x2060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x20, %ecx
movb %al, -0x15(%rbp)
je 0xf502
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x9, %ecx
movb %al, -0x15(%rbp)
je 0xf502
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x16(%rbp)
je 0xf4fc
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0xd, %ecx
movb %al, -0x16(%rbp)
je 0xf4fc
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xf50b
jmp 0xf541
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0xf52d
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jle 0xf533
movb $0x0, -0x1(%rbp)
jmp 0xf54f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf48f
movl -0x14(%rbp), %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x2deb(%rip), %rdi      # 0x3fd8
leaq 0xe10(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movq 0x2dc5(%rip), %rsi      # 0x3fc8
callq 0x1050
movq 0x2dc9(%rip), %rdi      # 0x3fd8
leaq 0xe0d(%rip), %rsi       # 0x2023
callq 0x1040
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x1080
movq %rax, %rdi
movq 0x2d98(%rip), %rsi      # 0x3fc8
callq 0x1050
movq 0x2d9c(%rip), %rdi      # 0x3fd8
leaq 0xde8(%rip), %rsi       # 0x202b
callq 0x1040
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1040
movq %rax, %rdi
movq 0x2d67(%rip), %rsi      # 0x3fc8
callq 0x1050
movl $0x0, -0x14(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x12ef
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1070
movl %eax, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x12ed
movq 0x2d3f(%rip), %rdi      # 0x3fd8
leaq 0xd96(%rip), %rsi       # 0x2036
callq 0x1040
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x1080
movq %rax, %rdi
leaq 0xd77(%rip), %rsi       # 0x2031
callq 0x1040
movq %rax, %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1040
movq %rax, %rdi
movq 0x2ceb(%rip), %rsi      # 0x3fc8
callq 0x1050
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x128a
jmp 0x12ef
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x40, %rsp
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x21a0
movq -0x38(%rbp), %rdi
callq 0x2130
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
movl 0x10(%rax), %edx
incl %edx
movl 0x14(%rax), %ecx
addl $0x76c, %ecx            # imm = 0x76C
leaq -0xc(%rbp), %rdi
callq 0x2580
movl -0x4(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl -0x28(%rbp), %edx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x20, %rdi
callq 0x3da0
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x38e0
movq -0x68(%rbp), %rdi
addq $0x20, %rdi
movslq -0x10(%rbp), %rsi
callq 0x3dd0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x86a0
leaq -0x28(%rbp), %rdi
callq 0x3df0
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x38be
movq 0xb7ef(%rip), %rdi      # 0xefd8
leaq 0x6924(%rip), %rsi      # 0xa114
callq 0x21b0
movq %rax, -0x70(%rbp)
jmp 0x37fb
movslq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x3e20
movq %rax, %rdi
callq 0x5a60
movl %eax, -0x74(%rbp)
jmp 0x3815
movl -0x74(%rbp), %esi
movq -0x70(%rbp), %rdi
callq 0x22c0
jmp 0x3823
movq 0xb7ae(%rip), %rdi      # 0xefd8
leaq 0x68e8(%rip), %rsi      # 0xa119
callq 0x21b0
movq %rax, -0x80(%rbp)
jmp 0x383c
movslq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x3e20
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x5a30
jmp 0x3857
movq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2190
movq %rax, -0x88(%rbp)
jmp 0x386d
movq -0x88(%rbp), %rdi
movq 0xb74d(%rip), %rsi      # 0xefc8
callq 0x21e0
jmp 0x3882
leaq -0x60(%rbp), %rdi
callq 0x20f0
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x37d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x38d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x20f0
jmp 0x38d5
leaq -0x28(%rbp), %rdi
callq 0x3ea0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x379a
leaq -0x28(%rbp), %rdi
callq 0x3ea0
jmp 0x38e9
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rsi, -0x70(%rbp)
movq %r8, -0x68(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movl %r9d, -0x3c(%rbp)
movss %xmm0, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x8, %rdi
movq %rdi, -0x60(%rbp)
callq 0x2270
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
callq 0x2570
jmp 0x5961
movq -0x58(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x78(%rbp)
callq 0x2270
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rsi
addq $0x8, %rdi
callq 0x2040
jmp 0x5985
movq -0x58(%rbp), %rdi
callq 0x5a10
movl %eax, -0x7c(%rbp)
jmp 0x5993
movq -0x68(%rbp), %rsi
movq -0x58(%rbp), %rdi
movl -0x7c(%rbp), %eax
movl %eax, (%rdi)
movl -0x8(%rbp), %eax
movl %eax, 0x30(%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x28(%rdi)
addq $0x38, %rdi
callq 0x2040
jmp 0x59b9
movq -0x58(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl %ecx, 0x58(%rax)
movss -0x40(%rbp), %xmm0
movss %xmm0, 0x5c(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x59f9
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x20f0
movq -0x60(%rbp), %rdi
callq 0x20f0
movq -0x48(%rbp), %rdi
callq 0x22d0
nopl (%rax,%rax)
// File: VitorCorreaSilva[P]sistemaControle/source/jogador.cpp
// Function: Jogador::calcularDescontoInss(float)
float Jogador::calcularDescontoInss(float salarioBruto){
	float inss;

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

	return salarioBruto * (inss/100);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
xorps %xmm0, %xmm0
ucomiss -0xc(%rbp), %xmm0
jbe 0x5d21
movq 0x92d7(%rip), %rdi      # 0xefd8
leaq 0x4490(%rip), %rsi      # 0xa198
callq 0x21b0
movq %rax, %rdi
movq 0x92b1(%rip), %rsi      # 0xefc8
callq 0x21e0
jmp 0x5daa
movss 0x443f(%rip), %xmm0     # 0xa168
ucomiss -0xc(%rbp), %xmm0
jb 0x5d3e
movss 0x444d(%rip), %xmm0     # 0xa184
movss %xmm0, -0x10(%rbp)
jmp 0x5da8
movss 0x4426(%rip), %xmm0     # 0xa16c
ucomiss -0xc(%rbp), %xmm0
jb 0x5d5b
movss 0x442c(%rip), %xmm0     # 0xa180
movss %xmm0, -0x10(%rbp)
jmp 0x5da6
movss 0x440d(%rip), %xmm0     # 0xa170
ucomiss -0xc(%rbp), %xmm0
jb 0x5d78
movss 0x440b(%rip), %xmm0     # 0xa17c
movss %xmm0, -0x10(%rbp)
jmp 0x5da4
movss 0x43f4(%rip), %xmm0     # 0xa174
ucomiss -0xc(%rbp), %xmm0
jb 0x5d95
movss 0x43ea(%rip), %xmm0     # 0xa178
movss %xmm0, -0x10(%rbp)
jmp 0x5da2
movss 0x43db(%rip), %xmm0     # 0xa178
movss %xmm0, -0x10(%rbp)
jmp 0x5da4
jmp 0x5da6
jmp 0x5da8
jmp 0x5daa
movss -0xc(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
movss 0x43cc(%rip), %xmm2     # 0xa188
divss %xmm2, %xmm1
mulss %xmm1, %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: VitorCorreaSilva[P]sistemaControle/source/jogador.cpp
// Function: Jogador::calcularDescontoIrrf(float)
float Jogador::calcularDescontoIrrf(float salarioSemInss){
	float irrf;

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

	return salarioSemInss * (irrf/100);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
xorps %xmm0, %xmm0
ucomiss -0xc(%rbp), %xmm0
jbe 0x5e11
movq 0x91e7(%rip), %rdi      # 0xefd8
leaq 0x43a0(%rip), %rsi      # 0xa198
callq 0x21b0
movq %rax, %rdi
movq 0x91c1(%rip), %rsi      # 0xefc8
callq 0x21e0
jmp 0x5e95
movss 0x434f(%rip), %xmm0     # 0xa168
ucomiss -0xc(%rbp), %xmm0
jb 0x5e29
xorps %xmm0, %xmm0
movss %xmm0, -0x10(%rbp)
jmp 0x5e93
movss 0x433b(%rip), %xmm0     # 0xa16c
ucomiss -0xc(%rbp), %xmm0
jb 0x5e46
movss 0x4345(%rip), %xmm0     # 0xa184
movss %xmm0, -0x10(%rbp)
jmp 0x5e91
movss 0x4322(%rip), %xmm0     # 0xa170
ucomiss -0xc(%rbp), %xmm0
jb 0x5e63
movss 0x4338(%rip), %xmm0     # 0xa194
movss %xmm0, -0x10(%rbp)
jmp 0x5e8f
movss 0x4309(%rip), %xmm0     # 0xa174
ucomiss -0xc(%rbp), %xmm0
jb 0x5e80
movss 0x4317(%rip), %xmm0     # 0xa190
movss %xmm0, -0x10(%rbp)
jmp 0x5e8d
movss 0x4304(%rip), %xmm0     # 0xa18c
movss %xmm0, -0x10(%rbp)
jmp 0x5e8f
jmp 0x5e91
jmp 0x5e93
jmp 0x5e95
movss -0xc(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
movss 0x42e1(%rip), %xmm2     # 0xa188
divss %xmm2, %xmm1
mulss %xmm1, %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rsi, -0x20(%rbp)
movl %edx, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq %rdi, -0x28(%rbp)
callq 0x2870
movl %edx, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x34(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x2c(%rbp)
leaq -0x34(%rbp), %rdi
callq 0x25e0
movl %eax, -0x60(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x25e0
movl %eax, %ecx
movl -0x60(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4c(%rbp)
leaq -0x34(%rbp), %rdi
callq 0x25c0
movl %eax, -0x5c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x25c0
movl %eax, %ecx
movl -0x5c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x50(%rbp)
leaq -0x34(%rbp), %rdi
callq 0x25b0
movl %eax, -0x58(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x25b0
movl %eax, %ecx
movl -0x58(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x50(%rbp)
jge 0x5f69
movl -0x4c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x5f82
cmpl $0x0, -0x50(%rbp)
jne 0x5f80
cmpl $0x0, -0x54(%rbp)
jge 0x5f7e
movl -0x4c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x5f80
jmp 0x5f82
movl -0x4c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl (%rax), %esi
movq 0x8fdb(%rip), %rdi      # 0xefd8
movq %rdi, -0x50(%rbp)
callq 0x22c0
movq %rax, %rdi
leaq 0x41a3(%rip), %rsi      # 0xa1b3
movq %rsi, -0x60(%rbp)
callq 0x21b0
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
addq $0x8, %rsi
callq 0x2190
movq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0x21b0
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
addq $0x38, %rsi
callq 0x2190
movq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0x21b0
movq -0x58(%rbp), %rsi
addq $0x28, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2660
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x2190
movq %rax, -0x40(%rbp)
jmp 0x607b
movq -0x40(%rbp), %rdi
leaq 0x412d(%rip), %rsi      # 0xa1b3
callq 0x21b0
jmp 0x608d
leaq -0x28(%rbp), %rdi
callq 0x20f0
movq -0x58(%rbp), %rax
movl 0x58(%rax), %esi
movq 0x8f34(%rip), %rdi      # 0xefd8
callq 0x22c0
movq %rax, %rdi
movq 0x8f15(%rip), %rsi      # 0xefc8
callq 0x21e0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x20f0
movq -0x30(%rbp), %rdi
callq 0x22d0
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x30, %rdi
callq 0x3df0
movq -0x18(%rbp), %rsi
movl %eax, -0xc(%rbp)
addq $0x8, %rsi
movq 0x6809(%rip), %rdi      # 0xefd8
callq 0x2190
movq %rax, %rdi
movq 0x67ea(%rip), %rsi      # 0xefc8
callq 0x21e0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8816
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movslq -0x10(%rbp), %rsi
callq 0x3e20
movq %rax, %rdi
callq 0x5fe0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x87ea
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x30, %rdi
callq 0x3df0
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x8896
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movslq -0x14(%rbp), %rsi
callq 0x3e20
movq %rax, %rdi
callq 0x5a60
cmpl -0xc(%rbp), %eax
jne 0x8889
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movslq -0x14(%rbp), %rsi
callq 0x3e20
movq %rax, %rdi
callq 0x5fe0
jmp 0x888b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x884a
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x30, %rdi
callq 0x3df0
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x893c
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movslq -0x18(%rbp), %rsi
callq 0x3e20
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x5a30
movq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3f00
movb %al, -0x49(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20f0
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x8916
jmp 0x892f
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movslq -0x18(%rbp), %rsi
callq 0x3e20
movq %rax, %rdi
callq 0x5fe0
jmp 0x8931
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x88cf
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x30, %rdi
callq 0x3df0
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8a80
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
movslq -0x10(%rbp), %rsi
callq 0x3e20
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x5a30
movq -0x58(%rbp), %rsi
movq 0x6629(%rip), %rdi      # 0xefd8
callq 0x2190
movq %rax, -0x50(%rbp)
jmp 0x89ba
movq -0x50(%rbp), %rdi
leaq 0x17ee(%rip), %rsi      # 0xa1b3
callq 0x21b0
jmp 0x89cc
leaq -0x30(%rbp), %rdi
callq 0x20f0
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
movslq -0x10(%rbp), %rsi
callq 0x3e20
movq %rax, %rdi
callq 0x5b00
movq 0x65e3(%rip), %rdi      # 0xefd8
callq 0x2140
movq %rax, %rdi
leaq 0x17af(%rip), %rsi      # 0xa1b3
callq 0x21b0
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
movslq -0x10(%rbp), %rsi
callq 0x3e20
movq -0x48(%rbp), %rdi
movq %rax, -0x60(%rbp)
addq $0x30, %rdi
movslq -0x10(%rbp), %rsi
callq 0x3e20
movq %rax, %rdi
callq 0x5b00
movq -0x60(%rbp), %rdi
callq 0x5c70
movq 0x6591(%rip), %rdi      # 0xefd8
callq 0x2140
movq %rax, %rdi
movq 0x6572(%rip), %rsi      # 0xefc8
callq 0x21e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8977
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20f0
jmp 0x8a86
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22d0
nop