LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: initsystem
int initsystem(void)
{
	SDL_version linked;
	SDL_version compiled;

	SDL_GetVersion(&linked);
	SDL_VERSION(&compiled);

	buildprintf("SDL2 system interface "
		  "(compiled with SDL version %d.%d.%d, runtime version %d.%d.%d)\n",
		linked.major, linked.minor, linked.patch,
		compiled.major, compiled.minor, compiled.patch);

	atexit(uninitsystem);

#if USE_OPENGL
	if (getenv("BUILD_NOGL")) {
		buildputs("OpenGL disabled.\n");
		glunavailable = 1;
	} else {
		glunavailable = loadgldriver(getenv("BUILD_GLDRV"));
		if (glunavailable) {
			buildputs("Failed loading OpenGL driver. GL modes will be unavailable.\n");
		}
	}

	OSD_RegisterFunction("glswapinterval", "glswapinterval: frame swap interval for OpenGL modes. 0 = no vsync, -1 = adaptive, max 2", set_glswapinterval);
#endif
	if (getenv("BUILD_USESDLRENDERER")) {
		buildputs("Will use SDL renderer if OpenGL is not available.\n");
		usesdlrenderer = 1;
	}

	return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xd(%rsp), %rbx
movq %rbx, %rdi
callq 0x6680
movzbl (%rbx), %esi
movzbl 0x1(%rbx), %edx
movzbl 0x2(%rbx), %ecx
movl $0x14, (%rsp)
leaq 0x10a31(%rip), %rdi     # 0x7e764
movl $0x2, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x25221
leaq 0xcc(%rip), %rdi        # 0x6de16
callq 0x72d50
leaq 0x10a64(%rip), %rdi     # 0x7e7ba
callq 0x67f0
testq %rax, %rax
je 0x6dd7b
leaq 0x10a5e(%rip), %rdi     # 0x7e7c5
callq 0x32d18
leaq 0x110375(%rip), %rax    # 0x17e0e8
movl $0x1, (%rax)
jmp 0x6ddd0
leaq 0x10a55(%rip), %rdi     # 0x7e7d7
callq 0x67f0
movq %rax, %rbx
testq %rax, %rax
leaq 0x10d7c(%rip), %rsi     # 0x7eb10
cmovneq %rax, %rsi
leaq 0x10d87(%rip), %rdi     # 0x7eb26
xorl %eax, %eax
callq 0x25221
movq %rbx, %rdi
callq 0x67b0
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
negl %ecx
leaq 0x11032a(%rip), %rdx    # 0x17e0e8
movl %ecx, (%rdx)
testl %eax, %eax
je 0x6ddd0
leaq 0x10a18(%rip), %rdi     # 0x7e7e3
callq 0x32d18
leaq 0x10a49(%rip), %rdi     # 0x7e820
leaq 0x10a51(%rip), %rsi     # 0x7e82f
leaq 0xa3(%rip), %rdx        # 0x6de88
callq 0x4b4d8
leaq 0x10a97(%rip), %rdi     # 0x7e888
callq 0x67f0
testq %rax, %rax
je 0x6de0e
leaq 0x10a9b(%rip), %rdi     # 0x7e89d
callq 0x32d18
movb $0x1, 0x65f5c2(%rip)    # 0x6cd3d0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: uninitsystem
void uninitsystem(void)
{
	uninitinput();
	uninitmouse();
	uninittimer();

	shutdownvideo();
#if USE_OPENGL
	glbuild_unloadfunctions();
	unloadgldriver();
#endif
}

// Assembly:
pushq %rax
callq 0x6df1b
xorl %edi, %edi
callq 0x6e2a9
movb $0x0, 0x65f49f(%rip)    # 0x6cd2c9
cmpq $0x0, 0x6611b6(%rip)    # 0x6cefe8
je 0x6de3f
movq $0x0, 0x6611a9(%rip) # 0x6cefe8
callq 0x6df6f
callq 0x4f363
popq %rax
jmp 0x69c0
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: loadgldriver
int loadgldriver(const char *soname)
{
	const char *name = soname;
	if (!name) {
		name = "system OpenGL library";
	}

	buildprintf("Loading %s\n", name);
	if (SDL_GL_LoadLibrary(soname)) return -1;
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
leaq 0x10cb1(%rip), %rsi     # 0x7eb10
cmovneq %rdi, %rsi
leaq 0x10cbc(%rip), %rdi     # 0x7eb26
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x25221
movq %rbx, %rdi
callq 0x67b0
negl %eax
sbbl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: set_glswapinterval
static int set_glswapinterval(const osdfuncparm_t *parm)
{
	int interval;

	if (glunavailable) {
		buildputs("glswapinterval is not adjustable\n");
		return OSDCMD_OK;
	}
	if (parm->numparms == 0) {
		buildprintf("glswapinterval is %d\n", glswapinterval);
		return OSDCMD_OK;
	}
	if (parm->numparms != 1) return OSDCMD_SHOWHELP;

	interval = atoi(parm->parms[0]);
	if (interval < -1 || interval > 2) return OSDCMD_SHOWHELP;

	if (SDL_GL_SetSwapInterval(interval) < 0) {
		buildprintf("error: could not change swap interval: %s\n", SDL_GetError());
	} else {
		glswapinterval = SDL_GL_GetSwapInterval();
	}
	return OSDCMD_OK;
}

// Assembly:
pushq %rbx
leaq 0x110258(%rip), %rax    # 0x17e0e8
cmpl $0x0, (%rax)
je 0x6dea7
leaq 0x10c96(%rip), %rdi     # 0x7eb32
callq 0x32d18
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
movl (%rdi), %eax
movl $0x1, %ebx
cmpl $0x1, %eax
je 0x6ded2
testl %eax, %eax
jne 0x6dea3
leaq 0x3616a(%rip), %rax     # 0xa4028
movl (%rax), %esi
leaq 0x10c8d(%rip), %rdi     # 0x7eb54
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x25221
jmp 0x6dea3
movq 0x10(%rdi), %rax
movq (%rax), %rdi
callq 0x6310
leal -0x3(%rax), %ecx
cmpl $-0x4, %ecx
jb 0x6dea3
movl %eax, %edi
callq 0x6580
testl %eax, %eax
js 0x6df01
callq 0x6600
leaq 0x3612b(%rip), %rcx     # 0xa4028
movl %eax, (%rcx)
jmp 0x6dea1
callq 0x6b40
leaq 0x10c5d(%rip), %rdi     # 0x7eb6a
xorl %ebx, %ebx
movq %rax, %rsi
xorl %eax, %eax
callq 0x25221
jmp 0x6dea3
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: uninitinput
void uninitinput(void)
{
	uninitmouse();

	if (controller) {
		SDL_GameControllerClose(controller);
		controller = NULL;
	}
}

// Assembly:
pushq %rax
xorl %edi, %edi
callq 0x6e2a9
movb $0x0, 0x65f39f(%rip)    # 0x6cd2c9
movq 0x6610af(%rip), %rdi    # 0x6cefe0
testq %rdi, %rdi
je 0x6df46
callq 0x6360
movq $0x0, 0x66109a(%rip) # 0x6cefe0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: shutdownvideo
static void shutdownvideo(void)
{
	if (frame) {
		free(frame);
		frame = NULL;
	}
#if USE_OPENGL
	if (!glunavailable) {
		glbuild_delete_8bit_shader(&gl8bit);
	}
	if (sdl_glcontext) {
#if USE_POLYMOST
		polymost_glreset();
#endif

		SDL_GL_DeleteContext(sdl_glcontext);
		sdl_glcontext = NULL;
	}
#endif
	if (sdl_texture) {
		SDL_DestroyTexture(sdl_texture);
		sdl_texture = NULL;
	}
	if (sdl_renderer) {
		SDL_DestroyRenderer(sdl_renderer);
		sdl_renderer = NULL;
	}
	if (sdl_surface) {
		SDL_FreeSurface(sdl_surface);
		sdl_surface = NULL;
	}
	if (sdl_window) {
		SDL_DestroyWindow(sdl_window);
		sdl_window = NULL;
	}
}

// Assembly:
pushq %rax
movq 0x6610f1(%rip), %rdi    # 0x6cf068
testq %rdi, %rdi
je 0x6df8c
callq 0x61c0
movq $0x0, 0x6610dc(%rip) # 0x6cf068
leaq 0x110155(%rip), %rax    # 0x17e0e8
cmpl $0x0, (%rax)
jne 0x6dfa4
leaq 0x661089(%rip), %rdi    # 0x6cf028
callq 0x4fc12
cmpq $0x0, 0x661074(%rip)    # 0x6cf020
je 0x6dfca
callq 0x50163
movq 0x661066(%rip), %rdi    # 0x6cf020
callq 0x60d0
movq $0x0, 0x661056(%rip) # 0x6cf020
movq 0x66103f(%rip), %rdi    # 0x6cf010
testq %rdi, %rdi
je 0x6dfe6
callq 0x67d0
movq $0x0, 0x66102a(%rip) # 0x6cf010
movq 0x66101b(%rip), %rdi    # 0x6cf008
testq %rdi, %rdi
je 0x6e002
callq 0x6620
movq $0x0, 0x661006(%rip) # 0x6cf008
movq 0x66100f(%rip), %rdi    # 0x6cf018
testq %rdi, %rdi
je 0x6e01e
callq 0x6350
movq $0x0, 0x660ffa(%rip) # 0x6cf018
movq 0x65f29b(%rip), %rdi    # 0x6cd2c0
testq %rdi, %rdi
je 0x6e03a
callq 0x65f0
movq $0x0, 0x65f286(%rip) # 0x6cd2c0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: grabmouse
void grabmouse(int a)
{
	if (appactive && moustat) {
		if (a != mouseacquired) {
			SDL_SetRelativeMouseMode(a ? SDL_TRUE : SDL_FALSE);
			mouseacquired = a;
		}
	} else {
		mouseacquired = a;
	}
	mousex = mousey = 0;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
leaq 0x35d79(%rip), %rax     # 0xa402c
cmpb $0x0, (%rax)
je 0x6e2d9
testb $0x1, 0x65f00a(%rip)    # 0x6cd2c9
je 0x6e2d9
movsbl 0x65f000(%rip), %eax    # 0x6cd2c8
cmpl %ebx, %eax
je 0x6e2df
xorl %edi, %edi
testl %ebx, %ebx
setne %dil
callq 0x6540
movb %bl, 0x65efe9(%rip)     # 0x6cd2c8
leaq 0x10fdf2(%rip), %rax    # 0x17e0d8
xorl %ecx, %ecx
movl %ecx, (%rax)
leaq 0x10fde3(%rip), %rax    # 0x17e0d4
movl %ecx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: readmousexy
void readmousexy(int *x, int *y)
{
	if (!mouseacquired || !appactive || !moustat) { *x = *y = 0; return; }
	*x = mousex;
	*y = mousey;
	mousex = mousey = 0;
}

// Assembly:
cmpb $0x0, 0x65efcc(%rip)    # 0x6cd2c8
je 0x6e32f
leaq 0x35d27(%rip), %rax     # 0xa402c
cmpb $0x0, (%rax)
je 0x6e32f
testb $0x1, 0x65efb8(%rip)    # 0x6cd2c9
je 0x6e32f
leaq 0x10fdba(%rip), %rax    # 0x17e0d4
movl (%rax), %ecx
movl %ecx, (%rdi)
leaq 0x10fdb3(%rip), %rcx    # 0x17e0d8
movl (%rcx), %edx
movl %edx, (%rsi)
movq %rcx, %rsi
movq %rax, %rdi
xorl %eax, %eax
movl %eax, (%rsi)
movl %eax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: inittimer
int inittimer(int tickspersecond, void(*callback)(void))
{
	if (timerfreq) return 0;    // already installed

	buildputs("Initialising timer\n");

	timerfreq = SDL_GetPerformanceFrequency();
	timerticspersec = tickspersecond;
	timerlastsample = (Uint32)(SDL_GetPerformanceCounter() * timerticspersec / timerfreq);

	usertimercallback = callback;

	return 0;
}

// Assembly:
cmpq $0x0, 0x660c70(%rip)    # 0x6cefe8
jne 0x6e3cb
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x105e5(%rip), %rdi     # 0x7e96e
callq 0x32d18
callq 0x6c30
movq %rax, 0x660c4e(%rip)    # 0x6cefe8
movl %ebp, 0x660c50(%rip)    # 0x6ceff0
callq 0x62a0
movl 0x660c45(%rip), %ecx    # 0x6ceff0
imulq %rcx, %rax
xorl %edx, %edx
divq 0x660c30(%rip)          # 0x6cefe8
movl %eax, 0x660c36(%rip)    # 0x6ceff4
movq %rbx, 0x660c33(%rip)    # 0x6ceff8
addq $0x8, %rsp
popq %rbx
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: sampletimer
void sampletimer(void)
{
	int n;

	if (!timerfreq) return;

	n = (int)(SDL_GetPerformanceCounter() * timerticspersec / timerfreq) - timerlastsample;
	if (n>0) {
		totalclock += n;
		timerlastsample += n;
	}

	if (usertimercallback) for (; n>0; n--) usertimercallback();
}

// Assembly:
cmpq $0x0, 0x660c12(%rip)    # 0x6cefe8
je 0x6e427
pushq %rbx
callq 0x62a0
movl 0x660c0c(%rip), %ecx    # 0x6ceff0
imulq %rcx, %rax
xorl %edx, %edx
divq 0x660bf7(%rip)          # 0x6cefe8
movl %eax, %ebx
subl 0x660bfb(%rip), %ebx    # 0x6ceff4
testl %ebx, %ebx
jle 0x6e426
leaq 0x33e0e4(%rip), %rcx    # 0x3ac4e8
addl %ebx, (%rcx)
movl %eax, 0x660be8(%rip)    # 0x6ceff4
cmpq $0x0, 0x660be4(%rip)    # 0x6ceff8
je 0x6e426
callq *0x660bdc(%rip)         # 0x6ceff8
leal -0x1(%rbx), %eax
cmpl $0x1, %ebx
movl %eax, %ebx
ja 0x6e416
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: sortmodes
static int sortmodes(const struct validmode_t *a, const struct validmode_t *b)
{
	int x;

	if ((x = a->fs   - b->fs)   != 0) return x;
	if ((x = a->bpp  - b->bpp)  != 0) return x;
	if ((x = a->xdim - b->xdim) != 0) return x;
	if ((x = a->ydim - b->ydim) != 0) return x;

	return 0;
}

// Assembly:
movzbl 0x9(%rdi), %eax
movzbl 0x9(%rsi), %ecx
subl %ecx, %eax
je 0x6e7fe
retq
movzbl 0x8(%rdi), %eax
movzbl 0x8(%rsi), %ecx
subl %ecx, %eax
jne 0x6e7fd
movl (%rdi), %eax
subl (%rsi), %eax
jne 0x6e7fd
movl 0x4(%rdi), %eax
subl 0x4(%rsi), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: setsysgamma
int setsysgamma(float shadergamma, float sysgamma)
{
	int r = 0;
#if USE_OPENGL
	if (!glunavailable && bpp == 8) glbuild_set_8bit_gamma(&gl8bit, shadergamma);
#endif
	if (sdl_window) {
		if (sysgamma < 0.f) r = SDL_SetWindowBrightness(sdl_window, 1.0);
		else r = SDL_SetWindowBrightness(sdl_window, sysgamma);
	}
	if (r == 0) { curshadergamma = shadergamma; cursysgamma = sysgamma; }
	return r;
}

// Assembly:
subq $0x18, %rsp
leaq 0x10ee20(%rip), %rax    # 0x17e0e8
cmpl $0x0, (%rax)
jne 0x6f2ed
leaq 0x10edd0(%rip), %rax    # 0x17e0a4
cmpl $0x8, (%rax)
jne 0x6f2ed
leaq 0x65fd48(%rip), %rdi    # 0x6cf028
movaps %xmm1, (%rsp)
callq 0x4fd24
movaps (%rsp), %xmm1
movq 0x65dfcc(%rip), %rdi    # 0x6cd2c0
testq %rdi, %rdi
je 0x6f31e
xorps %xmm2, %xmm2
movaps %xmm1, %xmm0
cmpltss %xmm2, %xmm0
movss 0x7e08(%rip), %xmm2     # 0x77114
andps %xmm0, %xmm2
andnps %xmm1, %xmm0
orps %xmm2, %xmm0
addq $0x18, %rsp
jmp 0x6150
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/gtkbits.c
// Function: wmgtk_msgbox
int wmgtk_msgbox(char *name, char *msg)
{
	GtkWidget *dialog;

	if (!gtkenabled) return -1;

	dialog = gtk_message_dialog_new(NULL,
			GTK_DIALOG_DESTROY_WITH_PARENT,
			GTK_MESSAGE_INFO,
			GTK_BUTTONS_OK,
			"%s", msg);
	gtk_window_set_title(GTK_WINDOW(dialog), name);
	gtk_dialog_run(GTK_DIALOG(dialog));
	gtk_widget_destroy(dialog);

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x0, 0x65f922(%rip)    # 0x6cf074
je 0x6f7bb
movq %rsi, %r9
movq %rdi, %r14
leaq 0x5483(%rip), %r8       # 0x74be4
movl $0x1, %ebx
xorl %edi, %edi
movl $0x2, %esi
xorl %edx, %edx
movl $0x1, %ecx
xorl %eax, %eax
callq 0x6980
movq %rax, %r15
callq 0x6c40
movq %r15, %rdi
movq %rax, %rsi
callq 0x6140
movq %rax, %rdi
movq %r14, %rsi
callq 0x6210
callq 0x66c0
movq %r15, %rdi
movq %rax, %rsi
callq 0x6140
movq %rax, %rdi
callq 0x6270
movq %r15, %rdi
callq 0x6180
jmp 0x6f7c0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/gtkbits.c
// Function: wmgtk_ynbox
int wmgtk_ynbox(char *name, char *msg)
{
	int r;
	GtkWidget *dialog;

	if (!gtkenabled) return -1;

	dialog = gtk_message_dialog_new(NULL,
			GTK_DIALOG_DESTROY_WITH_PARENT,
			GTK_MESSAGE_INFO,
			GTK_BUTTONS_YES_NO,
			"%s", msg);
	gtk_window_set_title(GTK_WINDOW(dialog), name);
	r = gtk_dialog_run(GTK_DIALOG(dialog));
	gtk_widget_destroy(dialog);

	if (r == GTK_RESPONSE_YES) return 1;

	return 0;
}

// Assembly:
cmpl $0x0, 0x65f8a5(%rip)    # 0x6cf074
je 0x6f844
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r9
movq %rdi, %r14
leaq 0x5402(%rip), %r8       # 0x74be4
xorl %edi, %edi
movl $0x2, %esi
xorl %edx, %edx
movl $0x4, %ecx
xorl %eax, %eax
callq 0x6980
movq %rax, %rbx
callq 0x6c40
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6140
movq %rax, %rdi
movq %r14, %rsi
callq 0x6210
callq 0x66c0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6140
movq %rax, %rdi
callq 0x6270
movl %eax, %ebp
movq %rbx, %rdi
callq 0x6180
xorl %eax, %eax
cmpl $-0x8, %ebp
sete %al
popq %rbx
popq %r14
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/gtkbits.c
// Function: wmgtk_filechooser
int wmgtk_filechooser(const char *initialdir, const char *initialfile, const char *type, int foropen, char **choice)
{
	GtkWidget *dialog;
	GtkFileChooserAction action;
	const char *title;
	gint r;

	GtkFileFilter *filter;
	char typepat[20];

	(void)initialdir;

	*choice = NULL;
	if (!gtkenabled) return -1;

	if (foropen) {
		action = GTK_FILE_CHOOSER_ACTION_OPEN;
		title = "_Open";
	} else {
		action = GTK_FILE_CHOOSER_ACTION_SAVE;
		title = "_Save";
	}
	dialog = gtk_file_chooser_dialog_new(title + 1, NULL, action,
		"_Cancel", GTK_RESPONSE_CANCEL,
		title, GTK_RESPONSE_ACCEPT,
		NULL);

	if (!foropen && initialfile) {
		gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), initialfile);
	}

	filter = gtk_file_filter_new();
	sprintf(typepat, "*.%s", type);
	gtk_file_filter_add_pattern(filter, typepat);
	gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);

	r = gtk_dialog_run(GTK_DIALOG(dialog));
	if (r == GTK_RESPONSE_ACCEPT) {
		GtkFileChooser *chooser = GTK_FILE_CHOOSER(dialog);
		char *fn = gtk_file_chooser_get_filename(chooser);
		if (fn) {
			*choice = strdup(fn);
			g_free(fn);
		}
	}
	gtk_widget_destroy(dialog);

	return r == GTK_RESPONSE_ACCEPT ? 1 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq $0x0, (%r8)
cmpl $0x0, 0x65f80e(%rip)    # 0x6cf074
je 0x6f992
movq %r8, %rbx
movq %rdx, %r15
movq %rsi, %r12
xorl %edx, %edx
testl %ecx, %ecx
setne %bpl
sete %dl
leaq 0xf3e3(%rip), %rax      # 0x7ec6a
leaq 0xf3d6(%rip), %r9       # 0x7ec64
cmoveq %rax, %r9
leaq 0xf3d2(%rip), %rax      # 0x7ec6b
leaq 0xf3c5(%rip), %rdi      # 0x7ec65
cmoveq %rax, %rdi
leaq 0xf3c5(%rip), %rcx      # 0x7ec70
xorl %esi, %esi
movl $0xfffffffa, %r8d       # imm = 0xFFFFFFFA
xorl %eax, %eax
pushq $0x0
pushq $-0x3
callq 0x6ba0
addq $0x10, %rsp
movq %rax, %r14
testq %r12, %r12
sete %al
orb %bpl, %al
jne 0x6f8eb
callq 0x6830
movq %r14, %rdi
movq %rax, %rsi
callq 0x6140
movq %rax, %rdi
movq %r12, %rsi
callq 0x60e0
callq 0x6520
movq %rax, %r12
leaq 0xf37e(%rip), %rsi      # 0x7ec78
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x6b00
movq %r12, %rdi
movq %r13, %rsi
callq 0x66f0
callq 0x6830
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x6140
movq %rax, %rdi
movq %r12, %rsi
callq 0x6650
callq 0x66c0
movq %r14, %rdi
movq %rax, %rsi
callq 0x6140
movq %rax, %rdi
callq 0x6270
movl %eax, %ebp
cmpl $-0x3, %eax
jne 0x6f980
movq %r14, %rdi
movq %r15, %rsi
callq 0x6140
movq %rax, %rdi
callq 0x68a0
testq %rax, %rax
je 0x6f980
movq %rax, %r15
movq %rax, %rdi
callq 0x6060
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x6230
xorl %ebx, %ebx
cmpl $-0x3, %ebp
sete %bl
movq %r14, %rdi
callq 0x6180
jmp 0x6f997
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/gtkbits.c
// Function: wmgtk_init
void wmgtk_init(int *argc, char ***argv)
{
	GdkPixbuf *appicon = NULL;
	GError *error = NULL;

	gtkenabled = gtk_init_check(argc, argv);
	if (!gtkenabled) {
		return;
	}

	startgtk_register_resource();

	appicon = gdk_pixbuf_new_from_resource("/appicon.png", &error);
	if (!appicon) {
        buildprintf("gdk_pixbuf_new_from_resource error: %s\n", error->message);
	} else {
		gtk_window_set_default_icon(appicon);
		g_object_unref(G_OBJECT(appicon));
	}
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq $0x0, 0x8(%rsp)
callq 0x68b0
movl %eax, 0x65f6b3(%rip)    # 0x6cf074
testl %eax, %eax
je 0x6fa19
callq 0xacf8
leaq 0x624e(%rip), %rdi      # 0x75c1f
leaq 0x8(%rsp), %rsi
callq 0x6a30
testq %rax, %rax
je 0x6fa02
movq %rax, %rbx
movq %rax, %rdi
callq 0x69f0
movl $0x50, %esi
movq %rbx, %rdi
callq 0x6140
movq %rax, %rdi
callq 0x6aa0
jmp 0x6fa19
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0xf26b(%rip), %rdi      # 0x7ec7d
xorl %eax, %eax
callq 0x25221
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/a-c.c
// Function: hlineasm4
void hlineasm4(int cnt, int skiploadincs, int paloffs, unsigned int by, unsigned int bx, void *p)
{
	unsigned char *palptr, *pp;

	palptr = &ghlinepal[paloffs];
	pp = (unsigned char *)p;
	if (!skiploadincs) { gbxinc = asm1; gbyinc = asm2; }
	for(;cnt>=0;cnt--)
	{
		*pp = palptr[gbuf[((bx>>(32-glogx))<<glogy)+(by>>(32-glogy))]];
		bx -= gbxinc;
		by -= gbyinc;
		pp--;
	}
}

// Assembly:
movl %ecx, %eax
testl %esi, %esi
jne 0x6fab4
leaq 0x3a71b7(%rip), %rcx    # 0x416c54
movl (%rcx), %ecx
movl %ecx, 0x65f603(%rip)    # 0x6cf0a8
leaq 0x3a71ac(%rip), %rcx    # 0x416c58
movl (%rcx), %ecx
movl %ecx, 0x65f5f8(%rip)    # 0x6cf0ac
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %edi, %edi
js 0x6fb2c
movslq %edx, %r11
addq 0x65f5d6(%rip), %r11    # 0x6cf0a0
movq 0x65f5c7(%rip), %rbx    # 0x6cf098
movl $0x20, %edx
movl $0x20, %esi
subl 0x65f5ab(%rip), %esi    # 0x6cf08c
movl 0x65f5a8(%rip), %r10d   # 0x6cf090
subl %r10d, %edx
movl 0x65f5b7(%rip), %ebp    # 0x6cf0a8
movl 0x65f5b4(%rip), %r14d   # 0x6cf0ac
incl %edi
movl %r8d, %r15d
movl %esi, %ecx
shrl %cl, %r15d
movl %r10d, %ecx
shll %cl, %r15d
movl %eax, %r12d
movl %edx, %ecx
shrl %cl, %r12d
addl %r15d, %r12d
movzbl (%rbx,%r12), %ecx
movb (%r11,%rcx), %cl
movb %cl, (%r9)
subl %ebp, %r8d
subl %r14d, %eax
decq %r9
decl %edi
jne 0x6fafa
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/a-c.c
// Function: slopevlin
void slopevlin(void *p, int i, void *slopaloffs, int cnt, int bx, int by)
{
	intptr_t *slopalptr;
	int bz, bzinc;
	unsigned int u, v;
	unsigned char *pp;

	bz = (int)asm3; bzinc = (asm1>>3);
	slopalptr = (intptr_t *)slopaloffs;
	pp = (unsigned char *)p;
	for(;cnt>0;cnt--)
	{
		i = krecip(bz>>6); bz += bzinc;
		u = bx+globalx3*i;
		v = by+globaly3*i;
		*pp = *(unsigned char *)(slopalptr[0]+gbuf[((u>>(32-glogx))<<glogy)+(v>>(32-glogy))]);
		slopalptr--;
		pp += gpinc;
	}
}

// Assembly:
testl %ecx, %ecx
jle 0x6fc0f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %r13d
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %r12
leaq 0x3a70d5(%rip), %rax    # 0x416c54
movl (%rax), %eax
sarl $0x3, %eax
movl %eax, 0x4(%rsp)
leaq 0x3a70d1(%rip), %rax    # 0x416c60
movl (%rax), %ebx
incl %r14d
movl %ebx, %edi
sarl $0x6, %edi
callq 0x369d6
addl 0x4(%rsp), %ebx
leaq 0x3e3f4b(%rip), %rcx    # 0x453af4
movl (%rcx), %edx
imull %eax, %edx
addl %r13d, %edx
leaq 0x3e3f40(%rip), %rcx    # 0x453af8
imull (%rcx), %eax
addl %ebp, %eax
xorl %ecx, %ecx
subb 0x65f4c7(%rip), %cl     # 0x6cf08c
shrl %cl, %edx
movb 0x65f4c3(%rip), %cl     # 0x6cf090
shll %cl, %edx
movq (%r15), %rsi
movq 0x65f4bf(%rip), %rdi    # 0x6cf098
negb %cl
shrl %cl, %eax
addl %edx, %eax
movzbl (%rdi,%rax), %eax
movb (%rsi,%rax), %al
movb %al, (%r12)
addq $-0x8, %r15
movslq 0x65f4bb(%rip), %rax    # 0x6cf0b0
addq %rax, %r12
decl %r14d
cmpl $0x1, %r14d
ja 0x6fb94
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/a-c.c
// Function: vlineasm1
void vlineasm1(int vinc, void *paloffs, int cnt, unsigned int vplc, void *bufplc, void *p)
{
	unsigned char *pp;

	gbuf = (unsigned char *)bufplc;
	gpal = (unsigned char *)paloffs;
	pp = (unsigned char *)p;
	for(;cnt>=0;cnt--)
	{
		*pp = gpal[gbuf[vplc>>glogy]];
		pp += bpl;
		vplc += vinc;
	}
}

// Assembly:
movq %r8, 0x65f47a(%rip)     # 0x6cf098
movq %rsi, 0x65f493(%rip)    # 0x6cf0b8
testl %edx, %edx
js 0x6fc55
movl %ecx, %eax
movl 0x65f45f(%rip), %ecx    # 0x6cf090
movslq 0x65f440(%rip), %r10    # 0x6cf078
incl %edx
movl %eax, %r11d
shrq %cl, %r11
movzbl (%r8,%r11), %r11d
movb (%rsi,%r11), %r11b
movb %r11b, (%r9)
addq %r10, %r9
addl %edi, %eax
decl %edx
jne 0x6fc3a
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/a-c.c
// Function: mvlineasm1
void mvlineasm1(int vinc, void *paloffs, int cnt, unsigned int vplc, void *bufplc, void *p)
{
	unsigned char ch, *pp;

	gbuf = (unsigned char *)bufplc;
	gpal = (unsigned char *)paloffs;
	pp = (unsigned char *)p;
	for(;cnt>=0;cnt--)
	{
		ch = gbuf[vplc>>glogy]; if (ch != 255) *pp = gpal[ch];
		pp += bpl;
		vplc += vinc;
	}
}

// Assembly:
movq %r8, 0x65f434(%rip)     # 0x6cf098
movq %rsi, 0x65f44d(%rip)    # 0x6cf0b8
testl %edx, %edx
js 0x6fca6
movl %ecx, %eax
movl 0x65f419(%rip), %ecx    # 0x6cf090
movslq 0x65f3fa(%rip), %r10    # 0x6cf078
incl %edx
movl %eax, %r11d
shrq %cl, %r11
movzbl (%r8,%r11), %r11d
cmpq $0xff, %r11
je 0x6fc9b
movb (%rsi,%r11), %r11b
movb %r11b, (%r9)
addq %r10, %r9
addl %edi, %eax
decl %edx
testl %edx, %edx
jg 0x6fc80
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/a-c.c
// Function: tvlineasm1
void tvlineasm1(int vinc, void *paloffs, int cnt, unsigned int vplc, void *bufplc, void *p)
{
	unsigned char ch, *pp;

	gbuf = (unsigned char *)bufplc;
	gpal = (unsigned char *)paloffs;
	pp = (unsigned char *)p;
	if (transmode)
	{
		for(;cnt>=0;cnt--)
		{
			ch = gbuf[vplc>>glogy];
			if (ch != 255) *pp = gtrans[(*pp)+(gpal[ch]<<8)];
			pp += bpl;
			vplc += vinc;
		}
	}
	else
	{
		for(;cnt>=0;cnt--)
		{
			ch = gbuf[vplc>>glogy];
			if (ch != 255) *pp = gtrans[((*pp)<<8)+gpal[ch]];
			pp += bpl;
			vplc += vinc;
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
movl %ecx, %eax
movq %r8, 0x65f3de(%rip)     # 0x6cf098
movq %rsi, 0x65f3f7(%rip)    # 0x6cf0b8
cmpb $0x0, 0x65f3c0(%rip)    # 0x6cf088
je 0x6fd1d
testl %edx, %edx
js 0x6fd6b
movl 0x65f3b8(%rip), %ecx    # 0x6cf090
movq 0x65f3a1(%rip), %r10    # 0x6cf080
movslq 0x65f392(%rip), %r11    # 0x6cf078
incl %edx
movl %eax, %ebx
shrq %cl, %rbx
movzbl (%r8,%rbx), %ebx
cmpq $0xff, %rbx
je 0x6fd10
movzbl (%r9), %r14d
movzbl (%rsi,%rbx), %ebx
shll $0x8, %ebx
orq %r14, %rbx
movb (%r10,%rbx), %bl
movb %bl, (%r9)
addq %r11, %r9
addl %edi, %eax
decl %edx
testl %edx, %edx
jg 0x6fce8
jmp 0x6fd6b
testl %edx, %edx
js 0x6fd6b
movl 0x65f369(%rip), %ecx    # 0x6cf090
movq 0x65f352(%rip), %r10    # 0x6cf080
movslq 0x65f343(%rip), %r11    # 0x6cf078
incl %edx
movl %eax, %ebx
shrq %cl, %rbx
movzbl (%r8,%rbx), %ebx
cmpq $0xff, %rbx
je 0x6fd60
movzbl (%r9), %r14d
shll $0x8, %r14d
movzbl (%rsi,%rbx), %ebx
orq %r14, %rbx
movb (%r10,%rbx), %bl
movb %bl, (%r9)
addq %r11, %r9
addl %edi, %eax
decl %edx
testl %edx, %edx
jg 0x6fd37
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/a-c.c
// Function: mhline
void mhline(void *bufplc, unsigned int bx, int cntup16, int junk, unsigned int by, void *p)
{
	unsigned char ch, *pp;
	(void)junk;

	gbuf = (unsigned char *)bufplc;
	gpal = (unsigned char *)asm3;
	pp = (unsigned char *)p;
	for(cntup16>>=16;cntup16>0;cntup16--)
	{
		ch = gbuf[((bx>>(32-glogx))<<glogy)+(by>>(32-glogy))];
		if (ch != 255) *pp = gpal[ch];
		bx += asm1;
		by += asm2;
		pp++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, 0x65f30d(%rip)    # 0x6cf098
leaq 0x3a6ece(%rip), %rax    # 0x416c60
movq (%rax), %rbx
movq %rbx, 0x65f31c(%rip)    # 0x6cf0b8
sarl $0x10, %edx
testl %edx, %edx
jle 0x6fe0a
movl $0x20, %eax
movl $0x20, %r10d
subl 0x65f2d7(%rip), %r10d   # 0x6cf08c
movl 0x65f2d4(%rip), %r11d   # 0x6cf090
subl %r11d, %eax
incl %edx
leaq 0x3a6e8c(%rip), %r14    # 0x416c54
leaq 0x3a6e89(%rip), %r15    # 0x416c58
movl %esi, %ebp
movl %r10d, %ecx
shrl %cl, %ebp
movl %r11d, %ecx
shll %cl, %ebp
movl %r8d, %r12d
movl %eax, %ecx
shrl %cl, %r12d
addl %ebp, %r12d
movzbl (%rdi,%r12), %ecx
cmpq $0xff, %rcx
je 0x6fdfa
movb (%rbx,%rcx), %cl
movb %cl, (%r9)
addl (%r14), %esi
addl (%r15), %r8d
incq %r9
decl %edx
cmpl $0x1, %edx
jg 0x6fdcf
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/a-c.c
// Function: thline
void thline(void *bufplc, unsigned int bx, int cntup16, int junk, unsigned int by, void *p)
{
	unsigned char ch, *pp;
	(void)junk;

	gbuf = (unsigned char *)bufplc;
	gpal = (unsigned char *)asm3;
	pp = (unsigned char *)p;
	if (transmode)
	{
		for(cntup16>>=16;cntup16>0;cntup16--)
		{
			ch = gbuf[((bx>>(32-glogx))<<glogy)+(by>>(32-glogy))];
			if (ch != 255) *pp = gtrans[(*pp)+(gpal[ch]<<8)];
			bx += asm1;
			by += asm2;
			pp++;
		}
	}
	else
	{
		for(cntup16>>=16;cntup16>0;cntup16--)
		{
			ch = gbuf[((bx>>(32-glogx))<<glogy)+(by>>(32-glogy))];
			if (ch != 255) *pp = gtrans[((*pp)<<8)+gpal[ch]];
			bx += asm1;
			by += asm2;
			pp++;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, 0x65f267(%rip)    # 0x6cf098
leaq 0x3a6e28(%rip), %rax    # 0x416c60
movq (%rax), %rbx
movq %rbx, 0x65f276(%rip)    # 0x6cf0b8
sarl $0x10, %edx
cmpb $0x1, 0x65f23c(%rip)    # 0x6cf088
jne 0x6fedd
testl %edx, %edx
jle 0x6ff60
movl $0x20, %eax
movl $0x20, %r10d
subl 0x65f220(%rip), %r10d   # 0x6cf08c
movl 0x65f21d(%rip), %r11d   # 0x6cf090
subl %r11d, %eax
movq 0x65f203(%rip), %r14    # 0x6cf080
incl %edx
leaq 0x3a6dce(%rip), %r15    # 0x416c54
leaq 0x3a6dcb(%rip), %r12    # 0x416c58
movl %esi, %ebp
movl %r10d, %ecx
shrl %cl, %ebp
movl %r11d, %ecx
shll %cl, %ebp
movl %r8d, %r13d
movl %eax, %ecx
shrl %cl, %r13d
addl %ebp, %r13d
movzbl (%rdi,%r13), %ecx
cmpq $0xff, %rcx
je 0x6fec7
movzbl (%r9), %r13d
movzbl (%rbx,%rcx), %ecx
shll $0x8, %ecx
orq %r13, %rcx
movb (%r14,%rcx), %cl
movb %cl, (%r9)
addl (%r15), %esi
addl (%r12), %r8d
incq %r9
decl %edx
cmpl $0x1, %edx
jg 0x6fe8d
jmp 0x6ff60
testl %edx, %edx
jle 0x6ff60
movl $0x20, %eax
movl $0x20, %r10d
subl 0x65f199(%rip), %r10d   # 0x6cf08c
movl 0x65f196(%rip), %r11d   # 0x6cf090
subl %r11d, %eax
movq 0x65f17c(%rip), %r14    # 0x6cf080
incl %edx
leaq 0x3a6d47(%rip), %r15    # 0x416c54
leaq 0x3a6d44(%rip), %r12    # 0x416c58
movl %esi, %ebp
movl %r10d, %ecx
shrl %cl, %ebp
movl %r11d, %ecx
shll %cl, %ebp
movl %r8d, %r13d
movl %eax, %ecx
shrl %cl, %r13d
addl %ebp, %r13d
movzbl (%rdi,%r13), %ecx
cmpq $0xff, %rcx
je 0x6ff4f
movzbl (%r9), %r13d
shll $0x8, %r13d
movzbl (%rbx,%rcx), %ecx
orq %r13, %rcx
movb (%r14,%rcx), %cl
movb %cl, (%r9)
addl (%r15), %esi
addl (%r12), %r8d
incq %r9
decl %edx
cmpl $0x1, %edx
jg 0x6ff14
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/a-c.c
// Function: spritevline
void spritevline(int bx, int by, int cnt, void *bufplc, void *p)
{
	unsigned char *pp;

	gbuf = (unsigned char *)bufplc;
	pp = (unsigned char *)p;
	for(;cnt>1;cnt--)
	{
		*pp = gpal[gbuf[(bx>>16)*glogy+(by>>16)]];
		bx += gbxinc;
		by += gbyinc;
		pp += bpl;
	}
}

// Assembly:
movq %rcx, 0x65f10c(%rip)    # 0x6cf098
cmpl $0x2, %edx
jl 0x6fff0
pushq %rbp
pushq %r14
pushq %rbx
movq 0x65f11c(%rip), %rax    # 0x6cf0b8
movl 0x65f0ed(%rip), %r9d    # 0x6cf090
movl 0x65f0fe(%rip), %r10d   # 0x6cf0a8
movl 0x65f0fb(%rip), %r11d   # 0x6cf0ac
movslq 0x65f0c0(%rip), %rbx    # 0x6cf078
incl %edx
movl %edi, %ebp
sarl $0x10, %ebp
imull %r9d, %ebp
movl %esi, %r14d
sarl $0x10, %r14d
addl %ebp, %r14d
movslq %r14d, %r14
movzbl (%rcx,%r14), %r14d
movb (%rax,%r14), %bpl
movb %bpl, (%r8)
addq %rbx, %r8
addl %r10d, %edi
addl %r11d, %esi
decl %edx
cmpl $0x2, %edx
ja 0x6ffba
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/a-c.c
// Function: mspritevline
void mspritevline(int bx, int by, int cnt, void *bufplc, void *p)
{
	unsigned char ch, *pp;

	gbuf = (unsigned char *)bufplc;
	pp = (unsigned char *)p;
	for(;cnt>1;cnt--)
	{
		ch = gbuf[(bx>>16)*glogy+(by>>16)];
		if (ch != 255) *pp = gpal[ch];
		bx += gbxinc;
		by += gbyinc;
		pp += bpl;
	}
}

// Assembly:
movq %rcx, 0x65f086(%rip)    # 0x6cf098
cmpl $0x2, %edx
jl 0x7007d
pushq %rbp
pushq %r14
pushq %rbx
movl 0x65f06f(%rip), %eax    # 0x6cf090
movq 0x65f090(%rip), %r9     # 0x6cf0b8
movl 0x65f079(%rip), %r10d   # 0x6cf0a8
movl 0x65f076(%rip), %r11d   # 0x6cf0ac
movslq 0x65f03b(%rip), %rbx    # 0x6cf078
incl %edx
movl %edi, %ebp
sarl $0x10, %ebp
imull %eax, %ebp
movl %esi, %r14d
sarl $0x10, %r14d
addl %ebp, %r14d
movslq %r14d, %r14
movzbl (%rcx,%r14), %r14d
cmpq $0xff, %r14
je 0x70069
movb (%r9,%r14), %bpl
movb %bpl, (%r8)
addq %rbx, %r8
addl %r10d, %edi
addl %r11d, %esi
decl %edx
cmpl $0x2, %edx
jg 0x7003f
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/a-c.c
// Function: tspritevline
void tspritevline(int bx, int by, int cnt, void *bufplc, void *p)
{
	unsigned char ch, *pp;

	gbuf = (unsigned char *)bufplc;
	pp = (unsigned char *)p;
	if (transmode)
	{
		for(;cnt>1;cnt--)
		{
			ch = gbuf[(bx>>16)*glogy+(by>>16)];
			if (ch != 255) *pp = gtrans[(*pp)+(gpal[ch]<<8)];
			bx += gbxinc;
			by += gbyinc;
			pp += bpl;
		}
	}
	else
	{
		for(;cnt>1;cnt--)
		{
			ch = gbuf[(bx>>16)*glogy+(by>>16)];
			if (ch != 255) *pp = gtrans[((*pp)<<8)+gpal[ch]];
			bx += gbxinc;
			by += gbyinc;
			pp += bpl;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, 0x65eff1(%rip)    # 0x6cf098
cmpb $0x0, 0x65efda(%rip)    # 0x6cf088
je 0x7012e
cmpl $0x2, %edx
jl 0x701a6
movl 0x65efd1(%rip), %eax    # 0x6cf090
movq 0x65efba(%rip), %r9     # 0x6cf080
movq 0x65efeb(%rip), %r10    # 0x6cf0b8
movl 0x65efd4(%rip), %r11d   # 0x6cf0a8
movl 0x65efd2(%rip), %ebx    # 0x6cf0ac
movslq 0x65ef97(%rip), %r14    # 0x6cf078
incl %edx
movl %edi, %ebp
sarl $0x10, %ebp
imull %eax, %ebp
movl %esi, %r15d
sarl $0x10, %r15d
addl %ebp, %r15d
movslq %r15d, %r15
movzbl (%rcx,%r15), %r15d
cmpq $0xff, %r15
je 0x7011d
movzbl (%r8), %r12d
movzbl (%r10,%r15), %r15d
shll $0x8, %r15d
orq %r12, %r15
movb (%r9,%r15), %bpl
movb %bpl, (%r8)
addq %r14, %r8
addl %r11d, %edi
addl %ebx, %esi
decl %edx
cmpl $0x2, %edx
jg 0x700e3
jmp 0x701a6
cmpl $0x2, %edx
jl 0x701a6
movl 0x65ef57(%rip), %eax    # 0x6cf090
movq 0x65ef40(%rip), %r9     # 0x6cf080
movq 0x65ef71(%rip), %r10    # 0x6cf0b8
movl 0x65ef5a(%rip), %r11d   # 0x6cf0a8
movl 0x65ef58(%rip), %ebx    # 0x6cf0ac
movslq 0x65ef1d(%rip), %r14    # 0x6cf078
incl %edx
movl %edi, %ebp
sarl $0x10, %ebp
imull %eax, %ebp
movl %esi, %r15d
sarl $0x10, %r15d
addl %ebp, %r15d
movslq %r15d, %r15
movzbl (%rcx,%r15), %r15d
cmpq $0xff, %r15
je 0x70197
movzbl (%r8), %r12d
shll $0x8, %r12d
movzbl (%r10,%r15), %r15d
orq %r12, %r15
movb (%r9,%r15), %bpl
movb %bpl, (%r8)
addq %r14, %r8
addl %r11d, %edi
addl %ebx, %esi
decl %edx
cmpl $0x2, %edx
jg 0x7015d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/a-c.c
// Function: drawslab
void drawslab (int dx, int v, int dy, int vi, void *vptr, void *p)
{
	int x;
	unsigned char *pp, *vpptr;
	
	pp = (unsigned char *)p;
	vpptr = (unsigned char *)vptr;
	while (dy > 0)
	{
		for(x=0;x<dx;x++) *(pp+x) = gpal[(int)(*(vpptr+(v>>16)))];
		pp += bpl; v += vi; dy--;
	}
}

// Assembly:
testl %edx, %edx
jle 0x70211
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq 0x65eeea(%rip), %rax    # 0x6cf0b8
movslq 0x65eea3(%rip), %r10    # 0x6cf078
movl %edi, %r11d
testl %edi, %edi
jle 0x701fc
movl %esi, %ebx
sarl $0x10, %ebx
movslq %ebx, %rbx
xorl %r14d, %r14d
movzbl (%r8,%rbx), %r15d
movb (%rax,%r15), %bpl
movb %bpl, (%r9,%r14)
incq %r14
cmpq %r14, %r11
jne 0x701e7
addq %r10, %r9
addl %ecx, %esi
leal -0x1(%rdx), %ebx
cmpl $0x1, %edx
movl %ebx, %edx
jg 0x701d8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/crc32.c
// Function: initcrc32table
void initcrc32table(void)
{
	unsigned int i,j,k;
	
	// algorithm and polynomial same as that used by infozip's zip
	for (i=0; i<256; i++) {
		j = i;
		for (k=8; k; k--)
			j = (j&1) ? (0xedb88320L ^ (j>>1)) : (j>>1);
		crc32table[i] = j;
	}
}

// Assembly:
xorl %eax, %eax
leaq 0x65ee7b(%rip), %rcx    # 0x6cf0c0
movl $0xfffffff8, %edx       # imm = 0xFFFFFFF8
movl %eax, %esi
movl %esi, %edi
shrl %edi
movl %edi, %r8d
xorl $0xedb88320, %r8d       # imm = 0xEDB88320
testb $0x1, %sil
movl %r8d, %esi
cmovel %edi, %esi
incl %edx
jne 0x7024c
movl %esi, (%rcx,%rax,4)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x70245
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/libsquish/alpha.cpp
// Function: squish::CompressAlphaDxt3(unsigned char const*, int, void*)
void CompressAlphaDxt3( u8 const* rgba, int mask, void* block )
{
    u8* bytes = reinterpret_cast< u8* >( block );

    // quantise and pack the alpha values pairwise
    for( int i = 0; i < 8; ++i )
    {
        // quantise down to 4 bits
        float alpha1 = ( float )rgba[8*i + 3] * ( 15.0f/255.0f );
        float alpha2 = ( float )rgba[8*i + 7] * ( 15.0f/255.0f );
        int quant1 = FloatToInt( alpha1, 15 );
        int quant2 = FloatToInt( alpha2, 15 );

        // set alpha to zero where masked
        int bit1 = 1 << ( 2*i );
        int bit2 = 1 << ( 2*i + 1 );
        if( ( mask & bit1 ) == 0 )
            quant1 = 0;
        if( ( mask & bit2 ) == 0 )
            quant2 = 0;

        // pack into the byte
        bytes[i] = ( u8 )( quant1 | ( quant2 << 4 ) );
    }
}

// Assembly:
xorl %ecx, %ecx
movss 0xe9ce(%rip), %xmm0     # 0x7ecc4
movss 0xa28a(%rip), %xmm1     # 0x7a588
movl $0xf, %r10d
movzbl 0x3(%rdi,%rcx,4), %eax
xorps %xmm2, %xmm2
cvtsi2ss %eax, %xmm2
mulss %xmm0, %xmm2
addss %xmm1, %xmm2
cvttss2si %xmm2, %eax
cmpl %r10d, %eax
jl 0x70326
movl $0xf, %eax
xorl %r8d, %r8d
testl %eax, %eax
jg 0x7032f
xorl %eax, %eax
movzbl 0x7(%rdi,%rcx,4), %r9d
xorps %xmm2, %xmm2
cvtsi2ss %r9d, %xmm2
mulss %xmm0, %xmm2
addss %xmm1, %xmm2
cvttss2si %xmm2, %r9d
cmpl %r10d, %r9d
jl 0x70355
movl $0xf, %r9d
testl %r9d, %r9d
jg 0x7035d
xorl %r9d, %r9d
btl %ecx, %esi
cmovael %r8d, %eax
movl %esi, %r8d
shrl %cl, %r8d
shll $0x1e, %r8d
sarl $0x1f, %r8d
shll $0x4, %r9d
andl %r8d, %r9d
orl %eax, %r9d
movb %r9b, (%rdx)
addq $0x2, %rcx
incq %rdx
cmpq $0x10, %rcx
jne 0x70304
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/libsquish/clusterfit.cpp
// Function: squish::ClusterFit::ClusterFit(squish::ColourSet const*, int, float*)
ClusterFit::ClusterFit( ColourSet const* colours, int flags, float* metric )
  : ColourFit( colours, flags )
{
    // set the iteration count
    m_iterationCount = ( m_flags & kColourIterativeClusterFit ) ? kMaxIterations : 1;

    // initialise the metric (old perceptual = 0.2126f, 0.7152f, 0.0722f)
    if( metric )
        m_metric = Vec4( metric[0], metric[1], metric[2], 1.0f );
    else
        m_metric = VEC4_CONST( 1.0f );

    // initialise the best error
    m_besterror = VEC4_CONST( FLT_MAX );

    // cache some values
    int const count = m_colours->GetCount();
    Vec3 const* values = m_colours->GetPoints();

    // get the covariance matrix
    Sym3x3 covariance = ComputeWeightedCovariance( count, values, m_colours->GetWeights() );

    // compute the principle component
    m_principle = ComputePrincipleComponent( covariance );
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdi, %rbx
callq 0x71f40
leaq 0x221cb(%rip), %rax     # 0x92bb0
movq %rax, (%rbx)
btl $0x8, 0x10(%rbx)
movl $0x1, %eax
movl $0x8, %ecx
cmovael %eax, %ecx
movl %ecx, 0x14(%rbx)
testq %r14, %r14
je 0x70a0f
movsd (%r14), %xmm0
movss 0x8(%r14), %xmm1
jmp 0x70a1e
movaps 0x9d1a(%rip), %xmm0     # 0x7a730
movss 0x66f6(%rip), %xmm1     # 0x77114
movlps %xmm0, 0x1b4(%rbx)
movss %xmm1, 0x1bc(%rbx)
movaps 0xe2dc(%rip), %xmm0     # 0x7ed10
movups %xmm0, 0x1c0(%rbx)
movl $0x7f7fffff, 0x1d0(%rbx) # imm = 0x7F7FFFFF
movq 0x8(%rbx), %rcx
movl (%rcx), %esi
leaq 0x4(%rcx), %rdx
addq $0xc4, %rcx
movq %rsp, %r14
movq %r14, %rdi
callq 0x721bc
movq %r14, %rdi
callq 0x722f0
movlps %xmm0, 0x18(%rbx)
movss %xmm1, 0x20(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/libsquish/simd_float.h
// Function: squish::Truncate(squish::Vec4 const&)
Vec4 Truncate( Vec4::Arg v )
    {
        return Vec4(
            v.m_x > 0.0f ? std::floor( v.m_x ) : std::ceil( v.m_x ),
            v.m_y > 0.0f ? std::floor( v.m_y ) : std::ceil( v.m_y ),
            v.m_z > 0.0f ? std::floor( v.m_z ) : std::ceil( v.m_z ),
            v.m_w > 0.0f ? std::floor( v.m_w ) : std::ceil( v.m_w )
        );
    }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movss (%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x71b8c
callq 0x6850
jmp 0x71b91
callq 0x63d0
movaps %xmm0, 0x20(%rsp)
movss 0x4(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x71baa
callq 0x6850
jmp 0x71baf
callq 0x63d0
movaps %xmm0, 0x10(%rsp)
movss 0x8(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x71bc8
callq 0x6850
jmp 0x71bcd
callq 0x63d0
movaps %xmm0, (%rsp)
movss 0xc(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x71be5
callq 0x6850
jmp 0x71bea
callq 0x63d0
movaps (%rsp), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movaps 0x20(%rsp), %xmm0
unpcklps 0x10(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
addq $0x30, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/libsquish/colourblock.cpp
// Function: squish::WriteColourBlock3(squish::Vec3 const&, squish::Vec3 const&, unsigned char const*, void*)
void WriteColourBlock3( Vec3::Arg start, Vec3::Arg end, u8 const* indices, void* block )
{
    // get the packed values
    int a = FloatTo565( start );
    int b = FloatTo565( end );

    // remap the indices
    u8 remapped[16];
    if( a <= b )
    {
        // use the indices directly
        for( int i = 0; i < 16; ++i )
            remapped[i] = indices[i];
    }
    else
    {
        // swap a and b
        std::swap( a, b );
        for( int i = 0; i < 16; ++i )
        {
            if( indices[i] == 0 )
                remapped[i] = 1;
            else if( indices[i] == 1 )
                remapped[i] = 0;
            else
                remapped[i] = indices[i];
        }
    }

    // write the block
    WriteColourBlock( a, b, remapped, block );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x71c84
movl %eax, %ebp
movq %r15, %rdi
callq 0x71c84
cmpl %eax, %ebp
jbe 0x71c62
xorl %ecx, %ecx
movzbl (%r14,%rcx), %edx
testl %edx, %edx
je 0x71c4e
cmpl $0x1, %edx
jne 0x71c50
xorl %edx, %edx
jmp 0x71c50
movb $0x1, %dl
movb %dl, (%rsp,%rcx)
incq %rcx
cmpq $0x10, %rcx
jne 0x71c3c
movl %eax, %edi
movl %ebp, %eax
jmp 0x71c6c
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movl %ebp, %edi
movq %rsp, %rdx
movl %eax, %esi
movq %rbx, %rcx
callq 0x71d0b
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/libsquish/colourblock.cpp
// Function: squish::WriteColourBlock(int, int, unsigned char*, void*)
static void WriteColourBlock( int a, int b, u8* indices, void* block )
{
    // get the block as bytes
    u8* bytes = ( u8* )block;

    // write the endpoints
    bytes[0] = ( u8 )( a & 0xff );
    bytes[1] = ( u8 )( a >> 8 );
    bytes[2] = ( u8 )( b & 0xff );
    bytes[3] = ( u8 )( b >> 8 );

    // write the indices
    for( int i = 0; i < 4; ++i )
    {
        u8 const* ind = indices + 4*i;
        bytes[4 + i] = ind[0] | ( ind[1] << 2 ) | ( ind[2] << 4 ) | ( ind[3] << 6 );
    }
}

// Assembly:
pushq %rbx
movl %esi, %eax
movl %edi, %ebx
movb %bl, (%rcx)
movb %bh, 0x1(%rcx)
movb %al, 0x2(%rcx)
movb %ah, 0x3(%rcx)
xorl %eax, %eax
movb 0x1(%rdx,%rax,4), %sil
movb 0x2(%rdx,%rax,4), %dil
shlb $0x2, %sil
orb (%rdx,%rax,4), %sil
shlb $0x4, %dil
movb 0x3(%rdx,%rax,4), %r8b
shlb $0x6, %r8b
orb %dil, %r8b
orb %sil, %r8b
movb %r8b, 0x4(%rcx,%rax)
incq %rax
cmpq $0x4, %rax
jne 0x71d1d
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/libsquish/colourblock.cpp
// Function: squish::WriteColourBlock4(squish::Vec3 const&, squish::Vec3 const&, unsigned char const*, void*)
void WriteColourBlock4( Vec3::Arg start, Vec3::Arg end, u8 const* indices, void* block )
{
    // get the packed values
    int a = FloatTo565( start );
    int b = FloatTo565( end );

    // remap the indices
    u8 remapped[16];
    if( a < b )
    {
        // swap a and b
        std::swap( a, b );
        for( int i = 0; i < 16; ++i )
            remapped[i] = ( indices[i] ^ 0x1 ) & 0x3;
    }
    else if( a == b )
    {
        // use index 0
        for( int i = 0; i < 16; ++i )
            remapped[i] = 0;
    }
    else
    {
        // use the indices directly
        for( int i = 0; i < 16; ++i )
            remapped[i] = indices[i];
    }

    // write the block
    WriteColourBlock( a, b, remapped, block );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x71c84
movl %eax, %ebp
movq %r15, %rdi
callq 0x71c84
cmpl %eax, %ebp
jae 0x71d92
movups (%r14), %xmm0
andps 0xd05d(%rip), %xmm0     # 0x7ede0
xorps 0xd066(%rip), %xmm0     # 0x7edf0
movaps %xmm0, (%rsp)
movl %eax, %edi
jmp 0x71dab
jne 0x71d9f
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movl %ebp, %edi
jmp 0x71dab
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movl %ebp, %edi
movl %eax, %ebp
movq %rsp, %rdx
movl %ebp, %esi
movq %rbx, %rcx
callq 0x71d0b
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/libsquish/colourfit.cpp
// Function: squish::ColourFit::Compress(void*)
void ColourFit::Compress( void* block )
{
    bool isDxt1 = ( ( m_flags & kDxt1 ) != 0 );
    if( isDxt1 )
    {
        Compress3( block );
        if( !m_colours->IsTransparent() )
            Compress4( block );
    }
    else
        Compress4( block );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testb $0x1, 0x10(%rdi)
movq (%rdi), %rax
je 0x71f8a
movq %r14, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
movq 0x8(%r14), %rax
cmpb $0x0, 0x144(%rax)
je 0x71f87
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rax
movq 0x18(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/libsquish/colourset.cpp
// Function: squish::ColourSet::RemapIndices(unsigned char const*, unsigned char*) const
void ColourSet::RemapIndices( u8 const* source, u8* target ) const
{
    for( int i = 0; i < 16; ++i )
    {
        int j = m_remap[i];
        if( j == -1 )
            target[i] = 3;
        else
            target[i] = source[j];
    }
}

// Assembly:
xorl %eax, %eax
movslq 0x104(%rdi,%rax,4), %rcx
cmpq $-0x1, %rcx
je 0x721ab
movb (%rsi,%rcx), %cl
jmp 0x721ad
movb $0x3, %cl
movb %cl, (%rdx,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x72198
retq
nop
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/libsquish/maths.cpp
// Function: squish::ComputeWeightedCovariance(int, squish::Vec3 const*, float const*)
Sym3x3 ComputeWeightedCovariance( int n, Vec3 const* points, float const* weights )
{
    // compute the centroid
    float total = 0.0f;
    Vec3 centroid( 0.0f );
    for( int i = 0; i < n; ++i )
    {
        total += weights[i];
        centroid += weights[i]*points[i];
    }
    if( total > FLT_EPSILON )
        centroid /= total;

    // accumulate the covariance matrix
    Sym3x3 covariance( 0.0f );
    for( int i = 0; i < n; ++i )
    {
        Vec3 a = points[i] - centroid;
        Vec3 b = weights[i]*a;

        covariance[0] += a.X()*b.X();
        covariance[1] += a.X()*b.Y();
        covariance[2] += a.X()*b.Z();
        covariance[3] += a.Y()*b.Y();
        covariance[4] += a.Y()*b.Z();
        covariance[5] += a.Z()*b.Z();
    }

    // return it
    return covariance;
}

// Assembly:
movq %rdi, %rax
movl %esi, %edi
testl %esi, %esi
jle 0x72209
leaq 0x8(%rdx), %r8
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
xorl %r9d, %r9d
xorps %xmm0, %xmm0
movss (%rcx,%r9,4), %xmm3
addss %xmm3, %xmm2
movsd -0x8(%r8), %xmm4
movaps %xmm3, %xmm5
shufps $0x0, %xmm3, %xmm5      # xmm5 = xmm5[0,0],xmm3[0,0]
mulps %xmm4, %xmm5
addps %xmm5, %xmm1
mulss (%r8), %xmm3
addss %xmm3, %xmm0
incq %r9
addq $0xc, %r8
cmpq %r9, %rdi
jne 0x721d5
jmp 0x72212
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
xorps %xmm2, %xmm2
xorl %r8d, %r8d
ucomiss 0xcbe4(%rip), %xmm2     # 0x7ee00
seta %r9b
movss 0x4eec(%rip), %xmm4     # 0x77114
divss %xmm2, %xmm4
jbe 0x72232
mulss %xmm4, %xmm0
xorps %xmm2, %xmm2
movups %xmm2, 0x4(%rax)
movl $0x0, 0x14(%rax)
testl %esi, %esi
jle 0x722e8
shufps $0x0, %xmm4, %xmm4      # xmm4 = xmm4[0,0,0,0]
mulps %xmm1, %xmm4
movb %r9b, %r8b
movd %r8d, %xmm3
pshufd $0x50, %xmm3, %xmm3     # xmm3 = xmm3[0,0,1,1]
pslld $0x1f, %xmm3
psrad $0x1f, %xmm3
andps %xmm3, %xmm4
andnps %xmm1, %xmm3
orps %xmm4, %xmm3
addq $0x8, %rdx
xorl %esi, %esi
xorps %xmm1, %xmm1
movsd -0x8(%rdx), %xmm4
subps %xmm3, %xmm4
movss (%rdx), %xmm5
subss %xmm0, %xmm5
movss (%rcx,%rsi,4), %xmm6
movaps %xmm4, %xmm7
unpcklps %xmm4, %xmm7            # xmm7 = xmm7[0],xmm4[0],xmm7[1],xmm4[1]
movaps %xmm4, %xmm8
mulss %xmm6, %xmm8
movaps %xmm5, %xmm9
shufps $0xd4, %xmm4, %xmm9     # xmm9 = xmm9[0,1],xmm4[1,3]
shufps $0x52, %xmm4, %xmm9     # xmm9 = xmm9[2,0],xmm4[1,1]
shufps $0x0, %xmm6, %xmm6      # xmm6 = xmm6[0,0,0,0]
mulps %xmm9, %xmm6
shufps $0x10, %xmm6, %xmm4     # xmm4 = xmm4[0,0],xmm6[1,0]
shufps $0xe2, %xmm6, %xmm4     # xmm4 = xmm4[2,0],xmm6[2,3]
movlhps %xmm6, %xmm6            # xmm6 = xmm6[0,0]
mulps %xmm7, %xmm6
addps %xmm6, %xmm2
unpcklps %xmm8, %xmm5            # xmm5 = xmm5[0],xmm8[0],xmm5[1],xmm8[1]
mulps %xmm5, %xmm4
addps %xmm4, %xmm1
incq %rsi
addq $0xc, %rdx
cmpq %rsi, %rdi
jne 0x72278
movups %xmm2, 0x4(%rax)
movss %xmm1, 0x14(%rax)
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
jmp 0x722eb
xorps %xmm1, %xmm1
movss %xmm1, (%rax)
retq