LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: trisolaris233[P]httpc/src/gzip.hpp
// Function: httpc::compress(std::basic_string_view<char, std::char_traits<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int)
inline bool compress(std::string_view data, std::string& compressed_data, int level = -1) {
		unsigned char out[CHUNK];
		z_stream strm;
		strm.zalloc = Z_NULL;
		strm.zfree = Z_NULL;
		strm.opaque = Z_NULL;
		if (deflateInit2(&strm, level, Z_DEFLATED, windowBits | GZIP_ENCODING, 8, Z_DEFAULT_STRATEGY) != Z_OK)
		{
			return false;
		}
		strm.next_in = (unsigned char*)data.data();
		strm.avail_in = (uInt)data.length();
		do {
			int have;
			strm.avail_out = CHUNK;
			strm.next_out = out;
			if (deflate(&strm, Z_FINISH) == Z_STREAM_ERROR)
			{
				return false;
			}
			have = CHUNK - strm.avail_out;
			compressed_data.append((char*)out, have);
		} while (strm.avail_out == 0);
		if (deflateEnd(&strm) != Z_OK)
		{
			return false;
		}
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40c0, %rsp           # imm = 0x40C0
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq $0x0, -0x4060(%rbp)
movq $0x0, -0x4058(%rbp)
movq $0x0, -0x4050(%rbp)
movl -0x24(%rbp), %esi
leaq -0x40a0(%rbp), %rdi
movl $0x8, %r8d
movl $0x1f, %ecx
xorl %r9d, %r9d
leaq 0x45d53(%rip), %rax     # 0x597bd
movl %r8d, %edx
movq %rax, (%rsp)
movl $0x70, 0x8(%rsp)
callq 0xa0a0
cmpl $0x0, %eax
je 0x13a8c
movb $0x0, -0x1(%rbp)
jmp 0x13b2b
leaq -0x18(%rbp), %rdi
callq 0x13b40
movq %rax, -0x40a0(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x13b60
movl %eax, -0x4098(%rbp)
movl $0x4000, -0x4080(%rbp)  # imm = 0x4000
leaq -0x4030(%rbp), %rax
movq %rax, -0x4088(%rbp)
leaq -0x40a0(%rbp), %rdi
movl $0x4, %esi
callq 0xa330
cmpl $-0x2, %eax
jne 0x13adf
movb $0x0, -0x1(%rbp)
jmp 0x13b2b
movl $0x4000, %eax           # imm = 0x4000
subl -0x4080(%rbp), %eax
movl %eax, -0x40a4(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x4030(%rbp), %rsi
movslq -0x40a4(%rbp), %rdx
callq 0xa0c0
cmpl $0x0, -0x4080(%rbp)
je 0x13aab
leaq -0x40a0(%rbp), %rdi
callq 0xa420
cmpl $0x0, %eax
je 0x13b27
movb $0x0, -0x1(%rbp)
jmp 0x13b2b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40c0, %rsp           # imm = 0x40C0
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x508, %edi            # imm = 0x508
callq 0xa6b0
movq -0x50(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsi, %rdx
subq $-0x80, %rdx
callq 0x27e70
jmp 0x27bda
movq -0x48(%rbp), %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x27f70
movq -0x50(%rbp), %rax
movq -0x68(%rbp), %rdi
addq $0x10, %rax
movq %rax, -0x60(%rbp)
callq 0x27ff0
movq %rax, %rdi
callq 0x28010
movq %rax, -0x58(%rbp)
jmp 0x27c0e
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x28030
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x40(%rbp), %rdx
callq 0x27fa0
jmp 0x27c3a
leaq -0x40(%rbp), %rdi
callq 0x28060
leaq -0x18(%rbp), %rdi
callq 0x28080
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x508, %esi            # imm = 0x508
callq 0xa6d0
jmp 0x27c9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x27c91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x28060
leaq -0x18(%rbp), %rdi
callq 0x28080
movq -0x20(%rbp), %rdi
callq 0xab10
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2cf20
movq -0x50(%rbp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x48(%rbp)
addq $0x68, %rdi
callq 0x2d020
movq -0x50(%rbp), %rsi
movq %rax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rsi, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2d060
movq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2cfd0
jmp 0x2ceed
leaq -0x30(%rbp), %rdi
callq 0x2d090
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2d090
movq -0x38(%rbp), %rdi
callq 0xab10
nopw (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x498, %rax            # imm = 0x498
movq %rax, -0x50(%rbp)
movl $0x3c, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x68(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x2d120
movq -0x68(%rbp), %rsi
leaq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x2d140
movq -0x60(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x2d0b0
movq -0x58(%rbp), %rsi
movq %rsi, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2d060
movq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2d180
jmp 0x2cf94
leaq -0x38(%rbp), %rdi
callq 0x2d1b0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2d1b0
movq -0x40(%rbp), %rdi
callq 0xab10
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xab40
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x70(%rbp), %rcx
leaq -0x48(%rbp), %rdi
callq 0x31550
jmp 0x306ff
movq 0x59882(%rip), %rdi     # 0x89f88
leaq -0x48(%rbp), %rsi
callq 0xa600
movq %rax, -0xa0(%rbp)
jmp 0x30718
movq -0xa0(%rbp), %rdi
movq 0x597ea(%rip), %rsi     # 0x89f10
callq 0xa720
jmp 0x3072d
leaq -0x48(%rbp), %rdi
callq 0xa450
leaq -0x49(%rbp), %rdi
callq 0xa740
movl $0x1, -0x60(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x307ca
movq -0x88(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movsbl (%rax), %edx
callq 0x315c0
cmpl $0x0, %eax
jne 0x307b7
movq -0x98(%rbp), %rdi
movl $0x0, -0x64(%rbp)
leaq -0x64(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x31c30
jmp 0x307e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x307ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa450
leaq -0x49(%rbp), %rdi
callq 0xa740
jmp 0x307f5
jmp 0x307b9
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x30746
movq -0x98(%rbp), %rdi
movl $0x2, -0x68(%rbp)
leaq -0x68(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x31c30
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xab10
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x32170
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
callq 0x30d50
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x14d60
testb $0x1, %al
jne 0x30cc1
jmp 0x30cf3
leaq -0x20(%rbp), %rdi
callq 0x31450
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x13b80
testb $0x1, %al
jne 0x30cdc
jmp 0x30ce6
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x30d00
jmp 0x30ce8
leaq -0x20(%rbp), %rdi
callq 0x14dc0
jmp 0x30ca1
movq -0x30(%rbp), %rdi
callq 0x30d50
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x50(%rbp)
movq %rsi, %rax
addq $0x18, %rax
movq %rax, -0x58(%rbp)
addq $0x3d0, %rsi            # imm = 0x3D0
leaq -0x20(%rbp), %rdi
callq 0x3cd20
movq -0x50(%rbp), %rsi
movq %rsi, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2d060
jmp 0x31352
movq -0x58(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x3ccc0
jmp 0x31369
leaq -0x38(%rbp), %rdi
callq 0x3cf60
leaq -0x20(%rbp), %rdi
callq 0x3cf80
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x313a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3cf60
leaq -0x20(%rbp), %rdi
callq 0x3cf80
movq -0x40(%rbp), %rdi
callq 0xab10
nopw %cs:(%rax,%rax)
// File: trisolaris233[P]httpc/src/connection.hpp
// Function: httpc::Connection::ReadBody()
void ReadBody() {
            debug().dg("enter the ReadBody() member function").lf();

            this->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) {
                    debug()
                        .dg("Read Body ec.message => ")
                        .dg(ec.message())
                        .lf()
                        .dg("size => ")
                        .dg(bytes_transferred)
                        .lf();
                    
                    // if no error occurs
                    if (!ec) {
                        debug().dg("try to invoke HandleReadBody() memeber function").lf();
                        HandleReadBody(ec, bytes_transferred);
                    } else {
                        // debug().dg("read eof do write").lf();
                        // this->CheckKeepAlive_();
                        debug().dg("Invoke route").lf();
                        
                            // debug().dg(this->request_.uri.GetUri()).lf();
                        this->http_router_.Route(
                            this->request_.method,
                            this->request_.uri.GetUri(), 
                            this->request_, 
                            this->response_
                        );
                        debug().dg("Make Respond").lf();
                        //debug().dg(this->response_).lf();
                        this->handler_.Respond(
                            this->request_,
                            this->response_
                        );
                        debug().dg("Do Write").lf();
                        this->DoWrite();
                    }
                }
            );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0x28a27(%rip), %rsi     # 0x59ef2
leaq -0x9(%rbp), %rdi
callq 0x41a40
movq %rax, %rdi
callq 0x2cc60
movq -0x58(%rbp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x50(%rbp)
addq $0x68, %rdi
callq 0x2d020
movq -0x58(%rbp), %rsi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq %rsi, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2d060
movq -0x50(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x41a60
jmp 0x31520
leaq -0x38(%rbp), %rdi
callq 0x41ab0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x41ab0
movq -0x40(%rbp), %rdi
callq 0xab10
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x491(%rax)
je 0x40154
movq -0x28(%rbp), %rdi
addq $0x268, %rdi            # imm = 0x268
callq 0x40180
movq -0x28(%rbp), %rdi
addq $0x2a8, %rdi            # imm = 0x2A8
callq 0x401b0
movq -0x28(%rbp), %rdi
addq $0x3d0, %rdi            # imm = 0x3D0
callq 0x40250
movq -0x28(%rbp), %rdi
callq 0x2ce90
jmp 0x40176
movq -0x28(%rbp), %rdi
addq $0x498, %rdi            # imm = 0x498
callq 0x402c0
movq -0x28(%rbp), %rdi
callq 0x40330
movq -0x28(%rbp), %rdi
callq 0x40380
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: trisolaris233[P]httpc/src/request.hpp
// Function: httpc::Request::Reset()
inline void Reset() {
            this->method.clear();
            this->uri.Reset();
            this->http_major_version = this->http_minor_version = 0;
            this->headers.clear();
            this->message_body.clear();
            this->files_.clear();
            this->fields_.clear();
            this->file_recv_flag_ = false;
            this->file_recv_complete_flag_ = false;
            this->file_recv_successfully_flag_ = false;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xa900
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x403a0
movq -0x10(%rbp), %rdi
movl $0x0, 0x94(%rdi)
movl $0x0, 0x90(%rdi)
addq $0x98, %rdi
callq 0x127b0
movq -0x10(%rbp), %rdi
addq $0xb0, %rdi
callq 0xa900
movq -0x10(%rbp), %rdi
addq $0xd0, %rdi
callq 0x403e0
movq -0x10(%rbp), %rdi
addq $0xe8, %rdi
callq 0x40400
movq -0x10(%rbp), %rax
movb $0x0, 0x120(%rax)
movb $0x0, 0x121(%rax)
movb $0x0, 0x122(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: trisolaris233[P]httpc/src/response.hpp
// Function: httpc::Response::Reset()
inline void Reset() {
            this->http_major_version = this->http_minor_version = 0;
            this->status_code = static_cast<HTTPStatusCodeEnum>(0);
            this->reason_phrase.clear();
            this->headers.clear();
            this->message_body.clear();
#ifdef HTTPC_ENABLE_GZIP
            this->gzip_message_body_.clear();
#endif
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x0, 0x4(%rdi)
movl $0x0, (%rdi)
movl $0x0, 0x8(%rdi)
addq $0x10, %rdi
callq 0xa900
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x127b0
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0xa900
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0xa900
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x4b1c0
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
callq 0x43c20
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x14d60
testb $0x1, %al
jne 0x43bd1
jmp 0x43c03
leaq -0x20(%rbp), %rdi
callq 0x31450
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x13b80
testb $0x1, %al
jne 0x43bec
jmp 0x43bf6
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x43c10
jmp 0x43bf8
leaq -0x20(%rbp), %rdi
callq 0x14dc0
jmp 0x43bb1
movq -0x30(%rbp), %rdi
callq 0x43c20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: trisolaris233[P]httpc/src/request.hpp
// Function: httpc::Request::GetFileSize() const
inline std::size_t GetFileSize() const {
            if (this->method == "POST") {
                auto itr = this->FindHeader("Content-Length");
                if (itr != this->HeaderCEnd()) {
                    return boost::lexical_cast<std::size_t>(itr->value);
                }
            }
            return 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
leaq 0x7533(%rip), %rsi      # 0x5a0de
callq 0x13b80
testb $0x1, %al
jne 0x52bb6
jmp 0x52c07
movq -0x28(%rbp), %rdi
leaq 0x6c03(%rip), %rsi      # 0x597c4
callq 0x30c80
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x30d50
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x14d60
testb $0x1, %al
jne 0x52bea
jmp 0x52c05
leaq -0x18(%rbp), %rdi
callq 0x31450
movq %rax, %rdi
addq $0x20, %rdi
callq 0x52d60
movq %rax, -0x8(%rbp)
jmp 0x52c0f
jmp 0x52c07
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: trisolaris233[P]httpc/src/response.hpp
// Function: void httpc::Response::RenderString<char const (&) [13]>(char const (&) [13])
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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x53500
movq -0x18(%rbp), %rdi
leaq 0x6afc(%rip), %rsi      # 0x59768
leaq 0x6b06(%rip), %rdx      # 0x59779
callq 0x127d0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x48, %rdi
movq -0x10(%rbp), %rsi
callq 0xac00
movq -0x18(%rbp), %rdi
callq 0x12900
movq -0x18(%rbp), %rdi
callq 0x12960
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: trisolaris233[P]httpc/src/utility.cpp
// Function: httpc::is_tspecial(int)
bool is_tspecial(int c) noexcept {
        switch (c)
        {
        case '(': case ')': case '<': case '>': case '@':
        case ',': case ';': case ':': case '\\': case '"':
        case '/': case '[': case ']': case '?': case '=':
        case '{': case '}': case ' ': case '\t':
            return true;
        default:
            return false;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x9, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x74, %eax
ja 0x55392
movq -0x10(%rbp), %rax
leaq 0x6021(%rip), %rcx      # 0x5b3a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x1(%rbp)
jmp 0x55396
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: mapbox[P]svg-tools/test/path.hpp
// Function: mapbox::svg::operator<<(std::ostream&, mapbox::svg::PathParseErrorType)
::std::ostream& operator<<(::std::ostream& os, const PathParseErrorType error) {
    switch (error) {
        case PathParseErrorType::NumberParsing: return os << "PathParseErrorType::NumberParsing";
        case PathParseErrorType::FlagParsing: return os << "PathParseErrorType::FlagParsing";
        case PathParseErrorType::CommandParsing: return os << "PathParseErrorType::CommandParsing";
        default: return os << "PathParseErrorType::None";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x1, %eax
je 0x1310
jmp 0x12fc
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x1326
jmp 0x1306
movl -0x18(%rbp), %eax
subl $0x3, %eax
je 0x133c
jmp 0x1352
movq -0x10(%rbp), %rdi
leaq 0x4f45(%rip), %rsi      # 0x6260
callq 0x10c0
movq %rax, -0x8(%rbp)
jmp 0x1366
movq -0x10(%rbp), %rdi
leaq 0x4f51(%rip), %rsi      # 0x6282
callq 0x10c0
movq %rax, -0x8(%rbp)
jmp 0x1366
movq -0x10(%rbp), %rdi
leaq 0x4f5b(%rip), %rsi      # 0x62a2
callq 0x10c0
movq %rax, -0x8(%rbp)
jmp 0x1366
movq -0x10(%rbp), %rdi
leaq 0x4f68(%rip), %rsi      # 0x62c5
callq 0x10c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x4b4e(%rip), %rsi      # 0x63e9
callq 0x10c0
movq %rax, %rdi
movq 0x771e(%rip), %rsi      # 0x8fc8
callq 0x10f0
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d00
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d30
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2d60
testb $0x1, %al
jne 0x18e4
jmp 0x1936
leaq -0x20(%rbp), %rdi
callq 0x2da0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x4af4(%rip), %rsi      # 0x63f0
callq 0x10c0
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x1370
movq %rax, %rdi
leaq 0x4ade(%rip), %rsi      # 0x63f5
callq 0x10c0
movq %rax, %rdi
movq 0x76a2(%rip), %rsi      # 0x8fc8
callq 0x10f0
leaq -0x20(%rbp), %rdi
callq 0x2dc0
jmp 0x18d1
movq -0x8(%rbp), %rdi
leaq 0x49b1(%rip), %rsi      # 0x62f2
callq 0x10c0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x10(%rax), %rax
cmpb $0x0, (%rax)
je 0x3d2b
movq -0x20(%rbp), %rsi
movq 0x10(%rsi), %rdi
addq $0x18, %rsi
callq 0x1080
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq 0x10(%rcx), %rax
cmpq 0x18(%rcx), %rax
je 0x3d29
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x2350(%rip), %xmm1     # 0x6058
ucomisd %xmm1, %xmm0
jne 0x3d12
jp 0x3d12
jmp 0x3d29
movq -0x20(%rbp), %rdi
movq 0x18(%rdi), %rax
movq %rax, 0x10(%rdi)
callq 0x4a90
movb $0x1, -0x1(%rbp)
jmp 0x3d3a
jmp 0x3d2b
movq -0x20(%rbp), %rax
movl $0x1, 0x20(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: mapbox[P]svg-tools/include/mapbox/svg/path_parser.hpp
// Function: mapbox::svg::PathParser<mapbox::svg::test::PathVertexReceiver>::parseFlag(bool&)
bool parseFlag(bool& value) {
        if (*cursor == '0') {
            value = false;
        } else if (*cursor == '1') {
            value = true;
        } else {
            error = PathParseErrorType::FlagParsing;
            return false;
        }
        ++cursor;
        skipSeparator();
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x40ad
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
jmp 0x40d9
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x31, %eax
jne 0x40c6
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
jmp 0x40d7
movq -0x20(%rbp), %rax
movl $0x2, 0x20(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x40f2
jmp 0x40d9
movq -0x20(%rbp), %rdi
movq 0x10(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x10(%rdi)
callq 0x4a90
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb (%rax), %cl
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpb (%rdx), %cl
movb %al, -0x11(%rbp)
jne 0x56bb
movq -0x20(%rbp), %rax
movb 0x1(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x10(%rbp), %rax
movb 0x1(%rax), %al
andb $0x1, %al
movzbl %al, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x11(%rbp)
jne 0x56bb
movq -0x20(%rbp), %rax
movb 0x2(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x10(%rbp), %rax
movb 0x2(%rax), %al
andb $0x1, %al
movzbl %al, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x11(%rbp)
jne 0x56bb
movq -0x20(%rbp), %rax
movb 0x3(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x10(%rbp), %rax
movb 0x3(%rax), %al
andb $0x1, %al
movzbl %al, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x11(%rbp)
jne 0x56bb
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm1
callq 0x2cc0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x55e2
jmp 0x56bb
movq -0x20(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm1
callq 0x2cc0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x560a
jmp 0x56bb
movq -0x20(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm1
callq 0x2cc0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x5632
jmp 0x56bb
movq -0x20(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm1
callq 0x2cc0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x5657
jmp 0x56bb
movq -0x20(%rbp), %rax
movsd 0x28(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x28(%rax), %xmm1
callq 0x2cc0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x567c
jmp 0x56bb
movq -0x20(%rbp), %rax
movsd 0x30(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x30(%rax), %xmm1
callq 0x2cc0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x56a1
jmp 0x56bb
movq -0x20(%rbp), %rax
movsd 0x38(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x38(%rax), %xmm1
callq 0x2cc0
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3350
testb $0x1, %al
jne 0x5f7b
movq -0x18(%rbp), %rdi
leaq 0xb2b6(%rip), %rsi      # 0x11210
xorl %eax, %eax
movl %eax, %edx
callq 0x30f0
cmpq $-0x1, %rax
jne 0x5f7b
movq -0x80(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x30b0
jmp 0x6089
leaq -0x39(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3390
movq -0x88(%rbp), %rdx
leaq 0xb291(%rip), %rsi      # 0x1122a
leaq -0x38(%rbp), %rdi
callq 0x52f0
jmp 0x5fa4
leaq -0x39(%rbp), %rdi
callq 0x3240
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x31e0
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x33b0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x60f0
testb $0x1, %al
jne 0x5fe2
jmp 0x6057
leaq -0x60(%rbp), %rdi
callq 0x6130
movb (%rax), %al
movb %al, -0x69(%rbp)
movsbl -0x69(%rbp), %eax
cmpl $0x27, %eax
jne 0x600d
leaq 0xb227(%rip), %rsi      # 0x11227
leaq -0x38(%rbp), %rdi
callq 0x31f0
jmp 0x600b
jmp 0x601e
movsbl -0x69(%rbp), %esi
leaq -0x38(%rbp), %rdi
callq 0x3140
jmp 0x601c
jmp 0x601e
leaq -0x60(%rbp), %rdi
callq 0x6150
jmp 0x5fcf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x3240
jmp 0x6096
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3130
jmp 0x6096
leaq -0x38(%rbp), %rdi
movl $0x27, %esi
callq 0x3140
movq %rax, -0x90(%rbp)
jmp 0x606e
movq -0x90(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0x30b0
jmp 0x6080
leaq -0x38(%rbp), %rdi
callq 0x3130
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3380
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x10(%rax)
jne 0xb3fd
movq -0x30(%rbp), %rsi
movq %rsi, %rdi
addq $0x8, %rdi
callq 0xa460
movq %rax, -0x18(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xac30
jmp 0xb424
callq 0xa070
movq -0x30(%rbp), %rsi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa460
movq %rax, -0x28(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xac30
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x10(%rax)
je 0xb530
movb $0x0, -0x1(%rbp)
jmp 0xb553
movq -0x20(%rbp), %rax
movb $0x1, 0x10(%rax)
callq 0xa070
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x10(%rax)
jne 0xb580
movb $0x0, -0x1(%rbp)
jmp 0xb5a0
callq 0xa070
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb050
movq -0x20(%rbp), %rdi
addq $0x58, %rdi
callq 0xa700
cmpl $0x0, %eax
ja 0xbbe2
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
leaq -0x18(%rbp), %rsi
callq 0xa200
jmp 0xbbbd
movq -0x20(%rbp), %rdi
addq $0x58, %rdi
callq 0xa6d0
leaq -0x18(%rbp), %rdi
callq 0xa250
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x60, %rax
movq %rax, -0x8(%rbp)
movq $0x1, -0x10(%rbp)
movl $0x3, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
decl %eax
movl %eax, %ecx
movq %rcx, -0x48(%rbp)
subl $0x4, %eax
ja 0xc0af
movq -0x48(%rbp), %rax
leaq 0x7f72(%rip), %rcx      # 0x14018
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0xc10c
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0xc10c
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0xc10c
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0xc10c
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
movq -0x58(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xb050
movq -0x58(%rbp), %rdi
addq $0x58, %rdi
callq 0xa1a0
movq %rax, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x59(%rbp)
jne 0xc144
movq -0x58(%rbp), %rdi
addq $0x68, %rdi
callq 0xa4e0
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0xc14d
jmp 0xc160
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
leaq -0x40(%rbp), %rsi
callq 0xa200
jmp 0xc119
movq -0x58(%rbp), %rdi
addq $0x68, %rdi
movl $0x1, %esi
movl $0x3, %edx
callq 0xa910
leaq -0x40(%rbp), %rdi
callq 0xa250
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xac40
leaq -0x220(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0xafb0
movq -0x258(%rbp), %rdi
movl $0x0, -0x224(%rbp)
leaq -0x224(%rbp), %rsi
callq 0xb0c0
jmp 0xca6a
leaq -0x20(%rbp), %rdi
callq 0xa8c0
jmp 0xca75
leaq -0x220(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0xad00
jmp 0xca8a
leaq -0x20(%rbp), %rdi
callq 0xaa10
jmp 0xca95
leaq -0x20(%rbp), %rdi
callq 0xb180
movsd %xmm0, -0x260(%rbp)
jmp 0xcaa8
movsd -0x260(%rbp), %xmm0
movsd %xmm0, -0x248(%rbp)
movl $0x2, -0x24c(%rbp)
leaq -0x248(%rbp), %rdi
leaq -0x24c(%rbp), %rsi
callq 0xa3f0
movsd %xmm0, -0x268(%rbp)
jmp 0xcadf
movsd -0x268(%rbp), %xmm0
movsd %xmm0, -0x240(%rbp)
movq 0xc4ea(%rip), %rax      # 0x18fe0
movq -0x240(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x220(%rbp), %rdi
callq 0xa570
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x220(%rbp), %rdi
callq 0xa570
movq -0x230(%rbp), %rdi
callq 0xaf80
nop
// File: Barath-Kannan[P]SignalsAndSlots/src/details/WheeledThreadPool.cpp
// Function: BSignals::details::WheeledThreadPool::_init::~_init()
WheeledThreadPool::_init::~_init() {
    std::lock_guard<mutex> lock(tpLock);
    isStarted = false;
    for (uint32_t i=0; i<nThreads; i++){
        threadPooledFunctions.getSpoke(i).enqueue(nullptr);
    }
    for (auto &t : queueMonitors){
        t.join();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq 0xc46d(%rip), %rsi      # 0x18fc0
leaq -0x10(%rbp), %rdi
callq 0xa970
jmp 0xcb5e
movq 0xc46b(%rip), %rax      # 0x18fd0
movb $0x0, (%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x20, -0x14(%rbp)
jae 0xcbbc
movl -0x14(%rbp), %esi
movq 0xc459(%rip), %rdi      # 0x18fd8
callq 0xaa40
movq %rax, -0x68(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xa300
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0xab50
jmp 0xcba8
leaq -0x38(%rbp), %rdi
callq 0xa2a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcb6f
movq 0xc3d5(%rip), %rax      # 0x18f98
movq %rax, -0x40(%rbp)
movq 0xc3ca(%rip), %rdi      # 0x18f98
callq 0xa3a0
movq %rax, -0x48(%rbp)
movq 0xc3ba(%rip), %rdi      # 0x18f98
callq 0xa5a0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xb100
testb $0x1, %al
jne 0xcbfa
jmp 0xcc1f
leaq -0x48(%rbp), %rdi
callq 0xaf10
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0xaef0
jmp 0xcc12
jmp 0xcc14
leaq -0x48(%rbp), %rdi
callq 0xabd0
jmp 0xcbe7
leaq -0x10(%rbp), %rdi
callq 0xadb0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xb820
nopw %cs:(%rax,%rax)
// File: Barath-Kannan[P]SignalsAndSlots/src/details/WheeledThreadPool.cpp
// Function: BSignals::details::WheeledThreadPool::startup()
void WheeledThreadPool::startup() {
    std::lock_guard<mutex> lock(tpLock);
    if (!isStarted){
        isStarted = true;
        for (unsigned int i=0; i<nThreads; ++i){
            queueMonitors.emplace_back(queueListener, i);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x8(%rbp), %rdi
movq 0xc32d(%rip), %rsi      # 0x18fc0
callq 0xa970
movq 0xc331(%rip), %rax      # 0x18fd0
testb $0x1, (%rax)
jne 0xccfa
movq 0xc325(%rip), %rax      # 0x18fd0
movb $0x1, (%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x20, -0xc(%rbp)
jae 0xccf8
movq 0xc2d6(%rip), %rdi      # 0x18f98
movq 0xc2bf(%rip), %rsi      # 0x18f88
leaq -0xc(%rbp), %rdx
callq 0xa8d0
jmp 0xccd4
jmp 0xccd6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xccb5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x8(%rbp), %rdi
callq 0xadb0
jmp 0xcd09
jmp 0xccfa
leaq -0x8(%rbp), %rdi
callq 0xadb0
addq $0x20, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xaf80
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
addq $0x1a0, %rsi            # imm = 0x1A0
leaq -0x20(%rbp), %rdi
callq 0xb050
movq -0x38(%rbp), %rdi
addq $0x1f8, %rdi            # imm = 0x1F8
movl $0x1, %esi
movl $0x3, %edx
callq 0xa910
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb160
movb %al, -0x39(%rbp)
jmp 0xd2e4
movb -0x39(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xd2ef
jmp 0xd31c
movq -0x38(%rbp), %rdi
addq $0x1c8, %rdi            # imm = 0x1C8
leaq -0x20(%rbp), %rsi
callq 0xa200
jmp 0xd2d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa250
jmp 0xd342
movq -0x38(%rbp), %rdi
addq $0x1f8, %rdi            # imm = 0x1F8
xorl %esi, %esi
movl $0x3, %edx
callq 0xa910
leaq -0x20(%rbp), %rdi
callq 0xa250
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xaf80
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xacc0
movq -0x38(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa4f0
movb %al, -0x39(%rbp)
jmp 0xdc7f
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xdc88
jmp 0xdc8a
jmp 0xdc6d
movq -0x38(%rbp), %rdi
addq $0x2890, %rdi           # imm = 0x2890
xorl %esi, %esi
callq 0xa7a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xdcc5
movq -0x48(%rbp), %rdi
callq 0xaa20
movq -0x48(%rbp), %rdi
movl $0x28, %esi
callq 0xa870
leaq -0x28(%rbp), %rdi
callq 0xa2a0
movq -0x38(%rbp), %rdi
addq $0x28c8, %rdi           # imm = 0x28C8
callq 0xaff0
movq -0x38(%rbp), %rdi
callq 0xa6f0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xb820
nopw %cs:(%rax,%rax)
nop