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;... | 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
adds... | /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[... | 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,%r... | /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 = wid... | 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), %xm... | /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_f... | 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 ... | /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 =... | 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... | /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 = N... | 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, ... | /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_separ... | 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, %c... | /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 sub... | 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
... | /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[... | 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), %ea... | /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 = SliderBe... | 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, (... | /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... | 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(%... | /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), ... | /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... | 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)
j... | /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.NextWi... | 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, %... | /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; }... | 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 %r... | /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)
... | 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 0x... | /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)... | 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(%ri... | /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;
retu... | 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 (%... | /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);
... | 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
... | /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, %r... | /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) {
... | 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... | /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 = (da... | 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
mov... | /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 & ImGui... | 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
... | /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 & ImGui... | 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)... | /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];
ImFormatStri... | 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
m... | /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_clamp... | 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 0x78... | /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_clamp... | 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), %xm... | /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.MouseWhe... | 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 ... | /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_VER... | 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, %e... | /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(G... | 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 = ... | /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 curc... | 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 (%... | /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)... | 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... | /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_si... | 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)
cmova... | /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 )
d... | 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... | /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[... | 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 = 0x380000... | /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.... | 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... | /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];
}
f... | 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 %es... | /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 ... | 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,... | /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_ENCS... | 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 ... | /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_ARGUME... | 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 0x... | /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 =
EX... | 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 $0... | /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;
... | 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 %e... | /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;
}... | 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... | /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... | 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_WRITI... | 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 ... | /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_... | 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
mo... | /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)
re... | 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),... | /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 != ... | 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), %ea... | /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) l... | 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 ... | /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)}};
... | 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... | /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)... | /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 (ctx... | 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, %... | /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)... | /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 (%... | /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)
{
... | 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
call... | /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,
... | 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
le... | /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)
{
... | 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... | /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... | /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->... | 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 %eb... | /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")
... | 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 %r... | /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")
... | 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 %... | /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
... | /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);... | 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);... | 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);... | 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_... | 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':
handle... | 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, ... | /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), ... | /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 = BAS... | 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 %e... | /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), ... | /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 = BAS... | 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), ... | /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), ... | /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<uns... | 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()... | 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 %... | /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), ... | /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), ... | /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:... | 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()... | 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 %... | /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>>::... | 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), ... | /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>>::... | 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), ... | /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::... | 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) {
pa... | 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),... | /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>>::... | 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), ... | /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>>::... | 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), ... | /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::... | 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) {
pa... | 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),... | /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:... | 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()... | 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 %... | /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::... | 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) {
pa... | 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... | /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:... | 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()... | 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 %... | /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>>::... | 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), ... | /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>>::... | 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), ... | /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
c... | /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::bas... | 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) {
pa... | 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... | /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... | 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), ... | /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<ch... | 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), ... | /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<ch... | 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), ... | /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.