LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/csa_variable_strands.c
// Function: store_splice_form
static void store_splice_form(GtArray *spliced_alignments_in_form,
                              const void *set_of_sas,
                              GT_UNUSED GtUword number_of_sas,
                              size_t size_of_sa, void *data)
{
  StoreSpliceFormInfo *info = data;
  GtCSASpliceForm *splice_form;
  GtUword i, sa;
  gt_assert(info);
  gt_assert(spliced_alignments_in_form &&
         gt_array_size(spliced_alignments_in_form));
  sa = *(GtUword*) gt_array_get(spliced_alignments_in_form, 0);
  splice_form = gt_csa_splice_form_new((char*) set_of_sas + sa * size_of_sa,
                                    info->get_genomic_range, info->get_strand);
  for (i = 1; i < gt_array_size(spliced_alignments_in_form); i++) {
    sa = *(GtUword*) gt_array_get(spliced_alignments_in_form, i);
    gt_csa_splice_form_add_sa(splice_form,
                              (char*) set_of_sas + sa * size_of_sa);
  }
  gt_array_add(info->splice_forms, splice_form);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x15ac27
movq 0x593e2(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3466(%rip), %rsi      # 0x15e066
leaq 0xaefe(%rip), %rdx      # 0x165b05
leaq 0x34865(%rip), %rcx     # 0x18f473
leaq 0x3480d(%rip), %r8      # 0x18f422
movl $0x25, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15ac29
jmp 0x15ac2b
cmpq $0x0, 0x50(%rsp)
je 0x15ac43
movq 0x50(%rsp), %rdi
callq 0x76490
cmpq $0x0, %rax
jne 0x15ac7b
movq 0x5938e(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3412(%rip), %rsi      # 0x15e066
leaq 0x3482a(%rip), %rdx     # 0x18f485
leaq 0x34811(%rip), %rcx     # 0x18f473
leaq 0x347b9(%rip), %r8      # 0x18f422
movl $0x27, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15ac7d
movq 0x50(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x75c80
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x10(%rsp), %rax
imulq 0x38(%rsp), %rax
addq %rax, %rdi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x15a4d0
movq %rax, 0x20(%rsp)
movq $0x1, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x15ad30
movq 0x50(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x75c80
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x10(%rsp), %rax
imulq 0x38(%rsp), %rax
addq %rax, %rsi
callq 0x15a5e0
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x15accb
movq 0x28(%rsp), %rax
movq (%rax), %rdi
leaq 0x20(%rsp), %rsi
movl $0x8, %edx
callq 0x76220
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/consensus_sa.c
// Function: set_of_sas_is_sorted
static bool set_of_sas_is_sorted(const void *set_of_sas,
                                 GtUword number_of_sas,
                                 size_t size_of_sa, GtGetGenomicRangeFunc
                                 get_genomic_range)
{
  GtRange gt_range_a, gt_range_b;
  GtUword max_end;
  const char *sa;

  gt_assert(set_of_sas && number_of_sas && size_of_sa && get_genomic_range);

  /* get first range */
  gt_range_a = get_genomic_range(set_of_sas);
  max_end = gt_range_a.end;

  /* loop over the other ranges */
  for (sa = (char*) set_of_sas + size_of_sa;
       sa < (char*) set_of_sas + number_of_sas * size_of_sa;
       sa = sa + size_of_sa) {
    /* get second range */
    gt_range_b = get_genomic_range(sa);

    /* compare */
    if (!(gt_range_a.start <= gt_range_b.start)) return false;

    /* make the second range the first */
    gt_range_a = gt_range_b;
    if (gt_range_a.end > max_end)
      max_end = gt_range_a.end;
  }
  return true;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
cmpq $0x0, 0x68(%rsp)
je 0x15b278
cmpq $0x0, 0x60(%rsp)
je 0x15b278
cmpq $0x0, 0x58(%rsp)
je 0x15b278
cmpq $0x0, 0x50(%rsp)
jne 0x15b2b0
movq 0x58d59(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x2ddd(%rip), %rsi      # 0x15e066
leaq 0x3432d(%rip), %rdx     # 0x18f5bd
leaq 0x34365(%rip), %rcx     # 0x18f5fc
leaq 0x34287(%rip), %r8      # 0x18f525
movl $0x2f, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15b2b2
movq 0x50(%rsp), %rax
movq 0x68(%rsp), %rdi
callq *%rax
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rax
addq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x68(%rsp), %rcx
movq 0x60(%rsp), %rdx
imulq 0x58(%rsp), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x15b38d
movq 0x50(%rsp), %rax
movq 0x20(%rsp), %rdi
callq *%rax
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x30(%rsp), %rax
jbe 0x15b34d
movb $0x0, 0x77(%rsp)
jmp 0x15b392
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x28(%rsp), %rax
jbe 0x15b377
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x15b379
movq 0x20(%rsp), %rax
addq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x15b2f5
movb $0x1, 0x77(%rsp)
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/consensus_sa.c
// Function: compute_C
static void compute_C(GtBittab **C, const ConsensusSA *csa)
{
  GtUword sa, sa_1;
  gt_assert(csa);
  for (sa = 0; sa < csa->number_of_sas; sa++) {
    for (sa_1 = 0; sa_1 < csa->number_of_sas; sa_1++) {
      if (contains(csa, sa, sa_1))
        gt_bittab_set_bit(C[sa], sa_1);
    }
    gt_assert(gt_bittab_bit_is_set(C[sa], sa));
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x15bade
movq 0x5852b(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x25af(%rip), %rsi      # 0x15e066
leaq 0x326c3(%rip), %rdx     # 0x18e181
leaq 0x33bac(%rip), %rcx     # 0x18f671
leaq 0x33a59(%rip), %r8      # 0x18f525
movl $0x11d, %r9d            # imm = 0x11D
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15bae0
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x15bbc7
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x15bb5a
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x15c230
testb $0x1, %al
jne 0x15bb30
jmp 0x15bb48
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%rsp), %rsi
callq 0x78fe0
jmp 0x15bb4a
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x15bb06
jmp 0x15bb5c
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rsi
callq 0x79c60
testb $0x1, %al
jne 0x15bbb0
movq 0x58459(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x24dd(%rip), %rsi      # 0x15e066
leaq 0x33aeb(%rip), %rdx     # 0x18f67b
leaq 0x33ada(%rip), %rcx     # 0x18f671
leaq 0x33987(%rip), %r8      # 0x18f525
movl $0x123, %r9d            # imm = 0x123
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15bbb2
jmp 0x15bbb4
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x15bae9
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/consensus_sa.c
// Function: splice_form_is_valid
static bool splice_form_is_valid(GtBittab *SA_p, const ConsensusSA *csa)
{
  GtBittab *SA_p_complement; /* SA \ SA_p */
  GtUword sa, sa_prime;
  bool incompatible_found, valid = true;

  SA_p_complement = gt_bittab_new(csa->number_of_sas);
  gt_bittab_complement(SA_p_complement, SA_p);

  for (sa_prime  = gt_bittab_get_first_bitnum(SA_p_complement);
       sa_prime != gt_bittab_get_last_bitnum(SA_p_complement);
       sa_prime  = gt_bittab_get_next_bitnum(SA_p_complement, sa_prime)) {
    incompatible_found = false;
    for (sa  = gt_bittab_get_first_bitnum(SA_p);
         sa != gt_bittab_get_last_bitnum(SA_p);
         sa  = gt_bittab_get_next_bitnum(SA_p, sa)) {
      if (!compatible(csa, sa, sa_prime)) {
        incompatible_found = true;
        break;
      }
    }
    if (!incompatible_found) { valid = false; break; }
  }
  gt_bittab_delete(SA_p_complement);
  return valid;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb $0x1, 0x1e(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x78f00
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x79120
movq 0x30(%rsp), %rdi
callq 0x79ee0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x79fb0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x15c20e
movb $0x0, 0x1f(%rsp)
movq 0x40(%rsp), %rdi
callq 0x79ee0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x79fb0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x15c1e5
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x15c3e0
testb $0x1, %al
jne 0x15c1cd
movb $0x1, 0x1f(%rsp)
jmp 0x15c1e5
jmp 0x15c1cf
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x7a000
movq %rax, 0x28(%rsp)
jmp 0x15c18d
testb $0x1, 0x1f(%rsp)
jne 0x15c1f3
movb $0x0, 0x1e(%rsp)
jmp 0x15c20e
jmp 0x15c1f5
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7a000
movq %rax, 0x20(%rsp)
jmp 0x15c154
movq 0x30(%rsp), %rdi
callq 0x7a420
movb 0x1e(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/consensus_sa.c
// Function: contains
static bool contains(const ConsensusSA *csa,
                     GtUword sa_1, GtUword sa_2)
{
  GtRange range_sa_1, range_sa_2;
  gt_assert(csa);

  /* get ranges */
  range_sa_1 = extract_genomic_range(csa, sa_1);
  range_sa_2 = extract_genomic_range(csa, sa_2);

  if (gt_range_contains(&range_sa_1, &range_sa_2) &&
      compatible(csa, sa_1, sa_2)) {
    return true;
  }
  return false;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x15c283
movq 0x57d86(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1e0a(%rip), %rsi      # 0x15e066
leaq 0x31f1e(%rip), %rdx     # 0x18e181
leaq 0x13e31(%rip), %rcx     # 0x17009b
leaq 0x332b4(%rip), %r8      # 0x18f525
movl $0x10d, %r9d            # imm = 0x10D
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15c285
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x15c330
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x15c330
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x93ea0
testb $0x1, %al
jne 0x15c2f4
jmp 0x15c315
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x15c3e0
testb $0x1, %al
jne 0x15c30e
jmp 0x15c315
movb $0x1, 0x67(%rsp)
jmp 0x15c31a
movb $0x0, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/consensus_sa.c
// Function: extract_strand
static GtStrand extract_strand(const ConsensusSA *csa, GtUword sa)
{
  GtStrand strand;
  gt_assert(csa && csa->set_of_sas && sa < csa->number_of_sas);
  strand = csa->get_strand((char*) csa->set_of_sas + csa->size_of_sa * sa);
  /* XXX */
  gt_assert(strand == GT_STRAND_FORWARD || strand == GT_STRAND_REVERSE);
  return strand;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x15cb81
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x15cb81
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x15cbb9
movq 0x57450(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14d4(%rip), %rsi      # 0x15e066
leaq 0x32b02(%rip), %rdx     # 0x18f69b
leaq 0x32b85(%rip), %rcx     # 0x18f725
leaq 0x3297e(%rip), %r8      # 0x18f525
movl $0x51, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15cbbb
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rdi
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
imulq 0x8(%rsp), %rcx
addq %rcx, %rdi
callq *%rax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x15cc2a
cmpl $0x1, 0x4(%rsp)
je 0x15cc2a
movq 0x573df(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1463(%rip), %rsi      # 0x15e066
leaq 0x32b2a(%rip), %rdx     # 0x18f734
leaq 0x32b14(%rip), %rcx     # 0x18f725
leaq 0x3290d(%rip), %r8      # 0x18f525
movl $0x54, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15cc2c
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/consensus_sa.c
// Function: extract_exons
static void extract_exons(const ConsensusSA *csa, GtArray *exon_ranges,
                          GtUword sa)
{
  gt_assert(csa && exon_ranges && csa->set_of_sas && sa < csa->number_of_sas);
  csa->get_exons(exon_ranges, (char*) csa->set_of_sas + csa->size_of_sa * sa);
  gt_assert(gt_array_size(exon_ranges));
  gt_assert(gt_ranges_are_sorted_and_do_not_overlap(exon_ranges));
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x15cc7c
cmpq $0x0, 0x8(%rsp)
je 0x15cc7c
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x15cc7c
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x15ccb4
movq 0x57355(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x13d9(%rip), %rsi      # 0x15e066
leaq 0x32adb(%rip), %rdx     # 0x18f76f
leaq 0x32b15(%rip), %rcx     # 0x18f7b0
leaq 0x32883(%rip), %r8      # 0x18f525
movl $0x5b, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15ccb6
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rcx
movq (%rcx), %rsi
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
imulq (%rsp), %rcx
addq %rcx, %rsi
callq *%rax
movq 0x8(%rsp), %rdi
callq 0x76490
cmpq $0x0, %rax
jne 0x15cd27
movq 0x572e2(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1366(%rip), %rsi      # 0x15e066
leaq 0x315f4(%rip), %rdx     # 0x18e2fb
leaq 0x32aa2(%rip), %rcx     # 0x18f7b0
leaq 0x32810(%rip), %r8      # 0x18f525
movl $0x5d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15cd29
jmp 0x15cd2b
movq 0x8(%rsp), %rdi
callq 0x957e0
testb $0x1, %al
jne 0x15cd71
movq 0x57298(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x131c(%rip), %rsi      # 0x15e066
leaq 0x315c5(%rip), %rdx     # 0x18e316
leaq 0x32a58(%rip), %rcx     # 0x18f7b0
leaq 0x327c6(%rip), %r8      # 0x18f525
movl $0x5e, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15cd73
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/consensus_sa.c
// Function: has_acceptor_site
static bool has_acceptor_site(GT_UNUSED GtArray *gene, GtUword exon)
{
  gt_assert(exon < gt_array_size(gene));
  if (exon == 0)
    return false;
  return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x15cde7
movq 0x57222(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x12a6(%rip), %rsi      # 0x15e066
leaq 0x329f7(%rip), %rdx     # 0x18f7be
leaq 0x32a0b(%rip), %rcx     # 0x18f7d9
leaq 0x32750(%rip), %r8      # 0x18f525
movl $0x6b, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15cde9
cmpq $0x0, 0x10(%rsp)
jne 0x15cdf8
movb $0x0, 0x27(%rsp)
jmp 0x15cdfd
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/consensus_sa.c
// Function: has_donor_site
static bool has_donor_site(GtArray *gene, GtUword exon)
{
  gt_assert(exon < gt_array_size(gene));
  if (exon == gt_array_size(gene) - 1)
    return false;
  return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x15ce77
movq 0x57192(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1216(%rip), %rsi      # 0x15e066
leaq 0x32967(%rip), %rdx     # 0x18f7be
leaq 0x3298d(%rip), %rcx     # 0x18f7eb
leaq 0x326c0(%rip), %r8      # 0x18f525
movl $0x63, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15ce79
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x76490
movq %rax, %rcx
movq (%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x15cea3
movb $0x0, 0x27(%rsp)
jmp 0x15cea8
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/consensus_sa.c
// Function: compute_left_or_right
static void compute_left_or_right(GtBittab **left_or_right,
                                  const ConsensusSA *csa,
                                  bool (*cmp_func) (const ConsensusSA *csa,
                                                    GtUword sa_1,
                                                    GtUword sa_2))
{
  GtUword sa, sa_1;
  gt_assert(csa && left_or_right && *left_or_right);
  for (sa = 0; sa < csa->number_of_sas; sa++) {
    for (sa_1 = 0; sa_1 < csa->number_of_sas; sa_1++) {
      if (cmp_func(csa, sa, sa_1) && compatible(csa, sa, sa_1))
        gt_bittab_set_bit(left_or_right[sa], sa_1);
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x15ceee
cmpq $0x0, 0x20(%rsp)
je 0x15ceee
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x15cf26
movq 0x570e3(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1167(%rip), %rsi      # 0x15e066
leaq 0x32901(%rip), %rdx     # 0x18f807
leaq 0x32921(%rip), %rcx     # 0x18f82e
leaq 0x32611(%rip), %r8      # 0x18f525
movl $0x12e, %r9d            # imm = 0x12E
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15cf28
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x15cfcc
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x15cfb7
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
testb $0x1, %al
jne 0x15cf77
jmp 0x15cfa7
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x15c3e0
testb $0x1, %al
jne 0x15cf90
jmp 0x15cfa7
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rsp), %rsi
callq 0x78fe0
jmp 0x15cfa9
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x15cf4d
jmp 0x15cfb9
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x15cf31
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/consensus_sa.c
// Function: is_right_of
static bool is_right_of(const ConsensusSA *csa,
                        GtUword sa_1, GtUword sa_2)
{
  GtRange range_sa_1, range_sa_2;
  gt_assert(csa);
  range_sa_1 = extract_genomic_range(csa, sa_1);
  range_sa_2 = extract_genomic_range(csa, sa_2);
  if (range_sa_1.start  > range_sa_2.start && range_sa_1.end > range_sa_2.end)
    return true;
  return false;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x15d033
movq 0x56fd6(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x105a(%rip), %rsi      # 0x15e066
leaq 0x3116e(%rip), %rdx     # 0x18e181
leaq 0x3282a(%rip), %rcx     # 0x18f844
leaq 0x32504(%rip), %r8      # 0x18f525
movl $0x13b, %r9d            # imm = 0x13B
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15d035
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x15c330
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x15c330
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x28(%rsp), %rax
jbe 0x15d0ae
movq 0x40(%rsp), %rax
cmpq 0x30(%rsp), %rax
jbe 0x15d0ae
movb $0x1, 0x67(%rsp)
jmp 0x15d0b3
movb $0x0, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test-regidx.c
// Function: error
HTS_NORETURN HTS_FORMAT(HTS_PRINTF_FMT, 1, 2)
static void error(const char *format, ...)
{
    va_list ap;
    va_start(ap, format);
    vfprintf(stderr, format, ap);
    va_end(ap);
    exit(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x5f75
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)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x104019(%rip), %rax    # 0x109fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x4670
leaq -0x20(%rbp), %rax
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x45d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test-regidx.c
// Function: debug
static void debug(const char *format, ...)
{
    if ( verbose<2 ) return;
    va_list ap;
    va_start(ap, format);
    vfprintf(stderr, format, ap);
    va_end(ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x6025
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)
cmpl $0x2, 0x108cf1(%rip)    # 0x10ed44
jge 0x6057
jmp 0x6096
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x103f5e(%rip), %rax    # 0x109fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x4670
leaq -0x20(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test-regidx.c
// Function: usage
static void usage(void)
{
    fprintf(stderr, "Usage: test-regidx [OPTIONS]\n");
    fprintf(stderr, "Options:\n");
    fprintf(stderr, "   -h, --help          this help message\n");
    fprintf(stderr, "   -s, --seed <int>    random seed\n");
    fprintf(stderr, "   -v, --verbose       increase verbosity by giving multiple times\n");

    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x102745(%rip), %rax    # 0x109fe0
movq (%rax), %rdi
leaq 0xe3dd1(%rip), %rsi     # 0xeb676
movb $0x0, %al
callq 0x46e0
movq 0x10272d(%rip), %rax    # 0x109fe0
movq (%rax), %rdi
leaq 0xe3dd7(%rip), %rsi     # 0xeb694
movb $0x0, %al
callq 0x46e0
movq 0x102715(%rip), %rax    # 0x109fe0
movq (%rax), %rdi
leaq 0xe3dc9(%rip), %rsi     # 0xeb69e
movb $0x0, %al
callq 0x46e0
movq 0x1026fd(%rip), %rax    # 0x109fe0
movq (%rax), %rdi
leaq 0xe3ddb(%rip), %rsi     # 0xeb6c8
movb $0x0, %al
callq 0x46e0
movq 0x1026e5(%rip), %rax    # 0x109fe0
movq (%rax), %rdi
leaq 0xe3de7(%rip), %rsi     # 0xeb6ec
movb $0x0, %al
callq 0x46e0
movl $0x1, %edi
callq 0x45d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test-regidx.c
// Function: info
static void info(const char *format, ...)
{
    if ( verbose<1 ) return;
    va_list ap;
    va_start(ap, format);
    vfprintf(stderr, format, ap);
    va_end(ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x7955
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)
cmpl $0x1, 0x1073c1(%rip)    # 0x10ed44
jge 0x7987
jmp 0x79c6
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x10262e(%rip), %rax    # 0x109fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x4670
leaq -0x20(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/asm.c
// Function: asm_store_field
void asm_store_field(Address address, unsigned L, unsigned R, Cell cell)
{
    // assert(address < memory_size);
    if (VERBOSE) {
        char temp[16];
        unparse_cell(temp, cell, false);
        printf("%s(%u,%u): %s\n", address_to_string(address), L, R, temp);
    }
    memory_store(address, set_field(cell, make_field_spec(L, R), memory_fetch(address)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
leaq 0x108e4(%rip), %rax     # 0x13d00
cmpl $0x0, (%rax)
je 0x3453
leaq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3a30
movl -0x4(%rbp), %edi
callq 0x4670
movq %rax, %rsi
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
leaq -0x30(%rbp), %r8
leaq 0x8c0e(%rip), %rdi      # 0xc05a
movb $0x0, %al
callq 0x30f0
movl -0x4(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x36d0
movl %eax, -0x38(%rbp)
movl -0x4(%rbp), %edi
callq 0x8e80
movq -0x40(%rbp), %rdi
movl -0x38(%rbp), %esi
movq %rax, %rdx
callq 0x3790
movl -0x34(%rbp), %edi
movq %rax, %rsi
callq 0x8f40
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/asm.c
// Function: assemble
void assemble(Cell cell)
{
    if (VERBOSE) {
        char temp[16];
        unparse_cell(temp, cell, true);
        printf("%s: %s  %s\n", address_to_string(here), temp, current_line);
    }
    // if (here < memory_size)
    //	memory[here] = cell;
    // else
	//  error("Address out of range");
	memory_store(here, cell);
    ++here;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1084d(%rip), %rax     # 0x13d00
cmpl $0x0, (%rax)
je 0x34f1
leaq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x1, %edx
callq 0x3a30
movl 0xf274(%rip), %edi      # 0x12744
callq 0x4670
movq %rax, %rsi
leaq -0x20(%rbp), %rdx
leaq 0x8b86(%rip), %rdi      # 0xc069
leaq 0xf696(%rip), %rcx      # 0x12b80
movb $0x0, %al
callq 0x30f0
movl 0xf24d(%rip), %edi      # 0x12744
movq -0x8(%rbp), %rsi
callq 0x8f40
movl 0xf23e(%rip), %eax      # 0x12744
addl $0x1, %eax
movl %eax, 0xf235(%rip)      # 0x12744
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/cell.c
// Function: ulong_to_cell
Cell ulong_to_cell(unsigned long n)
{
    if (CELL_MAX < n) {
        warn("Value out of range: %lu", n);
        return CELL_MAX;
    } else
        return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
cmpq -0x10(%rbp), %rax
jae 0x35a3
movq -0x10(%rbp), %rsi
leaq 0x8b1c(%rip), %rdi      # 0xc0ae
movb $0x0, %al
callq 0x7590
movq $0x3fffffff, -0x8(%rbp) # imm = 0x3FFFFFFF
jmp 0x35ab
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/cell.c
// Function: field
Cell field(Byte F, Cell cell)
{
    if (bad_field[F])
        error("Bad field spec: %02o", F);
    if (F < 8)      /* if F is of the form (0:R), retain the sign of -cell- */
        return ((cell & mask[F]) >> shift[F]) | sign_bit(cell);
    else
        return (cell & mask[F]) >> shift[F];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xf115(%rip), %rax      # 0x12750
cmpl $0x0, (%rax,%rcx,4)
je 0x3652
movl -0xc(%rbp), %esi
leaq 0x8ad3(%rip), %rdi      # 0xc11e
movb $0x0, %al
callq 0x74b0
cmpl $0x8, -0xc(%rbp)
jae 0x3692
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
leaq 0xf1e8(%rip), %rcx      # 0x12850
andq (%rcx,%rdx,8), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
leaq 0xf3d8(%rip), %rcx      # 0x12a50
movl (%rcx,%rdx,4), %ecx
sarq %cl, %rax
movq -0x18(%rbp), %rcx
andq $0x40000000, %rcx       # imm = 0x40000000
orq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x36bc
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
leaq 0xf1ae(%rip), %rcx      # 0x12850
andq (%rcx,%rdx,8), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
leaq 0xf39e(%rip), %rcx      # 0x12a50
movl (%rcx,%rdx,4), %ecx
sarq %cl, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/cell.c
// Function: set_field
Cell set_field(Cell value, Byte F, Cell into)
{
    long m = mask[F];
    if (bad_field[F])
        error("Bad field spec: %02o", F);
    if (F < 8)      /* if F is of the form (0:R), use the sign of -value- */
        return (into & ~m & ~the_sign_bit) | ((value << shift[F]) & m) | sign_bit(value);
    else
        return (into & ~m) | ((value << shift[F]) & m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0xf0a1(%rip), %rax      # 0x12850
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0xef8d(%rip), %rax      # 0x12750
cmpl $0x0, (%rax,%rcx,4)
je 0x37da
movl -0x14(%rbp), %esi
leaq 0x894b(%rip), %rdi      # 0xc11e
movb $0x0, %al
callq 0x74b0
cmpl $0x8, -0x14(%rbp)
jae 0x3829
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
andq $-0x40000001, %rax      # imm = 0xBFFFFFFF
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movl %ecx, %esi
leaq 0xf24b(%rip), %rcx      # 0x12a50
movl (%rcx,%rsi,4), %ecx
shlq %cl, %rdx
movq %rdx, %rcx
andq -0x28(%rbp), %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rcx
andq $0x40000000, %rcx       # imm = 0x40000000
orq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x385c
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movl %ecx, %esi
leaq 0xf208(%rip), %rcx      # 0x12a50
movl (%rcx,%rsi,4), %ecx
shlq %cl, %rdx
movq %rdx, %rcx
andq -0x28(%rbp), %rcx
orq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/cell.c
// Function: precompute_field_data
void precompute_field_data(void)
{
    unsigned L, R;
    for (L = 0; L < 8; ++L)
        for (R = 0; R < 8; ++R) {
            unsigned F = 8 * L + R;
            bad_field[F] = R < L || 5 < R;
            if (bad_field[F])
                shift[F] = 0, mask[F] = 0;
            else {
                unsigned width = R - (L == 0 ? 1 : L) + 1;
                shift[F] = 6 * (5 - R);
                mask[F] = ((1L << (6 * width)) - 1) << shift[F];
            } 
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0x8, -0x4(%rbp)
jae 0x39ab
movl $0x0, -0x8(%rbp)
cmpl $0x8, -0x8(%rbp)
jae 0x399b
movl -0x4(%rbp), %eax
shll $0x3, %eax
addl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %ecx
movb $0x1, %al
cmpl -0x4(%rbp), %ecx
movb %al, -0x11(%rbp)
jb 0x38bd
movl $0x5, %eax
cmpl -0x8(%rbp), %eax
setb %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xee7f(%rip), %rax      # 0x12750
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xee70(%rip), %rax      # 0x12750
cmpl $0x0, (%rax,%rcx,4)
je 0x390f
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xf15e(%rip), %rax      # 0x12a50
movl $0x0, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xef4b(%rip), %rax      # 0x12850
movq $0x0, (%rax,%rcx,8)
jmp 0x398b
movl -0x8(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x3925
movl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x392b
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl %ecx, %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl $0x5, %eax
subl -0x8(%rbp), %eax
imull $0x6, %eax, %edx
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xf100(%rip), %rax      # 0x12a50
movl %edx, (%rax,%rcx,4)
imull $0x6, -0x10(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %edx
shlq %cl, %rdx
subq $0x1, %rdx
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xf0dd(%rip), %rax      # 0x12a50
movl (%rax,%rcx,4), %eax
movl %eax, %ecx
shlq %cl, %rdx
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xeec9(%rip), %rax      # 0x12850
movq %rdx, (%rax,%rcx,8)
jmp 0x398d
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x388c
jmp 0x399d
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x387b
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/cell.c
// Function: assert_valid_field
void assert_valid_field(Cell field_spec)
{
    if (is_negative(field_spec) 
        || 64 <= magnitude(field_spec)
        || bad_field[(unsigned)magnitude(field_spec)])
    {
        char buffer[16];
        unparse_cell(buffer, field_spec, false);
        error("Invalid field specifier: %s", buffer);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
jne 0x39fc
movq -0x8(%rbp), %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
movl $0x40, %eax
cmpq %rcx, %rax
jle 0x39fc
movq -0x8(%rbp), %rax
andq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
movl %eax, %eax
movl %eax, %ecx
leaq 0xed5a(%rip), %rax      # 0x12750
cmpl $0x0, (%rax,%rcx,4)
je 0x3a1d
leaq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %edx, %edx
callq 0x3a30
leaq -0x20(%rbp), %rsi
leaq 0x875c(%rip), %rdi      # 0xc172
movb $0x0, %al
callq 0x74b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/cell.c
// Function: unparse_cell
void unparse_cell(char *buffer, Cell cell, Flag disasm)
{
    Byte I, F, C;
    Cell A;

    if (disasm) {
        destructure_cell (cell, A, I, F, C);
        sprintf(buffer, "%s%04lo %02o %02o %02o",
                is_negative (A) ? "-" : "+", magnitude (A),
                I, F, C);
    } else
        sprintf(buffer, "%s%010lo",
                is_negative (cell) ? "-" : "+", magnitude (cell));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x3afe
jmp 0x3a4f
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
andq $0x40000000, %rax       # imm = 0x40000000
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
andq $0x3f, %rax
movl %eax, -0x20(%rbp)
movq -0x30(%rbp), %rax
sarq $0x6, %rax
movq %rax, -0x30(%rbp)
andq $0x3f, %rax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rax
sarq $0x6, %rax
movq %rax, -0x30(%rbp)
andq $0x3f, %rax
movl %eax, -0x18(%rbp)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
sarq $0x6, %rcx
andq $0xfff, %rcx            # imm = 0xFFF
orq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rcx
andq $0x40000000, %rcx       # imm = 0x40000000
leaq 0x8706(%rip), %rdx      # 0xc1cc
leaq 0x8884(%rip), %rax      # 0xc351
cmpq $0x0, %rcx
cmovneq %rax, %rdx
movq -0x28(%rbp), %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movl -0x20(%rbp), %eax
leaq 0x86c3(%rip), %rsi      # 0xc1b5
movl %eax, (%rsp)
movb $0x0, %al
callq 0x3240
jmp 0x3b3c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
andq $0x40000000, %rcx       # imm = 0x40000000
leaq 0x86b8(%rip), %rdx      # 0xc1cc
leaq 0x8836(%rip), %rax      # 0xc351
cmpq $0x0, %rcx
cmovneq %rax, %rdx
movq -0x10(%rbp), %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
leaq 0x8699(%rip), %rsi      # 0xc1ce
movb $0x0, %al
callq 0x3240
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/cell.c
// Function: add
Cell add(Cell x, Cell y)
{   /* This is kinda clumsy. Should I combine code at the cost (?) of speed */
    /* and functional style? */
    if (sign_bit(x) == sign_bit(y)) {
        long sum = magnitude(x) + magnitude(y);
        long magnitude_of_sum = magnitude(sum);
        if (magnitude_of_sum != sum) overflow = true;
        return sign_bit(x) | magnitude_of_sum;
    } else {
        long diff = magnitude(x) - magnitude(y);
        return diff < 0 ? sign_bit (y) | -diff : sign_bit (x) | diff;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
andq $0x40000000, %rax       # imm = 0x40000000
movq -0x18(%rbp), %rcx
andq $0x40000000, %rcx       # imm = 0x40000000
cmpq %rcx, %rax
jne 0x3bc8
movq -0x10(%rbp), %rax
andq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
movq -0x18(%rbp), %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
andq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x3bb4
movl $0x1, 0xef9c(%rip)      # 0x12b50
movq -0x10(%rbp), %rax
andq $0x40000000, %rax       # imm = 0x40000000
orq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3c1e
movq -0x10(%rbp), %rax
andq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
movq -0x18(%rbp), %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
subq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jge 0x3c04
movq -0x18(%rbp), %rax
andq $0x40000000, %rax       # imm = 0x40000000
xorl %ecx, %ecx
subq -0x30(%rbp), %rcx
orq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x3c16
movq -0x10(%rbp), %rax
andq $0x40000000, %rax       # imm = 0x40000000
orq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/cell.c
// Function: shift_right
void shift_right(Cell A, Cell X, unsigned long count, Cell *pA, Cell *pX)
{
    *pX = sign_bit(X);
    *pA = sign_bit(A);
    if (count < 5) {
        *pA |= magnitude(A) >> (6 * count);
        *pX |= CELL_MAX & ((magnitude(X) >> (6 * count))
            | (A << (30 - 6 * count)));
    } else if (count < 10)
        *pX |= magnitude(A) >> (6 * count - 30);
    else
        ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rcx
andq $0x40000000, %rcx       # imm = 0x40000000
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
andq $0x40000000, %rcx       # imm = 0x40000000
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x5, -0x18(%rbp)
jae 0x4236
movq -0x8(%rbp), %rax
andq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
imulq $0x6, -0x18(%rbp), %rcx
sarq %cl, %rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
andq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
imulq $0x6, -0x18(%rbp), %rcx
sarq %cl, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
imulq $0x6, -0x18(%rbp), %rdx
movl $0x1e, %ecx
subq %rdx, %rcx
shlq %cl, %rax
movq -0x30(%rbp), %rcx
orq %rax, %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
movq -0x28(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x4266
cmpq $0xa, -0x18(%rbp)
jae 0x4262
movq -0x8(%rbp), %rax
andq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
imulq $0x6, -0x18(%rbp), %rcx
subq $0x1e, %rcx
sarq %cl, %rax
movq %rax, %rcx
movq -0x28(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x4264
jmp 0x4264
jmp 0x4266
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/cell.c
// Function: shift_left
void shift_left(Cell A, Cell X, unsigned long count, Cell *pA, Cell *pX)
{
    *pX = sign_bit(X);
    *pA = sign_bit(A);
    if (count < 5) {
        *pX |= CELL_MAX & (X << (6 * count));
        *pA |= CELL_MAX & ((A << (6 * count))
            | (magnitude(X) >> (30 - 6 * count)));
    } else if (count < 10)
        *pA |= CELL_MAX & (X << (6 * count - 30));
    else
        ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rcx
andq $0x40000000, %rcx       # imm = 0x40000000
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
andq $0x40000000, %rcx       # imm = 0x40000000
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x5, -0x18(%rbp)
jae 0x4317
movq -0x10(%rbp), %rax
imulq $0x6, -0x18(%rbp), %rcx
shlq %cl, %rax
movq %rax, %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
movq -0x28(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
imulq $0x6, -0x18(%rbp), %rcx
shlq %cl, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
andq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
imulq $0x6, -0x18(%rbp), %rdx
movl $0x1e, %ecx
subq %rdx, %rcx
sarq %cl, %rax
movq -0x30(%rbp), %rcx
orq %rax, %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
movq -0x20(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x4348
cmpq $0xa, -0x18(%rbp)
jae 0x4344
movq -0x10(%rbp), %rax
imulq $0x6, -0x18(%rbp), %rcx
subq $0x1e, %rcx
shlq %cl, %rax
movq %rax, %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
movq -0x20(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x4346
jmp 0x4346
jmp 0x4348
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/cell.c
// Function: shift_right_binary
void shift_right_binary(Cell A, Cell X, unsigned long count, Cell *pA, Cell *pX)
{
    *pX = sign_bit(X);
    *pA = sign_bit(A);
    if (count < 30) {
        *pA |= magnitude(A) >> count;
        *pX |= CELL_MAX & ((magnitude(X) >> count)
            | (A << (30 - count)));
    } else if (count < 60)
        *pX |= magnitude(A) >> (count - 30);
    else
        ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rcx
andq $0x40000000, %rcx       # imm = 0x40000000
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
andq $0x40000000, %rcx       # imm = 0x40000000
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x1e, -0x18(%rbp)
jae 0x43f0
movq -0x8(%rbp), %rax
andq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
movq -0x18(%rbp), %rcx
sarq %cl, %rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
andq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
movq -0x18(%rbp), %rcx
sarq %cl, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl $0x1e, %ecx
subq -0x18(%rbp), %rcx
shlq %cl, %rax
movq -0x30(%rbp), %rcx
orq %rax, %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
movq -0x28(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x441f
cmpq $0x3c, -0x18(%rbp)
jae 0x441b
movq -0x8(%rbp), %rax
andq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
movq -0x18(%rbp), %rcx
subq $0x1e, %rcx
sarq %cl, %rax
movq %rax, %rcx
movq -0x28(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x441d
jmp 0x441d
jmp 0x441f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/cell.c
// Function: shift_left_binary
void shift_left_binary(Cell A, Cell X, unsigned long count, Cell *pA, Cell *pX)
{
    *pX = sign_bit(X);
    *pA = sign_bit(A);
    if (count < 30) {
        *pX |= CELL_MAX & (X << count);
        *pA |= CELL_MAX & ((A << count)
            | (magnitude(X) >> (30 - count)));
    } else if (count < 60)
        *pA |= CELL_MAX & (X << (count - 30));
    else
        ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rcx
andq $0x40000000, %rcx       # imm = 0x40000000
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
andq $0x40000000, %rcx       # imm = 0x40000000
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x1e, -0x18(%rbp)
jae 0x44d1
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq %cl, %rax
movq %rax, %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
movq -0x28(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq %cl, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
andq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
movl $0x1e, %ecx
subq -0x18(%rbp), %rcx
sarq %cl, %rax
movq -0x30(%rbp), %rcx
orq %rax, %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
movq -0x20(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x4501
cmpq $0x3c, -0x18(%rbp)
jae 0x44fd
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1e, %rcx
shlq %cl, %rax
movq %rax, %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
movq -0x20(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x44ff
jmp 0x44ff
jmp 0x4501
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/cell.c
// Function: shift_left_circular
void shift_left_circular(Cell A, Cell X, unsigned count, Cell *pA, Cell *pX)
{
    Cell A1 = count < 5 ? A : X;
    Cell X1 = count < 5 ? X : A;
    unsigned c = 6 * (count < 5 ? count : count - 5);
    *pX = sign_bit(X)
        | (CELL_MAX & ((X1 << c) | (magnitude(A1) >> (30 - c))));
    *pA = sign_bit(A)
        | (CELL_MAX & ((A1 << c) | (magnitude(X1) >> (30 - c))));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x5, -0x14(%rbp)
jae 0x4537
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x453f
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x5, -0x14(%rbp)
jae 0x4557
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x455f
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x5, -0x14(%rbp)
jae 0x4575
movl -0x14(%rbp), %eax
movl %eax, -0x54(%rbp)
jmp 0x457e
movl -0x14(%rbp), %eax
subl $0x5, %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
imull $0x6, %eax, %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
andq $0x40000000, %rax       # imm = 0x40000000
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rax
movl -0x3c(%rbp), %ecx
shlq %cl, %rax
movq -0x30(%rbp), %rdx
andq $0x3fffffff, %rdx       # imm = 0x3FFFFFFF
movl $0x1e, %ecx
subl -0x3c(%rbp), %ecx
movl %ecx, %ecx
sarq %cl, %rdx
movq -0x68(%rbp), %rcx
orq %rdx, %rax
andq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
orq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
andq $0x40000000, %rax       # imm = 0x40000000
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rax
movl -0x3c(%rbp), %ecx
shlq %cl, %rax
movq -0x38(%rbp), %rdx
andq $0x3fffffff, %rdx       # imm = 0x3FFFFFFF
movl $0x1e, %ecx
subl -0x3c(%rbp), %ecx
movl %ecx, %ecx
sarq %cl, %rdx
movq -0x60(%rbp), %rcx
orq %rdx, %rax
andq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
orq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)