LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::get_byte_bits(unsigned int, unsigned int) const
inline uint get_byte_bits(uint ofs, uint num) const
      {
         RG_ETC1_ASSERT((ofs + num) <= 64U);
         RG_ETC1_ASSERT(num && (num <= 8U));
         RG_ETC1_ASSERT((ofs >> 3) == ((ofs + num - 1) >> 3));
         const uint byte_ofs = 7 - (ofs >> 3);
         const uint byte_bit_ofs = ofs & 7;
         return (m_bytes[byte_ofs] >> byte_bit_ofs) & ((1 << num) - 1);
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
cmpl $0x40, %eax
ja 0xa2fb7
jmp 0xa2fd6
leaq 0x15885(%rip), %rdi     # 0xb8843
leaq 0x1535e(%rip), %rsi     # 0xb8323
movl $0x21d, %edx            # imm = 0x21D
leaq 0x15885(%rip), %rcx     # 0xb8856
callq 0x61a0
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x21(%rbp)
je 0xa2feb
cmpl $0x8, -0x10(%rbp)
setbe %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xa2ff4
jmp 0xa2ff6
jmp 0xa3015
leaq 0x15893(%rip), %rdi     # 0xb8890
leaq 0x1531f(%rip), %rsi     # 0xb8323
movl $0x21e, %edx            # imm = 0x21E
leaq 0x15846(%rip), %rcx     # 0xb8856
callq 0x61a0
movl -0xc(%rbp), %eax
shrl $0x3, %eax
movl -0xc(%rbp), %ecx
addl -0x10(%rbp), %ecx
subl $0x1, %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
jne 0xa302d
jmp 0xa304c
leaq 0x1586f(%rip), %rdi     # 0xb88a3
leaq 0x152e8(%rip), %rsi     # 0xb8323
movl $0x21f, %edx            # imm = 0x21F
leaq 0x1580f(%rip), %rcx     # 0xb8856
callq 0x61a0
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %edx
shrl $0x3, %edx
movl $0x7, %ecx
subl %edx, %ecx
movl %ecx, -0x14(%rbp)
movl -0xc(%rbp), %ecx
andl $0x7, %ecx
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movl -0x18(%rbp), %ecx
sarl %cl, %eax
movl -0x10(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
addq $0x30, %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::operator=(rg_etc1::etc1_solution_coordinates const&)
inline etc1_solution_coordinates& operator= (const etc1_solution_coordinates& rhs)
      {
         m_unscaled_color = rhs.m_unscaled_color;
         m_inten_table = rhs.m_inten_table;
         m_color4 = rhs.m_color4;
         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
callq 0xa1ff0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rcx
movb 0x8(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_optimizer::clear()
void clear()
      {
         m_pParams = NULL;
         m_pResult = NULL;
         m_pSorted_luma = NULL;
         m_pSorted_luma_indices = NULL;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x88(%rax)
movq $0x0, 0x80(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_optimizer::params::clear_optimizer_params()
void clear_optimizer_params()
         {
            m_num_src_pixels = 0;
            m_pSrc_pixels = 0;

            m_use_color4 = false;
            static const int s_default_scan_delta[] = { 0 };
            m_pScan_deltas = s_default_scan_delta;
            m_scan_delta_size = 1;

            m_base_color5.clear();
            m_constrain_against_base_color5 = false;
         }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x173c2(%rip), %rax     # 0xba5b0
movq %rax, 0x20(%rdi)
movl $0x1, 0x28(%rdi)
addq $0x2c, %rdi
callq 0xa3090
movq -0x10(%rbp), %rax
movb $0x0, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/squish.cpp
// Function: squish::FixFlags(int)
static int FixFlags( int flags )
{
    // grab the flag bits
    int method = flags & ( kDxt1 | kDxt3 | kDxt5 | kBc4 | kBc5 );
    int fit = flags & ( kColourIterativeClusterFit | kColourClusterFit | kColourRangeFit );
    int extra = flags & (kWeightColourByAlpha | kSourceBGRA);   //JonoF

    // set defaults
    if ( method != kDxt3
    &&   method != kDxt5
    &&   method != kBc4
    &&   method != kBc5 )
    {
        method = kDxt1;
    }
    if( fit != kColourRangeFit && fit != kColourIterativeClusterFit )
        fit = kColourClusterFit;

    // done
    return method | fit | extra;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
andl $0x1f, %eax
movl %eax, -0x8(%rsp)
movl -0x4(%rsp), %eax
andl $0x160, %eax            # imm = 0x160
movl %eax, -0xc(%rsp)
movl -0x4(%rsp), %eax
andl $0x280, %eax            # imm = 0x280
movl %eax, -0x10(%rsp)
cmpl $0x2, -0x8(%rsp)
je 0xa364d
cmpl $0x4, -0x8(%rsp)
je 0xa364d
cmpl $0x8, -0x8(%rsp)
je 0xa364d
cmpl $0x10, -0x8(%rsp)
je 0xa364d
movl $0x1, -0x8(%rsp)
cmpl $0x40, -0xc(%rsp)
je 0xa3666
cmpl $0x100, -0xc(%rsp)      # imm = 0x100
je 0xa3666
movl $0x20, -0xc(%rsp)
movl -0x8(%rsp), %eax
orl -0xc(%rsp), %eax
orl -0x10(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/squish.cpp
// Function: squish::Decompress(unsigned char*, void const*, int)
void Decompress( u8* rgba, void const* block, int flags )
{
    // fix any bad flags
    flags = FixFlags( flags );

    // get the block locations
    void const* colourBlock = block;
    void const* alphaBlock = block;
    if( ( flags & ( kDxt3 | kDxt5 ) ) != 0 )
        colourBlock = reinterpret_cast< u8 const* >( block ) + 8;

    // decompress colour
    DecompressColour( rgba, colourBlock, ( flags & kDxt1 ) != 0 );

    // decompress alpha separately if necessary
    if( ( flags & kDxt3 ) != 0 )
        DecompressAlphaDxt3( rgba, alphaBlock );
    else if( ( flags & kDxt5 ) != 0 )
        DecompressAlphaDxt5( rgba, alphaBlock );
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl 0x14(%rsp), %edi
callq 0xa3600
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl 0x14(%rsp), %eax
andl $0x6, %eax
cmpl $0x0, %eax
je 0xa36cc
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x14(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
movzbl %al, %edx
andl $0x1, %edx
callq 0xac200
movl 0x14(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xa370a
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0xa86b0
jmp 0xa3726
movl 0x14(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xa3724
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0xa8d60
jmp 0xa3726
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/squish.cpp
// Function: squish::GetStorageRequirements(int, int, int)
int GetStorageRequirements( int width, int height, int flags )
{
    // fix any bad flags
    flags = FixFlags( flags );

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

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl 0xc(%rsp), %edi
callq 0xa3600
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %eax
addl $0x3, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, (%rsp)
movl 0x10(%rsp), %eax
addl $0x3, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl (%rsp), %eax
imull %ecx, %eax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %edx
andl $0x9, %edx
movl $0x10, %eax
movl $0x8, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x4(%rsp)
movl 0x8(%rsp), %eax
imull 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/squish.cpp
// Function: squish::CopyRGBA(unsigned char const*, unsigned char*, int)
void CopyRGBA( u8 const* source, u8* dest, int flags )
{
    if (flags & kSourceBGRA)
    {
        // convert from bgra to rgba
        dest[0] = source[2];
        dest[1] = source[1];
        dest[2] = source[0];
        dest[3] = source[3];
    }
    else
    {
        for( int i = 0; i < 4; ++i )
            *dest++ = *source++;
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0xa380c
movq -0x8(%rsp), %rax
movb 0x2(%rax), %cl
movq -0x10(%rsp), %rax
movb %cl, (%rax)
movq -0x8(%rsp), %rax
movb 0x1(%rax), %cl
movq -0x10(%rsp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rsp), %rax
movb (%rax), %cl
movq -0x10(%rsp), %rax
movb %cl, 0x2(%rax)
movq -0x8(%rsp), %rax
movb 0x3(%rax), %cl
movq -0x10(%rsp), %rax
movb %cl, 0x3(%rax)
jmp 0xa3850
movl $0x0, -0x18(%rsp)
cmpl $0x4, -0x18(%rsp)
jge 0xa384e
movq -0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rsp)
movb (%rax), %cl
movq -0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rsp)
movb %cl, (%rax)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0xa3814
jmp 0xa3850
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: wm_msgbox
int wm_msgbox(const char *name, const char *fmt, ...)
{
	char *buf = NULL;
	int rv;
	va_list va;

	if (!name) {
		name = apptitle;
	}

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

	if (rv < 0) return -1;

	do {
		rv = 0;

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

		puts(buf);
	} while(0);

	free(buf);

	return rv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0xa448b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa44c9
leaq 0x3d76b(%rip), %rax     # 0xe1c30
movq %rax, -0x10(%rbp)
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x326d0
movl %eax, -0x24(%rbp)
leaq -0x40(%rbp), %rax
cmpl $0x0, -0x24(%rbp)
jge 0xa4514
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa4577
jmp 0xa4516
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xa70f0
cmpl $0x0, %eax
jl 0xa4538
movl $0x1, -0x24(%rbp)
jmp 0xa4568
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq 0x61bd59(%rip), %rcx    # 0x6c02a0
movl $0x40, %edi
callq 0x6a00
cmpl $0x0, %eax
jl 0xa455f
movl $0x1, -0x24(%rbp)
jmp 0xa4568
movq -0x20(%rbp), %rdi
callq 0x69e0
movq -0x20(%rbp), %rdi
callq 0x61c0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: wm_ynbox
int wm_ynbox(const char *name, const char *fmt, ...)
{
	char *buf = NULL;
	int rv;
	va_list va;

	if (!name) {
		name = apptitle;
	}

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

	if (rv < 0) return -1;

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

	do {
		rv = 0;

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

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

	free(buf);

	return rv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
testb %al, %al
je 0xa45d7
movaps %xmm0, -0x120(%rbp)
movaps %xmm1, -0x110(%rbp)
movaps %xmm2, -0x100(%rbp)
movaps %xmm3, -0xf0(%rbp)
movaps %xmm4, -0xe0(%rbp)
movaps %xmm5, -0xd0(%rbp)
movaps %xmm6, -0xc0(%rbp)
movaps %xmm7, -0xb0(%rbp)
movq %r9, -0x128(%rbp)
movq %r8, -0x130(%rbp)
movq %rcx, -0x138(%rbp)
movq %rdx, -0x140(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa4615
leaq 0x3d61f(%rip), %rax     # 0xe1c30
movq %rax, -0x10(%rbp)
leaq -0x40(%rbp), %rax
leaq -0x150(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x326d0
movl %eax, -0x24(%rbp)
leaq -0x40(%rbp), %rax
cmpl $0x0, -0x24(%rbp)
jge 0xa4663
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa4740
movq 0x2a546(%rip), %rax     # 0xcebb0
movq %rax, -0x60(%rbp)
movq 0x2a543(%rip), %rax     # 0xcebb8
movq %rax, -0x58(%rbp)
movq 0x2a540(%rip), %rax     # 0xcebc0
movq %rax, -0x50(%rbp)
movq 0x2a53d(%rip), %rax     # 0xcebc8
movq %rax, -0x48(%rbp)
movl $0x40, -0x98(%rbp)
movq 0x61bc00(%rip), %rax    # 0x6c02a0
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x2, -0x78(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
movq $0x0, -0x68(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xa71a0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jl 0xa46ef
jmp 0xa4731
leaq -0x98(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x65c0
cmpl $0x0, %eax
jl 0xa4715
cmpl $0x1, -0x24(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
jmp 0xa4731
movq -0x20(%rbp), %rdi
callq 0x69e0
leaq 0x15ea2(%rip), %rdi     # 0xba5c7
callq 0x69e0
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x61c0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: wm_filechooser
int wm_filechooser(const char *initialdir, const char *initialfile, const char *type, int foropen, char **choice)
{
#if defined __APPLE__ || defined HAVE_GTK
    int rv;
    if (mouseacquired && moustat) {
        SDL_SetRelativeMouseMode(SDL_FALSE);
    }
#if defined __APPLE__
    rv = wmosx_filechooser(initialdir, initialfile, type, foropen, choice);
#elif defined HAVE_GTK
    rv = wmgtk_filechooser(initialdir, initialfile, type, foropen, choice);
#endif
    SDL_RaiseWindow(sdl_window);
    if (mouseacquired && moustat) {
        SDL_SetRelativeMouseMode(SDL_TRUE);
    }
    return rv;
#else
    (void)initialdir; (void)initialfile; (void)type; (void)foropen; (void)choice;
#endif
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movsbl 0x61bb36(%rip), %eax    # 0x6c02a8
cmpl $0x0, %eax
je 0xa478a
movsbl 0x61bb2b(%rip), %eax    # 0x6c02a9
cmpl $0x0, %eax
je 0xa478a
xorl %edi, %edi
callq 0x64e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
callq 0xa7260
movl %eax, -0x2c(%rbp)
movq 0x61baf4(%rip), %rdi    # 0x6c02a0
callq 0x67d0
movsbl 0x61baf0(%rip), %eax    # 0x6c02a8
cmpl $0x0, %eax
je 0xa47d3
movsbl 0x61bae5(%rip), %eax    # 0x6c02a9
cmpl $0x0, %eax
je 0xa47d3
movl $0x1, %edi
callq 0x64e0
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: wm_setapptitle
void wm_setapptitle(const char *name)
{
	if (name) {
		Bstrncpy(apptitle, name, sizeof(apptitle)-1);
		apptitle[ sizeof(apptitle)-1 ] = 0;
	}
#if defined HAVE_GTK
	wmgtk_setapptitle(apptitle);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa482f
movq -0x8(%rbp), %rsi
leaq 0x3d412(%rip), %rdi     # 0xe1c30
movl $0xff, %edx
callq 0x6180
movb $0x0, 0x3d500(%rip)     # 0xe1d2f
leaq 0x3d3fa(%rip), %rdi     # 0xe1c30
callq 0xa70c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: wm_setwindowtitle
void wm_setwindowtitle(const char *name)
{
	if (name) {
		Bstrncpy(wintitle, name, sizeof(wintitle)-1);
		wintitle[ sizeof(wintitle)-1 ] = 0;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa487f
movq -0x8(%rbp), %rsi
leaq 0x61ba42(%rip), %rdi    # 0x6c02b0
movl $0xff, %edx
callq 0x6180
movb $0x0, 0x61bb30(%rip)    # 0x6c03af
cmpq $0x0, 0x61ba19(%rip)    # 0x6c02a0
je 0xa489c
movq 0x61ba10(%rip), %rdi    # 0x6c02a0
leaq 0x61ba19(%rip), %rsi    # 0x6c02b0
callq 0x61d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: initsystem
int initsystem(void)
{
	SDL_version linked;
	SDL_version compiled;

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

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

	atexit(uninitsystem);

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

	OSD_RegisterFunction("glswapinterval", "glswapinterval: frame swap interval for OpenGL modes. 0 = no vsync, -1 = adaptive, max 2", set_glswapinterval);
#endif

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x3(%rbp), %rdi
callq 0x6610
movb $0x2, -0x6(%rbp)
movb $0x0, -0x5(%rbp)
movb $0x14, -0x4(%rbp)
movzbl -0x3(%rbp), %esi
movzbl -0x2(%rbp), %edx
movzbl -0x1(%rbp), %ecx
movzbl -0x6(%rbp), %r8d
movzbl -0x5(%rbp), %r9d
movzbl -0x4(%rbp), %eax
leaq 0x15866(%rip), %rdi     # 0xba604
movl %eax, (%rsp)
movb $0x0, %al
callq 0x37c90
leaq 0x91(%rip), %rdi        # 0xa4e40
callq 0xaef40
leaq 0x1589f(%rip), %rdi     # 0xba65a
callq 0x6740
cmpq $0x0, %rax
je 0xa4de1
leaq 0x15898(%rip), %rdi     # 0xba665
callq 0x4a720
leaq 0x115e6f(%rip), %rax    # 0x1bac48
movl $0x1, (%rax)
jmp 0xa4e1a
leaq 0x1588f(%rip), %rdi     # 0xba677
callq 0x6740
movq %rax, %rdi
callq 0xa4e70
movl %eax, %ecx
leaq 0x115e4a(%rip), %rax    # 0x1bac48
movl %ecx, (%rax)
leaq 0x115e41(%rip), %rax    # 0x1bac48
cmpl $0x0, (%rax)
je 0xa4e18
leaq 0x15870(%rip), %rdi     # 0xba683
callq 0x4a720
jmp 0xa4e1a
leaq 0x1589f(%rip), %rdi     # 0xba6c0
leaq 0x158a7(%rip), %rsi     # 0xba6cf
leaq 0xa1(%rip), %rdx        # 0xa4ed0
callq 0x6c300
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: uninitsystem
void uninitsystem(void)
{
	uninitinput();
	uninitmouse();
	uninittimer();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0xa4fb0
callq 0xa4fe0
callq 0xa5000
callq 0xa5020
callq 0x710f0
callq 0xa50d0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: loadgldriver
int loadgldriver(const char *soname)
{
	const char *name = soname;
	if (!name) {
		name = "system OpenGL library";
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa4e96
leaq 0x15b02(%rip), %rax     # 0xba994
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x15b09(%rip), %rdi     # 0xba9aa
movb $0x0, %al
callq 0x37c90
movq -0x10(%rbp), %rdi
callq 0x6710
cmpl $0x0, %eax
je 0xa4ebf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa4ec6
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/sdlayer2.c
// Function: set_glswapinterval
static int set_glswapinterval(const osdfuncparm_t *parm)
{
	int interval;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x115d65(%rip), %rax    # 0x1bac48
cmpl $0x0, (%rax)
je 0xa4f00
leaq 0x15ac7(%rip), %rdi     # 0xba9b6
callq 0x4a720
movl $0x0, -0x4(%rbp)
jmp 0xa4f9f
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xa4f29
leaq 0x3b4dc(%rip), %rax     # 0xe03ec
movl (%rax), %esi
leaq 0x15abf(%rip), %rdi     # 0xba9d8
movb $0x0, %al
callq 0x37c90
movl $0x0, -0x4(%rbp)
jmp 0xa4f9f
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
je 0xa4f3b
movl $0x1, -0x4(%rbp)
jmp 0xa4f9f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x62e0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jl 0xa4f5a
cmpl $0x2, -0x14(%rbp)
jle 0xa4f63
movl $0x1, -0x4(%rbp)
jmp 0xa4f9f
movl -0x14(%rbp), %edi
callq 0x6520
cmpl $0x0, %eax
jge 0xa4f88
callq 0x6a60
movq %rax, %rsi
leaq 0x15a6f(%rip), %rdi     # 0xba9ee
movb $0x0, %al
callq 0x37c90
jmp 0xa4f98
callq 0x65a0
movl %eax, %ecx
leaq 0x3b456(%rip), %rax     # 0xe03ec
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: uninitinput
void uninitinput(void)
{
	uninitmouse();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0xa4fe0
cmpq $0x0, 0x61cfef(%rip)    # 0x6c1fb0
je 0xa4fda
movq 0x61cfe6(%rip), %rdi    # 0x6c1fb0
callq 0x6330
movq $0x0, 0x61cfd6(%rip) # 0x6c1fb0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: getjoyname
const char *getjoyname(int what, int num)
{
	switch (what) {
		case 0: // axis
			return SDL_GameControllerGetStringForAxis(num);
		case 1: // button
			return SDL_GameControllerGetStringForButton(num);
		default:
			return NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0xa5404
jmp 0xa53fa
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0xa5412
jmp 0xa5420
movl -0x10(%rbp), %edi
callq 0x6810
movq %rax, -0x8(%rbp)
jmp 0xa5428
movl -0x10(%rbp), %edi
callq 0x6c30
movq %rax, -0x8(%rbp)
jmp 0xa5428
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: grabmouse
void grabmouse(int a)
{
	if (appactive && moustat) {
		if (a != mouseacquired) {
			SDL_SetRelativeMouseMode(a ? SDL_TRUE : SDL_FALSE);
			mouseacquired = a;
		}
	} else {
		mouseacquired = a;
	}
	mousex = mousey = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x3af7e(%rip), %rax     # 0xe03f0
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xa54b4
movsbl 0x61ae28(%rip), %eax    # 0x6c02a9
cmpl $0x0, %eax
je 0xa54b4
movl -0x4(%rbp), %eax
movsbl 0x61ae18(%rip), %ecx    # 0x6c02a8
cmpl %ecx, %eax
je 0xa54b2
movl -0x4(%rbp), %ecx
xorl %edi, %edi
movl $0x1, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
callq 0x64e0
movl -0x4(%rbp), %eax
movb %al, 0x61adf6(%rip)     # 0x6c02a8
jmp 0xa54bd
movl -0x4(%rbp), %eax
movb %al, 0x61adeb(%rip)     # 0x6c02a8
leaq 0x115774(%rip), %rax    # 0x1bac38
movl $0x0, (%rax)
leaq 0x115763(%rip), %rax    # 0x1bac34
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: readmousexy
void readmousexy(int *x, int *y)
{
	if (!mouseacquired || !appactive || !moustat) { *x = *y = 0; return; }
	*x = mousex;
	*y = mousey;
	mousex = mousey = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpb $0x0, 0x61adb5(%rip)    # 0x6c02a8
je 0xa550a
leaq 0x3aef4(%rip), %rax     # 0xe03f0
cmpb $0x0, (%rax)
je 0xa550a
cmpb $0x0, 0x61ada1(%rip)    # 0x6c02a9
jne 0xa5520
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
jmp 0xa5558
leaq 0x11570d(%rip), %rax    # 0x1bac34
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
leaq 0x115702(%rip), %rax    # 0x1bac38
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
leaq 0x1156f3(%rip), %rax    # 0x1bac38
movl $0x0, (%rax)
leaq 0x1156e2(%rip), %rax    # 0x1bac34
movl $0x0, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: inittimer
int inittimer(int tickspersecond, void(*callback)(void))
{
	if (timerfreq) return 0;    // already installed

	buildputs("Initialising timer\n");

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

	usertimercallback = callback;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x61c9d1(%rip)    # 0x6c1fb8
je 0xa55f2
movl $0x0, -0x4(%rbp)
jmp 0xa5645
leaq 0x151cd(%rip), %rdi     # 0xba7c6
callq 0x4a720
callq 0x6b60
movq %rax, 0x61c9ae(%rip)    # 0x6c1fb8
movl -0x8(%rbp), %eax
movl %eax, 0x61c9ad(%rip)    # 0x6c1fc0
callq 0x6290
movl 0x61c9a2(%rip), %ecx    # 0x6c1fc0
imulq %rcx, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x61c98b(%rip)          # 0x6c1fb8
movl %eax, 0x61c991(%rip)    # 0x6c1fc4
movq -0x10(%rbp), %rax
movq %rax, 0x61c98a(%rip)    # 0x6c1fc8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: sampletimer
void sampletimer(void)
{
	int n;

	if (!timerfreq) return;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x61c958(%rip)    # 0x6c1fb8
jne 0xa5664
jmp 0xa56d6
callq 0x6290
movl 0x61c951(%rip), %ecx    # 0x6c1fc0
imulq %rcx, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x61c93a(%rip)          # 0x6c1fb8
subl 0x61c940(%rip), %eax    # 0x6c1fc4
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0xa56b1
movl -0x4(%rbp), %ecx
leaq 0x3439b1(%rip), %rax    # 0x3e9048
addl (%rax), %ecx
leaq 0x3439a8(%rip), %rax    # 0x3e9048
movl %ecx, (%rax)
movl -0x4(%rbp), %eax
addl 0x61c919(%rip), %eax    # 0x6c1fc4
movl %eax, 0x61c913(%rip)    # 0x6c1fc4
cmpq $0x0, 0x61c90f(%rip)    # 0x6c1fc8
je 0xa56d6
jmp 0xa56bd
cmpl $0x0, -0x4(%rbp)
jle 0xa56d4
callq *0x61c8ff(%rip)         # 0x6c1fc8
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xa56bd
jmp 0xa56d6
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: sortmodes
static int sortmodes(const struct validmode_t *a, const struct validmode_t *b)
{
	int x;

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

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x9(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x9(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0xa602e
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa6091
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0xa6050
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa6091
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0xa606c
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa6091
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
subl 0x4(%rcx), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0xa608a
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa6091
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: loadappicon
static SDL_Surface * loadappicon(void)
{
	SDL_Surface *surf;

	surf = SDL_CreateRGBSurfaceFrom((void*)sdlappicon.pixels,
			sdlappicon.width, sdlappicon.height, 32, sdlappicon.width*4,
			0xffl,0xff00l,0xff0000l,0xff000000l);

	return surf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x397b1(%rip), %rax     # 0xdfef0
movq 0x8(%rax), %rdi
leaq 0x397a6(%rip), %rax     # 0xdfef0
movl (%rax), %esi
leaq 0x3979d(%rip), %rax     # 0xdfef0
movl 0x4(%rax), %edx
leaq 0x39793(%rip), %rax     # 0xdfef0
movl (%rax), %r8d
shll $0x2, %r8d
movl $0x20, %ecx
movl $0xff, %r9d
movl $0xff00, (%rsp)         # imm = 0xFF00
movl $0xff0000, 0x8(%rsp)    # imm = 0xFF0000
movl $0xff000000, 0x10(%rsp) # imm = 0xFF000000
callq 0x66c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: setpalette
int setpalette(int start, int num, unsigned char *dapal)
{
	(void)start; (void)num; (void)dapal;
#if USE_OPENGL
	if (!glunavailable) {
		glbuild_update_8bit_palette(&gl8bit, curpalettefaded);
	}
#endif
#ifndef SDLAYER_USE_RENDERER
	if (sdl_surface) {
		if (SDL_SetPaletteColors(sdl_surface->format->palette, (const SDL_Color *)curpalettefaded, 0, 256)) {
			debugprintf("Could not set palette: %s\n", SDL_GetError());
		}
	}
#endif
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
leaq 0x1142df(%rip), %rax    # 0x1bac48
cmpl $0x0, (%rax)
jne 0xa6981
leaq 0x61b673(%rip), %rdi    # 0x6c1fe8
leaq 0x3cac84(%rip), %rsi    # 0x471600
callq 0x71df0
cmpq $0x0, 0x61b64f(%rip)    # 0x6c1fd8
je 0xa69ca
movq 0x61b646(%rip), %rax    # 0x6c1fd8
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x3cac5f(%rip), %rsi    # 0x471600
xorl %edx, %edx
movl $0x100, %ecx            # imm = 0x100
callq 0x6ac0
cmpl $0x0, %eax
je 0xa69c8
callq 0x6a60
movq %rax, %rsi
leaq 0x13fb8(%rip), %rdi     # 0xba979
movb $0x0, %al
callq 0xa5110
jmp 0xa69ca
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: setsysgamma
int setsysgamma(float shadergamma, float sysgamma)
{
	int r = 0;
#if USE_OPENGL
	if (!glunavailable && bpp == 8) glbuild_set_8bit_gamma(&gl8bit, shadergamma);
#endif
	if (sdl_window) {
		if (sysgamma < 0.f) r = SDL_SetWindowBrightness(sdl_window, 1.0);
		else r = SDL_SetWindowBrightness(sdl_window, sysgamma);
	}
	if (r == 0) { curshadergamma = shadergamma; cursysgamma = sysgamma; }
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0x114248(%rip), %rax    # 0x1bac48
cmpl $0x0, (%rax)
jne 0xa6a22
leaq 0x1141f8(%rip), %rax    # 0x1bac04
cmpl $0x8, (%rax)
jne 0xa6a22
movss -0x4(%rbp), %xmm0
leaq 0x61b5cb(%rip), %rdi    # 0x6c1fe8
callq 0x71e70
cmpq $0x0, 0x619876(%rip)    # 0x6c02a0
je 0xa6a64
xorps %xmm0, %xmm0
ucomiss -0x8(%rbp), %xmm0
jbe 0xa6a4e
movq 0x619864(%rip), %rdi    # 0x6c02a0
movss 0xc3bc(%rip), %xmm0     # 0xb2e00
callq 0x6140
movl %eax, -0xc(%rbp)
jmp 0xa6a62
movq 0x61984b(%rip), %rdi    # 0x6c02a0
movss -0x8(%rbp), %xmm0
callq 0x6140
movl %eax, -0xc(%rbp)
jmp 0xa6a64
cmpl $0x0, -0xc(%rbp)
jne 0xa6a84
movss -0x4(%rbp), %xmm0
movss %xmm0, 0x3b371(%rip)    # 0xe1de8
movss -0x8(%rbp), %xmm0
movss %xmm0, 0x3b368(%rip)    # 0xe1dec
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/gtkbits.c
// Function: wmgtk_msgbox
int wmgtk_msgbox(char *name, char *msg)
{
	GtkWidget *dialog;

	if (!gtkenabled) return -1;

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

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpl $0x0, 0x61af11(%rip)    # 0x6c2018
jne 0xa7112
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa718e
movq -0x18(%rbp), %r9
xorl %eax, %eax
movl %eax, %edi
movl $0x2, %esi
xorl %edx, %edx
movl $0x1, %ecx
leaq 0x98ce(%rip), %r8       # 0xb09fb
movb $0x0, %al
callq 0x68e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x6b70
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x6130
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x6210
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x6650
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x6130
movq %rax, %rdi
callq 0x6260
movq -0x20(%rbp), %rdi
callq 0x6170
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/gtkbits.c
// Function: wmgtk_ynbox
int wmgtk_ynbox(char *name, char *msg)
{
	int r;
	GtkWidget *dialog;

	if (!gtkenabled) return -1;

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

	if (r == GTK_RESPONSE_YES) return 1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpl $0x0, 0x61ae61(%rip)    # 0x6c2018
jne 0xa71c5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa7253
movq -0x18(%rbp), %r9
xorl %eax, %eax
movl %eax, %edi
movl $0x2, %esi
xorl %edx, %edx
movl $0x4, %ecx
leaq 0x981b(%rip), %r8       # 0xb09fb
movb $0x0, %al
callq 0x68e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x6b70
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x6130
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x6210
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x6650
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x6130
movq %rax, %rdi
callq 0x6260
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6170
cmpl $-0x8, -0x1c(%rbp)
jne 0xa724c
movl $0x1, -0x4(%rbp)
jmp 0xa7253
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/gtkbits.c
// Function: wmgtk_init
void wmgtk_init(int *argc, char ***argv)
{
	GdkPixbuf *appicon = NULL;
	GError *error = NULL;

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

	startgtk_register_resource();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6800
movl %eax, 0x61ab95(%rip)    # 0x6c2018
cmpl $0x0, 0x61ab8e(%rip)    # 0x6c2018
jne 0xa748e
jmp 0xa74e5
callq 0xc280
leaq 0xa595(%rip), %rdi      # 0xb1a2f
leaq -0x20(%rbp), %rsi
callq 0x6960
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa74c6
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x13575(%rip), %rdi     # 0xbaa32
movb $0x0, %al
callq 0x37c90
jmp 0xa74e5
movq -0x18(%rbp), %rdi
callq 0x6920
movq -0x18(%rbp), %rdi
movl $0x50, %esi
callq 0x6130
movq %rax, %rdi
callq 0x69d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/a-c.c
// Function: hlineasm4
void hlineasm4(int cnt, int skiploadincs, int paloffs, unsigned int by, unsigned int bx, void *p)
{
	unsigned char *palptr, *pp;

	palptr = &ghlinepal[paloffs];
	pp = (unsigned char *)p;
	if (!skiploadincs) { gbxinc = asm1; gbyinc = asm2; }
	for(;cnt>=0;cnt--)
	{
		*pp = palptr[gbuf[((bx>>(32-glogx))<<glogy)+(by>>(32-glogy))]];
		bx -= gbxinc;
		by -= gbyinc;
		pp--;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movq %r9, -0x20(%rbp)
movq 0x61aa09(%rip), %rax    # 0x6c2048
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0xa7676
leaq 0x3aa355(%rip), %rax    # 0x4519b4
movl (%rax), %eax
movl %eax, 0x61a9e9(%rip)    # 0x6c2050
leaq 0x3aa34a(%rip), %rax    # 0x4519b8
movl (%rax), %eax
movl %eax, 0x61a9de(%rip)    # 0x6c2054
jmp 0xa7678
cmpl $0x0, -0x4(%rbp)
jl 0xa7704
movq -0x28(%rbp), %rax
movq 0x61a9b3(%rip), %rcx    # 0x6c2040
movq %rcx, -0x38(%rbp)
movl -0x14(%rbp), %edx
movl $0x20, %ecx
subl 0x61a995(%rip), %ecx    # 0x6c2034
shrl %cl, %edx
movl 0x61a991(%rip), %ecx    # 0x6c2038
shll %cl, %edx
movl -0x10(%rbp), %esi
movl $0x20, %ecx
subl 0x61a981(%rip), %ecx    # 0x6c2038
shrl %cl, %esi
movq -0x38(%rbp), %rcx
addl %esi, %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
movb (%rax,%rcx), %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movl 0x61a97c(%rip), %ecx    # 0x6c2050
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl 0x61a972(%rip), %ecx    # 0x6c2054
movl -0x10(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x10(%rbp)
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xa7678
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/a-c.c
// Function: slopevlin
void slopevlin(void *p, int i, void *slopaloffs, int cnt, int bx, int by)
{
	intptr_t *slopalptr;
	int bz, bzinc;
	unsigned int u, v;
	unsigned char *pp;

	bz = (int)asm3; bzinc = (asm1>>3);
	slopalptr = (intptr_t *)slopaloffs;
	pp = (unsigned char *)p;
	for(;cnt>0;cnt--)
	{
		i = krecip(bz>>6); bz += bzinc;
		u = bx+globalx3*i;
		v = by+globaly3*i;
		*pp = *(unsigned char *)(slopalptr[0]+gbuf[((u>>(32-glogx))<<glogy)+(v>>(32-glogy))]);
		slopalptr--;
		pp += gpinc;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
leaq 0x3aa24b(%rip), %rax    # 0x4519c0
movq (%rax), %rax
movl %eax, -0x34(%rbp)
leaq 0x3aa232(%rip), %rax    # 0x4519b4
movl (%rax), %eax
sarl $0x3, %eax
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0xa7864
movl -0x34(%rbp), %edi
sarl $0x6, %edi
callq 0x4f130
movl %eax, -0xc(%rbp)
movl -0x38(%rbp), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x20(%rbp), %eax
leaq 0x3e118f(%rip), %rcx    # 0x488954
movl (%rcx), %ecx
imull -0xc(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x3c(%rbp)
movl -0x24(%rbp), %eax
leaq 0x3e117e(%rip), %rcx    # 0x488958
movl (%rcx), %ecx
imull -0xc(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x61a84d(%rip), %rcx    # 0x6c2040
movq %rcx, -0x50(%rbp)
movl -0x3c(%rbp), %edx
movl $0x20, %ecx
subl 0x61a82f(%rip), %ecx    # 0x6c2034
shrl %cl, %edx
movl 0x61a82b(%rip), %ecx    # 0x6c2038
shll %cl, %edx
movl -0x40(%rbp), %esi
movl $0x20, %ecx
subl 0x61a81b(%rip), %ecx    # 0x6c2038
shrl %cl, %esi
movq -0x50(%rbp), %rcx
addl %esi, %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
addq %rcx, %rax
movb (%rax), %cl
movq -0x48(%rbp), %rax
movb %cl, (%rax)
movq -0x30(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x30(%rbp)
movl 0x61a810(%rip), %ecx    # 0x6c2058
movq -0x48(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa779a
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/a-c.c
// Function: vlineasm1
void vlineasm1(int vinc, void *paloffs, int cnt, unsigned int vplc, void *bufplc, void *p)
{
	unsigned char *pp;

	gbuf = (unsigned char *)bufplc;
	gpal = (unsigned char *)paloffs;
	pp = (unsigned char *)p;
	for(;cnt>=0;cnt--)
	{
		*pp = gpal[gbuf[vplc>>glogy]];
		pp += bpl;
		vplc += vinc;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0x61a78c(%rip)    # 0x6c2040
movq -0x10(%rbp), %rax
movq %rax, 0x61a7a1(%rip)    # 0x6c2060
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0xa7925
movq 0x61a78c(%rip), %rax    # 0x6c2060
movq 0x61a765(%rip), %rcx    # 0x6c2040
movq %rcx, -0x38(%rbp)
movl -0x18(%rbp), %edx
movl 0x61a750(%rip), %ecx    # 0x6c2038
shrl %cl, %edx
movq -0x38(%rbp), %rcx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
movb (%rax,%rcx), %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movl 0x61a71d(%rip), %ecx    # 0x6c2020
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa78c7
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/a-c.c
// Function: mvlineasm1
void mvlineasm1(int vinc, void *paloffs, int cnt, unsigned int vplc, void *bufplc, void *p)
{
	unsigned char ch, *pp;

	gbuf = (unsigned char *)bufplc;
	gpal = (unsigned char *)paloffs;
	pp = (unsigned char *)p;
	for(;cnt>=0;cnt--)
	{
		ch = gbuf[vplc>>glogy]; if (ch != 255) *pp = gpal[ch];
		pp += bpl;
		vplc += vinc;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0x61a6cc(%rip)    # 0x6c2040
movq -0x10(%rbp), %rax
movq %rax, 0x61a6e1(%rip)    # 0x6c2060
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0xa79f0
movq 0x61a6ac(%rip), %rax    # 0x6c2040
movl -0x18(%rbp), %edx
movl 0x61a69b(%rip), %ecx    # 0x6c2038
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0xff, %eax
je 0xa79c8
movq 0x61a6a5(%rip), %rax    # 0x6c2060
movzbl -0x29(%rbp), %ecx
movb (%rax,%rcx), %cl
movq -0x38(%rbp), %rax
movb %cl, (%rax)
movl 0x61a652(%rip), %ecx    # 0x6c2020
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0x4(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa7987
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/a-c.c
// Function: tvlineasm1
void tvlineasm1(int vinc, void *paloffs, int cnt, unsigned int vplc, void *bufplc, void *p)
{
	unsigned char ch, *pp;

	gbuf = (unsigned char *)bufplc;
	gpal = (unsigned char *)paloffs;
	pp = (unsigned char *)p;
	if (transmode)
	{
		for(;cnt>=0;cnt--)
		{
			ch = gbuf[vplc>>glogy];
			if (ch != 255) *pp = gtrans[(*pp)+(gpal[ch]<<8)];
			pp += bpl;
			vplc += vinc;
		}
	}
	else
	{
		for(;cnt>=0;cnt--)
		{
			ch = gbuf[vplc>>glogy];
			if (ch != 255) *pp = gtrans[((*pp)<<8)+gpal[ch]];
			pp += bpl;
			vplc += vinc;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0x61a5fc(%rip)    # 0x6c2040
movq -0x10(%rbp), %rax
movq %rax, 0x61a611(%rip)    # 0x6c2060
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, 0x61a5d2(%rip)    # 0x6c2030
je 0xa7af5
jmp 0xa7a66
cmpl $0x0, -0x14(%rbp)
jl 0xa7af0
movq 0x61a5c9(%rip), %rax    # 0x6c2040
movl -0x18(%rbp), %edx
movl 0x61a5b8(%rip), %ecx    # 0x6c2038
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0xff, %eax
je 0xa7ac5
movq 0x61a58a(%rip), %rax    # 0x6c2028
movq -0x38(%rbp), %rcx
movzbl (%rcx), %ecx
movq 0x61a5b4(%rip), %rdx    # 0x6c2060
movzbl -0x29(%rbp), %esi
movzbl (%rdx,%rsi), %edx
shll $0x8, %edx
addl %edx, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq -0x38(%rbp), %rax
movb %cl, (%rax)
movl 0x61a555(%rip), %ecx    # 0x6c2020
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0x4(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa7a66
jmp 0xa7b83
jmp 0xa7af7
cmpl $0x0, -0x14(%rbp)
jl 0xa7b81
movq 0x61a538(%rip), %rax    # 0x6c2040
movl -0x18(%rbp), %edx
movl 0x61a527(%rip), %ecx    # 0x6c2038
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0xff, %eax
je 0xa7b56
movq 0x61a4f9(%rip), %rax    # 0x6c2028
movq -0x38(%rbp), %rcx
movzbl (%rcx), %ecx
shll $0x8, %ecx
movq 0x61a520(%rip), %rdx    # 0x6c2060
movzbl -0x29(%rbp), %esi
movzbl (%rdx,%rsi), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq -0x38(%rbp), %rax
movb %cl, (%rax)
movl 0x61a4c4(%rip), %ecx    # 0x6c2020
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0x4(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa7af7
jmp 0xa7b83
popq %rbp
retq
nopw %cs:(%rax,%rax)