LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/trisolaris233[P]httpc/src/server.hpp
// Function: httpc::Server::Accept_()
void Accept_() {
            //while (this->atomic_accept_flag_);
            //this->atomic_accept_flag_ = true;
            
            std::shared_ptr<Connection> ptr_conn(new Connection(this->io_context_, this->http_router_));
            acceptor_.async_accept(
                ptr_conn->Socket(), 
                [this, ptr_conn] (boost::system::error_code ec) {
                    if(!ec) {
                        // debug().dg("accept: ").dg(ec.message()).lf();
                        //debug().dg("start").lf();
                        debug().dg("accept and start a connection").lf();
                        ptr_conn->Socket().set_option(boost::asio::ip::tcp::no_delay(true));
                        ptr_conn->Start();
                    } else {
                        // std::cout << "err: " << ec.message() << std::endl;
                    }
                    //this->atomic_accept_flag_ = false;
                    debug().dg("wait for next connection").lf();
                    this->Accept_();
                }
            );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x508, %edi            # imm = 0x508
callq 0x8510
movq %rax, %r14
leaq 0x80(%rbx), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x13dca
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x14b30
movq (%r15), %rdx
movq 0x8(%r15), %rax
movq %rbx, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
addq $0x18, %rdx
movq %rax, -0x20(%rbp)
testq %rax, %rax
je 0x13c0d
movq 0x21389(%rip), %rcx     # 0x34f88
cmpb $0x0, (%rcx)
je 0x13c09
incl 0x8(%rax)
jmp 0x13c0d
lock
incl 0x8(%rax)
movq 0x10(%rbx), %rdi
leaq 0x18(%rbx), %rsi
addq $0x30, %rbx
leaq -0x30(%rbp), %r8
xorl %ecx, %ecx
movq %rbx, %r9
callq 0x14fea
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x13c35
callq 0x11b2a
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x13c43
callq 0x11b2a
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x13c5f
callq 0x11b2a
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x13c7f
callq 0x11b2a
jmp 0x13c7f
movq %rax, %rbx
movl $0x508, %esi            # imm = 0x508
movq %r14, %rdi
callq 0x8520
movq %rbx, %rdi
callq 0x8830
// File: /workspace/github_cpp_makefile_star2_O1/trisolaris233[P]httpc/src/connection.hpp
// Function: httpc::Connection::DoRead()
void DoRead() {
            // set up timer for each call
            this->ActiveKeepAliveTimer();

            // try to read from buffer
            socket_.async_read_some(
                boost::asio::buffer(this->buffer_),
                [this, self = this->shared_from_this()] 
                (boost::system::error_code const& ec, std::size_t bytes_transferred) {
                    // if no error occurs
                    if (!ec) {
                        // handle read.
                        this->HandleRead_(ec, bytes_transferred);
                    } else {
                        if (ec == boost::asio::error::eof) {
                            // this->hand_shake_ = false;
                            debug().dg("shut down send").lf();
                            boost::system::error_code ignore_ec;
                            this->Socket().shutdown(boost::asio::ip::tcp::socket::shutdown_send, ignore_ec);
                        }
                    }
                }
            );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x15820
leaq 0x68(%rbx), %rax
leaq -0x38(%rbp), %r14
movq %rax, (%r14)
movq $0x200, 0x8(%r14)       # imm = 0x200
leaq -0x20(%rbp), %rdi
movq %rbx, -0x8(%rdi)
movq %rbx, %rsi
callq 0x209c2
movq 0x18(%rbx), %rdi
addq $0x28, %rdi
leaq 0x20(%rbx), %rsi
addq $0x38, %rbx
leaq -0x28(%rbp), %r8
movq %r14, %rdx
xorl %ecx, %ecx
movq %rbx, %r9
callq 0x166d4
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x157fd
callq 0x11b2a
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x15817
callq 0x11b2a
movq %rbx, %rdi
callq 0x8830
nop
// File: /workspace/github_cpp_makefile_star2_O1/trisolaris233[P]httpc/src/connection.hpp
// Function: httpc::Connection::ActiveKeepAliveTimer()
void ActiveKeepAliveTimer() {
            //debug().dg("set timer").lf();
            // this->keep_alive_ = true;
            this->keep_alive_timer_.expires_after(std::chrono::seconds{60});
            this->keep_alive_timer_.async_wait([this, self = this->shared_from_this()]
            (boost::system::error_code const& ec) {
                if (ec) {
                    //debug().dg("timer handler: ").dg(ec.message()).lf();
                    return;
                }
                debug().dg("timer handler get closed").lf();
                //std::cout << "no." << this->no << " timer close" << std::endl;
                self->Socket().close();
            });
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
addq $0x498, %rdi            # imm = 0x498
movabsq $0xdf8475800, %rax      # imm = 0xDF8475800
leaq -0x28(%rbp), %r14
movq %rax, (%r14)
movq %r14, %rsi
callq 0x158ae
movq %rbx, (%r14)
leaq -0x20(%rbp), %rdi
movq %rbx, %rsi
callq 0x209c2
movq 0x498(%rbx), %rdi
leaq 0x4a0(%rbx), %rsi
addq $0x4d8, %rbx            # imm = 0x4D8
leaq -0x28(%rbp), %rdx
movq %rbx, %rcx
callq 0x159da
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x1588c
callq 0x11b2a
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x158a6
callq 0x11b2a
movq %rbx, %rdi
callq 0x8830
// File: /workspace/github_cpp_makefile_star2_O1/trisolaris233[P]httpc/src/request_parser.hpp
// Function: std::tuple<httpc::RequestParser::ResultType, char*> httpc::RequestParser::Parse<char*>(httpc::Request&, char*, char*)
std::tuple<ResultType, InputIterator> Parse(Request& request, 
            InputIterator begin, InputIterator end) {
            std::cout << std::string(begin, end) << std::endl;
            ResultType res = kBad;
            for (; begin != end; ++begin) {
                if(ParseRequest(request, *begin) == kGood) {
                    return std::make_tuple(kGood, begin);
                }

            }
            //std::cout << "end of parse" << std::endl;
            return std::make_tuple(kIndeterminate, begin);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, -0x30(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movq %rcx, %rsi
movq %r8, %rdx
callq 0xb0fe
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x1e151(%rip), %rdi     # 0x34f90
callq 0x85b0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x8500
movsbl %al, %esi
movq %r14, %rdi
callq 0x8050
movq %rax, %rdi
callq 0x83b0
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x16e87
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
movl $0x2, %r14d
cmpq %r15, %rbx
je 0x16eac
movsbl (%rbx), %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x177ec
testl %eax, %eax
je 0x16ea9
incq %rbx
jmp 0x16e8d
xorl %r14d, %r14d
movq -0x30(%rbp), %rax
movq %rbx, (%rax)
movl %r14d, 0x8(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x16ee2
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8830
// File: /workspace/github_cpp_makefile_star2_O1/trisolaris233[P]httpc/src/request.hpp
// Function: auto httpc::Request::FindHeader<char const (&) [15]>(char const (&) [15]) const
auto FindHeader(StringT&& str) const {
            for (auto itr = this->HeaderCBegin(); itr != this->HeaderCEnd(); ++itr) {
                if (itr->field == str) {
                    return itr;
                }
            }
            return this->HeaderCEnd();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x98(%rdi), %r14
cmpq 0xa0(%rdi), %r14
sete %r12b
je 0x1716f
movq %rsi, %r15
movq %r14, %rdi
callq 0x81a0
testl %eax, %eax
je 0x1716f
addq $0x40, %r14
movq %r14, %rcx
movq %rcx, %r14
cmpq 0xa0(%rbx), %rcx
sete %r12b
je 0x1716f
movq %r14, %rdi
movq %r15, %rsi
callq 0x81a0
leaq 0x40(%r14), %rcx
testl %eax, %eax
jne 0x1714c
testb %r12b, %r12b
je 0x1717b
movq 0xa0(%rbx), %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/trisolaris233[P]httpc/src/connection.hpp
// Function: httpc::Connection::DoWrite()
void DoWrite()  {
            // auto self{shared_from_this()};
            // std::cout << "write" << std::endl;
            // this->write_buffer_ = response_.ToBuffers();
// #ifdef HTTPC_ENABLE_GZIP 
//             this->response_.WriteGzipBuffer(this->write_buffer_);
//             // this->response_.WriteBuffer(this->write_buffer_);
// #endif
            // std::vector<boost::asio::const_buffer> buffers = this->response_.ToBuffers();
            // for(auto x : buffers) {
            //     std::cout << static_cast<const char*>(x.data()) << std::endl;
            // }
            // std::cout << response_ << std::endl;
            // this->ResetKeepAliveTimer();
            // debug().dg(this->response_).lf();
            // this->ActiveKeepAliveTimer();
            boost::asio::async_write(
                socket_,
                this->response_.ToBuffers(),
                [this, self = this->shared_from_this()]
                (boost::system::error_code ec, std::size_t bytes_transferred) {
                    //std::cout << ec.message() << std::endl;
                    //std::cout << bytes_transferred << std::endl;
                    this->HandleWrite_(ec, bytes_transferred);
                }
            );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x3d0(%rdi), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1ab58
leaq -0x38(%rbp), %rdi
movq %rbx, -0x8(%rdi)
movq %rbx, %rsi
callq 0x209c2
addq $0x18, %rbx
leaq -0x48(%rbp), %rdi
movq %rbx, (%rdi)
leaq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x9(%rbp), %rcx
callq 0x1aefa
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x176a6
callq 0x11b2a
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x176bb
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x8520
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x176d8
callq 0x11b2a
jmp 0x176d8
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x176ed
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8830
nop
// File: /workspace/github_cpp_makefile_star2_O1/trisolaris233[P]httpc/src/connection.hpp
// Function: httpc::Connection::HandleWrite_(boost::system::error_code, unsigned long)
void HandleWrite_(boost::system::error_code ec, std::size_t bytes_transferred) {
            if (this->keep_alive_) {
                this->parser_.Reset();
                this->request_.Reset();
                this->response_.Reset();
                //std::cout << "keep-alive" << std::endl;
                this->DoRead();
            }
            else {
                this->keep_alive_timer_.cancel();
                this->ShutDownSocket_();
                this->Close();
            }
            
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x491(%rdi)
jne 0x1c003
xorl %r14d, %r14d
movl %r14d, 0x288(%rbx)
movl $0x1, 0x290(%rbx)
movq %r14, 0x270(%rbx)
movq 0x268(%rbx), %rax
movb %r14b, (%rax)
movq %r14, 0x2b0(%rbx)
movq 0x2a8(%rbx), %rax
movb %r14b, (%rax)
movq %r14, 0x2d0(%rbx)
movq 0x2c8(%rbx), %rax
movb %r14b, (%rax)
movq %r14, 0x2f0(%rbx)
movq 0x2e8(%rbx), %rax
movb %r14b, (%rax)
leaq 0x308(%rbx), %rdi
callq 0x1c078
movq %r14, 0x338(%rbx)
leaq 0x340(%rbx), %rdi
movq 0x340(%rbx), %rsi
callq 0xb4fe
movq %r14, 0x360(%rbx)
movq 0x358(%rbx), %rax
movb %r14b, (%rax)
leaq 0x378(%rbx), %rdi
movq 0x378(%rbx), %rsi
callq 0x1c0b0
leaq 0x390(%rbx), %rdi
callq 0x149f8
movw $0x0, 0x3c8(%rbx)
movb %r14b, 0x3ca(%rbx)
movq %r14, 0x3d0(%rbx)
movl %r14d, 0x3d8(%rbx)
movq %r14, 0x3e8(%rbx)
movq 0x3e0(%rbx), %rax
movb %r14b, (%rax)
leaq 0x400(%rbx), %rdi
movq 0x400(%rbx), %rsi
callq 0xb4fe
movq %r14, 0x420(%rbx)
movq 0x418(%rbx), %rax
movb %r14b, (%rax)
movq %r14, 0x478(%rbx)
movq 0x470(%rbx), %rax
movb %r14b, (%rax)
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x15798
cmpb $0x1, 0x4a8(%rbx)
jne 0x1c035
movq 0x498(%rbx), %rsi
movq 0x58(%rsi), %rdi
addq $0x28, %rsi
leaq 0x4b0(%rbx), %rdx
movq $-0x1, %rcx
callq 0x14e04
movb $0x0, 0x4a8(%rbx)
leaq -0x20(%rbp), %rcx
movl $0x0, (%rcx)
movb $0x0, 0x4(%rcx)
leaq 0x17796(%rip), %rax     # 0x337e0
movq %rax, 0x8(%rcx)
leaq 0x18(%rbx), %r14
movq 0x18(%rbx), %rdi
addq $0x20, %rbx
movq %rbx, %rsi
movl $0x2, %edx
callq 0x20172
movq %r14, %rdi
callq 0x15ec2
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/trisolaris233[P]httpc/src/connection.hpp
// Function: httpc::Connection::HandleReadBody(boost::system::error_code const&, unsigned long)
void HandleReadBody(boost::system::error_code const& ec, std::size_t bytes_transferred) {
            debug().dg("HandleReadBody() member function").lf();
        
            // debug().dg(this->request_).lf();

            // judge if user would like to receive the next file
            // if (this->request_.RecvNextFileOrNot()) {
            this->parser_.ParseBody(
                this->request_,
                this->buffer_.data(), 
                this->buffer_.data() + bytes_transferred
            );
            this->parser_.ParseFormData(
                this->request_,
                this->buffer_.data(), 
                this->buffer_.data() + bytes_transferred
            );
            debug().dg("parse post body complete").lf();
            // debug().dg(this->request_).lf();
            auto itr = this->response_.FindHeader("Content-Length");
            if (itr != this->response_.HeaderCEnd()) {
                debug().dg("Response Content-Length => ").dg(itr->value).lf();
            }
            // complete the parsement
            this->http_router_.Route(
                this->request_.method,
                this->request_.uri.GetUri(), 
                this->request_, 
                this->response_
            );
            // }
            
            // this->CheckKeepAlive_();

            // this->request_.uri.Update();
                // debug().dg(this->request_.uri.GetUri()).lf();
            
            //debug().dg(this->response_).lf();
            this->handler_.Respond(
                this->request_,
                this->response_
            );
            this->DoWrite();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x268(%rdi), %r15
leaq 0x2a8(%rdi), %r14
leaq 0x68(%rdi), %r12
leaq 0x68(%rdi,%rdx), %r13
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x1c948
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x1d412
leaq 0x3d0(%rbx), %r15
leaq 0x7ebb(%rip), %rsi      # 0x247b9
movq %r15, %rdi
callq 0x1d7fc
movq 0x10(%rbx), %rdi
leaq 0x2e8(%rbx), %rdx
movq %r14, %rsi
movq %r14, %rcx
movq %r15, %r8
callq 0x17188
leaq 0x490(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x234bc
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17650
nop
// File: /workspace/github_cpp_makefile_star2_O1/trisolaris233[P]httpc/src/response.hpp
// Function: decltype(auto) httpc::Response::FindHeader<char const (&) [15]>(char const (&) [15])
decltype(auto) FindHeader(StringT&& field) {
            for (auto itr = this->HeaderCBegin(); itr != this->HeaderCEnd(); ++itr) {
                if (itr->field == field) {
                    return itr;
                }
            }
            return this->HeaderCEnd();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %r14
cmpq 0x38(%rdi), %r14
sete %r12b
je 0x1d84e
movq %rsi, %r15
movq %r14, %rdi
callq 0x81a0
testl %eax, %eax
je 0x1d84e
addq $0x40, %r14
movq %r14, %rcx
movq %rcx, %r14
cmpq 0x38(%rbx), %rcx
sete %r12b
je 0x1d84e
movq %r14, %rdi
movq %r15, %rsi
callq 0x81a0
leaq 0x40(%r14), %rcx
testl %eax, %eax
jne 0x1d82e
testb %r12b, %r12b
je 0x1d857
movq 0x38(%rbx), %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/trisolaris233[P]httpc/src/response.hpp
// Function: void httpc::Response::RenderString<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void RenderString(StringT&& str) {
            this->SetMessageBody_(
                std::forward<StringT>(str)
            );
#ifdef HTTPC_ENABLE_GZIP
            this->AddHeader("Content-Encoding", "gzip");
#endif
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4078, %rsp           # imm = 0x4078
movq %rdi, %rbx
addq $0x48, %rdi
callq 0x8310
movq 0x48(%rbx), %r13
movq 0x50(%rbx), %r12
xorps %xmm0, %xmm0
leaq -0x98(%rbp), %rdi
movups %xmm0, 0x40(%rdi)
movq $0x0, 0x50(%rdi)
leaq 0x262f(%rip), %rax      # 0x247b2
movl $0x1, %esi
movl $0x8, %edx
movl $0x1f, %ecx
movl $0x8, %r8d
xorl %r9d, %r9d
pushq $0x70
pushq %rax
callq 0x8090
addq $0x10, %rsp
testl %eax, %eax
jne 0x2220c
leaq 0xa0(%rbx), %r14
leaq -0x98(%rbp), %r15
movq %r13, (%r15)
movl %r12d, 0x8(%r15)
leaq -0x40a0(%rbp), %r12
movl $0x4000, -0x78(%rbp)    # imm = 0x4000
movq %r12, -0x80(%rbp)
movq %r15, %rdi
movl $0x4, %esi
callq 0x8290
cmpl $-0x2, %eax
je 0x2220c
movl $0x4000, %eax           # imm = 0x4000
subl -0x78(%rbp), %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x80b0
cmpl $0x0, -0x78(%rbp)
je 0x221c7
leaq -0x98(%rbp), %rdi
callq 0x8360
movq %rbx, %rdi
callq 0xb256
leaq 0x2542(%rip), %rsi      # 0x2475d
leaq 0x254c(%rip), %rdx      # 0x2476e
movq %rbx, %rdi
callq 0xb198
addq $0x4078, %rsp           # imm = 0x4078
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/trisolaris233[P]httpc/src/response.hpp
// Function: void httpc::Response::SetMessageBody_<char const (&) [13]>(char const (&) [13])
inline void SetMessageBody_(StringT&& str) {
            this->message_body.assign(
                std::forward<StringT>(str)
            );
            
#ifdef HTTPC_ENABLE_GZIP
            this->GzipEncode();
#endif
            this->SetContentLength_();
            //std::cout << "SetMessageBody_" << std::endl;
            //std::cout << this->message_body << std::endl;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4078, %rsp           # imm = 0x4078
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rdi), %r15
movq 0x50(%rdi), %r12
movq %rsi, %rdi
callq 0x8260
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x8790
movq 0x48(%rbx), %r13
movq 0x50(%rbx), %r12
xorps %xmm0, %xmm0
leaq -0x98(%rbp), %rdi
movups %xmm0, 0x40(%rdi)
movq $0x0, 0x50(%rdi)
leaq 0x21dc(%rip), %rax      # 0x247b2
movl $0x1, %esi
movl $0x8, %edx
movl $0x1f, %ecx
movl $0x8, %r8d
xorl %r9d, %r9d
pushq $0x70
pushq %rax
callq 0x8090
addq $0x10, %rsp
testl %eax, %eax
jne 0x2265f
leaq 0xa0(%rbx), %r14
leaq -0x98(%rbp), %r15
movq %r13, (%r15)
movl %r12d, 0x8(%r15)
leaq -0x40a0(%rbp), %r12
movl $0x4000, -0x78(%rbp)    # imm = 0x4000
movq %r12, -0x80(%rbp)
movq %r15, %rdi
movl $0x4, %esi
callq 0x8290
cmpl $-0x2, %eax
je 0x2265f
movl $0x4000, %eax           # imm = 0x4000
subl -0x78(%rbp), %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x80b0
cmpl $0x0, -0x78(%rbp)
je 0x2261a
leaq -0x98(%rbp), %rdi
callq 0x8360
movq %rbx, %rdi
callq 0xb256
addq $0x4078, %rsp           # imm = 0x4078
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mapbox[P]svg-tools/test/path.hpp
// Function: mapbox::svg::test::operator<<(std::ostream&, std::vector<mapbox::svg::test::PathCommand, std::allocator<mapbox::svg::test::PathCommand>> const&)
::std::ostream& operator<<(::std::ostream& os, const Path& path) {
    os << "Path {" << std::endl;
    for (const auto& command : path) {
        os << "    " << command << "," << std::endl;
    }
    os << "}";
    return os;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x2c3d(%rip), %rsi      # 0x4279
movl $0x6, %edx
callq 0x10f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
movq (%r15), %r14
movq 0x8(%r15), %r13
cmpq %r13, %r14
je 0x16e2
leaq 0x2c00(%rip), %r15      # 0x4280
leaq 0x2bfe(%rip), %r12      # 0x4285
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12f2
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
addq $0x40, %r14
cmpq %r13, %r14
jne 0x1687
leaq 0x2a99(%rip), %rsi      # 0x4182
movl $0x1, %edx
movq %rbx, %rdi
callq 0x10f0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mapbox[P]svg-tools/include/mapbox/svg/path_parser.hpp
// Function: mapbox::svg::PathParser<mapbox::svg::test::PathVertexReceiver>::parseNumber(double&)
bool parseNumber(double& value) {
        if (*cursor) {
            value = strtod(cursor, &next);
            if (cursor != next && value != HUGE_VAL) {
                cursor = next;
                skipSeparator();
                return true;
            }
        }
        error = PathParseErrorType::NumberParsing;
        return false;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
cmpb $0x0, (%rdi)
je 0x30cf
movq %rsi, %r14
leaq 0x18(%rbx), %rsi
callq 0x1080
movsd %xmm0, (%r14)
movq 0x18(%rbx), %rax
cmpq %rax, 0x10(%rbx)
je 0x30cf
ucomisd 0x1013(%rip), %xmm0     # 0x40d0
jae 0x30cf
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
callq 0x36d4
movb $0x1, %al
jmp 0x30d8
movl $0x1, 0x20(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mapbox[P]svg-tools/test/path.hpp
// Function: mapbox::svg::test::PathCommand::operator==(mapbox::svg::test::PathCommand const&) const
bool operator==(const PathCommand& other) const {
        return type == other.type && relative == other.relative &&
               largeArcFlag == other.largeArcFlag && sweepFlag == other.sweepFlag &&
               equals(x, other.x) && equals(y, other.y) && equals(x1, other.x1) &&
               equals(y1, other.y1) && equals(x2, other.x2) && equals(y2, other.y2) &&
               equals(xAxisRotation, other.xAxisRotation);
    }

// Assembly:
movb (%rdi), %al
cmpb (%rsi), %al
jne 0x38a6
movb 0x1(%rdi), %al
cmpb 0x1(%rsi), %al
jne 0x38a6
movb 0x2(%rdi), %al
cmpb 0x2(%rsi), %al
jne 0x38a6
movb 0x3(%rdi), %al
cmpb 0x3(%rsi), %al
jne 0x38a6
movsd 0x8(%rdi), %xmm1
subsd 0x8(%rsi), %xmm1
andpd 0x8de(%rip), %xmm1      # 0x40e0
movsd 0x8ce(%rip), %xmm0      # 0x40d8
ucomisd %xmm1, %xmm0
jbe 0x38a6
movsd 0x10(%rdi), %xmm1
subsd 0x10(%rsi), %xmm1
andpd 0x8ba(%rip), %xmm1      # 0x40e0
ucomisd %xmm1, %xmm0
jbe 0x38a6
movsd 0x18(%rdi), %xmm1
subsd 0x18(%rsi), %xmm1
andpd 0x8a2(%rip), %xmm1      # 0x40e0
ucomisd %xmm1, %xmm0
jbe 0x38a6
movsd 0x20(%rdi), %xmm1
subsd 0x20(%rsi), %xmm1
andpd 0x88a(%rip), %xmm1      # 0x40e0
ucomisd %xmm1, %xmm0
jbe 0x38a6
movsd 0x28(%rdi), %xmm1
subsd 0x28(%rsi), %xmm1
andpd 0x872(%rip), %xmm1      # 0x40e0
ucomisd %xmm1, %xmm0
jbe 0x38a6
movsd 0x30(%rdi), %xmm1
subsd 0x30(%rsi), %xmm1
andpd 0x85a(%rip), %xmm1      # 0x40e0
ucomisd %xmm1, %xmm0
jbe 0x38a6
movsd 0x38(%rdi), %xmm1
subsd 0x38(%rsi), %xmm1
andpd 0x842(%rip), %xmm1      # 0x40e0
ucomisd %xmm1, %xmm0
seta %al
retq
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::operator<<(std::ostream&, to::saved_options const&)::'lambda'(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::ostream& operator<<(std::ostream& out, const saved_options& s) {
        auto escape = [](const std::string& v) {
            if (!v.empty() && v.find_first_of("\\*?[#~=%|^;<>()$'`\" \t\n")==std::string::npos) return v;

            // Wrap string in single quotes, replacing any internal single quote
            // character with: '\''

            std::string q ="'";
            for (auto c: v) {
                c=='\''? q += "'\\''": q += c;
            }
            return q += '\'';
        };

        bool first = true;
        for (auto& p: s) {
            if (first) first = false; else out << ' ';
            out << escape(p);
        }
        return out;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdx)
je 0x3e71
leaq 0x3344(%rip), %rsi      # 0x719c
movl $0x16, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x2200
cmpq $-0x1, %rax
je 0x3f1f
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x3335(%rip), %rsi      # 0x71b6
leaq 0x332f(%rip), %rdx      # 0x71b7
leaq 0x8(%rsp), %rdi
callq 0x4004
movq 0x8(%r14), %r13
testq %r13, %r13
je 0x3ed6
movq (%r14), %rbp
xorl %r12d, %r12d
leaq 0x330b(%rip), %r14      # 0x71b3
leaq 0x8(%rsp), %r15
movb (%rbp,%r12), %al
cmpb $0x27, %al
jne 0x3ec3
movq %r15, %rdi
movq %r14, %rsi
callq 0x2290
jmp 0x3ece
movsbl %al, %esi
movq %r15, %rdi
callq 0x2140
incq %r12
cmpq %r12, %r13
jne 0x3ead
leaq 0x8(%rsp), %rdi
movl $0x27, %esi
callq 0x2140
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3f74
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3f38
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x3f38
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3f74
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3f4c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3f6b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/src/details/BasicTimer.cpp
// Function: BSignals::details::BasicTimer::getElapsedDuration()
std::chrono::duration<double> BasicTimer::getElapsedDuration() {
    if (!running){
        std::chrono::duration<double> elapsed = end-begin;
        return elapsed;
    }
    auto n = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> elapsed = n-begin;
    return elapsed;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x10(%rdi)
je 0x35e1
callq 0x3050
jmp 0x35e5
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cvtsi2sd %rax, %xmm0
divsd 0x1a0b(%rip), %xmm0     # 0x5000
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/src/details/BasicTimer.cpp
// Function: BSignals::details::BasicTimer::start()
bool BasicTimer::start() {
    if (running) return false;
    running = true;
    begin = std::chrono::high_resolution_clock::now();
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movb 0x10(%rdi), %bl
testb %bl, %bl
jne 0x36a6
movq %rdi, %r14
movb $0x1, 0x10(%rdi)
callq 0x3050
movq %rax, (%r14)
xorb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/src/details/BasicTimer.cpp
// Function: BSignals::details::BasicTimer::stop()
bool BasicTimer::stop() {
    if (!running) return false;
    end = std::chrono::high_resolution_clock::now();
    running = false;
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movb 0x10(%rdi), %bl
cmpb $0x1, %bl
jne 0x36d1
movq %rdi, %r14
callq 0x3050
movq %rax, 0x8(%r14)
movb $0x0, 0x10(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/src/details/Semaphore.cpp
// Function: BSignals::details::Semaphore::acquire()
void Semaphore::acquire() {
    std::unique_lock<std::mutex> lock(semMutex);
    while (semCounter <= 0){
        semCV.wait(lock);
    }
    --semCounter;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %rdi, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x3240
movb $0x1, 0x8(%r14)
movl 0x58(%rbx), %eax
testl %eax, %eax
jne 0x375e
leaq 0x28(%rbx), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3090
movl 0x58(%rbx), %eax
testl %eax, %eax
je 0x374c
lock
decl 0x58(%rbx)
movq %rsp, %rdi
callq 0x30b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/src/details/SharedMutex.cpp
// Function: BSignals::details::SharedMutex::lock()
void SharedMutex::lock() {
    m_writers.fetch_add(1, std::memory_order_release);
    std::unique_lock<std::mutex> lock(m_mutex);
    while (m_readers || m_writer){
        m_condVar.wait(lock);
    }
    m_writer.store(true, std::memory_order_release);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
lock
incq 0x60(%rdi)
movq %rsp, %r14
movq %rdi, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x3240
movb $0x1, 0x8(%r14)
leaq 0x28(%rbx), %r15
movq 0x58(%rbx), %rax
testq %rax, %rax
jne 0x3869
movb 0x68(%rbx), %al
testb $0x1, %al
je 0x3876
movq %r15, %rdi
movq %r14, %rsi
callq 0x3090
jmp 0x3859
movb $0x1, 0x68(%rbx)
movq %rsp, %rdi
callq 0x30b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/src/details/WheeledThreadPool.cpp
// Function: BSignals::details::WheeledThreadPool::_init::_init()
WheeledThreadPool::_init::_init(){  
    //make a conservative estimate of when blocking will
    //be faster than spinning
    BasicTimer bt;
    MPSCQueue<int> tq;
    tq.enqueue(0);
    int x;
    bt.start();
    tq.blockingDequeue(x);
    bt.stop();
    maxWait = bt.getElapsedDuration()*2;
}

// Assembly:
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
leaq 0x8(%rsp), %rdi
callq 0x32c0
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x3370
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
movq %rbx, %rdi
callq 0x3390
leaq 0x8(%rsp), %rdi
callq 0x3210
leaq 0x20(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x3320
leaq 0x8(%rsp), %rdi
callq 0x3250
leaq 0x8(%rsp), %rdi
callq 0x33c0
addsd %xmm0, %xmm0
movq 0x4692(%rip), %rax      # 0x7fe0
movsd %xmm0, (%rax)
leaq 0x20(%rsp), %rdi
callq 0x3190
addq $0x220, %rsp            # imm = 0x220
popq %rbx
retq
jmp 0x3969
jmp 0x3969
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3190
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/MPSCQueue.hpp
// Function: BSignals::details::MPSCQueue<int, 16ul>::blockingDequeue(int&)
void blockingDequeue(T& output){
        std::unique_lock<std::mutex> lock(_mutex);
        waitingReader.store(true, std::memory_order_release);
        while (!dequeue(output)){
            _cv.wait(lock);
        }
        waitingReader.store(false, std::memory_order_release);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1a0(%rdi), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0x3240
movb $0x1, 0x8(%r15)
movb $0x1, 0x1f8(%rbx)
leaq 0x1c8(%rbx), %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33b0
testb %al, %al
jne 0x3f22
movq %r12, %rdi
movq %r15, %rsi
callq 0x3090
jmp 0x3f06
movb $0x0, 0x1f8(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x30b0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/MPSCQueue.hpp
// Function: BSignals::details::MPSCQueue<std::function<void ()>, 256ul>::~MPSCQueue()
~MPSCQueue(){
        T output;
        while(this->dequeue(output));
        listNode* front = _head.load(std::memory_order_relaxed);
        delete front;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3160
testb %al, %al
jne 0x4349
movq 0x2890(%rbx), %r14
testq %r14, %r14
je 0x4387
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x437a
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movl $0x28, %esi
movq %r14, %rdi
callq 0x3200
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x439e
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x28c8(%rbx), %rdi
callq 0x3380
addq $0x27d8, %rbx           # imm = 0x27D8
movq $-0x2800, %r14          # imm = 0xD800
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x43ce
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
addq $-0x28, %rbx
addq $0x28, %r14
jne 0x43b8
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x43e6
jmp 0x43e6
jmp 0x43e6
movq %rax, %rdi
callq 0x381f
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/MPSCQueue.hpp
// Function: BSignals::details::MPSCQueue<std::function<void ()>, 256ul>::transferMaxToCache()
void transferMaxToCache(){
        T output;
        while (slowDequeue(output)){
            if (!fastEnqueue(output)){
                slowEnqueue(output);
                break;
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movq 0x2898(%rbx), %r12
movq 0x20(%r12), %r15
testq %r15, %r15
je 0x4194
movq %r14, %rdi
movq %r15, %rsi
callq 0x3070
movq %r15, 0x2898(%rbx)
testq %r12, %r12
je 0x412f
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x4122
movq %r12, %rdi
movq %r12, %rsi
movl $0x3, %edx
callq *%rax
movl $0x28, %esi
movq %r12, %rdi
callq 0x3200
testq %r15, %r15
je 0x4194
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3170
testb %al, %al
jne 0x40df
movl $0x28, %edi
callq 0x31f0
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x20(%rax)
movq %rsp, %rsi
movq %rax, %rdi
callq 0x3070
movq %r14, %rax
xchgq %rax, 0x2890(%rbx)
movq %r14, 0x20(%rax)
movb 0x28f8(%rbx), %al
testb $0x1, %al
je 0x4194
addq $0x28c8, %rbx           # imm = 0x28C8
movq %rbx, %rdi
callq 0x30f0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x41ab
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x41df
jmp 0x41bd
jmp 0x41df
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x41d7
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x3360
movq %rax, %rdi
callq 0x381f
nop
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/MPSCQueue.hpp
// Function: BSignals::details::MPSCQueue<std::function<void ()>, 256ul>::fastEnqueue(std::function<void ()> const&)
bool fastEnqueue(const T& input){
        if (_cache.enqueue(input)){    
            if (waitingReader.load(std::memory_order_acquire)) _cv.notify_one();
            return true;
        }
        return false;
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3130
movl %eax, %ebp
testb %al, %al
je 0x456c
movb 0x28f8(%rbx), %al
testb $0x1, %al
je 0x456c
addq $0x28c8, %rbx           # imm = 0x28C8
movq %rbx, %rdi
callq 0x30f0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/ContiguousMPMCQueue.hpp
// Function: BSignals::details::ContiguousMPMCQueue<std::function<void ()>, 256ul>::enqueue(std::function<void ()> const&)
bool enqueue(const T& data){
        size_t  head_seq = _head_seq.load(std::memory_order_relaxed);
        while(true){
            node_t*  node     = &_buffer[head_seq & (N-1)];
            size_t   node_seq = node->seq.load(std::memory_order_acquire);
            intptr_t dif      = (intptr_t) node_seq - (intptr_t) head_seq;

            if (dif == 0){
                if (_head_seq.compare_exchange_weak(head_seq, head_seq + 1, std::memory_order_relaxed)) {
                    node->data = data;
                    node->seq.store(head_seq + 1, std::memory_order_release);
                    return true;
                }
            }
            else if (dif < 0){
                return false;
            }
            else{
                head_seq = _head_seq.load(std::memory_order_relaxed);
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2840(%rdi), %r15
movzbl %r15b, %eax
leaq (%rax,%rax,4), %rsi
movq 0x20(%r14,%rsi,8), %rax
cmpq %r15, %rax
jne 0x45d2
leaq 0x1(%r15), %rdx
movq %r15, %rax
lock
cmpxchgq %rdx, 0x2840(%r14)
movb $0x1, %dl
movq %rax, %r15
jne 0x45e3
leaq (%r14,%rsi,8), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3070
movq %r15, %rax
incq %rax
movq %rax, 0x20(%r12)
movb $0x1, %cl
jmp 0x45d6
jge 0x45da
xorl %ecx, %ecx
xorl %edx, %edx
jmp 0x45e3
movq 0x2840(%r14), %r15
movb $0x1, %dl
testb %dl, %dl
jne 0x458b
andb $0x1, %cl
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/ContiguousMPMCQueue.hpp
// Function: BSignals::details::ContiguousMPMCQueue<std::function<void ()>, 256ul>::dequeue(std::function<void ()>&)
bool dequeue(T& data){
        size_t       tail_seq = _tail_seq.load(std::memory_order_relaxed);
        while(true){
            node_t*  node     = &_buffer[tail_seq & (N-1)];
            size_t   node_seq = node->seq.load(std::memory_order_acquire);
            intptr_t dif      = (intptr_t) node_seq - (intptr_t)(tail_seq + 1);
            if (dif == 0) {
                if (_tail_seq.compare_exchange_weak(tail_seq, tail_seq + 1, std::memory_order_relaxed)) {
                    data = node->data;
                    node->seq.store(tail_seq + N, std::memory_order_release);
                    return true;
                }
            }
            else if (dif < 0){
                return false;
            }
            else{
                tail_seq = _tail_seq.load(std::memory_order_relaxed);
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2888(%rdi), %r15
movzbl %r15b, %eax
leaq (%rax,%rax,4), %rsi
movq 0x20(%r14,%rsi,8), %rax
leaq 0x1(%r15), %rdx
cmpq %rdx, %rax
jne 0x4989
movq %r15, %rax
lock
cmpxchgq %rdx, 0x2888(%r14)
movb $0x1, %dl
movq %rax, %r15
jne 0x499a
leaq (%r14,%rsi,8), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3070
movq %r15, %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, 0x20(%r12)
movb $0x1, %cl
jmp 0x498d
jge 0x4991
xorl %ecx, %ecx
xorl %edx, %edx
jmp 0x499a
movq 0x2888(%r14), %r15
movb $0x1, %dl
testb %dl, %dl
jne 0x493f
andb $0x1, %cl
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/amit-mittal[P]FTP/./include/../tcpSocket.cpp
// Function: tcpSocket::setHints(int)
void tcpSocket::setHints(int flag){
	memset(&hints, 0, sizeof hints);
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	if(flag == 1)//server
		hints.ai_flags = AI_PASSIVE; // use my IP
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movl $0x1, 0x38(%rdi)
cmpl $0x1, %esi
jne 0x277f
addq $0x30, %rdi
movl $0x1, (%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/amit-mittal[P]FTP/./include/../tcpSocket.cpp
// Function: tcpSocket::getOtherIp[abi:cxx11]()
string tcpSocket::getOtherIp(){

	socklen_t len;
	struct sockaddr_storage addr;
	char ipstr[INET6_ADDRSTRLEN];

	len = sizeof addr;
	getpeername(getSocket(), (struct sockaddr*)&addr, &len);

	// deal with both IPv4 and IPv6:
	if (addr.ss_family == AF_INET) {
    		struct sockaddr_in *s = (struct sockaddr_in *)&addr;
    		inet_ntop(AF_INET, &s->sin_addr, ipstr, sizeof ipstr);
	} else { // AF_INET6
   		 struct sockaddr_in6 *s = (struct sockaddr_in6 *)&addr;
    		inet_ntop(AF_INET6, &s->sin6_addr, ipstr, sizeof ipstr);
	}

	string str(ipstr);
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
leaq -0x14(%rbp), %rdx
movl $0x80, (%rdx)
movl (%rsi), %edi
leaq -0xd0(%rbp), %r14
movq %r14, %rsi
callq 0x2180
xorl %eax, %eax
cmpw $0x2, (%r14)
setne %al
leal 0x2(,%rax,8), %edi
leaq -0xcc(,%rax,4), %rsi
addq %rbp, %rsi
leaq -0x50(%rbp), %r14
movq %r14, %rdx
movl $0x2e, %ecx
callq 0x2240
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x2110
leaq (%rax,%rbp), %rdx
addq $-0x50, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4964
movq %rbx, %rax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/amit-mittal[P]FTP/./include/../tcpSocket.cpp
// Function: tcpSocket::connect()
int tcpSocket::connect(){
	struct addrinfo *p;
	int rv;
	stringstream port_str;
	port_str<<port;

	setHints(0);
	if ((rv = getaddrinfo(ip.c_str(), port_str.str().c_str(), &hints, &servinfo)) != 0) {
		fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
		return 1;
	}
	
	// loop through all the results and connect to the first we can
	for(p = servinfo; p != NULL; p = p->ai_next) {
		if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
			perror("socket");
			continue;
		}
		if (::connect(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
			close();
			perror("connect");
			continue;
		}
		break;
	}

	if (p == NULL) {
		fprintf(stderr, "failed to connect\n");
		return 2;
	}

	return 0;//no error
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
leaq -0x1c8(%rbp), %rdi
callq 0x2160
leaq -0x1b8(%rbp), %rdi
movzwl 0x28(%rbx), %esi
callq 0x2140
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movl $0x1, 0x38(%rbx)
movq 0x8(%rbx), %r15
leaq -0x1b0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2390
leaq 0x30(%rbx), %rdx
movq -0x40(%rbp), %rsi
leaq 0x60(%rbx), %r14
movq %r15, %rdi
movq %r14, %rcx
callq 0x22e0
movl %eax, %r15d
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2893
callq 0x21f0
testl %r15d, %r15d
jne 0x2938
movq (%r14), %r14
testq %r14, %r14
je 0x28f9
leaq 0x278d(%rip), %r15      # 0x5038
leaq 0x2763(%rip), %r12      # 0x5015
movl 0x4(%r14), %edi
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
callq 0x2080
movl %eax, (%rbx)
movq %r15, %rdi
cmpl $-0x1, %eax
je 0x28eb
movq 0x18(%r14), %rsi
movl 0x10(%r14), %edx
movl %eax, %edi
callq 0x21b0
cmpl $-0x1, %eax
jne 0x2905
movl (%rbx), %edi
callq 0x2420
movq %r12, %rdi
callq 0x21c0
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0x28b2
callq 0x2470
movl $0x2, %ebx
jmp 0x2907
xorl %ebx, %ebx
movq 0x56aa(%rip), %rsi      # 0x7fb8
leaq -0x1c8(%rbp), %rdi
callq 0x2190
leaq -0x148(%rbp), %rdi
callq 0x2100
movl %ebx, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %r15d, %edi
callq 0x2440
movl $0x1, %ebx
jmp 0x2907
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2965
callq 0x21f0
jmp 0x2965
jmp 0x2962
jmp 0x2962
movq %rax, %rbx
movq 0x564c(%rip), %rsi      # 0x7fb8
leaq -0x1c8(%rbp), %rdi
callq 0x2190
leaq -0x148(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O1/amit-mittal[P]FTP/./include/../tcpSocket.cpp
// Function: tcpSocket::bind()
int tcpSocket::bind(){
	struct addrinfo *p;
	int rv;
	int yes = 1;
	stringstream port_str;
	port_str<<port;

	setHints(1);
	if ((rv = getaddrinfo(NULL, port_str.str().c_str(), &hints, &servinfo)) != 0) {
		fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
		return 1;
	}

	// loop through all the results and bind to the first we can
	for(p = servinfo; p != NULL; p = p->ai_next) {
		if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
			perror("server: socket");
			continue;
		}
		if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
			perror("setsockopt");
		}
		if (::bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
			close();
			perror("server: bind");
			continue;
		}
		break;
	}

	if (p == NULL) {
		fprintf(stderr, "server: failed to bind\n");
		return 2;
	}

	return 0;//no error
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
movl $0x1, -0x2c(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x2160
leaq -0x1c8(%rbp), %rdi
movzwl 0x28(%rbx), %esi
callq 0x2140
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movl $0x1, %eax
movl %eax, 0x38(%rbx)
movl %eax, 0x30(%rbx)
leaq -0x1c0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x2390
leaq 0x30(%rbx), %rdx
movq -0x50(%rbp), %rsi
leaq 0x60(%rbx), %r14
xorl %edi, %edi
movq %r14, %rcx
callq 0x22e0
movl %eax, %r15d
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a27
callq 0x21f0
testl %r15d, %r15d
jne 0x2b0b
movq (%r14), %r12
testq %r12, %r12
je 0x2aff
leaq 0x25ed(%rip), %r13      # 0x5030
leaq -0x2c(%rbp), %r14
leaq 0x25fc(%rip), %r15      # 0x504a
movl 0x4(%r12), %edi
movl 0x8(%r12), %esi
movl 0xc(%r12), %edx
callq 0x2080
movl %eax, (%rbx)
movq %r13, %rdi
cmpl $-0x1, %eax
je 0x2aab
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rcx
movl $0x4, %r8d
callq 0x23d0
cmpl $-0x1, %eax
je 0x2abc
movl (%rbx), %edi
movq 0x18(%r12), %rsi
movl 0x10(%r12), %edx
callq 0x2070
cmpl $-0x1, %eax
jne 0x2aca
movl (%rbx), %edi
callq 0x2420
movq %r15, %rdi
callq 0x21c0
movq 0x28(%r12), %r12
testq %r12, %r12
jne 0x2a4e
jmp 0x2aff
leaq 0x257c(%rip), %rdi      # 0x503f
callq 0x21c0
jmp 0x2a8b
xorl %ebx, %ebx
movq 0x54e5(%rip), %rsi      # 0x7fb8
leaq -0x1d8(%rbp), %rdi
callq 0x2190
leaq -0x158(%rbp), %rdi
callq 0x2100
movl %ebx, %eax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x24c2
movl $0x2, %ebx
jmp 0x2acc
movl %r15d, %edi
callq 0x2492
movl $0x1, %ebx
jmp 0x2acc
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b38
callq 0x21f0
jmp 0x2b38
jmp 0x2b35
jmp 0x2b35
movq %rax, %rbx
movq 0x5479(%rip), %rsi      # 0x7fb8
leaq -0x1d8(%rbp), %rdi
callq 0x2190
leaq -0x158(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x23c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/amit-mittal[P]FTP/./include/../tcpSocket.cpp
// Function: tcpSocket::accept()
tcpSocket tcpSocket::accept(){
	int newfd = ::accept(sockfd, (struct sockaddr *)&their_addr, &their_addr_size);
	if(newfd == -1)
		perror("accept");
	return tcpSocket(newfd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rsi), %edi
leaq 0x68(%rsi), %rax
leaq 0xe8(%rsi), %rdx
movq %rax, %rsi
callq 0x20e0
movl %eax, %r14d
cmpl $-0x1, %eax
je 0x2bde
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movl %r14d, (%rbx)
movl $0x80, 0xe8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2491(%rip), %rdi      # 0x5076
callq 0x21c0
jmp 0x2bb5