LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_redis.c
// Function: redis_response_reader_create_array
static void *redis_response_reader_create_array(const redis_response_reader *reader, const redis_response_reader_task *task, int elements) {
  redis_response *resp, *parent;

  if ((resp = redis_response_reader_create_response(reader, REDIS_RESPONSE_ARRAY)) == NULL) {
    return NULL;
  }

  if (elements > 0) {
    if ((resp->payload.array.array = allocator_calloc(reader->allocator, elements * sizeof(redis_response *))) == NULL) {
      redis_response_reader_free_response(resp);
      return NULL;
    }
  }

  resp->payload.array.length = elements;
  if (task->parent) {
    parent = task->parent->obj;
    assert(parent->type == REDIS_RESPONSE_ARRAY);
    parent->payload.array.array[task->idx] = resp;
  }
  return resp;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0xc380
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0xc4da
movq $0x0, 0x30(%rsp)
jmp 0xc59d
cmpl $0x0, 0x1c(%rsp)
jle 0xc521
movq 0x28(%rsp), %rax
movq 0x88(%rax), %rdi
movslq 0x1c(%rsp), %rsi
shlq $0x3, %rsi
callq 0x52a0
movq 0x10(%rsp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0xc51f
movq 0x10(%rsp), %rdi
callq 0x5260
movq $0x0, 0x30(%rsp)
jmp 0xc59d
jmp 0xc521
movslq 0x1c(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0xc593
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x2, (%rax)
jne 0xc559
jmp 0xc578
leaq 0x1e71(%rip), %rdi      # 0xe3d1
leaq 0x1dc7(%rip), %rsi      # 0xe32e
movl $0xbc, %edx
leaq 0x210a(%rip), %rcx      # 0xe67d
callq 0x5100
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/pthread_mutex3.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	while (1) {
		pthread_mutex_lock(&mutex);
		val++;
		pthread_mutex_unlock(&mutex);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xf1d9(%rip), %rdi      # 0x121a0
callq 0x22a0
movq 0xf1f5(%rip), %rax      # 0x121c8
addq $0x1, %rax
movq %rax, 0xf1ea(%rip)      # 0x121c8
leaq 0xf1bb(%rip), %rdi      # 0x121a0
callq 0x2180
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x2fc0
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: main
global int main(int argc, char* argv[]) {
  readcmdline(argv);
  checkoptions();
  setdefaults();
  if (options & opt_re) {
    if (options & opt_bp)
      compute_bpres(); /* bandpass resonator	 */
    if (options & opt_bs)
      compute_notch(); /* bandstop resonator (notch) */
    if (options & opt_ap)
      compute_apres(); /* allpass resonator		 */
  } else {
    if (options & opt_pi) {
      prewarp();
      splane.poles[0] = 0.0;
      splane.zeros[0] = -TWOPI * warped_alpha1;
      splane.numpoles = splane.numzeros = 1;
    } else {
      compute_s();
      prewarp();
      normalize();
    }
    if (options & opt_z)
      compute_z_mzt();
    else
      compute_z_blt();
  }
  if (options & opt_Z)
    add_extra_zero();
  expandpoly();
  printresults(argv);
  return 0;
}

// Assembly:
subq $0x38, %rsp
movl $0x0, 0x34(%rsp)
movl %edi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1470
callq 0x18b0
callq 0x1ac0
movl 0xffe1(%rip), %eax      # 0x11320
andl $0x8, %eax
cmpl $0x0, %eax
je 0x138b
movl 0xffd3(%rip), %eax      # 0x11320
andl $0x80, %eax
cmpl $0x0, %eax
je 0x135c
callq 0x1b00
movl 0xffbe(%rip), %eax      # 0x11320
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x1371
callq 0x2010
movl 0xffa9(%rip), %eax      # 0x11320
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x1386
callq 0x20b0
jmp 0x143e
movl 0xff8f(%rip), %eax      # 0x11320
andl $0x10, %eax
cmpl $0x0, %eax
je 0x1411
callq 0x2160
leaq 0x18(%rsp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x4ea0
movq 0x18(%rsp), %rax
movq %rax, 0x7f26(%rip)      # 0x92e0
movq 0x20(%rsp), %rax
movq %rax, 0x7f22(%rip)      # 0x92e8
movsd 0x4c3a(%rip), %xmm0     # 0x6008
mulsd 0xff52(%rip), %xmm0     # 0x11328
leaq 0x8(%rsp), %rdi
xorps %xmm1, %xmm1
callq 0x4ea0
movq 0x8(%rsp), %rax
movq %rax, 0x9ef1(%rip)      # 0xb2e0
movq 0x10(%rsp), %rax
movq %rax, 0x9eed(%rip)      # 0xb2e8
movl $0x1, 0xbedf(%rip)      # 0xd2e4
movl $0x1, 0xbed1(%rip)      # 0xd2e0
jmp 0x1420
callq 0x21f0
callq 0x2160
callq 0x2620
movl 0xfefa(%rip), %eax      # 0x11320
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x1437
callq 0x32c0
jmp 0x143c
callq 0x3400
jmp 0x143e
movl 0xfedc(%rip), %eax      # 0x11320
andl $0x10000, %eax          # imm = 0x10000
cmpl $0x0, %eax
je 0x1453
callq 0x35a0
callq 0x3700
movq 0x28(%rsp), %rdi
callq 0x3af0
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: compute_notch()
static void compute_notch() { /* compute Z-plane pole & zero positions for
                                 bandstop resonator (notch filter) */
  compute_bpres();            /* iterate to place poles */
  double theta = TWOPI * raw_alpha1;
  complex zz = expj(theta); /* place zeros exactly */
  zplane.zeros[0] = zz;
  zplane.zeros[1] = cconj(zz);
}

// Assembly:
subq $0x38, %rsp
callq 0x1b00
movsd 0x3fef(%rip), %xmm0     # 0x6010
mulsd 0xf317(%rip), %xmm0     # 0x11340
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
callq 0x5750
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0xd296(%rip)      # 0xf2e8
movq 0x28(%rsp), %rax
movq %rax, 0xd292(%rip)      # 0xf2f0
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x4f60
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0xd25f(%rip)      # 0xf2f8
movq 0x18(%rsp), %rax
movq %rax, 0xd25b(%rip)      # 0xf300
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: compute_apres()
static void compute_apres() { /* compute Z-plane pole & zero positions for
                                 allpass resonator */
  compute_bpres();            /* iterate to place poles */
  zplane.zeros[0] = reflect(zplane.poles[0]);
  zplane.zeros[1] = reflect(zplane.poles[1]);
}

// Assembly:
subq $0x48, %rsp
callq 0x1b00
movq 0xb228(%rip), %rax      # 0xd2e8
movq %rax, 0x28(%rsp)
movq 0xb224(%rip), %rax      # 0xd2f0
movq %rax, 0x30(%rsp)
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
callq 0x4360
movsd %xmm0, 0x38(%rsp)
movsd %xmm1, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0xd1ee(%rip)      # 0xf2e8
movq 0x40(%rsp), %rax
movq %rax, 0xd1ea(%rip)      # 0xf2f0
movq 0xb1eb(%rip), %rax      # 0xd2f8
movq %rax, 0x8(%rsp)
movq 0xb1e7(%rip), %rax      # 0xd300
movq %rax, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x4360
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0xd1b1(%rip)      # 0xf2f8
movq 0x20(%rsp), %rax
movq %rax, 0xd1ad(%rip)      # 0xf300
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: prewarp()
static void
prewarp() { /* for bilinear transform, perform pre-warp on alpha values */
  if (options & (opt_w | opt_z)) {
    warped_alpha1 = raw_alpha1;
    warped_alpha2 = raw_alpha2;
  } else {
    warped_alpha1 = tan(PI * raw_alpha1) / PI;
    warped_alpha2 = tan(PI * raw_alpha2) / PI;
  }
}

// Assembly:
pushq %rax
movl 0xf1b9(%rip), %eax      # 0x11320
andl $0xc000, %eax           # imm = 0xC000
cmpl $0x0, %eax
je 0x2193
movsd 0xf1c7(%rip), %xmm0     # 0x11340
movsd %xmm0, 0xf1a7(%rip)     # 0x11328
movsd 0xf1bf(%rip), %xmm0     # 0x11348
movsd %xmm0, 0xf1e7(%rip)     # 0x11378
jmp 0x21e5
movsd 0x3e8d(%rip), %xmm0     # 0x6028
mulsd 0xf19d(%rip), %xmm0     # 0x11340
callq 0x1090
movsd 0x3e78(%rip), %xmm1     # 0x6028
divsd %xmm1, %xmm0
movsd %xmm0, 0xf16c(%rip)     # 0x11328
movsd 0x3e64(%rip), %xmm0     # 0x6028
mulsd 0xf17c(%rip), %xmm0     # 0x11348
callq 0x1090
movsd 0x3e4f(%rip), %xmm1     # 0x6028
divsd %xmm1, %xmm0
movsd %xmm0, 0xf193(%rip)     # 0x11378
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: compute_z_mzt()
static void compute_z_mzt() /* given S-plane poles & zeros, compute Z-plane
                               poles & zeros, by matched z-transform */
{
  int i;
  zplane.numpoles = splane.numpoles;
  zplane.numzeros = splane.numzeros;
  for (i = 0; i < zplane.numpoles; i++)
    zplane.poles[i] = cexp(splane.poles[i]);
  for (i = 0; i < zplane.numzeros; i++)
    zplane.zeros[i] = cexp(splane.zeros[i]);
}

// Assembly:
subq $0x48, %rsp
movl 0xa016(%rip), %eax      # 0xd2e0
movl %eax, 0xe018(%rip)      # 0x112e8
movl 0xa00e(%rip), %eax      # 0xd2e4
movl %eax, 0xe010(%rip)      # 0x112ec
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
cmpl 0xdffa(%rip), %eax      # 0x112e8
jge 0x3362
movslq 0x44(%rsp), %rcx
leaq 0x5fe4(%rip), %rax      # 0x92e0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
callq 0x56e0
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x38(%rsp)
movslq 0x44(%rsp), %rcx
leaq 0x9fab(%rip), %rax      # 0xd2e8
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x30(%rsp), %rcx
movq %rcx, (%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x32e4
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
cmpl 0xdf78(%rip), %eax      # 0x112ec
jge 0x33f5
movslq 0x44(%rsp), %rcx
leaq 0x5f5e(%rip), %rax      # 0x92e0
addq $0x2000, %rax           # imm = 0x2000
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x56e0
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x18(%rsp)
movslq 0x44(%rsp), %rcx
leaq 0x9f21(%rip), %rax      # 0xd2e8
addq $0x2000, %rax           # imm = 0x2000
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x336a
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: compute_z_blt()
static void compute_z_blt() /* given S-plane poles & zeros, compute Z-plane
                               poles & zeros, by bilinear transform */
{
  int i;
  zplane.numpoles = splane.numpoles;
  zplane.numzeros = splane.numzeros;
  for (i = 0; i < zplane.numpoles; i++)
    zplane.poles[i] = blt(splane.poles[i]);
  for (i = 0; i < zplane.numzeros; i++)
    zplane.zeros[i] = blt(splane.zeros[i]);
  while (zplane.numzeros < zplane.numpoles)
    zplane.zeros[zplane.numzeros++] = -1.0;
}

// Assembly:
subq $0x58, %rsp
movl 0x9ed6(%rip), %eax      # 0xd2e0
movl %eax, 0xded8(%rip)      # 0x112e8
movl 0x9ece(%rip), %eax      # 0xd2e4
movl %eax, 0xded0(%rip)      # 0x112ec
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
cmpl 0xdeba(%rip), %eax      # 0x112e8
jge 0x34a2
movslq 0x54(%rsp), %rcx
leaq 0x5ea4(%rip), %rax      # 0x92e0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
callq 0x4260
movsd %xmm0, 0x40(%rsp)
movsd %xmm1, 0x48(%rsp)
movslq 0x54(%rsp), %rcx
leaq 0x9e6b(%rip), %rax      # 0xd2e8
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x40(%rsp), %rcx
movq %rcx, (%rax)
movq 0x48(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x3424
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
cmpl 0xde38(%rip), %eax      # 0x112ec
jge 0x353b
movslq 0x54(%rsp), %rcx
leaq 0x5e1a(%rip), %rax      # 0x92e0
addq $0x2000, %rax           # imm = 0x2000
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x4260
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x28(%rsp)
movslq 0x54(%rsp), %rcx
leaq 0x9ddb(%rip), %rax      # 0xd2e8
addq $0x2000, %rax           # imm = 0x2000
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x34aa
jmp 0x353d
movl 0xdda9(%rip), %eax      # 0x112ec
cmpl 0xdd9f(%rip), %eax      # 0x112e8
jge 0x3598
movq %rsp, %rdi
movsd 0x2ac2(%rip), %xmm0     # 0x6018
xorps %xmm1, %xmm1
callq 0x4ea0
movl 0xdd88(%rip), %eax      # 0x112ec
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0xdd7d(%rip)      # 0x112ec
movslq %eax, %rcx
leaq 0x9d6f(%rip), %rax      # 0xd2e8
addq $0x2000, %rax           # imm = 0x2000
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rsp), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x353d
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: add_extra_zero()
static void add_extra_zero() {
  if (zplane.numzeros + 2 > MAXPZ) {
    fprintf(stderr, "mkfilter: too many zeros; can't do -Z\n");
    exit(1);
  }
  double theta = TWOPI * raw_alphaz;
  complex zz = expj(theta);
  zplane.zeros[zplane.numzeros++] = zz;
  zplane.zeros[zplane.numzeros++] = cconj(zz);
  while (zplane.numpoles < zplane.numzeros)
    zplane.poles[zplane.numpoles++] = 0.0; /* ensure causality */
}

// Assembly:
subq $0x48, %rsp
movl 0xdd42(%rip), %eax      # 0x112ec
addl $0x2, %eax
cmpl $0x200, %eax            # imm = 0x200
jle 0x35d6
movq 0x5a25(%rip), %rax      # 0x8fe0
movq (%rax), %rdi
leaq 0x3186(%rip), %rsi      # 0x674b
movb $0x0, %al
callq 0x1140
movl $0x1, %edi
callq 0x10e0
movsd 0x2a32(%rip), %xmm0     # 0x6010
mulsd 0xdd72(%rip), %xmm0     # 0x11358
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
callq 0x5750
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x38(%rsp)
movl 0xdce3(%rip), %eax      # 0x112ec
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0xdcd8(%rip)      # 0x112ec
movslq %eax, %rcx
leaq 0x9cca(%rip), %rax      # 0xd2e8
addq $0x2000, %rax           # imm = 0x2000
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x30(%rsp), %rcx
movq %rcx, (%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x4f60
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x28(%rsp)
movl 0xdc79(%rip), %eax      # 0x112ec
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0xdc6e(%rip)      # 0x112ec
movslq %eax, %rcx
leaq 0x9c60(%rip), %rax      # 0xd2e8
addq $0x2000, %rax           # imm = 0x2000
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0xdc3c(%rip), %eax      # 0x112e8
cmpl 0xdc3a(%rip), %eax      # 0x112ec
jge 0x36f6
movq %rsp, %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x4ea0
movl 0xdc20(%rip), %eax      # 0x112e8
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0xdc15(%rip)      # 0x112e8
movslq %eax, %rcx
leaq 0x9c0b(%rip), %rax      # 0xd2e8
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rsp), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x36a6
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: optbit(char)
static uint optbit(char c) {
  switch (c) {
    default:
      return 0;
    case 'a':
      return opt_a;
    case 'A':
      return opt_A;
    case 'R':
      return opt_R;
    case 'l':
      return opt_l;
    case 'o':
      return opt_o;
    case 'p':
      return opt_p;
    case 'w':
      return opt_w;
    case 'z':
      return opt_z;
    case 'Z':
      return opt_Z;
  }
}

// Assembly:
movb %dil, %al
movb %al, -0x5(%rsp)
movsbl -0x5(%rsp), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rsp)
subl $0x39, %eax
ja 0x4110
movq -0x10(%rsp), %rax
leaq 0x1f79(%rip), %rcx      # 0x6080
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rsp)
jmp 0x4172
movl $0x400, -0x4(%rsp)      # imm = 0x400
jmp 0x4172
movl $0x40000, -0x4(%rsp)    # imm = 0x40000
jmp 0x4172
movl $0x20000, -0x4(%rsp)    # imm = 0x20000
jmp 0x4172
movl $0x800, -0x4(%rsp)      # imm = 0x800
jmp 0x4172
movl $0x1000, -0x4(%rsp)     # imm = 0x1000
jmp 0x4172
movl $0x2000, -0x4(%rsp)     # imm = 0x2000
jmp 0x4172
movl $0x4000, -0x4(%rsp)     # imm = 0x4000
jmp 0x4172
movl $0x8000, -0x4(%rsp)     # imm = 0x8000
jmp 0x4172
movl $0x10000, -0x4(%rsp)    # imm = 0x10000
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: opterror(char const*, int, int)
static void opterror(const char* msg, int p1, int p2) {
  fprintf(stderr, "mkfilter: ");
  fprintf(stderr, msg, p1, p2);
  putc('\n', stderr);
  optsok = false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x4e48(%rip), %rax      # 0x8fe0
movq (%rax), %rdi
leaq 0x24c2(%rip), %rsi      # 0x6664
movb $0x0, %al
callq 0x1140
movq 0x4e30(%rip), %rax      # 0x8fe0
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
movb $0x0, %al
callq 0x1140
movq 0x4e12(%rip), %rax      # 0x8fe0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x1190
movb $0x0, 0xd18e(%rip)      # 0x11370
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: choosepole(complex)
static void choosepole(complex z) {
  if (z.re < 0.0) {
    if (polemask & 1)
      splane.poles[splane.numpoles++] = z;
    polemask >>= 1;
  }
}

// Assembly:
movsd %xmm0, -0x10(%rsp)
movsd %xmm1, -0x8(%rsp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rsp), %xmm0
jbe 0x4256
movl 0xd123(%rip), %eax      # 0x11330
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4248
movl 0x90c5(%rip), %eax      # 0xd2e0
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x90ba(%rip)      # 0xd2e0
movslq %eax, %rcx
leaq 0x50b0(%rip), %rax      # 0x92e0
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x10(%rsp), %rcx
movq %rcx, (%rax)
movq -0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0xd0e2(%rip), %eax      # 0x11330
shrl %eax
movl %eax, 0xd0da(%rip)      # 0x11330
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: expand(complex*, int, complex*)
static void expand(
    complex pz[],
    int npz,
    complex
        coeffs[]) { /* compute product of poles or zeros as a polynomial of z */
  int i;
  coeffs[0] = 1.0;
  for (i = 0; i < npz; i++)
    coeffs[i + 1] = 0.0;
  for (i = 0; i < npz; i++)
    multin(pz[i], npz, coeffs);
  /* check computed coeffs of z^k are all real */
  for (i = 0; i < npz + 1; i++) {
    if (fabs(coeffs[i].im) > EPS) {
      fprintf(stderr,
              "mkfilter: coeff of z^%d is not real; poles/zeros are not "
              "complex conjugates\n",
              i);
      exit(1);
    }
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
leaq 0x28(%rsp), %rdi
movsd 0x1c21(%rip), %xmm0     # 0x6020
xorps %xmm1, %xmm1
callq 0x4ea0
movq 0x40(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0x4473
leaq 0x18(%rsp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x4ea0
movq 0x40(%rsp), %rax
movl 0x3c(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x4425
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0x44ce
movq 0x50(%rsp), %rax
movslq 0x3c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movl 0x4c(%rsp), %edi
movq 0x40(%rsp), %rsi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x4550
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x447b
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl 0x4c(%rsp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4549
movq 0x40(%rsp), %rax
movslq 0x3c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movaps 0x1b5e(%rip), %xmm1     # 0x6060
pand %xmm1, %xmm0
movsd 0x1b2a(%rip), %xmm1     # 0x6038
ucomisd %xmm1, %xmm0
jbe 0x453a
movq 0x4ac5(%rip), %rax      # 0x8fe0
movq (%rax), %rdi
movl 0x3c(%rsp), %edx
leaq 0x21d5(%rip), %rsi      # 0x66fe
movb $0x0, %al
callq 0x1140
movl $0x1, %edi
callq 0x10e0
jmp 0x453c
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x44d6
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: multin(complex, int, complex*)
static void multin(complex w,
                   int npz,
                   complex coeffs[]) { /* multiply factor (z-w) into coeffs */
  complex nw = -w;
  for (int i = npz; i >= 1; i--)
    coeffs[i] = (nw * coeffs[i]) + coeffs[i - 1];
  coeffs[0] = nw * coeffs[0];
}

// Assembly:
subq $0xc8, %rsp
movsd %xmm0, 0xb8(%rsp)
movsd %xmm1, 0xc0(%rsp)
movl %edi, 0xb4(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x90(%rsp)
movsd 0x88(%rsp), %xmm0
movsd 0x90(%rsp), %xmm1
callq 0x5240
movsd %xmm0, 0x98(%rsp)
movsd %xmm1, 0xa0(%rsp)
movl 0xb4(%rsp), %eax
movl %eax, 0x84(%rsp)
cmpl $0x1, 0x84(%rsp)
jl 0x46dc
movq 0x98(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0xa8(%rsp), %rax
movslq 0x84(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0x40(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x48(%rsp)
movsd 0x50(%rsp), %xmm0
movsd 0x58(%rsp), %xmm1
movsd 0x40(%rsp), %xmm2
movsd 0x48(%rsp), %xmm3
callq 0x57a0
movsd %xmm0, 0x60(%rsp)
movsd %xmm1, 0x68(%rsp)
movq 0xa8(%rsp), %rax
movl 0x84(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movsd 0x60(%rsp), %xmm0
movsd 0x68(%rsp), %xmm1
movsd 0x30(%rsp), %xmm2
movsd 0x38(%rsp), %xmm3
callq 0x5150
movsd %xmm0, 0x70(%rsp)
movsd %xmm1, 0x78(%rsp)
movq 0xa8(%rsp), %rax
movslq 0x84(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x70(%rsp), %rcx
movq %rcx, (%rax)
movq 0x78(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x84(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x84(%rsp)
jmp 0x45cf
movq 0x98(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xa8(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd (%rsp), %xmm2
movsd 0x8(%rsp), %xmm3
callq 0x57a0
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x28(%rsp)
movq 0xa8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0xc8, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: printfilter()
static void printfilter() {
  printf("raw alpha1    = %14.10f\n", raw_alpha1);
  printf("raw alpha2    = %14.10f\n", raw_alpha2);
  unless(options & (opt_re | opt_w | opt_z)) {
    printf("warped alpha1 = %14.10f\n", warped_alpha1);
    printf("warped alpha2 = %14.10f\n", warped_alpha2);
  }
  printgain("dc    ", dc_gain);
  printgain("centre", fc_gain);
  printgain("hf    ", hf_gain);
  putchar('\n');
  unless(options & opt_re) printrat_s();
  printrat_z();
  printrecurrence();
}

// Assembly:
subq $0x38, %rsp
movsd 0xcae4(%rip), %xmm0     # 0x11340
leaq 0x1f42(%rip), %rdi      # 0x67a5
movb $0x1, %al
callq 0x1030
movsd 0xcad6(%rip), %xmm0     # 0x11348
leaq 0x1f45(%rip), %rdi      # 0x67be
movb $0x1, %al
callq 0x1030
movl 0xca9a(%rip), %eax      # 0x11320
andl $0xc008, %eax           # imm = 0xC008
cmpl $0x0, %eax
jne 0x48bc
movsd 0xca90(%rip), %xmm0     # 0x11328
leaq 0x1f38(%rip), %rdi      # 0x67d7
movb $0x1, %al
callq 0x1030
movsd 0xcaca(%rip), %xmm0     # 0x11378
leaq 0x1f3b(%rip), %rdi      # 0x67f0
movb $0x1, %al
callq 0x1030
movq 0xca2d(%rip), %rax      # 0x112f0
movq %rax, 0x28(%rsp)
movq 0xca29(%rip), %rax      # 0x112f8
movq %rax, 0x30(%rsp)
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
leaq 0x1f22(%rip), %rdi      # 0x6809
callq 0x4980
movq 0xca0d(%rip), %rax      # 0x11300
movq %rax, 0x18(%rsp)
movq 0xca09(%rip), %rax      # 0x11308
movq %rax, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
leaq 0x1ef9(%rip), %rdi      # 0x6810
callq 0x4980
movq 0xc9ed(%rip), %rax      # 0x11310
movq %rax, 0x8(%rsp)
movq 0xc9e9(%rip), %rax      # 0x11318
movq %rax, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
leaq 0x1ed0(%rip), %rdi      # 0x6817
callq 0x4980
movl $0xa, %edi
callq 0x1110
movl 0xc9c4(%rip), %eax      # 0x11320
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x4969
callq 0x4a40
callq 0x4a90
callq 0x4ae0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: printgain(char const*, complex)
static void printgain(const char* str, complex gain) {
  double r = hypot(gain);
  printf("gain at %s:   mag = %15.9e", str, r);
  if (r > EPS)
    printf("   phase = %14.10f pi", atan2(gain) / PI);
  putchar('\n');
}

// Assembly:
subq $0x48, %rsp
movsd %xmm0, 0x38(%rsp)
movsd %xmm1, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x51b0
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rsi
movsd 0x28(%rsp), %xmm0
leaq 0x1e4c(%rip), %rdi      # 0x681e
movb $0x1, %al
callq 0x1030
movsd 0x28(%rsp), %xmm0
movsd 0x1651(%rip), %xmm1     # 0x6038
ucomisd %xmm1, %xmm0
jbe 0x4a2c
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x52b0
movsd 0x160e(%rip), %xmm1     # 0x6028
divsd %xmm1, %xmm0
leaq 0x1e14(%rip), %rdi      # 0x6839
movb $0x1, %al
callq 0x1030
movl $0xa, %edi
callq 0x1110
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: printrat_s()
static void printrat_s() /* print S-plane poles and zeros */
{
  printf("S-plane zeros:\n");
  printpz(splane.zeros, splane.numzeros);
  printf("S-plane poles:\n");
  printpz(splane.poles, splane.numpoles);
}

// Assembly:
pushq %rax
leaq 0x1e07(%rip), %rdi      # 0x684f
movb $0x0, %al
callq 0x1030
movl 0x888f(%rip), %esi      # 0xd2e4
leaq 0x4884(%rip), %rdi      # 0x92e0
addq $0x2000, %rdi           # imm = 0x2000
callq 0x4c70
leaq 0x1df0(%rip), %rdi      # 0x685f
movb $0x0, %al
callq 0x1030
movl 0x8864(%rip), %esi      # 0xd2e0
leaq 0x485d(%rip), %rdi      # 0x92e0
callq 0x4c70
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: printrat_z()
static void printrat_z() /* print Z-plane poles and zeros */
{
  printf("Z-plane zeros:\n");
  printpz(zplane.zeros, zplane.numzeros);
  printf("Z-plane poles:\n");
  printpz(zplane.poles, zplane.numpoles);
}

// Assembly:
pushq %rax
leaq 0x1df5(%rip), %rdi      # 0x688d
movb $0x0, %al
callq 0x1030
movl 0xc847(%rip), %esi      # 0x112ec
leaq 0x883c(%rip), %rdi      # 0xd2e8
addq $0x2000, %rdi           # imm = 0x2000
callq 0x4c70
leaq 0x1dde(%rip), %rdi      # 0x689d
movb $0x0, %al
callq 0x1030
movl 0xc81c(%rip), %esi      # 0x112e8
leaq 0x8815(%rip), %rdi      # 0xd2e8
callq 0x4c70
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: printrecurrence()
static void printrecurrence() /* given (real) Z-plane poles & zeros, compute &
                                 print recurrence relation */
{
  printf("Recurrence relation:\n");
  printf("y[n] = ");
  int i;
  for (i = 0; i < zplane.numzeros + 1; i++) {
    if (i > 0)
      printf("     + ");
    double x = xcoeffs[i];
    double f = fmod(fabs(x), 1.0);
    const char* fmt = (f < EPS || f > 1.0 - EPS) ? "%3g" : "%14.10f";
    putchar('(');
    printf(fmt, x);
    printf(" * x[n-%2d])\n", zplane.numzeros - i);
  }
  putchar('\n');
  for (i = 0; i < zplane.numpoles; i++) {
    printf("     + (%14.10f * y[n-%2d])\n", ycoeffs[i], zplane.numpoles - i);
  }
  putchar('\n');
}

// Assembly:
subq $0x28, %rsp
leaq 0x1dc2(%rip), %rdi      # 0x68ad
movb $0x0, %al
callq 0x1030
leaq 0x1dca(%rip), %rdi      # 0x68c3
movb $0x0, %al
callq 0x1030
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl 0xc7da(%rip), %ecx      # 0x112ec
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4bfe
cmpl $0x0, 0x24(%rsp)
jle 0x4b32
leaq 0x1da0(%rip), %rdi      # 0x68cb
movb $0x0, %al
callq 0x1030
movslq 0x24(%rsp), %rcx
leaq 0xc842(%rip), %rax      # 0x11380
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movaps 0x150a(%rip), %xmm1     # 0x6060
pand %xmm1, %xmm0
movsd 0x14be(%rip), %xmm1     # 0x6020
callq 0x1100
movsd %xmm0, 0x10(%rsp)
movb $0x1, %al
movsd 0x14c1(%rip), %xmm0     # 0x6038
ucomisd 0x10(%rsp), %xmm0
movb %al, 0x7(%rsp)
ja 0x4b9c
movsd 0x10(%rsp), %xmm0
movsd 0x14bf(%rip), %xmm1     # 0x6050
ucomisd %xmm1, %xmm0
seta %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %dl
leaq 0x1cde(%rip), %rax      # 0x6885
leaq 0x1d25(%rip), %rcx      # 0x68d3
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x8(%rsp)
movl $0x28, %edi
callq 0x1110
movq 0x8(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
movb $0x1, %al
callq 0x1030
movl 0xc710(%rip), %esi      # 0x112ec
subl 0x24(%rsp), %esi
leaq 0x1cf0(%rip), %rdi      # 0x68d7
movb $0x0, %al
callq 0x1030
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x4b08
movl $0xa, %edi
callq 0x1110
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0xc6ce(%rip), %eax      # 0x112e8
jge 0x4c52
movslq 0x24(%rsp), %rcx
leaq 0xd768(%rip), %rax      # 0x12390
movsd (%rax,%rcx,8), %xmm0
movl 0xc6b5(%rip), %esi      # 0x112e8
subl 0x24(%rsp), %esi
leaq 0x1ca7(%rip), %rdi      # 0x68e5
movb $0x1, %al
callq 0x1030
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x4c10
movl $0xa, %edi
callq 0x1110
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: printpz(complex*, int)
static void printpz(complex* pzvec, int num) {
  int n1 = 0;
  while (n1 < num) {
    putchar('\t');
    prcomplex(pzvec[n1]);
    int n2 = n1 + 1;
    while (n2 < num && pzvec[n2] == pzvec[n1])
      n2++;
    if (n2 - n1 > 1)
      printf("\t%d times", n2 - n1);
    putchar('\n');
    n1 = n2;
  }
  putchar('\n');
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl $0x0, 0x48(%rsp)
movl 0x48(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0x4da4
movl $0x9, %edi
callq 0x1110
movq 0x50(%rsp), %rax
movslq 0x48(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movsd 0x38(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
callq 0x4dc0
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %ecx
xorl %eax, %eax
cmpl 0x4c(%rsp), %ecx
movb %al, 0xf(%rsp)
jge 0x4d50
movq 0x50(%rsp), %rax
movslq 0x34(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rax
movslq 0x48(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movsd 0x18(%rsp), %xmm3
callq 0x52e0
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x4d5a
jmp 0x4d6a
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x4cdb
movl 0x34(%rsp), %eax
subl 0x48(%rsp), %eax
cmpl $0x1, %eax
jle 0x4d8d
movl 0x34(%rsp), %esi
subl 0x48(%rsp), %esi
leaq 0x1ae9(%rip), %rdi      # 0x686f
movb $0x0, %al
callq 0x1030
movl $0xa, %edi
callq 0x1110
movl 0x34(%rsp), %eax
movl %eax, 0x48(%rsp)
jmp 0x4c85
movl $0xa, %edi
callq 0x1110
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cirocosta[P]stress/src/socket-backlog.c
// Function: str_echo
void
str_echo(int sockfd)
{
	ssize_t rn;
	char buf[MAXLINE];

	while ((rn = read(sockfd, buf, MAXLINE)) > 0) {
		_STRESS_MUST(rn >= 0, "unexpected error reading");
		_STRESS_MUST(stress_write_n(sockfd, buf, rn) > 0,
		             "couldn't write back data sent");
	}
}

// Assembly:
subq $0x1018, %rsp           # imm = 0x1018
movl %edi, 0x1014(%rsp)
movl 0x1014(%rsp), %edi
movq %rsp, %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x10f0
movq %rax, 0x1008(%rsp)
cmpq $0x0, %rax
jle 0x1b2d
jmp 0x1946
cmpq $0x0, 0x1008(%rsp)
jge 0x1a2b
movq 0x269c(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x6d2(%rip), %rsi       # 0x2038
movb $0x0, %al
callq 0x1110
movq 0x2684(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x6c0(%rip), %rsi       # 0x203e
movb $0x0, %al
callq 0x1110
movq 0x266c(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x78a(%rip), %rsi       # 0x2120
movb $0x0, %al
callq 0x1110
movq 0x2654(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x6b7(%rip), %rsi       # 0x2065
movb $0x0, %al
callq 0x1110
movq 0x263c(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x6a2(%rip), %rsi       # 0x2068
leaq 0x76c(%rip), %rdx       # 0x2139
movb $0x0, %al
callq 0x1110
movq 0x261d(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x69f(%rip), %rsi       # 0x2084
movl $0x18, %edx
movb $0x0, %al
callq 0x1110
movq 0x2600(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x664(%rip), %rsi       # 0x2066
movb $0x0, %al
callq 0x1110
movq 0x25e8(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x677(%rip), %rsi       # 0x2091
movb $0x0, %al
callq 0x1110
movl $0x1, %edi
callq 0x1170
jmp 0x1a2d
jmp 0x1a2f
movl 0x1014(%rsp), %edi
movq %rsp, %rsi
movq 0x1008(%rsp), %rdx
callq 0x17b0
cmpq $0x0, %rax
jg 0x1b26
movq 0x25a1(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x5d7(%rip), %rsi       # 0x2038
movb $0x0, %al
callq 0x1110
movq 0x2589(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x5c5(%rip), %rsi       # 0x203e
movb $0x0, %al
callq 0x1110
movq 0x2571(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x6bd(%rip), %rsi       # 0x214e
movb $0x0, %al
callq 0x1110
movq 0x2559(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x5bc(%rip), %rsi       # 0x2065
movb $0x0, %al
callq 0x1110
movq 0x2541(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x5a7(%rip), %rsi       # 0x2068
leaq 0x671(%rip), %rdx       # 0x2139
movb $0x0, %al
callq 0x1110
movq 0x2522(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x5a4(%rip), %rsi       # 0x2084
movl $0x1a, %edx
movb $0x0, %al
callq 0x1110
movq 0x2505(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x569(%rip), %rsi       # 0x2066
movb $0x0, %al
callq 0x1110
movq 0x24ed(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x57c(%rip), %rsi       # 0x2091
movb $0x0, %al
callq 0x1110
movl $0x1, %edi
callq 0x1170
jmp 0x1b28
jmp 0x191e
addq $0x1018, %rsp           # imm = 0x1018
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cirocosta[P]stress/src/socket-backlog.c
// Function: main
int
main(int argc, char** argv)
{
	stress_args_t args = { .b = 0 };

	int listen_fd;
	int conn_fd;
	pid_t child_pid;

	socklen_t client_len;
	struct sockaddr_in client_addr;
	struct sockaddr_in server_addr;

	signal(SIGINT, terminate);
	setbuf(stdout, NULL);

	stress_parse_args(argc, argv, &args);

	listen_fd = socket(AF_INET, SOCK_STREAM, 0);

	memset(&server_addr, sizeof(server_addr), 0);
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	server_addr.sin_port = htons(1337);

	bind(listen_fd, (struct sockaddr*)&server_addr, sizeof(server_addr));
	listen(listen_fd, LISTEN_BACKLOG);

	for (;;) {
		client_len = sizeof(client_addr);
		conn_fd = accept(
		  listen_fd, (struct sockaddr*)&client_addr, &client_len);

		if ((child_pid = fork()) == 0) {
			close(listen_fd);
			str_echo(conn_fd);
			exit(0);
		}

		close(conn_fd);
	}

	return 0;
}

// Assembly:
subq $0x2058, %rsp           # imm = 0x2058
movl $0x0, 0x2054(%rsp)
movl %edi, 0x2050(%rsp)
movq %rsi, 0x2048(%rsp)
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
movl $0x2008, %edx           # imm = 0x2008
callq 0x10d0
movl $0x2, %edi
leaq -0x4e(%rip), %rsi       # 0x1b40
callq 0x1100
movq 0x242e(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1090
movl 0x2050(%rsp), %edi
movq 0x2048(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x1350
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x11b0
movl %eax, 0x3c(%rsp)
leaq 0x10(%rsp), %rdi
movl $0x10, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x10d0
movw $0x2, 0x10(%rsp)
xorl %edi, %edi
callq 0x10c0
movl %eax, 0x14(%rsp)
movl $0x539, %edi            # imm = 0x539
callq 0x10a0
movw %ax, 0x12(%rsp)
movl 0x3c(%rsp), %edi
leaq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
movl $0x10, %edx
callq 0x1130
movl 0x3c(%rsp), %edi
movl $0x400, %esi            # imm = 0x400
callq 0x1120
movl $0x10, 0x30(%rsp)
movl 0x3c(%rsp), %edi
leaq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x1150
movl %eax, 0x38(%rsp)
callq 0x1190
movl %eax, 0x34(%rsp)
cmpl $0x0, %eax
jne 0x1c81
movl 0x3c(%rsp), %edi
callq 0x10e0
movl 0x38(%rsp), %edi
callq 0x1910
xorl %edi, %edi
callq 0x1170
movl 0x38(%rsp), %edi
callq 0x10e0
jmp 0x1c33
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/donna/dut_donna.c
// Function: do_one_computation
uint8_t do_one_computation(uint8_t *data) {
  uint8_t out[32] = {0};
  const uint8_t secret[32] = {1,2,3};
  uint8_t ret = 0;
  const uint8_t basepoint[32] = {9};
  curve25519_donna(out, data, basepoint);
  ret ^= out[0];
  return ret;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1080
movq 0x45ef(%rip), %rax      # 0x62d0
movq %rax, 0x30(%rsp)
movq 0x45eb(%rip), %rax      # 0x62d8
movq %rax, 0x38(%rsp)
movq 0x45e7(%rip), %rax      # 0x62e0
movq %rax, 0x40(%rsp)
movq 0x45e3(%rip), %rax      # 0x62e8
movq %rax, 0x48(%rsp)
movb $0x0, 0x2f(%rsp)
movq 0x45da(%rip), %rax      # 0x62f0
movq %rax, (%rsp)
movq 0x45d7(%rip), %rax      # 0x62f8
movq %rax, 0x8(%rsp)
movq 0x45d3(%rip), %rax      # 0x6300
movq %rax, 0x10(%rsp)
movq 0x45cf(%rip), %rax      # 0x6308
movq %rax, 0x18(%rsp)
leaq 0x50(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq %rsp, %rdx
callq 0x21e0
movzbl 0x50(%rsp), %ecx
movzbl 0x2f(%rsp), %eax
xorl %ecx, %eax
movb %al, 0x2f(%rsp)
movb 0x2f(%rsp), %al
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/donna/dut_donna.c
// Function: main
int main(int argc, char **argv)
{
  (void)argc;
  (void)argv;

  dudect_config_t config = {
     .chunk_size = 32,
     .number_measurements = 1e5,
  };
  dudect_ctx_t ctx;

  dudect_init(&ctx, &config);

  dudect_state_t state = DUDECT_NO_LEAKAGE_EVIDENCE_YET;
  while (state == DUDECT_NO_LEAKAGE_EVIDENCE_YET) {
    state = dudect_main(&ctx);
  }
  dudect_free(&ctx);
  return (int)state;
}

// Assembly:
subq $0x388, %rsp            # imm = 0x388
movl $0x0, 0x384(%rsp)
movl %edi, 0x380(%rsp)
movq %rsi, 0x378(%rsp)
movq 0x42e8(%rip), %rax      # 0x6080
movq %rax, 0x368(%rsp)
movq 0x42e1(%rip), %rax      # 0x6088
movq %rax, 0x370(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x368(%rsp), %rsi
callq 0x1940
movl $0x1, 0x4(%rsp)
cmpl $0x1, 0x4(%rsp)
jne 0x1de0
leaq 0x8(%rsp), %rdi
callq 0x1310
movl %eax, 0x4(%rsp)
jmp 0x1dc9
leaq 0x8(%rsp), %rdi
callq 0x1c20
movl 0x4(%rsp), %eax
addq $0x388, %rsp            # imm = 0x388
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/donna/curve25519-donna.c
// Function: curve25519_donna
int
curve25519_donna(u8 *mypublic, const u8 *secret, const u8 *basepoint) {
  limb bp[10], x[10], z[11], zmone[10];
  uint8_t e[32];
  int i;

  for (i = 0; i < 32; ++i) e[i] = secret[i];
  e[0] &= 248;
  e[31] &= 127;
  e[31] |= 64;

  fexpand(bp, basepoint);
  cmult(x, z, e, bp);
  crecip(zmone, z);
  fmul(z, x, zmone);
  fcontract(mypublic, z);
  return 0;
}

// Assembly:
subq $0x198, %rsp            # imm = 0x198
movq %rdi, 0x190(%rsp)
movq %rsi, 0x188(%rsp)
movq %rdx, 0x180(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x20, 0xc(%rsp)
jge 0x2234
movq 0x188(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb (%rax,%rcx), %cl
movslq 0xc(%rsp), %rax
movb %cl, 0x10(%rsp,%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2207
movzbl 0x10(%rsp), %eax
andl $0xf8, %eax
movb %al, 0x10(%rsp)
movzbl 0x2f(%rsp), %eax
andl $0x7f, %eax
movb %al, 0x2f(%rsp)
movzbl 0x2f(%rsp), %eax
orl $0x40, %eax
movb %al, 0x2f(%rsp)
leaq 0x130(%rsp), %rdi
movq 0x180(%rsp), %rsi
callq 0x22e0
leaq 0xe0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x130(%rsp), %rcx
callq 0x2600
leaq 0x30(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x2990
leaq 0x80(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x2dd0
movq 0x190(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x2e40
xorl %eax, %eax
addq $0x198, %rsp            # imm = 0x198
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/donna/curve25519-donna.c
// Function: fmul
static void
fmul(limb *output, const limb *in, const limb *in2) {
  limb t[19];
  fproduct(t, in, in2);
  /* |t[i]| < 14*2^54 */
  freduce_degree(t);
  freduce_coefficients(t);
  /* |t[i]| < 2^26 */
  memcpy(output, t, sizeof(limb) * 10);
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rsp, %rdi
movq 0xa8(%rsp), %rsi
movq 0xa0(%rsp), %rdx
callq 0x3a90
movq %rsp, %rdi
callq 0x46f0
movq %rsp, %rdi
callq 0x49a0
movq 0xb0(%rsp), %rdi
movq %rsp, %rsi
movl $0x50, %edx
callq 0x10b0
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/donna/curve25519-donna.c
// Function: swap_conditional
static void
swap_conditional(limb a[19], limb b[19], limb iswap) {
  unsigned i;
  const s32 swap = (s32) -iswap;

  for (i = 0; i < 10; ++i) {
    const s32 x = swap & ( ((s32)a[i]) ^ ((s32)b[i]) );
    a[i] = ((s32)a[i]) ^ x;
    b[i] = ((s32)b[i]) ^ x;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
xorl %eax, %eax
subq -0x18(%rsp), %rax
movl %eax, -0x20(%rsp)
movl $0x0, -0x1c(%rsp)
cmpl $0xa, -0x1c(%rsp)
jae 0x367e
movl -0x20(%rsp), %eax
movq -0x8(%rsp), %rcx
movl -0x1c(%rsp), %edx
movq (%rcx,%rdx,8), %rcx
movq -0x10(%rsp), %rdx
movl -0x1c(%rsp), %esi
movq (%rdx,%rsi,8), %rdx
xorl %edx, %ecx
andl %ecx, %eax
movl %eax, -0x24(%rsp)
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
xorl -0x24(%rsp), %eax
movslq %eax, %rdx
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rsp), %rax
movl -0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
xorl -0x24(%rsp), %eax
movslq %eax, %rdx
movq -0x10(%rsp), %rax
movl -0x1c(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x3602
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/donna/curve25519-donna.c
// Function: fsum
static void fsum(limb *output, const limb *in) {
  unsigned i;
  for (i = 0; i < 10; i += 2) {
    output[0+i] = output[0+i] + in[0+i];
    output[1+i] = output[1+i] + in[1+i];
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0xa, -0x14(%rsp)
jae 0x3a32
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
addl $0x0, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
addl $0x0, %ecx
movl %ecx, %ecx
addq (%rax,%rcx,8), %rdx
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
addl $0x0, %ecx
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
addq (%rax,%rcx,8), %rdx
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rsp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rsp)
jmp 0x39b2
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/donna/curve25519-donna.c
// Function: fsquare
static void
fsquare(limb *output, const limb *in) {
  limb t[19];
  fsquare_inner(t, in);
  /* |t[i]| < 14*2^54 because the largest product of two limbs will be <
   * 2^(27+27) and fsquare_inner adds together, at most, 14 of those
   * products. */
  freduce_degree(t);
  freduce_coefficients(t);
  /* |t[i]| < 2^26 */
  memcpy(output, t, sizeof(limb) * 10);
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rsp, %rdi
movq 0x98(%rsp), %rsi
callq 0x4c50
movq %rsp, %rdi
callq 0x46f0
movq %rsp, %rdi
callq 0x49a0
movq 0xa0(%rsp), %rdi
movq %rsp, %rsi
movl $0x50, %edx
callq 0x10b0
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/donna/curve25519-donna.c
// Function: div_by_2_26
static inline limb
div_by_2_26(const limb v)
{
  /* High word of v; no shift needed. */
  const uint32_t highword = (uint32_t) (((uint64_t) v) >> 32);
  /* Set to all 1s if v was negative; else set to 0s. */
  const int32_t sign = ((int32_t) highword) >> 31;
  /* Set to 0x3ffffff if v was negative; else set to 0. */
  const int32_t roundoff = ((uint32_t) sign) >> 6;
  /* Should return v / (1<<26) */
  return (v + roundoff) >> 26;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x20, %rax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
sarl $0x1f, %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
shrl $0x6, %eax
movl %eax, -0x14(%rsp)
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
addq %rcx, %rax
sarq $0x1a, %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/donna/curve25519-donna.c
// Function: div_by_2_25
static inline limb
div_by_2_25(const limb v)
{
  /* High word of v; no shift needed*/
  const uint32_t highword = (uint32_t) (((uint64_t) v) >> 32);
  /* Set to all 1s if v was negative; else set to 0s. */
  const int32_t sign = ((int32_t) highword) >> 31;
  /* Set to 0x1ffffff if v was negative; else set to 0. */
  const int32_t roundoff = ((uint32_t) sign) >> 7;
  /* Should return v / (1<<25) */
  return (v + roundoff) >> 25;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x20, %rax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
sarl $0x1f, %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
shrl $0x7, %eax
movl %eax, -0x14(%rsp)
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
addq %rcx, %rax
sarq $0x19, %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/donna/curve25519-donna.c
// Function: s32_eq
static s32 s32_eq(s32 a, s32 b) {
  a = ~(a ^ b);
  a &= a << 16;
  a &= a << 8;
  a &= a << 4;
  a &= a << 2;
  a &= a << 1;
  return a >> 31;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl -0x4(%rsp), %eax
xorl -0x8(%rsp), %eax
xorl $-0x1, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shll $0x10, %eax
andl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shll $0x8, %eax
andl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shll $0x4, %eax
andl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shll $0x2, %eax
andl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shll %eax
andl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
sarl $0x1f, %eax
retq