LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/arkanis[P]process-map/./deps/raygui.h
// Function: GuiSetStyle
void GuiSetStyle(int control, int property, int value)
{
    if (!guiStyleLoaded) GuiLoadStyleDefault();
    guiStyle[control*(NUM_PROPS_DEFAULT + NUM_PROPS_EXTENDED) + property] = value;

    // Default properties are propagated to all controls
    if ((control == 0) && (property < NUM_PROPS_DEFAULT))
    {
        for (int i = 1; i < NUM_CONTROLS; i++) guiStyle[i*(NUM_PROPS_DEFAULT + NUM_PROPS_EXTENDED) + property] = value;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
testb $0x1, 0xc31ed(%rip)     # 0xca0e5
jne 0x6eff
callq 0x6a20
movl -0xc(%rbp), %edx
imull $0x18, -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
movslq %eax, %rcx
leaq 0xc320d(%rip), %rax     # 0xca120
movl %edx, (%rax,%rcx,4)
cmpl $0x0, -0x4(%rbp)
jne 0x6f53
cmpl $0x10, -0x8(%rbp)
jge 0x6f53
movl $0x1, -0x10(%rbp)
cmpl $0x10, -0x10(%rbp)
jge 0x6f51
movl -0xc(%rbp), %edx
imull $0x18, -0x10(%rbp), %eax
addl -0x8(%rbp), %eax
movslq %eax, %rcx
leaq 0xc31dd(%rip), %rax     # 0xca120
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6f29
jmp 0x6f53
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/arkanis[P]process-map/./deps/raygui.h
// Function: GuiStatusBar
void GuiStatusBar(Rectangle bounds, const char *text)
{
    GuiControlState state = guiState;

    // Draw control
    //--------------------------------------------------------------------
    GuiDrawRectangle(bounds, GuiGetStyle(STATUSBAR, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(STATUSBAR, (state != GUI_STATE_DISABLED)? BORDER_COLOR_NORMAL : BORDER_COLOR_DISABLED)), guiAlpha),
                     Fade(GetColor(GuiGetStyle(STATUSBAR, (state != GUI_STATE_DISABLED)? BASE_COLOR_NORMAL : BASE_COLOR_DISABLED)), guiAlpha));
    GuiDrawText(text, GetTextBounds(STATUSBAR, bounds), GuiGetStyle(STATUSBAR, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(STATUSBAR, (state != GUI_STATE_DISABLED)? TEXT_COLOR_NORMAL : TEXT_COLOR_DISABLED)), guiAlpha));
    //--------------------------------------------------------------------
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl 0xc2ee4(%rip), %eax     # 0xca0e0
movl %eax, -0x1c(%rbp)
movl $0xf, %edi
movl %edi, -0x54(%rbp)
movl $0xc, %esi
callq 0x6f90
movl -0x54(%rbp), %edi
movl %eax, -0x58(%rbp)
movl -0x1c(%rbp), %eax
subl $0x3, %eax
sete %al
movzbl %al, %ecx
movl %ecx, %eax
leal (%rax,%rax,8), %esi
callq 0x6f90
movl %eax, %edi
callq 0x526e0
movl %eax, -0x24(%rbp)
movss 0xc11d1(%rip), %xmm0    # 0xc8410
movl -0x24(%rbp), %edi
callq 0x51fa0
movl -0x54(%rbp), %edi
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
subl $0x3, %eax
sete %al
movzbl %al, %ecx
movl %ecx, %eax
leal 0x1(%rax,%rax,8), %esi
callq 0x6f90
movl %eax, %edi
callq 0x526e0
movl %eax, -0x2c(%rbp)
movss 0xc119a(%rip), %xmm0    # 0xc8410
movl -0x2c(%rbp), %edi
callq 0x51fa0
movl -0x58(%rbp), %edi
movl %eax, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
movl -0x20(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0x77c0
movl -0x54(%rbp), %edi
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
callq 0x9f70
movl -0x54(%rbp), %edi
movlpd %xmm0, -0x3c(%rbp)
movlpd %xmm1, -0x34(%rbp)
movl $0xe, %esi
callq 0x6f90
movl -0x54(%rbp), %edi
movl %eax, -0x48(%rbp)
movl -0x1c(%rbp), %eax
subl $0x3, %eax
sete %al
movzbl %al, %ecx
movl %ecx, %eax
leal 0x2(%rax,%rax,8), %esi
callq 0x6f90
movl %eax, %edi
callq 0x526e0
movl %eax, -0x44(%rbp)
movss 0xc1117(%rip), %xmm0    # 0xc8410
movl -0x44(%rbp), %edi
callq 0x51fa0
movq -0x50(%rbp), %rdi
movl -0x48(%rbp), %esi
movl %eax, -0x40(%rbp)
movsd -0x3c(%rbp), %xmm0
movsd -0x34(%rbp), %xmm1
movl -0x40(%rbp), %edx
callq 0x9cf0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arkanis[P]process-map/./deps/raygui.h
// Function: GuiPanel
void GuiPanel(Rectangle bounds)
{
    #define PANEL_BORDER_WIDTH   1

    GuiControlState state = guiState;

    // Draw control
    //--------------------------------------------------------------------
    GuiDrawRectangle(bounds, PANEL_BORDER_WIDTH, Fade(GetColor(GuiGetStyle(DEFAULT, (state == GUI_STATE_DISABLED)? BORDER_COLOR_DISABLED: LINE_COLOR)), guiAlpha),
                     Fade(GetColor(GuiGetStyle(DEFAULT, (state == GUI_STATE_DISABLED)? BASE_COLOR_DISABLED : BACKGROUND_COLOR)), guiAlpha));
    //--------------------------------------------------------------------
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
movl 0xc2d98(%rip), %eax     # 0xca0e0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl $0x3, %eax
setne %al
movzbl %al, %ecx
movl %ecx, %eax
leal 0x9(%rax,%rax,8), %esi
xorl %edi, %edi
movl %edi, -0x28(%rbp)
callq 0x6f90
movl %eax, %edi
callq 0x526e0
movl %eax, -0x1c(%rbp)
movss 0xc1097(%rip), %xmm0    # 0xc8410
movl -0x1c(%rbp), %edi
callq 0x51fa0
movl -0x28(%rbp), %edi
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl $0x3, %eax
setne %al
movzbl %al, %ecx
movl %ecx, %eax
leal 0xa(%rax,%rax,8), %esi
callq 0x6f90
movl %eax, %edi
callq 0x526e0
movl %eax, -0x24(%rbp)
movss 0xc1060(%rip), %xmm0    # 0xc8410
movl -0x24(%rbp), %edi
callq 0x51fa0
movl %eax, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
movl -0x18(%rbp), %esi
movl -0x20(%rbp), %edx
movl $0x1, %edi
callq 0x77c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arkanis[P]process-map/./deps/raygui.h
// Function: GuiDrawRectangle
static void GuiDrawRectangle(Rectangle rec, int borderWidth, Color borderColor, Color color)
{
    if (color.a > 0)
    {
        // Draw rectangle filled with color
        DrawRectangle((int)rec.x, (int)rec.y, (int)rec.width, (int)rec.height, color);
    }

    if (borderWidth > 0)
    {
        // Draw rectangle border lines with color
        DrawRectangle((int)rec.x, (int)rec.y, (int)rec.width, borderWidth, borderColor);
        DrawRectangle((int)rec.x, (int)rec.y + borderWidth, borderWidth, (int)rec.height - 2*borderWidth, borderColor);
        DrawRectangle((int)rec.x + (int)rec.width - borderWidth, (int)rec.y + borderWidth, borderWidth, (int)rec.height - 2*borderWidth, borderColor);
        DrawRectangle((int)rec.x, (int)rec.y + (int)rec.height - borderWidth, (int)rec.width, borderWidth, borderColor);
    }

    // TODO: For n-patch-based style we would need: [state] and maybe [control]
    // In this case all controls drawing logic should be moved to this function... I don't like it...
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %edi, -0x1c(%rbp)
movzbl -0x15(%rbp), %eax
cmpl $0x0, %eax
jle 0x7801
cvttss2si -0x10(%rbp), %edi
cvttss2si -0xc(%rbp), %esi
cvttss2si -0x8(%rbp), %edx
cvttss2si -0x4(%rbp), %ecx
movl -0x18(%rbp), %r8d
callq 0x38a90
cmpl $0x0, -0x1c(%rbp)
jle 0x789f
cvttss2si -0x10(%rbp), %edi
cvttss2si -0xc(%rbp), %esi
cvttss2si -0x8(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x14(%rbp), %r8d
callq 0x38a90
cvttss2si -0x10(%rbp), %edi
cvttss2si -0xc(%rbp), %esi
addl -0x1c(%rbp), %esi
movl -0x1c(%rbp), %edx
cvttss2si -0x4(%rbp), %ecx
movl -0x1c(%rbp), %eax
shll %eax
subl %eax, %ecx
movl -0x14(%rbp), %r8d
callq 0x38a90
cvttss2si -0x10(%rbp), %edi
cvttss2si -0x8(%rbp), %eax
addl %eax, %edi
subl -0x1c(%rbp), %edi
cvttss2si -0xc(%rbp), %esi
addl -0x1c(%rbp), %esi
movl -0x1c(%rbp), %edx
cvttss2si -0x4(%rbp), %ecx
movl -0x1c(%rbp), %eax
shll %eax
subl %eax, %ecx
movl -0x14(%rbp), %r8d
callq 0x38a90
cvttss2si -0x10(%rbp), %edi
cvttss2si -0xc(%rbp), %esi
cvttss2si -0x4(%rbp), %eax
addl %eax, %esi
subl -0x1c(%rbp), %esi
cvttss2si -0x8(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x14(%rbp), %r8d
callq 0x38a90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arkanis[P]process-map/./deps/raygui.h
// Function: GuiToggleGroup
int GuiToggleGroup(Rectangle bounds, const char *text, int active)
{
    #if !defined(TOGGLEGROUP_MAX_ELEMENTS)
        #define TOGGLEGROUP_MAX_ELEMENTS    32
    #endif

    float initBoundsX = bounds.x;

    // Get substrings items from text (items pointers)
    int rows[TOGGLEGROUP_MAX_ELEMENTS] = { 0 };
    int itemsCount = 0;
    const char **items = GuiTextSplit(text, &itemsCount, rows);

    int prevRow = rows[0];

    for (int i = 0; i < itemsCount; i++)
    {
        if (prevRow != rows[i])
        {
            bounds.x = initBoundsX;
            bounds.y += (bounds.height + GuiGetStyle(TOGGLE, GROUP_PADDING));
            prevRow = rows[i];
        }

        if (i == active) GuiToggle(bounds, items[i], true);
        else if (GuiToggle(bounds, items[i], false) == true) active = i;

        bounds.x += (bounds.width + GuiGetStyle(TOGGLE, GROUP_PADDING));
    }

    return active;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movss -0x10(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x6060
movl $0x0, -0xa4(%rbp)
movq -0x18(%rbp), %rdi
leaq -0xa0(%rbp), %rdx
leaq -0xa4(%rbp), %rsi
callq 0xaac0
movq %rax, -0xb0(%rbp)
movl -0xa0(%rbp), %eax
movl %eax, -0xb4(%rbp)
movl $0x0, -0xb8(%rbp)
movl -0xb8(%rbp), %eax
cmpl -0xa4(%rbp), %eax
jge 0xaaa8
movl -0xb4(%rbp), %eax
movslq -0xb8(%rbp), %rcx
cmpl -0xa0(%rbp,%rcx,4), %eax
je 0xa9f3
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x4(%rbp), %xmm0
movss %xmm0, -0xbc(%rbp)
movl $0x3, %edi
movl $0x10, %esi
callq 0x6f90
movss -0xbc(%rbp), %xmm0
cvtsi2ss %eax, %xmm1
addss %xmm1, %xmm0
addss -0xc(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movslq -0xb8(%rbp), %rax
movl -0xa0(%rbp,%rax,4), %eax
movl %eax, -0xb4(%rbp)
movl -0xb8(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0xaa26
movq -0xb0(%rbp), %rax
movslq -0xb8(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
movl $0x1, %esi
callq 0xa5b0
jmp 0xaa5e
movq -0xb0(%rbp), %rax
movslq -0xb8(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
xorl %esi, %esi
callq 0xa5b0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xaa5c
movl -0xb8(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xaa5e
movss -0x8(%rbp), %xmm0
movss %xmm0, -0xc0(%rbp)
movl $0x3, %edi
movl $0x10, %esi
callq 0x6f90
movss -0xc0(%rbp), %xmm0
cvtsi2ss %eax, %xmm1
addss %xmm1, %xmm0
addss -0x10(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
movl -0xb8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb8(%rbp)
jmp 0xa977
movl -0x1c(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arkanis[P]process-map/./deps/raygui.h
// Function: GuiDummyRec
void GuiDummyRec(Rectangle bounds, const char *text)
{
    GuiControlState state = guiState;

    // Update control
    //--------------------------------------------------------------------
    if ((state != GUI_STATE_DISABLED) && !guiLocked)
    {
        Vector2 mousePoint = GetMousePosition();

        // Check button state
        if (CheckCollisionPointRec(mousePoint, bounds))
        {
            if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = GUI_STATE_PRESSED;
            else state = GUI_STATE_FOCUSED;
        }
    }
    //--------------------------------------------------------------------

    // Draw control
    //--------------------------------------------------------------------
    GuiDrawRectangle(bounds, 0, BLANK, Fade(GetColor(GuiGetStyle(DEFAULT, (state != GUI_STATE_DISABLED)? BASE_COLOR_NORMAL : BASE_COLOR_DISABLED)), guiAlpha));
    GuiDrawText(text, GetTextBounds(DEFAULT, bounds), GUI_TEXT_ALIGN_CENTER, Fade(GetColor(GuiGetStyle(BUTTON, (state != GUI_STATE_DISABLED)? TEXT_COLOR_NORMAL : TEXT_COLOR_DISABLED)), guiAlpha));
    //------------------------------------------------------------------
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl 0xbb714(%rip), %eax     # 0xca0e0
movl %eax, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
je 0xea23
testb $0x1, 0xbb708(%rip)     # 0xca0e4
jne 0xea23
callq 0x2dd60
movlpd %xmm0, -0x24(%rbp)
movsd -0x24(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd -0x8(%rbp), %xmm2
callq 0x3e640
testb $0x1, %al
jne 0xea02
jmp 0xea21
xorl %edi, %edi
callq 0x2ddd0
testb $0x1, %al
jne 0xea0f
jmp 0xea18
movl $0x2, -0x1c(%rbp)
jmp 0xea1f
movl $0x1, -0x1c(%rbp)
jmp 0xea21
jmp 0xea23
movb $0x0, -0x28(%rbp)
movb $0x0, -0x27(%rbp)
movb $0x0, -0x26(%rbp)
movb $0x0, -0x25(%rbp)
movl -0x1c(%rbp), %eax
subl $0x3, %eax
sete %al
movzbl %al, %ecx
movl %ecx, %eax
leal 0x1(%rax,%rax,8), %esi
xorl %edi, %edi
movl %edi, -0x54(%rbp)
callq 0x6f90
movl %eax, %edi
callq 0x526e0
movl %eax, -0x30(%rbp)
movss 0xb99af(%rip), %xmm0    # 0xc8410
movl -0x30(%rbp), %edi
callq 0x51fa0
movl -0x54(%rbp), %edi
movl %eax, -0x2c(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
movl -0x28(%rbp), %esi
movl -0x2c(%rbp), %edx
callq 0x77c0
movl -0x54(%rbp), %edi
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
callq 0x9f70
movlpd %xmm0, -0x40(%rbp)
movlpd %xmm1, -0x38(%rbp)
movl -0x1c(%rbp), %eax
subl $0x3, %eax
sete %al
movzbl %al, %ecx
movl %ecx, %eax
leal 0x2(%rax,%rax,8), %esi
movl $0x2, %edi
callq 0x6f90
movl %eax, %edi
callq 0x526e0
movl %eax, -0x48(%rbp)
movss 0xb993a(%rip), %xmm0    # 0xc8410
movl -0x48(%rbp), %edi
callq 0x51fa0
movq -0x50(%rbp), %rdi
movl %eax, -0x44(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
movl -0x44(%rbp), %edx
movl $0x1, %esi
callq 0x9cf0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arkanis[P]process-map/./deps/raygui.h
// Function: GuiListView
int GuiListView(Rectangle bounds, const char *text, int *scrollIndex, int active)
{
    int itemsCount = 0;
    const char **items = NULL;

    if (text != NULL) items = GuiTextSplit(text, &itemsCount, NULL);

    return GuiListViewEx(bounds, items, itemsCount, NULL, scrollIndex, active);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xeb58
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xaac0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0x28(%rbp), %esi
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
xorl %eax, %eax
movl %eax, %edx
callq 0xeb80
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/arkanis[P]process-map/map.c
// Function: LoadSdfFont
Font LoadSdfFont(const char* fileName) {
	uint32_t fontFileSize = 0;
	uint8_t* fontFileData = LoadFileData(fileName, &fontFileSize);
		Font font = { .baseSize = 32, .charsCount = 95 };
		font.chars = LoadFontData(fontFileData, fontFileSize, font.baseSize, NULL, 0, FONT_SDF);
		Image atlas = GenImageFontAtlas(font.chars, &font.recs, font.charsCount, font.baseSize, 0, 1);
			font.texture = LoadTextureFromImage(atlas);
			SetTextureFilter(font.texture, FILTER_BILINEAR);
		UnloadImage(atlas);
	UnloadFileData(fontFileData);
	return font;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x71580
movq -0x68(%rbp), %rdi
movq %rax, -0x18(%rbp)
xorl %esi, %esi
movl $0x30, %edx
callq 0x6060
movq -0x68(%rbp), %rax
movl $0x20, (%rax)
movl $0x5f, 0x4(%rax)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
movl (%rax), %edx
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
movl $0x2, %r9d
callq 0x64290
movq -0x68(%rbp), %rdi
movq %rax, 0x28(%rdi)
movq 0x28(%rdi), %rsi
movq %rdi, %rdx
addq $0x20, %rdx
movl 0x4(%rdi), %ecx
movl (%rdi), %r8d
leaq -0x30(%rbp), %rdi
xorl %r9d, %r9d
movl $0x1, (%rsp)
callq 0x647f0
leaq -0x44(%rbp), %rdi
leaq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x4f700
movq -0x68(%rbp), %rdi
movq -0x44(%rbp), %rax
movq %rax, 0xc(%rdi)
movq -0x3c(%rbp), %rax
movq %rax, 0x14(%rdi)
movl -0x34(%rbp), %eax
movl %eax, 0x1c(%rdi)
movq 0xc(%rdi), %rax
movq %rax, -0x58(%rbp)
movq 0x14(%rdi), %rax
movq %rax, -0x50(%rbp)
movl 0x1c(%rdi), %eax
movl %eax, -0x48(%rbp)
leaq -0x58(%rbp), %rax
movl $0x1, %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x10(%rsp)
callq 0x50200
leaq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x46670
movq -0x18(%rbp), %rdi
callq 0x716d0
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arkanis[P]process-map/map.c
// Function: HilberCurvePosToDist
uint64_t HilberCurvePosToDist(uint64_t curveOrder, int x, int y) {
	uint64_t d = 0, tmp;
	for (uint64_t s = (1 << curveOrder) / 2; s > 0; s /= 2) {
		uint64_t rx = 0, ry = 0;
		
		if ((x & s) > 0) rx = 1;
		if ((y & s) > 0) ry = 1;
		
		d += s * s * ((3 * rx) ^ ry);
		
		// inlining
		// hilbertRot(s, p, rx, ry)
		if (ry == 0) {
			if (rx == 1) {
				x = s - 1 - x;
				y = s - 1 - y;
			}
			tmp = x;
			x = y;
			y = tmp;
		}
		// end inline
	}
	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
movl $0x2, %ecx
cltd
idivl %ecx
cltq
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x1653f
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movslq -0xc(%rbp), %rax
andq -0x28(%rbp), %rax
cmpq $0x0, %rax
jbe 0x164b2
movq $0x1, -0x30(%rbp)
movslq -0x10(%rbp), %rax
andq -0x28(%rbp), %rax
cmpq $0x0, %rax
jbe 0x164c8
movq $0x1, -0x38(%rbp)
movq -0x28(%rbp), %rax
imulq -0x28(%rbp), %rax
imulq $0x3, -0x30(%rbp), %rcx
xorq -0x38(%rbp), %rcx
imulq %rcx, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x1652d
cmpq $0x1, -0x30(%rbp)
jne 0x16518
movq -0x28(%rbp), %rax
subq $0x1, %rax
movslq -0xc(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0xc(%rbp)
movq -0x28(%rbp), %rax
subq $0x1, %rax
movslq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x10(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
movl %eax, -0x10(%rbp)
jmp 0x1652f
movq -0x28(%rbp), %rax
shrq %rax
movq %rax, -0x28(%rbp)
jmp 0x16481
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arkanis[P]process-map/map.c
// Function: HumanReadableByteSize
double HumanReadableByteSize(size_t bytes, const char** unit) {
	static const char* units[] = { "Byte", "KiByte", "MiByte", "GiByte", "TiByte", "PiByte", "EiByte", "ZiByte", "YiByte" };
	size_t unitIndex = floor(log2(bytes) / 10);
	if (unitIndex >= sizeof(units) / sizeof(units[0]))
		unitIndex = sizeof(units) / sizeof(units[0]) - 1;
	
	*unit = units[unitIndex];
	return bytes / pow(1024, unitIndex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movaps 0x75809(%rip), %xmm1    # 0x8c0a0
movq -0x8(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x75808(%rip), %xmm1    # 0x8c0b0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
callq 0x6630
movsd 0x7585c(%rip), %xmm1    # 0x8c120
divsd %xmm1, %xmm0
callq 0x66e0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x75814(%rip), %xmm1    # 0x8c0f8
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpq $0x9, -0x18(%rbp)
jb 0x16906
movq $0x8, -0x18(%rbp)
movq -0x18(%rbp), %rcx
leaq 0xb1b0f(%rip), %rax     # 0xc8420
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movaps 0x7577d(%rip), %xmm2    # 0x8c0a0
movq -0x8(%rbp), %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x7577c(%rip), %xmm0    # 0x8c0b0
subpd %xmm0, %xmm1
movaps %xmm1, %xmm3
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm3, %xmm1
movsd %xmm1, -0x20(%rbp)
movq -0x18(%rbp), %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd 0x757c0(%rip), %xmm0    # 0x8c128
callq 0x6750
movaps %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
divsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/arkanis[P]process-map/map.c
// Function: UnloadTaskTraces
void UnloadTaskTraces(TaskTraces* traces) {
	for (size_t i = 0; i < traces->taskCount; i++) {
		if ( ptrace(PTRACE_DETACH, traces->tasks[i].pid, NULL, NULL) != 0 )
			perror("ptrace(PTRACE_DETACH)");
		free(traces->tasks[i].name);
		glDeleteBuffers(1, (const GLuint[]){ traces->tasks[i].particleVBO });
		glDeleteVertexArrays(1, (const GLuint[]){ traces->tasks[i].particleVAO });
	}
	
	free(traces->tasks);
	UnloadShader(traces->particleShader);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x16a65
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl (%rax), %esi
movl $0x11, %edi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
movb $0x0, %al
callq 0x63b0
cmpq $0x0, %rax
je 0x169df
leaq 0x75a5b(%rip), %rdi     # 0x8c435
callq 0x6700
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x62e0
leaq 0xb520f(%rip), %rax     # 0xcbc10
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x10(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movl 0x18(%rcx), %ecx
movl %ecx, -0x14(%rbp)
leaq -0x14(%rbp), %rsi
movl $0x1, %edi
callq *%rax
leaq 0xb51ea(%rip), %rax     # 0xcbc18
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x10(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movl 0x14(%rcx), %ecx
movl %ecx, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
movl $0x1, %edi
callq *%rax
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x16994
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x62e0
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edi
movq 0x20(%rax), %rsi
callq 0x29010
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arkanis[P]process-map/map.c
// Function: UnloadAddrRanges
void UnloadAddrRanges(AddrRange** ranges, size_t* rangeCount) {
	for (size_t i = 0; i < *rangeCount; i++) {
		AddrRange* range = &(*ranges)[i];
		free(range->perms);
		free(range->filePath);
		free(range->label.text);
		
		UnloadTexture(range->symbolMap);
		for (size_t s = 0; s < range->symbolCount; s++)
			free(range->symbolLabels[s].text);
		free(range->symbolLabels);
	}
	free(*ranges);
	*ranges = NULL;
	*rangeCount = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x16b80
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xa0, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x62e0
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x62e0
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x62e0
movq -0x20(%rbp), %rax
addq $0x78, %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x10(%rsp)
callq 0x4ff80
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x90(%rcx), %rax
jae 0x16b5f
movq -0x20(%rbp), %rax
movq 0x98(%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x62e0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x16b22
movq -0x20(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x62e0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x16aa8
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x62e0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arkanis[P]process-map/map.c
// Function: LabelFor
Label LabelFor(char* text, Rectangle container, Font font) {
	Vector2 textSize = MeasureTextEx(font, text, 10, 0);
	float textScale = (container.width * 0.66) / textSize.x;
	return (Label){
		.text = text,
		.fontSize = 10 * textScale,
		.boundingBox = (Rectangle){
			.x = container.x + (container.width  - textSize.x * textScale) / 2,
			.y = container.y + (container.height - textSize.y * textScale) / 2,
			.width  = textSize.x * textScale,
			.height = textSize.y * textScale
		}
	};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movss 0x75425(%rip), %xmm0    # 0x8c01c
xorps %xmm1, %xmm1
callq 0x66400
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movlpd %xmm0, -0x20(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x75513(%rip), %xmm1    # 0x8c130
mulsd %xmm1, %xmm0
movss -0x20(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, (%rdi)
movss 0x753d6(%rip), %xmm0    # 0x8c01c
mulss -0x24(%rbp), %xmm0
movss %xmm0, 0x8(%rdi)
movss -0x10(%rbp), %xmm0
movss -0x8(%rbp), %xmm2
movss -0x20(%rbp), %xmm1
movss -0x24(%rbp), %xmm3
movd %xmm1, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm1
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
movss 0x75386(%rip), %xmm2    # 0x8c008
divss %xmm2, %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0xc(%rdi)
movss -0xc(%rbp), %xmm0
movss -0x4(%rbp), %xmm2
movss -0x1c(%rbp), %xmm1
movss -0x24(%rbp), %xmm3
movd %xmm1, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm1
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
movss 0x75347(%rip), %xmm2    # 0x8c008
divss %xmm2, %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0x10(%rdi)
movss -0x20(%rbp), %xmm0
mulss -0x24(%rbp), %xmm0
movss %xmm0, 0x14(%rdi)
movss -0x1c(%rbp), %xmm0
mulss -0x24(%rbp), %xmm0
movss %xmm0, 0x18(%rdi)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arkanis[P]process-map/map.c
// Function: fnv1a
uint32_t fnv1a(void *buffer, size_t size) {
	uint32_t hash = 2166136261;
	for (char* c = buffer; c < (char*)buffer + size; c++) {
		hash ^= *c;
		hash *= 16777619;
	}
	return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x811c9dc5, -0x14(%rbp) # imm = 0x811C9DC5
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
addq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jae 0x16d51
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
xorl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
imull $0x1000193, -0x14(%rbp), %eax # imm = 0x1000193
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x16d1b
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arkanis[P]process-map/map.c
// Function: HilberCurveDistToPos
void HilberCurveDistToPos(uint64_t curveOrder, uint64_t dist, int* x, int* y) {
	*x = 0; *y = 0;
	uint64_t tmp;
	uint64_t n = 1 << curveOrder;
	for (uint64_t s = 1; s < n; s *= 2) {
		uint64_t rx = 1 & (dist / 2);
		uint64_t ry = 1 & (dist ^ rx);
		// inlining
		// hilbertRot(s, p, rx, ry)
		if (ry == 0) {
			if (rx == 1) {
				*x = s - 1 - *x;
				*y = s - 1 - *y;
			}
			tmp = *x;
			*x = *y;
			*y = tmp;
		}
		// end inline

		*x += s * rx;
		*y += s * ry;
		dist /= 4;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
cltq
movq %rax, -0x30(%rbp)
movq $0x1, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x16e7b
movq -0x10(%rbp), %rax
shrq %rax
andq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
xorq -0x40(%rbp), %rax
andq $0x1, %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x16e35
cmpq $0x1, -0x40(%rbp)
jne 0x16e12
movq -0x38(%rbp), %rax
subq $0x1, %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
subq $0x1, %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rdx
imulq -0x40(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq (%rax), %rcx
addq %rdx, %rcx
movl %ecx, (%rax)
movq -0x38(%rbp), %rdx
imulq -0x48(%rbp), %rdx
movq -0x20(%rbp), %rax
movslq (%rax), %rcx
addq %rdx, %rcx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
shrq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
shlq %rax
movq %rax, -0x38(%rbp)
jmp 0x16da3
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/tests/test_bisect.c
// Function: lfind_ge
void *
lfind_ge(const void *key, const void *arr, size_t el_num, size_t el_size,
         int (*compare) (const void *, const void *))
{
    char *off = (char *) arr;
    char *high = off + el_num * el_size;
    int t;

    while (off < high) {
        t = (*compare) (key, off);
        if ((t == 0) || (t < 0)) {
            return off;
        }
        off += el_size;
    }

    return off;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
imulq -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x15b7
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x159f
cmpl $0x0, -0x44(%rbp)
jge 0x15a9
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15bf
movq -0x28(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x1578
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/tests/test_bisect.c
// Function: lfind_gt
void *
lfind_gt(const void *key, const void *arr, size_t el_num, size_t el_size,
         int (*compare) (const void *, const void *))
{
    char *off = (char *) arr;
    char *high = off + el_num * el_size;
    int t;

    while (off < high) {
        t = (*compare) (key, off);
        if (t < 0) {
            return off;
        }
        off += el_size;
    }

    return off;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
imulq -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x1641
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jge 0x1633
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1649
movq -0x28(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x1608
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/tests/test_bisect.c
// Function: bisect_suite
SUITE(bisect_suite)
{
    int i;

    for (i = 0; i < TEST_NUM; i++) {
        RUN_TEST(do_bisect_left_test);
    }

    for (i = 0; i < TEST_NUM; i++) {
        RUN_TEST(do_bisect_right_test);
    }

    for (i = 0; i < TEST_NUM; i++) {
        RUN_TEST(do_bisect_min_max);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x40, -0x4(%rbp)
jge 0x16b4
jmp 0x1677
leaq 0x2bcc(%rip), %rdi      # 0x424a
callq 0x1760
cmpl $0x1, %eax
jne 0x16a5
movl $0x0, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x169d
callq 0x2d30
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x1970
jmp 0x16a7
jmp 0x16a9
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x166f
movl $0x0, -0x4(%rbp)
cmpl $0x40, -0x4(%rbp)
jge 0x1700
jmp 0x16c3
leaq 0x2b94(%rip), %rdi      # 0x425e
callq 0x1760
cmpl $0x1, %eax
jne 0x16f1
movl $0x0, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x16e9
callq 0x2e80
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x1970
jmp 0x16f3
jmp 0x16f5
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x16bb
movl $0x0, -0x4(%rbp)
cmpl $0x40, -0x4(%rbp)
jge 0x174c
jmp 0x170f
leaq 0x2b5d(%rip), %rdi      # 0x4273
callq 0x1760
cmpl $0x1, %eax
jne 0x173d
movl $0x0, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x1735
callq 0x2fd0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
callq 0x1970
jmp 0x173f
jmp 0x1741
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1707
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/tests/test_bisect.c
// Function: main
int
main(int argc, char *argv[])
{
    GREATEST_MAIN_BEGIN();
#if defined(__STDC_VERSION__)
    printf("Compiler Standard version - %ld\n", __STDC_VERSION__);
#endif

    srand(time(NULL));

    RUN_SUITE(bisect_suite);

    GREATEST_MAIN_END();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2510
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x25b0
leaq 0x16e7(%rip), %rdi      # 0x43b5
movl $0x313ee, %esi          # imm = 0x313EE
movb $0x0, %al
callq 0x1080
xorl %eax, %eax
movl %eax, %edi
callq 0x1100
movl %eax, %edi
callq 0x10c0
leaq -0x1691(%rip), %rdi     # 0x1660
leaq 0x16de(%rip), %rsi      # 0x43d6
callq 0x2580
callq 0x27e0
callq 0x2070
movl %eax, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/tests/test_bisect.c
// Function: do_bisect_left_test
TEST
do_bisect_left_test()
{
    size_t i;
    int r;

    for (i = 0; i < ARR_SZ; i++) {
        arint[i] = rand();
    }

    qsort(&arint[0], ARR_SZ, sizeof (int), cmp_int);

    for (i = 0; i < TEST_NUM; i++) {
        r = rand();
        ASSERT_EQ(lfind_ge(&r, &arint[0], ARR_SZ, sizeof (int), cmp_int),
                  bisect_left(&r, &arint[0], ARR_SZ, sizeof (int),
                              cmp_int));
    }

    PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x10(%rbp)
cmpq $0xfffff, -0x10(%rbp)   # imm = 0xFFFFF
jae 0x2d6d
callq 0x1130
movl %eax, %edx
movq -0x10(%rbp), %rcx
leaq 0x4394(%rip), %rax      # 0x70f0
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2d40
leaq 0x437c(%rip), %rdi      # 0x70f0
movl $0xfffff, %esi          # imm = 0xFFFFF
movl $0x4, %edx
leaq -0x1895(%rip), %rcx     # 0x14f0
callq 0x1050
movq $0x0, -0x10(%rbp)
cmpq $0x40, -0x10(%rbp)
jae 0x2e60
callq 0x1130
movl %eax, -0x14(%rbp)
movl 0x404389(%rip), %eax    # 0x407134
addl $0x1, %eax
movl %eax, 0x404380(%rip)    # 0x407134
leaq -0x14(%rbp), %rdi
leaq 0x4331(%rip), %rsi      # 0x70f0
movl $0xfffff, %edx          # imm = 0xFFFFF
movl $0x4, %ecx
leaq -0x18e0(%rip), %r8      # 0x14f0
callq 0x1540
movq %rax, -0x20(%rbp)
leaq -0x14(%rbp), %rdi
leaq 0x430c(%rip), %rsi      # 0x70f0
movl $0xfffff, %edx          # imm = 0xFFFFF
movl $0x4, %ecx
leaq -0x1905(%rip), %r8      # 0x14f0
callq 0x1250
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0x2e4b
jmp 0x2e08
leaq 0x15d4(%rip), %rax      # 0x43e3
movq %rax, 0x40432a(%rip)    # 0x407140
movl $0x51, 0x404318(%rip)   # 0x407138
leaq 0x15d0(%rip), %rax      # 0x43f7
movq %rax, 0x40431a(%rip)    # 0x407148
movzbl 0x4042bb(%rip), %eax    # 0x4070f0
andl $0x4, %eax
cmpl $0x0, %eax
je 0x2e42
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e74
jmp 0x2e4d
jmp 0x2e4f
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2d92
jmp 0x2e62
movq $0x0, 0x4042db(%rip) # 0x407148
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/tests/test_bisect.c
// Function: do_bisect_right_test
TEST
do_bisect_right_test()
{
    size_t i;
    int r;

    for (i = 0; i < ARR_SZ; i++) {
        arint[i] = rand();
    }

    qsort(&arint[0], ARR_SZ, sizeof (int), cmp_int);

    for (i = 0; i < TEST_NUM; i++) {
        r = rand();
        ASSERT_EQ(lfind_gt(&r, &arint[0], ARR_SZ, sizeof (int), cmp_int),
                  bisect_right(&r, &arint[0], ARR_SZ, sizeof (int),
                               cmp_int));
    }

    PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x10(%rbp)
cmpq $0xfffff, -0x10(%rbp)   # imm = 0xFFFFF
jae 0x2ebd
callq 0x1130
movl %eax, %edx
movq -0x10(%rbp), %rcx
leaq 0x4244(%rip), %rax      # 0x70f0
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2e90
leaq 0x422c(%rip), %rdi      # 0x70f0
movl $0xfffff, %esi          # imm = 0xFFFFF
movl $0x4, %edx
leaq -0x19e5(%rip), %rcx     # 0x14f0
callq 0x1050
movq $0x0, -0x10(%rbp)
cmpq $0x40, -0x10(%rbp)
jae 0x2fb0
callq 0x1130
movl %eax, -0x14(%rbp)
movl 0x404239(%rip), %eax    # 0x407134
addl $0x1, %eax
movl %eax, 0x404230(%rip)    # 0x407134
leaq -0x14(%rbp), %rdi
leaq 0x41e1(%rip), %rsi      # 0x70f0
movl $0xfffff, %edx          # imm = 0xFFFFF
movl $0x4, %ecx
leaq -0x1a30(%rip), %r8      # 0x14f0
callq 0x15d0
movq %rax, -0x20(%rbp)
leaq -0x14(%rbp), %rdi
leaq 0x41bc(%rip), %rsi      # 0x70f0
movl $0xfffff, %edx          # imm = 0xFFFFF
movl $0x4, %ecx
leaq -0x1a55(%rip), %r8      # 0x14f0
callq 0x13a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0x2f9b
jmp 0x2f58
leaq 0x1484(%rip), %rax      # 0x43e3
movq %rax, 0x4041da(%rip)    # 0x407140
movl $0x67, 0x4041c8(%rip)   # 0x407138
leaq 0x14f4(%rip), %rax      # 0x446b
movq %rax, 0x4041ca(%rip)    # 0x407148
movzbl 0x40416b(%rip), %eax    # 0x4070f0
andl $0x4, %eax
cmpl $0x0, %eax
je 0x2f92
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2fc4
jmp 0x2f9d
jmp 0x2f9f
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2ee2
jmp 0x2fb2
movq $0x0, 0x40418b(%rip) # 0x407148
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/audio.c
// Function: main
int main(int arcg, char *argv[]) {
    scg_config_t config = scg_config_new_default();
    config.video.title = "SCG Example: Audio";
    config.audio.enabled = true;

    scg_app_t app;
    scg_app_init(&app, config);

    scg_sound_t *music =
        scg_sound_new_from_wav(app.audio, "assets/arcade-music-loop.wav", true);
    if (music == NULL) {
        return -1;
    }
    scg_sound_play(music);

    while (scg_app_process_events(&app)) {
        float32_t play_position = scg_sound_get_position(music);
        draw(app.draw_target, play_position);

        scg_app_present(&app);
    }

    scg_app_free(&app);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x49e0
leaq 0xe93(%rip), %rax       # 0x759c
movq %rax, -0x30(%rbp)
movb $0x1, -0x1c(%rbp)
movq -0x18(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xa0(%rbp), %rdi
callq 0x4a30
movq -0x50(%rbp), %rdi
leaq 0xe6d(%rip), %rsi       # 0x75af
movl $0x1, %edx
callq 0x47b0
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
jne 0x6766
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x67ca
movq -0xa8(%rbp), %rdi
callq 0x4980
leaq -0xa0(%rbp), %rdi
callq 0x56b0
testb $0x1, %al
jne 0x6784
jmp 0x67b7
movq -0xa8(%rbp), %rdi
callq 0x49a0
movss %xmm0, -0xac(%rbp)
movq -0x68(%rbp), %rdi
movss -0xac(%rbp), %xmm0
callq 0x67e0
leaq -0xa0(%rbp), %rdi
callq 0x5800
jmp 0x6772
leaq -0xa0(%rbp), %rdi
callq 0x5cb0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/audio.c
// Function: draw
static void draw(scg_image_t *draw_target, float32_t music_progress) {
    int w = draw_target->width;
    int h = draw_target->height;
    scg_pixel_t clear_color = SCG_COLOR_WHITE;
    scg_pixel_t progress_bar_color = SCG_COLOR_BLACK;

    scg_image_clear(draw_target, clear_color);

    scg_image_draw_string(draw_target, "Playing: arcade-music-loop.wav", w / 2,
                          h / 2 - 20, true, progress_bar_color);

    int progress_bar_max_width = w - 20;
    int progress_bar_width =
        (int)((float32_t)progress_bar_max_width * music_progress);

    scg_image_draw_rect(draw_target, 10, h / 2 + 20, progress_bar_max_width, 10,
                        progress_bar_color);
    scg_image_fill_rect(draw_target, 10, h / 2 + 20, progress_bar_width, 10,
                        progress_bar_color);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movl 0x832(%rip), %eax       # 0x703c
movl %eax, -0x18(%rbp)
movl 0x82d(%rip), %eax       # 0x7040
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x3100
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl -0x28(%rbp), %edx
movl %eax, %ecx
subl $0x14, %ecx
movl -0x1c(%rbp), %r9d
leaq 0x196d(%rip), %rsi      # 0x81bf
movl $0x1, %r8d
callq 0x4190
movl -0x10(%rbp), %eax
subl $0x14, %eax
movl %eax, -0x20(%rbp)
cvtsi2ssl -0x20(%rbp), %xmm0
mulss -0xc(%rbp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edx
addl $0x14, %edx
movl -0x20(%rbp), %ecx
movl -0x1c(%rbp), %r9d
movl $0xa, %r8d
movl %r8d, %esi
callq 0x3c30
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edx
addl $0x14, %edx
movl -0x24(%rbp), %ecx
movl -0x1c(%rbp), %r9d
movl $0xa, %r8d
movl %r8d, %esi
callq 0x3ce0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-gcc.c
// Function: main
int main(int argc,char** argv) {

  mypid = getpid();
  
  debug("[bunny] bunny-gcc " VERSION " (" __DATE__ " " __TIME__ ") by <lcamtuf@google.com>\n");

  parse_params((_u32)argc,(_u8**)argv);
  precompile();
  insert_hooks();
  
  /* Common sense would suggest that calling gcc -E <file.i> -o <file.i> would simply copy
     input to output. No dice. */
  
  if (gcc_mode == 'E') dump_code(); else compile();

  exit(0);
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x11f0
movl %eax, 0x9def(%rip)      # 0xb150
movq 0x9c78(%rip), %rax      # 0xafe0
movq (%rax), %rdi
leaq 0x5dea(%rip), %rsi      # 0x715c
movb $0x0, %al
callq 0x11c0
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x13b0
callq 0x3810
callq 0x3910
movzbl 0x9dbe(%rip), %eax      # 0xb154
cmpl $0x45, %eax
jne 0x13a2
callq 0x54e0
jmp 0x13a7
callq 0x5730
xorl %edi, %edi
callq 0x1190
nop
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-gcc.c
// Function: precompile
static void precompile(void) {
  _u32 i;
  _u8 tmp[128], *gcc = getenv("BUNNY_GCC");
  
  if (!gcc) gcc = "/usr/bin/gcc";

  for (i=0;i<used_files.c;i++) {
    sprintf(tmp,".bunny-%x-%u.i",mypid,i);
    
    /* We "trust" gcc to safely create the output file. Perhaps not the best idea ever, but 
       then neither is running gcc in world-writable directories to begin with - no point
       in pretending we could fix it. */
    
    preproc_params.v[preproc_params.c-3] = used_files.v[i];
    preproc_params.v[preproc_params.c-1] = tmp;

    debug("[bunny] STAGE 1/3: Precompiling '%s'...\n",used_files.v[i]);
    wait_execvp(gcc,preproc_params.v);
    
  }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq 0x3b46(%rip), %rdi      # 0x7368
callq 0x11a0
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
jne 0x3846
leaq 0x3b33(%rip), %rax      # 0x7372
movq %rax, -0x98(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x7932(%rip), %eax      # 0xb188
jae 0x3902
leaq -0x90(%rbp), %rdi
movl 0x78e7(%rip), %edx      # 0xb150
movl -0x4(%rbp), %ecx
leaq 0x3b0c(%rip), %rsi      # 0x737f
movb $0x0, %al
callq 0x1040
movq 0x78ff(%rip), %rax      # 0xb180
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
movq 0x78c9(%rip), %rax      # 0xb158
movl 0x78cb(%rip), %ecx      # 0xb160
subl $0x3, %ecx
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
leaq -0x90(%rbp), %rdx
movq 0x78ac(%rip), %rax      # 0xb158
movl 0x78ae(%rip), %ecx      # 0xb160
subl $0x1, %ecx
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
movq 0x771e(%rip), %rax      # 0xafe0
movq (%rax), %rdi
movq 0x78b4(%rip), %rax      # 0xb180
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
leaq 0x3ab4(%rip), %rsi      # 0x738e
movb $0x0, %al
callq 0x11c0
movq -0x98(%rbp), %rdi
movq 0x7869(%rip), %rsi      # 0xb158
callq 0x5a40
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x384d
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/bloom/./BloomFilter.cpp
// Function: Bloom::isExist(char*)
int Bloom::isExist( char *str )
{
	int ret;
	pthread_mutex_lock(&lockis);
	ret = search(str);
	pthread_mutex_unlock(&lockis);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xbb65d(%rip), %rdi     # 0xc3ff0
callq 0x8410
movq -0x8(%rbp), %rdi
callq 0xad80
movl %eax, -0xc(%rbp)
leaq 0xbb645(%rip), %rdi     # 0xc3ff0
callq 0x81f0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/dns/DNSCache.cpp
// Function: DNSCache::getDNSCache()
DNSCache* DNSCache::getDNSCache()
{
	if ( dnsCa == NULL )
	{
		pthread_mutex_lock(&lock);
		dnsCa = new DNSCache(); 
		pthread_mutex_unlock(&lock);
	}
	return dnsCa;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpq $0x0, 0xbb628(%rip)     # 0xc4018
jne 0x8a4e
leaq 0xbb627(%rip), %rdi     # 0xc4020
callq 0x8410
movl $0xf8, %edi
callq 0x82d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x18(%rbp)
callq 0x89c0
jmp 0x8a19
movq -0x18(%rbp), %rax
movq %rax, 0xbb5f4(%rip)     # 0xc4018
leaq 0xbb5f5(%rip), %rdi     # 0xc4020
callq 0x81f0
jmp 0x8a4e
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl $0xf8, %esi
callq 0x82e0
jmp 0x8a5b
movq 0xbb5c3(%rip), %rax     # 0xc4018
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
callq 0x84e0
nopw %cs:(%rax,%rax)