LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: usage()
static void usage() {
  fprintf(stderr, "Mkfilter V.%s from <fisher@minster.york.ac.uk>\n", VERSION);
  fprintf(stderr,
          "Usage: mkfilter [-Be | -Bu | -Ch <r> | -Pi] [-Lp | -Hp | -Bp | -Bs] "
          "[-p <n1> <n2> ...] [-{lwz}] "
          "[-Z <alphaz>] "
          "-o <order> -a <alpha1> [ <alpha2> ]\n");
  fprintf(stderr,
          "       mkfilter -Re <q> [-Bp | -Bs | -Ap] [-l] -a <alpha>\n\n");
  fprintf(stderr, "  -Be, Bu             = Bessel, Butterworth\n");
  fprintf(stderr, "  -Ch <r>             = Chebyshev (r = dB ripple)\n");
  fprintf(stderr, "  -Pi                 = Proportional-Integral\n");
  fprintf(stderr, "  -Re <q>             = 2-pole resonator (q = Q-factor)\n");
  fprintf(stderr,
          "  -Lp, Hp, Bp, Bs, Ap = lowpass, highpass, bandpass, bandstop, "
          "allpass\n");
  fprintf(
      stderr,
      "  -p                  = use listed poles only (ni = 0 .. order-1)\n");
  fprintf(stderr, "  -l                  = just list <order> parameters\n");
  fprintf(stderr, "  -w                  = don't pre-warp frequencies\n");
  fprintf(stderr, "  -z                  = use matched z-transform\n");
  fprintf(stderr, "  -Z                  = additional z-plane zero\n");
  fprintf(stderr, "  order = 1..%d;  alpha = f(corner)/f(sample)\n\n",
          MAXORDER);
  exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x4658(%rip), %r15      # 0x6fe0
movq (%r15), %rdi
leaq 0x1917(%rip), %rsi      # 0x42a9
leaq 0x1940(%rip), %rdx      # 0x42d9
xorl %eax, %eax
callq 0x1120
movq (%r15), %rcx
leaq 0x1933(%rip), %rdi      # 0x42dd
pushq $0x1
popq %rbx
movl $0x92, %esi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0x19ac(%rip), %rdi      # 0x4370
pushq $0x3b
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0x19d3(%rip), %rdi      # 0x43ac
pushq $0x2c
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0x19eb(%rip), %rdi      # 0x43d9
pushq $0x32
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0x1a09(%rip), %rdi      # 0x440c
pushq $0x2e
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0x1a23(%rip), %rdi      # 0x443b
pushq $0x38
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0x1a47(%rip), %rdi      # 0x4474
pushq $0x47
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0x1a7a(%rip), %rdi      # 0x44bc
pushq $0x42
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0x1aa8(%rip), %rdi      # 0x44ff
pushq $0x35
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0x1ac9(%rip), %rdi      # 0x4535
pushq $0x33
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0x1ae8(%rip), %rdi      # 0x4569
pushq $0x30
popq %r14
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0x1b00(%rip), %rdi      # 0x459a
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rdi
leaq 0x1b1c(%rip), %rsi      # 0x45cb
pushq $0xa
popq %rdx
xorl %eax, %eax
callq 0x1120
pushq $0x1
popq %rdi
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movq 0x450a(%rip), %r15      # 0x6fe0
movq (%r15), %rcx
leaq 0x1cac(%rip), %rdi      # 0x478c
pushq $0xa
popq %rsi
pushq $0x1
popq %rdx
callq 0x1190
movq (%r15), %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1120
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x1180
movb $0x0, 0xc642(%rip)      # 0xf150
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x2b5b
movl 0xc5e7(%rip), %eax      # 0xf110
testb $0x1, %al
je 0x2b53
movslq 0x85bc(%rip), %rcx      # 0xb0f0
leaq 0x45b5(%rip), %rdx      # 0x70f0
leal 0x1(%rcx), %esi
movl %esi, 0x85ac(%rip)      # 0xb0f0
shlq $0x4, %rcx
movsd %xmm0, (%rcx,%rdx)
movsd %xmm1, 0x8(%rcx,%rdx)
shrl %eax
movl %eax, 0xc5b5(%rip)      # 0xf110
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rdx)
andq $0x0, 0x8(%rdx)
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
movl %esi, 0xc(%rsp)
cmovgl %esi, %ecx
movq %rdi, %r14
movq %rcx, 0x20(%rsp)
shlq $0x4, %rcx
xorpd %xmm0, %xmm0
cmpq %rax, %rcx
je 0x2c21
movupd %xmm0, 0x10(%rbx,%rax)
addq $0x10, %rax
jmp 0x2c10
movl 0xc(%rsp), %r15d
shlq $0x4, %r15
addq %rbx, %r15
xorl %r13d, %r13d
cmpq 0x20(%rsp), %r13
je 0x2cda
movq %r13, %rax
shlq $0x4, %rax
xorpd %xmm0, %xmm0
subsd (%r14,%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
xorpd %xmm0, %xmm0
subsd 0x8(%r14,%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0xc(%rsp), %ebp
movq %r15, %r12
testl %ebp, %ebp
jle 0x2caf
movsd (%r12), %xmm2
movsd 0x8(%r12), %xmm3
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x31af
addsd -0x10(%r12), %xmm0
addsd -0x8(%r12), %xmm1
movsd %xmm0, (%r12)
movsd %xmm1, 0x8(%r12)
addq $-0x10, %r12
decl %ebp
jmp 0x2c6a
movsd (%rbx), %xmm2
movsd 0x8(%rbx), %xmm3
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x31af
movsd %xmm0, (%rbx)
movsd %xmm1, 0x8(%rbx)
incq %r13
jmp 0x2c30
movslq 0xc(%rsp), %rax
addq $0x8, %rbx
xorl %edx, %edx
movapd 0x1393(%rip), %xmm0     # 0x4080
movsd 0x135b(%rip), %xmm1     # 0x4050
cmpq %rax, %rdx
jg 0x2d11
movsd (%rbx), %xmm2
andpd %xmm0, %xmm2
ucomisd %xmm1, %xmm2
ja 0x2d20
incq %rdx
addq $0x10, %rbx
jmp 0x2cf5
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x42b9(%rip), %rax      # 0x6fe0
movq (%rax), %rdi
leaq 0x1af5(%rip), %rsi      # 0x4826
xorl %eax, %eax
callq 0x1120
pushq $0x1
popq %rdi
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/randyrossi[P]fisher-modem/mkfilter/src/mkfilter.C
// Function: printcmdline(char**)
static void printcmdline(char* argv[]) {
  int k = 0;
  until(argv[k] == NULL) {
    if (k > 0)
      putchar(' ');
    fputs(argv[k++], stdout);
  }
  putchar('\n');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x4274(%rip), %r15      # 0x6fc8
pushq $0x20
popq %rbp
movq (%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x2d7e
testq %r14, %r14
je 0x2d70
movl %ebp, %edi
callq 0x10f0
movq (%rbx,%r14), %rdi
movq (%r15), %rsi
callq 0x10b0
addq $0x8, %r14
jmp 0x2d57
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
subq $0x20, %rsp
movaps %xmm1, %xmm2
movaps %xmm0, %xmm1
movq %rdi, %rbx
movsd %xmm2, 0x8(%rsp)
movaps %xmm2, %xmm0
movsd %xmm1, 0x10(%rsp)
callq 0x1060
movsd %xmm0, 0x18(%rsp)
leaq 0x1b37(%rip), %rdi      # 0x4946
movq %rbx, %rsi
movb $0x1, %al
callq 0x1030
movsd 0x18(%rsp), %xmm0
ucomisd 0x1229(%rip), %xmm0     # 0x4050
jbe 0x2e50
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x1040
divsd 0x11de(%rip), %xmm0     # 0x4020
leaq 0x1b18(%rip), %rdi      # 0x4961
movb $0x1, %al
callq 0x1030
pushq $0xa
popq %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, 0x4(%rsp)
movslq %esi, %r12
movq %rdi, 0x10(%rsp)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
cmpl 0x4(%rsp), %r13d
jge 0x2f29
pushq $0x9
popq %rdi
callq 0x10f0
movslq %r13d, %rbx
movq %rbx, %rbp
shlq $0x4, %rbp
movq 0x10(%rsp), %rax
leaq (%rax,%rbp), %r14
movsd (%rax,%rbp), %xmm0
movsd 0x8(%rax,%rbp), %xmm1
leaq 0x1ac6(%rip), %rdi      # 0x4981
movb $0x2, %al
callq 0x1030
incq %rbx
addq 0x8(%rsp), %rbp
movl %r13d, %r15d
cmpq %r12, %rbx
jge 0x2efb
movsd -0x8(%rbp), %xmm0
incl %r15d
ucomisd (%r14), %xmm0
jne 0x2f00
jp 0x2f00
movsd (%rbp), %xmm0
incq %rbx
addq $0x10, %rbp
ucomisd 0x8(%r14), %xmm0
jne 0x2f00
jnp 0x2ecd
jmp 0x2f00
movl 0x4(%rsp), %r15d
movl %r15d, %esi
subl %r13d, %esi
cmpl $0x2, %esi
jl 0x2f19
leaq 0x1a65(%rip), %rdi      # 0x4977
xorl %eax, %eax
callq 0x1030
pushq $0xa
popq %rdi
callq 0x10f0
movl %r15d, %r13d
jmp 0x2e83
pushq $0xa
popq %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2038, %rsp           # imm = 0x2038
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x30(%rsp), %r14
movl $0x2008, %edx           # imm = 0x2008
movq %r14, %rdi
xorl %esi, %esi
callq 0x10b0
leaq -0x35(%rip), %rsi       # 0x17d4
pushq $0x2
popq %r15
movl %r15d, %edi
callq 0x10f0
movq 0x27ac(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
xorl %esi, %esi
callq 0x1090
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x130d
pushq $0x1
popq %rsi
movl %r15d, %edi
xorl %edx, %edx
callq 0x11b0
movl %eax, %ebx
leaq 0x10(%rsp), %rsi
movq $0x39050002, (%rsi)     # imm = 0x39050002
pushq $0x10
popq %rdx
movl %eax, %edi
callq 0x1120
movl %ebx, %edi
movl $0x400, %esi            # imm = 0x400
callq 0x1110
leaq 0x20(%rsp), %r14
leaq 0xc(%rsp), %r15
movl $0x10, 0xc(%rsp)
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1140
movl %eax, %ebp
callq 0x1190
testl %eax, %eax
je 0x1897
movl %ebp, %edi
callq 0x10c0
jmp 0x186e
movl %ebx, %edi
callq 0x10c0
movl %ebp, %edi
callq 0x16de
xorl %edi, %edi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rsi
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rbx
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movaps 0x29b3(%rip), %xmm0     # 0x42e0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps 0x2995(%rip), %xmm0     # 0x42d0
movaps %xmm0, (%rdx)
movq %rbx, %rdi
callq 0x1a74
movb (%rbx), %al
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
subq $0x360, %rsp            # imm = 0x360
leaq 0x2733(%rip), %rsi      # 0x4090
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x16d1
pushq $0x1
popq %rax
testl %eax, %eax
je 0x1979
movq %rbx, %rdi
callq 0x12b3
jmp 0x196b
movq %rsp, %rdi
callq 0x18ae
xorl %eax, %eax
addq $0x360, %rsp            # imm = 0x360
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x26db
movq %r14, %rdi
callq 0x2cca
movq %r14, %rdi
callq 0x2dae
pushq $0xa
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
negl %edx
xorl %eax, %eax
cmpq $0xa, %rax
je 0x269f
movl (%rdi,%rax,8), %ecx
movl (%rsi,%rax,8), %r8d
xorl %ecx, %r8d
andl %edx, %r8d
xorl %r8d, %ecx
movslq %ecx, %rcx
movq %rcx, (%rdi,%rax,8)
xorl (%rsi,%rax,8), %r8d
movslq %r8d, %rcx
movq %rcx, (%rsi,%rax,8)
incq %rax
jmp 0x2672
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
cmpq $0x9, %rax
ja 0x26c0
movq (%rsi,%rax,8), %rcx
addq %rcx, (%rdi,%rax,8)
movq 0x8(%rsi,%rax,8), %rcx
addq %rcx, 0x8(%rdi,%rax,8)
addq $0x2, %rax
jmp 0x26a2
retq
// File: /workspace/github_c_makefile_star2_O2/oreparaz[P]dudect/examples/donna/curve25519-donna.c
// Function: freduce_degree
static void freduce_degree(limb *output) {
  /* Each of these shifts and adds ends up multiplying the value by 19.
   *
   * For output[0..8], the absolute entry value is < 14*2^54 and we add, at
   * most, 19*14*2^54 thus, on exit, |output[0..8]| < 280*2^54. */
  output[8] += output[18] << 4;
  output[8] += output[18] << 1;
  output[8] += output[18];
  output[7] += output[17] << 4;
  output[7] += output[17] << 1;
  output[7] += output[17];
  output[6] += output[16] << 4;
  output[6] += output[16] << 1;
  output[6] += output[16];
  output[5] += output[15] << 4;
  output[5] += output[15] << 1;
  output[5] += output[15];
  output[4] += output[14] << 4;
  output[4] += output[14] << 1;
  output[4] += output[14];
  output[3] += output[13] << 4;
  output[3] += output[13] << 1;
  output[3] += output[13];
  output[2] += output[12] << 4;
  output[2] += output[12] << 1;
  output[2] += output[12];
  output[1] += output[11] << 4;
  output[1] += output[11] << 1;
  output[1] += output[11];
  output[0] += output[10] << 4;
  output[0] += output[10] << 1;
  output[0] += output[10];
}

// Assembly:
movq 0x90(%rdi), %rax
imulq $0x12, %rax, %rcx
addq 0x40(%rdi), %rax
addq %rcx, %rax
movq %rax, 0x40(%rdi)
movdqu 0x80(%rdi), %xmm3
movdqu (%rdi), %xmm0
movdqu 0x10(%rdi), %xmm2
movdqu 0x20(%rdi), %xmm4
movdqu 0x30(%rdi), %xmm5
movdqa 0x15ed(%rip), %xmm1     # 0x42f0
movdqa %xmm3, %xmm6
pmuludq %xmm1, %xmm6
paddq %xmm3, %xmm5
psrlq $0x20, %xmm3
pmuludq %xmm1, %xmm3
psllq $0x20, %xmm3
paddq %xmm6, %xmm3
paddq %xmm5, %xmm3
movdqu %xmm3, 0x30(%rdi)
movdqu 0x70(%rdi), %xmm3
movdqa %xmm3, %xmm5
pmuludq %xmm1, %xmm5
paddq %xmm3, %xmm4
psrlq $0x20, %xmm3
pmuludq %xmm1, %xmm3
psllq $0x20, %xmm3
paddq %xmm5, %xmm3
paddq %xmm4, %xmm3
movdqu %xmm3, 0x20(%rdi)
movdqu 0x60(%rdi), %xmm3
movdqa %xmm3, %xmm4
pmuludq %xmm1, %xmm4
paddq %xmm3, %xmm2
psrlq $0x20, %xmm3
pmuludq %xmm1, %xmm3
psllq $0x20, %xmm3
paddq %xmm4, %xmm3
paddq %xmm2, %xmm3
movdqu %xmm3, 0x10(%rdi)
movdqu 0x50(%rdi), %xmm2
movdqa %xmm2, %xmm3
pmuludq %xmm1, %xmm3
paddq %xmm2, %xmm0
psrlq $0x20, %xmm2
pmuludq %xmm1, %xmm2
psllq $0x20, %xmm2
paddq %xmm3, %xmm2
paddq %xmm0, %xmm2
movdqu %xmm2, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/oreparaz[P]dudect/examples/donna/curve25519-donna.c
// Function: freduce_coefficients
static void freduce_coefficients(limb *output) {
  unsigned i;

  output[10] = 0;

  for (i = 0; i < 10; i += 2) {
    limb over = div_by_2_26(output[i]);
    /* The entry condition (that |output[i]| < 280*2^54) means that over is, at
     * most, 280*2^28 in the first iteration of this loop. This is added to the
     * next limb and we can approximate the resulting bound of that limb by
     * 281*2^54. */
    output[i] -= over << 26;
    output[i+1] += over;

    /* For the first iteration, |output[i+1]| < 281*2^54, thus |over| <
     * 281*2^29. When this is added to the next limb, the resulting bound can
     * be approximated as 281*2^54.
     *
     * For subsequent iterations of the loop, 281*2^54 remains a conservative
     * bound and no overflow occurs. */
    over = div_by_2_25(output[i+1]);
    output[i+1] -= over << 25;
    output[i+2] += over;
  }
  /* Now |output[10]| < 281*2^29 and all other coefficients are reduced. */
  output[0] += output[10] << 4;
  output[0] += output[10] << 1;
  output[0] += output[10];

  output[10] = 0;

  /* Now output[1..9] are reduced, and |output[0]| < 2^26 + 19*281*2^29
   * So |over| will be no more than 2^16. */
  {
    limb over = div_by_2_26(output[0]);
    output[0] -= over << 26;
    output[1] += over;
  }

  /* Now output[0,2..9] are reduced, and |output[1]| < 2^25 + 2^16 < 2^26. The
   * bound on |output[1]| is sufficient to meet our needs. */
}

// Assembly:
andq $0x0, 0x50(%rdi)
xorl %eax, %eax
cmpq $0x9, %rax
ja 0x2e1a
movq (%rdi,%rax,8), %rcx
movq %rcx, %rdx
shrq $0x20, %rdx
sarl $0x1f, %edx
shrl $0x6, %edx
addq %rcx, %rdx
movq %rdx, %rsi
sarq $0x1a, %rsi
andq $-0x4000000, %rdx       # imm = 0xFC000000
subq %rdx, %rcx
movq %rcx, (%rdi,%rax,8)
addq 0x8(%rdi,%rax,8), %rsi
movq %rsi, %rcx
shrq $0x20, %rcx
sarl $0x1f, %ecx
shrl $0x7, %ecx
addq %rsi, %rcx
movq %rcx, %rdx
sarq $0x19, %rdx
andq $-0x2000000, %rcx       # imm = 0xFE000000
subq %rcx, %rsi
movq %rsi, 0x8(%rdi,%rax,8)
addq %rdx, 0x10(%rdi,%rax,8)
addq $0x2, %rax
jmp 0x2db5
movq 0x50(%rdi), %rax
imulq $0x12, %rax, %rcx
addq (%rdi), %rax
addq %rcx, %rax
andq $0x0, 0x50(%rdi)
movq %rax, %rcx
sarq $0x3f, %rcx
shrl $0x6, %ecx
addq %rax, %rcx
movq %rcx, %rdx
sarq $0x1a, %rdx
andq $-0x4000000, %rcx       # imm = 0xFC000000
subq %rcx, %rax
movq %rax, (%rdi)
addq %rdx, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/silverneko[P]miku/./src/utils.h
// Function: submission::submission()
submission()
      {
         problem_id = 0;
         submission_id = 0;
         code = "";
         sjcode = "";
         interlib = "";
         lang = "";
         std = "";
         submitter = "";
         submitter_id = 0;
         problem_type = 0;
         special_judge = "";
         testdata_count = 0;
         fill(mem_limit, mem_limit + 200, 0);
         fill(time_limit, time_limit + 200, 0);
         fill(verdict, verdict + 200, 0);
         fill(mem, mem + 200, 0);
         fill(time, time + 200, 0);
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, 0x48(%rdi)
andq $0x0, 0x50(%rdi)
addq $0x8, %rdi
movb %al, 0x58(%rbx)
leaq 0x78(%rbx), %rcx
movq %rcx, 0x68(%rbx)
andq $0x0, 0x70(%rbx)
leaq 0x28(%rbx), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x48(%rbx), %r12
movb %al, 0x78(%rbx)
leaq 0x98(%rbx), %rcx
movq %rcx, 0x88(%rbx)
andq $0x0, 0x90(%rbx)
leaq 0x68(%rbx), %r13
leaq 0x88(%rbx), %rbp
movb %al, 0x98(%rbx)
leaq 0xb8(%rbx), %rcx
movq %rcx, 0xa8(%rbx)
andq $0x0, 0xb0(%rbx)
leaq 0xa8(%rbx), %r14
movb %al, 0xb8(%rbx)
leaq 0xd0(%rbx), %r15
leaq 0xe0(%rbx), %rcx
movq %rcx, 0xd0(%rbx)
andq $0x0, 0xd8(%rbx)
movb %al, 0xe0(%rbx)
andq $0x0, (%rbx)
leaq 0x4a22(%rip), %rsi      # 0x8522
movq %rdi, 0x10(%rsp)
callq 0x3520
leaq 0x4a11(%rip), %rsi      # 0x8522
movq 0x8(%rsp), %rdi
callq 0x3520
leaq 0x4a00(%rip), %rsi      # 0x8522
movq %r12, %rdi
callq 0x3520
leaq 0x49f1(%rip), %rsi      # 0x8522
movq %r13, %rdi
callq 0x3520
leaq 0x49e2(%rip), %rsi      # 0x8522
movq %rbp, %rdi
callq 0x3520
leaq 0x49d3(%rip), %rsi      # 0x8522
movq %r14, %rdi
callq 0x3520
andq $0x0, 0xc8(%rbx)
leaq 0x49bc(%rip), %rsi      # 0x8522
movq %r15, %rdi
callq 0x3520
andl $0x0, 0xf0(%rbx)
movq $-0x320, %rax           # imm = 0xFCE0
testq %rax, %rax
je 0x3b8f
andl $0x0, 0x414(%rbx,%rax)
addq $0x4, %rax
jmp 0x3b7c
movq $-0x320, %rax           # imm = 0xFCE0
testq %rax, %rax
je 0x3ba9
andl $0x0, 0x734(%rbx,%rax)
addq $0x4, %rax
jmp 0x3b96
movq $-0x320, %rax           # imm = 0xFCE0
testq %rax, %rax
je 0x3bc3
andl $0x0, 0xa54(%rbx,%rax)
addq $0x4, %rax
jmp 0x3bb0
movq $-0x320, %rax           # imm = 0xFCE0
testq %rax, %rax
je 0x3bdd
andl $0x0, 0xd74(%rbx,%rax)
addq $0x4, %rax
jmp 0x3bca
movq $-0x320, %rax           # imm = 0xFCE0
testq %rax, %rax
je 0x3bf7
andl $0x0, 0x1094(%rbx,%rax)
addq $0x4, %rax
jmp 0x3be4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3170
movq %rbp, %rdi
callq 0x3170
movq %r13, %rdi
callq 0x3170
movq %r12, %rdi
callq 0x3170
movq 0x8(%rsp), %rdi
callq 0x3170
movq 0x10(%rsp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x34d0
nop
// File: /workspace/github_c_makefile_star2_O2/silverneko[P]miku/./src/sandbox.cpp
// Function: sandboxInit(int)
int sandboxInit(int boxid)
{
   ostringstream sout;
   sout << "isolate --box-id=" << boxid;
   sout << " --cg";
   sout << " --init 2>/dev/null >/dev/null";
   cerr << "[debug] box-" << boxid << " inited" << endl;
   system(sout.str().c_str());
   return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movl %edi, %ebx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x3360
leaq 0x41ae(%rip), %rsi      # 0x8280
movq %r14, %rdi
callq 0x3290
movq %rax, %rdi
movl %ebx, %esi
callq 0x34c0
leaq 0x41a7(%rip), %rsi      # 0x8292
leaq 0x20(%rsp), %rdi
callq 0x3290
leaq 0x425d(%rip), %rsi      # 0x8359
leaq 0x20(%rsp), %rdi
callq 0x3290
movq 0x7ee3(%rip), %rdi      # 0xbff0
leaq 0x4224(%rip), %rsi      # 0x8338
callq 0x3290
movq %rax, %rdi
movl %ebx, %esi
callq 0x34c0
leaq 0x424e(%rip), %rsi      # 0x8378
movq %rax, %rdi
callq 0x3290
movq %rax, %rdi
callq 0x31a0
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x3430
movq (%rsp), %rdi
callq 0x3260
movq %rsp, %rdi
callq 0x3170
leaq 0x20(%rsp), %rdi
callq 0x30b0
xorl %eax, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3170
jmp 0x4181
jmp 0x417e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_c_makefile_star2_O2/silverneko[P]miku/./src/sandbox.cpp
// Function: sandboxDele(int)
int sandboxDele(int boxid)
{
   ostringstream sout;
   sout << "isolate --box-id=" << boxid;
   sout << " --cg";
   sout << " --cleanup 2>/dev/null >/dev/null";
   cerr << "[debug] box-" << boxid << " cleaned" << endl;
   system(sout.str().c_str());
   return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movl %edi, %ebx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x3360
leaq 0x40cd(%rip), %rsi      # 0x8280
movq %r14, %rdi
callq 0x3290
movq %rax, %rdi
movl %ebx, %esi
callq 0x34c0
leaq 0x40c6(%rip), %rsi      # 0x8292
leaq 0x20(%rsp), %rdi
callq 0x3290
leaq 0x41a3(%rip), %rsi      # 0x8380
leaq 0x20(%rsp), %rdi
callq 0x3290
movq 0x7e02(%rip), %rdi      # 0xbff0
leaq 0x4143(%rip), %rsi      # 0x8338
callq 0x3290
movq %rax, %rdi
movl %ebx, %esi
callq 0x34c0
leaq 0x4197(%rip), %rsi      # 0x83a2
movq %rax, %rdi
callq 0x3290
movq %rax, %rdi
callq 0x31a0
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x3430
movq (%rsp), %rdi
callq 0x3260
movq %rsp, %rdi
callq 0x3170
leaq 0x20(%rsp), %rdi
callq 0x30b0
xorl %eax, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3170
jmp 0x4262
jmp 0x425f
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_c_makefile_star2_O2/silverneko[P]miku/./src/server_io.cpp
// Function: respondValidating(int)
int respondValidating(int submission_id)
{
   ostringstream sout;
   sout << "respond_validating.py " << submission_id;
   system(sout.str().c_str());
   return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movl %edi, %ebx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x3360
leaq 0x1fb7(%rip), %rsi      # 0x866b
movq %r14, %rdi
callq 0x3290
movq %rax, %rdi
movl %ebx, %esi
callq 0x34c0
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x3430
movq (%rsp), %rdi
callq 0x3260
movq %rsp, %rdi
callq 0x3170
leaq 0x20(%rsp), %rdi
callq 0x30b0
xorl %eax, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3170
jmp 0x670d
jmp 0x670a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/src/Main.cpp
// Function: ShowHelp()
static void ShowHelp()
{
  printf("\nTundra Build Processor 2.0\n");
  printf("Copyright (C) 2010-2023 Andreas Fredriksson\n\n");

#ifdef HAVE_GIT_INFO
  printf("Git branch: %s\n", g_GitBranch);
  printf("Git commit: %s\n\n", g_GitVersion);
#endif

  printf("This program comes with ABSOLUTELY NO WARRANTY.\n");

  printf("Usage: tundra2 [options...] [targets...]\n\n");
  printf("Options:\n");

  size_t max_opt_len = 0;
  for (size_t i = 0; i < ARRAY_SIZE(g_OptionTemplates); ++i)
  {
    size_t opt_len = strlen(g_OptionTemplates[i].m_LongName) + 12;
    if (opt_len > max_opt_len)
      max_opt_len = opt_len;
  }

  for (size_t i = 0; i < ARRAY_SIZE(g_OptionTemplates); ++i)
  {
    const OptionTemplate* t = g_OptionTemplates + i;

    if (!t->m_Help)
      continue;

    char long_text[256];
    if (t->m_Type == OptionType::kInt)
      snprintf(long_text, sizeof long_text, "%s=<integer>", t->m_LongName);
    else if (t->m_Type == OptionType::kString)
      snprintf(long_text, sizeof long_text, "%s=<string>", t->m_LongName);
    else
      snprintf(long_text, sizeof long_text, "%s          ", t->m_LongName);

    printf("  -%c, --%-*s %s\n", t->m_ShortName, (int) max_opt_len, long_text, t->m_Help);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
leaq 0xf964(%rip), %rdi      # 0x13873
callq 0x3540
leaq 0xf974(%rip), %rdi      # 0x1388f
callq 0x3540
leaq 0xf8af(%rip), %rdi      # 0x137d6
leaq 0xf10b(%rip), %rsi      # 0x13039
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3060
leaq 0xf8a8(%rip), %rdi      # 0x137e6
leaq 0xf0cb(%rip), %rsi      # 0x13010
xorl %eax, %eax
callq 0x3060
leaq 0xf969(%rip), %rdi      # 0x138bc
callq 0x3540
leaq 0xf98d(%rip), %rdi      # 0x138ec
callq 0x3540
leaq 0xf9ab(%rip), %rdi      # 0x13916
callq 0x3540
pushq $0x8
popq %r14
leaq 0x18b15(%rip), %r13     # 0x1ca90
cmpq $0x328, %r14            # imm = 0x328
je 0x3f9e
movq (%r14,%r13), %rdi
callq 0x3150
addq $0xc, %rax
cmpq %rbx, %rax
cmovaq %rax, %rbx
addq $0x28, %r14
jmp 0x3f7b
pushq $0x20
popq %rbp
movq %rsp, %r14
leaq 0xf872(%rip), %r15      # 0x1381d
cmpq $0x340, %rbp            # imm = 0x340
je 0x4016
movq (%rbp,%r13), %r12
testq %r12, %r12
je 0x4010
movl -0x10(%rbp,%r13), %eax
leaq 0xf83a(%rip), %rdx      # 0x13804
cmpl $0x2, %eax
je 0x3fd6
leaq 0xf83a(%rip), %rdx      # 0x13810
movq -0x18(%rbp,%r13), %rcx
cmpl $0x1, %eax
leaq 0xf812(%rip), %rax      # 0x137f7
cmoveq %rax, %rdx
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
xorl %eax, %eax
callq 0x3560
movsbl -0x20(%rbp,%r13), %esi
movq %r15, %rdi
movl %ebx, %edx
movq %r14, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x3060
addq $0x28, %rbp
jmp 0x3fab
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/src/Main.cpp
// Function: AssignOptionValue(char*, OptionTemplate const*, char const*, bool)
static int AssignOptionValue(char* option_base, const OptionTemplate* templ, const char* value, bool is_short)
{
  char* dest = option_base + templ->m_Offset;

  switch (templ->m_Type)
  {
    case OptionType::kBool:
      *(bool*)dest = true;
      return 1;

    case OptionType::kInt:
      if (value)
      {
        *(int*)dest = atoi(value);
        return is_short ? 2 : 1;
      }
      else
      {
        if (is_short)
          fprintf(stderr, "option requires an argument: %c\n", templ->m_ShortName);
        else
          fprintf(stderr, "option requires an argument: --%s\n", templ->m_LongName);
        return 0;
      }
      break;

    case OptionType::kString:
      if (value)
      {
        *(const char**)dest = value;
        return is_short ? 2 : 1;
      }
      else
      {
        if (is_short)
          fprintf(stderr, "option requires an argument: %c\n", templ->m_ShortName);
        else
          fprintf(stderr, "option requires an argument: --%s\n", templ->m_LongName);
        return 0;
      }
      break;

    default:
      return 0;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movq %rdi, %r14
movq 0x18(%rsi), %r15
movl 0x10(%rsi), %eax
cmpl $0x2, %eax
je 0x4066
cmpl $0x1, %eax
je 0x4053
xorl %ebx, %ebx
testl %eax, %eax
jne 0x4074
movb $0x1, (%r14,%r15)
pushq $0x1
popq %rbx
jmp 0x4074
testq %rdx, %rdx
je 0x407c
movq %rdx, %rdi
callq 0x3550
movl %eax, (%r14,%r15)
jmp 0x406f
testq %rdx, %rdx
je 0x407c
movq %rdx, (%r14,%r15)
movzbl %bl, %ebx
incl %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x18f55(%rip), %rax     # 0x1cfd8
movq (%rax), %rdi
testb %bl, %bl
je 0x409f
movsbl (%rsi), %edx
leaq 0xf6fe(%rip), %rsi      # 0x13792
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3480
jmp 0x4074
movq 0x8(%rsi), %rdx
leaq 0xf709(%rip), %rsi      # 0x137b3
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3480
jmp 0x4074
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/src/BuildQueue.cpp
// Function: t2::BuildQueueDestroy(t2::BuildQueue*)
void BuildQueueDestroy(BuildQueue* queue)
  {
    ProfilerScope prof_scope("Tundra BuildQueueDestroy", 0);
    Log(kDebug, "destroying build queue");
    const BuildQueueConfig* config = &queue->m_Config;

    MutexLock(&queue->m_Lock);
    queue->m_QuitSignalled = true;
    MutexUnlock(&queue->m_Lock);

    CondBroadcast(&queue->m_WorkAvailable);

    for (int i = 0, thread_count = config->m_ThreadCount; i < thread_count; ++i)
    {
      if (i > 0)
      {
        Log(kDebug, "joining with build thread %d", i);
        ThreadJoin(queue->m_Threads[i]);
      }

      ThreadStateDestroy(&queue->m_ThreadState[i]);
    }

    // Deallocate storage.
    MemAllocHeap* heap = queue->m_Config.m_Heap;
    HeapFree(heap, queue->m_ExpensiveWaitList);
    HeapFree(heap, queue->m_Queue);

    CondDestroy(&queue->m_WorkAvailable);
    MutexDestroy(&queue->m_Lock);

    HeapFree(config->m_Heap, queue->m_ThreadState);
    HeapFree(config->m_Heap, queue->m_Threads);

    // Unblock all signals on the main thread.
    SignalHandlerSetCondition(nullptr);
    SignalBlockThread(false);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
andl $0x0, 0xc(%rsp)
leaq 0xf735(%rip), %rdi      # 0x139db
xorl %esi, %esi
callq 0x551c
leaq 0xf740(%rip), %rsi      # 0x139f4
pushq $0x8
popq %rdi
xorl %eax, %eax
callq 0x5981
movq %rbx, %rdi
callq 0x549a
movb $0x1, 0x118(%rbx)
movq %rbx, %rdi
callq 0x54b4
leaq 0x28(%rbx), %rdi
movq %rdi, 0x10(%rsp)
callq 0x54ce
movl 0x80(%rbx), %r14d
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
pushq $0x8
popq %rbp
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x4351
testq %r15, %r15
je 0x4329
movl %ebp, %edi
leaq 0xf6fc(%rip), %rsi      # 0x13a0b
movl %r12d, %edx
xorl %eax, %eax
callq 0x5981
movq 0xf8(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x10942
movq 0x100(%rbx), %r13
leaq (%r15,%r13), %rdi
addq $0x8, %rdi
callq 0xd84a
addq %r15, %r13
movq %r13, %rdi
callq 0xd799
incq %r12
addq $0x50, %r15
jmp 0x42fc
movq 0x78(%rbx), %r15
movq 0x110(%rbx), %rsi
movq %r15, %rdi
callq 0xd7a2
movq 0x58(%rbx), %rsi
movq %r15, %rdi
callq 0xd7a2
movq 0x10(%rsp), %rdi
callq 0x54e8
movq %rbx, %rdi
callq 0x5502
movq 0x78(%rbx), %rdi
movq 0x100(%rbx), %rsi
callq 0xd7a2
movq 0x78(%rbx), %rdi
movq 0xf8(%rbx), %rsi
callq 0xd7a2
xorl %edi, %edi
callq 0x100b5
xorl %edi, %edi
callq 0x100e1
leaq 0xc(%rsp), %rdi
callq 0x5488
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x43cf
jmp 0x43cf
jmp 0x43cf
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x5488
movq %rbx, %rdi
callq 0x35e0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/src/BuildQueue.cpp
// Function: t2::BuildQueueBuildNodeRange(t2::BuildQueue*, int, int, int)
BuildResult::Enum BuildQueueBuildNodeRange(BuildQueue* queue, int start_index, int count, int pass_index)
  {
    // Make sure none of the build threads see in-progress state due to a spurious wakeup.
    MutexLock(&queue->m_Lock);

    CHECK(start_index + count <= queue->m_Config.m_MaxNodes);

    queue->m_CurrentPassIndex = pass_index;

    // Initialize build queue with index range to build
    int32_t   *build_queue = queue->m_Queue;
    NodeState *node_states = queue->m_Config.m_NodeState;

    for (int i = 0; i < count; ++i)
    {
      NodeState* state = node_states + start_index + i;

      NodeStateFlagQueued(state);

      // Verify node hasn't been touched already
      CHECK(state->m_Progress == BuildProgress::kInitial);

      build_queue[i] = start_index + i;
    }

    queue->m_PendingNodeCount = count;
    queue->m_FailedNodeCount  = 0;
    queue->m_QueueWriteIndex  = count;
    queue->m_QueueReadIndex   = 0;

    MutexUnlock(&queue->m_Lock);

    CondBroadcast(&queue->m_WorkAvailable);

    // This thread is thread 0.
    BuildLoop(&queue->m_ThreadState[0]);

    if (SignalGetReason())
      return BuildResult::kInterrupted;
    else if (queue->m_FailedNodeCount)
      return BuildResult::kBuildError;
    else
      return BuildResult::kOk;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
callq 0x549a
movl %r14d, 0xf0(%rbx)
movq 0x58(%rbx), %rax
movslq %r15d, %rdx
movl %edx, %ecx
shlq $0x6, %rdx
addq 0x90(%rbx), %rdx
xorl %esi, %esi
testl %ebp, %ebp
movl $0x0, %edi
cmovgl %ebp, %edi
cmpq %rsi, %rdi
je 0x443b
orb $0x1, (%rdx)
leal (%rcx,%rsi), %r8d
movl %r8d, (%rax,%rsi,4)
incq %rsi
addq $0x40, %rdx
jmp 0x4422
movl %ebp, 0xe8(%rbx)
andl $0x0, 0xec(%rbx)
movl %ebp, 0x68(%rbx)
andl $0x0, 0x64(%rbx)
movq %rbx, %rdi
callq 0x54b4
leaq 0x28(%rbx), %rdi
callq 0x54ce
movq 0x100(%rbx), %rdi
callq 0x4494
callq 0xff70
testq %rax, %rax
je 0x447b
pushq $0x1
popq %rax
jmp 0x4489
xorl %eax, %eax
cmpl $0x0, 0xec(%rbx)
setne %al
addl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/src/BuildQueue.cpp
// Function: t2::MakeDirectoriesRecursive(t2::StatCache*, t2::PathBuffer const&)
static bool MakeDirectoriesRecursive(StatCache* stat_cache, const PathBuffer& dir)
  {
    PathBuffer parent_dir = dir;
    PathStripLast(&parent_dir);

    // Can't go any higher.
    if (dir == parent_dir)
      return true;

    if (!MakeDirectoriesRecursive(stat_cache, parent_dir))
      return false;

    char path[kMaxPathLength];
    PathFormat(path, &dir);

    FileInfo info = StatCacheStat(stat_cache, path);

    if (info.Exists())
    {
      // Just asssume this is a directory. We could check it - but there's currently no way via _stat64() calls
      // on Windows to check if a file is a symbolic link (to a directory).
      return true;
    }
    else
    {
      Log(kSpam, "create dir \"%s\"", path);
      bool success = MakeDirectory(path);
      StatCacheMarkDirty(stat_cache, path, Djb2HashPath(path));
      return success;
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x4b8, %rsp            # imm = 0x4B8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x22c(%rsp), %r15
movl $0x28c, %edx            # imm = 0x28C
movq %r15, %rdi
callq 0x3290
movq %r15, %rdi
callq 0xdc55
movq %r14, %rdi
movq %r15, %rsi
callq 0x5603
movb $0x1, %bpl
testb %al, %al
jne 0x53f4
leaq 0x22c(%rsp), %rsi
movq %rbx, %rdi
callq 0x5336
testb %al, %al
je 0x53f2
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xdd8e
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x568b
movb $0x1, %bpl
testb $0x1, (%r14)
jne 0x53f4
leaq 0xe9c6(%rip), %rsi      # 0x13d85
pushq $0x10
popq %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rdx
xorl %eax, %eax
callq 0x5981
movq %r14, %rdi
callq 0x5bc1
movl %eax, %ebp
movq %r14, %rdi
callq 0x58de
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x10186
jmp 0x53f4
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x4b8, %rsp            # imm = 0x4B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/src/Hash.hpp
// Function: t2::CompareHashDigests(t2::HashDigest const&, t2::HashDigest const&)
inline int CompareHashDigests(const HashDigest& lhs, const HashDigest& rhs)
{
  const uint64_t l0 = lhs.m_Words64[0];
  const uint64_t r0 = rhs.m_Words64[0];

  const int res0 = (l0 > r0) - (l0 < r0);

  const uint64_t l1 = lhs.m_Words64[1];
  const uint64_t r1 = rhs.m_Words64[1];

  const int res1 = (l1 > r1) - (l1 < r1);

  return res0 ? res0 : res1;
}

// Assembly:
movq (%rdi), %rax
xorl %ecx, %ecx
cmpq (%rsi), %rax
seta %cl
sbbl $0x0, %ecx
movq 0x8(%rdi), %rdx
xorl %eax, %eax
cmpq 0x8(%rsi), %rdx
seta %al
sbbl $0x0, %eax
testl %ecx, %ecx
cmovnel %ecx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/src/Stats.hpp
// Function: t2::TimingScope::~TimingScope()
~TimingScope()
  {
    uint64_t micros = TimerGet() - m_StartTime;
    if (uint32_t *ptr = m_CountPtr)
      AtomicIncrement(ptr);
    AtomicAdd(m_TimePtr, micros);
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x5b35
movq (%rbx), %rdx
movq 0x10(%rbx), %rcx
testq %rdx, %rdx
je 0x55ee
lock
incl (%rdx)
subq %rcx, %rax
movq 0x8(%rbx), %rcx
lock
addq %rax, (%rcx)
popq %rbx
retq
movq %rax, %rdi
callq 0x553e
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/src/PathUtil.hpp
// Function: t2::operator==(t2::PathBuffer const&, t2::PathBuffer const&)
inline bool operator==(const PathBuffer& a, const PathBuffer& b)
  {
    if (a.m_SegCount != b.m_SegCount)
      return false;

    if (a.m_SegCount == 0)
      return true;

    return
      0 == memcmp(a.m_SegEnds, b.m_SegEnds, sizeof(uint16_t) * a.m_SegCount) &&
      0 == memcmp(a.m_Data, b.m_Data, a.SegLength(a.m_SegCount - 1));
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movzwl 0x6(%rdi), %r12d
cmpw 0x6(%rsi), %r12w
jne 0x563a
testq %r12, %r12
je 0x563e
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa(%rdi), %r15
addq $0xa, %rsi
leal (%r12,%r12), %edx
movq %r15, %rdi
callq 0x3360
testl %eax, %eax
je 0x5642
xorl %eax, %eax
jmp 0x567f
movb $0x1, %al
jmp 0x567f
movl $0x8a, %eax
addq %rax, %r14
addq %rax, %rbx
cmpl $0x1, %r12d
jne 0x5659
movzwl (%r15), %eax
jmp 0x566c
leal -0x1(%r12), %eax
movzwl (%r15,%rax,2), %eax
addl $-0x2, %r12d
subw (%r15,%r12,2), %ax
movzwl %ax, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3360
testl %eax, %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/src/Common.cpp
// Function: t2::Croak(char const*, ...)
void NORETURN Croak(const char* fmt, ...)
{
  va_list args;
  va_start(args, fmt);
  vfprintf(stderr, fmt, args);
  va_end(args);
  fprintf(stderr, "\n");
  if (DebuggerAttached())
    abort();
  else
    exit(1);
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x572c
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0x17885(%rip), %rbx     # 0x1cfd8
movq (%rbx), %rdi
movq %r10, %rsi
callq 0x3450
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x3410
pushq $0x1
popq %rdi
callq 0x33f0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/src/Common.cpp
// Function: t2::CroakErrno(char const*, ...)
void NORETURN CroakErrno(const char* fmt, ...)
{
  va_list args;
  va_start(args, fmt);
  vfprintf(stderr, fmt, args);
  va_end(args);
  fprintf(stderr, "\n");
  fprintf(stderr, "errno: %d (%s)\n", errno, strerror(errno));
#if defined(TUNDRA_WIN32)
  DWORD gle = GetLastError();

  char* message = nullptr;
  size_t size = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                                 NULL, gle, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (char*)&message, 0, NULL);
    
  fprintf(stderr, "Win32 GLE: %u (%s)\n", gle, message);
#endif
  if (DebuggerAttached())
    abort();
  else
    exit(1);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x57d1
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0x177e0(%rip), %rbx     # 0x1cfd8
movq (%rbx), %rdi
movq %r10, %rsi
callq 0x3450
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x3410
movq (%rbx), %rbx
callq 0x3050
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30f0
leaq 0xe5d2(%rip), %rsi      # 0x13df8
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3480
pushq $0x1
popq %rdi
callq 0x33f0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/src/Common.cpp
// Function: t2::CroakAbort(char const*, ...)
void NORETURN CroakAbort(const char* fmt, ...)
{
  va_list args;
  va_start(args, fmt);
  vfprintf(stderr, fmt, args);
  va_end(args);
  fprintf(stderr, "\n");
  abort();
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x589c
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0x17715(%rip), %rbx     # 0x1cfd8
movq (%rbx), %rdi
movq %r10, %rsi
callq 0x3450
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x3410
callq 0x31c0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/src/Common.cpp
// Function: t2::Djb2HashNoCase(char const*)
uint32_t Djb2HashNoCase(const char *str_)
{
  const uint8_t *str = (const uint8_t *) str_;
  uint32_t hash = 5381;
  int c;

  while (0 != (c = *str++))
  {
    hash = (hash * 33) + FoldCase(c);
  }

  return hash ? hash : 1;
}

// Assembly:
movl $0x1505, %eax           # imm = 0x1505
movzbl (%rdi), %ecx
testl %ecx, %ecx
je 0x593f
incq %rdi
imull $0x21, %eax, %edx
leal -0x41(%rcx), %esi
leal 0x20(%rcx), %eax
cmpl $0x1a, %esi
cmovael %ecx, %eax
addl %edx, %eax
jmp 0x5922
cmpl $0x1, %eax
adcl $0x0, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/src/Common.cpp
// Function: t2::Djb2HashNoCase64(char const*)
uint64_t Djb2HashNoCase64(const char *str_)
{
  const uint8_t *str = (const uint8_t *) str_;
  uint64_t hash = 5381;
  int c;

  while (0 != (c = *str++))
  {
    hash = (hash * 33) + FoldCase(c);
  }

  return hash ? hash : 1;
}

// Assembly:
movl $0x1505, %eax           # imm = 0x1505
movzbl (%rdi), %ecx
testl %ecx, %ecx
je 0x596a
incq %rdi
imulq $0x21, %rax, %rdx
leal -0x41(%rcx), %esi
leal 0x20(%rcx), %eax
cmpl $0x1a, %esi
cmovael %ecx, %eax
addq %rdx, %rax
jmp 0x594b
cmpq $0x1, %rax
adcq $0x0, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/src/Common.cpp
// Function: t2::Log(t2::LogLevel, char const*, ...)
void Log(LogLevel level, const char* fmt, ...)
{
  if (s_LogFlags & level)
  {
    const char* prefix = "?";

    switch (level)
    {
      case kError   : prefix = "E"; break;
      case kWarning : prefix = "W"; break;
      case kInfo    : prefix = "I"; break;
      case kDebug   : prefix = "D"; break;
      case kSpam    : prefix = "S"; break;
      default       : break;
    }
    fprintf(stderr, "[%s] ", prefix);

    va_list args;
    va_start(args, fmt);
    vfprintf(stderr, fmt, args);
    va_end(args);

    fprintf(stderr, "\n");
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
testb %al, %al
je 0x59c6
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testl %edi, 0x179b0(%rip)     # 0x1d390
jne 0x59ed
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
movq %rsi, %rbx
leaq 0xe411(%rip), %rdx      # 0x13e08
leal -0x1(%rdi), %eax
cmpl $0x7, %eax
ja 0x5a18
leaq 0xe3aa(%rip), %rcx      # 0x13db0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xe619(%rip), %rdx      # 0x1402f
jmp 0x5a3f
cmpl $0x10, %edi
jne 0x5a3f
leaq 0xe5ec(%rip), %rdx      # 0x14010
jmp 0x5a3f
leaq 0xf26a(%rip), %rdx      # 0x14c97
jmp 0x5a3f
leaq 0xe3d6(%rip), %rdx      # 0x13e0c
jmp 0x5a3f
leaq 0xe3cb(%rip), %rdx      # 0x13e0a
movq 0x17592(%rip), %r14     # 0x1cfd8
movq (%r14), %rdi
leaq 0xe3be(%rip), %rsi      # 0x13e0e
xorl %eax, %eax
callq 0x3480
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x3450
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x3410
jmp 0x59e2