LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Lut99[P]RayTracer/src/RayTracer.cpp
// Function: create_default_camera(double, double, unsigned int, unsigned int, unsigned int, bool)
Camera* create_default_camera(double vfov, double aperture, unsigned int screen_width, unsigned int screen_height, unsigned int number_of_rays, bool correct_gamma) {
    Camera* cam = new Camera(Vec3(3, 2, 2), Vec3(0, 0, -1), Vec3(0, 1, 0), vfov, aperture);
    update_camera(cam, screen_width, screen_height, number_of_rays, correct_gamma);
    cam->recompute();

    return cam;
}

// Assembly:
subq $0xa8, %rsp
movb %cl, %al
movsd %xmm0, 0xa0(%rsp)
movsd %xmm1, 0x98(%rsp)
movl %edi, 0x94(%rsp)
movl %esi, 0x90(%rsp)
movl %edx, 0x8c(%rsp)
andb $0x1, %al
movb %al, 0x8b(%rsp)
movl $0x178, %edi            # imm = 0x178
callq 0xd05d0
movq %rax, 0x8(%rsp)
leaq 0x60(%rsp), %rdi
movsd 0x9bf93(%rip), %xmm0    # 0x170058
movsd 0x9bf93(%rip), %xmm2    # 0x170060
movaps %xmm2, %xmm1
callq 0x154750
jmp 0xd40d7
leaq 0x30(%rsp), %rdi
xorps %xmm1, %xmm1
movsd 0x9bf21(%rip), %xmm2    # 0x170008
movaps %xmm1, %xmm0
callq 0x154750
jmp 0xd40f1
leaq 0x10(%rsp), %rdi
movsd 0x9bf42(%rip), %xmm1    # 0x170040
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
callq 0x154750
jmp 0xd410b
movq 0x8(%rsp), %rdi
movsd 0xa0(%rsp), %xmm0
movsd 0x98(%rsp), %xmm1
leaq 0x60(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x1611a0
jmp 0xd4138
movq 0x8(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rdi
movl 0x94(%rsp), %esi
movl 0x90(%rsp), %edx
movl 0x8c(%rsp), %ecx
movb 0x8b(%rsp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0xd4020
movq 0x80(%rsp), %rdi
callq 0x160e50
movq 0x80(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x178, %esi            # imm = 0x178
callq 0xd05e0
movq 0x58(%rsp), %rdi
callq 0xd0a10
nopl (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/include/cxxopts.hpp
// Function: cxxopts::ParseResult::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const OptionValue&
    operator[](const std::string& option) const
    {
      auto iter = m_options->find(option);

      if (iter == m_options->end())
      {
        throw_or_mimic<option_not_present_exception>(option);
      }

      auto riter = m_results.find(iter->second);

      return riter->second;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe56c0
movq %rax, %rdi
movq 0x28(%rsp), %rsi
callq 0xead30
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0xe56c0
movq %rax, %rdi
callq 0xead80
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xead60
testb $0x1, %al
jne 0xd965b
jmp 0xd9665
movq 0x28(%rsp), %rdi
callq 0xeec20
movq 0x8(%rsp), %rax
addq $0x68, %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0xeae20
movq (%rsp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0xeeb30
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xeeb60
addq $0x10, %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: Lut99[P]RayTracer/src/lib/include/cxxopts.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const& cxxopts::OptionValue::as<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>() const
const T&
    as() const
    {
      if (m_value == nullptr) {
        throw_or_mimic<std::domain_error>("No value");
      }

#ifdef CXXOPTS_NO_RTTI
      return static_cast<const values::standard_value<T>&>(*m_value).get();
#else
      return dynamic_cast<const values::standard_value<T>&>(*m_value).get();
#endif
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0xebf10
testb $0x1, %al
jne 0xd96d2
jmp 0xd974f
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xd0a20
movq 0x8(%rsp), %rdx
leaq 0x988ca(%rip), %rsi     # 0x171fb7
leaq 0x30(%rsp), %rdi
callq 0xd8b80
jmp 0xd96f9
leaq 0x30(%rsp), %rdi
callq 0x120c00
jmp 0xd9705
leaq 0x30(%rsp), %rdi
callq 0xd0b38
leaq 0x2f(%rsp), %rdi
callq 0xd0630
jmp 0xd974f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0xd9743
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd0b38
leaq 0x2f(%rsp), %rdi
callq 0xd0630
jmp 0xd9790
movq 0x10(%rsp), %rdi
callq 0x120c70
movq %rax, %rdi
leaq 0xd132d(%rip), %rsi     # 0x1aaa90
leaq 0xd1366(%rip), %rdx     # 0x1aaad0
xorl %eax, %eax
movl %eax, %ecx
callq 0xd0690
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0xd9782
callq 0xd0a90
movq (%rsp), %rdi
callq 0x120ca0
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xd0a10
nopw (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/include/cxxopts.hpp
// Function: void cxxopts::values::stringstream_parser<double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double&)
void stringstream_parser(const std::string& text, T& value)
    {
      std::stringstream in(text);
      in >> value;
      if (!in) {
        throw_or_mimic<argument_incorrect_type>(text);
      }
    }

// Assembly:
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, 0x1c0(%rsp)
movq %rsi, 0x1b8(%rsp)
movq 0x1c0(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x11e9a0
movq 0x10(%rsp), %rsi
movl %eax, %edx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xd08d0
movq 0x18(%rsp), %rdi
movq 0x1b8(%rsp), %rsi
callq 0xd04c0
jmp 0x11e92d
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x30(%rsp,%rax), %rdi
callq 0xd0290
movb %al, 0xf(%rsp)
jmp 0x11e946
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x11e950
jmp 0x11e97b
movq 0x1c0(%rsp), %rdi
callq 0x115130
jmp 0x11e95f
jmp 0x11e97b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd0450
jmp 0x11e98d
leaq 0x30(%rsp), %rdi
callq 0xd0450
addq $0x1c8, %rsp            # imm = 0x1C8
retq
movq 0x28(%rsp), %rdi
callq 0xd0a10
nopw (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/include/json.hpp
// Function: nlohmann::detail::input_stream_adapter::get_character()
std::char_traits<char>::int_type get_character() override
    {
        auto res = sb.sbumpc();
        // set eof manually, as we don't use the istream interface.
        if (res == EOF)
        {
            is.clear(is.rdstate() | std::ios::eofbit);
        }
        return res;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rax), %rdi
callq 0xd02f0
movl %eax, 0x1c(%rsp)
cmpl $-0x1, 0x1c(%rsp)
jne 0x123dc4
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rcx), %rdx
addq -0x18(%rdx), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0xd0520
movl %eax, %edi
movl $0x2, %esi
callq 0x123ea0
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0xd09a0
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/Frames.cpp
// Function: RayTracer::Frames::Frames(RayTracer::Frames const&)
Frames::Frames(const Frames& other)
    : frame_index(other.frame_index),
    temp_dir(other.temp_dir),
    dynamic_writing(other.dynamic_writing),
    width(other.width),
    height(other.height),
    n_frames(other.n_frames),
    fps(other.fps)
{
    // Depending on whether we write dynamically, copy the necessary data
    if (this->dynamic_writing) {
        // Copy the current_frame, done
        this->current_frame = new Image(*other.current_frame);
    } else {
        // Copy their entire this->frames list
        this->frames = new Image*[this->n_frames];
        for (std::size_t i = 0; i <= this->frame_index; i++) {
            this->frames[i] = new Image(*other.frames[i]);
        }
        // Update the current_frame
        this->current_frame = this->frames[frame_index];
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
movq %rdi, 0x20(%rsp)
movq 0x48(%rsp), %rsi
addq $0x18, %rsi
callq 0xd0250
movq 0x28(%rsp), %rax
movq 0x48(%rsp), %rcx
movb 0x38(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x38(%rax)
movq 0x48(%rsp), %rcx
movl 0x3c(%rcx), %ecx
movl %ecx, 0x3c(%rax)
movq 0x48(%rsp), %rcx
movl 0x40(%rcx), %ecx
movl %ecx, 0x40(%rax)
movq 0x48(%rsp), %rcx
movl 0x44(%rcx), %ecx
movl %ecx, 0x44(%rax)
movq 0x48(%rsp), %rcx
movl 0x48(%rcx), %ecx
movl %ecx, 0x48(%rax)
testb $0x1, 0x38(%rax)
je 0x13a18d
movl $0x10, %edi
callq 0xd05d0
movq %rax, 0x18(%rsp)
jmp 0x13a132
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rax
movq (%rax), %rsi
callq 0x13b3c0
jmp 0x13a146
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x13a257
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x13a25c
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x10, %esi
callq 0xd05e0
jmp 0x13a25c
movq 0x28(%rsp), %rax
movl 0x44(%rax), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0xd0050
movq %rax, 0x10(%rsp)
jmp 0x13a1a7
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x30(%rsp)
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
cmpq 0x10(%rcx), %rax
ja 0x13a243
movl $0x10, %edi
callq 0xd05d0
movq %rax, 0x8(%rsp)
jmp 0x13a1df
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x13b3c0
jmp 0x13a1fd
movq 0x8(%rsp), %rdx
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x13a1be
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x10, %esi
callq 0xd05e0
jmp 0x13a25c
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, (%rax)
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xd0b38
movq 0x40(%rsp), %rdi
callq 0xd0a10
// File: Lut99[P]RayTracer/src/lib/Frames.cpp
// Function: RayTracer::Frames::Frames(RayTracer::Frames&&)
Frames::Frames(Frames&& other)
    : frame_index(other.frame_index),
    temp_dir(other.temp_dir),
    dynamic_writing(other.dynamic_writing),
    width(other.width),
    height(other.height),
    n_frames(other.n_frames),
    fps(other.fps)
{
    // Copy the correct pointers
    if (this->dynamic_writing) {
        this->current_frame = other.current_frame;
    } else {
        this->frames = other.frames;
        this->current_frame = this->frames[this->frame_index];
    }

    // Overwrite the other pointer with null
    other.frames = nullptr;
    other.current_frame = nullptr;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
callq 0xd0250
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movb 0x38(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x38(%rax)
movq 0x8(%rsp), %rcx
movl 0x3c(%rcx), %ecx
movl %ecx, 0x3c(%rax)
movq 0x8(%rsp), %rcx
movl 0x40(%rcx), %ecx
movl %ecx, 0x40(%rax)
movq 0x8(%rsp), %rcx
movl 0x44(%rcx), %ecx
movl %ecx, 0x44(%rax)
movq 0x8(%rsp), %rcx
movl 0x48(%rcx), %ecx
movl %ecx, 0x48(%rax)
testb $0x1, 0x38(%rax)
je 0x13a2fb
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
jmp 0x13a31b
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/Frames.cpp
// Function: RayTracer::Frames::~Frames()
Frames::~Frames() {
    // Deallocate either everything or only the current frame
    if (!this->dynamic_writing) {
        for (std::size_t i = 0; i <= this->frame_index; i++) {
            delete this->frames[i];
        }
        // Delete the list as well
        delete[] this->frames;
    } else {
        delete this->current_frame;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
testb $0x1, 0x38(%rax)
jne 0x13a3de
movq $0x0, 0x28(%rsp)
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
cmpq 0x10(%rcx), %rax
ja 0x13a3be
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x13a3ac
movq 0x18(%rsp), %rdi
callq 0x13b4a0
movq 0x18(%rsp), %rdi
movl $0x10, %esi
callq 0xd05e0
jmp 0x13a3ae
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x13a366
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x13a3dc
movq 0x10(%rsp), %rdi
callq 0xd0750
jmp 0x13a40c
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x13a40a
movq 0x8(%rsp), %rdi
callq 0x13b4a0
movq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0xd05e0
jmp 0x13a40c
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
callq 0xd0b38
addq $0x38, %rsp
retq
nop
// File: Lut99[P]RayTracer/src/lib/Frames.cpp
// Function: RayTracer::Frames::next()
void Frames::next() {
    // Do nothing if we're already at the last frame
    if (this->frame_index == this->n_frames) {
        return;
    }

    // Depending on whether we should keep everything in memory, write current image to disk and delete it
    if (this->dynamic_writing) {
        this->current_frame->to_png(this->temp_dir + "/out" + to_string(this->frame_index) + ".png");

        delete this->current_frame;
    }

    // Create a new frame
    this->frame_index++;
    this->current_frame = new Image(this->width, this->height);

    // If we should keep everything in memory, update the frames list
    if (!this->dynamic_writing) {
        this->frames[this->frame_index] = this->current_frame;
    }
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movq 0x10(%rcx), %rax
movl 0x44(%rcx), %ecx
cmpq %rcx, %rax
jne 0x13a44d
jmp 0x13a61b
movq 0x18(%rsp), %rax
testb $0x1, 0x38(%rax)
je 0x13a59f
movq 0x18(%rsp), %rsi
movq (%rsi), %rax
movq %rax, 0x10(%rsp)
addq $0x18, %rsi
leaq 0x3bb4e(%rip), %rdx     # 0x175fc2
leaq 0x50(%rsp), %rdi
callq 0x13ae30
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
leaq 0x30(%rsp), %rdi
callq 0x12e250
jmp 0x13a493
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x122650
jmp 0x13a4a9
leaq 0x3bac8(%rip), %rdx     # 0x175f78
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xe6bb0
jmp 0x13a4c4
movq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x13bb50
jmp 0x13a4d8
leaq 0x90(%rsp), %rdi
callq 0xd0b38
leaq 0x70(%rsp), %rdi
callq 0xd0b38
leaq 0x30(%rsp), %rdi
callq 0xd0b38
leaq 0x50(%rsp), %rdi
callq 0xd0b38
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x13a52f
movq 0x8(%rsp), %rdi
callq 0x13b4a0
movq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0xd05e0
jmp 0x13a59f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x13a590
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x13a586
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x13a57c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xd0b38
leaq 0x70(%rsp), %rdi
callq 0xd0b38
leaq 0x30(%rsp), %rdi
callq 0xd0b38
leaq 0x50(%rsp), %rdi
callq 0xd0b38
jmp 0x13a623
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
incq %rcx
movq %rcx, 0x10(%rax)
movl $0x10, %edi
callq 0xd05d0
movq %rax, %rdi
movq 0x18(%rsp), %rax
movq %rdi, %rcx
movq %rcx, (%rsp)
movl 0x3c(%rax), %esi
movl 0x40(%rax), %edx
callq 0x13b350
jmp 0x13a5d5
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, (%rax)
testb $0x1, 0x38(%rax)
jne 0x13a61b
movq 0x18(%rsp), %rcx
movq (%rcx), %rdx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x13a61b
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x10, %esi
callq 0xd05e0
jmp 0x13a623
addq $0xb8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xd0a10
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/Image.cpp
// Function: RayTracer::Pixel::operator=(RayTracer::Pixel const&)
Pixel& Pixel::operator=(const Pixel& other) {
    this->data[0] = other.data[0];
    this->data[1] = other.data[1];
    this->data[2] = other.data[2];
    return *this;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movsd (%rcx), %xmm0
movq (%rax), %rcx
movsd %xmm0, (%rcx)
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movsd 0x8(%rcx), %xmm0
movq (%rax), %rcx
movsd %xmm0, 0x8(%rcx)
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movsd 0x10(%rcx), %xmm0
movq (%rax), %rcx
movsd %xmm0, 0x10(%rcx)
retq
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/Image.cpp
// Function: RayTracer::Pixel::operator=(RayTracer::Vec3 const&)
Pixel& Pixel::operator=(const Vec3& other) {
    // Simply set our own data to given vector
    this->data[0] = other.x;
    this->data[1] = other.y;
    this->data[2] = other.z;
    return *this;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movsd 0x8(%rcx), %xmm0
movq (%rax), %rcx
movsd %xmm0, (%rcx)
movq -0x10(%rsp), %rcx
movsd 0x10(%rcx), %xmm0
movq (%rax), %rcx
movsd %xmm0, 0x8(%rcx)
movq -0x10(%rsp), %rcx
movsd 0x18(%rcx), %xmm0
movq (%rax), %rcx
movsd %xmm0, 0x10(%rcx)
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/Image.cpp
// Function: RayTracer::ImageRow::operator[](unsigned int)
Pixel ImageRow::operator[](unsigned int index) {
    // Check if out of bounds
    if (index >= this->width) {
        throw out_of_range("Cannot get element " + to_string(index) + " from Image with width " + to_string(index));
    }

    // Get a pointer to the correct position in the data
    double* pixel = this->data + 3 * index;
    return Pixel(pixel);
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movl %esi, 0xd4(%rsp)
movq 0xd8(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movl 0xd4(%rsp), %eax
cmpl 0x8(%rcx), %eax
jb 0x13b2fc
movb $0x1, 0x1f(%rsp)
movl $0x10, %edi
callq 0xd02b0
movq %rax, (%rsp)
movl 0xd4(%rsp), %esi
leaq 0x50(%rsp), %rdi
callq 0x139a70
jmp 0x13b1b9
leaq 0x3aed7(%rip), %rsi     # 0x176097
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x12d820
jmp 0x13b1d1
leaq 0x3aed3(%rip), %rdx     # 0x1760ab
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xe6bb0
jmp 0x13b1ec
movl 0xd4(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x139a70
jmp 0x13b1ff
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x122650
jmp 0x13b21b
movq (%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0xd08a0
jmp 0x13b22e
movq (%rsp), %rdi
movb $0x0, 0x1f(%rsp)
movq 0x70d6a(%rip), %rsi     # 0x1abfa8
movq 0x70d4b(%rip), %rdx     # 0x1abf90
callq 0xd09b0
jmp 0x13b346
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x13b2e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x13b2de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x13b2d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x13b2c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x13b2bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0xd0b38
leaq 0x20(%rsp), %rdi
callq 0xd0b38
leaq 0x90(%rsp), %rdi
callq 0xd0b38
leaq 0x70(%rsp), %rdi
callq 0xd0b38
leaq 0x50(%rsp), %rdi
callq 0xd0b38
testb $0x1, 0x1f(%rsp)
jne 0x13b2f1
jmp 0x13b2fa
movq (%rsp), %rdi
callq 0xd0430
jmp 0x13b33c
movq 0x8(%rsp), %rax
movq (%rax), %rax
imull $0x3, 0xd4(%rsp), %ecx
movl %ecx, %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
leaq 0xe0(%rsp), %rdi
callq 0x13aec0
movq 0xe0(%rsp), %rax
addq $0xe8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xd0a10
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/Image.cpp
// Function: RayTracer::Image::Image(RayTracer::Image const&)
Image::Image(const Image& other)
    : Image(other.width, other.height)
{
    cout << "Copy constructor" << endl;

    // Copy all pixels over
    for (std::size_t i = 0; i < this->width * this->height * 3; i++) {
        this->data[i] = other.data[i];
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x13b350
movq 0x70b9a(%rip), %rdi     # 0x1abf88
leaq 0x3acce(%rip), %rsi     # 0x1760c3
callq 0xd05b0
movq %rax, 0x8(%rsp)
jmp 0x13b401
movq 0x8(%rsp), %rdi
movq 0x70b2b(%rip), %rsi     # 0x1abf38
callq 0xd0610
jmp 0x13b414
movq $0x0, 0x10(%rsp)
movq (%rsp), %rdx
movq 0x10(%rsp), %rax
movl 0x8(%rdx), %ecx
imull 0xc(%rdx), %ecx
imull $0x3, %ecx, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x13b483
movq (%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
movq 0x10(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x13b41d
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x13b4a0
jmp 0x13b488
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xd0a10
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/Image.cpp
// Function: RayTracer::Image::operator[](unsigned int)
ImageRow Image::operator[](unsigned int index) {
    // Check if the index is within bounds
    if (index >= this->height) {
        throw out_of_range("Cannot get row " + to_string(index) + " from Image with height " + to_string(index));
    }

    // Get the correct pointer
    double* row = this->data + 3 * (index * this->width);
    return ImageRow(row, this->width);
}

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0xe0(%rsp)
movl %esi, 0xdc(%rsp)
movq 0xe0(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movl 0xdc(%rsp), %eax
cmpl 0xc(%rcx), %eax
jb 0x13baf0
movb $0x1, 0x27(%rsp)
movl $0x10, %edi
callq 0xd02b0
movq %rax, 0x8(%rsp)
movl 0xdc(%rsp), %esi
leaq 0x58(%rsp), %rdi
callq 0x139a70
jmp 0x13b9aa
leaq 0x3a76a(%rip), %rsi     # 0x17611b
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0x12d820
jmp 0x13b9c2
leaq 0x3a762(%rip), %rdx     # 0x17612b
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xe6bb0
jmp 0x13b9dd
movl 0xdc(%rsp), %esi
leaq 0x28(%rsp), %rdi
callq 0x139a70
jmp 0x13b9f0
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x122650
jmp 0x13ba0c
movq 0x8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0xd08a0
jmp 0x13ba20
movq 0x8(%rsp), %rdi
movb $0x0, 0x27(%rsp)
movq 0x70577(%rip), %rsi     # 0x1abfa8
movq 0x70558(%rip), %rdx     # 0x1abf90
callq 0xd09b0
jmp 0x13bb49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x13badb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x13bad1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x13bac7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x13baba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x13bab0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0xd0b38
leaq 0x28(%rsp), %rdi
callq 0xd0b38
leaq 0x98(%rsp), %rdi
callq 0xd0b38
leaq 0x78(%rsp), %rdi
callq 0xd0b38
leaq 0x58(%rsp), %rdi
callq 0xd0b38
testb $0x1, 0x27(%rsp)
jne 0x13bae4
jmp 0x13baee
movq 0x8(%rsp), %rdi
callq 0xd0430
jmp 0x13bb3f
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movl 0xdc(%rsp), %esi
movl 0x8(%rax), %edx
imull %edx, %esi
movl %esi, %edx
leal (%rdx,%rdx,2), %edx
leaq (%rcx,%rdx,8), %rcx
movq %rcx, 0x18(%rsp)
movq 0x18(%rsp), %rsi
movl 0x8(%rax), %edx
leaq 0xe8(%rsp), %rdi
callq 0x13b130
movq 0xe8(%rsp), %rax
movl 0xf0(%rsp), %edx
addq $0xf8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0xd0a10
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_save_file(unsigned char const*, unsigned long, char const*)
unsigned lodepng_save_file(const unsigned char* buffer, size_t buffersize, const char* filename) {
  FILE* file;
  file = fopen(filename, "wb" );
  if(!file) return 79;
  fwrite(buffer, 1, buffersize, file);
  fclose(file);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x39786(%rip), %rsi     # 0x1766c5
callq 0xd06d0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x13cf59
movl $0x4f, 0x24(%rsp)
jmp 0x13cf82
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq (%rsp), %rcx
movl $0x1, %esi
callq 0xd0ae0
movq (%rsp), %rdi
callq 0xd05c0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lode_png_test_bitreader(unsigned char const*, unsigned long, unsigned long, unsigned long const*, unsigned int*)
unsigned lode_png_test_bitreader(const unsigned char* data, size_t size,
                                 size_t numsteps, const size_t* steps, unsigned* result) {
  size_t i;
  LodePNGBitReader reader;
  LodePNGBitReader_init(&reader, data, size);
  for(i = 0; i < numsteps; i++) {
    size_t step = steps[i];
    unsigned ok;
    if(step > 25) ok = ensureBits32(&reader, step);
    else if(step > 17) ok = ensureBits25(&reader, step);
    else if(step > 9) ok = ensureBits17(&reader, step);
    else ok = ensureBits9(&reader, step);
    if(!ok) return 0;
    result[i] = readBits(&reader, step);
  }
  return 1;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
leaq 0x18(%rsp), %rdi
callq 0x13d0e0
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x58(%rsp), %rax
jae 0x13d0cd
movq 0x50(%rsp), %rax
movq 0x40(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x19, 0x10(%rsp)
jbe 0x13d03a
movq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x13d190
movl %eax, 0xc(%rsp)
jmp 0x13d08b
cmpq $0x11, 0x10(%rsp)
jbe 0x13d057
movq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x13d3a0
movl %eax, 0xc(%rsp)
jmp 0x13d089
cmpq $0x9, 0x10(%rsp)
jbe 0x13d074
movq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x13d550
movl %eax, 0xc(%rsp)
jmp 0x13d087
movq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x13d6b0
movl %eax, 0xc(%rsp)
jmp 0x13d089
jmp 0x13d08b
cmpl $0x0, 0xc(%rsp)
jne 0x13d09c
movl $0x0, 0x74(%rsp)
jmp 0x13d0d5
movq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x13d7c0
movl %eax, %edx
movq 0x48(%rsp), %rax
movq 0x40(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x13cffa
movl $0x1, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nop
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: LodePNGBitReader_init(LodePNGBitReader*, unsigned char const*, unsigned long)
static unsigned LodePNGBitReader_init(LodePNGBitReader* reader, const unsigned char* data, size_t size) {
  size_t temp;
  reader->data = data;
  reader->size = size;
  /* size in bits, return error if overflow (if size_t is 32 bit this supports up to 500MB)  */
  if(lodepng_mulofl(size, 8u, &reader->bitsize)) return 105;
  /*ensure incremented bp can be compared to bitsize without overflow even when it would be incremented 32 too much and
  trying to ensure 32 more bits*/
  if(lodepng_addofl(reader->bitsize, 64u, &temp)) return 105;
  reader->bp = 0;
  reader->buffer = 0;
  return 0; /*ok*/
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rdx
addq $0x10, %rdx
movl $0x8, %esi
callq 0x14b760
cmpl $0x0, %eax
je 0x13d135
movl $0x69, 0x24(%rsp)
jmp 0x13d17b
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movl $0x40, %esi
movq %rsp, %rdx
callq 0x13f260
cmpl $0x0, %eax
je 0x13d15a
movl $0x69, 0x24(%rsp)
jmp 0x13d17b
movq 0x18(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x18(%rsp), %rax
movl $0x0, 0x20(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: ensureBits25(LodePNGBitReader*, unsigned long)
static LODEPNG_INLINE unsigned ensureBits25(LodePNGBitReader* reader, size_t nbits) {
  size_t start = reader->bp >> 3u;
  size_t size = reader->size;
  if(start + 3u < size) {
    reader->buffer = (unsigned)reader->data[start + 0] | ((unsigned)reader->data[start + 1] << 8u) |
                     ((unsigned)reader->data[start + 2] << 16u) | ((unsigned)reader->data[start + 3] << 24u);
    reader->buffer >>= (reader->bp & 7u);
    return 1;
  } else {
    reader->buffer = 0;
    if(start + 0u < size) reader->buffer |= reader->data[start + 0];
    if(start + 1u < size) reader->buffer |= ((unsigned)reader->data[start + 1] << 8u);
    if(start + 2u < size) reader->buffer |= ((unsigned)reader->data[start + 2] << 16u);
    reader->buffer >>= (reader->bp & 7u);
    return reader->bp + nbits <= reader->bitsize;
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
shrq $0x3, %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
addq $0x3, %rax
cmpq -0x28(%rsp), %rax
jae 0x13d465
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %ecx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rdx
movzbl 0x1(%rax,%rdx), %eax
shll $0x8, %eax
orl %eax, %ecx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rdx
movzbl 0x2(%rax,%rdx), %eax
shll $0x10, %eax
orl %eax, %ecx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rdx
movzbl 0x3(%rax,%rdx), %eax
shll $0x18, %eax
orl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rcx
andq $0x7, %rcx
movq -0x10(%rsp), %rax
movl 0x20(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x20(%rax)
movl $0x1, -0x4(%rsp)
jmp 0x13d53c
movq -0x10(%rsp), %rax
movl $0x0, 0x20(%rax)
movq -0x20(%rsp), %rax
addq $0x0, %rax
cmpq -0x28(%rsp), %rax
jae 0x13d49d
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %ecx
movq -0x10(%rsp), %rax
orl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x20(%rsp), %rax
addq $0x1, %rax
cmpq -0x28(%rsp), %rax
jae 0x13d4cd
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rcx
movzbl 0x1(%rax,%rcx), %ecx
shll $0x8, %ecx
movq -0x10(%rsp), %rax
orl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x20(%rsp), %rax
addq $0x2, %rax
cmpq -0x28(%rsp), %rax
jae 0x13d4fd
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rcx
movzbl 0x2(%rax,%rcx), %ecx
shll $0x10, %ecx
movq -0x10(%rsp), %rax
orl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rcx
andq $0x7, %rcx
movq -0x10(%rsp), %rax
movl 0x20(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
addq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
setbe %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: ensureBits17(LodePNGBitReader*, unsigned long)
static unsigned ensureBits17(LodePNGBitReader* reader, size_t nbits) {
  size_t start = reader->bp >> 3u;
  size_t size = reader->size;
  if(start + 2u < size) {
    reader->buffer = (unsigned)reader->data[start + 0] | ((unsigned)reader->data[start + 1] << 8u) |
                     ((unsigned)reader->data[start + 2] << 16u);
    reader->buffer >>= (reader->bp & 7u);
    return 1;
  } else {
    reader->buffer = 0;
    if(start + 0u < size) reader->buffer |= reader->data[start + 0];
    if(start + 1u < size) reader->buffer |= ((unsigned)reader->data[start + 1] << 8u);
    reader->buffer >>= (reader->bp & 7u);
    return reader->bp + nbits <= reader->bitsize;
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
shrq $0x3, %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
addq $0x2, %rax
cmpq -0x28(%rsp), %rax
jae 0x13d5fa
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %ecx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rdx
movzbl 0x1(%rax,%rdx), %eax
shll $0x8, %eax
orl %eax, %ecx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rdx
movzbl 0x2(%rax,%rdx), %eax
shll $0x10, %eax
orl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rcx
andq $0x7, %rcx
movq -0x10(%rsp), %rax
movl 0x20(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x20(%rax)
movl $0x1, -0x4(%rsp)
jmp 0x13d6a1
movq -0x10(%rsp), %rax
movl $0x0, 0x20(%rax)
movq -0x20(%rsp), %rax
addq $0x0, %rax
cmpq -0x28(%rsp), %rax
jae 0x13d632
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %ecx
movq -0x10(%rsp), %rax
orl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x20(%rsp), %rax
addq $0x1, %rax
cmpq -0x28(%rsp), %rax
jae 0x13d662
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rcx
movzbl 0x1(%rax,%rcx), %ecx
shll $0x8, %ecx
movq -0x10(%rsp), %rax
orl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rcx
andq $0x7, %rcx
movq -0x10(%rsp), %rax
movl 0x20(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
addq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
setbe %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: ensureBits9(LodePNGBitReader*, unsigned long)
static unsigned ensureBits9(LodePNGBitReader* reader, size_t nbits) {
  size_t start = reader->bp >> 3u;
  size_t size = reader->size;
  if(start + 1u < size) {
    reader->buffer = (unsigned)reader->data[start + 0] | ((unsigned)reader->data[start + 1] << 8u);
    reader->buffer >>= (reader->bp & 7u);
    return 1;
  } else {
    reader->buffer = 0;
    if(start + 0u < size) reader->buffer |= reader->data[start + 0];
    reader->buffer >>= (reader->bp & 7u);
    return reader->bp + nbits <= reader->bitsize;
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
shrq $0x3, %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
cmpq -0x28(%rsp), %rax
jae 0x13d740
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %ecx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rdx
movzbl 0x1(%rax,%rdx), %eax
shll $0x8, %eax
orl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rcx
andq $0x7, %rcx
movq -0x10(%rsp), %rax
movl 0x20(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x20(%rax)
movl $0x1, -0x4(%rsp)
jmp 0x13d7b7
movq -0x10(%rsp), %rax
movl $0x0, 0x20(%rax)
movq -0x20(%rsp), %rax
addq $0x0, %rax
cmpq -0x28(%rsp), %rax
jae 0x13d778
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %ecx
movq -0x10(%rsp), %rax
orl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rcx
andq $0x7, %rcx
movq -0x10(%rsp), %rax
movl 0x20(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
addq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
setbe %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_inflatev(ucvector*, unsigned char const*, unsigned long, LodePNGDecompressSettings const*)
static unsigned lodepng_inflatev(ucvector* out,
                                 const unsigned char* in, size_t insize,
                                 const LodePNGDecompressSettings* settings) {
  unsigned BFINAL = 0;
  size_t pos = 0; /*byte position in the out buffer*/
  LodePNGBitReader reader;
  unsigned error = LodePNGBitReader_init(&reader, in, insize);

  if(error) return error;

  while(!BFINAL) {
    unsigned BTYPE;
    if(!ensureBits9(&reader, 3)) return 52; /*error, bit pointer will jump past memory*/
    BFINAL = readBits(&reader, 1);
    BTYPE = readBits(&reader, 2);

    if(BTYPE == 3) return 20; /*error: invalid BTYPE*/
    else if(BTYPE == 0) error = inflateNoCompression(out, &pos, &reader, settings); /*no compression*/
    else error = inflateHuffmanBlock(out, &pos, &reader, BTYPE); /*compression, BTYPE 01 or 10*/

    if(error) return error;
  }

  return error;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x13d0e0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x13e3f5
movl 0x4(%rsp), %eax
movl %eax, 0x64(%rsp)
jmp 0x13e4c0
jmp 0x13e3f7
cmpl $0x0, 0x3c(%rsp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x13e40a
jmp 0x13e4b8
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
callq 0x13d6b0
cmpl $0x0, %eax
jne 0x13e42b
movl $0x34, 0x64(%rsp)
jmp 0x13e4c0
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x13d7c0
movl %eax, 0x3c(%rsp)
leaq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x13d7c0
movl %eax, (%rsp)
cmpl $0x3, (%rsp)
jne 0x13e460
movl $0x14, 0x64(%rsp)
jmp 0x13e4c0
cmpl $0x0, (%rsp)
jne 0x13e485
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rcx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x14b880
movl %eax, 0x4(%rsp)
jmp 0x13e4a0
movq 0x58(%rsp), %rdi
movl (%rsp), %ecx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x14ba30
movl %eax, 0x4(%rsp)
jmp 0x13e4a2
cmpl $0x0, 0x4(%rsp)
je 0x13e4b3
movl 0x4(%rsp), %eax
movl %eax, 0x64(%rsp)
jmp 0x13e4c0
jmp 0x13e3f7
movl 0x4(%rsp), %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: inflate(unsigned char**, unsigned long*, unsigned char const*, unsigned long, LodePNGDecompressSettings const*)
static unsigned inflate(unsigned char** out, size_t* outsize,
                        const unsigned char* in, size_t insize,
                        const LodePNGDecompressSettings* settings) {
  if(settings->custom_inflate) {
    return settings->custom_inflate(out, outsize, in, insize, settings);
  } else {
    return lodepng_inflate(out, outsize, in, insize, settings);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x13e9e3
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq *%rax
movl %eax, 0x34(%rsp)
jmp 0x13ea05
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x13e2e0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: deflate(unsigned char**, unsigned long*, unsigned char const*, unsigned long, LodePNGCompressSettings const*)
static unsigned deflate(unsigned char** out, size_t* outsize,
                        const unsigned char* in, size_t insize,
                        const LodePNGCompressSettings* settings) {
  if(settings->custom_deflate) {
    return settings->custom_deflate(out, outsize, in, insize, settings);
  } else {
    return lodepng_deflate(out, outsize, in, insize, settings);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x13eca3
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq *%rax
movl %eax, 0x34(%rsp)
jmp 0x13ecc5
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x13e4d0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_decompress_settings_init(LodePNGDecompressSettings*)
void lodepng_decompress_settings_init(LodePNGDecompressSettings* settings) {
  settings->ignore_adler32 = 0;
  settings->ignore_nlen = 0;

  settings->custom_zlib = 0;
  settings->custom_inflate = 0;
  settings->custom_context = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, (%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_crc32(unsigned char const*, unsigned long)
unsigned lodepng_crc32(const unsigned char* data, size_t length) {
  unsigned r = 0xffffffffu;
  size_t i;
  for(i = 0; i < length; ++i) {
    r = lodepng_crc32_table[(r ^ data[i]) & 0xffu] ^ (r >> 8u);
  }
  return r ^ 0xffffffffu;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0xffffffff, -0x14(%rsp) # imm = 0xFFFFFFFF
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x13ee6b
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
movq -0x20(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x6db95(%rip), %rax     # 0x1ac9e0
movl (%rax,%rcx,4), %eax
movl -0x14(%rsp), %ecx
shrl $0x8, %ecx
xorl %ecx, %eax
movl %eax, -0x14(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x13ee1b
movl -0x14(%rsp), %eax
xorl $-0x1, %eax
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_chunk_next(unsigned char*, unsigned char*)
unsigned char* lodepng_chunk_next(unsigned char* chunk, unsigned char* end) {
  if(chunk >= end || end - chunk < 12) return end; /*too small to contain a chunk*/
  if(chunk[0] == 0x89 && chunk[1] == 0x50 && chunk[2] == 0x4e && chunk[3] == 0x47
    && chunk[4] == 0x0d && chunk[5] == 0x0a && chunk[6] == 0x1a && chunk[7] == 0x0a) {
    /* Is PNG magic header at start of PNG file. Jump to first actual chunk. */
    return chunk + 8;
  } else {
    size_t total_chunk_length;
    unsigned char* result;
    if(lodepng_addofl(lodepng_chunk_length(chunk), 12, &total_chunk_length)) return end;
    result = chunk + total_chunk_length;
    if(result < chunk) return end; /*pointer overflow*/
    return result;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x13f15d
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
cmpq $0xc, %rax
jge 0x13f16c
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x13f249
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x89, %eax
jne 0x13f1ed
movq 0x18(%rsp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x50, %eax
jne 0x13f1ed
movq 0x18(%rsp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x4e, %eax
jne 0x13f1ed
movq 0x18(%rsp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x47, %eax
jne 0x13f1ed
movq 0x18(%rsp), %rax
movzbl 0x4(%rax), %eax
cmpl $0xd, %eax
jne 0x13f1ed
movq 0x18(%rsp), %rax
movzbl 0x5(%rax), %eax
cmpl $0xa, %eax
jne 0x13f1ed
movq 0x18(%rsp), %rax
movzbl 0x6(%rax), %eax
cmpl $0x1a, %eax
jne 0x13f1ed
movq 0x18(%rsp), %rax
movzbl 0x7(%rax), %eax
cmpl $0xa, %eax
jne 0x13f1ed
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
jmp 0x13f249
movq 0x18(%rsp), %rdi
callq 0x13ee80
movl %eax, %eax
movl %eax, %edi
movl $0xc, %esi
leaq 0x8(%rsp), %rdx
callq 0x13f260
cmpl $0x0, %eax
je 0x13f21b
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x13f249
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x13f240
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x13f249
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_chunk_next_const(unsigned char const*, unsigned char const*)
const unsigned char* lodepng_chunk_next_const(const unsigned char* chunk, const unsigned char* end) {
  if(chunk >= end || end - chunk < 12) return end; /*too small to contain a chunk*/
  if(chunk[0] == 0x89 && chunk[1] == 0x50 && chunk[2] == 0x4e && chunk[3] == 0x47
    && chunk[4] == 0x0d && chunk[5] == 0x0a && chunk[6] == 0x1a && chunk[7] == 0x0a) {
    /* Is PNG magic header at start of PNG file. Jump to first actual chunk. */
    return chunk + 8;
  } else {
    size_t total_chunk_length;
    const unsigned char* result;
    if(lodepng_addofl(lodepng_chunk_length(chunk), 12, &total_chunk_length)) return end;
    result = chunk + total_chunk_length;
    if(result < chunk) return end; /*pointer overflow*/
    return result;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x13f2cd
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
cmpq $0xc, %rax
jge 0x13f2dc
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x13f3b9
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x89, %eax
jne 0x13f35d
movq 0x18(%rsp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x50, %eax
jne 0x13f35d
movq 0x18(%rsp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x4e, %eax
jne 0x13f35d
movq 0x18(%rsp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x47, %eax
jne 0x13f35d
movq 0x18(%rsp), %rax
movzbl 0x4(%rax), %eax
cmpl $0xd, %eax
jne 0x13f35d
movq 0x18(%rsp), %rax
movzbl 0x5(%rax), %eax
cmpl $0xa, %eax
jne 0x13f35d
movq 0x18(%rsp), %rax
movzbl 0x6(%rax), %eax
cmpl $0x1a, %eax
jne 0x13f35d
movq 0x18(%rsp), %rax
movzbl 0x7(%rax), %eax
cmpl $0xa, %eax
jne 0x13f35d
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
jmp 0x13f3b9
movq 0x18(%rsp), %rdi
callq 0x13ee80
movl %eax, %eax
movl %eax, %edi
movl $0xc, %esi
leaq 0x8(%rsp), %rdx
callq 0x13f260
cmpl $0x0, %eax
je 0x13f38b
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x13f3b9
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x13f3b0
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x13f3b9
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_chunk_find(unsigned char*, unsigned char*, char const*)
unsigned char* lodepng_chunk_find(unsigned char* chunk, unsigned char* end, const char type[5]) {
  for(;;) {
    if(chunk >= end || end - chunk < 12) return 0; /* past file end: chunk + 12 > end */
    if(lodepng_chunk_type_equals(chunk, type)) return chunk;
    chunk = lodepng_chunk_next(chunk, end);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x13f402
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
cmpq $0xc, %rax
jge 0x13f40d
movq $0x0, 0x20(%rsp)
jmp 0x13f442
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x13eee0
cmpb $0x0, %al
je 0x13f42c
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x13f442
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x13f130
movq %rax, 0x18(%rsp)
jmp 0x13f3e3
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)