LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: joao18araujo[P]pierluigi/src/interval.cpp
// Function: Interval::interval_to_note(Note, Interval)
Note Interval::interval_to_note(Note note, Interval interval){
  if(note.rest()){
    return note;
  }

  int midi_number = note.midi_number + interval.half_tones * interval.direction;
  int note_number = note.note_number + (interval.quantitative - 1) * interval.direction;
  Note n(midi_number);

  if(n.note_number == note_number){
    n.duration = note.duration;
    return n;
  }else{
    vector<Note> notes = n.enarmonies();
    for(auto & other_note : notes){
      if(other_note.note_number == note_number){
        other_note.duration = note.duration;
        return other_note;
      }
    }
  }

  return Note();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdx, -0xe0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, %rax
movq -0xd8(%rbp), %rdi
movq %rax, -0xd0(%rbp)
movq %rax, %rcx
movq %rcx, -0xc8(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x23be0
testb $0x1, %al
jne 0x1c48b
jmp 0x1c4a3
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdi
callq 0x22ce0
jmp 0x1c667
movq -0xe0(%rbp), %rdx
movq -0xd8(%rbp), %rax
movl 0x4c(%rax), %ecx
movl 0x28(%rdx), %esi
movswl 0x2c(%rdx), %edi
imull %edi, %esi
addl %esi, %ecx
movl %ecx, -0x1c(%rbp)
movl 0x50(%rax), %eax
movl (%rdx), %ecx
subl $0x1, %ecx
movswl 0x2c(%rdx), %edx
imull %edx, %ecx
addl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %esi
leaq -0x78(%rbp), %rdi
xorl %edx, %edx
callq 0x22f10
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0x1c52e
movq -0xd0(%rbp), %rdi
movq -0xd8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x78(%rbp)
leaq -0x78(%rbp), %rsi
callq 0x22ce0
jmp 0x1c50b
movl $0x1, -0x88(%rbp)
jmp 0x1c651
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x1c65c
leaq -0xa0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x23820
jmp 0x1c540
leaq -0xa0(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
callq 0x126e0
movq %rax, -0xb0(%rbp)
movq -0xa8(%rbp), %rdi
callq 0x12550
movq %rax, -0xb8(%rbp)
leaq -0xb0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x1cc60
testb $0x1, %al
jne 0x1c590
jmp 0x1c615
leaq -0xb0(%rbp), %rdi
callq 0x1b840
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
movl 0x50(%rax), %eax
cmpl -0x20(%rbp), %eax
jne 0x1c602
movq -0xd0(%rbp), %rdi
movq -0xd8(%rbp), %rax
movl (%rax), %ecx
movq -0xc0(%rbp), %rax
movl %ecx, (%rax)
movq -0xc0(%rbp), %rsi
callq 0x22ce0
jmp 0x1c5d9
movl $0x1, -0x88(%rbp)
jmp 0x1c61f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x100b0
jmp 0x1c65c
jmp 0x1c604
leaq -0xb0(%rbp), %rdi
callq 0x1cca0
jmp 0x1c574
movl $0x0, -0x88(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x100b0
movl -0x88(%rbp), %eax
testl %eax, %eax
jne 0x1c651
jmp 0x1c637
jmp 0x1c639
movq -0xd0(%rbp), %rdi
callq 0x22dc0
jmp 0x1c647
movl $0x1, -0x88(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xfd80
jmp 0x1c667
leaq -0x78(%rbp), %rdi
callq 0xfd80
jmp 0x1c677
movq -0xc8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x6820
// File: joao18araujo[P]pierluigi/src/note.cpp
// Function: Note::Note(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, bool)
Note::Note(const string note, const string accidental, const int octave, const int duration, bool linked) {
  this->valid = true;
  this->note = note;

  this->accidental = accidental;
  this->duration = duration;
  this->linked = linked;

  if(note != "r"){
    this->octave = octave;
    this->midi_number = (octave + 1) * N_SCALE + notes_with_accidental_to_number[this->full_note()];
    this->note_number = (octave + 1) * N_NOTES + notes_to_number[this->note];
  }else{
    this->octave = 0;
    this->midi_number = 0;
    this->note_number = 0;
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x80(%rbp)
movq %rsi, -0x60(%rbp)
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0x0, 0x4(%rdi)
addq $0x8, %rdi
movq %rdi, -0x68(%rbp)
callq 0x6650
movq -0x70(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x78(%rbp)
callq 0x6650
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movb $0x1, 0x54(%rax)
movb $0x0, 0x55(%rax)
movb $0x1, 0x54(%rax)
callq 0x6070
jmp 0x22b3a
movq -0x80(%rbp), %rsi
movq -0x70(%rbp), %rdi
addq $0x28, %rdi
callq 0x6070
jmp 0x22b4d
movq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, (%rax)
movb -0x21(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x55(%rax)
leaq 0x3e163(%rip), %rsi     # 0x60ccd
callq 0xfe70
movb %al, -0x81(%rbp)
jmp 0x22b77
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x22b86
jmp 0x22c59
movq -0x70(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, 0x48(%rsi)
movl -0x1c(%rbp), %ecx
movl %ecx, %eax
leal (%rax,%rax,2), %ecx
movl %ecx, %eax
leal 0xc(,%rax,4), %eax
movl %eax, -0x88(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x22ca0
jmp 0x22bb2
leaq 0x9c2a04f(%rip), %rdi   # 0x9c4cc08
leaq -0x58(%rbp), %rsi
callq 0x23f70
movq %rax, -0x90(%rbp)
jmp 0x22bcb
movq -0x70(%rbp), %rax
movl -0x88(%rbp), %ecx
movq -0x90(%rbp), %rdx
movl (%rdx), %edx
addl %edx, %ecx
movl %ecx, 0x4c(%rax)
leaq -0x58(%rbp), %rdi
callq 0x62d0
movq -0x70(%rbp), %rsi
movl -0x1c(%rbp), %ecx
movl %ecx, %eax
shll $0x3, %eax
subl %ecx, %eax
addl $0x7, %eax
movl %eax, -0x9c(%rbp)
addq $0x8, %rsi
leaq 0x9c2a032(%rip), %rdi   # 0x9c4cc40
callq 0x23fa0
movq %rax, -0x98(%rbp)
jmp 0x22c1c
movq -0x70(%rbp), %rax
movq -0x98(%rbp), %rdx
movl -0x9c(%rbp), %ecx
addl (%rdx), %ecx
movl %ecx, 0x50(%rax)
jmp 0x22c72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x22c7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x62d0
jmp 0x22c7b
movq -0x70(%rbp), %rax
movl $0x0, 0x48(%rax)
movl $0x0, 0x4c(%rax)
movl $0x0, 0x50(%rax)
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x62d0
movq -0x68(%rbp), %rdi
callq 0x62d0
movq -0x30(%rbp), %rdi
callq 0x6820
nopw %cs:(%rax,%rax)
// File: joao18araujo[P]pierluigi/src/note.cpp
// Function: Note::Note(Note const&)
Note::Note(const Note & note){
  this->valid = true;
  this->duration = note.duration;
  this->note = note.note;
  this->accidental = note.accidental;
  this->octave = note.octave;
  this->midi_number = note.midi_number;
  this->note_number = note.note_number;
  this->linked = note.linked;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x0, 0x4(%rdi)
addq $0x8, %rdi
movq %rdi, -0x28(%rbp)
callq 0x6650
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x38(%rbp)
callq 0x6650
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movb $0x1, 0x54(%rax)
movb $0x0, 0x55(%rax)
movb $0x1, 0x54(%rax)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x6070
jmp 0x22d48
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
addq $0x28, %rdi
callq 0x6070
jmp 0x22d5f
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x48(%rcx), %ecx
movl %ecx, 0x48(%rax)
movq -0x10(%rbp), %rcx
movl 0x4c(%rcx), %ecx
movl %ecx, 0x4c(%rax)
movq -0x10(%rbp), %rcx
movl 0x50(%rcx), %ecx
movl %ecx, 0x50(%rax)
movq -0x10(%rbp), %rcx
movb 0x55(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x55(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x62d0
movq -0x28(%rbp), %rdi
callq 0x62d0
movq -0x18(%rbp), %rdi
callq 0x6820
nopl (%rax,%rax)
// File: joao18araujo[P]pierluigi/src/note.cpp
// Function: Note::Note()
Note::Note(){
  this->valid = false;
  this->duration = 0;
  this->note = "c";
  this->accidental = "";
  this->octave = BELOW_MIDDLE_C_OCTAVE;
  this->midi_number = (octave + 1) * N_SCALE + notes_with_accidental_to_number[this->full_note()];
  this->note_number = (octave + 1) * N_NOTES + notes_to_number[this->note];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x0, 0x4(%rdi)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x6650
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x50(%rbp)
callq 0x6650
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movb $0x1, 0x54(%rax)
movb $0x0, 0x55(%rax)
movb $0x0, 0x54(%rax)
movl $0x0, (%rax)
leaq 0x3d6ee(%rip), %rsi     # 0x60508
callq 0x6640
jmp 0x22e21
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
leaq 0x3d9a2(%rip), %rsi     # 0x607d2
callq 0x6640
jmp 0x22e37
movq -0x48(%rbp), %rsi
movl $0x3, 0x48(%rsi)
movl 0x48(%rsi), %ecx
movl %ecx, %eax
leal (%rax,%rax,2), %ecx
movl %ecx, %eax
leal 0xc(,%rax,4), %eax
movl %eax, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x22ca0
jmp 0x22e61
leaq 0x9c29da0(%rip), %rdi   # 0x9c4cc08
leaq -0x38(%rbp), %rsi
callq 0x23f70
movq %rax, -0x60(%rbp)
jmp 0x22e77
movq -0x48(%rbp), %rax
movl -0x54(%rbp), %ecx
movq -0x60(%rbp), %rdx
movl (%rdx), %edx
addl %edx, %ecx
movl %ecx, 0x4c(%rax)
leaq -0x38(%rbp), %rdi
callq 0x62d0
movq -0x48(%rbp), %rsi
movl 0x48(%rsi), %ecx
movl %ecx, %eax
shll $0x3, %eax
subl %ecx, %eax
addl $0x7, %eax
movl %eax, -0x6c(%rbp)
addq $0x8, %rsi
leaq 0x9c29d8f(%rip), %rdi   # 0x9c4cc40
callq 0x23fa0
movq %rax, -0x68(%rbp)
jmp 0x22ebc
movq -0x48(%rbp), %rax
movq -0x68(%rbp), %rdx
movl -0x6c(%rbp), %ecx
addl (%rdx), %ecx
movl %ecx, 0x50(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x22ef5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x62d0
movq -0x50(%rbp), %rdi
callq 0x62d0
movq -0x40(%rbp), %rdi
callq 0x62d0
movq -0x10(%rbp), %rdi
callq 0x6820
// File: joao18araujo[P]pierluigi/src/note.cpp
// Function: Note::Note(int, int)
Note::Note(int midi_number, int duration){
  this->valid = true;
  this->duration = duration;
  this->midi_number = midi_number;
  this->octave = (midi_number / N_SCALE) - 1;
  string note_with_accidental = number_to_notes_with_accidental[midi_number % N_SCALE];
  this->set_full_note(note_with_accidental);
  this->note_number = (octave + 1) * N_NOTES + notes_to_number[this->note];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movl $0x0, 0x4(%rdi)
addq $0x8, %rdi
movq %rdi, -0x78(%rbp)
callq 0x6650
movq -0x68(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x70(%rbp)
callq 0x6650
movq -0x68(%rbp), %rax
movb $0x1, 0x54(%rax)
movb $0x0, 0x55(%rax)
movb $0x1, 0x54(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x4c(%rax)
movslq -0xc(%rbp), %rcx
imulq $0x2aaaaaab, %rcx, %rcx # imm = 0x2AAAAAAB
movq %rcx, %rdx
sarq $0x21, %rdx
movl %edx, %esi
shrq $0x3f, %rcx
movl %ecx, %edx
movl %esi, %ecx
leal -0x1(%rcx,%rdx), %ecx
movl %ecx, 0x48(%rax)
movslq -0xc(%rbp), %rcx
movl %ecx, %eax
imulq $0x2aaaaaab, %rcx, %rdx # imm = 0x2AAAAAAB
movq %rdx, %rcx
shrq $0x3f, %rcx
shrq $0x21, %rdx
addl %ecx, %edx
shll $0x2, %edx
movl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
cltq
shlq $0x5, %rax
leaq 0x9c29dff(%rip), %rsi   # 0x9c4cdc0
addq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x61f0
jmp 0x22fcf
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x61f0
jmp 0x22fde
movq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x230a0
jmp 0x22fed
leaq -0x60(%rbp), %rdi
callq 0x62d0
movq -0x68(%rbp), %rsi
movl 0x48(%rsi), %ecx
movl %ecx, %eax
shll $0x3, %eax
subl %ecx, %eax
addl $0x7, %eax
movl %eax, -0x84(%rbp)
addq $0x8, %rsi
leaq 0x9c29c28(%rip), %rdi   # 0x9c4cc40
callq 0x23fa0
movq %rax, -0x80(%rbp)
jmp 0x23023
movq -0x68(%rbp), %rax
movq -0x80(%rbp), %rdx
movl -0x84(%rbp), %ecx
addl (%rdx), %ecx
movl %ecx, 0x50(%rax)
leaq -0x30(%rbp), %rdi
callq 0x62d0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x23082
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x23079
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x62d0
leaq -0x30(%rbp), %rdi
callq 0x62d0
movq -0x70(%rbp), %rdi
callq 0x62d0
movq -0x78(%rbp), %rdi
callq 0x62d0
movq -0x38(%rbp), %rdi
callq 0x6820
nopl (%rax)
// File: joao18araujo[P]pierluigi/src/note.cpp
// Function: Note::set_full_note(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Note::set_full_note(string s){
  string only_note = "";
  only_note += s[0];
  this->note = only_note;
  s.erase(s.begin());
  this->accidental = s;
  this->midi_number = (octave + 1) * N_SCALE + notes_with_accidental_to_number[this->full_note()];
  this->note_number = (octave + 1) * N_NOTES + notes_to_number[this->note];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x6830
movq -0x88(%rbp), %rdx
leaq 0x3d6ef(%rip), %rsi     # 0x607d2
leaq -0x30(%rbp), %rdi
callq 0xfb20
jmp 0x230ee
leaq -0x31(%rbp), %rdi
callq 0x64f0
movq -0x98(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x68e0
movq %rax, -0xa0(%rbp)
jmp 0x23110
movq -0xa0(%rbp), %rax
movsbl (%rax), %esi
leaq -0x30(%rbp), %rdi
callq 0x62f0
jmp 0x23125
movq -0x90(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x6070
jmp 0x2313b
movq -0x98(%rbp), %rdi
callq 0x63f0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x24050
movq -0x98(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x6590
movq %rax, -0xa8(%rbp)
jmp 0x23171
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdi
movq -0xa8(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x28, %rdi
callq 0x6070
jmp 0x23195
movq -0x90(%rbp), %rsi
movl 0x48(%rsi), %ecx
movl %ecx, %eax
leal (%rax,%rax,2), %ecx
movl %ecx, %eax
leal 0xc(,%rax,4), %eax
movl %eax, -0xac(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x22ca0
jmp 0x231be
leaq 0x9c29a43(%rip), %rdi   # 0x9c4cc08
leaq -0x80(%rbp), %rsi
callq 0x23f70
movq %rax, -0xb8(%rbp)
jmp 0x231d7
movq -0x90(%rbp), %rax
movl -0xac(%rbp), %ecx
movq -0xb8(%rbp), %rdx
movl (%rdx), %edx
addl %edx, %ecx
movl %ecx, 0x4c(%rax)
leaq -0x80(%rbp), %rdi
callq 0x62d0
movq -0x90(%rbp), %rsi
movl 0x48(%rsi), %ecx
movl %ecx, %eax
shll $0x3, %eax
subl %ecx, %eax
addl $0x7, %eax
movl %eax, -0xc4(%rbp)
addq $0x8, %rsi
leaq 0x9c29a20(%rip), %rdi   # 0x9c4cc40
callq 0x23fa0
movq %rax, -0xc0(%rbp)
jmp 0x2322e
movq -0x90(%rbp), %rax
movq -0xc0(%rbp), %rdx
movl -0xc4(%rbp), %ecx
addl (%rdx), %ecx
movl %ecx, 0x50(%rax)
leaq -0x30(%rbp), %rdi
callq 0x62d0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x64f0
jmp 0x2329c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x23293
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x62d0
leaq -0x30(%rbp), %rdi
callq 0x62d0
movq -0x40(%rbp), %rdi
callq 0x6820
nopw %cs:(%rax,%rax)
// File: joao18araujo[P]pierluigi/src/scale.cpp
// Function: Scale::fill_note_set(Note, std::vector<Interval, std::allocator<Interval>>)
void Scale::fill_note_set(Note note, vector<Interval> intervals){
  permitted_notes.clear();
  permitted_notes.insert(note.full_note());

  for(auto & interval : intervals){
    note = Interval::interval_to_note(note, interval);
    permitted_notes.insert(note.full_note());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rsi, -0x1b0(%rbp)
movq %rdx, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x27a80
movq -0x1b0(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0x22ca0
movq -0x1a8(%rbp), %rdi
movq -0x1a0(%rbp), %rsi
callq 0x27950
movb %dl, -0x191(%rbp)
movq %rax, -0x190(%rbp)
jmp 0x2739e
movb -0x191(%rbp), %al
movq -0x190(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x62d0
movq -0x1b8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x12f70
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x12de0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x16890
testb $0x1, %al
jne 0x273f6
jmp 0x2756c
leaq -0x68(%rbp), %rdi
callq 0x168d0
movq -0x1b0(%rbp), %rsi
movq %rax, -0x78(%rbp)
leaq -0x128(%rbp), %rdi
callq 0x22ce0
movq -0x78(%rbp), %rsi
leaq -0x158(%rbp), %rdi
callq 0xfdb0
jmp 0x27428
leaq -0xd0(%rbp), %rdi
leaq -0x128(%rbp), %rsi
leaq -0x158(%rbp), %rdx
callq 0x1c440
jmp 0x27444
movq -0x1b0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0xfe00
jmp 0x27459
leaq -0xd0(%rbp), %rdi
callq 0xfd80
leaq -0x158(%rbp), %rdi
callq 0xfc90
leaq -0x128(%rbp), %rdi
callq 0xfd80
movq -0x1b0(%rbp), %rsi
leaq -0x178(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x22ca0
movq -0x1a8(%rbp), %rdi
movq -0x1d0(%rbp), %rsi
callq 0x27950
movb %dl, -0x1c1(%rbp)
movq %rax, -0x1c0(%rbp)
jmp 0x274b9
movb -0x1c1(%rbp), %al
movq -0x1c0(%rbp), %rcx
movq %rcx, -0x188(%rbp)
movb %al, -0x180(%rbp)
leaq -0x178(%rbp), %rdi
callq 0x62d0
leaq -0x68(%rbp), %rdi
callq 0x16920
jmp 0x273e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x62d0
jmp 0x27575
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x27544
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x27538
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0xfd80
leaq -0x158(%rbp), %rdi
callq 0xfc90
leaq -0x128(%rbp), %rdi
callq 0xfd80
jmp 0x27575
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x178(%rbp), %rdi
callq 0x62d0
jmp 0x27575
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6820
nop
// File: joao18araujo[P]pierluigi/src/second_species_counterpoint.cpp
// Function: SecondSpeciesCounterpoint::dfs_generate_counterpoint(Song&, bool, int, int)
Song SecondSpeciesCounterpoint::dfs_generate_counterpoint(Song & c_song, bool ascendant, int paralels, int same_movements){
  song = &c_song;
  Song counterpoint(c_song.scale, c_song.time);
  if(song->size() > 200 || paralels > 4 || same_movements > 600)
    return Song();

  SecondSpeciesCounterpoint::solve(0, 0, paralels, same_movements, ascendant, counterpoint);
  SecondSpeciesCounterpoint::add_trailing_rests(counterpoint);
  return counterpoint;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d0(%rbp)
movb %dl, %al
movq %rdi, %rdx
movq %rdx, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
leaq 0x9c22a4b(%rip), %rax   # 0x9c4b5e8
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
leaq -0x1a0(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
callq 0x10110
movq -0x1c0(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x1a8(%rbp)
movq -0x1a8(%rbp), %rdx
leaq -0xf0(%rbp), %rdi
callq 0x165a0
jmp 0x28be9
leaq -0x1a0(%rbp), %rdi
callq 0x101b0
leaq 0x9c229ec(%rip), %rax   # 0x9c4b5e8
movq (%rax), %rdi
callq 0x2dd20
movl %eax, -0x1d4(%rbp)
jmp 0x28c0c
movl -0x1d4(%rbp), %eax
cmpl $0xc8, %eax
ja 0x28c28
cmpl $0x4, -0x18(%rbp)
jg 0x28c28
cmpl $0x258, -0x1c(%rbp)     # imm = 0x258
jle 0x28c88
movq -0x1d0(%rbp), %rdi
callq 0x16620
jmp 0x28c36
movl $0x1, -0x1b8(%rbp)
jmp 0x28cd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x101b0
jmp 0x28cf2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x16720
jmp 0x28cf2
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movzbl -0x11(%rbp), %r8d
andl $0x1, %r8d
xorl %esi, %esi
leaq -0xf0(%rbp), %r9
movl %esi, %edi
callq 0x28d00
jmp 0x28ca9
leaq -0xf0(%rbp), %rdi
callq 0xfa90
jmp 0x28cb7
movq -0x1d0(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x166a0
jmp 0x28ccc
movl $0x1, -0x1b8(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x16720
movq -0x1c8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1b0(%rbp), %rdi
callq 0x6820
nop
// File: joao18araujo[P]pierluigi/src/song.cpp
// Function: Song::trailing_rests()
unsigned Song::trailing_rests(){
  int tr = 0;

  for(int i = (int) notes.size() - 1; i >= 0; ++i){
    if(notes[i].rest()) tr++;
    else break;
  }

  return tr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
callq 0x12820
subl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x2dde1
movq -0x18(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0xfd10
movq %rax, %rdi
callq 0x23be0
testb $0x1, %al
jne 0x2ddc7
jmp 0x2ddd2
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2ddd4
jmp 0x2dde1
jmp 0x2ddd6
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2dda6
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: joao18araujo[P]pierluigi/src/song.cpp
// Function: Song::back()
Note Song::back() {
  if(notes.size() > 0)
    return notes.back();
  else
    return Note();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x12820
cmpq $0x0, %rax
jbe 0x2de35
movq -0x18(%rbp), %rdi
callq 0x1b790
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x22ce0
jmp 0x2de3e
movq -0x28(%rbp), %rdi
callq 0x22dc0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: joao18araujo[P]pierluigi/src/song_reader.cpp
// Function: SongReader::string_to_compass_time(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
CompassTime SongReader::string_to_compass_time(string line){
  if(!regex_match(line, regex("\\\\time \\d+\\/\\d+")))
    return CompassTime();

  int times, base_note;
  sscanf(line.c_str(), "\\time %d/%d\n", &times, &base_note);
  return CompassTime(times, base_note);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x319a0(%rip), %rsi     # 0x60787
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0x10, %edx
callq 0x2fab0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x2fa60
movb %al, -0x45(%rbp)
jmp 0x2ee0d
movb -0x45(%rbp), %al
xorb $-0x1, %al
movb %al, -0x59(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2fb50
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x2ee27
jmp 0x2ee49
leaq -0x8(%rbp), %rdi
callq 0x16940
jmp 0x2ee7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2fb50
jmp 0x2ee84
movq -0x58(%rbp), %rdi
callq 0x61d0
movq %rax, %rdi
leaq 0x3193b(%rip), %rsi     # 0x60797
leaq -0x40(%rbp), %rdx
leaq -0x44(%rbp), %rcx
movb $0x0, %al
callq 0x6470
movl -0x40(%rbp), %esi
movl -0x44(%rbp), %edx
leaq -0x8(%rbp), %rdi
callq 0x2fc60
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6820
nopl (%rax)
// File: stetre[P]moonfonts/src/fonts.c
// Function: font_free
static void font_free(lua_State *L, rec_t* rec)
    {
    if(search(rec->name) == rec)
        rremove(rec);
    Free(L, rec->name);
    Free(L, rec);   
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x122a0
cmpq 0x8(%rsp), %rax
jne 0x135d
movq 0x8(%rsp), %rdi
callq 0x122d0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x1190
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1190
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonfonts/src/fonts.c
// Function: IsAvailable
static int IsAvailable(lua_State *L)
    {
    const char *name = luaL_checkstring(L, 1);
    font_t *font = font_search(L, name);
    lua_pushboolean(L, font !=NULL);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x10e0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x131f0
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
cmpq $0x0, (%rsp)
setne %al
andb $0x1, %al
movzbl %al, %esi
callq 0x1140
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonfonts/src/fonts.c
// Function: List
static int List(lua_State *L)
    {
    int i, byname;
    rec_t *rec;

    byname = optboolean(L, 1, 0);

    lua_newtable(L);

    if(byname)
        {
        rec = first(" ");
        while(rec)
            {
            lua_pushboolean(L, 1);
            lua_setfield(L, -2, (const char*)rec->name);
            rec = next(rec);
            }
        }
    else
        {
        i = 1;
        rec = first(" ");
        while(rec)
            {
            lua_pushstring(L, (const char*)rec->name);
            lua_seti(L, -2, i++);
            rec = next(rec);
            }
        }

    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x11e0
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x1090
cmpl $0x0, 0x8(%rsp)
je 0x12ed1
leaq 0x19918e(%rip), %rdi    # 0x1ac018
callq 0x1300
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x12ecf
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x1140
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x20(%rax), %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10a0
movq (%rsp), %rdi
callq 0x13240
movq %rax, (%rsp)
jmp 0x12e93
jmp 0x12f32
movl $0x1, 0xc(%rsp)
leaq 0x199138(%rip), %rdi    # 0x1ac018
callq 0x1300
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x12f30
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x11d0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rsp)
movslq %eax, %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10f0
movq (%rsp), %rdi
callq 0x13240
movq %rax, (%rsp)
jmp 0x12ee9
jmp 0x12f32
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: stetre[P]moonfonts/src/fonts.c
// Function: font_new
static int font_new(lua_State *L, const char *name, createfunc_t create,
    unsigned int first_char, unsigned int num_chars, 
    unsigned int width, unsigned int height, unsigned int height_pow2, unsigned int line_spacing)
    {
    rec_t *rec;
    if((rec = (rec_t*)Malloc(L, sizeof(rec_t))) == NULL) 
        return luaL_error(L, errstring(ERR_MEMORY));

    memset(rec, 0, sizeof(rec_t));
    rec->name= Strdup(L, name);
    rec->font.name = name;
    rec->font.create = create;
    rec->font.num_chars = num_chars;
    rec->font.first_char = first_char;
    rec->font.width = width;
    rec->font.height = height;
    rec->font.height_pow2 = height_pow2;
    rec->font.line_spacing = line_spacing;

    if(search(name))
        {
        Free(L, rec->name);
        Free(L, rec); 
        return unexpected(L); /* duplicate value */
        }
    insert(rec);
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movl 0x60(%rsp), %eax
movl 0x58(%rsp), %eax
movl 0x50(%rsp), %eax
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movl %r8d, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
movl $0x50, %esi
callq 0x1070
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0x13743
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xfffffffa, %edi       # imm = 0xFFFFFFFA
callq 0x1050
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x1170
movl %eax, 0x44(%rsp)
jmp 0x1383c
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x10b0
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1180
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x48(%rax)
movl 0x20(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x44(%rax)
movl 0x24(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x40(%rax)
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x30(%rax)
movl 0x50(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x34(%rax)
movl 0x58(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x38(%rax)
movl 0x60(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x3c(%rax)
movq 0x30(%rsp), %rdi
callq 0x122a0
cmpq $0x0, %rax
je 0x1382a
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x1190
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1190
movq 0x38(%rsp), %rdi
leaq 0x19e134(%rip), %rsi    # 0x1b1945
leaq 0x19e147(%rip), %rdx    # 0x1b195f
movl $0x66, %ecx
movb $0x0, %al
callq 0x1170
movl %eax, 0x44(%rsp)
jmp 0x1383c
movq 0x10(%rsp), %rdi
callq 0x1aa930
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonfonts/src/utils.c
// Function: moonfonts_Malloc
void *Malloc(lua_State *L, size_t size)
    {
    void *ptr = Malloc_(size);
    if(ptr==NULL)
        { luaL_error(L, errstring(ERR_MEMORY)); return NULL; }
    memset(ptr, 0, size);
    //DBG("Malloc %p\n", ptr);
    return ptr;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1ab0f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1ab0c1
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl $0xfffffffa, %edi       # imm = 0xFFFFFFFA
callq 0x1050
movq (%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x1170
movq $0x0, 0x20(%rsp)
jmp 0x1ab0dc
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
xorl %esi, %esi
callq 0x10b0
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonfonts/src/utils.c
// Function: moonfonts_errstring
const char* errstring(int err)
    {
    switch(err)
        {
        case 0: return "success";
        case ERR_GENERIC: return "generic error";
        case ERR_TABLE: return "not a table";
        case ERR_EMPTY: return "empty list";
        case ERR_TYPE: return "invalid type";
        case ERR_VALUE: return "invalid value";
        case ERR_NOTPRESENT: return "missing";
        case ERR_MEMORY: return "out of memory";
        case ERR_LENGTH: return "invalid length";
        case ERR_POOL: return "elements are not from the same pool";
        case ERR_BOUNDARIES: return "invalid boundaries";
        case ERR_UNKNOWN: return "unknown field name";
        default:
            return "???";
        }
    return NULL; /* unreachable */
    }

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
addl $0xa, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rsp)
subl $0xb, %eax
ja 0x1ab221
movq -0x18(%rsp), %rax
leaq 0x6801(%rip), %rcx      # 0x1b1968
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x6861(%rip), %rax      # 0x1b19d8
movq %rax, -0x8(%rsp)
jmp 0x1ab22d
leaq 0x6858(%rip), %rax      # 0x1b19e0
movq %rax, -0x8(%rsp)
jmp 0x1ab22d
leaq 0x6855(%rip), %rax      # 0x1b19ee
movq %rax, -0x8(%rsp)
jmp 0x1ab22d
leaq 0x6850(%rip), %rax      # 0x1b19fa
movq %rax, -0x8(%rsp)
jmp 0x1ab22d
leaq 0x684d(%rip), %rax      # 0x1b1a05
movq %rax, -0x8(%rsp)
jmp 0x1ab22d
leaq 0x684c(%rip), %rax      # 0x1b1a12
movq %rax, -0x8(%rsp)
jmp 0x1ab22d
leaq 0x684c(%rip), %rax      # 0x1b1a20
movq %rax, -0x8(%rsp)
jmp 0x1ab22d
leaq 0x6846(%rip), %rax      # 0x1b1a28
movq %rax, -0x8(%rsp)
jmp 0x1ab22d
leaq 0x6846(%rip), %rax      # 0x1b1a36
movq %rax, -0x8(%rsp)
jmp 0x1ab22d
leaq 0x6847(%rip), %rax      # 0x1b1a45
movq %rax, -0x8(%rsp)
jmp 0x1ab22d
leaq 0x685d(%rip), %rax      # 0x1b1a69
movq %rax, -0x8(%rsp)
jmp 0x1ab22d
leaq 0x6862(%rip), %rax      # 0x1b1a7c
movq %rax, -0x8(%rsp)
jmp 0x1ab22d
leaq 0x6867(%rip), %rax      # 0x1b1a8f
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonfonts/src/utils.c
// Function: moonfonts_MallocNoErr
void *MallocNoErr(lua_State *L, size_t size) /* do not raise errors (check the retval) */
    {
    void *ptr = Malloc_(size);
    (void)L;
    if(ptr==NULL)
        return NULL;
    memset(ptr, 0, size);
    //DBG("MallocNoErr %p\n", ptr);
    return ptr;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1ab0f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1ab270
movq $0x0, 0x20(%rsp)
jmp 0x1ab28b
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
xorl %esi, %esi
callq 0x10b0
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonfonts/src/utils.c
// Function: moonfonts_Strdup
char *Strdup(lua_State *L, const char *s)
    {
    size_t len = strnlen(s, 256);
    char *ptr = (char*)Malloc(L, len + 1);
    if(len>0)
        memcpy(ptr, s, len);
    ptr[len]='\0';
    return ptr;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x10d0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0x1070
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jbe 0x1ab2f6
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1120
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: stetre[P]moonfonts/src/utils.c
// Function: moonfonts_testboolean
int testboolean(lua_State *L, int arg, int *err)
    {
    if(!lua_isboolean(L, arg))
        { *err = ERR_TYPE; return 0; }
    *err = 0;
    return lua_toboolean(L, arg);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x11c0
cmpl $0x1, %eax
je 0x1ab40a
movq 0x8(%rsp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
movl $0x0, 0x24(%rsp)
jmp 0x1ab427
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x1030
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::empty() const
bool HierarchicalBlockSparseMatrix<Treal>::empty() const {
			if(nRows == 0 && nCols == 0 && submatrix.empty() && !children_exist())
			  return true;
			else
			  return false;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, (%rax)
jne 0x49b9
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x49b9
movq -0x18(%rbp), %rdi
addq $0x70, %rdi
callq 0x8b50
testb $0x1, %al
jne 0x49a6
jmp 0x49b9
movq -0x18(%rbp), %rdi
callq 0x50d0
testb $0x1, %al
jne 0x49b9
movb $0x1, -0x1(%rbp)
jmp 0x49bd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_n_rows() const
int HierarchicalBlockSparseMatrix<Treal>::get_n_rows() const  {
			if(parent == NULL)
				return nRows_orig;
			else{
				const HierarchicalBlockSparseMatrix<Treal> *tmp = this;
				while(tmp->parent != NULL){
					tmp = tmp->parent;
                  }
				return tmp->nRows_orig;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x68(%rax)
jne 0x4b43
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x4b6e
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x4b64
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4b4b
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_n_cols() const
int HierarchicalBlockSparseMatrix<Treal>::get_n_cols() const  {
            if(parent == NULL)
				return nCols_orig;
			else{
				const HierarchicalBlockSparseMatrix<Treal> *tmp = this;
				while(tmp->parent != NULL){
					tmp = tmp->parent;
                  }
				return tmp->nCols_orig;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x68(%rax)
jne 0x4ba3
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x4bce
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x4bc4
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4bab
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::clear()
void HierarchicalBlockSparseMatrix<Treal>::clear() {

			if(empty()){
				return;
			}

			if(lowest_level()){
				submatrix.clear();
				nRows = 0;
				nCols = 0;
				if(children_exist()){
					throw std::runtime_error("Error in HierarchicalBlockSparseMatrix<Treal>::clear: children exist on leaf level.");
				}
				return;
			}

			for(int i = 0; i < 4; ++i){
				if(children[i] != NULL){
					children[i]->clear(); // smart pointer, no need to call delete explicitly!
					children[i] = NULL;
				}
			}
			nRows = 0;
			nCols = 0;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x4970
testb $0x1, %al
jne 0x4bff
jmp 0x4c04
jmp 0x4d3d
movq -0x30(%rbp), %rdi
callq 0x97b0
testb $0x1, %al
jne 0x4c16
jmp 0x4c97
movq -0x30(%rbp), %rdi
addq $0x70, %rdi
callq 0x8ac0
movq -0x30(%rbp), %rdi
movl $0x0, (%rdi)
movl $0x0, 0x4(%rdi)
callq 0x50d0
testb $0x1, %al
jne 0x4c3f
jmp 0x4c92
movl $0x10, %edi
callq 0x20a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0xc9ca(%rip), %rsi      # 0x11624
callq 0x2070
jmp 0x4c61
movq -0x38(%rbp), %rdi
movq 0x13384(%rip), %rsi     # 0x17ff0
movq 0x1334d(%rip), %rdx     # 0x17fc0
callq 0x22c0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x2130
jmp 0x4d43
jmp 0x4d3d
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x4d2c
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movslq -0x18(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9800
testb $0x1, %al
jne 0x4cca
jmp 0x4d1c
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movslq -0x18(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x9830
movq %rax, %rdi
callq 0x4be0
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9850
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movslq -0x18(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
leaq -0x28(%rbp), %rsi
callq 0x9870
leaq -0x28(%rbp), %rdi
callq 0x98a0
jmp 0x4d1e
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4c9e
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x22e0
nopl (%rax)
// File: toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_frob_squared() const
Treal HierarchicalBlockSparseMatrix<Treal>::get_frob_squared() const  {

			if(empty())
				throw std::runtime_error("Error in HierarchicalBlockSparseMatrix<Treal>::get_frob_squared: empty matrix occured.");

		    if(lowest_level()){

				Treal frob_squared = 0.0;
				for(int i = 0; i < submatrix.size(); ++i){
					frob_squared += submatrix[i] * submatrix[i];
				}
				return frob_squared;
			}
			else{

				Treal frob_squared = 0.0;

				for(int i = 0; i < 4; ++i){
					if(children[i] != NULL) frob_squared += children[i]->get_frob_squared();
				}

				return frob_squared;
			}

		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4970
testb $0x1, %al
jne 0x4d6f
jmp 0x4dc2
movl $0x10, %edi
callq 0x20a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0xc8ee(%rip), %rsi      # 0x11678
callq 0x2070
jmp 0x4d91
movq -0x50(%rbp), %rdi
movq 0x13254(%rip), %rsi     # 0x17ff0
movq 0x1321d(%rip), %rdx     # 0x17fc0
callq 0x22c0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2130
jmp 0x4ee4
movq -0x48(%rbp), %rdi
callq 0x97b0
testb $0x1, %al
jne 0x4dd4
jmp 0x4e61
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x48(%rbp), %rdi
movslq -0x2c(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x70, %rdi
callq 0x8cf0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x4e55
movq -0x48(%rbp), %rdi
addq $0x70, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x9c20
movq -0x48(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
addq $0x70, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x9c20
movsd -0x60(%rbp), %xmm0
movsd (%rax), %xmm2
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4de3
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x4ed9
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
cmpl $0x4, -0x3c(%rbp)
jge 0x4ecf
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
movslq -0x3c(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9800
testb $0x1, %al
jne 0x4e98
jmp 0x4ec2
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
movslq -0x3c(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x9830
movq %rax, %rdi
callq 0x4d50
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x4ec4
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x4e70
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x22e0
nopl (%rax)
// File: toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_nnz() const
size_t HierarchicalBlockSparseMatrix<Treal>::get_nnz() const  {
			if(empty())
				throw std::runtime_error("Error in HierarchicalBlockSparseMatrix<Treal>::get_nnz: empty matrix occured.");

		    if(lowest_level()){

                //this seems to be more logical!
				int nnz = 0;
				for(int i = 0; i < submatrix.size(); ++i){
					if(fabs(submatrix[i]) > 0.0) nnz += 1;
				}
				return nnz;
			}
			else{

				int nnz = 0.0;

				for(int i = 0; i < 4; ++i){
					if(children[i] != NULL) nnz += children[i]->get_nnz();
				}

				return nnz;
			}

		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x4970
testb $0x1, %al
jne 0x518f
jmp 0x51e2
movl $0x10, %edi
callq 0x20a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0xc8ab(%rip), %rsi      # 0x11a55
callq 0x2070
jmp 0x51b1
movq -0x40(%rbp), %rdi
movq 0x12e34(%rip), %rsi     # 0x17ff0
movq 0x12dfd(%rip), %rdx     # 0x17fc0
callq 0x22c0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2130
jmp 0x52eb
movq -0x38(%rbp), %rdi
callq 0x97b0
testb $0x1, %al
jne 0x51f1
jmp 0x5269
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x24(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x70, %rdi
callq 0x8cf0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x525f
movq -0x38(%rbp), %rdi
addq $0x70, %rdi
movslq -0x24(%rbp), %rsi
callq 0x9c20
movsd (%rax), %xmm0
movaps 0xbde4(%rip), %xmm1     # 0x11020
pand %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x5252
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5254
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x51ff
movslq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x52e1
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x4, -0x2c(%rbp)
jge 0x52d9
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movslq -0x2c(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9800
testb $0x1, %al
jne 0x529f
jmp 0x52cc
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movslq -0x2c(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x9830
movq %rax, %rdi
callq 0x5170
movq %rax, %rcx
movslq -0x28(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x28(%rbp)
jmp 0x52ce
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5277
movslq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
nop
// File: toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_values(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&, std::vector<double, std::allocator<double>>&) const
void HierarchicalBlockSparseMatrix<Treal>::get_values(const std::vector<int> & rows,
						  const std::vector<int> & cols,
						  std::vector<Treal> & values) const  {

			if(empty()){
				throw std::runtime_error("Error in HierarchicalBlockSparseMatrix<Treal>::get_values: empty matrix occured.");
			}

			if(rows.size() != cols.size()){
				throw std::runtime_error("Error in HierarchicalBlockSparseMatrix<Treal>::get_values: bad sizes.");
			}

			if(rows.size() == 0) return;

			values.resize(rows.size());

			for(int i = 0; i < rows.size(); ++i){
				values[i] = get_single_value(rows[i],cols[i]);
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x4970
testb $0x1, %al
jne 0x542b
jmp 0x547e
movl $0x10, %edi
callq 0x20a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0xc65d(%rip), %rsi      # 0x11aa3
callq 0x2070
jmp 0x544d
movq -0x40(%rbp), %rdi
movq 0x12b98(%rip), %rsi     # 0x17ff0
movq 0x12b61(%rip), %rdx     # 0x17fc0
callq 0x22c0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2130
jmp 0x55a1
movq -0x10(%rbp), %rdi
callq 0x6070
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6070
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
je 0x54f3
movl $0x10, %edi
callq 0x20a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0xc639(%rip), %rsi      # 0x11af4
callq 0x2070
jmp 0x54c2
movq -0x50(%rbp), %rdi
movq 0x12b23(%rip), %rsi     # 0x17ff0
movq 0x12aec(%rip), %rdx     # 0x17fc0
callq 0x22c0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2130
jmp 0x55a1
movq -0x10(%rbp), %rdi
callq 0x6070
cmpq $0x0, %rax
jne 0x5507
jmp 0x559b
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6070
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x8c60
movl $0x0, -0x30(%rbp)
movslq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6070
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x559b
movq -0x10(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0xb6b0
movl (%rax), %eax
movl %eax, -0x6c(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0xb6b0
movq -0x38(%rbp), %rdi
movl -0x6c(%rbp), %esi
movl (%rax), %edx
callq 0xd1c0
movsd %xmm0, -0x68(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x5070
movsd -0x68(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x552b
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x22e0
nopw (%rax,%rax)