// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableHeader(char const*)
void ImGui::TableHeader(const char* label)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->SkipItems)
        return;

    ImGuiTable* table = g.CurrentTable;
    IM_ASSERT(table != NULL && "Need to call TableHeader() after BeginTable()!");
    IM_ASSERT(table->CurrentColumn != -1);
    const int column_n = table->CurrentColumn;
    ImGuiTableColumn* column = &table->Columns[column_n];

    // Label
    if (label == NULL)
        label = "";
    const char* label_end = FindRenderedTextEnd(label);
    ImVec2 label_size = CalcTextSize(label, label_end, true);
    ImVec2 label_pos = window->DC.CursorPos;

    // If we already got a row height, there's use that.
    // FIXME-TABLE: Padding problem if the correct outer-padding CellBgRect strays off our ClipRect?
    ImRect cell_r = TableGetCellBgRect(table, column_n);
    float label_height = ImMax(label_size.y, table->RowMinHeight - table->CellPaddingY * 2.0f);

    // Calculate ideal size for sort order arrow
    float w_arrow = 0.0f;
    float w_sort_text = 0.0f;
    char sort_order_suf[4] = "";
    const float ARROW_SCALE = 0.65f;
    if ((table->Flags & ImGuiTableFlags_Sortable) && !(column->Flags & ImGuiTableColumnFlags_NoSort))
    {
        w_arrow = ImFloor(g.FontSize * ARROW_SCALE + g.Style.FramePadding.x);
        if (column->SortOrder > 0)
        {
            ImFormatString(sort_order_suf, IM_ARRAYSIZE(sort_order_suf), "%d", column->SortOrder + 1);
            w_sort_text = g.Style.ItemInnerSpacing.x + CalcTextSize(sort_order_suf).x;
        }
    }

    // We feed our unclipped width to the column without writing on CursorMaxPos, so that column is still considering for merging.
    float max_pos_x = label_pos.x + label_size.x + w_sort_text + w_arrow;
    column->ContentMaxXHeadersUsed = ImMax(column->ContentMaxXHeadersUsed, column->WorkMaxX);
    column->ContentMaxXHeadersIdeal = ImMax(column->ContentMaxXHeadersIdeal, max_pos_x);

    // Keep header highlighted when context menu is open.
    const bool selected = (table->IsContextPopupOpen && table->ContextPopupColumn == column_n && table->InstanceInteracted == table->InstanceCurrent);
    ImGuiID id = window->GetID(label);
    ImRect bb(cell_r.Min.x, cell_r.Min.y, cell_r.Max.x, ImMax(cell_r.Max.y, cell_r.Min.y + label_height + g.Style.CellPadding.y * 2.0f));
    ItemSize(ImVec2(0.0f, label_height)); // Don't declare unclipped width, it'll be fed ContentMaxPosHeadersIdeal
    if (!ItemAdd(bb, id))
        return;

    //GetForegroundDrawList()->AddRect(cell_r.Min, cell_r.Max, IM_COL32(255, 0, 0, 255)); // [DEBUG]
    //GetForegroundDrawList()->AddRect(bb.Min, bb.Max, IM_COL32(255, 0, 0, 255)); // [DEBUG]

    // Using AllowItemOverlap mode because we cover the whole cell, and we want user to be able to submit subsequent items.
    bool hovered, held;
    bool pressed = ButtonBehavior(bb, id, &hovered, &held, ImGuiButtonFlags_AllowItemOverlap);
    if (g.ActiveId != id)
        SetItemAllowOverlap();
    if (held || hovered || selected)
    {
        const ImU32 col = GetColorU32(held ? ImGuiCol_HeaderActive : hovered ? ImGuiCol_HeaderHovered : ImGuiCol_Header);
        //RenderFrame(bb.Min, bb.Max, col, false, 0.0f);
        TableSetBgColor(ImGuiTableBgTarget_CellBg, col, table->CurrentColumn);
        RenderNavHighlight(bb, id, ImGuiNavHighlightFlags_TypeThin | ImGuiNavHighlightFlags_NoRounding);
    }
    else
    {
        // Submit single cell bg color in the case we didn't submit a full header row
        if ((table->RowFlags & ImGuiTableRowFlags_Headers) == 0)
            TableSetBgColor(ImGuiTableBgTarget_CellBg, GetColorU32(ImGuiCol_TableHeaderBg), table->CurrentColumn);
    }
    if (held)
        table->HeldHeaderColumn = (ImGuiTableColumnIdx)column_n;
    window->DC.CursorPos.y -= g.Style.ItemSpacing.y * 0.5f;

    // Drag and drop to re-order columns.
    // FIXME-TABLE: Scroll request while reordering a column and it lands out of the scrolling zone.
    if (held && (table->Flags & ImGuiTableFlags_Reorderable) && IsMouseDragging(0) && !g.DragDropActive)
    {
        // While moving a column it will jump on the other side of the mouse, so we also test for MouseDelta.x
        table->ReorderColumn = (ImGuiTableColumnIdx)column_n;
        table->InstanceInteracted = table->InstanceCurrent;

        // We don't reorder: through the frozen<>unfrozen line, or through a column that is marked with ImGuiTableColumnFlags_NoReorder.
        if (g.IO.MouseDelta.x < 0.0f && g.IO.MousePos.x < cell_r.Min.x)
            if (ImGuiTableColumn* prev_column = (column->PrevEnabledColumn != -1) ? &table->Columns[column->PrevEnabledColumn] : NULL)
                if (!((column->Flags | prev_column->Flags) & ImGuiTableColumnFlags_NoReorder))
                    if ((column->IndexWithinEnabledSet < table->FreezeColumnsRequest) == (prev_column->IndexWithinEnabledSet < table->FreezeColumnsRequest))
                        table->ReorderColumnDir = -1;
        if (g.IO.MouseDelta.x > 0.0f && g.IO.MousePos.x > cell_r.Max.x)
            if (ImGuiTableColumn* next_column = (column->NextEnabledColumn != -1) ? &table->Columns[column->NextEnabledColumn] : NULL)
                if (!((column->Flags | next_column->Flags) & ImGuiTableColumnFlags_NoReorder))
                    if ((column->IndexWithinEnabledSet < table->FreezeColumnsRequest) == (next_column->IndexWithinEnabledSet < table->FreezeColumnsRequest))
                        table->ReorderColumnDir = +1;
    }

    // Sort order arrow
    const float ellipsis_max = cell_r.Max.x - w_arrow - w_sort_text;
    if ((table->Flags & ImGuiTableFlags_Sortable) && !(column->Flags & ImGuiTableColumnFlags_NoSort))
    {
        if (column->SortOrder != -1)
        {
            float x = ImMax(cell_r.Min.x, cell_r.Max.x - w_arrow - w_sort_text);
            float y = label_pos.y;
            if (column->SortOrder > 0)
            {
                PushStyleColor(ImGuiCol_Text, GetColorU32(ImGuiCol_Text, 0.70f));
                RenderText(ImVec2(x + g.Style.ItemInnerSpacing.x, y), sort_order_suf);
                PopStyleColor();
                x += w_sort_text;
            }
            RenderArrow(window->DrawList, ImVec2(x, y), GetColorU32(ImGuiCol_Text), column->SortDirection == ImGuiSortDirection_Ascending ? ImGuiDir_Up : ImGuiDir_Down, ARROW_SCALE);
        }

        // Handle clicking on column header to adjust Sort Order
        if (pressed && table->ReorderColumn != column_n)
        {
            ImGuiSortDirection sort_direction = TableGetColumnNextSortDirection(column);
            TableSetColumnSortDirection(column_n, sort_direction, g.IO.KeyShift);
        }
    }

    // Render clipped label. Clipping here ensure that in the majority of situations, all our header cells will
    // be merged into a single draw call.
    //window->DrawList->AddCircleFilled(ImVec2(ellipsis_max, label_pos.y), 40, IM_COL32_WHITE);
    RenderTextEllipsis(window->DrawList, label_pos, ImVec2(ellipsis_max, label_pos.y + label_height + g.Style.FramePadding.y), ellipsis_max, ellipsis_max, label, label_end, &label_size);

    const bool text_clipped = label_size.x > (ellipsis_max - label_pos.x);
    if (text_clipped && hovered && g.HoveredIdNotActiveTimer > g.TooltipSlowDelay)
        SetTooltip("%.*s", (int)(label_end - label), label);

    // We don't use BeginPopupContextItem() because we want the popup to stay up even after the column is hidden
    if (IsMouseReleased(1) && IsItemHovered())
        TableOpenContextMenu(column_n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
leaq 0x6e07b(%rip), %rax     # 0xe3ce0
movq (%rax), %rcx
movq 0x1ae0(%rcx), %rax
movq %rax, -0x48(%rbp)
cmpb $0x0, 0x93(%rax)
jne 0x763f5
movq 0x20a8(%rcx), %r13
testq %r13, %r13
je 0x76407
movq %rcx, -0x68(%rbp)
movl 0x74(%r13), %r14d
cmpl $-0x1, %r14d
je 0x76426
movq %rdi, %rbx
leaq 0x10(%r13), %rdi
movq %rdi, -0xc8(%rbp)
movl %r14d, %esi
callq 0x4c4c6
movq %rax, %r12
testq %rbx, %rbx
leaq 0x2625c(%rip), %r15     # 0x9bf21
cmovneq %rbx, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x36123
pushq $0x1
popq %rdx
movss 0x26312(%rip), %xmm0    # 0x9bff0
movq %r15, -0xa8(%rbp)
movq %r15, %rdi
movq %rax, %rsi
movq %rax, -0xd0(%rbp)
callq 0x365e8
movaps %xmm0, -0xc0(%rbp)
movlps %xmm0, -0xe0(%rbp)
movq -0x48(%rbp), %rbx
movq 0xd8(%rbx), %r15
movq %r15, -0xd8(%rbp)
movq %r13, %rdi
movl %r14d, %esi
callq 0x74b53
movaps -0xc0(%rbp), %xmm4
movaps %xmm0, -0x90(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm4, %xmm0
shufps $0x55, %xmm4, %xmm0     # xmm0 = xmm0[1,1],xmm4[1,1]
movss 0x84(%r13), %xmm1
movss 0xc0(%r13), %xmm2
addss %xmm2, %xmm2
subss %xmm2, %xmm1
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
andps %xmm2, %xmm0
andnps %xmm1, %xmm2
orps %xmm0, %xmm2
movaps %xmm2, -0x100(%rbp)
andl $0x0, -0x4c(%rbp)
testb $0x8, 0x4(%r13)
movd %r15d, %xmm2
xorps %xmm0, %xmm0
movq %r12, -0x38(%rbp)
je 0x75e32
testb $0x1, 0x1(%r12)
jne 0x75e32
movq %r15, -0x80(%rbp)
movq -0x68(%rbp), %r15
movss 0x1980(%r15), %xmm1
mulss 0x26b34(%rip), %xmm1    # 0x9c8e4
addss 0x1598(%r15), %xmm1
cvttps2dq %xmm1, %xmm1
cvtdq2ps %xmm1, %xmm1
movzbl 0x56(%r12), %ecx
testb %cl, %cl
jle 0x75e2c
incl %ecx
leaq 0x2d9af(%rip), %rdx     # 0xa3782
leaq -0x4c(%rbp), %rbx
pushq $0x4
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
movaps %xmm1, -0x60(%rbp)
movd %xmm2, -0x30(%rbp)
callq 0x3468c
movss 0x15b0(%r15), %xmm0
movss %xmm0, -0x3c(%rbp)
movss 0x261ed(%rip), %xmm0    # 0x9bff0
movq %rbx, %rdi
movq -0x48(%rbp), %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x365e8
movd -0x30(%rbp), %xmm2
movaps -0xc0(%rbp), %xmm4
movaps -0x60(%rbp), %xmm1
movq -0x38(%rbp), %r12
addss -0x3c(%rbp), %xmm0
movq -0x80(%rbp), %r15
jmp 0x75e35
xorps %xmm1, %xmm1
addss %xmm2, %xmm4
addss %xmm0, %xmm4
movaps %xmm1, -0x60(%rbp)
addss %xmm1, %xmm4
movss 0x38(%r12), %xmm3
movss 0x48(%r12), %xmm1
movaps %xmm3, %xmm2
cmpless %xmm1, %xmm2
andps %xmm2, %xmm1
andnps %xmm3, %xmm2
orps %xmm1, %xmm2
movss %xmm2, 0x48(%r12)
movss 0x4c(%r12), %xmm3
movaps %xmm4, %xmm1
cmpless %xmm3, %xmm1
movaps %xmm1, %xmm2
andnps %xmm4, %xmm2
andps %xmm3, %xmm1
orps %xmm2, %xmm1
movss %xmm1, 0x4c(%r12)
cmpb $0x1, 0x24d(%r13)
movl %r14d, -0xc0(%rbp)
movaps %xmm0, -0x80(%rbp)
jne 0x75ec5
movsbl 0x23f(%r13), %eax
cmpl %eax, %r14d
movq -0x68(%rbp), %r12
jne 0x75ed2
movzwl 0x7a(%r13), %eax
cmpw 0x78(%r13), %ax
sete %al
movl %eax, -0x30(%rbp)
jmp 0x75ed9
movl $0x0, -0x30(%rbp)
movq -0x68(%rbp), %r12
jmp 0x75ed9
movl $0x0, -0x30(%rbp)
movq %rbx, %rdi
movq -0xa8(%rbp), %rsi
xorl %edx, %edx
callq 0x3700a
movl %eax, %ebx
movaps -0x90(%rbp), %xmm3
movaps %xmm3, %xmm0
shufps $0x55, %xmm3, %xmm0     # xmm0 = xmm0[1,1],xmm3[1,1]
movaps -0xa0(%rbp), %xmm4
movaps %xmm4, %xmm1
shufps $0x55, %xmm4, %xmm1     # xmm1 = xmm1[1,1],xmm4[1,1]
movss 0x15bc(%r12), %xmm2
leaq -0x110(%rbp), %r14
movss %xmm3, (%r14)
movss %xmm0, 0x4(%r14)
movaps -0x100(%rbp), %xmm5
addss %xmm5, %xmm0
addss %xmm2, %xmm2
addss %xmm0, %xmm2
movaps %xmm2, %xmm0
cmpless %xmm1, %xmm0
movaps %xmm0, %xmm3
andnps %xmm2, %xmm3
andps %xmm1, %xmm0
orps %xmm3, %xmm0
movss %xmm4, 0x8(%r14)
movss %xmm0, 0xc(%r14)
leaq -0xe8(%rbp), %rdi
andl $0x0, (%rdi)
movss %xmm5, 0x4(%rdi)
movss 0x26082(%rip), %xmm0    # 0x9bff0
callq 0x40d3b
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x40ea5
testb %al, %al
je 0x763f5
leaq -0x110(%rbp), %rdi
leaq -0x2a(%rbp), %rdx
leaq -0x29(%rbp), %rcx
movl %ebx, %esi
movl $0x1000, %r8d           # imm = 0x1000
callq 0x79dde
movb %al, -0x3c(%rbp)
cmpl %ebx, 0x1b30(%r12)
je 0x75fb5
callq 0x406fd
shrq $0x20, %r15
movb -0x29(%rbp), %al
movb -0x2a(%rbp), %cl
movl %eax, %edx
orb %cl, %dl
orb -0x30(%rbp), %dl
testb $0x1, %dl
movl -0xc0(%rbp), %r14d
je 0x76015
movzbl %cl, %ecx
andl $0x1, %ecx
orl $0x18, %ecx
testb %al, %al
pushq $0x1a
popq %rdi
cmovel %ecx, %edi
movss 0x2600d(%rip), %xmm0    # 0x9bff8
callq 0x35d33
movl 0x74(%r13), %edx
pushq $0x3
popq %rdi
movl %eax, %esi
callq 0x74bcf
leaq -0x110(%rbp), %rdi
pushq $0xa
popq %rdx
movl %ebx, %esi
callq 0x36c91
movq -0x48(%rbp), %rbx
jmp 0x76041
testb $0x1, 0x90(%r13)
movq -0x48(%rbp), %rbx
jne 0x76041
pushq $0x2a
popq %rdi
movss 0x25fca(%rip), %xmm0    # 0x9bff8
callq 0x35d33
movl 0x74(%r13), %edx
pushq $0x3
popq %rdi
movl %eax, %esi
callq 0x74bcf
cmpb $0x1, -0x29(%rbp)
movaps -0x80(%rbp), %xmm3
jne 0x761a7
movb %r14b, 0x239(%r13)
movss 0x15ac(%r12), %xmm0
mulss 0x2688c(%rip), %xmm0    # 0x9c8f4
addss 0xdc(%rbx), %xmm0
movss %xmm0, 0xdc(%rbx)
testb $0x2, 0x4(%r13)
je 0x761c9
movss 0x25f65(%rip), %xmm0    # 0x9bff0
xorl %edi, %edi
callq 0x40317
movaps -0x80(%rbp), %xmm3
testb %al, %al
je 0x761c9
cmpb $0x0, 0x2004(%r12)
jne 0x761c9
movb %r14b, 0x23a(%r13)
movzwl 0x78(%r13), %eax
movw %ax, 0x7a(%r13)
movss 0x3b8(%r12), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x7613c
movaps -0x90(%rbp), %xmm0
ucomiss 0x128(%r12), %xmm0
jbe 0x76132
movq -0x38(%rbp), %rax
movsbl 0x54(%rax), %esi
cmpl $-0x1, %esi
je 0x76132
movq -0xc8(%rbp), %rdi
callq 0x4c4c6
xorps %xmm1, %xmm1
movaps -0x80(%rbp), %xmm3
movl (%rax), %ecx
movq -0x38(%rbp), %rdx
orl (%rdx), %ecx
testb $0x20, %cl
jne 0x76132
movb 0x242(%r13), %cl
movq -0x38(%rbp), %rdx
cmpb %cl, 0x53(%rdx)
setl %dl
cmpb %cl, 0x53(%rax)
setge %al
cmpb %al, %dl
je 0x76132
movb $-0x1, 0x23b(%r13)
movss 0x3b8(%r12), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x761c9
movss 0x128(%r12), %xmm0
ucomiss -0xa0(%rbp), %xmm0
jbe 0x761c9
movq -0x38(%rbp), %rax
movsbl 0x55(%rax), %esi
cmpl $-0x1, %esi
je 0x761c9
movq -0xc8(%rbp), %rdi
callq 0x4c4c6
movaps -0x80(%rbp), %xmm3
movl (%rax), %ecx
movq -0x38(%rbp), %rdx
orl (%rdx), %ecx
testb $0x20, %cl
jne 0x761c9
movb 0x242(%r13), %cl
movq -0x38(%rbp), %rdx
cmpb %cl, 0x53(%rdx)
setl %dl
cmpb %cl, 0x53(%rax)
setge %al
cmpb %al, %dl
je 0x761c9
movb $0x1, 0x23b(%r13)
jmp 0x761c9
movss 0x15ac(%r12), %xmm0
mulss 0x2673b(%rip), %xmm0    # 0x9c8f4
addss 0xdc(%rbx), %xmm0
movss %xmm0, 0xdc(%rbx)
movd %r15d, %xmm1
movaps -0xa0(%rbp), %xmm0
subss -0x60(%rbp), %xmm0
subss %xmm3, %xmm0
movaps %xmm0, -0xa0(%rbp)
testb $0x8, 0x4(%r13)
movq -0x38(%rbp), %rdi
je 0x76326
testb $0x1, 0x1(%rdi)
jne 0x76326
movb 0x56(%rdi), %al
cmpb $-0x1, %al
je 0x762f1
movdqa %xmm1, -0x60(%rbp)
movaps -0xa0(%rbp), %xmm1
movaps %xmm1, %xmm4
movaps -0x90(%rbp), %xmm2
cmpless %xmm2, %xmm4
movaps %xmm4, %xmm0
andps %xmm2, %xmm0
andnps %xmm1, %xmm4
orps %xmm0, %xmm4
testb %al, %al
movaps %xmm4, -0x90(%rbp)
jle 0x76293
movss 0x266c1(%rip), %xmm0    # 0x9c904
xorl %edi, %edi
callq 0x35d33
xorl %edi, %edi
movl %eax, %esi
callq 0x35e06
movss 0x15b0(%r12), %xmm0
addss -0x90(%rbp), %xmm0
unpcklps -0x60(%rbp), %xmm0      # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
leaq -0x4c(%rbp), %rdi
pushq $0x1
popq %rbx
xorl %esi, %esi
movl %ebx, %edx
callq 0x36156
movl %ebx, %edi
callq 0x35eb4
movaps -0x90(%rbp), %xmm0
addss -0x80(%rbp), %xmm0
movaps %xmm0, -0x90(%rbp)
movq -0x48(%rbp), %rax
movq 0x2b8(%rax), %rbx
movss 0x25d52(%rip), %xmm0    # 0x9bff8
xorl %edi, %edi
callq 0x35d33
movq -0x38(%rbp), %r12
movb 0x64(%r12), %cl
andb $0x3, %cl
xorl %edx, %edx
cmpb $0x1, %cl
sete %dl
xorl $0x3, %edx
movaps -0x90(%rbp), %xmm0
unpcklps -0x60(%rbp), %xmm0      # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
movss 0x2660d(%rip), %xmm1    # 0x9c8e4
movq %rbx, %rdi
movq -0x48(%rbp), %rbx
movl %eax, %esi
callq 0x6b8b0
movq %r12, %rdi
movq -0x68(%rbp), %r12
movdqa -0x60(%rbp), %xmm1
cmpb $0x0, -0x3c(%rbp)
je 0x76326
movsbl 0x23a(%r13), %eax
cmpl %eax, %r14d
je 0x76326
movdqa %xmm1, -0x60(%rbp)
callq 0x75602
movzbl 0x141(%r12), %edx
movl %r14d, %edi
movl %eax, %esi
callq 0x756ab
movdqa -0x60(%rbp), %xmm1
movaps -0x100(%rbp), %xmm0
addss %xmm1, %xmm0
addss 0x159c(%r12), %xmm0
movq 0x2b8(%rbx), %rdi
leaq -0xe8(%rbp), %rdx
movaps -0xa0(%rbp), %xmm1
movss %xmm1, (%rdx)
movss %xmm0, 0x4(%rdx)
leaq -0xd8(%rbp), %rbx
leaq -0xe0(%rbp), %r14
movq %rbx, %rsi
movaps %xmm1, %xmm0
movq -0xa8(%rbp), %rcx
movq -0xd0(%rbp), %r8
movq %r14, %r9
callq 0x36718
movss (%r14), %xmm0
movaps -0xa0(%rbp), %xmm1
subss (%rbx), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x763d1
cmpb $0x1, -0x2a(%rbp)
jne 0x763d1
movss 0x1b2c(%r12), %xmm0
ucomiss 0x30ac(%r12), %xmm0
jbe 0x763d1
movq -0xa8(%rbp), %rdx
movq -0xd0(%rbp), %rsi
subl %edx, %esi
leaq 0x293e5(%rip), %rdi     # 0x9f7af
xorl %eax, %eax
callq 0x3fb35
pushq $0x1
popq %rdi
callq 0x40253
testb %al, %al
movl -0xc0(%rbp), %ebx
je 0x763f5
xorl %edi, %edi
callq 0x374fd
testb %al, %al
je 0x763f5
movl %ebx, %edi
callq 0x739bb
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x40d75(%rip), %rdi     # 0xb7183
leaq 0x3fcf1(%rip), %rsi     # 0xb6106
leaq 0x40dab(%rip), %rcx     # 0xb71c7
movl $0xabc, %edx            # imm = 0xABC
callq 0xc140
leaq 0x40dc0(%rip), %rdi     # 0xb71ed
leaq 0x3fcd2(%rip), %rsi     # 0xb6106
leaq 0x40d8c(%rip), %rcx     # 0xb71c7
movl $0xabd, %edx            # imm = 0xABD
callq 0xc140