LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0x61a46c(%rip)    # 0x6c2040
leaq 0x3a9de5(%rip), %rax    # 0x4519c0
movq (%rax), %rax
movq %rax, 0x61a47b(%rip)    # 0x6c2060
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x10(%rbp), %eax
sarl $0x10, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0xa7c96
movq 0x61a439(%rip), %rax    # 0x6c2040
movl -0xc(%rbp), %edx
movl $0x20, %ecx
subl 0x61a41f(%rip), %ecx    # 0x6c2034
shrl %cl, %edx
movl 0x61a41b(%rip), %ecx    # 0x6c2038
shll %cl, %edx
movl %edx, -0x34(%rbp)
movl -0x18(%rbp), %edx
movl $0x20, %ecx
subl 0x61a408(%rip), %ecx    # 0x6c2038
shrl %cl, %edx
movl -0x34(%rbp), %ecx
addl %edx, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0xff, %eax
je 0xa7c5e
movq 0x61a40f(%rip), %rax    # 0x6c2060
movzbl -0x21(%rbp), %ecx
movb (%rax,%rcx), %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
leaq 0x3a9d4f(%rip), %rax    # 0x4519b4
movl (%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
leaq 0x3a9d44(%rip), %rax    # 0x4519b8
movl (%rax), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xa7bf6
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/a-c.c
// Function: setupspritevline
void setupspritevline(void *paloffs, int bxinc, int byinc, int ysiz)
{
	gpal = (unsigned char *)paloffs;
	gbxinc = bxinc;
	gbyinc = byinc;
	glogy = ysiz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0x61a1a4(%rip)    # 0x6c2060
movl -0xc(%rbp), %eax
movl %eax, 0x61a18b(%rip)    # 0x6c2050
movl -0x10(%rbp), %eax
movl %eax, 0x61a186(%rip)    # 0x6c2054
movl -0x14(%rbp), %eax
movl %eax, 0x61a161(%rip)    # 0x6c2038
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x61a140(%rip)    # 0x6c2040
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x1, -0xc(%rbp)
jle 0xa7f78
movq 0x61a14b(%rip), %rax    # 0x6c2060
movq 0x61a124(%rip), %rcx    # 0x6c2040
movl -0x4(%rbp), %edx
sarl $0x10, %edx
imull 0x61a10f(%rip), %edx    # 0x6c2038
movl -0x8(%rbp), %esi
sarl $0x10, %esi
addl %esi, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
movb (%rax,%rcx), %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movl 0x61a109(%rip), %eax    # 0x6c2050
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl 0x61a101(%rip), %eax    # 0x6c2054
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl 0x61a0c1(%rip), %ecx    # 0x6c2020
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa7f08
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x61a060(%rip)    # 0x6c2040
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x1, -0xc(%rbp)
jle 0xa806c
movq 0x61a04b(%rip), %rax    # 0x6c2040
movl -0x4(%rbp), %ecx
sarl $0x10, %ecx
imull 0x61a036(%rip), %ecx    # 0x6c2038
movl -0x8(%rbp), %edx
sarl $0x10, %edx
addl %edx, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0xff, %eax
je 0xa8032
movq 0x61a03b(%rip), %rax    # 0x6c2060
movzbl -0x21(%rbp), %ecx
movb (%rax,%rcx), %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movl 0x61a018(%rip), %eax    # 0x6c2050
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl 0x61a010(%rip), %eax    # 0x6c2054
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl 0x619fd0(%rip), %ecx    # 0x6c2020
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa7fe8
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x619f70(%rip)    # 0x6c2040
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, 0x619f51(%rip)    # 0x6c2030
je 0xa818e
jmp 0xa80e7
cmpl $0x1, -0xc(%rbp)
jle 0xa8189
movq 0x619f48(%rip), %rax    # 0x6c2040
movl -0x4(%rbp), %ecx
sarl $0x10, %ecx
imull 0x619f33(%rip), %ecx    # 0x6c2038
movl -0x8(%rbp), %edx
sarl $0x10, %edx
addl %edx, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0xff, %eax
je 0xa814f
movq 0x619f00(%rip), %rax    # 0x6c2028
movq -0x30(%rbp), %rcx
movzbl (%rcx), %ecx
movq 0x619f2a(%rip), %rdx    # 0x6c2060
movzbl -0x21(%rbp), %esi
movzbl (%rdx,%rsi), %edx
shll $0x8, %edx
addl %edx, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movl 0x619efb(%rip), %eax    # 0x6c2050
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl 0x619ef3(%rip), %eax    # 0x6c2054
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl 0x619eb3(%rip), %ecx    # 0x6c2020
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa80e7
jmp 0xa8234
jmp 0xa8190
cmpl $0x1, -0xc(%rbp)
jle 0xa8232
movq 0x619e9f(%rip), %rax    # 0x6c2040
movl -0x4(%rbp), %ecx
sarl $0x10, %ecx
imull 0x619e8a(%rip), %ecx    # 0x6c2038
movl -0x8(%rbp), %edx
sarl $0x10, %edx
addl %edx, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0xff, %eax
je 0xa81f8
movq 0x619e57(%rip), %rax    # 0x6c2028
movq -0x30(%rbp), %rcx
movzbl (%rcx), %ecx
shll $0x8, %ecx
movq 0x619e7e(%rip), %rdx    # 0x6c2060
movzbl -0x21(%rbp), %esi
movzbl (%rdx,%rsi), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movl 0x619e52(%rip), %eax    # 0x6c2050
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl 0x619e4a(%rip), %eax    # 0x6c2054
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl 0x619e0a(%rip), %ecx    # 0x6c2020
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa8190
jmp 0xa8234
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0xa8309
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xa82e1
movq 0x619dac(%rip), %rax    # 0x6c2060
movq -0x38(%rbp), %rcx
movl -0x8(%rbp), %edx
sarl $0x10, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa82a5
movl 0x619d39(%rip), %ecx    # 0x6c2020
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x10(%rbp), %eax
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa8298
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/a-c.c
// Function: stretchhline
void stretchhline (void *p0, int u, int cnt, int uinc, void *rptr, void *p)
{
	unsigned char *pp, *rpptr, *np;
	(void)p0;

	rpptr = (unsigned char *)rptr;
	pp = (unsigned char *)p;
	np = (unsigned char *)((intptr_t)p-(cnt<<2));
	do
	{
		pp--;
		*pp = *(rpptr+(u>>16)); u -= uinc;
	} while (pp > np);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl -0x10(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movl -0xc(%rbp), %ecx
sarl $0x10, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movl -0x14(%rbp), %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x40(%rbp), %rax
ja 0xa834d
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jae 0xa8426
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl $0x8, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xa8409
movl -0x8(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xa83ec
movl -0x8(%rbp), %eax
shrl %eax
movl %eax, %eax
movabsq $0xedb88320, %rcx       # imm = 0xEDB88320
xorq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0xa83f7
movl -0x8(%rbp), %eax
shrl %eax
movl %eax, %eax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa83c1
movl -0x8(%rbp), %edx
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x619c58(%rip), %rax    # 0x6c2070
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xa83ab
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
cmpl $0x8, 0x24(%rsp)
jge 0xa8656
movq 0x40(%rsp), %rax
movl 0x24(%rsp), %ecx
shll $0x3, %ecx
movslq %ecx, %rcx
movzbl 0x3(%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movss 0x124f1(%rip), %xmm1    # 0xbaa70
mulss %xmm1, %xmm0
movss %xmm0, 0x20(%rsp)
movq 0x40(%rsp), %rax
movl 0x24(%rsp), %ecx
shll $0x3, %ecx
movslq %ecx, %rcx
movzbl 0x7(%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movss 0x124c7(%rip), %xmm1    # 0xbaa70
mulss %xmm1, %xmm0
movss %xmm0, 0x1c(%rsp)
movss 0x20(%rsp), %xmm0
movl $0xf, %edi
callq 0xa8660
movl %eax, 0x18(%rsp)
movss 0x1c(%rsp), %xmm0
movl $0xf, %edi
callq 0xa8660
movl %eax, 0x14(%rsp)
movl 0x24(%rsp), %ecx
shll %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x10(%rsp)
movl 0x24(%rsp), %ecx
shll %ecx
addl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0xc(%rsp)
movl 0x3c(%rsp), %eax
andl 0x10(%rsp), %eax
cmpl $0x0, %eax
jne 0xa8615
movl $0x0, 0x18(%rsp)
movl 0x3c(%rsp), %eax
andl 0xc(%rsp), %eax
cmpl $0x0, %eax
jne 0xa862a
movl $0x0, 0x14(%rsp)
movl 0x18(%rsp), %eax
movl 0x14(%rsp), %ecx
shll $0x4, %ecx
orl %ecx, %eax
movb %al, %dl
movq 0x28(%rsp), %rax
movslq 0x24(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xa8554
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/alpha.cpp
// Function: squish::FloatToInt(float, int)
static int FloatToInt( float a, int limit )
{
    // use ANSI round-to-zero behaviour to get round-to-nearest
    int i = ( int )( a + 0.5f );

    // clamp to the limit
    if( i < 0 )
        i = 0;
    else if( i > limit )
        i = limit;

    // done
    return i;
}

// Assembly:
movss %xmm0, -0x4(%rsp)
movl %edi, -0x8(%rsp)
movss 0xdf56(%rip), %xmm0     # 0xb65c8
addss -0x4(%rsp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0xc(%rsp)
cmpl $0x0, -0xc(%rsp)
jge 0xa8691
movl $0x0, -0xc(%rsp)
jmp 0xa86a5
movl -0xc(%rsp), %eax
cmpl -0x8(%rsp), %eax
jle 0xa86a3
movl -0x8(%rsp), %eax
movl %eax, -0xc(%rsp)
jmp 0xa86a5
movl -0xc(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
cmpl $0x8, -0x1c(%rsp)
jge 0xa875e
movq -0x18(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1d(%rsp)
movzbl -0x1d(%rsp), %eax
andl $0xf, %eax
movb %al, -0x1e(%rsp)
movzbl -0x1d(%rsp), %eax
andl $0xf0, %eax
movb %al, -0x1f(%rsp)
movzbl -0x1e(%rsp), %eax
movzbl -0x1e(%rsp), %ecx
shll $0x4, %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
shll $0x3, %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movzbl -0x1f(%rsp), %eax
movzbl -0x1f(%rsp), %ecx
sarl $0x4, %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
shll $0x3, %ecx
addl $0x7, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0xa86cc
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq 0x20(%rsp), %rcx
subl (%rcx), %eax
cmpl 0x14(%rsp), %eax
jge 0xa8a35
movq 0x20(%rsp), %rax
movl (%rax), %eax
addl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
movl $0xff, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0xa4410
movl (%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq 0x20(%rsp), %rcx
subl (%rcx), %eax
cmpl 0x14(%rsp), %eax
jge 0xa8a78
movl $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
subl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0xa9080
movl (%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/alpha.cpp
// Function: squish::FitCodes(unsigned char const*, int, unsigned char const*, unsigned char*)
static int FitCodes( u8 const* rgba, int mask, u8 const* codes, u8* indices )
{
    // fit each alpha value to the codebook
    int err = 0;
    for( int i = 0; i < 16; ++i )
    {
        // check this pixel is valid
        int bit = 1 << i;
        if( ( mask & bit ) == 0 )
        {
            // use the first code
            indices[i] = 0;
            continue;
        }

        // find the least error and corresponding index
        int value = rgba[4*i + 3];
        int least = INT_MAX;
        int index = 0;
        for( int j = 0; j < 8; ++j )
        {
            // get the squared error from this code
            int dist = ( int )value - ( int )codes[j];
            dist *= dist;

            // compare with the best so far
            if( dist < least )
            {
                least = dist;
                index = j;
            }
        }

        // save this index and accumulate the error
        indices[i] = ( u8 )index;
        err += least;
    }

    // return the total error
    return err;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movl $0x0, -0x28(%rsp)
cmpl $0x10, -0x28(%rsp)
jge 0xa8b93
movl -0x28(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x2c(%rsp)
movl -0xc(%rsp), %eax
andl -0x2c(%rsp), %eax
cmpl $0x0, %eax
jne 0xa8add
movq -0x20(%rsp), %rax
movslq -0x28(%rsp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0xa8b83
movq -0x8(%rsp), %rax
movl -0x28(%rsp), %ecx
shll $0x2, %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x30(%rsp)
movl $0x7fffffff, -0x34(%rsp) # imm = 0x7FFFFFFF
movl $0x0, -0x38(%rsp)
movl $0x0, -0x3c(%rsp)
cmpl $0x8, -0x3c(%rsp)
jge 0xa8b64
movl -0x30(%rsp), %eax
movq -0x18(%rsp), %rcx
movslq -0x3c(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x40(%rsp)
movl -0x40(%rsp), %eax
imull -0x40(%rsp), %eax
movl %eax, -0x40(%rsp)
movl -0x40(%rsp), %eax
cmpl -0x34(%rsp), %eax
jge 0xa8b55
movl -0x40(%rsp), %eax
movl %eax, -0x34(%rsp)
movl -0x3c(%rsp), %eax
movl %eax, -0x38(%rsp)
jmp 0xa8b57
movl -0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rsp)
jmp 0xa8b0f
movl -0x38(%rsp), %eax
movb %al, %dl
movq -0x20(%rsp), %rax
movslq -0x28(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl -0x34(%rsp), %eax
addl -0x24(%rsp), %eax
movl %eax, -0x24(%rsp)
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0xa8aa3
movl -0x24(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/alpha.cpp
// Function: squish::WriteAlphaBlock5(int, int, unsigned char const*, void*)
static void WriteAlphaBlock5( int alpha0, int alpha1, u8 const* indices, void* block )
{
    // check the relative values of the endpoints
    if( alpha0 > alpha1 )
    {
        // swap the indices
        u8 swapped[16];
        for( int i = 0; i < 16; ++i )
        {
            u8 index = indices[i];
            if( index == 0 )
                swapped[i] = 1;
            else if( index == 1 )
                swapped[i] = 0;
            else if( index <= 5 )
                swapped[i] = 7 - index;
            else
                swapped[i] = index;
        }

        // write the block
        WriteAlphaBlock( alpha1, alpha0, swapped, block );
    }
    else
    {
        // write the block
        WriteAlphaBlock( alpha0, alpha1, indices, block );
    }
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl %esi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x30(%rsp), %eax
jle 0xa8c73
movl $0x0, 0xc(%rsp)
cmpl $0x10, 0xc(%rsp)
jge 0xa8c5a
movq 0x28(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0xb(%rsp)
movzbl 0xb(%rsp), %eax
cmpl $0x0, %eax
jne 0xa8bfe
movslq 0xc(%rsp), %rax
movb $0x1, 0x10(%rsp,%rax)
jmp 0xa8c48
movzbl 0xb(%rsp), %eax
cmpl $0x1, %eax
jne 0xa8c14
movslq 0xc(%rsp), %rax
movb $0x0, 0x10(%rsp,%rax)
jmp 0xa8c46
movzbl 0xb(%rsp), %eax
cmpl $0x5, %eax
jg 0xa8c37
movzbl 0xb(%rsp), %ecx
movl $0x7, %eax
subl %ecx, %eax
movb %al, %cl
movslq 0xc(%rsp), %rax
movb %cl, 0x10(%rsp,%rax)
jmp 0xa8c44
movb 0xb(%rsp), %cl
movslq 0xc(%rsp), %rax
movb %cl, 0x10(%rsp,%rax)
jmp 0xa8c46
jmp 0xa8c48
jmp 0xa8c4a
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xa8bcc
movl 0x30(%rsp), %edi
movl 0x34(%rsp), %esi
leaq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0xa8f70
jmp 0xa8c8a
movl 0x34(%rsp), %edi
movl 0x30(%rsp), %esi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0xa8f70
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/alpha.cpp
// Function: squish::WriteAlphaBlock(int, int, unsigned char const*, void*)
static void WriteAlphaBlock( int alpha0, int alpha1, u8 const* indices, void* block )
{
    u8* bytes = reinterpret_cast< u8* >( block );

    // write the first two bytes
    bytes[0] = ( u8 )alpha0;
    bytes[1] = ( u8 )alpha1;

    // pack the indices with 3 bits each
    u8* dest = bytes + 2;
    u8 const* src = indices;
    for( int i = 0; i < 2; ++i )
    {
        // pack 8 3-bit values
        int value = 0;
        for( int j = 0; j < 8; ++j )
        {
            int index = *src++;
            value |= ( index << 3*j );
        }

        // store in 3 bytes
        for( int j = 0; j < 3; ++j )
        {
            int byte = ( value >> 8*j ) & 0xff;
            *dest++ = ( u8 )byte;
        }
    }
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movq %rdx, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movl -0x4(%rsp), %eax
movb %al, %cl
movq -0x20(%rsp), %rax
movb %cl, (%rax)
movl -0x8(%rsp), %eax
movb %al, %cl
movq -0x20(%rsp), %rax
movb %cl, 0x1(%rax)
movq -0x20(%rsp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x30(%rsp)
movl $0x0, -0x34(%rsp)
cmpl $0x2, -0x34(%rsp)
jge 0xa907e
movl $0x0, -0x38(%rsp)
movl $0x0, -0x3c(%rsp)
cmpl $0x8, -0x3c(%rsp)
jge 0xa9021
movq -0x30(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rsp)
movzbl (%rax), %eax
movl %eax, -0x40(%rsp)
movl -0x40(%rsp), %eax
imull $0x3, -0x3c(%rsp), %ecx
shll %cl, %eax
orl -0x38(%rsp), %eax
movl %eax, -0x38(%rsp)
movl -0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rsp)
jmp 0xa8fe2
movl $0x0, -0x44(%rsp)
cmpl $0x3, -0x44(%rsp)
jge 0xa906c
movl -0x38(%rsp), %eax
movl -0x44(%rsp), %ecx
shll $0x3, %ecx
sarl %cl, %eax
andl $0xff, %eax
movl %eax, -0x48(%rsp)
movl -0x48(%rsp), %eax
movb %al, %cl
movq -0x28(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rsp)
movb %cl, (%rax)
movl -0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rsp)
jmp 0xa9029
jmp 0xa906e
movl -0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rsp)
jmp 0xa8fc7
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/simd_float.h
// Function: squish::Vec4::operator+=(squish::Vec4 const&)
Vec4& operator+=( Arg v )
    {
        m_x += v.m_x;
        m_y += v.m_y;
        m_z += v.m_z;
        m_w += v.m_w;
        return *this;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movss (%rcx), %xmm0
addss (%rax), %xmm0
movss %xmm0, (%rax)
movq -0x10(%rsp), %rcx
movss 0x4(%rcx), %xmm0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x4(%rax)
movq -0x10(%rsp), %rcx
movss 0x8(%rcx), %xmm0
addss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rcx
movss 0xc(%rcx), %xmm0
addss 0xc(%rax), %xmm0
movss %xmm0, 0xc(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/simd_float.h
// Function: squish::Reciprocal(squish::Vec4 const&)
Vec4 Reciprocal( Vec4::Arg v )
    {
        return Vec4(
            1.0f/v.m_x,
            1.0f/v.m_y,
            1.0f/v.m_z,
            1.0f/v.m_w
        );
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, (%rsp)
movq (%rsp), %rax
movss (%rax), %xmm1
movss 0x4(%rax), %xmm2
movss 0x76f3(%rip), %xmm3     # 0xb2e00
movaps %xmm3, %xmm0
divss %xmm1, %xmm0
movaps %xmm3, %xmm1
divss %xmm2, %xmm1
movss 0x8(%rax), %xmm4
movaps %xmm3, %xmm2
divss %xmm4, %xmm2
movss 0xc(%rax), %xmm4
divss %xmm4, %xmm3
leaq 0x8(%rsp), %rdi
callq 0xab3c0
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/simd_float.h
// Function: squish::Min(squish::Vec4 const&, squish::Vec4 const&)
Vec4 Min( Vec4::Arg left, Vec4::Arg right )
    {
        return Vec4(
            std::min( left.m_x, right.m_x ),
            std::min( left.m_y, right.m_y ),
            std::min( left.m_z, right.m_z ),
            std::min( left.m_w, right.m_w )
        );
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xabd50
movss (%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x20(%rsp), %rdi
addq $0x4, %rdi
movq 0x18(%rsp), %rsi
addq $0x4, %rsi
callq 0xabd50
movss (%rax), %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
callq 0xabd50
movss (%rax), %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x20(%rsp), %rdi
addq $0xc, %rdi
movq 0x18(%rsp), %rsi
addq $0xc, %rsi
callq 0xabd50
movss 0xc(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
movss 0x14(%rsp), %xmm2
movss (%rax), %xmm3
leaq 0x28(%rsp), %rdi
callq 0xab3c0
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/simd_float.h
// Function: squish::Max(squish::Vec4 const&, squish::Vec4 const&)
Vec4 Max( Vec4::Arg left, Vec4::Arg right )
    {
        return Vec4(
            std::max( left.m_x, right.m_x ),
            std::max( left.m_y, right.m_y ),
            std::max( left.m_z, right.m_z ),
            std::max( left.m_w, right.m_w )
        );
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xabd90
movss (%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x20(%rsp), %rdi
addq $0x4, %rdi
movq 0x18(%rsp), %rsi
addq $0x4, %rsi
callq 0xabd90
movss (%rax), %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
callq 0xabd90
movss (%rax), %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x20(%rsp), %rdi
addq $0xc, %rdi
movq 0x18(%rsp), %rsi
addq $0xc, %rsi
callq 0xabd90
movss 0xc(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
movss 0x14(%rsp), %xmm2
movss (%rax), %xmm3
leaq 0x28(%rsp), %rdi
callq 0xab3c0
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xab970
movq 0x20(%rsp), %rax
movss (%rax), %xmm0
callq 0xabdd0
movss %xmm0, 0x1c(%rsp)
jmp 0xab984
movq 0x20(%rsp), %rax
movss (%rax), %xmm0
callq 0xabdf0
movss %xmm0, 0x1c(%rsp)
movss 0x1c(%rsp), %xmm0
movss %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movss 0x4(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xab9b9
movq 0x20(%rsp), %rax
movss 0x4(%rax), %xmm0
callq 0xabdd0
movss %xmm0, 0x14(%rsp)
jmp 0xab9ce
movq 0x20(%rsp), %rax
movss 0x4(%rax), %xmm0
callq 0xabdf0
movss %xmm0, 0x14(%rsp)
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movss 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xaba03
movq 0x20(%rsp), %rax
movss 0x8(%rax), %xmm0
callq 0xabdd0
movss %xmm0, 0xc(%rsp)
jmp 0xaba18
movq 0x20(%rsp), %rax
movss 0x8(%rax), %xmm0
callq 0xabdf0
movss %xmm0, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movss 0xc(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xaba4d
movq 0x20(%rsp), %rax
movss 0xc(%rax), %xmm0
callq 0xabdd0
movss %xmm0, 0x4(%rsp)
jmp 0xaba62
movq 0x20(%rsp), %rax
movss 0xc(%rax), %xmm0
callq 0xabdf0
movss %xmm0, 0x4(%rsp)
movss 0x8(%rsp), %xmm2
movss 0x10(%rsp), %xmm1
movss 0x18(%rsp), %xmm0
movss 0x4(%rsp), %xmm3
leaq 0x28(%rsp), %rdi
callq 0xab3c0
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/simd_float.h
// Function: squish::CompareAnyLessThan(squish::Vec4 const&, squish::Vec4 const&)
bool CompareAnyLessThan( Vec4::Arg left, Vec4::Arg right )
    {
        return left.m_x < right.m_x
            || left.m_y < right.m_y
            || left.m_z < right.m_z
            || left.m_w < right.m_w;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movss (%rax), %xmm1
movq -0x10(%rsp), %rax
movss (%rax), %xmm0
movb $0x1, %al
ucomiss %xmm1, %xmm0
movb %al, -0x11(%rsp)
ja 0xabbf3
movq -0x8(%rsp), %rax
movss 0x4(%rax), %xmm1
movq -0x10(%rsp), %rax
movss 0x4(%rax), %xmm0
movb $0x1, %al
ucomiss %xmm1, %xmm0
movb %al, -0x11(%rsp)
ja 0xabbf3
movq -0x8(%rsp), %rax
movss 0x8(%rax), %xmm1
movq -0x10(%rsp), %rax
movss 0x8(%rax), %xmm0
movb $0x1, %al
ucomiss %xmm1, %xmm0
movb %al, -0x11(%rsp)
ja 0xabbf3
movq -0x8(%rsp), %rax
movss 0xc(%rax), %xmm1
movq -0x10(%rsp), %rax
movss 0xc(%rax), %xmm0
ucomiss %xmm1, %xmm0
seta %al
movb %al, -0x11(%rsp)
movb -0x11(%rsp), %al
andb $0x1, %al
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0xabf70
movl %eax, 0x24(%rsp)
movq 0x38(%rsp), %rdi
callq 0xabf70
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
jg 0xabec5
movl $0x0, 0xc(%rsp)
cmpl $0x10, 0xc(%rsp)
jge 0xabec0
movq 0x30(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb (%rax,%rcx), %cl
movslq 0xc(%rsp), %rax
movb %cl, 0x10(%rsp,%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xabe96
jmp 0xabf4a
leaq 0x24(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xac580
movl $0x0, 0x8(%rsp)
cmpl $0x10, 0x8(%rsp)
jge 0xabf48
movq 0x30(%rsp), %rax
movslq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xabf02
movslq 0x8(%rsp), %rax
movb $0x1, 0x10(%rsp,%rax)
jmp 0xabf39
movq 0x30(%rsp), %rax
movslq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x1, %eax
jne 0xabf21
movslq 0x8(%rsp), %rax
movb $0x0, 0x10(%rsp,%rax)
jmp 0xabf37
movq 0x30(%rsp), %rax
movslq 0x8(%rsp), %rcx
movb (%rax,%rcx), %cl
movslq 0x8(%rsp), %rax
movb %cl, 0x10(%rsp,%rax)
jmp 0xabf39
jmp 0xabf3b
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xabedc
jmp 0xabf4a
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
leaq 0x10(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0xac010
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/colourblock.cpp
// Function: squish::FloatTo565(squish::Vec3 const&)
static int FloatTo565( Vec3::Arg colour )
{
    // get the components in the correct range
    int r = FloatToInt( 31.0f*colour.X(), 31 );
    int g = FloatToInt( 63.0f*colour.Y(), 63 );
    int b = FloatToInt( 31.0f*colour.Z(), 31 );

    // pack into a single value
    return ( r << 11 ) | ( g << 5 ) | b;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xab550
movaps %xmm0, %xmm1
movss 0xeaf2(%rip), %xmm0     # 0xbaa80
mulss %xmm1, %xmm0
movl $0x1f, %edi
callq 0xac530
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0xab560
movaps %xmm0, %xmm1
movss 0xa62b(%rip), %xmm0     # 0xb65e0
mulss %xmm1, %xmm0
movl $0x3f, %edi
callq 0xac530
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xab570
movaps %xmm0, %xmm1
movss 0xeaa4(%rip), %xmm0     # 0xbaa80
mulss %xmm1, %xmm0
movl $0x1f, %edi
callq 0xac530
movl %eax, 0x4(%rsp)
movl 0xc(%rsp), %eax
shll $0xb, %eax
movl 0x8(%rsp), %ecx
shll $0x5, %ecx
orl %ecx, %eax
orl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movq %rdx, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movl -0x4(%rsp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rsp), %rax
movb %cl, (%rax)
movl -0x4(%rsp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rsp), %rax
movb %cl, 0x1(%rax)
movl -0x8(%rsp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rsp), %rax
movb %cl, 0x2(%rax)
movl -0x8(%rsp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rsp), %rax
movb %cl, 0x3(%rax)
movl $0x0, -0x24(%rsp)
cmpl $0x4, -0x24(%rsp)
jge 0xac0ec
movq -0x10(%rsp), %rax
movl -0x24(%rsp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
movzbl (%rax), %eax
movq -0x30(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x2, %ecx
orl %ecx, %eax
movq -0x30(%rsp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x4, %ecx
orl %ecx, %eax
movq -0x30(%rsp), %rcx
movzbl 0x3(%rcx), %ecx
shll $0x6, %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x20(%rsp), %rax
movl -0x24(%rsp), %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0xac07b
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0xabf70
movl %eax, 0x24(%rsp)
movq 0x38(%rsp), %rdi
callq 0xabf70
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0xac17a
leaq 0x24(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xac580
movl $0x0, 0xc(%rsp)
cmpl $0x10, 0xc(%rsp)
jge 0xac178
movq 0x30(%rsp), %rax
movslq 0xc(%rsp), %rcx
movzbl (%rax,%rcx), %eax
xorl $0x1, %eax
andl $0x3, %eax
movb %al, %cl
movslq 0xc(%rsp), %rax
movb %cl, 0x10(%rsp,%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xac145
jmp 0xac1e2
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
jne 0xac1ac
movl $0x0, 0x8(%rsp)
cmpl $0x10, 0x8(%rsp)
jge 0xac1aa
movslq 0x8(%rsp), %rax
movb $0x0, 0x10(%rsp,%rax)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xac18c
jmp 0xac1e0
movl $0x0, 0x4(%rsp)
cmpl $0x10, 0x4(%rsp)
jge 0xac1de
movq 0x30(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb (%rax,%rcx), %cl
movslq 0x4(%rsp), %rax
movb %cl, 0x10(%rsp,%rax)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xac1b4
jmp 0xac1e0
jmp 0xac1e2
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
leaq 0x10(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0xac010
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/colourblock.cpp
// Function: squish::Unpack565(unsigned char const*, unsigned char*)
static int Unpack565( u8 const* packed, u8* colour )
{
    // build the packed value
    int value = ( int )packed[0] | ( ( int )packed[1] << 8 );

    // get the components in the stored range
    u8 red = ( u8 )( ( value >> 11 ) & 0x1f );
    u8 green = ( u8 )( ( value >> 5 ) & 0x3f );
    u8 blue = ( u8 )( value & 0x1f );

    // scale up to 8 bits
    colour[0] = ( red << 3 ) | ( red >> 2 );
    colour[1] = ( green << 2 ) | ( green >> 4 );
    colour[2] = ( blue << 3 ) | ( blue >> 2 );
    colour[3] = 255;

    // return the value
    return value;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
movq -0x8(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
sarl $0xb, %eax
andl $0x1f, %eax
movb %al, -0x15(%rsp)
movl -0x14(%rsp), %eax
sarl $0x5, %eax
andl $0x3f, %eax
movb %al, -0x16(%rsp)
movl -0x14(%rsp), %eax
andl $0x1f, %eax
movb %al, -0x17(%rsp)
movzbl -0x15(%rsp), %eax
shll $0x3, %eax
movzbl -0x15(%rsp), %ecx
sarl $0x2, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, (%rax)
movzbl -0x16(%rsp), %eax
shll $0x2, %eax
movzbl -0x16(%rsp), %ecx
sarl $0x4, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, 0x1(%rax)
movzbl -0x17(%rsp), %eax
shll $0x3, %eax
movzbl -0x17(%rsp), %ecx
sarl $0x2, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rsp), %rax
movb $-0x1, 0x3(%rax)
movl -0x14(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x10(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x17(%rsp)
testb $0x1, 0x17(%rsp)
je 0xac675
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xac690
testb $0x1, %al
jne 0xac673
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0xac685
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movl $0x0, -0x1c(%rsp)
cmpl $0x10, -0x1c(%rsp)
jge 0xacbdd
movq -0x28(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movl 0x104(%rax,%rcx,4), %eax
movl %eax, -0x20(%rsp)
cmpl $-0x1, -0x20(%rsp)
jne 0xacbb4
movq -0x18(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movb $0x3, (%rax,%rcx)
jmp 0xacbce
movq -0x10(%rsp), %rax
movslq -0x20(%rsp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xacbd0
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0xacb81
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/maths.h
// Function: squish::Vec3::operator+=(squish::Vec3 const&)
Vec3& operator+=( Arg v )
    {
        m_x += v.m_x;
        m_y += v.m_y;
        m_z += v.m_z;
        return *this;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movss (%rcx), %xmm0
addss (%rax), %xmm0
movss %xmm0, (%rax)
movq -0x10(%rsp), %rcx
movss 0x4(%rcx), %xmm0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x4(%rax)
movq -0x10(%rsp), %rcx
movss 0x8(%rcx), %xmm0
addss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/maths.h
// Function: squish::Vec3::operator/=(float)
Vec3& operator/=( float s )
    {
        float t = 1.0f/s;
        m_x *= t;
        m_y *= t;
        m_z *= t;
        return *this;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movss %xmm0, -0xc(%rsp)
movq -0x8(%rsp), %rax
movss 0x5968(%rip), %xmm0     # 0xb2e00
divss -0xc(%rsp), %xmm0
movss %xmm0, -0x10(%rsp)
movss -0x10(%rsp), %xmm0
mulss (%rax), %xmm0
movss %xmm0, (%rax)
movss -0x10(%rsp), %xmm0
mulss 0x4(%rax), %xmm0
movss %xmm0, 0x4(%rax)
movss -0x10(%rsp), %xmm0
mulss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rax)
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/maths.h
// Function: squish::Vec3::operator*=(float)
Vec3& operator*=( float s )
    {
        m_x *= s;
        m_y *= s;
        m_z *= s;
        return *this;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movss %xmm0, -0xc(%rsp)
movq -0x8(%rsp), %rax
movss -0xc(%rsp), %xmm0
mulss (%rax), %xmm0
movss %xmm0, (%rax)
movss -0xc(%rsp), %xmm0
mulss 0x4(%rax), %xmm0
movss %xmm0, 0x4(%rax)
movss -0xc(%rsp), %xmm0
mulss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/maths.h
// Function: squish::Min(squish::Vec3 const&, squish::Vec3 const&)
Vec3 Min( Arg left, Arg right )
    {
        return Vec3(
            std::min( left.m_x, right.m_x ),
            std::min( left.m_y, right.m_y ),
            std::min( left.m_z, right.m_z )
        );
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xabd50
movss (%rax), %xmm0
movss %xmm0, (%rsp)
movq 0x20(%rsp), %rdi
addq $0x4, %rdi
movq 0x18(%rsp), %rsi
addq $0x4, %rsi
callq 0xabd50
movss (%rax), %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
callq 0xabd50
movss (%rsp), %xmm0
movss 0x4(%rsp), %xmm1
movss (%rax), %xmm2
leaq 0x2c(%rsp), %rdi
callq 0xabe10
movl 0x34(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x2c(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/maths.h
// Function: squish::Max(squish::Vec3 const&, squish::Vec3 const&)
Vec3 Max( Arg left, Arg right )
    {
        return Vec3(
            std::max( left.m_x, right.m_x ),
            std::max( left.m_y, right.m_y ),
            std::max( left.m_z, right.m_z )
        );
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xabd90
movss (%rax), %xmm0
movss %xmm0, (%rsp)
movq 0x20(%rsp), %rdi
addq $0x4, %rdi
movq 0x18(%rsp), %rsi
addq $0x4, %rsi
callq 0xabd90
movss (%rax), %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
callq 0xabd90
movss (%rsp), %xmm0
movss 0x4(%rsp), %xmm1
movss (%rax), %xmm2
leaq 0x2c(%rsp), %rdi
callq 0xabe10
movl 0x34(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x2c(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
addq $0x38, %rsp
retq
nopw (%rax,%rax)