LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_set_precharge
uint8_t ssd1306_oled_set_precharge(uint8_t precharge)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_PRECHARGE;
    data_buf[2] = precharge;
    
    return _i2c_write(data_buf, 3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, 0xeffeb(%rip)     # 0x4f23d0
movb $-0x27, 0xeffe5(%rip)   # 0x4f23d1
movb -0x1(%rbp), %al
movb %al, 0xeffdd(%rip)      # 0x4f23d2
leaq 0xeffd4(%rip), %rdi     # 0x4f23d0
movl $0x3, %esi
callq 0x403280
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_set_deselect
uint8_t ssd1306_oled_set_deselect(uint8_t voltage)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_DESELECT_LV;
    data_buf[2] = voltage;
    
    return _i2c_write(data_buf, 3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, 0xeffab(%rip)     # 0x4f23d0
movb $-0x25, 0xeffa5(%rip)   # 0x4f23d1
movb -0x1(%rbp), %al
movb %al, 0xeff9d(%rip)      # 0x4f23d2
leaq 0xeff94(%rip), %rdi     # 0x4f23d0
movl $0x3, %esi
callq 0x403280
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_set_com_pin
uint8_t ssd1306_oled_set_com_pin(uint8_t value)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_COM_PIN;
    data_buf[2] = value;
    
    return _i2c_write(data_buf, 3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, 0xeff6b(%rip)     # 0x4f23d0
movb $-0x26, 0xeff65(%rip)   # 0x4f23d1
movb -0x1(%rbp), %al
movb %al, 0xeff5d(%rip)      # 0x4f23d2
leaq 0xeff54(%rip), %rdi     # 0x4f23d0
movl $0x3, %esi
callq 0x403280
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_set_mem_mode
uint8_t ssd1306_oled_set_mem_mode(uint8_t mode)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_MEMORY_MODE;
    data_buf[2] = mode;
    
    return _i2c_write(data_buf, 3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, 0xeff2b(%rip)     # 0x4f23d0
movb $0x20, 0xeff25(%rip)    # 0x4f23d1
movb -0x1(%rbp), %al
movb %al, 0xeff1d(%rip)      # 0x4f23d2
leaq 0xeff14(%rip), %rdi     # 0x4f23d0
movl $0x3, %esi
callq 0x403280
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_set_col
uint8_t ssd1306_oled_set_col(uint8_t start, uint8_t end)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_SET_COL_ADDR;
    data_buf[2] = start;
    data_buf[3] = end;
    
    return _i2c_write(data_buf, 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
movb $0x0, 0xefee5(%rip)     # 0x4f23d0
movb $0x21, 0xefedf(%rip)    # 0x4f23d1
movb -0x1(%rbp), %al
movb %al, 0xefed7(%rip)      # 0x4f23d2
movb -0x2(%rbp), %al
movb %al, 0xefecf(%rip)      # 0x4f23d3
leaq 0xefec5(%rip), %rdi     # 0x4f23d0
movl $0x4, %esi
callq 0x403280
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_set_page
uint8_t ssd1306_oled_set_page(uint8_t start, uint8_t end)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_SET_PAGE_ADDR;
    data_buf[2] = start;
    data_buf[3] = end;
    
    return _i2c_write(data_buf, 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
movb $0x0, 0xefe95(%rip)     # 0x4f23d0
movb $0x22, 0xefe8f(%rip)    # 0x4f23d1
movb -0x1(%rbp), %al
movb %al, 0xefe87(%rip)      # 0x4f23d2
movb -0x2(%rbp), %al
movb %al, 0xefe7f(%rip)      # 0x4f23d3
leaq 0xefe75(%rip), %rdi     # 0x4f23d0
movl $0x4, %esi
callq 0x403280
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_set_constrast
uint8_t ssd1306_oled_set_constrast(uint8_t value)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_CONTRAST;
    data_buf[2] = value;
    
    return _i2c_write(data_buf, 3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, 0xefe4b(%rip)     # 0x4f23d0
movb $-0x7f, 0xefe45(%rip)   # 0x4f23d1
movb -0x1(%rbp), %al
movb %al, 0xefe3d(%rip)      # 0x4f23d2
leaq 0xefe34(%rip), %rdi     # 0x4f23d0
movl $0x3, %esi
callq 0x403280
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_scroll_onoff
uint8_t ssd1306_oled_scroll_onoff(uint8_t onoff)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    if (onoff == 0)
        data_buf[1] = SSD1306_COMM_DISABLE_SCROLL;
    else
        data_buf[1] = SSD1306_COMM_ENABLE_SCROLL;
    
    return _i2c_write(data_buf, 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, 0xefe0b(%rip)     # 0x4f23d0
movzbl -0x1(%rbp), %eax
cmpl $0x0, %eax
jne 0x4025d7
movb $0x2e, 0xefdfc(%rip)    # 0x4f23d1
jmp 0x4025de
movb $0x2f, 0xefdf3(%rip)    # 0x4f23d1
leaq 0xefdeb(%rip), %rdi     # 0x4f23d0
movl $0x2, %esi
callq 0x403280
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_set_X
uint8_t ssd1306_oled_set_X(uint8_t x)
{
    if (x >= max_columns)
        return 1;

    global_x = x;
    
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_LOW_COLUMN | (x & 0x0f);
    data_buf[2] = SSD1306_COMM_HIGH_COLUMN | ((x >> 4) & 0x0f);
    
    return _i2c_write(data_buf, 3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
movzbl 0xf01b7(%rip), %ecx     # 0x4f27d0
cmpl %ecx, %eax
jl 0x402623
movb $0x1, -0x1(%rbp)
jmp 0x40266a
movb -0x2(%rbp), %al
movb %al, 0xf01a5(%rip)      # 0x4f27d1
movb $0x0, 0xefd9d(%rip)     # 0x4f23d0
movzbl -0x2(%rbp), %eax
andl $0xf, %eax
orl $0x0, %eax
movb %al, 0xefd8e(%rip)      # 0x4f23d1
movzbl -0x2(%rbp), %eax
sarl $0x4, %eax
andl $0xf, %eax
orl $0x10, %eax
movb %al, 0xefd7c(%rip)      # 0x4f23d2
leaq 0xefd73(%rip), %rdi     # 0x4f23d0
movl $0x3, %esi
callq 0x403280
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_set_Y
uint8_t ssd1306_oled_set_Y(uint8_t y)
{
    if (y >= (max_lines / 8))
        return 1;

    global_y = y;
    
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_PAGE_NUMBER | (y & 0x0f);

    return _i2c_write(data_buf, 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
movl %eax, -0x8(%rbp)
movzbl 0xf0136(%rip), %eax     # 0x4f27d2
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x8(%rbp), %eax
cmpl %ecx, %eax
jl 0x4026b3
movb $0x1, -0x1(%rbp)
jmp 0x4026e9
movb -0x2(%rbp), %al
movb %al, 0xf0117(%rip)      # 0x4f27d3
movb $0x0, 0xefd0d(%rip)     # 0x4f23d0
movzbl -0x2(%rbp), %eax
andl $0xf, %eax
orl $0xb0, %eax
movb %al, 0xefcfc(%rip)      # 0x4f23d1
leaq 0xefcf4(%rip), %rdi     # 0x4f23d0
movl $0x2, %esi
callq 0x403280
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_set_XY
uint8_t ssd1306_oled_set_XY(uint8_t x, uint8_t y)
{
    if (x >= max_columns || y >= (max_lines / 8))
        return 1;

    global_x = x;
    global_y = y;
    
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_PAGE_NUMBER | (y & 0x0f);

    data_buf[2] = SSD1306_COMM_LOW_COLUMN | (x & 0x0f);
    
    data_buf[3] = SSD1306_COMM_HIGH_COLUMN | ((x >> 4) & 0x0f);
    
    return _i2c_write(data_buf, 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x2(%rbp)
movb %al, -0x3(%rbp)
movzbl -0x2(%rbp), %eax
movzbl 0xf00b1(%rip), %ecx     # 0x4f27d0
cmpl %ecx, %eax
jge 0x402742
movzbl -0x3(%rbp), %eax
movl %eax, -0x8(%rbp)
movzbl 0xf00a1(%rip), %eax     # 0x4f27d2
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x8(%rbp), %eax
cmpl %ecx, %eax
jl 0x402748
movb $0x1, -0x1(%rbp)
jmp 0x4027aa
movb -0x2(%rbp), %al
movb %al, 0xf0080(%rip)      # 0x4f27d1
movb -0x3(%rbp), %al
movb %al, 0xf0079(%rip)      # 0x4f27d3
movb $0x0, 0xefc6f(%rip)     # 0x4f23d0
movzbl -0x3(%rbp), %eax
andl $0xf, %eax
orl $0xb0, %eax
movb %al, 0xefc5e(%rip)      # 0x4f23d1
movzbl -0x2(%rbp), %eax
andl $0xf, %eax
orl $0x0, %eax
movb %al, 0xefc4f(%rip)      # 0x4f23d2
movzbl -0x2(%rbp), %eax
sarl $0x4, %eax
andl $0xf, %eax
orl $0x10, %eax
movb %al, 0xefc3d(%rip)      # 0x4f23d3
leaq 0xefc33(%rip), %rdi     # 0x4f23d0
movl $0x4, %esi
callq 0x403280
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_set_rotate
uint8_t ssd1306_oled_set_rotate(uint8_t degree)
{
    // only degree 0 and 180
    if (degree == 0)
    {
        data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
        data_buf[1] = SSD1306_COMM_HORIZ_FLIP;
        data_buf[2] = SSD1306_COMM_SCAN_REVS;
    
        return _i2c_write(data_buf, 3);
    }
    else if (degree == 180)
    {
        data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
        data_buf[1] = SSD1306_COMM_HORIZ_NORM;
        data_buf[2] = SSD1306_COMM_SCAN_NORM;
    
        return _i2c_write(data_buf, 3);
    }
    else
        return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
cmpl $0x0, %eax
jne 0x402802
movb $0x0, 0xefbf2(%rip)     # 0x4f23d0
movb $-0x5f, 0xefbec(%rip)   # 0x4f23d1
movb $-0x38, 0xefbe6(%rip)   # 0x4f23d2
leaq 0xefbdd(%rip), %rdi     # 0x4f23d0
movl $0x3, %esi
callq 0x403280
movb %al, -0x1(%rbp)
jmp 0x40283c
movzbl -0x2(%rbp), %eax
cmpl $0xb4, %eax
jne 0x402838
movb $0x0, 0xefbbc(%rip)     # 0x4f23d0
movb $-0x60, 0xefbb6(%rip)   # 0x4f23d1
movb $-0x40, 0xefbb0(%rip)   # 0x4f23d2
leaq 0xefba7(%rip), %rdi     # 0x4f23d0
movl $0x3, %esi
callq 0x403280
movb %al, -0x1(%rbp)
jmp 0x40283c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_save_resolution
uint8_t ssd1306_oled_save_resolution(uint8_t column, uint8_t row)
{
    FILE* fp;
    
    fp = fopen(init_oled_type_file, "w");
    
    if (fp == NULL)
    {
        // file create failed
        return 1;
    }
    
    fprintf(fp, "%hhux%hhu", column, row);
    fclose(fp);
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x2(%rbp)
movb %al, -0x3(%rbp)
leaq 0xbbd45(%rip), %rdi     # 0x4bea00
leaq 0xbbd59(%rip), %rsi     # 0x4bea1b
callq 0x41c1a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x402cd8
movb $0x1, -0x1(%rbp)
jmp 0x402cff
movq -0x10(%rbp), %rdi
movzbl -0x2(%rbp), %edx
movzbl -0x3(%rbp), %ecx
leaq 0xbbd32(%rip), %rsi     # 0x4bea1d
movb $0x0, %al
callq 0x40d730
movq -0x10(%rbp), %rdi
callq 0x41bd60
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_write_string
uint8_t ssd1306_oled_write_string(uint8_t size, char* ptr)
{
    uint8_t rc = 0;
    
    if (ptr == 0)
        return 1;
    
    char* line = 0;
    char* cr = 0;
    char buf[20];
    
    line = ptr;
    do {
        memset(buf, 0, 20);
        cr = strstr(line, "\\n");
        if (cr != NULL)
        {
            strncpy(buf, line, cr - line);
        }
        else
        {
            strcpy(buf, line);
        }
        
        // set cursor position
        ssd1306_oled_set_XY(global_x, global_y);
        rc += ssd1306_oled_write_line(size, buf);
        
        if (cr != NULL)
        {
            line = &cr[2];
            global_x = 0;
            global_y++;
            if (global_y >= (max_lines / 8))
                global_y = 0;
        }
        else
            line = NULL;
                
    }while (line != NULL);
    
    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x402f06
movb $0x1, -0x1(%rbp)
jmp 0x40300e
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x4010a0
movq -0x20(%rbp), %rdi
leaq 0xbbadf(%rip), %rsi     # 0x4bea18
callq 0x401070
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x402f63
leaq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rax
subq %rax, %rdx
callq 0x401080
jmp 0x402f70
leaq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x401020
movb 0xef85b(%rip), %al      # 0x4f27d1
movzbl %al, %edi
movzbl 0xef853(%rip), %esi     # 0x4f27d3
callq 0x402700
movb -0x2(%rbp), %al
leaq -0x40(%rbp), %rsi
movzbl %al, %edi
callq 0x402d10
movzbl %al, %ecx
movzbl -0x11(%rbp), %eax
addl %ecx, %eax
movb %al, -0x11(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x402ff3
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movb $0x0, 0xef817(%rip)     # 0x4f27d1
movb 0xef813(%rip), %al      # 0x4f27d3
addb $0x1, %al
movb %al, 0xef80b(%rip)      # 0x4f27d3
movzbl 0xef804(%rip), %eax     # 0x4f27d3
movl %eax, -0x44(%rbp)
movzbl 0xef7f9(%rip), %eax     # 0x4f27d2
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jl 0x402ff1
movb $0x0, 0xef7e2(%rip)     # 0x4f27d3
jmp 0x402ffb
movq $0x0, -0x20(%rbp)
jmp 0x402ffd
cmpq $0x0, -0x20(%rbp)
jne 0x402f1e
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_clear_line
uint8_t ssd1306_oled_clear_line(uint8_t row)
{
    uint8_t i;
    if (row >= (max_lines / 8))
        return 1;
        
    ssd1306_oled_set_XY(0, row);
    data_buf[0] = SSD1306_DATA_CONTROL_BYTE;
    for (i = 0; i < max_columns; i++)
        data_buf[i+1] = 0x00;
        
    return _i2c_write(data_buf, 1 + max_columns);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
movl %eax, -0x8(%rbp)
movzbl 0xef796(%rip), %eax     # 0x4f27d2
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x8(%rbp), %eax
cmpl %ecx, %eax
jl 0x403053
movb $0x1, -0x1(%rbp)
jmp 0x4030b3
xorl %edi, %edi
movzbl -0x2(%rbp), %esi
callq 0x402700
movb $0x40, 0xef36b(%rip)    # 0x4f23d0
movb $0x0, -0x3(%rbp)
movzbl -0x3(%rbp), %eax
movzbl 0xef75c(%rip), %ecx     # 0x4f27d0
cmpl %ecx, %eax
jge 0x403097
movzbl -0x3(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0xef347(%rip), %rax     # 0x4f23d0
movb $0x0, (%rax,%rcx)
movb -0x3(%rbp), %al
addb $0x1, %al
movb %al, -0x3(%rbp)
jmp 0x403069
movzbl 0xef732(%rip), %eax     # 0x4f27d0
addl $0x1, %eax
leaq 0xef328(%rip), %rdi     # 0x4f23d0
movswl %ax, %esi
callq 0x403280
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_clear_screen
uint8_t ssd1306_oled_clear_screen()
{
    uint8_t rc = 0;
    uint8_t i;
    
    for (i = 0; i < (max_lines / 8); i++)
    {
        rc += ssd1306_oled_clear_line(i);
    }
    
    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x0, -0x1(%rbp)
movb $0x0, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
movl %eax, -0x8(%rbp)
movzbl 0xef6f4(%rip), %eax     # 0x4f27d2
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x8(%rbp), %eax
cmpl %ecx, %eax
jge 0x40310e
movzbl -0x2(%rbp), %edi
callq 0x403020
movzbl %al, %ecx
movzbl -0x1(%rbp), %eax
addl %ecx, %eax
movb %al, -0x1(%rbp)
movb -0x2(%rbp), %al
addb $0x1, %al
movb %al, -0x2(%rbp)
jmp 0x4030d0
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_load_resolution
uint8_t ssd1306_oled_load_resolution()
{
    FILE* fp;
    
    fp = fopen(init_oled_type_file, "r");
    
    if (fp == NULL)
    {
        // file not exists
        return 1;
    }
    
    // file exists
    fscanf(fp, "%hhux%hhu", &max_columns, &max_lines);
    fclose(fp);
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xbb8d1(%rip), %rdi     # 0x4bea00
leaq 0xd7491(%rip), %rsi     # 0x4da5c7
callq 0x41c1a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x40314c
movb $0x1, -0x1(%rbp)
jmp 0x403179
movq -0x10(%rbp), %rdi
leaq 0xbb8c6(%rip), %rsi     # 0x4bea1d
leaq 0xef672(%rip), %rdx     # 0x4f27d0
leaq 0xef66d(%rip), %rcx     # 0x4f27d2
movb $0x0, %al
callq 0x40db10
movq -0x10(%rbp), %rdi
callq 0x41bd60
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/linux_i2c.c
// Function: i2c_init
uint8_t _i2c_init(int i2c, int dev_addr)
{
	if (file_i2c == 0)
	{
		char filename[32];
  		sprintf(filename, "/dev/i2c-%d", i2c); // I2C bus number passed
		file_i2c = open(filename, O_RDWR);
		if (file_i2c < 0)
		{
			file_i2c = 0;
			return 1;
		}
		if (ioctl(file_i2c, I2C_SLAVE, dev_addr) < 0) // set slave address
		{
			close(file_i2c);
			file_i2c = 0;
			return 1;
		}
		return 0;
	}
	
	// assume done init already
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, 0xef62f(%rip)     # 0x4f27d4
jne 0x403226
leaq -0x30(%rbp), %rdi
movl -0x8(%rbp), %edx
leaq 0xbb872(%rip), %rsi     # 0x4bea27
movb $0x0, %al
callq 0x40d980
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
movb $0x0, %al
callq 0x4600d0
movl %eax, 0xef602(%rip)     # 0x4f27d4
cmpl $0x0, 0xef5fb(%rip)     # 0x4f27d4
jge 0x4031eb
movl $0x0, 0xef5ef(%rip)     # 0x4f27d4
movb $0x1, -0x1(%rbp)
jmp 0x40322a
movl 0xef5e3(%rip), %edi     # 0x4f27d4
movl -0xc(%rbp), %edx
movl $0x703, %esi            # imm = 0x703
movb $0x0, %al
callq 0x460eb0
cmpl $0x0, %eax
jge 0x403220
movl 0xef5c9(%rip), %edi     # 0x4f27d4
callq 0x460370
movl $0x0, 0xef5ba(%rip)     # 0x4f27d4
movb $0x1, -0x1(%rbp)
jmp 0x40322a
movb $0x0, -0x1(%rbp)
jmp 0x40322a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/linux_i2c.c
// Function: i2c_close
uint8_t _i2c_close()
{
	if (file_i2c != 0)
	{
		close(file_i2c);
		file_i2c = 0;
		return 0;
	}
	
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0xef585(%rip)     # 0x4f27d4
je 0x40326c
movl 0xef57d(%rip), %edi     # 0x4f27d4
callq 0x460370
movl $0x0, 0xef56e(%rip)     # 0x4f27d4
movb $0x0, -0x1(%rbp)
jmp 0x403270
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/linux_i2c.c
// Function: i2c_write
uint8_t _i2c_write(uint8_t* ptr, int16_t len)
{
	if (file_i2c == 0 || ptr == 0 || len <= 0)
		return 1;
				
	write(file_i2c, ptr, len);
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
cmpl $0x0, 0xef53a(%rip)     # 0x4f27d4
je 0x4032ac
cmpq $0x0, -0x10(%rbp)
je 0x4032ac
movswl -0x12(%rbp), %eax
cmpl $0x0, %eax
jg 0x4032b2
movb $0x1, -0x1(%rbp)
jmp 0x4032ca
movl 0xef51c(%rip), %edi     # 0x4f27d4
movq -0x10(%rbp), %rsi
movswq -0x12(%rbp), %rdx
callq 0x4602a0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/linux_i2c.c
// Function: i2c_read
uint8_t _i2c_read(uint8_t *ptr, int16_t len)
{
	if (file_i2c == 0 || ptr == 0 || len <= 0)
		return 1;
				
	read(file_i2c, ptr, len);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
cmpl $0x0, 0xef4da(%rip)     # 0x4f27d4
je 0x40330c
cmpq $0x0, -0x10(%rbp)
je 0x40330c
movswl -0x12(%rbp), %eax
cmpl $0x0, %eax
jg 0x403312
movb $0x1, -0x1(%rbp)
jmp 0x40332a
movl 0xef4bc(%rip), %edi     # 0x4f27d4
movq -0x10(%rbp), %rsi
movswq -0x12(%rbp), %rdx
callq 0x460200
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilesr[P]dotter/./stb/stb_image_write.h
// Function: stbi_write_hdr_core
static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data)
{
   if (y <= 0 || x <= 0 || data == NULL)
      return 0;
   else {
      // Each component is stored separately. Allocate scratch space for full output scanline.
      unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4);
      int i, len;
      char buffer[128];
      char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n";
      s->func(s->context, header, sizeof(header)-1);

      len = sprintf(buffer, "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n", y, x);
      s->func(s->context, buffer, len);

      for(i=0; i < y; i++)
         stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*i*x);
      STBIW_FREE(scratch);
      return 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x21ef
cmpl $0x0, -0x14(%rbp)
jle 0x21ef
cmpq $0x0, -0x28(%rbp)
jne 0x21fb
movl $0x0, -0x4(%rbp)
jmp 0x22d0
movl -0x14(%rbp), %eax
shll $0x2, %eax
movslq %eax, %rdi
callq 0x1120
movq %rax, -0x30(%rbp)
leaq -0x110(%rbp), %rdi
leaq 0xd055(%rip), %rsi      # 0xf270
movl $0x42, %edx
callq 0x1100
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
leaq -0x110(%rbp), %rsi
movl $0x41, %edx
callq *%rax
leaq -0xc0(%rbp), %rdi
movl -0x18(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0xc933(%rip), %rsi      # 0xeb89
movb $0x0, %al
callq 0x1190
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
leaq -0xc0(%rbp), %rsi
movl -0x38(%rbp), %edx
callq *%rax
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x22c0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x1c(%rbp), %edx
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %r8
movl -0x1c(%rbp), %eax
imull -0x34(%rbp), %eax
imull -0x14(%rbp), %eax
cltq
shlq $0x2, %rax
addq %rax, %r8
callq 0x1d80
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2282
movq -0x30(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilesr[P]dotter/./stb/stb_image_write.h
// Function: stbi_write_png
STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
{
   FILE *f;
   int len;
   unsigned char *png = stbi_write_png_to_mem((unsigned char *) data, stride_bytes, x, y, comp, &len);
   if (png == NULL) return 0;
   f = fopen(filename, "wb");
   if (!f) { STBIW_FREE(png); return 0; }
   fwrite(png, 1, len, f);
   fclose(f);
   STBIW_FREE(png);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
leaq -0x3c(%rbp), %r9
callq 0x3190
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x3d5b
movl $0x0, -0x4(%rbp)
jmp 0x3db7
movq -0x10(%rbp), %rdi
leaq 0xac89(%rip), %rsi      # 0xe9ef
callq 0x1170
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x3d88
movq -0x48(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
jmp 0x3db7
movq -0x48(%rbp), %rdi
movslq -0x3c(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl $0x1, %esi
callq 0x11a0
movq -0x38(%rbp), %rdi
callq 0x1060
movq -0x48(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nilesr[P]dotter/dotter.c
// Function: dist
double dist(uint8_t* a, uint8_t* b, box_t box, int width) {
   double res = 0;
   // Add up the differences in each pixel
   for (int x = box.x1; x < box.x2; x++) {
      for (int y = box.y1; y < box.y2; y++) {
         res += subtract(getpixel(a, x, y, width), getpixel(b, x, y, width));
      }
   }
   // divide by the area (width*height) of the box
   return res / ((box.x2 - box.x1) * (box.y2 - box.y1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x5c36
movl -0xc(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x5c29
movq -0x18(%rbp), %rdi
movl -0x34(%rbp), %esi
movl -0x38(%rbp), %edx
movl -0x24(%rbp), %ecx
callq 0x5af0
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movl -0x34(%rbp), %esi
movl -0x38(%rbp), %edx
movl -0x24(%rbp), %ecx
callq 0x5af0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x5b20
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x5bd8
jmp 0x5c2b
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5bca
movsd -0x30(%rbp), %xmm0
movl -0x8(%rbp), %eax
subl -0x10(%rbp), %eax
movl -0x4(%rbp), %ecx
subl -0xc(%rbp), %ecx
imull %ecx, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilesr[P]dotter/dotter.c
// Function: correct
void correct(box_t* box, int width, int height, int radius) {
   if (box->x1 < 0) {
      box->x2 += -box->x1;
      box->x1 += -box->x1;
   }
   if (box->y1 < 0) {
      box->y2 += -box->y1;
      box->y1 += -box->y1;
   }
   if (box->y2 > height) {
      box->y2 -= radius * 2;
      box->y1 -= radius * 2;
   }
   if (box->x2 > width) {
      box->x2 -= radius * 2;
      box->x1 -= radius * 2;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x5c9c
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
subl (%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
subl (%rax), %ecx
movq -0x8(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jge 0x5ccc
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
subl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
subl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x10(%rbp), %eax
jle 0x5cfa
movl -0x14(%rbp), %edx
shll %edx
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %edx
shll %edx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0xc(%rbp), %eax
jle 0x5d26
movl -0x14(%rbp), %edx
shll %edx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %edx
shll %edx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilesr[P]dotter/dotter.c
// Function: draw
void draw(uint8_t* image, box_t box, uint8_t* color, int width, int radius) {
   // Center coordinates of the circle
   int cx = box.x1 + ((box.x2 - box.x1)/2);
   int cy = box.y1 + ((box.y2 - box.y1)/2);
   // For each pixel
   for (int x = box.x1; x < box.x2; x++) {
      for (int y = box.y1; y < box.y2; y++) {
         // If it's inside the circle, copy the color to that pixel
         if (sqrt(square(x - cx) + square(y - cy)) <= radius) {
            uint8_t* pixel = getpixel(image, x, y, width);
            memcpy(pixel, color, 3);
         }
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x8(%rbp), %eax
subl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x48(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x4(%rbp), %eax
subl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x44(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x30(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x5e2a
movl -0xc(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x5e1a
movl -0x34(%rbp), %edi
subl -0x2c(%rbp), %edi
callq 0x5ae0
movl %eax, -0x4c(%rbp)
movl -0x38(%rbp), %edi
subl -0x30(%rbp), %edi
callq 0x5ae0
movl %eax, %ecx
movl -0x4c(%rbp), %eax
addl %ecx, %eax
cvtsi2sd %eax, %xmm0
callq 0x11b0
movaps %xmm0, %xmm1
cvtsi2sdl -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x5e0d
movq -0x18(%rbp), %rdi
movl -0x34(%rbp), %esi
movl -0x38(%rbp), %edx
movl -0x24(%rbp), %ecx
callq 0x5af0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movw (%rcx), %dx
movw %dx, (%rax)
movb 0x2(%rcx), %cl
movb %cl, 0x2(%rax)
jmp 0x5e0f
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x5da4
jmp 0x5e1c
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5d92
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nilesr[P]dotter/./stb/stb_image.h
// Function: stbi__ldr_to_hdr
static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
{
   int i,k,n;
   float *output;
   if (!data) return NULL;
   output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0);
   if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); }
   // compute number of non-alpha components
   if (comp & 1) n = comp; else n = comp-1;
   for (i=0; i < x*y; ++i) {
      for (k=0; k < n; ++k) {
         output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
      }
      if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f;
   }
   STBI_FREE(data);
   return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xbb09
movq $0x0, -0x8(%rbp)
jmp 0xbc6a
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0xbc80
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xbb53
movq -0x10(%rbp), %rdi
callq 0x1030
leaq 0x3244(%rip), %rdi      # 0xed7e
callq 0x4a00
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0xbc6a
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xbb66
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0xbb6f
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x14(%rbp), %ecx
imull -0x18(%rbp), %ecx
cmpl %ecx, %eax
jge 0xbc59
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0xbc06
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movss 0x148c(%rip), %xmm1     # 0xd044
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movss 0x663c(%rip), %xmm1     # 0x12204
cvtss2sd %xmm1, %xmm1
callq 0x1050
movss 0x662f(%rip), %xmm1     # 0x12208
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xbb8f
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xbc49
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movss 0x1415(%rip), %xmm1     # 0xd044
divss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0xbc4b
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xbb76
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/starius[P]dna-complement/dna-complement.c
// Function: initializeTranslate
void initializeTranslate() {
    int i;
    for (i = 0; i < NCHARS; i++) {
        translate[i] = i;
    }
    translate['A'] = 'T';
    translate['T'] = 'A';
    translate['G'] = 'C';
    translate['C'] = 'G';
    translate['a'] = 't';
    translate['t'] = 'a';
    translate['g'] = 'c';
    translate['c'] = 'g';
#if USE_SHORT
    int x, y;
    for (x = 0; x < NCHARS; x++) {
        for (y = 0; y < NCHARS; y++) {
            unsigned short in_xy = (x << 8) | y;
            unsigned short out_xy =
                ((unsigned short)(translate[x]) << 8) |
                (unsigned short)(translate[y]);
            short_translate[in_xy] = out_xy;
        }
    }
#endif
}

// Assembly:
movl $0x0, -0x4(%rsp)
cmpl $0x100, -0x4(%rsp)      # imm = 0x100
jge 0x11d4
movl -0x4(%rsp), %eax
movb %al, %dl
movslq -0x4(%rsp), %rcx
leaq 0x2eac(%rip), %rax      # 0x4070
movb %dl, (%rax,%rcx)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x11a8
movb $0x54, 0x2ed6(%rip)     # 0x40b1
movb $0x41, 0x2ee2(%rip)     # 0x40c4
movb $0x43, 0x2ece(%rip)     # 0x40b7
movb $0x47, 0x2ec3(%rip)     # 0x40b3
movb $0x74, 0x2eda(%rip)     # 0x40d1
movb $0x61, 0x2ee6(%rip)     # 0x40e4
movb $0x63, 0x2ed2(%rip)     # 0x40d7
movb $0x67, 0x2ec7(%rip)     # 0x40d3
movl $0x0, -0x8(%rsp)
cmpl $0x100, -0x8(%rsp)      # imm = 0x100
jge 0x12aa
movl $0x0, -0xc(%rsp)
cmpl $0x100, -0xc(%rsp)      # imm = 0x100
jge 0x1298
movl -0x8(%rsp), %eax
shll $0x8, %eax
orl -0xc(%rsp), %eax
movw %ax, -0xe(%rsp)
movslq -0x8(%rsp), %rcx
leaq 0x2e20(%rip), %rax      # 0x4070
movsbl (%rax,%rcx), %eax
movzwl %ax, %eax
shll $0x8, %eax
movslq -0xc(%rsp), %rdx
leaq 0x2e0a(%rip), %rcx      # 0x4070
movsbl (%rcx,%rdx), %ecx
movzwl %cx, %ecx
orl %ecx, %eax
movw %ax, -0x10(%rsp)
movw -0x10(%rsp), %dx
movzwl -0xe(%rsp), %eax
movl %eax, %ecx
leaq 0x2ee9(%rip), %rax      # 0x4170
movw %dx, (%rax,%rcx,2)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x122a
jmp 0x129a
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x1214
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/tests/mux/main.c
// Function: pingpong
static int
pingpong(struct wire_requestqueue * Q, const char * key, const char * to,
    const char * from, int start)
{
	struct kvldskey * k;
	struct kvldskey * v0, * v1;
	int i;

	/* Create key and values. */
	if ((k = kvldskey_create((const uint8_t *)key, strlen(key))) == NULL)
		return (-1);
	if ((v0 = kvldskey_create((const uint8_t *)from, strlen(from))) == NULL)
		return (-1);
	if ((v1 = kvldskey_create((const uint8_t *)to, strlen(to))) == NULL)
		return (-1);

	/* Write initial value if we're starting the pingpong. */
	if (start) {
		if (set(Q, k, v1))
			return (-1);
	}

	/* Pingpong 100 times. */
	for (i = start; i < 100; ) {
		if (cas(Q, k, v0, v1))
			return (-1);
		if (op_p)
			i++;
	}

	/* Delete final value if necessary. */
	if (start) {
		do {
			if (cad(Q, k, v0))
				return (-1);
			if (op_p)
				break;
		} while (1);
	}

	/* Delete the values and key. */
	kvldskey_free(v1);
	kvldskey_free(v0);
	kvldskey_free(k);

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2100
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x5940
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x267f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x27b2
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2100
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x5940
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x26b2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x27b2
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2100
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x5940
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
jne 0x26e5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x27b2
cmpl $0x0, -0x2c(%rbp)
je 0x270f
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x2c50
cmpl $0x0, %eax
je 0x270d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x27b2
jmp 0x270f
movl -0x2c(%rbp), %eax
movl %eax, -0x4c(%rbp)
cmpl $0x64, -0x4c(%rbp)
jge 0x2752
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x2d40
cmpl $0x0, %eax
je 0x273e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x27b2
cmpl $0x0, 0x12ee3(%rip)     # 0x15628
je 0x2750
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x2715
cmpl $0x0, -0x2c(%rbp)
je 0x2790
jmp 0x275a
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x2e40
cmpl $0x0, %eax
je 0x2779
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x27b2
cmpl $0x0, 0x12ea8(%rip)     # 0x15628
je 0x2784
jmp 0x278e
jmp 0x2786
movb $0x1, %al
testb $0x1, %al
jne 0x275a
jmp 0x278e
jmp 0x2790
movq -0x48(%rbp), %rdi
callq 0x2040
movq -0x40(%rbp), %rdi
callq 0x2040
movq -0x38(%rbp), %rdi
callq 0x2040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/tests/mux/main.c
// Function: cas
static int
cas(struct wire_requestqueue * Q,
    const struct kvldskey * key, const struct kvldskey * oval,
    const struct kvldskey * value)
{

	/* Send the request. */
	op_done = 0;
	op_count = 1;
	if (proto_kvlds_request_cas(Q, key, oval, value, callback_donep, NULL)) {
		warnp("Error sending CAS request");
		goto err0;
	}

	/* Wait for it to finish. */
	if (events_spin(&op_done) || op_failed) {
		warnp("CAS request failed");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, 0x128ca(%rip)     # 0x1562c
movq $0x1, 0x128c3(%rip) # 0x15630
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x1fc(%rip), %r8        # 0x2f80
xorl %eax, %eax
movl %eax, %r9d
callq 0x6040
cmpl $0x0, %eax
je 0x2dcc
jmp 0x2d95
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2dba
leaq 0xc2fd(%rip), %rdi      # 0xf0a3
movb $0x0, %al
callq 0x54b0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2dc8
leaq 0xc2e2(%rip), %rdi      # 0xf0a3
movb $0x0, %al
callq 0x5700
jmp 0x2dca
jmp 0x2e28
leaq 0x12859(%rip), %rdi     # 0x1562c
callq 0x34f0
cmpl $0x0, %eax
jne 0x2de6
cmpl $0x0, 0x12854(%rip)     # 0x15638
je 0x2e1f
jmp 0x2de8
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2e0d
leaq 0xc2c4(%rip), %rdi      # 0xf0bd
movb $0x0, %al
callq 0x54b0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2e1b
leaq 0xc2a9(%rip), %rdi      # 0xf0bd
movb $0x0, %al
callq 0x5700
jmp 0x2e1d
jmp 0x2e28
movl $0x0, -0x4(%rbp)
jmp 0x2e2f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/tests/mux/main.c
// Function: cad
static int
cad(struct wire_requestqueue * Q,
    const struct kvldskey * key, const struct kvldskey * oval)
{

	/* Send the request. */
	op_done = 0;
	op_count = 1;
	if (proto_kvlds_request_cad(Q, key, oval, callback_donep, NULL)) {
		warnp("Error sending CAD request");
		goto err0;
	}

	/* Wait for it to finish. */
	if (events_spin(&op_done) || op_failed) {
		warnp("CAD request failed");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, 0x127ce(%rip)     # 0x1562c
movq $0x1, 0x127c7(%rip) # 0x15630
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x104(%rip), %rcx       # 0x2f80
xorl %eax, %eax
movl %eax, %r8d
callq 0x6770
cmpl $0x0, %eax
je 0x2ec4
jmp 0x2e8d
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2eb2
leaq 0xc232(%rip), %rdi      # 0xf0d0
movb $0x0, %al
callq 0x54b0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2ec0
leaq 0xc217(%rip), %rdi      # 0xf0d0
movb $0x0, %al
callq 0x5700
jmp 0x2ec2
jmp 0x2f20
leaq 0x12761(%rip), %rdi     # 0x1562c
callq 0x34f0
cmpl $0x0, %eax
jne 0x2ede
cmpl $0x0, 0x1275c(%rip)     # 0x15638
je 0x2f17
jmp 0x2ee0
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2f05
leaq 0xc1f9(%rip), %rdi      # 0xf0ea
movb $0x0, %al
callq 0x54b0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2f13
leaq 0xc1de(%rip), %rdi      # 0xf0ea
movb $0x0, %al
callq 0x5700
jmp 0x2f15
jmp 0x2f20
movl $0x0, -0x4(%rbp)
jmp 0x2f27
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OfficialRepo[P]PokiLib/encrypt.c
// Function: sub_9E9D8
void sub_9E9D8(unsigned char *input, unsigned char*output)
{
	_DWORD temp[0x32C / 4];
	_DWORD temp2[0x100 / 4];
	memcpy(temp2, input, 0x100);
	sub_87568((unsigned char*)temp, (unsigned char*)temp2);
	sub_8930C((unsigned char*)temp);
	sub_8B2F4((unsigned char*)temp);
	sub_8D114((unsigned char*)temp);
	sub_8F0B0((unsigned char*)temp);
	sub_910A8((unsigned char*)temp);
	sub_92E08((unsigned char*)temp);
	sub_94BDC((unsigned char*)temp);
	sub_96984((unsigned char*)temp);
	sub_985E0((unsigned char*)temp);
	sub_9A490((unsigned char*)temp);
	sub_9C42C((unsigned char*)temp);
	sub_9E1C4((unsigned char*)temp, (unsigned char*)temp2);
	memcpy(output, temp2, 0x100);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x440(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10d0
leaq -0x340(%rbp), %rdi
leaq -0x440(%rbp), %rsi
callq 0x1110
leaq -0x340(%rbp), %rdi
callq 0x10e0
leaq -0x340(%rbp), %rdi
callq 0x1040
leaq -0x340(%rbp), %rdi
callq 0x10f0
leaq -0x340(%rbp), %rdi
callq 0x10c0
leaq -0x340(%rbp), %rdi
callq 0x1090
leaq -0x340(%rbp), %rdi
callq 0x1050
leaq -0x340(%rbp), %rdi
callq 0x1070
leaq -0x340(%rbp), %rdi
callq 0x1100
leaq -0x340(%rbp), %rdi
callq 0x1060
leaq -0x340(%rbp), %rdi
callq 0x1030
leaq -0x340(%rbp), %rdi
callq 0x10b0
leaq -0x340(%rbp), %rdi
leaq -0x440(%rbp), %rsi
callq 0x1120
movq -0x10(%rbp), %rdi
leaq -0x440(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10d0
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/poll1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkstemp(tmpfile);

	assert(fd >= 0);
	unlink(tmpfile);

	while (1) {
		struct pollfd pfd[1];

		memset(&pfd, 0, sizeof(pfd));
		pfd[0].fd = fd;
		pfd[0].events = POLLOUT;

		assert(poll(pfd, 1, 0) >= 0);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x12a9(%rip), %rax      # 0x32d0
movq %rax, -0x30(%rbp)
movq 0x12a6(%rip), %rax      # 0x32d8
movq %rax, -0x28(%rbp)
movq 0x12a3(%rip), %rax      # 0x32e0
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x11d0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x2055
jmp 0x2074
leaq 0x1209(%rip), %rdi      # 0x3265
leaq 0x120a(%rip), %rsi      # 0x326d
movl $0xe, %edx
leaq 0x120c(%rip), %rcx      # 0x327b
callq 0x1120
leaq -0x30(%rbp), %rdi
callq 0x1080
leaq -0x3c(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x1130
movl -0x34(%rbp), %eax
movl %eax, -0x3c(%rbp)
movw $0x4, -0x38(%rbp)
leaq -0x3c(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x11e0
cmpl $0x0, %eax
jl 0x20b0
jmp 0x20cf
leaq 0x11f7(%rip), %rdi      # 0x32ae
leaq 0x11af(%rip), %rsi      # 0x326d
movl $0x18, %edx
leaq 0x11b1(%rip), %rcx      # 0x327b
callq 0x1120
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x207d
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/shell.c
// Function: isempty
int isempty()
{

	if (top == -1)
	{
		suspendedJobs = 0;
		return 1;
	}
	else
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0x1, 0x6c19(%rip)     # 0x9304
jne 0x2700
movl $0x0, 0x6c2d(%rip)      # 0x9324
movl $0x1, -0x4(%rbp)
jmp 0x2707
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/shell.c
// Function: contains
int contains(int x)
{
	if (isempty())
		return -1;
	for (size_t i = 0; i < top; i++)
	{
		if (stack[i] == x)
			return i;
	}
	return -1;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
callq 0x26e0
cmpl $0x0, %eax
je 0x27be
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2809
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movslq 0x6b33(%rip), %rcx      # 0x9304
cmpq %rcx, %rax
jae 0x2802
movq -0x10(%rbp), %rcx
leaq 0x6b4f(%rip), %rax      # 0x9330
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jne 0x27f2
movq -0x10(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x2809
jmp 0x27f4
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x27c6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/shell.c
// Function: pop
int pop()
{
	int data;

	if (isempty() == 0)
	{
		data = stack[top];
		top = top - 1;
		return data;
	}
	else
	{
		printf("Could not retrieve process, Stack is empty.\n");
		return -127;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x26e0
cmpl $0x0, %eax
jne 0x285d
movslq 0x6acb(%rip), %rcx      # 0x9304
leaq 0x6af0(%rip), %rax      # 0x9330
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
movl 0x6ab8(%rip), %eax      # 0x9304
subl $0x1, %eax
movl %eax, 0x6aaf(%rip)      # 0x9304
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2872
leaq 0x37a4(%rip), %rdi      # 0x6008
movb $0x0, %al
callq 0x2170
movl $0xffffff81, -0x4(%rbp) # imm = 0xFFFFFF81
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/shell.c
// Function: push
int push(int data)
{

	if (isfull() == 0)
	{
		top = top + 1;
		stack[top] = data;
		return 0;
	}
	else
	{
		printf("Could not insert job, Stack is full.\n");
		return -128;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
callq 0x2770
cmpl $0x0, %eax
jne 0x28c1
movl 0x6a69(%rip), %eax      # 0x9304
addl $0x1, %eax
movl %eax, 0x6a60(%rip)      # 0x9304
movl -0x8(%rbp), %edx
movslq 0x6a56(%rip), %rcx      # 0x9304
leaq 0x6a7b(%rip), %rax      # 0x9330
movl %edx, (%rax,%rcx,4)
movl $0x0, -0x4(%rbp)
jmp 0x28d6
leaq 0x376d(%rip), %rdi      # 0x6035
movb $0x0, %al
callq 0x2170
movl $0xffffff80, -0x4(%rbp) # imm = 0xFFFFFF80
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop