LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/polymosttexcache.c
// Function: PTCacheLoadTile
PTCacheTile * PTCacheLoadTile(const char * filename, int effects, int flags)
{
	PTCacheIndex * pci;
	PTCacheTile * tdef;

	if (cachedisabled) {
		return 0;
	}

	pci = ptcache_findhash(filename, effects, flags);
	if (!pci) {
		return 0;
	}

	tdef = ptcache_load(pci->offset);
	if (tdef) {
		tdef->filename = strdup(filename);
		tdef->effects  = effects;
	}
	return tdef;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x0, 0x61ab9b(%rip)    # 0x6b7174
je 0x9c5e5
movq $0x0, -0x8(%rbp)
jmp 0x9c647
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x9c460
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9c609
movq $0x0, -0x8(%rbp)
jmp 0x9c647
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %edi
callq 0x9c660
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x9c63f
movq -0x10(%rbp), %rdi
callq 0x6060
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/polymosttexcache.c
// Function: PTCacheFreeTile
void PTCacheFreeTile(PTCacheTile * tdef)
{
	int i;

	if (tdef->filename) {
		free(tdef->filename);
	}
	for (i = 0; i < tdef->nummipmaps; i++) {
		if (tdef->mipmap[i].data) {
			free(tdef->mipmap[i].data);
		}
	}
	free(tdef);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9c9d2
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x61c0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jge 0x9ca28
movq -0x8(%rbp), %rax
addq $0x20, %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x9ca1b
movq -0x8(%rbp), %rax
addq $0x20, %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x61c0
jmp 0x9ca1d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9c9d9
movq -0x8(%rbp), %rdi
callq 0x61c0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/polymosttexcache.c
// Function: PTCacheAllocNewTile
PTCacheTile * PTCacheAllocNewTile(int nummipmaps)
{
	int size = sizeof(PTCacheTile) + (nummipmaps-1) * sizeof(PTCacheTileMip);
	PTCacheTile * tdef;

	tdef = (PTCacheTile *) malloc(size);
	memset(tdef, 0, size);

	tdef->nummipmaps = nummipmaps;

	return tdef;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
cltq
imulq $0x18, %rax, %rax
addq $0x38, %rax
movl %eax, -0x8(%rbp)
movslq -0x8(%rbp), %rdi
callq 0x68f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x8(%rbp), %rdx
xorl %esi, %esi
callq 0x62d0
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/polymosttexcache.c
// Function: gethashhead
static unsigned int gethashhead(const char * filename)
{
	// implements the djb2 hash, constrained to the hash table size
	// http://www.cse.yorku.ca/~oz/hash.html
	unsigned long hash = 5381;
	int c;

    while ((c = (unsigned char)*filename++)) {
		hash = ((hash << 5) + hash) ^ c; /* hash * 33 ^ c */
	}

    return hash & (PTCACHEHASHSIZ-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x1505, -0x10(%rbp)    # imm = 0x1505
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x9d033
movq -0x10(%rbp), %rax
shlq $0x5, %rax
addq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
xorq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x9d000
movq -0x10(%rbp), %rax
andq $0x1ff, %rax            # imm = 0x1FF
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/polymosttexcompress.cc
// Function: ptcompress_getstorage
int ptcompress_getstorage(int width, int height, int format)
{
	switch (format) {
		case PTCOMPRESS_DXT1:
		case PTCOMPRESS_DXT5:
			return squish::GetStorageRequirements(width, height, getsquishflags(format));
		case PTCOMPRESS_ETC1:
			return 8 * ((width + 3) / 4) * ((height + 3) / 4);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
decl %eax
subl $0x2, %eax
jb 0x9d06a
jmp 0x9d060
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x9d090
jmp 0x9d0bf
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %edi
callq 0x9d0d0
movl -0x1c(%rbp), %edi
movl -0x18(%rbp), %esi
movl %eax, %edx
callq 0xa3730
movl %eax, -0x4(%rbp)
jmp 0x9d0c6
movl -0x8(%rbp), %eax
addl $0x3, %eax
movl $0x4, %ecx
cltd
idivl %ecx
shll $0x3, %eax
movl %eax, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl $0x3, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x20(%rbp), %eax
imull %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x9d0c6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/polymosttexcompress.cc
// Function: getsquishflags(int)
static int getsquishflags(int format)
{
	int flags;

	switch (gltexcomprquality) {
		case 2: flags = squish::kColourIterativeClusterFit;	// slower
			break;
		case 1: flags = squish::kColourClusterFit;		// slow, but also quite good looking
			break;
		default: flags = squish::kColourRangeFit;		// fast, but worse quality
			break;
	}

	flags |= squish::kSourceBGRA;
	if (format == PTCOMPRESS_DXT1) {
		flags |= squish::kDxt1;
	} else if (format == PTCOMPRESS_DXT5) {
		flags |= squish::kDxt5;
	}

	return flags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
leaq 0x55087a(%rip), %rax    # 0x5ed958
movl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x1, %eax
je 0x9d0fd
jmp 0x9d0ea
movl -0xc(%rbp), %eax
subl $0x2, %eax
jne 0x9d106
jmp 0x9d0f4
movl $0x100, -0x8(%rbp)      # imm = 0x100
jmp 0x9d10d
movl $0x20, -0x8(%rbp)
jmp 0x9d10d
movl $0x40, -0x8(%rbp)
movl -0x8(%rbp), %eax
orl $0x200, %eax            # imm = 0x200
movl %eax, -0x8(%rbp)
cmpl $0x1, -0x4(%rbp)
jne 0x9d129
movl -0x8(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x9d13a
cmpl $0x2, -0x4(%rbp)
jne 0x9d138
movl -0x8(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x8(%rbp)
jmp 0x9d13a
movl -0x8(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/polymosttexcompress.cc
// Function: ptcompress_compress
int ptcompress_compress(void * bgra, int width, int height, unsigned char * output, int format)
{
	switch (format) {
		case PTCOMPRESS_DXT1:
		case PTCOMPRESS_DXT5:
			squish::CompressImage( (squish::u8 const *) bgra, width, height, output, getsquishflags(format));
			return 0;
		case PTCOMPRESS_ETC1:
			compressetc1((uint8_t *)bgra, width, height, output);
			return 0;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
decl %eax
subl $0x2, %eax
jb 0x9d173
jmp 0x9d169
movl -0x28(%rbp), %eax
subl $0x3, %eax
je 0x9d1bb
jmp 0x9d1d7
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %edi
callq 0x9d0d0
movq -0x40(%rbp), %rdi
movl -0x38(%rbp), %esi
movl -0x34(%rbp), %edx
movq -0x30(%rbp), %rcx
movl %eax, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0xa3ab0
movl $0x0, -0x4(%rbp)
jmp 0x9d1de
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x9d1f0
movl $0x0, -0x4(%rbp)
jmp 0x9d1de
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::pack_color5(unsigned int, unsigned int, unsigned int, bool, unsigned int)
uint16 etc1_block::pack_color5(uint r, uint g, uint b, bool scaled, uint bias)
   {
      if (scaled)
      {
         r = (r * 31U + bias) / 255U;
         g = (g * 31U + bias) / 255U;
         b = (b * 31U + bias) / 255U;
      }

      r = rg_etc1::minimum(r, 31U);
      g = rg_etc1::minimum(g, 31U);
      b = rg_etc1::minimum(b, 31U);

      return static_cast<uint16>(b | (g << 5U) | (r << 10U));
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movl %r8d, -0x14(%rbp)
testb $0x1, -0xd(%rbp)
je 0x9d5cb
imull $0x1f, -0x4(%rbp), %eax
addl -0x14(%rbp), %eax
movl $0xff, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x4(%rbp)
imull $0x1f, -0x8(%rbp), %eax
addl -0x14(%rbp), %eax
movl $0xff, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x8(%rbp)
imull $0x1f, -0xc(%rbp), %eax
addl -0x14(%rbp), %eax
movl $0xff, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %edi
movl $0x1f, %esi
callq 0xa1a30
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %edi
movl $0x1f, %esi
callq 0xa1a30
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %edi
movl $0x1f, %esi
callq 0xa1a30
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0x8(%rbp), %ecx
shll $0x5, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
shll $0xa, %ecx
orl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::unpack_color5(unsigned short, bool, unsigned int)
color_quad_u8 etc1_block::unpack_color5(uint16 packed_color5, bool scaled, uint alpha)
   {
      uint b = packed_color5 & 31U;
      uint g = (packed_color5 >> 5U) & 31U;
      uint r = (packed_color5 >> 10U) & 31U;

      if (scaled)
      {
         b = (b << 3U) | (b >> 2U);
         g = (g << 3U) | (g >> 2U);
         r = (r << 3U) | (r >> 2U);
      }

      return color_quad_u8(cNoClamp, r, g, b, rg_etc1::minimum(alpha, 255U));
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movb %dl, %al
movw %si, %dx
movq %rdi, %rsi
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movw %dx, -0xa(%rbp)
andb $0x1, %al
movb %al, -0xb(%rbp)
movl %ecx, -0x10(%rbp)
movzwl -0xa(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x14(%rbp)
movzwl -0xa(%rbp), %eax
sarl $0x5, %eax
andl $0x1f, %eax
movl %eax, -0x18(%rbp)
movzwl -0xa(%rbp), %eax
sarl $0xa, %eax
andl $0x1f, %eax
movl %eax, -0x1c(%rbp)
testb $0x1, -0xb(%rbp)
je 0x9d6a5
movl -0x14(%rbp), %eax
shll $0x3, %eax
movl -0x14(%rbp), %ecx
shrl $0x2, %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
shll $0x3, %eax
movl -0x18(%rbp), %ecx
shrl $0x2, %ecx
orl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
shll $0x3, %eax
movl -0x1c(%rbp), %ecx
shrl $0x2, %ecx
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x10(%rbp), %edi
movl $0xff, %esi
callq 0xa1a30
movq -0x30(%rbp), %rdi
movl -0x3c(%rbp), %edx
movl -0x38(%rbp), %ecx
movl -0x34(%rbp), %r8d
movl %eax, %r9d
xorl %esi, %esi
callq 0xa1a60
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::unpack_color5(unsigned int&, unsigned int&, unsigned int&, unsigned short, bool)
void etc1_block::unpack_color5(uint& r, uint& g, uint& b, uint16 packed_color5, bool scaled)
   {
      color_quad_u8 c(unpack_color5(packed_color5, scaled, 0));
      r = c.r;
      g = c.g;
      b = c.b;
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movw %cx, -0x1a(%rbp)
andb $0x1, %al
movb %al, -0x1b(%rbp)
movw -0x1a(%rbp), %dx
movb -0x1b(%rbp), %al
leaq -0x20(%rbp), %rdi
xorl %ecx, %ecx
andb $0x1, %al
movzwl %dx, %esi
movzbl %al, %edx
callq 0x9d620
movzbl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movzbl -0x1f(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movzbl -0x1e(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::unpack_color5(rg_etc1::color_quad_u8&, unsigned short, unsigned short, bool, unsigned int)
bool etc1_block::unpack_color5(color_quad_u8& result, uint16 packed_color5, uint16 packed_delta3, bool scaled, uint alpha)
   {
      int dc_r, dc_g, dc_b;
      unpack_delta3(dc_r, dc_g, dc_b, packed_delta3);
      
      int b = (packed_color5 & 31U) + dc_b;
      int g = ((packed_color5 >> 5U) & 31U) + dc_g;
      int r = ((packed_color5 >> 10U) & 31U) + dc_r;

      bool success = true;
      if (static_cast<uint>(r | g | b) > 31U)
      {
         success = false;
         r = rg_etc1::clamp<int>(r, 0, 31);
         g = rg_etc1::clamp<int>(g, 0, 31);
         b = rg_etc1::clamp<int>(b, 0, 31);
      }

      if (scaled)
      {
         b = (b << 3U) | (b >> 2U);
         g = (g << 3U) | (g >> 2U);
         r = (r << 3U) | (r >> 2U);
      }

      result.set_noclamp_rgba(r, g, b, rg_etc1::minimum(alpha, 255U));
      return success;
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movw %dx, %cx
movw %si, %dx
movq %rdi, -0x8(%rbp)
movw %dx, -0xa(%rbp)
movw %cx, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movl %r8d, -0x14(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
movzwl -0xc(%rbp), %ecx
callq 0x9d890
movzwl -0xa(%rbp), %eax
andl $0x1f, %eax
addl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movzwl -0xa(%rbp), %eax
sarl $0x5, %eax
andl $0x1f, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movzwl -0xa(%rbp), %eax
sarl $0xa, %eax
andl $0x1f, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movb $0x1, -0x2d(%rbp)
movl -0x2c(%rbp), %eax
orl -0x28(%rbp), %eax
orl -0x24(%rbp), %eax
cmpl $0x1f, %eax
jbe 0x9d803
movb $0x0, -0x2d(%rbp)
movl -0x2c(%rbp), %edi
xorl %esi, %esi
movl $0x1f, %edx
callq 0xa1aa0
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %edi
xorl %esi, %esi
movl $0x1f, %edx
callq 0xa1aa0
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %edi
xorl %esi, %esi
movl $0x1f, %edx
callq 0xa1aa0
movl %eax, -0x24(%rbp)
testb $0x1, -0xd(%rbp)
je 0x9d83c
movl -0x24(%rbp), %eax
shll $0x3, %eax
movl -0x24(%rbp), %ecx
sarl $0x2, %ecx
orl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
shll $0x3, %eax
movl -0x28(%rbp), %ecx
sarl $0x2, %ecx
orl %ecx, %eax
movl %eax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
shll $0x3, %eax
movl -0x2c(%rbp), %ecx
sarl $0x2, %ecx
orl %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %edi
movl $0xff, %esi
callq 0xa1a30
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %esi
movl -0x38(%rbp), %edx
movl -0x34(%rbp), %ecx
movl %eax, %r8d
callq 0xa1ae0
movb -0x2d(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::unpack_delta3(int&, int&, int&, unsigned short)
void etc1_block::unpack_delta3(int& r, int& g, int& b, uint16 packed_delta3)
   {
      r = (packed_delta3 >> 6) & 7;
      g = (packed_delta3 >> 3) & 7;
      b = packed_delta3 & 7;
      if (r >= 4) r -= 8;
      if (g >= 4) g -= 8;
      if (b >= 4) b -= 8;
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %cx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movzwl -0x1a(%rbp), %ecx
sarl $0x6, %ecx
andl $0x7, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movzwl -0x1a(%rbp), %ecx
sarl $0x3, %ecx
andl $0x7, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movzwl -0x1a(%rbp), %ecx
andl $0x7, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x4, (%rax)
jl 0x9d8e8
movq -0x8(%rbp), %rax
movl (%rax), %ecx
subl $0x8, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
jl 0x9d8fc
movq -0x10(%rbp), %rax
movl (%rax), %ecx
subl $0x8, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
jl 0x9d910
movq -0x18(%rbp), %rax
movl (%rax), %ecx
subl $0x8, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::unpack_color5(unsigned int&, unsigned int&, unsigned int&, unsigned short, unsigned short, bool, unsigned int)
bool etc1_block::unpack_color5(uint& r, uint& g, uint& b, uint16 packed_color5, uint16 packed_delta3, bool scaled, uint alpha)
   {
      color_quad_u8 result;
      const bool success = unpack_color5(result, packed_color5, packed_delta3, scaled, alpha);
      r = result.r;
      g = result.g;
      b = result.b;
      return success;
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %r8d, -0x40(%rbp)
movl %ecx, %eax
movl -0x40(%rbp), %ecx
movl %eax, -0x3c(%rbp)
movq %rdx, %rax
movl -0x3c(%rbp), %edx
movq %rax, -0x38(%rbp)
movq %rsi, %rax
movq -0x38(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq %rdi, %r8
movq -0x30(%rbp), %rdi
movb %r9b, %al
movl 0x10(%rbp), %r9d
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw %dx, -0x1a(%rbp)
movw %cx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
leaq -0x24(%rbp), %rdi
callq 0xa1c30
movw -0x1a(%rbp), %dx
movw -0x1c(%rbp), %cx
movb -0x1d(%rbp), %al
movl 0x10(%rbp), %r8d
leaq -0x24(%rbp), %rdi
andb $0x1, %al
movzwl %dx, %esi
movzwl %cx, %edx
movzbl %al, %ecx
callq 0x9d750
andb $0x1, %al
movb %al, -0x25(%rbp)
movzbl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movzbl -0x23(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movzbl -0x22(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb -0x25(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::pack_delta3(int, int, int)
uint16 etc1_block::pack_delta3(int r, int g, int b)
   {
      RG_ETC1_ASSERT((r >= cETC1ColorDeltaMin) && (r <= cETC1ColorDeltaMax));
      RG_ETC1_ASSERT((g >= cETC1ColorDeltaMin) && (g <= cETC1ColorDeltaMax));
      RG_ETC1_ASSERT((b >= cETC1ColorDeltaMin) && (b <= cETC1ColorDeltaMax));
      if (r < 0) r += 8;
      if (g < 0) g += 8;
      if (b < 0) b += 8;
      return static_cast<uint16>(b | (g << 3) | (r << 6));
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
xorl %eax, %eax
cmpl $-0x4, -0x4(%rbp)
movb %al, -0xd(%rbp)
jl 0x9d9f6
cmpl $0x3, -0x4(%rbp)
setle %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x9d9ff
jmp 0x9da01
jmp 0x9da20
leaq 0x1a8e4(%rip), %rdi     # 0xb82ec
leaq 0x1a914(%rip), %rsi     # 0xb8323
movl $0x3fc, %edx            # imm = 0x3FC
leaq 0x1a918(%rip), %rcx     # 0xb8333
callq 0x61a0
xorl %eax, %eax
cmpl $-0x4, -0x8(%rbp)
movb %al, -0xe(%rbp)
jl 0x9da35
cmpl $0x3, -0x8(%rbp)
setle %al
movb %al, -0xe(%rbp)
movb -0xe(%rbp), %al
testb $0x1, %al
jne 0x9da3e
jmp 0x9da40
jmp 0x9da5f
leaq 0x1a92a(%rip), %rdi     # 0xb8371
leaq 0x1a8d5(%rip), %rsi     # 0xb8323
movl $0x3fd, %edx            # imm = 0x3FD
leaq 0x1a8d9(%rip), %rcx     # 0xb8333
callq 0x61a0
xorl %eax, %eax
cmpl $-0x4, -0xc(%rbp)
movb %al, -0xf(%rbp)
jl 0x9da74
cmpl $0x3, -0xc(%rbp)
setle %al
movb %al, -0xf(%rbp)
movb -0xf(%rbp), %al
testb $0x1, %al
jne 0x9da7d
jmp 0x9da7f
jmp 0x9da9e
leaq 0x1a922(%rip), %rdi     # 0xb83a8
leaq 0x1a896(%rip), %rsi     # 0xb8323
movl $0x3fe, %edx            # imm = 0x3FE
leaq 0x1a89a(%rip), %rcx     # 0xb8333
callq 0x61a0
cmpl $0x0, -0x4(%rbp)
jge 0x9daad
movl -0x4(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x9dabc
movl -0x8(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x9dacb
movl -0xc(%rbp), %eax
addl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0x8(%rbp), %ecx
shll $0x3, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
shll $0x6, %ecx
orl %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::pack_color4(unsigned int, unsigned int, unsigned int, bool, unsigned int)
uint16 etc1_block::pack_color4(uint r, uint g, uint b, bool scaled, uint bias)
   {
      if (scaled)
      {
         r = (r * 15U + bias) / 255U;
         g = (g * 15U + bias) / 255U;
         b = (b * 15U + bias) / 255U;
      }

      r = rg_etc1::minimum(r, 15U);
      g = rg_etc1::minimum(g, 15U);
      b = rg_etc1::minimum(b, 15U);

      return static_cast<uint16>(b | (g << 4U) | (r << 8U));
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movl %r8d, -0x14(%rbp)
testb $0x1, -0xd(%rbp)
je 0x9db9b
imull $0xf, -0x4(%rbp), %eax
addl -0x14(%rbp), %eax
movl $0xff, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x4(%rbp)
imull $0xf, -0x8(%rbp), %eax
addl -0x14(%rbp), %eax
movl $0xff, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x8(%rbp)
imull $0xf, -0xc(%rbp), %eax
addl -0x14(%rbp), %eax
movl $0xff, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %edi
movl $0xf, %esi
callq 0xa1a30
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %edi
movl $0xf, %esi
callq 0xa1a30
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %edi
movl $0xf, %esi
callq 0xa1a30
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0x8(%rbp), %ecx
shll $0x4, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::unpack_color4(unsigned short, bool, unsigned int)
color_quad_u8 etc1_block::unpack_color4(uint16 packed_color4, bool scaled, uint alpha)
   {
      uint b = packed_color4 & 15U;
      uint g = (packed_color4 >> 4U) & 15U;
      uint r = (packed_color4 >> 8U) & 15U;

      if (scaled)
      {
         b = (b << 4U) | b;
         g = (g << 4U) | g;
         r = (r << 4U) | r;
      }

      return color_quad_u8(cNoClamp, r, g, b, rg_etc1::minimum(alpha, 255U));
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movb %dl, %al
movw %si, %dx
movq %rdi, %rsi
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movw %dx, -0xa(%rbp)
andb $0x1, %al
movb %al, -0xb(%rbp)
movl %ecx, -0x10(%rbp)
movzwl -0xa(%rbp), %eax
andl $0xf, %eax
movl %eax, -0x14(%rbp)
movzwl -0xa(%rbp), %eax
sarl $0x4, %eax
andl $0xf, %eax
movl %eax, -0x18(%rbp)
movzwl -0xa(%rbp), %eax
sarl $0x8, %eax
andl $0xf, %eax
movl %eax, -0x1c(%rbp)
testb $0x1, -0xb(%rbp)
je 0x9dc66
movl -0x14(%rbp), %eax
shll $0x4, %eax
orl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
shll $0x4, %eax
orl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
shll $0x4, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x10(%rbp), %edi
movl $0xff, %esi
callq 0xa1a30
movq -0x30(%rbp), %rdi
movl -0x3c(%rbp), %edx
movl -0x38(%rbp), %ecx
movl -0x34(%rbp), %r8d
movl %eax, %r9d
xorl %esi, %esi
callq 0xa1a60
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::get_diff_subblock_colors(rg_etc1::color_quad_u8*, unsigned short, unsigned int)
void etc1_block::get_diff_subblock_colors(color_quad_u8* pDst, uint16 packed_color5, uint table_idx)
   {
      RG_ETC1_ASSERT(table_idx < cETC1IntenModifierValues);
      const int *pInten_modifer_table = &g_etc1_inten_tables[table_idx][0];

      uint r, g, b;
      unpack_color5(r, g, b, packed_color5, true);

      const int ir = static_cast<int>(r), ig = static_cast<int>(g), ib = static_cast<int>(b);

      const int y0 = pInten_modifer_table[0];
      pDst[0].set(ir + y0, ig + y0, ib + y0);

      const int y1 = pInten_modifer_table[1];
      pDst[1].set(ir + y1, ig + y1, ib + y1);

      const int y2 = pInten_modifer_table[2];
      pDst[2].set(ir + y2, ig + y2, ib + y2);

      const int y3 = pInten_modifer_table[3];
      pDst[3].set(ir + y3, ig + y3, ib + y3);
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jae 0x9dd2e
jmp 0x9dd4d
leaq 0x1a6aa(%rip), %rdi     # 0xb83df
leaq 0x1a5e7(%rip), %rsi     # 0xb8323
movl $0x43e, %edx            # imm = 0x43E
leaq 0x1a6bc(%rip), %rcx     # 0xb8404
callq 0x61a0
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0x1aee7(%rip), %rax     # 0xb8c40
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
leaq -0x1c(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
movl $0x1, %r8d
movzwl -0xa(%rbp), %ecx
callq 0x9d6f0
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movl -0x28(%rbp), %esi
addl -0x34(%rbp), %esi
movl -0x2c(%rbp), %edx
addl -0x34(%rbp), %edx
movl -0x30(%rbp), %ecx
addl -0x34(%rbp), %ecx
movl $0xff, %r8d
callq 0xa1c40
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movl -0x28(%rbp), %esi
addl -0x38(%rbp), %esi
movl -0x2c(%rbp), %edx
addl -0x38(%rbp), %edx
movl -0x30(%rbp), %ecx
addl -0x38(%rbp), %ecx
movl $0xff, %r8d
callq 0xa1c40
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movl -0x28(%rbp), %esi
addl -0x3c(%rbp), %esi
movl -0x2c(%rbp), %edx
addl -0x3c(%rbp), %edx
movl -0x30(%rbp), %ecx
addl -0x3c(%rbp), %ecx
movl $0xff, %r8d
callq 0xa1c40
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
addq $0xc, %rdi
movl -0x28(%rbp), %esi
addl -0x40(%rbp), %esi
movl -0x2c(%rbp), %edx
addl -0x40(%rbp), %edx
movl -0x30(%rbp), %ecx
addl -0x40(%rbp), %ecx
movl $0xff, %r8d
callq 0xa1c40
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::get_diff_subblock_colors(rg_etc1::color_quad_u8*, unsigned short, unsigned short, unsigned int)
bool etc1_block::get_diff_subblock_colors(color_quad_u8* pDst, uint16 packed_color5, uint16 packed_delta3, uint table_idx)
   {
      RG_ETC1_ASSERT(table_idx < cETC1IntenModifierValues);
      const int *pInten_modifer_table = &g_etc1_inten_tables[table_idx][0];

      uint r, g, b;
      bool success = unpack_color5(r, g, b, packed_color5, packed_delta3, true);

      const int ir = static_cast<int>(r), ig = static_cast<int>(g), ib = static_cast<int>(b);

      const int y0 = pInten_modifer_table[0];
      pDst[0].set(ir + y0, ig + y0, ib + y0);

      const int y1 = pInten_modifer_table[1];
      pDst[1].set(ir + y1, ig + y1, ib + y1);

      const int y2 = pInten_modifer_table[2];
      pDst[2].set(ir + y2, ig + y2, ib + y2);

      const int y3 = pInten_modifer_table[3];
      pDst[3].set(ir + y3, ig + y3, ib + y3);

      return success;
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movw %dx, %ax
movw %si, %dx
movq %rdi, -0x8(%rbp)
movw %dx, -0xa(%rbp)
movw %ax, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jae 0x9de75
jmp 0x9de94
leaq 0x1a563(%rip), %rdi     # 0xb83df
leaq 0x1a4a0(%rip), %rsi     # 0xb8323
movl $0x455, %edx            # imm = 0x455
leaq 0x1a5ce(%rip), %rcx     # 0xb845d
callq 0x61a0
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0x1ada0(%rip), %rax     # 0xb8c40
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movw -0xa(%rbp), %ax
leaq -0x1c(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
movl $0x1, %r9d
movzwl %ax, %ecx
movzwl -0xc(%rbp), %r8d
movl $0xff, (%rsp)
callq 0x9d920
andb $0x1, %al
movb %al, -0x25(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
addl -0x38(%rbp), %esi
movl -0x30(%rbp), %edx
addl -0x38(%rbp), %edx
movl -0x34(%rbp), %ecx
addl -0x38(%rbp), %ecx
movl $0xff, %r8d
callq 0xa1c40
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movl -0x2c(%rbp), %esi
addl -0x3c(%rbp), %esi
movl -0x30(%rbp), %edx
addl -0x3c(%rbp), %edx
movl -0x34(%rbp), %ecx
addl -0x3c(%rbp), %ecx
movl $0xff, %r8d
callq 0xa1c40
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movl -0x2c(%rbp), %esi
addl -0x40(%rbp), %esi
movl -0x30(%rbp), %edx
addl -0x40(%rbp), %edx
movl -0x34(%rbp), %ecx
addl -0x40(%rbp), %ecx
movl $0xff, %r8d
callq 0xa1c40
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rdi
addq $0xc, %rdi
movl -0x2c(%rbp), %esi
addl -0x44(%rbp), %esi
movl -0x30(%rbp), %edx
addl -0x44(%rbp), %edx
movl -0x34(%rbp), %ecx
addl -0x44(%rbp), %ecx
movl $0xff, %r8d
callq 0xa1c40
movb -0x25(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::get_abs_subblock_colors(rg_etc1::color_quad_u8*, unsigned short, unsigned int)
void etc1_block::get_abs_subblock_colors(color_quad_u8* pDst, uint16 packed_color4, uint table_idx)
   {
      RG_ETC1_ASSERT(table_idx < cETC1IntenModifierValues);
      const int *pInten_modifer_table = &g_etc1_inten_tables[table_idx][0];

      uint r, g, b;
      unpack_color4(r, g, b, packed_color4, true);
      
      const int ir = static_cast<int>(r), ig = static_cast<int>(g), ib = static_cast<int>(b);

      const int y0 = pInten_modifer_table[0];
      pDst[0].set(ir + y0, ig + y0, ib + y0);
      
      const int y1 = pInten_modifer_table[1];
      pDst[1].set(ir + y1, ig + y1, ib + y1);

      const int y2 = pInten_modifer_table[2];
      pDst[2].set(ir + y2, ig + y2, ib + y2);

      const int y3 = pInten_modifer_table[3];
      pDst[3].set(ir + y3, ig + y3, ib + y3);
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jae 0x9dfce
jmp 0x9dfed
leaq 0x1a40a(%rip), %rdi     # 0xb83df
leaq 0x1a347(%rip), %rsi     # 0xb8323
movl $0x46e, %edx            # imm = 0x46E
leaq 0x1a4d6(%rip), %rcx     # 0xb84be
callq 0x61a0
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0x1ac47(%rip), %rax     # 0xb8c40
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
leaq -0x1c(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
movl $0x1, %r8d
movzwl -0xa(%rbp), %ecx
callq 0x9dcb0
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movl -0x28(%rbp), %esi
addl -0x34(%rbp), %esi
movl -0x2c(%rbp), %edx
addl -0x34(%rbp), %edx
movl -0x30(%rbp), %ecx
addl -0x34(%rbp), %ecx
movl $0xff, %r8d
callq 0xa1c40
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movl -0x28(%rbp), %esi
addl -0x38(%rbp), %esi
movl -0x2c(%rbp), %edx
addl -0x38(%rbp), %edx
movl -0x30(%rbp), %ecx
addl -0x38(%rbp), %ecx
movl $0xff, %r8d
callq 0xa1c40
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movl -0x28(%rbp), %esi
addl -0x3c(%rbp), %esi
movl -0x2c(%rbp), %edx
addl -0x3c(%rbp), %edx
movl -0x30(%rbp), %ecx
addl -0x3c(%rbp), %ecx
movl $0xff, %r8d
callq 0xa1c40
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
addq $0xc, %rdi
movl -0x28(%rbp), %esi
addl -0x40(%rbp), %esi
movl -0x2c(%rbp), %edx
addl -0x40(%rbp), %edx
movl -0x30(%rbp), %ecx
addl -0x40(%rbp), %ecx
movl $0xff, %r8d
callq 0xa1c40
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_decode_value(unsigned int, unsigned int, unsigned int, unsigned int)
static uint etc1_decode_value(uint diff, uint inten, uint selector, uint packed_c)
   {
      const uint limit = diff ? 32 : 16; (void)limit;   //JonoF
      RG_ETC1_ASSERT((diff < 2) && (inten < 8) && (selector < 4) && (packed_c < limit));
      int c;
      if (diff)
         c = (packed_c >> 2) | (packed_c << 3);
      else 
         c = packed_c | (packed_c << 4);
      c += g_etc1_inten_tables[inten][selector];
      c = rg_etc1::clamp<int>(c, 0, 255);
      return c;
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x4(%rbp), %edx
movl $0x10, %eax
movl $0x20, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x2, -0x4(%rbp)
movb %al, -0x19(%rbp)
jae 0xa0027
xorl %eax, %eax
cmpl $0x8, -0x8(%rbp)
movb %al, -0x19(%rbp)
jae 0xa0027
xorl %eax, %eax
cmpl $0x4, -0xc(%rbp)
movb %al, -0x19(%rbp)
jae 0xa0027
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
setb %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xa0030
jmp 0xa0032
jmp 0xa0051
leaq 0x18907(%rip), %rdi     # 0xb8940
leaq 0x182e3(%rip), %rsi     # 0xb8323
movl $0x764, %edx            # imm = 0x764
leaq 0x18936(%rip), %rcx     # 0xb8982
callq 0x61a0
cmpl $0x0, -0x4(%rbp)
je 0xa006a
movl -0x10(%rbp), %eax
shrl $0x2, %eax
movl -0x10(%rbp), %ecx
shll $0x3, %ecx
orl %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0xa0078
movl -0x10(%rbp), %eax
movl -0x10(%rbp), %ecx
shll $0x4, %ecx
orl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x18bbc(%rip), %rax     # 0xb8c40
shlq $0x4, %rcx
addq %rcx, %rax
movl -0xc(%rbp), %ecx
movl (%rax,%rcx,4), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
xorl %esi, %esi
movl $0xff, %edx
callq 0xa1aa0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::color_quad_u8::set_noclamp_rgba(int, int, int, int)
inline color_quad_u8& set_noclamp_rgba(parameter_t red, parameter_t green, parameter_t blue, parameter_t alpha)
      {
         RG_ETC1_ASSERT( (red >= component_traits::cMin) && (red <= component_traits::cMax) );
         RG_ETC1_ASSERT( (green >= component_traits::cMin) && (green <= component_traits::cMax) );
         RG_ETC1_ASSERT( (blue >= component_traits::cMin) && (blue <= component_traits::cMax) );
         RG_ETC1_ASSERT( (alpha >= component_traits::cMin) && (alpha <= component_traits::cMax) );

         r = static_cast<component_t>(red);
         g = static_cast<component_t>(green);
         b = static_cast<component_t>(blue);
         a = static_cast<component_t>(alpha);
         return *this;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x19(%rbp)
jl 0xa1b19
cmpl $0xff, -0xc(%rbp)
setle %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xa1b22
jmp 0xa1b24
jmp 0xa1b43
leaq 0x16b50(%rip), %rdi     # 0xb867b
leaq 0x167f1(%rip), %rsi     # 0xb8323
movl $0xb3, %edx
leaq 0x16b80(%rip), %rcx     # 0xb86be
callq 0x61a0
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x29(%rbp)
jl 0xa1b5b
cmpl $0xff, -0x10(%rbp)
setle %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xa1b64
jmp 0xa1b66
jmp 0xa1b85
leaq 0x16bbd(%rip), %rdi     # 0xb872a
leaq 0x167af(%rip), %rsi     # 0xb8323
movl $0xb4, %edx
leaq 0x16b3e(%rip), %rcx     # 0xb86be
callq 0x61a0
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x2a(%rbp)
jl 0xa1b9d
cmpl $0xff, -0x14(%rbp)
setle %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0xa1ba6
jmp 0xa1ba8
jmp 0xa1bc7
leaq 0x16bc2(%rip), %rdi     # 0xb8771
leaq 0x1676d(%rip), %rsi     # 0xb8323
movl $0xb5, %edx
leaq 0x16afc(%rip), %rcx     # 0xb86be
callq 0x61a0
xorl %eax, %eax
cmpl $0x0, -0x18(%rbp)
movb %al, -0x2b(%rbp)
jl 0xa1bdf
cmpl $0xff, -0x18(%rbp)
setle %al
movb %al, -0x2b(%rbp)
movb -0x2b(%rbp), %al
testb $0x1, %al
jne 0xa1be8
jmp 0xa1bea
jmp 0xa1c09
leaq 0x16bc5(%rip), %rdi     # 0xb87b6
leaq 0x1672b(%rip), %rsi     # 0xb8323
movl $0xb6, %edx
leaq 0x16aba(%rip), %rcx     # 0xb86be
callq 0x61a0
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movb %cl, (%rax)
movl -0x10(%rbp), %ecx
movb %cl, 0x1(%rax)
movl -0x14(%rbp), %ecx
movb %cl, 0x2(%rax)
movl -0x18(%rbp), %ecx
movb %cl, 0x3(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::color_quad_u8::set(int, int, int, int)
inline color_quad_u8& set(parameter_t red, parameter_t green, parameter_t blue, parameter_t alpha = component_traits::cMax)
      {
         r = static_cast<component_t>(clamp(red));
         g = static_cast<component_t>(clamp(green));
         b = static_cast<component_t>(clamp(blue));
         a = static_cast<component_t>(clamp(alpha));
         return *this;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0xa2f60
movl %eax, %ecx
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl -0x10(%rbp), %edi
callq 0xa2f60
movl %eax, %ecx
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x14(%rbp), %edi
callq 0xa2f60
movl %eax, %ecx
movq -0x20(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x18(%rbp), %edi
callq 0xa2f60
movl %eax, %ecx
movq -0x20(%rbp), %rax
movb %cl, 0x3(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::get_base5_color() const
inline uint16 get_base5_color() const
      {
         const uint r = get_byte_bits(cETC1BaseColor5RBitOffset, 5);
         const uint g = get_byte_bits(cETC1BaseColor5GBitOffset, 5);
         const uint b = get_byte_bits(cETC1BaseColor5BBitOffset, 5);
         return static_cast<uint16>(b | (g << 5U) | (r << 10U));
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x3b, %esi
movl $0x5, %edx
callq 0xa2f90
movq -0x20(%rbp), %rdi
movl %eax, -0xc(%rbp)
movl $0x33, %esi
movl $0x5, %edx
callq 0xa2f90
movq -0x20(%rbp), %rdi
movl %eax, -0x10(%rbp)
movl $0x2b, %esi
movl $0x5, %edx
callq 0xa2f90
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0x10(%rbp), %ecx
shll $0x5, %ecx
orl %ecx, %eax
movl -0xc(%rbp), %ecx
shll $0xa, %ecx
orl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::get_delta3_color() const
inline uint16 get_delta3_color() const
      {
         const uint r = get_byte_bits(cETC1DeltaColor3RBitOffset, 3);
         const uint g = get_byte_bits(cETC1DeltaColor3GBitOffset, 3);
         const uint b = get_byte_bits(cETC1DeltaColor3BBitOffset, 3);
         return static_cast<uint16>(b | (g << 3U) | (r << 6U));
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x38, %esi
movl $0x3, %edx
callq 0xa2f90
movq -0x20(%rbp), %rdi
movl %eax, -0xc(%rbp)
movl $0x30, %esi
movl $0x3, %edx
callq 0xa2f90
movq -0x20(%rbp), %rdi
movl %eax, -0x10(%rbp)
movl $0x28, %esi
movl $0x3, %edx
callq 0xa2f90
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0x10(%rbp), %ecx
shll $0x3, %ecx
orl %ecx, %eax
movl -0xc(%rbp), %ecx
shll $0x6, %ecx
orl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::get_base4_color(unsigned int) const
inline uint16 get_base4_color(uint idx) const
      {
         uint r, g, b;
         if (idx)
         {
            r = get_byte_bits(cETC1AbsColor4R2BitOffset, 4);
            g = get_byte_bits(cETC1AbsColor4G2BitOffset, 4);
            b = get_byte_bits(cETC1AbsColor4B2BitOffset, 4);
         }
         else
         {
            r = get_byte_bits(cETC1AbsColor4R1BitOffset, 4);
            g = get_byte_bits(cETC1AbsColor4G1BitOffset, 4);
            b = get_byte_bits(cETC1AbsColor4B1BitOffset, 4);
         }
         return static_cast<uint16>(b | (g << 4U) | (r << 8U));
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xa1ea1
movq -0x20(%rbp), %rdi
movl $0x38, %esi
movl $0x4, %edx
callq 0xa2f90
movq -0x20(%rbp), %rdi
movl %eax, -0x10(%rbp)
movl $0x30, %esi
movl $0x4, %edx
callq 0xa2f90
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl $0x28, %esi
movl $0x4, %edx
callq 0xa2f90
movl %eax, -0x18(%rbp)
jmp 0xa1ee3
movq -0x20(%rbp), %rdi
movl $0x3c, %esi
movl $0x4, %edx
callq 0xa2f90
movq -0x20(%rbp), %rdi
movl %eax, -0x10(%rbp)
movl $0x34, %esi
movl $0x4, %edx
callq 0xa2f90
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl $0x2c, %esi
movl $0x4, %edx
callq 0xa2f90
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
shll $0x4, %ecx
orl %ecx, %eax
movl -0x10(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::color_quad_u8::set_rgb(rg_etc1::color_quad_u8 const&)
inline color_quad_u8& set_rgb(const color_quad_u8& other)
      {
         r = other.r;
         g = other.g;
         b = other.b;
         return *this;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movb (%rcx), %cl
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movb 0x1(%rcx), %cl
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rcx
movb 0x2(%rcx), %cl
movb %cl, 0x2(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::get_selector(unsigned int, unsigned int) const
inline uint get_selector(uint x, uint y) const
      {
         RG_ETC1_ASSERT((x | y) < 4);

         const uint bit_index = x * 4 + y;
         const uint byte_bit_ofs = bit_index & 7;
         const uint8 *p = &m_bytes[7 - (bit_index >> 3)];
         const uint lsb = (p[0] >> byte_bit_ofs) & 1;
         const uint msb = (p[-2] >> byte_bit_ofs) & 1;
         const uint val = lsb | (msb << 1);

         return g_etc1_to_selector_index[val];
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %eax
orl -0x10(%rbp), %eax
cmpl $0x4, %eax
jae 0xa1f57
jmp 0xa1f76
leaq 0x1696a(%rip), %rdi     # 0xb88c8
leaq 0x163be(%rip), %rsi     # 0xb8323
movl $0x260, %edx            # imm = 0x260
leaq 0x16963(%rip), %rcx     # 0xb88d4
callq 0x61a0
movq -0x38(%rbp), %rax
movl -0xc(%rbp), %ecx
shll $0x2, %ecx
addl -0x10(%rbp), %ecx
movl %ecx, -0x14(%rbp)
movl -0x14(%rbp), %ecx
andl $0x7, %ecx
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %edx
shrl $0x3, %edx
movl $0x7, %ecx
subl %edx, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl -0x18(%rbp), %ecx
sarl %cl, %eax
andl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movzbl -0x2(%rax), %eax
movl -0x18(%rbp), %ecx
sarl %cl, %eax
andl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl -0x28(%rbp), %ecx
shll %ecx
orl %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %ecx
leaq 0x16d61(%rip), %rax     # 0xb8d44
movzbl (%rax,%rcx), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_solution_coordinates::get_scaled_color() const
inline color_quad_u8 get_scaled_color() const
      {
         int br, bg, bb;
         if (m_color4)
         {
            br = m_unscaled_color.r | (m_unscaled_color.r << 4);
            bg = m_unscaled_color.g | (m_unscaled_color.g << 4);
            bb = m_unscaled_color.b | (m_unscaled_color.b << 4);
         }
         else
         {
            br = (m_unscaled_color.r >> 2) | (m_unscaled_color.r << 3);
            bg = (m_unscaled_color.g >> 2) | (m_unscaled_color.g << 3);
            bb = (m_unscaled_color.b >> 2) | (m_unscaled_color.b << 3);
         }
         return color_quad_u8(br, bg, bb);
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x8(%rax)
je 0xa20cd
movq -0x28(%rbp), %rcx
movzbl (%rcx), %eax
movzbl (%rcx), %edx
shll $0x4, %edx
orl %edx, %eax
movl %eax, -0x14(%rbp)
movzbl 0x1(%rcx), %eax
movzbl 0x1(%rcx), %edx
shll $0x4, %edx
orl %edx, %eax
movl %eax, -0x18(%rbp)
movzbl 0x2(%rcx), %eax
movzbl 0x2(%rcx), %ecx
shll $0x4, %ecx
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa2108
movq -0x28(%rbp), %rcx
movzbl (%rcx), %eax
sarl $0x2, %eax
movzbl (%rcx), %edx
shll $0x3, %edx
orl %edx, %eax
movl %eax, -0x14(%rbp)
movzbl 0x1(%rcx), %eax
sarl $0x2, %eax
movzbl 0x1(%rcx), %edx
shll $0x3, %edx
orl %edx, %eax
movl %eax, -0x18(%rbp)
movzbl 0x2(%rcx), %eax
sarl $0x2, %eax
movzbl 0x2(%rcx), %ecx
shll $0x3, %ecx
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl $0xff, %r8d
callq 0xa2d20
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_optimizer::results::operator=(rg_etc1::etc1_optimizer::results const&)
inline results& operator= (const results& rhs)
         {
            m_block_color_unscaled = rhs.m_block_color_unscaled;
            m_block_color4 = rhs.m_block_color4;
            m_block_inten_table = rhs.m_block_inten_table;
            m_error = rhs.m_error;
            RG_ETC1_ASSERT(m_n == rhs.m_n);
            memcpy(m_pSelectors, rhs.m_pSelectors, rhs.m_n);
            return *this;
         }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0xa1ff0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb 0x20(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x20(%rax)
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jne 0xa2f0c
jmp 0xa2f2b
leaq 0x15bfd(%rip), %rdi     # 0xb8b10
leaq 0x15409(%rip), %rsi     # 0xb8323
movl $0x599, %edx            # imm = 0x599
leaq 0x15bf9(%rip), %rcx     # 0xb8b1f
callq 0x61a0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %edx
callq 0x60c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)