// File: /workspace/github_c_makefile_star2_O2/arkanis[P]process-map/map.c
// Function: main
int main(int argc, char** argv) {
	if (argc != 2) {
		fprintf(stderr, "usage: %s pid\n", argv[0]);
		return 0;
	}
	
	FILE* cmdLineFile = fopen(TextFormat("/proc/%s/cmdline", argv[1]), "rb");
	if (cmdLineFile == NULL) {
		fprintf(stderr, "Couldn't find process %s\n", argv[1]);
		return 0;
	}
	char* cmdLine = NULL;
	fscanf(cmdLineFile, "%m[^\n]", &cmdLine);
	fclose(cmdLineFile);
	
	int screenWidth = 800, screenHeight = 600;
	SetConfigFlags(FLAG_VSYNC_HINT | FLAG_WINDOW_RESIZABLE);
	InitWindow(screenWidth, screenHeight, TextFormat("Memory map of process %s: %s", argv[1], cmdLine));
	
	Font uiFont      = LoadFontEx("NotoSans-Regular.ttf", 16, NULL, 0);
	Font mapLabelSdfFont = LoadSdfFont("NotoSans-Regular.ttf");
	Shader sdfFontShader = LoadShader(NULL, "sdf-text.fs");
	
	GuiSetFont(uiFont);
	
	AddrRange* ranges = NULL;
	size_t rangeCount = 0;
	LoadAddrRanges(argv[1], &ranges, &rangeCount);
	size_t hilbertCurveOrder = 0;
	Texture2D mapTexture = PlotAddrRanges(ranges, rangeCount, mapLabelSdfFont, &hilbertCurveOrder);
	PlotRangeElfSymbols(ranges, rangeCount, hilbertCurveOrder, mapLabelSdfFont);
	
	Shader mapShader = LoadShader(NULL, "range-map2.fs");
	int selectedColorLoc = GetShaderLocation(mapShader, "selectedColor");
	Shader symbolMapShader = LoadShader(NULL, "symbol-map.fs");
	
	TaskTraces traces = LoadTaskTraces(argv[1]);
	
	Camera2D camera = (Camera2D){
		.target = (Vector2){ mapTexture.width / 2, mapTexture.height / 2 },
		.offset = (Vector2){ screenWidth / 2, screenHeight / 2 },
		.zoom = 1.0
	};
	
	bool wasWindowFocused = true, isPanning = false;
	Vector2 prevMousePos = { 0 };
	while ( !WindowShouldClose() ) {
		if ( IsWindowResized() ) {
			screenWidth = GetScreenWidth();
			screenHeight = GetScreenHeight();
		}
		
		// Reduce FPS when window isn't focused
		if ( IsWindowFocused() && !wasWindowFocused ) {
			wasWindowFocused = true;
			SetTargetFPS(0);
		} else if ( !IsWindowFocused() && wasWindowFocused ) {
			wasWindowFocused = false;
			SetTargetFPS(30);
		}
		
		// Mouse panning
		if ( IsMouseButtonPressed(MOUSE_LEFT_BUTTON) ) {
			isPanning = true;
			prevMousePos = GetMousePosition();
		} else if ( isPanning && IsMouseButtonReleased(MOUSE_LEFT_BUTTON) ) {
			isPanning = false;
		} else if ( isPanning ) {
			float dx = prevMousePos.x - GetMouseX(), dy = prevMousePos.y - GetMouseY();
			camera.target.x += dx / camera.zoom;
			camera.target.y += dy / camera.zoom;
			prevMousePos = GetMousePosition();
		}
		
		// Mousewheel zooming (world space position remains the same directly at the mouse pointer)
		const float factor = powf(0.9, -GetMouseWheelMove());  // 0.9^1 = 0.9, 0.9^-1 = 1/0.9
		Vector2 mousePosWs = GetScreenToWorld2D(GetMousePosition(), camera);
		float oldScale = camera.zoom, newScale = camera.zoom * factor;
		camera.target.x = mousePosWs.x + (camera.target.x - mousePosWs.x) * (oldScale / newScale);
		camera.target.y = mousePosWs.y + (camera.target.y - mousePosWs.y) * (oldScale / newScale);
		camera.zoom = newScale;
		
		// Handle keyboard input
		if (IsKeyPressed(KEY_R)) {
			mapShader = LoadShader(NULL, "range-map2.fs");
			symbolMapShader = LoadShader(NULL, "symbol-map.fs");
		}
		
		// Picking
		AddrRange* selectedRange = NULL;
		Color      selectedRangeColor = BLACK;
		if ( CheckCollisionPointRec(mousePosWs, (Rectangle){ .x = 0, .y = 0, .width = mapTexture.width, .height = mapTexture.height }) ) {
			uint64_t page = HilberCurvePosToDist(hilbertCurveOrder, mousePosWs.x, mousePosWs.y);
			for (size_t i = 0; i < rangeCount; i++) {
				if (page >= ranges[i].startPage && page < ranges[i].endPage) {
					selectedRange = &ranges[i];
					selectedRangeColor = selectedRange->color;
					break;
				}
			}
		}
		
		UpdateTaskTraces(&traces, ranges, rangeCount, hilbertCurveOrder);
		
		
		// Prepare view culling
		Vector2 viewTopLeft = GetScreenToWorld2D((Vector2){ 0, 0 }, camera);
		Vector2 viewBottomRight = GetScreenToWorld2D((Vector2){ screenWidth, screenHeight }, camera);
		Rectangle viewBoundingBox = (Rectangle){ .x = viewTopLeft.x, .y = viewTopLeft.y, .width = viewBottomRight.x - viewTopLeft.x, .height = viewBottomRight.y - viewTopLeft.y };
		
		BeginDrawing();
			ClearBackground(WHITE);
			
			BeginMode2D(camera);
				// Draw map legend
				int lx = -220, ly = 0;
				DrawRectangle(lx, ly, 16, 16, (Color){ 184, 224, 198, 255 });
				BeginShaderMode(sdfFontShader);
					DrawTextEx(mapLabelSdfFont, "File backed memory map",          (Vector2){ -200, ly }, 14, 0, BLACK); ly += 14;
					DrawTextEx(mapLabelSdfFont, "(different color for each name)", (Vector2){ -200, ly }, 14, 0, BLACK); ly += 14 + 6;
				EndShaderMode();
				DrawRectangle(lx, ly, 16, 16, (Color){ 229, 229, 229, 255 });
				BeginShaderMode(sdfFontShader);
					DrawTextEx(mapLabelSdfFont, "Anonymous memory map",            (Vector2){ -200, ly }, 14, 0, BLACK); ly += 14 + 6;
				EndShaderMode();
				DrawRectangle(lx, ly, 16, 16, (Color){ 250, 250, 250, 255 });
				BeginShaderMode(sdfFontShader);
					DrawTextEx(mapLabelSdfFont, "Unused address space",            (Vector2){ -200, ly }, 14, 0, BLACK); ly += 14 + 6;
					DrawTextEx(mapLabelSdfFont, "(not displayed to scale)",        (Vector2){ -200, ly }, 14, 0, BLACK); ly += (14 + 6) * 2;
				EndShaderMode();
				DrawRectangle(lx, ly, 16, 16, (Color){ 229, 229, 229, 255 });
				BeginShaderMode(sdfFontShader);
					DrawTextEx(mapLabelSdfFont, "1 MiByte to scale",               (Vector2){ -200, ly }, 14, 0, BLACK); ly += 14 + 6;
				EndShaderMode();
				DrawRectangle(lx - (64-16), ly, 64, 64, (Color){ 229, 229, 229, 255 });
				BeginShaderMode(sdfFontShader);
					DrawTextEx(mapLabelSdfFont, "16 MiByte to scale",              (Vector2){ -200, ly }, 14, 0, BLACK); ly += 14 + 6;
				EndShaderMode();
				
				// Draw map and highlight selected range
				BeginShaderMode(mapShader);
					Vector4 selectedColor = ColorNormalize(selectedRangeColor);
					SetShaderValue(mapShader, selectedColorLoc, &selectedColor, UNIFORM_VEC4);
					DrawTexture(mapTexture, 0, 0, BLANK);
				EndShaderMode();
				
				if (selectedRange && selectedRange->label.boundingBox.width < viewBoundingBox.width * mmapLabelMaxWindowFraction) {
					BeginShaderMode(sdfFontShader);
						DrawTextEx(mapLabelSdfFont, selectedRange->label.text, (Vector2){ selectedRange->label.boundingBox.x, selectedRange->label.boundingBox.y }, selectedRange->label.fontSize, 0, BLACK);
					EndShaderMode();
				}
				
				// Draw range lables, their symbol maps and the symbol lables if necessary
				for (size_t i = 0; i < rangeCount; i++) {
					AddrRange* range = &ranges[i];
					if ( CheckCollisionRecs(range->boundingBox, viewBoundingBox) ) {
						if (range->boundingBox.width < viewBoundingBox.width * mmapLabelMaxWindowFraction) {
							BeginShaderMode(sdfFontShader);
								DrawTextEx(mapLabelSdfFont, range->label.text, (Vector2){ range->label.boundingBox.x, range->label.boundingBox.y }, range->label.fontSize, 0, (Color){ 0, 0, 0, 128 });
							EndShaderMode();
						}
						
						if (range->boundingBox.width > viewBoundingBox.width * mmapDetailsMinWindowFraction) {
							BeginShaderMode(symbolMapShader);
								DrawTexturePro(range->symbolMap, (Rectangle){ 0, 0, range->symbolMap.width, range->symbolMap.height }, range->boundingBox, (Vector2){ 0, 0 }, 0, (Color){0, 0, 0, 32});
							EndShaderMode();
							
							BeginShaderMode(sdfFontShader);
								for (size_t s = 0; s < range->symbolCount; s++) {
									Label* label = &range->symbolLabels[s];
									if ( CheckCollisionRecs(label->boundingBox, viewBoundingBox) && label->boundingBox.height * camera.zoom > 2 )
										DrawTextEx(mapLabelSdfFont, label->text, (Vector2){ label->boundingBox.x, label->boundingBox.y }, label->fontSize, 0, (Color){ 0, 0, 0, 128 });
								}
							EndShaderMode();
						}
					}
				}
				
				rlglDraw();
				glUseProgram(traces.particleShader.id);
					// Have to set the model view projection matrix manually because raylib has not matrix uniform type
					Matrix mvp = MatrixMultiply(GetMatrixModelview(), GetMatrixProjection());
					glUniformMatrix4fv(traces.particleShader.locs[LOC_MATRIX_MVP], 1, false, MatrixToFloat(mvp));
					glUniform1ui(traces.shaderCurrentTimeLocation, traces.currentTime);
					
					for (size_t t = 0; t < traces.taskCount; t++) {
						if (traces.focusedTaskIndex == -1 || (ssize_t)t == traces.focusedTaskIndex) {
							Color transparentColor = traces.tasks[t].color;
							transparentColor.a = 64;
							Vector4 color = ColorNormalize(transparentColor);
							SetShaderValue(traces.particleShader, traces.shaderColorLocation, &color, UNIFORM_VEC4);
							glBindVertexArray(traces.tasks[t].particleVAO);
								glDrawArrays(GL_POINTS, 0, particleCount);
							glBindVertexArray(0);
						}
					}
				glUseProgram(0);
			EndMode2D();
			
			DrawRectangle(0, 0, screenWidth, 20, RAYWHITE);
			if (selectedRange) {
				const char* sizeUnit = NULL;
				double size = HumanReadableByteSize(selectedRange->endAddr - selectedRange->startAddr, &sizeUnit);
				DrawTextEx(uiFont, TextFormat("Size: %.2lf %s", size, sizeUnit), (Vector2){ 5, 3 }, uiFont.baseSize, 0, BLACK);
				DrawTextEx(uiFont, TextFormat("Address 0x%016lx - 0x%016lx", selectedRange->startAddr, selectedRange->endAddr), (Vector2){ 120, 3 }, uiFont.baseSize, 0, BLACK);
				
				if ( ! selectedRange->isGap ) {
					DrawTextEx(uiFont, selectedRange->perms,    (Vector2){ 410, 3 }, uiFont.baseSize, 0, BLACK);
					DrawTextEx(uiFont, selectedRange->filePath, (Vector2){ 450, 3 }, uiFont.baseSize, 0, BLACK);
				}
			}
			
			GuiEnable();
			Rectangle tasksPanel = (Rectangle){ screenWidth - 200, 20, 200, screenHeight };
			GuiPanel(tasksPanel);
			float x = 5, y = 5;
			for (ssize_t t = 0; t < (ssize_t)traces.taskCount; t++) {
				if (traces.focusedTaskIndex == -1 || t == traces.focusedTaskIndex) {
					GuiEnable();
					DrawCircle(tasksPanel.x + x + 3, tasksPanel.y + y + 16/2, 3, traces.tasks[t].color);
				} else {
					GuiDisable();
					DrawCircle(tasksPanel.x + x + 3, tasksPanel.y + y + 16/2, 3, LIGHTGRAY);
				}
				const char* text = TextFormat("Task %d%s", traces.tasks[t].pid, traces.tasks[t].dead ? " (dead)" : "");
				if ( GuiLabelButton((Rectangle){ tasksPanel.x + x + 10, tasksPanel.y + y, 200 - 2*5, 16 }, text) ) {
					if (t == traces.focusedTaskIndex)
						traces.focusedTaskIndex = -1;
					else
						traces.focusedTaskIndex = t;
				}
				GuiLabel((Rectangle){ tasksPanel.x + x + 10, tasksPanel.y + y + 16, 200 - 2*5, 16 }, traces.tasks[t].name);
				
				y += 20 + 16;
			}
			
		EndDrawing();
	}
	
	UnloadTaskTraces(&traces);
	UnloadShader(mapShader);
	UnloadTexture(mapTexture);
	UnloadAddrRanges(&ranges, &rangeCount);
	UnloadShader(sdfFontShader);
	UnloadFont(mapLabelSdfFont);
	UnloadShader(symbolMapShader);
	UnloadFont(uiFont);
	CloseWindow();
	free(cmdLine);
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x328, %rsp            # imm = 0x328
movq %rsi, %r15
cmpl $0x2, %edi
jne 0x102d8
movq 0x8(%r15), %rsi
leaq 0x4a3ff(%rip), %rdi     # 0x593ef
xorl %eax, %eax
callq 0x43d0d
leaq 0x4a3df(%rip), %rsi     # 0x593dd
movq %rax, %rdi
callq 0x61d0
testq %rax, %rax
je 0x102ee
movq %rax, %rbx
leaq 0x230(%rsp), %r14
andq $0x0, (%r14)
leaq 0x4a5ab(%rip), %rsi     # 0x595d0
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x60e0
movq %rbx, %rdi
callq 0x6630
pushq $0x44
popq %rdi
callq 0x23a79
movq 0x8(%r15), %rsi
movq (%r14), %rdx
leaq 0x4a3ca(%rip), %rdi     # 0x5941a
xorl %eax, %eax
callq 0x43d0d
movl $0x320, %ecx            # imm = 0x320
movq %rcx, 0x118(%rsp)
movl $0x258, 0xcc(%rsp) # imm = 0x258
movl $0x320, %edi            # imm = 0x320
movl $0x258, %esi            # imm = 0x258
movq %rax, %rdx
callq 0x20b36
leaq 0x4a3af(%rip), %rbx     # 0x59437
leaq 0x148(%rsp), %r13
pushq $0x10
popq %rdx
movq %r13, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x404c1
leaq 0xd0(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1030c
leaq 0x4a38f(%rip), %rsi     # 0x5944c
xorl %edi, %edi
callq 0x1c5c1
movl %eax, 0x84(%rsp)
movq %rdx, 0xa8(%rsp)
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x69a2
leaq 0x128(%rsp), %r13
andq $0x0, (%r13)
leaq 0x120(%rsp), %rbp
andq $0x0, (%rbp)
movq 0x8(%r15), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x10413
movq %r15, %rbx
leaq 0x178(%rsp), %r15
andq $0x0, (%r15)
movq (%r13), %r13
movq (%rbp), %rbp
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x190(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x105fe
movq (%r15), %rdx
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x10ad2
leaq 0x4a2b7(%rip), %rsi     # 0x59458
xorl %edi, %edi
callq 0x1c5c1
movq %rdx, %rsi
leaq 0x4a2b4(%rip), %rdx     # 0x59466
movl %eax, 0xa0(%rsp)
movl %eax, %edi
movq %rsi, 0x130(%rsp)
callq 0x1cb7d
movl %eax, 0x140(%rsp)
leaq 0x4a29e(%rip), %rsi     # 0x59474
xorl %edi, %edi
callq 0x1c5c1
movl %eax, 0xa4(%rsp)
movq %rdx, 0x138(%rsp)
movq 0x8(%rbx), %rsi
leaq 0x238(%rsp), %rdi
callq 0x10f13
movsd 0x49fdb(%rip), %xmm0    # 0x591e0
movq 0x4(%r14), %xmm1
movdqa %xmm1, %xmm2
psrld $0x1f, %xmm2
paddd %xmm1, %xmm2
psrad $0x1, %xmm2
cvtdq2ps %xmm2, %xmm1
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0xb0(%rsp)
movsd 0x49e8d(%rip), %xmm0    # 0x590c0
movsd %xmm0, 0xc0(%rsp)
movb $0x1, %al
movl %eax, 0x88(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x270(%rsp)
movl $0x0, 0x8c(%rsp)
callq 0x215ef
testb %al, %al
jne 0x101e2
callq 0x21685
testb %al, %al
je 0xf28a
callq 0x21cdc
movq %rax, 0x118(%rsp)
callq 0x21ce3
movl %eax, 0xcc(%rsp)
callq 0x2167a
testb %al, %al
je 0xf29d
testb $0x1, 0x88(%rsp)
je 0xf2c0
callq 0x2167a
testb %al, %al
jne 0xf2d0
testb $0x1, 0x88(%rsp)
je 0xf2d0
movl $0x0, 0x88(%rsp)
pushq $0x1e
popq %rdi
jmp 0xf2cb
movb $0x1, %al
movl %eax, 0x88(%rsp)
xorl %edi, %edi
callq 0x23979
xorl %edi, %edi
callq 0x2459e
testb %al, %al
je 0xf2f3
movb $0x1, %al
movl %eax, 0x8c(%rsp)
callq 0x1fd8b
movaps %xmm0, 0x270(%rsp)
jmp 0xf36c
testb $0x1, 0x8c(%rsp)
je 0xf361
movl $0x0, 0x8c(%rsp)
xorl %edi, %edi
callq 0x245dd
testb %al, %al
jne 0xf36c
callq 0x2463f
movl %eax, %ebp
callq 0x2465c
movd %ebp, %xmm0
movd %eax, %xmm1
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
cvtdq2ps %xmm0, %xmm0
movaps 0x270(%rsp), %xmm1
subps %xmm0, %xmm1
movss 0xc4(%rsp), %xmm0
unpcklps %xmm0, %xmm0            # xmm0 = xmm0[0,0,1,1]
divps %xmm0, %xmm1
movsd 0xb8(%rsp), %xmm0
addps %xmm1, %xmm0
movlps %xmm0, 0xb8(%rsp)
jmp 0xf2db
movl $0x0, 0x8c(%rsp)
callq 0x1fdaa
movaps %xmm0, %xmm1
xorps 0x49d65(%rip), %xmm1    # 0x590e0
movss 0x49ce1(%rip), %xmm0    # 0x59064
callq 0x6040
movss %xmm0, 0x90(%rsp)
callq 0x1fd8b
movq 0xc0(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0xb0(%rsp), %xmm1
movups %xmm1, (%rsp)
callq 0x238a1
movss 0xc4(%rsp), %xmm2
movss 0x90(%rsp), %xmm1
mulss %xmm2, %xmm1
divss %xmm1, %xmm2
movaps %xmm1, %xmm3
movsd 0xb8(%rsp), %xmm1
subps %xmm0, %xmm1
unpcklps %xmm2, %xmm2            # xmm2 = xmm2[0,0,1,1]
mulps %xmm1, %xmm2
movaps %xmm0, 0x90(%rsp)
addps %xmm0, %xmm2
movlps %xmm2, 0xb8(%rsp)
movss %xmm3, 0xc4(%rsp)
pushq $0x52
popq %rdi
callq 0x242af
testb %al, %al
je 0xf445
xorl %edi, %edi
leaq 0x4a044(%rip), %rsi     # 0x59458
callq 0x1c5c1
movl %eax, 0xa0(%rsp)
movq %rdx, 0x130(%rsp)
xorl %edi, %edi
leaq 0x4a043(%rip), %rsi     # 0x59474
callq 0x1c5c1
movl %eax, 0xa4(%rsp)
movq %rdx, 0x138(%rsp)
movsd 0x194(%rsp), %xmm0
cvtdq2ps %xmm0, %xmm2
xorps %xmm1, %xmm1
movaps 0x90(%rsp), %xmm0
callq 0x2a643
testb %al, %al
je 0xf4be
movaps 0x90(%rsp), %xmm0
cvttss2si %xmm0, %esi
movq 0x178(%rsp), %r13
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
cvttss2si %xmm0, %edx
movq %r13, %rdi
callq 0x112ba
movq 0x120(%rsp), %rdx
movq 0x128(%rsp), %rsi
movq %rsi, %rdi
movq %rdx, %rcx
subq $0x1, %rcx
jb 0xf4dd
cmpq 0x30(%rdi), %rax
jb 0xf4b5
cmpq 0x38(%rdi), %rax
jb 0x101d7
addq $0xa0, %rdi
jmp 0xf49f
movq 0x128(%rsp), %rsi
movq 0x120(%rsp), %rdx
movl $0xff000000, %ebp       # imm = 0xFF000000
movq 0x178(%rsp), %r13
jmp 0xf4e2
movl $0xff000000, %ebp       # imm = 0xFF000000
xorl %r12d, %r12d
leaq 0x238(%rsp), %rdi
movq %r13, %rcx
callq 0x11332
movq 0xc0(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0xb0(%rsp), %xmm0
movups %xmm0, (%rsp)
xorps %xmm0, %xmm0
callq 0x238a1
cvtsi2ssl 0x118(%rsp), %xmm1
movaps %xmm0, 0x100(%rsp)
cvtsi2ssl 0xcc(%rsp), %xmm2
movq 0xc0(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0xb0(%rsp), %xmm0
movups %xmm0, (%rsp)
movaps %xmm2, 0x280(%rsp)
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movaps %xmm1, %xmm0
callq 0x238a1
subps 0x100(%rsp), %xmm0
movaps %xmm0, 0x90(%rsp)
callq 0x22103
pushq $-0x1
popq %rdi
callq 0x220d7
movq 0xc0(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0xb0(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x2262f
movl $0xffffff24, %edi       # imm = 0xFFFFFF24
xorl %esi, %esi
pushq $0x10
popq %r15
movl %r15d, %edx
movl %r15d, %ecx
movl $0xffc6e0b8, %r8d       # imm = 0xFFC6E0B8
callq 0x26d3a
movl 0x84(%rsp), %ebx
movl %ebx, %edi
movq 0xa8(%rsp), %r14
movq %r14, %rsi
callq 0x1cb3b
movups 0xd0(%rsp), %xmm0
movups 0xe0(%rsp), %xmm1
movups 0xf0(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
xorps %xmm2, %xmm2
leaq 0x49e86(%rip), %rdi     # 0x59482
movss 0x49a64(%rip), %xmm0    # 0x59068
movss 0x49a60(%rip), %xmm1    # 0x5906c
movl $0xff000000, %esi       # imm = 0xFF000000
callq 0x43de8
movups 0xd0(%rsp), %xmm0
movups 0xe0(%rsp), %xmm1
movups 0xf0(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
xorps %xmm2, %xmm2
leaq 0x49e53(%rip), %rdi     # 0x59499
movsd 0x49ba2(%rip), %xmm0    # 0x591f0
movss 0x49a16(%rip), %xmm1    # 0x5906c
movl $0xff000000, %esi       # imm = 0xFF000000
callq 0x43de8
callq 0x1cb6b
movl $0xffffff24, %edi       # imm = 0xFFFFFF24
pushq $0x22
popq %rsi
movl %r15d, %edx
movl %r15d, %ecx
movl $0xffe5e5e5, %r8d       # imm = 0xFFE5E5E5
callq 0x26d3a
movl %ebx, %edi
movq %r14, %rsi
callq 0x1cb3b
movups 0xd0(%rsp), %xmm0
movups 0xe0(%rsp), %xmm1
movups 0xf0(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
xorps %xmm2, %xmm2
leaq 0x49e01(%rip), %rdi     # 0x594b9
movsd 0x49b40(%rip), %xmm0    # 0x59200
movss 0x499a4(%rip), %xmm1    # 0x5906c
movl $0xff000000, %esi       # imm = 0xFF000000
callq 0x43de8
callq 0x1cb6b
movl $0xffffff24, %edi       # imm = 0xFFFFFF24
pushq $0x36
popq %rsi
movl %r15d, %edx
movl %r15d, %ecx
movl $0xfffafafa, %r8d       # imm = 0xFFFAFAFA
callq 0x26d3a
movl %ebx, %edi
movq %r14, %rsi
callq 0x1cb3b
movups 0xd0(%rsp), %xmm0
movups 0xe0(%rsp), %xmm1
movups 0xf0(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
xorps %xmm2, %xmm2
leaq 0x49da4(%rip), %rdi     # 0x594ce
movsd 0x49ade(%rip), %xmm0    # 0x59210
movss 0x49932(%rip), %xmm1    # 0x5906c
movl $0xff000000, %esi       # imm = 0xFF000000
callq 0x43de8
movups 0xd0(%rsp), %xmm0
movups 0xe0(%rsp), %xmm1
movups 0xf0(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
xorps %xmm2, %xmm2
leaq 0x49d6f(%rip), %rdi     # 0x594e3
movsd 0x49aa4(%rip), %xmm0    # 0x59220
movss 0x498e8(%rip), %xmm1    # 0x5906c
movl $0xff000000, %esi       # imm = 0xFF000000
callq 0x43de8
callq 0x1cb6b
movl $0xffffff24, %edi       # imm = 0xFFFFFF24
pushq $0x72
popq %rsi
movl %r15d, %edx
movl %r15d, %ecx
movl $0xffe5e5e5, %r8d       # imm = 0xFFE5E5E5
callq 0x26d3a
movl %ebx, %edi
movq %r14, %rsi
callq 0x1cb3b
movups 0xd0(%rsp), %xmm0
movups 0xe0(%rsp), %xmm1
movups 0xf0(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
xorps %xmm2, %xmm2
leaq 0x49d16(%rip), %rdi     # 0x594fc
movsd 0x49a42(%rip), %xmm0    # 0x59230
movss 0x49876(%rip), %xmm1    # 0x5906c
movl $0xff000000, %esi       # imm = 0xFF000000
callq 0x43de8
callq 0x1cb6b
movl $0xfffffef4, %edi       # imm = 0xFFFFFEF4
movl $0x86, %esi
pushq $0x40
popq %rcx
movl %ecx, %edx
movl $0xffe5e5e5, %r8d       # imm = 0xFFE5E5E5
callq 0x26d3a
movl %ebx, %edi
movq %r14, %rsi
callq 0x1cb3b
movups 0xd0(%rsp), %xmm0
movups 0xe0(%rsp), %xmm1
movups 0xf0(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
xorps %xmm2, %xmm2
leaq 0x49cb5(%rip), %rdi     # 0x5950e
movsd 0x499df(%rip), %xmm0    # 0x59240
movss 0x49803(%rip), %xmm1    # 0x5906c
movl $0xff000000, %esi       # imm = 0xFF000000
callq 0x43de8
callq 0x1cb6b
movl 0xa0(%rsp), %ebx
movl %ebx, %edi
movq 0x130(%rsp), %r14
movq %r14, %rsi
callq 0x1cb3b
movl %ebp, %edi
callq 0x3810f
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x298(%rsp)
movl %ebx, %edi
movq %r14, %rsi
movl 0x140(%rsp), %edx
leaq 0x298(%rsp), %rcx
pushq $0x3
popq %r8
callq 0x1cc1f
movl 0x1a0(%rsp), %eax
movl %eax, 0x10(%rsp)
movups 0x190(%rsp), %xmm0
movups %xmm0, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x36d00
callq 0x1cb6b
movaps 0x90(%rsp), %xmm3
testq %r12, %r12
movq %r12, 0x228(%rsp)
movaps %xmm3, %xmm0
je 0xf987
mulss 0x49765(%rip), %xmm0    # 0x59070
movss %xmm0, 0x80(%rsp)
ucomiss 0x6c(%r12), %xmm0
jbe 0xf998
movl 0x84(%rsp), %ebp
movl %ebp, %edi
movq 0xa8(%rsp), %rsi
callq 0x1cb3b
movq 0x58(%r12), %rdi
movsd 0x64(%r12), %xmm0
movss 0x60(%r12), %xmm1
movups 0xd0(%rsp), %xmm2
movups 0xe0(%rsp), %xmm3
movups 0xf0(%rsp), %xmm4
movups %xmm4, 0x20(%rsp)
movups %xmm3, 0x10(%rsp)
movups %xmm2, (%rsp)
xorps %xmm2, %xmm2
movl $0xff000000, %esi       # imm = 0xFF000000
callq 0x43de8
callq 0x1cb6b
movaps 0x90(%rsp), %xmm3
jmp 0xf99f
mulss 0x496e1(%rip), %xmm0    # 0x59070
movss %xmm0, 0x80(%rsp)
movl 0x84(%rsp), %ebp
movaps %xmm3, %xmm0
mulss 0x496ca(%rip), %xmm0    # 0x59074
movss %xmm0, 0x144(%rsp)
xorl %ebx, %ebx
cmpq 0x120(%rsp), %rbx
jae 0xfb9d
movq 0x128(%rsp), %r14
imulq $0xa0, %rbx, %r15
movsd 0x44(%r14,%r15), %xmm0
movsd 0x4c(%r14,%r15), %xmm1
movaps 0x100(%rsp), %xmm2
callq 0x2a74b
testb %al, %al
je 0xfb8d
addq %r15, %r14
movss 0x4c(%r14), %xmm0
movss 0x80(%rsp), %xmm1
ucomiss %xmm0, %xmm1
jbe 0xfa69
movl %ebp, %edi
movq 0xa8(%rsp), %rsi
callq 0x1cb3b
movq 0x58(%r14), %rdi
movsd 0x64(%r14), %xmm0
movss 0x60(%r14), %xmm1
movups 0xd0(%rsp), %xmm2
movups 0xe0(%rsp), %xmm3
movups 0xf0(%rsp), %xmm4
movups %xmm4, 0x20(%rsp)
movups %xmm3, 0x10(%rsp)
movups %xmm2, (%rsp)
xorps %xmm2, %xmm2
movl $0x80000000, %esi       # imm = 0x80000000
callq 0x43de8
callq 0x1cb6b
movss 0x4c(%r14), %xmm0
ucomiss 0x144(%rsp), %xmm0
jbe 0xfb8d
movl 0xa4(%rsp), %edi
movq 0x138(%rsp), %rsi
callq 0x1cb3b
movsd 0x7c(%r14), %xmm0
cvtdq2ps %xmm0, %xmm1
movsd 0x44(%r14), %xmm2
movsd 0x4c(%r14), %xmm3
movl 0x88(%r14), %eax
movl %eax, 0x10(%rsp)
movups 0x78(%r14), %xmm0
movups %xmm0, (%rsp)
xorps %xmm0, %xmm0
xorps %xmm4, %xmm4
xorps %xmm5, %xmm5
movl $0x20000000, %edi       # imm = 0x20000000
callq 0x36d55
callq 0x1cb6b
movl %ebp, %edi
movq 0xa8(%rsp), %rsi
callq 0x1cb3b
pushq $0x18
popq %r15
xorl %r12d, %r12d
movaps 0x90(%rsp), %xmm3
cmpq 0x90(%r14), %r12
jae 0xfb88
movq 0x98(%r14), %r13
movsd -0xc(%r13,%r15), %xmm0
movsd -0x4(%r13,%r15), %xmm1
movaps 0x100(%rsp), %xmm2
callq 0x2a74b
testb %al, %al
je 0xfb7c
movss (%r13,%r15), %xmm0
mulss 0xc4(%rsp), %xmm0
ucomiss 0x494f8(%rip), %xmm0    # 0x5902c
jbe 0xfb7c
movq -0x18(%r13,%r15), %rdi
movsd -0xc(%r13,%r15), %xmm0
movss -0x10(%r13,%r15), %xmm1
movups 0xd0(%rsp), %xmm2
movups 0xe0(%rsp), %xmm3
movups 0xf0(%rsp), %xmm4
movups %xmm4, 0x20(%rsp)
movups %xmm3, 0x10(%rsp)
movups %xmm2, (%rsp)
xorps %xmm2, %xmm2
movl $0x80000000, %esi       # imm = 0x80000000
callq 0x43de8
incq %r12
addq $0x20, %r15
jmp 0xfae2
callq 0x1cb6b
incq %rbx
movaps 0x90(%rsp), %xmm3
jmp 0xf9b5
callq 0x1a0ce
movl 0x250(%rsp), %edi
movl %edi, 0x90(%rsp)
leaq 0x8d019(%rip), %rax     # 0x9cbd0
callq *(%rax)
leaq 0x2e8(%rsp), %rdi
callq 0x1cdd0
leaq 0x2a8(%rsp), %rdi
callq 0x1cd70
movups 0x2a8(%rsp), %xmm0
movups 0x2b8(%rsp), %xmm1
movups 0x2c8(%rsp), %xmm2
movups 0x2d8(%rsp), %xmm3
movups %xmm3, 0x70(%rsp)
movups %xmm2, 0x60(%rsp)
movups %xmm1, 0x50(%rsp)
movups %xmm0, 0x40(%rsp)
movups 0x2e8(%rsp), %xmm0
movups 0x2f8(%rsp), %xmm1
movups 0x308(%rsp), %xmm2
movups 0x318(%rsp), %xmm3
movups %xmm3, 0x30(%rsp)
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x1a8(%rsp), %rdi
callq 0x12c07
leaq 0x8d132(%rip), %rax     # 0x9cd80
movq (%rax), %rax
movq 0x258(%rsp), %rcx
movq %rcx, 0x100(%rsp)
movl 0x18(%rcx), %edi
movss 0x1a8(%rsp), %xmm0
movss 0x1ac(%rsp), %xmm1
movss 0x1b0(%rsp), %xmm2
movss 0x1b4(%rsp), %xmm3
movss 0x1b8(%rsp), %xmm4
movss 0x1bc(%rsp), %xmm5
movss 0x1c0(%rsp), %xmm6
movss 0x1c4(%rsp), %xmm7
movss 0x1c8(%rsp), %xmm8
movss 0x1cc(%rsp), %xmm9
movss 0x1d0(%rsp), %xmm10
movss 0x1d4(%rsp), %xmm11
movss 0x1d8(%rsp), %xmm12
movss 0x1dc(%rsp), %xmm13
movss 0x1e0(%rsp), %xmm14
movss 0x1e4(%rsp), %xmm15
movss %xmm0, 0x1e8(%rsp)
movss %xmm4, 0x1ec(%rsp)
movss %xmm8, 0x1f0(%rsp)
movss %xmm12, 0x1f4(%rsp)
movss %xmm1, 0x1f8(%rsp)
movss %xmm5, 0x1fc(%rsp)
movss %xmm9, 0x200(%rsp)
movss %xmm13, 0x204(%rsp)
movss %xmm2, 0x208(%rsp)
movss %xmm6, 0x20c(%rsp)
movss %xmm10, 0x210(%rsp)
movss %xmm14, 0x214(%rsp)
movss %xmm3, 0x218(%rsp)
movss %xmm7, 0x21c(%rsp)
movss %xmm11, 0x220(%rsp)
movss %xmm15, 0x224(%rsp)
pushq $0x1
popq %rsi
xorl %edx, %edx
leaq 0x1e8(%rsp), %rcx
callq *%rax
movl 0x264(%rsp), %edi
movl 0x268(%rsp), %esi
leaq 0x90b30(%rip), %rax     # 0xa08e8
callq *(%rax)
movq 0x238(%rsp), %rbx
movq 0x240(%rsp), %r12
movq 0x248(%rsp), %r14
movl 0x260(%rsp), %eax
movl %eax, 0x80(%rsp)
leaq 0x14(%rbx), %rbp
xorl %r13d, %r13d
cmpq %r13, %r12
je 0xfe7c
cmpq $-0x1, %r14
setne %al
cmpq %r13, %r14
setne %cl
testb %cl, %al
jne 0xfe70
movzbl -0x2(%rbp), %eax
shll $0x10, %eax
movzwl -0x4(%rbp), %ecx
leal (%rcx,%rax), %edi
addl $0x40000000, %edi       # imm = 0x40000000
callq 0x3810f
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x180(%rsp)
movl 0x90(%rsp), %edi
movq 0x100(%rsp), %rsi
movl 0x80(%rsp), %edx
leaq 0x180(%rsp), %rcx
pushq $0x3
popq %r8
callq 0x1cc1f
movl (%rbp), %edi
leaq 0x8ceca(%rip), %r15     # 0x9cd20
callq *(%r15)
xorl %edi, %edi
xorl %esi, %esi
movl $0x7d0, %edx            # imm = 0x7D0
leaq 0x8cf27(%rip), %rax     # 0x9cd90
callq *(%rax)
xorl %edi, %edi
callq *(%r15)
incq %r13
addq $0x20, %rbp
jmp 0xfde7
xorl %edi, %edi
leaq 0x8cd4b(%rip), %rax     # 0x9cbd0
callq *(%rax)
callq 0x22add
xorl %edi, %edi
xorl %esi, %esi
movq 0x118(%rsp), %rdx
pushq $0x14
popq %rcx
movl $0xfff5f5f5, %r8d       # imm = 0xFFF5F5F5
callq 0x26d3a
movq 0x228(%rsp), %r15
testq %r15, %r15
leaq 0x4969e(%rip), %r13     # 0x59556
je 0x1002f
andq $0x0, 0x180(%rsp)
movq 0x8(%r15), %rdi
subq (%r15), %rdi
leaq 0x180(%rsp), %rsi
callq 0x1152e
movq 0x180(%rsp), %rsi
leaq 0x49637(%rip), %rdi     # 0x59521
movb $0x1, %al
callq 0x43d0d
cvtsi2ssl 0x148(%rsp), %xmm1
movups 0x148(%rsp), %xmm0
movups 0x158(%rsp), %xmm2
movups 0x168(%rsp), %xmm3
movups %xmm3, 0x20(%rsp)
movups %xmm2, 0x10(%rsp)
movups %xmm0, (%rsp)
xorps %xmm2, %xmm2
movq %rax, %rdi
movsd 0x49322(%rip), %xmm0    # 0x59250
movl $0xff000000, %esi       # imm = 0xFF000000
callq 0x43de8
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x495ea(%rip), %rdi     # 0x59530
xorl %eax, %eax
callq 0x43d0d
cvtsi2ssl 0x148(%rsp), %xmm1
movups 0x148(%rsp), %xmm0
movups 0x158(%rsp), %xmm2
movups 0x168(%rsp), %xmm3
movups %xmm3, 0x20(%rsp)
movups %xmm2, 0x10(%rsp)
movups %xmm0, (%rsp)
xorps %xmm2, %xmm2
movq %rax, %rdi
movsd 0x492d6(%rip), %xmm0    # 0x59260
movl $0xff000000, %esi       # imm = 0xFF000000
callq 0x43de8
cmpb $0x0, 0x10(%r15)
jne 0x1002f
movq 0x18(%r15), %rdi
cvtsi2ssl 0x148(%rsp), %xmm1
movups 0x148(%rsp), %xmm0
movups 0x158(%rsp), %xmm2
movups 0x168(%rsp), %xmm3
movups %xmm3, 0x20(%rsp)
movups %xmm2, 0x10(%rsp)
movups %xmm0, (%rsp)
xorps %xmm2, %xmm2
movsd 0x49293(%rip), %xmm0    # 0x59270
movl $0xff000000, %esi       # imm = 0xFF000000
callq 0x43de8
movq 0x20(%r15), %rdi
cvtsi2ssl 0x148(%rsp), %xmm1
movups 0x148(%rsp), %xmm0
movups 0x158(%rsp), %xmm2
movups 0x168(%rsp), %xmm3
movups %xmm3, 0x20(%rsp)
movups %xmm2, 0x10(%rsp)
movups %xmm0, (%rsp)
xorps %xmm2, %xmm2
movsd 0x4925b(%rip), %xmm0    # 0x59280
movl $0xff000000, %esi       # imm = 0xFF000000
callq 0x43de8
andl $0x0, 0x8b24a(%rip)     # 0x9b280
movq 0x118(%rsp), %rax
addl $0xffffff38, %eax       # imm = 0xFFFFFF38
cvtsi2ss %eax, %xmm0
movaps %xmm0, 0x100(%rsp)
movaps 0x4923a(%rip), %xmm0    # 0x59290
cvtsi2ss %eax, %xmm0
movaps 0x4923f(%rip), %xmm1    # 0x592a0
unpcklps 0x280(%rsp), %xmm1      # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
callq 0x7165
movss 0x49002(%rip), %xmm1    # 0x59078
movaps 0x100(%rsp), %xmm2
addss %xmm1, %xmm2
movaps %xmm2, %xmm0
addss 0x48fef(%rip), %xmm0    # 0x5907c
cvttss2si %xmm0, %ebp
addss 0x48f77(%rip), %xmm2    # 0x59010
movaps %xmm2, 0x100(%rsp)
testq %r12, %r12
movl $0x0, %eax
cmovleq %rax, %r12
xorl %r15d, %r15d
cmpq %r15, %r12
je 0x101c5
cmpq $-0x1, %r14
setne %al
cmpq %r14, %r15
setne %cl
movaps %xmm1, %xmm2
addss 0x48f53(%rip), %xmm2    # 0x59024
movaps %xmm2, %xmm0
addss 0x48fa4(%rip), %xmm0    # 0x59080
testb %cl, %al
movss %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
jne 0x100fd
andl $0x0, 0x8b188(%rip)     # 0x9b280
movl 0x10(%rbx), %edx
jmp 0x1010c
movl $0x3, 0x8b179(%rip)     # 0x9b280
movl $0xffc8c8c8, %edx       # imm = 0xFFC8C8C8
cvttss2si %xmm0, %esi
movl %ebp, %edi
movss 0x48f62(%rip), %xmm0    # 0x5907c
callq 0x2537a
cmpb $0x0, 0x1c(%rbx)
movl (%rbx), %esi
leaq 0x51e28(%rip), %rdx     # 0x61f54
cmovneq %r13, %rdx
leaq 0x49415(%rip), %rdi     # 0x5954c
xorl %eax, %eax
callq 0x43d0d
movaps 0x90(%rsp), %xmm0
movaps 0x100(%rsp), %xmm1
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
shufps $0xe2, %xmm1, %xmm0     # xmm0 = xmm0[2,0],xmm1[2,3]
movsd 0x49153(%rip), %xmm1    # 0x592b0
movq %rax, %rdi
callq 0x8fef
cmpq %r14, %r15
movq %r15, %rcx
pushq $-0x1
popq %rdx
cmoveq %rdx, %rcx
testb %al, %al
cmovneq %rcx, %r14
movaps 0x90(%rsp), %xmm0
addss 0x48efc(%rip), %xmm0    # 0x59084
movq 0x8(%rbx), %rdi
movaps 0x100(%rsp), %xmm1
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
shufps $0xe2, %xmm1, %xmm0     # xmm0 = xmm0[2,0],xmm1[2,3]
movsd 0x4910d(%rip), %xmm1    # 0x592b0
callq 0x7768
movss 0x80(%rsp), %xmm1
addss 0x48ecf(%rip), %xmm1    # 0x59088
incq %r15
addq $0x20, %rbx
jmp 0x100b0
movq %r14, 0x248(%rsp)
callq 0x22228
jmp 0xf25b
movq %rdi, %r12
movl 0x40(%rdi), %ebp
jmp 0xf4e5
leaq 0x238(%rsp), %rdi
callq 0x115ca
movl 0xa0(%rsp), %edi
movq 0x130(%rsp), %rsi
callq 0x1cb01
movl 0x1a0(%rsp), %eax
movl %eax, 0x10(%rsp)
movups 0x190(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x36a85
leaq 0x128(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0x11681
movl 0x84(%rsp), %edi
movq 0xa8(%rsp), %rsi
callq 0x1cb01
movups 0xd0(%rsp), %xmm0
movups 0xe0(%rsp), %xmm1
movups 0xf0(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x43c17
movl 0xa4(%rsp), %edi
movq 0x138(%rsp), %rsi
callq 0x1cb01
movups 0x148(%rsp), %xmm0
movups 0x158(%rsp), %xmm1
movups 0x168(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x43c17
callq 0x2158f
movq 0x230(%rsp), %rdi
callq 0x62f0
xorl %eax, %eax
addq $0x328, %rsp            # imm = 0x328
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x89d11(%rip), %rax     # 0x99ff0
movq (%rax), %rdi
movq (%r15), %rdx
leaq 0x490f4(%rip), %rsi     # 0x593e0
jmp 0x10303
movq 0x89cfb(%rip), %rax     # 0x99ff0
movq (%rax), %rdi
movq 0x8(%r15), %rdx
leaq 0x490fd(%rip), %rsi     # 0x59400
xorl %eax, %eax
callq 0x6760
jmp 0x102c4