name string | code string | asm string | file string |
|---|---|---|---|
w3Interp::Max_f32() | INTERP (Max_f32)
{
const float z2 = pop_f32 ();
float& z1 = f32 ();
z1 = std::max (z1, z2);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %r14, %rdi
movl $0x7d, %esi
callq 0x20b0c
movss (%rax), %xmm0
movss %xmm0, 0x4(%rsp)
movq %r14, %rdi
callq 0x1e348
addq $-0x30, 0x18(%rbx)
movq %r14, %rdi
movl $0x7d, %esi
callq 0x20b0c
movss 0x4(%rsp), %xmm0
maxss (%rax), %xmm0
movss %xmm0, (%... | /jaykrell[P]w3/w3interp.cpp |
w3Interp::i32_Trunc_f32u() | INTERP (i32_Trunc_f32u)
{
set_u32 ((uint32_t)f32 ());
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %r14, %rdi
movl $0x7d, %esi
callq 0x20b0c
cvttss2si (%rax), %r15
movq %r14, %rdi
callq 0x1e348
movq 0x18(%rbx), %rax
movb $0x7f, -0x28(%rax)
movl %r15d, -0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
| /jaykrell[P]w3/w3interp.cpp |
w3Stack::DumpStack(char const*) | void DumpStack (PCSTR prefix)
{
const size_t n = size ();
printf ("stack@%s: %" FORMAT_SIZE "X ", prefix, n);
for (size_t i = 0; i != n; ++i)
{
printf ("%s:", TagToString (begin () [(ssize_t)i].tag));
switch (begin () [(ssize_t)i].tag)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movq (%rdi), %r12
movq %r15, %rax
subq %r12, %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %r14 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r14
leaq 0x8ff4(%rip), %rdi # 0x270ba
movq %r14, %rdx
xorl %... | /jaykrell[P]w3/w3Stack.h |
smf::Binasc::writeBigEndianLong(std::ostream&, long) | std::ostream& Binasc::writeBigEndianLong(std::ostream& out, long value) {
union { char bytes[4]; long l; } data;
data.l = value;
out << data.bytes[3];
out << data.bytes[2];
out << data.bytes[1];
out << data.bytes[0];
return out;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, %ebp
shrl $0x10, %ebp
movl %esi, %eax
movq %rsi, %r14
shrl $0x18, %eax
leaq 0xd(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
callq 0xe360
leaq 0xe(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xe360
movq %r14, %rax
movb ... | /dean-deng[P]midifile/src-library/Binasc.cpp |
smf::Binasc::writeBigEndianULong(std::ostream&, unsigned long) | std::ostream& Binasc::writeBigEndianULong(std::ostream& out, ulong value) {
union { char bytes[4]; long ul; } data;
data.ul = value;
out << data.bytes[3];
out << data.bytes[2];
out << data.bytes[1];
out << data.bytes[0];
return out;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, %ebp
shrl $0x10, %ebp
movl %esi, %eax
movq %rsi, %r14
shrl $0x18, %eax
leaq 0xd(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
callq 0xe360
leaq 0xe(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xe360
movq %r14, %rax
movb ... | /dean-deng[P]midifile/src-library/Binasc.cpp |
smf::MidiEvent::operator=(smf::MidiEvent const&) | MidiEvent& MidiEvent::operator=(const MidiEvent& mfevent) {
if (this == &mfevent) {
return *this;
}
tick = mfevent.tick;
track = mfevent.track;
seconds = mfevent.seconds;
seq = mfevent.seq;
m_eventlink = NULL;
this->resize(mfevent.size());
for (int i=0; i<(int)this->size(); i++) {
(*this)[i] = mfe... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x20ecc
movq %rsi, %r14
movl 0x18(%rsi), %eax
movl %eax, 0x18(%rbx)
movl 0x1c(%rsi), %eax
movl %eax, 0x1c(%rbx)
movsd 0x20(%rsi), %xmm0
movsd %xmm0, 0x20(%rbx)
movl 0x28(%rsi), %eax
movl %eax, 0x28(%rbx)
movq $0x0, 0x30(%rbx)
movq 0x8(%rsi), %rsi
subq ... | /dean-deng[P]midifile/src-library/MidiEvent.cpp |
queries::API::TriplePatern(std::vector<diplo::TripleIDs, std::allocator<diplo::TripleIDs>>&, std::vector<diplo::TripleIDs, std::allocator<diplo::TripleIDs>>&, std::vector<std::vector<std::unordered_set<unsigned long, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<unsigned long>>, std::allocator<... | void API::TriplePatern(vector<TripleIDs>& constrains, vector<TripleIDs>& projections, vector<vector<unordered_set<KEY_ID>>> & resultsmaster, vector<vector<unordered_set<KEY_ID>>> & provmaster) {
set<pair<const KEY_ID, Molecule>*> molecules;
set<pair<const KEY_ID, Molecule>*>* Molecules_with_O = NULL;
// cerr <<... | pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x806e0
movq $0x0, -0x58(%rbp)
movq -0x8(%rbp), %rdi
callq 0x80700
cmpq $0x0, %rax
jbe 0x7f4a6
movq -0x8(%rbp), %rdi
xorl %eax, %e... | /MarcinWylot[P]tripleprov_demo/src/API.cpp |
t_enum::f_define() | std::vector<std::pair<t_root, t_rvalue>> t_enum::f_define()
{
return t_define(this)
(L"Number"sv, t_type_of<t_number>::f_define(this))
;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
leaq 0x18(%rsp), %rbx
movq %rsi, -0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movq %rsi, %rdi
callq 0x5570
movq %rax, %r12
leaq 0x28f7(%rip), %rsi # 0x8010
movl $0x6, %edi
callq 0x52... | /shin1m[P]xemmai/test/enum/enum.cc |
xemmai::t_object* xemmai::t_enum_of<t_number, t_enum>::f_define<xemmai::t_type_of<t_number>::f_define(t_enum*)::'lambda'(auto)>(t_enum*, auto) | static t_object* f_define(t_library* a_library, auto a_fields)
{
t_define{a_library}.template f_derive<T, intptr_t>();
t_define fields(a_library);
a_fields(std::ref(fields));
return static_cast<t_type_of<T>*>(a_library->template f_type<T>())->f_do_derive({{}, fields});
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
leaq 0x10(%rsp), %rbx
movq %rdi, -0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x5440
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x5290
movq %rbx, %rdi
callq 0x... | /shin1m[P]xemmai/include/xemmai/convert.h |
xemmai::t_object* xemmai::t_type_of<xemmai::t_object>::f_derive<xemmai::t_type_of<t_number>>(xemmai::t_object*, xemmai::t_fields const&) | t_object* t_type::f_derive(t_object* a_module, const t_fields& a_fields)
{
auto [fields, key2index] = f_merge(a_fields);
auto p = f_engine()->f_allocate_for_type<T>(fields.size());
new(p->f_data()) T(T::c_IDS, this, a_module, T::c_NATIVE, v_instance_fields + a_fields.v_instance.size(), fields, key2index);
p->f_be(t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x54a0
leaq 0x18(%rsp), %rbx
leaq 0x5410(%rip), %rdi # 0xae88
callq 0x5480
movq -0x10(%rbx), %rcx
subq -0x18(%rbx), %rcx
movq (%ra... | /shin1m[P]xemmai/include/xemmai/engine.h |
xemmai::t_engine::f_wait() | void f_wait()
{
v_collector__wait.fetch_add(1, std::memory_order_relaxed);
if (!v_collector__running.test_and_set(std::memory_order_release)) v_collector__running.notify_one();
v_collector__running.wait(true, std::memory_order_relaxed);
} | pushq %rbx
movq %rdi, %rbx
lock
incq 0x10(%rdi)
movb $0x1, %al
xchgb %al, (%rdi)
testb %al, %al
jne 0x5cf8
movl %ebx, %eax
andl $0x38, %eax
shll $0x5, %eax
movq 0x5132(%rip), %rcx # 0xae00
lock
incl 0x40(%rcx,%rax)
movl (%rcx,%rax), %edx
testl %edx, %edx
je 0x5cf8
leaq (%rcx,%rax), %rsi
addq $0x40, %rsi
movl $0xca... | /shin1m[P]xemmai/include/xemmai/engine.h |
xemmai::t_slot::t_queue<256ul>::f_next() | void t_slot::t_queue<A_SIZE>::f_next() noexcept
{
auto engine = f_engine();
engine->f_tick();
if (v_head < v_objects + A_SIZE - 1) {
++v_head;
while (v_tail == v_head) engine->f_wait();
auto tail = v_tail;
v_next = std::min(tail < v_head ? v_objects + A_SIZE - 1 : tail - 1, v_head + A_SIZE / 8);
} else {
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x5028(%rip), %rdi # 0xae88
callq 0x5480
movq (%rax), %r14
movq %r14, %rdi
callq 0x5110
movq (%rbx), %rax
leaq 0x808(%rbx), %r15
cmpq %r15, %rax
jae 0x5eb6
addq $0x8, %rax
movq %rax, (%rbx)
movq 0x818(%rbx), %rdx
cmpq %rax, %rdx
jne 0x5ea9
movq %r14, %rdi
callq... | /shin1m[P]xemmai/include/xemmai/engine.h |
xemmai::t_heap<xemmai::t_object>::f_allocate_medium(unsigned long) | constexpr T* t_heap<T>::f_allocate_medium(size_t a_size)
{
if (a_size <= c_UNIT << 1) return f_allocate(v_of1);
if (a_size <= c_UNIT << 2) return f_allocate(v_of2);
if (a_size <= c_UNIT << 3) return f_allocate(v_of3);
if (a_size <= c_UNIT << 4) return f_allocate(v_of4);
return f_allocate_large(a_size);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x100, %rsi # imm = 0x100
ja 0x5fa9
leaq 0x5062(%rip), %rdi # 0xafe0
callq 0x5480
movq %rax, %r14
movq (%rax), %rax
testq %rax, %rax
jne 0x6037
leaq 0x88(%rbx), %rdi
movq %rbx, %rsi
callq 0x54b0
jmp 0x6037
cmpq $0x200, %rsi # imm = 0x200
... | /shin1m[P]xemmai/include/xemmai/heap.h |
xemmai::t_heap<xemmai::t_object>::t_of<0ul, 65536ul>::f_grow(xemmai::t_heap<xemmai::t_object>&) | T* f_grow(t_heap& a_heap)
{
auto size = c_UNIT << A_rank;
auto length = size * A_size;
auto block = static_cast<char*>(f_map(length));
auto p = block;
for (size_t i = 1; i < A_size; ++i) {
auto q = new(p) T;
q->v_next = reinterpret_cast<T*>(p += size);
q->v_rank = A_rank;
}
auto q = n... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq $0x800000, 0x8(%rsp) # imm = 0x800000
movl $0x800000, %edi # imm = 0x800000
callq 0x53d0
movl $0xffff, %ecx # imm = 0xFFFF
movq %rax, %rdx
movq %rdx, %rsi
movq $0x1, 0x20(%rdx)
addq $0x80, %rdx
movq %rdx, (%rsi)
... | /shin1m[P]xemmai/include/xemmai/heap.h |
xemmai::t_heap<xemmai::t_object>::f_map(unsigned long) | static void* f_map(size_t a_n)
{
#ifdef __unix__
auto p = mmap(NULL, a_n, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (p == MAP_FAILED) portable::f_throw_system_error();
#endif
#ifdef _WIN32
auto p = VirtualAlloc(NULL, a_n, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (p == NULL) throw std... | pushq %rax
movq %rdi, %rsi
xorl %edi, %edi
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x54d0
cmpq $-0x1, %rax
je 0x618a
popq %rcx
retq
callq 0x5220
nop
| /shin1m[P]xemmai/include/xemmai/heap.h |
xemmai::t_heap<xemmai::t_object>::f_allocate_large(unsigned long) | T* t_heap<T>::f_allocate_large(size_t a_size)
{
auto p = new(f_map(a_size)) T;
p->v_rank = c_RANKX;
{
std::lock_guard lock(v_mutex);
v_blocks.emplace(p, a_size);
++v_allocated;
}
return p;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rsi, %rdi
callq 0x53d0
movq $0x1, 0x20(%rax)
movq %rax, 0x8(%rsp)
movq $0x39, 0x30(%rax)
leaq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0x5430
testl %eax, %eax
jne 0x6353
leaq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq... | /shin1m[P]xemmai/include/xemmai/heap.h |
xemmai::t_heap<xemmai::t_object>::t_of<1ul, 16384ul>::f_grow(xemmai::t_heap<xemmai::t_object>&) | T* f_grow(t_heap& a_heap)
{
auto size = c_UNIT << A_rank;
auto length = size * A_size;
auto block = static_cast<char*>(f_map(length));
auto p = block;
for (size_t i = 1; i < A_size; ++i) {
auto q = new(p) T;
q->v_next = reinterpret_cast<T*>(p += size);
q->v_rank = A_rank;
}
auto q = n... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq $0x400000, 0x8(%rsp) # imm = 0x400000
movl $0x400000, %edi # imm = 0x400000
callq 0x53d0
movl $0x3fff, %ecx # imm = 0x3FFF
movl $0x1, %edx
movq %rax, %rsi
movq %rsi, %rdi
movq %rdx, 0x20(%rsi)
addq $0x100, %rsi ... | /shin1m[P]xemmai/include/xemmai/heap.h |
xemmai::t_heap<xemmai::t_object>::t_of<3ul, 1024ul>::f_allocate(xemmai::t_heap<xemmai::t_object>&) | T* f_allocate(t_heap& a_heap)
{
auto p = v_chunks.load(std::memory_order_acquire);
while (p && !v_chunks.compare_exchange_weak(p, p->v_previous, std::memory_order_acquire));
if (!p) p = f_grow(a_heap);
v_allocated.fetch_add(p->v_cyclic, std::memory_order_relaxed);
return p;
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x6582
movq %rax, %rcx
movq 0x8(%rax), %rdx
lock
cmpxchgq %rdx, (%rbx)
cmoveq %rcx, %rax
jne 0x656b
testq %rax, %rax
jne 0x658f
movq %rbx, %rdi
callq 0x52f0
movq 0x28(%rax), %rcx
lock
addq %rcx, 0x10(%rbx)
popq %rbx
retq
| /shin1m[P]xemmai/include/xemmai/heap.h |
xemmai::t_heap<xemmai::t_object>::t_of<3ul, 1024ul>::f_grow(xemmai::t_heap<xemmai::t_object>&) | T* f_grow(t_heap& a_heap)
{
auto size = c_UNIT << A_rank;
auto length = size * A_size;
auto block = static_cast<char*>(f_map(length));
auto p = block;
for (size_t i = 1; i < A_size; ++i) {
auto q = new(p) T;
q->v_next = reinterpret_cast<T*>(p += size);
q->v_rank = A_rank;
}
auto q = n... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq $0x100000, 0x8(%rsp) # imm = 0x100000
movl $0x100000, %edi # imm = 0x100000
callq 0x53d0
movl $0x3ff, %ecx # imm = 0x3FF
movq %rax, %rdx
movq %rdx, %rsi
movq $0x1, 0x20(%rdx)
addq $0x400, %rdx # imm =... | /shin1m[P]xemmai/include/xemmai/heap.h |
xemmai::t_heap<xemmai::t_object>::t_of<4ul, 256ul>::f_allocate(xemmai::t_heap<xemmai::t_object>&) | T* f_allocate(t_heap& a_heap)
{
auto p = v_chunks.load(std::memory_order_acquire);
while (p && !v_chunks.compare_exchange_weak(p, p->v_previous, std::memory_order_acquire));
if (!p) p = f_grow(a_heap);
v_allocated.fetch_add(p->v_cyclic, std::memory_order_relaxed);
return p;
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x6680
movq %rax, %rcx
movq 0x8(%rax), %rdx
lock
cmpxchgq %rdx, (%rbx)
cmoveq %rcx, %rax
jne 0x6669
testq %rax, %rax
jne 0x668d
movq %rbx, %rdi
callq 0x51a0
movq 0x28(%rax), %rcx
lock
addq %rcx, 0x10(%rbx)
popq %rbx
retq
| /shin1m[P]xemmai/include/xemmai/heap.h |
xemmai::t_heap<xemmai::t_object>::t_of<4ul, 256ul>::f_grow(xemmai::t_heap<xemmai::t_object>&) | T* f_grow(t_heap& a_heap)
{
auto size = c_UNIT << A_rank;
auto length = size * A_size;
auto block = static_cast<char*>(f_map(length));
auto p = block;
for (size_t i = 1; i < A_size; ++i) {
auto q = new(p) T;
q->v_next = reinterpret_cast<T*>(p += size);
q->v_rank = A_rank;
}
auto q = n... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq $0x80000, 0x8(%rsp) # imm = 0x80000
movl $0x80000, %edi # imm = 0x80000
callq 0x53d0
movl $0xff, %ecx
movq %rax, %rdx
movq %rdx, %rsi
movq $0x1, 0x20(%rdx)
addq $0x800, %rdx # imm = 0x800
movq %rdx, (%rsi)
mov... | /shin1m[P]xemmai/include/xemmai/heap.h |
xemmai::t_type_of<xemmai::t_object>::t_type_of<3ul>(std::array<void const*, 3ul> const&, xemmai::t_type_of<xemmai::t_object>*, xemmai::t_object*, unsigned long, unsigned long, std::vector<std::pair<xemmai::t_root, xemmai::t_value<xemmai::t_root>>, std::allocator<std::pair<xemmai::t_root, xemmai::t_value<xemmai::t_root>... | inline t_type::t_type_of(const std::array<t_type_id, A_n>& a_ids, t_type* a_super, t_object* a_module, size_t a_native, size_t a_instance_fields, const std::vector<std::pair<t_root, t_rvalue>>& a_fields, const std::map<t_object*, size_t>& a_key2index) : v_this(t_object::f_of(this)), v_depth(A_n - 1), v_ids(a_ids.data()... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %rbx
leaq -0x48(%rdi), %rsi
callq 0x54f0
movq $0x2, 0x8(%rbx)
movq %rbp, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
leaq 0x28(%rbx), %rdi
movq... | /shin1m[P]xemmai/include/xemmai/object.h |
xemmai::t_object* xemmai::t_engine::f_allocate_for_type<xemmai::t_derived_primitive<long>>(unsigned long) | t_object* f_allocate_for_type(size_t a_fields)
{
return f_allocate(t_object::f_align_for_fields(sizeof(T)) + (sizeof(std::pair<t_slot, t_svalue>) + sizeof(std::pair<t_object*, size_t>)) * a_fields);
} | pushq %r15
pushq %r14
pushq %rbx
leaq (%rsi,%rsi,4), %rax
leaq 0x30(%rdi), %rbx
leaq 0x1c0(,%rax,8), %rsi
cmpq $0x80, %rsi
ja 0x6d1b
movq %rdi, %r14
leaq 0x4203(%rip), %rdi # 0xaef8
callq 0x5480
movq %rax, %r15
movq (%rax), %rax
testq %rax, %rax
je 0x6d25
movq (%rax), %rcx
movq %rcx, (%r15)
movq $0x0, (%rax)
popq ... | /shin1m[P]xemmai/include/xemmai/engine.h |
xemmai::t_derived<xemmai::t_type_of<long>>::t_derived<std::array<void const*, 2ul> const&, xemmai::t_type_of<xemmai::t_object>*, xemmai::t_object*&, unsigned long const&, unsigned long, std::vector<std::pair<xemmai::t_root, xemmai::t_value<xemmai::t_root>>, std::allocator<std::pair<xemmai::t_root, xemmai::t_value<xemma... | t_derived(auto&&... a_xs) : T(std::forward<decltype(a_xs)>(a_xs)...)
{
this->f_call = t_type::f_do_call;
this->f_string = t_type::f_do_string;
this->f_hash = t_type::f_do_hash;
this->f_get_at = t_type::f_do_get_at;
this->f_set_at = t_type::f_do_set_at;
this->f_plus = t_type::f_do_plus;
this->f_minus = t_... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movaps 0x20(%rsp), %xmm0
movq (%rdx), %rdx
movq (%rcx), %rcx
movq (%r8), %r8
movq (%r9), %r9
movups %xmm0, (%rsp)
callq 0x5560
movq 0x4235(%rip), %rax # 0xaf98
movq %rax, 0x70(%rbx)
xorl %eax, %eax
movq %rax, 0x78(%rbx)
movq 0x413c(%rip), %rcx # 0xaeb0
movq %rcx, 0x... | /shin1m[P]xemmai/include/xemmai/type.h |
xemmai::t_derived_primitive<long>::f_do_construct(xemmai::t_value<xemmai::t_pointer>*, unsigned long) | t_pvalue f_do_construct(t_pvalue* a_stack, size_t a_n)
{
f_check<T>(a_stack[2], L"argument0");
return this->template f_new<T>(f_as<T>(a_stack[2]));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbp
movq 0x20(%rdx), %rax
cmpq $0x3, %rax
je 0x6f21
jb 0x7066
cmpq $0x4, %rax
je 0x7066
movq 0x40(%rax), %rcx
cmpq $0x0, 0x8(%rcx)
je 0x7066
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x3f45(%rip), %rcx # ... | /shin1m[P]xemmai/include/xemmai/type.h |
xemmai::t_type_of<xemmai::t_object>::t_type_of<2ul>(std::array<void const*, 2ul> const&, xemmai::t_type_of<xemmai::t_object>*, xemmai::t_object*, unsigned long, unsigned long, std::vector<std::pair<xemmai::t_root, xemmai::t_value<xemmai::t_root>>, std::allocator<std::pair<xemmai::t_root, xemmai::t_value<xemmai::t_root>... | inline t_type::t_type_of(const std::array<t_type_id, A_n>& a_ids, t_type* a_super, t_object* a_module, size_t a_native, size_t a_instance_fields, const std::vector<std::pair<t_root, t_rvalue>>& a_fields, const std::map<t_object*, size_t>& a_key2index) : v_this(t_object::f_of(this)), v_depth(A_n - 1), v_ids(a_ids.data()... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %rbx
leaq -0x48(%rdi), %rsi
callq 0x54f0
movq $0x1, 0x8(%rbx)
movq %rbp, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
leaq 0x28(%rbx), %rdi
movq... | /shin1m[P]xemmai/include/xemmai/object.h |
curl_msnprintf | int curl_msnprintf(char *buffer, size_t maxlength, const char *format, ...)
{
int retcode;
va_list ap_save; /* argument pointer */
va_start(ap_save, format);
retcode = curl_mvsnprintf(buffer, maxlength, format, ap_save);
va_end(ap_save);
return retcode;
} | subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x34ae
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, 0xc... | /lesstif[P]curl/lib/mprintf.c |
curlx_sztosi | int curlx_sztosi(ssize_t sznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sznum >= 0);
DEBUGASSERT((size_t) sznum <= (size_t) CURL_MASK_SINT);
return (int)(sznum & (ssize_t) CURL_MASK_SINT);
#ifdef __INTEL_COMPI... | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /lesstif[P]curl/lib/warnless.c |
Curl_base64_decode | CURLcode Curl_base64_decode(const char *src,
unsigned char **outptr, size_t *outlen)
{
size_t length = 0;
size_t equalsTerm = 0;
size_t i;
size_t numQuantums;
unsigned char lastQuantum[3];
size_t rawlen = 0;
unsigned char *newstr;
*outptr = NULL;
*outlen = 0;
while((src... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r14
xorl %ebp, %ebp
movq %rbp, (%rsi)
movq %rbp, (%rdx)
movzbl (%r14,%rbp), %eax
testl %eax, %eax
je 0x4245
cmpl $0x3d, %eax
je 0x4233
incq %rbp
jmp 0x4220
xorl %r13d, %r13d
cmpb $0x3d, 0x1(%r14,%rbp)
sete %r1... | /lesstif[P]curl/lib/base64.c |
decodeQuantum | static void decodeQuantum(unsigned char *dest, const char *src)
{
const char *s, *p;
unsigned long i, v, x = 0;
for(i = 0, s = src; i < 4; i++, s++) {
v = 0;
p = table64;
while(*p && (*p != *s)) {
v++;
p++;
}
if(*p == *s)
x = (x << 6) + v;
else if(*s == '=')
x = (x... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0xec7(%rip), %rax # 0x51d0
xorl %ecx, %ecx
movb (%rsi), %dl
movb $0x41, %r8b
xorl %edi, %edi
cmpb %dl, %r8b
je 0x432f
movb 0x1(%rdi,%rax), %r8b
incq %rdi
cmpq $0x40, %rdi
jne 0x4312
movl $0x40, %edi
cmpb %dl, %r8b
jne 0x4338
shlq $0x6, %r14
a... | /lesstif[P]curl/lib/base64.c |
Curl_base64_encode | CURLcode Curl_base64_encode(struct SessionHandle *data,
const char *inputbuff, size_t insize,
char **outptr, size_t *outlen)
{
CURLcode error;
unsigned char ibuf[3];
unsigned char obuf[4];
int i;
int inputparts;
char *output;
char *base64data;
char... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r15
xorl %eax, %eax
movq %rax, (%rcx)
movq %rax, (%r8)
testq %rdx, %rdx
jne 0x43bb
movq %r15, %rdi
callq 0x2070
movq %rax, %r12
leaq (,%r12,4), %rax
movabsq $-0x5555555555555555,... | /lesstif[P]curl/lib/base64.c |
Reset_testValueSetClear_Test::~Reset_testValueSetClear_Test() | TEST(Reset, testValueSetClear)
{
const std::string test1 =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\">\n"
" <component>\n"
" <reset variable=\"A\" test_variable=\"B\" order=\"1\"/>\n"
" </component>\n"
"</mo... | pushq %rbx
movq %rdi, %rbx
callq 0x6530
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x62d0
nop
| /cellml[P]libcellml/tests/reset/reset.cpp |
testing::internal::scoped_ptr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::reset(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | void reset(T* p = NULL) {
if (p != ptr_) {
if (IsTrue(sizeof(T) > 0)) { // Makes sure T is a complete type.
delete ptr_;
}
ptr_ = p;
}
} | cmpq %rsi, (%rdi)
je 0x11050
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
callq 0x61b0
testb %al, %al
je 0x11048
movq (%r14), %r15
testq %r15, %r15
je 0x11048
movq (%r15), %rdi
leaq 0x10(%r15), %rax
cmpq %rax, %rdi
je 0x1103b
movq (%rax), %rsi
incq %rsi
callq 0x62d0
movl $0x20, %esi
... | /cellml[P]libcellml/tests/gtest/include/gtest/gtest.h |
main | int
main(int argc, char** argv)
{
mraa_result_t ret = MRAA_SUCCESS;
mraa_platform_t platform_type = mraa_get_platform_type();
if (platform_type != MRAA_INTEL_EDISON_FAB_C) {
fprintf(stderr, "Error: This program can only run on an edison\n");
ret = MRAA_ERROR_INVALID_PLATFORM;
goto e... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %eax, %eax
callq 0x10b0
cmpl $0x2, %eax
jne 0x1278
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x1060
testq %rax, %rax
je 0x128d
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
callq 0x10d0
movq %r14, %rdi
xorl %esi, %esi
callq 0x1080
movq %r14, %rdi
callq 0x10c0
mo... | /vraoresearch[P]mraa/examples/platform/gpio_edison.c |
acesup_deckCreateWin | Card ** acesup_deckCreateWin(unsigned long * cardsCount)
{
char * cardString = strdup("2d,3d,4d,5d,13d,13h,1s,13s,2s,3s,4s,5s,6s,7s,8s,9s,10s,11s,12s,1c,2c,3c,4c,5c,6c,7c,8c,9c,10c,11c,12c,13c,2h,3h,4h,5h,6h,7h,8h,9h,10h,11h,12h,12d,6d,7d,8d,9d,10d,11d,1h,1d");
Card ** cards;
*cardsCount = 52;
cards = cards_createF... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4cfa(%rip), %rdi # 0x8004
callq 0x31f0
movq %rax, %rdi
movq %rax, %r14
movq $0x34, (%rbx)
callq 0x5882
movq %r14, %rdi
movq %rax, %rbx
callq 0x3030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /Sembiance[P]solitaire-deal-generator/src/game/acesup.c |
acesup_boardCreate | Board * acesup_boardCreate(Card ** cards, unsigned long cardsCount)
{
Board * board = board_create();
unsigned char i;
board_spotAdd(board, spot_create(STOCK, 0));
board_spotAdd(board, spot_create(FOUNDATION, 0));
for(i=0;i<4;i++)
{
board_spotAdd(board, spot_create(TABLEAU, i));
}
for(i=0;i<4;i++)
{
boa... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5bd0
movq %rax, %r14
pushq $0x1
popq %rdi
xorl %esi, %esi
xorl %r15d, %r15d
callq 0x612c
movq %r14, %rdi
movq %rax, %rsi
callq 0x5be7
pushq $0x4
popq %rdi
xorl %esi, %esi
callq 0x612c
movq %r14, %rdi
movq %rax, %rsi
callq 0x5be7
pushq $0x3
p... | /Sembiance[P]solitaire-deal-generator/src/game/acesup.c |
acesup_movePackGet | MovePack * acesup_movePackGet(Board * board)
{
MovePack * movePack = movePack_create();
unsigned char i, j;
Spot * stock = board_spotGet(board, STOCK, 0);
Spot * tableaus[4];
unsigned char suitTopRanks[4] = {0,0,0,0};
Card * card;
for(i=0;i<4;i++)
{
tableaus[i] = board_spotGet(board, TABLEAU, i);
if(tablea... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r15
callq 0x696c
movq %rax, %rbx
pushq $0x1
popq %rsi
xorl %r12d, %r12d
movq %r15, %rdi
xorl %edx, %edx
callq 0x5c76
andl $0x0, 0x14(%rsp)
movq %rax, 0x18(%rsp)
pushq $0xe
popq %r14
cmpq $0x4, %r12
je 0x348e
movzbl %r12b, %ed... | /Sembiance[P]solitaire-deal-generator/src/game/acesup.c |
klondike_isWon | bool klondike_isWon(Board * board)
{
unsigned char i;
unsigned char foundationCount = (gConfig.game->id==TRIPLEKLONDIKETURN1 || gConfig.game->id==TRIPLEKLONDIKETURN3 ? 12 : (gConfig.game->id==DOUBLEKLONDIKETURN1 || gConfig.game->id==DOUBLEKLONDIKETURN3 ? 8 : 4));
Spot * foundation;
for(i=0;i<foundationCount;i++)
{... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x1a722(%rip), %rax # 0x1f130
movq %rdi, %rbx
movq 0x28(%rax), %rax
movb (%rax), %al
movzbl %al, %ecx
leal -0x17(%rcx), %edx
cmpl $0x2, %edx
jae 0x4a26
pushq $0xc
jmp 0x4a2d
cmpl $0x5, %ecx
jne 0x4a31
pushq $0x8
popq %r14
jmp 0x4a40
xorl %ecx, %ecx
cmpb $0... | /Sembiance[P]solitaire-deal-generator/src/game/klondike.c |
klondike_updateBoard | void klondike_updateBoard(Board * board)
{
unsigned char i;
unsigned char tableauCount = (gConfig.game->id==TRIPLEKLONDIKETURN1 || gConfig.game->id==TRIPLEKLONDIKETURN3 ? 13 : (gConfig.game->id==DOUBLEKLONDIKETURN1 || gConfig.game->id==DOUBLEKLONDIKETURN3 ? 9 : 7));
Spot * tableau;
for(i=0;i<tableauCount;i++)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x1a6ac(%rip), %rax # 0x1f130
movb $0xd, %r14b
movq %rdi, %rbx
movq 0x28(%rax), %rax
movb (%rax), %al
movzbl %al, %ecx
leal -0x17(%rcx), %edx
cmpl $0x2, %edx
jb 0x4ab2
cmpl $0x5, %ecx
jne 0x4aa5
movb $0x9, %r14b
jmp 0x4ab2
cmpb $0x6, %al
sete %r14b
addb %r... | /Sembiance[P]solitaire-deal-generator/src/game/klondike.c |
pyramid_boardCreate | Board * pyramid_boardCreate(Card ** cards, unsigned long cardsCount)
{
Board * board = board_create();
unsigned char i;
board_spotAdd(board, spot_create(STOCK, 0));
board_spotAdd(board, spot_create(FOUNDATION, 0));
board_spotAdd(board, spot_create(WASTE, 0));
for(i=0;i<28;i++)
{
board_spotAdd(board, spot_cre... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x5bd0
movq %rax, %rbx
pushq $0x1
popq %rdi
xorl %esi, %esi
xorl %r15d, %r15d
callq 0x612c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5be7
pushq $0x4
popq %rdi
xorl %esi, %esi
callq 0x612c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5be7
pushq $0x2
p... | /Sembiance[P]solitaire-deal-generator/src/game/pyramid.c |
pyramid_addCombineMove | void pyramid_addCombineMove(MovePack * movePack, SPOTTYPE spot1, unsigned char spot1Index, SPOTTYPE spot2, unsigned char spot2Index)
{
MovePack * subPack = movePack_create();
movePack_add(subPack, move_create(MOVE, spot1, spot1Index, -1, FOUNDATION, 0, -1));
movePack_add(subPack, move_create(MOVE, spot2, spot2Index,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, 0x10(%rsp)
callq 0x696c
orl $-0x1, (%rsp)
movq %rax, %r14
pushq $-0x1
popq %rbx
pushq $0x4
popq %r8
movl %r12d, %edx
xorl %edi, %edi
movl %r13d, %esi
movl %ebx... | /Sembiance[P]solitaire-deal-generator/src/game/pyramid.c |
pyramid_movePackGet | MovePack * pyramid_movePackGet(Board * board)
{
MovePack * movePack = movePack_create();
Spot * stock = board_spotGet(board, STOCK, 0);
unsigned char stockCardRank = stock->cardsCount>0 ? stock->cards[stock->cardsCount-1]->rank : 0;
Spot * waste = board_spotGet(board, WASTE, 0);
unsigned char wasteCardRank = waste... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r15
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
callq 0x696c
movq %rax, %rbx
pushq $0x1
popq %rbp
movq $0x0, 0x10(%rsp)
movq %r15, 0x18(%rsp)
movq %r15, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x5c76
movzbl 0x2(%rax), ... | /Sembiance[P]solitaire-deal-generator/src/game/pyramid.c |
pyramid_isWon | bool pyramid_isWon(Board * board)
{
unsigned char i;
for(i=0;i<28;i++)
{
if(board_spotGet(board, TABLEAU, i)->cardsCount!=0)
return false;
}
if(gConfig.game->id==PYRAMIDRELAXED || gConfig.game->id==PYRAMIDRELAXEDEASY)
return true;
return board_spotGet(board, FOUNDATION, 0)->cardsCount==52;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
pushq $0x3
popq %rbp
cmpb $0x1c, %r14b
je 0x5083
movzbl %r14b, %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5c76
incb %r14b
cmpb $0x0, 0x2(%rax)
je 0x5062
xorl %eax, %eax
jmp 0x50ae
leaq 0x1a0a6(%rip), %rax # 0x1f130
movq 0x28(%rax), %rax
movb (%rax... | /Sembiance[P]solitaire-deal-generator/src/game/pyramid.c |
tripeaks_boardCreate | Board * tripeaks_boardCreate(Card ** cards, unsigned long cardsCount)
{
Board * board = board_create();
unsigned char i;
board_spotAdd(board, spot_create(STOCK, 0));
board_spotAdd(board, spot_create(FOUNDATION, 0));
for(i=0;i<28;i++)
{
board_spotAdd(board, spot_create(TABLEAU, i));
}
for(i=0;i<28;i++)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x5bd0
movq %rax, %rbx
pushq $0x1
popq %rdi
xorl %esi, %esi
xorl %r15d, %r15d
callq 0x612c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5be7
pushq $0x4
popq %rdi
xorl %esi, %esi
callq 0x612c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5be7
pushq $0x3
p... | /Sembiance[P]solitaire-deal-generator/src/game/tripeaks.c |
tripeaks_movePackGet | MovePack * tripeaks_movePackGet(Board * board)
{
MovePack * movePack = movePack_create();
Spot * stock = board_spotGet(board, STOCK, 0);
Spot * foundation = board_spotGet(board, FOUNDATION, 0);
unsigned char foundationCardRank = foundation->cardsCount>0 ? foundation->cards[foundation->cardsCount-1]->rank : 0;
unsi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r15
callq 0x696c
movq %rax, 0x10(%rsp)
pushq $0x1
popq %rsi
movq $0x0, 0x8(%rsp)
movq %r15, %rdi
xorl %edx, %edx
callq 0x5c76
movq %rax, 0x18(%rsp)
pushq $0x4
popq %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x5c76
movzbl 0x2(... | /Sembiance[P]solitaire-deal-generator/src/game/tripeaks.c |
comma_print | char * comma_print(unsigned long n)
{
int comma = '\0';
char *p;
int i = 0;
if(commaPrintBufIndex>=16)
commaPrintBufIndex = 0;
p = &commaPrintBufs[commaPrintBufIndex][sizeof(commaPrintBufs[commaPrintBufIndex])-1];
if(comma == '\0')
{
struct lconv *lcp = localeconv();
if(lcp != NULL)
{
if(lcp->thous... | pushq %r14
pushq %rbx
pushq %rax
movb 0x95ee(%rip), %al # 0xea00
movq %rdi, %rbx
cmpb $0x10, %al
jb 0x5422
xorl %eax, %eax
movb $0x0, 0x95de(%rip) # 0xea00
movzbl %al, %eax
leaq 0x95e4(%rip), %rcx # 0xea10
imulq $0x1e, %rax, %rax
leaq 0x1d(%rax,%rcx), %r14
callq 0x3080
xorl %ecx, %ecx
testq %rax, %rax
j... | /Sembiance[P]solitaire-deal-generator/src/util.c |
strchrcount | unsigned long strchrcount(char * haystack, char needle)
{
unsigned long i=0;
if(!haystack)
return 0;
while(*haystack)
{
if(*haystack==needle)
i++;
haystack++;
}
return i;
} | xorl %eax, %eax
testq %rdi, %rdi
je 0x54f7
movb (%rdi), %cl
testb %cl, %cl
je 0x54f7
xorl %edx, %edx
cmpb %sil, %cl
sete %dl
incq %rdi
addq %rdx, %rax
jmp 0x54e1
retq
| /Sembiance[P]solitaire-deal-generator/src/string_util.c |
strchrrep | char * strchrrep(char * haystack, char needle, char replacement)
{
char * c=0;
int length=0;
if(!haystack)
return haystack;
for(c=haystack,length=strlen(haystack);length;length--,c++)
{
if(*c==needle)
*c = replacement;
}
return haystack;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x552c
movq %r14, %rdi
movl %edx, %ebx
movl %esi, %ebp
callq 0x30b0
movq %r14, %rcx
movl %eax, %edx
subl $0x1, %edx
jb 0x552c
cmpb %bpl, (%rcx)
jne 0x5521
movb %bl, (%rcx)
decl %eax
jo 0x5534
incq %rcx
movl %edx, %eax
jmp 0x5515
movq %r14, %rax
popq %... | /Sembiance[P]solitaire-deal-generator/src/string_util.c |
strchrexplode | char ** strchrexplode(char * strP, char sep)
{
unsigned long count, i;
char ** array;
char * str;
char * originalstr;
if(!strP)
return 0;
str = strdup(strP);
originalstr = str;
if(strlen(str)==0)
{
strfree(originalstr);
return 0;
}
count = strchrcount(str, sep)+1;
arra... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x55e3
movl %esi, %ebp
callq 0x31f0
cmpb $0x0, (%rax)
movq %rax, %rbx
je 0x55db
movsbl %bpl, %r13d
movq %rbx, %rdi
movl %r13d, %esi
callq 0x54da
movq %rax, %r15
incq %r15
leaq 0x10(,%rax,8), %rsi
pushq $0x1
popq %r12
movq %... | /Sembiance[P]solitaire-deal-generator/src/string_util.c |
randinit | void randinit(unsigned int seed)
{
struct timeval now;
gettimeofday(&now, 0);
initstate(seed, seedState, 256);
initstate(mix(now.tv_usec, clock(), getpid()), unseededState, 256);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rsp), %r14
movl %edi, %ebx
xorl %esi, %esi
movq %r14, %rdi
callq 0x30d0
leaq 0x95e9(%rip), %rsi # 0xec00
movl $0x100, %edx # imm = 0x100
movl %ebx, %edi
callq 0x3060
movq 0x8(%r14), %r14
callq 0x30a0
movq %rax, %rbx
callq 0x3090
cltq
subq %rbx, %r14
subq ... | /Sembiance[P]solitaire-deal-generator/src/rand.c |
card_createFromId | Card * card_createFromId(char * id)
{
char rank[3] = {0, 0, 0};
rank[0] = id[0];
char suit = id[1];
if(strlen(id)==3)
{
rank[1] = id[1];
suit = id[2];
}
return card_create(atoi(rank), (suit=='s' ? SPADE : (suit=='c' ? CLUB : (suit=='h' ? HEART : DIAMOND))), true);
} | pushq %rbp
pushq %rbx
pushq %rax
andw $0x0, 0x6(%rsp)
movq %rdi, %rbx
movb (%rdi), %al
movb %al, 0x5(%rsp)
movb 0x1(%rdi), %bpl
callq 0x30b0
cmpq $0x3, %rax
jne 0x5808
movb %bpl, 0x6(%rsp)
movb 0x2(%rbx), %bpl
leaq 0x5(%rsp), %rdi
callq 0x3180
cmpb $0x63, %bpl
je 0x582e
movzbl %bpl, %edx
movb $0x3, %cl
cmpl $0x73, %edx... | /Sembiance[P]solitaire-deal-generator/src/card.c |
cards_reverse | void cards_reverse(Card ** cards, unsigned char cardsCount)
{
unsigned char start=0;
unsigned char end=cardsCount-1;
Card * card;
while(start<end)
{
card = cards[start];
cards[start] = cards[end];
cards[end] = card;
start++;
end--;
}
} | decb %sil
xorl %eax, %eax
movzbl %sil, %ecx
cmpq %rcx, %rax
jae 0x5881
movq (%rdi,%rax,8), %rdx
movq (%rdi,%rcx,8), %rsi
movq %rsi, (%rdi,%rax,8)
movq %rdx, (%rdi,%rcx,8)
incq %rax
leal -0x1(%rcx), %esi
jmp 0x5860
retq
| /Sembiance[P]solitaire-deal-generator/src/card.c |
cards_createFromIds | Card ** cards_createFromIds(char * idAsString)
{
unsigned long cardCount = strchrcount(idAsString, ',')+1;
char ** ids = strchrexplode(idAsString, ',');
char ** id;
unsigned long i;
Card ** cards = (Card **)malloc(sizeof(Card *)*cardCount);
for(i=0,id=ids;*id;id++,i++)
{
cards[i] = card_createFromId(*id);
f... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2c
popq %rbp
movl %ebp, %esi
callq 0x54da
movq %rax, %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5539
leaq 0x8(,%r14,8), %rdi
movq %rax, %rbx
callq 0x3130
movq %rax, %r14
xorl %r15d, %r15d
movq (%rbx,%r15), %rdi
testq %rdi, %rdi
je 0x58da
... | /Sembiance[P]solitaire-deal-generator/src/card.c |
cards_createDeck | Card ** cards_createDeck(unsigned char decksCount)
{
unsigned char i, d;
Card ** cards = (Card **)malloc(sizeof(Card *)*(52*decksCount));
for(d=0;d<decksCount;d++)
{
for(i=1;i<=13;i++)
{
cards[((i-1)*4)+(d*52)] = card_create(i, CLUB, true);
cards[((i-1)*4)+1+(d*52)] = card_create(i, DIAMOND, true);
ca... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %eax
imulq $0x1a0, %rax, %rdi # imm = 0x1A0
movq %rax, 0x8(%rsp)
callq 0x3130
movq %rax, %r13
xorl %ecx, %ecx
pushq $0x1
popq %rbp
pushq $0x2
popq %r14
pushq $0x3
popq %r15
movq %rax, (%rsp)
cmpq 0x8(%rsp), %rcx
je 0x59a4... | /Sembiance[P]solitaire-deal-generator/src/card.c |
card_print | char * card_print(Card * card, bool showDownCard)
{
if(cardPrintBufIndex>=255)
cardPrintBufIndex = 0;
if(!card->faceUp && !showDownCard)
sprintf(cardPrintBufs[cardPrintBufIndex], "BACK");
else
sprintf(cardPrintBufs[cardPrintBufIndex], "%3d%c", card->rank, SUIT_CHAR[card->suit]);
cardPrintBufIndex++;
return... | movb 0x9443(%rip), %cl # 0xee00
cmpb $-0x1, %cl
jne 0x59cb
xorl %ecx, %ecx
movb $0x0, 0x9435(%rip) # 0xee00
pushq %rbx
orb 0x3(%rdi), %sil
movzbl %cl, %eax
leaq 0x9436(%rip), %rbx # 0xee10
leaq (%rax,%rax,4), %rax
addq %rbx, %rax
testb %sil, %sil
je 0x5a11
movzbl 0x1(%rdi), %ecx
leaq 0x2791(%rip), %rsi ... | /Sembiance[P]solitaire-deal-generator/src/card.c |
cards_printAsDeck | void cards_printAsDeck(Card ** cards, unsigned char cardsCount)
{
unsigned char i;
printf("[");
for(i=0;i<cardsCount;i++)
{
if(i>0)
printf(",");
printf("\"%d%c\"", cards[i]->rank, SUIT_CHAR[cards[i]->suit]);
}
printf("]");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x5b
popq %rdi
callq 0x3040
leaq 0x2732(%rip), %r12 # 0x8182
leaq 0x2724(%rip), %r14 # 0x817b
movl %ebp, %r15d
pushq $0x2c
popq %rbp
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x5a90
testq %r13, %r13
... | /Sembiance[P]solitaire-deal-generator/src/card.c |
cards_print | char * cards_print(Card ** cards, unsigned char cardsCount, bool showDownCards)
{
unsigned char i;
if(cardsPrintBufIndex>=255)
cardsPrintBufIndex = 0;
memset(cardsPrintBufs[cardsPrintBufIndex], 0, 255);
for(i=0;i<cardsCount;i++)
{
if(i>0)
strcat(cardsPrintBufs[cardsPrintBufIndex], " ");
strcat(cardsPri... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb 0x9854(%rip), %al # 0xf30b
movq %rdi, (%rsp)
cmpb $-0x1, %al
jne 0x5ac8
xorl %eax, %eax
movb $0x0, 0x9843(%rip) # 0xf30b
movzbl %al, %eax
leaq 0x983e(%rip), %rbx # 0xf310
vxorps %xmm0, %xmm0, %xmm0
movzbl %sil, %r12d
movzb... | /Sembiance[P]solitaire-deal-generator/src/card.c |
board_free | void board_free(Board * board)
{
unsigned char i;
if(board->gameState!=0 && gConfig.game->freeGameState!=0)
gConfig.game->freeGameState(board);
for(i=0;i<board->spotsCount;i++)
{
spot_free(board->spots[i]);
}
free(board->spots);
free(board);
} | pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x10(%rdi)
movq %rdi, %rbx
je 0x5c45
leaq 0x19500(%rip), %rax # 0x1f130
movq 0x28(%rax), %rax
movq 0x140(%rax), %rax
testq %rax, %rax
je 0x5c45
movq %rbx, %rdi
callq *%rax
xorl %r14d, %r14d
movzbl (%rbx), %eax
movq 0x8(%rbx), %rdi
cmpq %rax, %r14
jae 0x5c62
movq (%rdi,%r1... | /Sembiance[P]solitaire-deal-generator/src/board.c |
board_spotGet | Spot * board_spotGet(Board * board, SPOTTYPE spotType, unsigned char spotIndex)
{
unsigned char i;
Spot * spot;
for(i=0;i<board->spotsCount;i++)
{
spot = board->spots[i];
if(spot->type==spotType && spot->index==spotIndex)
return spot;
}
return 0;
} | movzbl (%rdi), %ecx
xorl %r8d, %r8d
cmpq %rcx, %r8
jae 0x5c98
movq 0x8(%rdi), %rax
movq (%rax,%r8,8), %rax
cmpb %sil, (%rax)
jne 0x5c93
cmpb %dl, 0x1(%rax)
je 0x5c9a
incq %r8
jmp 0x5c7c
xorl %eax, %eax
retq
| /Sembiance[P]solitaire-deal-generator/src/board.c |
board_print | void board_print(Board * board, bool showDownCards)
{
unsigned char i, j, spotTypesCount;
Spot * spot;
SPOTTYPE spotType;
SPOTTYPE * spotTypes = board_getSpotTypes(board, &spotTypesCount);
for(i=0;i<spotTypesCount;i++)
{
spotType = spotTypes[i];
for(j=0;j<board->spotsCount;j++)
{
spot = board->spots[j];... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0xf(%rsp), %r15
movl %esi, %ebp
movq %rdi, %rbx
movq %r15, %rsi
callq 0x5cb7
movzbl (%r15), %r15d
movzbl %bpl, %ebp
xorl %r12d, %r12d
movq %rax, 0x10(%rsp)
cmpq %r15, %r12
jae 0x5d93
movq 0x10(%rsp), %rax
xorl %r14d, %r14d
movb (%ra... | /Sembiance[P]solitaire-deal-generator/src/board.c |
board_printKlondikeSolverDeck | void board_printKlondikeSolverDeck(Board * board)
{
int i,j;
Spot * spot;
for(i=0;i<7;i++)
{
for(j=0;j<7;j++)
{
spot = board_spotGet(board, TABLEAU, j);
if(spot->cardsCount>=(i+1))
printf("%02d%d", spot->cards[i]->rank, spot->cards[i]->suit+1);
}
}
spot = board_spotGet(board, STOCK, 0);
for(i=s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x3
popq %rbp
leaq 0x23c3(%rip), %r14 # 0x8186
xorl %r15d, %r15d
cmpq $0x7, %r15
je 0x5e15
leaq 0x1(%r15), %r12
xorl %r13d, %r13d
cmpl $0x7, %r13d
je 0x5e10
movzbl %r13b, %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0... | /Sembiance[P]solitaire-deal-generator/src/board.c |
board_moveLinkMake | void board_moveLinkMake(Board * board, MoveLink * lastLink)
{
Move * moveLinks[2048];
long i=0;
while(lastLink)
{
moveLinks[i++] = lastLink->move;
lastLink = lastLink->prev;
}
for(--i;i>=0;i--)
{
board_moveMake(board, moveLinks[i]);
}
} | pushq %r14
pushq %rbx
subq $0x4008, %rsp # imm = 0x4008
movq %rdi, %rbx
xorl %r14d, %r14d
testq %rsi, %rsi
je 0x609c
movq %r14, %rax
incq %rax
jo 0x60ac
movq (%rsi), %rcx
movq %rcx, (%rsp,%r14,8)
movq %rax, %r14
movq 0x8(%rsi), %rsi
jmp 0x606f
movq -0x8(%rsp,%r14,8), %rsi
movq %rbx, %rdi
decq %r14
callq 0x5ef... | /Sembiance[P]solitaire-deal-generator/src/board.c |
board_boardAddDups | Board ** board_boardAddDups(Board ** boards, unsigned long boardsCount, Board * board, unsigned long boardNumToAdd)
{
unsigned long i;
boards = (Board **)realloc(boards, sizeof(Board *)*(boardsCount+boardNumToAdd));
for(i=0;i<boardNumToAdd;i++)
{
boards[boardsCount+i] = board_dup(board);
}
return boards;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
addq %rcx, %rsi
movq %rcx, %rbx
movq %rdx, %r14
shlq $0x3, %rsi
callq 0x3140
leaq (%rax,%r12,8), %r12
movq %rax, %r15
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x60ee
movq %r14, %rdi
callq 0x5e6d
movq %rax, (%r12,%r13,8)
incq %r13
jmp 0x60d8
movq %r15, %... | /Sembiance[P]solitaire-deal-generator/src/board.c |
spot_free | void spot_free(Spot * spot)
{
unsigned char i;
for(i=0;i<spot->cardsCount;i++)
{
card_free(spot->cards[i]);
}
free(spot->cards);
free(spot);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movzbl 0x2(%rbx), %eax
movq 0x8(%rbx), %rdi
cmpq %rax, %r14
jae 0x6176
movq (%rdi,%r14,8), %rdi
callq 0x5844
incq %r14
jmp 0x615b
callq 0x3030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3030
| /Sembiance[P]solitaire-deal-generator/src/spot.c |
spot_dup | Spot * spot_dup(Spot * spot)
{
unsigned char i;
Spot * dupSpot = spot_create(spot->type, spot->index);
dupSpot->cards = (Card **)malloc(sizeof(Card *)*spot->cardsCount);
dupSpot->cardsCount = spot->cardsCount;
for(i=0;i<spot->cardsCount;i++)
{
dupSpot->cards[i] = card_dup(spot->cards[i]);
}
return dupSpot;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movzbl (%rdi), %edi
movzbl 0x1(%rbx), %esi
callq 0x612c
movzbl 0x2(%rbx), %ebp
movq %rax, %r14
movl %ebp, %edi
shll $0x3, %edi
callq 0x3130
movq %rax, 0x8(%r14)
movq %rax, %r15
xorl %r12d, %r12d
movb %bpl, 0x2(%r14)
movzbl %bpl, %eax
cmpq %rax, %r12... | /Sembiance[P]solitaire-deal-generator/src/spot.c |
spot_moveCards | void spot_moveCards(Spot * fromSpot, unsigned char fromCardsIndex, unsigned char cardsToMoveCount, Spot * toSpot, unsigned char toCardsIndex, bool reverseCards)
{
unsigned char displacedCardsCount = toSpot->cardsCount>0 && toCardsIndex<toSpot->cardsCount ? toSpot->cardsCount-toCardsIndex : 0;
//printf("%d from %s%d %... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movzbl 0x2(%rcx), %r15d
movq %rdi, %rbx
movq 0x8(%rcx), %rdi
movl %esi, %r13d
movl %r9d, 0x4(%rsp)
movl %r8d, %r12d
movq %rcx, %r14
movl %edx, %ebp
movl %r15d, %esi
addl %edx, %esi
shll $0x3, %esi
callq 0x3140
movq %rax, 0x8(%r14)
cmpb %r12b, ... | /Sembiance[P]solitaire-deal-generator/src/spot.c |
move_create | Move * move_create(MOVETYPE type, SPOTTYPE fromSpotType, unsigned char fromSpotIndex, int fromSpotCardIndex, SPOTTYPE toSpotType, unsigned char toSpotIndex, int toSpotCardIndex)
{
Move * move = (Move *)malloc(sizeof(Move));
move->type = type;
move->fromSpotType = fromSpotType;
move->fromSpotIndex = fromSpotIndex;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movl %edi, %r13d
pushq $0x18
popq %rdi
callq 0x3130
movl 0x40(%rsp), %ecx
movb %r13b, (%rax)
movb %r12b, 0x1(%rax)
movb %r15b, 0x2(%rax)
movl %r14d, 0x4(%rax)
m... | /Sembiance[P]solitaire-deal-generator/src/move.c |
move_dup | Move * move_dup(Move * move)
{
Move * dupMove = move_create(move->type, move->fromSpotType, move->fromSpotIndex, move->fromSpotCardIndex, move->toSpotType, move->toSpotIndex, move->toSpotCardIndex);
if(move->movePack!=0)
dupMove->movePack = movePack_dup(move->movePack);
return dupMove;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movzbl (%rdi), %edi
movzbl 0x1(%r14), %esi
movzbl 0x2(%r14), %edx
movzbl 0x8(%r14), %r8d
movzbl 0x9(%r14), %r9d
movl 0x4(%r14), %ecx
movl 0xc(%r14), %eax
movl %eax, (%rsp)
callq 0x6340
movq 0x10(%r14), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0x6403
callq 0x640e
movq %ra... | /Sembiance[P]solitaire-deal-generator/src/move.c |
movePack_dup | MovePack * movePack_dup(MovePack * movePack)
{
unsigned long i;
MovePack * dupMovePack = movePack_create();
dupMovePack->moves = (Move **)malloc(sizeof(Move *)*movePack->movesCount);
dupMovePack->movesCount = movePack->movesCount;
for(i=0;i<movePack->movesCount;i++)
{
dupMovePack->moves[i] = move_dup(movePack->... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x696c
movq (%rbx), %r13
movq %rax, %r14
leaq (,%r13,8), %rdi
callq 0x3130
movq %rax, 0x8(%r14)
movq %rax, %r15
xorl %r12d, %r12d
movq %r13, (%r14)
cmpq %r13, %r12
jae 0x645d
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x63c0
movq %rax... | /Sembiance[P]solitaire-deal-generator/src/move.c |
movePack_print_json | void movePack_print_json(MovePack * movePack)
{
unsigned char i;
printf("[");
for(i=0;i<movePack->movesCount;i++)
{
if(i>0)
printf(",");
move_print_json(movePack->moves[i]);
}
printf("]");
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x5b
popq %rdi
callq 0x3040
xorl %eax, %eax
pushq $0x2c
popq %rbp
movzbl %al, %r14d
cmpq %r14, (%rbx)
jbe 0x64a6
testq %r14, %r14
je 0x6493
movl %ebp, %edi
callq 0x3040
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x64b2
leal 0x1(%r14), %eax
jmp 0x647e
push... | /Sembiance[P]solitaire-deal-generator/src/move.c |
move_print | void move_print(Board * board, Move * move, bool indent)
{
char buf[1024];
Spot * fromSpot = (move->type==MULTIPLE ? 0 : board_spotGet(board, move->fromSpotType, move->fromSpotIndex));
Spot * toSpot = (move->type==MOVE || move->type==MOVEREVERSED ? board_spotGet(board, move->toSpotType, move->toSpotIndex) : 0);
uns... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp # imm = 0x418
cmpb $0x3, (%rsi)
movq %rsi, %rbx
movq %rdi, %r14
jne 0x657e
testb %dl, %dl
pushq $0x9
popq %rax
pushq $0x20
popq %rsi
cmovnel %eax, %esi
leaq 0x1d4a(%rip), %rdi # 0x82a1
xorl %eax, %eax
callq 0x30c0
movq 0... | /Sembiance[P]solitaire-deal-generator/src/move.c |
movePack_free | void movePack_free(MovePack * movePack, bool freeMoves)
{
unsigned long i;
if(!movePack)
return;
if(freeMoves)
{
for(i=0;i<movePack->movesCount;i++)
{
move_free(movePack->moves[i]);
}
}
free(movePack->moves);
free(movePack);
} | testq %rdi, %rdi
je 0x696b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb %sil, %sil
je 0x6953
xorl %r14d, %r14d
cmpq (%rbx), %r14
jae 0x6953
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x690a
incq %r14
jmp 0x693c
movq 0x8(%rbx), %rdi
callq 0x3030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp ... | /Sembiance[P]solitaire-deal-generator/src/move.c |
games_load | void games_load(void)
{
acesup_load();
easthaven_load();
freecell_load();
klondike_load();
pyramid_load();
tripeaks_load();
} | pushq %rax
callq 0x35ca
callq 0x3bf2
callq 0x42cf
callq 0x4af8
callq 0x50b3
popq %rax
jmp 0x53a2
| /Sembiance[P]solitaire-deal-generator/src/game.c |
add_game | void add_game(Game * game)
{
gamesCount++;
// cppcheck-suppress memleakOnRealloc
games = (Game **)realloc(games, sizeof(Game *)*gamesCount);
games[(gamesCount-1)] = game;
} | pushq %rbx
movq 0x186a8(%rip), %rax # 0x1f120
movq %rdi, %rbx
movq 0x18696(%rip), %rdi # 0x1f118
leaq 0x8(,%rax,8), %rsi
leaq 0x1(%rax), %rcx
movq %rcx, 0x1868b(%rip) # 0x1f120
callq 0x3140
movq 0x1867f(%rip), %rcx # 0x1f120
movq %rax, 0x18670(%rip) # 0x1f118
movq %rbx, -0x8(%rax,%rcx,8)
popq %rbx
r... | /Sembiance[P]solitaire-deal-generator/src/game.c |
game_deckCreate | Card ** game_deckCreate(unsigned long * cardsCount)
{
Card ** cards = cards_createDeck(gConfig.game->numDecks);
*cardsCount = (gConfig.game->numDecks*52);
cards_shuffle(cards, *cardsCount);
return cards;
} | pushq %r15
pushq %r14
pushq %rbx
leaq 0x185e5(%rip), %r15 # 0x1f130
movq %rdi, %rbx
movq 0x28(%r15), %rax
movzbl 0x110(%rax), %edi
callq 0x58f0
movq 0x28(%r15), %rcx
movq %rax, %r14
movq %r14, %rdi
movzbl 0x110(%rcx), %eax
imulq $0x34, %rax, %rax
movzbl %al, %esi
movq %rax, (%rbx)
callq 0x5b95
movq %r14, %rax
popq ... | /Sembiance[P]solitaire-deal-generator/src/game.c |
sim | void sim(void)
{
unsigned long i;
pthread_t threads[gConfig.threadCount];
Board * startBoard;
Board * winningStartBoard;
Results * results;
Results * totalResults = results_create();
Card ** cards;
MovePack * movePack;
unsigned long cardsCount=0;
if(gConfig.game->deckCreate==0)
cards = game_deckCreate(&car... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x183d3(%rip), %r13 # 0x1f130
movq %rsp, %rcx
movq 0x18(%r13), %rax
leaq 0xf(,%rax,8), %rax
andq $-0x10, %rax
subq %rax, %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, %rsp
callq 0x6a34
movq 0x28(%r13), %rcx
andq $0x0, -... | /Sembiance[P]solitaire-deal-generator/src/sim.c |
usage | static void usage(void)
{
fprintf(stderr,
"sim %s\n"
"\n"
"Usage: sim [OPTIONS] GAMEID\n"
" --seed <n> Seed to use for random number generator\n"
" --iterations <n> Number of iterations to perform.\n"
" --maxDepth <n> Maximum depth to randomly crawl into a move tree b... | pushq %rbx
movq 0x4c32(%rip), %rbx # 0xbff8
leaq 0x11c8(%rip), %rsi # 0x8595
leaq 0x117b(%rip), %rdx # 0x854f
xorl %eax, %eax
movq (%rbx), %rdi
callq 0x3100
movq (%rbx), %rcx
leaq 0x13fd(%rip), %rdi # 0x87e5
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
callq 0x31c0
callq 0x6afa
pushq $0x1
popq %rdi
cal... | /Sembiance[P]solitaire-deal-generator/src/main.c |
add_passes(backend::Backend&) | void add_passes(backend::Backend& backend) {
backend.add_pass(std::make_unique<optimization::sanity_check::SanityCheck>());
backend.add_pass(
std::make_unique<optimization::remove_temp_var::Remove_Temp_Var>());
backend.add_pass(
std::make_unique<optimization::const_propagation::Const_Propagation>());
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdi, %rbx
movl $0x10, %edi
callq 0xc3c0
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
leaq 0xdcbd9(%rip), %rcx # 0xedfe0
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
leaq 0x170(%rsp), %rsi
movq %rax, (%rsi)
leaq 0... | /segviol[P]indigo/main.cpp |
AixLog::operator<<(std::ostream&, AixLog::Timestamp const&) | static std::ostream& operator<<(std::ostream& os, const Timestamp& timestamp) {
Log* log = dynamic_cast<Log*>(os.rdbuf());
if (log != nullptr) {
std::lock_guard<std::recursive_mutex> lock(log->mutex_);
log->metadata_.timestamp = timestamp;
} else if (timestamp) {
os << timestamp.to_string();
}
ret... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0xda1b0(%rip), %rax # 0xf0f28
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq 0xe8(%rax,%rcx), %rdi
testq %rdi, %rdi
je 0x16da6
movq 0xda23d(%rip), %rsi # 0xf0fd0
leaq 0xd70ee(%rip), %rdx # 0xede88
xorl %ecx, %ecx
callq 0xc420
movq %rax, %... | /segviol[P]indigo/backend/codegen/../../include/aixlog.hpp |
argparse::Argument& argparse::ArgumentParser::add_argument<char const*, char const*>(char const*, char const*) | Argument &add_argument(Targs... Fargs) {
using array_of_sv = std::string_view[sizeof...(Targs)];
auto tArgument = mOptionalArguments.emplace(cend(mOptionalArguments),
array_of_sv{Fargs...});
if (!tArgument->mIsOptional)
mPositionalArguments.splice(cend(... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x98(%rdi), %r14
movq %rsi, %rdi
callq 0xc140
movq %rsp, %r13
movq %rax, (%r13)
movq %r12, 0x8(%r13)
movq %r15, %rdi
callq 0xc140
movq %rax, 0x10(%r13)
movq %r15, 0x18(%r13)
movq %r14, %rdi
movq ... | /segviol[P]indigo/include/argparse/argparse.hpp |
_gnu_cxx::__normal_iterator<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>>>>> argparse::Argume... | void operator()(void_action &f) {
std::for_each(start, end, f);
if (!self.mDefaultValue.has_value()) {
if (auto expected = self.maybe_nargs())
self.mValues.resize(*expected);
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x1ab90
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x1ab18
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x1aaa0
leaq 0x28(%rsp), %r... | /segviol[P]indigo/include/argparse/argparse.hpp |
argparse::operator<<(std::ostream&, argparse::Argument const&) | std::ostream &operator<<(std::ostream &stream,
const Argument &argument) {
std::stringstream nameStream;
std::copy(std::begin(argument.mNames), std::end(argument.mNames),
std::ostream_iterator<std::string>(nameStream, " "));
stream << nameStream.str() << "\t" ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0xc270
movq (%r14), %r15
movq 0x8(%r14), %r13
leaq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xa11af(%rip), %rax # 0xbc552
movq %rax, 0x10(%rsp)
subq %r15, %... | /segviol[P]indigo/include/argparse/argparse.hpp |
optimization::remove_temp_var::Remove_Temp_Var::pass_name[abi:cxx11]() const | std::string pass_name() const { return name; } | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x38(%rsi), %rax
movq 0x40(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x18456
movq %rbx, %rax
popq %rbx
retq
nop
| /segviol[P]indigo/backend/optimization/remove_temp_var.hpp |
optimization::var_mir_fold::VarMirFold::optimize_mir(mir::inst::MirPackage&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::any, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<c... | void optimize_mir(mir::inst::MirPackage& package,
std::map<std::string, std::any>& extra_data_repo) {
for (auto& i : package.functions) {
if (!i.second.type->is_extern) {
optimize_func(i.first, i.second);
}
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x20(%rsi), %r15
addq $0x10, %rbx
cmpq %rbx, %r15
je 0x1ea10
movq %rdi, %r14
movq 0x68(%r15), %rax
cmpb $0x0, 0x30(%rax)
jne 0x1ea00
leaq 0x20(%r15), %rsi
leaq 0x40(%r15), %rdx
movq %r14, %rdi
callq 0x1ea5c
movq %r15, %rdi
callq 0xc260
movq %rax, %r15
cmpq %rbx, %ra... | /segviol[P]indigo/backend/optimization/var_mir_fold.hpp |
optimization::remove_dead_code::Remove_Dead_Code::optimize_mir(mir::inst::MirPackage&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::any, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basi... | void optimize_mir(mir::inst::MirPackage& package,
std::map<std::string, std::any>& extra_data_repo) {
for (auto iter = package.functions.begin(); iter != package.functions.end();
++iter) {
optimize_func(iter->first, iter->second);
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq 0x20(%rsi), %r15
addq $0x10, %rbx
cmpq %rbx, %r15
je 0x1f596
movq %rdi, %r14
leaq 0x10(%rsp), %r13
movq %rsp, %r12
movq %r13, (%rsp)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x18456
leaq... | /segviol[P]indigo/backend/optimization/remove_dead_code.hpp |
optimization::remove_dead_code::Remove_Dead_Code::remove_dead_code(std::shared_ptr<optimization::livevar_analyse::Block_Live_Var>, mir::inst::BasicBlk&, std::map<unsigned int, mir::inst::Variable, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, mir::inst::Variable>>>&) | bool remove_dead_code(std::shared_ptr<livevar_analyse::Block_Live_Var> blv,
mir::inst::BasicBlk& block,
std::map<uint32_t, mir::inst::Variable>& vartable) {
bool modify = false;
auto tmp = blv->live_vars_out;
for (auto riter = block.inst.rbegin(); riter != blo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq (%rsi), %rax
movq 0x28(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x30(%rax), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x1f93a
movq 0xd1664(%rip), %rcx # 0xf0f90
cmpb $0x0, (%rcx... | /segviol[P]indigo/backend/optimization/remove_dead_code.hpp |
optimization::var_replace::Var_Replace::add_usepoint(mir::inst::VarId, int, int) | void add_usepoint(mir::inst::VarId var, mir::types::LabelId labelId,
int idx) {
if (!usepoints.count(var)) {
usepoints.insert(
{var, std::vector<std::pair<mir::types::LabelId, int>>()});
}
usepoints.at(var).push_back({labelId, idx});
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
addq $0x8, %r15
movq %r15, %rdi
callq 0x207b4
testq %rax, %rax
jne 0x2076b
leaq 0xcd928(%rip), %rax # 0xee058
movq %rsp, %rsi
movq %rax, (%rsi)
movl 0x8(%r14), %eax
movl %eax, 0x8(%rsi)
xorps... | /segviol[P]indigo/backend/optimization/./var_replace.hpp |
mir::inst::JumpInstruction::useVars() | std::set<VarId> useVars() {
std::set<VarId> s;
if (cond_or_ret.has_value()) {
s.insert(cond_or_ret.value());
}
return s;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
cmpb $0x1, 0x20(%rsi)
jne 0x220dc
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x20cf2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
po... | /segviol[P]indigo/backend/../mir/mir.hpp |
optimization::inlineFunc::Inline_Func::pass_name[abi:cxx11]() const | std::string pass_name() const { return name; } | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x68(%rsi), %rax
movq 0x70(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x18456
movq %rbx, %rax
popq %rbx
retq
nop
| /segviol[P]indigo/backend/optimization/inline.hpp |
optimization::inlineFunc::Inline_Func::optimize_mir(mir::inst::MirPackage&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::any, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<ch... | void optimize_mir(mir::inst::MirPackage& package,
std::map<std::string, std::any>& extra_data_repo) {
init(package);
for (auto iter = package.functions.begin(); iter != package.functions.end();
iter++) {
optimize_func(iter->first, iter->second, package.functions);
}
st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rsi, %r13
movq %rdi, %rbx
callq 0x23988
leaq 0x8(%r13), %rax
movq %rax, 0xf8(%rsp)
movq 0x20(%r13), %r15
leaq 0x10(%r13), %r14
cmpq %r14, %r15
je 0x23098
leaq 0x138(%rsp), %rbp
leaq 0x128(%rsp), %r12
movq ... | /segviol[P]indigo/backend/optimization/inline.hpp |
optimization::inlineFunc::Rewriter::cast_value(mir::inst::Value) | mir::inst::Value cast_value(mir::inst::Value val) {
if (val.index() == 0) {
return std::get<int>(val);
}
return mir::inst::VarId(
var_cast_map.at(std::get<mir::inst::VarId>(val).id));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdx), %rdi
cmpb $0x0, 0x18(%rdx)
je 0x26d01
movq %rsi, %r14
addq $0x10, %r14
callq 0x1deb4
movl 0x8(%rax), %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x26480
movl (%rax), %eax
leaq 0xc7364(%rip), %rcx # 0xee058
movq %rcx, 0x8(%rbx)
mo... | /segviol[P]indigo/backend/optimization/inline.hpp |
mir::inst::CallInst::CallInst(mir::inst::VarId, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<mir::inst::Value, std::allocator<mir::inst::Value>>) | CallInst(VarId _dest, std::string _func, std::vector<Value> _params)
: Inst(_dest), func(_func), params(_params) {} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %r15
movl 0x8(%rsi), %eax
leaq 0xc6ab6(%rip), %rcx # 0xee058
movq %rcx, 0x8(%rdi)
movl %eax, 0x10(%rdi)
leaq 0xc8b78(%rip), %rax # 0xf0128
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x18(%rdi), %rbx
leaq 0x28(%rdi), %r12
movq %r12, 0... | /segviol[P]indigo/backend/../mir/mir.hpp |
mir::inst::CallInst::~CallInst() | virtual ~CallInst() {} | pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x276cb
movq 0x48(%rbx), %rsi
subq %rdi, %rsi
callq 0xc3d0
movq 0x18(%rbx), %rdi
addq $0x28, %rbx
cmpq %rbx, %rdi
je 0x276e4
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0xc3d0
popq %rbx
retq
| /segviol[P]indigo/backend/../mir/mir.hpp |
optimization::mergeBlocks::Merge_Block::optimize_func(mir::inst::MirFunction&) | void optimize_func(mir::inst::MirFunction& func) {
while (true) {
bool flag = false;
for (auto& blkiter : func.basic_blks) {
auto& blk = blkiter.second;
if (blk.id > 100000) {
continue;
}
if (blk.preceding.size() == 1) {
auto& preBlk = func.basic_blks.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x68(%rsi), %r14
movq %rsi, 0x18(%rsp)
leaq 0x70(%rsi), %r15
movq %r14, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x80(%rax), %r12
xorl %ebx, %ebx
cmpq %r15, %r12
je 0x281c7
movl $0x5, %ebp
cmpl $0x186a0, 0x30(%r12) # imm = 0x186A0
j... | /segviol[P]indigo/backend/optimization/block_merge.hpp |
optimization::common_expr_del::Common_Expr_Del::Common_Expr_Del(bool) | Common_Expr_Del(bool offset_inst = false) : offset_inst(offset_inst) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xc6240(%rip), %rax # 0xee478
movq %rax, (%rdi)
movb %sil, 0x8(%rdi)
leaq 0x18(%rdi), %rax
movl $0x0, 0x18(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movq %rcx, 0x38(%rdi)
addq $0x40, %rdi
leaq 0x50(%rbx), %rax
movq %... | /segviol[P]indigo/backend/optimization/common_expression_delete.hpp |
optimization::common_expr_del::Common_Expr_Del::optimize_mir(mir::inst::MirPackage&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::any, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_... | void optimize_mir(mir::inst::MirPackage& package,
std::map<std::string, std::any>& extra_data_repo) {
init_funcs(package);
for (auto iter = package.functions.begin(); iter != package.functions.end();
++iter) {
optimize_func(iter->second);
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x28370
movq 0x20(%rbx), %r15
addq $0x10, %rbx
cmpq %rbx, %r15
je 0x282f7
leaq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0x284f6
movq %r15, %rdi
callq 0xc260
movq %rax, %r15
cmpq %rbx, %rax
jne 0x282db
popq %rbx
popq %r14
popq %r15
retq
nop
| /segviol[P]indigo/backend/optimization/common_expression_delete.hpp |
optimization::common_expr_del::BlockNodes::cast_operands[abi:cxx11](std::vector<mir::inst::Value, std::allocator<mir::inst::Value>>) | std::vector<Operand> cast_operands(std::vector<mir::inst::Value> value) {
std::vector<Operand> operands;
for (auto val : value) {
if (val.index() == 0) {
operands.push_back(std::get<int>(val));
} else {
auto var = std::get<mir::inst::VarId>(val);
if (!query_var(var)) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x8(%rsp)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rbp
movq 0x8(%rdx), %r12
cmpq %r12, %rbp
je 0x2a575
leaq 0x80(%rsp), %r15
movq 0x10(%rsp), %rax
leaq 0x20(%rax), %rcx
... | /segviol[P]indigo/backend/optimization/common_expression_delete.hpp |
optimization::common_expr_del::BlockNodes::query_node(std::variant<mir::inst::Op, optimization::common_expr_del::ExtraNormOp, optimization::common_expr_del::InNormOp>, std::vector<std::variant<int, optimization::common_expr_del::NodeId, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, st... | bool query_node(Op op, std::vector<Operand> operands) {
Node node(op, operands);
return node_map.count(node);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x2a73e
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2d0e4
movq %rsp, %rdi
callq 0x2a5ee
leaq 0x50(%rbx), %rdi
leaq 0x18(%rsp), %r... | /segviol[P]indigo/backend/optimization/common_expression_delete.hpp |
optimization::common_expr_del::BlockNodes::add_node(std::variant<mir::inst::Op, optimization::common_expr_del::ExtraNormOp, optimization::common_expr_del::InNormOp>, std::vector<std::variant<int, optimization::common_expr_del::NodeId, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std:... | NodeId add_node(Op op, std::vector<Operand> operands, mir::inst::VarId var) {
auto nodeId = add_node(op, operands);
add_var(var, nodeId.id);
return nodeId;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x2a73e
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2aa8c
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x2a5ee
leaq 0xc383a(%rip), ... | /segviol[P]indigo/backend/optimization/common_expression_delete.hpp |
optimization::common_expr_del::BlockNodes::add_var(mir::inst::VarId, optimization::common_expr_del::NodeId) | void add_var(mir::inst::VarId var, NodeId nodeId) {
var_map[var] = nodeId;
if (in_live_out(var)) {
nodes[nodeId.id]->add_live_var(var);
} else {
nodes[nodeId.id]->add_local_var(var);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x20, %rdi
callq 0x2c9ce
movl %ebp, (%rax)
movl 0x8(%r14), %r15d
movq 0x88(%rbx), %rax
movq (%rax), %rax
movq 0x28(%rax), %r14
movq 0x10(%r14), %rcx
addq $0x8, %r14
movq %r14, %rax
testq %rcx, %rcx
je 0x2a9a1
mo... | /segviol[P]indigo/backend/optimization/common_expression_delete.hpp |
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.