LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/permutation.c
// Function: gen_random_permutation
void gen_random_permutation(perm_t *perm, size_t nr, size_t base) {
  size_t i;

  for (i = 0; i < nr; ++i) {
    size_t t = rng_int(i);
    perm[i] = perm[t];
    perm[t] = base + i;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
leaq 0xc(%rsp), %rbp
leaq 0x8(%rsp), %r12
cmpq %r13, %r14
je 0x4076f5
movq %fs:-0x58, %rdi
leaq 0x14(%rsp), %rsi
callq 0x412520
testl %eax, %eax
jne 0x407704
movq %fs:-0x58, %rdi
leaq 0x10(%rsp), %rsi
callq 0x412520
testl %eax, %eax
jne 0x407704
movq %fs:-0x58, %rdi
movq %rbp, %rsi
callq 0x412520
testl %eax, %eax
jne 0x407704
movq %fs:-0x58, %rdi
movq %r12, %rsi
callq 0x412520
testl %eax, %eax
jne 0x407704
movzwl 0x14(%rsp), %eax
movl 0x10(%rsp), %ecx
shll $0x10, %ecx
orq %rax, %rcx
movl 0xc(%rsp), %eax
movzwl %ax, %edx
shlq $0x20, %rdx
orq %rcx, %rdx
movl 0x8(%rsp), %eax
shlq $0x30, %rax
orq %rdx, %rax
leaq 0x1(%r13), %rcx
xorl %edx, %edx
divq %rcx
movq (%r15,%rdx,8), %rax
movq %rax, (%r15,%r13,8)
addq %rbx, %r13
movq %r13, (%r15,%rdx,8)
movq %rcx, %r13
jmp 0x407644
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcaabb(%rip), %rdi     # 0x4d21c6
callq 0x4130f0
pushq $0x1
popq %rdi
callq 0x411e30
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/permutation.c
// Function: is_a_permutation
int is_a_permutation(const perm_t *perm, size_t nr_elts) {
  uint8_t *vec;
  size_t vec_len = (nr_elts + 7) / 8;
  size_t i;

  vec = malloc(vec_len);
  memset(vec, 0, vec_len);

  for (i = 0; i < nr_elts; ++i) {
    size_t vec_elt = perm[i] / 8;
    size_t test_bit = 1u << (perm[i] % 8);
    if (vec[vec_elt] & test_bit) {
      free(vec);
      return 0;
    }
    vec[vec_elt] |= test_bit;
  }
  for (i = 0; i < nr_elts / 8; ++i) {
    if (vec[i] != 0xff) {
      free(vec);
      return 0;
    }
  }
  if (nr_elts % 8) {
    if (vec[vec_len - 1] != ((1u << (nr_elts % 8)) - 1)) {
      free(vec);
      return 0;
    }
  }
  free(vec);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
leaq 0x7(%rsi), %r14
shrq $0x3, %r14
pushq $0x1
popq %rdi
movq %r14, %rsi
callq 0x4364f0
xorl %edx, %edx
pushq $0x1
popq %rbx
cmpq %rdx, %r15
je 0x407787
movq (%r12,%rdx,8), %r8
movq %r8, %rsi
movl %r8d, %ecx
andb $0x7, %cl
movl %ebx, %edi
shll %cl, %edi
shrq $0x3, %rsi
movzbl (%rax,%rsi), %ecx
andl $0x7, %r8d
btl %r8d, %ecx
jb 0x4077bc
orb %cl, %dil
movb %dil, (%rax,%rsi)
incq %rdx
jmp 0x407753
movq %r15, %rcx
shrq $0x3, %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x4077a1
cmpb $-0x1, (%rax,%rdx)
leaq 0x1(%rdx), %rdx
je 0x407790
jmp 0x4077bc
andq $0x7, %r15
je 0x4077d4
pushq $-0x1
popq %rdx
movl %r15d, %ecx
shll %cl, %edx
movzbl -0x1(%rax,%r14), %ecx
xorl %ecx, %edx
cmpl $-0x1, %edx
je 0x4077d4
movq %rax, %rdi
callq 0x4353e0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x4353e0
jmp 0x4077c6
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/permutation.c
// Function: generate_chase_mixer
void generate_chase_mixer(struct generate_chase_common_args *args,
                          size_t nr_mixers) {
  size_t nr_mixer_indices = args->nr_mixer_indices;
  void (*gen_permutation)(perm_t *, size_t, size_t) = args->gen_permutation;

  /* Set number of mixers rounded up to the power of two */
  if (nr_mixers > 1) {
    args->nr_mixers = 1 << (CHAR_BIT * sizeof(long) -
                            __builtin_clzl(nr_mixers - 1));
  } else {
    args->nr_mixers = 1;
  }

  if (args->nr_mixers < 64) {
    args->nr_mixers = 64;
  }

  if (verbosity > 1)
    printf("nr_mixers = %zu\n", args->nr_mixers);
  perm_t *t = malloc(nr_mixer_indices * sizeof(*t));
  if (t == NULL) {
    fprintf(stderr, "Could not allocate %lu bytes, check stride/memory size?\n",
            nr_mixer_indices * sizeof(*t));
    exit(1);
  }
  perm_t *r = malloc(nr_mixer_indices * args->nr_mixers * sizeof(*r));
  if (r == NULL) {
    fprintf(stderr, "Could not allocate %lu bytes, check stride/memory size?\n",
            nr_mixer_indices * args->nr_mixers * sizeof(*r));
    exit(1);
  }
  size_t i;
  size_t j;

  // we arrange r in a transposed manner so that all of the
  // data for a particular mixer_idx is packed together.
  for (i = 0; i < args->nr_mixers; ++i) {
    gen_permutation(t, nr_mixer_indices, 0);
    for (j = 0; j < nr_mixer_indices; ++j) {
      r[j * args->nr_mixers + i] = t[j];
    }
  }
  free(t);

  args->mixer = r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x2, %rsi
jb 0x407811
pushq $0x1
popq %rax
decq %rsi
bsrq %rsi, %rcx
xorl $0x3f, %ecx
negb %cl
shll %cl, %eax
cmpl $0x41, %eax
pushq $0x40
popq %rcx
cmovael %eax, %ecx
movslq %ecx, %rsi
jmp 0x407814
pushq $0x40
popq %rsi
movq 0x28(%rbx), %rax
movq %rax, (%rsp)
movq 0x30(%rbx), %r14
movq %rsi, 0x20(%rbx)
movq $0x50a310, %rax         # imm = 0x50A310
cmpl $0x2, (%rax)
jl 0x40783e
leaq 0xca817(%rip), %rdi     # 0x4d204e
xorl %eax, %eax
callq 0x412ec0
leaq (,%r14,8), %r13
movq %r13, %rdi
callq 0x4350a0
testq %rax, %rax
je 0x4078c5
movq %rax, %r15
movq 0x20(%rbx), %rbp
imulq %rbp, %r13
movq %r13, %rdi
callq 0x4350a0
testq %rax, %rax
je 0x4078c5
movq %rax, %r12
xorl %r13d, %r13d
cmpq %rbp, %r13
jae 0x4078aa
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq *(%rsp)
leaq (%r12,%r13,8), %rax
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x4078a1
movq (%r15,%rcx,8), %rdx
movq 0x20(%rbx), %rsi
imulq %rcx, %rsi
movq %rdx, (%rax,%rsi,8)
incq %rcx
jmp 0x407887
incq %r13
movq 0x20(%rbx), %rbp
jmp 0x407871
movq %r15, %rdi
callq 0x4353e0
movq %r12, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $0x508708, %rax         # imm = 0x508708
movq (%rax), %rdi
leaq 0xca789(%rip), %rsi     # 0x4d205f
movq %r13, %rdx
xorl %eax, %eax
callq 0x412e00
pushq $0x1
popq %rdi
callq 0x411e30
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/arena.c
// Function: get_native_page_size
size_t get_native_page_size(void) {
  long sz;

  sz = sysconf(_SC_PAGESIZE);
  if (sz < 0) {
    perror("failed to get native page size");
    exit(1);
  }

  return (size_t)sz;
}

// Assembly:
pushq %rax
pushq $0x1e
popq %rdi
callq 0x464640
testq %rax, %rax
js 0x407eac
popq %rcx
retq
leaq 0xca35a(%rip), %rdi     # 0x4d220d
callq 0x4130f0
pushq $0x1
popq %rdi
callq 0x411e30
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/arena.c
// Function: print_page_size
void print_page_size(size_t page_size, bool use_thp) {
  FILE *f;
  size_t read;
  /* Big enough to fit UINT64_MAX + '\n' + '\0'. */
  char buf[22];

  if (!use_thp) {
    printf("page_size = %zu bytes\n", page_size);
    return;
  }

  f = fopen("/sys/kernel/mm/transparent_hugepage/hpage_pmd_size", "r");
  if (!f) goto err;

  read = fread(buf, 1, sizeof(buf) - 1, f);
  if (!feof(f) || (ferror(f) && !feof(f))) goto err;

  if (fclose(f)) goto err;

  if (buf[read - 1] == '\n') --read;
  buf[read] = '\0';

  printf("page_size = %s bytes (THP)\n", buf);
  return;

err:
  perror(
      "page_size = <failed to read "
      "/sys/kernel/mm/transparent_hugepage/hpage_pmd_size>");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
je 0x407f6e
leaq 0xca35c(%rip), %rdi     # 0x4d2243
leaq 0xca0c4(%rip), %rsi     # 0x4d1fb2
callq 0x421c70
testq %rax, %rax
je 0x407f89
movq %rax, %rbx
movq %rsp, %rdi
pushq $0x1
popq %rsi
pushq $0x15
popq %rdx
movq %rax, %rcx
callq 0x421d70
movq %rax, %r14
movq %rbx, %rdi
callq 0x424430
testl %eax, %eax
je 0x407f89
movq %rbx, %rdi
callq 0x424500
testl %eax, %eax
je 0x407f37
movq %rbx, %rdi
callq 0x424430
testl %eax, %eax
je 0x407f89
movq %rbx, %rdi
callq 0x421540
testl %eax, %eax
jne 0x407f89
cmpb $0xa, -0x1(%rsp,%r14)
leaq -0x1(%r14), %rax
cmovneq %r14, %rax
movb $0x0, (%rsp,%rax)
leaq 0xca31a(%rip), %rdi     # 0x4d2276
movq %rsp, %rsi
xorl %eax, %eax
callq 0x412ec0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %rax
leaq 0xca2b4(%rip), %rdi     # 0x4d222c
movq %rax, %rsi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x412ec0
leaq 0xca302(%rip), %rdi     # 0x4d2292
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x4130f0
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/arena.c
// Function: read_sysfs_state_file
static char *read_sysfs_state_file(char const *path) {
  FILE *f = fopen(path, "r");
  char *token = NULL;
  int ret;

  if (f == NULL) {
    perror("open sysfs state file");
    exit(1);
  }

  while ((ret = fscanf(f, "%ms", &token)) == 1) {
    if (token[0] == '[') break;

    free(token);
    token = NULL;
  }

  if (ferror(f) && !feof(f)) {
    perror("read sysfs state file");
    exit(1);
  }

  if (fclose(f)) {
    perror("close sysfs state file");
    exit(1);
  }

  return token;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc9bdb(%rip), %rsi     # 0x4d1fb2
callq 0x421c70
andq $0x0, 0x8(%rsp)
testq %rax, %rax
je 0x408455
movq %rax, %rbx
leaq 0xca005(%rip), %r14     # 0x4d23f6
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x4131b0
cmpl $0x1, %eax
jne 0x408422
movq 0x8(%rsp), %rdi
cmpb $0x5b, (%rdi)
je 0x408422
callq 0x4353e0
andq $0x0, 0x8(%rsp)
jmp 0x4083f6
movq %rbx, %rdi
callq 0x424500
testl %eax, %eax
je 0x40843a
movq %rbx, %rdi
callq 0x424430
testl %eax, %eax
je 0x408467
movq %rbx, %rdi
callq 0x421540
testl %eax, %eax
jne 0x40845e
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xc9f84(%rip), %rdi     # 0x4d23e0
jmp 0x40846e
leaq 0xc9fab(%rip), %rdi     # 0x4d2410
jmp 0x40846e
leaq 0xc9f8c(%rip), %rdi     # 0x4d23fa
callq 0x4130f0
pushq $0x1
popq %rdi
callq 0x411e30
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/arena.c
// Function: write_sysfs_file
static void write_sysfs_file(char const *path, char const *value) {
  FILE *f = fopen(path, "w");

  if (f == NULL) {
    perror("open sysfs file for write");
    exit(1);
  }

  if (fprintf(f, "%s\n", value) < 0) {
    perror("write value to sysfs file");
    exit(1);
  }

  if (fclose(f)) {
    perror("close sysfs file");
    exit(1);
  }
}

// Assembly:
pushq %rbx
leaq 0xc9fa4(%rip), %rsi     # 0x4d2427
callq 0x421c70
testq %rax, %rax
je 0x4084ba
movq %rax, %rbx
leaq 0xc8d03(%rip), %rsi     # 0x4d119a
leaq 0xc9e49(%rip), %rdx     # 0x4d22e7
movq %rax, %rdi
xorl %eax, %eax
callq 0x412e00
testl %eax, %eax
js 0x4084c3
movq %rbx, %rdi
callq 0x421540
testl %eax, %eax
jne 0x4084cc
popq %rbx
retq
leaq 0xc9f68(%rip), %rdi     # 0x4d2429
jmp 0x4084d3
leaq 0xc9f79(%rip), %rdi     # 0x4d2443
jmp 0x4084d3
leaq 0xc9f8a(%rip), %rdi     # 0x4d245d
callq 0x4130f0
pushq $0x1
popq %rdi
callq 0x411e30
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/br_asm.c
// Function: convert_pointers_to_branches
int convert_pointers_to_branches(void *head, int chunk_size) {
  int remain = cycle_len(head);
  chunk_size = (remain < chunk_size)
                   ? remain
                   : remain / (1 << lround(log2(1.0 * remain / chunk_size)));
  int base_chunk_size = chunk_size;
  int chunks_remaining = remain / chunk_size;
  int chunk_count = 0;
  const int br_code_len = 12;  // len(mov_imm64) + max(len(jmp), len(ret))
  char *p = (char *)head;
  do {
    if (!chunk_count) chunk_count = remain / chunks_remaining;
    char *next = *((char **)p);
    for (int i = 8; i < br_code_len; i++) {
      if (p[i]) {
        fprintf(stderr, "not enough space to convert a pointer to branches\n");
        exit(1);
      }
    }
    p = x64_emit_mov_imm64_rax(p, (intptr_t)next);
    // At end of branch chunk, return with a pointer to the next chunk.
    --remain;
    if (--chunk_count == 0) {
      p = x64_emit_ret(p);
      --chunks_remaining;
    } else {
      p = x64_emit_jmp_to_rax(p);
    }
    p = next;
  } while (p != head);
  return base_chunk_size;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movq %rdi, %rax
incl %ebp
movq (%rax), %rax
cmpq %rbx, %rax
jne 0x4084eb
movl %ebp, %r8d
cmpl %esi, %ebp
jl 0x40851a
cvtsi2sd %ebp, %xmm0
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
callq 0x408640
callq 0x408940
movl %ebp, %r8d
movl %eax, %ecx
shrl %cl, %r8d
movl %ebp, %eax
cltd
idivl %r8d
movl %eax, %edi
xorl %eax, %eax
pushq $0x8
popq %rsi
movq %rbx, %r9
testl %eax, %eax
jne 0x408533
movl %ebp, %eax
cltd
idivl %edi
movq (%r9), %rdx
movq %rsi, %rcx
cmpq $0xc, %rcx
je 0x40854c
cmpb $0x0, (%r9,%rcx)
leaq 0x1(%rcx), %rcx
je 0x408539
jmp 0x408598
movw $0xb848, (%r9)          # imm = 0xB848
addq $0x2, %r9
xorl %ecx, %ecx
cmpq $0x40, %rcx
je 0x408570
movq %rdx, %r10
shrq %cl, %r10
movb %r10b, (%r9)
incq %r9
addq $0x8, %rcx
jmp 0x408558
decl %eax
je 0x40857d
movb $-0x20, 0x1(%r9)
movb $-0x1, %cl
jmp 0x408581
decl %edi
movb $-0x3d, %cl
decl %ebp
movb %cl, (%r9)
movq %rdx, %r9
cmpq %rbx, %rdx
jne 0x40852a
movl %r8d, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq $0x508708, %rax         # imm = 0x508708
movq (%rax), %rcx
leaq 0xc9ef2(%rip), %rdi     # 0x4d249b
pushq $0x32
popq %rsi
pushq $0x1
popq %rdx
callq 0x421e70
pushq $0x1
popq %rdi
callq 0x411e30
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/util.c
// Function: parse_mem_arg
int parse_mem_arg(const char *str, size_t *result) {
  size_t r;
  char *p;

  r = strtoull(str, &p, 0);
  switch (*p) {
    case 'k':
    case 'K':
      r *= 1024;
      ++p;
      break;
    case 'm':
    case 'M':
      r *= 1024 * 1024;
      ++p;
      break;
    case 'g':
    case 'G':
      r *= 1024 * 1024 * 1024;
      ++p;
      break;
  }
  if (*p) {
    return -1;
  }
  *result = r;
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsp, %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x4125e0
movq (%r14), %rdx
movzbl (%rdx), %ecx
movl %ecx, %esi
addl $-0x47, %esi
cmpl $0x26, %esi
ja 0x408621
movabsq $0x100000001, %rdi      # imm = 0x100000001
btq %rsi, %rdi
jb 0x408618
movabsq $0x1000000010, %rdi     # imm = 0x1000000010
btq %rsi, %rdi
jb 0x408614
movabsq $0x4000000040, %rdi     # imm = 0x4000000040
btq %rsi, %rdi
jae 0x408621
pushq $0x14
jmp 0x40861a
pushq $0xa
jmp 0x40861a
pushq $0x1e
popq %rcx
shlq %cl, %rax
movb 0x1(%rdx), %cl
testb %cl, %cl
je 0x40862a
pushq $-0x1
popq %rax
jmp 0x40862f
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/hs1sivv2/ref/encrypt.c
// Function: chacha
void chacha(chacha_ctx_t *x,unsigned char *out,unsigned bytes)
{
  unsigned char output[64];
  unsigned i;

  if (!bytes) return;
  for (;;) {
    salsa20_wordtobyte(output,x->input);
    x->input[12] += 1;
    if (bytes <= 64) {
      for (i = 0;i < bytes;++i) out[i] = output[i];
      return;
    }
    for (i = 0;i < 64;++i) out[i] = output[i];
    bytes -= 64;
    out += 64;
  }
}

// Assembly:
testl %edx, %edx
je 0x13f0
pushq %rax
movl $0xfffffff4, %eax       # imm = 0xFFFFFFF4
xorl %ecx, %ecx
cmpq $0x10, %rcx
je 0x12a7
movl (%rdi,%rcx,4), %r8d
movl %r8d, -0x80(%rsp,%rcx,4)
incq %rcx
jmp 0x1293
vmovdqa -0x70(%rsp), %xmm1
vmovdqa -0x60(%rsp), %xmm0
vmovdqa -0x50(%rsp), %xmm2
vpshufd $0x4e, -0x80(%rsp), %xmm3 # xmm3 = mem[2,3,0,1]
movl %eax, %ecx
vpshufd $0x4e, %xmm3, %xmm3     # xmm3 = xmm3[2,3,0,1]
testl %ecx, %ecx
je 0x1368
vpaddd %xmm3, %xmm1, %xmm3
vpxor %xmm2, %xmm3, %xmm2
vprold $0x10, %xmm2, %xmm2
vpaddd %xmm0, %xmm2, %xmm0
vpxor %xmm1, %xmm0, %xmm1
vprold $0xc, %xmm1, %xmm1
vpaddd %xmm3, %xmm1, %xmm3
vpxor %xmm2, %xmm3, %xmm2
vprold $0x8, %xmm2, %xmm2
vpaddd %xmm0, %xmm2, %xmm0
vpxor %xmm1, %xmm0, %xmm1
vpshufd $0x93, %xmm1, %xmm1     # xmm1 = xmm1[3,0,1,2]
vprold $0x7, %xmm1, %xmm1
vpshufd $0x4e, %xmm3, %xmm3     # xmm3 = xmm3[2,3,0,1]
vpaddd %xmm3, %xmm1, %xmm3
vpshufd $0x39, %xmm2, %xmm2     # xmm2 = xmm2[1,2,3,0]
vpxor %xmm3, %xmm2, %xmm2
vprold $0x10, %xmm2, %xmm2
vpaddd %xmm2, %xmm0, %xmm0
vpxor %xmm1, %xmm0, %xmm1
vprold $0xc, %xmm1, %xmm1
vpaddd %xmm3, %xmm1, %xmm3
vpxor %xmm2, %xmm3, %xmm2
vprold $0x8, %xmm2, %xmm2
vpaddd %xmm0, %xmm2, %xmm0
vpxor %xmm1, %xmm0, %xmm1
vpshufd $0x39, %xmm1, %xmm1     # xmm1 = xmm1[1,2,3,0]
vprold $0x7, %xmm1, %xmm1
vpshufd $0x93, %xmm2, %xmm2     # xmm2 = xmm2[3,0,1,2]
addl $0x2, %ecx
jmp 0x12c2
vmovdqa %xmm1, -0x70(%rsp)
vmovdqa %xmm3, -0x80(%rsp)
vmovdqa %xmm2, -0x50(%rsp)
vmovdqa %xmm0, -0x60(%rsp)
xorl %ecx, %ecx
cmpq $0x10, %rcx
je 0x1396
movl (%rdi,%rcx,4), %r8d
addl %r8d, -0x80(%rsp,%rcx,4)
incq %rcx
jmp 0x1382
xorl %ecx, %ecx
cmpq $0x10, %rcx
je 0x13ad
movl -0x80(%rsp,%rcx,4), %r8d
movl %r8d, -0x40(%rsp,%rcx,4)
incq %rcx
jmp 0x1398
incl 0x30(%rdi)
cmpl $0x41, %edx
jb 0x13d7
xorl %ecx, %ecx
cmpq $0x40, %rcx
je 0x13cb
movb -0x40(%rsp,%rcx), %r8b
movb %r8b, (%rsi,%rcx)
incq %rcx
jmp 0x13b7
addl $-0x40, %edx
addq $0x40, %rsi
jmp 0x1291
movl %edx, %eax
xorl %ecx, %ecx
cmpq %rax, %rcx
jae 0x13ec
movb -0x40(%rsp,%rcx), %dl
movb %dl, (%rsi,%rcx)
incq %rcx
jmp 0x13db
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/hs1sivv2/ref/encrypt.c
// Function: hs1siv_chacha256
void hs1siv_chacha256(void *out, unsigned outbytes,
                      unsigned char *iv, void *user_key)
{
    chacha_ctx_t ctx;

    chacha_keysetup(&ctx, user_key, 256);
    chacha_ivsetup(&ctx,iv);
    chacha(&ctx,out,outbytes);
}

// Assembly:
subq $0x48, %rsp
vmovups (%rcx), %ymm0
movq %rsp, %rax
vmovups %ymm0, 0x10(%rax)
vmovaps 0xbf7(%rip), %xmm0      # 0x2000
vmovaps %xmm0, (%rax)
andl $0x0, 0x30(%rax)
movl %esi, %ecx
movq %rdi, %rsi
movq (%rdx), %rdi
movq %rdi, 0x34(%rax)
movl 0x8(%rdx), %edx
movl %edx, 0x3c(%rax)
movq %rax, %rdi
movl %ecx, %edx
vzeroupper
callq 0x10d0
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/hs1sivv2/ref/encrypt.c
// Function: hs1siv_subkeygen
void hs1siv_subkeygen(hs1siv_ctx_t *ctx, void *user_key, unsigned key_bytes)
{
    unsigned char chacha_key[32];
    unsigned char iv[12];
    unsigned i=0;

    /* Copy user_key as many times as needed to fill 32 byte chacha key */
    while (i < 32) {
        unsigned nbytes = 32-i;
        if (nbytes > key_bytes) nbytes = key_bytes;
        memcpy(chacha_key+i,user_key,nbytes);
        i += nbytes;
    }

    /* Build key-derivation nonce and fill context */
    memset(iv,0,12);
    iv[0] = key_bytes;
    iv[2] = HS1_SIV_SIV_LEN;
    iv[4] = HS1_SIV_CHACHA_RNDS;
    iv[5] = HS1_SIV_HASH_RNDS;
    iv[6] = HS1_SIV_NH_LEN;
    hs1siv_chacha256(ctx, sizeof(hs1siv_ctx_t), iv, chacha_key);

    /* Pre-process internal keys: make future reads little-endian, mod poly */
    for (i=0; i<sizeof(ctx->nh_key)/4; i++)
        ((uint32_t *)ctx->nh_key)[i] = read32le(((uint32_t *)ctx->nh_key)+i);
    for (i=0; i<sizeof(ctx->poly_key)/8; i++)
        ((uint64_t *)ctx->poly_key)[i] = read64le(((uint64_t *)ctx->poly_key)+i)
                                       & m60;
    #if (HS1_SIV_HASH_RNDS > 4)
    for (i=0; i<sizeof(ctx->asu_key)/8; i++)
        ((uint64_t *)ctx->asu_key)[i] = read64le(((uint64_t *)ctx->asu_key)+i);
    #endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r13d, %r13d
pushq $0x20
popq %r12
cmpl $0x1f, %r13d
ja 0x1836
movl %r12d, %r15d
subl %r13d, %r15d
cmpl %ebp, %r15d
cmovael %ebp, %r15d
movl %r13d, %eax
leaq (%rsp,%rax), %rdi
addq $0x10, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1110
addl %r13d, %r15d
movl %r15d, %r13d
jmp 0x1805
leaq 0x4(%rsp), %rdx
andq $0x0, 0x1(%rdx)
andl $0x0, 0x8(%rdx)
movb %bpl, (%rdx)
movb $0x10, 0x2(%rdx)
movw $0x40c, 0x4(%rdx)       # imm = 0x40C
movb $0x40, 0x6(%rdx)
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movl $0xb0, %esi
callq 0x10a0
xorl %eax, %eax
cmpq $0x4, %rax
je 0x187c
andb $0xf, 0x97(%rbx,%rax,8)
incq %rax
jmp 0x1869
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/hs1sivv2/ref/encrypt.c
// Function: hs1
void hs1(
    hs1siv_ctx_t *hs1_ctx,
    void *in, unsigned inbytes,
    void *iv,
    void *out, unsigned outbytes
)
{
    #if (HS1_SIV_HASH_RNDS > 4)
    uint64_t h[HS1_SIV_HASH_RNDS/2];
    #else
    uint64_t h[HS1_SIV_HASH_RNDS];
    #endif

    unsigned i;
    unsigned char key[32];
    chacha_ctx_t chacha_ctx;

    hs1_hash(hs1_ctx, in, inbytes, h);
    memcpy(key, hs1_ctx->chacha_key, 32);
    for (i=0; i<sizeof(h)/8;i++) ((uint64_t *)key)[i] ^= h[i];
    chacha_keysetup(&chacha_ctx, key, 256);
    chacha_ivsetup(&chacha_ctx,(unsigned char *)iv);
    chacha(&chacha_ctx, (unsigned char *)out, outbytes);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r12
leaq 0x20(%rsp), %rcx
callq 0x1050
vmovups (%r12), %ymm0
vmovups %ymm0, (%rsp)
xorl %eax, %eax
cmpq $0x4, %rax
je 0x18d0
movq 0x20(%rsp,%rax,8), %rcx
xorq %rcx, (%rsp,%rax,8)
incq %rax
jmp 0x18bc
vmovups (%rsp), %ymm0
leaq 0x40(%rsp), %rdi
vmovups %ymm0, 0x10(%rdi)
vmovaps 0x719(%rip), %xmm0      # 0x2000
vmovaps %xmm0, (%rdi)
andl $0x0, 0x30(%rdi)
movq (%r15), %rax
movq %rax, 0x34(%rdi)
movl 0x8(%r15), %eax
movl %eax, 0x3c(%rdi)
movq %r14, %rsi
movl %ebx, %edx
vzeroupper
callq 0x10d0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/hs1sivv2/ref/encrypt.c
// Function: hs1siv_encrypt
void hs1siv_encrypt(hs1siv_ctx_t *ctx, void *m, unsigned mbytes,
                    void *a, unsigned abytes, void *n, void *t, void *c)
{
    unsigned i;
    unsigned abuflen = (abytes+HS1_SIV_NH_LEN-1)/HS1_SIV_NH_LEN*HS1_SIV_NH_LEN;
    unsigned buflen = abuflen + (mbytes+15)/16*16 + 16;
    unsigned char tmp_t[HS1_SIV_SIV_LEN];
    unsigned char *buf = (unsigned char *)malloc(buflen);
    memset(buf, 0, buflen);
    memcpy(buf, a, abytes);
    memcpy(buf+abuflen, m, mbytes);
    write32le((uint32_t *)(buf+buflen-16), abytes);
    write32le((uint32_t *)(buf+buflen-8), mbytes);
    hs1(ctx, buf, buflen, n, tmp_t, HS1_SIV_SIV_LEN);
    free(buf);
    buf = (unsigned char *)malloc(mbytes+64);
    hs1(ctx, tmp_t, HS1_SIV_SIV_LEN, n, buf, mbytes+64);
    for (i=0; i<mbytes; i++)
        buf[64+i] ^= ((unsigned char *)m)[i];
    memcpy(c,buf+64,mbytes);
    memcpy(t,tmp_t,HS1_SIV_SIV_LEN);
    free(buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x18(%rsp)
movl %r8d, %ebx
movq %rcx, 0x8(%rsp)
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
leal 0x3f(%rbx), %r13d
andl $-0x40, %r13d
leal 0xf(%r12), %eax
andl $-0x10, %eax
leal (%rax,%r13), %r15d
addl $0x10, %r15d
pushq $0x1
popq %rdi
movq %r15, %rsi
callq 0x10e0
movq %rax, %rbp
movl %ebx, %edx
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x1110
addq %rbp, %r13
movl %r12d, %edx
movq %rdx, 0x8(%rsp)
movq %r13, %rdi
movq %r14, %rsi
callq 0x1110
movl %ebx, -0x10(%rbp,%r15)
movl %r12d, -0x8(%rbp,%r15)
leaq 0x30(%rsp), %r8
pushq $0x10
popq %r9
movq 0x10(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rsi
movl %r15d, %edx
movq 0x18(%rsp), %r15
movq %r15, %rcx
callq 0x1100
movq %rbp, %rdi
callq 0x1080
addl $0x40, %r12d
movq %r12, %rdi
callq 0x1060
movq %rax, %rbx
movq %r13, %rdi
leaq 0x30(%rsp), %rsi
pushq $0x10
popq %rdx
movq %r15, %rcx
movq %rax, %r8
movl %r12d, %r9d
callq 0x1100
movq 0x8(%rsp), %rdx
movq %rdx, %rax
negq %rax
pushq $0x40
popq %rcx
leaq (%rax,%rcx), %rsi
cmpq $0x40, %rsi
je 0x1a2a
movb -0x40(%r14,%rcx), %dil
movl %ecx, %esi
xorb %dil, (%rbx,%rsi)
incq %rcx
jmp 0x1a10
movq %rbx, %rsi
addq $0x40, %rsi
movq 0x20(%rsp), %rdi
callq 0x1110
vmovaps 0x30(%rsp), %xmm0
movq 0x28(%rsp), %rax
vmovups %xmm0, (%rax)
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1080
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/hs1sivv2/ref/encrypt.c
// Function: hs1siv_decrypt
int hs1siv_decrypt(hs1siv_ctx_t *ctx, void *c, unsigned cbytes,
                   void *a, unsigned abytes, void *n, void *t, void *m)
{
    unsigned i;
    unsigned abuflen = (abytes+HS1_SIV_NH_LEN-1)/HS1_SIV_NH_LEN*HS1_SIV_NH_LEN;
    unsigned buflen = abuflen + (cbytes+15)/16*16 + 16;
    unsigned char *maybe_m = (unsigned char *)malloc(cbytes);
    unsigned char maybe_t[HS1_SIV_SIV_LEN];
    unsigned char *buf = (unsigned char *)malloc(cbytes+64);
    hs1(ctx, t, HS1_SIV_SIV_LEN, n, buf, cbytes+64);
    for (i=0; i<cbytes; i++)
        ((unsigned char *)maybe_m)[i] = ((unsigned char *)c)[i] ^ buf[64+i];
    free(buf);
    buf = (unsigned char *)malloc(buflen);
    memset(buf, 0, buflen);
    memcpy(buf, a, abytes);
    memcpy(buf+abuflen, maybe_m, cbytes);
    write32le((uint32_t *)(buf+buflen-16), abytes);
    write32le((uint32_t *)(buf+buflen-8), cbytes);
    hs1(ctx, buf, buflen, n, maybe_t, HS1_SIV_SIV_LEN);
    free(buf);
    if (memcmp(t,maybe_t,HS1_SIV_SIV_LEN) == 0) {
        memcpy(m,maybe_m,cbytes);
        free(maybe_m);
        return 0;
    } else {
        free(maybe_m);
        return -1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq %r8, 0x38(%rsp)
leal 0x3f(%r8), %eax
movq %rax, 0x20(%rsp)
leal 0xf(%r15), %r13d
andl $-0x10, %r13d
addl $0x10, %r13d
movl %edx, %ebp
movq %rbp, %rdi
callq 0x1060
movq %rax, %r14
movq %r15, 0x30(%rsp)
addl $0x40, %r15d
movq %r15, %rdi
callq 0x1060
movq %rax, %r12
pushq $0x10
popq %rdx
movq 0x8(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x10(%rsp), %rcx
movq %rax, %r8
movl %r15d, %r9d
callq 0x1100
movq %rbp, 0x28(%rsp)
negq %rbp
pushq $0x40
popq %rcx
leaq (%rcx,%rbp), %rdx
cmpq $0x40, %rdx
je 0x1b07
movl %ecx, %edx
movb (%r12,%rdx), %dl
xorb -0x40(%rbx,%rcx), %dl
movb %dl, -0x40(%r14,%rcx)
incq %rcx
jmp 0x1ae9
movq 0x20(%rsp), %r15
andl $-0x40, %r15d
addl %r15d, %r13d
movq %r12, %rdi
callq 0x1080
pushq $0x1
popq %rdi
movq %r13, %rsi
callq 0x10e0
movq %rax, %rbx
movq 0x38(%rsp), %rbp
movl %ebp, %edx
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x1110
addq %rbx, %r15
movq %r15, %rdi
movq %r14, %rsi
movq 0x28(%rsp), %r12
movq %r12, %rdx
callq 0x1110
movl %ebp, -0x10(%rbx,%r13)
movq 0x30(%rsp), %rax
movl %eax, -0x8(%rbx,%r13)
leaq 0x40(%rsp), %r15
pushq $0x10
popq %r9
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl %r13d, %edx
movq 0x10(%rsp), %rcx
movq %r15, %r8
callq 0x1100
movq %rbx, %rdi
callq 0x1080
movq 0x90(%rsp), %rax
vmovdqu (%rax), %xmm0
vpxor (%r15), %xmm0, %xmm0
vptest %xmm0, %xmm0
je 0x1ba8
pushq $-0x1
popq %rbx
jmp 0x1bbd
movq 0x98(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1110
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x1080
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/hs1sivv2/ref/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
    unsigned char *c,unsigned long long *clen,
    const unsigned char *m,unsigned long long mlen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *nsec,
    const unsigned char *npub,
    const unsigned char *k
)
{
    hs1siv_ctx_t ctx;
    (void)nsec;
    hs1siv_subkeygen(&ctx, (void *)k, CRYPTO_KEYBYTES);
    if (clen) *clen = mlen+CRYPTO_ABYTES;
    hs1siv_encrypt(&ctx, (void *)m, mlen, (void *)ad, adlen, (void *)npub,
                   c+mlen, c);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %r15
movq 0x100(%rsp), %rsi
movq %rsp, %rdi
pushq $0x10
popq %rdx
callq 0x10c0
testq %r13, %r13
je 0x1c1a
leaq 0x10(%r12), %rax
movq %rax, (%r13)
movq %r12, %rax
addq %r15, %rax
movq %rsp, %rdi
movq %rbp, %rsi
movl %r12d, %edx
movq %r14, %rcx
movl %ebx, %r8d
movq 0xf8(%rsp), %r9
pushq %r15
pushq %rax
callq 0x10f0
popq %rax
popq %rcx
xorl %eax, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/hs1sivv2/ref/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
    unsigned char *m,unsigned long long *mlen,
    unsigned char *nsec,
    const unsigned char *c,unsigned long long clen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *npub,
    const unsigned char *k
)
{
    hs1siv_ctx_t ctx;
    (void)nsec;
    if (mlen) *mlen = clen-CRYPTO_ABYTES;
    hs1siv_subkeygen(&ctx, (void *)k, CRYPTO_KEYBYTES);
    return hs1siv_decrypt(&ctx, (void *)c, clen-CRYPTO_ABYTES,
    	(void *)ad, adlen, (void *)npub, (void *)(c+clen-CRYPTO_ABYTES), m);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %rbx
movq %r8, %rbp
movq %rcx, %r15
movq %rsi, %rax
movq %rdi, %r14
movq 0x100(%rsp), %rsi
movq 0xf0(%rsp), %r13
testq %rax, %rax
je 0x1c91
leaq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq %rsp, %r12
pushq $0x10
popq %rdx
movq %r12, %rdi
callq 0x10c0
leal -0x10(%rbp), %edx
leaq (%r15,%rbp), %rax
addq $-0x10, %rax
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rcx
movl %r13d, %r8d
movq 0xf8(%rsp), %r9
pushq %r14
pushq %rax
callq 0x1040
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mishun[P]plantri/plantri.c
// Function: make_me_a_star
static void
make_me_a_star(int n)

/* Makes a star on n vertices -- so one vertex of degree n-1
   and n-1 vertices of degree 1 */
{
   int i;
   EDGE *buffer, *buffer2;

   if (n==1) { nv=1; ne=0; firstedge[0]=NULL; return; }

   firstedge[0]=edges;
   degree[0]=n-1;
   for (i=1, buffer=edges, buffer2=edges+n-1;
	i<=n-1;i++,buffer++,buffer2++)
     { buffer->start=buffer2->end=0;
       buffer->end=buffer2->start=i;
       buffer->invers=buffer2;
       buffer2->invers=buffer;
       buffer->min=buffer2->min=buffer;
       buffer2->prev=buffer2->next=buffer2;
       degree[i]=1;
       firstedge[i]=buffer2;
     }
   
   buffer=edges; /* buffer leading to 1 */
   if (n>2) buffer->next=buffer+1; else buffer->next=buffer;
   buffer->prev=buffer+n-2;
   for (i=2,buffer++; i<n-1; i++, buffer++) /* buffer leading to i */
     { buffer->prev=buffer-1;
       buffer->next=buffer+1;
     }
   if (n>2) /* buffer leading to n-1 */
     {
       buffer->prev=buffer-1;
       buffer->next=edges;
     }

    nv=n;
    ne=2*(n-1);
}

// Assembly:
cmpl $0x1, %edi
jne 0x6494
andl $0x0, 0x23c183(%rip)    # 0x242604
movl $0x1, 0x23c175(%rip)    # 0x242600
andq $0x0, 0x1f54d(%rip)     # 0x259e0
retq
pushq %rbx
leaq 0x23c174(%rip), %rdx    # 0x242610
movq %rdx, 0x1f53d(%rip)     # 0x259e0
leal -0x1(%rdi), %eax
movl %eax, 0x1f734(%rip)     # 0x25be0
movslq %edi, %rsi
movq %rsi, %r8
shlq $0x6, %r8
leaq (%rdx,%r8), %rcx
addq $-0x3c, %r8
movabsq $0x1, %r9
leaq 0x1f711(%rip), %r10     # 0x25be0
leaq 0x1f50a(%rip), %r11     # 0x259e0
cmpq %rsi, %r9
jge 0x651e
leaq (%rdx,%r8), %rbx
addq $-0x4, %rbx
andl $0x0, 0x4(%rbx)
andl $0x0, (%rdx)
movl %r9d, (%rbx)
movl %r9d, 0x4(%rdx)
movq %rbx, 0x20(%rdx)
movq %rdx, 0x20(%rbx)
movq %rdx, 0x28(%rbx)
movq %rdx, 0x28(%rdx)
movq %rbx, 0x18(%rbx)
movq %rbx, 0x10(%rbx)
movl $0x1, (%r10,%r9,4)
movq %rbx, (%r11,%r9,8)
incq %r9
addq $0x40, %rdx
jmp 0x64d6
cmpl $0x3, %edi
leaq 0x23c128(%rip), %rsi    # 0x242650
leaq 0x23c0e1(%rip), %rdx    # 0x242610
cmovlq %rdx, %rsi
movq %rsi, 0x23c0ee(%rip)    # 0x242628
addq $-0x80, %rcx
movq %rcx, 0x23c0db(%rip)    # 0x242620
movl $0x2, %esi
leaq 0x23c13f(%rip), %rcx    # 0x242690
cmpl %eax, %esi
jge 0x6569
leaq -0x80(%rcx), %r8
movq %r8, -0x30(%rcx)
movq %rcx, -0x28(%rcx)
incl %esi
addq $0x40, %rcx
jmp 0x6551
cmpl $0x3, %edi
jl 0x657a
leaq -0x80(%rcx), %rsi
movq %rsi, -0x30(%rcx)
movq %rdx, -0x28(%rcx)
movl %edi, 0x23c080(%rip)    # 0x242600
addl %eax, %eax
movl %eax, 0x23c07c(%rip)    # 0x242604
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mishun[P]plantri/plantri.c
// Function: write_planar_code
static void
write_planar_code(FILE *f, int doflip)   

/* Write in planar_code format.  Always write in next direction,
   and if doflip != 0 also write in prev direction. */
{
    size_t length;
    unsigned char code[MAXN+MAXE+1];
    
    length=nv+ne+1;
    compute_code(code);
    if (fwrite(code,sizeof(unsigned char),length,f) != length)
    {
        fprintf(stderr,">E %s: fwrite() failed\n",cmdname);
        perror(">E ");
        exit(1);
    }
    if (doflip)
      { compute_code_mirror(code);
        if (fwrite(code,sizeof(unsigned char),length,f) != length)
	  {
	    fprintf(stderr,">E %s: fwrite() failed\n",cmdname);
	    perror(">E ");
	    exit(1);
	  }
      }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movl %esi, %ebp
movq %rdi, %rbx
movl 0x2384a0(%rip), %eax    # 0x242600
movl 0x23849e(%rip), %ecx    # 0x242604
leal 0x1(%rax,%rcx), %eax
movslq %eax, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0xa2a9
pushq $0x1
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10c0
cmpq %r14, %rax
jne 0xa1c1
testl %ebp, %ebp
je 0xa1b3
movq %rsp, %r15
movq %r15, %rdi
callq 0xa3dc
pushq $0x1
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10c0
cmpq %r14, %rax
jne 0xa1c1
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x19e30(%rip), %rax     # 0x23ff8
movq (%rax), %rdi
movq 0x19ede(%rip), %rdx     # 0x240b0
leaq 0x14308(%rip), %rsi     # 0x1e4e1
xorl %eax, %eax
callq 0x1050
leaq 0x1428e(%rip), %rdi     # 0x1e475
callq 0x1090
pushq $0x1
popq %rdi
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/mishun[P]plantri/plantri.c
// Function: write_dual_planar_code
static void
write_dual_planar_code(FILE *f, int doflip)   

/* Write the dual in planar_code format.  Always write in next direction,
   and if doflip != 0 also write in prev direction. */
{
    size_t length;
    unsigned char code[MAXF+MAXE+1];
    
    length=3+ne+(ne/2)-nv;
    compute_dual_code(code);
    if (fwrite(code,sizeof(unsigned char),length,f) != length)
    {
        fprintf(stderr,">E %s: fwrite() failed\n",cmdname);
        perror(">E ");
        exit(1);
    }
    if (doflip)
      { compute_dual_code_mirror(code);
      if (fwrite(code,sizeof(unsigned char),length,f) != length)
	{
	  fprintf(stderr,">E %s: fwrite() failed\n",cmdname);
	  perror(">E ");
	  exit(1);
	}
      }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movl %esi, %ebp
movq %rdi, %rbx
movl 0x2383f8(%rip), %ecx    # 0x242604
pushq $0x2
popq %rsi
movl %ecx, %eax
cltd
idivl %esi
addl %ecx, %eax
subl 0x2383e4(%rip), %eax    # 0x242600
addl $0x3, %eax
movslq %eax, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0xa513
pushq $0x1
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10c0
cmpq %r14, %rax
jne 0xa276
testl %ebp, %ebp
je 0xa268
movq %rsp, %r15
movq %r15, %rdi
callq 0xa6b0
pushq $0x1
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10c0
cmpq %r14, %rax
jne 0xa276
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x19d7b(%rip), %rax     # 0x23ff8
movq (%rax), %rdi
movq 0x19e29(%rip), %rdx     # 0x240b0
leaq 0x14253(%rip), %rsi     # 0x1e4e1
xorl %eax, %eax
callq 0x1050
leaq 0x141d9(%rip), %rdi     # 0x1e475
callq 0x1090
pushq $0x1
popq %rdi
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/mishun[P]plantri/plantri.c
// Function: startbipscan
static void
startbipscan(int nbtot, int nbop, int conn)

/* This routine begins the scan for general connected bipartite planar graphs
 * formed by removing edges from quadrangulations.  The current graph is
 * a quadrangulation, and the group is known (parameters nbtot,nbop).
 * conn is the connectivity (2 or 3, must be correct).
 */

{
    EDGE *feasible[MAXE/2];
    EDGE *e,*ex;
    int i,j,nfeas;

    for (i = 0; i < nv; ++i)
    {
	for (j = 0; j < nv; ++j) am2[i][j] = 0;
	am2[i][i] = 1;
    }

    nfeas = 0;
    for (i = 0; i < nv; ++i)
    {
        e = ex = firstedge[i];
        do
        {
            if (e == e->min && degree[e->start] > minpolydeg
                            && degree[e->end] > minpolydeg)
                feasible[nfeas++] = e;
            e->left_facesize = 4;
            am2[e->start][e->end] = 1;
            e = e->next;
        } while (e != ex);
    }

    prune_bip_edgelist(feasible,nfeas,feasible,&nfeas);

    scanbip(nbtot,nbop,feasible,nfeas,4,0,0,conn);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x5f0, %rsp            # imm = 0x5F0
movl %edx, %r14d
movl %esi, %ebx
movl %edi, %ebp
movl 0x236e7d(%rip), %ecx    # 0x242600
xorl %edx, %edx
testl %ecx, %ecx
movl $0x0, %eax
cmovgl %ecx, %eax
leaq 0x27d59a(%rip), %rsi    # 0x288d30
movq %rsi, %rdi
cmpq %rax, %rdx
je 0xb7c8
xorl %r8d, %r8d
cmpq %r8, %rcx
je 0xb7b0
movb $0x0, (%rdi,%r8)
incq %r8
jmp 0xb7a1
movq %rdx, %r8
shlq $0x6, %r8
addq %rsi, %r8
movb $0x1, (%rdx,%r8)
incq %rdx
addq $0x40, %rdi
jmp 0xb799
xorl %ecx, %ecx
movl 0x189c0(%rip), %edx     # 0x24190
leaq 0x1a209(%rip), %rdi     # 0x259e0
leaq 0x1a402(%rip), %r8      # 0x25be0
leaq 0x27d54b(%rip), %r9     # 0x288d30
xorl %esi, %esi
cmpq %rax, %rcx
je 0xb83c
movq (%rdi,%rcx,8), %r10
movq %r10, %r11
movslq (%r11), %r15
cmpq 0x28(%r11), %r11
jne 0xb816
cmpl %edx, (%r8,%r15,4)
jle 0xb816
movslq 0x4(%r11), %r12
cmpl %edx, (%r8,%r12,4)
jle 0xb816
movslq %esi, %r12
incl %esi
movq %r11, 0x20(%rsp,%r12,8)
movl $0x4, 0x38(%r11)
movslq 0x4(%r11), %r12
shlq $0x6, %r15
addq %r9, %r15
movb $0x1, (%r12,%r15)
movq 0x18(%r11), %r11
cmpq %r10, %r11
jne 0xb7f3
incq %rcx
jmp 0xb7e7
leaq 0x1c(%rsp), %r15
movl %esi, (%r15)
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0xbdd7
movl (%r15), %ecx
andl $0x0, (%rsp)
movl %r14d, 0x8(%rsp)
pushq $0x4
popq %r8
movl %ebp, %edi
movl %ebx, %esi
movq %r12, %rdx
xorl %r9d, %r9d
callq 0xbe32
addq $0x5f0, %rsp            # imm = 0x5F0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mishun[P]plantri/plantri.c
// Function: extend_quadr_P1
static EDGE
*extend_quadr_P1(EDGE *e)

/* extends a graph in the way given by the type P1 extension for
   3-connected quadrangulations. 

   It returns the directed edge characterizing this operation.
*/

{
  register EDGE *e1, *e1i, *e2, *e3, *e3i, *e4, *start, *dummy;
  int end1, end2, center, end;

  center=e->start; 
  end=e->end;
  e1=e->prev;
  e1i=e1->invers;
  e2=e1i->prev;
  end1=e2->start;

  e3=e->next;
  e3i=e3->invers;
  e4=e3i->next;
  end2=e4->start;

  e1->next=e3; e3->prev=e1; degree[center]--; firstedge[center]=e1;

  start=quadr_P1(nv);
  dummy=start+1;
  start->start=dummy->end=end1;
  degree[end1]++;
  start->next=e1i; e1i->prev=start;
  start->prev=e2; e2->next=start;

  dummy->next=e; e->prev=dummy;

  start+=2; dummy=start+1;
  start->start=dummy->end=end2;
  degree[end2]++;
  e3i->next=start; start->prev=e3i;
  e4->prev=start; start->next=e4;

  e->next=dummy; dummy->prev=e;

  degree[nv]=3; e->start=e->invers->end=nv; firstedge[nv]=e;
  nv++; ne+=4;

  return (e); 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rax
movslq (%rdi), %rsi
movq 0x10(%rdi), %r9
movq 0x18(%rdi), %rdx
movq 0x20(%r9), %r10
movq 0x10(%r10), %r11
movslq (%r11), %rbx
movq 0x20(%rdx), %rdi
movq 0x18(%rdi), %rcx
movslq (%rcx), %r14
movq %rdx, 0x18(%r9)
movq %r9, 0x10(%rdx)
leaq 0x19f5c(%rip), %r8      # 0x25be0
decl (%r8,%rsi,4)
leaq 0x19d51(%rip), %rdx     # 0x259e0
movq %r9, (%rdx,%rsi,8)
movslq 0x236966(%rip), %rsi    # 0x242600
movq %rsi, %r9
shlq $0x8, %r9
leaq 0x236968(%rip), %r15    # 0x242610
leaq (%r9,%r15), %r12
addq $0x100, %r12            # imm = 0x100
leaq (%r9,%r15), %r13
addq $0x140, %r13            # imm = 0x140
incl (%r8,%rbx,4)
movl %ebx, 0x4(%r13)
movl %ebx, -0x40(%r13)
movq %r10, -0x28(%r13)
movq %r12, 0x10(%r10)
movq %r11, -0x30(%r13)
movq %r12, 0x18(%r11)
movq %rax, 0x18(%r13)
movq %r13, 0x10(%rax)
leaq 0x180(%r9,%r15), %r10
addq %r15, %r9
addq $0x1c0, %r9             # imm = 0x1C0
movl %r14d, 0x4(%r9)
movl %r14d, -0x40(%r9)
incl (%r8,%r14,4)
movq %r10, 0x18(%rdi)
movq %rdi, -0x30(%r9)
movq %r10, 0x10(%rcx)
movq %rcx, -0x28(%r9)
movq %r9, 0x18(%rax)
movq %rax, 0x10(%r9)
movl $0x3, (%r8,%rsi,4)
movq 0x20(%rax), %rcx
movl %esi, 0x4(%rcx)
movl %esi, (%rax)
movq %rax, (%rdx,%rsi,8)
leal 0x1(%rsi), %ecx
movl %ecx, 0x2368ca(%rip)    # 0x242600
addl $0x4, 0x2368c7(%rip)    # 0x242604
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mishun[P]plantri/plantri.c
// Function: reduce_quadr_P1
static void
reduce_quadr_P1(EDGE *e)

/* reduces a graph previously extended by the type P1 extension for
   3-connected quadrangulations. The edge e must be the reference edge
*/

{
  register EDGE *e1, *e1i, *e2, *e3, *e3i, *e4;
  int end1, end2, center, end;

  nv--; ne-=4;

  end=e->end;
  e2=e->prev->invers->prev;
  end1=e2->start;
  e1i=e2->next->next;
  e1=e1i->invers;
  center=e1->start;
  e3=e1->next;
  e3i=e3->invers;
  e4=e3i->next->next;
  end2=e4->start;

  e2->next=e1i; e1i->prev=e2; firstedge[end1]=e2; degree[end1]--;
  e1->next=e; e->prev=e1; e->next=e3; e3->prev=e; 
  e->start=e->invers->end=center; degree[center]++;
  e3i->next=e4; e4->prev=e3i; firstedge[end2]=e4; degree[end2]--;
}

// Assembly:
pushq %r14
pushq %rbx
decl 0x2368b0(%rip)          # 0x242600
addl $-0x4, 0x2368ad(%rip)   # 0x242604
movq 0x10(%rdi), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movslq (%rax), %rcx
movq 0x18(%rax), %rdx
movq 0x18(%rdx), %rdx
movq 0x20(%rdx), %rsi
movslq (%rsi), %r8
movq 0x18(%rsi), %r9
movq 0x20(%r9), %r10
movq 0x18(%r10), %r11
movq 0x18(%r11), %r11
movslq (%r11), %rbx
movq %rdx, 0x18(%rax)
movq %rax, 0x10(%rdx)
leaq 0x19e49(%rip), %rdx     # 0x25be0
decl (%rdx,%rcx,4)
leaq 0x19c3f(%rip), %r14     # 0x259e0
movq %rax, (%r14,%rcx,8)
movq %rdi, 0x18(%rsi)
movq %rsi, 0x10(%rdi)
movq %r9, 0x18(%rdi)
movq %rdi, 0x10(%r9)
movq 0x20(%rdi), %rax
movl %r8d, 0x4(%rax)
movl %r8d, (%rdi)
incl (%rdx,%r8,4)
movq %r11, 0x18(%r10)
movq %r10, 0x10(%r11)
movq %r11, (%r14,%rbx,8)
decl (%rdx,%rbx,4)
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mishun[P]plantri/plantri.c
// Function: prune_bip_edgelist
static void
prune_bip_edgelist(EDGE *old[], int numold, EDGE *newe[], int *numnew)

/* Copy from old[0..numold-1] to newe[0..*numnew-1] each edge e with
 *    these two properties:
 *       1. Both ends of e have degree >= minpolydeg+1.
 *          2. e is contained in a 4-face.
 *            It is legal that old and newe and &numold and numnew are the same.
 */

{
    int i,counter=0;
    EDGE *e;

    for (i=0; i<numold; i++, old++)
      { e = *old; 
        if (degree[e->start] > minpolydeg && degree[e->end] > minpolydeg
             && (e->left_facesize == 4 || e->invers->left_facesize == 4))
            newe[counter++]=e;
      }

    *numnew=counter;
}

// Assembly:
pushq %rbx
movl 0x183b2(%rip), %eax     # 0x24190
xorl %r8d, %r8d
testl %esi, %esi
cmovlel %r8d, %esi
leaq 0x19df2(%rip), %r9      # 0x25be0
xorl %r10d, %r10d
cmpl %r8d, %esi
je 0xbe2d
movq (%rdi,%r8,8), %r11
movslq (%r11), %rbx
cmpl %eax, (%r9,%rbx,4)
jle 0xbe28
movslq 0x4(%r11), %rbx
cmpl %eax, (%r9,%rbx,4)
jle 0xbe28
cmpl $0x4, 0x38(%r11)
je 0xbe1e
movq 0x20(%r11), %rbx
cmpl $0x4, 0x38(%rbx)
jne 0xbe28
movslq %r10d, %rbx
incl %r10d
movq %r11, (%rdx,%rbx,8)
incq %r8
jmp 0xbdf1
movl %r10d, (%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mishun[P]plantri/plantri.c
// Function: mark_edge_orbits
static void
mark_edge_orbits(EDGE *edge[], int count, int minimal[], int nbtot)

/* edge[0..count-1] is a list of edges.  Put minimal[i] = 1 if
   edge[i] is the first appearance of its orbit, and  minimal[i] = 0
   if not.  Orbits on undirected edges are considered. */
{
    int i;
    EDGE **nb0,**nb,**nblim;
 
    if (nbtot == 1) 
        for (i = 0; i < count; ++i) minimal[i] = 1;
    else
    {
        nb0 = (EDGE**)numbering[0];
        nblim = (EDGE**)numbering[nbtot];
        for (i = 0; i < ne; ++i) nb0[i]->index = i;
 
        RESETMARKS;
    
        for (i = 0; i < count; ++i)
        {
            nb = nb0 + edge[i]->index;
            if (!ISMARKEDLO((*nb)->min))
            {
                minimal[i] = 1;
                for ( ; nb < nblim; nb += MAXE) MARKLO((*nb)->min);
            }
            else
                minimal[i] = 0;
        }
    }
}

// Assembly:
cmpl $0x1, %ecx
jne 0xd202
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
cmpq %rax, %rsi
je 0xd2dc
movl $0x1, (%rdx,%rax,4)
incq %rax
jmp 0xd1ed
movslq %ecx, %rax
movl 0x2353f9(%rip), %ecx    # 0x242604
xorl %r8d, %r8d
testl %ecx, %ecx
cmovlel %r8d, %ecx
leaq 0x18ac5(%rip), %r9      # 0x25ce0
cmpq %r8, %rcx
je 0xd230
movq (%r9), %r10
movl %r8d, 0x34(%r10)
incq %r8
addq $0x8, %r9
jmp 0xd21b
imulq $0xba0, %rax, %rax      # imm = 0xBA0
leaq 0x18aa2(%rip), %rcx     # 0x25ce0
movl 0x16e37(%rip), %r9d     # 0x2407c
leal 0x2(%r9), %r8d
movl %r8d, 0x16e2c(%rip)     # 0x2407c
cmpl $0x752f, %r9d           # imm = 0x752F
jl 0xd286
movl $0x2, 0x16e19(%rip)     # 0x2407c
pushq $0x30
popq %r9
pushq $0x2
popq %r8
leaq 0x23539e(%rip), %r10    # 0x242610
cmpq $0x46630, %r9           # imm = 0x46630
je 0xd286
andl $0x0, (%r9,%r10)
addq $0x40, %r9
jmp 0xd272
addq %rcx, %rax
xorl %r9d, %r9d
testl %esi, %esi
cmovlel %r9d, %esi
cmpq %rsi, %r9
je 0xd2dc
movq (%rdi,%r9,8), %r10
movslq 0x34(%r10), %r10
movq (%rcx,%r10,8), %r11
movq 0x28(%r11), %r11
cmpl %r8d, 0x30(%r11)
jne 0xd2b7
andl $0x0, (%rdx,%r9,4)
incq %r9
jmp 0xd292
leaq (%rcx,%r10,8), %r10
movl $0x1, (%rdx,%r9,4)
cmpq %rax, %r10
jae 0xd2b2
movq (%r10), %r11
movq 0x28(%r11), %r11
movl %r8d, 0x30(%r11)
addq $0xba0, %r10            # imm = 0xBA0
jmp 0xd2c3
retq