LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/brk2.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	unsigned long page_size = getpagesize();
	void *addr = sbrk(page_size) + page_size;

	while (1) {
		addr += page_size;
		assert(brk(addr) == 0);

		addr -= page_size;
		assert(brk(addr) == 0);

		(*iterations) += 2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1260
cltq
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1170
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1160
cmpl $0x0, %eax
jne 0x2078
jmp 0x2097
leaq 0x1204(%rip), %rdi      # 0x3283
leaq 0x120c(%rip), %rsi      # 0x3292
movl $0xe, %edx
leaq 0x120d(%rip), %rcx      # 0x329f
callq 0x1120
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1160
cmpl $0x0, %eax
jne 0x20bb
jmp 0x20da
leaq 0x11c1(%rip), %rdi      # 0x3283
leaq 0x11c9(%rip), %rsi      # 0x3292
movl $0x11, %edx
leaq 0x11ca(%rip), %rcx      # 0x329f
callq 0x1120
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
jmp 0x205c
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/gencode.C
// Function: main
global int main(int argc, char* argv[]) {
  readcmdline(argv);
  readdata(cmdline, pbgain, nzeros, xcoeffs, npoles, ycoeffs);
  if (language == fifi)
    compilefifi();
  else
    compileclear();
  return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x12b0
leaq 0x3e6a(%rip), %rdi      # 0x50d0
leaq 0x3f6b(%rip), %rsi      # 0x51d8
leaq 0x3f6c(%rip), %rdx      # 0x51e0
leaq 0x3f75(%rip), %rcx      # 0x51f0
leaq 0x4f76(%rip), %r8       # 0x61f8
leaq 0x4f77(%rip), %r9       # 0x6200
callq 0x25f0
cmpl $0x3, 0x5f73(%rip)      # 0x7208
jne 0x129e
callq 0x13e0
jmp 0x12a3
callq 0x15e0
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/gencode.C
// Function: readcmdline(char**)
static void readcmdline(char* argv[]) {
  language = none;
  int ap = 0;
  progname = (argv[ap] != NULL) ? argv[ap++] : "???";
  until(argv[ap] == NULL) {
    char* s = argv[ap++];
    if (seq(s, "-ansic"))
      language = ansic;
    else if (seq(s, "-xyc"))
      language = xyc;
    else if (seq(s, "-f"))
      language = fifi;
    else
      usage();
  }
  if (language == none)
    language = ansic;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x5f45(%rip)      # 0x7208
movl $0x0, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x12fc
movq 0x20(%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x1c(%rsp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x130a
leaq 0x1d1d(%rip), %rax      # 0x3020
movq %rax, 0x8(%rsp)
jmp 0x130a
movq 0x8(%rsp), %rax
movq %rax, 0x3daa(%rip)      # 0x50c0
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1333
jmp 0x13c8
movq 0x20(%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x1c(%rsp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x1cc7(%rip), %rsi      # 0x3024
callq 0x1fc0
testb $0x1, %al
jne 0x1368
jmp 0x1374
movl $0x1, 0x5e96(%rip)      # 0x7208
jmp 0x13c3
movq 0x10(%rsp), %rdi
leaq 0x1cab(%rip), %rsi      # 0x302b
callq 0x1fc0
testb $0x1, %al
jne 0x138b
jmp 0x1397
movl $0x2, 0x5e73(%rip)      # 0x7208
jmp 0x13c1
movq 0x10(%rsp), %rdi
leaq 0x1c8d(%rip), %rsi      # 0x3030
callq 0x1fc0
testb $0x1, %al
jne 0x13ae
jmp 0x13ba
movl $0x3, 0x5e50(%rip)      # 0x7208
jmp 0x13bf
callq 0x1730
jmp 0x13c1
jmp 0x13c3
jmp 0x1316
cmpl $0x0, 0x5e39(%rip)      # 0x7208
jne 0x13db
movl $0x1, 0x5e2d(%rip)      # 0x7208
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/gencode.C
// Function: compileclear()
static void compileclear() {
  if (language == xyc) {
    printf("%15.8e", pbgain);
    for (int i = 0; i <= nzeros; i++)
      printf("\t%15.8e", xcoeffs[i]);
    for (int i = 0; i <= npoles; i++)
      printf("\t%15.8e", ycoeffs[i]);
    putchar('\n');
  } else {
    printf(
        "/* Digital filter designed by mkfilter/mkshape/gencode   A.J. "
        "Fisher\n");
    printf("   Command line: %s */\n\n", cmdline);
    int n = 0;
    while (n < npoles && ycoeffs[n] == 0.0)
      n++;
    if (n >= npoles)
      comp_fir();
    else
      comp_iir();
  }
}

// Assembly:
subq $0x18, %rsp
cmpl $0x2, 0x5c1d(%rip)      # 0x7208
jne 0x1696
movsd 0x3bdf(%rip), %xmm0     # 0x51d8
leaq 0x1c49(%rip), %rdi      # 0x3249
movb $0x1, %al
callq 0x1030
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x3bc7(%rip), %eax      # 0x51e0
jg 0x1647
movslq 0x14(%rsp), %rcx
leaq 0x3bc9(%rip), %rax      # 0x51f0
movsd (%rax,%rcx,8), %xmm0
leaq 0x1c15(%rip), %rdi      # 0x3248
movb $0x1, %al
callq 0x1030
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x160f
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x4b9f(%rip), %eax      # 0x61f8
jg 0x1687
movslq 0x10(%rsp), %rcx
leaq 0x4b99(%rip), %rax      # 0x6200
movsd (%rax,%rcx,8), %xmm0
leaq 0x1bd5(%rip), %rdi      # 0x3248
movb $0x1, %al
callq 0x1030
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x164f
movl $0xa, %edi
callq 0x10e0
jmp 0x1728
leaq 0x1bb3(%rip), %rdi      # 0x3250
movb $0x0, %al
callq 0x1030
leaq 0x1beb(%rip), %rdi      # 0x3296
leaq 0x3a1e(%rip), %rsi      # 0x50d0
movb $0x0, %al
callq 0x1030
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %ecx
xorl %eax, %eax
cmpl 0x4b2b(%rip), %ecx      # 0x61f8
movb %al, 0xb(%rsp)
jge 0x16f7
movslq 0xc(%rsp), %rcx
leaq 0x4b21(%rip), %rax      # 0x6200
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x1701
jmp 0x170e
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x16c1
movl 0xc(%rsp), %eax
cmpl 0x4ae0(%rip), %eax      # 0x61f8
jl 0x1721
callq 0x1cb0
jmp 0x1726
callq 0x1d80
jmp 0x1728
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/gencode.C
// Function: usage()
static void usage() {
  fprintf(stderr, "Gencode version %s from <fisher@minster.york.ac.uk>\n",
          VERSION);
  fprintf(stderr, "Usage: gencode [-ansic | -xyc | -f]\n");
  exit(1);
}

// Assembly:
pushq %rax
movq 0x38a8(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x18f1(%rip), %rsi      # 0x3033
leaq 0x191f(%rip), %rdx      # 0x3068
movb $0x0, %al
callq 0x1100
movq 0x3889(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x190b(%rip), %rsi      # 0x306c
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x10a0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/gencode.C
// Function: prshift(char const*, int)
static void prshift(const char* vs, int n) {
  if (n > 0) {
    for (int i = 0; i < n; i++) {
      if (i % 4 == 0)
        printf("    ");
      printf("%s[%d] = %s[%d]; ", vs, i, vs, i + 1);
      if (i % 4 == 3)
        putchar('\n');
    }
    unless(n % 4 == 0) putchar('\n');
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jle 0x1835
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x1818
movl 0x8(%rsp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x17c9
leaq 0x1d14(%rip), %rdi      # 0x34d6
movb $0x0, %al
callq 0x1030
movq 0x10(%rsp), %rsi
movl 0x8(%rsp), %edx
movq 0x10(%rsp), %rcx
movl 0x8(%rsp), %r8d
addl $0x1, %r8d
leaq 0x19f7(%rip), %rdi      # 0x31de
movb $0x0, %al
callq 0x1030
movl 0x8(%rsp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x3, %edx
jne 0x1809
movl $0xa, %edi
callq 0x10e0
jmp 0x180b
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x17a0
movl 0xc(%rsp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x1833
movl $0xa, %edi
callq 0x10e0
jmp 0x1835
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/gencode.C
// Function: pr_ypart(char const*)
static void pr_ypart(const char* vs) { /* output contribution from Y vec */
  for (int i = 0; i < npoles; i++) {
    if (i % 2 == 0)
      prnl();
    printf(" + (%14.10f * %s[%d])", ycoeffs[i], vs, i);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x499d(%rip), %eax      # 0x61f8
jge 0x18a8
movl 0xc(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x1873
callq 0x1b10
movslq 0xc(%rsp), %rcx
leaq 0x4981(%rip), %rax      # 0x6200
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
leaq 0x195c(%rip), %rdi      # 0x31f0
movb $0x1, %al
callq 0x1030
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1851
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/gencode.C
// Function: prxfac(double)
static void prxfac(double x) {
  if (nxfacs > 0 && nxfacs % 3 == 0)
    prnl();
  if (x > 0.0)
    printf((nxfacs > 0) ? " + " : "   ");
  if (x < 0.0) {
    printf(" - ");
    x = -x;
  }
  unless(x == 1.0) {
    double f = fmod(x, 1.0);
    const char* fmt = (f < EPS || f > 1.0 - EPS) ? "%g" : "%14.10f";
    printf(fmt, x);
    printf(" * ");
  }
  nxfacs++;
}

// Assembly:
subq $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
cmpl $0x0, 0x56af(%rip)      # 0x7210
jle 0x1b7b
movl 0x56a7(%rip), %eax      # 0x7210
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x1b7b
callq 0x1b10
movsd 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1bbb
cmpl $0x0, 0x567f(%rip)      # 0x7210
jle 0x1ba1
leaq 0x1697(%rip), %rax      # 0x3231
movq %rax, 0x8(%rsp)
jmp 0x1baf
leaq 0x189d(%rip), %rax      # 0x3445
movq %rax, 0x8(%rsp)
jmp 0x1baf
movq 0x8(%rsp), %rdi
movb $0x0, %al
callq 0x1030
xorps %xmm0, %xmm0
ucomisd 0x20(%rsp), %xmm0
jbe 0x1bf7
leaq 0x1668(%rip), %rdi      # 0x3235
movb $0x0, %al
callq 0x1030
movsd 0x20(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x1403(%rip), %xmm1     # 0x3008
ucomisd %xmm1, %xmm0
jne 0x1c12
jp 0x1c12
jmp 0x1c98
movsd 0x20(%rsp), %xmm0
movsd 0x13e8(%rip), %xmm1     # 0x3008
callq 0x10c0
movsd %xmm0, 0x18(%rsp)
movb $0x1, %al
movsd 0x13db(%rip), %xmm0     # 0x3010
ucomisd 0x18(%rsp), %xmm0
movb %al, 0x7(%rsp)
ja 0x1c5a
movsd 0x18(%rsp), %xmm0
movsd 0x13c9(%rip), %xmm1     # 0x3018
ucomisd %xmm1, %xmm0
seta %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %dl
leaq 0x15d7(%rip), %rax      # 0x323c
leaq 0x15cd(%rip), %rcx      # 0x3239
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movsd 0x20(%rsp), %xmm0
movb $0x1, %al
callq 0x1030
leaq 0x15b3(%rip), %rdi      # 0x3244
movb $0x0, %al
callq 0x1030
movl 0x5572(%rip), %eax      # 0x7210
addl $0x1, %eax
movl %eax, 0x5569(%rip)      # 0x7210
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/gencode.C
// Function: comp_fir()
static void comp_fir() {
  printf("#define NZEROS %d\n", nzeros);
  printf("#define GAIN   %15.9e\n\n", pbgain);
  printf("static float xv[NZEROS+1];\n\n");
  pr_xcoeffs();
  printf("static void filterloop()\n");
  printf("  { for (;;)\n");
  printf("      { float sum; int i;\n");
  printf("        for (i = 0; i < NZEROS; i++) xv[i] = xv[i+1];\n");
  printf("        xv[NZEROS] = `next input value' / GAIN;\n");
  printf("        sum = 0.0;\n");
  printf(
      "        for (i = 0; i <= NZEROS; i++) sum += (xcoeffs[i] * xv[i]);\n");
  printf("        `next output value' = sum;\n");
  printf("      }\n");
  printf("  }\n\n");
}

// Assembly:
pushq %rax
movl 0x3529(%rip), %esi      # 0x51e0
leaq 0x15f1(%rip), %rdi      # 0x32af
movb $0x0, %al
callq 0x1030
movsd 0x350b(%rip), %xmm0     # 0x51d8
leaq 0x15ee(%rip), %rdi      # 0x32c2
movb $0x1, %al
callq 0x1030
leaq 0x15f8(%rip), %rdi      # 0x32da
movb $0x0, %al
callq 0x1030
callq 0x1ed0
leaq 0x1602(%rip), %rdi      # 0x32f7
movb $0x0, %al
callq 0x1030
leaq 0x160e(%rip), %rdi      # 0x3311
movb $0x0, %al
callq 0x1030
leaq 0x160e(%rip), %rdi      # 0x331f
movb $0x0, %al
callq 0x1030
leaq 0x161b(%rip), %rdi      # 0x333a
movb $0x0, %al
callq 0x1030
leaq 0x1644(%rip), %rdi      # 0x3371
movb $0x0, %al
callq 0x1030
leaq 0x1667(%rip), %rdi      # 0x33a2
movb $0x0, %al
callq 0x1030
leaq 0x166d(%rip), %rdi      # 0x33b6
movb $0x0, %al
callq 0x1030
leaq 0x16a3(%rip), %rdi      # 0x33fa
movb $0x0, %al
callq 0x1030
leaq 0x16b9(%rip), %rdi      # 0x341e
movb $0x0, %al
callq 0x1030
leaq 0x1433(%rip), %rdi      # 0x31a6
movb $0x0, %al
callq 0x1030
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/gencode.C
// Function: comp_iir()
static void comp_iir() {
  printf("#define NZEROS %d\n", nzeros);
  printf("#define NPOLES %d\n", npoles);
  printf("#define GAIN   %15.9e\n\n", pbgain);
  printf("static float xv[NZEROS+1], yv[NPOLES+1];\n\n");
  margin = 20;
  printf("static void filterloop()\n");
  printf("  { for (;;)\n");
  printf("      { ");
  pr_shiftdown("xv", nzeros);
  putchar('\n');
  printf("        xv[%d] = `next input value' / GAIN;\n", nzeros);
  printf("        ");
  pr_shiftdown("yv", npoles);
  putchar('\n');
  printf("        yv[%d] =", npoles);
  pr_xpart("xv");
  pr_ypart("yv");
  printf(";\n");
  printf("        `next output value' = yv[%d];\n", npoles);
  printf("      }\n");
  printf("  }\n\n");
}

// Assembly:
pushq %rax
movl 0x3459(%rip), %esi      # 0x51e0
leaq 0x1521(%rip), %rdi      # 0x32af
movb $0x0, %al
callq 0x1030
movl 0x445d(%rip), %esi      # 0x61f8
leaq 0x16b9(%rip), %rdi      # 0x345b
movb $0x0, %al
callq 0x1030
movsd 0x3427(%rip), %xmm0     # 0x51d8
leaq 0x150a(%rip), %rdi      # 0x32c2
movb $0x1, %al
callq 0x1030
leaq 0x16a8(%rip), %rdi      # 0x346e
movb $0x0, %al
callq 0x1030
movl $0x14, 0x5435(%rip)     # 0x720c
leaq 0x1519(%rip), %rdi      # 0x32f7
movb $0x0, %al
callq 0x1030
leaq 0x1525(%rip), %rdi      # 0x3311
movb $0x0, %al
callq 0x1030
leaq 0x169f(%rip), %rdi      # 0x3499
movb $0x0, %al
callq 0x1030
movl 0x33d9(%rip), %esi      # 0x51e0
leaq 0x1694(%rip), %rdi      # 0x34a2
callq 0x1f60
movl $0xa, %edi
callq 0x10e0
movl 0x33bd(%rip), %esi      # 0x51e0
leaq 0x167b(%rip), %rdi      # 0x34a5
movb $0x0, %al
callq 0x1030
leaq 0x169a(%rip), %rdi      # 0x34d2
movb $0x0, %al
callq 0x1030
movl 0x43b3(%rip), %esi      # 0x61f8
leaq 0x168f(%rip), %rdi      # 0x34db
callq 0x1f60
movl $0xa, %edi
callq 0x10e0
movl 0x4397(%rip), %esi      # 0x61f8
leaq 0x1676(%rip), %rdi      # 0x34de
movb $0x0, %al
callq 0x1030
leaq 0x162c(%rip), %rdi      # 0x34a2
callq 0x18b0
leaq 0x1659(%rip), %rdi      # 0x34db
callq 0x1840
leaq 0x1569(%rip), %rdi      # 0x33f7
movb $0x0, %al
callq 0x1030
movl 0x435d(%rip), %esi      # 0x61f8
leaq 0x164d(%rip), %rdi      # 0x34ef
movb $0x0, %al
callq 0x1030
leaq 0x156e(%rip), %rdi      # 0x341e
movb $0x0, %al
callq 0x1030
leaq 0x12e8(%rip), %rdi      # 0x31a6
movb $0x0, %al
callq 0x1030
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/gencode.C
// Function: pr_xcoeffs()
static void pr_xcoeffs() {
  printf("static float xcoeffs[] =\n  {");
  for (int i = 0; i <= nzeros; i++) {
    if (i > 0 && i % 4 == 0)
      printf("\n   ");
    printf(" %+0.10f,", xcoeffs[i]);
  }
  printf("\n  };\n\n");
}

// Assembly:
pushq %rax
leaq 0x154f(%rip), %rdi      # 0x3427
movb $0x0, %al
callq 0x1030
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x32ef(%rip), %eax      # 0x51e0
jg 0x1f45
cmpl $0x0, 0x4(%rsp)
jle 0x1f19
movl 0x4(%rsp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x1f19
leaq 0x1532(%rip), %rdi      # 0x3444
movb $0x0, %al
callq 0x1030
movslq 0x4(%rsp), %rcx
leaq 0x32cb(%rip), %rax      # 0x51f0
movsd (%rax,%rcx,8), %xmm0
leaq 0x1518(%rip), %rdi      # 0x3449
movb $0x1, %al
callq 0x1030
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1ee7
leaq 0x1507(%rip), %rdi      # 0x3453
movb $0x0, %al
callq 0x1030
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/readdata.C
// Function: rdline(char*)
static void rdline(char vec[]) {
  int n = 0;
  int ch = getchar();
  until(n >= MAXSTRING || ch == '\n' || ch < 0) {
    vec[n++] = ch;
    ch = getchar();
  }
  if (n == 0 && ch < 0)
    formaterror(6);
  vec[n] = '\0';
  until(ch == '\n' || ch < 0) ch = getchar();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
callq 0x10d0
movl %eax, 0x8(%rsp)
movb $0x1, %al
cmpl $0x100, 0xc(%rsp)       # imm = 0x100
movb %al, 0x7(%rsp)
jge 0x26f3
movb $0x1, %al
cmpl $0xa, 0x8(%rsp)
movb %al, 0x7(%rsp)
je 0x26f3
cmpl $0x0, 0x8(%rsp)
setl %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x26ff
jmp 0x2728
movl 0x8(%rsp), %eax
movb %al, %dl
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xc(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
callq 0x10d0
movl %eax, 0x8(%rsp)
jmp 0x26ca
cmpl $0x0, 0xc(%rsp)
jne 0x2740
cmpl $0x0, 0x8(%rsp)
jge 0x2740
movl $0x6, %edi
callq 0x2890
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movb $0x1, %al
cmpl $0xa, 0x8(%rsp)
movb %al, 0x6(%rsp)
je 0x2767
cmpl $0x0, 0x8(%rsp)
setl %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2773
jmp 0x277e
callq 0x10d0
movl %eax, 0x8(%rsp)
jmp 0x274e
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/readdata.C
// Function: rdcoeffs(char, int&, double*)
static void rdcoeffs(char c, int& n, double* coeffs) {
  char fmt[6];
  strcpy(fmt, "N? = ");
  fmt[1] = c;
  n = rdint(fmt);
  unless(n >= 0 && n <= MAXPZ) formaterror(3);
  for (int i = 0; i <= n; i++)
    coeffs[i] = rddouble("");
}

// Assembly:
subq $0x28, %rsp
movb %dil, %al
movb %al, 0x27(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0xa(%rsp), %rdi
leaq 0xd2d(%rip), %rsi       # 0x352e
callq 0x1090
movb 0x27(%rsp), %al
movb %al, 0xb(%rsp)
leaq 0xa(%rsp), %rdi
callq 0x28d0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
jl 0x2838
movq 0x18(%rsp), %rax
cmpl $0x200, (%rax)          # imm = 0x200
jle 0x2842
movl $0x3, %edi
callq 0x2890
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jg 0x287f
leaq 0xa50(%rip), %rdi       # 0x32ae
callq 0x2790
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x284a
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/readdata.C
// Function: getline(char*, int&, int, char const*)
static void getline(char* vec, int& p, int e, const char* exp) {
  rdline(vec);
  p = strlen(exp);
  unless(memcmp(vec, exp, p) == 0) formaterror(e);
  while (vec[p] == ' ' || vec[p] == '\t')
    p++;
  unless((vec[p] >= '0' && vec[p] <= '9') || (vec[p] == '+') ||
         (vec[p] == '-') || (vec[p] == '.')) formaterror(e);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x26b0
movq 0x8(%rsp), %rdi
callq 0x1060
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movslq (%rax), %rdx
callq 0x1070
cmpl $0x0, %eax
je 0x2979
movl 0x14(%rsp), %edi
callq 0x2890
jmp 0x297b
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, 0x7(%rsp)
je 0x29b2
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x29bc
jmp 0x29ca
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x297b
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x29f6
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jle 0x2a41
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
je 0x2a41
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
je 0x2a41
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
je 0x2a41
movl 0x14(%rsp), %edi
callq 0x2890
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/tests/test_verify_cigars.c
// Function: binomial_coefficient
static inline unsigned long binomial_coefficient(
        unsigned long n,
        unsigned long k)
{
    /* from http://blog.plover.com/math/choose.html */
    unsigned long r = 1;
    unsigned long d;
    if (k > n) {
        return 0;
    }
    for (d = 1; d <= k; d++) {
        r *= n--;
        r /= d;
    }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x1, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jbe 0x12a1d8
movq $0x0, -0x8(%rbp)
jmp 0x12a229
movq $0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x12a221
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
imulq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x12a1e0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/tests/test_verify_cigars.c
// Function: k_combination2
static inline void k_combination2(
        unsigned long pos,
        unsigned long *a,
        unsigned long *b)
{
    double s;
    double i = floor(sqrt(2.0 * pos)) - 1.0;
    if (i <= 1.0) {
        i = 1.0;
    }
    s = i * (i - 1.0) / 2.0;
    while (pos - s >= i) {
        s += i;
        i += 1;
    }
    *a = (unsigned long)(pos - s);
    *b = (unsigned long)(i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movaps 0xad7ea5(%rip), %xmm0   # 0xc02b10
movq -0x8(%rbp), %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0xad7ea4(%rip), %xmm0   # 0xc02b20
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd 0xad7e65(%rip), %xmm0   # 0xc02af8
mulsd %xmm1, %xmm0
callq 0x1290d0
callq 0x1291f0
movsd 0xad7e47(%rip), %xmm1   # 0xc02af0
subsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0xad7e36(%rip), %xmm0   # 0xc02af0
ucomisd -0x28(%rbp), %xmm0
jb 0x12acce
movsd 0xad7e27(%rip), %xmm0   # 0xc02af0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd 0xad7e10(%rip), %xmm2   # 0xc02af0
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd 0xad7e08(%rip), %xmm1   # 0xc02af8
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movaps 0xad7e10(%rip), %xmm1   # 0xc02b10
movq -0x8(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xad7e0f(%rip), %xmm1   # 0xc02b20
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
subsd -0x20(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jb 0x12ad4f
movsd -0x28(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0xad7dad(%rip), %xmm0   # 0xc02af0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x12acf9
movaps 0xad7dba(%rip), %xmm1   # 0xc02b10
movq -0x8(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xad7db9(%rip), %xmm1   # 0xc02b20
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd -0x20(%rbp), %xmm1
subsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
movsd 0xad7d6a(%rip), %xmm2   # 0xc02b00
subsd %xmm2, %xmm0
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movsd -0x28(%rbp), %xmm0
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rax
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
andq %rdx, %rax
orq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/tests/test_verify_cigars.c
// Function: diff_cigar
static inline int diff_cigar(
        uint32_t *a,
        uint32_t *b,
        int lena,
        int lenb)
{
    int i = 0;
    for (i=0; i<lena; ++i) {
        if (a[i] != b[i]) return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x12ae36
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x12ae29
movl $0x1, -0x4(%rbp)
jmp 0x12ae3d
jmp 0x12ae2b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x12ae00
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/matrix_lookup.c
// Function: parasail_matrix_lookup
const parasail_matrix_t* parasail_matrix_lookup(const char *matrixname)
{
    const parasail_matrix_t *matrix = NULL;

    if (matrixname) {
        int index = 0;
        const parasail_matrix_t *current = parasail_matrices[index++];
        while (current) {
            if (0 == strcmp(matrixname, current->name)) {
                matrix = current;
                break;
            }
            current = parasail_matrices[index++];
        }
    }

    return matrix;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x134789
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %eax, %rcx
leaq 0xba3739(%rip), %rax    # 0xcd7e70
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x134787
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x129180
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x134768
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x134787
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %eax, %rcx
leaq 0xba36f3(%rip), %rax    # 0xcd7e70
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0x13473f
jmp 0x134789
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/parasail/stats.h
// Function: stats_clear
static inline void stats_clear(stats_t *stats) {
    stats->_n = 0UL;
    stats->_mean = 0.0;
    stats->_M2 = 0.0;
    stats->_sum = 0.0;
    stats->_min = 0.0;
    stats->_max = 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/parasail/stats.h
// Function: stats_sample_value
static inline void stats_sample_value(stats_t *stats, const double x) {
    double delta = 0;

    /* extra stats */
    stats->_sum = stats->_sum + x;
    if (0UL == stats->_n) {
        stats->_min = x;
        stats->_max = x;
    }
    else {
        stats->_min = stats->_min < x ? stats->_min : x;
        stats->_max = stats->_max > x ? stats->_max : x;
    }

    stats->_n = stats->_n + 1UL;
    delta = x - stats->_mean;
    stats->_mean = stats->_mean + delta/stats->_n;
    stats->_M2 = stats->_M2 + delta * (x - stats->_mean);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
addsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x139455
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x28(%rax)
jmp 0x1394c9
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x139479
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x139483
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movq -0x8(%rbp), %rax
movsd 0x28(%rax), %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x1394b1
movq -0x8(%rbp), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x1394bb
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
incq %rcx
movq %rcx, (%rax)
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd -0x18(%rbp), %xmm1
movq (%rax), %xmm2
movaps 0xac960a(%rip), %xmm3   # 0xc02b10
punpckldq %xmm3, %xmm2    # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
movapd 0xac960e(%rip), %xmm3   # 0xc02b20
subpd %xmm3, %xmm2
movaps %xmm2, %xmm3
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
addsd %xmm3, %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm1
movsd -0x18(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
movq -0x8(%rbp), %rax
subsd 0x8(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/parser.c
// Function: strdup_rpl
static char* strdup_rpl(const char *str)
{
    size_t l = strlen(str);
    char *s = (char*)calloc(l + 1, sizeof(char));
    if(!s) {
        return NULL;
    }
    (void)memcpy(s, str, l);
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x129080
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x1290c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1395b0
movq $0x0, -0x8(%rbp)
jmp 0x1395c9
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1290e0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/parser.c
// Function: parasail_sequences_free
void parasail_sequences_free(parasail_sequences_t *sequences)
{
    size_t i;
    for (i=0; i<sequences->l; ++i) {
        if (sequences->seqs[i].name.s)    free(sequences->seqs[i].name.s);
        if (sequences->seqs[i].comment.s) free(sequences->seqs[i].comment.s);
        if (sequences->seqs[i].seq.s)     free(sequences->seqs[i].seq.s);
        if (sequences->seqs[i].qual.s)    free(sequences->seqs[i].qual.s);
    }
    free(sequences->seqs);
    free(sequences);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x139779
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x1396ca
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x129150
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
cmpq $0x0, 0x18(%rax)
je 0x1396fe
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
callq 0x129150
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
cmpq $0x0, 0x28(%rax)
je 0x139732
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rdi
callq 0x129150
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
cmpq $0x0, 0x38(%rax)
je 0x139766
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x38(%rax), %rdi
callq 0x129150
jmp 0x139768
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x139684
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x129150
movq -0x8(%rbp), %rdi
callq 0x129150
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/parser.c
// Function: parasail_sequences_pack
char* parasail_sequences_pack(const parasail_sequences_t *sequences, size_t *size)
{
    size_t i = 0;
    size_t offset = 0;
    char *packed = NULL;

    packed = (char*)malloc(sizeof(char) * (sequences->characters+sequences->l+1));
    if (NULL == packed) {
        perror("malloc");
        fprintf(stderr, "parasail_sequences_pack: failed\n");
        return NULL;
    }

    for (i=0; i<sequences->l; ++i) {
        memcpy(&packed[offset], sequences->seqs[i].seq.s, sequences->seqs[i].seq.l);
        offset += sequences->seqs[i].seq.l;
        packed[offset++] = '$';
    }
    packed[offset] = '\0';

    *size = offset;

    return packed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x129170
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x30(%rbp), %rax
jne 0x139822
leaq 0xaf73c5(%rip), %rdi    # 0xc30bbd
callq 0x1290f0
movq 0xb8f7dc(%rip), %rax    # 0xcc8fe0
movq (%rax), %rdi
leaq 0xaf7422(%rip), %rsi    # 0xc30c30
movb $0x0, %al
callq 0x1291a0
movq $0x0, -0x8(%rbp)
jmp 0x1398d6
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x1398b7
movq -0x30(%rbp), %rdi
addq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rdx
callq 0x1290e0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb $0x24, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x13982a
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/janmojzis[P]mcencrypt/benes.c
// Function: layer_ex
static void layer_ex(uint64_t * data, uint64_t * bits, int lgs)
{
	int i, j, s;

	uint64_t d;

	s = 1 << lgs;

	for (i = 0; i < 128; i += s*2)
	for (j = i; j < i+s; j++)
	{

		d = (data[j+0] ^ data[j+s]);
		d &= (*bits++);
		data[j+0] ^= d;
		data[j+s] ^= d;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x80, -0x18(%rbp)
jge 0x1aa9
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x18(%rbp), %ecx
addl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1a97
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl -0x20(%rbp), %edx
movslq %edx, %rdx
xorq (%rcx,%rdx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rax
andq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
xorq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
xorq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1a06
jmp 0x1a99
movl -0x20(%rbp), %eax
shll %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x19f3
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janmojzis[P]mcencrypt/benes.c
// Function: layer_in
static void layer_in(uint64_t data[2][64], uint64_t * bits, int lgs)
{
	int i, j, s;

	uint64_t d;

	s = 1 << lgs;

	for (i = 0; i < 64; i += s*2)
	for (j = i; j < i+s; j++)
	{

		d = (data[0][j+0] ^ data[0][j+s]);
		d &= (*bits++);
		data[0][j+0] ^= d;
		data[0][j+s] ^= d;

		d = (data[1][j+0] ^ data[1][j+s]);
		d &= (*bits++);
		data[1][j+0] ^= d;
		data[1][j+s] ^= d;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x40, -0x18(%rbp)
jge 0x1c10
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x18(%rbp), %ecx
addl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1bfe
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl -0x20(%rbp), %edx
movslq %edx, %rdx
xorq (%rcx,%rdx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rax
andq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
xorq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
xorq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movq 0x200(%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl -0x20(%rbp), %edx
movslq %edx, %rdx
xorq 0x200(%rcx,%rdx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rax
andq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
xorq 0x200(%rax,%rcx,8), %rdx
movq %rdx, 0x200(%rax,%rcx,8)
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
xorq 0x200(%rax,%rcx,8), %rdx
movq %rdx, 0x200(%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1ae3
jmp 0x1c00
movl -0x20(%rbp), %eax
shll %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x1ad3
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janmojzis[P]mcencrypt/chacha20.c
// Function: unpack32
static unsigned long unpack32(const unsigned char *x) {
    return
        (unsigned long) (x[0])                  \
    | (((unsigned long) (x[1])) << 8)           \
    | (((unsigned long) (x[2])) << 16)          \
    | (((unsigned long) (x[3])) << 24);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shlq $0x8, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shlq $0x10, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
shlq $0x18, %rcx
orq %rcx, %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/janmojzis[P]mcencrypt/chacha20.c
// Function: pack32
static void pack32(unsigned char *x, unsigned long u) {
    x[0] = u; u >>= 8;
    x[1] = u; u >>= 8;
    x[2] = u; u >>= 8;
    x[3] = u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/janmojzis[P]mcencrypt/checkfd.c
// Function: checkfd
int checkfd(int fd, short event) {

    struct pollfd p;
    char ch = 0;
    int r;
    struct stat st;

    if (fstat(fd, &st) != 0) return 0;

    p.fd = fd;
    p.events = event;
    p.revents = 0;
    for (;;) {
        r = poll(&p, 1, 0);
        if (r == -1) {
            if (errno == EAGAIN) continue;
            if (errno == EINTR) continue;
        }
        if (r != 1) return 0;
        if (r == 1) break;
    }
    if (p.revents) return 1;
    /* catch errno */
    if (event == POLLOUT)
        r = write(fd, &ch, 1);
    if (event == POLLIN)
        r = read(fd, &ch, 1);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movw %si, %ax
movl %edi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movb $0x0, -0x15(%rbp)
movl -0x8(%rbp), %edi
leaq -0xb0(%rbp), %rsi
callq 0x1110
cmpl $0x0, %eax
je 0x8729
movl $0x0, -0x4(%rbp)
jmp 0x87da
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movw -0xa(%rbp), %ax
movw %ax, -0x10(%rbp)
movw $0x0, -0xe(%rbp)
leaq -0x14(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x10d0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x8770
callq 0x1040
cmpl $0xb, (%rax)
jne 0x8762
jmp 0x873d
callq 0x1040
cmpl $0x4, (%rax)
jne 0x876e
jmp 0x873d
jmp 0x8770
cmpl $0x1, -0x1c(%rbp)
je 0x877f
movl $0x0, -0x4(%rbp)
jmp 0x87da
cmpl $0x1, -0x1c(%rbp)
jne 0x8787
jmp 0x8789
jmp 0x873d
cmpw $0x0, -0xe(%rbp)
je 0x8799
movl $0x1, -0x4(%rbp)
jmp 0x87da
movswl -0xa(%rbp), %eax
cmpl $0x4, %eax
jne 0x87b6
movl -0x8(%rbp), %edi
leaq -0x15(%rbp), %rsi
movl $0x1, %edx
callq 0x1060
movl %eax, -0x1c(%rbp)
movswl -0xa(%rbp), %eax
cmpl $0x1, %eax
jne 0x87d3
movl -0x8(%rbp), %edi
leaq -0x15(%rbp), %rsi
movl $0x1, %edx
callq 0x1090
movl %eax, -0x1c(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janmojzis[P]mcencrypt/controlbits.c
// Function: controlbits
void controlbits(unsigned char * out)
{
	int i;
	uint32_t pi[ (1 << GFBITS) ];
	unsigned char c[ (2*GFBITS - 1) * (1 << GFBITS) / 16 ];

	perm_gen(pi);

	for (i = 0; i < sizeof(c); i++)
		c[i] = 0;

	controlbitsfrompermutation(GFBITS, (1 << GFBITS), 1, 0, c, pi);

	for (i = 0; i < sizeof(c); i++)
		out[i] = c[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb210, %rsp           # imm = 0xB210
movq %rdi, -0x8(%rbp)
leaq -0x8010(%rbp), %rdi
callq 0x88a0
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq $0x3200, %rax           # imm = 0x3200
jae 0x8835
movslq -0xc(%rbp), %rax
movb $0x0, -0xb210(%rbp,%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8812
leaq -0xb210(%rbp), %r8
leaq -0x8010(%rbp), %r9
movl $0xd, %edi
movl $0x2000, %esi           # imm = 0x2000
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x89e0
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq $0x3200, %rax           # imm = 0x3200
jae 0x888d
movslq -0xc(%rbp), %rax
movb -0xb210(%rbp,%rax), %dl
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8860
addq $0xb210, %rsp           # imm = 0xB210
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janmojzis[P]mcencrypt/controlbits.c
// Function: perm_gen
static void perm_gen(uint32_t *out)
{
	int i, j, rep;

	uint64_t list[ 1 << GFBITS ];
	
	while(1)
	{
		randombytes((unsigned char *) list, sizeof(list));

		for (i = 0; i < (1 << GFBITS); i++)
		{
			list[i] <<= GFBITS;
			list[i] |= i;
		}

		rep = 0;
		for (i = 1; i < (1 << GFBITS); i++)
			for (j = 0; j < i; j++)
				if ((list[j] >> GFBITS) == (list[i] >> GFBITS))
					rep = 1;

		if (rep == 0) break;
	}

	sort_64b(1 << GFBITS, list);

	for (i = 0; i < (1 << GFBITS); i++)
		out[i] = list[i] & GFMASK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10020, %rsp          # imm = 0x10020
movq %rdi, -0x8(%rbp)
leaq -0x10020(%rbp), %rdi
movl $0x10000, %esi          # imm = 0x10000
callq 0xd3b0
movl $0x0, -0xc(%rbp)
cmpl $0x2000, -0xc(%rbp)     # imm = 0x2000
jge 0x890b
movslq -0xc(%rbp), %rax
movq -0x10020(%rbp,%rax,8), %rcx
shlq $0xd, %rcx
movq %rcx, -0x10020(%rbp,%rax,8)
movslq -0xc(%rbp), %rcx
movslq -0xc(%rbp), %rax
orq -0x10020(%rbp,%rax,8), %rcx
movq %rcx, -0x10020(%rbp,%rax,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x88c7
movl $0x0, -0x14(%rbp)
movl $0x1, -0xc(%rbp)
cmpl $0x2000, -0xc(%rbp)     # imm = 0x2000
jge 0x8977
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x896a
movslq -0x10(%rbp), %rax
movq -0x10020(%rbp,%rax,8), %rax
shrq $0xd, %rax
movslq -0xc(%rbp), %rcx
movq -0x10020(%rbp,%rcx,8), %rcx
shrq $0xd, %rcx
cmpq %rcx, %rax
jne 0x895d
movl $0x1, -0x14(%rbp)
jmp 0x895f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8929
jmp 0x896c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8919
cmpl $0x0, -0x14(%rbp)
jne 0x897f
jmp 0x8984
jmp 0x88af
leaq -0x10020(%rbp), %rsi
movl $0x2000, %edi           # imm = 0x2000
callq 0x9110
movl $0x0, -0xc(%rbp)
cmpl $0x2000, -0xc(%rbp)     # imm = 0x2000
jge 0x89cf
movslq -0xc(%rbp), %rax
movq -0x10020(%rbp,%rax,8), %rax
andq $0x1fff, %rax           # imm = 0x1FFF
movl %eax, %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x899c
addq $0x10020, %rsp          # imm = 0x10020
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janmojzis[P]mcencrypt/controlbits.c
// Function: sort_64b
static void sort_64b(int n, uint64_t x[n])
{
  if (n <= 1) return;
  sort_64b(n/2,x);
  sort_64b(n/2,x + n/2);
  merge_64b(n/2,x,1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x4(%rbp)
jg 0x9127
jmp 0x9182
movl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edi
movq -0x10(%rbp), %rsi
callq 0x9110
movl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edi
movq -0x10(%rbp), %rsi
movl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cltq
shlq $0x3, %rax
addq %rax, %rsi
callq 0x9110
movl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x9190
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)