name
string | code
string | asm
string | file
string |
|---|---|---|---|
QPDF::readStream(QPDFObjectHandle&, QPDFObjGen, long long)
|
void
QPDF::readStream(QPDFObjectHandle& object, QPDFObjGen og, qpdf_offset_t offset)
{
validateStreamLineEnd(object, og, offset);
// Must get offset before accessing any additional objects since resolving a previously
// unresolved indirect object will change file position.
qpdf_offset_t stream_offset = m->file->tell();
size_t length = 0;
try {
auto length_obj = object.getKey("/Length");
if (!length_obj.isInteger()) {
if (length_obj.isNull()) {
QTC::TC("qpdf", "QPDF stream without length");
throw damagedPDF(offset, "stream dictionary lacks /Length key");
}
QTC::TC("qpdf", "QPDF stream length not integer");
throw damagedPDF(offset, "/Length key in stream dictionary is not an integer");
}
length = toS(length_obj.getUIntValue());
// Seek in two steps to avoid potential integer overflow
m->file->seek(stream_offset, SEEK_SET);
m->file->seek(toO(length), SEEK_CUR);
if (!readToken(*m->file).isWord("endstream")) {
QTC::TC("qpdf", "QPDF missing endstream");
throw damagedPDF("expected endstream");
}
} catch (QPDFExc& e) {
if (m->attempt_recovery) {
warn(e);
length = recoverStreamLength(m->file, og, stream_offset);
} else {
throw;
}
}
object = QPDFObjectHandle(qpdf::Stream(*this, og, object, stream_offset, length));
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %r13
movq %rdx, 0x18(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
callq 0x12c6ae
movq (%r15), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, %r12
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3970b(%rip), %rsi # 0x16586e
leaq 0x3970b(%rip), %rdx # 0x165875
leaq 0x30(%rsp), %rdi
callq 0x1edc8
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %rbx, %rsi
callq 0xfbad6
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x12c19d
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x20(%rsp), %rdi
callq 0xc19c2
testb %al, %al
je 0x12c3d5
leaq 0x20(%rsp), %rdi
callq 0xc2c1e
movq %rax, %r13
movq (%r15), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
movq %r12, %rsi
xorl %edx, %edx
callq *0x28(%rax)
movq (%r15), %rax
movq 0xb0(%rax), %rbp
testq %r13, %r13
jns 0x12c1e8
movq %r13, %rdi
callq 0x1e520
movq (%rbp), %rax
movq %rbp, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq *0x28(%rax)
movq (%r15), %rcx
movq 0xb0(%rcx), %rdx
leaq 0x18(%rcx), %rsi
addq $0xc0, %rcx
leaq 0x30(%rsp), %rdi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0xe2bfa
leaq 0xc8(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x4eb28(%rip), %rsi # 0x17ad5d
leaq 0x4eb2a(%rip), %rdx # 0x17ad66
leaq 0xb8(%rsp), %rdi
callq 0x1edc8
cmpl $0xd, 0x30(%rsp)
jne 0x12c282
movq 0x40(%rsp), %rdx
cmpq 0xc0(%rsp), %rdx
jne 0x12c282
testq %rdx, %rdx
je 0x12c3cd
movq 0xb8(%rsp), %rsi
movq 0x38(%rsp), %rdi
callq 0x19790
testl %eax, %eax
sete %bpl
jmp 0x12c284
xorl %ebp, %ebp
movq 0xb8(%rsp), %rdi
cmpq %r14, %rdi
je 0x12c2a1
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12c2c2
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12c2dd
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12c2f8
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %bpl, %bpl
je 0x12c454
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x12c310
callq 0x1ed58
movq (%rbx), %rax
movq %rax, 0x98(%rsp)
movq 0x8(%rbx), %rax
movq %rax, 0xa0(%rsp)
testq %rax, %rax
je 0x12c341
movq 0xc3c4d(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx)
je 0x12c33d
incl 0x8(%rax)
jmp 0x12c341
lock
incl 0x8(%rax)
leaq 0x30(%rsp), %rdi
leaq 0x98(%rsp), %rcx
movq %r15, %rsi
movq 0x18(%rsp), %rdx
movq %r12, %r8
movq %r13, %r9
callq 0xfc67c
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x12c385
movq 0xc3c09(%rip), %rdx # 0x1eff80
cmpb $0x0, (%rdx)
je 0x12c381
incl 0x8(%rax)
jmp 0x12c385
lock
incl 0x8(%rax)
movq %rcx, (%rbx)
movq 0x8(%rbx), %rdi
movq %rax, 0x8(%rbx)
testq %rdi, %rdi
je 0x12c39a
callq 0x1ed58
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x12c3a9
callq 0x1ed58
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x12c3bb
callq 0x1ed58
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %bpl
jmp 0x12c284
leaq 0x20(%rsp), %rdi
callq 0xc1978
movl %eax, %ebp
movl $0x80, %edi
callq 0x193f0
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
testb %bpl, %bpl
je 0x12c4b8
movq %r14, (%rdi)
leaq 0x528ee(%rip), %rsi # 0x17ecf6
leaq 0x5290a(%rip), %rdx # 0x17ed19
callq 0x1edc8
movb $0x1, %al
movl %eax, 0xc(%rsp)
leaq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x3defc
movl $0x0, 0xc(%rsp)
leaq 0xbd9c2(%rip), %rsi # 0x1e9e00
leaq -0x10c42d(%rip), %rdx # 0x20018
movq 0x10(%rsp), %rdi
callq 0x196e0
jmp 0x12c682
movl $0x80, %edi
callq 0x193f0
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
movq %rax, (%rdi)
leaq 0x528d6(%rip), %rsi # 0x17ed4d
leaq 0x528e1(%rip), %rdx # 0x17ed5f
callq 0x1edc8
movb $0x1, %r14b
leaq 0x30(%rsp), %rdx
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x3df54
xorl %r14d, %r14d
leaq 0xbd95e(%rip), %rsi # 0x1e9e00
leaq -0x10c491(%rip), %rdx # 0x20018
movq 0x10(%rsp), %rdi
callq 0x196e0
jmp 0x12c682
movq %r14, (%rdi)
leaq 0x52858(%rip), %rsi # 0x17ed1a
leaq 0x52883(%rip), %rdx # 0x17ed4c
callq 0x1edc8
movb $0x1, %al
movl %eax, 0xc(%rsp)
leaq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x3defc
movl $0x0, 0xc(%rsp)
leaq 0xbd908(%rip), %rsi # 0x1e9e00
leaq -0x10c4e7(%rip), %rdx # 0x20018
movq 0x10(%rsp), %rdi
callq 0x196e0
jmp 0x12c682
jmp 0x12c510
movq %rdx, %rbp
movq %rax, %r13
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x12c52d
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x190e0
cmpb $0x0, 0xc(%rsp)
jne 0x12c56c
jmp 0x12c5d8
jmp 0x12c566
jmp 0x12c566
movq %rdx, %rbp
movq %rax, %r13
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x12c55f
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %r14b, %r14b
jne 0x12c56c
jmp 0x12c5d8
movq %rdx, %rbp
movq %rax, %r13
movq 0x10(%rsp), %rdi
callq 0x19a40
jmp 0x12c5d8
movq %rdx, %rbp
movq %rax, %r13
leaq 0x30(%rsp), %rdi
callq 0x37340
jmp 0x12c5d8
jmp 0x12c5d2
jmp 0x12c5d2
movq %rdx, %rbp
movq %rax, %r13
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x12c5e7
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x12c5e7
movq %rax, %r13
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x12c5c2
callq 0x1ed58
movq %r13, %rdi
callq 0x19710
movq %rdx, %rbp
movq %rax, %r13
jmp 0x12c5e7
movq %rdx, %rbp
movq %rax, %r13
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x12c5e7
callq 0x1ed58
cmpl $0x1, %ebp
jne 0x12c5c2
movq %r13, %rdi
callq 0x19060
movq (%r15), %rcx
cmpb $0x1, 0x100(%rcx)
jne 0x12c67d
movq %r15, %rdi
movq %rax, %rsi
callq 0x3a362
movq (%r15), %rax
movq 0xb0(%rax), %rcx
movq %rcx, 0xa8(%rsp)
movq 0xb8(%rax), %rax
movq %rax, 0xb0(%rsp)
testq %rax, %rax
je 0x12c646
movq 0xc3948(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx)
je 0x12c642
incl 0x8(%rax)
jmp 0x12c646
lock
incl 0x8(%rax)
leaq 0xa8(%rsp), %rsi
movq %r15, %rdi
movq 0x18(%rsp), %rdx
movq %r12, %rcx
callq 0x12c93c
movq %rax, %r13
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x12c673
callq 0x1ed58
callq 0x19890
jmp 0x12c310
callq 0x19900
movq %rax, %r13
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x12c69c
callq 0x1ed58
jmp 0x12c69c
movq %rax, %r13
callq 0x19890
jmp 0x12c5c2
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc
|
QPDF::tableSize()
|
size_t
QPDF::tableSize()
{
// If obj_cache is dense, accommodate all object in tables,else accommodate only original
// objects.
auto max_xref = m->xref_table.size() ? m->xref_table.crbegin()->first.getObj() : 0;
auto max_obj = m->obj_cache.size() ? m->obj_cache.crbegin()->first.getObj() : 0;
auto max_id = std::numeric_limits<int>::max() - 1;
if (max_obj >= max_id || max_xref >= max_id) {
// Temporary fix. Long-term solution is
// - QPDFObjGen to enforce objgens are valid and sensible
// - xref table and obj cache to protect against insertion of impossibly large obj ids
stopOnError("Impossibly large object id encountered.");
}
if (max_obj < 1.1 * std::max(toI(m->obj_cache.size()), max_xref)) {
return toS(++max_obj);
}
return toS(++max_xref);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
xorl %r12d, %r12d
cmpq $0x0, 0x160(%r15)
movl $0x0, %r13d
je 0x1308c2
leaq 0x140(%r15), %rdi
callq 0x19c20
movl 0x20(%rax), %r13d
movq 0x1d0(%r15), %r14
testq %r14, %r14
je 0x1308e1
addq $0x1b0, %r15 # imm = 0x1B0
movq %r15, %rdi
callq 0x19c20
movl 0x20(%rax), %r12d
cmpl $0x7ffffffd, %r12d # imm = 0x7FFFFFFD
jg 0x1308f3
cmpl $0x7ffffffe, %r13d # imm = 0x7FFFFFFE
jl 0x130943
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4e821(%rip), %rsi # 0x17f124
leaq 0x4e841(%rip), %rdx # 0x17f14b
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x1edc8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3a482
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x130939
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
movq (%rbx), %rax
movq 0x1d0(%rax), %r14
cvtsi2sd %r12d, %xmm1
movq %r14, %rax
shrq $0x1f, %rax
je 0x130965
movq %r14, %rdi
movsd %xmm1, 0x8(%rsp)
callq 0x62562
movsd 0x8(%rsp), %xmm1
cmpl %r14d, %r13d
cmovgl %r13d, %r14d
cvtsi2sd %r14d, %xmm0
mulsd 0x4da97(%rip), %xmm0 # 0x17e410
ucomisd %xmm1, %xmm0
jbe 0x13098c
leal 0x1(%r12), %ebx
cmpl $-0x1, %r12d
jl 0x130996
jmp 0x13099d
leal 0x1(%r13), %ebx
cmpl $-0x2, %r13d
jg 0x13099d
movl %ebx, %edi
callq 0x32732
movslq %ebx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x1309c8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rdi
callq 0x19710
|
/jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc
|
QPDFObject::move_to(std::shared_ptr<QPDFObject>&, bool)
|
void
move_to(std::shared_ptr<QPDFObject>& o, bool destroy)
{
o->value = std::move(value);
o->qpdf = qpdf;
o->og = og;
o->object_description = object_description;
o->parsed_offset = parsed_offset;
if (!destroy) {
value = QPDF_Reference(o);
}
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
movsbq 0x30(%rbx), %rax
leaq 0xbdf11(%rip), %rcx # 0x1eec08
movq %rbx, %rsi
callq *0x8(%rcx,%rax,8)
movq 0x48(%rbx), %rax
movq (%r14), %rcx
movq %rax, 0x48(%rcx)
movq 0x50(%rbx), %rax
movq %rax, 0x50(%rcx)
movq (%r14), %rdi
movq 0x38(%rbx), %rax
movq %rax, 0x38(%rdi)
addq $0x40, %rdi
leaq 0x40(%rbx), %rsi
callq 0x274ee
movq 0x58(%rbx), %rcx
movq (%r14), %rax
movq %rcx, 0x58(%rax)
testb %bpl, %bpl
jne 0x130d7a
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0x130d57
movq 0xbf237(%rip), %rdx # 0x1eff80
cmpb $0x0, (%rdx)
je 0x130d53
incl 0x8(%rcx)
jmp 0x130d57
lock
incl 0x8(%rcx)
movq %rsp, %r14
movq %rax, (%r14)
movq %rcx, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1324e0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x130d7a
callq 0x1ed58
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x1d07a
nop
|
/jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObject_private.hh
|
QPDF::optimize(std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int>>> const&, bool, std::function<int (QPDFObjectHandle&)>)
|
void
QPDF::optimize(
std::map<int, int> const& object_stream_data,
bool allow_changes,
std::function<int(QPDFObjectHandle&)> skip_stream_parameters)
{
optimize_internal(object_stream_data, allow_changes, skip_stream_parameters);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rcx, %rsi
callq 0xf5d46
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
callq 0x136c64
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x135312
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x135344
movq %rax, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x13533c
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/QPDF_optimization.cc
|
QUtil::safe_fopen(char const*, char const*)
|
FILE*
QUtil::safe_fopen(char const* filename, char const* mode)
{
FILE* f = nullptr;
#ifdef _WIN32
std::shared_ptr<wchar_t> wfilenamep = win_convert_filename(filename);
wchar_t* wfilename = wfilenamep.get();
auto wmodep = QUtil::make_shared_array<wchar_t>(strlen(mode) + 1);
wchar_t* wmode = wmodep.get();
wmode[strlen(mode)] = 0;
for (size_t i = 0; i < strlen(mode); ++i) {
wmode[i] = static_cast<wchar_t>(mode[i]);
}
# ifdef _MSC_VER
errno_t err = _wfopen_s(&f, wfilename, wmode);
if (err != 0) {
errno = err;
}
# else
f = _wfopen(wfilename, wmode);
# endif
if (f == 0) {
throw_system_error(std::string("open ") + filename);
}
#else
f = fopen_wrapper(std::string("open ") + filename, fopen(filename, mode));
#endif
return f;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x427e1(%rip), %rsi # 0x18070b
leaq 0x427df(%rip), %rdx # 0x180710
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x1edc8
movq %r15, %rdi
movq %r14, %rsi
callq 0x19730
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x13df70
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x13df77
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19db0
testq %rax, %rax
je 0x13dfdf
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x13dfb9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x13dfd0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rdi
callq 0x13deab
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x13e008
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x13e008
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x13e01f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rdi
callq 0x19710
|
/jberkenbilt[P]qpdf/libqpdf/QUtil.cc
|
QUtil::same_file(char const*, char const*)
|
bool
QUtil::same_file(char const* name1, char const* name2)
{
if ((name1 == nullptr) || (strlen(name1) == 0) || (name2 == nullptr) || (strlen(name2) == 0)) {
return false;
}
#ifdef _WIN32
bool same = false;
# ifndef AVOID_WINDOWS_HANDLE
HANDLE fh1 = CreateFile(
name1, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
HANDLE fh2 = CreateFile(
name2, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
BY_HANDLE_FILE_INFORMATION fi1;
BY_HANDLE_FILE_INFORMATION fi2;
if ((fh1 != INVALID_HANDLE_VALUE) && (fh2 != INVALID_HANDLE_VALUE) &&
GetFileInformationByHandle(fh1, &fi1) && GetFileInformationByHandle(fh2, &fi2) &&
(fi1.dwVolumeSerialNumber == fi2.dwVolumeSerialNumber) &&
(fi1.nFileIndexLow == fi2.nFileIndexLow) && (fi1.nFileIndexHigh == fi2.nFileIndexHigh)) {
same = true;
}
if (fh1 != INVALID_HANDLE_VALUE) {
CloseHandle(fh1);
}
if (fh2 != INVALID_HANDLE_VALUE) {
CloseHandle(fh2);
}
# endif
return same;
#else
struct stat st1;
struct stat st2;
if ((stat(name1, &st1) == 0) && (stat(name2, &st2) == 0) && (st1.st_ino == st2.st_ino) &&
(st1.st_dev == st2.st_dev)) {
return true;
}
#endif
return false;
}
|
testq %rdi, %rdi
je 0x13e0d5
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rsi, %rbx
xorl %eax, %eax
testq %rsi, %rsi
je 0x13e0cc
cmpb $0x0, (%rdi)
je 0x13e0cc
cmpb $0x0, (%rbx)
je 0x13e0ca
leaq 0x90(%rsp), %rsi
callq 0x190b0
testl %eax, %eax
jne 0x13e0ca
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x190b0
testl %eax, %eax
jne 0x13e0ca
movq 0x98(%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x13e0ca
movq 0x90(%rsp), %rcx
movb $0x1, %al
cmpq (%rsp), %rcx
je 0x13e0cc
xorl %eax, %eax
addq $0x120, %rsp # imm = 0x120
popq %rbx
retq
xorl %eax, %eax
retq
|
/jberkenbilt[P]qpdf/libqpdf/QUtil.cc
|
QUtil::hex_decode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
std::string
QUtil::hex_decode(std::string const& input)
{
std::string result;
// We know result.size() <= 0.5 * input.size() + 1. However, reserving string space for this
// upper bound has a negative impact.
bool first = true;
char decoded;
for (auto ch: input) {
ch = util::hex_decode_char(ch);
if (ch < '\20') {
if (first) {
decoded = static_cast<char>(ch << 4);
first = false;
} else {
result.push_back(decoded | ch);
first = true;
}
}
}
if (!first) {
result.push_back(decoded);
}
return result;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0x13e993
movq (%rsi), %r12
movb $0x1, %r15b
xorl %r13d, %r13d
movb (%r12,%r13), %cl
leal -0x30(%rcx), %eax
cmpb $0xa, %al
jb 0x13e958
cmpb $0x61, %cl
jl 0x13e949
addb $-0x57, %cl
jmp 0x13e951
cmpb $0x41, %cl
jl 0x13e979
addb $-0x37, %cl
movl %ecx, %eax
cmpb $0xf, %cl
ja 0x13e979
testb $0x1, %r15b
je 0x13e968
shlb $0x4, %al
xorl %r15d, %r15d
movl %eax, %ebp
jmp 0x13e979
orb %bpl, %al
movb $0x1, %r15b
movsbl %al, %esi
movq %rbx, %rdi
callq 0x19d90
incq %r13
cmpq %r13, %r14
jne 0x13e934
testb $0x1, %r15b
jne 0x13e993
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x19d90
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13e9a7
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x13e9c2
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movq %r14, %rdi
callq 0x19710
|
/jberkenbilt[P]qpdf/libqpdf/QUtil.cc
|
QUtil::toUTF8[abi:cxx11](unsigned long)
|
std::string
QUtil::toUTF8(unsigned long uval)
{
std::string result;
// A UTF-8 encoding of a Unicode value is a single byte for Unicode values <= 127. For larger
// values, the first byte of the UTF-8 encoding has '1' as each of its n highest bits and '0'
// for its (n+1)th highest bit where n is the total number of bytes required. Subsequent bytes
// start with '10' and have the remaining 6 bits free for encoding. For example, an 11-bit
// Unicode value can be stored in two bytes where the first is 110zzzzz, the second is 10zzzzzz,
// and the z's represent the remaining bits.
if (uval > 0x7fffffff) {
throw std::runtime_error("bounds error in QUtil::toUTF8");
} else if (uval < 128) {
result += static_cast<char>(uval);
} else {
unsigned char bytes[7];
bytes[6] = '\0';
unsigned char* cur_byte = &bytes[5];
// maximum value that will fit in the current number of bytes
unsigned char maxval = 0x3f; // six bits
while (uval > QIntC::to_ulong(maxval)) {
// Assign low six bits plus 10000000 to lowest unused byte position, then shift
*cur_byte = static_cast<unsigned char>(0x80 + (uval & 0x3f));
uval >>= 6;
// Maximum that will fit in high byte now shrinks by one bit
maxval = static_cast<unsigned char>(maxval >> 1);
// Slide to the left one byte
if (cur_byte <= bytes) {
throw std::logic_error("QUtil::toUTF8: overflow error");
}
--cur_byte;
}
// If maxval is k bits long, the high (7 - k) bits of the resulting byte must be high.
*cur_byte = static_cast<unsigned char>(QIntC::to_ulong(0xff - (1 + (maxval << 1))) + uval);
result += reinterpret_cast<char*>(cur_byte);
}
return result;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rax
shrq $0x1f, %rax
jne 0x140e04
cmpq $0x7f, %rsi
ja 0x140d6f
movsbl %sil, %esi
movq %rbx, %rdi
callq 0x19d90
jmp 0x140dc1
leaq 0x6(%rsp), %rax
movb $0x0, 0x1(%rax)
movb $0x3f, %dil
leaq 0x1(%rsp), %rdx
movl %edi, %ecx
movl %esi, %edi
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, (%rax)
cmpq %rdx, %rax
jbe 0x140dd0
movl %ecx, %edi
shrb %dil
shrq $0x6, %rsi
decq %rax
movzbl %dil, %r8d
cmpq %r8, %rsi
ja 0x140d80
andb $0x3e, %cl
subb %cl, %sil
addb $-0x2, %sil
movb %sil, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x19730
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x193f0
movq %rax, %r15
leaq 0x3f9e1(%rip), %rsi # 0x1807c5
movq %rax, %rdi
callq 0x19970
movq 0xaf1fd(%rip), %rsi # 0x1efff0
movq 0xaf1c6(%rip), %rdx # 0x1effc0
movq %r15, %rdi
callq 0x196e0
jmp 0x140e36
movl $0x10, %edi
callq 0x193f0
movq %rax, %r15
leaq 0x3f98f(%rip), %rsi # 0x1807a7
movq %rax, %rdi
callq 0x192b0
movq 0xaf179(%rip), %rsi # 0x1effa0
movq 0xaf142(%rip), %rdx # 0x1eff70
movq %r15, %rdi
callq 0x196e0
jmp 0x140e3a
jmp 0x140e47
movq %rax, %r14
movq %r15, %rdi
callq 0x19a40
jmp 0x140e4a
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x140e5e
movq (%r12), %rsi
incq %rsi
callq 0x190e0
movq %r14, %rdi
callq 0x19710
|
/jberkenbilt[P]qpdf/libqpdf/QUtil.cc
|
QUtil::read_file_into_string[abi:cxx11](_IO_FILE*, std::basic_string_view<char, std::char_traits<char>>)
|
std::string
QUtil::read_file_into_string(FILE* f, std::string_view filename)
{
fseek(f, 0, SEEK_END);
auto o_size = QUtil::tell(f);
if (o_size >= 0) {
// Seekable file
auto size = QIntC::to_size(o_size);
fseek(f, 0, SEEK_SET);
std::string result(size, '\0');
if (auto n_read = fread(result.data(), 1, size, f); n_read != size) {
if (ferror(f)) {
throw std::runtime_error(
std::string("failure reading file ") + std::string(filename) +
" into memory: read " + uint_to_string(n_read) + "; wanted " +
uint_to_string(size));
} else {
throw std::runtime_error(
std::string("premature eof reading file ") + std::string(filename) +
" into memory: read " + uint_to_string(n_read) + "; wanted " +
uint_to_string(size));
}
}
return result;
} else {
// Pipe or other non-seekable file
size_t buf_size = 8192;
auto n_read = buf_size;
std::string buffer(buf_size, '\0');
std::string result;
while (n_read == buf_size) {
n_read = fread(buffer.data(), 1, buf_size, f);
buffer.erase(n_read);
result.append(buffer);
}
if (ferror(f)) {
throw std::runtime_error(
std::string("failure reading file ") + std::string(filename) + " into memory");
}
return result;
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rcx, 0x68(%rsp)
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x19da0
movq %r14, %rdi
callq 0x198d0
testq %rax, %rax
js 0x14181d
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x19da0
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x19670
movq (%rbx), %rdi
movl $0x1, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x19620
cmpq %r15, %rax
je 0x1418c4
movq %rax, %rbp
movq %r12, 0xb0(%rsp)
movq %r14, %rdi
callq 0x19850
movl %eax, %r14d
movl $0x10, %edi
callq 0x193f0
movq %rax, 0x20(%rsp)
testl %r14d, %r14d
jne 0x14199d
leaq 0x80(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3f076(%rip), %rsi # 0x180804
leaq 0x3f08a(%rip), %rdx # 0x18081f
leaq 0x70(%rsp), %rdi
callq 0x1edc8
leaq 0xe8(%rsp), %rax
movq %rax, %r12
movq %rax, -0x10(%rax)
movq 0x68(%rsp), %rsi
addq %rsi, %r13
leaq 0xd8(%rsp), %rdi
movq %r13, %rdx
callq 0x1edc8
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0xd8(%rsp), %rdx
callq 0x1d4c1
leaq 0x3efff(%rip), %rsi # 0x1807e6
leaq 0x90(%rsp), %rdi
callq 0x19730
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x141a8e
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x141a9b
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x48(%rsp), %rdi
movl $0x2000, %r15d # imm = 0x2000
movl $0x2000, %esi # imm = 0x2000
xorl %edx, %edx
callq 0x19670
leaq 0x10(%rbx), %rbp
movq %rbp, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
cmpq $0x2000, %r15 # imm = 0x2000
jne 0x1418a1
movq 0x48(%rsp), %rdi
movl $0x1, %esi
movl $0x2000, %edx # imm = 0x2000
movq %r14, %rcx
callq 0x19620
movq %rax, %r15
movq 0x50(%rsp), %rcx
cmpq %rax, %rcx
jb 0x1418d9
movq %r15, 0x50(%rsp)
movq 0x48(%rsp), %rax
movb $0x0, (%rax,%r15)
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x19810
jmp 0x141851
movq %r14, %rdi
callq 0x19850
testl %eax, %eax
jne 0x1418f1
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x1418c4
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rax
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3f05a(%rip), %rdi # 0x18093a
leaq 0x3f0ba(%rip), %rsi # 0x1809a1
movq %r15, %rdx
xorl %eax, %eax
callq 0x19030
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x3ee13(%rip), %rsi # 0x180721
leaq 0x3ee21(%rip), %rdx # 0x180736
leaq 0x28(%rsp), %rdi
callq 0x1edc8
leaq 0xa0(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x68(%rsp), %rsi
addq %rsi, %r13
leaq 0x90(%rsp), %rdi
movq %r13, %rdx
callq 0x1edc8
leaq 0xb8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x90(%rsp), %rdx
callq 0x1d4c1
leaq 0x3eebc(%rip), %rsi # 0x180820
leaq 0xb8(%rsp), %rdi
callq 0x19730
leaq 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x141a3f
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x141a4b
leaq 0x80(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3ed71(%rip), %rsi # 0x180721
leaq 0x3ed7f(%rip), %rdx # 0x180736
leaq 0x70(%rsp), %rdi
callq 0x1edc8
leaq 0xe8(%rsp), %rax
movq %rax, %r12
movq %rax, -0x10(%rax)
movq 0x68(%rsp), %rsi
addq %rsi, %r13
leaq 0xd8(%rsp), %rdi
movq %r13, %rdx
callq 0x1edc8
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0xd8(%rsp), %rdx
callq 0x1d4c1
leaq 0x3eddd(%rip), %rsi # 0x1807e6
leaq 0x90(%rsp), %rdi
callq 0x19730
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x141b24
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x141b31
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %r13b
movq %r14, %rdi
callq 0x192d0
xorl %r13d, %r13d
movq 0xae526(%rip), %rsi # 0x1effa0
movq 0xae4ef(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x141cb4
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x118(%rsp), %rdi
movq %rbp, %rsi
movl $0xa, %edx
xorl %ecx, %ecx
callq 0x13d4a1
leaq 0xb8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x118(%rsp), %rdx
callq 0x1d4c1
leaq 0x3ed0f(%rip), %rsi # 0x1807fa
leaq 0xb8(%rsp), %rdi
callq 0x19730
leaq 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x141bba
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x141bc6
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x118(%rsp), %rdi
movq %rbp, %rsi
movl $0xa, %edx
xorl %ecx, %ecx
callq 0x13d4a1
leaq 0xb8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x118(%rsp), %rdx
callq 0x1d4c1
leaq 0x3ec79(%rip), %rsi # 0x1807fa
leaq 0xb8(%rsp), %rdi
callq 0x19730
leaq 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x141c38
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x141c44
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xf8(%rsp), %rdi
movq %r15, %rsi
movl $0xa, %edx
xorl %ecx, %ecx
callq 0x13d4a1
leaq 0x48(%rsp), %rdi
movq %rsp, %rsi
leaq 0xf8(%rsp), %rdx
callq 0x1d4c1
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0xae37b(%rip), %rsi # 0x1effa0
movq 0xae344(%rip), %rdx # 0x1eff70
movq 0x20(%rsp), %rdi
callq 0x196e0
jmp 0x141cb4
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xf8(%rsp), %rdi
movq %r15, %rsi
movl $0xa, %edx
xorl %ecx, %ecx
callq 0x13d4a1
leaq 0x48(%rsp), %rdi
movq %rsp, %rsi
leaq 0xf8(%rsp), %rdx
callq 0x1d4c1
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0xae2fd(%rip), %rsi # 0x1effa0
movq 0xae2c6(%rip), %rdx # 0x1eff70
movq 0x20(%rsp), %rdi
callq 0x196e0
jmp 0x141cb8
jmp 0x141cd8
movq %rax, %r15
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x141cde
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x141cde
movq %rax, %r15
movb $0x1, %bpl
leaq 0x108(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x141d09
movq 0x108(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x141d09
jmp 0x141d03
movq %rax, %r15
movb $0x1, %bpl
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x141d2e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x141d2e
jmp 0x141d28
movq %rax, %r15
movb $0x1, %bpl
leaq 0xc8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x141d59
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x141d59
jmp 0x141d53
movq %rax, %r15
movb $0x1, %bpl
leaq 0x128(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x141d84
movq 0x128(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x141d84
jmp 0x141d7e
movq %rax, %r15
movb $0x1, %bpl
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x141da5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x141da5
jmp 0x141d9f
movq %rax, %r15
movb $0x1, %bpl
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x141e19
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x141e19
movq %rax, %r15
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x141dee
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x141dee
movq %rax, %r15
movb $0x1, %r13b
leaq 0xc8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x141e64
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x141e64
jmp 0x141e13
movq %rax, %r15
movb $0x1, %bpl
movq 0xd8(%rsp), %rdi
cmpq %r12, %rdi
je 0x141e36
movq 0xe8(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x70(%rsp), %rdi
cmpq %r14, %rdi
je 0x141e50
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %bpl, %bpl
jne 0x141ef6
jmp 0x141f00
movq %rax, %r15
movb $0x1, %r13b
movq 0x90(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x141e89
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x141ea5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %r13b, %r13b
jne 0x141f1d
jmp 0x141f31
jmp 0x141eb1
movq %rax, %r15
movq 0x70(%rsp), %rdi
cmpq %r14, %rdi
je 0x141ef6
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x141ef6
movq %rax, %r15
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x141f1d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x141f1d
jmp 0x141ef3
movq %rax, %r15
movq 0x20(%rsp), %rdi
callq 0x19a40
movq (%rbx), %rdi
cmpq 0xb0(%rsp), %rdi
je 0x141f5c
movq 0xb0(%rsp), %rax
movq (%rax), %rsi
jmp 0x141f54
movq %rax, %r15
movq %r14, %rdi
callq 0x19a40
jmp 0x141f31
movq %rax, %r15
jmp 0x141f5c
jmp 0x141f2e
movq %rax, %r15
movq (%rbx), %rdi
cmpq %rbp, %rdi
je 0x141f45
movq (%rbp), %rsi
incq %rsi
callq 0x190e0
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x141f5c
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %r15, %rdi
callq 0x19710
|
/jberkenbilt[P]qpdf/libqpdf/QUtil.cc
|
QUtil::parse_numrange(char const*, int)
|
std::vector<int>
QUtil::parse_numrange(char const* range, int max)
{
// Performance note: this implementation aims to be straightforward, not efficient. Numeric
// range parsing is used only during argument processing. It is not used during processing of
// PDF files.
static std::regex group_re(R"((x)?(z|r?\d+)(?:-(z|r?\d+))?)");
auto parse_num = [&max](std::string const& s) -> int {
if (s == "z") {
return max;
}
int num;
if (s.at(0) == 'r') {
num = max + 1 - string_to_int(s.substr(1).c_str());
} else {
num = string_to_int(s.c_str());
}
// max == 0 means we don't know the max and are just testing for valid syntax.
if ((max > 0) && ((num < 1) || (num > max))) {
throw std::runtime_error("number " + std::to_string(num) + " out of range");
}
return num;
};
auto populate = [](std::vector<int>& group, int first_num, bool is_span, int last_num) {
group.clear();
group.emplace_back(first_num);
if (is_span) {
if (first_num > last_num) {
for (auto i = first_num - 1; i >= last_num; --i) {
group.push_back(i);
}
} else {
for (auto i = first_num + 1; i <= last_num; ++i) {
group.push_back(i);
}
}
}
};
char const* p;
try {
char const* range_end = range + strlen(range);
std::vector<int> result;
std::vector<int> last_group;
// See if range ends with :even or :odd.
size_t start_idx = 0;
size_t skip = 1;
p = std::find(range, range_end, ':');
if (*p == ':') {
if (strcmp(p, ":odd") == 0) {
skip = 2;
} else if (strcmp(p, ":even") == 0) {
skip = 2;
start_idx = 1;
} else {
throw std::runtime_error("expected :even or :odd");
}
range_end = p;
}
// Divide the range into groups
p = range;
char const* group_end;
bool first = true;
while (p != range_end) {
group_end = std::find(p, range_end, ',');
std::cmatch m;
if (!std::regex_match(p, group_end, m, group_re)) {
throw std::runtime_error("invalid range syntax");
}
auto is_exclude = m[1].matched;
if (first && is_exclude) {
throw std::runtime_error("first range group may not be an exclusion");
}
first = false;
auto first_num = parse_num(m[2].str());
auto is_span = m[3].matched;
int last_num{0};
if (is_span) {
last_num = parse_num(m[3].str());
}
if (is_exclude) {
std::vector<int> work;
populate(work, first_num, is_span, last_num);
std::set<int> exclusions;
exclusions.insert(work.begin(), work.end());
work = last_group;
last_group.clear();
for (auto n: work) {
if (exclusions.count(n) == 0) {
last_group.emplace_back(n);
}
}
} else {
result.insert(result.end(), last_group.begin(), last_group.end());
populate(last_group, first_num, is_span, last_num);
}
p = group_end;
if (*p == ',') {
++p;
if (p == range_end) {
throw std::runtime_error("trailing comma");
}
}
}
result.insert(result.end(), last_group.begin(), last_group.end());
if (skip == 1) {
return result;
}
std::vector<int> filtered;
for (auto i = start_idx; i < result.size(); i += skip) {
filtered.emplace_back(result.at(i));
}
return filtered;
} catch (std::runtime_error const& e) {
std::string message;
if (p) {
message = "error at * in numeric range " +
std::string(range, QIntC::to_size(p - range)) + "*" + p + ": " + e.what();
} else {
message = "error in numeric range " + std::string(range) + ": " + e.what();
}
throw std::runtime_error(message);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rsi, %rbx
movq %rdi, 0xf0(%rsp)
movl %edx, 0xec(%rsp)
movb 0xaf2bb(%rip), %al # 0x1f1578
testb %al, %al
je 0x142ae2
leaq 0xec(%rsp), %rax
movq %rax, 0x100(%rsp)
movq %rbx, %rdi
callq 0x19420
movq %rax, %r15
addq %rbx, %r15
xorl %eax, %eax
movq %rax, 0x40(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq %rax, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
leaq 0x80(%rsp), %rdx
movb $0x3a, (%rdx)
movq %rbx, %rdi
movq %r15, %rsi
movq %rbx, 0xd8(%rsp)
callq 0x146549
movq %rax, %r13
movb (%rax), %bpl
cmpb $0x3a, %bpl
movb %bpl, 0xf(%rsp)
jne 0x142364
leaq 0x3e530(%rip), %rsi # 0x180862
movq %r13, %rdi
callq 0x19980
testl %eax, %eax
je 0x142372
leaq 0x3e505(%rip), %rsi # 0x18084a
movq %r13, %rdi
callq 0x19980
testl %eax, %eax
jne 0x142b39
movl $0x1, %eax
movq %rax, 0xe0(%rsp)
jmp 0x14237e
movq $0x0, 0xe0(%rsp)
jmp 0x142381
movq $0x0, 0xe0(%rsp)
movq %r13, %r15
movq %rbx, %r12
cmpq %rbx, %r15
leaq 0x80(%rsp), %rbp
je 0x142933
leaq 0x88(%rsp), %rbx
movq 0xd8(%rsp), %r13
xorl %r14d, %r14d
movq %r15, 0xf8(%rsp)
movb $0x2c, 0x80(%rsp)
movq %r13, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x146549
movq %rax, %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0xc0(%rsp)
movaps %xmm0, 0xb0(%rsp)
movq %r13, %rdi
movq %rax, %rsi
leaq 0xb0(%rsp), %rdx
leaq 0xaf167(%rip), %rcx # 0x1f1558
xorl %r8d, %r8d
callq 0x1465dd
testb %al, %al
je 0x142a74
movq 0xb0(%rsp), %rax
movq 0xb8(%rsp), %rcx
subq %rax, %rcx
je 0x14245c
movq %rcx, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rdx
leaq -0x5(%rdx), %rsi
cmpq $-0x2, %rsi
jae 0x14245c
movb 0x28(%rax), %r15b
movl %r15d, %esi
notb %sil
orb %sil, %r14b
testb $0x1, %r14b
je 0x142a3d
addq $-0x6, %rdx
cmpq $-0x4, %rdx
ja 0x142473
addq $0x30, %rax
jmp 0x14247a
movb -0x38(%rax,%rcx), %r15b
movl %r15d, %edx
notb %dl
orb %dl, %r14b
testb $0x1, %r14b
je 0x142a3d
addq %rcx, %rax
addq $-0x48, %rax
cmpb $0x1, 0x10(%rax)
jne 0x1424a1
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq 0x90(%rsp), %rax
movq %rax, 0x80(%rsp)
movq %rbp, %rdi
callq 0x1edc8
jmp 0x1424c5
leaq 0x90(%rsp), %rax
movq %rax, 0x80(%rsp)
movq $0x0, 0x88(%rsp)
movb $0x0, 0x90(%rsp)
leaq 0x100(%rsp), %rdi
movq %rbp, %rsi
callq 0x1432d2
movl %eax, %r14d
movq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x1424fd
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0xb0(%rsp), %rax
movq 0xb8(%rsp), %rcx
subq %rax, %rcx
movq %r13, 0x70(%rsp)
je 0x14254e
movq %rcx, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rdx
addq $-0x7, %rdx
xorl %r13d, %r13d
cmpq $-0x4, %rdx
jae 0x142551
cmpb $0x0, 0x58(%rax)
movl $0x0, %ebp
je 0x1425f5
addq $0x48, %rax
jmp 0x142568
xorl %r13d, %r13d
cmpb $0x0, -0x38(%rax,%rcx)
movl $0x0, %ebp
je 0x1425f5
addq %rcx, %rax
addq $-0x48, %rax
leaq 0x80(%rsp), %r13
cmpb $0x1, 0x10(%rax)
jne 0x142597
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq 0x90(%rsp), %rax
movq %rax, 0x80(%rsp)
movq %r13, %rdi
callq 0x1edc8
jmp 0x1425bb
leaq 0x90(%rsp), %rax
movq %rax, 0x80(%rsp)
movq $0x0, 0x88(%rsp)
movb $0x0, 0x90(%rsp)
leaq 0x100(%rsp), %rdi
movq %r13, %rsi
callq 0x1432d2
movl %eax, %ebp
movq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x1425f2
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x190e0
movb $0x1, %r13b
testb $0x1, %r15b
je 0x142719
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movq $0x0, 0x60(%rsp)
movl %r14d, 0x78(%rsp)
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
leaq 0x78(%rsp), %rdx
callq 0x14646e
testb %r13b, %r13b
movq 0x70(%rsp), %r13
je 0x14267c
movl 0x78(%rsp), %eax
cmpl %ebp, %eax
leaq 0x8(%rsp), %r14
jle 0x1426e2
decl %eax
movl %eax, 0x8(%rsp)
movq 0x58(%rsp), %rsi
cmpq 0x60(%rsp), %rsi
je 0x142660
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x58(%rsp)
jmp 0x14266d
leaq 0x50(%rsp), %rdi
movq %r14, %rdx
callq 0x8a0d0
movl 0x8(%rsp), %ecx
leal -0x1(%rcx), %eax
movl %eax, 0x8(%rsp)
cmpl %ebp, %ecx
jg 0x142647
movl $0x0, 0x88(%rsp)
xorl %eax, %eax
movq %rax, 0x90(%rsp)
movq %rbx, 0x98(%rsp)
movq %rbx, 0xa0(%rsp)
movq %rax, 0xa8(%rsp)
movq 0x50(%rsp), %r14
movq 0x58(%rsp), %r15
leaq 0x80(%rsp), %rbp
movq %rbp, 0x78(%rsp)
cmpq %r15, %r14
je 0x142777
movq %rbp, %rdi
movq %rbx, %rsi
movq %r14, %rdx
leaq 0x78(%rsp), %rcx
callq 0x148500
addq $0x4, %r14
jmp 0x1426c0
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%rsp)
cmpl %ebp, %eax
jge 0x14267c
movq 0x58(%rsp), %rsi
cmpq 0x60(%rsp), %rsi
je 0x142706
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x58(%rsp)
jmp 0x142713
leaq 0x50(%rsp), %rdi
movq %r14, %rdx
callq 0x8a0d0
movl 0x8(%rsp), %eax
jmp 0x1426e2
movq 0x38(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0x30(%rsp), %rdi
callq 0x14865c
movq 0xf8(%rsp), %r15
movl %r14d, 0x78(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rsi
cmpq %rax, %rsi
je 0x142756
movq %rax, 0x18(%rsp)
movq %rax, %rsi
cmpq 0x20(%rsp), %rsi
je 0x142853
movl %r14d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
leaq 0x8(%rsp), %r14
jmp 0x142867
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x8d102
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x142797
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %r14
movq 0x58(%rsp), %r15
cmpq %r15, %r14
je 0x14282a
movl (%r14), %eax
movl %eax, 0x108(%rsp)
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x1427f6
movq %rbx, %r8
movq %r8, %rcx
movq %rdi, %rdx
movl 0x20(%rdi), %esi
xorl %edi, %edi
cmpl %eax, %esi
setl %dil
movq %rdx, %r8
cmovlq %rcx, %r8
movq 0x10(%rdx,%rdi,8), %rdi
testq %rdi, %rdi
jne 0x1427c4
cmpq %rbx, %r8
je 0x1427f6
cmpl %eax, %esi
cmovlq %rcx, %rdx
cmpl 0x20(%rdx), %eax
jge 0x142821
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x14280f
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x142821
leaq 0x10(%rsp), %rdi
leaq 0x108(%rsp), %rdx
callq 0x14646e
addq $0x4, %r14
jmp 0x1427a1
movq %rbp, %rdi
callq 0x40428
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x142849
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x190e0
movq 0xf8(%rsp), %r15
jmp 0x1428bb
leaq 0x10(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0x14646e
leaq 0x8(%rsp), %r14
testb %r13b, %r13b
je 0x1428b3
movl 0x78(%rsp), %eax
cmpl %ebp, %eax
jle 0x1428fc
decl %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x142897
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x1428a4
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
callq 0x8a0d0
movl 0x8(%rsp), %ecx
leal -0x1(%rcx), %eax
movl %eax, 0x8(%rsp)
cmpl %ebp, %ecx
jg 0x14287e
leaq 0x80(%rsp), %rbp
cmpb $0x2c, (%r12)
jne 0x1428ce
incq %r12
cmpq %r15, %r12
je 0x142aab
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x1428eb
movq 0xc0(%rsp), %rsi
subq %rdi, %rsi
callq 0x190e0
movb $0x1, %r14b
movq %r12, %r13
cmpq %r15, %r12
jne 0x1423b0
jmp 0x142933
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%rsp)
cmpl %ebp, %eax
jge 0x1428b3
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x142920
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x14292d
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
callq 0x8a0d0
movl 0x8(%rsp), %eax
jmp 0x1428fc
leaq 0x30(%rsp), %rdi
movq 0x8(%rdi), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x14865c
cmpb $0x3a, 0xf(%rsp)
movq 0xf0(%rsp), %r14
movq 0xe0(%rsp), %r15
jne 0x1429d2
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rax
subq %rdx, %rax
sarq $0x2, %rax
cmpq %rax, %r15
jae 0x1429f7
leal (,%r15,4), %ebx
addq %rbx, %rdx
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x1429aa
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x1429b2
movq %r14, %rdi
callq 0x14646e
addq $0x2, %r15
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rax
subq %rdx, %rax
sarq $0x2, %rax
addq $0x8, %rbx
cmpq %rax, %r15
jb 0x14298f
jmp 0x1429f7
movaps 0x30(%rsp), %xmm0
movups %xmm0, (%r14)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
xorl %edx, %edx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x142a13
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x190e0
movq 0x30(%rsp), %rdx
testq %rdx, %rdx
je 0x142a28
movq 0x40(%rsp), %rsi
subq %rdx, %rsi
movq %rdx, %rdi
callq 0x190e0
movq %r14, %rax
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
leaq 0x3de2b(%rip), %rsi # 0x18087c
movq %rax, %rdi
callq 0x192b0
movq 0xad540(%rip), %rsi # 0x1effa0
movq 0xad509(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x142ff1
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
leaq 0x3dddf(%rip), %rsi # 0x180867
movq %rax, %rdi
callq 0x192b0
movq 0xad509(%rip), %rsi # 0x1effa0
movq 0xad4d2(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x142ff1
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
leaq 0x3268e(%rip), %rsi # 0x17514d
movq %rax, %rdi
callq 0x192b0
movq 0xad4d2(%rip), %rsi # 0x1effa0
movq 0xad49b(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x142ff1
leaq 0xaea8f(%rip), %rdi # 0x1f1578
callq 0x193a0
testl %eax, %eax
je 0x1422c5
leaq 0xaea5b(%rip), %rdi # 0x1f1558
leaq 0x3dd29(%rip), %rsi # 0x18082d
movl $0x10, %edx
callq 0x3ebdc
leaq -0x103ed1(%rip), %rdi # 0x3ec44
leaq 0xaea3c(%rip), %rsi # 0x1f1558
leaq 0xadbf5(%rip), %rdx # 0x1f0718
callq 0x19a30
leaq 0xaea49(%rip), %rdi # 0x1f1578
callq 0x19650
jmp 0x1422c5
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
leaq 0x3dd03(%rip), %rsi # 0x180850
movq %rax, %rdi
callq 0x192b0
movq 0xad444(%rip), %rsi # 0x1effa0
movq 0xad40d(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x142ff1
movq %rax, %rbx
leaq 0xae9fe(%rip), %rdi # 0x1f1578
callq 0x19450
jmp 0x1432c2
jmp 0x142c67
movq %rdx, %r15
movq %rax, %rbx
movq %r14, %rdi
callq 0x19a40
jmp 0x142d00
movq %rdx, %r15
movq %rax, %rbx
jmp 0x142bd1
movq %rdx, %r15
movq %rax, %rbx
jmp 0x142d00
movq %rdx, %r15
movq %rax, %rbx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x142bd1
movq 0xf0(%rsp), %rax
movq 0x10(%rax), %rsi
subq %rdi, %rsi
callq 0x190e0
movq %r12, %r13
jmp 0x142d00
jmp 0x142caa
jmp 0x142caa
movq %rdx, %r15
movq %rax, %rbx
jmp 0x142bf9
movq %rdx, %r15
movq %rax, %rbx
movq %r14, %rdi
callq 0x19a40
movq %r12, %r13
jmp 0x142ce3
jmp 0x142caa
movq %rdx, %r15
movq %rax, %rbx
movq 0x70(%rsp), %r13
jmp 0x142ccc
jmp 0x142c72
jmp 0x142c1c
jmp 0x142c72
movq %rdx, %r15
movq %rax, %rbx
movq %r14, %rdi
callq 0x19a40
jmp 0x142ce3
jmp 0x142c72
jmp 0x142cb9
movq %rdx, %r15
movq %rax, %rbx
movq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x142cb0
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x142cb0
jmp 0x142ca2
jmp 0x142caa
movq %rdx, %r15
movq %rax, %rbx
jmp 0x142d00
movq %rdx, %r15
movq %rax, %rbx
jmp 0x142ce3
movq %rdx, %r15
movq %rax, %rbx
movq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x142ce3
movq 0x90(%rsp), %rsi
incq %rsi
jmp 0x142cde
movq %rdx, %r15
movq %rax, %rbx
jmp 0x142ccc
movq %rdx, %r15
movq %rax, %rbx
movq 0x70(%rsp), %r13
jmp 0x142ce3
jmp 0x142cb9
movq %rdx, %r15
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x40428
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x142ce3
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x190e0
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x142d00
movq 0xc0(%rsp), %rsi
subq %rdi, %rsi
callq 0x190e0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x142d17
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x190e0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x142d2e
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x190e0
cmpl $0x1, %r15d
jne 0x1432c2
movq %rbx, %rdi
callq 0x19060
movq %rax, %rbx
leaq 0x90(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
testq %r13, %r13
jne 0x142dcb
leaq 0x50(%rsp), %rdi
leaq 0x108(%rsp), %rdx
movq 0xd8(%rsp), %rsi
callq 0x1ed1a
leaq 0x3db44(%rip), %rsi # 0x1808c5
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x1d569
leaq 0x3a2d0(%rip), %rsi # 0x17d067
leaq 0x10(%rsp), %rdi
callq 0x19730
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x142e5d
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x142e6a
movq %r13, %r14
subq 0xd8(%rsp), %r14
jns 0x142de0
movq %r14, %rdi
callq 0x20572
movq %r13, %rbp
leaq 0x138(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0xd8(%rsp), %rsi
addq %rsi, %r14
leaq 0x128(%rsp), %rdi
movq %r14, %rdx
callq 0x1edc8
leaq 0x3da94(%rip), %rsi # 0x1808a6
leaq 0x108(%rsp), %rdi
leaq 0x128(%rsp), %rdx
callq 0x1d569
leaq 0x3da95(%rip), %rsi # 0x1808c3
leaq 0x108(%rsp), %rdi
callq 0x19730
leaq 0x60(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x142ebe
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x142ecb
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
movq 0x8(%rax), %rdx
leaq 0x30(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x19730
leaq 0xc0(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x142f17
movups (%rcx), %xmm0
movups %xmm0, (%r14)
jmp 0x142f2a
movq %rdx, 0x50(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x60(%rsp)
movq 0x8(%rax), %rdx
leaq 0x50(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbp, %rsi
callq 0x19730
leaq 0x20(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x142ff1
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
jmp 0x142ffe
movq %rdx, 0xb0(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xc0(%rsp)
movq 0x8(%rax), %rdx
leaq 0xb0(%rsp), %rbx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x80(%rsp), %rdi
movq %rbx, %rsi
callq 0x195c0
movq (%rbx), %rdi
cmpq %r14, %rdi
je 0x142f71
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x142f88
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x142fa3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x142fbe
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x190e0
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
leaq 0x80(%rsp), %rsi
movq %rax, %rdi
callq 0x192d0
movq 0xacfbe(%rip), %rsi # 0x1effa0
movq 0xacf87(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
movq 0x8(%rax), %rdx
leaq 0x10(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x3a046(%rip), %rsi # 0x17d067
callq 0x19730
leaq 0x40(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x14304b
movups (%rcx), %xmm0
leaq 0x40(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x143058
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
movq 0x8(%rax), %rdx
leaq 0x30(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x19730
leaq 0xc0(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1430ac
movups (%rcx), %xmm0
movups %xmm0, (%r14)
jmp 0x1430bf
movq %rdx, 0xb0(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xc0(%rsp)
movq 0x8(%rax), %rdx
leaq 0xb0(%rsp), %rbx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x80(%rsp), %rdi
movq %rbx, %rsi
callq 0x195c0
movq (%rbx), %rdi
cmpq %r14, %rdi
je 0x143106
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x143122
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x143139
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x143150
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x118(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x143171
movq 0x118(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x128(%rsp), %rdi
cmpq %r12, %rdi
je 0x142fbe
movq 0x138(%rsp), %rsi
jmp 0x142fb6
movq %rax, %rbx
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x1431b3
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x1431b3
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1431e4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x1431e4
jmp 0x14329d
movq %rax, %rbx
movq %r14, %rdi
callq 0x19a40
jmp 0x1432a0
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x14321c
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x14321c
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x143242
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x143242
movq %rax, %rbx
leaq 0x118(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x143262
movq 0x118(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x143262
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14327e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x14327e
movq %rax, %rbx
movq 0x128(%rsp), %rdi
cmpq %r12, %rdi
je 0x1432a0
movq 0x138(%rsp), %rsi
jmp 0x143291
jmp 0x14329d
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1432a0
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x1432a0
jmp 0x14329d
movq %rax, %rbx
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0x1432bd
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x190e0
callq 0x19890
movq %rbx, %rdi
callq 0x19710
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/QUtil.cc
|
QUtil::pdf_doc_to_utf8(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
std::string
QUtil::pdf_doc_to_utf8(std::string const& val)
{
std::string result;
size_t len = val.length();
for (unsigned int i = 0; i < len; ++i) {
unsigned char ch = static_cast<unsigned char>(val.at(i));
unsigned short ch_short = ch;
if ((ch >= 127) && (ch <= 160)) {
ch_short = pdf_doc_to_unicode[ch - 127];
} else if ((ch >= 24) && (ch <= 31)) {
ch_short = pdf_doc_low_to_unicode[ch - 24];
} else if (ch == 173) {
ch_short = 0xfffd;
}
result += QUtil::toUTF8(ch_short);
}
return result;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r13
testq %r13, %r13
je 0x1440b0
movq %rsi, %r14
movl $0x1, %r12d
leaq 0x18(%rsp), %rbp
xorl %esi, %esi
leaq 0x8(%rsp), %r15
movq 0x8(%r14), %rdx
cmpq %rsi, %rdx
jbe 0x1440c2
movq (%r14), %rax
movzbl (%rax,%rsi), %eax
leal -0x7f(%rax), %ecx
cmpb $0x21, %cl
ja 0x144049
addl $-0x7f, %eax
leaq 0x3c469(%rip), %rcx # 0x1804b0
jmp 0x14405d
movl %eax, %ecx
andb $-0x8, %cl
cmpb $0x18, %cl
jne 0x144063
addl $-0x18, %eax
leaq 0x3b783(%rip), %rcx # 0x17f7e0
movzwl (%rcx,%rax,2), %eax
jmp 0x14406d
cmpb $-0x53, %al
movl $0xfffd, %ecx # imm = 0xFFFD
cmovel %ecx, %eax
movzwl %ax, %esi
movq %r15, %rdi
callq 0x140d30
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x19810
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1440a1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
movl %r12d, %esi
incl %r12d
cmpq %rsi, %r13
ja 0x144021
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1d834(%rip), %rdi # 0x1618fd
xorl %eax, %eax
callq 0x19030
jmp 0x1440d2
movq %rax, %r14
jmp 0x1440f1
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1440f1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x144109
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movq %r14, %rdi
callq 0x19710
|
/jberkenbilt[P]qpdf/libqpdf/QUtil.cc
|
QUtil::call_main_from_wmain(int, wchar_t const* const*, std::function<int (int, char const* const*)>)
|
int
QUtil::call_main_from_wmain(
int argc, wchar_t const* const argv[], std::function<int(int, char const* const[])> realmain)
{
return ::call_main_from_wmain(true, argc, argv, [realmain](int new_argc, char* new_argv[]) {
return realmain(new_argc, new_argv);
});
}
|
pushq %rbp
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x145848
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movl $0x20, %edi
callq 0x19180
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
je 0x144a43
leaq 0x10(%rsp), %rdx
movups -0x10(%rdx), %xmm0
movups %xmm0, (%rax)
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0xc38(%rip), %rax # 0x14568a
movq %rax, 0x18(%rdx)
leaq 0xc61(%rip), %rax # 0x1456be
movq %rax, 0x10(%rdx)
movl %ebp, %edi
movq %rbx, %rsi
callq 0x14472f
movl %eax, %ebx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x144a86
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x144a9d
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
jmp 0x144aec
jmp 0x144aec
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x144acd
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x144acd
jmp 0x144aec
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x144ae4
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/QUtil.cc
|
ResourceFinder::ResourceFinder()
|
ResourceFinder::ResourceFinder() :
last_name_offset(0)
{
}
|
leaq 0xa6105(%rip), %rax # 0x1eedd8
movq %rax, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movq %rax, 0x28(%rdi)
leaq 0x38(%rdi), %rcx
movl %eax, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movq %rcx, 0x48(%rdi)
movq %rcx, 0x50(%rdi)
movq %rax, 0x58(%rdi)
leaq 0x68(%rdi), %rcx
movl %eax, 0x68(%rdi)
movq %rax, 0x70(%rdi)
movq %rcx, 0x78(%rdi)
movq %rcx, 0x80(%rdi)
movq %rax, 0x88(%rdi)
retq
nop
|
/jberkenbilt[P]qpdf/libqpdf/ResourceFinder.cc
|
qpdf_read
|
QPDF_ERROR_CODE
qpdf_read(qpdf_data qpdf, char const* filename, char const* password)
{
QPDF_ERROR_CODE status = QPDF_SUCCESS;
qpdf->filename = filename;
qpdf->password = password;
status = trap_errors(qpdf, &call_read);
// We no longer have a good way to exercise a file with both warnings and errors because qpdf is
// getting much better at recovering.
QTC::TC(
"qpdf",
"qpdf-c called qpdf_read",
(status == 0) ? 0
: (status & QPDF_WARNINGS) ? 1
: (status & QPDF_ERRORS) ? 2
: -1);
return status;
}
|
pushq %rbx
subq $0x20, %rsp
movq %rsi, 0x78(%rdi)
movq %rdx, 0x90(%rdi)
movq %rsp, %rsi
movq $0x0, 0x8(%rsi)
leaq 0x6b(%rip), %rax # 0x14ae55
movq %rax, (%rsi)
leaq 0xee48(%rip), %rax # 0x159c3c
movq %rax, 0x18(%rsi)
leaq 0xee45(%rip), %rax # 0x159c44
movq %rax, 0x10(%rsi)
callq 0x14aa1a
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14ae21
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x14ae4d
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14ae45
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc
|
qpdf_set_info_key
|
void
qpdf_set_info_key(qpdf_data qpdf, char const* key, char const* value)
{
if ((key == nullptr) || (std::strlen(key) == 0) || (key[0] != '/')) {
return;
}
QPDFObjectHandle value_object;
if (value) {
QTC::TC("qpdf", "qpdf-c set_info_key to value");
value_object = QPDFObjectHandle::newString(value);
} else {
QTC::TC("qpdf", "qpdf-c set_info_key to null");
value_object = QPDFObjectHandle::newNull();
}
QPDFObjectHandle trailer = qpdf->qpdf->getTrailer();
if (!trailer.hasKey("/Info")) {
QTC::TC("qpdf", "qpdf-c add info to trailer");
trailer.replaceKey(
"/Info", qpdf->qpdf->makeIndirectObject(QPDFObjectHandle::newDictionary()));
} else {
QTC::TC("qpdf", "qpdf-c set-info-key use existing info");
}
QPDFObjectHandle info = trailer.getKey("/Info");
info.replaceKey(key, value_object);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
testq %rsi, %rsi
je 0x14b456
movq %rsi, %rbx
cmpb $0x2f, (%rsi)
jne 0x14b456
movq %rdx, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
testq %rdx, %rdx
je 0x14b2bb
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x19420
leaq (%rax,%r15), %rdx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x1edc8
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0xc7dae
movaps 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x40(%rsp)
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x14b2cf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x14b2cf
movq %rsp, %r15
movq %r15, %rdi
callq 0xc6058
movaps (%r15), %xmm0
movaps %xmm0, 0x40(%rsp)
movq (%r14), %rsi
leaq 0x20(%rsp), %rdi
callq 0x3d364
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x19deb(%rip), %rsi # 0x1650d7
leaq 0x19de9(%rip), %rdx # 0x1650dc
movq %rsp, %rdi
callq 0x1edc8
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0xfb9a6
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x14b320
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %bpl, %bpl
jne 0x14b3a3
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x19da5(%rip), %rsi # 0x1650d7
leaq 0x19da3(%rip), %rdx # 0x1650dc
callq 0x1edc8
movq (%r14), %r14
leaq 0x50(%rsp), %rdi
callq 0xc823a
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rdx
movq %r14, %rsi
callq 0x130194
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
leaq 0x30(%rsp), %rdx
callq 0xfbff0
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x14b37e
callq 0x1ed58
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x14b38d
callq 0x1ed58
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x14b3a3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x19d27(%rip), %rsi # 0x1650d7
leaq 0x19d25(%rip), %rdx # 0x1650dc
callq 0x1edc8
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
callq 0xfbad6
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x14b3e4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rsp, %r14
movq %r15, (%r14)
movq %rbx, %rdi
callq 0x19420
leaq (%rax,%rbx), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1edc8
leaq 0x30(%rsp), %rdi
movq %rsp, %rsi
leaq 0x40(%rsp), %rdx
callq 0xfbff0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x14b429
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x14b438
callq 0x1ed58
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x14b447
callq 0x1ed58
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x14b456
callq 0x1ed58
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x14b47a
callq 0x1ed58
jmp 0x14b47a
movq %rax, %rbx
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x14b4e9
callq 0x1ed58
jmp 0x14b4e9
jmp 0x14b4e6
jmp 0x14b501
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x14b527
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x14b527
movq %rax, %rbx
jmp 0x14b527
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x14b4d1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x14b4d1
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x14b504
callq 0x1ed58
jmp 0x14b504
jmp 0x14b4e6
jmp 0x14b501
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x14b504
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x14b504
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x14b518
callq 0x1ed58
jmp 0x14b518
movq %rax, %rbx
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x14b527
callq 0x1ed58
movq %rbx, %rdi
callq 0x19710
|
/jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc
|
qpdf_replace_object
|
void
qpdf_replace_object(qpdf_data qpdf, int objid, int generation, qpdf_oh oh)
{
do_with_oh_void(qpdf, oh, [qpdf, objid, generation](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_replace_object");
qpdf->qpdf->replaceObject(objid, generation, o);
});
}
|
pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq %rdi, (%rax)
movl %esi, 0x8(%rax)
movl %edx, 0xc(%rax)
leaq 0x83ed(%rip), %rdx # 0x154812
movq %rdx, 0x18(%rax)
leaq 0x8458(%rip), %rdx # 0x154888
movq %rdx, 0x10(%rax)
movl %ecx, %esi
movq %rax, %rdx
callq 0x14c487
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14c455
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x14c47f
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14c477
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc
|
qpdf_oh_is_null
|
QPDF_BOOL
qpdf_oh_is_null(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_null");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return o.isNull(); });
}
|
pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq -0xf5(%rip), %rax # 0x14cf4e
movq %rax, (%rdx)
leaq 0xd0e9(%rip), %rax # 0x15a136
movq %rax, 0x18(%rdx)
leaq 0xd0e0(%rip), %rax # 0x15a138
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x7c42(%rip), %rax # 0x154cae
movq %rax, 0x18(%rcx)
leaq 0x7c45(%rip), %rax # 0x154cbc
movq %rax, 0x10(%rcx)
callq 0x14cb2e
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14d099
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x14d0b2
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
jmp 0x14d0fb
jmp 0x14d0fb
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14d0d8
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x14d0f1
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
jmp 0x14d0fb
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc
|
qpdf_oh_is_operator
|
QPDF_BOOL
qpdf_oh_is_operator(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_operator");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return o.isOperator(); });
}
|
pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq -0x532(%rip), %rax # 0x14cf4e
movq %rax, (%rdx)
leaq 0xccac(%rip), %rax # 0x15a136
movq %rax, 0x18(%rdx)
leaq 0xcca3(%rip), %rax # 0x15a138
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x78c3(%rip), %rax # 0x154d6c
movq %rax, 0x18(%rcx)
leaq 0x78c6(%rip), %rax # 0x154d7a
movq %rax, 0x10(%rcx)
callq 0x14cb2e
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14d4d6
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x14d4ef
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
jmp 0x14d538
jmp 0x14d538
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14d515
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x14d52e
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
jmp 0x14d538
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc
|
qpdf_oh_is_number
|
QPDF_BOOL
qpdf_oh_is_number(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_number");
return o.isNumber();
});
}
|
pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq -0xb21(%rip), %rax # 0x14cf4e
movq %rax, (%rdx)
leaq 0xc6bd(%rip), %rax # 0x15a136
movq %rax, 0x18(%rdx)
leaq 0xc6b4(%rip), %rax # 0x15a138
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x73de(%rip), %rax # 0x154e76
movq %rax, 0x18(%rcx)
leaq 0x73e1(%rip), %rax # 0x154e84
movq %rax, 0x10(%rcx)
callq 0x14cb2e
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14dac5
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x14dade
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
jmp 0x14db27
jmp 0x14db27
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14db04
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x14db1d
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
jmp 0x14db27
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc
|
char const* do_with_oh<char const*>(_qpdf_data*, unsigned int, std::function<char const* ()>, std::function<char const* (QPDFObjectHandle&)>)
|
static RET
do_with_oh(
qpdf_data qpdf,
qpdf_oh oh,
std::function<RET()> fallback,
std::function<RET(QPDFObjectHandle&)> fn)
{
return trap_oh_errors<RET>(qpdf, fallback, [fn, oh](qpdf_data q) {
auto i = q->oh_cache.find(oh);
bool result = ((i != q->oh_cache.end()) && (i->second).get());
if (!result) {
QTC::TC("qpdf", "qpdf-c invalid object handle");
throw QPDFExc(
qpdf_e_internal,
q->qpdf->getFilename(),
std::string("C API object handle ") + std::to_string(oh),
0,
"attempted access to unknown object handle");
}
return fn(*(q->oh_cache[oh]));
});
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xb0(%rsp), %rdi
movq %rdx, %rsi
callq 0x15a274
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x15a2d2
movl %ebp, 0x68(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x80(%rsp)
movl $0x28, %edi
callq 0x19180
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x60(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x58(%rsp), %rcx
testq %rcx, %rcx
je 0x14e373
leaq 0x58(%rsp), %rdx
movups -0x10(%rdx), %xmm0
movups %xmm0, (%rax)
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
movl %ebp, 0x20(%rax)
leaq 0x70(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x71bf(%rip), %rax # 0x155544
movq %rax, 0x18(%rsi)
leaq 0x73de(%rip), %rax # 0x15576e
movq %rax, 0x10(%rsi)
leaq 0x38(%rsp), %rax
leaq 0x8(%rsp), %r14
movq %rax, -0x8(%r14)
movq %r14, %rdi
callq 0x15a330
xorps %xmm0, %xmm0
movaps %xmm0, 0xa0(%rsp)
movaps %xmm0, 0x90(%rsp)
movl $0x28, %edi
callq 0x19180
movq (%rsp), %rcx
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rcx
testq %rcx, %rcx
je 0x14e40d
movq %rax, %rdx
addq $0x8, %rdx
leaq 0x18(%rsp), %rsi
movups (%r14), %xmm0
movups %xmm0, (%rdx)
movq %rcx, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
leaq 0x90(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x7041(%rip), %rax # 0x155460
movq %rax, 0x18(%rsi)
leaq 0x706a(%rip), %rax # 0x155494
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x14aa1a
movl %eax, %ebp
movq 0xa0(%rsp), %rax
testq %rax, %rax
je 0x14e457
leaq 0x90(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x14e46e
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
cmpl $0x2, %ebp
jae 0x14e47d
movq 0x38(%rsp), %rbx
jmp 0x14e57d
cmpb $0x0, 0xb0(%rbx)
jne 0x14e564
cmpb $0x0, 0xb1(%rbx)
jne 0x14e505
movl $0x1, 0x28(%rsp)
movq (%rbx), %rsi
movq %rsp, %rdi
callq 0x3a5fe
leaq 0x40(%rbx), %r14
leaq 0x44(%rsp), %r8
movl $0x0, (%r8)
leaq 0x2c7e9(%rip), %rcx # 0x17aca6
leaq 0x33ebb(%rip), %r9 # 0x18237f
leaq 0x28(%rsp), %rsi
movq %rsp, %rdx
movq %r14, %rdi
callq 0x159700
movq %rax, %rdi
movq %r14, %rsi
callq 0x19250
incq 0x50(%rbx)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14e4fe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
movb $0x1, 0xb1(%rbx)
leaq 0x28(%rsp), %rdi
callq 0xb937a
movq 0x28(%rsp), %rsi
movq %rsp, %rdi
xorl %edx, %edx
callq 0xb96be
movq (%rsp), %r14
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x30b90
leaq 0x2c767(%rip), %rsi # 0x17aca5
movq %rax, %rdi
callq 0x30b90
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x14e555
callq 0x1ed58
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x14e564
callq 0x1ed58
cmpq $0x0, 0xc0(%rsp)
je 0x14e5e0
leaq 0xb0(%rsp), %rdi
callq *0x18(%rdi)
movq %rax, %rbx
movq 0x80(%rsp), %rax
testq %rax, %rax
je 0x14e599
leaq 0x70(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0x14e5b2
leaq 0x48(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0xc0(%rsp), %rax
testq %rax, %rax
je 0x14e5d1
leaq 0xb0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x19ce0
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14e6a1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x14e6a1
movq %rax, %rbx
jmp 0x14e623
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x14e623
callq 0x1ed58
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x14e6a1
callq 0x1ed58
jmp 0x14e6a1
jmp 0x14e701
jmp 0x14e701
jmp 0x14e701
jmp 0x14e701
jmp 0x14e701
movq %rax, %rbx
movq 0xa0(%rsp), %rax
testq %rax, %rax
je 0x14e679
leaq 0x90(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x14e679
jmp 0x14e701
movq %rax, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x14e6a1
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x14e6a1
jmp 0x14e701
movq %rax, %rbx
jmp 0x14e6bd
movq %rax, %rbx
jmp 0x14e6d6
movq %rax, %rbx
movq 0x80(%rsp), %rax
testq %rax, %rax
je 0x14e6bd
leaq 0x70(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0x14e6d6
leaq 0x48(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0xc0(%rsp), %rax
testq %rax, %rax
je 0x14e6f5
leaq 0xb0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
jmp 0x14e701
jmp 0x14e701
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc
|
qpdf_oh_get_value_as_bool
|
QPDF_BOOL
qpdf_oh_get_value_as_bool(qpdf_data qpdf, qpdf_oh oh, QPDF_BOOL* value)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [value](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_value_as_bool");
bool v = *value;
QPDF_BOOL result = o.getValueAsBool(v);
if (result) {
*value = v;
}
return result;
});
}
|
pushq %rbx
subq $0x40, %rsp
xorl %r8d, %r8d
leaq 0x20(%rsp), %rax
movq %r8, 0x8(%rax)
leaq -0x1bc5(%rip), %rcx # 0x14cf4e
movq %rcx, (%rax)
leaq 0xb619(%rip), %rcx # 0x15a136
movq %rcx, 0x18(%rax)
leaq 0xb610(%rip), %rcx # 0x15a138
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %r8, 0x8(%rcx)
movq %rdx, (%rcx)
leaq 0x72b9(%rip), %rdx # 0x155df6
movq %rdx, 0x18(%rcx)
leaq 0x72e6(%rip), %rdx # 0x155e2e
movq %rdx, 0x10(%rcx)
movq %rax, %rdx
callq 0x14cb2e
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14eb6d
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x14eb86
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
jmp 0x14ebcf
jmp 0x14ebcf
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14ebac
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x14ebc5
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
jmp 0x14ebcf
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc
|
qpdf_oh_get_value_as_longlong
|
QPDF_BOOL
qpdf_oh_get_value_as_longlong(qpdf_data qpdf, qpdf_oh oh, long long* value)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [value](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_value_as_longlong");
return o.getValueAsInt(*value);
});
}
|
pushq %rbx
subq $0x40, %rsp
xorl %r8d, %r8d
leaq 0x20(%rsp), %rax
movq %r8, 0x8(%rax)
leaq -0x21be(%rip), %rcx # 0x14cf4e
movq %rcx, (%rax)
leaq 0xb020(%rip), %rcx # 0x15a136
movq %rcx, 0x18(%rax)
leaq 0xb017(%rip), %rcx # 0x15a138
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %r8, 0x8(%rcx)
movq %rdx, (%rcx)
leaq 0x7122(%rip), %rdx # 0x156258
movq %rdx, 0x18(%rcx)
leaq 0x712b(%rip), %rdx # 0x15626c
movq %rdx, 0x10(%rcx)
movq %rax, %rdx
callq 0x14cb2e
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14f166
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x14f17f
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
jmp 0x14f1c8
jmp 0x14f1c8
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14f1a5
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x14f1be
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
jmp 0x14f1c8
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc
|
qpdf_oh_get_value_as_int
|
QPDF_BOOL
qpdf_oh_get_value_as_int(qpdf_data qpdf, qpdf_oh oh, int* value)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [value](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_value_as_int");
return o.getValueAsInt(*value);
});
}
|
pushq %rbx
subq $0x40, %rsp
xorl %r8d, %r8d
leaq 0x20(%rsp), %rax
movq %r8, 0x8(%rax)
leaq -0x237d(%rip), %rcx # 0x14cf4e
movq %rcx, (%rax)
leaq 0xae61(%rip), %rcx # 0x15a136
movq %rcx, 0x18(%rax)
leaq 0xae58(%rip), %rcx # 0x15a138
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %r8, 0x8(%rcx)
movq %rdx, (%rcx)
leaq 0x6fe9(%rip), %rdx # 0x1562de
movq %rdx, 0x18(%rcx)
leaq 0x6ff2(%rip), %rdx # 0x1562f2
movq %rdx, 0x10(%rcx)
movq %rax, %rdx
callq 0x14cb2e
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14f325
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x14f33e
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
jmp 0x14f387
jmp 0x14f387
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14f364
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x14f37d
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
jmp 0x14f387
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc
|
qpdf_oh_get_value_as_number
|
QPDF_BOOL
qpdf_oh_get_value_as_number(qpdf_data qpdf, qpdf_oh oh, double* value)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [value](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_value_as_number");
return o.getValueAsNumber(*value);
});
}
|
pushq %rbx
subq $0x40, %rsp
xorl %r8d, %r8d
leaq 0x20(%rsp), %rax
movq %r8, 0x8(%rax)
leaq -0x333d(%rip), %rcx # 0x14cf4e
movq %rcx, (%rax)
leaq 0x9ea1(%rip), %rcx # 0x15a136
movq %rcx, 0x18(%rax)
leaq 0x9e98(%rip), %rcx # 0x15a138
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %r8, 0x8(%rcx)
movq %rdx, (%rcx)
leaq 0x6a43(%rip), %rdx # 0x156cf8
movq %rdx, 0x18(%rcx)
leaq 0x6a4c(%rip), %rdx # 0x156d0c
movq %rdx, 0x10(%rcx)
movq %rax, %rdx
callq 0x14cb2e
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1502e5
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1502fe
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
jmp 0x150347
jmp 0x150347
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x150324
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x15033d
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
jmp 0x150347
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc
|
qpdf_oh_get_binary_string_value
|
char const*
qpdf_oh_get_binary_string_value(qpdf_data qpdf, qpdf_oh oh, size_t* length)
{
return do_with_oh<char const*>(
qpdf, oh, return_T<char const*>(""), [qpdf, length](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_binary_string_value");
qpdf->tmp_string = o.getStringValue();
*length = qpdf->tmp_string.length();
return qpdf->tmp_string.c_str();
});
}
|
pushq %rbx
subq $0x50, %rsp
leaq 0x2a32d(%rip), %rax # 0x17aca6
leaq 0x48(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x28(%rsp), %rax
movq $0x0, 0x8(%rax)
movq %rcx, (%rax)
leaq 0x4a9a(%rip), %rcx # 0x155432
movq %rcx, 0x18(%rax)
leaq 0x4a97(%rip), %rcx # 0x15543a
movq %rcx, 0x10(%rax)
leaq 0x8(%rsp), %rcx
movq %rdi, (%rcx)
movq %rdx, 0x8(%rcx)
leaq 0x66ba(%rip), %rdx # 0x157074
movq %rdx, 0x18(%rcx)
leaq 0x6709(%rip), %rdx # 0x1570ce
movq %rdx, 0x10(%rcx)
movq %rax, %rdx
callq 0x14e2ee
movq %rax, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x1509ed
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x150a06
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
jmp 0x150a52
jmp 0x150a52
movq %rax, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x150a2f
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x150a48
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
jmp 0x150a52
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc
|
qpdf_oh_has_key
|
QPDF_BOOL
qpdf_oh_has_key(qpdf_data qpdf, qpdf_oh oh, char const* key)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [key](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_has_key");
return o.hasKey(key);
});
}
|
pushq %rbx
subq $0x40, %rsp
xorl %r8d, %r8d
leaq 0x20(%rsp), %rax
movq %r8, 0x8(%rax)
leaq -0x447d(%rip), %rcx # 0x14cf4e
movq %rcx, (%rax)
leaq 0x8d61(%rip), %rcx # 0x15a136
movq %rcx, 0x18(%rax)
leaq 0x8d58(%rip), %rcx # 0x15a138
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %r8, 0x8(%rcx)
movq %rdx, (%rcx)
leaq 0x62a3(%rip), %rdx # 0x157698
movq %rdx, 0x18(%rcx)
leaq 0x6310(%rip), %rdx # 0x157710
movq %rdx, 0x10(%rcx)
movq %rax, %rdx
callq 0x14cb2e
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x151425
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x15143e
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
jmp 0x151487
jmp 0x151487
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x151464
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x15147d
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
jmp 0x151487
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc
|
qpdf_oh_get_key_if_dict
|
qpdf_oh
qpdf_oh_get_key_if_dict(qpdf_data qpdf, qpdf_oh oh, char const* key)
{
return do_with_oh<qpdf_oh>(qpdf, oh, return_null(qpdf), [qpdf, key](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_key_if_dict");
return new_object(qpdf, o.getKeyIfDict(key));
});
}
|
pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rax
movq $0x0, 0x8(%rax)
movq %rdi, (%rax)
leaq 0x2c3b(%rip), %rcx # 0x1541bc
movq %rcx, 0x18(%rax)
leaq 0x2c38(%rip), %rcx # 0x1541c4
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %rdi, (%rcx)
movq %rdx, 0x8(%rcx)
leaq 0x6271(%rip), %rdx # 0x157812
movq %rdx, 0x18(%rcx)
leaq 0x631a(%rip), %rdx # 0x1578c6
movq %rdx, 0x10(%rcx)
movq %rax, %rdx
callq 0x14e7da
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1515d1
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1515ea
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
jmp 0x151633
jmp 0x151633
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x151610
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x151629
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
jmp 0x151633
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc
|
qpdf_oh_new_uninitialized
|
qpdf_oh
qpdf_oh_new_uninitialized(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_uninitialized");
return new_object(qpdf, QPDFObjectHandle());
}
|
pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
callq 0x14be97
movl %eax, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x15173b
callq 0x1ed58
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x151755
callq 0x1ed58
movq %rbx, %rdi
callq 0x19710
|
/jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc
|
qpdf_oh_new_real_from_double
|
qpdf_oh
qpdf_oh_new_real_from_double(qpdf_data qpdf, double value, int decimal_places)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_real_from_double");
return new_object(qpdf, QPDFObjectHandle::newReal(value, decimal_places));
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %edx
callq 0xc7cfc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14be97
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x151949
callq 0x1ed58
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x151965
callq 0x1ed58
movq %rbx, %rdi
callq 0x19710
|
/jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc
|
qpdf_oh_new_array
|
qpdf_oh
qpdf_oh_new_array(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_array");
return new_object(qpdf, QPDFObjectHandle::newArray());
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc6376
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14be97
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x151cdc
callq 0x1ed58
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x151cf8
callq 0x1ed58
movq %rbx, %rdi
callq 0x19710
|
/jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc
|
qpdf_oh_set_array_item
|
void
qpdf_oh_set_array_item(qpdf_data qpdf, qpdf_oh oh, int at, qpdf_oh item)
{
do_with_oh_void(qpdf, oh, [qpdf, at, item](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_set_array_item");
o.setArrayItem(at, qpdf_oh_item_internal(qpdf, item));
});
}
|
pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq %rdi, (%rax)
movl %edx, 0x8(%rax)
movl %ecx, 0xc(%rax)
leaq 0x5b6e(%rip), %rcx # 0x157a7a
movq %rcx, 0x18(%rax)
leaq 0x5bc1(%rip), %rcx # 0x157ad8
movq %rcx, 0x10(%rax)
movq %rax, %rdx
callq 0x14c487
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x151f3a
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x151f64
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x151f5c
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc
|
qpdf_push_inherited_attributes_to_page
|
QPDF_ERROR_CODE
qpdf_push_inherited_attributes_to_page(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_push_inherited_attributes_to_page");
return trap_errors(qpdf, [](qpdf_data q) { q->qpdf->pushInheritedAttributesToPage(); });
}
|
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x5940(%rip), %rax # 0x1587ce
movq %rax, 0x18(%rsi)
leaq 0x5941(%rip), %rax # 0x1587da
movq %rax, 0x10(%rsi)
callq 0x14aa1a
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x152ebb
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x152ee7
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x152edf
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc
|
qpdfjob_initialize_from_argv
|
int
qpdfjob_initialize_from_argv(qpdfjob_handle j, char const* const argv[])
{
return wrap_qpdfjob(j, [argv](qpdfjob_handle jh) {
jh->j.initializeFromArgv(argv);
return 0;
});
}
|
pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq $0x0, 0x8(%rax)
movq %rsi, (%rax)
leaq 0x848(%rip), %rcx # 0x15b4cc
movq %rcx, 0x18(%rax)
leaq 0x853(%rip), %rcx # 0x15b4e2
movq %rcx, 0x10(%rax)
movq %rax, %rsi
callq 0x15ace8
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x15acb4
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x15ace0
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x15acd8
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
movq %rax, %rdi
callq 0x1d07a
|
/jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc
|
qpdflogger_default_logger
|
qpdflogger_handle
qpdflogger_default_logger()
{
return new _qpdflogger_handle(QPDFLogger::defaultLogger());
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl $0x10, %edi
callq 0x19180
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb937a
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rbx)
testq %rdi, %rdi
je 0x15b984
movq 0x94619(%rip), %rax # 0x1eff80
cmpb $0x0, (%rax)
je 0x15b971
incl 0x8(%rdi)
jmp 0x15b97f
lock
incl 0x8(%rdi)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x15b984
callq 0x1ed58
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x190e0
movq %r14, %rdi
callq 0x19710
|
/jberkenbilt[P]qpdf/libqpdf/qpdflogger-c.cc
|
(anonymous namespace)::RC4Loader::getRC4()
|
EVP_CIPHER const*
RC4Loader::getRC4()
{
static auto loader = std::shared_ptr<RC4Loader>(new RC4Loader());
return loader->rc4;
}
|
pushq %r14
pushq %rbx
pushq %rax
movb 0x94f94(%rip), %al # 0x1f16f8
testb %al, %al
je 0x15c77b
movq 0x94f79(%rip), %rax # 0x1f16e8
movq 0x10(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x94f76(%rip), %rdi # 0x1f16f8
callq 0x193a0
testl %eax, %eax
je 0x15c768
movl $0x18, %edi
callq 0x19180
movq %rax, %rbx
movq %rax, %rdi
callq 0x15c93e
movq %rbx, %rdi
callq 0x15ca28
leaq 0x2fd(%rip), %rdi # 0x15caac
leaq 0x94f32(%rip), %rsi # 0x1f16e8
leaq 0x93f5b(%rip), %rdx # 0x1f0718
callq 0x19a30
leaq 0x94f2f(%rip), %rdi # 0x1f16f8
callq 0x19650
jmp 0x15c768
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x190e0
jmp 0x15c7e5
movq %rax, %r14
leaq 0x94f0c(%rip), %rdi # 0x1f16f8
callq 0x19450
movq %r14, %rdi
callq 0x19710
nop
|
/jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc
|
Utils::ArgumentParser::make_flag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
|
inline ArgFlag& ArgumentParser::make_flag( const std::string& name,
const std::string& description, const std::vector<std::string>& flg) {
assert(used_name.find(name) == used_name.end());
used_name.insert(name);
auto f = new ArgFlag(name,description,flg);
flags.push_back(f);
for ( auto i : flg ) {
assert(used_identifier.find(i) == used_identifier.end());
used_identifier.insert(i);
flag_mapping.insert( std::make_pair(i, f));
}
return *f;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
movq -0x10(%rbp), %rsi
callq 0x31c30
movq -0xf0(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x31c70
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x31c00
testb $0x1, %al
jne 0x2ee26
jmp 0x2ee28
jmp 0x2ee47
leaq 0x1ed8c(%rip), %rdi # 0x4dbbb
leaq 0x1edad(%rip), %rsi # 0x4dbe3
movl $0x120, %edx # imm = 0x120
leaq 0x1ee06(%rip), %rcx # 0x4dc48
callq 0x2a260
movq -0xf0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x31ca0
movq %rax, -0x40(%rbp)
movb %dl, -0x38(%rbp)
movl $0x68, %edi
callq 0x2a380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xf8(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x31cf0
jmp 0x2ee88
movq -0xf0(%rbp), %rdi
movq -0xf8(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x90, %rdi
leaq -0x48(%rbp), %rsi
callq 0x31d60
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x31dd0
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x31e00
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x31e30
testb $0x1, %al
jne 0x2eee2
jmp 0x2f0a8
leaq -0x68(%rbp), %rdi
callq 0x31e70
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x2a1a0
movq -0xf0(%rbp), %rdi
movq -0x108(%rbp), %rsi
addq $0x30, %rdi
callq 0x31c30
movq %rax, -0x100(%rbp)
jmp 0x2ef21
movq -0xf0(%rbp), %rdi
movq -0x100(%rbp), %rax
movq %rax, -0x98(%rbp)
addq $0x30, %rdi
callq 0x31c70
movq %rax, -0xa0(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x31c00
testb $0x1, %al
jne 0x2ef5f
jmp 0x2ef61
jmp 0x2efb3
leaq 0x1ed56(%rip), %rdi # 0x4dcbe
leaq 0x1ec74(%rip), %rsi # 0x4dbe3
movl $0x127, %edx # imm = 0x127
leaq 0x1eccd(%rip), %rcx # 0x4dc48
callq 0x2a260
movq -0xf8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x68, %esi
callq 0x2a390
jmp 0x2f0b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2f09a
movq -0xf0(%rbp), %rdi
addq $0x30, %rdi
leaq -0x90(%rbp), %rsi
callq 0x31ca0
movb %dl, -0x111(%rbp)
movq %rax, -0x110(%rbp)
jmp 0x2efd9
movq -0xf0(%rbp), %rax
movb -0x111(%rbp), %cl
movq -0x110(%rbp), %rdx
movq %rdx, -0xb0(%rbp)
movb %cl, -0xa8(%rbp)
addq $0xd8, %rax
movq %rax, -0x120(%rbp)
leaq -0xd8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x31ed0
jmp 0x2f020
movq -0x120(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x31e90
movb %dl, -0x129(%rbp)
movq %rax, -0x128(%rbp)
jmp 0x2f042
movb -0x129(%rbp), %al
movq -0x128(%rbp), %rcx
movq %rcx, -0xe8(%rbp)
movb %al, -0xe0(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x31f10
leaq -0x90(%rbp), %rdi
callq 0x2a6f8
leaq -0x68(%rbp), %rdi
callq 0x31f30
jmp 0x2eecc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x31f10
leaq -0x90(%rbp), %rdi
callq 0x2a6f8
jmp 0x2f0b5
movq -0x48(%rbp), %rax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2a630
nop
|
/GiuMaz[P]satyricon/include/ArgumentParser.hpp
|
Utils::ArgOption<unsigned int>& Utils::ArgumentParser::make_option<unsigned int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
|
ArgOption<T>& ArgumentParser::make_option( const std::string& name,
const std::string& description, const std::vector<std::string>& opts) {
assert(used_name.find(name) == used_name.end());
used_name.insert(name);
auto o = new ArgOption<T>(name,description,opts);
options.push_back(o);
for ( auto i : opts ) {
assert(used_identifier.find(i) == used_identifier.end());
used_identifier.insert(i);
option_mapping.insert( make_pair (i, o));
}
return *o;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
movq -0x10(%rbp), %rsi
callq 0x31c30
movq -0xf8(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x31c70
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x31c00
testb $0x1, %al
jne 0x2f626
jmp 0x2f628
jmp 0x2f647
leaq 0x1e58c(%rip), %rdi # 0x4dbbb
leaq 0x1e5ad(%rip), %rsi # 0x4dbe3
movl $0x105, %edx # imm = 0x105
leaq 0x1e959(%rip), %rcx # 0x4df9b
callq 0x2a260
movq -0xf8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x31ca0
movq %rax, -0x40(%rbp)
movb %dl, -0x38(%rbp)
movl $0x68, %edi
callq 0x2a380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x100(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x39300
jmp 0x2f688
movq -0xf8(%rbp), %rdi
movq -0x100(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x78, %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x37be0
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x31dd0
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0x31e00
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x31e30
testb $0x1, %al
jne 0x2f6e7
jmp 0x2f8ad
leaq -0x70(%rbp), %rdi
callq 0x31e70
movq %rax, %rsi
leaq -0x98(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x2a1a0
movq -0xf8(%rbp), %rdi
movq -0x110(%rbp), %rsi
addq $0x30, %rdi
callq 0x31c30
movq %rax, -0x108(%rbp)
jmp 0x2f726
movq -0xf8(%rbp), %rdi
movq -0x108(%rbp), %rax
movq %rax, -0xa0(%rbp)
addq $0x30, %rdi
callq 0x31c70
movq %rax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x31c00
testb $0x1, %al
jne 0x2f764
jmp 0x2f766
jmp 0x2f7b8
leaq 0x1e551(%rip), %rdi # 0x4dcbe
leaq 0x1e46f(%rip), %rsi # 0x4dbe3
movl $0x10c, %edx # imm = 0x10C
leaq 0x1e81b(%rip), %rcx # 0x4df9b
callq 0x2a260
movq -0x100(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x68, %esi
callq 0x2a390
jmp 0x2f8ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2f89f
movq -0xf8(%rbp), %rdi
addq $0x30, %rdi
leaq -0x98(%rbp), %rsi
callq 0x31ca0
movb %dl, -0x119(%rbp)
movq %rax, -0x118(%rbp)
jmp 0x2f7de
movq -0xf8(%rbp), %rax
movb -0x119(%rbp), %cl
movq -0x118(%rbp), %rdx
movq %rdx, -0xb8(%rbp)
movb %cl, -0xb0(%rbp)
addq $0xa8, %rax
movq %rax, -0x128(%rbp)
leaq -0xe0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x393b0
jmp 0x2f825
movq -0x128(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x39370
movb %dl, -0x131(%rbp)
movq %rax, -0x130(%rbp)
jmp 0x2f847
movb -0x131(%rbp), %al
movq -0x130(%rbp), %rcx
movq %rcx, -0xf0(%rbp)
movb %al, -0xe8(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x393f0
leaq -0x98(%rbp), %rdi
callq 0x2a6f8
leaq -0x70(%rbp), %rdi
callq 0x31f30
jmp 0x2f6d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x393f0
leaq -0x98(%rbp), %rdi
callq 0x2a6f8
jmp 0x2f8ba
movq -0x48(%rbp), %rax
addq $0x140, %rsp # imm = 0x140
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2a630
nopw %cs:(%rax,%rax)
nopl (%rax)
|
/GiuMaz[P]satyricon/include/ArgumentParser.hpp
|
Utils::ArgOption<float>::get_message[abi:cxx11]()
|
const std::string get_message() {
std::string opt("\e[1m");
for (auto o : opts) {
if (o.size() == 1) opt += "-" + o + " ";
else opt += "--" + o + " ";
}
opt += "<" + this->get_name() + ">\e[0m";
return this->argument_message(opt,8,80);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x160(%rbp)
movq %rdi, %rax
movq %rax, -0x158(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x2a640
movq -0x148(%rbp), %rdx
leaq 0x15202(%rip), %rsi # 0x4dcef
leaq -0x30(%rbp), %rdi
callq 0x2a510
jmp 0x38af8
leaq -0x31(%rbp), %rdi
callq 0x2a3e0
movq -0x150(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x33440
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x33470
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x334a0
testb $0x1, %al
jne 0x38b40
jmp 0x38cfb
leaq -0x58(%rbp), %rdi
callq 0x334e0
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0x2a1a0
jmp 0x38b57
leaq -0x80(%rbp), %rdi
callq 0x2a2a0
cmpq $0x1, %rax
jne 0x38c41
leaq 0x15184(%rip), %rsi # 0x4dcf5
leaq -0xc0(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0x33500
jmp 0x38b83
leaq 0x15170(%rip), %rdx # 0x4dcfa
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x2f4e0
jmp 0x38b9f
leaq -0x30(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x2a4b0
jmp 0x38bb1
leaq -0xa0(%rbp), %rdi
callq 0x2a6f8
leaq -0xc0(%rbp), %rdi
callq 0x2a6f8
jmp 0x38cd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x2a3e0
jmp 0x38ddd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x38dd4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x38ced
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x38c30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x2a6f8
leaq -0xc0(%rbp), %rdi
callq 0x2a6f8
jmp 0x38ced
leaq 0x150ac(%rip), %rsi # 0x4dcf4
leaq -0x100(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0x33500
jmp 0x38c5a
leaq 0x15099(%rip), %rdx # 0x4dcfa
leaq -0xe0(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x2f4e0
jmp 0x38c76
leaq -0x30(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x2a4b0
jmp 0x38c88
leaq -0xe0(%rbp), %rdi
callq 0x2a6f8
leaq -0x100(%rbp), %rdi
callq 0x2a6f8
jmp 0x38cd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x38cc8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x2a6f8
leaq -0x100(%rbp), %rdi
callq 0x2a6f8
jmp 0x38ced
leaq -0x80(%rbp), %rdi
callq 0x2a6f8
leaq -0x58(%rbp), %rdi
callq 0x33610
jmp 0x38b2a
leaq -0x80(%rbp), %rdi
callq 0x2a6f8
jmp 0x38dd4
movq -0x150(%rbp), %rdi
callq 0x35490
movq %rax, %rdx
leaq 0x151b6(%rip), %rsi # 0x4dec7
leaq -0x140(%rbp), %rdi
callq 0x33500
jmp 0x38d1f
leaq 0x151a3(%rip), %rdx # 0x4dec9
leaq -0x120(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x2f4e0
jmp 0x38d3b
leaq -0x30(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x2a4b0
jmp 0x38d4d
leaq -0x120(%rbp), %rdi
callq 0x2a6f8
leaq -0x140(%rbp), %rdi
callq 0x2a6f8
movq -0x160(%rbp), %rdi
movq -0x150(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movl $0x8, %ecx
movl $0x50, %r8d
callq 0x33630
jmp 0x38d89
leaq -0x30(%rbp), %rdi
callq 0x2a6f8
movq -0x158(%rbp), %rax
addq $0x160, %rsp # imm = 0x160
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x38dc8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x2a6f8
leaq -0x140(%rbp), %rdi
callq 0x2a6f8
leaq -0x30(%rbp), %rdi
callq 0x2a6f8
movq -0x40(%rbp), %rdi
callq 0x2a630
nopw %cs:(%rax,%rax)
|
/GiuMaz[P]satyricon/include/ArgumentParser.hpp
|
Utils::ArgOption<unsigned int>::get_message[abi:cxx11]()
|
const std::string get_message() {
std::string opt("\e[1m");
for (auto o : opts) {
if (o.size() == 1) opt += "-" + o + " ";
else opt += "--" + o + " ";
}
opt += "<" + this->get_name() + ">\e[0m";
return this->argument_message(opt,8,80);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x160(%rbp)
movq %rdi, %rax
movq %rax, -0x158(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x2a640
movq -0x148(%rbp), %rdx
leaq 0x147d2(%rip), %rsi # 0x4dcef
leaq -0x30(%rbp), %rdi
callq 0x2a510
jmp 0x39528
leaq -0x31(%rbp), %rdi
callq 0x2a3e0
movq -0x150(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x33440
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x33470
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x334a0
testb $0x1, %al
jne 0x39570
jmp 0x3972b
leaq -0x58(%rbp), %rdi
callq 0x334e0
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0x2a1a0
jmp 0x39587
leaq -0x80(%rbp), %rdi
callq 0x2a2a0
cmpq $0x1, %rax
jne 0x39671
leaq 0x14754(%rip), %rsi # 0x4dcf5
leaq -0xc0(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0x33500
jmp 0x395b3
leaq 0x14740(%rip), %rdx # 0x4dcfa
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x2f4e0
jmp 0x395cf
leaq -0x30(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x2a4b0
jmp 0x395e1
leaq -0xa0(%rbp), %rdi
callq 0x2a6f8
leaq -0xc0(%rbp), %rdi
callq 0x2a6f8
jmp 0x39706
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x2a3e0
jmp 0x3980d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x39804
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3971d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x39660
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x2a6f8
leaq -0xc0(%rbp), %rdi
callq 0x2a6f8
jmp 0x3971d
leaq 0x1467c(%rip), %rsi # 0x4dcf4
leaq -0x100(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0x33500
jmp 0x3968a
leaq 0x14669(%rip), %rdx # 0x4dcfa
leaq -0xe0(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x2f4e0
jmp 0x396a6
leaq -0x30(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x2a4b0
jmp 0x396b8
leaq -0xe0(%rbp), %rdi
callq 0x2a6f8
leaq -0x100(%rbp), %rdi
callq 0x2a6f8
jmp 0x39706
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x396f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x2a6f8
leaq -0x100(%rbp), %rdi
callq 0x2a6f8
jmp 0x3971d
leaq -0x80(%rbp), %rdi
callq 0x2a6f8
leaq -0x58(%rbp), %rdi
callq 0x33610
jmp 0x3955a
leaq -0x80(%rbp), %rdi
callq 0x2a6f8
jmp 0x39804
movq -0x150(%rbp), %rdi
callq 0x35490
movq %rax, %rdx
leaq 0x14786(%rip), %rsi # 0x4dec7
leaq -0x140(%rbp), %rdi
callq 0x33500
jmp 0x3974f
leaq 0x14773(%rip), %rdx # 0x4dec9
leaq -0x120(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x2f4e0
jmp 0x3976b
leaq -0x30(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x2a4b0
jmp 0x3977d
leaq -0x120(%rbp), %rdi
callq 0x2a6f8
leaq -0x140(%rbp), %rdi
callq 0x2a6f8
movq -0x160(%rbp), %rdi
movq -0x150(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movl $0x8, %ecx
movl $0x50, %r8d
callq 0x33630
jmp 0x397b9
leaq -0x30(%rbp), %rdi
callq 0x2a6f8
movq -0x158(%rbp), %rax
addq $0x160, %rsp # imm = 0x160
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x397f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x2a6f8
leaq -0x140(%rbp), %rdi
callq 0x2a6f8
leaq -0x30(%rbp), %rdi
callq 0x2a6f8
movq -0x40(%rbp), %rdi
callq 0x2a630
nopw %cs:(%rax,%rax)
|
/GiuMaz[P]satyricon/include/ArgumentParser.hpp
|
Satyricon::SATSolver::propagation()
|
SATSolver::ClausePtr SATSolver::propagation() {
while ( propagation_starting_pos < trail.size() ) {
PRINT_VERBOSE("propagate " << trail[propagation_starting_pos] << endl);
// extract the list of the opposite literal
// (they are false now, their watcher must be moved)
auto failed = !trail[propagation_starting_pos++];
propagation_to_move.clear();
swap(propagation_to_move,watch_list[failed.index()]);
for (auto it = propagation_to_move.begin();
it != propagation_to_move.end(); ++it) {
// propagate effect on a clause
Clause &c = *(it->get_clause()); // usefull reference
assert(c[0]==failed || c[1]==failed);
// make sure the false literal is in position 1
if ( c[0] == failed ) { c[0] = c[1]; c[1] = failed; }
// if the clause is already solved, nothing need to be moved
if (get_asigned_value(c[0]) == LIT_TRUE) {
// reinsert inside the previous watch list
watch_list[failed.index()].push_back(*it);
continue; // move to the next
}
// search a new literal to watch
bool foundt_new_watch = false;
for ( size_t pos = 2; pos != c.size(); ++pos) {
if ( get_asigned_value(c[pos]) != LIT_FALSE ) {
// swap value
c[1] = c[pos]; c[pos] = failed;
// insert in the new watch list
watch_list[c[1].index()].push_back(*it);
// move to the next
foundt_new_watch = true;
break;
}
}
if ( foundt_new_watch ) continue; // move to the next
// no new literal to watch, reinsert in the old position
watch_list[failed.index()].push_back(*it);
// the clause must be a conflict or a unit, try to assign the value
bool conflict = assign(c[0],it->get_clause());
if ( ! conflict ) continue; // no problem, move to the next
// conflict found in propagation
PRINT_VERBOSE("\tfound a conflict on " << (it->get_clause())->print() << endl);
ClausePtr conflict_clause = it->get_clause();
// reset the other literal to move (it is already set by propagate)
copy(++it, propagation_to_move.end(),
back_inserter(watch_list[failed.index()]));
return conflict_clause;
}
}
return nullptr; // no conflict
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
movq 0x98(%rdi), %rax
movq %rax, -0xb0(%rbp)
addq $0xa0, %rdi
callq 0x3af10
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
jae 0x3c430
movq -0xa8(%rbp), %rax
cmpl $0x2, 0xd0(%rax)
jl 0x3bef6
movq 0x23123(%rip), %rdi # 0x5efc8
leaq 0x12699(%rip), %rsi # 0x4e545
callq 0x2a370
movq %rax, %rcx
movq -0xa8(%rbp), %rax
movq %rcx, -0xb8(%rbp)
movq %rax, %rdi
addq $0xa0, %rdi
movq 0x98(%rax), %rsi
callq 0x40760
movq -0xb8(%rbp), %rdi
movq %rax, %rsi
callq 0x3ff60
movq %rax, %rdi
movq 0x2309f(%rip), %rsi # 0x5ef90
callq 0x2a3c0
movq -0xa8(%rbp), %rax
movq %rax, %rdi
addq $0xa0, %rdi
movq 0x98(%rax), %rsi
movq %rsi, %rcx
addq $0x1, %rcx
movq %rcx, 0x98(%rax)
callq 0x40760
movq %rax, %rdi
callq 0x40780
movq -0xa8(%rbp), %rdi
movl %eax, -0x14(%rbp)
addq $0x110, %rdi # imm = 0x110
callq 0x407c0
movq -0xa8(%rbp), %rax
movq %rax, %rcx
addq $0x110, %rcx # imm = 0x110
movq %rcx, -0xc0(%rbp)
addq $0x38, %rax
movq %rax, -0xc8(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x40830
movq -0xc8(%rbp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x40810
movq -0xc0(%rbp), %rdi
movq %rax, %rsi
callq 0x407e0
movq -0xa8(%rbp), %rdi
addq $0x110, %rdi # imm = 0x110
callq 0x40840
movq %rax, -0x20(%rbp)
movq -0xa8(%rbp), %rdi
addq $0x110, %rdi # imm = 0x110
callq 0x408b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x40870
testb $0x1, %al
jne 0x3bfce
jmp 0x3c42b
leaq -0x20(%rbp), %rdi
callq 0x408e0
movq %rax, %rdi
callq 0x40900
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x40920
movq %rax, %rdi
leaq -0x14(%rbp), %rsi
callq 0x40950
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xc9(%rbp)
jne 0x3c02b
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x40920
movq %rax, %rdi
leaq -0x14(%rbp), %rsi
callq 0x40950
movb %al, -0xc9(%rbp)
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x3c037
jmp 0x3c039
jmp 0x3c058
leaq 0x12510(%rip), %rdi # 0x4e550
leaq 0x12369(%rip), %rsi # 0x4e3b0
movl $0x14f, %edx # imm = 0x14F
leaq 0x1251a(%rip), %rcx # 0x4e56d
callq 0x2a260
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x40920
movq %rax, %rdi
leaq -0x14(%rbp), %rsi
callq 0x40950
testb $0x1, %al
jne 0x3c077
jmp 0x3c0b7
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x40920
movq %rax, -0xd8(%rbp)
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x40920
movq -0xd8(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x40920
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x40920
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
callq 0x3d790
cmpl $0x2, %eax
jne 0x3c127
movq -0xa8(%rbp), %rax
addq $0x38, %rax
movq %rax, -0xe8(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x40830
movq -0xe8(%rbp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x40810
movq %rax, -0xe0(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x409e0
movq -0xe0(%rbp), %rdi
movq %rax, %rsi
callq 0x40970
jmp 0x3c41d
movb $0x0, -0x31(%rbp)
movq $0x2, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0x30(%rbp), %rdi
callq 0x40a00
movq %rax, %rcx
movq -0xf0(%rbp), %rax
cmpq %rcx, %rax
je 0x3c231
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x40920
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
callq 0x3d790
cmpl $0x0, %eax
je 0x3c21e
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x40920
movq %rax, -0x108(%rbp)
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x40920
movq -0x108(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x40920
movq %rax, %rcx
movq -0xa8(%rbp), %rax
movl -0x14(%rbp), %edx
movl %edx, (%rcx)
addq $0x38, %rax
movq %rax, -0x100(%rbp)
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x40920
movq %rax, %rdi
callq 0x40830
movq -0x100(%rbp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x40810
movq %rax, -0xf8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x409e0
movq -0xf8(%rbp), %rdi
movq %rax, %rsi
callq 0x40970
movb $0x1, -0x31(%rbp)
jmp 0x3c231
jmp 0x3c220
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x3c133
testb $0x1, -0x31(%rbp)
je 0x3c23c
jmp 0x3c41d
movq -0xa8(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x118(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x40830
movq -0x118(%rbp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x40810
movq %rax, -0x110(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x409e0
movq -0x110(%rbp), %rdi
movq %rax, %rsi
callq 0x40970
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x40920
movl (%rax), %eax
movl %eax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x408e0
movq %rax, %rdi
callq 0x40900
movq -0xa8(%rbp), %rdi
movq %rax, %rdx
movl -0x48(%rbp), %esi
callq 0x3d820
andb $0x1, %al
movb %al, -0x41(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x3c2cb
jmp 0x3c41d
movq -0xa8(%rbp), %rax
cmpl $0x2, 0xd0(%rax)
jl 0x3c373
movq 0x22ce2(%rip), %rdi # 0x5efc8
leaq 0x122b9(%rip), %rsi # 0x4e5a6
callq 0x2a370
movq %rax, -0x130(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x408e0
movq %rax, %rdi
callq 0x40900
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x404f0
movq -0x130(%rbp), %rdi
movq -0x128(%rbp), %rsi
callq 0x2a350
movq %rax, -0x120(%rbp)
jmp 0x3c339
movq -0x120(%rbp), %rdi
movq 0x22c49(%rip), %rsi # 0x5ef90
callq 0x2a3c0
jmp 0x3c34e
leaq -0x68(%rbp), %rdi
callq 0x2a6f8
jmp 0x3c373
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2a6f8
jmp 0x3c445
leaq -0x20(%rbp), %rdi
callq 0x408e0
movq %rax, %rdi
callq 0x40900
movq %rax, -0x80(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x40a90
movq -0xa8(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x88(%rbp)
addq $0x110, %rdi # imm = 0x110
callq 0x408b0
movq %rax, %rcx
movq -0xa8(%rbp), %rax
movq %rcx, -0x90(%rbp)
addq $0x38, %rax
movq %rax, -0x138(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x40830
movq -0x138(%rbp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x40810
movq %rax, %rdi
callq 0x40ab0
movq %rax, -0x98(%rbp)
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x98(%rbp), %rdx
callq 0x40a20
movq %rax, -0xa0(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3c438
leaq -0x20(%rbp), %rdi
callq 0x40a90
jmp 0x3bfa1
jmp 0x3be5a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x140, %rsp # imm = 0x140
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x2a630
nop
|
/GiuMaz[P]satyricon/src/sat_solver.cpp
|
Satyricon::SATSolver::cancel_until(int)
|
void SATSolver::cancel_until( int level ) {
PRINT_VERBOSE("backtrack from " << current_level() <<
" to " << level << endl);
while ( current_level() > level )
cancel();
propagation_starting_pos = trail.size();
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x2, 0xd0(%rax)
jl 0x3cc34
movq 0x223e1(%rip), %rdi # 0x5efc8
leaq 0x118de(%rip), %rsi # 0x4e4cc
callq 0x2a370
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x3ff30
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x2a620
movq %rax, %rdi
leaq 0x118c7(%rip), %rsi # 0x4e4dc
callq 0x2a370
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2a620
movq %rax, %rdi
movq 0x22361(%rip), %rsi # 0x5ef90
callq 0x2a3c0
jmp 0x3cc36
movq -0x18(%rbp), %rdi
callq 0x3ff30
cmpl -0xc(%rbp), %eax
jle 0x3cc4f
movq -0x18(%rbp), %rdi
callq 0x3daa0
jmp 0x3cc36
movq -0x18(%rbp), %rdi
addq $0xa0, %rdi
callq 0x3af10
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x98(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/GiuMaz[P]satyricon/src/sat_solver.cpp
|
Satyricon::SATSolver::simplify_clause(Satyricon::Clause*)
|
bool SATSolver::simplify_clause( ClausePtr c ) {
size_t j = 0;
for ( const auto & l : *c ) {
if ( get_asigned_value(l) == LIT_TRUE )
return true; // useless
if ( get_asigned_value(l) == LIT_UNASIGNED )
c->at(j++) = l;
}
c->shrink(j);
return false; // still usefull
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x40130
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x40150
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x3d766
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x3d790
cmpl $0x2, %eax
jne 0x3d71c
movb $0x1, -0x1(%rbp)
jmp 0x3d777
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3d790
cmpl $0x1, %eax
jne 0x3d756
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
callq 0x40190
movq -0x50(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
jmp 0x3d758
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
jmp 0x3d6f2
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x401c0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/GiuMaz[P]satyricon/src/sat_solver.cpp
|
Satyricon::Literal_Heap::initialize()
|
void initialize() {
value.clear();
value.reserve(map_position.size());
for ( int i = 0; i < static_cast<int>(map_position.size()/2); ++i ) {
Literal l(i,false);
value.push_back(l);
map_position[l.index()] = value.size()-1;
l = Literal(i,true);
value.push_back(l);
map_position[l.index()] = value.size()-1;
}
assert( value.size() == map_position.size());
for ( int i = value.size()/2; i >= 0; --i )
heapify(i);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x8, %rdi
callq 0x3a6c0
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
addq $0x20, %rdi
callq 0x421a0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x420a0
movl $0x0, -0xc(%rbp)
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x20, %rdi
callq 0x421a0
movq %rax, %rcx
movl -0x2c(%rbp), %eax
shrq %rcx
cmpl %ecx, %eax
jge 0x4201d
movl -0xc(%rbp), %esi
leaq -0x10(%rbp), %rdi
xorl %edx, %edx
callq 0x30680
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x406f0
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x3af10
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
movl %ecx, -0x3c(%rbp)
addq $0x20, %rax
movq %rax, -0x48(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x40830
movq -0x48(%rbp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x406d0
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
movl -0xc(%rbp), %esi
leaq -0x14(%rbp), %rdi
movl $0x1, %edx
callq 0x30680
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
addq $0x8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x406f0
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x3af10
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
movl %ecx, -0x30(%rbp)
addq $0x20, %rax
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x40830
movq -0x38(%rbp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x406d0
movl -0x30(%rbp), %ecx
movl %ecx, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x41f28
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x3af10
movq -0x28(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x20, %rdi
callq 0x421a0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jne 0x42049
jmp 0x42068
leaq 0xc72b(%rip), %rdi # 0x4e77b
leaq 0xc748(%rip), %rsi # 0x4e79f
movl $0xdf, %edx
leaq 0xc79f(%rip), %rcx # 0x4e802
callq 0x2a260
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x3af10
shrq %rax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x42099
movq -0x28(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x421c0
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4207b
addq $0x50, %rsp
popq %rbp
retq
nop
|
/GiuMaz[P]satyricon/include/solver_types.hpp
|
main
|
int main(void)
{
GLFWwindow* window;
memset(joysticks, 0, sizeof(joysticks));
glfwSetErrorCallback(error_callback);
if (!glfwInit())
exit(EXIT_FAILURE);
find_joysticks();
glfwSetJoystickCallback(joystick_callback);
window = glfwCreateWindow(640, 480, "Joystick Test", NULL, NULL);
if (!window)
{
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
glfwMakeContextCurrent(window);
gladLoadGLLoader((GLADloadproc) glfwGetProcAddress);
glfwSwapInterval(1);
while (!glfwWindowShouldClose(window))
{
glClear(GL_COLOR_BUFFER_BIT);
draw_joysticks(window);
glfwSwapBuffers(window);
glfwPollEvents();
// Workaround for an issue with msvcrt and mintty
fflush(stdout);
}
glfwTerminate();
exit(EXIT_SUCCESS);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x1c9ec(%rip) # 0x2d590
movaps %xmm0, 0x1c9d5(%rip) # 0x2d580
movaps %xmm0, 0x1c9be(%rip) # 0x2d570
movaps %xmm0, 0x1c9a7(%rip) # 0x2d560
leaq -0x140(%rip), %rdi # 0x10a80
callq 0x14c1f
callq 0x14aa9
testl %eax, %eax
je 0x10c1f
xorl %ebx, %ebx
movl %ebx, %edi
callq 0x1580d
testl %eax, %eax
je 0x10be7
movl %ebx, %edi
movl $0x40001, %esi # imm = 0x40001
callq 0x10f59
incl %ebx
cmpl $0x10, %ebx
jne 0x10bd0
leaq 0x364(%rip), %rdi # 0x10f59
callq 0x1596d
leaq 0x10423(%rip), %rdx # 0x21024
movl $0x280, %edi # imm = 0x280
movl $0x1e0, %esi # imm = 0x1E0
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x16d71
testq %rax, %rax
jne 0x10c29
callq 0x14b20
movl $0x1, %edi
callq 0x10200
movq %rax, %rbx
leaq 0x406(%rip), %rsi # 0x11039
movq %rax, %rdi
callq 0x17ebe
movq %rbx, %rdi
callq 0x147cb
leaq 0x3ca8(%rip), %rdi # 0x148f2
callq 0x11050
movl $0x1, %edi
callq 0x148ba
movq %rbx, %rdi
callq 0x17355
testl %eax, %eax
jne 0x10f4d
leaq 0x1c8f0(%rip), %r14 # 0x2d560
leaq 0x1d521(%rip), %rbp # 0x2e198
movq %rbx, 0x48(%rsp)
movl $0x4000, %edi # imm = 0x4000
leaq 0x1cc68(%rip), %rax # 0x2d8f0
callq *(%rax)
movq %rbx, %rdi
leaq 0x14(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x17794
movl $0x1701, %edi # imm = 0x1701
leaq 0x1d058(%rip), %rbx # 0x2dd00
callq *(%rbx)
xorl %eax, %eax
leaq 0x1cafd(%rip), %rcx # 0x2d7b0
callq *(%rcx)
xorps %xmm1, %xmm1
cvtsi2sdl 0x14(%rsp), %xmm1
xorps %xmm2, %xmm2
cvtsi2sdl 0x10(%rsp), %xmm2
xorps %xmm0, %xmm0
xorps %xmm3, %xmm3
movsd 0x10333(%rip), %xmm4 # 0x21008
movsd 0x10333(%rip), %xmm5 # 0x21010
leaq 0x1ce1c(%rip), %rax # 0x2db00
callq *(%rax)
movl $0x1700, %edi # imm = 0x1700
callq *(%rbx)
movl 0x1c8ad(%rip), %esi # 0x2d5a0
testl %esi, %esi
jle 0x10f1c
xorl %edi, %edi
movl 0x10(%rsp), %ecx
movl %ecx, %eax
imull %edi, %eax
cltd
idivl %esi
movl %eax, %r15d
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
movl %ecx, %eax
cltd
idivl %esi
leal (%rax,%rax,2), %ecx
leal (%rax,%rax,2), %edx
addl $0x3, %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
sarl $0x2, %edx
movq %rdx, 0x38(%rsp)
leal 0x3(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
movl %ecx, 0x28(%rsp)
movq %rdi, 0x40(%rsp)
movl (%r14,%rdi,4), %edi
leaq 0x1c(%rsp), %rsi
callq 0x15850
movl 0x1c(%rsp), %ecx
testl %ecx, %ecx
movss 0x102c0(%rip), %xmm1 # 0x2101c
movss 0x102b4(%rip), %xmm0 # 0x21018
je 0x10e4e
movq %rax, %rsi
movl 0xc(%rsp), %eax
cltd
idivl %ecx
testl %ecx, %ecx
jle 0x10e4e
movl %eax, %r12d
movq 0x38(%rsp), %rcx
leal -0x5(%rcx), %eax
xorps %xmm2, %xmm2
cvtsi2ss %eax, %xmm2
movss %xmm2, 0x34(%rsp)
leal (%rcx,%r15), %eax
movl %eax, 0x30(%rsp)
leal 0x5(%r15), %eax
movl %eax, 0x2c(%rsp)
xorl %r14d, %r14d
xorl %r13d, %r13d
movq %rsi, 0x50(%rsp)
movss (%rsi,%r13,4), %xmm2
mulss %xmm0, %xmm2
addss %xmm0, %xmm2
mulss 0x34(%rsp), %xmm2
movss %xmm2, 0x20(%rsp)
movaps %xmm1, %xmm0
movss 0x10248(%rip), %xmm2 # 0x2101c
callq *(%rbp)
incq %r13
leal (%r12,%r14), %ebp
movl %r14d, %edi
movl %r15d, %esi
movl %ebp, %edx
movl 0x30(%rsp), %ecx
leaq 0x1d207(%rip), %rbx # 0x2dff8
callq *(%rbx)
movss 0x10225(%rip), %xmm0 # 0x21020
movapd %xmm0, %xmm1
movapd %xmm0, %xmm2
leaq 0x1d38e(%rip), %rax # 0x2e198
callq *(%rax)
cvttss2si 0x20(%rsp), %ecx
leal (%r15,%rcx), %esi
addl 0x2c(%rsp), %ecx
movl %r14d, %edi
movl %ebp, %edx
callq *(%rbx)
movss 0x101ef(%rip), %xmm0 # 0x21018
movss 0x101eb(%rip), %xmm1 # 0x2101c
movq 0x50(%rsp), %rsi
movslq 0x1c(%rsp), %rax
movl %ebp, %r14d
leaq 0x1d353(%rip), %rbp # 0x2e198
cmpq %rax, %r13
jl 0x10daf
leaq 0x1c70b(%rip), %r13 # 0x2d560
movq 0x40(%rsp), %rax
movl (%r13,%rax,4), %edi
leaq 0x18(%rsp), %rsi
callq 0x158bd
movq %rax, 0x20(%rsp)
movl 0x18(%rsp), %ecx
testl %ecx, %ecx
je 0x10efd
movl 0xc(%rsp), %eax
cltd
idivl %ecx
testl %ecx, %ecx
jle 0x10efd
movl %eax, %ebx
movl 0x28(%rsp), %r12d
sarl $0x2, %r12d
movq 0x38(%rsp), %rax
addl %r15d, %eax
movq %rax, %r13
addl %eax, %r12d
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x20(%rsp), %rax
cmpb $0x0, (%rax,%r15)
movq (%rbp), %rax
je 0x10ebe
movss 0x10164(%rip), %xmm0 # 0x21020
jmp 0x10ec6
movss 0x10156(%rip), %xmm0 # 0x2101c
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq *%rax
incq %r15
leal (%rbx,%r14), %ebp
movl %r14d, %edi
movl %r13d, %esi
movl %ebp, %edx
movl %r12d, %ecx
leaq 0x1d111(%rip), %rax # 0x2dff8
callq *(%rax)
movslq 0x18(%rsp), %rax
movl %ebp, %r14d
cmpq %rax, %r15
leaq 0x1d29d(%rip), %rbp # 0x2e198
jl 0x10ea4
movq 0x40(%rsp), %rdi
incq %rdi
movslq 0x1c694(%rip), %rsi # 0x2d5a0
cmpq %rsi, %rdi
leaq 0x1c64a(%rip), %r14 # 0x2d560
jl 0x10cfd
movq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x14865
callq 0x17f14
movq 0x1c0c3(%rip), %rax # 0x2cff8
movq (%rax), %rdi
callq 0x10a40
movq %rbx, %rdi
callq 0x17355
testl %eax, %eax
je 0x10c7c
callq 0x14b20
xorl %edi, %edi
callq 0x10200
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/tests/joysticks.c
|
joystick_callback
|
static void joystick_callback(int joy, int event)
{
if (event == GLFW_CONNECTED)
{
int axis_count, button_count;
glfwGetJoystickAxes(joy, &axis_count);
glfwGetJoystickButtons(joy, &button_count);
printf("Found joystick %i named \'%s\' with %i axes, %i buttons\n",
joy + 1,
glfwGetJoystickName(joy),
axis_count,
button_count);
joysticks[joystick_count++] = joy;
}
else if (event == GLFW_DISCONNECTED)
{
int i;
for (i = 0; i < joystick_count; i++)
{
if (joysticks[i] == joy)
break;
}
for (i = i + 1; i < joystick_count; i++)
joysticks[i - 1] = joysticks[i];
printf("Lost joystick %i\n", joy + 1);
joystick_count--;
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
cmpl $0x40001, %esi # imm = 0x40001
je 0x10fd5
cmpl $0x40002, %esi # imm = 0x40002
jne 0x1102e
movl 0x1c624(%rip), %eax # 0x2d5a0
leaq 0x1c5dd(%rip), %rcx # 0x2d560
xorl %edx, %edx
testl %eax, %eax
jle 0x10f9e
movq %rcx, %rsi
cmpl %ebx, (%rsi)
je 0x10f9e
incq %rdx
addq $0x4, %rsi
cmpq %rdx, %rax
jne 0x10f8c
movl %eax, %edx
leal 0x1(%rdx), %esi
cmpl %eax, %esi
jge 0x10fbb
movl %edx, %edx
movl 0x4(%rcx,%rdx,4), %edi
movl %edx, %r8d
movl %edi, (%rcx,%r8,4)
incq %rdx
incl %esi
cmpl %esi, %eax
jg 0x10fa7
incl %ebx
leaq 0x100b0(%rip), %rdi # 0x21074
movl %ebx, %esi
xorl %eax, %eax
callq 0x100a0
decl 0x1c5cd(%rip) # 0x2d5a0
jmp 0x1102e
leaq 0x4(%rsp), %r14
movl %ebx, %edi
movq %r14, %rsi
callq 0x15850
movq %rsp, %r15
movl %ebx, %edi
movq %r15, %rsi
callq 0x158bd
leal 0x1(%rbx), %ebp
movl %ebx, %edi
callq 0x1592a
movl (%r14), %ecx
movl (%r15), %r8d
leaq 0x10035(%rip), %rdi # 0x2103d
movl %ebp, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x100a0
movslq 0x1c585(%rip), %rax # 0x2d5a0
leal 0x1(%rax), %ecx
movl %ecx, 0x1c57c(%rip) # 0x2d5a0
leaq 0x1c535(%rip), %rcx # 0x2d560
movl %ebx, (%rcx,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/tests/joysticks.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);
find_extensionsGL();
load_GL_ARB_multisample(load);
load_GL_ARB_robustness(load);
return GLVersion.major != 0 || GLVersion.minor != 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, 0x1c53f(%rip) # 0x2d5a8
leaq 0x10016(%rip), %rdi # 0x21086
callq *%rbx
movq %rax, 0x1c537(%rip) # 0x2d5b0
xorl %ebp, %ebp
testq %rax, %rax
je 0x13e19
movl $0x1f02, %edi # imm = 0x1F02
callq *%rax
testq %rax, %rax
je 0x13e19
movl $0x1f02, %edi # imm = 0x1F02
callq *0x1c511(%rip) # 0x2d5b0
testq %rax, %rax
je 0x110df
movq %rax, %r14
xorl %r13d, %r13d
leaq 0x1bc2f(%rip), %rbp # 0x2cce0
movq (%r13,%rbp), %r12
movq %r12, %rdi
callq 0x10460
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x102a0
testl %eax, %eax
je 0x110ea
addq $0x8, %r13
cmpq $0x18, %r13
jne 0x110b1
jmp 0x110ed
movl 0x1c4d3(%rip), %edx # 0x2d5b8
jmp 0x11218
addq %r15, %r14
leaq 0x12bbf(%rip), %rsi # 0x23cb3
leaq 0x4(%rsp), %r15
movq %rsp, %r12
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x101e0
movl (%r15), %esi
movl (%r12), %r8d
xorl %eax, %eax
cmpl $0x2, %esi
setge %al
xorl %r12d, %r12d
cmpl $0x4, %esi
setge %r12b
cmpl $0x2, %r8d
movl $0x1, %r10d
movl %eax, %edi
cmovgel %r10d, %edi
movl %r12d, %ecx
cmovgel %r10d, %ecx
xorl %r13d, %r13d
cmpl $0x3, %esi
setge %r13b
cmovnel %r12d, %ecx
testl %r8d, %r8d
movl %eax, %edx
cmovnsl %r10d, %edx
movl %eax, %r15d
cmovgl %r10d, %r15d
movl %r13d, %r9d
cmovnsl %r10d, %r9d
movl %r13d, %r11d
cmovgl %r10d, %r11d
movl %r12d, %ebp
cmovnsl %r10d, %ebp
movl %r12d, %r14d
cmovgl %r10d, %r14d
cmpl $0x3, %esi
cmovnel %r12d, %ebp
cmovnel %r12d, %r14d
cmpl $0x2, %esi
movl %esi, 0x1c41e(%rip) # 0x2d5a8
cmovnel %r13d, %r9d
cmovnel %r13d, %r11d
cmpl $0x3, %r8d
movl %eax, %r12d
cmovgel %r10d, %r12d
movl %r8d, 0x1c408(%rip) # 0x2d5ac
movl %eax, %r13d
cmovgl %r10d, %r13d
cmpl $0x5, %r8d
movl %eax, %r8d
cmovgel %r10d, %r8d
cmpl %r10d, %esi
cmovnel %eax, %edx
movl %edx, 0x1c3f6(%rip) # 0x2d5b8
cmovnel %eax, %r15d
cmovnel %eax, %edi
movl %r15d, 0x1c3ec(%rip) # 0x2d5bc
movl %edi, 0x1c3ea(%rip) # 0x2d5c0
cmovnel %eax, %r12d
movl %r12d, 0x1c3e3(%rip) # 0x2d5c4
cmovnel %eax, %r13d
movl %r13d, 0x1c3dc(%rip) # 0x2d5c8
cmovnel %eax, %r8d
movl %r8d, 0x1c3d5(%rip) # 0x2d5cc
movl %r9d, 0x1c3d2(%rip) # 0x2d5d0
movl %r11d, 0x1c3cf(%rip) # 0x2d5d4
movl %ebp, 0x1c3cd(%rip) # 0x2d5d8
movl %r14d, 0x1c3ca(%rip) # 0x2d5dc
movl %ecx, 0x1c3c8(%rip) # 0x2d5e0
testl %edx, %edx
je 0x12540
leaq 0xfe92(%rip), %rdi # 0x210b9
callq *%rbx
movq %rax, 0x1cf88(%rip) # 0x2e1b8
leaq 0xfe8d(%rip), %rdi # 0x210c4
callq *%rbx
movq %rax, 0x1d858(%rip) # 0x2ea98
leaq 0xfe89(%rip), %rdi # 0x210d0
callq *%rbx
movq %rax, 0x1cdf0(%rip) # 0x2e040
leaq 0xfe80(%rip), %rdi # 0x210d7
callq *%rbx
movq %rax, 0x1c408(%rip) # 0x2d668
leaq 0xfe7c(%rip), %rdi # 0x210e3
callq *%rbx
movq %rax, 0x1c510(%rip) # 0x2d780
leaq 0xfe78(%rip), %rdi # 0x210ef
callq *%rbx
movq %rax, 0x1cbc8(%rip) # 0x2de48
leaq 0xfe76(%rip), %rdi # 0x210fd
callq *%rbx
movq %rax, 0x1d2a8(%rip) # 0x2e538
leaq 0xfe70(%rip), %rdi # 0x21107
callq *%rbx
movq %rax, 0x1cd08(%rip) # 0x2dfa8
leaq 0xfe70(%rip), %rdi # 0x21117
callq *%rbx
movq %rax, 0x1d710(%rip) # 0x2e9c0
leaq 0xfe71(%rip), %rdi # 0x21128
callq *%rbx
movq %rax, 0x1ccf0(%rip) # 0x2dfb0
leaq 0xfe71(%rip), %rdi # 0x21138
callq *%rbx
movq %rax, 0x1c698(%rip) # 0x2d968
leaq 0xfe72(%rip), %rdi # 0x21149
callq *%rbx
movq %rax, 0x1c680(%rip) # 0x2d960
leaq 0xfe6f(%rip), %rdi # 0x21156
callq *%rbx
movq %rax, 0x1d680(%rip) # 0x2e970
leaq 0xfe6c(%rip), %rdi # 0x21163
callq *%rbx
movq %rax, 0x1c7e8(%rip) # 0x2dae8
leaq 0xfe69(%rip), %rdi # 0x21170
callq *%rbx
movq %rax, 0x1c5e0(%rip) # 0x2d8f0
leaq 0xfe61(%rip), %rdi # 0x21178
callq *%rbx
movq %rax, 0x1d258(%rip) # 0x2e578
leaq 0xfe5e(%rip), %rdi # 0x21185
callq *%rbx
movq %rax, 0x1c890(%rip) # 0x2dbc0
leaq 0xfe5d(%rip), %rdi # 0x21194
callq *%rbx
movq %rax, 0x1cc58(%rip) # 0x2df98
leaq 0xfe5a(%rip), %rdi # 0x211a1
callq *%rbx
movq %rax, 0x1d628(%rip) # 0x2e978
leaq 0xfe58(%rip), %rdi # 0x211af
callq *%rbx
movq %rax, 0x1d370(%rip) # 0x2e6d0
leaq 0xfe54(%rip), %rdi # 0x211bb
callq *%rbx
movq %rax, 0x1d6e8(%rip) # 0x2ea58
leaq 0xfe50(%rip), %rdi # 0x211c7
callq *%rbx
movq %rax, 0x1cde8(%rip) # 0x2e168
leaq 0xfe4a(%rip), %rdi # 0x211d1
callq *%rbx
movq %rax, 0x1c6c0(%rip) # 0x2da50
leaq 0xfe43(%rip), %rdi # 0x211da
callq *%rbx
movq %rax, 0x1cb80(%rip) # 0x2df20
leaq 0xfe3c(%rip), %rdi # 0x211e3
callq *%rbx
movq %rax, 0x1c780(%rip) # 0x2db30
leaq 0xfe34(%rip), %rdi # 0x211eb
callq *%rbx
movq %rax, 0x1d130(%rip) # 0x2e4f0
leaq 0xfe30(%rip), %rdi # 0x211f7
callq *%rbx
movq %rax, 0x1cda0(%rip) # 0x2e170
leaq 0xfe2a(%rip), %rdi # 0x21201
callq *%rbx
movq %rax, 0x1d040(%rip) # 0x2e420
leaq 0xfe28(%rip), %rdi # 0x2120f
callq *%rbx
movq %rax, 0x1c528(%rip) # 0x2d918
leaq 0xfe24(%rip), %rdi # 0x2121b
callq *%rbx
movq %rax, 0x1d260(%rip) # 0x2e660
leaq 0xfe20(%rip), %rdi # 0x21227
callq *%rbx
movq %rax, 0x1cbc8(%rip) # 0x2dfd8
leaq 0xfe1e(%rip), %rdi # 0x21235
callq *%rbx
movq %rax, 0x1c980(%rip) # 0x2dda0
leaq 0xfe1c(%rip), %rdi # 0x21243
callq *%rbx
movq %rax, 0x1ce48(%rip) # 0x2e278
leaq 0xfe19(%rip), %rdi # 0x21250
callq *%rbx
movq %rax, 0x1cf50(%rip) # 0x2e390
leaq 0xfe16(%rip), %rdi # 0x2125d
callq *%rbx
movq %rax, 0x1cad8(%rip) # 0x2df28
leaq 0xfe14(%rip), %rdi # 0x2126b
callq *%rbx
movq %rax, 0x1c8f8(%rip) # 0x2dd58
leaq 0x166ee(%rip), %rdi # 0x27b55
callq *%rbx
movq %rax, 0x1d458(%rip) # 0x2e8c8
leaq 0xfe01(%rip), %rdi # 0x21278
callq *%rbx
movq %rax, 0x1d460(%rip) # 0x2e8e0
leaq 0xfdfd(%rip), %rdi # 0x21284
callq *%rbx
movq %rax, 0x1d498(%rip) # 0x2e928
leaq 0xfbef(%rip), %rdi # 0x21086
callq *%rbx
movq %rax, 0x1c110(%rip) # 0x2d5b0
leaq 0xfdeb(%rip), %rdi # 0x21292
callq *%rbx
movq %rax, 0x1c4d0(%rip) # 0x2d980
leaq 0xfde9(%rip), %rdi # 0x212a0
callq *%rbx
movq %rax, 0x1d1d8(%rip) # 0x2e698
leaq 0xfded(%rip), %rdi # 0x212b4
callq *%rbx
movq %rax, 0x1cc20(%rip) # 0x2e0f0
leaq 0xfdf1(%rip), %rdi # 0x212c8
callq *%rbx
movq %rax, 0x1d428(%rip) # 0x2e908
leaq 0xfdfa(%rip), %rdi # 0x212e1
callq *%rbx
movq %rax, 0x1c698(%rip) # 0x2db88
leaq 0xfe03(%rip), %rdi # 0x212fa
callq *%rbx
movq %rax, 0x1c410(%rip) # 0x2d910
leaq 0xfdff(%rip), %rdi # 0x21306
callq *%rbx
movq %rax, 0x1c5c0(%rip) # 0x2dad0
leaq 0xfdfc(%rip), %rdi # 0x21313
callq *%rbx
movq %rax, 0x1ca40(%rip) # 0x2df60
leaq 0xfdf7(%rip), %rdi # 0x2131e
callq *%rbx
movq %rax, 0x1caf8(%rip) # 0x2e028
leaq 0xfdf1(%rip), %rdi # 0x21328
callq *%rbx
movq %rax, 0x1d2b8(%rip) # 0x2e7f8
leaq 0xfdeb(%rip), %rdi # 0x21332
callq *%rbx
movq %rax, 0x1c7f8(%rip) # 0x2dd48
leaq 0xfde6(%rip), %rdi # 0x2133d
callq *%rbx
movq %rax, 0x1c848(%rip) # 0x2dda8
leaq 0xfde2(%rip), %rdi # 0x21349
callq *%rbx
movq %rax, 0x1cd38(%rip) # 0x2e2a8
leaq 0xfde0(%rip), %rdi # 0x21357
callq *%rbx
movq %rax, 0x1d248(%rip) # 0x2e7c8
leaq 0xfddb(%rip), %rdi # 0x21362
callq *%rbx
movq %rax, 0x1d0e0(%rip) # 0x2e670
leaq 0xfdd6(%rip), %rdi # 0x2136d
callq *%rbx
movq %rax, 0x1c2f0(%rip) # 0x2d890
leaq 0xfdce(%rip), %rdi # 0x21375
callq *%rbx
movq %rax, 0x1c418(%rip) # 0x2d9c8
leaq 0xfdc7(%rip), %rdi # 0x2137e
callq *%rbx
movq %rax, 0x1c210(%rip) # 0x2d7d0
leaq 0xfdc1(%rip), %rdi # 0x21388
callq *%rbx
movq %rax, 0x1d200(%rip) # 0x2e7d0
leaq 0xfdbc(%rip), %rdi # 0x21393
callq *%rbx
movq %rax, 0x1cbe8(%rip) # 0x2e1c8
leaq 0xfdb6(%rip), %rdi # 0x2139d
callq *%rbx
movq %rax, 0x1caf0(%rip) # 0x2e0e0
leaq 0xfdb1(%rip), %rdi # 0x213a8
callq *%rbx
movq %rax, 0x1cb98(%rip) # 0x2e198
leaq 0xfdab(%rip), %rdi # 0x213b2
callq *%rbx
movq %rax, 0x1d458(%rip) # 0x2ea68
leaq 0xfda6(%rip), %rdi # 0x213bd
callq *%rbx
movq %rax, 0x1c1e0(%rip) # 0x2d800
leaq 0xfda0(%rip), %rdi # 0x213c7
callq *%rbx
movq %rax, 0x1d108(%rip) # 0x2e738
leaq 0xfd9b(%rip), %rdi # 0x213d2
callq *%rbx
movq %rax, 0x1c1d8(%rip) # 0x2d818
leaq 0xfd95(%rip), %rdi # 0x213dc
callq *%rbx
movq %rax, 0x1c208(%rip) # 0x2d858
leaq 0xfd90(%rip), %rdi # 0x213e7
callq *%rbx
movq %rax, 0x1d020(%rip) # 0x2e680
leaq 0xfd8b(%rip), %rdi # 0x213f2
callq *%rbx
movq %rax, 0x1c230(%rip) # 0x2d8a0
leaq 0xfd87(%rip), %rdi # 0x213fe
callq *%rbx
movq %rax, 0x1d020(%rip) # 0x2e6a0
leaq 0xfd82(%rip), %rdi # 0x21409
callq *%rbx
movq %rax, 0x1cfb8(%rip) # 0x2e648
leaq 0xfd7e(%rip), %rdi # 0x21415
callq *%rbx
movq %rax, 0x1cfa0(%rip) # 0x2e640
leaq 0xfd79(%rip), %rdi # 0x21420
callq *%rbx
movq %rax, 0x1d160(%rip) # 0x2e810
leaq 0xfd75(%rip), %rdi # 0x2142c
callq *%rbx
movq %rax, 0x1c808(%rip) # 0x2dec8
leaq 0xfd6f(%rip), %rdi # 0x21436
callq *%rbx
movq %rax, 0x1c0c8(%rip) # 0x2d798
leaq 0xfd6a(%rip), %rdi # 0x21441
callq *%rbx
movq %rax, 0x1c800(%rip) # 0x2dee0
leaq 0xfd64(%rip), %rdi # 0x2144b
callq *%rbx
movq %rax, 0x1ced8(%rip) # 0x2e5c8
leaq 0xfd5f(%rip), %rdi # 0x21456
callq *%rbx
movq %rax, 0x1c7d8(%rip) # 0x2ded8
leaq 0xfd59(%rip), %rdi # 0x21460
callq *%rbx
movq %rax, 0x1c350(%rip) # 0x2da60
leaq 0xfd54(%rip), %rdi # 0x2146b
callq *%rbx
movq %rax, 0x1c7c8(%rip) # 0x2dee8
leaq 0xfd4e(%rip), %rdi # 0x21475
callq *%rbx
movq %rax, 0x1cba8(%rip) # 0x2e2d8
leaq 0xfd49(%rip), %rdi # 0x21480
callq *%rbx
movq %rax, 0x1c740(%rip) # 0x2de80
leaq 0xfd43(%rip), %rdi # 0x2148a
callq *%rbx
movq %rax, 0x1cfc0(%rip) # 0x2e710
leaq 0xfd3e(%rip), %rdi # 0x21495
callq *%rbx
movq %rax, 0x1c8a0(%rip) # 0x2e000
leaq 0xfd39(%rip), %rdi # 0x214a0
callq *%rbx
movq %rax, 0x1cd10(%rip) # 0x2e480
leaq 0xfd35(%rip), %rdi # 0x214ac
callq *%rbx
movq %rax, 0x1bf48(%rip) # 0x2d6c8
leaq 0xfd30(%rip), %rdi # 0x214b7
callq *%rbx
movq %rax, 0x1cca8(%rip) # 0x2e438
leaq 0xfd2c(%rip), %rdi # 0x214c3
callq *%rbx
movq %rax, 0x1c890(%rip) # 0x2e030
leaq 0xfd27(%rip), %rdi # 0x214ce
callq *%rbx
movq %rax, 0x1d230(%rip) # 0x2e9e0
leaq 0xfd23(%rip), %rdi # 0x214da
callq *%rbx
movq %rax, 0x1c020(%rip) # 0x2d7e0
leaq 0xfd1e(%rip), %rdi # 0x214e5
callq *%rbx
movq %rax, 0x1c890(%rip) # 0x2e060
leaq 0xfd1a(%rip), %rdi # 0x214f1
callq *%rbx
movq %rax, 0x1cd48(%rip) # 0x2e528
leaq 0xfd10(%rip), %rdi # 0x214f7
callq *%rbx
movq %rax, 0x1be60(%rip) # 0x2d650
leaq 0xfd09(%rip), %rdi # 0x21500
callq *%rbx
movq %rax, 0x1c778(%rip) # 0x2df78
leaq 0xfd03(%rip), %rdi # 0x2150a
callq *%rbx
movq %rax, 0x1be50(%rip) # 0x2d660
leaq 0xfcfc(%rip), %rdi # 0x21513
callq *%rbx
movq %rax, 0x1be80(%rip) # 0x2d6a0
leaq 0xfcf6(%rip), %rdi # 0x2151d
callq *%rbx
movq %rax, 0x1bdf0(%rip) # 0x2d620
leaq 0xfcef(%rip), %rdi # 0x21526
callq *%rbx
movq %rax, 0x1c300(%rip) # 0x2db40
leaq 0xfce9(%rip), %rdi # 0x21530
callq *%rbx
movq %rax, 0x1be30(%rip) # 0x2d680
leaq 0xfce2(%rip), %rdi # 0x21539
callq *%rbx
movq %rax, 0x1c148(%rip) # 0x2d9a8
leaq 0xfcdc(%rip), %rdi # 0x21543
callq *%rbx
movq %rax, 0x1d1a0(%rip) # 0x2ea10
leaq 0xfcd7(%rip), %rdi # 0x2154e
callq *%rbx
movq %rax, 0x1c3d8(%rip) # 0x2dc58
leaq 0xfcd3(%rip), %rdi # 0x2155a
callq *%rbx
movq %rax, 0x1d178(%rip) # 0x2ea08
leaq 0xfcce(%rip), %rdi # 0x21565
callq *%rbx
movq %rax, 0x1cab8(%rip) # 0x2e358
leaq 0xfcca(%rip), %rdi # 0x21571
callq *%rbx
movq %rax, 0x1d150(%rip) # 0x2ea00
leaq 0xfcc5(%rip), %rdi # 0x2157c
callq *%rbx
movq %rax, 0x1c200(%rip) # 0x2dac0
leaq 0xfcc1(%rip), %rdi # 0x21588
callq *%rbx
movq %rax, 0x1d128(%rip) # 0x2e9f8
leaq 0xfcbc(%rip), %rdi # 0x21593
callq *%rbx
movq %rax, 0x1cd28(%rip) # 0x2e608
leaq 0xfcb8(%rip), %rdi # 0x2159f
callq *%rbx
movq %rax, 0x1cc98(%rip) # 0x2e588
leaq 0xfcb3(%rip), %rdi # 0x215aa
callq *%rbx
movq %rax, 0x1c720(%rip) # 0x2e020
leaq 0xfcaf(%rip), %rdi # 0x215b6
callq *%rbx
movq %rax, 0x1be98(%rip) # 0x2d7a8
leaq 0xfcad(%rip), %rdi # 0x215c4
callq *%rbx
movq %rax, 0x1c928(%rip) # 0x2e248
leaq 0xfcac(%rip), %rdi # 0x215d3
callq *%rbx
movq %rax, 0x1be70(%rip) # 0x2d7a0
leaq 0xfcaa(%rip), %rdi # 0x215e1
callq *%rbx
movq %rax, 0x1bd78(%rip) # 0x2d6b8
leaq 0xfca9(%rip), %rdi # 0x215f0
callq *%rbx
movq %rax, 0x1be68(%rip) # 0x2d7b8
leaq 0xfca7(%rip), %rdi # 0x215fe
callq *%rbx
movq %rax, 0x1cb40(%rip) # 0x2e4a0
leaq 0xfca6(%rip), %rdi # 0x2160d
callq *%rbx
movq %rax, 0x1c5d0(%rip) # 0x2df40
leaq 0xfca4(%rip), %rdi # 0x2161b
callq *%rbx
movq %rax, 0x1c4f0(%rip) # 0x2de70
leaq 0xfca3(%rip), %rdi # 0x2162a
callq *%rbx
movq %rax, 0x1c450(%rip) # 0x2dde0
leaq 0xfca1(%rip), %rdi # 0x21638
callq *%rbx
movq %rax, 0x1caa8(%rip) # 0x2e448
leaq 0xfca0(%rip), %rdi # 0x21647
callq *%rbx
movq %rax, 0x1c438(%rip) # 0x2dde8
leaq 0xfc9e(%rip), %rdi # 0x21655
callq *%rbx
movq %rax, 0x1c138(%rip) # 0x2daf8
leaq 0xfc9d(%rip), %rdi # 0x21664
callq *%rbx
movq %rax, 0x1c400(%rip) # 0x2ddd0
leaq 0xfc9b(%rip), %rdi # 0x21672
callq *%rbx
movq %rax, 0x1c518(%rip) # 0x2def8
leaq 0xfc9a(%rip), %rdi # 0x21681
callq *%rbx
movq %rax, 0x1c450(%rip) # 0x2de40
leaq 0xfc98(%rip), %rdi # 0x2168f
callq *%rbx
movq %rax, 0x1c148(%rip) # 0x2db48
leaq 0xfc97(%rip), %rdi # 0x2169e
callq *%rbx
movq %rax, 0x1c8e8(%rip) # 0x2e2f8
leaq 0xfc95(%rip), %rdi # 0x216ac
callq *%rbx
movq %rax, 0x1cf28(%rip) # 0x2e948
leaq 0xfc94(%rip), %rdi # 0x216bb
callq *%rbx
movq %rax, 0x1c8d0(%rip) # 0x2e300
leaq 0xfc92(%rip), %rdi # 0x216c9
callq *%rbx
movq %rax, 0x1c5a8(%rip) # 0x2dfe8
leaq 0xfc91(%rip), %rdi # 0x216d8
callq *%rbx
movq %rax, 0x1cb18(%rip) # 0x2e568
leaq 0xfc8f(%rip), %rdi # 0x216e6
callq *%rbx
movq %rax, 0x1c5f8(%rip) # 0x2e058
leaq 0xfc8e(%rip), %rdi # 0x216f5
callq *%rbx
movq %rax, 0x1cc80(%rip) # 0x2e6f0
leaq 0xfc8c(%rip), %rdi # 0x21703
callq *%rbx
movq %rax, 0x1c3f8(%rip) # 0x2de78
leaq 0xfc8b(%rip), %rdi # 0x21712
callq *%rbx
movq %rax, 0x1c588(%rip) # 0x2e018
leaq 0xfc83(%rip), %rdi # 0x2171a
callq *%rbx
movq %rax, 0x1bb90(%rip) # 0x2d630
leaq 0xfc7c(%rip), %rdi # 0x21723
callq *%rbx
movq %rax, 0x1c560(%rip) # 0x2e010
leaq 0xfc74(%rip), %rdi # 0x2172b
callq *%rbx
movq %rax, 0x1c6f0(%rip) # 0x2e1b0
leaq 0xfc6d(%rip), %rdi # 0x21734
callq *%rbx
movq %rax, 0x1c528(%rip) # 0x2dff8
leaq 0xfc65(%rip), %rdi # 0x2173c
callq *%rbx
movq %rax, 0x1c960(%rip) # 0x2e440
leaq 0xfc5e(%rip), %rdi # 0x21745
callq *%rbx
movq %rax, 0x1c558(%rip) # 0x2e048
leaq 0xfc56(%rip), %rdi # 0x2174d
callq *%rbx
movq %rax, 0x1ced8(%rip) # 0x2e9d8
leaq 0xfc4f(%rip), %rdi # 0x21756
callq *%rbx
movq %rax, 0x1cc50(%rip) # 0x2e760
leaq 0xfc4c(%rip), %rdi # 0x21763
callq *%rbx
movq %rax, 0x1cda0(%rip) # 0x2e8c0
leaq 0xfc4a(%rip), %rdi # 0x21771
callq *%rbx
movq %rax, 0x1cc38(%rip) # 0x2e768
leaq 0xfc47(%rip), %rdi # 0x2177e
callq *%rbx
movq %rax, 0x1bf28(%rip) # 0x2da68
leaq 0xfc45(%rip), %rdi # 0x2178c
callq *%rbx
movq %rax, 0x1cc00(%rip) # 0x2e750
leaq 0xfc42(%rip), %rdi # 0x21799
callq *%rbx
movq %rax, 0x1bcd8(%rip) # 0x2d838
leaq 0xfc40(%rip), %rdi # 0x217a7
callq *%rbx
movq %rax, 0x1cc38(%rip) # 0x2e7a8
leaq 0xfc3d(%rip), %rdi # 0x217b4
callq *%rbx
movq %rax, 0x1cd20(%rip) # 0x2e8a0
leaq 0xfc3b(%rip), %rdi # 0x217c2
callq *%rbx
movq %rax, 0x1c730(%rip) # 0x2e2c0
leaq 0xfc38(%rip), %rdi # 0x217cf
callq *%rbx
movq %rax, 0x1c4b0(%rip) # 0x2e050
leaq 0xfc36(%rip), %rdi # 0x217dd
callq *%rbx
movq %rax, 0x1c720(%rip) # 0x2e2d0
leaq 0xfc33(%rip), %rdi # 0x217ea
callq *%rbx
movq %rax, 0x1bb98(%rip) # 0x2d758
leaq 0xfc31(%rip), %rdi # 0x217f8
callq *%rbx
movq %rax, 0x1c720(%rip) # 0x2e2f0
leaq 0xfc2e(%rip), %rdi # 0x21805
callq *%rbx
movq %rax, 0x1cd70(%rip) # 0x2e950
leaq 0xfc2c(%rip), %rdi # 0x21813
callq *%rbx
movq %rax, 0x1c720(%rip) # 0x2e310
leaq 0xfc29(%rip), %rdi # 0x21820
callq *%rbx
movq %rax, 0x1be70(%rip) # 0x2da70
leaq 0xfc27(%rip), %rdi # 0x2182e
callq *%rbx
movq %rax, 0x1c1f8(%rip) # 0x2de08
leaq 0xfc24(%rip), %rdi # 0x2183b
callq *%rbx
movq %rax, 0x1c9d8(%rip) # 0x2e5f8
leaq 0xfc22(%rip), %rdi # 0x21849
callq *%rbx
movq %rax, 0x1c1c8(%rip) # 0x2ddf8
leaq 0xfc1f(%rip), %rdi # 0x21856
callq *%rbx
movq %rax, 0x1be50(%rip) # 0x2da90
leaq 0xfc1d(%rip), %rdi # 0x21864
callq *%rbx
movq %rax, 0x1c170(%rip) # 0x2ddc0
leaq 0xfc1a(%rip), %rdi # 0x21871
callq *%rbx
movq %rax, 0x1c328(%rip) # 0x2df88
leaq 0xfc18(%rip), %rdi # 0x2187f
callq *%rbx
movq %rax, 0x1c1c0(%rip) # 0x2de30
leaq 0xfc15(%rip), %rdi # 0x2188c
callq *%rbx
movq %rax, 0x1bcd0(%rip) # 0x2d950
leaq 0xfc13(%rip), %rdi # 0x2189a
callq *%rbx
movq %rax, 0x1bd68(%rip) # 0x2d9f8
leaq 0xfc10(%rip), %rdi # 0x218a7
callq *%rbx
movq %rax, 0x1c688(%rip) # 0x2e328
leaq 0xfc0e(%rip), %rdi # 0x218b5
callq *%rbx
movq %rax, 0x1bd40(%rip) # 0x2d9f0
leaq 0xfc0b(%rip), %rdi # 0x218c2
callq *%rbx
movq %rax, 0x1bab0(%rip) # 0x2d770
leaq 0xfc09(%rip), %rdi # 0x218d0
callq *%rbx
movq %rax, 0x1bd30(%rip) # 0x2da00
leaq 0xfc06(%rip), %rdi # 0x218dd
callq *%rbx
movq %rax, 0x1bf00(%rip) # 0x2dbe0
leaq 0xfc04(%rip), %rdi # 0x218eb
callq *%rbx
movq %rax, 0x1bd20(%rip) # 0x2da10
leaq 0xfc01(%rip), %rdi # 0x218f8
callq *%rbx
movq %rax, 0x1c208(%rip) # 0x2df08
leaq 0xfbff(%rip), %rdi # 0x21906
callq *%rbx
movq %rax, 0x1bf00(%rip) # 0x2dc10
leaq 0xfbfa(%rip), %rdi # 0x21911
callq *%rbx
movq %rax, 0x1c1e0(%rip) # 0x2df00
leaq 0xfbf6(%rip), %rdi # 0x2191d
callq *%rbx
movq %rax, 0x1bed8(%rip) # 0x2dc08
leaq 0xfbf1(%rip), %rdi # 0x21928
callq *%rbx
movq %rax, 0x1b8d8(%rip) # 0x2d618
leaq 0xfbed(%rip), %rdi # 0x21934
callq *%rbx
movq %rax, 0x1bee8(%rip) # 0x2dc38
leaq 0xfbe8(%rip), %rdi # 0x2193f
callq *%rbx
movq %rax, 0x1baf0(%rip) # 0x2d850
leaq 0xfbe4(%rip), %rdi # 0x2194b
callq *%rbx
movq %rax, 0x1bee0(%rip) # 0x2dc50
leaq 0xfbdf(%rip), %rdi # 0x21956
callq *%rbx
movq %rax, 0x1c000(%rip) # 0x2dd80
leaq 0xfbdb(%rip), %rdi # 0x21962
callq *%rbx
movq %rax, 0x1ba58(%rip) # 0x2d7e8
leaq 0xfbd6(%rip), %rdi # 0x2196d
callq *%rbx
movq %rax, 0x1bc98(%rip) # 0x2da38
leaq 0xfbd2(%rip), %rdi # 0x21979
callq *%rbx
movq %rax, 0x1ba40(%rip) # 0x2d7f0
leaq 0xfbcd(%rip), %rdi # 0x21984
callq *%rbx
movq %rax, 0x1c560(%rip) # 0x2e320
leaq 0xfbc9(%rip), %rdi # 0x21990
callq *%rbx
movq %rax, 0x1ba28(%rip) # 0x2d7f8
leaq 0xfbc4(%rip), %rdi # 0x2199b
callq *%rbx
movq %rax, 0x1bbe0(%rip) # 0x2d9c0
leaq 0xfbc0(%rip), %rdi # 0x219a7
callq *%rbx
movq %rax, 0x1ba30(%rip) # 0x2d820
leaq 0xfbbb(%rip), %rdi # 0x219b2
callq *%rbx
movq %rax, 0x1be78(%rip) # 0x2dc78
leaq 0xfbb7(%rip), %rdi # 0x219be
callq *%rbx
movq %rax, 0x1ca80(%rip) # 0x2e890
leaq 0xfbb2(%rip), %rdi # 0x219c9
callq *%rbx
movq %rax, 0x1c498(%rip) # 0x2e2b8
leaq 0xfbae(%rip), %rdi # 0x219d5
callq *%rbx
movq %rax, 0x1cba0(%rip) # 0x2e9d0
leaq 0xfba9(%rip), %rdi # 0x219e0
callq *%rbx
movq %rax, 0x1b900(%rip) # 0x2d740
leaq 0xfba5(%rip), %rdi # 0x219ec
callq *%rbx
movq %rax, 0x1c538(%rip) # 0x2e388
leaq 0xfba0(%rip), %rdi # 0x219f7
callq *%rbx
movq %rax, 0x1b888(%rip) # 0x2d6e8
leaq 0xfb9c(%rip), %rdi # 0x21a03
callq *%rbx
movq %rax, 0x1c4d8(%rip) # 0x2e348
leaq 0xfb97(%rip), %rdi # 0x21a0e
callq *%rbx
movq %rax, 0x1b9f8(%rip) # 0x2d878
leaq 0xfb93(%rip), %rdi # 0x21a1a
callq *%rbx
movq %rax, 0x1c6b0(%rip) # 0x2e540
leaq 0xfb8f(%rip), %rdi # 0x21a26
callq *%rbx
movq %rax, 0x1c268(%rip) # 0x2e108
leaq 0xfb8f(%rip), %rdi # 0x21a36
callq *%rbx
movq %rax, 0x1c878(%rip) # 0x2e728
leaq 0xfb86(%rip), %rdi # 0x21a3d
callq *%rbx
movq %rax, 0x1b818(%rip) # 0x2d6d8
leaq 0xfb7e(%rip), %rdi # 0x21a45
callq *%rbx
movq %rax, 0x1b9b8(%rip) # 0x2d888
leaq 0xfb75(%rip), %rdi # 0x21a4c
callq *%rbx
movq %rax, 0x1b7c8(%rip) # 0x2d6a8
leaq 0xfb6d(%rip), %rdi # 0x21a54
callq *%rbx
movq %rax, 0x1bca8(%rip) # 0x2db98
leaq 0xfb66(%rip), %rdi # 0x21a5d
callq *%rbx
movq %rax, 0x1b9e0(%rip) # 0x2d8e0
leaq 0xfb60(%rip), %rdi # 0x21a67
callq *%rbx
movq %rax, 0x1bc80(%rip) # 0x2db90
leaq 0xfb59(%rip), %rdi # 0x21a70
callq *%rbx
movq %rax, 0x1c5f0(%rip) # 0x2e510
leaq 0xfb53(%rip), %rdi # 0x21a7a
callq *%rbx
movq %rax, 0x1be40(%rip) # 0x2dd70
leaq 0xfb51(%rip), %rdi # 0x21a88
callq *%rbx
movq %rax, 0x1c360(%rip) # 0x2e2a0
leaq 0xfb50(%rip), %rdi # 0x21a97
callq *%rbx
movq %rax, 0x1be38(%rip) # 0x2dd88
leaq 0xfb4e(%rip), %rdi # 0x21aa5
callq *%rbx
movq %rax, 0x1b760(%rip) # 0x2d6c0
leaq 0xfb4d(%rip), %rdi # 0x21ab4
callq *%rbx
movq %rax, 0x1bf20(%rip) # 0x2de90
leaq 0xfb4b(%rip), %rdi # 0x21ac2
callq *%rbx
movq %rax, 0x1ba88(%rip) # 0x2da08
leaq 0xfb47(%rip), %rdi # 0x21ace
callq *%rbx
movq %rax, 0x1bfc8(%rip) # 0x2df58
leaq 0xfb44(%rip), %rdi # 0x21adb
callq *%rbx
movq %rax, 0x1ba30(%rip) # 0x2d9d0
leaq 0xfb40(%rip), %rdi # 0x21ae7
callq *%rbx
movq %rax, 0x1c380(%rip) # 0x2e330
leaq 0xfb3d(%rip), %rdi # 0x21af4
callq *%rbx
movq %rax, 0x1ca28(%rip) # 0x2e9e8
leaq 0xfb3e(%rip), %rdi # 0x21b05
callq *%rbx
movq %rax, 0x1c3f0(%rip) # 0x2e3c0
leaq 0xfb3b(%rip), %rdi # 0x21b12
callq *%rbx
movq %rax, 0x1bcb0(%rip) # 0x2dc90
leaq 0xfb35(%rip), %rdi # 0x21b1c
callq *%rbx
movq %rax, 0x1c280(%rip) # 0x2e270
leaq 0xfb30(%rip), %rdi # 0x21b27
callq *%rbx
movq %rax, 0x1bcc0(%rip) # 0x2dcc0
leaq 0xfb2a(%rip), %rdi # 0x21b31
callq *%rbx
movq %rax, 0x1c4a0(%rip) # 0x2e4b0
leaq 0xfb25(%rip), %rdi # 0x21b3c
callq *%rbx
movq %rax, 0x1c1b0(%rip) # 0x2e1d0
leaq 0xfb1f(%rip), %rdi # 0x21b46
callq *%rbx
movq %rax, 0x1c520(%rip) # 0x2e550
leaq 0xfb1a(%rip), %rdi # 0x21b51
callq *%rbx
movq %rax, 0x1ba60(%rip) # 0x2daa0
leaq 0xfb14(%rip), %rdi # 0x21b5b
callq *%rbx
movq %rax, 0x1c4d0(%rip) # 0x2e520
leaq 0xfb0f(%rip), %rdi # 0x21b66
callq *%rbx
movq %rax, 0x1c178(%rip) # 0x2e1d8
leaq 0xfb09(%rip), %rdi # 0x21b70
callq *%rbx
movq %rax, 0x1c1d0(%rip) # 0x2e240
leaq 0xfb04(%rip), %rdi # 0x21b7b
callq *%rbx
movq %rax, 0x1bc88(%rip) # 0x2dd08
leaq 0xfb05(%rip), %rdi # 0x21b8c
callq *%rbx
movq %rax, 0x1c440(%rip) # 0x2e4d0
leaq 0xfb04(%rip), %rdi # 0x21b9b
callq *%rbx
movq %rax, 0x1c088(%rip) # 0x2e128
leaq 0xfb01(%rip), %rdi # 0x21ba8
callq *%rbx
movq %rax, 0x1c020(%rip) # 0x2e0d0
leaq 0xfafd(%rip), %rdi # 0x21bb4
callq *%rbx
movq %rax, 0x1c2e0(%rip) # 0x2e3a0
leaq 0xfaf8(%rip), %rdi # 0x21bbf
callq *%rbx
movq %rax, 0x1b7b0(%rip) # 0x2d880
leaq 0xfaf6(%rip), %rdi # 0x21bcd
callq *%rbx
movq %rax, 0x1bee8(%rip) # 0x2dfc8
leaq 0xfaf0(%rip), %rdi # 0x21bd7
callq *%rbx
movq %rax, 0x1c458(%rip) # 0x2e548
leaq 0xfaeb(%rip), %rdi # 0x21be2
callq *%rbx
movq %rax, 0x1c750(%rip) # 0x2e850
leaq 0xfae8(%rip), %rdi # 0x21bef
callq *%rbx
movq %rax, 0x1ba08(%rip) # 0x2db18
leaq 0xfae5(%rip), %rdi # 0x21bfc
callq *%rbx
movq %rax, 0x1c708(%rip) # 0x2e828
leaq 0xfae1(%rip), %rdi # 0x21c08
callq *%rbx
movq %rax, 0x1c800(%rip) # 0x2e930
leaq 0xfad9(%rip), %rdi # 0x21c10
callq *%rbx
movq %rax, 0x1bf60(%rip) # 0x2e0a0
leaq 0xfad5(%rip), %rdi # 0x21c1c
callq *%rbx
movq %rax, 0x1c390(%rip) # 0x2e4e0
leaq 0xfad2(%rip), %rdi # 0x21c29
callq *%rbx
movq %rax, 0x1b9c0(%rip) # 0x2db20
leaq 0xfaca(%rip), %rdi # 0x21c31
callq *%rbx
movq %rax, 0x1b9b8(%rip) # 0x2db28
leaq 0xfac2(%rip), %rdi # 0x21c39
callq *%rbx
movq %rax, 0x1c700(%rip) # 0x2e880
leaq 0xfaba(%rip), %rdi # 0x21c41
callq *%rbx
movq %rax, 0x1c6f8(%rip) # 0x2e888
leaq 0xfab2(%rip), %rdi # 0x21c49
callq *%rbx
movq %rax, 0x1c228(%rip) # 0x2e3c8
leaq 0xfaae(%rip), %rdi # 0x21c55
callq *%rbx
movq %rax, 0x1c228(%rip) # 0x2e3d8
leaq 0xfaaa(%rip), %rdi # 0x21c61
callq *%rbx
movq %rax, 0x1ba68(%rip) # 0x2dc28
leaq 0xfaa6(%rip), %rdi # 0x21c6d
callq *%rbx
movq %rax, 0x1ba60(%rip) # 0x2dc30
leaq 0xfaa2(%rip), %rdi # 0x21c79
callq *%rbx
movq %rax, 0x1c720(%rip) # 0x2e900
leaq 0xfaa0(%rip), %rdi # 0x21c87
callq *%rbx
movq %rax, 0x1be00(%rip) # 0x2dff0
leaq 0xfa9f(%rip), %rdi # 0x21c96
callq *%rbx
movq %rax, 0x1c710(%rip) # 0x2e910
leaq 0xfa9d(%rip), %rdi # 0x21ca4
callq *%rbx
movq %rax, 0x1b4e0(%rip) # 0x2d6f0
leaq 0xfa9c(%rip), %rdi # 0x21cb3
callq *%rbx
movq %rax, 0x1b420(%rip) # 0x2d640
leaq 0xfa9a(%rip), %rdi # 0x21cc1
callq *%rbx
movq %rax, 0x1b668(%rip) # 0x2d898
leaq 0xfa99(%rip), %rdi # 0x21cd0
callq *%rbx
movq %rax, 0x1b408(%rip) # 0x2d648
leaq 0xfa97(%rip), %rdi # 0x21cde
callq *%rbx
movq %rax, 0x1c228(%rip) # 0x2e478
leaq 0xfa96(%rip), %rdi # 0x21ced
callq *%rbx
movq %rax, 0x1c1f8(%rip) # 0x2e458
leaq 0xfa92(%rip), %rdi # 0x21cf9
callq *%rbx
movq %rax, 0x1c640(%rip) # 0x2e8b0
leaq 0xfa8f(%rip), %rdi # 0x21d06
callq *%rbx
movq %rax, 0x1c1d0(%rip) # 0x2e450
leaq 0xfa8b(%rip), %rdi # 0x21d12
callq *%rbx
movq %rax, 0x1bee8(%rip) # 0x2e178
leaq 0xfa88(%rip), %rdi # 0x21d1f
callq *%rbx
movq %rax, 0x1c160(%rip) # 0x2e400
leaq 0xfa84(%rip), %rdi # 0x21d2b
callq *%rbx
movq %rax, 0x1b8a8(%rip) # 0x2db58
leaq 0xfa80(%rip), %rdi # 0x21d37
callq *%rbx
movq %rax, 0x1bec0(%rip) # 0x2e180
leaq 0xfa81(%rip), %rdi # 0x21d48
callq *%rbx
movq %rax, 0x1be88(%rip) # 0x2e158
leaq 0xfa82(%rip), %rdi # 0x21d59
callq *%rbx
movq %rax, 0x1c638(%rip) # 0x2e918
leaq 0xfa7f(%rip), %rdi # 0x21d66
callq *%rbx
movq %rax, 0x1b6a0(%rip) # 0x2d990
leaq 0xfa7d(%rip), %rdi # 0x21d74
callq *%rbx
movq %rax, 0x1c718(%rip) # 0x2ea18
leaq 0xfa7b(%rip), %rdi # 0x21d82
callq *%rbx
movq %rax, 0x1bd80(%rip) # 0x2e090
leaq 0xfa78(%rip), %rdi # 0x21d8f
callq *%rbx
movq %rax, 0x1c660(%rip) # 0x2e980
leaq 0xfa75(%rip), %rdi # 0x21d9c
callq *%rbx
movq %rax, 0x1bf80(%rip) # 0x2e2b0
leaq 0xfa74(%rip), %rdi # 0x21dab
callq *%rbx
movq %rax, 0x1be80(%rip) # 0x2e1c0
leaq 0xfa71(%rip), %rdi # 0x21db8
callq *%rbx
movq %rax, 0x1c308(%rip) # 0x2e658
leaq 0xfa6e(%rip), %rdi # 0x21dc5
callq *%rbx
movq %rax, 0x1bbe8(%rip) # 0x2df48
leaq 0xfa69(%rip), %rdi # 0x21dd0
callq *%rbx
movq %rax, 0x1b308(%rip) # 0x2d678
leaq 0xfa64(%rip), %rdi # 0x21ddb
callq *%rbx
movq %rax, 0x1b990(%rip) # 0x2dd10
leaq 0xfa5f(%rip), %rdi # 0x21de6
callq *%rbx
movq %rax, 0x1b5e8(%rip) # 0x2d978
leaq 0xfa5f(%rip), %rdi # 0x21df6
callq *%rbx
movq %rax, 0x1c600(%rip) # 0x2e9a0
leaq 0xfa5f(%rip), %rdi # 0x21e06
callq *%rbx
movq %rax, 0x1b8d8(%rip) # 0x2dc88
leaq 0xfa5f(%rip), %rdi # 0x21e16
callq *%rbx
movq %rax, 0x1b810(%rip) # 0x2dbd0
leaq 0xfa60(%rip), %rdi # 0x21e27
callq *%rbx
movq %rax, 0x1c550(%rip) # 0x2e920
leaq 0xfa61(%rip), %rdi # 0x21e38
callq *%rbx
movq %rax, 0x1c2d0(%rip) # 0x2e6b0
leaq 0xfa65(%rip), %rdi # 0x21e4c
callq *%rbx
movq %rax, 0x1bdb8(%rip) # 0x2e1a8
leaq 0xfa63(%rip), %rdi # 0x21e5a
callq *%rbx
movq %rax, 0x1c4d0(%rip) # 0x2e8d0
leaq 0xfa61(%rip), %rdi # 0x21e68
callq *%rbx
movq %rax, 0x1c3d8(%rip) # 0x2e7e8
leaq 0xfa5f(%rip), %rdi # 0x21e76
callq *%rbx
movq %rax, 0x1be00(%rip) # 0x2e220
leaq 0xfa5d(%rip), %rdi # 0x21e84
callq *%rbx
movq %rax, 0x1c5f0(%rip) # 0x2ea20
leaq 0xfa5b(%rip), %rdi # 0x21e92
callq *%rbx
movq %rax, 0x1ba28(%rip) # 0x2de68
leaq 0xfa54(%rip), %rdi # 0x21e9b
callq *%rbx
movq %rax, 0x1b688(%rip) # 0x2dad8
leaq 0xfa4e(%rip), %rdi # 0x21ea5
callq *%rbx
movq %rax, 0x1b350(%rip) # 0x2d7b0
leaq 0xfa4d(%rip), %rdi # 0x21eb4
callq *%rbx
movq %rax, 0x1c540(%rip) # 0x2e9b0
leaq 0xfa4b(%rip), %rdi # 0x21ec2
callq *%rbx
movq %rax, 0x1c538(%rip) # 0x2e9b8
leaq 0xfa49(%rip), %rdi # 0x21ed0
callq *%rbx
movq %rax, 0x1b870(%rip) # 0x2dd00
leaq 0xfa46(%rip), %rdi # 0x21edd
callq *%rbx
movq %rax, 0x1c4f0(%rip) # 0x2e990
leaq 0xfa44(%rip), %rdi # 0x21eeb
callq *%rbx
movq %rax, 0x1c4d8(%rip) # 0x2e988
leaq 0xfa42(%rip), %rdi # 0x21ef9
callq *%rbx
movq %rax, 0x1b640(%rip) # 0x2db00
leaq 0xfa3a(%rip), %rdi # 0x21f01
callq *%rbx
movq %rax, 0x1bdf8(%rip) # 0x2e2c8
leaq 0xfa36(%rip), %rdi # 0x21f0d
callq *%rbx
movq %rax, 0x1b610(%rip) # 0x2daf0
leaq 0xfa33(%rip), %rdi # 0x21f1a
callq *%rbx
movq %rax, 0x1be88(%rip) # 0x2e378
leaq 0xfa2d(%rip), %rdi # 0x21f24
callq *%rbx
movq %rax, 0x1be80(%rip) # 0x2e380
leaq 0xfa27(%rip), %rdi # 0x21f2e
callq *%rbx
movq %rax, 0x1bb70(%rip) # 0x2e080
leaq 0xfa20(%rip), %rdi # 0x21f37
callq *%rbx
movq %rax, 0x1bb50(%rip) # 0x2e070
leaq 0xfa19(%rip), %rdi # 0x21f40
callq *%rbx
movq %rax, 0x1b418(%rip) # 0x2d948
leaq 0xfa16(%rip), %rdi # 0x21f4d
callq *%rbx
movq %rax, 0x1b3f8(%rip) # 0x2d938
cmpl $0x0, 0x1b075(%rip) # 0x2d5bc
je 0x1272d
leaq 0xfa06(%rip), %rdi # 0x21f5a
callq *%rbx
movq %rax, 0x1b363(%rip) # 0x2d8c0
leaq 0xfa03(%rip), %rdi # 0x21f67
callq *%rbx
movq %rax, 0x1b9cb(%rip) # 0x2df38
leaq 0xfa02(%rip), %rdi # 0x21f76
callq *%rbx
movq %rax, 0x1b52b(%rip) # 0x2daa8
leaq 0xfa00(%rip), %rdi # 0x21f84
callq *%rbx
movq %rax, 0x1b523(%rip) # 0x2dab0
leaq 0xfa00(%rip), %rdi # 0x21f94
callq *%rbx
movq %rax, 0x1b04b(%rip) # 0x2d5e8
leaq 0xfa01(%rip), %rdi # 0x21fa5
callq *%rbx
movq %rax, 0x1b70b(%rip) # 0x2dcb8
leaq 0xfa02(%rip), %rdi # 0x21fb6
callq *%rbx
movq %rax, 0x1c18b(%rip) # 0x2e748
leaq 0xfa06(%rip), %rdi # 0x21fca
callq *%rbx
movq %rax, 0x1b153(%rip) # 0x2d720
leaq 0xfa0a(%rip), %rdi # 0x21fde
callq *%rbx
movq %rax, 0x1c30b(%rip) # 0x2e8e8
leaq 0xfa0a(%rip), %rdi # 0x21fee
callq *%rbx
movq %rax, 0x1bb73(%rip) # 0x2e160
leaq 0xfa0a(%rip), %rdi # 0x21ffe
callq *%rbx
movq %rax, 0x1b14b(%rip) # 0x2d748
leaq 0xfa08(%rip), %rdi # 0x2200c
callq *%rbx
movq %rax, 0x1ba9b(%rip) # 0x2e0a8
leaq 0xfa09(%rip), %rdi # 0x2201d
callq *%rbx
movq %rax, 0x1b5bb(%rip) # 0x2dbd8
leaq 0xfa07(%rip), %rdi # 0x2202b
callq *%rbx
movq %rax, 0x1c36b(%rip) # 0x2e998
leaq 0xfa03(%rip), %rdi # 0x22037
callq *%rbx
movq %rax, 0x1c3eb(%rip) # 0x2ea28
leaq 0xfa02(%rip), %rdi # 0x22046
callq *%rbx
movq %rax, 0x1c443(%rip) # 0x2ea90
leaq 0xfa01(%rip), %rdi # 0x22055
callq *%rbx
movq %rax, 0x1bd83(%rip) # 0x2e3e0
leaq 0xfa06(%rip), %rdi # 0x2206a
callq *%rbx
movq %rax, 0x1ba1b(%rip) # 0x2e088
leaq 0xfa08(%rip), %rdi # 0x2207c
callq *%rbx
movq %rax, 0x1c0fb(%rip) # 0x2e778
leaq 0xfa0c(%rip), %rdi # 0x22090
callq *%rbx
movq %rax, 0x1b563(%rip) # 0x2dbf0
leaq 0xfa0b(%rip), %rdi # 0x2209f
callq *%rbx
movq %rax, 0x1c353(%rip) # 0x2e9f0
leaq 0xfa0f(%rip), %rdi # 0x220b3
callq *%rbx
movq %rax, 0x1b1c3(%rip) # 0x2d870
leaq 0xfa0f(%rip), %rdi # 0x220c3
callq *%rbx
movq %rax, 0x1bda3(%rip) # 0x2e460
leaq 0xfa11(%rip), %rdi # 0x220d5
callq *%rbx
movq %rax, 0x1b1db(%rip) # 0x2d8a8
leaq 0xfa11(%rip), %rdi # 0x220e5
callq *%rbx
movq %rax, 0x1b783(%rip) # 0x2de60
leaq 0xfa17(%rip), %rdi # 0x220fb
callq *%rbx
movq %rax, 0x1b653(%rip) # 0x2dd40
leaq 0xfa1c(%rip), %rdi # 0x22110
callq *%rbx
movq %rax, 0x1be5b(%rip) # 0x2e558
leaq 0xfa16(%rip), %rdi # 0x2211a
callq *%rbx
movq %rax, 0x1bbd3(%rip) # 0x2e2e0
leaq 0xfa11(%rip), %rdi # 0x22125
callq *%rbx
movq %rax, 0x1bffb(%rip) # 0x2e718
leaq 0xfa13(%rip), %rdi # 0x22137
callq *%rbx
movq %rax, 0x1c103(%rip) # 0x2e830
cmpl $0x0, 0x1ae8c(%rip) # 0x2d5c0
je 0x12776
leaq 0xfa0d(%rip), %rdi # 0x2214a
callq *%rbx
movq %rax, 0x1c05a(%rip) # 0x2e7a0
leaq 0xfa11(%rip), %rdi # 0x2215e
callq *%rbx
movq %rax, 0x1bdaa(%rip) # 0x2e500
leaq 0xfa0e(%rip), %rdi # 0x2216b
callq *%rbx
movq %rax, 0x1b532(%rip) # 0x2dc98
leaq 0xfa0e(%rip), %rdi # 0x2217b
callq *%rbx
movq %rax, 0x1b80a(%rip) # 0x2df80
cmpl $0x0, 0x1ae47(%rip) # 0x2d5c4
je 0x12a63
leaq 0xfa05(%rip), %rdi # 0x2218f
callq *%rbx
movq %rax, 0x1bbd5(%rip) # 0x2e368
leaq 0xfa05(%rip), %rdi # 0x2219f
callq *%rbx
movq %rax, 0x1b96d(%rip) # 0x2e110
leaq 0xfa06(%rip), %rdi # 0x221b0
callq *%rbx
movq %rax, 0x1b63d(%rip) # 0x2ddf0
leaq 0xfa0d(%rip), %rdi # 0x221c7
callq *%rbx
movq %rax, 0x1af65(%rip) # 0x2d728
leaq 0xfa14(%rip), %rdi # 0x221de
callq *%rbx
movq %rax, 0x1bf6d(%rip) # 0x2e740
leaq 0xfa1b(%rip), %rdi # 0x221f5
callq *%rbx
movq %rax, 0x1ae55(%rip) # 0x2d638
leaq 0xfa25(%rip), %rdi # 0x2220f
callq *%rbx
movq %rax, 0x1be75(%rip) # 0x2e668
leaq 0xfa2f(%rip), %rdi # 0x22229
callq *%rbx
movq %rax, 0x1b715(%rip) # 0x2df18
leaq 0xfa39(%rip), %rdi # 0x22243
callq *%rbx
movq %rax, 0x1b91d(%rip) # 0x2e130
leaq 0xfa41(%rip), %rdi # 0x2225b
callq *%rbx
movq %rax, 0x1ba35(%rip) # 0x2e258
leaq 0xfa47(%rip), %rdi # 0x22271
callq *%rbx
movq %rax, 0x1b09d(%rip) # 0x2d8d0
leaq 0xfa49(%rip), %rdi # 0x22283
callq *%rbx
movq %rax, 0x1b23d(%rip) # 0x2da80
leaq 0xfa4c(%rip), %rdi # 0x22296
callq *%rbx
movq %rax, 0x1b085(%rip) # 0x2d8d8
leaq 0xfa4e(%rip), %rdi # 0x222a8
callq *%rbx
movq %rax, 0x1bbc5(%rip) # 0x2e428
leaq 0xfa51(%rip), %rdi # 0x222bb
callq *%rbx
movq %rax, 0x1b085(%rip) # 0x2d8f8
leaq 0xfa53(%rip), %rdi # 0x222cd
callq *%rbx
movq %rax, 0x1b445(%rip) # 0x2dcc8
leaq 0xfa56(%rip), %rdi # 0x222e0
callq *%rbx
movq %rax, 0x1b075(%rip) # 0x2d908
leaq 0xfa58(%rip), %rdi # 0x222f2
callq *%rbx
movq %rax, 0x1b5f5(%rip) # 0x2de98
leaq 0xfa5b(%rip), %rdi # 0x22305
callq *%rbx
movq %rax, 0x1b475(%rip) # 0x2dd28
leaq 0xfa5d(%rip), %rdi # 0x22317
callq *%rbx
movq %rax, 0x1b41d(%rip) # 0x2dce0
leaq 0xfa60(%rip), %rdi # 0x2232a
callq *%rbx
movq %rax, 0x1b45d(%rip) # 0x2dd30
leaq 0xfa62(%rip), %rdi # 0x2233c
callq *%rbx
movq %rax, 0x1c00d(%rip) # 0x2e8f0
leaq 0xfa65(%rip), %rdi # 0x2234f
callq *%rbx
movq %rax, 0x1b195(%rip) # 0x2da88
leaq 0xfa67(%rip), %rdi # 0x22361
callq *%rbx
movq %rax, 0x1b5ad(%rip) # 0x2deb0
leaq 0xfa6a(%rip), %rdi # 0x22374
callq *%rbx
movq %rax, 0x1b115(%rip) # 0x2da28
leaq 0xfa6c(%rip), %rdi # 0x22386
callq *%rbx
movq %rax, 0x1be6d(%rip) # 0x2e790
leaq 0xfa6f(%rip), %rdi # 0x22399
callq *%rbx
movq %rax, 0x1b8cd(%rip) # 0x2e200
leaq 0xfa71(%rip), %rdi # 0x223ab
callq *%rbx
movq %rax, 0x1bdc5(%rip) # 0x2e708
leaq 0xfa74(%rip), %rdi # 0x223be
callq *%rbx
movq %rax, 0x1b8a5(%rip) # 0x2e1f8
leaq 0xfa76(%rip), %rdi # 0x223d0
callq *%rbx
movq %rax, 0x1b265(%rip) # 0x2dbc8
leaq 0xfa79(%rip), %rdi # 0x223e3
callq *%rbx
movq %rax, 0x1b87d(%rip) # 0x2e1f0
leaq 0xfa7b(%rip), %rdi # 0x223f5
callq *%rbx
movq %rax, 0x1b3dd(%rip) # 0x2dd60
leaq 0xfa7e(%rip), %rdi # 0x22408
callq *%rbx
movq %rax, 0x1b84d(%rip) # 0x2e1e0
leaq 0xfa80(%rip), %rdi # 0x2241a
callq *%rbx
movq %rax, 0x1ba45(%rip) # 0x2e3e8
leaq 0xfa83(%rip), %rdi # 0x2242d
callq *%rbx
movq %rax, 0x1bcd5(%rip) # 0x2e688
leaq 0xfa85(%rip), %rdi # 0x2243f
callq *%rbx
movq %rax, 0x1bd05(%rip) # 0x2e6c8
leaq 0xfa88(%rip), %rdi # 0x22452
callq *%rbx
movq %rax, 0x1bca5(%rip) # 0x2e678
leaq 0xfa8a(%rip), %rdi # 0x22464
callq *%rbx
movq %rax, 0x1b3e5(%rip) # 0x2ddc8
leaq 0xfa8d(%rip), %rdi # 0x22477
callq *%rbx
movq %rax, 0x1bcb5(%rip) # 0x2e6a8
leaq 0xfa8f(%rip), %rdi # 0x22489
callq *%rbx
movq %rax, 0x1ba0d(%rip) # 0x2e410
leaq 0xfa92(%rip), %rdi # 0x2249c
callq *%rbx
movq %rax, 0x1bc1d(%rip) # 0x2e630
leaq 0xfa94(%rip), %rdi # 0x224ae
callq *%rbx
movq %rax, 0x1b0bd(%rip) # 0x2dae0
leaq 0xfa97(%rip), %rdi # 0x224c1
callq *%rbx
movq %rax, 0x1ba5d(%rip) # 0x2e490
leaq 0xfa9e(%rip), %rdi # 0x224d8
callq *%rbx
movq %rax, 0x1ba45(%rip) # 0x2e488
leaq 0xfaa5(%rip), %rdi # 0x224ef
callq *%rbx
movq %rax, 0x1b5b5(%rip) # 0x2e008
leaq 0xfaac(%rip), %rdi # 0x22506
callq *%rbx
movq %rax, 0x1bb0d(%rip) # 0x2e570
cmpl $0x0, 0x1ab5e(%rip) # 0x2d5c8
je 0x12d60
leaq 0xfaa6(%rip), %rdi # 0x2251d
callq *%rbx
movq %rax, 0x1acb8(%rip) # 0x2d738
leaq 0xfaaa(%rip), %rdi # 0x22531
callq *%rbx
movq %rax, 0x1bd60(%rip) # 0x2e7f0
leaq 0xfaac(%rip), %rdi # 0x22543
callq *%rbx
movq %rax, 0x1b380(%rip) # 0x2de20
leaq 0xfab0(%rip), %rdi # 0x22557
callq *%rbx
movq %rax, 0x1bb68(%rip) # 0x2e618
leaq 0xfab2(%rip), %rdi # 0x22569
callq *%rbx
movq %rax, 0x1bb18(%rip) # 0x2e5d8
leaq 0xfab5(%rip), %rdi # 0x2257c
callq *%rbx
movq %rax, 0x1bad0(%rip) # 0x2e5a0
leaq 0xfab7(%rip), %rdi # 0x2258e
callq *%rbx
movq %rax, 0x1af68(%rip) # 0x2da48
leaq 0xfaba(%rip), %rdi # 0x225a1
callq *%rbx
movq %rax, 0x1b1c0(%rip) # 0x2dcb0
leaq 0xfab6(%rip), %rdi # 0x225ad
callq *%rbx
movq %rax, 0x1ae88(%rip) # 0x2d988
leaq 0xfab3(%rip), %rdi # 0x225ba
callq *%rbx
movq %rax, 0x1b198(%rip) # 0x2dca8
leaq 0xfaaf(%rip), %rdi # 0x225c6
callq *%rbx
movq %rax, 0x1b6f0(%rip) # 0x2e210
leaq 0xfaac(%rip), %rdi # 0x225d3
callq *%rbx
movq %rax, 0x1b6f8(%rip) # 0x2e228
leaq 0xfaae(%rip), %rdi # 0x225e5
callq *%rbx
movq %rax, 0x1b298(%rip) # 0x2ddd8
leaq 0xfab1(%rip), %rdi # 0x225f8
callq *%rbx
movq %rax, 0x1ae20(%rip) # 0x2d970
leaq 0xfab5(%rip), %rdi # 0x2260c
callq *%rbx
movq %rax, 0x1b258(%rip) # 0x2ddb8
leaq 0xfab8(%rip), %rdi # 0x2261f
callq *%rbx
movq %rax, 0x1b6e0(%rip) # 0x2e250
leaq 0xfabc(%rip), %rdi # 0x22633
callq *%rbx
movq %rax, 0x1b350(%rip) # 0x2ded0
leaq 0xfabf(%rip), %rdi # 0x22646
callq *%rbx
movq %rax, 0x1ab40(%rip) # 0x2d6d0
leaq 0xfac3(%rip), %rdi # 0x2265a
callq *%rbx
movq %rax, 0x1b5e8(%rip) # 0x2e188
leaq 0xfac6(%rip), %rdi # 0x2266d
callq *%rbx
movq %rax, 0x1b9b0(%rip) # 0x2e560
leaq 0xfaca(%rip), %rdi # 0x22681
callq *%rbx
movq %rax, 0x1af08(%rip) # 0x2dac8
leaq 0xfacd(%rip), %rdi # 0x22694
callq *%rbx
movq %rax, 0x1b0a0(%rip) # 0x2dc70
leaq 0xfad1(%rip), %rdi # 0x226a8
callq *%rbx
movq %rax, 0x1ba08(%rip) # 0x2e5e8
leaq 0xfad5(%rip), %rdi # 0x226bc
callq *%rbx
movq %rax, 0x1b160(%rip) # 0x2dd50
leaq 0xfada(%rip), %rdi # 0x226d1
callq *%rbx
movq %rax, 0x1b9f0(%rip) # 0x2e5f0
leaq 0xfade(%rip), %rdi # 0x226e5
callq *%rbx
movq %rax, 0x1aca0(%rip) # 0x2d8b0
leaq 0xfae3(%rip), %rdi # 0x226fa
callq *%rbx
movq %rax, 0x1b648(%rip) # 0x2e268
leaq 0xfae7(%rip), %rdi # 0x2270e
callq *%rbx
movq %rax, 0x1ae68(%rip) # 0x2da98
leaq 0xfaec(%rip), %rdi # 0x22723
callq *%rbx
movq %rax, 0x1b7b8(%rip) # 0x2e3f8
leaq 0xfaf4(%rip), %rdi # 0x2273b
callq *%rbx
movq %rax, 0x1a9c0(%rip) # 0x2d610
leaq 0xfaf2(%rip), %rdi # 0x22749
callq *%rbx
movq %rax, 0x1b4d8(%rip) # 0x2e138
leaq 0xfaf1(%rip), %rdi # 0x22758
callq *%rbx
movq %rax, 0x1a998(%rip) # 0x2d608
leaq 0xfaef(%rip), %rdi # 0x22766
callq *%rbx
movq %rax, 0x1bb98(%rip) # 0x2e818
leaq 0xfaee(%rip), %rdi # 0x22775
callq *%rbx
movq %rax, 0x1a970(%rip) # 0x2d600
leaq 0xfaec(%rip), %rdi # 0x22783
callq *%rbx
movq %rax, 0x1a9f8(%rip) # 0x2d698
leaq 0xfaeb(%rip), %rdi # 0x22792
callq *%rbx
movq %rax, 0x1a948(%rip) # 0x2d5f8
leaq 0xfae9(%rip), %rdi # 0x227a0
callq *%rbx
movq %rax, 0x1aa38(%rip) # 0x2d6f8
leaq 0xfae8(%rip), %rdi # 0x227af
callq *%rbx
movq %rax, 0x1b8e0(%rip) # 0x2e5b0
leaq 0xfae6(%rip), %rdi # 0x227bd
callq *%rbx
movq %rax, 0x1bc88(%rip) # 0x2e968
leaq 0xfae5(%rip), %rdi # 0x227cc
callq *%rbx
movq %rax, 0x1b948(%rip) # 0x2e638
leaq 0xfae3(%rip), %rdi # 0x227da
callq *%rbx
movq %rax, 0x1b598(%rip) # 0x2e298
leaq 0xfae2(%rip), %rdi # 0x227e9
callq *%rbx
movq %rax, 0x1b918(%rip) # 0x2e628
leaq 0xfae0(%rip), %rdi # 0x227f7
callq *%rbx
movq %rax, 0x1b070(%rip) # 0x2dd90
leaq 0xfadf(%rip), %rdi # 0x22806
callq *%rbx
movq %rax, 0x1b8e0(%rip) # 0x2e610
leaq 0xfadd(%rip), %rdi # 0x22814
callq *%rbx
movq %rax, 0x1add0(%rip) # 0x2db10
leaq 0xfadc(%rip), %rdi # 0x22823
callq *%rbx
movq %rax, 0x1b858(%rip) # 0x2e5a8
leaq 0xfad9(%rip), %rdi # 0x22830
callq *%rbx
movq %rax, 0x1b980(%rip) # 0x2e6e0
cmpl $0x0, 0x1a865(%rip) # 0x2d5cc
je 0x12e9d
leaq 0xfacc(%rip), %rdi # 0x22840
callq *%rbx
movq %rax, 0x1af03(%rip) # 0x2dc80
leaq 0xfac9(%rip), %rdi # 0x2284d
callq *%rbx
movq %rax, 0x1b32b(%rip) # 0x2e0b8
leaq 0xfac9(%rip), %rdi # 0x2285d
callq *%rbx
movq %rax, 0x1bbbb(%rip) # 0x2e958
leaq 0xfac3(%rip), %rdi # 0x22867
callq *%rbx
movq %rax, 0x1babb(%rip) # 0x2e868
leaq 0xfac0(%rip), %rdi # 0x22874
callq *%rbx
movq %rax, 0x1b2bb(%rip) # 0x2e078
leaq 0xfabb(%rip), %rdi # 0x2287f
callq *%rbx
movq %rax, 0x1ac1b(%rip) # 0x2d9e8
leaq 0xfab8(%rip), %rdi # 0x2288c
callq *%rbx
movq %rax, 0x1b63b(%rip) # 0x2e418
leaq 0xfabb(%rip), %rdi # 0x2289f
callq *%rbx
movq %rax, 0x1ab33(%rip) # 0x2d920
leaq 0xfabf(%rip), %rdi # 0x228b3
callq *%rbx
movq %rax, 0x1ba7b(%rip) # 0x2e878
leaq 0xfabc(%rip), %rdi # 0x228c0
callq *%rbx
movq %rax, 0x1b723(%rip) # 0x2e530
leaq 0xfabc(%rip), %rdi # 0x228d0
callq *%rbx
movq %rax, 0x1b6ab(%rip) # 0x2e4c8
leaq 0xfab9(%rip), %rdi # 0x228dd
callq *%rbx
movq %rax, 0x1a8db(%rip) # 0x2d708
leaq 0xfab4(%rip), %rdi # 0x228e8
callq *%rbx
movq %rax, 0x1ba6b(%rip) # 0x2e8a8
leaq 0xfab1(%rip), %rdi # 0x228f5
callq *%rbx
movq %rax, 0x1b96b(%rip) # 0x2e7b8
leaq 0xfab1(%rip), %rdi # 0x22905
callq *%rbx
movq %rax, 0x1b64b(%rip) # 0x2e4a8
leaq 0xfab4(%rip), %rdi # 0x22918
callq *%rbx
movq %rax, 0x1af43(%rip) # 0x2ddb0
leaq 0xfab0(%rip), %rdi # 0x22924
callq *%rbx
movq %rax, 0x1b46b(%rip) # 0x2e2e8
leaq 0xfaae(%rip), %rdi # 0x22932
callq *%rbx
movq %rax, 0x1b01b(%rip) # 0x2dea8
leaq 0xfab5(%rip), %rdi # 0x22949
callq *%rbx
movq %rax, 0x1ba9b(%rip) # 0x2e938
cmpl $0x0, 0x1a72c(%rip) # 0x2d5d0
je 0x1347a
leaq 0xfaac(%rip), %rdi # 0x2295d
callq *%rbx
movq %rax, 0x1b5fe(%rip) # 0x2e4b8
leaq 0xfab4(%rip), %rdi # 0x22975
callq *%rbx
movq %rax, 0x1af86(%rip) # 0x2de50
leaq 0xfab2(%rip), %rdi # 0x22983
callq *%rbx
movq %rax, 0x1b1d6(%rip) # 0x2e0b0
leaq 0xfab6(%rip), %rdi # 0x22997
callq *%rbx
movq %rax, 0x1acbe(%rip) # 0x2dba8
leaq 0xfabc(%rip), %rdi # 0x229ad
callq *%rbx
movq %rax, 0x1a7b6(%rip) # 0x2d6b0
leaq 0xfac2(%rip), %rdi # 0x229c3
callq *%rbx
movq %rax, 0x1b2fe(%rip) # 0x2e208
leaq 0xfac1(%rip), %rdi # 0x229d2
callq *%rbx
movq %rax, 0x1b866(%rip) # 0x2e780
leaq 0xfac6(%rip), %rdi # 0x229e7
callq *%rbx
movq %rax, 0x1a75e(%rip) # 0x2d688
leaq 0xfac6(%rip), %rdi # 0x229f7
callq *%rbx
movq %rax, 0x1b5be(%rip) # 0x2e4f8
leaq 0xfac6(%rip), %rdi # 0x22a07
callq *%rbx
movq %rax, 0x1a7b6(%rip) # 0x2d700
leaq 0xfac5(%rip), %rdi # 0x22a16
callq *%rbx
movq %rax, 0x1a836(%rip) # 0x2d790
leaq 0xfac5(%rip), %rdi # 0x22a26
callq *%rbx
movq %rax, 0x1afc6(%rip) # 0x2df30
leaq 0xfac4(%rip), %rdi # 0x22a35
callq *%rbx
movq %rax, 0x1b0ee(%rip) # 0x2e068
leaq 0xfac3(%rip), %rdi # 0x22a44
callq *%rbx
movq %rax, 0x1aa56(%rip) # 0x2d9e0
leaq 0xface(%rip), %rdi # 0x22a5f
callq *%rbx
movq %rax, 0x1b3d6(%rip) # 0x2e370
leaq 0xfad8(%rip), %rdi # 0x22a79
callq *%rbx
movq %rax, 0x1b19e(%rip) # 0x2e148
leaq 0xfada(%rip), %rdi # 0x22a8b
callq *%rbx
movq %rax, 0x1bace(%rip) # 0x2ea88
leaq 0xfadd(%rip), %rdi # 0x22a9e
callq *%rbx
movq %rax, 0x1a9e6(%rip) # 0x2d9b0
leaq 0xfae2(%rip), %rdi # 0x22ab3
callq *%rbx
movq %rax, 0x1abc6(%rip) # 0x2dba0
leaq 0xfae6(%rip), %rdi # 0x22ac7
callq *%rbx
movq %rax, 0x1b8ee(%rip) # 0x2e8d8
leaq 0xfae5(%rip), %rdi # 0x22ad6
callq *%rbx
movq %rax, 0x1aea6(%rip) # 0x2dea0
leaq 0xfae9(%rip), %rdi # 0x22aea
callq *%rbx
movq %rax, 0x1ad16(%rip) # 0x2dd20
leaq 0xfae7(%rip), %rdi # 0x22af8
callq *%rbx
movq %rax, 0x1a97e(%rip) # 0x2d998
leaq 0xfaea(%rip), %rdi # 0x22b0b
callq *%rbx
movq %rax, 0x1af8e(%rip) # 0x2dfb8
leaq 0xfaec(%rip), %rdi # 0x22b1d
callq *%rbx
movq %rax, 0x1b6ae(%rip) # 0x2e6e8
leaq 0xfaf1(%rip), %rdi # 0x22b32
callq *%rbx
movq %rax, 0x1b386(%rip) # 0x2e3d0
leaq 0xfaf0(%rip), %rdi # 0x22b41
callq *%rbx
movq %rax, 0x1ad1e(%rip) # 0x2dd78
leaq 0xfaef(%rip), %rdi # 0x22b50
callq *%rbx
movq %rax, 0x1a7f6(%rip) # 0x2d860
leaq 0xfaf3(%rip), %rdi # 0x22b64
callq *%rbx
movq %rax, 0x1b0a6(%rip) # 0x2e120
leaq 0xfaf7(%rip), %rdi # 0x22b78
callq *%rbx
movq %rax, 0x1ad8e(%rip) # 0x2de18
leaq 0xfafb(%rip), %rdi # 0x22b8c
callq *%rbx
movq %rax, 0x1aab6(%rip) # 0x2db50
leaq 0xfb05(%rip), %rdi # 0x22ba6
callq *%rbx
movq %rax, 0x1b28e(%rip) # 0x2e338
leaq 0xfb01(%rip), %rdi # 0x22bb2
callq *%rbx
movq %rax, 0x1a966(%rip) # 0x2da20
leaq 0xfafc(%rip), %rdi # 0x22bbd
callq *%rbx
movq %rax, 0x1af6e(%rip) # 0x2e038
leaq 0xfafa(%rip), %rdi # 0x22bcb
callq *%rbx
movq %rax, 0x1b75e(%rip) # 0x2e838
leaq 0xfaf9(%rip), %rdi # 0x22bda
callq *%rbx
movq %rax, 0x1ad9e(%rip) # 0x2de88
leaq 0xfaf6(%rip), %rdi # 0x22be7
callq *%rbx
movq %rax, 0x1b01e(%rip) # 0x2e118
leaq 0xfaf2(%rip), %rdi # 0x22bf3
callq *%rbx
movq %rax, 0x1b756(%rip) # 0x2e860
leaq 0xfaee(%rip), %rdi # 0x22bff
callq *%rbx
movq %rax, 0x1a6ee(%rip) # 0x2d808
leaq 0xfaea(%rip), %rdi # 0x22c0b
callq *%rbx
movq %rax, 0x1b27e(%rip) # 0x2e3a8
leaq 0xfae6(%rip), %rdi # 0x22c17
callq *%rbx
movq %rax, 0x1b006(%rip) # 0x2e140
leaq 0xfae2(%rip), %rdi # 0x22c23
callq *%rbx
movq %rax, 0x1aad6(%rip) # 0x2dc20
leaq 0xfade(%rip), %rdi # 0x22c2f
callq *%rbx
movq %rax, 0x1aff6(%rip) # 0x2e150
leaq 0xfada(%rip), %rdi # 0x22c3b
callq *%rbx
movq %rax, 0x1b1f6(%rip) # 0x2e360
leaq 0xfad6(%rip), %rdi # 0x22c47
callq *%rbx
movq %rax, 0x1b82e(%rip) # 0x2e9a8
leaq 0xfad3(%rip), %rdi # 0x22c54
callq *%rbx
movq %rax, 0x1b456(%rip) # 0x2e5e0
leaq 0xfad0(%rip), %rdi # 0x22c61
callq *%rbx
movq %rax, 0x1abfe(%rip) # 0x2dd98
leaq 0xfacd(%rip), %rdi # 0x22c6e
callq *%rbx
movq %rax, 0x1b8d6(%rip) # 0x2ea80
leaq 0xfaca(%rip), %rdi # 0x22c7b
callq *%rbx
movq %rax, 0x1b24e(%rip) # 0x2e408
leaq 0xfac7(%rip), %rdi # 0x22c88
callq *%rbx
movq %rax, 0x1ab1e(%rip) # 0x2dce8
leaq 0xfac4(%rip), %rdi # 0x22c95
callq *%rbx
movq %rax, 0x1ac5e(%rip) # 0x2de38
leaq 0xfac1(%rip), %rdi # 0x22ca2
callq *%rbx
movq %rax, 0x1a9ce(%rip) # 0x2dbb8
leaq 0xfabe(%rip), %rdi # 0x22caf
callq *%rbx
movq %rax, 0x1b69e(%rip) # 0x2e898
leaq 0xfac1(%rip), %rdi # 0x22cc2
callq *%rbx
movq %rax, 0x1b7be(%rip) # 0x2e9c8
leaq 0xfac4(%rip), %rdi # 0x22cd5
callq *%rbx
movq %rax, 0x1b85e(%rip) # 0x2ea78
leaq 0xfac7(%rip), %rdi # 0x22ce8
callq *%rbx
movq %rax, 0x1ada6(%rip) # 0x2dfd0
leaq 0xfac9(%rip), %rdi # 0x22cfa
callq *%rbx
movq %rax, 0x1ab2e(%rip) # 0x2dd68
leaq 0xfaca(%rip), %rdi # 0x22d0b
callq *%rbx
movq %rax, 0x1b54e(%rip) # 0x2e798
leaq 0xfacc(%rip), %rdi # 0x22d1d
callq *%rbx
movq %rax, 0x1a4d6(%rip) # 0x2d730
leaq 0xfacd(%rip), %rdi # 0x22d2e
callq *%rbx
movq %rax, 0x1aa86(%rip) # 0x2dcf0
leaq 0xfacf(%rip), %rdi # 0x22d40
callq *%rbx
movq %rax, 0x1a4d6(%rip) # 0x2d750
leaq 0xfad0(%rip), %rdi # 0x22d51
callq *%rbx
movq %rax, 0x1a3ce(%rip) # 0x2d658
leaq 0xfad2(%rip), %rdi # 0x22d63
callq *%rbx
movq %rax, 0x1b7a6(%rip) # 0x2ea40
leaq 0xfad3(%rip), %rdi # 0x22d74
callq *%rbx
movq %rax, 0x1a4de(%rip) # 0x2d788
leaq 0xfad5(%rip), %rdi # 0x22d86
callq *%rbx
movq %rax, 0x1b78e(%rip) # 0x2ea48
leaq 0xfad6(%rip), %rdi # 0x22d97
callq *%rbx
movq %rax, 0x1b62e(%rip) # 0x2e8f8
leaq 0xfad8(%rip), %rdi # 0x22da9
callq *%rbx
movq %rax, 0x1b786(%rip) # 0x2ea60
leaq 0xfad9(%rip), %rdi # 0x22dba
callq *%rbx
movq %rax, 0x1b1ee(%rip) # 0x2e4d8
leaq 0xfadb(%rip), %rdi # 0x22dcc
callq *%rbx
movq %rax, 0x1a5ee(%rip) # 0x2d8e8
leaq 0xfadc(%rip), %rdi # 0x22ddd
callq *%rbx
movq %rax, 0x1b746(%rip) # 0x2ea50
leaq 0xfade(%rip), %rdi # 0x22def
callq *%rbx
movq %rax, 0x1a52e(%rip) # 0x2d848
leaq 0xfadf(%rip), %rdi # 0x22e00
callq *%rbx
movq %rax, 0x1aafe(%rip) # 0x2de28
leaq 0xfae1(%rip), %rdi # 0x22e12
callq *%rbx
movq %rax, 0x1afce(%rip) # 0x2e308
leaq 0xfae2(%rip), %rdi # 0x22e23
callq *%rbx
movq %rax, 0x1a826(%rip) # 0x2db70
leaq 0xfae4(%rip), %rdi # 0x22e35
callq *%rbx
movq %rax, 0x1a89e(%rip) # 0x2dbf8
leaq 0xfae7(%rip), %rdi # 0x22e48
callq *%rbx
movq %rax, 0x1b226(%rip) # 0x2e590
leaq 0xfaea(%rip), %rdi # 0x22e5b
callq *%rbx
movq %rax, 0x1abd6(%rip) # 0x2df50
leaq 0xfaed(%rip), %rdi # 0x22e6e
callq *%rbx
movq %rax, 0x1a5b6(%rip) # 0x2d940
leaq 0xfaf0(%rip), %rdi # 0x22e81
callq *%rbx
movq %rax, 0x1b0ce(%rip) # 0x2e468
leaq 0xfaf4(%rip), %rdi # 0x22e95
callq *%rbx
movq %rax, 0x1a8b6(%rip) # 0x2dc60
leaq 0xfaf8(%rip), %rdi # 0x22ea9
callq *%rbx
movq %rax, 0x1b296(%rip) # 0x2e650
leaq 0xfafc(%rip), %rdi # 0x22ebd
callq *%rbx
movq %rax, 0x1af76(%rip) # 0x2e340
leaq 0xfafe(%rip), %rdi # 0x22ecf
callq *%rbx
movq %rax, 0x1acee(%rip) # 0x2e0c8
leaq 0xfaff(%rip), %rdi # 0x22ee0
callq *%rbx
movq %rax, 0x1a68e(%rip) # 0x2da78
leaq 0xfb01(%rip), %rdi # 0x22ef2
callq *%rbx
movq %rax, 0x1acc6(%rip) # 0x2e0c0
leaq 0xfb02(%rip), %rdi # 0x22f03
callq *%rbx
movq %rax, 0x1af46(%rip) # 0x2e350
leaq 0xfb04(%rip), %rdi # 0x22f15
callq *%rbx
movq %rax, 0x1b3a6(%rip) # 0x2e7c0
leaq 0xfb06(%rip), %rdi # 0x22f27
callq *%rbx
movq %rax, 0x1acd6(%rip) # 0x2e100
leaq 0xfb07(%rip), %rdi # 0x22f38
callq *%rbx
movq %rax, 0x1b526(%rip) # 0x2e960
leaq 0xfb09(%rip), %rdi # 0x22f4a
callq *%rbx
movq %rax, 0x1a3c6(%rip) # 0x2d810
leaq 0xfb0c(%rip), %rdi # 0x22f5d
callq *%rbx
movq %rax, 0x1b126(%rip) # 0x2e580
leaq 0xfb0f(%rip), %rdi # 0x22f70
callq *%rbx
movq %rax, 0x1b296(%rip) # 0x2e700
leaq 0xfb12(%rip), %rdi # 0x22f83
callq *%rbx
movq %rax, 0x1a7c6(%rip) # 0x2dc40
cmpl $0x0, 0x1a153(%rip) # 0x2d5d4
je 0x134e3
leaq 0xfb0f(%rip), %rdi # 0x22f99
callq *%rbx
movq %rax, 0x1ad85(%rip) # 0x2e218
leaq 0xfb14(%rip), %rdi # 0x22fae
callq *%rbx
movq %rax, 0x1a2d5(%rip) # 0x2d778
leaq 0xfb19(%rip), %rdi # 0x22fc3
callq *%rbx
movq %rax, 0x1aa05(%rip) # 0x2deb8
leaq 0xfb1e(%rip), %rdi # 0x22fd8
callq *%rbx
movq %rax, 0x1b2c5(%rip) # 0x2e788
leaq 0xfb23(%rip), %rdi # 0x22fed
callq *%rbx
movq %rax, 0x1a395(%rip) # 0x2d868
leaq 0xfb28(%rip), %rdi # 0x23002
callq *%rbx
movq %rax, 0x1a2e5(%rip) # 0x2d7c8
cmpl $0x0, 0x1a0ee(%rip) # 0x2d5d8
je 0x13a30
leaq 0xfb20(%rip), %rdi # 0x23017
callq *%rbx
movq %rax, 0x1a328(%rip) # 0x2d828
leaq 0xfb1d(%rip), %rdi # 0x23024
callq *%rbx
movq %rax, 0x1b590(%rip) # 0x2eaa0
leaq 0xfb1d(%rip), %rdi # 0x23034
callq *%rbx
movq %rax, 0x1a150(%rip) # 0x2d670
leaq 0xfb1d(%rip), %rdi # 0x23044
callq *%rbx
movq %rax, 0x1a1b0(%rip) # 0x2d6e0
leaq 0xfb17(%rip), %rdi # 0x2304e
callq *%rbx
movq %rax, 0x1b2e0(%rip) # 0x2e820
leaq 0xfb12(%rip), %rdi # 0x23059
callq *%rbx
movq %rax, 0x1a780(%rip) # 0x2dcd0
leaq 0xfb0f(%rip), %rdi # 0x23066
callq *%rbx
movq %rax, 0x1b1c0(%rip) # 0x2e720
leaq 0xfb18(%rip), %rdi # 0x2307f
callq *%rbx
movq %rax, 0x1b188(%rip) # 0x2e6f8
leaq 0xfb1f(%rip), %rdi # 0x23096
callq *%rbx
movq %rax, 0x1b080(%rip) # 0x2e600
leaq 0xfb21(%rip), %rdi # 0x230a8
callq *%rbx
movq %rax, 0x1b220(%rip) # 0x2e7b0
leaq 0xfb22(%rip), %rdi # 0x230b9
callq *%rbx
movq %rax, 0x1a9d0(%rip) # 0x2df70
leaq 0xfb2e(%rip), %rdi # 0x230d5
callq *%rbx
movq %rax, 0x1a0e0(%rip) # 0x2d690
leaq 0xfb3c(%rip), %rdi # 0x230f3
callq *%rbx
movq %rax, 0x1a5f0(%rip) # 0x2dbb0
leaq 0xfb39(%rip), %rdi # 0x23100
callq *%rbx
movq %rax, 0x1a5a8(%rip) # 0x2db78
leaq 0xfb42(%rip), %rdi # 0x23119
callq *%rbx
movq %rax, 0x1b190(%rip) # 0x2e770
leaq 0xfb49(%rip), %rdi # 0x23130
callq *%rbx
movq %rax, 0x1aef8(%rip) # 0x2e4e8
leaq 0xfb50(%rip), %rdi # 0x23147
callq *%rbx
movq %rax, 0x1b340(%rip) # 0x2e940
leaq 0xfb55(%rip), %rdi # 0x2315c
callq *%rbx
movq %rax, 0x1b010(%rip) # 0x2e620
leaq 0xfb5b(%rip), %rdi # 0x23172
callq *%rbx
movq %rax, 0x1aac8(%rip) # 0x2e0e8
leaq 0xfb5d(%rip), %rdi # 0x23184
callq *%rbx
movq %rax, 0x1a6a8(%rip) # 0x2dcd8
leaq 0xfb5f(%rip), %rdi # 0x23196
callq *%rbx
movq %rax, 0x1a950(%rip) # 0x2df90
leaq 0xfb61(%rip), %rdi # 0x231a8
callq *%rbx
movq %rax, 0x1ae48(%rip) # 0x2e498
leaq 0xfb63(%rip), %rdi # 0x231ba
callq *%rbx
movq %rax, 0x1ae60(%rip) # 0x2e4c0
leaq 0xfb66(%rip), %rdi # 0x231cd
callq *%rbx
movq %rax, 0x1aa28(%rip) # 0x2e098
leaq 0xfb69(%rip), %rdi # 0x231e0
callq *%rbx
movq %rax, 0x19f70(%rip) # 0x2d5f0
leaq 0xfb6c(%rip), %rdi # 0x231f3
callq *%rbx
movq %rax, 0x1b030(%rip) # 0x2e6c0
leaq 0xfb6f(%rip), %rdi # 0x23206
callq *%rbx
movq %rax, 0x1b090(%rip) # 0x2e730
leaq 0xfb72(%rip), %rdi # 0x23219
callq *%rbx
movq %rax, 0x1b158(%rip) # 0x2e808
leaq 0xfb75(%rip), %rdi # 0x2322c
callq *%rbx
movq %rax, 0x1acd8(%rip) # 0x2e398
leaq 0xfb78(%rip), %rdi # 0x2323f
callq *%rbx
movq %rax, 0x1ada0(%rip) # 0x2e470
leaq 0xfb7b(%rip), %rdi # 0x23252
callq *%rbx
movq %rax, 0x1b358(%rip) # 0x2ea38
leaq 0xfb7f(%rip), %rdi # 0x23266
callq *%rbx
movq %rax, 0x1aec8(%rip) # 0x2e5b8
leaq 0xfb83(%rip), %rdi # 0x2327a
callq *%rbx
movq %rax, 0x1b148(%rip) # 0x2e848
leaq 0xfb87(%rip), %rdi # 0x2328e
callq *%rbx
movq %rax, 0x1aec0(%rip) # 0x2e5d0
leaq 0xfb8b(%rip), %rdi # 0x232a2
callq *%rbx
movq %rax, 0x1af70(%rip) # 0x2e690
leaq 0xfb8e(%rip), %rdi # 0x232b5
callq *%rbx
movq %rax, 0x1ab30(%rip) # 0x2e260
leaq 0xfb91(%rip), %rdi # 0x232c8
callq *%rbx
movq %rax, 0x1a2f0(%rip) # 0x2da30
leaq 0xfb95(%rip), %rdi # 0x232dc
callq *%rbx
movq %rax, 0x1a850(%rip) # 0x2dfa0
leaq 0xfb99(%rip), %rdi # 0x232f0
callq *%rbx
movq %rax, 0x1a358(%rip) # 0x2dab8
leaq 0xfb99(%rip), %rdi # 0x23300
callq *%rbx
movq %rax, 0x1a5c8(%rip) # 0x2dd38
leaq 0xfba0(%rip), %rdi # 0x23317
callq *%rbx
movq %rax, 0x1a1d8(%rip) # 0x2d958
leaq 0xfba6(%rip), %rdi # 0x2332d
callq *%rbx
movq %rax, 0x1a138(%rip) # 0x2d8c8
leaq 0xfba3(%rip), %rdi # 0x2333a
callq *%rbx
movq %rax, 0x1b060(%rip) # 0x2e800
leaq 0xfba0(%rip), %rdi # 0x23347
callq *%rbx
movq %rax, 0x1ae10(%rip) # 0x2e5c0
leaq 0xfb9d(%rip), %rdi # 0x23354
callq *%rbx
movq %rax, 0x1a9d0(%rip) # 0x2e190
leaq 0xfb9a(%rip), %rdi # 0x23361
callq *%rbx
movq %rax, 0x1a798(%rip) # 0x2df68
leaq 0xfb98(%rip), %rdi # 0x2336f
callq *%rbx
movq %rax, 0x1a730(%rip) # 0x2df10
leaq 0xfb96(%rip), %rdi # 0x2337d
callq *%rbx
movq %rax, 0x1a7f0(%rip) # 0x2dfe0
leaq 0xfb94(%rip), %rdi # 0x2338b
callq *%rbx
movq %rax, 0x1a4f8(%rip) # 0x2dcf8
leaq 0xfb92(%rip), %rdi # 0x23399
callq *%rbx
movq %rax, 0x1aec8(%rip) # 0x2e6d8
leaq 0xfb94(%rip), %rdi # 0x233ab
callq *%rbx
movq %rax, 0x1aa60(%rip) # 0x2e280
leaq 0xfb97(%rip), %rdi # 0x233be
callq *%rbx
movq %rax, 0x1b088(%rip) # 0x2e8b8
leaq 0xfb9c(%rip), %rdi # 0x233d3
callq *%rbx
movq %rax, 0x1a3a8(%rip) # 0x2dbe8
leaq 0xfba2(%rip), %rdi # 0x233e9
callq *%rbx
movq %rax, 0x1ad48(%rip) # 0x2e598
leaq 0xfba2(%rip), %rdi # 0x233f9
callq *%rbx
movq %rax, 0x1b248(%rip) # 0x2eaa8
leaq 0xfba3(%rip), %rdi # 0x2340a
callq *%rbx
movq %rax, 0x19f68(%rip) # 0x2d7d8
leaq 0xfba3(%rip), %rdi # 0x2341a
callq *%rbx
movq %rax, 0x19fb0(%rip) # 0x2d830
leaq 0xfba3(%rip), %rdi # 0x2342a
callq *%rbx
movq %rax, 0x1a958(%rip) # 0x2e1e8
leaq 0xfba0(%rip), %rdi # 0x23437
callq *%rbx
movq %rax, 0x1a118(%rip) # 0x2d9b8
leaq 0xfba1(%rip), %rdi # 0x23448
callq *%rbx
movq %rax, 0x1aa68(%rip) # 0x2e318
leaq 0xfba4(%rip), %rdi # 0x2345b
callq *%rbx
movq %rax, 0x1a358(%rip) # 0x2dc18
leaq 0xfbaa(%rip), %rdi # 0x23471
callq *%rbx
movq %rax, 0x19e48(%rip) # 0x2d718
leaq 0xfbad(%rip), %rdi # 0x23484
callq *%rbx
movq %rax, 0x19ee0(%rip) # 0x2d7c0
leaq 0xfbb3(%rip), %rdi # 0x2349a
callq *%rbx
movq %rax, 0x1a248(%rip) # 0x2db38
leaq 0xfbc0(%rip), %rdi # 0x234b7
callq *%rbx
movq %rax, 0x1ac08(%rip) # 0x2e508
leaq 0xfbc0(%rip), %rdi # 0x234c7
callq *%rbx
movq %rax, 0x1a890(%rip) # 0x2e1a0
leaq 0xfbc2(%rip), %rdi # 0x234d9
callq *%rbx
movq %rax, 0x19f98(%rip) # 0x2d8b8
leaq 0xfbc7(%rip), %rdi # 0x234ee
callq *%rbx
movq %rax, 0x1a070(%rip) # 0x2d9a0
leaq 0xfbc9(%rip), %rdi # 0x23500
callq *%rbx
movq %rax, 0x1ae18(%rip) # 0x2e758
leaq 0xfbd2(%rip), %rdi # 0x23519
callq *%rbx
movq %rax, 0x1a3c8(%rip) # 0x2dd18
leaq 0xfbd9(%rip), %rdi # 0x23530
callq *%rbx
movq %rax, 0x19fc8(%rip) # 0x2d928
leaq 0xfbe0(%rip), %rdi # 0x23547
callq *%rbx
movq %rax, 0x1a8c8(%rip) # 0x2e238
leaq 0xfbe7(%rip), %rdi # 0x2355e
callq *%rbx
movq %rax, 0x19ca8(%rip) # 0x2d628
leaq 0xfbf1(%rip), %rdi # 0x23578
callq *%rbx
movq %rax, 0x19fa0(%rip) # 0x2d930
leaq 0xfc07(%rip), %rdi # 0x2359e
callq *%rbx
movq %rax, 0x1a8f0(%rip) # 0x2e290
leaq 0xfc08(%rip), %rdi # 0x235af
callq *%rbx
movq %rax, 0x19e90(%rip) # 0x2d840
leaq 0xfc0a(%rip), %rdi # 0x235c1
callq *%rbx
movq %rax, 0x1a9f0(%rip) # 0x2e3b0
leaq 0xfc1b(%rip), %rdi # 0x235e2
callq *%rbx
movq %rax, 0x1a278(%rip) # 0x2dc48
leaq 0xfc25(%rip), %rdi # 0x235fc
callq *%rbx
movq %rax, 0x1adf8(%rip) # 0x2e7d8
leaq 0xfc26(%rip), %rdi # 0x2360d
callq *%rbx
movq %rax, 0x1a278(%rip) # 0x2dc68
leaq 0xfc2f(%rip), %rdi # 0x23626
callq *%rbx
movq %rax, 0x1a4c0(%rip) # 0x2dec0
leaq 0xfc31(%rip), %rdi # 0x23638
callq *%rbx
movq %rax, 0x1a158(%rip) # 0x2db68
leaq 0xfc36(%rip), %rdi # 0x2364d
callq *%rbx
movq %rax, 0x1a998(%rip) # 0x2e3b8
leaq 0xfc38(%rip), %rdi # 0x2365f
callq *%rbx
movq %rax, 0x19fa8(%rip) # 0x2d9d8
cmpl $0x0, 0x19ba5(%rip) # 0x2d5dc
je 0x13b2d
leaq 0xfc2b(%rip), %rdi # 0x2366f
callq *%rbx
movq %rax, 0x1a83b(%rip) # 0x2e288
leaq 0xfc31(%rip), %rdi # 0x23685
callq *%rbx
movq %rax, 0x1a0ab(%rip) # 0x2db08
leaq 0xfc39(%rip), %rdi # 0x2369d
callq *%rbx
movq %rax, 0x1a553(%rip) # 0x2dfc0
leaq 0xfc35(%rip), %rdi # 0x236a9
callq *%rbx
movq %rax, 0x1aa9b(%rip) # 0x2e518
leaq 0xfc3d(%rip), %rdi # 0x236c1
callq *%rbx
movq %rax, 0x1afa3(%rip) # 0x2ea30
leaq 0xfc41(%rip), %rdi # 0x236d5
callq *%rbx
movq %rax, 0x19f7b(%rip) # 0x2da18
leaq 0xfc45(%rip), %rdi # 0x236e9
callq *%rbx
movq %rax, 0x19fab(%rip) # 0x2da58
leaq 0xfc4b(%rip), %rdi # 0x236ff
callq *%rbx
movq %rax, 0x19e43(%rip) # 0x2d900
leaq 0xfc52(%rip), %rdi # 0x23716
callq *%rbx
movq %rax, 0x1ada3(%rip) # 0x2e870
leaq 0xfc59(%rip), %rdi # 0x2372d
callq *%rbx
movq %rax, 0x1a37b(%rip) # 0x2de58
leaq 0xfc63(%rip), %rdi # 0x23747
callq *%rbx
movq %rax, 0x1ad53(%rip) # 0x2e840
leaq 0xfc6f(%rip), %rdi # 0x23763
callq *%rbx
movq %rax, 0x1a933(%rip) # 0x2e430
leaq 0xf592(%rip), %rdi # 0x23096
callq *%rbx
movq %rax, 0x1aaf3(%rip) # 0x2e600
leaq 0xf594(%rip), %rdi # 0x230a8
callq *%rbx
movq %rax, 0x1ac93(%rip) # 0x2e7b0
leaq 0xf510(%rip), %rdi # 0x23034
callq *%rbx
movq %rax, 0x19b43(%rip) # 0x2d670
cmpl $0x0, 0x19aac(%rip) # 0x2d5e0
je 0x13c6a
leaq 0xfc38(%rip), %rdi # 0x23779
callq *%rbx
movq %rax, 0x1a036(%rip) # 0x2db80
leaq 0xfc41(%rip), %rdi # 0x23792
callq *%rbx
movq %rax, 0x19c0e(%rip) # 0x2d768
leaq 0xfc4f(%rip), %rdi # 0x237b0
callq *%rbx
movq %rax, 0x1a886(%rip) # 0x2e3f0
leaq 0xfc61(%rip), %rdi # 0x237d2
callq *%rbx
movq %rax, 0x1a376(%rip) # 0x2def0
leaq 0xfc6f(%rip), %rdi # 0x237f0
callq *%rbx
movq %rax, 0x1a6a6(%rip) # 0x2e230
leaq 0xfc71(%rip), %rdi # 0x23802
callq *%rbx
movq %rax, 0x19fc6(%rip) # 0x2db60
leaq 0xfc6d(%rip), %rdi # 0x2380e
callq *%rbx
movq %rax, 0x1a056(%rip) # 0x2dc00
leaq 0xfc66(%rip), %rdi # 0x23817
callq *%rbx
movq %rax, 0x1a246(%rip) # 0x2de00
leaq 0xfc63(%rip), %rdi # 0x23824
callq *%rbx
movq %rax, 0x1aaee(%rip) # 0x2e6b8
leaq 0xfc64(%rip), %rdi # 0x23835
callq *%rbx
movq %rax, 0x1a51e(%rip) # 0x2e0f8
leaq 0xfc5f(%rip), %rdi # 0x23840
callq *%rbx
movq %rax, 0x19e56(%rip) # 0x2da40
leaq 0xfc5f(%rip), %rdi # 0x23850
callq *%rbx
movq %rax, 0x1ac5e(%rip) # 0x2e858
leaq 0xfc5b(%rip), %rdi # 0x2385c
callq *%rbx
movq %rax, 0x1a096(%rip) # 0x2dca0
leaq 0xfc5d(%rip), %rdi # 0x2386e
callq *%rbx
movq %rax, 0x1a4be(%rip) # 0x2e0d8
leaq 0xfc66(%rip), %rdi # 0x23887
callq *%rbx
movq %rax, 0x1abb6(%rip) # 0x2e7e0
leaq 0xfc6b(%rip), %rdi # 0x2389c
callq *%rbx
movq %rax, 0x1a1d6(%rip) # 0x2de10
leaq 0xfc73(%rip), %rdi # 0x238b4
callq *%rbx
movq %rax, 0x1ae26(%rip) # 0x2ea70
leaq 0xfc7b(%rip), %rdi # 0x238cc
callq *%rbx
movq %rax, 0x19ab6(%rip) # 0x2d710
leaq 0xfc7e(%rip), %rdi # 0x238df
callq *%rbx
movq %rax, 0x19af6(%rip) # 0x2d760
leaq 0xfc7c(%rip), %rdi # 0x238ed
callq 0x13e2a
movl %eax, 0x1ae3c(%rip) # 0x2eab8
leaq 0xfc89(%rip), %rdi # 0x2390c
callq 0x13e2a
movl %eax, 0x1ae26(%rip) # 0x2eab4
leaq 0xfc8a(%rip), %rdi # 0x2391f
callq 0x13e2a
movl %eax, 0x1ae10(%rip) # 0x2eab0
cmpl $0x0, 0x1ae0d(%rip) # 0x2eab4
je 0x13cbf
leaq 0xfc81(%rip), %rdi # 0x23931
callq *%rbx
movq %rax, 0x1ae07(%rip) # 0x2eac0
movl 0x1adf1(%rip), %eax # 0x2eab0
testl %eax, %eax
je 0x13e07
leaq 0xfc77(%rip), %rdi # 0x23945
callq *%rbx
movq %rax, 0x1adf1(%rip) # 0x2eac8
leaq 0xfc83(%rip), %rdi # 0x23961
callq *%rbx
movq %rax, 0x1ade9(%rip) # 0x2ead0
leaq 0xfc85(%rip), %rdi # 0x23973
callq *%rbx
movq %rax, 0x1ade1(%rip) # 0x2ead8
leaq 0xfc86(%rip), %rdi # 0x23984
callq *%rbx
movq %rax, 0x1add9(%rip) # 0x2eae0
leaq 0xfc92(%rip), %rdi # 0x239a0
callq *%rbx
movq %rax, 0x1add1(%rip) # 0x2eae8
leaq 0xfc95(%rip), %rdi # 0x239b3
callq *%rbx
movq %rax, 0x1adc9(%rip) # 0x2eaf0
leaq 0xfc98(%rip), %rdi # 0x239c6
callq *%rbx
movq %rax, 0x1adc1(%rip) # 0x2eaf8
leaq 0xfc9c(%rip), %rdi # 0x239da
callq *%rbx
movq %rax, 0x1adb9(%rip) # 0x2eb00
leaq 0xfc9f(%rip), %rdi # 0x239ed
callq *%rbx
movq %rax, 0x1adb1(%rip) # 0x2eb08
leaq 0xfc9e(%rip), %rdi # 0x239fc
callq *%rbx
movq %rax, 0x1ada9(%rip) # 0x2eb10
leaq 0xfc9d(%rip), %rdi # 0x23a0b
callq *%rbx
movq %rax, 0x1ada1(%rip) # 0x2eb18
leaq 0xfc9c(%rip), %rdi # 0x23a1a
callq *%rbx
movq %rax, 0x1ad99(%rip) # 0x2eb20
leaq 0xfca0(%rip), %rdi # 0x23a2e
callq *%rbx
movq %rax, 0x1ad91(%rip) # 0x2eb28
leaq 0xfca5(%rip), %rdi # 0x23a43
callq *%rbx
movq %rax, 0x1ad89(%rip) # 0x2eb30
leaq 0xfcaa(%rip), %rdi # 0x23a58
callq *%rbx
movq %rax, 0x1ad81(%rip) # 0x2eb38
leaq 0xfcb2(%rip), %rdi # 0x23a70
callq *%rbx
movq %rax, 0x1ad79(%rip) # 0x2eb40
leaq 0xfcb6(%rip), %rdi # 0x23a84
callq *%rbx
movq %rax, 0x1ad71(%rip) # 0x2eb48
leaq 0xfcc1(%rip), %rdi # 0x23a9f
callq *%rbx
movq %rax, 0x1ad69(%rip) # 0x2eb50
leaq 0xfcca(%rip), %rdi # 0x23ab8
callq *%rbx
movq %rax, 0x1ad61(%rip) # 0x2eb58
leaq 0xfccd(%rip), %rdi # 0x23acb
callq *%rbx
movq %rax, 0x1ad59(%rip) # 0x2eb60
movl 0x1979f(%rip), %eax # 0x2d5ac
xorl %ebp, %ebp
orl 0x19793(%rip), %eax # 0x2d5a8
setne %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/deps/glad.c
|
glfwIsValidContextConfig
|
GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
{
if (ctxconfig->source != GLFW_NATIVE_CONTEXT_API &&
ctxconfig->source != GLFW_EGL_CONTEXT_API)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid context creation API %i",
ctxconfig->source);
return GLFW_FALSE;
}
if (ctxconfig->client != GLFW_NO_API &&
ctxconfig->client != GLFW_OPENGL_API &&
ctxconfig->client != GLFW_OPENGL_ES_API)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid client API %i",
ctxconfig->client);
return GLFW_FALSE;
}
if (ctxconfig->client == GLFW_OPENGL_API)
{
if ((ctxconfig->major < 1 || ctxconfig->minor < 0) ||
(ctxconfig->major == 1 && ctxconfig->minor > 5) ||
(ctxconfig->major == 2 && ctxconfig->minor > 1) ||
(ctxconfig->major == 3 && ctxconfig->minor > 3))
{
// OpenGL 1.0 is the smallest valid version
// OpenGL 1.x series ended with version 1.5
// OpenGL 2.x series ended with version 2.1
// OpenGL 3.x series ended with version 3.3
// For now, let everything else through
_glfwInputError(GLFW_INVALID_VALUE,
"Invalid OpenGL version %i.%i",
ctxconfig->major, ctxconfig->minor);
return GLFW_FALSE;
}
if (ctxconfig->profile)
{
if (ctxconfig->profile != GLFW_OPENGL_CORE_PROFILE &&
ctxconfig->profile != GLFW_OPENGL_COMPAT_PROFILE)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid OpenGL profile %i",
ctxconfig->profile);
return GLFW_FALSE;
}
if (ctxconfig->major <= 2 ||
(ctxconfig->major == 3 && ctxconfig->minor < 2))
{
// Desktop OpenGL context profiles are only defined for version 3.2
// and above
_glfwInputError(GLFW_INVALID_VALUE,
"Context profiles are only defined for OpenGL version 3.2 and above");
return GLFW_FALSE;
}
}
if (ctxconfig->forward && ctxconfig->major <= 2)
{
// Forward-compatible contexts are only defined for OpenGL version 3.0 and above
_glfwInputError(GLFW_INVALID_VALUE,
"Forward-compatibility is only defined for OpenGL version 3.0 and above");
return GLFW_FALSE;
}
}
else if (ctxconfig->client == GLFW_OPENGL_ES_API)
{
if (ctxconfig->major < 1 || ctxconfig->minor < 0 ||
(ctxconfig->major == 1 && ctxconfig->minor > 1) ||
(ctxconfig->major == 2 && ctxconfig->minor > 0))
{
// OpenGL ES 1.0 is the smallest valid version
// OpenGL ES 1.x series ended with version 1.1
// OpenGL ES 2.x series ended with version 2.0
// For now, let everything else through
_glfwInputError(GLFW_INVALID_VALUE,
"Invalid OpenGL ES version %i.%i",
ctxconfig->major, ctxconfig->minor);
return GLFW_FALSE;
}
}
if (ctxconfig->robustness)
{
if (ctxconfig->robustness != GLFW_NO_RESET_NOTIFICATION &&
ctxconfig->robustness != GLFW_LOSE_CONTEXT_ON_RESET)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid context robustness mode %i",
ctxconfig->robustness);
return GLFW_FALSE;
}
}
if (ctxconfig->release)
{
if (ctxconfig->release != GLFW_RELEASE_BEHAVIOR_NONE &&
ctxconfig->release != GLFW_RELEASE_BEHAVIOR_FLUSH)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid context release behavior %i",
ctxconfig->release);
return GLFW_FALSE;
}
}
return GLFW_TRUE;
}
|
pushq %rbx
movl 0x4(%rdi), %edx
leal -0x36001(%rdx), %eax
cmpl $0x2, %eax
jae 0x13f93
movl (%rdi), %edx
testl %edx, %edx
je 0x14071
cmpl $0x30001, %edx # imm = 0x30001
je 0x13fad
cmpl $0x30002, %edx # imm = 0x30002
jne 0x13fef
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %ecx
testl %edx, %edx
setle %al
testl %ecx, %ecx
sets %sil
orb %al, %sil
jne 0x13f8a
cmpl $0x1, %edx
sete %al
cmpl $0x2, %ecx
setae %sil
testb %sil, %al
jne 0x13f8a
cmpl $0x2, %edx
setne %al
testl %ecx, %ecx
sete %sil
orb %al, %sil
jne 0x14071
leaq 0xfc41(%rip), %rsi # 0x23bd2
jmp 0x13fdc
leaq 0xfb41(%rip), %rsi # 0x23adb
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x14954
jmp 0x1409a
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %ecx
testl %edx, %edx
setle %al
testl %ecx, %ecx
sets %sil
orb %al, %sil
jne 0x13fd5
cmpl $0x1, %edx
sete %al
cmpl $0x6, %ecx
setae %sil
testb %sil, %al
je 0x13fff
leaq 0xfb35(%rip), %rsi # 0x23b11
xorl %ebx, %ebx
movl $0x10004, %edi # imm = 0x10004
xorl %eax, %eax
callq 0x14954
jmp 0x1409a
leaq 0xfb05(%rip), %rsi # 0x23afb
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
jmp 0x13fa1
cmpl $0x3, %edx
je 0x14012
cmpl $0x2, %edx
jne 0x1400e
cmpl $0x1, %ecx
ja 0x13fd5
xorl %esi, %esi
jmp 0x1401a
movb $0x1, %sil
cmpl $0x4, %ecx
jae 0x13fd5
movl 0x1c(%rdi), %eax
leal -0x32001(%rax), %r8d
cmpl $0x2, %r8d
jae 0x1404b
cmpl $0x3, %edx
setae %al
cmpl $0x2, %ecx
setae %cl
xorb $0x1, %sil
orb %cl, %sil
testb %sil, %al
jne 0x14071
leaq 0xfaff(%rip), %rsi # 0x23b48
jmp 0x14061
testl %eax, %eax
jne 0x140b6
cmpl $0x2, %edx
ja 0x14071
cmpl $0x0, 0x10(%rdi)
je 0x14071
leaq 0xfb2a(%rip), %rsi # 0x23b8b
xorl %ebx, %ebx
movl $0x10004, %edi # imm = 0x10004
xorl %eax, %eax
callq 0x14954
jmp 0x1409a
movl 0x20(%rdi), %edx
leal -0x31001(%rdx), %eax
cmpl $0x2, %eax
jb 0x14083
testl %edx, %edx
jne 0x1409e
movl 0x24(%rdi), %edx
movl $0x1, %ebx
leal -0x35001(%rdx), %eax
cmpl $0x2, %eax
jb 0x1409a
testl %edx, %edx
jne 0x140aa
movl %ebx, %eax
popq %rbx
retq
leaq 0xfb4d(%rip), %rsi # 0x23bf2
jmp 0x13f9a
leaq 0xfb64(%rip), %rsi # 0x23c15
jmp 0x13f9a
leaq 0xfa71(%rip), %rsi # 0x23b2e
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
movl %eax, %edx
jmp 0x13fa1
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/context.c
|
glfwChooseFBConfig
|
const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
const _GLFWfbconfig* alternatives,
unsigned int count)
{
unsigned int i;
unsigned int missing, leastMissing = UINT_MAX;
unsigned int colorDiff, leastColorDiff = UINT_MAX;
unsigned int extraDiff, leastExtraDiff = UINT_MAX;
const _GLFWfbconfig* current;
const _GLFWfbconfig* closest = NULL;
for (i = 0; i < count; i++)
{
current = alternatives + i;
if (desired->stereo > 0 && current->stereo == 0)
{
// Stereo is a hard constraint
continue;
}
if (desired->doublebuffer != current->doublebuffer)
{
// Double buffering is a hard constraint
continue;
}
// Count number of missing buffers
{
missing = 0;
if (desired->alphaBits > 0 && current->alphaBits == 0)
missing++;
if (desired->depthBits > 0 && current->depthBits == 0)
missing++;
if (desired->stencilBits > 0 && current->stencilBits == 0)
missing++;
if (desired->auxBuffers > 0 &&
current->auxBuffers < desired->auxBuffers)
{
missing += desired->auxBuffers - current->auxBuffers;
}
if (desired->samples > 0 && current->samples == 0)
{
// Technically, several multisampling buffers could be
// involved, but that's a lower level implementation detail and
// not important to us here, so we count them as one
missing++;
}
}
// These polynomials make many small channel size differences matter
// less than one large channel size difference
// Calculate color channel size difference value
{
colorDiff = 0;
if (desired->redBits != GLFW_DONT_CARE)
{
colorDiff += (desired->redBits - current->redBits) *
(desired->redBits - current->redBits);
}
if (desired->greenBits != GLFW_DONT_CARE)
{
colorDiff += (desired->greenBits - current->greenBits) *
(desired->greenBits - current->greenBits);
}
if (desired->blueBits != GLFW_DONT_CARE)
{
colorDiff += (desired->blueBits - current->blueBits) *
(desired->blueBits - current->blueBits);
}
}
// Calculate non-color channel size difference value
{
extraDiff = 0;
if (desired->alphaBits != GLFW_DONT_CARE)
{
extraDiff += (desired->alphaBits - current->alphaBits) *
(desired->alphaBits - current->alphaBits);
}
if (desired->depthBits != GLFW_DONT_CARE)
{
extraDiff += (desired->depthBits - current->depthBits) *
(desired->depthBits - current->depthBits);
}
if (desired->stencilBits != GLFW_DONT_CARE)
{
extraDiff += (desired->stencilBits - current->stencilBits) *
(desired->stencilBits - current->stencilBits);
}
if (desired->accumRedBits != GLFW_DONT_CARE)
{
extraDiff += (desired->accumRedBits - current->accumRedBits) *
(desired->accumRedBits - current->accumRedBits);
}
if (desired->accumGreenBits != GLFW_DONT_CARE)
{
extraDiff += (desired->accumGreenBits - current->accumGreenBits) *
(desired->accumGreenBits - current->accumGreenBits);
}
if (desired->accumBlueBits != GLFW_DONT_CARE)
{
extraDiff += (desired->accumBlueBits - current->accumBlueBits) *
(desired->accumBlueBits - current->accumBlueBits);
}
if (desired->accumAlphaBits != GLFW_DONT_CARE)
{
extraDiff += (desired->accumAlphaBits - current->accumAlphaBits) *
(desired->accumAlphaBits - current->accumAlphaBits);
}
if (desired->samples != GLFW_DONT_CARE)
{
extraDiff += (desired->samples - current->samples) *
(desired->samples - current->samples);
}
if (desired->sRGB && !current->sRGB)
extraDiff++;
}
// Figure out if the current one is better than the best one found so far
// Least number of missing buffers is the most important heuristic,
// then color buffer size match and lastly size match for other buffers
if (missing < leastMissing)
closest = current;
else if (missing == leastMissing)
{
if ((colorDiff < leastColorDiff) ||
(colorDiff == leastColorDiff && extraDiff < leastExtraDiff))
{
closest = current;
}
}
if (current == closest)
{
leastMissing = missing;
leastColorDiff = colorDiff;
leastExtraDiff = extraDiff;
}
}
return closest;
}
|
testl %edx, %edx
je 0x142a7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x2c(%rdi), %ecx
movl %edx, %edx
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
xorl %eax, %eax
movl $0xffffffff, %r11d # imm = 0xFFFFFFFF
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testl %ecx, %ecx
jle 0x14103
cmpl $0x0, 0x2c(%rsi)
je 0x1427d
movl 0x38(%rdi), %r9d
cmpl 0x38(%rsi), %r9d
jne 0x1427d
movl 0xc(%rdi), %r9d
xorl %r10d, %r10d
testl %r9d, %r9d
jle 0x14125
cmpl $0x0, 0xc(%rsi)
sete %r10b
movl 0x10(%rdi), %r12d
testl %r12d, %r12d
jle 0x14136
cmpl $0x1, 0x10(%rsi)
adcl $0x0, %r10d
movl 0x14(%rdi), %r15d
testl %r15d, %r15d
jle 0x14147
cmpl $0x1, 0x14(%rsi)
adcl $0x0, %r10d
movl 0x28(%rdi), %ebp
testl %ebp, %ebp
jle 0x14160
movl 0x28(%rsi), %r14d
cmpl %ebp, %r14d
jge 0x14160
addl %r10d, %ebp
subl %r14d, %ebp
movl %ebp, %r10d
movl 0x30(%rdi), %r14d
testl %r14d, %r14d
jle 0x14171
cmpl $0x1, 0x30(%rsi)
adcl $0x0, %r10d
movl (%rdi), %ebp
cmpl $-0x1, %ebp
je 0x1417f
subl (%rsi), %ebp
imull %ebp, %ebp
jmp 0x14181
xorl %ebp, %ebp
movl 0x4(%rdi), %r13d
cmpl $-0x1, %r13d
je 0x14196
subl 0x4(%rsi), %r13d
imull %r13d, %r13d
addl %r13d, %ebp
movl 0x8(%rdi), %r13d
cmpl $-0x1, %r13d
je 0x141ab
subl 0x8(%rsi), %r13d
imull %r13d, %r13d
addl %r13d, %ebp
cmpl $-0x1, %r9d
je 0x141bb
subl 0xc(%rsi), %r9d
imull %r9d, %r9d
jmp 0x141be
xorl %r9d, %r9d
cmpl $-0x1, %r12d
je 0x141cf
subl 0x10(%rsi), %r12d
imull %r12d, %r12d
addl %r12d, %r9d
cmpl $-0x1, %r15d
je 0x141e0
subl 0x14(%rsi), %r15d
imull %r15d, %r15d
addl %r15d, %r9d
movl 0x18(%rdi), %r15d
cmpl $-0x1, %r15d
je 0x141f5
subl 0x18(%rsi), %r15d
imull %r15d, %r15d
addl %r15d, %r9d
movl 0x1c(%rdi), %r15d
cmpl $-0x1, %r15d
je 0x1420a
subl 0x1c(%rsi), %r15d
imull %r15d, %r15d
addl %r15d, %r9d
movl 0x20(%rdi), %r15d
cmpl $-0x1, %r15d
je 0x1421f
subl 0x20(%rsi), %r15d
imull %r15d, %r15d
addl %r15d, %r9d
movl 0x24(%rdi), %r15d
cmpl $-0x1, %r15d
je 0x14234
subl 0x24(%rsi), %r15d
imull %r15d, %r15d
addl %r15d, %r9d
cmpl $-0x1, %r14d
je 0x14245
subl 0x30(%rsi), %r14d
imull %r14d, %r14d
addl %r14d, %r9d
cmpl $0x0, 0x34(%rdi)
je 0x14253
cmpl $0x1, 0x34(%rsi)
adcl $0x0, %r9d
cmpl %ebx, %r10d
jae 0x1425d
movq %rsi, %rax
jmp 0x14286
jne 0x14278
cmpl %r11d, %ebp
jae 0x14269
movl %ebx, %r10d
jmp 0x14258
jne 0x14278
cmpl %r8d, %r9d
jae 0x14278
movl %ebx, %r10d
movl %r11d, %ebp
jmp 0x14258
cmpq %rax, %rsi
je 0x14286
movl %ebx, %r10d
movl %r11d, %ebp
movl %r8d, %r9d
addq $0x48, %rsi
movl %r9d, %r8d
movl %ebp, %r11d
movl %r10d, %ebx
decq %rdx
jne 0x140f5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/context.c
|
glfwRefreshContextAttribs
|
GLFWbool _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig)
{
int i;
_GLFWwindow* window;
const char* version;
const char* prefixes[] =
{
"OpenGL ES-CM ",
"OpenGL ES-CL ",
"OpenGL ES ",
NULL
};
window = _glfwPlatformGetCurrentContext();
window->context.source = ctxconfig->source;
window->context.client = GLFW_OPENGL_API;
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");
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");
}
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");
}
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);
}
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");
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);
}
return GLFW_TRUE;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
callq 0x1e42e
movq %rax, %rbx
movl 0x4(%r14), %eax
movl %eax, 0x1f4(%rbx)
movl $0x30001, 0x1f0(%rbx) # imm = 0x30001
leaq 0xcfa6(%rip), %rdi # 0x21284
callq *0x258(%rbx)
movq %rax, 0x228(%rbx)
leaq 0xcd94(%rip), %rdi # 0x21086
callq *0x258(%rbx)
movq %rax, 0x230(%rbx)
cmpq $0x0, 0x228(%rbx)
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x1433d
leaq 0xf91b(%rip), %rsi # 0x23c39
xorl %ebx, %ebx
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x14954
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1f02, %edi # imm = 0x1F02
callq *%rax
testq %rax, %rax
je 0x14388
movq %rax, %r13
movq %r14, 0x10(%rsp)
xorl %ebp, %ebp
leaq 0x189a6(%rip), %r14 # 0x2cd00
movq (%rbp,%r14), %r12
movq %r12, %rdi
callq 0x10460
movq %rax, %r15
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x102a0
testl %eax, %eax
je 0x1439e
addq $0x8, %rbp
cmpq $0x18, %rbp
jne 0x1435a
jmp 0x143ab
cmpl $0x30001, (%r14) # imm = 0x30001
jne 0x14527
leaq 0xf8bd(%rip), %rsi # 0x23c59
jmp 0x1431e
addq %r15, %r13
movl $0x30002, 0x1f0(%rbx) # imm = 0x30002
leaq 0x1f8(%rbx), %r12
leaq 0x1fc(%rbx), %r15
movq %rbx, %r8
addq $0x200, %r8 # imm = 0x200
leaq 0xf8e6(%rip), %rsi # 0x23cb0
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x101e0
testl %eax, %eax
movq 0x10(%rsp), %r14
je 0x14417
movl (%r12), %r8d
movl 0x8(%r14), %edx
cmpl %edx, %r8d
jge 0x14433
movl 0x1fc(%rbx), %r9d
cmpl $0x30001, 0x1f0(%rbx) # imm = 0x30001
movl 0xc(%r14), %ecx
jne 0x14533
leaq 0xf8fe(%rip), %rsi # 0x23d10
jmp 0x1453a
cmpl $0x30001, 0x1f0(%rbx) # imm = 0x30001
jne 0x1454d
leaq 0xf88b(%rip), %rsi # 0x23cb9
jmp 0x1431e
jne 0x1443e
movl (%r15), %eax
cmpl 0xc(%r14), %eax
jl 0x143f0
cmpl $0x3, %r8d
jl 0x14461
leaq 0xefdf(%rip), %rdi # 0x2342a
callq *0x258(%rbx)
movq %rax, 0x220(%rbx)
testq %rax, %rax
je 0x14317
cmpl $0x30001, 0x1f0(%rbx) # imm = 0x30001
jne 0x14559
cmpl $0x3, (%r12)
jl 0x1456e
leaq 0xc(%rsp), %r13
movl $0x821e, %edi # imm = 0x821E
movq %r13, %rsi
callq *0x228(%rbx)
movl (%r13), %eax
testb $0x1, %al
je 0x144a1
movl $0x1, 0x204(%rbx)
testb $0x2, %al
jne 0x144bc
leaq 0xf8cb(%rip), %rdi # 0x23d77
callq 0x1461e
testl %eax, %eax
je 0x144c6
cmpl $0x0, 0x14(%r14)
je 0x144c6
movl $0x1, 0x208(%rbx)
testb $0x8, 0xc(%rsp)
je 0x144d7
movl $0x1, 0x20c(%rbx)
cmpl $0x3, (%r12)
jle 0x14562
leaq 0xc(%rsp), %r14
movl $0x9126, %edi # imm = 0x9126
movq %r14, %rsi
callq *0x228(%rbx)
movl (%r14), %eax
movl $0x32002, %ecx # imm = 0x32002
testb $0x2, %al
jne 0x1451f
movl $0x32001, %ecx # imm = 0x32001
testb $0x1, %al
jne 0x1451f
leaq 0xf87a(%rip), %rdi # 0x23d8b
callq 0x1461e
movl $0x32002, %ecx # imm = 0x32002
testl %eax, %eax
je 0x1456e
movl %ecx, 0x210(%rbx)
jmp 0x1456e
leaq 0xf755(%rip), %rsi # 0x23c83
jmp 0x1431e
leaq 0xf808(%rip), %rsi # 0x23d42
xorl %ebx, %ebx
movl $0x10007, %edi # imm = 0x10007
xorl %eax, %eax
callq 0x14954
jmp 0x1432c
leaq 0xf78f(%rip), %rsi # 0x23ce3
jmp 0x1431e
leaq 0xf840(%rip), %rdi # 0x23da0
jmp 0x14575
jne 0x1456e
cmpl $0x2, (%r15)
jge 0x144e2
leaq 0xf3aa(%rip), %rdi # 0x2391f
callq 0x1461e
testl %eax, %eax
je 0x145b4
leaq 0xc(%rsp), %r14
movl $0x8256, %edi # imm = 0x8256
movq %r14, %rsi
callq *0x228(%rbx)
movl (%r14), %eax
cmpl $0x8252, %eax # imm = 0x8252
je 0x145a9
cmpl $0x8261, %eax # imm = 0x8261
jne 0x145b4
movl $0x31001, %eax # imm = 0x31001
jmp 0x145ae
movl $0x31002, %eax # imm = 0x31002
movl %eax, 0x214(%rbx)
leaq 0xf7f7(%rip), %rdi # 0x23db2
callq 0x1461e
testl %eax, %eax
je 0x145f7
leaq 0xc(%rsp), %r14
movl $0x82fb, %edi # imm = 0x82FB
movq %r14, %rsi
callq *0x228(%rbx)
movl (%r14), %eax
testl %eax, %eax
je 0x145ec
cmpl $0x82fc, %eax # imm = 0x82FC
jne 0x145f7
movl $0x35001, %eax # imm = 0x35001
jmp 0x145f1
movl $0x35002, %eax # imm = 0x35002
movl %eax, 0x218(%rbx)
leaq 0xcb72(%rip), %rdi # 0x21170
callq *0x258(%rbx)
movl $0x4000, %edi # imm = 0x4000
callq *%rax
movq %rbx, %rdi
callq *0x240(%rbx)
movl $0x1, %ebx
jmp 0x1432c
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/context.c
|
glfwExtensionSupported
|
GLFWAPI int glfwExtensionSupported(const char* extension)
{
_GLFWwindow* window;
assert(extension != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
window = _glfwPlatformGetCurrentContext();
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
return GLFW_FALSE;
}
if (*extension == '\0')
{
_glfwInputError(GLFW_INVALID_VALUE, "Extension name is 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 0x1473c
leaq 0x1a533(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x146b4
movq %rdi, %rbx
callq 0x1e42e
testq %rax, %rax
je 0x146be
cmpb $0x0, (%rbx)
je 0x146dd
movq %rax, %r14
cmpl $0x3, 0x1f8(%rax)
jl 0x146ee
leaq 0x4(%rsp), %r15
movl $0x821d, %edi # imm = 0x821D
movq %r15, %rsi
callq *0x228(%r14)
cmpl $0x0, (%r15)
jle 0x14714
xorl %ebp, %ebp
movl $0x1f03, %edi # imm = 0x1F03
movl %ebp, %esi
callq *0x220(%r14)
testq %rax, %rax
je 0x14723
movq %rax, %rdi
movq %rbx, %rsi
callq 0x10720
testl %eax, %eax
je 0x14734
incl %ebp
cmpl 0x4(%rsp), %ebp
jl 0x14680
jmp 0x14714
xorl %r15d, %r15d
movl $0x10001, %edi # imm = 0x10001
jmp 0x146c6
xorl %r15d, %r15d
movl $0x10002, %edi # imm = 0x10002
xorl %esi, %esi
xorl %eax, %eax
callq 0x14954
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf7c5(%rip), %rsi # 0x23ea9
xorl %r15d, %r15d
movl $0x10004, %edi # imm = 0x10004
jmp 0x146c8
movl $0x1f03, %edi # imm = 0x1F03
callq *0x230(%r14)
testq %rax, %rax
je 0x14723
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1475b
movl $0x1, %r15d
testl %eax, %eax
jne 0x146cf
movq %rbx, %rdi
callq *0x250(%r14)
movl %eax, %r15d
jmp 0x146cf
leaq 0xf79e(%rip), %rsi # 0x23ec8
xorl %r15d, %r15d
movl $0x10008, %edi # imm = 0x10008
jmp 0x146c8
movl $0x1, %r15d
jmp 0x146cf
leaq 0xf72b(%rip), %rdi # 0x23e6e
leaq 0xf694(%rip), %rsi # 0x23dde
leaq 0xf72f(%rip), %rcx # 0x23e80
movl $0x282, %edx # imm = 0x282
callq 0x10210
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/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 0x10590
xorl %ebx, %ebx
testq %rax, %rax
je 0x147bf
movq %rax, %r13
movq %r14, %rdi
callq 0x10460
movq %rax, %r12
movq %r15, %rax
leaq (%r12,%r13), %r15
cmpq %rax, %r13
je 0x1479d
cmpb $0x20, -0x1(%r13)
jne 0x147a5
movzbl (%r15), %eax
testb $-0x21, %al
je 0x147ba
movq %r15, %rdi
movq %r14, %rsi
callq 0x10590
movq %rax, %r13
testq %rax, %rax
jne 0x1478a
jmp 0x147bf
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/context.c
|
glfwMakeContextCurrent
|
GLFWAPI void glfwMakeContextCurrent(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFWwindow* previous = _glfwPlatformGetCurrentContext();
_GLFW_REQUIRE_INIT();
if (window && window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return;
}
if (previous)
{
if (!window || window->context.source != previous->context.source)
previous->context.makeCurrent(NULL);
}
if (window)
window->context.makeCurrent(window);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0x1e42e
leaq 0x1a38d(%rip), %rcx # 0x2eb68
cmpl $0x0, (%rcx)
je 0x1481c
testq %rbx, %rbx
je 0x14823
movq %rbx, %rdx
cmpl $0x0, 0x1f0(%rbx)
je 0x14831
testq %rax, %rax
je 0x14812
movl 0x1f4(%rdx), %ecx
cmpl 0x1f4(%rax), %ecx
je 0x14812
xorl %edi, %edi
movq %rdx, %rbx
callq *0x238(%rax)
movq %rbx, %rdx
movq %rdx, %rdi
popq %rbx
jmpq *0x238(%rdx)
movl $0x10001, %edi # imm = 0x10001
jmp 0x14836
testq %rax, %rax
je 0x14840
xorl %edi, %edi
popq %rbx
jmpq *0x238(%rax)
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
popq %rbx
jmp 0x14954
popq %rbx
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/context.c
|
glfwSwapInterval
|
GLFWAPI void glfwSwapInterval(int interval)
{
_GLFWwindow* window;
_GLFW_REQUIRE_INIT();
window = _glfwPlatformGetCurrentContext();
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
return;
}
window->context.swapInterval(interval);
}
|
pushq %rbx
leaq 0x1a2a6(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x148dc
movl %edi, %ebx
callq 0x1e42e
testq %rax, %rax
je 0x148e3
movl %ebx, %edi
popq %rbx
jmpq *0x248(%rax)
movl $0x10001, %edi # imm = 0x10001
jmp 0x148e8
movl $0x10002, %edi # imm = 0x10002
xorl %esi, %esi
xorl %eax, %eax
popq %rbx
jmp 0x14954
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/context.c
|
glfwGetProcAddress
|
GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname)
{
_GLFWwindow* window;
assert(procname != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
window = _glfwPlatformGetCurrentContext();
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
return NULL;
}
return window->context.getProcAddress(procname);
}
|
pushq %rbx
testq %rdi, %rdi
je 0x14934
leaq 0x1a269(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x1491b
movq %rdi, %rbx
callq 0x1e42e
testq %rax, %rax
je 0x14922
movq %rbx, %rdi
popq %rbx
jmpq *0x258(%rax)
movl $0x10001, %edi # imm = 0x10001
jmp 0x14927
movl $0x10002, %edi # imm = 0x10002
xorl %esi, %esi
xorl %eax, %eax
callq 0x14954
xorl %eax, %eax
popq %rbx
retq
leaq 0xf5b2(%rip), %rdi # 0x23eed
leaq 0xf49c(%rip), %rsi # 0x23dde
leaq 0xf5b5(%rip), %rcx # 0x23efe
movl $0x2c3, %edx # imm = 0x2C3
callq 0x10210
nop
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/context.c
|
glfwInputError
|
void _glfwInputError(int error, const char* format, ...)
{
if (_glfwErrorCallback)
{
char buffer[8192];
const char* description;
if (format)
{
int count;
va_list vl;
va_start(vl, format);
count = vsnprintf(buffer, sizeof(buffer), format, vl);
va_end(vl);
if (count < 0)
buffer[sizeof(buffer) - 1] = '\0';
description = buffer;
}
else
description = getErrorString(error);
_glfwErrorCallback(error, description);
}
}
|
pushq %r14
pushq %rbx
subq $0x20d8, %rsp # imm = 0x20D8
testb %al, %al
je 0x14999
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)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
movq 0x1a1bc(%rip), %rax # 0x2eb70
testq %rax, %rax
je 0x14a1a
movq %rsi, %r10
movl %edi, %ebx
testq %rsi, %rsi
je 0x14a25
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x20f0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rcx)
leaq 0xd0(%rsp), %r14
movl $0x2000, %esi # imm = 0x2000
movq %r14, %rdi
movq %r10, %rdx
callq 0x10630
testl %eax, %eax
jns 0x14a0c
movb $0x0, 0x20cf(%rsp)
movq 0x1a15d(%rip), %rax # 0x2eb70
movl %ebx, %edi
movq %r14, %rsi
callq *%rax
addq $0x20d8, %rsp # imm = 0x20D8
popq %rbx
popq %r14
retq
leal -0x10001(%rbx), %ecx
cmpl $0x9, %ecx
ja 0x14a91
leaq 0xf4f5(%rip), %rdx # 0x23f2c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0xf50d(%rip), %r14 # 0x23f54
jmp 0x14a13
leaq 0xf584(%rip), %r14 # 0x23fd4
jmp 0x14a13
leaq 0xf61a(%rip), %r14 # 0x24073
jmp 0x14a13
leaq 0xf532(%rip), %r14 # 0x23f94
jmp 0x14a13
leaq 0xf54d(%rip), %r14 # 0x23fb8
jmp 0x14a13
leaq 0xf5b8(%rip), %r14 # 0x2402c
jmp 0x14a13
leaq 0xf4fb(%rip), %r14 # 0x23f78
jmp 0x14a13
leaq 0xf55c(%rip), %r14 # 0x23fe2
jmp 0x14a13
leaq 0xf574(%rip), %r14 # 0x24003
jmp 0x14a13
leaq 0xf5ff(%rip), %r14 # 0x24097
jmp 0x14a13
leaq 0xf5ab(%rip), %r14 # 0x2404f
jmp 0x14a13
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/init.c
|
glfwInit
|
GLFWAPI int glfwInit(void)
{
if (_glfwInitialized)
return GLFW_TRUE;
memset(&_glfw, 0, sizeof(_glfw));
if (!_glfwPlatformInit())
{
_glfwPlatformTerminate();
return GLFW_FALSE;
}
_glfw.monitors = _glfwPlatformGetMonitors(&_glfw.monitorCount);
_glfwInitialized = GLFW_TRUE;
_glfw.timerOffset = _glfwPlatformGetTimerValue();
// Not all window hints have zero as their default value
glfwDefaultWindowHints();
return GLFW_TRUE;
}
|
pushq %r15
pushq %r14
pushq %rbx
leaq 0x1a0b3(%rip), %r15 # 0x2eb68
movl $0x1, %ebx
cmpl $0x0, (%r15)
jne 0x14b18
leaq 0x1a0b1(%rip), %r14 # 0x2eb78
xorl %ebx, %ebx
movl $0xdb8, %edx # imm = 0xDB8
movq %r14, %rdi
xorl %esi, %esi
callq 0x10110
callq 0x18157
testl %eax, %eax
je 0x14b13
leaq 0xc8(%r14), %rdi
callq 0x19ed8
movq %rax, 0xc0(%r14)
movl $0x1, (%r15)
callq 0x1e359
movq %rax, 0xd0(%r14)
callq 0x17071
movl $0x1, %ebx
jmp 0x14b18
callq 0x199b3
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/init.c
|
glfwTerminate
|
GLFWAPI void glfwTerminate(void)
{
int i;
if (!_glfwInitialized)
return;
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);
}
_glfwTerminateVulkan();
_glfwFreeMonitors(_glfw.monitors, _glfw.monitorCount);
_glfw.monitors = NULL;
_glfw.monitorCount = 0;
_glfwPlatformTerminate();
memset(&_glfw, 0, sizeof(_glfw));
_glfwInitialized = GLFW_FALSE;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x1a03a(%rip), %r14 # 0x2eb68
cmpl $0x0, (%r14)
je 0x14bed
xorps %xmm0, %xmm0
leaq 0x1a036(%rip), %rbx # 0x2eb78
movups %xmm0, 0x120(%rbx)
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x14b61
callq 0x16fc5
jmp 0x14b49
callq 0x153eb
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
jne 0x14b5c
movl 0xc8(%rbx), %eax
testl %eax, %eax
jle 0x14bac
movq 0xc0(%rbx), %rcx
xorl %r15d, %r15d
movq (%rcx,%r15,8), %rdi
cmpl $0x0, 0x58(%rdi)
je 0x14ba1
leaq 0x40(%rdi), %rsi
callq 0x1a538
movq 0xc0(%rbx), %rcx
movl 0xc8(%rbx), %eax
incq %r15
movslq %eax, %rdx
cmpq %rdx, %r15
jl 0x14b81
callq 0x168b2
movq 0xc0(%rbx), %rdi
movl 0xc8(%rbx), %esi
callq 0x15dfd
movq $0x0, 0xc0(%rbx)
xorl %ebp, %ebp
movl %ebp, 0xc8(%rbx)
callq 0x199b3
movl $0xdb8, %edx # imm = 0xDB8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10110
movl %ebp, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/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 0x14c03
movl $0x3, (%rdi)
testq %rsi, %rsi
je 0x14c0e
movl $0x2, (%rsi)
testq %rdx, %rdx
je 0x14c19
movl $0x1, (%rdx)
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/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->callbacks.key)
window->callbacks.key((GLFWwindow*) window, key, scancode, action, mods);
}
|
cmpl $0x15c, %esi # imm = 0x15C
ja 0x14c6e
movl %esi, %eax
cmpl $0x1, %ecx
je 0x14c57
testl %ecx, %ecx
jne 0x14c6a
cmpb $0x0, 0x7c(%rdi,%rax)
je 0x14c81
cmpl $0x0, 0x68(%rdi)
je 0x14c82
movb $0x3, 0x7c(%rdi,%rax)
jmp 0x14c6e
cmpb $0x1, 0x7c(%rdi,%rax)
movb $0x1, 0x7c(%rdi,%rax)
movl $0x2, %eax
jne 0x14c6e
jmp 0x14c70
movb %cl, 0x7c(%rdi,%rax)
movl %ecx, %eax
movq 0x2f0(%rdi), %r9
testq %r9, %r9
je 0x14c81
movl %eax, %ecx
jmpq *%r9
retq
movb $0x0, 0x7c(%rdi,%rax)
jmp 0x14c6e
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/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->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 0x14cd5
movq %rdi, %r14
movq 0x300(%rdi), %rax
testq %rax, %rax
je 0x14cba
movq %r14, %rdi
movl %ebx, %esi
callq *%rax
testl %ebp, %ebp
je 0x14cd5
movq 0x2f8(%r14), %rax
testq %rax, %rax
je 0x14cd5
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
popq %rbx
popq %r14
popq %rbp
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/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 0x14d35
jp 0x14d35
movsd 0x1e8(%rdi), %xmm2
ucomisd %xmm1, %xmm2
jne 0x14d35
jnp 0x14d53
movsd %xmm0, 0x1e0(%rdi)
movsd %xmm1, 0x1e8(%rdi)
movq 0x2d8(%rdi), %rax
testq %rax, %rax
je 0x14d53
jmpq *%rax
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/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;
default:
_glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode %i", mode);
return 0;
}
}
|
pushq %rbx
testq %rdi, %rdi
je 0x14e14
leaq 0x19dad(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x14ddf
movl %esi, %edx
cmpl $0x33003, %esi # imm = 0x33003
je 0x14df6
cmpl $0x33002, %edx # imm = 0x33002
je 0x14df1
cmpl $0x33001, %edx # imm = 0x33001
jne 0x14dfb
movl 0x70(%rdi), %ebx
jmp 0x14e10
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x14954
jmp 0x14e10
movl 0x68(%rdi), %ebx
jmp 0x14e10
movl 0x6c(%rdi), %ebx
jmp 0x14e10
leaq 0xf411(%rip), %rsi # 0x24213
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x14954
movl %ebx, %eax
popq %rbx
retq
leaq 0xefb4(%rip), %rdi # 0x23dcf
leaq 0xf35e(%rip), %rsi # 0x24180
leaq 0xf3c2(%rip), %rcx # 0x241eb
movl $0x99, %edx
callq 0x10210
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/input.c
|
glfwSetInputMode
|
GLFWAPI void glfwSetInputMode(GLFWwindow* handle, int mode, int value)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
switch (mode)
{
case GLFW_CURSOR:
{
if (value != GLFW_CURSOR_NORMAL &&
value != GLFW_CURSOR_HIDDEN &&
value != GLFW_CURSOR_DISABLED)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid cursor mode %i",
value);
return;
}
if (window->cursorMode == value)
return;
window->cursorMode = value;
_glfwPlatformGetCursorPos(window,
&window->virtualCursorPosX,
&window->virtualCursorPosY);
if (_glfwPlatformWindowFocused(window))
_glfwPlatformSetCursorMode(window, value);
return;
}
case GLFW_STICKY_KEYS:
{
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 ? GLFW_TRUE : GLFW_FALSE;
return;
}
case GLFW_STICKY_MOUSE_BUTTONS:
{
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 ? GLFW_TRUE : GLFW_FALSE;
return;
}
}
_glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode %i", mode);
}
|
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x15088
leaq 0x19d21(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x14e95
movl %edx, %ebx
movl %esi, %edx
movq %rdi, %r14
cmpl $0x33003, %esi # imm = 0x33003
je 0x14ee4
cmpl $0x33002, %edx # imm = 0x33002
je 0x14eaa
cmpl $0x33001, %edx # imm = 0x33001
jne 0x15029
leal -0x34004(%rbx), %eax
cmpl $-0x4, %eax
ja 0x15043
leaq 0xf3ce(%rip), %rsi # 0x24257
movl $0x10003, %edi # imm = 0x10003
movl %ebx, %edx
jmp 0x15035
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14954
cmpl %ebx, 0x68(%r14)
je 0x15080
testl %ebx, %ebx
jne 0x14ed4
movl $0x7c, %eax
cmpb $0x3, (%r14,%rax)
jne 0x14ec9
movb $0x0, (%r14,%rax)
incq %rax
cmpq $0x1d9, %rax # imm = 0x1D9
jne 0x14ebd
xorl %eax, %eax
testl %ebx, %ebx
setne %al
movl %eax, 0x68(%r14)
jmp 0x15080
cmpl %ebx, 0x6c(%r14)
je 0x15080
testl %ebx, %ebx
jne 0x1501c
movq 0x74(%r14), %xmm0
movdqa 0xf1bc(%rip), %xmm1 # 0x240c0
pcmpeqb %xmm0, %xmm1
movd %xmm1, %eax
testb $0x1, %al
je 0x14f15
movb $0x0, 0x74(%r14)
movdqa 0xf1b3(%rip), %xmm1 # 0x240d0
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, %eax
shrl $0x10, %eax
testb $0x1, %al
je 0x14f3e
movb $0x0, 0x75(%r14)
movdqa 0xf19a(%rip), %xmm1 # 0x240e0
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, %eax
testb $0x1, %al
je 0x14f61
movb $0x0, 0x76(%r14)
movdqa 0xf187(%rip), %xmm1 # 0x240f0
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, %eax
testb $0x1, %al
je 0x14f88
movb $0x0, 0x77(%r14)
movdqa 0xf170(%rip), %xmm1 # 0x24100
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, %eax
testb $0x1, %al
je 0x14fab
movb $0x0, 0x78(%r14)
movdqa 0xf15d(%rip), %xmm1 # 0x24110
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, %eax
testb $0x1, %al
je 0x14fd2
movb $0x0, 0x79(%r14)
movdqa 0xf146(%rip), %xmm1 # 0x24120
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, %eax
testb $0x1, %al
je 0x14ff9
movb $0x0, 0x7a(%r14)
movdqa 0xf12f(%rip), %xmm1 # 0x24130
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, %eax
testb $0x1, %al
je 0x1501c
movb $0x0, 0x7b(%r14)
xorl %eax, %eax
testl %ebx, %ebx
setne %al
movl %eax, 0x6c(%r14)
jmp 0x15080
leaq 0xf1e3(%rip), %rsi # 0x24213
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14954
cmpl %ebx, 0x70(%r14)
je 0x15080
movl %ebx, 0x70(%r14)
leaq 0x1e0(%r14), %rsi
leaq 0x1e8(%r14), %rdx
movq %r14, %rdi
callq 0x1cfee
movq %r14, %rdi
callq 0x1c1d6
testl %eax, %eax
je 0x15080
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1d0dc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xed40(%rip), %rdi # 0x23dcf
leaq 0xf0ea(%rip), %rsi # 0x24180
leaq 0xf18c(%rip), %rcx # 0x24229
movl $0xae, %edx
callq 0x10210
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/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 0x1512e
leaq 0x19a91(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x15102
movl %esi, %edx
leal -0x15d(%rdx), %eax
cmpl $0xfffffec2, %eax # imm = 0xFFFFFEC2
ja 0x15114
leaq 0xf19e(%rip), %rsi # 0x24290
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x14954
jmp 0x1512a
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x14954
jmp 0x1512a
movl %edx, %eax
movsbl 0x7c(%rdi,%rax), %ebx
cmpl $0x3, %ebx
jne 0x1512a
movb $0x0, 0x7c(%rdi,%rax)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
leaq 0xec9a(%rip), %rdi # 0x23dcf
leaq 0xf044(%rip), %rsi # 0x24180
leaq 0xf12b(%rip), %rcx # 0x2426e
movl $0x106, %edx # imm = 0x106
callq 0x10210
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/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 0x19772(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x1545f
movq %rdi, %rbx
testq %rdi, %rdi
je 0x15474
leaq 0x1976e(%rip), %rax # 0x2eb78
movq 0xb8(%rax), %r14
testq %r14, %r14
je 0x1542b
cmpq %rbx, 0x48(%r14)
jne 0x15426
movq %r14, %rdi
xorl %esi, %esi
callq 0x15515
movq (%r14), %r14
jmp 0x15411
movq %rbx, %rdi
callq 0x1d32c
movl $0xb0, %eax
addq 0x17ba1(%rip), %rax # 0x2cfe0
movq %rax, %rcx
movq (%rax), %rax
cmpq %rbx, %rax
jne 0x1543f
movq (%rbx), %rax
movq %rax, (%rcx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10430
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14954
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/input.c
|
glfwGetJoystickAxes
|
GLFWAPI const float* glfwGetJoystickAxes(int joy, int* count)
{
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick %i", joy);
return NULL;
}
return _glfwPlatformGetJoystickAxes(joy, count);
}
|
pushq %rax
testq %rsi, %rsi
je 0x1589e
movl $0x0, (%rsi)
leaq 0x19305(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x15884
movl %edi, %edx
cmpl $0x10, %edi
jb 0x15896
leaq 0xeda7(%rip), %rsi # 0x2461d
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x14954
jmp 0x15892
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x14954
xorl %eax, %eax
popq %rcx
retq
movl %edx, %edi
popq %rax
jmp 0x1e261
leaq 0xed8c(%rip), %rdi # 0x24631
leaq 0xe8d4(%rip), %rsi # 0x24180
leaq 0xed8c(%rip), %rcx # 0x2463f
movl $0x22e, %edx # imm = 0x22E
callq 0x10210
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/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.timerOffset = _glfwPlatformGetTimerValue() -
(uint64_t) (time * _glfwPlatformGetTimerFrequency());
}
|
leaq 0x19077(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x15b8b
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x15b99
ucomisd 0xe660(%rip), %xmm0 # 0x24170
ja 0x15b99
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
callq 0x1e359
movq %rax, %rbx
callq 0x1e3a5
movq %rax, %xmm0
punpckldq 0xe605(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xe60d(%rip), %xmm0 # 0x24150
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x8(%rsp), %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rcx
subsd 0xe613(%rip), %xmm1 # 0x24178
sarq $0x3f, %rcx
cvttsd2si %xmm1, %rdx
andq %rcx, %rdx
orq %rax, %rdx
subq %rdx, %rbx
leaq 0x18ffa(%rip), %rax # 0x2eb78
movq %rbx, 0xd0(%rax)
addq $0x10, %rsp
popq %rbx
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x14954
leaq 0xeb7c(%rip), %rsi # 0x2471c
movl $0x10004, %edi # imm = 0x10004
movb $0x1, %al
jmp 0x14954
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/input.c
|
glfwFreeMonitor
|
void _glfwFreeMonitor(_GLFWmonitor* monitor)
{
if (monitor == NULL)
return;
_glfwFreeGammaArrays(&monitor->originalRamp);
_glfwFreeGammaArrays(&monitor->currentRamp);
free(monitor->modes);
free(monitor->name);
free(monitor);
}
|
testq %rdi, %rdi
je 0x15dfc
pushq %rbx
movq %rdi, %rbx
addq $0x40, %rdi
callq 0x15e73
leaq 0x60(%rbx), %rdi
callq 0x15e73
movq 0x18(%rbx), %rdi
callq 0x10430
movq (%rbx), %rdi
callq 0x10430
movq %rbx, %rdi
popq %rbx
jmp 0x10430
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/monitor.c
|
refreshVideoModes
|
static GLFWbool refreshVideoModes(_GLFWmonitor* monitor)
{
int modeCount;
GLFWvidmode* modes;
if (monitor->modes)
return GLFW_TRUE;
modes = _glfwPlatformGetVideoModes(monitor, &modeCount);
if (!modes)
return GLFW_FALSE;
qsort(modes, modeCount, sizeof(GLFWvidmode), compareVideoModes);
free(monitor->modes);
monitor->modes = modes;
monitor->modeCount = modeCount;
return GLFW_TRUE;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x1, %ebx
cmpq $0x0, 0x18(%rdi)
jne 0x1606a
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
callq 0x1a263
testq %rax, %rax
je 0x16068
movq %rax, %r15
movslq 0xc(%rsp), %rsi
leaq 0x34(%rip), %rcx # 0x16078
movl $0x18, %edx
movq %rax, %rdi
callq 0x10690
movq 0x18(%r14), %rdi
callq 0x10430
movq %r15, 0x18(%r14)
movl 0xc(%rsp), %eax
movl %eax, 0x20(%r14)
jmp 0x1606a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/monitor.c
|
glfwGetMonitorPos
|
GLFWAPI void glfwGetMonitorPos(GLFWmonitor* handle, int* xpos, int* ypos)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
if (xpos)
*xpos = 0;
if (ypos)
*ypos = 0;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetMonitorPos(monitor, xpos, ypos);
}
|
testq %rdi, %rdi
je 0x161c0
testq %rsi, %rsi
je 0x16196
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x161a1
movl $0x0, (%rdx)
leaq 0x189c0(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x161b2
jmp 0x1a1d1
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x14954
pushq %rax
leaq 0xe612(%rip), %rdi # 0x247da
leaq 0xe579(%rip), %rsi # 0x24748
leaq 0xe614(%rip), %rcx # 0x247ea
movl $0x148, %edx # imm = 0x148
callq 0x10210
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/monitor.c
|
glfwGetVideoModes
|
GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* handle, int* count)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (!refreshVideoModes(monitor))
return NULL;
*count = monitor->modeCount;
return monitor->modes;
}
|
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16329
movq %rsi, %r14
testq %rsi, %rsi
je 0x16348
movl $0x0, (%r14)
leaq 0x1887b(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x1630a
movq %rdi, %rbx
callq 0x1600e
testl %eax, %eax
je 0x1631c
movl 0x20(%rbx), %eax
movl %eax, (%r14)
movq 0x18(%rbx), %rbx
jmp 0x1631e
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x14954
jmp 0x1631e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xe4aa(%rip), %rdi # 0x247da
leaq 0xe411(%rip), %rsi # 0x24748
leaq 0xe54b(%rip), %rcx # 0x24889
movl $0x179, %edx # imm = 0x179
callq 0x10210
leaq 0xe2e2(%rip), %rdi # 0x24631
leaq 0xe3f2(%rip), %rsi # 0x24748
leaq 0xe52c(%rip), %rcx # 0x24889
movl $0x17a, %edx # imm = 0x17A
callq 0x10210
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/monitor.c
|
glfwSetWindowSize
|
GLFWAPI void glfwSetWindowSize(GLFWwindow* handle, int width, int height)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
window->videoMode.width = width;
window->videoMode.height = height;
_glfwPlatformSetWindowSize(window, width, height);
}
|
testq %rdi, %rdi
je 0x1760a
leaq 0x1757c(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x175fc
movl %esi, 0x28(%rdi)
movl %edx, 0x2c(%rdi)
jmp 0x1b6cc
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x14954
pushq %rax
leaq 0xc7bd(%rip), %rdi # 0x23dcf
leaq 0xdc5d(%rip), %rsi # 0x25276
leaq 0xdeca(%rip), %rcx # 0x254ea
movl $0x1ee, %edx # imm = 0x1EE
callq 0x10210
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/window.c
|
glfwSetWindowSizeLimits
|
GLFWAPI void glfwSetWindowSizeLimits(GLFWwindow* handle,
int minwidth, int minheight,
int maxwidth, int maxheight)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (minwidth != GLFW_DONT_CARE && minheight != GLFW_DONT_CARE)
{
if (minwidth < 0 || minheight < 0)
{
_glfwInputError(GLFW_INVALID_VALUE,
"Invalid window minimum size %ix%i",
minwidth, minheight);
return;
}
}
if (maxwidth != GLFW_DONT_CARE && maxheight != GLFW_DONT_CARE)
{
if (maxwidth < 0 || maxheight < 0 ||
maxwidth < minwidth || maxheight < minheight)
{
_glfwInputError(GLFW_INVALID_VALUE,
"Invalid window maximum size %ix%i",
maxwidth, maxheight);
return;
}
}
window->minwidth = minwidth;
window->minheight = minheight;
window->maxwidth = maxwidth;
window->maxheight = maxheight;
if (window->monitor || !window->resizable)
return;
_glfwPlatformSetWindowSizeLimits(window,
minwidth, minheight,
maxwidth, maxheight);
}
|
testq %rdi, %rdi
je 0x176df
movl %edx, %eax
movl %esi, %edx
leaq 0x1752a(%rip), %rsi # 0x2eb68
cmpl $0x0, (%rsi)
je 0x1769a
cmpl $-0x1, %edx
sete %sil
cmpl $-0x1, %eax
sete %r9b
orb %sil, %r9b
movl %eax, %esi
orl %edx, %esi
setns %sil
orb %r9b, %sil
je 0x176a8
cmpl $-0x1, %ecx
sete %sil
cmpl $-0x1, %r8d
sete %r9b
orb %sil, %r9b
jne 0x17685
cmpl %eax, %r8d
jl 0x176cc
cmpl %edx, %ecx
jl 0x176cc
movl %r8d, %esi
orl %ecx, %esi
js 0x176cc
movl %edx, 0x50(%rdi)
movl %eax, 0x54(%rdi)
movl %ecx, 0x58(%rdi)
movl %r8d, 0x5c(%rdi)
cmpq $0x0, 0x40(%rdi)
je 0x176bd
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x14954
leaq 0xdea9(%rip), %rsi # 0x25558
movl $0x10004, %edi # imm = 0x10004
movl %eax, %ecx
xorl %eax, %eax
jmp 0x14954
cmpl $0x0, 0x8(%rdi)
je 0x17699
movl %edx, %esi
movl %eax, %edx
jmp 0x1b829
leaq 0xdea7(%rip), %rsi # 0x2557a
movl $0x10004, %edi # imm = 0x10004
movl %ecx, %edx
movl %r8d, %ecx
jmp 0x176b6
pushq %rax
leaq 0xc6e8(%rip), %rdi # 0x23dcf
leaq 0xdb88(%rip), %rsi # 0x25276
leaq 0xde24(%rip), %rcx # 0x25519
movl $0x1fd, %edx # imm = 0x1FD
callq 0x10210
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/window.c
|
glfwSetWindowAspectRatio
|
GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow* handle, int numer, int denom)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (numer != GLFW_DONT_CARE && denom != GLFW_DONT_CARE)
{
if (numer <= 0 || denom <= 0)
{
_glfwInputError(GLFW_INVALID_VALUE,
"Invalid window aspect ratio %i:%i",
numer, denom);
return;
}
}
window->numer = numer;
window->denom = denom;
if (window->monitor || !window->resizable)
return;
_glfwPlatformSetWindowAspectRatio(window, numer, denom);
}
|
testq %rdi, %rdi
je 0x17774
leaq 0x1745d(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x17757
movl %edx, %ecx
movl %esi, %edx
cmpl $-0x1, %esi
sete %al
cmpl $-0x1, %ecx
sete %sil
orb %al, %sil
jne 0x17749
testl %edx, %edx
setg %al
testl %ecx, %ecx
setg %sil
testb %sil, %al
jne 0x17749
leaq 0xde95(%rip), %rsi # 0x255d2
movl $0x10004, %edi # imm = 0x10004
xorl %eax, %eax
jmp 0x14954
movl %edx, 0x60(%rdi)
movl %ecx, 0x64(%rdi)
cmpq $0x0, 0x40(%rdi)
je 0x17765
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x14954
cmpl $0x0, 0x8(%rdi)
je 0x17756
movl %edx, %esi
movl %ecx, %edx
jmp 0x1b883
pushq %rax
leaq 0xc653(%rip), %rdi # 0x23dcf
leaq 0xdaf3(%rip), %rsi # 0x25276
leaq 0xde12(%rip), %rcx # 0x2559c
movl $0x228, %edx # imm = 0x228
callq 0x10210
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/window.c
|
glfwGetFramebufferSize
|
GLFWAPI void glfwGetFramebufferSize(GLFWwindow* handle, int* width, int* height)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (width)
*width = 0;
if (height)
*height = 0;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetFramebufferSize(window, width, height);
}
|
testq %rdi, %rdi
je 0x177ce
testq %rsi, %rsi
je 0x177a4
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x177af
movl $0x0, (%rdx)
leaq 0x173b2(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x177c0
jmp 0x1b8dd
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x14954
pushq %rax
leaq 0xc5f9(%rip), %rdi # 0x23dcf
leaq 0xda99(%rip), %rsi # 0x25276
leaq 0xde10(%rip), %rcx # 0x255f4
movl $0x243, %edx # imm = 0x243
callq 0x10210
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/window.c
|
glfwGetWindowFrameSize
|
GLFWAPI void glfwGetWindowFrameSize(GLFWwindow* handle,
int* left, int* top,
int* right, int* bottom)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (left)
*left = 0;
if (top)
*top = 0;
if (right)
*right = 0;
if (bottom)
*bottom = 0;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetWindowFrameSize(window, left, top, right, bottom);
}
|
testq %rdi, %rdi
je 0x1783f
testq %rsi, %rsi
je 0x177fe
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x17809
movl $0x0, (%rdx)
testq %rcx, %rcx
je 0x17814
movl $0x0, (%rcx)
testq %r8, %r8
je 0x17820
movl $0x0, (%r8)
leaq 0x17341(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x17831
jmp 0x1b8e2
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x14954
pushq %rax
leaq 0xc588(%rip), %rdi # 0x23dcf
leaq 0xda28(%rip), %rsi # 0x25276
leaq 0xddd7(%rip), %rcx # 0x2562c
movl $0x253, %edx # imm = 0x253
callq 0x10210
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/window.c
|
glfwShowWindow
|
GLFWAPI void glfwShowWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->monitor)
return;
_glfwPlatformShowWindow(window);
_glfwPlatformFocusWindow(window);
}
|
pushq %rbx
testq %rdi, %rdi
je 0x17969
leaq 0x17230(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x17949
movq %rdi, %rbx
cmpq $0x0, 0x40(%rdi)
je 0x17958
popq %rbx
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
popq %rbx
jmp 0x14954
movq %rbx, %rdi
callq 0x1ac27
movq %rbx, %rdi
popq %rbx
jmp 0x1bfeb
leaq 0xc45f(%rip), %rdi # 0x23dcf
leaq 0xd8ff(%rip), %rsi # 0x25276
leaq 0xdd64(%rip), %rcx # 0x256e2
movl $0x280, %edx # imm = 0x280
callq 0x10210
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/window.c
|
glfwGetWindowAttrib
|
GLFWAPI int glfwGetWindowAttrib(GLFWwindow* handle, int attrib)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(0);
switch (attrib)
{
case GLFW_FOCUSED:
return _glfwPlatformWindowFocused(window);
case GLFW_ICONIFIED:
return _glfwPlatformWindowIconified(window);
case GLFW_VISIBLE:
return _glfwPlatformWindowVisible(window);
case GLFW_MAXIMIZED:
return _glfwPlatformWindowMaximized(window);
case GLFW_RESIZABLE:
return window->resizable;
case GLFW_DECORATED:
return window->decorated;
case GLFW_FLOATING:
return window->floating;
case GLFW_CLIENT_API:
return window->context.client;
case GLFW_CONTEXT_CREATION_API:
return window->context.source;
case GLFW_CONTEXT_VERSION_MAJOR:
return window->context.major;
case GLFW_CONTEXT_VERSION_MINOR:
return window->context.minor;
case GLFW_CONTEXT_REVISION:
return window->context.revision;
case GLFW_CONTEXT_ROBUSTNESS:
return window->context.robustness;
case GLFW_OPENGL_FORWARD_COMPAT:
return window->context.forward;
case GLFW_OPENGL_DEBUG_CONTEXT:
return window->context.debug;
case GLFW_OPENGL_PROFILE:
return window->context.profile;
case GLFW_CONTEXT_RELEASE_BEHAVIOR:
return window->context.release;
case GLFW_CONTEXT_NO_ERROR:
return window->context.noerror;
}
_glfwInputError(GLFW_INVALID_ENUM, "Invalid window attribute %i", attrib);
return 0;
}
|
pushq %rbx
testq %rdi, %rdi
je 0x17b22
leaq 0x17140(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x17a52
movl %esi, %edx
leal -0x22001(%rdx), %eax
cmpl $0xa, %eax
ja 0x17a66
leaq 0xd7fb(%rip), %rcx # 0x2523c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x1f0(%rdi), %ebx
jmp 0x17a62
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x14954
movl %ebx, %eax
popq %rbx
retq
leal -0x20001(%rdx), %eax
cmpl $0x7, %eax
ja 0x17b08
leaq 0xd7a0(%rip), %rcx # 0x2521c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
popq %rbx
jmp 0x1c1d6
popq %rbx
jmp 0x1b63b
movl 0x8(%rdi), %ebx
jmp 0x17a62
popq %rbx
jmp 0x1be6f
movl 0xc(%rdi), %ebx
jmp 0x17a62
movl 0x14(%rdi), %ebx
jmp 0x17a62
popq %rbx
jmp 0x1c25a
movl 0x214(%rdi), %ebx
jmp 0x17a62
movl 0x20c(%rdi), %ebx
jmp 0x17a62
movl 0x1fc(%rdi), %ebx
jmp 0x17a62
movl 0x200(%rdi), %ebx
jmp 0x17a62
movl 0x210(%rdi), %ebx
jmp 0x17a62
movl 0x1f8(%rdi), %ebx
jmp 0x17a62
movl 0x204(%rdi), %ebx
jmp 0x17a62
movl 0x208(%rdi), %ebx
jmp 0x17a62
movl 0x1f4(%rdi), %ebx
jmp 0x17a62
movl 0x218(%rdi), %ebx
jmp 0x17a62
leaq 0xdc65(%rip), %rsi # 0x25774
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x14954
jmp 0x17a62
leaq 0xc2a6(%rip), %rdi # 0x23dcf
leaq 0xd746(%rip), %rsi # 0x25276
leaq 0xdc12(%rip), %rcx # 0x25749
movl $0x2a5, %edx # imm = 0x2A5
callq 0x10210
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/window.c
|
glfwSetWindowMonitor
|
GLFWAPI void glfwSetWindowMonitor(GLFWwindow* wh,
GLFWmonitor* mh,
int xpos, int ypos,
int width, int height,
int refreshRate)
{
_GLFWwindow* window = (_GLFWwindow*) wh;
_GLFWmonitor* monitor = (_GLFWmonitor*) mh;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (width <= 0 || height <= 0)
{
_glfwInputError(GLFW_INVALID_VALUE,
"Invalid window size %ix%i",
width, height);
return;
}
if (refreshRate < 0 && refreshRate != GLFW_DONT_CARE)
{
_glfwInputError(GLFW_INVALID_VALUE,
"Invalid refresh rate %i",
refreshRate);
return;
}
window->videoMode.width = width;
window->videoMode.height = height;
window->videoMode.refreshRate = refreshRate;
_glfwPlatformSetWindowMonitor(window, monitor,
xpos, ypos, width, height,
refreshRate);
}
|
pushq %rax
testq %rdi, %rdi
je 0x17c0b
leaq 0x16fce(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x17bcc
testl %r8d, %r8d
setg %al
testl %r9d, %r9d
setg %r10b
testb %r10b, %al
jne 0x17bdb
leaq 0xd77c(%rip), %rsi # 0x25334
movl $0x10004, %edi # imm = 0x10004
movl %r8d, %edx
movl %r9d, %ecx
xorl %eax, %eax
popq %r8
jmp 0x14954
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
popq %rcx
jmp 0x14954
movl 0x10(%rsp), %eax
cmpl $-0x2, %eax
jg 0x17bfa
leaq 0xdc25(%rip), %rsi # 0x25810
movl $0x10004, %edi # imm = 0x10004
movl %eax, %edx
xorl %eax, %eax
popq %rcx
jmp 0x14954
movl %r8d, 0x28(%rdi)
movl %r9d, 0x2c(%rdi)
movl %eax, 0x3c(%rdi)
popq %rax
jmp 0x1c0bd
leaq 0xc1bd(%rip), %rdi # 0x23dcf
leaq 0xd65d(%rip), %rsi # 0x25276
leaq 0xdba0(%rip), %rcx # 0x257c0
movl $0x2e6, %edx # imm = 0x2E6
callq 0x10210
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/window.c
|
glfwPlatformGetVideoMode
|
void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRScreenResources* sr;
XRRCrtcInfo* ci;
sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
*mode = vidmodeFromModeInfo(getModeInfo(sr, ci->mode), ci);
XRRFreeCrtcInfo(ci);
XRRFreeScreenResources(sr);
}
else
{
mode->width = DisplayWidth(_glfw.x11.display, _glfw.x11.screen);
mode->height = DisplayHeight(_glfw.x11.display, _glfw.x11.screen);
mode->refreshRate = 0;
_glfwSplitBPP(DefaultDepth(_glfw.x11.display, _glfw.x11.screen),
&mode->redBits, &mode->greenBits, &mode->blueBits);
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x14f17(%rip), %r12 # 0x2eb78
cmpl $0x0, 0x7c8(%r12)
movq 0x130(%r12), %rdi
je 0x19d0e
cmpl $0x0, 0x7e0(%r12)
jne 0x19d0e
movq 0x140(%r12), %rsi
callq 0x10a00
movq %rax, %r14
movq 0x130(%r12), %rdi
movq 0x88(%r15), %rdx
movq %rax, %rsi
callq 0x10860
movq %rax, %r15
movslq 0x30(%r14), %rax
testq %rax, %rax
jle 0x19cd0
movq 0x18(%r15), %rcx
movq 0x38(%r14), %rsi
cmpq %rcx, (%rsi)
je 0x19cd2
addq $0x50, %rsi
decq %rax
jne 0x19cc2
xorl %esi, %esi
movl 0x20(%r15), %edx
movq %rsp, %r12
movq %r12, %rdi
callq 0x19d53
movq 0x10(%r12), %rax
movq %rax, 0x10(%rbx)
movups (%r12), %xmm0
movups %xmm0, (%rbx)
movq %r15, %rdi
callq 0x10120
movq %r14, %rdi
callq 0x100b0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xe8(%rdi), %rax
movslq 0x138(%r12), %rcx
shlq $0x7, %rcx
movq 0x18(%rax,%rcx), %rdx
movq %rdx, (%rbx)
movl $0x0, 0x14(%rbx)
movl 0x38(%rax,%rcx), %edi
leaq 0x8(%rbx), %rsi
leaq 0xc(%rbx), %rdx
addq $0x10, %rbx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x160a5
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_monitor.c
|
glfwPlatformSetWindowIcon
|
void _glfwPlatformSetWindowIcon(_GLFWwindow* window,
int count, const GLFWimage* images)
{
if (count)
{
int i, j, longCount = 0;
for (i = 0; i < count; i++)
longCount += 2 + images[i].width * images[i].height;
long* icon = calloc(longCount, sizeof(long));
long* target = icon;
for (i = 0; i < count; i++)
{
*target++ = images[i].width;
*target++ = images[i].height;
for (j = 0; j < images[i].width * images[i].height; j++)
{
*target++ = (images[i].pixels[j * 4 + 0] << 16) |
(images[i].pixels[j * 4 + 1] << 8) |
(images[i].pixels[j * 4 + 2] << 0) |
(images[i].pixels[j * 4 + 3] << 24);
}
}
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_ICON,
XA_CARDINAL, 32,
PropModeReplace,
(unsigned char*) icon,
longCount);
free(icon);
}
else
{
XDeleteProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_ICON);
}
XFlush(_glfw.x11.display);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x1b476
jle 0x1b499
movq %rdx, %r14
movl %esi, %ebp
movl %esi, %r13d
movq %r13, %rax
shlq $0x4, %rax
xorl %ecx, %ecx
xorl %r12d, %r12d
movl 0x4(%r14,%rcx), %edx
imull (%r14,%rcx), %edx
addl %edx, %r12d
addl $0x2, %r12d
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x1b3c3
movslq %r12d, %rdi
movl $0x8, %esi
callq 0x107f0
movq %rax, %r15
testl %ebp, %ebp
jle 0x1b4ab
xorl %eax, %eax
movq %r15, %rcx
movq %rax, %rdx
shlq $0x4, %rdx
movslq (%r14,%rdx), %rdi
movq %rdi, (%rcx)
movslq 0x4(%r14,%rdx), %rsi
movq %rsi, 0x8(%rcx)
addq $0x10, %rcx
imull %edi, %esi
testl %esi, %esi
jle 0x1b46c
addq %r14, %rdx
movq 0x8(%rdx), %rdx
movl %esi, %esi
xorl %edi, %edi
xorl %r8d, %r8d
movzbl (%rdx,%r8,4), %r9d
shll $0x10, %r9d
movzbl 0x1(%rdx,%r8,4), %r10d
shll $0x8, %r10d
orl %r9d, %r10d
movzbl 0x2(%rdx,%r8,4), %r9d
orl %r10d, %r9d
movzbl 0x3(%rdx,%r8,4), %r10d
shll $0x18, %r10d
orl %r9d, %r10d
movslq %r10d, %r9
movq %r9, (%rcx,%r8,8)
incq %r8
addq $-0x8, %rdi
cmpq %r8, %rsi
jne 0x1b42a
subq %rdi, %rcx
incq %rax
cmpq %r13, %rax
jne 0x1b3fa
jmp 0x1b4ab
leaq 0x136fb(%rip), %rax # 0x2eb78
movq 0x130(%rax), %rdi
movq 0x318(%rbx), %rsi
movq 0x6b0(%rax), %rdx
callq 0x10440
jmp 0x1b4ea
xorl %r12d, %r12d
movl $0x8, %esi
xorl %edi, %edi
callq 0x107f0
movq %rax, %r15
leaq 0x136c6(%rip), %rax # 0x2eb78
movq 0x130(%rax), %rdi
movq 0x318(%rbx), %rsi
movq 0x6b0(%rax), %rdx
movl $0x6, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r12
pushq %r15
callq 0x108e0
addq $0x10, %rsp
movq %r15, %rdi
callq 0x10430
leaq 0x13687(%rip), %rax # 0x2eb78
movq 0x130(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10680
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c
|
glfwPlatformSetWindowPos
|
void _glfwPlatformSetWindowPos(_GLFWwindow* window, int xpos, int ypos)
{
// HACK: Explicitly setting PPosition to any value causes some WMs, notably
// Compiz and Metacity, to honor the position of unmapped windows
if (!_glfwPlatformWindowVisible(window))
{
long supplied;
XSizeHints* hints = XAllocSizeHints();
if (XGetWMNormalHints(_glfw.x11.display, window->x11.handle, hints, &supplied))
{
hints->flags |= PPosition;
hints->x = hints->y = 0;
XSetWMNormalHints(_glfw.x11.display, window->x11.handle, hints);
}
XFree(hints);
}
XMoveWindow(_glfw.x11.display, window->x11.handle, xpos, ypos);
XFlush(_glfw.x11.display);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x135e8(%rip), %r12 # 0x2eb78
movq 0x130(%r12), %rdi
movq 0x318(%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x108b0
cmpl $0x2, 0x5c(%r15)
je 0x1b606
callq 0x108f0
movq %rax, %r15
movq 0x130(%r12), %rdi
movq 0x318(%r14), %rsi
leaq 0x8(%rsp), %rcx
movq %rax, %rdx
callq 0x101b0
testl %eax, %eax
je 0x1b5fe
orb $0x4, (%r15)
movq $0x0, 0x8(%r15)
movq 0x130(%r12), %rdi
movq 0x318(%r14), %rsi
movq %r15, %rdx
callq 0x102f0
movq %r15, %rdi
callq 0x10080
movq 0x130(%r12), %rdi
movq 0x318(%r14), %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x100c0
movq 0x130(%r12), %rdi
callq 0x10680
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c
|
glfwPlatformSetWindowSizeLimits
|
void _glfwPlatformSetWindowSizeLimits(_GLFWwindow* window,
int minwidth, int minheight,
int maxwidth, int maxheight)
{
int width, height;
_glfwPlatformGetWindowSize(window, &width, &height);
updateNormalHints(window, width, height);
XFlush(_glfw.x11.display);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x13339(%rip), %r15 # 0x2eb78
movq 0x130(%r15), %rdi
movq 0x318(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0x108b0
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
movq %rbx, %rdi
callq 0x1b738
movq 0x130(%r15), %rdi
callq 0x10680
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c
|
isFrameExtentsEvent
|
static Bool isFrameExtentsEvent(Display* display, XEvent* event, XPointer pointer)
{
_GLFWwindow* window = (_GLFWwindow*) pointer;
return event->type == PropertyNotify &&
event->xproperty.state == PropertyNewValue &&
event->xproperty.window == window->x11.handle &&
event->xproperty.atom == _glfw.x11.NET_FRAME_EXTENTS;
}
|
xorl %eax, %eax
cmpl $0x1c, (%rsi)
jne 0x1bac7
cmpl $0x0, 0x38(%rsi)
je 0x1bac8
retq
movq 0x20(%rsi), %rcx
cmpq 0x318(%rdx), %rcx
jne 0x1bac7
movq 0x28(%rsi), %rcx
leaq 0x13098(%rip), %rdx # 0x2eb78
xorl %eax, %eax
cmpq 0x718(%rdx), %rcx
sete %al
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c
|
glfwPlatformIconifyWindow
|
void _glfwPlatformIconifyWindow(_GLFWwindow* window)
{
if (window->x11.overrideRedirect)
{
// Override-redirect windows cannot be iconified or restored, as those
// tasks are performed by the window manager
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Iconification of full screen windows requires a WM that supports EWMH full screen");
return;
}
XIconifyWindow(_glfw.x11.display, window->x11.handle, _glfw.x11.screen);
XFlush(_glfw.x11.display);
}
|
cmpl $0x0, 0x328(%rdi)
je 0x1bcf8
leaq 0xa82d(%rip), %rsi # 0x26519
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
jmp 0x14954
pushq %rbx
leaq 0x12e78(%rip), %rbx # 0x2eb78
movq 0x130(%rbx), %rax
movq 0x318(%rdi), %rsi
movl 0x138(%rbx), %edx
movq %rax, %rdi
callq 0x10350
movq 0x130(%rbx), %rdi
popq %rbx
jmp 0x10680
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c
|
glfwPlatformRestoreWindow
|
void _glfwPlatformRestoreWindow(_GLFWwindow* window)
{
if (window->x11.overrideRedirect)
{
// Override-redirect windows cannot be iconified or restored, as those
// tasks are performed by the window manager
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Iconification of full screen windows requires a WM that supports EWMH full screen");
return;
}
if (_glfwPlatformWindowIconified(window))
{
XMapWindow(_glfw.x11.display, window->x11.handle);
waitForVisibilityNotify(window);
}
else if (_glfwPlatformWindowVisible(window))
{
if (_glfw.x11.NET_WM_STATE &&
_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT &&
_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
{
sendEventToWM(window,
_glfw.x11.NET_WM_STATE,
_NET_WM_STATE_REMOVE,
_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT,
_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ,
1, 0);
}
}
XFlush(_glfw.x11.display);
}
|
cmpl $0x0, 0x328(%rdi)
je 0x1bd45
leaq 0xa7e0(%rip), %rsi # 0x26519
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
jmp 0x14954
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movq 0x318(%rdi), %rdi
callq 0x1c217
cmpl $0x3, %eax
jne 0x1bd91
leaq 0x12e07(%rip), %rax # 0x2eb78
movq 0x130(%rax), %rdi
movq 0x318(%rbx), %rsi
callq 0x105e0
movq %rbx, %rdi
callq 0x1be88
jmp 0x1be4a
leaq 0x12de0(%rip), %r15 # 0x2eb78
movq 0x130(%r15), %rdi
movq 0x318(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0x108b0
cmpl $0x2, 0x5c(%r14)
jne 0x1be4a
movq 0x6d8(%r15), %r14
movq 0x6f0(%r15), %r12
testq %r14, %r14
setne %al
testq %r12, %r12
setne %cl
andb %al, %cl
movq 0x6f8(%r15), %r13
testq %r13, %r13
setne %al
andb %cl, %al
cmpb $0x1, %al
jne 0x1be4a
movq 0x318(%rbx), %rbp
leaq 0x8(%rsp), %rbx
movl $0xc0, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10110
movl $0x21, (%rbx)
movq %rbp, 0x20(%rbx)
movl $0x20, 0x30(%rbx)
movq %r14, 0x28(%rbx)
movq %r12, 0x40(%rbx)
movq %r13, 0x48(%rbx)
movq $0x1, 0x50(%rbx)
movq 0x130(%r15), %rdi
movq 0x140(%r15), %rsi
movl $0x180000, %ecx # imm = 0x180000
xorl %edx, %edx
movq %rbx, %r8
callq 0x106f0
leaq 0x12d27(%rip), %rax # 0x2eb78
movq 0x130(%rax), %rdi
callq 0x10680
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c
|
glfwPlatformWindowMaximized
|
int _glfwPlatformWindowMaximized(_GLFWwindow* window)
{
Atom* states;
unsigned long i;
GLFWbool maximized = GLFW_FALSE;
const unsigned long count =
_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.NET_WM_STATE,
XA_ATOM,
(unsigned char**) &states);
for (i = 0; i < count; i++)
{
if (states[i] == _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT ||
states[i] == _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
{
maximized = GLFW_TRUE;
break;
}
}
XFree(states);
return maximized;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq 0x318(%rdi), %rdi
leaq 0x1290c(%rip), %r14 # 0x2eb78
movq 0x6d8(%r14), %rsi
movq %rsp, %rbx
movl $0x4, %edx
movq %rbx, %rcx
callq 0x1a66c
movq (%rbx), %rdi
testq %rax, %rax
je 0x1c2b6
movq 0x6f0(%r14), %rcx
movq 0x6f8(%r14), %rdx
xorl %esi, %esi
movl $0x1, %ebx
movq (%rdi,%rsi,8), %r8
cmpq %rcx, %r8
je 0x1c2b8
cmpq %rdx, %r8
je 0x1c2b8
incq %rsi
cmpq %rsi, %rax
jne 0x1c2a0
xorl %ebx, %ebx
callq 0x10080
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c
|
glfwPlatformPollEvents
|
void _glfwPlatformPollEvents(void)
{
_glfwPollJoystickEvents();
int count = XPending(_glfw.x11.display);
while (count--)
{
XEvent event;
XNextEvent(_glfw.x11.display, &event);
processEvent(&event);
}
if (_glfw.x11.disabledCursorWindow)
centerCursor(_glfw.x11.disabledCursorWindow);
XFlush(_glfw.x11.display);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
callq 0x1e071
leaq 0x12894(%rip), %r14 # 0x2eb78
movq 0x130(%r14), %rdi
callq 0x10a20
testl %eax, %eax
je 0x1cec3
movl %eax, %ebx
leaq 0x30(%rsp), %r13
movq 0x130(%r14), %rdi
movq %r13, %rsi
callq 0x10560
movl 0x30(%rsp), %eax
movl %eax, %ecx
andl $-0x2, %ecx
movl $0x0, %r12d
cmpl $0x2, %ecx
jne 0x1c32a
movl 0x84(%rsp), %r12d
cmpq $0x0, 0x158(%r14)
je 0x1c34a
movq %r13, %rdi
xorl %esi, %esi
callq 0x10410
testl %eax, %eax
sete %r15b
movl 0x30(%rsp), %eax
jmp 0x1c34d
movb $0x1, %r15b
cmpl $0x0, 0x7c8(%r14)
je 0x1c373
movl 0x7cc(%r14), %ecx
incl %ecx
cmpl %ecx, %eax
jne 0x1c373
movq %r13, %rdi
callq 0x106c0
callq 0x15bf4
jmp 0x1c3af
cmpl $0x23, %eax
je 0x1c3af
movq 0x50(%rsp), %rsi
movq 0x130(%r14), %rdi
movl 0x150(%r14), %edx
leaq 0xf0(%rsp), %rcx
callq 0x10390
testl %eax, %eax
setne %al
movq 0xf0(%rsp), %rbp
testq %rbp, %rbp
sete %cl
orb %al, %cl
je 0x1c3c1
decl %ebx
leaq 0x30(%rsp), %r13
jne 0x1c2ff
jmp 0x1cec3
movl 0x30(%rsp), %eax
addl $-0x2, %eax
cmpl $0x1f, %eax
ja 0x1c3af
leaq 0xa00c(%rip), %rcx # 0x263e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
cmpl $0xff, %r12d
ja 0x1c3f7
movl %r12d, %eax
movswl 0x1b0(%r14,%rax,2), %esi
movl 0x80(%rsp), %r13d
movl %r13d, %eax
andl $0x1, %eax
movl %r13d, %ecx
shrl %ecx
andl $0x6, %ecx
shrl $0x3, %r13d
andl $0x8, %r13d
orl %eax, %r13d
orl %ecx, %r13d
xorl %eax, %eax
testl %ecx, %ecx
sete %al
movl %eax, (%rsp)
cmpq $0x0, 0x320(%rbp)
je 0x1ca2b
cmpl %r12d, 0x34c(%rbp)
jne 0x1cb2b
movq 0x350(%rbp), %rax
cmpq 0x68(%rsp), %rax
setne %al
testl %r12d, %r12d
setne %cl
testb %cl, %al
jne 0x1cb30
jmp 0x1cb43
leaq 0x30(%rsp), %rdi
callq 0x1d8ef
jmp 0x1c3af
movl 0x68(%rsp), %esi
movl 0x6c(%rsp), %edx
cmpl 0x32c(%rbp), %esi
jne 0x1c489
cmpl 0x330(%rbp), %edx
je 0x1c4ad
movq %rbp, %rdi
callq 0x16d38
movl 0x68(%rsp), %esi
movl 0x6c(%rsp), %edx
movq %rbp, %rdi
callq 0x16d1a
movq 0x68(%rsp), %rax
movq %rax, 0x32c(%rbp)
movl 0x60(%rsp), %esi
cmpl 0x334(%rbp), %esi
jne 0x1c4c9
movl 0x64(%rsp), %eax
cmpl 0x338(%rbp), %eax
je 0x1c3af
movl 0x40(%rsp), %eax
orl 0x328(%rbp), %eax
je 0x1c3af
movl 0x64(%rsp), %edx
movq %rbp, %rdi
callq 0x16d0b
movq 0x60(%rsp), %rax
movq %rax, 0x334(%rbp)
jmp 0x1c3af
movq 0x168(%r14), %rdi
callq 0x10430
movq $0x0, 0x168(%r14)
jmp 0x1c3af
movl 0x80(%rsp), %ecx
movl 0x84(%rsp), %esi
movl %ecx, %eax
andl $0x1, %eax
movl %ecx, %edx
shrl %edx
andl $0x6, %edx
orl %eax, %edx
shrl $0x3, %ecx
andl $0x8, %ecx
orl %edx, %ecx
leal -0x1(%rsi), %eax
cmpl $0x6, %eax
ja 0x1cc68
leaq 0x9f17(%rip), %rdx # 0x26460
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq %rbp, %rdi
xorl %esi, %esi
jmp 0x1cc78
cmpl $0x34002, 0x70(%rbp) # imm = 0x34002
jne 0x1c572
movq %rbp, %rdi
movl $0x34002, %esi # imm = 0x34002
callq 0x1d0dc
movq %rbp, %rdi
movl $0x1, %esi
jmp 0x1c63f
movq 0x58(%rsp), %rax
cmpq 0x690(%r14), %rax
jne 0x1c3af
cmpl $0x0, 0x68(%rsp)
jne 0x1c3af
movq 0x318(%rbp), %rdi
callq 0x1c217
cmpl $0x1, %eax
je 0x1cbcc
cmpl $0x3, %eax
jne 0x1c3af
cmpq $0x0, 0x40(%rbp)
je 0x1c5c9
movq %rbp, %rdi
callq 0x1b240
movq %rbp, %rdi
movl $0x1, %esi
jmp 0x1cbe0
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
cmpl $0xff, %r12d
ja 0x1c5f1
movl %r12d, %eax
movswl 0x1b0(%r14,%rax,2), %r15d
movl 0x80(%rsp), %r13d
cmpl $0x0, 0x7e8(%r14)
je 0x1ca88
movl %r13d, %eax
andl $0x1, %eax
movl %r13d, %ecx
shrl %ecx
andl $0x6, %ecx
orl %eax, %ecx
shrl $0x3, %r13d
andl $0x8, %r13d
orl %ecx, %r13d
movq %rbp, %rdi
movl %r15d, %esi
movl %r12d, %edx
xorl %ecx, %ecx
movl %r13d, %r8d
callq 0x14c30
jmp 0x1c3af
movq %rbp, %rdi
xorl %esi, %esi
callq 0x14d54
jmp 0x1c3af
cmpl $0x34003, 0x70(%rbp) # imm = 0x34003
jne 0x1c65f
movq %rbp, %rdi
movl $0x34003, %esi # imm = 0x34003
callq 0x1d0dc
movl 0x58(%rsp), %eax
decl %eax
cmpl $0x2, %eax
jb 0x1c3af
movq 0x320(%rbp), %rdi
testq %rdi, %rdi
je 0x1c67f
callq 0x10700
movq %rbp, %rdi
movl $0x1, %esi
jmp 0x1c942
movq 0x68(%rsp), %rsi
testq %rsi, %rsi
je 0x1c3af
movq 0x50(%rsp), %rdi
movq 0x60(%rsp), %rdx
leaq 0x8(%rsp), %rcx
callq 0x1a66c
movq %rax, %r12
testl %r12d, %r12d
je 0x1c989
movq %r12, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq $0x0, (%rsp)
xorl %r12d, %r12d
leaq 0xa19f(%rip), %r13 # 0x2687e
movq %r13, %rsi
callq 0x10790
testq %rax, %rax
je 0x1c94c
movq %rax, %r15
cmpb $0x23, (%rax)
movl $0x0, %edi
je 0x1c6df
movl $0x7, %edx
movq %r15, %rdi
leaq 0xa16a(%rip), %rsi # 0x26876
callq 0x102a0
leaq 0x7(%r15), %r13
testl %eax, %eax
cmovneq %r15, %r13
movq (%rsp), %rax
incq %rax
movq %rax, 0x10(%rsp)
movq %r13, %rdi
callq 0x10460
leaq 0x1(%rax), %rdi
movl $0x1, %esi
callq 0x107f0
movq %rax, %r15
movq (%rsp), %rax
leaq 0x8(,%rax,8), %rsi
movq %r12, %rdi
callq 0x10950
movq %rax, %r12
movq (%rsp), %rax
movq %r15, (%r12,%rax,8)
leaq 0xf0(%rsp), %rdi
movzbl (%r13), %eax
cmpl $0x25, %eax
je 0x1c777
testl %eax, %eax
jne 0x1c7ba
jmp 0x1c7c5
movb 0x1(%r13), %cl
testb %cl, %cl
je 0x1c7ba
movb 0x2(%r13), %dl
testb %dl, %dl
je 0x1c7ba
addq $0x2, %r13
movb %cl, 0xf0(%rsp)
movb %dl, 0xf1(%rsp)
movb $0x0, 0xf2(%rsp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x105c0
leaq 0xf0(%rsp), %rdi
movb %al, (%r15)
jmp 0x1c7bd
movb %al, (%r15)
incq %r15
incq %r13
jmp 0x1c767
movq 0x18(%rsp), %rax
incl %eax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
xorl %edi, %edi
jmp 0x1c6d8
testb %r15b, %r15b
je 0x1c3af
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0x1c3af
cmpq 0x688(%r14), %rax
jne 0x1cbea
movq 0x68(%rsp), %rax
testq %rax, %rax
je 0x1c3af
cmpq 0x698(%r14), %rax
jne 0x1cda0
movq %rbp, %rdi
callq 0x16d56
jmp 0x1c3af
movl 0x80(%rsp), %ecx
movl 0x84(%rsp), %esi
movl %ecx, %eax
andl $0x1, %eax
movl %ecx, %edx
shrl %edx
andl $0x6, %edx
orl %eax, %edx
shrl $0x3, %ecx
andl $0x8, %ecx
orl %edx, %ecx
cmpl $0x3, %esi
je 0x1cbac
cmpl $0x2, %esi
je 0x1cba2
cmpl $0x1, %esi
jne 0x1cbb6
movq %rbp, %rdi
xorl %esi, %esi
jmp 0x1cbc5
movl 0x70(%rsp), %r15d
movl 0x74(%rsp), %r12d
cmpl 0x344(%rbp), %r15d
jne 0x1c896
cmpl 0x348(%rbp), %r12d
je 0x1cb18
cmpl $0x34003, 0x70(%rbp) # imm = 0x34003
jne 0x1cb00
cmpq %rbp, 0x680(%r14)
jne 0x1c3af
movl %r15d, %eax
subl 0x33c(%rbp), %eax
movl %r12d, %ecx
subl 0x340(%rbp), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
addsd 0x1e0(%rbp), %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
addsd 0x1e8(%rbp), %xmm1
jmp 0x1cb10
movq %rbp, %rdi
callq 0x16d47
jmp 0x1c3af
cmpl $0x34003, 0x70(%rbp) # imm = 0x34003
jne 0x1c908
movq %rbp, %rdi
movl $0x34001, %esi # imm = 0x34001
callq 0x1d0dc
movl 0x58(%rsp), %eax
decl %eax
cmpl $0x2, %eax
jb 0x1c3af
movq 0x320(%rbp), %rdi
testq %rdi, %rdi
je 0x1c928
callq 0x104d0
cmpq $0x0, 0x40(%rbp)
je 0x1c93d
cmpl $0x0, 0x10(%rbp)
je 0x1c93d
movq %rbp, %rdi
callq 0x1bcdc
movq %rbp, %rdi
xorl %esi, %esi
callq 0x16c88
jmp 0x1c3af
movq %rbp, %rdi
movq (%rsp), %r15
movl %r15d, %esi
movq %r12, %rdx
callq 0x14d63
testq %r15, %r15
je 0x1c97c
movl 0x18(%rsp), %r15d
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
callq 0x10430
incq %r13
cmpq %r13, %r15
jne 0x1c96b
movq %r12, %rdi
callq 0x10430
movq 0x20(%rsp), %r12
movq 0x8(%rsp), %rdi
callq 0x10080
movl $0xc0, %edx
leaq 0xf0(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x10110
movl $0x21, 0xf0(%rsp)
movq 0x818(%r14), %rsi
movq %rsi, 0x110(%rsp)
movq 0x768(%r14), %rax
movq %rax, 0x118(%rsp)
movl $0x20, 0x120(%rsp)
movq 0x318(%rbp), %rax
movq %rax, 0x128(%rsp)
movslq %r12d, %rax
movq %rax, 0x130(%rsp)
movq 0x750(%r14), %rax
movq %rax, 0x138(%rsp)
movq 0x130(%r14), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r15, %r8
callq 0x106f0
movq 0x130(%r14), %rdi
callq 0x10680
jmp 0x1c3af
leaq 0x30(%rsp), %rdi
movl %esi, %r15d
xorl %esi, %esi
xorl %edx, %edx
leaq 0xf0(%rsp), %rcx
xorl %r8d, %r8d
callq 0x101d0
movq %rbp, %rdi
movl %r15d, %esi
movl %r12d, %edx
movl $0x1, %ecx
movl %r13d, %r8d
callq 0x14c30
movl 0xf0(%rsp), %edi
callq 0x1dbb0
cmpq $-0x1, %rax
je 0x1c3af
movq %rbp, %rdi
movl %eax, %esi
movl %r13d, %edx
movl (%rsp), %ecx
callq 0x14c89
jmp 0x1c3af
movq 0x130(%r14), %rdi
movl $0x1, %esi
callq 0x109d0
testl %eax, %eax
je 0x1c607
movq 0x130(%r14), %rdi
leaq 0xf0(%rsp), %rsi
callq 0x10760
cmpl $0x2, 0xf0(%rsp)
jne 0x1c607
movq 0x110(%rsp), %rax
cmpq 0x50(%rsp), %rax
jne 0x1c607
cmpl %r12d, 0x144(%rsp)
jne 0x1c607
movq 0x128(%rsp), %rax
subq 0x68(%rsp), %rax
cmpq $0x14, %rax
jb 0x1c3af
jmp 0x1c607
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r12d, %xmm1
movq %rbp, %rdi
callq 0x14d15
movl %r15d, 0x33c(%rbp)
movl %r12d, 0x340(%rbp)
jmp 0x1c3af
testl %r12d, %r12d
je 0x1cb43
movq %rbp, %rdi
movl %r12d, %edx
movl $0x1, %ecx
movl %r13d, %r8d
callq 0x14c30
movl %r12d, 0x34c(%rbp)
movq 0x68(%rsp), %rax
movq %rax, 0x350(%rbp)
testb %r15b, %r15b
je 0x1c3af
movq 0x320(%rbp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0xf0(%rsp), %r15
movq %r15, %rdx
movl $0x63, %ecx
xorl %r8d, %r8d
leaq 0x8(%rsp), %r9
callq 0x104a0
movl %eax, %r12d
movl 0x8(%rsp), %eax
cmpl $-0x1, %eax
je 0x1ccb1
movq %r15, 0x10(%rsp)
jmp 0x1ccee
movq %rbp, %rdi
movl $0x2, %esi
jmp 0x1cbc5
movq %rbp, %rdi
movl $0x1, %esi
jmp 0x1cbc5
cmpl $0x8, %esi
jb 0x1c3af
addl $-0x5, %esi
movq %rbp, %rdi
xorl %edx, %edx
jmp 0x1cc7d
cmpq $0x0, 0x40(%rbp)
je 0x1cbdb
movq %rbp, %rdi
callq 0x1af2b
movq %rbp, %rdi
xorl %esi, %esi
callq 0x16d29
jmp 0x1c3af
cmpq 0x738(%r14), %rax
je 0x1c3af
cmpq 0x758(%r14), %rax
jne 0x1cdf1
movq 0x68(%rsp), %rax
movq %rax, 0x818(%r14)
movq 0x130(%r14), %rdi
movq 0x770(%r14), %rcx
movq 0x7a8(%r14), %rdx
movq 0x318(%rbp), %r8
movq %rcx, %rsi
xorl %r9d, %r9d
callq 0x10260
jmp 0x1c3af
xorpd %xmm0, %xmm0
movq %rbp, %rdi
movsd 0x43c5(%rip), %xmm1 # 0x21010
jmp 0x1cca7
movq %rbp, %rdi
movl $0x1, %esi
jmp 0x1cc78
xorpd %xmm0, %xmm0
movq %rbp, %rdi
movsd 0x43a2(%rip), %xmm1 # 0x21008
jmp 0x1cca7
addl $-0x5, %esi
movq %rbp, %rdi
jmp 0x1cc78
movq %rbp, %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x14ce9
jmp 0x1c3af
xorpd %xmm1, %xmm1
movq %rbp, %rdi
movsd 0x4372(%rip), %xmm0 # 0x21008
jmp 0x1cca7
xorpd %xmm1, %xmm1
movq %rbp, %rdi
movsd 0x4369(%rip), %xmm0 # 0x21010
callq 0x14cda
jmp 0x1c3af
movl %r12d, %eax
incl %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x107f0
movq 0x320(%rbp), %rdi
leaq 0x30(%rsp), %rsi
movq %rax, 0x10(%rsp)
movq %rax, %rdx
movl %r12d, %ecx
xorl %r8d, %r8d
leaq 0x8(%rsp), %r9
callq 0x104a0
movl %eax, %r12d
movl 0x8(%rsp), %eax
cmpl $0x4, %eax
je 0x1ccfc
cmpl $0x2, %eax
jne 0x1cd80
movslq %r12d, %rcx
movq 0x10(%rsp), %rax
movb $0x0, (%rax,%rcx)
movq %rcx, 0x18(%rsp)
testl %ecx, %ecx
jle 0x1cd80
movq 0x10(%rsp), %r15
movq %r15, %rax
negq %rax
movq %rax, 0x20(%rsp)
movb (%r15), %cl
movq 0x20(%rsp), %rax
leaq (%rax,%r15), %r12
xorl %esi, %esi
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movl %esi, %edx
shll $0x6, %edx
movzbl %cl, %esi
addl %edx, %esi
movb 0x1(%r15), %cl
incq %r15
movl %ecx, %edx
andb $-0x40, %dl
incq %r12
incl %eax
negb %dl
jo 0x1cd34
leal 0x1(%rax), %ecx
cmpl $0x7, %ecx
jae 0x1cef2
movl %eax, %eax
leaq 0x9718(%rip), %rcx # 0x26480
subl (%rcx,%rax,4), %esi
movq %rbp, %rdi
movl %r13d, %edx
movl (%rsp), %ecx
callq 0x14c89
cmpq 0x18(%rsp), %r12
jl 0x1cd21
leaq 0xf0(%rsp), %rax
movq 0x10(%rsp), %rdi
cmpq %rax, %rdi
je 0x1c3af
callq 0x10430
jmp 0x1c3af
cmpq 0x6c0(%r14), %rax
jne 0x1c3af
movl $0xc0, %edx
leaq 0xf0(%rsp), %r15
movq %r15, %rdi
leaq 0x30(%rsp), %rsi
callq 0x109b0
movq 0x130(%r14), %rdi
movq 0x140(%r14), %rsi
movq %rsi, 0x110(%rsp)
movl $0x180000, %ecx # imm = 0x180000
xorl %edx, %edx
movq %r15, %r8
callq 0x106f0
jmp 0x1c3af
cmpq 0x740(%r14), %rax
jne 0x1c3af
movl 0x78(%rsp), %eax
movzwl %ax, %r15d
movl %eax, %r12d
shrl $0x10, %r12d
movq %rbp, %rdi
leaq 0x8(%rsp), %rsi
leaq 0x2c(%rsp), %rdx
callq 0x1b50b
subl 0x8(%rsp), %r12d
cvtsi2sd %r12d, %xmm0
subl 0x2c(%rsp), %r15d
cvtsi2sd %r15d, %xmm1
movq %rbp, %rdi
callq 0x14d15
movl $0xc0, %edx
leaq 0xf0(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x10110
movl $0x21, 0xf0(%rsp)
movq 0x68(%rsp), %rsi
movq %rsi, 0x110(%rsp)
movq 0x748(%r14), %rax
movq %rax, 0x118(%rsp)
movl $0x20, 0x120(%rsp)
movq 0x318(%rbp), %rax
movq %rax, 0x128(%rsp)
movq $0x1, 0x130(%rsp)
leaq 0x138(%rsp), %rax
xorpd %xmm0, %xmm0
movupd %xmm0, (%rax)
movq 0x750(%r14), %rax
movq %rax, 0x148(%rsp)
jmp 0x1ca07
movq 0x680(%r14), %rdi
testq %rdi, %rdi
je 0x1ced4
callq 0x1b01c
movq 0x130(%r14), %rdi
callq 0x10680
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x98db(%rip), %rdi # 0x267d4
leaq 0x98df(%rip), %rsi # 0x267df
leaq 0x9948(%rip), %rcx # 0x2684f
movl $0x3b1, %edx # imm = 0x3B1
callq 0x10210
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c
|
glfwPlatformGetCursorPos
|
void _glfwPlatformGetCursorPos(_GLFWwindow* window, double* xpos, double* ypos)
{
Window root, child;
int rootX, rootY, childX, childY;
unsigned int mask;
XQueryPointer(_glfw.x11.display, window->x11.handle,
&root, &child,
&rootX, &rootY, &childX, &childY,
&mask);
if (xpos)
*xpos = childX;
if (ypos)
*ypos = childY;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x11b74(%rip), %rax # 0x2eb78
movq 0x130(%rax), %rax
movq 0x318(%rdi), %rsi
subq $0x8, %rsp
leaq 0x1c(%rsp), %r10
leaq 0x14(%rsp), %r11
leaq 0x18(%rsp), %r15
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x24(%rsp), %r8
leaq 0x20(%rsp), %r9
movq %rax, %rdi
pushq %r10
pushq %r11
pushq %r15
callq 0x10830
addq $0x20, %rsp
testq %r14, %r14
je 0x1d05b
cvtsi2sdl 0x10(%rsp), %xmm0
movsd %xmm0, (%r14)
testq %rbx, %rbx
je 0x1d06d
xorps %xmm0, %xmm0
cvtsi2sdl 0xc(%rsp), %xmm0
movsd %xmm0, (%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c
|
glfwPlatformSetCursorMode
|
void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
{
if (mode == GLFW_CURSOR_DISABLED)
{
_glfw.x11.disabledCursorWindow = window;
_glfwPlatformGetCursorPos(window,
&_glfw.x11.restoreCursorPosX,
&_glfw.x11.restoreCursorPosY);
centerCursor(window);
XGrabPointer(_glfw.x11.display, window->x11.handle, True,
ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
GrabModeAsync, GrabModeAsync,
window->x11.handle, _glfw.x11.cursor, CurrentTime);
}
else if (_glfw.x11.disabledCursorWindow == window)
{
_glfw.x11.disabledCursorWindow = NULL;
XUngrabPointer(_glfw.x11.display, CurrentTime);
_glfwPlatformSetCursorPos(window,
_glfw.x11.restoreCursorPosX,
_glfw.x11.restoreCursorPosY);
}
updateCursorImage(window);
XFlush(_glfw.x11.display);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x11a8e(%rip), %r14 # 0x2eb78
cmpl $0x34003, %esi # imm = 0x34003
jne 0x1d154
movq %rbx, 0x680(%r14)
leaq 0x670(%r14), %rsi
leaq 0x678(%r14), %rdx
movq %rbx, %rdi
callq 0x1cfee
movq %rbx, %rdi
callq 0x1b01c
movq 0x318(%rbx), %rsi
movq 0x130(%r14), %rdi
subq $0x8, %rsp
movl $0x1, %edx
movl $0x4c, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
pushq $0x0
pushq 0x148(%r14)
pushq %rsi
callq 0x10310
addq $0x20, %rsp
jmp 0x1d190
cmpq %rbx, 0x680(%r14)
jne 0x1d190
movq $0x0, 0x680(%r14)
movq 0x130(%r14), %rdi
xorl %esi, %esi
callq 0x10270
movsd 0x670(%r14), %xmm0
movsd 0x678(%r14), %xmm1
movq %rbx, %rdi
callq 0x1d077
movq %rbx, %rdi
callq 0x1d1b2
leaq 0x119d9(%rip), %rax # 0x2eb78
movq 0x130(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10680
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c
|
glfwPlatformGetKeyName
|
const char* _glfwPlatformGetKeyName(int key, int scancode)
{
KeySym keysym;
int extra;
if (!_glfw.x11.xkb.available)
return NULL;
if (key != GLFW_KEY_UNKNOWN)
scancode = _glfw.x11.nativeKeys[key];
if (!_glfwIsPrintable(_glfw.x11.publicKeys[scancode]))
return NULL;
keysym = XkbKeycodeToKeysym(_glfw.x11.display, scancode, 0, 0);
if (keysym == NoSymbol)
return NULL;
XkbTranslateKeySym(_glfw.x11.display, &keysym, 0,
_glfw.x11.keyName, sizeof(_glfw.x11.keyName),
&extra);
if (!strlen(_glfw.x11.keyName))
return NULL;
return _glfw.x11.keyName;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x1195a(%rip), %r15 # 0x2eb78
cmpl $0x0, 0x7e4(%r15)
je 0x1d2a4
movl %esi, %ebx
cmpl $-0x1, %edi
je 0x1d23b
movslq %edi, %rax
movswl 0x3b0(%r15,%rax,2), %ebx
movslq %ebx, %rax
movswl 0x1b0(%r15,%rax,2), %edi
callq 0x14d88
testl %eax, %eax
je 0x1d2a4
movq 0x130(%r15), %rdi
movzbl %bl, %esi
xorl %ebx, %ebx
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x10360
movq %rax, (%rsp)
testq %rax, %rax
je 0x1d2a6
movq 0x130(%r15), %rdi
leaq 0x170(%r15), %r14
movq %rsp, %rsi
xorl %ebx, %ebx
leaq 0xc(%rsp), %r9
xorl %edx, %edx
movq %r14, %rcx
movl $0x40, %r8d
callq 0x10930
cmpb $0x0, 0x170(%r15)
cmovneq %r14, %rbx
jmp 0x1d2a6
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c
|
glfwInitJoysticksLinux
|
GLFWbool _glfwInitJoysticksLinux(void)
{
#if defined(__linux__)
DIR* dir;
int count = 0;
const char* dirname = "/dev/input";
_glfw.linux_js.inotify = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
if (_glfw.linux_js.inotify == -1)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Linux: Failed to initialize inotify: %s",
strerror(errno));
return GLFW_FALSE;
}
// HACK: Register for IN_ATTRIB as well to get notified when udev is done
// This works well in practice but the true way is libudev
_glfw.linux_js.watch = inotify_add_watch(_glfw.linux_js.inotify,
dirname,
IN_CREATE | IN_ATTRIB);
if (_glfw.linux_js.watch == -1)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Linux: Failed to watch for joystick connections in %s: %s",
dirname,
strerror(errno));
// Continue without device connection notifications
}
if (regcomp(&_glfw.linux_js.regex, "^js[0-9]\\+$", 0) != 0)
{
_glfwInputError(GLFW_PLATFORM_ERROR, "Linux: Failed to compile regex");
return GLFW_FALSE;
}
dir = opendir(dirname);
if (dir)
{
struct dirent* entry;
while ((entry = readdir(dir)))
{
char path[20];
regmatch_t match;
if (regexec(&_glfw.linux_js.regex, entry->d_name, 1, &match, 0) != 0)
continue;
snprintf(path, sizeof(path), "%s/%s", dirname, entry->d_name);
if (openJoystickDevice(path))
count++;
}
closedir(dir);
}
else
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Linux: Failed to open joystick device directory %s: %s",
dirname,
strerror(errno));
// Continue with no joysticks detected
}
qsort(_glfw.linux_js.js, count, sizeof(_GLFWjoystickLinux), compareJoysticks);
#endif // __linux__
return GLFW_TRUE;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0x80800, %edi # imm = 0x80800
callq 0x10610
leaq 0x10f29(%rip), %rbx # 0x2eb78
movl %eax, 0xcc0(%rbx)
cmpl $-0x1, %eax
je 0x1dcd9
leaq 0x9853(%rip), %rsi # 0x274b4
movl %eax, %edi
movl $0x104, %edx # imm = 0x104
callq 0x10880
movl %eax, 0xcc4(%rbx)
cmpl $-0x1, %eax
jne 0x1dca1
callq 0x10670
movl (%rax), %edi
callq 0x10580
leaq 0x985c(%rip), %rsi # 0x274e7
leaq 0x9822(%rip), %rdx # 0x274b4
movl $0x10008, %edi # imm = 0x10008
movq %rax, %rcx
xorl %eax, %eax
callq 0x14954
movl $0xcc8, %edi # imm = 0xCC8
addq 0xf333(%rip), %rdi # 0x2cfe0
leaq 0x986d(%rip), %rsi # 0x27521
xorl %ebx, %ebx
xorl %edx, %edx
callq 0x105f0
testl %eax, %eax
je 0x1dd02
leaq 0x9865(%rip), %rsi # 0x2752d
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x14954
jmp 0x1ddfe
callq 0x10670
movl (%rax), %edi
callq 0x10580
leaq 0x97d3(%rip), %rsi # 0x274bf
xorl %ebx, %ebx
movl $0x10008, %edi # imm = 0x10008
movq %rax, %rdx
xorl %eax, %eax
callq 0x14954
jmp 0x1ddfe
leaq 0x97ab(%rip), %rdi # 0x274b4
callq 0x10490
testq %rax, %rax
je 0x1ddad
movq %rax, %rbx
movq %rax, %rdi
callq 0x10500
xorl %r14d, %r14d
testq %rax, %rax
je 0x1dda3
movq %rax, %r12
movl $0xcc8, %r14d # imm = 0xCC8
addq 0xf2a6(%rip), %r14 # 0x2cfe0
leaq 0x8(%rsp), %r15
leaq 0x10(%rsp), %rbp
xorl %r13d, %r13d
addq $0x13, %r12
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x102c0
testl %eax, %eax
jne 0x1dd90
movl $0x14, %esi
movq %rbp, %rdi
leaq 0x97d8(%rip), %rdx # 0x2754c
leaq 0x9739(%rip), %rcx # 0x274b4
movq %r12, %r8
xorl %eax, %eax
callq 0x10130
movq %rbp, %rdi
callq 0x1de0f
addl %eax, %r13d
movq %rbx, %rdi
callq 0x10500
movq %rax, %r12
testq %rax, %rax
jne 0x1dd47
movslq %r13d, %r14
movq %rbx, %rdi
callq 0x108d0
jmp 0x1ddd9
callq 0x10670
movl (%rax), %edi
callq 0x10580
leaq 0x9792(%rip), %rsi # 0x27552
leaq 0x96ed(%rip), %rdx # 0x274b4
xorl %r14d, %r14d
movl $0x10008, %edi # imm = 0x10008
movq %rax, %rcx
xorl %eax, %eax
callq 0x14954
movl $0x940, %edi # imm = 0x940
addq 0xf1fb(%rip), %rdi # 0x2cfe0
leaq 0x1d2(%rip), %rcx # 0x1dfbe
movl $0x38, %edx
movq %r14, %rsi
callq 0x10690
movl $0x1, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/linux_joystick.c
|
openJoystickDevice
|
static GLFWbool openJoystickDevice(const char* path)
{
char axisCount, buttonCount;
char name[256] = "";
int joy, fd, version;
_GLFWjoystickLinux* js;
for (joy = GLFW_JOYSTICK_1; joy <= GLFW_JOYSTICK_LAST; joy++)
{
if (!_glfw.linux_js.js[joy].present)
continue;
if (strcmp(_glfw.linux_js.js[joy].path, path) == 0)
return GLFW_FALSE;
}
for (joy = GLFW_JOYSTICK_1; joy <= GLFW_JOYSTICK_LAST; joy++)
{
if (!_glfw.linux_js.js[joy].present)
break;
}
if (joy > GLFW_JOYSTICK_LAST)
return GLFW_FALSE;
fd = open(path, O_RDONLY | O_NONBLOCK);
if (fd == -1)
return GLFW_FALSE;
// Verify that the joystick driver version is at least 1.0
ioctl(fd, JSIOCGVERSION, &version);
if (version < 0x010000)
{
// It's an old 0.x interface (we don't support it)
close(fd);
return GLFW_FALSE;
}
if (ioctl(fd, JSIOCGNAME(sizeof(name)), name) < 0)
strncpy(name, "Unknown", sizeof(name));
js = _glfw.linux_js.js + joy;
js->present = GLFW_TRUE;
js->name = strdup(name);
js->path = strdup(path);
js->fd = fd;
ioctl(fd, JSIOCGAXES, &axisCount);
js->axisCount = (int) axisCount;
js->axes = calloc(axisCount, sizeof(float));
ioctl(fd, JSIOCGBUTTONS, &buttonCount);
js->buttonCount = (int) buttonCount;
js->buttons = calloc(buttonCount, 1);
_glfwInputJoystickChange(joy, GLFW_CONNECTED);
return GLFW_TRUE;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, %r14
leaq 0x10(%rsp), %rdi
xorl %ebx, %ebx
movl $0x100, %edx # imm = 0x100
xorl %esi, %esi
callq 0x10110
leaq 0x10d3b(%rip), %r15 # 0x2eb78
cmpl $0x0, 0x940(%r15,%rbx)
je 0x1de5c
movq 0x970(%r15,%rbx), %rdi
movq %r14, %rsi
callq 0x10720
testl %eax, %eax
je 0x1de8b
addq $0x38, %rbx
cmpq $0x380, %rbx # imm = 0x380
jne 0x1de3d
movl $0x940, %r15d # imm = 0x940
addq 0xf16a(%rip), %r15 # 0x2cfe0
xorl %ebx, %ebx
cmpl $0x0, (%r15)
je 0x1dea3
incq %rbx
addq $0x38, %r15
cmpq $0x10, %rbx
jne 0x1de78
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
movq %r14, %rdi
movl $0x800, %esi # imm = 0x800
xorl %eax, %eax
callq 0x109f0
cmpl $-0x1, %eax
je 0x1de8e
movl %eax, %ebp
movl $0x80016a11, %eax # imm = 0x80016A11
leaq 0x2fff0(%rax), %rsi
xorl %r12d, %r12d
leaq 0xc(%rsp), %r13
movl %ebp, %edi
movq %r13, %rdx
xorl %eax, %eax
callq 0x10150
cmpl $0xffff, (%r13) # imm = 0xFFFF
jg 0x1deef
movl %ebp, %edi
callq 0x10140
jmp 0x1de8e
movl $0x80016a11, %eax # imm = 0x80016A11
leaq 0xff0002(%rax), %rsi
leaq 0x10(%rsp), %rdx
movl %ebp, %edi
xorl %eax, %eax
callq 0x10150
testl %eax, %eax
movl $0x80016a11, %r12d # imm = 0x80016A11
jns 0x1df29
leaq 0x967d(%rip), %rsi # 0x27597
leaq 0x10(%rsp), %rdi
movl $0x100, %edx # imm = 0x100
callq 0x10820
movl $0x1, (%r15)
leaq 0x10(%rsp), %rdi
callq 0x106a0
movq %rax, 0x28(%r15)
movq %r14, %rdi
callq 0x106a0
movq %rax, 0x30(%r15)
movl %ebp, 0x4(%r15)
leaq 0xb(%rsp), %r14
movl $0x80016a11, %esi # imm = 0x80016A11
movl %ebp, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x10150
movsbq (%r14), %rdi
movl %edi, 0x10(%r15)
movl $0x4, %esi
callq 0x107f0
movq %rax, 0x8(%r15)
incq %r12
leaq 0xa(%rsp), %r14
movl %ebp, %edi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x10150
movsbq (%r14), %rdi
movl %edi, 0x20(%r15)
movl $0x1, %esi
callq 0x107f0
movq %rax, 0x18(%r15)
movl %ebx, %edi
movl $0x40001, %esi # imm = 0x40001
callq 0x14d72
movl $0x1, %r12d
jmp 0x1de8e
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/linux_joystick.c
|
destroyContextGLX
|
static void destroyContextGLX(_GLFWwindow* window)
{
if (window->context.glx.window)
{
glXDestroyWindow(_glfw.x11.display, window->context.glx.window);
window->context.glx.window = None;
}
if (window->context.glx.handle)
{
glXDestroyContext(_glfw.x11.display, window->context.glx.handle);
window->context.glx.handle = NULL;
}
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x270(%rdi), %rsi
testq %rsi, %rsi
je 0x1f25a
leaq 0xf936(%rip), %rax # 0x2eb78
movq 0x130(%rax), %rdi
callq *0x8c8(%rax)
movq $0x0, 0x270(%rbx)
movq 0x268(%rbx), %rsi
testq %rsi, %rsi
je 0x1f285
leaq 0xf90b(%rip), %rax # 0x2eb78
movq 0x130(%rax), %rdi
callq *0x890(%rax)
movq $0x0, 0x268(%rbx)
popq %rbx
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/glx_context.c
|
glfwChooseVisualGLX
|
GLFWbool _glfwChooseVisualGLX(const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig,
Visual** visual, int* depth)
{
GLXFBConfig native;
XVisualInfo* result;
if (!chooseGLXFBConfig(fbconfig, &native))
{
_glfwInputError(GLFW_FORMAT_UNAVAILABLE,
"GLX: Failed to find a suitable GLXFBConfig");
return GLFW_FALSE;
}
result = glXGetVisualFromFBConfig(_glfw.x11.display, native);
if (!result)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"GLX: Failed to retrieve Visual for GLXFBConfig");
return GLFW_FALSE;
}
*visual = result->visual;
*depth = result->depth;
XFree(result);
return GLFW_TRUE;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %rdi
movq %rsp, %rsi
callq 0x1ed94
testl %eax, %eax
je 0x1f2d7
leaq 0xf8d1(%rip), %rax # 0x2eb78
movq 0x130(%rax), %rdi
movq (%rsp), %rsi
callq *0x8b8(%rax)
testq %rax, %rax
je 0x1f2e7
movq (%rax), %rcx
movq %rcx, (%r14)
movl 0x14(%rax), %ecx
movl %ecx, (%rbx)
movq %rax, %rdi
callq 0x10080
movl $0x1, %ebx
jmp 0x1f2fc
leaq 0x8626(%rip), %rsi # 0x27904
xorl %ebx, %ebx
movl $0x10009, %edi # imm = 0x10009
jmp 0x1f2f5
leaq 0x8775(%rip), %rsi # 0x27a63
xorl %ebx, %ebx
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x14954
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/glx_context.c
|
glfwGetGLXContext
|
GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return NULL;
}
return window->context.glx.handle;
}
|
pushq %rbx
leaq 0xf85a(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x1f325
cmpl $0x0, 0x1f0(%rdi)
je 0x1f32e
movq 0x268(%rdi), %rbx
jmp 0x1f33e
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x1f335
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq 0x14954
movq %rbx, %rax
popq %rbx
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/glx_context.c
|
glfwGetGLXWindow
|
GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(None);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return None;
}
return window->context.glx.window;
}
|
pushq %rbx
leaq 0xf81d(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x1f362
cmpl $0x0, 0x1f0(%rdi)
je 0x1f36b
movq 0x270(%rdi), %rbx
jmp 0x1f37b
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x1f372
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq 0x14954
movq %rbx, %rax
popq %rbx
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/glx_context.c
|
glfwInitEGL
|
GLFWbool _glfwInitEGL(void)
{
int i;
const char* sonames[] =
{
#if defined(_GLFW_WIN32)
"libEGL.dll",
"EGL.dll",
#elif defined(_GLFW_COCOA)
"libEGL.dylib",
#else
"libEGL.so.1",
#endif
NULL
};
if (_glfw.egl.handle)
return GLFW_TRUE;
for (i = 0; sonames[i]; i++)
{
_glfw.egl.handle = _glfw_dlopen(sonames[i]);
if (_glfw.egl.handle)
break;
}
if (!_glfw.egl.handle)
{
_glfwInputError(GLFW_API_UNAVAILABLE, "EGL: Library not found");
return GLFW_FALSE;
}
_glfw.egl.prefix = (strncmp(sonames[i], "lib", 3) == 0);
_glfw.egl.GetConfigAttrib = (PFNEGLGETCONFIGATTRIBPROC)
_glfw_dlsym(_glfw.egl.handle, "eglGetConfigAttrib");
_glfw.egl.GetConfigs = (PFNEGLGETCONFIGSPROC)
_glfw_dlsym(_glfw.egl.handle, "eglGetConfigs");
_glfw.egl.GetDisplay = (PFNEGLGETDISPLAYPROC)
_glfw_dlsym(_glfw.egl.handle, "eglGetDisplay");
_glfw.egl.GetError = (PFNEGLGETERRORPROC)
_glfw_dlsym(_glfw.egl.handle, "eglGetError");
_glfw.egl.Initialize = (PFNEGLINITIALIZEPROC)
_glfw_dlsym(_glfw.egl.handle, "eglInitialize");
_glfw.egl.Terminate = (PFNEGLTERMINATEPROC)
_glfw_dlsym(_glfw.egl.handle, "eglTerminate");
_glfw.egl.BindAPI = (PFNEGLBINDAPIPROC)
_glfw_dlsym(_glfw.egl.handle, "eglBindAPI");
_glfw.egl.CreateContext = (PFNEGLCREATECONTEXTPROC)
_glfw_dlsym(_glfw.egl.handle, "eglCreateContext");
_glfw.egl.DestroySurface = (PFNEGLDESTROYSURFACEPROC)
_glfw_dlsym(_glfw.egl.handle, "eglDestroySurface");
_glfw.egl.DestroyContext = (PFNEGLDESTROYCONTEXTPROC)
_glfw_dlsym(_glfw.egl.handle, "eglDestroyContext");
_glfw.egl.CreateWindowSurface = (PFNEGLCREATEWINDOWSURFACEPROC)
_glfw_dlsym(_glfw.egl.handle, "eglCreateWindowSurface");
_glfw.egl.MakeCurrent = (PFNEGLMAKECURRENTPROC)
_glfw_dlsym(_glfw.egl.handle, "eglMakeCurrent");
_glfw.egl.SwapBuffers = (PFNEGLSWAPBUFFERSPROC)
_glfw_dlsym(_glfw.egl.handle, "eglSwapBuffers");
_glfw.egl.SwapInterval = (PFNEGLSWAPINTERVALPROC)
_glfw_dlsym(_glfw.egl.handle, "eglSwapInterval");
_glfw.egl.QueryString = (PFNEGLQUERYSTRINGPROC)
_glfw_dlsym(_glfw.egl.handle, "eglQueryString");
_glfw.egl.GetProcAddress = (PFNEGLGETPROCADDRESSPROC)
_glfw_dlsym(_glfw.egl.handle, "eglGetProcAddress");
if (!_glfw.egl.GetConfigAttrib ||
!_glfw.egl.GetConfigs ||
!_glfw.egl.GetDisplay ||
!_glfw.egl.GetError ||
!_glfw.egl.Initialize ||
!_glfw.egl.Terminate ||
!_glfw.egl.BindAPI ||
!_glfw.egl.CreateContext ||
!_glfw.egl.DestroySurface ||
!_glfw.egl.DestroyContext ||
!_glfw.egl.CreateWindowSurface ||
!_glfw.egl.MakeCurrent ||
!_glfw.egl.SwapBuffers ||
!_glfw.egl.SwapInterval ||
!_glfw.egl.QueryString ||
!_glfw.egl.GetProcAddress)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"EGL: Failed to load required entry points");
_glfwTerminateEGL();
return GLFW_FALSE;
}
_glfw.egl.display = eglGetDisplay(_GLFW_EGL_NATIVE_DISPLAY);
if (_glfw.egl.display == EGL_NO_DISPLAY)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"EGL: Failed to get EGL display: %s",
getEGLErrorString(eglGetError()));
_glfwTerminateEGL();
return GLFW_FALSE;
}
if (!eglInitialize(_glfw.egl.display, &_glfw.egl.major, &_glfw.egl.minor))
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"EGL: Failed to initialize EGL: %s",
getEGLErrorString(eglGetError()));
_glfwTerminateEGL();
return GLFW_FALSE;
}
_glfw.egl.KHR_create_context =
extensionSupportedEGL("EGL_KHR_create_context");
_glfw.egl.KHR_create_context_no_error =
extensionSupportedEGL("EGL_KHR_create_context_no_error");
_glfw.egl.KHR_gl_colorspace =
extensionSupportedEGL("EGL_KHR_gl_colorspace");
return GLFW_TRUE;
}
|
pushq %r14
pushq %rbx
pushq %rax
leaq 0xf7ed(%rip), %r14 # 0x2eb78
movl $0x1, %ebx
cmpq $0x0, 0xd30(%r14)
jne 0x1f741
leaq 0x875d(%rip), %rdi # 0x27b02
movl $0x1, %esi
callq 0x105b0
movq %rax, 0xd30(%r14)
testq %rax, %rax
je 0x1f66f
movl $0x1, 0xd20(%r14)
leaq 0x8754(%rip), %rsi # 0x27b25
movq %rax, %rdi
callq 0x10920
movq %rax, 0xd38(%r14)
movq 0xd30(%r14), %rdi
leaq 0x874a(%rip), %rsi # 0x27b38
callq 0x10920
movq %rax, 0xd40(%r14)
movq 0xd30(%r14), %rdi
leaq 0x873e(%rip), %rsi # 0x27b46
callq 0x10920
movq %rax, 0xd48(%r14)
movq 0xd30(%r14), %rdi
leaq 0x8732(%rip), %rsi # 0x27b54
callq 0x10920
movq %rax, 0xd50(%r14)
movq 0xd30(%r14), %rdi
leaq 0x8724(%rip), %rsi # 0x27b60
callq 0x10920
movq %rax, 0xd58(%r14)
movq 0xd30(%r14), %rdi
leaq 0x8718(%rip), %rsi # 0x27b6e
callq 0x10920
movq %rax, 0xd60(%r14)
movq 0xd30(%r14), %rdi
leaq 0x870b(%rip), %rsi # 0x27b7b
callq 0x10920
movq %rax, 0xd68(%r14)
movq 0xd30(%r14), %rdi
leaq 0x86fc(%rip), %rsi # 0x27b86
callq 0x10920
movq %rax, 0xd70(%r14)
movq 0xd30(%r14), %rdi
leaq 0x86f3(%rip), %rsi # 0x27b97
callq 0x10920
movq %rax, 0xd78(%r14)
movq 0xd30(%r14), %rdi
leaq 0x86eb(%rip), %rsi # 0x27ba9
callq 0x10920
movq %rax, 0xd80(%r14)
movq 0xd30(%r14), %rdi
leaq 0x86e3(%rip), %rsi # 0x27bbb
callq 0x10920
movq %rax, 0xd88(%r14)
movq 0xd30(%r14), %rdi
leaq 0x86e0(%rip), %rsi # 0x27bd2
callq 0x10920
movq %rax, 0xd90(%r14)
movq 0xd30(%r14), %rdi
leaq 0x86d5(%rip), %rsi # 0x27be1
callq 0x10920
movq %rax, 0xd98(%r14)
movq 0xd30(%r14), %rdi
leaq 0x86ca(%rip), %rsi # 0x27bf0
callq 0x10920
movq %rax, 0xda0(%r14)
movq 0xd30(%r14), %rdi
leaq 0x86c0(%rip), %rsi # 0x27c00
callq 0x10920
movq %rax, 0xda8(%r14)
movq 0xd30(%r14), %rdi
leaq 0x86b5(%rip), %rsi # 0x27c0f
callq 0x10920
movq %rax, 0xdb0(%r14)
movdqu 0xd38(%r14), %xmm7
movdqu 0xd48(%r14), %xmm0
movdqu 0xd58(%r14), %xmm6
movdqu 0xd68(%r14), %xmm8
movdqu 0xd88(%r14), %xmm5
movdqu 0xd78(%r14), %xmm4
movdqu 0xd98(%r14), %xmm2
movq %rax, %xmm3
movq 0xda8(%r14), %xmm1
punpcklqdq %xmm3, %xmm1 # xmm1 = xmm1[0],xmm3[0]
pxor %xmm3, %xmm3
pcmpeqd %xmm3, %xmm8
pshufd $0xb1, %xmm8, %xmm9 # xmm9 = xmm8[1,0,3,2]
pand %xmm8, %xmm9
pcmpeqd %xmm3, %xmm6
pshufd $0xb1, %xmm6, %xmm8 # xmm8 = xmm6[1,0,3,2]
pand %xmm6, %xmm8
packssdw %xmm9, %xmm8
movdqa %xmm0, %xmm6
pcmpeqd %xmm3, %xmm6
pshufd $0xb1, %xmm6, %xmm9 # xmm9 = xmm6[1,0,3,2]
pand %xmm6, %xmm9
pcmpeqd %xmm3, %xmm7
pshufd $0xb1, %xmm7, %xmm6 # xmm6 = xmm7[1,0,3,2]
pand %xmm7, %xmm6
packssdw %xmm9, %xmm6
packssdw %xmm8, %xmm6
pcmpeqd %xmm3, %xmm5
pshufd $0xb1, %xmm5, %xmm7 # xmm7 = xmm5[1,0,3,2]
pand %xmm5, %xmm7
pcmpeqd %xmm3, %xmm4
pshufd $0xb1, %xmm4, %xmm5 # xmm5 = xmm4[1,0,3,2]
pand %xmm4, %xmm5
packssdw %xmm7, %xmm5
pcmpeqd %xmm3, %xmm2
pshufd $0xb1, %xmm2, %xmm4 # xmm4 = xmm2[1,0,3,2]
pand %xmm2, %xmm4
pcmpeqd %xmm3, %xmm1
pshufd $0xb1, %xmm1, %xmm2 # xmm2 = xmm1[1,0,3,2]
pand %xmm1, %xmm2
packssdw %xmm2, %xmm4
packssdw %xmm4, %xmm5
packsswb %xmm5, %xmm6
pmovmskb %xmm6, %eax
testl %eax, %eax
je 0x1f689
leaq 0x85c5(%rip), %rsi # 0x27c21
xorl %ebx, %ebx
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x14954
jmp 0x1f73c
leaq 0x8498(%rip), %rsi # 0x27b0e
xorl %ebx, %ebx
movl $0x10006, %edi # imm = 0x10006
xorl %eax, %eax
callq 0x14954
jmp 0x1f741
movq 0x130(%r14), %rdi
movq %xmm0, %rax
callq *%rax
movq %rax, 0xd10(%r14)
testq %rax, %rax
je 0x1f6ff
leaq 0xd18(%r14), %rsi
leaq 0xd1c(%r14), %rdx
movq %rax, %rdi
callq *0xd58(%r14)
testl %eax, %eax
je 0x1f716
leaq 0x85ca(%rip), %rdi # 0x27c90
callq 0x1f7b2
movl %eax, 0xd24(%r14)
leaq 0x85ce(%rip), %rdi # 0x27ca7
callq 0x1f7b2
movl %eax, 0xd28(%r14)
leaq 0x85db(%rip), %rdi # 0x27cc7
callq 0x1f7b2
movl %eax, 0xd2c(%r14)
movl $0x1, %ebx
jmp 0x1f741
callq *0xd50(%r14)
movl %eax, %edi
callq 0x1f78e
leaq 0x8537(%rip), %rsi # 0x27c4b
jmp 0x1f72b
callq *0xd50(%r14)
movl %eax, %edi
callq 0x1f78e
leaq 0x8543(%rip), %rsi # 0x27c6e
xorl %ebx, %ebx
movl $0x10006, %edi # imm = 0x10006
movq %rax, %rdx
xorl %eax, %eax
callq 0x14954
callq 0x1f74b
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/egl_context.c
|
glfwTerminateEGL
|
void _glfwTerminateEGL(void)
{
if (_glfw.egl.display)
{
eglTerminate(_glfw.egl.display);
_glfw.egl.display = EGL_NO_DISPLAY;
}
if (_glfw.egl.handle)
{
_glfw_dlclose(_glfw.egl.handle);
_glfw.egl.handle = NULL;
}
}
|
pushq %rbx
leaq 0xf425(%rip), %rbx # 0x2eb78
movq 0xd10(%rbx), %rdi
testq %rdi, %rdi
je 0x1f770
callq *0xd60(%rbx)
movq $0x0, 0xd10(%rbx)
movq 0xd30(%rbx), %rdi
testq %rdi, %rdi
je 0x1f78c
callq 0x10a60
movq $0x0, 0xd30(%rbx)
popq %rbx
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/egl_context.c
|
getEGLErrorString
|
static const char* getEGLErrorString(EGLint error)
{
switch (error)
{
case EGL_SUCCESS:
return "Success";
case EGL_NOT_INITIALIZED:
return "EGL is not or could not be initialized";
case EGL_BAD_ACCESS:
return "EGL cannot access a requested resource";
case EGL_BAD_ALLOC:
return "EGL failed to allocate resources for the requested operation";
case EGL_BAD_ATTRIBUTE:
return "An unrecognized attribute or attribute value was passed in the attribute list";
case EGL_BAD_CONTEXT:
return "An EGLContext argument does not name a valid EGL rendering context";
case EGL_BAD_CONFIG:
return "An EGLConfig argument does not name a valid EGL frame buffer configuration";
case EGL_BAD_CURRENT_SURFACE:
return "The current surface of the calling thread is a window, pixel buffer or pixmap that is no longer valid";
case EGL_BAD_DISPLAY:
return "An EGLDisplay argument does not name a valid EGL display connection";
case EGL_BAD_SURFACE:
return "An EGLSurface argument does not name a valid surface configured for GL rendering";
case EGL_BAD_MATCH:
return "Arguments are inconsistent";
case EGL_BAD_PARAMETER:
return "One or more argument values are invalid";
case EGL_BAD_NATIVE_PIXMAP:
return "A NativePixmapType argument does not refer to a valid native pixmap";
case EGL_BAD_NATIVE_WINDOW:
return "A NativeWindowType argument does not refer to a valid native window";
case EGL_CONTEXT_LOST:
return "The application must destroy all contexts and reinitialise";
default:
return "ERROR: UNKNOWN EGL ERROR";
}
}
|
addl $0xffffd000, %edi # imm = 0xFFFFD000
cmpl $0xe, %edi
ja 0x1f7aa
movl %edi, %eax
leaq 0x8ac6(%rip), %rcx # 0x28268
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x89e1(%rip), %rax # 0x28192
retq
|
/Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/egl_context.c
|
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.