LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/vividvilla[P]hackerrank/src/median.cpp
// Function: main
int main() {
    int n;
    long long x;
    char o;
    cin >> n;

    vector<char> ops;
    vector<long long> ints;
    for (int i = 0; i < n; i++) {
        cin >> o >> x;
        ops.push_back(o);
        ints.push_back(x);
    }

    outputMedians(ops, ints);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq 0x2a41(%rip), %rbx      # 0x3fe0
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x10d0
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x10(%rsp), %r15
andq $0x0, 0x10(%r15)
movaps %xmm0, (%r15)
xorl %ebp, %ebp
leaq 0xb(%rsp), %r12
leaq 0x80(%rsp), %r13
cmpl 0xc(%rsp), %ebp
jge 0x1610
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1140
movq %rax, %rdi
movq %r13, %rsi
callq 0x1150
movq %r14, %rdi
movq %r12, %rsi
callq 0x16b8
movq %r15, %rdi
movq %r13, %rsi
callq 0x16d2
incl %ebp
jmp 0x15da
leaq 0x68(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x16f2
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x173c
leaq 0x68(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x12bc
leaq 0x50(%rsp), %rdi
callq 0x19d6
leaq 0x68(%rsp), %rdi
callq 0x19aa
leaq 0x10(%rsp), %rdi
callq 0x19d6
leaq 0x30(%rsp), %rdi
callq 0x19aa
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x19d6
jmp 0x168b
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x19aa
jmp 0x169c
jmp 0x1699
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x19d6
leaq 0x30(%rsp), %rdi
callq 0x19aa
movq %rbx, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O2/vividvilla[P]hackerrank/src/insertionsort2.cpp
// Function: outputSteps(std::vector<int, std::allocator<int>>)
void outputSteps(vector<int> ar) {
    int M = ar.size();

    for (int N = 2; N <= M; N++) {
        int el = ar[N - 1];
        for (int i = N - 1; i >= 0; i--) {
            if (i > 0 && ar[i - 1] > el)
                ar[i] = ar[i - 1];
            else
                ar[i] = el;

            if (ar[i] <= el)
                break;
        }

        for (int j = 0; j < M; j++) {
            cout << ar[j];
            if (j + 1 < M)
                cout << " ";
            else
                cout << endl;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r12
subq (%rdi), %r12
shrq $0x2, %r12
xorl %r13d, %r13d
testl %r12d, %r12d
cmovgl %r12d, %r13d
movslq %r12d, %rax
movq %rax, 0x8(%rsp)
pushq $0x2
popq %r8
movq 0x2d4b(%rip), %r14      # 0x3fd0
leaq 0xd78(%rip), %r15       # 0x2004
cmpq 0x8(%rsp), %r8
jg 0x1303
leaq -0x1(%r8), %rdx
movq (%rbx), %rax
movl -0x4(%rax,%r8,4), %ecx
testl %edx, %edx
js 0x12c0
movl %edx, %esi
subl $0x1, %esi
jb 0x12bb
movl %edx, %edx
movl -0x4(%rax,%rdx,4), %edi
cmpl %ecx, %edi
jle 0x12bd
movl %edi, (%rax,%rdx,4)
movl %esi, %edx
jmp 0x129f
xorl %edx, %edx
movl %ecx, (%rax,%rdx,4)
movq %r8, 0x10(%rsp)
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x12f9
movq (%rbx), %rax
movl (%rax,%rbp,4), %esi
movq %r14, %rdi
callq 0x1100
leal 0x1(%rbp), %eax
movq %r14, %rdi
cmpl %r12d, %eax
jge 0x12ef
movq %r15, %rsi
callq 0x10b0
jmp 0x12f4
callq 0x1060
incq %rbp
jmp 0x12c7
movq 0x10(%rsp), %r8
incq %r8
jmp 0x128c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vividvilla[P]hackerrank/src/insertionsort2.cpp
// Function: main
int main() {
    int s, x;
    cin >> s;

    vector<int> ar;
    for (int i = 0; i < s; i++) {
        cin >> x;
        ar.push_back(x);
    }

    outputSteps(ar);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x2cbd(%rip), %rbx      # 0x3fe0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1080
leaq 0x10(%rsp), %r14
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
xorl %ebp, %ebp
leaq 0xc(%rsp), %r15
cmpl 0x8(%rsp), %ebp
jge 0x1368
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1080
movq %r14, %rdi
movq %r15, %rsi
callq 0x13c8
incl %ebp
jmp 0x1348
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x13e6
leaq 0x30(%rsp), %rdi
callq 0x124c
leaq 0x30(%rsp), %rdi
callq 0x143e
leaq 0x10(%rsp), %rdi
callq 0x143e
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x143e
jmp 0x13b6
jmp 0x13b3
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x143e
movq %rbx, %rdi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O2/jmbjorndalen[P]Malbolge-gen/mbolge-gen.cpp
// Function: MBSearch::storeMem(unsigned short, unsigned short)
unsigned short MBSearch::storeMem(unsigned short addr, unsigned short val)
{
    // NB: writes to an addr always occurs after a read to the same addr, so we never have to consider path branching 
    // or any other recording here. 
    if (addr >= MAX_TRIT)
    { 
	std::cerr << "MBSearch::storeMem called with addr " << addr << " with is outside legal bounds\n";
	throw ILLEGAL_ADDR_EXCEPTION; // program made an illegal reference, which will not fare well with the original interpreter, so abort this branch
    }
    if (addr >= maxAllowedProgLen) 
	throw MAX_APLEN_EXCEPTION;

    mem[addr] = val;
    return 0; 
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
cmpw $0xe6a9, %bx            # imm = 0xE6A9
jae 0x4048ba
cmpl %ebx, 0x1ed896(%rip)    # 0x5f2130
jle 0x4048f7
movzwl %dx, %ebp
addq $0x18, %rdi
leaq 0x4(%rsp), %rsi
movl %ebx, (%rsi)
callq 0x405340
movl %ebp, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq $0x5f5420, %rdi         # imm = 0x5F5420
leaq 0x17e816(%rip), %rsi    # 0x5830de
callq 0x470290
movzwl %bx, %esi
movq %rax, %rdi
callq 0x4708b0
leaq 0x17e824(%rip), %rsi    # 0x583103
movq %rax, %rdi
callq 0x470290
pushq $0x4
popq %rdi
callq 0x4061c0
movl $0x2b, (%rax)
jmp 0x404905
pushq $0x4
popq %rdi
callq 0x4061c0
movl $0x2c, (%rax)
leaq 0x1e60a4(%rip), %rsi    # 0x5ea9b0
movq %rax, %rdi
xorl %edx, %edx
callq 0x407210
// File: /workspace/github_cpp_makefile_star2_O2/jmbjorndalen[P]Malbolge-gen/mbolge-gen.cpp
// Function: MBSearch::initExec()
void MBSearch::initExec()
{
    Ra = 0;
    Rc = 0; 
    Rd = 0; 
    output = ""; 
    odepth = 0; 
    iStage = STAGE_IFETCH; 
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
andl $0x0, (%rdi)
andw $0x0, 0x4(%rdi)
addq $0x88, %rdi
leaq 0x19c8d8(%rip), %rsi    # 0x5a1512
callq 0x481140
andl $0x0, 0x14(%rbx)
andl $0x0, 0x7c(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jmbjorndalen[P]Malbolge-gen/mbolge-gen.cpp
// Function: MBSearch::dumpProgram(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void MBSearch::dumpProgram(std::string fname)
{
    std::ofstream f(fname.c_str(), std::ios::trunc); 

    for (int i = 0; i <= highestAddrRead; i++) 
    {
	MBMemory::iterator pos = mem.find(i); 
	if (pos == mem.end())
	    f << (char) (encode_op(OP_NOP, i));   // Since these aren't fetched, I could dump anything here
	else
	    f << (char) orig[i]; 
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x8(%rsp), %rdi
pushq $0x20
popq %rdx
callq 0x44cc90
leaq 0x18(%rbx), %r15
leaq 0x20(%rbx), %rbp
leaq 0x48(%rbx), %r12
xorl %r14d, %r14d
leaq 0x4(%rsp), %r13
cmpl 0x78(%rbx), %r14d
jg 0x404cea
movl %r14d, 0x4(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x4059c2
cmpq %rbp, %rax
je 0x404cbc
movl %r14d, 0x4(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x405340
movsbl (%rax), %esi
leaq 0x8(%rsp), %rdi
callq 0x4701c0
jmp 0x404ce5
movzwl %r14w, %ecx
pushq $0x23
popq %rax
subl %ecx, %eax
cltd
pushq $0x5e
popq %rcx
idivl %ecx
leal 0x5e(%rdx), %eax
testl %edx, %edx
movzbl %al, %eax
cmovnsl %edx, %eax
addb $0x21, %al
movsbl %al, %esi
leaq 0x8(%rsp), %rdi
callq 0x4701c0
incl %r14d
jmp 0x404c82
leaq 0x8(%rsp), %rdi
callq 0x44d340
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x404d0a
jmp 0x404d0a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x44d340
movq %rbx, %rdi
callq 0x4b1a40
// File: /workspace/github_cpp_makefile_star2_O2/jmbjorndalen[P]Malbolge-gen/mbolge-gen.cpp
// Function: printCurOutput(MBSearch*, int)
void printCurOutput(MBSearch *cur, int newline = true)
{
    std::cout << "\r   output from program '" << cur->output << "' "
	      << "maxMemLoc " << cur->maxMemLoc() 
	      << " nFetches " << cur->nFetches << "                     "; 
    if (newline)
	std::cout << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq $0x5f5540, %rdi         # imm = 0x5F5540
leaq 0x17e41f(%rip), %rsi    # 0x583155
callq 0x470290
leaq 0x88(%r14), %rsi
movq %rax, %rdi
callq 0x482bc0
leaq 0x17e41e(%rip), %rsi    # 0x58316f
movq %rax, %rdi
callq 0x470290
leaq 0x17e412(%rip), %rsi    # 0x583172
movq %rax, %rdi
callq 0x470290
movl 0x78(%r14), %esi
movq %rax, %rdi
callq 0x470630
leaq 0x17e402(%rip), %rsi    # 0x58317d
movq %rax, %rdi
callq 0x470290
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x470630
leaq 0x17e3f2(%rip), %rsi    # 0x583188
movq %rax, %rdi
callq 0x470290
testl %ebx, %ebx
je 0x404db5
movq $0x5f5540, %rdi         # imm = 0x5F5540
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x46fb70
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/hzeller[P]FlaschenTaschen-PixelPusher-bridge/ft-thread.cc
// Function: ft::Thread::WaitStopped()
void Thread::WaitStopped() {
    if (!started_) return;
    int result = pthread_join(thread_, NULL);
    if (result != 0) {
        fprintf(stderr, "err code: %d %s\n", result, strerror(result));
    }
    started_ = false;
}

// Assembly:
cmpb $0x1, 0x8(%rdi)
jne 0x2746
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
xorl %esi, %esi
callq 0x21b0
testl %eax, %eax
jne 0x2747
movb $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movl %eax, %ebp
movq 0x5888(%rip), %rax      # 0x7fd8
movq (%rax), %r14
movl %ebp, %edi
callq 0x20a0
leaq 0x2a41(%rip), %rsi      # 0x51a2
movq %r14, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2290
jmp 0x273e
// File: /workspace/github_cpp_makefile_star2_O2/hzeller[P]FlaschenTaschen-PixelPusher-bridge/ft-thread.cc
// Function: ft::Thread::Start(int, unsigned int)
void Thread::Start(int priority, uint32_t affinity_mask) {
    assert(!started_);  // Did you call WaitStopped() ?
    pthread_create(&thread_, NULL, &PthreadCallRun, this);

    if (priority > 0) {
        struct sched_param p;
        p.sched_priority = priority;
        pthread_setschedparam(thread_, SCHED_FIFO, &p);
    }

#ifndef __APPLE__
    if (affinity_mask != 0) {
        cpu_set_t cpu_mask;
        CPU_ZERO(&cpu_mask);
        for (int i = 0; i < 32; ++i) {
            if ((affinity_mask & (1<<i)) != 0) {
                CPU_SET(i, &cpu_mask);
            }
        }
        pthread_setaffinity_np(thread_, sizeof(cpu_mask), &cpu_mask);
    }
#endif

    started_ = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
cmpb $0x1, 0x8(%rdi)
je 0x2844
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
leaq -0xb2(%rip), %rdx       # 0x26ec
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x2350
testl %r15d, %r15d
jle 0x27c3
leaq 0x8(%rsp), %rdx
movl %r15d, (%rdx)
movq (%r14), %rdi
pushq $0x1
popq %rsi
callq 0x2150
testl %ebp, %ebp
je 0x2832
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rsp)
movups %xmm0, 0x60(%rsp)
movups %xmm0, 0x50(%rsp)
movups %xmm0, 0x40(%rsp)
movups %xmm0, 0x30(%rsp)
movups %xmm0, 0x20(%rsp)
andq $0x0, 0x80(%rsp)
movups %xmm0, 0x10(%rsp)
xorl %ecx, %ecx
pushq $0x1
popq %rdx
xorl %eax, %eax
cmpq $0x20, %rcx
je 0x281d
movq %rdx, %rsi
shlq %cl, %rsi
btl %ecx, %ebp
movl $0x0, %edi
cmovbq %rsi, %rdi
orq %rdi, %rax
incq %rcx
jmp 0x27fd
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq (%r14), %rdi
movl $0x80, %esi
callq 0x2310
movb $0x1, 0x8(%rbx)
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2968(%rip), %rdi      # 0x51b3
leaq 0x296b(%rip), %rsi      # 0x51bd
leaq 0x2971(%rip), %rcx      # 0x51ca
pushq $0x31
popq %rdx
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O2/hzeller[P]FlaschenTaschen-PixelPusher-bridge/ft-thread.cc
// Function: ft::Mutex::WaitOnWithTimeout(pthread_cond_t*, int)
bool Mutex::WaitOnWithTimeout(pthread_cond_t *cond, int wait_ms) {
    if (wait_ms <= 0) return 1;  // already expired.
    struct timespec abs_time;
#ifndef __APPLE__
    clock_gettime(CLOCK_REALTIME, &abs_time);
#else
    struct timeval apple_time;
    gettimeofday(&apple_time, NULL);
    abs_time.tv_sec = apple_time.tv_sec;
    abs_time.tv_nsec = apple_time.tv_usec * 1000;
#endif
    abs_time.tv_sec += wait_ms / 1000;
    abs_time.tv_nsec += 1000000 * (wait_ms % 1000);
    if (abs_time.tv_nsec > 1000000000) {
        abs_time.tv_sec += 1;
        abs_time.tv_nsec -= 1000000000;
    }
    return pthread_cond_timedwait(cond, &mutex_, &abs_time) == 0;
}

// Assembly:
testl %edx, %edx
jle 0x28e3
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
xorl %edi, %edi
movq %r15, %rsi
callq 0x21c0
movl $0x3e8, %ecx            # imm = 0x3E8
movl %ebp, %eax
xorl %edx, %edx
divl %ecx
addq (%r15), %rax
movq %rax, (%r15)
imull $0xf4240, %edx, %ecx    # imm = 0xF4240
addq 0x8(%r15), %rcx
movq %rcx, 0x8(%r15)
cmpq $0x3b9aca01, %rcx       # imm = 0x3B9ACA01
jl 0x28c3
incq %rax
movq %rax, 0x8(%rsp)
addq $-0x3b9aca00, %rcx      # imm = 0xC4653600
movq %rcx, 0x10(%rsp)
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22c0
testl %eax, %eax
sete %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/hzeller[P]FlaschenTaschen-PixelPusher-bridge/ft-server.cc
// Function: udp_server_init(int)
bool udp_server_init(int port) {
    if ((server_socket = socket(PF_INET6, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
        perror("IPv6 enabled ? While reating listen socket");
        return false;
    }
    int opt = 0;   // Unset IPv6-only, in case it is set. Best effort.
    setsockopt(server_socket, IPPROTO_IPV6, IPV6_V6ONLY, &opt, sizeof(opt));

    struct sockaddr_in6 addr = {0};
    addr.sin6_family = AF_INET6;
    addr.sin6_addr = in6addr_any;
    addr.sin6_port = htons(port);
    if (bind(server_socket, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
        perror("bind");
        return false;
    }

    fprintf(stderr, "FlaschenTaschen server: ready to listen on %d\n", port);
    return true;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
pushq $0xa
popq %rdi
pushq $0x2
popq %rsi
pushq $0x11
popq %rdx
callq 0x2080
movl %eax, 0x5928(%rip)      # 0x8238
testl %eax, %eax
jns 0x2927
leaq 0x2905(%rip), %rdi      # 0x5220
callq 0x21a0
xorl %ebp, %ebp
jmp 0x29ac
leaq 0x8(%rsp), %rcx
andl $0x0, (%rcx)
pushq $0x29
popq %rsi
pushq $0x1a
popq %rdx
pushq $0x4
popq %r8
movl %eax, %edi
callq 0x2330
xorps %xmm0, %xmm0
leaq 0xc(%rsp), %rsi
movups %xmm0, 0x4(%rsi)
andq $0x0, 0x14(%rsi)
movw $0xa, (%rsi)
movq 0x5683(%rip), %rax      # 0x7fe0
movups (%rax), %xmm0
movups %xmm0, 0x8(%rsi)
movl %ebx, %eax
rolw $0x8, %ax
movw %ax, 0x2(%rsi)
movl 0x58c4(%rip), %edi      # 0x8238
pushq $0x1c
popq %rdx
callq 0x2070
testl %eax, %eax
setns %bpl
js 0x29a0
movq 0x564d(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
leaq 0x28bb(%rip), %rsi      # 0x5250
movl %ebx, %edx
xorl %eax, %eax
callq 0x2290
jmp 0x29ac
leaq 0x28a4(%rip), %rdi      # 0x524b
callq 0x21a0
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::CompositeFlaschenTaschen(FlaschenTaschen*, int)
CompositeFlaschenTaschen::CompositeFlaschenTaschen(FlaschenTaschen *delegatee,
                                                   int layers)
    : delegatee_(delegatee),
      width_(delegatee->width()), height_(delegatee->height()),
      current_layer_(0), any_visible_pixel_drawn_(false),
      z_buffer_(new ZBuffer(width_, height_)),
      garbage_collect_(NULL) {
    assert(layers < 32);  // otherwise could getting slow.
    for (int i = 0; i < layers; ++i) {
        screens_.push_back(new ScreenBuffer(delegatee->width(),
                                            delegatee->height()));
        last_layer_update_time_.push_back(INT_MAX);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x50df(%rip), %rax      # 0x7c60
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
movl %eax, 0x10(%r14)
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movl %eax, %r12d
movl %eax, 0x14(%r14)
andl $0x0, 0x18(%r14)
movb $0x0, 0x1c(%r14)
leaq 0x28(%r14), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
andq $0x0, 0x38(%r14)
pushq $0x10
popq %rdi
callq 0x21d0
movq %rax, %r13
movl 0x10(%r14), %esi
movq %rax, %rdi
movl %r12d, %edx
callq 0x305a
movq %r13, 0x40(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
cmpl $0x1f, %ebp
jg 0x2c67
movl %ebp, %eax
addq $0x48, %r14
xorl %ebp, %ebp
testl %eax, %eax
cmovgl %eax, %ebp
subl $0x1, %ebp
jb 0x2c58
pushq $0x10
popq %rdi
callq 0x21d0
movq %rax, %r12
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movl %eax, %r13d
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq %r12, %rdi
movl %r13d, %esi
movl %eax, %edx
callq 0x309a
movq %r12, 0x10(%rsp)
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
callq 0x3274
movl $0x7fffffff, 0xc(%rsp)  # imm = 0x7FFFFFFF
movq %r14, %rdi
leaq 0xc(%rsp), %rsi
callq 0x33f0
jmp 0x2bfd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2624(%rip), %rdi      # 0x5292
leaq 0x2629(%rip), %rsi      # 0x529e
leaq 0x2640(%rip), %rcx      # 0x52bc
pushq $0x65
popq %rdx
callq 0x2140
movq %rax, %r15
pushq $0x10
popq %rsi
movq %r13, %rdi
callq 0x21e0
jmp 0x2cb6
movq %rax, %r15
jmp 0x2cb6
jmp 0x2c9b
movq %rax, %r15
jmp 0x2cae
movq %rax, %r15
pushq $0x10
popq %rsi
movq %r12, %rdi
callq 0x21e0
movq %r14, %rdi
callq 0x3240
movq %rbx, %rdi
callq 0x320c
movq %r15, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::~CompositeFlaschenTaschen()
CompositeFlaschenTaschen::~CompositeFlaschenTaschen() {
    if (garbage_collect_) {
        garbage_collect_->TriggerExit();
        garbage_collect_->WaitStopped();
    }
    for (size_t i = 0; i < screens_.size(); ++i) delete screens_[i];
    delete z_buffer_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x4f87(%rip), %rax      # 0x7c60
movq %rax, (%rdi)
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0x2cf3
callq 0x30da
movq 0x60(%rbx), %rdi
callq 0x2722
leaq 0x28(%rbx), %r14
xorl %r13d, %r13d
pushq $0x10
popq %r15
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jae 0x2d3a
movq (%rax,%r13,8), %r12
testq %r12, %r12
je 0x2d2a
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x2d2a
callq 0x2240
movq %r12, %rdi
movq %r15, %rsi
callq 0x21e0
incq %r13
jmp 0x2cfe
movq 0x40(%rbx), %r15
testq %r15, %r15
je 0x2d51
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x2d51
callq 0x2240
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x21e0
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x3240
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x320c
movq %rax, %rdi
callq 0x28e6
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movslq %ecx, %rax
movq 0x28(%rdi), %rcx
movq (%rcx,%rax,8), %rcx
movq 0x8(%rcx), %rdx
movl (%rcx), %ecx
imull %ebp, %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 %ebp, %ecx
addl %r14d, %ecx
movslq %ecx, %rcx
cmpl %eax, (%rdx,%rcx,4)
jg 0x2ebc
movq %r8, %r12
movq %rdi, %r15
movb $0x1, 0x1c(%rdi)
movq %r8, %rdi
callq 0x310c
testb %al, %al
je 0x2e67
movl %ebx, %r12d
movl %ebx, %r13d
sarl $0x1f, %r13d
andl %ebx, %r13d
incl %ebx
testl %r12d, %r12d
jle 0x2e78
movq 0x28(%r15), %rax
movq (%rax,%r12,8), %rax
movl (%rax), %ecx
imull %ebp, %ecx
addl %r14d, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rdi
addq 0x8(%rax), %rdi
callq 0x310c
decq %r12
decl %ebx
testb %al, %al
jne 0x2e37
jmp 0x2e7b
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movl %r14d, %esi
movl %ebp, %edx
movq %r12, %rcx
jmp 0x2ea5
movl %r13d, %ebx
movslq %ebx, %rax
movq 0x8(%r15), %rdi
movq 0x28(%r15), %rcx
movq (%rcx,%rax,8), %rax
movl (%rax), %ecx
imull %ebp, %ecx
addl %r14d, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
addq 0x8(%rax), %rcx
movq (%rdi), %rax
movl %r14d, %esi
movl %ebp, %edx
callq *0x20(%rax)
movq 0x40(%r15), %rax
imull (%rax), %ebp
movq 0x8(%rax), %rax
addl %r14d, %ebp
movslq %ebp, %rcx
movl %ebx, (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2ee0
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x0, 0x1c(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2f66
movq %rsi, %r15
testq %rsi, %rsi
je 0x2f85
movl %edx, %ebp
movq %rdi, %rbx
pushq $0x68
popq %rdi
callq 0x21d0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x311e
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 0x239a(%rip), %rdi      # 0x5307
leaq 0x232a(%rip), %rsi      # 0x529e
leaq 0x23a5(%rip), %rcx      # 0x5320
movl $0x9e, %edx
callq 0x2140
leaq 0x23e1(%rip), %rdi      # 0x536d
leaq 0x230b(%rip), %rsi      # 0x529e
leaq 0x2386(%rip), %rcx      # 0x5320
movl $0x9f, %edx
callq 0x2140
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %r14, %rdi
callq 0x21e0
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::ClearLayersOlderThan(int)
void CompositeFlaschenTaschen::ClearLayersOlderThan(Ticks cutoff_time) {
    const Color black(0, 0, 0);
    bool any_change = false;
    // Only cleaning layers above zero (= background)
    for (size_t layer = 1; layer < last_layer_update_time_.size(); ++layer) {
        if (last_layer_update_time_[layer] > cutoff_time)
            continue;
        // Not very efficient, but good for now:
        for (int x = 0; x < width_; ++x) {
            for (int y = 0; y < height_; ++y) {
                SetPixelAtLayer(x, y, layer, black);
            }
        }
        last_layer_update_time_[layer] = INT_MAX;
        any_change = true;
    }
    if (any_change) Send();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x5(%rsp), %r14
andw $0x0, (%r14)
movb $0x0, 0x2(%r14)
movq 0x48(%rdi), %rax
pushq $0x1
popq %r15
xorl %ecx, %ecx
movq 0x50(%rbx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rdx, %r15
jae 0x303c
cmpl %ebp, (%rax,%r15,4)
jg 0x3037
xorl %r12d, %r12d
cmpl 0x10(%rbx), %r12d
jge 0x3029
xorl %r13d, %r13d
cmpl 0x14(%rbx), %r13d
jge 0x3024
movq %rbx, %rdi
movl %r12d, %esi
movl %r13d, %edx
movl %r15d, %ecx
movq %r14, %r8
callq 0x2db6
incl %r13d
jmp 0x3005
incl %r12d
jmp 0x2ffc
movq 0x48(%rbx), %rax
movl $0x7fffffff, (%rax,%r15,4) # imm = 0x7FFFFFFF
movb $0x1, %cl
incq %r15
jmp 0x2fe3
testb $0x1, %cl
je 0x304a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
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 0x2862
cmpb $0x0, 0x60(%rbx)
je 0x31eb
movq 0x18(%rbx), %rdi
movl 0x64(%rbx), %esi
subl 0x28(%rbx), %esi
callq 0x2fba
movq 0x18(%rbx), %rax
movl 0x64(%rbx), %ecx
movl %ecx, 0x20(%rax)
incl %ecx
movl %ecx, 0x64(%rbx)
movq %r15, %rdi
callq 0x2160
jmp 0x31a0
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2160
movq %rax, %rbx
movq %r15, %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x365c
cmpb $0x36, 0x1(%rbx)
jne 0x365c
movq %rdx, %r14
movq %rsi, %r15
movsbl 0x2(%rbx), %ebp
movl %ebp, %edi
callq 0x2060
cmpl $0x23, %ebp
je 0x35aa
testl %eax, %eax
je 0x365c
leaq 0x2(%rbx), %rax
addq %rbx, %r15
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x366e
cmpq $0x0, (%r12)
je 0x365c
movl %eax, %ebp
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x366e
cmpq $0x0, (%r13)
je 0x365c
movl %eax, %r12d
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x366e
movq (%r13), %r13
testq %r13, %r13
je 0x365c
movl %eax, 0xc(%rsp)
movsbl (%r13), %edi
callq 0x2060
testl %eax, %eax
je 0x365c
incq %r13
movl %ebp, %eax
imull %r12d, %eax
leal (%rax,%rax,2), %eax
movslq %eax, %rdi
movq %r15, %rax
subq %r13, %rax
cmpq %rdi, %rax
jb 0x365c
jbe 0x364a
addq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3758
movl %ebp, (%r14)
movl %r12d, 0x4(%r14)
movl 0xc(%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_O2/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
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movq (%rdi), %r12
leaq 0x1d64(%rip), %r13      # 0x53f5
pushq $0x4
popq %rbp
cmpq %r15, %r12
jae 0x3709
movq %r12, %rbx
movb (%r12), %r12b
movsbl %r12b, %edi
callq 0x2060
testl %eax, %eax
je 0x36b5
incq %rbx
movq %rbx, %r12
jmp 0x3694
cmpb $0x23, %r12b
jne 0x3716
xorl %eax, %eax
leaq (%rbx,%rax), %r12
cmpq %r15, %r12
jae 0x36d2
cmpb $0xa, (%r12)
je 0x36d2
incq %rax
jmp 0x36bd
testq %r14, %r14
sete %cl
cmpq $0x4, %rax
setl %al
orb %cl, %al
jne 0x3694
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x20d0
testl %eax, %eax
jne 0x3694
addq $0x4, %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3758
jmp 0x3694
movq 0x8(%rsp), %rax
andq $0x0, (%rax)
xorl %eax, %eax
jmp 0x3749
leaq 0x10(%rsp), %r14
andq $0x0, (%r14)
pushq $0xa
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2270
movq (%r14), %rcx
xorl %edx, %edx
cmpq %rbx, %rcx
movl $0x0, %esi
cmovneq %rcx, %rsi
cmovel %edx, %eax
movq 0x8(%rsp), %rcx
movq %rsi, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x366e
movl %eax, 0xc(%rbx)
cmpq $0x0, (%r15)
je 0x37af
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x366e
movl %eax, 0x10(%rbx)
cmpq $0x0, (%r15)
je 0x37af
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x366e
movl %eax, 0x14(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x38, %rsp
testl %esi, %esi
js 0x3ac7
movl %edx, %r14d
testl %edx, %edx
js 0x3ac7
movl %esi, %ebp
movq %rdi, %rbx
cmpl %esi, 0x8(%rdi)
jle 0x3ac7
cmpl %r14d, 0xc(%rbx)
jle 0x3ac7
movq %rcx, %r15
movl %r14d, %r13d
imulq 0x18(%rbx), %r13
movq 0x38(%rbx), %r8
movzbl 0x28(%rbx), %r12d
movb 0x4805(%rip), %al       # 0x8250
testb %al, %al
je 0x3ad6
shll $0x9, %r12d
addq 0x47ea(%rip), %r12      # 0x8248
movzbl (%r15), %eax
movb -0x200(%r12,%rax,2), %cl
movzbl 0x1(%r15), %eax
movb -0x200(%r12,%rax,2), %sil
movzbl 0x2(%r15), %eax
movb -0x200(%r12,%rax,2), %dil
movl %r14d, %eax
cltd
idivl 0x20(%rbx)
leaq (%r8,%r13), %r9
incq %r9
movl %ebp, %edx
leaq (%rdx,%rdx,2), %r10
leaq (%r9,%r10), %rdx
movb $0x1, %r8b
cmpb %cl, (%r9,%r10)
jne 0x3ab3
cmpb %sil, 0x1(%rdx)
jne 0x3ab3
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 $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4773(%rip), %rdi      # 0x8250
movq %r8, 0x18(%rsp)
callq 0x2340
movq 0x18(%rsp), %r8
testl %eax, %eax
je 0x3a53
movq %r13, 0x28(%rsp)
movl $0xc800, %edi           # imm = 0xC800
callq 0x2040
movq %rax, 0x10(%rsp)
movq $0x0, (%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x100, (%rsp)          # imm = 0x100
je 0x3bdc
movzbl (%rsp), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, 0xc(%rsp)
movq $-0xc800, %rdx          # imm = 0xFFFF3800
movb $0x1, %r13b
testq %rdx, %rdx
je 0x3bcd
movsbl %r13b, %eax
cvtsi2ss %eax, %xmm0
mulss 0xc(%rsp), %xmm0
divss 0x189d(%rip), %xmm0     # 0x53fc
movss 0x1899(%rip), %xmm1     # 0x5400
ucomiss %xmm0, %xmm1
jae 0x3b99
addss 0x1890(%rip), %xmm0     # 0x5404
cvtss2sd %xmm0, %xmm0
divsd 0x1890(%rip), %xmm0     # 0x5410
movsd 0x1890(%rip), %xmm1     # 0x5418
movq %rdx, 0x30(%rsp)
callq 0x2300
movq 0x30(%rsp), %rdx
jmp 0x3ba5
cvtss2sd %xmm0, %xmm0
divsd 0x1863(%rip), %xmm0     # 0x5408
mulsd 0x1873(%rip), %xmm0     # 0x5420
cvttsd2si %xmm0, %eax
movq 0x20(%rsp), %rcx
movw %ax, 0xc800(%rcx,%rdx)
addq $0x200, %rdx            # imm = 0x200
incb %r13b
jmp 0x3b40
incq (%rsp)
addq $0x2, 0x20(%rsp)
jmp 0x3b1a
movq 0x10(%rsp), %rax
movq %rax, 0x4660(%rip)      # 0x8248
leaq 0x4661(%rip), %rdi      # 0x8250
callq 0x2130
movq 0x18(%rsp), %r8
movq 0x28(%rsp), %r13
jmp 0x3a53
movq %rax, %rbx
leaq 0x4643(%rip), %rdi      # 0x8250
callq 0x2120
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3ca3
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 0x3ca3
movq 0x30(%r14), %rsi
cmpb $0x1, (%rsi,%rdx)
jne 0x3c92
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)
pushq $0x2
popq %rdx
callq 0x20f0
incl 0x40(%r14)
incl %ebx
movslq %ebx, %rax
imulq %rax, %r15
cmpq %r12, %r15
setb %al
jmp 0x3ca5
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14d
leaq 0x406e(%rip), %rax      # 0x7d68
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
andq $0x0, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %r13d, %r13d
leaq 0x17ed(%rip), %r15      # 0x5504
cmpq $0xc, %r13
je 0x3d65
pushq $0x48
popq %rdi
callq 0x21d0
movq %rax, %r12
movslq (%r13,%r15), %rcx
addq %r15, %rcx
movl %ebp, (%rsp)
movq %rax, %rdi
movl $0xf0, %esi
pushq $0x8
popq %rdx
leaq 0x188a(%rip), %r8       # 0x55cf
movl %r14d, %r9d
callq 0x37bc
movq %r12, 0x10(%rsp)
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
callq 0x3f96
addq $0x4, %r13
jmp 0x3d17
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
pushq $0x48
popq %rsi
movq %r12, %rdi
callq 0x21e0
jmp 0x3d87
movq %rax, %r14
movq %rbx, %rdi
callq 0x3f62
movq %r14, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
testl %esi, %esi
js 0x3ed9
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movq (%rdi), %rax
callq *0x10(%rax)
testl %ebp, %ebp
js 0x3ed9
cmpl %r15d, %eax
jle 0x3ed9
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
cmpl %ebp, %eax
jle 0x3ed9
movq %rbx, 0x10(%rsp)
pushq $0x28
popq %rcx
movl %r15d, %eax
xorl %edx, %edx
divl %ecx
movq 0x10(%r14), %rcx
subq 0x8(%r14), %rcx
shrq $0x3, %rcx
movl %eax, 0xc(%rsp)
cmpl %ecx, %eax
jge 0x3ee8
movl %edx, %r13d
movzbl %r13b, %eax
movb $0x5, %cl
divb %cl
movzbl %ah, %ecx
movl %ecx, %r12d
movzbl %al, %ebx
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movl %eax, %r15d
imull %r12d, %r15d
addl %ebx, %r13d
testb $0x1, %r13b
je 0x3eaa
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
notl %ebp
addl %eax, %ebp
movq 0x10(%rsp), %rcx
addl %r15d, %ebp
movl 0xc(%rsp), %eax
movq 0x8(%r14), %rdx
movq (%rdx,%rax,8), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl %ebp, %esi
movl %ebx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1632(%rip), %rdi      # 0x5521
leaq 0x165c(%rip), %rsi      # 0x5552
leaq 0x1669(%rip), %rcx      # 0x5566
pushq $0x44
popq %rdx
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movb $0x1, %r14b
testb $0x1, %r14b
je 0x3f56
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jae 0x3f48
movq (%rax,%r15,8), %rdi
movl %ebp, %esi
callq 0x3c1a
orb %al, %r14b
incq %r15
jmp 0x3f21
movl $0xbb8, %edi            # imm = 0xBB8
callq 0x2280
incl %ebp
jmp 0x3f15
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8a74(%rip), %rbx      # 0xcfc8
leaq 0x4ad5(%rip), %rsi      # 0x9030
movq %rbx, %rdi
callq 0x41c0
leaq 0x4b15(%rip), %rsi      # 0x907f
movq %rbx, %rdi
callq 0x41c0
leaq 0x4b29(%rip), %rsi      # 0x90a2
movq %rbx, %rdi
callq 0x41c0
leaq 0x4b35(%rip), %rsi      # 0x90bd
movq %rbx, %rdi
callq 0x41c0
leaq 0x4b61(%rip), %rsi      # 0x90f8
movq %rbx, %rdi
callq 0x41c0
leaq 0x4b8e(%rip), %rsi      # 0x9134
movq %rbx, %rdi
callq 0x41c0
leaq 0x4bc5(%rip), %rsi      # 0x917a
movq %rbx, %rdi
callq 0x41c0
xorl %edi, %edi
callq 0x4240
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %r8, %rbx
movl %edx, %ebp
movq %rdi, %r14
testl %ecx, %ecx
je 0x45ef
movq 0x89ed(%rip), %rdi      # 0xcfc8
leaq 0x4be1(%rip), %rsi      # 0x91c3
callq 0x41c0
movq %rax, %rdi
callq 0x40d0
movl 0x8(%rbx), %ecx
xorl %esi, %esi
movss 0x4a08(%rip), %xmm0     # 0x9004
cmpl %ebp, %esi
je 0x462c
movl %ecx, %eax
xorl %edx, %edx
divl 0x4(%rbx)
movaps %xmm0, %xmm1
testl %edx, %edx
je 0x4611
xorps %xmm1, %xmm1
movl (%rbx), %eax
subl $0x1, %eax
jb 0x4623
movss %xmm1, (%r14)
addq $0x4, %r14
jmp 0x4613
incl %ecx
movl %ecx, 0x8(%rbx)
incl %esi
jmp 0x45fc
xorl %eax, %eax
cmpl 0xc(%rbx), %ecx
jb 0x4636
movl 0x10(%rbx), %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
andq $0x0, (%rdi)
testl %esi, %esi
je 0x4ee1
movq %rbx, %rdi
callq 0x4e42
cmpq $0x0, (%rbx)
jne 0x4f45
movq 0x8123(%rip), %rdi      # 0xcff0
leaq 0x46b6(%rip), %rsi      # 0x958a
callq 0x41c0
movq %rax, %rdi
callq 0x40d0
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x4e1a
xorl %r14d, %r14d
movl %r14d, %r14d
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r14, %rcx
jbe 0x4f35
movl (%rax,%r14,4), %esi
movq %rbx, %rdi
callq 0x4e42
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4f30
movq (%rdi), %rax
callq *0x18(%rax)
testl %eax, %eax
jne 0x4f35
incl %r14d
jmp 0x4ef9
cmpq $0x0, (%rbx)
je 0x4f4d
leaq 0x10(%rsp), %rdi
callq 0x7cd8
addq $0x48, %rsp
popq %rbx
popq %r14
retq
leaq 0x4671(%rip), %rsi      # 0x95c5
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x77ae
pushq $0x30
popq %rdi
callq 0x40e0
movq %rax, %rbx
leaq 0x28(%rsp), %rsi
pushq $0x2
popq %rdx
movq %rax, %rdi
callq 0x7812
leaq 0x7c7b(%rip), %rsi      # 0xcc00
leaq 0x28b6(%rip), %rdx      # 0x7842
movq %rbx, %rdi
callq 0x4380
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x40c0
jmp 0x4fa8
jmp 0x4fa5
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7cd8
movq %rbx, %rdi
callq 0x4390