LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::SetPixelAtLayer(int, int, int, Color const&)
void CompositeFlaschenTaschen::SetPixelAtLayer(int x, int y, int layer,
                                               const Color &col) {
    screens_[layer]->At(x, y) = col;
    if (layer >= z_buffer_->At(x, y)) {
        any_visible_pixel_drawn_ = true;
        if (col.is_black()) {
            // Transparent pixel. Find closest stacked below us that is not.
            for (/**/; layer > 0; --layer) {
                if (!screens_[layer]->At(x, y).is_black())
                    break;
            }
            delegatee_->SetPixel(x, y, screens_[layer]->At(x, y));
        } else {
            delegatee_->SetPixel(x, y, col);
        }
        z_buffer_->At(x, y) = layer;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %ebx
movl %esi, %ebp
movslq %ecx, %rax
movq 0x28(%rdi), %rcx
movq (%rcx,%rax,8), %rcx
movq 0x8(%rcx), %rdx
movl (%rcx), %ecx
imull %ebx, %ecx
addl %esi, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movb 0x2(%r8), %sil
movb %sil, 0x2(%rdx,%rcx)
movzwl (%r8), %esi
movw %si, (%rdx,%rcx)
movq 0x40(%rdi), %rcx
movq 0x8(%rcx), %rdx
movl (%rcx), %ecx
imull %ebx, %ecx
addl %ebp, %ecx
movslq %ecx, %rcx
cmpl %eax, (%rdx,%rcx,4)
jg 0x3079
movq %rdi, %r15
movb $0x1, 0x1c(%rdi)
cmpb $0x0, (%r8)
jne 0x3054
cmpb $0x0, 0x1(%r8)
jne 0x3054
cmpb $0x0, 0x2(%r8)
jne 0x3054
testl %r14d, %r14d
jle 0x302a
movq 0x28(%r15), %rax
movl %r14d, %ecx
movq (%rax,%rcx,8), %rdx
movq 0x8(%rdx), %rcx
movl (%rdx), %edx
imull %ebx, %edx
addl %ebp, %edx
movslq %edx, %rdx
leaq (%rdx,%rdx,2), %rdx
movb 0x1(%rcx,%rdx), %sil
orb (%rcx,%rdx), %sil
jne 0x302a
addq %rdx, %rcx
cmpb $0x0, 0x2(%rcx)
jne 0x302a
leal -0x1(%r14), %ecx
cmpl $0x1, %r14d
movl %ecx, %r14d
jg 0x2fed
xorl %r14d, %r14d
movslq %r14d, %rax
movq 0x8(%r15), %rdi
movq 0x28(%r15), %rcx
movq (%rcx,%rax,8), %rax
movl (%rax), %ecx
imull %ebx, %ecx
addl %ebp, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
addq 0x8(%rax), %rcx
movq (%rdi), %rax
movl %ebp, %esi
movl %ebx, %edx
jmp 0x3062
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movl %ebp, %esi
movl %ebx, %edx
movq %r8, %rcx
callq *0x20(%rax)
movq 0x40(%r15), %rax
imull (%rax), %ebx
movq 0x8(%rax), %rax
addl %ebp, %ebx
movslq %ebx, %rcx
movl %r14d, (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::Send()
void CompositeFlaschenTaschen::Send() {
    // Don't send anything if we only had pixels in hidden layers.
    if (any_visible_pixel_drawn_)
        delegatee_->Send();
    any_visible_pixel_drawn_ = false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1c(%rdi)
jne 0x3098
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x0, 0x1c(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::SetLayer(int)
void CompositeFlaschenTaschen::SetLayer(int layer) {
    if (layer < 0) layer = 0;
    if (layer >= (int)screens_.size()) layer = screens_.size() - 1;
    current_layer_ = layer;
    last_layer_update_time_[current_layer_] = current_time_;
}

// Assembly:
xorl %eax, %eax
testl %esi, %esi
cmovgl %esi, %eax
movq 0x30(%rdi), %rcx
subq 0x28(%rdi), %rcx
shrq $0x3, %rcx
leal -0x1(%rcx), %edx
cmpl %ecx, %eax
cmovll %eax, %edx
movl %edx, 0x18(%rdi)
movl 0x20(%rdi), %eax
movslq %edx, %rcx
movq 0x48(%rdi), %rdx
movl %eax, (%rdx,%rcx,4)
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::StartLayerGarbageCollection(ft::Mutex*, int)
void CompositeFlaschenTaschen::StartLayerGarbageCollection(ft::Mutex *lock,
                                                           int timeout_seconds) {
    assert(garbage_collect_ == NULL);  // only start once.
    assert(lock != NULL);  // Must provide mutex.
    garbage_collect_ = new LayerGarbageCollector(this, lock, timeout_seconds);
    garbage_collect_->Start();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x60(%rdi)
jne 0x314d
movq %rsi, %r15
testq %rsi, %rsi
je 0x316c
movl %edx, %ebp
movq %rdi, %rbx
movl $0x68, %edi
callq 0x21d0
movq %rax, %r14
movq %rax, %rdi
callq 0x27cc
leaq 0x4bc3(%rip), %rax      # 0x7cc8
movq %rax, (%r14)
movq %rbx, 0x18(%r14)
movq %r15, 0x20(%r14)
movl %ebp, 0x28(%r14)
movb $0x1, 0x60(%r14)
movl $0x0, 0x64(%r14)
movq %r14, %rdi
addq $0x30, %rdi
xorl %esi, %esi
callq 0x2210
movq %r14, 0x60(%rbx)
movq (%r14), %rax
movq 0x10(%rax), %rax
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
leaq 0x21b3(%rip), %rdi      # 0x5307
leaq 0x2143(%rip), %rsi      # 0x529e
leaq 0x21be(%rip), %rcx      # 0x5320
movl $0x9e, %edx
callq 0x2140
leaq 0x21fa(%rip), %rdi      # 0x536d
leaq 0x2124(%rip), %rsi      # 0x529e
leaq 0x219f(%rip), %rcx      # 0x5320
movl $0x9f, %edx
callq 0x2140
movq %rax, %rbx
movl $0x68, %esi
movq %r14, %rdi
callq 0x21e0
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::LayerGarbageCollector::Run()
void Run() {
        for (;;) {
            ft::MutexLock m(lock_);
            lock_->WaitOnWithTimeout(&running_cond_, 1000);
            if (!running_) break;
            owner_->ClearLayersOlderThan(ticks_ - max_age_);
            owner_->SetTimeTicks(ticks_);
            ++ticks_;  // one tick, roughly one second.
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
movq 0x20(%rbx), %r15
movq %r15, %rdi
callq 0x22a0
movq 0x20(%rbx), %rdi
movq %r14, %rsi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x2906
movb 0x60(%rbx), %bpl
testb %bpl, %bpl
je 0x331e
movq 0x18(%rbx), %rdi
movl 0x64(%rbx), %esi
subl 0x28(%rbx), %esi
callq 0x31a4
movq 0x18(%rbx), %rax
movl 0x64(%rbx), %ecx
movl %ecx, 0x20(%rax)
incl %ecx
movl %ecx, 0x64(%rbx)
movq %r15, %rdi
callq 0x2160
testb %bpl, %bpl
jne 0x32c2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2160
movq %rax, %rbx
movq %r15, %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]FlaschenTaschen-PixelPusher-bridge/ppm-reader.cc
// Function: ReadImageData(char const*, unsigned long, ImageMetaInfo*)
const char *ReadImageData(const char *in_buffer, size_t buf_len,
                          struct ImageMetaInfo *info) {
    if (in_buffer[0] != 'P' || in_buffer[1] != '6' ||
        (!isspace(in_buffer[2]) && in_buffer[2] != '#')) {
        return in_buffer;  // raw image. No P6 magic header.
    }
    const char *const end = in_buffer + buf_len;
    const char *parse_buffer = in_buffer + 2;
    const int width = readNextNumber(&parse_buffer, end, info);
    if (parse_buffer == NULL) return in_buffer;
    const int height = readNextNumber(&parse_buffer, end, info);
    if (parse_buffer == NULL) return in_buffer;
    const int range = readNextNumber(&parse_buffer, end, info);
    if (parse_buffer == NULL) return in_buffer;
    if (!isspace(*parse_buffer++)) return in_buffer;   // last char before data
    // Now make sure that the rest of the buffer still makes sense
    const size_t expected_image_data = width * height * 3;
    const size_t actual_data = end - parse_buffer;
    if (actual_data < expected_image_data)
        return in_buffer;   // Uh, not enough data.
    if (actual_data > expected_image_data) {
        // Our extension: at the end of the binary data, we provide an optional
        // offset. We can't store it in the header, as it is fixed in number
        // of fields. But nobody cares what is at the end of the buffer.
        // Note, this also can be supplied in the specially formatted comment
        // in the header.
        parseOffsets(parse_buffer + expected_image_data, end, info);
    }
    info->width = width;
    info->height = height;
    info->range = range;
    return parse_buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x50, (%rdi)
jne 0x36e4
cmpb $0x36, 0x1(%rbx)
jne 0x36e4
movq %rdx, %r14
movq %rsi, %r15
movsbl 0x2(%rbx), %ebp
movl %ebp, %edi
callq 0x2060
cmpl $0x23, %ebp
je 0x362e
testl %eax, %eax
je 0x36e4
leaq 0x2(%rbx), %rax
addq %rbx, %r15
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x36f6
cmpq $0x0, (%r12)
je 0x36e4
movl %eax, %ebp
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x36f6
cmpq $0x0, (%r13)
je 0x36e4
movl %eax, %r12d
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x36f6
movq (%r13), %rcx
testq %rcx, %rcx
je 0x36e4
movl %eax, 0x14(%rsp)
leaq 0x1(%rcx), %r13
movq %r13, 0x8(%rsp)
movsbl (%rcx), %edi
callq 0x2060
testl %eax, %eax
je 0x36e4
movl %ebp, %eax
imull %r12d, %eax
leal (%rax,%rax,2), %eax
movslq %eax, %rdi
movq %r15, %rax
subq %r13, %rax
cmpq %rdi, %rax
jb 0x36e4
jbe 0x36d2
addq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x380b
movl %ebp, (%r14)
movl %r12d, 0x4(%r14)
movl 0x14(%rsp), %eax
movl %eax, 0x8(%r14)
movq %r13, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]FlaschenTaschen-PixelPusher-bridge/ppm-reader.cc
// Function: readNextNumber(char const**, char const*, ImageMetaInfo*)
static int readNextNumber(const char **start, const char *end,
                          struct ImageMetaInfo *info) {
    const char *start_number = skipWhitespace(*start, end, info);
    if (start_number == NULL) { *start = NULL; return 0; }
    char *end_number = NULL;
    int result = strtol(start_number, &end_number, 10);
    if (end_number == start_number) { *start = NULL; return 0; }
    *start = end_number;
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r13
cmpq %rsi, %r13
setb %r12b
jae 0x37c0
movq %rdx, %r14
movq %rsi, %r15
movsbl (%r13), %edi
callq 0x2060
testl %eax, %eax
je 0x374c
incq %r13
cmpq %r15, %r13
setb %r12b
jae 0x37c0
movsbl (%r13), %edi
callq 0x2060
incq %r13
testl %eax, %eax
jne 0x372b
decq %r13
movq %r13, %rbp
testb $0x1, %r12b
je 0x37c0
cmpb $0x23, (%rbp)
jne 0x37c2
movq %rbp, %r13
cmpq %r15, %rbp
jae 0x3778
movq %rbp, %r13
cmpb $0xa, (%r13)
je 0x3778
incq %r13
cmpq %r15, %r13
jb 0x3766
movq %r15, %r13
testq %r14, %r14
je 0x37b3
movq %r13, %rax
subq %rbp, %rax
cmpq $0x4, %rax
jl 0x37b3
movl $0x4, %edx
movq %rbp, %rdi
leaq 0x1c5d(%rip), %rsi      # 0x53f5
callq 0x20d0
testl %eax, %eax
jne 0x37b3
addq $0x4, %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x380b
cmpq %r15, %r13
setb %r12b
jb 0x371a
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x37f3
xorl %r15d, %r15d
movq %rsp, %r14
movq %r15, (%r14)
movq %rbp, %rdi
movq %r14, %rsi
movl $0xa, %edx
callq 0x2270
movq (%r14), %rcx
cmpq %rbp, %rcx
cmoveq %r15, %rcx
cmovel %r15d, %eax
movq %rcx, (%rbx)
jmp 0x37fc
movq $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]FlaschenTaschen-PixelPusher-bridge/ppm-reader.cc
// Function: parseOffsets(char const*, char const*, ImageMetaInfo*)
static void parseOffsets(const char *start, const char *end,
                         struct ImageMetaInfo *info) {
    info->offset_x = readNextNumber(&start, end, NULL);
    if (start != NULL) {
        info->offset_y = readNextNumber(&start, end, NULL);
    }
    if (start != NULL) {
        info->layer = readNextNumber(&start, end, NULL);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x8(%rsp), %r15
movq %rdi, (%r15)
movq %r15, %rdi
xorl %edx, %edx
callq 0x36f6
movl %eax, 0xc(%rbx)
cmpq $0x0, (%r15)
je 0x3847
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x36f6
movl %eax, 0x10(%rbx)
cmpq $0x0, 0x8(%rsp)
je 0x3861
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x36f6
movl %eax, 0x14(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]FlaschenTaschen-PixelPusher-bridge/pixel-pusher-client.cc
// Function: PixelPusherClient::SetPixel(int, int, Color const&)
void PixelPusherClient::SetPixel(int x, int y, const Color &col) {
    if (x < 0 || x >= width_ || y < 0 || y >= height_) return;
    Color *row = (Color*) (pixel_buffer_ + y*row_size_ + 1);
    Color new_color = CIEMapColor(brightness_percent_, col);
    const int packet = y / rows_per_packet_;
    block_dirty_[packet] |= (row[x].r != new_color.r ||
                             row[x].g != new_color.g ||
                             row[x].b != new_color.b);
    row[x] = new_color;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x3b99
movl %edx, %r14d
testl %edx, %edx
js 0x3b99
movl %esi, %ebp
movq %rdi, %rbx
cmpl %esi, 0x8(%rdi)
jle 0x3b99
cmpl %r14d, 0xc(%rbx)
jle 0x3b99
movq %rcx, %r15
movl %r14d, %r12d
imulq 0x18(%rbx), %r12
movq 0x38(%rbx), %rax
movq %rax, (%rsp)
movzbl 0x28(%rbx), %r13d
movb 0x4738(%rip), %al       # 0x8250
testb %al, %al
je 0x3ba8
shll $0x9, %r13d
addq 0x471d(%rip), %r13      # 0x8248
movzbl (%r15), %eax
movb -0x200(%r13,%rax,2), %cl
movzbl 0x1(%r15), %eax
movb -0x200(%r13,%rax,2), %sil
movzbl 0x2(%r15), %eax
movzwl -0x200(%r13,%rax,2), %edi
movl %r14d, %eax
cltd
idivl 0x20(%rbx)
movq (%rsp), %rdx
leaq (%rdx,%r12), %r9
incq %r9
movl %ebp, %edx
leaq (%rdx,%rdx,2), %r10
leaq (%r9,%r10), %rdx
movb $0x1, %r8b
cmpb %cl, (%r9,%r10)
jne 0x3b85
cmpb %sil, 0x1(%rdx)
jne 0x3b85
cmpb %dil, 0x2(%rdx)
setne %r8b
movq 0x30(%rbx), %r9
cltq
orb %r8b, (%r9,%rax)
movb %cl, (%rdx)
movb %sil, 0x1(%rdx)
movb %dil, 0x2(%rdx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x46a1(%rip), %rdi      # 0x8250
callq 0x2340
testl %eax, %eax
je 0x3b20
callq 0x3cc3
movq %rax, 0x4680(%rip)      # 0x8248
leaq 0x4681(%rip), %rdi      # 0x8250
callq 0x2130
jmp 0x3b20
movq %rax, %rbx
leaq 0x466d(%rip), %rdi      # 0x8250
callq 0x2120
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]FlaschenTaschen-PixelPusher-bridge/pixel-pusher-client.cc
// Function: PixelPusherClient::SendPacket(int)
bool PixelPusherClient::SendPacket(int packet_index) {
    if (socket_ < 0) return false;
    const size_t block_size = rows_per_packet_ * row_size_;
    const size_t start = packet_index * block_size;
    const size_t end = height_ * row_size_;
    if (start >= end) return false;

    if (block_dirty_[packet_index]) {
        // Each packet has a sequence number in the beginning, but our pixel
        // buffer if contiguous.
        // So we stuff it in front atomically with writev().
        iovec parts[2];
        parts[0].iov_base = &sequence_number_;
        parts[0].iov_len = sizeof(sequence_number_);
        parts[1].iov_base = pixel_buffer_ + start;
        parts[1].iov_len = std::min(end - start, block_size);
        writev(socket_, parts, 2);

        sequence_number_++;
    }

    return (packet_index + 1) * block_size < end;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl 0x10(%rdi), %edi
testl %edi, %edi
js 0x3c7b
movl %esi, %ebx
movslq 0x20(%r14), %r15
movq 0x18(%r14), %rcx
imulq %rcx, %r15
movslq %esi, %rdx
movq %r15, %rax
imulq %rdx, %rax
movslq 0xc(%r14), %r12
imulq %rcx, %r12
movq %r12, %rcx
subq %rax, %rcx
jbe 0x3c7b
movq 0x30(%r14), %rsi
cmpb $0x1, (%rsi,%rdx)
jne 0x3c6a
leaq 0x40(%r14), %rdx
movq %rsp, %rsi
movq %rdx, (%rsi)
movq $0x4, 0x8(%rsi)
addq 0x38(%r14), %rax
movq %rax, 0x10(%rsi)
cmpq %rcx, %r15
cmovbq %r15, %rcx
movq %rcx, 0x18(%rsi)
movl $0x2, %edx
callq 0x20f0
incl 0x40(%r14)
incl %ebx
movslq %ebx, %rax
imulq %rax, %r15
cmpq %r12, %r15
setb %al
jmp 0x3c7d
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]FlaschenTaschen-PixelPusher-bridge/pixel-pusher-client.cc
// Function: CreateLuminanceCIE1931LookupTable()
static ColorLookup *CreateLuminanceCIE1931LookupTable() {
  ColorLookup *for_brightness = new ColorLookup[100];
  for (int c = 0; c < 256; ++c)
    for (int b = 0; b < 100; ++b)
      for_brightness[b].color[c] = luminance_cie1931(c, b + 1);

  return for_brightness;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl $0xc800, %edi           # imm = 0xC800
callq 0x2040
movq %rax, %rbx
xorl %r14d, %r14d
movss 0x1715(%rip), %xmm1     # 0x53fc
movss 0x1711(%rip), %xmm2     # 0x5400
movsd 0x1729(%rip), %xmm3     # 0x5420
movq %rax, %r15
movzbl %r14b, %eax
xorps %xmm4, %xmm4
cvtsi2ss %eax, %xmm4
movq $-0xc800, %r12          # imm = 0xFFFF3800
movb $0x1, %bpl
movss %xmm4, 0xc(%rsp)
movzbl %bpl, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss %xmm4, %xmm0
divss %xmm1, %xmm0
ucomiss %xmm0, %xmm2
jae 0x3d6e
addss 0x16cf(%rip), %xmm0     # 0x5404
cvtss2sd %xmm0, %xmm0
divsd 0x16cf(%rip), %xmm0     # 0x5410
movsd 0x16cf(%rip), %xmm1     # 0x5418
callq 0x2300
movss 0xc(%rsp), %xmm4
movsd 0x16c4(%rip), %xmm3     # 0x5420
movss 0x169c(%rip), %xmm2     # 0x5400
movss 0x1690(%rip), %xmm1     # 0x53fc
jmp 0x3d7a
cvtss2sd %xmm0, %xmm0
divsd 0x168e(%rip), %xmm0     # 0x5408
mulsd %xmm3, %xmm0
cvttsd2si %xmm0, %eax
movw %ax, 0xc800(%r15,%r12)
incb %bpl
addq $0x200, %r12            # imm = 0x200
jne 0x3d15
incq %r14
addq $0x2, %r15
cmpq $0x100, %r14            # imm = 0x100
jne 0x3cfa
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]FlaschenTaschen-PixelPusher-bridge/bjk-pixel-pusher.cc
// Function: BJKPixelPusher::BJKPixelPusher(int, int)
BJKPixelPusher::BJKPixelPusher(int max_udp_packet_size, int brightness) {
    for (int i = 0; i < kPixelPusherCount; ++i) {
        clients_.push_back(
            new PixelPusherClient(kStripLen, kStripsPerPP,
                                  kPixelPusherHost[i], kPixelPusherPort,
                                  max_udp_packet_size, brightness));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movl %esi, %r15d
leaq 0x3f86(%rip), %rax      # 0x7d68
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rdi, 0x8(%rsp)
movq $0x0, 0x18(%rdi)
xorl %r12d, %r12d
leaq 0x16fd(%rip), %r13      # 0x5504
movl $0x48, %edi
callq 0x21d0
movq %rax, %rbx
movslq (%r12,%r13), %rcx
addq %r13, %rcx
movl %ebp, (%rsp)
movq %rax, %rdi
movl $0xf0, %esi
movl $0x8, %edx
leaq 0x179d(%rip), %r8       # 0x55cf
movl %r15d, %r9d
callq 0x386c
movq %rbx, 0x10(%rsp)
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq 0x409c
addq $0x4, %r12
cmpq $0xc, %r12
jne 0x3e07
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movl $0x48, %esi
movq %rbx, %rdi
callq 0x21e0
jmp 0x3e7a
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3e93
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
subq %rdi, %rsi
callq 0x21e0
movq %r15, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]FlaschenTaschen-PixelPusher-bridge/bjk-pixel-pusher.cc
// Function: BJKPixelPusher::SetPixel(int, int, Color const&)
void BJKPixelPusher::SetPixel(int x, int y, const Color &col) {
    if (x < 0 || x >= width() || y < 0 || y >= height()) return;

    // BJK, here you need to do the mapping. This is just roughtly from
    // what I assume things are, but I might be off.

    const int columns_per_pp = kStripsPerPP * kZigZagCount;
    const int pp_index = x / columns_per_pp;
    assert(pp_index >= 0 && pp_index < (int)clients_.size());
    x %= columns_per_pp;

    int strip = x / kZigZagCount;
    int strip_offset = x % kZigZagCount * height();
    int strip_pos = ((x + strip) % 2 == 0) ? y : height() - 1 - y; // Zigzag
    clients_[pp_index]->SetPixel(strip_offset + strip_pos, strip, col);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x4009
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movq (%rdi), %rax
callq *0x10(%rax)
testl %ebp, %ebp
js 0x4009
cmpl %r15d, %eax
jle 0x4009
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
cmpl %ebp, %eax
jle 0x4009
movq %rbx, (%rsp)
movl %r15d, %ebx
movl $0xcccccccd, %eax       # imm = 0xCCCCCCCD
imulq %rax, %rbx
shrq $0x25, %rbx
movq 0x10(%r14), %rcx
subq 0x8(%r14), %rcx
shrq $0x3, %rcx
cmpl %ecx, %ebx
jge 0x4018
leal (,%rbx,8), %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %r15d
movl %r15d, %r12d
imulq %rax, %r12
shrq $0x22, %r12
leal (%r12,%r12,4), %eax
movl %r15d, %r13d
subl %eax, %r13d
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
imull %r13d, %eax
addl %r12d, %r15d
testb $0x1, %r15b
je 0x3fdd
movl %eax, %r15d
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
notl %ebp
addl %eax, %ebp
movl %r15d, %eax
addl %eax, %ebp
movq 0x8(%r14), %rax
movl %ebx, %ecx
movq (%rax,%rcx,8), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl %ebp, %esi
movl %r12d, %edx
movq (%rsp), %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1502(%rip), %rdi      # 0x5521
leaq 0x152c(%rip), %rsi      # 0x5552
leaq 0x1539(%rip), %rcx      # 0x5566
movl $0x44, %edx
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]FlaschenTaschen-PixelPusher-bridge/bjk-pixel-pusher.cc
// Function: BJKPixelPusher::Send()
void BJKPixelPusher::Send() {
    bool need_more_packets = true;
    for (int packet = 0; need_more_packets; ++packet) {
        need_more_packets = false;
        for (size_t i = 0; i < clients_.size(); ++i) {
            need_more_packets |= clients_[i]->SendPacket(packet);
        }
        usleep(3000);  // PixelPushers need some time to digest
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movq 0x8(%rbx), %rax
cmpq %rax, 0x10(%rbx)
je 0x407b
xorl %r15d, %r15d
xorl %r14d, %r14d
movq (%rax,%r15,8), %rdi
movl %ebp, %esi
callq 0x3bf0
orb %al, %r14b
incq %r15
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jb 0x4054
jmp 0x407e
xorl %r14d, %r14d
movl $0xbb8, %edi            # imm = 0xBB8
callq 0x2280
incl %ebp
testb $0x1, %r14b
jne 0x4044
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtaudio/tests/teststops.cpp
// Function: usage()
void usage( void ) {
  // Error function in case of incorrect command-line
  // argument specifications
  std::cout << "\nuseage: teststops N fs <iDevice> <oDevice> <iChannelOffset> <oChannelOffset>\n";
  std::cout << "    where N = number of channels,\n";
  std::cout << "    fs = the sample rate,\n";
  std::cout << "    iDevice = optional input device to use (default = 0),\n";
  std::cout << "    oDevice = optional output device to use (default = 0),\n";
  std::cout << "    iChannelOffset = an optional input channel offset (default = 0),\n";
  std::cout << "    and oChannelOffset = optional output channel offset (default = 0).\n\n";
  exit( 0 );
}

// Assembly:
pushq %rbx
movq 0x8a24(%rip), %rbx      # 0xcfc8
leaq 0x4a85(%rip), %rsi      # 0x9030
movq %rbx, %rdi
callq 0x41d0
leaq 0x4ac5(%rip), %rsi      # 0x907f
movq %rbx, %rdi
callq 0x41d0
leaq 0x4ad9(%rip), %rsi      # 0x90a2
movq %rbx, %rdi
callq 0x41d0
leaq 0x4ae5(%rip), %rsi      # 0x90bd
movq %rbx, %rdi
callq 0x41d0
leaq 0x4b11(%rip), %rsi      # 0x90f8
movq %rbx, %rdi
callq 0x41d0
leaq 0x4b3e(%rip), %rsi      # 0x9134
movq %rbx, %rdi
callq 0x41d0
leaq 0x4b75(%rip), %rsi      # 0x917a
movq %rbx, %rdi
callq 0x41d0
xorl %edi, %edi
callq 0x4250
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtaudio/tests/teststops.cpp
// Function: pulse(void*, void*, unsigned int, double, unsigned int, void*)
int pulse( void *outputBuffer, void * /*inputBuffer*/, unsigned int nBufferFrames,
           double /*streamTime*/, RtAudioStreamStatus status, void *mydata )
{
  // Write out a pulse signal and ignore the input buffer.
  unsigned int i, j;
  float sample;
  float *buffer = (float *) outputBuffer;
  MyData *data = (MyData *) mydata;

  if ( status ) std::cout << "Stream over/underflow detected!" << std::endl;

  for ( i=0; i<nBufferFrames; i++ ) {
    if ( data->frameCounter % data->pulseCount == 0 ) sample = 0.9f;
    else sample = 0.0;
    for ( j=0; j<data->channels; j++ )
      *buffer++ = sample;

    data->frameCounter++;
  }

  if ( data->frameCounter >= data->nFrames )
    return data->returnValue;
  else
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %edx, %ebp
movq %rdi, %r14
testl %ecx, %ecx
je 0x4669
movq 0x899a(%rip), %r15      # 0xcfc8
leaq 0x4b8e(%rip), %rsi      # 0x91c3
movl $0x1f, %edx
movq %r15, %rdi
callq 0x4200
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x41c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4140
testl %ebp, %ebp
je 0x46b0
movl (%rbx), %esi
movl 0x4(%rbx), %edi
movl 0x8(%rbx), %ecx
xorl %r8d, %r8d
movss 0x4984(%rip), %xmm0     # 0x9004
movl %ecx, %eax
xorl %edx, %edx
divl %edi
movaps %xmm0, %xmm1
testl %edx, %edx
je 0x4690
xorps %xmm1, %xmm1
testl %esi, %esi
je 0x46a3
movl %esi, %eax
movss %xmm1, (%r14)
addq $0x4, %r14
decl %eax
jne 0x4696
incl %ecx
incl %r8d
cmpl %ebp, %r8d
jne 0x4680
movl %ecx, 0x8(%rbx)
movl 0x8(%rbx), %ecx
xorl %eax, %eax
cmpl 0xc(%rbx), %ecx
jb 0x46bd
movl 0x10(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtAudio::RtAudio(RtAudio::Api)
RtAudio :: RtAudio( RtAudio::Api api )
{
  rtapi_ = 0;

  if ( api != UNSPECIFIED ) {
    // Attempt to open the specified API.
    openRtApi( api );
    if ( rtapi_ ) return;

    // No compiled support for specified API value.  Issue a debug
    // warning and continue as if no API was specified.
    std::cerr << "\nRtAudio: no compiled support for specified API argument!\n" << std::endl;
  }

  // Iterate through the compiled APIs and return as soon as we find
  // one with at least one device or we reach the end of the list.
  std::vector< RtAudio::Api > apis;
  getCompiledApi( apis );
  for ( unsigned int i=0; i<apis.size(); i++ ) {
    openRtApi( apis[i] );
    if ( rtapi_ && rtapi_->getDeviceCount() ) break;
  }

  if ( rtapi_ ) return;

  // It should not be possible to get here because the preprocessor
  // definition __RTAUDIO_DUMMY__ is automatically defined if no
  // API-specific definitions are passed to the compiler. But just in
  // case something weird happens, we'll thow an error.
  std::string errorText = "\nRtAudio: no compiled API support found ... critical error!!\n\n";
  throw( RtAudioError( errorText, RtAudioError::UNSPECIFIED ) );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq $0x0, (%rdi)
testl %esi, %esi
je 0x5016
movq %rbx, %rdi
callq 0x4f24
cmpq $0x0, (%rbx)
jne 0x5092
movq 0x8015(%rip), %r14      # 0xcff0
leaq 0x45a8(%rip), %rsi      # 0x958a
movl $0x3a, %edx
movq %r14, %rdi
callq 0x4200
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x41c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4140
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq %r14, %rdi
callq 0x4ee0
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x5076
movl $0x1, %ebp
xorl %ecx, %ecx
movl (%rax,%rcx,4), %esi
movq %rbx, %rdi
callq 0x4f24
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x505d
movq (%rdi), %rax
callq *0x18(%rax)
testl %eax, %eax
jne 0x5076
movl %ebp, %ecx
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x5040
cmpq $0x0, (%rbx)
je 0x509b
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5092
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x41f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x451a(%rip), %rsi      # 0x95c5
leaq 0x4551(%rip), %rdx      # 0x9603
leaq 0x20(%rsp), %rdi
callq 0x8252
movl $0x30, %edi
callq 0x40d0
movq %rax, %rbx
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
movl $0x2, %edx
callq 0x8064
leaq 0x7b16(%rip), %rsi      # 0xcbf8
leaq 0x2fc1(%rip), %rdx      # 0x80aa
movq %rbx, %rdi
callq 0x43a0
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x5112
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x41f0
jmp 0x5112
jmp 0x510f
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5128
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x41f0
movq %rbx, %rdi
callq 0x43b0
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApi::RtApi()
RtApi :: RtApi()
{
  stream_.state = STREAM_CLOSED;
  stream_.mode = UNINITIALIZED;
  stream_.apiHandle = 0;
  stream_.userBuffer[0] = 0;
  stream_.userBuffer[1] = 0;
  MUTEX_INITIALIZE( &stream_.mutex );
  showWarnings_ = true;
  firstErrorOccurred_ = false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x7821(%rip), %rax      # 0xcc20
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x4270
leaq 0x190(%rbx), %rax
movq %rax, 0x180(%rbx)
xorl %eax, %eax
movq %rax, 0x188(%rbx)
movb $0x0, 0x190(%rbx)
movq %rax, 0x1b0(%rbx)
movq %rax, 0x1d0(%rbx)
movq %rax, 0x258(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x268(%rbx)
movups %xmm0, 0x278(%rbx)
movw $0x0, 0x288(%rbx)
leaq 0x2b0(%rbx), %rax
movq $-0xa0, %rcx
movups %xmm0, 0xc0(%rax,%rcx)
movups %xmm0, 0xb0(%rax,%rcx)
movups %xmm0, 0xa0(%rax,%rcx)
addq $0x50, %rcx
jne 0x5466
movabsq $0x2b6700002b67, %rax   # imm = 0x2B6700002B67
movq %rax, 0x1a8(%rbx)
movabsq $-0x310000004b, %rax    # imm = 0xFFFFFFCEFFFFFFB5
movq %rax, 0x1b8(%rbx)
movq $0x0, 0x1b0(%rbx)
leaq 0x230(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x1c0(%rbx)
xorl %esi, %esi
callq 0x42d0
movb $0x1, 0x1a0(%rbx)
movb $0x0, 0x348(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApi::error(RtAudioError::Type)
void RtApi :: error( RtAudioError::Type type )
{
  errorStream_.str(""); // clear the ostringstream

  RtAudioErrorCallback errorCallback = (RtAudioErrorCallback) stream_.callbackInfo.errorCallback;
  if ( errorCallback ) {
    // abortStream() can generate new error messages. Ignore them. Just keep original one.

    if ( firstErrorOccurred_ )
      return;

    firstErrorOccurred_ = true;
    const std::string errorMessage = errorText_;

    if ( type != RtAudioError::WARNING && stream_.state != STREAM_STOPPED) {
      stream_.callbackInfo.isRunning = false; // exit from the thread
      abortStream();
    }

    errorCallback( type, errorMessage );
    firstErrorOccurred_ = false;
    return;
  }

  if ( type == RtAudioError::WARNING && showWarnings_ == true )
    std::cerr << '\n' << errorText_ << "\n\n";
  else if ( type != RtAudioError::WARNING )
    throw( RtAudioError( errorText_, type ) );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x4060(%rip), %rdx      # 0x9603
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x8252
leaq 0x10(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x42e0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x55d5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x41f0
movq 0x278(%rbx), %r15
testq %r15, %r15
je 0x565a
cmpb $0x0, 0x348(%rbx)
jne 0x56aa
movb $0x1, 0x348(%rbx)
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
movq 0x180(%rbx), %rsi
movq 0x188(%rbx), %rdx
addq %rsi, %rdx
callq 0x81c2
testl %ebp, %ebp
je 0x5630
cmpl $0x0, 0x1bc(%rbx)
je 0x5630
movb $0x0, 0x288(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
leaq 0x8(%rsp), %rsi
movl %ebp, %edi
callq *%r15
movb $0x0, 0x348(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x56aa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x41f0
jmp 0x56aa
testl %ebp, %ebp
jne 0x56b5
cmpb $0x1, 0x1a0(%rbx)
jne 0x56aa
leaq 0x8(%rsp), %rsi
movb $0xa, (%rsi)
movq 0x797a(%rip), %rdi      # 0xcff0
movl $0x1, %edx
callq 0x4200
movq 0x180(%rbx), %rsi
movq 0x188(%rbx), %rdx
movq %rax, %rdi
callq 0x4200
leaq 0x3f64(%rip), %rsi      # 0x9601
movl $0x2, %edx
movq %rax, %rdi
callq 0x4200
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x40d0
movq %rax, %r14
addq $0x180, %rbx            # imm = 0x180
movq %rax, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x8064
leaq 0x751b(%rip), %rsi      # 0xcbf8
leaq 0x29c6(%rip), %rdx      # 0x80aa
movq %r14, %rdi
callq 0x43a0
jmp 0x56ee
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x570d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x41f0
jmp 0x570d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x43b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApi::clearStreamInfo()
void RtApi :: clearStreamInfo()
{
  stream_.mode = UNINITIALIZED;
  stream_.state = STREAM_CLOSED;
  stream_.sampleRate = 0;
  stream_.bufferSize = 0;
  stream_.nBuffers = 0;
  stream_.userFormat = 0;
  stream_.userInterleaved = true;
  stream_.streamTime = 0.0;
  stream_.apiHandle = 0;
  stream_.deviceBuffer = 0;
  stream_.callbackInfo.callback = 0;
  stream_.callbackInfo.userData = 0;
  stream_.callbackInfo.isRunning = false;
  stream_.callbackInfo.errorCallback = 0;
  for ( int i=0; i<2; i++ ) {
    stream_.device[i] = 11111;
    stream_.doConvertBuffer[i] = false;
    stream_.deviceInterleaved[i] = true;
    stream_.doByteSwap[i] = false;
    stream_.nUserChannels[i] = 0;
    stream_.nDeviceChannels[i] = 0;
    stream_.channelOffset[i] = 0;
    stream_.deviceFormat[i] = 0;
    stream_.latency[i] = 0;
    stream_.userBuffer[i] = 0;
    stream_.convertInfo[i].channels = 0;
    stream_.convertInfo[i].inJump = 0;
    stream_.convertInfo[i].outJump = 0;
    stream_.convertInfo[i].inFormat = 0;
    stream_.convertInfo[i].outFormat = 0;
    stream_.convertInfo[i].inOffset.clear();
    stream_.convertInfo[i].outOffset.clear();
  }
}

// Assembly:
movabsq $-0x310000004b, %rax    # imm = 0xFFFFFFCEFFFFFFB5
movq %rax, 0x1b8(%rdi)
xorl %eax, %eax
movq %rax, 0x1e0(%rdi)
movl $0x0, 0x1e8(%rdi)
movq %rax, 0x218(%rdi)
movb $0x1, 0x1da(%rdi)
movq %rax, 0x330(%rdi)
movq %rax, 0x1b0(%rdi)
movq %rax, 0x1d0(%rdi)
movb $0x0, 0x288(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x268(%rdi)
movq %rax, 0x278(%rdi)
movl $0x5a, %ecx
movl $0x1dd, %edx            # imm = 0x1DD
movl $0x2b67, -0x5cc(%rdi,%rdx,4) # imm = 0x2B67
movb %al, -0x5(%rdi,%rdx)
movb $0x1, -0x2(%rdi,%rdx)
movb %al, (%rdi,%rdx)
movl %eax, -0x588(%rdi,%rdx,4)
movl %eax, -0x580(%rdi,%rdx,4)
movl %eax, -0x578(%rdi,%rdx,4)
movq %rax, -0xcc8(%rdi,%rdx,8)
movq %rax, -0xce0(%rdi,%rdx,8)
movq %rax, -0xd28(%rdi,%rdx,8)
movq %rax, -0x40(%rdi,%rcx,8)
movl %eax, -0x38(%rdi,%rcx,8)
movups %xmm0, -0x30(%rdi,%rcx,8)
movq -0x20(%rdi,%rcx,8), %rsi
cmpq %rsi, -0x18(%rdi,%rcx,8)
je 0x57e2
movq %rsi, -0x18(%rdi,%rcx,8)
movq -0x8(%rdi,%rcx,8), %rsi
cmpq %rsi, (%rdi,%rcx,8)
je 0x57f1
movq %rsi, (%rdi,%rcx,8)
addq $0xa, %rcx
incq %rdx
cmpq $0x64, %rcx
je 0x577f
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApi::formatBytes(unsigned long)
unsigned int RtApi :: formatBytes( RtAudioFormat format )
{
  if ( format == RTAUDIO_SINT16 )
    return 2;
  else if ( format == RTAUDIO_SINT32 || format == RTAUDIO_FLOAT32 )
    return 4;
  else if ( format == RTAUDIO_FLOAT64 )
    return 8;
  else if ( format == RTAUDIO_SINT24 )
    return 3;
  else if ( format == RTAUDIO_SINT8 )
    return 1;

  errorText_ = "RtApi::formatBytes: undefined format.";
  error( RtAudioError::WARNING );

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x1(%rsi), %rax
cmpq $0x7, %rax
ja 0x5829
leaq 0x3b58(%rip), %rcx      # 0x9370
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, %r14d
jmp 0x5884
cmpq $0x10, %rsi
je 0x583d
cmpq $0x20, %rsi
jne 0x5845
movl $0x8, %r14d
jmp 0x5884
movl $0x4, %r14d
jmp 0x5884
leaq 0x180(%rbx), %rdi
movq 0x188(%rbx), %rdx
leaq 0x4455(%rip), %rcx      # 0x9caf
xorl %r14d, %r14d
movl $0x25, %r8d
xorl %esi, %esi
callq 0x4310
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5584
jmp 0x5884
movl $0x3, %r14d
jmp 0x5884
movl $0x2, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApi::getStreamLatency()
long RtApi :: getStreamLatency( void )
{
  verifyStream();

  long totalLatency = 0;
  if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX )
    totalLatency = stream_.latency[0];
  if ( stream_.mode == INPUT || stream_.mode == DUPLEX )
    totalLatency += stream_.latency[1];

  return totalLatency;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x590e
movl 0x1b8(%rbx), %eax
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jne 0x58f5
movq 0x208(%rbx), %rcx
jmp 0x58f7
xorl %ecx, %ecx
decl %eax
cmpl $0x2, %eax
jae 0x5907
movq 0x210(%rbx), %rax
jmp 0x5909
xorl %eax, %eax
addq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApi::getStreamTime()
double RtApi :: getStreamTime( void )
{
  verifyStream();

#if defined( HAVE_GETTIMEOFDAY )
  // Return a very accurate estimate of the stream time by
  // adding in the elapsed time since the last tick.
  struct timeval then;
  struct timeval now;

  if ( stream_.state != STREAM_RUNNING || stream_.streamTime == 0.0 )
    return stream_.streamTime;

  gettimeofday( &now, NULL );
  then = stream_.lastTickTimestamp;
  return stream_.streamTime +
    ((now.tv_sec + 0.000001 * now.tv_usec) -
     (then.tv_sec + 0.000001 * then.tv_usec));     
#else
  return stream_.streamTime;
#endif
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x590e
cmpl $0x2, 0x1bc(%rbx)
jne 0x5978
movsd 0x330(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5988
jp 0x5988
movsd 0x330(%rbx), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x4350
xorps %xmm1, %xmm1
cvtsi2sdq (%r14), %xmm1
xorps %xmm0, %xmm0
cvtsi2sdq 0x8(%r14), %xmm0
movsd 0x3b68(%rip), %xmm2     # 0x9518
mulsd %xmm2, %xmm0
cvtsi2sdq 0x338(%rbx), %xmm3
addsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sdq 0x340(%rbx), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm3, %xmm1
subsd %xmm1, %xmm0
addsd 0x330(%rbx), %xmm0
jmp 0x5980
nop
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApiPulse::getDeviceInfo(unsigned int)
RtAudio::DeviceInfo RtApiPulse::getDeviceInfo( unsigned int /*device*/ )
{
  RtAudio::DeviceInfo info;
  info.probed = true;
  info.name = "PulseAudio";
  info.outputChannels = 2;
  info.inputChannels = 2;
  info.duplexChannels = 2;
  info.isDefaultOutput = true;
  info.isDefaultInput = true;

  for ( const unsigned int *sr = SUPPORTED_SAMPLERATES; *sr; ++sr )
    info.sampleRates.push_back( *sr );

  info.preferredSampleRate = 48000;
  info.nativeFormats = RTAUDIO_SINT16 | RTAUDIO_SINT32 | RTAUDIO_FLOAT32;

  return info;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x8, %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movq %rax, 0x58(%rbx)
movq %rax, 0x28(%rbx)
movq %rax, 0x2e(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x44(%rbx)
movb $0x1, (%rbx)
leaq 0x3d4d(%rip), %rcx      # 0x980e
movl $0xa, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x4310
leaq 0x38(%rbx), %r14
movabsq $0x200000002, %rax      # imm = 0x200000002
movq %rax, 0x28(%rbx)
movl $0x2, 0x30(%rbx)
movw $0x101, 0x34(%rbx)      # imm = 0x101
leaq 0x39aa(%rip), %r15      # 0x94a0
movl $0x1f40, %eax           # imm = 0x1F40
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x5b11
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x40(%rbx)
jmp 0x5b1c
movq %r14, %rdi
movq %r15, %rdx
callq 0x846c
movl 0x4(%r15), %eax
addq $0x4, %r15
testl %eax, %eax
jne 0x5afb
movl $0xbb80, 0x50(%rbx)     # imm = 0xBB80
movq $0x1a, 0x58(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x5b42
movq %rax, %r14
movq %rbx, %rdi
callq 0x810a
movq %r14, %rdi
callq 0x43b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApiPulse::closeStream()
void RtApiPulse::closeStream( void )
{
  PulseAudioHandle *pah = static_cast<PulseAudioHandle *>( stream_.apiHandle );

  stream_.callbackInfo.isRunning = false;
  if ( pah ) {
    MUTEX_LOCK( &stream_.mutex );
    if ( stream_.state == STREAM_STOPPED ) {
      pah->runnable = true;
      pthread_cond_signal( &pah->runnable_cv );
    }
    MUTEX_UNLOCK( &stream_.mutex );

    pthread_join( pah->thread, 0 );
    if ( pah->s_play ) {
      pa_simple_flush( pah->s_play, NULL );
      pa_simple_free( pah->s_play );
    }
    if ( pah->s_rec )
      pa_simple_free( pah->s_rec );

    pthread_cond_destroy( &pah->runnable_cv );
    delete pah;
    stream_.apiHandle = 0;
  }

  if ( stream_.userBuffer[0] ) {
    free( stream_.userBuffer[0] );
    stream_.userBuffer[0] = 0;
  }
  if ( stream_.userBuffer[1] ) {
    free( stream_.userBuffer[1] );
    stream_.userBuffer[1] = 0;
  }

  stream_.state = STREAM_CLOSED;
  stream_.mode = UNINITIALIZED;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x1b0(%rdi), %r14
movb $0x0, 0x288(%rdi)
testq %r14, %r14
je 0x5bf0
leaq 0x230(%rbx), %r15
movq %r15, %rdi
callq 0x42b0
cmpl $0x0, 0x1bc(%rbx)
jne 0x5b97
movb $0x1, 0x48(%r14)
leaq 0x18(%r14), %rdi
callq 0x4030
movq %r15, %rdi
callq 0x4160
movq 0x10(%r14), %rdi
xorl %esi, %esi
callq 0x41a0
movq (%r14), %rdi
testq %rdi, %rdi
je 0x5bc1
xorl %esi, %esi
callq 0x4080
movq (%r14), %rdi
callq 0x4370
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x5bcf
callq 0x4370
leaq 0x18(%r14), %rdi
callq 0x4400
movl $0x50, %esi
movq %r14, %rdi
callq 0x41f0
movq $0x0, 0x1b0(%rbx)
movq 0x1c0(%rbx), %rdi
testq %rdi, %rdi
je 0x5c0c
callq 0x4230
movq $0x0, 0x1c0(%rbx)
movq 0x1c8(%rbx), %rdi
testq %rdi, %rdi
je 0x5c28
callq 0x4230
movq $0x0, 0x1c8(%rbx)
movabsq $-0x310000004b, %rax    # imm = 0xFFFFFFCEFFFFFFB5
movq %rax, 0x1b8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApiPulse::startStream()
void RtApiPulse::startStream( void )
{
  PulseAudioHandle *pah = static_cast<PulseAudioHandle *>( stream_.apiHandle );

  if ( stream_.state == STREAM_CLOSED ) {
    errorText_ = "RtApiPulse::startStream(): the stream is not open!";
    error( RtAudioError::INVALID_USE );
    return;
  }
  if ( stream_.state == STREAM_RUNNING ) {
    errorText_ = "RtApiPulse::startStream(): the stream is already running!";
    error( RtAudioError::WARNING );
    return;
  }

  MUTEX_LOCK( &stream_.mutex );

  stream_.state = STREAM_RUNNING;

  pah->runnable = true;
  pthread_cond_signal( &pah->runnable_cv );
  MUTEX_UNLOCK( &stream_.mutex );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x1bc(%rdi), %eax
cmpl $0x2, %eax
je 0x7258
cmpl $-0x32, %eax
jne 0x7289
leaq 0x180(%rbx), %rdi
movq 0x188(%rbx), %rdx
leaq 0x2682(%rip), %rcx      # 0x98c3
movl $0x32, %r8d
xorl %esi, %esi
callq 0x4310
movq %rbx, %rdi
movl $0x7, %esi
jmp 0x727f
leaq 0x180(%rbx), %rdi
movq 0x188(%rbx), %rdx
leaq 0x2689(%rip), %rcx      # 0x98f6
movl $0x39, %r8d
xorl %esi, %esi
callq 0x4310
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x5584
movq 0x1b0(%rbx), %r14
leaq 0x230(%rbx), %r15
movq %r15, %rdi
callq 0x42b0
movl $0x2, 0x1bc(%rbx)
movb $0x1, 0x48(%r14)
addq $0x18, %r14
movq %r14, %rdi
callq 0x4030
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4160
nop
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApiPulse::stopStream()
void RtApiPulse::stopStream( void )
{
  PulseAudioHandle *pah = static_cast<PulseAudioHandle *>( stream_.apiHandle );

  if ( stream_.state == STREAM_CLOSED ) {
    errorText_ = "RtApiPulse::stopStream(): the stream is not open!";
    error( RtAudioError::INVALID_USE );
    return;
  }
  if ( stream_.state == STREAM_STOPPED ) {
    errorText_ = "RtApiPulse::stopStream(): the stream is already stopped!";
    error( RtAudioError::WARNING );
    return;
  }

  stream_.state = STREAM_STOPPED;
  MUTEX_LOCK( &stream_.mutex );

  if ( pah && pah->s_play ) {
    int pa_error;
    if ( pa_simple_drain( pah->s_play, &pa_error ) < 0 ) {
      errorStream_ << "RtApiPulse::stopStream: error draining output device, " <<
        pa_strerror( pa_error ) << ".";
      errorText_ = errorStream_.str();
      MUTEX_UNLOCK( &stream_.mutex );
      error( RtAudioError::SYSTEM_ERROR );
      return;
    }
  }

  stream_.state = STREAM_STOPPED;
  MUTEX_UNLOCK( &stream_.mutex );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x1bc(%rdi), %eax
testl %eax, %eax
je 0x7311
cmpl $-0x32, %eax
jne 0x7348
leaq 0x180(%rbx), %rdi
movq 0x188(%rbx), %rdx
leaq 0x2636(%rip), %rcx      # 0x9930
movl $0x31, %r8d
xorl %esi, %esi
callq 0x4310
movq %rbx, %rdi
movl $0x7, %esi
jmp 0x7338
leaq 0x180(%rbx), %rdi
movq 0x188(%rbx), %rdx
leaq 0x263c(%rip), %rcx      # 0x9962
movl $0x38, %r8d
xorl %esi, %esi
callq 0x4310
movq %rbx, %rdi
xorl %esi, %esi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5584
movq 0x1b0(%rbx), %r15
movl $0x0, 0x1bc(%rbx)
leaq 0x230(%rbx), %r14
movq %r14, %rdi
callq 0x42b0
testq %r15, %r15
je 0x7383
movq (%r15), %rdi
testq %rdi, %rdi
je 0x7383
leaq 0x4(%rsp), %rsi
callq 0x40b0
testl %eax, %eax
js 0x73a1
movl $0x0, 0x1bc(%rbx)
movq %r14, %rdi
callq 0x4160
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x8(%rbx), %r15
leaq 0x25ef(%rip), %rsi      # 0x999b
movl $0x36, %edx
movq %r15, %rdi
callq 0x4200
movl 0x4(%rsp), %edi
callq 0x4050
testq %rax, %rax
je 0x73e2
movq %rax, %r12
movq %rax, %rdi
callq 0x40c0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x4200
jmp 0x73fa
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x4390
leaq 0x288e(%rip), %rsi      # 0x9c8f
movl $0x1, %edx
movq %r15, %rdi
callq 0x4200
leaq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x4340
leaq 0x180(%rbx), %rdi
movq %r15, %rsi
callq 0x4260
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x7448
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x41f0
movq %r14, %rdi
callq 0x4160
movq %rbx, %rdi
movl $0x9, %esi
callq 0x5584
jmp 0x7395