name
string | code
string | asm
string | file
string |
|---|---|---|---|
stbtt__tesselate_curve(stbtt__point*, int*, float, float, float, float, float, float, float, int)
|
static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n)
{
// midpoint
float mx = (x0 + 2*x1 + x2)/4;
float my = (y0 + 2*y1 + y2)/4;
// versus directly drawn line
float dx = (x0+x2)/2 - mx;
float dy = (y0+y2)/2 - my;
if (n > 16) // 65536 segments on one curve better be enough!
return 1;
if (dx*dx+dy*dy > objspace_flatness_squared) { // half-pixel error allowed... need to be smaller if AA
stbtt__tesselate_curve(points, num_points, x0,y0, (x0+x1)/2.0f,(y0+y1)/2.0f, mx,my, objspace_flatness_squared,n+1);
stbtt__tesselate_curve(points, num_points, mx,my, (x1+x2)/2.0f,(y1+y2)/2.0f, x2,y2, objspace_flatness_squared,n+1);
} else {
stbtt__add_point(points, *num_points,x2,y2);
*num_points = *num_points+1;
}
return 1;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movss %xmm6, 0xc(%rsp)
movaps %xmm3, %xmm7
movaps %xmm2, %xmm8
movq %rsi, %rbx
movq %rdi, %r14
movss 0x22fcc(%rip), %xmm9 # 0x7ee58
movss %xmm5, 0x8(%rsp)
movss %xmm4, 0x4(%rsp)
cmpl $0x10, %ebp
jg 0x5bfc0
movaps %xmm8, %xmm10
addss %xmm8, %xmm10
addss %xmm0, %xmm10
addss %xmm4, %xmm10
movss 0x23010(%rip), %xmm2 # 0x7eecc
mulss %xmm2, %xmm10
movaps %xmm7, %xmm11
addss %xmm7, %xmm11
addss %xmm1, %xmm11
addss %xmm5, %xmm11
mulss %xmm2, %xmm11
movaps %xmm1, %xmm2
addss %xmm5, %xmm2
mulss %xmm9, %xmm2
subss %xmm11, %xmm2
movaps %xmm0, %xmm3
addss %xmm4, %xmm3
mulss %xmm9, %xmm3
subss %xmm10, %xmm3
mulss %xmm2, %xmm2
mulss %xmm3, %xmm3
addss %xmm2, %xmm3
movss 0xc(%rsp), %xmm6
ucomiss %xmm6, %xmm3
jbe 0x5bfa7
movaps %xmm0, %xmm2
addss %xmm8, %xmm2
mulss %xmm9, %xmm2
movaps %xmm1, %xmm3
addss %xmm7, %xmm3
mulss %xmm9, %xmm3
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movaps %xmm10, %xmm4
movaps %xmm11, %xmm5
movl %ebp, %edx
movss %xmm7, 0x1c(%rsp)
movss %xmm8, 0x18(%rsp)
movss %xmm10, 0x10(%rsp)
movss %xmm11, 0x14(%rsp)
callq 0x5be66
movss 0x22eee(%rip), %xmm9 # 0x7ee58
movss 0x18(%rsp), %xmm8
movss 0x1c(%rsp), %xmm7
movss 0x4(%rsp), %xmm4
movss 0x8(%rsp), %xmm5
addss %xmm4, %xmm8
mulss %xmm9, %xmm8
addss %xmm5, %xmm7
mulss %xmm9, %xmm7
movss 0x10(%rsp), %xmm0
movss 0x14(%rsp), %xmm1
jmp 0x5be98
movslq (%rbx), %rax
testq %r14, %r14
je 0x5bfbc
movss %xmm4, (%r14,%rax,8)
movss %xmm5, 0x4(%r14,%rax,8)
incl %eax
movl %eax, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
/ggerganov[P]kbd-audio/imgui/imstb_truetype.h
|
stbtt__sort_edges_quicksort(stbtt__edge*, int)
|
static void stbtt__sort_edges_quicksort(stbtt__edge *p, int n)
{
/* threshold for transitioning to insertion sort */
while (n > 12) {
stbtt__edge t;
int c01,c12,c,m,i,j;
/* compute median of three */
m = n >> 1;
c01 = STBTT__COMPARE(&p[0],&p[m]);
c12 = STBTT__COMPARE(&p[m],&p[n-1]);
/* if 0 >= mid >= end, or 0 < mid < end, then use mid */
if (c01 != c12) {
/* otherwise, we'll need to swap something else to middle */
int z;
c = STBTT__COMPARE(&p[0],&p[n-1]);
/* 0>mid && mid<n: 0>n => n; 0<n => 0 */
/* 0<mid && mid>n: 0>n => 0; 0<n => n */
z = (c == c12) ? 0 : n-1;
t = p[z];
p[z] = p[m];
p[m] = t;
}
/* now p[m] is the median-of-three */
/* swap it to the beginning so it won't move around */
t = p[0];
p[0] = p[m];
p[m] = t;
/* partition loop */
i=1;
j=n-1;
for(;;) {
/* handling of equality is crucial here */
/* for sentinels & efficiency with duplicates */
for (;;++i) {
if (!STBTT__COMPARE(&p[i], &p[0])) break;
}
for (;;--j) {
if (!STBTT__COMPARE(&p[0], &p[j])) break;
}
/* make sure we haven't crossed */
if (i >= j) break;
t = p[i];
p[i] = p[j];
p[j] = t;
++i;
--j;
}
/* recurse on smaller side, iterate on larger */
if (j < (n-i)) {
stbtt__sort_edges_quicksort(p,j);
p = p+i;
n = n-i;
} else {
stbtt__sort_edges_quicksort(p+i, n-i);
n = j;
}
}
}
|
cmpl $0xd, %esi
jl 0x5c423
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorl %r12d, %r12d
movl %esi, %eax
shrl %eax
movss 0x4(%rbx), %xmm0
leaq (%rax,%rax,4), %rax
leaq (%rbx,%rax,4), %rax
movss 0x4(%rax), %xmm1
leal -0x1(%rsi), %r14d
leaq (%r14,%r14,4), %rcx
movss 0x4(%rbx,%rcx,4), %xmm2
movaps %xmm0, %xmm3
cmpnltps %xmm1, %xmm3
cmpltps %xmm2, %xmm1
xorps %xmm1, %xmm3
movd %xmm3, %ecx
testb $0x1, %cl
jne 0x5c32c
cmpnltps %xmm2, %xmm0
xorps %xmm1, %xmm0
movd %xmm0, %ecx
testb $0x1, %cl
movq %r14, %rcx
cmovneq %r12, %rcx
leaq (%rcx,%rcx,4), %rcx
movl 0x10(%rbx,%rcx,4), %edx
movl %edx, 0x10(%rsp)
movups (%rbx,%rcx,4), %xmm0
movaps %xmm0, (%rsp)
movl 0x10(%rax), %edx
movl %edx, 0x10(%rbx,%rcx,4)
movups (%rax), %xmm0
movups %xmm0, (%rbx,%rcx,4)
movl 0x10(%rsp), %ecx
movl %ecx, 0x10(%rax)
movaps (%rsp), %xmm0
movups %xmm0, (%rax)
movl 0x10(%rbx), %ecx
movl %ecx, 0x10(%rsp)
movups (%rbx), %xmm0
movaps %xmm0, (%rsp)
movl 0x10(%rax), %ecx
movl %ecx, 0x10(%rbx)
movups (%rax), %xmm0
movups %xmm0, (%rbx)
movl 0x10(%rsp), %ecx
movl %ecx, 0x10(%rax)
movaps (%rsp), %xmm0
movups %xmm0, (%rax)
incl %esi
leaq 0x14(%rbx), %rax
movl $0x1, %ecx
movss 0x4(%rbx), %xmm0
movslq %ecx, %rcx
movl %esi, %ebp
subl %ecx, %ebp
leaq (%rcx,%rcx,4), %rdx
leaq -0x14(,%rdx,4), %r15
incq %rcx
decl %ebp
ucomiss 0x18(%rbx,%r15), %xmm0
leaq 0x14(%r15), %r15
ja 0x5c377
movslq %r14d, %rdi
leaq -0x1(%rcx), %r8
addq %rbx, %r15
leaq (%rdi,%rdi,4), %rdx
incq %rdi
leaq (%rax,%rdx,4), %rdx
movss -0x10(%rdx), %xmm1
decq %rdi
decl %r14d
addq $-0x14, %rdx
ucomiss %xmm0, %xmm1
ja 0x5c39d
cmpq %rdi, %r8
jge 0x5c3e7
movl 0x10(%r15), %edi
movl %edi, 0x10(%rsp)
movups (%r15), %xmm0
movaps %xmm0, (%rsp)
movl 0x10(%rdx), %edi
movl %edi, 0x10(%r15)
movups (%rdx), %xmm0
movups %xmm0, (%r15)
movl 0x10(%rsp), %edi
movl %edi, 0x10(%rdx)
movaps (%rsp), %xmm0
movups %xmm0, (%rdx)
jmp 0x5c35f
incl %r14d
cmpl %r14d, %ebp
jle 0x5c3ff
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5c291
movq %r15, %rbx
jmp 0x5c40c
movq %r15, %rdi
movl %ebp, %esi
callq 0x5c291
movl %r14d, %ebp
movl %ebp, %esi
cmpl $0xc, %ebp
jg 0x5c2ac
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/ggerganov[P]kbd-audio/imgui/imstb_truetype.h
|
ImGui::GetWindowScrollbarRect(ImGuiWindow*, ImGuiAxis)
|
ImRect ImGui::GetWindowScrollbarRect(ImGuiWindow* window, ImGuiAxis axis)
{
const ImRect outer_rect = window->Rect();
const ImRect inner_rect = window->InnerRect;
const float border_size = window->WindowBorderSize;
const float scrollbar_size = window->ScrollbarSizes[axis ^ 1]; // (ScrollbarSizes.x = width of Y scrollbar; ScrollbarSizes.y = height of X scrollbar)
IM_ASSERT(scrollbar_size > 0.0f);
if (axis == ImGuiAxis_X)
return ImRect(inner_rect.Min.x, ImMax(outer_rect.Min.y, outer_rect.Max.y - border_size - scrollbar_size), inner_rect.Max.x, outer_rect.Max.y);
else
return ImRect(ImMax(outer_rect.Min.x, outer_rect.Max.x - border_size - scrollbar_size), inner_rect.Min.y, outer_rect.Max.x, inner_rect.Max.y);
}
|
pushq %rax
cmpl $0x2, %esi
jae 0x5e48c
movl %esi, %eax
xorl $0x1, %eax
movss 0x74(%rdi,%rax,4), %xmm4
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm4
jbe 0x5e4ab
movss 0x44(%rdi), %xmm5
testl %esi, %esi
je 0x5e447
movss 0x10(%rdi), %xmm6
movss 0x18(%rdi), %xmm1
addss %xmm6, %xmm1
movss 0x22c(%rdi), %xmm3
movss 0x234(%rdi), %xmm2
movaps %xmm1, %xmm7
subss %xmm5, %xmm7
subss %xmm4, %xmm7
movaps %xmm7, %xmm0
cmpless %xmm6, %xmm0
movaps %xmm0, %xmm4
andnps %xmm7, %xmm4
andps %xmm6, %xmm0
orps %xmm4, %xmm0
jmp 0x5e484
movss 0x14(%rdi), %xmm6
movss 0x1c(%rdi), %xmm2
addss %xmm6, %xmm2
movss 0x228(%rdi), %xmm0
movss 0x230(%rdi), %xmm1
movaps %xmm2, %xmm7
subss %xmm5, %xmm7
subss %xmm4, %xmm7
movaps %xmm7, %xmm3
cmpless %xmm6, %xmm3
movaps %xmm3, %xmm4
andnps %xmm7, %xmm4
andps %xmm6, %xmm3
orps %xmm4, %xmm3
unpcklps %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
unpcklps %xmm3, %xmm0 # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
popq %rax
retq
leaq 0x2f8be(%rip), %rdi # 0x8dd51
leaq 0x237b7(%rip), %rsi # 0x81c51
leaq 0x2f8b9(%rip), %rcx # 0x8dd5a
movl $0xd6, %edx
callq 0x22190
leaq 0x2de53(%rip), %rdi # 0x8c305
leaq 0x2dca7(%rip), %rsi # 0x8c160
leaq 0x2de5b(%rip), %rcx # 0x8c31b
movl $0x33a, %edx # imm = 0x33A
callq 0x22190
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
ImGui::ScrollbarEx(ImRect const&, unsigned int, ImGuiAxis, float*, float, float, int)
|
bool ImGui::ScrollbarEx(const ImRect& bb_frame, ImGuiID id, ImGuiAxis axis, float* p_scroll_v, float size_avail_v, float size_contents_v, ImDrawCornerFlags rounding_corners)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (window->SkipItems)
return false;
const float bb_frame_width = bb_frame.GetWidth();
const float bb_frame_height = bb_frame.GetHeight();
if (bb_frame_width <= 0.0f || bb_frame_height <= 0.0f)
return false;
// When we are too small, start hiding and disabling the grab (this reduce visual noise on very small window and facilitate using the window resize grab)
float alpha = 1.0f;
if ((axis == ImGuiAxis_Y) && bb_frame_height < g.FontSize + g.Style.FramePadding.y * 2.0f)
alpha = ImSaturate((bb_frame_height - g.FontSize) / (g.Style.FramePadding.y * 2.0f));
if (alpha <= 0.0f)
return false;
const ImGuiStyle& style = g.Style;
const bool allow_interaction = (alpha >= 1.0f);
ImRect bb = bb_frame;
bb.Expand(ImVec2(-ImClamp(IM_FLOOR((bb_frame_width - 2.0f) * 0.5f), 0.0f, 3.0f), -ImClamp(IM_FLOOR((bb_frame_height - 2.0f) * 0.5f), 0.0f, 3.0f)));
// V denote the main, longer axis of the scrollbar (= height for a vertical scrollbar)
const float scrollbar_size_v = (axis == ImGuiAxis_X) ? bb.GetWidth() : bb.GetHeight();
// Calculate the height of our grabbable box. It generally represent the amount visible (vs the total scrollable amount)
// But we maintain a minimum size in pixel to allow for the user to still aim inside.
IM_ASSERT(ImMax(size_contents_v, size_avail_v) > 0.0f); // Adding this assert to check if the ImMax(XXX,1.0f) is still needed. PLEASE CONTACT ME if this triggers.
const float win_size_v = ImMax(ImMax(size_contents_v, size_avail_v), 1.0f);
const float grab_h_pixels = ImClamp(scrollbar_size_v * (size_avail_v / win_size_v), style.GrabMinSize, scrollbar_size_v);
const float grab_h_norm = grab_h_pixels / scrollbar_size_v;
// Handle input right away. None of the code of Begin() is relying on scrolling position before calling Scrollbar().
bool held = false;
bool hovered = false;
ButtonBehavior(bb, id, &hovered, &held, ImGuiButtonFlags_NoNavFocus);
float scroll_max = ImMax(1.0f, size_contents_v - size_avail_v);
float scroll_ratio = ImSaturate(*p_scroll_v / scroll_max);
float grab_v_norm = scroll_ratio * (scrollbar_size_v - grab_h_pixels) / scrollbar_size_v; // Grab position in normalized space
if (held && allow_interaction && grab_h_norm < 1.0f)
{
float scrollbar_pos_v = bb.Min[axis];
float mouse_pos_v = g.IO.MousePos[axis];
// Click position in scrollbar normalized space (0.0f->1.0f)
const float clicked_v_norm = ImSaturate((mouse_pos_v - scrollbar_pos_v) / scrollbar_size_v);
SetHoveredID(id);
bool seek_absolute = false;
if (g.ActiveIdIsJustActivated)
{
// On initial click calculate the distance between mouse and the center of the grab
seek_absolute = (clicked_v_norm < grab_v_norm || clicked_v_norm > grab_v_norm + grab_h_norm);
if (seek_absolute)
g.ScrollbarClickDeltaToGrabCenter = 0.0f;
else
g.ScrollbarClickDeltaToGrabCenter = clicked_v_norm - grab_v_norm - grab_h_norm * 0.5f;
}
// Apply scroll (p_scroll_v will generally point on one member of window->Scroll)
// It is ok to modify Scroll here because we are being called in Begin() after the calculation of ContentSize and before setting up our starting position
const float scroll_v_norm = ImSaturate((clicked_v_norm - g.ScrollbarClickDeltaToGrabCenter - grab_h_norm * 0.5f) / (1.0f - grab_h_norm));
*p_scroll_v = IM_ROUND(scroll_v_norm * scroll_max);//(win_size_contents_v - win_size_v));
// Update values for rendering
scroll_ratio = ImSaturate(*p_scroll_v / scroll_max);
grab_v_norm = scroll_ratio * (scrollbar_size_v - grab_h_pixels) / scrollbar_size_v;
// Update distance to grab now that we have seeked and saturated
if (seek_absolute)
g.ScrollbarClickDeltaToGrabCenter = clicked_v_norm - grab_v_norm - grab_h_norm * 0.5f;
}
// Render
const ImU32 bg_col = GetColorU32(ImGuiCol_ScrollbarBg);
const ImU32 grab_col = GetColorU32(held ? ImGuiCol_ScrollbarGrabActive : hovered ? ImGuiCol_ScrollbarGrabHovered : ImGuiCol_ScrollbarGrab, alpha);
window->DrawList->AddRectFilled(bb_frame.Min, bb_frame.Max, bg_col, window->WindowRounding, rounding_corners);
ImRect grab_rect;
if (axis == ImGuiAxis_X)
grab_rect = ImRect(ImLerp(bb.Min.x, bb.Max.x, grab_v_norm), bb.Min.y, ImLerp(bb.Min.x, bb.Max.x, grab_v_norm) + grab_h_pixels, bb.Max.y);
else
grab_rect = ImRect(bb.Min.x, ImLerp(bb.Min.y, bb.Max.y, grab_v_norm), bb.Max.x, ImLerp(bb.Min.y, bb.Max.y, grab_v_norm) + grab_h_pixels);
window->DrawList->AddRectFilled(grab_rect.Min, grab_rect.Max, grab_col, style.ScrollbarRounding);
return held;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
leaq 0x460ce(%rip), %rax # 0xa46a0
movq (%rax), %rbp
movq 0x1a80(%rbp), %r15
cmpb $0x0, 0x83(%r15)
je 0x5e5fa
xorl %eax, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movaps %xmm1, %xmm6
movq %rdi, %r14
movsd (%rdi), %xmm1
movsd 0x8(%rdi), %xmm7
subps %xmm1, %xmm7
xorl %eax, %eax
xorps %xmm2, %xmm2
ucomiss %xmm7, %xmm2
jae 0x5e5e8
movaps %xmm7, %xmm1
shufps $0x55, %xmm7, %xmm1 # xmm1 = xmm1[1,1],xmm7[1,1]
ucomiss %xmm1, %xmm2
jae 0x5e5e8
movq %rcx, %r13
movl %edx, %ebx
movl %esi, %r12d
movss 0x1f9de(%rip), %xmm5 # 0x7e010
cmpl $0x1, %edx
jne 0x5e679
movss 0x1928(%rbp), %xmm3
movss 0x15a4(%rbp), %xmm2
addss %xmm2, %xmm2
movaps %xmm2, %xmm4
addss %xmm3, %xmm4
ucomiss %xmm1, %xmm4
jbe 0x5e679
subss %xmm3, %xmm1
divss %xmm2, %xmm1
movss 0x1f9a9(%rip), %xmm2 # 0x7e010
minss %xmm1, %xmm2
xorps %xmm3, %xmm3
cmpltss %xmm3, %xmm1
andnps %xmm2, %xmm1
movaps %xmm1, %xmm5
xorps %xmm1, %xmm1
ucomiss %xmm5, %xmm1
jae 0x5e5e6
movups (%r14), %xmm1
addps 0x2d7b0(%rip), %xmm7 # 0x8be40
mulps 0x205b9(%rip), %xmm7 # 0x7ec50
cvttps2dq %xmm7, %xmm4
cvtdq2ps %xmm4, %xmm2
xorps %xmm3, %xmm3
pcmpgtd %xmm4, %xmm3
pcmpgtd 0x2d7a3(%rip), %xmm4 # 0x8be50
xorps 0x1ffac(%rip), %xmm2 # 0x7e660
movaps %xmm1, 0x10(%rsp)
movdqa %xmm4, %xmm1
pand 0x2d79b(%rip), %xmm4 # 0x8be60
pandn %xmm2, %xmm1
por %xmm1, %xmm4
movdqa %xmm3, %xmm1
pandn %xmm4, %xmm1
pand 0x2d793(%rip), %xmm3 # 0x8be70
por %xmm1, %xmm3
pshufd $0x44, %xmm3, %xmm1 # xmm1 = xmm3[0,1,0,1]
movaps 0x10(%rsp), %xmm3
movaps %xmm3, %xmm2
subps %xmm1, %xmm2
addps %xmm1, %xmm3
movaps %xmm3, %xmm1
movsd %xmm2, %xmm1 # xmm1 = xmm2[0],xmm1[1]
movapd %xmm1, 0x10(%rsp)
testl %ebx, %ebx
je 0x5e70f
shufps $0x55, %xmm2, %xmm2 # xmm2 = xmm2[1,1,1,1]
shufps $0xff, %xmm3, %xmm3 # xmm3 = xmm3[3,3,3,3]
jmp 0x5e712
movhlps %xmm3, %xmm3 # xmm3 = xmm3[1,1]
subss %xmm2, %xmm3
movss %xmm5, 0xc(%rsp)
movl %r8d, 0x2c(%rsp)
movaps %xmm0, %xmm2
cmpless %xmm6, %xmm2
movaps %xmm2, %xmm1
andps %xmm6, %xmm1
andnps %xmm0, %xmm2
orps %xmm1, %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm2
movaps %xmm6, 0x30(%rsp)
jbe 0x5eaef
movss 0x1f8c2(%rip), %xmm1 # 0x7e010
maxss %xmm1, %xmm2
movaps %xmm0, %xmm5
divss %xmm2, %xmm5
mulss %xmm3, %xmm5
movss 0x15d8(%rbp), %xmm4
movaps %xmm3, %xmm1
minss %xmm5, %xmm1
cmpltss %xmm4, %xmm5
movaps %xmm5, %xmm2
andnps %xmm1, %xmm2
andps %xmm4, %xmm5
orps %xmm2, %xmm5
movaps %xmm5, 0x60(%rsp)
xorl %eax, %eax
leaq 0xa(%rsp), %rcx
movb %al, (%rcx)
leaq 0xb(%rsp), %rdx
movb %al, (%rdx)
leaq 0x10(%rsp), %rdi
movl %r12d, %esi
movl $0x4000, %r8d # imm = 0x4000
movaps %xmm3, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
callq 0x5d4bf
movss 0x1f859(%rip), %xmm4 # 0x7e010
movaps 0x50(%rsp), %xmm3
movaps 0x60(%rsp), %xmm2
movaps 0x30(%rsp), %xmm0
subss 0x40(%rsp), %xmm0
movaps %xmm4, %xmm6
maxss %xmm0, %xmm6
movss (%r13), %xmm0
movaps %xmm2, %xmm5
unpcklps %xmm0, %xmm5 # xmm5 = xmm5[0],xmm0[0],xmm5[1],xmm0[1]
movaps %xmm3, %xmm0
unpcklps %xmm6, %xmm0 # xmm0 = xmm0[0],xmm6[0],xmm0[1],xmm6[1]
divps %xmm0, %xmm5
movss 0x1f820(%rip), %xmm0 # 0x7e010
movaps %xmm5, %xmm1
cmpltps %xmm0, %xmm1
unpcklps %xmm1, %xmm1 # xmm1 = xmm1[0,0,1,1]
movmskpd %xmm1, %eax
testb $0x2, %al
xorps %xmm1, %xmm1
jne 0x5e813
movaps %xmm5, %xmm0
shufps $0x55, %xmm5, %xmm0 # xmm0 = xmm0[1,1],xmm5[1,1]
movaps %xmm4, %xmm1
minss %xmm0, %xmm1
movss 0xc(%rsp), %xmm0
ucomiss %xmm4, %xmm0
movaps %xmm3, %xmm0
subss %xmm2, %xmm0
mulss %xmm0, %xmm1
divss %xmm3, %xmm1
movaps %xmm1, 0x30(%rsp)
jb 0x5e9dc
testb $0x1, %al
je 0x5e9dc
cmpb $0x0, 0xa(%rsp)
je 0x5e9dc
movaps %xmm0, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm5, 0x40(%rsp)
cmpl $0x2, %ebx
jae 0x5eb0e
movl %ebx, %eax
movss 0x130(%rbp,%rax,4), %xmm2
subss 0x10(%rsp,%rax,4), %xmm2
divss %xmm3, %xmm2
movaps %xmm4, %xmm0
minss %xmm2, %xmm0
xorps %xmm1, %xmm1
cmpltss %xmm1, %xmm2
andnps %xmm0, %xmm2
movaps %xmm2, 0x70(%rsp)
movl %r12d, %edi
callq 0x352c8
cmpb $0x1, 0x1ad4(%rbp)
jne 0x5e915
movaps 0x40(%rsp), %xmm5
movaps %xmm5, %xmm0
movaps 0x30(%rsp), %xmm2
addss %xmm2, %xmm0
movaps 0x70(%rsp), %xmm8
movaps %xmm8, %xmm1
cmpltps %xmm2, %xmm1
cmpltps %xmm8, %xmm0
orps %xmm1, %xmm0
movd %xmm0, %eax
xorps %xmm0, %xmm0
testb $0x1, %al
movaps 0x90(%rsp), %xmm6
movaps 0x80(%rsp), %xmm7
jne 0x5e8fe
movaps %xmm8, %xmm1
subss %xmm2, %xmm1
movss 0x205e6(%rip), %xmm0 # 0x7eedc
mulss %xmm5, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x2f68(%rbp)
movaps 0x50(%rsp), %xmm3
movss 0x1f6fd(%rip), %xmm4 # 0x7e010
jmp 0x5e93f
xorl %eax, %eax
movaps 0x50(%rsp), %xmm3
movss 0x1f6ec(%rip), %xmm4 # 0x7e010
movaps 0x40(%rsp), %xmm5
movaps 0x90(%rsp), %xmm6
movaps 0x80(%rsp), %xmm7
movaps 0x70(%rsp), %xmm8
xorps %xmm9, %xmm9
movss 0x2f68(%rbp), %xmm0
movaps %xmm8, %xmm1
subss %xmm0, %xmm1
movss 0x204fd(%rip), %xmm0 # 0x7ee58
movaps %xmm5, %xmm2
mulss %xmm0, %xmm2
subss %xmm2, %xmm1
movaps %xmm4, %xmm2
subss %xmm5, %xmm2
divss %xmm2, %xmm1
movaps %xmm4, %xmm2
minss %xmm1, %xmm2
cmpltss %xmm9, %xmm1
andnps %xmm2, %xmm1
mulss %xmm6, %xmm1
addss %xmm0, %xmm1
cvttps2dq %xmm1, %xmm0
cvtdq2ps %xmm0, %xmm0
movss %xmm0, (%r13)
divss %xmm6, %xmm0
minss %xmm0, %xmm4
cmpltss %xmm9, %xmm0
andnps %xmm4, %xmm0
mulss %xmm0, %xmm7
movaps %xmm7, %xmm0
divss %xmm3, %xmm0
testb $0x1, %al
movaps %xmm0, 0x30(%rsp)
je 0x5e9dc
xorps 0x1fc9e(%rip), %xmm5 # 0x7e660
subss %xmm0, %xmm8
mulss 0x20489(%rip), %xmm5 # 0x7ee58
addss %xmm8, %xmm5
movss %xmm5, 0x2f68(%rbp)
leaq 0x8(%r14), %r12
movss 0x1f628(%rip), %xmm0 # 0x7e010
movl $0xe, %edi
callq 0x32e01
movzbl 0xb(%rsp), %ecx
andl $0x1, %ecx
addl $0xf, %ecx
cmpb $0x0, 0xa(%rsp)
movl %eax, %r13d
movl $0x11, %edi
cmovel %ecx, %edi
movss 0xc(%rsp), %xmm0
callq 0x32e01
movl %eax, 0xc(%rsp)
movq 0x2b0(%r15), %rdi
movss 0x40(%r15), %xmm0
movq %r14, %rsi
movq %r12, %rdx
movl %r13d, %ecx
movl 0x2c(%rsp), %r8d
callq 0x4ea4c
xorps %xmm0, %xmm0
movaps %xmm0, 0xa0(%rsp)
movss 0x10(%rsp), %xmm0
testl %ebx, %ebx
je 0x5ea7c
movss 0x1c(%rsp), %xmm1
movss 0x14(%rsp), %xmm3
movaps 0x60(%rsp), %xmm2
movss 0x18(%rsp), %xmm4
subss %xmm3, %xmm1
mulss 0x30(%rsp), %xmm1
addss %xmm3, %xmm1
addss %xmm1, %xmm2
jmp 0x5eaa5
movss 0x14(%rsp), %xmm1
movss 0x18(%rsp), %xmm2
subss %xmm0, %xmm2
mulss 0x30(%rsp), %xmm2
addss %xmm2, %xmm0
movaps 0x60(%rsp), %xmm4
addss %xmm0, %xmm4
movss 0x1c(%rsp), %xmm2
leaq 0xa8(%rsp), %rdx
movss %xmm0, -0x8(%rdx)
movss %xmm1, -0x4(%rdx)
movss %xmm4, (%rdx)
movss %xmm2, 0x4(%rdx)
movq 0x2b0(%r15), %rdi
movss 0x15d4(%rbp), %xmm0
leaq 0xa0(%rsp), %rsi
movl 0xc(%rsp), %ecx
movl $0xf, %r8d
callq 0x4ea4c
movb 0xa(%rsp), %al
jmp 0x5e5e8
leaq 0x2d864(%rip), %rdi # 0x8c35a
leaq 0x2d663(%rip), %rsi # 0x8c160
leaq 0x2d882(%rip), %rcx # 0x8c386
movl $0x382, %edx # imm = 0x382
callq 0x22190
leaq 0x2f23c(%rip), %rdi # 0x8dd51
leaq 0x23135(%rip), %rsi # 0x81c51
leaq 0x2f237(%rip), %rcx # 0x8dd5a
movl $0xd6, %edx
callq 0x22190
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
ImGui::ShrinkWidths(ImGuiShrinkWidthItem*, int, float)
|
void ImGui::ShrinkWidths(ImGuiShrinkWidthItem* items, int count, float width_excess)
{
if (count == 1)
{
items[0].Width = ImMax(items[0].Width - width_excess, 1.0f);
return;
}
ImQsort(items, (size_t)count, sizeof(ImGuiShrinkWidthItem), ShrinkWidthItemComparer);
int count_same_width = 1;
while (width_excess > 0.0f && count_same_width < count)
{
while (count_same_width < count && items[0].Width <= items[count_same_width].Width)
count_same_width++;
float max_width_to_remove_per_item = (count_same_width < count) ? (items[0].Width - items[count_same_width].Width) : (items[0].Width - 1.0f);
float width_to_remove_per_item = ImMin(width_excess / count_same_width, max_width_to_remove_per_item);
for (int item_n = 0; item_n < count_same_width; item_n++)
items[item_n].Width -= width_to_remove_per_item;
width_excess -= width_to_remove_per_item * count_same_width;
}
// Round width and redistribute remainder left-to-right (could make it an option of the function?)
// Ensure that e.g. the right-most tab of a shrunk tab-bar always reaches exactly at the same distance from the right-most edge of the tab bar separator.
width_excess = 0.0f;
for (int n = 0; n < count; n++)
{
float width_rounded = ImFloor(items[n].Width);
width_excess += items[n].Width - width_rounded;
items[n].Width = width_rounded;
}
if (width_excess > 0.0f)
for (int n = 0; n < count; n++)
if (items[n].Index < (int)(width_excess + 0.01f))
items[n].Width += 1.0f;
}
|
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, %esi
jne 0x601b3
movss 0x4(%rbx), %xmm1
subss %xmm0, %xmm1
maxss 0x1de67(%rip), %xmm1 # 0x7e010
movss %xmm1, 0x4(%rbx)
jmp 0x602e0
movl %esi, %ebp
movslq %esi, %rsi
leaq 0x128(%rip), %rcx # 0x602e7
movl $0x8, %edx
movq %rbx, %rdi
movss %xmm0, 0x4(%rsp)
callq 0x225c0
movss 0x4(%rsp), %xmm5
movl %ebp, %eax
cmpl $0x2, %ebp
jl 0x6026f
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm5
jbe 0x6026f
movl $0x1, %ecx
movss 0x1de0c(%rip), %xmm1 # 0x7e008
movss 0x4(%rbx), %xmm2
movslq %ecx, %rcx
movss 0x4(%rbx,%rcx,8), %xmm3
ucomiss %xmm2, %xmm3
jb 0x60222
incq %rcx
cmpq %rax, %rcx
jl 0x60204
movss 0x4(%rbx), %xmm2
addss %xmm1, %xmm2
jmp 0x60226
subss %xmm3, %xmm2
xorps %xmm4, %xmm4
cvtsi2ss %ecx, %xmm4
movaps %xmm5, %xmm3
divss %xmm4, %xmm3
minss %xmm2, %xmm3
testl %ecx, %ecx
jle 0x6025e
movl %ecx, %edx
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
xorl %esi, %esi
movss 0x4(%rbx,%rsi,8), %xmm2
subss %xmm3, %xmm2
movss %xmm2, 0x4(%rbx,%rsi,8)
incq %rsi
cmpq %rsi, %rdx
jne 0x60246
cmpl %ebp, %ecx
jge 0x6026f
mulss %xmm4, %xmm3
subss %xmm3, %xmm5
ucomiss %xmm0, %xmm5
ja 0x601fc
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
testl %ebp, %ebp
jle 0x6029e
xorl %ecx, %ecx
movss 0x4(%rbx,%rcx,8), %xmm2
cvttps2dq %xmm2, %xmm3
cvtdq2ps %xmm3, %xmm3
subss %xmm3, %xmm2
addss %xmm2, %xmm0
movss %xmm3, 0x4(%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x6027b
ucomiss %xmm1, %xmm0
setbe %cl
testl %ebp, %ebp
setle %dl
orb %cl, %dl
jne 0x602e0
addss 0x2bafb(%rip), %xmm0 # 0x8bdb0
cvttss2si %xmm0, %ecx
xorl %edx, %edx
movss 0x1dd4d(%rip), %xmm0 # 0x7e010
cmpl %ecx, (%rbx,%rdx,8)
jge 0x602d8
movss 0x4(%rbx,%rdx,8), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x4(%rbx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x602c3
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
ImGui::Combo(char const*, int*, bool (*)(void*, int, char const**), void*, int, int)
|
bool ImGui::Combo(const char* label, int* current_item, bool (*items_getter)(void*, int, const char**), void* data, int items_count, int popup_max_height_in_items)
{
ImGuiContext& g = *GImGui;
// Call the getter to obtain the preview string which is a parameter to BeginCombo()
const char* preview_value = NULL;
if (*current_item >= 0 && *current_item < items_count)
items_getter(data, *current_item, &preview_value);
// The old Combo() API exposed "popup_max_height_in_items". The new more general BeginCombo() API doesn't have/need it, but we emulate it here.
if (popup_max_height_in_items != -1 && !(g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSizeConstraint))
SetNextWindowSizeConstraints(ImVec2(0,0), ImVec2(FLT_MAX, CalcMaxPopupHeightFromItemCount(popup_max_height_in_items)));
if (!BeginCombo(label, preview_value, ImGuiComboFlags_None))
return false;
// Display items
// FIXME-OPT: Use clipper (but we need to disable it on the appearing frame to make sure our call to SetItemDefaultFocus() is processed)
bool value_changed = false;
for (int i = 0; i < items_count; i++)
{
PushID((void*)(intptr_t)i);
const bool item_selected = (i == *current_item);
const char* item_text;
if (!items_getter(data, i, &item_text))
item_text = "*Unknown item*";
if (Selectable(item_text, item_selected))
{
value_changed = true;
*current_item = i;
}
if (item_selected)
SetItemDefaultFocus();
PopID();
}
EndCombo();
return value_changed;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %r12d
movl %r8d, %ebp
movq %rcx, 0x10(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
leaq 0x43c77(%rip), %rdx # 0xa46a0
movq (%rdx), %rbx
movq $0x0, 0x20(%rsp)
movl (%rsi), %esi
testl %esi, %esi
sets %al
cmpl %r8d, %esi
setge %cl
orb %al, %cl
jne 0x60a5a
leaq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rdi
callq *%r14
leaq 0x43c46(%rip), %rdx # 0xa46a0
cmpl $-0x1, %r12d
je 0x60ad3
testb $0x10, 0x1b20(%rbx)
jne 0x60ad3
movq $0x0, 0x8(%rsp)
testl %r12d, %r12d
jle 0x60aad
movq (%rdx), %rax
movss 0x1570(%rax), %xmm0
movss 0x15b4(%rax), %xmm1
movss 0x1928(%rax), %xmm2
addss %xmm1, %xmm2
cvtsi2ss %r12d, %xmm3
mulss %xmm2, %xmm3
subss %xmm1, %xmm3
addss %xmm0, %xmm0
addss %xmm3, %xmm0
jmp 0x60ab5
movss 0x1e39b(%rip), %xmm0 # 0x7ee50
leaq 0x18(%rsp), %rsi
movl $0x7f7fffff, (%rsi) # imm = 0x7F7FFFFF
movss %xmm0, 0x4(%rsi)
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x42232
movq 0x20(%rsp), %rsi
xorl %r12d, %r12d
movq %r13, %rdi
xorl %edx, %edx
callq 0x602ff
testb %al, %al
je 0x60b72
testl %ebp, %ebp
jle 0x60b6a
movl %ebp, %ebp
xorl %r13d, %r13d
xorl %r12d, %r12d
movq %r13, %rdi
callq 0x42934
movl (%r15), %ebx
movq 0x10(%rsp), %rdi
movl %r13d, %esi
leaq 0x8(%rsp), %rdx
callq *%r14
testb %al, %al
jne 0x60b24
leaq 0x2bb51(%rip), %rax # 0x8c670
movq %rax, 0x8(%rsp)
xorl %esi, %esi
cmpq %rbx, %r13
sete %sil
movq 0x8(%rsp), %rdi
movq $0x0, 0x18(%rsp)
xorl %edx, %edx
leaq 0x18(%rsp), %rcx
callq 0x60b88
testb %al, %al
je 0x60b51
movl %r13d, (%r15)
movb $0x1, %r12b
cmpq %rbx, %r13
jne 0x60b5b
callq 0x42575
callq 0x42c26
incq %r13
cmpq %r13, %rbp
jne 0x60af9
jmp 0x60b6d
xorl %r12d, %r12d
callq 0x449a2
andb $0x1, %r12b
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
Items_SingleStringGetter(void*, int, char const**)
|
static bool Items_SingleStringGetter(void* data, int idx, const char** out_text)
{
// FIXME-OPT: we could pre-compute the indices to fasten this. But only 1 active combo means the waste is limited.
const char* items_separated_by_zeros = (const char*)data;
int items_count = 0;
const char* p = items_separated_by_zeros;
while (*p)
{
if (idx == items_count)
break;
p += strlen(p) + 1;
items_count++;
}
if (!*p)
return false;
if (out_text)
*out_text = p;
return true;
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movb (%rdi), %al
testb %al, %al
sete %cl
testl %esi, %esi
sete %dl
orb %cl, %dl
jne 0x61098
movl %esi, %ebp
decl %ebp
movq %r14, %rdi
callq 0x22340
addq %rax, %r14
incq %r14
movb (%r14), %al
subl $0x1, %ebp
setb %cl
testb %al, %al
je 0x61098
testb %cl, %cl
je 0x61079
testq %rbx, %rbx
je 0x610a4
testb %al, %al
je 0x610a4
movq %r14, (%rbx)
testb %al, %al
setne %al
popq %rbx
popq %r14
popq %rbp
retq
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
ImGui::DataTypeApplyOpFromText(char const*, char const*, int, void*, char const*)
|
bool ImGui::DataTypeApplyOpFromText(const char* buf, const char* initial_value_buf, ImGuiDataType data_type, void* p_data, const char* format)
{
while (ImCharIsBlankA(*buf))
buf++;
// We don't support '-' op because it would conflict with inputing negative value.
// Instead you can use +-100 to subtract from an existing value
char op = buf[0];
if (op == '+' || op == '*' || op == '/')
{
buf++;
while (ImCharIsBlankA(*buf))
buf++;
}
else
{
op = 0;
}
if (!buf[0])
return false;
// Copy the value in an opaque buffer so we can compare at the end of the function if it changed at all.
const ImGuiDataTypeInfo* type_info = DataTypeGetInfo(data_type);
ImGuiDataTypeTempStorage data_backup;
memcpy(&data_backup, p_data, type_info->Size);
if (format == NULL)
format = type_info->ScanFmt;
// FIXME-LEGACY: The aim is to remove those operators and write a proper expression evaluator at some point..
int arg1i = 0;
if (data_type == ImGuiDataType_S32)
{
int* v = (int*)p_data;
int arg0i = *v;
float arg1f = 0.0f;
if (op && sscanf(initial_value_buf, format, &arg0i) < 1)
return false;
// Store operand in a float so we can use fractional value for multipliers (*1.1), but constant always parsed as integer so we can fit big integers (e.g. 2000000003) past float precision
if (op == '+') { if (sscanf(buf, "%d", &arg1i)) *v = (int)(arg0i + arg1i); } // Add (use "+-" to subtract)
else if (op == '*') { if (sscanf(buf, "%f", &arg1f)) *v = (int)(arg0i * arg1f); } // Multiply
else if (op == '/') { if (sscanf(buf, "%f", &arg1f) && arg1f != 0.0f) *v = (int)(arg0i / arg1f); } // Divide
else { if (sscanf(buf, format, &arg1i) == 1) *v = arg1i; } // Assign constant
}
else if (data_type == ImGuiDataType_Float)
{
// For floats we have to ignore format with precision (e.g. "%.2f") because sscanf doesn't take them in
format = "%f";
float* v = (float*)p_data;
float arg0f = *v, arg1f = 0.0f;
if (op && sscanf(initial_value_buf, format, &arg0f) < 1)
return false;
if (sscanf(buf, format, &arg1f) < 1)
return false;
if (op == '+') { *v = arg0f + arg1f; } // Add (use "+-" to subtract)
else if (op == '*') { *v = arg0f * arg1f; } // Multiply
else if (op == '/') { if (arg1f != 0.0f) *v = arg0f / arg1f; } // Divide
else { *v = arg1f; } // Assign constant
}
else if (data_type == ImGuiDataType_Double)
{
format = "%lf"; // scanf differentiate float/double unlike printf which forces everything to double because of ellipsis
double* v = (double*)p_data;
double arg0f = *v, arg1f = 0.0;
if (op && sscanf(initial_value_buf, format, &arg0f) < 1)
return false;
if (sscanf(buf, format, &arg1f) < 1)
return false;
if (op == '+') { *v = arg0f + arg1f; } // Add (use "+-" to subtract)
else if (op == '*') { *v = arg0f * arg1f; } // Multiply
else if (op == '/') { if (arg1f != 0.0f) *v = arg0f / arg1f; } // Divide
else { *v = arg1f; } // Assign constant
}
else if (data_type == ImGuiDataType_U32 || data_type == ImGuiDataType_S64 || data_type == ImGuiDataType_U64)
{
// All other types assign constant
// We don't bother handling support for legacy operators since they are a little too crappy. Instead we will later implement a proper expression evaluator in the future.
sscanf(buf, format, p_data);
}
else
{
// Small types need a 32-bit buffer to receive the result from scanf()
int v32;
sscanf(buf, format, &v32);
if (data_type == ImGuiDataType_S8)
*(ImS8*)p_data = (ImS8)ImClamp(v32, (int)IM_S8_MIN, (int)IM_S8_MAX);
else if (data_type == ImGuiDataType_U8)
*(ImU8*)p_data = (ImU8)ImClamp(v32, (int)IM_U8_MIN, (int)IM_U8_MAX);
else if (data_type == ImGuiDataType_S16)
*(ImS16*)p_data = (ImS16)ImClamp(v32, (int)IM_S16_MIN, (int)IM_S16_MAX);
else if (data_type == ImGuiDataType_U16)
*(ImU16*)p_data = (ImU16)ImClamp(v32, (int)IM_U16_MIN, (int)IM_U16_MAX);
else
IM_ASSERT(0);
}
return memcmp(&data_backup, p_data, type_info->Size) != 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %r15
movabsq $0x100000200, %rax # imm = 0x100000200
movzbl (%r15), %r14d
cmpq $0x2f, %r14
ja 0x615c6
btq %r14, %rax
jae 0x615a3
incq %r15
jmp 0x6158e
movabsq $0x8c0000000000, %rax # imm = 0x8C0000000000
btq %r14, %rax
jae 0x615c6
incq %r15
movzbl (%r15), %eax
cmpl $0x20, %eax
je 0x615b3
cmpl $0x9, %eax
je 0x615b3
jmp 0x615c9
xorl %r14d, %r14d
cmpb $0x0, (%r15)
je 0x617f2
movq %rsi, 0x30(%rsp)
cmpl $0xa, %ebp
jae 0x61a29
movq %r8, %rbx
movl %ebp, %eax
movq %rax, 0x38(%rsp)
leaq (%rax,%rax,2), %r13
leaq 0x425ba(%rip), %r12 # 0xa3bb0
movq (%r12,%r13,8), %rdx
leaq 0x40(%rsp), %rdi
movq %rcx, 0x10(%rsp)
movq %rcx, %rsi
movq %rdx, 0x20(%rsp)
callq 0x220a0
movq %rbx, %rsi
testq %rbx, %rbx
jne 0x61621
leaq (%r12,%r13,8), %rax
movq 0x10(%rax), %rsi
movl $0x0, 0x2c(%rsp)
cmpl $0x9, %ebp
je 0x61764
cmpl $0x8, %ebp
movq 0x10(%rsp), %rdx
je 0x616d4
cmpl $0x4, %ebp
jne 0x617f9
movl (%rdx), %eax
movl %eax, 0x8(%rsp)
movl $0x0, 0x18(%rsp)
testb %r14b, %r14b
je 0x6186b
leaq 0x8(%rsp), %rdx
movq 0x30(%rsp), %rdi
movq %rsi, %rbx
xorl %eax, %eax
callq 0x220e0
testl %eax, %eax
jle 0x617f2
cmpb $0x2a, %r14b
je 0x619d5
movzbl %r14b, %eax
cmpl $0x2f, %eax
je 0x6198e
cmpl $0x2b, %eax
movq %rbx, %rsi
jne 0x6186b
leaq 0x2041a(%rip), %rsi # 0x81ac0
leaq 0x2c(%rsp), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x220e0
testl %eax, %eax
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
je 0x61a0b
movl 0x2c(%rsp), %eax
addl 0x8(%rsp), %eax
jmp 0x61a09
movss (%rdx), %xmm0
movss %xmm0, 0x8(%rsp)
movl $0x0, 0x18(%rsp)
testb %r14b, %r14b
je 0x6170b
leaq 0x2b0bb(%rip), %rsi # 0x8c7ad
leaq 0x8(%rsp), %rdx
movq 0x30(%rsp), %rdi
xorl %eax, %eax
callq 0x220e0
testl %eax, %eax
jle 0x617f2
leaq 0x2b09b(%rip), %rsi # 0x8c7ad
leaq 0x18(%rsp), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x220e0
testl %eax, %eax
jle 0x617f2
cmpb $0x2a, %r14b
je 0x6191c
movzbl %r14b, %eax
cmpl $0x2f, %eax
movq 0x20(%rsp), %rdx
je 0x618f7
cmpl $0x2b, %eax
movq 0x10(%rsp), %rsi
jne 0x6195b
movss 0x8(%rsp), %xmm0
addss 0x18(%rsp), %xmm0
jmp 0x61961
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
testb %r14b, %r14b
je 0x6179d
leaq 0x2b028(%rip), %rsi # 0x8c7b0
leaq 0x8(%rsp), %rdx
movq 0x30(%rsp), %rdi
xorl %eax, %eax
callq 0x220e0
testl %eax, %eax
jle 0x617f2
leaq 0x2b00c(%rip), %rsi # 0x8c7b0
leaq 0x18(%rsp), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x220e0
testl %eax, %eax
jle 0x617f2
cmpb $0x2a, %r14b
je 0x6196a
movzbl %r14b, %eax
cmpl $0x2f, %eax
movq 0x20(%rsp), %rdx
je 0x61934
cmpl $0x2b, %eax
movq 0x10(%rsp), %rsi
jne 0x61982
movsd 0x8(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
jmp 0x61988
xorl %eax, %eax
jmp 0x61a1a
leal -0x5(%rbp), %eax
cmpl $0x2, %eax
ja 0x6181a
movq %r15, %rdi
xorl %eax, %eax
callq 0x220e0
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
jmp 0x61a0b
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x220e0
cmpl $0x3, %ebp
ja 0x61a48
leaq 0x2a7c7(%rip), %rax # 0x8c000
movq 0x38(%rsp), %rcx
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
movq 0x20(%rsp), %rdx
jmpq *%rcx
movl 0x8(%rsp), %eax
cmpl $0x7f, %eax
movl $0x7f, %ecx
cmovll %eax, %ecx
cmpl $-0x7f, %ecx
movl $0xffffff80, %eax # imm = 0xFFFFFF80
cmovgel %ecx, %eax
jmp 0x618eb
leaq 0x2c(%rsp), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x220e0
cmpl $0x1, %eax
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
jne 0x61a0b
movl 0x2c(%rsp), %eax
jmp 0x61a09
movl 0x8(%rsp), %eax
movl $0x7fff, %ecx # imm = 0x7FFF
cmpl %ecx, %eax
cmovll %eax, %ecx
cmpl $0xffff8001, %ecx # imm = 0xFFFF8001
movl $0xffff8000, %eax # imm = 0xFFFF8000
cmovgel %ecx, %eax
jmp 0x618c9
movl 0x8(%rsp), %eax
movl $0xffff, %ecx # imm = 0xFFFF
cmpl %ecx, %eax
cmovll %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
movq 0x10(%rsp), %rsi
movw %ax, (%rsi)
jmp 0x61a0b
movl 0x8(%rsp), %eax
movl $0xff, %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
movq 0x10(%rsp), %rsi
movb %al, (%rsi)
jmp 0x61a0b
movss 0x18(%rsp), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
movq 0x10(%rsp), %rsi
jne 0x61910
jnp 0x61a0b
movss 0x8(%rsp), %xmm0
divss %xmm1, %xmm0
jmp 0x61961
movss 0x8(%rsp), %xmm0
mulss 0x18(%rsp), %xmm0
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
jmp 0x61961
movsd 0x18(%rsp), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
movq 0x10(%rsp), %rsi
jne 0x6194f
jnp 0x61a0b
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
jmp 0x61988
movss 0x18(%rsp), %xmm0
movss %xmm0, (%rsi)
jmp 0x61a0b
movsd 0x8(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
jmp 0x61988
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsi)
jmp 0x61a0b
leaq 0x2ae18(%rip), %rsi # 0x8c7ad
leaq 0x18(%rsp), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x220e0
testl %eax, %eax
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
je 0x61a0b
movss 0x18(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x619c2
jnp 0x61a0b
xorps %xmm1, %xmm1
cvtsi2ssl 0x8(%rsp), %xmm1
divss %xmm0, %xmm1
cvttss2si %xmm1, %eax
jmp 0x61a09
leaq 0x2add1(%rip), %rsi # 0x8c7ad
leaq 0x18(%rsp), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x220e0
testl %eax, %eax
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
je 0x61a0b
cvtsi2ssl 0x8(%rsp), %xmm0
mulss 0x18(%rsp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, (%rsi)
leaq 0x40(%rsp), %rdi
callq 0x22560
testl %eax, %eax
setne %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ac4f(%rip), %rdi # 0x8c67f
leaq 0x2a729(%rip), %rsi # 0x8c160
leaq 0x2ac73(%rip), %rcx # 0x8c6b1
movl $0x6bb, %edx # imm = 0x6BB
callq 0x22190
leaq 0x1f3b7(%rip), %rdi # 0x80e06
leaq 0x2a70a(%rip), %rsi # 0x8c160
leaq 0x2ad57(%rip), %rcx # 0x8c7b4
movl $0x767, %edx # imm = 0x767
callq 0x22190
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
ImGui::DragBehavior(unsigned int, int, void*, float, void const*, void const*, char const*, float, int)
|
bool ImGui::DragBehavior(ImGuiID id, ImGuiDataType data_type, void* p_v, float v_speed, const void* p_min, const void* p_max, const char* format, float power, ImGuiDragFlags flags)
{
ImGuiContext& g = *GImGui;
if (g.ActiveId == id)
{
if (g.ActiveIdSource == ImGuiInputSource_Mouse && !g.IO.MouseDown[0])
ClearActiveID();
else if (g.ActiveIdSource == ImGuiInputSource_Nav && g.NavActivatePressedId == id && !g.ActiveIdIsJustActivated)
ClearActiveID();
}
if (g.ActiveId != id)
return false;
switch (data_type)
{
case ImGuiDataType_S8: { ImS32 v32 = (ImS32)*(ImS8*)p_v; bool r = DragBehaviorT<ImS32, ImS32, float>(ImGuiDataType_S32, &v32, v_speed, p_min ? *(const ImS8*) p_min : IM_S8_MIN, p_max ? *(const ImS8*)p_max : IM_S8_MAX, format, power, flags); if (r) *(ImS8*)p_v = (ImS8)v32; return r; }
case ImGuiDataType_U8: { ImU32 v32 = (ImU32)*(ImU8*)p_v; bool r = DragBehaviorT<ImU32, ImS32, float>(ImGuiDataType_U32, &v32, v_speed, p_min ? *(const ImU8*) p_min : IM_U8_MIN, p_max ? *(const ImU8*)p_max : IM_U8_MAX, format, power, flags); if (r) *(ImU8*)p_v = (ImU8)v32; return r; }
case ImGuiDataType_S16: { ImS32 v32 = (ImS32)*(ImS16*)p_v; bool r = DragBehaviorT<ImS32, ImS32, float>(ImGuiDataType_S32, &v32, v_speed, p_min ? *(const ImS16*)p_min : IM_S16_MIN, p_max ? *(const ImS16*)p_max : IM_S16_MAX, format, power, flags); if (r) *(ImS16*)p_v = (ImS16)v32; return r; }
case ImGuiDataType_U16: { ImU32 v32 = (ImU32)*(ImU16*)p_v; bool r = DragBehaviorT<ImU32, ImS32, float>(ImGuiDataType_U32, &v32, v_speed, p_min ? *(const ImU16*)p_min : IM_U16_MIN, p_max ? *(const ImU16*)p_max : IM_U16_MAX, format, power, flags); if (r) *(ImU16*)p_v = (ImU16)v32; return r; }
case ImGuiDataType_S32: return DragBehaviorT<ImS32, ImS32, float >(data_type, (ImS32*)p_v, v_speed, p_min ? *(const ImS32* )p_min : IM_S32_MIN, p_max ? *(const ImS32* )p_max : IM_S32_MAX, format, power, flags);
case ImGuiDataType_U32: return DragBehaviorT<ImU32, ImS32, float >(data_type, (ImU32*)p_v, v_speed, p_min ? *(const ImU32* )p_min : IM_U32_MIN, p_max ? *(const ImU32* )p_max : IM_U32_MAX, format, power, flags);
case ImGuiDataType_S64: return DragBehaviorT<ImS64, ImS64, double>(data_type, (ImS64*)p_v, v_speed, p_min ? *(const ImS64* )p_min : IM_S64_MIN, p_max ? *(const ImS64* )p_max : IM_S64_MAX, format, power, flags);
case ImGuiDataType_U64: return DragBehaviorT<ImU64, ImS64, double>(data_type, (ImU64*)p_v, v_speed, p_min ? *(const ImU64* )p_min : IM_U64_MIN, p_max ? *(const ImU64* )p_max : IM_U64_MAX, format, power, flags);
case ImGuiDataType_Float: return DragBehaviorT<float, float, float >(data_type, (float*)p_v, v_speed, p_min ? *(const float* )p_min : -FLT_MAX, p_max ? *(const float* )p_max : FLT_MAX, format, power, flags);
case ImGuiDataType_Double: return DragBehaviorT<double,double,double>(data_type, (double*)p_v, v_speed, p_min ? *(const double*)p_min : -DBL_MAX, p_max ? *(const double*)p_max : DBL_MAX, format, power, flags);
case ImGuiDataType_COUNT: break;
}
IM_ASSERT(0);
return false;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movaps %xmm1, %xmm3
movq %r9, %r15
movq %rcx, %r12
movq %rdx, %rbx
movl %esi, %r13d
movl %edi, %ebp
movl 0x60(%rsp), %r9d
leaq 0x42ad6(%rip), %rax # 0xa46a0
movq (%rax), %r14
cmpl %edi, 0x1ac8(%r14)
jne 0x61c40
movl 0x1b00(%r14), %eax
cmpl $0x2, %eax
je 0x61bf6
cmpl $0x1, %eax
jne 0x61c40
cmpb $0x1, 0x138(%r14)
jne 0x61c09
cmpl $0x2, %eax
jne 0x61c40
cmpl %ebp, 0x1c10(%r14)
jne 0x61c40
cmpb $0x0, 0x1ad4(%r14)
jne 0x61c40
movq %rbx, 0x20(%rsp)
movl %r9d, %ebx
movss %xmm3, 0x14(%rsp)
movss %xmm0, 0x10(%rsp)
movq %r8, 0x18(%rsp)
callq 0x35270
movq 0x18(%rsp), %r8
movss 0x10(%rsp), %xmm0
movss 0x14(%rsp), %xmm3
movl %ebx, %r9d
movq 0x20(%rsp), %rbx
cmpl %ebp, 0x1ac8(%r14)
jne 0x61c80
cmpl $0x9, %r13d
ja 0x61f69
movl %r13d, %eax
leaq 0x2a3db(%rip), %rcx # 0x8c038
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsbl (%rbx), %eax
movl %eax, 0xc(%rsp)
testq %r12, %r12
je 0x61e67
movsbl (%r12), %edx
jmp 0x61e6c
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r12, %r12
je 0x61d59
movl (%r12), %edx
jmp 0x61d5e
testq %r12, %r12
je 0x61d8e
movsd (%r12), %xmm1
jmp 0x61d96
movswl (%rbx), %eax
movl %eax, 0xc(%rsp)
testq %r12, %r12
je 0x61dcb
movswl (%r12), %edx
jmp 0x61dd0
movzwl (%rbx), %eax
movl %eax, 0xc(%rsp)
testq %r12, %r12
je 0x61df7
movzwl (%r12), %edx
jmp 0x61df9
testq %r12, %r12
je 0x61e33
movq (%r12), %rdx
jmp 0x61e35
movzbl (%rbx), %eax
movl %eax, 0xc(%rsp)
testq %r12, %r12
je 0x61e77
movzbl (%r12), %edx
jmp 0x61e79
testq %r12, %r12
je 0x61ecd
movl (%r12), %edx
jmp 0x61ecf
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
testq %r12, %r12
je 0x61eff
movq (%r12), %rdx
jmp 0x61f03
testq %r12, %r12
je 0x61f2c
movss (%r12), %xmm1
jmp 0x61f34
movl $0x80000000, %edx # imm = 0x80000000
testq %r8, %r8
je 0x61d68
movl (%r8), %ecx
jmp 0x61d6d
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
movl $0x4, %edi
movq %rbx, %rsi
movq %r15, %r8
movaps %xmm3, %xmm1
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x73734
movsd 0x1d90a(%rip), %xmm1 # 0x7f6a0
testq %r8, %r8
je 0x61da2
movsd (%r8), %xmm2
jmp 0x61daa
movsd 0x2a37e(%rip), %xmm2 # 0x8c128
movl $0x9, %edi
movq %rbx, %rsi
movq %r15, %rdx
movl %r9d, %ecx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x74e7e
movl $0xffff8000, %edx # imm = 0xFFFF8000
testq %r8, %r8
je 0x61ddb
movswl (%r8), %ecx
jmp 0x61de0
movl $0x7fff, %ecx # imm = 0x7FFF
leaq 0xc(%rsp), %rsi
movl $0x4, %edi
movq %r15, %r8
movaps %xmm3, %xmm1
callq 0x73734
jmp 0x61e1e
xorl %edx, %edx
testq %r8, %r8
je 0x61e04
movzwl (%r8), %ecx
jmp 0x61e09
movl $0xffff, %ecx # imm = 0xFFFF
leaq 0xc(%rsp), %rsi
movl $0x5, %edi
movq %r15, %r8
movaps %xmm3, %xmm1
callq 0x73ba6
testb %al, %al
je 0x61c82
movzwl 0xc(%rsp), %ecx
movw %cx, (%rbx)
jmp 0x61c82
xorl %edx, %edx
testq %r8, %r8
je 0x61e3f
movq (%r8), %rcx
jmp 0x61e46
movq $-0x1, %rcx
movl $0x7, %edi
movq %rbx, %rsi
movq %r15, %r8
movaps %xmm3, %xmm1
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x744c1
movl $0xffffff80, %edx # imm = 0xFFFFFF80
testq %r8, %r8
je 0x61e84
movsbl (%r8), %ecx
jmp 0x61e89
xorl %edx, %edx
testq %r8, %r8
je 0x61ea0
movzbl (%r8), %ecx
jmp 0x61ea5
movl $0x7f, %ecx
leaq 0xc(%rsp), %rsi
movl $0x4, %edi
movq %r15, %r8
movaps %xmm3, %xmm1
callq 0x73734
jmp 0x61eba
movl $0xff, %ecx
leaq 0xc(%rsp), %rsi
movl $0x5, %edi
movq %r15, %r8
movaps %xmm3, %xmm1
callq 0x73ba6
testb %al, %al
je 0x61c82
movb 0xc(%rsp), %cl
movb %cl, (%rbx)
jmp 0x61c82
xorl %edx, %edx
testq %r8, %r8
je 0x61ed9
movl (%r8), %ecx
jmp 0x61ede
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movl $0x5, %edi
movq %rbx, %rsi
movq %r15, %r8
movaps %xmm3, %xmm1
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x73ba6
leaq 0x1(%rcx), %rdx
testq %r8, %r8
je 0x61f0b
movq (%r8), %rcx
movl $0x6, %edi
movq %rbx, %rsi
movq %r15, %r8
movaps %xmm3, %xmm1
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x74023
movss 0x1cfbc(%rip), %xmm1 # 0x7eef0
testq %r8, %r8
je 0x61f40
movss (%r8), %xmm2
jmp 0x61f48
movss 0x1cf08(%rip), %xmm2 # 0x7ee50
movl $0x8, %edi
movq %rbx, %rsi
movq %r15, %rdx
movl %r9d, %ecx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x74a10
leaq 0x1ee96(%rip), %rdi # 0x80e06
leaq 0x2a1e9(%rip), %rsi # 0x8c160
leaq 0x2a8e8(%rip), %rcx # 0x8c866
movl $0x84b, %edx # imm = 0x84B
callq 0x22190
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
ImGui::SliderBehavior(ImRect const&, unsigned int, int, void*, void const*, void const*, char const*, float, int, ImRect*)
|
bool ImGui::SliderBehavior(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, void* p_v, const void* p_min, const void* p_max, const char* format, float power, ImGuiSliderFlags flags, ImRect* out_grab_bb)
{
switch (data_type)
{
case ImGuiDataType_S8: { ImS32 v32 = (ImS32)*(ImS8*)p_v; bool r = SliderBehaviorT<ImS32, ImS32, float>(bb, id, ImGuiDataType_S32, &v32, *(const ImS8*)p_min, *(const ImS8*)p_max, format, power, flags, out_grab_bb); if (r) *(ImS8*)p_v = (ImS8)v32; return r; }
case ImGuiDataType_U8: { ImU32 v32 = (ImU32)*(ImU8*)p_v; bool r = SliderBehaviorT<ImU32, ImS32, float>(bb, id, ImGuiDataType_U32, &v32, *(const ImU8*)p_min, *(const ImU8*)p_max, format, power, flags, out_grab_bb); if (r) *(ImU8*)p_v = (ImU8)v32; return r; }
case ImGuiDataType_S16: { ImS32 v32 = (ImS32)*(ImS16*)p_v; bool r = SliderBehaviorT<ImS32, ImS32, float>(bb, id, ImGuiDataType_S32, &v32, *(const ImS16*)p_min, *(const ImS16*)p_max, format, power, flags, out_grab_bb); if (r) *(ImS16*)p_v = (ImS16)v32; return r; }
case ImGuiDataType_U16: { ImU32 v32 = (ImU32)*(ImU16*)p_v; bool r = SliderBehaviorT<ImU32, ImS32, float>(bb, id, ImGuiDataType_U32, &v32, *(const ImU16*)p_min, *(const ImU16*)p_max, format, power, flags, out_grab_bb); if (r) *(ImU16*)p_v = (ImU16)v32; return r; }
case ImGuiDataType_S32:
IM_ASSERT(*(const ImS32*)p_min >= IM_S32_MIN/2 && *(const ImS32*)p_max <= IM_S32_MAX/2);
return SliderBehaviorT<ImS32, ImS32, float >(bb, id, data_type, (ImS32*)p_v, *(const ImS32*)p_min, *(const ImS32*)p_max, format, power, flags, out_grab_bb);
case ImGuiDataType_U32:
IM_ASSERT(*(const ImU32*)p_max <= IM_U32_MAX/2);
return SliderBehaviorT<ImU32, ImS32, float >(bb, id, data_type, (ImU32*)p_v, *(const ImU32*)p_min, *(const ImU32*)p_max, format, power, flags, out_grab_bb);
case ImGuiDataType_S64:
IM_ASSERT(*(const ImS64*)p_min >= IM_S64_MIN/2 && *(const ImS64*)p_max <= IM_S64_MAX/2);
return SliderBehaviorT<ImS64, ImS64, double>(bb, id, data_type, (ImS64*)p_v, *(const ImS64*)p_min, *(const ImS64*)p_max, format, power, flags, out_grab_bb);
case ImGuiDataType_U64:
IM_ASSERT(*(const ImU64*)p_max <= IM_U64_MAX/2);
return SliderBehaviorT<ImU64, ImS64, double>(bb, id, data_type, (ImU64*)p_v, *(const ImU64*)p_min, *(const ImU64*)p_max, format, power, flags, out_grab_bb);
case ImGuiDataType_Float:
IM_ASSERT(*(const float*)p_min >= -FLT_MAX/2.0f && *(const float*)p_max <= FLT_MAX/2.0f);
return SliderBehaviorT<float, float, float >(bb, id, data_type, (float*)p_v, *(const float*)p_min, *(const float*)p_max, format, power, flags, out_grab_bb);
case ImGuiDataType_Double:
IM_ASSERT(*(const double*)p_min >= -DBL_MAX/2.0f && *(const double*)p_max <= DBL_MAX/2.0f);
return SliderBehaviorT<double,double,double>(bb, id, data_type, (double*)p_v, *(const double*)p_min, *(const double*)p_max, format, power, flags, out_grab_bb);
case ImGuiDataType_COUNT: break;
}
IM_ASSERT(0);
return false;
}
|
pushq %rbx
subq $0x10, %rsp
cmpl $0x9, %edx
ja 0x62f7e
movaps %xmm0, %xmm2
movq %rcx, %rbx
movq 0x30(%rsp), %r11
movl 0x28(%rsp), %r10d
movq 0x20(%rsp), %rax
movl %edx, %ecx
leaq 0x29399(%rip), %rdx # 0x8c060
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movsbl (%rbx), %edx
leaq 0xc(%rsp), %rcx
movl %edx, (%rcx)
movsbl (%r8), %r8d
movsbl (%r9), %r9d
subq $0x8, %rsp
movl $0x4, %edx
movaps %xmm2, %xmm0
pushq %r11
pushq %r10
pushq %rax
callq 0x75342
jmp 0x62e33
movl (%r8), %r8d
cmpl $0xc0000000, %r8d # imm = 0xC0000000
jl 0x62f02
movl (%r9), %r9d
cmpl $0x40000000, %r9d # imm = 0x40000000
jge 0x62f02
subq $0x8, %rsp
movl $0x4, %edx
movq %rbx, %rcx
movaps %xmm2, %xmm0
pushq %r11
pushq %r10
pushq %rax
callq 0x75342
jmp 0x62eb9
movsd (%r8), %xmm0
ucomisd 0x293f0(%rip), %xmm0 # 0x8c138
jb 0x62f21
movsd (%r9), %xmm1
movsd 0x293e5(%rip), %xmm3 # 0x8c140
ucomisd %xmm1, %xmm3
jb 0x62f21
subq $0x8, %rsp
movl $0x9, %edx
movq %rbx, %rcx
movq %rax, %r8
movl %r10d, %r9d
pushq %r11
callq 0x778db
jmp 0x62efc
movswl (%rbx), %edx
leaq 0xc(%rsp), %rcx
movl %edx, (%rcx)
movswl (%r8), %r8d
movswl (%r9), %r9d
subq $0x8, %rsp
movl $0x4, %edx
movaps %xmm2, %xmm0
pushq %r11
pushq %r10
pushq %rax
callq 0x75342
jmp 0x62dd5
movzwl (%rbx), %edx
leaq 0xc(%rsp), %rcx
movl %edx, (%rcx)
movzwl (%r8), %r8d
movzwl (%r9), %r9d
subq $0x8, %rsp
movl $0x5, %edx
movaps %xmm2, %xmm0
pushq %r11
pushq %r10
pushq %rax
callq 0x75aa1
addq $0x20, %rsp
testb %al, %al
je 0x62e41
movzwl 0xc(%rsp), %ecx
movw %cx, (%rbx)
jmp 0x62e41
movq (%r9), %r9
testq %r9, %r9
js 0x62f9d
movq (%r8), %r8
movl $0x7, %edx
movq %rbx, %rcx
movaps %xmm2, %xmm0
addq $0x10, %rsp
popq %rbx
jmp 0x768d4
movzbl (%rbx), %edx
leaq 0xc(%rsp), %rcx
movl %edx, (%rcx)
movzbl (%r8), %r8d
movzbl (%r9), %r9d
subq $0x8, %rsp
movl $0x5, %edx
movaps %xmm2, %xmm0
pushq %r11
pushq %r10
pushq %rax
callq 0x75aa1
addq $0x20, %rsp
testb %al, %al
je 0x62e41
movb 0xc(%rsp), %cl
movb %cl, (%rbx)
addq $0x10, %rsp
jmp 0x62f00
movl (%r9), %r9d
testl %r9d, %r9d
js 0x62fbc
movl (%r8), %r8d
subq $0x8, %rsp
movl $0x5, %edx
movq %rbx, %rcx
movaps %xmm2, %xmm0
pushq %r11
pushq %r10
pushq %rax
callq 0x75aa1
jmp 0x62eb9
movq (%r8), %r8
movabsq $-0x4000000000000000, %rcx # imm = 0xC000000000000000
cmpq %rcx, %r8
jl 0x62f40
movq (%r9), %r9
movabsq $0x4000000000000000, %rcx # imm = 0x4000000000000000
cmpq %rcx, %r9
jge 0x62f40
subq $0x8, %rsp
movl $0x6, %edx
movq %rbx, %rcx
movaps %xmm2, %xmm0
pushq %r11
pushq %r10
pushq %rax
callq 0x7613d
addq $0x30, %rsp
jmp 0x62f00
movss (%r8), %xmm0
ucomiss 0x28eed(%rip), %xmm0 # 0x8bdb8
jb 0x62f5f
movss (%r9), %xmm1
movss 0x28ede(%rip), %xmm3 # 0x8bdbc
ucomiss %xmm1, %xmm3
jb 0x62f5f
subq $0x8, %rsp
movl $0x8, %edx
movq %rbx, %rcx
movq %rax, %r8
movl %r10d, %r9d
pushq %r11
callq 0x770b0
addq $0x20, %rsp
popq %rbx
retq
leaq 0x29a81(%rip), %rdi # 0x8c98a
leaq 0x29250(%rip), %rsi # 0x8c160
leaq 0x29ac0(%rip), %rcx # 0x8c9d7
movl $0xa00, %edx # imm = 0xA00
callq 0x22190
leaq 0x29c3c(%rip), %rdi # 0x8cb64
leaq 0x29231(%rip), %rsi # 0x8c160
leaq 0x29aa1(%rip), %rcx # 0x8c9d7
movl $0xa0f, %edx # imm = 0xA0F
callq 0x22190
leaq 0x29b4d(%rip), %rdi # 0x8ca94
leaq 0x29212(%rip), %rsi # 0x8c160
leaq 0x29a82(%rip), %rcx # 0x8c9d7
movl $0xa06, %edx # imm = 0xA06
callq 0x22190
leaq 0x29ba0(%rip), %rdi # 0x8cb06
leaq 0x291f3(%rip), %rsi # 0x8c160
leaq 0x29a63(%rip), %rcx # 0x8c9d7
movl $0xa0c, %edx # imm = 0xA0C
callq 0x22190
leaq 0x1de81(%rip), %rdi # 0x80e06
leaq 0x291d4(%rip), %rsi # 0x8c160
leaq 0x29a44(%rip), %rcx # 0x8c9d7
movl $0xa13, %edx # imm = 0xA13
callq 0x22190
leaq 0x29b3d(%rip), %rdi # 0x8cae1
leaq 0x291b5(%rip), %rsi # 0x8c160
leaq 0x29a25(%rip), %rcx # 0x8c9d7
movl $0xa09, %edx # imm = 0xA09
callq 0x22190
leaq 0x29aac(%rip), %rdi # 0x8ca6f
leaq 0x29196(%rip), %rsi # 0x8c160
leaq 0x29a06(%rip), %rcx # 0x8c9d7
movl $0xa03, %edx # imm = 0xA03
callq 0x22190
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
ImParseFormatFindEnd(char const*)
|
const char* ImParseFormatFindEnd(const char* fmt)
{
// Printf/scanf types modifiers: I/L/h/j/l/t/w/z. Other uppercase letters qualify as types aka end of the format.
if (fmt[0] != '%')
return fmt;
const unsigned int ignored_uppercase_mask = (1 << ('I'-'A')) | (1 << ('L'-'A'));
const unsigned int ignored_lowercase_mask = (1 << ('h'-'a')) | (1 << ('j'-'a')) | (1 << ('l'-'a')) | (1 << ('t'-'a')) | (1 << ('w'-'a')) | (1 << ('z'-'a'));
for (char c; (c = *fmt) != 0; fmt++)
{
if (c >= 'A' && c <= 'Z' && ((1 << (c - 'A')) & ignored_uppercase_mask) == 0)
return fmt + 1;
if (c >= 'a' && c <= 'z' && ((1 << (c - 'a')) & ignored_lowercase_mask) == 0)
return fmt + 1;
}
return fmt;
}
|
movq %rdi, %rax
cmpb $0x25, (%rdi)
jne 0x63c69
movb (%rax), %cl
testb %cl, %cl
je 0x63c69
incq %rax
movl $0x900, %edx # imm = 0x900
movl $0x2480a80, %esi # imm = 0x2480A80
leal -0x41(%rcx), %edi
cmpb $0x19, %dil
ja 0x63c4a
leal -0x1(%rcx), %edi
movzbl %dil, %edi
btl %edi, %edx
jae 0x63c69
leal -0x61(%rcx), %edi
cmpb $0x19, %dil
ja 0x63c5d
decb %cl
movzbl %cl, %ecx
btl %ecx, %esi
jae 0x63c69
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0x63c35
decq %rax
retq
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
ImStb::stb_textedit_paste(ImGuiInputTextState*, ImStb::STB_TexteditState*, unsigned short const*, int)
|
static int stb_textedit_paste(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE const *ctext, int len)
{
return stb_textedit_paste_internal(str, state, (STB_TEXTEDIT_CHARTYPE *) ctext, len);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x73046
movq %r15, %rdi
movq %rbx, %rsi
callq 0x72fb3
movl (%rbx), %esi
movq %r15, %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x72dcd
testb %al, %al
je 0x6887e
movl (%rbx), %esi
leaq 0x18(%rbx), %rdi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x73302
addl %ebp, (%rbx)
movb $0x0, 0xf(%rbx)
jmp 0x68893
movzwl 0xe16(%rbx), %eax
testw %ax, %ax
je 0x68893
decl %eax
movw %ax, 0xe16(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/ggerganov[P]kbd-audio/imgui/imstb_textedit.h
|
ImGui::PlotEx(ImGuiPlotType, char const*, float (*)(void*, int), void*, int, int, char const*, float, float, ImVec2)
|
int ImGui::PlotEx(ImGuiPlotType plot_type, const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 frame_size)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return -1;
const ImGuiStyle& style = g.Style;
const ImGuiID id = window->GetID(label);
const ImVec2 label_size = CalcTextSize(label, NULL, true);
if (frame_size.x == 0.0f)
frame_size.x = CalcItemWidth();
if (frame_size.y == 0.0f)
frame_size.y = label_size.y + (style.FramePadding.y * 2);
const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + frame_size);
const ImRect inner_bb(frame_bb.Min + style.FramePadding, frame_bb.Max - style.FramePadding);
const ImRect total_bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0));
ItemSize(total_bb, style.FramePadding.y);
if (!ItemAdd(total_bb, 0, &frame_bb))
return -1;
const bool hovered = ItemHoverable(frame_bb, id);
// Determine scale from values if not specified
if (scale_min == FLT_MAX || scale_max == FLT_MAX)
{
float v_min = FLT_MAX;
float v_max = -FLT_MAX;
for (int i = 0; i < values_count; i++)
{
const float v = values_getter(data, i);
if (v != v) // Ignore NaN values
continue;
v_min = ImMin(v_min, v);
v_max = ImMax(v_max, v);
}
if (scale_min == FLT_MAX)
scale_min = v_min;
if (scale_max == FLT_MAX)
scale_max = v_max;
}
RenderFrame(frame_bb.Min, frame_bb.Max, GetColorU32(ImGuiCol_FrameBg), true, style.FrameRounding);
const int values_count_min = (plot_type == ImGuiPlotType_Lines) ? 2 : 1;
int idx_hovered = -1;
if (values_count >= values_count_min)
{
int res_w = ImMin((int)frame_size.x, values_count) + ((plot_type == ImGuiPlotType_Lines) ? -1 : 0);
int item_count = values_count + ((plot_type == ImGuiPlotType_Lines) ? -1 : 0);
// Tooltip on hover
if (hovered && inner_bb.Contains(g.IO.MousePos))
{
const float t = ImClamp((g.IO.MousePos.x - inner_bb.Min.x) / (inner_bb.Max.x - inner_bb.Min.x), 0.0f, 0.9999f);
const int v_idx = (int)(t * item_count);
IM_ASSERT(v_idx >= 0 && v_idx < values_count);
const float v0 = values_getter(data, (v_idx + values_offset) % values_count);
const float v1 = values_getter(data, (v_idx + 1 + values_offset) % values_count);
if (plot_type == ImGuiPlotType_Lines)
SetTooltip("%d: %8.4g\n%d: %8.4g", v_idx, v0, v_idx+1, v1);
else if (plot_type == ImGuiPlotType_Histogram)
SetTooltip("%d: %8.4g", v_idx, v0);
idx_hovered = v_idx;
}
const float t_step = 1.0f / (float)res_w;
const float inv_scale = (scale_min == scale_max) ? 0.0f : (1.0f / (scale_max - scale_min));
float v0 = values_getter(data, (0 + values_offset) % values_count);
float t0 = 0.0f;
ImVec2 tp0 = ImVec2( t0, 1.0f - ImSaturate((v0 - scale_min) * inv_scale) ); // Point in the normalized space of our target rectangle
float histogram_zero_line_t = (scale_min * scale_max < 0.0f) ? (-scale_min * inv_scale) : (scale_min < 0.0f ? 0.0f : 1.0f); // Where does the zero line stands
const ImU32 col_base = GetColorU32((plot_type == ImGuiPlotType_Lines) ? ImGuiCol_PlotLines : ImGuiCol_PlotHistogram);
const ImU32 col_hovered = GetColorU32((plot_type == ImGuiPlotType_Lines) ? ImGuiCol_PlotLinesHovered : ImGuiCol_PlotHistogramHovered);
for (int n = 0; n < res_w; n++)
{
const float t1 = t0 + t_step;
const int v1_idx = (int)(t0 * item_count + 0.5f);
IM_ASSERT(v1_idx >= 0 && v1_idx < values_count);
const float v1 = values_getter(data, (v1_idx + values_offset + 1) % values_count);
const ImVec2 tp1 = ImVec2( t1, 1.0f - ImSaturate((v1 - scale_min) * inv_scale) );
// NB: Draw calls are merged together by the DrawList system. Still, we should render our batch are lower level to save a bit of CPU.
ImVec2 pos0 = ImLerp(inner_bb.Min, inner_bb.Max, tp0);
ImVec2 pos1 = ImLerp(inner_bb.Min, inner_bb.Max, (plot_type == ImGuiPlotType_Lines) ? tp1 : ImVec2(tp1.x, histogram_zero_line_t));
if (plot_type == ImGuiPlotType_Lines)
{
window->DrawList->AddLine(pos0, pos1, idx_hovered == v1_idx ? col_hovered : col_base);
}
else if (plot_type == ImGuiPlotType_Histogram)
{
if (pos1.x >= pos0.x + 2.0f)
pos1.x -= 1.0f;
window->DrawList->AddRectFilled(pos0, pos1, idx_hovered == v1_idx ? col_hovered : col_base);
}
t0 = t1;
tp0 = tp1;
}
}
// Text overlay
if (overlay_text)
RenderTextClipped(ImVec2(frame_bb.Min.x, frame_bb.Min.y + style.FramePadding.y), frame_bb.Max, overlay_text, NULL, NULL, ImVec2(0.5f,0.0f));
if (label_size.x > 0.0f)
RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, inner_bb.Min.y), label);
// Return hovered index or -1 if none are hovered.
// This is currently not exposed in the public API because we need a larger redesign of the whole thing, but in the short-term we are making it available in PlotEx().
return idx_hovered;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %r9, 0x20(%rsp)
movq %rcx, %r15
leaq 0x36eeb(%rip), %rax # 0xa46a0
movq (%rax), %rax
movq 0x1a80(%rax), %rcx
movb $0x1, 0x80(%rcx)
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
cmpb $0x0, 0x83(%rcx)
jne 0x6df14
movl %r8d, %ebp
movq %rdx, %r12
movq %rsi, %r13
movaps %xmm1, 0xa0(%rsp)
movaps %xmm0, 0xb0(%rsp)
movl %edi, 0xc(%rsp)
movq %rax, 0x30(%rsp)
movq %rcx, 0xc8(%rsp)
movq %rcx, %rdi
xorl %edx, %edx
movaps %xmm2, 0x60(%rsp)
callq 0x349a6
movl %eax, %ebx
movss 0x107ec(%rip), %xmm0 # 0x7e008
movq %r13, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x33c86
movaps 0x60(%rsp), %xmm2
movaps %xmm0, %xmm1
xorps %xmm3, %xmm3
ucomiss %xmm3, %xmm2
movaps %xmm0, 0xd0(%rsp)
jne 0x6d85e
jp 0x6d85e
callq 0x43629
xorps %xmm3, %xmm3
movaps 0x60(%rsp), %xmm2
movaps 0xd0(%rsp), %xmm1
movss %xmm0, %xmm2 # xmm2 = xmm0[0],xmm2[1,2,3]
movaps %xmm2, %xmm0
shufps $0x55, %xmm2, %xmm0 # xmm0 = xmm0[1,1],xmm2[1,1]
ucomiss %xmm3, %xmm0
movq 0x30(%rsp), %rcx
jne 0x6d89a
jp 0x6d89a
movaps %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm0 # xmm0 = xmm0[1,1],xmm1[1,1]
movss 0x15a4(%rcx), %xmm1
addss %xmm1, %xmm1
addss %xmm0, %xmm1
movlhps %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0]
shufps $0xe2, %xmm2, %xmm1 # xmm1 = xmm1[2,0],xmm2[2,3]
movaps %xmm1, %xmm2
movaps 0xd0(%rsp), %xmm1
movq %r13, 0x50(%rsp)
movq 0xc8(%rsp), %rax
movsd 0xd0(%rax), %xmm0
movaps %xmm2, 0x60(%rsp)
addps %xmm0, %xmm2
movaps %xmm0, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movlhps %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0]
movups %xmm0, 0xe0(%rsp)
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jbe 0x6d8e3
movss 0x15b8(%rcx), %xmm0
addss %xmm1, %xmm0
movsd 0x15a0(%rcx), %xmm1
movaps %xmm1, 0x90(%rsp)
xorps %xmm1, %xmm1
movss %xmm0, %xmm1 # xmm1 = xmm0[0],xmm1[1,2,3]
addps 0x80(%rsp), %xmm1
leaq 0xe0(%rsp), %r14
movq (%r14), %rax
leaq 0x128(%rsp), %r13
movq %rax, (%r13)
movlps %xmm1, 0x8(%r13)
movss 0x15a4(%rcx), %xmm0
movq %r13, %rdi
callq 0x42f38
movq %r13, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x405cd
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
testb %al, %al
je 0x6df14
leaq 0xe0(%rsp), %rdi
movl %ebx, %esi
callq 0x354aa
movl %eax, %r13d
movaps 0xb0(%rsp), %xmm0
ucomiss 0x114e6(%rip), %xmm0 # 0x7ee50
movaps 0xa0(%rsp), %xmm0
jne 0x6d976
jnp 0x6d98b
ucomiss 0x114d3(%rip), %xmm0 # 0x7ee50
jne 0x6d981
jnp 0x6d98b
movq 0x50(%rsp), %rbx
jmp 0x6da4e
movss 0x114bd(%rip), %xmm0 # 0x7ee50
testl %ebp, %ebp
movq 0x50(%rsp), %rbx
jle 0x6d9fc
xorl %r14d, %r14d
movss 0x11549(%rip), %xmm3 # 0x7eef0
movss 0x114a1(%rip), %xmm4 # 0x7ee50
movaps %xmm4, 0x10(%rsp)
movaps %xmm3, 0x40(%rsp)
movq %r15, %rdi
movl %r14d, %esi
callq *%r12
ucomiss %xmm0, %xmm0
jp 0x6d9f0
movaps 0x10(%rsp), %xmm4
minss %xmm0, %xmm4
movaps %xmm0, %xmm1
movaps 0x40(%rsp), %xmm3
cmpless %xmm3, %xmm1
andps %xmm1, %xmm3
andnps %xmm0, %xmm1
orps %xmm1, %xmm3
incl %r14d
cmpl %r14d, %ebp
jne 0x6d9af
jmp 0x6da07
movaps 0x40(%rsp), %xmm3
movaps 0x10(%rsp), %xmm4
jmp 0x6d9e6
movss 0x114ec(%rip), %xmm3 # 0x7eef0
movaps %xmm0, %xmm4
movaps 0xb0(%rsp), %xmm1
movaps %xmm1, %xmm0
movss 0x11436(%rip), %xmm2 # 0x7ee50
cmpeqss %xmm2, %xmm0
andps %xmm0, %xmm4
andnps %xmm1, %xmm0
orps %xmm4, %xmm0
movaps 0xa0(%rsp), %xmm1
cmpeqss %xmm1, %xmm2
andps %xmm2, %xmm3
andnps %xmm1, %xmm2
orps %xmm3, %xmm2
movaps %xmm2, 0xa0(%rsp)
movaps %xmm0, 0xb0(%rsp)
movaps 0x70(%rsp), %xmm0
movaps 0x90(%rsp), %xmm1
addps %xmm1, %xmm0
movaps %xmm0, 0x70(%rsp)
movsd 0xe0(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
movsd 0xe8(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
movss 0x10589(%rip), %xmm0 # 0x7e010
movl $0x7, %edi
callq 0x32e01
movq 0x30(%rsp), %rcx
movss 0x15a8(%rcx), %xmm2
movaps 0x40(%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movl %eax, %edi
movl $0x1, %esi
callq 0x341e2
xorl %eax, %eax
movl 0xc(%rsp), %ecx
cmpl $0x1, %ecx
adcl $0x1, %eax
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
cmpl %ebp, %eax
movaps 0xd0(%rsp), %xmm1
jg 0x6de79
movaps 0x80(%rsp), %xmm0
subps 0x90(%rsp), %xmm0
movaps %xmm0, 0x80(%rsp)
xorl %ebx, %ebx
testl %ecx, %ecx
movl %r13d, %ecx
cvttss2si 0x60(%rsp), %r13d
sete %bl
cmpl %ebp, %r13d
cmovgel %ebp, %r13d
movl %ebp, %eax
subl %ebx, %eax
movl %eax, 0x40(%rsp)
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
testb %cl, %cl
je 0x6db33
movq 0x30(%rsp), %rax
movss 0x130(%rax), %xmm0
movaps 0x70(%rsp), %xmm2
ucomiss %xmm2, %xmm0
jae 0x6df29
subl %ebx, %r13d
movaps 0xa0(%rsp), %xmm2
movaps %xmm2, %xmm0
movaps 0xb0(%rsp), %xmm3
subss %xmm3, %xmm0
movss 0x104bb(%rip), %xmm1 # 0x7e010
divss %xmm0, %xmm1
cmpeqss %xmm2, %xmm3
andnps %xmm1, %xmm3
movaps %xmm3, 0x60(%rsp)
movq 0x20(%rsp), %rax
cltd
idivl %ebp
movq %r15, %rdi
movl %edx, %esi
callq *%r12
movaps 0x60(%rsp), %xmm4
movaps 0xb0(%rsp), %xmm3
xorps %xmm2, %xmm2
movaps 0xa0(%rsp), %xmm1
mulss %xmm3, %xmm1
ucomiss %xmm1, %xmm2
movss %xmm0, 0x90(%rsp)
jbe 0x6dbb0
movaps 0x10ab9(%rip), %xmm1 # 0x7e660
xorps %xmm3, %xmm1
mulss %xmm4, %xmm1
jmp 0x6dbc3
movaps %xmm3, %xmm1
cmpltss %xmm2, %xmm1
movss 0x10450(%rip), %xmm0 # 0x7e010
andnps %xmm0, %xmm1
movaps %xmm1, 0x10(%rsp)
movl 0xc(%rsp), %eax
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
leal 0x26(,%rbx,2), %edi
movss 0x1042e(%rip), %xmm0 # 0x7e010
callq 0x32e01
movl %eax, 0x3c(%rsp)
leal 0x27(,%rbx,2), %edi
movss 0x10416(%rip), %xmm0 # 0x7e010
callq 0x32e01
movl %eax, 0x38(%rsp)
testl %r13d, %r13d
jle 0x6de6c
movss 0x90(%rsp), %xmm1
subss 0xb0(%rsp), %xmm1
movaps 0x60(%rsp), %xmm0
mulss %xmm1, %xmm0
movss 0x103e1(%rip), %xmm3 # 0x7e010
movaps %xmm3, %xmm1
minss %xmm0, %xmm1
movaps %xmm3, %xmm2
subss %xmm1, %xmm2
cmpltss 0x1120e(%rip), %xmm0 # 0x7ee54
movaps %xmm0, %xmm1
andnps %xmm2, %xmm1
andps %xmm3, %xmm0
orps %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2ss %r13d, %xmm1
divss %xmm1, %xmm3
movaps %xmm3, 0x90(%rsp)
xorps %xmm1, %xmm1
cvtsi2ssl 0x40(%rsp), %xmm1
movss %xmm1, 0xa0(%rsp)
movq 0x20(%rsp), %rax
incl %eax
movq %rax, 0x20(%rsp)
movaps 0x70(%rsp), %xmm1
movaps 0x80(%rsp), %xmm2
subps %xmm1, %xmm2
movaps %xmm2, 0x80(%rsp)
shufps $0x55, %xmm2, %xmm2 # xmm2 = xmm2[1,1,1,1]
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
movaps %xmm2, 0x100(%rsp)
mulss 0x10(%rsp), %xmm2
movaps %xmm1, 0xf0(%rsp)
addss %xmm1, %xmm2
movaps %xmm2, 0x110(%rsp)
movq %xmm0, %xmm1 # xmm1 = xmm0[0],zero
xorps %xmm0, %xmm0
shufps $0xe2, %xmm0, %xmm1 # xmm1 = xmm1[2,0],xmm0[2,3]
movaps %xmm1, %xmm0
mulss 0xa0(%rsp), %xmm0
addss 0x11173(%rip), %xmm0 # 0x7ee58
cvttss2si %xmm0, %ebx
testl %ebx, %ebx
js 0x6e03c
cmpl %ebp, %ebx
jge 0x6e03c
movaps 0x90(%rsp), %xmm0
addss %xmm1, %xmm0
movaps %xmm0, 0x40(%rsp)
movq 0x20(%rsp), %rax
addl %ebx, %eax
cltd
idivl %ebp
movq %r15, %rdi
movl %edx, %esi
movaps %xmm1, 0x10(%rsp)
callq *%r12
movaps %xmm0, %xmm3
subss 0xb0(%rsp), %xmm3
mulss 0x60(%rsp), %xmm3
movss 0x102d5(%rip), %xmm2 # 0x7e010
movaps %xmm2, %xmm0
minss %xmm3, %xmm0
movaps %xmm2, %xmm1
subss %xmm0, %xmm1
cmpltss 0x11102(%rip), %xmm3 # 0x7ee54
movaps %xmm3, %xmm0
andnps %xmm1, %xmm0
andps %xmm2, %xmm3
orps %xmm0, %xmm3
movaps 0x80(%rsp), %xmm0
movaps 0x10(%rsp), %xmm4
mulps %xmm0, %xmm4
movaps 0x70(%rsp), %xmm1
addps %xmm1, %xmm4
movlps %xmm4, 0x58(%rsp)
mulss 0x40(%rsp), %xmm0
addss %xmm1, %xmm0
movl 0xc(%rsp), %eax
testl %eax, %eax
je 0x6de04
unpcklps 0x110(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
movlps %xmm0, 0x28(%rsp)
cmpl $0x1, %eax
jne 0x6de58
movaps %xmm3, 0x10(%rsp)
movss 0x28(%rsp), %xmm0
movss 0x58(%rsp), %xmm1
addss 0x110bc(%rip), %xmm1 # 0x7ee78
ucomiss %xmm1, %xmm0
jb 0x6ddcf
addss 0x1023f(%rip), %xmm0 # 0x7e008
movss %xmm0, 0x28(%rsp)
movq 0xc8(%rsp), %rax
movq 0x2b0(%rax), %rdi
cmpl %ebx, %r14d
movl 0x3c(%rsp), %ecx
cmovel 0x38(%rsp), %ecx
xorps %xmm0, %xmm0
leaq 0x58(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movl $0xf, %r8d
callq 0x4ea4c
jmp 0x6de53
movaps 0x100(%rsp), %xmm1
mulss %xmm3, %xmm1
addss 0xf0(%rsp), %xmm1
unpcklps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movlps %xmm0, 0x28(%rsp)
movq 0xc8(%rsp), %rax
movq 0x2b0(%rax), %rdi
cmpl %ebx, %r14d
movl 0x3c(%rsp), %ecx
cmovel 0x38(%rsp), %ecx
leaq 0x58(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movaps %xmm2, %xmm0
movaps %xmm3, 0x10(%rsp)
callq 0x4e7d4
movaps 0x10(%rsp), %xmm3
movaps 0x40(%rsp), %xmm0
unpcklps %xmm3, %xmm0 # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movaps %xmm0, %xmm1
decl %r13d
jne 0x6dcd1
movq 0x50(%rsp), %rbx
movaps 0xd0(%rsp), %xmm1
movq 0x170(%rsp), %rdx
testq %rdx, %rdx
je 0x6dede
leaq 0xe8(%rsp), %rsi
movss -0x8(%rsi), %xmm0
movss -0x4(%rsi), %xmm1
movq 0x30(%rsp), %rax
addss 0x15a4(%rax), %xmm1
leaq 0x58(%rsp), %rdi
movss %xmm0, (%rdi)
movss %xmm1, 0x4(%rdi)
movss 0x10f9d(%rip), %xmm0 # 0x7ee58
leaq 0x28(%rsp), %r9
movlps %xmm0, (%r9)
movq $0x0, (%rsp)
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x33d1d
movaps 0xd0(%rsp), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jbe 0x6df14
movss 0xe8(%rsp), %xmm1
movq 0x30(%rsp), %rax
addss 0x15b8(%rax), %xmm1
movaps 0x70(%rsp), %xmm0
movss %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[1,2,3]
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x336a6
movl %r14d, %eax
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movss 0x134(%rax), %xmm1
shufps $0x55, %xmm2, %xmm2 # xmm2 = xmm2[1,1,1,1]
ucomiss %xmm2, %xmm1
jb 0x6db33
movaps 0x80(%rsp), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x6db33
shufps $0x55, %xmm2, %xmm2 # xmm2 = xmm2[1,1,1,1]
ucomiss %xmm1, %xmm2
jbe 0x6db33
movaps 0x70(%rsp), %xmm2
subss %xmm2, %xmm0
movaps 0x80(%rsp), %xmm1
subss %xmm2, %xmm1
divss %xmm1, %xmm0
movss 0x1de7f(%rip), %xmm1 # 0x8bdfc
minss %xmm0, %xmm1
xorps %xmm2, %xmm2
cmpltss %xmm2, %xmm0
andnps %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2ssl 0x40(%rsp), %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %r14d
testl %r14d, %r14d
js 0x6e05b
cmpl %ebp, %r14d
jge 0x6e05b
movq 0x20(%rsp), %rax
addl %r14d, %eax
cltd
idivl %ebp
movq %r15, %rdi
movl %edx, %esi
callq *%r12
movss %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
addl %r14d, %eax
incl %eax
cltd
idivl %ebp
movq %r15, %rdi
movl %edx, %esi
callq *%r12
movl 0xc(%rsp), %eax
testl %eax, %eax
je 0x6e00f
movss 0x10(%rsp), %xmm0
cmpl $0x1, %eax
jne 0x6db33
cvtss2sd %xmm0, %xmm0
leaq 0x1f70c(%rip), %rdi # 0x8d70c
movl %r14d, %esi
movb $0x1, %al
callq 0x3f075
jmp 0x6db33
leal 0x1(%r14), %edx
xorps %xmm2, %xmm2
cvtss2sd 0x10(%rsp), %xmm2
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
leaq 0x1f6d8(%rip), %rdi # 0x8d702
movl %r14d, %esi
movaps %xmm2, %xmm0
movb $0x2, %al
callq 0x3f075
jmp 0x6db33
leaq 0x1f6d3(%rip), %rdi # 0x8d716
leaq 0x1e116(%rip), %rsi # 0x8c160
leaq 0x1f634(%rip), %rcx # 0x8d685
movl $0x1770, %edx # imm = 0x1770
callq 0x22190
leaq 0x1f600(%rip), %rdi # 0x8d662
leaq 0x1e0f7(%rip), %rsi # 0x8c160
leaq 0x1f615(%rip), %rcx # 0x8d685
movl $0x1756, %edx # imm = 0x1756
callq 0x22190
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
ImGui::BeginMainMenuBar()
|
bool ImGui::BeginMainMenuBar()
{
ImGuiContext& g = *GImGui;
g.NextWindowData.MenuBarOffsetMinVal = ImVec2(g.Style.DisplaySafeAreaPadding.x, ImMax(g.Style.DisplaySafeAreaPadding.y - g.Style.FramePadding.y, 0.0f));
SetNextWindowPos(ImVec2(0.0f, 0.0f));
SetNextWindowSize(ImVec2(g.IO.DisplaySize.x, g.NextWindowData.MenuBarOffsetMinVal.y + g.FontBaseSize + g.Style.FramePadding.y));
PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
PushStyleVar(ImGuiStyleVar_WindowMinSize, ImVec2(0, 0));
ImGuiWindowFlags window_flags = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_MenuBar;
bool is_open = Begin("##MainMenuBar", NULL, window_flags) && BeginMenuBar();
PopStyleVar(2);
g.NextWindowData.MenuBarOffsetMinVal = ImVec2(0.0f, 0.0f);
if (!is_open)
{
End();
return false;
}
return true; //-V1020
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x36015(%rip), %rax # 0xa46a0
movq (%rax), %r15
movl 0x1608(%r15), %eax
movss 0x160c(%r15), %xmm0
subss 0x15a4(%r15), %xmm0
xorps %xmm1, %xmm1
cmpless %xmm0, %xmm1
andps %xmm0, %xmm1
movl %eax, 0x1b84(%r15)
movss %xmm1, 0x1b88(%r15)
xorl %ebx, %ebx
movq %rsp, %r14
movq %rbx, (%r14)
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x421dc
movss 0x10(%r15), %xmm0
movss 0x1b88(%r15), %xmm1
addss 0x192c(%r15), %xmm1
addss 0x15a4(%r15), %xmm1
movss %xmm0, (%r14)
movss %xmm1, 0x4(%r14)
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x39c14
xorps %xmm0, %xmm0
movl $0x2, %edi
callq 0x33214
movq %rbx, (%r14)
movq %rsp, %rsi
movl $0x4, %edi
callq 0x333b2
leaq 0x143cd(%rip), %rdi # 0x82b06
xorl %esi, %esi
movl $0x50f, %edx # imm = 0x50F
callq 0x39c60
testb %al, %al
je 0x6e750
callq 0x6e33f
movl %eax, %ebx
movl $0x2, %edi
callq 0x3354c
movq $0x0, 0x1b84(%r15)
testb %bl, %bl
jne 0x6e76e
callq 0x3eca4
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
ImGui::TabBarRemoveTab(ImGuiTabBar*, unsigned int)
|
void ImGui::TabBarRemoveTab(ImGuiTabBar* tab_bar, ImGuiID tab_id)
{
if (ImGuiTabItem* tab = TabBarFindTabByID(tab_bar, tab_id))
tab_bar->Tabs.erase(tab);
if (tab_bar->VisibleTabId == tab_id) { tab_bar->VisibleTabId = 0; }
if (tab_bar->SelectedTabId == tab_id) { tab_bar->SelectedTabId = 0; }
if (tab_bar->NextSelectedTabId == tab_id) { tab_bar->NextSelectedTabId = 0; }
}
|
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
je 0x70643
movslq (%rbx), %rax
testq %rax, %rax
setg %cl
jle 0x70631
movq 0x8(%rbx), %rdi
movb $0x1, %cl
cmpl %ebp, (%rdi)
je 0x7063f
movq %rax, %rcx
shlq $0x5, %rcx
addq %rdi, %rcx
addq $-0x20, %rcx
movl $0x1, %r8d
movq %r8, %rdx
cmpq %r8, %rax
je 0x70633
leaq 0x20(%rdi), %rsi
leaq 0x1(%rdx), %r8
cmpl %ebp, 0x20(%rdi)
movq %rsi, %rdi
jne 0x70617
jmp 0x70636
jmp 0x7063f
movq %rcx, %rsi
cmpq %rax, %rdx
setb %cl
movq %rsi, %rdi
testb %cl, %cl
jne 0x70645
xorl %edi, %edi
testq %rdi, %rdi
je 0x70684
movq 0x8(%rbx), %rax
cmpq %rdi, %rax
ja 0x706af
movslq (%rbx), %rdx
movq %rdx, %rcx
shlq $0x5, %rcx
addq %rax, %rcx
cmpq %rdi, %rcx
jbe 0x706af
movq %rdi, %rcx
subq %rax, %rcx
leaq 0x20(%rdi), %rsi
notq %rcx
shrq $0x5, %rcx
addq %rcx, %rdx
shlq $0x5, %rdx
callq 0x22170
decl (%rbx)
cmpl %ebp, 0x1c(%rbx)
jne 0x70690
movl $0x0, 0x1c(%rbx)
cmpl %ebp, 0x14(%rbx)
jne 0x7069c
movl $0x0, 0x14(%rbx)
cmpl %ebp, 0x18(%rbx)
jne 0x706a8
movl $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1dbb9(%rip), %rdi # 0x8e26f
leaq 0x11594(%rip), %rsi # 0x81c51
leaq 0x1dbc8(%rip), %rcx # 0x8e28c
movl $0x546, %edx # imm = 0x546
callq 0x22190
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
ImGui::TabItemEx(ImGuiTabBar*, char const*, bool*, int)
|
bool ImGui::TabItemEx(ImGuiTabBar* tab_bar, const char* label, bool* p_open, ImGuiTabItemFlags flags)
{
// Layout whole tab bar if not already done
if (tab_bar->WantLayout)
TabBarLayout(tab_bar);
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (window->SkipItems)
return false;
const ImGuiStyle& style = g.Style;
const ImGuiID id = TabBarCalcTabID(tab_bar, label);
// If the user called us with *p_open == false, we early out and don't render. We make a dummy call to ItemAdd() so that attempts to use a contextual popup menu with an implicit ID won't use an older ID.
IMGUI_TEST_ENGINE_ITEM_INFO(id, label, window->DC.LastItemStatusFlags);
if (p_open && !*p_open)
{
PushItemFlag(ImGuiItemFlags_NoNav | ImGuiItemFlags_NoNavDefaultFocus, true);
ItemAdd(ImRect(), id);
PopItemFlag();
return false;
}
// Store into ImGuiTabItemFlags_NoCloseButton, also honor ImGuiTabItemFlags_NoCloseButton passed by user (although not documented)
if (flags & ImGuiTabItemFlags_NoCloseButton)
p_open = NULL;
else if (p_open == NULL)
flags |= ImGuiTabItemFlags_NoCloseButton;
// Calculate tab contents size
ImVec2 size = TabItemCalcSize(label, p_open != NULL);
// Acquire tab data
ImGuiTabItem* tab = TabBarFindTabByID(tab_bar, id);
bool tab_is_new = false;
if (tab == NULL)
{
tab_bar->Tabs.push_back(ImGuiTabItem());
tab = &tab_bar->Tabs.back();
tab->ID = id;
tab->Width = size.x;
tab_is_new = true;
}
tab_bar->LastTabItemIdx = (short)tab_bar->Tabs.index_from_ptr(tab);
tab->ContentWidth = size.x;
const bool tab_bar_appearing = (tab_bar->PrevFrameVisible + 1 < g.FrameCount);
const bool tab_bar_focused = (tab_bar->Flags & ImGuiTabBarFlags_IsFocused) != 0;
const bool tab_appearing = (tab->LastFrameVisible + 1 < g.FrameCount);
tab->LastFrameVisible = g.FrameCount;
tab->Flags = flags;
// Append name with zero-terminator
tab->NameOffset = tab_bar->TabsNames.size();
tab_bar->TabsNames.append(label, label + strlen(label) + 1);
// If we are not reorderable, always reset offset based on submission order.
// (We already handled layout and sizing using the previous known order, but sizing is not affected by order!)
if (!tab_appearing && !(tab_bar->Flags & ImGuiTabBarFlags_Reorderable))
{
tab->Offset = tab_bar->OffsetNextTab;
tab_bar->OffsetNextTab += tab->Width + g.Style.ItemInnerSpacing.x;
}
// Update selected tab
if (tab_appearing && (tab_bar->Flags & ImGuiTabBarFlags_AutoSelectNewTabs) && tab_bar->NextSelectedTabId == 0)
if (!tab_bar_appearing || tab_bar->SelectedTabId == 0)
tab_bar->NextSelectedTabId = id; // New tabs gets activated
if ((flags & ImGuiTabItemFlags_SetSelected) && (tab_bar->SelectedTabId != id)) // SetSelected can only be passed on explicit tab bar
tab_bar->NextSelectedTabId = id;
// Lock visibility
// (Note: tab_contents_visible != tab_selected... because CTRL+TAB operations may preview some tabs without selecting them!)
bool tab_contents_visible = (tab_bar->VisibleTabId == id);
if (tab_contents_visible)
tab_bar->VisibleTabWasSubmitted = true;
// On the very first frame of a tab bar we let first tab contents be visible to minimize appearing glitches
if (!tab_contents_visible && tab_bar->SelectedTabId == 0 && tab_bar_appearing)
if (tab_bar->Tabs.Size == 1 && !(tab_bar->Flags & ImGuiTabBarFlags_AutoSelectNewTabs))
tab_contents_visible = true;
if (tab_appearing && !(tab_bar_appearing && !tab_is_new))
{
PushItemFlag(ImGuiItemFlags_NoNav | ImGuiItemFlags_NoNavDefaultFocus, true);
ItemAdd(ImRect(), id);
PopItemFlag();
return tab_contents_visible;
}
if (tab_bar->SelectedTabId == id)
tab->LastFrameSelected = g.FrameCount;
// Backup current layout position
const ImVec2 backup_main_cursor_pos = window->DC.CursorPos;
// Layout
size.x = tab->Width;
window->DC.CursorPos = tab_bar->BarRect.Min + ImVec2(IM_FLOOR(tab->Offset - tab_bar->ScrollingAnim), 0.0f);
ImVec2 pos = window->DC.CursorPos;
ImRect bb(pos, pos + size);
// We don't have CPU clipping primitives to clip the CloseButton (until it becomes a texture), so need to add an extra draw call (temporary in the case of vertical animation)
bool want_clip_rect = (bb.Min.x < tab_bar->BarRect.Min.x) || (bb.Max.x > tab_bar->BarRect.Max.x);
if (want_clip_rect)
PushClipRect(ImVec2(ImMax(bb.Min.x, tab_bar->BarRect.Min.x), bb.Min.y - 1), ImVec2(tab_bar->BarRect.Max.x, bb.Max.y), true);
ImVec2 backup_cursor_max_pos = window->DC.CursorMaxPos;
ItemSize(bb.GetSize(), style.FramePadding.y);
window->DC.CursorMaxPos = backup_cursor_max_pos;
if (!ItemAdd(bb, id))
{
if (want_clip_rect)
PopClipRect();
window->DC.CursorPos = backup_main_cursor_pos;
return tab_contents_visible;
}
// Click to Select a tab
ImGuiButtonFlags button_flags = (ImGuiButtonFlags_PressedOnClick | ImGuiButtonFlags_AllowItemOverlap);
if (g.DragDropActive)
button_flags |= ImGuiButtonFlags_PressedOnDragDropHold;
bool hovered, held;
bool pressed = ButtonBehavior(bb, id, &hovered, &held, button_flags);
if (pressed)
tab_bar->NextSelectedTabId = id;
hovered |= (g.HoveredId == id);
// Allow the close button to overlap unless we are dragging (in which case we don't want any overlapping tabs to be hovered)
if (!held)
SetItemAllowOverlap();
// Drag and drop: re-order tabs
if (held && !tab_appearing && IsMouseDragging(0))
{
if (!g.DragDropActive && (tab_bar->Flags & ImGuiTabBarFlags_Reorderable))
{
// While moving a tab it will jump on the other side of the mouse, so we also test for MouseDelta.x
if (g.IO.MouseDelta.x < 0.0f && g.IO.MousePos.x < bb.Min.x)
{
if (tab_bar->Flags & ImGuiTabBarFlags_Reorderable)
TabBarQueueChangeTabOrder(tab_bar, tab, -1);
}
else if (g.IO.MouseDelta.x > 0.0f && g.IO.MousePos.x > bb.Max.x)
{
if (tab_bar->Flags & ImGuiTabBarFlags_Reorderable)
TabBarQueueChangeTabOrder(tab_bar, tab, +1);
}
}
}
#if 0
if (hovered && g.HoveredIdNotActiveTimer > 0.50f && bb.GetWidth() < tab->ContentWidth)
{
// Enlarge tab display when hovering
bb.Max.x = bb.Min.x + IM_FLOOR(ImLerp(bb.GetWidth(), tab->ContentWidth, ImSaturate((g.HoveredIdNotActiveTimer - 0.40f) * 6.0f)));
display_draw_list = GetForegroundDrawList(window);
TabItemBackground(display_draw_list, bb, flags, GetColorU32(ImGuiCol_TitleBgActive));
}
#endif
// Render tab shape
ImDrawList* display_draw_list = window->DrawList;
const ImU32 tab_col = GetColorU32((held || hovered) ? ImGuiCol_TabHovered : tab_contents_visible ? (tab_bar_focused ? ImGuiCol_TabActive : ImGuiCol_TabUnfocusedActive) : (tab_bar_focused ? ImGuiCol_Tab : ImGuiCol_TabUnfocused));
TabItemBackground(display_draw_list, bb, flags, tab_col);
RenderNavHighlight(bb, id);
// Select with right mouse button. This is so the common idiom for context menu automatically highlight the current widget.
const bool hovered_unblocked = IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByPopup);
if (hovered_unblocked && (IsMouseClicked(1) || IsMouseReleased(1)))
tab_bar->NextSelectedTabId = id;
if (tab_bar->Flags & ImGuiTabBarFlags_NoCloseWithMiddleMouseButton)
flags |= ImGuiTabItemFlags_NoCloseWithMiddleMouseButton;
// Render tab label, process close button
const ImGuiID close_button_id = p_open ? window->GetID((void*)((intptr_t)id + 1)) : 0;
bool just_closed = TabItemLabelAndCloseButton(display_draw_list, bb, flags, tab_bar->FramePadding, label, id, close_button_id, tab_contents_visible);
if (just_closed && p_open != NULL)
{
*p_open = false;
TabBarCloseTab(tab_bar, tab);
}
// Restore main window position so user can draw there
if (want_clip_rect)
PopClipRect();
window->DC.CursorPos = backup_main_cursor_pos;
// Tooltip (FIXME: Won't work over the close button because ItemOverlap systems messes up with HoveredIdTimer)
// We test IsItemHovered() to discard e.g. when another item is active or drag and drop over the tab bar (which g.HoveredId ignores)
if (g.HoveredId == id && !held && g.HoveredIdNotActiveTimer > 0.50f && IsItemHovered())
if (!(tab_bar->Flags & ImGuiTabBarFlags_NoTooltip))
SetTooltip("%.*s", (int)(FindRenderedTextEnd(label) - label), label);
return tab_contents_visible;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %ecx, %r12d
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
cmpb $0x1, 0x61(%rdi)
jne 0x7082f
movq %r14, %rdi
callq 0x6f888
leaq 0x33e6a(%rip), %rax # 0xa46a0
movq (%rax), %r15
movq 0x1a80(%r15), %rax
cmpb $0x0, 0x83(%rax)
je 0x70851
xorl %r12d, %r12d
jmp 0x70ff0
movq %rax, 0x28(%rsp)
movq %r14, %rdi
movq %rbp, %rsi
callq 0x71136
movl %eax, %ebx
testq %r13, %r13
je 0x70873
cmpb $0x0, (%r13)
je 0x708f8
movl %r12d, %ecx
orl $0x100000, %ecx # imm = 0x100000
xorl %eax, %eax
btl $0x14, %r12d
cmovbl %r12d, %ecx
cmovaeq %r13, %rax
testq %r13, %r13
cmovnel %r12d, %ecx
movl %ecx, 0x24(%rsp)
xorl %esi, %esi
movq %rax, 0x90(%rsp)
testq %rax, %rax
setne %sil
movq %rbp, %rdi
callq 0x7116e
testl %ebx, %ebx
je 0x7092c
movslq (%r14), %rax
testq %rax, %rax
setg %cl
jle 0x7091a
movq 0x8(%r14), %r13
movb $0x1, %cl
cmpl %ebx, (%r13)
je 0x70928
movq %rax, %rcx
shlq $0x5, %rcx
addq %r13, %rcx
addq $-0x20, %rcx
movl $0x1, %edi
movq %rdi, %rdx
cmpq %rdi, %rax
je 0x7091c
leaq 0x20(%r13), %rsi
leaq 0x1(%rdx), %rdi
cmpl %ebx, 0x20(%r13)
movq %rsi, %r13
jne 0x708dd
jmp 0x7091f
movl $0x18, %edi
movl $0x1, %esi
callq 0x41a88
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
xorl %r12d, %r12d
jmp 0x70b91
jmp 0x70928
movq %rcx, %rsi
cmpq %rax, %rdx
setb %cl
movq %rsi, %r13
testb %cl, %cl
jne 0x7092f
xorl %r13d, %r13d
movq %r15, 0x18(%rsp)
movq %r13, %rdx
testq %r13, %r13
movaps %xmm0, 0x70(%rsp)
jne 0x70a0e
movl %ebx, %r12d
movl (%r14), %ebx
movl 0x4(%r14), %eax
cmpl %eax, %ebx
jne 0x709b1
incl %ebx
testl %eax, %eax
je 0x70966
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x7096b
movl $0x8, %ecx
cmpl %ebx, %ecx
cmovgl %ecx, %ebx
cmpl %ebx, %eax
jge 0x709b1
movslq %ebx, %rdi
shlq $0x5, %rdi
callq 0x31065
movq %rax, %r15
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x709a4
movslq (%r14), %rdx
shlq $0x5, %rdx
movq %r15, %rdi
callq 0x220a0
movq 0x8(%r14), %rdi
callq 0x3112f
movq %r15, 0x8(%r14)
movl %ebx, 0x4(%r14)
movaps 0x70(%rsp), %xmm0
movq 0x8(%r14), %rax
movslq (%r14), %rcx
shlq $0x5, %rcx
movaps 0x1b5bd(%rip), %xmm1 # 0x8bf80
movups %xmm1, (%rax,%rcx)
movl $0xffffffff, 0x10(%rax,%rcx) # imm = 0xFFFFFFFF
movq $0x0, 0x14(%rax,%rcx)
movl $0x0, 0x1c(%rax,%rcx)
movl (%r14), %ecx
leal 0x1(%rcx), %eax
movl %eax, (%r14)
testl %ecx, %ecx
js 0x71024
movq 0x8(%r14), %rcx
movl %eax, %eax
shlq $0x5, %rax
leaq (%rcx,%rax), %rdx
addq $-0x20, %rdx
movl %r12d, %ebx
movl %r12d, (%rdx)
movss %xmm0, 0x18(%rdx)
movl %ebx, 0x14(%rsp)
movq %rbp, 0x88(%rsp)
movq 0x8(%r14), %rax
cmpq %rdx, %rax
ja 0x71005
movslq (%r14), %rcx
shlq $0x5, %rcx
addq %rax, %rcx
cmpq %rdx, %rcx
jbe 0x71005
movl %edx, %ecx
subl %eax, %ecx
shrl $0x5, %ecx
movw %cx, 0x64(%r14)
movss %xmm0, 0x1c(%rdx)
movl 0x24(%r14), %ecx
movl 0x58(%r14), %eax
movl %eax, 0x54(%rsp)
incl %ecx
movl %ecx, 0x40(%rsp)
movq 0x18(%rsp), %rax
movl 0x1a08(%rax), %ebp
movl 0x8(%rdx), %r15d
incl %r15d
movl %ebp, 0x8(%rdx)
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rdx)
leaq 0x70(%r14), %r12
movl 0x70(%r14), %eax
xorl %ecx, %ecx
subl $0x1, %eax
cmovbl %ecx, %eax
movq %rdx, 0x48(%rsp)
movl %eax, 0x10(%rdx)
movq 0x88(%rsp), %rbx
movq %rbx, %rdi
callq 0x22340
leaq (%rbx,%rax), %rdx
incq %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3261e
movl 0x58(%r14), %eax
cmpl %ebp, %r15d
jge 0x70ae5
testb $0x2, %al
movl 0x14(%rsp), %ebx
movq 0x48(%rsp), %rsi
movl 0x40(%rsp), %edi
je 0x70b1d
cmpl $0x0, 0x18(%r14)
jne 0x70b1d
cmpl %ebp, %edi
jge 0x70adf
cmpl $0x0, 0x14(%r14)
jne 0x70b1d
movl %ebx, 0x18(%r14)
jmp 0x70b1d
testb $0x1, %al
movl 0x14(%rsp), %ebx
movq 0x48(%rsp), %rsi
movl 0x40(%rsp), %edi
jne 0x70b1d
movss 0x44(%r14), %xmm0
movss %xmm0, 0x14(%rsi)
movss 0x18(%rsi), %xmm1
movq 0x18(%rsp), %rax
addss 0x15b8(%rax), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x44(%r14)
testb $0x2, 0x24(%rsp)
je 0x70b2e
cmpl %ebx, 0x14(%r14)
je 0x70b2e
movl %ebx, 0x18(%r14)
cmpl %ebx, 0x1c(%r14)
jne 0x70b3e
movb $0x1, 0x62(%r14)
movb $0x1, %r12b
jmp 0x70b63
cmpl %ebp, %edi
setge %al
cmpl $0x0, 0x14(%r14)
setne %cl
orb %al, %cl
jne 0x70b60
cmpl $0x1, (%r14)
jne 0x70b60
testb $0x2, 0x58(%r14)
sete %r12b
jmp 0x70b63
xorl %r12d, %r12d
cmpl %ebp, %edi
setge %al
testq %r13, %r13
sete %cl
cmpl %ebp, %r15d
jge 0x70ba4
orb %al, %cl
je 0x70ba4
movl $0x18, %edi
movl $0x1, %esi
callq 0x41a88
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movl %ebx, %esi
xorl %edx, %edx
callq 0x405cd
callq 0x41b8d
jmp 0x70ff0
cmpl %ebx, 0x14(%r14)
jne 0x70bb8
movq 0x18(%rsp), %rax
movl 0x1a08(%rax), %eax
movl %eax, 0xc(%rsi)
movl %ebp, 0x6c(%rsp)
movq 0x28(%rsp), %rax
movq 0xd0(%rax), %rcx
movq %rcx, 0x80(%rsp)
movss 0x14(%rsi), %xmm0
subss 0x48(%r14), %xmm0
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movsd 0x28(%r14), %xmm1
xorps %xmm2, %xmm2
movss %xmm0, %xmm2 # xmm2 = xmm0[0],xmm2[1,2,3]
addps %xmm1, %xmm2
movss 0x18(%rsi), %xmm0
movlps %xmm2, 0xd0(%rax)
movaps 0x70(%rsp), %xmm1
movss %xmm0, %xmm1 # xmm1 = xmm0[0],xmm1[1,2,3]
addps %xmm2, %xmm1
movlhps %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
movups %xmm2, 0x30(%rsp)
movss 0x30(%rsp), %xmm0
movss 0x28(%r14), %xmm1
movb $0x1, %cl
ucomiss %xmm0, %xmm1
ja 0x70c33
movss 0x38(%rsp), %xmm2
ucomiss 0x30(%r14), %xmm2
seta %cl
movq %r12, 0x40(%rsp)
movb %cl, 0x70(%rsp)
testb %cl, %cl
je 0x70c96
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
andps %xmm2, %xmm0
andnps %xmm1, %xmm2
orps %xmm0, %xmm2
movss 0x34(%rsp), %xmm0
addss 0xd3a9(%rip), %xmm0 # 0x7e008
movss 0x3c(%rsp), %xmm1
leaq 0x60(%rsp), %rdi
movss %xmm2, (%rdi)
movss %xmm0, 0x4(%rdi)
movss 0x30(%r14), %xmm0
leaq 0x58(%rsp), %rsi
movss %xmm0, (%rsi)
movss %xmm1, 0x4(%rsi)
movl $0x1, %edx
callq 0x3e148
movq 0x28(%rsp), %rax
movq 0xe8(%rax), %rbp
leaq 0x30(%rsp), %r13
movsd (%r13), %xmm0
movsd 0x8(%r13), %xmm1
subps %xmm0, %xmm1
leaq 0x60(%rsp), %rdi
movlps %xmm1, (%rdi)
movq 0x18(%rsp), %r12
movss 0x15a4(%r12), %xmm0
movq %rax, %rbx
callq 0x4046e
movq %rbp, 0xe8(%rbx)
movq %r13, %rdi
movl 0x14(%rsp), %ebx
movl %ebx, %esi
xorl %edx, %edx
callq 0x405cd
testb %al, %al
je 0x70dc5
movzbl 0x1f2c(%r12), %r8d
shll $0x6, %r8d
orl $0x102, %r8d # imm = 0x102
leaq 0x30(%rsp), %rdi
leaq 0x60(%rsp), %rdx
leaq 0x58(%rsp), %rcx
movl %ebx, %esi
callq 0x5d4bf
testb %al, %al
je 0x70d21
movl %ebx, 0x18(%r14)
movq 0x18(%rsp), %rax
cmpl %ebx, 0x1ab4(%rax)
sete %al
orb %al, 0x60(%rsp)
cmpb $0x0, 0x58(%rsp)
movq 0x90(%rsp), %rbp
movq 0x40(%rsp), %r12
jne 0x70d4c
callq 0x3fe99
cmpb $0x1, 0x58(%rsp)
movl 0x6c(%rsp), %eax
jne 0x70e24
cmpl %eax, %r15d
jl 0x70e24
movss 0xd29c(%rip), %xmm0 # 0x7e008
xorl %edi, %edi
callq 0x3fa7f
testb %al, %al
je 0x70e24
movq 0x18(%rsp), %rax
cmpb $0x0, 0x1f2c(%rax)
jne 0x70e24
testb $0x1, 0x58(%r14)
je 0x70e24
movq 0x18(%rsp), %rax
movss 0x3c0(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x70def
movss 0x30(%rsp), %xmm2
movq 0x18(%rsp), %rax
ucomiss 0x130(%rax), %xmm2
jbe 0x70def
movb $-0x1, %al
jmp 0x70e0a
cmpb $0x0, 0x70(%rsp)
je 0x70dd1
callq 0x3e1bc
movq 0x28(%rsp), %rax
movq 0x80(%rsp), %rcx
movq %rcx, 0xd0(%rax)
movq 0x40(%rsp), %r12
jmp 0x70ff0
ucomiss %xmm1, %xmm0
jbe 0x70e24
movq 0x18(%rsp), %rax
movss 0x130(%rax), %xmm0
ucomiss 0x38(%rsp), %xmm0
jbe 0x70e24
movb $0x1, %al
cmpl $0x0, 0x5c(%r14)
jne 0x71043
movq 0x48(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x5c(%r14)
movb %al, 0x60(%r14)
movq 0x28(%rsp), %rax
movq 0x2b0(%rax), %r15
movl $0x22, %edi
cmpb $0x0, 0x58(%rsp)
jne 0x70e6b
cmpb $0x0, 0x60(%rsp)
jne 0x70e6b
xorl %eax, %eax
testb %r12b, %r12b
je 0x70e5c
btl $0x15, 0x54(%rsp)
setae %al
leal 0x23(,%rax,2), %edi
jmp 0x70e6b
btl $0x15, 0x54(%rsp)
setae %al
leal (%rax,%rax,2), %edi
addl $0x21, %edi
movss 0xd19d(%rip), %xmm0 # 0x7e010
callq 0x32e01
leaq 0x30(%rsp), %r13
movq %r15, %rbx
movq %r15, %rdi
movq %r13, %rsi
movl %eax, %ecx
callq 0x71200
movq %r13, %rdi
movl 0x14(%rsp), %esi
movl $0x1, %edx
callq 0x3447a
movl $0x8, %edi
callq 0x35369
testb %al, %al
je 0x70ed2
movl $0x1, %edi
xorl %esi, %esi
callq 0x3f948
testb %al, %al
jne 0x70eca
movl $0x1, %edi
callq 0x3f9c4
testb %al, %al
je 0x70ed2
movl 0x14(%rsp), %eax
movl %eax, 0x18(%r14)
movl 0x58(%r14), %r13d
shrl %r13d
andl $0x4, %r13d
orl 0x24(%rsp), %r13d
movq %rbp, %r15
testq %rbp, %rbp
je 0x70f02
movl 0x14(%rsp), %ebp
movl %ebp, %esi
incq %rsi
movq 0x28(%rsp), %rdi
callq 0x34c1a
movl %eax, %r9d
jmp 0x70f09
xorl %r9d, %r9d
movl 0x14(%rsp), %ebp
movsd 0x68(%r14), %xmm0
movzbl %r12b, %eax
movl %eax, (%rsp)
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
movl %r13d, %edx
movq 0x88(%rsp), %r13
movq %r13, %rcx
movl %ebp, %r8d
callq 0x716d3
testq %r15, %r15
je 0x70f75
testb %al, %al
je 0x70f75
movb $0x0, (%r15)
movq 0x48(%rsp), %rcx
movl (%rcx), %eax
movl 0x4(%rcx), %ecx
cmpl %eax, 0x1c(%r14)
jne 0x70f6c
testb $0x1, %cl
jne 0x70f75
movq 0x48(%rsp), %rax
movl $0xffffffff, 0x8(%rax) # imm = 0xFFFFFFFF
movq $0x0, 0x14(%r14)
jmp 0x70f75
testb $0x1, %cl
je 0x70f75
movl %eax, 0x18(%r14)
cmpb $0x0, 0x70(%rsp)
je 0x70f81
callq 0x3e1bc
movq 0x28(%rsp), %rax
movq 0x80(%rsp), %rcx
movq %rcx, 0xd0(%rax)
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
cmpl %ecx, 0x1ab4(%rax)
jne 0x70ff0
cmpb $0x0, 0x58(%rsp)
jne 0x70ff0
movss 0x1ac4(%rax), %xmm0
ucomiss 0xde9c(%rip), %xmm0 # 0x7ee58
jbe 0x70ff0
xorl %edi, %edi
callq 0x35369
testb %al, %al
je 0x70ff0
testb $0x20, 0x58(%r14)
jne 0x70ff0
movq %r13, %rdi
xorl %esi, %esi
callq 0x33672
subl %r13d, %eax
leaq 0x104b5(%rip), %rdi # 0x81499
movl %eax, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x3f075
movl %r12d, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1d13b(%rip), %rdi # 0x8e147
leaq 0x10c3e(%rip), %rsi # 0x81c51
leaq 0x1d14c(%rip), %rcx # 0x8e166
movl $0x54f, %edx # imm = 0x54F
callq 0x22190
leaq 0x18ef5(%rip), %rdi # 0x89f20
leaq 0x10c1f(%rip), %rsi # 0x81c51
leaq 0x1d292(%rip), %rcx # 0x8e2cb
movl $0x538, %edx # imm = 0x538
callq 0x22190
leaq 0x1c924(%rip), %rdi # 0x8d96e
leaq 0x1b10f(%rip), %rsi # 0x8c160
leaq 0x1c8c6(%rip), %rcx # 0x8d91e
movl $0x1b12, %edx # imm = 0x1B12
callq 0x22190
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
ImGui::SetTabItemClosed(char const*)
|
void ImGui::SetTabItemClosed(const char* label)
{
ImGuiContext& g = *GImGui;
bool is_within_manual_tab_bar = g.CurrentTabBar && !(g.CurrentTabBar->Flags & ImGuiTabBarFlags_DockNode);
if (is_within_manual_tab_bar)
{
ImGuiTabBar* tab_bar = g.CurrentTabBar;
IM_ASSERT(tab_bar->WantLayout); // Needs to be called AFTER BeginTabBar() and BEFORE the first call to BeginTabItem()
ImGuiID tab_id = TabBarCalcTabID(tab_bar, label);
TabBarRemoveTab(tab_bar, tab_id);
}
}
|
pushq %rbx
leaq 0x32cb1(%rip), %rax # 0xa46a0
movq (%rax), %rax
movq 0x1fd0(%rax), %rbx
testq %rbx, %rbx
je 0x71a20
testb $0x10, 0x5a(%rbx)
jne 0x71a20
cmpb $0x0, 0x61(%rbx)
je 0x71a22
movq %rdi, %rsi
movq %rbx, %rdi
callq 0x71136
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
jmp 0x705e2
popq %rbx
retq
leaq 0x1c088(%rip), %rdi # 0x8dab1
leaq 0x1a730(%rip), %rsi # 0x8c160
leaq 0x1c08e(%rip), %rcx # 0x8dac5
movl $0x1c76, %edx # imm = 0x1C76
callq 0x22190
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
ImGui::GetColumnWidth(int)
|
float ImGui::GetColumnWidth(int column_index)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImGuiColumns* columns = window->DC.CurrentColumns;
if (columns == NULL)
return GetContentRegionAvail().x;
if (column_index < 0)
column_index = columns->Current;
return GetColumnOffsetFromNorm(columns, columns->Columns[column_index + 1].OffsetNorm - columns->Columns[column_index].OffsetNorm);
}
|
pushq %rax
leaq 0x32b77(%rip), %rax # 0xa46a0
movq (%rax), %rax
movq 0x1a80(%rax), %rax
movq 0x1a0(%rax), %rax
testq %rax, %rax
je 0x71b88
testl %edi, %edi
jns 0x71b46
movl 0xc(%rax), %edi
leal 0x1(%rdi), %ecx
cmpl %ecx, 0x50(%rax)
jle 0x71b8f
movq 0x58(%rax), %rdx
movslq %ecx, %rcx
leaq (%rcx,%rcx,8), %rsi
leaq (%rsi,%rsi,2), %rsi
addq %rcx, %rsi
movss (%rdx,%rsi), %xmm1
movslq %edi, %rcx
leaq (%rcx,%rcx,8), %rsi
leaq (%rsi,%rsi,2), %rsi
addq %rcx, %rsi
subss (%rdx,%rsi), %xmm1
movss 0x18(%rax), %xmm0
subss 0x14(%rax), %xmm0
mulss %xmm1, %xmm0
jmp 0x71b8d
callq 0x40124
popq %rax
retq
leaq 0x100b2(%rip), %rdi # 0x81c48
leaq 0x100b4(%rip), %rsi # 0x81c51
leaq 0x1c75c(%rip), %rcx # 0x8e300
movl $0x52e, %edx # imm = 0x52E
callq 0x22190
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
ImGui::EndColumns()
|
void ImGui::EndColumns()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
ImGuiColumns* columns = window->DC.CurrentColumns;
IM_ASSERT(columns != NULL);
PopItemWidth();
if (columns->Count > 1)
{
PopClipRect();
columns->Splitter.Merge(window->DrawList);
}
const ImGuiColumnsFlags flags = columns->Flags;
columns->LineMaxY = ImMax(columns->LineMaxY, window->DC.CursorPos.y);
window->DC.CursorPos.y = columns->LineMaxY;
if (!(flags & ImGuiColumnsFlags_GrowParentContentsSize))
window->DC.CursorMaxPos.x = columns->HostCursorMaxPosX; // Restore cursor max pos, as columns don't grow parent
// Draw columns borders and handle resize
// The IsBeingResized flag ensure we preserve pre-resize columns width so back-and-forth are not lossy
bool is_being_resized = false;
if (!(flags & ImGuiColumnsFlags_NoBorder) && !window->SkipItems)
{
// We clip Y boundaries CPU side because very long triangles are mishandled by some GPU drivers.
const float y1 = ImMax(columns->HostCursorPosY, window->ClipRect.Min.y);
const float y2 = ImMin(window->DC.CursorPos.y, window->ClipRect.Max.y);
int dragging_column = -1;
for (int n = 1; n < columns->Count; n++)
{
ImGuiColumnData* column = &columns->Columns[n];
float x = window->Pos.x + GetColumnOffset(n);
const ImGuiID column_id = columns->ID + ImGuiID(n);
const float column_hit_hw = COLUMNS_HIT_RECT_HALF_WIDTH;
const ImRect column_hit_rect(ImVec2(x - column_hit_hw, y1), ImVec2(x + column_hit_hw, y2));
KeepAliveID(column_id);
if (IsClippedEx(column_hit_rect, column_id, false))
continue;
bool hovered = false, held = false;
if (!(flags & ImGuiColumnsFlags_NoResize))
{
ButtonBehavior(column_hit_rect, column_id, &hovered, &held);
if (hovered || held)
g.MouseCursor = ImGuiMouseCursor_ResizeEW;
if (held && !(column->Flags & ImGuiColumnsFlags_NoResize))
dragging_column = n;
}
// Draw column
const ImU32 col = GetColorU32(held ? ImGuiCol_SeparatorActive : hovered ? ImGuiCol_SeparatorHovered : ImGuiCol_Separator);
const float xi = IM_FLOOR(x);
window->DrawList->AddLine(ImVec2(xi, y1 + 1.0f), ImVec2(xi, y2), col);
}
// Apply dragging after drawing the column lines, so our rendered lines are in sync with how items were displayed during the frame.
if (dragging_column != -1)
{
if (!columns->IsBeingResized)
for (int n = 0; n < columns->Count + 1; n++)
columns->Columns[n].OffsetNormBeforeResize = columns->Columns[n].OffsetNorm;
columns->IsBeingResized = is_being_resized = true;
float x = GetDraggedColumnOffset(columns, dragging_column);
SetColumnOffset(dragging_column, x);
}
}
columns->IsBeingResized = is_being_resized;
window->WorkRect = columns->HostWorkRect;
window->DC.CurrentColumns = NULL;
window->DC.ColumnsOffset.x = 0.0f;
window->DC.CursorPos.x = IM_FLOOR(window->Pos.x + window->DC.Indent.x + window->DC.ColumnsOffset.x);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
leaq 0x31ec1(%rip), %rbx # 0xa46a0
movq (%rbx), %r15
movq 0x1a80(%r15), %rbp
movb $0x1, 0x80(%rbp)
movq 0x1a0(%rbp), %r12
testq %r12, %r12
je 0x72c0d
callq 0x43592
cmpl $0x2, 0x10(%r12)
jl 0x72823
callq 0x3e1bc
leaq 0x60(%r12), %rdi
movq 0x2b0(%rbp), %rsi
callq 0x50c92
movl 0x4(%r12), %eax
movss 0x20(%r12), %xmm0
movss 0xd4(%rbp), %xmm1
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
andps %xmm2, %xmm0
andnps %xmm1, %xmm2
orps %xmm0, %xmm2
movss %xmm2, 0x20(%r12)
movaps %xmm2, 0x50(%rsp)
movss %xmm2, 0xd4(%rbp)
movl %eax, 0xc(%rsp)
testb $0x10, %al
jne 0x72873
movss 0x28(%r12), %xmm0
movss %xmm0, 0xe8(%rbp)
testb $0x1, 0xc(%rsp)
jne 0x72883
cmpb $0x0, 0x83(%rbp)
je 0x7288a
xorl %eax, %eax
jmp 0x72b92
movl 0x10(%r12), %eax
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
cmpl $0x2, %eax
jl 0x72a81
movq %r15, 0x68(%rsp)
movss 0x24(%r12), %xmm0
movss 0x25c(%rbp), %xmm1
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
andps %xmm2, %xmm0
andnps %xmm1, %xmm2
orps %xmm0, %xmm2
movaps 0x50(%rsp), %xmm0
minss 0x264(%rbp), %xmm0
movaps %xmm0, 0x50(%rsp)
movaps %xmm2, 0x70(%rsp)
addss 0xb72e(%rip), %xmm2 # 0x7e010
movss %xmm2, 0x2c(%rsp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movq %rax, 0x20(%rsp)
movl $0x1, %r14d
movl $0x24, %r15d
movslq 0x50(%r12), %rax
cmpq %rax, %r14
jge 0x72bee
movq 0x58(%r12), %rbx
movss 0x10(%rbp), %xmm0
movss %xmm0, 0x10(%rsp)
movl %r14d, %edi
callq 0x71aaa
movaps %xmm0, %xmm1
addss 0x10(%rsp), %xmm1
movl (%r12), %r13d
addq %r14, %r13
movaps %xmm1, %xmm0
addss 0x19481(%rip), %xmm0 # 0x8bdc0
movaps %xmm1, 0x10(%rsp)
addss 0xc56c(%rip), %xmm1 # 0x7eeb8
movss %xmm0, 0x40(%rsp)
movaps 0x70(%rsp), %xmm0
movss %xmm0, 0x44(%rsp)
movss %xmm1, 0x48(%rsp)
movaps 0x50(%rsp), %xmm0
movss %xmm0, 0x4c(%rsp)
movl %r13d, %edi
callq 0x34bf4
leaq 0x40(%rsp), %rdi
movl %r13d, %esi
xorl %edx, %edx
callq 0x356a5
testb %al, %al
jne 0x72a60
xorl %eax, %eax
movb %al, 0xb(%rsp)
movb %al, 0xa(%rsp)
testb $0x2, 0xc(%rsp)
jne 0x729ef
leaq 0x40(%rsp), %rdi
movl %r13d, %esi
leaq 0xb(%rsp), %rdx
leaq 0xa(%rsp), %rcx
xorl %r8d, %r8d
callq 0x5d4bf
cmpb $0x0, 0xb(%rsp)
jne 0x729c6
cmpb $0x1, 0xa(%rsp)
jne 0x729d5
movq 0x68(%rsp), %rax
movl $0x4, 0x1f28(%rax)
cmpb $0x1, 0xa(%rsp)
jne 0x729ef
testb $0x2, (%rbx,%r15)
movq 0x20(%rsp), %rax
cmovel %r14d, %eax
movq %rax, 0x20(%rsp)
movzbl 0xb(%rsp), %edi
andl $0x1, %edi
addl $0x1b, %edi
cmpb $0x0, 0xa(%rsp)
movl $0x1d, %eax
cmovnel %eax, %edi
movss 0xb601(%rip), %xmm0 # 0x7e010
callq 0x32e01
cvttps2dq 0x10(%rsp), %xmm0
cvtdq2ps %xmm0, %xmm0
movq 0x2b0(%rbp), %rdi
movss %xmm0, 0x38(%rsp)
movss 0x2c(%rsp), %xmm1
movss %xmm1, 0x3c(%rsp)
movss %xmm0, 0x30(%rsp)
movaps 0x50(%rsp), %xmm0
movss %xmm0, 0x34(%rsp)
leaq 0x38(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movl %eax, %ecx
movss 0xb5b5(%rip), %xmm0 # 0x7e010
callq 0x4e7d4
incq %r14
movslq 0x10(%r12), %rax
addq $0x1c, %r15
cmpq %rax, %r14
jl 0x728fe
leaq 0x31c24(%rip), %rbx # 0xa46a0
movq 0x20(%rsp), %r14
cmpl $-0x1, %r14d
je 0x72b8b
testl %eax, %eax
js 0x72ae4
cmpb $0x0, 0x9(%r12)
jne 0x72ae4
movl 0x50(%r12), %edx
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
movl %eax, %esi
leaq (%rdx,%rdx,8), %rax
leaq (%rax,%rax,2), %rax
addq %rdx, %rax
leaq (%rsi,%rsi,8), %rdx
addq $0x9, %rdx
leaq (%rdx,%rdx,2), %rdx
addq %rsi, %rdx
incq %rdx
cmpq %rcx, %rax
je 0x72bee
movq 0x58(%r12), %rsi
movss (%rsi,%rcx), %xmm0
movss %xmm0, 0x4(%rsi,%rcx)
addq $0x1c, %rcx
cmpq %rcx, %rdx
jne 0x72ac2
movb $0x1, 0x9(%r12)
testl %r14d, %r14d
jle 0x72c2c
movq (%rbx), %rbx
movl (%r12), %eax
addl %r14d, %eax
cmpl %eax, 0x1ac8(%rbx)
jne 0x72c4b
movss 0x130(%rbx), %xmm0
subss 0x1af0(%rbx), %xmm0
addss 0xc397(%rip), %xmm0 # 0x7eeb8
movq 0x1a80(%rbx), %rax
subss 0x10(%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
leal -0x1(%r14), %edi
callq 0x71aaa
addss 0x15cc(%rbx), %xmm0
movaps %xmm0, %xmm1
movaps 0x10(%rsp), %xmm2
cmpless %xmm2, %xmm1
andps %xmm1, %xmm2
andnps %xmm0, %xmm1
orps %xmm2, %xmm1
testb $0x4, 0x4(%r12)
je 0x72b80
leal 0x1(%r14), %edi
movaps %xmm1, 0x10(%rsp)
callq 0x71aaa
movaps 0x10(%rsp), %xmm1
subss 0x15cc(%rbx), %xmm0
minss %xmm0, %xmm1
movl %r14d, %edi
movaps %xmm1, %xmm0
callq 0x71bae
cmpl $-0x1, %r14d
setne %al
movb %al, 0x9(%r12)
movups 0x3c(%r12), %xmm0
movups %xmm0, 0x248(%rbp)
movq $0x0, 0x1a0(%rbp)
movl $0x0, 0x10c(%rbp)
movss 0x10(%rbp), %xmm0
addss 0x108(%rbp), %xmm0
xorps %xmm1, %xmm1
addss %xmm0, %xmm1
cvttps2dq %xmm1, %xmm0
cvtdq2ps %xmm0, %xmm0
movss %xmm0, 0xd0(%rbp)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf053(%rip), %rdi # 0x81c48
leaq 0xf055(%rip), %rsi # 0x81c51
leaq 0x1b6fd(%rip), %rcx # 0x8e300
movl $0x52e, %edx # imm = 0x52E
callq 0x22190
leaq 0x1af86(%rip), %rdi # 0x8db9a
leaq 0x19545(%rip), %rsi # 0x8c160
leaq 0x1b0e9(%rip), %rcx # 0x8dd0b
movl $0x1e2f, %edx # imm = 0x1E2F
callq 0x22190
leaq 0x1b49f(%rip), %rdi # 0x8e0d2
leaq 0x19526(%rip), %rsi # 0x8c160
leaq 0x1b4a2(%rip), %rcx # 0x8e0e3
movl $0x1d18, %edx # imm = 0x1D18
callq 0x22190
leaq 0x1b4c3(%rip), %rdi # 0x8e115
leaq 0x19507(%rip), %rsi # 0x8c160
leaq 0x1b483(%rip), %rcx # 0x8e0e3
movl $0x1d19, %edx # imm = 0x1D19
callq 0x22190
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
ImStb::stb_textedit_delete(ImGuiInputTextState*, ImStb::STB_TexteditState*, int, int)
|
static void stb_textedit_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int len)
{
stb_text_makeundo_delete(str, state, where, len);
STB_TEXTEDIT_DELETECHARS(str, where, len);
state->has_preferred_x = 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x18(%rsi), %rdi
movl %edx, %esi
movl %ecx, %edx
xorl %ecx, %ecx
callq 0x73302
testq %rax, %rax
sete %cl
testl %ebp, %ebp
setle %dl
orb %cl, %dl
jne 0x732c7
movl 0x10(%r15), %ecx
movslq %r14d, %rdx
cmpl %r14d, %ecx
cmovlel %r14d, %ecx
subl %r14d, %ecx
movl %ebp, %esi
addq %rdx, %rdx
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x732e3
movq 0x18(%r15), %r8
addq %rdx, %r8
movzwl (%r8,%rdi,2), %r8d
movw %r8w, (%rax,%rdi,2)
incq %rdi
cmpq %rdi, %rsi
jne 0x732a9
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x72d6d
movb $0x0, 0xf(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe95e(%rip), %rdi # 0x81c48
leaq 0xe960(%rip), %rsi # 0x81c51
leaq 0x1abee(%rip), %rcx # 0x8dee6
movl $0x52f, %edx # imm = 0x52F
callq 0x22190
|
/ggerganov[P]kbd-audio/imgui/imstb_textedit.h
|
ImStb::stb_text_locate_coord(ImGuiInputTextState*, float, float)
|
static int stb_text_locate_coord(STB_TEXTEDIT_STRING *str, float x, float y)
{
StbTexteditRow r;
int n = STB_TEXTEDIT_STRINGLEN(str);
float base_y = 0, prev_x;
int i=0, k;
r.x0 = r.x1 = 0;
r.ymin = r.ymax = 0;
r.num_chars = 0;
// search rows to find one that straddles 'y'
while (i < n) {
STB_TEXTEDIT_LAYOUTROW(&r, str, i);
if (r.num_chars <= 0)
return n;
if (i==0 && y < base_y + r.ymin)
return 0;
if (y < base_y + r.ymax)
break;
i += r.num_chars;
base_y += r.baseline_y_delta;
}
// below all text, return 'after' last character
if (i >= n)
return n;
// check if it's before the beginning of the line
if (x < r.x0)
return i;
// check if it's before the end of the line
if (x < r.x1) {
// search characters in row for one that straddles 'x'
prev_x = r.x0;
for (k=0; k < r.num_chars; ++k) {
float w = STB_TEXTEDIT_GETWIDTH(str, i, k);
if (x < prev_x+w) {
if (x < prev_x+w/2)
return k+i;
else
return k+i+1;
}
prev_x += w;
}
// shouldn't happen, but if it does, fall through to end-of-line case
}
// if the last character is a newline, return that. otherwise return 'after' the last character
if (STB_TEXTEDIT_GETCHAR(str, i+r.num_chars-1) == STB_TEXTEDIT_NEWLINE)
return i+r.num_chars-1;
else
return i+r.num_chars;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movaps %xmm0, %xmm3
movq %rdi, %rbx
movl 0x4(%rdi), %r15d
testl %r15d, %r15d
setg %r12b
jle 0x735eb
movss %xmm3, 0x4(%rsp)
xorps %xmm3, %xmm3
xorl %r14d, %r14d
movss %xmm1, 0xc(%rsp)
movss %xmm3, 0x8(%rsp)
movq 0x18(%rbx), %rax
movq $0x0, 0x10(%rsp)
movslq %r14d, %rcx
leaq (%rax,%rcx,2), %r13
movslq 0x4(%rbx), %rcx
leaq (%rax,%rcx,2), %rsi
movq %r13, %rdi
leaq 0x10(%rsp), %rdx
movl $0x1, %ecx
callq 0x6889e
movq 0x10(%rsp), %rbp
subq %r13, %rbp
shrq %rbp
testl %ebp, %ebp
jle 0x736a1
movss 0xc(%rsp), %xmm1
movss 0x8(%rsp), %xmm3
ucomiss %xmm1, %xmm3
jbe 0x735c7
testl %r14d, %r14d
je 0x7369e
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2 # xmm2 = xmm2[1,1],xmm0[1,1]
addss %xmm2, %xmm3
ucomiss %xmm1, %xmm3
ja 0x735e3
addl %ebp, %r14d
cmpl %r15d, %r14d
setl %r12b
jl 0x73566
movss 0x4(%rsp), %xmm3
jmp 0x735f3
xorl %r14d, %r14d
xorps %xmm0, %xmm0
xorl %ebp, %ebp
testb $0x1, %r12b
je 0x736a1
xorps %xmm1, %xmm1
ucomiss %xmm3, %xmm1
jbe 0x7360d
movl %r14d, %r15d
jmp 0x736a1
ucomiss %xmm3, %xmm0
jbe 0x73680
testl %ebp, %ebp
jle 0x73680
leal 0x1(%r14), %r13d
xorps %xmm2, %xmm2
xorl %r12d, %r12d
movss %xmm3, 0x4(%rsp)
movss %xmm2, 0x8(%rsp)
movq %rbx, %rdi
movl %r14d, %esi
movl %r12d, %edx
callq 0x731e9
movss 0x8(%rsp), %xmm4
movss 0x4(%rsp), %xmm3
movaps %xmm4, %xmm1
addss %xmm0, %xmm1
ucomiss %xmm3, %xmm1
movaps %xmm1, %xmm2
jbe 0x73673
mulss 0xb7fb(%rip), %xmm0 # 0x7ee58
addss %xmm4, %xmm0
ucomiss %xmm3, %xmm0
jbe 0x7366c
leal (%r14,%r12), %r15d
jmp 0x73670
leal (%r12,%r13), %r15d
movaps %xmm4, %xmm2
ucomiss %xmm3, %xmm1
ja 0x736a1
incl %r12d
cmpl %r12d, %ebp
jne 0x73626
addl %r14d, %ebp
cmpl %ebp, 0x10(%rbx)
jl 0x736b3
movq 0x18(%rbx), %rax
movslq %ebp, %r15
decl %ebp
cmpw $0xa, -0x2(%rax,%r15,2)
cmovel %ebp, %r15d
jmp 0x736a1
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe58e(%rip), %rdi # 0x81c48
leaq 0xe590(%rip), %rsi # 0x81c51
leaq 0x1a81e(%rip), %rcx # 0x8dee6
movl $0x52f, %edx # imm = 0x52F
callq 0x22190
|
/ggerganov[P]kbd-audio/imgui/imstb_textedit.h
|
bool ImGui::DragBehaviorT<long long, long long, double>(int, long long*, float, long long, long long, char const*, float, int)
|
bool ImGui::DragBehaviorT(ImGuiDataType data_type, TYPE* v, float v_speed, const TYPE v_min, const TYPE v_max, const char* format, float power, ImGuiDragFlags flags)
{
ImGuiContext& g = *GImGui;
const ImGuiAxis axis = (flags & ImGuiDragFlags_Vertical) ? ImGuiAxis_Y : ImGuiAxis_X;
const bool is_decimal = (data_type == ImGuiDataType_Float) || (data_type == ImGuiDataType_Double);
const bool is_clamped = (v_min < v_max);
const bool is_power = (power != 1.0f && is_decimal && is_clamped && (v_max - v_min < FLT_MAX));
const bool is_locked = (v_min > v_max);
if (is_locked)
return false;
// Default tweak speed
if (v_speed == 0.0f && is_clamped && (v_max - v_min < FLT_MAX))
v_speed = (float)((v_max - v_min) * g.DragSpeedDefaultRatio);
// Inputs accumulates into g.DragCurrentAccum, which is flushed into the current value as soon as it makes a difference with our precision settings
float adjust_delta = 0.0f;
if (g.ActiveIdSource == ImGuiInputSource_Mouse && IsMousePosValid() && g.IO.MouseDragMaxDistanceSqr[0] > 1.0f*1.0f)
{
adjust_delta = g.IO.MouseDelta[axis];
if (g.IO.KeyAlt)
adjust_delta *= 1.0f / 100.0f;
if (g.IO.KeyShift)
adjust_delta *= 10.0f;
}
else if (g.ActiveIdSource == ImGuiInputSource_Nav)
{
int decimal_precision = is_decimal ? ImParseFormatPrecision(format, 3) : 0;
adjust_delta = GetNavInputAmount2d(ImGuiNavDirSourceFlags_Keyboard | ImGuiNavDirSourceFlags_PadDPad, ImGuiInputReadMode_RepeatFast, 1.0f / 10.0f, 10.0f)[axis];
v_speed = ImMax(v_speed, GetMinimumStepAtDecimalPrecision(decimal_precision));
}
adjust_delta *= v_speed;
// For vertical drag we currently assume that Up=higher value (like we do with vertical sliders). This may become a parameter.
if (axis == ImGuiAxis_Y)
adjust_delta = -adjust_delta;
// Clear current value on activation
// Avoid altering values and clamping when we are _already_ past the limits and heading in the same direction, so e.g. if range is 0..255, current value is 300 and we are pushing to the right side, keep the 300.
bool is_just_activated = g.ActiveIdIsJustActivated;
bool is_already_past_limits_and_pushing_outward = is_clamped && ((*v >= v_max && adjust_delta > 0.0f) || (*v <= v_min && adjust_delta < 0.0f));
bool is_drag_direction_change_with_power = is_power && ((adjust_delta < 0 && g.DragCurrentAccum > 0) || (adjust_delta > 0 && g.DragCurrentAccum < 0));
if (is_just_activated || is_already_past_limits_and_pushing_outward || is_drag_direction_change_with_power)
{
g.DragCurrentAccum = 0.0f;
g.DragCurrentAccumDirty = false;
}
else if (adjust_delta != 0.0f)
{
g.DragCurrentAccum += adjust_delta;
g.DragCurrentAccumDirty = true;
}
if (!g.DragCurrentAccumDirty)
return false;
TYPE v_cur = *v;
FLOATTYPE v_old_ref_for_accum_remainder = (FLOATTYPE)0.0f;
if (is_power)
{
// Offset + round to user desired precision, with a curve on the v_min..v_max range to get more precision on one side of the range
FLOATTYPE v_old_norm_curved = ImPow((FLOATTYPE)(v_cur - v_min) / (FLOATTYPE)(v_max - v_min), (FLOATTYPE)1.0f / power);
FLOATTYPE v_new_norm_curved = v_old_norm_curved + (g.DragCurrentAccum / (v_max - v_min));
v_cur = v_min + (SIGNEDTYPE)ImPow(ImSaturate((float)v_new_norm_curved), power) * (v_max - v_min);
v_old_ref_for_accum_remainder = v_old_norm_curved;
}
else
{
v_cur += (SIGNEDTYPE)g.DragCurrentAccum;
}
// Round to user desired precision based on format string
v_cur = RoundScalarWithFormatT<TYPE, SIGNEDTYPE>(format, data_type, v_cur);
// Preserve remainder after rounding has been applied. This also allow slow tweaking of values.
g.DragCurrentAccumDirty = false;
if (is_power)
{
FLOATTYPE v_cur_norm_curved = ImPow((FLOATTYPE)(v_cur - v_min) / (FLOATTYPE)(v_max - v_min), (FLOATTYPE)1.0f / power);
g.DragCurrentAccum -= (float)(v_cur_norm_curved - v_old_ref_for_accum_remainder);
}
else
{
g.DragCurrentAccum -= (float)((SIGNEDTYPE)v_cur - (SIGNEDTYPE)*v);
}
// Lose zero sign for float/double
if (v_cur == (TYPE)-0)
v_cur = (TYPE)0;
// Clamp values (+ handle overflow/wrap-around for integer types)
if (*v != v_cur && is_clamped)
{
if (v_cur < v_min || (v_cur > *v && adjust_delta < 0.0f && !is_decimal))
v_cur = v_min;
if (v_cur > v_max || (v_cur < *v && adjust_delta > 0.0f && !is_decimal))
v_cur = v_max;
}
// Apply result
if (*v == v_cur)
return false;
*v = v_cur;
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r9d, %r13d
movl %edi, %ebp
andl $-0x2, %ebp
cmpl $0x8, %ebp
sete %r12b
cmpq %rdx, %rcx
setg %r9b
movss %xmm1, 0xc(%rsp)
ucomiss 0x9fbc(%rip), %xmm1 # 0x7e010
setp %r14b
setne %r10b
cmpq %rdx, %rcx
jl 0x743b7
movq %rdx, %r15
movaps %xmm0, %xmm2
movl %edi, 0x54(%rsp)
movq %r8, 0x48(%rsp)
leaq 0x30625(%rip), %rax # 0xa46a0
movq (%rax), %rbx
movq %rcx, %rax
subq %rdx, %rax
setle %r8b
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm2
setp %dl
setne %dil
orb %dl, %dil
orb %r8b, %dil
jne 0x740ad
xorps %xmm2, %xmm2
cvtsi2ss %rax, %xmm2
mulss 0x2f64(%rbx), %xmm2
andl $0x1, %r13d
cmpl $0x1, 0x1b00(%rbx)
movq %rsi, 0x10(%rsp)
movq %rcx, 0x28(%rsp)
movaps %xmm2, 0x30(%rsp)
movb %r14b, 0x20(%rsp)
jne 0x74166
xorl %edi, %edi
movq %r15, 0x18(%rsp)
movl %ebp, %r15d
movq %rcx, %rbp
movl %r13d, 0x8(%rsp)
movq %rbx, %r13
movl %r9d, %ebx
movl %r10d, %r14d
callq 0x3633f
movaps 0x30(%rsp), %xmm2
movl %r14d, %r10d
movb 0x20(%rsp), %r14b
movl %ebx, %r9d
movq %r13, %rbx
movl 0x8(%rsp), %r13d
movq %rbp, %rcx
movl %r15d, %ebp
movq 0x18(%rsp), %r15
movq 0x10(%rsp), %rsi
testb %al, %al
je 0x74166
movss 0x494(%rbx), %xmm0
ucomiss 0x9ee3(%rip), %xmm0 # 0x7e010
jbe 0x74166
movl %r13d, %eax
movss 0x3c0(%rbx,%rax,4), %xmm3
cmpb $0x0, 0x14a(%rbx)
je 0x7414c
mulss 0x17c64(%rip), %xmm3 # 0x8bdb0
cmpb $0x1, 0x149(%rbx)
jne 0x74244
mulss 0xad37(%rip), %xmm3 # 0x7ee98
jmp 0x74244
xorps %xmm3, %xmm3
cmpl $0x2, 0x1b00(%rbx)
jne 0x74244
movb %r12b, 0x8(%rsp)
movb %r10b, 0x18(%rsp)
movl %r9d, %r14d
xorl %r12d, %r12d
cmpl $0x8, %ebp
jne 0x7419d
movq 0x48(%rsp), %rdi
movl $0x3, %esi
callq 0x63cfa
movl %eax, %r12d
movss 0xacef(%rip), %xmm0 # 0x7ee94
movss 0xaceb(%rip), %xmm1 # 0x7ee98
movl $0x3, %edi
movl $0x5, %esi
callq 0x454dd
movlps %xmm0, 0x58(%rsp)
movl %r13d, %eax
movss 0x58(%rsp,%rax,4), %xmm3
testl %r12d, %r12d
js 0x741e6
cmpl $0x9, %r12d
jg 0x741f0
movl %r12d, %eax
leaq 0x17f21(%rip), %rcx # 0x8c100
movss (%rcx,%rax,4), %xmm0
jmp 0x74212
movss 0x17bc6(%rip), %xmm0 # 0x8bdb4
jmp 0x74212
negl %r12d
xorps %xmm1, %xmm1
cvtsi2ss %r12d, %xmm1
movss 0xac95(%rip), %xmm0 # 0x7ee98
movaps %xmm3, 0x60(%rsp)
callq 0x226c0
movaps 0x60(%rsp), %xmm3
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rcx
movl %r14d, %r9d
movb 0x18(%rsp), %r10b
movaps 0x30(%rsp), %xmm2
movb 0x8(%rsp), %r12b
movaps %xmm0, %xmm1
cmpless %xmm2, %xmm1
andps %xmm1, %xmm2
andnps %xmm0, %xmm1
orps %xmm1, %xmm2
movb 0x20(%rsp), %r14b
orb %r14b, %r10b
andb %r12b, %r9b
mulss %xmm2, %xmm3
movaps %xmm3, %xmm2
testl %r13d, %r13d
je 0x74260
movaps 0xa403(%rip), %xmm2 # 0x7e660
xorps %xmm3, %xmm2
andb %r10b, %r9b
movq %rcx, %r13
subq %r15, %r13
jle 0x74290
movq (%rsi), %rdx
cmpq %rcx, %rdx
jl 0x7427d
movb $0x1, %al
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm2
ja 0x74292
cmpq %r15, %rdx
setle %dl
xorps %xmm0, %xmm0
ucomiss %xmm2, %xmm0
seta %al
andb %dl, %al
jmp 0x74292
xorl %eax, %eax
movb 0x1ad4(%rbx), %dil
testb %r9b, %r9b
je 0x742c6
xorps %xmm0, %xmm0
ucomiss %xmm2, %xmm0
jbe 0x742b5
movss 0x2f60(%rbx), %xmm1
movb $0x1, %dl
ucomiss %xmm0, %xmm1
ja 0x742c8
ucomiss %xmm0, %xmm2
jbe 0x742c6
ucomiss 0x2f60(%rbx), %xmm0
seta %dl
jmp 0x742c8
xorl %edx, %edx
orb %al, %dil
testb $0x1, %dil
jne 0x742f7
testb %dl, %dl
jne 0x742f7
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm3
jne 0x742df
jnp 0x74309
movss 0x2f60(%rbx), %xmm0
addss %xmm2, %xmm0
movss %xmm0, 0x2f60(%rbx)
movb $0x1, %al
jmp 0x74303
movl $0x0, 0x2f60(%rbx)
xorl %eax, %eax
movb %al, 0x2f5c(%rbx)
cmpb $0x1, 0x2f5c(%rbx)
jne 0x743b7
movq (%rsi), %rdx
movl %r9d, %r14d
testb %r9b, %r9b
movaps %xmm2, 0x30(%rsp)
je 0x743c8
subq %r15, %rdx
xorps %xmm0, %xmm0
cvtsi2sd %rdx, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r13, %xmm1
divsd %xmm1, %xmm0
xorps %xmm2, %xmm2
cvtss2sd 0xc(%rsp), %xmm2
movsd 0xa2b6(%rip), %xmm1 # 0x7e608
divsd %xmm2, %xmm1
callq 0x22300
xorps %xmm1, %xmm1
cvtsi2ss %r13, %xmm1
movss 0x2f60(%rbx), %xmm2
divss %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtss2sd %xmm2, %xmm1
movsd %xmm0, 0x20(%rsp)
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss 0x9c81(%rip), %xmm1 # 0x7e010
minss %xmm0, %xmm1
xorps %xmm2, %xmm2
cmpltss %xmm2, %xmm0
andnps %xmm1, %xmm0
movss 0xc(%rsp), %xmm1
callq 0x226c0
cvttss2si %xmm0, %rdx
imulq %r13, %rdx
addq %r15, %rdx
jmp 0x743dd
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cvttss2si 0x2f60(%rbx), %rax
addq %rax, %rdx
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x78520
movq %rax, %r12
movb $0x0, 0x2f5c(%rbx)
testb %r14b, %r14b
je 0x7443c
subq %r15, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r13, %xmm1
divsd %xmm1, %xmm0
xorps %xmm2, %xmm2
cvtss2sd 0xc(%rsp), %xmm2
movsd 0xa1e6(%rip), %xmm1 # 0x7e608
divsd %xmm2, %xmm1
callq 0x22300
subsd 0x20(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x10(%rsp), %r14
jmp 0x7444c
movq 0x10(%rsp), %r14
subq (%r14), %rax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
movq 0x28(%rsp), %rcx
movaps 0x30(%rsp), %xmm2
movss 0x2f60(%rbx), %xmm1
subss %xmm0, %xmm1
movss %xmm1, 0x2f60(%rbx)
movq (%r14), %rax
cmpq %r15, %rcx
jle 0x744ab
cmpq %r12, %rax
je 0x744ab
cmpq %r15, %r12
jl 0x7448e
cmpl $0x8, %ebp
je 0x74491
cmpq %rax, %r12
jle 0x74491
xorps %xmm0, %xmm0
ucomiss %xmm2, %xmm0
jbe 0x74491
movq %r15, %r12
cmpq %rcx, %r12
jg 0x744a8
cmpl $0x8, %ebp
je 0x744ab
cmpq %rax, %r12
jge 0x744ab
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm2
jbe 0x744ab
movq %rcx, %r12
cmpq %r12, %rax
setne %al
je 0x743b9
movq %r12, (%r14)
movb $0x1, %al
jmp 0x743b9
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
bool ImGui::SliderBehaviorT<int, int, float>(ImRect const&, unsigned int, int, int*, int, int, char const*, float, int, ImRect*)
|
bool ImGui::SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, TYPE* v, const TYPE v_min, const TYPE v_max, const char* format, float power, ImGuiSliderFlags flags, ImRect* out_grab_bb)
{
ImGuiContext& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiAxis axis = (flags & ImGuiSliderFlags_Vertical) ? ImGuiAxis_Y : ImGuiAxis_X;
const bool is_decimal = (data_type == ImGuiDataType_Float) || (data_type == ImGuiDataType_Double);
const bool is_power = (power != 1.0f) && is_decimal;
const float grab_padding = 2.0f;
const float slider_sz = (bb.Max[axis] - bb.Min[axis]) - grab_padding * 2.0f;
float grab_sz = style.GrabMinSize;
SIGNEDTYPE v_range = (v_min < v_max ? v_max - v_min : v_min - v_max);
if (!is_decimal && v_range >= 0) // v_range < 0 may happen on integer overflows
grab_sz = ImMax((float)(slider_sz / (v_range + 1)), style.GrabMinSize); // For integer sliders: if possible have the grab size represent 1 unit
grab_sz = ImMin(grab_sz, slider_sz);
const float slider_usable_sz = slider_sz - grab_sz;
const float slider_usable_pos_min = bb.Min[axis] + grab_padding + grab_sz * 0.5f;
const float slider_usable_pos_max = bb.Max[axis] - grab_padding - grab_sz * 0.5f;
// For power curve sliders that cross over sign boundary we want the curve to be symmetric around 0.0f
float linear_zero_pos; // 0.0->1.0f
if (is_power && v_min * v_max < 0.0f)
{
// Different sign
const FLOATTYPE linear_dist_min_to_0 = ImPow(v_min >= 0 ? (FLOATTYPE)v_min : -(FLOATTYPE)v_min, (FLOATTYPE)1.0f / power);
const FLOATTYPE linear_dist_max_to_0 = ImPow(v_max >= 0 ? (FLOATTYPE)v_max : -(FLOATTYPE)v_max, (FLOATTYPE)1.0f / power);
linear_zero_pos = (float)(linear_dist_min_to_0 / (linear_dist_min_to_0 + linear_dist_max_to_0));
}
else
{
// Same sign
linear_zero_pos = v_min < 0.0f ? 1.0f : 0.0f;
}
// Process interacting with the slider
bool value_changed = false;
if (g.ActiveId == id)
{
bool set_new_value = false;
float clicked_t = 0.0f;
if (g.ActiveIdSource == ImGuiInputSource_Mouse)
{
if (!g.IO.MouseDown[0])
{
ClearActiveID();
}
else
{
const float mouse_abs_pos = g.IO.MousePos[axis];
clicked_t = (slider_usable_sz > 0.0f) ? ImClamp((mouse_abs_pos - slider_usable_pos_min) / slider_usable_sz, 0.0f, 1.0f) : 0.0f;
if (axis == ImGuiAxis_Y)
clicked_t = 1.0f - clicked_t;
set_new_value = true;
}
}
else if (g.ActiveIdSource == ImGuiInputSource_Nav)
{
const ImVec2 delta2 = GetNavInputAmount2d(ImGuiNavDirSourceFlags_Keyboard | ImGuiNavDirSourceFlags_PadDPad, ImGuiInputReadMode_RepeatFast, 0.0f, 0.0f);
float delta = (axis == ImGuiAxis_X) ? delta2.x : -delta2.y;
if (g.NavActivatePressedId == id && !g.ActiveIdIsJustActivated)
{
ClearActiveID();
}
else if (delta != 0.0f)
{
clicked_t = SliderCalcRatioFromValueT<TYPE,FLOATTYPE>(data_type, *v, v_min, v_max, power, linear_zero_pos);
const int decimal_precision = is_decimal ? ImParseFormatPrecision(format, 3) : 0;
if ((decimal_precision > 0) || is_power)
{
delta /= 100.0f; // Gamepad/keyboard tweak speeds in % of slider bounds
if (IsNavInputDown(ImGuiNavInput_TweakSlow))
delta /= 10.0f;
}
else
{
if ((v_range >= -100.0f && v_range <= 100.0f) || IsNavInputDown(ImGuiNavInput_TweakSlow))
delta = ((delta < 0.0f) ? -1.0f : +1.0f) / (float)v_range; // Gamepad/keyboard tweak speeds in integer steps
else
delta /= 100.0f;
}
if (IsNavInputDown(ImGuiNavInput_TweakFast))
delta *= 10.0f;
set_new_value = true;
if ((clicked_t >= 1.0f && delta > 0.0f) || (clicked_t <= 0.0f && delta < 0.0f)) // This is to avoid applying the saturation when already past the limits
set_new_value = false;
else
clicked_t = ImSaturate(clicked_t + delta);
}
}
if (set_new_value)
{
TYPE v_new;
if (is_power)
{
// Account for power curve scale on both sides of the zero
if (clicked_t < linear_zero_pos)
{
// Negative: rescale to the negative range before powering
float a = 1.0f - (clicked_t / linear_zero_pos);
a = ImPow(a, power);
v_new = ImLerp(ImMin(v_max, (TYPE)0), v_min, a);
}
else
{
// Positive: rescale to the positive range before powering
float a;
if (ImFabs(linear_zero_pos - 1.0f) > 1.e-6f)
a = (clicked_t - linear_zero_pos) / (1.0f - linear_zero_pos);
else
a = clicked_t;
a = ImPow(a, power);
v_new = ImLerp(ImMax(v_min, (TYPE)0), v_max, a);
}
}
else
{
// Linear slider
if (is_decimal)
{
v_new = ImLerp(v_min, v_max, clicked_t);
}
else
{
// For integer values we want the clicking position to match the grab box so we round above
// This code is carefully tuned to work with large values (e.g. high ranges of U64) while preserving this property..
FLOATTYPE v_new_off_f = (v_max - v_min) * clicked_t;
TYPE v_new_off_floor = (TYPE)(v_new_off_f);
TYPE v_new_off_round = (TYPE)(v_new_off_f + (FLOATTYPE)0.5);
if (v_new_off_floor < v_new_off_round)
v_new = v_min + v_new_off_round;
else
v_new = v_min + v_new_off_floor;
}
}
// Round to user desired precision based on format string
v_new = RoundScalarWithFormatT<TYPE,SIGNEDTYPE>(format, data_type, v_new);
// Apply result
if (*v != v_new)
{
*v = v_new;
value_changed = true;
}
}
}
if (slider_sz < 1.0f)
{
*out_grab_bb = ImRect(bb.Min, bb.Min);
}
else
{
// Output grab position so it can be displayed by the caller
float grab_t = SliderCalcRatioFromValueT<TYPE, FLOATTYPE>(data_type, *v, v_min, v_max, power, linear_zero_pos);
if (axis == ImGuiAxis_Y)
grab_t = 1.0f - grab_t;
const float grab_pos = ImLerp(slider_usable_pos_min, slider_usable_pos_max, grab_t);
if (axis == ImGuiAxis_X)
*out_grab_bb = ImRect(grab_pos - grab_sz * 0.5f, bb.Min.y + grab_padding, grab_pos + grab_sz * 0.5f, bb.Max.y - grab_padding);
else
*out_grab_bb = ImRect(bb.Min.x + grab_padding, grab_pos - grab_sz * 0.5f, bb.Max.x - grab_padding, grab_pos + grab_sz * 0.5f);
}
return value_changed;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, 0x58(%rsp)
movl %edx, %r15d
movl %esi, %r13d
movl 0xc8(%rsp), %r12d
andl $0x1, %r12d
movl %edx, 0x2c(%rsp)
andl $-0x2, %r15d
cmpl $0x8, %r15d
sete %al
movss %xmm0, 0x18(%rsp)
ucomiss 0x8c8a(%rip), %xmm0 # 0x7e010
setp %cl
setne %bl
orb %cl, %bl
andb %al, %bl
movl %r8d, %eax
movl %r9d, 0x14(%rsp)
subl %r9d, %eax
movl %eax, %ebp
negl %ebp
cmovsl %eax, %ebp
leaq 0x2f2f7(%rip), %rax # 0xa46a0
movq (%rax), %r14
movss (%rdi,%r12,4), %xmm4
movq %rdi, 0x20(%rsp)
movss 0x8(%rdi,%r12,4), %xmm3
movaps %xmm3, %xmm5
subss %xmm4, %xmm5
addss 0x169f3(%rip), %xmm5 # 0x8bdc0
movss 0x15d8(%r14), %xmm2
cmpl $0x8, %r15d
je 0x75401
leal 0x1(%rbp), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movaps %xmm5, %xmm1
divss %xmm0, %xmm1
movaps %xmm2, %xmm0
cmpless %xmm1, %xmm0
andps %xmm0, %xmm1
andnps %xmm2, %xmm0
orps %xmm1, %xmm0
movaps %xmm0, %xmm2
minss %xmm5, %xmm2
addss 0x9a6b(%rip), %xmm4 # 0x7ee78
movss 0x9a43(%rip), %xmm6 # 0x7ee58
mulss %xmm2, %xmm6
movl 0x14(%rsp), %eax
imull %r8d, %eax
testl %eax, %eax
sets %al
andb %bl, %al
cmpb $0x1, %al
movaps %xmm2, 0x40(%rsp)
movl %r8d, 0x30(%rsp)
movss %xmm3, 0x4(%rsp)
movss %xmm5, 0x10(%rsp)
movss %xmm6, 0xc(%rsp)
jne 0x754db
xorps %xmm0, %xmm0
cvtsi2ss %r8d, %xmm0
testl %r8d, %r8d
movss %xmm4, 0x1c(%rsp)
jns 0x75466
xorps 0x91fa(%rip), %xmm0 # 0x7e660
movss 0x8ba2(%rip), %xmm1 # 0x7e010
divss 0x18(%rsp), %xmm1
movss %xmm1, 0x60(%rsp)
callq 0x226c0
movaps %xmm0, %xmm1
movl 0x14(%rsp), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
testl %eax, %eax
movss %xmm1, 0x8(%rsp)
jns 0x7549e
xorps 0x91c2(%rip), %xmm0 # 0x7e660
movss 0x60(%rsp), %xmm1
callq 0x226c0
movss 0x8(%rsp), %xmm1
addss %xmm1, %xmm0
divss %xmm0, %xmm1
movss 0x4(%rsp), %xmm3
movaps 0x40(%rsp), %xmm2
movl 0x30(%rsp), %r8d
movss 0x1c(%rsp), %xmm4
movss 0x10(%rsp), %xmm5
movss 0xc(%rsp), %xmm6
jmp 0x754ed
testl %r8d, %r8d
js 0x754e5
xorps %xmm1, %xmm1
jmp 0x754ed
movss 0x8b23(%rip), %xmm1 # 0x7e010
addss %xmm6, %xmm4
cmpl %r13d, 0x1ac8(%r14)
movss %xmm4, 0x1c(%rsp)
jne 0x75592
movl 0x1b00(%r14), %eax
cmpl $0x2, %eax
movss %xmm1, 0x8(%rsp)
je 0x7559f
xorps %xmm8, %xmm8
cmpl $0x1, %eax
jne 0x756bc
cmpb $0x0, 0x138(%r14)
je 0x75691
movaps %xmm5, %xmm0
subss %xmm2, %xmm0
ucomiss %xmm8, %xmm0
jbe 0x75570
movss 0x130(%r14,%r12,4), %xmm8
subss %xmm4, %xmm8
divss %xmm0, %xmm8
movss 0x8ab2(%rip), %xmm0 # 0x7e010
minss %xmm8, %xmm0
xorps %xmm7, %xmm7
cmpltss %xmm7, %xmm8
andnps %xmm0, %xmm8
testq %r12, %r12
je 0x75586
movss 0x8a93(%rip), %xmm0 # 0x7e010
subss %xmm8, %xmm0
movaps %xmm0, %xmm8
movq 0x20(%rsp), %r14
movb $0x1, %al
jmp 0x757cd
xorl %r13d, %r13d
movq 0x20(%rsp), %r14
jmp 0x75938
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movl $0x3, %edi
movl $0x5, %esi
callq 0x454dd
testq %r12, %r12
je 0x755c4
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
xorps 0x909c(%rip), %xmm0 # 0x7e660
cmpl %r13d, 0x1c10(%r14)
movl 0x30(%rsp), %r8d
movss 0x8(%rsp), %xmm1
jne 0x755e6
cmpb $0x0, 0x1ad4(%r14)
je 0x7570f
xorps %xmm8, %xmm8
ucomiss %xmm8, %xmm0
jne 0x755f6
jnp 0x75723
movaps %xmm0, 0x60(%rsp)
movq 0x58(%rsp), %rax
movl (%rax), %esi
movl 0x2c(%rsp), %edi
movl %r8d, %edx
movl 0x14(%rsp), %ecx
movss 0x18(%rsp), %xmm0
callq 0x78898
movaps %xmm0, %xmm8
cmpl $0x8, %r15d
movq 0x20(%rsp), %r14
jne 0x756c8
movq 0xc0(%rsp), %rdi
movl $0x3, %esi
movaps %xmm8, 0x70(%rsp)
callq 0x63cfa
movaps 0x70(%rsp), %xmm8
testl %eax, %eax
setle %al
movl %ebx, %ecx
notb %cl
testb %al, %cl
jne 0x756c8
movaps 0x60(%rsp), %xmm9
divss 0x89b3(%rip), %xmm9 # 0x7e018
leaq 0x2f034(%rip), %rdx # 0xa46a0
movq (%rdx), %rax
movss 0x384(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x75755
divss 0x980c(%rip), %xmm9 # 0x7ee98
jmp 0x75755
callq 0x35270
xorps %xmm8, %xmm8
movss 0x8(%rsp), %xmm1
movss 0xc(%rsp), %xmm6
movss 0x10(%rsp), %xmm5
movl 0x30(%rsp), %r8d
movaps 0x40(%rsp), %xmm2
movss 0x4(%rsp), %xmm3
xorl %eax, %eax
movq 0x20(%rsp), %r14
jmp 0x757cd
cmpl $0x65, %ebp
leaq 0x2efce(%rip), %rdx # 0xa46a0
jb 0x756e7
movq (%rdx), %rax
movss 0x384(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x75746
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
xorps %xmm1, %xmm1
xorl %eax, %eax
ucomiss 0x60(%rsp), %xmm1
seta %al
leaq 0x9f96(%rip), %rcx # 0x7f698
movss (%rcx,%rax,4), %xmm9
divss %xmm0, %xmm9
jmp 0x75755
callq 0x35270
movss 0x8(%rsp), %xmm1
movl 0x30(%rsp), %r8d
xorps %xmm8, %xmm8
xorl %eax, %eax
movq 0x20(%rsp), %r14
movss 0x4(%rsp), %xmm3
movaps 0x40(%rsp), %xmm2
movss 0x10(%rsp), %xmm5
movss 0xc(%rsp), %xmm6
jmp 0x757cd
movaps 0x60(%rsp), %xmm9
divss 0x88c3(%rip), %xmm9 # 0x7e018
movss 0x4(%rsp), %xmm3
movl 0x30(%rsp), %r8d
movss 0x10(%rsp), %xmm5
movss 0xc(%rsp), %xmm6
movss 0x8(%rsp), %xmm1
movq (%rdx), %rax
movss 0x971b(%rip), %xmm2 # 0x7ee98
mulss %xmm9, %xmm2
xorps %xmm7, %xmm7
xorps %xmm0, %xmm0
cmpltss 0x388(%rax), %xmm0
andps %xmm0, %xmm2
andnps %xmm9, %xmm0
orps %xmm2, %xmm0
ucomiss 0x886d(%rip), %xmm8 # 0x7e010
jb 0x757b3
ucomiss %xmm7, %xmm0
jbe 0x757b3
xorl %eax, %eax
movaps 0x40(%rsp), %xmm2
jmp 0x757cd
ucomiss %xmm8, %xmm7
movaps 0x40(%rsp), %xmm2
jb 0x75a80
ucomiss %xmm0, %xmm7
jbe 0x75a80
xorl %eax, %eax
testb %al, %al
je 0x75813
testb %bl, %bl
je 0x7581b
ucomiss %xmm8, %xmm1
jbe 0x7584d
divss %xmm1, %xmm8
movss 0x8828(%rip), %xmm0 # 0x7e010
subss %xmm8, %xmm0
movss 0x18(%rsp), %xmm1
callq 0x226c0
movl 0x14(%rsp), %ecx
movl %ecx, %eax
sarl $0x1f, %eax
andl %ecx, %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movl 0x30(%rsp), %ecx
jmp 0x758b0
xorl %r13d, %r13d
jmp 0x75938
movl 0x14(%rsp), %eax
subl %r8d, %eax
cmpl $0x8, %r15d
jne 0x758c7
xorps %xmm0, %xmm0
cvtsi2ss %r8d, %xmm0
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
mulss %xmm8, %xmm1
addss %xmm0, %xmm1
cvttss2si %xmm1, %edx
jmp 0x758ee
movss 0x87b3(%rip), %xmm3 # 0x7e008
addss %xmm1, %xmm3
andps 0x8df0(%rip), %xmm3 # 0x7e650
movaps %xmm8, %xmm2
subss %xmm1, %xmm2
movss 0x87a0(%rip), %xmm0 # 0x7e010
subss %xmm1, %xmm0
divss %xmm0, %xmm2
movss 0x16544(%rip), %xmm0 # 0x8bdc4
cmpltss %xmm3, %xmm0
andps %xmm0, %xmm2
andnps %xmm8, %xmm0
orps %xmm2, %xmm0
movss 0x18(%rsp), %xmm1
callq 0x226c0
xorl %eax, %eax
movl 0x30(%rsp), %ecx
testl %ecx, %ecx
cmovgl %ecx, %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movl 0x14(%rsp), %ecx
subl %eax, %ecx
xorps %xmm2, %xmm2
cvtsi2ss %ecx, %xmm2
mulss %xmm0, %xmm2
addss %xmm1, %xmm2
cvttss2si %xmm2, %edx
jmp 0x758ee
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss %xmm0, %xmm8
cvttss2si %xmm8, %eax
addss 0x9577(%rip), %xmm8 # 0x7ee58
cvttss2si %xmm8, %edx
cmpl %edx, %eax
cmovgl %eax, %edx
addl %r8d, %edx
movq 0xc0(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x783c9
movq 0x58(%rsp), %rcx
cmpl %eax, (%rcx)
setne %r13b
movss 0x4(%rsp), %xmm3
movaps 0x40(%rsp), %xmm2
movl 0x30(%rsp), %r8d
movss 0x10(%rsp), %xmm5
movss 0xc(%rsp), %xmm6
movss 0x8(%rsp), %xmm1
je 0x75938
movq 0x58(%rsp), %rcx
movl %eax, (%rcx)
movb $0x1, %r13b
movq 0xd0(%rsp), %rbx
movss 0x86c8(%rip), %xmm0 # 0x7e010
ucomiss %xmm5, %xmm0
jbe 0x7595c
movq (%r14), %rax
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x75a6b
addss 0x8c90(%rip), %xmm3 # 0x7e5f4
movaps 0x8cf5(%rip), %xmm0 # 0x7e660
xorps %xmm2, %xmm0
movaps %xmm0, 0x30(%rsp)
subss %xmm6, %xmm3
movss %xmm3, 0x4(%rsp)
movq 0x58(%rsp), %rax
movl (%rax), %esi
movl 0x2c(%rsp), %edi
movl %r8d, %edx
movl 0x14(%rsp), %ecx
movss 0x18(%rsp), %xmm0
callq 0x78898
testq %r12, %r12
je 0x759ae
movss 0x8669(%rip), %xmm1 # 0x7e010
subss %xmm0, %xmm1
movaps %xmm1, %xmm0
movss 0x1c(%rsp), %xmm1
movss 0x4(%rsp), %xmm3
subss %xmm1, %xmm3
mulss %xmm0, %xmm3
addss %xmm1, %xmm3
je 0x75a1a
movss (%r14), %xmm0
addss 0x94a3(%rip), %xmm0 # 0x7ee78
movss 0x8(%r14), %xmm1
movss 0x9475(%rip), %xmm2 # 0x7ee58
movaps 0x30(%rsp), %xmm5
mulss %xmm2, %xmm5
addss %xmm3, %xmm5
addss 0x8bfc(%rip), %xmm1 # 0x7e5f4
movaps 0x40(%rsp), %xmm4
mulss %xmm2, %xmm4
addss %xmm3, %xmm4
movss %xmm0, (%rbx)
movss %xmm5, 0x4(%rbx)
movss %xmm1, 0x8(%rbx)
movss %xmm4, 0xc(%rbx)
jmp 0x75a6b
movss 0x9436(%rip), %xmm0 # 0x7ee58
movaps 0x30(%rsp), %xmm5
mulss %xmm0, %xmm5
addss %xmm3, %xmm5
movss 0x4(%r14), %xmm1
movss 0xc(%r14), %xmm2
addss 0x9435(%rip), %xmm1 # 0x7ee78
movaps 0x40(%rsp), %xmm4
mulss %xmm0, %xmm4
addss %xmm3, %xmm4
addss 0x8b9c(%rip), %xmm2 # 0x7e5f4
movss %xmm5, (%rbx)
movss %xmm1, 0x4(%rbx)
movss %xmm4, 0x8(%rbx)
movss %xmm2, 0xc(%rbx)
movl %r13d, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addss %xmm0, %xmm8
movss 0x8583(%rip), %xmm0 # 0x7e010
minss %xmm8, %xmm0
cmpltss %xmm7, %xmm8
andnps %xmm0, %xmm8
jmp 0x7558b
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
bool ImGui::SliderBehaviorT<double, double, double>(ImRect const&, unsigned int, int, double*, double, double, char const*, float, int, ImRect*)
|
bool ImGui::SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, TYPE* v, const TYPE v_min, const TYPE v_max, const char* format, float power, ImGuiSliderFlags flags, ImRect* out_grab_bb)
{
ImGuiContext& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiAxis axis = (flags & ImGuiSliderFlags_Vertical) ? ImGuiAxis_Y : ImGuiAxis_X;
const bool is_decimal = (data_type == ImGuiDataType_Float) || (data_type == ImGuiDataType_Double);
const bool is_power = (power != 1.0f) && is_decimal;
const float grab_padding = 2.0f;
const float slider_sz = (bb.Max[axis] - bb.Min[axis]) - grab_padding * 2.0f;
float grab_sz = style.GrabMinSize;
SIGNEDTYPE v_range = (v_min < v_max ? v_max - v_min : v_min - v_max);
if (!is_decimal && v_range >= 0) // v_range < 0 may happen on integer overflows
grab_sz = ImMax((float)(slider_sz / (v_range + 1)), style.GrabMinSize); // For integer sliders: if possible have the grab size represent 1 unit
grab_sz = ImMin(grab_sz, slider_sz);
const float slider_usable_sz = slider_sz - grab_sz;
const float slider_usable_pos_min = bb.Min[axis] + grab_padding + grab_sz * 0.5f;
const float slider_usable_pos_max = bb.Max[axis] - grab_padding - grab_sz * 0.5f;
// For power curve sliders that cross over sign boundary we want the curve to be symmetric around 0.0f
float linear_zero_pos; // 0.0->1.0f
if (is_power && v_min * v_max < 0.0f)
{
// Different sign
const FLOATTYPE linear_dist_min_to_0 = ImPow(v_min >= 0 ? (FLOATTYPE)v_min : -(FLOATTYPE)v_min, (FLOATTYPE)1.0f / power);
const FLOATTYPE linear_dist_max_to_0 = ImPow(v_max >= 0 ? (FLOATTYPE)v_max : -(FLOATTYPE)v_max, (FLOATTYPE)1.0f / power);
linear_zero_pos = (float)(linear_dist_min_to_0 / (linear_dist_min_to_0 + linear_dist_max_to_0));
}
else
{
// Same sign
linear_zero_pos = v_min < 0.0f ? 1.0f : 0.0f;
}
// Process interacting with the slider
bool value_changed = false;
if (g.ActiveId == id)
{
bool set_new_value = false;
float clicked_t = 0.0f;
if (g.ActiveIdSource == ImGuiInputSource_Mouse)
{
if (!g.IO.MouseDown[0])
{
ClearActiveID();
}
else
{
const float mouse_abs_pos = g.IO.MousePos[axis];
clicked_t = (slider_usable_sz > 0.0f) ? ImClamp((mouse_abs_pos - slider_usable_pos_min) / slider_usable_sz, 0.0f, 1.0f) : 0.0f;
if (axis == ImGuiAxis_Y)
clicked_t = 1.0f - clicked_t;
set_new_value = true;
}
}
else if (g.ActiveIdSource == ImGuiInputSource_Nav)
{
const ImVec2 delta2 = GetNavInputAmount2d(ImGuiNavDirSourceFlags_Keyboard | ImGuiNavDirSourceFlags_PadDPad, ImGuiInputReadMode_RepeatFast, 0.0f, 0.0f);
float delta = (axis == ImGuiAxis_X) ? delta2.x : -delta2.y;
if (g.NavActivatePressedId == id && !g.ActiveIdIsJustActivated)
{
ClearActiveID();
}
else if (delta != 0.0f)
{
clicked_t = SliderCalcRatioFromValueT<TYPE,FLOATTYPE>(data_type, *v, v_min, v_max, power, linear_zero_pos);
const int decimal_precision = is_decimal ? ImParseFormatPrecision(format, 3) : 0;
if ((decimal_precision > 0) || is_power)
{
delta /= 100.0f; // Gamepad/keyboard tweak speeds in % of slider bounds
if (IsNavInputDown(ImGuiNavInput_TweakSlow))
delta /= 10.0f;
}
else
{
if ((v_range >= -100.0f && v_range <= 100.0f) || IsNavInputDown(ImGuiNavInput_TweakSlow))
delta = ((delta < 0.0f) ? -1.0f : +1.0f) / (float)v_range; // Gamepad/keyboard tweak speeds in integer steps
else
delta /= 100.0f;
}
if (IsNavInputDown(ImGuiNavInput_TweakFast))
delta *= 10.0f;
set_new_value = true;
if ((clicked_t >= 1.0f && delta > 0.0f) || (clicked_t <= 0.0f && delta < 0.0f)) // This is to avoid applying the saturation when already past the limits
set_new_value = false;
else
clicked_t = ImSaturate(clicked_t + delta);
}
}
if (set_new_value)
{
TYPE v_new;
if (is_power)
{
// Account for power curve scale on both sides of the zero
if (clicked_t < linear_zero_pos)
{
// Negative: rescale to the negative range before powering
float a = 1.0f - (clicked_t / linear_zero_pos);
a = ImPow(a, power);
v_new = ImLerp(ImMin(v_max, (TYPE)0), v_min, a);
}
else
{
// Positive: rescale to the positive range before powering
float a;
if (ImFabs(linear_zero_pos - 1.0f) > 1.e-6f)
a = (clicked_t - linear_zero_pos) / (1.0f - linear_zero_pos);
else
a = clicked_t;
a = ImPow(a, power);
v_new = ImLerp(ImMax(v_min, (TYPE)0), v_max, a);
}
}
else
{
// Linear slider
if (is_decimal)
{
v_new = ImLerp(v_min, v_max, clicked_t);
}
else
{
// For integer values we want the clicking position to match the grab box so we round above
// This code is carefully tuned to work with large values (e.g. high ranges of U64) while preserving this property..
FLOATTYPE v_new_off_f = (v_max - v_min) * clicked_t;
TYPE v_new_off_floor = (TYPE)(v_new_off_f);
TYPE v_new_off_round = (TYPE)(v_new_off_f + (FLOATTYPE)0.5);
if (v_new_off_floor < v_new_off_round)
v_new = v_min + v_new_off_round;
else
v_new = v_min + v_new_off_floor;
}
}
// Round to user desired precision based on format string
v_new = RoundScalarWithFormatT<TYPE,SIGNEDTYPE>(format, data_type, v_new);
// Apply result
if (*v != v_new)
{
*v = v_new;
value_changed = true;
}
}
}
if (slider_sz < 1.0f)
{
*out_grab_bb = ImRect(bb.Min, bb.Min);
}
else
{
// Output grab position so it can be displayed by the caller
float grab_t = SliderCalcRatioFromValueT<TYPE, FLOATTYPE>(data_type, *v, v_min, v_max, power, linear_zero_pos);
if (axis == ImGuiAxis_Y)
grab_t = 1.0f - grab_t;
const float grab_pos = ImLerp(slider_usable_pos_min, slider_usable_pos_max, grab_t);
if (axis == ImGuiAxis_X)
*out_grab_bb = ImRect(grab_pos - grab_sz * 0.5f, bb.Min.y + grab_padding, grab_pos + grab_sz * 0.5f, bb.Max.y - grab_padding);
else
*out_grab_bb = ImRect(bb.Min.x + grab_padding, grab_pos - grab_sz * 0.5f, bb.Max.x - grab_padding, grab_pos + grab_sz * 0.5f);
}
return value_changed;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %r9d, %r14d
movq %r8, 0x88(%rsp)
movapd %xmm1, %xmm5
movapd %xmm0, %xmm6
movq %rcx, 0x68(%rsp)
movl %edx, %ebp
movl %esi, %r13d
andl $0x1, %r14d
movl %edx, 0x1c(%rsp)
andl $-0x2, %ebp
cmpl $0x8, %ebp
sete %al
movss %xmm2, 0x14(%rsp)
ucomiss 0x66e9(%rip), %xmm2 # 0x7e010
setp %cl
setne %r12b
orb %cl, %r12b
andb %al, %r12b
leaq 0x2cd65(%rip), %rax # 0xa46a0
movq (%rax), %r15
movss (%rdi,%r14,4), %xmm9
movq %rdi, %rbx
movss 0x8(%rdi,%r14,4), %xmm3
movaps %xmm3, %xmm7
subss %xmm9, %xmm7
addss 0x14462(%rip), %xmm7 # 0x8bdc0
movss 0x15d8(%r15), %xmm2
movapd %xmm1, %xmm4
subsd %xmm0, %xmm4
subsd %xmm1, %xmm0
movapd %xmm6, %xmm8
cmpltsd %xmm1, %xmm8
movapd %xmm8, %xmm1
movapd %xmm4, 0x90(%rsp)
andpd %xmm4, %xmm1
andnpd %xmm0, %xmm8
orpd %xmm1, %xmm8
cmpl $0x8, %ebp
movapd %xmm8, 0xb0(%rsp)
je 0x779e4
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm8
jb 0x779e4
xorps %xmm0, %xmm0
cvtss2sd %xmm7, %xmm0
movsd 0x6c45(%rip), %xmm1 # 0x7e608
addsd %xmm8, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movaps %xmm2, %xmm1
cmpless %xmm0, %xmm1
andps %xmm1, %xmm0
andnps %xmm2, %xmm1
orps %xmm0, %xmm1
movaps %xmm1, %xmm2
minss %xmm7, %xmm2
movaps %xmm2, 0x50(%rsp)
addss 0x7482(%rip), %xmm9 # 0x7ee78
movss 0x7459(%rip), %xmm8 # 0x7ee58
movapd %xmm6, %xmm1
mulsd %xmm5, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
setbe %al
mulss %xmm2, %xmm8
movl %r12d, %ecx
xorb $0x1, %cl
orb %al, %cl
movss %xmm3, (%rsp)
movapd %xmm5, 0x30(%rsp)
movapd %xmm6, 0x40(%rsp)
movss %xmm7, 0x20(%rsp)
movss %xmm8, 0x4(%rsp)
jne 0x77afb
movapd %xmm6, %xmm1
xorpd 0x6c32(%rip), %xmm1 # 0x7e680
movapd %xmm1, %xmm0
cmplesd %xmm6, %xmm0
movapd %xmm0, %xmm2
andnpd %xmm1, %xmm2
andpd %xmm6, %xmm0
orpd %xmm2, %xmm0
xorps %xmm2, %xmm2
cvtss2sd 0x14(%rsp), %xmm2
movsd 0x6b90(%rip), %xmm1 # 0x7e608
divsd %xmm2, %xmm1
movsd %xmm1, 0x70(%rsp)
movss %xmm9, 0x18(%rsp)
callq 0x22300
movsd %xmm0, 0x8(%rsp)
movapd 0x6be4(%rip), %xmm1 # 0x7e680
movapd 0x30(%rsp), %xmm3
xorpd %xmm3, %xmm1
movapd %xmm1, %xmm0
movapd %xmm1, %xmm2
cmplesd %xmm3, %xmm0
movapd %xmm0, %xmm1
andnpd %xmm2, %xmm1
andpd %xmm3, %xmm0
orpd %xmm1, %xmm0
movsd 0x70(%rsp), %xmm1
callq 0x22300
movss 0x4(%rsp), %xmm8
movapd 0x40(%rsp), %xmm6
movss 0x18(%rsp), %xmm9
movss (%rsp), %xmm3
movsd 0x8(%rsp), %xmm1
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm4
jmp 0x77b0f
ucomisd %xmm6, %xmm0
ja 0x77b07
xorpd %xmm4, %xmm4
jmp 0x77b0f
movss 0x6501(%rip), %xmm4 # 0x7e010
addss %xmm8, %xmm9
cmpl %r13d, 0x1ac8(%r15)
movss %xmm9, 0x18(%rsp)
jne 0x77bcb
movl 0x1b00(%r15), %eax
cmpl $0x2, %eax
movaps 0x50(%rsp), %xmm5
movss %xmm4, 0x8(%rsp)
je 0x77beb
xorps %xmm10, %xmm10
cmpl $0x1, %eax
movaps 0x30(%rsp), %xmm2
movss 0x20(%rsp), %xmm7
jne 0x77cf2
cmpb $0x0, 0x138(%r15)
movq 0x68(%rsp), %rcx
movq %rbx, %r13
je 0x77d01
movaps %xmm7, %xmm0
subss %xmm5, %xmm0
ucomiss %xmm10, %xmm0
jbe 0x77bac
movss 0x130(%r15,%r14,4), %xmm10
subss %xmm9, %xmm10
divss %xmm0, %xmm10
movss 0x6476(%rip), %xmm0 # 0x7e010
minss %xmm10, %xmm0
xorps %xmm1, %xmm1
cmpltss %xmm1, %xmm10
andnps %xmm0, %xmm10
testq %r14, %r14
je 0x77e99
movss 0x6453(%rip), %xmm0 # 0x7e010
subss %xmm10, %xmm0
movaps %xmm0, %xmm10
jmp 0x77e99
xorl %r12d, %r12d
movaps 0x50(%rsp), %xmm5
movaps 0x30(%rsp), %xmm2
movq 0x68(%rsp), %rcx
movq %rbx, %r13
movss 0x20(%rsp), %xmm7
jmp 0x7801a
xorpd %xmm0, %xmm0
xorps %xmm1, %xmm1
movl $0x3, %edi
movl $0x5, %esi
callq 0x454dd
testq %r14, %r14
je 0x77c11
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
xorps 0x6a4f(%rip), %xmm0 # 0x7e660
cmpl %r13d, 0x1c10(%r15)
movaps 0x30(%rsp), %xmm2
movaps 0x40(%rsp), %xmm6
movss 0x20(%rsp), %xmm7
movss 0x8(%rsp), %xmm4
jne 0x77c3e
cmpb $0x0, 0x1ad4(%r15)
je 0x77db4
xorps %xmm10, %xmm10
ucomiss %xmm10, %xmm0
movq 0x68(%rsp), %rcx
movq %rbx, %r13
jne 0x77c56
jnp 0x77da6
movaps %xmm0, 0x70(%rsp)
movq %rcx, %rbx
movsd (%rcx), %xmm0
movl 0x1c(%rsp), %edi
movaps %xmm6, %xmm1
movss 0x14(%rsp), %xmm3
callq 0x78d07
movaps %xmm0, %xmm10
cmpl $0x8, %ebp
jne 0x77d3f
movq 0x88(%rsp), %rdi
movl $0x3, %esi
movaps %xmm10, 0xa0(%rsp)
callq 0x63cfa
movaps 0xa0(%rsp), %xmm10
testl %eax, %eax
setle %al
movl %r12d, %ecx
notb %cl
testb %al, %cl
jne 0x77d3f
movaps 0x70(%rsp), %xmm11
divss 0x6352(%rip), %xmm11 # 0x7e018
leaq 0x2c9d3(%rip), %rdx # 0xa46a0
movq (%rdx), %rax
movss 0x384(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x77e02
divss 0x71ab(%rip), %xmm11 # 0x7ee98
jmp 0x77e02
xorl %eax, %eax
movq 0x68(%rsp), %rcx
movq %rbx, %r13
jmp 0x77e9b
movq %rcx, %rbx
callq 0x35270
xorps %xmm10, %xmm10
movq %rbx, %rcx
movss 0x8(%rsp), %xmm4
movss 0x4(%rsp), %xmm8
movss 0x20(%rsp), %xmm7
movapd 0x40(%rsp), %xmm6
movaps 0x30(%rsp), %xmm2
movaps 0x50(%rsp), %xmm5
movss (%rsp), %xmm3
xorl %eax, %eax
jmp 0x77e9b
movapd 0x14149(%rip), %xmm0 # 0x8be90
movapd 0xb0(%rsp), %xmm2
andpd %xmm2, %xmm0
movsd 0x143f4(%rip), %xmm1 # 0x8c150
ucomisd %xmm0, %xmm1
leaq 0x2c939(%rip), %rdx # 0xa46a0
jae 0x77d7d
movq (%rdx), %rax
movss 0x384(%rax), %xmm0
xorpd %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x77df3
xorpd %xmm0, %xmm0
xorl %eax, %eax
ucomiss 0x70(%rsp), %xmm0
seta %al
leaq 0x7906(%rip), %rcx # 0x7f698
movss (%rcx,%rax,4), %xmm11
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
divss %xmm0, %xmm11
jmp 0x77e02
xorl %eax, %eax
movss (%rsp), %xmm3
movaps 0x50(%rsp), %xmm5
jmp 0x77de7
callq 0x35270
movss 0x8(%rsp), %xmm4
movss 0x20(%rsp), %xmm7
movaps 0x40(%rsp), %xmm6
movaps 0x30(%rsp), %xmm2
xorps %xmm10, %xmm10
xorl %eax, %eax
movss (%rsp), %xmm3
movaps 0x50(%rsp), %xmm5
movq 0x68(%rsp), %rcx
movq %rbx, %r13
movss 0x4(%rsp), %xmm8
jmp 0x77e9b
movaps 0x70(%rsp), %xmm11
divss 0x6216(%rip), %xmm11 # 0x7e018
movss (%rsp), %xmm3
movaps 0x30(%rsp), %xmm2
movapd 0x40(%rsp), %xmm6
movss 0x20(%rsp), %xmm7
movss 0x4(%rsp), %xmm8
movss 0x8(%rsp), %xmm4
movq %rbx, %rcx
movq (%rdx), %rax
movss 0x7065(%rip), %xmm5 # 0x7ee98
mulss %xmm11, %xmm5
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
cmpltss 0x388(%rax), %xmm0
andps %xmm0, %xmm5
andnps %xmm11, %xmm0
orps %xmm5, %xmm0
ucomiss 0x61b7(%rip), %xmm10 # 0x7e010
jb 0x77e69
ucomiss %xmm1, %xmm0
jbe 0x77e69
xorl %eax, %eax
movaps 0x50(%rsp), %xmm5
jmp 0x77e9b
ucomiss %xmm10, %xmm1
movaps 0x50(%rsp), %xmm5
jb 0x77e7d
ucomiss %xmm0, %xmm1
ja 0x77d38
addss %xmm0, %xmm10
movss 0x6186(%rip), %xmm0 # 0x7e010
minss %xmm10, %xmm0
cmpltss %xmm1, %xmm10
andnps %xmm0, %xmm10
movb $0x1, %al
testb %al, %al
je 0x77ef3
movq %rcx, %rbx
testb %r12b, %r12b
je 0x77efb
ucomiss %xmm10, %xmm4
jbe 0x77f22
divss %xmm4, %xmm10
movss 0x6156(%rip), %xmm0 # 0x7e010
subss %xmm10, %xmm0
movss 0x14(%rsp), %xmm1
callq 0x226c0
xorpd %xmm1, %xmm1
movapd 0x30(%rsp), %xmm2
minsd %xmm1, %xmm2
movapd 0x40(%rsp), %xmm1
subsd %xmm2, %xmm1
cvtss2sd %xmm0, %xmm0
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
jmp 0x77fbb
xorl %r12d, %r12d
jmp 0x7801a
xorps %xmm0, %xmm0
cvtss2sd %xmm10, %xmm0
cmpl $0x8, %ebp
jne 0x77f9a
movapd 0x90(%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x77fb7
movss 0x60de(%rip), %xmm1 # 0x7e008
addss %xmm4, %xmm1
andps 0x671b(%rip), %xmm1 # 0x7e650
movaps %xmm10, %xmm2
subss %xmm4, %xmm2
movss 0x60cb(%rip), %xmm0 # 0x7e010
subss %xmm4, %xmm0
divss %xmm0, %xmm2
movss 0x13e6f(%rip), %xmm0 # 0x8bdc4
cmpltss %xmm1, %xmm0
andps %xmm0, %xmm2
andnps %xmm10, %xmm0
orps %xmm2, %xmm0
movss 0x14(%rsp), %xmm1
callq 0x226c0
xorpd %xmm1, %xmm1
movapd 0x40(%rsp), %xmm2
cmplesd %xmm2, %xmm1
andpd %xmm2, %xmm1
movapd 0x30(%rsp), %xmm2
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
jmp 0x77fbb
movapd 0x90(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd 0x6691(%rip), %xmm0 # 0x7e640
addsd %xmm1, %xmm0
maxsd %xmm1, %xmm0
addsd %xmm6, %xmm0
movq 0x88(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x7879d
movq %rbx, %rcx
movsd (%rbx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x77fdb
jnp 0x77fe4
movsd %xmm0, (%rcx)
movb $0x1, %r12b
jmp 0x77ff2
cmpneqsd %xmm1, %xmm0
movq %xmm0, %r12
andl $0x1, %r12d
movss (%rsp), %xmm3
movaps 0x50(%rsp), %xmm5
movaps 0x30(%rsp), %xmm2
movapd 0x40(%rsp), %xmm6
movss 0x20(%rsp), %xmm7
movss 0x4(%rsp), %xmm8
movss 0x8(%rsp), %xmm4
movq 0x100(%rsp), %r15
movss 0x5fe6(%rip), %xmm0 # 0x7e010
ucomiss %xmm7, %xmm0
jbe 0x7803f
movq (%r13), %rax
movq %rax, (%r15)
movq %rax, 0x8(%r15)
jmp 0x78150
addss 0x65ad(%rip), %xmm3 # 0x7e5f4
movaps 0x6612(%rip), %xmm0 # 0x7e660
xorps %xmm5, %xmm0
movaps %xmm0, 0x20(%rsp)
subss %xmm8, %xmm3
movss %xmm3, (%rsp)
movsd (%rcx), %xmm0
movl 0x1c(%rsp), %edi
movapd %xmm6, %xmm1
movss 0x14(%rsp), %xmm3
callq 0x78d07
testq %r14, %r14
je 0x7808b
movss 0x5f8c(%rip), %xmm1 # 0x7e010
subss %xmm0, %xmm1
movaps %xmm1, %xmm0
movss 0x18(%rsp), %xmm1
movss (%rsp), %xmm3
subss %xmm1, %xmm3
mulss %xmm0, %xmm3
addss %xmm1, %xmm3
je 0x780fb
movss (%r13), %xmm0
addss 0x6dc6(%rip), %xmm0 # 0x7ee78
movss 0x8(%r13), %xmm1
movss 0x6d98(%rip), %xmm2 # 0x7ee58
movaps 0x20(%rsp), %xmm5
mulss %xmm2, %xmm5
addss %xmm3, %xmm5
addss 0x651f(%rip), %xmm1 # 0x7e5f4
movaps 0x50(%rsp), %xmm4
mulss %xmm2, %xmm4
addss %xmm3, %xmm4
movss %xmm0, (%r15)
movss %xmm5, 0x4(%r15)
movss %xmm1, 0x8(%r15)
movss %xmm4, 0xc(%r15)
jmp 0x78150
movss 0x6d55(%rip), %xmm0 # 0x7ee58
movaps 0x20(%rsp), %xmm5
mulss %xmm0, %xmm5
addss %xmm3, %xmm5
movss 0x4(%r13), %xmm1
movss 0xc(%r13), %xmm2
addss 0x6d54(%rip), %xmm1 # 0x7ee78
movaps 0x50(%rsp), %xmm4
mulss %xmm0, %xmm4
addss %xmm3, %xmm4
addss 0x64bb(%rip), %xmm2 # 0x7e5f4
movss %xmm5, (%r15)
movss %xmm1, 0x4(%r15)
movss %xmm4, 0x8(%r15)
movss %xmm2, 0xc(%r15)
movl %r12d, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
long long ImGui::RoundScalarWithFormatT<long long, long long>(char const*, int, long long)
|
TYPE ImGui::RoundScalarWithFormatT(const char* format, ImGuiDataType data_type, TYPE v)
{
const char* fmt_start = ImParseFormatFindStart(format);
if (fmt_start[0] != '%' || fmt_start[1] == '%') // Don't apply if the value is not visible in the format string
return v;
char v_str[64];
ImFormatString(v_str, IM_ARRAYSIZE(v_str), fmt_start, v);
const char* p = v_str;
while (*p == ' ')
p++;
if (data_type == ImGuiDataType_Float || data_type == ImGuiDataType_Double)
v = (TYPE)ImAtof(p);
else
ImAtoi(p, (SIGNEDTYPE*)&v);
return v;
}
|
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rax
movl %esi, %ebx
movq %rdi, %rdx
movq %rax, 0x8(%rsp)
movb (%rdx), %dil
testb %dil, %dil
je 0x7855f
cmpb $0x25, %dil
jne 0x7854b
movl $0x1, %esi
cmpb $0x25, 0x1(%rdx)
jne 0x78566
xorl %esi, %esi
cmpb $0x25, %dil
sete %sil
addq %rsi, %rdx
incq %rdx
xorl %esi, %esi
jmp 0x78569
movl $0x3, %esi
jmp 0x78569
movq %rdx, %rcx
testl %esi, %esi
je 0x78532
cmpl $0x1, %esi
jne 0x78575
movq %rcx, %rdx
cmpb $0x25, (%rdx)
jne 0x785cb
cmpb $0x25, 0x1(%rdx)
je 0x785cb
leaq 0x10(%rsp), %rdi
movl $0x40, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x312f6
leaq 0xf(%rsp), %rdi
cmpb $0x20, 0x1(%rdi)
leaq 0x1(%rdi), %rdi
je 0x78599
andl $-0x2, %ebx
cmpl $0x8, %ebx
jne 0x785bc
callq 0x22690
cvttsd2si %xmm0, %rax
movq %rax, 0x8(%rsp)
jmp 0x785c6
leaq 0x8(%rsp), %rsi
callq 0x736d2
movq 0x8(%rsp), %rax
addq $0x50, %rsp
popq %rbx
retq
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
float ImGui::SliderCalcRatioFromValueT<int, float>(int, int, int, int, float, float)
|
float ImGui::SliderCalcRatioFromValueT(ImGuiDataType data_type, TYPE v, TYPE v_min, TYPE v_max, float power, float linear_zero_pos)
{
if (v_min == v_max)
return 0.0f;
const bool is_power = (power != 1.0f) && (data_type == ImGuiDataType_Float || data_type == ImGuiDataType_Double);
const TYPE v_clamped = (v_min < v_max) ? ImClamp(v, v_min, v_max) : ImClamp(v, v_max, v_min);
if (is_power)
{
if (v_clamped < 0.0f)
{
const float f = 1.0f - (float)((v_clamped - v_min) / (ImMin((TYPE)0, v_max) - v_min));
return (1.0f - ImPow(f, 1.0f/power)) * linear_zero_pos;
}
else
{
const float f = (float)((v_clamped - ImMax((TYPE)0, v_min)) / (v_max - ImMax((TYPE)0, v_min)));
return linear_zero_pos + ImPow(f, 1.0f/power) * (1.0f - linear_zero_pos);
}
}
// Linear slider
return (float)((FLOATTYPE)(v_clamped - v_min) / (FLOATTYPE)(v_max - v_min));
}
|
pushq %rax
xorps %xmm2, %xmm2
movl %ecx, %r8d
subl %edx, %r8d
je 0x78980
andl $-0x2, %edi
cmpl %ecx, %edx
movl %ecx, %r9d
cmovll %edx, %r9d
movl %ecx, %eax
cmovgl %edx, %eax
cmpl %eax, %esi
cmovll %esi, %eax
cmpl %esi, %r9d
cmovgl %r9d, %eax
cmpl $0x8, %edi
jne 0x78924
ucomiss 0x573f(%rip), %xmm0 # 0x7e010
jne 0x788d5
jnp 0x78924
movss %xmm1, 0x4(%rsp)
testl %eax, %eax
js 0x7893b
xorl %esi, %esi
testl %edx, %edx
cmovgl %edx, %esi
subl %esi, %eax
subl %esi, %ecx
cltd
idivl %ecx
xorps %xmm2, %xmm2
cvtsi2ss %eax, %xmm2
movss 0x5714(%rip), %xmm1 # 0x7e010
divss %xmm0, %xmm1
movaps %xmm2, %xmm0
callq 0x226c0
movss 0x4(%rsp), %xmm1
movss 0x56fa(%rip), %xmm2 # 0x7e010
subss %xmm1, %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
jmp 0x78983
subl %edx, %eax
xorps %xmm2, %xmm2
cvtsi2ss %eax, %xmm2
xorps %xmm0, %xmm0
cvtsi2ss %r8d, %xmm0
divss %xmm0, %xmm2
jmp 0x78980
subl %edx, %eax
movl %ecx, %esi
sarl $0x1f, %esi
andl %ecx, %esi
subl %edx, %esi
cltd
idivl %esi
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movss 0x56b8(%rip), %xmm3 # 0x7e010
movaps %xmm3, %xmm2
subss %xmm1, %xmm2
movaps %xmm3, %xmm1
divss %xmm0, %xmm1
movaps %xmm2, %xmm0
callq 0x226c0
movss 0x569a(%rip), %xmm2 # 0x7e010
subss %xmm0, %xmm2
mulss 0x4(%rsp), %xmm2
movaps %xmm2, %xmm0
popq %rax
retq
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
float ImGui::SliderCalcRatioFromValueT<float, float>(int, float, float, float, float, float)
|
float ImGui::SliderCalcRatioFromValueT(ImGuiDataType data_type, TYPE v, TYPE v_min, TYPE v_max, float power, float linear_zero_pos)
{
if (v_min == v_max)
return 0.0f;
const bool is_power = (power != 1.0f) && (data_type == ImGuiDataType_Float || data_type == ImGuiDataType_Double);
const TYPE v_clamped = (v_min < v_max) ? ImClamp(v, v_min, v_max) : ImClamp(v, v_max, v_min);
if (is_power)
{
if (v_clamped < 0.0f)
{
const float f = 1.0f - (float)((v_clamped - v_min) / (ImMin((TYPE)0, v_max) - v_min));
return (1.0f - ImPow(f, 1.0f/power)) * linear_zero_pos;
}
else
{
const float f = (float)((v_clamped - ImMax((TYPE)0, v_min)) / (v_max - ImMax((TYPE)0, v_min)));
return linear_zero_pos + ImPow(f, 1.0f/power) * (1.0f - linear_zero_pos);
}
}
// Linear slider
return (float)((FLOATTYPE)(v_clamped - v_min) / (FLOATTYPE)(v_max - v_min));
}
|
pushq %rax
xorps %xmm5, %xmm5
ucomiss %xmm2, %xmm1
jne 0x78c2f
jnp 0x78cbe
andl $-0x2, %edi
movaps %xmm1, %xmm6
minss %xmm2, %xmm6
movaps %xmm2, %xmm5
maxss %xmm1, %xmm5
minss %xmm0, %xmm5
cmpltss %xmm6, %xmm0
andps %xmm0, %xmm6
andnps %xmm5, %xmm0
orps %xmm6, %xmm0
cmpl $0x8, %edi
jne 0x78caf
ucomiss 0x53b2(%rip), %xmm3 # 0x7e010
jne 0x78c62
jnp 0x78caf
movss %xmm4, 0x4(%rsp)
xorps %xmm4, %xmm4
ucomiss %xmm0, %xmm4
jbe 0x78cc3
subss %xmm1, %xmm0
minss %xmm2, %xmm4
subss %xmm1, %xmm4
divss %xmm4, %xmm0
movss 0x5388(%rip), %xmm1 # 0x7e010
movaps %xmm1, %xmm2
subss %xmm0, %xmm2
divss %xmm3, %xmm1
movaps %xmm2, %xmm0
callq 0x226c0
movss 0x536d(%rip), %xmm5 # 0x7e010
subss %xmm0, %xmm5
mulss 0x4(%rsp), %xmm5
jmp 0x78cbe
subss %xmm1, %xmm0
subss %xmm1, %xmm2
divss %xmm2, %xmm0
movaps %xmm0, %xmm5
movaps %xmm5, %xmm0
popq %rax
retq
movaps %xmm1, %xmm5
cmpless %xmm4, %xmm5
andnps %xmm1, %xmm5
subss %xmm5, %xmm0
subss %xmm5, %xmm2
divss %xmm2, %xmm0
movss 0x532e(%rip), %xmm1 # 0x7e010
divss %xmm3, %xmm1
callq 0x226c0
movss 0x4(%rsp), %xmm1
movss 0x5317(%rip), %xmm2 # 0x7e010
subss %xmm1, %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
jmp 0x78cc1
|
/ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp
|
ImGui_ImplSDL2_ProcessEvent(SDL_Event const*)
|
bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event)
{
ImGuiIO& io = ImGui::GetIO();
switch (event->type)
{
case SDL_MOUSEWHEEL:
{
if (event->wheel.x > 0) io.MouseWheelH += 1;
if (event->wheel.x < 0) io.MouseWheelH -= 1;
if (event->wheel.y > 0) io.MouseWheel += 1;
if (event->wheel.y < 0) io.MouseWheel -= 1;
return true;
}
case SDL_MOUSEBUTTONDOWN:
{
if (event->button.button == SDL_BUTTON_LEFT) g_MousePressed[0] = true;
if (event->button.button == SDL_BUTTON_RIGHT) g_MousePressed[1] = true;
if (event->button.button == SDL_BUTTON_MIDDLE) g_MousePressed[2] = true;
return true;
}
case SDL_TEXTINPUT:
{
io.AddInputCharactersUTF8(event->text.text);
return true;
}
case SDL_KEYDOWN:
case SDL_KEYUP:
{
int key = event->key.keysym.scancode;
IM_ASSERT(key >= 0 && key < IM_ARRAYSIZE(io.KeysDown));
io.KeysDown[key] = (event->type == SDL_KEYDOWN);
io.KeyShift = ((SDL_GetModState() & KMOD_SHIFT) != 0);
io.KeyCtrl = ((SDL_GetModState() & KMOD_CTRL) != 0);
io.KeyAlt = ((SDL_GetModState() & KMOD_ALT) != 0);
#ifdef _WIN32
io.KeySuper = false;
#else
io.KeySuper = ((SDL_GetModState() & KMOD_GUI) != 0);
#endif
return true;
}
}
return false;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x35fb5
movq %rax, %rbx
movl (%r14), %ecx
xorl %eax, %eax
cmpl $0x400, %ecx # imm = 0x400
jg 0x7bd44
leal -0x300(%rcx), %edx
cmpl $0x2, %edx
jae 0x7bddc
movl 0x10(%r14), %eax
cmpq $0x200, %rax # imm = 0x200
jae 0x7be2e
cmpl $0x300, %ecx # imm = 0x300
sete 0x144(%rbx,%rax)
callq 0x22780
testb $0x3, %al
setne 0x141(%rbx)
callq 0x22780
testb $-0x40, %al
setne 0x140(%rbx)
callq 0x22780
testl $0x300, %eax # imm = 0x300
setne 0x142(%rbx)
callq 0x22780
testl $0xc00, %eax # imm = 0xC00
setne 0x143(%rbx)
jmp 0x7bdf3
cmpl $0x401, %ecx # imm = 0x401
je 0x7bdfd
cmpl $0x403, %ecx # imm = 0x403
jne 0x7bdf5
cmpl $0x0, 0x10(%r14)
jle 0x7bd7b
movss 0x13c(%rbx), %xmm0
addss 0x229d(%rip), %xmm0 # 0x7e010
movss %xmm0, 0x13c(%rbx)
cmpl $0x0, 0x10(%r14)
jns 0x7bd9a
movss 0x13c(%rbx), %xmm0
addss 0x2276(%rip), %xmm0 # 0x7e008
movss %xmm0, 0x13c(%rbx)
cmpl $0x0, 0x14(%r14)
jle 0x7bdb9
movss 0x138(%rbx), %xmm0
addss 0x225f(%rip), %xmm0 # 0x7e010
movss %xmm0, 0x138(%rbx)
movb $0x1, %al
cmpl $0x0, 0x14(%r14)
jns 0x7bdf5
movss 0x138(%rbx), %xmm0
addss 0x2236(%rip), %xmm0 # 0x7e008
movss %xmm0, 0x138(%rbx)
jmp 0x7bdf5
cmpl $0x303, %ecx # imm = 0x303
jne 0x7bdf5
addq $0xc, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3025c
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movzbl 0x10(%r14), %ecx
movb $0x1, %al
cmpl $0x3, %ecx
je 0x7be25
cmpl $0x2, %ecx
je 0x7be1c
cmpl $0x1, %ecx
jne 0x7bdf5
movb $0x1, 0x2e166(%rip) # 0xa9f80
jmp 0x7bdf5
movb $0x1, 0x2e15f(%rip) # 0xa9f82
jmp 0x7bdf5
movb $0x1, 0x2e155(%rip) # 0xa9f81
jmp 0x7bdf5
leaq 0x1539b(%rip), %rdi # 0x911d0
leaq 0x153da(%rip), %rsi # 0x91216
leaq 0x1543d(%rip), %rcx # 0x91280
movl $0x73, %edx
callq 0x22190
|
/ggerganov[P]kbd-audio/imgui/examples/imgui_impl_sdl.cpp
|
ImGui_ImplOpenGL3_CreateDeviceObjects()
|
bool ImGui_ImplOpenGL3_CreateDeviceObjects()
{
// Backup GL state
GLint last_texture, last_array_buffer;
glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
#ifndef IMGUI_IMPL_OPENGL_ES2
GLint last_vertex_array;
glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
#endif
// Parse GLSL version string
int glsl_version = 130;
sscanf(g_GlslVersionString, "#version %d", &glsl_version);
const GLchar* vertex_shader_glsl_120 =
"uniform mat4 ProjMtx;\n"
"attribute vec2 Position;\n"
"attribute vec2 UV;\n"
"attribute vec4 Color;\n"
"varying vec2 Frag_UV;\n"
"varying vec4 Frag_Color;\n"
"void main()\n"
"{\n"
" Frag_UV = UV;\n"
" Frag_Color = Color;\n"
" gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
"}\n";
const GLchar* vertex_shader_glsl_130 =
"uniform mat4 ProjMtx;\n"
"in vec2 Position;\n"
"in vec2 UV;\n"
"in vec4 Color;\n"
"out vec2 Frag_UV;\n"
"out vec4 Frag_Color;\n"
"void main()\n"
"{\n"
" Frag_UV = UV;\n"
" Frag_Color = Color;\n"
" gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
"}\n";
const GLchar* vertex_shader_glsl_300_es =
"precision mediump float;\n"
"layout (location = 0) in vec2 Position;\n"
"layout (location = 1) in vec2 UV;\n"
"layout (location = 2) in vec4 Color;\n"
"uniform mat4 ProjMtx;\n"
"out vec2 Frag_UV;\n"
"out vec4 Frag_Color;\n"
"void main()\n"
"{\n"
" Frag_UV = UV;\n"
" Frag_Color = Color;\n"
" gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
"}\n";
const GLchar* vertex_shader_glsl_410_core =
"layout (location = 0) in vec2 Position;\n"
"layout (location = 1) in vec2 UV;\n"
"layout (location = 2) in vec4 Color;\n"
"uniform mat4 ProjMtx;\n"
"out vec2 Frag_UV;\n"
"out vec4 Frag_Color;\n"
"void main()\n"
"{\n"
" Frag_UV = UV;\n"
" Frag_Color = Color;\n"
" gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
"}\n";
const GLchar* fragment_shader_glsl_120 =
"#ifdef GL_ES\n"
" precision mediump float;\n"
"#endif\n"
"uniform sampler2D Texture;\n"
"varying vec2 Frag_UV;\n"
"varying vec4 Frag_Color;\n"
"void main()\n"
"{\n"
" gl_FragColor = Frag_Color * texture2D(Texture, Frag_UV.st);\n"
"}\n";
const GLchar* fragment_shader_glsl_130 =
"uniform sampler2D Texture;\n"
"in vec2 Frag_UV;\n"
"in vec4 Frag_Color;\n"
"out vec4 Out_Color;\n"
"void main()\n"
"{\n"
" Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
"}\n";
const GLchar* fragment_shader_glsl_300_es =
"precision mediump float;\n"
"uniform sampler2D Texture;\n"
"in vec2 Frag_UV;\n"
"in vec4 Frag_Color;\n"
"layout (location = 0) out vec4 Out_Color;\n"
"void main()\n"
"{\n"
" Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
"}\n";
const GLchar* fragment_shader_glsl_410_core =
"in vec2 Frag_UV;\n"
"in vec4 Frag_Color;\n"
"uniform sampler2D Texture;\n"
"layout (location = 0) out vec4 Out_Color;\n"
"void main()\n"
"{\n"
" Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
"}\n";
// Select shaders matching our GLSL versions
const GLchar* vertex_shader = NULL;
const GLchar* fragment_shader = NULL;
if (glsl_version < 130)
{
vertex_shader = vertex_shader_glsl_120;
fragment_shader = fragment_shader_glsl_120;
}
else if (glsl_version >= 410)
{
vertex_shader = vertex_shader_glsl_410_core;
fragment_shader = fragment_shader_glsl_410_core;
}
else if (glsl_version == 300)
{
vertex_shader = vertex_shader_glsl_300_es;
fragment_shader = fragment_shader_glsl_300_es;
}
else
{
vertex_shader = vertex_shader_glsl_130;
fragment_shader = fragment_shader_glsl_130;
}
// Create shaders
const GLchar* vertex_shader_with_version[2] = { g_GlslVersionString, vertex_shader };
g_VertHandle = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(g_VertHandle, 2, vertex_shader_with_version, NULL);
glCompileShader(g_VertHandle);
CheckShader(g_VertHandle, "vertex shader");
const GLchar* fragment_shader_with_version[2] = { g_GlslVersionString, fragment_shader };
g_FragHandle = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(g_FragHandle, 2, fragment_shader_with_version, NULL);
glCompileShader(g_FragHandle);
CheckShader(g_FragHandle, "fragment shader");
g_ShaderHandle = glCreateProgram();
glAttachShader(g_ShaderHandle, g_VertHandle);
glAttachShader(g_ShaderHandle, g_FragHandle);
glLinkProgram(g_ShaderHandle);
CheckProgram(g_ShaderHandle, "shader program");
g_AttribLocationTex = glGetUniformLocation(g_ShaderHandle, "Texture");
g_AttribLocationProjMtx = glGetUniformLocation(g_ShaderHandle, "ProjMtx");
g_AttribLocationVtxPos = glGetAttribLocation(g_ShaderHandle, "Position");
g_AttribLocationVtxUV = glGetAttribLocation(g_ShaderHandle, "UV");
g_AttribLocationVtxColor = glGetAttribLocation(g_ShaderHandle, "Color");
// Create buffers
glGenBuffers(1, &g_VboHandle);
glGenBuffers(1, &g_ElementsHandle);
ImGui_ImplOpenGL3_CreateFontsTexture();
// Restore modified GL state
glBindTexture(GL_TEXTURE_2D, last_texture);
glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
#ifndef IMGUI_IMPL_OPENGL_ES2
glBindVertexArray(last_vertex_array);
#endif
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq 0x2c513(%rip), %rbx # 0xa8dc8
leaq 0x24(%rsp), %rsi
movl $0x8069, %edi # imm = 0x8069
callq *(%rbx)
leaq 0x20(%rsp), %rsi
movl $0x8894, %edi # imm = 0x8894
callq *(%rbx)
leaq 0x1c(%rsp), %rsi
movl $0x85b5, %edi # imm = 0x85B5
callq *(%rbx)
movl $0x82, %ebp
leaq 0x28(%rsp), %r14
movl %ebp, (%r14)
leaq 0x2d723(%rip), %rbx # 0xaa010
leaq 0x14c02(%rip), %rsi # 0x914f6
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x220e0
movl (%r14), %eax
cmpl %ebp, %eax
jge 0x7c918
leaq 0x14ef3(%rip), %r15 # 0x91802
leaq 0x14bec(%rip), %rax # 0x91502
jmp 0x7c958
cmpl $0x199, %eax # imm = 0x199
jle 0x7c92f
leaq 0x15117(%rip), %r15 # 0x91a3d
leaq 0x14dbb(%rip), %rax # 0x916e8
jmp 0x7c958
cmpl $0x12c, %eax # imm = 0x12C
leaq 0x14d94(%rip), %rcx # 0x916cf
leaq 0x14cb5(%rip), %rax # 0x915f7
cmoveq %rcx, %rax
leaq 0x15021(%rip), %rcx # 0x9196e
leaq 0x14f7a(%rip), %r15 # 0x918ce
cmoveq %rcx, %r15
leaq 0x40(%rsp), %r14
movq %rbx, (%r14)
movq %rax, 0x8(%r14)
leaq 0x2c6ad(%rip), %rbp # 0xa9018
movl $0x8b31, %edi # imm = 0x8B31
callq *(%rbp)
movl %eax, 0x2d6bf(%rip) # 0xaa038
leaq 0x2c760(%rip), %r13 # 0xa90e0
movl %eax, %edi
movl $0x2, %esi
movq %r14, %rdx
xorl %ecx, %ecx
callq *(%r13)
leaq 0x2c671(%rip), %r12 # 0xa9008
movl 0x2d69b(%rip), %edi # 0xaa038
callq *(%r12)
movl 0x2d691(%rip), %edi # 0xaa038
leaq 0x15145(%rip), %rsi # 0x91af3
callq 0x7d4b3
leaq 0x30(%rsp), %r14
movq %rbx, (%r14)
movq %r15, 0x8(%r14)
movl $0x8b30, %edi # imm = 0x8B30
callq *(%rbp)
movl %eax, 0x2d66f(%rip) # 0xaa03c
movl %eax, %edi
movl $0x2, %esi
movq %r14, %rdx
xorl %ecx, %ecx
callq *(%r13)
movl 0x2d659(%rip), %edi # 0xaa03c
callq *(%r12)
movl 0x2d64f(%rip), %edi # 0xaa03c
leaq 0x1510d(%rip), %rsi # 0x91b01
callq 0x7d4b3
leaq 0x2c610(%rip), %rax # 0xa9010
callq *(%rax)
movl %eax, 0x2d628(%rip) # 0xaa030
leaq 0x2c5e9(%rip), %rbx # 0xa8ff8
movl 0x2d623(%rip), %esi # 0xaa038
movl %eax, %edi
callq *(%rbx)
movl 0x2d611(%rip), %edi # 0xaa030
movl 0x2d617(%rip), %esi # 0xaa03c
callq *(%rbx)
leaq 0x2c6aa(%rip), %rax # 0xa90d8
movl 0x2d5fc(%rip), %edi # 0xaa030
callq *(%rax)
movl 0x2d5f4(%rip), %ebx # 0xaa030
leaq 0x2c(%rsp), %r14
xorl %eax, %eax
movl %eax, (%r14)
leaq 0x18(%rsp), %r15
movl %eax, (%r15)
leaq 0x2c613(%rip), %r12 # 0xa9068
movl %ebx, %edi
movl $0x8b82, %esi # imm = 0x8B82
movq %r14, %rdx
callq *(%r12)
movl %ebx, %edi
movl $0x8b84, %esi # imm = 0x8B84
movq %r15, %rdx
callq *(%r12)
cmpb $0x0, (%r14)
je 0x7cb69
movl 0x18(%rsp), %ecx
cmpl $0x2, %ecx
jge 0x7cb73
leaq 0x2c601(%rip), %rbx # 0xa9090
movl 0x2d59b(%rip), %edi # 0xaa030
leaq 0x11c0e(%rip), %rsi # 0x8e6aa
callq *(%rbx)
movl %eax, 0x2d59c(%rip) # 0xaa040
movl 0x2d586(%rip), %edi # 0xaa030
leaq 0x1506f(%rip), %rsi # 0x91b20
callq *(%rbx)
movl %eax, 0x2d58b(%rip) # 0xaa044
leaq 0x2c5a0(%rip), %rbx # 0xa9060
movl 0x2d56a(%rip), %edi # 0xaa030
leaq 0x1505b(%rip), %rsi # 0x91b28
callq *(%rbx)
movl %eax, 0x2d573(%rip) # 0xaa048
movl 0x2d555(%rip), %edi # 0xaa030
leaq 0x1504f(%rip), %rsi # 0x91b31
callq *(%rbx)
movl %eax, 0x2d562(%rip) # 0xaa04c
movl 0x2d540(%rip), %edi # 0xaa030
leaq 0x11bed(%rip), %rsi # 0x8e6e4
callq *(%rbx)
movl %eax, 0x2d551(%rip) # 0xaa050
leaq 0x2c482(%rip), %rbx # 0xa8f88
leaq 0x2d547(%rip), %rsi # 0xaa054
movl $0x1, %edi
callq *(%rbx)
leaq 0x2d53d(%rip), %rsi # 0xaa058
movl $0x1, %edi
callq *(%rbx)
callq 0x7d357
leaq 0x2c33a(%rip), %rax # 0xa8e68
movl 0x24(%rsp), %esi
movl $0xde1, %edi # imm = 0xDE1
callq *(%rax)
leaq 0x2c438(%rip), %rax # 0xa8f78
movl 0x20(%rsp), %esi
movl $0x8892, %edi # imm = 0x8892
callq *(%rax)
leaq 0x2ca7e(%rip), %rax # 0xa95d0
movl 0x1c(%rsp), %edi
callq *(%rax)
movb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x22b97
jmp 0x7ca7b
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
leal 0x1(%rcx), %ebp
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jg 0x7cbe0
movl $0x8, %r15d
testl %eax, %eax
je 0x7cb9f
movl %eax, %r15d
shrl $0x1f, %r15d
addl %eax, %r15d
sarl %r15d
addl %eax, %r15d
cmpl %ebp, %r15d
cmovlel %ebp, %r15d
cmpl %r15d, %eax
jge 0x7cbe0
movl %r15d, %edi
callq 0x31065
movq %rax, %r14
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x7cbd6
movslq (%rsp), %rdx
movq %r14, %rdi
callq 0x220a0
movq 0x8(%rsp), %rdi
callq 0x3112f
movq %r14, 0x8(%rsp)
movl %r15d, 0x4(%rsp)
movl %ebp, (%rsp)
leaq 0x2c486(%rip), %rax # 0xa9070
movl 0x18(%rsp), %esi
movq 0x8(%rsp), %rcx
movl %ebx, %edi
xorl %edx, %edx
callq *(%rax)
movq 0x273e8(%rip), %rax # 0xa3fe8
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x156e(%rip), %rsi # 0x7e17d
xorl %eax, %eax
callq 0x221f0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7ca88
callq 0x3112f
jmp 0x7ca88
movq %rax, %rdi
callq 0x281c4
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4a99e
movq %rbx, %rdi
callq 0x22520
|
/ggerganov[P]kbd-audio/imgui/examples/imgui_impl_opengl3.cpp
|
ImGui_ImplOpenGL3_SetupRenderState(ImDrawData*, int, int, unsigned int)
|
static void ImGui_ImplOpenGL3_SetupRenderState(ImDrawData* draw_data, int fb_width, int fb_height, GLuint vertex_array_object)
{
// Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, polygon fill
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_SCISSOR_TEST);
#ifdef GL_POLYGON_MODE
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
#endif
// Support for GL 4.5 rarely used glClipControl(GL_UPPER_LEFT)
bool clip_origin_lower_left = true;
#if defined(GL_CLIP_ORIGIN) && !defined(__APPLE__)
GLenum current_clip_origin = 0; glGetIntegerv(GL_CLIP_ORIGIN, (GLint*)¤t_clip_origin);
if (current_clip_origin == GL_UPPER_LEFT)
clip_origin_lower_left = false;
#endif
// Setup viewport, orthographic projection matrix
// Our visible imgui space lies from draw_data->DisplayPos (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right). DisplayPos is (0,0) for single viewport apps.
glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height);
float L = draw_data->DisplayPos.x;
float R = draw_data->DisplayPos.x + draw_data->DisplaySize.x;
float T = draw_data->DisplayPos.y;
float B = draw_data->DisplayPos.y + draw_data->DisplaySize.y;
if (!clip_origin_lower_left) { float tmp = T; T = B; B = tmp; } // Swap top and bottom if origin is upper left
const float ortho_projection[4][4] =
{
{ 2.0f/(R-L), 0.0f, 0.0f, 0.0f },
{ 0.0f, 2.0f/(T-B), 0.0f, 0.0f },
{ 0.0f, 0.0f, -1.0f, 0.0f },
{ (R+L)/(L-R), (T+B)/(B-T), 0.0f, 1.0f },
};
glUseProgram(g_ShaderHandle);
glUniform1i(g_AttribLocationTex, 0);
glUniformMatrix4fv(g_AttribLocationProjMtx, 1, GL_FALSE, &ortho_projection[0][0]);
#ifdef GL_SAMPLER_BINDING
glBindSampler(0, 0); // We use combined texture/sampler state. Applications using GL 3.3 may set that otherwise.
#endif
(void)vertex_array_object;
#ifndef IMGUI_IMPL_OPENGL_ES2
glBindVertexArray(vertex_array_object);
#endif
// Bind vertex/index buffers and setup attributes for ImDrawVert
glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_ElementsHandle);
glEnableVertexAttribArray(g_AttribLocationVtxPos);
glEnableVertexAttribArray(g_AttribLocationVtxUV);
glEnableVertexAttribArray(g_AttribLocationVtxColor);
glVertexAttribPointer(g_AttribLocationVtxPos, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, pos));
glVertexAttribPointer(g_AttribLocationVtxUV, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, uv));
glVertexAttribPointer(g_AttribLocationVtxColor, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, col));
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
leaq 0x2bbf0(%rip), %r12 # 0xa8d48
movl $0xbe2, %edi # imm = 0xBE2
callq *(%r12)
leaq 0x2bd28(%rip), %rax # 0xa8e90
movl $0x8006, %edi # imm = 0x8006
callq *(%rax)
leaq 0x2bbea(%rip), %rax # 0xa8d60
movl $0x302, %edi # imm = 0x302
movl $0x303, %esi # imm = 0x303
callq *(%rax)
leaq 0x2bbb7(%rip), %r13 # 0xa8d40
movl $0xb44, %edi # imm = 0xB44
callq *(%r13)
movl $0xb71, %edi # imm = 0xB71
callq *(%r13)
movl $0xc11, %edi # imm = 0xC11
callq *(%r12)
leaq 0x2bb15(%rip), %rax # 0xa8cc0
movl $0x408, %edi # imm = 0x408
movl $0x1b02, %esi # imm = 0x1B02
callq *(%rax)
leaq 0x2bc52(%rip), %rax # 0xa8e10
xorl %edi, %edi
xorl %esi, %esi
movl %r14d, %edx
movl %ebp, %ecx
callq *(%rax)
xorps %xmm0, %xmm0
movq %rsp, %r14
movups %xmm0, 0x4(%r14)
movups %xmm0, 0x18(%r14)
movss 0xe27(%rip), %xmm0 # 0x7e008
movlps %xmm0, 0x28(%r14)
movsd 0x1c(%r15), %xmm0
movsd 0x24(%r15), %xmm1
addps %xmm0, %xmm1
movaps %xmm1, %xmm2
subss %xmm0, %xmm2
movss 0x1c74(%rip), %xmm3 # 0x7ee78
movaps %xmm3, %xmm4
divss %xmm2, %xmm4
movss %xmm4, (%r14)
movaps %xmm0, %xmm2
subps %xmm1, %xmm2
shufps $0x55, %xmm2, %xmm2 # xmm2 = xmm2[1,1,1,1]
divss %xmm2, %xmm3
movaps %xmm0, %xmm2
addps %xmm1, %xmm2
movaps %xmm1, %xmm4
shufps $0x1, %xmm0, %xmm4 # xmm4 = xmm4[1,0],xmm0[0,0]
shufps $0xe2, %xmm0, %xmm4 # xmm4 = xmm4[2,0],xmm0[2,3]
shufps $0x1, %xmm1, %xmm0 # xmm0 = xmm0[1,0],xmm1[0,0]
shufps $0xe2, %xmm1, %xmm0 # xmm0 = xmm0[2,0],xmm1[2,3]
subps %xmm0, %xmm4
divps %xmm4, %xmm2
unpcklpd 0x700b(%rip), %xmm2 # xmm2 = xmm2[0],mem[0]
movss %xmm3, 0x14(%r14)
movaps %xmm2, 0x30(%r14)
leaq 0x2be91(%rip), %rax # 0xa90e8
movl 0x2cdd3(%rip), %edi # 0xaa030
callq *(%rax)
leaq 0x2beaa(%rip), %rax # 0xa9110
movl 0x2cdd4(%rip), %edi # 0xaa040
xorl %esi, %esi
callq *(%rax)
leaq 0x2bf09(%rip), %rax # 0xa9180
movl 0x2cdc7(%rip), %edi # 0xaa044
movl $0x1, %esi
xorl %edx, %edx
movq %r14, %rcx
callq *(%rax)
leaq 0x2c4a0(%rip), %rax # 0xa9730
xorl %edi, %edi
xorl %esi, %esi
callq *(%rax)
leaq 0x2c333(%rip), %rax # 0xa95d0
movl %ebx, %edi
callq *(%rax)
leaq 0x2bcd0(%rip), %rbx # 0xa8f78
movl 0x2cda6(%rip), %esi # 0xaa054
movl $0x8892, %edi # imm = 0x8892
callq *(%rbx)
movl 0x2cd9d(%rip), %esi # 0xaa058
movl $0x8893, %edi # imm = 0x8893
callq *(%rbx)
leaq 0x2bd77(%rip), %rbx # 0xa9040
movl 0x2cd79(%rip), %edi # 0xaa048
callq *(%rbx)
movl 0x2cd75(%rip), %edi # 0xaa04c
callq *(%rbx)
movl 0x2cd71(%rip), %edi # 0xaa050
callq *(%rbx)
leaq 0x2bfc8(%rip), %rbx # 0xa92b0
movl 0x2cd5a(%rip), %edi # 0xaa048
movl $0x2, %esi
movl $0x1406, %edx # imm = 0x1406
xorl %ecx, %ecx
movl $0x14, %r8d
xorl %r9d, %r9d
callq *(%rbx)
movl 0x2cd41(%rip), %edi # 0xaa04c
movl $0x8, %r9d
movl $0x2, %esi
movl $0x1406, %edx # imm = 0x1406
xorl %ecx, %ecx
movl $0x14, %r8d
callq *(%rbx)
movl 0x2cd25(%rip), %edi # 0xaa050
movl $0x10, %r9d
movl $0x4, %esi
movl $0x1401, %edx # imm = 0x1401
movl $0x1, %ecx
movl $0x14, %r8d
callq *(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/ggerganov[P]kbd-audio/imgui/examples/imgui_impl_opengl3.cpp
|
internal_rle_compress
|
uint64_t
internal_rle_compress (
void* out, uint64_t outbytes, const void* src, uint64_t srcbytes)
{
int8_t* cbuf = out;
const int8_t* runs = src;
const int8_t* end = runs + srcbytes;
const int8_t* rune = runs + 1;
uint64_t outb = 0;
while (runs < end)
{
uint8_t curcount = 0;
while (rune < end && *runs == *rune && curcount < MAX_RUN_LENGTH)
{
++rune;
++curcount;
}
if (curcount >= (MIN_RUN_LENGTH - 1))
{
cbuf[outb++] = (int8_t) curcount;
cbuf[outb++] = *runs;
runs = rune;
}
else
{
/* incompressible */
++curcount;
while (rune < end &&
((rune + 1 >= end || *rune != *(rune + 1)) ||
(rune + 2 >= end || *(rune + 1) != *(rune + 2))) &&
curcount < MAX_RUN_LENGTH)
{
++curcount;
++rune;
}
cbuf[outb++] = (int8_t) (-((int) curcount));
while (runs < rune)
cbuf[outb++] = *runs++;
}
++rune;
if (outb >= outbytes) break;
}
return outb;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
addq %rdx, %rcx
leaq 0x1(%rdi), %r8
xorl %r10d, %r10d
movl $0x7e, %r9d
movq %rdx, %r11
cmpq %rcx, %rdx
jae 0x5245
incq %r11
cmpq %rcx, %r11
jae 0x515d
movb (%rdx), %al
xorl %r14d, %r14d
cmpb (%r11,%r14), %al
jne 0x513a
cmpb $0x7f, %r14b
je 0x513a
leaq (%r11,%r14), %rbx
incq %rbx
incq %r14
cmpq %rcx, %rbx
jb 0x511f
addq %r14, %r11
cmpb $0x1, %r14b
jbe 0x5160
movb %r14b, (%rdi,%r10)
movb (%rdx), %al
movb %al, 0x1(%rdi,%r10)
addq $0x2, %r10
movq %r11, %rbx
movq %r10, %rax
jmp 0x5219
xorl %r14d, %r14d
cmpq %rcx, %r11
jae 0x51c4
movzbl %r14b, %eax
xorl %r14d, %r14d
leaq (%r11,%r14), %r15
leaq (%rax,%r14), %r12
addq $-0x7e, %r12
leaq (%r11,%r14), %rbx
incq %rbx
cmpq %rcx, %rbx
jae 0x51b5
movb (%r15), %bpl
cmpb 0x1(%r15), %bpl
jne 0x51b5
leaq (%r11,%r14), %r13
addq $0x2, %r13
cmpq %rcx, %r13
jae 0x51b5
cmpb (%r13), %bpl
sete %r13b
testb %r12b, %r12b
sete %bpl
orb %r13b, %bpl
jne 0x522d
cmpq %rcx, %rbx
jb 0x51bf
jmp 0x522d
testb %r12b, %r12b
je 0x51c9
cmpq %rcx, %rbx
jae 0x51c9
incq %r14
jmp 0x516c
movq %r11, %rbx
jmp 0x51e1
testb %r12b, %r12b
cmoveq %r15, %rbx
addl %r14d, %eax
incb %al
movzbl %al, %r14d
cmpb $0x7e, %r14b
cmovgel %r9d, %r14d
notb %r14b
movb %r14b, (%rdi,%r10)
leaq 0x1(%r10), %rax
cmpq %rbx, %rdx
jae 0x5216
addq %rbx, %rax
subq %rdx, %rax
movq %rbx, %r11
subq %rdx, %r11
addq %r8, %r10
xorl %r14d, %r14d
movb (%rdx,%r14), %bpl
movb %bpl, (%r10,%r14)
incq %r14
cmpq %r14, %r11
jne 0x5203
addq %r14, %rdx
movq %rdx, %r11
movq %r11, %rdx
movq %rbx, %r11
movq %rax, %r10
cmpq %rsi, %rax
jb 0x5109
jmp 0x5248
addl %r14d, %eax
testb %bpl, %bpl
cmovneq %r15, %rbx
leal 0x1(%rax), %r11d
movzbl %r11b, %r14d
cmovnel %eax, %r14d
jmp 0x51e1
movq %r10, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/internal_rle.c
|
internal_zip_deconstruct_bytes
|
void
internal_zip_deconstruct_bytes (
uint8_t* scratch, const uint8_t* source, uint64_t count)
{
int p;
uint8_t* t1 = scratch;
uint8_t* t2 = t1 + (count + 1) / 2;
const uint8_t* raw = source;
const uint8_t* stop = raw + count;
/* reorder */
while (raw < stop)
{
*(t1++) = *(raw++);
if (raw < stop) *(t2++) = *(raw++);
}
/* reorder */
t1 = scratch;
t2 = t1 + count;
t1++;
p = (int) t1[-1];
while (t1 < t2)
{
int d = (int) (t1[0]) - p + (128 + 256);
p = (int) t1[0];
t1[0] = (uint8_t) d;
++t1;
}
}
|
testq %rdx, %rdx
jle 0x55ec
leaq (%rsi,%rdx), %rax
leaq 0x1(%rdx), %rcx
shrq %rcx
addq %rdi, %rcx
movq %rdi, %r8
leaq 0x1(%rsi), %r9
movb (%rsi), %r10b
movb %r10b, (%r8)
cmpq %rax, %r9
jae 0x55bb
movb 0x1(%rsi), %r9b
addq $0x2, %rsi
movb %r9b, (%rcx)
incq %rcx
movq %rsi, %r9
jmp 0x55be
movq %r9, %rsi
incq %r8
cmpq %rax, %r9
jb 0x5599
cmpq $0x1, %rdx
je 0x55ec
addq %rdi, %rdx
movb (%rdi), %al
incq %rdi
movb (%rdi), %cl
movl %ecx, %esi
subb %al, %sil
addb $-0x80, %sil
movb %sil, (%rdi)
incq %rdi
movl %ecx, %eax
cmpq %rdx, %rdi
jb 0x55d4
retq
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/internal_zip.c
|
internal_exr_undo_zip
|
exr_result_t
internal_exr_undo_zip (
exr_decode_pipeline_t* decode,
const void* compressed_data,
uint64_t comp_buf_size,
void* uncompressed_data,
uint64_t uncompressed_size)
{
exr_result_t rv;
uint64_t scratchbufsz = uncompressed_size;
if (comp_buf_size > scratchbufsz) scratchbufsz = comp_buf_size;
if (comp_buf_size == uncompressed_size)
{
decode->bytes_decompressed = comp_buf_size;
if (compressed_data != uncompressed_data)
memcpy(uncompressed_data, compressed_data, comp_buf_size);
return EXR_ERR_SUCCESS;
}
rv = internal_decode_alloc_buffer (
decode,
EXR_TRANSCODE_BUFFER_SCRATCH1,
&(decode->scratch_buffer_1),
&(decode->scratch_alloc_size_1),
scratchbufsz);
if (rv != EXR_ERR_SUCCESS) return rv;
return undo_zip_impl (
decode,
compressed_data,
comp_buf_size,
uncompressed_data,
uncompressed_size,
decode->scratch_buffer_1,
decode->scratch_alloc_size_1);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %r12
cmpq %r8, %rdx
jne 0x5626
movq %r14, 0x68(%r12)
xorl %ebx, %ebx
cmpq %rcx, %rsi
je 0x56be
movq %rcx, %rdi
movq %r14, %rdx
callq 0x4290
jmp 0x56be
movq %r8, %r15
movq %rsi, 0x8(%rsp)
movq %rcx, (%rsp)
cmovaq %r14, %r8
leaq 0xb8(%r12), %r13
leaq 0xc0(%r12), %rbp
movq %r12, %rdi
movl $0x3, %esi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x2cee0
movl %eax, %ebx
testl %eax, %eax
jne 0x56be
movq (%rbp), %r8
cmpq %r15, %r8
movl $0x3, %eax
jb 0x56bc
movq (%r13), %rbx
movq 0x18(%r12), %rdi
leaq 0x10(%rsp), %r9
movq 0x8(%rsp), %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x4340
testl %eax, %eax
jne 0x56bc
movq 0x10(%rsp), %rdx
movq %rdx, 0x68(%r12)
cmpq %r14, %rdx
setb %al
cmpq %r15, %rdx
seta %cl
orb %al, %cl
movl $0x17, %eax
jne 0x56bc
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x54e0
xorl %eax, %eax
movl %eax, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/internal_zip.c
|
applyLut
|
static inline void
applyLut (const uint16_t lut[NO_ALIAS USHORT_RANGE], uint16_t* NO_ALIAS data, uint64_t nData)
{
/* partially unrolling is noticeably faster */
uint16_t dvals[8];
while ( nData > 8 )
{
memcpy (dvals, data, sizeof(uint16_t)*8);
for ( int i = 0; i < 8; ++i )
dvals[i] = lut[dvals[i]];
memcpy (data, dvals, sizeof(uint16_t)*8);
data += 8;
nData -= 8;
}
for (uint64_t i = 0; i < nData; ++i)
data[i] = lut[data[i]];
}
|
cmpq $0x9, %rdx
jb 0x78fa
movups (%rsi), %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
movzwl -0x18(%rsp,%rax,2), %ecx
movzwl (%rdi,%rcx,2), %ecx
movw %cx, -0x18(%rsp,%rax,2)
incq %rax
cmpq $0x8, %rax
jne 0x78cd
movaps -0x18(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, %rsi
addq $-0x8, %rdx
cmpq $0x8, %rdx
ja 0x78c3
testq %rdx, %rdx
je 0x7915
xorl %eax, %eax
movzwl (%rsi,%rax,2), %ecx
movzwl (%rdi,%rcx,2), %ecx
movw %cx, (%rsi,%rax,2)
incq %rax
cmpq %rax, %rdx
jne 0x7901
retq
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/internal_piz.c
|
fromHalfZigZag_scalar
|
static void
fromHalfZigZag_scalar (uint16_t* src, float* dst)
{
dst[0] = half_to_float (src[0]);
dst[1] = half_to_float (src[1]);
dst[2] = half_to_float (src[5]);
dst[3] = half_to_float (src[6]);
dst[4] = half_to_float (src[14]);
dst[5] = half_to_float (src[15]);
dst[6] = half_to_float (src[27]);
dst[7] = half_to_float (src[28]);
dst[8] = half_to_float (src[2]);
dst[9] = half_to_float (src[4]);
dst[10] = half_to_float (src[7]);
dst[11] = half_to_float (src[13]);
dst[12] = half_to_float (src[16]);
dst[13] = half_to_float (src[26]);
dst[14] = half_to_float (src[29]);
dst[15] = half_to_float (src[42]);
dst[16] = half_to_float (src[3]);
dst[17] = half_to_float (src[8]);
dst[18] = half_to_float (src[12]);
dst[19] = half_to_float (src[17]);
dst[20] = half_to_float (src[25]);
dst[21] = half_to_float (src[30]);
dst[22] = half_to_float (src[41]);
dst[23] = half_to_float (src[43]);
dst[24] = half_to_float (src[9]);
dst[25] = half_to_float (src[11]);
dst[26] = half_to_float (src[18]);
dst[27] = half_to_float (src[24]);
dst[28] = half_to_float (src[31]);
dst[29] = half_to_float (src[40]);
dst[30] = half_to_float (src[44]);
dst[31] = half_to_float (src[53]);
dst[32] = half_to_float (src[10]);
dst[33] = half_to_float (src[19]);
dst[34] = half_to_float (src[23]);
dst[35] = half_to_float (src[32]);
dst[36] = half_to_float (src[39]);
dst[37] = half_to_float (src[45]);
dst[38] = half_to_float (src[52]);
dst[39] = half_to_float (src[54]);
dst[40] = half_to_float (src[20]);
dst[41] = half_to_float (src[22]);
dst[42] = half_to_float (src[33]);
dst[43] = half_to_float (src[38]);
dst[44] = half_to_float (src[46]);
dst[45] = half_to_float (src[51]);
dst[46] = half_to_float (src[55]);
dst[47] = half_to_float (src[60]);
dst[48] = half_to_float (src[21]);
dst[49] = half_to_float (src[34]);
dst[50] = half_to_float (src[37]);
dst[51] = half_to_float (src[47]);
dst[52] = half_to_float (src[50]);
dst[53] = half_to_float (src[56]);
dst[54] = half_to_float (src[59]);
dst[55] = half_to_float (src[61]);
dst[56] = half_to_float (src[35]);
dst[57] = half_to_float (src[36]);
dst[58] = half_to_float (src[48]);
dst[59] = half_to_float (src[49]);
dst[60] = half_to_float (src[57]);
dst[61] = half_to_float (src[58]);
dst[62] = half_to_float (src[62]);
dst[63] = half_to_float (src[63]);
}
|
movswl (%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb163
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xba63
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, (%rsi)
movswl 0x2(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb187
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xba6d
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x4(%rsi)
movswl 0xa(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb1ab
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xba77
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x8(%rsi)
movswl 0xc(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb1cf
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xba81
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xc(%rsi)
movswl 0x1c(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb1f3
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xba8b
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x10(%rsi)
movswl 0x1e(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb217
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xba95
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x14(%rsi)
movswl 0x36(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb23b
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xba9f
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x18(%rsi)
movswl 0x38(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb25f
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbaa9
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x1c(%rsi)
movswl 0x4(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb283
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbab3
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x20(%rsi)
movswl 0x8(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb2a7
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbabd
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x24(%rsi)
movswl 0xe(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb2cb
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbac7
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x28(%rsi)
movswl 0x1a(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb2ef
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbad1
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x2c(%rsi)
movswl 0x20(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb313
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbadb
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x30(%rsi)
movswl 0x34(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb337
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbae5
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x34(%rsi)
movswl 0x3a(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb35b
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbaef
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x38(%rsi)
movswl 0x54(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb37f
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbaf9
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x3c(%rsi)
movswl 0x6(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb3a3
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbb03
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x40(%rsi)
movswl 0x10(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb3c7
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbb0d
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x44(%rsi)
movswl 0x18(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb3eb
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbb17
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x48(%rsi)
movswl 0x22(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb40f
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbb21
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x4c(%rsi)
movswl 0x32(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb433
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbb2b
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x50(%rsi)
movswl 0x3c(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb457
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbb35
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x54(%rsi)
movswl 0x52(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb47b
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbb3f
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x58(%rsi)
movswl 0x56(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb49f
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbb49
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x5c(%rsi)
movswl 0x12(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb4c3
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbb53
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x60(%rsi)
movswl 0x16(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb4e7
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbb5d
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x64(%rsi)
movswl 0x24(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb50b
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbb67
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x68(%rsi)
movswl 0x30(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb52f
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbb71
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x6c(%rsi)
movswl 0x3e(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb553
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbb7b
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x70(%rsi)
movswl 0x50(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb577
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbb85
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x74(%rsi)
movswl 0x58(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb59b
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbb8f
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x78(%rsi)
movswl 0x6a(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb5bf
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbb99
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x7c(%rsi)
movswl 0x14(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb5e3
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbba3
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x80(%rsi)
movswl 0x26(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb607
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbbad
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x84(%rsi)
movswl 0x2e(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb62b
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbbb7
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x88(%rsi)
movswl 0x40(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb64f
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbbc1
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x8c(%rsi)
movswl 0x4e(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb673
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbbcb
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x90(%rsi)
movswl 0x5a(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb697
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbbd5
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x94(%rsi)
movswl 0x68(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb6bb
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbbdf
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x98(%rsi)
movswl 0x6c(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb6df
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbbe9
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0x9c(%rsi)
movswl 0x28(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb703
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbbf3
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xa0(%rsi)
movswl 0x2c(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb727
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbbfd
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xa4(%rsi)
movswl 0x42(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb74b
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbc07
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xa8(%rsi)
movswl 0x4c(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb76f
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbc11
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xac(%rsi)
movswl 0x5c(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb793
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbc1b
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xb0(%rsi)
movswl 0x66(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb7b7
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbc25
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xb4(%rsi)
movswl 0x6e(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb7db
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbc2f
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xb8(%rsi)
movswl 0x78(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb7ff
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbc39
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xbc(%rsi)
movswl 0x2a(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb823
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbc43
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xc0(%rsi)
movswl 0x44(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb847
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbc4d
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xc4(%rsi)
movswl 0x4a(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb86b
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbc57
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xc8(%rsi)
movswl 0x5e(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb88f
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbc61
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xcc(%rsi)
movswl 0x64(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb8b3
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbc6b
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xd0(%rsi)
movswl 0x70(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb8d7
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbc75
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xd4(%rsi)
movswl 0x76(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb8fb
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbc7f
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xd8(%rsi)
movswl 0x7a(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb91f
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbc89
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xdc(%rsi)
movswl 0x46(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb943
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbc93
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xe0(%rsi)
movswl 0x48(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb967
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbc9d
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xe4(%rsi)
movswl 0x60(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb98b
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbca7
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xe8(%rsi)
movswl 0x62(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb9af
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbcb1
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xec(%rsi)
movswl 0x72(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb9d3
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbcbb
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xf0(%rsi)
movswl 0x74(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xb9f7
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbcc5
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xf4(%rsi)
movswl 0x7c(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xba1b
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbccf
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xf8(%rsi)
movswl 0x7e(%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xba3f
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xbcd9
addl $0x38000000, %eax # imm = 0x38000000
movl %eax, 0xfc(%rsi)
retq
testl %edx, %edx
je 0xa3b6
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa3b6
testl %edx, %edx
je 0xa3eb
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa3eb
testl %edx, %edx
je 0xa421
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa421
testl %edx, %edx
je 0xa457
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa457
testl %edx, %edx
je 0xa48d
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa48d
testl %edx, %edx
je 0xa4c3
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa4c3
testl %edx, %edx
je 0xa4f9
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa4f9
testl %edx, %edx
je 0xa52f
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa52f
testl %edx, %edx
je 0xa565
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa565
testl %edx, %edx
je 0xa59b
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa59b
testl %edx, %edx
je 0xa5d1
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa5d1
testl %edx, %edx
je 0xa607
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa607
testl %edx, %edx
je 0xa63d
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa63d
testl %edx, %edx
je 0xa673
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa673
testl %edx, %edx
je 0xa6a9
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa6a9
testl %edx, %edx
je 0xa6df
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa6df
testl %edx, %edx
je 0xa715
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa715
testl %edx, %edx
je 0xa74b
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa74b
testl %edx, %edx
je 0xa781
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa781
testl %edx, %edx
je 0xa7b7
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa7b7
testl %edx, %edx
je 0xa7ed
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa7ed
testl %edx, %edx
je 0xa823
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa823
testl %edx, %edx
je 0xa859
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa859
testl %edx, %edx
je 0xa88f
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa88f
testl %edx, %edx
je 0xa8c5
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa8c5
testl %edx, %edx
je 0xa8fb
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa8fb
testl %edx, %edx
je 0xa931
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa931
testl %edx, %edx
je 0xa967
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa967
testl %edx, %edx
je 0xa99d
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa99d
testl %edx, %edx
je 0xa9d3
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xa9d3
testl %edx, %edx
je 0xaa09
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xaa09
testl %edx, %edx
je 0xaa3f
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xaa3f
testl %edx, %edx
je 0xaa75
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xaa75
testl %edx, %edx
je 0xaaae
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xaaae
testl %edx, %edx
je 0xaae7
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xaae7
testl %edx, %edx
je 0xab20
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xab20
testl %edx, %edx
je 0xab59
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xab59
testl %edx, %edx
je 0xab92
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xab92
testl %edx, %edx
je 0xabcb
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xabcb
testl %edx, %edx
je 0xac04
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xac04
testl %edx, %edx
je 0xac3d
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xac3d
testl %edx, %edx
je 0xac76
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xac76
testl %edx, %edx
je 0xacaf
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xacaf
testl %edx, %edx
je 0xace8
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xace8
testl %edx, %edx
je 0xad21
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xad21
testl %edx, %edx
je 0xad5a
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xad5a
testl %edx, %edx
je 0xad93
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xad93
testl %edx, %edx
je 0xadcc
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xadcc
testl %edx, %edx
je 0xae05
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xae05
testl %edx, %edx
je 0xae3e
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xae3e
testl %edx, %edx
je 0xae77
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xae77
testl %edx, %edx
je 0xaeb0
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xaeb0
testl %edx, %edx
je 0xaee9
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xaee9
testl %edx, %edx
je 0xaf22
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xaf22
testl %edx, %edx
je 0xaf5b
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xaf5b
testl %edx, %edx
je 0xaf94
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xaf94
testl %edx, %edx
je 0xafcd
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xafcd
testl %edx, %edx
je 0xb006
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xb006
testl %edx, %edx
je 0xb03f
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xb03f
testl %edx, %edx
je 0xb078
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xb078
testl %edx, %edx
je 0xb0b1
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xb0b1
testl %edx, %edx
je 0xb0ea
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xb0ea
testl %edx, %edx
je 0xb123
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xb123
testl %edx, %edx
je 0xb15c
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xb15c
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa3b6
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa3eb
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa421
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa457
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa48d
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa4c3
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa4f9
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa52f
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa565
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa59b
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa5d1
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa607
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa63d
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa673
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa6a9
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa6df
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa715
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa74b
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa781
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa7b7
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa7ed
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa823
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa859
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa88f
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa8c5
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa8fb
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa931
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa967
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa99d
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xa9d3
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xaa09
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xaa3f
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xaa75
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xaaae
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xaae7
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xab20
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xab59
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xab92
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xabcb
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xac04
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xac3d
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xac76
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xacaf
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xace8
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xad21
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xad5a
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xad93
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xadcc
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xae05
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xae3e
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xae77
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xaeb0
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xaee9
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xaf22
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xaf5b
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xaf94
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xafcd
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xb006
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xb03f
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xb078
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xb0b1
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xb0ea
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xb123
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xb15c
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/internal_dwa_simd.h
|
dctInverse8x8_scalar
|
static inline void
dctInverse8x8_scalar (float* data, int zeroedRows)
{
const float a = .5f * cosf (3.14159f / 4.0f);
const float b = .5f * cosf (3.14159f / 16.0f);
const float c = .5f * cosf (3.14159f / 8.0f);
const float d = .5f * cosf (3.f * 3.14159f / 16.0f);
const float e = .5f * cosf (5.f * 3.14159f / 16.0f);
const float f = .5f * cosf (3.f * 3.14159f / 8.0f);
const float g = .5f * cosf (7.f * 3.14159f / 16.0f);
float alpha[4], beta[4], theta[4], gamma[4];
float* rowPtr = NULL;
//
// First pass - row wise.
//
// This looks less-compact than the description above in
// an attempt to fold together common sub-expressions.
//
for (int row = 0; row < 8 - zeroedRows; ++row)
{
rowPtr = data + row * 8;
alpha[0] = c * rowPtr[2];
alpha[1] = f * rowPtr[2];
alpha[2] = c * rowPtr[6];
alpha[3] = f * rowPtr[6];
beta[0] = b * rowPtr[1] + d * rowPtr[3] + e * rowPtr[5] + g * rowPtr[7];
beta[1] = d * rowPtr[1] - g * rowPtr[3] - b * rowPtr[5] - e * rowPtr[7];
beta[2] = e * rowPtr[1] - b * rowPtr[3] + g * rowPtr[5] + d * rowPtr[7];
beta[3] = g * rowPtr[1] - e * rowPtr[3] + d * rowPtr[5] - b * rowPtr[7];
theta[0] = a * (rowPtr[0] + rowPtr[4]);
theta[3] = a * (rowPtr[0] - rowPtr[4]);
theta[1] = alpha[0] + alpha[3];
theta[2] = alpha[1] - alpha[2];
gamma[0] = theta[0] + theta[1];
gamma[1] = theta[3] + theta[2];
gamma[2] = theta[3] - theta[2];
gamma[3] = theta[0] - theta[1];
rowPtr[0] = gamma[0] + beta[0];
rowPtr[1] = gamma[1] + beta[1];
rowPtr[2] = gamma[2] + beta[2];
rowPtr[3] = gamma[3] + beta[3];
rowPtr[4] = gamma[3] - beta[3];
rowPtr[5] = gamma[2] - beta[2];
rowPtr[6] = gamma[1] - beta[1];
rowPtr[7] = gamma[0] - beta[0];
}
//
// Second pass - column wise.
//
for (int column = 0; column < 8; ++column)
{
alpha[0] = c * data[16 + column];
alpha[1] = f * data[16 + column];
alpha[2] = c * data[48 + column];
alpha[3] = f * data[48 + column];
beta[0] = b * data[8 + column] + d * data[24 + column] +
e * data[40 + column] + g * data[56 + column];
beta[1] = d * data[8 + column] - g * data[24 + column] -
b * data[40 + column] - e * data[56 + column];
beta[2] = e * data[8 + column] - b * data[24 + column] +
g * data[40 + column] + d * data[56 + column];
beta[3] = g * data[8 + column] - e * data[24 + column] +
d * data[40 + column] - b * data[56 + column];
theta[0] = a * (data[column] + data[32 + column]);
theta[3] = a * (data[column] - data[32 + column]);
theta[1] = alpha[0] + alpha[3];
theta[2] = alpha[1] - alpha[2];
gamma[0] = theta[0] + theta[1];
gamma[1] = theta[3] + theta[2];
gamma[2] = theta[3] - theta[2];
gamma[3] = theta[0] - theta[1];
data[column] = gamma[0] + beta[0];
data[8 + column] = gamma[1] + beta[1];
data[16 + column] = gamma[2] + beta[2];
data[24 + column] = gamma[3] + beta[3];
data[32 + column] = gamma[3] - beta[3];
data[40 + column] = gamma[2] - beta[2];
data[48 + column] = gamma[1] - beta[1];
data[56 + column] = gamma[0] - beta[0];
}
}
|
cmpl $0x8, %esi
je 0xdf01
movl $0x8, %eax
subl %esi, %eax
shlq $0x5, %rax
xorl %ecx, %ecx
movaps 0x67529(%rip), %xmm0 # 0x75320
movsd 0x67531(%rip), %xmm1 # 0x75330
movsd 0x67539(%rip), %xmm2 # 0x75340
movaps 0x67542(%rip), %xmm3 # 0x75350
movaps 0x6754b(%rip), %xmm4 # 0x75360
movaps 0x67554(%rip), %xmm5 # 0x75370
movaps 0x6755d(%rip), %xmm6 # 0x75380
movss (%rdi,%rcx), %xmm8
movss 0x10(%rdi,%rcx), %xmm9
movaps %xmm8, %xmm7
addss %xmm9, %xmm7
subss %xmm9, %xmm8
unpcklps %xmm8, %xmm7 # xmm7 = xmm7[0],xmm8[0],xmm7[1],xmm8[1]
mulps %xmm0, %xmm7
movss 0x8(%rdi,%rcx), %xmm9
shufps $0x0, %xmm9, %xmm9 # xmm9 = xmm9[0,0,0,0]
mulps %xmm1, %xmm9
movss 0x18(%rdi,%rcx), %xmm8
shufps $0x0, %xmm8, %xmm8 # xmm8 = xmm8[0,0,0,0]
mulps %xmm2, %xmm8
movaps %xmm9, %xmm10
subps %xmm8, %xmm10
addps %xmm9, %xmm8
shufps $0x1, %xmm10, %xmm8 # xmm8 = xmm8[1,0],xmm10[0,0]
movss 0xc(%rdi,%rcx), %xmm9
shufps $0x0, %xmm9, %xmm9 # xmm9 = xmm9[0,0,0,0]
mulps %xmm3, %xmm9
movss 0x4(%rdi,%rcx), %xmm10
shufps $0x0, %xmm10, %xmm10 # xmm10 = xmm10[0,0,0,0]
mulps %xmm4, %xmm10
addps %xmm9, %xmm10
movss 0x14(%rdi,%rcx), %xmm9
shufps $0x0, %xmm9, %xmm9 # xmm9 = xmm9[0,0,0,0]
mulps %xmm5, %xmm9
addps %xmm10, %xmm9
movss 0x1c(%rdi,%rcx), %xmm10
shufps $0x0, %xmm10, %xmm10 # xmm10 = xmm10[0,0,0,0]
mulps %xmm6, %xmm10
addps %xmm9, %xmm10
shufps $0x24, %xmm8, %xmm9 # xmm9 = xmm9[0,1],xmm8[2,0]
shufps $0x18, %xmm7, %xmm8 # xmm8 = xmm8[0,2],xmm7[1,0]
addps %xmm8, %xmm9
subps %xmm8, %xmm7
shufps $0x1b, %xmm7, %xmm9 # xmm9 = xmm9[3,2],xmm7[1,0]
movaps %xmm10, %xmm7
addps %xmm9, %xmm7
movups %xmm7, (%rdi,%rcx)
subps %xmm10, %xmm9
shufps $0x1b, %xmm9, %xmm9 # xmm9 = xmm9[3,2,1,0]
movups %xmm9, 0x10(%rdi,%rcx)
addq $0x20, %rcx
cmpq %rcx, %rax
jne 0xde23
movq $-0x8, %rax
movaps 0x674a1(%rip), %xmm2 # 0x753b0
movaps 0x674ca(%rip), %xmm5 # 0x753e0
movaps 0x674e3(%rip), %xmm7 # 0x75400
movaps 0x674eb(%rip), %xmm8 # 0x75410
movaps 0x674f3(%rip), %xmm9 # 0x75420
movups 0x40(%rdi,%rax,4), %xmm1
movups 0x60(%rdi,%rax,4), %xmm11
movups 0x80(%rdi,%rax,4), %xmm3
movaps %xmm11, %xmm0
movaps 0x67445(%rip), %xmm4 # 0x75390
mulps %xmm4, %xmm0
movaps 0x6744a(%rip), %xmm10 # 0x753a0
mulps %xmm10, %xmm11
movups 0xe0(%rdi,%rax,4), %xmm12
movaps %xmm12, %xmm6
mulps %xmm4, %xmm6
subps %xmm6, %xmm11
mulps %xmm10, %xmm12
addps %xmm0, %xmm12
movaps %xmm3, %xmm0
mulps %xmm2, %xmm0
movaps %xmm1, %xmm6
mulps 0x6743a(%rip), %xmm6 # 0x753c0
addps %xmm0, %xmm6
movups 0xc0(%rdi,%rax,4), %xmm4
movaps %xmm4, %xmm14
movaps 0x67434(%rip), %xmm0 # 0x753d0
mulps %xmm0, %xmm14
addps %xmm6, %xmm14
movups 0x100(%rdi,%rax,4), %xmm13
movaps %xmm13, %xmm10
mulps %xmm5, %xmm10
addps %xmm14, %xmm10
movaps %xmm3, %xmm6
mulps 0x6742d(%rip), %xmm6 # 0x753f0
movaps %xmm1, %xmm14
mulps %xmm2, %xmm14
addps %xmm6, %xmm14
movaps %xmm4, %xmm6
mulps %xmm7, %xmm6
addps %xmm14, %xmm6
movaps %xmm13, %xmm14
mulps %xmm8, %xmm14
addps %xmm6, %xmm14
movaps %xmm3, %xmm6
mulps %xmm7, %xmm6
movaps %xmm1, %xmm15
mulps %xmm0, %xmm15
addps %xmm6, %xmm15
movaps %xmm4, %xmm0
mulps %xmm5, %xmm0
addps %xmm15, %xmm0
movaps %xmm13, %xmm6
mulps %xmm2, %xmm6
addps %xmm0, %xmm6
mulps %xmm8, %xmm3
mulps %xmm5, %xmm1
addps %xmm3, %xmm1
movups 0x20(%rdi,%rax,4), %xmm3
mulps %xmm2, %xmm4
addps %xmm1, %xmm4
mulps %xmm7, %xmm13
addps %xmm4, %xmm13
movups 0xa0(%rdi,%rax,4), %xmm0
movaps %xmm3, %xmm1
addps %xmm0, %xmm1
mulps %xmm9, %xmm1
subps %xmm0, %xmm3
mulps %xmm9, %xmm3
movaps %xmm11, %xmm0
addps %xmm3, %xmm0
subps %xmm11, %xmm3
movaps %xmm12, %xmm4
addps %xmm1, %xmm4
subps %xmm12, %xmm1
movaps %xmm10, %xmm11
addps %xmm4, %xmm11
movups %xmm11, 0x20(%rdi,%rax,4)
movaps %xmm14, %xmm11
addps %xmm0, %xmm11
movups %xmm11, 0x40(%rdi,%rax,4)
movaps %xmm6, %xmm11
addps %xmm3, %xmm11
movups %xmm11, 0x60(%rdi,%rax,4)
movaps %xmm13, %xmm11
addps %xmm1, %xmm11
movups %xmm11, 0x80(%rdi,%rax,4)
subps %xmm13, %xmm1
movups %xmm1, 0xa0(%rdi,%rax,4)
subps %xmm6, %xmm3
movups %xmm3, 0xc0(%rdi,%rax,4)
subps %xmm14, %xmm0
movups %xmm0, 0xe0(%rdi,%rax,4)
subps %xmm10, %xmm4
movups %xmm4, 0x100(%rdi,%rax,4)
addq $0x4, %rax
jne 0xdf2d
retq
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/internal_dwa_simd.h
|
DwaCompressor_setupChannelData
|
exr_result_t
DwaCompressor_setupChannelData (DwaCompressor* me)
{
uint8_t* planarUncBuffer[NUM_COMPRESSOR_SCHEMES];
for (int i = 0; i < NUM_COMPRESSOR_SCHEMES; ++i)
{
planarUncBuffer[i] = 0;
if (me->_planarUncBuffer[i])
planarUncBuffer[i] = me->_planarUncBuffer[i];
}
for (int c = 0; c < me->_numChannels; ++c)
{
ChannelData* cd = me->_channelData + c;
const exr_coding_channel_info_t* curc = cd->chan;
size_t uncSize;
uncSize = (size_t) curc->width * (size_t) curc->height *
(size_t) curc->bytes_per_element;
cd->planarUncSize = uncSize;
cd->planarUncBuffer = planarUncBuffer[cd->compression];
cd->planarUncBufferEnd = cd->planarUncBuffer;
cd->planarUncRle[0] = cd->planarUncBuffer;
cd->planarUncRleEnd[0] = cd->planarUncRle[0];
if (!cd->planarUncBuffer)
{
for (int byte = 1; byte < curc->bytes_per_element; ++byte)
{
cd->planarUncRle[byte] = 0;
cd->planarUncRleEnd[byte] = 0;
}
}
else
{
for (int byte = 1; byte < curc->bytes_per_element; ++byte)
{
cd->planarUncRle[byte] =
cd->planarUncRle[byte - 1] + curc->width * curc->height;
cd->planarUncRleEnd[byte] = cd->planarUncRle[byte];
}
}
cd->planarUncType = (exr_pixel_type_t) curc->data_type;
if (cd->compression == LOSSY_DCT)
{
cd->planarUncType = EXR_PIXEL_FLOAT;
}
else { planarUncBuffer[cd->compression] += uncSize; }
}
return EXR_ERR_SUCCESS;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %eax, %eax
movq 0x88(%rdi,%rax,8), %rcx
movq %rcx, -0x18(%rsp,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0xefd0
movslq 0x28(%rdi), %rax
movq %rax, -0x20(%rsp)
testq %rax, %rax
jle 0xf0f7
movl $0x200, %ecx # imm = 0x200
xorl %edx, %edx
xorl %esi, %esi
movq 0x30(%rdi), %r8
leaq (%rsi,%rsi,8), %r10
shlq $0x6, %r10
movq 0x1c0(%r8,%r10), %r11
movslq 0xc(%r11), %r12
movslq 0x8(%r11), %r13
movq %r13, %r9
imulq %r12, %r9
movsbq 0x19(%r11), %r15
imulq %r15, %r9
movq %r9, 0x218(%r8,%r10)
movl 0x224(%r8,%r10), %ebx
movq -0x18(%rsp,%rbx,8), %r14
movq %r14, 0x1c8(%r8,%r10)
movq %r14, 0x1d0(%r8,%r10)
movq %r14, 0x1d8(%r8,%r10)
movq %r14, 0x1f8(%r8,%r10)
testq %r14, %r14
je 0xf098
cmpb $0x2, %r15b
jl 0xf0b9
imull %r12d, %r13d
movslq %r13d, %r12
leaq (%r14,%r12), %r13
leaq (%r8,%rcx), %rbp
decq %r15
xorl %eax, %eax
movq %r13, -0x20(%rbp,%rax,8)
movq %r13, (%rbp,%rax,8)
addq %r12, %r13
incq %rax
cmpq %rax, %r15
jne 0xf081
jmp 0xf0b9
cmpb $0x2, %r15b
jl 0xf0b9
leaq (%r8,%rcx), %rax
decq %r15
xorl %r12d, %r12d
movq %rdx, -0x20(%rax,%r12,8)
movq %rdx, (%rax,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0xf0a8
addq %r10, %r8
movzwl 0x1a(%r11), %eax
movl %eax, 0x228(%r8)
cmpl $0x1, %ebx
jne 0xf0da
movl $0x2, 0x228(%r8)
jmp 0xf0e2
addq %r9, %r14
movq %r14, -0x18(%rsp,%rbx,8)
incq %rsi
addq $0x240, %rcx # imm = 0x240
cmpq -0x20(%rsp), %rsi
jne 0xf001
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/internal_dwa_compressor.h
|
LossyDctEncoder_execute
|
exr_result_t
LossyDctEncoder_execute (
void* (*alloc_fn) (size_t), void (*free_fn) (void*), LossyDctEncoder* e)
{
int numComp = e->_channel_encode_data_count;
DctCoderChannelData* chanData[3];
int numBlocksX = (int) (ceilf ((float) e->_width / 8.0f));
int numBlocksY = (int) (ceilf ((float) e->_height / 8.0f));
uint16_t halfZigCoef[64];
uint16_t* currAcComp = (uint16_t*) e->_packedAc;
int tmpHalfBufferElements = 0;
uint16_t* tmpHalfBuffer = NULL;
uint16_t* tmpHalfBufferPtr = NULL;
e->_numAcComp = 0;
e->_numDcComp = 0;
//
// Allocate a temp half buffer to quantize into for
// any FLOAT source channels.
//
for (int chan = 0; chan < numComp; ++chan)
{
chanData[chan] = e->_channel_encode_data[chan];
if (chanData[chan]->_type == EXR_PIXEL_FLOAT)
tmpHalfBufferElements += e->_width * e->_height;
}
if (tmpHalfBufferElements)
{
tmpHalfBuffer = (uint16_t*) alloc_fn (
(size_t) tmpHalfBufferElements * sizeof (uint16_t));
if (!tmpHalfBuffer) return EXR_ERR_OUT_OF_MEMORY;
tmpHalfBufferPtr = tmpHalfBuffer;
}
//
// Run over all the float scanlines, quantizing,
// and re-assigning _rowPtr[y]. We need to translate
// FLOAT XDR to HALF XDR.
//
for (int chan = 0; chan < numComp; ++chan)
{
if (chanData[chan]->_type != EXR_PIXEL_FLOAT) continue;
for (int y = 0; y < e->_height; ++y)
{
const float* srcXdr = (const float*) chanData[chan]->_rows[y];
for (int x = 0; x < e->_width; ++x)
{
//
// Clamp to half ranges, instead of just casting. This
// avoids introducing Infs which end up getting zeroed later
//
float src = one_to_native_float (srcXdr[x]);
if (src > 65504.f)
src = 65504.f;
else if (src < -65504.f)
src = -65504.f;
tmpHalfBufferPtr[x] = one_from_native16 (float_to_half (src));
}
chanData[chan]->_rows[y] = (uint8_t*) tmpHalfBufferPtr;
tmpHalfBufferPtr += e->_width;
}
}
//
// Pack DC components together by common plane, so we can get
// a little more out of differencing them. We'll always have
// one component per block, so we can computed offsets.
//
chanData[0]->_dc_comp = (uint16_t*) e->_packedDc;
for (int chan = 1; chan < numComp; ++chan)
chanData[chan]->_dc_comp =
chanData[chan - 1]->_dc_comp + numBlocksX * numBlocksY;
for (int blocky = 0; blocky < numBlocksY; ++blocky)
{
for (int blockx = 0; blockx < numBlocksX; ++blockx)
{
uint16_t h;
const float* restrict quantTable;
const uint16_t* restrict hquantTable;
for (int chan = 0; chan < numComp; ++chan)
{
//
// Break the source into 8x8 blocks. If we don't
// fit at the edges, mirror.
//
// Also, convert from linear to nonlinear representation.
// Our source is assumed to be XDR, and we need to convert
// to NATIVE prior to converting to float.
//
// If we're converting linear -> nonlinear, assume that the
// XDR -> NATIVE conversion is built into the lookup. Otherwise,
// we'll need to explicitly do it.
//
for (int y = 0; y < 8; ++y)
{
for (int x = 0; x < 8; ++x)
{
int vx = 8 * blockx + x;
int vy = 8 * blocky + y;
if (vx >= e->_width)
vx = e->_width - (vx - (e->_width - 1));
if (vx < 0) vx = e->_width - 1;
if (vy >= e->_height)
vy = e->_height - (vy - (e->_height - 1));
if (vy < 0) vy = e->_height - 1;
h = ((const uint16_t*) (chanData[chan]->_rows)[vy])[vx];
if (e->_toNonlinear) { h = e->_toNonlinear[h]; }
else { h = one_to_native16 (h); }
chanData[chan]->_dctData[y * 8 + x] = half_to_float (h);
} // x
} // y
} // chan
//
// Color space conversion
//
if (numComp == 3)
{
csc709Forward64 (
chanData[0]->_dctData,
chanData[1]->_dctData,
chanData[2]->_dctData);
}
quantTable = e->_quantTableY;
hquantTable = e->_hquantTableY;
for (int chan = 0; chan < numComp; ++chan)
{
//
// Forward DCT
//
dctForward8x8 (chanData[chan]->_dctData);
//
// Quantize to half, zigzag, and convert to XDR
//
quantizeCoeffAndZigXDR (halfZigCoef, chanData[chan]->_dctData,
quantTable, hquantTable);
//
// Save the DC component separately, to be compressed on
// its own.
//
*(chanData[chan]->_dc_comp)++ = halfZigCoef[0];
e->_numDcComp++;
//
// Then RLE the AC components (which will record the count
// of the resulting number of items)
//
LossyDctEncoder_rleAc (e, halfZigCoef, &currAcComp);
quantTable = e->_quantTableCbCr;
hquantTable = e->_hquantTableCbCr;
} // chan
} // blockx
} // blocky
if (tmpHalfBuffer) free_fn (tmpHalfBuffer);
return EXR_ERR_SUCCESS;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r12
movq %rsi, 0x78(%rsp)
movq %rdi, %rbx
movl 0x34(%rdx), %r15d
cvtsi2ss %r15d, %xmm0
movslq 0x30(%rdx), %r13
movl 0x38(%rdx), %r14d
mulss 0x663ae(%rip), %xmm0 # 0x75598
callq 0x4240
movss %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2ss %r14d, %xmm0
mulss 0x66394(%rip), %xmm0 # 0x75598
callq 0x4240
cvttss2si (%rsp), %eax
movl %eax, 0x10(%rsp)
cvttss2si %xmm0, %edx
movq 0x40(%r12), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r12)
testq %r13, %r13
movq %r12, 0x20(%rsp)
movq %r13, 0x28(%rsp)
jle 0xf2a4
movl %edx, (%rsp)
addq $0x18, %r12
imull %r15d, %r14d
leaq (,%r13,8), %rdx
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
callq 0x4290
xorl %edx, %edx
xorl %eax, %eax
movq (%r12,%rax,8), %rcx
cmpl $0x2, 0x1a0(%rcx)
movl $0x0, %ecx
cmovel %r14d, %ecx
addl %ecx, %edx
incq %rax
cmpq %rax, %r13
jne 0xf25c
testl %edx, %edx
je 0xf2ba
movslq %edx, %rdi
addq %rdi, %rdi
callq *%rbx
testq %rax, %rax
movq 0x20(%rsp), %r12
movq 0x28(%rsp), %r11
movq 0x8(%rsp), %r8
jne 0xf2cb
movl $0x1, %ebx
jmp 0x10231
movq $0x0, 0x58(%rsp)
movq %r13, %r11
movq 0x8(%rsp), %r8
jmp 0xf4b4
xorl %eax, %eax
movq 0x20(%rsp), %r12
movq 0x28(%rsp), %r11
movq 0x8(%rsp), %r8
testl %r11d, %r11d
movq %rax, 0x58(%rsp)
jle 0xf4b1
movss 0x662bf(%rip), %xmm0 # 0x755a0
movss 0x662bb(%rip), %xmm1 # 0x755a4
movq %rax, %rdx
xorl %eax, %eax
movq 0x40(%rsp,%rax,8), %rsi
cmpl $0x2, 0x1a0(%rsi)
jne 0xf448
movslq 0x38(%r12), %rdi
testq %rdi, %rdi
jle 0xf448
movl 0x34(%r12), %r8d
movslq %r8d, %r9
addq %r9, %r9
xorl %r10d, %r10d
movq 0x188(%rsi), %r11
testl %r8d, %r8d
jle 0xf435
movq (%r11,%r10,8), %rbx
xorl %r14d, %r14d
movss (%rbx,%r14,4), %xmm3
ucomiss %xmm0, %xmm3
movaps %xmm0, %xmm2
ja 0xf34c
ucomiss %xmm3, %xmm1
movaps %xmm3, %xmm2
jbe 0xf34c
movaps %xmm1, %xmm2
movd %xmm2, %r15d
movl %r15d, %r12d
andl $0x7fffffff, %r12d # imm = 0x7FFFFFFF
shrl $0x10, %r15d
andl $0x8000, %r15d # imm = 0x8000
cmpl $0x38800000, %r12d # imm = 0x38800000
jb 0xf3a1
cmpl $0x7f800000, %r12d # imm = 0x7F800000
jae 0xf404
cmpl $0x477ff000, %r12d # imm = 0x477FF000
jae 0xf42c
btl $0xd, %r12d
adcl $0x8000fff, %r12d # imm = 0x8000FFF
shrl $0xd, %r12d
orl %r15d, %r12d
movl %r12d, %r15d
jmp 0xf3f1
cmpl $0x33000001, %r12d # imm = 0x33000001
jb 0xf3f1
movl %r12d, %ebp
shrl $0x17, %ebp
andl $0x7fffff, %r12d # imm = 0x7FFFFF
orl $0x800000, %r12d # imm = 0x800000
leal -0x5e(%rbp), %ecx
movl %r12d, %r13d
shll %cl, %r13d
movb $0x7e, %cl
subb %bpl, %cl
shrl %cl, %r12d
orl %r12d, %r15d
cmpl $0x80000000, %r13d # imm = 0x80000000
ja 0xf3ee
negl %r13d
setno %cl
testb $0x1, %r12b
sete %bpl
orb %cl, %bpl
jne 0xf3f1
incl %r15d
movw %r15w, (%rdx,%r14,2)
incq %r14
cmpq %r14, %r8
jne 0xf333
jmp 0xf435
orl $0x7c00, %r15d # imm = 0x7C00
cmpl $0x7f800000, %r12d # imm = 0x7F800000
je 0xf3f1
shrl $0xd, %r12d
xorl %ecx, %ecx
andl $0x3ff, %r12d # imm = 0x3FF
sete %cl
orl %r12d, %r15d
orl %ecx, %r15d
jmp 0xf3f1
orl $0x7c00, %r15d # imm = 0x7C00
jmp 0xf3f1
movq %rdx, (%r11,%r10,8)
addq %r9, %rdx
incq %r10
cmpq %rdi, %r10
jne 0xf31c
incq %rax
movq 0x28(%rsp), %r11
cmpq %r11, %rax
movq 0x20(%rsp), %r12
movq 0x8(%rsp), %r8
jne 0xf2ee
movq 0x48(%r12), %rcx
movq 0x40(%rsp), %rax
movq %rax, 0x60(%rsp)
movq %rcx, 0x180(%rax)
cmpl $0x1, %r11d
je 0xf4ac
movl (%rsp), %eax
imull 0x10(%rsp), %eax
cltq
leaq (%rcx,%rax,2), %rcx
addq %rax, %rax
movl $0x1, %edx
movq 0x40(%rsp,%rdx,8), %rsi
movq %rcx, 0x180(%rsi)
incq %rdx
addq %rax, %rcx
cmpq %rdx, %r11
jne 0xf495
movl (%rsp), %edx
jmp 0xf4ca
movl (%rsp), %edx
movq 0x48(%r12), %rax
movq 0x40(%rsp), %rcx
movq %rcx, 0x60(%rsp)
movq %rax, 0x180(%rcx)
testl %edx, %edx
jle 0x10221
leaq 0x8(%r12), %rax
movq %rax, 0xd8(%rsp)
leaq 0x50(%r12), %rax
movq %rax, 0x98(%rsp)
leaq 0x150(%r12), %rax
movq %rax, 0x90(%rsp)
leaq 0x1d0(%r12), %rax
movq %rax, 0xd0(%rsp)
leaq 0x2d0(%r12), %rax
movq %rax, 0xc8(%rsp)
movl %edx, %eax
movq %rax, 0x80(%rsp)
movl 0x10(%rsp), %eax
movq %rax, 0xb0(%rsp)
xorl %eax, %eax
movss 0x6606c(%rip), %xmm5 # 0x755a8
movss 0x66068(%rip), %xmm6 # 0x755ac
movss 0x66064(%rip), %xmm7 # 0x755b0
movss 0x6605f(%rip), %xmm8 # 0x755b4
movss 0x6605a(%rip), %xmm9 # 0x755b8
movss 0x66055(%rip), %xmm10 # 0x755bc
movss 0x66050(%rip), %xmm11 # 0x755c0
cmpl $0x0, 0x10(%rsp)
movq %rax, 0x88(%rsp)
jle 0x10208
movq 0x48(%rsp), %rcx
movq %rcx, 0xa8(%rsp)
movq 0x50(%rsp), %rcx
movq %rcx, 0xa0(%rsp)
leaq (,%rax,8), %rax
movq %rax, 0xe8(%rsp)
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
xorl %r15d, %r15d
xorl %eax, %eax
movq %rax, 0xb8(%rsp)
testl %r11d, %r11d
movq %rcx, 0xc0(%rsp)
jle 0x101e0
movq %r8, 0x8(%rsp)
movl 0x34(%r12), %eax
leal -0x1(%rax), %edx
movl 0x38(%r12), %esi
leal (%rsi,%rsi), %edi
movl %edi, (%rsp)
movq %rsi, %r8
decl %esi
movl %esi, 0x4(%rsp)
movq (%r12), %r9
leal (%rcx,%rax,2), %r10d
xorl %ecx, %ecx
movq %rcx, 0x18(%rsp)
movq 0x40(%rsp,%rcx,8), %rbx
movq 0x188(%rbx), %r14
xorl %r12d, %r12d
movq 0xe8(%rsp), %rcx
addl %r12d, %ecx
movl %ecx, %esi
notl %esi
addl (%rsp), %esi
cmpl %ecx, %r8d
cmovgl %ecx, %esi
testl %esi, %esi
cmovsl 0x4(%rsp), %esi
movslq %esi, %rcx
movq (%r14,%rcx,8), %r13
movl %r10d, %ebp
xorl %r11d, %r11d
leal (%r15,%r11), %ecx
cmpl %ecx, %eax
cmovlel %ebp, %ecx
testl %ecx, %ecx
cmovsl %edx, %ecx
movslq %ecx, %rcx
movzwl (%r13,%rcx,2), %ecx
testq %r9, %r9
je 0xf65f
movzwl %cx, %ecx
movzwl (%r9,%rcx,2), %ecx
movl %ecx, %edi
shll $0xd, %edi
andl $0xfffe000, %edi # imm = 0xFFFE000
movswl %cx, %esi
andl $0x80000000, %esi # imm = 0x80000000
cmpl $0x800000, %edi # imm = 0x800000
jb 0xf69c
orl %edi, %esi
cmpl $0xf7fffff, %edi # imm = 0xF7FFFFF
ja 0xf6ba
addl $0x38000000, %esi # imm = 0x38000000
movl %esi, (%rbx,%r11,4)
incq %r11
decl %ebp
cmpq $0x8, %r11
jne 0xf63b
jmp 0xf6c2
testl %edi, %edi
je 0xf68b
bsrl %edi, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edi
orl %edi, %esi
orl $0x38800000, %esi # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %esi
jmp 0xf68b
orl $0x7f800000, %esi # imm = 0x7F800000
jmp 0xf68b
incq %r12
addq $0x20, %rbx
cmpq $0x8, %r12
jne 0xf60f
movq 0x18(%rsp), %rcx
incq %rcx
movq 0x28(%rsp), %r11
cmpq %r11, %rcx
jne 0xf5fb
cmpl $0x3, %r11d
movq 0x60(%rsp), %rcx
movq 0xa8(%rsp), %rdx
movq 0xa0(%rsp), %rsi
jne 0xf788
xorl %eax, %eax
movss (%rcx,%rax,4), %xmm0
movss (%rdx,%rax,4), %xmm2
movss (%rsi,%rax,4), %xmm1
movaps %xmm2, %xmm3
mulss %xmm5, %xmm3
movaps %xmm0, %xmm4
mulss %xmm6, %xmm4
addss %xmm3, %xmm4
movaps %xmm1, %xmm3
mulss %xmm7, %xmm3
addss %xmm4, %xmm3
movss %xmm3, (%rcx,%rax,4)
movaps %xmm2, %xmm3
mulss %xmm8, %xmm3
movaps %xmm0, %xmm4
mulss %xmm9, %xmm4
addss %xmm3, %xmm4
movaps %xmm1, %xmm3
mulss %xmm10, %xmm3
addss %xmm4, %xmm3
movss %xmm3, (%rdx,%rax,4)
mulss %xmm11, %xmm2
mulss %xmm10, %xmm0
addss %xmm2, %xmm0
mulss 0x65e4e(%rip), %xmm1 # 0x755c4
addss %xmm0, %xmm1
movss %xmm1, (%rsi,%rax,4)
incq %rax
cmpq $0x40, %rax
jne 0xf70a
testl %r11d, %r11d
movq 0x8(%rsp), %r8
jle 0x101db
xorl %eax, %eax
movq 0x90(%rsp), %rcx
movq %rcx, 0x70(%rsp)
movq 0x98(%rsp), %rcx
movq %rcx, 0x68(%rsp)
movq %r8, 0x8(%rsp)
movq %rax, 0xe0(%rsp)
movq 0x40(%rsp,%rax,8), %r14
movb $0x1, %al
movb $0x1, %cl
xorl %edx, %edx
movaps 0x65cae(%rip), %xmm13 # 0x75480
movaps 0x65cb6(%rip), %xmm14 # 0x75490
movaps 0x65cbe(%rip), %xmm15 # 0x754a0
movaps 0x65c46(%rip), %xmm11 # 0x75430
shlq $0x4, %rdx
movaps 0xe0(%r14,%rdx), %xmm6
movaps (%r14,%rdx), %xmm2
movaps 0x20(%r14,%rdx), %xmm4
movaps 0x40(%r14,%rdx), %xmm8
movaps 0x60(%r14,%rdx), %xmm3
movaps %xmm2, %xmm5
addps %xmm6, %xmm5
movaps %xmm4, %xmm0
addps %xmm8, %xmm0
movaps 0x80(%r14,%rdx), %xmm9
movaps %xmm3, %xmm7
addps %xmm9, %xmm7
movaps 0xa0(%r14,%rdx), %xmm1
movaps 0xc0(%r14,%rdx), %xmm10
subps %xmm6, %xmm2
movaps %xmm1, %xmm6
addps %xmm10, %xmm6
subps %xmm8, %xmm4
subps %xmm9, %xmm3
subps %xmm10, %xmm1
movaps %xmm5, %xmm8
addps %xmm7, %xmm8
movaps %xmm0, %xmm9
addps %xmm6, %xmm9
mulps %xmm11, %xmm8
mulps %xmm11, %xmm9
movaps %xmm8, %xmm10
addps %xmm9, %xmm10
subps %xmm9, %xmm8
movaps 0x65bc1(%rip), %xmm9 # 0x75440
mulps %xmm9, %xmm10
movaps %xmm10, (%r14,%rdx)
mulps %xmm9, %xmm8
movaps %xmm8, 0x80(%r14,%rdx)
movaps %xmm4, %xmm8
subps %xmm1, %xmm8
subps %xmm7, %xmm5
movaps %xmm8, %xmm7
movaps 0x65ba4(%rip), %xmm10 # 0x75450
mulps %xmm10, %xmm7
movaps %xmm5, %xmm9
movaps 0x65ba4(%rip), %xmm12 # 0x75460
mulps %xmm12, %xmm9
addps %xmm7, %xmm9
movaps %xmm9, 0x40(%r14,%rdx)
mulps %xmm10, %xmm5
mulps %xmm12, %xmm8
subps %xmm8, %xmm5
movaps %xmm5, 0xc0(%r14,%rdx)
subps %xmm6, %xmm0
mulps %xmm11, %xmm0
addps %xmm4, %xmm1
mulps 0x65b80(%rip), %xmm1 # 0x75470
movaps %xmm2, %xmm4
subps %xmm0, %xmm4
movaps %xmm3, %xmm5
addps %xmm1, %xmm5
movaps %xmm4, %xmm6
mulps %xmm13, %xmm6
movaps %xmm5, %xmm7
mulps %xmm14, %xmm7
subps %xmm7, %xmm6
movaps %xmm6, 0x60(%r14,%rdx)
mulps %xmm14, %xmm4
mulps %xmm13, %xmm5
addps %xmm4, %xmm5
movaps %xmm5, 0xa0(%r14,%rdx)
addps %xmm2, %xmm0
subps %xmm3, %xmm1
movaps %xmm0, %xmm2
mulps %xmm15, %xmm2
movaps %xmm1, %xmm3
movaps 0x65b72(%rip), %xmm4 # 0x754b0
mulps %xmm4, %xmm3
subps %xmm3, %xmm2
movaps %xmm2, 0x20(%r14,%rdx)
mulps %xmm4, %xmm0
mulps %xmm15, %xmm1
addps %xmm0, %xmm1
movaps %xmm1, 0xe0(%r14,%rdx)
movl $0x1, %edx
testb $0x1, %cl
movl $0x0, %ecx
jne 0xf7ea
movaps (%r14), %xmm2
movaps 0x10(%r14), %xmm0
movaps 0x20(%r14), %xmm3
movaps 0x30(%r14), %xmm1
movaps %xmm2, %xmm4
movlhps %xmm3, %xmm4 # xmm4 = xmm4[0],xmm3[0]
movaps 0x40(%r14), %xmm5
movaps 0x60(%r14), %xmm6
movaps %xmm5, %xmm7
movlhps %xmm6, %xmm7 # xmm7 = xmm7[0],xmm6[0]
unpckhpd %xmm6, %xmm5 # xmm5 = xmm5[1],xmm6[1]
unpckhpd %xmm3, %xmm2 # xmm2 = xmm2[1],xmm3[1]
movaps 0x90(%r14), %xmm3
movaps 0xb0(%r14), %xmm6
movaps %xmm3, %xmm8
movlhps %xmm6, %xmm8 # xmm8 = xmm8[0],xmm6[0]
movaps 0xd0(%r14), %xmm9
movaps 0xf0(%r14), %xmm10
movaps %xmm9, %xmm11
movlhps %xmm10, %xmm11 # xmm11 = xmm11[0],xmm10[0]
unpckhpd %xmm6, %xmm3 # xmm3 = xmm3[1],xmm6[1]
unpckhpd %xmm10, %xmm9 # xmm9 = xmm9[1],xmm10[1]
movaps %xmm4, %xmm6
shufps $0x88, %xmm7, %xmm6 # xmm6 = xmm6[0,2],xmm7[0,2]
movaps %xmm6, (%r14)
movaps %xmm2, %xmm6
shufps $0x88, %xmm5, %xmm6 # xmm6 = xmm6[0,2],xmm5[0,2]
movaps %xmm6, 0x40(%r14)
shufps $0xdd, %xmm7, %xmm4 # xmm4 = xmm4[1,3],xmm7[1,3]
movaps %xmm4, 0x20(%r14)
shufps $0xdd, %xmm5, %xmm2 # xmm2 = xmm2[1,3],xmm5[1,3]
movaps %xmm2, 0x60(%r14)
movaps %xmm8, %xmm2
shufps $0x88, %xmm11, %xmm2 # xmm2 = xmm2[0,2],xmm11[0,2]
movaps %xmm2, 0x90(%r14)
movaps %xmm3, %xmm2
shufps $0x88, %xmm9, %xmm2 # xmm2 = xmm2[0,2],xmm9[0,2]
movaps %xmm2, 0xd0(%r14)
shufps $0xdd, %xmm11, %xmm8 # xmm8 = xmm8[1,3],xmm11[1,3]
movaps %xmm8, 0xb0(%r14)
shufps $0xdd, %xmm9, %xmm3 # xmm3 = xmm3[1,3],xmm9[1,3]
movaps %xmm3, 0xf0(%r14)
movaps %xmm0, %xmm2
movlhps %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
movaps 0x50(%r14), %xmm3
movaps 0x70(%r14), %xmm4
movaps %xmm3, %xmm5
movlhps %xmm4, %xmm5 # xmm5 = xmm5[0],xmm4[0]
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
unpckhpd %xmm4, %xmm3 # xmm3 = xmm3[1],xmm4[1]
movaps 0x80(%r14), %xmm1
movaps 0xa0(%r14), %xmm4
movaps %xmm1, %xmm6
movlhps %xmm4, %xmm6 # xmm6 = xmm6[0],xmm4[0]
movaps 0xc0(%r14), %xmm7
movaps 0xe0(%r14), %xmm8
movaps %xmm7, %xmm9
movlhps %xmm8, %xmm9 # xmm9 = xmm9[0],xmm8[0]
unpckhpd %xmm4, %xmm1 # xmm1 = xmm1[1],xmm4[1]
unpckhpd %xmm8, %xmm7 # xmm7 = xmm7[1],xmm8[1]
movaps %xmm2, %xmm4
shufps $0x88, %xmm5, %xmm4 # xmm4 = xmm4[0,2],xmm5[0,2]
movaps %xmm4, 0x80(%r14)
movaps %xmm0, %xmm4
shufps $0x88, %xmm3, %xmm4 # xmm4 = xmm4[0,2],xmm3[0,2]
movaps %xmm4, 0xc0(%r14)
shufps $0xdd, %xmm5, %xmm2 # xmm2 = xmm2[1,3],xmm5[1,3]
movaps %xmm2, 0xa0(%r14)
shufps $0xdd, %xmm3, %xmm0 # xmm0 = xmm0[1,3],xmm3[1,3]
movaps %xmm0, 0xe0(%r14)
movaps %xmm6, %xmm0
shufps $0x88, %xmm9, %xmm0 # xmm0 = xmm0[0,2],xmm9[0,2]
movaps %xmm0, 0x10(%r14)
movaps %xmm1, %xmm0
shufps $0x88, %xmm7, %xmm0 # xmm0 = xmm0[0,2],xmm7[0,2]
movaps %xmm0, 0x50(%r14)
shufps $0xdd, %xmm9, %xmm6 # xmm6 = xmm6[1,3],xmm9[1,3]
movaps %xmm6, 0x30(%r14)
shufps $0xdd, %xmm7, %xmm1 # xmm1 = xmm1[1,3],xmm7[1,3]
movaps %xmm1, 0x70(%r14)
testb $0x1, %al
movl $0x0, %eax
jne 0xf7c6
movq $-0x4, %rbp
movl 0x10(%r14,%rbp,4), %eax
movl %eax, %edx
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
shrl $0x10, %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x38800000, %edx # imm = 0x38800000
jb 0xfb51
cmpl $0x7f800000, %edx # imm = 0x7F800000
jae 0xffdd
cmpl $0x477ff000, %edx # imm = 0x477FF000
jae 0x10086
btl $0xd, %edx
adcl $0x8000fff, %edx # imm = 0x8000FFF
shrl $0xd, %edx
orl %eax, %edx
movl %edx, %eax
jmp 0xfb93
cmpl $0x33000001, %edx # imm = 0x33000001
jb 0xfb93
movl %edx, %edi
shrl $0x17, %edi
andl $0x7fffff, %edx # imm = 0x7FFFFF
orl $0x800000, %edx # imm = 0x800000
leal -0x5e(%rdi), %ecx
movl %edx, %esi
shll %cl, %esi
movb $0x7e, %cl
subb %dil, %cl
shrl %cl, %edx
orl %edx, %eax
cmpl $0x80000000, %esi # imm = 0x80000000
ja 0xfb91
negl %esi
setno %cl
testb $0x1, %dl
sete %dl
orb %cl, %dl
jne 0xfb93
incl %eax
movl 0x14(%r14,%rbp,4), %r12d
movl %r12d, %edx
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
shrl $0x10, %r12d
andl $0x8000, %r12d # imm = 0x8000
cmpl $0x38800000, %edx # imm = 0x38800000
jb 0xfbe1
cmpl $0x7f800000, %edx # imm = 0x7F800000
jae 0x10005
cmpl $0x477ff000, %edx # imm = 0x477FF000
jae 0x10090
btl $0xd, %edx
adcl $0x8000fff, %edx # imm = 0x8000FFF
shrl $0xd, %edx
orl %r12d, %edx
movl %edx, %r12d
jmp 0xfc25
cmpl $0x33000001, %edx # imm = 0x33000001
jb 0xfc25
movl %edx, %edi
shrl $0x17, %edi
andl $0x7fffff, %edx # imm = 0x7FFFFF
orl $0x800000, %edx # imm = 0x800000
leal -0x5e(%rdi), %ecx
movl %edx, %esi
shll %cl, %esi
movb $0x7e, %cl
subb %dil, %cl
shrl %cl, %edx
orl %edx, %r12d
cmpl $0x80000000, %esi # imm = 0x80000000
ja 0xfc22
negl %esi
setno %cl
testb $0x1, %dl
sete %dl
orb %cl, %dl
jne 0xfc25
incl %r12d
movl 0x18(%r14,%rbp,4), %r13d
movl %r13d, %edx
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
shrl $0x10, %r13d
andl $0x8000, %r13d # imm = 0x8000
cmpl $0x38800000, %edx # imm = 0x38800000
jb 0xfc73
cmpl $0x7f800000, %edx # imm = 0x7F800000
jae 0x10031
cmpl $0x477ff000, %edx # imm = 0x477FF000
jae 0x1009c
btl $0xd, %edx
adcl $0x8000fff, %edx # imm = 0x8000FFF
shrl $0xd, %edx
orl %r13d, %edx
movl %edx, %r13d
jmp 0xfcb7
cmpl $0x33000001, %edx # imm = 0x33000001
jb 0xfcb7
movl %edx, %edi
shrl $0x17, %edi
andl $0x7fffff, %edx # imm = 0x7FFFFF
orl $0x800000, %edx # imm = 0x800000
leal -0x5e(%rdi), %ecx
movl %edx, %esi
shll %cl, %esi
movb $0x7e, %cl
subb %dil, %cl
shrl %cl, %edx
orl %edx, %r13d
cmpl $0x80000000, %esi # imm = 0x80000000
ja 0xfcb4
negl %esi
setno %cl
testb $0x1, %dl
sete %dl
orb %cl, %dl
jne 0xfcb7
incl %r13d
movl 0x1c(%r14,%rbp,4), %ebx
movl %ebx, %edx
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
shrl $0x10, %ebx
andl $0x8000, %ebx # imm = 0x8000
cmpl $0x38800000, %edx # imm = 0x38800000
jb 0xfd00
cmpl $0x7f800000, %edx # imm = 0x7F800000
jae 0x1005d
cmpl $0x477ff000, %edx # imm = 0x477FF000
jae 0x100a8
btl $0xd, %edx
adcl $0x8000fff, %edx # imm = 0x8000FFF
shrl $0xd, %edx
orl %ebx, %edx
movl %edx, %ebx
jmp 0xfd42
cmpl $0x33000001, %edx # imm = 0x33000001
jb 0xfd42
movl %edx, %edi
shrl $0x17, %edi
andl $0x7fffff, %edx # imm = 0x7FFFFF
orl $0x800000, %edx # imm = 0x800000
leal -0x5e(%rdi), %ecx
movl %edx, %esi
shll %cl, %esi
movb $0x7e, %cl
subb %dil, %cl
shrl %cl, %edx
orl %edx, %ebx
cmpl $0x80000000, %esi # imm = 0x80000000
ja 0xfd40
negl %esi
setno %cl
testb $0x1, %dl
sete %dl
orb %cl, %dl
jne 0xfd42
incl %ebx
movq 0x68(%rsp), %rcx
movss 0x10(%rcx,%rbp,4), %xmm0
movss 0x14(%rcx,%rbp,4), %xmm3
movss 0x18(%rcx,%rbp,4), %xmm2
movss 0x1c(%rcx,%rbp,4), %xmm1
movq 0x70(%rsp), %rcx
movzwl 0x8(%rcx,%rbp,2), %esi
movzwl 0xa(%rcx,%rbp,2), %edx
movl %edx, 0x18(%rsp)
movzwl 0xc(%rcx,%rbp,2), %edx
movl %edx, 0x4(%rsp)
movzwl 0xe(%rcx,%rbp,2), %ecx
movzwl %ax, %edi
movl %edi, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
movswl %di, %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
movss %xmm1, 0x3c(%rsp)
movl %ecx, (%rsp)
movss %xmm2, 0x38(%rsp)
movss %xmm3, 0x34(%rsp)
jb 0xff13
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xffb3
addl $0x38000000, %eax # imm = 0x38000000
movd %eax, %xmm1
callq 0x10954
movzwl %r12w, %edi
movl %edi, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
movswl %di, %r8d
andl $0x80000000, %r8d # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
movw %ax, 0x16(%rsp)
jb 0xff37
orl %edx, %r8d
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
movss 0x34(%rsp), %xmm0
ja 0xffbd
addl $0x38000000, %r8d # imm = 0x38000000
movl 0x18(%rsp), %esi
movd %r8d, %xmm1
callq 0x10954
movl %eax, %r12d
movzwl %r13w, %edi
movl %edi, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
movswl %di, %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xff65
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
movss 0x38(%rsp), %xmm0
ja 0xffc9
addl $0x38000000, %eax # imm = 0x38000000
movl 0x4(%rsp), %esi
movd %eax, %xmm1
callq 0x10954
movl %eax, %r13d
movzwl %bx, %edi
movl %edi, %edx
shll $0xd, %edx
andl $0xfffe000, %edx # imm = 0xFFFE000
movswl %di, %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x800000, %edx # imm = 0x800000
jb 0xff8f
orl %edx, %eax
cmpl $0xf7fffff, %edx # imm = 0xF7FFFFF
ja 0xffd3
addl $0x38000000, %eax # imm = 0x38000000
movl (%rsp), %esi
movd %eax, %xmm1
movss 0x3c(%rsp), %xmm0
callq 0x10954
leaq 0x859bb(%rip), %rdx # 0x95880
movslq 0x10(%rdx,%rbp,4), %rcx
movzwl 0x16(%rsp), %esi
movw %si, 0xf0(%rsp,%rcx,2)
movslq 0x14(%rdx,%rbp,4), %rcx
movw %r12w, 0xf0(%rsp,%rcx,2)
movslq 0x18(%rdx,%rbp,4), %rcx
movw %r13w, 0xf0(%rsp,%rcx,2)
movslq 0x1c(%rdx,%rbp,4), %rcx
movw %ax, 0xf0(%rsp,%rcx,2)
addq $0x4, %rbp
cmpq $0x3c, %rbp
jb 0xfb09
jmp 0x100b3
testl %edx, %edx
je 0xfdca
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xfdca
testl %edx, %edx
movss 0x34(%rsp), %xmm0
je 0xfe1a
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %r8d
orl $0x38800000, %r8d # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %r8d
jmp 0xfe1a
testl %edx, %edx
movss 0x38(%rsp), %xmm0
je 0xfe67
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xfe67
testl %edx, %edx
je 0xfeac
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $-0x8, %ecx
shll %cl, %edx
orl %edx, %eax
orl $0x38800000, %eax # imm = 0x38800000
shll $0x17, %ecx
subl %ecx, %eax
jmp 0xfeac
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xfdca
orl $0x7f800000, %r8d # imm = 0x7F800000
jmp 0xfe1a
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xfe67
orl $0x7f800000, %eax # imm = 0x7F800000
jmp 0xfeac
orl $0x7c00, %eax # imm = 0x7C00
cmpl $0x7f800000, %edx # imm = 0x7F800000
je 0xfb93
shrl $0xd, %edx
xorl %ecx, %ecx
andl $0x3ff, %edx # imm = 0x3FF
sete %cl
orl %edx, %eax
orl %ecx, %eax
jmp 0xfb93
orl $0x7c00, %r12d # imm = 0x7C00
cmpl $0x7f800000, %edx # imm = 0x7F800000
je 0xfc25
shrl $0xd, %edx
xorl %ecx, %ecx
andl $0x3ff, %edx # imm = 0x3FF
sete %cl
orl %edx, %r12d
orl %ecx, %r12d
jmp 0xfc25
orl $0x7c00, %r13d # imm = 0x7C00
cmpl $0x7f800000, %edx # imm = 0x7F800000
je 0xfcb7
shrl $0xd, %edx
xorl %ecx, %ecx
andl $0x3ff, %edx # imm = 0x3FF
sete %cl
orl %edx, %r13d
orl %ecx, %r13d
jmp 0xfcb7
orl $0x7c00, %ebx # imm = 0x7C00
cmpl $0x7f800000, %edx # imm = 0x7F800000
je 0xfd42
shrl $0xd, %edx
xorl %ecx, %ecx
andl $0x3ff, %edx # imm = 0x3FF
sete %cl
orl %edx, %ebx
orl %ecx, %ebx
jmp 0xfd42
orl $0x7c00, %eax # imm = 0x7C00
jmp 0xfb93
orl $0x7c00, %r12d # imm = 0x7C00
jmp 0xfc25
orl $0x7c00, %r13d # imm = 0x7C00
jmp 0xfcb7
orl $0x7c00, %ebx # imm = 0x7C00
jmp 0xfd42
movzwl 0xf0(%rsp), %eax
movq 0x180(%r14), %rcx
leaq 0x2(%rcx), %rdx
movq %rdx, 0x180(%r14)
movw %ax, (%rcx)
movq 0x20(%rsp), %r12
incq 0x10(%r12)
movq 0x8(%r12), %rax
movl $0x1, %ecx
movq 0x28(%rsp), %r11
movq 0x8(%rsp), %r8
movss 0x654b2(%rip), %xmm5 # 0x755a8
movss 0x654ae(%rip), %xmm6 # 0x755ac
movss 0x654aa(%rip), %xmm7 # 0x755b0
movss 0x654a5(%rip), %xmm8 # 0x755b4
movss 0x654a0(%rip), %xmm9 # 0x755b8
movss 0x6549b(%rip), %xmm10 # 0x755bc
movss 0x65496(%rip), %xmm11 # 0x755c0
movl $0xff00, %r9d # imm = 0xFF00
movl %ecx, %edx
movzwl 0xf0(%rsp,%rdx,2), %edi
movl $0x1, %edx
testw %di, %di
jne 0x1018e
cmpl $0x3e, %ecx
ja 0x10178
leal 0x1(%rcx), %esi
movw $0x1, %dx
movl %esi, %edi
cmpw $0x0, 0xf0(%rsp,%rdi,2)
jne 0x10169
incl %edx
movzwl %dx, %esi
addl %ecx, %esi
cmpl $0x40, %esi
jb 0x10150
cmpw $0x1, %dx
jne 0x1017c
xorl %edi, %edi
movl $0x1, %edx
jmp 0x1018e
xorl %edi, %edi
jmp 0x1018e
movl %edx, %edi
orl $0xffffff00, %edi # imm = 0xFFFFFF00
cmpl $0x40, %esi
cmovel %r9d, %edi
movzwl %dx, %edx
movw %di, (%r8)
incq %rax
addl %edx, %ecx
addq $0x2, %r8
cmpl $0x40, %ecx
jb 0x10130
movq 0xd8(%rsp), %rcx
movq %rax, (%rcx)
movq 0xe0(%rsp), %rax
incq %rax
movq 0xc8(%rsp), %rcx
movq %rcx, 0x70(%rsp)
movq 0xd0(%rsp), %rcx
movq %rcx, 0x68(%rsp)
cmpq %r11, %rax
jne 0xf7b2
jmp 0x101e0
movq 0x20(%rsp), %r12
movq 0xb8(%rsp), %rax
incq %rax
addq $0x8, %r15
movq 0xc0(%rsp), %rcx
addl $-0x8, %ecx
cmpq 0xb0(%rsp), %rax
jne 0xf5b7
movq 0x88(%rsp), %rax
incq %rax
cmpq 0x80(%rsp), %rax
jne 0xf570
xorl %ebx, %ebx
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x10231
callq *0x78(%rsp)
movl %ebx, %eax
addq $0x178, %rsp # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/internal_dwa_encoder.h
|
hufCanonicalCodeTable
|
static void
hufCanonicalCodeTable (uint64_t* hcode)
{
uint64_t n[59];
uint64_t c;
//
// For each i from 0 through 58, count the
// number of different codes of length i, and
// store the count in n[i].
//
for (int i = 0; i <= 58; ++i)
n[i] = 0;
for (int i = 0; i < HUF_ENCSIZE; ++i)
n[hcode[i]] += 1;
//
// For each i from 58 through 1, compute the
// numerically lowest code with length i, and
// store that code in n[i].
//
c = 0;
for (int i = 58; i > 0; --i)
{
uint64_t nc = ((c + n[i]) >> 1);
n[i] = c;
c = nc;
}
//
// hcode[i] contains the length, l, of the
// code for symbol i. Assign the next available
// code of length l to the symbol and store both
// l and the code in hcode[i].
//
for (int i = 0; i < HUF_ENCSIZE; ++i)
{
uint64_t l = hcode[i];
if (l > 0) hcode[i] = l | (n[l]++ << 6);
}
}
|
pushq %r14
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, %rbx
movq %rsp, %rdi
xorl %r14d, %r14d
movl $0x1d8, %edx # imm = 0x1D8
xorl %esi, %esi
callq 0x41f0
movq (%rbx,%r14,8), %rax
incq (%rsp,%rax,8)
incq %r14
cmpq $0x10001, %r14 # imm = 0x10001
jne 0x15489
movl $0x3b, %eax
xorl %ecx, %ecx
movq -0x8(%rsp,%rax,8), %rdx
addq %rcx, %rdx
shrq %rdx
movq %rcx, -0x8(%rsp,%rax,8)
decq %rax
movq %rdx, %rcx
cmpq $0x1, %rax
ja 0x154a4
xorl %eax, %eax
movq (%rbx,%rax,8), %rcx
testq %rcx, %rcx
je 0x154e2
movq (%rsp,%rcx,8), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, (%rsp,%rcx,8)
shlq $0x6, %rdx
orq %rcx, %rdx
movq %rdx, (%rbx,%rax,8)
incq %rax
cmpq $0x10001, %rax # imm = 0x10001
jne 0x154c2
addq $0x1d8, %rsp # imm = 0x1D8
popq %rbx
popq %r14
retq
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/internal_huf.c
|
exr_attr_string_init_static_with_length
|
exr_result_t
exr_attr_string_init_static_with_length (
exr_context_t ctxt, exr_attr_string_t* s, const char* v, int32_t len)
{
exr_attr_string_t nil = {0};
if (!ctxt) return EXR_ERR_MISSING_CONTEXT_ARG;
if (len < 0)
return ctxt->print_error (
ctxt,
EXR_ERR_INVALID_ARGUMENT,
"Received request to allocate negative sized string (%d)",
len);
if (!v)
return ctxt->report_error (
ctxt,
EXR_ERR_INVALID_ARGUMENT,
"Invalid static string argument to initialize");
if (!s)
return ctxt->report_error (
ctxt,
EXR_ERR_INVALID_ARGUMENT,
"Invalid reference to string object to initialize");
*s = nil;
s->length = len;
s->str = v;
return EXR_ERR_SUCCESS;
}
|
testq %rdi, %rdi
je 0x1676a
testl %ecx, %ecx
js 0x16770
testq %rdx, %rdx
je 0x16785
testq %rsi, %rsi
je 0x16792
movq $0x0, (%rsi)
movl %ecx, (%rsi)
movq %rdx, 0x8(%rsi)
xorl %eax, %eax
retq
movl $0x2, %eax
retq
movq 0x48(%rdi), %r8
leaq 0x9fac8(%rip), %rdx # 0xb6243
movl $0x3, %esi
xorl %eax, %eax
jmpq *%r8
movq 0x40(%rdi), %rax
leaq 0x9fb1c(%rip), %rdx # 0xb62ac
jmp 0x1679d
movq 0x40(%rdi), %rax
leaq 0x9fade(%rip), %rdx # 0xb627b
movl $0x3, %esi
jmpq *%rax
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/string.c
|
exr_attr_chlist_destroy
|
exr_result_t
exr_attr_chlist_destroy (exr_context_t ctxt, exr_attr_chlist_t* clist)
{
if (!ctxt) return EXR_ERR_MISSING_CONTEXT_ARG;
if (clist)
{
exr_attr_chlist_t nil = {0};
int nc = clist->num_channels;
exr_attr_chlist_entry_t* entries =
EXR_CONST_CAST (exr_attr_chlist_entry_t*, clist->entries);
for (int i = 0; i < nc; ++i)
exr_attr_string_destroy (ctxt, &(entries[i].name));
if (entries) ctxt->free_fn (entries);
*clist = nil;
}
return EXR_ERR_SUCCESS;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x176b7
movq %rsi, %r14
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x176bc
movq %rdi, %r15
movslq (%r14), %rbp
movq 0x8(%r14), %r12
testq %rbp, %rbp
jle 0x176a2
movq %r12, %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x16a09
addq $0x20, %r13
decq %rbp
jne 0x1768e
testq %r12, %r12
je 0x176ae
movq %r12, %rdi
callq *0x60(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
jmp 0x176bc
movl $0x2, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/channel_list.c
|
exr_attr_preview_create
|
exr_result_t
exr_attr_preview_create (
exr_context_t ctxt,
exr_attr_preview_t* p,
uint32_t w,
uint32_t h,
const uint8_t* d)
{
exr_result_t rv = exr_attr_preview_init (ctxt, p, w, h);
if (rv == EXR_ERR_SUCCESS)
{
size_t copybytes = w * h * 4;
if (copybytes > 0)
memcpy (EXR_CONST_CAST (uint8_t*, p->rgba), d, copybytes);
}
return rv;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %r12d
movl %edx, %r15d
movq %rsi, %r14
callq 0x17d38
movl %eax, %ebp
testl %eax, %eax
jne 0x17e67
imull %r12d, %r15d
shll $0x2, %r15d
testl %r15d, %r15d
je 0x17e67
movl %r15d, %edx
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x4290
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/preview.c
|
exr_attr_preview_destroy
|
exr_result_t
exr_attr_preview_destroy (exr_context_t ctxt, exr_attr_preview_t* p)
{
if (!ctxt) return EXR_ERR_MISSING_CONTEXT_ARG;
if (p)
{
exr_attr_preview_t nil = {0};
if (p->rgba && p->alloc_size > 0)
ctxt->free_fn (EXR_CONST_CAST (uint8_t*, p->rgba));
*p = nil;
}
return EXR_ERR_SUCCESS;
}
|
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x17eac
movq %rsi, %r14
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x17eb1
movq %rdi, %rax
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x17e9b
cmpq $0x0, 0x8(%r14)
je 0x17e9b
callq *0x60(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
jmp 0x17eb1
movl $0x2, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/preview.c
|
exr_get_library_version
|
void
exr_get_library_version (int* maj, int* min, int* patch, const char** extra)
{
if (maj) *maj = OPENEXR_VERSION_MAJOR;
if (min) *min = OPENEXR_VERSION_MINOR;
if (patch) *patch = OPENEXR_VERSION_PATCH;
#ifdef OPENEXR_VERSION_EXTRA
if (extra) *extra = OPENEXR_VERSION_EXTRA;
#else
if (extra) *extra = "";
#endif
}
|
testq %rdi, %rdi
je 0x17ec7
movl $0x3, (%rdi)
testq %rsi, %rsi
je 0x17ed2
movl $0x4, (%rsi)
testq %rdx, %rdx
je 0x17edd
movl $0x0, (%rdx)
testq %rcx, %rcx
je 0x17eec
leaq 0x9eb0b(%rip), %rax # 0xb69f4
movq %rax, (%rcx)
retq
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/base.c
|
exr_finish
|
exr_result_t
exr_finish (exr_context_t* pctxt)
{
exr_context_t ctxt;
exr_result_t rv = EXR_ERR_SUCCESS;
if (!pctxt) return EXR_ERR_MISSING_CONTEXT_ARG;
ctxt = *pctxt;
if (ctxt)
{
int failed = 0;
if (ctxt->mode == EXR_CONTEXT_WRITE ||
ctxt->mode == EXR_CONTEXT_WRITING_DATA)
failed = 1;
if (ctxt->mode != EXR_CONTEXT_READ &&
ctxt->mode != EXR_CONTEXT_TEMPORARY)
rv = finalize_write (ctxt, failed);
if (ctxt->destroy_fn) ctxt->destroy_fn (ctxt, ctxt->user_data, failed);
internal_exr_destroy_context (ctxt);
}
*pctxt = NULL;
return rv;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x18329
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x18331
movzbl (%r14), %ecx
leal -0x1(%rcx), %eax
xorl %ebp, %ebp
testb $-0x3, %al
sete %r12b
xorl %r15d, %r15d
testb $-0x5, %cl
jne 0x18347
movq 0x90(%r14), %rax
testq %rax, %rax
je 0x1831f
movb %r12b, %bpl
movq 0x88(%r14), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq *%rax
movq %r14, %rdi
callq 0x19b94
jmp 0x18334
movl $0x2, %r15d
jmp 0x1833b
xorl %r15d, %r15d
movq $0x0, (%rbx)
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testb $-0x3, %al
je 0x1838b
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x18302
movq 0x10(%r14), %rsi
callq 0x4400
testl %eax, %eax
jns 0x18302
movq 0x48(%r14), %r15
xorl %edi, %edi
callq 0x4480
leaq 0x9f46b(%rip), %rdx # 0xb77de
movq %r14, %rdi
movl $0x5, %esi
movq %rax, %rcx
xorl %eax, %eax
callq *%r15
movl %eax, %r15d
jmp 0x18302
leaq 0xed6(%rip), %rax # 0x19268
cmpq %rax, 0x90(%r14)
jne 0x18302
movq 0x20(%r14), %rdi
testq %rdi, %rdi
jne 0x183ac
movq 0x10(%r14), %rdi
callq 0x40b0
jmp 0x18302
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/context.c
|
exr_get_attribute_count
|
exr_result_t
exr_get_attribute_count (
exr_const_context_t ctxt, int part_index, int32_t* count)
{
int32_t cnt;
EXR_LOCK_WRITE_AND_DEFINE_PART (part_index);
cnt = part->attributes.num_attributes;
if (ctxt->mode == EXR_CONTEXT_WRITE) internal_exr_unlock (ctxt);
if (!count) return ctxt->standard_error (ctxt, EXR_ERR_INVALID_ARGUMENT);
*count = cnt;
return EXR_ERR_SUCCESS;
}
|
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1b14c
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x1, (%rdi)
jne 0x1b112
leaq 0x1f8(%rbx), %rdi
callq 0x44c0
testl %ebp, %ebp
js 0x1b156
movb (%rbx), %al
cmpl %ebp, 0xc4(%rbx)
jle 0x1b158
movq 0x1d8(%rbx), %rcx
movl %ebp, %edx
movq (%rcx,%rdx,8), %rcx
movl 0x8(%rcx), %ebp
cmpb $0x1, %al
jne 0x1b140
leaq 0x1f8(%rbx), %rdi
callq 0x42c0
testq %r14, %r14
je 0x1b186
movl %ebp, (%r14)
xorl %eax, %eax
jmp 0x1b151
movl $0x2, %eax
popq %rbx
popq %r14
popq %rbp
retq
movb (%rbx), %al
cmpb $0x1, %al
jne 0x1b168
leaq 0x1f8(%rbx), %rdi
callq 0x42c0
movq 0x48(%rbx), %r8
leaq 0x9c7f5(%rip), %rdx # 0xb7968
movq %rbx, %rdi
movl $0x4, %esi
movl %ebp, %ecx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmpq *%r8
movq 0x38(%rbx), %rax
movq %rbx, %rdi
movl $0x3, %esi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/part_attr.c
|
exr_get_attribute_by_name
|
exr_result_t
exr_get_attribute_by_name (
exr_const_context_t ctxt,
int part_index,
const char* name,
const exr_attribute_t** outattr)
{
exr_attribute_t* tmpptr;
exr_result_t rv;
EXR_LOCK_WRITE_AND_DEFINE_PART (part_index);
if (!outattr)
return EXR_UNLOCK_WRITE_AND_RETURN (
ctxt->standard_error (ctxt, EXR_ERR_INVALID_ARGUMENT));
rv = exr_attr_list_find_by_name (
EXR_CONST_CAST (exr_context_t, ctxt),
EXR_CONST_CAST (exr_attribute_list_t*, &(part->attributes)),
name,
&tmpptr);
if (rv == EXR_ERR_SUCCESS) *outattr = tmpptr;
return EXR_UNLOCK_WRITE_AND_RETURN (rv);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1b37b
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x1, (%rdi)
jne 0x1b2ef
leaq 0x1f8(%rbx), %rdi
callq 0x44c0
testl %ebp, %ebp
js 0x1b346
cmpl %ebp, 0xc4(%rbx)
jle 0x1b346
testq %r14, %r14
je 0x1b38d
movq 0x1d8(%rbx), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %rsi
addq $0x8, %rsi
movq %rsp, %rcx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x15891
movl %eax, %ebp
testl %eax, %eax
jne 0x1b330
movq (%rsp), %rax
movq %rax, (%r14)
cmpb $0x1, (%rbx)
jne 0x1b380
addq $0x1f8, %rbx # imm = 0x1F8
movq %rbx, %rdi
callq 0x42c0
jmp 0x1b380
cmpb $0x1, (%rbx)
jne 0x1b357
leaq 0x1f8(%rbx), %rdi
callq 0x42c0
movq 0x48(%rbx), %r8
leaq 0x9c606(%rip), %rdx # 0xb7968
movq %rbx, %rdi
movl $0x4, %esi
movl %ebp, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%r8
movl $0x2, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x1, (%rbx)
jne 0x1b39e
leaq 0x1f8(%rbx), %rdi
callq 0x42c0
movq 0x38(%rbx), %rax
movq %rbx, %rdi
movl $0x3, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/part_attr.c
|
exr_attr_declare
|
exr_result_t
exr_attr_declare (
exr_context_t ctxt,
int part_index,
const char* name,
exr_attribute_type_t type,
exr_attribute_t** outattr)
{
exr_result_t rv;
EXR_LOCK_AND_DEFINE_PART (part_index);
if (ctxt->mode != EXR_CONTEXT_WRITE && ctxt->mode != EXR_CONTEXT_TEMPORARY)
return EXR_UNLOCK_AND_RETURN (
ctxt->standard_error (ctxt, EXR_ERR_NOT_OPEN_WRITE));
rv = exr_attr_list_add (
ctxt, &(part->attributes), name, type, 0, NULL, outattr);
return EXR_UNLOCK_AND_RETURN (rv);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1b67f
movq %r8, %r13
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %rbx
leaq 0x1f8(%rdi), %r14
movq %r14, %rdi
callq 0x44c0
testl %r12d, %r12d
js 0x1b64e
cmpl %r12d, 0xc4(%rbx)
jle 0x1b64e
movzbl (%rbx), %eax
cmpl $0x1, %eax
je 0x1b617
cmpl $0x4, %eax
jne 0x1b693
movq 0x1d8(%rbx), %rax
movl %r12d, %ecx
movq (%rax,%rcx,8), %rsi
addq $0x8, %rsi
movq %r13, (%rsp)
movq %rbx, %rdi
movq %r15, %rdx
movl %ebp, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x161f4
movl %eax, %ebx
movq %r14, %rdi
callq 0x42c0
movl %ebx, %eax
jmp 0x1b684
movq %r14, %rdi
callq 0x42c0
movq 0x48(%rbx), %r8
leaq 0x9c307(%rip), %rdx # 0xb7968
movq %rbx, %rdi
movl $0x4, %esi
movl %r12d, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%r8
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x42c0
movq 0x38(%rbx), %rax
movq %rbx, %rdi
movl $0x8, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/part_attr.c
|
exr_set_lineorder
|
exr_result_t
exr_set_lineorder (exr_context_t ctxt, int part_index, exr_lineorder_t lo)
{
if (lo >= EXR_LINEORDER_LAST_TYPE)
return ctxt->print_error (
ctxt,
EXR_ERR_ARGUMENT_OUT_OF_RANGE,
"'lineOrder' value for line order (%d) out of range (%d - %d)",
(int) lo,
0,
(int) EXR_LINEORDER_LAST_TYPE);
{
REQ_ATTR_FIND_CREATE (lineOrder, EXR_ATTR_LINEORDER);
if (rv == EXR_ERR_SUCCESS)
{
attr->uc = (uint8_t) lo;
part->lineorder = lo;
}
return EXR_UNLOCK_AND_RETURN (rv);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %rbx
cmpl $0x3, %edx
jb 0x1bc82
movq 0x48(%rbx), %r11
leaq 0x9c0a1(%rip), %rdx # 0xb7cff
movq %rbx, %rdi
movl $0x4, %esi
movl %ebp, %ecx
xorl %r8d, %r8d
movl $0x3, %r9d
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%r11
testq %rbx, %rbx
je 0x1bcf8
movl %esi, %r15d
leaq 0x1f8(%rbx), %r14
movq %r14, %rdi
callq 0x44c0
testl %r15d, %r15d
js 0x1bcc9
cmpl %r15d, 0xc4(%rbx)
jle 0x1bcc9
movzbl (%rbx), %eax
cmpl $0x3, %eax
je 0x1bd0c
testl %eax, %eax
jne 0x1bd2e
movq %r14, %rdi
callq 0x42c0
movq 0x38(%rbx), %rax
movq %rbx, %rdi
movl $0x8, %esi
jmp 0x1bd20
movq %r14, %rdi
callq 0x42c0
movq 0x48(%rbx), %r8
leaq 0x9bc8c(%rip), %rdx # 0xb7968
movq %rbx, %rdi
movl $0x4, %esi
movl %r15d, %ecx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%r8
movl $0x2, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x42c0
movq 0x38(%rbx), %rax
movq %rbx, %rdi
movl $0x15, %esi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq 0x1d8(%rbx), %rax
movl %r15d, %ecx
movq (%rax,%rcx,8), %r15
leaq 0x40(%r15), %r12
movq 0x40(%r15), %rax
testq %rax, %rax
je 0x1bd8a
cmpl $0xc, 0x14(%rax)
je 0x1bdb6
movq %r14, %rdi
callq 0x42c0
movq 0x48(%rbx), %r9
movq (%r12), %rax
movq 0x8(%rax), %rcx
leaq 0x9beff(%rip), %rdx # 0xb7c69
leaq 0x9a2f1(%rip), %r8 # 0xb6062
movq %rbx, %rdi
movl $0x6, %esi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%r9
leaq 0x8(%r15), %rsi
movq %r12, (%rsp)
leaq 0x9a2c9(%rip), %rdx # 0xb6062
movq %rbx, %rdi
movl $0xc, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x161f4
movl %eax, %ebx
testl %eax, %eax
jne 0x1bdc3
movq (%r12), %rax
movb %bpl, 0x18(%rax)
movl %ebp, 0xb4(%r15)
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x42c0
jmp 0x1bcfd
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/part_attr.c
|
exr_initialize_required_attr_simple
|
exr_result_t
exr_initialize_required_attr_simple (
exr_context_t ctxt,
int part_index,
int32_t width,
int32_t height,
exr_compression_t ctype)
{
exr_attr_box2i_t dispWindow = {
.min = {.x = 0, .y = 0}, .max = {.x = (width - 1), .y = (height - 1)}};
exr_attr_v2f_t swc = {.x = 0.f, .y = 0.f};
return exr_initialize_required_attr (
ctxt,
part_index,
&dispWindow,
&dispWindow,
1.f,
&swc,
1.f,
EXR_LINEORDER_INCREASING_Y,
ctype);
}
|
subq $0x28, %rsp
xorl %r10d, %r10d
leaq 0x18(%rsp), %rax
movq %r10, (%rax)
decl %edx
movl %edx, 0x8(%rax)
decl %ecx
movl %ecx, 0xc(%rax)
leaq 0x10(%rsp), %r9
movq %r10, (%r9)
movl %r8d, (%rsp)
movss 0x9b91c(%rip), %xmm0 # 0xb7b64
movq %rax, %rdx
movq %rax, %rcx
movq %r9, %r8
movaps %xmm0, %xmm1
xorl %r9d, %r9d
callq 0x4160
addq $0x28, %rsp
retq
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/part_attr.c
|
exr_attr_get_int
|
exr_result_t
exr_attr_get_int (
exr_const_context_t ctxt, int part_index, const char* name, int32_t* out)
{
ATTR_GET_IMPL (EXR_ATTR_INT, i);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x20712
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x1, (%rdi)
jne 0x2067f
leaq 0x1f8(%rbx), %rdi
callq 0x44c0
testl %ebp, %ebp
js 0x206dd
cmpl %ebp, 0xc4(%rbx)
jle 0x206dd
testq %r14, %r14
je 0x20724
cmpb $0x0, (%r14)
je 0x20724
movq 0x1d8(%rbx), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %rsi
addq $0x8, %rsi
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x15891
testl %eax, %eax
je 0x20754
movl %eax, %ebp
cmpb $0x1, (%rbx)
jne 0x20717
addq $0x1f8, %rbx # imm = 0x1F8
movq %rbx, %rdi
callq 0x42c0
jmp 0x20717
cmpb $0x1, (%rbx)
jne 0x206ee
leaq 0x1f8(%rbx), %rdi
callq 0x42c0
movq 0x48(%rbx), %r8
leaq 0x9726f(%rip), %rdx # 0xb7968
movq %rbx, %rdi
movl $0x4, %esi
movl %ebp, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%r8
movl $0x2, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x1, (%rbx)
jne 0x20735
leaq 0x1f8(%rbx), %rdi
callq 0x42c0
movq 0x40(%rbx), %rax
leaq 0x97c64(%rip), %rdx # 0xb83a4
movq %rbx, %rdi
movl $0x3, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq (%rsp), %rax
cmpl $0xa, 0x14(%rax)
jne 0x20770
testq %r15, %r15
je 0x207a2
movl 0x18(%rax), %eax
movl %eax, (%r15)
xorl %ebp, %ebp
jmp 0x206c7
cmpb $0x1, (%rbx)
jne 0x20785
leaq 0x1f8(%rbx), %rdi
callq 0x42c0
movq (%rsp), %rax
movq 0x8(%rax), %r8
leaq 0x97c37(%rip), %rdx # 0xb83c7
movq %rbx, %rdi
movl $0x10, %esi
movq %r14, %rcx
xorl %eax, %eax
callq *0x48(%rbx)
jmp 0x207ca
cmpb $0x1, (%rbx)
jne 0x207b3
leaq 0x1f8(%rbx), %rdi
callq 0x42c0
leaq 0x9749a(%rip), %rdx # 0xb7c54
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rcx
xorl %eax, %eax
callq *0x48(%rbx)
movl %eax, %ebp
jmp 0x20717
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/part_attr.c
|
exr_attr_get_string_vector
|
exr_result_t
exr_attr_get_string_vector (
exr_const_context_t ctxt,
int part_index,
const char* name,
int32_t* size,
const char** out)
{
ATTR_FIND_ATTR (EXR_ATTR_STRING_VECTOR, stringvector);
if (!size)
return EXR_UNLOCK_WRITE_AND_RETURN (ctxt->report_error (
ctxt,
EXR_ERR_INVALID_ARGUMENT,
"size parameter required to query stringvector"));
if (out)
{
if (*size < attr->stringvector->n_strings)
return EXR_UNLOCK_WRITE_AND_RETURN (ctxt->print_error (
ctxt,
EXR_ERR_INVALID_ARGUMENT,
"'%s' array buffer too small (%d) to hold string values (%d)",
name,
*size,
attr->stringvector->n_strings));
for (int32_t i = 0; i < attr->stringvector->n_strings; ++i)
out[i] = attr->stringvector->strings[i].str;
}
*size = attr->stringvector->n_strings;
return EXR_UNLOCK_WRITE_AND_RETURN (rv);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x22c15
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x1, (%rdi)
jne 0x22b7e
leaq 0x1f8(%rbx), %rdi
callq 0x44c0
testl %ebp, %ebp
js 0x22bde
cmpl %ebp, 0xc4(%rbx)
jle 0x22bde
testq %r15, %r15
je 0x22c29
cmpb $0x0, (%r15)
je 0x22c29
movq 0x1d8(%rbx), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %rsi
addq $0x8, %rsi
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x15891
testl %eax, %eax
je 0x22c5b
movl %eax, %ebp
cmpb $0x1, (%rbx)
jne 0x22c1a
addq $0x1f8, %rbx # imm = 0x1F8
movq %rbx, %rdi
callq 0x42c0
jmp 0x22c1a
cmpb $0x1, (%rbx)
jne 0x22bef
leaq 0x1f8(%rbx), %rdi
callq 0x42c0
movq 0x48(%rbx), %r8
leaq 0x94d6e(%rip), %rdx # 0xb7968
movq %rbx, %rdi
movl $0x4, %esi
movl %ebp, %ecx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%r8
movl $0x2, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x1, (%rbx)
jne 0x22c3a
leaq 0x1f8(%rbx), %rdi
callq 0x42c0
movq 0x40(%rbx), %rax
leaq 0x95d06(%rip), %rdx # 0xb894b
movq %rbx, %rdi
movl $0x3, %esi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq 0x8(%rsp), %rax
cmpl $0x14, 0x14(%rax)
jne 0x22cc4
testq %r14, %r14
je 0x22cf7
testq %r12, %r12
je 0x22d21
movl (%r14), %r8d
movq 0x18(%rax), %rcx
movl (%rcx), %r9d
cmpl %r9d, %r8d
jge 0x22d2a
cmpb $0x1, (%rbx)
jne 0x22cab
leaq 0x1f8(%rbx), %rdi
callq 0x42c0
movl (%r14), %r8d
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl (%rax), %r9d
leaq 0x95d3c(%rip), %rdx # 0xb89ee
movq %rbx, %rdi
movl $0x3, %esi
movq %r15, %rcx
xorl %eax, %eax
callq *0x48(%rbx)
jmp 0x22d1a
cmpb $0x1, (%rbx)
jne 0x22cda
leaq 0x1f8(%rbx), %rdi
callq 0x42c0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r8
leaq 0x95c94(%rip), %rdx # 0xb8979
movq %rbx, %rdi
movl $0x10, %esi
movq %r15, %rcx
xorl %eax, %eax
callq *0x48(%rbx)
jmp 0x22d1a
cmpb $0x1, (%rbx)
jne 0x22d08
leaq 0x1f8(%rbx), %rdi
callq 0x42c0
leaq 0x95cb1(%rip), %rdx # 0xb89c0
movq %rbx, %rdi
movl $0x3, %esi
callq *0x40(%rbx)
movl %eax, %ebp
jmp 0x22c1a
movq 0x18(%rax), %rax
movl (%rax), %r9d
jmp 0x22d55
testl %r9d, %r9d
jle 0x22d55
movl $0x8, %edx
xorl %esi, %esi
movq 0x8(%rcx), %rcx
movq (%rcx,%rdx), %rcx
movq %rcx, (%r12,%rsi,8)
incq %rsi
movq 0x18(%rax), %rcx
movslq (%rcx), %r9
addq $0x10, %rdx
cmpq %r9, %rsi
jl 0x22d36
movl %r9d, (%r14)
xorl %ebp, %ebp
jmp 0x22bc8
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/part_attr.c
|
exr_attr_get_v2d
|
exr_result_t
exr_attr_get_v2d (
exr_const_context_t ctxt,
int part_index,
const char* name,
exr_attr_v2d_t* out)
{
ATTR_GET_IMPL_DEREF (EXR_ATTR_V2D, v2d);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x24006
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x1, (%rdi)
jne 0x23f73
leaq 0x1f8(%rbx), %rdi
callq 0x44c0
testl %ebp, %ebp
js 0x23fd1
cmpl %ebp, 0xc4(%rbx)
jle 0x23fd1
testq %r14, %r14
je 0x24018
cmpb $0x0, (%r14)
je 0x24018
movq 0x1d8(%rbx), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %rsi
addq $0x8, %rsi
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x15891
testl %eax, %eax
je 0x24048
movl %eax, %ebp
cmpb $0x1, (%rbx)
jne 0x2400b
addq $0x1f8, %rbx # imm = 0x1F8
movq %rbx, %rdi
callq 0x42c0
jmp 0x2400b
cmpb $0x1, (%rbx)
jne 0x23fe2
leaq 0x1f8(%rbx), %rdi
callq 0x42c0
movq 0x48(%rbx), %r8
leaq 0x9397b(%rip), %rdx # 0xb7968
movq %rbx, %rdi
movl $0x4, %esi
movl %ebp, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%r8
movl $0x2, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x1, (%rbx)
jne 0x24029
leaq 0x1f8(%rbx), %rdi
callq 0x42c0
movq 0x40(%rbx), %rax
leaq 0x94d05(%rip), %rdx # 0xb8d39
movq %rbx, %rdi
movl $0x3, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq (%rsp), %rax
cmpl $0x19, 0x14(%rax)
jne 0x24069
testq %r15, %r15
je 0x2409b
movq 0x18(%rax), %rax
movups (%rax), %xmm0
movups %xmm0, (%r15)
xorl %ebp, %ebp
jmp 0x23fbb
cmpb $0x1, (%rbx)
jne 0x2407e
leaq 0x1f8(%rbx), %rdi
callq 0x42c0
movq (%rsp), %rax
movq 0x8(%rax), %r8
leaq 0x94cd5(%rip), %rdx # 0xb8d5e
movq %rbx, %rdi
movl $0x10, %esi
movq %r14, %rcx
xorl %eax, %eax
callq *0x48(%rbx)
jmp 0x240c3
cmpb $0x1, (%rbx)
jne 0x240ac
leaq 0x1f8(%rbx), %rdi
callq 0x42c0
leaq 0x93ba1(%rip), %rdx # 0xb7c54
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rcx
xorl %eax, %eax
callq *0x48(%rbx)
movl %eax, %ebp
jmp 0x2400b
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/part_attr.c
|
exr_attr_set_v3d
|
exr_result_t
exr_attr_set_v3d (
exr_context_t ctxt,
int part_index,
const char* name,
const exr_attr_v3d_t* val)
{
ATTR_SET_IMPL_DEREF (EXR_ATTR_V3D, v3d);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq $0x0, 0x10(%rsp)
testq %rdi, %rdi
je 0x24b83
movq %rcx, %r12
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x1f8(%rdi), %r14
movq %r14, %rdi
callq 0x44c0
testl %ebp, %ebp
js 0x24b53
cmpl %ebp, 0xc4(%rbx)
jle 0x24b53
movzbl (%rbx), %eax
cmpl $0x3, %eax
je 0x24b99
testl %eax, %eax
jne 0x24bbd
movq %r14, %rdi
callq 0x42c0
movq 0x38(%rbx), %rax
movq %rbx, %rdi
movl $0x8, %esi
jmp 0x24bad
movq %r14, %rdi
callq 0x42c0
movq 0x48(%rbx), %r8
leaq 0x92e02(%rip), %rdx # 0xb7968
movq %rbx, %rdi
movl $0x4, %esi
movl %ebp, %ecx
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%r8
movl $0x2, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x42c0
movq 0x38(%rbx), %rax
movq %rbx, %rdi
movl $0x15, %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq 0x1d8(%rbx), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %r13
addq $0x8, %r13
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x15891
testl %eax, %eax
je 0x24c31
movl %eax, %ebp
cmpl $0xf, %eax
jne 0x24c58
movzbl (%rbx), %eax
cmpl $0x1, %eax
je 0x24bfd
cmpl $0x4, %eax
jne 0x24cb4
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
movl $0x1c, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x161f4
testq %r12, %r12
je 0x24c87
movl %eax, %ebp
testl %eax, %eax
jne 0x24c58
movq 0x10(%rsp), %rax
jmp 0x24c41
movq 0x10(%rsp), %rax
cmpl $0x1c, 0x14(%rax)
jne 0x24c65
testq %r12, %r12
je 0x24c87
movq 0x18(%rax), %rax
movq 0x10(%r12), %rcx
movq %rcx, 0x10(%rax)
movups (%r12), %xmm0
movups %xmm0, (%rax)
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x42c0
jmp 0x24b88
movq %r14, %rdi
callq 0x42c0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %r8
leaq 0x9420a(%rip), %rdx # 0xb8e87
movq %rbx, %rdi
movl $0x10, %esi
jmp 0x24ca5
movq %r14, %rdi
callq 0x42c0
leaq 0x9328d(%rip), %rdx # 0xb7f23
leaq 0x9141a(%rip), %r8 # 0xb60b7
movq %rbx, %rdi
movl $0x3, %esi
movq %r15, %rcx
xorl %eax, %eax
callq *0x48(%rbx)
movl %eax, %ebp
jmp 0x24b88
movq %r14, %rdi
callq 0x42c0
movl $0xf, %ebp
jmp 0x24b88
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/part_attr.c
|
extract_attr_chlist
|
static exr_result_t
extract_attr_chlist (
exr_context_t ctxt,
struct _internal_exr_seq_scratch* scratch,
exr_attr_chlist_t* attrdata,
const char* aname,
const char* tname,
int32_t attrsz)
{
char chname[256];
int32_t chlen;
int32_t ptype, xsamp, ysamp;
uint8_t flags[4];
int32_t maxlen = ctxt->max_name_length;
exr_result_t rv;
rv = check_bad_attrsz (scratch, attrsz, 1, aname, tname, &chlen);
while (rv == EXR_ERR_SUCCESS && attrsz > 0)
{
chlen = 0;
rv = read_text (chname, &chlen, maxlen, scratch, aname);
if (rv != EXR_ERR_SUCCESS) break;
attrsz -= chlen + 1;
if (chlen == 0) break;
if (attrsz < 16)
{
scratch->sequential_skip (scratch, attrsz);
return ctxt->print_error (
ctxt,
EXR_ERR_ATTR_SIZE_MISMATCH,
"Out of data parsing '%s', last channel '%s'",
aname,
chname);
}
rv = scratch->sequential_read (scratch, &ptype, 4);
if (rv != EXR_ERR_SUCCESS) break;
rv = scratch->sequential_read (scratch, &flags, 4);
if (rv != EXR_ERR_SUCCESS) break;
rv = scratch->sequential_read (scratch, &xsamp, 4);
if (rv != EXR_ERR_SUCCESS) break;
rv = scratch->sequential_read (scratch, &ysamp, 4);
if (rv != EXR_ERR_SUCCESS) break;
attrsz -= 16;
ptype = (int32_t) one_to_native32 ((uint32_t) ptype);
xsamp = (int32_t) one_to_native32 ((uint32_t) xsamp);
ysamp = (int32_t) one_to_native32 ((uint32_t) ysamp);
if (ptype < 0 || ptype > (int)EXR_PIXEL_LAST_TYPE)
ptype = (int)EXR_PIXEL_LAST_TYPE;
rv = exr_attr_chlist_add_with_length (
ctxt,
attrdata,
chname,
chlen,
(exr_pixel_type_t) ptype,
flags[0],
xsamp,
ysamp);
}
scratch->sequential_skip (scratch, attrsz);
return rv;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movl %r9d, %r12d
movq %rcx, %r15
movq %rdx, 0x28(%rsp)
movq %rsi, %rbx
movq %rdi, 0x20(%rsp)
movzbl 0x2(%rdi), %eax
movl %eax, 0x10(%rsp)
leaq 0x8(%rsp), %r9
movq %rsi, %rdi
movl %r12d, %esi
movl $0x1, %edx
callq 0x27a4a
movl %eax, %ebp
testl %eax, %eax
setne %al
testl %r12d, %r12d
setle %cl
orb %al, %cl
jne 0x27d0d
movl %r12d, %r13d
movl $0x0, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl 0x10(%rsp), %edx
movq %rbx, %rcx
movq %r15, %r8
callq 0x27990
testl %eax, %eax
jne 0x27d08
movl 0x8(%rsp), %r14d
movl %r14d, %eax
notl %eax
addl %eax, %r13d
testl %r14d, %r14d
je 0x27d2a
cmpl $0xf, %r13d
jle 0x27d2e
movl $0x4, %edx
movq %rbx, %rdi
leaq 0xc(%rsp), %rsi
callq *0x20(%rbx)
testl %eax, %eax
jne 0x27d08
movl $0x4, %edx
movq %rbx, %rdi
leaq 0x1c(%rsp), %rsi
callq *0x20(%rbx)
testl %eax, %eax
jne 0x27d08
movl $0x4, %edx
movq %rbx, %rdi
leaq 0x18(%rsp), %rsi
callq *0x20(%rbx)
testl %eax, %eax
jne 0x27d08
movl $0x4, %edx
movq %rbx, %rdi
leaq 0x14(%rsp), %rsi
callq *0x20(%rbx)
testl %eax, %eax
jne 0x27d08
movl 0xc(%rsp), %r8d
cmpl $0x4, %r8d
jb 0x27cc2
movl $0x3, 0xc(%rsp)
movl $0x3, %r8d
leal -0x10(%r13), %r12d
movl 0x18(%rsp), %eax
movl 0x14(%rsp), %r10d
movzbl 0x1c(%rsp), %r9d
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movl %r14d, %ecx
pushq %r10
pushq %rax
callq 0x1727e
addq $0x10, %rsp
movl %eax, %ebp
testl %eax, %eax
jne 0x27d0d
cmpl $0x10, %r13d
movl %r12d, %r13d
jne 0x27c08
jmp 0x27d0d
movl %eax, %ebp
movl %r13d, %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq *0x28(%rbx)
movl %ebp, %eax
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x27d0a
movq %rbx, %rdi
movl %r13d, %esi
callq *0x28(%rbx)
leaq 0x91f84(%rip), %rdx # 0xb9cc2
leaq 0x30(%rsp), %r8
movq 0x20(%rsp), %rdi
movl $0x11, %esi
movq %r15, %rcx
xorl %eax, %eax
callq *0x48(%rdi)
movl %eax, %ebp
jmp 0x27d16
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/parse_header.c
|
extract_attr_64bit
|
static exr_result_t
extract_attr_64bit (
exr_context_t ctxt,
struct _internal_exr_seq_scratch* scratch,
void* attrdata,
const char* aname,
const char* tname,
int32_t attrsz,
int32_t num)
{
exr_result_t rv;
if (attrsz != 8 * num)
return ctxt->print_error (
ctxt,
EXR_ERR_ATTR_SIZE_MISMATCH,
"Attribute '%s': Invalid size %d (exp '%s' size 8 * %d (%d))",
aname,
attrsz,
tname,
num,
8 * num);
rv = scratch->sequential_read (scratch, attrdata, 8 * (uint64_t) num);
if (rv != EXR_ERR_SUCCESS)
return ctxt->print_error (
ctxt, rv, "Unable to read '%s' %s data", aname, tname);
priv_to_native64 (attrdata, num);
return rv;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movl 0x20(%rsp), %r10d
leal (,%r10,8), %r11d
cmpl %r9d, %r11d
jne 0x27e7f
movq %rsi, %rax
movl %r10d, %ecx
shlq $0x3, %rcx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq *0x20(%rax)
testl %eax, %eax
je 0x27ea6
movq 0x48(%rbx), %r9
leaq 0x91e3c(%rip), %rdx # 0xb9ca6
movq %rbx, %rdi
movl %eax, %esi
movq %r15, %rcx
movq %r14, %r8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmpq *%r9
leaq 0x91ed8(%rip), %rdx # 0xb9d5e
movq %rbx, %rdi
movl $0x11, %esi
movq %r15, %rcx
movl %r9d, %r8d
movq %r14, %r9
xorl %eax, %eax
pushq %r11
pushq %r10
callq *0x48(%rbx)
addq $0x10, %rsp
jmp 0x27ea8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/parse_header.c
|
save_float_vector
|
static exr_result_t
save_float_vector (exr_context_t ctxt, const exr_attribute_t* a)
{
exr_result_t rv;
rv =
save_attr_sz (ctxt, sizeof (float) * (size_t) (a->floatvector->length));
if (rv == EXR_ERR_SUCCESS && a->floatvector->length > 0)
{
if (a->floatvector->alloc_size > 0)
{
/* we own the data, so we can swap it, then swap it back */
rv = save_attr_32 (
ctxt,
EXR_CONST_CAST (void*, a->floatvector->arr),
a->floatvector->length);
priv_to_native32 (
EXR_CONST_CAST (void*, a->floatvector->arr),
a->floatvector->length);
}
else
{
/* might be static data, take a copy first */
float* tmp = ctxt->alloc_fn (
(size_t) (a->floatvector->length) * sizeof (float));
if (tmp == NULL)
return ctxt->standard_error (ctxt, EXR_ERR_OUT_OF_MEMORY);
memcpy (
tmp,
a->floatvector->arr,
(size_t) (a->floatvector->length) * sizeof (float));
rv = save_attr_32 (ctxt, tmp, a->floatvector->length);
ctxt->free_fn (tmp);
}
}
return rv;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rax
movslq (%rax), %rax
shlq $0x2, %rax
testq $-0x80000000, %rax # imm = 0x80000000
je 0x28fe2
movq %rbx, %rdi
movl $0x3, %esi
callq *0x38(%rbx)
jmp 0x28ffb
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
leaq 0xb0(%rbx), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq *0x30(%rbx)
movl %eax, %ebp
testl %eax, %eax
jne 0x2907c
movq 0x18(%r14), %rax
movslq (%rax), %rdx
testq %rdx, %rdx
jle 0x2902c
cmpl $0x0, 0x4(%rax)
jle 0x29030
movq 0x8(%rax), %rsi
shlq $0x2, %rdx
leaq 0xb0(%rbx), %rcx
movq %rbx, %rdi
callq *0x30(%rbx)
movl %eax, %ebp
jmp 0x2907c
xorl %ebp, %ebp
jmp 0x2907c
shlq $0x2, %rdx
movq %rdx, %rdi
callq *0x58(%rbx)
testq %rax, %rax
je 0x29089
movq %rax, %r15
movq 0x18(%r14), %rax
movq 0x8(%rax), %rsi
movslq (%rax), %rdx
shlq $0x2, %rdx
movq %r15, %rdi
callq 0x4290
movq 0x18(%r14), %rax
movslq (%rax), %rdx
shlq $0x2, %rdx
leaq 0xb0(%rbx), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x30(%rbx)
movl %eax, %ebp
movq %r15, %rdi
callq *0x60(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x1, %esi
callq *0x38(%rbx)
jmp 0x29028
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/write_header.c
|
save_v2i
|
static exr_result_t
save_v2i (exr_context_t ctxt, const exr_attribute_t* a)
{
exr_result_t rv;
exr_attr_v2i_t tmp = *(a->v2i);
rv = save_attr_sz (ctxt, sizeof (exr_attr_v2i_t));
if (rv == EXR_ERR_SUCCESS) rv = save_attr_32 (ctxt, &tmp, 2);
return rv;
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
leaq 0x14(%rsp), %rsi
movl $0x8, (%rsi)
leaq 0xb0(%rdi), %r14
movl $0x4, %edx
movq %r14, %rcx
callq *0x30(%rdi)
testl %eax, %eax
jne 0x295fa
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq *0x30(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/write_header.c
|
compute_chunk_unpack_size
|
static uint64_t
compute_chunk_unpack_size (
int x, int y, int width, int height, int lpc, exr_const_priv_part_t part)
{
uint64_t unpacksize = 0;
if (part->chan_has_line_sampling || height != lpc)
{
const exr_attr_chlist_t* chanlist = part->channels->chlist;
for (int c = 0; c < chanlist->num_channels; ++c)
{
const exr_attr_chlist_entry_t* curc = (chanlist->entries + c);
uint64_t chansz = ((curc->pixel_type == EXR_PIXEL_HALF) ? 2 : 4);
chansz *=
(uint64_t) compute_sampled_width (width, curc->x_sampling, x);
chansz *=
(uint64_t) compute_sampled_height (height, curc->y_sampling, y);
unpacksize += chansz;
}
}
else
unpacksize = part->unpacked_size_per_chunk;
return unpacksize;
}
|
movl %edx, %r11d
cmpl %ecx, %edx
jne 0x2a16b
cmpw $0x0, 0xf2(%r8)
jne 0x2a16b
movq 0xe8(%r8), %r10
jmp 0x2a258
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x20(%r8), %rax
movq 0x18(%rax), %rax
movslq (%rax), %r8
testq %r8, %r8
jle 0x2a24b
leal (%r11,%rdi), %ecx
leal (%r11,%rdi), %ebx
decl %ebx
movl $0x1, %r9d
subl %ecx, %r9d
testl %ecx, %ecx
cmovgl %ebx, %r9d
movq 0x8(%rax), %r14
shlq $0x5, %r8
xorl %r15d, %r15d
xorl %r10d, %r10d
cmpl $0x1, %esi
sete %dl
movl 0x10(%r14,%r15), %ecx
movl 0x18(%r14,%r15), %ebp
cmpl $0x2, %ebp
setl %r12b
movl $0x1, %eax
cmovll %esi, %eax
orb %dl, %r12b
jne 0x2a1d9
movl %esi, %eax
cltd
idivl %ebp
cmpl $0x1, %ecx
sete %dl
movslq %eax, %r12
movb $0x2, %cl
subb %dl, %cl
shlq %cl, %r12
movl 0x1c(%r14,%r15), %ebp
movl %r11d, %ecx
cmpl $0x2, %ebp
jl 0x2a232
movl %edi, %eax
cltd
idivl %ebp
cmpl $0x1, %r11d
jne 0x2a20a
xorl %ecx, %ecx
testl %edx, %edx
sete %cl
jmp 0x2a232
movl %ebp, %r13d
subl %edx, %r13d
testl %edx, %edx
cmovel %edx, %r13d
addl %edi, %r13d
xorl %ecx, %ecx
movl %r9d, %eax
xorl %edx, %edx
divl %ebp
movl %ebx, %eax
subl %edx, %eax
subl %r13d, %eax
jl 0x2a232
cltd
idivl %ebp
movl %eax, %ecx
incl %ecx
movslq %ecx, %rax
imulq %rax, %r12
addq %r12, %r10
addq $0x20, %r15
cmpq %r15, %r8
jne 0x2a1b0
jmp 0x2a24e
xorl %r10d, %r10d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movq %r10, %rax
retq
|
/AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRCore/chunk.c
|
bidfx_public_api::ApiExample::DealableStreams(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
|
void ApiExample::DealableStreams(std::vector<std::string> liquidity_providers)
{
for (std::string lp : liquidity_providers)
{
Subject subject1 = subscriber_->Subjects().Fx().Stream().Spot()
.LiquidityProvider(lp)
.CurrencyPair("EURUSD")
.Currency("EUR")
.Quantity(1230080.11)
.CreateSubject();
subscriber_->Subscribe(subject1);
//subscriber_->Unsubscribe(subject1);
Subject subject2 = subscriber_->Subjects().Fx().Stream().Forward()
.LiquidityProvider(lp)
.CurrencyPair("EURUSD")
.Currency("EUR")
.Quantity(1000000)
.Tenor(Tenor::IN_1_MONTH)
.CreateSubject();
subscriber_->Subscribe(subject2);
//subscriber_->Unsubscribe(subject2);
Subject subject3 = subscriber_->Subjects().Fx().Stream().Ndf()
.LiquidityProvider(lp)
.CurrencyPair("USDKRW")
.Currency("USD")
.Quantity(2000000)
.Tenor(Tenor::IN_1_YEAR)
.FixingDate(new Date(2019, 12, 10))
.SettlementDate(new Date(2019, 12, 12))
.CreateSubject();
subscriber_->Subscribe(subject3);
//subscriber_->Unsubscribe(subject3);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rdi, 0x10(%rsp)
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
movq %rax, 0x40(%rsp)
leaq 0x148(%rsp), %r14
leaq 0xe0(%rsp), %r13
pushq $0xc
popq %rbx
cmpq 0x40(%rsp), %rcx
je 0x2c8cc
leaq 0xa8(%rsp), %rdi
movq %rcx, 0x48(%rsp)
movq %rcx, %rsi
callq 0x2b2e0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, 0x28(%rsp)
movq %r14, %rdi
leaq 0x28(%rsp), %rsi
callq 0x2b2c0
movq %r14, %rdi
callq 0x2b160
movq %rax, 0x70(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x2b060
leaq 0x50(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x2b200
movq %rax, %r15
leaq 0x88(%rsp), %rbp
movq %rbp, %rdi
leaq 0x13db1(%rip), %rsi # 0x402e8
leaq 0x18(%rsp), %rdx
callq 0x2d5c2
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2b5a0
movq %rax, %r15
movq %r13, %rdi
leaq 0x13d96(%rip), %rsi # 0x402ef
leaq 0x20(%rsp), %rdx
callq 0x2d5c2
movq %rbx, %r12
movq %r15, %rdi
movq %r13, %rsi
callq 0x2b430
movq %rax, %rdi
movsd 0x13a8c(%rip), %xmm0 # 0x40008
callq 0x2b590
movq (%rax), %rcx
leaq 0xc8(%rsp), %rdi
movq %rax, %rsi
callq *(%rcx)
movq %r13, %rbx
movq %r13, %rdi
callq 0x2b390
leaq 0x88(%rsp), %rdi
callq 0x2b390
movq %r14, %r13
movq %r14, %rdi
callq 0x2d734
movq 0x10(%rsp), %rax
movq 0x10(%rax), %r15
movq (%r15), %rax
movq -0x30(%rax), %rbp
leaq 0x130(%rsp), %r14
movq %r14, %rdi
leaq 0xc8(%rsp), %rsi
callq 0x2b120
leaq (%r15,%rbp), %rdi
movq (%r15,%rbp), %rax
movq %r14, %rsi
callq *0x8(%rax)
movq %r14, %rdi
callq 0x2d6da
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %r13, %r14
movq %rax, 0x18(%rsp)
movq %r13, %rdi
leaq 0x18(%rsp), %rsi
callq 0x2b2c0
movq %r14, %rdi
callq 0x2b160
movq %rbx, %r13
movq %rax, 0x28(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2b3a0
leaq 0x88(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x2b1d0
movq %rax, %r15
movq %r13, %rdi
leaq 0x13c8e(%rip), %rsi # 0x402e8
leaq 0x20(%rsp), %rdx
callq 0x2d5c2
movq %r15, %rdi
movq %r13, %rsi
callq 0x2b600
movq %rax, %r15
leaq 0x50(%rsp), %rbp
movq %rbp, %rdi
leaq 0x13c6e(%rip), %rsi # 0x402ef
leaq 0xe(%rsp), %rdx
callq 0x2d5c2
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2b480
movq %rax, %rdi
movsd 0x1396f(%rip), %xmm0 # 0x40010
callq 0x2b110
movq %rax, %rdi
movq 0x22938(%rip), %rsi # 0x4efe8
callq 0x2b330
movq (%rax), %rcx
leaq 0x70(%rsp), %rdi
movq %rax, %rsi
callq *(%rcx)
leaq 0x50(%rsp), %rdi
callq 0x2b390
movq %r13, %rdi
callq 0x2b390
movq %r14, %rdi
callq 0x2d734
movq 0x10(%rsp), %rax
movq 0x10(%rax), %r15
movq (%r15), %rax
movq -0x30(%rax), %rbp
leaq 0x118(%rsp), %rbx
movq %rbx, %rdi
leaq 0x70(%rsp), %rsi
callq 0x2b120
leaq (%r15,%rbp), %rdi
movq (%r15,%rbp), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x2d6da
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, 0x20(%rsp)
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
callq 0x2b2c0
movq %r14, %rdi
callq 0x2b160
movq %r12, %rbx
movq %rax, 0x18(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2b2f0
leaq 0x88(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x2b1d0
movq %rax, %r15
movq %r13, %rdi
leaq 0x13b77(%rip), %rsi # 0x402f3
leaq 0xe(%rsp), %rdx
callq 0x2d5c2
movq %r15, %rdi
movq %r13, %rsi
callq 0x2b600
movq %rax, %r15
leaq 0x50(%rsp), %rbp
movq %rbp, %rdi
leaq 0x13b48(%rip), %rsi # 0x402eb
leaq 0xf(%rsp), %rdx
callq 0x2d5c2
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2b480
movq %rax, %rdi
movsd 0x13855(%rip), %xmm0 # 0x40018
callq 0x2b110
movq %rax, %rdi
movq 0x227f6(%rip), %rsi # 0x4efc8
callq 0x2b330
movq %rax, %r15
movq %rbx, %rdi
callq 0x2b0e0
movq %rax, %rbp
movq %rax, %rdi
movl $0x7e3, %esi # imm = 0x7E3
pushq $0xc
popq %rdx
pushq $0xa
popq %rcx
callq 0x2b140
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2b4f0
movq %rax, %r15
movq %rbx, %rdi
callq 0x2b0e0
movq %rax, %rbp
movq %rax, %rdi
movl $0x7e3, %esi # imm = 0x7E3
pushq $0xc
popq %rcx
movl %ecx, %edx
callq 0x2b140
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2b530
movq (%rax), %rcx
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq *(%rcx)
leaq 0x50(%rsp), %rdi
callq 0x2b390
movq %r13, %rdi
callq 0x2b390
movq %r14, %rdi
callq 0x2d734
movq 0x10(%rsp), %rax
movq 0x10(%rax), %r15
movq (%r15), %rax
movq -0x30(%rax), %rbp
leaq 0x100(%rsp), %r12
movq %r12, %rdi
leaq 0x28(%rsp), %rsi
callq 0x2b120
leaq (%r15,%rbp), %rdi
movq (%r15,%rbp), %rax
movq %r12, %rsi
callq *0x8(%rax)
movq %r12, %rdi
callq 0x2d6da
leaq 0x28(%rsp), %rdi
callq 0x2d6da
leaq 0x70(%rsp), %rdi
callq 0x2d6da
leaq 0xc8(%rsp), %rdi
callq 0x2d6da
leaq 0xa8(%rsp), %rdi
callq 0x2b390
movq 0x48(%rsp), %rcx
addq $0x20, %rcx
jmp 0x2c4b3
addq $0x188, %rsp # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c8e2
jmp 0x2c8ea
movq %rax, %rbx
jmp 0x2c9b9
movq %rax, %rbx
pushq $0xc
popq %rsi
movq %rbp, %rdi
callq 0x2b0b0
jmp 0x2c9d8
movq %rax, %rbx
jmp 0x2c912
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x2d6da
leaq 0x28(%rsp), %rdi
jmp 0x2c92c
jmp 0x2c971
jmp 0x2c959
jmp 0x2c936
jmp 0x2c976
movq %rax, %rbx
leaq 0x118(%rsp), %rdi
callq 0x2d6da
jmp 0x2c9fc
movq %rax, %rbx
jmp 0x2c9e2
movq %rax, %rbx
leaq 0x130(%rsp), %rdi
jmp 0x2ca01
jmp 0x2c99a
jmp 0x2c952
movq %rax, %rbx
jmp 0x2c98b
jmp 0x2c961
movq %rax, %rbx
jmp 0x2c9fc
movq %rax, %rbx
jmp 0x2ca06
movq %rax, %rbx
jmp 0x2ca13
movq %rax, %rbx
jmp 0x2c9ef
movq %rax, %rbx
jmp 0x2c9c6
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
callq 0x2b390
leaq 0x88(%rsp), %rdi
callq 0x2b390
jmp 0x2c99d
movq %rax, %rbx
leaq 0x148(%rsp), %rdi
callq 0x2d734
jmp 0x2ca13
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2b390
leaq 0xe0(%rsp), %rdi
callq 0x2b390
leaq 0x148(%rsp), %rdi
callq 0x2d734
jmp 0x2ca06
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2b390
leaq 0xe0(%rsp), %rdi
callq 0x2b390
leaq 0x148(%rsp), %rdi
callq 0x2d734
leaq 0x70(%rsp), %rdi
callq 0x2d6da
leaq 0xc8(%rsp), %rdi
callq 0x2d6da
leaq 0xa8(%rsp), %rdi
callq 0x2b390
movq %rbx, %rdi
callq 0x2b370
|
/bidfx[P]bidfx-api-cpp/example/api_example.cpp
|
bidfx_public_api::ApiExample::DealableQuotes(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
|
void ApiExample::DealableQuotes(std::vector<std::string> liquidity_providers)
{
for (std::string lp : liquidity_providers)
{
subscriber_->Subscribe(subscriber_->Subjects().Fx().Quote().Spot()
.LiquidityProvider(lp)
.CurrencyPair("EURUSD")
.Currency("EUR")
.Quantity(1000000.11)
.CreateSubject());
subscriber_->Subscribe(subscriber_->Subjects().Fx().Stream().Forward()
.LiquidityProvider(lp)
.CurrencyPair("EURUSD")
.Currency("EUR")
.Quantity(1000000)
.Tenor(Tenor::IN_1_MONTH)
.CreateSubject());
subscriber_->Subscribe(subscriber_->Subjects().Fx().Stream().Swap()
.LiquidityProvider(lp)
.CurrencyPair("CHFJPY")
.Currency("CHF")
.NearQuantity(15000000)
.NearTenor(Tenor::IN_3_MONTHS)
.FarQuantity(15000000)
.FarTenor(Tenor::IN_1_YEAR)
.CreateSubject());
subscriber_->Subscribe(subscriber_->Subjects().Fx().Stream().Nds()
.LiquidityProvider(lp)
.CurrencyPair("USDCNY")
.Currency("USD")
.NearQuantity(10000000)
.NearTenor(Tenor::IN_1_YEAR)
.FarQuantity(8500000)
.FarTenor(Tenor::IN_3_YEARS)
.CreateSubject());
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rdi, 0x20(%rsp)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, 0x48(%rsp)
leaq 0xf8(%rsp), %r14
leaq 0xa8(%rsp), %r15
leaq 0x138(%rsp), %r12
cmpq 0x48(%rsp), %rax
je 0x2cecc
leaq 0x58(%rsp), %rdi
movq %rax, 0x50(%rsp)
movq %rax, %rsi
callq 0x2b2e0
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
movq -0x30(%rax), %rbx
addq %rdi, %rbx
callq *0x38(%rax)
movq %rax, 0x10(%rsp)
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq 0x2b2c0
movq %r14, %r13
movq %r14, %rdi
callq 0x2b1c0
movq %rax, 0x18(%rsp)
movq %r15, %rdi
leaq 0x18(%rsp), %rsi
callq 0x2b060
movq %r15, %rdi
leaq 0x58(%rsp), %rsi
callq 0x2b200
movq %rax, %r14
movq %r12, %rbp
movq %r12, %rdi
leaq 0x13807(%rip), %rsi # 0x402e8
leaq 0xf(%rsp), %rdx
callq 0x2d5c2
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2b5a0
movq %rax, %r14
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
leaq 0x137e7(%rip), %rsi # 0x402ef
leaq 0xe(%rsp), %rdx
callq 0x2d5c2
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2b430
movq %rax, %rdi
movsd 0x134f8(%rip), %xmm0 # 0x40020
callq 0x2b590
movq (%rax), %rcx
leaq 0xe0(%rsp), %rdi
movq %rax, %rsi
callq *(%rcx)
movq (%rbx), %rax
movq %rbx, %rdi
leaq 0xe0(%rsp), %rbx
movq %rbx, %rsi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x2d6da
leaq 0x28(%rsp), %rdi
callq 0x2b390
movq %r12, %rdi
callq 0x2b390
movq %r13, %r14
movq %r13, %rdi
callq 0x2d734
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
movq -0x30(%rax), %rbx
addq %rdi, %rbx
callq *0x38(%rax)
movq %rax, 0x10(%rsp)
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq 0x2b2c0
movq %r14, %rdi
callq 0x2b160
movq %rax, 0x18(%rsp)
movq %r12, %rdi
leaq 0x18(%rsp), %rsi
callq 0x2b3a0
movq %r12, %rdi
leaq 0x58(%rsp), %rsi
callq 0x2b1d0
movq %rax, %r14
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
leaq 0x13711(%rip), %rsi # 0x402e8
leaq 0xf(%rsp), %rdx
callq 0x2d5c2
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2b600
movq %rax, %r14
movq %r15, %rbp
movq %r15, %rdi
leaq 0x136f3(%rip), %rsi # 0x402ef
leaq 0xe(%rsp), %rdx
callq 0x2d5c2
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2b480
movq %rax, %rdi
movsd 0x133f4(%rip), %xmm0 # 0x40010
callq 0x2b110
movq %rax, %rdi
movq 0x223bd(%rip), %rsi # 0x4efe8
callq 0x2b330
movq (%rax), %rcx
leaq 0xc8(%rsp), %rdi
movq %rax, %rsi
callq *(%rcx)
movq (%rbx), %rax
movq %rbx, %rdi
leaq 0xc8(%rsp), %rbx
movq %rbx, %rsi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x2d6da
movq %rbp, %rdi
callq 0x2b390
leaq 0x28(%rsp), %rdi
callq 0x2b390
movq %r13, %r14
movq %r13, %rdi
callq 0x2d734
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
movq -0x30(%rax), %rbx
addq %rdi, %rbx
callq *0x38(%rax)
movq %rax, 0x10(%rsp)
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq 0x2b2c0
movq %r14, %rdi
callq 0x2b160
movq %rax, 0x18(%rsp)
movq %r12, %rdi
leaq 0x18(%rsp), %rsi
callq 0x2b400
movq %r12, %rdi
leaq 0x58(%rsp), %rsi
callq 0x2b4d0
movq %rax, %r14
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
leaq 0x13620(%rip), %rsi # 0x402fa
leaq 0xf(%rsp), %rdx
callq 0x2d5c2
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2b610
movq %rax, %r14
movq %r15, %rbp
movq %r15, %rdi
leaq 0x13602(%rip), %rsi # 0x40301
leaq 0xe(%rsp), %rdx
callq 0x2d5c2
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2b4a0
movq %rax, %rdi
movsd 0x13309(%rip), %xmm0 # 0x40028
callq 0x2b4c0
movq %rax, %rdi
movq 0x22292(%rip), %rsi # 0x4efc0
callq 0x2b170
movq %rax, %rdi
movsd 0x132ea(%rip), %xmm0 # 0x40028
callq 0x2b450
movq %rax, %rdi
movq 0x2227b(%rip), %rsi # 0x4efc8
callq 0x2b0c0
movq (%rax), %rcx
leaq 0x90(%rsp), %rdi
movq %rax, %rsi
callq *(%rcx)
movq (%rbx), %rax
movq %rbx, %rdi
leaq 0x90(%rsp), %rbx
movq %rbx, %rsi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x2d6da
movq %rbp, %rdi
callq 0x2b390
leaq 0x28(%rsp), %rdi
callq 0x2b390
movq %r13, %r14
movq %r13, %rdi
callq 0x2d734
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
movq -0x30(%rax), %rbx
addq %rdi, %rbx
callq *0x38(%rax)
movq %rax, 0x10(%rsp)
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq 0x2b2c0
movq %r14, %rdi
callq 0x2b160
movq %rax, 0x18(%rsp)
movq %r12, %rdi
leaq 0x18(%rsp), %rsi
callq 0x2b3d0
movq %r12, %rdi
leaq 0x58(%rsp), %rsi
callq 0x2b4d0
movq %rax, %r14
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
leaq 0x13509(%rip), %rsi # 0x40305
leaq 0xf(%rsp), %rdx
callq 0x2d5c2
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2b610
movq %rax, %r14
movq %r15, %rdi
leaq 0x134cd(%rip), %rsi # 0x402eb
leaq 0xe(%rsp), %rdx
callq 0x2d5c2
movq %r14, %rdi
movq %r15, %rsi
callq 0x2b4a0
movq %rax, %rdi
movsd 0x131f2(%rip), %xmm0 # 0x40030
callq 0x2b4c0
movq %rax, %rdi
movq 0x2217b(%rip), %rsi # 0x4efc8
callq 0x2b170
movq %rax, %rdi
movsd 0x131db(%rip), %xmm0 # 0x40038
callq 0x2b450
movq %rax, %rdi
movq 0x22134(%rip), %rsi # 0x4efa0
callq 0x2b0c0
movq (%rax), %rcx
leaq 0x78(%rsp), %rdi
movq %rax, %rsi
callq *(%rcx)
movq (%rbx), %rax
movq %rbx, %rdi
leaq 0x78(%rsp), %rbx
movq %rbx, %rsi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x2d6da
movq %r15, %rdi
callq 0x2b390
leaq 0x28(%rsp), %rdi
callq 0x2b390
movq %r13, %r14
movq %r13, %rdi
callq 0x2d734
leaq 0x58(%rsp), %rdi
callq 0x2b390
movq 0x50(%rsp), %rax
addq $0x20, %rax
jmp 0x2ca62
addq $0x158, %rsp # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
jmp 0x2cf0a
jmp 0x2cf5f
jmp 0x2cf5f
jmp 0x2cf17
jmp 0x2cf17
jmp 0x2cf17
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
jmp 0x2cf0a
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x2d6da
jmp 0x2cf6b
jmp 0x2cf17
jmp 0x2cf5f
jmp 0x2cf17
movq %rax, %rbx
jmp 0x2cf78
jmp 0x2cf5f
jmp 0x2cf20
movq %rax, %rbx
jmp 0x2cf55
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
callq 0x2d6da
jmp 0x2cf4b
jmp 0x2cf3d
jmp 0x2cf3d
jmp 0x2cf3d
movq %rax, %rbx
jmp 0x2cf8f
jmp 0x2cf5f
jmp 0x2cf5f
jmp 0x2cf5f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2b390
leaq 0x138(%rsp), %rdi
jmp 0x2cf7d
movq %rax, %rbx
jmp 0x2cf82
jmp 0x2cf68
jmp 0x2cf68
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x2b390
leaq 0x28(%rsp), %rdi
callq 0x2b390
leaq 0xf8(%rsp), %rdi
callq 0x2d734
leaq 0x58(%rsp), %rdi
callq 0x2b390
movq %rbx, %rdi
callq 0x2b370
nop
|
/bidfx[P]bidfx-api-cpp/example/api_example.cpp
|
bidfx_public_api::ApiExample::OnSubscriptionStatus(std::shared_ptr<bidfx_public_api::SubscriptionStatusEvent>)
|
void ApiExample::OnSubscriptionStatus(std::shared_ptr<SubscriptionStatusEvent> event)
{
logger_->info("Subscription Status Update: {} -> {}: {}", event->GetSubject(), event->GetStatus(), event->GetExplanation());
}
|
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq 0x18(%rdi), %rbx
movq (%rsi), %rsi
leaq 0x10(%rsp), %rdi
callq 0x2b300
movq (%r14), %rdi
callq 0x2b510
movl %eax, 0xc(%rsp)
movq (%r14), %rsi
leaq 0x28(%rsp), %rdi
callq 0x2b3e0
leaq 0x13215(%rip), %rsi # 0x40316
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
leaq 0x28(%rsp), %r8
movq %rbx, %rdi
callq 0x2d768
leaq 0x28(%rsp), %rdi
callq 0x2b390
leaq 0x10(%rsp), %rdi
callq 0x2d6da
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2b390
jmp 0x2d148
jmp 0x2d145
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2d6da
movq %rbx, %rdi
callq 0x2b370
|
/bidfx[P]bidfx-api-cpp/example/api_example.cpp
|
std::enable_if<std::is_integral<unsigned int>::value, std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>>::type fmt::v5::internal::arg_formatter_base<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::operator()<unsigned int>(unsigned int)
|
typename std::enable_if<std::is_integral<T>::value, iterator>::type
operator()(T value) {
// MSVC2013 fails to compile separate overloads for bool and char_type so
// use std::is_same instead.
if (std::is_same<T, bool>::value) {
if (specs_ && specs_->type_)
return (*this)(value ? 1 : 0);
write(value != 0);
} else if (std::is_same<T, char_type>::value) {
internal::handle_char_specs(
specs_, char_spec_handler(*this, static_cast<char_type>(value)));
} else {
specs_ ? writer_.write_int(value, *specs_) : writer_.write(value);
}
return out();
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdx
testq %rdx, %rdx
je 0x2e356
callq 0x2f8d6
jmp 0x2e35b
callq 0x308d2
movq (%rbx), %rax
popq %rbx
retq
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
std::enable_if<std::is_integral<long long>::value, std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>>::type fmt::v5::internal::arg_formatter_base<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::operator()<long long>(long long)
|
typename std::enable_if<std::is_integral<T>::value, iterator>::type
operator()(T value) {
// MSVC2013 fails to compile separate overloads for bool and char_type so
// use std::is_same instead.
if (std::is_same<T, bool>::value) {
if (specs_ && specs_->type_)
return (*this)(value ? 1 : 0);
write(value != 0);
} else if (std::is_same<T, char_type>::value) {
internal::handle_char_specs(
specs_, char_spec_handler(*this, static_cast<char_type>(value)));
} else {
specs_ ? writer_.write_int(value, *specs_) : writer_.write(value);
}
return out();
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdx
testq %rdx, %rdx
je 0x2e374
callq 0x308fe
jmp 0x2e379
callq 0x31bb6
movq (%rbx), %rax
popq %rbx
retq
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
std::enable_if<std::is_integral<unsigned long long>::value, std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>>::type fmt::v5::internal::arg_formatter_base<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::operator()<unsigned long long>(unsigned long long)
|
typename std::enable_if<std::is_integral<T>::value, iterator>::type
operator()(T value) {
// MSVC2013 fails to compile separate overloads for bool and char_type so
// use std::is_same instead.
if (std::is_same<T, bool>::value) {
if (specs_ && specs_->type_)
return (*this)(value ? 1 : 0);
write(value != 0);
} else if (std::is_same<T, char_type>::value) {
internal::handle_char_specs(
specs_, char_spec_handler(*this, static_cast<char_type>(value)));
} else {
specs_ ? writer_.write_int(value, *specs_) : writer_.write(value);
}
return out();
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdx
testq %rdx, %rdx
je 0x2e392
callq 0x31c0a
jmp 0x2e397
callq 0x32c70
movq (%rbx), %rax
popq %rbx
retq
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::internal::handle_int_type_spec<char, fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<int, fmt::v5::basic_format_specs<char>>>(char, fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<int, fmt::v5::basic_format_specs<char>>&&)
|
FMT_CONSTEXPR void handle_int_type_spec(Char spec, Handler &&handler) {
switch (spec) {
case 0: case 'd':
handler.on_dec();
break;
case 'x': case 'X':
handler.on_hex();
break;
case 'b': case 'B':
handler.on_bin();
break;
case 'o':
handler.on_oct();
break;
case 'n':
handler.on_num();
break;
default:
handler.on_error();
}
}
|
testl %edi, %edi
je 0x2e612
cmpl $0x42, %edi
je 0x2e622
cmpl $0x58, %edi
je 0x2e61a
cmpl $0x62, %edi
je 0x2e622
cmpl $0x78, %edi
je 0x2e61a
cmpl $0x6e, %edi
je 0x2e632
cmpl $0x6f, %edi
je 0x2e62a
cmpl $0x64, %edi
jne 0x2e63a
movq %rsi, %rdi
jmp 0x2e642
movq %rsi, %rdi
jmp 0x2e672
movq %rsi, %rdi
jmp 0x2e6d8
movq %rsi, %rdi
jmp 0x2e730
movq %rsi, %rdi
jmp 0x2e778
movq %rsi, %rdi
jmp 0x2e7e2
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<int, fmt::v5::basic_format_specs<char>>::hex_writer>::operator()<char*&>(char*&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x2ee02
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x2ee1e
leaq (%r15,%rdx), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2ee3c
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
char* fmt::v5::internal::format_uint<4u, char, unsigned int>(char*, unsigned int, unsigned int, bool)
|
inline Char *format_uint(Char *buffer, UInt value, unsigned num_digits,
bool upper = false) {
buffer += num_digits;
Char *end = buffer;
do {
const char *digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
unsigned digit = (value & ((1 << BASE_BITS) - 1));
*--buffer = BASE_BITS < 4 ? static_cast<char>('0' + digit) : digits[digit];
} while ((value >>= BASE_BITS) != 0);
return end;
}
|
movl %edx, %r8d
leaq (%rdi,%r8), %rax
leaq 0x119cc(%rip), %r9 # 0x40840
leaq 0x119d6(%rip), %rdx # 0x40851
testl %ecx, %ecx
cmovneq %r9, %rdx
leaq (%rdi,%r8), %rcx
decq %rcx
movl %esi, %edi
movl %esi, %r8d
andl $0xf, %r8d
movb (%rdx,%r8), %r8b
movb %r8b, (%rcx)
shrl $0x4, %edi
decq %rcx
cmpl $0xf, %esi
movl %edi, %esi
ja 0x2ee8a
retq
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
unsigned int fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<int, fmt::v5::basic_format_specs<char>>::count_digits<1u>() const
|
unsigned count_digits() const {
unsigned_type n = abs_value;
unsigned num_digits = 0;
do {
++num_digits;
} while ((n >>= BITS) != 0);
return num_digits;
}
|
movl 0x10(%rdi), %ecx
xorl %eax, %eax
movl %ecx, %edx
incl %eax
shrl %edx
cmpl $0x1, %ecx
movl %edx, %ecx
ja 0x2eead
retq
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<int, fmt::v5::basic_format_specs<char>>::bin_writer<1>>::operator()<char*>(char*&&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x2f08c
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x2f0a8
leaq (%r15,%rdx), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2f12e
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
char* fmt::v5::internal::format_uint<1u, char, unsigned int>(char*, unsigned int, unsigned int, bool)
|
inline Char *format_uint(Char *buffer, UInt value, unsigned num_digits,
bool upper = false) {
buffer += num_digits;
Char *end = buffer;
do {
const char *digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
unsigned digit = (value & ((1 << BASE_BITS) - 1));
*--buffer = BASE_BITS < 4 ? static_cast<char>('0' + digit) : digits[digit];
} while ((value >>= BASE_BITS) != 0);
return end;
}
|
movl %edx, %ecx
leaq (%rdi,%rcx), %rax
addq %rdi, %rcx
decq %rcx
movl %esi, %edx
movl %esi, %edi
andb $0x1, %dil
orb $0x30, %dil
movb %dil, (%rcx)
shrl %edx
decq %rcx
cmpl $0x1, %esi
movl %edx, %esi
ja 0x2f157
retq
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
unsigned int fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<int, fmt::v5::basic_format_specs<char>>::count_digits<3u>() const
|
unsigned count_digits() const {
unsigned_type n = abs_value;
unsigned num_digits = 0;
do {
++num_digits;
} while ((n >>= BITS) != 0);
return num_digits;
}
|
movl 0x10(%rdi), %ecx
xorl %eax, %eax
movl %ecx, %edx
incl %eax
shrl $0x3, %edx
cmpl $0x7, %ecx
movl %edx, %ecx
ja 0x2f179
retq
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::bin_writer<3>>::operator()<char*>(char*&&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x30540
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x3055c
leaq (%r15,%rdx), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x305e2
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::bin_writer<3>>::operator()<char*&>(char*&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x305a8
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x305c4
leaq (%r15,%rdx), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x305e2
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_padded<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::num_writer>>(unsigned long, fmt::v5::align_spec const&, fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::num_writer>&&)
|
void basic_writer<Range>::write_padded(
std::size_t size, const align_spec &spec, F &&f) {
unsigned width = spec.width();
if (width <= size)
return f(reserve(size));
auto &&it = reserve(width);
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = width - size;
if (spec.align() == ALIGN_RIGHT) {
it = std::fill_n(it, padding, fill);
f(it);
} else if (spec.align() == ALIGN_CENTER) {
std::size_t left_padding = padding / 2;
it = std::fill_n(it, left_padding, fill);
f(it);
it = std::fill_n(it, padding - left_padding, fill);
} else {
f(it);
it = std::fill_n(it, padding, fill);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl (%rdx), %eax
movq %rax, %r14
subq %rsi, %r14
jbe 0x30732
movq %rdx, %r15
movq %rax, %rsi
callq 0x2eb52
movq %rax, 0x8(%rsp)
movb 0x4(%r15), %bpl
movl 0x8(%r15), %ecx
cmpl $0x3, %ecx
je 0x30749
cmpl $0x2, %ecx
jne 0x3078a
movq %rax, %r15
addq %r14, %r15
movzbl %bpl, %esi
movq %rax, %rdi
movq %r14, %rdx
callq 0x2b1a0
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x3081e
jmp 0x307a9
callq 0x2eb52
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x307b6
jmp 0x307a9
movq %r14, %r15
shrq %r15
cmpq $0x2, %r14
jb 0x3076d
movq %rax, %r12
addq %r15, %r12
movzbl %bpl, %esi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2b1a0
movq %r12, %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3081e
movq (%r12), %rdi
subq %r15, %r14
jmp 0x3079d
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3081e
movq (%r15), %rdi
movzbl %bpl, %esi
movq %r14, %rdx
callq 0x2b1a0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<long long, fmt::v5::basic_format_specs<char>>::dec_writer>::operator()<char*>(char*&&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x30e00
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x30e1c
leaq (%r15,%rdx), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x30ea2
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<long long, fmt::v5::basic_format_specs<char>>::bin_writer<1>>::operator()<char*>(char*&&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x3142e
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x3144a
leaq (%r15,%rdx), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x314d0
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::write_padded<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::hex_writer>>(unsigned long, fmt::v5::align_spec const&, fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::hex_writer>&&)
|
void basic_writer<Range>::write_padded(
std::size_t size, const align_spec &spec, F &&f) {
unsigned width = spec.width();
if (width <= size)
return f(reserve(size));
auto &&it = reserve(width);
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = width - size;
if (spec.align() == ALIGN_RIGHT) {
it = std::fill_n(it, padding, fill);
f(it);
} else if (spec.align() == ALIGN_CENTER) {
std::size_t left_padding = padding / 2;
it = std::fill_n(it, left_padding, fill);
f(it);
it = std::fill_n(it, padding - left_padding, fill);
} else {
f(it);
it = std::fill_n(it, padding, fill);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl (%rdx), %eax
movq %rax, %r14
subq %rsi, %r14
jbe 0x3a196
movq %rdx, %r15
movq %rax, %rsi
callq 0x2eb52
movq %rax, 0x8(%rsp)
movb 0x4(%r15), %bpl
movl 0x8(%r15), %ecx
cmpl $0x3, %ecx
je 0x3a1ad
cmpl $0x2, %ecx
jne 0x3a1ee
movq %rax, %r15
addq %r14, %r15
movzbl %bpl, %esi
movq %rax, %rdi
movq %r14, %rdx
callq 0x2b1a0
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x3a282
jmp 0x3a20d
callq 0x2eb52
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3a21a
jmp 0x3a20d
movq %r14, %r15
shrq %r15
cmpq $0x2, %r14
jb 0x3a1d1
movq %rax, %r12
addq %r15, %r12
movzbl %bpl, %esi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2b1a0
movq %r12, %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3a282
movq (%r12), %rdi
subq %r15, %r14
jmp 0x3a201
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3a282
movq (%r15), %rdi
movzbl %bpl, %esi
movq %r14, %rdx
callq 0x2b1a0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::hex_writer>::operator()<char*>(char*&&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x3a248
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x3a264
leaq (%r15,%rdx), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3a2ea
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::hex_writer>::operator()<char*&>(char*&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x3a2b0
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x3a2cc
leaq (%r15,%rdx), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3a2ea
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
unsigned int fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::count_digits<1u>() const
|
unsigned count_digits() const {
unsigned_type n = abs_value;
unsigned num_digits = 0;
do {
++num_digits;
} while ((n >>= BITS) != 0);
return num_digits;
}
|
movl 0x10(%rdi), %ecx
xorl %eax, %eax
movl %ecx, %edx
incl %eax
shrl %edx
cmpl $0x1, %ecx
movl %edx, %ecx
ja 0x3a31b
retq
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::write_int<fmt::v5::basic_format_specs<char>, fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::bin_writer<1>>(unsigned int, fmt::v5::basic_string_view<char>, fmt::v5::basic_format_specs<char> const&, fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::bin_writer<1>)
|
void write_int(unsigned num_digits, string_view prefix,
const Spec &spec, F f) {
std::size_t size = prefix.size() + num_digits;
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = 0;
if (spec.align() == ALIGN_NUMERIC) {
if (spec.width() > size) {
padding = spec.width() - size;
size = spec.width();
}
} else if (spec.precision() > static_cast<int>(num_digits)) {
size = prefix.size() + static_cast<std::size_t>(spec.precision());
padding = static_cast<std::size_t>(spec.precision()) - num_digits;
fill = '0';
}
align_spec as = spec;
if (spec.align() == ALIGN_DEFAULT)
as.align_ = ALIGN_RIGHT;
write_padded(size, as, padded_int_writer<F>{prefix, fill, padding, f});
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %eax
movl %esi, %r11d
leaq (%r11,%rcx), %rsi
movb 0x4(%r8), %r10b
movl 0x8(%r8), %ebx
cmpl $0x4, %ebx
jne 0x3a374
movl (%r8), %eax
cmpq %rax, %rsi
movq %rax, %rbx
cmovaq %rsi, %rbx
xorl %r11d, %r11d
subq %rsi, %rax
cmovaeq %rax, %r11
movl 0x8(%r8), %eax
movl %eax, 0x8(%rsp)
movq (%r8), %rax
movq %rax, (%rsp)
movq %rbx, %rsi
jmp 0x3a3b7
movslq 0x10(%r8), %r14
leaq (%r14,%rcx), %r15
movq %r14, %r12
subq %r11, %r12
xorl %r11d, %r11d
cmpl %eax, %r14d
cmovgq %r15, %rsi
movzbl %r10b, %eax
pushq $0x30
popq %r10
cmovlel %eax, %r10d
cmovgq %r12, %r11
movl 0x8(%r8), %eax
movl %eax, 0x8(%rsp)
movq (%r8), %rax
movq %rax, (%rsp)
testl %ebx, %ebx
jne 0x3a3b7
movl $0x2, 0x8(%rsp)
leaq 0x10(%rsp), %rax
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movb %r10b, 0x10(%rax)
movq %r11, 0x18(%rax)
movq %r9, 0x20(%rax)
movq %rsp, %rdx
movq %rax, %rcx
callq 0x3a3e6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::bin_writer<1>>::operator()<char*>(char*&&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x3a4fa
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x3a516
leaq (%r15,%rdx), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3a59c
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::bin_writer<1>>::operator()<char*&>(char*&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x3a562
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x3a57e
leaq (%r15,%rdx), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3a59c
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
unsigned int fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::count_digits<3u>() const
|
unsigned count_digits() const {
unsigned_type n = abs_value;
unsigned num_digits = 0;
do {
++num_digits;
} while ((n >>= BITS) != 0);
return num_digits;
}
|
movl 0x10(%rdi), %ecx
xorl %eax, %eax
movl %ecx, %edx
incl %eax
shrl $0x3, %edx
cmpl $0x7, %ecx
movl %edx, %ecx
ja 0x3a5bf
retq
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::write_int<fmt::v5::basic_format_specs<char>, fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::bin_writer<3>>(unsigned int, fmt::v5::basic_string_view<char>, fmt::v5::basic_format_specs<char> const&, fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::bin_writer<3>)
|
void write_int(unsigned num_digits, string_view prefix,
const Spec &spec, F f) {
std::size_t size = prefix.size() + num_digits;
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = 0;
if (spec.align() == ALIGN_NUMERIC) {
if (spec.width() > size) {
padding = spec.width() - size;
size = spec.width();
}
} else if (spec.precision() > static_cast<int>(num_digits)) {
size = prefix.size() + static_cast<std::size_t>(spec.precision());
padding = static_cast<std::size_t>(spec.precision()) - num_digits;
fill = '0';
}
align_spec as = spec;
if (spec.align() == ALIGN_DEFAULT)
as.align_ = ALIGN_RIGHT;
write_padded(size, as, padded_int_writer<F>{prefix, fill, padding, f});
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %eax
movl %esi, %r11d
leaq (%r11,%rcx), %rsi
movb 0x4(%r8), %r10b
movl 0x8(%r8), %ebx
cmpl $0x4, %ebx
jne 0x3a618
movl (%r8), %eax
cmpq %rax, %rsi
movq %rax, %rbx
cmovaq %rsi, %rbx
xorl %r11d, %r11d
subq %rsi, %rax
cmovaeq %rax, %r11
movl 0x8(%r8), %eax
movl %eax, 0x8(%rsp)
movq (%r8), %rax
movq %rax, (%rsp)
movq %rbx, %rsi
jmp 0x3a65b
movslq 0x10(%r8), %r14
leaq (%r14,%rcx), %r15
movq %r14, %r12
subq %r11, %r12
xorl %r11d, %r11d
cmpl %eax, %r14d
cmovgq %r15, %rsi
movzbl %r10b, %eax
pushq $0x30
popq %r10
cmovlel %eax, %r10d
cmovgq %r12, %r11
movl 0x8(%r8), %eax
movl %eax, 0x8(%rsp)
movq (%r8), %rax
movq %rax, (%rsp)
testl %ebx, %ebx
jne 0x3a65b
movl $0x2, 0x8(%rsp)
leaq 0x10(%rsp), %rax
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movb %r10b, 0x10(%rax)
movq %r11, 0x18(%rax)
movq %r9, 0x20(%rax)
movq %rsp, %rdx
movq %rax, %rcx
callq 0x3a68a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::write_padded<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::bin_writer<3>>>(unsigned long, fmt::v5::align_spec const&, fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::bin_writer<3>>&&)
|
void basic_writer<Range>::write_padded(
std::size_t size, const align_spec &spec, F &&f) {
unsigned width = spec.width();
if (width <= size)
return f(reserve(size));
auto &&it = reserve(width);
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = width - size;
if (spec.align() == ALIGN_RIGHT) {
it = std::fill_n(it, padding, fill);
f(it);
} else if (spec.align() == ALIGN_CENTER) {
std::size_t left_padding = padding / 2;
it = std::fill_n(it, left_padding, fill);
f(it);
it = std::fill_n(it, padding - left_padding, fill);
} else {
f(it);
it = std::fill_n(it, padding, fill);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl (%rdx), %eax
movq %rax, %r14
subq %rsi, %r14
jbe 0x3a6ec
movq %rdx, %r15
movq %rax, %rsi
callq 0x2eb52
movq %rax, 0x8(%rsp)
movb 0x4(%r15), %bpl
movl 0x8(%r15), %ecx
cmpl $0x3, %ecx
je 0x3a703
cmpl $0x2, %ecx
jne 0x3a744
movq %rax, %r15
addq %r14, %r15
movzbl %bpl, %esi
movq %rax, %rdi
movq %r14, %rdx
callq 0x2b1a0
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x3a7d8
jmp 0x3a763
callq 0x2eb52
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3a770
jmp 0x3a763
movq %r14, %r15
shrq %r15
cmpq $0x2, %r14
jb 0x3a727
movq %rax, %r12
addq %r15, %r12
movzbl %bpl, %esi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2b1a0
movq %r12, %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3a7d8
movq (%r12), %rdi
subq %r15, %r14
jmp 0x3a757
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3a7d8
movq (%r15), %rdi
movzbl %bpl, %esi
movq %r14, %rdx
callq 0x2b1a0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::write_int<fmt::v5::basic_format_specs<char>, fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::num_writer>(unsigned int, fmt::v5::basic_string_view<char>, fmt::v5::basic_format_specs<char> const&, fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::num_writer)
|
void write_int(unsigned num_digits, string_view prefix,
const Spec &spec, F f) {
std::size_t size = prefix.size() + num_digits;
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = 0;
if (spec.align() == ALIGN_NUMERIC) {
if (spec.width() > size) {
padding = spec.width() - size;
size = spec.width();
}
} else if (spec.precision() > static_cast<int>(num_digits)) {
size = prefix.size() + static_cast<std::size_t>(spec.precision());
padding = static_cast<std::size_t>(spec.precision()) - num_digits;
fill = '0';
}
align_spec as = spec;
if (spec.align() == ALIGN_DEFAULT)
as.align_ = ALIGN_RIGHT;
write_padded(size, as, padded_int_writer<F>{prefix, fill, padding, f});
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %eax
leaq 0x70(%rsp), %r9
movl %esi, %r11d
leaq (%r11,%rcx), %rsi
movb 0x4(%r8), %r10b
movl 0x8(%r8), %ebx
cmpl $0x4, %ebx
jne 0x3a8ae
movl (%r8), %eax
cmpq %rax, %rsi
movq %rax, %rbx
cmovaq %rsi, %rbx
xorl %r11d, %r11d
subq %rsi, %rax
cmovaeq %rax, %r11
movl 0x8(%r8), %eax
movl %eax, 0x10(%rsp)
movq (%r8), %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rsi
jmp 0x3a8f2
movslq 0x10(%r8), %r14
leaq (%r14,%rcx), %r15
movq %r14, %r12
subq %r11, %r12
xorl %r11d, %r11d
cmpl %eax, %r14d
cmovgq %r15, %rsi
movzbl %r10b, %eax
pushq $0x30
popq %r10
cmovlel %eax, %r10d
cmovgq %r12, %r11
movl 0x8(%r8), %eax
movl %eax, 0x10(%rsp)
movq (%r8), %rax
movq %rax, 0x8(%rsp)
testl %ebx, %ebx
jne 0x3a8f2
movl $0x2, 0x10(%rsp)
leaq 0x18(%rsp), %rax
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movb %r10b, 0x10(%rax)
movq %r11, 0x18(%rax)
movq (%r9), %rcx
movq %rcx, 0x20(%rax)
movl 0x8(%r9), %ecx
movl %ecx, 0x28(%rax)
leaq 0x8(%rsp), %rdx
movq %rax, %rcx
callq 0x3a92e
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::write_padded<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::num_writer>>(unsigned long, fmt::v5::align_spec const&, fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::num_writer>&&)
|
void basic_writer<Range>::write_padded(
std::size_t size, const align_spec &spec, F &&f) {
unsigned width = spec.width();
if (width <= size)
return f(reserve(size));
auto &&it = reserve(width);
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = width - size;
if (spec.align() == ALIGN_RIGHT) {
it = std::fill_n(it, padding, fill);
f(it);
} else if (spec.align() == ALIGN_CENTER) {
std::size_t left_padding = padding / 2;
it = std::fill_n(it, left_padding, fill);
f(it);
it = std::fill_n(it, padding - left_padding, fill);
} else {
f(it);
it = std::fill_n(it, padding, fill);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl (%rdx), %eax
movq %rax, %r14
subq %rsi, %r14
jbe 0x3a990
movq %rdx, %r15
movq %rax, %rsi
callq 0x2eb52
movq %rax, 0x8(%rsp)
movb 0x4(%r15), %bpl
movl 0x8(%r15), %ecx
cmpl $0x3, %ecx
je 0x3a9a7
cmpl $0x2, %ecx
jne 0x3a9e8
movq %rax, %r15
addq %r14, %r15
movzbl %bpl, %esi
movq %rax, %rdi
movq %r14, %rdx
callq 0x2b1a0
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x3aa7c
jmp 0x3aa07
callq 0x2eb52
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3aa14
jmp 0x3aa07
movq %r14, %r15
shrq %r15
cmpq $0x2, %r14
jb 0x3a9cb
movq %rax, %r12
addq %r15, %r12
movzbl %bpl, %esi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2b1a0
movq %r12, %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3aa7c
movq (%r12), %rdi
subq %r15, %r14
jmp 0x3a9fb
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3aa7c
movq (%r15), %rdi
movzbl %bpl, %esi
movq %r14, %rdx
callq 0x2b1a0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::num_writer>::operator()<char*>(char*&&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x3aa42
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x3aa5e
leaq (%r15,%rdx), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3aae4
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::num_writer>::operator()<char*&>(char*&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x3aaaa
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x3aac6
leaq (%r15,%rdx), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3aae4
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<long long, fmt::v5::basic_format_specs<char>>::on_hex()
|
void on_hex() {
if (spec.flag(HASH_FLAG)) {
prefix[prefix_size++] = '0';
prefix[prefix_size++] = static_cast<char>(spec.type());
}
unsigned num_digits = count_digits<4>();
writer.write_int(num_digits, get_prefix(), spec,
hex_writer{*this, num_digits});
}
|
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testb $0x8, 0xc(%rax)
je 0x3ac8e
movl 0x1c(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x1c(%rbx)
movb $0x30, 0x18(%rbx,%rcx)
movb 0x14(%rax), %al
movl 0x1c(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x1c(%rbx)
movb %al, 0x18(%rbx,%rcx)
movq %rbx, %rdi
callq 0x3b0d4
leaq 0x18(%rbx), %rdx
movl 0x1c(%rbx), %ecx
movq (%rbx), %rdi
movq 0x8(%rbx), %r8
movq %rbx, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rsp)
movl %eax, %esi
callq 0x3b0ee
addq $0x20, %rsp
popq %rbx
retq
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
unsigned int fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<long long, fmt::v5::basic_format_specs<char>>::count_digits<4u>() const
|
unsigned count_digits() const {
unsigned_type n = abs_value;
unsigned num_digits = 0;
do {
++num_digits;
} while ((n >>= BITS) != 0);
return num_digits;
}
|
movq 0x10(%rdi), %rcx
xorl %eax, %eax
movq %rcx, %rdx
incl %eax
shrq $0x4, %rdx
cmpq $0xf, %rcx
movq %rdx, %rcx
ja 0x3b0dd
retq
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
unsigned int fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<long long, fmt::v5::basic_format_specs<char>>::count_digits<1u>() const
|
unsigned count_digits() const {
unsigned_type n = abs_value;
unsigned num_digits = 0;
do {
++num_digits;
} while ((n >>= BITS) != 0);
return num_digits;
}
|
movq 0x10(%rdi), %rcx
xorl %eax, %eax
movq %rcx, %rdx
incl %eax
shrq %rdx
cmpq $0x1, %rcx
movq %rdx, %rcx
ja 0x3b3ab
retq
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::write_int<fmt::v5::basic_format_specs<char>, fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<long long, fmt::v5::basic_format_specs<char>>::bin_writer<1>>(unsigned int, fmt::v5::basic_string_view<char>, fmt::v5::basic_format_specs<char> const&, fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<long long, fmt::v5::basic_format_specs<char>>::bin_writer<1>)
|
void write_int(unsigned num_digits, string_view prefix,
const Spec &spec, F f) {
std::size_t size = prefix.size() + num_digits;
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = 0;
if (spec.align() == ALIGN_NUMERIC) {
if (spec.width() > size) {
padding = spec.width() - size;
size = spec.width();
}
} else if (spec.precision() > static_cast<int>(num_digits)) {
size = prefix.size() + static_cast<std::size_t>(spec.precision());
padding = static_cast<std::size_t>(spec.precision()) - num_digits;
fill = '0';
}
align_spec as = spec;
if (spec.align() == ALIGN_DEFAULT)
as.align_ = ALIGN_RIGHT;
write_padded(size, as, padded_int_writer<F>{prefix, fill, padding, f});
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %eax
leaq 0x70(%rsp), %r9
movl %esi, %r11d
leaq (%r11,%rcx), %rsi
movb 0x4(%r8), %r10b
movl 0x8(%r8), %ebx
cmpl $0x4, %ebx
jne 0x3b40c
movl (%r8), %eax
cmpq %rax, %rsi
movq %rax, %rbx
cmovaq %rsi, %rbx
xorl %r11d, %r11d
subq %rsi, %rax
cmovaeq %rax, %r11
movl 0x8(%r8), %eax
movl %eax, 0x10(%rsp)
movq (%r8), %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rsi
jmp 0x3b450
movslq 0x10(%r8), %r14
leaq (%r14,%rcx), %r15
movq %r14, %r12
subq %r11, %r12
xorl %r11d, %r11d
cmpl %eax, %r14d
cmovgq %r15, %rsi
movzbl %r10b, %eax
pushq $0x30
popq %r10
cmovlel %eax, %r10d
cmovgq %r12, %r11
movl 0x8(%r8), %eax
movl %eax, 0x10(%rsp)
movq (%r8), %rax
movq %rax, 0x8(%rsp)
testl %ebx, %ebx
jne 0x3b450
movl $0x2, 0x10(%rsp)
leaq 0x18(%rsp), %rax
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movb %r10b, 0x10(%rax)
movq %r11, 0x18(%rax)
movups (%r9), %xmm0
movups %xmm0, 0x20(%rax)
leaq 0x8(%rsp), %rdx
movq %rax, %rcx
callq 0x3b486
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<long long, fmt::v5::basic_format_specs<char>>::bin_writer<3>>::operator()<char*&>(char*&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x3b8ba
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x3b8d6
leaq (%r15,%rdx), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3b8f4
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned long long, fmt::v5::basic_format_specs<char>>::dec_writer>::operator()<char*&>(char*&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x3c13a
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x3c156
leaq (%r15,%rdx), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3c174
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
unsigned int fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned long long, fmt::v5::basic_format_specs<char>>::count_digits<4u>() const
|
unsigned count_digits() const {
unsigned_type n = abs_value;
unsigned num_digits = 0;
do {
++num_digits;
} while ((n >>= BITS) != 0);
return num_digits;
}
|
movq 0x10(%rdi), %rcx
xorl %eax, %eax
movq %rcx, %rdx
incl %eax
shrq $0x4, %rdx
cmpq $0xf, %rcx
movq %rdx, %rcx
ja 0x3c197
retq
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned long long, fmt::v5::basic_format_specs<char>>::bin_writer<1>>::operator()<char*&>(char*&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x3c6bc
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x3c6d8
leaq (%r15,%rdx), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3c6f6
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
unsigned int fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned long long, fmt::v5::basic_format_specs<char>>::count_digits<3u>() const
|
unsigned count_digits() const {
unsigned_type n = abs_value;
unsigned num_digits = 0;
do {
++num_digits;
} while ((n >>= BITS) != 0);
return num_digits;
}
|
movq 0x10(%rdi), %rcx
xorl %eax, %eax
movq %rcx, %rdx
incl %eax
shrq $0x3, %rdx
cmpq $0x7, %rcx
movq %rdx, %rcx
ja 0x3c71b
retq
nop
|
/bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h
|
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.