LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: skyleaworlder[P]AES/src/AddRoundKey.cpp
// Function: AddRoundKey(std::vector<std::bitset<8ul>, std::allocator<std::bitset<8ul>>>, std::vector<std::bitset<8ul>, std::allocator<std::bitset<8ul>>>)
vector<byte> AddRoundKey(
    vector<byte> input,
    vector<byte> round_key
) {
    assert(input.size() == 16 && round_key.size() == 16);
    vector<byte> ret;
    for (size_t index = 0; index < input.size(); ++index)
        ret.push_back(input[index] ^ round_key[index]);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x60(%rbp)
movq %rsi, -0x58(%rbp)
movq %rdi, %rax
movq -0x58(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq %rax, %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x2770
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x10, %rcx
movb %al, -0x3d(%rbp)
jne 0x2684
movq -0x60(%rbp), %rdi
callq 0x2770
cmpq $0x10, %rax
sete %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x268d
jmp 0x268f
jmp 0x26ae
leaq 0x696e(%rip), %rdi      # 0x9004
leaq 0x6994(%rip), %rsi      # 0x9031
movl $0x7, %edx
leaq 0x699c(%rip), %rcx      # 0x9045
callq 0x20e0
movq -0x50(%rbp), %rdi
movb $0x0, -0x19(%rbp)
callq 0x2790
movq $0x0, -0x28(%rbp)
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x2770
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x2744
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2820
movq -0x60(%rbp), %rdi
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rsi
callq 0x2820
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x27e0
movq -0x50(%rbp), %rdi
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x27b0
jmp 0x271d
jmp 0x271f
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x26c3
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x2840
jmp 0x2761
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x2757
movq -0x50(%rbp), %rdi
callq 0x2840
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22b0
nopw (%rax,%rax)
// File: skyleaworlder[P]AES/src/KeyExpan.cpp
// Function: Key_Expansion(std::vector<std::bitset<8ul>, std::allocator<std::bitset<8ul>>>, unsigned long)
vector<vector<byte>> Key_Expansion(
    vector<byte> input,
    size_t total_turn
) {
    vector<vector<byte>> ret { input };
    for (size_t index = 0; index < total_turn; ++index)
        ret.push_back(next_key(
            ret[index], index
        ));
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3bc0
jmp 0x345b
leaq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x1, -0x28(%rbp)
leaq -0x5d(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x3cb0
movq -0xa8(%rbp), %rdi
movq -0xb0(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3cd0
jmp 0x3498
leaq -0x5d(%rbp), %rdi
callq 0x3d50
leaq -0x48(%rbp), %rax
movq %rax, -0xc0(%rbp)
addq $0x18, %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rdi
addq $-0x18, %rdi
movq %rdi, -0xc8(%rbp)
callq 0x2840
movq -0xc0(%rbp), %rcx
movq -0xc8(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0xb8(%rbp)
jne 0x34b7
movq $0x0, -0x68(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x365a
movq -0xa8(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x3da0
movq %rax, %rsi
leaq -0x98(%rbp), %rdi
callq 0x3bc0
jmp 0x351f
movq -0x68(%rbp), %rdx
leaq -0x80(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x36a0
jmp 0x3535
movq -0xa8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3d70
jmp 0x3547
leaq -0x80(%rbp), %rdi
callq 0x2840
leaq -0x98(%rbp), %rdi
callq 0x2840
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x34f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
movq -0x50(%rbp), %rax
leaq -0x48(%rbp), %rcx
cmpq %rax, %rcx
movq %rax, -0xd0(%rbp)
je 0x35b8
movq -0xd0(%rbp), %rdi
addq $-0x18, %rdi
movq %rdi, -0xd8(%rbp)
callq 0x2840
movq -0xd8(%rbp), %rax
leaq -0x48(%rbp), %rcx
cmpq %rcx, %rax
movq %rax, -0xd0(%rbp)
jne 0x358a
jmp 0x368c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x5d(%rbp), %rdi
callq 0x3d50
leaq -0x48(%rbp), %rax
movq %rax, -0xe8(%rbp)
addq $0x18, %rax
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rdi
addq $-0x18, %rdi
movq %rdi, -0xf0(%rbp)
callq 0x2840
movq -0xe8(%rbp), %rcx
movq -0xf0(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0xe0(%rbp)
jne 0x35e8
jmp 0x368c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3680
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x364c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x2840
leaq -0x98(%rbp), %rdi
callq 0x2840
jmp 0x3680
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x3670
movq -0xa8(%rbp), %rdi
callq 0x3dc0
movq -0xa0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x3dc0
movq -0x58(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: skyleaworlder[P]AES/src/Misc.cpp
// Function: byte_to_vector(std::bitset<128ul>)
vector<byte> byte_to_vector(std::bitset<128> input) {
    /* cos tmp is reverse */
    vector<byte> ret, tmp;
    for (size_t index = 0; index < 128 / 8; ++index) {
        tmp.push_back(std::bitset<8> {
            (input & std::bitset<128> { 0xFF }).to_ulong()
        });
        input >>= 8;
    }
    while (tmp.size()) {
        ret.push_back(tmp.back());
        tmp.pop_back();
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x2790
leaq -0x38(%rbp), %rdi
callq 0x2790
movq $0x0, -0x40(%rbp)
cmpq $0x10, -0x40(%rbp)
jae 0x5a64
leaq -0x68(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0xff, %esi
callq 0x60e0
movq -0x98(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x60a0
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6130
movq %rax, -0x90(%rbp)
jmp 0x59f9
movq -0x90(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3f20
movq -0xa0(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x27b0
jmp 0x5a22
leaq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x6150
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x59af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2840
movq -0x88(%rbp), %rdi
callq 0x2840
jmp 0x5ac6
jmp 0x5a66
leaq -0x38(%rbp), %rdi
callq 0x2770
cmpq $0x0, %rax
je 0x5a9a
leaq -0x38(%rbp), %rdi
callq 0x2dc0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x3fb0
jmp 0x5a8f
leaq -0x38(%rbp), %rdi
callq 0x61a0
jmp 0x5a66
movb $0x1, -0x19(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2840
testb $0x1, -0x19(%rbp)
jne 0x5ab9
movq -0x88(%rbp), %rdi
callq 0x2840
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x22b0
nop
// File: skyleaworlder[P]AES/src/MixColumns.cpp
// Function: FieldMult(std::bitset<8ul>)
byte FieldMult(byte input) {
    std::bitset<1> top { input[7] };
    byte tmp { input << 1 };
    if (top == 1)
        return tmp ^ byte(0x1b);
    else
        return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0x7, %edx
callq 0x6c80
leaq -0x28(%rbp), %rdi
callq 0x6cc0
andb $0x1, %al
movzbl %al, %eax
movl %eax, %esi
leaq -0x18(%rbp), %rdi
callq 0x6d00
leaq -0x28(%rbp), %rdi
callq 0x6d50
leaq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6d60
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x6d00
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6da0
testb $0x1, %al
jne 0x65f3
jmp 0x6614
leaq -0x40(%rbp), %rdi
movl $0x1b, %esi
callq 0x3f20
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x27e0
movq %rax, -0x8(%rbp)
jmp 0x661c
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: skyleaworlder[P]AES/src/ShiftRows.cpp
// Function: ShiftRows(std::vector<std::bitset<8ul>, std::allocator<std::bitset<8ul>>>)
vector<byte> ShiftRows(
    vector<byte> input
) {
    return vector<byte> {
        input[0], input[5], input[10], input[15],
        input[4], input[9], input[14], input[3],
        input[8], input[13], input[2], input[7],
        input[12], input[1], input[6], input[11]
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xd0(%rbp)
movq %rdi, %rax
movq -0xd0(%rbp), %rdi
movq %rax, -0xc8(%rbp)
movq %rax, %rcx
movq %rcx, -0xd8(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x2820
movq -0xd0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
movl $0x5, %esi
callq 0x2820
movq -0xd0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x98(%rbp)
movl $0xa, %esi
callq 0x2820
movq -0xd0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x90(%rbp)
movl $0xf, %esi
callq 0x2820
movq -0xd0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x88(%rbp)
movl $0x4, %esi
callq 0x2820
movq -0xd0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movl $0x9, %esi
callq 0x2820
movq -0xd0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movl $0xe, %esi
callq 0x2820
movq -0xd0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movl $0x3, %esi
callq 0x2820
movq -0xd0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movl $0x8, %esi
callq 0x2820
movq -0xd0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movl $0xd, %esi
callq 0x2820
movq -0xd0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movl $0x2, %esi
callq 0x2820
movq -0xd0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movl $0x7, %esi
callq 0x2820
movq -0xd0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movl $0xc, %esi
callq 0x2820
movq -0xd0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x1, %esi
callq 0x2820
movq -0xd0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x6, %esi
callq 0x2820
movq -0xd0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0xb, %esi
callq 0x2820
movq (%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0xa0(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x10, -0x18(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x28f0
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rcx
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3e20
jmp 0x723c
leaq -0xa1(%rbp), %rdi
callq 0x2ae0
movq -0xd8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa1(%rbp), %rdi
callq 0x2ae0
movq -0xb0(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: skyleaworlder[P]AES/src/SubBytes.cpp
// Function: SubBytes(std::vector<std::bitset<8ul>, std::allocator<std::bitset<8ul>>>)
vector<byte> SubBytes(
    vector<byte> input
) {
    assert(input.size() == 16);
    vector<byte> ret;
    for (byte elem : input) {
        size_t col_index = (elem & byte(0x0F)).to_ulong();
        size_t row_index = (elem & byte(0xF0)).to_ulong() >> 4;
        ret.push_back(s_box[row_index * 16 + col_index]);
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, %rax
movq -0x90(%rbp), %rdi
movq %rax, -0x88(%rbp)
movq %rax, %rcx
movq %rcx, -0x80(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x2770
cmpq $0x10, %rax
jne 0x72cf
jmp 0x72ee
leaq 0x1e44(%rip), %rdi      # 0x911a
leaq 0x1eb0(%rip), %rsi      # 0x918d
movl $0x6, %edx
leaq 0x1eb5(%rip), %rcx      # 0x919e
callq 0x20e0
movq -0x88(%rbp), %rdi
movb $0x0, -0x11(%rbp)
callq 0x2790
movq -0x90(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2f40
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2d90
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3ea0
testb $0x1, %al
jne 0x7339
jmp 0x742f
leaq -0x28(%rbp), %rdi
callq 0x3400
movq (%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movl $0xf, %esi
callq 0x3f20
movq -0xa0(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3ee0
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3f70
movq %rax, -0x98(%rbp)
jmp 0x7384
movq -0x98(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movl $0xf0, %esi
callq 0x3f20
movq -0xb0(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3ee0
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3f70
movq %rax, -0xa8(%rbp)
jmp 0x73ca
movq -0xa8(%rbp), %rax
shrq $0x4, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
shlq $0x4, %rsi
movq -0x40(%rbp), %rax
addq %rax, %rsi
leaq 0x6dc9(%rip), %rdi      # 0xe1b8
callq 0x3f90
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x3fb0
jmp 0x7405
jmp 0x7407
leaq -0x28(%rbp), %rdi
callq 0x4020
jmp 0x7323
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x2840
jmp 0x7452
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x7445
movq -0x88(%rbp), %rdi
callq 0x2840
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x22b0
nop
nopl (%rax)
// File: skyleaworlder[P]AES/src/main.cpp
// Function: main
int main() {
    std::bitset<128> input(std::string("110010010000111111011010101000100010000101101000110000100011010011000100110001100110001010001011100000001101110000011100110100"));
    std::bitset<128> key(std::string("101011011111100001010100010110001010001010111011010010101001101010101111110111000101011000100000001001110011110100111100111100"));
    vector<byte> res { aes(input, key, 10) };
    for (byte elem : res)
        std::cout << elem << " ";
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl $0x0, -0x4(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x22c0
movq -0xe8(%rbp), %rdx
leaq 0x20ae(%rip), %rsi      # 0x9b6e
leaq -0x38(%rbp), %rdi
callq 0x7d30
jmp 0x7acb
xorl %eax, %eax
movl %eax, %edx
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7de0
jmp 0x7ade
leaq -0x38(%rbp), %rdi
callq 0x20c0
leaq -0x39(%rbp), %rdi
callq 0x21d0
leaq -0x81(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x22c0
movq -0xf0(%rbp), %rdx
leaq 0x20dc(%rip), %rsi      # 0x9bed
leaq -0x80(%rbp), %rdi
callq 0x7d30
jmp 0x7b1c
xorl %eax, %eax
movl %eax, %edx
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7de0
jmp 0x7b2f
leaq -0x80(%rbp), %rdi
callq 0x20c0
leaq -0x81(%rbp), %rdi
callq 0x21d0
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq -0xc0(%rbp), %rcx
movq -0xb8(%rbp), %r8
leaq -0xa0(%rbp), %rdi
movl $0xa, %r9d
callq 0x7460
leaq -0xa0(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rdi
callq 0x2f40
movq %rax, -0xd0(%rbp)
movq -0xc8(%rbp), %rdi
callq 0x2d90
movq %rax, -0xd8(%rbp)
leaq -0xd0(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x3ea0
testb $0x1, %al
jne 0x7bee
jmp 0x7cbe
leaq -0xd0(%rbp), %rdi
callq 0x3400
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
movq 0x63cd(%rip), %rdi      # 0xdfd8
leaq -0xe0(%rbp), %rsi
callq 0x7e40
movq %rax, -0xf8(%rbp)
jmp 0x7c20
movq -0xf8(%rbp), %rdi
leaq 0x203e(%rip), %rsi      # 0x9c6c
callq 0x2180
jmp 0x7c35
jmp 0x7c37
leaq -0xd0(%rbp), %rdi
callq 0x4020
jmp 0x7bd2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x7c68
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20c0
leaq -0x39(%rbp), %rdi
callq 0x21d0
jmp 0x7ceb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x7c96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x20c0
leaq -0x81(%rbp), %rdi
callq 0x21d0
jmp 0x7ceb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x2840
jmp 0x7ceb
movq 0x6313(%rip), %rdi      # 0xdfd8
movq 0x62fc(%rip), %rsi      # 0xdfc8
callq 0x21b0
jmp 0x7cd3
leaq -0xa0(%rbp), %rdi
callq 0x2840
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
nop
// File: porzell[P]PTest/examples/my_first_test.cpp
// Function: MyFirstTest5()
P_TEST(MyFirstTest) {
	std::string testString;

	testString += "hello";
	testString += ' ';
	testString += "world!";

	P_ASSERT(testString == "hello world!");
	P_EXPECT(testString == "goodbye world!");
	
	P_ASSERT(2 + 2 != 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
leaq -0x20(%rbp), %rdi
movq %rdi, -0x198(%rbp)
callq 0x2200
movq -0x198(%rbp), %rdi
leaq 0x5c94(%rip), %rsi      # 0x817d
callq 0x2180
jmp 0x24f0
leaq -0x20(%rbp), %rdi
movl $0x20, %esi
callq 0x2120
jmp 0x2500
leaq 0x5c82(%rip), %rsi      # 0x8189
leaq -0x20(%rbp), %rdi
callq 0x2180
jmp 0x2512
leaq 0x5c6a(%rip), %rsi      # 0x8183
leaq -0x20(%rbp), %rdi
callq 0x6aa0
movb %al, -0x199(%rbp)
jmp 0x252a
movb -0x199(%rbp), %al
andb $0x1, %al
movb %al, -0x2d(%rbp)
callq 0x2710
movq %rax, -0x1a8(%rbp)
movzbl -0x2d(%rbp), %esi
andl $0x1, %esi
leaq 0x5c41(%rip), %rdx      # 0x8190
leaq 0x5c55(%rip), %r8       # 0x81ab
xorl %eax, %eax
movl %eax, %r9d
leaq -0xa0(%rbp), %rdi
movl $0xc, %ecx
callq 0x6c10
jmp 0x256e
movq -0x1a8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
xorl %edx, %edx
callq 0x6ad0
jmp 0x2585
leaq -0xa0(%rbp), %rdi
callq 0x36a0
testb $0x1, -0x2d(%rbp)
jne 0x25d4
movl $0x1, -0xa4(%rbp)
jmp 0x26e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x26f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x36a0
jmp 0x26f7
callq 0x2710
movq %rax, -0x1b0(%rbp)
leaq 0x5ba9(%rip), %rdx      # 0x8190
leaq 0x5bda(%rip), %r8       # 0x81c8
xorl %esi, %esi
movl %esi, %r9d
leaq -0x118(%rbp), %rdi
movl $0xd, %ecx
callq 0x6c10
jmp 0x2606
movq -0x1b0(%rbp), %rdi
leaq -0x118(%rbp), %rsi
movl $0x1, %edx
callq 0x6ad0
jmp 0x2620
leaq -0x118(%rbp), %rdi
callq 0x36a0
movb $0x0, -0x119(%rbp)
callq 0x2710
movq %rax, -0x1b8(%rbp)
movzbl -0x119(%rbp), %esi
andl $0x1, %esi
leaq 0x5b40(%rip), %rdx      # 0x8190
leaq 0x5b90(%rip), %r8       # 0x81e7
xorl %eax, %eax
movl %eax, %r9d
leaq -0x190(%rbp), %rdi
movl $0xf, %ecx
callq 0x6c10
jmp 0x266f
movq -0x1b8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
xorl %edx, %edx
callq 0x6ad0
jmp 0x2686
leaq -0x190(%rbp), %rdi
callq 0x36a0
testb $0x1, -0x119(%rbp)
jne 0x26db
movl $0x1, -0xa4(%rbp)
jmp 0x26e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x36a0
jmp 0x26f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x36a0
jmp 0x26f7
movl $0x0, -0xa4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2110
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x2110
movq -0x28(%rbp), %rdi
callq 0x2250
nopl (%rax)
// File: snuke[P]a/src/compiler.cc
// Function: ReadCode(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void ReadCode(const char* filename, string* result) {
  ifstream ifs(filename);
  if (ifs.fail()) {
    cerr << "Error : FILE not found" << endl;
    exit(0);
  }
  string str;
  while (getline(ifs, str)) result->append(str + '\n');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x22d0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x2030
movb %al, -0x269(%rbp)
jmp 0x2978
movb -0x269(%rbp), %al
testb $0x1, %al
jne 0x2984
jmp 0x29d3
movq 0x3665(%rip), %rdi      # 0x5ff0
leaq 0x16b1(%rip), %rsi      # 0x4043
callq 0x2180
movq %rax, -0x278(%rbp)
jmp 0x29a0
movq -0x278(%rbp), %rdi
movq 0x360a(%rip), %rsi      # 0x5fb8
callq 0x21a0
jmp 0x29b5
xorl %edi, %edi
callq 0x2210
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x2ad1
leaq -0x248(%rbp), %rdi
callq 0x2250
leaq -0x218(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x2050
movq %rax, -0x280(%rbp)
jmp 0x29fb
movq -0x280(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2240
movb %al, -0x281(%rbp)
jmp 0x2a19
movb -0x281(%rbp), %al
testb $0x1, %al
jne 0x2a25
jmp 0x2aa4
movq -0x10(%rbp), %rax
movq %rax, -0x290(%rbp)
leaq -0x268(%rbp), %rdi
leaq -0x248(%rbp), %rsi
movl $0xa, %edx
callq 0x2e80
jmp 0x2a4a
movq -0x290(%rbp), %rdi
leaq -0x268(%rbp), %rsi
callq 0x22e0
jmp 0x2a5f
leaq -0x268(%rbp), %rdi
callq 0x2318
jmp 0x29df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x2ac5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x268(%rbp), %rdi
callq 0x2318
jmp 0x2ac5
leaq -0x248(%rbp), %rdi
callq 0x2318
leaq -0x218(%rbp), %rdi
callq 0x2070
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
leaq -0x248(%rbp), %rdi
callq 0x2318
leaq -0x218(%rbp), %rdi
callq 0x2070
movq -0x220(%rbp), %rdi
callq 0x2290
nopl (%rax)
// File: snuke[P]a/src/compiler.cc
// Function: Escape(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string Escape(const string& code) {
  string result;
  for (int i = 0; i < (int)code.size(); ++i) {
    if (code[i] == '\n') result += "\\n";
    else if (code[i] == '\?') result += "\\\?";
    else if (code[i] == '\t') result += "\\t";
    else if (code[i] == '\'') result += "\\\'";
    else if (code[i] == '\"') result += "\\\"";
    else if (code[i] == '\\') result += "\\\\";
    else result += code[i];
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x2250
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2100
movq %rax, %rcx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x2c88
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x21f0
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x2b7e
movq -0x38(%rbp), %rdi
leaq 0x1502(%rip), %rsi      # 0x405a
callq 0x2170
jmp 0x2b5f
jmp 0x2c78
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2318
jmp 0x2ca5
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x21f0
movsbl (%rax), %eax
cmpl $0x3f, %eax
jne 0x2baa
movq -0x38(%rbp), %rdi
leaq 0x14bf(%rip), %rsi      # 0x405d
callq 0x2170
jmp 0x2ba5
jmp 0x2c76
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x21f0
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x2bd6
movq -0x38(%rbp), %rdi
leaq 0x1496(%rip), %rsi      # 0x4060
callq 0x2170
jmp 0x2bd1
jmp 0x2c74
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x21f0
movsbl (%rax), %eax
cmpl $0x27, %eax
jne 0x2bff
movq -0x38(%rbp), %rdi
leaq 0x146d(%rip), %rsi      # 0x4063
callq 0x2170
jmp 0x2bfd
jmp 0x2c72
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x21f0
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x2c28
movq -0x38(%rbp), %rdi
leaq 0x1447(%rip), %rsi      # 0x4066
callq 0x2170
jmp 0x2c26
jmp 0x2c70
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x21f0
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x2c51
movq -0x38(%rbp), %rdi
leaq 0x1421(%rip), %rsi      # 0x4069
callq 0x2170
jmp 0x2c4f
jmp 0x2c6e
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x21f0
movq -0x38(%rbp), %rdi
movsbl (%rax), %esi
callq 0x20e0
jmp 0x2c6c
jmp 0x2c6e
jmp 0x2c70
jmp 0x2c72
jmp 0x2c74
jmp 0x2c76
jmp 0x2c78
jmp 0x2c7a
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2b1b
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2c9b
movq -0x38(%rbp), %rdi
callq 0x2318
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2290
nop
// File: ryanbarringtoncox[P]AVLTree/AVLTree.cpp
// Function: AVLTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::traversalPrint(Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*)
void AVLTree<T>::traversalPrint(Node<T>* n) {
	if(root != 0) {
		traversalPrint(n->getLeftChild());
		std::cout << n->getValue() << std::endl;
		traversalPrint(n->getRightChild());
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, (%rax)
je 0x7a27
movq -0x10(%rbp), %rdi
callq 0xd000
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
callq 0x7980
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xcf30
movq -0x58(%rbp), %rsi
movq 0x16605(%rip), %rdi     # 0x1dfd8
callq 0x2190
movq %rax, -0x50(%rbp)
jmp 0x79de
movq -0x50(%rbp), %rdi
movq 0x165df(%rip), %rsi     # 0x1dfc8
callq 0x21d0
jmp 0x79f0
leaq -0x30(%rbp), %rdi
callq 0x2100
movq -0x10(%rbp), %rdi
callq 0xd040
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
callq 0x7980
jmp 0x7a27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2100
jmp 0x7a2d
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
// File: ryanbarringtoncox[P]AVLTree/AVLTree.cpp
// Function: AVLTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::traversalPrintPost(Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*)
void AVLTree<T>::traversalPrintPost(Node<T>* n) {
	if(n != 0) {
		traversalPrintPost(n->getLeftChild());
		traversalPrintPost(n->getRightChild());
		std::cout << "Value is " << n->getValue() << std::endl;
		std::cout << "Balance is " << n->getBalance() << endl;		
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7b36
movq -0x10(%rbp), %rdi
callq 0xd000
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
callq 0x7a40
movq -0x10(%rbp), %rdi
callq 0xd040
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
callq 0x7a40
movq 0x16544(%rip), %rdi     # 0x1dfd8
leaq 0xc6d2(%rip), %rsi      # 0x1416d
callq 0x21a0
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xcf30
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x2190
movq %rax, -0x50(%rbp)
jmp 0x7ac8
movq -0x50(%rbp), %rdi
movq 0x164f5(%rip), %rsi     # 0x1dfc8
callq 0x21d0
jmp 0x7ada
leaq -0x30(%rbp), %rdi
callq 0x2100
movq 0x164ee(%rip), %rdi     # 0x1dfd8
leaq 0xc686(%rip), %rsi      # 0x14177
callq 0x21a0
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcf60
movq -0x68(%rbp), %rdi
movl %eax, %esi
callq 0x22b0
movq %rax, %rdi
movq 0x164b0(%rip), %rsi     # 0x1dfc8
callq 0x21d0
jmp 0x7b36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2100
jmp 0x7b3c
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
nop
// File: ryanbarringtoncox[P]AVLTree/AVLTree.cpp
// Function: AVLTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::traversalPrintIn(Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*)
void AVLTree<T>::traversalPrintIn(Node<T>* n) {
	if(n != 0) {
		traversalPrintIn(n->getLeftChild());		
		std::cout << "Value is " << n->getValue() << std::endl;
		std::cout << "Balance is " << n->getBalance() << endl;
		//cout << "It's address is " << n << endl;
		traversalPrintIn(n->getRightChild());
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7c46
movq -0x10(%rbp), %rdi
callq 0xd000
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
callq 0x7b50
movq 0x16449(%rip), %rdi     # 0x1dfd8
leaq 0xc5d7(%rip), %rsi      # 0x1416d
callq 0x21a0
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xcf30
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x2190
movq %rax, -0x50(%rbp)
jmp 0x7bc3
movq -0x50(%rbp), %rdi
movq 0x163fa(%rip), %rsi     # 0x1dfc8
callq 0x21d0
jmp 0x7bd5
leaq -0x30(%rbp), %rdi
callq 0x2100
movq 0x163f3(%rip), %rdi     # 0x1dfd8
leaq 0xc58b(%rip), %rsi      # 0x14177
callq 0x21a0
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcf60
movq -0x68(%rbp), %rdi
movl %eax, %esi
callq 0x22b0
movq %rax, %rdi
movq 0x163b5(%rip), %rsi     # 0x1dfc8
callq 0x21d0
movq -0x10(%rbp), %rdi
callq 0xd040
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
callq 0x7b50
jmp 0x7c46
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2100
jmp 0x7c4c
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
nop
// File: ryanbarringtoncox[P]AVLTree/AVLTree.cpp
// Function: AVLTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::leftRotation(Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>**)
void AVLTree<T>::leftRotation(Node<T>* cn, Node<T>** parent) {
	cout << "Left Rotation on " << cn->getValue() << endl;
	Node<T>* newRoot = cn->getRightChild();
	Node<T>* tempLC = newRoot->getLeftChild();
	*parent = newRoot;
	newRoot->setLeftChild(*cn);
	cn->setRightChild(*tempLC);	
	
	//special case
	if (tempLC != 0 && newRoot->getRightChild() != 0) newRoot->getRightChild()->incBalance();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x1635d(%rip), %rdi     # 0x1dfd8
leaq 0xc501(%rip), %rsi      # 0x14183
callq 0x21a0
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xcf30
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x2190
movq %rax, -0x60(%rbp)
jmp 0x7caf
movq -0x60(%rbp), %rdi
movq 0x1630e(%rip), %rsi     # 0x1dfc8
callq 0x21d0
jmp 0x7cc1
leaq -0x38(%rbp), %rdi
callq 0x2100
movq -0x10(%rbp), %rdi
callq 0xd040
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0xd000
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd020
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xd060
cmpq $0x0, -0x58(%rbp)
je 0x7d4f
movq -0x50(%rbp), %rdi
callq 0xd040
cmpq $0x0, (%rax)
je 0x7d4f
movq -0x50(%rbp), %rdi
callq 0xd040
movq (%rax), %rdi
callq 0xcf80
jmp 0x7d4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2100
jmp 0x7d55
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x22c0
nop
// File: ryanbarringtoncox[P]AVLTree/AVLTree.cpp
// Function: AVLTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::rightRotation(Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>**)
void AVLTree<T>::rightRotation(Node<T>* cn, Node<T>** parent) {	
	cout << "Right rotation on " << cn->getValue() << endl;
	Node<T>* newRoot = cn->getLeftChild();
	Node<T>* tempRC = newRoot->getRightChild();	
	*parent = newRoot;
	newRoot->setRightChild(*cn);
	cn->setLeftChild(*tempRC);	

	//special case
	if (tempRC != 0 && newRoot->getLeftChild() != 0) newRoot->getLeftChild()->decBalance();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x1625d(%rip), %rdi     # 0x1dfd8
leaq 0xc413(%rip), %rsi      # 0x14195
callq 0x21a0
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xcf30
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x2190
movq %rax, -0x60(%rbp)
jmp 0x7daf
movq -0x60(%rbp), %rdi
movq 0x1620e(%rip), %rsi     # 0x1dfc8
callq 0x21d0
jmp 0x7dc1
leaq -0x38(%rbp), %rdi
callq 0x2100
movq -0x10(%rbp), %rdi
callq 0xd000
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0xd040
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd060
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xd020
cmpq $0x0, -0x58(%rbp)
je 0x7e4f
movq -0x50(%rbp), %rdi
callq 0xd000
cmpq $0x0, (%rax)
je 0x7e4f
movq -0x50(%rbp), %rdi
callq 0xd000
movq (%rax), %rdi
callq 0xcfa0
jmp 0x7e4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2100
jmp 0x7e55
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x22c0
nop
// File: ryanbarringtoncox[P]AVLTree/AVLTree.cpp
// Function: AVLTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool AVLTree<T>::find(T v) {
	Node<T>** curr =&root;
	
	while(*curr!=0 && (*curr)->getValue()!= v) {
		if (v < (*curr)->getValue()) {
			curr = &((*curr)->getLeftChild());
		} else if (v > (*curr)->getValue()) {
			curr = &((*curr)->getRightChild());
		}    
	}
	
	if (*curr==0) {
		return false;
	}
	else {
		return true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movb $0x0, -0x41(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x91(%rbp)
je 0x7ef5
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0xcf30
movq -0x90(%rbp), %rsi
movb $0x1, -0x41(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7ff0
movb %al, -0x91(%rbp)
movb -0x91(%rbp), %al
movb %al, -0x92(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x7f09
jmp 0x7f12
leaq -0x40(%rbp), %rdi
callq 0x2100
movb -0x92(%rbp), %al
testb $0x1, %al
jne 0x7f21
jmp 0x7fc9
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq -0x68(%rbp), %rdi
callq 0xcf30
movq -0x90(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x8020
movb %al, -0x93(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2100
movb -0x93(%rbp), %al
testb $0x1, %al
jne 0x7f5c
jmp 0x7f6e
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xd000
movq %rax, -0x20(%rbp)
jmp 0x7fc4
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq -0x88(%rbp), %rdi
callq 0xcf30
movq -0x90(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x8060
movb %al, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2100
movb -0x94(%rbp), %al
testb $0x1, %al
jne 0x7fb2
jmp 0x7fc2
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xd040
movq %rax, -0x20(%rbp)
jmp 0x7fc4
jmp 0x7eb2
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x7fd9
movb $0x0, -0x1(%rbp)
jmp 0x7fdd
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ryanbarringtoncox[P]AVLTree/Node.cpp
// Function: Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Node<T>::Node(T v) {
	value = v;
	leftChild = 0;
	rightChild = 0;
	parent = 0;
	balance = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x2250
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2040
jmp 0xcee7
movq -0x38(%rbp), %rax
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x38(%rax)
movl $0x0, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2100
movq -0x18(%rbp), %rdi
callq 0x22c0
nop
// File: ryanbarringtoncox[P]AVLTree/TwoDArray.cpp
// Function: TwoDArray<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::TwoDArray(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
TwoDArray<T>::TwoDArray(int r, int c, T def) {
	assert(r > 0 && c > 0);	
	numRows = r;
	numColumns = c;
	deffy = def;
	theArray.resize(r);	
	for(int i = 0; i < r; ++i) {
		theArray[i].resize(c);
	}
	
	for(int i = 0; i < numRows; ++i) {
		for (int j = 0; j < numColumns; ++j) {
			theArray[i][j]=def;
		}
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xe100
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x40(%rbp)
callq 0x2250
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x31(%rbp)
jle 0xdfcd
cmpl $0x0, -0x10(%rbp)
setg %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xdfd6
jmp 0xdfd8
jmp 0xdff7
leaq 0x6258(%rip), %rdi      # 0x14237
leaq 0x6260(%rip), %rsi      # 0x14246
movl $0xd, %edx
leaq 0x642e(%rip), %rcx      # 0x14420
callq 0x2110
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x18(%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0x1c(%rdi)
addq $0x20, %rdi
callq 0x2040
jmp 0xe016
movq -0x48(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0xe120
jmp 0xe025
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xe07c
movq -0x48(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0xe1b0
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0xe1d0
jmp 0xe04f
jmp 0xe051
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xe02c
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2100
movq -0x48(%rbp), %rdi
callq 0xe280
jmp 0xe0e9
movl $0x0, -0x2c(%rbp)
movq -0x48(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0xe0e3
movl $0x0, -0x30(%rbp)
movq -0x48(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jge 0xe0d6
movq -0x48(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0xe1b0
movq %rax, %rdi
movslq -0x30(%rbp), %rsi
callq 0xe260
movq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x2040
jmp 0xe0c9
jmp 0xe0cb
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xe096
jmp 0xe0d8
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xe083
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ryanbarringtoncox[P]AVLTree/TwoDArray.cpp
// Function: TwoDArray<int>::print()
void TwoDArray<T>::print() {	
	for(int i = 0; i < numRows; ++i) {
		for (int j = 0; j < numColumns; ++j) {
			cout << theArray[i][j]	<< " ";
		}
		cout << endl;
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0xd8e9
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jge 0xd8cb
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0xd500
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0xd5b0
movl (%rax), %esi
movq 0x1072c(%rip), %rdi     # 0x1dfd8
callq 0x22b0
movq %rax, %rdi
leaq 0x6772(%rip), %rsi      # 0x1402d
callq 0x21a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd87e
movq 0x10706(%rip), %rdi     # 0x1dfd8
movq 0x106ef(%rip), %rsi     # 0x1dfc8
callq 0x21d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd86b
addq $0x20, %rsp
popq %rbp
retq
nop
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_07.cc
// Function: main
int main(int argc, char const *argv[])
{
	std::string s[] = { "sss" };
	std::cout << getSize(s) << std::endl;

	char c[] = "s";
	std::cout << getSize(c) << std::endl;
	// the output is 2, as '\0' is added at the end of the array
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x1, -0x4d(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %rax, -0x38(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x10b0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0xdbf(%rip), %rsi       # 0x2004
callq 0x1080
jmp 0x124c
movb $0x0, -0x4d(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x1070
leaq -0x30(%rbp), %rdi
callq 0x1400
movq %rax, -0x68(%rbp)
jmp 0x1268
movq -0x68(%rbp), %rsi
movq 0x2d65(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, -0x70(%rbp)
jmp 0x127e
movq -0x70(%rbp), %rdi
movq 0x2d3f(%rip), %rsi      # 0x3fc8
callq 0x1060
jmp 0x1290
movw $0x73, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1410
movq %rax, -0x78(%rbp)
jmp 0x12a5
movq -0x78(%rbp), %rsi
movq 0x2d28(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, -0x80(%rbp)
jmp 0x12bb
movq -0x80(%rbp), %rdi
movq 0x2d02(%rip), %rsi      # 0x3fc8
callq 0x1060
jmp 0x12cd
movl $0x0, -0x4(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x90(%rbp)
addq $0x20, %rax
movq %rax, -0x88(%rbp)
jmp 0x1379
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x1070
testb $0x1, -0x4d(%rbp)
jne 0x130c
jmp 0x1350
movq -0x38(%rbp), %rax
leaq -0x30(%rbp), %rcx
cmpq %rax, %rcx
movq %rax, -0x98(%rbp)
je 0x134e
movq -0x98(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1040
movq -0xa0(%rbp), %rax
leaq -0x30(%rbp), %rcx
cmpq %rcx, %rax
movq %rax, -0x98(%rbp)
jne 0x1320
jmp 0x1350
jmp 0x13e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0xb0(%rbp)
addq $0x20, %rax
movq %rax, -0xa8(%rbp)
jmp 0x13b6
movq -0x88(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0xb8(%rbp)
callq 0x1040
movq -0x90(%rbp), %rcx
movq -0xb8(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x88(%rbp)
jne 0x1379
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0xc0(%rbp)
callq 0x1040
movq -0xb0(%rbp), %rcx
movq -0xc0(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0xa8(%rbp)
jne 0x13b6
jmp 0x13e9
movq -0x48(%rbp), %rdi
callq 0x10a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: LiGaCu[P]Distributed_System_to_Compute_the_Shortest_Path/aws.cpp
// Function: getTCPsockandbind(addrinfo*)
int getTCPsockandbind(struct addrinfo *servinfo)
{
    int sockfd;
    struct addrinfo *p;
    int reuseaddr=1;

    // loop through all the results and bind to the first we can
    for(p = servinfo; p != NULL; p = p->ai_next) 
    {
        if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) 
        {
            perror("server: socket");
            continue;
        }
        if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(int)) == -1) 
        {
            perror("setsockopt");
            exit(1);
        }
        if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) 
        {
            close(sockfd);
            perror("server: bind");
            continue;
        }
        break;
    }
    if (p == NULL) 
    {
        fprintf(stderr, "server: failed to bind\n");
        exit(1);
    }

    return sockfd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3642
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x2080
movl %eax, -0xc(%rbp)
cmpl $-0x1, %eax
jne 0x35c6
leaq 0x1d4d(%rip), %rdi      # 0x530c
callq 0x2180
jmp 0x3631
movl -0xc(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x1c(%rbp), %rcx
movl $0x4, %r8d
callq 0x2370
cmpl $-0x1, %eax
jne 0x35fd
leaq 0x1d2d(%rip), %rdi      # 0x531b
callq 0x2180
movl $0x1, %edi
callq 0x2250
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x2060
cmpl $-0x1, %eax
jne 0x362f
movl -0xc(%rbp), %edi
callq 0x23a0
leaq 0x1cfe(%rip), %rdi      # 0x5326
callq 0x2180
jmp 0x3631
jmp 0x3642
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x358b
cmpq $0x0, -0x18(%rbp)
jne 0x366b
movq 0x3988(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
leaq 0x1cd9(%rip), %rsi      # 0x5333
movb $0x0, %al
callq 0x22f0
movl $0x1, %edi
callq 0x2250
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tobias93[P]piano/rtaudio/tests/playsaw.cpp
// Function: usage()
void usage( void ) {
  // Error function in case of incorrect command-line
  // argument specifications
  std::cout << "\nuseage: playsaw N fs <device> <channelOffset> <time>\n";
  std::cout << "    where N = number of channels,\n";
  std::cout << "    fs = the sample rate,\n";
  std::cout << "    device = optional device to use (default = 0),\n";
  std::cout << "    channelOffset = an optional channel offset on the device (default = 0),\n";
  std::cout << "    and time = an optional time duration in seconds (default = no limit).\n\n";
  exit( 0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xf92d(%rip), %rdi      # 0x17fc8
leaq 0xa996(%rip), %rsi      # 0x13038
callq 0x8210
movq 0xf91a(%rip), %rdi      # 0x17fc8
leaq 0xa9ba(%rip), %rsi      # 0x1306f
callq 0x8210
movq 0xf907(%rip), %rdi      # 0x17fc8
leaq 0xa9ca(%rip), %rsi      # 0x13092
callq 0x8210
movq 0xf8f4(%rip), %rdi      # 0x17fc8
leaq 0xa9d2(%rip), %rsi      # 0x130ad
callq 0x8210
movq 0xf8e1(%rip), %rdi      # 0x17fc8
leaq 0xa9f3(%rip), %rsi      # 0x130e1
callq 0x8210
movq 0xf8ce(%rip), %rdi      # 0x17fc8
leaq 0xaa2d(%rip), %rsi      # 0x1312e
callq 0x8210
xorl %edi, %edi
callq 0x82e0
nopl (%rax)
// File: tobias93[P]piano/rtaudio/tests/playsaw.cpp
// Function: errorCallback(RtAudioError::Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void errorCallback( RtAudioError::Type type, const std::string &errorText )
{
  // This example error handling function does exactly the same thing
  // as the embedded RtAudio::error() function.
  std::cout << "in errorCallback" << std::endl;
  if ( type == RtAudioError::WARNING )
    std::cerr << '\n' << errorText << "\n\n";
  else if ( type != RtAudioError::WARNING )
    throw( RtAudioError( errorText, type ) );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xf8a2(%rip), %rdi      # 0x17fc8
leaq 0xaa4d(%rip), %rsi      # 0x1317a
callq 0x8210
movq %rax, %rdi
movq 0xf874(%rip), %rsi      # 0x17fb0
callq 0x8250
cmpl $0x0, -0x4(%rbp)
jne 0x8775
movq 0xf8a2(%rip), %rdi      # 0x17ff0
movl $0xa, %esi
callq 0x82a0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x81e0
movq %rax, %rdi
leaq 0xac43(%rip), %rsi      # 0x133b1
callq 0x8210
jmp 0x87b1
cmpl $0x0, -0x4(%rbp)
je 0x87af
movl $0x30, %edi
callq 0x8110
movq %rax, %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movl -0x4(%rbp), %edx
callq 0x8cd0
movq -0x18(%rbp), %rdi
leaq 0xf455(%rip), %rsi      # 0x17bf8
leaq 0x586(%rip), %rdx       # 0x8d30
callq 0x8450
jmp 0x87b1
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)