name string | code string | asm string | file string |
|---|---|---|---|
CGL::GLScene::Scene::get_static_scene() | SceneObjects::Scene *Scene::get_static_scene() {
std::vector<SceneObjects::SceneObject *> staticObjects;
std::vector<SceneObjects::SceneLight *> staticLights;
for (SceneObject *obj : objects) {
staticObjects.push_back(obj->get_static_object());
}
for (SceneLight *light : lights) {
staticLights.push_b... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x30(%rsp)
xorl %eax, %eax
movq %rax, 0x40(%rsp)
movq %rax, 0x20(%rsp)
vmovaps %xmm0, 0x10(%rsp)
movq (%rdi), %r12
movq 0x8(%rdi), %r13
cmpq %r13, %r12
je 0x1b29c
leaq 0x30(%rsp), %r14
leaq ... | /aatifjiwani[P]lens-flare/src/scene/gl_scene/scene.cpp |
CGL::GLScene::Sphere::Sphere(CGL::Collada::SphereInfo const&, CGL::Vector3D, double) | Sphere::Sphere(const Collada::SphereInfo& info,
const Vector3D position, const double scale) :
p(position), r(info.radius * scale) {
if (info.material) {
bsdf = info.material->bsdf;
} else {
bsdf = new DiffuseBSDF(Vector3D(0.5f,0.5f,0.5f));
}
} | pushq %rbx
movq %rdi, %rbx
leaq 0x18da59(%rip), %rax # 0x1a9250
addq $0x10, %rax
movq %rax, (%rdi)
vcvtss2sd 0x48(%rsi), %xmm1, %xmm1
vmulsd %xmm0, %xmm1, %xmm0
vmovsd %xmm0, 0x8(%rdi)
vmovsd (%rdx), %xmm0
vmovsd %xmm0, 0x10(%rdi)
vmovsd 0x8(%rdx), %xmm0
vmovsd %xmm0, 0x18(%rdi)
vmovsd 0x10(%rdx), %xmm0
vmovsd %xmm0... | /aatifjiwani[P]lens-flare/src/scene/gl_scene/sphere.cpp |
CGL::HalfedgeMesh::build(std::vector<std::vector<unsigned long, std::allocator<unsigned long>>, std::allocator<std::vector<unsigned long, std::allocator<unsigned long>>>> const&, std::vector<CGL::Vector3D, std::allocator<CGL::Vector3D>> const&, std::vector<CGL::Vector2D, std::allocator<CGL::Vector2D>> const&) | void HalfedgeMesh::build(const vector<vector<Index> >& polygons,
const vector<Vector3D>& vertexPositions,
const vector<Vector2D>& texcoords)
// This method initializes the halfedge data structure from a raw list of
// polygons, where each input polygon is specified as a... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rcx, 0x90(%rsp)
movq %rdx, 0x58(%rsp)
movq %rsi, %r13
movq %rdi, %rbx
callq 0x1a7da
movq %rbx, 0x8(%rbx)
movq %rbx, (%rbx)
xorl %r15d, %r15d
movq %r15, 0x10(%rbx)
leaq 0x18(%rbx), %r14
movq %r14, %rdi
call... | /aatifjiwani[P]lens-flare/src/util/halfEdgeMesh.cpp |
CGL::HalfedgeMesh::HalfedgeMesh(CGL::HalfedgeMesh const&) | HalfedgeMesh::HalfedgeMesh(const HalfedgeMesh& mesh) { *this = mesh; } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0x18(%rdi), %r14
movq %r14, 0x20(%rdi)
movq %r14, 0x18(%rdi)
movq %rax, 0x28(%rdi)
leaq 0x30(%rdi), %r15
movq %r15, 0x38(%rdi)
movq %r15, 0x30(%r... | /aatifjiwani[P]lens-flare/src/util/halfEdgeMesh.cpp |
CGL::Vertex::computeNormal() | void computeNormal(void) {
normal = Vector3D( 0., 0., 0. );
Vector3D pi = position;
// Iterate over neighbors.
HalfedgeCIter h = halfedge();
if (isBoundary()) {
do {
Vector3D pj = h->next()->vertex()->position;
Vector3D pk = h->next()->next()->vertex()->position;
no... | pushq %rbx
movq %rdi, %rbx
leaq 0x80(%rdi), %rcx
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x80(%rdi)
movq $0x0, 0x90(%rdi)
vmovapd 0x10(%rdi), %xmm0
vmovsd 0x20(%rdi), %xmm1
movq 0x130(%rdi), %rax
movq %rax, %rdx
movq 0x38(%rdx), %rsi
cmpb $0x0, 0xa8(%rsi)
jne 0x1cf96
movq 0x18(%rdx), %rdx
movq 0x20(%rdx), %rdx
cmpq %... | /aatifjiwani[P]lens-flare/src/util/halfEdgeMesh.h |
CGL::MeshResampler::upsample(CGL::HalfedgeMesh&) | void MeshResampler::upsample(HalfedgeMesh& mesh) {
// TODO: (meshEdit)
// Compute new positions for all the vertices in the input mesh, using
// the Loop subdivision rule, and store them in Vertex::newPosition.
// -> At this point, we also want to mark each vertex as being a vertex of the
// original mesh... | retq
nop
| /aatifjiwani[P]lens-flare/src/application/meshEdit.cpp |
CGL::UniformGridSampler2D::get_sample() const | Vector2D UniformGridSampler2D::get_sample() const {
return Vector2D(random_uniform(), random_uniform());
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18d8cd(%rip), %r14 # 0x1ac808
movq %r14, %rdi
callq 0x1f424
movq %rax, %r15
movq %r14, %rdi
callq 0x1f424
vmovq %r15, %xmm0
vmovq %rax, %xmm1
vpunpcklqdq %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[0]
vpxor %xmm1, %xmm1, %xmm1
vpblendd $0xa, %xmm1, %xmm0, %xmm1 #... | /aatifjiwani[P]lens-flare/src/pathtracer/sampler.cpp |
CGL::UniformHemisphereSampler3D::get_sample() const | Vector3D UniformHemisphereSampler3D::get_sample() const {
double Xi1 = random_uniform();
double Xi2 = random_uniform();
double theta = acos(Xi1);
double phi = 2.0 * PI * Xi2;
double xs = sinf(theta) * cosf(phi);
double ys = sinf(theta) * sinf(phi);
double zs = cosf(theta);
return Vector3D(xs, ys, zs... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x18d6ee(%rip), %r14 # 0x1ac808
movq %r14, %rdi
callq 0x1f424
movq %rax, %r15
movq %r14, %rdi
callq 0x1f424
vmovq %r15, %xmm0
vmovq %rax, %xmm1
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vpxor %xmm1, %xmm1, %xmm1
vpblendd... | /aatifjiwani[P]lens-flare/src/pathtracer/sampler.cpp |
CGL::SceneObjects::EnvironmentLight::init() | void EnvironmentLight::init() {
uint32_t w = envMap->w, h = envMap->h;
pdf_envmap = new double[w * h];
conds_y = new double[w * h];
marginal_y = new double[h];
std::cout << "[PathTracer] Initializing environment light...";
// 3-2 Part 3 Task 3 Steps 1,2,3
// Store the environment map pdf t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq (%rax), %rbp
movq 0x8(%rax), %r15
movl %ebp, %r14d
imull %r15d, %r14d
shlq $0x3, %r14
movq %r14, %rdi
callq 0xe040
movq %rax, 0x20(%rbx)
movq %r14, %rdi
callq 0xe040
movq %rax, 0x30(%rbx)
movl %r... | /aatifjiwani[P]lens-flare/src/scene/environment_light.cpp |
CGL::SceneObjects::EnvironmentLight::xy_to_theta_phi(CGL::Vector2D const&) const | Vector2D EnvironmentLight::xy_to_theta_phi(const Vector2D& xy) const {
uint32_t w = envMap->w, h = envMap->h;
double x = xy.x;
double y = xy.y;
double phi = x / w * 2.0 * PI;
double theta = y / h * PI;
return Vector2D(theta, phi);
} | movq %rdi, %rax
movq 0x8(%rsi), %rcx
movl (%rcx), %esi
movl 0x8(%rcx), %ecx
vmovsd (%rdx), %xmm0
vmovsd 0x8(%rdx), %xmm1
vcvtsi2sd %rsi, %xmm2, %xmm2
vdivsd %xmm2, %xmm0, %xmm0
vaddsd %xmm0, %xmm0, %xmm0
vcvtsi2sd %rcx, %xmm3, %xmm2
vdivsd %xmm2, %xmm1, %xmm1
vunpcklpd %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vmovd... | /aatifjiwani[P]lens-flare/src/scene/environment_light.cpp |
CGL::SceneObjects::EnvironmentLight::dir_to_theta_phi(CGL::Vector3D) const | Vector2D EnvironmentLight::dir_to_theta_phi(const Vector3D dir) const {
Vector3D unit_dir = dir.unit();
double theta = acos(unit_dir.y);
double phi = atan2(-unit_dir.z, unit_dir.x) + PI;
return Vector2D(theta, phi);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
vmovapd (%rdx), %xmm0
vdppd $0x31, %xmm0, %xmm0, %xmm0
movq %rdi, %rbx
vmovsd 0x10(%rdx), %xmm1
vmulsd %xmm1, %xmm1, %xmm1
vaddsd %xmm0, %xmm1, %xmm0
vxorpd %xmm1, %xmm1, %xmm1
vucomisd %xmm1, %xmm0
jb 0x1ffa0
vsqrtsd %xmm0, %xmm0, %xmm0
jmp 0x1ffa5
callq 0xe6b0
vm... | /aatifjiwani[P]lens-flare/src/scene/environment_light.cpp |
CGL::RaytracedRenderer::~RaytracedRenderer() | RaytracedRenderer::~RaytracedRenderer() {
delete bvh;
delete pt;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x188cda(%rip), %rax # 0x1a96a0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0xd8(%rdi), %r14
testq %r14, %r14
je 0x209e1
movq %r14, %rdi
callq 0xea50
movq %r14, %rdi
callq 0xe840
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x209fa
movq %r14, %rdi
callq 0xe6a0
movq %r14... | /aatifjiwani[P]lens-flare/src/pathtracer/raytraced_renderer.cpp |
CGL::RaytracedRenderer::update_screen() | void RaytracedRenderer::update_screen() {
switch (state) {
case INIT:
case READY:
break;
case VISUALIZE:
visualize_accel();
break;
case RENDERING:
glDrawPixels(frameBuffer.w, frameBuffer.h, GL_RGBA,
GL_UNSIGNED_BYTE, &frameBuffer.data[0]);
if (render_ce... | pushq %rbx
movq %rdi, %rbx
movl 0x38(%rdi), %eax
cmpl $0x4, %eax
je 0x21009
cmpl $0x3, %eax
je 0x21009
cmpl $0x2, %eax
jne 0x2103a
movq %rbx, %rdi
popq %rbx
jmp 0x2103c
movl 0xe0(%rbx), %edi
movl 0xe8(%rbx), %esi
movq 0xf0(%rbx), %r8
movl $0x1908, %edx # imm = 0x1908
movl $0x1401, %ecx # imm = 0x140... | /aatifjiwani[P]lens-flare/src/pathtracer/raytraced_renderer.cpp |
CGL::RaytracedRenderer::visualize_accel() const | void RaytracedRenderer::visualize_accel() const {
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_LIGHTING);
glLineWidth(1);
glEnable(GL_DEPTH_TEST);
// hardcoded color settings
Color cnode = Color(.5, .5, .5); float cnode_alpha = 0.25f;
Color cnode_hl = Color(1., .25, .0); float cnode_hl_alpha = 0.6f;
Colo... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
movl $0x2000, %edi # imm = 0x2000
callq 0xed40
movl $0xb50, %edi # imm = 0xB50
callq 0xe220
vmovss 0xc2379(%rip), %xmm0 # 0xe33e4
callq 0xf110
movl $0xb71, %edi # imm = 0xB71
callq 0xe810
vbroadcas... | /aatifjiwani[P]lens-flare/src/pathtracer/raytraced_renderer.cpp |
CGL::RaytracedRenderer::clear() | void RaytracedRenderer::clear() {
if (state != READY) return;
delete bvh;
bvh = NULL;
scene = NULL;
camera = NULL;
selectionHistory.pop();
frameBuffer.resize(0, 0);
state = INIT;
render_cell = false;
pt->clear();
} | cmpl $0x1, 0x38(%rdi)
jne 0x21870
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xd8(%rdi), %r14
testq %r14, %r14
je 0x2181d
movq %r14, %rdi
callq 0xea50
movq %r14, %rdi
callq 0xe840
movq $0x0, 0xd8(%rbx)
leaq 0x210(%rbx), %rdi
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x40(%rbx)
callq 0x2401e
leaq 0xe0(%rbx), ... | /aatifjiwani[P]lens-flare/src/pathtracer/raytraced_renderer.cpp |
CGL::RaytracedRenderer::raytrace_tile(int, int, int, int) | void RaytracedRenderer::raytrace_tile(int tile_x, int tile_y,
int tile_w, int tile_h) {
size_t w = frame_w;
size_t h = frame_h;
size_t tile_start_x = tile_x;
size_t tile_start_y = tile_y;
size_t tile_end_x = std::min(tile_start_x + tile_w, w);
size_t tile_end_y = std::min(ti... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x78(%rdi), %rax
movq 0x80(%rdi), %rdi
movslq %esi, %rbp
movslq %ecx, %r15
addq %rbp, %r15
cmpq %r15, %rax
cmovbq %rax, %r15
movslq %edx, %rsi
movslq %r8d, %r12
addq %rsi, %r12
cmpq %r12, %rdi
cmovbq %rdi, %r12
movq ... | /aatifjiwani[P]lens-flare/src/pathtracer/raytraced_renderer.cpp |
CGL::RaytracedRenderer::save_image(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CGL::ImageBuffer*) | void RaytracedRenderer::save_image(string filename, ImageBuffer* buffer) {
if (state != DONE) return;
if (!buffer)
buffer = &frameBuffer;
if (filename == "") {
time_t rawtime;
time (&rawtime);
time_t t = time(nullptr);
tm *lt = localtime(&t);
stringstream ss;
ss << this->filename <... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
cmpl $0x4, 0x38(%rdi)
je 0x22951
addq $0x1d8, %rsp # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xe0(%rdi), %r15
testq %rdx, %rdx... | /aatifjiwani[P]lens-flare/src/pathtracer/raytraced_renderer.cpp |
WorkQueue<CGL::WorkItem>::put_work(CGL::WorkItem const&) | void put_work(const T& item) {
lock.lock();
storage.push_back(item);
lock.unlock();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0xeda0
testl %eax, %eax
jne 0x234bb
movq 0x8(%r15), %rsi
cmpq 0x10(%r15), %rsi
je 0x234a3
vmovups (%r14), %xmm0
vmovups %xmm0, (%rsi)
addq $0x10, 0x8(%r15)
jmp 0x234ae
movq %r15, %rdi
movq %r14, %rdx
callq 0x241... | /aatifjiwani[P]lens-flare/src/util/work_queue.h |
CGL::HDRImageBuffer::HDRImageBuffer(unsigned long, unsigned long) | HDRImageBuffer(size_t w, size_t h) : w(w), h(h) { data.resize(w * h); } | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
imulq %rdx, %rsi
movq %rbx, %rdi
callq 0x16138
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x23660
c... | /aatifjiwani[P]lens-flare/src/util/image.h |
CGL::ImageBuffer::update_pixel(CGL::Color const&, unsigned long, unsigned long) | void update_pixel(const Color& c, size_t x, size_t y) {
assert(0 <= x && x < w);
assert(0 <= y && y < h);
uint32_t p = 0;
p |= ((uint32_t) (clamp(0.f, 1.f, c.b) * 255)) << 16;
p |= ((uint32_t) (clamp(0.f, 1.f, c.g) * 255)) << 8;
p |= ((uint32_t) (clamp(0.f, 1.f, c.r) * 255));
p |= 0xFF000000... | pushq %rax
movq (%rdi), %rax
cmpq %rdx, %rax
jbe 0x237dc
cmpq %rcx, 0x8(%rdi)
jbe 0x237fb
vmovsd 0x4(%rsi), %xmm0
vbroadcastss 0xbfc87(%rip), %xmm1 # 0xe33e4
vminps %xmm1, %xmm0, %xmm0
vbroadcastss 0xc081e(%rip), %xmm1 # 0xe3f88
vmulps %xmm1, %xmm0, %xmm0
vcvttps2dq %xmm0, %xmm1
vpsrad $0x1f, %xmm1, %xmm2
vbroadcastss ... | /aatifjiwani[P]lens-flare/src/util/image.h |
CGL::Misc::draw_sphere(CGL::Vector3D const&, double) | void draw_sphere(const Vector3D& p, double r) {
if (!initialized) {
init_mesh();
initialized = true;
}
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslated(p.x, p.y, p.z);
glScaled(r, r, r);
for (int i = 0; i < SPHERE_NUM_INDICES; i += 3) {
glBegin(GL_POLYGON);
double *vPtr1 = &Verti... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
vmovsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
cmpb $0x0, 0x18931e(%rip) # 0x1adba1
jne 0x24891
callq 0x24b2c
movb $0x1, 0x189310(%rip) # 0x1adba1
movl $0x1700, %edi # imm = 0x1700
callq 0xec80
callq 0xeef0
vmovsd (%rbx), %xmm0
... | /aatifjiwani[P]lens-flare/src/util/sphere_drawing.cpp |
CGL::Misc::draw_sphere_wireframe_opengl(CGL::Vector3D const&, double, CGL::Color const&) | void draw_sphere_wireframe_opengl(const Vector3D& p, double r, const Color& c) {
if (!initialized) {
init_mesh();
initialized = true;
}
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslated(p.x, p.y, p.z);
glScaled(r, r, r);
for (int i = 0; i < SPHERE_NUM_INDICES; i += 3) {
glBegin(GL_LIN... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
vmovsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
cmpb $0x0, 0x18913c(%rip) # 0x1adba1
jne 0x24a73
callq 0x24b2c
movb $0x1, 0x18912e(%rip) # 0x1adba1
movl $0x1700, %edi # imm = 0x1700
callq 0xec80
callq 0xeef0
vmovsd (%rbx), %xmm0
vmovsd 0x8(... | /aatifjiwani[P]lens-flare/src/util/sphere_drawing.cpp |
CGL::Misc::init_mesh() | void init_mesh() {
for ( int i = 0; i <= SPHERE_NUM_LAT; i++ ) {
for ( int j = 0; j <= SPHERE_NUM_LON; j++ ) {
double lat = ((double)i) / SPHERE_NUM_LAT;
double lon = ((double)j) / SPHERE_NUM_LON;
double *vptr = &Vertices[VERTEX_SIZE * SINDEX(i,j)];
vptr[TCOORD_OFFSET + 0] = lon;
vp... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x1890aa(%rip), %rbx # 0x1adbe8
xorl %r14d, %r14d
vmovsd 0xbf3ef(%rip), %xmm2 # 0xe3f38
vmovsd 0xbf0b7(%rip), %xmm3 # 0xe3c08
vcvtsi2sd %r14d, %xmm4, %xmm0
vdivsd 0xbfb8a(%rip), %xmm0, %xmm0 # 0xe46e8
vmovsd 0xbe51a(%rip), %xmm1 # 0xe3080
vsu... | /aatifjiwani[P]lens-flare/src/util/sphere_drawing.cpp |
lodepng_load_file(unsigned char**, unsigned long*, char const*) | unsigned lodepng_load_file(unsigned char** out, size_t* outsize, const char* filename) {
long size = lodepng_filesize(filename);
if (size < 0) return 78;
*outsize = (size_t)size;
*out = (unsigned char*)lodepng_malloc((size_t)size);
if (!(*out) && size > 0) return 83; /*the above malloc failed*/
return lod... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq %rdx, %rdi
callq 0x24d27
testq %rax, %rax
js 0x24d14
movq %rax, %r14
movq %rax, (%r12)
movq %rax, %rdi
callq 0xec20
movq %rax, (%r15)
testq %rax, %rax
sete %dl
testq %r14, %r14
setne %sil
movl $0x53, %ecx
testb %... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
lodepng_save_file(unsigned char const*, unsigned long, char const*) | unsigned lodepng_save_file(const unsigned char* buffer, size_t buffersize, const char* filename) {
FILE* file;
file = fopen(filename, "wb");
if (!file) return 79;
fwrite(buffer, 1, buffersize, file);
fclose(file);
return 0;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc04e4(%rip), %rsi # 0xe52e5
movq %rdx, %rdi
callq 0xead0
testq %rax, %rax
je 0x24e30
movq %rax, %r15
movl $0x1, %esi
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0xf1f0
movq %r15, %rdi
callq 0xe8e0
xorl %eax, %eax
jmp 0x24e35
movl $0x4... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
ensureBits9(LodePNGBitReader*, unsigned long) | static unsigned ensureBits9(LodePNGBitReader* reader, size_t nbits) {
size_t start = reader->bp >> 3u;
size_t size = reader->size;
if (start + 1u < size) {
reader->buffer = (unsigned)reader->data[start + 0] | ((unsigned)reader->data[start + 1] << 8u);
reader->buffer >>= (reader->bp & 7u);
return 1;
... | movq 0x8(%rdi), %r8
movq 0x18(%rdi), %rax
movq %rax, %rcx
shrq $0x3, %rcx
leaq 0x1(%rcx), %rdx
cmpq %r8, %rdx
jae 0x250e2
movq (%rdi), %rdx
movzwl (%rdx,%rcx), %edx
andb $0x7, %al
movl %eax, %ecx
shrl %cl, %edx
movl %edx, 0x20(%rdi)
movl $0x1, %eax
retq
movl $0x0, 0x20(%rdi)
xorl %edx, %edx
cmpq %r8, %rcx
jae 0x250f7
m... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
lodepng_huffman_code_lengths(unsigned int*, unsigned int const*, unsigned long, unsigned int) | unsigned lodepng_huffman_code_lengths(unsigned* lengths, const unsigned* frequencies,
size_t numcodes, unsigned maxbitlen) {
unsigned error = 0;
unsigned i;
size_t numpresent = 0; /*number of symbols with non-zero frequency*/
BPMNode* leaves; /*the symbols, only those with > 0 frequency*/
if (numcodes == 0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r13
testq %rdx, %rdx
sete %al
movl $0x1, %edx
shll %cl, %edx
cmpl %r13d, %edx
setb %dl
orb %al, %dl
movl $0x50, %ebx
jne 0x2555a
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, 0x18(%rsp)
leaq (,%r13,8), %rax
leaq (%rax,%rax,2), %... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
boundaryPM(BPMLists*, BPMNode*, unsigned long, int, int) | static void boundaryPM(BPMLists* lists, BPMNode* leaves, size_t numpresent, int c, int num) {
unsigned lastindex = lists->chains1[c]->index;
if (c == 0) {
if (lastindex >= numpresent) return;
lists->chains0[c] = lists->chains1[c];
lists->chains1[c] = bpmnode_create(lists, leaves[lastindex].weight, last... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rdi), %rdx
movslq %ecx, %r13
movq (%rdx,%r13,8), %rax
movl 0x4(%rax), %ecx
testl %r13d, %r13d
je 0x2590b
movq %r8, 0x10(%rsp)
leal 0x1(%r8), %esi
movl %esi, 0x4(%rsp)
leal -0x2(,... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
lodepng_zlib_decompressv(ucvector*, unsigned char const*, unsigned long, LodePNGDecompressSettings const*) | static unsigned lodepng_zlib_decompressv(ucvector* out,
const unsigned char* in, size_t insize,
const LodePNGDecompressSettings* settings) {
unsigned error = 0;
unsigned CM, CINFO, FDICT;
if (insize < 2) return 53; /*error, size of zlib data too small*/
/*read information from zlib header*/
if ((in[0] * ... | movl $0x35, %eax
cmpq $0x2, %rdx
jb 0x27edf
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movzbl (%rsi), %edx
movl %edx, %eax
shll $0x8, %eax
movzbl 0x1(%rsi), %ecx
orl %ecx, %eax
imull $0x7bdf, %eax, %eax # imm = 0x7BDF
movzwl %ax, %esi
movl $0x18, %eax
cmpl... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
lodepng_chunk_next(unsigned char*, unsigned char*) | unsigned char* lodepng_chunk_next(unsigned char* chunk, unsigned char* end) {
if (chunk >= end || end - chunk < 12) return end; /*too small to contain a chunk*/
if (chunk[0] == 0x89 && chunk[1] == 0x50 && chunk[2] == 0x4e && chunk[3] == 0x47
&& chunk[4] == 0x0d && chunk[5] == 0x0a && chunk[6] == 0x1a && chunk[7... | movq %rsi, %rax
movq %rsi, %rcx
subq %rdi, %rcx
setbe %dl
cmpq $0xc, %rcx
setl %cl
orb %dl, %cl
jne 0x2825a
movzbl (%rdi), %eax
movl %eax, %edx
xorb $-0x77, %dl
movb 0x1(%rdi), %cl
movl %ecx, %esi
xorb $0x50, %sil
orb %dl, %sil
jne 0x28237
movb $0x50, %cl
cmpb $0x4e, 0x2(%rdi)
jne 0x28237
cmpb $0x47, 0x3(%rdi)
jne 0x28... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
lodepng_chunk_createv(ucvector*, unsigned int, char const*, unsigned char const*) | static unsigned lodepng_chunk_createv(ucvector* out,
unsigned length, const char* type, const unsigned char* data) {
unsigned char* chunk;
CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, length, type));
/*3: the data*/
lodepng_memcpy(chunk + 8, data, length);
/*4: CRC (of the chunkname characters and th... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %rcx
movl %esi, %r14d
movq %rdi, %rsi
movq %rsp, %rdi
movl %r14d, %edx
callq 0x30576
movl %eax, %ebp
testl %eax, %eax
jne 0x284b4
movq (%rsp), %r15
testl %r14d, %r14d
je 0x284ac
movl %r14d, %edx
leaq 0x8(%r15), %rdi
movq %rbx, %rsi
callq ... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
lodepng_can_have_alpha(LodePNGColorMode const*) | unsigned lodepng_can_have_alpha(const LodePNGColorMode* info) {
return info->key_defined
|| lodepng_is_alpha_type(info)
|| lodepng_has_palette_alpha(info);
} | movl $0x1, %eax
cmpl $0x0, 0x18(%rdi)
je 0x28729
retq
testb $0x4, (%rdi)
jne 0x28728
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x2874c
movq 0x8(%rdi), %rdx
xorl %esi, %esi
cmpb $-0x1, 0x3(%rdx,%rsi,4)
jne 0x28728
incq %rsi
cmpq %rsi, %rcx
jne 0x2873d
xorl %eax, %eax
retq
| /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
LodePNGText_cleanup(LodePNGInfo*) | static void LodePNGText_cleanup(LodePNGInfo* info) {
size_t i;
for (i = 0; i != info->text_num; ++i) {
string_cleanup(&info->text_keys[i]);
string_cleanup(&info->text_strings[i]);
}
lodepng_free(info->text_keys);
lodepng_free(info->text_strings);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x48(%rdi)
je 0x288d0
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x50(%rbx), %r12
movq (%r12,%r15,8), %rdi
callq 0xeaf0
movq %r14, (%r12,%r15,8)
movq 0x58(%rbx), %r12
movq (%r12,%r15,8), %rdi
callq 0xeaf0
movq %r14, (%r12,%r15,8)
incq %r15
... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
lodepng_add_itext_sized(LodePNGInfo*, char const*, char const*, char const*, char const*, unsigned long) | static unsigned lodepng_add_itext_sized(LodePNGInfo* info, const char* key, const char* langtag,
const char* transkey, const char* str, size_t size) {
char** new_keys = (char**)(lodepng_realloc(info->itext_keys, sizeof(char*) * (info->itext_num + 1)));
char** new_langtags = (char**)(lodepng_realloc(info->itext_la... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, (%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %rbp
movq %rdi, %r14
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0xefd0
movq %rax, %r15
movq 0x60(%r14), %rax
movq 0x70(%... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
lodepng_info_init(LodePNGInfo*) | void lodepng_color_mode_init(LodePNGColorMode* info) {
info->key_defined = 0;
info->key_r = info->key_g = info->key_b = 0;
info->colortype = LCT_RGBA;
info->bitdepth = 8;
info->palette = 0;
info->palettesize = 0;
} | vxorps %xmm0, %xmm0, %xmm0
movabsq $0x800000006, %rax # imm = 0x800000006
movq %rax, 0x10(%rdi)
vxorps %xmm1, %xmm1, %xmm1
vmovups %ymm1, 0x18(%rdi)
xorl %eax, %eax
movl %eax, 0x8(%rdi)
movq $0x0, (%rdi)
movl %eax, 0xa4(%rdi)
movl %eax, 0xb4(%rdi)
movl %eax, 0xbc(%rdi)
movl %eax, 0xe0(%rdi)
movl %eax, 0xe8(%rdi)
v... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
lodepng_color_mode_equal(LodePNGColorMode const*, LodePNGColorMode const*) | static int lodepng_color_mode_equal(const LodePNGColorMode* a, const LodePNGColorMode* b) {
size_t i;
if (a->colortype != b->colortype) return 0;
if (a->bitdepth != b->bitdepth) return 0;
if (a->key_defined != b->key_defined) return 0;
if (a->key_defined) {
if (a->key_r != b->key_r) return 0;
if (a->k... | movl (%rdi), %ecx
xorl %eax, %eax
cmpl (%rsi), %ecx
jne 0x294cc
movl 0x4(%rdi), %ecx
cmpl 0x4(%rsi), %ecx
jne 0x294cc
movl 0x18(%rdi), %ecx
cmpl 0x18(%rsi), %ecx
jne 0x294cc
testl %ecx, %ecx
je 0x29494
movl 0x1c(%rdi), %ecx
cmpl 0x1c(%rsi), %ecx
jne 0x294cc
movl 0x20(%rdi), %ecx
cmpl 0x20(%rsi), %ecx
jne 0x294cc
movl 0... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
getPixelColorRGBA16(unsigned short*, unsigned short*, unsigned short*, unsigned short*, unsigned char const*, unsigned long, LodePNGColorMode const*) | static void getPixelColorRGBA16(unsigned short* r, unsigned short* g, unsigned short* b, unsigned short* a,
const unsigned char* in, size_t i, const LodePNGColorMode* mode) {
if (mode->colortype == LCT_GREY) {
*r = *g = *b = 256 * in[i * 2 + 0] + in[i * 2 + 1];
if (mode->key_defined && 256U * in[i * 2 + 0] ... | pushq %rbx
movq 0x10(%rsp), %rax
movl (%rax), %r10d
cmpq $0x6, %r10
ja 0x29717
leaq 0xbb300(%rip), %r11 # 0xe48b4
movslq (%r11,%r10,4), %r10
addq %r11, %r10
jmpq *%r10
movzbl (%r8,%r9,2), %r10d
shll $0x8, %r10d
movzbl 0x1(%r8,%r9,2), %r11d
orl %r10d, %r11d
movw %r11w, (%rdx)
movw %r11w, (%rsi)
movw %r11w, (%rdi)
cm... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
getPixelColorsRGB8(unsigned char*, unsigned long, unsigned char const*, LodePNGColorMode const*) | static void getPixelColorsRGB8(unsigned char* LODEPNG_RESTRICT buffer, size_t numpixels,
const unsigned char* LODEPNG_RESTRICT in,
const LodePNGColorMode* mode) {
const unsigned num_channels = 3;
size_t i;
if (mode->colortype == LCT_GREY) {
if (mode->bitdepth == 8) {
for (i = 0; i != numpixels; ++i,... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl (%rcx), %eax
cmpq $0x6, %rax
ja 0x29e03
movq %rdx, %r8
leaq 0xbadb9(%rip), %rdx # 0xe48f0
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movl 0x4(%rcx), %ecx
cmpq $0x8, %rcx
je 0x29d5f
cmpl $0x10, %ecx
jne 0x29d88
testq %rsi, %rsi
je 0x29e03
addq $0x2, %rdi
xo... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
lodepng_inspect_chunk(LodePNGState*, unsigned long, unsigned char const*, unsigned long) | unsigned lodepng_inspect_chunk(LodePNGState* state, size_t pos,
const unsigned char* in, size_t insize) {
const unsigned char* chunk = in + pos;
unsigned chunkLength;
const unsigned char* data;
unsigned unhandled = 0;
unsigned error = 0;
if (pos + 4 > insize) return 30;
chunkLength = lodepng_chunk_leng... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
addq $0x4, %rsi
movl $0x1e, %eax
cmpq %rcx, %rsi
ja 0x2b126
addq %rdx, %rbx
movzbl (%rbx), %esi
shll $0x18, %esi
js 0x2afdb
movq %rdi, %r14
movzbl 0x1(%rbx), %edi
shll $0x10, %edi
movzbl 0x2(%rbx), %r8d
shll $0x8, %r8d
movzbl 0x3(%rbx), %r15d
orl %e... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
readChunk_tIME(LodePNGInfo*, unsigned char const*, unsigned long) | static unsigned readChunk_tIME(LodePNGInfo* info, const unsigned char* data, size_t chunkLength) {
if (chunkLength != 7) return 73; /*invalid tIME chunk size*/
info->time_defined = 1;
info->time.year = 256u * data[0] + data[1];
info->time.month = data[2];
info->time.day = data[3];
info->time.hour = data[4]... | movl $0x49, %eax
cmpq $0x7, %rdx
jne 0x2b931
movl $0x1, 0x88(%rdi)
movzwl (%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl %eax, 0x8c(%rdi)
movzbl 0x2(%rsi), %eax
movl %eax, 0x90(%rdi)
movzbl 0x3(%rsi), %eax
movl %eax, 0x94(%rdi)
movzbl 0x4(%rsi), %eax
movl %eax, 0x98(%rdi)
movzbl 0x5(%rsi), %eax
movl %eax, 0x9c(%rdi)... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
readChunk_iCCP(LodePNGInfo*, LodePNGDecompressSettings const*, unsigned char const*, unsigned long) | static unsigned readChunk_iCCP(LodePNGInfo* info, const LodePNGDecompressSettings* zlibsettings,
const unsigned char* data, size_t chunkLength) {
unsigned error = 0;
unsigned i;
size_t size = 0;
unsigned length, string2_begin;
info->iccp_defined = 1;
if (info->iccp_name) lodepng_clear_icc(info);
for ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq $0x0, 0x10(%rsp)
movl $0x1, 0xe8(%rdi)
movq 0xf0(%rdi), %rdi
testq %rdi, %rdi
je 0x2ba41
callq 0xeaf0
xorl %r15d, %r15d
movq %r15, 0xf0(%rbx)
movq 0xf8(%rbx), %rdi
call... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
lodepng_encoder_settings_init(LodePNGEncoderSettings*) | void lodepng_compress_settings_init(LodePNGCompressSettings* settings) {
/*compress with dynamic huffman tree (not in the mathematical sense, just not the predefined one)*/
settings->btype = 2;
settings->use_lz77 = 1;
settings->windowsize = DEFAULT_WINDOWSIZE;
settings->minmatch = 3;
settings->nicematch = 1... | vmovaps 0xb7b8d(%rip), %xmm0 # 0xe4820
vmovups %xmm0, (%rdi)
movabsq $0x100000080, %rax # imm = 0x100000080
movq %rax, 0x10(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x18(%rdi)
movq $0x0, 0x28(%rdi)
movl $0x5, 0x38(%rdi)
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x30(%rdi)
vmovups %xm... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
addChunk_cHRM(ucvector*, LodePNGInfo const*) | static unsigned addChunk_cHRM(ucvector* out, const LodePNGInfo* info) {
unsigned char* chunk;
CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, 32, "cHRM"));
lodepng_set32bitInt(chunk + 8, info->chrm_white_x);
lodepng_set32bitInt(chunk + 12, info->chrm_white_y);
lodepng_set32bitInt(chunk + 16, info->chrm_red_... | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0xb70a1(%rip), %rcx # 0xe531a
movq %rsp, %rdi
movl $0x20, %edx
callq 0x30576
movl %eax, %ebp
testl %eax, %eax
jne 0x2e2ed
movq (%rsp), %rdi
movl 0xc0(%rbx), %eax
bswapl %eax
movl %eax, 0x8(%rdi)
movl 0xc4(%rbx), %eax
bswapl %eax
movl %eax, 0xc(%r... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
addChunk_pHYs(ucvector*, LodePNGInfo const*) | static unsigned addChunk_pHYs(ucvector* out, const LodePNGInfo* info) {
unsigned char* chunk;
CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, 9, "pHYs"));
lodepng_set32bitInt(chunk + 8, info->phys_x);
lodepng_set32bitInt(chunk + 12, info->phys_y);
chunk[16] = info->phys_unit;
lodepng_chunk_generate_crc(ch... | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0xb6d90(%rip), %rcx # 0xe5310
movq %rsp, %rdi
movl $0x9, %edx
callq 0x30576
movl %eax, %ebp
testl %eax, %eax
jne 0x2e5bb
movq (%rsp), %rdi
movl 0xa8(%rbx), %eax
bswapl %eax
movl %eax, 0x8(%rdi)
movl 0xac(%rbx), %eax
bswapl %eax
movl %eax, 0xc(%rd... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
addChunk_tEXt(ucvector*, char const*, char const*) | static unsigned addChunk_tEXt(ucvector* out, const char* keyword, const char* textstring) {
unsigned char* chunk = 0;
size_t keysize = lodepng_strlen(keyword), textsize = lodepng_strlen(textstring);
size_t size = keysize + 1 + textsize;
if (keysize < 1 || keysize > 79) return 89; /*error: invalid keyword size*/... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %rsi
movq $0x0, 0x8(%rsp)
movq $-0x1, %r14
cmpb $0x0, 0x1(%r15,%r14)
leaq 0x1(%r14), %r14
jne 0x2e7ac
movq $-0x1, %r12
movl %r14d, %edx
incl %edx
cmpb $0x0, 0x1(%rbx,%r12)
leaq 0x1(%r12), %r12
jne 0x2e7c2
... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
lodepng_error_text(unsigned int) | const char* lodepng_error_text(unsigned code) {
switch (code) {
case 0: return "no error, everything went ok";
case 1: return "nothing done yet"; /*the Encoder/Decoder has done nothing yet, error checking makes no sense yet*/
case 10: return "end of input memory reached without huffman end code"; /*while huffma... | cmpl $0x6c, %edi
ja 0x2ec1e
movl %edi, %eax
leaq 0xb6512(%rip), %rcx # 0xe5128
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0xb78c4(%rip), %rax # 0xe64e9
retq
| /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
unfilter(unsigned char*, unsigned char const*, unsigned int, unsigned int, unsigned int) | static unsigned unfilter(unsigned char* out, const unsigned char* in, unsigned w, unsigned h, unsigned bpp) {
/*
For PNG filter method 0
this function unfilters a single image (e.g. without interlacing this is called once, with Adam7 seven times)
out must have enough bytes allocated already, in must have the sc... | testl %ecx, %ecx
je 0x30fa0
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leal 0x7(%r8), %eax
movl %eax, -0x74(%rsp)
movl %eax, %r13d
shrl $0x3, %r13d
movl %edx, %eax
shrl $0x3, %eax
movl %r8d, %r9d
imulq %rax, %r9
andl $0x7, %edx
imull %r8d, %edx
addl $0x7, %edx
shrl $0x3, %edx
lea... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
filterScanline(unsigned char*, unsigned char const*, unsigned char const*, unsigned long, unsigned long, unsigned char) | static void filterScanline(unsigned char* out, const unsigned char* scanline, const unsigned char* prevline,
size_t length, size_t bytewidth, unsigned char filterType) {
size_t i;
switch (filterType) {
case 0: /*None*/
for (i = 0; i != length; ++i) out[i] = scanline[i];
break;
case 1: /*Sub*/
for ... | cmpl $0x4, %r9d
ja 0x31d4e
movl %r9d, %eax
leaq 0xb2ebf(%rip), %r9 # 0xe49d8
movslq (%r9,%rax,4), %rax
addq %r9, %rax
jmpq *%rax
testq %rcx, %rcx
je 0x31d4e
xorl %eax, %eax
movb (%rsi,%rax), %dl
movb %dl, (%rdi,%rax)
incq %rax
cmpq %rax, %rcx
jne 0x31b2d
jmp 0x31d4e
testq %rdx, %rdx
je 0x31cc6
testq %r8, %r8
je 0x... | /aatifjiwani[P]lens-flare/src/util/lodepng.cpp |
CGL::Application::load(CGL::Collada::SceneInfo*) | void Application::load(SceneInfo* sceneInfo) {
vector<Collada::Node>& nodes = sceneInfo->nodes;
vector<GLScene::SceneLight *> lights;
vector<GLScene::SceneObject *> objects;
// save camera position to update camera control later
CameraInfo *c;
Vector3D c_pos = Vector3D();
Vector3D c_dir = Vector3D();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdi, 0x78(%rsp)
vxorpd %xmm1, %xmm1, %xmm1
vmovapd %xmm1, 0x50(%rsp)
xorl %eax, %eax
movq %rax, 0x60(%rsp)
movq %rax, 0x30(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vmovapd %xmm0, 0x40(%rsp)
vmovapd %xmm1, 0x20(%rs... | /aatifjiwani[P]lens-flare/src/application/application.cpp |
CGL::Matrix3x3::Matrix3x3() | Matrix3x3(void) {
for( int i = 0; i < 3; i++ ) {
for( int j = 0; j < 3; j++ ) {
(*this)(i,j) = (i==j) ? 1. : 0.;
}
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, (%rdi)
xorl %r14d, %r14d
movq %r14, 0x10(%rdi)
vmovaps %xmm0, 0x20(%rdi)
movq %r14, 0x30(%rdi)
vmovaps %xmm0, 0x40(%rdi)
movq %r14, 0x50(%rdi)
xorl %ebp, %ebp
vmovsd 0xadb6a(%rip), %xmm0 # 0xe3080
cmpl %ebp, %... | /aatifjiwani[P]lens-flare/CGL/include/CGL/matrix3x3.h |
tdefl_create_comp_flags_from_zip_params | mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits,
int strategy) {
mz_uint comp_flags =
s_tdefl_num_probes[(level >= 0) ? MZ_MIN(10, level) : MZ_DEFAULT_LEVEL] |
((level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0);
if (window_bits > 0)
... | cmpl $0xa, %edi
movl $0xa, %eax
cmovbl %edi, %eax
testl %edi, %edi
movl $0x6, %ecx
cmovnsl %eax, %ecx
leaq 0xb0b6c(%rip), %rax # 0xe6d50
xorl %r8d, %r8d
cmpl $0x4, %edi
setl %r8b
shll $0xe, %r8d
orl (%rax,%rcx,4), %r8d
movl %r8d, %eax
orl $0x1000, %eax # imm = 0x1000
testl %esi, %esi
cmovlel %r8d, %eax
te... | /aatifjiwani[P]lens-flare/CGL/include/CGL/tinyexr.h |
mz_deflateEnd | int mz_deflateEnd(mz_streamp pStream) {
if (!pStream)
return MZ_STREAM_ERROR;
if (pStream->state) {
pStream->zfree(pStream->opaque, pStream->state);
pStream->state = NULL;
}
return MZ_OK;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3635e
movq %rdi, %r14
movq 0x38(%rdi), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x36363
movq 0x50(%r14), %rdi
callq *0x48(%r14)
movq $0x0, 0x38(%r14)
jmp 0x36363
movl $0xfffffffe, %ebx # imm = 0xFFFFFFFE
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
ret... | /aatifjiwani[P]lens-flare/CGL/include/CGL/tinyexr.h |
mz_deflateReset | int mz_deflateReset(mz_streamp pStream) {
if ((!pStream) || (!pStream->state) || (!pStream->zalloc) ||
(!pStream->zfree))
return MZ_STREAM_ERROR;
pStream->total_in = pStream->total_out = 0;
tdefl_init((tdefl_compressor *)pStream->state, NULL, NULL,
((tdefl_compressor *)pStream->state)->m_fl... | pushq %rbx
movl $0xfffffffe, %ebx # imm = 0xFFFFFFFE
testq %rdi, %rdi
je 0x363a8
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x363a8
cmpq $0x0, 0x40(%rdi)
je 0x363a8
cmpq $0x0, 0x48(%rdi)
je 0x363a8
xorl %ebx, %ebx
movq %rbx, 0x28(%rdi)
movq %rbx, 0x10(%rdi)
movl 0x10(%rax), %ecx
movq %rax, %rdi
xorl %esi, %esi
xor... | /aatifjiwani[P]lens-flare/CGL/include/CGL/tinyexr.h |
mz_deflate | int mz_deflate(mz_streamp pStream, int flush) {
size_t in_bytes, out_bytes;
mz_ulong orig_total_in, orig_total_out;
int mz_status = MZ_OK;
if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) ||
(!pStream->next_out))
return MZ_STREAM_ERROR;
if (!pStream->avail_out)
return M... | testq %rdi, %rdi
je 0x36419
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
sete %al
cmpl $0x5, %esi
setae %cl
orb %al, %cl
jne 0x36507
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x36507
movl 0x20(%rbx), %r9d
testl %r9d, %r9d
je 0x... | /aatifjiwani[P]lens-flare/CGL/include/CGL/tinyexr.h |
mz_inflateInit2 | int mz_inflateInit2(mz_streamp pStream, int window_bits) {
inflate_state *pDecomp;
if (!pStream)
return MZ_STREAM_ERROR;
if ((window_bits != MZ_DEFAULT_WINDOW_BITS) &&
(-window_bits != MZ_DEFAULT_WINDOW_BITS))
return MZ_PARAM_ERROR;
pStream->data_type = 0;
pStream->adler = 0;
pStream->msg = N... | testq %rdi, %rdi
je 0x3690b
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl $0xf, %esi
je 0x36882
movl $0xffffd8f0, %eax # imm = 0xFFFFD8F0
cmpl $-0xf, %ebx
jne 0x36916
movl $0x0, 0x58(%r14)
movq $0x0, 0x10(%r14)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x28(%r14)
vmovups %xmm0, 0x60(%r14)
... | /aatifjiwani[P]lens-flare/CGL/include/CGL/tinyexr.h |
(anonymous namespace)::miniz::tdefl_compress_normal((anonymous namespace)::miniz::tdefl_compressor*) | static mz_bool tdefl_compress_normal(tdefl_compressor *d) {
const mz_uint8 *pSrc = d->m_pSrc;
size_t src_buf_left = d->m_src_buf_left;
tdefl_flush flush = d->m_flush;
while ((src_buf_left) || ((flush) && (d->m_lookahead_size))) {
mz_uint len_to_move, cur_match_dist, cur_match_len, cur_pos;
// Update di... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0xb0(%rdi), %r14
movq 0xb8(%rdi), %rbp
movl 0xa8(%rdi), %eax
movl %eax, 0x2c(%rsp)
leaq 0xc8(%rdi), %r15
leaq 0x92aa(%rdi), %rax
movq %rax, 0x30(%rsp)
leaq 0x192a2(%rdi), %rax
movq %rax, 0x40(%rsp)
testq %rbp, %rbp
j... | /aatifjiwani[P]lens-flare/CGL/include/CGL/tinyexr.h |
tdefl_compress_mem_to_heap | void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len,
size_t *pOut_len, int flags) {
tdefl_output_buffer out_buf;
MZ_CLEAR_OBJ(out_buf);
if (!pOut_len)
return MZ_FALSE;
else
*pOut_len = 0;
out_buf.m_expandable = MZ_TRUE;
if (!tdefl_compress_mem_t... | pushq %rbx
subq $0x20, %rsp
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, (%rsp)
testq %rdx, %rdx
je 0x3a183
movl %ecx, %r8d
movq %rdx, %rbx
movq $0x0, (%rdx)
movq %rsp, %rcx
movl $0x1, 0x18(%rcx)
leaq 0x25(%rip), %rdx # 0x3a18e
vzeroupper
callq 0x3a0a6
testl %eax, %eax
je 0x3a183
movq (%rsp), %rax
movq %rax, (%rbx)... | /aatifjiwani[P]lens-flare/CGL/include/CGL/tinyexr.h |
mz_zip_reader_init | mz_bool mz_zip_reader_init(mz_zip_archive *pZip, mz_uint64 size,
mz_uint32 flags) {
if ((!pZip) || (!pZip->m_pRead))
return MZ_FALSE;
if (!mz_zip_reader_init_internal(pZip, flags))
return MZ_FALSE;
pZip->m_archive_size = size;
if (!mz_zip_reader_read_central_dir(pZip, flags)) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x3a5cd
movq %rdi, %r14
cmpq $0x0, 0x40(%rdi)
je 0x3a5cd
movl %edx, %ebp
movq %rsi, %r15
movq %r14, %rdi
callq 0x3a5da
testl %eax, %eax
je 0x3a5cd
movq %r15, (%r14)
movq %r14, %rdi
movl %ebp, %esi
callq 0x3a6a9
movl $0x1, %ebx
te... | /aatifjiwani[P]lens-flare/CGL/include/CGL/tinyexr.h |
mz_zip_reader_init_mem | mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, const void *pMem,
size_t size, mz_uint32 flags) {
if (!mz_zip_reader_init_internal(pZip, flags))
return MZ_FALSE;
pZip->m_archive_size = size;
pZip->m_pRead = mz_zip_mem_read_func;
pZip->m_pIO_opaque = pZip;
#ifdef __cpluspl... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x3a5da
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x3ab16
movq %r14, (%rbx)
leaq 0x3e(%rip), %rax # 0x3ab21
movq %rax, 0x40(%rbx)
movq %rbx, 0x50(%rbx)
movq 0x58(%rbx), %rax
movq... | /aatifjiwani[P]lens-flare/CGL/include/CGL/tinyexr.h |
mz_zip_reader_is_file_encrypted | mz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip,
mz_uint file_index) {
mz_uint m_bit_flag;
const mz_uint8 *p = mz_zip_reader_get_cdh(pZip, file_index);
if (!p)
return MZ_FALSE;
m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
return (m_bit_flag &... | xorl %eax, %eax
testq %rdi, %rdi
je 0x3aca3
movq 0x58(%rdi), %rcx
testq %rcx, %rcx
je 0x3aca3
cmpl %esi, 0x10(%rdi)
jbe 0x3aca3
cmpl $0x1, 0x14(%rdi)
jne 0x3aca3
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x3aca3
movq 0x20(%rcx), %rax
movl %esi, %ecx
movl (%rax,%rcx,4), %eax
movzbl 0x8(%rdx,%rax), %eax
andl $0x1, %eax
retq
| /aatifjiwani[P]lens-flare/CGL/include/CGL/tinyexr.h |
mz_zip_reader_extract_to_mem_no_alloc | mz_bool mz_zip_reader_extract_to_mem_no_alloc(mz_zip_archive *pZip,
mz_uint file_index, void *pBuf,
size_t buf_size, mz_uint flags,
void *pUser_read_buf,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2da8, %rsp # imm = 0x2DA8
movq %rcx, %r14
testq %rcx, %rcx
setne %al
testq %rdx, %rdx
sete %cl
testb %al, %cl
jne 0x3b350
movq %r9, %r13
movl %r8d, %ebp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r12
leaq 0x68(%rsp), %rdx
callq 0x3acf3... | /aatifjiwani[P]lens-flare/CGL/include/CGL/tinyexr.h |
(anonymous namespace)::miniz::mz_zip_writer_add_put_buf_callback(void const*, int, void*) | static mz_bool mz_zip_writer_add_put_buf_callback(const void *pBuf, int len,
void *pUser) {
mz_zip_writer_add_state *pState = (mz_zip_writer_add_state *)pUser;
if ((int)pState->m_pZip->m_pWrite(pState->m_pZip->m_pIO_opaque,
pState... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %rdx
movq (%rbx), %r8
movq 0x8(%rbx), %rax
movq 0x50(%r8), %rdi
movslq %esi, %r14
movq %rax, %rsi
movq %r14, %rcx
callq *0x48(%r8)
movq %rax, %rcx
xorl %eax, %eax
cmpl %r14d, %ecx
jne 0x3c8ee
vmovq %r14, %xmm0
vpbroadcastq %xmm0, %xmm0
vpaddq 0x8(%rbx), %xmm0,... | /aatifjiwani[P]lens-flare/CGL/include/CGL/tinyexr.h |
mz_zip_add_mem_to_archive_file_in_place | mz_bool mz_zip_add_mem_to_archive_file_in_place(
const char *pZip_filename, const char *pArchive_name, const void *pBuf,
size_t buf_size, const void *pComment, mz_uint16 comment_size,
mz_uint level_and_flags) {
mz_bool status, created_new_archive = MZ_FALSE;
mz_zip_archive zip_archive;
struct MZ_FILE_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rcx, %r12
movl 0x140(%rsp), %eax
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x10(%rsp)
vmovups %ymm0, 0x30(%rsp)
vmovups %ymm0, 0x50(%rsp)
testl %eax, %eax
movl $0x6, %ebp
cmovnsl %eax, %ebp
testq %rdi, %rd... | /aatifjiwani[P]lens-flare/CGL/include/CGL/tinyexr.h |
LoadEXR | int LoadEXR(float **out_rgba, int *width, int *height, const char *filename,
const char **err) {
if (out_rgba == NULL) {
if (err) {
(*err) = "Invalid argument.\n";
}
return -1;
}
EXRImage exrImage;
InitEXRImage(&exrImage);
{
int ret = ParseMultiChannelEXRHeaderFromFile(&ex... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1078, %rsp # imm = 0x1078
movq %r8, %r15
testq %rdi, %rdi
je 0x3dd4e
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
vxorps %xmm0, %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
vmovups %ymm0, 0x1000(%rdi)
movq $0x0, 0x1020(%rdi)
mo... | /aatifjiwani[P]lens-flare/CGL/include/CGL/tinyexr.h |
ParseMultiChannelEXRHeaderFromFile | int ParseMultiChannelEXRHeaderFromFile(EXRImage *exrImage, const char *filename,
const char **err) {
if (exrImage == NULL) {
if (err) {
(*err) = "Invalid argument.";
}
return -1;
}
FILE *fp = fopen(filename, "rb");
if (!fp) {
if (err) {
(*err) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
testq %rdi, %rdi
je 0x3de8e
movq %rdi, %r14
leaq 0xa870b(%rip), %rax # 0xe64fc
movq %rsi, %rdi
movq %rax, %rsi
callq 0xead0
testq %rax, %rax
je 0x3dea1
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
c... | /aatifjiwani[P]lens-flare/CGL/include/CGL/tinyexr.h |
(anonymous namespace)::WriteAttribute(_IO_FILE*, char const*, char const*, unsigned char const*, int) | void WriteAttribute(FILE *fp, const char *name, const char *type,
const unsigned char *data, int len) {
size_t n = fwrite(name, 1, strlen(name) + 1, fp);
assert(n == strlen(name) + 1);
n = fwrite(type, 1, strlen(type) + 1, fp);
assert(n == strlen(type) + 1);
int outLen = len;
if (IsBig... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
callq 0xe3c0
leaq 0x1(%rax), %rdx
movl $0x1, %esi
movq %r12, %rdi
movq %r14, %rcx
callq 0xf1f0
movq %rax, %r13
movq %r12, %rdi
callq 0xe3c0
incq %r... | /aatifjiwani[P]lens-flare/CGL/include/CGL/tinyexr.h |
ImGuiWindow::GetID(char const*, char const*) | ImGuiID ImGuiWindow::GetID(const char* str, const char* str_end)
{
ImGuiID seed = IDStack.back();
ImGuiID id = ImHashStr(str, str_end ? (str_end - str) : 0, seed);
ImGui::KeepAliveID(id);
#ifdef IMGUI_ENABLE_TEST_ENGINE
ImGuiContext& g = *GImGui;
IMGUI_TEST_ENGINE_ID_INFO2(id, ImGuiDataType_String, ... | pushq %rax
movslq 0xc8(%rdi), %rax
testq %rax, %rax
jle 0x4cbcd
movq 0xd0(%rdi), %rcx
movl -0x4(%rcx,%rax,4), %eax
movq %rdx, %rcx
subq %rsi, %rcx
testq %rdx, %rdx
cmoveq %rdx, %rcx
movq %rsi, %rdi
movq %rcx, %rsi
movl %eax, %edx
callq 0x495ee
leaq 0x20fbcd(%rip), %rcx # 0x25c778
movq (%rcx), %rcx
cmpl %eax, 0x1b30(... | /aatifjiwani[P]lens-flare/src/imgui/imgui.cpp |
ImGui::MarkItemEdited(unsigned int) | void ImGui::MarkItemEdited(ImGuiID id)
{
// This marking is solely to be able to provide info for IsItemDeactivatedAfterEdit().
// ActiveId might have been released by the time we call this (as in the typical press/release button behavior) but still need need to fill the data.
ImGuiContext& g = *GImGui;
... | leaq 0x20f1dc(%rip), %rax # 0x25c778
movq (%rax), %rax
movl 0x1b30(%rax), %ecx
cmpl %edi, %ecx
sete %dl
testl %ecx, %ecx
sete %cl
orb %dl, %cl
jne 0x4d5bc
cmpb $0x0, 0x1e24(%rax)
je 0x4d5d4
movw $0x101, 0x1b40(%rax) # imm = 0x101
movq 0x1ae0(%rax), %rax
orl $0x4, 0x128(%rax)
retq
pushq %rax
leaq 0x9c76f(%rip), %r... | /aatifjiwani[P]lens-flare/src/imgui/imgui.cpp |
ImGui::ClosePopupsOverWindow(ImGuiWindow*, bool) | void ImGui::ClosePopupsOverWindow(ImGuiWindow* ref_window, bool restore_focus_to_window_under_popup)
{
ImGuiContext& g = *GImGui;
if (g.OpenPopupStack.Size == 0)
return;
// Don't close our own child popup windows.
int popup_count_to_keep = 0;
if (ref_window)
{
// Find the highes... | pushq %rbx
leaq 0x20d683(%rip), %rcx # 0x25c778
movq (%rcx), %rdx
movl 0x1c70(%rdx), %ecx
testq %rcx, %rcx
je 0x4f191
movq %rdi, %rax
xorl %edi, %edi
testq %rax, %rax
je 0x4f183
testl %ecx, %ecx
jle 0x4f183
movq 0x1c78(%rdx), %rdx
leaq 0x8(%rdx), %r8
xorl %edi, %edi
movq %rcx, %r9
leaq (%rdi,%rdi,2), %r10
shlq $0x4,... | /aatifjiwani[P]lens-flare/src/imgui/imgui.cpp |
ImGui::BeginChildEx(char const*, unsigned int, ImVec2 const&, bool, int) | bool ImGui::BeginChildEx(const char* name, ImGuiID id, const ImVec2& size_arg, bool border, ImGuiWindowFlags flags)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* parent_window = g.CurrentWindow;
flags |= ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFla... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0x10(%rsp)
movl %esi, %r9d
movq %rdi, %r10
leaq 0x2034ec(%rip), %rax # 0x25c778
movq (%rax), %r13
movq 0x1ae0(%r13), %rbp
vmovsd 0x270(%rbp), %xmm0
cmpq $0x0, 0x1b0(%rbp)
jne 0x592b2
cmpq $0x0, 0x1ec8(%r13)
je 0x592be
vmovs... | /aatifjiwani[P]lens-flare/src/imgui/imgui.cpp |
ImGui::DebugNodeWindowsList(ImVector<ImGuiWindow*>*, char const*) | void ImGui::DebugNodeWindowsList(ImVector<ImGuiWindow*>* windows, const char* label)
{
if (!TreeNode(label, "%s (%d)", label, windows->Size))
return;
Text("(In front-to-back order:)");
for (int i = windows->Size - 1; i >= 0; i--) // Iterate front to back
{
PushID((*windows)[i]);
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movl (%rdi), %ecx
leaq 0x8a27c(%rip), %rsi # 0xecc4e
movq %rdx, %rdi
xorl %eax, %eax
callq 0x76db9
testb %al, %al
je 0x62a48
leaq 0x8a26f(%rip), %rdi # 0xecc56
xorl %eax, %eax
callq 0x66e18
movslq (%rbx), %r15
testq %r15, %r15
jle 0x62a3e
leaq 0x8... | /aatifjiwani[P]lens-flare/src/imgui/imgui.cpp |
ImVector<ImGuiWindow*>::insert(ImGuiWindow* const*, ImGuiWindow* const&) | inline T* insert(const T* it, const T& v) { IM_ASSERT(it >= Data && it <= Data + Size); const ptrdiff_t off = it - Data; if (Size == Capacity) reserve(_grow_capacity(Size + 1)); if (off < (int)Size) memmove(Data + off + 1, Data + off, ((size_t)Size - (size_t)off) * sizeof(T)); memcpy(&Data[off], &v, sizeo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r12
cmpq %rsi, %r12
ja 0x66035
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movslq (%rdi), %rdx
leaq (%r12,%rdx,8), %rax
cmpq %rsi, %rax
jb 0x66035
subq %r12, %rbx
movq %rbx, %r13
sarq $0x3, %r13
cmpl 0x4(%r14), %edx
jne 0x... | /aatifjiwani[P]lens-flare/src/imgui/imgui.h |
ImStb::stb_textedit_drag(ImGuiInputTextState*, ImStb::STB_TexteditState*, float, float) | static void stb_textedit_drag(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
{
int p = 0;
// In single-line mode, just always make y = 0. This lets the drag keep working if the mouse
// goes off the top or bottom of the text
if( state->single_line )
{
StbTexteditRow r;
... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x17(%rsi)
je 0x73114
movslq 0x4(%r14), %rax
movq 0x18(%r14), %rdi
leaq (%rdi,%rax,2), %rsi
leaq 0x10(%rsp), %rdx
movl $0x1, %ecx
vmovss %xmm0, 0xc(%rsp)
callq 0x733c6
vmovss 0xc(%rsp), %xmm0
vxorps %xmm1, %xmm1, %xmm1
movl 0x4(%rbx), %ea... | /aatifjiwani[P]lens-flare/src/imgui/imstb_textedit.h |
ImGuiMenuColumns::DeclColumns(float, float, float) | float ImGuiMenuColumns::DeclColumns(float w0, float w1, float w2) // not using va_arg because they promote float to double
{
NextWidth = 0.0f;
NextWidths[0] = ImMax(NextWidths[0], w0);
NextWidths[1] = ImMax(NextWidths[1], w1);
NextWidths[2] = ImMax(NextWidths[2], w2);
for (int i = 0; i < IM_ARRAYSIZ... | vmovsd 0x18(%rdi), %xmm3
vinsertps $0x10, %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[2,3]
vcmpleps %xmm3, %xmm0, %xmm1
vblendvps %xmm1, %xmm3, %xmm0, %xmm0
vmovlps %xmm0, 0x18(%rdi)
vmovss 0x20(%rdi), %xmm0
vcmpless %xmm0, %xmm2, %xmm1
vblendvps %xmm1, %xmm0, %xmm2, %xmm0
vmovss %xmm0, 0x20(%rdi)
vmovss (%rdi), ... | /aatifjiwani[P]lens-flare/src/imgui/imgui_widgets.cpp |
ImGui::TableGetSortSpecs() | ImGuiTableSortSpecs* ImGui::TableGetSortSpecs()
{
ImGuiContext& g = *GImGui;
ImGuiTable* table = g.CurrentTable;
IM_ASSERT(table != NULL);
if (!(table->Flags & ImGuiTableFlags_Sortable))
return NULL;
// Require layout (in case TableHeadersRow() hasn't been called) as it may alter IsSortSpe... | pushq %rbx
leaq 0x1c1623(%rip), %rax # 0x25c778
movq (%rax), %rax
movq 0x1ec8(%rax), %rbx
testq %rbx, %rbx
je 0x9b19c
testb $0x8, 0x4(%rbx)
jne 0x9b16e
xorl %ebx, %ebx
jmp 0x9b197
cmpb $0x0, 0x249(%rbx)
jne 0x9b17f
movq %rbx, %rdi
callq 0x96710
cmpb $0x1, 0x24c(%rbx)
jne 0x9b190
movq %rbx, %rdi
callq 0x98020
addq $0... | /aatifjiwani[P]lens-flare/src/imgui/imgui_tables.cpp |
ImGui::TableGetHeaderRowHeight() | float ImGui::TableGetHeaderRowHeight()
{
// Caring for a minor edge case:
// Calculate row height, for the unlikely case that some labels may be taller than others.
// If we didn't do that, uneven header height would highlight but smaller one before the tallest wouldn't catch input for all height.
// In... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
callq 0x5d529
vmovaps %xmm0, (%rsp)
leaq 0x1c108c(%rip), %r14 # 0x25c778
movq (%r14), %rax
movq 0x1ec8(%rax), %rax
testq %rax, %rax
je 0x9b75e
movl 0x6c(%rax), %ebp
testl %ebp, %ebp
jle 0x9b75e
xorl %ebx, %ebx
movl %ebx, %edi
callq 0x9a645
btl $0x14, %eax
jae 0x9b758... | /aatifjiwani[P]lens-flare/src/imgui/imgui_tables.cpp |
base64_decode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string base64_decode(std::string const& encoded_string) {
int in_len = encoded_string.size();
int i = 0;
int j = 0;
int in_ = 0;
unsigned char char_array_4[4], char_array_3[3];
std::string ret;
while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
char_array_4[i++... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movl 0x8(%rsi), %r12d
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testl %r12d, %r12d
je 0xa3425
xorl %r14d, %r14d
leaq 0x1becda(%rip), %r15... | /aatifjiwani[P]lens-flare/CGL/src/base64.cpp |
glfwAllocJoystick | _GLFWjoystick* _glfwAllocJoystick(const char* name,
const char* guid,
int axisCount,
int buttonCount,
int hatCount)
{
int jid;
_GLFWjoystick* js;
for (jid = 0; jid <= GLF... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %r14
movl $0x408, %ebx # imm = 0x408
addq 0xd8f69(%rip), %rbx # 0x1aafa0
movl $0x10, %eax
cmpl $0x0, (%rbx)
je 0xd2051
addq $0x1fa0, %rbx # imm = 0x1FA0
decq... | /aatifjiwani[P]lens-flare/CGL/deps/glfw/src/input.c |
glfwCreateStandardCursor | GLFWAPI GLFWcursor* glfwCreateStandardCursor(int shape)
{
_GLFWcursor* cursor;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (shape != GLFW_ARROW_CURSOR &&
shape != GLFW_IBEAM_CURSOR &&
shape != GLFW_CROSSHAIR_CURSOR &&
shape != GLFW_POINTING_HAND_CURSOR &&
shape != GLFW_RESIZE_EW... | pushq %r15
pushq %r14
pushq %rbx
leaq 0x19461f(%rip), %r15 # 0x266ff0
cmpl $0x0, (%r15)
je 0xd2a00
movl %edi, %r14d
leal -0x3600b(%r14), %eax
cmpl $-0xb, %eax
ja 0xd2a12
leaq 0xad25e(%rip), %rsi # 0x17fc4b
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
movl %r14d, %edx
xorl %eax, %eax
callq 0xd177d... | /aatifjiwani[P]lens-flare/CGL/deps/glfw/src/input.c |
glfwSetJoystickUserPointer | GLFWAPI void glfwSetJoystickUserPointer(int jid, void* pointer)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT();
js = _glfw.joysticks + jid;
if (!js->present)
return;
js->userPointer = pointer;
} | pushq %rax
testl %edi, %edi
js 0xd3249
cmpl $0x10, %edi
jae 0xd3268
leaq 0x193ddd(%rip), %rax # 0x266ff0
cmpl $0x0, (%rax)
je 0xd323a
movl %edi, %ecx
imulq $0x1fa0, %rcx, %rcx # imm = 0x1FA0
cmpl $0x0, 0x408(%rax,%rcx)
je 0xd3238
addq %rcx, %rax
addq $0x408, %rax # imm = 0x408
movq %rsi, 0x40(%rax)
po... | /aatifjiwani[P]lens-flare/CGL/deps/glfw/src/input.c |
glfwGetWindowPropertyX11 | unsigned long _glfwGetWindowPropertyX11(Window window,
Atom property,
Atom type,
unsigned char** value)
{
Atom actualType;
int actualFormat;
unsigned long itemCount, bytesAfter;
XGetW... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rax
movq %rdx, %r10
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x18c906(%rip), %r11 # 0x266ff0
movq 0x1fec0(%r11), %rdi
leaq 0x10(%rsp), %rbx
leaq 0x18(%rsp), %r14
leaq 0xc(%rsp), %r15
leaq 0x20(%rsp), %r12
movabsq $0x7fffffffffffffff, %r8 # imm = 0x... | /aatifjiwani[P]lens-flare/CGL/deps/glfw/src/x11_window.c |
releaseMonitor | static void releaseMonitor(_GLFWwindow* window)
{
if (window->monitor->window != window)
return;
_glfwInputMonitorWindow(window->monitor, NULL);
_glfwRestoreVideoModeX11(window->monitor);
_glfw.x11.saver.count--;
if (_glfw.x11.saver.count == 0)
{
// Restore old screen saver se... | pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
cmpq %rbx, 0x18(%rdi)
jne 0xdba4a
xorl %esi, %esi
callq 0xd4486
movq 0x40(%rbx), %rdi
callq 0xd9e00
leaq 0x18b5ae(%rip), %rax # 0x266ff0
decl 0x21050(%rax)
je 0xdba4c
popq %rbx
retq
movq 0x20e88(%rax), %r9
movq 0x1fec0(%rax), %rdi
movl 0x21054(%rax), %esi
movl 0x21058... | /aatifjiwani[P]lens-flare/CGL/deps/glfw/src/x11_window.c |
chooseGLXFBConfig | static GLFWbool chooseGLXFBConfig(const _GLFWfbconfig* desired,
GLXFBConfig* result)
{
GLXFBConfig* nativeConfigs;
_GLFWfbconfig* usableConfigs;
const _GLFWfbconfig* closest;
int i, nativeCount, usableCount;
const char* vendor;
GLFWbool trustWindowBit = GLFW_TRU... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
leaq 0x186ecd(%rip), %r12 # 0x266ff0
movq 0x1fec0(%r12), %rdi
movl $0x1, %esi
callq *0x211c8(%r12)
testq %rax, %rax
je 0xe0155
leaq 0xa465a(%rip), %rsi # 0x18479e
movq %rax, %rdi
callq 0xed00
... | /aatifjiwani[P]lens-flare/CGL/deps/glfw/src/glx_context.c |
handleAbsEvent | static void handleAbsEvent(_GLFWjoystick* js, int code, int value)
{
const int index = js->linjs.absMap[code];
if (code >= ABS_HAT0X && code <= ABS_HAT3Y)
{
static const char stateMap[3][3] =
{
{ GLFW_HAT_CENTERED, GLFW_HAT_UP, GLFW_HAT_DOWN },
{ GLFW_HAT_LEFT,... | movl %esi, %eax
movslq %esi, %rcx
movl 0x187c(%rdi,%rcx,4), %esi
movl %ecx, %r8d
andl $-0x8, %r8d
cmpl $0x10, %r8d
jne 0xe2989
leal -0x10(%rax), %ecx
shrl %ecx
andl $0x1, %eax
leaq (%rdi,%rcx,8), %rcx
addq $0x1f7c, %rcx # imm = 0x1F7C
movl %eax, %eax
testl %edx, %edx
je 0xe29cb
js 0xe29d4
movl $0x2, (%rcx,%ra... | /aatifjiwani[P]lens-flare/CGL/deps/glfw/src/linux_joystick.c |
VELOCYPACK_XXH3_64bits_digest | XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_digest(const XXH3_state_t* state) {
const unsigned char* const secret =
(state->extSecret == NULL) ? state->customSecret : state->extSecret;
if (state->totalLen > XXH3_MIDSIZE_MAX) {
XXH_ALIGN(XXH_ACC_ALIGN) XXH64_hash_t acc[XXH_ACC_NB];
XXH3_digest_long(acc, st... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq 0x210(%rdi), %rsi
movq 0x238(%rdi), %rax
leaq 0x40(%rdi), %rbx
testq %rax, %rax
cmovneq %rax, %rbx
cmpq $0xf1, %rsi
jb 0x1079f
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x107ed
addq $0xb, %rbx
movabsq $-0x61c8864e7a143579... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_mergeAccs | static XXH64_hash_t XXH3_mergeAccs(const xxh_u64* XXH_RESTRICT acc,
const xxh_u8* XXH_RESTRICT secret,
xxh_u64 start) {
xxh_u64 result64 = start;
size_t i = 0;
for (i = 0; i < 4; i++) {
result64 += XXH3_mix2Accs(acc + 2 * i, secret + 16 * ... | movq %rdx, %xmm0
xorl %r9d, %r9d
movdqu (%rdi,%r9), %xmm1
movdqu 0x10(%rdi,%r9), %xmm2
movdqu (%rsi,%r9), %xmm3
movdqu 0x10(%rsi,%r9), %xmm4
movdqa %xmm3, %xmm5
punpcklqdq %xmm4, %xmm5 # xmm5 = xmm5[0],xmm4[0]
movdqa %xmm1, %xmm6
punpcklqdq %xmm2, %xmm6 # xmm6 = xmm6[0],xmm2[0]
pxor %xmm5, %xmm6
punpckhqdq %xmm4,... | /arangodb[P]velocypack/src/xxhash.h |
event_print | static void event_print(telnet_t *telnet, telnet_event_t *ev, void *ud) {
size_t i;
state_t *state;
(void)telnet;
state = (state_t *)ud;
switch (ev->type) {
case TELNET_EV_DATA:
stprintf(state, "DATA [%zi] ==> ", ev->data.size);
print_encode(state, ev->data.buffer, ev->data.size);
stprintf(state, "\n");
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rsi), %eax
cmpq $0xe, %rax
ja 0x19ca
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x392d(%rip), %rcx # 0x5010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%r14), %rdx
leaq 0x3bd8(%rip), %rsi # 0x52cf
movq %rbx, %rdi... | /fluffos[P]libtelnet/util/telnet-test.c |
telnet_recv | void telnet_recv(telnet_t *telnet, const char *buffer,
size_t size) {
#if defined(HAVE_ZLIB)
/* if we have an inflate (decompression) zlib stream, use it */
if (telnet->z != 0 && !(telnet->flags & TELNET_PFLAG_DEFLATE)) {
char inflate_buffer[1024];
int rs;
/* initialize zlib state */
telnet->z->next_in = (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x430, %rsp # imm = 0x430
movq %rdi, %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x21ee
cmpb $0x0, 0x44(%rbx)
js 0x21ee
movq %rsi, (%rax)
movl %edx, 0x8(%rax)
leaq 0x30(%rsp), %r14
movq %r14, 0x18(%rax)
movl $0x400, 0x20(%rax) # imm = 0x400... | /fluffos[P]libtelnet/libtelnet.c |
telnet_vprintf | int telnet_vprintf(telnet_t *telnet, const char *fmt, va_list va) {
va_list va_temp;
char buffer[1024];
char *output = buffer;
unsigned int rs, i, l;
/* format */
va_copy(va_temp, va);
rs = vsnprintf(buffer, sizeof(buffer), fmt, va_temp);
va_end(va_temp);
if (rs >= sizeof(buffer)) {
output = (char*)malloc(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp # imm = 0x438
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movups (%rdx), %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movq 0x10(%rdx), %rax
movq %rax, 0x10(%rcx)
leaq 0x30(%rsp), %r15
movl $0x400, %esi # im... | /fluffos[P]libtelnet/libtelnet.c |
telnet_send_vzmpv | void telnet_send_vzmpv(telnet_t *telnet, va_list va) {
const char* arg;
/* ZMP header */
telnet_begin_sb(telnet, TELNET_TELOPT_ZMP);
/* send out each argument, including trailing NUL byte */
while ((arg = va_arg(va, const char *)) != 0)
telnet_zmp_arg(telnet, arg);
/* ZMP footer */
telnet_finish_zmp(telnet)... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb(%rsp), %rsi
movw $0xfaff, (%rsi) # imm = 0xFAFF
movb $0x5d, 0x2(%rsi)
movl $0x3, %edx
callq 0x257f
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x3366
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0... | /fluffos[P]libtelnet/libtelnet.c |
benchmark::State::KeepRunning() | bool KeepRunning() {
if (BENCHMARK_BUILTIN_EXPECT(!started_, false)) {
assert(!finished_);
started_ = true;
ResumeTiming();
}
bool const res = total_iterations_++ < max_iterations;
if (BENCHMARK_BUILTIN_EXPECT(!res, false)) {
assert(started_ && (!finished_ || error_occurred_));
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x1a5aa
movq 0x8(%rbx), %r15
movq 0x48(%rbx), %r14
leaq 0x1(%r15), %rax
movq %rax, 0x8(%rbx)
cmpq %r14, %r15
jae 0x1a5b4
cmpq %r14, %r15
setb %al
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x198b0
jmp 0x1a589
leaq 0x8(%rbx), %rdx
leaq 0... | /jtomschroeder[P]lambda/vendor/benchmark/include/benchmark/benchmark_api.h |
benchmark::internal::BenchmarkFamilies::AddBenchmark(std::unique_ptr<benchmark::internal::Benchmark, std::default_delete<benchmark::internal::Benchmark>>) | size_t BenchmarkFamilies::AddBenchmark(std::unique_ptr<Benchmark> family) {
MutexLock l(mutex_);
size_t index = families_.size();
families_.push_back(std::move(family));
return index;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rdi), %rax
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movb $0x0, 0x8(%rbx)
movq %rbx, %rdi
callq 0x1e4e6
movb $0x1, 0x8(%rbx)
movq (%r15), %r12
movq 0x8(%r15), %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1f4a0
subq %r12... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::internal::BenchmarkFamilies::FindBenchmarks(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<benchmark::internal::Benchmark::Instance, std::allocator<benchmark::internal::Benchmark::Instance>>*) | bool BenchmarkFamilies::FindBenchmarks(
const std::string& spec,
std::vector<Benchmark::Instance>* benchmarks) {
// Make regular expression out of command-line flag
std::string error_msg;
Regex re;
if (!re.Init(spec, &error_msg)) {
std::cerr << "Could not compile benchmark re: " << error_msg << std:... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rdx, 0xb8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf0(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x120(%rsp), %rdi
callq 0x25abc
leaq 0x120(%rsp), %rdi
leaq 0xe0(%r... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::internal::BenchmarkImp::BenchmarkImp(char const*) | BenchmarkImp::BenchmarkImp(const char* name)
: name_(name), report_mode_(RM_Unspecified), time_unit_(kNanosecond),
range_multiplier_(kRangeMultiplier), min_time_(0.0), repetitions_(0),
use_real_time_(false), use_manual_time_(false),
complexity_(oNone) {
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %rdx
callq 0x19160
xorl %eax, %eax
movl %eax, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x34(%rbx)
movl $0x8, 0x44(%rbx)
movl %eax, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq %rax, 0x78(%rbx)
movq %rax, 0x48(%rbx)
movq %rax, 0x4e(%rbx)... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::internal::BenchmarkImp::~BenchmarkImp() | BenchmarkImp::~BenchmarkImp() {
} | pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
testq %rdi, %rdi
je 0x1acf4
callq 0x19430
leaq 0x28(%rbx), %rdi
callq 0x1e042
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x1ad0f
popq %rbx
jmp 0x19430
popq %rbx
retq
nop
| /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::internal::BenchmarkImp::Arg(int) | void BenchmarkImp::Arg(int x) {
CHECK(ArgsCnt() == -1 || ArgsCnt() == 1);
args_.push_back({x});
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x28(%rdi), %rcx
cmpq 0x30(%rdi), %rcx
je 0x1ad48
movq 0x8(%rcx), %rax
subq (%rcx), %rax
movabsq $0x3fffffffc, %rcx # imm = 0x3FFFFFFFC
andq %rcx, %rax
cmpq %rcx, %rax
je 0x1ad48
cmpq $0x4, %rax
jne 0x1ad92
addq $0x28, %rbx
call... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::internal::BenchmarkImp::Range(int, int) | void BenchmarkImp::Range(int start, int limit) {
CHECK(ArgsCnt() == -1 || ArgsCnt() == 1);
std::vector<int> arglist;
AddRange(&arglist, start, limit, range_multiplier_);
for (int i : arglist) {
args_.push_back({i});
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x28(%rdi), %rcx
cmpq 0x30(%rdi), %rcx
je 0x1ae23
movq 0x8(%rcx), %rax
subq (%rcx), %rax
movabsq $0x3fffffffc, %rcx # imm = 0x3FFFFFFFC
andq %rcx, %rax
cmpq %rcx, %rax
je 0x1ae23... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::internal::BenchmarkImp::Ranges(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&) | void BenchmarkImp::Ranges(const std::vector<std::pair<int, int>>& ranges) {
std::vector<std::vector<int>> arglists(ranges.size());
int total = 1;
for (std::size_t i = 0; i < ranges.size(); i++) {
AddRange(&arglists[i], ranges[i].first, ranges[i].second, range_multiplier_);
total *= arglists[i].size();
}... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %r13
movq 0x8(%rsi), %rsi
subq (%r14), %rsi
sarq $0x3, %rsi
leaq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x1e240
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x1b292
movl $0x1, %ebp
movq 0x8(%rsp), %rdi
xorl %... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::internal::BenchmarkImp::UseRealTime() | void BenchmarkImp::UseRealTime() {
CHECK(!use_manual_time_) << "Cannot set UseRealTime and UseManualTime simultaneously.";
use_real_time_ = true;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movb 0x55(%rdi), %bpl
testb %bpl, %bpl
je 0x1b579
leaq 0x18e3a(%rip), %rsi # 0x3438d
leaq 0x18d56(%rip), %rdx # 0x342b0
leaq 0x18e3e(%rip), %rcx # 0x3439f
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x256, %r8d # imm = 0x256
callq 0... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::internal::BenchmarkImp::UseManualTime() | void BenchmarkImp::UseManualTime() {
CHECK(!use_real_time_) << "Cannot set UseRealTime and UseManualTime simultaneously.";
use_manual_time_ = true;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movb 0x54(%rdi), %bpl
testb %bpl, %bpl
je 0x1b60f
leaq 0x18dfb(%rip), %rsi # 0x343e4
leaq 0x18cc0(%rip), %rdx # 0x342b0
leaq 0x18dfd(%rip), %rcx # 0x343f4
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x25b, %r8d # imm = 0x25B
callq 0... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
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.