LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::lexer::lexer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
explicit lexer(const string_t& s) noexcept
            : m_stream(nullptr), m_buffer(s)
        {
            m_content = reinterpret_cast<const lexer_char_t*>(s.c_str());
            assert(m_content != nullptr);
            m_start = m_cursor = m_content;
            m_limit = m_content + s.size();
        }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq $0x0, (%rdi)
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
callq 0x8f440
jmp 0x9c82f
movq 0x10(%rsp), %rax
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x38(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x48(%rax)
movq 0x18(%rsp), %rdi
callq 0x8f110
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
cmpq $0x0, 0x28(%rax)
je 0x9c87b
jmp 0x9c89a
leaq 0x47af0(%rip), %rdi     # 0xe4372
leaq 0x47afe(%rip), %rsi     # 0xe4387
movl $0x1a0f, %edx           # imm = 0x1A0F
leaq 0x47b04(%rip), %rcx     # 0xe4399
callq 0x90c40
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rcx
movq %rcx, 0x40(%rax)
movq %rcx, 0x30(%rax)
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x91060
movq 0x8(%rsp), %rcx
movq %rax, %rdx
movq 0x10(%rsp), %rax
addq %rdx, %rcx
movq %rcx, 0x48(%rax)
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x9b760
nop
// File: alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::json_value::json_value(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::value_t)
json_value(value_t t)
        {
            switch (t)
            {
                case value_t::object:
                {
                    object = create<object_t>();
                    break;
                }

                case value_t::array:
                {
                    array = create<array_t>();
                    break;
                }

                case value_t::string:
                {
                    string = create<string_t>("");
                    break;
                }

                case value_t::boolean:
                {
                    boolean = boolean_t(false);
                    break;
                }

                case value_t::number_integer:
                {
                    number_integer = number_integer_t(0);
                    break;
                }

                case value_t::number_float:
                {
                    number_float = number_float_t(0.0);
                    break;
                }

                default:
                {
                    break;
                }
            }
        }

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movb 0x1f(%rsp), %al
decb %al
movzbl %al, %ecx
movq %rcx, 0x10(%rsp)
subb $0x5, %al
ja 0x9ed35
movq 0x10(%rsp), %rax
leaq 0x4537c(%rip), %rcx     # 0xe4044
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x96410
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0x9ed37
callq 0x8d970
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0x9ed37
leaq 0x45a68(%rip), %rdi     # 0xe4764
callq 0x99170
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0x9ed37
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
jmp 0x9ed37
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
jmp 0x9ed37
movq 0x8(%rsp), %rax
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, (%rax)
jmp 0x9ed37
jmp 0x9ed37
addq $0x28, %rsp
retq
nopl (%rax)
// File: alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
reference operator[](const typename object_t::key_type& key)
    {
        // implicitly convert null to object
        if (is_null())
        {
            m_type = value_t::object;
            m_value.object = create<object_t>();
        }

        // [] only works for objects
        if (is_object())
        {
            assert(m_value.object != nullptr);
            return m_value.object->operator[](key);
        }
        else
        {
            throw std::domain_error("cannot use operator[] with " + type_name());
        }
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x979d0
testb $0x1, %al
jne 0x9f5b3
jmp 0x9f5cc
movq 0x10(%rsp), %rax
movb $0x1, (%rax)
callq 0x96410
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rdi
callq 0x8e3c0
testb $0x1, %al
jne 0x9f5dc
jmp 0x9f621
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9f5ea
jmp 0x9f609
leaq 0x456c8(%rip), %rdi     # 0xe4cb9
leaq 0x44d8f(%rip), %rsi     # 0xe4387
movl $0xbc6, %edx            # imm = 0xBC6
leaq 0x451c3(%rip), %rcx     # 0xe47c7
callq 0x90c40
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x68(%rsp), %rsi
callq 0x91e00
addq $0x78, %rsp
retq
movb $0x1, 0x1b(%rsp)
movl $0x10, %edi
callq 0x8f970
movq 0x10(%rsp), %rsi
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x95540
jmp 0x9f646
leaq 0x4528b(%rip), %rsi     # 0xe48d8
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x97a00
jmp 0x9f65e
movq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x94700
jmp 0x9f66f
movq 0x8(%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0x665a8(%rip), %rsi     # 0x105c28
movq 0x666b9(%rip), %rdx     # 0x105d40
callq 0x97c60
jmp 0x9f6ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x9f6d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x9f6c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x99830
leaq 0x28(%rsp), %rdi
callq 0x99830
testb $0x1, 0x1b(%rsp)
jne 0x9f6d9
jmp 0x9f6e3
movq 0x8(%rsp), %rdi
callq 0x911a0
jmp 0x9f6e5
movq 0x20(%rsp), %rdi
callq 0x981c0
nop
// File: alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::push_back(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>&&)
void push_back(basic_json&& val)
    {
        // push_back only works for null objects or arrays
        if (not(is_null() or is_array()))
        {
            throw std::domain_error("cannot use push_back() with " + type_name());
        }

        // transform null object into an array
        if (is_null())
        {
            m_type = value_t::array;
            m_value = value_t::array;
        }

        // add element to array (move semantics)
        assert(m_value.array != nullptr);
        m_value.array->push_back(std::move(val));
        // invalidate object
        val.m_type = value_t::null;
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x979d0
testb $0x1, %al
jne 0x9f7ed
movq 0x8(%rsp), %rdi
callq 0x960f0
testb $0x1, %al
jne 0x9f7ed
movb $0x1, 0x1b(%rsp)
movl $0x10, %edi
callq 0x8f970
movq 0x8(%rsp), %rsi
movq %rax, (%rsp)
leaq 0x28(%rsp), %rdi
callq 0x95540
jmp 0x9f74b
leaq 0x451cd(%rip), %rsi     # 0xe491f
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x97a00
jmp 0x9f763
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x94700
jmp 0x9f773
movq (%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0x664a5(%rip), %rsi     # 0x105c28
movq 0x665b6(%rip), %rdx     # 0x105d40
callq 0x97c60
jmp 0x9f879
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x9f7d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x9f7cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x99830
leaq 0x28(%rsp), %rdi
callq 0x99830
testb $0x1, 0x1b(%rsp)
jne 0x9f7df
jmp 0x9f7e8
movq (%rsp), %rdi
callq 0x911a0
jmp 0x9f86f
movq 0x8(%rsp), %rdi
callq 0x979d0
testb $0x1, %al
jne 0x9f7fd
jmp 0x9f822
movq 0x8(%rsp), %rax
movb $0x2, (%rax)
leaq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x93130
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9f830
jmp 0x9f84f
leaq 0x455fb(%rip), %rdi     # 0xe4e32
leaq 0x44b49(%rip), %rsi     # 0xe4387
movl $0x10da, %edx           # imm = 0x10DA
leaq 0x450f2(%rip), %rcx     # 0xe493c
callq 0x90c40
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x68(%rsp), %rsi
callq 0x92540
movq 0x68(%rsp), %rax
movb $0x0, (%rax)
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x981c0
nopl (%rax)
// File: alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::lexer::get_number() const
number_float_t get_number() const
        {
            // conversion
            typename string_t::value_type* endptr;
            assert(m_start != nullptr);
            number_float_t float_val = str_to_float_t(static_cast<number_float_t*>(nullptr), &endptr);

            // return float_val if the whole number was translated and NAN
            // otherwise
            return (reinterpret_cast<lexer_char_t*>(endptr) == m_cursor) ? float_val : NAN;
        }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x30(%rax)
je 0x9f8bc
jmp 0x9f8db
leaq 0x44bcc(%rip), %rdi     # 0xe448f
leaq 0x44abd(%rip), %rsi     # 0xe4387
movl $0x1e9d, %edx           # imm = 0x1E9D
leaq 0x451d8(%rip), %rcx     # 0xe4aae
callq 0x90c40
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x18(%rsp), %rdx
callq 0x8e060
movq 0x8(%rsp), %rcx
vmovsd %xmm0, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x40(%rcx), %rax
jne 0x9f911
vmovsd 0x10(%rsp), %xmm0
vmovsd %xmm0, (%rsp)
jmp 0x9f920
vmovsd 0x446ef(%rip), %xmm0    # 0xe4008
vmovsd %xmm0, (%rsp)
jmp 0x9f920
vmovsd (%rsp), %xmm0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: alfanick[P]rest-cpp/src/rest/json.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>* nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::create<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [1]>(char const (&) [1])
static T* create(Args&& ... args)
    {
        AllocatorType<T> alloc;
        auto deleter = [&](T * object)
        {
            alloc.deallocate(object, 1);
        };
        std::unique_ptr<T, decltype(deleter)> object(alloc.allocate(1), deleter);
        alloc.construct(object.get(), std::forward<Args>(args)...);
        return object.release();
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x8e0f0
movq 0x10(%rsp), %rdi
movq %rdi, 0x40(%rsp)
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %esi
callq 0x8e9b0
movq %rax, 0x18(%rsp)
jmp 0x9fd17
movq 0x18(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x40(%rsp), %rdx
callq 0x90940
movq 0x8(%rsp), %rdi
callq 0x93f80
movq %rax, %rsi
movq 0x50(%rsp), %rdx
leaq 0x4f(%rsp), %rdi
callq 0x8d040
jmp 0x9fd4e
leaq 0x30(%rsp), %rdi
callq 0x8e6c0
movq %rax, (%rsp)
leaq 0x30(%rsp), %rdi
callq 0x90dc0
leaq 0x4f(%rsp), %rdi
callq 0x8deb0
movq (%rsp), %rax
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x9fda1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x90dc0
leaq 0x4f(%rsp), %rdi
callq 0x8deb0
movq 0x28(%rsp), %rdi
callq 0x981c0
nopw %cs:(%rax,%rax)
nop
// File: alfanick[P]rest-cpp/src/rest/utils.h
// Function: int REST::Utils::parse_string<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
R parse_string(const S& str) {
  std::stringstream buf;
  buf << str;
  R val;
  buf >> val;
  return val;
}

// Assembly:
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, 0x1a0(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x91140
leaq 0x28(%rsp), %rdi
movq 0x1a0(%rsp), %rsi
callq 0x925d0
jmp 0xa5f5d
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x90860
jmp 0xa5f6e
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x91450
movl 0x4(%rsp), %eax
addq $0x1a8, %rsp            # imm = 0x1A8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x91450
movq 0x10(%rsp), %rdi
callq 0x981c0
nop
// File: alfanick[P]rest-cpp/src/rest/router.cpp
// Function: REST::Router::match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::function<void (REST::LambdaService*)>)
void Router::match(std::string path, LambdaService::function lambda) {
    auto r = to_regex(path, false);

    std::vector<Service*> services;
    services.resize(Worker::POOL_SIZE);
    for (int i = 0; i < Worker::POOL_SIZE; i++)
      services[i] = new LambdaService(lambda);

    path = nested_path(path);

    routes.emplace_back(r, path, services);
  }

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movq %rsi, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdx, 0x120(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0xc8(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x8f440
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0xe8(%rsp), %rdi
xorl %ecx, %ecx
callq 0x8db80
jmp 0xa7cc3
leaq 0xc8(%rsp), %rdi
callq 0x99830
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x93950
movq 0x28(%rsp), %rdi
movq 0x5de72(%rip), %rax     # 0x105b60
movslq (%rax), %rsi
callq 0x97fc0
jmp 0xa7cf8
movl $0x0, 0x9c(%rsp)
movl 0x9c(%rsp), %eax
movq 0x5de4f(%rip), %rcx     # 0x105b60
cmpl (%rcx), %eax
jge 0xa7e48
movl $0x98, %edi
callq 0x930f0
movq %rax, 0x20(%rsp)
jmp 0xa7d2a
movq 0x38(%rsp), %rsi
movb $0x1, 0x77(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x99250
jmp 0xa7d40
movq 0x20(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x93e80
jmp 0xa7d51
movq 0x20(%rsp), %rcx
movb $0x0, 0x77(%rsp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, 0x18(%rsp)
je 0xa7d79
movq 0x20(%rsp), %rax
movq (%rax), %rcx
addq -0x18(%rcx), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movslq 0x9c(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
callq 0x8f790
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
leaq 0x78(%rsp), %rdi
callq 0x94630
movl 0x9c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x9c(%rsp)
jmp 0xa7d03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0x99830
jmp 0xa7ed9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0xa7ebf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0xa7e33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x94630
testb $0x1, 0x77(%rsp)
jne 0xa7e3c
jmp 0xa7e46
movq 0x20(%rsp), %rdi
callq 0x92ca0
jmp 0xa7ebf
movq 0x30(%rsp), %rdx
movq 0x40(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x95030
jmp 0xa7e5e
movq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0x94870
movq 0x8(%rsp), %rdi
callq 0x99830
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rdx
leaq 0xe8(%rsp), %rsi
leaq 0xa0(%rsp), %rcx
callq 0x8e940
jmp 0xa7e9d
leaq 0xa0(%rsp), %rdi
callq 0x997a0
leaq 0xe8(%rsp), %rdi
callq 0x8f120
addq $0x138, %rsp            # imm = 0x138
retq
leaq 0xa0(%rsp), %rdi
callq 0x997a0
leaq 0xe8(%rsp), %rdi
callq 0x8f120
movq 0xc0(%rsp), %rdi
callq 0x981c0
nopw %cs:(%rax,%rax)
// File: alfanick[P]rest-cpp/src/rest/router.h
// Function: REST::Router::nested_path(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string nested_path(std::string const& path) {
      std::string np;
      for (auto& p : nested_paths)
        np += p;

      return np + path;
    }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x959e0
movq 0x18(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x97720
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x97970
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x952d0
testb $0x1, %al
jne 0xa8a6b
jmp 0xa8ab3
leaq 0x40(%rsp), %rdi
callq 0x98d80
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x94d40
jmp 0xa8a8b
jmp 0xa8a8d
leaq 0x40(%rsp), %rdi
callq 0x93e60
jmp 0xa8a56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x99830
jmp 0xa8ae0
movq 0x8(%rsp), %rdi
movq 0x70(%rsp), %rdx
leaq 0x50(%rsp), %rsi
callq 0x99210
jmp 0xa8ac9
leaq 0x50(%rsp), %rdi
callq 0x99830
movq 0x10(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x981c0
nopw (%rax,%rax)
// File: alfanick[P]rest-cpp/src/rest/utils.cpp
// Function: REST::Utils::random_uuid[abi:cxx11]()
std::string random_uuid() {
  std::string uuid(36, ' ');

  for (int i = 0; i < 36; i++) {
    switch (i) {
      case 8:
      case 13:
      case 18:
      case 23:
        uuid[i] = '-';
        break;
      case 14:
        uuid[i] = '4';
        break;
      case 19:
        uuid[i] = DEC2HEX[rand()%4 + 8];
        break;
      default:
        uuid[i] = DEC2HEX[rand()%16];
    }
  }

  return uuid;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x70(%rsp)
movb $0x0, 0x6f(%rsp)
leaq 0x6e(%rsp), %rdi
movq %rdi, 0x50(%rsp)
callq 0x98200
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rcx
movl $0x24, %esi
movl $0x20, %edx
callq 0x90d00
jmp 0xd4f25
leaq 0x6e(%rsp), %rdi
callq 0x938a0
movl $0x0, 0x58(%rsp)
cmpl $0x24, 0x58(%rsp)
jge 0xd50b6
movl 0x58(%rsp), %eax
movl %eax, 0x3c(%rsp)
subl $0x8, %eax
je 0xd4fb0
jmp 0xd4f51
movl 0x3c(%rsp), %eax
subl $0xd, %eax
je 0xd4fb0
jmp 0xd4f5c
movl 0x3c(%rsp), %eax
subl $0xe, %eax
je 0xd4ff0
jmp 0xd4f6b
movl 0x3c(%rsp), %eax
subl $0x12, %eax
je 0xd4fb0
jmp 0xd4f76
movl 0x3c(%rsp), %eax
subl $0x13, %eax
je 0xd5013
jmp 0xd4f85
movl 0x3c(%rsp), %eax
subl $0x17, %eax
je 0xd4fb0
jmp 0xd505d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x6e(%rsp), %rdi
callq 0x938a0
jmp 0xd50d6
movq 0x48(%rsp), %rdi
movslq 0x58(%rsp), %rsi
callq 0x99640
movq %rax, 0x30(%rsp)
jmp 0xd4fc6
movq 0x30(%rsp), %rax
movb $0x2d, (%rax)
jmp 0xd50a4
movq 0x48(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x99830
jmp 0xd50d6
movq 0x48(%rsp), %rdi
movslq 0x58(%rsp), %rsi
callq 0x99640
movq %rax, 0x28(%rsp)
jmp 0xd5006
movq 0x28(%rsp), %rax
movb $0x34, (%rax)
jmp 0xd50a4
callq 0x8e4c0
movq 0x48(%rsp), %rdi
movl %eax, %edx
addl $0x3, %edx
testl %eax, %eax
movl %eax, %ecx
cmovsl %edx, %ecx
andl $-0x4, %ecx
subl %ecx, %eax
cltq
leaq 0x110d9(%rip), %rcx     # 0xe6110
movb 0x8(%rax,%rcx), %al
movb %al, 0x1f(%rsp)
movslq 0x58(%rsp), %rsi
callq 0x99640
movq %rax, 0x20(%rsp)
jmp 0xd5050
movq 0x20(%rsp), %rax
movb 0x1f(%rsp), %cl
movb %cl, (%rax)
jmp 0xd50a4
callq 0x8e4c0
movq 0x48(%rsp), %rdi
movl %eax, %edx
addl $0xf, %edx
testl %eax, %eax
movl %eax, %ecx
cmovsl %edx, %ecx
andl $-0x10, %ecx
subl %ecx, %eax
cltq
leaq 0x1108f(%rip), %rcx     # 0xe6110
movb (%rax,%rcx), %al
movb %al, 0xf(%rsp)
movslq 0x58(%rsp), %rsi
callq 0x99640
movq %rax, 0x10(%rsp)
jmp 0xd5099
movq 0x10(%rsp), %rax
movb 0xf(%rsp), %cl
movb %cl, (%rax)
jmp 0xd50a6
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0xd4f37
movb $0x1, 0x6f(%rsp)
testb $0x1, 0x6f(%rsp)
jne 0xd50cc
movq 0x48(%rsp), %rdi
callq 0x99830
movq 0x40(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x981c0
// File: alfanick[P]rest-cpp/src/rest/utils.cpp
// Function: REST::Utils::rfc1123_datetime[abi:cxx11](long)
std::string rfc1123_datetime( time_t time ) {
  struct tm * timeinfo;
  char buffer [80];

  timeinfo = gmtime ( &time );
  strftime (buffer,80,"%a, %d %b %Y %H:%M:%S GMT",timeinfo);

  return buffer;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x92460
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rcx
leaq 0x10eb8(%rip), %rdx     # 0xe6220
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x50, %esi
callq 0x91c40
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x98200
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x95700
jmp 0xd53a1
leaq 0x3f(%rsp), %rdi
callq 0x938a0
movq 0x8(%rsp), %rax
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x938a0
movq 0x30(%rsp), %rdi
callq 0x981c0
nopw (%rax,%rax)
// File: alfanick[P]rest-cpp/src/rest/service.cpp
// Function: REST::Service::make_action()
void Service::make_action() {
    for (auto feature = features.cbegin(); feature != features.cend(); ++feature) {
      (*feature)->feature_push();
    }

    before();

    method(request->method);

    after();

    for (auto feature = features.crbegin(); feature != features.crend(); ++feature) {
      (*feature)->feature_pop();
    }
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
callq 0x8e830
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x97fe0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x90220
testb $0x1, %al
jne 0xd62d9
jmp 0xd62f8
leaq 0x28(%rsp), %rdi
callq 0x99390
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x28(%rsp), %rdi
callq 0x91bc0
jmp 0xd62b1
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
movq 0x10(%rdi), %rax
movl (%rax), %esi
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
leaq 0x18(%rsp), %rdi
callq 0x99720
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
leaq 0x10(%rsp), %rdi
callq 0x92290
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x94e80
testb $0x1, %al
jne 0xd635a
jmp 0xd6379
leaq 0x18(%rsp), %rdi
callq 0x94160
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x18(%rsp), %rdi
callq 0x90d90
jmp 0xd6332
addq $0x38, %rsp
retq
nop
// File: alfanick[P]rest-cpp/src/rest/resource.cpp
// Function: REST::Resource::method(REST::Request::Method)
void Resource::method(Request::Method method) {
  switch (method) {
    case Request::Method::POST:
      create();
      break;
    case Request::Method::GET:
      read();
      break;
    case Request::Method::PATCH:
    case Request::Method::PUT:
      update();
      break;
    case Request::Method::DELETE:
      destroy();
      break;
    default:
      throw HTTP::MethodNotAllowed();
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
movq %rax, 0x10(%rsp)
subq $0x8, %rax
ja 0xd6b4e
movq 0x10(%rsp), %rax
leaq 0xf7b6(%rip), %rcx      # 0xe62c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *(%rax)
jmp 0xd6b8b
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xd6b8b
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0xd6b8b
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0xd6b8b
movl $0x8, %edi
callq 0x8f970
movq %rax, %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x8ffc0
movq (%rsp), %rdi
callq 0x936d0
movq (%rsp), %rdi
movq 0x2f321(%rip), %rsi     # 0x105ea0
movq 0x2f1ea(%rip), %rdx     # 0x105d70
callq 0x97c60
addq $0x28, %rsp
retq
// File: alfanick[P]rest-cpp/src/rest/dispatcher.cpp
// Function: REST::Dispatcher::Dispatcher(int, int)
Dispatcher::Dispatcher(int wc, int sc) : workers_count(wc), streamers_count(sc) {
  Worker::POOL_SIZE = workers_count;
  workers.resize(workers_count);

  for (int i = 0; i < workers_count; i++) {
    workers[i] = new Worker(i, sc);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x2f20e(%rip), %rax     # 0x105e80
addq $0x10, %rax
movq %rax, (%rdi)
movl 0x2c(%rsp), %eax
movl %eax, 0x8(%rdi)
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rdi)
addq $0x10, %rdi
movq %rdi, 0x10(%rsp)
callq 0x97150
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdi
movl 0x8(%rax), %edx
movq 0x2eeb7(%rip), %rcx     # 0x105b60
movl %edx, (%rcx)
movslq 0x8(%rax), %rsi
callq 0x8e190
jmp 0xd6cb6
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0xd6d3f
movl $0xe0, %edi
callq 0x930f0
movq %rax, (%rsp)
jmp 0xd6cdc
movq (%rsp), %rdi
movl 0x18(%rsp), %esi
movl 0x28(%rsp), %edx
callq 0x91410
jmp 0xd6cef
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movslq 0x18(%rsp), %rsi
callq 0x95b20
movq (%rsp), %rcx
movq %rcx, (%rax)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xd6cbe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0xd6d44
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x92ca0
jmp 0xd6d44
addq $0x38, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x8f180
movq 0x20(%rsp), %rdi
callq 0x981c0
nopl (%rax,%rax)
// File: alfanick[P]rest-cpp/src/rest/readerwriterqueue/readerwriterqueue.h
// Function: moodycamel::ReaderWriterQueue<REST::Request::client, 512ul>::~ReaderWriterQueue()
~ReaderWriterQueue()
	{
		// Make sure we get the latest version of all variables from other CPUs:
		fence(memory_order_sync);

		// Destroy any remaining objects in queue and free memory
		Block* frontBlock_ = frontBlock;
		Block* block = frontBlock_;
		do {
			Block* nextBlock = block->next;
			size_t blockFront = block->front;
			size_t blockTail = block->tail;

			for (size_t i = blockFront; i != blockTail; i = (i + 1) & block->sizeMask) {
				auto element = reinterpret_cast<T*>(block->data + i * sizeof(T));
				element->~T();
				(void)element;
			}
			
			auto rawBlock = block->rawThis;
			block->~Block();
			std::free(rawBlock);
			block = nextBlock;
		} while (block != frontBlock_);
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x4, %edi
callq 0x96180
jmp 0xd717f
movq 0x28(%rsp), %rdi
callq 0x96ee0
movq %rax, 0x20(%rsp)
jmp 0xd7190
movq 0x20(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
subq $-0x80, %rdi
callq 0x96ee0
movq %rax, 0x18(%rsp)
jmp 0xd71b9
movq 0x18(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x99670
movq %rax, 0x10(%rsp)
jmp 0xd71d4
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rdi
addq $0x40, %rdi
callq 0x99670
movq %rax, 0x8(%rsp)
jmp 0xd71f3
movq 0x8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x48(%rsp), %rax
je 0xd724c
movq 0x60(%rsp), %rax
movq 0x88(%rax), %rax
imulq $0x88, 0x40(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq 0x60(%rsp), %rcx
andq 0x90(%rcx), %rax
movq %rax, 0x40(%rsp)
jmp 0xd7207
movq 0x60(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x94530
movq 0x58(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
cmpq 0x68(%rsp), %rax
jne 0xd71a4
addq $0x78, %rsp
retq
movq %rax, %rdi
callq 0x9b760
nop
// File: alfanick[P]rest-cpp/src/rest/readerwriterqueue/atomicops.h
// Function: moodycamel::fence(moodycamel::memory_order)
AE_FORCEINLINE void fence(memory_order order)
{
	switch (order) {
		case memory_order_relaxed: break;
		case memory_order_acquire: std::atomic_thread_fence(std::memory_order_acquire); break;
		case memory_order_release: std::atomic_thread_fence(std::memory_order_release); break;
		case memory_order_acq_rel: std::atomic_thread_fence(std::memory_order_acq_rel); break;
		case memory_order_seq_cst: std::atomic_thread_fence(std::memory_order_seq_cst); break;
		default: assert(false);
	}
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x34(%rsp)
movl 0x34(%rsp), %eax
movq %rax, 0x28(%rsp)
subq $0x4, %rax
ja 0xd73c3
movq 0x28(%rsp), %rax
leaq 0xf069(%rip), %rcx      # 0xe6330
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xd73e2
movl $0x2, 0x44(%rsp)
movl 0x44(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x20(%rsp)
subl $0x4, %eax
ja 0xd730d
movq 0x20(%rsp), %rax
leaq 0xf085(%rip), %rcx      # 0xe6380
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xd730d
jmp 0xd730d
jmp 0xd730d
mfence
jmp 0xd73e2
movl $0x3, 0x40(%rsp)
movl 0x40(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x18(%rsp)
subl $0x4, %eax
ja 0xd734a
movq 0x18(%rsp), %rax
leaq 0xf034(%rip), %rcx      # 0xe636c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xd734a
jmp 0xd734a
jmp 0xd734a
mfence
jmp 0xd73e2
movl $0x4, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x4, %eax
ja 0xd7387
movq 0x10(%rsp), %rax
leaq 0xefe3(%rip), %rcx      # 0xe6358
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xd7387
jmp 0xd7387
jmp 0xd7387
mfence
jmp 0xd73e2
movl $0x5, 0x38(%rsp)
movl 0x38(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x4, %eax
ja 0xd73c1
movq 0x8(%rsp), %rax
leaq 0xef95(%rip), %rcx      # 0xe6344
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xd73c1
jmp 0xd73c1
jmp 0xd73c1
mfence
jmp 0xd73e2
leaq 0xefde(%rip), %rdi      # 0xe63a8
leaq 0xefdd(%rip), %rsi      # 0xe63ae
movl $0xc9, %edx
leaq 0xeff8(%rip), %rcx      # 0xe63d5
callq 0x90c40
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: alfanick[P]rest-cpp/src/rest/worker.cpp
// Function: REST::Worker::Worker(int, int)
Worker::Worker(int i, int sc) :
 id(i), streamers_count(sc), clients_queue(1024) {
  THREAD_NAME("rest-cpp - main thread");
  clients_count.store(0);
  server_header = "rest-cpp, worker " + std::to_string(id);
  streamers.reserve(sc);
  run();
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0x98(%rsp)
movl %esi, 0x94(%rsp)
movl %edx, 0x90(%rsp)
movq 0x98(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq $0x0, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, 0x18(%rsp)
callq 0x959e0
movq 0x30(%rsp), %rdi
movl 0x94(%rsp), %eax
movl %eax, 0x30(%rdi)
movl 0x90(%rsp), %eax
movl %eax, 0x38(%rdi)
addq $0x40, %rdi
movq %rdi, 0x20(%rsp)
callq 0x8ec90
movq 0x30(%rsp), %rdi
addq $0x48, %rdi
movq %rdi, 0x28(%rsp)
callq 0x93850
movq 0x30(%rsp), %rdi
addq $0x60, %rdi
movq %rdi, 0x38(%rsp)
movl $0x400, %esi            # imm = 0x400
callq 0x978e0
jmp 0xd8354
callq 0x92640
movq %rax, %rdi
leaq 0xe14d(%rip), %rsi      # 0xe64b0
callq 0x94370
movq 0x30(%rsp), %rax
movq %rax, 0xb0(%rsp)
movl $0x0, 0xac(%rsp)
movl $0x5, 0xa8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0xa8(%rsp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x8d340
movl %eax, 0xa4(%rsp)
movl 0xa8(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0xac(%rsp), %ecx
movl %ecx, 0xa0(%rsp)
subl $0x3, %eax
je 0xd83eb
jmp 0xd83d0
movl 0x14(%rsp), %eax
subl $0x5, %eax
je 0xd83fb
jmp 0xd83db
movq 0x8(%rsp), %rax
movl 0xa0(%rsp), %ecx
movl %ecx, (%rax)
jmp 0xd8409
movq 0x8(%rsp), %rax
movl 0xa0(%rsp), %ecx
movl %ecx, (%rax)
jmp 0xd8409
movq 0x8(%rsp), %rcx
movl 0xa0(%rsp), %eax
xchgl %eax, (%rcx)
movq 0x30(%rsp), %rax
movl 0x30(%rax), %esi
leaq 0x40(%rsp), %rdi
callq 0x950d0
jmp 0xd841d
leaq 0xe0a3(%rip), %rsi      # 0xe64c7
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x97a00
jmp 0xd8435
movq 0x30(%rsp), %rdi
addq $0x10, %rdi
leaq 0x60(%rsp), %rsi
movq %rsi, (%rsp)
callq 0x94870
movq (%rsp), %rdi
callq 0x99830
leaq 0x40(%rsp), %rdi
callq 0x99830
movq 0x30(%rsp), %rdi
addq $0x48, %rdi
movslq 0x90(%rsp), %rsi
callq 0x953b0
jmp 0xd8477
movq 0x30(%rsp), %rdi
callq 0x903c0
jmp 0xd8483
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0xd84df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0xd84d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x99830
movq 0x38(%rsp), %rdi
callq 0x8f300
movq 0x28(%rsp), %rdi
callq 0x8d730
movq 0x20(%rsp), %rdi
callq 0x96b60
movq 0x18(%rsp), %rdi
callq 0x99830
movq 0x88(%rsp), %rdi
callq 0x981c0
nopw (%rax,%rax)
// File: alfanick[P]rest-cpp/src/rest/worker.cpp
// Function: REST::Worker::make_action(REST::Request&, REST::Response&)
void Worker::make_action(Request &request, Response &response) {
  Service* service = Router::find(request, id);

  if (service == nullptr)
    throw HTTP::NotFound();

  service->request = &request;
  service->response = &response;

  service->make_action();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rdi
movl 0x30(%rax), %esi
callq 0x96060
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xd86cf
movl $0x8, %edi
callq 0x8f970
movq %rax, %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x8ffc0
movq (%rsp), %rdi
callq 0x8d200
movq (%rsp), %rdi
movq 0x2d7f5(%rip), %rsi     # 0x105eb8
movq 0x2d5ee(%rip), %rdx     # 0x105cb8
callq 0x97c60
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rdi
callq 0x95270
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: alfanick[P]rest-cpp/src/rest/worker.cpp
// Function: REST::Worker::stop()
void Worker::stop() {
  should_run = false;
  clear_streamers();
  Request::client c;
  clients_queue.enqueue(c);
  thread.join();
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, (%rsp)
movb $0x0, 0x34(%rdi)
xorl %esi, %esi
callq 0x92c30
movq (%rsp), %rdi
addq $0x60, %rdi
leaq 0x8(%rsp), %rsi
callq 0x8de80
movq (%rsp), %rdi
addq $0x40, %rdi
callq 0x97c40
addq $0x98, %rsp
retq
nopl (%rax)
// File: alfanick[P]rest-cpp/src/rest/readerwriterqueue/readerwriterqueue.h
// Function: moodycamel::BlockingReaderWriterQueue<REST::Request::client, 512ul>::enqueue(REST::Request::client const&)
AE_FORCEINLINE bool enqueue(T const& element)
	{
		if (inner.enqueue(element)) {
			sema.signal();
			return true;
		}
		return false;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
callq 0x91800
testb $0x1, %al
jne 0xd9188
jmp 0xd91a2
movq 0x8(%rsp), %rdi
addq $0x58, %rdi
movl $0x1, %esi
callq 0x96650
movb $0x1, 0x27(%rsp)
jmp 0xd91a7
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: alfanick[P]rest-cpp/src/rest/worker.cpp
// Function: REST::Worker::clear_streamers(bool)
void Worker::clear_streamers(bool force) {
  if (streamers.size() >= streamers_count || force)  {
    for (auto& s : streamers)
      s.join();
    streamers.clear();
  }
}

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x48, %rdi
callq 0x93e30
movq (%rsp), %rcx
movl 0x38(%rcx), %ecx
cmpq %rcx, %rax
jae 0xd9337
testb $0x1, 0x2f(%rsp)
je 0xd93a9
movq (%rsp), %rax
addq $0x48, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x8fc30
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x91330
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x99440
testb $0x1, %al
jne 0xd9377
jmp 0xd939c
leaq 0x18(%rsp), %rdi
callq 0x97e60
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x97c40
leaq 0x18(%rsp), %rdi
callq 0x95d00
jmp 0xd9362
movq (%rsp), %rdi
addq $0x48, %rdi
callq 0x97cf0
addq $0x38, %rsp
retq
nop
// File: alfanick[P]rest-cpp/src/rest/readerwriterqueue/readerwriterqueue.h
// Function: moodycamel::ReaderWriterQueue<REST::Request::client, 512ul>::ceilToPow2(unsigned long)
AE_FORCEINLINE static size_t ceilToPow2(size_t x)
	{
		// From http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
		--x;
		x |= x >> 1;
		x |= x >> 2;
		x |= x >> 4;
		for (size_t i = 1; i < sizeof(size_t); i <<= 1) {
			x |= x >> (i << 3);
		}
		++x;
		return x;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x2, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x4, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq $0x1, -0x10(%rsp)
cmpq $0x8, -0x10(%rsp)
jae 0xd9be6
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
shlq $0x3, %rcx
shrq %cl, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x10(%rsp), %rax
shlq %rax
movq %rax, -0x10(%rsp)
jmp 0xd9bb4
movq -0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: alfanick[P]rest-cpp/src/rest/readerwriterqueue/readerwriterqueue.h
// Function: moodycamel::ReaderWriterQueue<REST::Request::client, 512ul>::make_block(unsigned long)
static Block* make_block(size_t capacity)
	{
		// Allocate enough memory for the block itself, as well as all the elements it will contain
		auto size = sizeof(Block) + std::alignment_of<Block>::value - 1;
		size += sizeof(T) * capacity + std::alignment_of<T>::value - 1;
		auto newBlockRaw = static_cast<char*>(std::malloc(size));
		if (newBlockRaw == nullptr) {
			return nullptr;
		}
		
		auto newBlockAligned = align_for<Block>(newBlockRaw);
		auto newBlockData = align_for<T>(newBlockAligned + sizeof(Block));
		return new (newBlockAligned) Block(capacity, newBlockRaw, newBlockData);
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq $0xa7, 0x20(%rsp)
imulq $0x88, 0x28(%rsp), %rax
addq $0x8, %rax
subq $0x1, %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x95310
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xd9c4f
movq $0x0, 0x30(%rsp)
jmp 0xd9c9a
movq 0x18(%rsp), %rdi
callq 0x94ff0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0xa0, %rdi
callq 0x993f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rcx
leaq 0x28(%rsp), %rsi
callq 0x8d850
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: alfanick[P]rest-cpp/src/rest/readerwriterqueue/atomicops.h
// Function: moodycamel::spsc_sema::LightweightSemaphore::signal(long)
void signal(ssize_t count = 1)
		    {
		    	assert(count >= 0);
		        ssize_t oldCount = m_count.fetch_add_release(count);
		        assert(oldCount >= -1);
		        if (oldCount < 0)
		        {
		            m_sema.signal(1);
		        }
		    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jl 0xda542
jmp 0xda561
leaq 0xc395(%rip), %rdi      # 0xe68de
leaq 0xbe5e(%rip), %rsi      # 0xe63ae
movl $0x22a, %edx            # imm = 0x22A
leaq 0xc38d(%rip), %rcx      # 0xe68e9
callq 0x90c40
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x90110
movq %rax, 0x10(%rsp)
cmpq $-0x1, 0x10(%rsp)
jl 0xda57f
jmp 0xda59e
leaq 0xc3a5(%rip), %rdi      # 0xe692b
leaq 0xbe21(%rip), %rsi      # 0xe63ae
movl $0x22c, %edx            # imm = 0x22C
leaq 0xc350(%rip), %rcx      # 0xe68e9
callq 0x90c40
cmpq $0x0, 0x10(%rsp)
jge 0xda5b9
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x971e0
addq $0x28, %rsp
retq
nop
// File: alfanick[P]rest-cpp/src/rest/readerwriterqueue/readerwriterqueue.h
// Function: moodycamel::ReaderWriterQueue<REST::Request::client, 512ul>::ReentrantGuard::ReentrantGuard(bool&)
ReentrantGuard(bool& _inSection)
			: inSection(_inSection)
		{
			assert(!inSection);
			if (inSection) {
				throw std::runtime_error("ReaderWriterQueue does not support enqueuing or dequeuing elements from other elements' ctors and dtors");
			}

			inSection = true;
		}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rax
movb (%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xdaaed
jmp 0xdaaef
jmp 0xdab0e
leaq 0xbce6(%rip), %rdi      # 0xe67dc
leaq 0xb9f2(%rip), %rsi      # 0xe64ef
movl $0x222, %edx            # imm = 0x222
leaq 0xbcde(%rip), %rcx      # 0xe67e7
callq 0x90c40
movq 0x10(%rsp), %rax
movq (%rax), %rax
testb $0x1, (%rax)
je 0xdab70
movl $0x10, %edi
callq 0x8f970
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0xbd3f(%rip), %rsi      # 0xe6876
callq 0x8ef60
jmp 0xdab3e
movq 0x8(%rsp), %rdi
movq 0x2b48e(%rip), %rsi     # 0x105fd8
movq 0x2b267(%rip), %rdx     # 0x105db8
callq 0x97c60
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x911a0
jmp 0xdab80
movq 0x10(%rsp), %rax
movq (%rax), %rax
movb $0x1, (%rax)
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x981c0
nopw (%rax,%rax)
// File: alfanick[P]rest-cpp/src/rest/readerwriterqueue/atomicops.h
// Function: moodycamel::spsc_sema::LightweightSemaphore::tryWait()
bool tryWait()
		    {
		        if (m_count.load() > 0)
		        {
		        	m_count.fetch_add_acquire(-1);
		        	return true;
		        }
		        return false;
		    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x95830
cmpq $0x0, %rax
jle 0xdb5f4
movq (%rsp), %rdi
movq $-0x1, %rsi
callq 0x943f0
movb $0x1, 0x17(%rsp)
jmp 0xdb5f9
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: alfanick[P]rest-cpp/src/rest/readerwriterqueue/atomicops.h
// Function: moodycamel::spsc_sema::LightweightSemaphore::waitWithPartialSpinning()
void waitWithPartialSpinning()
		    {
		        ssize_t oldCount;
		        // Is there a better way to set the initial spin count?
		        // If we lower it to 1000, testBenaphore becomes 15x slower on my Core i7-5930K Windows PC,
		        // as threads start hitting the kernel semaphore.
		        int spin = 10000;
		        while (--spin >= 0)
		        {
		            if (m_count.load() > 0)
		            {
		                m_count.fetch_add_acquire(-1);
		                return;
		            }
		            compiler_fence(memory_order_acquire);     // Prevent the compiler from collapsing the loop.
		        }
		        oldCount = m_count.fetch_add_acquire(-1);
		        if (oldCount <= 0)
		        {
		            m_sema.wait();
		        }
		    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x2710, 0x14(%rsp)     # imm = 0x2710
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, %eax
jl 0xdb66a
movq 0x8(%rsp), %rdi
callq 0x95830
cmpq $0x0, %rax
jle 0xdb65e
movq 0x8(%rsp), %rdi
movq $-0x1, %rsi
callq 0x943f0
jmp 0xdb696
movl $0x1, %edi
callq 0x93c10
jmp 0xdb62b
movq 0x8(%rsp), %rdi
movq $-0x1, %rsi
callq 0x943f0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jg 0xdb696
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x96a90
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: alfanick[P]rest-cpp/src/rest/readerwriterqueue/atomicops.h
// Function: moodycamel::compiler_fence(moodycamel::memory_order)
AE_FORCEINLINE void compiler_fence(memory_order order)
{
	switch (order) {
		case memory_order_relaxed: break;
		case memory_order_acquire: std::atomic_signal_fence(std::memory_order_acquire); break;
		case memory_order_release: std::atomic_signal_fence(std::memory_order_release); break;
		case memory_order_acq_rel: std::atomic_signal_fence(std::memory_order_acq_rel); break;
		case memory_order_seq_cst: std::atomic_signal_fence(std::memory_order_seq_cst); break;
		default: assert(false);
	}
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x34(%rsp)
movl 0x34(%rsp), %eax
movq %rax, 0x28(%rsp)
subq $0x4, %rax
ja 0xdb927
movq 0x28(%rsp), %rax
leaq 0xac15(%rip), %rcx      # 0xe644c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xdb946
movl $0x2, 0x44(%rsp)
movl 0x44(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x20(%rsp)
subl $0x4, %eax
ja 0xdb87a
movq 0x20(%rsp), %rax
leaq 0xac31(%rip), %rcx      # 0xe649c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xdb87a
jmp 0xdb87a
jmp 0xdb87a
jmp 0xdb946
movl $0x3, 0x40(%rsp)
movl 0x40(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x18(%rsp)
subl $0x4, %eax
ja 0xdb8b4
movq 0x18(%rsp), %rax
leaq 0xabe3(%rip), %rcx      # 0xe6488
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xdb8b4
jmp 0xdb8b4
jmp 0xdb8b4
jmp 0xdb946
movl $0x4, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x4, %eax
ja 0xdb8ee
movq 0x10(%rsp), %rax
leaq 0xab95(%rip), %rcx      # 0xe6474
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xdb8ee
jmp 0xdb8ee
jmp 0xdb8ee
jmp 0xdb946
movl $0x5, 0x38(%rsp)
movl 0x38(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x4, %eax
ja 0xdb925
movq 0x8(%rsp), %rax
leaq 0xab4a(%rip), %rcx      # 0xe6460
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xdb925
jmp 0xdb925
jmp 0xdb925
jmp 0xdb946
leaq 0xaa7a(%rip), %rdi      # 0xe63a8
leaq 0xaa79(%rip), %rsi      # 0xe63ae
movl $0xbd, %edx
leaq 0xb0e4(%rip), %rcx      # 0xe6a25
callq 0x90c40
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::empty() const
bool empty() const noexcept
    {
        switch (m_type)
        {
            case value_t::null:
            {
                // null values are empty
                return true;
            }

            case value_t::array:
            {
                assert(m_value.array != nullptr);
                return m_value.array->empty();
            }

            case value_t::object:
            {
                assert(m_value.object != nullptr);
                return m_value.object->empty();
            }

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movb (%rax), %al
movb %al, 0x17(%rsp)
testb %al, %al
je 0xde9c6
jmp 0xde9af
movb 0x17(%rsp), %al
subb $0x1, %al
je 0xdea13
jmp 0xde9b9
movb 0x17(%rsp), %al
subb $0x2, %al
je 0xde9d0
jmp 0xdea56
movb $0x1, 0x27(%rsp)
jmp 0xdea5b
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xde9de
jmp 0xde9fd
leaq 0x644d(%rip), %rdi      # 0xe4e32
leaq 0x599b(%rip), %rsi      # 0xe4387
movl $0xfdd, %edx            # imm = 0xFDD
leaq 0x882a(%rip), %rcx      # 0xe7222
callq 0x90c40
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x97140
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xdea5b
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xdea21
jmp 0xdea40
leaq 0x6291(%rip), %rdi      # 0xe4cb9
leaq 0x5958(%rip), %rsi      # 0xe4387
movl $0xfe3, %edx            # imm = 0xFE3
leaq 0x87e7(%rip), %rcx      # 0xe7222
callq 0x90c40
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x95040
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xdea5b
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)