name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
curlx_uitouc | unsigned char curlx_uitouc(unsigned int uinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_UCHAR);
return (unsigned char) (uinum & (unsigned int) CURL_MASK_UCHAR);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movl %edi, %eax
retq
| /nomaster[P]curl/lib/warnless.c |
curlx_uitosi | int curlx_uitosi(unsigned int uinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_SINT);
return (int) (uinum & (unsigned int) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movl %edi, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /nomaster[P]curl/lib/warnless.c |
curlx_sitouz | size_t curlx_sitouz(int sinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sinum >= 0);
return (size_t) sinum;
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movslq %edi, %rax
retq
| /nomaster[P]curl/lib/warnless.c |
cappuccino::ut_map<unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, (cappuccino::thread_safe)1>::do_insert(unsigned long const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>) | auto do_insert(const key_type& key, value_type&& value, std::chrono::steady_clock::time_point expire_time) -> void
{
keyed_element element;
element.m_value = std::move(value);
auto keyed_position = m_keyed_elements.emplace(key, std::move(element)).first;
m_ttl_list.emplace_back(expire_time, keyed_position);
// Update the elements iterator to ttl_element.
keyed_position->second.m_ttl_position = std::prev(m_ttl_list.end());
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
xorl %eax, %eax
movq %rax, -0x8(%r13)
movb $0x0, (%r13)
movq %rax, 0x10(%r13)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x3190
leaq 0x28(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4058
movq %rax, %r15
movl $0x20, %edi
callq 0x3150
leaq 0x58(%rbx), %rsi
movq %r14, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %rax, %rdi
callq 0x3050
incq 0x68(%rbx)
movq 0x60(%rbx), %rax
movq %rax, 0x48(%r15)
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3feb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3160
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3ffb
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4015
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3160
movq %rbx, %rdi
callq 0x3210
nop
| /jbaldwin[P]libcappuccino/inc/cappuccino/ut_map.hpp |
EventLoop::addChannel(std::shared_ptr<Channel>) | void EventLoop::addChannel(ChannelPtr channel) {
assertInLoopThread();
poller_->addChannel(std::move(channel));
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb9ae
movq 0x8(%r14), %rdi
movq (%rbx), %rax
leaq -0x20(%rbp), %rsi
movq %rax, (%rsi)
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x8(%rbx)
movq %rax, 0x8(%rsi)
movq %rcx, (%rbx)
callq 0xc490
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0xb45e
callq 0xa9e2
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0xb478
callq 0xa9e2
movq %rbx, %rdi
callq 0xa400
| /Raven65[P]WebServer/net/EventLoop.cpp |
EventLoop::updateChannel(std::shared_ptr<Channel>) | void EventLoop::updateChannel(ChannelPtr channel) {
assert(channel->ownerLoop() == this);
assertInLoopThread();
poller_->updateChannel(std::move(channel));
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rsi), %rax
cmpq %rdi, 0x10(%rax)
jne 0xb4da
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb9ae
movq 0x8(%r14), %rdi
movq (%rbx), %rax
leaq -0x20(%rbp), %rsi
movq %rax, (%rsi)
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x8(%rbx)
movq %rax, 0x8(%rsi)
movq %rcx, (%rbx)
callq 0xc5a4
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0xb4d1
callq 0xa9e2
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x5ce5(%rip), %rdi # 0x111c6
leaq 0x5bd8(%rip), %rsi # 0x110c0
leaq 0x5cf4(%rip), %rcx # 0x111e3
movl $0x4d, %edx
callq 0xa150
movq %rax, %rbx
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0xb50a
callq 0xa9e2
movq %rbx, %rdi
callq 0xa400
| /Raven65[P]WebServer/net/EventLoop.cpp |
EventLoop::removeChannel(std::shared_ptr<Channel>) | void EventLoop::removeChannel(ChannelPtr channel) {
assert(channel->ownerLoop() == this);
assertInLoopThread();
poller_->removeChannel(std::move(channel));
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rsi), %rax
cmpq %rdi, 0x10(%rax)
jne 0xb56c
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb9ae
movq 0x8(%r14), %rdi
movq (%rbx), %rax
leaq -0x20(%rbp), %rsi
movq %rax, (%rsi)
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x8(%rbx)
movq %rax, 0x8(%rsi)
movq %rcx, (%rbx)
callq 0xc6c4
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0xb563
callq 0xa9e2
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x5c53(%rip), %rdi # 0x111c6
leaq 0x5b46(%rip), %rsi # 0x110c0
leaq 0x5c8c(%rip), %rcx # 0x1120d
movl $0x53, %edx
callq 0xa150
movq %rax, %rbx
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0xb59c
callq 0xa9e2
movq %rbx, %rdi
callq 0xa400
| /Raven65[P]WebServer/net/EventLoop.cpp |
EventLoop::queueInLoop(std::function<void ()>) | void EventLoop::queueInLoop(Functor cb) {
{
MutexLockGuard lock(mutex_);
pendingFuntors_.push_back(std::move(cb));
}
if(!isInLoopThread() || callingPendingFunctors_) {
wakeup();
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x58(%rdi), %r14
movq %r14, %rdi
callq 0xa350
leaq 0x80(%rbx), %rdi
movq %r15, %rsi
callq 0xbccc
movq %r14, %rdi
callq 0xa1a0
movl 0x40(%rbx), %r14d
movq 0xb914(%rip), %r15 # 0x16fe8
movl %fs:(%r15), %eax
testl %eax, %eax
je 0xb704
cmpl %eax, %r14d
jne 0xb6e7
cmpb $0x1, 0x2(%rbx)
jne 0xb6f9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb722
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xf055
movl %fs:(%r15), %eax
jmp 0xb6dc
movq %rax, %rbx
movq %r14, %rdi
callq 0xa1a0
movq %rbx, %rdi
callq 0xa400
| /Raven65[P]WebServer/net/EventLoop.cpp |
LogStream::operator<<(char const*) | LogStream& operator<<(const char* str) {
if (str)
buffer_.append(str, strlen(str));
else
buffer_.append("(null)", 6);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0xb8ea
movq %rsi, %r15
movq %rsi, %rdi
callq 0xa0f0
movq %rax, %r14
leaq 0xfa8(%rbx), %r12
movq 0xfa8(%rbx), %rdi
movl %r12d, %eax
subl %edi, %eax
cmpl %r14d, %eax
jle 0xb918
movq %r15, %rsi
movq %r14, %rdx
callq 0xa1e0
jmp 0xb914
leaq 0xfa8(%rbx), %r12
movq 0xfa8(%rbx), %rax
movl %r12d, %ecx
subl %eax, %ecx
cmpl $0x7, %ecx
jl 0xb918
movw $0x296c, 0x4(%rax) # imm = 0x296C
movl $0x6c756e28, (%rax) # imm = 0x6C756E28
movl $0x6, %r14d
addq %r14, (%r12)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /Raven65[P]WebServer/net/../base/LogStream.h |
EventLoop::assertInLoopThread() | void assertInLoopThread() { assert(isInLoopThread()); } | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x40(%rdi), %ebx
movq 0xb629(%rip), %r14 # 0x16fe8
movl %fs:(%r14), %eax
testl %eax, %eax
je 0xb9d0
cmpl %eax, %ebx
jne 0xb9db
popq %rbx
popq %r14
popq %rbp
retq
callq 0xf055
movl %fs:(%r14), %eax
jmp 0xb9c7
leaq 0x58b8(%rip), %rdi # 0x1129a
leaq 0x58c2(%rip), %rsi # 0x112ab
leaq 0x5916(%rip), %rcx # 0x11306
movl $0x1a, %edx
callq 0xa150
| /Raven65[P]WebServer/net/EventLoop.h |
Channel::~Channel() | Channel::~Channel() {} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x98(%rdi), %rax
testq %rax, %rax
je 0xbf6a
leaq 0x88(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x78(%rbx), %rax
testq %rax, %rax
je 0xbf81
leaq 0x68(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x58(%rbx), %rax
testq %rax, %rax
je 0xbf98
leaq 0x48(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0xbfaf
leaq 0x28(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xbfea
movq 0xafe1(%rip), %rax # 0x16fa0
cmpb $0x0, (%rax)
je 0xbfcf
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xbfd9
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xbfea
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
jmp 0xbff7
jmp 0xbff7
jmp 0xbff7
movq %rax, %rdi
callq 0xa9d4
nop
| /Raven65[P]WebServer/net/Channel.cpp |
Channel::handleEvent() | void Channel::handleEvent() {
if (fd_ == -1) return;
ChannelPtr guard(shared_from_this());
if ((revents_ & EPOLLHUP) && !(revents_ & EPOLLIN)) {
if(closeCallback_) closeCallback_();
}
if (revents_ & EPOLLERR) {
if (errorCallback_) errorCallback_();
else if (closeCallback_) closeCallback_();
}
if (revents_ & (EPOLLIN | EPOLLPRI | EPOLLRDHUP)) {
if(readCallback_) readCallback_();
}
if(revents_ & EPOLLOUT) {
if(writeCallback_) writeCallback_();
}
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
cmpl $-0x1, 0x18(%rdi)
je 0xc0b5
movq %rdi, %rbx
leaq -0x18(%rbp), %rdi
movq %rbx, %rsi
callq 0xc146
movl 0x20(%rbx), %eax
movl %eax, %ecx
andl $0x11, %ecx
cmpl $0x10, %ecx
jne 0xc049
cmpq $0x0, 0x98(%rbx)
je 0xc049
leaq 0x88(%rbx), %rdi
callq *0xa0(%rbx)
movl 0x20(%rbx), %eax
testb $0x8, %al
je 0xc07a
cmpq $0x0, 0x78(%rbx)
je 0xc060
movl $0x80, %eax
movl $0x68, %edi
jmp 0xc074
cmpq $0x0, 0x98(%rbx)
je 0xc07a
movl $0xa0, %eax
movl $0x88, %edi
addq %rbx, %rdi
callq *(%rbx,%rax)
movl 0x20(%rbx), %eax
testl $0x2003, %eax # imm = 0x2003
je 0xc095
cmpq $0x0, 0x38(%rbx)
je 0xc095
leaq 0x28(%rbx), %rdi
callq *0x40(%rbx)
movl 0x20(%rbx), %eax
testb $0x4, %al
je 0xc0a7
cmpq $0x0, 0x58(%rbx)
je 0xc0a7
leaq 0x48(%rbx), %rdi
callq *0x60(%rbx)
movq -0x10(%rbp), %rdi
testq %rdi, %rdi
je 0xc0b5
callq 0xa9e2
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x10(%rbp), %rdi
testq %rdi, %rdi
je 0xc0cd
callq 0xa9e2
movq %rbx, %rdi
callq 0xa400
nop
| /Raven65[P]WebServer/net/Channel.cpp |
EPoller::EPoller() | EPoller::EPoller() : epollfd_(epoll_create1(EPOLL_CLOEXEC)), events_(kEventInit) {
if (epollfd_ < 0) {
LOG << "Error: Epoller";
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xfd8, %rsp # imm = 0xFD8
movq %rdi, %rbx
movl $0x80000, %edi # imm = 0x80000
callq 0xa2f0
movl %eax, (%rbx)
leaq 0x8(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
xorl %r14d, %r14d
movq %r14, 0x18(%rbx)
movl $0xc000, %edi # imm = 0xC000
callq 0xa260
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
leaq 0xc000(%rax), %rcx
movq %rcx, 0x18(%rbx)
movq %r14, (%rax)
movl $0x0, 0x8(%rax)
movl $0xc, %edx
movl 0x8(%rax), %esi
movl %esi, 0x8(%rax,%rdx)
movq (%rax), %rsi
movq %rsi, (%rax,%rdx)
addq $0xc, %rdx
cmpq $0xc000, %rdx # imm = 0xC000
jne 0xc1fd
movq %rcx, 0x10(%rbx)
leaq 0x50(%rbx), %rax
movq %rax, 0x20(%rbx)
movq $0x1, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movl $0x3f800000, 0x40(%rbx) # imm = 0x3F800000
movups %xmm0, 0x48(%rbx)
cmpl $0x0, (%rbx)
jns 0xc299
addq $0x20, %rbx
leaq 0x5222(%rip), %rsi # 0x11470
leaq -0xff0(%rbp), %rdi
movl $0xb, %edx
callq 0xe738
leaq -0x48(%rbp), %rcx
movq (%rcx), %rax
subl %eax, %ecx
cmpl $0xf, %ecx
jl 0xc28d
movabsq $0x72656c6c6f704520, %rcx # imm = 0x72656C6C6F704520
movq %rcx, 0x6(%rax)
movabsq $0x45203a726f727245, %rcx # imm = 0x45203A726F727245
movq %rcx, (%rax)
addq $0xe, -0x48(%rbp)
leaq -0xff0(%rbp), %rdi
callq 0xe742
addq $0xfd8, %rsp # imm = 0xFD8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xc83a
movq (%r15), %rdi
testq %rdi, %rdi
je 0xc2bf
callq 0xa230
movq %r14, %rdi
callq 0xa400
nop
| /Raven65[P]WebServer/net/EPoller.cpp |
EPoller::~EPoller() | EPoller::~EPoller() {
close(epollfd_);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0xa470
leaq 0x20(%rbx), %rdi
callq 0xc83a
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0xc2f5
popq %rbx
popq %rbp
jmp 0xa230
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0xa9d4
| /Raven65[P]WebServer/net/EPoller.cpp |
EPoller::fillActiveChannels(int, std::vector<std::shared_ptr<Channel>, std::allocator<std::shared_ptr<Channel>>>*) const | void EPoller::fillActiveChannels(int numEvents, ChannelList* activeChannels) const {
for(int i = 0; i < numEvents; ++i) {
int fd = events_[i].data.fd;
auto it = channels_.find(fd);
assert(it != channels_.end());
auto channel = it->second;
channel->setRevents(events_[i].events);
activeChannels->push_back(channel);
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
jle 0xc449
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x20(%rdi), %r15
movl %esi, %eax
shlq $0x2, %rax
leaq (%rax,%rax,2), %r12
xorl %r13d, %r13d
movq 0x8(%r14), %rax
movl 0x4(%rax,%r13), %eax
movl %eax, -0x2c(%rbp)
movq %r15, %rdi
leaq -0x2c(%rbp), %rsi
callq 0xc920
testq %rax, %rax
je 0xc458
movq 0x10(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0xc41b
movq 0xab97(%rip), %rdx # 0x16fa0
cmpb $0x0, (%rdx)
je 0xc413
incl 0x8(%rax)
jmp 0xc41b
lock
incl 0x8(%rax)
movq -0x40(%rbp), %rcx
movq 0x8(%r14), %rax
movl (%rax,%r13), %eax
movl %eax, 0x20(%rcx)
movq %rbx, %rdi
leaq -0x40(%rbp), %rsi
callq 0xc7ec
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xc440
callq 0xa9e2
addq $0xc, %r13
cmpq %r13, %r12
jne 0xc3d0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x508d(%rip), %rdi # 0x114ec
leaq 0x500a(%rip), %rsi # 0x11470
leaq 0x5095(%rip), %rcx # 0x11502
movl $0x27, %edx
callq 0xa150
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xc488
callq 0xa9e2
movq %rbx, %rdi
callq 0xa400
| /Raven65[P]WebServer/net/EPoller.cpp |
EPoller::addChannel(std::shared_ptr<Channel>) | void EPoller::addChannel(ChannelPtr channel) {
int fd = channel->fd();
assert(channels_.find(fd) == channels_.end());
channels_[fd] = channel;
struct epoll_event event;
memset(&event, 0, sizeof event);
event.events = channel->events();
event.data.fd = fd;
if (epoll_ctl(epollfd_, EPOLL_CTL_ADD, fd, &event) < 0) {
LOG << "epoll_add error";
channels_.erase(fd);
}
// LOG << "Epoll ADD fd = " << fd;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xff0, %rsp # imm = 0xFF0
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rax
movl 0x18(%rax), %eax
leaq -0x24(%rbp), %rsi
movl %eax, (%rsi)
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0xcb0e
testq %rax, %rax
jne 0xc584
leaq -0x24(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xcb70
movq (%r15), %rcx
movq %rcx, (%rax)
leaq 0x8(%rax), %rdi
leaq 0x8(%r15), %rsi
callq 0xc8d6
leaq -0x30(%rbp), %rcx
movl $0x0, 0x8(%rcx)
movq (%r15), %rax
movl 0x1c(%rax), %eax
movl %eax, (%rcx)
movl (%r12), %edx
movl %edx, 0x4(%rcx)
movl (%r14), %edi
movl $0x1, %esi
callq 0xa310
testl %eax, %eax
jns 0xc574
leaq 0x4f53(%rip), %rsi # 0x11470
leaq -0x1008(%rbp), %rdi
movl $0x3a, %edx
callq 0xe738
leaq -0x60(%rbp), %rcx
movq (%rcx), %rax
subl %eax, %ecx
cmpl $0x10, %ecx
jl 0xc55c
movabsq $0x726f727265206464, %rcx # imm = 0x726F727265206464
movq %rcx, 0x7(%rax)
movabsq $0x64615f6c6c6f7065, %rcx # imm = 0x64615F6C6C6F7065
movq %rcx, (%rax)
addq $0xf, -0x60(%rbp)
leaq -0x1008(%rbp), %rdi
callq 0xe742
leaq -0x24(%rbp), %rsi
movq %rbx, %rdi
callq 0xce7c
addq $0xff0, %rsp # imm = 0xFF0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4fb2(%rip), %rdi # 0x1153d
leaq 0x4ede(%rip), %rsi # 0x11470
leaq 0x4fca(%rip), %rcx # 0x11563
movl $0x31, %edx
callq 0xa150
nop
| /Raven65[P]WebServer/net/EPoller.cpp |
Thread::Thread(std::function<void ()> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Thread::Thread(const ThreadFunc& func, const std::string& name)
: started_(false),
joined_(false),
pthreadId_(0),
tid_(0),
func_(func),
name_(name),
latch_(1) {
setDefaultName();
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rdi, %r14
movw $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
addq $0x18, %rdi
movq %rdi, -0x38(%rbp)
callq 0xf484
leaq 0x38(%r14), %r15
leaq 0x48(%r14), %rbx
movq %rbx, 0x38(%r14)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0xe844
leaq 0x60(%r14), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0xa360
movq %r13, 0x88(%r14)
leaq 0x90(%r14), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0xa2b0
movl $0x1, 0xc0(%r14)
movq %r14, %rdi
callq 0xf1e8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x30(%rbp)
movq %r12, %rdi
callq 0xa450
movq %r13, %rdi
callq 0xa280
movq (%r15), %rdi
cmpq %rbx, %rdi
je 0xf1bf
callq 0xa230
jmp 0xf1bf
movq %rax, -0x30(%rbp)
movq 0x28(%r14), %rax
testq %rax, %rax
je 0xf1d6
movq -0x38(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x30(%rbp), %rdi
callq 0xa400
movq %rax, %rdi
callq 0xa9d4
nop
| /Raven65[P]WebServer/base/Thread.cpp |
AsyncLogging::threadFunc() | void AsyncLogging::threadFunc() {
assert(running_ == true);
latch_.countDown();
LogFile output(basename_);
BufferPtr newBuffer(new Buffer);
newBuffer->bzero();
BufferVector buffersToWrite;
buffersToWrite.reserve(16);
while (running_) {
assert(newBuffer && newBuffer->length() == 0);
assert(buffersToWrite.empty());
{
MutexLockGuard lock(mutex_);
if(buffers_.empty()) {
cond_.waitForSeconds(flushInterval_);
}
buffers_.push_back(std::move(currentBuffer_));
currentBuffer_ = std::move(newBuffer);
buffersToWrite.swap(buffers_);
}
assert(!buffersToWrite.empty());
if (buffersToWrite.size() > 25) {
buffersToWrite.erase(buffersToWrite.begin() + 2, buffersToWrite.end());
}
for (const auto& buffer : buffersToWrite) {
output.append(buffer->data(), buffer->length());
}
if (buffersToWrite.size() > 1) {
buffersToWrite.resize(1);
}
if (!newBuffer) {
assert(!buffersToWrite.empty());
newBuffer = std::move(buffersToWrite.back());
buffersToWrite.pop_back();
newBuffer->reset();
}
buffersToWrite.clear();
output.flush();
}
output.flush();
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpb $0x0, 0x4(%rdi)
je 0xfb7b
movq %rdi, %rbx
addq $0x178, %rdi # imm = 0x178
callq 0xf55e
leaq 0x8(%rbx), %rsi
leaq -0xa8(%rbp), %rdi
movl $0x400, %edx # imm = 0x400
callq 0x105a4
movl $0x3d0908, %edi # imm = 0x3D0908
callq 0xa260
movq %rax, 0x3d0900(%rax)
leaq -0x48(%rbp), %rdi
movq %rax, -0x8(%rdi)
movq %rax, %rsi
callq 0x10074
movq -0x50(%rbp), %rdi
movl $0x3d0900, %edx # imm = 0x3D0900
xorl %esi, %esi
callq 0xa130
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x10, %esi
callq 0xfcd2
leaq 0xf0(%rbx), %rax
movq %rax, -0x70(%rbp)
leaq 0x160(%rbx), %rax
movq %rax, -0x68(%rbp)
leaq 0x118(%rbx), %rax
movq %rax, -0x58(%rbp)
leaq 0x150(%rbx), %rax
movq %rax, -0x60(%rbp)
leaq -0xa8(%rbp), %r12
cmpb $0x1, 0x4(%rbx)
jne 0xfabe
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0xfaff
cmpl %eax, 0x3d0900(%rax)
jne 0xfaff
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
movq -0x70(%rbp), %r14
jne 0xfb1e
movq %r14, %rdi
callq 0xa350
movq 0x160(%rbx), %rax
cmpq 0x168(%rbx), %rax
jne 0xf938
movl (%rbx), %esi
movq -0x58(%rbp), %rdi
callq 0xfde0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x1012c
movaps -0x50(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x50(%rbp)
movq 0x158(%rbx), %rdi
movups %xmm0, 0x150(%rbx)
testq %rdi, %rdi
je 0xf968
callq 0xa9e2
movaps -0x40(%rbp), %xmm0
movq -0x30(%rbp), %rax
movq 0x160(%rbx), %rcx
movq %rcx, -0x40(%rbp)
movq 0x168(%rbx), %rcx
movq %rcx, -0x38(%rbp)
movq 0x170(%rbx), %rcx
movq %rcx, -0x30(%rbp)
movups %xmm0, 0x160(%rbx)
movq %rax, 0x170(%rbx)
movq %r14, %rdi
callq 0xa1a0
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r13
cmpq %r13, %r15
je 0xfb3d
movq %r13, %rdx
subq %r15, %rdx
cmpq $0x191, %rdx # imm = 0x191
jb 0xf9df
leaq 0x20(%r15), %rsi
addq %r15, %rdx
leaq -0x40(%rbp), %rdi
callq 0x102d2
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r13
cmpq %r13, %r15
je 0xfa0d
movq (%r15), %rsi
movl 0x3d0900(%rsi), %edx
subl %esi, %edx
movq %r12, %rdi
callq 0x106b6
addq $0x10, %r15
cmpq %r13, %r15
jne 0xf9e4
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r14
movq %r15, %r13
jmp 0xfa10
movq %r13, %r14
movq %r14, %rax
subq %r13, %rax
cmpq $0x10, %rax
jbe 0xfa32
movl $0x1, %esi
leaq -0x40(%rbp), %rdi
callq 0xfe2a
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r14
cmpq $0x0, -0x50(%rbp)
jne 0xfa8e
cmpq %r14, %r15
je 0xfb5c
movups -0x10(%r14), %xmm0
xorps %xmm1, %xmm1
movups %xmm1, -0x10(%r14)
movq -0x48(%rbp), %rdi
movaps %xmm0, -0x50(%rbp)
testq %rdi, %rdi
je 0xfa61
callq 0xa9e2
movq -0x38(%rbp), %rax
leaq -0x10(%rax), %r14
movq %r14, -0x38(%rbp)
movq -0x8(%rax), %rdi
testq %rdi, %rdi
je 0xfa7f
callq 0xa9e2
movq -0x38(%rbp), %r14
movq -0x50(%rbp), %rax
movq %rax, 0x3d0900(%rax)
movq -0x40(%rbp), %r15
cmpq %r15, %r14
je 0xfab1
movq %r15, %r13
movq 0x8(%r13), %rdi
testq %rdi, %rdi
je 0xfaa4
callq 0xa9e2
addq $0x10, %r13
cmpq %r14, %r13
jne 0xfa96
movq %r15, -0x38(%rbp)
movq %r12, %rdi
callq 0x10734
jmp 0xf8e0
leaq -0xa8(%rbp), %rdi
callq 0x10734
leaq -0x40(%rbp), %rdi
callq 0xea9a
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0xfae1
callq 0xa9e2
leaq -0xa8(%rbp), %rdi
callq 0xfe9a
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2004(%rip), %rdi # 0x11b0a
leaq 0x1f3e(%rip), %rsi # 0x11a4b
leaq 0x1fd6(%rip), %rcx # 0x11aea
movl $0x2c, %edx
callq 0xa150
leaq 0x200c(%rip), %rdi # 0x11b31
leaq 0x1f1f(%rip), %rsi # 0x11a4b
leaq 0x1fb7(%rip), %rcx # 0x11aea
movl $0x2d, %edx
callq 0xa150
leaq 0x1fec(%rip), %rdi # 0x11b30
leaq 0x1f00(%rip), %rsi # 0x11a4b
leaq 0x1f98(%rip), %rcx # 0x11aea
movl $0x38, %edx
callq 0xa150
leaq 0x1fcd(%rip), %rdi # 0x11b30
leaq 0x1ee1(%rip), %rsi # 0x11a4b
leaq 0x1f79(%rip), %rcx # 0x11aea
movl $0x47, %edx
callq 0xa150
leaq 0x1f57(%rip), %rdi # 0x11ad9
leaq 0x1ec2(%rip), %rsi # 0x11a4b
leaq 0x1f5a(%rip), %rcx # 0x11aea
movl $0x23, %edx
callq 0xa150
jmp 0xfbb2
movq %rax, %rbx
jmp 0xfbcc
jmp 0xfbb2
movq %rax, %rbx
movq %r14, %rdi
callq 0xa1a0
jmp 0xfbb5
jmp 0xfbb2
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xea9a
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0xfbcc
callq 0xa9e2
leaq -0xa8(%rbp), %rdi
callq 0xfe9a
movq %rbx, %rdi
callq 0xa400
| /Raven65[P]WebServer/base/AsyncLogging.cpp |
LogFile::~LogFile() | ~LogFile() = default; | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x30, %rdi
callq 0xfed0
leaq 0x28(%rbx), %rdi
callq 0xfefe
movq (%rbx), %rdi
addq $0x10, %rbx
addq $0x8, %rsp
cmpq %rbx, %rdi
je 0xfecc
popq %rbx
popq %rbp
jmp 0xa230
popq %rbx
popq %rbp
retq
nop
| /Raven65[P]WebServer/base/LogFile.h |
mainMenu(std::basic_ifstream<char, std::char_traits<char>>&, std::basic_ofstream<char, std::char_traits<char>>&, std::basic_ofstream<char, std::char_traits<char>>&) | int mainMenu(ifstream &loadFile, ofstream &compressedFile, ofstream &mapper)
{
// Display user cmd line interface for selection if they want to compress or decmopress or close programm
cout << "Welcome to Pied Piper the brand new middle out compression engine"<< endl;
cout << "Please select what you would like to do..."<< endl;
cout << "1) Compress File" << endl;
cout << "2) Decompress File" <<endl;
cout << "3) Close Program and install virus"<<endl;
// Take in user input
int userChoice = 0;
cin >> userChoice;
// Check agianst choices
if (userChoice == 1)
{
// Compress File
// If compressing take in the folder they want the .pra files stored I recommend a folder called Compressed
cout << "Please enter the folder path to where you would like to save .pra file..." <<endl;
string folderName;
cin >> folderName;
// Ask the user to enter the path to the source file they want to try and compress
cout << "Please enter directory of file with file name..." <<endl;
string fileName;
cin >> fileName;
// Initialize the fstreams based on the values passed in by the user
initalizeFiles(loadFile, compressedFile, mapper, folderName, fileName);
cout << endl; // Display cleanup
// Inform the user compression is starting
// TODO: Add progress bar
cout << "COMPRESSING....."<<endl;
// Parse through the file once looking for unique words and saving the top three used with corresponding single
// byte representations
preCompress(loadFile, compressedFile);
// Parse through file a second time this time looking for any word matching the top three from preCompression
// and replacing them with the single byte mapping
compressor(loadFile, compressedFile, mapper);
}
else if (userChoice == 2)
{
// Decompress File
// If Decompressing have user enter folder of .pra files
cout << "Please enter the path of the folder containing the .pra mapper and compressed file"<<endl;
string folderName;
cin >> folderName;
// Run decopression saving a new decmopressed file in the same folder as the main.cpp file and call it
// Decmpressed.txt
// TODO: Change save directory to compressed .pra folder and resave as original source file name
decompress(folderName);
// Inform the user its decompressing their file
cout << endl;
cout << "DECOMPRESSING..." <<endl;
}
else if (userChoice == 3)
{
// Close the program
return 0;
}
else
{
// User did not select 1-3
cerr << "Not a valid choice pick again..." <<endl;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x4675(%rip), %r12 # 0x6fc0
leaq 0x2771(%rip), %rsi # 0x50c3
movl $0x41, %edx
movq %r12, %rdi
callq 0x2210
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x2777(%rip), %rsi # 0x5105
movl $0x2a, %edx
movq %r12, %rdi
callq 0x2210
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x2766(%rip), %rsi # 0x5130
movl $0x10, %edx
movq %r12, %rdi
callq 0x2210
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x273b(%rip), %rsi # 0x5141
movl $0x12, %edx
movq %r12, %rdi
callq 0x2210
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x2712(%rip), %rsi # 0x5154
movl $0x22, %edx
movq %r12, %rdi
callq 0x2210
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x44(%rsp), %r12
movl $0x0, (%r12)
movq 0x454d(%rip), %rdi # 0x6fd8
movq %r12, %rsi
callq 0x20e0
movl (%r12), %eax
cmpl $0x3, %eax
jne 0x2ab0
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %eax
je 0x2c37
cmpl $0x1, %eax
jne 0x2cf6
movq 0x44f7(%rip), %r12 # 0x6fc0
leaq 0x26a7(%rip), %rsi # 0x5177
movl $0x49, %edx
movq %r12, %rdi
callq 0x2210
movq %r12, %rdi
callq 0x20b0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x44d4(%rip), %rdi # 0x6fd8
movq %rsp, %rsi
callq 0x2240
movq 0x44ad(%rip), %rdi # 0x6fc0
leaq 0x26a7(%rip), %rsi # 0x51c1
movl $0x30, %edx
callq 0x2210
movq 0x4495(%rip), %rdi # 0x6fc0
callq 0x20b0
leaq 0x98(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq 0x4488(%rip), %rdi # 0x6fd8
leaq 0x88(%rsp), %rsi
callq 0x2240
leaq 0x78(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x68(%rsp), %rdi
callq 0x272c
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x272c
leaq 0x68(%rsp), %rcx
leaq 0x20(%rsp), %r8
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x27bc
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x2bd6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2bed
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x43cc(%rip), %rdi # 0x6fc0
callq 0x20b0
movq 0x43c0(%rip), %rdi # 0x6fc0
leaq 0x25eb(%rip), %rsi # 0x51f2
movl $0x10, %edx
callq 0x2210
movq 0x43a8(%rip), %rdi # 0x6fc0
callq 0x20b0
leaq 0x4574(%rip), %rax # 0x7198
movb $0x1, (%rax)
movl $0x1, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x374f
movq 0x4382(%rip), %rbx # 0x6fc0
leaq 0x25be(%rip), %rsi # 0x5203
movl $0x52, %edx
movq %rbx, %rdi
callq 0x2210
movq %rbx, %rdi
callq 0x20b0
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq 0x4362(%rip), %rdi # 0x6fd8
movq %rsp, %rsi
callq 0x2240
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x272c
leaq 0x48(%rsp), %rdi
callq 0x2f67
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x2cbe
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x42fb(%rip), %rdi # 0x6fc0
callq 0x20b0
movq 0x42ef(%rip), %rdi # 0x6fc0
leaq 0x257e(%rip), %rsi # 0x5256
movl $0x10, %edx
callq 0x2210
movq 0x42d7(%rip), %rdi # 0x6fc0
callq 0x20b0
movq %rsp, %rdi
callq 0x2320
callq 0x2330
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x2d1f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21d0
jmp 0x2d1f
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2d3b
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x21d0
jmp 0x2d3b
movq %rax, %rbx
movq 0x88(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d87
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x21d0
jmp 0x2d87
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x2d79
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21d0
jmp 0x2d79
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
jne 0x2d90
jmp 0x2d9d
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2d9d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22d0
| /Christian-Prather[P]Pied-Piper/HelperFunctions.cpp |
xs::sendMessage(de::Socket&, xs::Message const&) | void sendMessage (de::Socket& socket, const Message& message)
{
// Format message.
vector<deUint8> buf;
message.write(buf);
// Write to socket.
size_t pos = 0;
while (pos < buf.size())
{
size_t numLeft = buf.size() - pos;
size_t numSent = 0;
deSocketResult result = socket.send(&buf[pos], numLeft, &numSent);
if (result != DE_SOCKETRESULT_SUCCESS)
throw SocketError(result, "send() failed", __FILE__, __LINE__);
pos += numSent;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
subq %rsi, %rdx
je 0x6626
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
subq %r15, %rdx
movq $0x0, 0x8(%rsp)
addq %r15, %rsi
movq (%rbx), %rdi
movq %r14, %rcx
callq 0x933e
movl %eax, %ebp
testl %eax, %eax
jne 0x6649
addq 0x8(%rsp), %r15
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
subq %rsi, %rdx
cmpq %rdx, %r15
jb 0x65ef
testq %rsi, %rsi
je 0x663e
movq 0x20(%rsp), %rax
subq %rsi, %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x6250
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x18, %edi
callq 0x6120
movq %rax, %r14
leaq 0x39cb(%rip), %rdx # 0xa028
leaq 0x39d2(%rip), %rcx # 0xa036
movq %rax, %rdi
movl %ebp, %esi
movl $0x4e, %r8d
callq 0x726a
leaq 0x73f5(%rip), %rsi # 0xda70
movq 0x794e(%rip), %rdx # 0xdfd0
movq %r14, %rdi
callq 0x6430
jmp 0x669b
jmp 0x669b
movq %rax, %rbx
movq %r14, %rdi
callq 0x61f0
jmp 0x669e
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x66b5
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6250
movq %rbx, %rdi
callq 0x6450
| /kaydenl[P]VK-GL-CTS/execserver/tools/xsClient.cpp |
xs::readMessage(de::Socket&) | Message* readMessage (de::Socket& socket)
{
// Header.
vector<deUint8> header;
readBytes(socket, header, MESSAGE_HEADER_SIZE);
MessageType type;
size_t messageSize;
Message::parseHeader(&header[0], (int)header.size(), type, messageSize);
// Simple messages without any data.
switch (type)
{
case MESSAGETYPE_KEEPALIVE: return new KeepAliveMessage();
case MESSAGETYPE_PROCESS_STARTED: return new ProcessStartedMessage();
default:
break; // Read message with data.
}
vector<deUint8> messageBuf;
readBytes(socket, messageBuf, messageSize-MESSAGE_HEADER_SIZE);
switch (type)
{
case MESSAGETYPE_HELLO: return new HelloMessage(&messageBuf[0], (int)messageBuf.size());
case MESSAGETYPE_TEST: return new TestMessage(&messageBuf[0], (int)messageBuf.size());
case MESSAGETYPE_PROCESS_LOG_DATA: return new ProcessLogDataMessage(&messageBuf[0], (int)messageBuf.size());
case MESSAGETYPE_INFO: return new InfoMessage(&messageBuf[0], (int)messageBuf.size());
case MESSAGETYPE_PROCESS_LAUNCH_FAILED: return new ProcessLaunchFailedMessage(&messageBuf[0], (int)messageBuf.size());
case MESSAGETYPE_PROCESS_FINISHED: return new ProcessFinishedMessage(&messageBuf[0], (int)messageBuf.size());
default:
XS_FAIL("Unknown message");
}
} | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movl $0x8, %edx
callq 0x66bd
movq 0x30(%rsp), %rdi
movl 0x38(%rsp), %eax
subl %edi, %eax
movslq %eax, %rsi
leaq 0xc(%rsp), %rdx
leaq 0x50(%rsp), %rcx
callq 0x781a
movl 0xc(%rsp), %eax
cmpl $0x66, %eax
je 0x67e9
cmpl $0xc8, %eax
jne 0x680c
movl $0x10, %edi
callq 0x6240
movq %rax, %rbx
movl $0xc8, 0x8(%rax)
leaq 0x7351(%rip), %rax # 0xdb38
jmp 0x6804
movl $0x10, %edi
callq 0x6240
movq %rax, %rbx
movl $0x66, 0x8(%rax)
leaq 0x72f4(%rip), %rax # 0xdaf8
movq %rax, (%rbx)
jmp 0x6956
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq 0x50(%rsp), %rdx
addq $-0x8, %rdx
movq %rbx, %rdi
callq 0x66bd
movl 0xc(%rsp), %eax
leal -0xc9(%rax), %ecx
cmpl $0x3, %ecx
ja 0x6877
leaq 0x37be(%rip), %rax # 0xa004
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x30, %edi
callq 0x6240
movq %rax, %rbx
movq 0x10(%rsp), %rsi
movl 0x18(%rsp), %eax
subl %esi, %eax
movslq %eax, %rdx
movq %rbx, %rdi
callq 0x7d68
jmp 0x693f
cmpl $0x64, %eax
je 0x68d2
cmpl $0x65, %eax
jne 0x6978
movl $0x30, %edi
callq 0x6240
movq %rax, %rbx
movq 0x10(%rsp), %rsi
movl 0x18(%rsp), %eax
subl %esi, %eax
movslq %eax, %rdx
movq %rbx, %rdi
callq 0x7a14
jmp 0x693f
movl $0x30, %edi
callq 0x6240
movq %rax, %rbx
movq 0x10(%rsp), %rsi
movl 0x18(%rsp), %eax
subl %esi, %eax
movslq %eax, %rdx
movq %rbx, %rdi
callq 0x7c9a
jmp 0x693f
movl $0x10, %edi
callq 0x6240
movq %rax, %rbx
movq 0x10(%rsp), %rsi
movl 0x18(%rsp), %eax
subl %esi, %eax
movslq %eax, %rdx
movq %rbx, %rdi
callq 0x7960
jmp 0x693f
movl $0x30, %edi
callq 0x6240
movq %rax, %rbx
movq 0x10(%rsp), %rsi
movl 0x18(%rsp), %eax
subl %esi, %eax
movslq %eax, %rdx
movq %rbx, %rdi
callq 0x7eea
jmp 0x693f
movl $0x10, %edi
callq 0x6240
movq %rax, %rbx
movq 0x10(%rsp), %rsi
movl 0x18(%rsp), %eax
subl %esi, %eax
movslq %eax, %rdx
movq %rbx, %rdi
callq 0x7e36
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x6956
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6250
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x696d
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x6250
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x6120
movq %rax, %rbx
leaq 0x3724(%rip), %rsi # 0xa0b0
leaq 0x3741(%rip), %rdx # 0xa0d4
leaq 0x369c(%rip), %rcx # 0xa036
movq %rax, %rdi
movl $0x84, %r8d
callq 0x75c0
leaq 0x70a9(%rip), %rsi # 0xda58
movq 0x761a(%rip), %rdx # 0xdfd0
movq %rbx, %rdi
callq 0x6430
movq %rax, %r14
movq %rbx, %rdi
callq 0x61f0
jmp 0x69f2
jmp 0x69dd
jmp 0x69d1
jmp 0x69dd
movq %rax, %r14
movl $0x10, %esi
jmp 0x69e5
jmp 0x69dd
movq %rax, %r14
movl $0x30, %esi
movq %rbx, %rdi
callq 0x6250
jmp 0x69f2
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x6a10
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6250
jmp 0x6a10
jmp 0x6a0d
movq %rax, %r14
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x6a27
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x6250
movq %r14, %rdi
callq 0x6450
nop
| /kaydenl[P]VK-GL-CTS/execserver/tools/xsClient.cpp |
xs::parseString[abi:cxx11](char const*) | string parseString (const char* str)
{
if (str[0] == '\'' || str[0] == '"')
{
const char* p = str;
char endChar = *p++;
std::ostringstream o;
while (*p != endChar && *p)
{
if (*p == '\\')
{
switch (p[1])
{
case 0: DE_ASSERT(DE_FALSE); break;
case 'n': o << '\n'; break;
case 't': o << '\t'; break;
default: o << p[1]; break;
}
p += 2;
}
else
o << *p++;
}
return o.str();
}
else
return string(str);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %ebp
cmpl $0x27, %ebp
je 0x6d82
cmpl $0x22, %ebp
jne 0x6e60
leaq 0x8(%rsp), %rdi
callq 0x6330
movb 0x1(%r14), %al
cmpb %bpl, %al
sete %cl
testb %al, %al
sete %dl
orb %cl, %dl
jne 0x6e36
incq %r14
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %r12
cmpb $0x5c, %al
jne 0x6dde
movzbl 0x1(%r14), %eax
testl %eax, %eax
je 0x6e22
cmpl $0x74, %eax
je 0x6df7
cmpl $0x6e, %eax
jne 0x6e0e
movb $0xa, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x6290
jmp 0x6e22
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x6290
incq %r14
jmp 0x6e26
movb $0x9, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x6290
jmp 0x6e22
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x6290
addq $0x2, %r14
movb (%r14), %al
cmpb %bpl, %al
je 0x6e36
testb %al, %al
jne 0x6db0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x63e0
movq 0x717e(%rip), %rsi # 0xdfc8
leaq 0x8(%rsp), %rdi
callq 0x6170
leaq 0x78(%rsp), %rdi
callq 0x60e0
jmp 0x6e7e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x6110
leaq (%rax,%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73fe
movq %rbx, %rax
addq $0x180, %rsp # imm = 0x180
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6e93
movq %rax, %rbx
movq 0x712b(%rip), %rsi # 0xdfc8
leaq 0x8(%rsp), %rdi
callq 0x6170
leaq 0x78(%rsp), %rdi
callq 0x60e0
movq %rbx, %rdi
callq 0x6450
| /kaydenl[P]VK-GL-CTS/execserver/tools/xsClient.cpp |
xs::runClient(int, char const* const*) | int runClient (int argc, const char* const* argv)
{
CommandLine cmdLine;
// Defaults.
cmdLine.address.setHost("127.0.0.1");
cmdLine.address.setPort(50016);
cmdLine.dstFileName = "TestResults.qpa";
// Parse command line.
for (int argNdx = 1; argNdx < argc; argNdx++)
{
const char* arg = argv[argNdx];
if (deStringBeginsWith(arg, "--port="))
cmdLine.address.setPort(atoi(arg+7));
else if (deStringBeginsWith(arg, "--host="))
cmdLine.address.setHost(parseString(arg+7).c_str());
else if (deStringBeginsWith(arg, "--program="))
cmdLine.program = parseString(arg+10);
else if (deStringBeginsWith(arg, "--params="))
cmdLine.params = parseString(arg+9);
else if (deStringBeginsWith(arg, "--workdir="))
cmdLine.workingDir = parseString(arg+10);
else if (deStringBeginsWith(arg, "--caselist="))
cmdLine.caseList = parseString(arg+11);
else if (deStringBeginsWith(arg, "--out="))
cmdLine.dstFileName = parseString(arg+6);
else
{
printHelp(argv[0]);
return -1;
}
}
// Run client.
try
{
Client client(cmdLine);
client.run();
}
catch (const std::exception& e)
{
printf("%s\n", e.what());
return -1;
}
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x8328
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
xorl %ecx, %ecx
movq %rcx, -0x8(%rax)
movb %cl, (%rax)
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rcx, -0x8(%rax)
movb %cl, (%rax)
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rcx, -0x8(%rax)
movb %cl, (%rax)
leaq 0x98(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rcx, -0x8(%rax)
movb %cl, (%rax)
leaq 0xb8(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rcx, -0x8(%rax)
movb %cl, (%rax)
leaq 0x31c6(%rip), %rsi # 0xa163
movq %r14, %rdi
callq 0x837e
leaq 0x20(%rsp), %rdi
movl $0xc360, %esi # imm = 0xC360
callq 0x83dc
leaq 0xa8(%rsp), %rdi
movq 0x8(%rdi), %rdx
leaq 0x31a6(%rip), %rcx # 0xa16d
movl $0xf, %r8d
xorl %esi, %esi
callq 0x63c0
cmpl $0x2, %ebp
jl 0x718a
movl %ebp, %r13d
movl $0x1, %r14d
leaq 0x3190(%rip), %rbp # 0xa17d
leaq 0x20(%rsp), %r12
movq (%rbx,%r14,8), %r15
movq %r15, %rdi
movq %rbp, %rsi
callq 0x9940
testl %eax, %eax
je 0x7028
addq $0x7, %r15
movq %r15, %rdi
callq 0x63d0
movq %r12, %rdi
movl %eax, %esi
callq 0x83dc
incq %r14
cmpq %r14, %r13
jne 0x6ff2
jmp 0x718a
movq %r15, %rdi
leaq 0x3153(%rip), %rsi # 0xa185
callq 0x9940
testl %eax, %eax
je 0x7073
addq $0x7, %r15
movq %rsp, %rdi
movq %r15, %rsi
callq 0x6d5c
movq (%rsp), %rsi
movq %r12, %rdi
callq 0x837e
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x701b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6250
jmp 0x701b
movq %r15, %rdi
leaq 0x3110(%rip), %rsi # 0xa18d
callq 0x9940
testl %eax, %eax
je 0x70a2
addq $0xa, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6d5c
leaq 0x28(%rsp), %rdi
jmp 0x715d
movq %r15, %rdi
leaq 0x30ec(%rip), %rsi # 0xa198
callq 0x9940
testl %eax, %eax
je 0x70d1
addq $0x9, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6d5c
leaq 0x48(%rsp), %rdi
jmp 0x715d
movq %r15, %rdi
leaq 0x30c7(%rip), %rsi # 0xa1a2
callq 0x9940
testl %eax, %eax
je 0x70fd
addq $0xa, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6d5c
leaq 0x68(%rsp), %rdi
jmp 0x715d
movq %r15, %rdi
leaq 0x30a6(%rip), %rsi # 0xa1ad
callq 0x9940
testl %eax, %eax
je 0x712c
addq $0xb, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6d5c
leaq 0x88(%rsp), %rdi
jmp 0x715d
movq %r15, %rdi
leaq 0x3083(%rip), %rsi # 0xa1b9
callq 0x9940
testl %eax, %eax
je 0x71d0
addq $0x6, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6d5c
leaq 0xa8(%rsp), %rdi
movq %r12, %rsi
callq 0x62d0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x7180
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6250
leaq 0x20(%rsp), %r12
jmp 0x701b
leaq 0x8(%rsp), %r14
leaq 0x20(%rsp), %rax
movq %rax, -0x8(%r14)
movq %r14, %rdi
callq 0x8554
movq %rsp, %rdi
callq 0x6a46
movq %r14, %rdi
callq 0x8596
xorl %ebx, %ebx
leaq 0x20(%rsp), %rdi
callq 0x735a
movl %ebx, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
callq 0x6eb9
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
jmp 0x71b2
jmp 0x7250
jmp 0x7250
jmp 0x7250
jmp 0x7250
movq %rdx, %r15
movq %rax, %rbx
movq %r14, %rdi
callq 0x8596
jmp 0x71fd
movq %rdx, %r15
movq %rax, %rbx
cmpl $0x1, %r15d
jne 0x7253
movq %rbx, %rdi
callq 0x6100
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, %rdi
callq 0x63b0
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
callq 0x6400
jmp 0x71b2
jmp 0x7250
jmp 0x7250
jmp 0x7250
jmp 0x7250
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x7253
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6250
jmp 0x7253
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x735a
movq %rbx, %rdi
callq 0x6450
| /kaydenl[P]VK-GL-CTS/execserver/tools/xsClient.cpp |
xs::Error::Error(char const*, char const*, char const*, int) | Error::Error (const char* message, const char* expr, const char* file, int line)
: std::runtime_error(formatError(message, expr, file, line))
{
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movl %r8d, 0xc(%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x30(%rsp), %r13
movq %r13, %rdi
callq 0x6330
testq %r12, %r12
leaq 0x2df5(%rip), %rbp # 0xa3ee
cmovneq %r12, %rbp
movq %rbp, %rdi
callq 0x6110
movq %r13, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x6290
leaq 0x2de9(%rip), %rsi # 0xa403
leaq 0x30(%rsp), %rdi
movl $0x2, %edx
callq 0x6290
testq %r15, %r15
je 0x7673
leaq 0xb(%rsp), %rsi
movb $0x27, (%rsi)
leaq 0x30(%rsp), %rdi
movl $0x1, %edx
callq 0x6290
movq %rax, %r12
movq %r15, %rdi
callq 0x6110
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x6290
leaq 0xb(%rsp), %rsi
movb $0x27, (%rsi)
movl $0x1, %edx
movq %r12, %rdi
callq 0x6290
leaq 0x2d8c(%rip), %rsi # 0xa406
leaq 0x30(%rsp), %rdi
movl $0x4, %edx
callq 0x6290
testq %r14, %r14
je 0x76a8
movq %r14, %rdi
callq 0x6110
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x6290
jmp 0x76c4
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x30, %rdi
movl 0x20(%rdi), %esi
orl $0x1, %esi
callq 0x6420
leaq 0x2d40(%rip), %rsi # 0xa40b
leaq 0x30(%rsp), %rdi
movl $0x1, %edx
callq 0x6290
leaq 0x30(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x6440
leaq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x63e0
movq 0x68ca(%rip), %rsi # 0xdfc8
leaq 0x30(%rsp), %rdi
callq 0x6170
leaq 0xa0(%rsp), %rdi
callq 0x60e0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x62e0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x773d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6250
leaq 0x6434(%rip), %rax # 0xdb78
movq %rax, (%rbx)
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x779a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6250
jmp 0x779a
movq %rax, %rbx
movq 0x6845(%rip), %rsi # 0xdfc8
leaq 0x30(%rsp), %rdi
callq 0x6170
leaq 0xa0(%rsp), %rdi
callq 0x60e0
movq %rbx, %rdi
callq 0x6450
| /kaydenl[P]VK-GL-CTS/execserver/xsDefs.cpp |
xs::Message::parseHeader(unsigned char const*, unsigned long, xs::MessageType&, unsigned long&) | void Message::parseHeader (const deUint8* data, size_t dataSize, MessageType& type, size_t& size)
{
XS_CHECK_MSG(dataSize >= MESSAGE_HEADER_SIZE, "Incomplete header");
MessageParser parser(data, dataSize);
size = (size_t)(MessageType)parser.get<int>();
type = (MessageType)parser.get<int>();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpq $0x7, %rsi
jbe 0x7864
movq %rcx, %r14
movq %rdx, %rbx
leaq 0x8(%rsp), %r15
movq %rdi, (%r15)
movq %rsi, 0x8(%r15)
movq $0x0, 0x10(%r15)
movq %r15, %rdi
callq 0x7fb8
movl %eax, %eax
movq %rax, (%r14)
movq %r15, %rdi
callq 0x7fb8
movl %eax, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x6120
movq %rax, %rbx
leaq 0x2b95(%rip), %rsi # 0xa40d
leaq 0x2ba0(%rip), %rdx # 0xa41f
leaq 0x2bb9(%rip), %rcx # 0xa43f
movq %rax, %rdi
movl $0x8f, %r8d
callq 0x75c0
leaq 0x61bd(%rip), %rsi # 0xda58
movq 0x672e(%rip), %rdx # 0xdfd0
movq %rbx, %rdi
callq 0x6430
movq %rax, %r14
movq %rbx, %rdi
callq 0x61f0
movq %r14, %rdi
callq 0x6450
nop
| /kaydenl[P]VK-GL-CTS/execserver/xsProtocol.cpp |
xs::ExecuteBinaryMessage::write(std::vector<unsigned char, std::allocator<unsigned char>>&) const | void ExecuteBinaryMessage::write (vector<deUint8>& buf) const
{
MessageWriter writer(type, buf);
writer.put(name.c_str());
writer.put(params.c_str());
writer.put(workDir.c_str());
writer.put(caseList.c_str());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movl 0x8(%rdi), %esi
movq %rsp, %r14
movq %r14, %rdi
callq 0x8038
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x77c6
movq 0x30(%rbx), %rsi
movq %rsp, %rdi
callq 0x77c6
movq 0x50(%rbx), %rsi
movq %rsp, %rdi
callq 0x77c6
movq 0x70(%rbx), %rsi
movq %rsp, %rdi
callq 0x77c6
movq (%rsp), %rax
movl 0x8(%rax), %ecx
movq (%rax), %rax
subl %eax, %ecx
bswapl %ecx
movl %ecx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rsp), %rcx
movl 0x8(%rcx), %edx
movq (%rcx), %rcx
subl %ecx, %edx
bswapl %edx
movl %edx, (%rcx)
movq %rax, %rdi
callq 0x6450
| /kaydenl[P]VK-GL-CTS/execserver/xsProtocol.cpp |
int xs::MessageParser::get<int>() | T get (void)
{
XS_CHECK_MSG(m_pos + sizeof(T) <= m_size, "Invalid payload size");
T netValue;
deMemcpy(&netValue, &m_data[m_pos], sizeof(T));
m_pos += sizeof(T);
return networkToHost(netValue);
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
leaq 0x4(%rax), %rcx
cmpq 0x8(%rdi), %rcx
ja 0x7fde
movq (%rdi), %rdx
movl (%rdx,%rax), %eax
movq %rcx, 0x10(%rdi)
bswapl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x6120
movq %rax, %rbx
leaq 0x24d1(%rip), %rsi # 0xa4c3
leaq 0x250a(%rip), %rdx # 0xa503
leaq 0x243f(%rip), %rcx # 0xa43f
movq %rax, %rdi
movl $0x3c, %r8d
callq 0x75c0
leaq 0x5a43(%rip), %rsi # 0xda58
movq 0x5fb4(%rip), %rdx # 0xdfd0
movq %rbx, %rdi
callq 0x6430
movq %rax, %r14
movq %rbx, %rdi
callq 0x61f0
movq %r14, %rdi
callq 0x6450
nop
| /kaydenl[P]VK-GL-CTS/execserver/xsProtocol.cpp |
xs::InfoMessage::~InfoMessage() | ~InfoMessage (void) {} | movq %rdi, %rax
leaq 0x5a14(%rip), %rcx # 0xdc90
movq %rcx, (%rdi)
movq 0x10(%rdi), %rdi
addq $0x20, %rax
cmpq %rax, %rdi
je 0x8297
movq (%rax), %rsi
incq %rsi
jmp 0x6250
retq
| /kaydenl[P]VK-GL-CTS/execserver/xsProtocol.hpp |
xs::TestMessage::~TestMessage() | ~TestMessage (void) {} | movq %rdi, %rax
leaq 0x58f2(%rip), %rcx # 0xdbc8
movq %rcx, (%rdi)
movq 0x10(%rdi), %rdi
addq $0x20, %rax
cmpq %rax, %rdi
je 0x82f1
movq (%rax), %rsi
incq %rsi
jmp 0x6250
retq
| /kaydenl[P]VK-GL-CTS/execserver/xsProtocol.hpp |
de::Socket::listen(de::SocketAddress const&) | void Socket::listen (const SocketAddress& address)
{
if (!deSocket_listen(m_socket, address))
throw SocketError("Listening on socket failed");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0x8ee3
testl %eax, %eax
je 0x8686
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x6120
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1fce(%rip), %rsi # 0xa671
leaq 0x1fe1(%rip), %rdx # 0xa68b
leaq 0x8(%rsp), %rdi
callq 0x73fe
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x62e0
leaq 0x56ad(%rip), %rax # 0xdd78
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x5679(%rip), %rsi # 0xdd50
movq 0x58f2(%rip), %rdx # 0xdfd0
movq %rbx, %rdi
callq 0x6430
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8708
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6250
jmp 0x8708
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x8715
movq %rbx, %rdi
callq 0x61f0
movq %r14, %rdi
callq 0x6450
nop
| /kaydenl[P]VK-GL-CTS/framework/delibs/decpp/deSocket.cpp |
deSocket_setFlags | deBool deSocket_setFlags (deSocket* sock, deUint32 flags)
{
deSocketHandle fd = sock->handle;
if (sock->state == DE_SOCKETSTATE_CLOSED)
return DE_FALSE;
/* Keepalive. */
{
int mode = (flags & DE_SOCKET_KEEPALIVE) ? 1 : 0;
if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (const char*)&mode, sizeof(mode)) != 0)
return DE_FALSE;
}
/* Nodelay. */
{
int mode = (flags & DE_SOCKET_NODELAY) ? 1 : 0;
if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (const char*)&mode, sizeof(mode)) != 0)
return DE_FALSE;
}
/* Non-blocking. */
{
#if defined(DE_USE_WINSOCK)
u_long mode = (flags & DE_SOCKET_NONBLOCKING) ? 1 : 0;
if (ioctlsocket(fd, FIONBIO, &mode) != 0)
return DE_FALSE;
#else
int oldFlags = fcntl(fd, F_GETFL, 0);
int newFlags = (flags & DE_SOCKET_NONBLOCKING) ? (oldFlags | O_NONBLOCK) : (oldFlags & ~O_NONBLOCK);
if (fcntl(fd, F_SETFL, newFlags) != 0)
return DE_FALSE;
#endif
}
/* Close on exec. */
{
#if defined(DE_USE_BERKELEY_SOCKETS)
int oldFlags = fcntl(fd, F_GETFD, 0);
int newFlags = (flags & DE_SOCKET_CLOSE_ON_EXEC) ? (oldFlags | FD_CLOEXEC) : (oldFlags & ~FD_CLOEXEC);
if (fcntl(fd, F_SETFD, newFlags) != 0)
return DE_FALSE;
#endif
}
return DE_TRUE;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl (%rdi), %ebp
xorl %r14d, %r14d
cmpl $0x0, 0x10(%rdi)
je 0x8ed7
movl %esi, %ebx
movl %esi, %eax
andl $0x1, %eax
leaq 0xc(%rsp), %rcx
movl %eax, (%rcx)
movl %ebp, %edi
movl $0x1, %esi
movl $0x9, %edx
movl $0x4, %r8d
callq 0x6460
testl %eax, %eax
jne 0x8ed7
movl %ebx, %eax
shrl %eax
andl $0x1, %eax
leaq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movl %ebp, %edi
movl $0x6, %esi
movl $0x1, %edx
movl $0x4, %r8d
callq 0x6460
testl %eax, %eax
jne 0x8ed7
xorl %r14d, %r14d
movl %ebp, %edi
movl $0x3, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x61a0
andl $0xfffff7ff, %eax # imm = 0xFFFFF7FF
movl %ebx, %edx
andl $0x4, %edx
shll $0x9, %edx
orl %eax, %edx
movl %ebp, %edi
movl $0x4, %esi
xorl %eax, %eax
callq 0x61a0
testl %eax, %eax
jne 0x8ed7
movl %ebp, %edi
movl $0x1, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x61a0
andl $-0x2, %eax
shrl $0x3, %ebx
andl $0x1, %ebx
orl %eax, %ebx
movl %ebp, %edi
movl $0x2, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x61a0
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| /kaydenl[P]VK-GL-CTS/framework/delibs/deutil/deSocket.c |
deSocket_receive | deSocketResult deSocket_receive (deSocket* sock, void* buf, size_t bufSize, size_t* numReceivedPtr)
{
int numRecv = (int)recv(sock->handle, (char*)buf, (NativeSize)bufSize, 0);
deSocketResult result = mapSendRecvResult(numRecv);
if (numReceivedPtr)
*numReceivedPtr = (numRecv > 0) ? ((size_t)numRecv) : (0);
/* Update state. */
if (result == DE_SOCKETRESULT_CONNECTION_CLOSED)
deSocket_setChannelsClosed(sock, DE_SOCKETCHANNEL_RECEIVE);
else if (result == DE_SOCKETRESULT_CONNECTION_TERMINATED)
deSocket_setChannelsClosed(sock, DE_SOCKETCHANNEL_BOTH);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
movl (%rdi), %edi
xorl %ecx, %ecx
callq 0x60d0
movq %rax, %r15
movl %r15d, %edi
callq 0x93c5
movl %eax, %ebp
testq %r14, %r14
je 0x9436
xorl %eax, %eax
testl %r15d, %r15d
movslq %r15d, %rcx
cmovgq %rcx, %rax
movq %rax, (%r14)
cmpl $0x3, %ebp
je 0x9453
cmpl $0x2, %ebp
jne 0x9479
leaq 0x8(%rbx), %r14
movq 0x8(%rbx), %rdi
callq 0x9533
andl $-0x2, 0x14(%rbx)
jmp 0x9464
leaq 0x8(%rbx), %r14
movq 0x8(%rbx), %rdi
callq 0x9533
andl $-0x4, 0x14(%rbx)
cmpl $0x0, 0x14(%rbx)
jne 0x9471
movl $0x3, 0x10(%rbx)
movq (%r14), %rdi
callq 0x9538
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /kaydenl[P]VK-GL-CTS/framework/delibs/deutil/deSocket.c |
deMalloc | DE_BEGIN_EXTERN_C
/*--------------------------------------------------------------------*//*!
* \brief Allocate a chunk of memory.
* \param numBytes Number of bytes to allocate.
* \return Pointer to the allocated memory (or null on failure).
*//*--------------------------------------------------------------------*/
void* deMalloc (size_t numBytes)
{
void* ptr;
DE_ASSERT(numBytes > 0);
ptr = malloc((size_t)numBytes);
#if defined(DE_DEBUG)
/* Trash memory in debug builds (if under Valgrind, don't make it think we're initializing data here). */
if (ptr)
memset(ptr, 0xcd, numBytes);
#if defined(DE_VALGRIND_BUILD) && defined(HAVE_VALGRIND_MEMCHECK_H)
if (ptr && RUNNING_ON_VALGRIND)
{
VALGRIND_MAKE_MEM_UNDEFINED(ptr, numBytes);
}
#endif
#endif
return ptr;
} | jmp 0x6310
| /kaydenl[P]VK-GL-CTS/framework/delibs/debase/deMemory.c |
vs_start | int vs_start(struct bitstream *str, uint32_t *val) {
if (str->type == VS_H261 || str->type == VS_H263) {
int nzbit = (str->type == VS_H261 ? 15 : 16);
int nsbit = (str->type == VS_H261 ? 4 : 5);
int bit = 0;
while (str->zero_bits < nzbit) {
if (vs_bit(str, &bit)) return 1;
if (bit != 0) {
fprintf(stderr, "Found premature 1 bit when searching for a start code!\n");
return 1;
}
}
while (bit == 0) {
bit = 1;
if (vs_bit(str, &bit)) return 1;
}
if (vs_u(str, val, nsbit)) return 1;
return 0;
} else {
if (str->bitpos != 7) {
fprintf (stderr, "Start code attempted at non-bytealigned position\n");
return 1;
}
if (str->dir == VS_ENCODE) {
ADDARRAY(str->bytes, 0);
ADDARRAY(str->bytes, 0);
ADDARRAY(str->bytes, 1);
ADDARRAY(str->bytes, *val);
} else {
str->zero_bytes--;
do {
str->zero_bytes++;
if (str->bytepos >= str->bytesnum) {
fprintf(stderr, "End of bitstream when searching for a start code!\n");
return 1;
}
str->curbyte = str->bytes[str->bytepos++];
} while (str->curbyte == 0);
if (str->curbyte != 1) {
fprintf(stderr, "Found byte %08x when searching for a start code!\n", str->curbyte);
return 1;
}
if (str->zero_bytes < 2) {
fprintf(stderr, "Found premature byte %08x when searching for a start code!\n", str->curbyte);
return 1;
}
if (str->bytepos >= str->bytesnum) {
fprintf(stderr, "End of bitstream when searching for a start code!\n");
return 1;
}
str->curbyte = str->bytes[str->bytepos++];
str->zero_bytes = 0;
*val = str->curbyte;
}
}
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x2c(%rdi), %eax
testl $0xfffffffd, %eax # imm = 0xFFFFFFFD
jne 0x1ec7
xorl %ebp, %ebp
testl %eax, %eax
sete %bpl
movl $0x10, %r13d
subl %ebp, %r13d
xorl $0x5, %ebp
leaq 0x4(%rsp), %r12
movl $0x0, (%r12)
movl $0x1, %r15d
cmpl %r13d, 0x28(%rbx)
jge 0x1f6b
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1a1d
testl %eax, %eax
jne 0x209b
cmpl $0x0, 0x4(%rsp)
je 0x1e99
callq 0x11b8
jmp 0x209b
cmpl $0x7, 0x1c(%rbx)
jne 0x20ad
cmpl $0x0, (%rbx)
je 0x1fae
movl 0x10(%rbx), %ecx
movl 0x24(%rbx), %edi
leal -0x1(%rdi), %eax
movl %eax, 0x24(%rbx)
movslq 0x20(%rbx), %rax
cmpl %ecx, %eax
movl %ecx, %edx
cmovgl %eax, %edx
movslq %edx, %r9
movq %rax, %rsi
shlq $0x20, %rsi
movabsq $0x100000000, %r10 # imm = 0x100000000
movl %edi, 0x24(%rbx)
cmpq %rax, %r9
je 0x20b7
movq 0x8(%rbx), %r8
leal 0x1(%rax), %edx
movl %edx, 0x20(%rbx)
movzbl (%r8,%rax), %edx
incq %rax
addq %r10, %rsi
incl %edi
movb %dl, 0x18(%rbx)
testl %edx, %edx
je 0x1f05
cmpl $0x1, %edx
jne 0x20c1
addl $-0x2, %edi
testl %edi, %edi
jle 0x20de
cmpl %eax, %ecx
jle 0x20e8
incl %eax
movl %eax, 0x20(%rbx)
sarq $0x20, %rsi
movzbl (%r8,%rsi), %eax
movb %al, 0x18(%rbx)
movl $0x0, 0x24(%rbx)
movl %eax, (%r14)
jmp 0x2098
leaq 0x4(%rsp), %r15
cmpl $0x0, 0x4(%rsp)
jne 0x1f99
movl $0x1, 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a1d
testl %eax, %eax
je 0x1f70
movl $0x1, %r15d
jmp 0x209b
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x1abd
movl %eax, %r15d
jmp 0x209b
movl 0x14(%rbx), %eax
cmpl %eax, 0x10(%rbx)
jl 0x1fd6
leal (%rax,%rax), %ecx
testl %eax, %eax
movl $0x10, %eax
cmovnel %ecx, %eax
movl %eax, 0x14(%rbx)
movq 0x8(%rbx), %rdi
movslq %eax, %rsi
callq 0x1070
movq %rax, 0x8(%rbx)
movq 0x8(%rbx), %rax
movslq 0x10(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x10(%rbx)
movb $0x0, (%rax,%rcx)
movl 0x14(%rbx), %eax
cmpl %eax, 0x10(%rbx)
jl 0x2010
leal (%rax,%rax), %ecx
testl %eax, %eax
movl $0x10, %eax
cmovnel %ecx, %eax
movl %eax, 0x14(%rbx)
movq 0x8(%rbx), %rdi
movslq %eax, %rsi
callq 0x1070
movq %rax, 0x8(%rbx)
movq 0x8(%rbx), %rax
movslq 0x10(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x10(%rbx)
movb $0x0, (%rax,%rcx)
movl 0x14(%rbx), %eax
cmpl %eax, 0x10(%rbx)
jl 0x204a
leal (%rax,%rax), %ecx
testl %eax, %eax
movl $0x10, %eax
cmovnel %ecx, %eax
movl %eax, 0x14(%rbx)
movq 0x8(%rbx), %rdi
movslq %eax, %rsi
callq 0x1070
movq %rax, 0x8(%rbx)
movq 0x8(%rbx), %rax
movslq 0x10(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x10(%rbx)
movb $0x1, (%rax,%rcx)
movl 0x14(%rbx), %eax
cmpl %eax, 0x10(%rbx)
jl 0x2084
leal (%rax,%rax), %ecx
testl %eax, %eax
movl $0x10, %eax
cmovnel %ecx, %eax
movl %eax, 0x14(%rbx)
movq 0x8(%rbx), %rdi
movslq %eax, %rsi
callq 0x1070
movq %rax, 0x8(%rbx)
movb (%r14), %al
movq 0x8(%rbx), %rcx
movslq 0x10(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x10(%rbx)
movb %al, (%rcx,%rdx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x11d4
jmp 0x1f8e
callq 0x1227
jmp 0x1f8e
movq 0x6f30(%rip), %rax # 0x8ff8
movq (%rax), %rdi
leaq 0x4101(%rip), %rsi # 0x61d3
xorl %eax, %eax
callq 0x1060
jmp 0x1f8e
callq 0x120c
jmp 0x1f8e
callq 0x11f0
jmp 0x1f8e
| /polachok[P]envytools/vstream/bitstream.c |
vs_infer | int vs_infer(struct bitstream *str, uint32_t *val, uint32_t ival) {
if (str->dir == VS_ENCODE) {
if (*val != ival) {
fprintf (stderr, "Wrong infered value: %d != %d\n", *val, ival);
return 1;
}
} else {
*val = ival;
}
return 0;
} | movl %edx, %ecx
cmpl $0x0, (%rdi)
je 0x24a4
movl %ecx, (%rsi)
xorl %eax, %eax
retq
movl (%rsi), %edx
xorl %eax, %eax
cmpl %ecx, %edx
jne 0x24ad
retq
pushq %rax
movq 0x6b43(%rip), %rax # 0x8ff8
movq (%rax), %rdi
leaq 0x3e44(%rip), %rsi # 0x6303
xorl %eax, %eax
callq 0x1060
movl $0x1, %eax
addq $0x8, %rsp
retq
| /polachok[P]envytools/vstream/bitstream.c |
h264_seqparm_mvc | int h264_seqparm_mvc(struct bitstream *str, struct h264_seqparm *seqparm) {
uint32_t bit_equal_to_one = 1;
int i, j, k;
if (str->dir == VS_DECODE)
seqparm->is_mvc = 1;
if (vs_u(str, &bit_equal_to_one, 1)) return 1;
if (!bit_equal_to_one) {
fprintf(stderr, "bit_equal_to_one invalid\n");
return 1;
}
if (vs_ue(str, &seqparm->num_views_minus1)) return 1;
if (str->dir == VS_DECODE)
seqparm->views = calloc(sizeof *seqparm->views, seqparm->num_views_minus1 + 1);
for (i = 0; i <= seqparm->num_views_minus1; i++)
if (vs_ue(str, &seqparm->views[i].view_id)) return 1;
for (i = 1; i <= seqparm->num_views_minus1; i++) {
if (vs_ue(str, &seqparm->views[i].num_anchor_refs_l0)) return 1;
if (seqparm->views[i].num_anchor_refs_l0 > 15) {
fprintf (stderr, "num_anchor_refs_l0 over limit\n");
return 1;
}
for (j = 0; j < seqparm->views[i].num_anchor_refs_l0; j++)
if (vs_ue(str, &seqparm->views[i].anchor_ref_l0[j])) return 1;
if (vs_ue(str, &seqparm->views[i].num_anchor_refs_l1)) return 1;
if (seqparm->views[i].num_anchor_refs_l1 > 15) {
fprintf (stderr, "num_anchor_refs_l1 over limit\n");
return 1;
}
for (j = 0; j < seqparm->views[i].num_anchor_refs_l1; j++)
if (vs_ue(str, &seqparm->views[i].anchor_ref_l1[j])) return 1;
}
for (i = 1; i <= seqparm->num_views_minus1; i++) {
if (vs_ue(str, &seqparm->views[i].num_non_anchor_refs_l0)) return 1;
if (seqparm->views[i].num_non_anchor_refs_l0 > 15) {
fprintf (stderr, "num_non_anchor_refs_l0 over limit\n");
return 1;
}
for (j = 0; j < seqparm->views[i].num_non_anchor_refs_l0; j++)
if (vs_ue(str, &seqparm->views[i].non_anchor_ref_l0[j])) return 1;
if (vs_ue(str, &seqparm->views[i].num_non_anchor_refs_l1)) return 1;
if (seqparm->views[i].num_non_anchor_refs_l1 > 15) {
fprintf (stderr, "num_non_anchor_refs_l1 over limit\n");
return 1;
}
for (j = 0; j < seqparm->views[i].num_non_anchor_refs_l1; j++)
if (vs_ue(str, &seqparm->views[i].non_anchor_ref_l1[j])) return 1;
}
if (vs_ue(str, &seqparm->num_level_values_signalled_minus1)) return 1;
if (str->dir == VS_DECODE)
seqparm->levels = calloc(sizeof *seqparm->levels, seqparm->num_level_values_signalled_minus1 + 1);
for (i = 0; i <= seqparm->num_level_values_signalled_minus1; i++) {
if (vs_u(str, &seqparm->levels[i].level_idc, 8)) return 1;
if (vs_ue(str, &seqparm->levels[i].num_applicable_ops_minus1)) return 1;
if (str->dir == VS_DECODE)
seqparm->levels[i].applicable_ops = calloc(sizeof *seqparm->levels[i].applicable_ops, seqparm->levels[i].num_applicable_ops_minus1 + 1);
for (j = 0; j <= seqparm->levels[i].num_applicable_ops_minus1; j++) {
if (vs_u(str, &seqparm->levels[i].applicable_ops[j].temporal_id, 3)) return 1;
if (vs_ue(str, &seqparm->levels[i].applicable_ops[j].num_target_views_minus1)) return 1;
if (str->dir == VS_DECODE)
seqparm->levels[i].applicable_ops[j].target_view_id = calloc(sizeof *seqparm->levels[i].applicable_ops[j].target_view_id, seqparm->levels[i].applicable_ops[j].num_target_views_minus1 + 1);
for (k = 0; k <= seqparm->levels[i].applicable_ops[j].num_target_views_minus1; k++)
if (vs_ue(str, &seqparm->levels[i].applicable_ops[j].target_view_id[k])) return 1;
if (vs_ue(str, &seqparm->levels[i].applicable_ops[j].num_views_minus1)) return 1;
}
}
uint32_t mvc_vui_parameters_present_flag = !!(seqparm->mvc_vui);
if (vs_u(str, &mvc_vui_parameters_present_flag, 1)) return 1;
if (mvc_vui_parameters_present_flag) {
if (str->dir == VS_DECODE) {
seqparm->mvc_vui = calloc (sizeof *seqparm->mvc_vui, 1);
}
if (h264_mvc_vui_parameters(str, seqparm->mvc_vui)) return 1;
} else {
seqparm->mvc_vui = 0;
}
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, 0x18(%rsp)
cmpl $0x1, (%rdi)
jne 0x3878
movl $0x1, 0xc98(%r14)
leaq 0x18(%rsp), %rsi
movl $0x1, %ebp
movq %r15, %rdi
movl $0x1, %edx
callq 0x1abd
testl %eax, %eax
jne 0x3ddc
cmpl $0x0, 0x18(%rsp)
je 0x3db6
leaq 0xc9c(%r14), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1b50
testl %eax, %eax
jne 0x3ddc
cmpl $0x1, (%r15)
jne 0x38dc
movl 0xc9c(%r14), %esi
incl %esi
movl $0x104, %edi # imm = 0x104
callq 0x1050
movq %rax, 0xca0(%r14)
movq $-0x1, %r13
xorl %ebx, %ebx
movq 0xca0(%r14), %rsi
addq %rbx, %rsi
movq %r15, %rdi
callq 0x1b50
testl %eax, %eax
jne 0x3dd7
movl (%r12), %eax
incq %r13
addq $0x104, %rbx # imm = 0x104
cmpq %rax, %r13
jb 0x38e5
cmpl $0x0, (%r12)
je 0x3a44
movl $0x1, %ebx
movl $0x10c, %ebp # imm = 0x10C
movl $0x14c, %eax # imm = 0x14C
movq %rax, (%rsp)
movq 0xca0(%r14), %rax
movq %rbx, %rcx
shlq $0x8, %rcx
leaq (%rcx,%rbx,4), %r13
leaq (%rax,%r13), %rsi
addq $0x4, %rsi
movq %r15, %rdi
callq 0x1b50
testl %eax, %eax
jne 0x3dd7
movq 0xca0(%r14), %rax
cmpl $0xf, 0x4(%rax,%r13)
ja 0x3dbd
movq %rbx, 0x8(%rsp)
movq 0xca0(%r14), %rsi
cmpl $0x0, 0x4(%rsi,%r13)
movq %rbp, 0x10(%rsp)
je 0x39b3
xorl %ebx, %ebx
addq %rbp, %rsi
movq %r15, %rdi
callq 0x1b50
testl %eax, %eax
jne 0x3dd7
incq %rbx
movq 0xca0(%r14), %rsi
movl 0x4(%rsi,%r13), %eax
addq $0x4, %rbp
cmpq %rax, %rbx
jb 0x3988
addq %r13, %rsi
addq $0x44, %rsi
movq %r15, %rdi
callq 0x1b50
testl %eax, %eax
jne 0x3dd7
movq 0xca0(%r14), %rax
cmpl $0xf, 0x44(%rax,%r13)
ja 0x3dc4
movq 0xca0(%r14), %rsi
cmpl $0x0, 0x44(%rsi,%r13)
je 0x3a1d
movq (%rsp), %rbx
xorl %ebp, %ebp
addq %rbx, %rsi
movq %r15, %rdi
callq 0x1b50
testl %eax, %eax
jne 0x3dd7
incq %rbp
movq 0xca0(%r14), %rsi
movl 0x44(%rsi,%r13), %eax
addq $0x4, %rbx
cmpq %rax, %rbp
jb 0x39f2
movq 0x8(%rsp), %rdx
leaq 0x1(%rdx), %rbx
movl (%r12), %ecx
movq 0x10(%rsp), %rbp
movl $0x104, %esi # imm = 0x104
addq %rsi, %rbp
addq %rsi, (%rsp)
cmpq %rcx, %rdx
jb 0x3930
cmpl $0x0, (%r12)
je 0x3b8e
movl $0x1, %ebx
movl $0x18c, %ebp # imm = 0x18C
movl $0x1cc, %eax # imm = 0x1CC
movq %rax, (%rsp)
movq 0xca0(%r14), %rax
movq %rbx, %rcx
shlq $0x8, %rcx
leaq (%rcx,%rbx,4), %r13
leaq (%rax,%r13), %rsi
addq $0x84, %rsi
movq %r15, %rdi
callq 0x1b50
testl %eax, %eax
jne 0x3dd7
movq 0xca0(%r14), %rax
cmpl $0xf, 0x84(%rax,%r13)
ja 0x3dcb
movq %rbx, 0x8(%rsp)
movq 0xca0(%r14), %rsi
cmpl $0x0, 0x84(%rsi,%r13)
movq %rbp, 0x10(%rsp)
je 0x3af1
xorl %ebx, %ebx
addq %rbp, %rsi
movq %r15, %rdi
callq 0x1b50
testl %eax, %eax
jne 0x3dd7
incq %rbx
movq 0xca0(%r14), %rsi
movl 0x84(%rsi,%r13), %eax
addq $0x4, %rbp
cmpq %rax, %rbx
jb 0x3ac3
addq %r13, %rsi
addq $0xc4, %rsi
movq %r15, %rdi
callq 0x1b50
testl %eax, %eax
jne 0x3dd7
movq 0xca0(%r14), %rax
cmpl $0xf, 0xc4(%rax,%r13)
ja 0x3dd2
movq 0xca0(%r14), %rsi
cmpl $0x0, 0xc4(%rsi,%r13)
je 0x3b67
movq (%rsp), %rbx
xorl %ebp, %ebp
addq %rbx, %rsi
movq %r15, %rdi
callq 0x1b50
testl %eax, %eax
jne 0x3dd7
incq %rbp
movq 0xca0(%r14), %rsi
movl 0xc4(%rsi,%r13), %eax
addq $0x4, %rbx
cmpq %rax, %rbp
jb 0x3b39
movq 0x8(%rsp), %rdx
leaq 0x1(%rdx), %rbx
movl (%r12), %ecx
movq 0x10(%rsp), %rbp
movl $0x104, %esi # imm = 0x104
addq %rsi, %rbp
addq %rsi, (%rsp)
cmpq %rcx, %rdx
jb 0x3a62
leaq 0xca8(%r14), %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b50
testl %eax, %eax
movl $0x1, %ebp
jne 0x3ddc
cmpl $0x1, (%r15)
jne 0x3bcd
movl 0xca8(%r14), %esi
incl %esi
movl $0x10, %edi
callq 0x1050
movq %rax, 0xcb0(%r14)
xorl %r12d, %r12d
movq %r12, %r13
shlq $0x4, %r13
movq 0xcb0(%r14), %rsi
addq %r13, %rsi
movq %r15, %rdi
movl $0x8, %edx
callq 0x1abd
testl %eax, %eax
jne 0x3ddc
movq 0xcb0(%r14), %rax
movq %r13, (%rsp)
leaq (%rax,%r13), %rsi
addq $0x4, %rsi
movq %r15, %rdi
callq 0x1b50
testl %eax, %eax
jne 0x3ddc
movq %r12, 0x20(%rsp)
movq %rbx, 0x8(%rsp)
cmpl $0x1, (%r15)
jne 0x3c4a
movq 0xcb0(%r14), %rbx
movq (%rsp), %r12
movl 0x4(%rbx,%r12), %esi
incl %esi
movl $0x18, %edi
callq 0x1050
movq %rax, 0x8(%rbx,%r12)
movq 0xcb0(%r14), %rax
xorl %r13d, %r13d
movq (%rsp), %rbx
leaq (,%r13,2), %r12
addq %r13, %r12
leaq (,%r12,8), %rsi
addq 0x8(%rax,%rbx), %rsi
movq %r15, %rdi
movl $0x3, %edx
callq 0x1abd
testl %eax, %eax
jne 0x3ddc
movq 0xcb0(%r14), %rax
movq 0x8(%rax,%rbx), %rax
leaq (%rax,%r12,8), %rsi
addq $0x4, %rsi
movq %r15, %rdi
callq 0x1b50
testl %eax, %eax
jne 0x3ddc
movq %r13, 0x10(%rsp)
cmpl $0x1, (%r15)
jne 0x3cde
movq 0xcb0(%r14), %rax
movq (%rsp), %rcx
movq 0x8(%rax,%rcx), %rbx
movl 0x4(%rbx,%r12,8), %esi
incl %esi
movl $0x4, %edi
callq 0x1050
movq %rax, 0x8(%rbx,%r12,8)
movq (%rsp), %rbx
movq 0xcb0(%r14), %rax
movq 0x8(%rax,%rbx), %rax
movq $-0x1, %r13
xorl %ebp, %ebp
movq 0x8(%rax,%r12,8), %rsi
addq %rbp, %rsi
movq %r15, %rdi
callq 0x1b50
testl %eax, %eax
jne 0x3dd7
movq 0xcb0(%r14), %rax
movq 0x8(%rax,%rbx), %rax
movl 0x4(%rax,%r12,8), %ecx
incq %r13
addq $0x4, %rbp
cmpq %rcx, %r13
jb 0x3cf3
leaq (%rax,%r12,8), %rsi
addq $0x10, %rsi
movq %r15, %rdi
callq 0x1b50
testl %eax, %eax
jne 0x3dd7
movq 0x10(%rsp), %rsi
leaq 0x1(%rsi), %r13
movq 0xcb0(%r14), %rax
movl 0x4(%rax,%rbx), %edx
cmpq %rdx, %rsi
movl $0x1, %ebp
jb 0x3c58
movq 0x20(%rsp), %rdx
leaq 0x1(%rdx), %r12
movq 0x8(%rsp), %rbx
movl (%rbx), %ecx
cmpq %rcx, %rdx
jb 0x3bd0
xorl %eax, %eax
cmpq $0x0, 0xcb8(%r14)
setne %al
leaq 0x1c(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
movl $0x1, %edx
callq 0x1abd
testl %eax, %eax
jne 0x3ddc
cmpl $0x0, 0x1c(%rsp)
jne 0x3ded
movq $0x0, 0xcb8(%r14)
xorl %ebp, %ebp
jmp 0x3ddc
callq 0x138f
jmp 0x3ddc
callq 0x1329
jmp 0x3dd7
callq 0x1307
jmp 0x3dd7
callq 0x136d
jmp 0x3dd7
callq 0x134b
movl $0x1, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1, (%r15)
jne 0x3e09
movl $0x88, %edi
movl $0x1, %esi
callq 0x1050
movq %rax, 0xcb8(%r14)
callq 0x1040
| /polachok[P]envytools/vstream/h264.c |
cnd_signal | int cnd_signal(cnd_t *cond)
{
#if defined(_TTHREAD_WIN32_)
int haveWaiters;
/* Are there any waiters? */
EnterCriticalSection(&cond->mWaitersCountLock);
haveWaiters = (cond->mWaitersCount > 0);
LeaveCriticalSection(&cond->mWaitersCountLock);
/* If we have any waiting threads, send them a signal */
if(haveWaiters)
{
if (SetEvent(cond->mEvents[_CONDITION_EVENT_ONE]) == 0)
{
return thrd_error;
}
}
return thrd_success;
#else
return pthread_cond_signal(cond) == 0 ? thrd_success : thrd_error;
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x151c0
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /Rodousse[P]SSSGems/third_party/glfw/deps/tinycthread.c |
createHelperWindow | static Window createHelperWindow(void)
{
XSetWindowAttributes wa;
wa.event_mask = PropertyChangeMask;
return XCreateWindow(_glfw.x11.display, _glfw.x11.root,
0, 0, 1, 1, 0, 0,
InputOnly,
DefaultVisual(_glfw.x11.display, _glfw.x11.screen),
CWEventMask, &wa);
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq $0x400000, -0x28(%rbp) # imm = 0x400000
leaq 0x3b796(%rip), %rax # 0x62a80
movq 0x1fec0(%rax), %rdi
leaq 0x3b788(%rip), %rax # 0x62a80
movq 0x1fed0(%rax), %rsi
leaq 0x3b77a(%rip), %rax # 0x62a80
movq 0x1fec0(%rax), %rax
movq 0xe8(%rax), %rax
leaq 0x3b765(%rip), %rcx # 0x62a80
movslq 0x1fec8(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x40(%rax), %r10
xorl %ecx, %ecx
movl $0x1, %r9d
leaq -0x70(%rbp), %rax
movl %ecx, %edx
movl %r9d, %r8d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x2, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq $0x800, 0x20(%rsp) # imm = 0x800
movq %rax, 0x28(%rsp)
callq 0x15320
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /Rodousse[P]SSSGems/third_party/glfw/src/x11_init.c |
hasUsableInputMethodStyle | static GLFWbool hasUsableInputMethodStyle(void)
{
GLFWbool found = GLFW_FALSE;
XIMStyles* styles = NULL;
if (XGetIMValues(_glfw.x11.im, XNQueryInputStyle, &styles, NULL) != NULL)
return GLFW_FALSE;
for (unsigned int i = 0; i < styles->count_styles; i++)
{
if (styles->supported_styles[i] == (XIMPreeditNothing | XIMStatusNothing))
{
found = GLFW_TRUE;
break;
}
}
XFree(styles);
return found;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0x3b682(%rip), %rax # 0x62a80
movq 0x1fef8(%rax), %rdi
leaq 0x30af8(%rip), %rsi # 0x57f04
leaq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x15220
cmpq $0x0, %rax
je 0x2742a
movl $0x0, -0x4(%rbp)
jmp 0x27479
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jae 0x2746a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
cmpq $0x408, (%rax,%rcx,8) # imm = 0x408
jne 0x2745d
movl $0x1, -0x8(%rbp)
jmp 0x2746a
jmp 0x2745f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x27431
movq -0x10(%rbp), %rdi
callq 0x15080
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /Rodousse[P]SSSGems/third_party/glfw/src/x11_init.c |
glfwPlatformTerminate | void _glfwPlatformTerminate(void)
{
if (_glfw.x11.helperWindowHandle)
{
if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD) ==
_glfw.x11.helperWindowHandle)
{
_glfwPushSelectionToManagerX11();
}
XDestroyWindow(_glfw.x11.display, _glfw.x11.helperWindowHandle);
_glfw.x11.helperWindowHandle = None;
}
if (_glfw.x11.hiddenCursorHandle)
{
XFreeCursor(_glfw.x11.display, _glfw.x11.hiddenCursorHandle);
_glfw.x11.hiddenCursorHandle = (Cursor) 0;
}
free(_glfw.x11.primarySelectionString);
free(_glfw.x11.clipboardString);
if (_glfw.x11.im)
{
XCloseIM(_glfw.x11.im);
_glfw.x11.im = NULL;
}
if (_glfw.x11.display)
{
XCloseDisplay(_glfw.x11.display);
_glfw.x11.display = NULL;
}
if (_glfw.x11.x11xcb.handle)
{
_glfw_dlclose(_glfw.x11.x11xcb.handle);
_glfw.x11.x11xcb.handle = NULL;
}
if (_glfw.x11.xcursor.handle)
{
_glfw_dlclose(_glfw.x11.xcursor.handle);
_glfw.x11.xcursor.handle = NULL;
}
if (_glfw.x11.randr.handle)
{
_glfw_dlclose(_glfw.x11.randr.handle);
_glfw.x11.randr.handle = NULL;
}
if (_glfw.x11.xinerama.handle)
{
_glfw_dlclose(_glfw.x11.xinerama.handle);
_glfw.x11.xinerama.handle = NULL;
}
if (_glfw.x11.xrender.handle)
{
_glfw_dlclose(_glfw.x11.xrender.handle);
_glfw.x11.xrender.handle = NULL;
}
if (_glfw.x11.vidmode.handle)
{
_glfw_dlclose(_glfw.x11.vidmode.handle);
_glfw.x11.vidmode.handle = NULL;
}
if (_glfw.x11.xi.handle)
{
_glfw_dlclose(_glfw.x11.xi.handle);
_glfw.x11.xi.handle = NULL;
}
// NOTE: These need to be unloaded after XCloseDisplay, as they register
// cleanup callbacks that get called by that function
_glfwTerminateEGL();
_glfwTerminateGLX();
#if defined(__linux__)
_glfwTerminateJoysticksLinux();
#endif
} | pushq %rbp
movq %rsp, %rbp
leaq 0x3b5e5(%rip), %rax # 0x62a80
cmpq $0x0, 0x1fee0(%rax)
je 0x2750e
leaq 0x3b5d4(%rip), %rax # 0x62a80
movq 0x1fec0(%rax), %rdi
leaq 0x3b5c6(%rip), %rax # 0x62a80
movq 0x20c08(%rax), %rsi
callq 0x15a90
leaq 0x3b5b3(%rip), %rcx # 0x62a80
cmpq 0x1fee0(%rcx), %rax
jne 0x274db
callq 0x2abd0
leaq 0x3b59e(%rip), %rax # 0x62a80
movq 0x1fec0(%rax), %rdi
leaq 0x3b590(%rip), %rax # 0x62a80
movq 0x1fee0(%rax), %rsi
callq 0x15460
leaq 0x3b57d(%rip), %rax # 0x62a80
movq $0x0, 0x1fee0(%rax)
leaq 0x3b56b(%rip), %rax # 0x62a80
cmpq $0x0, 0x1fee8(%rax)
je 0x27552
leaq 0x3b55a(%rip), %rax # 0x62a80
movq 0x1fec0(%rax), %rdi
leaq 0x3b54c(%rip), %rax # 0x62a80
movq 0x1fee8(%rax), %rsi
callq 0x150c0
leaq 0x3b539(%rip), %rax # 0x62a80
movq $0x0, 0x1fee8(%rax)
leaq 0x3b527(%rip), %rax # 0x62a80
movq 0x1ff08(%rax), %rdi
callq 0x15430
leaq 0x3b514(%rip), %rax # 0x62a80
movq 0x1ff10(%rax), %rdi
callq 0x15430
leaq 0x3b501(%rip), %rax # 0x62a80
cmpq $0x0, 0x1fef8(%rax)
je 0x275ae
leaq 0x3b4f0(%rip), %rax # 0x62a80
movq 0x1fef8(%rax), %rdi
callq 0x15a40
leaq 0x3b4dd(%rip), %rax # 0x62a80
movq $0x0, 0x1fef8(%rax)
leaq 0x3b4cb(%rip), %rax # 0x62a80
cmpq $0x0, 0x1fec0(%rax)
je 0x275e4
leaq 0x3b4ba(%rip), %rax # 0x62a80
movq 0x1fec0(%rax), %rdi
callq 0x15470
leaq 0x3b4a7(%rip), %rax # 0x62a80
movq $0x0, 0x1fec0(%rax)
leaq 0x3b495(%rip), %rax # 0x62a80
cmpq $0x0, 0x20da0(%rax)
je 0x2761a
leaq 0x3b484(%rip), %rax # 0x62a80
movq 0x20da0(%rax), %rdi
callq 0x15b10
leaq 0x3b471(%rip), %rax # 0x62a80
movq $0x0, 0x20da0(%rax)
leaq 0x3b45f(%rip), %rax # 0x62a80
cmpq $0x0, 0x20d50(%rax)
je 0x27650
leaq 0x3b44e(%rip), %rax # 0x62a80
movq 0x20d50(%rax), %rdi
callq 0x15b10
leaq 0x3b43b(%rip), %rax # 0x62a80
movq $0x0, 0x20d50(%rax)
leaq 0x3b429(%rip), %rax # 0x62a80
cmpq $0x0, 0x20c58(%rax)
je 0x27686
leaq 0x3b418(%rip), %rax # 0x62a80
movq 0x20c58(%rax), %rdi
callq 0x15b10
leaq 0x3b405(%rip), %rax # 0x62a80
movq $0x0, 0x20c58(%rax)
leaq 0x3b3f3(%rip), %rax # 0x62a80
cmpq $0x0, 0x20d78(%rax)
je 0x276bc
leaq 0x3b3e2(%rip), %rax # 0x62a80
movq 0x20d78(%rax), %rdi
callq 0x15b10
leaq 0x3b3cf(%rip), %rax # 0x62a80
movq $0x0, 0x20d78(%rax)
leaq 0x3b3bd(%rip), %rax # 0x62a80
cmpq $0x0, 0x20e28(%rax)
je 0x276f2
leaq 0x3b3ac(%rip), %rax # 0x62a80
movq 0x20e28(%rax), %rdi
callq 0x15b10
leaq 0x3b399(%rip), %rax # 0x62a80
movq $0x0, 0x20e28(%rax)
leaq 0x3b387(%rip), %rax # 0x62a80
cmpq $0x0, 0x20db8(%rax)
je 0x27728
leaq 0x3b376(%rip), %rax # 0x62a80
movq 0x20db8(%rax), %rdi
callq 0x15b10
leaq 0x3b363(%rip), %rax # 0x62a80
movq $0x0, 0x20db8(%rax)
leaq 0x3b351(%rip), %rax # 0x62a80
cmpq $0x0, 0x20df0(%rax)
je 0x2775e
leaq 0x3b340(%rip), %rax # 0x62a80
movq 0x20df0(%rax), %rdi
callq 0x15b10
leaq 0x3b32d(%rip), %rax # 0x62a80
movq $0x0, 0x20df0(%rax)
callq 0x33aa0
callq 0x321d0
callq 0x367c0
popq %rbp
retq
nop
| /Rodousse[P]SSSGems/third_party/glfw/src/x11_init.c |
glfwPlatformGetVersionString | const char* _glfwPlatformGetVersionString(void)
{
return _GLFW_VERSION_NUMBER " X11 GLX EGL OSMesa"
#if defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK)
" clock_gettime"
#else
" gettimeofday"
#endif
#if defined(__linux__)
" evdev"
#endif
#if defined(_GLFW_BUILD_DLL)
" shared"
#endif
;
} | pushq %rbp
movq %rsp, %rbp
leaq 0x3003c(%rip), %rax # 0x577b7
popq %rbp
retq
nopl (%rax)
| /Rodousse[P]SSSGems/third_party/glfw/src/x11_init.c |
glfwExtensionSupported | GLFWAPI int glfwExtensionSupported(const char* extension)
{
_GLFWwindow* window;
assert(extension != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
window = _glfwPlatformGetTls(&_glfw.contextSlot);
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT,
"Cannot query extension without a current OpenGL or OpenGL ES context");
return GLFW_FALSE;
}
if (*extension == '\0')
{
_glfwInputError(GLFW_INVALID_VALUE, "Extension name cannot be an empty string");
return GLFW_FALSE;
}
if (window->context.major >= 3)
{
int i;
GLint count;
// Check if extension is in the modern OpenGL extensions string list
window->context.GetIntegerv(GL_NUM_EXTENSIONS, &count);
for (i = 0; i < count; i++)
{
const char* en = (const char*)
window->context.GetStringi(GL_EXTENSIONS, i);
if (!en)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Extension string retrieval is broken");
return GLFW_FALSE;
}
if (strcmp(en, extension) == 0)
return GLFW_TRUE;
}
}
else
{
// Check if extension is in the old style OpenGL extensions string
const char* extensions = (const char*)
window->context.GetString(GL_EXTENSIONS);
if (!extensions)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Extension string retrieval is broken");
return GLFW_FALSE;
}
if (_glfwStringInExtensionString(extension, extensions))
return GLFW_TRUE;
}
// Check if extension is in the platform-specific string
return window->context.extensionSupported(extension);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1979e
leaq 0x3d248(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x1970f
movq %rdi, %rbx
movl $0x1fe1c, %edi # imm = 0x1FE1C
addq 0x3a950(%rip), %rdi # 0x53fe8
callq 0x26699
testq %rax, %rax
je 0x1971b
cmpb $0x0, (%rbx)
je 0x1972c
movq %rax, %r14
cmpl $0x3, 0x200(%rax)
jl 0x1973d
leaq 0x4(%rsp), %r15
movl $0x821d, %edi # imm = 0x821D
movq %r15, %rsi
callq *0x230(%r14)
cmpl $0x0, (%r15)
jle 0x19763
xorl %ebp, %ebp
movl $0x1f03, %edi # imm = 0x1F03
movl %ebp, %esi
callq *0x228(%r14)
testq %rax, %rax
je 0x19772
movq %rax, %rdi
movq %rbx, %rsi
callq 0x136a0
testl %eax, %eax
je 0x19796
incl %ebp
cmpl 0x4(%rsp), %ebp
jl 0x196db
jmp 0x19763
xorl %r15d, %r15d
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
jmp 0x19781
leaq 0x14376(%rip), %rsi # 0x2da98
xorl %r15d, %r15d
movl $0x10002, %edi # imm = 0x10002
jmp 0x19781
leaq 0x143aa(%rip), %rsi # 0x2dadd
xorl %r15d, %r15d
movl $0x10004, %edi # imm = 0x10004
jmp 0x19781
movl $0x1f03, %edi # imm = 0x1F03
callq *0x238(%r14)
testq %rax, %rax
je 0x19772
movq %rbx, %rdi
movq %rax, %rsi
callq 0x197bd
movl $0x1, %r15d
testl %eax, %eax
jne 0x19788
movq %rbx, %rdi
callq *0x258(%r14)
movl %eax, %r15d
jmp 0x19788
leaq 0x1438d(%rip), %rsi # 0x2db06
xorl %r15d, %r15d
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x199c5
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %r15d
jmp 0x19788
leaq 0x142b8(%rip), %rdi # 0x2da5d
leaq 0x141a4(%rip), %rsi # 0x2d950
leaq 0x142bc(%rip), %rcx # 0x2da6f
movl $0x2a6, %edx # imm = 0x2A6
callq 0x131e0
| /anael-seghezzi[P]glfw/src/context.c |
glfwStringInExtensionString | GLFWbool _glfwStringInExtensionString(const char* string, const char* extensions)
{
const char* start = extensions;
for (;;)
{
const char* where;
const char* terminator;
where = strstr(start, string);
if (!where)
return GLFW_FALSE;
terminator = where + strlen(string);
if (where == start || *(where - 1) == ' ')
{
if (*terminator == ' ' || *terminator == '\0')
break;
}
start = terminator;
}
return GLFW_TRUE;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x13500
xorl %ebx, %ebx
testq %rax, %rax
je 0x19821
movq %rax, %r13
movq %r14, %rdi
callq 0x13400
movq %rax, %r12
movq %r15, %rax
leaq (%r12,%r13), %r15
cmpq %rax, %r13
je 0x197ff
cmpb $0x20, -0x1(%r13)
jne 0x19807
movzbl (%r15), %eax
testb $-0x21, %al
je 0x1981c
movq %r15, %rdi
movq %r14, %rsi
callq 0x13500
movq %rax, %r13
testq %rax, %rax
jne 0x197ec
jmp 0x19821
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /anael-seghezzi[P]glfw/src/context.c |
glfwSwapBuffers | GLFWAPI void glfwSwapBuffers(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT,
"Cannot swap buffers of a window that has no OpenGL or OpenGL ES context");
return;
}
window->context.swapBuffers(window);
} | testq %rdi, %rdi
je 0x19899
leaq 0x3d05f(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x1987d
cmpl $0x0, 0x1f8(%rdi)
je 0x19886
jmpq *0x248(%rdi)
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
jmp 0x19892
leaq 0x14141(%rip), %rsi # 0x2d9ce
movl $0x1000a, %edi # imm = 0x1000A
xorl %eax, %eax
jmp 0x199c5
pushq %rax
leaq 0x140a0(%rip), %rdi # 0x2d941
leaq 0x140a8(%rip), %rsi # 0x2d950
leaq 0x140fc(%rip), %rcx # 0x2d9ab
movl $0x284, %edx # imm = 0x284
callq 0x131e0
| /anael-seghezzi[P]glfw/src/context.c |
glfwSwapInterval | GLFWAPI void glfwSwapInterval(int interval)
{
_GLFWwindow* window;
_GLFW_REQUIRE_INIT();
window = _glfwPlatformGetTls(&_glfw.contextSlot);
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT,
"Cannot set swap interval without a current OpenGL or OpenGL ES context");
return;
}
window->context.swapInterval(interval);
} | pushq %rbx
leaq 0x3d007(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x198e7
movl %edi, %ebx
movl $0x1fe1c, %edi # imm = 0x1FE1C
addq 0x3a714(%rip), %rdi # 0x53fe8
callq 0x26699
testq %rax, %rax
je 0x198f0
movl %ebx, %edi
popq %rbx
jmpq *0x250(%rax)
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
jmp 0x198fc
leaq 0x1411f(%rip), %rsi # 0x2da16
movl $0x10002, %edi # imm = 0x10002
xorl %eax, %eax
popq %rbx
jmp 0x199c5
| /anael-seghezzi[P]glfw/src/context.c |
glfwGetProcAddress | GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname)
{
_GLFWwindow* window;
assert(procname != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
window = _glfwPlatformGetTls(&_glfw.contextSlot);
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT,
"Cannot query entry point without a current OpenGL or OpenGL ES context");
return NULL;
}
return window->context.getProcAddress(procname);
} | pushq %rbx
testq %rdi, %rdi
je 0x19959
leaq 0x3cfb7(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x19939
movq %rdi, %rbx
movl $0x1fe1c, %edi # imm = 0x1FE1C
addq 0x3a6c3(%rip), %rdi # 0x53fe8
callq 0x26699
testq %rax, %rax
je 0x19942
movq %rbx, %rdi
popq %rbx
jmpq *0x260(%rax)
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
jmp 0x1994e
leaq 0x1421f(%rip), %rsi # 0x2db68
movl $0x10002, %edi # imm = 0x10002
xorl %eax, %eax
callq 0x199c5
xorl %eax, %eax
popq %rbx
retq
leaq 0x141cb(%rip), %rdi # 0x2db2b
leaq 0x13fe9(%rip), %rsi # 0x2d950
leaq 0x141ce(%rip), %rcx # 0x2db3c
movl $0x2e8, %edx # imm = 0x2E8
callq 0x131e0
| /anael-seghezzi[P]glfw/src/context.c |
glfw_fminf | float _glfw_fminf(float a, float b)
{
if (a != a)
return b;
else if (b != b)
return a;
else if (a < b)
return a;
else
return b;
} | ucomiss %xmm0, %xmm0
jp 0x199ac
ucomiss %xmm1, %xmm1
jp 0x199a9
minss %xmm1, %xmm0
movaps %xmm0, %xmm1
movaps %xmm1, %xmm0
retq
| /anael-seghezzi[P]glfw/src/init.c |
glfw_fmaxf | float _glfw_fmaxf(float a, float b)
{
if (a != a)
return b;
else if (b != b)
return a;
else if (a > b)
return a;
else
return b;
} | ucomiss %xmm0, %xmm0
jp 0x199c1
ucomiss %xmm1, %xmm1
jp 0x199be
maxss %xmm1, %xmm0
movaps %xmm0, %xmm1
movaps %xmm1, %xmm0
retq
| /anael-seghezzi[P]glfw/src/init.c |
glfwInputError | void _glfwInputError(int code, const char* format, ...)
{
_GLFWerror* error;
char description[_GLFW_MESSAGE_SIZE];
if (format)
{
va_list vl;
va_start(vl, format);
vsnprintf(description, sizeof(description), format, vl);
va_end(vl);
description[sizeof(description) - 1] = '\0';
}
else
{
if (code == GLFW_NOT_INITIALIZED)
strcpy(description, "The GLFW library is not initialized");
else if (code == GLFW_NO_CURRENT_CONTEXT)
strcpy(description, "There is no current context");
else if (code == GLFW_INVALID_ENUM)
strcpy(description, "Invalid argument for enum parameter");
else if (code == GLFW_INVALID_VALUE)
strcpy(description, "Invalid value for parameter");
else if (code == GLFW_OUT_OF_MEMORY)
strcpy(description, "Out of memory");
else if (code == GLFW_API_UNAVAILABLE)
strcpy(description, "The requested API is unavailable");
else if (code == GLFW_VERSION_UNAVAILABLE)
strcpy(description, "The requested API version is unavailable");
else if (code == GLFW_PLATFORM_ERROR)
strcpy(description, "A platform-specific error occurred");
else if (code == GLFW_FORMAT_UNAVAILABLE)
strcpy(description, "The requested format is unavailable");
else if (code == GLFW_NO_WINDOW_CONTEXT)
strcpy(description, "The specified window has no context");
else
strcpy(description, "ERROR: UNKNOWN GLFW ERROR");
}
if (_glfw.initialized)
{
error = _glfwPlatformGetTls(&_glfw.errorSlot);
if (!error)
{
error = calloc(1, sizeof(_GLFWerror));
_glfwPlatformSetTls(&_glfw.errorSlot, error);
_glfwPlatformLockMutex(&_glfw.errorLock);
error->next = _glfw.errorListHead;
_glfw.errorListHead = error;
_glfwPlatformUnlockMutex(&_glfw.errorLock);
}
}
else
error = &_glfwMainThreadError;
error->code = code;
strcpy(error->description, description);
if (_glfwErrorCallback)
_glfwErrorCallback(code, description);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x4d8, %rsp # imm = 0x4D8
movl %edi, %ebx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x19a24
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rsi, %rsi
je 0x19af3
movq %rsi, %r10
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x500(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rcx)
leaq 0xd0(%rsp), %r14
movl $0x400, %esi # imm = 0x400
movq %r14, %rdi
movq %r10, %rdx
callq 0x135d0
movb $0x0, 0x3ff(%r14)
leaq 0x3ce4c(%rip), %r12 # 0x568c8
cmpl $0x0, (%r12)
je 0x19b40
movl $0x1fe14, %edi # imm = 0x1FE14
addq 0x3a555(%rip), %rdi # 0x53fe8
callq 0x26699
movq %rax, %r14
testq %rax, %rax
jne 0x19b47
movl $0x1, %edi
movl $0x410, %esi # imm = 0x410
callq 0x13790
movq %rax, %r14
leaq 0x1fe14(%r12), %rdi
movq %rax, %rsi
callq 0x266c6
leaq 0x1fe28(%r12), %r15
movq %r15, %rdi
callq 0x2677c
movq 0x3e0(%r12), %rax
movq %rax, (%r14)
movq %r14, 0x3e0(%r12)
movq %r15, %rdi
callq 0x267aa
jmp 0x19b47
leal -0x10001(%rbx), %eax
cmpl $0x9, %eax
ja 0x19cbe
leaq 0x140a7(%rip), %rcx # 0x2dbb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movups 0x2f261(%rip), %xmm0 # 0x48d7a
movaps %xmm0, 0xe0(%rsp)
movups 0x2f242(%rip), %xmm0 # 0x48d6a
movaps %xmm0, 0xd0(%rsp)
movl $0x64657a, 0xf0(%rsp) # imm = 0x64657A
jmp 0x19a75
leaq 0x5d701(%rip), %r14 # 0x77248
movl %ebx, 0x8(%r14)
addq $0xc, %r14
leaq 0xd0(%rsp), %rsi
movq %r14, %rdi
callq 0x13720
movq 0x5daf2(%rip), %rax # 0x77658
testq %rax, %rax
je 0x19b77
leaq 0xd0(%rsp), %rsi
movl %ebx, %edi
callq *%rax
addq $0x4d8, %rsp # imm = 0x4D8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movabsq $0x79726f6d656d20, %rax # imm = 0x79726F6D656D20
movq %rax, 0xd6(%rsp)
movabsq $0x6d20666f2074754f, %rax # imm = 0x6D20666F2074754F
movq %rax, 0xd0(%rsp)
jmp 0x19a75
movups 0x2f2e3(%rip), %xmm0 # 0x48e99
movaps %xmm0, 0xe0(%rsp)
movups 0x2f2c4(%rip), %xmm0 # 0x48e89
movaps %xmm0, 0xd0(%rsp)
movl $0x747865, 0xf0(%rsp) # imm = 0x747865
jmp 0x19a75
movups 0x2f1d6(%rip), %xmm0 # 0x48dba
movaps %xmm0, 0xe0(%rsp)
movups 0x2f1b7(%rip), %xmm0 # 0x48daa
movaps %xmm0, 0xd0(%rsp)
movl $0x726574, 0xf0(%rsp) # imm = 0x726574
jmp 0x19a75
movups 0x2f1c8(%rip), %xmm0 # 0x48dda
movups %xmm0, 0xdc(%rsp)
movups 0x2f1ad(%rip), %xmm0 # 0x48dce
jmp 0x19cd4
movups 0x2f225(%rip), %xmm0 # 0x48e52
movaps %xmm0, 0xe0(%rsp)
movups 0x2f206(%rip), %xmm0 # 0x48e42
movaps %xmm0, 0xd0(%rsp)
movl $0x646572, 0xef(%rsp) # imm = 0x646572
jmp 0x19a75
movups 0x2f13f(%rip), %xmm0 # 0x48d9a
movups %xmm0, 0xdc(%rsp)
movups 0x2f124(%rip), %xmm0 # 0x48d8e
jmp 0x19cd4
movups 0x2f195(%rip), %xmm0 # 0x48e08
movaps %xmm0, 0xe0(%rsp)
movups 0x2f176(%rip), %xmm0 # 0x48df8
movaps %xmm0, 0xd0(%rsp)
movb $0x0, 0xf0(%rsp)
jmp 0x19a75
movups 0x2f194(%rip), %xmm0 # 0x48e32
movups %xmm0, 0xe9(%rsp)
movups 0x2f17c(%rip), %xmm0 # 0x48e29
movaps %xmm0, 0xe0(%rsp)
movups 0x2f15d(%rip), %xmm0 # 0x48e19
jmp 0x19cd4
movups 0x2f1f2(%rip), %xmm0 # 0x48eb7
movups %xmm0, 0xda(%rsp)
movups 0x2f1d9(%rip), %xmm0 # 0x48ead
movaps %xmm0, 0xd0(%rsp)
jmp 0x19a75
movups 0x2f18d(%rip), %xmm0 # 0x48e75
movaps %xmm0, 0xe0(%rsp)
movups 0x2f16e(%rip), %xmm0 # 0x48e65
movaps %xmm0, 0xd0(%rsp)
movl $0x656c62, 0xf0(%rsp) # imm = 0x656C62
jmp 0x19a75
| /anael-seghezzi[P]glfw/src/init.c |
glfwInit | GLFWAPI int glfwInit(void)
{
if (_glfw.initialized)
return GLFW_TRUE;
memset(&_glfw, 0, sizeof(_glfw));
_glfw.hints.init = _glfwInitHints;
if (!_glfwPlatformInit())
{
terminate();
return GLFW_FALSE;
}
if (!_glfwPlatformCreateMutex(&_glfw.errorLock) ||
!_glfwPlatformCreateTls(&_glfw.errorSlot) ||
!_glfwPlatformCreateTls(&_glfw.contextSlot))
{
terminate();
return GLFW_FALSE;
}
_glfwPlatformSetTls(&_glfw.errorSlot, &_glfwMainThreadError);
_glfw.initialized = GLFW_TRUE;
_glfw.timer.offset = _glfwPlatformGetTimerValue();
glfwDefaultWindowHints();
{
int i;
for (i = 0; _glfwDefaultMappings[i]; i++)
{
if (!glfwUpdateGamepadMappings(_glfwDefaultMappings[i]))
{
terminate();
return GLFW_FALSE;
}
}
}
return GLFW_TRUE;
} | pushq %r14
pushq %rbx
pushq %rax
leaq 0x3cbae(%rip), %r14 # 0x568c8
cmpl $0x0, (%r14)
je 0x19d2a
movl $0x1, %ebx
jmp 0x19e01
xorl %ebx, %ebx
movl $0x20980, %edx # imm = 0x20980
movq %r14, %rdi
xorl %esi, %esi
callq 0x130f0
movq 0x3b4e6(%rip), %rax # 0x55228
movq %rax, 0x8(%r14)
movl 0x3b4e4(%rip), %eax # 0x55230
movl %eax, 0x10(%r14)
callq 0x1f0e2
testl %eax, %eax
je 0x19dfc
movl $0x1fe28, %edi # imm = 0x1FE28
addq 0x3a27f(%rip), %rdi # 0x53fe8
callq 0x266f3
testl %eax, %eax
je 0x19dfc
movl $0x1fe14, %edi # imm = 0x1FE14
addq 0x3a266(%rip), %rdi # 0x53fe8
callq 0x26618
testl %eax, %eax
je 0x19dfc
movl $0x1fe1c, %edi # imm = 0x1FE1C
addq 0x3a251(%rip), %rdi # 0x53fe8
callq 0x26618
testl %eax, %eax
je 0x19dfc
leaq 0x1fe14(%r14), %rdi
leaq 0x5d49a(%rip), %rsi # 0x77248
callq 0x266c6
movl $0x1, (%r14)
callq 0x265bd
movq %rax, 0x1fe58(%r14)
callq 0x1dad3
leaq 0x3a76e(%rip), %r14 # 0x54540
movq (%r14), %rdi
testq %rdi, %rdi
je 0x19d20
addq $0x8, %r14
callq 0x1b557
testl %eax, %eax
je 0x19dfc
movq (%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0x19de2
jmp 0x19d20
callq 0x19e0b
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /anael-seghezzi[P]glfw/src/init.c |
terminate | static void terminate(void)
{
int i;
memset(&_glfw.callbacks, 0, sizeof(_glfw.callbacks));
while (_glfw.windowListHead)
glfwDestroyWindow((GLFWwindow*) _glfw.windowListHead);
while (_glfw.cursorListHead)
glfwDestroyCursor((GLFWcursor*) _glfw.cursorListHead);
for (i = 0; i < _glfw.monitorCount; i++)
{
_GLFWmonitor* monitor = _glfw.monitors[i];
if (monitor->originalRamp.size)
_glfwPlatformSetGammaRamp(monitor, &monitor->originalRamp);
_glfwFreeMonitor(monitor);
}
free(_glfw.monitors);
_glfw.monitors = NULL;
_glfw.monitorCount = 0;
free(_glfw.mappings);
_glfw.mappings = NULL;
_glfw.mappingCount = 0;
_glfwTerminateVulkan();
_glfwPlatformTerminate();
_glfw.initialized = GLFW_FALSE;
while (_glfw.errorListHead)
{
_GLFWerror* error = _glfw.errorListHead;
_glfw.errorListHead = error->next;
free(error);
}
_glfwPlatformDestroyTls(&_glfw.contextSlot);
_glfwPlatformDestroyTls(&_glfw.errorSlot);
_glfwPlatformDestroyMutex(&_glfw.errorLock);
memset(&_glfw, 0, sizeof(_glfw));
} | pushq %r15
pushq %r14
pushq %rbx
xorps %xmm0, %xmm0
leaq 0x3caae(%rip), %rbx # 0x568c8
movups %xmm0, 0x1feb0(%rbx)
movq 0x3f0(%rbx), %rdi
testq %rdi, %rdi
je 0x19e39
callq 0x1da4f
jmp 0x19e21
callq 0x1ab4a
movq 0x3e8(%rbx), %rdi
testq %rdi, %rdi
jne 0x19e34
cmpl $0x0, 0x400(%rbx)
jle 0x19e86
xorl %r15d, %r15d
movq 0x3f8(%rbx), %rax
movq (%rax,%r15,8), %r14
cmpl $0x0, 0x60(%r14)
je 0x19e6f
leaq 0x48(%r14), %rsi
movq %r14, %rdi
callq 0x21d65
movq %r14, %rdi
callq 0x1c623
incq %r15
movslq 0x400(%rbx), %rax
cmpq %rax, %r15
jl 0x19e51
movq 0x3f8(%rbx), %rdi
callq 0x133e0
xorl %r14d, %r14d
movq %r14, 0x3f8(%rbx)
movl %r14d, 0x400(%rbx)
movq 0x1fe08(%rbx), %rdi
callq 0x133e0
movq %r14, 0x1fe08(%rbx)
movl %r14d, 0x1fe10(%rbx)
callq 0x1d268
callq 0x21078
movl %r14d, (%rbx)
movq 0x3e0(%rbx), %rdi
testq %rdi, %rdi
je 0x19ee7
movq (%rdi), %rax
movq %rax, 0x3e0(%rbx)
callq 0x133e0
jmp 0x19eca
leaq 0x1fe1c(%rbx), %rdi
callq 0x2667f
leaq 0x1fe14(%rbx), %rdi
callq 0x2667f
leaq 0x1fe28(%rbx), %rdi
callq 0x2675a
movl $0x20980, %edx # imm = 0x20980
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x130f0
| /anael-seghezzi[P]glfw/src/init.c |
glfwInitHint | GLFWAPI void glfwInitHint(int hint, int value)
{
switch (hint)
{
case GLFW_JOYSTICK_HAT_BUTTONS:
_glfwInitHints.hatButtons = value;
return;
case GLFW_COCOA_CHDIR_RESOURCES:
_glfwInitHints.ns.chdir = value;
return;
case GLFW_COCOA_MENUBAR:
_glfwInitHints.ns.menubar = value;
return;
}
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid init hint 0x%08X", hint);
} | cmpl $0x51002, %edi # imm = 0x51002
je 0x19f58
movl %edi, %edx
cmpl $0x51001, %edi # imm = 0x51001
je 0x19f51
cmpl $0x50001, %edx # imm = 0x50001
jne 0x19f5f
movl %esi, 0x3b2d8(%rip) # 0x55228
retq
movl %esi, 0x3b2d9(%rip) # 0x55230
retq
movl %esi, 0x3b2ce(%rip) # 0x5522c
retq
leaq 0x2ef61(%rip), %rsi # 0x48ec7
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
jmp 0x199c5
| /anael-seghezzi[P]glfw/src/init.c |
glfwGetVersion | GLFWAPI void glfwGetVersion(int* major, int* minor, int* rev)
{
if (major != NULL)
*major = GLFW_VERSION_MAJOR;
if (minor != NULL)
*minor = GLFW_VERSION_MINOR;
if (rev != NULL)
*rev = GLFW_VERSION_REVISION;
} | testq %rdi, %rdi
je 0x19f7d
movl $0x3, (%rdi)
testq %rsi, %rsi
je 0x19f88
movl $0x3, (%rsi)
testq %rdx, %rdx
je 0x19f93
movl $0x0, (%rdx)
retq
| /anael-seghezzi[P]glfw/src/init.c |
glfwGetError | GLFWAPI int glfwGetError(const char** description)
{
_GLFWerror* error;
int code = GLFW_NO_ERROR;
if (description)
*description = NULL;
if (_glfw.initialized)
error = _glfwPlatformGetTls(&_glfw.errorSlot);
else
error = &_glfwMainThreadError;
if (error)
{
code = error->code;
error->code = GLFW_NO_ERROR;
if (description && code)
*description = error->description;
}
return code;
} | pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x19fa9
movq $0x0, (%rbx)
leaq 0x3c918(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x19fcf
movl $0x1fe14, %edi # imm = 0x1FE14
addq 0x3a027(%rip), %rdi # 0x53fe8
callq 0x26699
testq %rax, %rax
jne 0x19fd6
xorl %ecx, %ecx
jmp 0x19ffc
leaq 0x5d272(%rip), %rax # 0x77248
testq %rbx, %rbx
setne %dl
movl 0x8(%rax), %ecx
movl $0x0, 0x8(%rax)
testl %ecx, %ecx
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x19ffc
addq $0xc, %rax
movq %rax, (%rbx)
movl %ecx, %eax
popq %rbx
retq
| /anael-seghezzi[P]glfw/src/init.c |
glfwInputKey | void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int mods)
{
if (key >= 0 && key <= GLFW_KEY_LAST)
{
GLFWbool repeated = GLFW_FALSE;
if (action == GLFW_RELEASE && window->keys[key] == GLFW_RELEASE)
return;
if (action == GLFW_PRESS && window->keys[key] == GLFW_PRESS)
repeated = GLFW_TRUE;
if (action == GLFW_RELEASE && window->stickyKeys)
window->keys[key] = _GLFW_STICK;
else
window->keys[key] = (char) action;
if (repeated)
action = GLFW_REPEAT;
}
if (!window->lockKeyMods)
mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
if (window->callbacks.key)
window->callbacks.key((GLFWwindow*) window, key, scancode, action, mods);
} | cmpl $0x15c, %esi # imm = 0x15C
ja 0x1a05d
movl %esi, %eax
cmpl $0x1, %ecx
je 0x1a03d
testl %ecx, %ecx
jne 0x1a056
cmpb $0x0, 0x80(%rdi,%rax)
je 0x1a082
cmpl $0x0, 0x68(%rdi)
je 0x1a083
movb $0x3, 0x80(%rdi,%rax)
jmp 0x1a05d
cmpb $0x1, 0x80(%rdi,%rax)
movb $0x1, 0x80(%rdi,%rax)
movl $0x2, %eax
jne 0x1a05d
jmp 0x1a05f
movb %cl, 0x80(%rdi,%rax)
movl %ecx, %eax
movq 0x320(%rdi), %r11
testq %r11, %r11
je 0x1a082
movl %r8d, %r9d
andl $-0x31, %r9d
cmpl $0x0, 0x70(%rdi)
cmovnel %r8d, %r9d
movl %eax, %ecx
movl %r9d, %r8d
jmpq *%r11
retq
movb $0x0, 0x80(%rdi,%rax)
jmp 0x1a05d
| /anael-seghezzi[P]glfw/src/input.c |
glfwInputChar | void _glfwInputChar(_GLFWwindow* window, unsigned int codepoint, int mods, GLFWbool plain)
{
if (codepoint < 32 || (codepoint > 126 && codepoint < 160))
return;
if (!window->lockKeyMods)
mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
if (window->callbacks.charmods)
window->callbacks.charmods((GLFWwindow*) window, codepoint, mods);
if (plain)
{
if (window->callbacks.character)
window->callbacks.character((GLFWwindow*) window, codepoint);
}
} | pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movl %esi, %ebx
cmpl $0x20, %esi
setb %al
leal -0x7f(%rbx), %ecx
cmpl $0x21, %ecx
setb %cl
orb %al, %cl
jne 0x1a0e8
movq %rdi, %r14
movq 0x330(%rdi), %rcx
testq %rcx, %rcx
je 0x1a0cd
movl %edx, %eax
andl $-0x31, %eax
cmpl $0x0, 0x70(%r14)
cmovnel %edx, %eax
movq %r14, %rdi
movl %ebx, %esi
movl %eax, %edx
callq *%rcx
testl %ebp, %ebp
je 0x1a0e8
movq 0x328(%r14), %rax
testq %rax, %rax
je 0x1a0e8
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
popq %rbx
popq %r14
popq %rbp
retq
| /anael-seghezzi[P]glfw/src/input.c |
glfwInputMouseClick | void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods)
{
if (button < 0 || button > GLFW_MOUSE_BUTTON_LAST)
return;
if (!window->lockKeyMods)
mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
if (action == GLFW_RELEASE && window->stickyMouseButtons)
window->mouseButtons[button] = _GLFW_STICK;
else
window->mouseButtons[button] = (char) action;
if (window->callbacks.mouseButton)
window->callbacks.mouseButton((GLFWwindow*) window, button, action, mods);
} | cmpl $0x7, %esi
ja 0x1a133
movl %ecx, %eax
andl $-0x31, %ecx
cmpl $0x0, 0x70(%rdi)
cmovnel %eax, %ecx
testl %edx, %edx
je 0x1a115
movl %edx, %eax
jmp 0x1a11d
movb $0x3, %al
cmpl $0x0, 0x6c(%rdi)
je 0x1a111
movl %esi, %r8d
movb %al, 0x78(%rdi,%r8)
movq 0x300(%rdi), %rax
testq %rax, %rax
je 0x1a133
jmpq *%rax
retq
| /anael-seghezzi[P]glfw/src/input.c |
glfwInputCursorPos | void _glfwInputCursorPos(_GLFWwindow* window, double xpos, double ypos)
{
if (window->virtualCursorPosX == xpos && window->virtualCursorPosY == ypos)
return;
window->virtualCursorPosX = xpos;
window->virtualCursorPosY = ypos;
if (window->callbacks.cursorPos)
window->callbacks.cursorPos((GLFWwindow*) window, xpos, ypos);
} | movsd 0x1e0(%rdi), %xmm2
ucomisd %xmm0, %xmm2
jne 0x1a154
jp 0x1a154
movsd 0x1e8(%rdi), %xmm2
ucomisd %xmm1, %xmm2
jne 0x1a154
jnp 0x1a172
movsd %xmm0, 0x1e0(%rdi)
movsd %xmm1, 0x1e8(%rdi)
movq 0x308(%rdi), %rax
testq %rax, %rax
je 0x1a172
jmpq *%rax
retq
| /anael-seghezzi[P]glfw/src/input.c |
glfwInputJoystickHat | void _glfwInputJoystickHat(_GLFWjoystick* js, int hat, char value)
{
const int base = js->buttonCount + hat * 4;
js->buttons[base + 0] = (value & 0x01) ? GLFW_PRESS : GLFW_RELEASE;
js->buttons[base + 1] = (value & 0x02) ? GLFW_PRESS : GLFW_RELEASE;
js->buttons[base + 2] = (value & 0x04) ? GLFW_PRESS : GLFW_RELEASE;
js->buttons[base + 3] = (value & 0x08) ? GLFW_PRESS : GLFW_RELEASE;
js->hats[hat] = value;
} | movslq 0x20(%rdi), %rax
movslq %esi, %rcx
leaq (%rax,%rcx,4), %rax
movl %edx, %esi
andb $0x1, %sil
movq 0x18(%rdi), %r8
movb %sil, (%r8,%rax)
movl %edx, %esi
shrb %sil
andb $0x1, %sil
movq 0x18(%rdi), %r8
movb %sil, 0x1(%r8,%rax)
movl %edx, %esi
shrb $0x2, %sil
andb $0x1, %sil
movq 0x18(%rdi), %r8
movb %sil, 0x2(%r8,%rax)
movl %edx, %esi
shrb $0x3, %sil
andb $0x1, %sil
movq 0x18(%rdi), %r8
movb %sil, 0x3(%r8,%rax)
movq 0x28(%rdi), %rax
movb %dl, (%rax,%rcx)
retq
| /anael-seghezzi[P]glfw/src/input.c |
glfwAllocJoystick | _GLFWjoystick* _glfwAllocJoystick(const char* name,
const char* guid,
int axisCount,
int buttonCount,
int hatCount)
{
int jid;
_GLFWjoystick* js;
for (jid = 0; jid <= GLFW_JOYSTICK_LAST; jid++)
{
if (!_glfw.joysticks[jid].present)
break;
}
if (jid > GLFW_JOYSTICK_LAST)
return NULL;
js = _glfw.joysticks + jid;
js->present = GLFW_TRUE;
js->name = _glfw_strdup(name);
js->axes = calloc(axisCount, sizeof(float));
js->buttons = calloc(buttonCount + hatCount * 4, 1);
js->hats = calloc(hatCount, 1);
js->axisCount = axisCount;
js->buttonCount = buttonCount;
js->hatCount = hatCount;
strcpy(js->guid, guid);
js->mapping = findValidMapping(js);
return js;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movl $0x408, %ebx # imm = 0x408
addq 0x39d96(%rip), %rbx # 0x53fe8
movl $0x10, %eax
cmpl $0x0, (%rbx)
je 0x1a26c
addq $0x1fa0, %rbx # imm = 0x1FA0
decq %rax
jne 0x1a257
xorl %ebx, %ebx
jmp 0x1a2dc
movl $0x1, (%rbx)
callq 0x19978
movq %rax, 0x38(%rbx)
movslq %ebp, %r13
movl $0x4, %esi
movq %r13, %rdi
callq 0x13790
movq %rax, 0x8(%rbx)
leal (%r15,%r12,4), %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x13790
movq %rax, 0x18(%rbx)
movslq %r12d, %r12
movl $0x1, %esi
movq %r12, %rdi
callq 0x13790
movq %rax, 0x28(%rbx)
movl %r13d, 0x10(%rbx)
movl %r15d, 0x20(%rbx)
movl %r12d, 0x30(%rbx)
leaq 0x48(%rbx), %rdi
movq %r14, %rsi
callq 0x13720
movq %rbx, %rdi
callq 0x1a2ee
movq %rax, 0x70(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /anael-seghezzi[P]glfw/src/input.c |
glfwGetInputMode | GLFWAPI int glfwGetInputMode(GLFWwindow* handle, int mode)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(0);
switch (mode)
{
case GLFW_CURSOR:
return window->cursorMode;
case GLFW_STICKY_KEYS:
return window->stickyKeys;
case GLFW_STICKY_MOUSE_BUTTONS:
return window->stickyMouseButtons;
case GLFW_LOCK_KEY_MODS:
return window->lockKeyMods;
case GLFW_RAW_MOUSE_MOTION:
return window->rawMouseMotion;
}
_glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode 0x%08X", mode);
return 0;
} | pushq %rbx
testq %rdi, %rdi
je 0x1a485
leaq 0x3c4ac(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x1a443
movl %esi, %edx
leal -0x33001(%rdx), %eax
cmpl $0x4, %eax
ja 0x1a46c
leaq 0x2ead3(%rip), %rcx # 0x48f08
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x74(%rdi), %ebx
jmp 0x1a481
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x199c5
jmp 0x1a481
movl 0x1f0(%rdi), %ebx
jmp 0x1a481
movl 0x6c(%rdi), %ebx
jmp 0x1a481
movl 0x70(%rdi), %ebx
jmp 0x1a481
movl 0x68(%rdi), %ebx
jmp 0x1a481
leaq 0x2ec02(%rip), %rsi # 0x49075
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x199c5
movl %ebx, %eax
popq %rbx
retq
leaq 0x134b5(%rip), %rdi # 0x2d941
leaq 0x2eb61(%rip), %rsi # 0x48ff4
leaq 0x2ebb3(%rip), %rcx # 0x4904d
movl $0x1da, %edx # imm = 0x1DA
callq 0x131e0
| /anael-seghezzi[P]glfw/src/input.c |
glfwSetInputMode | GLFWAPI void glfwSetInputMode(GLFWwindow* handle, int mode, int value)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (mode == GLFW_CURSOR)
{
if (value != GLFW_CURSOR_NORMAL &&
value != GLFW_CURSOR_HIDDEN &&
value != GLFW_CURSOR_DISABLED)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid cursor mode 0x%08X",
value);
return;
}
if (window->cursorMode == value)
return;
window->cursorMode = value;
_glfwPlatformGetCursorPos(window,
&window->virtualCursorPosX,
&window->virtualCursorPosY);
_glfwPlatformSetCursorMode(window, value);
}
else if (mode == GLFW_STICKY_KEYS)
{
value = value ? GLFW_TRUE : GLFW_FALSE;
if (window->stickyKeys == value)
return;
if (!value)
{
int i;
// Release all sticky keys
for (i = 0; i <= GLFW_KEY_LAST; i++)
{
if (window->keys[i] == _GLFW_STICK)
window->keys[i] = GLFW_RELEASE;
}
}
window->stickyKeys = value;
}
else if (mode == GLFW_STICKY_MOUSE_BUTTONS)
{
value = value ? GLFW_TRUE : GLFW_FALSE;
if (window->stickyMouseButtons == value)
return;
if (!value)
{
int i;
// Release all sticky mouse buttons
for (i = 0; i <= GLFW_MOUSE_BUTTON_LAST; i++)
{
if (window->mouseButtons[i] == _GLFW_STICK)
window->mouseButtons[i] = GLFW_RELEASE;
}
}
window->stickyMouseButtons = value;
}
else if (mode == GLFW_LOCK_KEY_MODS)
{
window->lockKeyMods = value ? GLFW_TRUE : GLFW_FALSE;
}
else if (mode == GLFW_RAW_MOUSE_MOTION)
{
if (!_glfwPlatformRawMouseMotionSupported())
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Raw mouse motion is not supported on this system");
return;
}
value = value ? GLFW_TRUE : GLFW_FALSE;
if (window->rawMouseMotion == value)
return;
window->rawMouseMotion = value;
_glfwPlatformSetRawMouseMotion(window, value);
}
else
_glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode 0x%08X", mode);
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1a73c
leaq 0x3c410(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x1a508
movl %edx, %r14d
movl %esi, %edx
leal -0x33001(%rdx), %eax
cmpl $0x4, %eax
ja 0x1a6d7
movq %rdi, %rbx
leaq 0x2ea41(%rip), %rcx # 0x48f1c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leal -0x34004(%r14), %eax
cmpl $-0x4, %eax
ja 0x1a6f1
leaq 0x2ebc2(%rip), %rsi # 0x490bd
movl $0x10003, %edi # imm = 0x10003
movl %r14d, %edx
jmp 0x1a6e3
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x199c5
callq 0x246b6
testl %eax, %eax
je 0x1a6ff
xorl %esi, %esi
testl %r14d, %r14d
setne %sil
cmpl %esi, 0x1f0(%rbx)
je 0x1a6f7
movl %esi, 0x1f0(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24638
xorl %eax, %eax
testl %r14d, %r14d
setne %al
cmpl %eax, 0x6c(%rbx)
je 0x1a6f7
testl %r14d, %r14d
jne 0x1a693
movq 0x78(%rbx), %xmm0
movdqa 0x2e9b5(%rip), %xmm1 # 0x48f30
pcmpeqb %xmm0, %xmm1
movd %xmm1, %ecx
testb $0x1, %cl
je 0x1a58c
movb $0x0, 0x78(%rbx)
movdqa 0x2e9ac(%rip), %xmm1 # 0x48f40
punpcklbw %xmm1, %xmm1 # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
movdqa %xmm0, %xmm2
pslld $0x8, %xmm2
pcmpeqb %xmm1, %xmm2
movd %xmm2, %ecx
shrl $0x10, %ecx
testb $0x1, %cl
je 0x1a5b5
movb $0x0, 0x79(%rbx)
movdqa 0x2e993(%rip), %xmm1 # 0x48f50
punpcklbw %xmm1, %xmm1 # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x55, %xmm0, %xmm2 # xmm2 = xmm0[1,1,1,1,4,5,6,7]
pcmpeqb %xmm1, %xmm2
pextrw $0x2, %xmm2, %ecx
testb $0x1, %cl
je 0x1a5d8
movb $0x0, 0x7a(%rbx)
movdqa 0x2e980(%rip), %xmm1 # 0x48f60
punpcklbw %xmm1, %xmm1 # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
movdqa %xmm0, %xmm2
psllq $0x18, %xmm2
pcmpeqb %xmm1, %xmm2
pextrw $0x3, %xmm2, %ecx
testb $0x1, %cl
je 0x1a5ff
movb $0x0, 0x7b(%rbx)
movdqa 0x2e969(%rip), %xmm1 # 0x48f70
punpcklbw %xmm1, %xmm1 # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshufd $0x55, %xmm0, %xmm2 # xmm2 = xmm0[1,1,1,1]
pcmpeqb %xmm1, %xmm2
pextrw $0x4, %xmm2, %ecx
testb $0x1, %cl
je 0x1a622
movb $0x0, 0x7c(%rbx)
movdqa 0x2e956(%rip), %xmm1 # 0x48f80
punpcklbw %xmm1, %xmm1 # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
movdqa %xmm0, %xmm2
pslldq $0x5, %xmm2 # xmm2 = zero,zero,zero,zero,zero,xmm2[0,1,2,3,4,5,6,7,8,9,10]
pcmpeqb %xmm1, %xmm2
pextrw $0x5, %xmm2, %ecx
testb $0x1, %cl
je 0x1a649
movb $0x0, 0x7d(%rbx)
movdqa 0x2e93f(%rip), %xmm1 # 0x48f90
punpcklbw %xmm1, %xmm1 # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
movdqa %xmm0, %xmm2
pslldq $0x6, %xmm2 # xmm2 = zero,zero,zero,zero,zero,zero,xmm2[0,1,2,3,4,5,6,7,8,9]
pcmpeqb %xmm1, %xmm2
pextrw $0x6, %xmm2, %ecx
testb $0x1, %cl
je 0x1a670
movb $0x0, 0x7e(%rbx)
movdqa 0x2e928(%rip), %xmm1 # 0x48fa0
punpcklbw %xmm1, %xmm1 # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pslldq $0x7, %xmm0 # xmm0 = zero,zero,zero,zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8]
pcmpeqb %xmm1, %xmm0
pextrw $0x7, %xmm0, %ecx
testb $0x1, %cl
je 0x1a693
movb $0x0, 0x7f(%rbx)
movl %eax, 0x6c(%rbx)
jmp 0x1a6f7
xorl %eax, %eax
testl %r14d, %r14d
setne %al
movl %eax, 0x70(%rbx)
jmp 0x1a6f7
xorl %eax, %eax
testl %r14d, %r14d
setne %al
cmpl %eax, 0x68(%rbx)
je 0x1a6f7
testl %r14d, %r14d
jne 0x1a6d2
movl $0x80, %ecx
cmpb $0x3, (%rbx,%rcx)
jne 0x1a6c6
movb $0x0, (%rbx,%rcx)
incq %rcx
cmpq $0x1dd, %rcx # imm = 0x1DD
jne 0x1a6bc
movl %eax, 0x68(%rbx)
jmp 0x1a6f7
leaq 0x2e997(%rip), %rsi # 0x49075
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x199c5
cmpl %r14d, 0x74(%rbx)
jne 0x1a710
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2e9d2(%rip), %rsi # 0x490d8
movl $0x10008, %edi # imm = 0x10008
jmp 0x1a50f
movl %r14d, 0x74(%rbx)
leaq 0x1e0(%rbx), %rsi
leaq 0x1e8(%rbx), %rdx
movq %rbx, %rdi
callq 0x25817
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x258a0
leaq 0x131fe(%rip), %rdi # 0x2d941
leaq 0x2e8aa(%rip), %rsi # 0x48ff4
leaq 0x2e93e(%rip), %rcx # 0x4908f
movl $0x1f3, %edx # imm = 0x1F3
callq 0x131e0
| /anael-seghezzi[P]glfw/src/input.c |
glfwGetKey | GLFWAPI int glfwGetKey(GLFWwindow* handle, int key)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
if (key < GLFW_KEY_SPACE || key > GLFW_KEY_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid key %i", key);
return GLFW_RELEASE;
}
if (window->keys[key] == _GLFW_STICK)
{
// Sticky mode: release key now
window->keys[key] = GLFW_RELEASE;
return GLFW_PRESS;
}
return (int) window->keys[key];
} | pushq %rbx
testq %rdi, %rdi
je 0x1a891
leaq 0x3c094(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x1a85f
movl %esi, %edx
leal -0x15d(%rdx), %eax
cmpl $0xfffffec2, %eax # imm = 0xFFFFFEC2
ja 0x1a871
leaq 0x2e8ba(%rip), %rsi # 0x49109
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x199c5
jmp 0x1a88d
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x199c5
jmp 0x1a88d
movl %edx, %eax
movsbl 0x80(%rdi,%rax), %ebx
cmpl $0x3, %ebx
jne 0x1a88d
movb $0x0, 0x80(%rdi,%rax)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
leaq 0x130a9(%rip), %rdi # 0x2d941
leaq 0x2e755(%rip), %rsi # 0x48ff4
leaq 0x2e872(%rip), %rcx # 0x49118
movl $0x276, %edx # imm = 0x276
callq 0x131e0
| /anael-seghezzi[P]glfw/src/input.c |
glfwGetMouseButton | GLFWAPI int glfwGetMouseButton(GLFWwindow* handle, int button)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
if (button < GLFW_MOUSE_BUTTON_1 || button > GLFW_MOUSE_BUTTON_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid mouse button %i", button);
return GLFW_RELEASE;
}
if (window->mouseButtons[button] == _GLFW_STICK)
{
// Sticky mode: release mouse button now
window->mouseButtons[button] = GLFW_RELEASE;
return GLFW_PRESS;
}
return (int) window->mouseButtons[button];
} | pushq %rbx
testq %rdi, %rdi
je 0x1a90c
leaq 0x3c00b(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x1a8e0
movl %esi, %edx
cmpl $0x8, %esi
jb 0x1a8f2
leaq 0x2e894(%rip), %rsi # 0x49164
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x199c5
jmp 0x1a908
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x199c5
jmp 0x1a908
movl %edx, %eax
movsbl 0x78(%rdi,%rax), %ebx
cmpl $0x3, %ebx
jne 0x1a908
movb $0x0, 0x78(%rdi,%rax)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
leaq 0x1302e(%rip), %rdi # 0x2d941
leaq 0x2e6da(%rip), %rsi # 0x48ff4
leaq 0x2e819(%rip), %rcx # 0x4913a
movl $0x28d, %edx # imm = 0x28D
callq 0x131e0
| /anael-seghezzi[P]glfw/src/input.c |
glfwGetCursorPos | GLFWAPI void glfwGetCursorPos(GLFWwindow* handle, double* xpos, double* ypos)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (xpos)
*xpos = 0;
if (ypos)
*ypos = 0;
_GLFW_REQUIRE_INIT();
if (window->cursorMode == GLFW_CURSOR_DISABLED)
{
if (xpos)
*xpos = window->virtualCursorPosX;
if (ypos)
*ypos = window->virtualCursorPosY;
}
else
_glfwPlatformGetCursorPos(window, xpos, ypos);
} | testq %rdi, %rdi
je 0x1a992
testq %rsi, %rsi
je 0x1a93c
movq $0x0, (%rsi)
testq %rdx, %rdx
je 0x1a948
movq $0x0, (%rdx)
leaq 0x3bf79(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x1a984
cmpl $0x34003, 0x74(%rdi) # imm = 0x34003
jne 0x25817
testq %rsi, %rsi
je 0x1a972
movsd 0x1e0(%rdi), %xmm0
movsd %xmm0, (%rsi)
testq %rdx, %rdx
je 0x1a983
movsd 0x1e8(%rdi), %xmm0
movsd %xmm0, (%rdx)
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x199c5
pushq %rax
leaq 0x12fa7(%rip), %rdi # 0x2d941
leaq 0x2e653(%rip), %rsi # 0x48ff4
leaq 0x2e7d4(%rip), %rcx # 0x4917c
movl $0x2a4, %edx # imm = 0x2A4
callq 0x131e0
| /anael-seghezzi[P]glfw/src/input.c |
glfwSetCursorPos | GLFWAPI void glfwSetCursorPos(GLFWwindow* handle, double xpos, double ypos)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (xpos != xpos || xpos < -DBL_MAX || xpos > DBL_MAX ||
ypos != ypos || ypos < -DBL_MAX || ypos > DBL_MAX)
{
_glfwInputError(GLFW_INVALID_VALUE,
"Invalid cursor position %f %f",
xpos, ypos);
return;
}
if (!_glfwPlatformWindowFocused(window))
return;
if (window->cursorMode == GLFW_CURSOR_DISABLED)
{
// Only update the accumulated position if the cursor is disabled
window->virtualCursorPosX = xpos;
window->virtualCursorPosY = ypos;
}
else
{
// Update system cursor position
_glfwPlatformSetCursorPos(window, xpos, ypos);
}
} | pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x1aa88
leaq 0x3bf01(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x1aa5d
ucomisd 0x2e510(%rip), %xmm0 # 0x48ee8
ja 0x1aa45
ucomisd %xmm0, %xmm0
jp 0x1aa45
movsd 0x2e508(%rip), %xmm2 # 0x48ef0
ucomisd %xmm0, %xmm2
ja 0x1aa45
ucomisd 0x2e4f2(%rip), %xmm1 # 0x48ee8
ja 0x1aa45
ucomisd %xmm1, %xmm1
jp 0x1aa45
ucomisd %xmm1, %xmm2
ja 0x1aa45
movq %rdi, %rbx
movsd %xmm0, (%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x23fbf
testl %eax, %eax
je 0x1aa3f
cmpl $0x34003, 0x74(%rbx) # imm = 0x34003
jne 0x1aa70
movsd (%rsp), %xmm0
movsd %xmm0, 0x1e0(%rbx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x1e8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
leaq 0x2e79c(%rip), %rsi # 0x491e8
movl $0x10004, %edi # imm = 0x10004
movb $0x2, %al
addq $0x10, %rsp
popq %rbx
jmp 0x199c5
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x199c5
movq %rbx, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addq $0x10, %rsp
popq %rbx
jmp 0x256de
leaq 0x12eb2(%rip), %rdi # 0x2d941
leaq 0x2e55e(%rip), %rsi # 0x48ff4
leaq 0x2e717(%rip), %rcx # 0x491b4
movl $0x2bb, %edx # imm = 0x2BB
callq 0x131e0
| /anael-seghezzi[P]glfw/src/input.c |
glfwCreateCursor | GLFWAPI GLFWcursor* glfwCreateCursor(const GLFWimage* image, int xhot, int yhot)
{
_GLFWcursor* cursor;
assert(image != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
cursor = calloc(1, sizeof(_GLFWcursor));
cursor->next = _glfw.cursorListHead;
_glfw.cursorListHead = cursor;
if (!_glfwPlatformCreateCursor(cursor, image, xhot, yhot))
{
glfwDestroyCursor((GLFWcursor*) cursor);
return NULL;
}
return (GLFWcursor*) cursor;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1ab2b
leaq 0x3be0d(%rip), %r12 # 0x568c8
cmpl $0x0, (%r12)
je 0x1ab0f
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
movl $0x1, %edi
movl $0x10, %esi
callq 0x13790
movq %rax, %rbx
movq 0x3e8(%r12), %rax
movq %rax, (%rbx)
movq %rbx, 0x3e8(%r12)
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x25c0a
testl %eax, %eax
jne 0x1ab1f
movq %rbx, %rdi
callq 0x1ab4a
xorl %ebx, %ebx
jmp 0x1ab1f
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x199c5
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e6d4(%rip), %rdi # 0x49206
leaq 0x2e4bb(%rip), %rsi # 0x48ff4
leaq 0x2e6d4(%rip), %rcx # 0x49214
movl $0x2dc, %edx # imm = 0x2DC
callq 0x131e0
| /anael-seghezzi[P]glfw/src/input.c |
glfwDestroyCursor | GLFWAPI void glfwDestroyCursor(GLFWcursor* handle)
{
_GLFWcursor* cursor = (_GLFWcursor*) handle;
_GLFW_REQUIRE_INIT();
if (cursor == NULL)
return;
// Make sure the cursor is not being used by any window
{
_GLFWwindow* window;
for (window = _glfw.windowListHead; window; window = window->next)
{
if (window->cursor == cursor)
glfwSetCursor((GLFWwindow*) window, NULL);
}
}
_glfwPlatformDestroyCursor(cursor);
// Unlink cursor from global linked list
{
_GLFWcursor** prev = &_glfw.cursorListHead;
while (*prev != cursor)
prev = &((*prev)->next);
*prev = cursor->next;
}
free(cursor);
} | pushq %r14
pushq %rbx
pushq %rax
leaq 0x3bd73(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x1abb7
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1abcc
movq 0x3f0(%rax), %r14
testq %r14, %r14
je 0x1ab83
cmpq %rbx, 0x48(%r14)
jne 0x1ab7e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1ac66
movq (%r14), %r14
jmp 0x1ab69
movq %rbx, %rdi
callq 0x25c88
movl $0x3e8, %eax # imm = 0x3E8
addq 0x39451(%rip), %rax # 0x53fe8
movq %rax, %rcx
movq (%rax), %rax
cmpq %rbx, %rax
jne 0x1ab97
movq (%rbx), %rax
movq %rax, (%rcx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x133e0
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x199c5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /anael-seghezzi[P]glfw/src/input.c |
glfwCreateStandardCursor | GLFWAPI GLFWcursor* glfwCreateStandardCursor(int shape)
{
_GLFWcursor* cursor;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (shape != GLFW_ARROW_CURSOR &&
shape != GLFW_IBEAM_CURSOR &&
shape != GLFW_CROSSHAIR_CURSOR &&
shape != GLFW_HAND_CURSOR &&
shape != GLFW_HRESIZE_CURSOR &&
shape != GLFW_VRESIZE_CURSOR)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid standard cursor 0x%08X", shape);
return NULL;
}
cursor = calloc(1, sizeof(_GLFWcursor));
cursor->next = _glfw.cursorListHead;
_glfw.cursorListHead = cursor;
if (!_glfwPlatformCreateStandardCursor(cursor, shape))
{
glfwDestroyCursor((GLFWcursor*) cursor);
return NULL;
}
return (GLFWcursor*) cursor;
} | pushq %r15
pushq %r14
pushq %rbx
leaq 0x3bce8(%rip), %r15 # 0x568c8
cmpl $0x0, (%r15)
je 0x1ac0f
movl %edi, %r14d
leal -0x36007(%r14), %eax
cmpl $-0x7, %eax
ja 0x1ac21
leaq 0x2e652(%rip), %rsi # 0x4924e
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
movl %r14d, %edx
xorl %eax, %eax
callq 0x199c5
jmp 0x1ac5d
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x199c5
jmp 0x1ac5d
movl $0x1, %edi
movl $0x10, %esi
callq 0x13790
movq %rax, %rbx
movq 0x3e8(%r15), %rax
movq %rax, (%rbx)
movq %rbx, 0x3e8(%r15)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x25c2a
testl %eax, %eax
jne 0x1ac5d
movq %rbx, %rdi
callq 0x1ab4a
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
| /anael-seghezzi[P]glfw/src/input.c |
glfwSetTime | GLFWAPI void glfwSetTime(double time)
{
_GLFW_REQUIRE_INIT();
if (time != time || time < 0.0 || time > 18446744073.0)
{
_glfwInputError(GLFW_INVALID_VALUE, "Invalid time %f", time);
return;
}
_glfw.timer.offset = _glfwPlatformGetTimerValue() -
(uint64_t) (time * _glfwPlatformGetTimerFrequency());
} | pushq %r14
pushq %rbx
pushq %rax
leaq 0x3a59d(%rip), %r14 # 0x568c8
cmpl $0x0, (%r14)
je 0x1c3b6
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1c3cb
ucomisd 0x2cbad(%rip), %xmm0 # 0x48ef8
ja 0x1c3cb
movsd %xmm0, (%rsp)
callq 0x265bd
movq %rax, %rbx
callq 0x26609
movq %rax, %xmm0
punpckldq 0x2cc64(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2cc6c(%rip), %xmm0 # 0x48fe0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd (%rsp), %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x2cb67(%rip), %xmm1 # 0x48f00
cvttsd2si %xmm1, %rdx
andq %rcx, %rdx
orq %rax, %rdx
subq %rdx, %rbx
movq %rbx, 0x1fe58(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x199c5
leaq 0x2d375(%rip), %rsi # 0x49747
movl $0x10004, %edi # imm = 0x10004
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x199c5
| /anael-seghezzi[P]glfw/src/input.c |
gladLoadGLLoader | int gladLoadGLLoader(GLADloadproc load) {
GLVersion.major = 0; GLVersion.minor = 0;
glGetString = (PFNGLGETSTRINGPROC)load("glGetString");
if(glGetString == NULL) return 0;
if(glGetString(GL_VERSION) == NULL) return 0;
find_coreGL();
load_GL_VERSION_1_0(load);
load_GL_VERSION_1_1(load);
load_GL_VERSION_1_2(load);
load_GL_VERSION_1_3(load);
load_GL_VERSION_1_4(load);
load_GL_VERSION_1_5(load);
load_GL_VERSION_2_0(load);
load_GL_VERSION_2_1(load);
load_GL_VERSION_3_0(load);
load_GL_VERSION_3_1(load);
load_GL_VERSION_3_2(load);
if (!find_extensionsGL()) return 0;
load_GL_ARB_multisample(load);
load_GL_ARB_robustness(load);
load_GL_KHR_debug(load);
return GLVersion.major != 0 || GLVersion.minor != 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
andq $0x0, 0x758df(%rip) # 0x89cc0
leaq 0x12e7f(%rip), %rdi # 0x27267
callq *%rbx
movq %rax, 0x758d7(%rip) # 0x89cc8
xorl %ebp, %ebp
testq %rax, %rax
je 0x17353
movl $0x1f02, %edi # imm = 0x1F02
callq *%rax
testq %rax, %rax
je 0x17353
movl $0x1f02, %edi # imm = 0x1F02
callq *0x758b1(%rip) # 0x89cc8
testq %rax, %rax
je 0x145a2
movq %rax, %r14
xorl %r13d, %r13d
leaq 0x3c8d3(%rip), %rbp # 0x50d00
cmpq $0x18, %r13
je 0x1445c
movq (%r13,%rbp), %r12
movq %r12, %rdi
callq 0x133d0
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x13240
addq $0x8, %r13
testl %eax, %eax
jne 0x1442d
addq %r15, %r14
leaq 0x15bda(%rip), %rsi # 0x2a03d
leaq 0x14(%rsp), %r15
leaq 0x10(%rsp), %r12
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x13180
movl (%r15), %edi
movl (%r12), %r14d
xorl %esi, %esi
xorl %r13d, %r13d
cmpl $0x2, %edi
setge %sil
setg %r13b
xorl %ecx, %ecx
cmpl $0x4, %edi
setge %cl
testl %r14d, %r14d
pushq $0x1
popq %rdx
movl %esi, %eax
cmovnsl %edx, %eax
movl %eax, 0xc(%rsp)
movl %esi, %r12d
cmovgl %edx, %r12d
movl %r13d, %r9d
cmovnsl %edx, %r9d
movl %r13d, %r10d
cmovgl %edx, %r10d
movl %ecx, %r11d
cmovnsl %edx, %r11d
movl %ecx, %r8d
cmovgl %edx, %r8d
cmpl $0x3, %edi
sete 0xb(%rsp)
cmovnel %ecx, %r11d
cmovnel %ecx, %r8d
cmpl $0x2, %edi
movl %edi, 0x757d9(%rip) # 0x89cc0
movl %r14d, 0x757d6(%rip) # 0x89cc4
movl %edi, 0x76e34(%rip) # 0x8b328
cmovnel %r13d, %r9d
cmovnel %r13d, %r10d
cmpl $0x2, %r14d
movl %esi, %ebp
cmovgel %edx, %ebp
setge %r13b
movl %esi, %eax
cmovgl %edx, %eax
cmpl $0x4, %r14d
movl %esi, %r14d
cmovgel %edx, %r14d
movl %esi, %r15d
cmovgl %edx, %r15d
cmpl %edx, %edi
movl 0xc(%rsp), %edi
cmovnel %esi, %edi
cmovnel %esi, %r12d
movl %edi, 0x7579d(%rip) # 0x89cd0
movl %r12d, 0x7579a(%rip) # 0x89cd4
cmovnel %esi, %ebp
movl %ebp, 0x75795(%rip) # 0x89cd8
cmovnel %esi, %eax
movl %eax, 0x75790(%rip) # 0x89cdc
cmovnel %esi, %r14d
cmovnel %esi, %r15d
movl %r14d, 0x75785(%rip) # 0x89ce0
movl %r15d, 0x75782(%rip) # 0x89ce4
movl %r9d, 0x7577f(%rip) # 0x89ce8
movl %r10d, 0x7577c(%rip) # 0x89cec
movl %r11d, 0x75779(%rip) # 0x89cf0
andb 0xb(%rsp), %r13b
cmovel %ecx, %edx
movl %r8d, 0x7576e(%rip) # 0x89cf4
movl %edx, 0x7576c(%rip) # 0x89cf8
orb %r13b, %cl
testb $0x1, %cl
je 0x1459e
movl $0x3, 0x76d8a(%rip) # 0x8b328
xorl %ebp, %ebp
jmp 0x145a8
movl 0x75728(%rip), %edi # 0x89cd0
testl %edi, %edi
je 0x158d0
leaq 0x12ce3(%rip), %rdi # 0x2729a
callq *%rbx
movq %rax, 0x76310(%rip) # 0x8a8d0
leaq 0x12cde(%rip), %rdi # 0x272a5
callq *%rbx
movq %rax, 0x76be0(%rip) # 0x8b1b0
leaq 0x12cda(%rip), %rdi # 0x272b1
callq *%rbx
movq %rax, 0x76178(%rip) # 0x8a758
leaq 0x12cd1(%rip), %rdi # 0x272b8
callq *%rbx
movq %rax, 0x75790(%rip) # 0x89d80
leaq 0x12ccd(%rip), %rdi # 0x272c4
callq *%rbx
movq %rax, 0x75898(%rip) # 0x89e98
leaq 0x12cc9(%rip), %rdi # 0x272d0
callq *%rbx
movq %rax, 0x75f50(%rip) # 0x8a560
leaq 0x12cc7(%rip), %rdi # 0x272de
callq *%rbx
movq %rax, 0x76630(%rip) # 0x8ac50
leaq 0x12cc1(%rip), %rdi # 0x272e8
callq *%rbx
movq %rax, 0x76090(%rip) # 0x8a6c0
leaq 0x12cc1(%rip), %rdi # 0x272f8
callq *%rbx
movq %rax, 0x76a98(%rip) # 0x8b0d8
leaq 0x12cc2(%rip), %rdi # 0x27309
callq *%rbx
movq %rax, 0x76078(%rip) # 0x8a6c8
leaq 0x12cc2(%rip), %rdi # 0x27319
callq *%rbx
movq %rax, 0x75a20(%rip) # 0x8a080
leaq 0x12cc3(%rip), %rdi # 0x2732a
callq *%rbx
movq %rax, 0x75a08(%rip) # 0x8a078
leaq 0x12cc0(%rip), %rdi # 0x27337
callq *%rbx
movq %rax, 0x76a08(%rip) # 0x8b088
leaq 0x12cbd(%rip), %rdi # 0x27344
callq *%rbx
movq %rax, 0x75b70(%rip) # 0x8a200
leaq 0x12cba(%rip), %rdi # 0x27351
callq *%rbx
movq %rax, 0x75968(%rip) # 0x8a008
leaq 0x12cb2(%rip), %rdi # 0x27359
callq *%rbx
movq %rax, 0x765e0(%rip) # 0x8ac90
leaq 0x12caf(%rip), %rdi # 0x27366
callq *%rbx
movq %rax, 0x75c18(%rip) # 0x8a2d8
leaq 0x12cae(%rip), %rdi # 0x27375
callq *%rbx
movq %rax, 0x75fe0(%rip) # 0x8a6b0
leaq 0x12cab(%rip), %rdi # 0x27382
callq *%rbx
movq %rax, 0x769b0(%rip) # 0x8b090
leaq 0x12ca9(%rip), %rdi # 0x27390
callq *%rbx
movq %rax, 0x766f8(%rip) # 0x8ade8
leaq 0x12ca5(%rip), %rdi # 0x2739c
callq *%rbx
movq %rax, 0x76a70(%rip) # 0x8b170
leaq 0x12ca1(%rip), %rdi # 0x273a8
callq *%rbx
movq %rax, 0x76170(%rip) # 0x8a880
leaq 0x12c9b(%rip), %rdi # 0x273b2
callq *%rbx
movq %rax, 0x75a48(%rip) # 0x8a168
leaq 0x12c94(%rip), %rdi # 0x273bb
callq *%rbx
movq %rax, 0x75f08(%rip) # 0x8a638
leaq 0x12c8d(%rip), %rdi # 0x273c4
callq *%rbx
movq %rax, 0x75b08(%rip) # 0x8a248
leaq 0x12c85(%rip), %rdi # 0x273cc
callq *%rbx
movq %rax, 0x764b8(%rip) # 0x8ac08
leaq 0x12c81(%rip), %rdi # 0x273d8
callq *%rbx
movq %rax, 0x76128(%rip) # 0x8a888
leaq 0x12c7b(%rip), %rdi # 0x273e2
callq *%rbx
movq %rax, 0x763c8(%rip) # 0x8ab38
leaq 0x12c79(%rip), %rdi # 0x273f0
callq *%rbx
movq %rax, 0x758b0(%rip) # 0x8a030
leaq 0x12c75(%rip), %rdi # 0x273fc
callq *%rbx
movq %rax, 0x765e8(%rip) # 0x8ad78
leaq 0x12c71(%rip), %rdi # 0x27408
callq *%rbx
movq %rax, 0x75f50(%rip) # 0x8a6f0
leaq 0x12c6f(%rip), %rdi # 0x27416
callq *%rbx
movq %rax, 0x75d08(%rip) # 0x8a4b8
leaq 0x12c6d(%rip), %rdi # 0x27424
callq *%rbx
movq %rax, 0x761d0(%rip) # 0x8a990
leaq 0x12c6a(%rip), %rdi # 0x27431
callq *%rbx
movq %rax, 0x762d8(%rip) # 0x8aaa8
leaq 0x12c67(%rip), %rdi # 0x2743e
callq *%rbx
movq %rax, 0x75e60(%rip) # 0x8a640
leaq 0x12c65(%rip), %rdi # 0x2744c
callq *%rbx
movq %rax, 0x75c80(%rip) # 0x8a470
leaq 0x35693(%rip), %rdi # 0x49e8a
callq *%rbx
movq %rax, 0x767e0(%rip) # 0x8afe0
leaq 0x12c52(%rip), %rdi # 0x27459
callq *%rbx
movq %rax, 0x767e8(%rip) # 0x8aff8
leaq 0x12c4e(%rip), %rdi # 0x27465
callq *%rbx
movq %rax, 0x76820(%rip) # 0x8b040
leaq 0x12a40(%rip), %rdi # 0x27267
callq *%rbx
movq %rax, 0x75498(%rip) # 0x89cc8
leaq 0x12c3c(%rip), %rdi # 0x27473
callq *%rbx
movq %rax, 0x75858(%rip) # 0x8a098
leaq 0x12c3a(%rip), %rdi # 0x27481
callq *%rbx
movq %rax, 0x76560(%rip) # 0x8adb0
leaq 0x12c3e(%rip), %rdi # 0x27495
callq *%rbx
movq %rax, 0x75fa8(%rip) # 0x8a808
leaq 0x12c42(%rip), %rdi # 0x274a9
callq *%rbx
movq %rax, 0x767b0(%rip) # 0x8b020
leaq 0x12c4b(%rip), %rdi # 0x274c2
callq *%rbx
movq %rax, 0x75a20(%rip) # 0x8a2a0
leaq 0x12c54(%rip), %rdi # 0x274db
callq *%rbx
movq %rax, 0x75798(%rip) # 0x8a028
leaq 0x12c50(%rip), %rdi # 0x274e7
callq *%rbx
movq %rax, 0x75948(%rip) # 0x8a1e8
leaq 0x12c4d(%rip), %rdi # 0x274f4
callq *%rbx
movq %rax, 0x75dc8(%rip) # 0x8a678
leaq 0x12c48(%rip), %rdi # 0x274ff
callq *%rbx
movq %rax, 0x75e80(%rip) # 0x8a740
leaq 0x12c42(%rip), %rdi # 0x27509
callq *%rbx
movq %rax, 0x76640(%rip) # 0x8af10
leaq 0x12c3c(%rip), %rdi # 0x27513
callq *%rbx
movq %rax, 0x75b80(%rip) # 0x8a460
leaq 0x12c37(%rip), %rdi # 0x2751e
callq *%rbx
movq %rax, 0x75bd0(%rip) # 0x8a4c0
leaq 0x12c33(%rip), %rdi # 0x2752a
callq *%rbx
movq %rax, 0x760c0(%rip) # 0x8a9c0
leaq 0x12c31(%rip), %rdi # 0x27538
callq *%rbx
movq %rax, 0x765d0(%rip) # 0x8aee0
leaq 0x12c2c(%rip), %rdi # 0x27543
callq *%rbx
movq %rax, 0x76468(%rip) # 0x8ad88
leaq 0x12c27(%rip), %rdi # 0x2754e
callq *%rbx
movq %rax, 0x75678(%rip) # 0x89fa8
leaq 0x12c1f(%rip), %rdi # 0x27556
callq *%rbx
movq %rax, 0x757a0(%rip) # 0x8a0e0
leaq 0x12c18(%rip), %rdi # 0x2755f
callq *%rbx
movq %rax, 0x75598(%rip) # 0x89ee8
leaq 0x12c12(%rip), %rdi # 0x27569
callq *%rbx
movq %rax, 0x76588(%rip) # 0x8aee8
leaq 0x12c0d(%rip), %rdi # 0x27574
callq *%rbx
movq %rax, 0x75f70(%rip) # 0x8a8e0
leaq 0x12c07(%rip), %rdi # 0x2757e
callq *%rbx
movq %rax, 0x75e78(%rip) # 0x8a7f8
leaq 0x12c02(%rip), %rdi # 0x27589
callq *%rbx
movq %rax, 0x75f20(%rip) # 0x8a8b0
leaq 0x12bfc(%rip), %rdi # 0x27593
callq *%rbx
movq %rax, 0x767e0(%rip) # 0x8b180
leaq 0x12bf7(%rip), %rdi # 0x2759e
callq *%rbx
movq %rax, 0x75568(%rip) # 0x89f18
leaq 0x12bf1(%rip), %rdi # 0x275a8
callq *%rbx
movq %rax, 0x76490(%rip) # 0x8ae50
leaq 0x12bec(%rip), %rdi # 0x275b3
callq *%rbx
movq %rax, 0x75560(%rip) # 0x89f30
leaq 0x12be6(%rip), %rdi # 0x275bd
callq *%rbx
movq %rax, 0x75590(%rip) # 0x89f70
leaq 0x12be1(%rip), %rdi # 0x275c8
callq *%rbx
movq %rax, 0x763a8(%rip) # 0x8ad98
leaq 0x12bdc(%rip), %rdi # 0x275d3
callq *%rbx
movq %rax, 0x755b8(%rip) # 0x89fb8
leaq 0x12bd8(%rip), %rdi # 0x275df
callq *%rbx
movq %rax, 0x763a8(%rip) # 0x8adb8
leaq 0x12bd3(%rip), %rdi # 0x275ea
callq *%rbx
movq %rax, 0x76340(%rip) # 0x8ad60
leaq 0x12bcf(%rip), %rdi # 0x275f6
callq *%rbx
movq %rax, 0x76328(%rip) # 0x8ad58
leaq 0x12bca(%rip), %rdi # 0x27601
callq *%rbx
movq %rax, 0x764e8(%rip) # 0x8af28
leaq 0x12bc6(%rip), %rdi # 0x2760d
callq *%rbx
movq %rax, 0x75b90(%rip) # 0x8a5e0
leaq 0x12bc0(%rip), %rdi # 0x27617
callq *%rbx
movq %rax, 0x75450(%rip) # 0x89eb0
leaq 0x12bbb(%rip), %rdi # 0x27622
callq *%rbx
movq %rax, 0x75b88(%rip) # 0x8a5f8
leaq 0x12bb5(%rip), %rdi # 0x2762c
callq *%rbx
movq %rax, 0x76260(%rip) # 0x8ace0
leaq 0x12bb0(%rip), %rdi # 0x27637
callq *%rbx
movq %rax, 0x75b60(%rip) # 0x8a5f0
leaq 0x12baa(%rip), %rdi # 0x27641
callq *%rbx
movq %rax, 0x756d8(%rip) # 0x8a178
leaq 0x12ba5(%rip), %rdi # 0x2764c
callq *%rbx
movq %rax, 0x75b50(%rip) # 0x8a600
leaq 0x12b9f(%rip), %rdi # 0x27656
callq *%rbx
movq %rax, 0x75f30(%rip) # 0x8a9f0
leaq 0x12b9a(%rip), %rdi # 0x27661
callq *%rbx
movq %rax, 0x75ac8(%rip) # 0x8a598
leaq 0x12b94(%rip), %rdi # 0x2766b
callq *%rbx
movq %rax, 0x76348(%rip) # 0x8ae28
leaq 0x12b8f(%rip), %rdi # 0x27676
callq *%rbx
movq %rax, 0x75c28(%rip) # 0x8a718
leaq 0x12b8a(%rip), %rdi # 0x27681
callq *%rbx
movq %rax, 0x76098(%rip) # 0x8ab98
leaq 0x12b86(%rip), %rdi # 0x2768d
callq *%rbx
movq %rax, 0x752d0(%rip) # 0x89de0
leaq 0x12b81(%rip), %rdi # 0x27698
callq *%rbx
movq %rax, 0x76030(%rip) # 0x8ab50
leaq 0x12b7d(%rip), %rdi # 0x276a4
callq *%rbx
movq %rax, 0x75c18(%rip) # 0x8a748
leaq 0x12b78(%rip), %rdi # 0x276af
callq *%rbx
movq %rax, 0x765b8(%rip) # 0x8b0f8
leaq 0x12b74(%rip), %rdi # 0x276bb
callq *%rbx
movq %rax, 0x753a8(%rip) # 0x89ef8
leaq 0x12b6f(%rip), %rdi # 0x276c6
callq *%rbx
movq %rax, 0x75c18(%rip) # 0x8a778
leaq 0x12b6b(%rip), %rdi # 0x276d2
callq *%rbx
movq %rax, 0x760d0(%rip) # 0x8ac40
leaq 0x12b61(%rip), %rdi # 0x276d8
callq *%rbx
movq %rax, 0x751e8(%rip) # 0x89d68
leaq 0x12b5a(%rip), %rdi # 0x276e1
callq *%rbx
movq %rax, 0x75b00(%rip) # 0x8a690
leaq 0x12b54(%rip), %rdi # 0x276eb
callq *%rbx
movq %rax, 0x751d8(%rip) # 0x89d78
leaq 0x12b4d(%rip), %rdi # 0x276f4
callq *%rbx
movq %rax, 0x75208(%rip) # 0x89db8
leaq 0x12b47(%rip), %rdi # 0x276fe
callq *%rbx
movq %rax, 0x75178(%rip) # 0x89d38
leaq 0x12b40(%rip), %rdi # 0x27707
callq *%rbx
movq %rax, 0x75688(%rip) # 0x8a258
leaq 0x12b3a(%rip), %rdi # 0x27711
callq *%rbx
movq %rax, 0x751b8(%rip) # 0x89d98
leaq 0x12b33(%rip), %rdi # 0x2771a
callq *%rbx
movq %rax, 0x754d0(%rip) # 0x8a0c0
leaq 0x12b2d(%rip), %rdi # 0x27724
callq *%rbx
movq %rax, 0x76528(%rip) # 0x8b128
leaq 0x12b28(%rip), %rdi # 0x2772f
callq *%rbx
movq %rax, 0x75760(%rip) # 0x8a370
leaq 0x12b24(%rip), %rdi # 0x2773b
callq *%rbx
movq %rax, 0x76500(%rip) # 0x8b120
leaq 0x12b1f(%rip), %rdi # 0x27746
callq *%rbx
movq %rax, 0x75e40(%rip) # 0x8aa70
leaq 0x12b1b(%rip), %rdi # 0x27752
callq *%rbx
movq %rax, 0x764d8(%rip) # 0x8b118
leaq 0x12b16(%rip), %rdi # 0x2775d
callq *%rbx
movq %rax, 0x75588(%rip) # 0x8a1d8
leaq 0x12b12(%rip), %rdi # 0x27769
callq *%rbx
movq %rax, 0x764b0(%rip) # 0x8b110
leaq 0x12b0d(%rip), %rdi # 0x27774
callq *%rbx
movq %rax, 0x760b0(%rip) # 0x8ad20
leaq 0x12b09(%rip), %rdi # 0x27780
callq *%rbx
movq %rax, 0x76020(%rip) # 0x8aca0
leaq 0x12b04(%rip), %rdi # 0x2778b
callq *%rbx
movq %rax, 0x75aa8(%rip) # 0x8a738
leaq 0x12b00(%rip), %rdi # 0x27797
callq *%rbx
movq %rax, 0x75220(%rip) # 0x89ec0
leaq 0x12afe(%rip), %rdi # 0x277a5
callq *%rbx
movq %rax, 0x75cb0(%rip) # 0x8a960
leaq 0x12afd(%rip), %rdi # 0x277b4
callq *%rbx
movq %rax, 0x751f8(%rip) # 0x89eb8
leaq 0x12afb(%rip), %rdi # 0x277c2
callq *%rbx
movq %rax, 0x75100(%rip) # 0x89dd0
leaq 0x12afa(%rip), %rdi # 0x277d1
callq *%rbx
movq %rax, 0x751f0(%rip) # 0x89ed0
leaq 0x12af8(%rip), %rdi # 0x277df
callq *%rbx
movq %rax, 0x75ec8(%rip) # 0x8abb8
leaq 0x12af7(%rip), %rdi # 0x277ee
callq *%rbx
movq %rax, 0x75958(%rip) # 0x8a658
leaq 0x12af5(%rip), %rdi # 0x277fc
callq *%rbx
movq %rax, 0x75878(%rip) # 0x8a588
leaq 0x12af4(%rip), %rdi # 0x2780b
callq *%rbx
movq %rax, 0x757d8(%rip) # 0x8a4f8
leaq 0x12af2(%rip), %rdi # 0x27819
callq *%rbx
movq %rax, 0x75e30(%rip) # 0x8ab60
leaq 0x12af1(%rip), %rdi # 0x27828
callq *%rbx
movq %rax, 0x757c0(%rip) # 0x8a500
leaq 0x12aef(%rip), %rdi # 0x27836
callq *%rbx
movq %rax, 0x754c0(%rip) # 0x8a210
leaq 0x12aee(%rip), %rdi # 0x27845
callq *%rbx
movq %rax, 0x75788(%rip) # 0x8a4e8
leaq 0x12aec(%rip), %rdi # 0x27853
callq *%rbx
movq %rax, 0x758a0(%rip) # 0x8a610
leaq 0x12aeb(%rip), %rdi # 0x27862
callq *%rbx
movq %rax, 0x757d8(%rip) # 0x8a558
leaq 0x12ae9(%rip), %rdi # 0x27870
callq *%rbx
movq %rax, 0x754d0(%rip) # 0x8a260
leaq 0x12ae8(%rip), %rdi # 0x2787f
callq *%rbx
movq %rax, 0x75c70(%rip) # 0x8aa10
leaq 0x12ae6(%rip), %rdi # 0x2788d
callq *%rbx
movq %rax, 0x762b0(%rip) # 0x8b060
leaq 0x12ae5(%rip), %rdi # 0x2789c
callq *%rbx
movq %rax, 0x75c58(%rip) # 0x8aa18
leaq 0x12ae3(%rip), %rdi # 0x278aa
callq *%rbx
movq %rax, 0x75930(%rip) # 0x8a700
leaq 0x12ae2(%rip), %rdi # 0x278b9
callq *%rbx
movq %rax, 0x75ea0(%rip) # 0x8ac80
leaq 0x12ae0(%rip), %rdi # 0x278c7
callq *%rbx
movq %rax, 0x75980(%rip) # 0x8a770
leaq 0x12adf(%rip), %rdi # 0x278d6
callq *%rbx
movq %rax, 0x76008(%rip) # 0x8ae08
leaq 0x12add(%rip), %rdi # 0x278e4
callq *%rbx
movq %rax, 0x75780(%rip) # 0x8a590
leaq 0x12adc(%rip), %rdi # 0x278f3
callq *%rbx
movq %rax, 0x75910(%rip) # 0x8a730
leaq 0x12ad4(%rip), %rdi # 0x278fb
callq *%rbx
movq %rax, 0x74f18(%rip) # 0x89d48
leaq 0x12acd(%rip), %rdi # 0x27904
callq *%rbx
movq %rax, 0x758e8(%rip) # 0x8a728
leaq 0x12ac5(%rip), %rdi # 0x2790c
callq *%rbx
movq %rax, 0x75a78(%rip) # 0x8a8c8
leaq 0x12abe(%rip), %rdi # 0x27915
callq *%rbx
movq %rax, 0x758b0(%rip) # 0x8a710
leaq 0x12ab6(%rip), %rdi # 0x2791d
callq *%rbx
movq %rax, 0x75ce8(%rip) # 0x8ab58
leaq 0x12aaf(%rip), %rdi # 0x27926
callq *%rbx
movq %rax, 0x758e0(%rip) # 0x8a760
leaq 0x12aa7(%rip), %rdi # 0x2792e
callq *%rbx
movq %rax, 0x76260(%rip) # 0x8b0f0
leaq 0x12aa0(%rip), %rdi # 0x27937
callq *%rbx
movq %rax, 0x75fd8(%rip) # 0x8ae78
leaq 0x12a9d(%rip), %rdi # 0x27944
callq *%rbx
movq %rax, 0x76128(%rip) # 0x8afd8
leaq 0x12a9b(%rip), %rdi # 0x27952
callq *%rbx
movq %rax, 0x75fc0(%rip) # 0x8ae80
leaq 0x12a98(%rip), %rdi # 0x2795f
callq *%rbx
movq %rax, 0x752b0(%rip) # 0x8a180
leaq 0x12a96(%rip), %rdi # 0x2796d
callq *%rbx
movq %rax, 0x75f88(%rip) # 0x8ae68
leaq 0x12a93(%rip), %rdi # 0x2797a
callq *%rbx
movq %rax, 0x75060(%rip) # 0x89f50
leaq 0x12a91(%rip), %rdi # 0x27988
callq *%rbx
movq %rax, 0x75fc0(%rip) # 0x8aec0
leaq 0x12a8e(%rip), %rdi # 0x27995
callq *%rbx
movq %rax, 0x760a8(%rip) # 0x8afb8
leaq 0x12a8c(%rip), %rdi # 0x279a3
callq *%rbx
movq %rax, 0x75ab8(%rip) # 0x8a9d8
leaq 0x12a89(%rip), %rdi # 0x279b0
callq *%rbx
movq %rax, 0x75838(%rip) # 0x8a768
leaq 0x12a87(%rip), %rdi # 0x279be
callq *%rbx
movq %rax, 0x75aa8(%rip) # 0x8a9e8
leaq 0x12a84(%rip), %rdi # 0x279cb
callq *%rbx
movq %rax, 0x74f20(%rip) # 0x89e70
leaq 0x12a82(%rip), %rdi # 0x279d9
callq *%rbx
movq %rax, 0x75aa8(%rip) # 0x8aa08
leaq 0x12a7f(%rip), %rdi # 0x279e6
callq *%rbx
movq %rax, 0x760f8(%rip) # 0x8b068
leaq 0x12a7d(%rip), %rdi # 0x279f4
callq *%rbx
movq %rax, 0x75aa8(%rip) # 0x8aa28
leaq 0x12a7a(%rip), %rdi # 0x27a01
callq *%rbx
movq %rax, 0x751f8(%rip) # 0x8a188
leaq 0x12a78(%rip), %rdi # 0x27a0f
callq *%rbx
movq %rax, 0x756f8(%rip) # 0x8a698
leaq 0x12a75(%rip), %rdi # 0x27a1c
callq *%rbx
movq %rax, 0x75d60(%rip) # 0x8ad10
leaq 0x12a73(%rip), %rdi # 0x27a2a
callq *%rbx
movq %rax, 0x75550(%rip) # 0x8a510
leaq 0x12a70(%rip), %rdi # 0x27a37
callq *%rbx
movq %rax, 0x751d8(%rip) # 0x8a1a8
leaq 0x12a6e(%rip), %rdi # 0x27a45
callq *%rbx
movq %rax, 0x754f8(%rip) # 0x8a4d8
leaq 0x12a6b(%rip), %rdi # 0x27a52
callq *%rbx
movq %rax, 0x756b0(%rip) # 0x8a6a0
leaq 0x12a69(%rip), %rdi # 0x27a60
callq *%rbx
movq %rax, 0x75548(%rip) # 0x8a548
leaq 0x12a66(%rip), %rdi # 0x27a6d
callq *%rbx
movq %rax, 0x75058(%rip) # 0x8a068
leaq 0x12a64(%rip), %rdi # 0x27a7b
callq *%rbx
movq %rax, 0x750f0(%rip) # 0x8a110
leaq 0x12a61(%rip), %rdi # 0x27a88
callq *%rbx
movq %rax, 0x75a10(%rip) # 0x8aa40
leaq 0x12a5f(%rip), %rdi # 0x27a96
callq *%rbx
movq %rax, 0x750c8(%rip) # 0x8a108
leaq 0x12a5c(%rip), %rdi # 0x27aa3
callq *%rbx
movq %rax, 0x74e38(%rip) # 0x89e88
leaq 0x12a5a(%rip), %rdi # 0x27ab1
callq *%rbx
movq %rax, 0x750b8(%rip) # 0x8a118
leaq 0x12a57(%rip), %rdi # 0x27abe
callq *%rbx
movq %rax, 0x75288(%rip) # 0x8a2f8
leaq 0x12a55(%rip), %rdi # 0x27acc
callq *%rbx
movq %rax, 0x750a8(%rip) # 0x8a128
leaq 0x12a52(%rip), %rdi # 0x27ad9
callq *%rbx
movq %rax, 0x75590(%rip) # 0x8a620
leaq 0x12a50(%rip), %rdi # 0x27ae7
callq *%rbx
movq %rax, 0x75288(%rip) # 0x8a328
leaq 0x12a4b(%rip), %rdi # 0x27af2
callq *%rbx
movq %rax, 0x75568(%rip) # 0x8a618
leaq 0x12a47(%rip), %rdi # 0x27afe
callq *%rbx
movq %rax, 0x75260(%rip) # 0x8a320
leaq 0x12a42(%rip), %rdi # 0x27b09
callq *%rbx
movq %rax, 0x74c60(%rip) # 0x89d30
leaq 0x12a3e(%rip), %rdi # 0x27b15
callq *%rbx
movq %rax, 0x75270(%rip) # 0x8a350
leaq 0x12a39(%rip), %rdi # 0x27b20
callq *%rbx
movq %rax, 0x74e78(%rip) # 0x89f68
leaq 0x12a35(%rip), %rdi # 0x27b2c
callq *%rbx
movq %rax, 0x75268(%rip) # 0x8a368
leaq 0x12a30(%rip), %rdi # 0x27b37
callq *%rbx
movq %rax, 0x75388(%rip) # 0x8a498
leaq 0x12a2c(%rip), %rdi # 0x27b43
callq *%rbx
movq %rax, 0x74de0(%rip) # 0x89f00
leaq 0x12a27(%rip), %rdi # 0x27b4e
callq *%rbx
movq %rax, 0x75020(%rip) # 0x8a150
leaq 0x12a23(%rip), %rdi # 0x27b5a
callq *%rbx
movq %rax, 0x74dc8(%rip) # 0x89f08
leaq 0x12a1e(%rip), %rdi # 0x27b65
callq *%rbx
movq %rax, 0x758e8(%rip) # 0x8aa38
leaq 0x12a1a(%rip), %rdi # 0x27b71
callq *%rbx
movq %rax, 0x74db0(%rip) # 0x89f10
leaq 0x12a15(%rip), %rdi # 0x27b7c
callq *%rbx
movq %rax, 0x74f68(%rip) # 0x8a0d8
leaq 0x12a11(%rip), %rdi # 0x27b88
callq *%rbx
movq %rax, 0x74db8(%rip) # 0x89f38
leaq 0x12a0c(%rip), %rdi # 0x27b93
callq *%rbx
movq %rax, 0x75200(%rip) # 0x8a390
leaq 0x12a08(%rip), %rdi # 0x27b9f
callq *%rbx
movq %rax, 0x75e08(%rip) # 0x8afa8
leaq 0x12a03(%rip), %rdi # 0x27baa
callq *%rbx
movq %rax, 0x75820(%rip) # 0x8a9d0
leaq 0x129ff(%rip), %rdi # 0x27bb6
callq *%rbx
movq %rax, 0x75f28(%rip) # 0x8b0e8
leaq 0x129fa(%rip), %rdi # 0x27bc1
callq *%rbx
movq %rax, 0x74c88(%rip) # 0x89e58
leaq 0x129f6(%rip), %rdi # 0x27bcd
callq *%rbx
movq %rax, 0x758c0(%rip) # 0x8aaa0
leaq 0x129f1(%rip), %rdi # 0x27bd8
callq *%rbx
movq %rax, 0x74c10(%rip) # 0x89e00
leaq 0x129ed(%rip), %rdi # 0x27be4
callq *%rbx
movq %rax, 0x75860(%rip) # 0x8aa60
leaq 0x129e8(%rip), %rdi # 0x27bef
callq *%rbx
movq %rax, 0x74d80(%rip) # 0x89f90
leaq 0x129e4(%rip), %rdi # 0x27bfb
callq *%rbx
movq %rax, 0x75a38(%rip) # 0x8ac58
leaq 0x129e0(%rip), %rdi # 0x27c07
callq *%rbx
movq %rax, 0x755f0(%rip) # 0x8a820
leaq 0x129e0(%rip), %rdi # 0x27c17
callq *%rbx
movq %rax, 0x75c00(%rip) # 0x8ae40
leaq 0x129d7(%rip), %rdi # 0x27c1e
callq *%rbx
movq %rax, 0x74ba0(%rip) # 0x89df0
leaq 0x129cf(%rip), %rdi # 0x27c26
callq *%rbx
movq %rax, 0x74d40(%rip) # 0x89fa0
leaq 0x129c6(%rip), %rdi # 0x27c2d
callq *%rbx
movq %rax, 0x74b50(%rip) # 0x89dc0
leaq 0x129be(%rip), %rdi # 0x27c35
callq *%rbx
movq %rax, 0x75030(%rip) # 0x8a2b0
leaq 0x129b7(%rip), %rdi # 0x27c3e
callq *%rbx
movq %rax, 0x74d68(%rip) # 0x89ff8
leaq 0x129b1(%rip), %rdi # 0x27c48
callq *%rbx
movq %rax, 0x75008(%rip) # 0x8a2a8
leaq 0x129aa(%rip), %rdi # 0x27c51
callq *%rbx
movq %rax, 0x75978(%rip) # 0x8ac28
leaq 0x129a4(%rip), %rdi # 0x27c5b
callq *%rbx
movq %rax, 0x751c8(%rip) # 0x8a488
leaq 0x129a2(%rip), %rdi # 0x27c69
callq *%rbx
movq %rax, 0x756e8(%rip) # 0x8a9b8
leaq 0x129a1(%rip), %rdi # 0x27c78
callq *%rbx
movq %rax, 0x751c0(%rip) # 0x8a4a0
leaq 0x1299f(%rip), %rdi # 0x27c86
callq *%rbx
movq %rax, 0x74ae8(%rip) # 0x89dd8
leaq 0x1299e(%rip), %rdi # 0x27c95
callq *%rbx
movq %rax, 0x752a8(%rip) # 0x8a5a8
leaq 0x1299c(%rip), %rdi # 0x27ca3
callq *%rbx
movq %rax, 0x74e10(%rip) # 0x8a120
leaq 0x12998(%rip), %rdi # 0x27caf
callq *%rbx
movq %rax, 0x75350(%rip) # 0x8a670
leaq 0x12995(%rip), %rdi # 0x27cbc
callq *%rbx
movq %rax, 0x74db8(%rip) # 0x8a0e8
leaq 0x12991(%rip), %rdi # 0x27cc8
callq *%rbx
movq %rax, 0x75708(%rip) # 0x8aa48
leaq 0x1298e(%rip), %rdi # 0x27cd5
callq *%rbx
movq %rax, 0x75db0(%rip) # 0x8b100
leaq 0x1298f(%rip), %rdi # 0x27ce6
callq *%rbx
movq %rax, 0x75778(%rip) # 0x8aad8
leaq 0x1298c(%rip), %rdi # 0x27cf3
callq *%rbx
movq %rax, 0x75038(%rip) # 0x8a3a8
leaq 0x12986(%rip), %rdi # 0x27cfd
callq *%rbx
movq %rax, 0x75608(%rip) # 0x8a988
leaq 0x12981(%rip), %rdi # 0x27d08
callq *%rbx
movq %rax, 0x75048(%rip) # 0x8a3d8
leaq 0x1297b(%rip), %rdi # 0x27d12
callq *%rbx
movq %rax, 0x75828(%rip) # 0x8abc8
leaq 0x12976(%rip), %rdi # 0x27d1d
callq *%rbx
movq %rax, 0x75538(%rip) # 0x8a8e8
leaq 0x12970(%rip), %rdi # 0x27d27
callq *%rbx
movq %rax, 0x758a8(%rip) # 0x8ac68
leaq 0x1296b(%rip), %rdi # 0x27d32
callq *%rbx
movq %rax, 0x74de8(%rip) # 0x8a1b8
leaq 0x12965(%rip), %rdi # 0x27d3c
callq *%rbx
movq %rax, 0x75858(%rip) # 0x8ac38
leaq 0x12960(%rip), %rdi # 0x27d47
callq *%rbx
movq %rax, 0x75500(%rip) # 0x8a8f0
leaq 0x1295a(%rip), %rdi # 0x27d51
callq *%rbx
movq %rax, 0x75558(%rip) # 0x8a958
leaq 0x12955(%rip), %rdi # 0x27d5c
callq *%rbx
movq %rax, 0x75010(%rip) # 0x8a420
leaq 0x12956(%rip), %rdi # 0x27d6d
callq *%rbx
movq %rax, 0x757c8(%rip) # 0x8abe8
leaq 0x12955(%rip), %rdi # 0x27d7c
callq *%rbx
movq %rax, 0x75410(%rip) # 0x8a840
leaq 0x12952(%rip), %rdi # 0x27d89
callq *%rbx
movq %rax, 0x753a8(%rip) # 0x8a7e8
leaq 0x1294e(%rip), %rdi # 0x27d95
callq *%rbx
movq %rax, 0x75668(%rip) # 0x8aab8
leaq 0x12949(%rip), %rdi # 0x27da0
callq *%rbx
movq %rax, 0x74b38(%rip) # 0x89f98
leaq 0x12947(%rip), %rdi # 0x27dae
callq *%rbx
movq %rax, 0x75270(%rip) # 0x8a6e0
leaq 0x12941(%rip), %rdi # 0x27db8
callq *%rbx
movq %rax, 0x757e0(%rip) # 0x8ac60
leaq 0x1293c(%rip), %rdi # 0x27dc3
callq *%rbx
movq %rax, 0x75ad8(%rip) # 0x8af68
leaq 0x12939(%rip), %rdi # 0x27dd0
callq *%rbx
movq %rax, 0x74d90(%rip) # 0x8a230
leaq 0x12936(%rip), %rdi # 0x27ddd
callq *%rbx
movq %rax, 0x75a90(%rip) # 0x8af40
leaq 0x12932(%rip), %rdi # 0x27de9
callq *%rbx
movq %rax, 0x75b88(%rip) # 0x8b048
leaq 0x1292a(%rip), %rdi # 0x27df1
callq *%rbx
movq %rax, 0x752e8(%rip) # 0x8a7b8
leaq 0x12926(%rip), %rdi # 0x27dfd
callq *%rbx
movq %rax, 0x75718(%rip) # 0x8abf8
leaq 0x12923(%rip), %rdi # 0x27e0a
callq *%rbx
movq %rax, 0x74d48(%rip) # 0x8a238
leaq 0x1291b(%rip), %rdi # 0x27e12
callq *%rbx
movq %rax, 0x74d40(%rip) # 0x8a240
leaq 0x12913(%rip), %rdi # 0x27e1a
callq *%rbx
movq %rax, 0x75a88(%rip) # 0x8af98
leaq 0x1290b(%rip), %rdi # 0x27e22
callq *%rbx
movq %rax, 0x75a80(%rip) # 0x8afa0
leaq 0x12903(%rip), %rdi # 0x27e2a
callq *%rbx
movq %rax, 0x755b0(%rip) # 0x8aae0
leaq 0x128ff(%rip), %rdi # 0x27e36
callq *%rbx
movq %rax, 0x755b0(%rip) # 0x8aaf0
leaq 0x128fb(%rip), %rdi # 0x27e42
callq *%rbx
movq %rax, 0x74df0(%rip) # 0x8a340
leaq 0x128f7(%rip), %rdi # 0x27e4e
callq *%rbx
movq %rax, 0x74de8(%rip) # 0x8a348
leaq 0x128f3(%rip), %rdi # 0x27e5a
callq *%rbx
movq %rax, 0x75aa8(%rip) # 0x8b018
leaq 0x128f1(%rip), %rdi # 0x27e68
callq *%rbx
movq %rax, 0x75188(%rip) # 0x8a708
leaq 0x128f0(%rip), %rdi # 0x27e77
callq *%rbx
movq %rax, 0x75a98(%rip) # 0x8b028
leaq 0x128ee(%rip), %rdi # 0x27e85
callq *%rbx
movq %rax, 0x74868(%rip) # 0x89e08
leaq 0x128ed(%rip), %rdi # 0x27e94
callq *%rbx
movq %rax, 0x747a8(%rip) # 0x89d58
leaq 0x128eb(%rip), %rdi # 0x27ea2
callq *%rbx
movq %rax, 0x749f0(%rip) # 0x89fb0
leaq 0x128ea(%rip), %rdi # 0x27eb1
callq *%rbx
movq %rax, 0x74790(%rip) # 0x89d60
leaq 0x128e8(%rip), %rdi # 0x27ebf
callq *%rbx
movq %rax, 0x755b0(%rip) # 0x8ab90
leaq 0x128e7(%rip), %rdi # 0x27ece
callq *%rbx
movq %rax, 0x75580(%rip) # 0x8ab70
leaq 0x128e3(%rip), %rdi # 0x27eda
callq *%rbx
movq %rax, 0x759c8(%rip) # 0x8afc8
leaq 0x128e0(%rip), %rdi # 0x27ee7
callq *%rbx
movq %rax, 0x75558(%rip) # 0x8ab68
leaq 0x128dc(%rip), %rdi # 0x27ef3
callq *%rbx
movq %rax, 0x75270(%rip) # 0x8a890
leaq 0x128d9(%rip), %rdi # 0x27f00
callq *%rbx
movq %rax, 0x754e8(%rip) # 0x8ab18
leaq 0x128d5(%rip), %rdi # 0x27f0c
callq *%rbx
movq %rax, 0x74c30(%rip) # 0x8a270
leaq 0x128d1(%rip), %rdi # 0x27f18
callq *%rbx
movq %rax, 0x75248(%rip) # 0x8a898
leaq 0x128d2(%rip), %rdi # 0x27f29
callq *%rbx
movq %rax, 0x75210(%rip) # 0x8a870
leaq 0x128d3(%rip), %rdi # 0x27f3a
callq *%rbx
movq %rax, 0x759c0(%rip) # 0x8b030
leaq 0x128d0(%rip), %rdi # 0x27f47
callq *%rbx
movq %rax, 0x74a28(%rip) # 0x8a0a8
leaq 0x128ce(%rip), %rdi # 0x27f55
callq *%rbx
movq %rax, 0x75aa0(%rip) # 0x8b130
leaq 0x128cc(%rip), %rdi # 0x27f63
callq *%rbx
movq %rax, 0x75108(%rip) # 0x8a7a8
leaq 0x128c9(%rip), %rdi # 0x27f70
callq *%rbx
movq %rax, 0x759e8(%rip) # 0x8b098
leaq 0x128c6(%rip), %rdi # 0x27f7d
callq *%rbx
movq %rax, 0x75308(%rip) # 0x8a9c8
leaq 0x128c5(%rip), %rdi # 0x27f8c
callq *%rbx
movq %rax, 0x75208(%rip) # 0x8a8d8
leaq 0x128c2(%rip), %rdi # 0x27f99
callq *%rbx
movq %rax, 0x75690(%rip) # 0x8ad70
leaq 0x128bf(%rip), %rdi # 0x27fa6
callq *%rbx
movq %rax, 0x74f70(%rip) # 0x8a660
leaq 0x128ba(%rip), %rdi # 0x27fb1
callq *%rbx
movq %rax, 0x74690(%rip) # 0x89d90
leaq 0x128b5(%rip), %rdi # 0x27fbc
callq *%rbx
movq %rax, 0x74d18(%rip) # 0x8a428
leaq 0x128b0(%rip), %rdi # 0x27fc7
callq *%rbx
movq %rax, 0x74970(%rip) # 0x8a090
leaq 0x128b0(%rip), %rdi # 0x27fd7
callq *%rbx
movq %rax, 0x75988(%rip) # 0x8b0b8
leaq 0x128b0(%rip), %rdi # 0x27fe7
callq *%rbx
movq %rax, 0x74c60(%rip) # 0x8a3a0
leaq 0x128b0(%rip), %rdi # 0x27ff7
callq *%rbx
movq %rax, 0x74b98(%rip) # 0x8a2e8
leaq 0x128b1(%rip), %rdi # 0x28008
callq *%rbx
movq %rax, 0x758d8(%rip) # 0x8b038
leaq 0x128b2(%rip), %rdi # 0x28019
callq *%rbx
movq %rax, 0x75658(%rip) # 0x8adc8
leaq 0x128b6(%rip), %rdi # 0x2802d
callq *%rbx
movq %rax, 0x75140(%rip) # 0x8a8c0
leaq 0x128b4(%rip), %rdi # 0x2803b
callq *%rbx
movq %rax, 0x75858(%rip) # 0x8afe8
leaq 0x128b2(%rip), %rdi # 0x28049
callq *%rbx
movq %rax, 0x75760(%rip) # 0x8af00
leaq 0x128b0(%rip), %rdi # 0x28057
callq *%rbx
movq %rax, 0x75188(%rip) # 0x8a938
leaq 0x128ae(%rip), %rdi # 0x28065
callq *%rbx
movq %rax, 0x75978(%rip) # 0x8b138
leaq 0x128ac(%rip), %rdi # 0x28073
callq *%rbx
movq %rax, 0x74db0(%rip) # 0x8a580
leaq 0x128a5(%rip), %rdi # 0x2807c
callq *%rbx
movq %rax, 0x74a10(%rip) # 0x8a1f0
leaq 0x1289f(%rip), %rdi # 0x28086
callq *%rbx
movq %rax, 0x746d8(%rip) # 0x89ec8
leaq 0x1289e(%rip), %rdi # 0x28095
callq *%rbx
movq %rax, 0x758c8(%rip) # 0x8b0c8
leaq 0x1289c(%rip), %rdi # 0x280a3
callq *%rbx
movq %rax, 0x758c0(%rip) # 0x8b0d0
leaq 0x1289a(%rip), %rdi # 0x280b1
callq *%rbx
movq %rax, 0x74bf8(%rip) # 0x8a418
leaq 0x12897(%rip), %rdi # 0x280be
callq *%rbx
movq %rax, 0x75878(%rip) # 0x8b0a8
leaq 0x12895(%rip), %rdi # 0x280cc
callq *%rbx
movq %rax, 0x75860(%rip) # 0x8b0a0
leaq 0x12893(%rip), %rdi # 0x280da
callq *%rbx
movq %rax, 0x749c8(%rip) # 0x8a218
leaq 0x1288b(%rip), %rdi # 0x280e2
callq *%rbx
movq %rax, 0x75180(%rip) # 0x8a9e0
leaq 0x12887(%rip), %rdi # 0x280ee
callq *%rbx
movq %rax, 0x74998(%rip) # 0x8a208
leaq 0x12884(%rip), %rdi # 0x280fb
callq *%rbx
movq %rax, 0x75210(%rip) # 0x8aa90
leaq 0x1287e(%rip), %rdi # 0x28105
callq *%rbx
movq %rax, 0x75208(%rip) # 0x8aa98
leaq 0x12878(%rip), %rdi # 0x2810f
callq *%rbx
movq %rax, 0x74ef8(%rip) # 0x8a798
leaq 0x12871(%rip), %rdi # 0x28118
callq *%rbx
movq %rax, 0x74ed8(%rip) # 0x8a788
leaq 0x1286a(%rip), %rdi # 0x28121
callq *%rbx
movq %rax, 0x747a0(%rip) # 0x8a060
leaq 0x12867(%rip), %rdi # 0x2812e
callq *%rbx
movq %rax, 0x74780(%rip) # 0x8a050
cmpl $0x0, 0x743fd(%rip) # 0x89cd4
je 0x15abd
leaq 0x12857(%rip), %rdi # 0x2813b
callq *%rbx
movq %rax, 0x746eb(%rip) # 0x89fd8
leaq 0x12854(%rip), %rdi # 0x28148
callq *%rbx
movq %rax, 0x74d53(%rip) # 0x8a650
leaq 0x12853(%rip), %rdi # 0x28157
callq *%rbx
movq %rax, 0x748b3(%rip) # 0x8a1c0
leaq 0x12851(%rip), %rdi # 0x28165
callq *%rbx
movq %rax, 0x748ab(%rip) # 0x8a1c8
leaq 0x12851(%rip), %rdi # 0x28175
callq *%rbx
movq %rax, 0x743d3(%rip) # 0x89d00
leaq 0x12852(%rip), %rdi # 0x28186
callq *%rbx
movq %rax, 0x74a93(%rip) # 0x8a3d0
leaq 0x12853(%rip), %rdi # 0x28197
callq *%rbx
movq %rax, 0x75513(%rip) # 0x8ae60
leaq 0x12857(%rip), %rdi # 0x281ab
callq *%rbx
movq %rax, 0x744db(%rip) # 0x89e38
leaq 0x1285b(%rip), %rdi # 0x281bf
callq *%rbx
movq %rax, 0x75693(%rip) # 0x8b000
leaq 0x1285b(%rip), %rdi # 0x281cf
callq *%rbx
movq %rax, 0x74efb(%rip) # 0x8a878
leaq 0x1285b(%rip), %rdi # 0x281df
callq *%rbx
movq %rax, 0x744d3(%rip) # 0x89e60
leaq 0x12859(%rip), %rdi # 0x281ed
callq *%rbx
movq %rax, 0x74e23(%rip) # 0x8a7c0
leaq 0x1285a(%rip), %rdi # 0x281fe
callq *%rbx
movq %rax, 0x74943(%rip) # 0x8a2f0
leaq 0x12858(%rip), %rdi # 0x2820c
callq *%rbx
movq %rax, 0x756f3(%rip) # 0x8b0b0
leaq 0x12854(%rip), %rdi # 0x28218
callq *%rbx
movq %rax, 0x75773(%rip) # 0x8b140
leaq 0x12853(%rip), %rdi # 0x28227
callq *%rbx
movq %rax, 0x757cb(%rip) # 0x8b1a8
leaq 0x12852(%rip), %rdi # 0x28236
callq *%rbx
movq %rax, 0x7510b(%rip) # 0x8aaf8
leaq 0x12857(%rip), %rdi # 0x2824b
callq *%rbx
movq %rax, 0x74da3(%rip) # 0x8a7a0
leaq 0x12859(%rip), %rdi # 0x2825d
callq *%rbx
movq %rax, 0x75483(%rip) # 0x8ae90
leaq 0x1285d(%rip), %rdi # 0x28271
callq *%rbx
movq %rax, 0x748eb(%rip) # 0x8a308
leaq 0x1285c(%rip), %rdi # 0x28280
callq *%rbx
movq %rax, 0x756db(%rip) # 0x8b108
leaq 0x12860(%rip), %rdi # 0x28294
callq *%rbx
movq %rax, 0x7454b(%rip) # 0x89f88
leaq 0x12860(%rip), %rdi # 0x282a4
callq *%rbx
movq %rax, 0x7512b(%rip) # 0x8ab78
leaq 0x12862(%rip), %rdi # 0x282b6
callq *%rbx
movq %rax, 0x74563(%rip) # 0x89fc0
leaq 0x12862(%rip), %rdi # 0x282c6
callq *%rbx
movq %rax, 0x74b0b(%rip) # 0x8a578
leaq 0x12868(%rip), %rdi # 0x282dc
callq *%rbx
movq %rax, 0x749db(%rip) # 0x8a458
leaq 0x1286d(%rip), %rdi # 0x282f1
callq *%rbx
movq %rax, 0x751e3(%rip) # 0x8ac70
leaq 0x12867(%rip), %rdi # 0x282fb
callq *%rbx
movq %rax, 0x74f5b(%rip) # 0x8a9f8
leaq 0x12862(%rip), %rdi # 0x28306
callq *%rbx
movq %rax, 0x75383(%rip) # 0x8ae30
leaq 0x12864(%rip), %rdi # 0x28318
callq *%rbx
movq %rax, 0x7548b(%rip) # 0x8af48
cmpl $0x0, 0x74214(%rip) # 0x89cd8
je 0x15b06
leaq 0x1285e(%rip), %rdi # 0x2832b
callq *%rbx
movq %rax, 0x753e2(%rip) # 0x8aeb8
leaq 0x12862(%rip), %rdi # 0x2833f
callq *%rbx
movq %rax, 0x75132(%rip) # 0x8ac18
leaq 0x1285f(%rip), %rdi # 0x2834c
callq *%rbx
movq %rax, 0x748ba(%rip) # 0x8a3b0
leaq 0x1285f(%rip), %rdi # 0x2835c
callq *%rbx
movq %rax, 0x74a1a(%rip) # 0x8a520
cmpl $0x0, 0x741cf(%rip) # 0x89cdc
je 0x15df3
leaq 0x12856(%rip), %rdi # 0x28370
callq *%rbx
movq %rax, 0x74f5d(%rip) # 0x8aa80
leaq 0x12856(%rip), %rdi # 0x28380
callq *%rbx
movq %rax, 0x74cf5(%rip) # 0x8a828
leaq 0x12857(%rip), %rdi # 0x28391
callq *%rbx
movq %rax, 0x749c5(%rip) # 0x8a508
leaq 0x1285e(%rip), %rdi # 0x283a8
callq *%rbx
movq %rax, 0x742ed(%rip) # 0x89e40
leaq 0x12865(%rip), %rdi # 0x283bf
callq *%rbx
movq %rax, 0x752f5(%rip) # 0x8ae58
leaq 0x1286c(%rip), %rdi # 0x283d6
callq *%rbx
movq %rax, 0x741dd(%rip) # 0x89d50
leaq 0x12876(%rip), %rdi # 0x283f0
callq *%rbx
movq %rax, 0x751fd(%rip) # 0x8ad80
leaq 0x12880(%rip), %rdi # 0x2840a
callq *%rbx
movq %rax, 0x74a9d(%rip) # 0x8a630
leaq 0x1288a(%rip), %rdi # 0x28424
callq *%rbx
movq %rax, 0x74ca5(%rip) # 0x8a848
leaq 0x12892(%rip), %rdi # 0x2843c
callq *%rbx
movq %rax, 0x74dbd(%rip) # 0x8a970
leaq 0x12898(%rip), %rdi # 0x28452
callq *%rbx
movq %rax, 0x74425(%rip) # 0x89fe8
leaq 0x1289a(%rip), %rdi # 0x28464
callq *%rbx
movq %rax, 0x745c5(%rip) # 0x8a198
leaq 0x1289d(%rip), %rdi # 0x28477
callq *%rbx
movq %rax, 0x7440d(%rip) # 0x89ff0
leaq 0x1289f(%rip), %rdi # 0x28489
callq *%rbx
movq %rax, 0x74f4d(%rip) # 0x8ab40
leaq 0x128a2(%rip), %rdi # 0x2849c
callq *%rbx
movq %rax, 0x7440d(%rip) # 0x8a010
leaq 0x128a4(%rip), %rdi # 0x284ae
callq *%rbx
movq %rax, 0x747cd(%rip) # 0x8a3e0
leaq 0x128a7(%rip), %rdi # 0x284c1
callq *%rbx
movq %rax, 0x743fd(%rip) # 0x8a020
leaq 0x128a9(%rip), %rdi # 0x284d3
callq *%rbx
movq %rax, 0x7497d(%rip) # 0x8a5b0
leaq 0x128ac(%rip), %rdi # 0x284e6
callq *%rbx
movq %rax, 0x747fd(%rip) # 0x8a440
leaq 0x128ae(%rip), %rdi # 0x284f8
callq *%rbx
movq %rax, 0x747a5(%rip) # 0x8a3f8
leaq 0x128b1(%rip), %rdi # 0x2850b
callq *%rbx
movq %rax, 0x747e5(%rip) # 0x8a448
leaq 0x128b3(%rip), %rdi # 0x2851d
callq *%rbx
movq %rax, 0x75395(%rip) # 0x8b008
leaq 0x128b6(%rip), %rdi # 0x28530
callq *%rbx
movq %rax, 0x7451d(%rip) # 0x8a1a0
leaq 0x128b8(%rip), %rdi # 0x28542
callq *%rbx
movq %rax, 0x74935(%rip) # 0x8a5c8
leaq 0x128bb(%rip), %rdi # 0x28555
callq *%rbx
movq %rax, 0x7449d(%rip) # 0x8a140
leaq 0x128bd(%rip), %rdi # 0x28567
callq *%rbx
movq %rax, 0x751f5(%rip) # 0x8aea8
leaq 0x128c0(%rip), %rdi # 0x2857a
callq *%rbx
movq %rax, 0x74c55(%rip) # 0x8a918
leaq 0x128c2(%rip), %rdi # 0x2858c
callq *%rbx
movq %rax, 0x7514d(%rip) # 0x8ae20
leaq 0x128c5(%rip), %rdi # 0x2859f
callq *%rbx
movq %rax, 0x74c2d(%rip) # 0x8a910
leaq 0x128c7(%rip), %rdi # 0x285b1
callq *%rbx
movq %rax, 0x745ed(%rip) # 0x8a2e0
leaq 0x128ca(%rip), %rdi # 0x285c4
callq *%rbx
movq %rax, 0x74c05(%rip) # 0x8a908
leaq 0x128cc(%rip), %rdi # 0x285d6
callq *%rbx
movq %rax, 0x74765(%rip) # 0x8a478
leaq 0x128cf(%rip), %rdi # 0x285e9
callq *%rbx
movq %rax, 0x74bd5(%rip) # 0x8a8f8
leaq 0x128d1(%rip), %rdi # 0x285fb
callq *%rbx
movq %rax, 0x74dcd(%rip) # 0x8ab00
leaq 0x128d4(%rip), %rdi # 0x2860e
callq *%rbx
movq %rax, 0x7505d(%rip) # 0x8ada0
leaq 0x128d6(%rip), %rdi # 0x28620
callq *%rbx
movq %rax, 0x7508d(%rip) # 0x8ade0
leaq 0x128d9(%rip), %rdi # 0x28633
callq *%rbx
movq %rax, 0x7502d(%rip) # 0x8ad90
leaq 0x128db(%rip), %rdi # 0x28645
callq *%rbx
movq %rax, 0x7476d(%rip) # 0x8a4e0
leaq 0x128de(%rip), %rdi # 0x28658
callq *%rbx
movq %rax, 0x7503d(%rip) # 0x8adc0
leaq 0x128e0(%rip), %rdi # 0x2866a
callq *%rbx
movq %rax, 0x74d95(%rip) # 0x8ab28
leaq 0x128e3(%rip), %rdi # 0x2867d
callq *%rbx
movq %rax, 0x74fa5(%rip) # 0x8ad48
leaq 0x128e5(%rip), %rdi # 0x2868f
callq *%rbx
movq %rax, 0x74445(%rip) # 0x8a1f8
leaq 0x128e8(%rip), %rdi # 0x286a2
callq *%rbx
movq %rax, 0x74de5(%rip) # 0x8aba8
leaq 0x128ef(%rip), %rdi # 0x286b9
callq *%rbx
movq %rax, 0x74dcd(%rip) # 0x8aba0
leaq 0x128f6(%rip), %rdi # 0x286d0
callq *%rbx
movq %rax, 0x7493d(%rip) # 0x8a720
leaq 0x128fd(%rip), %rdi # 0x286e7
callq *%rbx
movq %rax, 0x74e95(%rip) # 0x8ac88
cmpl $0x0, 0x73ee6(%rip) # 0x89ce0
je 0x160f0
leaq 0x128f7(%rip), %rdi # 0x286fe
callq *%rbx
movq %rax, 0x74040(%rip) # 0x89e50
leaq 0x128fb(%rip), %rdi # 0x28712
callq *%rbx
movq %rax, 0x750e8(%rip) # 0x8af08
leaq 0x128fd(%rip), %rdi # 0x28724
callq *%rbx
movq %rax, 0x74708(%rip) # 0x8a538
leaq 0x12901(%rip), %rdi # 0x28738
callq *%rbx
movq %rax, 0x74ef0(%rip) # 0x8ad30
leaq 0x12903(%rip), %rdi # 0x2874a
callq *%rbx
movq %rax, 0x74ea0(%rip) # 0x8acf0
leaq 0x12906(%rip), %rdi # 0x2875d
callq *%rbx
movq %rax, 0x74e58(%rip) # 0x8acb8
leaq 0x12908(%rip), %rdi # 0x2876f
callq *%rbx
movq %rax, 0x742f0(%rip) # 0x8a160
leaq 0x1290b(%rip), %rdi # 0x28782
callq *%rbx
movq %rax, 0x74548(%rip) # 0x8a3c8
leaq 0x12907(%rip), %rdi # 0x2878e
callq *%rbx
movq %rax, 0x74210(%rip) # 0x8a0a0
leaq 0x12904(%rip), %rdi # 0x2879b
callq *%rbx
movq %rax, 0x74520(%rip) # 0x8a3c0
leaq 0x12900(%rip), %rdi # 0x287a7
callq *%rbx
movq %rax, 0x74a78(%rip) # 0x8a928
leaq 0x128fd(%rip), %rdi # 0x287b4
callq *%rbx
movq %rax, 0x74a80(%rip) # 0x8a940
leaq 0x128ff(%rip), %rdi # 0x287c6
callq *%rbx
movq %rax, 0x74620(%rip) # 0x8a4f0
leaq 0x12902(%rip), %rdi # 0x287d9
callq *%rbx
movq %rax, 0x741a8(%rip) # 0x8a088
leaq 0x12906(%rip), %rdi # 0x287ed
callq *%rbx
movq %rax, 0x745e0(%rip) # 0x8a4d0
leaq 0x12909(%rip), %rdi # 0x28800
callq *%rbx
movq %rax, 0x74a68(%rip) # 0x8a968
leaq 0x1290d(%rip), %rdi # 0x28814
callq *%rbx
movq %rax, 0x746d8(%rip) # 0x8a5e8
leaq 0x12910(%rip), %rdi # 0x28827
callq *%rbx
movq %rax, 0x73ec8(%rip) # 0x89de8
leaq 0x12914(%rip), %rdi # 0x2883b
callq *%rbx
movq %rax, 0x74970(%rip) # 0x8a8a0
leaq 0x12917(%rip), %rdi # 0x2884e
callq *%rbx
movq %rax, 0x74d38(%rip) # 0x8ac78
leaq 0x1291b(%rip), %rdi # 0x28862
callq *%rbx
movq %rax, 0x74290(%rip) # 0x8a1e0
leaq 0x1291e(%rip), %rdi # 0x28875
callq *%rbx
movq %rax, 0x74428(%rip) # 0x8a388
leaq 0x12922(%rip), %rdi # 0x28889
callq *%rbx
movq %rax, 0x74d90(%rip) # 0x8ad00
leaq 0x12926(%rip), %rdi # 0x2889d
callq *%rbx
movq %rax, 0x744e8(%rip) # 0x8a468
leaq 0x1292b(%rip), %rdi # 0x288b2
callq *%rbx
movq %rax, 0x74d78(%rip) # 0x8ad08
leaq 0x1292f(%rip), %rdi # 0x288c6
callq *%rbx
movq %rax, 0x74028(%rip) # 0x89fc8
leaq 0x12934(%rip), %rdi # 0x288db
callq *%rbx
movq %rax, 0x749d0(%rip) # 0x8a980
leaq 0x12938(%rip), %rdi # 0x288ef
callq *%rbx
movq %rax, 0x741f0(%rip) # 0x8a1b0
leaq 0x1293d(%rip), %rdi # 0x28904
callq *%rbx
movq %rax, 0x74b40(%rip) # 0x8ab10
leaq 0x12945(%rip), %rdi # 0x2891c
callq *%rbx
movq %rax, 0x73d48(%rip) # 0x89d28
leaq 0x12943(%rip), %rdi # 0x2892a
callq *%rbx
movq %rax, 0x74860(%rip) # 0x8a850
leaq 0x12942(%rip), %rdi # 0x28939
callq *%rbx
movq %rax, 0x73d20(%rip) # 0x89d20
leaq 0x12940(%rip), %rdi # 0x28947
callq *%rbx
movq %rax, 0x74f20(%rip) # 0x8af30
leaq 0x1293f(%rip), %rdi # 0x28956
callq *%rbx
movq %rax, 0x73cf8(%rip) # 0x89d18
leaq 0x1293d(%rip), %rdi # 0x28964
callq *%rbx
movq %rax, 0x73d80(%rip) # 0x89db0
leaq 0x1293c(%rip), %rdi # 0x28973
callq *%rbx
movq %rax, 0x73cd0(%rip) # 0x89d10
leaq 0x1293a(%rip), %rdi # 0x28981
callq *%rbx
movq %rax, 0x73dc0(%rip) # 0x89e10
leaq 0x12939(%rip), %rdi # 0x28990
callq *%rbx
movq %rax, 0x74c68(%rip) # 0x8acc8
leaq 0x12937(%rip), %rdi # 0x2899e
callq *%rbx
movq %rax, 0x75010(%rip) # 0x8b080
leaq 0x12936(%rip), %rdi # 0x289ad
callq *%rbx
movq %rax, 0x74cd0(%rip) # 0x8ad50
leaq 0x12934(%rip), %rdi # 0x289bb
callq *%rbx
movq %rax, 0x74920(%rip) # 0x8a9b0
leaq 0x12933(%rip), %rdi # 0x289ca
callq *%rbx
movq %rax, 0x74ca0(%rip) # 0x8ad40
leaq 0x12931(%rip), %rdi # 0x289d8
callq *%rbx
movq %rax, 0x743f8(%rip) # 0x8a4a8
leaq 0x12930(%rip), %rdi # 0x289e7
callq *%rbx
movq %rax, 0x74c68(%rip) # 0x8ad28
leaq 0x1292e(%rip), %rdi # 0x289f5
callq *%rbx
movq %rax, 0x74158(%rip) # 0x8a228
leaq 0x1292d(%rip), %rdi # 0x28a04
callq *%rbx
movq %rax, 0x74be0(%rip) # 0x8acc0
leaq 0x1292a(%rip), %rdi # 0x28a11
callq *%rbx
movq %rax, 0x74d08(%rip) # 0x8adf8
cmpl $0x0, 0x73bed(%rip) # 0x89ce4
je 0x1622d
leaq 0x1291d(%rip), %rdi # 0x28a21
callq *%rbx
movq %rax, 0x7428b(%rip) # 0x8a398
leaq 0x1291a(%rip), %rdi # 0x28a2e
callq *%rbx
movq %rax, 0x746b3(%rip) # 0x8a7d0
leaq 0x1291a(%rip), %rdi # 0x28a3e
callq *%rbx
movq %rax, 0x74f43(%rip) # 0x8b070
leaq 0x12914(%rip), %rdi # 0x28a48
callq *%rbx
movq %rax, 0x74e43(%rip) # 0x8af80
leaq 0x12911(%rip), %rdi # 0x28a55
callq *%rbx
movq %rax, 0x74643(%rip) # 0x8a790
leaq 0x1290c(%rip), %rdi # 0x28a60
callq *%rbx
movq %rax, 0x73fa3(%rip) # 0x8a100
leaq 0x12909(%rip), %rdi # 0x28a6d
callq *%rbx
movq %rax, 0x749c3(%rip) # 0x8ab30
leaq 0x1290c(%rip), %rdi # 0x28a80
callq *%rbx
movq %rax, 0x73ebb(%rip) # 0x8a038
leaq 0x12910(%rip), %rdi # 0x28a94
callq *%rbx
movq %rax, 0x74e03(%rip) # 0x8af90
leaq 0x1290d(%rip), %rdi # 0x28aa1
callq *%rbx
movq %rax, 0x74aab(%rip) # 0x8ac48
leaq 0x1290d(%rip), %rdi # 0x28ab1
callq *%rbx
movq %rax, 0x74a33(%rip) # 0x8abe0
leaq 0x1290a(%rip), %rdi # 0x28abe
callq *%rbx
movq %rax, 0x73c63(%rip) # 0x89e20
leaq 0x12905(%rip), %rdi # 0x28ac9
callq *%rbx
movq %rax, 0x74df3(%rip) # 0x8afc0
leaq 0x12902(%rip), %rdi # 0x28ad6
callq *%rbx
movq %rax, 0x74cf3(%rip) # 0x8aed0
leaq 0x12902(%rip), %rdi # 0x28ae6
callq *%rbx
movq %rax, 0x749d3(%rip) # 0x8abc0
leaq 0x12905(%rip), %rdi # 0x28af9
callq *%rbx
movq %rax, 0x742cb(%rip) # 0x8a4c8
leaq 0x12901(%rip), %rdi # 0x28b05
callq *%rbx
movq %rax, 0x747f3(%rip) # 0x8aa00
leaq 0x128ff(%rip), %rdi # 0x28b13
callq *%rbx
movq %rax, 0x743a3(%rip) # 0x8a5c0
leaq 0x12906(%rip), %rdi # 0x28b2a
callq *%rbx
movq %rax, 0x74e23(%rip) # 0x8b050
cmpl $0x0, 0x73ab4(%rip) # 0x89ce8
je 0x1680a
leaq 0x128fd(%rip), %rdi # 0x28b3e
callq *%rbx
movq %rax, 0x74986(%rip) # 0x8abd0
leaq 0x12905(%rip), %rdi # 0x28b56
callq *%rbx
movq %rax, 0x7430e(%rip) # 0x8a568
leaq 0x12903(%rip), %rdi # 0x28b64
callq *%rbx
movq %rax, 0x7455e(%rip) # 0x8a7c8
leaq 0x12907(%rip), %rdi # 0x28b78
callq *%rbx
movq %rax, 0x74046(%rip) # 0x8a2c0
leaq 0x1290d(%rip), %rdi # 0x28b8e
callq *%rbx
movq %rax, 0x73b3e(%rip) # 0x89dc8
leaq 0x12913(%rip), %rdi # 0x28ba4
callq *%rbx
movq %rax, 0x74686(%rip) # 0x8a920
leaq 0x12912(%rip), %rdi # 0x28bb3
callq *%rbx
movq %rax, 0x74bee(%rip) # 0x8ae98
leaq 0x12917(%rip), %rdi # 0x28bc8
callq *%rbx
movq %rax, 0x73ae6(%rip) # 0x89da0
leaq 0x12917(%rip), %rdi # 0x28bd8
callq *%rbx
movq %rax, 0x74946(%rip) # 0x8ac10
leaq 0x12917(%rip), %rdi # 0x28be8
callq *%rbx
movq %rax, 0x73b3e(%rip) # 0x89e18
leaq 0x12916(%rip), %rdi # 0x28bf7
callq *%rbx
movq %rax, 0x73bbe(%rip) # 0x89ea8
leaq 0x12916(%rip), %rdi # 0x28c07
callq *%rbx
movq %rax, 0x7434e(%rip) # 0x8a648
leaq 0x12915(%rip), %rdi # 0x28c16
callq *%rbx
movq %rax, 0x74476(%rip) # 0x8a780
leaq 0x12914(%rip), %rdi # 0x28c25
callq *%rbx
movq %rax, 0x73dde(%rip) # 0x8a0f8
leaq 0x1291f(%rip), %rdi # 0x28c40
callq *%rbx
movq %rax, 0x7475e(%rip) # 0x8aa88
leaq 0x12929(%rip), %rdi # 0x28c5a
callq *%rbx
movq %rax, 0x74526(%rip) # 0x8a860
leaq 0x1292b(%rip), %rdi # 0x28c6c
callq *%rbx
movq %rax, 0x74e56(%rip) # 0x8b1a0
leaq 0x1292e(%rip), %rdi # 0x28c7f
callq *%rbx
movq %rax, 0x73d6e(%rip) # 0x8a0c8
leaq 0x12933(%rip), %rdi # 0x28c94
callq *%rbx
movq %rax, 0x73f4e(%rip) # 0x8a2b8
leaq 0x12937(%rip), %rdi # 0x28ca8
callq *%rbx
movq %rax, 0x74c76(%rip) # 0x8aff0
leaq 0x12936(%rip), %rdi # 0x28cb7
callq *%rbx
movq %rax, 0x7422e(%rip) # 0x8a5b8
leaq 0x1293a(%rip), %rdi # 0x28ccb
callq *%rbx
movq %rax, 0x7409e(%rip) # 0x8a438
leaq 0x12938(%rip), %rdi # 0x28cd9
callq *%rbx
movq %rax, 0x73d06(%rip) # 0x8a0b0
leaq 0x1293b(%rip), %rdi # 0x28cec
callq *%rbx
movq %rax, 0x74316(%rip) # 0x8a6d0
leaq 0x1293d(%rip), %rdi # 0x28cfe
callq *%rbx
movq %rax, 0x74a36(%rip) # 0x8ae00
leaq 0x12942(%rip), %rdi # 0x28d13
callq *%rbx
movq %rax, 0x7470e(%rip) # 0x8aae8
leaq 0x12941(%rip), %rdi # 0x28d22
callq *%rbx
movq %rax, 0x740a6(%rip) # 0x8a490
leaq 0x12940(%rip), %rdi # 0x28d31
callq *%rbx
movq %rax, 0x73b7e(%rip) # 0x89f78
leaq 0x12944(%rip), %rdi # 0x28d45
callq *%rbx
movq %rax, 0x7442e(%rip) # 0x8a838
leaq 0x12948(%rip), %rdi # 0x28d59
callq *%rbx
movq %rax, 0x74116(%rip) # 0x8a530
leaq 0x1294c(%rip), %rdi # 0x28d6d
callq *%rbx
movq %rax, 0x73e3e(%rip) # 0x8a268
leaq 0x12956(%rip), %rdi # 0x28d87
callq *%rbx
movq %rax, 0x74616(%rip) # 0x8aa50
leaq 0x12952(%rip), %rdi # 0x28d93
callq *%rbx
movq %rax, 0x73cee(%rip) # 0x8a138
leaq 0x1294d(%rip), %rdi # 0x28d9e
callq *%rbx
movq %rax, 0x742f6(%rip) # 0x8a750
leaq 0x1294b(%rip), %rdi # 0x28dac
callq *%rbx
movq %rax, 0x74ae6(%rip) # 0x8af50
leaq 0x1294a(%rip), %rdi # 0x28dbb
callq *%rbx
movq %rax, 0x74126(%rip) # 0x8a5a0
leaq 0x12947(%rip), %rdi # 0x28dc8
callq *%rbx
movq %rax, 0x743a6(%rip) # 0x8a830
leaq 0x12943(%rip), %rdi # 0x28dd4
callq *%rbx
movq %rax, 0x74ade(%rip) # 0x8af78
leaq 0x1293f(%rip), %rdi # 0x28de0
callq *%rbx
movq %rax, 0x73a76(%rip) # 0x89f20
leaq 0x1293b(%rip), %rdi # 0x28dec
callq *%rbx
movq %rax, 0x74606(%rip) # 0x8aac0
leaq 0x12937(%rip), %rdi # 0x28df8
callq *%rbx
movq %rax, 0x7438e(%rip) # 0x8a858
leaq 0x12933(%rip), %rdi # 0x28e04
callq *%rbx
movq %rax, 0x73e5e(%rip) # 0x8a338
leaq 0x1292f(%rip), %rdi # 0x28e10
callq *%rbx
movq %rax, 0x7437e(%rip) # 0x8a868
leaq 0x1292b(%rip), %rdi # 0x28e1c
callq *%rbx
movq %rax, 0x7457e(%rip) # 0x8aa78
leaq 0x12927(%rip), %rdi # 0x28e28
callq *%rbx
movq %rax, 0x74bb6(%rip) # 0x8b0c0
leaq 0x12924(%rip), %rdi # 0x28e35
callq *%rbx
movq %rax, 0x747de(%rip) # 0x8acf8
leaq 0x12921(%rip), %rdi # 0x28e42
callq *%rbx
movq %rax, 0x73f86(%rip) # 0x8a4b0
leaq 0x1291e(%rip), %rdi # 0x28e4f
callq *%rbx
movq %rax, 0x74c5e(%rip) # 0x8b198
leaq 0x1291b(%rip), %rdi # 0x28e5c
callq *%rbx
movq %rax, 0x745d6(%rip) # 0x8ab20
leaq 0x12918(%rip), %rdi # 0x28e69
callq *%rbx
movq %rax, 0x73ea6(%rip) # 0x8a400
leaq 0x12915(%rip), %rdi # 0x28e76
callq *%rbx
movq %rax, 0x73fe6(%rip) # 0x8a550
leaq 0x12912(%rip), %rdi # 0x28e83
callq *%rbx
movq %rax, 0x73d56(%rip) # 0x8a2d0
leaq 0x1290f(%rip), %rdi # 0x28e90
callq *%rbx
movq %rax, 0x74a26(%rip) # 0x8afb0
leaq 0x12912(%rip), %rdi # 0x28ea3
callq *%rbx
movq %rax, 0x74b46(%rip) # 0x8b0e0
leaq 0x12915(%rip), %rdi # 0x28eb6
callq *%rbx
movq %rax, 0x74be6(%rip) # 0x8b190
leaq 0x12918(%rip), %rdi # 0x28ec9
callq *%rbx
movq %rax, 0x7412e(%rip) # 0x8a6e8
leaq 0x1291a(%rip), %rdi # 0x28edb
callq *%rbx
movq %rax, 0x73eb6(%rip) # 0x8a480
leaq 0x1291b(%rip), %rdi # 0x28eec
callq *%rbx
movq %rax, 0x748d6(%rip) # 0x8aeb0
leaq 0x1291d(%rip), %rdi # 0x28efe
callq *%rbx
movq %rax, 0x7385e(%rip) # 0x89e48
leaq 0x1291e(%rip), %rdi # 0x28f0f
callq *%rbx
movq %rax, 0x73e0e(%rip) # 0x8a408
leaq 0x12920(%rip), %rdi # 0x28f21
callq *%rbx
movq %rax, 0x7385e(%rip) # 0x89e68
leaq 0x12921(%rip), %rdi # 0x28f32
callq *%rbx
movq %rax, 0x73756(%rip) # 0x89d70
leaq 0x12923(%rip), %rdi # 0x28f44
callq *%rbx
movq %rax, 0x74b2e(%rip) # 0x8b158
leaq 0x12924(%rip), %rdi # 0x28f55
callq *%rbx
movq %rax, 0x73866(%rip) # 0x89ea0
leaq 0x12926(%rip), %rdi # 0x28f67
callq *%rbx
movq %rax, 0x74b16(%rip) # 0x8b160
leaq 0x12927(%rip), %rdi # 0x28f78
callq *%rbx
movq %rax, 0x749b6(%rip) # 0x8b010
leaq 0x12929(%rip), %rdi # 0x28f8a
callq *%rbx
movq %rax, 0x74b0e(%rip) # 0x8b178
leaq 0x1292a(%rip), %rdi # 0x28f9b
callq *%rbx
movq %rax, 0x74576(%rip) # 0x8abf0
leaq 0x1292c(%rip), %rdi # 0x28fad
callq *%rbx
movq %rax, 0x73976(%rip) # 0x8a000
leaq 0x1292d(%rip), %rdi # 0x28fbe
callq *%rbx
movq %rax, 0x74ace(%rip) # 0x8b168
leaq 0x1292f(%rip), %rdi # 0x28fd0
callq *%rbx
movq %rax, 0x738b6(%rip) # 0x89f60
leaq 0x12930(%rip), %rdi # 0x28fe1
callq *%rbx
movq %rax, 0x73e86(%rip) # 0x8a540
leaq 0x12932(%rip), %rdi # 0x28ff3
callq *%rbx
movq %rax, 0x74356(%rip) # 0x8aa20
leaq 0x12933(%rip), %rdi # 0x29004
callq *%rbx
movq %rax, 0x73bae(%rip) # 0x8a288
leaq 0x12935(%rip), %rdi # 0x29016
callq *%rbx
movq %rax, 0x73c26(%rip) # 0x8a310
leaq 0x12938(%rip), %rdi # 0x29029
callq *%rbx
movq %rax, 0x745ae(%rip) # 0x8aca8
leaq 0x1293b(%rip), %rdi # 0x2903c
callq *%rbx
movq %rax, 0x73f5e(%rip) # 0x8a668
leaq 0x1293e(%rip), %rdi # 0x2904f
callq *%rbx
movq %rax, 0x7393e(%rip) # 0x8a058
leaq 0x12941(%rip), %rdi # 0x29062
callq *%rbx
movq %rax, 0x74456(%rip) # 0x8ab80
leaq 0x12945(%rip), %rdi # 0x29076
callq *%rbx
movq %rax, 0x73c3e(%rip) # 0x8a378
leaq 0x12949(%rip), %rdi # 0x2908a
callq *%rbx
movq %rax, 0x7461e(%rip) # 0x8ad68
leaq 0x1294d(%rip), %rdi # 0x2909e
callq *%rbx
movq %rax, 0x742fe(%rip) # 0x8aa58
leaq 0x1294f(%rip), %rdi # 0x290b0
callq *%rbx
movq %rax, 0x74076(%rip) # 0x8a7e0
leaq 0x12950(%rip), %rdi # 0x290c1
callq *%rbx
movq %rax, 0x73a16(%rip) # 0x8a190
leaq 0x12952(%rip), %rdi # 0x290d3
callq *%rbx
movq %rax, 0x7404e(%rip) # 0x8a7d8
leaq 0x12953(%rip), %rdi # 0x290e4
callq *%rbx
movq %rax, 0x742ce(%rip) # 0x8aa68
leaq 0x12955(%rip), %rdi # 0x290f6
callq *%rbx
movq %rax, 0x7472e(%rip) # 0x8aed8
leaq 0x12957(%rip), %rdi # 0x29108
callq *%rbx
movq %rax, 0x7405e(%rip) # 0x8a818
leaq 0x12958(%rip), %rdi # 0x29119
callq *%rbx
movq %rax, 0x748ae(%rip) # 0x8b078
leaq 0x1295a(%rip), %rdi # 0x2912b
callq *%rbx
movq %rax, 0x7374e(%rip) # 0x89f28
leaq 0x1295d(%rip), %rdi # 0x2913e
callq *%rbx
movq %rax, 0x744ae(%rip) # 0x8ac98
leaq 0x12960(%rip), %rdi # 0x29151
callq *%rbx
movq %rax, 0x7461e(%rip) # 0x8ae18
leaq 0x12963(%rip), %rdi # 0x29164
callq *%rbx
movq %rax, 0x73b4e(%rip) # 0x8a358
cmpl $0x0, 0x734db(%rip) # 0x89cec
je 0x16873
leaq 0x12960(%rip), %rdi # 0x2917a
callq *%rbx
movq %rax, 0x7410d(%rip) # 0x8a930
leaq 0x12965(%rip), %rdi # 0x2918f
callq *%rbx
movq %rax, 0x7365d(%rip) # 0x89e90
leaq 0x1296a(%rip), %rdi # 0x291a4
callq *%rbx
movq %rax, 0x73d8d(%rip) # 0x8a5d0
leaq 0x1296f(%rip), %rdi # 0x291b9
callq *%rbx
movq %rax, 0x7464d(%rip) # 0x8aea0
leaq 0x12974(%rip), %rdi # 0x291ce
callq *%rbx
movq %rax, 0x7371d(%rip) # 0x89f80
leaq 0x12979(%rip), %rdi # 0x291e3
callq *%rbx
movq %rax, 0x7366d(%rip) # 0x89ee0
cmpl $0x0, 0x73476(%rip) # 0x89cf0
je 0x16dc0
leaq 0x12971(%rip), %rdi # 0x291f8
callq *%rbx
movq %rax, 0x736b0(%rip) # 0x89f40
leaq 0x1296e(%rip), %rdi # 0x29205
callq *%rbx
movq %rax, 0x74918(%rip) # 0x8b1b8
leaq 0x1296e(%rip), %rdi # 0x29215
callq *%rbx
movq %rax, 0x734d8(%rip) # 0x89d88
leaq 0x1296e(%rip), %rdi # 0x29225
callq *%rbx
movq %rax, 0x73538(%rip) # 0x89df8
leaq 0x12968(%rip), %rdi # 0x2922f
callq *%rbx
movq %rax, 0x74668(%rip) # 0x8af38
leaq 0x12963(%rip), %rdi # 0x2923a
callq *%rbx
movq %rax, 0x73b08(%rip) # 0x8a3e8
leaq 0x12960(%rip), %rdi # 0x29247
callq *%rbx
movq %rax, 0x74548(%rip) # 0x8ae38
leaq 0x12969(%rip), %rdi # 0x29260
callq *%rbx
movq %rax, 0x74510(%rip) # 0x8ae10
leaq 0x12970(%rip), %rdi # 0x29277
callq *%rbx
movq %rax, 0x74408(%rip) # 0x8ad18
leaq 0x12972(%rip), %rdi # 0x29289
callq *%rbx
movq %rax, 0x745a8(%rip) # 0x8aec8
leaq 0x12973(%rip), %rdi # 0x2929a
callq *%rbx
movq %rax, 0x73d58(%rip) # 0x8a688
leaq 0x1297f(%rip), %rdi # 0x292b6
callq *%rbx
movq %rax, 0x73468(%rip) # 0x89da8
leaq 0x1298d(%rip), %rdi # 0x292d4
callq *%rbx
movq %rax, 0x73978(%rip) # 0x8a2c8
leaq 0x1298a(%rip), %rdi # 0x292e1
callq *%rbx
movq %rax, 0x73930(%rip) # 0x8a290
leaq 0x12993(%rip), %rdi # 0x292fa
callq *%rbx
movq %rax, 0x74518(%rip) # 0x8ae88
leaq 0x1299a(%rip), %rdi # 0x29311
callq *%rbx
movq %rax, 0x74280(%rip) # 0x8ac00
leaq 0x129a1(%rip), %rdi # 0x29328
callq *%rbx
movq %rax, 0x746c8(%rip) # 0x8b058
leaq 0x129a6(%rip), %rdi # 0x2933d
callq *%rbx
movq %rax, 0x74398(%rip) # 0x8ad38
leaq 0x129ac(%rip), %rdi # 0x29353
callq *%rbx
movq %rax, 0x73e50(%rip) # 0x8a800
leaq 0x129ae(%rip), %rdi # 0x29365
callq *%rbx
movq %rax, 0x73a30(%rip) # 0x8a3f0
leaq 0x129b0(%rip), %rdi # 0x29377
callq *%rbx
movq %rax, 0x73cd8(%rip) # 0x8a6a8
leaq 0x129b2(%rip), %rdi # 0x29389
callq *%rbx
movq %rax, 0x741d0(%rip) # 0x8abb0
leaq 0x129b4(%rip), %rdi # 0x2939b
callq *%rbx
movq %rax, 0x741e8(%rip) # 0x8abd8
leaq 0x129b7(%rip), %rdi # 0x293ae
callq *%rbx
movq %rax, 0x73db0(%rip) # 0x8a7b0
leaq 0x129ba(%rip), %rdi # 0x293c1
callq *%rbx
movq %rax, 0x732f8(%rip) # 0x89d08
leaq 0x129bd(%rip), %rdi # 0x293d4
callq *%rbx
movq %rax, 0x743b8(%rip) # 0x8add8
leaq 0x129c0(%rip), %rdi # 0x293e7
callq *%rbx
movq %rax, 0x74418(%rip) # 0x8ae48
leaq 0x129c3(%rip), %rdi # 0x293fa
callq *%rbx
movq %rax, 0x744e0(%rip) # 0x8af20
leaq 0x129c6(%rip), %rdi # 0x2940d
callq *%rbx
movq %rax, 0x74060(%rip) # 0x8aab0
leaq 0x129c9(%rip), %rdi # 0x29420
callq *%rbx
movq %rax, 0x74128(%rip) # 0x8ab88
leaq 0x129cc(%rip), %rdi # 0x29433
callq *%rbx
movq %rax, 0x746e0(%rip) # 0x8b150
leaq 0x129d0(%rip), %rdi # 0x29447
callq *%rbx
movq %rax, 0x74250(%rip) # 0x8acd0
leaq 0x129d4(%rip), %rdi # 0x2945b
callq *%rbx
movq %rax, 0x744d0(%rip) # 0x8af60
leaq 0x129d8(%rip), %rdi # 0x2946f
callq *%rbx
movq %rax, 0x74248(%rip) # 0x8ace8
leaq 0x129dc(%rip), %rdi # 0x29483
callq *%rbx
movq %rax, 0x742f8(%rip) # 0x8ada8
leaq 0x129df(%rip), %rdi # 0x29496
callq *%rbx
movq %rax, 0x73eb8(%rip) # 0x8a978
leaq 0x129e2(%rip), %rdi # 0x294a9
callq *%rbx
movq %rax, 0x73678(%rip) # 0x8a148
leaq 0x129e6(%rip), %rdi # 0x294bd
callq *%rbx
movq %rax, 0x73bd8(%rip) # 0x8a6b8
leaq 0x129ea(%rip), %rdi # 0x294d1
callq *%rbx
movq %rax, 0x736e0(%rip) # 0x8a1d0
leaq 0x129ea(%rip), %rdi # 0x294e1
callq *%rbx
movq %rax, 0x73950(%rip) # 0x8a450
leaq 0x129f1(%rip), %rdi # 0x294f8
callq *%rbx
movq %rax, 0x73560(%rip) # 0x8a070
leaq 0x129f7(%rip), %rdi # 0x2950e
callq *%rbx
movq %rax, 0x734c0(%rip) # 0x89fe0
leaq 0x129f4(%rip), %rdi # 0x2951b
callq *%rbx
movq %rax, 0x743e8(%rip) # 0x8af18
leaq 0x129f1(%rip), %rdi # 0x29528
callq *%rbx
movq %rax, 0x74198(%rip) # 0x8acd8
leaq 0x129ee(%rip), %rdi # 0x29535
callq *%rbx
movq %rax, 0x73d58(%rip) # 0x8a8a8
leaq 0x129eb(%rip), %rdi # 0x29542
callq *%rbx
movq %rax, 0x73b20(%rip) # 0x8a680
leaq 0x129e9(%rip), %rdi # 0x29550
callq *%rbx
movq %rax, 0x73ab8(%rip) # 0x8a628
leaq 0x129e7(%rip), %rdi # 0x2955e
callq *%rbx
movq %rax, 0x73b78(%rip) # 0x8a6f8
leaq 0x129e5(%rip), %rdi # 0x2956c
callq *%rbx
movq %rax, 0x73880(%rip) # 0x8a410
leaq 0x129e3(%rip), %rdi # 0x2957a
callq *%rbx
movq %rax, 0x74250(%rip) # 0x8adf0
leaq 0x129e5(%rip), %rdi # 0x2958c
callq *%rbx
movq %rax, 0x73de8(%rip) # 0x8a998
leaq 0x129e8(%rip), %rdi # 0x2959f
callq *%rbx
movq %rax, 0x74410(%rip) # 0x8afd0
leaq 0x129ed(%rip), %rdi # 0x295b4
callq *%rbx
movq %rax, 0x73730(%rip) # 0x8a300
leaq 0x129f3(%rip), %rdi # 0x295ca
callq *%rbx
movq %rax, 0x740d0(%rip) # 0x8acb0
leaq 0x129f3(%rip), %rdi # 0x295da
callq *%rbx
movq %rax, 0x745d0(%rip) # 0x8b1c0
leaq 0x129f4(%rip), %rdi # 0x295eb
callq *%rbx
movq %rax, 0x732f0(%rip) # 0x89ef0
leaq 0x129f4(%rip), %rdi # 0x295fb
callq *%rbx
movq %rax, 0x73338(%rip) # 0x89f48
leaq 0x129f4(%rip), %rdi # 0x2960b
callq *%rbx
movq %rax, 0x73ce0(%rip) # 0x8a900
leaq 0x129f1(%rip), %rdi # 0x29618
callq *%rbx
movq %rax, 0x734a0(%rip) # 0x8a0d0
leaq 0x129f2(%rip), %rdi # 0x29629
callq *%rbx
movq %rax, 0x73df0(%rip) # 0x8aa30
leaq 0x129f5(%rip), %rdi # 0x2963c
callq *%rbx
movq %rax, 0x736e0(%rip) # 0x8a330
leaq 0x129fb(%rip), %rdi # 0x29652
callq *%rbx
movq %rax, 0x731d0(%rip) # 0x89e30
leaq 0x129fe(%rip), %rdi # 0x29665
callq *%rbx
movq %rax, 0x73268(%rip) # 0x89ed8
leaq 0x12a04(%rip), %rdi # 0x2967b
callq *%rbx
movq %rax, 0x735d0(%rip) # 0x8a250
leaq 0x12a11(%rip), %rdi # 0x29698
callq *%rbx
movq %rax, 0x73f90(%rip) # 0x8ac20
leaq 0x12a11(%rip), %rdi # 0x296a8
callq *%rbx
movq %rax, 0x73c18(%rip) # 0x8a8b8
leaq 0x12a13(%rip), %rdi # 0x296ba
callq *%rbx
movq %rax, 0x73320(%rip) # 0x89fd0
leaq 0x12a18(%rip), %rdi # 0x296cf
callq *%rbx
movq %rax, 0x733f8(%rip) # 0x8a0b8
leaq 0x12a1a(%rip), %rdi # 0x296e1
callq *%rbx
movq %rax, 0x741a0(%rip) # 0x8ae70
leaq 0x12a23(%rip), %rdi # 0x296fa
callq *%rbx
movq %rax, 0x73750(%rip) # 0x8a430
leaq 0x12a2a(%rip), %rdi # 0x29711
callq *%rbx
movq %rax, 0x73350(%rip) # 0x8a040
leaq 0x12a31(%rip), %rdi # 0x29728
callq *%rbx
movq %rax, 0x73c50(%rip) # 0x8a950
leaq 0x12a38(%rip), %rdi # 0x2973f
callq *%rbx
movq %rax, 0x73030(%rip) # 0x89d40
leaq 0x12a42(%rip), %rdi # 0x29759
callq *%rbx
movq %rax, 0x73328(%rip) # 0x8a048
leaq 0x12a58(%rip), %rdi # 0x2977f
callq *%rbx
movq %rax, 0x73c78(%rip) # 0x8a9a8
leaq 0x12a59(%rip), %rdi # 0x29790
callq *%rbx
movq %rax, 0x73218(%rip) # 0x89f58
leaq 0x12a5b(%rip), %rdi # 0x297a2
callq *%rbx
movq %rax, 0x73d78(%rip) # 0x8aac8
leaq 0x12a6c(%rip), %rdi # 0x297c3
callq *%rbx
movq %rax, 0x73600(%rip) # 0x8a360
leaq 0x12a76(%rip), %rdi # 0x297dd
callq *%rbx
movq %rax, 0x74180(%rip) # 0x8aef0
leaq 0x12a77(%rip), %rdi # 0x297ee
callq *%rbx
movq %rax, 0x73600(%rip) # 0x8a380
leaq 0x12a80(%rip), %rdi # 0x29807
callq *%rbx
movq %rax, 0x73848(%rip) # 0x8a5d8
leaq 0x12a82(%rip), %rdi # 0x29819
callq *%rbx
movq %rax, 0x734e0(%rip) # 0x8a280
leaq 0x12a87(%rip), %rdi # 0x2982e
callq *%rbx
movq %rax, 0x73d20(%rip) # 0x8aad0
leaq 0x12a89(%rip), %rdi # 0x29840
callq *%rbx
movq %rax, 0x73330(%rip) # 0x8a0f0
cmpl $0x0, 0x72f2d(%rip) # 0x89cf4
je 0x16ebd
leaq 0x12a7c(%rip), %rdi # 0x29850
callq *%rbx
movq %rax, 0x73bc3(%rip) # 0x8a9a0
leaq 0x12a82(%rip), %rdi # 0x29866
callq *%rbx
movq %rax, 0x73433(%rip) # 0x8a220
leaq 0x12a8a(%rip), %rdi # 0x2987e
callq *%rbx
movq %rax, 0x738db(%rip) # 0x8a6d8
leaq 0x12a86(%rip), %rdi # 0x2988a
callq *%rbx
movq %rax, 0x73e23(%rip) # 0x8ac30
leaq 0x12a8e(%rip), %rdi # 0x298a2
callq *%rbx
movq %rax, 0x7432b(%rip) # 0x8b148
leaq 0x12a92(%rip), %rdi # 0x298b6
callq *%rbx
movq %rax, 0x73303(%rip) # 0x8a130
leaq 0x12a96(%rip), %rdi # 0x298ca
callq *%rbx
movq %rax, 0x73333(%rip) # 0x8a170
leaq 0x12a9c(%rip), %rdi # 0x298e0
callq *%rbx
movq %rax, 0x731cb(%rip) # 0x8a018
leaq 0x12aa3(%rip), %rdi # 0x298f7
callq *%rbx
movq %rax, 0x7412b(%rip) # 0x8af88
leaq 0x12aaa(%rip), %rdi # 0x2990e
callq *%rbx
movq %rax, 0x73703(%rip) # 0x8a570
leaq 0x12ab4(%rip), %rdi # 0x29928
callq *%rbx
movq %rax, 0x740db(%rip) # 0x8af58
leaq 0x12ac0(%rip), %rdi # 0x29944
callq *%rbx
movq %rax, 0x73cbb(%rip) # 0x8ab48
leaq 0x123e3(%rip), %rdi # 0x29277
callq *%rbx
movq %rax, 0x73e7b(%rip) # 0x8ad18
leaq 0x123e5(%rip), %rdi # 0x29289
callq *%rbx
movq %rax, 0x7401b(%rip) # 0x8aec8
leaq 0x12361(%rip), %rdi # 0x29215
callq *%rbx
movq %rax, 0x72ecb(%rip) # 0x89d88
cmpl $0x0, 0x72e34(%rip) # 0x89cf8
je 0x16ffa
leaq 0x12a89(%rip), %rdi # 0x2995a
callq *%rbx
movq %rax, 0x733be(%rip) # 0x8a298
leaq 0x12a92(%rip), %rdi # 0x29973
callq *%rbx
movq %rax, 0x72f96(%rip) # 0x89e80
leaq 0x12aa0(%rip), %rdi # 0x29991
callq *%rbx
movq %rax, 0x73c0e(%rip) # 0x8ab08
leaq 0x12ab2(%rip), %rdi # 0x299b3
callq *%rbx
movq %rax, 0x736fe(%rip) # 0x8a608
leaq 0x12ac0(%rip), %rdi # 0x299d1
callq *%rbx
movq %rax, 0x73a2e(%rip) # 0x8a948
leaq 0x12ac2(%rip), %rdi # 0x299e3
callq *%rbx
movq %rax, 0x7334e(%rip) # 0x8a278
leaq 0x12abe(%rip), %rdi # 0x299ef
callq *%rbx
movq %rax, 0x733de(%rip) # 0x8a318
leaq 0x12ab7(%rip), %rdi # 0x299f8
callq *%rbx
movq %rax, 0x735ce(%rip) # 0x8a518
leaq 0x12ab4(%rip), %rdi # 0x29a05
callq *%rbx
movq %rax, 0x73e76(%rip) # 0x8add0
leaq 0x12ab5(%rip), %rdi # 0x29a16
callq *%rbx
movq %rax, 0x738a6(%rip) # 0x8a810
leaq 0x12ab0(%rip), %rdi # 0x29a21
callq *%rbx
movq %rax, 0x731de(%rip) # 0x8a158
leaq 0x12ab0(%rip), %rdi # 0x29a31
callq *%rbx
movq %rax, 0x73fe6(%rip) # 0x8af70
leaq 0x12aac(%rip), %rdi # 0x29a3d
callq *%rbx
movq %rax, 0x7341e(%rip) # 0x8a3b8
leaq 0x12aae(%rip), %rdi # 0x29a4f
callq *%rbx
movq %rax, 0x73846(%rip) # 0x8a7f0
leaq 0x12ab7(%rip), %rdi # 0x29a68
callq *%rbx
movq %rax, 0x73f3e(%rip) # 0x8aef8
leaq 0x12abc(%rip), %rdi # 0x29a7d
callq *%rbx
movq %rax, 0x7355e(%rip) # 0x8a528
leaq 0x12ac4(%rip), %rdi # 0x29a95
callq *%rbx
movq %rax, 0x741ae(%rip) # 0x8b188
leaq 0x12acc(%rip), %rdi # 0x29aad
callq *%rbx
movq %rax, 0x72e3e(%rip) # 0x89e28
leaq 0x12acf(%rip), %rdi # 0x29ac0
callq *%rbx
movq %rax, 0x72e7e(%rip) # 0x89e78
cmpl $0x2, 0x74327(%rip) # 0x8b328
jg 0x17364
movl $0x1f03, %edi # imm = 0x1F03
callq *0x72cb6(%rip) # 0x89cc8
movq %rax, 0x74317(%rip) # 0x8b330
movq 0x74320(%rip), %r14 # 0x8b340
leaq 0x12aa7(%rip), %rdi # 0x29ace
callq 0x173dc
movl %eax, %ebp
movl %eax, 0x7419c(%rip) # 0x8b1d0
leaq 0x12aa6(%rip), %rdi # 0x29ae1
callq 0x173dc
movl %eax, 0x74186(%rip) # 0x8b1cc
leaq 0x12aa6(%rip), %rdi # 0x29af3
callq 0x173dc
movl %eax, 0x74170(%rip) # 0x8b1c8
testq %r14, %r14
je 0x17073
movq %r14, %rdi
callq 0x133b0
andq $0x0, 0x742d3(%rip) # 0x8b340
movl 0x7415d(%rip), %ebp # 0x8b1d0
testl %ebp, %ebp
je 0x17087
leaq 0x12a82(%rip), %rdi # 0x29b00
callq *%rbx
movq %rax, 0x74151(%rip) # 0x8b1d8
cmpl $0x0, 0x7413e(%rip) # 0x8b1cc
je 0x171d4
leaq 0x12a79(%rip), %rdi # 0x29b14
callq *%rbx
movq %rax, 0x7413c(%rip) # 0x8b1e0
leaq 0x12a85(%rip), %rdi # 0x29b30
callq *%rbx
movq %rax, 0x74134(%rip) # 0x8b1e8
leaq 0x12a87(%rip), %rdi # 0x29b42
callq *%rbx
movq %rax, 0x7412c(%rip) # 0x8b1f0
leaq 0x12a88(%rip), %rdi # 0x29b53
callq *%rbx
movq %rax, 0x74124(%rip) # 0x8b1f8
leaq 0x12a94(%rip), %rdi # 0x29b6f
callq *%rbx
movq %rax, 0x7411c(%rip) # 0x8b200
leaq 0x12a97(%rip), %rdi # 0x29b82
callq *%rbx
movq %rax, 0x74114(%rip) # 0x8b208
leaq 0x12a9a(%rip), %rdi # 0x29b95
callq *%rbx
movq %rax, 0x7410c(%rip) # 0x8b210
leaq 0x12a9e(%rip), %rdi # 0x29ba9
callq *%rbx
movq %rax, 0x74104(%rip) # 0x8b218
leaq 0x12aa1(%rip), %rdi # 0x29bbc
callq *%rbx
movq %rax, 0x740fc(%rip) # 0x8b220
leaq 0x12aa0(%rip), %rdi # 0x29bcb
callq *%rbx
movq %rax, 0x740f4(%rip) # 0x8b228
leaq 0x12a9f(%rip), %rdi # 0x29bda
callq *%rbx
movq %rax, 0x740ec(%rip) # 0x8b230
leaq 0x12a9e(%rip), %rdi # 0x29be9
callq *%rbx
movq %rax, 0x740e4(%rip) # 0x8b238
leaq 0x12aa2(%rip), %rdi # 0x29bfd
callq *%rbx
movq %rax, 0x740dc(%rip) # 0x8b240
leaq 0x12aa7(%rip), %rdi # 0x29c12
callq *%rbx
movq %rax, 0x740d4(%rip) # 0x8b248
leaq 0x12aac(%rip), %rdi # 0x29c27
callq *%rbx
movq %rax, 0x740cc(%rip) # 0x8b250
leaq 0x12ab4(%rip), %rdi # 0x29c3f
callq *%rbx
movq %rax, 0x740c4(%rip) # 0x8b258
leaq 0x12ab8(%rip), %rdi # 0x29c53
callq *%rbx
movq %rax, 0x740bc(%rip) # 0x8b260
leaq 0x12ac3(%rip), %rdi # 0x29c6e
callq *%rbx
movq %rax, 0x740b4(%rip) # 0x8b268
leaq 0x12acc(%rip), %rdi # 0x29c87
callq *%rbx
movq %rax, 0x740ac(%rip) # 0x8b270
leaq 0x12acf(%rip), %rdi # 0x29c9a
callq *%rbx
movq %rax, 0x740a4(%rip) # 0x8b278
cmpl $0x0, 0x73fed(%rip) # 0x8b1c8
je 0x17341
leaq 0x12ac2(%rip), %rdi # 0x29caa
callq *%rbx
movq %rax, 0x7408f(%rip) # 0x8b280
leaq 0x12ac8(%rip), %rdi # 0x29cc0
callq *%rbx
movq %rax, 0x74087(%rip) # 0x8b288
leaq 0x12acd(%rip), %rdi # 0x29cd5
callq *%rbx
movq %rax, 0x7407f(%rip) # 0x8b290
leaq 0x12ad4(%rip), %rdi # 0x29cec
callq *%rbx
movq %rax, 0x74077(%rip) # 0x8b298
leaq 0x12ad9(%rip), %rdi # 0x29d01
callq *%rbx
movq %rax, 0x7406f(%rip) # 0x8b2a0
leaq 0x12ada(%rip), %rdi # 0x29d12
callq *%rbx
movq %rax, 0x74067(%rip) # 0x8b2a8
leaq 0x12ada(%rip), %rdi # 0x29d22
callq *%rbx
movq %rax, 0x7405f(%rip) # 0x8b2b0
leaq 0x12ad8(%rip), %rdi # 0x29d30
callq *%rbx
movq %rax, 0x74057(%rip) # 0x8b2b8
leaq 0x12ad9(%rip), %rdi # 0x29d41
callq *%rbx
movq %rax, 0x7404f(%rip) # 0x8b2c0
leaq 0x12ada(%rip), %rdi # 0x29d52
callq *%rbx
movq %rax, 0x74047(%rip) # 0x8b2c8
leaq 0x10ecf(%rip), %rdi # 0x28157
callq *%rbx
movq %rax, 0x72f2f(%rip) # 0x8a1c0
leaq 0x12ace(%rip), %rdi # 0x29d66
callq *%rbx
movq %rax, 0x7402f(%rip) # 0x8b2d0
leaq 0x12ad7(%rip), %rdi # 0x29d7f
callq *%rbx
movq %rax, 0x74027(%rip) # 0x8b2d8
leaq 0x12adf(%rip), %rdi # 0x29d97
callq *%rbx
movq %rax, 0x7401f(%rip) # 0x8b2e0
leaq 0x12ae9(%rip), %rdi # 0x29db1
callq *%rbx
movq %rax, 0x74017(%rip) # 0x8b2e8
leaq 0x12af1(%rip), %rdi # 0x29dc9
callq *%rbx
movq %rax, 0x7400f(%rip) # 0x8b2f0
leaq 0x12af5(%rip), %rdi # 0x29ddd
callq *%rbx
movq %rax, 0x74007(%rip) # 0x8b2f8
leaq 0x12af8(%rip), %rdi # 0x29df0
callq *%rbx
movq %rax, 0x73fff(%rip) # 0x8b300
leaq 0x12af9(%rip), %rdi # 0x29e01
callq *%rbx
movq %rax, 0x73ff7(%rip) # 0x8b308
leaq 0x12afd(%rip), %rdi # 0x29e15
callq *%rbx
movq %rax, 0x73fef(%rip) # 0x8b310
leaq 0x12b01(%rip), %rdi # 0x29e29
callq *%rbx
movq %rax, 0x73fe7(%rip) # 0x8b318
leaq 0x12b08(%rip), %rdi # 0x29e40
callq *%rbx
movq %rax, 0x73fdf(%rip) # 0x8b320
movl 0x7297d(%rip), %eax # 0x89cc4
xorl %ebp, %ebp
orl 0x72971(%rip), %eax # 0x89cc0
setne %bpl
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
andl $0x0, 0x73fcd(%rip) # 0x8b338
leaq 0x73fc6(%rip), %rsi # 0x8b338
movl $0x821d, %edi # imm = 0x821D
callq *0x73cc3(%rip) # 0x8b040
movslq 0x73fb4(%rip), %rsi # 0x8b338
movq 0x73fb5(%rip), %r14 # 0x8b340
testq %rsi, %rsi
jle 0x173a6
shlq $0x3, %rsi
movq %r14, %rdi
callq 0x138d0
movq %rax, %r14
movq %rax, 0x73f9a(%rip) # 0x8b340
testq %r14, %r14
je 0x17353
xorl %r15d, %r15d
movslq 0x73f83(%rip), %rax # 0x8b338
cmpq %rax, %r15
jge 0x17020
movl $0x1f03, %edi # imm = 0x1F03
movl %r15d, %esi
callq *0x73534(%rip) # 0x8a900
movq 0x73f6d(%rip), %r14 # 0x8b340
movq %rax, (%r14,%r15,8)
incq %r15
jmp 0x173ae
| /Konf[P]LearnOpenGL-CLion/glfw/deps/glad.c |
glfwRefreshContextAttribs | GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
const _GLFWctxconfig* ctxconfig)
{
int i;
_GLFWwindow* previous;
const char* version;
const char* prefixes[] =
{
"OpenGL ES-CM ",
"OpenGL ES-CL ",
"OpenGL ES ",
NULL
};
window->context.source = ctxconfig->source;
window->context.client = GLFW_OPENGL_API;
previous = _glfwPlatformGetTls(&_glfw.contextSlot);;
glfwMakeContextCurrent((GLFWwindow*) window);
window->context.GetIntegerv = (PFNGLGETINTEGERVPROC)
window->context.getProcAddress("glGetIntegerv");
window->context.GetString = (PFNGLGETSTRINGPROC)
window->context.getProcAddress("glGetString");
if (!window->context.GetIntegerv || !window->context.GetString)
{
_glfwInputError(GLFW_PLATFORM_ERROR, "Entry point retrieval is broken");
glfwMakeContextCurrent((GLFWwindow*) previous);
return GLFW_FALSE;
}
version = (const char*) window->context.GetString(GL_VERSION);
if (!version)
{
if (ctxconfig->client == GLFW_OPENGL_API)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"OpenGL version string retrieval is broken");
}
else
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"OpenGL ES version string retrieval is broken");
}
glfwMakeContextCurrent((GLFWwindow*) previous);
return GLFW_FALSE;
}
for (i = 0; prefixes[i]; i++)
{
const size_t length = strlen(prefixes[i]);
if (strncmp(version, prefixes[i], length) == 0)
{
version += length;
window->context.client = GLFW_OPENGL_ES_API;
break;
}
}
if (!sscanf(version, "%d.%d.%d",
&window->context.major,
&window->context.minor,
&window->context.revision))
{
if (window->context.client == GLFW_OPENGL_API)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"No version found in OpenGL version string");
}
else
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"No version found in OpenGL ES version string");
}
glfwMakeContextCurrent((GLFWwindow*) previous);
return GLFW_FALSE;
}
if (window->context.major < ctxconfig->major ||
(window->context.major == ctxconfig->major &&
window->context.minor < ctxconfig->minor))
{
// The desired OpenGL version is greater than the actual version
// This only happens if the machine lacks {GLX|WGL}_ARB_create_context
// /and/ the user has requested an OpenGL version greater than 1.0
// For API consistency, we emulate the behavior of the
// {GLX|WGL}_ARB_create_context extension and fail here
if (window->context.client == GLFW_OPENGL_API)
{
_glfwInputError(GLFW_VERSION_UNAVAILABLE,
"Requested OpenGL version %i.%i, got version %i.%i",
ctxconfig->major, ctxconfig->minor,
window->context.major, window->context.minor);
}
else
{
_glfwInputError(GLFW_VERSION_UNAVAILABLE,
"Requested OpenGL ES version %i.%i, got version %i.%i",
ctxconfig->major, ctxconfig->minor,
window->context.major, window->context.minor);
}
glfwMakeContextCurrent((GLFWwindow*) previous);
return GLFW_FALSE;
}
if (window->context.major >= 3)
{
// OpenGL 3.0+ uses a different function for extension string retrieval
// We cache it here instead of in glfwExtensionSupported mostly to alert
// users as early as possible that their build may be broken
window->context.GetStringi = (PFNGLGETSTRINGIPROC)
window->context.getProcAddress("glGetStringi");
if (!window->context.GetStringi)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Entry point retrieval is broken");
glfwMakeContextCurrent((GLFWwindow*) previous);
return GLFW_FALSE;
}
}
if (window->context.client == GLFW_OPENGL_API)
{
// Read back context flags (OpenGL 3.0 and above)
if (window->context.major >= 3)
{
GLint flags;
window->context.GetIntegerv(GL_CONTEXT_FLAGS, &flags);
if (flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)
window->context.forward = GLFW_TRUE;
if (flags & GL_CONTEXT_FLAG_DEBUG_BIT)
window->context.debug = GLFW_TRUE;
else if (glfwExtensionSupported("GL_ARB_debug_output") &&
ctxconfig->debug)
{
// HACK: This is a workaround for older drivers (pre KHR_debug)
// not setting the debug bit in the context flags for
// debug contexts
window->context.debug = GLFW_TRUE;
}
if (flags & GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR)
window->context.noerror = GLFW_TRUE;
}
// Read back OpenGL context profile (OpenGL 3.2 and above)
if (window->context.major >= 4 ||
(window->context.major == 3 && window->context.minor >= 2))
{
GLint mask;
window->context.GetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
if (mask & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT)
window->context.profile = GLFW_OPENGL_COMPAT_PROFILE;
else if (mask & GL_CONTEXT_CORE_PROFILE_BIT)
window->context.profile = GLFW_OPENGL_CORE_PROFILE;
else if (glfwExtensionSupported("GL_ARB_compatibility"))
{
// HACK: This is a workaround for the compatibility profile bit
// not being set in the context flags if an OpenGL 3.2+
// context was created without having requested a specific
// version
window->context.profile = GLFW_OPENGL_COMPAT_PROFILE;
}
}
// Read back robustness strategy
if (glfwExtensionSupported("GL_ARB_robustness"))
{
// NOTE: We avoid using the context flags for detection, as they are
// only present from 3.0 while the extension applies from 1.1
GLint strategy;
window->context.GetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB,
&strategy);
if (strategy == GL_LOSE_CONTEXT_ON_RESET_ARB)
window->context.robustness = GLFW_LOSE_CONTEXT_ON_RESET;
else if (strategy == GL_NO_RESET_NOTIFICATION_ARB)
window->context.robustness = GLFW_NO_RESET_NOTIFICATION;
}
}
else
{
// Read back robustness strategy
if (glfwExtensionSupported("GL_EXT_robustness"))
{
// NOTE: The values of these constants match those of the OpenGL ARB
// one, so we can reuse them here
GLint strategy;
window->context.GetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB,
&strategy);
if (strategy == GL_LOSE_CONTEXT_ON_RESET_ARB)
window->context.robustness = GLFW_LOSE_CONTEXT_ON_RESET;
else if (strategy == GL_NO_RESET_NOTIFICATION_ARB)
window->context.robustness = GLFW_NO_RESET_NOTIFICATION;
}
}
if (glfwExtensionSupported("GL_KHR_context_flush_control"))
{
GLint behavior;
window->context.GetIntegerv(GL_CONTEXT_RELEASE_BEHAVIOR, &behavior);
if (behavior == GL_NONE)
window->context.release = GLFW_RELEASE_BEHAVIOR_NONE;
else if (behavior == GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH)
window->context.release = GLFW_RELEASE_BEHAVIOR_FLUSH;
}
// Clearing the front buffer to black to avoid garbage pixels left over from
// previous uses of our bit of VRAM
{
PFNGLCLEARPROC glClear = (PFNGLCLEARPROC)
window->context.getProcAddress("glClear");
glClear(GL_COLOR_BUFFER_BIT);
window->context.swapBuffers(window);
}
glfwMakeContextCurrent((GLFWwindow*) previous);
return GLFW_TRUE;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r14
movl 0x4(%rsi), %eax
movl %eax, 0x1f4(%rdi)
movl $0x30001, 0x1f0(%rdi) # imm = 0x30001
movl $0x1fe14, %edi # imm = 0x1FE14
addq 0x3974d(%rip), %rdi # 0x50fe8
callq 0x237f6
movq %rax, %r15
movq %r14, %rdi
callq 0x17c04
leaq 0xfbb3(%rip), %rdi # 0x27465
callq *0x258(%r14)
movq %rax, 0x228(%r14)
leaq 0xf9a0(%rip), %rdi # 0x27267
callq *0x258(%r14)
movq %rax, 0x230(%r14)
cmpq $0x0, 0x228(%r14)
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x178f9
leaq 0x126cf(%rip), %rsi # 0x29fc3
jmp 0x179fa
movl $0x1f02, %edi # imm = 0x1F02
callq *%rax
testq %rax, %rax
je 0x179e0
movq %rax, %rbx
movq %r12, 0x8(%rsp)
movq %r15, 0x10(%rsp)
xorl %ebp, %ebp
leaq 0x39401(%rip), %r15 # 0x50d20
cmpq $0x18, %rbp
je 0x17959
movq (%rbp,%r15), %r13
movq %r13, %rdi
callq 0x133d0
movq %rax, %r12
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x13240
addq $0x8, %rbp
testl %eax, %eax
jne 0x1791f
addq %r12, %rbx
movl $0x30002, 0x1f0(%r14) # imm = 0x30002
leaq 0x1f8(%r14), %r13
leaq 0x1fc(%r14), %r12
leaq 0x200(%r14), %r8
leaq 0x126c5(%rip), %rsi # 0x2a03a
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r13, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x13180
testl %eax, %eax
movq 0x10(%rsp), %r15
je 0x17a21
movl (%r13), %r8d
movq 0x8(%rsp), %rbp
movl 0x8(%rbp), %edx
cmpl %edx, %r8d
jge 0x17a40
movl 0x1fc(%r14), %r9d
cmpl $0x30001, 0x1f0(%r14) # imm = 0x30001
movl 0xc(%rbp), %ecx
leaq 0x126d5(%rip), %rax # 0x2a09a
leaq 0x12700(%rip), %rsi # 0x2a0cc
cmoveq %rax, %rsi
xorl %ebp, %ebp
movl $0x10007, %edi # imm = 0x10007
xorl %eax, %eax
callq 0x17f99
jmp 0x17a08
cmpl $0x30001, (%r12) # imm = 0x30001
leaq 0x125f4(%rip), %rax # 0x29fe3
leaq 0x12617(%rip), %rsi # 0x2a00d
cmoveq %rax, %rsi
xorl %ebp, %ebp
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x17f99
movq %r15, %rdi
callq 0x17c04
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x30001, 0x1f0(%r14) # imm = 0x30001
leaq 0x12610(%rip), %rax # 0x2a043
leaq 0x12633(%rip), %rsi # 0x2a06d
cmoveq %rax, %rsi
jmp 0x179fc
jne 0x17a4f
movl (%r12), %eax
cmpl 0xc(%rbp), %eax
jl 0x179a9
cmpl $0x3, %r8d
jl 0x17a73
leaq 0x11baf(%rip), %rdi # 0x2960b
callq *0x258(%r14)
movq %rax, 0x220(%r14)
testq %rax, %rax
je 0x178ed
cmpl $0x30001, 0x1f0(%r14) # imm = 0x30001
jne 0x17b38
cmpl $0x3, (%r13)
jl 0x17b4a
leaq 0x4(%rsp), %rbx
movl $0x821e, %edi # imm = 0x821E
movq %rbx, %rsi
callq *0x228(%r14)
movl (%rbx), %eax
testb $0x1, %al
je 0x17ab4
movl $0x1, 0x204(%r14)
testb $0x2, %al
jne 0x17ace
leaq 0x12642(%rip), %rdi # 0x2a101
callq 0x17c9c
testl %eax, %eax
je 0x17ad9
cmpl $0x0, 0x14(%rbp)
je 0x17ad9
movl $0x1, 0x208(%r14)
testb $0x8, 0x4(%rsp)
je 0x17aeb
movl $0x1, 0x20c(%r14)
cmpl $0x3, (%r13)
jle 0x17b41
leaq 0x4(%rsp), %rbx
movl $0x9126, %edi # imm = 0x9126
movq %rbx, %rsi
callq *0x228(%r14)
movl (%rbx), %eax
movl $0x32002, %ecx # imm = 0x32002
testb $0x2, %al
jne 0x17b2f
movl $0x32001, %ecx # imm = 0x32001
testb $0x1, %al
jne 0x17b2f
leaq 0x125f4(%rip), %rdi # 0x2a115
callq 0x17c9c
movl $0x32002, %ecx # imm = 0x32002
testl %eax, %eax
je 0x17b4a
movl %ecx, 0x210(%r14)
jmp 0x17b4a
leaq 0x125eb(%rip), %rdi # 0x2a12a
jmp 0x17b51
jne 0x17b4a
cmpl $0x2, (%r12)
jge 0x17af2
leaq 0x11f90(%rip), %rdi # 0x29ae1
callq 0x17c9c
testl %eax, %eax
je 0x17b91
leaq 0x4(%rsp), %rbx
movl $0x8256, %edi # imm = 0x8256
movq %rbx, %rsi
callq *0x228(%r14)
movl (%rbx), %eax
cmpl $0x8252, %eax # imm = 0x8252
je 0x17b85
cmpl $0x8261, %eax # imm = 0x8261
jne 0x17b91
movl $0x31001, %eax # imm = 0x31001
jmp 0x17b8a
movl $0x31002, %eax # imm = 0x31002
movl %eax, 0x214(%r14)
leaq 0x3249a(%rip), %rdi # 0x4a032
callq 0x17c9c
testl %eax, %eax
je 0x17bd5
leaq 0x4(%rsp), %rbx
movl $0x82fb, %edi # imm = 0x82FB
movq %rbx, %rsi
callq *0x228(%r14)
movl (%rbx), %eax
testl %eax, %eax
je 0x17bc9
cmpl $0x82fc, %eax # imm = 0x82FC
jne 0x17bd5
movl $0x35001, %eax # imm = 0x35001
jmp 0x17bce
movl $0x35002, %eax # imm = 0x35002
movl %eax, 0x218(%r14)
leaq 0xf775(%rip), %rdi # 0x27351
callq *0x258(%r14)
movl $0x4000, %edi # imm = 0x4000
callq *%rax
movq %r14, %rdi
callq *0x240(%r14)
movq %r15, %rdi
callq 0x17c04
pushq $0x1
popq %rbp
jmp 0x17a10
| /Konf[P]LearnOpenGL-CLion/glfw/src/context.c |
glfwInit | GLFWAPI int glfwInit(void)
{
if (_glfw.initialized)
return GLFW_TRUE;
memset(&_glfw, 0, sizeof(_glfw));
_glfw.hints.init = _glfwInitHints;
if (!_glfwPlatformInit())
{
terminate();
return GLFW_FALSE;
}
if (!_glfwPlatformCreateMutex(&_glfw.errorLock) ||
!_glfwPlatformCreateTls(&_glfw.errorSlot) ||
!_glfwPlatformCreateTls(&_glfw.contextSlot))
{
terminate();
return GLFW_FALSE;
}
_glfwPlatformSetTls(&_glfw.errorSlot, &_glfwMainThreadError);
_glfw.initialized = GLFW_TRUE;
_glfw.timer.offset = _glfwPlatformGetTimerValue();
glfwDefaultWindowHints();
{
int i;
for (i = 0; _glfwDefaultMappings[i]; i++)
{
if (!glfwUpdateGamepadMappings(_glfwDefaultMappings[i]))
{
terminate();
return GLFW_FALSE;
}
}
}
return GLFW_TRUE;
} | pushq %rbp
pushq %r14
pushq %rbx
leaq 0x7320b(%rip), %rbx # 0x8b348
cmpl $0x0, (%rbx)
je 0x1814a
pushq $0x1
popq %rbp
jmp 0x18226
xorl %ebp, %ebp
movl $0x20978, %edx # imm = 0x20978
movq %rbx, %rdi
xorl %esi, %esi
callq 0x130d0
movq 0x3a116(%rip), %rax # 0x52278
movq %rax, 0x8(%rbx)
movl 0x3a114(%rip), %eax # 0x52280
movl %eax, 0x10(%rbx)
callq 0x1d073
testl %eax, %eax
je 0x18221
movl $0x1fe20, %edi # imm = 0x1FE20
addq 0x38e60(%rip), %rdi # 0x50fe8
callq 0x2384c
testl %eax, %eax
je 0x18218
movl $0x1fe0c, %edi # imm = 0x1FE0C
addq 0x38e47(%rip), %rdi # 0x50fe8
callq 0x2377c
testl %eax, %eax
je 0x18218
movl $0x1fe14, %edi # imm = 0x1FE14
addq 0x38e32(%rip), %rdi # 0x50fe8
callq 0x2377c
testl %eax, %eax
je 0x18218
leaq 0x1fe0c(%rbx), %rdi
leaq 0x93af3(%rip), %rsi # 0xabcc0
callq 0x23821
movl $0x1, (%rbx)
callq 0x23723
movq %rax, 0x1fe50(%rbx)
callq 0x1babe
leaq 0x393a0(%rip), %r14 # 0x51590
movq (%r14), %rbx
testq %rbx, %rbx
je 0x1820d
movq %rbx, %rdi
callq 0x1978b
addq $0x8, %r14
testl %eax, %eax
jne 0x181f0
callq 0x1822d
xorl %ebp, %ebp
testq %rbx, %rbx
sete %bpl
jmp 0x18226
callq 0x1822d
xorl %ebp, %ebp
jmp 0x18226
callq 0x1822d
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /Konf[P]LearnOpenGL-CLion/glfw/src/init.c |
glfwInputKey | void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int mods)
{
if (key >= 0 && key <= GLFW_KEY_LAST)
{
GLFWbool repeated = GLFW_FALSE;
if (action == GLFW_RELEASE && window->keys[key] == GLFW_RELEASE)
return;
if (action == GLFW_PRESS && window->keys[key] == GLFW_PRESS)
repeated = GLFW_TRUE;
if (action == GLFW_RELEASE && window->stickyKeys)
window->keys[key] = _GLFW_STICK;
else
window->keys[key] = (char) action;
if (repeated)
action = GLFW_REPEAT;
}
if (!window->lockKeyMods)
mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
if (window->callbacks.key)
window->callbacks.key((GLFWwindow*) window, key, scancode, action, mods);
} | cmpl $0x15c, %esi # imm = 0x15C
ja 0x18467
movl %esi, %eax
cmpl $0x1, %ecx
je 0x18449
testl %ecx, %ecx
jne 0x18460
cmpb $0x0, 0x80(%rdi,%rax)
je 0x18487
cmpl $0x0, 0x68(%rdi)
je 0x18488
movb $0x3, 0x80(%rdi,%rax)
jmp 0x18467
cmpb $0x1, 0x80(%rdi,%rax)
movb $0x1, 0x80(%rdi,%rax)
jne 0x18467
pushq $0x2
popq %rcx
jmp 0x18467
movb %cl, 0x80(%rdi,%rax)
movq 0x318(%rdi), %r9
testq %r9, %r9
je 0x18487
movl %r8d, %eax
andl $-0x31, %eax
cmpl $0x0, 0x70(%rdi)
cmovnel %r8d, %eax
movl %eax, %r8d
jmpq *%r9
retq
movb $0x0, 0x80(%rdi,%rax)
jmp 0x18467
| /Konf[P]LearnOpenGL-CLion/glfw/src/input.c |
glfwCreateCursor | GLFWAPI GLFWcursor* glfwCreateCursor(const GLFWimage* image, int xhot, int yhot)
{
_GLFWcursor* cursor;
assert(image != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
cursor = calloc(1, sizeof(_GLFWcursor));
cursor->next = _glfw.cursorListHead;
_glfw.cursorListHead = cursor;
if (!_glfwPlatformCreateCursor(cursor, image, xhot, yhot))
{
glfwDestroyCursor((GLFWcursor*) cursor);
return NULL;
}
return (GLFWcursor*) cursor;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x18d74
leaq 0x72640(%rip), %r12 # 0x8b348
cmpl $0x0, (%r12)
je 0x18d58
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x13770
movq %rax, %rbx
movq 0x3e0(%r12), %rax
movq %rax, (%rbx)
movq %rbx, 0x3e0(%r12)
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x22db3
testl %eax, %eax
jne 0x18d68
movq %rbx, %rdi
callq 0x18d93
xorl %ebx, %ebx
jmp 0x18d68
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x17f99
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2cc09(%rip), %rdi # 0x45984
leaq 0x2ca1e(%rip), %rsi # 0x457a0
leaq 0x2cc09(%rip), %rcx # 0x45992
movl $0x2bb, %edx # imm = 0x2BB
callq 0x131c0
| /Konf[P]LearnOpenGL-CLion/glfw/src/input.c |
compareVideoModes | static int compareVideoModes(const void* fp, const void* sp)
{
const GLFWvidmode* fm = fp;
const GLFWvidmode* sm = sp;
const int fbpp = fm->redBits + fm->greenBits + fm->blueBits;
const int sbpp = sm->redBits + sm->greenBits + sm->blueBits;
const int farea = fm->width * fm->height;
const int sarea = sm->width * sm->height;
// First sort on color bits per pixel
if (fbpp != sbpp)
return fbpp - sbpp;
// Then sort on screen area
if (farea != sarea)
return farea - sarea;
// Lastly sort on refresh rate
return fm->refreshRate - sm->refreshRate;
} | movl 0xc(%rdi), %eax
addl 0x8(%rdi), %eax
addl 0x10(%rdi), %eax
movl 0xc(%rsi), %ecx
addl 0x8(%rsi), %ecx
addl 0x10(%rsi), %ecx
subl %ecx, %eax
jne 0x1a920
movl 0x4(%rdi), %eax
imull (%rdi), %eax
movl 0x4(%rsi), %ecx
imull (%rsi), %ecx
subl %ecx, %eax
jne 0x1a920
movl 0x14(%rdi), %eax
subl 0x14(%rsi), %eax
retq
| /Konf[P]LearnOpenGL-CLion/glfw/src/monitor.c |
glfwInitVulkan | GLFWbool _glfwInitVulkan(int mode)
{
VkResult err;
VkExtensionProperties* ep;
uint32_t i, count;
if (_glfw.vk.available)
return GLFW_TRUE;
#if !defined(_GLFW_VULKAN_STATIC)
#if defined(_GLFW_VULKAN_LIBRARY)
_glfw.vk.handle = _glfw_dlopen(_GLFW_VULKAN_LIBRARY);
#elif defined(_GLFW_WIN32)
_glfw.vk.handle = _glfw_dlopen("vulkan-1.dll");
#elif defined(_GLFW_COCOA)
_glfw.vk.handle = _glfw_dlopen("libMoltenVK.dylib");
#else
_glfw.vk.handle = _glfw_dlopen("libvulkan.so.1");
#endif
if (!_glfw.vk.handle)
{
if (mode == _GLFW_REQUIRE_LOADER)
_glfwInputError(GLFW_API_UNAVAILABLE, "Vulkan: Loader not found");
return GLFW_FALSE;
}
_glfw.vk.GetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)
_glfw_dlsym(_glfw.vk.handle, "vkGetInstanceProcAddr");
if (!_glfw.vk.GetInstanceProcAddr)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"Vulkan: Loader does not export vkGetInstanceProcAddr");
_glfwTerminateVulkan();
return GLFW_FALSE;
}
_glfw.vk.EnumerateInstanceExtensionProperties = (PFN_vkEnumerateInstanceExtensionProperties)
vkGetInstanceProcAddr(NULL, "vkEnumerateInstanceExtensionProperties");
if (!_glfw.vk.EnumerateInstanceExtensionProperties)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"Vulkan: Failed to retrieve vkEnumerateInstanceExtensionProperties");
_glfwTerminateVulkan();
return GLFW_FALSE;
}
#endif // _GLFW_VULKAN_STATIC
err = vkEnumerateInstanceExtensionProperties(NULL, &count, NULL);
if (err)
{
// NOTE: This happens on systems with a loader but without any Vulkan ICD
if (mode == _GLFW_REQUIRE_LOADER)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"Vulkan: Failed to query instance extension count: %s",
_glfwGetVulkanResultString(err));
}
_glfwTerminateVulkan();
return GLFW_FALSE;
}
ep = calloc(count, sizeof(VkExtensionProperties));
err = vkEnumerateInstanceExtensionProperties(NULL, &count, ep);
if (err)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"Vulkan: Failed to query instance extensions: %s",
_glfwGetVulkanResultString(err));
free(ep);
_glfwTerminateVulkan();
return GLFW_FALSE;
}
for (i = 0; i < count; i++)
{
if (strcmp(ep[i].extensionName, "VK_KHR_surface") == 0)
_glfw.vk.KHR_surface = GLFW_TRUE;
#if defined(_GLFW_WIN32)
else if (strcmp(ep[i].extensionName, "VK_KHR_win32_surface") == 0)
_glfw.vk.KHR_win32_surface = GLFW_TRUE;
#elif defined(_GLFW_COCOA)
else if (strcmp(ep[i].extensionName, "VK_MVK_macos_surface") == 0)
_glfw.vk.MVK_macos_surface = GLFW_TRUE;
#elif defined(_GLFW_X11)
else if (strcmp(ep[i].extensionName, "VK_KHR_xlib_surface") == 0)
_glfw.vk.KHR_xlib_surface = GLFW_TRUE;
else if (strcmp(ep[i].extensionName, "VK_KHR_xcb_surface") == 0)
_glfw.vk.KHR_xcb_surface = GLFW_TRUE;
#elif defined(_GLFW_WAYLAND)
else if (strcmp(ep[i].extensionName, "VK_KHR_wayland_surface") == 0)
_glfw.vk.KHR_wayland_surface = GLFW_TRUE;
#elif defined(_GLFW_MIR)
else if (strcmp(ep[i].extensionName, "VK_KHR_mir_surface") == 0)
_glfw.vk.KHR_mir_surface = GLFW_TRUE;
#endif
}
free(ep);
_glfw.vk.available = GLFW_TRUE;
_glfwPlatformGetRequiredInstanceExtensions(_glfw.vk.extensions);
return GLFW_TRUE;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x702fe(%rip), %rbx # 0x8b348
cmpl $0x0, 0x1fe68(%rbx)
je 0x1b05c
pushq $0x1
popq %r14
jmp 0x1b134
movl %edi, %r15d
leaq 0x2b332(%rip), %rdi # 0x46398
pushq $0x1
popq %rsi
callq 0x13520
movq %rax, 0x1fe70(%rbx)
testq %rax, %rax
je 0x1b0ef
leaq 0x2b35e(%rip), %rsi # 0x463df
movq %rax, %rdi
callq 0x13890
movq %rax, 0x1fe90(%rbx)
testq %rax, %rax
je 0x1b110
leaq 0x2b374(%rip), %rsi # 0x46410
xorl %r14d, %r14d
xorl %edi, %edi
callq *%rax
movq %rax, 0x1fe88(%rbx)
testq %rax, %rax
je 0x1b11c
leaq 0x4(%rsp), %rsi
xorl %edi, %edi
xorl %edx, %edx
callq *%rax
testl %eax, %eax
je 0x1b146
cmpl $0x2, %r15d
jne 0x1b0e5
movl %eax, %edi
callq 0x1b259
leaq 0x2b361(%rip), %rsi # 0x46437
movl $0x10006, %edi # imm = 0x10006
movq %rax, %rdx
xorl %eax, %eax
callq 0x17f99
callq 0x1b241
xorl %r14d, %r14d
jmp 0x1b134
xorl %r14d, %r14d
cmpl $0x2, %r15d
jne 0x1b134
leaq 0x2b2a8(%rip), %rsi # 0x463a7
xorl %r14d, %r14d
movl $0x10006, %edi # imm = 0x10006
xorl %eax, %eax
callq 0x17f99
jmp 0x1b134
leaq 0x2b2a9(%rip), %rsi # 0x463c0
xorl %r14d, %r14d
jmp 0x1b123
leaq 0x2b2d2(%rip), %rsi # 0x463f5
movl $0x10006, %edi # imm = 0x10006
xorl %eax, %eax
callq 0x17f99
callq 0x1b241
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4(%rsp), %r12
movl (%r12), %edi
movl $0x104, %esi # imm = 0x104
callq 0x13770
movq %rax, %r15
xorl %r14d, %r14d
xorl %edi, %edi
movq %r12, %rsi
movq %rax, %rdx
callq *0x1fe88(%rbx)
testl %eax, %eax
je 0x1b198
movl %eax, %edi
callq 0x1b259
leaq 0x2b2ed(%rip), %rsi # 0x4646c
movl $0x10006, %edi # imm = 0x10006
movq %rax, %rdx
xorl %eax, %eax
callq 0x17f99
movq %r15, %rdi
callq 0x133b0
jmp 0x1b12f
movl 0x4(%rsp), %eax
imulq $0x104, %rax, %r12 # imm = 0x104
xorl %ebp, %ebp
leaq 0x2b2f0(%rip), %r14 # 0x4649c
cmpq %rbp, %r12
je 0x1b215
leaq (%r15,%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x13680
testl %eax, %eax
je 0x1b1f6
movq %r13, %rdi
leaq 0x2b2dd(%rip), %rsi # 0x464ab
callq 0x13680
testl %eax, %eax
je 0x1b202
movq %r13, %rdi
leaq 0x2b2de(%rip), %rsi # 0x464bf
callq 0x13680
testl %eax, %eax
jne 0x1b20c
movl $0x1, 0x1fea0(%rbx)
jmp 0x1b20c
movl $0x1, 0x1fe98(%rbx)
jmp 0x1b20c
movl $0x1, 0x1fe9c(%rbx)
addq $0x104, %rbp # imm = 0x104
jmp 0x1b1ac
movq %r15, %rdi
callq 0x133b0
movl $0x1, 0x1fe68(%rbx)
addq $0x1fe78, %rbx # imm = 0x1FE78
movq %rbx, %rdi
callq 0x231f6
pushq $0x1
popq %rax
movl %eax, %r14d
jmp 0x1b134
| /Konf[P]LearnOpenGL-CLion/glfw/src/vulkan.c |
glfwInputWindowFocus | void _glfwInputWindowFocus(_GLFWwindow* window, GLFWbool focused)
{
if (window->callbacks.focus)
window->callbacks.focus((GLFWwindow*) window, focused);
if (!focused)
{
int key, button;
for (key = 0; key <= GLFW_KEY_LAST; key++)
{
if (window->keys[key] == GLFW_PRESS)
{
const int scancode = _glfwPlatformGetKeyScancode(key);
_glfwInputKey(window, key, scancode, GLFW_RELEASE, 0);
}
}
for (button = 0; button <= GLFW_MOUSE_BUTTON_LAST; button++)
{
if (window->mouseButtons[button] == GLFW_PRESS)
_glfwInputMouseClick(window, button, GLFW_RELEASE, 0);
}
}
} | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x2d0(%rdi), %rax
testq %rax, %rax
je 0x1b6a8
movq %rbx, %rdi
movl %ebp, %esi
callq *%rax
testl %ebp, %ebp
je 0x1b6b1
popq %rbx
popq %r14
popq %rbp
retq
xorl %r14d, %r14d
cmpq $0x15d, %r14 # imm = 0x15D
je 0x1b6e7
cmpb $0x1, 0x80(%rbx,%r14)
jne 0x1b6e2
movl %r14d, %edi
callq 0x22da0
movq %rbx, %rdi
movl %r14d, %esi
movl %eax, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1841c
incq %r14
jmp 0x1b6b4
xorl %r14d, %r14d
cmpq $0x8, %r14
je 0x1b6ac
cmpb $0x1, 0x78(%rbx,%r14)
jne 0x1b707
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x18501
incq %r14
jmp 0x1b6ea
| /Konf[P]LearnOpenGL-CLion/glfw/src/window.c |
glfwCreateWindow | GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,
const char* title,
GLFWmonitor* monitor,
GLFWwindow* share)
{
_GLFWfbconfig fbconfig;
_GLFWctxconfig ctxconfig;
_GLFWwndconfig wndconfig;
_GLFWwindow* window;
assert(title != NULL);
assert(width >= 0);
assert(height >= 0);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (width <= 0 || height <= 0)
{
_glfwInputError(GLFW_INVALID_VALUE,
"Invalid window size %ix%i",
width, height);
return NULL;
}
fbconfig = _glfw.hints.framebuffer;
ctxconfig = _glfw.hints.context;
wndconfig = _glfw.hints.window;
wndconfig.width = width;
wndconfig.height = height;
wndconfig.title = title;
ctxconfig.share = (_GLFWwindow*) share;
if (!_glfwIsValidContextConfig(&ctxconfig))
return NULL;
window = calloc(1, sizeof(_GLFWwindow));
window->next = _glfw.windowListHead;
_glfw.windowListHead = window;
window->videoMode.width = width;
window->videoMode.height = height;
window->videoMode.redBits = fbconfig.redBits;
window->videoMode.greenBits = fbconfig.greenBits;
window->videoMode.blueBits = fbconfig.blueBits;
window->videoMode.refreshRate = _glfw.hints.refreshRate;
window->monitor = (_GLFWmonitor*) monitor;
window->resizable = wndconfig.resizable;
window->decorated = wndconfig.decorated;
window->autoIconify = wndconfig.autoIconify;
window->floating = wndconfig.floating;
window->cursorMode = GLFW_CURSOR_NORMAL;
window->minwidth = GLFW_DONT_CARE;
window->minheight = GLFW_DONT_CARE;
window->maxwidth = GLFW_DONT_CARE;
window->maxheight = GLFW_DONT_CARE;
window->numer = GLFW_DONT_CARE;
window->denom = GLFW_DONT_CARE;
// Open the actual window and create its context
if (!_glfwPlatformCreateWindow(window, &wndconfig, &ctxconfig, &fbconfig))
{
glfwDestroyWindow((GLFWwindow*) window);
return NULL;
}
if (ctxconfig.client != GLFW_NO_API)
{
if (!_glfwRefreshContextAttribs(window, &ctxconfig))
{
glfwDestroyWindow((GLFWwindow*) window);
return NULL;
}
}
if (window->monitor)
{
if (wndconfig.centerCursor)
{
int width, height;
_glfwPlatformGetWindowSize(window, &width, &height);
_glfwPlatformSetCursorPos(window, width / 2.0, height / 2.0);
}
}
else
{
if (wndconfig.visible)
{
_glfwPlatformShowWindow(window);
if (wndconfig.focused)
_glfwPlatformFocusWindow(window);
}
}
return (GLFWwindow*) window;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3d8, %rsp # imm = 0x3D8
testq %rdx, %rdx
je 0x1b9dd
movl %edi, %r15d
testl %edi, %edi
js 0x1b9fc
movl %esi, %ebp
testl %esi, %esi
js 0x1ba1b
leaq 0x6fb82(%rip), %r14 # 0x8b348
cmpl $0x0, (%r14)
je 0x1b7fd
movq %rdx, %r12
testl %r15d, %r15d
setne %al
testl %ebp, %ebp
setne %dl
testb %dl, %al
jne 0x1b812
leaq 0x2b61f(%rip), %rsi # 0x46e04
xorl %ebx, %ebx
movl $0x10004, %edi # imm = 0x10004
movl %r15d, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x17f99
jmp 0x1b9a2
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x17f99
jmp 0x1b9a2
movq %rcx, 0x8(%rsp)
leaq 0x18(%r14), %rsi
pushq $0x9
popq %rcx
leaq 0x58(%rsp), %rdi
rep movsq (%rsi), %es:(%rdi)
movq 0x3c8(%r14), %rax
leaq 0x20(%rsp), %r13
movq %rax, 0x30(%r13)
movdqu 0x398(%r14), %xmm0
movupd 0x3a8(%r14), %xmm1
movupd 0x3b8(%r14), %xmm2
movapd %xmm2, 0x20(%r13)
movapd %xmm1, 0x10(%r13)
movdqa %xmm0, (%r13)
leaq 0x60(%r14), %rsi
leaq 0xa0(%rsp), %rbx
movl $0x338, %edx # imm = 0x338
movq %rbx, %rdi
movq %r8, 0x10(%rsp)
callq 0x13960
movl %r15d, (%rbx)
movl %ebp, 0x4(%rbx)
movq %r12, 0x8(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%r13)
movq %r13, %rdi
callq 0x174a4
testl %eax, %eax
je 0x1b9a0
pushq $0x1
popq %rdi
movl $0x388, %esi # imm = 0x388
callq 0x13770
movq %rax, %rbx
movq 0x3e8(%r14), %rax
movq %rax, (%rbx)
movq %rbx, 0x3e8(%r14)
movl %r15d, 0x28(%rbx)
movl %ebp, 0x2c(%rbx)
leaq 0x58(%rsp), %rcx
movq (%rcx), %rax
movq %rax, 0x30(%rbx)
movl 0x8(%rcx), %eax
movl %eax, 0x38(%rbx)
movl 0x3d0(%r14), %eax
movl %eax, 0x3c(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rbx)
leaq 0xa0(%rsp), %rsi
movl 0x10(%rsi), %eax
movl %eax, 0x8(%rbx)
movl 0x18(%rsi), %eax
movl %eax, 0xc(%rbx)
movq 0x20(%rsi), %rax
movq %rax, 0x10(%rbx)
movl $0x34001, 0x74(%rbx) # imm = 0x34001
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x50(%rbx)
orq $-0x1, 0x60(%rbx)
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x1ffff
testl %eax, %eax
je 0x1b998
cmpl $0x0, 0x20(%rsp)
je 0x1b94b
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x17868
testl %eax, %eax
je 0x1b998
cmpq $0x0, 0x40(%rbx)
je 0x1b9b7
cmpl $0x0, 0xcc(%rsp)
je 0x1b9a2
leaq 0x1c(%rsp), %r14
leaq 0x18(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x20d19
cvtsi2sdl (%r14), %xmm0
movsd 0x2b277(%rip), %xmm2 # 0x46bf8
mulsd %xmm2, %xmm0
cvtsi2sdl (%r15), %xmm1
mulsd %xmm2, %xmm1
movq %rbx, %rdi
callq 0x228d2
jmp 0x1b9a2
movq %rbx, %rdi
callq 0x1ba3a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x3d8, %rsp # imm = 0x3D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, 0xb4(%rsp)
je 0x1b9a2
movq %rbx, %rdi
callq 0x205b4
cmpl $0x0, 0xbc(%rsp)
je 0x1b9a2
movq %rbx, %rdi
callq 0x213ea
jmp 0x1b9a2
leaq 0x2b34c(%rip), %rdi # 0x46d30
leaq 0x2b353(%rip), %rsi # 0x46d3e
leaq 0x2b3a9(%rip), %rcx # 0x46d9b
movl $0xa1, %edx
callq 0x131c0
leaq 0x2b3ea(%rip), %rdi # 0x46ded
leaq 0x2b334(%rip), %rsi # 0x46d3e
leaq 0x2b38a(%rip), %rcx # 0x46d9b
movl $0xa2, %edx
callq 0x131c0
leaq 0x2b3d6(%rip), %rdi # 0x46df8
leaq 0x2b315(%rip), %rsi # 0x46d3e
leaq 0x2b36b(%rip), %rcx # 0x46d9b
movl $0xa3, %edx
callq 0x131c0
| /Konf[P]LearnOpenGL-CLion/glfw/src/window.c |
glfwSetWindowIcon | GLFWAPI void glfwSetWindowIcon(GLFWwindow* handle,
int count, const GLFWimage* images)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
assert(count >= 0);
assert(count == 0 || images != NULL);
_GLFW_REQUIRE_INIT();
_glfwPlatformSetWindowIcon(window, count, images);
} | pushq %rax
testq %rdi, %rdi
je 0x1beff
testl %esi, %esi
js 0x1bf1e
sete %al
testq %rdx, %rdx
setne %cl
orb %al, %cl
je 0x1bf3d
leaq 0x6f463(%rip), %rax # 0x8b348
cmpl $0x0, (%rax)
je 0x1bef0
popq %rax
jmp 0x20a7c
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
popq %rcx
jmp 0x17f99
leaq 0xe280(%rip), %rdi # 0x2a186
leaq 0x2ae31(%rip), %rsi # 0x46d3e
leaq 0x2b00f(%rip), %rcx # 0x46f23
movl $0x1f5, %edx # imm = 0x1F5
callq 0x131c0
leaq 0x2b03b(%rip), %rdi # 0x46f60
leaq 0x2ae12(%rip), %rsi # 0x46d3e
leaq 0x2aff0(%rip), %rcx # 0x46f23
movl $0x1f6, %edx # imm = 0x1F6
callq 0x131c0
leaq 0x2b027(%rip), %rdi # 0x46f6b
leaq 0x2adf3(%rip), %rsi # 0x46d3e
leaq 0x2afd1(%rip), %rcx # 0x46f23
movl $0x1f7, %edx # imm = 0x1F7
callq 0x131c0
| /Konf[P]LearnOpenGL-CLion/glfw/src/window.c |
glfwGetWindowSize | GLFWAPI void glfwGetWindowSize(GLFWwindow* handle, int* width, int* height)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (width)
*width = 0;
if (height)
*height = 0;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetWindowSize(window, width, height);
} | testq %rdi, %rdi
je 0x1c02f
testq %rsi, %rsi
je 0x1c008
andl $0x0, (%rsi)
testq %rdx, %rdx
je 0x1c010
andl $0x0, (%rdx)
leaq 0x6f331(%rip), %rax # 0x8b348
cmpl $0x0, (%rax)
je 0x1c021
jmp 0x20d19
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x17f99
pushq %rax
leaq 0xe14f(%rip), %rdi # 0x2a186
leaq 0x2ad00(%rip), %rsi # 0x46d3e
leaq 0x2afa3(%rip), %rcx # 0x46fe8
movl $0x21b, %edx # imm = 0x21B
callq 0x131c0
| /Konf[P]LearnOpenGL-CLion/glfw/src/window.c |
glfwCreateCursorX11 | Cursor _glfwCreateCursorX11(const GLFWimage* image, int xhot, int yhot)
{
int i;
Cursor cursor;
if (!_glfw.x11.xcursor.handle)
return None;
XcursorImage* native = XcursorImageCreate(image->width, image->height);
if (native == NULL)
return None;
native->xhot = xhot;
native->yhot = yhot;
unsigned char* source = (unsigned char*) image->pixels;
XcursorPixel* target = native->pixels;
for (i = 0; i < image->width * image->height; i++, target++, source += 4)
{
unsigned int alpha = source[3];
*target = (alpha << 24) |
((unsigned char) ((source[0] * alpha) / 255) << 16) |
((unsigned char) ((source[1] * alpha) / 255) << 8) |
((unsigned char) ((source[2] * alpha) / 255) << 0);
}
cursor = XcursorImageLoadCursor(_glfw.x11.display, native);
XcursorImageDestroy(native);
return cursor;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x6e3b7(%rip), %r12 # 0x8b348
cmpq $0x0, 0x20650(%r12)
je 0x1d042
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movl (%rdi), %edi
movl 0x4(%rbx), %esi
callq *0x20658(%r12)
testq %rax, %rax
je 0x1d042
movq %rax, %r14
movl %r15d, 0x10(%rax)
movl %ebp, 0x14(%rax)
movq 0x8(%rbx), %rsi
movq 0x20(%rax), %rdi
movw $0xff, %r8w
xorl %r9d, %r9d
movl 0x4(%rbx), %eax
imull (%rbx), %eax
cmpl %eax, %r9d
jge 0x1d046
movzbl 0x3(%rsi,%r9,4), %r10d
movzbl (%rsi,%r9,4), %eax
imull %r10d, %eax
xorl %edx, %edx
divw %r8w
movl %eax, %ecx
movzbl 0x1(%rsi,%r9,4), %eax
imull %r10d, %eax
xorl %edx, %edx
divw %r8w
movzbl 0x2(%rsi,%r9,4), %edx
imull %r10d, %edx
shll $0x18, %r10d
movzbl %cl, %ecx
shll $0x10, %ecx
orl %r10d, %ecx
shll $0x8, %eax
movzwl %ax, %r10d
orl %ecx, %r10d
movl %edx, %eax
xorl %edx, %edx
divw %r8w
movzwl %ax, %eax
addl %r10d, %eax
movl %eax, (%rdi,%r9,4)
incq %r9
jmp 0x1cfd8
xorl %eax, %eax
jmp 0x1d06a
movq 0x1feb8(%r12), %rdi
movq %r14, %rsi
callq *0x20668(%r12)
movq %rax, %rbx
movq %r14, %rdi
callq *0x20660(%r12)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /Konf[P]LearnOpenGL-CLion/glfw/src/x11_init.c |
glfwRestoreVideoModeX11 | void _glfwRestoreVideoModeX11(_GLFWmonitor* monitor)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRScreenResources* sr;
XRRCrtcInfo* ci;
if (monitor->x11.oldMode == None)
return;
sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
XRRSetCrtcConfig(_glfw.x11.display,
sr, monitor->x11.crtc,
CurrentTime,
ci->x, ci->y,
monitor->x11.oldMode,
ci->rotation,
ci->outputs,
ci->noutput);
XRRFreeCrtcInfo(ci);
XRRFreeScreenResources(sr);
monitor->x11.oldMode = None;
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x6bf0d(%rip), %r12 # 0x8b348
cmpl $0x0, 0x20558(%r12)
je 0x1f4fd
cmpl $0x0, 0x2057c(%r12)
jne 0x1f4fd
movq %rdi, %rbx
cmpq $0x0, 0x98(%rdi)
je 0x1f4fd
movq 0x1feb8(%r12), %rdi
movq 0x1fec8(%r12), %rsi
callq *0x205d0(%r12)
movq %rax, %r14
movq 0x1feb8(%r12), %rdi
movq 0x90(%rbx), %rdx
movq %rax, %rsi
callq *0x205b8(%r12)
movq %rax, %r15
movq 0x1feb8(%r12), %rdi
movl 0x8(%rax), %r8d
movl 0xc(%rax), %r9d
movq 0x90(%rbx), %rdx
movzwl 0x20(%rax), %eax
movl 0x24(%r15), %r10d
movq %r14, %rsi
xorl %ecx, %ecx
pushq %r10
pushq 0x28(%r15)
pushq %rax
pushq 0x98(%rbx)
callq *0x205f0(%r12)
addq $0x20, %rsp
movq %r15, %rdi
callq *0x20588(%r12)
movq %r14, %rdi
callq *0x205a0(%r12)
andq $0x0, 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /Konf[P]LearnOpenGL-CLion/glfw/src/x11_monitor.c |
glfwPlatformGetGammaRamp | void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.gammaBroken)
{
const size_t size = XRRGetCrtcGammaSize(_glfw.x11.display,
monitor->x11.crtc);
XRRCrtcGamma* gamma = XRRGetCrtcGamma(_glfw.x11.display,
monitor->x11.crtc);
_glfwAllocGammaArrays(ramp, size);
memcpy(ramp->red, gamma->red, size * sizeof(unsigned short));
memcpy(ramp->green, gamma->green, size * sizeof(unsigned short));
memcpy(ramp->blue, gamma->blue, size * sizeof(unsigned short));
XRRFreeGamma(gamma);
}
else if (_glfw.x11.vidmode.available)
{
int size;
XF86VidModeGetGammaRampSize(_glfw.x11.display, _glfw.x11.screen, &size);
_glfwAllocGammaArrays(ramp, size);
XF86VidModeGetGammaRamp(_glfw.x11.display,
_glfw.x11.screen,
ramp->size, ramp->red, ramp->green, ramp->blue);
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x6bbc0(%rip), %rax # 0x8b348
cmpl $0x0, 0x20558(%rax)
je 0x1f82d
cmpl $0x0, 0x20578(%rax)
jne 0x1f82d
movq %rdi, %r15
movq 0x1feb8(%rax), %rdi
movq 0x90(%r15), %rsi
movq %rax, %r12
callq *0x205b0(%rax)
movslq %eax, %r14
movq 0x1feb8(%r12), %rdi
movq 0x90(%r15), %rsi
callq *0x205a8(%r12)
movq %rax, %r15
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1a726
movq (%rbx), %rdi
movq 0x8(%r15), %rsi
addq %r14, %r14
movq %r14, %rdx
callq 0x13960
movq 0x8(%rbx), %rdi
movq 0x10(%r15), %rsi
movq %r14, %rdx
callq 0x13960
movq 0x10(%rbx), %rdi
movq 0x18(%r15), %rsi
movq %r14, %rdx
callq 0x13960
movq %r15, %rdi
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *0x20590(%rax)
cmpl $0x0, 0x206b0(%rax)
je 0x1f882
movq 0x1feb8(%rax), %rdi
movl 0x1fec0(%rax), %esi
leaq 0x4(%rsp), %r14
movq %r14, %rdx
movq %rax, %r15
callq *0x206e0(%rax)
movl (%r14), %esi
movq %rbx, %rdi
callq 0x1a726
movq 0x1feb8(%r15), %rdi
movl 0x1fec0(%r15), %esi
movl 0x18(%rbx), %edx
movq (%rbx), %rcx
movq 0x8(%rbx), %r8
movq 0x10(%rbx), %r9
callq *0x206d0(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /Konf[P]LearnOpenGL-CLion/glfw/src/x11_monitor.c |
glfwPlatformSetWindowMonitor | void _glfwPlatformSetWindowMonitor(_GLFWwindow* window,
_GLFWmonitor* monitor,
int xpos, int ypos,
int width, int height,
int refreshRate)
{
if (window->monitor == monitor)
{
if (monitor)
{
if (monitor->window == window)
acquireMonitor(window);
}
else
{
XMoveResizeWindow(_glfw.x11.display, window->x11.handle,
xpos, ypos, width, height);
}
return;
}
if (window->monitor)
releaseMonitor(window);
_glfwInputWindowMonitor(window, monitor);
updateNormalHints(window, width, height);
updateWindowMode(window);
if (window->monitor)
{
XMapRaised(_glfw.x11.display, window->x11.handle);
if (waitForVisibilityNotify(window))
acquireMonitor(window);
}
else
{
XMoveResizeWindow(_glfw.x11.display, window->x11.handle,
xpos, ypos, width, height);
}
XFlush(_glfw.x11.display);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rbx
movq 0x40(%rdi), %rax
cmpq %rsi, %rax
je 0x214e1
testq %rax, %rax
je 0x2148a
movq %rbx, %rdi
callq 0x20934
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1b78b
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x20dd7
movq %rbx, %rdi
callq 0x205e6
cmpq $0x0, 0x40(%rbx)
leaq 0x69e92(%rip), %r13 # 0x8b348
movq 0x1feb8(%r13), %rdi
movq 0x340(%rbx), %rsi
je 0x214fb
callq 0x13900
movq %rbx, %rdi
callq 0x212d5
testl %eax, %eax
je 0x2150c
movq %rbx, %rdi
callq 0x20775
jmp 0x2150c
testq %r13, %r13
je 0x21526
cmpq %rbx, 0x18(%r13)
je 0x2155a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r12d, %edx
movl %r15d, %ecx
movl %r14d, %r8d
movl %ebp, %r9d
callq 0x134a0
movq 0x1feb8(%r13), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13610
leaq 0x69e1b(%rip), %rax # 0x8b348
movq 0x1feb8(%rax), %rdi
movq 0x340(%rbx), %rsi
movl %r12d, %edx
movl %r15d, %ecx
movl %r14d, %r8d
movl %ebp, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x134a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20775
| /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
updateCursorImage | static void updateCursorImage(_GLFWwindow* window)
{
if (window->cursorMode == GLFW_CURSOR_NORMAL)
{
if (window->cursor)
{
XDefineCursor(_glfw.x11.display, window->x11.handle,
window->cursor->x11.handle);
}
else
XUndefineCursor(_glfw.x11.display, window->x11.handle);
}
else
{
XDefineCursor(_glfw.x11.display, window->x11.handle,
_glfw.x11.hiddenCursorHandle);
}
} | cmpl $0x34001, 0x74(%rdi) # imm = 0x34001
jne 0x22c64
movq 0x48(%rdi), %rcx
leaq 0x68703(%rip), %rax # 0x8b348
movq 0x1feb8(%rax), %rax
movq 0x340(%rdi), %rsi
testq %rcx, %rcx
je 0x22c85
movq 0x8(%rcx), %rdx
movq %rax, %rdi
jmp 0x13760
leaq 0x686dd(%rip), %rax # 0x8b348
movq 0x340(%rdi), %rsi
movq 0x1feb8(%rax), %rdi
movq 0x1fee0(%rax), %rdx
jmp 0x13760
movq %rax, %rdi
jmp 0x137d0
| /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformGetTimerValue | uint64_t _glfwPlatformGetTimerValue(void)
{
#if defined(CLOCK_MONOTONIC)
if (_glfw.timer.posix.monotonic)
{
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return (uint64_t) ts.tv_sec * (uint64_t) 1000000000 + (uint64_t) ts.tv_nsec;
}
else
#endif
{
struct timeval tv;
gettimeofday(&tv, NULL);
return (uint64_t) tv.tv_sec * (uint64_t) 1000000 + (uint64_t) tv.tv_usec;
}
} | pushq %rbx
subq $0x10, %rsp
leaq 0x67c19(%rip), %rax # 0x8b348
cmpl $0x0, 0x1fe58(%rax)
je 0x2374f
pushq $0x1
popq %rdi
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x13130
imulq $0x3b9aca00, (%rbx), %rax # imm = 0x3B9ACA00
jmp 0x23763
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x131f0
imulq $0xf4240, (%rbx), %rax # imm = 0xF4240
addq 0x8(%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
| /Konf[P]LearnOpenGL-CLion/glfw/src/posix_time.c |
makeContextCurrentGLX | static void makeContextCurrentGLX(_GLFWwindow* window)
{
if (window)
{
if (!glXMakeCurrent(_glfw.x11.display,
window->context.glx.window,
window->context.glx.handle))
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"GLX: Failed to make context current");
return;
}
}
else
{
if (!glXMakeCurrent(_glfw.x11.display, None, NULL))
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"GLX: Failed to clear current context");
return;
}
}
_glfwPlatformSetTls(&_glfw.contextSlot, window);
} | pushq %rbx
movq %rdi, %rbx
leaq 0x66df8(%rip), %rcx # 0x8b348
movq 0x207a0(%rcx), %rax
movq 0x1feb8(%rcx), %rdi
testq %rbx, %rbx
je 0x24580
movq 0x268(%rbx), %rdx
movq 0x270(%rbx), %rsi
callq *%rax
testl %eax, %eax
jne 0x2458a
leaq 0x25870(%rip), %rsi # 0x49dee
jmp 0x245a6
xorl %esi, %esi
xorl %edx, %edx
callq *%rax
testl %eax, %eax
je 0x2459f
movl $0x1fe14, %edi # imm = 0x1FE14
addq 0x2ca52(%rip), %rdi # 0x50fe8
movq %rbx, %rsi
popq %rbx
jmp 0x23821
leaq 0x2586c(%rip), %rsi # 0x49e12
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
popq %rbx
jmp 0x17f99
| /Konf[P]LearnOpenGL-CLion/glfw/src/glx_context.c |
destroyContextOSMesa | static void destroyContextOSMesa(_GLFWwindow* window)
{
if (window->context.osmesa.handle)
{
OSMesaDestroyContext(window->context.osmesa.handle);
window->context.osmesa.handle = NULL;
}
if (window->context.osmesa.buffer)
{
free(window->context.osmesa.buffer);
window->context.osmesa.width = 0;
window->context.osmesa.height = 0;
}
} | pushq %rbx
movq %rdi, %rbx
movq 0x298(%rdi), %rdi
testq %rdi, %rdi
je 0x25b5e
leaq 0x657f8(%rip), %rax # 0x8b348
callq *0x20950(%rax)
andq $0x0, 0x298(%rbx)
movq 0x2a8(%rbx), %rdi
testq %rdi, %rdi
je 0x25b77
callq 0x133b0
andq $0x0, 0x2a0(%rbx)
popq %rbx
retq
| /Konf[P]LearnOpenGL-CLion/glfw/src/osmesa_context.c |
handleAbsEvent | static void handleAbsEvent(_GLFWjoystick* js, int code, int value)
{
const int index = js->linjs.absMap[code];
if (code >= ABS_HAT0X && code <= ABS_HAT3Y)
{
static const char stateMap[3][3] =
{
{ GLFW_HAT_CENTERED, GLFW_HAT_UP, GLFW_HAT_DOWN },
{ GLFW_HAT_LEFT, GLFW_HAT_LEFT_UP, GLFW_HAT_LEFT_DOWN },
{ GLFW_HAT_RIGHT, GLFW_HAT_RIGHT_UP, GLFW_HAT_RIGHT_DOWN },
};
const int hat = (code - ABS_HAT0X) / 2;
const int axis = (code - ABS_HAT0X) % 2;
int* state = js->linjs.hats[hat];
// NOTE: Looking at several input drivers, it seems all hat events use
// -1 for left / up, 0 for centered and 1 for right / down
if (value == 0)
state[axis] = 0;
else if (value < 0)
state[axis] = 1;
else if (value > 0)
state[axis] = 2;
_glfwInputJoystickHat(js, index, stateMap[state[0]][state[1]]);
}
else
{
const struct input_absinfo* info = &js->linjs.absInfo[code];
float normalized = value;
const int range = info->maximum - info->minimum;
if (range)
{
// Normalize to 0.0 -> 1.0
normalized = (normalized - info->minimum) / range;
// Normalize to -1.0 -> 1.0
normalized = normalized * 2.0f - 1.0f;
}
_glfwInputJoystickAxis(js, index, normalized);
}
} | movl %esi, %eax
movslq %esi, %rcx
movl 0x187c(%rdi,%rcx,4), %esi
movl %ecx, %r8d
andl $-0x8, %r8d
cmpl $0x10, %r8d
jne 0x266b7
leal -0x10(%rax), %ecx
shrl %ecx
andl $0x1, %eax
leaq (%rdi,%rcx,8), %rcx
addq $0x1f7c, %rcx # imm = 0x1F7C
movl %eax, %eax
testl %edx, %edx
je 0x266f6
js 0x266fc
movl $0x2, (%rcx,%rax,4)
jmp 0x26703
cvtsi2ss %edx, %xmm0
imulq $0x18, %rcx, %rax
movl 0x1980(%rdi,%rax), %ecx
movl 0x1984(%rdi,%rax), %eax
subl %ecx, %eax
je 0x185ca
cvtsi2ss %ecx, %xmm1
subss %xmm1, %xmm0
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
addss %xmm0, %xmm0
addss 0x1f087(%rip), %xmm0 # 0x45778
jmp 0x185ca
andl $0x0, (%rcx,%rax,4)
jmp 0x26703
movl $0x1, (%rcx,%rax,4)
movslq (%rcx), %rax
movslq 0x4(%rcx), %rcx
leaq (%rax,%rax,2), %rax
leaq 0x242f6(%rip), %rdx # 0x4aa0b
addq %rax, %rdx
movsbl (%rcx,%rdx), %edx
jmp 0x185e2
| /Konf[P]LearnOpenGL-CLion/glfw/src/linux_joystick.c |
(anonymous namespace)::readOrDie[abi:cxx11](llvm::StringRef) | std::string readOrDie(llvm::StringRef Path) {
llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
llvm::MemoryBuffer::getFile(Path);
if (std::error_code EC = Text.getError()) {
llvm::errs() << "Error: can't read grammar file '" << Path
<< "': " << EC.message() << "\n";
::exit(1);
}
return Text.get()->getBuffer().str();
} | subq $0xc8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb0(%rsp)
movq %rdx, 0xb8(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x11ff0
leaq 0x6e(%rsp), %rdi
callq 0x12040
leaq 0x98(%rsp), %rdi
leaq 0x70(%rsp), %rsi
xorl %r8d, %r8d
movl $0x1, %ecx
movl %r8d, %edx
movzwl 0x6e(%rsp), %r9d
callq 0x47e00
leaq 0x98(%rsp), %rdi
callq 0x12060
movl %eax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x8ac0
testb $0x1, %al
jne 0x8824
jmp 0x88b7
callq 0x5f4b0
movq %rax, %rdi
leaq 0x859d8(%rip), %rsi # 0x8e20b
callq 0x8be0
movq %rax, %rdi
movq 0xb0(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x120c0
movq %rax, %rdi
leaq 0x859be(%rip), %rsi # 0x8e22c
callq 0x8be0
movq %rax, (%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x8ae0
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x89c0
movq %rax, %rdi
leaq 0x87b8e(%rip), %rsi # 0x9042c
callq 0x8be0
leaq 0x28(%rsp), %rdi
callq 0x7290
movl $0x1, %edi
callq 0x74b0
leaq 0x98(%rsp), %rdi
callq 0x12180
movq %rax, %rdi
callq 0x12190
movq %rax, %rdi
callq 0x121a0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x121e0
leaq 0x98(%rsp), %rdi
callq 0x12270
movq 0x10(%rsp), %rax
addq $0xc8, %rsp
retq
nopw (%rax,%rax)
| /gen/Main.cpp |
llvm::formatv_object<decltype(std::make_tuple(support::detail::build_format_adapter(std::forward<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(fp0)), support::detail::build_format_adapter(std::forward<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(fp0)), support::detail::build_format_adapter(std::forward<unsigned short&>(fp0))))> llvm::formatv<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned short&>(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, unsigned short&) | inline auto formatv(const char *Fmt, Ts &&...Vals)
-> formatv_object<decltype(std::make_tuple(
support::detail::build_format_adapter(std::forward<Ts>(Vals))...))> {
using ParamTuple = decltype(std::make_tuple(
support::detail::build_format_adapter(std::forward<Ts>(Vals))...));
return formatv_object<ParamTuple>(
Fmt, std::make_tuple(support::detail::build_format_adapter(
std::forward<Ts>(Vals))...));
} | subq $0x108, %rsp # imm = 0x108
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq %rdx, 0xf0(%rsp)
movq %rcx, 0xe8(%rsp)
movq %r8, 0xe0(%rsp)
movq 0xf8(%rsp), %rsi
leaq 0xd0(%rsp), %rdi
callq 0x7b90
movq 0xf0(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x16e40
movq 0xe8(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x16e40
movq 0xe0(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x16e70
leaq 0x70(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x20(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x17ef0
movq (%rsp), %rdi
movq 0xd0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
leaq 0x70(%rsp), %rcx
callq 0x17f30
leaq 0x70(%rsp), %rdi
callq 0x13260
leaq 0x10(%rsp), %rdi
callq 0x130d0
leaq 0x20(%rsp), %rdi
callq 0x12e40
leaq 0x48(%rsp), %rdi
callq 0x12e40
movq 0x8(%rsp), %rax
addq $0x108, %rsp # imm = 0x108
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /llvm/Support/FormatVariadic.h |
llvm::cl::parser<(anonymous namespace)::EmitType>::OptionInfo const* llvm::SmallVectorTemplateCommon<llvm::cl::parser<(anonymous namespace)::EmitType>::OptionInfo, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::cl::parser<(anonymous namespace)::EmitType>::OptionInfo, false>>(llvm::SmallVectorTemplateBase<llvm::cl::parser<(anonymous namespace)::EmitType>::OptionInfo, false>*, llvm::cl::parser<(anonymous namespace)::EmitType>::OptionInfo const&, unsigned long) | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::TakesParamByValue) {
if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
ReferencesStorage = true;
Index = &Elt - This->begin();
}
}
This->grow(NewSize);
return ReferencesStorage ? This->begin() + Index : &Elt;
} | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4d300
addq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4d110
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
ja 0x15ab7
movq 0x40(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x15b51
movb $0x0, 0x2f(%rsp)
movq $-0x1, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x15b60
testb $0x1, %al
jne 0x15ada
jmp 0x15b0d
movb $0x1, 0x2f(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x11050
movq %rax, %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movl $0x30, %ecx
cqto
idivq %rcx
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x15bc0
testb $0x1, 0x2f(%rsp)
je 0x15b3d
movq 0x48(%rsp), %rdi
callq 0x11050
imulq $0x30, 0x20(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
jmp 0x15b47
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
| /llvm/ADT/SmallVector.h |
llvm::SmallVectorImpl<char const*>::erase(char const* const*) | iterator erase(const_iterator CI) {
// Just cast away constness because this is a non-const member function.
iterator I = const_cast<iterator>(CI);
assert(this->isReferenceToStorage(CI) && "Iterator to erase is out of bounds.");
iterator N = I;
// Shift all elts down one.
std::move(I+1, this->end(), I);
// Drop the last elt.
this->pop_back();
return(N);
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
callq 0x1c220
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rdx
callq 0x35240
movq 0x10(%rsp), %rdi
callq 0x35290
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /llvm/ADT/SmallVector.h |
llvm::cl::Option::printHelpStr(llvm::StringRef, unsigned long, unsigned long) | void Option::printHelpStr(StringRef HelpStr, size_t Indent,
size_t FirstLineIndentedBy) {
assert(Indent >= FirstLineIndentedBy);
std::pair<StringRef, StringRef> Split = HelpStr.split('\n');
outs().indent(Indent - FirstLineIndentedBy)
<< ArgHelpPrefix << Split.first << "\n";
while (!Split.second.empty()) {
Split = Split.second.split('\n');
outs().indent(Indent) << Split.first << "\n";
}
} | subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x88(%rsp), %rsi
movl $0xa, %edx
callq 0x20b80
callq 0x5f420
movq %rax, %rdi
movq 0x80(%rsp), %rax
subq 0x78(%rsp), %rax
movl %eax, %esi
callq 0x5e720
movq %rax, %rdi
movq 0x9f97f(%rip), %rax # 0xc0410
movq %rax, 0x48(%rsp)
movq 0x9f97b(%rip), %rax # 0xc0418
movq %rax, 0x50(%rsp)
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x120c0
movq %rax, %rdi
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x120c0
movq %rax, %rdi
leaq 0x6f94b(%rip), %rsi # 0x9042c
callq 0x8be0
leaq 0x58(%rsp), %rdi
addq $0x10, %rdi
callq 0x11650
xorb $-0x1, %al
testb $0x1, %al
jne 0x20afc
jmp 0x20b74
leaq 0x58(%rsp), %rsi
addq $0x10, %rsi
leaq 0x18(%rsp), %rdi
movl $0xa, %edx
callq 0x20b80
leaq 0x58(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x20be0
callq 0x5f420
movq %rax, %rdi
movq 0x80(%rsp), %rax
movl %eax, %esi
callq 0x5e720
movq %rax, %rdi
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x120c0
movq %rax, %rdi
leaq 0x6f8c2(%rip), %rsi # 0x9042c
callq 0x8be0
jmp 0x20ae6
addq $0x98, %rsp
retq
nopl (%rax)
| /Support/CommandLine.cpp |
HandlePrefixedOrGroupedOption(llvm::StringRef&, llvm::StringRef&, bool&, llvm::StringMap<llvm::cl::Option*, llvm::MallocAllocator> const&) | static Option *
HandlePrefixedOrGroupedOption(StringRef &Arg, StringRef &Value,
bool &ErrorParsing,
const StringMap<Option *> &OptionsMap) {
if (Arg.size() == 1)
return nullptr;
// Do the lookup!
size_t Length = 0;
Option *PGOpt = getOptionPred(Arg, Length, isPrefixedOrGrouping, OptionsMap);
if (!PGOpt)
return nullptr;
do {
StringRef MaybeValue =
(Length < Arg.size()) ? Arg.substr(Length) : StringRef();
Arg = Arg.substr(0, Length);
assert(OptionsMap.count(Arg) && OptionsMap.find(Arg)->second == PGOpt);
// cl::Prefix options do not preserve '=' when used separately.
// The behavior for them with grouped options should be the same.
if (MaybeValue.empty() || PGOpt->getFormattingFlag() == cl::AlwaysPrefix ||
(PGOpt->getFormattingFlag() == cl::Prefix && MaybeValue[0] != '=')) {
Value = MaybeValue;
return PGOpt;
}
if (MaybeValue[0] == '=') {
Value = MaybeValue.substr(1);
return PGOpt;
}
// This must be a grouped option.
assert(isGrouping(PGOpt) && "Broken getOptionPred!");
// Grouping options inside a group can't have values.
if (PGOpt->getValueExpectedFlag() == cl::ValueRequired) {
ErrorParsing |= PGOpt->error("may not occur within a group!");
return nullptr;
}
// Because the value for the option is not required, we don't need to pass
// argc/argv in.
int Dummy = 0;
ErrorParsing |= ProvideOption(PGOpt, Arg, StringRef(), 0, nullptr, Dummy);
// Get the next grouping option.
Arg = MaybeValue;
PGOpt = getOptionPred(Arg, Length, isGrouping, OptionsMap);
} while (PGOpt);
// We could not find a grouping option in the remainder of Arg.
return nullptr;
} | subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x108(%rsp)
movq %rsi, 0x100(%rsp)
movq %rdx, 0xf8(%rsp)
movq %rcx, 0xf0(%rsp)
movq 0x108(%rsp), %rdi
callq 0x11670
cmpq $0x1, %rax
jne 0x27cfb
movq $0x0, 0x110(%rsp)
jmp 0x280f2
movq $0x0, 0xe8(%rsp)
movq 0x108(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0xd0(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0xd8(%rsp)
movq 0xf0(%rsp), %r8
movq 0xd0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
leaq 0xe8(%rsp), %rdx
leaq 0x17a3(%rip), %rcx # 0x294f0
callq 0x29150
movq %rax, 0xe0(%rsp)
cmpq $0x0, 0xe0(%rsp)
jne 0x27d76
movq $0x0, 0x110(%rsp)
jmp 0x280f2
jmp 0x27d78
movq 0xe8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x108(%rsp), %rdi
callq 0x11670
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0x27dcd
movq 0x108(%rsp), %rdi
movq 0xe8(%rsp), %rsi
movq $-0x1, %rdx
callq 0x13030
movq %rax, 0xc0(%rsp)
movq %rdx, 0xc8(%rsp)
jmp 0x27dee
leaq 0xc0(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x7210
leaq 0xc0(%rsp), %rdi
callq 0x11470
movq 0x108(%rsp), %rdi
movq 0xe8(%rsp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x13030
movq %rax, 0xb0(%rsp)
movq %rdx, 0xb8(%rsp)
movq 0x108(%rsp), %rax
movq 0xb0(%rsp), %rcx
movq %rcx, (%rax)
movq 0xb8(%rsp), %rcx
movq %rcx, 0x8(%rax)
leaq 0xc0(%rsp), %rdi
callq 0x11650
testb $0x1, %al
jne 0x27e84
movq 0xe0(%rsp), %rdi
callq 0x252d0
cmpl $0x3, %eax
je 0x27e84
movq 0xe0(%rsp), %rdi
callq 0x252d0
cmpl $0x2, %eax
jne 0x27eb8
leaq 0xc0(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1b290
movsbl %al, %eax
cmpl $0x3d, %eax
je 0x27eb8
movq 0x100(%rsp), %rax
movq 0xc0(%rsp), %rcx
movq %rcx, (%rax)
movq 0xc8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0xe0(%rsp), %rax
movq %rax, 0x110(%rsp)
jmp 0x280f2
leaq 0xc0(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1b290
movsbl %al, %eax
cmpl $0x3d, %eax
jne 0x27f2e
leaq 0xc0(%rsp), %rdi
movl $0x1, %esi
movq $-0x1, %rdx
callq 0x13030
movq %rax, 0xa0(%rsp)
movq %rdx, 0xa8(%rsp)
movq 0x100(%rsp), %rax
movq 0xa0(%rsp), %rcx
movq %rcx, (%rax)
movq 0xa8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0xe0(%rsp), %rax
movq %rax, 0x110(%rsp)
jmp 0x280f2
movq 0xe0(%rsp), %rdi
callq 0x20f30
cmpl $0x2, %eax
jne 0x27fd1
movq 0xe0(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x680f3(%rip), %rsi # 0x90050
callq 0x11600
leaq 0x68(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x7210
leaq 0x68(%rsp), %rdi
callq 0x11470
callq 0x5f4b0
movq 0x20(%rsp), %rdi
movq %rax, %r8
movq 0x68(%rsp), %rdx
movq 0x70(%rsp), %rcx
leaq 0x78(%rsp), %rsi
callq 0x20630
andb $0x1, %al
movzbl %al, %edx
movq 0xf8(%rsp), %rax
movb (%rax), %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %edx, %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movb %cl, (%rax)
movq $0x0, 0x110(%rsp)
jmp 0x280f2
movl $0x0, 0x64(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x108(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x50(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsp)
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x7210
leaq 0x40(%rsp), %rdi
callq 0x11470
movq 0x18(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %r8
xorl %r9d, %r9d
xorl %eax, %eax
leaq 0x64(%rsp), %rax
movq $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1a7f0
andb $0x1, %al
movzbl %al, %edx
movq 0xf8(%rsp), %rax
movb (%rax), %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %edx, %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movb %cl, (%rax)
movq 0x108(%rsp), %rax
movq 0xc0(%rsp), %rcx
movq %rcx, (%rax)
movq 0xc8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x108(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0xf0(%rsp), %r8
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
leaq 0xe8(%rsp), %rdx
leaq 0xf46(%rip), %rcx # 0x29010
callq 0x29150
movq %rax, 0xe0(%rsp)
cmpq $0x0, 0xe0(%rsp)
jne 0x27d78
movq $0x0, 0x110(%rsp)
movq 0x110(%rsp), %rax
addq $0x118, %rsp # imm = 0x118
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /Support/CommandLine.cpp |
llvm::cl::opt<(anonymous namespace)::HelpPrinterWrapper, true, llvm::cl::parser<bool>>::opt<char [5], llvm::cl::desc, llvm::cl::LocationClass<(anonymous namespace)::HelpPrinterWrapper>, llvm::cl::ValueExpected, llvm::cl::cat, llvm::cl::sub>(char const (&) [5], llvm::cl::desc const&, llvm::cl::LocationClass<(anonymous namespace)::HelpPrinterWrapper> const&, llvm::cl::ValueExpected const&, llvm::cl::cat const&, llvm::cl::sub const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | subq $0x48, %rsp
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x140a0
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
callq 0x2e870
movq 0x8(%rsp), %rsi
leaq 0x94819(%rip), %rax # 0xbeef0
addq $0x10, %rax
movq %rax, (%rsi)
movq %rsi, %rdi
addq $0x90, %rdi
callq 0x2d7b0
movq 0x8(%rsp), %rdi
addq $0x98, %rdi
leaq 0x17(%rsp), %rsi
callq 0x2e890
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
callq 0x2e910
movq 0x8(%rsp), %rdi
callq 0x2e990
addq $0x48, %rsp
retq
nop
| /llvm/Support/CommandLine.h |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [18], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::initializer<bool>, llvm::cl::cat, llvm::cl::sub>(char const (&) [18], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::initializer<bool> const&, llvm::cl::cat const&, llvm::cl::sub const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | subq $0x48, %rsp
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x140a0
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
callq 0x301a0
movq 0x8(%rsp), %rsi
leaq 0x94321(%rip), %rax # 0xbed18
addq $0x10, %rax
movq %rax, (%rsi)
movq %rsi, %rdi
addq $0x98, %rdi
callq 0x2d7b0
movq 0x8(%rsp), %rdi
addq $0xa0, %rdi
leaq 0x17(%rsp), %rsi
callq 0x301e0
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
callq 0x30a30
movq 0x8(%rsp), %rdi
callq 0x19ec0
addq $0x48, %rsp
retq
nop
| /llvm/Support/CommandLine.h |
llvm::cl::opt<(anonymous namespace)::VersionPrinter, true, llvm::cl::parser<bool>>::opt<char [8], llvm::cl::desc, llvm::cl::LocationClass<(anonymous namespace)::VersionPrinter>, llvm::cl::ValueExpected, llvm::cl::cat>(char const (&) [8], llvm::cl::desc const&, llvm::cl::LocationClass<(anonymous namespace)::VersionPrinter> const&, llvm::cl::ValueExpected const&, llvm::cl::cat const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x140a0
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
callq 0x30ba0
movq 0x8(%rsp), %rsi
leaq 0x944c6(%rip), %rax # 0xbeff8
addq $0x10, %rax
movq %rax, (%rsi)
movq %rsi, %rdi
addq $0x90, %rdi
callq 0x2d7b0
movq 0x8(%rsp), %rdi
addq $0x98, %rdi
leaq 0x17(%rsp), %rsi
callq 0x30bc0
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
callq 0x30c40
movq 0x8(%rsp), %rdi
callq 0x30cb0
addq $0x48, %rsp
retq
| /llvm/Support/CommandLine.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.