LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/serial.h
// Function: serial::IOException::IOException(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
explicit IOException (std::string file, int line, int errnum)
    : file_(file), line_(line), errno_(errnum) {
      std::stringstream ss;
#if defined(_WIN32) && !defined(__MINGW32__)
      char error_str [1024];
      strerror_s(error_str, 1024, errnum);
#else
      char * error_str = strerror(errnum);
#endif
      ss << "IO Exception (" << errno_ << "): " << error_str;
      ss << ", file " << file_ << ", line " << line_ << ".";
      e_what_ = ss.str();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rsi, -0x1e8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x187e0
movq -0x1f0(%rbp), %rdi
movq -0x1e8(%rbp), %rsi
leaq 0x1d91b(%rip), %rax     # 0x35d20
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x1e0(%rbp)
callq 0xd190
jmp 0x1841a
movq -0x1f0(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, 0x28(%rdi)
addq $0x30, %rdi
movq %rdi, -0x1f8(%rbp)
callq 0xd5b0
movq -0x1f0(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, 0x50(%rax)
leaq -0x1b0(%rbp), %rdi
callq 0xd2a0
jmp 0x18452
movl -0x18(%rbp), %edi
callq 0xd100
movq %rax, -0x1b8(%rbp)
leaq -0x1a0(%rbp), %rdi
leaq 0x152de(%rip), %rsi     # 0x2d74d
callq 0xd3a0
movq %rax, -0x200(%rbp)
jmp 0x1847d
movq -0x200(%rbp), %rdi
movq -0x1f0(%rbp), %rax
movl 0x50(%rax), %esi
callq 0xd740
movq %rax, -0x208(%rbp)
jmp 0x1849c
movq -0x208(%rbp), %rdi
leaq 0x15147(%rip), %rsi     # 0x2d5f1
callq 0xd3a0
movq %rax, -0x210(%rbp)
jmp 0x184b8
movq -0x210(%rbp), %rdi
movq -0x1b8(%rbp), %rsi
callq 0xd3a0
jmp 0x184cd
leaq -0x1a0(%rbp), %rdi
leaq 0x15262(%rip), %rsi     # 0x2d73d
callq 0xd3a0
movq %rax, -0x218(%rbp)
jmp 0x184e9
movq -0x218(%rbp), %rdi
movq -0x1f0(%rbp), %rsi
addq $0x8, %rsi
callq 0xd360
movq %rax, -0x220(%rbp)
jmp 0x18509
movq -0x220(%rbp), %rdi
leaq 0x1522e(%rip), %rsi     # 0x2d745
callq 0xd3a0
movq %rax, -0x228(%rbp)
jmp 0x18525
movq -0x228(%rbp), %rdi
movq -0x1f0(%rbp), %rax
movl 0x28(%rax), %esi
callq 0xd740
movq %rax, -0x230(%rbp)
jmp 0x18544
movq -0x230(%rbp), %rdi
leaq 0x151da(%rip), %rsi     # 0x2d72c
callq 0xd3a0
jmp 0x18559
leaq -0x1d8(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0xd390
jmp 0x1856e
movq -0x1f0(%rbp), %rdi
addq $0x30, %rdi
leaq -0x1d8(%rbp), %rsi
callq 0xd4f0
leaq -0x1d8(%rbp), %rdi
callq 0xd240
leaq -0x1b0(%rbp), %rdi
callq 0xd2e0
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x185f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x185da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0xd2e0
movq -0x1f8(%rbp), %rdi
callq 0xd240
movq -0x1e0(%rbp), %rdi
callq 0xd240
movq -0x1f0(%rbp), %rdi
callq 0xd7c0
movq -0x20(%rbp), %rdi
callq 0xd750
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/src/main.cpp
// Function: loadFromPath(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>>*)
static inline bool loadFromPath(const std::string& path, std::string* into) {
    std::ifstream file;
    std::string buffer;

    file.open(path.c_str());
    if(!file.is_open()) return false;
    while(!file.eof()) {
        getline(file, buffer);
        (*into) += buffer + "\n";
    }

    file.close();
    return true;
}

// Assembly:
subq $0x288, %rsp            # imm = 0x288
movq %rdi, 0x278(%rsp)
movq %rsi, 0x270(%rsp)
leaq 0x68(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xd4b0
leaq 0x48(%rsp), %rdi
callq 0xd5b0
movq 0x278(%rsp), %rdi
callq 0xd170
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0xd260
jmp 0x19d31
leaq 0x68(%rsp), %rdi
callq 0xd6b0
movb %al, 0xf(%rsp)
jmp 0x19d41
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x19d73
jmp 0x19d4b
movb $0x0, 0x287(%rsp)
movl $0x1, 0x38(%rsp)
jmp 0x19e19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x19e3e
jmp 0x19d75
movq 0x68(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x68(%rsp,%rax), %rdi
callq 0xd7b0
movb %al, 0xe(%rsp)
jmp 0x19d8e
movb 0xe(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x19d9a
jmp 0x19dfd
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xd0a0
jmp 0x19dab
leaq 0x1460a(%rip), %rdx     # 0x2e3bc
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xf8f0
jmp 0x19dc3
movq 0x270(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xd530
jmp 0x19dd7
leaq 0x18(%rsp), %rdi
callq 0xd240
jmp 0x19d75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xd240
jmp 0x19e3e
leaq 0x68(%rsp), %rdi
callq 0xd0c0
jmp 0x19e09
movb $0x1, 0x287(%rsp)
movl $0x1, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xd240
leaq 0x68(%rsp), %rdi
callq 0xd0d0
movb 0x287(%rsp), %al
andb $0x1, %al
addq $0x288, %rsp            # imm = 0x288
retq
leaq 0x48(%rsp), %rdi
callq 0xd240
leaq 0x68(%rsp), %rdi
callq 0xd0d0
movq 0x40(%rsp), %rdi
callq 0xd750
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__load_flip(stbi__context*, int*, int*, int*, int)
static unsigned char *stbi__load_flip(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
   unsigned char *result = stbi__load_main(s, x, y, comp, req_comp);

   if (stbi__vertically_flip_on_load && result != NULL) {
      int w = *x, h = *y;
      int depth = req_comp ? req_comp : *comp;
      int row,col,z;
      stbi_uc temp;

      // @OPTIMIZE: use a bigger temp buffer and memcpy multiple pixels at once
      for (row = 0; row < (h>>1); row++) {
         for (col = 0; col < w; col++) {
            for (z = 0; z < depth; z++) {
               temp = result[(row * w + col) * depth + z];
               result[(row * w + col) * depth + z] = result[((h - row - 1) * w + col) * depth + z];
               result[((h - row - 1) * w + col) * depth + z] = temp;
            }
         }
      }
   }

   return result;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movl 0x34(%rsp), %r8d
callq 0x1c770
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x1c4c9(%rip)     # 0x367b0
je 0x1a449
cmpq $0x0, 0x28(%rsp)
je 0x1a449
movq 0x48(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x40(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x20(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x1a320
movl 0x34(%rsp), %eax
movl %eax, 0x8(%rsp)
jmp 0x1a32b
movq 0x38(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl 0x20(%rsp), %ecx
sarl %ecx
cmpl %ecx, %eax
jge 0x1a447
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x1a435
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x1a423
movq 0x28(%rsp), %rax
movl 0x18(%rsp), %ecx
imull 0x24(%rsp), %ecx
addl 0x14(%rsp), %ecx
imull 0x1c(%rsp), %ecx
addl 0x10(%rsp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, 0xf(%rsp)
movq 0x28(%rsp), %rax
movl 0x20(%rsp), %ecx
subl 0x18(%rsp), %ecx
subl $0x1, %ecx
imull 0x24(%rsp), %ecx
addl 0x14(%rsp), %ecx
imull 0x1c(%rsp), %ecx
addl 0x10(%rsp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq 0x28(%rsp), %rax
movl 0x18(%rsp), %ecx
imull 0x24(%rsp), %ecx
addl 0x14(%rsp), %ecx
imull 0x1c(%rsp), %ecx
addl 0x10(%rsp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb 0xf(%rsp), %dl
movq 0x28(%rsp), %rax
movl 0x20(%rsp), %ecx
subl 0x18(%rsp), %ecx
subl $0x1, %ecx
imull 0x24(%rsp), %ecx
addl 0x14(%rsp), %ecx
imull 0x1c(%rsp), %ecx
addl 0x10(%rsp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1a36b
jmp 0x1a425
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1a355
jmp 0x1a437
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x1a33b
jmp 0x1a449
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__start_mem(stbi__context*, unsigned char const*, int)
static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)
{
   s->io.read = NULL;
   s->read_from_callbacks = 0;
   s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer;
   s->img_buffer_end = (stbi_uc *) buffer+len;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x30(%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0xc8(%rax)
movq -0x8(%rsp), %rax
movq %rcx, 0xb8(%rax)
movq -0x10(%rsp), %rcx
movslq -0x14(%rsp), %rax
addq %rax, %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0xc0(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__start_callbacks(stbi__context*, stbi_io_callbacks*, void*)
static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)
{
   s->io = *c;
   s->io_user_data = user;
   s->buflen = sizeof(s->buffer_start);
   s->read_from_callbacks = 1;
   s->img_buffer_original = s->buffer_start;
   stbi__refill_buffer(s);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rax
movl $0x80, 0x34(%rax)
movq 0x10(%rsp), %rax
movl $0x1, 0x30(%rax)
movq 0x10(%rsp), %rcx
addq $0x38, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0xc8(%rax)
movq 0x10(%rsp), %rdi
callq 0x215c0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/src/thermalPrinter.cpp
// Function: ThermalPrinter::setControlParameter(unsigned char, unsigned char, unsigned char)
void ThermalPrinter::setControlParameter(uint8_t maxHeatingDots, uint8_t heatingTime, uint8_t heatingInterval) {
    write(27,55);
    write(maxHeatingDots);
    write(heatingTime);
    write(heatingInterval);
}

// Assembly:
subq $0x18, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, 0x10(%rsp)
movb %dl, 0xf(%rsp)
movb %cl, 0xe(%rsp)
movb %al, 0xd(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movb $0x1b, 0xc(%rsp)
movb $0x37, 0xb(%rsp)
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
callq 0x1b810
movq (%rsp), %rdi
leaq 0xf(%rsp), %rsi
callq 0x1b860
movq (%rsp), %rdi
leaq 0xe(%rsp), %rsi
callq 0x1b860
movq (%rsp), %rdi
leaq 0xd(%rsp), %rsi
callq 0x1b860
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/src/thermalPrinter.cpp
// Function: ThermalPrinter::print(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ThermalPrinter::print(const std::string& _text){
    if (bConnected) 
    {
        // Characters perline
        uint nCharByLine = 32;

        uint index = 0;
        while (index+nCharByLine < _text.size()){
            std::string rta = _text.substr(index,nCharByLine);
            port->write(rta);
            usleep(BYTE_TIME*_text.size());
            index += nCharByLine;
        }

        uint rest = _text.size() % nCharByLine;
        std::string remainer = _text.substr(index,rest);
        // for(uint i = 0; i < nCharByLine-rest; i++){
        //     remainer += " ";
        // }
        port->write(remainer);
        usleep(BYTE_TIME*_text.size());
    }
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x10(%rax)
je 0x1c092
movl $0x20, 0x74(%rsp)
movl $0x0, 0x70(%rsp)
movl 0x70(%rsp), %eax
addl 0x74(%rsp), %eax
movl %eax, %eax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rdi
callq 0xd290
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x1c009
movq 0x78(%rsp), %rsi
movl 0x70(%rsp), %eax
movl %eax, %edx
movl 0x74(%rsp), %eax
movl %eax, %ecx
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xd3e0
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rsi
movq 0x8(%rax), %rdi
callq 0x121c0
jmp 0x1bfba
movq 0x78(%rsp), %rdi
callq 0xd290
imull $0x23c, %eax, %edi      # imm = 0x23C
callq 0xd5f0
jmp 0x1bfd1
movl 0x74(%rsp), %eax
addl 0x70(%rsp), %eax
movl %eax, 0x70(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xd240
jmp 0x1bf5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xd240
jmp 0x1c09a
movq 0x78(%rsp), %rdi
callq 0xd290
movl 0x74(%rsp), %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0x40(%rsp)
movq 0x78(%rsp), %rsi
movl 0x70(%rsp), %eax
movl %eax, %edx
movl 0x40(%rsp), %eax
movl %eax, %ecx
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xd3e0
movq 0x18(%rsp), %rax
movq (%rsp), %rsi
movq 0x8(%rax), %rdi
callq 0x121c0
jmp 0x1c055
movq 0x78(%rsp), %rdi
callq 0xd290
imull $0x23c, %eax, %edi      # imm = 0x23C
callq 0xd5f0
jmp 0x1c06c
leaq 0x20(%rsp), %rdi
callq 0xd240
jmp 0x1c092
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd240
jmp 0x1c09a
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xd750
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/src/thermalPrinter.cpp
// Function: ThermalPrinter::printBar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, BarcodeType)
void ThermalPrinter::printBar(const std::string &data, BarcodeType type) {
    if(bConnected){
        write(29, 107, type);
        port->write(data);
        usleep(BYTE_TIME*data.size());
        write(0);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x10(%rax)
je 0x1c13c
movq 0x8(%rsp), %rdi
movb $0x1d, 0x13(%rsp)
movb $0x6b, 0x12(%rsp)
movl 0x14(%rsp), %eax
movb %al, 0x11(%rsp)
leaq 0x13(%rsp), %rsi
leaq 0x12(%rsp), %rdx
leaq 0x11(%rsp), %rcx
callq 0x1b8f0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x121c0
movq 0x18(%rsp), %rdi
callq 0xd290
imulq $0x23c, %rax, %rax      # imm = 0x23C
movl %eax, %edi
callq 0xd5f0
movq 0x8(%rsp), %rdi
movb $0x0, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x1b860
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/src/thermalPrinter.cpp
// Function: ThermalPrinter::writeBytesRow(unsigned char const*, int)
void ThermalPrinter::writeBytesRow(const uint8_t *_array, int _width) {
    if(bConnected){
        if(_width>48)
            _width = 48;
        
        const uint8_t command[4] = {18, 42, 1, (uint8_t)_width};
        port->write(command, 4);
        usleep(BYTE_TIME*4);
        
        port->write(_array,_width);
        usleep(BYTE_TIME*_width);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x10(%rax)
je 0x1c695
cmpl $0x30, 0x14(%rsp)
jle 0x1c631
movl $0x30, 0x14(%rsp)
movq 0x8(%rsp), %rax
movb $0x12, 0x10(%rsp)
movb $0x2a, 0x11(%rsp)
movb $0x1, 0x12(%rsp)
movl 0x14(%rsp), %ecx
movb %cl, 0x13(%rsp)
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
movl $0x4, %edx
callq 0x12310
movl $0x8f0, %edi            # imm = 0x8F0
callq 0xd5f0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
movslq 0x14(%rsp), %rdx
callq 0x12310
movslq 0x14(%rsp), %rax
imulq $0x23c, %rax, %rax      # imm = 0x23C
movl %eax, %edi
callq 0xd5f0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__jpeg_test(stbi__context*)
static int stbi__jpeg_test(stbi__context *s)
{
   int r;
   stbi__jpeg j;
   j.s = s;
   stbi__setup_jpeg(&j);
   r = stbi__decode_jpeg_header(&j, STBI__SCAN_type);
   stbi__rewind(s);
   return r;
}

// Assembly:
subq $0x4798, %rsp           # imm = 0x4798
movq %rdi, 0x4790(%rsp)
movq 0x4790(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x1f900
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x1f940
movl %eax, 0x478c(%rsp)
movq 0x4790(%rsp), %rdi
callq 0x1fab0
movl 0x478c(%rsp), %eax
addq $0x4798, %rsp           # imm = 0x4798
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__gif_load(stbi__context*, int*, int*, int*, int)
static stbi_uc *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
   stbi_uc *u = 0;
   stbi__gif g;
   memset(&g, 0, sizeof(g));

   u = stbi__gif_load_next(s, &g, comp, req_comp);
   if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
   if (u) {
      *x = g.w;
      *y = g.h;
   }

   return u;
}

// Assembly:
subq $0x4888, %rsp           # imm = 0x4888
movq %rdi, 0x4880(%rsp)
movq %rsi, 0x4878(%rsp)
movq %rdx, 0x4870(%rsp)
movq %rcx, 0x4868(%rsp)
movl %r8d, 0x4864(%rsp)
movq $0x0, 0x4858(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x4858, %edx           # imm = 0x4858
callq 0xd200
movq 0x4880(%rsp), %rdi
movq 0x4868(%rsp), %rdx
movl 0x4864(%rsp), %ecx
movq %rsp, %rsi
callq 0x28c30
movq %rax, 0x4858(%rsp)
movq 0x4858(%rsp), %rax
cmpq 0x4880(%rsp), %rax
jne 0x1de2f
movq $0x0, 0x4858(%rsp)
cmpq $0x0, 0x4858(%rsp)
je 0x1de55
movl (%rsp), %ecx
movq 0x4878(%rsp), %rax
movl %ecx, (%rax)
movl 0x4(%rsp), %ecx
movq 0x4870(%rsp), %rax
movl %ecx, (%rax)
movq 0x4858(%rsp), %rax
addq $0x4888, %rsp           # imm = 0x4888
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__pic_load(stbi__context*, int*, int*, int*, int)
static stbi_uc *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp)
{
   stbi_uc *result;
   int i, x,y;

   for (i=0; i<92; ++i)
      stbi__get8(s);

   x = stbi__get16be(s);
   y = stbi__get16be(s);
   if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (pic header)");
   if ((1 << 28) / x < y) return stbi__errpuc("too large", "Image too large to decode");

   stbi__get32be(s); //skip `ratio'
   stbi__get16be(s); //skip `fields'
   stbi__get16be(s); //skip `pad'

   // intermediate buffer is RGBA
   result = (stbi_uc *) stbi__malloc(x*y*4);
   memset(result, 0xff, x*y*4);

   if (!stbi__pic_load_core(s,x,y,comp, result)) {
      STBI_FREE(result);
      result=0;
   }
   *px = x;
   *py = y;
   if (req_comp == 0) req_comp = *comp;
   result=stbi__convert_format(result,4,req_comp,x,y);

   return result;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x5c, 0xc(%rsp)
jge 0x1e483
movq 0x38(%rsp), %rdi
callq 0x21530
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1e465
movq 0x38(%rsp), %rdi
callq 0x21680
movl %eax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x21680
movl %eax, 0x4(%rsp)
movq 0x38(%rsp), %rdi
callq 0x20b60
cmpl $0x0, %eax
je 0x1e4cf
leaq 0xfc9e(%rip), %rdi      # 0x2e153
callq 0x1a190
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, 0x40(%rsp)
jmp 0x1e5dd
movl $0x10000000, %eax       # imm = 0x10000000
cltd
idivl 0x8(%rsp)
cmpl 0x4(%rsp), %eax
jge 0x1e500
leaq 0xf653(%rip), %rdi      # 0x2db39
callq 0x1a190
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, 0x40(%rsp)
jmp 0x1e5dd
movq 0x38(%rsp), %rdi
callq 0x261d0
movq 0x38(%rsp), %rdi
callq 0x21680
movq 0x38(%rsp), %rdi
callq 0x21680
movl 0x8(%rsp), %eax
imull 0x4(%rsp), %eax
shll $0x2, %eax
movslq %eax, %rdi
callq 0x1ac80
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %eax
imull 0x4(%rsp), %eax
shll $0x2, %eax
movslq %eax, %rdx
movl $0xff, %esi
callq 0xd200
movq 0x38(%rsp), %rdi
movl 0x8(%rsp), %esi
movl 0x4(%rsp), %edx
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x29c40
cmpq $0x0, %rax
jne 0x1e58a
movq 0x10(%rsp), %rdi
callq 0xd4e0
movq $0x0, 0x10(%rsp)
movl 0x8(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, (%rax)
movl 0x4(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
cmpl $0x0, 0x1c(%rsp)
jne 0x1e5b2
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl 0x8(%rsp), %ecx
movl 0x4(%rsp), %r8d
movl $0x4, %esi
callq 0x25b30
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__pnm_load(stbi__context*, int*, int*, int*, int)
static stbi_uc *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
   stbi_uc *out;
   if (!stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n))
      return 0;
   *x = s->img_x;
   *y = s->img_y;
   *comp = s->img_n;

   out = (stbi_uc *) stbi__malloc(s->img_n * s->img_x * s->img_y);
   if (!out) return stbi__errpuc("outofmem", "Out of memory");
   stbi__getn(s, out, s->img_n * s->img_x * s->img_y);

   if (req_comp && req_comp != s->img_n) {
      out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
      if (out == NULL) return out; // stbi__convert_format frees input on failure
   }
   return out;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq $0x4, %rdx
movq 0x28(%rsp), %rcx
addq $0x8, %rcx
callq 0x2a350
cmpl $0x0, %eax
jne 0x1e6b1
movq $0x0, 0x30(%rsp)
jmp 0x1e7ad
movq 0x28(%rsp), %rax
movl (%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rax
movl 0x4(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x28(%rsp), %rcx
imull (%rcx), %eax
movq 0x28(%rsp), %rcx
imull 0x4(%rcx), %eax
movl %eax, %eax
movl %eax, %edi
callq 0x1ac80
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1e72b
leaq 0xf432(%rip), %rdi      # 0x2db43
callq 0x1a190
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, 0x30(%rsp)
jmp 0x1e7ad
movq 0x28(%rsp), %rdi
movq (%rsp), %rsi
movq 0x28(%rsp), %rax
movl 0x8(%rax), %edx
movq 0x28(%rsp), %rax
imull (%rax), %edx
movq 0x28(%rsp), %rax
imull 0x4(%rax), %edx
callq 0x26210
cmpl $0x0, 0xc(%rsp)
je 0x1e7a4
movl 0xc(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x8(%rcx), %eax
je 0x1e7a4
movq (%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x8(%rax), %esi
movl 0xc(%rsp), %edx
movq 0x28(%rsp), %rax
movl (%rax), %ecx
movq 0x28(%rsp), %rax
movl 0x4(%rax), %r8d
callq 0x25b30
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1e7a2
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1e7ad
jmp 0x1e7a4
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__tga_test(stbi__context*)
static int stbi__tga_test(stbi__context *s)
{
   int res;
   int sz;
   stbi__get8(s);      //   discard Offset
   sz = stbi__get8(s);   //   color type
   if ( sz > 1 ) return 0;   //   only RGB or indexed allowed
   sz = stbi__get8(s);   //   image type
   if ( (sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11) ) return 0;   //   only RGB or grey allowed, +/- RLE
   stbi__get16be(s);      //   discard palette start
   stbi__get16be(s);      //   discard palette length
   stbi__get8(s);         //   discard bits per palette color entry
   stbi__get16be(s);      //   discard x origin
   stbi__get16be(s);      //   discard y origin
   if ( stbi__get16be(s) < 1 ) return 0;      //   test width
   if ( stbi__get16be(s) < 1 ) return 0;      //   test height
   sz = stbi__get8(s);   //   bits per pixel
   if ( (sz != 8) && (sz != 16) && (sz != 24) && (sz != 32) )
      res = 0;
   else
      res = 1;
   stbi__rewind(s);
   return res;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x21530
movq 0x8(%rsp), %rdi
callq 0x21530
movzbl %al, %eax
movl %eax, (%rsp)
cmpl $0x1, (%rsp)
jle 0x1f046
movl $0x0, 0x14(%rsp)
jmp 0x1f137
movq 0x8(%rsp), %rdi
callq 0x21530
movzbl %al, %eax
movl %eax, (%rsp)
cmpl $0x1, (%rsp)
je 0x1f087
cmpl $0x2, (%rsp)
je 0x1f087
cmpl $0x3, (%rsp)
je 0x1f087
cmpl $0x9, (%rsp)
je 0x1f087
cmpl $0xa, (%rsp)
je 0x1f087
cmpl $0xb, (%rsp)
je 0x1f087
movl $0x0, 0x14(%rsp)
jmp 0x1f137
movq 0x8(%rsp), %rdi
callq 0x21680
movq 0x8(%rsp), %rdi
callq 0x21680
movq 0x8(%rsp), %rdi
callq 0x21530
movq 0x8(%rsp), %rdi
callq 0x21680
movq 0x8(%rsp), %rdi
callq 0x21680
movq 0x8(%rsp), %rdi
callq 0x21680
cmpl $0x1, %eax
jge 0x1f0d2
movl $0x0, 0x14(%rsp)
jmp 0x1f137
movq 0x8(%rsp), %rdi
callq 0x21680
cmpl $0x1, %eax
jge 0x1f0eb
movl $0x0, 0x14(%rsp)
jmp 0x1f137
movq 0x8(%rsp), %rdi
callq 0x21530
movzbl %al, %eax
movl %eax, (%rsp)
cmpl $0x8, (%rsp)
je 0x1f11d
cmpl $0x10, (%rsp)
je 0x1f11d
cmpl $0x18, (%rsp)
je 0x1f11d
cmpl $0x20, (%rsp)
je 0x1f11d
movl $0x0, 0x4(%rsp)
jmp 0x1f125
movl $0x1, 0x4(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1fab0
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__decode_jpeg_header(stbi__jpeg*, int)
static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
{
   int m;
   z->marker = STBI__MARKER_none; // initialize cached marker to empty
   m = stbi__get_marker(z);
   if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG");
   if (scan == STBI__SCAN_type) return 1;
   m = stbi__get_marker(z);
   while (!stbi__SOF(m)) {
      if (!stbi__process_marker(z,m)) return 0;
      m = stbi__get_marker(z);
      while (m == STBI__MARKER_none) {
         // some files have extra padding after their blocks, so ok, we'll scan
         if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG");
         m = stbi__get_marker(z);
      }
   }
   z->progressive = stbi__SOF_progressive(m);
   if (!stbi__process_frame_header(z, scan)) return 0;
   return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movb $-0x1, 0x4728(%rax)
movq 0x18(%rsp), %rdi
callq 0x205f0
movzbl %al, %eax
movl %eax, 0x10(%rsp)
cmpl $0xd8, 0x10(%rsp)
je 0x1f989
leaq 0xe0f1(%rip), %rdi      # 0x2da6c
callq 0x1a190
movl %eax, 0x24(%rsp)
jmp 0x1faa0
cmpl $0x1, 0x14(%rsp)
jne 0x1f99d
movl $0x1, 0x24(%rsp)
jmp 0x1faa0
movq 0x18(%rsp), %rdi
callq 0x205f0
movzbl %al, %eax
movl %eax, 0x10(%rsp)
movb $0x1, %al
cmpl $0xc0, 0x10(%rsp)
movb %al, 0xf(%rsp)
je 0x1f9dd
movb $0x1, %al
cmpl $0xc1, 0x10(%rsp)
movb %al, 0xf(%rsp)
je 0x1f9dd
cmpl $0xc2, 0x10(%rsp)
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1f9e9
jmp 0x1fa60
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x20690
cmpl $0x0, %eax
jne 0x1fa09
movl $0x0, 0x24(%rsp)
jmp 0x1faa0
movq 0x18(%rsp), %rdi
callq 0x205f0
movzbl %al, %eax
movl %eax, 0x10(%rsp)
cmpl $0xff, 0x10(%rsp)
jne 0x1fa5b
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x20b60
cmpl $0x0, %eax
je 0x1fa48
leaq 0xe036(%rip), %rdi      # 0x2da73
callq 0x1a190
movl %eax, 0x24(%rsp)
jmp 0x1faa0
movq 0x18(%rsp), %rdi
callq 0x205f0
movzbl %al, %eax
movl %eax, 0x10(%rsp)
jmp 0x1fa1a
jmp 0x1f9ae
cmpl $0xc2, 0x10(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x4730(%rax)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x20be0
cmpl $0x0, %eax
jne 0x1fa98
movl $0x0, 0x24(%rsp)
jmp 0x1faa0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__cleanup_jpeg(stbi__jpeg*)
static void stbi__cleanup_jpeg(stbi__jpeg *j)
{
   int i;
   for (i=0; i < j->s->img_n; ++i) {
      if (j->img_comp[i].raw_data) {
         STBI_FREE(j->img_comp[i].raw_data);
         j->img_comp[i].raw_data = NULL;
         j->img_comp[i].data = NULL;
      }
      if (j->img_comp[i].raw_coeff) {
         STBI_FREE(j->img_comp[i].raw_coeff);
         j->img_comp[i].raw_coeff = 0;
         j->img_comp[i].coeff = 0;
      }
      if (j->img_comp[i].linebuf) {
         STBI_FREE(j->img_comp[i].linebuf);
         j->img_comp[i].linebuf = NULL;
      }
   }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0x2278d
movq 0x10(%rsp), %rax
addq $0x45a0, %rax           # imm = 0x45A0
movslq 0xc(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x38(%rax)
je 0x226a2
movq 0x10(%rsp), %rax
addq $0x45a0, %rax           # imm = 0x45A0
movslq 0xc(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq 0x38(%rax), %rdi
callq 0xd4e0
movq 0x10(%rsp), %rax
addq $0x45a0, %rax           # imm = 0x45A0
movslq 0xc(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x38(%rax)
movq 0x10(%rsp), %rax
addq $0x45a0, %rax           # imm = 0x45A0
movslq 0xc(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x30(%rax)
movq 0x10(%rsp), %rax
addq $0x45a0, %rax           # imm = 0x45A0
movslq 0xc(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x40(%rax)
je 0x2271e
movq 0x10(%rsp), %rax
addq $0x45a0, %rax           # imm = 0x45A0
movslq 0xc(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq 0x40(%rax), %rdi
callq 0xd4e0
movq 0x10(%rsp), %rax
addq $0x45a0, %rax           # imm = 0x45A0
movslq 0xc(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x40(%rax)
movq 0x10(%rsp), %rax
addq $0x45a0, %rax           # imm = 0x45A0
movslq 0xc(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x50(%rax)
movq 0x10(%rsp), %rax
addq $0x45a0, %rax           # imm = 0x45A0
movslq 0xc(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x48(%rax)
je 0x2277b
movq 0x10(%rsp), %rax
addq $0x45a0, %rax           # imm = 0x45A0
movslq 0xc(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
callq 0xd4e0
movq 0x10(%rsp), %rax
addq $0x45a0, %rax           # imm = 0x45A0
movslq 0xc(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x48(%rax)
jmp 0x2277d
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x22611
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__grow_buffer_unsafe(stbi__jpeg*)
static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
{
   do {
      int b = j->nomore ? 0 : stbi__get8(j->s);
      if (b == 0xff) {
         int c = stbi__get8(j->s);
         if (c != 0) {
            j->marker = (unsigned char) c;
            j->nomore = 1;
            return;
         }
      }
      j->code_buffer |= b << (24 - j->code_bits);
      j->code_bits += 8;
   } while (j->code_bits <= 24);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x472c(%rax)
je 0x2404f
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x24063
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x21530
movzbl %al, %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0xc(%rsp)
cmpl $0xff, 0xc(%rsp)
jne 0x240b4
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x21530
movzbl %al, %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
je 0x240b2
movl 0x8(%rsp), %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, 0x4728(%rax)
movq 0x10(%rsp), %rax
movl $0x1, 0x472c(%rax)
jmp 0x24103
jmp 0x240b4
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rdx
movl $0x18, %ecx
subl 0x4724(%rdx), %ecx
shll %cl, %eax
movl %eax, %ecx
movq 0x10(%rsp), %rax
orl 0x4720(%rax), %ecx
movl %ecx, 0x4720(%rax)
movq 0x10(%rsp), %rax
movl 0x4724(%rax), %ecx
addl $0x8, %ecx
movl %ecx, 0x4724(%rax)
movq 0x10(%rsp), %rax
cmpl $0x18, 0x4724(%rax)
jle 0x24039
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__do_png(stbi__png*, int*, int*, int*, int)
static unsigned char *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp)
{
   unsigned char *result=NULL;
   if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
   if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {
      result = p->out;
      p->out = NULL;
      if (req_comp && req_comp != p->s->img_out_n) {
         result = stbi__convert_format(result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
         p->s->img_out_n = req_comp;
         if (result == NULL) return result;
      }
      *x = p->s->img_x;
      *y = p->s->img_y;
      if (n) *n = p->s->img_out_n;
   }
   STBI_FREE(p->out);      p->out      = NULL;
   STBI_FREE(p->expanded); p->expanded = NULL;
   STBI_FREE(p->idata);    p->idata    = NULL;

   return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movq $0x0, (%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0x24db3
cmpl $0x4, 0xc(%rsp)
jle 0x24dd4
leaq 0x8d92(%rip), %rdi      # 0x2db4c
callq 0x1a190
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, 0x30(%rsp)
jmp 0x24f10
movq 0x28(%rsp), %rdi
movl 0xc(%rsp), %edx
xorl %esi, %esi
callq 0x24f20
cmpl $0x0, %eax
je 0x24eb6
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq $0x0, 0x18(%rax)
cmpl $0x0, 0xc(%rsp)
je 0x24e77
movl 0xc(%rsp), %eax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
cmpl 0xc(%rcx), %eax
je 0x24e77
movq (%rsp), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl 0xc(%rax), %esi
movl 0xc(%rsp), %edx
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl (%rax), %ecx
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl 0x4(%rax), %r8d
callq 0x25b30
movq %rax, (%rsp)
movl 0xc(%rsp), %ecx
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl %ecx, 0xc(%rax)
cmpq $0x0, (%rsp)
jne 0x24e75
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x24f10
jmp 0x24e77
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl (%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl 0x4(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x10(%rsp)
je 0x24eb4
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl 0xc(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
jmp 0x24eb6
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xd4e0
movq 0x28(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xd4e0
movq 0x28(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xd4e0
movq 0x28(%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__high_bit(unsigned int)
static int stbi__high_bit(unsigned int z)
{
   int n=0;
   if (z == 0) return -1;
   if (z >= 0x10000) n += 16, z >>= 16;
   if (z >= 0x00100) n +=  8, z >>=  8;
   if (z >= 0x00010) n +=  4, z >>=  4;
   if (z >= 0x00004) n +=  2, z >>=  2;
   if (z >= 0x00002) n +=  1, z >>=  1;
   return n;
}

// Assembly:
movl %edi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x0, -0x8(%rsp)
jne 0x289c0
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x28a5e
cmpl $0x10000, -0x8(%rsp)    # imm = 0x10000
jb 0x289e0
movl -0xc(%rsp), %eax
addl $0x10, %eax
movl %eax, -0xc(%rsp)
movl -0x8(%rsp), %eax
shrl $0x10, %eax
movl %eax, -0x8(%rsp)
cmpl $0x100, -0x8(%rsp)      # imm = 0x100
jb 0x28a00
movl -0xc(%rsp), %eax
addl $0x8, %eax
movl %eax, -0xc(%rsp)
movl -0x8(%rsp), %eax
shrl $0x8, %eax
movl %eax, -0x8(%rsp)
cmpl $0x10, -0x8(%rsp)
jb 0x28a1d
movl -0xc(%rsp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rsp)
movl -0x8(%rsp), %eax
shrl $0x4, %eax
movl %eax, -0x8(%rsp)
cmpl $0x4, -0x8(%rsp)
jb 0x28a3a
movl -0xc(%rsp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rsp)
movl -0x8(%rsp), %eax
shrl $0x2, %eax
movl %eax, -0x8(%rsp)
cmpl $0x2, -0x8(%rsp)
jb 0x28a56
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0x8(%rsp), %eax
shrl %eax
movl %eax, -0x8(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__shiftsigned(int, int, int)
static int stbi__shiftsigned(int v, int shift, int bits)
{
   int result;
   int z=0;

   if (shift < 0) v <<= -shift;
   else v >>= shift;
   result = v;

   z = bits;
   while (z < 8) {
      result += v >> z;
      z += bits;
   }
   return result;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl %edx, -0xc(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x0, -0x8(%rsp)
jge 0x28b1d
xorl %ecx, %ecx
subl -0x8(%rsp), %ecx
movl -0x4(%rsp), %eax
shll %cl, %eax
movl %eax, -0x4(%rsp)
jmp 0x28b2b
movl -0x8(%rsp), %ecx
movl -0x4(%rsp), %eax
sarl %cl, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x14(%rsp)
cmpl $0x8, -0x14(%rsp)
jge 0x28b62
movl -0x4(%rsp), %eax
movl -0x14(%rsp), %ecx
sarl %cl, %eax
addl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0xc(%rsp), %eax
addl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
jmp 0x28b3b
movl -0x10(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__fill_gif_background(stbi__gif*)
static void stbi__fill_gif_background(stbi__gif *g)
{
   int i;
   stbi_uc *c = g->pal[g->bgindex];
   // @OPTIMIZE: write a dword at a time
   for (i = 0; i < g->w * g->h * 4; i += 4) {
      stbi_uc *p  = &g->out[i];
      p[0] = c[2];
      p[1] = c[1];
      p[2] = c[0];
      p[3] = c[3];
   }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
addq $0x24, %rax
movq -0x8(%rsp), %rcx
movslq 0x14(%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
movl (%rcx), %ecx
movq -0x8(%rsp), %rdx
imull 0x4(%rdx), %ecx
shll $0x2, %ecx
cmpl %ecx, %eax
jge 0x29487
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rsp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movb 0x2(%rax), %cl
movq -0x20(%rsp), %rax
movb %cl, (%rax)
movq -0x18(%rsp), %rax
movb 0x1(%rax), %cl
movq -0x20(%rsp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rsp), %rax
movb (%rax), %cl
movq -0x20(%rsp), %rax
movb %cl, 0x2(%rax)
movq -0x18(%rsp), %rax
movb 0x3(%rax), %cl
movq -0x20(%rsp), %rax
movb %cl, 0x3(%rax)
movl -0xc(%rsp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rsp)
jmp 0x2940b
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__pnm_info(stbi__context*, int*, int*, int*)
static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
{
   int maxv;
   char c, p, t;

   stbi__rewind( s );

   // Get identifier
   p = (char) stbi__get8(s);
   t = (char) stbi__get8(s);
   if (p != 'P' || (t != '5' && t != '6')) {
       stbi__rewind( s );
       return 0;
   }

   *comp = (t == '6') ? 3 : 1;  // '5' is 1-component .pgm; '6' is 3-component .ppm

   c = (char) stbi__get8(s);
   stbi__pnm_skip_whitespace(s, &c);

   *x = stbi__pnm_getinteger(s, &c); // read width
   stbi__pnm_skip_whitespace(s, &c);

   *y = stbi__pnm_getinteger(s, &c); // read height
   stbi__pnm_skip_whitespace(s, &c);

   maxv = stbi__pnm_getinteger(s, &c);  // read max value

   if (maxv > 255)
      return stbi__err("max value > 255", "PPM image not 8-bit");
   else
      return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1fab0
movq 0x28(%rsp), %rdi
callq 0x21530
movb %al, 0xa(%rsp)
movq 0x28(%rsp), %rdi
callq 0x21530
movb %al, 0x9(%rsp)
movsbl 0xa(%rsp), %eax
cmpl $0x50, %eax
jne 0x2a3ac
movsbl 0x9(%rsp), %eax
cmpl $0x35, %eax
je 0x2a3c3
movsbl 0x9(%rsp), %eax
cmpl $0x36, %eax
je 0x2a3c3
movq 0x28(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x34(%rsp)
jmp 0x2a481
movsbl 0x9(%rsp), %edx
movl $0x1, %ecx
movl $0x3, %eax
cmpl $0x36, %edx
cmovel %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rdi
callq 0x21530
movb %al, 0xb(%rsp)
movq 0x28(%rsp), %rdi
leaq 0xb(%rsp), %rsi
callq 0x2a490
movq 0x28(%rsp), %rdi
leaq 0xb(%rsp), %rsi
callq 0x2a4f0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rdi
leaq 0xb(%rsp), %rsi
callq 0x2a490
movq 0x28(%rsp), %rdi
leaq 0xb(%rsp), %rsi
callq 0x2a4f0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rdi
leaq 0xb(%rsp), %rsi
callq 0x2a490
movq 0x28(%rsp), %rdi
leaq 0xb(%rsp), %rsi
callq 0x2a4f0
movl %eax, 0xc(%rsp)
cmpl $0xff, 0xc(%rsp)
jle 0x2a479
leaq 0x3cf9(%rip), %rdi      # 0x2e167
callq 0x1a190
movl %eax, 0x34(%rsp)
jmp 0x2a481
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__float_postprocess(float*, int*, int*, int*, int)
static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)
{
   if (stbi__vertically_flip_on_load && result != NULL) {
      int w = *x, h = *y;
      int depth = req_comp ? req_comp : *comp;
      int row,col,z;
      float temp;

      // @OPTIMIZE: use a bigger temp buffer and memcpy multiple pixels at once
      for (row = 0; row < (h>>1); row++) {
         for (col = 0; col < w; col++) {
            for (z = 0; z < depth; z++) {
               temp = result[(row * w + col) * depth + z];
               result[(row * w + col) * depth + z] = result[((h - row - 1) * w + col) * depth + z];
               result[((h - row - 1) * w + col) * depth + z] = temp;
            }
         }
      }
   }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movl %r8d, -0x24(%rsp)
cmpl $0x0, 0xbee0(%rip)      # 0x367b0
je 0x2aa3e
cmpq $0x0, -0x8(%rsp)
je 0x2aa3e
movq -0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rsp)
cmpl $0x0, -0x24(%rsp)
je 0x2a909
movl -0x24(%rsp), %eax
movl %eax, -0x44(%rsp)
jmp 0x2a914
movq -0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rsp)
movl -0x44(%rsp), %eax
movl %eax, -0x30(%rsp)
movl $0x0, -0x34(%rsp)
movl -0x34(%rsp), %eax
movl -0x2c(%rsp), %ecx
sarl %ecx
cmpl %ecx, %eax
jge 0x2aa3c
movl $0x0, -0x38(%rsp)
movl -0x38(%rsp), %eax
cmpl -0x28(%rsp), %eax
jge 0x2aa2a
movl $0x0, -0x3c(%rsp)
movl -0x3c(%rsp), %eax
cmpl -0x30(%rsp), %eax
jge 0x2aa18
movq -0x8(%rsp), %rax
movl -0x34(%rsp), %ecx
imull -0x28(%rsp), %ecx
addl -0x38(%rsp), %ecx
imull -0x30(%rsp), %ecx
addl -0x3c(%rsp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x40(%rsp)
movq -0x8(%rsp), %rax
movl -0x2c(%rsp), %ecx
subl -0x34(%rsp), %ecx
subl $0x1, %ecx
imull -0x28(%rsp), %ecx
addl -0x38(%rsp), %ecx
imull -0x30(%rsp), %ecx
addl -0x3c(%rsp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rsp), %rax
movl -0x34(%rsp), %ecx
imull -0x28(%rsp), %ecx
addl -0x38(%rsp), %ecx
imull -0x30(%rsp), %ecx
addl -0x3c(%rsp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x40(%rsp), %xmm0
movq -0x8(%rsp), %rax
movl -0x2c(%rsp), %ecx
subl -0x34(%rsp), %ecx
subl $0x1, %ecx
imull -0x28(%rsp), %ecx
addl -0x38(%rsp), %ecx
imull -0x30(%rsp), %ecx
addl -0x3c(%rsp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rsp)
jmp 0x2a954
jmp 0x2aa1a
movl -0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rsp)
jmp 0x2a93e
jmp 0x2aa2c
movl -0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rsp)
jmp 0x2a924
jmp 0x2aa3e
retq
nop
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__ldr_to_hdr(unsigned char*, int, int, int)
static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
{
   int i,k,n;
   float *output = (float *) stbi__malloc(x * y * comp * sizeof(float));
   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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl 0x24(%rsp), %eax
imull 0x20(%rsp), %eax
imull 0x1c(%rsp), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x1ac80
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2aaa7
movq 0x28(%rsp), %rdi
callq 0xd4e0
leaq 0x30b6(%rip), %rdi      # 0x2db43
callq 0x1a190
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, 0x30(%rsp)
jmp 0x2abcf
movl 0x1c(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2aabd
movl 0x1c(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x2aac8
movl 0x1c(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl 0x24(%rsp), %ecx
imull 0x20(%rsp), %ecx
cmpl %ecx, %eax
jge 0x2abbb
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x2ab5c
movq 0x28(%rsp), %rax
movl 0x18(%rsp), %ecx
imull 0x1c(%rsp), %ecx
addl 0x14(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movss 0x2d5c(%rip), %xmm1     # 0x2d878
divss %xmm1, %xmm0
movss 0xb918(%rip), %xmm1     # 0x36440
callq 0x2cbd0
mulss 0xb90f(%rip), %xmm0     # 0x36444
movq 0x8(%rsp), %rax
movl 0x18(%rsp), %ecx
imull 0x1c(%rsp), %ecx
addl 0x14(%rsp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2aaed
movl 0x14(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x2aba9
movq 0x28(%rsp), %rax
movl 0x18(%rsp), %ecx
imull 0x1c(%rsp), %ecx
addl 0x14(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movss 0x2ced(%rip), %xmm1     # 0x2d878
divss %xmm1, %xmm0
movq 0x8(%rsp), %rax
movl 0x18(%rsp), %ecx
imull 0x1c(%rsp), %ecx
addl 0x14(%rsp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0x2abab
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x2aad0
movq 0x28(%rsp), %rdi
callq 0xd4e0
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)