// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableMergeDrawChannels(ImGuiTable*)
void ImGui::TableMergeDrawChannels(ImGuiTable* table)
{
    ImGuiContext& g = *GImGui;
    ImDrawListSplitter* splitter = &table->DrawSplitter;
    const bool has_freeze_v = (table->FreezeRowsCount > 0);
    const bool has_freeze_h = (table->FreezeColumnsCount > 0);
    IM_ASSERT(splitter->_Current == 0);

    // Track which groups we are going to attempt to merge, and which channels goes into each group.
    struct MergeGroup
    {
        ImRect  ClipRect;
        int     ChannelsCount;
        ImBitArray<IMGUI_TABLE_MAX_DRAW_CHANNELS> ChannelsMask;
    };
    int merge_group_mask = 0x00;
    MergeGroup merge_groups[4];
    memset(merge_groups, 0, sizeof(merge_groups));

    // 1. Scan channels and take note of those which can be merged
    for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
    {
        if ((table->VisibleMaskByIndex & ((ImU64)1 << column_n)) == 0)
            continue;
        ImGuiTableColumn* column = &table->Columns[column_n];

        const int merge_group_sub_count = has_freeze_v ? 2 : 1;
        for (int merge_group_sub_n = 0; merge_group_sub_n < merge_group_sub_count; merge_group_sub_n++)
        {
            const int channel_no = (merge_group_sub_n == 0) ? column->DrawChannelFrozen : column->DrawChannelUnfrozen;

            // Don't attempt to merge if there are multiple draw calls within the column
            ImDrawChannel* src_channel = &splitter->_Channels[channel_no];
            if (src_channel->_CmdBuffer.Size > 0 && src_channel->_CmdBuffer.back().ElemCount == 0)
                src_channel->_CmdBuffer.pop_back();
            if (src_channel->_CmdBuffer.Size != 1)
                continue;

            // Find out the width of this merge group and check if it will fit in our column
            // (note that we assume that rendering didn't stray on the left direction. we should need a CursorMinPos to detect it)
            if (!(column->Flags & ImGuiTableColumnFlags_NoClip))
            {
                float content_max_x;
                if (!has_freeze_v)
                    content_max_x = ImMax(column->ContentMaxXUnfrozen, column->ContentMaxXHeadersUsed); // No row freeze
                else if (merge_group_sub_n == 0)
                    content_max_x = ImMax(column->ContentMaxXFrozen, column->ContentMaxXHeadersUsed);   // Row freeze: use width before freeze
                else
                    content_max_x = column->ContentMaxXUnfrozen;                                        // Row freeze: use width after freeze
                if (content_max_x > column->ClipRect.Max.x)
                    continue;
            }

            const int merge_group_n = (has_freeze_h && column_n < table->FreezeColumnsCount ? 0 : 1) + (has_freeze_v && merge_group_sub_n == 0 ? 0 : 2);
            IM_ASSERT(channel_no < IMGUI_TABLE_MAX_DRAW_CHANNELS);
            MergeGroup* merge_group = &merge_groups[merge_group_n];
            if (merge_group->ChannelsCount == 0)
                merge_group->ClipRect = ImRect(+FLT_MAX, +FLT_MAX, -FLT_MAX, -FLT_MAX);
            merge_group->ChannelsMask.SetBit(channel_no);
            merge_group->ChannelsCount++;
            merge_group->ClipRect.Add(src_channel->_CmdBuffer[0].ClipRect);
            merge_group_mask |= (1 << merge_group_n);
        }

        // Invalidate current draw channel
        // (we don't clear DrawChannelFrozen/DrawChannelUnfrozen solely to facilitate debugging/later inspection of data)
        column->DrawChannelCurrent = (ImGuiTableDrawChannelIdx)-1;
    }

    // [DEBUG] Display merge groups
#if 0
    if (g.IO.KeyShift)
        for (int merge_group_n = 0; merge_group_n < IM_ARRAYSIZE(merge_groups); merge_group_n++)
        {
            MergeGroup* merge_group = &merge_groups[merge_group_n];
            if (merge_group->ChannelsCount == 0)
                continue;
            char buf[32];
            ImFormatString(buf, 32, "MG%d:%d", merge_group_n, merge_group->ChannelsCount);
            ImVec2 text_pos = merge_group->ClipRect.Min + ImVec2(4, 4);
            ImVec2 text_size = CalcTextSize(buf, NULL);
            GetForegroundDrawList()->AddRectFilled(text_pos, text_pos + text_size, IM_COL32(0, 0, 0, 255));
            GetForegroundDrawList()->AddText(text_pos, IM_COL32(255, 255, 0, 255), buf, NULL);
            GetForegroundDrawList()->AddRect(merge_group->ClipRect.Min, merge_group->ClipRect.Max, IM_COL32(255, 255, 0, 255));
        }
#endif

    // 2. Rewrite channel list in our preferred order
    if (merge_group_mask != 0)
    {
        // We skip channel 0 (Bg0/Bg1) and 1 (Bg2 frozen) from the shuffling since they won't move - see channels allocation in TableSetupDrawChannels().
        const int LEADING_DRAW_CHANNELS = 2;
        g.DrawChannelsTempMergeBuffer.resize(splitter->_Count - LEADING_DRAW_CHANNELS); // Use shared temporary storage so the allocation gets amortized
        ImDrawChannel* dst_tmp = g.DrawChannelsTempMergeBuffer.Data;
        ImBitArray<IMGUI_TABLE_MAX_DRAW_CHANNELS> remaining_mask;                       // We need 132-bit of storage
        remaining_mask.ClearAllBits();
        remaining_mask.SetBitRange(LEADING_DRAW_CHANNELS, splitter->_Count);
        remaining_mask.ClearBit(table->Bg2DrawChannelUnfrozen);
        IM_ASSERT(has_freeze_v == false || table->Bg2DrawChannelUnfrozen != TABLE_DRAW_CHANNEL_BG2_FROZEN);
        int remaining_count = splitter->_Count - (has_freeze_v ? LEADING_DRAW_CHANNELS + 1 : LEADING_DRAW_CHANNELS);
        //ImRect host_rect = (table->InnerWindow == table->OuterWindow) ? table->InnerClipRect : table->HostClipRect;
        ImRect host_rect = table->HostClipRect;
        for (int merge_group_n = 0; merge_group_n < IM_ARRAYSIZE(merge_groups); merge_group_n++)
        {
            if (int merge_channels_count = merge_groups[merge_group_n].ChannelsCount)
            {
                MergeGroup* merge_group = &merge_groups[merge_group_n];
                ImRect merge_clip_rect = merge_group->ClipRect;

                // Extend outer-most clip limits to match those of host, so draw calls can be merged even if
                // outer-most columns have some outer padding offsetting them from their parent ClipRect.
                // The principal cases this is dealing with are:
                // - On a same-window table (not scrolling = single group), all fitting columns ClipRect -> will extend and match host ClipRect -> will merge
                // - Columns can use padding and have left-most ClipRect.Min.x and right-most ClipRect.Max.x != from host ClipRect -> will extend and match host ClipRect -> will merge
                // FIXME-TABLE FIXME-WORKRECT: We are wasting a merge opportunity on tables without scrolling if column doesn't fit
                // within host clip rect, solely because of the half-padding difference between window->WorkRect and window->InnerClipRect.
                if ((merge_group_n & 1) == 0 || !has_freeze_h)
                    merge_clip_rect.Min.x = ImMin(merge_clip_rect.Min.x, host_rect.Min.x);
                if ((merge_group_n & 2) == 0 || !has_freeze_v)
                    merge_clip_rect.Min.y = ImMin(merge_clip_rect.Min.y, host_rect.Min.y);
                if ((merge_group_n & 1) != 0)
                    merge_clip_rect.Max.x = ImMax(merge_clip_rect.Max.x, host_rect.Max.x);
                if ((merge_group_n & 2) != 0 && (table->Flags & ImGuiTableFlags_NoHostExtendY) == 0)
                    merge_clip_rect.Max.y = ImMax(merge_clip_rect.Max.y, host_rect.Max.y);
#if 0
                GetOverlayDrawList()->AddRect(merge_group->ClipRect.Min, merge_group->ClipRect.Max, IM_COL32(255, 0, 0, 200), 0.0f, ~0, 1.0f);
                GetOverlayDrawList()->AddLine(merge_group->ClipRect.Min, merge_clip_rect.Min, IM_COL32(255, 100, 0, 200));
                GetOverlayDrawList()->AddLine(merge_group->ClipRect.Max, merge_clip_rect.Max, IM_COL32(255, 100, 0, 200));
#endif
                remaining_count -= merge_group->ChannelsCount;
                for (int n = 0; n < IM_ARRAYSIZE(remaining_mask.Storage); n++)
                    remaining_mask.Storage[n] &= ~merge_group->ChannelsMask.Storage[n];
                for (int n = 0; n < splitter->_Count && merge_channels_count != 0; n++)
                {
                    // Copy + overwrite new clip rect
                    if (!merge_group->ChannelsMask.TestBit(n))
                        continue;
                    merge_group->ChannelsMask.ClearBit(n);
                    merge_channels_count--;

                    ImDrawChannel* channel = &splitter->_Channels[n];
                    IM_ASSERT(channel->_CmdBuffer.Size == 1 && merge_clip_rect.Contains(ImRect(channel->_CmdBuffer[0].ClipRect)));
                    channel->_CmdBuffer[0].ClipRect = merge_clip_rect.ToVec4();
                    memcpy(dst_tmp++, channel, sizeof(ImDrawChannel));
                }
            }

            // Make sure Bg2DrawChannelUnfrozen appears in the middle of our groups (whereas Bg0/Bg1 and Bg2 frozen are fixed to 0 and 1)
            if (merge_group_n == 1 && has_freeze_v)
                memcpy(dst_tmp++, &splitter->_Channels[table->Bg2DrawChannelUnfrozen], sizeof(ImDrawChannel));
        }

        // Append unmergeable channels that we didn't reorder at the end of the list
        for (int n = 0; n < splitter->_Count && remaining_count != 0; n++)
        {
            if (!remaining_mask.TestBit(n))
                continue;
            ImDrawChannel* channel = &splitter->_Channels[n];
            memcpy(dst_tmp++, channel, sizeof(ImDrawChannel));
            remaining_count--;
        }
        IM_ASSERT(dst_tmp == g.DrawChannelsTempMergeBuffer.Data + g.DrawChannelsTempMergeBuffer.Size);
        memcpy(splitter->_Channels.Data + LEADING_DRAW_CHANNELS, g.DrawChannelsTempMergeBuffer.Data, (splitter->_Count - LEADING_DRAW_CHANNELS) * sizeof(ImDrawChannel));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
cmpl $0x0, 0x1e8(%rdi)
jne 0x744af
movq %rdi, %r12
leaq 0x6fe69(%rip), %rax     # 0xe3ce0
movq (%rax), %rax
movq %rax, -0x88(%rbp)
movb 0x241(%rdi), %al
movb 0x243(%rdi), %cl
movb %cl, -0x2a(%rbp)
xorl %ecx, %ecx
movb %al, -0x29(%rbp)
testb %al, %al
setg %cl
leaq 0x10(%rdi), %rax
movq %rax, -0xd0(%rbp)
incl %ecx
movl %ecx, -0xe0(%rbp)
leaq 0x1f0(%rdi), %r15
leaq -0x1a0(%rbp), %rdi
xorl %ebx, %ebx
movl $0xa0, %edx
xorl %esi, %esi
callq 0xc270
movl $0x0, -0x80(%rbp)
movq %r12, -0x90(%rbp)
movq %r15, -0x38(%rbp)
movslq 0x6c(%r12), %rax
cmpq %rax, %rbx
jge 0x7408d
movq 0x50(%r12), %rax
btq %rbx, %rax
jae 0x74085
movq -0xd0(%rbp), %rdi
movq %rbx, -0xa0(%rbp)
movl %ebx, %esi
callq 0x4c4c6
movq %rax, %rcx
xorl %r14d, %r14d
movq %rax, -0x70(%rbp)
cmpl %r14d, -0xe0(%rbp)
je 0x7407a
cmpl $0x1, %r14d
pushq $0x59
popq %rax
sbbq $0x0, %rax
movzbl (%rcx,%rax), %r13d
movq %r15, %rdi
movl %r13d, %esi
callq 0x6f49a
cmpl $0x0, (%rax)
jle 0x7406e
movq %rax, %rbx
movq %rax, %rdi
callq 0x4b5ee
cmpl $0x0, 0x20(%rax)
jne 0x73f61
movq %rbx, %rdi
callq 0x6f2b4
cmpl $0x1, (%rbx)
jne 0x7406e
movq -0x70(%rbp), %rcx
testb $-0x80, (%rcx)
jne 0x73fb1
cmpb $0x0, -0x29(%rbp)
jle 0x73f85
testl %r14d, %r14d
je 0x73f8c
movss 0x44(%rcx), %xmm0
jmp 0x73fa7
movss 0x44(%rcx), %xmm1
jmp 0x73f91
movss 0x40(%rcx), %xmm1
movss 0x48(%rcx), %xmm2
movaps %xmm2, %xmm0
cmpless %xmm1, %xmm0
andps %xmm0, %xmm1
andnps %xmm2, %xmm0
orps %xmm1, %xmm0
ucomiss 0x28(%rcx), %xmm0
ja 0x74072
pushq $0x1
popq %r15
cmpb $0x0, -0x2a(%rbp)
jle 0x73fd2
movsbq 0x243(%r12), %rax
xorl %r15d, %r15d
cmpq %rax, -0xa0(%rbp)
setge %r15b
xorl %eax, %eax
testl %r14d, %r14d
setne %al
addl %eax, %eax
cmpb $0x0, -0x29(%rbp)
pushq $0x2
popq %rcx
cmovlel %ecx, %eax
cmpb $-0x7c, %r13b
jae 0x74490
orl %eax, %r15d
movl %r15d, %eax
imulq $0x28, %rax, %rax
leaq (%rax,%rbp), %r12
addq $-0x1a0, %r12           # imm = 0xFE60
cmpl $0x0, 0x10(%r12)
jne 0x74019
movaps 0x2883c(%rip), %xmm0    # 0x9c850
movups %xmm0, (%r12)
leaq 0x14(%r12), %rdi
movl %r13d, %esi
callq 0x789ea
incl 0x10(%r12)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4b5b8
movq (%rax), %rcx
movq %rcx, -0xc0(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0xb8(%rbp)
movq %r12, %rdi
leaq -0xc0(%rbp), %rsi
callq 0x49d26
movl -0x80(%rbp), %eax
btsl %r15d, %eax
movl %eax, -0x80(%rbp)
movq -0x90(%rbp), %r12
movq -0x38(%rbp), %r15
movq -0x70(%rbp), %rcx
incl %r14d
jmp 0x73f17
movb $-0x1, 0x57(%rcx)
movq -0xa0(%rbp), %rbx
incq %rbx
jmp 0x73edb
cmpl $0x0, -0x80(%rbp)
je 0x7445f
movq -0x88(%rbp), %rbx
leaq 0x20f8(%rbx), %rdi
movl 0x1ec(%r12), %esi
addl $-0x2, %esi
callq 0x6f528
movq 0x2100(%rbx), %r13
xorps %xmm0, %xmm0
leaq -0xc0(%rbp), %rbx
movaps %xmm0, (%rbx)
andl $0x0, 0x10(%rbx)
movl 0x1ec(%r12), %edx
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x78fb9
movzbl 0x247(%r12), %esi
movq %rbx, %rdi
callq 0x78a26
cmpb $0x0, -0x29(%rbp)
jle 0x7410a
cmpb $0x1, 0x247(%r12)
je 0x744ed
pushq $-0x3
jmp 0x7410c
pushq $-0x2
popq %r14
addl 0x1ec(%r12), %r14d
movss 0x15c(%r12), %xmm0
movss %xmm0, -0x58(%rbp)
movss 0x160(%r12), %xmm0
movss %xmm0, -0x54(%rbp)
movss 0x164(%r12), %xmm0
movaps %xmm0, -0x100(%rbp)
movss 0x168(%r12), %xmm0
movaps %xmm0, -0xf0(%rbp)
leaq -0x18c(%rbp), %rdx
xorl %esi, %esi
cmpq $0x4, %rsi
je 0x743d2
movl %r14d, -0x3c(%rbp)
imulq $0x28, %rsi, %rax
movl -0x190(%rbp,%rax), %r14d
testl %r14d, %r14d
movq %rdx, -0x50(%rbp)
movq %rsi, -0x48(%rbp)
je 0x7437c
leaq (%rax,%rbp), %r15
addq $-0x1a0, %r15           # imm = 0xFE60
cmpb $0x0, -0x2a(%rbp)
setle %al
movups (%r15), %xmm3
testb $0x1, %sil
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x741ba
movaps %xmm3, %xmm0
minss -0x58(%rbp), %xmm0
movss %xmm0, %xmm3            # xmm3 = xmm0[0],xmm3[1,2,3]
cmpb $0x0, -0x29(%rbp)
setg %al
cmpq $0x2, %rsi
setae %cl
testb %al, %cl
jne 0x741e2
movaps %xmm3, %xmm0
shufps $0x55, %xmm3, %xmm0     # xmm0 = xmm0[1,1],xmm3[1,1]
minss -0x54(%rbp), %xmm0
movlhps %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0]
shufps $0xe2, %xmm3, %xmm0     # xmm0 = xmm0[2,0],xmm3[2,3]
movaps %xmm0, %xmm3
testb $0x1, %sil
je 0x7420f
movaps %xmm3, %xmm0
unpckhpd %xmm3, %xmm0            # xmm0 = xmm0[1],xmm3[1]
movaps -0x100(%rbp), %xmm2
movaps %xmm2, %xmm1
cmpless %xmm0, %xmm1
andps %xmm1, %xmm0
andnps %xmm2, %xmm1
orps %xmm0, %xmm1
shufps $0x30, %xmm3, %xmm1     # xmm1 = xmm1[0,0],xmm3[3,0]
shufps $0x84, %xmm1, %xmm3     # xmm3 = xmm3[0,1],xmm1[0,2]
cmpq $0x2, %rsi
jb 0x74244
testb $0x2, 0x6(%r12)
jne 0x74244
movaps %xmm3, %xmm0
shufps $0xff, %xmm3, %xmm0     # xmm0 = xmm0[3,3],xmm3[3,3]
movaps -0xf0(%rbp), %xmm2
movaps %xmm2, %xmm1
cmpless %xmm0, %xmm1
andps %xmm1, %xmm0
andnps %xmm2, %xmm1
orps %xmm0, %xmm1
shufps $0xe4, %xmm3, %xmm1     # xmm1 = xmm1[0,1],xmm3[2,3]
shufps $0x24, %xmm1, %xmm3     # xmm3 = xmm3[0,1],xmm1[2,0]
addq $0x14, %r15
xorl %eax, %eax
cmpq $0x5, %rax
je 0x74261
movl (%rdx,%rax,4), %ecx
notl %ecx
andl %ecx, -0xc0(%rbp,%rax,4)
incq %rax
jmp 0x7424a
subl %r14d, -0x3c(%rbp)
movaps %xmm3, %xmm0
shufps $0x55, %xmm3, %xmm0     # xmm0 = xmm0[1,1],xmm3[1,1]
movaps %xmm0, -0xe0(%rbp)
movaps %xmm3, %xmm0
unpckhpd %xmm3, %xmm0            # xmm0 = xmm0[1],xmm3[1]
movaps %xmm3, %xmm1
shufps $0xff, %xmm3, %xmm1     # xmm1 = xmm1[3,3],xmm3[3,3]
movaps %xmm1, -0xa0(%rbp)
xorl %ebx, %ebx
movaps %xmm3, %xmm1
movaps %xmm0, -0x80(%rbp)
movlhps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movaps %xmm1, -0xd0(%rbp)
movaps %xmm3, -0x70(%rbp)
cmpl 0x1ec(%r12), %ebx
jge 0x74370
testl %r14d, %r14d
je 0x74370
movq %r15, %rdi
movl %ebx, %esi
callq 0x78a62
testb %al, %al
je 0x74369
movq %r15, %rdi
movl %ebx, %esi
callq 0x78a26
movq -0x38(%rbp), %rdi
movl %ebx, %esi
callq 0x6f49a
cmpl $0x1, (%rax)
jne 0x74471
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
callq 0x4b5b8
movss (%rax), %xmm0
ucomiss -0x70(%rbp), %xmm0
jb 0x74471
movss 0x4(%rax), %xmm0
ucomiss -0xe0(%rbp), %xmm0
jb 0x74471
movaps -0x80(%rbp), %xmm0
ucomiss 0x8(%rax), %xmm0
jb 0x74471
movaps -0xa0(%rbp), %xmm0
ucomiss 0xc(%rax), %xmm0
jb 0x74471
decl %r14d
movq %r12, %rdi
xorl %esi, %esi
callq 0x4b5b8
movaps -0xd0(%rbp), %xmm0
movups %xmm0, (%rax)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm0, (%r13)
movups %xmm1, 0x10(%r13)
addq $0x20, %r13
movq -0x90(%rbp), %r12
incl %ebx
jmp 0x7429f
movq -0x38(%rbp), %r15
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rsi
cmpb $0x0, -0x29(%rbp)
setg %al
cmpq $0x1, %rsi
sete %cl
andb %al, %cl
cmpb $0x1, %cl
movl -0x3c(%rbp), %r14d
jne 0x743c6
leaq 0x20(%r13), %rbx
movzbl 0x247(%r12), %esi
movq %r15, %rdi
callq 0x6f49a
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm0, (%r13)
movups %xmm1, 0x10(%r13)
movq %rbx, %r13
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
incq %rsi
addq $0x28, %rdx
jmp 0x7415f
xorl %ebx, %ebx
leaq -0xc0(%rbp), %r15
movslq 0x1ec(%r12), %rdx
cmpl %edx, %ebx
jge 0x74421
testl %r14d, %r14d
je 0x74421
movq %r15, %rdi
movl %ebx, %esi
callq 0x78a62
testb %al, %al
je 0x7441d
movq -0x38(%rbp), %rdi
movl %ebx, %esi
callq 0x6f49a
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm0, (%r13)
movups %xmm1, 0x10(%r13)
addq $0x20, %r13
decl %r14d
incl %ebx
jmp 0x743db
movq -0x88(%rbp), %rax
movq 0x2100(%rax), %rsi
movslq 0x20f8(%rax), %rax
shlq $0x5, %rax
addq %rsi, %rax
cmpq %rax, %r13
jne 0x744ce
movq 0x1f8(%r12), %rdi
addq $0x40, %rdi
shlq $0x5, %rdx
addq $-0x40, %rdx
callq 0xc080
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x429a8(%rip), %rdi     # 0xb6e20
leaq 0x41c87(%rip), %rsi     # 0xb6106
leaq 0x428f7(%rip), %rcx     # 0xb6d7d
movl $0x934, %edx            # imm = 0x934
callq 0xc140
leaq 0x42917(%rip), %rdi     # 0xb6dae
leaq 0x41c68(%rip), %rsi     # 0xb6106
leaq 0x428d8(%rip), %rcx     # 0xb6d7d
movl $0x8dd, %edx            # imm = 0x8DD
callq 0xc140
leaq 0x428af(%rip), %rdi     # 0xb6d65
leaq 0x41c49(%rip), %rsi     # 0xb6106
leaq 0x428b9(%rip), %rcx     # 0xb6d7d
movl $0x8ad, %edx            # imm = 0x8AD
callq 0xc140
leaq 0x429ae(%rip), %rdi     # 0xb6e83
leaq 0x41c2a(%rip), %rsi     # 0xb6106
leaq 0x4289a(%rip), %rcx     # 0xb6d7d
movl $0x948, %edx            # imm = 0x948
callq 0xc140
leaq 0x428d4(%rip), %rdi     # 0xb6dc8
leaq 0x41c0b(%rip), %rsi     # 0xb6106
leaq 0x4287b(%rip), %rcx     # 0xb6d7d
movl $0x909, %edx            # imm = 0x909
callq 0xc140