LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/cwalk/cwalk.c
// Function: cwk_path_get_previous_segment
bool cwk_path_get_previous_segment(struct cwk_segment *segment)
{
  const char *c;

  // The current position might point to the first character of the path, which
  // means there are no previous segments available.
  c = segment->begin;
  if (c <= segment->segments) {
    return false;
  }

  // We move towards the beginning of the path until we either reached the
  // beginning or the character is no separator anymore.
  do {
    --c;
    if (c < segment->segments) {
      // So we reached the beginning here and there is no segment. So we return
      // false and don't change the segment structure submitted by the caller.
      return false;
    }
  } while (cwk_path_is_separator(c));

  // We are guaranteed now that there is another segment, since we moved before
  // the previous separator and did not reach the segment path beginning.
  segment->end = c + 1;
  segment->begin = cwk_path_find_previous_stop(segment->segments, c);
  segment->size = (size_t)(segment->end - segment->begin);

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
ja 0x18a5c
movb $0x0, -0x1(%rbp)
jmp 0x18ad8
jmp 0x18a5e
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x18a7e
movb $0x0, -0x1(%rbp)
jmp 0x18ad8
jmp 0x18a80
movq -0x18(%rbp), %rdi
callq 0x18110
testb $0x1, %al
jne 0x18a5e
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x18af0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
subq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/cwalk/cwalk.c
// Function: cwk_path_find_previous_stop
static const char *cwk_path_find_previous_stop(const char *begin, const char *c)
{
  // We just move back until we find a separator or reach the beginning of the
  // path, which will be our previous "stop".
  while (c > begin && !cwk_path_is_separator(c)) {
    --c;
  }

  // Return the pointer to the previous stop. We have to return the first
  // character after the separator, not on the separator itself.
  if (cwk_path_is_separator(c)) {
    return c + 1;
  } else {
    return c;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x19(%rbp)
jbe 0x18b1d
movq -0x18(%rbp), %rdi
callq 0x18110
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x18b26
jmp 0x18b34
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x18b00
movq -0x18(%rbp), %rdi
callq 0x18110
testb $0x1, %al
jne 0x18b43
jmp 0x18b51
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x18b59
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/cwalk/cwalk.c
// Function: cwk_path_get_segment_type
enum cwk_segment_type cwk_path_get_segment_type(
  const struct cwk_segment *segment)
{
  // We just make a string comparison with the segment contents and return the
  // appropriate type.
  if (strncmp(segment->begin, ".", segment->size) == 0) {
    return CWK_CURRENT;
  } else if (strncmp(segment->begin, "..", segment->size) == 0) {
    return CWK_BACK;
  }

  return CWK_NORMAL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0x3f93(%rip), %rsi      # 0x1cb26
callq 0x1040
cmpl $0x0, %eax
jne 0x18ba6
movl $0x1, -0x4(%rbp)
jmp 0x18bd9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0x3c5a(%rip), %rsi      # 0x1c817
callq 0x1040
cmpl $0x0, %eax
jne 0x18bd0
movl $0x2, -0x4(%rbp)
jmp 0x18bd9
jmp 0x18bd2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/cwalk/cwalk.c
// Function: cwk_path_segment_will_be_removed
static bool
cwk_path_segment_will_be_removed(const struct cwk_segment_joined *sj,
  bool absolute)
{
  enum cwk_segment_type type;
  struct cwk_segment_joined sjc;

  // We copy the joined path so we don't need to modify it.
  sjc = *sj;

  // First we check whether this is a CWK_CURRENT or CWK_BACK segment, since
  // those will always be dropped.
  type = cwk_path_get_segment_type(&sj->segment);
  if (type == CWK_CURRENT) {
    return true;
  } else if (type == CWK_BACK && absolute) {
    return true;
  } else if (type == CWK_BACK) {
    return cwk_path_segment_back_will_be_removed(&sjc);
  } else {
    return cwk_path_segment_normal_will_be_removed(&sjc);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movl $0x38, %edx
callq 0x1100
movq -0x10(%rbp), %rdi
callq 0x18b70
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
jne 0x18d9e
movb $0x1, -0x1(%rbp)
jmp 0x18dd4
cmpl $0x2, -0x18(%rbp)
jne 0x18db0
testb $0x1, -0x11(%rbp)
je 0x18db0
movb $0x1, -0x1(%rbp)
jmp 0x18dd4
cmpl $0x2, -0x18(%rbp)
jne 0x18dc6
leaq -0x50(%rbp), %rdi
callq 0x18de0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x18dd4
leaq -0x50(%rbp), %rdi
callq 0x18e50
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/cwalk/cwalk.c
// Function: cwk_path_segment_normal_will_be_removed
static bool cwk_path_segment_normal_will_be_removed(
  struct cwk_segment_joined *sj)
{
  enum cwk_segment_type type;
  int counter;

  // The counter determines how many segments are above our current segment,
  // which will popped off before us. If the counter goes below zero it means
  // that our segment will be popped as well.
  counter = 0;

  // We loop over all following segments until we either reach the end, which
  // means our segment will not be dropped or the counter goes below zero.
  while (cwk_path_get_next_segment_joined(sj)) {

    // First, grab the type. The type determines whether we will increase or
    // decrease the counter. We don't handle a CWK_CURRENT frame here since it
    // has no influence.
    type = cwk_path_get_segment_type(&sj->segment);
    if (type == CWK_NORMAL) {
      // This is a normal segment. The normal segment will increase the counter
      // since it will be removed by a "../" before us.
      ++counter;
    } else if (type == CWK_BACK) {
      // A CWK_BACK segment will reduce the counter by one. If we are below zero
      // we can return immediately.
      --counter;
      if (counter < 0) {
        return true;
      }
    }
  }

  // We never got a negative count, so we will keep this segment alive.
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17a20
testb $0x1, %al
jne 0x18e72
jmp 0x18eb0
movq -0x10(%rbp), %rdi
callq 0x18b70
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x18e8f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x18eae
cmpl $0x2, -0x14(%rbp)
jne 0x18eac
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x18eaa
movb $0x1, -0x1(%rbp)
jmp 0x18eb4
jmp 0x18eac
jmp 0x18eae
jmp 0x18e63
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/cwalk/cwalk.c
// Function: cwk_path_get_previous_segment_joined
static bool cwk_path_get_previous_segment_joined(struct cwk_segment_joined *sj)
{
  bool result;

  if (*sj->paths == NULL) {
    // It's possible that there is no initialized segment available in the
    // struct since there are no paths. In that case we can return false, since
    // there is no previous segment.
    return false;
  } else if (cwk_path_get_previous_segment(&sj->segment)) {
    // Now we try to get the previous segment from the current path. If we can
    // do that successfully, we can let the caller know that we found one.
    return true;
  }

  result = false;

  do {
    // We are done once we reached index 0. In that case there are no more
    // segments left.
    if (sj->path_index == 0) {
      break;
    }

    // There is another path which we have to inspect. So we decrease the path
    // index.
    --sj->path_index;

    // If this is the first path we will have to consider that this path might
    // include a root, otherwise we just treat is as a segment.
    if (sj->path_index == 0) {
      result = cwk_path_get_last_segment(sj->paths[sj->path_index],
        &sj->segment);
    } else {
      result = cwk_path_get_last_segment_without_root(sj->paths[sj->path_index],
        &sj->segment);
    }

  } while (!result);

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpq $0x0, (%rax)
jne 0x18ee3
movb $0x0, -0x1(%rbp)
jmp 0x18f82
movq -0x10(%rbp), %rdi
callq 0x18a30
testb $0x1, %al
jne 0x18ef2
jmp 0x18efb
movb $0x1, -0x1(%rbp)
jmp 0x18f82
jmp 0x18efd
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x18f0e
jmp 0x18f7a
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x18f4d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x17f80
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x18f6f
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x18f90
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x18f71
movb -0x11(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x18f01
movb -0x11(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/cwalk/cwalk.c
// Function: cwk_path_get_last_segment_without_root
static bool cwk_path_get_last_segment_without_root(const char *path,
  struct cwk_segment *segment)
{
  // Now this is fairly similar to the normal algorithm, however, it will assume
  // that there is no root in the path. So we grab the first segment at this
  // position, assuming there is no root.
  if (!cwk_path_get_first_segment_without_root(path, path, segment)) {
    return false;
  }

  // Now we find our last segment. The segment struct of the caller
  // will contain the last segment, since the function we call here will not
  // change the segment struct when it reaches the end.
  while (cwk_path_get_next_segment(segment)) {
    // We just loop until there is no other segment left.
  }

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x18840
testb $0x1, %al
jne 0x18fbb
movb $0x0, -0x1(%rbp)
jmp 0x18fd2
jmp 0x18fbd
movq -0x18(%rbp), %rdi
callq 0x18900
testb $0x1, %al
jne 0x18fcc
jmp 0x18fce
jmp 0x18fbd
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/image.c
// Function: image_error_text
const char *image_error_text(image_error_t error) {
	switch(error) {
		case IMAGE_ERROR_NO_ERROR: return "No error";
		case IMAGE_ERROR_OPEN: return "Unable to open input file";
	}

	return "Unknown error";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x1926d
jmp 0x19263
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x1927a
jmp 0x19287
leaq 0x3669(%rip), %rax      # 0x1c8dd
movq %rax, -0x8(%rbp)
jmp 0x19292
leaq 0x3665(%rip), %rax      # 0x1c8e6
movq %rax, -0x8(%rbp)
jmp 0x19292
leaq 0x3672(%rip), %rax      # 0x1c900
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/path.c
// Function: path_file_exists
int path_file_exists(char *filename) {
	FILE *file;
	if ((file = fopen(filename, "r")) != NULL) {
		fclose(file);
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x25b5(%rip), %rsi      # 0x1b86c
callq 0x1170
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x192d8
movq -0x18(%rbp), %rdi
callq 0x1070
movl $0x1, -0x4(%rbp)
jmp 0x192df
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/path.c
// Function: path_get_output_filename
void path_get_output_filename(char *buffer, size_t buffer_length, const char *output_dir, const char *filename) {
	const char *basename;
	size_t basename_length;
	cwk_path_get_basename(filename, &basename, &basename_length);

	char temp_buffer[basename_length + 1];
	memcpy(&temp_buffer, basename, basename_length);
	temp_buffer[basename_length] = '\0';

	cwk_path_join(output_dir, temp_buffer, buffer, buffer_length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x17f20
movq -0x30(%rbp), %rcx
movq %rcx, %rax
incq %rax
movq %rsp, %rdx
movq %rdx, -0x38(%rbp)
addq $0x10, %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x48(%rbp)
movq %rdi, %rsp
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1100
movq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rax
movb $0x0, (%rsi,%rax)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x17c00
movq -0x38(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/shadetabler.c
// Function: palette_qsort_compare
static int palette_qsort_compare(const void *a, const void *b) {
	unsigned char ra = ((unsigned char *)a)[0];
	unsigned char ga = ((unsigned char *)a)[1];
	unsigned char ba = ((unsigned char *)a)[2];

	unsigned char rb = ((unsigned char *)b)[0];
	unsigned char gb = ((unsigned char *)b)[1];
	unsigned char bb = ((unsigned char *)b)[2];

	float af = (0.2126f * ((float)ra)) + (0.7152f * ((float)ga)) + (0.0722 * ((float)ba));
	float bf = (0.2126f * ((float)rb)) + (0.7152f * ((float)gb)) + (0.0722 * ((float)bb));

	if (af > bf) {
		return 1;
	} else if (bf > af) {
		return -1;
	} else {
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x1b(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x1d(%rbp)
movq -0x18(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x1e(%rbp)
movzbl -0x19(%rbp), %eax
cvtsi2ss %eax, %xmm0
movzbl -0x1a(%rbp), %eax
cvtsi2ss %eax, %xmm1
movss 0x2292(%rip), %xmm3     # 0x1c920
mulss %xmm3, %xmm1
movss 0x228a(%rip), %xmm2     # 0x1c924
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm1
movzbl -0x1b(%rbp), %eax
cvtsi2ss %eax, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x225e(%rip), %xmm4     # 0x1c918
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movzbl -0x1c(%rbp), %eax
cvtsi2ss %eax, %xmm0
movzbl -0x1d(%rbp), %eax
cvtsi2ss %eax, %xmm1
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm1
movzbl -0x1e(%rbp), %eax
cvtsi2ss %eax, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x2219(%rip), %xmm2     # 0x1c918
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x24(%rbp), %xmm0
ucomiss -0x28(%rbp), %xmm0
jbe 0x1a724
movl $0x1, -0x4(%rbp)
jmp 0x1a73f
movss -0x28(%rbp), %xmm0
ucomiss -0x24(%rbp), %xmm0
jbe 0x1a738
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1a73f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/shadetabler.c
// Function: usage
static void usage() {
	printf(SHADETABLER_HEADER "\n");
	printf("Usage: shadetabler -o <output directory> <additional options> <input files...>\n");
	printf("\n");
	printf("Available options are:\n");
	printf(" -o, --output                    Output directory. (Required)\n");
	printf(" -v, --verbose                   Verbose output.\n");
	printf(" -f, --force                     Overwrite existing files, never prompt.\n");
	printf(" -c, --colors [2-256]            Number of colors saved in the output file. (Default 256)\n");
	printf(" -s, --shades [2-256]            Number of shades in shade table. (Default 64)\n");
	printf(" -t, --type [light|dark|both]    Type of shade table(s) to genereate. (Default \"light\")\n");
	printf(" -h, --hq                        High quality quantization quality.\n");
	printf(" -r, --reserve                   Reserve colors for black and white.\n");
	printf(" -p, --priority [0-...]          Priority of input file colors over generated shaded. (Default 0)\n");
	printf(" -l, --light                     Light shade table filename. (Default \"shadetable_light.png\")\n");
	printf(" -d, --dark                      Dark shade table filename. (Default \"shadetable_dark.png\")\n");
	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1ef6(%rip), %rdi      # 0x1ca91
movb $0x0, %al
callq 0x10a0
leaq 0x211b(%rip), %rdi      # 0x1ccc4
movb $0x0, %al
callq 0x10a0
leaq 0x1e72(%rip), %rdi      # 0x1ca29
movb $0x0, %al
callq 0x10a0
leaq 0x214f(%rip), %rdi      # 0x1cd14
movb $0x0, %al
callq 0x10a0
leaq 0x2159(%rip), %rdi      # 0x1cd2c
movb $0x0, %al
callq 0x10a0
leaq 0x218a(%rip), %rdi      # 0x1cd6b
movb $0x0, %al
callq 0x10a0
leaq 0x21ae(%rip), %rdi      # 0x1cd9d
movb $0x0, %al
callq 0x10a0
leaq 0x21ea(%rip), %rdi      # 0x1cde7
movb $0x0, %al
callq 0x10a0
leaq 0x2237(%rip), %rdi      # 0x1ce42
movb $0x0, %al
callq 0x10a0
leaq 0x2279(%rip), %rdi      # 0x1ce92
movb $0x0, %al
callq 0x10a0
leaq 0x22c4(%rip), %rdi      # 0x1ceeb
movb $0x0, %al
callq 0x10a0
leaq 0x22fb(%rip), %rdi      # 0x1cf30
movb $0x0, %al
callq 0x10a0
leaq 0x2333(%rip), %rdi      # 0x1cf76
movb $0x0, %al
callq 0x10a0
leaq 0x2388(%rip), %rdi      # 0x1cfd9
movb $0x0, %al
callq 0x10a0
leaq 0x23d9(%rip), %rdi      # 0x1d038
movb $0x0, %al
callq 0x10a0
leaq 0x1dbc(%rip), %rdi      # 0x1ca29
movb $0x0, %al
callq 0x10a0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/shadetabler.c
// Function: exq_make_hash
static unsigned int exq_make_hash(unsigned int rgba)
{
	rgba -= (rgba >> 13) | (rgba << 19);
	rgba -= (rgba >> 13) | (rgba << 19);
	rgba -= (rgba >> 13) | (rgba << 19);
	rgba -= (rgba >> 13) | (rgba << 19);
	rgba -= (rgba >> 13) | (rgba << 19);
	rgba &= EXQ_HASH_SIZE - 1;
	return rgba;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %ecx
shrl $0xd, %ecx
movl -0x4(%rbp), %eax
shll $0x13, %eax
orl %eax, %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %ecx
shrl $0xd, %ecx
movl -0x4(%rbp), %eax
shll $0x13, %eax
orl %eax, %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %ecx
shrl $0xd, %ecx
movl -0x4(%rbp), %eax
shll $0x13, %eax
orl %eax, %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %ecx
shrl $0xd, %ecx
movl -0x4(%rbp), %eax
shll $0x13, %eax
orl %eax, %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %ecx
shrl $0xd, %ecx
movl -0x4(%rbp), %eax
shll $0x13, %eax
orl %eax, %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MAGI003769[P]EE450-Socket-Project/aws.c
// Function: sigchld_handler
void sigchld_handler(int s){
    // waitpid() might overwrite errno, so we save and restore it:
    int saved_errno = errno;
    
    while(waitpid(-1, NULL, WNOHANG) > 0);
    
    errno = saved_errno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x1050
movl (%rax), %eax
movl %eax, -0x8(%rbp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x1170
cmpl $0x0, %eax
jle 0x133f
jmp 0x1325
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
callq 0x1050
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MAGI003769[P]EE450-Socket-Project/aws.c
// Function: setupUDP2
int setupUDP2(char* port)
{
	int sockfd;
	int rv;
	struct addrinfo hints, *servinfo, *p;
	socklen_t addr_len;
	memset(&hints, 0, sizeof hints);
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_DGRAM;

	if ((rv = getaddrinfo(IPADDRESS, port, &hints, &servinfo)) != 0) {
		fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
		return 1;
	}

	// loop through all the results and make a socket
	for(p = servinfo; p != NULL; p = p->ai_next) {
		if ((sockfd = socket(p->ai_family, p->ai_socktype,
				p->ai_protocol)) == -1) {
			perror("talker: socket");
			continue;
		}

        if(bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
            close(sockfd);
            perror("server: bind");
            continue;
        }

		break;
	}

	if (p == NULL) {
		fprintf(stderr, "talker: failed to create socket\n");
		return 2;
	}

	freeaddrinfo(servinfo); // done with servinfo
	return sockfd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x10d0
movl $0x0, -0x44(%rbp)
movl $0x2, -0x40(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x1941(%rip), %rdi      # 0x3006
leaq -0x48(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x11d0
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x1711
movq 0x3917(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movl -0x18(%rbp), %edi
callq 0x10c0
movq -0x68(%rbp), %rdi
movq %rax, %rdx
leaq 0x1912(%rip), %rsi      # 0x3010
movb $0x0, %al
callq 0x1120
movl $0x1, -0x4(%rbp)
jmp 0x17c9
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x1792
movq -0x58(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x58(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x58(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x1200
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0x1750
leaq 0x1928(%rip), %rdi      # 0x3071
callq 0x1180
jmp 0x1784
movl -0x14(%rbp), %edi
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x58(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x1160
cmpl $-0x1, %eax
jne 0x1782
movl -0x14(%rbp), %edi
callq 0x10f0
leaq 0x18c0(%rip), %rdi      # 0x303b
callq 0x1180
jmp 0x1784
jmp 0x1792
movq -0x58(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0x1719
cmpq $0x0, -0x58(%rbp)
jne 0x17ba
movq 0x3858(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x18d6(%rip), %rsi      # 0x3080
movb $0x0, %al
callq 0x1120
movl $0x2, -0x4(%rbp)
jmp 0x17c9
movq -0x50(%rbp), %rdi
callq 0x11f0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MAGI003769[P]EE450-Socket-Project/aws.c
// Function: check_vtx
int check_vtx(char *source_vtx, char *target_vtx, char *data) {
    int source_flag = 0, target_flag = 0;
    char *end_str;
    char *token = strtok_r(data, "\n", &end_str);
    int i = 0;

    while (token != NULL) {
        char *end_token;
        //printf("debug: check line -- %s\n", token);
        if(i >= 3) {
            char *token2 = strtok_r(token, " ", &end_token);
            int j = 0;
            while (token2 != NULL && j < 2) {
                //printf("debug: check word -- %s\n", token2);
                if(strcmp(token2, source_vtx) == 0) {
                    source_flag = 1;
                } else if(strcmp(token2, target_vtx) == 0) {
                    target_flag = 1;
                }

                if(target_flag == 1 && source_flag == 1) {
                    return 11;
                }

                token2 = strtok_r(NULL, " ", &end_token);
                j++;
            }
        }
        token = strtok_r(NULL, "\n", &end_str);
        i++;
    }
    return (target_flag * 10 + source_flag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x1b2a(%rip), %rsi      # 0x3567
leaq -0x30(%rbp), %rdx
callq 0x1100
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x1b3d
cmpl $0x3, -0x3c(%rbp)
jl 0x1b17
movq -0x38(%rbp), %rdi
leaq 0x1593(%rip), %rsi      # 0x3004
leaq -0x48(%rbp), %rdx
callq 0x1100
movq %rax, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x50(%rbp)
movb %al, -0x55(%rbp)
je 0x1a9b
cmpl $0x2, -0x54(%rbp)
setl %al
movb %al, -0x55(%rbp)
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0x1aa4
jmp 0x1b15
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1110
cmpl $0x0, %eax
jne 0x1abf
movl $0x1, -0x24(%rbp)
jmp 0x1ada
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1110
cmpl $0x0, %eax
jne 0x1ad8
movl $0x1, -0x28(%rbp)
jmp 0x1ada
cmpl $0x1, -0x28(%rbp)
jne 0x1aef
cmpl $0x1, -0x24(%rbp)
jne 0x1aef
movl $0xb, -0x4(%rbp)
jmp 0x1b47
xorl %eax, %eax
movl %eax, %edi
leaq 0x150a(%rip), %rsi      # 0x3004
leaq -0x48(%rbp), %rdx
callq 0x1100
movq %rax, -0x50(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x1a85
jmp 0x1b17
xorl %eax, %eax
movl %eax, %edi
leaq 0x1a45(%rip), %rsi      # 0x3567
leaq -0x30(%rbp), %rdx
callq 0x1100
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1a51
imull $0xa, -0x28(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/mkfn.c
// Function: mkfn_script
int mkfn_script(char *script, int nscripts)
{
	/* fill mkfn_scripts (if unspecified) in the first call */
	if (!mkfn_scripts) {
		if (nscripts == 1 || !script)
			return 1;
		if (!strcmp("DFLT", script))
			mkfn_scripts = "DFLT";
		else
			mkfn_scripts = "latn";
	}
	if (!strcmp("list", mkfn_scripts))
		printf("%s\n", script ? script : "");
	if (strchr(script, ' '))
		*strchr(script, ' ') = '\0';
	return !!strstr(mkfn_scripts, script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, 0x354d1(%rip)     # 0x72798
jne 0x3d317
cmpl $0x1, -0x14(%rbp)
je 0x3d2d6
cmpq $0x0, -0x10(%rbp)
jne 0x3d2e2
movl $0x1, -0x4(%rbp)
jmp 0x3d3a7
movq -0x10(%rbp), %rsi
leaq 0x8ddf(%rip), %rdi      # 0x460cc
callq 0x3d120
cmpl $0x0, %eax
jne 0x3d307
leaq 0x8dce(%rip), %rax      # 0x460cc
movq %rax, 0x35493(%rip)     # 0x72798
jmp 0x3d315
leaq 0x8dc3(%rip), %rax      # 0x460d1
movq %rax, 0x35483(%rip)     # 0x72798
jmp 0x3d317
movq 0x3547a(%rip), %rsi     # 0x72798
leaq 0x8db1(%rip), %rdi      # 0x460d6
callq 0x3d120
cmpl $0x0, %eax
jne 0x3d35f
cmpq $0x0, -0x10(%rbp)
je 0x3d340
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x3d34d
leaq 0x9434(%rip), %rax      # 0x4677b
movq %rax, -0x20(%rbp)
jmp 0x3d34d
movq -0x20(%rbp), %rsi
leaq 0x9415(%rip), %rdi      # 0x4676d
movb $0x0, %al
callq 0x3d0b0
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x3d0a0
cmpq $0x0, %rax
je 0x3d384
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x3d0a0
movb $0x0, (%rax)
movq 0x3540d(%rip), %rdi     # 0x72798
movq -0x10(%rbp), %rsi
callq 0x3d190
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/mkfn.c
// Function: mkfn_lang
int mkfn_lang(char *lang, int nlangs)
{
	if (!mkfn_langs)
		return 1;
	if (!lang)
		lang = "";
	if (!strcmp("list", mkfn_langs))
		printf("%s\n", lang);
	if (strchr(lang, ' '))
		*strchr(lang, ' ') = '\0';
	return !!strstr(mkfn_langs, lang);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, 0x353d9(%rip)     # 0x727a0
jne 0x3d3d5
movl $0x1, -0x4(%rbp)
jmp 0x3d459
cmpq $0x0, -0x10(%rbp)
jne 0x3d3e7
leaq 0x9398(%rip), %rax      # 0x4677b
movq %rax, -0x10(%rbp)
movq 0x353b2(%rip), %rsi     # 0x727a0
leaq 0x8ce1(%rip), %rdi      # 0x460d6
callq 0x3d120
cmpl $0x0, %eax
jne 0x3d411
movq -0x10(%rbp), %rsi
leaq 0x9363(%rip), %rdi      # 0x4676d
movb $0x0, %al
callq 0x3d0b0
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x3d0a0
cmpq $0x0, %rax
je 0x3d436
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x3d0a0
movb $0x0, (%rax)
movq 0x35363(%rip), %rdi     # 0x727a0
movq -0x10(%rbp), %rsi
callq 0x3d190
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/mkfn.c
// Function: mkfn_font
int mkfn_font(char *font)
{
	static int idx;			/* font index */
	idx++;
	if (!mkfn_subfont)
		return idx == 1;
	if (!strcmp("list", mkfn_subfont))
		printf("%s\n", font);
	if (mkfn_subfont[0] && isdigit((unsigned char) mkfn_subfont[0]))
		if (atoi(mkfn_subfont) == idx)
			return 1;
	return !strcmp(mkfn_subfont, font);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movl 0x35326(%rip), %eax     # 0x727a8
addl $0x1, %eax
movl %eax, 0x3531d(%rip)     # 0x727a8
cmpq $0x0, 0x3531d(%rip)     # 0x727b0
jne 0x3d4ac
cmpl $0x1, 0x3530c(%rip)     # 0x727a8
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x3d547
movq 0x352fd(%rip), %rsi     # 0x727b0
leaq 0x8c1c(%rip), %rdi      # 0x460d6
callq 0x3d120
cmpl $0x0, %eax
jne 0x3d4d6
movq -0x10(%rbp), %rsi
leaq 0x929e(%rip), %rdi      # 0x4676d
movb $0x0, %al
callq 0x3d0b0
movq 0x352d3(%rip), %rax     # 0x727b0
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x3d527
callq 0x3d1a0
movq (%rax), %rax
movq 0x352bc(%rip), %rcx     # 0x727b0
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x3d527
movq 0x352a1(%rip), %rdi     # 0x727b0
callq 0x3d170
cmpl 0x3528e(%rip), %eax     # 0x727a8
jne 0x3d525
movl $0x1, -0x4(%rbp)
jmp 0x3d547
jmp 0x3d527
movq 0x35282(%rip), %rdi     # 0x727b0
movq -0x10(%rbp), %rsi
callq 0x3d120
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/mkfn.c
// Function: mkfn_featrank
int mkfn_featrank(char *scrp, char *feat)
{
	static char **order;
	int i;
	if (!order || strcmp(scrp, order[0])) {
		order = NULL;
		for (i = 0; i < LEN(scriptorder); i++)
			if (!strcmp(scrp, scriptorder[i][0]))
				order = scriptorder[i];
	}
	if (order && strstr(order[1], feat))
		return strstr(order[1], feat) - order[1];
	return 1000;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, 0x35250(%rip)     # 0x727b8
je 0x3d582
movq -0x10(%rbp), %rdi
movq 0x35243(%rip), %rax     # 0x727b8
movq (%rax), %rsi
callq 0x3d120
cmpl $0x0, %eax
je 0x3d5e9
movq $0x0, 0x3522b(%rip) # 0x727b8
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq $0x1e, %rax
jae 0x3d5e7
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
leaq 0x1cb53(%rip), %rax     # 0x5a100
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x3d120
cmpl $0x0, %eax
jne 0x3d5da
movslq -0x1c(%rbp), %rcx
leaq 0x1cb34(%rip), %rax     # 0x5a100
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x351de(%rip)     # 0x727b8
jmp 0x3d5dc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3d594
jmp 0x3d5e9
cmpq $0x0, 0x351c7(%rip)     # 0x727b8
je 0x3d634
movq 0x351be(%rip), %rax     # 0x727b8
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3d190
cmpq $0x0, %rax
je 0x3d634
movq 0x351a4(%rip), %rax     # 0x727b8
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3d190
movq 0x35190(%rip), %rcx     # 0x727b8
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0x3d63b
movl $0x3e8, -0x4(%rbp)      # imm = 0x3E8
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/mkfn.c
// Function: mkfn_header
void mkfn_header(char *fontname)
{
	if (mkfn_dry)
		return;
	if (mkfn_trname)
		printf("name %s\n", mkfn_trname);
	if (mkfn_psname)
		printf("fontname %s\n", mkfn_psname);
	if (!mkfn_psname && fontname && fontname[0])
		printf("fontname %s\n", fontname);
	if (mkfn_path)
		printf("fontpath %s\n", mkfn_path);
	trfn_header();
	if (mkfn_special)
		printf("special\n");
	trfn_cdefs();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x3515d(%rip)     # 0x727c0
je 0x3d66a
jmp 0x3d717
cmpq $0x0, 0x35156(%rip)     # 0x727c8
je 0x3d689
movq 0x3514d(%rip), %rsi     # 0x727c8
leaq 0x8a5d(%rip), %rdi      # 0x460df
movb $0x0, %al
callq 0x3d0b0
cmpq $0x0, 0x3513f(%rip)     # 0x727d0
je 0x3d6a8
movq 0x35136(%rip), %rsi     # 0x727d0
leaq 0x8a3a(%rip), %rdi      # 0x460db
movb $0x0, %al
callq 0x3d0b0
cmpq $0x0, 0x35120(%rip)     # 0x727d0
jne 0x3d6d7
cmpq $0x0, -0x8(%rbp)
je 0x3d6d7
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x3d6d7
movq -0x8(%rbp), %rsi
leaq 0x8a0b(%rip), %rdi      # 0x460db
movb $0x0, %al
callq 0x3d0b0
cmpq $0x0, 0x350f9(%rip)     # 0x727d8
je 0x3d6f6
movq 0x350f0(%rip), %rsi     # 0x727d8
leaq 0x89f9(%rip), %rdi      # 0x460e8
movb $0x0, %al
callq 0x3d0b0
callq 0x3e490
cmpl $0x0, 0x350de(%rip)     # 0x727e0
je 0x3d712
leaq 0x89ea(%rip), %rdi      # 0x460f5
movb $0x0, %al
callq 0x3d0b0
callq 0x3e4e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/trfn.c
// Function: trfn_aglexceptions
static void trfn_aglexceptions(char *dst)
{
	int i;
	for (i = 0; i < LEN(agl_exceptions); i++)
		if (!strcmp(agl_exceptions[i][0], dst))
			strcpy(dst, agl_exceptions[i][1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq $0x4, %rax
jae 0x3e1ec
movslq -0xc(%rbp), %rcx
leaq 0x32ef8(%rip), %rax     # 0x710a0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x3d120
cmpl $0x0, %eax
jne 0x3e1df
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x32ed1(%rip), %rax     # 0x710a0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x3d050
jmp 0x3e1e1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3e193
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/trfn.c
// Function: trfn_type
static int trfn_type(char *s, int lly, int ury)
{
	int typ = 0;
	int c = !s[0] || s[1] ? 0 : (unsigned char) *s;
	if (c == 't' && !mkfn_asc)
		mkfn_asc = ury;
	if ((c == 'g' || c == 'j' || c == 'p' || c == 'q' || c == 'y') &&
			(!mkfn_desc || mkfn_desc < lly))
		mkfn_desc = lly;
	if (!mkfn_desc || !mkfn_asc) {
		if (c > 0 && c < 128)
			return ctype_ascii[c];
		return 3;
	}
	if (!mkfn_desc || lly <= mkfn_desc)
		typ |= 1;
	if (!mkfn_asc || ury >= mkfn_asc)
		typ |= 2;
	return typ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x3e22b
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x3e232
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x3e23c
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x74, -0x20(%rbp)
jne 0x3e25a
cmpl $0x0, 0x385c9(%rip)     # 0x76818
jne 0x3e25a
movl -0x18(%rbp), %eax
movl %eax, 0x385be(%rip)     # 0x76818
cmpl $0x67, -0x20(%rbp)
je 0x3e278
cmpl $0x6a, -0x20(%rbp)
je 0x3e278
cmpl $0x70, -0x20(%rbp)
je 0x3e278
cmpl $0x71, -0x20(%rbp)
je 0x3e278
cmpl $0x79, -0x20(%rbp)
jne 0x3e295
cmpl $0x0, 0x3859d(%rip)     # 0x7681c
je 0x3e28c
movl 0x38595(%rip), %eax     # 0x7681c
cmpl -0x14(%rbp), %eax
jge 0x3e295
movl -0x14(%rbp), %eax
movl %eax, 0x38587(%rip)     # 0x7681c
cmpl $0x0, 0x38580(%rip)     # 0x7681c
je 0x3e2a7
cmpl $0x0, 0x38573(%rip)     # 0x76818
jne 0x3e2d2
cmpl $0x0, -0x20(%rbp)
jle 0x3e2c9
cmpl $0x80, -0x20(%rbp)
jge 0x3e2c9
movslq -0x20(%rbp), %rcx
leaq 0x32e1f(%rip), %rax     # 0x710e0
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x3e312
movl $0x3, -0x4(%rbp)
jmp 0x3e312
cmpl $0x0, 0x38543(%rip)     # 0x7681c
je 0x3e2e6
movl -0x14(%rbp), %eax
cmpl 0x38538(%rip), %eax     # 0x7681c
jg 0x3e2ef
movl -0x1c(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, 0x38522(%rip)     # 0x76818
je 0x3e303
movl -0x18(%rbp), %eax
cmpl 0x38517(%rip), %eax     # 0x76818
jl 0x3e30c
movl -0x1c(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/trfn.c
// Function: trfn_lig
static void trfn_lig(char *c)
{
	int i;
	for (i = 0; i < LEN(agl_exceptions); i++)
		if (!strcmp(agl_exceptions[i][1], c))
			return;
	if (c[0] && c[1] && strlen(c) > utf8len((unsigned char) c[0])) {
		trfn_ligput(c);
	} else {
		for (i = 0; i < LEN(ligs_utf8); i++)
			if (!strcmp(ligs_utf8[i][0], c))
				trfn_ligput(ligs_utf8[i][1]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq $0x4, %rax
jae 0x3e373
movslq -0xc(%rbp), %rcx
leaq 0x32d58(%rip), %rax     # 0x710a0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x3d120
cmpl $0x0, %eax
jne 0x3e366
jmp 0x3e41c
jmp 0x3e368
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3e333
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x3e3be
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x3e3be
movq -0x8(%rbp), %rdi
callq 0x3d080
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %edi
callq 0x3ee90
movl %eax, %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
jbe 0x3e3be
movq -0x8(%rbp), %rdi
callq 0x3ef20
jmp 0x3e41c
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq $0x6, %rax
jae 0x3e41a
movslq -0xc(%rbp), %rcx
leaq 0x32f06(%rip), %rax     # 0x712e0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x3d120
cmpl $0x0, %eax
jne 0x3e40d
movslq -0xc(%rbp), %rcx
leaq 0x32ee3(%rip), %rax     # 0x712e0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x3ef20
jmp 0x3e40f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3e3c5
jmp 0x3e41c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/trfn.c
// Function: trfn_init
void trfn_init(void)
{
	int i;
	sbuf_char = sbuf_make();
	tab_agl = tab_alloc(LEN(agl));
	for (i = 0; i < LEN(agl); i++)
		tab_put(tab_agl, agl[i][0], agl[i][1]);
	tab_alts = tab_alloc(LEN(alts));
	for (i = 0; i < LEN(alts); i++)
		tab_put(tab_alts, alts[i][0], alts[i] + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x3ef80
movq %rax, 0x342dc(%rip)     # 0x72800
movl $0x10b9, %edi           # imm = 0x10B9
callq 0x3f3a0
movq %rax, 0x382db(%rip)     # 0x76810
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0x10b9, %rax           # imm = 0x10B9
jae 0x3e58a
movq 0x382c1(%rip), %rdi     # 0x76810
movslq -0x4(%rbp), %rcx
leaq 0x1bd96(%rip), %rax     # 0x5a2f0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movslq -0x4(%rbp), %rcx
leaq 0x1bd81(%rip), %rax     # 0x5a2f0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
callq 0x3f4a0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3e53c
movl $0x161, %edi            # imm = 0x161
callq 0x3f3a0
movq %rax, 0x3426d(%rip)     # 0x72808
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0x161, %rax            # imm = 0x161
jae 0x3e5f0
movq 0x34253(%rip), %rdi     # 0x72808
movslq -0x4(%rbp), %rcx
leaq 0x2c8c0(%rip), %rax     # 0x6ae80
shlq $0x6, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movslq -0x4(%rbp), %rax
leaq 0x2c8ab(%rip), %rdx     # 0x6ae80
shlq $0x6, %rax
addq %rax, %rdx
addq $0x8, %rdx
callq 0x3f4a0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3e5a2
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/trfn.c
// Function: trfn_done
void trfn_done(void)
{
	sbuf_free(sbuf_char);
	tab_free(tab_alts);
	if (tab_agl)
		tab_free(tab_agl);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x341f5(%rip), %rdi     # 0x72800
callq 0x3f0a0
movq 0x341f1(%rip), %rdi     # 0x72808
callq 0x3f450
cmpq $0x0, 0x381ec(%rip)     # 0x76810
je 0x3e632
movq 0x381e3(%rip), %rdi     # 0x76810
callq 0x3f450
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/trfn.c
// Function: utf8put
static void utf8put(char **d, int c)
{
	int l = 0;
	if (c > 0xffff) {
		*(*d)++ = 0xf0 | (c >> 18);
		l = 3;
	} else if (c > 0x7ff) {
		*(*d)++ = 0xe0 | (c >> 12);
		l = 2;
	} else if (c > 0x7f) {
		*(*d)++ = 0xc0 | (c >> 6);
		l = 1;
	} else {
		*(*d)++ = c > 0 ? c : ' ';
	}
	while (l--)
		*(*d)++ = 0x80 | ((c >> (l * 6)) & 0x3f);
	**d = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0xffff, -0xc(%rbp)     # imm = 0xFFFF
jle 0x3e687
movl -0xc(%rbp), %eax
sarl $0x12, %eax
orl $0xf0, %eax
movb %al, %cl
movq -0x8(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movl $0x3, -0x10(%rbp)
jmp 0x3e71c
cmpl $0x7ff, -0xc(%rbp)      # imm = 0x7FF
jle 0x3e6b9
movl -0xc(%rbp), %eax
sarl $0xc, %eax
orl $0xe0, %eax
movb %al, %cl
movq -0x8(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movl $0x2, -0x10(%rbp)
jmp 0x3e71a
cmpl $0x7f, -0xc(%rbp)
jle 0x3e6e8
movl -0xc(%rbp), %eax
sarl $0x6, %eax
orl $0xc0, %eax
movb %al, %cl
movq -0x8(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movl $0x1, -0x10(%rbp)
jmp 0x3e718
cmpl $0x0, -0xc(%rbp)
jle 0x3e6f6
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x3e700
movl $0x20, %eax
movl %eax, -0x14(%rbp)
jmp 0x3e700
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
jmp 0x3e71a
jmp 0x3e71c
jmp 0x3e71e
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x10(%rbp)
cmpl $0x0, %eax
je 0x3e756
movl -0xc(%rbp), %eax
imull $0x6, -0x10(%rbp), %ecx
sarl %cl, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x8(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
jmp 0x3e71e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/trfn.c
// Function: agl_map
static int agl_map(char *d, char *s)
{
	char *u = tab_get(tab_agl, s);	/* unicode code point like "FB8E" */
	if (!u)
		return 1;
	while (u && *u) {
		while (*u == ' ')
			u++;
		utf8put(&d, hexval(u, 6));
		u = strchr(u, ' ');
	}
	*d = '\0';
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq 0x38089(%rip), %rdi     # 0x76810
movq -0x18(%rbp), %rsi
callq 0x3f530
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3e7a4
movl $0x1, -0x4(%rbp)
jmp 0x3e822
jmp 0x3e7a6
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x3e7c2
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x3e7cb
jmp 0x3e814
jmp 0x3e7cd
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x3e7e7
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3e7cd
movq -0x20(%rbp), %rdi
movl $0x6, %esi
callq 0x3e830
movl %eax, %esi
leaq -0x10(%rbp), %rdi
callq 0x3e640
movq -0x20(%rbp), %rdi
movl $0x20, %esi
callq 0x3d0a0
movq %rax, -0x20(%rbp)
jmp 0x3e7a6
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/trfn.c
// Function: hexval
static int hexval(char *s, int len)
{
	char *digs = HEXDIGS;
	int n = 0;
	int i;
	for (i = 0; i < len; i++) {
		if (s[i] && strchr(digs, s[i]))
			n = n * 16 + (strchr(digs, s[i]) - digs);
		else
			break;
	}
	return i < 4 ? -1 : n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x7f7d(%rip), %rax      # 0x467c3
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3e8d2
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3e8c3
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x3d0a0
cmpq $0x0, %rax
je 0x3e8c3
movl -0x1c(%rbp), %eax
shll $0x4, %eax
cltq
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x3d0a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
jmp 0x3e8c5
jmp 0x3e8d2
jmp 0x3e8c7
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3e858
cmpl $0x4, -0x20(%rbp)
jge 0x3e8e2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x2c(%rbp)
jmp 0x3e8e8
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)