LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::empty() const
bool empty() const noexcept
    {
        switch (m_type)
        {
            case value_t::null:
            {
                // null values are empty
                return true;
            }

            case value_t::array:
            {
                // delegate call to array_t::empty()
                return m_value.array->empty();
            }

            case value_t::object:
            {
                // delegate call to object_t::empty()
                return m_value.object->empty();
            }

            default:
            {
                // all other types are nonempty
                return false;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movb (%rax), %al
movb %al, -0x11(%rbp)
testb %al, %al
je 0x74301
jmp 0x742ef
movb -0x11(%rbp), %al
subb $0x1, %al
je 0x7431b
jmp 0x742f8
movb -0x11(%rbp), %al
subb $0x2, %al
je 0x74307
jmp 0x7432f
movb $0x1, -0x1(%rbp)
jmp 0x74333
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x74620
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x74333
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x74660
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x74333
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const>::iter_impl(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const*)
explicit iter_impl(pointer object) noexcept : m_object(object)
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_type)
        {
            case value_t::object:
            {
                m_it.object_iterator = typename object_t::iterator();
                break;
            }

            case value_t::array:
            {
                m_it.array_iterator = typename array_t::iterator();
                break;
            }

            default:
            {
                m_it.primitive_iterator = primitive_iterator_t();
                break;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x74f10
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0x74f30
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0xb310
movq -0x38(%rbp), %rdi
callq 0x74f50
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x74d96
jmp 0x74db5
leaq 0x4fb4c(%rip), %rdi     # 0xc48e9
leaq 0x4dbc9(%rip), %rsi     # 0xc296d
movl $0x2a68, %edx           # imm = 0x2A68
leaq 0x51991(%rip), %rcx     # 0xc6741
callq 0xb410
movq -0x30(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x41(%rbp)
subb $0x1, %al
je 0x74dd0
jmp 0x74dc7
movb -0x41(%rbp), %al
subb $0x2, %al
je 0x74de7
jmp 0x74dfe
leaq -0x18(%rbp), %rdi
callq 0x74f10
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x74e23
leaq -0x20(%rbp), %rdi
callq 0x74f30
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x74e23
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0xb310
leaq -0x28(%rbp), %rdi
callq 0x74f50
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const>::set_end()
void set_end() noexcept
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_type)
        {
            case value_t::object:
            {
                m_it.object_iterator = m_object->m_value.object->end();
                break;
            }

            case value_t::array:
            {
                m_it.array_iterator = m_object->m_value.array->end();
                break;
            }

            default:
            {
                m_it.primitive_iterator.set_end();
                break;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
je 0x7505c
jmp 0x7507b
leaq 0x4f886(%rip), %rdi     # 0xc48e9
leaq 0x4d903(%rip), %rsi     # 0xc296d
movl $0x2ae3, %edx           # imm = 0x2AE3
leaq 0x517c3(%rip), %rcx     # 0xc6839
callq 0xb410
movq -0x20(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
subb $0x1, %al
je 0x75096
jmp 0x7508d
movb -0x21(%rbp), %al
subb $0x2, %al
je 0x750bb
jmp 0x750e0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x50060
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x750f1
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x4ad50
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x750f1
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
addq $0x10, %rdi
callq 0x74fc0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::detail::operator<(nlohmann::detail::value_t, nlohmann::detail::value_t)
inline bool operator<(const value_t lhs, const value_t rhs) noexcept
{
    static constexpr std::array<std::uint8_t, 9> order = {{
            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
            6 /* binary */
        }
    };

    const auto l_index = static_cast<std::size_t>(lhs);
    const auto r_index = static_cast<std::size_t>(rhs);
    return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
movzbl -0x1(%rbp), %eax
movq %rax, -0x10(%rbp)
movzbl -0x2(%rbp), %eax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x555c5(%rip), %rdi     # 0xcb6c8
callq 0x76b90
movq -0x28(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x19(%rbp)
jae 0x76175
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x555a0(%rip), %rdi     # 0xcb6c8
callq 0x76b90
movq -0x30(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x19(%rbp)
jae 0x76175
movq -0x10(%rbp), %rsi
leaq 0x5557f(%rip), %rdi     # 0xcb6c8
callq 0x76ba0
movzbl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x55569(%rip), %rdi     # 0xcb6c8
callq 0x76ba0
movq %rax, %rcx
movl -0x34(%rbp), %eax
movzbl (%rcx), %ecx
cmpl %ecx, %eax
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const>::operator--()
iter_impl& operator--()
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_type)
        {
            case value_t::object:
            {
                std::advance(m_it.object_iterator, -1);
                break;
            }

            case value_t::array:
            {
                std::advance(m_it.array_iterator, -1);
                break;
            }

            default:
            {
                --m_it.primitive_iterator;
                break;
            }
        }

        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x78dac
jmp 0x78dcb
leaq 0x4bb36(%rip), %rdi     # 0xc48e9
leaq 0x49bb3(%rip), %rsi     # 0xc296d
movl $0x2b7f, %edx           # imm = 0x2B7F
leaq 0x4de0c(%rip), %rcx     # 0xc6bd2
callq 0xb410
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
subb $0x1, %al
je 0x78de6
jmp 0x78ddd
movb -0x11(%rbp), %al
subb $0x2, %al
je 0x78dfa
jmp 0x78e12
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x74af0
jmp 0x78e23
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x8, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x74b40
jmp 0x78e23
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x10, %rdi
callq 0x78e30
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::operator-(nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>> const&) const
difference_type operator-(const iter_impl& other) const
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_type)
        {
            case value_t::object:
                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));

            case value_t::array:
                return m_it.array_iterator - other.m_it.array_iterator;

            default:
                return m_it.primitive_iterator - other.m_it.primitive_iterator;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, (%rax)
je 0x7c703
jmp 0x7c722
leaq 0x481df(%rip), %rdi     # 0xc48e9
leaq 0x4625c(%rip), %rsi     # 0xc296d
movl $0x2c40, %edx           # imm = 0x2C40
leaq 0x4ac5a(%rip), %rcx     # 0xc7377
callq 0xb410
movq -0x68(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x69(%rbp)
subb $0x1, %al
je 0x7c744
jmp 0x7c734
movb -0x69(%rbp), %al
subb $0x2, %al
je 0x7c7ec
jmp 0x7c80f
movb $0x1, -0x4d(%rbp)
movl $0x20, %edi
callq 0xb2c0
movq %rax, -0x80(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xba70
movq -0x78(%rbp), %rdx
leaq 0x4aa23(%rip), %rsi     # 0xc7191
leaq -0x38(%rbp), %rdi
callq 0x10b90
jmp 0x7c779
movq -0x80(%rbp), %rdi
movl $0xd1, %esi
leaq -0x38(%rbp), %rdx
callq 0x50110
jmp 0x7c78d
movq -0x80(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq 0x9f634(%rip), %rsi     # 0x11bdd0
leaq -0x2c543(%rip), %rdx    # 0x50260
callq 0xb9f0
jmp 0x7c84e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x7c7d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xbb98
leaq -0x39(%rbp), %rdi
callq 0xb600
testb $0x1, -0x4d(%rbp)
jne 0x7c7e1
jmp 0x7c7ea
movq -0x80(%rbp), %rdi
callq 0xb460
jmp 0x7c845
movq -0x68(%rbp), %rdi
addq $0x8, %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rsi
callq 0x4ae90
movq %rax, -0x8(%rbp)
jmp 0x7c838
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x7e510
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xba60
nop
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::operator+=(long)
iter_impl& operator+=(difference_type i)
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_type)
        {
            case value_t::object:
                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));

            case value_t::array:
            {
                std::advance(m_it.array_iterator, i);
                break;
            }

            default:
            {
                m_it.primitive_iterator += i;
                break;
            }
        }

        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, (%rax)
je 0x7da30
jmp 0x7da4f
leaq 0x46eb2(%rip), %rdi     # 0xc48e9
leaq 0x44f2f(%rip), %rsi     # 0xc296d
movl $0x2bf9, %edx           # imm = 0x2BF9
leaq 0x496b3(%rip), %rcx     # 0xc70fd
callq 0xb410
movq -0x50(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x51(%rbp)
subb $0x1, %al
je 0x7da71
jmp 0x7da61
movb -0x51(%rbp), %al
subb $0x2, %al
je 0x7db16
jmp 0x7db2d
movb $0x1, -0x45(%rbp)
movl $0x20, %edi
callq 0xb2c0
movq %rax, -0x68(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xba70
movq -0x60(%rbp), %rdx
leaq 0x496f6(%rip), %rsi     # 0xc7191
leaq -0x30(%rbp), %rdi
callq 0x10b90
jmp 0x7daa6
movq -0x68(%rbp), %rdi
movl $0xd1, %esi
leaq -0x30(%rbp), %rdx
callq 0x50110
jmp 0x7daba
movq -0x68(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x9e307(%rip), %rsi     # 0x11bdd0
leaq -0x2d870(%rip), %rdx    # 0x50260
callq 0xb9f0
jmp 0x7db55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7dafa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbb98
leaq -0x31(%rbp), %rdi
callq 0xb600
testb $0x1, -0x45(%rbp)
jne 0x7db0b
jmp 0x7db14
movq -0x68(%rbp), %rdi
callq 0xb460
jmp 0x7db4c
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x7db60
jmp 0x7db42
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rdi
addq $0x10, %rdi
callq 0x7dbb0
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xba60
nopw %cs:(%rax,%rax)
nop
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Renderer::print_json(std::shared_ptr<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>)
void print_json(const std::shared_ptr<json> value) {
    if (value->is_string()) {
      *output_stream << value->get_ref<const json::string_t&>();
    } else if (value->is_number_integer()) {
      *output_stream << value->get<const json::number_integer_t>();
    } else if (value->is_null()) {
    } else {
      *output_stream << value->dump();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, %rax
movq -0x58(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x73b20
movq %rax, %rdi
callq 0x50830
testb $0x1, %al
jne 0x7f54d
jmp 0x7f57b
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x60(%rbp)
callq 0x73b20
movq %rax, %rdi
callq 0x3adc0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0xb500
jmp 0x7f643
movq -0x50(%rbp), %rdi
callq 0x73b20
movq %rax, %rdi
callq 0x72580
testb $0x1, %al
jne 0x7f592
jmp 0x7f5c0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x68(%rbp)
callq 0x73b20
movq %rax, %rdi
callq 0x7fa80
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0xbab0
jmp 0x7f641
movq -0x50(%rbp), %rdi
callq 0x73b20
movq %rax, %rdi
callq 0x6a560
testb $0x1, %al
jne 0x7f5d7
jmp 0x7f5d9
jmp 0x7f63f
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x78(%rbp)
callq 0x73b20
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x20, %ecx
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0x12ae0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0xb500
jmp 0x7f61d
leaq -0x30(%rbp), %rdi
callq 0xbb98
jmp 0x7f63f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbb98
jmp 0x7f64c
jmp 0x7f641
jmp 0x7f643
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xba60
nopw %cs:(%rax,%rax)
nop
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::detail::serializer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::dump_float(double)
void dump_float(number_float_t x)
    {
        // NaN / inf
        if (!std::isfinite(x))
        {
            o->write_characters("null", 4);
            return;
        }

        // If number_float_t is an IEEE-754 single or double precision number,
        // use the Grisu2 algorithm to produce short numbers which are
        // guaranteed to round-trip, using strtof and strtod, resp.
        //
        // NB: The test below works if <long double> == <double>.
        static constexpr bool is_ieee_single_or_double
            = (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
              (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);

        dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x49cf0
testb $0x1, %al
jne 0x84b97
movq -0x20(%rbp), %rdi
callq 0x83530
movq %rax, %rdi
movq (%rdi), %rax
leaq 0x3feeb(%rip), %rsi     # 0xc4a78
movl $0x4, %edx
callq *0x8(%rax)
jmp 0x84ba5
movq -0x20(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x851c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::detail::dtoa_impl::diyfp::normalize(nlohmann::detail::dtoa_impl::diyfp)
static diyfp normalize(diyfp x) noexcept
    {
        JSON_ASSERT(x.f != 0);

        while ((x.f >> 63u) == 0)
        {
            x.f <<= 1u;
            x.e--;
        }

        return x;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movl %esi, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x85d58
jmp 0x85d77
leaq 0x4201c(%rip), %rdi     # 0xc7d7b
leaq 0x3cc07(%rip), %rsi     # 0xc296d
movl $0x3891, %edx           # imm = 0x3891
leaq 0x42012(%rip), %rcx     # 0xc7d84
callq 0xb410
jmp 0x85d79
movq -0x20(%rbp), %rax
shrq $0x3f, %rax
cmpq $0x0, %rax
jne 0x85d9d
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x85d79
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::detail::dtoa_impl::diyfp::normalize_to(nlohmann::detail::dtoa_impl::diyfp const&, int)
static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
    {
        const int delta = x.e - target_exponent;

        JSON_ASSERT(delta >= 0);
        JSON_ASSERT(((x.f << delta) >> delta) == x.f);

        return {x.f << delta, target_exponent};
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x85de4
jmp 0x85e03
leaq 0x41fdb(%rip), %rdi     # 0xc7dc6
leaq 0x3cb7b(%rip), %rsi     # 0xc296d
movl $0x38a4, %edx           # imm = 0x38A4
leaq 0x41fd3(%rip), %rcx     # 0xc7dd1
callq 0xb410
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x20(%rbp), %ecx
shlq %cl, %rax
movl -0x20(%rbp), %ecx
shrq %cl, %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x85e21
jmp 0x85e40
leaq 0x42001(%rip), %rdi     # 0xc7e29
leaq 0x3cb3e(%rip), %rsi     # 0xc296d
movl $0x38a5, %edx           # imm = 0x38A5
leaq 0x41f96(%rip), %rcx     # 0xc7dd1
callq 0xb410
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movb -0x20(%rbp), %cl
shlq %cl, %rsi
movl -0x1c(%rbp), %edx
leaq -0x10(%rbp), %rdi
callq 0x85d10
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::erase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
size_type erase(const typename object_t::key_type& key)
    {
        // this erase only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            return m_value.object->erase(key);
        }

        JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x4a990
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xb248a
jmp 0xb24a4
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xb3c10
addq $0x90, %rsp
popq %rbp
retq
movb $0x1, -0x65(%rbp)
movl $0x20, %edi
callq 0xb2c0
movq -0x70(%rbp), %rdi
movq %rax, -0x88(%rbp)
callq 0x50ae0
movq %rax, -0x80(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xba70
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x10b90
jmp 0xb24e6
leaq 0x12567(%rip), %rsi     # 0xc4a54
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x34d50
jmp 0xb24fc
movq -0x88(%rbp), %rdi
movl $0x133, %esi            # imm = 0x133
leaq -0x30(%rbp), %rdx
callq 0x50990
jmp 0xb2513
movq -0x88(%rbp), %rdi
movb $0x0, -0x65(%rbp)
leaq 0x69913(%rip), %rsi     # 0x11be38
leaq -0x619ac(%rip), %rdx    # 0x50b80
callq 0xb9f0
jmp 0xb2595
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xb256d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xb2564
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbb98
leaq -0x50(%rbp), %rdi
callq 0xbb98
leaq -0x51(%rbp), %rdi
callq 0xb600
testb $0x1, -0x65(%rbp)
jne 0xb257e
jmp 0xb258a
movq -0x88(%rbp), %rdi
callq 0xb460
jmp 0xb258c
movq -0x60(%rbp), %rdi
callq 0xba60
nopw %cs:(%rax,%rax)
nop
// File: bitwiseshiftleft[P]crandom/bench.cpp
// Function: print_features(unsigned int)
void print_features(unsigned int features) {
  printf("features:%s%s%s%s\n",
         (features & SSE2)  ? " SSE2"  : "",
         (features & SSSE3) ? " SSSE3" : "",
         (features & AESNI) ? " AESNI" : "",
         (features & XOP)   ? " XOP"   : "");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %ecx
andl $0x2, %ecx
leaq 0x3d6c(%rip), %rsi      # 0x6084
leaq 0x3d04(%rip), %rax      # 0x6023
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movl -0x4(%rbp), %ecx
andl $0x4, %ecx
leaq 0x3d51(%rip), %rdx      # 0x6084
leaq 0x3cef(%rip), %rax      # 0x6029
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movl -0x4(%rbp), %edi
andl $0x8, %edi
leaq 0x3d36(%rip), %rcx      # 0x6084
leaq 0x3cdb(%rip), %rax      # 0x6030
cmpl $0x0, %edi
cmovneq %rax, %rcx
movl -0x4(%rbp), %edi
andl $0x10, %edi
leaq 0x3d1b(%rip), %r8       # 0x6084
leaq 0x3cc7(%rip), %rax      # 0x6037
cmpl $0x0, %edi
cmovneq %rax, %r8
leaq 0x3c92(%rip), %rdi      # 0x6010
movb $0x0, %al
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: bitwiseshiftleft[P]crandom/bench.cpp
// Function: main
int main(int argc, char **argv) {
  (void) argc; (void) argv;
  crandom_features = crandom_detect_features();
  
  test<chacha, SSE2 | SSSE3 | XOP, SSE2 | SSSE3 | XOP>(1000000);
  test<chacha, SSE2 | SSSE3, SSE2 | SSSE3 | XOP>(1000000);
  test<chacha, SSE2, SSE2 | SSSE3 | XOP>(1000000);
  test<chacha, 0, SSE2 | SSSE3 | XOP>(1000000);
  
  test<aes, AESNI, AESNI>(1000000);
  test<aes, 0, AESNI>(1000000);
  
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x56f0
movl %eax, %ecx
leaq 0x618c(%rip), %rax      # 0x8540
movl %ecx, (%rax)
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x24c0
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x2710
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x2960
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x2bb0
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x2df0
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x3040
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk-extras/exprtk_gcd.cpp
// Function: double gcd_println<double>(double, double, double)
T gcd_println(T x, T y, T z)
{
   printf("gcd(%2d,%2d) = %2d\n",
          static_cast<int>(x),
          static_cast<int>(y),
          static_cast<int>(z));

   return T(0);
}

// Assembly:
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, (%rsp)
cvttsd2si 0x10(%rsp), %esi
cvttsd2si 0x8(%rsp), %edx
cvttsd2si (%rsp), %ecx
leaq 0x3475b2(%rip), %rdi    # 0x46378f
movb $0x0, %al
callq 0x114080
xorps %xmm0, %xmm0
addq $0x18, %rsp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/string_size3.cc
// Function: main
int main() 
{
	string line;

	// read input a line at a time and discard blank lines
	while (getline(cin, line))
		if (!line.empty())
			cout << line << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1090
movq 0x2db1(%rip), %rdi      # 0x3fe0
leaq -0x28(%rbp), %rsi
callq 0x1030
movq %rax, -0x40(%rbp)
jmp 0x123e
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x1080
movb %al, -0x41(%rbp)
jmp 0x1256
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x125f
jmp 0x12b2
leaq -0x28(%rbp), %rdi
callq 0x10b0
testb $0x1, %al
jne 0x12ad
movq 0x2d5d(%rip), %rdi      # 0x3fd0
leaq -0x28(%rbp), %rsi
callq 0x1060
movq %rax, -0x50(%rbp)
jmp 0x1282
movq -0x50(%rbp), %rdi
movq 0x2d33(%rip), %rsi      # 0x3fc0
callq 0x1070
jmp 0x1294
jmp 0x12ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1040
jmp 0x12cb
jmp 0x1228
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1040
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x10c0
// File: bigtit[P]ps3patcher/pbase.cc
// Function: pbase::swap_bytes(std::vector<char, std::allocator<char>>&)
bool pbase::swap_bytes(std::vector<byte>& pdata){
  if(!pdata.size()%2) return false;
  for(int i=0; i<pdata.size(); i+=2)
    std::swap(pdata[i], pdata[i+1]);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2be0
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x2b66
movb $0x0, -0x1(%rbp)
jmp 0x2bc8
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2be0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x2bc4
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x2c30
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x2c30
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x2c00
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0x2b6d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: bigtit[P]ps3patcher/patcher.cc
// Function: patcher::get_pdata(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void patcher::get_pdata(string name, bool swap){
  std::ifstream freader(name.c_str(), std::ios::binary|std::ios::ate);
  freader >> std::noskipws;
  auto pos = freader.tellg();
  std::vector<byte> tmp(pos);

  freader.seekg(0, std::ios::beg);
  freader.read(&tmp[0], pos);
  if(swap) pbase::swap_bytes(tmp); // swap_byte(vector<byte>&, pos_type)

  pdata = std::move(tmp); // c++11 dafahao
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rsi, -0x280(%rbp)
movq %rdi, %rcx
movq -0x280(%rbp), %rdi
movb %dl, %al
movq %rcx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x278(%rbp)
callq 0x20b0
movq %rax, -0x270(%rbp)
movl $0x4, %edi
movl $0x2, %esi
callq 0x40c0
movq -0x270(%rbp), %rsi
movl %eax, %edx
leaq -0x220(%rbp), %rdi
movq %rdi, -0x268(%rbp)
callq 0x2300
movq -0x268(%rbp), %rdi
leaq 0x12e5(%rip), %rsi      # 0x40e0
callq 0x22a0
jmp 0x2e02
leaq -0x220(%rbp), %rdi
callq 0x22c0
movq %rdx, -0x290(%rbp)
movq %rax, -0x288(%rbp)
jmp 0x2e1e
movq -0x290(%rbp), %rax
movq -0x288(%rbp), %rcx
movq %rcx, -0x240(%rbp)
movq %rax, -0x238(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x4110
movq %rax, -0x298(%rbp)
jmp 0x2e4f
leaq -0x259(%rbp), %rdi
movq %rdi, -0x2a0(%rbp)
callq 0x22e0
movq -0x298(%rbp), %rsi
movq -0x2a0(%rbp), %rdx
leaq -0x258(%rbp), %rdi
callq 0x4130
jmp 0x2e7e
leaq -0x259(%rbp), %rdi
callq 0x21d0
xorl %edx, %edx
movl %edx, %esi
leaq -0x220(%rbp), %rdi
callq 0x2220
jmp 0x2e9c
xorl %eax, %eax
movl %eax, %esi
leaq -0x258(%rbp), %rdi
callq 0x2c30
movq %rax, -0x2b0(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x4110
movq %rax, -0x2a8(%rbp)
jmp 0x2ec8
movq -0x2a8(%rbp), %rdx
movq -0x2b0(%rbp), %rsi
leaq -0x220(%rbp), %rdi
callq 0x2200
jmp 0x2ee4
testb $0x1, -0x11(%rbp)
je 0x2f4e
leaq -0x258(%rbp), %rdi
callq 0x2b30
jmp 0x2ef8
jmp 0x2f4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x2f82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x259(%rbp), %rdi
callq 0x21d0
jmp 0x2f82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x258(%rbp), %rdi
callq 0x4060
jmp 0x2f82
movq -0x278(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x41a0
leaq -0x258(%rbp), %rdi
callq 0x4060
leaq -0x220(%rbp), %rdi
callq 0x2070
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbp
retq
leaq -0x220(%rbp), %rdi
callq 0x2070
movq -0x228(%rbp), %rdi
callq 0x22d0
nopw (%rax,%rax)
// File: kryffin[P]software-rasterizer/./geometry.cpp
// Function: projectionMatrix(float, float, float, float, float)
Mat4f projectionMatrix (float near, float far, float fov, float width, float height) {
    float aspectRatio = (float)height / (float)width;
    float fovRad = 1.f / tanf((fov / 2.f) * (M_PI / 180.f));

    Mat4f P;

    P.m[0][0] = fovRad;
    P.m[1][1] = fovRad;
    P.m[2][2] = -(far / (far - near));
    P.m[2][3] = (far * near) / (far - near);
    P.m[3][2] = -1.f;
    P.m[3][3] = 0.f;

    return P;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movss %xmm3, -0x10(%rbp)
movss %xmm4, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
divss -0x10(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movss -0xc(%rbp), %xmm0
movss 0x8a27(%rip), %xmm1     # 0xb00c
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x8a63(%rip), %xmm1     # 0xb058
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x22c0
movq -0x30(%rbp), %rdi
movaps %xmm0, %xmm1
movss 0x89f7(%rip), %xmm0     # 0xb008
divss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
callq 0x51d0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movss -0x1c(%rbp), %xmm0
movss %xmm0, (%rdi)
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0x14(%rdi)
movss -0x8(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
subss -0x4(%rbp), %xmm1
divss %xmm1, %xmm0
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
movss %xmm0, 0x28(%rdi)
movss -0x8(%rbp), %xmm0
mulss -0x4(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
subss -0x4(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x2c(%rdi)
movss 0x897f(%rip), %xmm0     # 0xb004
movss %xmm0, 0x38(%rdi)
xorps %xmm0, %xmm0
movss %xmm0, 0x3c(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kryffin[P]software-rasterizer/./geometry.cpp
// Function: rotationZ(float)
Mat4f rotationZ (float angle) {
	Mat4f out;
	out.m[2][2] = 1.f;
	out.m[0][0] = cosf(angle);
	out.m[1][0] = -sinf(angle);
	out.m[0][1] = sinf(angle);
	out.m[1][1] = cosf(angle);
	out.m[3][3] = 1.f;
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movss %xmm0, -0x4(%rbp)
callq 0x51d0
movq -0x18(%rbp), %rdi
movss 0x855f(%rip), %xmm0     # 0xb008
movss %xmm0, 0x28(%rdi)
movss -0x4(%rbp), %xmm0
callq 0x2150
movq -0x18(%rbp), %rdi
movss %xmm0, (%rdi)
movss -0x4(%rbp), %xmm0
callq 0x2190
movq -0x18(%rbp), %rdi
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, 0x10(%rdi)
movss -0x4(%rbp), %xmm0
callq 0x2190
movq -0x18(%rbp), %rdi
movss %xmm0, 0x4(%rdi)
movss -0x4(%rbp), %xmm0
callq 0x2150
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movss %xmm0, 0x14(%rdi)
movss 0x84f6(%rip), %xmm0     # 0xb008
movss %xmm0, 0x3c(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: kryffin[P]software-rasterizer/./geometry.cpp
// Function: rotationY(float)
Mat4f rotationY (float angle) {
	Mat4f out;
	out.m[1][1] = 1.f;
	out.m[0][0] = cosf(angle);
	out.m[2][0] = sinf(angle);
	out.m[0][2] = -sinf(angle);
	out.m[2][2] = cosf(angle);
	out.m[3][3] = 1.f;
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movss %xmm0, -0x4(%rbp)
callq 0x51d0
movq -0x18(%rbp), %rdi
movss 0x84bf(%rip), %xmm0     # 0xb008
movss %xmm0, 0x14(%rdi)
movss -0x4(%rbp), %xmm0
callq 0x2150
movq -0x18(%rbp), %rdi
movss %xmm0, (%rdi)
movss -0x4(%rbp), %xmm0
callq 0x2190
movq -0x18(%rbp), %rdi
movss %xmm0, 0x20(%rdi)
movss -0x4(%rbp), %xmm0
callq 0x2190
movq -0x18(%rbp), %rdi
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, 0x8(%rdi)
movss -0x4(%rbp), %xmm0
callq 0x2150
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movss %xmm0, 0x28(%rdi)
movss 0x8456(%rip), %xmm0     # 0xb008
movss %xmm0, 0x3c(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: kryffin[P]software-rasterizer/./geometry.cpp
// Function: rotationX(float)
Mat4f rotationX (float angle) {
	Mat4f out;
	out.m[0][0] = 1.f;
	out.m[1][1] = cosf(angle);
	out.m[2][1] = -sinf(angle);
	out.m[1][2] = sinf(angle);
	out.m[2][2] = cosf(angle);
	out.m[3][3] = 1.f;
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movss %xmm0, -0x4(%rbp)
callq 0x51d0
movq -0x18(%rbp), %rdi
movss 0x841f(%rip), %xmm0     # 0xb008
movss %xmm0, (%rdi)
movss -0x4(%rbp), %xmm0
callq 0x2150
movq -0x18(%rbp), %rdi
movss %xmm0, 0x14(%rdi)
movss -0x4(%rbp), %xmm0
callq 0x2190
movq -0x18(%rbp), %rdi
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, 0x24(%rdi)
movss -0x4(%rbp), %xmm0
callq 0x2190
movq -0x18(%rbp), %rdi
movss %xmm0, 0x18(%rdi)
movss -0x4(%rbp), %xmm0
callq 0x2150
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movss %xmm0, 0x28(%rdi)
movss 0x83b6(%rip), %xmm0     # 0xb008
movss %xmm0, 0x3c(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: kryffin[P]software-rasterizer/./geometry.cpp
// Function: scale(float, float, float)
Mat4f scale (float x, float y, float z) {
	Mat4f S;
	S.m[0][0] = x;
	S.m[1][1] = y;
	S.m[2][2] = z;
	S.m[3][3] = 1.f;
	return S;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
callq 0x51d0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movss -0x4(%rbp), %xmm0
movss %xmm0, (%rdi)
movss -0x8(%rbp), %xmm0
movss %xmm0, 0x14(%rdi)
movss -0xc(%rbp), %xmm0
movss %xmm0, 0x28(%rdi)
movss 0x8244(%rip), %xmm0     # 0xb008
movss %xmm0, 0x3c(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: kryffin[P]software-rasterizer/./geometry.cpp
// Function: translation(float, float, float)
Mat4f translation (float x, float y, float z) {
	Mat4f T = Mat4f(1.f);
	T.m[3][0] = x;
	T.m[3][1] = y;
	T.m[3][2] = z;
	return T;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movss 0x820e(%rip), %xmm0     # 0xb008
callq 0x53f0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movss -0x4(%rbp), %xmm0
movss %xmm0, 0x30(%rdi)
movss -0x8(%rbp), %xmm0
movss %xmm0, 0x34(%rdi)
movss -0xc(%rbp), %xmm0
movss %xmm0, 0x38(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kryffin[P]software-rasterizer/rasterizer.cpp
// Function: writeImage(std::vector<int, std::allocator<int>>)
void writeImage (std::vector<int>frameBuffer) {
    std::ofstream file;
    file.open("out.ppm");
    file << "P3" << std::endl << WIDTH << " " << HEIGHT << std::endl << 255 << std::endl;
    int x, y, c;
    for (y = 0; y < HEIGHT; y++) {
        for (x = WIDTH-1; x >= 0; x--) { //reverse course to inverse the rendered image along the x-axis
            for (c = 0; c < 3; c++) {
                file << frameBuffer[((x + (y * WIDTH)) * 3) + c] << " ";
            }
        }
        file << std::endl;
    }
    file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x230(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x208(%rbp), %rdi
movq %rdi, -0x228(%rbp)
callq 0x2330
movq -0x228(%rbp), %rdi
leaq 0x81f9(%rip), %rsi      # 0xb060
movl $0x10, %edx
callq 0x2050
jmp 0x2e73
leaq 0x81ee(%rip), %rsi      # 0xb068
leaq -0x208(%rbp), %rdi
callq 0x21c0
movq %rax, -0x238(%rbp)
jmp 0x2e8f
movq -0x238(%rbp), %rdi
movq 0xd11b(%rip), %rsi      # 0xffb8
callq 0x21f0
movq %rax, -0x240(%rbp)
jmp 0x2eab
movq -0x240(%rbp), %rdi
movl $0x320, %esi            # imm = 0x320
callq 0x2340
movq %rax, -0x248(%rbp)
jmp 0x2ec5
movq -0x248(%rbp), %rdi
leaq 0x8299(%rip), %rsi      # 0xb16c
callq 0x21c0
movq %rax, -0x250(%rbp)
jmp 0x2ee1
movq -0x250(%rbp), %rdi
movl $0x320, %esi            # imm = 0x320
callq 0x2340
movq %rax, -0x258(%rbp)
jmp 0x2efb
movq -0x258(%rbp), %rdi
movq 0xd0af(%rip), %rsi      # 0xffb8
callq 0x21f0
movq %rax, -0x260(%rbp)
jmp 0x2f17
movq -0x260(%rbp), %rdi
movl $0xff, %esi
callq 0x2340
movq %rax, -0x268(%rbp)
jmp 0x2f31
movq -0x268(%rbp), %rdi
movq 0xd079(%rip), %rsi      # 0xffb8
callq 0x21f0
jmp 0x2f46
movl $0x0, -0x21c(%rbp)
cmpl $0x320, -0x21c(%rbp)    # imm = 0x320
jge 0x305e
movl $0x31f, -0x218(%rbp)    # imm = 0x31F
cmpl $0x0, -0x218(%rbp)
jl 0x3033
movl $0x0, -0x220(%rbp)
cmpl $0x3, -0x220(%rbp)
jge 0x301d
movq -0x230(%rbp), %rdi
movl -0x218(%rbp), %ecx
movl -0x21c(%rbp), %eax
imull $0x320, %eax, %eax      # imm = 0x320
addl %eax, %ecx
movl %ecx, %eax
leal (%rax,%rax,2), %eax
movl -0x220(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rsi
callq 0x5590
movl (%rax), %esi
leaq -0x208(%rbp), %rdi
callq 0x2340
movq %rax, -0x270(%rbp)
jmp 0x2fd5
movq -0x270(%rbp), %rdi
leaq 0x8189(%rip), %rsi      # 0xb16c
callq 0x21c0
jmp 0x2fea
jmp 0x2fec
movl -0x220(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x220(%rbp)
jmp 0x2f81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x22e0
jmp 0x3081
jmp 0x301f
movl -0x218(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x218(%rbp)
jmp 0x2f6a
movq 0xcf7e(%rip), %rsi      # 0xffb8
leaq -0x208(%rbp), %rdi
callq 0x21f0
jmp 0x3048
jmp 0x304a
movl -0x21c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x21c(%rbp)
jmp 0x2f50
leaq -0x208(%rbp), %rdi
callq 0x22a0
jmp 0x306c
leaq -0x208(%rbp), %rdi
callq 0x22e0
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x210(%rbp), %rdi
callq 0x2350
nopl (%rax)
// File: kryffin[P]software-rasterizer/rasterizer.cpp
// Function: barycenter(Vec3f, Vec3f, Vec3f, Vec3f)
Vec3f barycenter (Vec3f a, Vec3f b, Vec3f c, Vec3f pixel) {
	Vec3f bc = Vec3f();
	bc.x = (c.x-b.x)*(pixel.y-b.y) - (c.y-b.y)*(pixel.x-b.x);
	bc.y = (a.x-c.x)*(pixel.y-c.y) - (a.y-c.y)*(pixel.x-c.x);
	bc.z = (b.x-a.x)*(pixel.y-a.y) - (b.y-a.y)*(pixel.x-a.x);
	return bc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movlpd %xmm0, -0x28(%rbp)
movss %xmm1, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movlpd %xmm2, -0x48(%rbp)
movss %xmm3, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movlpd %xmm4, -0x68(%rbp)
movss %xmm5, -0x60(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
movlpd %xmm6, -0x88(%rbp)
movss %xmm7, -0x80(%rbp)
movl -0x80(%rbp), %eax
movl %eax, -0x70(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x55b0
movss -0x38(%rbp), %xmm4
movss -0x34(%rbp), %xmm5
movss -0x58(%rbp), %xmm0
movss -0x54(%rbp), %xmm1
subss %xmm4, %xmm0
movss -0x78(%rbp), %xmm3
movss -0x74(%rbp), %xmm2
subss %xmm5, %xmm2
subss %xmm5, %xmm1
subss %xmm4, %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x58(%rbp), %xmm4
movss -0x54(%rbp), %xmm5
movss -0x18(%rbp), %xmm0
movss -0x14(%rbp), %xmm1
subss %xmm4, %xmm0
movss -0x78(%rbp), %xmm3
movss -0x74(%rbp), %xmm2
subss %xmm5, %xmm2
subss %xmm5, %xmm1
subss %xmm4, %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x18(%rbp), %xmm4
movss -0x14(%rbp), %xmm5
movss -0x38(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
subss %xmm4, %xmm0
movss -0x78(%rbp), %xmm3
movss -0x74(%rbp), %xmm2
subss %xmm5, %xmm2
subss %xmm5, %xmm1
subss %xmm4, %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x98(%rbp)
movsd -0x98(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kryffin[P]software-rasterizer/rasterizer.cpp
// Function: mix_channels(std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>)
std::vector<int> mix_channels(std::vector<int> buffR, std::vector<int> buffB){
    std::vector<int>frameBuffer(WIDTH * HEIGHT * 3); //vector representing the anaglyph render
    
    //red buffer goes in red channel, blue buffer in blue channel
    for (int x = 0; x < WIDTH; x++) {
        for (int y = 0; y < HEIGHT; y++) {
            frameBuffer[((x + (y * WIDTH)) * 3) + 0] = buffR[x + (y * WIDTH)]; //red
            frameBuffer[((x + (y * WIDTH)) * 3) + 1] = 0; //green
            frameBuffer[((x + (y * WIDTH)) * 3) + 2] = buffB[x + (y * WIDTH)]; //blue
        }
    }

    return frameBuffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x60(%rbp)
movq %rsi, -0x58(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x55e0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movl $0x1d4c00, %esi         # imm = 0x1D4C00
callq 0x5600
jmp 0x48dc
leaq -0x1a(%rbp), %rdi
callq 0x5670
movl $0x0, -0x30(%rbp)
cmpl $0x320, -0x30(%rbp)     # imm = 0x320
jge 0x49e6
movl $0x0, -0x34(%rbp)
cmpl $0x320, -0x34(%rbp)     # imm = 0x320
jge 0x49d6
movq -0x58(%rbp), %rdi
movl -0x30(%rbp), %eax
imull $0x320, -0x34(%rbp), %ecx # imm = 0x320
addl %ecx, %eax
movslq %eax, %rsi
callq 0x5590
movq -0x48(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x68(%rbp)
movl -0x30(%rbp), %eax
imull $0x320, -0x34(%rbp), %ecx # imm = 0x320
addl %ecx, %eax
imull $0x3, %eax, %eax
addl $0x0, %eax
movslq %eax, %rsi
callq 0x5590
movl -0x68(%rbp), %ecx
movq -0x48(%rbp), %rdi
movl %ecx, (%rax)
movl -0x30(%rbp), %eax
imull $0x320, -0x34(%rbp), %ecx # imm = 0x320
addl %ecx, %eax
imull $0x3, %eax, %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x5590
movq -0x60(%rbp), %rdi
movl $0x0, (%rax)
movl -0x30(%rbp), %eax
imull $0x320, -0x34(%rbp), %ecx # imm = 0x320
addl %ecx, %eax
movslq %eax, %rsi
callq 0x5590
movq -0x48(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x64(%rbp)
movl -0x30(%rbp), %eax
imull $0x320, -0x34(%rbp), %ecx # imm = 0x320
addl %ecx, %eax
imull $0x3, %eax, %eax
addl $0x2, %eax
movslq %eax, %rsi
callq 0x5590
movl -0x64(%rbp), %ecx
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4900
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x5670
jmp 0x4a03
jmp 0x49d8
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x48ec
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x49f9
movq -0x48(%rbp), %rdi
callq 0x5f50
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2350
nopl (%rax)
// File: kryffin[P]software-rasterizer/./geometry.cpp
// Function: Vec3f::cross(Vec3f)
Vec3f cross (Vec3f in) {
		return Vec3f(
        		(y * in.z) - (z * in.y),
        		(z * in.x) - (x * in.z),
        		(x * in.y) - (y * in.x)
        	);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movlpd %xmm0, -0x28(%rbp)
movss %xmm1, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movss (%rax), %xmm2
movss 0x4(%rax), %xmm3
movss -0x10(%rbp), %xmm7
movss 0x8(%rax), %xmm1
movss -0x18(%rbp), %xmm5
movss -0x14(%rbp), %xmm4
movaps %xmm1, %xmm6
mulss %xmm4, %xmm6
movaps %xmm3, %xmm0
mulss %xmm7, %xmm0
subss %xmm6, %xmm0
movaps %xmm2, %xmm6
mulss %xmm7, %xmm6
mulss %xmm5, %xmm1
subss %xmm6, %xmm1
mulss %xmm5, %xmm3
mulss %xmm4, %xmm2
subss %xmm3, %xmm2
leaq -0xc(%rbp), %rdi
callq 0x5d40
movl -0x4(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movss -0x38(%rbp), %xmm1
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: kryffin[P]software-rasterizer/./geometry.cpp
// Function: Mat4f::Mat4f(float)
Mat4f (float f) {
		m[0][0] = f;
		m[1][1] = f;
		m[2][2] = f;
		m[3][3] = f;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, (%rcx)
movq %rcx, %rax
addq $0x4, %rax
addq $0x10, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
addq $0x4, %rax
cmpq %rcx, %rax
movq %rax, -0x18(%rbp)
jne 0x5423
movq -0x28(%rbp), %rcx
movq %rcx, %rax
addq $0x10, %rax
addq $0x40, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x2100
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
addq $0x10, %rax
cmpq %rcx, %rax
movq %rax, -0x30(%rbp)
jne 0x5456
movq -0x28(%rbp), %rax
movss -0xc(%rbp), %xmm0
movss %xmm0, (%rax)
movss -0xc(%rbp), %xmm0
movss %xmm0, 0x14(%rax)
movss -0xc(%rbp), %xmm0
movss %xmm0, 0x28(%rax)
movss -0xc(%rbp), %xmm0
movss %xmm0, 0x3c(%rax)
addq $0x40, %rsp
popq %rbp
retq