LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/tools/configctl.c
// Function: configctl_do
static int _configctl_do(Config * config, int verbose, char const * section,
		char const * key, char const * value)
{
	char const * p;

	if(value == NULL)
	{
		if((p = config_get(config, section, key)) == NULL)
			return -_configctl_error(PROGNAME, 1);
		_configctl_print(verbose, section, key, p);
	}
	else
	{
		if(config_set(config, section, key, value) != 0)
			return -_configctl_error(PROGNAME, 1);
		_configctl_print(verbose, section, key, value);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x182f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x10a0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x1819
leaq 0x982(%rip), %rdi       # 0x2186
movl $0x1, %esi
callq 0x15f0
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1880
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x16a0
jmp 0x1879
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x10f0
cmpl $0x0, %eax
je 0x1865
leaq 0x936(%rip), %rdi       # 0x2186
movl $0x1, %esi
callq 0x15f0
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1880
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x16a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/test_analyze.c
// Function: show_post
void show_post(OTF_FILE *otf) // {{{
{
  assert(otf);
  int len=0;
  char *buf;

  buf=otf_get_table(otf,OTF_TAG('p','o','s','t'),&len);
  if (!buf) {
    assert(len==-1);
    printf("No post table\n");
    return;
  }
  // TODO: check len
  printf("POST: (%d bytes)\n"
         "  version: %08x\n"
         "  italicAngle: %d.%d\n"
         "  underlinePosition: %d\n"
         "  underlineThickness: %d\n"
         "  isFixedPitch: %d\n"
         "  vmType42: %d %d\n"
         "  vmType1: %d %d\n",len,
         get_ULONG(buf),
         get_LONG(buf+4)>>16,get_ULONG(buf+4)&0xffff,
         get_SHORT(buf+8),
         get_SHORT(buf+10),
         get_ULONG(buf+12),
         get_ULONG(buf+16),get_ULONG(buf+20),
         get_ULONG(buf+24),get_ULONG(buf+38));
  free(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x136a
jmp 0x1389
leaq 0xac93(%rip), %rdi      # 0xc004
leaq 0xac90(%rip), %rsi      # 0xc008
movl $0x19, %edx
leaq 0xac93(%rip), %rcx      # 0xc017
callq 0x1100
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movl $0x706f7374, %esi       # imm = 0x706F7374
leaq -0x24(%rbp), %rdx
callq 0x3340
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x13e7
cmpl $-0x1, -0x24(%rbp)
jne 0x13b5
jmp 0x13d4
leaq 0xac76(%rip), %rdi      # 0xc032
leaq 0xac45(%rip), %rsi      # 0xc008
movl $0x1f, %edx
leaq 0xac48(%rip), %rcx      # 0xc017
callq 0x1100
leaq 0xac5f(%rip), %rdi      # 0xc03a
movb $0x0, %al
callq 0x1040
jmp 0x14da
movl -0x24(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x30(%rbp), %rdi
callq 0x14f0
movl %eax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
addq $0x4, %rdi
callq 0x1530
sarl $0x10, %eax
movl %eax, -0x44(%rbp)
movq -0x30(%rbp), %rdi
addq $0x4, %rdi
callq 0x14f0
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x1570
cwtl
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rdi
addq $0xa, %rdi
callq 0x1570
movswl %ax, %r15d
movq -0x30(%rbp), %rdi
addq $0xc, %rdi
callq 0x14f0
movl %eax, %r14d
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
callq 0x14f0
movl %eax, %ebx
movq -0x30(%rbp), %rdi
addq $0x14, %rdi
callq 0x14f0
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x14f0
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
addq $0x26, %rdi
callq 0x14f0
movl -0x4c(%rbp), %esi
movl -0x48(%rbp), %edx
movl -0x44(%rbp), %ecx
movl -0x40(%rbp), %r8d
movl -0x3c(%rbp), %r9d
movl -0x38(%rbp), %r11d
movl -0x34(%rbp), %r10d
leaq 0xab9a(%rip), %rdi      # 0xc049
movl %r15d, (%rsp)
movl %r14d, 0x8(%rsp)
movl %ebx, 0x10(%rsp)
movl %r11d, 0x18(%rsp)
movl %r10d, 0x20(%rsp)
movl %eax, 0x28(%rsp)
movb $0x0, %al
callq 0x1040
movq -0x30(%rbp), %rdi
callq 0x11a0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/test_analyze.c
// Function: show_glyf
void show_glyf(OTF_FILE *otf,int full) // {{{
{
  assert(otf);

  // ensure >glyphOffsets and >gly is there
  if ( (!otf->gly)||(!otf->glyphOffsets) ) {
    if (otf_load_glyf(otf)!=0) {
      assert(0);
      return;
    }
  }

  int iA;
  int compGlyf=0,zeroGlyf=0;

  // {{{ glyf
  assert(otf->gly);
  for (iA=0;iA<otf->numGlyphs;iA++) {
    int len=otf_get_glyph(otf,iA);
    if (len==0) {
      zeroGlyf++;
    } else if (get_SHORT(otf->gly)==-1) {
      compGlyf++;
    }
    if (full) {
      printf("%d(%d) ",get_SHORT(otf->gly),len);
    }
  }
  if (full) {
    printf("\n");
  }
  printf("numGlyf(nonnull): %d(%d), composites: %d\n",otf->numGlyphs,otf->numGlyphs-zeroGlyf,compGlyf);
  // }}}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1c88
jmp 0x1ca7
leaq 0xa375(%rip), %rdi      # 0xc004
leaq 0xa372(%rip), %rsi      # 0xc008
movl $0xa8, %edx
leaq 0xa670(%rip), %rcx      # 0xc312
callq 0x1100
movq -0x8(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x1cc0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x1cef
movq -0x8(%rbp), %rdi
callq 0x3540
cmpl $0x0, %eax
je 0x1ced
leaq 0xa50f(%rip), %rdi      # 0xc1e4
leaq 0xa32c(%rip), %rsi      # 0xc008
movl $0xad, %edx
leaq 0xa62a(%rip), %rcx      # 0xc312
callq 0x1100
jmp 0x1cef
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x1d0d
jmp 0x1d2c
leaq 0xa61e(%rip), %rdi      # 0xc332
leaq 0xa2ed(%rip), %rsi      # 0xc008
movl $0xb6, %edx
leaq 0xa5eb(%rip), %rcx      # 0xc312
callq 0x1100
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movzwl 0x4c(%rcx), %ecx
cmpl %ecx, %eax
jge 0x1dc0
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
movzwl %ax, %esi
callq 0x4380
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x1d65
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1d86
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x1570
cwtl
cmpl $-0x1, %eax
jne 0x1d84
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1d86
cmpl $0x0, -0xc(%rbp)
je 0x1db0
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x1570
movswl %ax, %esi
movl -0x1c(%rbp), %edx
leaq 0xa592(%rip), %rdi      # 0xc33b
movb $0x0, %al
callq 0x1040
jmp 0x1db2
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1d33
cmpl $0x0, -0xc(%rbp)
je 0x1dd4
leaq 0xa966(%rip), %rdi      # 0xc733
movb $0x0, %al
callq 0x1040
movq -0x8(%rbp), %rax
movzwl 0x4c(%rax), %esi
movq -0x8(%rbp), %rax
movzwl 0x4c(%rax), %edx
subl -0x18(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0xa552(%rip), %rdi      # 0xc343
movb $0x0, %al
callq 0x1040
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/test_analyze.c
// Function: show_hmtx
void show_hmtx(OTF_FILE *otf) // {{{
{
  assert(otf);
  int iA;

  otf_get_width(otf,0); // load table.
  if (!otf->hmtx) {
    printf("NOTE: no hmtx table!\n");
    return;
  }
  printf("hmtx (%d):\n",otf->numberOfHMetrics);
  for (iA=0;iA<otf->numberOfHMetrics;iA++) {
    printf("(%d,%d) ",
           get_USHORT(otf->hmtx+iA*4),
           get_SHORT(otf->hmtx+iA*4+2));
  }
  printf(" (last is repeated for the remaining %d glyphs)\n",otf->numGlyphs-otf->numberOfHMetrics);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1e15
jmp 0x1e34
leaq 0xa1e8(%rip), %rdi      # 0xc004
leaq 0xa1e5(%rip), %rsi      # 0xc008
movl $0xcc, %edx
leaq 0xa53e(%rip), %rcx      # 0xc36d
callq 0x1100
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x4010
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x1e5d
leaq 0xa537(%rip), %rdi      # 0xc388
movb $0x0, %al
callq 0x1040
jmp 0x1f02
movq -0x8(%rbp), %rax
movzwl 0x58(%rax), %esi
leaq 0xa532(%rip), %rdi      # 0xc39e
movb $0x0, %al
callq 0x1040
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movzwl 0x58(%rcx), %ecx
cmpl %ecx, %eax
jge 0x1ee2
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movl -0xc(%rbp), %eax
shll $0x2, %eax
cltq
addq %rax, %rdi
callq 0x1840
movzwl %ax, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movl -0xc(%rbp), %eax
shll $0x2, %eax
cltq
addq %rax, %rdi
addq $0x2, %rdi
callq 0x1570
movl -0x10(%rbp), %esi
movswl %ax, %edx
leaq 0xa4da(%rip), %rdi      # 0xc3aa
movb $0x0, %al
callq 0x1040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1e7a
movq -0x8(%rbp), %rax
movzwl 0x4c(%rax), %esi
movq -0x8(%rbp), %rax
movzwl 0x58(%rax), %eax
subl %eax, %esi
leaq 0xa4b8(%rip), %rdi      # 0xc3b3
movb $0x0, %al
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shuffle2[P]nx2elf/nx2elf.cpp
// Function: main
int main(int argc, char** argv) {
  if (argc < 2 || !fs::exists(argv[1])) {
    fputs("file or directory", stderr);
    return 1;
  }

  fs::path path(argv[1]);
  if (fs::is_directory(path)) {
    File::iter_files(path, [](const fs::path& nx_path) { NsoToElf(nx_path); });
  } else {
    NsoToElf(path);
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %ecx
movb $0x0, -0x39(%rbp)
movb $0x1, %al
cmpl $0x2, %ecx
movb %al, -0x9a(%rbp)
jl 0x28c0
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movl $0x2, %edx
callq 0x34f0
movq -0xa8(%rbp), %rdi
movb $0x1, -0x39(%rbp)
callq 0x34c0
movb %al, -0x9b(%rbp)
jmp 0x28b2
movb -0x9b(%rbp), %al
xorb $-0x1, %al
movb %al, -0x9a(%rbp)
movb -0x9a(%rbp), %al
movb %al, -0xa9(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x28d4
jmp 0x28dd
leaq -0x38(%rbp), %rdi
callq 0x35d0
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x28e9
jmp 0x292d
movq 0x706f0(%rip), %rax     # 0x72fe0
movq (%rax), %rsi
leaq 0x6582a(%rip), %rdi     # 0x68124
callq 0x2270
movl $0x1, -0x4(%rbp)
jmp 0x29f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x291f
jmp 0x2928
leaq -0x38(%rbp), %rdi
callq 0x35d0
jmp 0x2a04
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movl $0x2, %edx
callq 0x34f0
movq -0xb8(%rbp), %rdi
callq 0x3600
movb %al, -0xaa(%rbp)
jmp 0x295e
movb -0xaa(%rbp), %al
testb $0x1, %al
jne 0x296a
jmp 0x29cc
leaq -0x98(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
leaq -0x99(%rbp), %rsi
callq 0x2b60
movq -0xc0(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x2a10
jmp 0x2996
leaq -0x98(%rbp), %rdi
callq 0x3630
jmp 0x29db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x29ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x3630
jmp 0x29ed
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
callq 0x2bf0
jmp 0x29d9
jmp 0x29db
movl $0x0, -0x4(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x35d0
jmp 0x29f8
leaq -0x78(%rbp), %rdi
callq 0x35d0
jmp 0x2a04
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2370
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shuffle2[P]nx2elf/nx2elf.cpp
// Function: File::iter_files(std::filesystem::__cxx11::path const&, std::function<void (std::filesystem::__cxx11::path const&)>)
static void iter_files(const fs::path& directory,
                       std::function<void(const fs::path&)> func) {
  for (auto& dirent : fs::directory_iterator(directory)) {
    auto& path = dirent.path();
    if (!fs::is_directory(path)) {
      func(path);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x3900
leaq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3960
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3930
leaq -0x48(%rbp), %rdi
callq 0x3990
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x3960
leaq -0x58(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x39b0
leaq -0x68(%rbp), %rdi
callq 0x3990
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x39f0
testb $0x1, %al
jne 0x2ab6
leaq -0x58(%rbp), %rdi
callq 0x3990
leaq -0x38(%rbp), %rdi
callq 0x3990
leaq -0x28(%rbp), %rdi
callq 0x3990
jmp 0x2b3f
leaq -0x38(%rbp), %rdi
callq 0x2390
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x3a20
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x3600
movb %al, -0x91(%rbp)
jmp 0x2ae1
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x2b2d
jmp 0x2aed
movq -0x90(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x3a30
jmp 0x2aff
jmp 0x2b2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3990
leaq -0x38(%rbp), %rdi
callq 0x3990
leaq -0x28(%rbp), %rdi
callq 0x3990
jmp 0x2b48
jmp 0x2b2f
leaq -0x38(%rbp), %rdi
callq 0x20a0
jmp 0x2b3a
jmp 0x2a85
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shuffle2[P]nx2elf/nx2elf.cpp
// Function: NsoToElf(std::filesystem::__cxx11::path const&, bool)
static bool NsoToElf(const fs::path& path, bool verbose = false) {
  NsoFile nso;
  if (!nso.Load(path)) {
    return false;
  }
  printf("%s:\n", path.string().c_str());
  nso.Dump(verbose);
  if (verbose) {
    nso.DumpElfInfo();
  }
  fs::path elf_path(path);
  elf_path.replace_extension(".elf");
  bool rv = nso.WriteElf(elf_path);
  puts("");
  return rv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq -0x1f8(%rbp), %rdi
movq %rdi, -0x288(%rbp)
callq 0x3ea0
movq -0x288(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x40e0
movb %al, -0x27a(%rbp)
jmp 0x2c32
movb -0x27a(%rbp), %al
testb $0x1, %al
jne 0x2c68
jmp 0x2c3e
movb $0x0, -0x1(%rbp)
movl $0x1, -0x208(%rbp)
jmp 0x2dda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x200(%rbp)
movl %eax, -0x204(%rbp)
jmp 0x2df4
movq -0x10(%rbp), %rsi
leaq -0x228(%rbp), %rdi
callq 0x5410
jmp 0x2c7a
leaq -0x228(%rbp), %rdi
callq 0x2100
movq %rax, %rsi
leaq 0x654a6(%rip), %rdi     # 0x68136
xorl %eax, %eax
callq 0x2030
jmp 0x2c99
leaq -0x228(%rbp), %rdi
callq 0x21b0
movzbl -0x11(%rbp), %esi
andl $0x1, %esi
leaq -0x1f8(%rbp), %rdi
callq 0x5490
jmp 0x2cba
testb $0x1, -0x11(%rbp)
je 0x2cf3
leaq -0x1f8(%rbp), %rdi
callq 0x5a20
jmp 0x2cce
jmp 0x2cf3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x200(%rbp)
movl %eax, -0x204(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x21b0
jmp 0x2df4
movq -0x10(%rbp), %rsi
leaq -0x250(%rbp), %rdi
callq 0x5cd0
jmp 0x2d05
leaq 0x6542f(%rip), %rsi     # 0x6813b
leaq -0x278(%rbp), %rdi
movl $0x2, %edx
callq 0x5d30
jmp 0x2d1f
leaq -0x250(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0x2200
jmp 0x2d34
leaq -0x278(%rbp), %rdi
callq 0x35d0
leaq -0x1f8(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x5e10
movb %al, -0x289(%rbp)
jmp 0x2d5b
movb -0x289(%rbp), %al
andb $0x1, %al
movb %al, -0x279(%rbp)
leaq 0x654f0(%rip), %rdi     # 0x68260
callq 0x2330
jmp 0x2d77
movb -0x279(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x208(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x35d0
jmp 0x2dda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x200(%rbp)
movl %eax, -0x204(%rbp)
jmp 0x2dcc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x200(%rbp)
movl %eax, -0x204(%rbp)
leaq -0x278(%rbp), %rdi
callq 0x35d0
leaq -0x250(%rbp), %rdi
callq 0x35d0
jmp 0x2df4
leaq -0x1f8(%rbp), %rdi
callq 0x8ea0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
leaq -0x1f8(%rbp), %rdi
callq 0x8ea0
movq -0x200(%rbp), %rdi
callq 0x2370
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shuffle2[P]nx2elf/nx2elf.cpp
// Function: File::Read(std::filesystem::__cxx11::path const&)
static std::vector<u8> Read(const fs::path& path) {
  std::error_code error;
  auto size = fs::file_size(path, error);
  if (size == std::numeric_limits<std::uintmax_t>::max())
    return {};
  auto buffer = std::vector<u8>(size);
  auto f = Open(path, "rb");
  if (!f)
    return {};
  if (!fread(buffer.data(), buffer.size(), 1, f.get()))
    return {};
  return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x9860
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x22a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x9890
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jne 0x2e7f
movq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2170
movq -0x80(%rbp), %rdi
callq 0x8ed0
jmp 0x2fff
movq -0x28(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x8fd0
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x8ff0
jmp 0x2eb3
leaq -0x41(%rbp), %rdi
callq 0x90f0
movq -0x10(%rbp), %rsi
leaq 0x6533e(%rip), %rdx     # 0x68205
leaq -0x60(%rbp), %rdi
callq 0x3020
jmp 0x2ed2
leaq -0x60(%rbp), %rdi
callq 0x98a0
testb $0x1, %al
jne 0x2f2f
movq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2170
movq -0x80(%rbp), %rdi
callq 0x8ed0
movl $0x1, -0x64(%rbp)
jmp 0x2fe0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x90f0
jmp 0x300c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2ff4
leaq -0x40(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x98d0
movq -0xb0(%rbp), %rdi
movq %rax, -0xa8(%rbp)
callq 0x8f50
movq %rax, -0xa0(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x98f0
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq %rax, %rcx
movl $0x1, %edx
callq 0x2310
movq %rax, -0x98(%rbp)
jmp 0x2f86
movq -0x98(%rbp), %rax
cmpq $0x0, %rax
jne 0x2fcc
movq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2170
movq -0x80(%rbp), %rdi
callq 0x8ed0
movl $0x1, -0x64(%rbp)
jmp 0x2fe0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x9950
jmp 0x2ff4
movq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9920
movl $0x1, -0x64(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x9950
leaq -0x40(%rbp), %rdi
callq 0x9090
jmp 0x2fff
leaq -0x40(%rbp), %rdi
callq 0x9090
jmp 0x300c
movq -0x78(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shuffle2[P]nx2elf/nx2elf.cpp
// Function: File::Write(std::filesystem::__cxx11::path const&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
static bool Write(const fs::path& path, const std::vector<u8>& buffer) {
  auto f = Open(path, "wb");
  if (!f)
    return false;
  return !!fwrite(buffer.data(), buffer.size(), 1, f.get());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
leaq 0x65691(%rip), %rdx     # 0x68760
callq 0x3020
leaq -0x20(%rbp), %rdi
callq 0x98a0
testb $0x1, %al
jne 0x30ee
movb $0x0, -0x1(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0x3160
movq -0x18(%rbp), %rdi
callq 0x12a00
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8f50
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x98f0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rcx
movl $0x1, %edx
callq 0x23a0
movq %rax, -0x40(%rbp)
jmp 0x312c
movq -0x40(%rbp), %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0x3160
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x9950
jmp 0x3174
leaq -0x20(%rbp), %rdi
callq 0x9950
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2370
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shuffle2[P]nx2elf/nx2elf.cpp
// Function: NsoFile::Decompress(unsigned char*, unsigned int, unsigned char const*, unsigned int)
bool Decompress(u8* dst, u32 dst_len, const u8* src, u32 src_len) {
    int len =
        LZ4_decompress_safe(reinterpret_cast<const char*>(src),
                            reinterpret_cast<char*>(dst), src_len, dst_len);
    if (len != dst_len)
      printf("LZ4_decompress_safe: %d (expected %8x)\n", len, dst_len);
    return len > 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0x54d80
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x915d
movl -0x28(%rbp), %esi
movl -0x14(%rbp), %edx
leaq 0x5f0e3(%rip), %rdi     # 0x68239
movb $0x0, %al
callq 0x2030
cmpl $0x0, -0x28(%rbp)
setg %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shuffle2[P]nx2elf/nx2elf.cpp
// Function: NsoFile::ResolvePlt(void*, unsigned long)
bool ResolvePlt(void* base, size_t len) {
    // Each plt slot is 4 instructions. The first entry fills 2 slots (resolving
    // thunk).
    if (dyn_info.pltrelsz) {
      const u32 plt_pattern[]{0xa9bf7bf0, 0xd00004d0, 0xf9428a11, 0x91144210,
                              0xd61f0220, 0xd503201f, 0xd503201f, 0xd503201f};
      const u32 plt_mask[ARRAY_SIZE(plt_pattern)]{
          0xffffffff, 0x00000000, 0xff000000, 0xff000000,
          0xff000000, 0xffffffff, 0xffffffff, 0xffffffff};
      auto found = static_cast<u8*>(
          memmem_m(base, len, plt_pattern, plt_mask, sizeof(plt_pattern)));
      if (found) {
        plt_info.addr = found - &image[0];
        // Assume the plt exactly matches .rela.plt
        u64 plt_entry_count = dyn_info.pltrelsz / sizeof(Elf64_Rela);
        const u64 plt_entry_size = sizeof(u32) * 4;
        plt_info.size = plt_entry_size * 2 + plt_entry_size * plt_entry_count;
        return true;
      }
    }
    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, 0x150(%rax)
je 0x9291
movq 0x5f5cc(%rip), %rax     # 0x68770
movq %rax, -0x40(%rbp)
movq 0x5f5c9(%rip), %rax     # 0x68778
movq %rax, -0x38(%rbp)
movq 0x5f5c6(%rip), %rax     # 0x68780
movq %rax, -0x30(%rbp)
movq 0x5f5c3(%rip), %rax     # 0x68788
movq %rax, -0x28(%rbp)
movq 0x5f5c0(%rip), %rax     # 0x68790
movq %rax, -0x60(%rbp)
movq 0x5f5bd(%rip), %rax     # 0x68798
movq %rax, -0x58(%rbp)
movq 0x5f5ba(%rip), %rax     # 0x687a0
movq %rax, -0x50(%rbp)
movq 0x5f5b7(%rip), %rax     # 0x687a8
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x60(%rbp), %rcx
movl $0x20, %r8d
callq 0xa790
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0x928f
movq -0x80(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, -0x88(%rbp)
addq $0x108, %rdi            # imm = 0x108
xorl %eax, %eax
movl %eax, %esi
callq 0x8f70
movq -0x88(%rbp), %rcx
movq %rax, %rdx
movq -0x80(%rbp), %rax
subq %rdx, %rcx
movq %rcx, 0x1b0(%rax)
movq 0x150(%rax), %rax
movl $0x18, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x80(%rbp), %rax
movq %rcx, -0x70(%rbp)
movq $0x10, -0x78(%rbp)
movq -0x70(%rbp), %rcx
shlq $0x4, %rcx
addq $0x20, %rcx
movq %rcx, 0x1b8(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x9295
jmp 0x9291
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shuffle2[P]nx2elf/./types.h
// Function: memmemr(void const*, unsigned long, void const*, unsigned long)
inline void* memmemr(const void* haystack,
                     size_t haystack_len,
                     const void* needle,
                     size_t needle_len) {
  u8* p = (u8*)haystack + haystack_len - needle_len;
  u8* e = (u8*)haystack;
  while (p >= e) {
    if (!memcmp(p, needle, needle_len)) {
      return p;
    }
    p--;
  }
  return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
xorl %ecx, %ecx
subq -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jb 0x980d
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2140
cmpl $0x0, %eax
jne 0x97ff
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9815
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x97d5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/shuffle2[P]nx2elf/./types.h
// Function: memmem_m(void const*, unsigned long, void const*, void const*, unsigned long)
inline void* memmem_m(const void* haystack,
                      size_t haystack_len,
                      const void* needle,
                      const void* mask,
                      size_t needle_len) {
  u8* p = (u8*)haystack;
  u8* e = (u8*)haystack + haystack_len - needle_len;
  while (p <= e) {
    if (!memcmp_m(p, needle, mask, needle_len)) {
      return p;
    }
    p++;
  }
  return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
xorl %ecx, %ecx
subq -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
ja 0xa805
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0xa820
cmpl $0x0, %eax
jne 0xa7f7
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa80d
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xa7c9
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shuffle2[P]nx2elf/./types.h
// Function: memcmp_m(void const*, void const*, void const*, unsigned long)
inline int memcmp_m(const void* ptr1,
                    const void* ptr2,
                    const void* mask,
                    size_t len) {
  const u8* a = (const u8*)ptr1;
  const u8* b = (const u8*)ptr2;
  const u8* m = (const u8*)mask;
  u8 x = 0;
  while (len-- && !x) {
    x = (*a++ ^ *b++) & *m++;
  }
  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x3a(%rbp)
je 0xa876
cmpb $0x0, -0x39(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0xa87f
jmp 0xa8be
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %eax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movzbl (%rcx), %ecx
xorl %ecx, %eax
movq -0x38(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movzbl (%rcx), %ecx
andl %ecx, %eax
movb %al, -0x39(%rbp)
jmp 0xa850
movzbl -0x39(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/shuffle2[P]nx2elf/./types.h
// Function: memmem
inline void* memmem(const void* haystack,
                    size_t haystack_len,
                    const void* needle,
                    size_t needle_len) {
  u8* p = (u8*)haystack;
  u8* e = (u8*)haystack + haystack_len - needle_len;
  while (p <= e) {
    if (!memcmp(p, needle, needle_len)) {
      return p;
    }
    p++;
  }
  return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
xorl %ecx, %ecx
subq -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
ja 0xe01d
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2140
cmpl $0x0, %eax
jne 0xe00f
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe025
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xdfe5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/shuffle2[P]nx2elf/nx2elf.cpp
// Function: StringTable::GetBuffer()
std::vector<char> GetBuffer() {
    std::vector<char> buffer(watermark);
    for (const auto& entry : entries) {
      strcpy(&buffer[entry.second], entry.first);
    }
    return buffer;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x11(%rbp)
movl 0x38(%rax), %eax
movq %rax, -0x58(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2380
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x11c60
jmp 0x11b6e
leaq -0x12(%rbp), %rdi
callq 0x2250
movq -0x68(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x11cd0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x11d00
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x11d30
testb $0x1, %al
jne 0x11bac
jmp 0x11bfc
leaq -0x38(%rbp), %rdi
callq 0x11d60
movq -0x60(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0xe090
movq %rax, %rdi
movq -0x48(%rbp), %rax
movq (%rax), %rsi
callq 0x2210
leaq -0x38(%rbp), %rdi
callq 0x11d90
jmp 0x11b99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x2250
jmp 0x11c19
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x11c0f
movq -0x60(%rbp), %rdi
callq 0xe510
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shuffle2[P]nx2elf/lz4.c
// Function: LZ4_initStream
LZ4_stream_t* LZ4_initStream (void* buffer, size_t size)
{
    DEBUGLOG(5, "LZ4_initStream");
    if (buffer == NULL) { return NULL; }
    if (size < sizeof(LZ4_stream_t)) { return NULL; }
    if (!LZ4_isAligned(buffer, LZ4_stream_t_alignment())) return NULL;
    MEM_INIT(buffer, 0, sizeof(LZ4_stream_t_internal));
    return (LZ4_stream_t*)buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1fc61
movq $0x0, -0x8(%rbp)
jmp 0x1fcb5
cmpq $0x4020, -0x18(%rbp)    # imm = 0x4020
jae 0x1fc75
movq $0x0, -0x8(%rbp)
jmp 0x1fcb5
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x3a3c0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x3a390
cmpl $0x0, %eax
jne 0x1fc9d
movq $0x0, -0x8(%rbp)
jmp 0x1fcb5
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x4020, %edx           # imm = 0x4020
callq 0x2170
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/shuffle2[P]nx2elf/lz4.c
// Function: LZ4_attach_dictionary
void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream)
{
    const LZ4_stream_t_internal* dictCtx = (dictionaryStream == NULL) ? NULL :
        &(dictionaryStream->internal_donotuse);

    DEBUGLOG(4, "LZ4_attach_dictionary (%p, %p, size %u)",
             workingStream, dictionaryStream,
             dictCtx != NULL ? dictCtx->dictSize : 0);

    if (dictCtx != NULL) {
        /* If the current offset is zero, we will never look in the
         * external dictionary context, since there is no value a table
         * entry can take that indicate a miss. In that case, we need
         * to bump the offset to something non-zero.
         */
        if (workingStream->internal_donotuse.currentOffset == 0) {
            workingStream->internal_donotuse.currentOffset = 64 KB;
        }

        /* Don't actually attach an empty dictionary.
         */
        if (dictCtx->dictSize == 0) {
            dictCtx = NULL;
        }
    }
    workingStream->internal_donotuse.dictCtx = dictCtx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3a8fb
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x3a903
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3a944
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4000(%rax)
jne 0x3a92d
movq -0x8(%rbp), %rax
movl $0x10000, 0x4000(%rax)  # imm = 0x10000
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4018(%rax)
jne 0x3a942
movq $0x0, -0x18(%rbp)
jmp 0x3a944
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x4010(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shuffle2[P]nx2elf/lz4.c
// Function: LZ4_saveDict
int LZ4_saveDict (LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize)
{
    LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse;

    DEBUGLOG(5, "LZ4_saveDict : dictSize=%i, safeBuffer=%p", dictSize, safeBuffer);

    if ((U32)dictSize > 64 KB) { dictSize = 64 KB; } /* useless to define a dictionary > 64 KB */
    if ((U32)dictSize > dict->dictSize) { dictSize = (int)dict->dictSize; }

    if (safeBuffer == NULL) assert(dictSize == 0);
    if (dictSize > 0) {
        const BYTE* const previousDictEnd = dict->dictionary + dict->dictSize;
        assert(dict->dictionary);
        memmove(safeBuffer, previousDictEnd - dictSize, dictSize);
    }

    dict->dictionary = (const BYTE*)safeBuffer;
    dict->dictSize = (U32)dictSize;

    return dictSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x10000, -0x14(%rbp)   # imm = 0x10000
jbe 0x54ceb
movl $0x10000, -0x14(%rbp)   # imm = 0x10000
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4018(%rcx), %eax
jbe 0x54d07
movq -0x20(%rbp), %rax
movl 0x4018(%rax), %eax
movl %eax, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x54d10
jmp 0x54d10
cmpl $0x0, -0x14(%rbp)
jle 0x54d4f
movq -0x20(%rbp), %rax
movq 0x4008(%rax), %rax
movq -0x20(%rbp), %rcx
movl 0x4018(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq -0x14(%rbp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movslq -0x14(%rbp), %rdx
callq 0x2340
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x4008(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4018(%rax)
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shuffle2[P]nx2elf/lz4.c
// Function: LZ4_setStreamDecode
int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)
{
    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
    lz4sd->prefixSize = (size_t)dictSize;
    if (dictSize) {
        assert(dictionary != NULL);
        lz4sd->prefixEnd = (const BYTE*) dictionary + dictSize;
    } else {
        lz4sd->prefixEnd = (const BYTE*) dictionary;
    }
    lz4sd->externalDict = NULL;
    lz4sd->extDictSize  = 0;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
cmpl $0x0, -0x14(%rbp)
je 0x5ed9e
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5edaa
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x1, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/sam.c
// Function: check_bam_aux_get
uint8_t *check_bam_aux_get(const bam1_t *aln, const char *tag, char type)
{
    uint8_t *p = bam_aux_get(aln, tag);
    if (p) {
        if (*p == type) return p;
        else fail("%s field of type '%c', expected '%c'", tag, *p, type);
    }
    else fail("can't find %s field", tag);

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x43840
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5b25
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5b06
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5b3f
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movzbl (%rax), %edx
movsbl -0x19(%rbp), %ecx
leaq 0xeae9c(%rip), %rdi     # 0xf09b8
movb $0x0, %al
callq 0x5b50
jmp 0x5b37
movq -0x18(%rbp), %rsi
leaq 0xeaead(%rip), %rdi     # 0xf09dd
movb $0x0, %al
callq 0x5b50
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/sam.c
// Function: fail
static void HTS_FORMAT(HTS_PRINTF_FMT, 1, 2) fail(const char *fmt, ...)
{
    va_list args;

    fprintf(stderr, "Failed: ");
    va_start(args, fmt);
    vfprintf(stderr, fmt, args);
    va_end(args);
    fprintf(stderr, "\n");

    status = EXIT_FAILURE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x5b85
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x10b42d(%rip), %rax    # 0x110fe0
movq %rax, -0xe0(%rbp)
movq (%rax), %rdi
leaq 0xeae6d(%rip), %rsi     # 0xf0a31
xorl %eax, %eax
movb %al, -0xd1(%rbp)
callq 0x46d0
movq -0xe0(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, -0x10(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x4660
movq -0xe0(%rbp), %rcx
movb -0xd1(%rbp), %al
movq (%rcx), %rdi
leaq 0xece2d(%rip), %rsi     # 0xf2a4d
callq 0x46d0
movl $0x1, 0x1100d5(%rip)    # 0x115d04
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/sam.c
// Function: main
int main(int argc, char **argv)
{
    int i;

    status = EXIT_SUCCESS;

    aux_fields1();
    iterators1();
    samrecord_layout();
    use_header_api();
    test_header_pg_lines();
    test_header_pg_loops();
    test_header_updates();
    test_header_remove_lines();
    test_header_ref_altnames();
    test_empty_sam_file("test/emptyfile");
    test_text_file("test/emptyfile", 0);
    test_text_file("test/xx#pair.sam", 7);
    test_text_file("test/xx.fa", 7);
    test_text_file("test/faidx/fastqs.fq", 500);
    check_enum1();
    check_cigar_tab();
    check_big_ref(0);
    check_big_ref(1);
    test_parse_decimal();
    test_mempolicy();
    set_qname();
    for (i = 1; i < argc; i++) faidx1(argv[i]);

    hts_set_log_level(HTS_LOG_OFF);
    test_bam_set1_minimal();
    test_bam_set1_full();
    test_bam_set1_even_and_odd_seq_len();
    test_bam_set1_with_seq_but_no_qual();
    test_bam_set1_validate_qname();
    test_bam_set1_validate_seq();
    test_bam_set1_validate_cigar();
    test_bam_set1_validate_size_limits();
    test_bam_set1_write_and_read_back();
    test_cigar_api();

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, 0x1100a4(%rip)    # 0x115d04
callq 0x5d80
callq 0x7590
callq 0x75d0
callq 0x76e0
callq 0x8330
callq 0x8650
callq 0x8810
callq 0x8bf0
callq 0x8e40
leaq 0xead5d(%rip), %rdi     # 0xf09f1
callq 0x9570
leaq 0xead51(%rip), %rdi     # 0xf09f1
xorl %esi, %esi
callq 0x9660
leaq 0xead52(%rip), %rdi     # 0xf0a00
movl $0x7, %esi
callq 0x9660
leaq 0xead52(%rip), %rdi     # 0xf0a11
movl $0x7, %esi
callq 0x9660
leaq 0xead4c(%rip), %rdi     # 0xf0a1c
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x9660
callq 0x9760
callq 0x9770
xorl %edi, %edi
callq 0x9850
movl $0x1, %edi
callq 0x9850
callq 0x9f70
callq 0xa110
callq 0xa860
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x5d2f
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xaa70
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5d0b
xorl %edi, %edi
callq 0x2ede0
callq 0xac80
callq 0xb040
callq 0xb640
callq 0xba00
callq 0xbc80
callq 0xbdd0
callq 0xbf00
callq 0xc200
callq 0xc4d0
callq 0xcb80
movl 0x10ff96(%rip), %eax    # 0x115d04
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/sam.c
// Function: test_empty_sam_file
static void test_empty_sam_file(const char *filename)
{
    samFile *in = sam_open(filename, "r");
    if (in) {
        enum htsExactFormat format = hts_get_format(in)->format;
        bam1_t *aln = bam_init1();
        sam_hdr_t *header = sam_hdr_read(in);
        int ret = sam_read1(in, header, aln);

        if (format != empty_format)
            fail("detected %s as %d (expected empty_format)", filename, format);
        if (header)
            fail("sam_hdr_read() from %s should fail", filename);
        if (ret >= -1)
            fail("sam_read1() from %s returned %d but should fail", filename, ret);

        bam_destroy1(aln);
        sam_hdr_destroy(header);
        sam_close(in);
    }
    else fail("can't open %s to read as SAM", filename);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xee4f1(%rip), %rsi     # 0xf7a78
callq 0x232d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9640
movq -0x10(%rbp), %rdi
callq 0x25900
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
callq 0x37e90
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c9b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x41af0
movl %eax, -0x2c(%rbp)
cmpl $0xf, -0x14(%rbp)
je 0x95ef
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0xe8cdc(%rip), %rdi     # 0xf22c4
movb $0x0, %al
callq 0x5b50
cmpq $0x0, -0x28(%rbp)
je 0x9608
movq -0x8(%rbp), %rsi
leaq 0xe8ced(%rip), %rdi     # 0xf22ee
movb $0x0, %al
callq 0x5b50
cmpl $-0x1, -0x2c(%rbp)
jl 0x9623
movq -0x8(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0xe8cf5(%rip), %rdi     # 0xf2311
movb $0x0, %al
callq 0x5b50
movq -0x20(%rbp), %rdi
callq 0x380d0
movq -0x28(%rbp), %rdi
callq 0x36f50
movq -0x10(%rbp), %rdi
callq 0x253f0
jmp 0x9652
movq -0x8(%rbp), %rsi
leaq 0xe8cf6(%rip), %rdi     # 0xf2341
movb $0x0, %al
callq 0x5b50
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/sam.c
// Function: test_text_file
static void test_text_file(const char *filename, int nexp)
{
    htsFile *in = hts_open(filename, "r");
    if (in) {
        kstring_t str = KS_INITIALIZE;
        int ret, n = 0;
        while ((ret = hts_getline(in, '\n', &str)) >= 0) {
            size_t len = strlen(str.s);
            n++;
            if (ret != len) fail("hts_getline read length %d (expected %zu)", ret, len);
        }
        if (ret != -1) fail("hts_getline got an error from %s", filename);
        if (n != nexp) fail("hts_getline read %d lines from %s (expected %d)", n, filename, nexp);

        hts_close(in);
        free(str.s);
    }
    else fail("can't open %s to read as text", filename);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xee3fe(%rip), %rsi     # 0xf7a78
callq 0x232d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9742
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4240
movl $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movl $0xa, %esi
leaq -0x30(%rbp), %rdx
callq 0x26150
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jl 0x96f6
movq -0x20(%rbp), %rdi
callq 0x41a0
movq %rax, -0x40(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movslq -0x34(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x96f4
movl -0x34(%rbp), %esi
movq -0x40(%rbp), %rdx
leaq 0xe8c71(%rip), %rdi     # 0xf235e
movb $0x0, %al
callq 0x5b50
jmp 0x96a5
cmpl $-0x1, -0x34(%rbp)
je 0x970e
movq -0x8(%rbp), %rsi
leaq 0xe8c81(%rip), %rdi     # 0xf2388
movb $0x0, %al
callq 0x5b50
movl -0x38(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x972e
movl -0x38(%rbp), %esi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
leaq 0xe8c82(%rip), %rdi     # 0xf23a9
movb $0x0, %al
callq 0x5b50
movq -0x18(%rbp), %rdi
callq 0x253f0
movq -0x20(%rbp), %rdi
callq 0x45a0
jmp 0x9754
movq -0x8(%rbp), %rsi
leaq 0xe8c8c(%rip), %rdi     # 0xf23d9
movb $0x0, %al
callq 0x5b50
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/sam.c
// Function: check_cigar_tab
static void check_cigar_tab(void)
{
    int i, n_neg = 0;

    for (i = 0; i < 256; ++i)
        if (bam_cigar_table[i] < 0) n_neg++;

    if (n_neg + strlen(BAM_CIGAR_STR) != 256)
        fail("bam_cigar_table has %d unset entries", n_neg);

    for (i = 0; BAM_CIGAR_STR[i]; ++i)
        if (bam_cigar_table[(unsigned char) BAM_CIGAR_STR[i]] != i)
            fail("bam_cigar_table['%c'] is not %d", BAM_CIGAR_STR[i], i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jge 0x97b9
movslq -0x4(%rbp), %rcx
leaq 0xecfe6(%rip), %rax     # 0xf6780
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jge 0x97ac
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x97ae
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x9786
movslq -0x8(%rbp), %rax
addq $0xa, %rax
cmpq $0x100, %rax            # imm = 0x100
je 0x97da
movl -0x8(%rbp), %esi
leaq 0xe8c24(%rip), %rdi     # 0xf23f7
movb $0x0, %al
callq 0x5b50
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xe8c30(%rip), %rax     # 0xf241c
cmpb $0x0, (%rax,%rcx)
je 0x9840
movslq -0x4(%rbp), %rcx
leaq 0xe8c1f(%rip), %rax     # 0xf241c
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0xecf76(%rip), %rax     # 0xf6780
movsbl (%rax,%rcx), %eax
cmpl -0x4(%rbp), %eax
je 0x9833
movslq -0x4(%rbp), %rcx
leaq 0xe8bfe(%rip), %rax     # 0xf241c
movsbl (%rax,%rcx), %esi
movl -0x4(%rbp), %edx
leaq 0xe8bfb(%rip), %rdi     # 0xf2427
movb $0x0, %al
callq 0x5b50
jmp 0x9835
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x97e1
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)