LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/jonof[P]jftekwar/jfbuild/libsquish/squish.cpp
// Function: squish::GetStorageRequirements(int, int, int)
int GetStorageRequirements( int width, int height, int flags )
{
    // fix any bad flags
    flags = FixFlags( flags );

    // compute the storage requirements
    int blockcount = ( ( width + 3 )/4 ) * ( ( height + 3 )/4 );
    int blocksize = ( ( flags & ( kDxt1 | kBc4 ) ) != 0 ) ? 8 : 16;
    return blockcount*blocksize;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl %edx, %edi
callq 0x617da
movl %eax, %edi
addl $0x3, %ebp
pushq $0x4
popq %rcx
movl %ebp, %eax
cltd
idivl %ecx
movl %eax, %esi
addl $0x3, %ebx
movl %ebx, %eax
cltd
idivl %ecx
imull %esi, %eax
andl $0x9, %edi
xorl %ecx, %ecx
cmpl $0x1, %edi
adcb $0x3, %cl
shll %cl, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jonof[P]jftekwar/jfbuild/libsquish/squish.cpp
// Function: squish::CopyRGBA(unsigned char const*, unsigned char*, int)
void CopyRGBA( u8 const* source, u8* dest, int flags )
{
    if (flags & kSourceBGRA)
    {
        // convert from bgra to rgba
        dest[0] = source[2];
        dest[1] = source[1];
        dest[2] = source[0];
        dest[3] = source[3];
    }
    else
    {
        for( int i = 0; i < 4; ++i )
            *dest++ = *source++;
    }
}

// Assembly:
btl $0x9, %edx
jb 0x618d0
xorl %eax, %eax
cmpl $0x4, %eax
je 0x618e6
movb (%rdi,%rax), %cl
movb %cl, (%rsi,%rax)
incq %rax
jmp 0x618c0
movb 0x2(%rdi), %al
movb %al, (%rsi)
movb 0x1(%rdi), %al
movb %al, 0x1(%rsi)
movb (%rdi), %al
movb %al, 0x2(%rsi)
movb 0x3(%rdi), %al
movb %al, 0x3(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: wm_msgbox
int wm_msgbox(const char *name, const char *fmt, ...)
{
	char *buf = NULL;
	int rv;
	va_list va;

	if (!name) {
		name = apptitle;
	}

	va_start(va,fmt);
	rv = Bvasprintf(&buf,fmt,va);
	va_end(va);

	if (rv < 0) return -1;

	do {
		rv = 0;

#if defined HAVE_GTK
		if (wmgtk_msgbox(name, buf) >= 0) {
			rv = 1;
			break;
		}
#endif
		if (SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, name, buf, sdl_window) >= 0) {
			rv = 1;
			break;
		}

		puts(buf);
	} while(0);

	free(buf);

	return rv;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xe8, %rsp
leaq 0x30(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x62019
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
leaq 0x8(%rsp), %rax
andq $0x0, (%rax)
testq %rdi, %rdi
leaq 0x3c574(%rip), %r14     # 0x9e5a0
cmovneq %rdi, %r14
leaq 0x10(%rsp), %rdx
movq %r10, 0x10(%rdx)
leaq 0x100(%rsp), %rcx
movq %rcx, 0x8(%rdx)
movabsq $0x3000000010, %rcx     # imm = 0x3000000010
movq %rcx, (%rdx)
movq %rax, %rdi
callq 0x1f520
testl %eax, %eax
js 0x620a5
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x63eaa
pushq $0x1
popq %rbx
testl %eax, %eax
jns 0x62099
movq 0x8(%rsp), %rdx
movq 0x664242(%rip), %rcx    # 0x6c62c0
pushq $0x40
popq %rdi
movq %r14, %rsi
callq 0x6ad0
testl %eax, %eax
jns 0x62099
movq 0x8(%rsp), %rdi
callq 0x6ab0
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
callq 0x61c0
jmp 0x620a8
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: wm_ynbox
int wm_ynbox(const char *name, const char *fmt, ...)
{
	char *buf = NULL;
	int rv;
	va_list va;

	if (!name) {
		name = apptitle;
	}

	va_start(va,fmt);
	rv = Bvasprintf(&buf,fmt,va);
	va_end(va);

	if (rv < 0) return -1;

	SDL_MessageBoxButtonData buttons[2] = {
		{ SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT, 1, "Yes" },
		{ SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT, 0, "No" },
	};
	SDL_MessageBoxData msgbox = {
		SDL_MESSAGEBOX_INFORMATION,
		sdl_window,
		name,
		buf,
		SDL_arraysize(buttons),
		buttons,
		NULL
	};

	do {
		rv = 0;

#if defined HAVE_GTK
		if ((rv = wmgtk_ynbox(name, buf)) >= 0) {
			break;
		}
#endif
		if (SDL_ShowMessageBox(&msgbox, &rv) >= 0) {
			rv = (rv == 1);
			break;
		}

		puts(buf);
		puts("   (assuming 'No')");
		rv = 0;
	} while(0);

	free(buf);

	return rv;
}

// Assembly:
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
leaq 0x90(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x62119
movaps %xmm0, 0xc0(%rsp)
movaps %xmm1, 0xd0(%rsp)
movaps %xmm2, 0xe0(%rsp)
movaps %xmm3, 0xf0(%rsp)
movaps %xmm4, 0x100(%rsp)
movaps %xmm5, 0x110(%rsp)
movaps %xmm6, 0x120(%rsp)
movaps %xmm7, 0x130(%rsp)
leaq 0x10(%rsp), %rax
andq $0x0, (%rax)
movq %rdi, %rbx
leaq 0x50(%rsp), %rdx
movq %r10, 0x10(%rdx)
leaq 0x150(%rsp), %rcx
movq %rcx, 0x8(%rdx)
movabsq $0x3000000010, %rcx     # imm = 0x3000000010
movq %rcx, (%rdx)
movq %rax, %rdi
callq 0x1f520
testl %eax, %eax
js 0x621e5
testq %rbx, %rbx
leaq 0x3c43f(%rip), %rdi     # 0x9e5a0
cmovneq %rbx, %rdi
movaps 0x29a04(%rip), %xmm0    # 0x8bb70
leaq 0x70(%rsp), %rax
movaps %xmm0, 0x10(%rax)
movaps 0x299e4(%rip), %xmm0    # 0x8bb60
movaps %xmm0, (%rax)
movl $0x40, 0x18(%rsp)
movq 0x664132(%rip), %rcx    # 0x6c62c0
movq %rcx, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x10(%rsp), %rsi
movq %rsi, 0x30(%rsp)
movl $0x2, 0x38(%rsp)
movq %rax, 0x40(%rsp)
andq $0x0, 0x48(%rsp)
callq 0x63f23
movl %eax, 0xc(%rsp)
testl %eax, %eax
jns 0x62205
leaq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x6630
testl %eax, %eax
js 0x621ea
xorl %eax, %eax
cmpl $0x1, 0xc(%rsp)
sete %al
movl %eax, 0xc(%rsp)
jmp 0x62205
pushq $-0x1
popq %rax
jmp 0x62213
movq 0x10(%rsp), %rdi
callq 0x6ab0
leaq 0x1138c(%rip), %rdi     # 0x73587
callq 0x6ab0
andl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x61c0
movl 0xc(%rsp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: wm_filechooser
int wm_filechooser(const char *initialdir, const char *initialfile, const char *type, int foropen, char **choice)
{
#if defined __APPLE__ || defined HAVE_GTK
    int rv;
    if (mouseacquired && moustat) {
        SDL_SetRelativeMouseMode(SDL_FALSE);
    }
#if defined __APPLE__
    rv = wmosx_filechooser(initialdir, initialfile, type, foropen, choice);
#elif defined HAVE_GTK
    rv = wmgtk_filechooser(initialdir, initialfile, type, foropen, choice);
#endif
    SDL_RaiseWindow(sdl_window);
    if (mouseacquired && moustat) {
        SDL_SetRelativeMouseMode(SDL_TRUE);
    }
    return rv;
#else
    (void)initialdir; (void)initialfile; (void)type; (void)foropen; (void)choice;
#endif
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpb $0x0, 0x66408f(%rip)    # 0x6c62c8
je 0x6224b
testb $0x1, 0x664087(%rip)    # 0x6c62c9
je 0x6224b
xorl %edi, %edi
callq 0x6540
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %rbx, %r8
callq 0x63fa2
movl %eax, %ebx
movq 0x664059(%rip), %rdi    # 0x6c62c0
callq 0x6890
cmpb $0x0, 0x664055(%rip)    # 0x6c62c8
je 0x62286
testb $0x1, 0x66404d(%rip)    # 0x6c62c9
je 0x62286
pushq $0x1
popq %rdi
callq 0x6540
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: wm_setapptitle
void wm_setapptitle(const char *name)
{
	if (name) {
		Bstrncpy(apptitle, name, sizeof(apptitle)-1);
		apptitle[ sizeof(apptitle)-1 ] = 0;
	}
#if defined HAVE_GTK
	wmgtk_setapptitle(apptitle);
#endif
}

// Assembly:
testq %rdi, %rdi
je 0x622bb
pushq %rax
movq %rdi, %rsi
leaq 0x3c2fa(%rip), %rdi     # 0x9e5a0
movl $0xff, %edx
callq 0x6190
movb $0x0, 0x3c3e8(%rip)     # 0x9e69f
addq $0x8, %rsp
leaq 0x3c2de(%rip), %rdi     # 0x9e5a0
jmp 0x63e9c
// File: /workspace/github_c_makefile_star2_O2/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: wm_setwindowtitle
void wm_setwindowtitle(const char *name)
{
	if (name) {
		Bstrncpy(wintitle, name, sizeof(wintitle)-1);
		wintitle[ sizeof(wintitle)-1 ] = 0;
	}

	if (sdl_window) {
		SDL_SetWindowTitle(sdl_window, wintitle);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x622ec
pushq %rax
movq %rdi, %rsi
leaq 0x663ff9(%rip), %rdi    # 0x6c62d0
movl $0xff, %edx
callq 0x6190
movb $0x0, 0x6640e7(%rip)    # 0x6c63cf
addq $0x8, %rsp
movq 0x663fcd(%rip), %rdi    # 0x6c62c0
testq %rdi, %rdi
je 0x62304
leaq 0x663fd1(%rip), %rsi    # 0x6c62d0
jmp 0x61d0
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x10f90(%rip), %rdi     # 0x735c4
pushq $0x2
popq %r8
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x22427
leaq 0xa4(%rip), %rdi        # 0x626ed
callq 0x67570
leaq 0x10fc5(%rip), %rdi     # 0x7361a
callq 0x67f0
testq %rax, %rax
je 0x6267a
leaq 0x10fbf(%rip), %rdi     # 0x73625
callq 0x30c8d
leaq 0x114a76(%rip), %rax    # 0x1770e8
movl $0x1, (%rax)
jmp 0x626a7
leaq 0x10fb6(%rip), %rdi     # 0x73637
callq 0x67f0
movq %rax, %rdi
callq 0x6271a
leaq 0x114a53(%rip), %rcx    # 0x1770e8
movl %eax, (%rcx)
testl %eax, %eax
je 0x626a7
leaq 0x10fa1(%rip), %rdi     # 0x73643
callq 0x30c8d
leaq 0x10fd2(%rip), %rdi     # 0x73680
leaq 0x10fda(%rip), %rsi     # 0x7368f
leaq 0x97(%rip), %rdx        # 0x62753
callq 0x42c61
leaq 0x11020(%rip), %rdi     # 0x736e8
callq 0x67f0
testq %rax, %rax
je 0x626e5
leaq 0x11024(%rip), %rdi     # 0x736fd
callq 0x30c8d
movb $0x1, 0x663ceb(%rip)    # 0x6c63d0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x11246(%rip), %rsi     # 0x73970
cmovneq %rdi, %rsi
leaq 0x11251(%rip), %rdi     # 0x73986
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x22427
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_O2/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 0x11498d(%rip), %rax    # 0x1770e8
cmpl $0x0, (%rax)
je 0x62772
leaq 0x1122b(%rip), %rdi     # 0x73992
callq 0x30c8d
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
movl (%rdi), %eax
pushq $0x1
popq %rbx
cmpl $0x1, %eax
je 0x6279b
testl %eax, %eax
jne 0x6276e
leaq 0x3a8a1(%rip), %rax     # 0x9d028
movl (%rax), %esi
leaq 0x11224(%rip), %rdi     # 0x739b4
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x22427
jmp 0x6276e
movq 0x10(%rdi), %rax
movq (%rax), %rdi
callq 0x6310
leal -0x3(%rax), %ecx
cmpl $-0x4, %ecx
jb 0x6276e
movl %eax, %edi
callq 0x6580
testl %eax, %eax
js 0x627ca
callq 0x6600
leaq 0x3a862(%rip), %rcx     # 0x9d028
movl %eax, (%rcx)
jmp 0x6276c
callq 0x6b40
leaq 0x111f4(%rip), %rdi     # 0x739ca
xorl %ebx, %ebx
movq %rax, %rsi
xorl %eax, %eax
callq 0x22427
jmp 0x6276e
// File: /workspace/github_c_makefile_star2_O2/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: uninitinput
void uninitinput(void)
{
	uninitmouse();

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

// Assembly:
pushq %rax
callq 0x62805
movq 0x6657ef(%rip), %rdi    # 0x6c7fe0
testq %rdi, %rdi
je 0x62803
callq 0x6360
andq $0x0, 0x6657dd(%rip)    # 0x6c7fe0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x665837(%rip), %rdi    # 0x6c8068
testq %rdi, %rdi
je 0x62843
callq 0x61c0
andq $0x0, 0x665825(%rip)    # 0x6c8068
leaq 0x11489e(%rip), %rax    # 0x1770e8
cmpl $0x0, (%rax)
jne 0x6285b
leaq 0x6657d2(%rip), %rdi    # 0x6c8028
callq 0x4641a
cmpq $0x0, 0x6657bd(%rip)    # 0x6c8020
je 0x6287e
callq 0x46917
movq 0x6657af(%rip), %rdi    # 0x6c8020
callq 0x60d0
andq $0x0, 0x6657a2(%rip)    # 0x6c8020
movq 0x66578b(%rip), %rdi    # 0x6c8010
testq %rdi, %rdi
je 0x62897
callq 0x67d0
andq $0x0, 0x665779(%rip)    # 0x6c8010
movq 0x66576a(%rip), %rdi    # 0x6c8008
testq %rdi, %rdi
je 0x628b0
callq 0x6620
andq $0x0, 0x665758(%rip)    # 0x6c8008
movq 0x665761(%rip), %rdi    # 0x6c8018
testq %rdi, %rdi
je 0x628c9
callq 0x6350
andq $0x0, 0x66574f(%rip)    # 0x6c8018
movq 0x6639f0(%rip), %rdi    # 0x6c62c0
testq %rdi, %rdi
je 0x628e2
callq 0x65f0
andq $0x0, 0x6639de(%rip)    # 0x6c62c0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3a4cd(%rip), %rax     # 0x9d02c
cmpb $0x0, (%rax)
je 0x62b85
testb $0x1, 0x66375e(%rip)    # 0x6c62c9
je 0x62b85
movsbl 0x663754(%rip), %eax    # 0x6c62c8
cmpl %ebx, %eax
je 0x62b8b
xorl %edi, %edi
testl %ebx, %ebx
setne %dil
callq 0x6540
movb %bl, 0x66373d(%rip)     # 0x6c62c8
leaq 0x114546(%rip), %rax    # 0x1770d8
andl $0x0, (%rax)
leaq 0x114538(%rip), %rax    # 0x1770d4
andl $0x0, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x663720(%rip)    # 0x6c62c8
je 0x62bdb
leaq 0x3a47b(%rip), %rax     # 0x9d02c
cmpb $0x0, (%rax)
je 0x62bdb
testb $0x1, 0x66370c(%rip)    # 0x6c62c9
je 0x62bdb
leaq 0x11450e(%rip), %rax    # 0x1770d4
movl (%rax), %ecx
movl %ecx, (%rdi)
leaq 0x114507(%rip), %rcx    # 0x1770d8
movl (%rcx), %edx
movl %edx, (%rsi)
movq %rcx, %rsi
movq %rax, %rdi
andl $0x0, (%rsi)
andl $0x0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x6653c4(%rip)    # 0x6c7fe8
jne 0x62c77
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x10b99(%rip), %rdi     # 0x737ce
callq 0x30c8d
callq 0x6c30
movq %rax, 0x6653a2(%rip)    # 0x6c7fe8
movl %ebp, 0x6653a4(%rip)    # 0x6c7ff0
callq 0x62a0
movl 0x665399(%rip), %ecx    # 0x6c7ff0
imulq %rcx, %rax
xorl %edx, %edx
divq 0x665384(%rip)          # 0x6c7fe8
movl %eax, 0x66538a(%rip)    # 0x6c7ff4
movq %rbx, 0x665387(%rip)    # 0x6c7ff8
addq $0x8, %rsp
popq %rbx
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x665366(%rip)    # 0x6c7fe8
je 0x62cd3
pushq %rbx
callq 0x62a0
movl 0x665360(%rip), %ecx    # 0x6c7ff0
imulq %rcx, %rax
xorl %edx, %edx
divq 0x66534b(%rip)          # 0x6c7fe8
movl %eax, %ebx
subl 0x66534f(%rip), %ebx    # 0x6c7ff4
testl %ebx, %ebx
jle 0x62cd2
leaq 0x342838(%rip), %rcx    # 0x3a54e8
addl %ebx, (%rcx)
movl %eax, 0x66533c(%rip)    # 0x6c7ff4
cmpq $0x0, 0x665338(%rip)    # 0x6c7ff8
je 0x62cd2
callq *0x665330(%rip)         # 0x6c7ff8
leal -0x1(%rbx), %eax
cmpl $0x1, %ebx
movl %eax, %ebx
ja 0x62cc2
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x63068
retq
movzbl 0x8(%rdi), %eax
movzbl 0x8(%rsi), %ecx
subl %ecx, %eax
jne 0x63067
movl (%rdi), %eax
subl (%rsi), %eax
jne 0x63067
movl 0x4(%rdi), %eax
subl 0x4(%rsi), %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1136d9(%rip), %rax    # 0x1770e8
cmpl $0x0, (%rax)
jne 0x63a34
leaq 0x113689(%rip), %rax    # 0x1770a4
cmpl $0x8, (%rax)
jne 0x63a34
leaq 0x664601(%rip), %rdi    # 0x6c8028
movaps %xmm1, (%rsp)
callq 0x46513
movaps (%rsp), %xmm1
movq 0x662885(%rip), %rdi    # 0x6c62c0
testq %rdi, %rdi
je 0x63a65
xorps %xmm2, %xmm2
movaps %xmm1, %xmm0
cmpltss %xmm2, %xmm0
movss 0x8581(%rip), %xmm2     # 0x6bfd4
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_O2/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, 0x6641be(%rip)    # 0x6c8074
je 0x63f18
movq %rsi, %r9
movq %rdi, %r14
leaq 0x5c5f(%rip), %r8       # 0x69b24
pushq $0x2
popq %rsi
pushq $0x1
popq %rbx
xorl %edi, %edi
xorl %edx, %edx
movl %ebx, %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 0x63f1b
pushq $-0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x66414a(%rip)    # 0x6c8074
je 0x63f9e
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r9
movq %rdi, %rbx
leaq 0x5be7(%rip), %r8       # 0x69b24
pushq $0x2
popq %rsi
pushq $0x4
popq %rcx
xorl %edi, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0x6980
movq %rax, %r14
callq 0x6c40
movq %r14, %rdi
movq %rax, %rsi
callq 0x6140
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6210
callq 0x66c0
movq %r14, %rdi
movq %rax, %rsi
callq 0x6140
movq %rax, %rdi
callq 0x6270
movl %eax, %ebx
movq %r14, %rdi
callq 0x6180
xorl %eax, %eax
cmpl $-0x8, %ebx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
andq $0x0, (%r8)
cmpl $0x0, 0x6640b9(%rip)    # 0x6c8074
je 0x640ec
movq %r8, %rbx
movq %rdx, %r15
movq %rsi, %r12
xorl %edx, %edx
testl %ecx, %ecx
setne %bpl
sete %dl
leaq 0xfaee(%rip), %rax      # 0x73aca
leaq 0xfae1(%rip), %r9       # 0x73ac4
cmoveq %rax, %r9
leaq 0xfadd(%rip), %rax      # 0x73acb
leaq 0xfad0(%rip), %rdi      # 0x73ac5
cmoveq %rax, %rdi
andq $0x0, 0x8(%rsp)
movl $0xfffffffd, (%rsp)     # imm = 0xFFFFFFFD
leaq 0xfac3(%rip), %rcx      # 0x73ad0
pushq $-0x6
popq %r8
xorl %esi, %esi
xorl %eax, %eax
callq 0x6ba0
movq %rax, %r14
testq %r12, %r12
sete %al
orb %bpl, %al
jne 0x64043
callq 0x6830
movq %r14, %rdi
movq %rax, %rsi
callq 0x6140
movq %rax, %rdi
movq %r12, %rsi
callq 0x60e0
callq 0x6520
movq %rax, %r12
leaq 0xfa86(%rip), %rsi      # 0x73ad8
leaq 0x10(%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 0x640da
movq %r14, %rdi
movq %r15, %rsi
callq 0x6140
movq %rax, %rdi
callq 0x68a0
testq %rax, %rax
je 0x640da
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 0x640ef
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0x8(%rsp)
callq 0x68b0
movl %eax, 0x663f5e(%rip)    # 0x6c8074
testl %eax, %eax
je 0x6416c
callq 0x9ff0
leaq 0x6a39(%rip), %rdi      # 0x6ab5f
leaq 0x8(%rsp), %rsi
callq 0x6a30
testq %rax, %rax
je 0x64155
movq %rax, %rbx
movq %rax, %rdi
callq 0x69f0
pushq $0x50
popq %rsi
movq %rbx, %rdi
callq 0x6140
movq %rax, %rdi
callq 0x6aa0
jmp 0x6416c
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0xf978(%rip), %rdi      # 0x73add
xorl %eax, %eax
callq 0x22427
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %eax
movslq %edx, %r11
testl %esi, %esi
je 0x641ff
movl 0x663eb1(%rip), %ebx    # 0x6c80a8
movl 0x663eaf(%rip), %ebp    # 0x6c80ac
jmp 0x6421d
leaq 0x3aba4e(%rip), %rcx    # 0x40fc54
movl (%rcx), %ebx
movl %ebx, 0x663e9a(%rip)    # 0x6c80a8
leaq 0x3aba43(%rip), %rcx    # 0x40fc58
movl (%rcx), %ebp
movl %ebp, 0x663e8f(%rip)    # 0x6c80ac
addq 0x663e7c(%rip), %r11    # 0x6c80a0
movq 0x663e6d(%rip), %r14    # 0x6c8098
movl $0x20, %edx
movl %edx, %esi
subl 0x663e54(%rip), %esi    # 0x6c808c
movl 0x663e51(%rip), %r10d   # 0x6c8090
subl %r10d, %edx
testl %edi, %edi
js 0x64277
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 (%r14,%r12), %ecx
movb (%r11,%rcx), %cl
movb %cl, (%r9)
subl %ebx, %r8d
subl %ebp, %eax
decq %r9
decl %edi
jmp 0x64242
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %r12
leaq 0x3ab99c(%rip), %rax    # 0x40fc60
movl (%rax), %r13d
leaq 0x3ab986(%rip), %rax    # 0x40fc54
movl (%rax), %ebx
sarl $0x3, %ebx
testl %r14d, %r14d
jle 0x64346
movl %r13d, %edi
sarl $0x6, %edi
callq 0x33271
addl %ebx, %r13d
leaq 0x3e8807(%rip), %rcx    # 0x44caf4
movl (%rcx), %edx
imull %eax, %edx
addl %ebp, %edx
leaq 0x3e87fd(%rip), %rcx    # 0x44caf8
imull (%rcx), %eax
addl 0x4(%rsp), %eax
movb 0x663d83(%rip), %sil    # 0x6c808c
xorl %ecx, %ecx
subb %sil, %cl
shrl %cl, %edx
movq (%r15), %rsi
movq 0x663d7e(%rip), %rdi    # 0x6c8098
movb 0x663d70(%rip), %cl     # 0x6c8090
shll %cl, %edx
negb %cl
shrl %cl, %eax
addl %edx, %eax
movzbl (%rdi,%rax), %eax
movb (%rsi,%rax), %al
movb %al, (%r12)
addq $-0x8, %r15
movslq 0x663d72(%rip), %rax    # 0x6c80b0
addq %rax, %r12
decl %r14d
jmp 0x642d3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl %ecx, %eax
movq %r8, 0x663d33(%rip)     # 0x6c8098
movq %rsi, 0x663d4c(%rip)    # 0x6c80b8
movl 0x663d1e(%rip), %ecx    # 0x6c8090
movslq 0x663cff(%rip), %r10    # 0x6c8078
testl %edx, %edx
js 0x64398
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
jmp 0x64379
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl %ecx, %eax
movq %r8, 0x663cef(%rip)     # 0x6c8098
movq %rsi, 0x663d08(%rip)    # 0x6c80b8
movl 0x663cda(%rip), %ecx    # 0x6c8090
movslq 0x663cbb(%rip), %r10    # 0x6c8078
testl %edx, %edx
js 0x643e5
movl %eax, %r11d
shrq %cl, %r11
movzbl (%r8,%r11), %r11d
cmpq $0xff, %r11
je 0x643dc
movb (%rsi,%r11), %r11b
movb %r11b, (%r9)
addq %r10, %r9
addl %edi, %eax
decl %edx
jmp 0x643bd
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x663c9f(%rip)     # 0x6c8098
movq %rsi, 0x663cb8(%rip)    # 0x6c80b8
movl 0x663c8a(%rip), %ecx    # 0x6c8090
movq 0x663c73(%rip), %r10    # 0x6c8080
movslq 0x663c64(%rip), %r11    # 0x6c8078
cmpb $0x0, 0x663c6d(%rip)    # 0x6c8088
jne 0x64482
testl %edx, %edx
js 0x64486
movl %eax, %ebx
shrq %cl, %rbx
movzbl (%r8,%rbx), %ebx
cmpq $0xff, %rbx
je 0x6444a
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
jmp 0x6441d
movl %eax, %ebx
shrq %cl, %rbx
movzbl (%r8,%rbx), %ebx
cmpq $0xff, %rbx
je 0x6447b
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
jns 0x64453
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x663bf2(%rip)    # 0x6c8098
leaq 0x3ab7b3(%rip), %rax    # 0x40fc60
movq (%rax), %rbx
movq %rbx, 0x663c01(%rip)    # 0x6c80b8
sarl $0x10, %edx
movl $0x20, %eax
movl %eax, %r10d
subl 0x663bc3(%rip), %r10d   # 0x6c808c
movl 0x663bc0(%rip), %r11d   # 0x6c8090
subl %r11d, %eax
leaq 0x3ab77a(%rip), %r14    # 0x40fc54
leaq 0x3ab777(%rip), %r15    # 0x40fc58
testl %edx, %edx
jle 0x6451d
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 0x64510
movb (%rbx,%rcx), %cl
movb %cl, (%r9)
addl (%r14), %esi
addl (%r15), %r8d
incq %r9
decl %edx
jmp 0x644e1
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x663b54(%rip)    # 0x6c8098
leaq 0x3ab715(%rip), %rax    # 0x40fc60
movq (%rax), %rbx
movq %rbx, 0x663b63(%rip)    # 0x6c80b8
sarl $0x10, %edx
movl $0x20, %eax
movl %eax, %r10d
movl 0x663b29(%rip), %r11d   # 0x6c8090
subl %r11d, %eax
movq 0x663b0f(%rip), %r14    # 0x6c8080
subl 0x663b14(%rip), %r10d   # 0x6c808c
cmpb $0x0, 0x663b09(%rip)    # 0x6c8088
je 0x645df
leaq 0x3ab6cc(%rip), %r15    # 0x40fc54
leaq 0x3ab6c9(%rip), %r12    # 0x40fc58
testl %edx, %edx
jle 0x6463a
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 0x645d1
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
jmp 0x6458f
leaq 0x3ab66e(%rip), %r15    # 0x40fc54
leaq 0x3ab66b(%rip), %r12    # 0x40fc58
testl %edx, %edx
jle 0x6463a
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 0x6462c
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
jmp 0x645ed
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, 0x663a2e(%rip)    # 0x6c8098
movq 0x663a47(%rip), %rax    # 0x6c80b8
movl 0x663a18(%rip), %r9d    # 0x6c8090
movl 0x663a29(%rip), %r10d   # 0x6c80a8
movl 0x663a26(%rip), %r11d   # 0x6c80ac
movslq 0x6639eb(%rip), %rbx    # 0x6c8078
cmpl $0x2, %edx
jl 0x646c1
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
decl %edx
addl %r11d, %esi
addl %r10d, %edi
jmp 0x6468d
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, 0x6639ad(%rip)    # 0x6c8098
movl 0x66399f(%rip), %eax    # 0x6c8090
movq 0x6639c0(%rip), %r9     # 0x6c80b8
movl 0x6639a9(%rip), %r10d   # 0x6c80a8
movl 0x6639a6(%rip), %r11d   # 0x6c80ac
movslq 0x66396b(%rip), %rbx    # 0x6c8078
cmpl $0x2, %edx
jl 0x64749
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 0x6473c
movb (%r9,%r14), %bpl
movb %bpl, (%r8)
addq %rbx, %r8
decl %edx
addl %r11d, %esi
addl %r10d, %edi
jmp 0x6470d
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x663921(%rip)    # 0x6c8098
movl 0x663913(%rip), %eax    # 0x6c8090
movq 0x6638fc(%rip), %r9     # 0x6c8080
movq 0x66392d(%rip), %r10    # 0x6c80b8
movl 0x663916(%rip), %r11d   # 0x6c80a8
movl 0x663914(%rip), %ebx    # 0x6c80ac
movslq 0x6638d9(%rip), %r14    # 0x6c8078
cmpb $0x0, 0x6638e2(%rip)    # 0x6c8088
jne 0x6483f
cmpl $0x2, %edx
jl 0x64844
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 0x647ef
movzbl (%r8), %r12d
shll $0x8, %r12d
movzbl (%r10,%r15), %r15d
orq %r12, %r15
movb (%r9,%r15), %bpl
movb %bpl, (%r8)
addq %r14, %r8
decl %edx
addl %ebx, %esi
addl %r11d, %edi
jmp 0x647ac
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 0x64835
movzbl (%r8), %r12d
movzbl (%r10,%r15), %r15d
shll $0x8, %r15d
orq %r12, %r15
movb (%r9,%r15), %bpl
movb %bpl, (%r8)
addq %r14, %r8
decl %edx
addl %ebx, %esi
addl %r11d, %edi
cmpl $0x2, %edx
jge 0x647fb
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x663852(%rip), %rax    # 0x6c80b8
movslq 0x66380b(%rip), %r10    # 0x6c8078
xorl %r11d, %r11d
testl %edi, %edi
cmovlel %r11d, %edi
testl %edx, %edx
jle 0x648a6
movl %esi, %r11d
sarl $0x10, %r11d
movslq %r11d, %r11
xorl %ebx, %ebx
cmpq %rbx, %rdi
je 0x6489d
movzbl (%r8,%r11), %r14d
movb (%rax,%r14), %bpl
movb %bpl, (%r9,%rbx)
incq %rbx
jmp 0x64886
addq %r10, %r9
addl %ecx, %esi
decl %edx
jmp 0x64876
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x8
popq %rcx
leaq 0x6637e0(%rip), %rdx    # 0x6c80c0
cmpq $0x100, %rax            # imm = 0x100
je 0x64917
movl %ecx, %esi
movl %eax, %edi
testl %esi, %esi
je 0x6490f
movl %edi, %r8d
shrl %r8d
movl %r8d, %r9d
xorl $0xedb88320, %r9d       # imm = 0xEDB88320
testb $0x1, %dil
cmovel %r8d, %r9d
incl %esi
movl %r9d, %edi
jmp 0x648ec
movl %edi, (%rdx,%rax,4)
incq %rax
jmp 0x648e0
retq
// File: /workspace/github_c_makefile_star2_O2/jonof[P]jftekwar/jfbuild/src/crc32.c
// Function: crc32once
unsigned int crc32once(unsigned char *blk, unsigned int len)
{
	unsigned int crc;
	
	crc32init(&crc);
	crc32block(&crc, blk, len);
	return crc32finish(&crc);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %edx
movq %rdi, %rsi
leaq 0xc(%rsp), %rbx
orl $-0x1, (%rbx)
movq %rbx, %rdi
callq 0x64945
movl (%rbx), %eax
notl %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf1a2(%rip), %xmm0     # 0x73b24
movss 0xa97e(%rip), %xmm1     # 0x6f308
pushq $0xf
popq %rax
cmpq $0x10, %rcx
je 0x64a18
movzbl 0x3(%rdi,%rcx,4), %r8d
cvtsi2ss %r8d, %xmm2
mulss %xmm0, %xmm2
addss %xmm1, %xmm2
cvttss2si %xmm2, %r8d
cmpl %eax, %r8d
jl 0x649b7
movl %eax, %r8d
xorl %r9d, %r9d
testl %r8d, %r8d
jg 0x649c2
xorl %r8d, %r8d
movzbl 0x7(%rdi,%rcx,4), %r10d
cvtsi2ss %r10d, %xmm2
mulss %xmm0, %xmm2
addss %xmm1, %xmm2
cvttss2si %xmm2, %r10d
cmpl %eax, %r10d
jl 0x649e2
movl %eax, %r10d
testl %r10d, %r10d
jg 0x649ea
xorl %r10d, %r10d
btl %ecx, %esi
cmovael %r9d, %r8d
movl %esi, %r9d
shrl %cl, %r9d
shll $0x1e, %r9d
sarl $0x1f, %r9d
shll $0x4, %r10d
andl %r9d, %r10d
orl %r8d, %r10d
movb %r10b, (%rdx)
addq $0x2, %rcx
incq %rdx
jmp 0x6498d
retq
// File: /workspace/github_c_makefile_star2_O2/jonof[P]jftekwar/jfbuild/libsquish/alpha.cpp
// Function: squish::DecompressAlphaDxt3(unsigned char*, void const*)
void DecompressAlphaDxt3( u8* rgba, void const* block )
{
    u8 const* bytes = reinterpret_cast< u8 const* >( block );

    // unpack the alpha values pairwise
    for( int i = 0; i < 8; ++i )
    {
        // quantise down to 4 bits
        u8 quant = bytes[i];

        // unpack the values
        u8 lo = quant & 0x0f;
        u8 hi = quant & 0xf0;

        // convert back up to bytes
        rgba[8*i + 3] = lo | ( lo << 4 );
        rgba[8*i + 7] = hi | ( hi >> 4 );
    }
}

// Assembly:
xorl %eax, %eax
cmpq $0x8, %rax
je 0x64a4e
movb (%rsi,%rax), %cl
movl %ecx, %edx
andb $0xf, %dl
movl %ecx, %r8d
andb $-0x10, %r8b
movl %ecx, %r9d
shlb $0x4, %r9b
orb %dl, %r9b
movb %r9b, 0x3(%rdi,%rax,8)
shrb $0x4, %cl
orb %r8b, %cl
movb %cl, 0x7(%rdi,%rax,8)
incq %rax
jmp 0x64a1b
retq
// File: /workspace/github_c_makefile_star2_O2/jonof[P]jftekwar/jfbuild/libsquish/alpha.cpp
// Function: squish::FixRange(int&, int&, int)
static void FixRange( int& min, int& max, int steps )
{
    if( max - min < steps )
        max = std::min( min + steps, 255 );
    if( max - min < steps )
        min = std::max( 0, max - steps );
}

// Assembly:
movl (%rsi), %eax
movl (%rdi), %ecx
movl %eax, %r8d
subl %ecx, %r8d
cmpl %edx, %r8d
jge 0x64c98
addl %edx, %ecx
movl $0xff, %eax
cmpl %eax, %ecx
cmovgel %eax, %ecx
movl %ecx, (%rsi)
movl %ecx, %r8d
subl (%rdi), %r8d
movl %ecx, %eax
cmpl %edx, %r8d
jge 0x64ca8
subl %edx, %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
movl %ecx, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/jonof[P]jftekwar/jfbuild/libsquish/alpha.cpp
// Function: squish::DecompressAlphaDxt5(unsigned char*, void const*)
void DecompressAlphaDxt5( u8* rgba, void const* block )
{
    // get the two alpha values
    u8 const* bytes = reinterpret_cast< u8 const* >( block );
    int alpha0 = bytes[0];
    int alpha1 = bytes[1];

    // compare the values to build the codebook
    u8 codes[8];
    codes[0] = ( u8 )alpha0;
    codes[1] = ( u8 )alpha1;
    if( alpha0 <= alpha1 )
    {
        // use 5-alpha codebook
        for( int i = 1; i < 5; ++i )
            codes[1 + i] = ( u8 )( ( ( 5 - i )*alpha0 + i*alpha1 )/5 );
        codes[6] = 0;
        codes[7] = 255;
    }
    else
    {
        // use 7-alpha codebook
        for( int i = 1; i < 7; ++i )
            codes[1 + i] = ( u8 )( ( ( 7 - i )*alpha0 + i*alpha1 )/7 );
    }

    // decode the indices
    u8 indices[16];
    u8 const* src = bytes + 2;
    u8* dest = indices;
    for( int i = 0; i < 2; ++i )
    {
        // grab 3 bytes
        int value = 0;
        for( int j = 0; j < 3; ++j )
        {
            int byte = *src++;
            value |= ( byte << 8*j );
        }

        // unpack 8 3-bit values from it
        for( int j = 0; j < 8; ++j )
        {
            int index = ( value >> 3*j ) & 0x7;
            *dest++ = ( u8 )index;
        }
    }

    // write out the indexed codebook values
    for( int i = 0; i < 16; ++i )
        rgba[4*i + 3] = codes[indices[i]];
}

// Assembly:
movzbl (%rsi), %eax
movzbl 0x1(%rsi), %r8d
movb %al, -0x20(%rsp)
movb %r8b, -0x1f(%rsp)
cmpb %r8b, %al
jbe 0x64d55
imull $0x6, %eax, %ecx
addl %r8d, %ecx
subl %eax, %r8d
movabsq $0x2, %r9
movl $0x7, %r10d
cmpq $0x8, %r9
je 0x64d86
movl %ecx, %eax
xorl %edx, %edx
divl %r10d
movb %al, -0x20(%rsp,%r9)
incq %r9
addl %r8d, %ecx
jmp 0x64d3b
leal (%r8,%rax,4), %ecx
subl %eax, %r8d
xorl %r9d, %r9d
movl $0x5, %r10d
cmpq $0x4, %r9
je 0x64d7f
movl %ecx, %eax
xorl %edx, %edx
divl %r10d
movb %al, -0x1e(%rsp,%r9)
incq %r9
addl %r8d, %ecx
jmp 0x64d65
movw $0xff00, -0x1a(%rsp)    # imm = 0xFF00
addq $0x2, %rsi
xorl %eax, %eax
leaq -0x18(%rsp), %rdx
cmpl $0x2, %eax
je 0x64dd9
xorl %ecx, %ecx
movq %rsi, %r9
xorl %r8d, %r8d
cmpl $0x18, %ecx
je 0x64db5
movzbl (%r9), %r10d
shll %cl, %r10d
incq %r9
orl %r10d, %r8d
addl $0x8, %ecx
jmp 0x64d9e
xorl %ecx, %ecx
cmpl $0x18, %ecx
je 0x64dd1
movl %r8d, %r9d
sarl %cl, %r9d
andb $0x7, %r9b
movb %r9b, (%rdx)
incq %rdx
addl $0x3, %ecx
jmp 0x64db7
addq $0x3, %rsi
incl %eax
jmp 0x64d91
xorl %eax, %eax
cmpq $0x10, %rax
je 0x64df3
movzbl -0x18(%rsp,%rax), %ecx
movb -0x20(%rsp,%rcx), %cl
movb %cl, 0x3(%rdi,%rax,4)
incq %rax
jmp 0x64ddb
retq