LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/miklhh[P]tetris/src/game.cpp
// Function: game_draw_field()
void game_draw_field()
{
    extern SDL_Renderer* renderer;
    extern int block_width;
    extern int block_height;
    for (int y = 0; y < GRID_HEIGHT; y++)
    {
        for (int x = 0; x < GRID_WIDTH; x++)
        {
            draw_box(
                x * block_width, y * block_height,  // Position.
                block_width, block_height,          // Size.
                field[y][x].color_f,                // Foreground color.
                field[y][x].color_b,                // Background color.
                renderer,                           // Renderer to draw to.
                GLOBAL_MARGIN                       // Margin level (px).
            );
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x3361(%rip), %rbp      # 0x6154
xorl %r14d, %r14d
leaq 0x3d63(%rip), %r15      # 0x6b60
leaq 0x3d60(%rip), %r12      # 0x6b64
leaq 0x3d45(%rip), %r13      # 0x6b50
cmpq $0x14, %r14
je 0x2e5a
movq %rbp, (%rsp)
xorl %ebx, %ebx
cmpq $0xa, %rbx
je 0x2e4d
movl (%r15), %edx
movl %ebx, %edi
imull %edx, %edi
movl (%r12), %ecx
movl %ecx, %esi
imull %r14d, %esi
movl -0x4(%rbp), %r8d
movl (%rbp), %r9d
pushq $0x1
pushq (%r13)
callq 0x23cc
popq %rax
popq %rcx
incq %rbx
addq $0xc, %rbp
jmp 0x2e17
incq %r14
movq (%rsp), %rbp
addq $0x78, %rbp
jmp 0x2e0b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/miklhh[P]tetris/src/game.cpp
// Function: iteration_timer()
bool iteration_timer()
{
    using namespace std::chrono;
    static time_point<high_resolution_clock>  last_timestamp;
    time_point<high_resolution_clock>         current_timestamp         = high_resolution_clock::now();
    milliseconds                              time_since_last_call      = duration_cast<milliseconds>(current_timestamp - last_timestamp);

    if (current_iteration_wait_time_ms < time_since_last_call.count())
    {
        last_timestamp = current_timestamp;
        return true;
    }
    else return false;

}

// Assembly:
pushq %rax
callq 0x2060
movq %rax, %rcx
subq 0x3ada(%rip), %rax      # 0x6ac0
movl $0xf4240, %esi          # imm = 0xF4240
cqto
idivq %rsi
movslq 0x3ad1(%rip), %rdx      # 0x6ac8
cmpq %rdx, %rax
jle 0x3003
movq %rcx, 0x3abd(%rip)      # 0x6ac0
cmpq %rdx, %rax
setg %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/miklhh[P]tetris/src/input.cpp
// Function: handle_keyboard_input(unsigned char const*)
void handle_keyboard_input(keyboard_state_t* keyboard_state)
{
    if (keyboard_key_timer(SDL_SCANCODE_LEFT, keyboard_state))
        current_block_move(DIRECTION_LEFT);

    if (keyboard_key_timer(SDL_SCANCODE_RIGHT, keyboard_state))
        current_block_move(DIRECTION_RIGHT);

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x50
popq %rdi
movq %rbx, %rsi
callq 0x320e
testb %al, %al
je 0x31f4
xorl %edi, %edi
callq 0x3012
pushq $0x4f
popq %rdi
movq %rbx, %rsi
callq 0x320e
testb %al, %al
je 0x320c
pushq $0x1
popq %rdi
popq %rbx
jmp 0x3012
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]optimal-seed-solver/hobbesSolver.cc
// Function: HobbesSolver::~HobbesSolver()
HobbesSolver::~HobbesSolver() {
	if  (invertedList != NULL) {
		delete [] invertedList;
		invertedList = NULL;
	}
	if  (defaultInvertedList != NULL) {
		delete [] defaultInvertedList;
		defaultInvertedList = NULL;
	}
		if  (dynamicMatrix != NULL) {
		delete [] dynamicMatrix;
		dynamicMatrix = NULL;
	}
	if  (defaultDynamicMatrix != NULL) {
		delete [] defaultDynamicMatrix;
		defaultDynamicMatrix = NULL;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x358(%rdi), %rdi
testq %rdi, %rdi
je 0x411b
callq 0x32e0
andq $0x0, 0x358(%rbx)
movq 0x378(%rbx), %rdi
testq %rdi, %rdi
je 0x4134
callq 0x32e0
andq $0x0, 0x378(%rbx)
movq 0x360(%rbx), %rdi
testq %rdi, %rdi
je 0x414d
callq 0x32e0
andq $0x0, 0x360(%rbx)
movq 0x380(%rbx), %rdi
testq %rdi, %rdi
je 0x4166
callq 0x32e0
andq $0x0, 0x380(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x4ac8
nop
// File: /workspace/github_cpp_makefile_star2_O2/c2-d2[P]disty/src/main.cpp
// Function: void compute_pileup<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
void compute_pileup(const T &seqs, U &pileup) {
    assert(seqs[0].size()==pileup.size());
    assert(pileup[0].size()==128);
    auto len=seqs[0].size();
    for(int i=0; i<static_cast<int>(len); i++){
        for(int c=0; c<128; c++){
            pileup[i][c]=0;
        }
    }

    for (const auto &seq: seqs){
        for(int i=0; i<static_cast<int>(len); i++){
            unsigned char c=seq[i];
            ++pileup[i][c];
        }
    }
}

// Assembly:
pushq %rax
movq (%rdi), %rcx
movq 0x8(%rcx), %r8
movq (%rsi), %r9
movq 0x8(%rsi), %rax
subq %r9, %rax
pushq $0x18
popq %rsi
cqto
idivq %rsi
cmpq %rax, %r8
jne 0x3561
movq 0x8(%r9), %rax
subq (%r9), %rax
cmpq $0x200, %rax            # imm = 0x200
jne 0x3580
xorl %eax, %eax
testl %r8d, %r8d
cmovlel %eax, %r8d
cmpq %r8, %rax
je 0x352f
imulq $0x18, %rax, %rdx
movq (%r9,%rdx), %rdx
xorl %esi, %esi
cmpq $0x80, %rsi
je 0x352a
andl $0x0, (%rdx,%rsi,4)
incq %rsi
jmp 0x3518
incq %rax
jmp 0x3509
movq 0x8(%rdi), %rax
cmpq %rax, %rcx
je 0x355f
movq %r9, %rdx
xorl %esi, %esi
cmpq %rsi, %r8
je 0x3559
movq (%rcx), %rdi
movzbl (%rdi,%rsi), %edi
movq (%rdx), %r10
incl (%r10,%rdi,4)
incq %rsi
addq $0x18, %rdx
jmp 0x353d
addq $0x20, %rcx
jmp 0x3533
popq %rax
retq
leaq 0x2008(%rip), %rdi      # 0x5570
leaq 0x1d77(%rip), %rsi      # 0x52e6
leaq 0x2018(%rip), %rcx      # 0x558e
movl $0x11b, %edx            # imm = 0x11B
callq 0x20c0
leaq 0x2079(%rip), %rdi      # 0x5600
leaq 0x1d58(%rip), %rsi      # 0x52e6
leaq 0x1ff9(%rip), %rcx      # 0x558e
movl $0x11c, %edx            # imm = 0x11C
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/c2-d2[P]disty/src/main.cpp
// Function: void compute_mask<std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&, int)
void compute_mask(string &mask, const T &pileup, int n_thres) {
    assert(pileup.size()==mask.size());
    assert(pileup[0].size()==128);

    int column_sum=accumulate(pileup[0].begin(), pileup[0].end(), 0);

    int masked_columns=0;

    for(int i=0; i<static_cast<int>(pileup.size()); i++){
        int ns=pileup[i]['n']+pileup[i]['N'];
        if (ns >= n_thres){
            mask[i]='0';
            masked_columns++;
        }
        else{
            if(ns>0)
            {
                mask[i]='N';
            }
            else{
                mask[i]='1';
            }
        }
    }

    cerr << "Number of masked columns: " << masked_columns << " (out of " << pileup.size() << " positions, threshold: " << n_thres << " Ns, number of samples: " << column_sum << ")" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq (%rsi), %rsi
movq 0x8(%r14), %rcx
movq %rcx, %rax
subq %rsi, %rax
pushq $0x18
popq %r12
cqto
idivq %r12
cmpq 0x8(%rdi), %rax
jne 0x37b8
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rdx, %r8
subq %rax, %r8
cmpq $0x200, %r8             # imm = 0x200
jne 0x37d7
xorl %ebp, %ebp
cmpq %rdx, %rax
je 0x36c4
addl (%rax), %ebp
addq $0x4, %rax
jmp 0x36b7
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %r15d, %r15d
subq %rsi, %rcx
movq %rcx, %rax
cqto
idivq %r12
cltq
cmpq %rax, %r9
jge 0x3723
movq (%rsi,%r8), %rcx
movl 0x138(%rcx), %eax
addl 0x1b8(%rcx), %eax
cmpl %ebx, %eax
jge 0x3701
movq (%rdi), %rcx
testl %eax, %eax
jle 0x370e
movb $0x4e, (%rcx,%r9)
jmp 0x3713
movq (%rdi), %rax
movb $0x30, (%rax,%r9)
incl %r15d
jmp 0x3713
movb $0x31, (%rcx,%r9)
incq %r9
movq (%r14), %rsi
movq 0x8(%r14), %rcx
addq $0x18, %r8
jmp 0x36cd
movq 0x48c6(%rip), %rdi      # 0x7ff0
leaq 0x1fc0(%rip), %rsi      # 0x56f1
callq 0x2140
movq %rax, %rdi
movl %r15d, %esi
callq 0x2280
leaq 0x1fc4(%rip), %rsi      # 0x570c
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
movq 0x8(%r14), %rax
subq (%r14), %rax
cqto
idivq %r12
movq %rax, %rsi
callq 0x20e0
leaq 0x1fa8(%rip), %rsi      # 0x5716
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
movl %ebx, %esi
callq 0x2280
leaq 0x1fa7(%rip), %rsi      # 0x572e
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
movl %ebp, %esi
callq 0x2280
leaq 0x1b86(%rip), %rsi      # 0x5326
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2090
leaq 0x1ec7(%rip), %rdi      # 0x5686
leaq 0x1b20(%rip), %rsi      # 0x52e6
leaq 0x1ed4(%rip), %rcx      # 0x56a1
movl $0x163, %edx            # imm = 0x163
callq 0x20c0
leaq 0x1e22(%rip), %rdi      # 0x5600
leaq 0x1b01(%rip), %rsi      # 0x52e6
leaq 0x1eb5(%rip), %rcx      # 0x56a1
movl $0x164, %edx            # imm = 0x164
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/c2-d2[P]disty/src/main.cpp
// Function: void compute_pair_matrix<std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
void compute_pair_matrix(const string &seq1, const string &seq2, const string &mask, T &pair_matrix){
    assert(seq1.size()==seq2.size());
    assert(seq1.size()==mask.size());
    assert(pair_matrix.size()==128);
    assert(pair_matrix[0].size()==128);

    for(int i=0; i<128; i++){
        for(int j=0; j<128; j++){
            pair_matrix[i][j]=0;
        }
    }
    int len=(int)seq1.size();
    for (int i=0;i<len;i++){
        if(mask[i]!='0'){
            ++pair_matrix[seq1[i]][seq2[i]];
        }
    }
}

// Assembly:
pushq %rax
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0x38f6
cmpq 0x8(%rdx), %rax
jne 0x3915
movq (%rcx), %r8
movq 0x8(%rcx), %rcx
subq %r8, %rcx
cmpq $0xc00, %rcx            # imm = 0xC00
jne 0x3934
movq 0x8(%r8), %rcx
subq (%r8), %rcx
cmpq $0x200, %rcx            # imm = 0x200
jne 0x3953
xorl %ecx, %ecx
cmpq $0x80, %rcx
je 0x38be
imulq $0x18, %rcx, %r9
movq (%r8,%r9), %r9
xorl %r10d, %r10d
cmpq $0x80, %r10
je 0x38b9
andl $0x0, (%r9,%r10,4)
incq %r10
jmp 0x38a6
incq %rcx
jmp 0x3892
movq (%rdx), %rcx
movq (%rdi), %rdx
movq (%rsi), %rsi
xorl %edi, %edi
testl %eax, %eax
cmovlel %edi, %eax
cmpq %rdi, %rax
je 0x38f4
cmpb $0x30, (%rcx,%rdi)
je 0x38ef
movsbq (%rdx,%rdi), %r9
imulq $0x18, %r9, %r9
movsbq (%rsi,%rdi), %r10
movq (%r8,%r9), %r9
incl (%r9,%r10,4)
incq %rdi
jmp 0x38ce
popq %rax
retq
leaq 0x1e4a(%rip), %rdi      # 0x5747
leaq 0x19e2(%rip), %rsi      # 0x52e6
leaq 0x1e55(%rip), %rcx      # 0x5760
movl $0x188, %edx            # imm = 0x188
callq 0x20c0
leaq 0x1eb6(%rip), %rdi      # 0x57d2
leaq 0x19c3(%rip), %rsi      # 0x52e6
leaq 0x1e36(%rip), %rcx      # 0x5760
movl $0x189, %edx            # imm = 0x189
callq 0x20c0
leaq 0x1eb0(%rip), %rdi      # 0x57eb
leaq 0x19a4(%rip), %rsi      # 0x52e6
leaq 0x1e17(%rip), %rcx      # 0x5760
movl $0x18a, %edx            # imm = 0x18A
callq 0x20c0
leaq 0x1ea9(%rip), %rdi      # 0x5803
leaq 0x1985(%rip), %rsi      # 0x52e6
leaq 0x1df8(%rip), %rcx      # 0x5760
movl $0x18b, %edx            # imm = 0x18B
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/c2-d2[P]disty/src/main.cpp
// Function: void print_distance_matrix<std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void print_distance_matrix(const T &distance_matrix, const U &names){
    assert(distance_matrix.size() == distance_matrix[0].size());
    assert(distance_matrix.size() == names.size());
    int count=static_cast<int>(distance_matrix.size());

    //cout << "";
    for (const string& name : names){
        cout << "\t" << name;
    }
    cout << endl;

    for (int i=0;i<count;i++){
        cout << names[i];
        for (int j=0;j<count;j++){
            cout << "\t" << distance_matrix[i][j];
        }
        cout << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
pushq $0x18
popq %rdi
cqto
idivq %rdi
movq %rax, %r12
movq 0x8(%rcx), %rax
subq (%rcx), %rax
sarq $0x2, %rax
cmpq %rax, %r12
jne 0x3c85
movq (%rsi), %r15
movq %rsi, (%rsp)
movq 0x8(%rsi), %r14
movq %r14, %rax
subq %r15, %rax
sarq $0x5, %rax
cmpq %rax, %r12
jne 0x3ca4
movq 0x4407(%rip), %r13      # 0x7fc8
leaq 0x17c3(%rip), %rbp      # 0x538b
cmpq %r14, %r15
je 0x3be9
movq %r13, %rdi
movq %rbp, %rsi
callq 0x2140
movq %rax, %rdi
movq %r15, %rsi
callq 0x2130
addq $0x20, %r15
jmp 0x3bc8
movq 0x43d8(%rip), %r15      # 0x7fc8
movq %r15, %rdi
callq 0x2090
xorl %r13d, %r13d
testl %r12d, %r12d
movl $0x0, %eax
cmovgl %r12d, %eax
movq %rax, 0x8(%rsp)
movl %r12d, %r14d
leaq 0x1775(%rip), %r12      # 0x538b
cmpq 0x8(%rsp), %r13
je 0x3c76
movq %r13, %rsi
shlq $0x5, %rsi
movq (%rsp), %rax
addq (%rax), %rsi
movq %r15, %rdi
callq 0x2130
movq %r13, 0x10(%rsp)
imulq $0x18, %r13, %rbp
xorl %r13d, %r13d
movq %r15, %rdi
cmpq %r13, %r14
je 0x3c67
movq %r12, %rsi
callq 0x2140
movq (%rbx), %rcx
movq (%rcx,%rbp), %rcx
movl (%rcx,%r13,4), %esi
movq %rax, %rdi
callq 0x2280
incq %r13
jmp 0x3c3f
callq 0x2090
movq 0x10(%rsp), %r13
incq %r13
jmp 0x3c16
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c3a(%rip), %rdi      # 0x58c6
leaq 0x1653(%rip), %rsi      # 0x52e6
leaq 0x1c60(%rip), %rcx      # 0x58fa
movl $0x1f1, %edx            # imm = 0x1F1
callq 0x20c0
leaq 0x1cce(%rip), %rdi      # 0x5979
leaq 0x1634(%rip), %rsi      # 0x52e6
leaq 0x1c41(%rip), %rcx      # 0x58fa
movl $0x1f2, %edx            # imm = 0x1F2
callq 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/p-ranav[P]video_device_discovery/src/main.cpp
// Function: main
int main() {
  for (auto& vd: find_video_devices()) {
    std::cout << vd.file.string() << "\n";
    std::cout << " Driver: " << vd.driver << "\n";
    std::cout << " Card: " << vd.card << "\n";
    std::cout << " Bus info: " << vd.bus_info << "\n";

    std::cout << " Pixel Format:\n";
    for (auto& fmt: vd.pixel_formats) {
      std::cout << " - " << fmt << "\n";
    }
    std::cout << " Resolutions:\n";
    for (auto& r: vd.resolutions) {
      std::cout << " - " << r.first << "x" << r.second << "\n";
    }
    std::cout << "\n\n";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq -0x50(%rbp), %rdi
callq 0x6a90
leaq -0x70(%rbp), %rdi
callq 0x6748
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq 0x1fa57(%rip), %r14     # 0x25fb8
leaq 0x16ade(%rip), %r15     # 0x1d046
leaq 0x16ac3(%rip), %r12     # 0x1d032
cmpq -0x38(%rbp), %rax
je 0x66f7
movq %rax, -0x30(%rbp)
leaq 0x8(%rax), %rsi
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x6774
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4350
movq %rax, %rdi
movq %r15, %rsi
callq 0x4370
leaq -0x70(%rbp), %rdi
callq 0x4170
movq %r14, %rdi
leaq 0x16a4e(%rip), %rsi     # 0x1d004
callq 0x4370
movq -0x30(%rbp), %rcx
leaq 0x78(%rcx), %rsi
movq %rax, %rdi
callq 0x4350
movq %rax, %rdi
movq %r15, %rsi
callq 0x4370
movq %r14, %rdi
leaq 0x16a2e(%rip), %rsi     # 0x1d00e
callq 0x4370
movq -0x30(%rbp), %rcx
leaq 0x98(%rcx), %rsi
movq %rax, %rdi
callq 0x4350
movq %rax, %rdi
movq %r15, %rsi
callq 0x4370
movq %r14, %rdi
leaq 0x16a09(%rip), %rsi     # 0x1d016
callq 0x4370
movq -0x30(%rbp), %rcx
leaq 0xb8(%rcx), %rsi
movq %rax, %rdi
callq 0x4350
movq %rax, %rdi
movq %r15, %rsi
callq 0x4370
movq %r14, %rdi
leaq 0x169e8(%rip), %rsi     # 0x1d022
callq 0x4370
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rbx
movq 0x50(%rax), %r13
cmpq %r13, %rbx
je 0x6677
movq %r14, %rdi
movq %r12, %rsi
callq 0x4370
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4350
movq %rax, %rdi
movq %r15, %rsi
callq 0x4370
addq $0x20, %rbx
jmp 0x664b
movq %r14, %rdi
leaq 0x169b5(%rip), %rsi     # 0x1d036
callq 0x4370
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rbx
movq 0x68(%rax), %r13
cmpq %r13, %rbx
je 0x66d9
movq %r14, %rdi
movq %r12, %rsi
callq 0x4370
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x4260
movq %rax, %rdi
leaq 0x1769e(%rip), %rsi     # 0x1dd55
callq 0x4370
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x4260
movq %rax, %rdi
movq %r15, %rsi
callq 0x4370
addq $0x10, %rbx
jmp 0x6692
movq %r14, %rdi
leaq 0x16962(%rip), %rsi     # 0x1d045
callq 0x4370
movq -0x30(%rbp), %rax
addq $0xd8, %rax
jmp 0x656f
leaq -0x50(%rbp), %rdi
callq 0x6790
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x6748
jmp 0x673f
jmp 0x6733
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x4170
jmp 0x6736
jmp 0x6733
jmp 0x6733
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x6790
movq %rbx, %rdi
callq 0x45e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/p-ranav[P]video_device_discovery/src/helpers.cpp
// Function: xioctl(int, int, void*)
int xioctl(int fd, int request, void *arg) {
  int r;
  do {
    r = ioctl (fd, request, arg);
  } while (-1 == r && EINTR == errno);
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %edi, %r14d
movslq %esi, %r15
movl %r14d, %edi
movq %r15, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x4490
movl %eax, %r12d
cmpl $-0x1, %eax
jne 0x8a12
callq 0x4030
cmpl $0x4, (%rax)
je 0x89f0
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/test.c
// Function: test_int
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0, size = 0;
	stb_idict *h;
	h = stb_idict_create();
	for (i = 0, x = x0; i < n; ++i) {
		uint32_t key, val = 1;
		x = hash32(x);
		key = get_key(n, x);
		if (stb_idict_get_flag(h, key, &val)) {
			stb_idict_set(h, key, val + 1);
		} else {
			stb_idict_set(h, key, 1);
			++size;
		}
		z += val;
	}
	fprintf(stderr, "# unique keys: %d; checksum: %u\n", size, z);
	stb_idict_destroy(h);
	return size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r12d
movl %edi, %r15d
xorl %ebp, %ebp
callq 0x658c
movq %rax, %rbx
movl %r15d, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
subl $0x1, %r15d
jb 0x2802
movl $0x1, 0xc(%rsp)
movl %r12d, %edi
callq 0x24fc
movl %eax, %r12d
movl 0x14(%rsp), %edi
movl %eax, %esi
callq 0x2527
movl %eax, %r13d
movq %rbx, %rdi
movl %eax, %esi
leaq 0xc(%rsp), %rdx
callq 0x65df
testl %eax, %eax
je 0x27e6
movl 0xc(%rsp), %r14d
leal 0x1(%r14), %edx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x66f4
jmp 0x27fd
movq %rbx, %rdi
movl %r13d, %esi
pushq $0x1
popq %rdx
callq 0x66f4
incl 0x10(%rsp)
movl 0xc(%rsp), %r14d
addl %r14d, %ebp
jmp 0x2796
movq 0x157ef(%rip), %rax     # 0x17ff8
movq (%rax), %rdi
leaq 0xe67e(%rip), %rsi      # 0x10e91
movl 0x10(%rsp), %r14d
movl %r14d, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x21f0
movq %rbx, %rdi
callq 0x65c1
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_to_utf8
char * stb_to_utf8(char *buffer, stb__wchar *str, int n)
{
   int i=0;
   --n;
   while (*str) {
      if (*str < 0x80) {
         if (i+1 > n) return NULL;
         buffer[i++] = (char) *str++;
      } else if (*str < 0x800) {
         if (i+2 > n) return NULL;
         buffer[i++] = 0xc0 + (*str >> 6);
         buffer[i++] = 0x80 + (*str & 0x3f);
         str += 1;
      } else if (*str >= 0xd800 && *str < 0xdc00) {
         stb_uint32 c;
         if (i+4 > n) return NULL;
         c = ((str[0] - 0xd800) << 10) + ((str[1]) - 0xdc00) + 0x10000;
         buffer[i++] = 0xf0 + (c >> 18);
         buffer[i++] = 0x80 + ((c >> 12) & 0x3f);
         buffer[i++] = 0x80 + ((c >>  6) & 0x3f);
         buffer[i++] = 0x80 + ((c      ) & 0x3f);
         str += 2;
      } else if (*str >= 0xdc00 && *str < 0xe000) {
         return NULL;
      } else {
         if (i+3 > n) return NULL;
         buffer[i++] = 0xe0 + (*str >> 12);
         buffer[i++] = 0x80 + ((*str >> 6) & 0x3f);
         buffer[i++] = 0x80 + ((*str     ) & 0x3f);
         str += 1;
      }
   }
   buffer[i] = 0;
   return buffer;
}

// Assembly:
pushq %rbx
leal -0x1(%rdx), %ecx
xorl %eax, %eax
xorl %r8d, %r8d
movzwl (%rsi), %r10d
movslq %r8d, %r9
testl %r10d, %r10d
je 0x2e2a
cmpw $0x7f, %r10w
ja 0x2d31
cmpl %ecx, %r8d
jge 0x2e32
incl %r8d
addq $0x2, %rsi
movb %r10b, (%rdi,%r9)
jmp 0x2d04
cmpw $0x7ff, %r10w           # imm = 0x7FF
ja 0x2d68
addl $0x2, %r8d
cmpl %edx, %r8d
jge 0x2e32
shrl $0x6, %r10d
orb $-0x40, %r10b
movb %r10b, (%rdi,%r9)
movb (%rsi), %r10b
andb $0x3f, %r10b
orb $-0x80, %r10b
movb %r10b, 0x1(%rdi,%r9)
addq $0x2, %rsi
jmp 0x2d04
movl %r10d, %r11d
andl $0xfc00, %r11d          # imm = 0xFC00
cmpw $0xd800, %r11w          # imm = 0xD800
jne 0x2ddf
addl $0x4, %r8d
cmpl %edx, %r8d
jge 0x2e32
shll $0xa, %r10d
movzwl 0x2(%rsi), %r11d
addl %r11d, %r10d
addl $0xfca02400, %r10d      # imm = 0xFCA02400
movl %r10d, %ebx
shrl $0x12, %ebx
addb $-0x10, %bl
movb %bl, (%rdi,%r9)
movl %r10d, %ebx
shrl $0xc, %ebx
andb $0x3f, %bl
orb $-0x80, %bl
movb %bl, 0x1(%rdi,%r9)
shrl $0x6, %r10d
andb $0x3f, %r10b
orb $-0x80, %r10b
movb %r10b, 0x2(%rdi,%r9)
andb $0x3f, %r11b
orb $-0x80, %r11b
movb %r11b, 0x3(%rdi,%r9)
addq $0x4, %rsi
jmp 0x2d04
cmpw $0xdc00, %r11w          # imm = 0xDC00
je 0x2e32
addl $0x3, %r8d
cmpl %edx, %r8d
jge 0x2e32
shrl $0xc, %r10d
orb $-0x20, %r10b
movb %r10b, (%rdi,%r9)
movzwl (%rsi), %r10d
shrl $0x6, %r10d
andb $0x3f, %r10b
orb $-0x80, %r10b
movb %r10b, 0x1(%rdi,%r9)
movb (%rsi), %r10b
andb $0x3f, %r10b
orb $-0x80, %r10b
movb %r10b, 0x2(%rdi,%r9)
addq $0x2, %rsi
jmp 0x2d04
movb $0x0, (%rdi,%r9)
movq %rdi, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fatal
void stb_fatal(char *s, ...)
{
   va_list a;
   if (stb__file)
      fprintf(stderr, "[%s:%d] ", stb__file, stb__line);
   va_start(a,s);
   fputs("Fatal error: ", stderr);
   vfprintf(stderr, s, a);
   va_end(a);
   fputs("\n", stderr);
   #ifdef STB_DEBUG
   #ifdef _MSC_VER
   #ifndef STB_PTR64
   __asm int 3;   // trap to debugger!
   #else
   __debugbreak();
   #endif
   #else
   __builtin_trap();
   #endif
   #endif
   exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x2ee1
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x18c08(%rip), %rdx     # 0x1baf0
testq %rdx, %rdx
je 0x2f0b
movq 0x15104(%rip), %rax     # 0x17ff8
movq (%rax), %rdi
movl 0x18bfb(%rip), %ecx     # 0x1baf8
leaq 0xd4ce(%rip), %rsi      # 0x103d2
xorl %eax, %eax
callq 0x21f0
leaq 0x20(%rsp), %rax
movq %rsp, %r14
movq %rax, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0x150c1(%rip), %r15     # 0x17ff8
movq (%r15), %rsi
leaq 0xd49a(%rip), %rdi      # 0x103db
callq 0x2150
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2330
movq (%r15), %rsi
leaq 0xd472(%rip), %rdi      # 0x103d0
callq 0x2150
pushq $0x1
popq %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_
void stb_(char *s, ...)
{
   if (stb__log_active) {
      FILE *f = fopen(stb__log_filename, "a");
      if (f) {
         va_list a;
         if (stb__log_fileline && stb__file)
            fprintf(f, "[%s:%4d] ", stb__file, stb__line);
         va_start(a,s);
         vfprintf(f, s, a);
         va_end(a);
         fputs("\n", f);
         fclose(f);
      }
   }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
testb %al, %al
je 0x2fc6
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
cmpl $0x0, 0x1520a(%rip)     # 0x181f0
je 0x3086
movq %rdi, %rbx
movq 0x15202(%rip), %rdi     # 0x181f8
leaq 0xd3f4(%rip), %rsi      # 0x103f1
callq 0x22f0
testq %rax, %rax
je 0x3086
movq %rax, %r14
cmpl $0x0, 0x151e3(%rip)     # 0x181f4
setne %al
movq 0x18ad5(%rip), %rdx     # 0x1baf0
testq %rdx, %rdx
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x303f
movl 0x18aca(%rip), %ecx     # 0x1baf8
leaq 0xd3be(%rip), %rsi      # 0x103f3
movq %r14, %rdi
xorl %eax, %eax
callq 0x21f0
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2330
leaq 0xd35a(%rip), %rdi      # 0x103d0
movq %r14, %rsi
callq 0x2150
movq %r14, %rdi
callq 0x20d0
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_append_to_file
void stb_append_to_file(char *filename, char *s, ...)
{
   FILE *f = fopen(filename, "a");
   if (f) {
      va_list a;
      va_start(a,s);
      vfprintf(f, s, a);
      va_end(a);
      fputs("\n", f);
      fclose(f);
   }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x30ed
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0xd2fd(%rip), %rsi      # 0x103f1
callq 0x22f0
testq %rax, %rax
je 0x3148
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2330
leaq 0xd298(%rip), %rdi      # 0x103d0
movq %r14, %rsi
callq 0x2150
movq %r14, %rdi
callq 0x20d0
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_swap
void stb_swap(void *p, void *q, size_t sz)
{
   char buffer[256];
   if (p == q) return;
   if (sz == 4) {
      stb__4 temp    = * ( stb__4 *) p;
      * (stb__4 *) p = * ( stb__4 *) q;
      * (stb__4 *) q = temp;
      return;
   } else if (sz == 8) {
      stb__8 temp    = * ( stb__8 *) p;
      * (stb__8 *) p = * ( stb__8 *) q;
      * (stb__8 *) q = temp;
      return;
   }

   while (sz > sizeof(buffer)) {
      stb_swap(p, q, sizeof(buffer));
      p = (char *) p + sizeof(buffer);
      q = (char *) q + sizeof(buffer);
      sz -= sizeof(buffer);
   }

   memcpy(buffer, p     , sz);
   memcpy(p     , q     , sz);
   memcpy(q     , buffer, sz);
}

// Assembly:
cmpq %rsi, %rdi
je 0x3202
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
cmpq $0x4, %rdx
je 0x318d
cmpq $0x8, %r14
jne 0x3199
movq (%r15), %rax
movq (%rbx), %rcx
movq %rcx, (%r15)
movq %rax, (%rbx)
jmp 0x31f4
movl (%r15), %eax
movl (%rbx), %ecx
movl %ecx, (%r15)
movl %eax, (%rbx)
jmp 0x31f4
movl $0x100, %r12d           # imm = 0x100
cmpq $0x101, %r14            # imm = 0x101
jb 0x31c7
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3153
addq %r12, %r15
addq %r12, %rbx
addq $-0x100, %r14
jmp 0x319f
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2230
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2230
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x2230
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_array_block_alloc
void **stb_array_block_alloc(int count, int blocksize)
{
   int i;
   char *p = (char *) malloc(sizeof(void *) * count + count * blocksize);
   void **q;
   if (p == NULL) return NULL;
   q = (void **) p;
   p += sizeof(void *) * count;
   for (i=0; i < count; ++i)
      q[i] = p + i * blocksize;
   return q;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movslq %edi, %r14
movl %r14d, %eax
imull %esi, %eax
cltq
leaq (%rax,%r14,8), %rdi
callq 0x2250
testq %rax, %rax
je 0x32a4
leaq (,%r14,8), %rdx
movq %rax, %rcx
addq %rdx, %rcx
movslq %ebx, %rdx
xorl %esi, %esi
testl %r14d, %r14d
cmovgl %r14d, %esi
movq %rax, %rdi
subq $0x1, %rsi
jb 0x32a4
movq %rcx, (%rdi)
addq $0x8, %rdi
addq %rdx, %rcx
jmp 0x3292
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_newell_normal
void stb_newell_normal(float *normal, int num_vert, float **vert, int normalize)
{
   int i,j;
   float p;
   normal[0] = normal[1] = normal[2] = 0;
   for (i=num_vert-1,j=0; j < num_vert; i=j++) {
      float *u = vert[i];
      float *v = vert[j];
      normal[0] += (u[1] - v[1]) * (u[2] + v[2]);
      normal[1] += (u[2] - v[2]) * (u[0] + v[0]);
      normal[2] += (u[0] - v[0]) * (u[1] + v[1]);
   }
   if (normalize) {
      p = normal[0]*normal[0] + normal[1]*normal[1] + normal[2]*normal[2];
      p = (float) (1.0 / sqrt(p));
      normal[0] *= p;
      normal[1] *= p;
      normal[2] *= p;
   }
}

// Assembly:
andl $0x0, 0x8(%rdi)
andq $0x0, (%rdi)
leal -0x1(%rsi), %r8d
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
cmpq %rax, %rsi
je 0x33e6
movslq %r8d, %r8
movq (%rdx,%r8,8), %r8
movq (%rdx,%rax,8), %r9
movss 0x4(%r8), %xmm3
subss 0x4(%r9), %xmm3
movss 0x8(%r8), %xmm4
addss 0x8(%r9), %xmm4
mulss %xmm3, %xmm4
addss %xmm4, %xmm2
movss %xmm2, (%rdi)
movss (%r8), %xmm3
movss 0x8(%r8), %xmm4
subss 0x8(%r9), %xmm4
addss (%r9), %xmm3
mulss %xmm4, %xmm3
addss %xmm3, %xmm1
movss %xmm1, 0x4(%rdi)
movss (%r8), %xmm3
movss 0x4(%r8), %xmm4
subss (%r9), %xmm3
addss 0x4(%r9), %xmm4
mulss %xmm3, %xmm4
addss %xmm4, %xmm0
movss %xmm0, 0x8(%rdi)
movl %eax, %r8d
incq %rax
jmp 0x335d
testl %ecx, %ecx
je 0x3439
movaps %xmm1, %xmm3
mulss %xmm1, %xmm3
movaps %xmm2, %xmm4
mulss %xmm2, %xmm4
addss %xmm3, %xmm4
movaps %xmm0, %xmm3
mulss %xmm0, %xmm3
addss %xmm4, %xmm3
cvtss2sd %xmm3, %xmm3
sqrtsd %xmm3, %xmm3
movsd 0xcc09(%rip), %xmm4     # 0x10020
divsd %xmm3, %xmm4
cvtsd2ss %xmm4, %xmm3
mulss %xmm3, %xmm2
movss %xmm2, (%rdi)
mulss %xmm3, %xmm1
movss %xmm1, 0x4(%rdi)
mulss %xmm3, %xmm0
movss %xmm0, 0x8(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_box_face_vertex_axis_side
int stb_box_face_vertex_axis_side(int face_number, int vertex_number, int axis)
{
   static int box_vertices[6][4][3] =
   {
      { { 1,1,1 }, { 1,0,1 }, { 1,0,0 }, { 1,1,0 } },
      { { 0,0,0 }, { 0,0,1 }, { 0,1,1 }, { 0,1,0 } },
      { { 0,0,0 }, { 0,1,0 }, { 1,1,0 }, { 1,0,0 } },
      { { 0,0,0 }, { 1,0,0 }, { 1,0,1 }, { 0,0,1 } },
      { { 1,1,1 }, { 0,1,1 }, { 0,0,1 }, { 1,0,1 } },
      { { 1,1,1 }, { 1,1,0 }, { 0,1,0 }, { 0,1,1 } },
   };
   assert(face_number >= 0 && face_number < 6);
   assert(vertex_number >= 0 && vertex_number < 4);
   assert(axis >= 0 && axis < 3);
   return box_vertices[face_number][vertex_number][axis];
}

// Assembly:
pushq %rax
cmpl $0x6, %edi
jae 0x346a
cmpl $0x4, %esi
jae 0x3489
cmpl $0x3, %edx
jae 0x34a8
movl %edi, %eax
movl %esi, %ecx
movl %edx, %edx
imulq $0x30, %rax, %rax
leaq 0xcdf5(%rip), %rsi      # 0x10250
addq %rax, %rsi
imulq $0xc, %rcx, %rax
addq %rsi, %rax
movl (%rax,%rdx,4), %eax
popq %rcx
retq
leaq 0xcf8c(%rip), %rdi      # 0x103fd
leaq 0xcfa9(%rip), %rsi      # 0x10421
leaq 0xcfaa(%rip), %rcx      # 0x10429
movl $0x52e, %edx            # imm = 0x52E
callq 0x2140
leaq 0xcfca(%rip), %rdi      # 0x1045a
leaq 0xcf8a(%rip), %rsi      # 0x10421
leaq 0xcf8b(%rip), %rcx      # 0x10429
movl $0x52f, %edx            # imm = 0x52F
callq 0x2140
leaq 0xcfd3(%rip), %rdi      # 0x10482
leaq 0xcf6b(%rip), %rsi      # 0x10421
leaq 0xcf6c(%rip), %rcx      # 0x10429
movl $0x530, %edx            # imm = 0x530
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_linear_controller
void stb_linear_controller(float *curpos, float target_pos, float acc, float deacc, float dt)
{
   float sign = 1, p, cp = *curpos;
   if (cp == target_pos) return;
   if (target_pos < cp) {
      target_pos = -target_pos;
      cp = -cp;
      sign = -1;
   }
   // first decelerate
   if (cp < 0) {
      p = cp + deacc * dt;
      if (p > 0) {
         p = 0;
         dt = dt - cp / deacc;
         if (dt < 0) dt = 0;
      } else {
         dt = 0;
      }
      cp = p;
   }
   // now accelerate
   p = cp + acc*dt;
   if (p > target_pos) p = target_pos;
   *curpos = p * sign;
   // @TODO: testing
}

// Assembly:
movss (%rdi), %xmm5
ucomiss %xmm0, %xmm5
jne 0x34d3
jp 0x34d3
retq
movaps 0xcb86(%rip), %xmm4     # 0x10060
movaps %xmm5, %xmm7
xorps %xmm4, %xmm7
ja 0x34e7
movaps %xmm0, %xmm4
jmp 0x34ea
xorps %xmm0, %xmm4
cmpltss %xmm5, %xmm0
andps %xmm0, %xmm7
movaps %xmm0, %xmm6
andnps %xmm5, %xmm6
orps %xmm7, %xmm6
xorps %xmm5, %xmm5
ucomiss %xmm6, %xmm5
jbe 0x352b
movaps %xmm2, %xmm7
mulss %xmm3, %xmm7
addss %xmm6, %xmm7
ucomiss %xmm5, %xmm7
jbe 0x3531
divss %xmm2, %xmm6
subss %xmm6, %xmm3
xorps %xmm7, %xmm7
ucomiss %xmm3, %xmm7
movaps %xmm3, %xmm5
jbe 0x3531
xorps %xmm5, %xmm5
jmp 0x3531
movaps %xmm3, %xmm5
movaps %xmm6, %xmm7
mulss %xmm5, %xmm1
addss %xmm7, %xmm1
minss %xmm1, %xmm4
movaps %xmm0, %xmm1
andnps %xmm4, %xmm1
xorps 0xcb16(%rip), %xmm4     # 0x10060
andps %xmm0, %xmm4
orps %xmm1, %xmm4
movss %xmm4, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_is_prime
int stb_is_prime(unsigned int m)
{
   unsigned int i,j;
   if (m < 2) return 0;
   if (m == 2) return 1;
   if (!(m & 1)) return 0;
   if (m % 3 == 0) return (m == 3);
   for (i=5; (j=i*i), j <= m && j > i; i += 6) {
      if (m %   i   == 0) return 0;
      if (m % (i+2) == 0) return 0;
   }
   return 1;
}

// Assembly:
xorl %ecx, %ecx
cmpl $0x2, %edi
jb 0x35ec
pushq $0x1
popq %rsi
jne 0x3599
movl %esi, %ecx
jmp 0x35ec
testb $0x1, %dil
je 0x35ec
pushq $0x3
popq %rcx
movl %edi, %eax
xorl %edx, %edx
divl %ecx
testl %edx, %edx
je 0x35e4
pushq $0x5
popq %r8
movl %r8d, %eax
imull %r8d, %eax
cmpl %edi, %eax
ja 0x3595
cmpl %r8d, %eax
jbe 0x3595
xorl %ecx, %ecx
movl %edi, %eax
xorl %edx, %edx
divl %r8d
testl %edx, %edx
je 0x35ec
leal 0x2(%r8), %r9d
xorl %ecx, %ecx
movl %edi, %eax
xorl %edx, %edx
divl %r9d
addl $0x6, %r8d
testl %edx, %edx
jne 0x35b0
jmp 0x35ec
xorl %ecx, %ecx
cmpl $0x3, %edi
sete %cl
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_power_of_two_nearest_prime
unsigned int stb_power_of_two_nearest_prime(int n)
{
   static signed char tab[32] = { 0,0,0,0,1,0,-1,0,1,-1,-1,3,-1,0,-1,2,1,
                                   0,2,0,-1,-4,-1,5,-1,18,-2,15,2,-1,2,0 };
   if (!tab[0]) {
      int i;
      for (i=0; i < 32; ++i)
         tab[i] = (1 << i) + 2*tab[i] - 1;
      tab[1] = 2;
      tab[0] = 1;
   }
   if (n >= 32) return 0xfffffffb;
   return tab[n];
}

// Assembly:
cmpb $0x0, 0x14c0a(%rip)     # 0x18200
leaq 0x14c03(%rip), %rax     # 0x18200
jne 0x362c
xorl %ecx, %ecx
pushq $0x1
popq %rdx
cmpq $0x20, %rcx
je 0x3623
movl %edx, %esi
shll %cl, %esi
movzbl (%rcx,%rax), %r8d
leal (%rsi,%r8,2), %esi
decb %sil
movb %sil, (%rcx,%rax)
incq %rcx
jmp 0x3604
movw $0x201, 0x14bd4(%rip)   # imm = 0x201
cmpl $0x1f, %edi
jle 0x3635
pushq $-0x5
popq %rax
retq
movslq %edi, %rcx
movsbl (%rcx,%rax), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_log2_floor
int stb_log2_floor(unsigned int n)
{
   static signed char log2_4[16] = { -1,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3 };

   // 2 compares if n < 16, 3 compares otherwise
   if (n < (1U << 14))
        if (n < (1U <<  4))        return     0 + log2_4[n      ];
        else if (n < (1U <<  9))      return  5 + log2_4[n >>  5];
             else                     return 10 + log2_4[n >> 10];
   else if (n < (1U << 24))
             if (n < (1U << 19))      return 15 + log2_4[n >> 15];
             else                     return 20 + log2_4[n >> 20];
        else if (n < (1U << 29))      return 25 + log2_4[n >> 25];
             else                     return 30 + log2_4[n >> 30];
}

// Assembly:
cmpl $0x3fff, %edi           # imm = 0x3FFF
ja 0x372b
cmpl $0xf, %edi
ja 0x374d
movl %edi, %eax
leaq 0xc9da(%rip), %rcx      # 0x10100
movsbl (%rax,%rcx), %eax
retq
cmpl $0xffffff, %edi         # imm = 0xFFFFFF
ja 0x3767
cmpl $0x7ffff, %edi          # imm = 0x7FFFF
ja 0x3781
shrl $0xf, %edi
leaq 0xc9bb(%rip), %rax      # 0x10100
movsbl (%rdi,%rax), %eax
addl $0xf, %eax
retq
cmpl $0x1ff, %edi            # imm = 0x1FF
ja 0x3793
shrl $0x5, %edi
leaq 0xc9a1(%rip), %rax      # 0x10100
movsbl (%rdi,%rax), %eax
addl $0x5, %eax
retq
cmpl $0x1fffffff, %edi       # imm = 0x1FFFFFFF
ja 0x37a5
shrl $0x19, %edi
leaq 0xc987(%rip), %rax      # 0x10100
movsbl (%rdi,%rax), %eax
addl $0x19, %eax
retq
shrl $0x14, %edi
leaq 0xc975(%rip), %rax      # 0x10100
movsbl (%rdi,%rax), %eax
addl $0x14, %eax
retq
shrl $0xa, %edi
leaq 0xc963(%rip), %rax      # 0x10100
movsbl (%rdi,%rax), %eax
addl $0xa, %eax
retq
shrl $0x1e, %edi
leaq 0xc951(%rip), %rax      # 0x10100
movsbl (%rdi,%rax), %eax
addl $0x1e, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_lowbit8
int stb_lowbit8(unsigned int n)
{
   static signed char lowbit4[16] = { -1,0,1,0, 2,0,1,0, 3,0,1,0, 2,0,1,0 };
   int k = lowbit4[n & 15];
   if (k >= 0) return k;
   k = lowbit4[(n >> 4) & 15];
   if (k >= 0) return k+4;
   return k;
}

// Assembly:
movl %edi, %eax
andl $0xf, %eax
je 0x37e6
leaq 0xc92f(%rip), %rcx      # 0x10110
movsbl (%rax,%rcx), %eax
retq
shrl $0x4, %edi
andl $0xf, %edi
leaq 0xc91d(%rip), %rax      # 0x10110
movsbl (%rdi,%rax), %ecx
leal 0x4(%rcx), %eax
testl %edi, %edi
cmovel %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_probe_guess
static int stb_probe_guess(stb_search *s, int *result)
{
   switch(s->mode) {
      case STB_probe_binary_largest:
         if (s->minval == s->maxval) {
            *result = s->minval;
            return 0;
         }
         assert(s->minval < s->maxval);
         // if a < b, then a < p <= b
         s->guess = s->minval + (((unsigned) s->maxval - s->minval + 1) >> 1);
         break;

      case STB_probe_binary_smallest:
         if (s->minval == s->maxval) {
            *result = s->minval;
            return 0;
         }
         assert(s->minval < s->maxval);
         // if a < b, then a <= p < b
         s->guess = s->minval + (((unsigned) s->maxval - s->minval) >> 1);
         break;
      case STB_probe_open_smallest:
      case STB_probe_open_largest:
         s->guess = s->maxval;  // guess the current maxval
         break;
   }
   *result = s->guess;
   return 1;
}

// Assembly:
pushq %rax
movl 0xc(%rdi), %eax
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jb 0x397f
testl %eax, %eax
je 0x3984
cmpl $0x1, %eax
jne 0x3991
movl (%rdi), %ecx
movl 0x4(%rdi), %eax
subl %ecx, %eax
je 0x398d
jle 0x39a6
incl %eax
jmp 0x3998
movl 0x4(%rdi), %ecx
jmp 0x399c
movl (%rdi), %ecx
movl 0x4(%rdi), %eax
subl %ecx, %eax
jne 0x3996
xorl %eax, %eax
jmp 0x39a2
movl 0x8(%rdi), %ecx
jmp 0x399f
jle 0x39c5
shrl %eax
addl %eax, %ecx
movl %ecx, 0x8(%rdi)
pushq $0x1
popq %rax
movl %ecx, (%rsi)
popq %rcx
retq
leaq 0xd505(%rip), %rdi      # 0x10eb2
leaq 0xca6d(%rip), %rsi      # 0x10421
leaq 0xd50d(%rip), %rcx      # 0x10ec8
movl $0x682, %edx            # imm = 0x682
callq 0x2140
leaq 0xd4e6(%rip), %rdi      # 0x10eb2
leaq 0xca4e(%rip), %rsi      # 0x10421
leaq 0xd4ee(%rip), %rcx      # 0x10ec8
movl $0x68c, %edx            # imm = 0x68C
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_search_binary
int stb_search_binary(stb_search *s, int minv, int maxv, int find_smallest)
{
   int r;
   if (maxv < minv) return minv-1;
   s->minval = minv;
   s->maxval = maxv;
   s->mode = find_smallest ? STB_probe_binary_smallest : STB_probe_binary_largest;
   stb_probe_guess(s, &r);
   return r;
}

// Assembly:
movl %esi, %eax
cmpl %esi, %edx
jge 0x39ed
decl %eax
retq
pushq %rbx
subq $0x10, %rsp
movl %eax, (%rdi)
movl %edx, 0x4(%rdi)
xorl %eax, %eax
testl %ecx, %ecx
sete %al
movl %eax, 0xc(%rdi)
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x395b
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_search_open
int stb_search_open(stb_search *s, int minv, int find_smallest)
{
   int r;
   s->step   = 4;
   s->minval = minv;
   s->maxval = minv+s->step;
   s->mode = find_smallest ? STB_probe_open_smallest : STB_probe_open_largest;
   stb_probe_guess(s, &r);
   return r;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl $0x4, 0x10(%rdi)
movl %esi, (%rdi)
addl $0x4, %esi
movl %esi, 0x4(%rdi)
xorl %eax, %eax
cmpl $0x1, %edx
adcl $0x2, %eax
movl %eax, 0xc(%rdi)
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x395b
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_strscpy
size_t stb_strscpy(char *d, const char *s, size_t n)
{
   size_t len = strlen(s);
   if (len >= n) {
      if (n) d[0] = 0;
      return 0;
   }
   strcpy(d,s);
   return len + 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2100
cmpq %r12, %rax
jae 0x3a7b
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2080
incq %rbx
jmp 0x3a86
testq %r12, %r12
je 0x3a84
movb $0x0, (%r14)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_prefix_count
int stb_prefix_count(char *s, char *t)
{
   int c=0;
   while (*t) {
      if (*s++ != *t++)
         break;
      ++c;
   }
   return c;
}

// Assembly:
xorl %eax, %eax
movb (%rsi,%rax), %cl
testb %cl, %cl
je 0x3ad9
cmpb %cl, (%rdi,%rax)
jne 0x3ad9
incq %rax
jmp 0x3ac8
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_skipnewline
char *stb_skipnewline(char *s)
{
   if (s[0] == '\r' || s[0] == '\n') {
      if (s[0]+s[1] == '\r' + '\n') ++s;
      ++s;
   }
   return s;
}

// Assembly:
movq %rdi, %rax
movzbl (%rdi), %ecx
cmpl $0xd, %ecx
je 0x3b96
cmpl $0xa, %ecx
jne 0x3bad
leaq 0x1(%rax), %rdx
movsbl 0x1(%rax), %esi
addl %ecx, %esi
cmpl $0x17, %esi
cmovneq %rax, %rdx
incq %rdx
movq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_trimwhite
char *stb_trimwhite(char *s)
{
   int i,n;
   s = stb_skipwhite(s);
   n = (int) strlen(s);
   for (i=n-1; i >= 0; --i)
      if (!isspace(s[i]))
         break;
   s[i+1] = 0;
   return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x3b64
movq %rax, %rbx
movq %rax, %rdi
callq 0x2100
movq %rax, %r14
movl %r14d, %eax
movl %r14d, %ebp
sarl $0x1f, %ebp
andl %r14d, %ebp
leaq (%rax,%rbx), %r15
decq %r15
testl %r14d, %r14d
jle 0x3bff
callq 0x23b0
movq (%rax), %rax
movsbq (%r15), %rcx
decl %r14d
decq %r15
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x3bdb
incl %r14d
movl %r14d, %ebp
movslq %ebp, %rax
movb $0x0, (%rbx,%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_duplower
char *stb_duplower(char *s)
{
   char *p = strdup(s), *q = p;
   while (*q) {
      *q = tolower(*q);
      ++q;
   }
   return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x2380
movq %rax, %rbx
movq %rax, %r14
movsbq (%r14), %r15
testq %r15, %r15
je 0x3ca5
callq 0x23a0
movq (%rax), %rax
movb (%rax,%r15,4), %al
movb %al, (%r14)
incq %r14
jmp 0x3c88
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_strrchr2
char *stb_strrchr2(char *s, char x, char y)
{
   char *r = NULL;
   for(; *s; ++s)
      if (*s == x || *s == y)
         r = s;
   return r;
}

// Assembly:
xorl %eax, %eax
movb (%rdi), %cl
testb %cl, %cl
je 0x3d0d
cmpb %dl, %cl
cmoveq %rdi, %rax
cmpb %sil, %cl
cmoveq %rdi, %rax
incq %rdi
jmp 0x3cf5
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_stristr
char *stb_stristr(char *s, char *t)
{
   size_t n = strlen(t);
   char *z;
   if (n==0) return s;
   while ((z = stb_strichr(s, *t)) != NULL) {
      if (0==stb_strnicmp(z, t, n))
         return z;
      s = z+1;
   }
   return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2100
testq %rax, %rax
je 0x3db5
movq %rax, %r15
movsbl (%r14), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3d0e
testq %rax, %rax
je 0x3db3
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2260
testl %eax, %eax
je 0x3db5
incq %rbx
jmp 0x3d8a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_strtok_raw
static char *stb_strtok_raw(char *output, char *src, char *delimit, int keep, int invert)
{
   if (invert) {
      while (*src && strchr(delimit, *src) != NULL) {
         *output++ = *src++;
      }
   } else {
      while (*src && strchr(delimit, *src) == NULL) {
         *output++ = *src++;
      }
   }
   *output = 0;
   if (keep)
      return src;
   else
      return *src ? src+1 : src;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testl %r8d, %r8d
je 0x3e1f
movsbl (%rbx), %r12d
testl %r12d, %r12d
je 0x3e28
movq %r15, %rdi
movl %r12d, %esi
callq 0x2110
testq %rax, %rax
je 0x3e28
incq %rbx
movb %r12b, (%r14)
incq %r14
jmp 0x3de2
movq %r15, %rdi
movl %r12d, %esi
callq 0x2110
testq %rax, %rax
jne 0x3e28
incq %rbx
movb %r12b, (%r14)
incq %r14
movsbl (%rbx), %r12d
testl %r12d, %r12d
jne 0x3e06
movb $0x0, (%r14)
testl %ebp, %ebp
jne 0x3e37
cmpb $0x1, (%rbx)
sbbq $-0x1, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq