LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_tir.c
// Function: gt_tir_arguments_new
static void* gt_tir_arguments_new(void)
{
  GtTirArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->str_indexname = gt_str_new();
  arguments->str_overlaps = gt_str_new();
  arguments->refseq_file = gt_str_new();
  arguments->cutoffs = gt_str_new();
  arguments->hmm_files = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0xb0, %esi
leaq 0x4b32be(%rip), %rdx    # 0x52e720
movl $0x40, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xa0(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_tir.c
// Function: gt_tir_arguments_delete
static void gt_tir_arguments_delete(void *tool_arguments)
{
  GtTirArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->str_indexname);
  gt_str_delete(arguments->cutoffs);
  gt_str_delete(arguments->refseq_file);
  gt_str_delete(arguments->str_overlaps);
  gt_str_array_delete(arguments->hmm_files);
  gt_option_delete(arguments->optionoverlaps);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x7b4ed
jmp 0x7b55c
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rax
movq 0x98(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rdi
leaq 0x4b31ce(%rip), %rsi    # 0x52e720
movl $0x53, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_trieins.c
// Function: gt_trieins
int gt_trieins(int argc, const char **argv, GtError *err)
{
  bool haserr = false;
  int parsed_args;
  bool onlyins = false;

  gt_error_check(err);

  switch (parse_options(&onlyins,&parsed_args, argc, argv, err)) {
    case GT_OPTION_PARSER_OK: break;
    case GT_OPTION_PARSER_ERROR: return -1;
    case GT_OPTION_PARSER_REQUESTS_EXIT: return 0;
  }
  gt_assert(parsed_args == 1);

  if (gt_test_trieins(onlyins,argv[parsed_args],err) != 0)
  {
    haserr = true;
  }
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movb $0x0, 0xf(%rsp)
movb $0x0, 0x7(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x7c73c
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x7c704
jmp 0x7c73c
movq 0x5bf895(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4998fe(%rip), %rsi    # 0x516013
leaq 0x499aa3(%rip), %rdx    # 0x5161bf
leaq 0x4b26ae(%rip), %rcx    # 0x52edd1
leaq 0x4b26b2(%rip), %r8     # 0x52eddc
movl $0x32, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x7c73e
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
leaq 0x7(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x7c830
movl %eax, %ecx
movl %ecx, (%rsp)
testl %eax, %eax
je 0x7c77a
jmp 0x7c766
movl (%rsp), %eax
subl $0x1, %eax
je 0x7c77c
jmp 0x7c770
movl (%rsp), %eax
subl $0x2, %eax
je 0x7c789
jmp 0x7c796
jmp 0x7c796
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x7c819
movl $0x0, 0x24(%rsp)
jmp 0x7c819
jmp 0x7c798
cmpl $0x1, 0x8(%rsp)
je 0x7c7d7
movq 0x5bf7fa(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x499863(%rip), %rsi    # 0x516013
leaq 0x4b263c(%rip), %rdx    # 0x52edf3
leaq 0x4b2613(%rip), %rcx    # 0x52edd1
leaq 0x4b2617(%rip), %r8     # 0x52eddc
movl $0x39, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x7c7d9
movb 0x7(%rsp), %al
movq 0x18(%rsp), %rcx
movslq 0x8(%rsp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x10(%rsp), %rdx
andb $0x1, %al
movzbl %al, %edi
callq 0x2f2b70
cmpl $0x0, %eax
je 0x7c804
movb $0x1, 0xf(%rsp)
movb 0xf(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_trieins.c
// Function: parse_options
static GtOPrval parse_options(bool *onlyins,int *parsed_args,
                              int argc, const char **argv, GtError *err)
{
  GtOptionParser *op;
  GtOption *option;
  GtOPrval oprval;

  gt_error_check(err);
  op = gt_option_parser_new("[options] indexname",
                         "Perform trie insertions and check consistency.");
  gt_option_parser_set_mail_address(op, "<kurtz@zbh.uni-hamburg.de>");
  option= gt_option_new_bool("ins","perform only insertions",onlyins,false);
  gt_option_parser_add_option(op, option);
  gt_option_parser_set_min_max_args(op, 1U, 1U);
  oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
                                  err);
  gt_option_parser_delete(op);
  return oprval;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x7c89c
movq 0x20(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x7c864
jmp 0x7c89c
movq 0x5bf735(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x49979e(%rip), %rsi    # 0x516013
leaq 0x499943(%rip), %rdx    # 0x5161bf
leaq 0x51860f(%rip), %rcx    # 0x594e92
leaq 0x4b2552(%rip), %r8     # 0x52eddc
movl $0x1f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x7c89e
leaq 0x4b255f(%rip), %rdi    # 0x52ee04
leaq 0x4b256c(%rip), %rsi    # 0x52ee18
callq 0xf1420
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x49aa22(%rip), %rsi    # 0x5172e4
callq 0xf1a10
movq 0x40(%rsp), %rdx
leaq 0x4f4d63(%rip), %rdi    # 0x571636
leaq 0x4b256d(%rip), %rsi    # 0x52ee47
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0xf2a40
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl 0x34(%rsp), %edx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r9
leaq 0xa9e0b(%rip), %r8      # 0x126730
callq 0xf2ab0
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
callq 0xf5cf0
movl 0xc(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_uniq.c
// Function: gt_uniq_arguments_delete
static void gt_uniq_arguments_delete(void *tool_arguments)
{
  UniqArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x7c9dd
jmp 0x7ca0f
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rdi
leaq 0x4b245a(%rip), %rsi    # 0x52ee5f
movl $0x31, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_uniq.c
// Function: gt_uniq_option_parser_new
static GtOptionParser* gt_uniq_option_parser_new(void *tool_arguments)
{
  UniqArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] [GFF3_file]", "Filter out repeated "
                            "feature node graphs in a sorted GFF3 file.");

  /* -v */
  option = gt_option_new_verbose(&arguments->verbose);
  gt_option_parser_add_option(op, option);

  /* output file options */
  gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);

  gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);
  gt_option_parser_set_max_args(op, 1);

  return op;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x7ca73
movq 0x5bf55e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4995c7(%rip), %rsi    # 0x516013
leaq 0x4fe10c(%rip), %rdx    # 0x57ab5f
leaq 0x4b2419(%rip), %rcx    # 0x52ee73
leaq 0x4b23fe(%rip), %r8     # 0x52ee5f
movl $0x39, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x7ca75
leaq 0x49a62c(%rip), %rdi    # 0x5170a8
leaq 0x4b240a(%rip), %rsi    # 0x52ee8d
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xf5f90
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x10, %rdx
callq 0xf7d50
movq 0x10(%rsp), %rdi
leaq 0x10520d(%rip), %rsi    # 0x181ce0
xorl %eax, %eax
movl %eax, %edx
callq 0xf1770
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xf29e0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_uniq.c
// Function: gt_uniq_runner
static int gt_uniq_runner(GT_UNUSED int argc, const char **argv,
                          int parsed_args, void *tool_arguments, GtError *err)
{
  UniqArguments *arguments = tool_arguments;
  GtNodeStream *gff3_in_stream,
               *uniq_stream = NULL,
               *gff3_out_stream = NULL;
  int had_err;

  gt_error_check(err);
  gt_assert(arguments);

  /* create gff3 input stream */
  gff3_in_stream = gt_gff3_in_stream_new_sorted(argv[parsed_args]);
  if (arguments->verbose && arguments->outfp)
    gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) gff3_in_stream);

  /* create uniq stream */
  uniq_stream = gt_uniq_stream_new(gff3_in_stream);

  /* create gff3 output stream */
  gff3_out_stream = gt_gff3_out_stream_new(uniq_stream, arguments->outfp);

  /* pull the features through the stream and free them afterwards */
  had_err = gt_node_stream_pull(gff3_out_stream, err);

  /* free */
  gt_node_stream_delete(gff3_out_stream);
  gt_node_stream_delete(uniq_stream);
  gt_node_stream_delete(gff3_in_stream);

  return had_err;
}

// Assembly:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x7cb87
movq 0x30(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x7cb4f
jmp 0x7cb87
movq 0x5bf44a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4994b3(%rip), %rsi    # 0x516013
leaq 0x499658(%rip), %rdx    # 0x5161bf
leaq 0x4b235e(%rip), %rcx    # 0x52eecc
leaq 0x4b22ea(%rip), %r8     # 0x52ee5f
movl $0x55, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x7cb89
jmp 0x7cb8b
cmpq $0x0, 0x28(%rsp)
jne 0x7cbcb
movq 0x5bf406(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x49946f(%rip), %rsi    # 0x516013
leaq 0x4fdfb4(%rip), %rdx    # 0x57ab5f
leaq 0x4b231a(%rip), %rcx    # 0x52eecc
leaq 0x4b22a6(%rip), %r8     # 0x52ee5f
movl $0x56, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x7cbcd
movq 0x48(%rsp), %rax
movslq 0x44(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1747b0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
testb $0x1, (%rax)
je 0x7cc05
movq 0x28(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x7cc05
movq 0x20(%rsp), %rdi
callq 0x1741e0
movq 0x20(%rsp), %rdi
callq 0x1f6670
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x176d50
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1b1f90
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1b1cb0
movq 0x18(%rsp), %rdi
callq 0x1b1cb0
movq 0x20(%rsp), %rdi
callq 0x1b1cb0
movl 0xc(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_wtree.c
// Function: gt_wtree_option_parser_new
static GtOptionParser* gt_wtree_option_parser_new(void *tool_arguments)
{
  GtToolbox *wtree_toolbox = tool_arguments;
  GtOptionParser *op;
  gt_assert(wtree_toolbox);
  op = gt_option_parser_new("[option ...] tool [argument ...]",
                            "Call an wtree manipulation tool "
                            "and pass argument(s) to it.");
  gt_option_parser_set_comment_func(op, gt_toolbox_show, wtree_toolbox);
  gt_option_parser_set_min_args(op, 1U);
  return op;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x7cd63
movq 0x5bf26e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4992d7(%rip), %rsi    # 0x516013
leaq 0x4b2198(%rip), %rdx    # 0x52eedb
leaq 0x4b219f(%rip), %rcx    # 0x52eee9
leaq 0x4b21b3(%rip), %r8     # 0x52ef04
movl $0x2d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x7cd65
leaq 0x49ad9e(%rip), %rdi    # 0x517b0a
leaq 0x4b21a6(%rip), %rsi    # 0x52ef19
callq 0xf1420
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0xa6c14(%rip), %rsi     # 0x1239a0
callq 0xf1770
movq (%rsp), %rdi
movl $0x1, %esi
callq 0xf2980
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_wtree_bench.c
// Function: gt_wtree_bench_arguments_delete
static void gt_wtree_bench_arguments_delete(void *tool_arguments)
{
  GtWaveletBenchArguments *arguments = tool_arguments;
  if (arguments != NULL) {
    gt_str_delete(arguments->safe);
    gt_free(arguments);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x7d04e
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4b1f5e(%rip), %rsi    # 0x52efa2
movl $0x2e, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_wtree_bench.c
// Function: gt_wtree_bench_option_parser_new
static GtOptionParser* gt_wtree_bench_option_parser_new(void *tool_arguments)
{
  GtWaveletBenchArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] encoded_sequence",
                            "Testing and benchmarking for wtree.");

  /* -safe */
  option = gt_option_new_string("safe", "safe files to disk, currently not "
                                "implemented",
                                arguments->safe, NULL);
  gt_option_parser_add_option(op, option);

  return op;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x7d0b3
movq 0x5bef1e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x498f87(%rip), %rsi    # 0x516013
leaq 0x4fdacc(%rip), %rdx    # 0x57ab5f
leaq 0x4b1f23(%rip), %rcx    # 0x52efbd
leaq 0x4b1f01(%rip), %r8     # 0x52efa2
movl $0x37, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x7d0b5
leaq 0x4b1f22(%rip), %rdi    # 0x52efde
leaq 0x4b1f39(%rip), %rsi    # 0x52effc
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdx
leaq 0x51c39a(%rip), %rdi    # 0x599476
leaq 0x4b1f3d(%rip), %rsi    # 0x52f020
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_wtree_bench.c
// Function: gt_wtree_bench_arguments_check
static int gt_wtree_bench_arguments_check(int rest_argc,
                                          void *tool_arguments,
                                          GtError *err)
{
  GtWaveletBenchArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  if (rest_argc == 0) {
    gt_error_set(err, "no encseq basename given");
    had_err = 1;
  }
  else if (rest_argc > 1) {
    gt_error_set(err, "give only one encseq basename");
    had_err = 1;
  }
  if (!had_err && gt_str_length(arguments->safe))
    printf("%s\n", gt_str_get(arguments->safe));

  return had_err;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x7d184
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x7d14c
jmp 0x7d184
movq 0x5bee4d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x498eb6(%rip), %rsi    # 0x516013
leaq 0x49905b(%rip), %rdx    # 0x5161bf
leaq 0x4b1ee3(%rip), %rcx    # 0x52f04e
leaq 0x4b1e30(%rip), %r8     # 0x52efa2
movl $0x4c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x7d186
jmp 0x7d188
cmpq $0x0, 0x8(%rsp)
jne 0x7d1c8
movq 0x5bee09(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x498e72(%rip), %rsi    # 0x516013
leaq 0x4fd9b7(%rip), %rdx    # 0x57ab5f
leaq 0x4b1e9f(%rip), %rcx    # 0x52f04e
leaq 0x4b1dec(%rip), %r8     # 0x52efa2
movl $0x4d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x7d1ca
cmpl $0x0, 0x24(%rsp)
jne 0x7d1ee
movq 0x10(%rsp), %rdi
leaq 0x4b1e90(%rip), %rsi    # 0x52f06d
movb $0x0, %al
callq 0xd88c0
movl $0x1, 0x4(%rsp)
jmp 0x7d212
cmpl $0x1, 0x24(%rsp)
jle 0x7d210
movq 0x10(%rsp), %rdi
leaq 0x4b1e85(%rip), %rsi    # 0x52f086
movb $0x0, %al
callq 0xd88c0
movl $0x1, 0x4(%rsp)
jmp 0x7d212
cmpl $0x0, 0x4(%rsp)
jne 0x7d24a
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11dfa0
cmpq $0x0, %rax
je 0x7d24a
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11dee0
movq %rax, %rsi
leaq 0x4a9ca9(%rip), %rdi    # 0x526eec
movb $0x0, %al
callq 0x19070
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_wtree_bench.c
// Function: gt_wtree_bench_bench_encseq
static int gt_wtree_bench_bench_encseq(GtEncseq *es, GtTimer *t,
                                       GT_UNUSED GtError *err)
{
  int had_err = 0;
  GtUword idx, length, pos;
  gt_error_check(err);
  length = gt_encseq_total_length(es);
  gt_timer_start(t);
  for (idx = 0; idx < WAVELET_BENCH_SIZE; idx++) {
    pos = gt_rand_max(length - 1);
    if (gt_encseq_position_is_separator(es, pos, GT_READMODE_FORWARD)) {
      printf("$");
    }
    else {
      printf("%c", gt_encseq_get_decoded_char(es, pos, GT_READMODE_FORWARD));
    }
  }
  printf("\n");
  gt_timer_show_progress_final(t, stderr);
  gt_timer_stop(t);
  return had_err;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x7d49b
movq 0x20(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x7d463
jmp 0x7d49b
movq 0x5beb36(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x498b9f(%rip), %rsi    # 0x516013
leaq 0x498d44(%rip), %rdx    # 0x5161bf
leaq 0x4b1c5c(%rip), %rcx    # 0x52f0de
leaq 0x4b1b19(%rip), %r8     # 0x52efa2
movl $0x62, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x7d49d
movq 0x30(%rsp), %rdi
callq 0xa9d00
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1213f0
movq $0x0, 0x10(%rsp)
cmpq $0xf4240, 0x10(%rsp)    # imm = 0xF4240
jae 0x7d535
movq 0x8(%rsp), %rdi
subq $0x1, %rdi
callq 0xec350
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq 0xaaca0
testb $0x1, %al
jne 0x7d4f2
jmp 0x7d502
leaq 0x4c1930(%rip), %rdi    # 0x53ee29
movb $0x0, %al
callq 0x19070
jmp 0x7d523
movq 0x30(%rsp), %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq 0xaa4b0
movsbl %al, %esi
leaq 0x4e47b0(%rip), %rdi    # 0x561ccc
movb $0x0, %al
callq 0x19070
jmp 0x7d525
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x7d4bf
leaq 0x515d37(%rip), %rdi    # 0x593273
movb $0x0, %al
callq 0x19070
movq 0x28(%rsp), %rdi
movq 0x5bea51(%rip), %rax    # 0x63bfa0
movq (%rax), %rsi
callq 0x121d70
movq 0x28(%rsp), %rdi
callq 0x121490
movl 0x1c(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/array2dim.c
// Function: gt_array2dim_example
int gt_array2dim_example(GT_UNUSED GtError *err)
{
  double **a2dim;
  int i, j;
  gt_error_check(err);

  /* create a 10 x 20 double array */
  gt_array2dim_malloc(a2dim, 10, 20);

  /* ... (use array a2dim in conventional way via a2dim[row][column]) */
  for (i = 1; i < 10; i++) {
    for (j = 1; j < 20; j++)
      a2dim[i][j] = i + j;
  }

  /* free */
  gt_array2dim_delete(a2dim);

  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x83719
movq 0x20(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x836e1
jmp 0x83719
movq 0x5b88b8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x492921(%rip), %rsi    # 0x516013
leaq 0x492ac6(%rip), %rdx    # 0x5161bf
leaq 0x4acab2(%rip), %rcx    # 0x5301b2
leaq 0x4acac0(%rip), %r8     # 0x5301c7
movl $0x1a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x8371b
movl $0x50, %edi
leaq 0x4acaa0(%rip), %rsi    # 0x5301c7
movl $0x1d, %edx
callq 0xe80f0
movq %rax, 0x18(%rsp)
movl $0x640, %edi            # imm = 0x640
leaq 0x4aca85(%rip), %rsi    # 0x5301c7
movl $0x1d, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq $0x1, 0x8(%rsp)
cmpq $0xa, 0x8(%rsp)
jae 0x8379f
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
addq $0xa0, %rdx
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x83760
movl $0x1, 0x14(%rsp)
cmpl $0xa, 0x14(%rsp)
jge 0x837fd
movl $0x1, 0x10(%rsp)
cmpl $0x14, 0x10(%rsp)
jge 0x837ee
movl 0x14(%rsp), %eax
addl 0x10(%rsp), %eax
cvtsi2sd %eax, %xmm0
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x10(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x837b6
jmp 0x837f0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x837a7
movq 0x18(%rsp), %rax
movq (%rax), %rdi
leaq 0x4ac9bb(%rip), %rsi    # 0x5301c7
movl $0x26, %edx
callq 0xe88c0
movq 0x18(%rsp), %rdi
leaq 0x4ac9a5(%rip), %rsi    # 0x5301c7
movl $0x26, %edx
callq 0xe88c0
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bioseq_iterator.c
// Function: gt_bioseq_iterator_new
GtBioseqIterator* gt_bioseq_iterator_new(int seqfile_counter,
                                         const char **sequence_files)
{
  GtBioseqIterator *bsi;
  gt_assert(sequence_files);
  bsi = gt_calloc(1, sizeof *bsi);
  bsi->seqfile_counter = seqfile_counter ? seqfile_counter : 1 /* for stdin */;
  bsi->sequence_files = gt_cstr_array_dup(sequence_files);
  return bsi;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x886dd
movq 0x5b38f4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x48d95d(%rip), %rsi    # 0x516013
leaq 0x4941d4(%rip), %rdx    # 0x51c891
leaq 0x4a86d6(%rip), %rcx    # 0x530d9a
leaq 0x4a86e6(%rip), %r8     # 0x530db1
movl $0x22, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x886df
movl $0x1, %edi
movl $0x18, %esi
leaq 0x4a86c1(%rip), %rdx    # 0x530db1
movl $0x23, %ecx
callq 0xe83c0
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x88710
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x8871b
movl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x8871b
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x18(%rsp), %rdi
callq 0xa3480
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bitbuffer.c
// Function: gt_bitbuffer_FILE_new
GtBitbuffer *gt_bitbuffer_FILE_new(FILE *outfp,GtBitcount_type bitsperentry)
{
  GtBitbuffer *bb = gt_malloc(sizeof *bb);

  if (outfp != NULL)
  {
     bb->bitsinbuffer = (GtBitcount_type) sizeof bb->currentbitbuffer;
  } else
  {
     gt_assert(bitsperentry == 0);
     bb->bitsinbuffer = (GtBitcount_type) CHAR_BIT;
  }
  if (bitsperentry > 0)
  {
    uint8_t bitsperentry8 = (uint8_t) bitsperentry;
    uint64_t writtenbits = 0;

    gt_assert(outfp != NULL);
    (void) fwrite(&writtenbits,sizeof writtenbits,(size_t) 1,outfp);
    (void) fwrite(&bitsperentry8,sizeof bitsperentry8,(size_t) 1,outfp);
  }
  bb->numberofallvalues = 0;
  bb->bitsperentry = bitsperentry;
  bb->currentbitbuffer = 0;
  bb->remainingbitsinbuffer = bb->bitsinbuffer;
  bb->currentuint8 = 0;
  bb->fp = outfp;
  return bb;
}

// Assembly:
subq $0x28, %rsp
movw %si, %ax
movq %rdi, 0x20(%rsp)
movw %ax, 0x1e(%rsp)
movl $0x20, %edi
leaq 0x4a8481(%rip), %rsi    # 0x530e1e
movl $0x26, %edx
callq 0xe80f0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x889c1
movq 0x10(%rsp), %rax
movw $0x8, 0x14(%rax)
jmp 0x88a12
jmp 0x889c3
movzwl 0x1e(%rsp), %eax
cmpl $0x0, %eax
je 0x88a05
movq 0x5b35cc(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x48d635(%rip), %rsi    # 0x516013
leaq 0x4a21cf(%rip), %rdx    # 0x52abb4
leaq 0x4a8447(%rip), %rcx    # 0x530e33
leaq 0x4a842b(%rip), %r8     # 0x530e1e
movl $0x2d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x88a07
movq 0x10(%rsp), %rax
movw $0x8, 0x14(%rax)
movzwl 0x1e(%rsp), %eax
cmpl $0x0, %eax
jle 0x88aa1
movw 0x1e(%rsp), %ax
movb %al, 0xf(%rsp)
movq $0x0, (%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x88a71
movq 0x5b3560(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x48d5c9(%rip), %rsi    # 0x516013
leaq 0x4a83f8(%rip), %rdx    # 0x530e49
leaq 0x4a83db(%rip), %rcx    # 0x530e33
leaq 0x4a83bf(%rip), %r8     # 0x530e1e
movl $0x35, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x88a73
movq 0x20(%rsp), %rcx
movq %rsp, %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x19ea0
movq 0x20(%rsp), %rcx
leaq 0xf(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x19ea0
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movw 0x1e(%rsp), %cx
movq 0x10(%rsp), %rax
movw %cx, 0x12(%rax)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movw 0x14(%rax), %cx
movq 0x10(%rsp), %rax
movw %cx, 0x10(%rax)
movq 0x10(%rsp), %rax
movb $0x0, 0x17(%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bitbuffer.c
// Function: gt_bitbuffer_write_bytestring_bf
GtUword gt_bitbuffer_write_bytestring_bf(GtBitbuffer *bb,
                                          uint8_t *bytestring,
                                          GtUword bytestring_offset,
                                          GT_UNUSED GtUword bytestring_length,
                                          GtUword value,
                                          GtBitcount_type bitsforvalue)
{
  int shift;

  gt_assert(bitsforvalue > 0);
  for (shift = (int) (bitsforvalue-1); shift >= 0; shift--)
  {
    if (bb->remainingbitsinbuffer == 0)
    {
      gt_assert(bytestring_offset < bytestring_length);
      bytestring[bytestring_offset++] = bb->currentuint8;
      bb->currentuint8 = 0;
      bb->remainingbitsinbuffer = bb->bitsinbuffer;
    }
    if (value & (1UL << shift))
    {
      bb->currentuint8 |= (1 << (bb->remainingbitsinbuffer-1));
    }
    bb->remainingbitsinbuffer--;
  }
  return bytestring_offset;
}

// Assembly:
subq $0x38, %rsp
movw %r9w, %ax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movw %ax, 0xe(%rsp)
movzwl 0xe(%rsp), %eax
cmpl $0x0, %eax
jg 0x89028
movq 0x5b2fa9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x48d012(%rip), %rsi    # 0x516013
leaq 0x4a7f5a(%rip), %rdx    # 0x530f62
leaq 0x4a7f64(%rip), %rcx    # 0x530f73
leaq 0x4a7e08(%rip), %r8     # 0x530e1e
movl $0xa5, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x8902a
movzwl 0xe(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jl 0x89136
movq 0x30(%rsp), %rax
movzwl 0x10(%rax), %eax
cmpl $0x0, %eax
jne 0x890d7
jmp 0x89055
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jb 0x89099
movq 0x5b2f38(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x48cfa1(%rip), %rsi    # 0x516013
leaq 0x4a7f1b(%rip), %rdx    # 0x530f94
leaq 0x4a7ef3(%rip), %rcx    # 0x530f73
leaq 0x4a7d97(%rip), %r8     # 0x530e1e
movl $0xaa, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x8909b
movq 0x30(%rsp), %rax
movb 0x17(%rax), %dl
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x20(%rsp)
movb %dl, (%rax,%rcx)
movq 0x30(%rsp), %rax
movb $0x0, 0x17(%rax)
movq 0x30(%rsp), %rax
movw 0x14(%rax), %cx
movq 0x30(%rsp), %rax
movw %cx, 0x10(%rax)
movq 0x10(%rsp), %rax
movl 0x8(%rsp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x89115
movq 0x30(%rsp), %rax
movzwl 0x10(%rax), %ecx
subl $0x1, %ecx
movl $0x1, %edx
shll %cl, %edx
movq 0x30(%rsp), %rax
movzbl 0x17(%rax), %ecx
orl %edx, %ecx
movb %cl, 0x17(%rax)
movq 0x30(%rsp), %rax
movw 0x10(%rax), %cx
addw $-0x1, %cx
movw %cx, 0x10(%rax)
movl 0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x89036
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bitbuffer.c
// Function: gt_bitbuffer_write_uint32tab_FILE
void gt_bitbuffer_write_uint32tab_FILE(GtBitbuffer *bb,const uint32_t *tab,
                                       GtUword len)
{
  const uint32_t *uintptr;

  gt_assert (bb != NULL && tab != NULL);
  for (uintptr = tab; uintptr < tab + len; uintptr++)
  {
    gt_bitbuffer_write_fixed_bits_FILE (bb, (GtUword) *uintptr);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x89263
cmpq $0x0, 0x18(%rsp)
jne 0x8929b
movq 0x5b2d36(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x48cd9f(%rip), %rsi    # 0x516013
leaq 0x4a7da8(%rip), %rdx    # 0x531023
leaq 0x4a7dbb(%rip), %rcx    # 0x53103d
leaq 0x4a7b95(%rip), %r8     # 0x530e1e
movl $0xca, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x8929d
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x892e5
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x891c0
movq 0x8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x8(%rsp)
jmp 0x892a7
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bitbuffer.c
// Function: gt_bitbuffer_write_ulongtab_FILE
void gt_bitbuffer_write_ulongtab_FILE(GtBitbuffer *bb,
                                      const GtUword *tab,
                                      GtUword len)
{
  const GtUword *ulongptr;

  gt_assert (bb != NULL && tab != NULL);
  for (ulongptr = tab; ulongptr < tab + len; ulongptr++)
  {
    gt_bitbuffer_write_fixed_bits_FILE(bb, *ulongptr);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x89313
cmpq $0x0, 0x18(%rsp)
jne 0x8934b
movq 0x5b2c86(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x48ccef(%rip), %rsi    # 0x516013
leaq 0x4a7cf8(%rip), %rdx    # 0x531023
leaq 0x4a7d2d(%rip), %rcx    # 0x53105f
leaq 0x4a7ae5(%rip), %r8     # 0x530e1e
movl $0xd7, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x8934d
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x89394
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x891c0
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
jmp 0x89357
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bitbuffer.c
// Function: gt_bitbuffer_delete
void gt_bitbuffer_delete(GtBitbuffer *bb)
{
  if (bb != NULL)
  {
    if (bb->fp != NULL)
    {
      gt_bitbuffer_flush(false,bb,NULL);
    }
    gt_free(bb);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x895db
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x895c6
movq (%rsp), %rsi
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x893a0
movq (%rsp), %rdi
leaq 0x4a784d(%rip), %rsi    # 0x530e1e
movl $0x108, %edx            # imm = 0x108
callq 0xe88c0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bitbuffer.c
// Function: gt_bitbuffer_read_bytestring_bf
GtUword gt_bitbuffer_read_bytestring_bf(GtBitbuffer *bb,
                                         GtUword *value,
                                         const uint8_t *bytestring,
                                         GtUword bytestring_offset,
                                         GtBitcount_type bitsforvalue)
{
  int shift;

  gt_assert(bb != NULL && bb->fp == NULL && bytestring != NULL);
  gt_assert(bitsforvalue > 0);
  for (shift = (int) (bitsforvalue - 1); shift >= 0; shift--)
  {
    if (bb->remainingbitsinbuffer == 0)
    {
      bb->readvalue = bytestring[bytestring_offset++];
      bb->remainingbitsinbuffer = bb->bitsinbuffer;
    }
    bb->remainingbitsinbuffer--;
    if (bb->readvalue & (1 << bb->remainingbitsinbuffer))
    {
      bb->currentbitbuffer |= (((uint64_t) 1) << shift);
    }
  }
  *value = (GtUword) bb->currentbitbuffer;
  bb->currentbitbuffer = 0;
  return bytestring_offset;
}

// Assembly:
subq $0x28, %rsp
movw %r8w, %ax
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movw %ax, 0x6(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x898bd
movq 0x20(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x898bd
cmpq $0x0, 0x10(%rsp)
jne 0x898f5
movq 0x5b26dc(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x48c745(%rip), %rsi    # 0x516013
leaq 0x4a7830(%rip), %rdx    # 0x531105
leaq 0x4a78a6(%rip), %rcx    # 0x531182
leaq 0x4a753b(%rip), %r8     # 0x530e1e
movl $0x147, %r9d            # imm = 0x147
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x898f7
jmp 0x898f9
movzwl 0x6(%rsp), %eax
cmpl $0x0, %eax
jg 0x8993b
movq 0x5b2696(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x48c6ff(%rip), %rsi    # 0x516013
leaq 0x4a7647(%rip), %rdx    # 0x530f62
leaq 0x4a7860(%rip), %rcx    # 0x531182
leaq 0x4a74f5(%rip), %r8     # 0x530e1e
movl $0x148, %r9d            # imm = 0x148
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x8993d
movzwl 0x6(%rsp), %eax
subl $0x1, %eax
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
jl 0x899f1
movq 0x20(%rsp), %rax
movzwl 0x10(%rax), %eax
cmpl $0x0, %eax
jne 0x89993
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movb (%rax,%rcx), %cl
movq 0x20(%rsp), %rax
movb %cl, 0x16(%rax)
movq 0x20(%rsp), %rax
movw 0x14(%rax), %cx
movq 0x20(%rsp), %rax
movw %cx, 0x10(%rax)
movq 0x20(%rsp), %rax
movw 0x10(%rax), %cx
addw $-0x1, %cx
movw %cx, 0x10(%rax)
movq 0x20(%rsp), %rax
movzbl 0x16(%rax), %eax
movq 0x20(%rsp), %rcx
movzwl 0x10(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x899e1
movl (%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movq 0x20(%rsp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x899e3
movl (%rsp), %eax
addl $-0x1, %eax
movl %eax, (%rsp)
jmp 0x89948
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bitpackarray.h
// Function: bitpackarray_store_uint64
static inline void
bitpackarray_store_uint64(BitPackArray *array, BitOffset index, uint64_t val)
{
  gt_assert(array && index < array->numElems
            && array->bitsPerElem <= sizeof (val)*CHAR_BIT);
  gt_bsStoreUInt64(array->store, array->bitsPerElem * index,
                   array->bitsPerElem, val);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x8e698
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x8e698
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
cmpq $0x40, %rax
jbe 0x8e6d0
movq 0x5ad901(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x48796a(%rip), %rsi    # 0x516013
leaq 0x4a3820(%rip), %rdx    # 0x531ed0
leaq 0x4a38f0(%rip), %rcx    # 0x531fa7
leaq 0x4a37ba(%rip), %r8     # 0x531e78
movl $0x8e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x8e6d2
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, %esi
imulq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movl 0x10(%rax), %edx
movq (%rsp), %rcx
callq 0x4770f0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bitpackarray.h
// Function: bitpackarray_get_uint64
static inline uint64_t
bitpackarray_get_uint64(const BitPackArray *array, BitOffset index)
{
  gt_assert(array && index < array->numElems
            && array->bitsPerElem <= sizeof (uint64_t)*CHAR_BIT);
  return gt_bsGetUInt64(array->store, array->bitsPerElem * index,
                        array->bitsPerElem);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x8e734
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x8e734
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
cmpq $0x40, %rax
jbe 0x8e76c
movq 0x5ad865(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4878ce(%rip), %rsi    # 0x516013
leaq 0x4a3875(%rip), %rdx    # 0x531fc1
leaq 0x4a38c3(%rip), %rcx    # 0x532016
leaq 0x4a371e(%rip), %r8     # 0x531e78
movl $0x9e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x8e76e
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, %esi
imulq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movl 0x10(%rax), %edx
callq 0x476ec0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/checkbitpackstring.c
// Function: gt_bitPackString_unit_test
int
gt_bitPackString_unit_test(GtError *err)
{
  return gt_bitPackStringInt_unit_test(err)
    || gt_bitPackStringInt8_unit_test(err)
    || gt_bitPackStringInt16_unit_test(err)
    || gt_bitPackStringInt32_unit_test(err)
    || gt_bitPackStringInt64_unit_test(err);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x47d060
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
jne 0x8e879
movq 0x10(%rsp), %rdi
callq 0x9af90
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
jne 0x8e879
movq 0x10(%rsp), %rdi
callq 0x8e890
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
jne 0x8e879
movq 0x10(%rsp), %rdi
callq 0x92b60
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
jne 0x8e879
movq 0x10(%rsp), %rdi
callq 0x96c60
cmpl $0x0, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bitpackstringsimpleop.h
// Function: gt_bsGetBit
static inline int
gt_bsGetBit(constBitString str, BitOffset pos)
{
  unsigned bitTop = pos%bitElemBits;
  const BitElem *p = str + pos/bitElemBits;
  gt_assert(str);
  return (*p & 1 << (bitElemBits - bitTop - 1))?1:0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
andq $0x7, %rax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
shrq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x92571
movq 0x5a9a60(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x483ac9(%rip), %rsi    # 0x516013
leaq 0x4b1b0c(%rip), %rdx    # 0x54405d
leaq 0x4a019d(%rip), %rcx    # 0x5326f5
leaq 0x4a01a2(%rip), %r8     # 0x532701
movl $0x18c, %r9d            # imm = 0x18C
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x92573
movq 0x8(%rsp), %rax
movzbl (%rax), %edx
movl $0x8, %ecx
subl 0x14(%rsp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
andl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bitpackstringsimpleop.h
// Function: bsSetBit
static inline void
bsSetBit(BitString str, BitOffset pos)
{
  unsigned bitTop = pos%bitElemBits;
  BitElem *p = str + pos/bitElemBits;
  gt_assert(str);
  *p |= 1 << (bitElemBits - bitTop - 1);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
andq $0x7, %rax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
shrq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x92621
movq 0x5a99b0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x483a19(%rip), %rsi    # 0x516013
leaq 0x4b1a5c(%rip), %rdx    # 0x54405d
leaq 0x4a015a(%rip), %rcx    # 0x532762
leaq 0x4a00f2(%rip), %r8     # 0x532701
movl $0x171, %r9d            # imm = 0x171
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x92623
movl $0x8, %ecx
subl 0x14(%rsp), %ecx
subl $0x1, %ecx
movl $0x1, %edx
shll %cl, %edx
movq 0x8(%rsp), %rax
movzbl (%rax), %ecx
orl %edx, %ecx
movb %cl, (%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bitpackstringsimpleop.h
// Function: gt_bsClearBit
static inline void
gt_bsClearBit(BitString str, BitOffset pos)
{
  unsigned bitTop = pos%bitElemBits;
  BitElem *p = str + pos/bitElemBits;
  gt_assert(str);
  *p &= ~(1 << (bitElemBits - bitTop - 1));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
andq $0x7, %rax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
shrq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x926c1
movq 0x5a9910(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x483979(%rip), %rsi    # 0x516013
leaq 0x4b19bc(%rip), %rdx    # 0x54405d
leaq 0x4a00c3(%rip), %rcx    # 0x53276b
leaq 0x4a0052(%rip), %r8     # 0x532701
movl $0x17a, %r9d            # imm = 0x17A
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x926c3
movl $0x8, %ecx
subl 0x14(%rsp), %ecx
subl $0x1, %ecx
movl $0x1, %edx
shll %cl, %edx
xorl $-0x1, %edx
movq 0x8(%rsp), %rax
movzbl (%rax), %ecx
andl %edx, %ecx
movb %cl, (%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bitpackstringsimpleop.h
// Function: bsToggleBit
static inline void
bsToggleBit(BitString str, BitOffset pos)
{
  unsigned bitTop = pos%bitElemBits;
  BitElem *p = str + pos/bitElemBits;
  gt_assert(str);
  *p ^= 1 << (bitElemBits - bitTop - 1);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
andq $0x7, %rax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
shrq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x92761
movq 0x5a9870(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4838d9(%rip), %rsi    # 0x516013
leaq 0x4b191c(%rip), %rdx    # 0x54405d
leaq 0x4a0031(%rip), %rcx    # 0x532779
leaq 0x49ffb2(%rip), %r8     # 0x532701
movl $0x183, %r9d            # imm = 0x183
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x92763
movl $0x8, %ecx
subl 0x14(%rsp), %ecx
subl $0x1, %ecx
movl $0x1, %edx
shll %cl, %edx
movq 0x8(%rsp), %rax
movzbl (%rax), %ecx
xorl %edx, %ecx
movb %cl, (%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/checkbitpackstring16.c
// Function: icmp_uint16_t
static inline int
icmp_uint16_t(uint16_t a, uint16_t b)
{
  if (a > b)
    return 1;
  else if (a < b)
    return -1;
  else /* if (a == b) */
    return 0;
}

// Assembly:
movw %si, %ax
movw %di, %cx
movw %cx, -0x6(%rsp)
movw %ax, -0x8(%rsp)
movzwl -0x6(%rsp), %eax
movzwl -0x8(%rsp), %ecx
cmpl %ecx, %eax
jle 0x927b8
movl $0x1, -0x4(%rsp)
jmp 0x927d8
movzwl -0x6(%rsp), %eax
movzwl -0x8(%rsp), %ecx
cmpl %ecx, %eax
jge 0x927d0
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x927d8
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bitpackstringsimpleop.h
// Function: gt_bsGetUniformInt16Array
static inline void
gt_bsGetUniformInt16Array(constBitString str, BitOffset offset,
                          unsigned numBits, size_t numValues, int16_t val[])
{
  /* read blocksize many ints at once, for later sign expansion */
  int blockSize = 16 * gt_pagesize() / sizeof (val[0]);
  /* the factor (16) is completely arbitrary and needs some profiling */
  int16_t *blockPtr = val;
  size_t revIndex = numValues;
  BitOffset offsetTemp = offset;
  gt_assert(blockSize >= 0);
  while (revIndex > (size_t)blockSize)
  {
    gt_bsGetUniformUInt16Array(str, offsetTemp, numBits,
                               blockSize, (uint16_t *)blockPtr);
    bsSignExpandArray16(blockPtr, blockSize, numBits);
    blockPtr += blockSize;
    revIndex -= blockSize;
    offsetTemp += blockSize * numBits;
  }
  gt_bsGetUniformUInt16Array(str, offsetTemp, numBits,
                             revIndex, (uint16_t *)blockPtr);
  bsSignExpandArray16(blockPtr, revIndex, numBits);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
callq 0xa2640
shlq $0x4, %rax
shrq %rax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x0, 0x1c(%rsp)
jge 0x92998
movq 0x5a9639(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4836a2(%rip), %rsi    # 0x516013
leaq 0x49fe0d(%rip), %rdx    # 0x532785
leaq 0x49fe15(%rip), %rcx    # 0x532794
leaq 0x49fd7b(%rip), %r8     # 0x532701
movl $0x12b, %r9d            # imm = 0x12B
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x9299a
jmp 0x9299c
movq 0x8(%rsp), %rax
movslq 0x1c(%rsp), %rcx
cmpq %rcx, %rax
jbe 0x92a18
movq 0x40(%rsp), %rdi
movq (%rsp), %rsi
movl 0x34(%rsp), %edx
movslq 0x1c(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x471250
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
movl 0x34(%rsp), %edx
callq 0x92ae0
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movslq 0x1c(%rsp), %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
imull 0x34(%rsp), %eax
movl %eax, %eax
addq (%rsp), %rax
movq %rax, (%rsp)
jmp 0x9299c
movq 0x40(%rsp), %rdi
movq (%rsp), %rsi
movl 0x34(%rsp), %edx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x471250
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x34(%rsp), %edx
callq 0x92ae0
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/checkbitpackstring16.c
// Function: genBitCount_uint16_t
static inline int
genBitCount_uint16_t(uint16_t v)
{
  unsigned c; /* c accumulates the total bits set in v */
  for (c = 0; v; c++)
    v &= v - 1; /* clear the least significant bit set */
  return c;
}

// Assembly:
movw %di, %ax
movw %ax, -0x2(%rsp)
movl $0x0, -0x8(%rsp)
cmpw $0x0, -0x2(%rsp)
je 0x92ad9
movzwl -0x2(%rsp), %ecx
subl $0x1, %ecx
movzwl -0x2(%rsp), %eax
andl %ecx, %eax
movw %ax, -0x2(%rsp)
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x92ab0
movl -0x8(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bitpackstringsimpleop.h
// Function: bsSignExpandArray16
static inline void
bsSignExpandArray16(int16_t val[], size_t numValues, unsigned numBits)
{
  int16_t m = 1 << (numBits - 1);
  size_t i;
  for (i = 0; i < numValues; ++i)
    val[i] = (val[i] ^ m) - m;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movw %ax, -0x16(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x92b53
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movswl (%rax,%rcx,2), %eax
movswl -0x16(%rsp), %ecx
xorl %ecx, %eax
movswl -0x16(%rsp), %ecx
subl %ecx, %eax
movw %ax, %dx
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movw %dx, (%rax,%rcx,2)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x92b0a
retq
nopw %cs:(%rax,%rax)
nop