LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]xpack/lib/xpack_compress.c
// Function: write_state_counts
static void
write_state_counts(struct header_ostream *os,
		   const u16 state_counts[], unsigned num_state_counts)
{
	unsigned sym = 0;

	while (sym < num_state_counts) {
		unsigned count = state_counts[sym++];
		unsigned bits;
		unsigned num_bits;

		if (count == 0) {
			unsigned start = sym - 1;
			unsigned num_zeroes;

			while (sym < num_state_counts && state_counts[sym] == 0)
				sym++;
			num_zeroes = sym - start;

			while (num_zeroes >= ZEROCODE2_MIN) {
				unsigned count = MIN(num_zeroes, ZEROCODE2_MAX);
				bits = ((count - ZEROCODE2_MIN) << CODEBITS) | ZEROCODE2;
				num_bits = ZEROCODE2_NBITS + CODEBITS;
				header_ostream_write_bits(os, bits, num_bits);
				num_zeroes -= count;
			}

			if (num_zeroes < ZEROCODE1_MIN)
				continue;

			bits = ((num_zeroes - ZEROCODE1_MIN) << CODEBITS) | ZEROCODE1;
			num_bits = ZEROCODE1_NBITS + CODEBITS;
		} else {
			unsigned order = bsr32(count);
			bits = ((count ^ (1 << order)) << CODEBITS) | order;
			num_bits = order + CODEBITS;
		}
		header_ostream_write_bits(os, bits, num_bits);
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x34(%rsp), %eax
jae 0x65fd
movq 0x38(%rsp), %rax
movl 0x30(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x30(%rsp)
movl %ecx, %ecx
movzwl (%rax,%rcx,2), %eax
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
jne 0x65a6
movl 0x30(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x20(%rsp)
movl 0x30(%rsp), %ecx
xorl %eax, %eax
cmpl 0x34(%rsp), %ecx
movb %al, 0x13(%rsp)
jae 0x64f1
movq 0x38(%rsp), %rax
movl 0x30(%rsp), %ecx
movzwl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
sete %al
movb %al, 0x13(%rsp)
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x64fb
jmp 0x6508
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x64ca
movl 0x30(%rsp), %eax
subl 0x20(%rsp), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x5, 0x1c(%rsp)
jb 0x657f
cmpl $0x84, 0x1c(%rsp)
ja 0x652f
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x653a
movl $0x84, %eax
movl %eax, 0xc(%rsp)
jmp 0x653a
movl 0xc(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
subl $0x5, %eax
shll $0x4, %eax
orl $0xf, %eax
movl %eax, 0x28(%rsp)
movl $0xb, 0x24(%rsp)
movq 0x40(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
movl 0x24(%rsp), %edx
callq 0x6200
movl 0x18(%rsp), %ecx
movl 0x1c(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x1c(%rsp)
jmp 0x6514
cmpl $0x1, 0x1c(%rsp)
jae 0x658b
jmp 0x648a
movl 0x1c(%rsp), %eax
subl $0x1, %eax
shll $0x4, %eax
orl $0xe, %eax
movl %eax, 0x28(%rsp)
movl $0x6, 0x24(%rsp)
jmp 0x65e4
movl 0x2c(%rsp), %eax
bsrl %eax, %ecx
xorl $0x1f, %ecx
movl $0x1f, %eax
subl %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0x2c(%rsp), %eax
movl 0x14(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
xorl %ecx, %eax
shll $0x4, %eax
orl 0x14(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x14(%rsp), %eax
addl $0x4, %eax
movl %eax, 0x24(%rsp)
movq 0x40(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
movl 0x24(%rsp), %edx
callq 0x6200
jmp 0x648a
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]xpack/lib/xpack_compress.c
// Function: header_ostream_flush
static size_t
header_ostream_flush(struct header_ostream *os)
{
	while ((int)os->bitcount > 0) {
		if (os->next != os->end)
			*os->next++ = os->bitbuf;
		os->bitcount -= 8;
		os->bitbuf >>= 8;
	}

	if (os->next == os->end)  /* overflow? */
		return 0;

	return os->next - os->begin;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jle 0x6673
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x20(%rcx), %rax
je 0x6654
movq -0x10(%rsp), %rax
movq (%rax), %rax
movb %al, %cl
movq -0x10(%rsp), %rdx
movq 0x18(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x18(%rdx)
movb %cl, (%rax)
movq -0x10(%rsp), %rax
movl 0x8(%rax), %ecx
subl $0x8, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
shrq $0x8, %rcx
movq %rcx, (%rax)
jmp 0x6615
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x6692
movq $0x0, -0x8(%rsp)
jmp 0x66ac
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]xpack/lib/xpack_compress.c
// Function: select_log2_num_states
static unsigned
select_log2_num_states(u32 total_freq, unsigned num_used_syms,
		       unsigned max_log2_num_states)
{
	unsigned num_states = 1 << max_log2_num_states;  /* Default value */

	/*
	 * If there are not many symbols to be encoded, then it's not helpful to
	 * use many states.
	 */
	num_states = MIN(num_states, total_freq / 4);

	/*
	 * There must be at least as many states as distinct used symbols.
	 * Note: we're guaranteed num_used_syms > 0 here because of the earlier
	 * check, which implies that this calculation produces num_states > 0.
	 */
	num_states = MAX(num_states, num_used_syms);

	return ilog2_ceil(num_states);
}

// Assembly:
movl %edi, -0xc(%rsp)
movl %esi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
movl -0xc(%rsp), %ecx
shrl $0x2, %ecx
cmpl %ecx, %eax
ja 0x9064
movl -0x18(%rsp), %eax
movl %eax, -0x1c(%rsp)
jmp 0x906f
movl -0xc(%rsp), %eax
shrl $0x2, %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
cmpl -0x10(%rsp), %eax
jb 0x908b
movl -0x18(%rsp), %eax
movl %eax, -0x20(%rsp)
jmp 0x9093
movl -0x10(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
movl %eax, -0x8(%rsp)
cmpl $0x1, -0x8(%rsp)
ja 0x90b4
movl $0x0, -0x4(%rsp)
jmp 0x90cf
movl -0x8(%rsp), %eax
subl $0x1, %eax
bsrl %eax, %ecx
xorl $0x1f, %ecx
movl $0x1f, %eax
subl %ecx, %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]xpack/lib/xpack_compress.c
// Function: adjust_state_counts
static void
adjust_state_counts(u16 state_counts[], unsigned num_states_overrun,
		    unsigned alphabet_size)
{
	unsigned shift;
	unsigned sym;
	unsigned n;

	for (shift = 3; num_states_overrun != 0; shift--) {
		for (sym = 0; sym < alphabet_size; sym++) {
			if (state_counts[sym] > 1) {
				n = MIN((state_counts[sym] - 1) >> shift,
					num_states_overrun);
				state_counts[sym] -= n;
				num_states_overrun -= n;
				if (num_states_overrun == 0)
					break;
			}
		}
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl $0x3, -0x14(%rsp)
cmpl $0x0, -0xc(%rsp)
je 0x9304
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
cmpl -0x10(%rsp), %eax
jae 0x92f2
movq -0x8(%rsp), %rax
movl -0x18(%rsp), %ecx
movzwl (%rax,%rcx,2), %eax
cmpl $0x1, %eax
jle 0x92e0
movq -0x8(%rsp), %rax
movl -0x18(%rsp), %ecx
movzwl (%rax,%rcx,2), %eax
subl $0x1, %eax
movl -0x14(%rsp), %ecx
sarl %cl, %eax
cmpl -0xc(%rsp), %eax
ja 0x92a0
movq -0x8(%rsp), %rax
movl -0x18(%rsp), %ecx
movzwl (%rax,%rcx,2), %eax
subl $0x1, %eax
movl -0x14(%rsp), %ecx
sarl %cl, %eax
movl %eax, -0x20(%rsp)
jmp 0x92a8
movl -0xc(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %esi
movq -0x8(%rsp), %rax
movl -0x18(%rsp), %ecx
movzwl (%rax,%rcx,2), %edx
subl %esi, %edx
movw %dx, (%rax,%rcx,2)
movl -0x1c(%rsp), %ecx
movl -0xc(%rsp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rsp)
cmpl $0x0, -0xc(%rsp)
jne 0x92de
jmp 0x92f2
jmp 0x92e0
jmp 0x92e2
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x9248
jmp 0x92f4
movl -0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x9235
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]xpack/lib/xpack_compress.c
// Function: symbol_ostream_init
static void
symbol_ostream_init(struct symbol_ostream *os, void *buffer, size_t size)
{
	os->bitbuf = 0;
	os->bitcount = 0;
	os->begin = buffer;
	os->end = os->begin + size;
	os->next = os->end - MIN(WORDBYTES, size);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rcx
addq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rsp)
movl $0x8, %eax
cmpq -0x18(%rsp), %rax
ja 0x9382
movl $0x8, %eax
movq %rax, -0x28(%rsp)
jmp 0x938c
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rcx
movq -0x28(%rsp), %rdx
xorl %eax, %eax
subq %rdx, %rax
addq %rax, %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]xpack/lib/xpack_compress.c
// Function: symbol_ostream_flush
static size_t
symbol_ostream_flush(struct symbol_ostream *os)
{
	symbol_ostream_flush_bits(os);

	if (os->next == os->begin) /* Not enough space? */
		return 0;

	/*
	 * Terminate the last byte with a '1' bit so that the decoder knows
	 * where to start from.
	 */
	os->bitbuf <<= 8 - os->bitcount;
	os->bitbuf |= (1 << (7 - os->bitcount));
	os->next += WORDBYTES - 1;
	*os->next = (u8)os->bitbuf;

	return os->end - os->next;
}

// Assembly:
movq %rdi, -0x50(%rsp)
movq -0x50(%rsp), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
movq (%rax), %rax
movq -0x38(%rsp), %rdx
movl $0x40, %ecx
subl 0x8(%rdx), %ecx
andl $0x3f, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x40(%rsp)
movq -0x40(%rsp), %rcx
movq -0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, -0x28(%rsp)
movq %rax, -0x30(%rsp)
movq -0x28(%rsp), %rcx
movq -0x30(%rsp), %rax
movq %rcx, -0x18(%rsp)
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, -0x8(%rsp)
movq %rax, -0x10(%rsp)
movq -0x8(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x38(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movq -0x38(%rsp), %rcx
movl 0x8(%rcx), %ecx
shrl $0x3, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jg 0x9471
movq -0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x38(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x58(%rsp)
jmp 0x9483
movq -0x38(%rsp), %rax
movl 0x8(%rax), %eax
shrl $0x3, %eax
movl %eax, %eax
movq %rax, -0x58(%rsp)
movq -0x58(%rsp), %rsi
movq -0x38(%rsp), %rax
movq 0x18(%rax), %rcx
xorl %edx, %edx
subq %rsi, %rdx
addq %rdx, %rcx
movq %rcx, 0x18(%rax)
movq -0x38(%rsp), %rax
movl 0x8(%rax), %ecx
andl $0x7, %ecx
movl %ecx, 0x8(%rax)
movq -0x50(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x50(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x94cd
movq $0x0, -0x48(%rsp)
jmp 0x954f
movq -0x50(%rsp), %rax
movl $0x8, %ecx
subl 0x8(%rax), %ecx
movq -0x50(%rsp), %rax
movq (%rax), %rdx
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
movq %rcx, (%rax)
movq -0x50(%rsp), %rax
movl $0x7, %ecx
subl 0x8(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rcx
movq -0x50(%rsp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x50(%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x7, %rcx
movq %rcx, 0x18(%rax)
movq -0x50(%rsp), %rax
movq (%rax), %rax
movb %al, %cl
movq -0x50(%rsp), %rax
movq 0x18(%rax), %rax
movb %cl, (%rax)
movq -0x50(%rsp), %rax
movq 0x20(%rax), %rax
movq -0x50(%rsp), %rcx
movq 0x18(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x48(%rsp)
movq -0x48(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_draw.c
// Function: displayobject
void displayobject(dc)
     DCp dc;
{
  Coord2dp point;
  int *i;

  point=dc->points;
  for (i=dc->s->pnum; *i; i++) {
    polyline(point, *i);
    point += *i;
  }
  for (i=dc->s->mnum; *i; i++) {
    multiline(point, *i>>1);
    point += *i;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x6347
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movb $0x0, %al
callq 0x9500
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x6307
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x6398
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
sarl %esi
movb $0x0, %al
callq 0x95e0
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x6356
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_gpr.c
// Function: grabpointer
void grabpointer()
{
  while (XGrabPointer(d, w, False,
                      ButtonPressMask|ButtonReleaseMask|PointerMotionMask,
                      GrabModeAsync,
                      GrabModeAsync,
                      w,
                      None,
                      CurrentTime) != GrabSuccess);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
jmp 0x7fea
movq 0x11aa7(%rip), %rdi     # 0x19a98
movq 0x11aa8(%rip), %rsi     # 0x19aa0
movq 0x11aa1(%rip), %rax     # 0x19aa0
xorl %edx, %edx
movl $0x4c, %ecx
movl $0x1, %r9d
xorl %r8d, %r8d
movl %r9d, %r8d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x51a0
cmpl $0x0, %eax
je 0x8034
jmp 0x7fea
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_gpr.c
// Function: setmonomap
void setmonomap()
{
  int i;

  cmap = dcmap;
  pixels = (Pixel*) malloc(2 * sizeof(Pixel));
  opt->cpi[COLOR_BG] = 0;
  pixels[0] = BlackPixelOfScreen(screen);
  opt->cpi[COLOR_FG] = 1;
  pixels[1] = WhitePixelOfScreen(screen);
  opt->fading_colors = 1;
  for (i=2; i<MAX_COLORS; i++)
    opt->cpi[i] = 1;
  cw = cr = 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x11a39(%rip), %rax     # 0x19aa8
movq %rax, 0x11a3a(%rip)     # 0x19ab0
movl $0x10, %edi
callq 0x5180
movq %rax, 0x119f9(%rip)     # 0x19a80
leaq 0x118d2(%rip), %rax     # 0x19960
movq (%rax), %rax
movl $0x0, 0xf0(%rax)
movq 0x11a16(%rip), %rax     # 0x19ab8
movq 0x60(%rax), %rcx
movq 0x119d3(%rip), %rax     # 0x19a80
movq %rcx, (%rax)
leaq 0x118a9(%rip), %rax     # 0x19960
movq (%rax), %rax
movl $0x1, 0xf4(%rax)
movq 0x119ed(%rip), %rax     # 0x19ab8
movq 0x58(%rax), %rcx
movq 0x119aa(%rip), %rax     # 0x19a80
movq %rcx, 0x8(%rax)
leaq 0x1187f(%rip), %rax     # 0x19960
movq (%rax), %rax
movl $0x1, 0x148(%rax)
movl $0x2, -0x4(%rbp)
cmpl $0x13, -0x4(%rbp)
jge 0x811f
leaq 0x1185e(%rip), %rax     # 0x19960
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movl $0x1, 0xf0(%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x80f5
movl $0x2, 0x11997(%rip)     # 0x19ac0
movl $0x2, 0x11991(%rip)     # 0x19ac4
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_gpr.c
// Function: createfadedcolors
void createfadedcolors()
{
  XColor color;
  int i, j;
  float factor;
  int num = 0;

  if (fcnames != NULL)
    free(fcnames);
  fcnames =
    (Colorname *) malloc(ufc*opt->fading_colors*sizeof(Colorname));
  for (i=LF_COLOR; i>LN_COLOR; i--)
    if (opt->cpi[i] == i) {
      XParseColor(d, dcmap, bases[i].name, &color);
      sprintf(fcnames[num++].name, "#%04x%04x%04x",
              color.red, color.green, color.blue);
      for (j=1; j<opt->fading_colors; j++) {
        factor = 1.0 - 0.5*j/(opt->fading_colors-1);
        sprintf(fcnames[num++].name, "#%04x%04x%04x",
                (int) (factor*color.red), (int) (factor*color.green),
                (int) (factor*color.blue));
      }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x20(%rbp)
cmpq $0x0, 0x11939(%rip)     # 0x19a90
je 0x8165
movq 0x11930(%rip), %rdi     # 0x19a90
callq 0x5240
movl 0x1195d(%rip), %eax     # 0x19ac8
leaq 0x117ee(%rip), %rcx     # 0x19960
movq (%rcx), %rcx
imull 0x148(%rcx), %eax
cltq
imulq $0xe, %rax, %rdi
callq 0x5180
movq %rax, 0x11902(%rip)     # 0x19a90
movl $0x12, -0x14(%rbp)
cmpl $0xb, -0x14(%rbp)
jle 0x8306
leaq 0x117ba(%rip), %rax     # 0x19960
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movl 0xf0(%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x82f6
movq 0x118d4(%rip), %rdi     # 0x19a98
movq 0x118dd(%rip), %rsi     # 0x19aa8
movq 0x118b6(%rip), %rdx     # 0x19a88
movslq -0x14(%rbp), %rax
imulq $0xe, %rax, %rax
addq %rax, %rdx
leaq -0x10(%rbp), %rcx
callq 0x5470
movq 0x118a3(%rip), %rdi     # 0x19a90
movl -0x20(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x20(%rbp)
cltq
imulq $0xe, %rax, %rax
addq %rax, %rdi
movzwl -0x8(%rbp), %edx
movzwl -0x6(%rbp), %ecx
movzwl -0x4(%rbp), %r8d
leaq 0xc093(%rip), %rsi      # 0x142a8
movb $0x0, %al
callq 0x52d0
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
leaq 0x11733(%rip), %rcx     # 0x19960
movq (%rcx), %rcx
cmpl 0x148(%rcx), %eax
jge 0x82f4
cvtsi2sdl -0x18(%rbp), %xmm0
movsd 0xbe4f(%rip), %xmm1     # 0x14098
mulsd %xmm0, %xmm1
leaq 0x1170c(%rip), %rax     # 0x19960
movq (%rax), %rax
movl 0x148(%rax), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm1
movsd 0xbe20(%rip), %xmm0     # 0x14090
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movq 0x1180c(%rip), %rdi     # 0x19a90
movl -0x20(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x20(%rbp)
cltq
imulq $0xe, %rax, %rax
addq %rax, %rdi
movss -0x1c(%rbp), %xmm0
movzwl -0x8(%rbp), %eax
cvtsi2ss %eax, %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %edx
movss -0x1c(%rbp), %xmm0
movzwl -0x6(%rbp), %eax
cvtsi2ss %eax, %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movss -0x1c(%rbp), %xmm0
movzwl -0x4(%rbp), %eax
cvtsi2ss %eax, %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %r8d
leaq 0xbfc9(%rip), %rsi      # 0x142a8
movb $0x0, %al
callq 0x52d0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8223
jmp 0x82f6
jmp 0x82f8
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8195
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_gpr.c
// Function: setcoloroptvalues
void setcoloroptvalues()
{
  int i;
  int num = 0;

  for (i=L_COLOR; i>=0; i--)
    if (opt->cpi[i] == i) {
      opt->cpi[i] = num;
      if (i>LN_COLOR)
        num += opt->fading_colors;
      else
        num++;
    }
    else
      opt->cpi[i] = opt->cpi[opt->cpi[i]];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x8(%rbp)
movl $0x12, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x83d3
leaq 0x1162d(%rip), %rax     # 0x19960
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movl 0xf0(%rax,%rcx,4), %eax
cmpl -0x4(%rbp), %eax
jne 0x8387
movl -0x8(%rbp), %edx
leaq 0x11610(%rip), %rax     # 0x19960
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movl %edx, 0xf0(%rax,%rcx,4)
cmpl $0xb, -0x4(%rbp)
jle 0x837c
leaq 0x115f5(%rip), %rax     # 0x19960
movq (%rax), %rax
movl 0x148(%rax), %eax
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x8385
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x83c3
leaq 0x115d2(%rip), %rax     # 0x19960
movq (%rax), %rax
leaq 0x115c8(%rip), %rcx     # 0x19960
movq (%rcx), %rcx
movslq -0x4(%rbp), %rdx
movslq 0xf0(%rcx,%rdx,4), %rcx
movl 0xf0(%rax,%rcx,4), %edx
leaq 0x115ab(%rip), %rax     # 0x19960
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movl %edx, 0xf0(%rax,%rcx,4)
jmp 0x83c5
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x8322
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_gpr.c
// Function: standardizecolors
void standardizecolors(v)
     Visual* v;
{
  XColor color;
  int i;
  int num = 0;

  if (bases != NULL)
    free(bases);
  bases = (Colorname *) malloc(MAX_COLORS*sizeof(Colorname));
  for (i=0; i<MAX_COLORS; i++) {
    XParseColor(d, dcmap, opt->cname[i], &color);
    if (v->class == StaticGray || v->class == GrayScale)
      color.red = color.green = color.blue = color.red > color.green ?
        (color.red > color.blue ? color.red : color.blue) :
          (color.green > color.blue ? color.green : color.blue);
    sprintf(bases[num++].name,
            "#%04x%04x%04x", color.red, color.green, color.blue);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x20(%rbp)
cmpq $0x0, 0x1168d(%rip)     # 0x19a88
je 0x8409
movq 0x11684(%rip), %rdi     # 0x19a88
callq 0x5240
movl $0x10a, %edi            # imm = 0x10A
callq 0x5180
movq %rax, 0x1166e(%rip)     # 0x19a88
movl $0x0, -0x1c(%rbp)
cmpl $0x13, -0x1c(%rbp)
jge 0x850e
movq 0x11666(%rip), %rdi     # 0x19a98
movq 0x1166f(%rip), %rsi     # 0x19aa8
leaq 0x11520(%rip), %rax     # 0x19960
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq 0x58(%rax,%rcx,8), %rdx
leaq -0x18(%rbp), %rcx
callq 0x5470
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x8469
movq -0x8(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x84ca
movzwl -0x10(%rbp), %eax
movzwl -0xe(%rbp), %ecx
cmpl %ecx, %eax
jle 0x8499
movzwl -0x10(%rbp), %eax
movzwl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jle 0x848a
movzwl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x8491
movzwl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x84bb
movzwl -0xe(%rbp), %eax
movzwl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jle 0x84ae
movzwl -0xe(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x84b5
movzwl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movw %ax, -0xc(%rbp)
movw %ax, -0xe(%rbp)
movw %ax, -0x10(%rbp)
movq 0x115b7(%rip), %rdi     # 0x19a88
movl -0x20(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x20(%rbp)
cltq
imulq $0xe, %rax, %rax
addq %rax, %rdi
movzwl -0x10(%rbp), %edx
movzwl -0xe(%rbp), %ecx
movzwl -0xc(%rbp), %r8d
leaq 0xbdaf(%rip), %rsi      # 0x142a8
movb $0x0, %al
callq 0x52d0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8421
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_gpr.c
// Function: countcolors
void countcolors()
{
  int i, j;

  ufc = unfc = 0;
  if (opt->mono) {
    cr = cw = unfc = 2;
    return;
  }
  for (i=L_COLOR; i>=0; i--) {
    for (j=L_COLOR; j>i && strcmp(bases[i].name,bases[j].name); j--);
    opt->cpi[i] = j;
    if (i == j)
      if (opt->fading_colors==1 || i<FF_COLOR)
        unfc++;
      else
        ufc++;
  }
  cw = unfc+ufc*opt->fading_colors;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, 0x1138a(%rip)     # 0x19acc
movl $0x0, 0x1137c(%rip)     # 0x19ac8
leaq 0x1120d(%rip), %rax     # 0x19960
movq (%rax), %rax
cmpl $0x0, 0x13c(%rax)
je 0x8782
movl $0x2, 0x11363(%rip)     # 0x19acc
movl $0x2, 0x11351(%rip)     # 0x19ac4
movl $0x2, 0x11343(%rip)     # 0x19ac0
jmp 0x887f
movl $0x12, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x885a
movl $0x12, -0x8(%rbp)
movl -0x8(%rbp), %ecx
xorl %eax, %eax
cmpl -0x4(%rbp), %ecx
movb %al, -0x9(%rbp)
jle 0x87d9
movq 0x112da(%rip), %rdi     # 0x19a88
movslq -0x4(%rbp), %rax
imulq $0xe, %rax, %rax
addq %rax, %rdi
movq 0x112c8(%rip), %rsi     # 0x19a88
movslq -0x8(%rbp), %rax
imulq $0xe, %rax, %rax
addq %rax, %rsi
callq 0x5430
cmpl $0x0, %eax
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x87e2
jmp 0x87ef
jmp 0x87e4
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x879a
movl -0x8(%rbp), %edx
leaq 0x11167(%rip), %rax     # 0x19960
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movl %edx, 0xf0(%rax,%rcx,4)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jne 0x884a
leaq 0x1114a(%rip), %rax     # 0x19960
movq (%rax), %rax
cmpl $0x1, 0x148(%rax)
je 0x8828
cmpl $0xc, -0x4(%rbp)
jge 0x8839
movl 0x1129e(%rip), %eax     # 0x19acc
addl $0x1, %eax
movl %eax, 0x11295(%rip)     # 0x19acc
jmp 0x8848
movl 0x11289(%rip), %eax     # 0x19ac8
addl $0x1, %eax
movl %eax, 0x11280(%rip)     # 0x19ac8
jmp 0x884a
jmp 0x884c
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x8789
movl 0x1126c(%rip), %eax     # 0x19acc
movl 0x11262(%rip), %ecx     # 0x19ac8
leaq 0x110f3(%rip), %rdx     # 0x19960
movq (%rdx), %rdx
imull 0x148(%rdx), %ecx
addl %ecx, %eax
movl %eax, 0x11245(%rip)     # 0x19ac4
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_gpr.c
// Function: reducecolors
void reducecolors()
{
  int i, firstcolor, lastcolor;
  static int attempt = 0;
  static int groupings[][2] = {
    F1_COLOR, L1_COLOR, F2_COLOR, L2_COLOR, F3_COLOR, L3_COLOR,
    F4_COLOR, L4_COLOR, F5_COLOR, L5_COLOR, F6_COLOR, L6_COLOR,
    F7_COLOR, L7_COLOR, F8_COLOR, L8_COLOR, F9_COLOR, L9_COLOR };

  while (cw > cr) {
    switch(attempt++) {
    case 0:                     /* reduce # of fading colors */
      opt->fading_colors = (cr-unfc)/ufc;
      if (opt->fading_colors < 1)
        opt->fading_colors = 1;
      break;
    case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 8: case 9:
      /* now start combining color groups */
      firstcolor = groupings[attempt-1][0];
      lastcolor = groupings[attempt-1][1];
      for (i=lastcolor; i>firstcolor; i--)
        strcpy(bases[i].name, bases[firstcolor].name);
      break;
    case 10:
      opt->mono = True;
      break;
    }
    countcolors();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x11226(%rip), %eax     # 0x19ac4
cmpl 0x1121c(%rip), %eax     # 0x19ac0
jle 0x89c6
movl 0x11220(%rip), %eax     # 0x19ad0
movl %eax, -0x10(%rbp)
movl %eax, %ecx
incl %ecx
movl %ecx, 0x11213(%rip)     # 0x19ad0
testl %eax, %eax
je 0x88e0
jmp 0x88c3
movl -0x10(%rbp), %eax
decl %eax
subl $0x9, %eax
jb 0x8931
jmp 0x88cf
movl -0x10(%rbp), %eax
subl $0xa, %eax
je 0x89a8
jmp 0x89bc
movl 0x111da(%rip), %eax     # 0x19ac0
subl 0x111e0(%rip), %eax     # 0x19acc
cltd
idivl 0x111d5(%rip)           # 0x19ac8
movl %eax, %ecx
leaq 0x11064(%rip), %rax     # 0x19960
movq (%rax), %rax
movl %ecx, 0x148(%rax)
leaq 0x11054(%rip), %rax     # 0x19960
movq (%rax), %rax
cmpl $0x1, 0x148(%rax)
jge 0x892c
leaq 0x11041(%rip), %rax     # 0x19960
movq (%rax), %rax
movl $0x1, 0x148(%rax)
jmp 0x89bc
movl 0x11199(%rip), %eax     # 0x19ad0
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x1005c(%rip), %rax     # 0x189a0
movl (%rax,%rcx,8), %eax
movl %eax, -0x8(%rbp)
movl 0x11180(%rip), %eax     # 0x19ad0
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x10043(%rip), %rax     # 0x189a0
movl 0x4(%rax,%rcx,8), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0x89a6
movq 0x1110f(%rip), %rdi     # 0x19a88
movslq -0x4(%rbp), %rax
imulq $0xe, %rax, %rax
addq %rax, %rdi
movq 0x110fd(%rip), %rsi     # 0x19a88
movslq -0x8(%rbp), %rax
imulq $0xe, %rax, %rax
addq %rax, %rsi
callq 0x5460
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x896a
jmp 0x89bc
leaq 0x10fb1(%rip), %rax     # 0x19960
movq (%rax), %rax
movl $0x1, 0x13c(%rax)
callq 0x8730
jmp 0x8898
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_gpr.c
// Function: gprinit
void gprinit ()
{
  XEvent ev;

  XSelectInput(d, w, ExposureMask|PointerMotionMask|ButtonPressMask
               |ButtonReleaseMask|KeyPressMask|StructureNotifyMask);
  XMapRaised(d, w);
  XWindowEvent(d, w, StructureNotifyMask, &ev);
  grabpointer();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq 0x10e36(%rip), %rdi     # 0x19a98
movq 0x10e37(%rip), %rsi     # 0x19aa0
movl $0x2804d, %edx          # imm = 0x2804D
callq 0x53d0
movq 0x10e1e(%rip), %rdi     # 0x19a98
movq 0x10e1f(%rip), %rsi     # 0x19aa0
callq 0x5540
movq 0x10e0b(%rip), %rdi     # 0x19a98
movq 0x10e0c(%rip), %rsi     # 0x19aa0
movl $0x20000, %edx          # imm = 0x20000
leaq -0xc0(%rbp), %rcx
callq 0x5340
callq 0x7fe0
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_gpr.c
// Function: buildpixmaps
void buildpixmaps()
{
  int i;

  for (i=0; i<NUMPIXMAPS; i++)
    bmaps[i].p =
      XCreatePixmapFromBitmapData(d, w, bmaps[i].bits,
                                  bmaps[i].width, bmaps[i].height,
                                  pixels[opt->cpi[bmaps[i].color]],
                                  pixels[opt->cpi[COLOR_BG]],
                                  depth);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x5, -0x4(%rbp)
jge 0x90f0
movq 0x10a78(%rip), %rdi     # 0x19a98
movq 0x10a79(%rip), %rsi     # 0x19aa0
movslq -0x4(%rbp), %rcx
leaq 0xf8ce(%rip), %rax      # 0x18900
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
movslq -0x4(%rbp), %rcx
leaq 0xf8b8(%rip), %rax      # 0x18900
shlq $0x5, %rcx
addq %rcx, %rax
movl (%rax), %ecx
movslq -0x4(%rbp), %r8
leaq 0xf8a4(%rip), %rax      # 0x18900
shlq $0x5, %r8
addq %r8, %rax
movl 0x4(%rax), %r8d
movq 0x10a12(%rip), %rax     # 0x19a80
leaq 0x108eb(%rip), %r9      # 0x19960
movq (%r9), %r9
movslq -0x4(%rbp), %r11
leaq 0xf87d(%rip), %r10      # 0x18900
shlq $0x5, %r11
addq %r11, %r10
movl 0x18(%r10), %r10d
movslq 0xf0(%r9,%r10,4), %r9
movq (%rax,%r9,8), %r9
movq 0x109df(%rip), %rax     # 0x19a80
leaq 0x108b8(%rip), %r10     # 0x19960
movq (%r10), %r10
movslq 0xf0(%r10), %r10
movq (%rax,%r10,8), %r10
movl 0x10a18(%rip), %eax     # 0x19ad4
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x52c0
movq %rax, %rcx
movslq -0x4(%rbp), %rdx
leaq 0xf829(%rip), %rax      # 0x18900
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x900f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_gpr.c
// Function: polyline
void polyline(points, number)
     XPoint *points;
     int number;
{
  int i;
  XPoint p[number]; // This is a GCC extension, use malloc otherwise
  for (i = 0; i < number; i++)
    {
      p[i].x = (points[i].x-XOFF)*XM/XD;
      p[i].y = (points[i].y-YOFF)*XM/XD;
    }
  XDrawLines(d, w, DrawGC, p, number, CoordModeOrigin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x28(%rbp)
movq %rcx, %rsp
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x95a8
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movswl (%rax,%rcx,4), %eax
subl $0x32, %eax
imull $0x7, %eax, %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rbp), %rax
movw %cx, %dx
movslq -0x10(%rbp), %rcx
movw %dx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movswl 0x2(%rax,%rcx,4), %eax
subl $0x32, %eax
imull $0x7, %eax, %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rbp), %rax
movw %cx, %dx
movslq -0x10(%rbp), %rcx
movw %dx, 0x2(%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x953d
movq -0x28(%rbp), %rcx
movq 0x104e5(%rip), %rdi     # 0x19a98
movq 0x104e6(%rip), %rsi     # 0x19aa0
movq 0x10527(%rip), %rdx     # 0x19ae8
movl -0xc(%rbp), %r8d
xorl %r9d, %r9d
callq 0x52f0
movq -0x18(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_gpr.c
// Function: multiline
void multiline(segments, number)
     XSegment *segments;
     int number;
{
  int i;
  XSegment seg[number]; // This is a GCC extension, use malloc otherwise
  for (i = 0; i < number; i++)
    {
      seg[i].x1 = (segments[i].x1-XOFF)*XM/XD;
      seg[i].x2 = (segments[i].x2-XOFF)*XM/XD;
      seg[i].y1 = (segments[i].y1-YOFF)*XM/XD;
      seg[i].y2 = (segments[i].y2-YOFF)*XM/XD;
    }
  XDrawSegments (d, w, DrawGC, seg, number);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
leaq 0xf(,%rax,8), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x28(%rbp)
movq %rcx, %rsp
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x96e9
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movswl (%rax,%rcx,8), %eax
subl $0x32, %eax
imull $0x7, %eax, %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rbp), %rax
movw %cx, %dx
movslq -0x10(%rbp), %rcx
movw %dx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movswl 0x4(%rax,%rcx,8), %eax
subl $0x32, %eax
imull $0x7, %eax, %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rbp), %rax
movw %cx, %dx
movslq -0x10(%rbp), %rcx
movw %dx, 0x4(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movswl 0x2(%rax,%rcx,8), %eax
subl $0x32, %eax
imull $0x7, %eax, %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rbp), %rax
movw %cx, %dx
movslq -0x10(%rbp), %rcx
movw %dx, 0x2(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movswl 0x6(%rax,%rcx,8), %eax
subl $0x32, %eax
imull $0x7, %eax, %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rbp), %rax
movw %cx, %dx
movslq -0x10(%rbp), %rcx
movw %dx, 0x6(%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x961d
movq -0x28(%rbp), %rcx
movq 0x103a4(%rip), %rdi     # 0x19a98
movq 0x103a5(%rip), %rsi     # 0x19aa0
movq 0x103e6(%rip), %rdx     # 0x19ae8
movl -0xc(%rbp), %r8d
callq 0x5070
movq -0x18(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_gpr.c
// Function: gprsetclippingactive
void gprsetclippingactive(flag)
     Bool flag;
{
  if (flag) {
    XSetClipRectangles (d, DrawGC, 0, 0, &clipr, 1, YXBanded);
    XSetClipRectangles (d, EraseGC, 0, 0, &clipr, 1, YXBanded);
  } else {
    XSetClipMask (d, DrawGC, None);
    XSetClipMask (d, EraseGC, None);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x9949
movq 0x101a0(%rip), %rdi     # 0x19a98
movq 0x101e9(%rip), %rsi     # 0x19ae8
xorl %ecx, %ecx
leaq 0x10208(%rip), %r8      # 0x19b10
movl $0x1, %r9d
movl %ecx, %edx
movl $0x3, (%rsp)
callq 0x5510
movq 0x10175(%rip), %rdi     # 0x19a98
movq 0x101ce(%rip), %rsi     # 0x19af8
xorl %ecx, %ecx
leaq 0x101dd(%rip), %r8      # 0x19b10
movl $0x1, %r9d
movl %ecx, %edx
movl $0x3, (%rsp)
callq 0x5510
jmp 0x9977
movq 0x10148(%rip), %rdi     # 0x19a98
movq 0x10191(%rip), %rsi     # 0x19ae8
xorl %eax, %eax
movl %eax, %edx
callq 0x5110
movq 0x10131(%rip), %rdi     # 0x19a98
movq 0x1018a(%rip), %rsi     # 0x19af8
xorl %eax, %eax
movl %eax, %edx
callq 0x5110
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_gpr.c
// Function: gprsetclipwindow
void gprsetclipwindow(window)
     Window_t *window;
{
  clipr.x = (window->base.x-XOFF)*XM/XD;
  clipr.y = (window->base.y-YOFF)*XM/XD;
  clipr.width = window->size.x*XM/XD;
  clipr.height =  window->size.y*YM/YD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
subl $0x32, %eax
imull $0x7, %eax, %eax
movl $0xa, %ecx
cltd
idivl %ecx
movw %ax, 0xfabd(%rip)       # 0x19b10
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x32, %eax
imull $0x7, %eax, %eax
movl $0xa, %ecx
cltd
idivl %ecx
movw %ax, 0xfaa3(%rip)       # 0x19b12
movq -0x8(%rbp), %rax
imull $0x7, 0x8(%rax), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movw %ax, 0xfa8d(%rip)       # 0x19b14
movq -0x8(%rbp), %rax
imull $0x7, 0xc(%rax), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movw %ax, 0xfa77(%rip)       # 0x19b16
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_gpr.c
// Function: waitforkey
void waitforkey(c)
     char c;
{
  char keystr;
  XEvent ev;

  XFlush(d);                    /* out with the old */
  while (XPending(d))
    XNextEvent(d, &ev);
                                /* now wait for the new */
  while (1) {
    XWindowEvent(d, w, KeyPressMask|ButtonPressMask, &ev);
    switch(ev.type) {
    case KeyPress:
      if (!c || XLookupString(&ev.xkey,&keystr,1,(KeySym *) 0,
                        (XComposeStatus *) 0) == 1 &&
          keystr == c)
        return;
      break;
    case ButtonPress:
      if (!c)
        return;
      break;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq 0xf990(%rip), %rdi      # 0x19a98
callq 0x53f0
movq 0xf984(%rip), %rdi      # 0x19a98
callq 0x55a0
cmpl $0x0, %eax
je 0xa133
movq 0xf973(%rip), %rdi      # 0x19a98
leaq -0xc8(%rbp), %rsi
callq 0x5330
jmp 0xa10d
jmp 0xa135
movq 0xf95c(%rip), %rdi      # 0x19a98
movq 0xf95d(%rip), %rsi      # 0x19aa0
movl $0x5, %edx
leaq -0xc8(%rbp), %rcx
callq 0x5340
movl -0xc8(%rbp), %eax
movl %eax, -0xcc(%rbp)
subl $0x2, %eax
je 0xa174
jmp 0xa167
movl -0xcc(%rbp), %eax
subl $0x4, %eax
je 0xa1ac
jmp 0xa1b6
cmpb $0x0, -0x1(%rbp)
je 0xa1a8
leaq -0xc8(%rbp), %rdi
leaq -0x2(%rbp), %rsi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x50d0
cmpl $0x1, %eax
jne 0xa1aa
movsbl -0x2(%rbp), %eax
movsbl -0x1(%rbp), %ecx
cmpl %ecx, %eax
jne 0xa1aa
jmp 0xa1bb
jmp 0xa1b6
cmpb $0x0, -0x1(%rbp)
jne 0xa1b4
jmp 0xa1bb
jmp 0xa1b6
jmp 0xa135
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_graphics.c
// Function: message
void message(number, bell)
     int number;
     Bool bell;
{
  static int xpt = 70;
  static int ypt[] = {507, 567, 627};
  static char* messages[] = {"ENEMY TANK IN FIRING ARC",
                               "MOVEMENT BLOCKED BY OBJECT",
                               "SALVO FIRED BY ENEMY TANK"};
  int ind;
  char text[41];

  ind = abs(number) - 1;
  if (number < 0)
    sprintf(text,"%-40s"," ");
  else
    sprintf(text,"%-40s",messages[ind]);

  gprsetclippingactive(False);
  printstring(xpt, ypt[ind], text, 40);
  gprsetclippingactive(True);
  if (bell)
    tonetime();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0xa36f
leaq -0x40(%rbp), %rdi
leaq 0xa3f3(%rip), %rsi      # 0x14752
leaq 0xa3f2(%rip), %rdx      # 0x14758
movb $0x0, %al
callq 0x52d0
jmp 0xa390
leaq -0x40(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0xf032(%rip), %rax      # 0x193b0
movq (%rax,%rcx,8), %rdx
leaq 0xa3c9(%rip), %rsi      # 0x14752
movb $0x0, %al
callq 0x52d0
xorl %edi, %edi
movb $0x0, %al
callq 0x98e0
movl 0xf001(%rip), %edi      # 0x193a0
movslq -0xc(%rbp), %rcx
leaq 0xeffa(%rip), %rax      # 0x193a4
movl (%rax,%rcx,4), %esi
leaq -0x40(%rbp), %rdx
movl $0x28, %ecx
movb $0x0, %al
callq 0x9490
movl $0x1, %edi
movb $0x0, %al
callq 0x98e0
cmpl $0x0, -0x8(%rbp)
je 0xa3d6
movb $0x0, %al
callq 0x9980
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_graphics.c
// Function: screeninit
void screeninit()
{
  controlfont = gprloadfontfile(CONTROLFONT);
  titlefont = gprloadfontfile(TITLEFONT);
  generalfont = gprloadfontfile(GENERALFONT);
  staticscreen();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xa36f(%rip), %rdi      # 0x1475a
movb $0x0, %al
callq 0x9db0
movq %rax, 0xf7b7(%rip)      # 0x19bb0
leaq 0xa387(%rip), %rdi      # 0x14787
movb $0x0, %al
callq 0x9db0
movq %rax, 0xf7aa(%rip)      # 0x19bb8
leaq 0xa3a0(%rip), %rdi      # 0x147b5
movb $0x0, %al
callq 0x9db0
movq %rax, 0xf79d(%rip)      # 0x19bc0
callq 0xa430
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_graphics.c
// Function: xhairs
void xhairs (aligned)
     Bool aligned;
{
  static Bool last = False;
  static short pt1[] = {500, 215, 500, 235, 500, 285, 500, 305, 475, 240,
                          475, 235, 475, 235, 525, 235, 525, 235, 525, 240,
                          475, 280, 475, 285, 475, 285, 525, 285, 525, 285,
                          525, 280};
  static short pt2[] = {500, 215, 500, 235, 500, 285, 500, 305, 475, 245,
                          500, 235, 500, 235, 525, 245, 475, 275, 500, 285,
                          500, 285, 525, 275};
  static Bool draw = True;
  if (draw) {
    if (aligned) {
      if (!last) {
        gprsetdrawvalue(opt->cpi[COLOR_BG]);       /* erase the old */
        multiline(pt1, 8);
        last = True;
      }
      gprsetdrawvalue(opt->cpi[COLOR_XHAIR]);        /* draw the new */
      multiline(pt2, 6);
    }
    else {
      if (last) {
        gprsetdrawvalue(opt->cpi[COLOR_BG]);       /* erase the old */
        multiline(pt2, 6);
        last = False;
      }
      gprsetdrawvalue(opt->cpi[COLOR_XHAIR]);        /* draw the new */
      multiline(pt1, 8);
    }
  }
  draw = !draw;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, 0xe12e(%rip)      # 0x19570
je 0xb520
cmpl $0x0, -0x4(%rbp)
je 0xb4b7
cmpl $0x0, 0xe7ab(%rip)      # 0x19c00
jne 0xb48b
leaq 0xe502(%rip), %rax      # 0x19960
movq (%rax), %rax
movl 0xf0(%rax), %edi
movb $0x0, %al
callq 0x9e90
leaq 0xe08b(%rip), %rdi      # 0x19500
movl $0x8, %esi
movb $0x0, %al
callq 0x95e0
movl $0x1, 0xe775(%rip)      # 0x19c00
leaq 0xe4ce(%rip), %rax      # 0x19960
movq (%rax), %rax
movl 0x104(%rax), %edi
movb $0x0, %al
callq 0x9e90
leaq 0xe097(%rip), %rdi      # 0x19540
movl $0x6, %esi
movb $0x0, %al
callq 0x95e0
jmp 0xb51e
cmpl $0x0, 0xe742(%rip)      # 0x19c00
je 0xb4f4
leaq 0xe499(%rip), %rax      # 0x19960
movq (%rax), %rax
movl 0xf0(%rax), %edi
movb $0x0, %al
callq 0x9e90
leaq 0xe062(%rip), %rdi      # 0x19540
movl $0x6, %esi
movb $0x0, %al
callq 0x95e0
movl $0x0, 0xe70c(%rip)      # 0x19c00
leaq 0xe465(%rip), %rax      # 0x19960
movq (%rax), %rax
movl 0x104(%rax), %edi
movb $0x0, %al
callq 0x9e90
leaq 0xdfee(%rip), %rdi      # 0x19500
movl $0x8, %esi
movb $0x0, %al
callq 0x95e0
jmp 0xb520
cmpl $0x0, 0xe049(%rip)      # 0x19570
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xe039(%rip)      # 0x19570
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_parseopts.c
// Function: pager
int pager(file)
     char* file;
{
  char buf[100], *pager, *getenv();
  static char defaultpager[] = PAGER;
  FILE *f;

  if ((pager = getenv("PAGER")) == NULL)
    pager = defaultpager;
  sprintf(buf,"%s%s",TANKDIR,file);
  if ((f=fopen(buf,"r")) != NULL) {
    fclose(f);
    switch (fork()) {
    case 0:
#ifndef WIN31
      execl(pager,pager,buf,0);
#endif
      fprintf(stderr,"Exec of %s failed\n", pager);
      return 1;
    case -1:
      fprintf(stderr,"Unable to fork process\n");
      return 1;
    default:
#ifndef WIN31
      wait(0);
#endif
      break;
    }
  }
  else {
    fprintf(stderr,"File %s not found or unreadable.\n", buf);
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x24e2(%rip), %rdi      # 0x14b58
callq 0x53c0
movq %rax, -0x88(%rbp)
cmpq $0x0, %rax
jne 0x12696
leaq 0x72f1(%rip), %rax      # 0x19980
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq 0x24b9(%rip), %rsi      # 0x14b5e
leaq 0x24b7(%rip), %rdx      # 0x14b63
movb $0x0, %al
callq 0x52d0
leaq -0x80(%rbp), %rdi
leaq 0x2148(%rip), %rsi      # 0x14806
callq 0x5190
movq %rax, -0x90(%rbp)
cmpq $0x0, %rax
je 0x1276f
movq -0x90(%rbp), %rdi
callq 0x54f0
callq 0x5520
movl %eax, %ecx
movl %ecx, -0x94(%rbp)
subl $-0x1, %eax
je 0x12743
jmp 0x126f4
movl -0x94(%rbp), %eax
testl %eax, %eax
jne 0x12764
jmp 0x12700
movq -0x88(%rbp), %rdi
movq -0x88(%rbp), %rsi
leaq -0x80(%rbp), %rdx
xorl %ecx, %ecx
movb $0x0, %al
callq 0x5150
movq 0x48ce(%rip), %rax      # 0x16ff0
movq (%rax), %rdi
movq -0x88(%rbp), %rdx
leaq 0x243a(%rip), %rsi      # 0x14b6d
movb $0x0, %al
callq 0x5550
movl $0x1, -0x4(%rbp)
jmp 0x1279b
movq 0x48a6(%rip), %rax      # 0x16ff0
movq (%rax), %rdi
leaq 0x242c(%rip), %rsi      # 0x14b80
movb $0x0, %al
callq 0x5550
movl $0x1, -0x4(%rbp)
jmp 0x1279b
xorl %eax, %eax
movl %eax, %edi
callq 0x5090
jmp 0x12794
movq 0x487a(%rip), %rax      # 0x16ff0
movq (%rax), %rdi
leaq -0x80(%rbp), %rdx
leaq 0x2414(%rip), %rsi      # 0x14b98
movb $0x0, %al
callq 0x5550
movl $0x1, -0x4(%rbp)
jmp 0x1279b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_parseopts.c
// Function: getoptionint
int getoptionint(s)
     char *s;
{
  char rest[100];
  int num;

  if (sscanf(s, "%d%s", &num, rest) != 1) {
    printf("Error in optional argument %s; use -help for help.\n",
           s);
    exit(0);
  }
  return(num);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x70(%rbp), %rcx
leaq 0x23ec(%rip), %rsi      # 0x14bba
leaq -0x74(%rbp), %rdx
movb $0x0, %al
callq 0x50e0
cmpl $0x1, %eax
je 0x127f7
movq -0x8(%rbp), %rsi
leaq 0x23d6(%rip), %rdi      # 0x14bbf
movb $0x0, %al
callq 0x5050
xorl %edi, %edi
callq 0x5100
movl -0x74(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jrrk[P]cbzone/c_scores.c
// Function: printandwait
void printandwait(s, c)                 /* print a string and then */
     char* s;                           /* wait for a character c  */
     char c;                            /* to be pressed.  If c==0 */
{                                       /* then any keypress will  */
  y += ydelta;                          /* do.                     */
  xprintf(s, True);
  waitforkey(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl 0x6f2c(%rip), %eax      # 0x19d74
addl 0x6f22(%rip), %eax      # 0x19d70
movl %eax, 0x6f1c(%rip)      # 0x19d70
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x12da0
movsbl -0x9(%rbp), %edi
movb $0x0, %al
callq 0xa0f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/add.c
// Function: main
int
main()
{
    int me;

    shmem_init();
    me = shmem_my_pe();

    dst = 22;
    shmem_barrier_all();

    if (me == 0) {
        shmem_int_atomic_add(&dst, 44, 1);
    }
    shmem_barrier_all();

    printf("%d: dst = %d\n", me, dst);

    shmem_finalize();

    return 0;
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
callq 0x1080
callq 0x1060
movl %eax, (%rsp)
movl $0x16, 0x2eac(%rip)     # 0x405c
callq 0x1070
cmpl $0x0, (%rsp)
jne 0x11d1
leaq 0x2e9a(%rip), %rdi      # 0x405c
movl $0x2c, %esi
movl $0x1, %edx
callq 0x1050
callq 0x1070
movl (%rsp), %esi
movl 0x2e7d(%rip), %edx      # 0x405c
leaq 0xe1e(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
callq 0x1040
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]xpack/programs/xpack.c
// Function: get_suffix
static const tchar *
get_suffix(const tchar *path, const tchar *suffix)
{
	const tchar *dot = tstrrchr(get_filename(path), '.');

	if (dot != NULL && tstrxcmp(dot + 1, suffix) == 0)
		return dot;
	return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2920
movq %rax, %rdi
movl $0x2e, %esi
callq 0x10c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1f26
movq 0x8(%rsp), %rdi
addq $0x1, %rdi
movq 0x10(%rsp), %rsi
callq 0x1110
cmpl $0x0, %eax
jne 0x1f26
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x1f2f
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)