name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
ear::PolarSpeakerPosition::~PolarSpeakerPosition()
|
struct EAR_EXPORT PolarSpeakerPosition {
PolarSpeakerPosition(double az = 0.0, double el = 0.0, double dist = 1.0)
: azimuth(az), elevation(el), distance(dist){};
double azimuth;
boost::optional<double> azimuthMin;
boost::optional<double> azimuthMax;
double elevation;
boost::optional<double> elevationMin;
boost::optional<double> elevationMax;
double distance;
boost::optional<double> distanceMin;
boost::optional<double> distanceMax;
ScreenEdgeLock screenEdgeLock;
}
|
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0xa0(%rdi)
jne 0x60f18
movq 0xa8(%rbx), %rdi
leaq 0xb8(%rbx), %rax
cmpq %rax, %rdi
je 0x60f11
movq (%rax), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0xa0(%rbx)
cmpb $0x1, 0x78(%rbx)
jne 0x60f40
movq 0x80(%rbx), %rdi
leaq 0x90(%rbx), %rax
cmpq %rax, %rdi
je 0x60f3c
movq (%rax), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0x78(%rbx)
popq %rbx
retq
|
/ebu[P]libear/include/ear/metadata.hpp
|
void ear::mask_write<ear::OutputGains&, Eigen::CwiseUnaryOp<Eigen::internal::scalar_boolean_not_op<bool>, Eigen::Array<bool, -1, 1, 0, -1, 1> const>, Eigen::Matrix<double, -1, 1, 0, -1, 1>>(ear::OutputGains&, Eigen::CwiseUnaryOp<Eigen::internal::scalar_boolean_not_op<bool>, Eigen::Array<bool, -1, 1, 0, -1, 1> const> const&, Eigen::Matrix<double, -1, 1, 0, -1, 1> const&)
|
void mask_write(OutT &&out, const MaskT &mask, const ValuesT &values) {
Eigen::Index out_size = out.size();
Eigen::Index mask_size = mask.size();
Eigen::Index values_size = values.size();
ear_assert(
out_size == mask_size,
"in mask_write: out_size and mask_write must be the same length");
Eigen::Index j = 0;
for (Eigen::Index i = 0; i < mask_size; i++)
if (mask[i]) vec_write(out, i, values[j++]);
ear_assert(j == values_size,
"in mask_size: length of values must equal the number of "
"entries in mask");
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %r12
movq (%r14), %rax
cmpq 0x8(%rax), %r12
jne 0x6107c
movq 0x8(%rbx), %rax
movq %rax, 0x20(%rsp)
testq %r12, %r12
jle 0x6102a
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%r14), %rax
cmpq %r13, 0x8(%rax)
jle 0x61046
movq (%rax), %rax
cmpb $0x0, (%rax,%r13)
jne 0x61020
testq %rbp, %rbp
js 0x6105d
cmpq %rbp, 0x8(%rbx)
jle 0x6105d
movq (%rbx), %rax
movsd (%rax,%rbp,8), %xmm0
incq %rbp
movq (%r15), %rax
movq %r15, %rdi
movq %r13, %rsi
callq *0x10(%rax)
incq %r13
cmpq %r13, %r12
jne 0x60feb
jmp 0x6102c
xorl %ebp, %ebp
cmpq 0x20(%rsp), %rbp
jne 0x610ce
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x52726(%rip), %rdi # 0xb3773
leaq 0x5273c(%rip), %rsi # 0xb3790
leaq 0x760f8(%rip), %rcx # 0xd7153
jmp 0x61072
leaq 0x5270f(%rip), %rdi # 0xb3773
leaq 0x52725(%rip), %rsi # 0xb3790
leaq 0x56cfd(%rip), %rcx # 0xb7d6f
movl $0xa3, %edx
callq 0x143c0
movl $0x10, %edi
callq 0x14290
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x539a7(%rip), %rsi # 0xb4a40
leaq 0x539de(%rip), %rdx # 0xb4a7e
movq %rsp, %rdi
callq 0x37fd8
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x42fb0
xorl %ebp, %ebp
leaq 0xaa5c9(%rip), %rsi # 0x10b688
movq 0xaeeb2(%rip), %rdx # 0x10ff78
movq %rbx, %rdi
callq 0x14a60
movl $0x10, %edi
callq 0x14290
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x53994(%rip), %rsi # 0xb4a7f
leaq 0x539d4(%rip), %rdx # 0xb4ac6
movq %rsp, %rdi
callq 0x37fd8
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x42fb0
xorl %ebp, %ebp
leaq 0xaa577(%rip), %rsi # 0x10b688
movq 0xaee60(%rip), %rdx # 0x10ff78
movq %rbx, %rdi
callq 0x14a60
jmp 0x61124
jmp 0x61144
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6113d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x145f0
testb %bpl, %bpl
jne 0x61147
jmp 0x6114f
movq %rax, %r14
movq %rbx, %rdi
callq 0x14460
movq %r14, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/src/direct_speakers/../common/helpers/eigen_helpers.hpp
|
ear::PolarExtentCoreScalar::run(ear::PolarExtentCoreContext&) const
|
void run(PolarExtentCoreContext &ctx) const override {
for (size_t speaker_idx = 0; speaker_idx < ctx.num_speakers;
speaker_idx++)
ctx.results[speaker_idx] = 0.0;
for (size_t i = 0; i < ctx.num_points; i++) {
ExtentPosition pos;
pos.x = ctx.xs[i];
pos.y = ctx.ys[i];
pos.z = ctx.zs[i];
extent_float_t weight = ctx.is_circular ? weight_circle(ctx, pos)
: weight_stadium(ctx, pos);
// add to results, using summed_panning_results for both as this is in
// a more efficient order
if (weight == 1.0) {
for (size_t speaker_idx = 0; speaker_idx < ctx.num_speakers;
speaker_idx++) {
extent_float_t gain =
ctx.summed_panning_results[i * ctx.num_speakers + speaker_idx];
ctx.results[speaker_idx] += gain;
}
} else if (weight != 0) {
for (size_t speaker_idx = 0; speaker_idx < ctx.num_speakers;
speaker_idx++) {
extent_float_t gain =
ctx.summed_panning_results[i * ctx.num_speakers + speaker_idx];
ctx.results[speaker_idx] += weight * gain;
}
}
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x6f872
movq 0x90(%rbx), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x14330
cmpq $0x0, (%rbx)
je 0x6f96f
xorl %r12d, %r12d
leaq 0x4(%rsp), %r15
xorl %r13d, %r13d
movq 0x18(%rbx), %rax
movss (%rax,%r13,4), %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x20(%rbx), %rax
movss (%rax,%r13,4), %xmm0
movss %xmm0, 0x8(%rsp)
movq 0x28(%rbx), %rax
movss (%rax,%r13,4), %xmm0
movss %xmm0, 0xc(%rsp)
cmpb $0x1, 0x40(%rbx)
jne 0x6f8cd
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x6f97e
jmp 0x6f8db
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x6f9f2
ucomiss 0x465a6(%rip), %xmm0 # 0xb5e88
jne 0x6f91c
jp 0x6f91c
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x6f95f
movq 0x90(%rbx), %rcx
movq %rax, %rdx
imulq %r12, %rdx
addq 0x38(%rbx), %rdx
xorl %esi, %esi
movss (%rdx,%rsi,4), %xmm0
addss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rax
jne 0x6f903
jmp 0x6f95f
ucomiss 0x67eb5(%rip), %xmm0 # 0xd77d8
jne 0x6f927
jnp 0x6f95f
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x6f95f
movq 0x90(%rbx), %rcx
movq %rax, %rdx
imulq %r12, %rdx
addq 0x38(%rbx), %rdx
xorl %esi, %esi
movss (%rdx,%rsi,4), %xmm1
mulss %xmm0, %xmm1
addss (%rcx,%rsi,4), %xmm1
movss %xmm1, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rax
jne 0x6f944
incq %r13
addq $0x4, %r12
cmpq (%rbx), %r13
jb 0x6f887
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/ebu[P]libear/src/object_based/polar_extent_scalar.cpp
|
ear::PolarExtentCoreScalar::weight_circle(ear::PolarExtentCoreContext&, ear::ExtentPosition const&) const
|
extent_float_t dot(const extent_float_t *vec) const {
return x * vec[0] + y * vec[1] + z * vec[2];
}
|
pushq %rbx
subq $0x10, %rsp
movss (%rdx), %xmm1
movss 0x4(%rdx), %xmm0
mulss 0x54(%rsi), %xmm0
mulss 0x50(%rsi), %xmm1
addss %xmm0, %xmm1
movss 0x8(%rdx), %xmm0
mulss 0x58(%rsi), %xmm0
addss %xmm1, %xmm0
ucomiss 0x78(%rsi), %xmm0
jae 0x6f9e1
movq %rsi, %rbx
movss 0x7c(%rsi), %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm2
jae 0x6f9e9
movss 0x88(%rbx), %xmm1
movss %xmm1, 0xc(%rsp)
callq 0x14670
mulss 0xc(%rsp), %xmm0
addss 0x8c(%rbx), %xmm0
jmp 0x6f9ec
movss 0x4649f(%rip), %xmm1 # 0xb5e88
movaps %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
|
/ebu[P]libear/src/object_based/polar_extent_scalar.cpp
|
ear::PolarExtentCoreScalar::weight_stadium(ear::PolarExtentCoreContext&, ear::ExtentPosition const&) const
|
extent_float_t weight_stadium(PolarExtentCoreContext &ctx,
const ExtentPosition &position) const {
ExtentPosition position_t = position.transform(ctx.flippedBasis);
ExtentPosition position_t_right = position_t;
position_t_right.x = std::abs(position_t.x);
auto circle_test_dot = position_t_right.x * ctx.circle_test[0] +
position_t_right.y * ctx.circle_test[1];
bool in_straight_line_part = circle_test_dot >= 0.0;
if (in_straight_line_part)
return weight_from_sin(ctx, std::abs(position_t.z));
else {
auto circle_dot = position_t_right.x * ctx.right_circle_centre[0] +
position_t_right.y * ctx.right_circle_centre[1];
return weight_from_cos(ctx, circle_dot);
}
}
|
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rdi
movq %rsi, %rbx
addq $0x44, %rsi
callq 0x6fac0
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2 # xmm2 = xmm2[1,1],xmm0[1,1]
andps 0x5cffc(%rip), %xmm0 # 0xcca10
movss 0x6c(%rbx), %xmm3
mulss %xmm2, %xmm3
movss 0x68(%rbx), %xmm4
mulss %xmm0, %xmm4
addss %xmm3, %xmm4
xorps %xmm3, %xmm3
ucomiss %xmm3, %xmm4
jae 0x6fa68
mulss 0x74(%rbx), %xmm2
mulss 0x70(%rbx), %xmm0
addss %xmm2, %xmm0
ucomiss 0x78(%rbx), %xmm0
jae 0x6faae
movss 0x7c(%rbx), %xmm1
xorps %xmm2, %xmm2
ucomiss %xmm0, %xmm1
jae 0x6fab6
movss 0x88(%rbx), %xmm1
movss %xmm1, 0xc(%rsp)
callq 0x14670
jmp 0x6fa9e
andps 0x5cfa1(%rip), %xmm1 # 0xcca10
movss 0x80(%rbx), %xmm0
ucomiss %xmm1, %xmm0
jae 0x6faae
xorps %xmm2, %xmm2
ucomiss 0x84(%rbx), %xmm1
jae 0x6fab6
movss 0x88(%rbx), %xmm0
movss %xmm0, 0xc(%rsp)
movaps %xmm1, %xmm0
callq 0x14950
mulss 0xc(%rsp), %xmm0
addss 0x8c(%rbx), %xmm0
jmp 0x6fab9
movss 0x463d2(%rip), %xmm2 # 0xb5e88
movaps %xmm2, %xmm0
addq $0x10, %rsp
popq %rbx
retq
nop
|
/ebu[P]libear/src/object_based/polar_extent_scalar.cpp
|
ear::convex_hull(std::vector<Eigen::Matrix<double, 3, 1, 0, 3, 1>, std::allocator<Eigen::Matrix<double, 3, 1, 0, 3, 1>>> const&, double)
|
std::vector<Facet> convex_hull(const std::vector<Eigen::Vector3d> &positions,
double tolerance) {
using Vec = Eigen::Vector3d;
using Tri = std::array<size_t, 3>;
// the mean point, guaranteed to be inside the convex hull
Vec inside_point = Vec::Zero();
for (auto &pos : positions) inside_point += pos;
inside_point /= (double)positions.size();
// find all triangles on the convex hull:
// - iterate through all possible triangles
// - find the triangle normal, checking for collinearity
// - it's on the convex hull if:
// - the inside point is not on the plane of the triangle
// - all points are on the same side of the plane of the triangle as the
// inside point
std::vector<Tri> hull_tris;
std::vector<Vec> hull_tri_normals;
for (size_t i = 0; i < positions.size(); i++)
for (size_t j = i + 1; j < positions.size(); j++)
for (size_t k = j + 1; k < positions.size(); k++) {
Vec normal =
(positions[j] - positions[i]).cross(positions[k] - positions[i]);
ear_assert(normal.squaredNorm() > tolerance,
"collinear points in convex hull");
normal.normalize(); // XXX: not really required, but helps make
// tolerances consistent
double dot_inside = normal.dot(inside_point - positions[i]);
if (std::abs(dot_inside) < tolerance)
continue; // tri coplanar with inside point
bool points_on_same_side_as_inside = true;
for (auto &pos : positions) {
double dot_point = normal.dot(pos - positions[i]);
// check if signs are equal, with tolerance
if (!(dot_inside > 0 ? dot_point > -tolerance
: dot_point < tolerance)) {
points_on_same_side_as_inside = false;
break;
}
}
if (points_on_same_side_as_inside) {
hull_tris.push_back({i, j, k});
hull_tri_normals.push_back(normal);
}
}
// merge coplanar triangles into facets
std::vector<Facet> hull_facets;
std::vector<Vec> hull_facet_normals;
for (size_t tri_i = 0; tri_i < hull_tris.size(); tri_i++) {
const Vec &tri_point = positions[hull_tris[tri_i][0]];
const Vec &tri_norm = hull_tri_normals[tri_i];
// check each facet to see if this triangle is on the same plane.
// if it is, add the points to the facet. if no facet is found, make a
// new facet.
bool found_facet = false;
for (size_t facet_i = 0; facet_i < hull_facets.size(); facet_i++) {
const Vec &facet_norm = hull_facet_normals[facet_i];
const Vec &facet_point = positions[*hull_facets[facet_i].begin()];
// they are on the same plane if the line between the test points is
// not along the normal, and if the normals point in the same or
// opposite direction. alternatively, we could just test all tri
// vertices.
if (std::abs((tri_point - facet_point).dot(facet_norm)) < tolerance &&
facet_norm.cross(tri_norm).squaredNorm() < tolerance) {
for (size_t corner_idx : hull_tris[tri_i]) {
hull_facets[facet_i].insert((Facet::value_type)corner_idx);
}
found_facet = true;
break;
}
}
if (!found_facet) {
Facet f;
for (size_t corner_idx : hull_tris[tri_i])
f.insert((Facet::value_type)corner_idx);
hull_facets.push_back(std::move(f));
hull_facet_normals.push_back(tri_norm);
}
}
return hull_facets;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movapd %xmm0, 0x70(%rsp)
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
xorpd %xmm0, %xmm0
cmpq %rcx, %rax
je 0x6fb82
xorpd %xmm2, %xmm2
xorpd %xmm6, %xmm6
movq %rax, %rdx
movupd (%rdx), %xmm1
addpd %xmm1, %xmm2
addsd 0x10(%rdx), %xmm6
addq $0x18, %rdx
cmpq %rcx, %rdx
jne 0x6fb6a
jmp 0x6fb8a
xorpd %xmm6, %xmm6
xorpd %xmm2, %xmm2
xorl %esi, %esi
movq %rcx, %rdx
movapd %xmm0, 0x30(%rsp)
movq %rsi, 0x40(%rsp)
movq %rsi, 0x60(%rsp)
movapd %xmm0, 0x50(%rsp)
subq %rax, %rdx
je 0x701b4
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rdx
movq %rdx, %xmm0
punpckldq 0x5dad3(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x5dadb(%rip), %xmm0 # 0xcd6b0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addpd %xmm0, %xmm1
divsd %xmm1, %xmm6
unpcklpd %xmm1, %xmm1 # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm2
movapd %xmm2, 0xc0(%rsp)
movapd 0x40492(%rip), %xmm0 # 0xb0090
xorpd 0x70(%rsp), %xmm0
movapd %xmm0, 0xb0(%rsp)
xorl %r15d, %r15d
movsd %xmm6, 0xe0(%rsp)
leaq 0x1(%r15), %rdi
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rdx
movq %rdi, %r12
movq %rdi, 0xd0(%rsp)
cmpq %rdx, %rdi
jae 0x6fee9
leaq 0x1(%r12), %r13
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rdx
cmpq %rdx, %r13
movq %r13, 0xd8(%rsp)
jae 0x6feca
leaq (%r12,%r12,2), %rbp
leaq (%r15,%r15,2), %rbx
leaq (,%r13,2), %rdx
addq %r13, %rdx
movsd 0x8(%rax,%rdx,8), %xmm2
movsd (%rax,%rbx,8), %xmm1
movsd (%rax,%rbp,8), %xmm0
subsd %xmm1, %xmm0
movupd 0x8(%rax,%rbx,8), %xmm3
movupd 0x8(%rax,%rbp,8), %xmm4
subpd %xmm3, %xmm4
subsd %xmm3, %xmm2
movsd 0x10(%rax,%rdx,8), %xmm5
movhpd (%rax,%rdx,8), %xmm5 # xmm5 = xmm5[0],mem[0]
shufpd $0x1, %xmm1, %xmm3 # xmm3 = xmm3[1],xmm1[0]
subpd %xmm3, %xmm5
movapd %xmm4, %xmm1
shufpd $0x1, %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[0]
mulsd %xmm2, %xmm0
unpcklpd %xmm5, %xmm2 # xmm2 = xmm2[0],xmm5[0]
mulpd %xmm1, %xmm2
movapd %xmm4, %xmm1
mulpd %xmm5, %xmm1
subpd %xmm2, %xmm1
unpckhpd %xmm5, %xmm5 # xmm5 = xmm5[1,1]
mulsd %xmm4, %xmm5
subsd %xmm5, %xmm0
movapd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x20(%rsp)
movapd %xmm1, %xmm2
mulpd %xmm1, %xmm2
movapd %xmm2, %xmm3
unpckhpd %xmm2, %xmm3 # xmm3 = xmm3[1],xmm2[1]
addsd %xmm2, %xmm3
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
ucomisd 0x70(%rsp), %xmm2
jbe 0x7020b
ucomisd 0x5d8fd(%rip), %xmm2 # 0xcd630
jbe 0x6fd55
movq %xmm2, %xmm2 # xmm2 = xmm2[0],zero
sqrtpd %xmm2, %xmm2
divsd %xmm2, %xmm0
unpcklpd %xmm2, %xmm2 # xmm2 = xmm2[0,0]
divpd %xmm2, %xmm1
movapd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x20(%rsp)
movapd 0xc0(%rsp), %xmm3
leaq (%rax,%rbx,8), %rdx
movupd (%rdx), %xmm2
subpd %xmm2, %xmm3
mulpd %xmm1, %xmm3
movapd %xmm3, %xmm5
unpckhpd %xmm3, %xmm5 # xmm5 = xmm5[1],xmm3[1]
addsd %xmm3, %xmm5
movsd 0x10(%rdx), %xmm3
movapd %xmm6, %xmm4
subsd %xmm3, %xmm4
mulsd %xmm0, %xmm4
addsd %xmm5, %xmm4
movapd %xmm4, %xmm5
andpd 0x3f2c5(%rip), %xmm5 # 0xaf060
movapd 0x70(%rsp), %xmm6
ucomisd %xmm5, %xmm6
ja 0x6fe96
cmpq %rcx, %rax
je 0x6fe09
ucomisd 0x5d878(%rip), %xmm4 # 0xcd630
movupd (%rax), %xmm5
subpd %xmm2, %xmm5
mulpd %xmm1, %xmm5
movapd %xmm5, %xmm6
unpckhpd %xmm5, %xmm6 # xmm6 = xmm6[1],xmm5[1]
addsd %xmm5, %xmm6
movsd 0x10(%rax), %xmm5
subsd %xmm3, %xmm5
mulsd %xmm0, %xmm5
addsd %xmm6, %xmm5
jbe 0x6fdf3
ucomisd 0xb0(%rsp), %xmm5
ja 0x6fe03
jmp 0x6fe96
movapd 0x70(%rsp), %xmm6
ucomisd %xmm5, %xmm6
jbe 0x6fe96
addq $0x18, %rax
jmp 0x6fdab
movq %r15, 0x80(%rsp)
movq %r12, 0x88(%rsp)
movq %r13, 0x90(%rsp)
movq 0x38(%rsp), %rsi
cmpq 0x40(%rsp), %rsi
je 0x6fe4e
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsi)
movupd 0x80(%rsp), %xmm0
movupd %xmm0, (%rsi)
addq $0x18, 0x38(%rsp)
jmp 0x6fe60
leaq 0x30(%rsp), %rdi
leaq 0x80(%rsp), %rdx
callq 0x70314
movq 0x58(%rsp), %rsi
cmpq 0x60(%rsp), %rsi
je 0x6fe87
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsi)
movapd 0x10(%rsp), %xmm0
movupd %xmm0, (%rsi)
addq $0x18, 0x58(%rsp)
jmp 0x6fe96
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x5cdf2
incq %r13
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rdx
cmpq %rdx, %r13
movsd 0xe0(%rsp), %xmm6
jb 0x6fc7f
movq 0xd8(%rsp), %r12
cmpq %rdx, %r12
jb 0x6fc49
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %rsi, %rdx
movq 0xd0(%rsp), %r15
cmpq %rdx, %r15
jb 0x6fc19
movq 0x30(%rsp), %rbx
movq 0x38(%rsp), %rax
xorpd %xmm0, %xmm0
movq 0x8(%rsp), %rdx
movupd %xmm0, (%rdx)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdx)
movq %rcx, 0x20(%rsp)
movapd %xmm0, 0x10(%rsp)
cmpq %rbx, %rax
je 0x701ad
leaq 0x80(%rsp), %r15
leaq 0x4c(%rsp), %r12
movq $0x0, 0xb0(%rsp)
xorl %edx, %edx
movq %rdx, 0xc0(%rsp)
leaq (%rdx,%rdx,2), %rsi
leaq (,%rsi,8), %rbp
addq 0x50(%rsp), %rbp
movq 0x8(%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
je 0x70080
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
movq (%r14), %rdx
movq (%rbx,%rsi,8), %rsi
leaq (%rsi,%rsi,2), %rdi
movq 0x10(%rsp), %rsi
movupd (%rdx,%rdi,8), %xmm0
movsd 0x10(%rdx,%rdi,8), %xmm1
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edi, %edi
xorl %r13d, %r13d
movq 0x18(%rax,%rdi,2), %r8
movslq 0x20(%r8), %r8
leaq (%r8,%r8,2), %r8
movupd (%rdx,%r8,8), %xmm2
movapd %xmm0, %xmm3
subpd %xmm2, %xmm3
movupd (%rsi,%rdi), %xmm2
mulpd %xmm2, %xmm3
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4 # xmm4 = xmm4[1],xmm3[1]
addsd %xmm3, %xmm4
movapd %xmm1, %xmm5
subsd 0x10(%rdx,%r8,8), %xmm5
movsd 0x10(%rsi,%rdi), %xmm3
mulsd %xmm3, %xmm5
addsd %xmm4, %xmm5
andpd 0x3f061(%rip), %xmm5 # 0xaf060
movapd 0x70(%rsp), %xmm4
ucomisd %xmm5, %xmm4
jbe 0x7006f
movapd %xmm2, %xmm4
unpckhpd %xmm2, %xmm4 # xmm4 = xmm4[1],xmm2[1]
movsd (%rbp), %xmm5
movupd 0x8(%rbp), %xmm6
movapd %xmm2, %xmm7
shufpd $0x1, %xmm3, %xmm7 # xmm7 = xmm7[1],xmm3[0]
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
mulpd %xmm6, %xmm3
mulsd %xmm6, %xmm2
shufpd $0x1, %xmm5, %xmm6 # xmm6 = xmm6[1],xmm5[0]
mulpd %xmm7, %xmm6
subpd %xmm3, %xmm6
mulsd %xmm5, %xmm4
subsd %xmm4, %xmm2
mulpd %xmm6, %xmm6
movapd %xmm6, %xmm3
unpckhpd %xmm6, %xmm3 # xmm3 = xmm3[1],xmm6[1]
addsd %xmm6, %xmm3
mulsd %xmm2, %xmm2
addsd %xmm3, %xmm2
movapd 0x70(%rsp), %xmm3
ucomisd %xmm2, %xmm3
ja 0x70126
addq $-0x30, %r13
addq $0x18, %rdi
decq %rcx
jne 0x6ffae
movl $0x0, 0x88(%rsp)
xorl %ecx, %ecx
movq %rcx, 0x90(%rsp)
leaq 0x88(%rsp), %rax
movq %rax, 0x98(%rsp)
movq %rax, 0xa0(%rsp)
movq %rcx, 0xa8(%rsp)
addq 0xb0(%rsp), %rbx
xorl %r13d, %r13d
movl (%rbx,%r13), %eax
movl %eax, 0x4c(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5cd48
addq $0x8, %r13
cmpq $0x18, %r13
jne 0x700c0
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x7048c
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x7010f
movq 0x10(%rbp), %rax
movq %rax, 0x10(%rsi)
movupd (%rbp), %xmm0
movupd %xmm0, (%rsi)
addq $0x18, 0x18(%rsp)
jmp 0x7011c
leaq 0x10(%rsp), %rdi
movq %rbp, %rdx
callq 0x5cdf2
movq %r15, %rdi
callq 0x55a1c
jmp 0x7015a
negq %r13
addq 0xb0(%rsp), %rbx
xorl %ebp, %ebp
movl (%rbx,%rbp), %eax
movq 0x8(%rsp), %rcx
movq (%rcx), %rdi
addq %r13, %rdi
movl %eax, 0x80(%rsp)
movq %r15, %rsi
callq 0x5cd48
addq $0x8, %rbp
cmpq $0x18, %rbp
jne 0x70133
movq 0xc0(%rsp), %rdx
incq %rdx
movq 0x30(%rsp), %rbx
movq 0x38(%rsp), %rax
subq %rbx, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
addq $0x18, 0xb0(%rsp)
cmpq %rax, %rdx
jb 0x6ff46
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x701ad
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x145f0
movq 0x50(%rsp), %rdi
jmp 0x701cb
xorpd %xmm0, %xmm0
movq 0x8(%rsp), %rax
movupd %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %edi, %edi
testq %rdi, %rdi
je 0x701dd
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x145f0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x701f4
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x145f0
movq 0x8(%rsp), %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x14290
movq %rax, %rbx
leaq 0x90(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x675cf(%rip), %rsi # 0xd77fa
leaq 0x675e7(%rip), %rdx # 0xd7819
leaq 0x80(%rsp), %rdi
callq 0x37fd8
movb $0x1, %bpl
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x42fb0
xorl %ebp, %ebp
leaq 0x9b42d(%rip), %rsi # 0x10b688
movq 0x9fd16(%rip), %rdx # 0x10ff78
movq %rbx, %rdi
callq 0x14a60
jmp 0x70271
movq %rax, %r14
jmp 0x70281
movq %rax, %r14
leaq 0x80(%rsp), %rdi
callq 0x55a1c
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x70298
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x145f0
movq 0x8(%rsp), %rdi
callq 0x5543e
jmp 0x702dd
jmp 0x702a6
movq %rax, %r14
jmp 0x702dd
movq %rax, %r14
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0x702cb
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x145f0
testb %bpl, %bpl
jne 0x702d5
jmp 0x702dd
movq %rax, %r14
movq %rbx, %rdi
callq 0x14460
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x702f4
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x145f0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x7030b
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x145f0
movq %r14, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/src/common/convex_hull.cpp
|
Catch::Benchmark::Detail::weighted_average_quantile(int, int, __gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double>>>, __gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double>>>)
|
double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last) {
auto count = last - first;
double idx = (count - 1) * k / static_cast<double>(q);
int j = static_cast<int>(idx);
double g = idx - j;
std::nth_element(first, first + j, last);
auto xj = first[j];
if (g == 0) return xj;
auto xj1 = *std::min_element(first + (j + 1), last);
return xj + g * (xj1 - xj);
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rcx, %rax
subq %rdx, %rax
sarq $0x3, %rax
leaq -0x1(%rax), %rcx
movslq %edi, %rdi
imulq %rcx, %rdi
cvtsi2sd %rdi, %xmm3
cvtsi2sd %esi, %xmm0
divsd %xmm0, %xmm3
cvttsd2si %xmm3, %ecx
cvttpd2dq %xmm3, %xmm0
cvtdq2pd %xmm0, %xmm0
subsd %xmm0, %xmm3
movslq %ecx, %rcx
leaq (%rdx,%rcx,8), %r14
cmpq %rdx, %rbx
je 0x70dd2
cmpq %rbx, %r14
je 0x70dd2
bsrq %rax, %rcx
xorl $0x3f, %ecx
addl %ecx, %ecx
xorq $0x7e, %rcx
movq %rdx, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movapd %xmm3, (%rsp)
callq 0xa371c
movapd (%rsp), %xmm3
movsd (%r14), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm3
jne 0x70de3
jnp 0x70e31
leaq 0x8(%r14), %rax
cmpq %rbx, %rax
sete %cl
addq $0x10, %r14
cmpq %rbx, %r14
sete %dl
orb %cl, %dl
jne 0x70e1d
movsd (%rax), %xmm1
movsd (%r14), %xmm2
ucomisd %xmm2, %xmm1
cmovaq %r14, %rax
minsd %xmm1, %xmm2
addq $0x8, %r14
movapd %xmm2, %xmm1
cmpq %rbx, %r14
jne 0x70dff
movsd (%rax), %xmm1
subsd %xmm0, %xmm1
mulsd %xmm1, %xmm3
addsd %xmm0, %xmm3
movapd %xmm3, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::Benchmark::Detail::erfc_inv(double)
|
double erfc_inv(double x) {
return erf_inv(1.0 - x);
}
|
subq $0x28, %rsp
movsd 0x3e1c3(%rip), %xmm1 # 0xaf008
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movapd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm2, 0x8(%rsp)
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x144b0
movapd %xmm0, %xmm2
ucomisd 0x66de8(%rip), %xmm0 # 0xd7c60
jbe 0x70f9f
movsd 0x66f22(%rip), %xmm0 # 0xd7da8
subsd %xmm2, %xmm0
movsd 0x66f1e(%rip), %xmm1 # 0xd7db0
mulsd %xmm0, %xmm1
addsd 0x66f1a(%rip), %xmm1 # 0xd7db8
mulsd %xmm0, %xmm1
addsd 0x66f16(%rip), %xmm1 # 0xd7dc0
mulsd %xmm0, %xmm1
addsd 0x66f12(%rip), %xmm1 # 0xd7dc8
mulsd %xmm0, %xmm1
addsd 0x66f0e(%rip), %xmm1 # 0xd7dd0
mulsd %xmm0, %xmm1
addsd 0x66f0a(%rip), %xmm1 # 0xd7dd8
mulsd %xmm0, %xmm1
addsd 0x66f06(%rip), %xmm1 # 0xd7de0
mulsd %xmm0, %xmm1
addsd 0x66f02(%rip), %xmm1 # 0xd7de8
mulsd %xmm0, %xmm1
addsd 0x66efe(%rip), %xmm1 # 0xd7df0
mulsd %xmm0, %xmm1
addsd 0x66efa(%rip), %xmm1 # 0xd7df8
mulsd %xmm0, %xmm1
addsd 0x66ef6(%rip), %xmm1 # 0xd7e00
mulsd %xmm0, %xmm1
addsd 0x66ef2(%rip), %xmm1 # 0xd7e08
mulsd %xmm0, %xmm1
addsd 0x66eee(%rip), %xmm1 # 0xd7e10
mulsd %xmm0, %xmm1
addsd 0x66eea(%rip), %xmm1 # 0xd7e18
mulsd %xmm0, %xmm1
addsd 0x66ee6(%rip), %xmm1 # 0xd7e20
mulsd %xmm0, %xmm1
addsd 0x66ee2(%rip), %xmm1 # 0xd7e28
mulsd %xmm0, %xmm1
addsd 0x66ede(%rip), %xmm1 # 0xd7e30
mulsd %xmm0, %xmm1
addsd 0x66eda(%rip), %xmm1 # 0xd7e38
mulsd %xmm0, %xmm1
addsd 0x66ed6(%rip), %xmm1 # 0xd7e40
mulsd %xmm0, %xmm1
addsd 0x66ed2(%rip), %xmm1 # 0xd7e48
mulsd %xmm0, %xmm1
addsd 0x66ece(%rip), %xmm1 # 0xd7e50
mulsd %xmm0, %xmm1
addsd 0x66eca(%rip), %xmm1 # 0xd7e58
mulsd %xmm0, %xmm1
addsd 0x66ec6(%rip), %xmm1 # 0xd7e60
jmp 0x7119b
movapd 0x3f0e9(%rip), %xmm0 # 0xb0090
xorpd %xmm2, %xmm0
movsd 0x66cb5(%rip), %xmm1 # 0xd7c68
ucomisd %xmm2, %xmm1
jb 0x70fbf
sqrtsd %xmm0, %xmm0
jmp 0x70fd0
movapd %xmm2, 0x10(%rsp)
callq 0x144a0
movapd 0x10(%rsp), %xmm2
ucomisd 0x66c98(%rip), %xmm2 # 0xd7c70
jbe 0x710cb
addsd 0x66d22(%rip), %xmm0 # 0xd7d08
movsd 0x66d22(%rip), %xmm1 # 0xd7d10
mulsd %xmm0, %xmm1
addsd 0x66d1e(%rip), %xmm1 # 0xd7d18
mulsd %xmm0, %xmm1
addsd 0x66d1a(%rip), %xmm1 # 0xd7d20
mulsd %xmm0, %xmm1
addsd 0x66d16(%rip), %xmm1 # 0xd7d28
mulsd %xmm0, %xmm1
addsd 0x66d12(%rip), %xmm1 # 0xd7d30
mulsd %xmm0, %xmm1
addsd 0x66d0e(%rip), %xmm1 # 0xd7d38
mulsd %xmm0, %xmm1
addsd 0x66d0a(%rip), %xmm1 # 0xd7d40
mulsd %xmm0, %xmm1
addsd 0x66d06(%rip), %xmm1 # 0xd7d48
mulsd %xmm0, %xmm1
addsd 0x66d02(%rip), %xmm1 # 0xd7d50
mulsd %xmm0, %xmm1
addsd 0x66cfe(%rip), %xmm1 # 0xd7d58
mulsd %xmm0, %xmm1
addsd 0x66cfa(%rip), %xmm1 # 0xd7d60
mulsd %xmm0, %xmm1
addsd 0x66cf6(%rip), %xmm1 # 0xd7d68
mulsd %xmm0, %xmm1
addsd 0x66cf2(%rip), %xmm1 # 0xd7d70
mulsd %xmm0, %xmm1
addsd 0x66cee(%rip), %xmm1 # 0xd7d78
mulsd %xmm0, %xmm1
addsd 0x66cea(%rip), %xmm1 # 0xd7d80
mulsd %xmm0, %xmm1
addsd 0x66ce6(%rip), %xmm1 # 0xd7d88
mulsd %xmm0, %xmm1
addsd 0x66ce2(%rip), %xmm1 # 0xd7d90
mulsd %xmm0, %xmm1
addsd 0x66cde(%rip), %xmm1 # 0xd7d98
mulsd %xmm0, %xmm1
addsd 0x66cda(%rip), %xmm1 # 0xd7da0
jmp 0x7119b
addsd 0x66ba5(%rip), %xmm0 # 0xd7c78
movsd 0x66ba5(%rip), %xmm1 # 0xd7c80
mulsd %xmm0, %xmm1
addsd 0x66ba1(%rip), %xmm1 # 0xd7c88
mulsd %xmm0, %xmm1
addsd 0x66b9d(%rip), %xmm1 # 0xd7c90
mulsd %xmm0, %xmm1
addsd 0x66b99(%rip), %xmm1 # 0xd7c98
mulsd %xmm0, %xmm1
addsd 0x66b95(%rip), %xmm1 # 0xd7ca0
mulsd %xmm0, %xmm1
addsd 0x66b91(%rip), %xmm1 # 0xd7ca8
mulsd %xmm0, %xmm1
addsd 0x66b8d(%rip), %xmm1 # 0xd7cb0
mulsd %xmm0, %xmm1
addsd 0x66b89(%rip), %xmm1 # 0xd7cb8
mulsd %xmm0, %xmm1
addsd 0x66b85(%rip), %xmm1 # 0xd7cc0
mulsd %xmm0, %xmm1
addsd 0x66b81(%rip), %xmm1 # 0xd7cc8
mulsd %xmm0, %xmm1
addsd 0x66b7d(%rip), %xmm1 # 0xd7cd0
mulsd %xmm0, %xmm1
addsd 0x66b79(%rip), %xmm1 # 0xd7cd8
mulsd %xmm0, %xmm1
addsd 0x66b75(%rip), %xmm1 # 0xd7ce0
mulsd %xmm0, %xmm1
addsd 0x66b71(%rip), %xmm1 # 0xd7ce8
mulsd %xmm0, %xmm1
addsd 0x66b6d(%rip), %xmm1 # 0xd7cf0
mulsd %xmm0, %xmm1
addsd 0x66b69(%rip), %xmm1 # 0xd7cf8
mulsd %xmm0, %xmm1
addsd 0x66b65(%rip), %xmm1 # 0xd7d00
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
addq $0x28, %rsp
retq
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::Benchmark::Detail::normal_quantile(double)
|
double normal_quantile(double p) {
static const double ROOT_TWO = std::sqrt(2.0);
double result = 0.0;
assert(p >= 0 && p <= 1);
if (p < 0 || p > 1) {
return result;
}
result = -erfc_inv(2.0 * p);
// result *= normal distribution standard deviation (1.0) * sqrt(2)
result *= /*sd * */ ROOT_TWO;
// result += normal disttribution mean (0)
return result;
}
|
pushq %rax
movapd %xmm0, %xmm1
movb 0x9fbf3(%rip), %al # 0x110da8
testb %al, %al
je 0x71204
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x71215
movsd 0x3de3d(%rip), %xmm0 # 0xaf008
ucomisd %xmm1, %xmm0
jb 0x71215
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x71202
ucomisd 0x3de25(%rip), %xmm1 # 0xaf008
ja 0x71202
addsd %xmm1, %xmm1
movapd %xmm1, %xmm0
callq 0x70e39
xorpd 0x3ee96(%rip), %xmm0 # 0xb0090
mulsd 0x9fb9e(%rip), %xmm0 # 0x110da0
popq %rax
retq
movsd %xmm1, (%rsp)
callq 0x15108
movsd (%rsp), %xmm1
jmp 0x711b9
leaq 0x6829d(%rip), %rdi # 0xd94b9
leaq 0x682a7(%rip), %rsi # 0xd94ca
leaq 0x682fb(%rip), %rcx # 0xd9525
movl $0x1e5e, %edx # imm = 0x1E5E
callq 0x143c0
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::Benchmark::Detail::outlier_variance(Catch::Benchmark::Estimate<double>, Catch::Benchmark::Estimate<double>, int)
|
double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {
double sb = stddev.point;
double mn = mean.point / n;
double mg_min = mn / 2.;
double sg = (std::min)(mg_min / 4., sb / std::sqrt(n));
double sg2 = sg * sg;
double sb2 = sb * sb;
auto c_max = [n, mn, sb2, sg2](double x) -> double {
double k = mn - x;
double d = k * k;
double nd = n * d;
double k0 = -n * nd;
double k1 = sb2 - n * sg2 + nd;
double det = k1 * k1 - 4 * sg2 * k0;
return (int)(-2. * k0 / (k1 + std::sqrt(det)));
};
auto var_out = [n, sb2, sg2](double c) {
double nc = n - c;
return (nc / n) * (sb2 - nc * sg2);
};
return (std::min)(var_out(1), var_out((std::min)(c_max(0.), c_max(mg_min)))) / sb2;
}
|
pushq %rbx
subq $0x80, %rsp
movl %edi, %ebx
movsd 0xb0(%rsp), %xmm1
movsd 0x90(%rsp), %xmm8
cvtsi2sd %edi, %xmm3
divsd %xmm3, %xmm8
movsd 0x3ddc5(%rip), %xmm9 # 0xaf028
mulsd %xmm8, %xmm9
movsd 0x66bf8(%rip), %xmm4 # 0xd7e68
mulsd %xmm9, %xmm4
xorpd %xmm6, %xmm6
ucomisd %xmm6, %xmm3
movapd %xmm3, 0x40(%rsp)
jb 0x7128b
sqrtsd %xmm3, %xmm0
jmp 0x712d0
movapd %xmm3, %xmm0
movapd %xmm1, 0x50(%rsp)
movapd %xmm8, 0x30(%rsp)
movsd %xmm9, (%rsp)
movsd %xmm4, 0x20(%rsp)
callq 0x144a0
movsd 0x20(%rsp), %xmm4
movsd (%rsp), %xmm9
movapd 0x30(%rsp), %xmm8
xorpd %xmm6, %xmm6
movapd 0x40(%rsp), %xmm3
movapd 0x50(%rsp), %xmm1
movapd %xmm1, %xmm2
divsd %xmm0, %xmm2
minsd %xmm4, %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
negl %ebx
xorps %xmm4, %xmm4
cvtsi2sd %ebx, %xmm4
movapd %xmm3, %xmm0
mulsd %xmm2, %xmm0
movapd %xmm1, 0x50(%rsp)
movapd %xmm1, %xmm5
subsd %xmm0, %xmm5
movsd 0x5c2ed(%rip), %xmm7 # 0xcd5f8
movapd %xmm2, 0x30(%rsp)
mulsd %xmm2, %xmm7
movapd %xmm8, %xmm0
subsd %xmm9, %xmm0
unpcklpd %xmm8, %xmm0 # xmm0 = xmm0[0],xmm8[0]
mulpd %xmm0, %xmm0
movapd %xmm3, %xmm1
unpcklpd %xmm3, %xmm1 # xmm1 = xmm1[0],xmm3[0]
movapd %xmm1, 0x20(%rsp)
mulpd %xmm1, %xmm0
unpcklpd %xmm4, %xmm4 # xmm4 = xmm4[0,0]
mulpd %xmm0, %xmm4
movapd %xmm4, %xmm1
unpckhpd %xmm4, %xmm1 # xmm1 = xmm1[1],xmm4[1]
mulsd %xmm7, %xmm1
unpcklpd %xmm5, %xmm5 # xmm5 = xmm5[0,0]
addpd %xmm0, %xmm5
movapd %xmm5, %xmm0
unpckhpd %xmm5, %xmm0 # xmm0 = xmm0[1],xmm5[1]
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd %xmm6, %xmm0
movapd %xmm5, 0x60(%rsp)
jb 0x7137b
xorps %xmm6, %xmm6
sqrtsd %xmm0, %xmm6
jmp 0x713a6
movapd %xmm4, (%rsp)
movsd %xmm7, 0x10(%rsp)
callq 0x144a0
movsd 0x10(%rsp), %xmm7
movapd 0x60(%rsp), %xmm5
movapd (%rsp), %xmm4
movapd 0x40(%rsp), %xmm3
movapd %xmm0, %xmm6
movsd 0x3ecd2(%rip), %xmm2 # 0xb0080
addsd %xmm3, %xmm2
mulsd %xmm4, %xmm7
movapd %xmm5, %xmm0
mulsd %xmm5, %xmm0
mulpd 0x66b1a(%rip), %xmm4 # 0xd7ee0
addsd %xmm7, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x713da
sqrtsd %xmm0, %xmm0
jmp 0x7140d
movapd %xmm4, (%rsp)
movapd %xmm2, 0x10(%rsp)
movapd %xmm6, 0x70(%rsp)
callq 0x144a0
movapd 0x70(%rsp), %xmm6
movapd 0x10(%rsp), %xmm2
movapd 0x60(%rsp), %xmm5
movapd (%rsp), %xmm4
movapd 0x40(%rsp), %xmm3
unpcklpd %xmm6, %xmm0 # xmm0 = xmm0[0],xmm6[0]
addpd %xmm5, %xmm0
divpd %xmm0, %xmm4
cvttpd2dq %xmm4, %xmm0
cvtdq2pd %xmm0, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
minsd %xmm1, %xmm0
subsd %xmm0, %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
movapd %xmm3, %xmm1
divpd 0x20(%rsp), %xmm1
movapd 0x30(%rsp), %xmm4
unpcklpd %xmm4, %xmm4 # xmm4 = xmm4[0,0]
movapd 0x50(%rsp), %xmm2
movapd %xmm2, %xmm0
unpcklpd %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0]
mulpd %xmm3, %xmm4
subpd %xmm4, %xmm0
mulpd %xmm1, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
minsd %xmm1, %xmm0
divsd %xmm2, %xmm0
addq $0x80, %rsp
popq %rbx
retq
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::Benchmark::Detail::analyse_samples(double, int, __gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double>>>, __gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double>>>)
|
bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
static std::random_device entropy;
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
auto mean = &Detail::mean<std::vector<double>::iterator>;
auto stddev = &standard_deviation;
#if defined(CATCH_CONFIG_USE_ASYNC)
auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
auto seed = entropy();
return std::async(std::launch::async, [=] {
std::mt19937 rng(seed);
auto resampled = resample(rng, n_resamples, first, last, f);
return bootstrap(confidence_level, first, last, resampled, f);
});
};
auto mean_future = Estimate(mean);
auto stddev_future = Estimate(stddev);
auto mean_estimate = mean_future.get();
auto stddev_estimate = stddev_future.get();
#else
auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
auto seed = entropy();
std::mt19937 rng(seed);
auto resampled = resample(rng, n_resamples, first, last, f);
return bootstrap(confidence_level, first, last, resampled, f);
};
auto mean_estimate = Estimate(mean);
auto stddev_estimate = Estimate(stddev);
#endif // CATCH_USE_ASYNC
double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
return { mean_estimate, stddev_estimate, outlier_variance };
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movsd %xmm0, 0x40(%rsp)
movq %rdi, %rbx
movb 0xa0c94(%rip), %al # 0x112138
testb %al, %al
je 0x7156c
movq %r14, %r12
subq %r15, %r12
shrq $0x3, %r12
leaq 0x88(%rsp), %r13
movl %ebp, (%r13)
movq %r15, 0x8(%r13)
movq %r14, 0x10(%r13)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x18(%r13)
leaq 0x24b75(%rip), %rdx # 0x96052
leaq 0x68(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x71638
leaq 0xda(%rip), %rdx # 0x715ce
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x71638
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x30(%rsp)
movups %xmm0, 0x20(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl %r12d, %edi
callq 0x71234
movups (%r14), %xmm1
movups 0x10(%r14), %xmm2
movups %xmm1, (%rbx)
movups %xmm2, 0x10(%rbx)
movups (%r15), %xmm1
movups 0x10(%r15), %xmm2
movups %xmm1, 0x20(%rbx)
movups %xmm2, 0x30(%rbx)
movsd %xmm0, 0x40(%rbx)
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa0bc5(%rip), %rdi # 0x112138
callq 0x14af0
testl %eax, %eax
je 0x714ac
leaq 0x9f829(%rip), %rdi # 0x110db0
callq 0x95fc8
leaq 0x24aaf(%rip), %rdi # 0x96042
leaq 0x9f816(%rip), %rsi # 0x110db0
leaq 0x9f067(%rip), %rdx # 0x110608
callq 0x14540
leaq 0xa0b8b(%rip), %rdi # 0x112138
callq 0x143a0
jmp 0x714ac
movq %rax, %rbx
leaq 0xa0b77(%rip), %rdi # 0x112138
callq 0x14390
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::Detail::Approx::toString[abi:cxx11]() const
|
std::string Approx::toString() const {
ReusableStringStream rss;
rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
return rss.str();
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x9b02a(%rip), %rax # 0x10c7b8
movq %rax, 0x28(%rsp)
callq 0xa7f40
leaq 0x8(%rax), %rdi
callq 0x97e94
movq %rax, %r14
movq %rax, 0x30(%rsp)
callq 0xa7f40
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %r14
movq %r14, 0x38(%rsp)
leaq 0x67d9c(%rip), %rsi # 0xd955e
movl $0x8, %edx
movq %r14, %rdi
callq 0x146d0
movsd 0x18(%r15), %xmm0
movl 0x9f269(%rip), %esi # 0x110a44
leaq 0x8(%rsp), %rdi
callq 0x9877d
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x146d0
leaq 0x67d69(%rip), %rsi # 0xd9567
movl $0x2, %edx
movq %r14, %rdi
callq 0x146d0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x71826
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14960
leaq 0x28(%rsp), %rdi
callq 0x83110
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x7186e
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x71871
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0x71871
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x83110
movq %rbx, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::Detail::Approx::setMargin(double)
|
void Approx::setMargin(double newMargin) {
CATCH_ENFORCE(newMargin >= 0,
"Invalid Approx::margin: " << newMargin << '.'
<< " Approx::Margin has to be non-negative.");
m_margin = newMargin;
}
|
pushq %rbx
subq $0x40, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x7192c
movsd %xmm0, 0x8(%rdi)
addq $0x40, %rsp
popq %rbx
retq
movsd %xmm0, (%rsp)
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x830d8
movq 0x10(%rbx), %rbx
leaq 0x67c21(%rip), %rsi # 0xd956a
movl $0x18, %edx
movq %rbx, %rdi
callq 0x146d0
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x14980
leaq 0x8(%rsp), %rsi
movb $0x2e, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x146d0
leaq 0x67c04(%rip), %rsi # 0xd9583
movl $0x27, %edx
movq %rbx, %rdi
callq 0x146d0
addq $0x8, %rbx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x14960
leaq 0x8(%rsp), %rdi
callq 0x719de
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x719cc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0x719cc
jmp 0x719c9
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x83110
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::Detail::Approx::setEpsilon(double)
|
void Approx::setEpsilon(double newEpsilon) {
CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
"Invalid Approx::epsilon: " << newEpsilon << '.'
<< " Approx::epsilon has to be in [0, 1]");
m_epsilon = newEpsilon;
}
|
pushq %rbx
subq $0x40, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x71a33
movsd 0x3d5e5(%rip), %xmm1 # 0xaf008
ucomisd %xmm0, %xmm1
jb 0x71a33
movsd %xmm0, (%rdi)
addq $0x40, %rsp
popq %rbx
retq
movsd %xmm0, (%rsp)
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x830d8
movq 0x10(%rbx), %rbx
leaq 0x67b5b(%rip), %rsi # 0xd95ab
movl $0x19, %edx
movq %rbx, %rdi
callq 0x146d0
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x14980
leaq 0x8(%rsp), %rsi
movb $0x2e, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x146d0
leaq 0x67b3f(%rip), %rsi # 0xd95c5
movl $0x24, %edx
movq %rbx, %rdi
callq 0x146d0
addq $0x8, %rbx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x14960
leaq 0x8(%rsp), %rdi
callq 0x719de
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x71ad3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0x71ad3
jmp 0x71ad0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x83110
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::operator<<(std::ostream&, Catch::LazyExpression const&)
|
auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
if( lazyExpr.m_isNegated )
os << "!";
if( lazyExpr ) {
if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
os << "(" << *lazyExpr.m_transientExpression << ")";
else
os << *lazyExpr.m_transientExpression;
}
else {
os << "{** error - unchecked empty expression requested **}";
}
return os;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x8(%rsi)
jne 0x71b98
leaq 0x687ee(%rip), %rsi # 0xda379
movl $0x1, %edx
movq %rbx, %rdi
callq 0x146d0
movq (%r14), %rdi
testq %rdi, %rdi
je 0x71be4
cmpb $0x1, 0x8(%r14)
jne 0x71bda
cmpb $0x1, 0x8(%rdi)
jne 0x71bda
leaq 0x68d2a(%rip), %rsi # 0xda8de
movl $0x1, %edx
movq %rbx, %rdi
callq 0x146d0
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
leaq 0x67995(%rip), %rsi # 0xd9568
movl $0x1, %edx
jmp 0x71bf0
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
jmp 0x71bf8
leaq 0x679ff(%rip), %rsi # 0xd95ea
movl $0x34, %edx
movq %rbx, %rdi
callq 0x146d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::getResultCapture()
|
inline IMutableContext& getCurrentMutableContext()
{
if( !IMutableContext::currentContext )
IMutableContext::createContext();
// NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
return *IMutableContext::currentContext;
}
|
pushq %rbx
subq $0x50, %rsp
movq 0xa050e(%rip), %rdi # 0x112150
testq %rdi, %rdi
je 0x71c4c
movq (%rdi), %rax
jmp 0x71c80
movl $0x30, %edi
callq 0x145c0
movq %rax, %rdi
leaq 0x9a4b0(%rip), %rax # 0x10c110
movq %rax, (%rdi)
leaq 0x9a4f6(%rip), %rcx # 0x10c160
movq %rcx, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rdi, 0xa04d0(%rip) # 0x112150
callq *0x10(%rax)
testq %rax, %rax
je 0x71c8e
addq $0x50, %rsp
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x830d8
leaq 0x67828(%rip), %rax # 0xd94ca
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
movq $0x335f, 0x8(%rsi) # imm = 0x335F
movq 0x10(%rbx), %rbx
movq %rbx, %rdi
callq 0x786e9
leaq 0x682dc(%rip), %rsi # 0xd9fa1
movl $0x19, %edx
movq %rbx, %rdi
callq 0x146d0
leaq 0x68632(%rip), %rsi # 0xda30b
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x146d0
addq $0x8, %rbx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x14960
leaq 0x8(%rsp), %rdi
callq 0x79562
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x71d24
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0x71d24
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x83110
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::AssertionHandler::allowThrows() const
|
auto AssertionHandler::allowThrows() const -> bool {
return getCurrentContext().getConfig()->allowThrows();
}
|
pushq %rax
movq 0xa03e0(%rip), %rdi # 0x112150
testq %rdi, %rdi
je 0x71d7a
movq (%rdi), %rax
jmp 0x71dae
movl $0x30, %edi
callq 0x145c0
movq %rax, %rdi
leaq 0x9a382(%rip), %rax # 0x10c110
movq %rax, (%rdi)
leaq 0x9a3c8(%rip), %rcx # 0x10c160
movq %rcx, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rdi, 0xa03a2(%rip) # 0x112150
callq *0x20(%rax)
movq (%rax), %rdi
movq (%rdi), %rax
popq %rcx
jmpq *0x10(%rax)
nop
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::AssertionHandler::complete()
|
void AssertionHandler::complete() {
setCompleted();
if( m_reaction.shouldDebugBreak ) {
// If you find your debugger stopping you here then go one level up on the
// call-stack for the code that caused it (typically a failed assertion)
// (To go back to the test and change execution, jump over the throw, next)
CATCH_BREAK_INTO_DEBUGGER();
}
if (m_reaction.shouldThrow) {
#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
throw Catch::TestFailureException();
#else
CATCH_ERROR( "Test failure requires aborting test!" );
#endif
}
}
|
pushq %rbx
movq %rdi, %rbx
movb $0x1, 0x3a(%rdi)
cmpb $0x1, 0x38(%rdi)
jne 0x71dd4
callq 0x7935a
testb %al, %al
je 0x71dd4
int3
cmpb $0x1, 0x39(%rbx)
je 0x71ddc
popq %rbx
retq
movl $0x1, %edi
callq 0x14290
leaq 0x9a203(%rip), %rsi # 0x10bff0
movq %rax, %rdi
xorl %edx, %edx
callq 0x14a60
nop
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::AssertionHandler::handleUnexpectedInflightException()
|
void AssertionHandler::handleUnexpectedInflightException() {
m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %r14
callq 0x94db0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x28(%rcx)
movq (%rax), %rcx
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
leaq 0x38(%rbx), %rcx
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq *0x88(%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x71e5c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x145f0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x71e84
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x145f0
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::handleExceptionMatchExpr(Catch::AssertionHandler&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::StringRef const&)
|
void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString ) {
handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0x7209e
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x71fd8
leaq 0x9a465(%rip), %rax # 0x10c3b0
leaq 0x70(%rsp), %rcx
movq %rax, -0x68(%rcx)
leaq 0x9a47d(%rip), %rax # 0x10c3d8
movq %rax, -0x40(%rcx)
movq -0x10(%rcx), %rdi
cmpq %rcx, %rdi
je 0x71f75
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x145f0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x71f90
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x145f0
leaq 0x9a319(%rip), %rax # 0x10c2b0
leaq 0x20(%rsp), %rcx
movq %rax, -0x18(%rcx)
movq -0x10(%rcx), %rdi
cmpq %rcx, %rdi
je 0x71fb6
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x145f0
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9a920
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::handleExceptionMatchExpr(Catch::AssertionHandler&, Catch::Matchers::Impl::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, Catch::StringRef const&)
|
void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString ) {
std::string exceptionMessage = Catch::translateActiveException();
MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
handler.handleExpr( expr );
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x94db0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x28(%rcx)
movq (%rax), %rcx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
leaq 0x28(%r15), %rdi
movq 0x28(%r15), %rax
movq %r12, %rsi
callq *(%rax)
leaq 0x28(%rsp), %rdx
movb $0x1, 0x8(%rdx)
movb %al, 0x9(%rdx)
leaq 0x9d3d5(%rip), %rax # 0x10f400
movq %rax, (%rdx)
movq %r12, 0x10(%rdx)
movq %r15, 0x18(%rdx)
movups (%r14), %xmm0
movups %xmm0, 0x20(%rdx)
movq 0x40(%rbx), %rdi
leaq 0x38(%rbx), %rcx
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x70(%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7206a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x72078
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x72096
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::Matchers::Equals(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::CaseSensitive::Choice)
|
StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl %edx, -0x8(%rdi)
movq %rsp, %r14
movq %r14, %rsi
movq %rax, %rdx
callq 0x7ce18
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7d124
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x720e7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x72110
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::AssertionResultData::reconstructExpression[abi:cxx11]() const
|
std::string AssertionResultData::reconstructExpression() const {
if( reconstructedExpression.empty() ) {
if( lazyExpression ) {
ReusableStringStream rss;
rss << lazyExpression;
reconstructedExpression = rss.str();
}
}
return reconstructedExpression;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x20(%rsi), %r14
movq 0x28(%rsi), %rdx
testq %rdx, %rdx
jne 0x72206
movq %rsi, %r15
cmpq $0x0, 0x40(%rsi)
je 0x72204
leaq 0x40(%r15), %r13
leaq 0x9a638(%rip), %rax # 0x10c7b8
movq %rax, 0x8(%rsp)
callq 0xa7f40
leaq 0x8(%rax), %rdi
callq 0x97e94
movq %rax, %r12
movq %rax, 0x10(%rsp)
callq 0xa7f40
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %r12
movq %r12, 0x18(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x71b74
addq $0x8, %r12
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x14960
leaq 0x20(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x14760
movq (%r12), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x721f4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x145f0
leaq 0x8(%rsp), %rdi
callq 0x83110
movq 0x28(%r15), %rdx
jmp 0x72206
xorl %edx, %edx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x36894
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x7222e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x83110
movq %rbx, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::AssertionResult::AssertionResult(Catch::AssertionInfo const&, Catch::AssertionResultData const&)
|
AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
: m_info( info ),
m_resultData( data )
{}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x30(%rsi), %rax
movq %rax, 0x30(%rdi)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups %xmm2, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x38(%rdi), %r15
leaq 0x48(%rdi), %r12
movq %r12, 0x38(%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x36894
leaq 0x58(%r14), %rdi
leaq 0x68(%r14), %rax
movq %rax, 0x58(%r14)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
callq 0x36894
movq $0x0, 0x78(%r14)
movb 0x48(%rbx), %al
movb %al, 0x80(%r14)
movl 0x50(%rbx), %eax
movl %eax, 0x88(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x722e9
movq (%r12), %rsi
incq %rsi
callq 0x145f0
movq %rbx, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::AssertionResult::getExpression[abi:cxx11]() const
|
std::string AssertionResult::getExpression() const {
// Possibly overallocating by 3 characters should be basically free
std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
if (isFalseTest(m_info.resultDisposition)) {
expr += "!(";
}
expr += m_info.capturedExpression;
if (isFalseTest(m_info.resultDisposition)) {
expr += ')';
}
return expr;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x28(%rsi), %rsi
addq $0x3, %rsi
callq 0x14940
testb $0x4, 0x30(%r14)
je 0x72383
leaq 0x672a4(%rip), %rsi # 0xd961f
movq %rbx, %rdi
callq 0x14ba0
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x140e0
testb $0x4, 0x30(%r14)
je 0x723a7
movq %rbx, %rdi
movl $0x29, %esi
callq 0x14520
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x723c6
movq (%r15), %rsi
incq %rsi
callq 0x145f0
movq %r14, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::AssertionResult::hasExpandedExpression() const
|
constexpr auto empty() const noexcept -> bool {
return m_size == 0;
}
|
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpq $0x0, 0x28(%rdi)
je 0x7252f
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x725a4
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x72342
movq 0x10(%rsp), %rdx
cmpq 0x30(%rsp), %rdx
jne 0x72533
movq 0x28(%rsp), %r14
testq %rdx, %rdx
je 0x7253c
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x14640
testl %eax, %eax
setne %bl
jmp 0x7253e
xorl %ebx, %ebx
jmp 0x72573
movb $0x1, %bl
movq 0x28(%rsp), %r14
jmp 0x7253e
xorl %ebx, %ebx
leaq 0x38(%rsp), %rax
cmpq %rax, %r14
je 0x72558
movq 0x38(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x145f0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x72573
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7259b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
movq %rbx, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::AssertionResult::getExpandedExpression[abi:cxx11]() const
|
std::string AssertionResult::getExpandedExpression() const {
std::string expr = m_resultData.reconstructExpression();
return expr.empty()
? getExpression()
: expr;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x38, %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x72146
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x725e3
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rsp), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x36894
jmp 0x725ee
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72342
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x72609
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x145f0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x72634
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x145f0
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::AssertionResult::getMessage[abi:cxx11]() const
|
std::string AssertionResult::getMessage() const {
return m_resultData.message;
}
|
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 0x36894
movq %rbx, %rax
popq %rbx
retq
nop
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::TestRunStats::TestRunStats(Catch::TestRunInfo const&, Catch::Totals const&, bool)
|
TestRunStats::TestRunStats( TestRunInfo const& _runInfo,
Totals const& _totals,
bool _aborting )
: runInfo( _runInfo ),
totals( _totals ),
aborting( _aborting )
{}
|
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x91a78(%rip), %rax # 0x10c290
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x18(%r15), %rax
movq %rax, 0x8(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x36894
movq 0x30(%r14), %rax
movq %rax, 0x58(%r15)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x48(%r15)
movups %xmm1, 0x38(%r15)
movups %xmm0, 0x28(%r15)
movb %bl, 0x60(%r15)
popq %rbx
popq %r14
popq %r15
retq
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::TestRunStats::~TestRunStats()
|
TestRunStats::~TestRunStats() = default;
|
movq %rdi, %rax
leaq 0x91a1e(%rip), %rcx # 0x10c290
movq %rcx, (%rdi)
movq 0x8(%rdi), %rdi
addq $0x18, %rax
cmpq %rax, %rdi
je 0x7a88d
movq (%rax), %rsi
incq %rsi
jmp 0x145f0
retq
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::Matchers::Floating::WithinRelMatcher::describe[abi:cxx11]() const
|
std::string WithinRelMatcher::describe() const {
Catch::ReusableStringStream sstr;
sstr << "and " << m_target << " are within " << m_epsilon * 100. << "% of each other";
return sstr.str();
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8fc1e(%rip), %rax # 0x10c7b8
movq %rax, 0x8(%rsp)
callq 0xa7f40
leaq 0x8(%rax), %rdi
callq 0x97e94
movq %rax, %r14
movq %rax, 0x10(%rsp)
callq 0xa7f40
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %r14
movq %r14, 0x18(%rsp)
leaq 0x5d494(%rip), %rsi # 0xda062
movl $0x4, %edx
movq %r14, %rdi
callq 0x146d0
movsd 0x30(%r15), %xmm0
movq %r14, %rdi
callq 0x14980
leaq 0x5d477(%rip), %rsi # 0xda067
movl $0xc, %edx
movq %r14, %rdi
callq 0x146d0
movsd 0x38(%r15), %xmm0
mulsd 0x5b285(%rip), %xmm0 # 0xd7e90
movq %r14, %rdi
callq 0x14980
leaq 0x5d45a(%rip), %rsi # 0xda074
movl $0xf, %edx
movq %r14, %rdi
callq 0x146d0
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14960
leaq 0x8(%rsp), %rdi
callq 0x83110
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x7cc4f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x83110
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::Matchers::WithinULP(double, unsigned long)
|
Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Double);
}
|
movq %rdi, %rax
leaq 0x18(%rdi), %rcx
movq %rcx, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x8f69e(%rip), %rcx # 0x10c320
movq %rcx, (%rdi)
leaq 0x8f6c4(%rip), %rcx # 0x10c350
movq %rcx, 0x28(%rdi)
movsd %xmm0, 0x30(%rdi)
movq %rsi, 0x38(%rdi)
movb $0x1, 0x40(%rdi)
retq
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::Matchers::Generic::Detail::finalizeDescription(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
if (desc.empty()) {
return "matches undescribed predicate";
} else {
return "matches predicate: \"" + desc + '"';
}
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x7cd77
movq %rsi, %rdx
leaq 0x5d373(%rip), %rsi # 0xda0a2
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3870f
movq 0x8(%r14), %rsi
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
movl $0x22, %r8d
callq 0x14b40
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x7cd96
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x7cd9c
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x5d2ff(%rip), %rsi # 0xda084
leaq 0x5d315(%rip), %rdx # 0xda0a1
movq %rbx, %rdi
callq 0x37fd8
jmp 0x7cdce
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7cdce
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7cdf7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
movq %rbx, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::clara::detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_9>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
auto setValue( std::string const &arg ) -> ParserResult override {
return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl $0x0, (%rax)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0xa4275
movl 0x8(%r15), %eax
testl %eax, %eax
je 0x935a2
movl %eax, 0x8(%rbx)
leaq 0x7b5e1(%rip), %r15 # 0x10eb60
movq %r15, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
callq 0x36894
jmp 0x935cd
movq 0x8(%r14), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0xc(%rax)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
leaq 0x7b5a6(%rip), %rcx # 0x10eb60
movq %rcx, (%rbx)
leaq 0x20(%rbx), %rcx
movq %rcx, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movb $0x0, 0x20(%rbx)
leaq 0x7b58c(%rip), %rax # 0x10eb60
leaq 0x30(%rsp), %rcx
movq %rax, -0x20(%rcx)
movq -0x10(%rcx), %rdi
cmpq %rcx, %rdi
je 0x935f3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x145f0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x7b5ae(%rip), %rax # 0x10ebb8
movq %rax, (%rbx)
leaq 0x30(%rsp), %rax
movq %r15, -0x20(%rax)
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9362c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x145f0
movq %r14, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Catch::clara::detail::BasicResult<Catch::clara::detail::ParseResultType> Catch::clara::detail::convertInto<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&)
|
inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
std::stringstream ss;
ss << source;
ss >> target;
if( ss.fail() )
return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
else
return ParserResult::ok( ParseResultType::Matched );
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x14430
leaq 0x58(%rsp), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x146d0
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x14370
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x68(%rsp,%rax)
je 0xa430e
leaq 0x37c5d(%rip), %rsi # 0xdbf26
leaq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x3870f
leaq 0x37c5d(%rip), %rsi # 0xdbf3a
leaq 0x28(%rsp), %rdi
callq 0x14ba0
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xa4330
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0xa4337
xorl %eax, %eax
movq %rax, 0x8(%rbx)
leaq 0x6a845(%rip), %rcx # 0x10eb60
movq %rcx, (%rbx)
leaq 0x20(%rbx), %rcx
movq %rcx, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movb $0x0, 0x20(%rbx)
jmp 0xa4392
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rsi
leaq 0x8(%rsp), %rdx
movq %rsi, 0x8(%rdx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movl $0x2, %esi
callq 0xa4210
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xa4377
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa4392
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x145f0
movq 0x6bb47(%rip), %rsi # 0x10fee0
leaq 0x48(%rsp), %rdi
callq 0x14480
leaq 0xc8(%rsp), %rdi
callq 0x141c0
movq %rbx, %rax
addq $0x1d0, %rsp # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xa43df
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0xa43df
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa4401
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0xa4401
jmp 0xa43fe
movq %rax, %rbx
movq 0x6bad8(%rip), %rsi # 0x10fee0
leaq 0x48(%rsp), %rdi
callq 0x14480
leaq 0xc8(%rsp), %rdi
callq 0x141c0
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/catch2/catch.hpp
|
Matrix<int>::transpose()
|
void transpose(){
// if matrix is square, no extra memory is needed to build its transpose
if (num_rows == num_cols){
for (size_type i {0}; i < num_rows; i++){
for (size_type j {i + 1}; j < num_cols; j++){
std::swap(at(i, j), at(j, i));
}
}
}
// if matrix is not square, some extra memory is needed to build
// its transpose
else{
// auxiliar memory to temporarily hold the transpose
Matrix<Type> t {num_cols, num_rows};
// builds transpose
for (size_type i {0}; i < num_rows; i++){
for (size_type j {0}; j < num_cols; j++){
t.at(j, i) = at(i, j);
}
}
// exchanges matrix data with t data, which is about to die
std::swap(data_, t.data_);
}
// exchanges number of rows and columns
std::swap(rows_, cols_);
}
|
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movq 0x30(%rdi), %rcx
movq (%rax), %rdx
movq (%rcx), %rsi
cmpq %rsi, %rdx
jne 0x1730
pushq $0x4
popq %rax
xorl %ecx, %ecx
xorl %esi, %esi
cmpq %rdx, %rsi
je 0x17ae
incq %rsi
movq (%rbx), %r10
movq 0x20(%rbx), %rdi
movq %rdi, %r8
imulq %rax, %r8
addq %r10, %r8
addq %rcx, %r8
leaq (,%rdi,4), %r9
imulq %rcx, %rdi
addq %r10, %rdi
movq %rsi, %r10
cmpq %rdx, %r10
jae 0x1726
movl (%rdi,%r10,4), %r11d
movl (%r8), %ebp
movl %ebp, (%rdi,%r10,4)
movl %r11d, (%r8)
incq %r10
addq %r9, %r8
jmp 0x170b
addq $0x4, %rcx
addq $0x4, %rax
jmp 0x16d9
movq %rsp, %rdi
callq 0x130a
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rax
movq (%rcx), %rcx
xorl %edx, %edx
xorl %esi, %esi
cmpq %rcx, %rsi
je 0x178a
movq (%rax), %rdi
movq 0x20(%rsp), %r8
movq (%rsp), %r9
addq %rdx, %r9
shlq $0x2, %r8
movq 0x20(%rbx), %r10
imulq %rdx, %r10
addq (%rbx), %r10
xorl %r11d, %r11d
cmpq %r11, %rdi
je 0x1781
movl (%r10,%r11,4), %ebp
movl %ebp, (%r9)
incq %r11
addq %r8, %r9
jmp 0x176d
incq %rsi
addq $0x4, %rdx
jmp 0x1747
movq 0x10(%rbx), %rax
movq %rsp, %rdi
movaps (%rdi), %xmm0
movq 0x10(%rdi), %rcx
movq %rcx, 0x10(%rbx)
movups (%rbx), %xmm1
movups %xmm0, (%rbx)
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
callq 0x1498
movdqu 0x18(%rbx), %xmm0
pshufd $0x4e, %xmm0, %xmm0 # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, 0x18(%rbx)
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
|
/luizalbertocviana[P]cracking-coding-problems/data-structures-cpp/Matrix.hpp
|
cinatra::coro_http_connection::start() (.resume)
|
async_simple::coro::Lazy<void> start() {
#ifdef CINATRA_ENABLE_SSL
bool has_shake = false;
#endif
std::chrono::system_clock::time_point start{};
std::chrono::system_clock::time_point mid{};
while (true) {
#ifdef CINATRA_ENABLE_SSL
if (use_ssl_ && !has_shake) {
auto ec = co_await coro_io::async_handshake(
ssl_stream_, asio::ssl::stream_base::server);
if (ec) {
CINATRA_LOG_ERROR << "handle_shake error: " << ec.message();
close();
break;
}
has_shake = true;
}
#endif
auto [ec, size] = co_await async_read_until(head_buf_, TWO_CRCF);
if (ec) {
if (ec != asio::error::eof) {
CINATRA_LOG_WARNING << "read http header error: " << ec.message();
}
close();
break;
}
const char *data_ptr = asio::buffer_cast<const char *>(head_buf_.data());
int head_len = parser_.parse_request(data_ptr, size, 0);
if (head_len <= 0) {
CINATRA_LOG_ERROR << "parse http header error";
response_.set_status_and_content(status_type::bad_request,
"invalid http protocol");
co_await reply();
close();
break;
}
if (parser_.body_len() > max_http_body_len_ || parser_.body_len() < 0)
[[unlikely]] {
CINATRA_LOG_ERROR << "invalid http content length: "
<< parser_.body_len();
response_.set_status_and_content(status_type::bad_request,
"invalid http content length");
co_await reply();
close();
break;
}
head_buf_.consume(size);
keep_alive_ = check_keep_alive();
auto type = request_.get_content_type();
if (type != content_type::chunked && type != content_type::multipart) {
size_t body_len = (size_t)parser_.body_len();
if (body_len == 0) {
if (parser_.method() == "GET"sv) {
if (request_.is_upgrade()) {
#ifdef CINATRA_ENABLE_GZIP
if (request_.is_support_compressed()) {
is_client_ws_compressed_ = true;
}
else {
is_client_ws_compressed_ = false;
}
#endif
// websocket
build_ws_handshake_head();
bool ok = co_await reply(true); // response ws handshake
if (!ok) {
close();
break;
}
response_.set_delay(true);
}
}
}
else if (body_len <= head_buf_.size()) {
if (body_len > 0) {
detail::resize(body_, body_len);
auto data_ptr = asio::buffer_cast<const char *>(head_buf_.data());
memcpy(body_.data(), data_ptr, body_len);
head_buf_.consume(head_buf_.size());
}
}
else {
size_t part_size = head_buf_.size();
size_t size_to_read = body_len - part_size;
auto data_ptr = asio::buffer_cast<const char *>(head_buf_.data());
detail::resize(body_, body_len);
memcpy(body_.data(), data_ptr, part_size);
head_buf_.consume(part_size);
auto [ec, size] = co_await async_read(
asio::buffer(body_.data() + part_size, size_to_read),
size_to_read);
if (ec) {
CINATRA_LOG_ERROR << "async_read error: " << ec.message();
close();
break;
}
}
}
std::string_view key = {
parser_.method().data(),
parser_.method().length() + 1 + parser_.url().length()};
std::string decode_key;
if (parser_.url().find('%') != std::string_view::npos) {
decode_key = code_utils::url_decode(key);
key = decode_key;
}
if (!body_.empty()) {
request_.set_body(body_);
}
if (auto handler = router_.get_handler(key); handler) {
router_.route(handler, request_, response_, key);
}
else {
if (auto coro_handler = router_.get_coro_handler(key); coro_handler) {
co_await router_.route_coro(coro_handler, request_, response_, key);
}
else {
bool is_exist = false;
bool is_coro_exist = false;
bool is_matched_regex_router = false;
std::function<void(coro_http_request & req,
coro_http_response & resp)>
handler;
std::string method_str{parser_.method()};
std::string url_path = method_str;
url_path.append(" ").append(parser_.url());
std::tie(is_exist, handler, request_.params_) =
router_.get_router_tree()->get(url_path, method_str);
if (is_exist) {
if (handler) {
(handler)(request_, response_);
}
else {
response_.set_status(status_type::not_found);
}
}
else {
std::function<async_simple::coro::Lazy<void>(
coro_http_request & req, coro_http_response & resp)>
coro_handler;
std::tie(is_coro_exist, coro_handler, request_.params_) =
router_.get_coro_router_tree()->get_coro(url_path, method_str);
if (is_coro_exist) {
if (coro_handler) {
co_await coro_handler(request_, response_);
}
else {
response_.set_status(status_type::not_found);
}
}
else {
// coro regex router
auto coro_regex_handlers = router_.get_coro_regex_handlers();
if (coro_regex_handlers.size() != 0) {
for (auto &pair : coro_regex_handlers) {
std::string coro_regex_key{key};
if (std::regex_match(coro_regex_key, request_.matches_,
std::get<0>(pair))) {
auto coro_handler = std::get<1>(pair);
if (coro_handler) {
co_await coro_handler(request_, response_);
is_matched_regex_router = true;
}
}
}
}
// regex router
if (!is_matched_regex_router) {
auto regex_handlers = router_.get_regex_handlers();
if (regex_handlers.size() != 0) {
for (auto &pair : regex_handlers) {
std::string regex_key{key};
if (std::regex_match(regex_key, request_.matches_,
std::get<0>(pair))) {
auto handler = std::get<1>(pair);
if (handler) {
(handler)(request_, response_);
is_matched_regex_router = true;
}
}
}
}
}
// radix route -> radix coro route -> regex coro -> regex ->
// default -> not found
if (!is_matched_regex_router) {
if (default_handler_) {
co_await default_handler_(request_, response_);
}
else {
// not found
response_.set_status(status_type::not_found);
}
}
}
}
}
}
if (!response_.get_delay()) {
if (head_buf_.size()) {
if (type == content_type::multipart ||
type == content_type::chunked) {
if (response_.content().empty())
response_.set_status_and_content(
status_type::not_implemented,
"mutipart handler not implemented or incorrect implemented");
co_await reply();
close();
CINATRA_LOG_ERROR
<< "mutipart handler not implemented or incorrect implemented"
<< ec.message();
break;
}
else if (parser_.method()[0] != 'G' && parser_.method()[0] != 'H') {
// handle pipeling, only support GET and HEAD method now.
response_.set_status_and_content(status_type::method_not_allowed,
"method not allowed");
co_await reply();
}
else {
resp_str_.reserve(512);
response_.build_resp_str(resp_str_);
while (true) {
size_t left_size = head_buf_.size();
auto next_data_ptr =
asio::buffer_cast<const char *>(head_buf_.data());
std::string_view left_content{next_data_ptr, left_size};
size_t pos = left_content.find(TWO_CRCF);
if (pos == std::string_view::npos) {
break;
}
http_parser parser;
int head_len = parser.parse_request(next_data_ptr, left_size, 0);
if (head_len <= 0) {
CINATRA_LOG_ERROR << "parse http header error";
response_.set_status_and_content(status_type::bad_request,
"invalid http protocol");
co_await reply();
close();
break;
}
head_buf_.consume(pos + TWO_CRCF.length());
std::string_view next_key = {
parser.method().data(),
parser.method().length() + 1 + parser.url().length()};
coro_http_request req(parser, this);
coro_http_response resp(this);
resp.need_date_head(response_.need_date());
if (auto handler = router_.get_handler(next_key); handler) {
router_.route(handler, req, resp, key);
}
else {
if (auto coro_handler = router_.get_coro_handler(next_key);
coro_handler) {
co_await router_.route_coro(coro_handler, req, resp, key);
}
else {
resp.set_status(status_type::not_found);
}
}
resp.build_resp_str(resp_str_);
}
auto [write_ec, _] = co_await async_write(asio::buffer(resp_str_));
if (write_ec) {
CINATRA_LOG_ERROR << "async_write error: " << write_ec.message();
close();
co_return;
}
}
head_buf_.consume(head_buf_.size());
}
else {
handle_session_for_response();
co_await reply();
}
}
if (!keep_alive_) {
// now in io thread, so can close socket immediately.
close();
}
response_.clear();
request_.clear();
buffers_.clear();
body_.clear();
resp_str_.clear();
multi_buf_ = true;
if (need_shrink_every_time_) {
body_.shrink_to_fit();
}
}
if(head_buf_.size()) {
head_buf_.consume(head_buf_.size());
}
}
|
subq $0xcd8, %rsp # imm = 0xCD8
movq %rdi, 0x6a8(%rsp)
movq %rdi, 0xcd0(%rsp)
movq %rdi, %rax
addq $0x14d0, %rax # imm = 0x14D0
movq %rax, 0x6b0(%rsp)
movq %rdi, %rax
addq $0x14d8, %rax # imm = 0x14D8
movq %rax, 0x6b8(%rsp)
movq %rdi, %rax
addq $0x14e0, %rax # imm = 0x14E0
movq %rax, 0x6c0(%rsp)
movq %rdi, %rax
addq $0x14e8, %rax # imm = 0x14E8
movq %rax, 0x6c8(%rsp)
movq %rdi, %rax
addq $0x14f0, %rax # imm = 0x14F0
movq %rax, 0x6d0(%rsp)
movq %rdi, %rax
addq $0x14f8, %rax # imm = 0x14F8
movq %rax, 0x6d8(%rsp)
movq %rdi, %rax
addq $0x1500, %rax # imm = 0x1500
movq %rax, 0x6e0(%rsp)
movq %rdi, %rax
addq $0x1508, %rax # imm = 0x1508
movq %rax, 0x6e8(%rsp)
movq %rdi, %rax
addq $0x1510, %rax # imm = 0x1510
movq %rax, 0x6f0(%rsp)
movq %rdi, %rax
addq $0x1518, %rax # imm = 0x1518
movq %rax, 0x6f8(%rsp)
movq %rdi, %rax
addq $0x1520, %rax # imm = 0x1520
movq %rax, 0x700(%rsp)
movq %rdi, %rax
addq $0x1528, %rax # imm = 0x1528
movq %rax, 0x708(%rsp)
movq %rdi, %rax
addq $0x1530, %rax # imm = 0x1530
movq %rax, 0x710(%rsp)
movq %rdi, %rax
addq $0x1538, %rax # imm = 0x1538
movq %rax, 0x718(%rsp)
movq %rdi, %rax
addq $0x1540, %rax # imm = 0x1540
movq %rax, 0x720(%rsp)
movq %rdi, %rax
addq $0x1711, %rax # imm = 0x1711
movq %rax, 0x728(%rsp)
movq %rdi, %rax
addq $0x1548, %rax # imm = 0x1548
movq %rax, 0x730(%rsp)
movq %rdi, %rax
addq $0x1550, %rax # imm = 0x1550
movq %rax, 0x738(%rsp)
movq %rdi, %rax
addq $0x1700, %rax # imm = 0x1700
movq %rax, 0x740(%rsp)
movq %rdi, %rax
addq $0x1558, %rax # imm = 0x1558
movq %rax, 0x748(%rsp)
movq %rdi, %rax
addq $0x1238, %rax # imm = 0x1238
movq %rax, 0x750(%rsp)
movq %rdi, %rax
addq $0x1560, %rax # imm = 0x1560
movq %rax, 0x758(%rsp)
movq %rdi, %rax
addq $0x1568, %rax # imm = 0x1568
movq %rax, 0x760(%rsp)
movq %rdi, %rax
addq $0x1570, %rax # imm = 0x1570
movq %rax, 0x768(%rsp)
movq %rdi, %rax
addq $0x1578, %rax # imm = 0x1578
movq %rax, 0x770(%rsp)
movq %rdi, %rax
addq $0x12e0, %rax # imm = 0x12E0
movq %rax, 0x778(%rsp)
movq %rdi, %rax
addq $0xfd8, %rax # imm = 0xFD8
movq %rax, 0x780(%rsp)
movq %rdi, %rax
addq $0x1580, %rax # imm = 0x1580
movq %rax, 0x788(%rsp)
movq %rdi, %rax
addq $0x12f0, %rax # imm = 0x12F0
movq %rax, 0x790(%rsp)
movq %rdi, %rax
addq $0x1704, %rax # imm = 0x1704
movq %rax, 0x798(%rsp)
movq %rdi, %rax
addq $0x1712, %rax # imm = 0x1712
movq %rax, 0x7a0(%rsp)
movq %rdi, %rax
addq $0xff8, %rax # imm = 0xFF8
movq %rax, 0x7a8(%rsp)
movq %rdi, %rax
addq $0x1713, %rax # imm = 0x1713
movq %rax, 0x7b0(%rsp)
movq %rdi, %rax
addq $0x1300, %rax # imm = 0x1300
movq %rax, 0x7b8(%rsp)
movq %rdi, %rax
addq $0x1588, %rax # imm = 0x1588
movq %rax, 0x7c0(%rsp)
movq %rdi, %rax
addq $0x1590, %rax # imm = 0x1590
movq %rax, 0x7c8(%rsp)
movq %rdi, %rax
addq $0x1714, %rax # imm = 0x1714
movq %rax, 0x7d0(%rsp)
movq %rdi, %rax
addq $0x1715, %rax # imm = 0x1715
movq %rax, 0x7d8(%rsp)
movq %rdi, %rax
addq $0x1598, %rax # imm = 0x1598
movq %rax, 0x7e0(%rsp)
movq %rdi, %rax
addq $0x1018, %rax # imm = 0x1018
movq %rax, 0x7e8(%rsp)
movq %rdi, %rax
addq $0x1716, %rax # imm = 0x1716
movq %rax, 0x7f0(%rsp)
movq %rdi, %rax
addq $0x1310, %rax # imm = 0x1310
movq %rax, 0x7f8(%rsp)
movq %rdi, %rax
addq $0x15a0, %rax # imm = 0x15A0
movq %rax, 0x800(%rsp)
movq %rdi, %rax
addq $0x15a8, %rax # imm = 0x15A8
movq %rax, 0x808(%rsp)
movq %rdi, %rax
addq $0x1717, %rax # imm = 0x1717
movq %rax, 0x810(%rsp)
movq %rdi, %rax
addq $0x1708, %rax # imm = 0x1708
movq %rax, 0x818(%rsp)
movq %rdi, %rax
addq $0x15b0, %rax # imm = 0x15B0
movq %rax, 0x820(%rsp)
movq %rdi, %rax
addq $0x1718, %rax # imm = 0x1718
movq %rax, 0x828(%rsp)
movq %rdi, %rax
addq $0x15b8, %rax # imm = 0x15B8
movq %rax, 0x830(%rsp)
movq %rdi, %rax
addq $0x15c0, %rax # imm = 0x15C0
movq %rax, 0x838(%rsp)
movq %rdi, %rax
addq $0x1719, %rax # imm = 0x1719
movq %rax, 0x840(%rsp)
movq %rdi, %rax
addq $0x1320, %rax # imm = 0x1320
movq %rax, 0x848(%rsp)
movq %rdi, %rax
addq $0x15c8, %rax # imm = 0x15C8
movq %rax, 0x850(%rsp)
movq %rdi, %rax
addq $0x15d0, %rax # imm = 0x15D0
movq %rax, 0x858(%rsp)
movq %rdi, %rax
addq $0x15d8, %rax # imm = 0x15D8
movq %rax, 0x860(%rsp)
movq %rdi, %rax
addq $0x1330, %rax # imm = 0x1330
movq %rax, 0x868(%rsp)
movq %rdi, %rax
addq $0x1250, %rax # imm = 0x1250
movq %rax, 0x870(%rsp)
movq %rdi, %rax
addq $0x15e0, %rax # imm = 0x15E0
movq %rax, 0x878(%rsp)
movq %rdi, %rax
addq $0x15e8, %rax # imm = 0x15E8
movq %rax, 0x880(%rsp)
movq %rdi, %rax
addq $0x1340, %rax # imm = 0x1340
movq %rax, 0x888(%rsp)
movq %rdi, %rax
addq $0x171a, %rax # imm = 0x171A
movq %rax, 0x890(%rsp)
movq %rdi, %rax
addq $0x1038, %rax # imm = 0x1038
movq %rax, 0x898(%rsp)
movq %rdi, %rax
addq $0x1350, %rax # imm = 0x1350
movq %rax, 0x8a0(%rsp)
movq %rdi, %rax
addq $0x1360, %rax # imm = 0x1360
movq %rax, 0x8a8(%rsp)
movq %rdi, %rax
addq $0x1370, %rax # imm = 0x1370
movq %rax, 0x8b0(%rsp)
movq %rdi, %rax
addq $0x1380, %rax # imm = 0x1380
movq %rax, 0x8b8(%rsp)
movq %rdi, %rax
addq $0x1058, %rax # imm = 0x1058
movq %rax, 0x8c0(%rsp)
movq %rdi, %rax
addq $0x1390, %rax # imm = 0x1390
movq %rax, 0x8c8(%rsp)
movq %rdi, %rax
addq $0x1078, %rax # imm = 0x1078
movq %rax, 0x8d0(%rsp)
movq %rdi, %rax
addq $0x15f0, %rax # imm = 0x15F0
movq %rax, 0x8d8(%rsp)
movq %rdi, %rax
addq $0x15f8, %rax # imm = 0x15F8
movq %rax, 0x8e0(%rsp)
movq %rdi, %rax
addq $0x1600, %rax # imm = 0x1600
movq %rax, 0x8e8(%rsp)
movq %rdi, %rax
addq $0x1608, %rax # imm = 0x1608
movq %rax, 0x8f0(%rsp)
movq %rdi, %rax
addq $0x13a0, %rax # imm = 0x13A0
movq %rax, 0x8f8(%rsp)
movq %rdi, %rax
addq $0x171b, %rax # imm = 0x171B
movq %rax, 0x900(%rsp)
movq %rdi, %rax
addq $0x171c, %rax # imm = 0x171C
movq %rax, 0x908(%rsp)
movq %rdi, %rax
addq $0x171d, %rax # imm = 0x171D
movq %rax, 0x910(%rsp)
movq %rdi, %rax
addq $0x1098, %rax # imm = 0x1098
movq %rax, 0x918(%rsp)
movq %rdi, %rax
addq $0x10b8, %rax # imm = 0x10B8
movq %rax, 0x920(%rsp)
movq %rdi, %rax
addq $0x13b0, %rax # imm = 0x13B0
movq %rax, 0x928(%rsp)
movq %rdi, %rax
addq $0x171e, %rax # imm = 0x171E
movq %rax, 0x930(%rsp)
movq %rdi, %rax
addq $0x10d8, %rax # imm = 0x10D8
movq %rax, 0x938(%rsp)
movq %rdi, %rax
addq $0x13c0, %rax # imm = 0x13C0
movq %rax, 0x940(%rsp)
movq %rdi, %rax
addq $0xf18, %rax # imm = 0xF18
movq %rax, 0x948(%rsp)
movq %rdi, %rax
addq $0x13d0, %rax # imm = 0x13D0
movq %rax, 0x950(%rsp)
movq %rdi, %rax
addq $0x1268, %rax # imm = 0x1268
movq %rax, 0x958(%rsp)
movq %rdi, %rax
addq $0x10f8, %rax # imm = 0x10F8
movq %rax, 0x960(%rsp)
movq %rdi, %rax
addq $0xf78, %rax # imm = 0xF78
movq %rax, 0x968(%rsp)
movq %rdi, %rax
addq $0x13e0, %rax # imm = 0x13E0
movq %rax, 0x970(%rsp)
movq %rdi, %rax
addq $0x1280, %rax # imm = 0x1280
movq %rax, 0x978(%rsp)
movq %rdi, %rax
addq $0x1610, %rax # imm = 0x1610
movq %rax, 0x980(%rsp)
movq %rdi, %rax
addq $0x1618, %rax # imm = 0x1618
movq %rax, 0x988(%rsp)
movq %rdi, %rax
addq $0x1298, %rax # imm = 0x1298
movq %rax, 0x990(%rsp)
movq %rdi, %rax
addq $0x1620, %rax # imm = 0x1620
movq %rax, 0x998(%rsp)
movq %rdi, %rax
addq $0x1628, %rax # imm = 0x1628
movq %rax, 0x9a0(%rsp)
movq %rdi, %rax
addq $0x1630, %rax # imm = 0x1630
movq %rax, 0x9a8(%rsp)
movq %rdi, %rax
addq $0x1638, %rax # imm = 0x1638
movq %rax, 0x9b0(%rsp)
movq %rdi, %rax
addq $0x1118, %rax # imm = 0x1118
movq %rax, 0x9b8(%rsp)
movq %rdi, %rax
addq $0x171f, %rax # imm = 0x171F
movq %rax, 0x9c0(%rsp)
movq %rdi, %rax
addq $0x1138, %rax # imm = 0x1138
movq %rax, 0x9c8(%rsp)
movq %rdi, %rax
addq $0x1640, %rax # imm = 0x1640
movq %rax, 0x9d0(%rsp)
movq %rdi, %rax
addq $0x1648, %rax # imm = 0x1648
movq %rax, 0x9d8(%rsp)
movq %rdi, %rax
addq $0x12b0, %rax # imm = 0x12B0
movq %rax, 0x9e0(%rsp)
movq %rdi, %rax
addq $0x1650, %rax # imm = 0x1650
movq %rax, 0x9e8(%rsp)
movq %rdi, %rax
addq $0x1658, %rax # imm = 0x1658
movq %rax, 0x9f0(%rsp)
movq %rdi, %rax
addq $0x1158, %rax # imm = 0x1158
movq %rax, 0x9f8(%rsp)
movq %rdi, %rax
addq $0x1720, %rax # imm = 0x1720
movq %rax, 0xa00(%rsp)
movq %rdi, %rax
addq $0x1178, %rax # imm = 0x1178
movq %rax, 0xa08(%rsp)
movq %rdi, %rax
addq $0x1660, %rax # imm = 0x1660
movq %rax, 0xa10(%rsp)
movq %rdi, %rax
addq $0x1668, %rax # imm = 0x1668
movq %rax, 0xa18(%rsp)
movq %rdi, %rax
addq $0x13f0, %rax # imm = 0x13F0
movq %rax, 0xa20(%rsp)
movq %rdi, %rax
addq $0x1198, %rax # imm = 0x1198
movq %rax, 0xa28(%rsp)
movq %rdi, %rax
addq $0x1721, %rax # imm = 0x1721
movq %rax, 0xa30(%rsp)
movq %rdi, %rax
addq $0x1400, %rax # imm = 0x1400
movq %rax, 0xa38(%rsp)
movq %rdi, %rax
addq $0x1670, %rax # imm = 0x1670
movq %rax, 0xa40(%rsp)
movq %rdi, %rax
addq $0x1678, %rax # imm = 0x1678
movq %rax, 0xa48(%rsp)
movq %rdi, %rax
addq $0x1722, %rax # imm = 0x1722
movq %rax, 0xa50(%rsp)
movq %rdi, %rax
addq $0x1723, %rax # imm = 0x1723
movq %rax, 0xa58(%rsp)
movq %rdi, %rax
addq $0x11b8, %rax # imm = 0x11B8
movq %rax, 0xa60(%rsp)
movq %rdi, %rax
addq $0x1410, %rax # imm = 0x1410
movq %rax, 0xa68(%rsp)
movq %rdi, %rax
addq $0x1420, %rax # imm = 0x1420
movq %rax, 0xa70(%rsp)
movq %rdi, %rax
addq $0x11d8, %rax # imm = 0x11D8
movq %rax, 0xa78(%rsp)
movq %rdi, %rax
addq $0x1724, %rax # imm = 0x1724
movq %rax, 0xa80(%rsp)
movq %rdi, %rax
addq $0x1430, %rax # imm = 0x1430
movq %rax, 0xa88(%rsp)
movq %rdi, %rax
addq $0x1680, %rax # imm = 0x1680
movq %rax, 0xa90(%rsp)
movq %rdi, %rax
addq $0x1688, %rax # imm = 0x1688
movq %rax, 0xa98(%rsp)
movq %rdi, %rax
addq $0x1725, %rax # imm = 0x1725
movq %rax, 0xaa0(%rsp)
movq %rdi, %rax
addq $0x1690, %rax # imm = 0x1690
movq %rax, 0xaa8(%rsp)
movq %rdi, %rax
addq $0x1698, %rax # imm = 0x1698
movq %rax, 0xab0(%rsp)
movq %rdi, %rax
addq $0x1440, %rax # imm = 0x1440
movq %rax, 0xab8(%rsp)
movq %rdi, %rax
addq $0x1450, %rax # imm = 0x1450
movq %rax, 0xac0(%rsp)
movq %rdi, %rax
addq $0x16a0, %rax # imm = 0x16A0
movq %rax, 0xac8(%rsp)
movq %rdi, %rax
addq $0x30, %rax
movq %rax, 0xad0(%rsp)
movq %rdi, %rax
addq $0x170c, %rax # imm = 0x170C
movq %rax, 0xad8(%rsp)
movq %rdi, %rax
addq $0x1726, %rax # imm = 0x1726
movq %rax, 0xae0(%rsp)
movq %rdi, %rax
addq $0x11f8, %rax # imm = 0x11F8
movq %rax, 0xae8(%rsp)
movq %rdi, %rax
addq $0x1727, %rax # imm = 0x1727
movq %rax, 0xaf0(%rsp)
movq %rdi, %rax
addq $0x1460, %rax # imm = 0x1460
movq %rax, 0xaf8(%rsp)
movq %rdi, %rax
addq $0x16a8, %rax # imm = 0x16A8
movq %rax, 0xb00(%rsp)
movq %rdi, %rax
addq $0x16b0, %rax # imm = 0x16B0
movq %rax, 0xb08(%rsp)
movq %rdi, %rax
addq $0x1728, %rax # imm = 0x1728
movq %rax, 0xb10(%rsp)
movq %rdi, %rax
addq $0x1470, %rax # imm = 0x1470
movq %rax, 0xb18(%rsp)
movq %rdi, %rax
addq $0x1480, %rax # imm = 0x1480
movq %rax, 0xb20(%rsp)
movq %rdi, %rax
addq $0x1490, %rax # imm = 0x1490
movq %rax, 0xb28(%rsp)
movq %rdi, %rax
addq $0x14a0, %rax # imm = 0x14A0
movq %rax, 0xb30(%rsp)
movq %rdi, %rax
addq $0xe50, %rax # imm = 0xE50
movq %rax, 0xb38(%rsp)
movq %rdi, %rax
addq $0xd50, %rax # imm = 0xD50
movq %rax, 0xb40(%rsp)
movq %rdi, %rax
addq $0x16b8, %rax # imm = 0x16B8
movq %rax, 0xb48(%rsp)
movq %rdi, %rax
addq $0x16c0, %rax # imm = 0x16C0
movq %rax, 0xb50(%rsp)
movq %rdi, %rax
addq $0x16c8, %rax # imm = 0x16C8
movq %rax, 0xb58(%rsp)
movq %rdi, %rax
addq $0x16d0, %rax # imm = 0x16D0
movq %rax, 0xb60(%rsp)
movq %rdi, %rax
addq $0x14b0, %rax # imm = 0x14B0
movq %rax, 0xb68(%rsp)
movq %rdi, %rax
addq $0x12c8, %rax # imm = 0x12C8
movq %rax, 0xb70(%rsp)
movq %rdi, %rax
addq $0x16d8, %rax # imm = 0x16D8
movq %rax, 0xb78(%rsp)
movq %rdi, %rax
addq $0x16e0, %rax # imm = 0x16E0
movq %rax, 0xb80(%rsp)
movq %rdi, %rax
addq $0x14c0, %rax # imm = 0x14C0
movq %rax, 0xb88(%rsp)
movq %rdi, %rax
addq $0x1729, %rax # imm = 0x1729
movq %rax, 0xb90(%rsp)
movq %rdi, %rax
addq $0x1218, %rax # imm = 0x1218
movq %rax, 0xb98(%rsp)
movq %rdi, %rax
addq $0x16e8, %rax # imm = 0x16E8
movq %rax, 0xba0(%rsp)
movq %rdi, %rax
addq $0x16f0, %rax # imm = 0x16F0
movq %rax, 0xba8(%rsp)
movq %rdi, %rax
addq $0x172a, %rax # imm = 0x172A
movq %rax, 0xbb0(%rsp)
movq %rdi, %rax
addq $0x172b, %rax # imm = 0x172B
movq %rax, 0xbb8(%rsp)
addq $0x10, %rdi
movq %rdi, 0xbc0(%rsp)
jmp 0x24cb7
jmp 0x1fb4a
jmp 0x1fb4c
movb $0x1, %al
testb %al, %al
jne 0x1fb7e
jmp 0x1fb54
movb $0x1, %al
testb %al, %al
jne 0x24c83
jmp 0x1fb60
movl $0x2, %eax
movl %eax, 0x6a4(%rsp)
jmp 0x1fb6e
movl 0x6a4(%rsp), %eax
movl %eax, 0x6a0(%rsp)
jmp 0x1fba2
movq 0x728(%rsp), %rdi
callq 0x66750
xorl %eax, %eax
movl %eax, 0x69c(%rsp)
movl 0x69c(%rsp), %eax
movl %eax, 0x6a0(%rsp)
movl 0x6a0(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x698(%rsp)
je 0x1fbc8
movl 0x698(%rsp), %eax
movl %eax, 0x694(%rsp)
jmp 0x24c3d
movq 0x730(%rsp), %rdi
callq 0x78d10
movq 0x748(%rsp), %rdi
callq 0x78d10
jmp 0x1fbe4
jmp 0x1fbe6
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rax
movq %rax, 0x680(%rsp)
addq $0x78, %rax
movq %rax, 0x688(%rsp)
leaq 0x10ae48(%rip), %rdi # 0x12aa58
callq 0x56f00
movq 0x680(%rsp), %rsi
movq 0x760(%rsp), %rdi
movq %rax, %rcx
movq %rdx, %rax
movq 0x688(%rsp), %rdx
movq %rcx, 0xbd8(%rsp)
movq %rax, 0xbe0(%rsp)
movq 0xbd8(%rsp), %rcx
movq 0xbe0(%rsp), %r8
callq 0x78d80
movq 0x758(%rsp), %rdi
movq 0xbc0(%rsp), %rsi
movq 0x760(%rsp), %rdx
callq 0x78d40
jmp 0x1fc77
movq 0x758(%rsp), %rdi
callq 0x78e10
testb $0x1, %al
jne 0x1fd78
movq 0x6a8(%rsp), %rax
movb $0x1, 0x1710(%rax)
movq 0x6a8(%rsp), %rsi
movq 0x758(%rsp), %rdi
callq 0x15350
movq %rax, 0x678(%rsp)
jmp 0x1fcba
movq 0x678(%rsp), %rdi
movq (%rdi), %rax
addq $0xcd8, %rsp # imm = 0xCD8
jmpq *%rax
jmp 0x1fcd0
jmp 0x1fcd2
movb $0x1, %al
testb %al, %al
jne 0x1fd78
jmp 0x1fcde
movb $0x1, %al
testb %al, %al
jne 0x24c83
jmp 0x1fcea
movl $0x2, %eax
movl %eax, 0x674(%rsp)
jmp 0x1fcf8
movl 0x674(%rsp), %eax
movl %eax, 0x670(%rsp)
jmp 0x1fdb8
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x24b24
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x1fef3
movq 0x758(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x78e30
jmp 0x1fef3
movq 0x750(%rsp), %rdi
movq 0x6e8(%rsp), %rax
movq 0x758(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rsi
callq 0x81a30
jmp 0x1fd9d
jmp 0x1fd9f
xorl %eax, %eax
movl %eax, 0x66c(%rsp)
jmp 0x1fdaa
movl 0x66c(%rsp), %eax
movl %eax, 0x670(%rsp)
movq 0x758(%rsp), %rdi
movl 0x670(%rsp), %eax
movl %eax, 0x664(%rsp)
callq 0x78e30
movq 0x760(%rsp), %rdi
callq 0x78e40
movl 0x664(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x668(%rsp)
je 0x1fe06
movl 0x668(%rsp), %eax
movl %eax, 0x660(%rsp)
jmp 0x24a3f
movq 0x750(%rsp), %rdi
callq 0x78e50
movq 0x750(%rsp), %rdi
movq %rax, %rcx
movq 0x768(%rsp), %rax
movq %rcx, (%rax)
callq 0x78e60
movq 0x770(%rsp), %rcx
movq %rax, %rdx
movq 0x768(%rsp), %rax
movq %rdx, (%rcx)
movq (%rax), %rdi
callq 0x3ac70
testb $0x1, %al
jne 0x1fe55
jmp 0x1ff81
movq 0x778(%rsp), %rdi
movq 0x768(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x658(%rsp)
movl $0x2, %esi
callq 0x78e70
movq 0x658(%rsp), %rdi
movq 0x778(%rsp), %rsi
callq 0x599b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1fe9a
jmp 0x1ff45
leaq 0xbd21b(%rip), %rdi # 0xdd0bc
leaq 0xbb4d8(%rip), %rsi # 0xdb380
callq 0x78ec0
movq %rax, 0x650(%rsp)
movq 0x780(%rsp), %rdi
movq 0x768(%rsp), %rax
movq (%rax), %rsi
callq 0x3aee0
jmp 0x1fecf
movq 0x780(%rsp), %rsi
movq 0x650(%rsp), %rdi
callq 0x66d40
movq 0x780(%rsp), %rdi
callq 0x358a0
jmp 0x1ff45
movq 0x760(%rsp), %rdi
callq 0x78e40
jmp 0x24a85
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x24a83
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x24a83
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
movl $0x1, %esi
callq 0x6f7e0
jmp 0x1ff60
movl $0x5, %eax
movl %eax, 0x64c(%rsp)
jmp 0x1ff6e
movl 0x64c(%rsp), %eax
movl %eax, 0x648(%rsp)
jmp 0x24a29
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
movq %rdi, 0x638(%rsp)
addq $0x78, %rdi
callq 0x78ee0
movq 0x790(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x78ed0
movq 0x638(%rsp), %rdi
movq 0x788(%rsp), %rcx
movq %rax, %rdx
movq 0x770(%rsp), %rax
movq %rdx, (%rcx)
addq $0x158, %rdi # imm = 0x158
movq (%rcx), %rsi
movq (%rax), %rax
movq (%rax), %rdx
xorl %ecx, %ecx
callq 0x78f70
movl %eax, 0x644(%rsp)
jmp 0x1fff3
movq 0x798(%rsp), %rax
movl 0x644(%rsp), %ecx
movl %ecx, (%rax)
cmpl $0x0, (%rax)
jg 0x203ca
movq 0x7a0(%rsp), %rdi
leaq 0xbb37d(%rip), %rsi # 0xdb399
callq 0x792d0
jmp 0x20023
movq 0x7a0(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rax
movq %rax, 0x628(%rsp)
callq 0x5e440
movq 0x628(%rsp), %rax
movq 0x7b0(%rsp), %rdi
addq $0xf48, %rax # imm = 0xF48
movq %rax, 0x630(%rsp)
callq 0x139e0
movq 0x7a8(%rsp), %rdi
movq 0x7b0(%rsp), %rdx
leaq 0xbb330(%rip), %rsi # 0xdb3b1
callq 0x357e0
jmp 0x20088
movq 0x7b8(%rsp), %rdi
leaq 0xb86f4(%rip), %rsi # 0xd878b
callq 0x793e0
movq 0x7b8(%rsp), %rax
movq 0x630(%rsp), %rdi
movq 0x7a8(%rsp), %rdx
movq (%rax), %r8
movq 0x8(%rax), %r9
movl $0x190, %esi # imm = 0x190
movl $0x3, %ecx
callq 0x79310
jmp 0x200cc
movq 0x7a8(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rax
movq %rax, 0x620(%rsp)
callq 0x358a0
movq 0x7b0(%rsp), %rdi
callq 0x135b0
movq 0x7c8(%rsp), %rdi
movq 0x620(%rsp), %rsi
movl $0x1, %edx
callq 0x79480
jmp 0x20119
movq 0x7c8(%rsp), %rdx
movq 0xbc0(%rsp), %rsi
movq 0x7c0(%rsp), %rdi
callq 0x79440
jmp 0x20138
movq 0x7c0(%rsp), %rdi
callq 0x79fa0
testb $0x1, %al
jne 0x202dd
movq 0x6a8(%rsp), %rax
movb $0x2, 0x1710(%rax)
movq 0x6a8(%rsp), %rsi
movq 0x7c0(%rsp), %rdi
callq 0x15410
movq %rax, 0x618(%rsp)
jmp 0x2017b
movq 0x618(%rsp), %rdi
movq (%rdi), %rax
addq $0xcd8, %rsp # imm = 0xCD8
jmpq *%rax
jmp 0x20191
jmp 0x20193
movb $0x1, %al
testb %al, %al
jne 0x202dd
jmp 0x2019f
movb $0x1, %al
testb %al, %al
jne 0x24c83
jmp 0x201ab
movl $0x2, %eax
movl %eax, 0x614(%rsp)
jmp 0x201b9
movl 0x614(%rsp), %eax
movl %eax, 0x610(%rsp)
jmp 0x2032e
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x24a81
movq 0x7a0(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x5e440
jmp 0x24a81
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x2025e
movq 0x7a8(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x358a0
movq 0x7b0(%rsp), %rdi
callq 0x135b0
jmp 0x24a81
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x203c5
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x203b8
movq 0x7c0(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x79fc0
jmp 0x203b8
movq 0x6b0(%rsp), %rax
movq 0x7c0(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x8e6a0
movb %al, 0x60f(%rsp)
jmp 0x20301
jmp 0x20303
movq 0x7d0(%rsp), %rax
movb 0x60f(%rsp), %cl
andb $0x1, %cl
movb %cl, (%rax)
xorl %eax, %eax
movl %eax, 0x608(%rsp)
movl 0x608(%rsp), %eax
movl %eax, 0x610(%rsp)
movq 0x7c0(%rsp), %rdi
movl 0x610(%rsp), %eax
movl %eax, 0x600(%rsp)
callq 0x79fc0
movq 0x7c8(%rsp), %rdi
callq 0x79fd0
movl 0x600(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x604(%rsp)
je 0x2037c
movl 0x604(%rsp), %eax
movl %eax, 0x5fc(%rsp)
jmp 0x24a13
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
movl $0x1, %esi
callq 0x6f7e0
jmp 0x20397
movl $0x5, %eax
movl %eax, 0x5f8(%rsp)
jmp 0x203a5
movl 0x5f8(%rsp), %eax
movl %eax, 0x5fc(%rsp)
jmp 0x24a13
movq 0x7c8(%rsp), %rdi
callq 0x79fd0
jmp 0x24a81
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0x158, %rdi # imm = 0x158
callq 0x79fe0
movq %rax, 0x5f0(%rsp)
movq 0x5f0(%rsp), %rax
movq 0x6a8(%rsp), %rcx
movq 0x16f8(%rcx), %rcx
cmpq 0x1168(%rcx), %rax
jg 0x20442
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0x158, %rdi # imm = 0x158
callq 0x79fe0
movq %rax, 0x5e8(%rsp)
movq 0x5e8(%rsp), %rax
cmpq $0x0, %rax
jge 0x20849
movq 0x7d8(%rsp), %rdi
leaq 0xbaf76(%rip), %rsi # 0xdb3c7
callq 0x79ff0
movq %rax, 0x5e0(%rsp)
jmp 0x20460
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0x158, %rdi # imm = 0x158
callq 0x79fe0
movq %rax, 0x5d8(%rsp)
movq 0x7e0(%rsp), %rsi
movq 0x5e0(%rsp), %rdi
movq 0x5d8(%rsp), %rax
movq %rax, (%rsi)
callq 0x7a030
jmp 0x204a5
movq 0x7d8(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rax
movq %rax, 0x5c8(%rsp)
callq 0x5e440
movq 0x5c8(%rsp), %rax
movq 0x7f0(%rsp), %rdi
addq $0xf48, %rax # imm = 0xF48
movq %rax, 0x5d0(%rsp)
callq 0x139e0
movq 0x7e8(%rsp), %rdi
movq 0x7f0(%rsp), %rdx
leaq 0xbaee2(%rip), %rsi # 0xdb3e5
callq 0x357e0
jmp 0x2050a
movq 0x7f8(%rsp), %rdi
leaq 0xb8272(%rip), %rsi # 0xd878b
callq 0x793e0
movq 0x7f8(%rsp), %rax
movq 0x5d0(%rsp), %rdi
movq 0x7e8(%rsp), %rdx
movq (%rax), %r8
movq 0x8(%rax), %r9
movl $0x190, %esi # imm = 0x190
movl $0x3, %ecx
callq 0x79310
jmp 0x2054e
movq 0x7e8(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rax
movq %rax, 0x5c0(%rsp)
callq 0x358a0
movq 0x7f0(%rsp), %rdi
callq 0x135b0
movq 0x808(%rsp), %rdi
movq 0x5c0(%rsp), %rsi
movl $0x1, %edx
callq 0x79480
jmp 0x2059b
movq 0x808(%rsp), %rdx
movq 0xbc0(%rsp), %rsi
movq 0x800(%rsp), %rdi
callq 0x79440
jmp 0x205ba
movq 0x800(%rsp), %rdi
callq 0x79fa0
testb $0x1, %al
jne 0x2075c
movq 0x6a8(%rsp), %rax
movb $0x3, 0x1710(%rax)
movq 0x6a8(%rsp), %rsi
movq 0x800(%rsp), %rdi
callq 0x154d0
movq %rax, 0x5b8(%rsp)
jmp 0x205fd
movq 0x5b8(%rsp), %rdi
movq (%rdi), %rax
addq $0xcd8, %rsp # imm = 0xCD8
jmpq *%rax
jmp 0x20613
jmp 0x20615
movb $0x1, %al
testb %al, %al
jne 0x2075c
jmp 0x20621
movb $0x1, %al
testb %al, %al
jne 0x24c83
jmp 0x2062d
movl $0x2, %eax
movl %eax, 0x5b4(%rsp)
jmp 0x2063b
movl 0x5b4(%rsp), %eax
movl %eax, 0x5b0(%rsp)
jmp 0x207ad
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x20686
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
movq 0x7d8(%rsp), %rdi
callq 0x5e440
jmp 0x24a81
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x206dd
movq 0x7e8(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x358a0
movq 0x7f0(%rsp), %rdi
callq 0x135b0
jmp 0x24a81
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x20844
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x20837
movq 0x800(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x79fc0
jmp 0x20837
movq 0x6b8(%rsp), %rax
movq 0x800(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x8e6a0
movb %al, 0x5af(%rsp)
jmp 0x20780
jmp 0x20782
movq 0x810(%rsp), %rax
movb 0x5af(%rsp), %cl
andb $0x1, %cl
movb %cl, (%rax)
xorl %eax, %eax
movl %eax, 0x5a8(%rsp)
movl 0x5a8(%rsp), %eax
movl %eax, 0x5b0(%rsp)
movq 0x800(%rsp), %rdi
movl 0x5b0(%rsp), %eax
movl %eax, 0x5a0(%rsp)
callq 0x79fc0
movq 0x808(%rsp), %rdi
callq 0x79fd0
movl 0x5a0(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x5a4(%rsp)
je 0x207fb
movl 0x5a4(%rsp), %eax
movl %eax, 0x5fc(%rsp)
jmp 0x24a13
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
movl $0x1, %esi
callq 0x6f7e0
jmp 0x20816
movl $0x5, %eax
movl %eax, 0x59c(%rsp)
jmp 0x20824
movl 0x59c(%rsp), %eax
movl %eax, 0x5fc(%rsp)
jmp 0x24a13
movq 0x808(%rsp), %rdi
callq 0x79fd0
jmp 0x24a81
movq 0x770(%rsp), %rax
movq 0x6a8(%rsp), %rcx
movq 0x16f8(%rcx), %rdi
addq $0x78, %rdi
movq (%rax), %rax
movq (%rax), %rsi
callq 0x7a070
jmp 0x20871
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
callq 0x7a160
movb %al, 0x59b(%rsp)
jmp 0x2088e
movb 0x59b(%rsp), %al
movq 0x6a8(%rsp), %rcx
movq 0x16f8(%rcx), %rdi
andb $0x1, %al
movb %al, 0xe78(%rdi)
addq $0xe80, %rdi # imm = 0xE80
callq 0x7a1a0
movl %eax, 0x594(%rsp)
jmp 0x208c1
movq 0x818(%rsp), %rax
movl 0x594(%rsp), %ecx
movl %ecx, (%rax)
cmpl $0x3, (%rax)
je 0x213b4
movq 0x818(%rsp), %rax
cmpl $0x1, (%rax)
je 0x213b4
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0x158, %rdi # imm = 0x158
callq 0x79fe0
movq %rax, 0x588(%rsp)
movq 0x820(%rsp), %rax
movq 0x588(%rsp), %rcx
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x20d20
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0x158, %rdi # imm = 0x158
callq 0x7a340
movq %rax, 0x578(%rsp)
movq %rdx, 0x580(%rsp)
movq 0x580(%rsp), %rax
movq 0x578(%rsp), %rcx
movq %rcx, 0xbe8(%rsp)
movq %rax, 0xbf0(%rsp)
leaq 0xbaa83(%rip), %rdi # 0xdb401
movl $0x3, %esi
callq 0x7a370
movq %rax, 0xbf8(%rsp)
movq %rdx, 0xc00(%rsp)
movq 0xbe8(%rsp), %rdi
movq 0xbf0(%rsp), %rsi
movq 0xbf8(%rsp), %rdx
movq 0xc00(%rsp), %rcx
callq 0x7a2b0
testb $0x1, %al
jne 0x209c6
jmp 0x20d1b
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0xe80, %rdi # imm = 0xE80
callq 0x7a3b0
movb %al, 0x577(%rsp)
jmp 0x209ea
movb 0x577(%rsp), %al
testb $0x1, %al
jne 0x209fa
jmp 0x20d19
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
callq 0x7a4e0
jmp 0x20a10
movq 0x838(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rsi
movl $0x1, %edx
callq 0x79480
jmp 0x20a33
movq 0x838(%rsp), %rdx
movq 0xbc0(%rsp), %rsi
movq 0x830(%rsp), %rdi
callq 0x79440
jmp 0x20a52
movq 0x830(%rsp), %rdi
callq 0x79fa0
testb $0x1, %al
jne 0x20b93
movq 0x6a8(%rsp), %rax
movb $0x4, 0x1710(%rax)
movq 0x6a8(%rsp), %rsi
movq 0x830(%rsp), %rdi
callq 0x15590
movq %rax, 0x568(%rsp)
jmp 0x20a95
movq 0x568(%rsp), %rdi
movq (%rdi), %rax
addq $0xcd8, %rsp # imm = 0xCD8
jmpq *%rax
jmp 0x20aab
jmp 0x20aad
movb $0x1, %al
testb %al, %al
jne 0x20b93
jmp 0x20ab9
movb $0x1, %al
testb %al, %al
jne 0x24c83
jmp 0x20ac5
movl $0x2, %eax
movl %eax, 0x564(%rsp)
jmp 0x20ad3
movl 0x564(%rsp), %eax
movl %eax, 0x560(%rsp)
jmp 0x20be4
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x24a7f
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x213af
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x20c94
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x20c87
movq 0x830(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x79fc0
jmp 0x20c87
movq 0x6c0(%rsp), %rax
movq 0x830(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x8e6a0
movb %al, 0x55f(%rsp)
jmp 0x20bb7
jmp 0x20bb9
movq 0x840(%rsp), %rax
movb 0x55f(%rsp), %cl
andb $0x1, %cl
movb %cl, (%rax)
xorl %eax, %eax
movl %eax, 0x558(%rsp)
movl 0x558(%rsp), %eax
movl %eax, 0x560(%rsp)
movq 0x830(%rsp), %rdi
movl 0x560(%rsp), %eax
movl %eax, 0x550(%rsp)
callq 0x79fc0
movq 0x838(%rsp), %rdi
callq 0x79fd0
movl 0x550(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x554(%rsp)
je 0x20c32
movl 0x554(%rsp), %eax
movl %eax, 0x54c(%rsp)
jmp 0x20cec
movq 0x828(%rsp), %rax
movq 0x840(%rsp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movb %cl, (%rax)
testb $0x1, (%rax)
jne 0x20cb3
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
movl $0x1, %esi
callq 0x6f7e0
jmp 0x20c69
movl $0x5, %eax
movl %eax, 0x548(%rsp)
jmp 0x20c77
movl 0x548(%rsp), %eax
movl %eax, 0x54c(%rsp)
jmp 0x20cec
movq 0x838(%rsp), %rdi
callq 0x79fd0
jmp 0x20d14
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x20d14
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0xf48, %rdi # imm = 0xF48
movl $0x1, %esi
callq 0x7a8e0
xorl %eax, %eax
movl %eax, 0x544(%rsp)
jmp 0x20cde
movl 0x544(%rsp), %eax
movl %eax, 0x54c(%rsp)
movl 0x54c(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x540(%rsp)
je 0x20d12
movl 0x540(%rsp), %eax
movl %eax, 0x53c(%rsp)
jmp 0x21387
jmp 0x20d19
jmp 0x213af
jmp 0x20d1b
jmp 0x2136e
movq 0x820(%rsp), %rax
movq 0x6a8(%rsp), %rcx
movq 0x16f8(%rcx), %rdi
movq (%rax), %rax
movq %rax, 0x530(%rsp)
addq $0x78, %rdi
callq 0x7a900
movq %rax, %rcx
movq 0x530(%rsp), %rax
cmpq %rcx, %rax
ja 0x20e52
movq 0x820(%rsp), %rax
cmpq $0x0, (%rax)
jbe 0x20e4d
movq 0x820(%rsp), %rax
movq 0x6a8(%rsp), %rcx
movq 0x16f8(%rcx), %rdi
addq $0xd8, %rdi
movq (%rax), %rsi
callq 0x7a950
jmp 0x20d99
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
movq %rdi, 0x520(%rsp)
addq $0x78, %rdi
movq %rdi, 0x528(%rsp)
callq 0x78ee0
movq 0x848(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x78ed0
movq 0x520(%rsp), %rdi
movq %rax, 0xc08(%rsp)
addq $0xd8, %rdi
callq 0x7a9c0
movq %rax, %rdi
movq 0x820(%rsp), %rax
movq 0xc08(%rsp), %rsi
movq (%rax), %rdx
callq 0x13480
movq 0x528(%rsp), %rdi
callq 0x7a900
movq 0x528(%rsp), %rdi
movq %rax, %rsi
callq 0x7a070
jmp 0x20e2b
jmp 0x20e4d
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x213af
jmp 0x2136c
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
movq %rdi, 0x518(%rsp)
addq $0x78, %rdi
movq %rdi, 0x510(%rsp)
callq 0x7a900
movq 0x850(%rsp), %rdx
movq 0x510(%rsp), %rdi
movq 0x820(%rsp), %rcx
movq %rax, %rsi
movq 0x858(%rsp), %rax
movq %rsi, (%rdx)
movq (%rcx), %rcx
movq (%rdx), %rdx
subq %rdx, %rcx
movq %rcx, (%rax)
callq 0x78ee0
movq 0x868(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x78ed0
movq 0x860(%rsp), %rcx
movq 0x518(%rsp), %rdi
movq %rax, %rdx
movq 0x820(%rsp), %rax
movq %rdx, (%rcx)
addq $0xd8, %rdi
movq (%rax), %rsi
callq 0x7a950
jmp 0x20ef4
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
movq %rdi, 0x508(%rsp)
addq $0xd8, %rdi
callq 0x7a9c0
movq 0x860(%rsp), %rcx
movq %rax, %rdi
movq 0x850(%rsp), %rax
movq (%rcx), %rsi
movq (%rax), %rdx
callq 0x13480
movq 0x508(%rsp), %rdi
movq 0x850(%rsp), %rax
addq $0x78, %rdi
movq (%rax), %rsi
callq 0x7a070
jmp 0x20f53
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
movq %rdi, 0x500(%rsp)
addq $0xd8, %rdi
callq 0x7a9c0
movq 0x850(%rsp), %rcx
movq %rax, %rdi
movq 0x858(%rsp), %rax
movq (%rcx), %rcx
addq %rcx, %rdi
movq (%rax), %rsi
callq 0x7aa30
movq 0x500(%rsp), %rsi
movq 0x880(%rsp), %rdi
movq %rax, %r8
movq 0x858(%rsp), %rax
movq %rdx, %rcx
movq 0x888(%rsp), %rdx
movq %r8, (%rdx)
movq %rcx, 0x8(%rdx)
movq (%rax), %rcx
callq 0x7a9d0
movq 0x878(%rsp), %rdi
movq 0xbc0(%rsp), %rsi
movq 0x880(%rsp), %rdx
callq 0x78d40
jmp 0x20feb
movq 0x878(%rsp), %rdi
callq 0x78e10
testb $0x1, %al
jne 0x210ec
movq 0x6a8(%rsp), %rax
movb $0x5, 0x1710(%rax)
movq 0x6a8(%rsp), %rsi
movq 0x878(%rsp), %rdi
callq 0x15650
movq %rax, 0x4f8(%rsp)
jmp 0x2102e
movq 0x4f8(%rsp), %rdi
movq (%rdi), %rax
addq $0xcd8, %rsp # imm = 0xCD8
jmpq *%rax
jmp 0x21044
jmp 0x21046
movb $0x1, %al
testb %al, %al
jne 0x210ec
jmp 0x21052
movb $0x1, %al
testb %al, %al
jne 0x24c83
jmp 0x2105e
movl $0x2, %eax
movl %eax, 0x4f4(%rsp)
jmp 0x2106c
movl 0x4f4(%rsp), %eax
movl %eax, 0x4f0(%rsp)
jmp 0x2112c
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x2136a
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x2126c
movq 0x878(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x78e30
jmp 0x2126c
movq 0x870(%rsp), %rdi
movq 0x6f0(%rsp), %rax
movq 0x878(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rsi
callq 0x81a30
jmp 0x21111
jmp 0x21113
xorl %eax, %eax
movl %eax, 0x4ec(%rsp)
jmp 0x2111e
movl 0x4ec(%rsp), %eax
movl %eax, 0x4f0(%rsp)
movq 0x878(%rsp), %rdi
movl 0x4f0(%rsp), %eax
movl %eax, 0x4e4(%rsp)
callq 0x78e30
movq 0x880(%rsp), %rdi
callq 0x78e40
movl 0x4e4(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x4e8(%rsp)
je 0x2117a
movl 0x4e8(%rsp), %eax
movl %eax, 0x4e0(%rsp)
jmp 0x21343
movq 0x870(%rsp), %rdi
callq 0x78e50
movq 0x870(%rsp), %rdi
movq %rax, 0xc10(%rsp)
callq 0x78e60
movq %rax, 0xc18(%rsp)
movq 0xc10(%rsp), %rdi
callq 0x3ac70
testb $0x1, %al
jne 0x211ba
jmp 0x2130e
movq 0x890(%rsp), %rdi
leaq 0xba23c(%rip), %rsi # 0xdb405
callq 0x7aa70
movq %rax, 0x4d8(%rsp)
jmp 0x211d8
movq 0x898(%rsp), %rdi
movq 0xc10(%rsp), %rsi
callq 0x3aee0
jmp 0x211ef
movq 0x898(%rsp), %rsi
movq 0x4d8(%rsp), %rdi
callq 0x5e400
jmp 0x21206
movq 0x898(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rax
movq %rax, 0x4d0(%rsp)
callq 0x358a0
movq 0x890(%rsp), %rdi
callq 0x5e440
movq 0x4d0(%rsp), %rdi
movl $0x1, %esi
callq 0x6f7e0
jmp 0x2124b
movl $0x5, %eax
movl %eax, 0x4cc(%rsp)
jmp 0x21259
movl 0x4cc(%rsp), %eax
movl %eax, 0x4c8(%rsp)
jmp 0x21327
movq 0x880(%rsp), %rdi
callq 0x78e40
jmp 0x21368
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x212e2
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x212e0
movq 0x898(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x358a0
jmp 0x212e2
movq 0x890(%rsp), %rdi
callq 0x5e440
jmp 0x21368
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x21368
xorl %eax, %eax
movl %eax, 0x4c4(%rsp)
jmp 0x21319
movl 0x4c4(%rsp), %eax
movl %eax, 0x4c8(%rsp)
movl 0x4c8(%rsp), %eax
movl %eax, 0x4c0(%rsp)
movl 0x4c0(%rsp), %eax
movl %eax, 0x4e0(%rsp)
movl 0x4e0(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x4bc(%rsp)
je 0x21366
movl 0x4bc(%rsp), %eax
movl %eax, 0x53c(%rsp)
jmp 0x21387
jmp 0x2136c
jmp 0x2136a
jmp 0x213af
jmp 0x2136e
xorl %eax, %eax
movl %eax, 0x4b8(%rsp)
jmp 0x21379
movl 0x4b8(%rsp), %eax
movl %eax, 0x53c(%rsp)
movl 0x53c(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x4b4(%rsp)
je 0x213ad
movl 0x4b4(%rsp), %eax
movl %eax, 0x4b0(%rsp)
jmp 0x249fd
jmp 0x213b4
jmp 0x24a7f
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0x158, %rdi # imm = 0x158
callq 0x7a340
movq %rax, 0x4a0(%rsp)
movq %rdx, 0x4a8(%rsp)
movq 0x8a8(%rsp), %rdi
movq 0x4a8(%rsp), %rax
movq 0x4a0(%rsp), %rcx
movq 0x6a8(%rsp), %rdx
movq 0x16f8(%rdx), %rdx
movq %rdx, 0x480(%rsp)
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
callq 0x57110
movq 0x480(%rsp), %rdi
movq %rax, 0x488(%rsp)
addq $0x158, %rdi # imm = 0x158
callq 0x7a340
movq %rax, 0x490(%rsp)
movq %rdx, 0x498(%rsp)
movq 0x8b0(%rsp), %rdi
movq 0x498(%rsp), %rax
movq 0x490(%rsp), %rcx
movq 0x6a8(%rsp), %rdx
movq 0x16f8(%rdx), %rdx
movq %rdx, 0x460(%rsp)
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
callq 0x7aab0
movq 0x460(%rsp), %rdi
addq $0x1, %rax
movq %rax, 0x468(%rsp)
addq $0x158, %rdi # imm = 0x158
callq 0x7aac0
movq %rax, 0x470(%rsp)
movq %rdx, 0x478(%rsp)
movq 0x8b8(%rsp), %rdi
movq 0x478(%rsp), %rax
movq 0x470(%rsp), %rcx
movq 0x6a8(%rsp), %rdx
movq 0x16f8(%rdx), %rdx
movq %rdx, 0x448(%rsp)
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
callq 0x7aab0
movq 0x468(%rsp), %rdx
movq 0x8a0(%rsp), %rdi
movq 0x488(%rsp), %rsi
addq %rax, %rdx
callq 0x574c0
movq 0x8c0(%rsp), %rdi
callq 0x38f00
movq 0x448(%rsp), %rdi
addq $0x158, %rdi # imm = 0x158
callq 0x7aac0
movq %rax, 0x450(%rsp)
movq %rdx, 0x458(%rsp)
movq 0x8c8(%rsp), %rdi
movq 0x458(%rsp), %rax
movq 0x450(%rsp), %rcx
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
movl $0x25, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x7aaf0
cmpq $-0x1, %rax
je 0x21611
movq 0x8a0(%rsp), %rax
movq 0x8d0(%rsp), %rdi
movq (%rax), %rcx
movq %rcx, 0xc20(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0xc28(%rsp)
movq 0xc20(%rsp), %rsi
movq 0xc28(%rsp), %rdx
callq 0x15710
movq 0x8d0(%rsp), %rsi
movq 0x8c0(%rsp), %rdi
callq 0x57130
movq 0x8d0(%rsp), %rdi
callq 0x358a0
movq 0x8c0(%rsp), %rdi
callq 0x56f00
movq %rax, %rcx
movq 0x8a0(%rsp), %rax
movq %rcx, 0xc30(%rsp)
movq %rdx, 0xc38(%rsp)
movq 0xc30(%rsp), %rcx
movq %rcx, (%rax)
movq 0xc38(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0xd8, %rdi
callq 0x7aba0
testb $0x1, %al
jne 0x21679
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rsi
movq %rsi, %rdi
addq $0xe80, %rdi # imm = 0xE80
addq $0xd8, %rsi
callq 0x7abc0
jmp 0x21657
jmp 0x21679
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x24a70
movq 0x8a0(%rsp), %rax
movq 0x6a8(%rsp), %rcx
movq 0x16f8(%rcx), %rcx
movq 0x70(%rcx), %rdi
movups (%rax), %xmm0
movaps %xmm0, 0xc40(%rsp)
movq 0xc40(%rsp), %rsi
movq 0xc48(%rsp), %rdx
callq 0x7ac50
movq %rax, 0x440(%rsp)
jmp 0x216be
movq 0x8d8(%rsp), %rax
movq 0x440(%rsp), %rcx
movq %rcx, (%rax)
cmpq $0x0, (%rax)
je 0x21755
movq 0x8a0(%rsp), %rax
movq 0x8d8(%rsp), %rdx
movq 0x6a8(%rsp), %rcx
movq 0x16f8(%rcx), %rcx
movq 0x70(%rcx), %rdi
movq (%rdx), %rsi
movq %rcx, %rdx
addq $0xe80, %rdx # imm = 0xE80
addq $0xf48, %rcx # imm = 0xF48
movups (%rax), %xmm0
movaps %xmm0, 0xc50(%rsp)
movq 0xc50(%rsp), %r8
movq 0xc58(%rsp), %r9
callq 0x7acd0
jmp 0x21730
jmp 0x22d01
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x22eb3
movq 0x8a0(%rsp), %rax
movq 0x6a8(%rsp), %rcx
movq 0x16f8(%rcx), %rcx
movq 0x70(%rcx), %rdi
movups (%rax), %xmm0
movaps %xmm0, 0xc60(%rsp)
movq 0xc60(%rsp), %rsi
movq 0xc68(%rsp), %rdx
callq 0x7ae10
movq %rax, 0x438(%rsp)
jmp 0x2179a
movq 0x8e0(%rsp), %rax
movq 0x438(%rsp), %rcx
movq %rcx, (%rax)
cmpq $0x0, (%rax)
je 0x219f2
movq 0x8f0(%rsp), %rdi
movq 0x8f8(%rsp), %rax
movq 0x8a0(%rsp), %r9
movq 0x8e0(%rsp), %rcx
movq 0x6a8(%rsp), %rdx
movq 0x16f8(%rdx), %r8
movq 0x70(%r8), %rsi
movq (%rcx), %rdx
movq %r8, %rcx
addq $0xe80, %rcx # imm = 0xE80
addq $0xf48, %r8 # imm = 0xF48
movups (%r9), %xmm0
movups %xmm0, (%rax)
movups (%rax), %xmm0
movq %rsp, %rax
movups %xmm0, (%rax)
callq 0x7aea0
jmp 0x21815
movq 0x8f0(%rsp), %rdx
movq 0xbc0(%rsp), %rsi
movq 0x8e8(%rsp), %rdi
callq 0x729d0
jmp 0x21834
movq 0x8e8(%rsp), %rdi
callq 0x78820
testb $0x1, %al
jne 0x21955
movq 0x6a8(%rsp), %rax
movb $0x6, 0x1710(%rax)
movq 0x6a8(%rsp), %rsi
movq 0x8e8(%rsp), %rdi
callq 0x159f0
movq %rax, 0x430(%rsp)
jmp 0x21877
movq 0x430(%rsp), %rdi
movq (%rdi), %rax
addq $0xcd8, %rsp # imm = 0xCD8
jmpq *%rax
jmp 0x2188d
jmp 0x2188f
movb $0x1, %al
testb %al, %al
jne 0x21955
jmp 0x2189b
movb $0x1, %al
testb %al, %al
jne 0x24c83
jmp 0x218a7
movl $0x2, %eax
movl %eax, 0x42c(%rsp)
jmp 0x218b5
movl 0x42c(%rsp), %eax
movl %eax, 0x428(%rsp)
jmp 0x2198d
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x22cfc
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x219ed
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x219e0
movq 0x8e8(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x78840
jmp 0x219e0
movq 0x700(%rsp), %rax
movq 0x8e8(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0xa9390
jmp 0x21972
jmp 0x21974
xorl %eax, %eax
movl %eax, 0x424(%rsp)
jmp 0x2197f
movl 0x424(%rsp), %eax
movl %eax, 0x428(%rsp)
movq 0x8e8(%rsp), %rdi
movl 0x428(%rsp), %eax
movl %eax, 0x41c(%rsp)
callq 0x78840
movq 0x8f0(%rsp), %rdi
callq 0x67720
movl 0x41c(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x420(%rsp)
je 0x219db
movl 0x420(%rsp), %eax
movl %eax, 0x418(%rsp)
jmp 0x22cd7
jmp 0x22cbe
movq 0x8f0(%rsp), %rdi
callq 0x67720
jmp 0x22cfc
movq 0x918(%rsp), %rdi
movq 0x910(%rsp), %rax
movq 0x908(%rsp), %rcx
movq 0x900(%rsp), %rdx
movq 0x6a8(%rsp), %rsi
movq 0x16f8(%rsi), %rsi
movq %rsi, 0x400(%rsp)
movb $0x0, (%rdx)
movb $0x0, (%rcx)
movb $0x0, (%rax)
callq 0x55e90
movq 0x400(%rsp), %rdi
addq $0x158, %rdi # imm = 0x158
callq 0x7a340
movq %rax, 0x408(%rsp)
movq %rdx, 0x410(%rsp)
movq 0x930(%rsp), %rdi
movq 0x928(%rsp), %rax
movq 0x410(%rsp), %rcx
movq 0x408(%rsp), %rdx
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
callq 0x139e0
movq 0x920(%rsp), %rdi
movq 0x928(%rsp), %rsi
movq 0x930(%rsp), %rdx
callq 0x61ab0
jmp 0x21aa6
movq 0x930(%rsp), %rdi
callq 0x135b0
movq 0x938(%rsp), %rdi
movq 0x920(%rsp), %rsi
callq 0x54e60
jmp 0x21aca
movq 0x938(%rsp), %rdi
leaq 0xb97ba(%rip), %rsi # 0xdb293
callq 0x7b5e0
movq %rax, 0x3f8(%rsp)
jmp 0x21ae8
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0x158, %rdi # imm = 0x158
callq 0x7aac0
movq %rax, 0x3e8(%rsp)
movq %rdx, 0x3f0(%rsp)
movq 0x940(%rsp), %rsi
movq 0x3f8(%rsp), %rdi
movq 0x3f0(%rsp), %rax
movq 0x3e8(%rsp), %rcx
movq %rcx, (%rsi)
movq %rax, 0x8(%rsi)
callq 0x7b640
jmp 0x21b41
movq 0x950(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rax
movq 0x70(%rax), %rsi
callq 0x7b6a0
movq 0x950(%rsp), %rdi
callq 0x7b6d0
movq 0x948(%rsp), %rdi
movq 0x938(%rsp), %rdx
movq 0x920(%rsp), %rcx
movq %rax, %rsi
callq 0x7b6e0
jmp 0x21b90
movq 0x900(%rsp), %rsi
movq 0x958(%rsp), %rdi
movq 0x918(%rsp), %rdx
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rcx
addq $0xe80, %rcx # imm = 0xE80
callq 0x7bc40
movq 0x958(%rsp), %rdi
movq 0x948(%rsp), %rsi
callq 0x7bc80
movq 0x948(%rsp), %rdi
callq 0x7bcc0
movq 0x950(%rsp), %rdi
callq 0x536f0
movq 0x900(%rsp), %rax
testb $0x1, (%rax)
je 0x21d2e
movq 0x918(%rsp), %rdi
callq 0x55480
testb $0x1, %al
jne 0x21c19
jmp 0x21d07
movq 0x918(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdx
movq %rdx, %rsi
addq $0xe80, %rsi # imm = 0xE80
addq $0xf48, %rdx # imm = 0xF48
callq 0x7bcd0
jmp 0x21c48
jmp 0x21d29
movq 0x930(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x135b0
jmp 0x22caf
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x22ca2
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x22c95
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x22c95
movq 0x950(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x536f0
jmp 0x22c95
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0xf48, %rdi # imm = 0xF48
movl $0x194, %esi # imm = 0x194
callq 0x7bd20
jmp 0x21d29
jmp 0x22c22
movq 0x960(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rax
movq %rax, 0x3e0(%rsp)
callq 0x55ed0
movq 0x3e0(%rsp), %rax
movq 0x970(%rsp), %rdi
movq 0x70(%rax), %rsi
callq 0x7bd40
movq 0x970(%rsp), %rdi
callq 0x7b6d0
movq 0x968(%rsp), %rdi
movq 0x938(%rsp), %rdx
movq 0x920(%rsp), %rcx
movq %rax, %rsi
callq 0x7bd70
jmp 0x21d9a
movq 0x908(%rsp), %rsi
movq 0x978(%rsp), %rdi
movq 0x960(%rsp), %rdx
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rcx
addq $0xe80, %rcx # imm = 0xE80
callq 0x7c2c0
movq 0x978(%rsp), %rdi
movq 0x968(%rsp), %rsi
callq 0x7c300
movq 0x968(%rsp), %rdi
callq 0x7c340
movq 0x970(%rsp), %rdi
callq 0x536f0
movq 0x908(%rsp), %rax
testb $0x1, (%rax)
je 0x22068
movq 0x960(%rsp), %rdi
callq 0x55550
testb $0x1, %al
jne 0x21e23
jmp 0x22041
movq 0x960(%rsp), %rsi
movq 0x988(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rcx
movq %rcx, %rdx
addq $0xe80, %rdx # imm = 0xE80
addq $0xf48, %rcx # imm = 0xF48
callq 0x7c350
jmp 0x21e5a
movq 0x988(%rsp), %rdx
movq 0xbc0(%rsp), %rsi
movq 0x980(%rsp), %rdi
callq 0x729d0
jmp 0x21e79
movq 0x980(%rsp), %rdi
callq 0x78820
testb $0x1, %al
jne 0x21fa7
movq 0x6a8(%rsp), %rax
movb $0x7, 0x1710(%rax)
movq 0x6a8(%rsp), %rsi
movq 0x980(%rsp), %rdi
callq 0x15ab0
movq %rax, 0x3d8(%rsp)
jmp 0x21ebc
movq 0x3d8(%rsp), %rdi
movq (%rdi), %rax
addq $0xcd8, %rsp # imm = 0xCD8
jmpq *%rax
jmp 0x21ed2
jmp 0x21ed4
movb $0x1, %al
testb %al, %al
jne 0x21fa7
jmp 0x21ee0
movb $0x1, %al
testb %al, %al
jne 0x24c83
jmp 0x21eec
movl $0x2, %eax
movl %eax, 0x3d4(%rsp)
jmp 0x21efa
movl 0x3d4(%rsp), %eax
movl %eax, 0x3d0(%rsp)
jmp 0x21fdf
movq 0x970(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x536f0
jmp 0x22c13
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x2203c
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x2202f
movq 0x980(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x78840
jmp 0x2202f
movq 0x708(%rsp), %rax
movq 0x980(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0xa9390
jmp 0x21fc4
jmp 0x21fc6
xorl %eax, %eax
movl %eax, 0x3cc(%rsp)
jmp 0x21fd1
movl 0x3cc(%rsp), %eax
movl %eax, 0x3d0(%rsp)
movq 0x980(%rsp), %rdi
movl 0x3d0(%rsp), %eax
movl %eax, 0x3c4(%rsp)
callq 0x78840
movq 0x988(%rsp), %rdi
callq 0x67720
movl 0x3c4(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x3c8(%rsp)
je 0x2202d
movl 0x3c8(%rsp), %eax
movl %eax, 0x3c0(%rsp)
jmp 0x22bd3
jmp 0x22063
movq 0x988(%rsp), %rdi
callq 0x67720
jmp 0x22c13
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0xf48, %rdi # imm = 0xF48
movl $0x194, %esi # imm = 0x194
callq 0x7bd20
jmp 0x22063
jmp 0x22bba
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rax
movq 0x70(%rax), %rdi
callq 0x7c3c0
movq %rax, 0x3b8(%rsp)
movq 0x3b8(%rsp), %rsi
movq 0x990(%rsp), %rdi
callq 0x7c3e0
jmp 0x2209f
movq 0x990(%rsp), %rdi
callq 0x7c4e0
cmpq $0x0, %rax
je 0x22605
movq 0x998(%rsp), %rax
movq 0x990(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x7c500
movq 0x9a0(%rsp), %rcx
movq %rax, %rdx
movq 0x998(%rsp), %rax
movq %rdx, (%rcx)
movq (%rax), %rdi
callq 0x7c530
movq %rax, %rcx
movq 0x9a8(%rsp), %rax
movq %rcx, (%rax)
movq 0x9a8(%rsp), %rsi
movq 0x9a0(%rsp), %rdi
callq 0x7c560
xorb $-0x1, %al
testb $0x1, %al
jne 0x22159
movl $0x6, %eax
movl %eax, 0x3b4(%rsp)
jmp 0x22126
movl 0x3b4(%rsp), %eax
movl %eax, 0x3b0(%rsp)
jmp 0x225dd
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x22bb8
movq 0x9a0(%rsp), %rdi
callq 0x7c5a0
movq 0x9c0(%rsp), %rdi
movq %rax, %rcx
movq 0x9b0(%rsp), %rax
movq %rcx, (%rax)
callq 0x139e0
movq 0x9b8(%rsp), %rdi
movq 0x8a0(%rsp), %rsi
movq 0x9c0(%rsp), %rdx
callq 0x61ab0
jmp 0x221a0
movq 0x9c0(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rax
movq %rax, 0x398(%rsp)
callq 0x135b0
movq 0x398(%rsp), %rcx
movq 0x9b0(%rsp), %rax
addq $0xeb8, %rcx # imm = 0xEB8
movq %rcx, 0x3a0(%rsp)
movq (%rax), %rdi
callq 0x7c610
movq 0x9b8(%rsp), %rdi
movq 0x3a0(%rsp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x7c5b0
movb %al, 0x3af(%rsp)
jmp 0x2220e
movb 0x3af(%rsp), %al
testb $0x1, %al
jne 0x2221e
jmp 0x22524
movq 0x9b0(%rsp), %rax
movq (%rax), %rdi
callq 0x7c620
movq 0x9c8(%rsp), %rdi
movq %rax, %rsi
callq 0x554a0
jmp 0x22240
movq 0x9c8(%rsp), %rdi
callq 0x55550
testb $0x1, %al
jne 0x22256
jmp 0x224c6
movq 0x9c8(%rsp), %rsi
movq 0x9d8(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rcx
movq %rcx, %rdx
addq $0xe80, %rdx # imm = 0xE80
addq $0xf48, %rcx # imm = 0xF48
callq 0x7c350
jmp 0x2228d
movq 0x9d8(%rsp), %rdx
movq 0xbc0(%rsp), %rsi
movq 0x9d0(%rsp), %rdi
callq 0x729d0
jmp 0x222ac
movq 0x9d0(%rsp), %rdi
callq 0x78820
testb $0x1, %al
jne 0x2241a
movq 0x6a8(%rsp), %rax
movb $0x8, 0x1710(%rax)
movq 0x6a8(%rsp), %rsi
movq 0x9d0(%rsp), %rdi
callq 0x15b70
movq %rax, 0x390(%rsp)
jmp 0x222ef
movq 0x390(%rsp), %rdi
movq (%rdi), %rax
addq $0xcd8, %rsp # imm = 0xCD8
jmpq *%rax
jmp 0x22305
jmp 0x22307
movb $0x1, %al
testb %al, %al
jne 0x2241a
jmp 0x22313
movb $0x1, %al
testb %al, %al
jne 0x24c83
jmp 0x2231f
movl $0x2, %eax
movl %eax, 0x38c(%rsp)
jmp 0x2232d
movl 0x38c(%rsp), %eax
movl %eax, 0x388(%rsp)
jmp 0x22452
movq 0x9c0(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x135b0
jmp 0x225d8
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x225cb
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x2251f
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x224b7
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x224aa
movq 0x9d0(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x78840
jmp 0x224aa
movq 0x710(%rsp), %rax
movq 0x9d0(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0xa9390
jmp 0x22437
jmp 0x22439
xorl %eax, %eax
movl %eax, 0x384(%rsp)
jmp 0x22444
movl 0x384(%rsp), %eax
movl %eax, 0x388(%rsp)
movq 0x9d0(%rsp), %rdi
movl 0x388(%rsp), %eax
movl %eax, 0x37c(%rsp)
callq 0x78840
movq 0x9d8(%rsp), %rdi
callq 0x67720
movl 0x37c(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x380(%rsp)
je 0x2249d
movl 0x380(%rsp), %eax
movl %eax, 0x378(%rsp)
jmp 0x224df
movq 0x910(%rsp), %rax
movb $0x1, (%rax)
jmp 0x224c6
movq 0x9d8(%rsp), %rdi
callq 0x67720
movq 0x9c8(%rsp), %rdi
callq 0x397f0
jmp 0x2251f
xorl %eax, %eax
movl %eax, 0x374(%rsp)
jmp 0x224d1
movl 0x374(%rsp), %eax
movl %eax, 0x378(%rsp)
movq 0x9c8(%rsp), %rdi
movl 0x378(%rsp), %eax
movl %eax, 0x36c(%rsp)
callq 0x397f0
movl 0x36c(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x370(%rsp)
je 0x2251d
movl 0x370(%rsp), %eax
movl %eax, 0x368(%rsp)
jmp 0x2253d
jmp 0x22524
jmp 0x225cb
xorl %eax, %eax
movl %eax, 0x364(%rsp)
jmp 0x2252f
movl 0x364(%rsp), %eax
movl %eax, 0x368(%rsp)
movq 0x9b8(%rsp), %rdi
movl 0x368(%rsp), %eax
movl %eax, 0x35c(%rsp)
callq 0x358a0
movl 0x35c(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x360(%rsp)
je 0x2257b
movl 0x360(%rsp), %eax
movl %eax, 0x358(%rsp)
jmp 0x22594
xorl %eax, %eax
movl %eax, 0x354(%rsp)
jmp 0x22586
movl 0x354(%rsp), %eax
movl %eax, 0x358(%rsp)
movl 0x358(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x350(%rsp)
je 0x225b7
movl 0x350(%rsp), %eax
movl %eax, 0x3b0(%rsp)
jmp 0x225dd
jmp 0x225b9
movq 0x9a0(%rsp), %rdi
callq 0x7c630
jmp 0x220fd
movq 0x9b8(%rsp), %rdi
callq 0x358a0
jmp 0x22bab
movl 0x3b0(%rsp), %eax
cmpl $0x6, %eax
movl %eax, 0x34c(%rsp)
je 0x22603
movl 0x34c(%rsp), %eax
movl %eax, 0x348(%rsp)
jmp 0x22b6b
jmp 0x22605
movq 0x910(%rsp), %rax
testb $0x1, (%rax)
jne 0x2290c
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rax
movq 0x70(%rax), %rdi
callq 0x7c650
movq %rax, 0x340(%rsp)
movq 0x340(%rsp), %rsi
movq 0x9e0(%rsp), %rdi
callq 0x7c670
jmp 0x2264d
movq 0x9e0(%rsp), %rdi
callq 0x7c770
cmpq $0x0, %rax
je 0x228f8
movq 0x9e0(%rsp), %rax
movq %rax, 0xc70(%rsp)
movq 0xc70(%rsp), %rdi
callq 0x7c790
movq %rax, %rcx
movq 0x9e8(%rsp), %rax
movq %rcx, (%rax)
movq 0xc70(%rsp), %rdi
callq 0x7c7c0
movq %rax, %rcx
movq 0x9f0(%rsp), %rax
movq %rcx, (%rax)
movq 0x9f0(%rsp), %rsi
movq 0x9e8(%rsp), %rdi
callq 0x7c7f0
xorb $-0x1, %al
testb $0x1, %al
jne 0x226ea
jmp 0x228f6
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x22907
movq 0x9e8(%rsp), %rdi
callq 0x7c830
movq 0xa00(%rsp), %rdi
movq %rax, 0xc78(%rsp)
callq 0x139e0
movq 0x9f8(%rsp), %rdi
movq 0x8a0(%rsp), %rsi
movq 0xa00(%rsp), %rdx
callq 0x61ab0
jmp 0x2272b
movq 0xa00(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rax
movq %rax, 0x328(%rsp)
callq 0x135b0
movq 0x328(%rsp), %rax
addq $0xeb8, %rax # imm = 0xEB8
movq %rax, 0x330(%rsp)
movq 0xc78(%rsp), %rdi
callq 0x7c840
movq 0x9f8(%rsp), %rdi
movq 0x330(%rsp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x7c5b0
movb %al, 0x33f(%rsp)
jmp 0x22795
movb 0x33f(%rsp), %al
testb $0x1, %al
jne 0x227a5
jmp 0x228bb
movq 0xc78(%rsp), %rdi
callq 0x7c850
movq 0xa08(%rsp), %rdi
movq %rax, %rsi
callq 0x553d0
jmp 0x227c4
movq 0xa08(%rsp), %rdi
callq 0x55480
testb $0x1, %al
jne 0x227da
jmp 0x228aa
movq 0xa08(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdx
movq %rdx, %rsi
addq $0xe80, %rsi # imm = 0xE80
addq $0xf48, %rdx # imm = 0xF48
callq 0x7bcd0
jmp 0x22809
movq 0x910(%rsp), %rax
movb $0x1, (%rax)
jmp 0x228aa
movq 0xa00(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x135b0
jmp 0x228e7
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x228da
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x228b9
movq 0xa08(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x55cd0
jmp 0x228b9
movq 0xa08(%rsp), %rdi
callq 0x55cd0
jmp 0x228bb
jmp 0x228da
movq 0x9f8(%rsp), %rdi
callq 0x358a0
movq 0x9e8(%rsp), %rdi
callq 0x7c860
jmp 0x226aa
movq 0x9f8(%rsp), %rdi
callq 0x358a0
movq 0x9e0(%rsp), %rdi
callq 0x57dc0
jmp 0x22907
jmp 0x228f8
movq 0x9e0(%rsp), %rdi
callq 0x57dc0
jmp 0x2290c
jmp 0x22bab
movq 0x910(%rsp), %rax
testb $0x1, (%rax)
jne 0x22b52
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0x1108, %rdi # imm = 0x1108
callq 0x55550
testb $0x1, %al
jne 0x22941
jmp 0x22b2e
movq 0xa18(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rcx
movq %rcx, %rsi
addq $0x1108, %rsi # imm = 0x1108
movq %rcx, %rdx
addq $0xe80, %rdx # imm = 0xE80
addq $0xf48, %rcx # imm = 0xF48
callq 0x7c350
jmp 0x2297a
movq 0xa18(%rsp), %rdx
movq 0xbc0(%rsp), %rsi
movq 0xa10(%rsp), %rdi
callq 0x729d0
jmp 0x22999
movq 0xa10(%rsp), %rdi
callq 0x78820
testb $0x1, %al
jne 0x22a9a
movq 0x6a8(%rsp), %rax
movb $0x9, 0x1710(%rax)
movq 0x6a8(%rsp), %rsi
movq 0xa10(%rsp), %rdi
callq 0x15c30
movq %rax, 0x320(%rsp)
jmp 0x229dc
movq 0x320(%rsp), %rdi
movq (%rdi), %rax
addq $0xcd8, %rsp # imm = 0xCD8
jmpq *%rax
jmp 0x229f2
jmp 0x229f4
movb $0x1, %al
testb %al, %al
jne 0x22a9a
jmp 0x22a00
movb $0x1, %al
testb %al, %al
jne 0x24c83
jmp 0x22a0c
movl $0x2, %eax
movl %eax, 0x31c(%rsp)
jmp 0x22a1a
movl 0x31c(%rsp), %eax
movl %eax, 0x318(%rsp)
jmp 0x22ad2
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x22b2c
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x22b1f
movq 0xa10(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x78840
jmp 0x22b1f
movq 0x718(%rsp), %rax
movq 0xa10(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0xa9390
jmp 0x22ab7
jmp 0x22ab9
xorl %eax, %eax
movl %eax, 0x314(%rsp)
jmp 0x22ac4
movl 0x314(%rsp), %eax
movl %eax, 0x318(%rsp)
movq 0xa10(%rsp), %rdi
movl 0x318(%rsp), %eax
movl %eax, 0x30c(%rsp)
callq 0x78840
movq 0xa18(%rsp), %rdi
callq 0x67720
movl 0x30c(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x310(%rsp)
je 0x22b1d
movl 0x310(%rsp), %eax
movl %eax, 0x348(%rsp)
jmp 0x22b6b
jmp 0x22b50
movq 0xa18(%rsp), %rdi
callq 0x67720
jmp 0x22bab
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0xf48, %rdi # imm = 0xF48
movl $0x194, %esi # imm = 0x194
callq 0x7bd20
jmp 0x22b50
jmp 0x22b52
xorl %eax, %eax
movl %eax, 0x308(%rsp)
jmp 0x22b5d
movl 0x308(%rsp), %eax
movl %eax, 0x348(%rsp)
movq 0x990(%rsp), %rdi
movl 0x348(%rsp), %eax
movl %eax, 0x300(%rsp)
callq 0x57d60
movl 0x300(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x304(%rsp)
je 0x22ba9
movl 0x304(%rsp), %eax
movl %eax, 0x3c0(%rsp)
jmp 0x22bd3
jmp 0x22bba
movq 0x990(%rsp), %rdi
callq 0x57d60
jmp 0x22c13
xorl %eax, %eax
movl %eax, 0x2fc(%rsp)
jmp 0x22bc5
movl 0x2fc(%rsp), %eax
movl %eax, 0x3c0(%rsp)
movq 0x960(%rsp), %rdi
movl 0x3c0(%rsp), %eax
movl %eax, 0x2f4(%rsp)
callq 0x397f0
movl 0x2f4(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x2f8(%rsp)
je 0x22c11
movl 0x2f8(%rsp), %eax
movl %eax, 0x2f0(%rsp)
jmp 0x22c3b
jmp 0x22c22
movq 0x960(%rsp), %rdi
callq 0x397f0
jmp 0x22c95
xorl %eax, %eax
movl %eax, 0x2ec(%rsp)
jmp 0x22c2d
movl 0x2ec(%rsp), %eax
movl %eax, 0x2f0(%rsp)
movq 0x938(%rsp), %rdi
movl 0x2f0(%rsp), %eax
movl %eax, 0x2e4(%rsp)
callq 0x358a0
movq 0x920(%rsp), %rdi
callq 0x358a0
movq 0x918(%rsp), %rdi
callq 0x55cd0
movl 0x2e4(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x2e8(%rsp)
je 0x22c93
movl 0x2e8(%rsp), %eax
movl %eax, 0x418(%rsp)
jmp 0x22cd7
jmp 0x22cbe
movq 0x938(%rsp), %rdi
callq 0x358a0
movq 0x920(%rsp), %rdi
callq 0x358a0
movq 0x918(%rsp), %rdi
callq 0x55cd0
jmp 0x22cfc
xorl %eax, %eax
movl %eax, 0x2e0(%rsp)
jmp 0x22cc9
movl 0x2e0(%rsp), %eax
movl %eax, 0x418(%rsp)
movl 0x418(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x2dc(%rsp)
je 0x22cfa
movl 0x2dc(%rsp), %eax
movl %eax, 0x2d8(%rsp)
jmp 0x22d1a
jmp 0x22d01
jmp 0x22eb3
xorl %eax, %eax
movl %eax, 0x2d4(%rsp)
jmp 0x22d0c
movl 0x2d4(%rsp), %eax
movl %eax, 0x2d8(%rsp)
movl 0x2d8(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x2d0(%rsp)
je 0x22d40
movl 0x2d0(%rsp), %eax
movl %eax, 0x2cc(%rsp)
jmp 0x249d2
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0xf48, %rdi # imm = 0xF48
callq 0x7c880
movb %al, 0x2cb(%rsp)
movb 0x2cb(%rsp), %al
testb $0x1, %al
jne 0x248d6
jmp 0x22d73
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0x78, %rdi
callq 0x7a900
cmpq $0x0, %rax
je 0x246c8
movq 0x818(%rsp), %rax
cmpl $0x1, (%rax)
je 0x22db3
movq 0x818(%rsp), %rax
cmpl $0x3, (%rax)
jne 0x2321c
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0xf48, %rdi # imm = 0xF48
callq 0x7c890
movq %rax, 0x2b8(%rsp)
movq %rdx, 0x2c0(%rsp)
movq 0xa20(%rsp), %rdi
movq 0x2c0(%rsp), %rax
movq 0x2b8(%rsp), %rcx
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
callq 0x7c8c0
testb $0x1, %al
jne 0x22e0b
jmp 0x22f0f
movq 0xa30(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rax
addq $0xf48, %rax # imm = 0xF48
movq %rax, 0x2b0(%rsp)
callq 0x139e0
movq 0xa28(%rsp), %rdi
movq 0xa30(%rsp), %rdx
leaq 0xb85cc(%rip), %rsi # 0xdb418
callq 0x357e0
jmp 0x22e53
movq 0xa38(%rsp), %rdi
leaq 0xb5929(%rip), %rsi # 0xd878b
callq 0x793e0
movq 0xa38(%rsp), %rax
movq 0x2b0(%rsp), %rdi
movq 0xa28(%rsp), %rdx
movq (%rax), %r8
movq 0x8(%rax), %r9
movl $0x1f5, %esi # imm = 0x1F5
movl $0x3, %ecx
callq 0x79310
jmp 0x22e97
movq 0xa28(%rsp), %rdi
callq 0x358a0
movq 0xa30(%rsp), %rdi
callq 0x135b0
jmp 0x22f0f
jmp 0x24a70
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x22efd
movq 0xa28(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x358a0
movq 0xa30(%rsp), %rdi
callq 0x135b0
jmp 0x24a70
movq 0xa48(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rsi
movl $0x1, %edx
callq 0x79480
jmp 0x22f32
movq 0xa48(%rsp), %rdx
movq 0xbc0(%rsp), %rsi
movq 0xa40(%rsp), %rdi
callq 0x79440
jmp 0x22f51
movq 0xa40(%rsp), %rdi
callq 0x79fa0
testb $0x1, %al
jne 0x23052
movq 0x6a8(%rsp), %rax
movb $0xa, 0x1710(%rax)
movq 0x6a8(%rsp), %rsi
movq 0xa40(%rsp), %rdi
callq 0x15cf0
movq %rax, 0x2a8(%rsp)
jmp 0x22f94
movq 0x2a8(%rsp), %rdi
movq (%rdi), %rax
addq $0xcd8, %rsp # imm = 0xCD8
jmpq *%rax
jmp 0x22faa
jmp 0x22fac
movb $0x1, %al
testb %al, %al
jne 0x23052
jmp 0x22fb8
movb $0x1, %al
testb %al, %al
jne 0x24c83
jmp 0x22fc4
movl $0x2, %eax
movl %eax, 0x2a4(%rsp)
jmp 0x22fd2
movl 0x2a4(%rsp), %eax
movl %eax, 0x2a0(%rsp)
jmp 0x230a3
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x231a1
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x23194
movq 0xa40(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x79fc0
jmp 0x23194
movq 0x6c8(%rsp), %rax
movq 0xa40(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x8e6a0
movb %al, 0x29f(%rsp)
jmp 0x23076
jmp 0x23078
movq 0xa50(%rsp), %rax
movb 0x29f(%rsp), %cl
andb $0x1, %cl
movb %cl, (%rax)
xorl %eax, %eax
movl %eax, 0x298(%rsp)
movl 0x298(%rsp), %eax
movl %eax, 0x2a0(%rsp)
movq 0xa40(%rsp), %rdi
movl 0x2a0(%rsp), %eax
movl %eax, 0x290(%rsp)
callq 0x79fc0
movq 0xa48(%rsp), %rdi
callq 0x79fd0
movl 0x290(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x294(%rsp)
je 0x230f1
movl 0x294(%rsp), %eax
movl %eax, 0x2cc(%rsp)
jmp 0x249d2
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
movl $0x1, %esi
callq 0x6f7e0
jmp 0x2310c
movq 0xa58(%rsp), %rdi
leaq 0xb82fd(%rip), %rsi # 0xdb418
callq 0x7c8e0
movq %rax, 0x288(%rsp)
jmp 0x2312a
movq 0xa60(%rsp), %rdi
movq 0x768(%rsp), %rax
movq (%rax), %rsi
callq 0x3aee0
jmp 0x23144
movq 0xa60(%rsp), %rsi
movq 0x288(%rsp), %rdi
callq 0x5e400
jmp 0x2315b
movq 0xa60(%rsp), %rdi
callq 0x358a0
movq 0xa58(%rsp), %rdi
callq 0x5e440
movl $0x5, %eax
movl %eax, 0x284(%rsp)
movl 0x284(%rsp), %eax
movl %eax, 0x2cc(%rsp)
jmp 0x249d2
movq 0xa48(%rsp), %rdi
callq 0x79fd0
jmp 0x24a70
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x2320a
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x23208
movq 0xa60(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x358a0
jmp 0x2320a
movq 0xa58(%rsp), %rdi
callq 0x5e440
jmp 0x24a70
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0x158, %rdi # imm = 0x158
callq 0x7a340
movq %rax, 0x270(%rsp)
movq %rdx, 0x278(%rsp)
movq 0xa68(%rsp), %rdi
movq 0x278(%rsp), %rax
movq 0x270(%rsp), %rcx
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movl %eax, %esi
callq 0x7c920
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x47, %ecx
movb %al, 0x26f(%rsp)
jne 0x23290
movb 0x26f(%rsp), %al
movb %al, 0x26e(%rsp)
jmp 0x23301
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0x158, %rdi # imm = 0x158
callq 0x7a340
movq %rax, 0x258(%rsp)
movq %rdx, 0x260(%rsp)
movq 0xa70(%rsp), %rdi
movq 0x260(%rsp), %rax
movq 0x258(%rsp), %rcx
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movl %eax, %esi
callq 0x7c920
movsbl (%rax), %eax
cmpl $0x48, %eax
setne %al
movb %al, 0x257(%rsp)
movb 0x257(%rsp), %al
movb %al, 0x26e(%rsp)
movb 0x26e(%rsp), %al
testb $0x1, %al
jne 0x23311
jmp 0x23617
movq 0xa80(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rax
addq $0xf48, %rax # imm = 0xF48
movq %rax, 0x248(%rsp)
callq 0x139e0
movq 0xa78(%rsp), %rdi
movq 0xa80(%rsp), %rdx
leaq 0xb8100(%rip), %rsi # 0xdb452
callq 0x357e0
jmp 0x23359
movq 0xa88(%rsp), %rdi
leaq 0xb5423(%rip), %rsi # 0xd878b
callq 0x793e0
movq 0xa88(%rsp), %rax
movq 0x248(%rsp), %rdi
movq 0xa78(%rsp), %rdx
movq (%rax), %r8
movq 0x8(%rax), %r9
movl $0x195, %esi # imm = 0x195
movl $0x3, %ecx
callq 0x79310
jmp 0x2339d
movq 0xa78(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rax
movq %rax, 0x240(%rsp)
callq 0x358a0
movq 0xa80(%rsp), %rdi
callq 0x135b0
movq 0xa98(%rsp), %rdi
movq 0x240(%rsp), %rsi
movl $0x1, %edx
callq 0x79480
jmp 0x233ea
movq 0xa98(%rsp), %rdx
movq 0xbc0(%rsp), %rsi
movq 0xa90(%rsp), %rdi
callq 0x79440
jmp 0x23409
movq 0xa90(%rsp), %rdi
callq 0x79fa0
testb $0x1, %al
jne 0x23561
movq 0x6a8(%rsp), %rax
movb $0xb, 0x1710(%rax)
movq 0x6a8(%rsp), %rsi
movq 0xa90(%rsp), %rdi
callq 0x15db0
movq %rax, 0x238(%rsp)
jmp 0x2344c
movq 0x238(%rsp), %rdi
movq (%rdi), %rax
addq $0xcd8, %rsp # imm = 0xCD8
jmpq *%rax
jmp 0x23462
jmp 0x23464
movb $0x1, %al
testb %al, %al
jne 0x23561
jmp 0x23470
movb $0x1, %al
testb %al, %al
jne 0x24c83
jmp 0x2347c
movl $0x2, %eax
movl %eax, 0x234(%rsp)
jmp 0x2348a
movl 0x234(%rsp), %eax
movl %eax, 0x230(%rsp)
jmp 0x235b2
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x234e2
movq 0xa78(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x358a0
movq 0xa80(%rsp), %rdi
callq 0x135b0
jmp 0x24a70
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x23612
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x23605
movq 0xa90(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x79fc0
jmp 0x23605
movq 0x6d0(%rsp), %rax
movq 0xa90(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x8e6a0
movb %al, 0x22f(%rsp)
jmp 0x23585
jmp 0x23587
movq 0xaa0(%rsp), %rax
movb 0x22f(%rsp), %cl
andb $0x1, %cl
movb %cl, (%rax)
xorl %eax, %eax
movl %eax, 0x228(%rsp)
movl 0x228(%rsp), %eax
movl %eax, 0x230(%rsp)
movq 0xa90(%rsp), %rdi
movl 0x230(%rsp), %eax
movl %eax, 0x220(%rsp)
callq 0x79fc0
movq 0xa98(%rsp), %rdi
callq 0x79fd0
movl 0x220(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x224(%rsp)
je 0x23600
movl 0x224(%rsp), %eax
movl %eax, 0x2cc(%rsp)
jmp 0x249d2
jmp 0x2468f
movq 0xa98(%rsp), %rdi
callq 0x79fd0
jmp 0x24a70
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0x10a8, %rdi # imm = 0x10A8
movl $0x200, %esi # imm = 0x200
callq 0x7c950
jmp 0x23639
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rsi
movq %rsi, %rdi
addq $0xf48, %rdi # imm = 0xF48
addq $0x10a8, %rsi # imm = 0x10A8
callq 0x7ca00
jmp 0x23660
jmp 0x23662
jmp 0x23664
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
movq %rdi, 0x218(%rsp)
addq $0x78, %rdi
callq 0x7a900
movq 0x218(%rsp), %rdi
movq %rax, %rcx
movq 0xaa8(%rsp), %rax
movq %rcx, (%rax)
addq $0x78, %rdi
callq 0x78ee0
movq 0xab8(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x78ed0
movq 0xab0(%rsp), %rcx
movq 0xac0(%rsp), %rdi
movq %rax, %rdx
movq 0xaa8(%rsp), %rax
movq %rdx, (%rcx)
movq (%rcx), %rsi
movq (%rax), %rdx
callq 0x574c0
leaq 0x107371(%rip), %rdi # 0x12aa58
callq 0x56f00
movq 0xac0(%rsp), %rdi
movq %rax, 0xc80(%rsp)
movq %rdx, 0xc88(%rsp)
movq 0xc80(%rsp), %rsi
movq 0xc88(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x7ce20
movq %rax, %rcx
movq 0xac8(%rsp), %rax
movq %rcx, (%rax)
cmpq $-0x1, (%rax)
jne 0x23752
movl $0xb, %eax
movl %eax, 0x214(%rsp)
jmp 0x2373f
movl 0x214(%rsp), %eax
movl %eax, 0x210(%rsp)
jmp 0x2423b
movq 0xad0(%rsp), %rdi
callq 0x6c440
movq 0xab0(%rsp), %rcx
movq 0xaa8(%rsp), %rax
movq 0xad0(%rsp), %rdi
movq (%rcx), %rsi
movq (%rax), %rdx
xorl %ecx, %ecx
callq 0x78f70
movl %eax, 0x20c(%rsp)
jmp 0x2378d
movq 0xad8(%rsp), %rax
movl 0x20c(%rsp), %ecx
movl %ecx, (%rax)
cmpl $0x0, (%rax)
jg 0x23b64
movq 0xae0(%rsp), %rdi
leaq 0xb7be3(%rip), %rsi # 0xdb399
callq 0x792d0
jmp 0x237bd
movq 0xae0(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rax
movq %rax, 0x1f8(%rsp)
callq 0x5e440
movq 0x1f8(%rsp), %rax
movq 0xaf0(%rsp), %rdi
addq $0xf48, %rax # imm = 0xF48
movq %rax, 0x200(%rsp)
callq 0x139e0
movq 0xae8(%rsp), %rdi
movq 0xaf0(%rsp), %rdx
leaq 0xb7b96(%rip), %rsi # 0xdb3b1
callq 0x357e0
jmp 0x23822
movq 0xaf8(%rsp), %rdi
leaq 0xb4f5a(%rip), %rsi # 0xd878b
callq 0x793e0
movq 0xaf8(%rsp), %rax
movq 0x200(%rsp), %rdi
movq 0xae8(%rsp), %rdx
movq (%rax), %r8
movq 0x8(%rax), %r9
movl $0x190, %esi # imm = 0x190
movl $0x3, %ecx
callq 0x79310
jmp 0x23866
movq 0xae8(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rax
movq %rax, 0x1f0(%rsp)
callq 0x358a0
movq 0xaf0(%rsp), %rdi
callq 0x135b0
movq 0xb08(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
movl $0x1, %edx
callq 0x79480
jmp 0x238b3
movq 0xb08(%rsp), %rdx
movq 0xbc0(%rsp), %rsi
movq 0xb00(%rsp), %rdi
callq 0x79440
jmp 0x238d2
movq 0xb00(%rsp), %rdi
callq 0x79fa0
testb $0x1, %al
jne 0x23a77
movq 0x6a8(%rsp), %rax
movb $0xc, 0x1710(%rax)
movq 0x6a8(%rsp), %rsi
movq 0xb00(%rsp), %rdi
callq 0x15e70
movq %rax, 0x1e8(%rsp)
jmp 0x23915
movq 0x1e8(%rsp), %rdi
movq (%rdi), %rax
addq $0xcd8, %rsp # imm = 0xCD8
jmpq *%rax
jmp 0x2392b
jmp 0x2392d
movb $0x1, %al
testb %al, %al
jne 0x23a77
jmp 0x23939
movb $0x1, %al
testb %al, %al
jne 0x24c83
jmp 0x23945
movl $0x2, %eax
movl %eax, 0x1e4(%rsp)
jmp 0x23953
movl 0x1e4(%rsp), %eax
movl %eax, 0x1e0(%rsp)
jmp 0x23ac8
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x2429e
movq 0xae0(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x5e440
jmp 0x2429e
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x239f8
movq 0xae8(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x358a0
movq 0xaf0(%rsp), %rdi
callq 0x135b0
jmp 0x2429e
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x23b5f
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x23b52
movq 0xb00(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x79fc0
jmp 0x23b52
movq 0x6d8(%rsp), %rax
movq 0xb00(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x8e6a0
movb %al, 0x1df(%rsp)
jmp 0x23a9b
jmp 0x23a9d
movq 0xb10(%rsp), %rax
movb 0x1df(%rsp), %cl
andb $0x1, %cl
movb %cl, (%rax)
xorl %eax, %eax
movl %eax, 0x1d8(%rsp)
movl 0x1d8(%rsp), %eax
movl %eax, 0x1e0(%rsp)
movq 0xb00(%rsp), %rdi
movl 0x1e0(%rsp), %eax
movl %eax, 0x1d0(%rsp)
callq 0x79fc0
movq 0xb08(%rsp), %rdi
callq 0x79fd0
movl 0x1d0(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x1d4(%rsp)
je 0x23b16
movl 0x1d4(%rsp), %eax
movl %eax, 0x1cc(%rsp)
jmp 0x24204
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
movl $0x1, %esi
callq 0x6f7e0
jmp 0x23b31
movl $0xb, %eax
movl %eax, 0x1c8(%rsp)
jmp 0x23b3f
movl 0x1c8(%rsp), %eax
movl %eax, 0x1cc(%rsp)
jmp 0x24204
movq 0xb08(%rsp), %rdi
callq 0x79fd0
jmp 0x2429e
movq 0xac8(%rsp), %rax
movq 0x6a8(%rsp), %rcx
movq 0x16f8(%rcx), %rcx
addq $0x78, %rcx
movq %rcx, 0x1c0(%rsp)
movq (%rax), %rax
movq %rax, 0x1b8(%rsp)
leaq 0x106ebf(%rip), %rdi # 0x12aa58
callq 0x3b920
movq 0x1b8(%rsp), %rsi
movq 0x1c0(%rsp), %rdi
addq %rax, %rsi
callq 0x7a070
jmp 0x23bb8
movq 0xad0(%rsp), %rdi
callq 0x7a340
movq %rax, 0x1a8(%rsp)
movq %rdx, 0x1b0(%rsp)
movq 0xb20(%rsp), %rdi
movq 0x1b0(%rsp), %rax
movq 0x1a8(%rsp), %rcx
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
callq 0x57110
movq 0xad0(%rsp), %rdi
movq %rax, 0x190(%rsp)
callq 0x7a340
movq %rax, 0x198(%rsp)
movq %rdx, 0x1a0(%rsp)
movq 0xb28(%rsp), %rdi
movq 0x1a0(%rsp), %rax
movq 0x198(%rsp), %rcx
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
callq 0x7aab0
movq 0xad0(%rsp), %rdi
addq $0x1, %rax
movq %rax, 0x178(%rsp)
callq 0x7aac0
movq %rax, 0x180(%rsp)
movq %rdx, 0x188(%rsp)
movq 0xb30(%rsp), %rdi
movq 0x188(%rsp), %rax
movq 0x180(%rsp), %rcx
movq 0x6a8(%rsp), %rdx
movq 0x16f8(%rdx), %rdx
movq %rdx, 0x170(%rsp)
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
callq 0x7aab0
movq 0x178(%rsp), %rdx
movq 0xb18(%rsp), %rdi
movq 0x190(%rsp), %rsi
addq %rax, %rdx
callq 0x574c0
movq 0xb38(%rsp), %rdi
movq 0xad0(%rsp), %rsi
movq 0x170(%rsp), %rdx
callq 0x6c4e0
jmp 0x23ce5
movq 0xb40(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rsi
callq 0x6c5a0
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0xf48, %rdi # imm = 0xF48
callq 0x7ce90
movb %al, 0x16f(%rsp)
movq 0xb40(%rsp), %rdi
movb 0x16f(%rsp), %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x7ce60
movq 0xb18(%rsp), %rax
movq 0x6a8(%rsp), %rcx
movq 0x16f8(%rcx), %rcx
movq 0x70(%rcx), %rdi
movups (%rax), %xmm0
movaps %xmm0, 0xc90(%rsp)
movq 0xc90(%rsp), %rsi
movq 0xc98(%rsp), %rdx
callq 0x7ac50
movq %rax, 0x160(%rsp)
jmp 0x23d82
movq 0xb48(%rsp), %rax
movq 0x160(%rsp), %rcx
movq %rcx, (%rax)
cmpq $0x0, (%rax)
je 0x23e5c
movq 0xb40(%rsp), %rcx
movq 0xb38(%rsp), %rdx
movq 0x8a0(%rsp), %rax
movq 0xb48(%rsp), %rsi
movq 0x6a8(%rsp), %rdi
movq 0x16f8(%rdi), %rdi
movq 0x70(%rdi), %rdi
movq (%rsi), %rsi
movups (%rax), %xmm0
movaps %xmm0, 0xca0(%rsp)
movq 0xca0(%rsp), %r8
movq 0xca8(%rsp), %r9
callq 0x7acd0
jmp 0x23df7
jmp 0x24146
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x2429a
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x24280
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x2427e
movq 0xb18(%rsp), %rax
movq 0x6a8(%rsp), %rcx
movq 0x16f8(%rcx), %rcx
movq 0x70(%rcx), %rdi
movups (%rax), %xmm0
movaps %xmm0, 0xcb0(%rsp)
movq 0xcb0(%rsp), %rsi
movq 0xcb8(%rsp), %rdx
callq 0x7ae10
movq %rax, 0x158(%rsp)
jmp 0x23ea1
movq 0xb50(%rsp), %rax
movq 0x158(%rsp), %rcx
movq %rcx, (%rax)
cmpq $0x0, (%rax)
je 0x240ef
movq 0xb40(%rsp), %r8
movq 0xb38(%rsp), %rcx
movq 0xb60(%rsp), %rdi
movq 0xb68(%rsp), %rax
movq 0x8a0(%rsp), %r9
movq 0xb50(%rsp), %rdx
movq 0x6a8(%rsp), %rsi
movq 0x16f8(%rsi), %rsi
movq 0x70(%rsi), %rsi
movq (%rdx), %rdx
movups (%r9), %xmm0
movups %xmm0, (%rax)
movups (%rax), %xmm0
movq %rsp, %rax
movups %xmm0, (%rax)
callq 0x7aea0
jmp 0x23f1b
movq 0xb60(%rsp), %rdx
movq 0xbc0(%rsp), %rsi
movq 0xb58(%rsp), %rdi
callq 0x729d0
jmp 0x23f3a
movq 0xb58(%rsp), %rdi
callq 0x78820
testb $0x1, %al
jne 0x2405b
movq 0x6a8(%rsp), %rax
movb $0xd, 0x1710(%rax)
movq 0x6a8(%rsp), %rsi
movq 0xb58(%rsp), %rdi
callq 0x15f30
movq %rax, 0x150(%rsp)
jmp 0x23f7d
movq 0x150(%rsp), %rdi
movq (%rdi), %rax
addq $0xcd8, %rsp # imm = 0xCD8
jmpq *%rax
jmp 0x23f93
jmp 0x23f95
movb $0x1, %al
testb %al, %al
jne 0x2405b
jmp 0x23fa1
movb $0x1, %al
testb %al, %al
jne 0x24c83
jmp 0x23fad
movl $0x2, %eax
movl %eax, 0x14c(%rsp)
jmp 0x23fbb
movl 0x14c(%rsp), %eax
movl %eax, 0x148(%rsp)
jmp 0x24093
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x24141
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x240ed
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x240e0
movq 0xb58(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x78840
jmp 0x240e0
movq 0x720(%rsp), %rax
movq 0xb58(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0xa9390
jmp 0x24078
jmp 0x2407a
xorl %eax, %eax
movl %eax, 0x144(%rsp)
jmp 0x24085
movl 0x144(%rsp), %eax
movl %eax, 0x148(%rsp)
movq 0xb58(%rsp), %rdi
movl 0x148(%rsp), %eax
movl %eax, 0x13c(%rsp)
callq 0x78840
movq 0xb60(%rsp), %rdi
callq 0x67720
movl 0x13c(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x140(%rsp)
je 0x240de
movl 0x140(%rsp), %eax
movl %eax, 0x138(%rsp)
jmp 0x2411c
jmp 0x24103
movq 0xb60(%rsp), %rdi
callq 0x67720
jmp 0x24141
movq 0xb40(%rsp), %rdi
movl $0x194, %esi # imm = 0x194
callq 0x7bd20
jmp 0x24103
xorl %eax, %eax
movl %eax, 0x134(%rsp)
jmp 0x2410e
movl 0x134(%rsp), %eax
movl %eax, 0x138(%rsp)
movl 0x138(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x130(%rsp)
je 0x2413f
movl 0x130(%rsp), %eax
movl %eax, 0x12c(%rsp)
jmp 0x2415f
jmp 0x24146
jmp 0x2427e
xorl %eax, %eax
movl %eax, 0x128(%rsp)
jmp 0x24151
movl 0x128(%rsp), %eax
movl %eax, 0x12c(%rsp)
movl 0x12c(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x124(%rsp)
je 0x24182
movl 0x124(%rsp), %eax
movl %eax, 0x120(%rsp)
jmp 0x241c0
movq 0xb40(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rsi
addq $0x10a8, %rsi # imm = 0x10A8
callq 0x7ca00
jmp 0x241a7
xorl %eax, %eax
movl %eax, 0x11c(%rsp)
jmp 0x241b2
movl 0x11c(%rsp), %eax
movl %eax, 0x120(%rsp)
movq 0xb40(%rsp), %rdi
movl 0x120(%rsp), %eax
movl %eax, 0x114(%rsp)
callq 0x6c8c0
movq 0xb38(%rsp), %rdi
callq 0x6c920
movl 0x114(%rsp), %eax
movl %eax, 0x118(%rsp)
movl 0x118(%rsp), %eax
movl %eax, 0x1cc(%rsp)
movq 0xad0(%rsp), %rdi
movl 0x1cc(%rsp), %eax
movl %eax, 0x10c(%rsp)
callq 0x6c980
movl 0x10c(%rsp), %eax
movl %eax, 0x110(%rsp)
movl 0x110(%rsp), %eax
movl %eax, 0x210(%rsp)
movl 0x210(%rsp), %eax
movl %eax, 0x108(%rsp)
testl %eax, %eax
je 0x24279
jmp 0x2424f
movl 0x108(%rsp), %eax
movl %eax, %ecx
subl $0xb, %ecx
movl %eax, 0x104(%rsp)
je 0x242b0
jmp 0x24266
movl 0x104(%rsp), %eax
movl %eax, 0x2cc(%rsp)
jmp 0x249d2
jmp 0x23662
jmp 0x24280
movq 0xb40(%rsp), %rdi
callq 0x6c8c0
movq 0xb38(%rsp), %rdi
callq 0x6c920
jmp 0x2429c
jmp 0x2429e
movq 0xad0(%rsp), %rdi
callq 0x6c980
jmp 0x24a70
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
movq 0x16f8(%rax), %rax
movq %rax, 0xf8(%rsp)
addq $0x10a8, %rdi # imm = 0x10A8
callq 0x7cf10
movq 0xb80(%rsp), %rdi
movq 0xf8(%rsp), %rsi
movq %rax, %rcx
movq %rdx, %rax
movq 0xb88(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
callq 0x7ceb0
movq 0xb80(%rsp), %rdx
movq 0xbc0(%rsp), %rsi
movq 0xb78(%rsp), %rdi
callq 0x78d40
jmp 0x24323
movq 0xb78(%rsp), %rdi
callq 0x78e10
testb $0x1, %al
jne 0x24400
movq 0x6a8(%rsp), %rax
movb $0xe, 0x1710(%rax)
movq 0x6a8(%rsp), %rsi
movq 0xb78(%rsp), %rdi
callq 0x15ff0
movq %rax, 0xf0(%rsp)
jmp 0x24366
movq 0xf0(%rsp), %rdi
movq (%rdi), %rax
addq $0xcd8, %rsp # imm = 0xCD8
jmpq *%rax
jmp 0x2437c
jmp 0x2437e
movb $0x1, %al
testb %al, %al
jne 0x24400
jmp 0x24386
movb $0x1, %al
testb %al, %al
jne 0x24c83
jmp 0x24392
movl $0x2, %eax
movl %eax, 0xec(%rsp)
jmp 0x243a0
movl 0xec(%rsp), %eax
movl %eax, 0xe8(%rsp)
jmp 0x24440
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x2458b
movq 0xb78(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x78e30
jmp 0x2458b
movq 0xb70(%rsp), %rdi
movq 0x6f8(%rsp), %rax
movq 0xb78(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rsi
callq 0x81a30
jmp 0x24425
jmp 0x24427
xorl %eax, %eax
movl %eax, 0xe4(%rsp)
jmp 0x24432
movl 0xe4(%rsp), %eax
movl %eax, 0xe8(%rsp)
movq 0xb78(%rsp), %rdi
movl 0xe8(%rsp), %eax
movl %eax, 0xdc(%rsp)
callq 0x78e30
movq 0xb80(%rsp), %rdi
callq 0x78e40
movl 0xdc(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0xe0(%rsp)
je 0x2448e
movl 0xe0(%rsp), %eax
movl %eax, 0xd8(%rsp)
jmp 0x24662
movq 0xb70(%rsp), %rdi
callq 0x78e50
movq 0xb70(%rsp), %rdi
movq %rax, 0xcc0(%rsp)
callq 0x78e60
movq %rax, 0xcc8(%rsp)
movq 0xcc0(%rsp), %rdi
callq 0x3ac70
testb $0x1, %al
jne 0x244ce
jmp 0x2462d
movq 0xb90(%rsp), %rdi
leaq 0xb6f88(%rip), %rsi # 0xdb465
callq 0x7cf80
movq %rax, 0xd0(%rsp)
jmp 0x244ec
movq 0xb98(%rsp), %rdi
movq 0xcc0(%rsp), %rsi
callq 0x3aee0
jmp 0x24503
movq 0xb98(%rsp), %rsi
movq 0xd0(%rsp), %rdi
callq 0x5e400
jmp 0x2451a
movq 0xb98(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rax
movq %rax, 0xc8(%rsp)
callq 0x358a0
movq 0xb90(%rsp), %rdi
callq 0x5e440
movq 0xc8(%rsp), %rdi
movl $0x1, %esi
callq 0x6f7e0
jmp 0x2455f
movq 0xbc0(%rsp), %rdi
callq 0x78850
movl $0x3, %eax
movl %eax, 0xc4(%rsp)
movl 0xc4(%rsp), %eax
movl %eax, 0xc0(%rsp)
jmp 0x24646
movq 0xb80(%rsp), %rdi
callq 0x78e40
jmp 0x2468a
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x24601
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x245ff
movq 0xb98(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x358a0
jmp 0x24601
movq 0xb90(%rsp), %rdi
callq 0x5e440
jmp 0x2468a
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x2468a
xorl %eax, %eax
movl %eax, 0xbc(%rsp)
jmp 0x24638
movl 0xbc(%rsp), %eax
movl %eax, 0xc0(%rsp)
movl 0xc0(%rsp), %eax
movl %eax, 0xb8(%rsp)
movl 0xb8(%rsp), %eax
movl %eax, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0xb4(%rsp)
je 0x24688
movl 0xb4(%rsp), %eax
movl %eax, 0x2cc(%rsp)
jmp 0x249d2
jmp 0x2468f
jmp 0x24a70
jmp 0x24691
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0x78, %rdi
movq %rdi, 0xa8(%rsp)
callq 0x7a900
movq 0xa8(%rsp), %rdi
movq %rax, %rsi
callq 0x7a070
jmp 0x246c3
jmp 0x248d4
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
callq 0x7cfc0
jmp 0x246de
movq 0xba8(%rsp), %rdi
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rsi
movl $0x1, %edx
callq 0x79480
jmp 0x24701
movq 0xba8(%rsp), %rdx
movq 0xbc0(%rsp), %rsi
movq 0xba0(%rsp), %rdi
callq 0x79440
jmp 0x24720
movq 0xba0(%rsp), %rdi
callq 0x79fa0
testb $0x1, %al
jne 0x24821
movq 0x6a8(%rsp), %rax
movb $0xf, 0x1710(%rax)
movq 0x6a8(%rsp), %rsi
movq 0xba0(%rsp), %rdi
callq 0x160b0
movq %rax, 0xa0(%rsp)
jmp 0x24763
movq 0xa0(%rsp), %rdi
movq (%rdi), %rax
addq $0xcd8, %rsp # imm = 0xCD8
jmpq *%rax
jmp 0x24779
jmp 0x2477b
movb $0x1, %al
testb %al, %al
jne 0x24821
jmp 0x24787
movb $0x1, %al
testb %al, %al
jne 0x24c83
jmp 0x24793
movl $0x2, %eax
movl %eax, 0x9c(%rsp)
jmp 0x247a1
movl 0x9c(%rsp), %eax
movl %eax, 0x98(%rsp)
jmp 0x24872
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x248cf
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x248c2
movq 0xba0(%rsp), %rdi
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x79fc0
jmp 0x248c2
movq 0x6e0(%rsp), %rax
movq 0xba0(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x8e6a0
movb %al, 0x97(%rsp)
jmp 0x24845
jmp 0x24847
movq 0xbb0(%rsp), %rax
movb 0x97(%rsp), %cl
andb $0x1, %cl
movb %cl, (%rax)
xorl %eax, %eax
movl %eax, 0x90(%rsp)
movl 0x90(%rsp), %eax
movl %eax, 0x98(%rsp)
movq 0xba0(%rsp), %rdi
movl 0x98(%rsp), %eax
movl %eax, 0x88(%rsp)
callq 0x79fc0
movq 0xba8(%rsp), %rdi
callq 0x79fd0
movl 0x88(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x8c(%rsp)
je 0x248c0
movl 0x8c(%rsp), %eax
movl %eax, 0x2cc(%rsp)
jmp 0x249d2
jmp 0x248d4
movq 0xba8(%rsp), %rdi
callq 0x79fd0
jmp 0x24a70
jmp 0x248d6
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rax
testb $0x1, 0xe78(%rax)
jne 0x2490b
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
movl $0x1, %esi
callq 0x6f7e0
jmp 0x24909
jmp 0x2490b
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0xf48, %rdi # imm = 0xF48
callq 0x7d110
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0xe80, %rdi # imm = 0xE80
callq 0x7d1b0
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
movq %rdi, 0x80(%rsp)
addq $0x1048, %rdi # imm = 0x1048
callq 0x7d240
movq 0x80(%rsp), %rdi
addq $0xd8, %rdi
callq 0x57a30
movq 0x80(%rsp), %rdi
addq $0x10a8, %rdi # imm = 0x10A8
callq 0x57a30
movq 0x80(%rsp), %rax
movb $0x1, 0x1101(%rax)
testb $0x1, 0x1100(%rax)
je 0x249bf
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0xd8, %rdi
callq 0x7d260
xorl %eax, %eax
movl %eax, 0x7c(%rsp)
jmp 0x249c7
movl 0x7c(%rsp), %eax
movl %eax, 0x2cc(%rsp)
movq 0x8c0(%rsp), %rdi
movl 0x2cc(%rsp), %eax
movl %eax, 0x74(%rsp)
callq 0x358a0
movl 0x74(%rsp), %eax
movl %eax, 0x78(%rsp)
movl 0x78(%rsp), %eax
movl %eax, 0x4b0(%rsp)
movl 0x4b0(%rsp), %eax
movl %eax, 0x70(%rsp)
movl 0x70(%rsp), %eax
movl %eax, 0x5fc(%rsp)
movl 0x5fc(%rsp), %eax
movl %eax, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
movl %eax, 0x648(%rsp)
movl 0x648(%rsp), %eax
movl %eax, 0x68(%rsp)
movl 0x68(%rsp), %eax
movl %eax, 0x660(%rsp)
movl 0x660(%rsp), %eax
movl %eax, 0x64(%rsp)
testl %eax, %eax
je 0x24a6b
jmp 0x24a50
movl 0x64(%rsp), %eax
movl %eax, %ecx
subl $0x5, %ecx
movl %eax, 0x60(%rsp)
je 0x24a8a
jmp 0x24a61
movl 0x60(%rsp), %eax
movl %eax, 0x5c(%rsp)
jmp 0x24ae6
jmp 0x1fbe4
movq 0x8c0(%rsp), %rdi
callq 0x358a0
jmp 0x24a7f
jmp 0x24a81
jmp 0x24a83
jmp 0x24a85
jmp 0x24b24
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0x78, %rdi
callq 0x7a900
cmpq $0x0, %rax
je 0x24ad6
movq 0x6a8(%rsp), %rax
movq 0x16f8(%rax), %rdi
addq $0x78, %rdi
movq %rdi, 0x50(%rsp)
callq 0x7a900
movq 0x50(%rsp), %rdi
movq %rax, %rsi
callq 0x7a070
jmp 0x24ad4
jmp 0x24ad6
xorl %eax, %eax
movl %eax, 0x4c(%rsp)
jmp 0x24ade
movl 0x4c(%rsp), %eax
movl %eax, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
movl %eax, 0x48(%rsp)
testl %eax, %eax
je 0x24b15
jmp 0x24af4
movl 0x48(%rsp), %eax
movl %eax, %ecx
subl $0x3, %ecx
movl %eax, 0x44(%rsp)
je 0x24b50
jmp 0x24b05
movl 0x44(%rsp), %eax
movl %eax, 0x694(%rsp)
jmp 0x24c3d
movq 0xbc0(%rsp), %rdi
callq 0x78850
jmp 0x24b50
jmp 0x24b26
jmp 0x24b28
movq 0x738(%rsp), %rax
movq (%rax), %rdi
callq 0x13230
movq 0xbc0(%rsp), %rdi
callq 0x78860
callq 0x138d0
jmp 0x24b4c
jmp 0x24b4e
jmp 0x24b50
movq 0xbc0(%rsp), %rdi
callq 0x67790
movq 0xbb8(%rsp), %rdi
callq 0x677a0
testb $0x1, %al
jne 0x24bf5
movq 0x6a8(%rsp), %rax
movq $0x0, (%rax)
movb $0x10, 0x1710(%rax)
movq 0x6a8(%rsp), %rsi
movq 0xbb8(%rsp), %rdi
callq 0x16170
movq %rax, 0x38(%rsp)
jmp 0x24ba4
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
addq $0xcd8, %rsp # imm = 0xCD8
jmpq *%rax
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x24c8d
movq %rdx, %rcx
movq 0x738(%rsp), %rdx
movq %rax, %rsi
movq 0x740(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x24c8d
movq 0xbb8(%rsp), %rdi
callq 0x677f0
xorl %eax, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x2c(%rsp)
je 0x24c2a
movl 0x2c(%rsp), %eax
movl %eax, 0x694(%rsp)
jmp 0x24c3d
xorl %eax, %eax
movl %eax, 0x28(%rsp)
jmp 0x24c32
movl 0x28(%rsp), %eax
movl %eax, 0x694(%rsp)
movq 0xbc0(%rsp), %rdi
movl 0x694(%rsp), %eax
movl %eax, 0x24(%rsp)
callq 0x788d0
movq 0x6a8(%rsp), %rax
cmpq $0x0, %rax
je 0x24c75
movq 0x6a8(%rsp), %rdi
movl $0x1730, %esi # imm = 0x1730
callq 0x13570
movl 0x24(%rsp), %eax
testl %eax, %eax
je 0x24c81
jmp 0x24c7f
jmp 0x24c83
jmp 0x24c83
jmp 0x24c85
addq $0xcd8, %rsp # imm = 0xCD8
retq
jmp 0x24c8f
movq 0x6a8(%rsp), %rax
movq $0x0, (%rax)
movb $0x10, 0x1710(%rax)
jmp 0x24ca7
movq 0x738(%rsp), %rax
movq (%rax), %rdi
callq 0x139b0
movq 0x6a8(%rsp), %rax
movzbl 0x1710(%rax), %eax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
leaq 0xb36f9(%rip), %rcx # 0xd83d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
|
/qicosmos[P]cinatra/include/cinatra/coro_http_connection.hpp
|
cinatra::coro_http_server::start_one(std::shared_ptr<cinatra::coro_http_connection>) (.destroy)
|
async_simple::coro::Lazy<void> start_one(
std::shared_ptr<coro_http_connection> conn) noexcept {
co_await conn->start();
}
|
subq $0xd8, %rsp
movq %rdi, 0x68(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rdi, %rax
addq $0x40, %rax
movq %rax, 0x70(%rsp)
movq %rdi, %rax
addq $0x30, %rax
movq %rax, 0x78(%rsp)
movq %rdi, %rax
addq $0x59, %rax
movq %rax, 0x80(%rsp)
movq %rdi, %rax
addq $0x48, %rax
movq %rax, 0x88(%rsp)
movq %rdi, %rax
addq $0x50, %rax
movq %rax, 0x90(%rsp)
movq %rdi, %rax
addq $0x5a, %rax
movq %rax, 0x98(%rsp)
addq $0x10, %rdi
movq %rdi, 0xa0(%rsp)
jmp 0x30d7a
jmp 0x30a4b
jmp 0x30a4d
xorl %eax, %eax
testb %al, %al
jne 0x30a76
jmp 0x30a55
xorl %eax, %eax
testb %al, %al
jne 0x30d68
jmp 0x30a61
movl $0x2, %eax
movl %eax, 0x64(%rsp)
jmp 0x30a6c
movl 0x64(%rsp), %eax
movl %eax, 0x60(%rsp)
jmp 0x30a91
movq 0x80(%rsp), %rdi
callq 0x66750
xorl %eax, %eax
movl %eax, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
movl %eax, 0x60(%rsp)
movl 0x60(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x58(%rsp)
je 0x30aab
movl 0x58(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0x30d21
movq 0x78(%rsp), %rdi
callq 0x66e30
movq 0x90(%rsp), %rdi
movq %rax, %rsi
callq 0x72a10
jmp 0x30ac7
movq 0x90(%rsp), %rdx
movq 0xa0(%rsp), %rsi
movq 0x88(%rsp), %rdi
callq 0x729d0
jmp 0x30ae6
movq 0x88(%rsp), %rdi
callq 0x78820
testb $0x1, %al
jne 0x30bb3
movq 0x68(%rsp), %rax
movb $0x1, 0x58(%rax)
movq 0x68(%rsp), %rsi
movq 0x88(%rsp), %rdi
callq 0x151f0
movq %rax, 0x48(%rsp)
jmp 0x30b1d
movq 0x48(%rsp), %rdi
movq (%rdi), %rax
addq $0xd8, %rsp
jmpq *%rax
jmp 0x30b30
jmp 0x30b32
xorl %eax, %eax
testb %al, %al
jne 0x30bb3
jmp 0x30b3a
xorl %eax, %eax
testb %al, %al
jne 0x30d68
jmp 0x30b46
movl $0x2, %eax
movl %eax, 0x44(%rsp)
jmp 0x30b51
movl 0x44(%rsp), %eax
movl %eax, 0x40(%rsp)
jmp 0x30bdf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x30c37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x30c2a
movq 0x88(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xcc(%rsp)
callq 0x78840
jmp 0x30c2a
movq 0x70(%rsp), %rax
movq 0x88(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0xa9390
jmp 0x30bcd
jmp 0x30bcf
xorl %eax, %eax
movl %eax, 0x3c(%rsp)
jmp 0x30bd7
movl 0x3c(%rsp), %eax
movl %eax, 0x40(%rsp)
movq 0x88(%rsp), %rdi
movl 0x40(%rsp), %eax
movl %eax, 0x34(%rsp)
callq 0x78840
movq 0x90(%rsp), %rdi
callq 0x67720
movl 0x34(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x38(%rsp)
je 0x30c1b
movl 0x38(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0x30d21
movq 0xa0(%rsp), %rdi
callq 0x78850
jmp 0x30c5e
movq 0x90(%rsp), %rdi
callq 0x67720
jmp 0x30c39
movq 0xc0(%rsp), %rdi
callq 0x13230
movq 0xa0(%rsp), %rdi
callq 0x78860
callq 0x138d0
jmp 0x30c5a
jmp 0x30c5c
jmp 0x30c5e
movq 0xa0(%rsp), %rdi
callq 0x67790
movq 0x98(%rsp), %rdi
callq 0x677a0
testb $0x1, %al
jne 0x30cdf
movq 0x68(%rsp), %rax
movq $0x0, (%rax)
movq 0x68(%rsp), %rsi
movq 0x98(%rsp), %rdi
callq 0x152b0
movq %rax, 0x28(%rsp)
jmp 0x30ca1
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
addq $0xd8, %rsp
jmpq *%rax
jmp 0x30cb4
jmp 0x30cb6
xorl %eax, %eax
testb %al, %al
jne 0x30cdf
jmp 0x30cbe
xorl %eax, %eax
testb %al, %al
jne 0x30d68
jmp 0x30cca
movl $0x2, %eax
movl %eax, 0x24(%rsp)
jmp 0x30cd5
movl 0x24(%rsp), %eax
movl %eax, 0x20(%rsp)
jmp 0x30cfa
movq 0x98(%rsp), %rdi
callq 0x677f0
xorl %eax, %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x18(%rsp)
je 0x30d11
movl 0x18(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0x30d21
xorl %eax, %eax
movl %eax, 0x14(%rsp)
jmp 0x30d19
movl 0x14(%rsp), %eax
movl %eax, 0x54(%rsp)
movq 0xa0(%rsp), %rdi
movl 0x54(%rsp), %eax
movl %eax, 0x10(%rsp)
callq 0x788d0
movq 0x78(%rsp), %rdi
callq 0x58740
movq 0x68(%rsp), %rax
cmpq $0x0, %rax
je 0x30d5a
movq 0x68(%rsp), %rdi
movl $0x60, %esi
callq 0x13570
movl 0x10(%rsp), %eax
testl %eax, %eax
je 0x30d66
jmp 0x30d64
jmp 0x30d68
jmp 0x30d68
jmp 0x30d6a
addq $0xd8, %rsp
retq
movq %rax, %rdi
callq 0x382b0
movq 0x68(%rsp), %rax
movb 0x58(%rax), %cl
movb %cl, 0xf(%rsp)
cmpq $0x0, (%rax)
je 0x30cb2
movb 0xf(%rsp), %al
testb $0x3, %al
je 0x30a49
jmp 0x30d9e
jmp 0x30b2e
nopw %cs:(%rax,%rax)
|
/qicosmos[P]cinatra/include/cinatra/coro_http_server.hpp
|
asio::detail::posix_thread::posix_thread<asio::detail::scheduler::thread_function>(asio::detail::scheduler::thread_function, unsigned int)
|
posix_thread(Function f, unsigned int = 0)
: joined_(false)
{
start_thread(new func<Function>(f));
}
|
subq $0x48, %rsp
movq %rsi, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3aae0
movq 0x8(%rsp), %rax
movb $0x0, 0x8(%rax)
movl $0x10, %edi
callq 0x13560
movq %rax, 0x10(%rsp)
jmp 0x3e7cb
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
callq 0x3ed50
jmp 0x3e7e6
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x3ecc0
jmp 0x3e7f7
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x3e829
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x10, %esi
callq 0x13570
movq 0x8(%rsp), %rdi
callq 0x3ab60
movq 0x28(%rsp), %rdi
callq 0x139b0
nopl (%rax)
|
/qicosmos[P]cinatra/include/asio/detail/posix_thread.hpp
|
asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock, asio::wait_traits<std::chrono::_V2::steady_clock>>>::cancel(asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock, asio::wait_traits<std::chrono::_V2::steady_clock>>>::implementation_type&, std::error_code&)
|
std::size_t cancel(implementation_type& impl, asio::error_code& ec)
{
if (!impl.might_have_pending_waits)
{
ec = asio::error_code();
return 0;
}
ASIO_HANDLER_OPERATION((scheduler_.context(),
"deadline_timer", &impl, 0, "cancel"));
std::size_t count = scheduler_.cancel_timer(timer_queue_, impl.timer_data);
impl.might_have_pending_waits = false;
ec = asio::error_code();
return count;
}
|
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rax
testb $0x1, 0x8(%rax)
jne 0x46a33
leaq 0x38(%rsp), %rdi
callq 0x38f80
movq 0x48(%rsp), %rax
movq 0x38(%rsp), %rcx
movq %rcx, (%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x60(%rsp)
jmp 0x46aaa
movq 0x18(%rsp), %rax
movq 0x58(%rax), %rcx
movq %rcx, (%rsp)
addq $0x28, %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
callq 0x3f540
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
callq 0x46ac0
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rax
movb $0x0, 0x8(%rax)
leaq 0x20(%rsp), %rdi
callq 0x38f80
movq 0x48(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nop
|
/qicosmos[P]cinatra/include/asio/detail/deadline_timer_service.hpp
|
void asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock, asio::wait_traits<std::chrono::_V2::steady_clock>>>::async_wait<coro_io::ExecutorWrapper<asio::io_context::basic_executor_type<std::allocator<void>, 0ul>>::schedule(std::function<void ()>, std::chrono::duration<long, std::ratio<1l, 1000000l>>)::'lambda'(auto), asio::any_io_executor>(asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock, asio::wait_traits<std::chrono::_V2::steady_clock>>>::implementation_type&, auto&, asio::any_io_executor const&)
|
void async_wait(implementation_type& impl,
Handler& handler, const IoExecutor& io_ex)
{
typename associated_cancellation_slot<Handler>::type slot
= asio::get_associated_cancellation_slot(handler);
// Allocate and construct an operation to wrap the handler.
typedef wait_handler<Handler, IoExecutor> op;
typename op::ptr p = { asio::detail::addressof(handler),
op::ptr::allocate(handler), 0 };
p.p = new (p.v) op(handler, io_ex);
// Optionally register for per-operation cancellation.
if (slot.is_connected())
{
p.p->cancellation_key_ =
&slot.template emplace<op_cancellation>(this, &impl.timer_data);
}
impl.might_have_pending_waits = true;
ASIO_HANDLER_CREATION((scheduler_.context(),
*p.p, "deadline_timer", &impl, 0, "async_wait"));
scheduler_.schedule_timer(timer_queue_, impl.expiry, impl.timer_data, p.p);
p.v = p.p = 0;
}
|
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
callq 0x47380
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rdi
callq 0x473d0
movq %rax, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x47430
jmp 0x4729e
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x47490
testb $0x1, %al
jne 0x472b8
jmp 0x47313
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x68(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x474b0
movq %rax, (%rsp)
jmp 0x472ea
movq (%rsp), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x28(%rax)
jmp 0x47313
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x47660
jmp 0x47362
movq 0x8(%rsp), %rsi
movq 0x68(%rsp), %rax
movb $0x1, 0x8(%rax)
movq 0x58(%rsi), %rdi
addq $0x28, %rsi
movq 0x68(%rsp), %rdx
movq %rdx, %rcx
addq $0x10, %rcx
movq 0x48(%rsp), %r8
callq 0x47570
jmp 0x47341
movq $0x0, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x47660
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x139b0
nopl (%rax)
|
/qicosmos[P]cinatra/include/asio/detail/deadline_timer_service.hpp
|
asio::execution::any_executor<asio::execution::context_as_t<asio::execution_context&>, asio::execution::detail::blocking::never_t<0>, asio::execution::prefer_only<asio::execution::detail::blocking::possibly_t<0>>, asio::execution::prefer_only<asio::execution::detail::outstanding_work::tracked_t<0>>, asio::execution::prefer_only<asio::execution::detail::outstanding_work::untracked_t<0>>, asio::execution::prefer_only<asio::execution::detail::relationship::fork_t<0>>, asio::execution::prefer_only<asio::execution::detail::relationship::continuation_t<0>>>::any_executor(asio::execution::any_executor<asio::execution::context_as_t<asio::execution_context&>, asio::execution::detail::blocking::never_t<0>, asio::execution::prefer_only<asio::execution::detail::blocking::possibly_t<0>>, asio::execution::prefer_only<asio::execution::detail::outstanding_work::tracked_t<0>>, asio::execution::prefer_only<asio::execution::detail::outstanding_work::untracked_t<0>>, asio::execution::prefer_only<asio::execution::detail::relationship::fork_t<0>>, asio::execution::prefer_only<asio::execution::detail::relationship::continuation_t<0>>>&&)
|
any_executor(any_executor&& other) ASIO_NOEXCEPT
: detail::any_executor_base(
static_cast<any_executor_base&&>(
static_cast<any_executor_base&>(other))),
prop_fns_(other.prop_fns_)
{
other.prop_fns_ = prop_fns_table<void>();
}
|
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x47ce0
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x30(%rcx), %rcx
movq %rcx, 0x30(%rax)
callq 0x47d80
movq %rax, 0x10(%rsp)
jmp 0x47cc0
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x30(%rax)
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x382b0
nopl (%rax,%rax)
|
/qicosmos[P]cinatra/include/asio/execution/any_executor.hpp
|
asio::execution::detail::any_executor_base::target_fns const* asio::execution::detail::any_executor_base::target_fns_table<void>(std::enable_if<is_same<void, void>::value, void>::type*)
|
static const target_fns* target_fns_table(
typename enable_if<
is_same<Ex, void>::value
>::type* = 0)
{
static const target_fns fns =
{
&any_executor_base::target_type_void,
&any_executor_base::equal_void,
&any_executor_base::execute_void,
&any_executor_base::blocking_execute_void
};
return &fns;
}
|
movq %rdi, -0x8(%rsp)
leaq 0xe0f04(%rip), %rax # 0x128cb0
retq
nopl (%rax)
|
/qicosmos[P]cinatra/include/asio/execution/any_executor.hpp
|
void asio::detail::thread_info_base::deallocate<asio::detail::thread_info_base::executor_function_tag>(asio::detail::thread_info_base::executor_function_tag, asio::detail::thread_info_base*, void*, unsigned long)
|
static void deallocate(Purpose, thread_info_base* this_thread,
void* pointer, std::size_t size)
{
if (size <= chunk_size * UCHAR_MAX)
{
if (this_thread)
{
for (int mem_index = Purpose::begin_mem_index;
mem_index < Purpose::end_mem_index; ++mem_index)
{
if (this_thread->reusable_memory_[mem_index] == 0)
{
unsigned char* const mem = static_cast<unsigned char*>(pointer);
mem[0] = mem[size];
this_thread->reusable_memory_[mem_index] = pointer;
return;
}
}
}
}
aligned_delete(pointer);
}
|
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x3fc, 0x18(%rsp) # imm = 0x3FC
ja 0x4996c
cmpq $0x0, 0x28(%rsp)
je 0x4996a
movl $0x4, 0x14(%rsp)
cmpl $0x6, 0x14(%rsp)
jge 0x49968
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x49959
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movb (%rax,%rcx), %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x49976
jmp 0x4995b
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4990e
jmp 0x4996a
jmp 0x4996c
movq 0x20(%rsp), %rdi
callq 0x3f810
addq $0x38, %rsp
retq
nopl (%rax,%rax)
|
/qicosmos[P]cinatra/include/asio/detail/thread_info_base.hpp
|
void asio::io_context::basic_executor_type<std::allocator<void>, 0ul>::execute<asio::detail::executor_function>(asio::detail::executor_function&&) const
|
void io_context::basic_executor_type<Allocator, Bits>::execute(
ASIO_MOVE_ARG(Function) f) const
{
typedef typename decay<Function>::type function_type;
// Invoke immediately if the blocking.possibly property is enabled and we are
// already inside the thread pool.
if ((bits() & blocking_never) == 0 && context_ptr()->impl_.can_dispatch())
{
// Make a local, non-const copy of the function.
function_type tmp(ASIO_MOVE_CAST(Function)(f));
#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
&& !defined(ASIO_NO_EXCEPTIONS)
try
{
#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
// && !defined(ASIO_NO_EXCEPTIONS)
detail::fenced_block b(detail::fenced_block::full);
asio_handler_invoke_helpers::invoke(tmp, tmp);
return;
#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
&& !defined(ASIO_NO_EXCEPTIONS)
}
catch (...)
{
context_ptr()->impl_.capture_current_exception();
return;
}
#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
// && !defined(ASIO_NO_EXCEPTIONS)
}
// Allocate and construct an operation to wrap the function.
typedef detail::executor_op<function_type, Allocator, detail::operation> op;
typename op::ptr p = {
detail::addressof(static_cast<const Allocator&>(*this)),
op::ptr::allocate(static_cast<const Allocator&>(*this)), 0 };
p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f),
static_cast<const Allocator&>(*this));
ASIO_HANDLER_CREATION((*context_ptr(), *p.p,
"io_context", context_ptr(), 0, "execute"));
context_ptr()->impl_.post_immediate_completion(p.p,
(bits() & relationship_continuation) != 0);
p.v = p.p = 0;
}
|
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x42df0
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x4d420
movq 0x18(%rsp), %rdi
callq 0x42e10
movq 0x8(%rax), %rdi
callq 0x42e30
testb $0x1, %al
jne 0x4d337
jmp 0x4d420
movq 0x58(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x4d4f0
leaq 0x4f(%rsp), %rdi
xorl %esi, %esi
callq 0x42e80
jmp 0x4d354
leaq 0x50(%rsp), %rsi
movq %rsi, %rdi
callq 0x4d520
jmp 0x4d363
movl $0x1, 0x38(%rsp)
leaq 0x4f(%rsp), %rdi
callq 0x42f10
jmp 0x4d3f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x4d39f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4f(%rsp), %rdi
callq 0x42f10
movq 0x40(%rsp), %rdi
callq 0x13230
movq 0x18(%rsp), %rdi
callq 0x42e10
movq 0x8(%rax), %rdi
callq 0x42f70
jmp 0x4d3be
movl $0x1, 0x38(%rsp)
callq 0x138d0
jmp 0x4d3e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x138d0
jmp 0x4d3f4
jmp 0x4d3f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x4d411
jmp 0x4d411
leaq 0x50(%rsp), %rdi
callq 0x493d0
movl 0x38(%rsp), %eax
testl %eax, %eax
je 0x4d40f
jmp 0x4d40a
jmp 0x4d4bb
jmp 0x4d420
leaq 0x50(%rsp), %rdi
callq 0x493d0
jmp 0x4d4d8
movq 0x18(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x4d550
movq 0x18(%rsp), %rdx
movq %rax, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x58(%rsp), %rsi
callq 0x4d590
jmp 0x4d458
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0x42e10
movq 0x18(%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x42df0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movl %eax, %edx
andl $0x2, %edx
shrl %edx
callq 0x43050
jmp 0x4d49f
movq $0x0, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4d5e0
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4d5e0
movq 0x40(%rsp), %rdi
callq 0x139b0
movq %rax, %rdi
callq 0x382b0
nopw (%rax,%rax)
|
/qicosmos[P]cinatra/include/asio/impl/io_context.hpp
|
asio::detail::executor_op<asio::detail::executor_function, std::allocator<void>, asio::detail::scheduler_operation>::do_complete(void*, asio::detail::scheduler_operation*, std::error_code const&, unsigned long)
|
static void do_complete(void* owner, Operation* base,
const asio::error_code& /*ec*/,
std::size_t /*bytes_transferred*/)
{
// Take ownership of the handler object.
executor_op* o(static_cast<executor_op*>(base));
Alloc allocator(o->allocator_);
ptr p = { detail::addressof(allocator), o, o };
ASIO_HANDLER_COMPLETION((*o));
// Make a copy of the handler so that the memory can be deallocated before
// the upcall is made. Even if we're not about to make an upcall, a
// sub-object of the handler may be the true owner of the memory associated
// with the handler. Consequently, a local copy of the handler is required
// to ensure that any owning sub-object remains valid until after we have
// deallocated the memory here.
Handler handler(ASIO_MOVE_CAST(Handler)(o->handler_));
p.reset();
// Make the upcall if required.
if (owner)
{
fenced_block b(fenced_block::half);
ASIO_HANDLER_INVOCATION_BEGIN(());
asio_handler_invoke_helpers::invoke(handler, handler);
ASIO_HANDLER_INVOCATION_END;
}
}
|
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x3f(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rsi
addq $0x18, %rsi
leaq 0x18(%rsp), %rdi
callq 0x4d4f0
leaq 0x20(%rsp), %rdi
callq 0x4d7b0
jmp 0x4d70f
cmpq $0x0, 0x60(%rsp)
je 0x4d76a
leaq 0xb(%rsp), %rdi
xorl %esi, %esi
callq 0x43bb0
jmp 0x4d725
leaq 0x18(%rsp), %rsi
movq %rsi, %rdi
callq 0x4d520
jmp 0x4d734
leaq 0xb(%rsp), %rdi
callq 0x42f10
jmp 0x4d76a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
jmp 0x4d783
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0xb(%rsp), %rdi
callq 0x42f10
jmp 0x4d783
leaq 0x18(%rsp), %rdi
callq 0x493d0
leaq 0x20(%rsp), %rdi
callq 0x4d5e0
addq $0x68, %rsp
retq
leaq 0x18(%rsp), %rdi
callq 0x493d0
leaq 0x20(%rsp), %rdi
callq 0x4d5e0
movq 0x10(%rsp), %rdi
callq 0x139b0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
/qicosmos[P]cinatra/include/asio/detail/executor_op.hpp
|
void asio::io_context::basic_executor_type<std::allocator<void>, 4ul>::execute<asio::detail::executor_function_view&>(asio::detail::executor_function_view&) const
|
void io_context::basic_executor_type<Allocator, Bits>::execute(
ASIO_MOVE_ARG(Function) f) const
{
typedef typename decay<Function>::type function_type;
// Invoke immediately if the blocking.possibly property is enabled and we are
// already inside the thread pool.
if ((bits() & blocking_never) == 0 && context_ptr()->impl_.can_dispatch())
{
// Make a local, non-const copy of the function.
function_type tmp(ASIO_MOVE_CAST(Function)(f));
#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
&& !defined(ASIO_NO_EXCEPTIONS)
try
{
#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
// && !defined(ASIO_NO_EXCEPTIONS)
detail::fenced_block b(detail::fenced_block::full);
asio_handler_invoke_helpers::invoke(tmp, tmp);
return;
#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
&& !defined(ASIO_NO_EXCEPTIONS)
}
catch (...)
{
context_ptr()->impl_.capture_current_exception();
return;
}
#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
// && !defined(ASIO_NO_EXCEPTIONS)
}
// Allocate and construct an operation to wrap the function.
typedef detail::executor_op<function_type, Allocator, detail::operation> op;
typename op::ptr p = {
detail::addressof(static_cast<const Allocator&>(*this)),
op::ptr::allocate(static_cast<const Allocator&>(*this)), 0 };
p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f),
static_cast<const Allocator&>(*this));
ASIO_HANDLER_CREATION((*context_ptr(), *p.p,
"io_context", context_ptr(), 0, "execute"));
context_ptr()->impl_.post_immediate_completion(p.p,
(bits() & relationship_continuation) != 0);
p.v = p.p = 0;
}
|
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x4f5b0
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x4f6ed
movq 0x20(%rsp), %rdi
callq 0x4f0c0
movq 0x8(%rax), %rdi
callq 0x42e30
testb $0x1, %al
jne 0x4f647
jmp 0x4f6ed
movq 0x68(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x4da80
leaq 0x57(%rsp), %rdi
xorl %esi, %esi
callq 0x42e80
jmp 0x4f664
leaq 0x58(%rsp), %rsi
movq %rsi, %rdi
callq 0x4dab0
jmp 0x4f673
leaq 0x57(%rsp), %rdi
callq 0x42f10
jmp 0x4f78a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x4f6aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x57(%rsp), %rdi
callq 0x42f10
movq 0x48(%rsp), %rdi
callq 0x13230
movq 0x20(%rsp), %rdi
callq 0x4f0c0
movq 0x8(%rax), %rdi
callq 0x42f70
jmp 0x4f6c9
callq 0x138d0
jmp 0x4f78a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x138d0
jmp 0x4f6e8
jmp 0x4f7a7
movq 0x20(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x4dae0
movq 0x20(%rsp), %rdx
movq %rax, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x68(%rsp), %rsi
callq 0x4db20
jmp 0x4f725
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
callq 0x4f0c0
movq 0x20(%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x4f5b0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl %eax, %edx
andl $0x2, %edx
shrl %edx
callq 0x43050
jmp 0x4f76e
movq $0x0, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x4db70
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x4db70
movq 0x48(%rsp), %rdi
callq 0x139b0
movq %rax, %rdi
callq 0x382b0
nopl (%rax)
|
/qicosmos[P]cinatra/include/asio/impl/io_context.hpp
|
void asio::execution::detail::any_executor_base::query_fn_non_void<asio::io_context::basic_executor_type<std::allocator<void>, 4ul>, asio::execution::prefer_only<asio::execution::detail::relationship::fork_t<0>>>(void*, void const*, void const*, std::enable_if<asio::can_query<asio::io_context::basic_executor_type<std::allocator<void>, 4ul> const&, asio::execution::prefer_only<asio::execution::detail::relationship::fork_t<0>> const&>::value && !is_same<asio::execution::prefer_only<asio::execution::detail::relationship::fork_t<0>>::polymorphic_query_result_type, void>::value && !is_reference<asio::execution::prefer_only<asio::execution::detail::relationship::fork_t<0>>::polymorphic_query_result_type>::value && !is_scalar<asio::execution::prefer_only<asio::execution::detail::relationship::fork_t<0>>::polymorphic_query_result_type>::value, void>::type*)
|
static void query_fn_non_void(void* result, const void* ex, const void* prop,
typename enable_if<
asio::can_query<const Ex&, const Prop&>::value
&& !is_same<typename Prop::polymorphic_query_result_type, void>::value
&& !is_reference<typename Prop::polymorphic_query_result_type>::value
&& !is_scalar<typename Prop::polymorphic_query_result_type>::value
>::type*)
{
*static_cast<typename Prop::polymorphic_query_result_type**>(result)
= new typename Prop::polymorphic_query_result_type(
asio::query(*static_cast<const Ex*>(ex),
*static_cast<const Prop*>(prop)));
}
|
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl $0x4, %edi
callq 0x13560
movq %rax, (%rsp)
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x8c085(%rip), %rdi # 0xdcc9c
callq 0x50c60
movl %eax, 0x8(%rsp)
jmp 0x50c22
movq (%rsp), %rcx
movl 0x8(%rsp), %eax
movl %eax, (%rcx)
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
addq $0x38, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movl $0x4, %esi
callq 0x13570
movq 0x10(%rsp), %rdi
callq 0x139b0
nop
|
/qicosmos[P]cinatra/include/asio/execution/any_executor.hpp
|
coro_io::io_context_pool::stop()::'lambda'()::operator()() const
|
void stop() {
std::call_once(flag_, [this] {
bool has_run_or_stop = false;
bool ok = has_run_or_stop_.compare_exchange_strong(has_run_or_stop, true);
work_.clear();
if (ok) {
// clear all unfinished work
for (auto &e : io_contexts_) {
e->run();
}
return;
}
promise_.get_future().wait();
});
}
|
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rdi
movq %rdi, 0x10(%rsp)
movb $0x0, 0x5f(%rsp)
addq $0x68, %rdi
leaq 0x5f(%rsp), %rsi
movl $0x1, %edx
movl $0x5, %ecx
callq 0x5a230
movq 0x10(%rsp), %rdi
andb $0x1, %al
movb %al, 0x5e(%rsp)
addq $0x30, %rdi
callq 0x5a810
testb $0x1, 0x5e(%rsp)
je 0x5a1cc
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x40c70
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x409a0
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x5a830
xorb $-0x1, %al
testb $0x1, %al
jne 0x5a19d
jmp 0x5a1ca
leaq 0x48(%rsp), %rdi
callq 0x5a870
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3a1e0
movq %rax, %rdi
callq 0x5a880
leaq 0x48(%rsp), %rdi
callq 0x5a8d0
jmp 0x5a186
jmp 0x5a1fa
movq 0x10(%rsp), %rsi
addq $0x50, %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5a8f0
movq 0x8(%rsp), %rdi
callq 0x5a920
jmp 0x5a1f0
leaq 0x28(%rsp), %rdi
callq 0x5a950
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5a950
movq 0x20(%rsp), %rdi
callq 0x139b0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
/qicosmos[P]cinatra/include/cinatra/ylt/coro_io/io_context_pool.hpp
|
asio::detail::epoll_reactor::descriptor_state* asio::detail::object_pool<asio::detail::epoll_reactor::descriptor_state>::alloc<bool>(bool)
|
Object* alloc(Arg arg)
{
Object* o = free_list_;
if (o)
free_list_ = object_pool_access::next(free_list_);
else
o = object_pool_access::create<Object>(arg);
object_pool_access::next(o) = live_list_;
object_pool_access::prev(o) = 0;
if (live_list_)
object_pool_access::prev(live_list_) = o;
live_list_ = o;
return o;
}
|
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x625cc
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3d910
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x625df
movb 0x2f(%rsp), %al
andb $0x1, %al
movzbl %al, %edi
callq 0x62660
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x3d910
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rdi
callq 0x3dff0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq $0x0, (%rcx)
cmpq $0x0, (%rax)
je 0x6263c
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdi
callq 0x3dff0
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
/qicosmos[P]cinatra/include/asio/detail/object_pool.hpp
|
cinatra::coro_http_server::start_one(std::shared_ptr<cinatra::coro_http_connection>)
|
async_simple::coro::Lazy<void> start_one(
std::shared_ptr<coro_http_connection> conn) noexcept {
co_await conn->start();
}
|
subq $0x148, %rsp # imm = 0x148
movq %rdx, 0xb0(%rsp)
movq %rdi, 0xb8(%rsp)
movq %rdi, %rax
movq %rax, 0xc0(%rsp)
movq %rdi, 0x138(%rsp)
movq %rsi, 0x130(%rsp)
movq %rdx, 0x128(%rsp)
xorl %eax, %eax
movb $0x1, %cl
testb $0x1, %cl
movq %rax, 0xc8(%rsp)
jne 0x6719d
movq 0xc8(%rsp), %rax
movq %rax, 0xa8(%rsp)
jmp 0x671e0
movl $0x60, %edi
movq 0xc2cff(%rip), %rsi # 0x129ea8
callq 0x13ae0
cmpq $0x0, %rax
movq %rax, 0xa0(%rsp)
je 0x671ce
movq 0xa0(%rsp), %rax
movq %rax, 0xa8(%rsp)
jmp 0x671e0
movq 0xb8(%rsp), %rdi
callq 0x728a0
jmp 0x675f7
movq 0xa8(%rsp), %rax
movq %rax, 0x98(%rsp)
leaq -0x36ba7(%rip), %rcx # 0x30650
movq %rcx, (%rax)
movb $0x1, %sil
leaq -0x36454(%rip), %rcx # 0x30db0
leaq -0x3683b(%rip), %rdx # 0x309d0
testb $0x1, %sil
cmovneq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq 0x98(%rsp), %rax
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, 0x60(%rsp)
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, 0x68(%rsp)
movq %rax, %rcx
addq $0x59, %rcx
movq %rcx, 0x70(%rsp)
movq %rax, %rcx
addq $0x48, %rcx
movq %rcx, 0x78(%rsp)
movq %rax, %rcx
addq $0x50, %rcx
movq %rcx, 0x80(%rsp)
movq %rax, %rcx
addq $0x5a, %rcx
movq %rcx, 0x88(%rsp)
addq $0x10, %rax
movq %rax, 0x90(%rsp)
movq 0xb0(%rsp), %rsi
movq 0x68(%rsp), %rdi
callq 0x70380
movq 0x90(%rsp), %rdi
callq 0x728e0
movq 0xb8(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0x72910
movq 0x90(%rsp), %rdi
callq 0x666c0
movq 0x70(%rsp), %rdi
callq 0x666d0
testb $0x1, %al
jne 0x67313
movq 0x98(%rsp), %rax
movb $0x0, 0x58(%rax)
movq 0x98(%rsp), %rsi
movq 0x70(%rsp), %rdi
callq 0x151a0
jmp 0x672e8
jmp 0x672ea
xorl %eax, %eax
testb %al, %al
jne 0x67313
jmp 0x672f2
movb $0x1, %al
testb %al, %al
jne 0x675f1
jmp 0x672fe
movl $0x2, %eax
movl %eax, 0x5c(%rsp)
jmp 0x67309
movl 0x5c(%rsp), %eax
movl %eax, 0x58(%rsp)
jmp 0x6732b
movq 0x70(%rsp), %rdi
callq 0x66750
xorl %eax, %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x50(%rsp)
je 0x67345
movl 0x50(%rsp), %eax
movl %eax, 0x4c(%rsp)
jmp 0x675a4
movq 0x68(%rsp), %rdi
callq 0x66e30
movq 0x80(%rsp), %rdi
movq %rax, %rsi
callq 0x72a10
jmp 0x67361
movq 0x80(%rsp), %rdx
movq 0x90(%rsp), %rsi
movq 0x78(%rsp), %rdi
callq 0x729d0
jmp 0x6737d
movq 0x78(%rsp), %rdi
callq 0x78820
testb $0x1, %al
jne 0x6743d
movq 0x98(%rsp), %rax
movb $0x1, 0x58(%rax)
movq 0x98(%rsp), %rsi
movq 0x78(%rsp), %rdi
callq 0x151f0
movq %rax, 0x40(%rsp)
jmp 0x673b4
movq 0x40(%rsp), %rax
movq %rax, %rdi
callq *(%rax)
jmp 0x673c0
jmp 0x673c2
xorl %eax, %eax
testb %al, %al
jne 0x6743d
jmp 0x673ca
movb $0x1, %al
testb %al, %al
jne 0x675f1
jmp 0x673d6
movl $0x2, %eax
movl %eax, 0x3c(%rsp)
jmp 0x673e1
movl 0x3c(%rsp), %eax
movl %eax, 0x38(%rsp)
jmp 0x67466
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
jmp 0x674bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
jmp 0x674ae
movq 0x78(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
callq 0x78840
jmp 0x674ae
movq 0x60(%rsp), %rax
movq 0x78(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0xa9390
jmp 0x67454
jmp 0x67456
xorl %eax, %eax
movl %eax, 0x34(%rsp)
jmp 0x6745e
movl 0x34(%rsp), %eax
movl %eax, 0x38(%rsp)
movq 0x78(%rsp), %rdi
movl 0x38(%rsp), %eax
movl %eax, 0x2c(%rsp)
callq 0x78840
movq 0x80(%rsp), %rdi
callq 0x67720
movl 0x2c(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x30(%rsp)
je 0x6749f
movl 0x30(%rsp), %eax
movl %eax, 0x4c(%rsp)
jmp 0x675a4
movq 0x90(%rsp), %rdi
callq 0x78850
jmp 0x674e2
movq 0x80(%rsp), %rdi
callq 0x67720
jmp 0x674bd
movq 0xd8(%rsp), %rdi
callq 0x13230
movq 0x90(%rsp), %rdi
callq 0x78860
callq 0x138d0
jmp 0x674de
jmp 0x674e0
jmp 0x674e2
movq 0x90(%rsp), %rdi
callq 0x67790
movq 0x88(%rsp), %rdi
callq 0x677a0
testb $0x1, %al
jne 0x67562
movq 0x98(%rsp), %rax
movq $0x0, (%rax)
movq 0x98(%rsp), %rsi
movq 0x88(%rsp), %rdi
callq 0x152b0
movq %rax, 0x20(%rsp)
jmp 0x6752b
movq 0x20(%rsp), %rax
movq %rax, %rdi
callq *(%rax)
jmp 0x67537
jmp 0x67539
xorl %eax, %eax
testb %al, %al
jne 0x67562
jmp 0x67541
movb $0x1, %al
testb %al, %al
jne 0x675f1
jmp 0x6754d
movl $0x2, %eax
movl %eax, 0x1c(%rsp)
jmp 0x67558
movl 0x1c(%rsp), %eax
movl %eax, 0x18(%rsp)
jmp 0x6757d
movq 0x88(%rsp), %rdi
callq 0x677f0
xorl %eax, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x10(%rsp)
je 0x67594
movl 0x10(%rsp), %eax
movl %eax, 0x4c(%rsp)
jmp 0x675a4
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x6759c
movl 0xc(%rsp), %eax
movl %eax, 0x4c(%rsp)
movq 0x90(%rsp), %rdi
movl 0x4c(%rsp), %eax
movl %eax, 0x8(%rsp)
callq 0x788d0
movq 0x68(%rsp), %rdi
callq 0x58740
movq 0x98(%rsp), %rax
cmpq $0x0, %rax
je 0x675e3
movq 0x98(%rsp), %rdi
movl $0x60, %esi
callq 0x13570
movl 0x8(%rsp), %eax
testl %eax, %eax
je 0x675ef
jmp 0x675ed
jmp 0x675f1
jmp 0x675f1
jmp 0x675f3
jmp 0x675f5
jmp 0x675f7
movq 0xc0(%rsp), %rax
addq $0x148, %rsp # imm = 0x148
retq
movq %rax, %rdi
callq 0x382b0
nop
|
/qicosmos[P]cinatra/include/cinatra/coro_http_server.hpp
|
auto async_simple::coro::detail::getAwaiter<coro_io::callback_awaitor_base<std::error_code, coro_io::callback_awaitor<std::error_code>>::callback_awaitor_impl<coro_io::async_accept(asio::basic_socket_acceptor<asio::ip::tcp, asio::any_io_executor>&, asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>&)::'lambda'(auto)>>(auto&&)
|
auto getAwaiter(Awaitable&& awaitable) {
if constexpr (HasMemberCoAwaitOperator<Awaitable>)
return std::forward<Awaitable>(awaitable).operator co_await();
else if constexpr (HasGlobalCoAwaitOperator<Awaitable>)
return operator co_await(std::forward<Awaitable>(awaitable));
else
return std::forward<Awaitable>(awaitable);
}
|
movq %rdi, -0x20(%rsp)
movq -0x20(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rdx
retq
nopl (%rax)
|
/qicosmos[P]cinatra/include/async_simple/coro/Traits.h
|
asio::detail::reactive_socket_service_base::reactor_op_cancellation& asio::cancellation_slot::emplace<asio::detail::reactive_socket_service_base::reactor_op_cancellation, asio::detail::epoll_reactor*, asio::detail::epoll_reactor::descriptor_state**, int&, asio::detail::epoll_reactor::op_types>(asio::detail::epoll_reactor*&&, asio::detail::epoll_reactor::descriptor_state**&&, int&, asio::detail::epoll_reactor::op_types&&)
|
CancellationHandler& emplace(ASIO_MOVE_ARG(Args)... args)
{
typedef detail::cancellation_handler<CancellationHandler>
cancellation_handler_type;
auto_delete_helper del = { prepare_memory(
sizeof(cancellation_handler_type),
ASIO_ALIGNOF(CancellationHandler)) };
cancellation_handler_type* handler_obj =
new (del.mem.first) cancellation_handler_type(
del.mem.second, ASIO_MOVE_CAST(Args)(args)...);
del.mem.first = 0;
*handler_ = handler_obj;
return handler_obj->handler();
}
|
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x28, %esi
movl $0x8, %edx
callq 0x49db0
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x38(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rcx
movq 0x48(%rsp), %r8
movq 0x40(%rsp), %r9
callq 0x69dc0
jmp 0x6871a
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x28(%rsp), %rcx
movq (%rax), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rdi
callq 0x69e60
movq %rax, (%rsp)
leaq 0x30(%rsp), %rdi
callq 0x49f30
movq (%rsp), %rax
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x49f30
movq 0x20(%rsp), %rdi
callq 0x139b0
|
/qicosmos[P]cinatra/include/asio/cancellation_signal.hpp
|
asio::detail::reactive_socket_accept_op<asio::basic_socket<asio::ip::tcp, asio::any_io_executor>, asio::ip::tcp, auto coro_io::async_accept(asio::basic_socket_acceptor<asio::ip::tcp, asio::any_io_executor>&, asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>&)::'lambda'(auto)::operator()<coro_io::callback_awaitor_base<std::error_code, coro_io::callback_awaitor<std::error_code>>::awaitor_handler>(auto) const::'lambda'(auto const&), asio::any_io_executor>::do_complete(void*, asio::detail::scheduler_operation*, std::error_code const&, unsigned long)
|
static void do_complete(void* owner, operation* base,
const asio::error_code& /*ec*/,
std::size_t /*bytes_transferred*/)
{
// Take ownership of the handler object.
reactive_socket_accept_op* o(static_cast<reactive_socket_accept_op*>(base));
ptr p = { asio::detail::addressof(o->handler_), o, o };
// On success, assign new connection to peer socket object.
if (owner)
o->do_assign();
ASIO_HANDLER_COMPLETION((*o));
// Take ownership of the operation's outstanding work.
handler_work<Handler, IoExecutor> w(
ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
o->work_));
ASIO_ERROR_LOCATION(o->ec_);
// Make a copy of the handler so that the memory can be deallocated before
// the upcall is made. Even if we're not about to make an upcall, a
// sub-object of the handler may be the true owner of the memory associated
// with the handler. Consequently, a local copy of the handler is required
// to ensure that any owning sub-object remains valid until after we have
// deallocated the memory here.
detail::binder1<Handler, asio::error_code>
handler(o->handler_, o->ec_);
p.h = asio::detail::addressof(handler.handler_);
p.reset();
// Make the upcall if required.
if (owner)
{
fenced_block b(fenced_block::half);
ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
w.complete(handler, handler.handler_);
ASIO_HANDLER_INVOCATION_END;
}
}
|
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
addq $0x70, %rax
movq %rax, 0x68(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x78(%rsp)
cmpq $0x0, 0xa0(%rsp)
je 0x68a31
movq 0x80(%rsp), %rdi
callq 0x68c40
jmp 0x68a1c
jmp 0x68a31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x68b05
movq 0x80(%rsp), %rsi
addq $0x78, %rsi
leaq 0x20(%rsp), %rdi
callq 0x68d00
movq 0x80(%rsp), %rdx
movq %rdx, %rsi
addq $0x70, %rsi
addq $0x18, %rdx
leaq 0x8(%rsp), %rdi
callq 0x68d30
jmp 0x68a66
leaq 0x8(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x68d70
jmp 0x68a7c
cmpq $0x0, 0xa0(%rsp)
je 0x68adf
leaq 0x7(%rsp), %rdi
xorl %esi, %esi
callq 0x43bb0
jmp 0x68a95
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %rdx, %rsi
callq 0x68e20
jmp 0x68aa9
leaq 0x7(%rsp), %rdi
callq 0x42f10
jmp 0x68adf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x68afb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x7(%rsp), %rdi
callq 0x42f10
jmp 0x68afb
leaq 0x20(%rsp), %rdi
callq 0x68e70
leaq 0x68(%rsp), %rdi
callq 0x68820
addq $0xa8, %rsp
retq
leaq 0x20(%rsp), %rdi
callq 0x68e70
leaq 0x68(%rsp), %rdi
callq 0x68820
movq 0x60(%rsp), %rdi
callq 0x139b0
nopl (%rax)
|
/qicosmos[P]cinatra/include/asio/detail/reactive_socket_accept_op.hpp
|
asio::detail::reactive_socket_accept_op_base<asio::basic_socket<asio::ip::tcp, asio::any_io_executor>, asio::ip::tcp>::do_assign()
|
void do_assign()
{
if (new_socket_.get() != invalid_socket)
{
if (peer_endpoint_)
peer_endpoint_->resize(addrlen_);
peer_.assign(protocol_, new_socket_.get(), ec_);
if (!ec_)
new_socket_.release();
}
}
|
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x48, %rdi
callq 0x622b0
cmpl $-0x1, %eax
je 0x68cf0
movq 0x10(%rsp), %rax
cmpq $0x0, 0x60(%rax)
je 0x68c83
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x68(%rax), %rsi
callq 0x608d0
movq 0x10(%rsp), %rdi
movq 0x50(%rdi), %rax
movq %rax, (%rsp)
movq %rdi, %rax
addq $0x58, %rax
movq %rax, 0x8(%rsp)
addq $0x48, %rdi
callq 0x622b0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rcx
movl %eax, 0x2c(%rsp)
addq $0x18, %rcx
leaq 0x2c(%rsp), %rdx
callq 0x68e80
movq 0x10(%rsp), %rdi
movl %eax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
addq $0x18, %rdi
callq 0x3ac70
testb $0x1, %al
jne 0x68cee
movq 0x10(%rsp), %rdi
addq $0x48, %rdi
callq 0x62410
jmp 0x68cf0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
|
/qicosmos[P]cinatra/include/asio/detail/reactive_socket_accept_op.hpp
|
asio::detail::reactive_socket_accept_op_base<asio::basic_socket<asio::ip::tcp, asio::any_io_executor>, asio::ip::tcp>::do_perform(asio::detail::reactor_op*)
|
static status do_perform(reactor_op* base)
{
reactive_socket_accept_op_base* o(
static_cast<reactive_socket_accept_op_base*>(base));
socket_type new_socket = invalid_socket;
status result = socket_ops::non_blocking_accept(o->socket_,
o->state_, o->peer_endpoint_ ? o->peer_endpoint_->data() : 0,
o->peer_endpoint_ ? &o->addrlen_ : 0, o->ec_, new_socket)
? done : not_done;
o->new_socket_.reset(new_socket);
ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_accept", o->ec_));
return result;
}
|
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rax
movl 0x40(%rax), %eax
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movb 0x44(%rax), %al
movb %al, 0x1f(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x60(%rax)
je 0x69924
movq 0x28(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x60900
movq %rax, 0x10(%rsp)
jmp 0x6992d
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x6992d
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x60(%rax)
je 0x69952
movq 0x28(%rsp), %rax
addq $0x68, %rax
movq %rax, (%rsp)
jmp 0x6995a
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x6995a
movq 0x8(%rsp), %rdx
movb 0x1f(%rsp), %al
movl 0x18(%rsp), %edi
movq (%rsp), %rcx
movq 0x28(%rsp), %r8
addq $0x18, %r8
leaq 0x24(%rsp), %r9
movzbl %al, %esi
callq 0x69a50
movb %al, %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
addq $0x48, %rdi
movl 0x24(%rsp), %esi
callq 0x69c00
movl 0x20(%rsp), %eax
addq $0x38, %rsp
retq
nop
|
/qicosmos[P]cinatra/include/asio/detail/reactive_socket_accept_op.hpp
|
asio::basic_streambuf<std::allocator<char>>::data() const
|
const_buffers_type data() const ASIO_NOEXCEPT
{
return asio::buffer(asio::const_buffer(gptr(),
(pptr() - gptr()) * sizeof(char_type)));
}
|
subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x13160
movq %rax, 0x28(%rsp)
jmp 0x78eff
movq 0x20(%rsp), %rdi
callq 0x13150
movq %rax, 0x18(%rsp)
jmp 0x78f10
movq 0x20(%rsp), %rdi
callq 0x13160
movq %rax, 0x10(%rsp)
jmp 0x78f21
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdx
subq %rax, %rdx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x81cb0
movq 0x8(%rsp), %rdi
callq 0x81c80
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rdx
addq $0x58, %rsp
retq
movq %rax, %rdi
callq 0x382b0
nopl (%rax)
|
/qicosmos[P]cinatra/include/asio/basic_streambuf.hpp
|
cinatra::coro_http_connection::reply(bool)
|
async_simple::coro::Lazy<bool> reply(bool need_to_bufffer = true) {
std::error_code ec;
size_t size;
if (multi_buf_) {
if (need_to_bufffer) {
response_.to_buffers(buffers_, chunk_size_str_);
}
std::tie(ec, size) = co_await async_write(buffers_);
}
else {
if (need_to_bufffer) {
response_.build_resp_str(resp_str_);
}
std::tie(ec, size) = co_await async_write(asio::buffer(resp_str_));
}
if (ec) {
CINATRA_LOG_ERROR << "async_write error: " << ec.message();
close();
co_return false;
}
co_return true;
}
|
subq $0x2a8, %rsp # imm = 0x2A8
movq %rdi, 0x148(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x150(%rsp)
movq %rdi, 0x290(%rsp)
movq %rsi, 0x288(%rsp)
andb $0x1, %al
movb %al, 0x287(%rsp)
movq 0x288(%rsp), %rax
movq %rax, 0x158(%rsp)
xorl %eax, %eax
movb $0x1, %cl
testb $0x1, %cl
movq %rax, 0x160(%rsp)
jne 0x794e8
movq 0x160(%rsp), %rax
movq %rax, 0x140(%rsp)
jmp 0x7952b
movl $0xd8, %edi
movq 0xb09b4(%rip), %rsi # 0x129ea8
callq 0x13ae0
cmpq $0x0, %rax
movq %rax, 0x138(%rsp)
je 0x79519
movq 0x138(%rsp), %rax
movq %rax, 0x140(%rsp)
jmp 0x7952b
movq 0x148(%rsp), %rdi
callq 0x85150
jmp 0x79f79
movq 0x140(%rsp), %rax
movq %rax, 0x130(%rsp)
leaq -0x5df32(%rip), %rcx # 0x1b610
movq %rcx, (%rax)
movb $0x1, %sil
leaq -0x5cb9f(%rip), %rcx # 0x1c9b0
leaq -0x5d596(%rip), %rdx # 0x1bfc0
testb $0x1, %sil
cmovneq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq 0x130(%rsp), %rax
movq %rax, %rcx
addq $0x88, %rcx
movq %rcx, 0xa8(%rsp)
movq %rax, %rcx
addq $0x90, %rcx
movq %rcx, 0xb0(%rsp)
movq %rax, %rcx
addq $0xd5, %rcx
movq %rcx, 0xb8(%rsp)
movq %rax, %rcx
addq $0xd6, %rcx
movq %rcx, 0xc0(%rsp)
movq %rax, %rcx
addq $0x68, %rcx
movq %rcx, 0xc8(%rsp)
movq %rax, %rcx
addq $0x98, %rcx
movq %rcx, 0xd0(%rsp)
movq %rax, %rcx
addq $0xa0, %rcx
movq %rcx, 0xd8(%rsp)
movq %rax, %rcx
addq $0xd0, %rcx
movq %rcx, 0xe0(%rsp)
movq %rax, %rcx
addq $0x38, %rcx
movq %rcx, 0xe8(%rsp)
movq %rax, %rcx
addq $0xa8, %rcx
movq %rcx, 0xf0(%rsp)
movq %rax, %rcx
addq $0xb0, %rcx
movq %rcx, 0xf8(%rsp)
movq %rax, %rcx
addq $0x50, %rcx
movq %rcx, 0x100(%rsp)
movq %rax, %rcx
addq $0xb8, %rcx
movq %rcx, 0x108(%rsp)
movq %rax, %rcx
addq $0xc0, %rcx
movq %rcx, 0x110(%rsp)
movq %rax, %rcx
addq $0x78, %rcx
movq %rcx, 0x118(%rsp)
movq %rax, %rcx
addq $0xd7, %rcx
movq %rcx, 0x120(%rsp)
addq $0x10, %rax
movq %rax, 0x128(%rsp)
movq 0x128(%rsp), %rdi
movq 0xb8(%rsp), %rax
movq 0x130(%rsp), %rcx
movq 0x158(%rsp), %rdx
movq %rdx, 0xc8(%rcx)
movb 0x287(%rsp), %cl
andb $0x1, %cl
movb %cl, (%rax)
callq 0x85190
movq 0x148(%rsp), %rdi
movq 0x128(%rsp), %rsi
callq 0x851c0
movq 0x128(%rsp), %rdi
callq 0x666c0
movq 0xc0(%rsp), %rdi
callq 0x666d0
testb $0x1, %al
jne 0x7974f
movq 0x130(%rsp), %rax
movb $0x0, 0xd4(%rax)
movq 0x130(%rsp), %rsi
movq 0xc0(%rsp), %rdi
callq 0x17390
jmp 0x7971b
jmp 0x7971d
xorl %eax, %eax
testb %al, %al
jne 0x7974f
jmp 0x79725
movb $0x1, %al
testb %al, %al
jne 0x79f3e
jmp 0x79731
movl $0x2, %eax
movl %eax, 0xa4(%rsp)
jmp 0x7973f
movl 0xa4(%rsp), %eax
movl %eax, 0xa0(%rsp)
jmp 0x79773
movq 0xc0(%rsp), %rdi
callq 0x66750
xorl %eax, %eax
movl %eax, 0x9c(%rsp)
movl 0x9c(%rsp), %eax
movl %eax, 0xa0(%rsp)
movl 0xa0(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x98(%rsp)
je 0x79799
movl 0x98(%rsp), %eax
movl %eax, 0x94(%rsp)
jmp 0x79efa
movq 0xc8(%rsp), %rdi
movq 0x130(%rsp), %rax
movq 0xc8(%rax), %rax
movq %rax, 0x88(%rsp)
callq 0x38f80
movq 0x88(%rsp), %rax
testb $0x1, 0x1101(%rax)
je 0x79a0a
movq 0xb8(%rsp), %rax
testb $0x1, (%rax)
je 0x79832
movq 0x130(%rsp), %rax
movq 0xc8(%rax), %rdx
movq %rdx, %rdi
addq $0xf48, %rdi # imm = 0xF48
movq %rdx, %rsi
addq $0x1048, %rsi # imm = 0x1048
addq $0x1128, %rdx # imm = 0x1128
callq 0x85280
jmp 0x79810
jmp 0x79832
movq %rdx, %rcx
movq 0xd8(%rsp), %rdx
movq %rax, %rsi
movq 0xe0(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x79dbd
movq 0xf8(%rsp), %rdi
movq 0x130(%rsp), %rax
movq 0xc8(%rax), %rdx
movq 0xc8(%rax), %rsi
addq $0x1048, %rdx # imm = 0x1048
callq 0x853b0
movq 0xf8(%rsp), %rdx
movq 0x128(%rsp), %rsi
movq 0xf0(%rsp), %rdi
callq 0x78d40
jmp 0x7987b
movq 0xf0(%rsp), %rdi
callq 0x78e10
testb $0x1, %al
jne 0x79948
movq 0x130(%rsp), %rax
movb $0x1, 0xd4(%rax)
movq 0x130(%rsp), %rsi
movq 0xf0(%rsp), %rdi
callq 0x173e0
movq %rax, 0x80(%rsp)
jmp 0x798be
movq 0x80(%rsp), %rax
movq %rax, %rdi
callq *(%rax)
jmp 0x798cd
jmp 0x798cf
xorl %eax, %eax
testb %al, %al
jne 0x79948
jmp 0x798d7
movb $0x1, %al
testb %al, %al
jne 0x79f3e
jmp 0x798e3
movl $0x2, %eax
movl %eax, 0x7c(%rsp)
jmp 0x798ee
movl 0x7c(%rsp), %eax
movl %eax, 0x78(%rsp)
jmp 0x799b7
movq %rdx, %rcx
movq 0xd8(%rsp), %rdx
movq %rax, %rsi
movq 0xe0(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x799f8
movq 0xf0(%rsp), %rdi
movq %rdx, %rcx
movq 0xd8(%rsp), %rdx
movq %rax, %rsi
movq 0xe0(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x78e30
jmp 0x799f8
movq 0xe8(%rsp), %rdi
movq 0xa8(%rsp), %rax
movq 0xf0(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rsi
callq 0x81a30
jmp 0x7996d
jmp 0x7996f
movq 0xd0(%rsp), %rdx
movq 0xc8(%rsp), %rsi
leaq 0x1f0(%rsp), %rdi
callq 0x85410
movq 0xe8(%rsp), %rsi
leaq 0x1f0(%rsp), %rdi
callq 0x85450
movq %rax, 0x1e8(%rsp)
xorl %eax, %eax
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
movl %eax, 0x78(%rsp)
movq 0xf0(%rsp), %rdi
movl 0x78(%rsp), %eax
movl %eax, 0x6c(%rsp)
callq 0x78e30
movq 0xf8(%rsp), %rdi
callq 0x78e40
movl 0x6c(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x70(%rsp)
je 0x799f3
movl 0x70(%rsp), %eax
movl %eax, 0x68(%rsp)
jmp 0x79da0
jmp 0x79c33
movq 0xf8(%rsp), %rdi
callq 0x78e40
jmp 0x79dbd
movq 0xb8(%rsp), %rax
testb $0x1, (%rax)
je 0x79a40
movq 0x130(%rsp), %rax
movq 0xc8(%rax), %rsi
movq %rsi, %rdi
addq $0xf48, %rdi # imm = 0xF48
addq $0x10a8, %rsi # imm = 0x10A8
callq 0x7ca00
jmp 0x79a3e
jmp 0x79a40
movq 0x130(%rsp), %rax
movq 0xc8(%rax), %rdi
movq 0xc8(%rax), %rax
movq %rax, 0x60(%rsp)
addq $0x10a8, %rdi # imm = 0x10A8
callq 0x7cf10
movq 0x110(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq %rax, %rcx
movq %rdx, %rax
movq 0x118(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
callq 0x7ceb0
movq 0x110(%rsp), %rdx
movq 0x128(%rsp), %rsi
movq 0x108(%rsp), %rdi
callq 0x78d40
jmp 0x79aad
movq 0x108(%rsp), %rdi
callq 0x78e10
testb $0x1, %al
jne 0x79b74
movq 0x130(%rsp), %rax
movb $0x2, 0xd4(%rax)
movq 0x130(%rsp), %rsi
movq 0x108(%rsp), %rdi
callq 0x174a0
movq %rax, 0x58(%rsp)
jmp 0x79aed
movq 0x58(%rsp), %rax
movq %rax, %rdi
callq *(%rax)
jmp 0x79af9
jmp 0x79afb
xorl %eax, %eax
testb %al, %al
jne 0x79b74
jmp 0x79b03
movb $0x1, %al
testb %al, %al
jne 0x79f3e
jmp 0x79b0f
movl $0x2, %eax
movl %eax, 0x54(%rsp)
jmp 0x79b1a
movl 0x54(%rsp), %eax
movl %eax, 0x50(%rsp)
jmp 0x79be3
movq %rdx, %rcx
movq 0xd8(%rsp), %rdx
movq %rax, %rsi
movq 0xe0(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x79c21
movq 0x108(%rsp), %rdi
movq %rdx, %rcx
movq 0xd8(%rsp), %rdx
movq %rax, %rsi
movq 0xe0(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
callq 0x78e30
jmp 0x79c21
movq 0x100(%rsp), %rdi
movq 0xb0(%rsp), %rax
movq 0x108(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rsi
callq 0x81a30
jmp 0x79b99
jmp 0x79b9b
movq 0xd0(%rsp), %rdx
movq 0xc8(%rsp), %rsi
leaq 0x1a0(%rsp), %rdi
callq 0x85410
movq 0x100(%rsp), %rsi
leaq 0x1a0(%rsp), %rdi
callq 0x85450
movq %rax, 0x198(%rsp)
xorl %eax, %eax
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x50(%rsp)
movq 0x108(%rsp), %rdi
movl 0x50(%rsp), %eax
movl %eax, 0x44(%rsp)
callq 0x78e30
movq 0x110(%rsp), %rdi
callq 0x78e40
movl 0x44(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x48(%rsp)
je 0x79c1f
movl 0x48(%rsp), %eax
movl %eax, 0x68(%rsp)
jmp 0x79da0
jmp 0x79c33
movq 0x110(%rsp), %rdi
callq 0x78e40
jmp 0x79dbd
movq 0xc8(%rsp), %rdi
callq 0x3ac70
testb $0x1, %al
jne 0x79c49
jmp 0x79d72
leaq 0x61815(%rip), %rsi # 0xdb465
leaq 0x197(%rsp), %rdi
callq 0x7cf80
movq %rax, 0x38(%rsp)
jmp 0x79c64
movq 0xc8(%rsp), %rsi
leaq 0x170(%rsp), %rdi
callq 0x3aee0
jmp 0x79c7b
movq 0x38(%rsp), %rdi
leaq 0x170(%rsp), %rsi
callq 0x5e400
jmp 0x79c8f
movq 0x130(%rsp), %rax
movq 0xc8(%rax), %rax
movq %rax, 0x30(%rsp)
leaq 0x170(%rsp), %rdi
callq 0x358a0
leaq 0x197(%rsp), %rdi
callq 0x5e440
movq 0x30(%rsp), %rdi
movl $0x1, %esi
callq 0x6f7e0
jmp 0x79cce
movq 0x128(%rsp), %rdi
movb $0x0, 0x16f(%rsp)
leaq 0x16f(%rsp), %rsi
callq 0x854c0
movl $0x3, %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x68(%rsp)
jmp 0x79da0
movq %rdx, %rcx
movq 0xd8(%rsp), %rdx
movq %rax, %rsi
movq 0xe0(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x79d63
movq %rdx, %rcx
movq 0xd8(%rsp), %rdx
movq %rax, %rsi
movq 0xe0(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x79d63
movq %rdx, %rcx
movq 0xd8(%rsp), %rdx
movq %rax, %rsi
movq 0xe0(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
leaq 0x170(%rsp), %rdi
callq 0x358a0
leaq 0x197(%rsp), %rdi
callq 0x5e440
jmp 0x79dbd
movq 0x128(%rsp), %rdi
movb $0x1, 0x16e(%rsp)
leaq 0x16e(%rsp), %rsi
callq 0x854c0
movl $0x3, %eax
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x68(%rsp)
movl 0x68(%rsp), %eax
cmpl $0x3, %eax
movl %eax, 0x24(%rsp)
je 0x79de7
movl 0x24(%rsp), %eax
movl %eax, 0x94(%rsp)
jmp 0x79efa
jmp 0x79dbf
movq 0xd8(%rsp), %rax
movq (%rax), %rdi
callq 0x13230
movq 0x128(%rsp), %rdi
callq 0x854f0
callq 0x138d0
jmp 0x79de3
jmp 0x79de5
jmp 0x79de7
movq 0x128(%rsp), %rdi
callq 0x67790
movq 0x120(%rsp), %rdi
callq 0x677a0
testb $0x1, %al
jne 0x79eb2
movq 0x130(%rsp), %rax
movq $0x0, (%rax)
movb $0x3, 0xd4(%rax)
movq 0x130(%rsp), %rsi
movq 0x120(%rsp), %rdi
callq 0x17560
movq %rax, 0x18(%rsp)
jmp 0x79e3b
movq 0x18(%rsp), %rax
movq %rax, %rdi
callq *(%rax)
jmp 0x79e47
jmp 0x79e49
xorl %eax, %eax
testb %al, %al
jne 0x79eb2
jmp 0x79e51
movb $0x1, %al
testb %al, %al
jne 0x79f3e
jmp 0x79e5d
movl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x79e68
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x79ecd
movq %rdx, %rcx
movq 0xd8(%rsp), %rdx
movq %rax, %rsi
movq 0xe0(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x79f44
movq %rdx, %rcx
movq 0xd8(%rsp), %rdx
movq %rax, %rsi
movq 0xe0(%rsp), %rax
movq %rsi, (%rdx)
movl %ecx, (%rax)
jmp 0x79f44
movq 0x120(%rsp), %rdi
callq 0x677f0
xorl %eax, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl $0x0, %eax
movl %eax, 0x8(%rsp)
je 0x79ee7
movl 0x8(%rsp), %eax
movl %eax, 0x94(%rsp)
jmp 0x79efa
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x79eef
movl 0x4(%rsp), %eax
movl %eax, 0x94(%rsp)
movq 0x128(%rsp), %rdi
movl 0x94(%rsp), %eax
movl %eax, (%rsp)
callq 0x85570
movq 0x130(%rsp), %rax
cmpq $0x0, %rax
je 0x79f31
movq 0x130(%rsp), %rdi
movl $0xd8, %esi
callq 0x13570
movl (%rsp), %eax
testl %eax, %eax
je 0x79f3c
jmp 0x79f3a
jmp 0x79f3e
jmp 0x79f3e
jmp 0x79f40
jmp 0x79f42
jmp 0x79f79
jmp 0x79f46
jmp 0x79f48
jmp 0x79f4a
movq 0x128(%rsp), %rdi
callq 0x85570
movq 0x130(%rsp), %rax
cmpq $0x0, %rax
je 0x79f77
movq 0x130(%rsp), %rdi
movl $0xd8, %esi
callq 0x13570
jmp 0x79f89
movq 0x150(%rsp), %rax
addq $0x2a8, %rsp # imm = 0x2A8
retq
movq 0xd8(%rsp), %rax
movq (%rax), %rdi
callq 0x139b0
nopl (%rax)
|
/qicosmos[P]cinatra/include/cinatra/coro_http_connection.hpp
|
async_simple::coro::Lazy<std::pair<std::error_code, unsigned long>>::coAwait(async_simple::Executor*)
|
auto coAwait(Executor* ex) {
logicAssert(this->_coro.operator bool(),
"Lazy do not have a coroutine_handle "
"Maybe the allocation failed or you're using a used Lazy");
// derived lazy inherits executor
this->_coro.promise()._executor = ex;
return typename Base::ValueAwaiter(std::exchange(this->_coro, nullptr));
}
|
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7d500
movzbl %al, %edi
andl $0x1, %edi
leaq 0x5df29(%rip), %rsi # 0xdb295
callq 0x637d0
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
callq 0x7d520
movq (%rsp), %rcx
movq 0x8(%rsp), %rdi
movq %rcx, 0x8(%rax)
movq $0x0, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x7d470
movq 0x10(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
callq 0x7d540
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
/qicosmos[P]cinatra/include/async_simple/coro/Lazy.h
|
auto async_simple::coro::detail::getAwaiter<coro_io::callback_awaitor_base<std::pair<std::error_code, unsigned long>, coro_io::callback_awaitor<std::pair<std::error_code, unsigned long>>>::callback_awaitor_impl<async_simple::coro::Lazy<std::pair<std::error_code, unsigned long>> coro_io::async_read_until<asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>, asio::basic_streambuf<std::allocator<char>>>(asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>&, asio::basic_streambuf<std::allocator<char>>&, std::basic_string_view<char, std::char_traits<char>>)::'lambda'(asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>)>>(asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>&&)
|
auto getAwaiter(Awaitable&& awaitable) {
if constexpr (HasMemberCoAwaitOperator<Awaitable>)
return std::forward<Awaitable>(awaitable).operator co_await();
else if constexpr (HasGlobalCoAwaitOperator<Awaitable>)
return operator co_await(std::forward<Awaitable>(awaitable));
else
return std::forward<Awaitable>(awaitable);
}
|
movq %rdi, -0x20(%rsp)
movq -0x20(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rdx
retq
nopl (%rax)
|
/qicosmos[P]cinatra/include/async_simple/coro/Traits.h
|
asio::detail::write_op<asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>, asio::mutable_buffers_1, asio::mutable_buffer const*, asio::detail::transfer_all_t, auto async_simple::coro::Lazy<std::pair<std::error_code, unsigned long>> coro_io::async_write<asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>, asio::mutable_buffers_1&>(asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>&, asio::mutable_buffers_1&)::'lambda'(asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>)::operator()<coro_io::callback_awaitor_base<std::pair<std::error_code, unsigned long>, coro_io::callback_awaitor<std::pair<std::error_code, unsigned long>>>::awaitor_handler>(asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>) const::'lambda'(asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor> const&, asio::mutable_buffers_1&)>::write_op(asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>&, asio::mutable_buffers_1 const&, asio::detail::transfer_all_t&, auto async_simple::coro::Lazy<std::pair<std::error_code, unsigned long>> coro_io::async_write<asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>, asio::mutable_buffers_1&>(asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>&, asio::mutable_buffers_1&)::'lambda'(asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>)::operator()<coro_io::callback_awaitor_base<std::pair<std::error_code, unsigned long>, coro_io::callback_awaitor<std::pair<std::error_code, unsigned long>>>::awaitor_handler>(asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>) const::'lambda'(asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor> const&, asio::mutable_buffers_1&)&)
|
write_op(AsyncWriteStream& stream, const ConstBufferSequence& buffers,
CompletionCondition& completion_condition, WriteHandler& handler)
: base_from_cancellation_state<WriteHandler>(
handler, enable_partial_cancellation()),
base_from_completion_cond<CompletionCondition>(completion_condition),
stream_(stream),
buffers_(buffers),
start_(0),
handler_(ASIO_MOVE_CAST(WriteHandler)(handler))
{
}
|
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x10(%rsp), %rsi
callq 0xa0270
movq (%rsp), %rdi
callq 0x8b350
movq (%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq 0x20(%rsp), %rsi
callq 0xa0280
movq (%rsp), %rax
movl $0x0, 0x20(%rax)
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x28(%rax)
addq $0x38, %rsp
retq
nop
|
/qicosmos[P]cinatra/include/asio/impl/write.hpp
|
Imf_3_4::checkOpenEXRFile(char const*, bool, bool, bool)
|
bool
checkOpenEXRFile (
const char* fileName, bool reduceMemory, bool reduceTime, bool runCoreCheck)
{
if (runCoreCheck)
{
return runCoreChecks (fileName, reduceMemory, reduceTime);
}
else { return runChecks (fileName, reduceMemory, reduceTime); }
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r14
testl %ecx, %ecx
je 0x10bf1
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movq $0x0, 0xa0(%rsp)
movq $0x68, 0x40(%rsp)
movabsq $-0x407fffff00000002, %rax # imm = 0xBF800000FFFFFFFE
movq %rax, 0x98(%rsp)
leaq 0xd4e(%rip), %rax # 0x118e0
movq %rax, 0x48(%rsp)
movl %ebp, %eax
orb %r12b, %al
cmpb $0x1, %al
jne 0x10baf
movaps 0xf459(%rip), %xmm0 # 0x20000
movups %xmm0, 0x88(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movq %r14, %rsi
callq 0xfb00
movb $0x1, %r15b
testl %eax, %eax
jne 0x1105f
leaq 0x10(%rsp), %rbx
movq (%rbx), %rdi
movzbl %bpl, %esi
movzbl %r12b, %edx
callq 0x11911
movl %eax, %r15d
movq %rbx, %rdi
callq 0x10130
jmp 0x1105f
callq 0xfe90
movq %rax, 0xb0(%rsp)
leaq 0x3c(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x10290
leaq 0x34(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x10290
movl %ebp, %eax
orb %r12b, %al
cmpb $0x1, %al
jne 0x10c4a
movl $0x100000, %edi # imm = 0x100000
callq 0xf970
movl $0x800, %edi # imm = 0x800
movl $0x800, %esi # imm = 0x800
callq 0xfea0
movl $0x200, %edi # imm = 0x200
movl $0x200, %esi # imm = 0x200
jmp 0x10c54
movl $0x4000, %edi # imm = 0x4000
movl $0x4000, %esi # imm = 0x4000
callq 0xf340
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
callq 0xf310
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %eax, %edx
movl $0x1, %ecx
callq 0xf0c0
movb $0x1, %r13b
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0xf460
movq %rax, %rdi
callq 0xf830
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xf560
leaq 0x10(%rsp), %rdi
callq 0xf940
testb %al, %al
je 0x10d1a
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0xf460
movq %rax, %rdi
callq 0xf210
movl (%rax), %r13d
movl 0x4(%rax), %ebx
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0xf460
movq %rax, %rdi
callq 0xf2d0
movq %rax, %r15
imulq %r13, %rbx
movq 0x18(%rsp), %rdx
cmpq 0x19d67(%rip), %rdx # 0x2aa60
jne 0x10d15
testq %rdx, %rdx
je 0x10d1f
movq 0x19d51(%rip), %rsi # 0x2aa58
movq 0x10(%rsp), %rdi
callq 0xfa30
testl %eax, %eax
je 0x10d1f
movslq %r15d, %rax
jmp 0x10d2f
xorl %r13d, %r13d
jmp 0x10d3e
movslq %r15d, %rcx
cmpq $0x5, %rcx
movl $0x4, %eax
cmovaeq %rcx, %rax
imulq %rax, %rbx
cmpq $0xf4241, %rbx # imm = 0xF4241
setae %r13b
movzbl %bpl, %esi
movzbl %r12b, %edx
leaq 0x40(%rsp), %rdi
callq 0x126fb
movl %eax, %r15d
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x10d62
callq 0x1651e
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x10d71
callq 0x1651e
movzbl %r12b, %r12d
testb %bpl, %bpl
movl %r13d, 0xc(%rsp)
jne 0x10e73
callq 0xf310
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0xf2f0
leaq 0x40(%rsp), %rdi
movl %r12d, %esi
callq 0x143f0
movl %eax, %ebx
leaq 0x40(%rsp), %rdi
callq 0xf990
testb %bl, %bl
je 0x10ded
movq 0x18(%rsp), %rdx
movb $0x1, %r13b
cmpq 0x19c9d(%rip), %rdx # 0x2aa60
jne 0x10df0
testq %rdx, %rdx
je 0x10ded
movq 0x19c87(%rip), %rsi # 0x2aa58
movq 0x10(%rsp), %rdi
callq 0xfa30
testl %eax, %eax
movzbl %r15b, %eax
movl $0x1, %r13d
cmovel %eax, %r13d
jmp 0x10df0
movl %r15d, %r13d
callq 0xf310
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0xfc00
leaq 0x40(%rsp), %rdi
movl %r12d, %esi
callq 0x1459f
movl %eax, %r15d
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x10e23
callq 0x1651e
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x10e32
callq 0x1651e
testb %r15b, %r15b
je 0x10e70
movq 0x18(%rsp), %rdx
movb $0x1, %r15b
cmpq 0x19c1a(%rip), %rdx # 0x2aa60
jne 0x10e73
testq %rdx, %rdx
je 0x10e70
movq 0x19c04(%rip), %rsi # 0x2aa58
movq 0x10(%rsp), %rdi
callq 0xfa30
testl %eax, %eax
movzbl %r13b, %eax
movl $0x1, %r15d
cmovel %eax, %r15d
jmp 0x10e73
movl %r13d, %r15d
movzbl %bpl, %r13d
testb %bpl, %bpl
je 0x10e87
cmpb $0x0, 0xc(%rsp)
jne 0x10f08
callq 0xf310
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0xf2c0
leaq 0x40(%rsp), %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x14980
movl %eax, %ebx
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x10ebc
callq 0x1651e
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x10ecb
callq 0x1651e
testb %bl, %bl
je 0x10f08
movq 0x18(%rsp), %rdx
cmpq 0x19b45(%rip), %rdx # 0x2aa20
jne 0x10f08
testq %rdx, %rdx
je 0x10f05
movq 0x19b2f(%rip), %rsi # 0x2aa18
movq 0x10(%rsp), %rdi
callq 0xfa30
testl %eax, %eax
movzbl %r15b, %eax
movl $0x1, %r15d
cmovnel %eax, %r15d
jmp 0x10f08
movb $0x1, %r15b
testb %bpl, %bpl
jne 0x10f8b
callq 0xf310
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0xf0a0
leaq 0x40(%rsp), %rdi
movl %r12d, %esi
callq 0x14e70
movl %eax, %ebx
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x10f3f
callq 0x1651e
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x10f4e
callq 0x1651e
testb %bl, %bl
je 0x10f8b
movq 0x18(%rsp), %rdx
cmpq 0x19ae2(%rip), %rdx # 0x2aa40
jne 0x10f8b
testq %rdx, %rdx
je 0x10f88
movq 0x19acc(%rip), %rsi # 0x2aa38
movq 0x10(%rsp), %rdi
callq 0xfa30
testl %eax, %eax
movzbl %r15b, %eax
movl $0x1, %r15d
cmovnel %eax, %r15d
jmp 0x10f8b
movb $0x1, %r15b
testb %bpl, %bpl
je 0x10f9b
cmpb $0x0, 0xc(%rsp)
jne 0x1101c
callq 0xf310
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0xf790
leaq 0x40(%rsp), %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x1538c
movl %eax, %ebx
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x10fd0
callq 0x1651e
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x10fdf
callq 0x1651e
testb %bl, %bl
je 0x1101c
movq 0x18(%rsp), %rdx
cmpq 0x19a71(%rip), %rdx # 0x2aa60
jne 0x1101c
testq %rdx, %rdx
je 0x11019
movq 0x19a5b(%rip), %rsi # 0x2aa58
movq 0x10(%rsp), %rdi
callq 0xfa30
testl %eax, %eax
movzbl %r15b, %eax
movl $0x1, %r15d
cmovnel %eax, %r15d
jmp 0x1101c
movb $0x1, %r15b
movq 0xb0(%rsp), %rdi
callq 0xf970
movl 0x3c(%rsp), %edi
movl 0x38(%rsp), %esi
callq 0xfea0
movl 0x34(%rsp), %edi
movl 0x30(%rsp), %esi
callq 0xf340
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x1105f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xfa10
movl %r15d, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x15cdc
jmp 0x110cf
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x15c94
jmp 0x110e9
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xf990
jmp 0x11100
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x15d00
jmp 0x11117
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x15cb8
jmp 0x1112e
jmp 0x110c1
movq %rax, %r15
movb $0x1, %r13b
jmp 0x1114d
movq %rax, %rbx
movq %rbx, %rdi
callq 0xf3d0
callq 0x10000
jmp 0x10f52
jmp 0x1116c
movq %rax, %rbx
movq %rbx, %rdi
callq 0xf3d0
callq 0x10000
jmp 0x10e37
jmp 0x1116c
movq %rax, %rbx
movq %rbx, %rdi
callq 0xf3d0
callq 0x10000
jmp 0x10db4
jmp 0x1116c
movq %rax, %rbx
movq %rbx, %rdi
callq 0xf3d0
callq 0x10000
jmp 0x10fe3
jmp 0x1116c
movq %rax, %rbx
movq %rbx, %rdi
callq 0xf3d0
callq 0x10000
jmp 0x10ecf
jmp 0x1116c
movq %rax, %r15
movb $0x1, %r13b
jmp 0x11157
movq %rax, %r15
leaq 0x40(%rsp), %rdi
callq 0x15c70
movq %r15, %rdi
callq 0xf3d0
movb $0x1, %r15b
callq 0x10000
jmp 0x10d71
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x1118b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xfa10
movq %rbx, %rdi
callq 0x10160
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfCheckFile.cpp
|
Imf_3_4::checkOpenEXRFile(char const*, unsigned long, bool, bool, bool)
|
bool
checkOpenEXRFile (
const char* data,
size_t numBytes,
bool reduceMemory,
bool reduceTime,
bool runCoreCheck)
{
if (runCoreCheck)
{
return runCoreChecks (data, numBytes, reduceMemory, reduceTime);
}
else
{
PtrIStream stream (data, numBytes);
return runChecks (stream, reduceMemory, reduceTime);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testl %r8d, %r8d
je 0x11292
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x90(%rsp)
movq $0x68, 0x30(%rsp)
movabsq $-0x407fffff00000002, %rax # imm = 0xBF800000FFFFFFFE
movq %rax, 0x88(%rsp)
leaq 0xa8(%rsp), %rax
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq %rax, 0x50(%rsp)
leaq 0x114d(%rip), %rax # 0x1236b
movq %rax, 0x58(%rsp)
leaq 0x1196(%rip), %rax # 0x123c0
movq %rax, 0x60(%rsp)
leaq 0x6aa(%rip), %rax # 0x118e0
movq %rax, 0x38(%rsp)
movl %ebp, %eax
orb %r15b, %al
cmpb $0x1, %al
jne 0x11250
movaps 0xedb5(%rip), %xmm0 # 0x20000
movups %xmm0, 0x78(%rsp)
leaq 0xee8e(%rip), %rsi # 0x200e5
movq %rsp, %rdi
leaq 0x30(%rsp), %rdx
callq 0xfb00
movb $0x1, %r14b
testl %eax, %eax
jne 0x1179d
movq %rsp, %rbx
movq (%rbx), %rdi
movzbl %bpl, %esi
movzbl %r15b, %edx
callq 0x11911
movl %eax, %r14d
movq %rbx, %rdi
callq 0x10130
jmp 0x1179d
leaq 0xee58(%rip), %rsi # 0x200f1
leaq 0xa8(%rsp), %r12
movq %r12, %rdi
callq 0x10230
leaq 0x18328(%rip), %rax # 0x295d8
movq %rax, (%r12)
movq %r14, 0x28(%r12)
movq %r14, 0x30(%r12)
addq %r14, %rbx
movq %rbx, 0x38(%r12)
callq 0xfe90
movq %rax, 0xa0(%rsp)
leaq 0x2c(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x10290
leaq 0x24(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x10290
movl %ebp, %eax
orb %r15b, %al
movl $0x4000, %r14d # imm = 0x4000
cmpb $0x1, %al
jne 0x1131f
movl $0x100000, %edi # imm = 0x100000
callq 0xf970
movl $0x200, %r14d # imm = 0x200
movl $0x800, %edi # imm = 0x800
movl $0x800, %esi # imm = 0x800
callq 0xfea0
movl %r14d, %edi
movl %r14d, %esi
callq 0xf340
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
callq 0xf310
leaq 0x30(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
movl %eax, %edx
movl $0x1, %ecx
callq 0xfd90
movb $0x1, %bl
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0xf460
movq %rax, %rdi
callq 0xf830
movq %rsp, %rdi
movq %rax, %rsi
callq 0xf560
movq %rsp, %rdi
callq 0xf940
testb %al, %al
je 0x113ea
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0xf460
movq %rax, %rdi
callq 0xf210
movl (%rax), %r12d
movl 0x4(%rax), %ebx
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0xf460
movq %rax, %rdi
callq 0xf2d0
movq %rax, %r14
imulq %r12, %rbx
movq 0x8(%rsp), %rdx
cmpq 0x19696(%rip), %rdx # 0x2aa60
jne 0x113e5
testq %rdx, %rdx
je 0x113ee
movq 0x19680(%rip), %rsi # 0x2aa58
movq (%rsp), %rdi
callq 0xfa30
testl %eax, %eax
je 0x113ee
movslq %r14d, %rax
jmp 0x113fe
xorl %ebx, %ebx
jmp 0x1140c
movslq %r14d, %rcx
cmpq $0x5, %rcx
movl $0x4, %eax
cmovaeq %rcx, %rax
imulq %rax, %rbx
cmpq $0xf4241, %rbx # imm = 0xF4241
setae %bl
movzbl %bpl, %esi
movzbl %r15b, %edx
leaq 0x30(%rsp), %rdi
callq 0x126fb
movl %eax, %r14d
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x11430
callq 0x1651e
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x1143f
callq 0x1651e
movzbl %r15b, %r15d
testb %bpl, %bpl
jne 0x11566
leaq 0xa8(%rsp), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x30(%rax)
callq 0xf310
leaq 0x30(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
movl %eax, %edx
callq 0xf8f0
leaq 0x30(%rsp), %rdi
movl %r15d, %esi
callq 0x143f0
movl %eax, %r12d
leaq 0x30(%rsp), %rdi
callq 0xf990
testb %r12b, %r12b
je 0x114cc
movq 0x8(%rsp), %rdx
movb $0x1, %r12b
cmpq 0x195bd(%rip), %rdx # 0x2aa60
jne 0x114cf
testq %rdx, %rdx
je 0x114cc
movq 0x195a7(%rip), %rsi # 0x2aa58
movq (%rsp), %rdi
callq 0xfa30
testl %eax, %eax
movzbl %r14b, %eax
movl $0x1, %r12d
cmovel %eax, %r12d
jmp 0x114cf
movl %r14d, %r12d
leaq 0xa8(%rsp), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x30(%rax)
callq 0xf310
leaq 0x30(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
movl %eax, %edx
callq 0x100b0
leaq 0x30(%rsp), %rdi
movl %r15d, %esi
callq 0x1459f
movl %eax, %r14d
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x11517
callq 0x1651e
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x11526
callq 0x1651e
testb %r14b, %r14b
je 0x11563
movq 0x8(%rsp), %rdx
movb $0x1, %r14b
cmpq 0x19526(%rip), %rdx # 0x2aa60
jne 0x11566
testq %rdx, %rdx
je 0x11563
movq 0x19510(%rip), %rsi # 0x2aa58
movq (%rsp), %rdi
callq 0xfa30
testl %eax, %eax
movzbl %r12b, %eax
movl $0x1, %r14d
cmovel %eax, %r14d
jmp 0x11566
movl %r12d, %r14d
movzbl %bpl, %r12d
testb %bpl, %bpl
je 0x11577
testb %bl, %bl
jne 0x1160e
leaq 0xa8(%rsp), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x30(%rax)
callq 0xf310
leaq 0x30(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
movl %eax, %edx
callq 0xf100
leaq 0x30(%rsp), %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x14980
movl %eax, %r13d
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x115c2
callq 0x1651e
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x115d1
callq 0x1651e
testb %r13b, %r13b
je 0x1160e
movq 0x8(%rsp), %rdx
cmpq 0x1943e(%rip), %rdx # 0x2aa20
jne 0x1160e
testq %rdx, %rdx
je 0x1160b
movq 0x19428(%rip), %rsi # 0x2aa18
movq (%rsp), %rdi
callq 0xfa30
testl %eax, %eax
movzbl %r14b, %eax
movl $0x1, %r14d
cmovnel %eax, %r14d
jmp 0x1160e
movb $0x1, %r14b
testb %bpl, %bpl
jne 0x116ab
leaq 0xa8(%rsp), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x30(%rax)
callq 0xf310
leaq 0x30(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
movl %eax, %edx
callq 0xf5d0
leaq 0x30(%rsp), %rdi
movl %r15d, %esi
callq 0x14e70
movl %eax, %r13d
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x1165f
callq 0x1651e
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x1166e
callq 0x1651e
testb %r13b, %r13b
je 0x116ab
movq 0x8(%rsp), %rdx
cmpq 0x193c1(%rip), %rdx # 0x2aa40
jne 0x116ab
testq %rdx, %rdx
je 0x116a8
movq 0x193ab(%rip), %rsi # 0x2aa38
movq (%rsp), %rdi
callq 0xfa30
testl %eax, %eax
movzbl %r14b, %eax
movl $0x1, %r14d
cmovnel %eax, %r14d
jmp 0x116ab
movb $0x1, %r14b
testb %bpl, %bpl
je 0x116b8
testb %bl, %bl
jne 0x1174e
leaq 0xa8(%rsp), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x30(%rax)
callq 0xf310
leaq 0x30(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
movl %eax, %edx
callq 0xfad0
leaq 0x30(%rsp), %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x1538c
movl %eax, %ebp
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x11702
callq 0x1651e
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x11711
callq 0x1651e
testb %bpl, %bpl
je 0x1174e
movq 0x8(%rsp), %rdx
cmpq 0x1933e(%rip), %rdx # 0x2aa60
jne 0x1174e
testq %rdx, %rdx
je 0x1174b
movq 0x19328(%rip), %rsi # 0x2aa58
movq (%rsp), %rdi
callq 0xfa30
testl %eax, %eax
movzbl %r14b, %eax
movl $0x1, %r14d
cmovnel %eax, %r14d
jmp 0x1174e
movb $0x1, %r14b
movq 0xa0(%rsp), %rdi
callq 0xf970
movl 0x2c(%rsp), %edi
movl 0x28(%rsp), %esi
callq 0xfea0
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
callq 0xf340
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x11790
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xfa10
leaq 0xa8(%rsp), %rdi
callq 0xfec0
movl %r14d, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
leaq 0x30(%rsp), %rdi
callq 0x15cdc
jmp 0x1180c
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x15c94
jmp 0x11826
movq %rax, %r12
leaq 0x30(%rsp), %rdi
callq 0xf990
jmp 0x1183d
movq %rax, %r15
leaq 0x30(%rsp), %rdi
callq 0x15d00
jmp 0x11854
movq %rax, %r13
leaq 0x30(%rsp), %rdi
callq 0x15cb8
jmp 0x1186b
jmp 0x117ff
movq %rax, %r14
movb $0x1, %bl
jmp 0x11889
movq %rax, %r13
movq %r13, %rdi
callq 0xf3d0
callq 0x10000
jmp 0x11673
jmp 0x118a8
movq %rax, %r14
movq %r14, %rdi
callq 0xf3d0
callq 0x10000
jmp 0x1152b
jmp 0x118a8
movq %rax, %r12
movq %r12, %rdi
callq 0xf3d0
callq 0x10000
jmp 0x11494
jmp 0x118a8
movq %rax, %r15
movq %r15, %rdi
callq 0xf3d0
callq 0x10000
jmp 0x11716
jmp 0x118a8
movq %rax, %r13
movq %r13, %rdi
callq 0xf3d0
callq 0x10000
jmp 0x115d6
jmp 0x118a8
movq %rax, %r14
movb $0x1, %bl
jmp 0x11893
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x15c70
movq %r14, %rdi
callq 0xf3d0
movb $0x1, %r14b
callq 0x10000
jmp 0x1143f
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x118cb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xfa10
jmp 0x118cb
movq %rax, %r14
leaq 0xa8(%rsp), %rdi
callq 0xfec0
movq %r14, %rdi
callq 0x10160
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfCheckFile.cpp
|
Imf_3_4::TypedDeepImageChannel<Imath_3_2::half>::resetBasePointer()
|
ImageLevel& level () { return _level; }
|
movq 0x8(%rdi), %rax
movq 0x30(%rdi), %rcx
movslq 0x1c(%rax), %rdx
movslq 0x1c(%rdi), %rsi
imulq %rdx, %rsi
shlq $0x3, %rsi
subq %rsi, %rcx
movslq 0x18(%rax), %rax
shlq $0x3, %rax
subq %rax, %rcx
movq %rcx, 0x38(%rdi)
retq
nop
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfImageChannel.h
|
Imf_3_4::TypedDeepImageChannel<float>::initializeSampleLists()
|
void
TypedDeepImageChannel<T>::initializeSampleLists ()
{
//
// Allocate a new set of sample lists for this channel, and
// construct zero-filled sample lists for the pixels.
//
delete[] _sampleBuffer;
_sampleBuffer = 0; // set to 0 to prevent double deletion
// in case of an exception
const unsigned int* numSamples = sampleCounts ().numSamples ();
const size_t* sampleListPositions = sampleCounts ().sampleListPositions ();
_sampleBuffer = new T[sampleCounts ().sampleBufferSize ()];
resetBasePointer ();
for (size_t i = 0; i < numPixels (); ++i)
{
_sampleListPointers[i] = _sampleBuffer + sampleListPositions[i];
for (unsigned int j = 0; j < numSamples[i]; ++j)
_sampleListPointers[i][j] = T (0);
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x16f42
callq 0xfcd0
movq $0x0, 0x40(%rbx)
movq 0x8(%rbx), %rax
movq 0x88(%rax), %r14
movq 0xa0(%rax), %r15
movq 0xb8(%rax), %rax
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0xf040
movq %rax, 0x40(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
movq 0x28(%rbx), %r12
testq %r12, %r12
je 0x16fcf
xorl %r13d, %r13d
movq (%r15,%r13,8), %rax
shlq $0x2, %rax
addq 0x40(%rbx), %rax
movq 0x30(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
movl (%r14,%r13,4), %edx
testq %rdx, %rdx
je 0x16fc7
movq 0x30(%rbx), %rax
movq (%rax,%r13,8), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0xf5a0
incq %r13
cmpq %r13, %r12
jne 0x16f97
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfDeepImageChannel.cpp
|
Imf_3_4::TypedDeepImageChannel<float>::resize()
|
void
TypedDeepImageChannel<T>::resize ()
{
DeepImageChannel::resize ();
delete[] _sampleListPointers;
_sampleListPointers = 0;
_sampleListPointers = new T*[numPixels ()];
initializeSampleLists ();
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xfbc0
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x16ff1
callq 0xfcd0
movq $0x0, 0x30(%rbx)
movq 0x28(%rbx), %rax
movq %rax, %rcx
shrq $0x3d, %rcx
shlq $0x3, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0xf040
movq %rax, 0x30(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x40(%rax)
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfDeepImageChannel.cpp
|
Imf_3_4::TypedDeepImageChannel<unsigned int>::resize()
|
void
TypedDeepImageChannel<T>::resize ()
{
DeepImageChannel::resize ();
delete[] _sampleListPointers;
_sampleListPointers = 0;
_sampleListPointers = new T*[numPixels ()];
initializeSampleLists ();
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xfbc0
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x1744f
callq 0xfcd0
movq $0x0, 0x30(%rbx)
movq 0x28(%rbx), %rax
movq %rax, %rcx
shrq $0x3d, %rcx
shlq $0x3, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0xf040
movq %rax, 0x30(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x40(%rax)
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfDeepImageChannel.cpp
|
Imf_3_4::loadDeepImage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Imf_3_4::Header&, Imf_3_4::DeepImage&)
|
void
loadDeepImage (const string& fileName, Header& hdr, DeepImage& img)
{
bool tiled, deep, multiPart;
if (!isOpenExrFile (fileName.c_str (), tiled, deep, multiPart))
{
THROW (
ArgExc,
"Cannot load image file " << fileName
<< ". "
"The file is not an OpenEXR file.");
}
if (multiPart)
{
THROW (
ArgExc,
"Cannot load image file "
<< fileName
<< ". "
"Multi-part file loading is not supported.");
}
if (!deep)
{
THROW (
ArgExc,
"Cannot load flat image file " << fileName
<< " "
"as a deep image.");
}
//XXX TODO: the tiled flag obtained above is unreliable;
// open the file as a multi-part file and inspect the header.
// Can the OpenEXR library be fixed?
{
MultiPartInputFile mpi (fileName.c_str ());
tiled =
(mpi.parts () > 0 && mpi.header (0).hasType () &&
isTiled (mpi.header (0).type ()));
}
if (tiled)
loadDeepTiledImage (fileName, hdr, img);
else
loadDeepScanLineImage (fileName, hdr, img);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x5(%rsp), %rsi
leaq 0x7(%rsp), %rdx
leaq 0x6(%rsp), %rcx
callq 0xf770
testb %al, %al
je 0x17cb9
cmpb $0x1, 0x6(%rsp)
je 0x17d39
cmpb $0x0, 0x7(%rsp)
je 0x17db6
movq (%rbx), %r12
callq 0xf310
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movl %eax, %edx
movl $0x1, %ecx
callq 0xf0c0
movq %r13, %rdi
callq 0xff10
testl %eax, %eax
jle 0x17c5f
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0xf460
movq %rax, %rdi
callq 0xf380
testb %al, %al
je 0x17c5f
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0xf460
movq %rax, %rdi
callq 0xf830
movq %rax, %rdi
callq 0xf940
jmp 0x17c61
xorl %eax, %eax
movb %al, 0x5(%rsp)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x17c74
callq 0x1651e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x17c83
callq 0x1651e
cmpb $0x1, 0x5(%rsp)
jne 0x17c9a
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xf090
jmp 0x17ca8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xfac0
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0xfd00
leaq 0x8(%rsp), %rdi
callq 0xf700
leaq 0x18(%rsp), %r14
leaq 0x85b4(%rip), %rsi # 0x20288
movl $0x17, %edx
movq %r14, %rdi
callq 0xfb70
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0xfb70
leaq 0x85a9(%rip), %rsi # 0x202a0
movl $0x23, %edx
movq %rax, %rdi
callq 0xfb70
movl $0x48, %edi
callq 0xf4a0
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x102a0
movq 0x121c3(%rip), %rsi # 0x29ee8
movq 0x1225c(%rip), %rdx # 0x29f88
movq %r14, %rdi
callq 0x10100
jmp 0x17e31
callq 0xfd00
leaq 0x8(%rsp), %rdi
callq 0xf700
leaq 0x18(%rsp), %r14
leaq 0x8534(%rip), %rsi # 0x20288
movl $0x17, %edx
movq %r14, %rdi
callq 0xfb70
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0xfb70
leaq 0x854d(%rip), %rsi # 0x202c4
movl $0x2c, %edx
movq %rax, %rdi
callq 0xfb70
movl $0x48, %edi
callq 0xf4a0
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x102a0
movq 0x12143(%rip), %rsi # 0x29ee8
movq 0x121dc(%rip), %rdx # 0x29f88
movq %r14, %rdi
callq 0x10100
jmp 0x17e31
callq 0xfd00
leaq 0x8(%rsp), %rdi
callq 0xf700
leaq 0x18(%rsp), %r14
leaq 0x8520(%rip), %rsi # 0x202f1
movl $0x1c, %edx
movq %r14, %rdi
callq 0xfb70
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0xfb70
leaq 0x851a(%rip), %rsi # 0x2030e
movl $0x11, %edx
movq %rax, %rdi
callq 0xfb70
movl $0x48, %edi
callq 0xf4a0
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x102a0
movq 0x120c6(%rip), %rsi # 0x29ee8
movq 0x1215f(%rip), %rdx # 0x29f88
movq %r14, %rdi
callq 0x10100
jmp 0x17e35
jmp 0x17e35
movq %rax, %rbx
movq %r14, %rdi
callq 0xf730
jmp 0x17e49
jmp 0x17e46
jmp 0x17e46
movq %rax, %rbx
movq 0x120b0(%rip), %rsi # 0x29f00
leaq 0x8(%rsp), %rdi
callq 0xf760
leaq 0x88(%rsp), %rdi
callq 0xf300
jmp 0x17e76
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x15c70
movq %rbx, %rdi
callq 0x10160
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfDeepImageIO.cpp
|
Imf_3_4::DeepImageLevel::moveSamplesToNewBuffer(unsigned int const*, unsigned int const*, unsigned long const*)
|
void
DeepImageLevel::moveSamplesToNewBuffer (
const unsigned int* oldNumSamples,
const unsigned int* newNumSamples,
const size_t* newSampleListPositions)
{
for (ChannelMap::iterator j = _channels.begin (); j != _channels.end ();
++j)
{
j->second->moveSamplesToNewBuffer (
oldNumSamples, newNumSamples, newSampleListPositions);
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r12
movq 0x40(%rdi), %r13
addq $0x30, %r12
cmpq %r12, %r13
je 0x18c3d
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x40(%r13), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *0x38(%rax)
movq %r13, %rdi
callq 0xf6f0
movq %rax, %r13
cmpq %r12, %rax
jne 0x18c1a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfDeepImageLevel.cpp
|
Imf_3_4::DeepImageLevel::shiftPixels(int, int)
|
void
DeepImageLevel::shiftPixels (int dx, int dy)
{
ImageLevel::shiftPixels (dx, dy);
_sampleCounts.resetBasePointer ();
for (ChannelMap::iterator i = _channels.begin (); i != _channels.end ();
++i)
i->second->resetBasePointer ();
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xf670
leaq 0x58(%rbx), %rdi
callq 0xfa70
movq 0x40(%rbx), %r14
addq $0x30, %rbx
cmpq %rbx, %r14
je 0x18cfe
movq 0x40(%r14), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq %r14, %rdi
callq 0xf6f0
movq %rax, %r14
cmpq %rbx, %rax
jne 0x18ce4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfDeepImageLevel.cpp
|
Imf_3_4::TypedFlatImageChannel<Imath_3_2::half>::resize()
|
void
TypedFlatImageChannel<T>::resize ()
{
delete[] _pixels;
_pixels = 0;
FlatImageChannel::resize (); // may throw an exception
_pixels = new T[numPixels ()];
for (size_t i = 0; i < numPixels (); ++i)
_pixels[i] = T (0);
resetBasePointer ();
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x19eb0
callq 0xfcd0
movq $0x0, 0x30(%rbx)
movq %rbx, %rdi
callq 0xfbc0
movq 0x28(%rbx), %r15
leaq (%r15,%r15), %r14
testq %r15, %r15
movq $-0x1, %rdi
cmovnsq %r14, %rdi
callq 0xf040
movq %rax, 0x30(%rbx)
testq %r15, %r15
je 0x19ef1
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0xf5a0
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x28(%rax)
nop
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfFlatImageChannel.cpp
|
Imf_3_4::TypedFlatImageChannel<unsigned int>::resize()
|
void
TypedFlatImageChannel<T>::resize ()
{
delete[] _pixels;
_pixels = 0;
FlatImageChannel::resize (); // may throw an exception
_pixels = new T[numPixels ()];
for (size_t i = 0; i < numPixels (); ++i)
_pixels[i] = T (0);
resetBasePointer ();
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x1a34e
callq 0xfcd0
movq $0x0, 0x30(%rbx)
movq %rbx, %rdi
callq 0xfbc0
movq 0x28(%rbx), %r15
movq %r15, %rax
shrq $0x3e, %rax
leaq (,%r15,4), %r14
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r14, %rdi
callq 0xf040
movq %rax, 0x30(%rbx)
testq %r15, %r15
je 0x1a397
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0xf5a0
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x28(%rax)
nop
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfFlatImageChannel.cpp
|
Imf_3_4::saveFlatTiledImage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Imf_3_4::Header const&, Imf_3_4::FlatImage const&, Imf_3_4::DataWindowSource)
|
void
saveFlatTiledImage (
const string& fileName,
const Header& hdr,
const FlatImage& img,
DataWindowSource dws)
{
Header newHdr;
for (Header::ConstIterator i = hdr.begin (); i != hdr.end (); ++i)
{
if (strcmp (i.name (), "dataWindow") && strcmp (i.name (), "tiles") &&
strcmp (i.name (), "channels"))
{
newHdr.insert (i.name (), i.attribute ());
}
}
if (hdr.hasTileDescription ())
{
newHdr.setTileDescription (TileDescription (
hdr.tileDescription ().xSize,
hdr.tileDescription ().ySize,
img.levelMode (),
img.levelRoundingMode ()));
}
else
{
newHdr.setTileDescription (TileDescription (
64, // xSize
64, // ySize
img.levelMode (),
img.levelRoundingMode ()));
}
newHdr.dataWindow () = dataWindowForFile (hdr, img, dws);
const FlatImageLevel& level = img.level (0, 0);
for (FlatImageLevel::ConstIterator i = level.begin (); i != level.end ();
++i)
newHdr.channels ().insert (i.name (), i.channel ().channel ());
TiledOutputFile out (fileName.c_str (), newHdr);
switch (img.levelMode ())
{
case ONE_LEVEL: saveLevel (out, img, 0, 0); break;
case MIPMAP_LEVELS:
for (int x = 0; x < out.numLevels (); ++x)
saveLevel (out, img, x, x);
break;
case RIPMAP_LEVELS:
for (int y = 0; y < out.numYLevels (); ++y)
for (int x = 0; x < out.numXLevels (); ++x)
saveLevel (out, img, x, y);
break;
default: assert (false);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, 0x24(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, 0x28(%rsp)
movq %rsp, %rcx
movq $0x0, (%rcx)
leaq 0x30(%rsp), %rdi
movss 0x5dff(%rip), %xmm0 # 0x20284
movl $0x40, %esi
movl $0x40, %edx
movaps %xmm0, %xmm1
xorl %r8d, %r8d
movl $0x3, %r9d
callq 0xf5f0
movq %r15, %rdi
callq 0xf8b0
movq %rax, %r12
leaq 0x5e6e(%rip), %r13 # 0x20320
leaq 0x5e72(%rip), %r14 # 0x2032b
movq %r15, %rdi
callq 0xf3e0
cmpq %rax, %r12
je 0x1a51e
leaq 0x20(%r12), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0xfda0
testl %eax, %eax
je 0x1a511
movq %rbp, %rdi
movq %r14, %rsi
callq 0xfda0
testl %eax, %eax
je 0x1a511
movq %rbp, %rdi
leaq 0x5e3e(%rip), %rsi # 0x20331
callq 0xfda0
testl %eax, %eax
je 0x1a511
movq 0x120(%r12), %rdx
leaq 0x30(%rsp), %rdi
movq %rbp, %rsi
callq 0xf4f0
movq %r12, %rdi
callq 0xfbb0
movq %rax, %r12
jmp 0x1a4b9
movq %r15, %rdi
callq 0xf8c0
testb %al, %al
je 0x1a56f
movq %r15, %rdi
callq 0xf210
movl (%rax), %r14d
movq %r15, %rdi
callq 0xf210
movl 0x4(%rax), %r12d
movq %rbx, %rdi
callq 0xffa0
movl %eax, %ebp
movq %rbx, %rdi
callq 0xf4c0
movq %rsp, %rsi
movl %r14d, (%rsi)
movl %r12d, 0x4(%rsi)
movl %ebp, 0x8(%rsi)
movl %eax, 0xc(%rsi)
leaq 0x30(%rsp), %rdi
callq 0xfd30
jmp 0x1a5a1
movq %rbx, %rdi
callq 0xffa0
movl %eax, %ebp
movq %rbx, %rdi
callq 0xf4c0
movabsq $0x4000000040, %rcx # imm = 0x4000000040
movq %rsp, %rsi
movq %rcx, (%rsi)
movl %ebp, 0x8(%rsi)
movl %eax, 0xc(%rsi)
leaq 0x30(%rsp), %rdi
callq 0xfd30
movq %rsp, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl 0x24(%rsp), %ecx
callq 0xf4e0
leaq 0x30(%rsp), %rdi
callq 0xfdd0
movq (%rsp), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq *0x30(%rax)
movq %rax, %r15
movq %rax, %rdi
callq 0x100a0
movq %rax, %r14
leaq 0x30(%rsp), %r12
movq %rsp, %r13
movq %r15, %rdi
callq 0xfd10
cmpq %rax, %r14
je 0x1a63d
movq %r12, %rdi
callq 0x10050
movq %rax, %rbp
movq 0x40(%r14), %rdi
callq 0xf500
leaq 0x20(%r14), %rsi
movq %rax, (%rsp)
movl %edx, 0x8(%rsp)
shrq $0x20, %rdx
movb %dl, 0xc(%rsp)
movq %rbp, %rdi
movq %r13, %rdx
callq 0xf0f0
movq %r14, %rdi
callq 0xfbb0
movq %rax, %r14
jmp 0x1a5f0
movq 0x28(%rsp), %rax
movq (%rax), %r14
callq 0xf310
movq %rsp, %rdi
leaq 0x30(%rsp), %rdx
movq %r14, %rsi
movl %eax, %ecx
callq 0xfb20
movq %rbx, %rdi
callq 0xffa0
testl %eax, %eax
je 0x1a6d0
cmpl $0x1, %eax
je 0x1a6ac
cmpl $0x2, %eax
jne 0x1a6df
xorl %ebp, %ebp
movq %rsp, %r14
movq %r14, %rdi
callq 0x10120
cmpl %eax, %ebp
jge 0x1a6df
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x102e0
cmpl %eax, %r15d
jge 0x1a6a8
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0x1b2fe
incl %r15d
jmp 0x1a686
incl %ebp
jmp 0x1a677
xorl %ebp, %ebp
movq %rsp, %r14
movq %r14, %rdi
callq 0xfcf0
cmpl %eax, %ebp
jge 0x1a6df
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %ebp, %ecx
callq 0x1b2fe
incl %ebp
jmp 0x1a6b1
movq %rsp, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1b2fe
movq %rsp, %rdi
callq 0x10330
leaq 0x30(%rsp), %rdi
callq 0xff30
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1a71e
jmp 0x1a71e
jmp 0x1a71e
jmp 0x1a71e
jmp 0x1a723
jmp 0x1a71e
jmp 0x1a71e
jmp 0x1a71e
jmp 0x1a71e
jmp 0x1a71e
jmp 0x1a723
jmp 0x1a723
jmp 0x1a71e
jmp 0x1a71e
jmp 0x1a71e
movq %rax, %rbx
jmp 0x1a72e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x10330
leaq 0x30(%rsp), %rdi
callq 0xff30
movq %rbx, %rdi
callq 0x10160
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfFlatImageIO.cpp
|
Imf_3_4::FlatImageLevel::channel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
FlatImageChannel&
FlatImageLevel::channel (const string& name)
{
ChannelMap::iterator i = _channels.find (name);
if (i == _channels.end ()) throwBadChannelName (name);
return *i->second;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x28, %rdi
callq 0xfd70
movq %rax, %r15
leaq 0x30(%r14), %rax
cmpq %rax, %r15
jne 0x1b99f
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfb40
movq 0x40(%r15), %rax
popq %rbx
popq %r14
popq %r15
retq
nop
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfFlatImageLevel.cpp
|
Imf_3_4::Image::Image()
|
Image::Image ()
: _dataWindow (Box2i (V2i (0, 0), V2i (-1, -1)))
, _levelMode (ONE_LEVEL)
, _levelRoundingMode (ROUND_DOWN)
, _channels ()
, _levels ()
{
// empty
}
|
movq 0xdbf9(%rip), %rax # 0x29fd0
addq $0x10, %rax
movq %rax, (%rdi)
movaps 0x3ddb(%rip), %xmm0 # 0x201c0
movups %xmm0, 0x8(%rdi)
leaq 0x28(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movq %rax, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
retq
nop
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfImage.cpp
|
Imf_3_4::Image::eraseChannel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
void
Image::eraseChannel (const std::string& name)
{
//
// Note: eraseChannel() is called to clean up if an exception is
// thrown during a call during insertChannel(), so eraseChannel()
// must work correctly even after an incomplete insertChannel()
// operation.
//
for (int y = 0; y < _levels.height (); ++y)
for (int x = 0; x < _levels.width (); ++x)
if (_levels[y][x]) _levels[y][x]->eraseChannel (name);
ChannelMap::iterator i = _channels.find (name);
if (i != _channels.end ()) _channels.erase (i);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x50(%rdi)
jle 0x1d02f
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x58(%rbx), %rax
testq %rax, %rax
jle 0x1d022
xorl %r13d, %r13d
imulq %r15, %rax
addq 0x60(%rbx), %rax
movq (%rax,%r13,8), %rdi
testq %rdi, %rdi
je 0x1d016
movq (%rdi), %rax
movq %r14, %rsi
callq *0x28(%rax)
incq %r13
movq 0x58(%rbx), %rax
cmpq %r13, %rax
jg 0x1cffc
incq %r12
addq $0x8, %r15
cmpq %r12, 0x50(%rbx)
jg 0x1cff0
leaq 0x20(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1deb2
addq $0x28, %rbx
cmpq %rbx, %rax
je 0x1d05b
movq %r15, %rdi
movq %rax, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1def8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfImage.cpp
|
void Imf_3_4::renameChannelsInMap<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Imf_3_4::Image::ChannelInfo, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Imf_3_4::Image::ChannelInfo>>>>(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Imf_3_4::Image::ChannelInfo, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Imf_3_4::Image::ChannelInfo>>>&)
|
inline void
renameChannelsInMap (const RenamingMap& oldToNewNames, ChannelMap& channels)
{
ChannelMap renamedChannels;
for (typename ChannelMap::const_iterator i = channels.begin ();
i != channels.end ();
++i)
{
RenamingMap::const_iterator j = oldToNewNames.find (i->first);
std::string newName = (j == oldToNewNames.end ()) ? i->first
: j->second;
renamedChannels[newName] = i->second;
}
channels = renamedChannels;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x40(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq 0x18(%rsi), %r15
movq %rsi, 0x10(%rsp)
leaq 0x8(%rsi), %rbx
cmpq %rbx, %r15
je 0x1d9fd
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %r14
leaq 0x28(%rsp), %r13
leaq 0x18(%rsp), %r12
leaq 0x20(%r15), %rbp
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0xff40
leaq 0x40(%rax), %rcx
cmpq %r14, %rax
cmoveq %rbp, %rcx
movq %r13, 0x18(%rsp)
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0xf3c0
leaq 0x38(%rsp), %rdi
movq %r12, %rsi
callq 0x1d8b2
movq 0x40(%r15), %rcx
movq 0x45(%r15), %rdx
movq %rdx, 0x5(%rax)
movq %rcx, (%rax)
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x1d9ed
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xfa10
movq %r15, %rdi
callq 0xfbb0
movq %rax, %r15
cmpq %rbx, %rax
jne 0x1d987
leaq 0x38(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x1e192
leaq 0x38(%rsp), %rdi
callq 0x1da5a
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1da29
jmp 0x1da29
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x1da5a
movq %rbx, %rdi
callq 0x10160
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x1da2c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xfa10
jmp 0x1da2c
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfImageChannelRenaming.h
|
Imf_3_4::loadImage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Imf_3_4::Header&)
|
Image*
loadImage (const string& fileName, Header& hdr)
{
bool tiled, deep, multiPart;
if (!isOpenExrFile (fileName.c_str (), tiled, deep, multiPart))
{
THROW (
ArgExc,
"Cannot load image file " << fileName
<< ". "
"The file is not an OpenEXR file.");
}
if (multiPart)
{
THROW (
ArgExc,
"Cannot load image file "
<< fileName
<< ". "
"Multi-part file loading is not supported.");
}
//XXX TODO: the tiled flag obtained above is unreliable;
// open the file as a multi-part file and inspect the header.
// Can the OpenEXR library be fixed?
{
MultiPartInputFile mpi (fileName.c_str ());
tiled =
(mpi.parts () > 0 && mpi.header (0).hasType () &&
isTiled (mpi.header (0).type ()));
}
Image* img = 0;
try
{
if (deep)
{
DeepImage* dimg = new DeepImage;
img = dimg;
if (tiled)
loadDeepTiledImage (fileName, hdr, *dimg);
else
loadDeepScanLineImage (fileName, hdr, *dimg);
}
else
{
FlatImage* fimg = new FlatImage;
img = fimg;
if (tiled)
loadFlatTiledImage (fileName, hdr, *fimg);
else
loadFlatScanLineImage (fileName, hdr, *fimg);
}
}
catch (...)
{
delete img;
throw;
}
return img;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xd(%rsp), %rsi
leaq 0xf(%rsp), %rdx
leaq 0xe(%rsp), %rcx
callq 0xf770
testb %al, %al
je 0x1ec69
cmpb $0x1, 0xe(%rsp)
je 0x1ece9
movq (%rbx), %r15
callq 0xf310
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movl %eax, %edx
movl $0x1, %ecx
callq 0xf0c0
movq %r12, %rdi
callq 0xff10
testl %eax, %eax
jle 0x1eba4
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0xf460
movq %rax, %rdi
callq 0xf380
testb %al, %al
je 0x1eba4
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0xf460
movq %rax, %rdi
callq 0xf830
movq %rax, %rdi
callq 0xf940
jmp 0x1eba6
xorl %eax, %eax
movb %al, 0xd(%rsp)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1ebb9
callq 0x1651e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1ebc8
callq 0x1651e
cmpb $0x1, 0xf(%rsp)
jne 0x1ec01
xorl %r12d, %r12d
movl $0x68, %edi
callq 0xf9d0
movq %rax, %r15
movq %rax, %rdi
callq 0x10340
cmpb $0x1, 0xd(%rsp)
jne 0x1ec33
movq %r15, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xf090
jmp 0x1ec57
xorl %r12d, %r12d
movl $0x68, %edi
callq 0xf9d0
movq %rax, %r15
movq %rax, %rdi
callq 0xffe0
cmpb $0x1, 0xd(%rsp)
jne 0x1ec46
movq %r15, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xfb80
jmp 0x1ec57
movq %r15, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xfac0
jmp 0x1ec57
movq %r15, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xf0e0
movq %r15, %rax
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xfd00
leaq 0x10(%rsp), %rdi
callq 0xf700
leaq 0x20(%rsp), %r14
leaq 0x1604(%rip), %rsi # 0x20288
movl $0x17, %edx
movq %r14, %rdi
callq 0xfb70
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0xfb70
leaq 0x15f9(%rip), %rsi # 0x202a0
movl $0x23, %edx
movq %rax, %rdi
callq 0xfb70
movl $0x48, %edi
callq 0xf4a0
movq %rax, %r14
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x102a0
movq 0xb213(%rip), %rsi # 0x29ee8
movq 0xb2ac(%rip), %rdx # 0x29f88
movq %r14, %rdi
callq 0x10100
jmp 0x1edd2
callq 0xfd00
leaq 0x10(%rsp), %rdi
callq 0xf700
leaq 0x20(%rsp), %r14
leaq 0x1584(%rip), %rsi # 0x20288
movl $0x17, %edx
movq %r14, %rdi
callq 0xfb70
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0xfb70
leaq 0x159d(%rip), %rsi # 0x202c4
movl $0x2c, %edx
movq %rax, %rdi
callq 0xfb70
movl $0x48, %edi
callq 0xf4a0
movq %rax, %r14
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x102a0
movq 0xb193(%rip), %rsi # 0x29ee8
movq 0xb22c(%rip), %rdx # 0x29f88
movq %r14, %rdi
callq 0x10100
jmp 0x1edd2
jmp 0x1ed68
movq %rax, %rbx
movq %r14, %rdi
callq 0xf730
jmp 0x1ed91
jmp 0x1ed77
movq %rax, %rbx
movl $0x68, %esi
movq %r15, %rdi
callq 0xfa10
xorl %r12d, %r12d
jmp 0x1edb6
jmp 0x1ed8e
movq %rax, %rbx
movq 0xb168(%rip), %rsi # 0x29f00
leaq 0x10(%rsp), %rdi
callq 0xf760
leaq 0x90(%rsp), %rdi
callq 0xf300
jmp 0x1edf1
jmp 0x1edb3
movq %rax, %rbx
movq %rbx, %rdi
callq 0xf3d0
testq %r12, %r12
je 0x1edcd
movq (%r12), %rax
movq %r12, %rdi
callq *0x8(%rax)
callq 0xfe30
movq %rax, %rbx
callq 0x10000
jmp 0x1edf1
movq %rax, %rdi
callq 0x15c65
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x15c70
movq %rbx, %rdi
callq 0x10160
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfImageIO.cpp
|
Imf_3_4::ImageLevel::throwBadChannelNameOrType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
|
void
ImageLevel::throwBadChannelNameOrType (const string& name) const
{
THROW (
ArgExc,
"Image channel \"" << name
<< "\" does not exist "
"or is not of the expected type.");
}
|
pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %rbx
callq 0xfd00
movq %rsp, %rdi
callq 0xf700
leaq 0x10(%rsp), %r14
leaq 0x19d6(%rip), %rsi # 0x20b70
movl $0xf, %edx
movq %r14, %rdi
callq 0xfb70
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0xfb70
leaq 0x19c3(%rip), %rsi # 0x20b80
movl $0x30, %edx
movq %rax, %rdi
callq 0xfb70
movl $0x48, %edi
callq 0xf4a0
movq %rax, %r14
movq %rsp, %rsi
movq %rax, %rdi
callq 0x102a0
movq 0xacff(%rip), %rsi # 0x29ee8
movq 0xad98(%rip), %rdx # 0x29f88
movq %r14, %rdi
callq 0x10100
movq %rax, %rbx
movq %r14, %rdi
callq 0xf730
jmp 0x1f208
movq %rax, %rbx
movq 0xacf1(%rip), %rsi # 0x29f00
movq %rsp, %rdi
callq 0xf760
leaq 0x80(%rsp), %rdi
callq 0xf300
movq %rbx, %rdi
callq 0x10160
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfImageLevel.cpp
|
slab_assert
|
static inline void
slab_assert(struct slab_cache *cache, struct slab *slab)
{
(void) slab;
assert(pthread_equal(cache->thread_id, pthread_self()));
assert(slab->magic == slab_magic);
assert(slab->order <= cache->order_max + 1);
if (slab->order <= cache->order_max) {
size_t size = slab_order_size(cache, slab->order);
(void) size;
assert(slab->size == size);
intptr_t addr = (intptr_t) slab;
(void) addr;
assert(addr == (intptr_t) (addr & ~(size - 1)));
}
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x250(%rdi), %r15
callq 0x2170
movq %r15, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
je 0x353e
cmpl $0xeec0ffee, 0x28(%rbx) # imm = 0xEEC0FFEE
jne 0x3557
movzbl 0x2c(%rbx), %eax
movzbl 0xd(%r14), %ecx
leal 0x1(%rcx), %edx
cmpl %eax, %edx
jb 0x3570
cmpb %cl, %al
ja 0x3533
movzbl %al, %esi
movq %r14, %rdi
callq 0x3df3
cmpq %rax, 0x20(%rbx)
jne 0x3589
decq %rax
testq %rbx, %rax
jne 0x35a2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25b4(%rip), %rdi # 0x5af9
leaq 0x2182(%rip), %rsi # 0x56ce
leaq 0x25d6(%rip), %rcx # 0x5b29
pushq $0x42
jmp 0x35b9
leaq 0x2600(%rip), %rdi # 0x5b5e
leaq 0x2169(%rip), %rsi # 0x56ce
leaq 0x25bd(%rip), %rcx # 0x5b29
pushq $0x43
jmp 0x35b9
leaq 0x2601(%rip), %rdi # 0x5b78
leaq 0x2150(%rip), %rsi # 0x56ce
leaq 0x25a4(%rip), %rcx # 0x5b29
pushq $0x44
jmp 0x35b9
leaq 0x260c(%rip), %rdi # 0x5b9c
leaq 0x2137(%rip), %rsi # 0x56ce
leaq 0x258b(%rip), %rcx # 0x5b29
pushq $0x48
jmp 0x35b9
leaq 0x2606(%rip), %rdi # 0x5baf
leaq 0x211e(%rip), %rsi # 0x56ce
leaq 0x2572(%rip), %rcx # 0x5b29
pushq $0x4b
popq %rdx
callq 0x20a0
|
/tarantool[P]small/small/slab_cache.c
|
clog::AsyncLogger::start()
|
void AsyncLogger::start()
{
running_ = true;
thread_ = std::thread([this](){ this->threadFunc(); });
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movb $0x1, 0x4(%rdi)
leaq 0x10(%rsp), %r14
movq $0x0, (%r14)
movl $0x10, %edi
callq 0x41d0
leaq 0x65f1(%rip), %rcx # 0xad38
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
xorl %edx, %edx
callq 0x41b0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4770
movq (%rdi), %rax
callq *0x8(%rax)
cmpq $0x0, 0x8(%rbx)
jne 0x4788
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x4070
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x47a0
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x42d0
nop
|
/bigYellowDuck[P]clog/AsyncLogger.cpp
|
main
|
int main(int argc, char **argv)
{
char *URL;
int result;
#ifdef O_BINARY
# ifdef __HIGHC__
_setmode(stdout, O_BINARY);
# else
setmode(fileno(stdout), O_BINARY);
# endif
#endif
memory_tracking_init();
/*
* Setup proper locale from environment. This is needed to enable locale-
* specific behaviour by the C library in order to test for undesired side
* effects that could cause in libcurl.
*/
#ifdef HAVE_SETLOCALE
setlocale(LC_ALL, "");
#endif
if(argc< 2) {
fprintf(stderr, "Pass URL as argument please\n");
return 1;
}
test_argc = argc;
test_argv = argv;
if(argc>2)
libtest_arg2 = argv[2];
if(argc>3)
libtest_arg3 = argv[3];
URL = argv[1]; /* provide this to the rest */
fprintf(stderr, "URL: %s\n", URL);
result = test(URL);
#ifdef USE_NSS
if(PR_Initialized())
/* prevent valgrind from reporting possibly lost memory (fd cache, ...) */
PR_Cleanup();
#endif
return result;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x1718
movl $0x6, %edi
leaq 0xa8a(%rip), %rsi # 0x21ae
callq 0x1090
cmpl $0x2, -0x8(%rbp)
jge 0x1750
movq 0x28aa(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0xa75(%rip), %rsi # 0x21b5
movb $0x0, %al
callq 0x10c0
movl $0x1, -0x4(%rbp)
jmp 0x17c8
movl -0x8(%rbp), %eax
movl %eax, 0x2bc3(%rip) # 0x431c
movq -0x10(%rbp), %rax
movq %rax, 0x2bbc(%rip) # 0x4320
cmpl $0x2, -0x8(%rbp)
jle 0x1779
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2937(%rip) # 0x40b0
cmpl $0x3, -0x8(%rbp)
jle 0x178e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x292a(%rip) # 0x40b8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq 0x283f(%rip), %rax # 0x3fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0xa23(%rip), %rsi # 0x21d2
movb $0x0, %al
callq 0x10c0
movq -0x18(%rbp), %rdi
callq 0x1210
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
|
/komeilkma[P]curl/tests/libtest/first.c
|
spdlog::details::T_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&)
|
void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
{
const size_t field_size = 8;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_hour, dest);
dest.push_back(':');
fmt_helper::pad2(tm_time.tm_min, dest);
dest.push_back(':');
fmt_helper::pad2(tm_time.tm_sec, dest);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r14
leaq 0x8(%rdi), %rdx
leaq 0x18(%rsp), %rdi
movl $0x8, %esi
callq 0x3d0ca
movl 0x8(%r14), %r15d
cmpq $0x63, %r15
ja 0x3f090
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x3f031
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl $0xcccccccd, %r12d # imm = 0xCCCCCCCD
imulq %r15, %r12
shrq $0x23, %r12
movl %r12d, %eax
orb $0x30, %al
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10(%rbx)
movb %al, (%rcx,%rdx)
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x3f06c
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
addl %r12d, %r12d
leal (%r12,%r12,4), %eax
subl %eax, %r15d
orb $0x30, %r15b
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb %r15b, (%rax,%rcx)
jmp 0x3f0d2
movq %rsp, %r8
movq %r15, (%r8)
movq 0x10(%rbx), %rax
leaq 0x40(%rsp), %rdi
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
leaq 0x9488a(%rip), %rax # 0xd3938
addq $0x10, %rax
movq %rax, (%rdi)
movq %rbx, 0x20(%rdi)
leaq 0x5c9b9(%rip), %rsi # 0x9ba79
movl $0x5, %edx
movl $0x1, %ecx
xorl %r9d, %r9d
callq 0x21205
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x3f0e7
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb $0x3a, (%rax,%rcx)
movl 0x4(%r14), %r15d
cmpq $0x63, %r15
ja 0x3f179
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x3f11a
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl $0xcccccccd, %r12d # imm = 0xCCCCCCCD
imulq %r15, %r12
shrq $0x23, %r12
movl %r12d, %eax
orb $0x30, %al
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10(%rbx)
movb %al, (%rcx,%rdx)
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x3f155
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
addl %r12d, %r12d
leal (%r12,%r12,4), %eax
subl %eax, %r15d
orb $0x30, %r15b
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb %r15b, (%rax,%rcx)
jmp 0x3f1bb
movq %rsp, %r8
movq %r15, (%r8)
movq 0x10(%rbx), %rax
leaq 0x40(%rsp), %rdi
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
leaq 0x947a1(%rip), %rax # 0xd3938
addq $0x10, %rax
movq %rax, (%rdi)
movq %rbx, 0x20(%rdi)
leaq 0x5c8d0(%rip), %rsi # 0x9ba79
movl $0x5, %edx
movl $0x1, %ecx
xorl %r9d, %r9d
callq 0x21205
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x3f1d0
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb $0x3a, (%rax,%rcx)
movl (%r14), %r14d
cmpq $0x63, %r14
ja 0x3f261
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x3f202
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl $0xcccccccd, %r15d # imm = 0xCCCCCCCD
imulq %r14, %r15
shrq $0x23, %r15
movl %r15d, %eax
orb $0x30, %al
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10(%rbx)
movb %al, (%rcx,%rdx)
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x3f23d
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
addl %r15d, %r15d
leal (%r15,%r15,4), %eax
subl %eax, %r14d
orb $0x30, %r14b
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb %r14b, (%rax,%rcx)
jmp 0x3f2a3
movq %rsp, %r8
movq %r14, (%r8)
movq 0x10(%rbx), %rax
leaq 0x40(%rsp), %rdi
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
leaq 0x946b9(%rip), %rax # 0xd3938
addq $0x10, %rax
movq %rax, (%rdi)
movq %rbx, 0x20(%rdi)
leaq 0x5c7e8(%rip), %rsi # 0x9ba79
movl $0x5, %edx
movl $0x1, %ecx
xorl %r9d, %r9d
callq 0x21205
leaq 0x18(%rsp), %rdi
callq 0x3d13e
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3f2bd
jmp 0x3f2bd
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x3d13e
movq %rbx, %rdi
callq 0x17b40
|
/njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h
|
opts::BasicOption::parse(int, char**, int&, int, std::function<bool (char)>)
|
bool
BasicOption::parse(int argc, char** argv, int& i, int j, IsShort is_short)
{
char* argument;
char* cur_arg = argv[i];
// -v...
if (argv[i][j] == '\0')
{
// -v data
if (i + 1 < argc && (argv[i+1][0] != '-' || Options::dashed_non_option(argv[i+1], is_short)))
{
++i;
argument = argv[i];
} else
{
std::cerr << "error: cannot find the argument; ignoring " << argv[i] << '\n';
return false;
}
} else if (argv[i][j] == '=')
{
// -v=data
argument = &argv[i][j+1];
} else if( j == 2 ) { // only for short options
// -vdata
argument = &argv[i][j];
} else
{
std::cerr << "error: unexpected character \'" << argv[i][j] << "\' ignoring " << argv[i] << '\n';
return false;
}
bool result = set(argument);
if (!result)
std::cerr << "error: failed to parse " << argument << " in " << cur_arg << '\n';
return result;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdi, %r12
movslq (%rcx), %rcx
movq (%rdx,%rcx,8), %rbx
movslq %r8d, %rbp
leaq (%rbx,%rbp), %r13
movzbl (%rbx,%rbp), %eax
cmpl $0x3d, %eax
je 0x6ea5
movq %rdx, %r14
testl %eax, %eax
jne 0x6eaa
leaq 0x1(%rcx), %rax
cmpl %esi, %eax
jge 0x6f1d
movq 0x8(%r14,%rcx,8), %r13
cmpb $0x2d, (%r13)
jne 0x6e9c
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
movq %r9, %rsi
callq 0x7dfc
movq %r13, %rdi
movq %rbp, %rsi
callq 0x7dc8
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x251b0
testb %bpl, %bpl
je 0x6f1d
movslq (%r15), %rax
incq %rax
movl %eax, (%r15)
movq (%r14,%rax,8), %r13
jmp 0x6eb0
incq %r13
jmp 0x6eb0
cmpl $0x2, %r8d
jne 0x6f2d
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r13, %rsi
callq 0x7e42
movq (%r12), %rax
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq *0x20(%rax)
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x6230
movb $0x1, %al
testb %bpl, %bpl
jne 0x6f7e
movq 0x3a0f9(%rip), %rdi # 0x40fe8
leaq 0x21407(%rip), %rsi # 0x282fd
callq 0x6420
movq %rax, %rdi
movq %r13, %rsi
callq 0x6420
leaq 0x22d45(%rip), %rsi # 0x29c52
movq %rax, %rdi
callq 0x6420
movq %rax, %rdi
movq %rbx, %rsi
jmp 0x6f6c
movq 0x3a0c4(%rip), %rdi # 0x40fe8
leaq 0x2137d(%rip), %rsi # 0x282a8
jmp 0x6f5d
movq 0x3a0b4(%rip), %rdi # 0x40fe8
leaq 0x21398(%rip), %rsi # 0x282d3
callq 0x6420
movslq (%r15), %rcx
movq (%r14,%rcx,8), %rcx
movsbl (%rcx,%rbp), %esi
movq %rax, %rdi
callq 0x64e0
leaq 0x21397(%rip), %rsi # 0x282f1
movq %rax, %rdi
callq 0x6420
movslq (%r15), %rcx
movq (%r14,%rcx,8), %rsi
movq %rax, %rdi
callq 0x6420
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x64e0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x251b0
jmp 0x6fae
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6230
jmp 0x6fae
movq %rax, %rbx
movq %rbx, %rdi
callq 0x67d0
|
/diatomic[P]diy/examples/opts.h
|
opts::Options::parse(int, char**)
|
bool
Options::parse(int argc, char** argv)
{
std::map<char, BasicOption*> short_opts;
std::map<std::string, BasicOption*> long_opts;
for (auto& opt : options)
{
if (opt->s)
short_opts[opt->s] = opt.get();
long_opts[opt->l] = opt.get();
}
auto is_short = [&short_opts](char c) -> bool { return short_opts.find(c) != short_opts.end(); };
for (int i = 1; i < argc; ++i)
{
if( argv[ i ][ 0 ] == '\0' )
continue;
if( argv[ i ][ 0 ] != '-' || dashed_non_option(argv[i], is_short))
args.push_back(argv[i]);
else
{
// -...
if( argv[ i ][ 1 ] == '\0' )
{
// -
args.push_back(argv[i]);
} else if( argv[ i ][ 1 ] == '-' )
{
if( argv[ i ][ 2 ] == '\0' )
{
// --
while( ++i < argc )
args.push_back(argv[i]);
} else {
// --...
char* first = &argv[ i ][ 2 ];
char* last = first;
for(; *last != '=' && *last != '\0'; ++last);
if (first == last)
{
failed = true;
unrecognized_option(argv[i]);
} else
{
auto opt_it = long_opts.find(std::string{first,last});
if (opt_it == long_opts.end())
{
failed = true;
unrecognized_option(argv[i]);
} else
{
failed |= !opt_it->second->parse(argc, argv, i, static_cast<int>(last - argv[i]), is_short);
}
}
}
} else
{
// -f...
auto opt_it = short_opts.find(argv[i][1]);
if (opt_it == short_opts.end())
{
failed = true;
unrecognized_option(argv[i]);
} else if (opt_it->second->flag())
{
opt_it->second->parse(argc, argv, i, 0, is_short); // arguments are meaningless; just sets the flag
// -fgh
char c;
for(int j = 1; (c = argv[i][j]) != '\0'; ++j)
{
if (!std::isprint(c) || c == '-')
{
failed = true;
std::cerr << "error: invalid character\'" << c << " ignoring " << &argv[i][j] << '\n';
break;
}
opt_it = short_opts.find(c);
if (opt_it == short_opts.end())
{
failed = true;
unrecognized_option("-" + std::string(1, c));
continue;
}
if (!opt_it->second->flag())
{
failed = true;
std::cerr << "error: non-void options not allowed in option packs; ignoring " << c << '\n';
continue;
}
opt_it->second->parse(argc, argv, i, 0, is_short); // arguments are meaningless; just sets the flag
}
} else
{
failed |= !opt_it->second->parse(argc, argv, i, 2, is_short);
}
}
}
}
return !failed;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdx, %rbx
movl %esi, 0x14(%rsp)
movq %rdi, %r14
leaq 0x40(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x110(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x18(%rdi), %r12
leaq 0x108(%rsp), %r15
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x7057
movq %r14, %rbp
movq 0x10(%r13), %r14
cmpb $0x0, 0x8(%r14)
je 0x7043
leaq 0x8(%r14), %rsi
leaq 0x38(%rsp), %rdi
callq 0x7e7e
movq %r14, (%rax)
movq 0x10(%r13), %r14
leaq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x7ecc
movq %r14, (%rax)
movq %rbp, %r14
jmp 0x7017
pushq $0x1
popq %rax
leaq 0xf(%rsp), %r12
movl 0x14(%rsp), %ebp
movl %eax, 0x10(%rsp)
cmpl %ebp, %eax
jge 0x75e6
cltq
movq (%rbx,%rax,8), %r15
movzbl (%r15), %eax
testl %eax, %eax
je 0x7116
cmpl $0x2d, %eax
jne 0x70f0
movq %r12, %r13
andq $0x0, 0xf0(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, 0xe8(%rsp)
leaq 0xca4(%rip), %rax # 0x7d4a
movq %rax, 0x100(%rsp)
leaq 0xcc1(%rip), %rax # 0x7d76
movq %rax, 0xf8(%rsp)
movq %r15, %rdi
leaq 0xe8(%rsp), %r15
movq %r15, %rsi
callq 0x7dc8
movl %eax, %r12d
movq %r15, %rdi
callq 0x251b0
movslq 0x10(%rsp), %rax
movq (%rbx,%rax,8), %r15
testb %r12b, %r12b
je 0x7121
movl 0x14(%rsp), %ebp
movq %r13, %r12
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7e42
movq %r14, %rdi
movq %r13, %rsi
callq 0x7f32
movq %r13, %rdi
callq 0x6230
movl 0x10(%rsp), %eax
incl %eax
jmp 0x7063
movzbl 0x1(%r15), %ecx
cmpl $0x2d, %ecx
movl 0x14(%rsp), %ebp
movq %r13, %r12
je 0x715a
testl %ecx, %ecx
jne 0x71c9
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7e42
movq %r14, %rdi
movq %r13, %rsi
callq 0x7f32
jmp 0x710e
movb 0x2(%r15), %cl
testb %cl, %cl
je 0x71ba
leaq 0x2(%r15), %rsi
pushq $0x3
popq %rax
pushq $-0x2
popq %r12
testb %cl, %cl
je 0x73bc
movzbl %cl, %ecx
cmpl $0x3d, %ecx
je 0x73bc
movb (%r15,%rax), %cl
decq %r12
incq %rax
jmp 0x716d
cltq
movq (%rbx,%rax,8), %rsi
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r12, %rdx
callq 0x7e42
movq %r14, %rdi
movq %r15, %rsi
callq 0x7f32
movq %r15, %rdi
callq 0x6230
movl 0x10(%rsp), %eax
incl %eax
movl %eax, 0x10(%rsp)
cmpl %ebp, %eax
jl 0x718d
jmp 0x7116
incq %r15
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
callq 0x24ac2
movq %rax, %r15
leaq 0x40(%rsp), %rax
cmpq %rax, %r15
je 0x73f9
movq 0x28(%r15), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x28(%r15), %rdi
testb %al, %al
je 0x74f0
andq $0x0, 0xb0(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, 0xa8(%rsp)
leaq 0xb2d(%rip), %rax # 0x7d4a
movq %rax, 0xc0(%rsp)
leaq 0xb4a(%rip), %rax # 0x7d76
movq %rax, 0xb8(%rsp)
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
leaq 0x10(%rsp), %rcx
xorl %r8d, %r8d
leaq 0xa8(%rsp), %r15
movq %r15, %r9
callq *0x18(%rax)
movq %r15, %rdi
callq 0x251b0
pushq $0x1
popq %r15
movslq 0x10(%rsp), %rax
movq (%rbx,%rax,8), %rax
movsbl (%rax,%r15), %r12d
movb %r12b, 0xf(%rsp)
testl %r12d, %r12d
je 0x759d
movl %r12d, %edi
callq 0x67e0
cmpb $0x2d, %r12b
je 0x754a
testl %eax, %eax
je 0x754a
leaq 0x38(%rsp), %rdi
movq %r13, %rsi
callq 0x24ac2
movq %rax, %r12
leaq 0x40(%rsp), %rax
cmpq %rax, %r12
je 0x7327
movq 0x28(%r12), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x7384
movq 0x28(%r12), %rdi
andq $0x0, 0x90(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0xa67(%rip), %rax # 0x7d4a
movq %rax, 0xa0(%rsp)
leaq 0xa84(%rip), %rax # 0x7d76
movq %rax, 0x98(%rsp)
movq (%rdi), %rax
movl 0x14(%rsp), %esi
movq %rbx, %rdx
leaq 0x10(%rsp), %rcx
xorl %r8d, %r8d
leaq 0x88(%rsp), %r12
movq %r12, %r9
callq *0x18(%rax)
movq %r12, %rdi
callq 0x251b0
jmp 0x73b4
movb $0x1, 0x30(%r14)
movsbl 0xf(%rsp), %edx
leaq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
pushq $0x1
popq %rsi
callq 0x64d0
leaq 0x138(%rsp), %rbp
movq %rbp, %rdi
leaq 0x210ae(%rip), %rsi # 0x2840b
movq %r12, %rdx
callq 0x7f6c
movq %r14, %rdi
movq %rbp, %rsi
callq 0x7f3e
movq %rbp, %rdi
callq 0x6230
leaq 0x18(%rsp), %rdi
callq 0x6230
jmp 0x73b4
movb $0x1, 0x30(%r14)
movq 0x39c58(%rip), %rdi # 0x40fe8
leaq 0x20f98(%rip), %rsi # 0x2832f
callq 0x6420
movsbl 0xf(%rsp), %esi
movq %rax, %rdi
callq 0x64e0
movq %rax, %rdi
pushq $0xa
popq %rsi
callq 0x64e0
incq %r15
jmp 0x725e
cmpq $-0x2, %r12
jne 0x742c
movb $0x1, 0x30(%r14)
leaq 0x198(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
leaq 0x18(%rsp), %rdx
callq 0x7e42
movq %r14, %rdi
movq %r12, %rsi
callq 0x7f3e
movl 0x14(%rsp), %ebp
movq %r12, %rdi
movq %r13, %r12
jmp 0x7111
movb $0x1, 0x30(%r14)
movslq 0x10(%rsp), %rax
movq (%rbx,%rax,8), %rsi
leaq 0x158(%rsp), %r15
movq %r15, %rdi
leaq 0x18(%rsp), %rdx
callq 0x7e42
movq %r14, %rdi
movq %r15, %rsi
callq 0x7f3e
jmp 0x75de
movq %r15, %rdx
subq %r12, %rdx
leaq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
callq 0xb7ae
leaq 0x108(%rsp), %rdi
movq %rbp, %rsi
callq 0x24bc2
movq %rax, %rbp
leaq 0x18(%rsp), %rdi
callq 0x6230
leaq 0x110(%rsp), %rax
cmpq %rax, %rbp
je 0x75a9
movq 0x40(%rbp), %rdi
movslq 0x10(%rsp), %rax
subl (%rbx,%rax,8), %r15d
subl %r12d, %r15d
andq $0x0, 0xd0(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, 0xc8(%rsp)
leaq 0x8a6(%rip), %rax # 0x7d4a
movq %rax, 0xe0(%rsp)
leaq 0x8c3(%rip), %rax # 0x7d76
movq %rax, 0xd8(%rsp)
movq (%rdi), %rax
movl 0x14(%rsp), %ebp
movl %ebp, %esi
movq %rbx, %rdx
leaq 0x10(%rsp), %rcx
movl %r15d, %r8d
leaq 0xc8(%rsp), %r15
movq %r15, %r9
callq *0x18(%rax)
xorb $0x1, %al
orb %al, 0x30(%r14)
movq %r15, %rdi
callq 0x251b0
jmp 0x75a1
andq $0x0, 0x70(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x843(%rip), %rax # 0x7d4a
movq %rax, 0x80(%rsp)
leaq 0x860(%rip), %rax # 0x7d76
movq %rax, 0x78(%rsp)
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
leaq 0x10(%rsp), %rcx
pushq $0x2
popq %r8
leaq 0x68(%rsp), %r15
movq %r15, %r9
callq *0x18(%rax)
xorb $0x1, %al
orb %al, 0x30(%r14)
movq %r15, %rdi
callq 0x251b0
jmp 0x7116
movb $0x1, 0x30(%r14)
movq 0x39a92(%rip), %rdi # 0x40fe8
leaq 0x20db8(%rip), %rsi # 0x28315
callq 0x6420
movsbl 0xf(%rsp), %esi
movq %rax, %rdi
callq 0x64e0
movq %rax, %rdi
leaq 0x20d79(%rip), %rsi # 0x282f2
callq 0x6420
movslq 0x10(%rsp), %rcx
addq (%rbx,%rcx,8), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x6420
movq %rax, %rdi
pushq $0xa
popq %rsi
callq 0x64e0
movl 0x14(%rsp), %ebp
movq %r13, %r12
jmp 0x7116
movb $0x1, 0x30(%r14)
movslq 0x10(%rsp), %rax
movq (%rbx,%rax,8), %rsi
leaq 0x178(%rsp), %r15
movq %r15, %rdi
leaq 0x18(%rsp), %rdx
callq 0x7e42
movq %r14, %rdi
movq %r15, %rsi
callq 0x7f3e
movl 0x14(%rsp), %ebp
movq %r13, %r12
movq %r15, %rdi
jmp 0x7111
movb 0x30(%r14), %bl
xorb $0x1, %bl
leaq 0x108(%rsp), %rdi
callq 0x8a9a
leaq 0x38(%rsp), %rdi
callq 0x8afe
movl %ebx, %eax
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x178(%rsp), %rdi
jmp 0x76c5
jmp 0x76cc
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
jmp 0x76ae
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x76ae
jmp 0x76bd
jmp 0x76cc
movq %rax, %rbx
leaq 0x198(%rsp), %rdi
jmp 0x76c5
jmp 0x76cc
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
jmp 0x76ae
jmp 0x76cc
movq %rax, %rbx
leaq 0x158(%rsp), %rdi
jmp 0x76c5
jmp 0x76cc
jmp 0x76bd
jmp 0x76cc
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
jmp 0x76ae
jmp 0x76cc
movq %rax, %rbx
leaq 0x138(%rsp), %rdi
callq 0x6230
jmp 0x76c0
jmp 0x76cc
jmp 0x76bd
jmp 0x76cc
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0x251b0
jmp 0x76cf
jmp 0x76cc
jmp 0x76bd
jmp 0x76cc
jmp 0x76cc
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x6230
jmp 0x76cf
movq %rax, %rbx
leaq 0x108(%rsp), %rdi
callq 0x8a9a
leaq 0x38(%rsp), %rdi
callq 0x8afe
movq %rbx, %rdi
callq 0x67d0
|
/diatomic[P]diy/examples/opts.h
|
main
|
int main(int argc, char** argv)
{
// initialize MPI
diy::mpi::environment env(argc, argv); // equivalent of MPI_Init(argc, argv)/MPI_Finalize()
diy::mpi::communicator world; // equivalent of MPI_COMM_WORLD
int tot_blocks = world.size(); // default number of global blocks
int mem_blocks = -1; // everything in core for now
int num_threads = 1; // 1 thread for now
int nvals = 100; // number of values per block
// get command line arguments
bool help;
opts::Options ops;
ops >> opts::Option('b', "tot_blocks", tot_blocks, " total number of blocks")
>> opts::Option('n', "nvals", nvals, " number of values per block")
>> opts::Option('h', "help", help, " show help");
if (!ops.parse(argc,argv) || help)
{
if (world.rank() == 0)
std::cout << ops;
return 1;
}
// read the results back
diy::Master read_master(world,
num_threads,
mem_blocks,
&Block::create,
&Block::destroy);
diy::ContiguousAssigner read_assigner(world.size(), -1); // number of blocks set by read_blocks()
diy::io::read_blocks("test.out", world, read_assigner, read_master, &Block::load);
fmt::print(stderr, "{} blocks read from file\n", read_master.size());
// debug: print the blocks
read_master.foreach(&Block::print_data);
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1810, %rsp # imm = 0x1810
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x24(%rsp), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x7f90
leaq 0x50(%rsp), %rdi
callq 0x7fb4
movl 0x5c(%rsp), %eax
movl %eax, 0x2c(%rsp)
leaq 0x188(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movl $0x64, 0x28(%rsp)
leaq 0x1a0(%rsp), %r14
movq %r14, 0x8(%r14)
movq %r14, (%r14)
andq $0x0, 0x10(%r14)
movb $0x0, 0x18(%r14)
leaq 0x20c13(%rip), %rsi # 0x2836e
leaq 0x1e0(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x7e42
leaq 0x20c05(%rip), %rsi # 0x28379
leaq 0x30(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x7e42
leaq 0x18(%rsp), %rdi
pushq $0x62
popq %rsi
leaq 0x1e0(%rsp), %rdx
leaq 0x2c(%rsp), %rcx
leaq 0x30(%rsp), %r8
callq 0x7ff6
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x8b56
leaq 0x20bdb(%rip), %rsi # 0x28391
leaq 0x68(%rsp), %rdi
leaq 0x5(%rsp), %rdx
callq 0x7e42
leaq 0x20bcb(%rip), %rsi # 0x28397
leaq 0xe0(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0x7e42
leaq 0x10(%rsp), %rdi
pushq $0x6e
popq %rsi
leaq 0x68(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0xe0(%rsp), %r8
callq 0x7ff6
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x8b56
leaq 0x20ba8(%rip), %rsi # 0x283b9
leaq 0x168(%rsp), %rdi
leaq 0x3(%rsp), %rdx
callq 0x7e42
leaq 0x20b89(%rip), %rsi # 0x283b3
leaq 0x148(%rsp), %rdi
leaq 0x2(%rsp), %rdx
callq 0x7e42
leaq 0x8(%rsp), %rdi
pushq $0x68
popq %rsi
leaq 0x168(%rsp), %rdx
leaq 0x1(%rsp), %rcx
leaq 0x148(%rsp), %r8
callq 0x8089
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x8b56
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x787b
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x8(%rsp)
leaq 0x148(%rsp), %rdi
callq 0x6230
leaq 0x168(%rsp), %rdi
callq 0x6230
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x78ab
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x10(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x6230
leaq 0x68(%rsp), %rdi
callq 0x6230
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x78d8
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6230
leaq 0x1e0(%rsp), %rdi
callq 0x6230
leaq 0x188(%rsp), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x6fb6
testb %al, %al
je 0x7912
cmpb $0x1, 0x1(%rsp)
jne 0x7939
pushq $0x1
popq %rbx
cmpl $0x0, 0x58(%rsp)
jne 0x7ba2
movq 0x39691(%rip), %rdi # 0x40fb8
leaq 0x188(%rsp), %rsi
callq 0x8108
jmp 0x7ba2
movups 0x50(%rsp), %xmm0
movups %xmm0, 0xc8(%rsp)
movb $0x0, 0xd8(%rsp)
andq $0x0, 0xb0(%rsp)
leaq 0x816(%rip), %rax # 0x8174
movq %rax, 0xa8(%rsp)
leaq 0x1d6b3(%rip), %rax # 0x25020
movq %rax, 0xc0(%rsp)
leaq 0x1d6a6(%rip), %rax # 0x25022
andq $0x0, 0x90(%rsp)
movq %rax, 0xb8(%rsp)
leaq 0x7f6(%rip), %rax # 0x818a
movq %rax, 0x88(%rsp)
leaq 0x1d6a1(%rip), %rax # 0x25044
movq %rax, 0xa0(%rsp)
leaq 0x1d69a(%rip), %rax # 0x2504c
movq %rax, 0x98(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x120(%rsp)
movaps %xmm0, 0x130(%rsp)
movaps %xmm0, 0x100(%rsp)
movaps %xmm0, 0x110(%rsp)
pushq $0x10
popq %rdi
callq 0x6430
leaq 0x3888c(%rip), %rcx # 0x40278
movq %rcx, (%rax)
movq $0x1000, 0x8(%rax) # imm = 0x1000
leaq 0x100(%rsp), %r10
leaq 0x120(%rsp), %r11
leaq 0x1e0(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
pushq $0x1
popq %rdx
pushq $-0x1
popq %rcx
leaq 0xa8(%rsp), %r8
leaq 0x88(%rsp), %r9
pushq %rax
pushq %r10
pushq %r11
pushq $0x0
callq 0x81a8
addq $0x20, %rsp
leaq 0x100(%rsp), %rdi
callq 0x251b0
leaq 0x120(%rsp), %rdi
callq 0x251b0
leaq 0x88(%rsp), %rdi
callq 0x251b0
leaq 0xa8(%rsp), %rdi
callq 0x251b0
leaq 0xc8(%rsp), %rdi
callq 0x85aa
movl 0x5c(%rsp), %eax
movl %eax, 0x70(%rsp)
orl $-0x1, 0x74(%rsp)
leaq 0x38966(%rip), %rax # 0x403f8
movq %rax, 0x68(%rsp)
leaq 0x20920(%rip), %rsi # 0x283be
leaq 0x30(%rsp), %rdi
leaq 0xe0(%rsp), %rdx
callq 0x7e42
leaq 0x1c0(%rsp), %r8
andq $0x0, 0x8(%r8)
leaq 0xb94(%rip), %rax # 0x8658
movq %rax, (%r8)
leaq 0x1d5a0(%rip), %rax # 0x2506e
movq %rax, 0x18(%r8)
leaq 0x1d5a1(%rip), %rax # 0x2507a
movq %rax, 0x10(%r8)
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x68(%rsp), %rdx
leaq 0x1e0(%rsp), %rcx
callq 0x85ba
leaq 0x1c0(%rsp), %rdi
callq 0x251b0
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x6230
movq 0x394a6(%rip), %rax # 0x40fc0
movq (%rax), %rdi
movq 0x288(%rsp), %rax
subq 0x280(%rsp), %rax
shrq $0x3, %rax
movl %eax, (%rbx)
leaq 0x2088d(%rip), %rsi # 0x283c7
leaq 0x30(%rsp), %rdx
callq 0x8666
leaq 0xbb7(%rip), %rax # 0x8702
leaq 0xe0(%rsp), %rsi
movq %rax, (%rsi)
andq $0x0, 0x8(%rsi)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdx
movaps %xmm0, (%rdx)
leaq 0x1d9f3(%rip), %rax # 0x25560
movq %rax, 0x18(%rdx)
leaq 0x1d9ec(%rip), %rax # 0x25564
movq %rax, 0x10(%rdx)
leaq 0x1e0(%rsp), %rdi
callq 0x869a
leaq 0x30(%rsp), %rdi
callq 0x251b0
leaq 0x1e0(%rsp), %rdi
callq 0x8784
xorl %ebx, %ebx
leaq 0x188(%rsp), %rdi
callq 0x8848
leaq 0x50(%rsp), %rdi
callq 0x85aa
leaq 0x24(%rsp), %rdi
callq 0x885e
movl %ebx, %eax
addq $0x1810, %rsp # imm = 0x1810
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x251b0
jmp 0x7c01
jmp 0x7bfe
movq %rax, %rbx
leaq 0x1c0(%rsp), %rdi
callq 0x251b0
leaq 0x30(%rsp), %rdi
callq 0x6230
jmp 0x7c01
movq %rax, %rbx
leaq 0x1e0(%rsp), %rdi
callq 0x8784
jmp 0x7d0b
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x251b0
leaq 0x120(%rsp), %rdi
callq 0x251b0
leaq 0x88(%rsp), %rdi
callq 0x251b0
leaq 0xa8(%rsp), %rdi
callq 0x251b0
leaq 0xc8(%rsp), %rdi
callq 0x85aa
jmp 0x7d0b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7c6f
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x8(%rsp)
jmp 0x7c7a
movq %rax, %rbx
leaq 0x148(%rsp), %rdi
callq 0x6230
jmp 0x7c8c
movq %rax, %rbx
leaq 0x168(%rsp), %rdi
callq 0x6230
jmp 0x7ca0
jmp 0x7c9d
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x7cb0
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x10(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x6230
leaq 0x68(%rsp), %rdi
callq 0x6230
jmp 0x7cde
movq %rax, %rbx
jmp 0x7cb6
movq %rax, %rbx
jmp 0x7cc3
jmp 0x7cdb
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x7cee
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6230
leaq 0x1e0(%rsp), %rdi
callq 0x6230
leaq 0x188(%rsp), %rdi
callq 0x8848
leaq 0x50(%rsp), %rdi
callq 0x85aa
leaq 0x24(%rsp), %rdi
callq 0x885e
movq %rbx, %rdi
callq 0x67d0
movq %rax, %rbx
jmp 0x7cf4
movq %rax, %rbx
jmp 0x7cfe
jmp 0x7d45
movq %rax, %rbx
jmp 0x7d22
movq %rax, %rbx
jmp 0x7d0b
|
/diatomic[P]diy/tests/custom-bounds-load.cpp
|
diy::mpi::environment::environment(int, char**)
|
diy::mpi::environment::environment(int argc, char* argv[])
{
#if DIY_HAS_MPI
MPI_Init_thread(&argc, &argv, MPI_THREAD_FUNNELED, &provided_threading);
#else
(void) argc; (void) argv;
provided_threading = MPI_THREAD_FUNNELED;
#endif
}
|
subq $0x18, %rsp
movq %rdi, %rcx
leaq 0xc(%rsp), %rdi
movl %esi, (%rdi)
leaq 0x10(%rsp), %rsi
movq %rdx, (%rsi)
pushq $0x1
popq %rdx
callq 0x60b0
addq $0x18, %rsp
retq
nop
|
/diatomic[P]diy/include/diy/mpi/environment.cpp
|
opts::operator<<(std::ostream&, opts::Options const&)
|
std::ostream&
operator<<(std::ostream& out, const Options& ops)
{
int max_long = 0;
for (auto& cur : ops.options)
{
int cur_long = cur->long_size();
if (cur_long > max_long)
max_long = cur_long;
}
out << "Options:\n";
for (auto& cur : ops.options)
cur->output(out, max_long);
return out;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x18, %r14
xorl %ebp, %ebp
movq %r14, %rax
movq (%rax), %rax
cmpq %r14, %rax
je 0x813b
movq 0x10(%rax), %rcx
movl 0x18(%rcx), %edx
movl 0x58(%rcx), %ecx
addl %edx, %ecx
incl %ecx
cmpl %ecx, %ebp
cmovlel %ecx, %ebp
jmp 0x811e
leaq 0x202bb(%rip), %rsi # 0x283fd
movq %rbx, %rdi
callq 0x6420
movq %r14, %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0x8165
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x8c30
jmp 0x814d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/diatomic[P]diy/examples/opts.h
|
diy::Master::Master(diy::mpi::communicator, int, int, std::function<void* ()>, std::function<void (void*)>, diy::ExternalStorage*, std::function<void (void const*, diy::BinaryBuffer&)>, std::function<void (void*, diy::BinaryBuffer&)>, diy::Master::QueuePolicy*)
|
diy::Master::
Master(mpi::communicator comm,
int threads__,
int limit__,
CreateBlock create_,
DestroyBlock destroy_,
ExternalStorage* storage,
SaveBlock save,
LoadBlock load_,
QueuePolicy* q_policy):
blocks_(create_, destroy_, storage, save, load_),
queue_policy_(q_policy),
limit_(limit__),
#if !defined(DIY_NO_THREADS)
threads_(threads__ == -1 ? static_cast<int>(thread::hardware_concurrency()) : threads__),
#else
threads_(1),
#endif
storage_(storage),
// Communicator functionality
inflight_sends_(new InFlightSendsList),
inflight_recvs_(new InFlightRecvsMap),
collectives_(new CollectivesMap)
{
#ifdef DIY_NO_THREADS
(void) threads__;
#endif
comm_.duplicate(comm);
// seed random number generator, broadcast seed, offset by rank
std::random_device rd; // seed source for the random number engine
unsigned int s = rd();
diy::mpi::broadcast(communicator(), s, 0);
std::mt19937 gen(s + communicator().rank()); // mersenne_twister random number generator
mt_gen = gen;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x27a8, %rsp # imm = 0x27A8
movq %r9, %r14
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x78(%rsp), %rdi
movq %r8, %rsi
callq 0x8d9e
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x8de4
movq 0x27e8(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x8e2a
movq 0x27f0(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x8e70
movq 0x27e0(%rsp), %r13
leaq 0x18(%rbx), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x58(%rsp), %rdx
leaq 0x38(%rsp), %r8
leaq 0x18(%rsp), %r9
movq %rdi, 0x10(%rsp)
movq %r13, %rcx
callq 0x8eb6
movq 0x27f8(%rsp), %r14
leaq 0x18(%rsp), %rdi
callq 0x251b0
leaq 0x38(%rsp), %rdi
callq 0x251b0
leaq 0x58(%rsp), %rdi
callq 0x251b0
leaq 0x78(%rsp), %rdi
callq 0x251b0
xorps %xmm0, %xmm0
movups %xmm0, 0x100(%rbx)
andq $0x0, 0x110(%rbx)
leaq 0x120(%rbx), %rax
andl $0x0, 0x120(%rbx)
andq $0x0, 0x128(%rbx)
movq %rax, 0x130(%rbx)
movq %rax, 0x138(%rbx)
andq $0x0, 0x140(%rbx)
movq %r14, 0x148(%rbx)
movl %r15d, 0x150(%rbx)
cmpl $-0x1, %ebp
jne 0x82c5
callq 0x65d0
movl %eax, %ebp
movl %ebp, 0x154(%rbx)
movq %r13, 0x158(%rbx)
leaq 0x160(%rbx), %r15
movq %r15, %rdi
callq 0x7fb4
leaq 0x180(%rbx), %rax
andl $0x0, 0x180(%rbx)
andq $0x0, 0x188(%rbx)
movq %rax, 0x190(%rbx)
movq %rax, 0x198(%rbx)
andq $0x0, 0x1a0(%rbx)
leaq 0x1b0(%rbx), %rax
andl $0x0, 0x1b0(%rbx)
andq $0x0, 0x1b8(%rbx)
movq %rax, 0x1c0(%rbx)
movq %rax, 0x1c8(%rbx)
andq $0x0, 0x1d0(%rbx)
pushq $0x18
popq %rdi
callq 0x6430
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x1d8(%rbx)
pushq $0x30
popq %rdi
callq 0x6430
andl $0x0, 0x8(%rax)
andq $0x0, 0x10(%rax)
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
andq $0x0, 0x28(%rax)
movq %rax, 0x1e0(%rbx)
pushq $0x30
popq %rdi
callq 0x6430
movq %rax, %rcx
addq $0x8, %rcx
andl $0x0, 0x8(%rax)
andq $0x0, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
andq $0x0, 0x28(%rax)
movq %rax, 0x1e8(%rbx)
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rax, 0x1f0(%rbx)
movb $0x1, 0x1f8(%rbx)
leaq 0x220(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x200(%rbx)
movups %xmm0, 0x20c(%rbx)
callq 0x9131
leaq 0x230(%rbx), %r13
movq %r13, %rdi
callq 0x9296
leaq 0x2a8(%rbx), %rbp
movq %rbp, %rdi
callq 0x8f7e
movq %r15, %rdi
movq %r12, %rsi
callq 0x8f88
leaq 0x98(%rsp), %rdi
callq 0x8fe8
leaq 0x98(%rsp), %rdi
callq 0x6600
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
xorl %edx, %edx
callq 0x9392
movl 0x168(%rbx), %esi
addl 0xc(%rsp), %esi
leaq 0x1420(%rsp), %rdi
callq 0x92d0
leaq 0x1420(%rsp), %rsi
movl $0x1388, %edx # imm = 0x1388
movq %rbp, %rdi
callq 0x63a0
leaq 0x98(%rsp), %rdi
callq 0x903e
addq $0x27a8, %rsp # imm = 0x27A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x84f6
jmp 0x8508
movq %rax, %r12
jmp 0x851f
movq %rax, %r12
jmp 0x853a
movq %rax, %r12
jmp 0x8546
movq %rax, %r12
jmp 0x8552
movq %rax, %r12
jmp 0x8575
movq %rax, %r12
leaq 0x18(%rsp), %rdi
callq 0x251b0
jmp 0x84c1
movq %rax, %r12
leaq 0x38(%rsp), %rdi
callq 0x251b0
jmp 0x84d0
movq %rax, %r12
leaq 0x58(%rsp), %rdi
callq 0x251b0
jmp 0x84df
movq %rax, %r12
leaq 0x78(%rsp), %rdi
callq 0x251b0
jmp 0x859a
movq %rax, %r12
jmp 0x859a
movq %rax, %r12
leaq 0x98(%rsp), %rdi
callq 0x903e
jmp 0x850b
movq %rax, %r12
movq %r13, %rdi
callq 0x93c6
leaq 0x228(%rbx), %rdi
callq 0x9558
leaq 0x1e8(%rbx), %r13
leaq 0x200(%rbx), %rdi
callq 0x904e
movq %r13, %rdi
callq 0x9070
leaq 0x1e0(%rbx), %rdi
callq 0x908a
leaq 0x1d8(%rbx), %rdi
callq 0x90a4
leaq 0x178(%rbx), %r13
leaq 0x1a8(%rbx), %rdi
callq 0xa206
movq %r13, %rdi
callq 0xa422
movq %r15, %rdi
callq 0x85aa
leaq 0x100(%rbx), %r15
leaq 0x118(%rbx), %rdi
callq 0xa550
movq %r15, %rdi
callq 0x8d50
movq 0x10(%rsp), %rdi
callq 0x90be
movq %rbx, %rdi
callq 0xa5a8
movq %r12, %rdi
callq 0x67d0
|
/diatomic[P]diy/include/diy/master.hpp
|
void diy::Master::foreach<void (Block::*)(diy::Master::ProxyWithLink const&)>(void (Block::* const&)(diy::Master::ProxyWithLink const&), std::function<bool (int, diy::Master const&)> const&)
|
mpi::communicator& communicator() { return comm_; }
|
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq (%rsi), %rax
testq %rax, %rax
je 0x86d8
movq 0x8(%rsi), %rcx
movq %rax, (%rsp)
movq %rcx, 0x8(%rsp)
leaq 0x1ce25(%rip), %rax # 0x254ec
movq %rax, 0x18(%rsp)
leaq 0x1ce1f(%rip), %rax # 0x254f2
movq %rax, 0x10(%rsp)
movq %rsp, %rsi
callq 0x2509c
movq %rsp, %rdi
callq 0x251b0
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x251b0
movq %rbx, %rdi
callq 0x67d0
nop
|
/diatomic[P]diy/include/diy/master.hpp
|
Block::print_data(diy::Master::ProxyWithLink const&)
|
void print_data(const diy::Master::ProxyWithLink& cp)
{
fmt::print(stderr, "gid {}:\n", cp.gid());
for (size_t i = 0; i < vals.size(); i++)
fmt::print(stderr, "{} ", vals[i]);
fmt::print(stderr, "\n");
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x388a7(%rip), %r15 # 0x40fc0
movq (%r15), %rdi
movl (%rsi), %eax
leaq 0xc(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x1fdd2(%rip), %rsi # 0x284fe
callq 0xd3da
xorl %r12d, %r12d
leaq 0x1fdcc(%rip), %r14 # 0x28507
xorl %r13d, %r13d
movq (%rbx), %rdx
movq 0x8(%rbx), %rax
subq %rdx, %rax
sarq $0x2, %rax
movq (%r15), %rdi
cmpq %rax, %r13
jae 0x8768
addq %r12, %rdx
movq %r14, %rsi
callq 0xd40d
incq %r13
addq $0x4, %r12
jmp 0x873e
leaq 0x1fc96(%rip), %rsi # 0x28405
callq 0xd440
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/diatomic[P]diy/tests/custom-bounds-load.cpp
|
diy::Master::~Master()
|
diy::Master::
~Master()
{
set_immediate(true);
clear();
delete queue_policy_;
}
|
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x1a60a
movq %rbx, %rdi
callq 0x1a638
movq 0x148(%rbx), %rdi
testq %rdi, %rdi
je 0x87aa
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x230(%rbx), %rdi
callq 0x93c6
leaq 0x228(%rbx), %rdi
callq 0x9558
leaq 0x200(%rbx), %rdi
callq 0x904e
leaq 0x1e8(%rbx), %rdi
callq 0x9070
leaq 0x1e0(%rbx), %rdi
callq 0x908a
leaq 0x1d8(%rbx), %rdi
callq 0x90a4
leaq 0x1a8(%rbx), %rdi
callq 0xa206
leaq 0x178(%rbx), %rdi
callq 0xa422
leaq 0x160(%rbx), %rdi
callq 0x85aa
leaq 0x118(%rbx), %rdi
callq 0xa550
leaq 0x100(%rbx), %rdi
callq 0x8d50
leaq 0x18(%rbx), %rdi
callq 0x90be
movq %rbx, %rdi
popq %rbx
jmp 0xa5a8
movq %rax, %rdi
callq 0x8a8e
|
/diatomic[P]diy/include/diy/master.hpp
|
diy::Factory<diy::Link>::Registrar<diy::AMRLink>::registerT()
|
static bool registerT()
{
const auto name = typeid(T).name();
Factory::data()[name] = [](Args... args) -> Base*
{
return new T(std::forward<Args>(args)...);
};
return true;
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0xb526
movq %rax, %rbx
leaq 0x20fd3(%rip), %rsi # 0x2985d
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x7e42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fae2
leaq 0x15276(%rip), %rcx # 0x1db24
movq %rcx, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x6230
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6230
movq %rbx, %rdi
callq 0x67d0
|
/diatomic[P]diy/include/diy/factory.hpp
|
diy::Factory<diy::Link>::Registrar<diy::RegularLink<diy::Bounds<int>>>::registerT()
|
static bool registerT()
{
const auto name = typeid(T).name();
Factory::data()[name] = [](Args... args) -> Base*
{
return new T(std::forward<Args>(args)...);
};
return true;
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0xb526
movq %rax, %rbx
leaq 0x20fd8(%rip), %rsi # 0x298c8
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x7e42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fae2
leaq 0x1755e(%rip), %rcx # 0x1fe72
movq %rcx, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x6230
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6230
movq %rbx, %rdi
callq 0x67d0
|
/diatomic[P]diy/include/diy/factory.hpp
|
diy::Factory<diy::Link>::Registrar<diy::RegularLink<diy::Bounds<float>>>::registerT()
|
static bool registerT()
{
const auto name = typeid(T).name();
Factory::data()[name] = [](Args... args) -> Base*
{
return new T(std::forward<Args>(args)...);
};
return true;
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0xb526
movq %rax, %rbx
leaq 0x20fdf(%rip), %rsi # 0x29935
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x7e42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fae2
leaq 0x187d6(%rip), %rcx # 0x21150
movq %rcx, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x6230
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6230
movq %rbx, %rdi
callq 0x67d0
|
/diatomic[P]diy/include/diy/factory.hpp
|
diy::Factory<diy::Link>::Registrar<diy::RegularLink<diy::Bounds<double>>>::registerT()
|
static bool registerT()
{
const auto name = typeid(T).name();
Factory::data()[name] = [](Args... args) -> Base*
{
return new T(std::forward<Args>(args)...);
};
return true;
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0xb526
movq %rax, %rbx
leaq 0x20fe6(%rip), %rsi # 0x299a2
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x7e42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fae2
leaq 0x1981c(%rip), %rcx # 0x221fc
movq %rcx, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x6230
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6230
movq %rbx, %rdi
callq 0x67d0
|
/diatomic[P]diy/include/diy/factory.hpp
|
diy::Factory<diy::Link>::Registrar<diy::RegularLink<diy::Bounds<long>>>::registerT()
|
static bool registerT()
{
const auto name = typeid(T).name();
Factory::data()[name] = [](Args... args) -> Base*
{
return new T(std::forward<Args>(args)...);
};
return true;
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0xb526
movq %rax, %rbx
leaq 0x20fed(%rip), %rsi # 0x29a0f
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x7e42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fae2
leaq 0x1a8fe(%rip), %rcx # 0x23344
movq %rcx, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x6230
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6230
movq %rbx, %rdi
callq 0x67d0
|
/diatomic[P]diy/include/diy/factory.hpp
|
opts::BasicOption::output(std::ostream&, int) const
|
void output(std::ostream& out, int max_long) const
{
out << " ";
if (s)
out << '-' << s << ", ";
else
out << " ";
out << "--" << l << ' ';
if (!t.empty())
out << t;
for (int i = long_size(); i < max_long; ++i)
out << ' ';
out << " " << help;
if (!d.empty())
{
out << " [default: " << d << "]";
}
out << '\n';
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2101a(%rip), %rsi # 0x29c61
movq %rbx, %rdi
callq 0x6420
cmpb $0x0, 0x8(%r14)
je 0x8c7a
pushq $0x2d
popq %rsi
movq %rbx, %rdi
callq 0x64e0
movsbl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x64e0
leaq 0x1f792(%rip), %rsi # 0x28407
movq %rax, %rdi
jmp 0x8c84
leaq 0x20fdf(%rip), %rsi # 0x29c60
movq %rbx, %rdi
callq 0x6420
leaq 0x1f77a(%rip), %rsi # 0x2840a
movq %rbx, %rdi
callq 0x6420
leaq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x63d0
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x64e0
cmpq $0x0, 0x58(%r14)
je 0x8cc8
leaq 0x50(%r14), %rsi
movq %rbx, %rdi
callq 0x63d0
movq 0x58(%r14), %rax
jmp 0x8cca
xorl %eax, %eax
movl 0x18(%r14), %ecx
leal (%rcx,%rax), %r12d
incl %r12d
pushq $0x20
popq %r15
cmpl %ebp, %r12d
jge 0x8cee
movq %rbx, %rdi
movl %r15d, %esi
callq 0x64e0
incl %r12d
jmp 0x8cd9
leaq 0x20f6c(%rip), %rsi # 0x29c61
movq %rbx, %rdi
callq 0x6420
leaq 0x70(%r14), %rsi
movq %rax, %rdi
callq 0x63d0
cmpq $0x0, 0x38(%r14)
je 0x8d3d
addq $0x30, %r14
leaq 0x1f6f2(%rip), %rsi # 0x2840d
movq %rbx, %rdi
callq 0x6420
movq %rax, %rdi
movq %r14, %rsi
callq 0x63d0
leaq 0x1f6e4(%rip), %rsi # 0x28419
movq %rax, %rdi
callq 0x6420
pushq $0xa
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x64e0
|
/diatomic[P]diy/examples/opts.h
|
diy::Collection::Collection(std::function<void* ()>, std::function<void (void*)>, diy::ExternalStorage*, std::function<void (void const*, diy::BinaryBuffer&)>, std::function<void (void*, diy::BinaryBuffer&)>)
|
Collection(Create create__,
Destroy destroy__,
ExternalStorage* storage__,
Save save__,
Load load__):
create_(create__),
destroy_(destroy__),
storage_(storage__),
save_(save__),
load_(load__),
in_memory_(0) {}
|
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, %rbp
movq %rdi, %rbx
callq 0x8d9e
leaq 0x20(%rbx), %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0x8de4
movq %r13, 0x40(%rbx)
leaq 0x48(%rbx), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x8e2a
leaq 0x68(%rbx), %rdi
movq %r15, %rsi
callq 0x8e70
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%rbx)
andq $0x0, 0xe0(%rbx)
movups %xmm0, 0xc0(%rbx)
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x98(%rbx)
movups %xmm0, 0xa8(%rbx)
andl $0x0, 0xb8(%rbx)
movl $0x1, 0xd0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r13, %rdi
callq 0x251b0
jmp 0x8f61
movq %rax, %r15
movq %r14, %rdi
callq 0x251b0
jmp 0x8f6e
movq %rax, %r15
movq %rbx, %rdi
callq 0x251b0
movq %r15, %rdi
callq 0x67d0
|
/diatomic[P]diy/include/diy/collection.hpp
|
diy::MemoryBuffer::save_binary_blob(char const*, unsigned long)
|
static void save(BinaryBuffer& bb, const Vector& v)
{
size_t s = v.size();
diy::save(bb, s);
if (s > 0)
diy::save(bb, &v[0], v.size());
}
|
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x37d(%rip), %rax # 0x9ea2
movq %rax, 0x18(%rcx)
leaq 0x374(%rip), %rax # 0x9ea4
movq %rax, 0x10(%rcx)
movq (%rdi), %rax
callq *0x48(%rax)
movq %rsp, %rdi
callq 0x251b0
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x251b0
movq %rbx, %rdi
callq 0x67d0
nop
|
/diatomic[P]diy/include/diy/serialization.hpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.