LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/otrtool[P]otrtool/src/main.c
// Function: getHeader
char * getHeader() {
  unsigned char *header = malloc(sizeof(char) * 513);
  if (fread(header, 512, 1, file) < 1 && !feof(file))
    PERROR("Error reading file");
  if (feof(file))
    ERROR("Error: unexpected end of file");
  unsigned char hardKey[] = {
      0xEF, 0x3A, 0xB2, 0x9C, 0xD1, 0x9F, 0x0C, 0xAC,
      0x57, 0x59, 0xC7, 0xAB, 0xD1, 0x2C, 0xC9, 0x2B,
      0xA3, 0xFE, 0x0A, 0xFE, 0xBF, 0x96, 0x0D, 0x63,
      0xFE, 0xBD, 0x0F, 0x45};
  bf_state_t blowfish;
  bf_init(&blowfish, hardKey, 28);
  bf_ecb_decrypt(&blowfish, header, 512);
  header[512] = 0;
  
  char *padding = strstr((char*)header, "&PD=");
  if (padding == NULL)
    ERROR("Corrupted header: could not find padding");
  *padding = 0;
  
  if (opts.verbosity >= VERB_DEBUG) {
    fputs("\nDumping decrypted header:\n", stderr);
    dumpQuerystring((char*)header);
    fputs("\n", stderr);
  }
  return (char*)header;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1068, %rsp           # imm = 0x1068
movl $0x201, %edi            # imm = 0x201
callq 0x2310
movq %rax, %rbx
movq 0x7f8c(%rip), %rcx      # 0xd2e0
movl $0x200, %esi            # imm = 0x200
movl $0x1, %edx
movq %rax, %rdi
callq 0x2370
testq %rax, %rax
jne 0x537f
movq 0x7f6e(%rip), %rdi      # 0xd2e0
callq 0x2380
testl %eax, %eax
je 0x5412
movq 0x7f5a(%rip), %rdi      # 0xd2e0
callq 0x2380
testl %eax, %eax
jne 0x5408
movups 0x3f26(%rip), %xmm0     # 0x92bc
movq %rsp, %rsi
movups %xmm0, 0xc(%rsi)
movaps 0x3f0c(%rip), %xmm0     # 0x92b0
movaps %xmm0, (%rsi)
leaq 0x20(%rsp), %r14
movl $0x1c, %edx
movq %r14, %rdi
callq 0x46fc
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
movq %rbx, %rsi
callq 0x48bf
movb $0x0, 0x200(%rbx)
leaq 0x4065(%rip), %rsi      # 0x943c
movq %rbx, %rdi
callq 0x2060
testq %rax, %rax
je 0x540d
movb $0x0, (%rax)
cmpb $0x1, 0x7eaa(%rip)      # 0xd298
je 0x53fe
movq %rbx, %rax
addq $0x1068, %rsp           # imm = 0x1068
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x2def
jmp 0x53f0
callq 0x2db0
callq 0x2e2b
callq 0x2e6a
// File: /workspace/github_c_makefile_star2_O3/otrtool[P]otrtool/src/main.c
// Function: generateBigkey
void * generateBigkey(char *date) {
  char *mailhash = bin2hex(MD5(
      (unsigned char*)email, strlen(email), NULL), 16);
  char *passhash = bin2hex(MD5(
      (unsigned char*)password, strlen(password), NULL), 16);
  char *bigkey_hex = malloc(57 * sizeof(char));
  char *ptr = bigkey_hex;
  
  strncpy(ptr, mailhash, 13);
  ptr += 13;
  
  strncpy(ptr, date, 4);
  date += 4;
  ptr += 4;
  
  strncpy(ptr, passhash, 11);
  ptr += 11;
  
  strncpy(ptr, date, 2);
  date += 2;
  ptr += 2;
  
  strncpy(ptr, mailhash + 21, 11);
  ptr += 11;
  
  strncpy(ptr, date, 2);
  ptr += 2;
  
  strncpy(ptr, passhash + 19, 13);
  ptr += 13;
  
  *ptr = 0;
  
  if (opts.verbosity >= VERB_DEBUG) {
    fprintf(stderr, "\nGenerated BigKey: %s\n\n", bigkey_hex);
  }
  
  void *res = hex2bin(bigkey_hex);
  
  free(bigkey_hex);
  free(mailhash);
  free(passhash);
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
movq 0x7ebe(%rip), %rbx      # 0xd2e8
movq %rbx, %rdi
callq 0x20c0
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x466c
movq %rax, %rdi
movl $0x10, %esi
callq 0x4c18
movq %rax, %rbx
movq 0x7e9a(%rip), %r14      # 0xd2f0
movq %r14, %rdi
callq 0x20c0
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x466c
movq %rax, %rdi
movl $0x10, %esi
callq 0x4c18
movq %rax, %r14
movl $0x39, %edi
callq 0x2310
movq %rax, %r12
movl $0xd, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x20f0
leaq 0xd(%r12), %rdi
movl $0x4, %edx
movq %r15, %rsi
callq 0x20f0
leaq 0x4(%r15), %r13
leaq 0x11(%r12), %rdi
movl $0xb, %edx
movq %r14, %rsi
callq 0x20f0
leaq 0x1c(%r12), %rdi
movl $0x2, %edx
movq %r13, %rsi
callq 0x20f0
addq $0x6, %r15
leaq 0x1e(%r12), %rdi
movq %rbx, %rsi
addq $0x15, %rsi
movl $0xb, %edx
callq 0x20f0
leaq 0x29(%r12), %rdi
movl $0x2, %edx
movq %r15, %rsi
callq 0x20f0
leaq 0x2b(%r12), %rdi
movq %r14, %rsi
addq $0x13, %rsi
movl $0xd, %edx
callq 0x20f0
movb $0x0, 0x38(%r12)
cmpb $0x1, 0x7d77(%rip)      # 0xd298
je 0x5553
movq %r12, %rdi
callq 0x4c94
movq %rax, %r15
movq %r12, %rdi
callq 0x2290
movq %rbx, %rdi
callq 0x2290
movq %r14, %rdi
callq 0x2290
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x7a7e(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x3f22(%rip), %rsi      # 0x9486
movq %r12, %rdx
xorl %eax, %eax
callq 0x2340
jmp 0x5523
// File: /workspace/github_c_makefile_star2_O3/otrtool[P]otrtool/src/main.c
// Function: WriteMemoryCallback
static size_t WriteMemoryCallback(void *ptr, size_t size,
          size_t nmemb, void *data) {
  size_t realsize = size * nmemb;
  struct MemoryStruct *mem = (struct MemoryStruct *)data;
  char *newmem;
  
  // abort very long transfers
  if (mem->size + realsize > MAX_RESPONSE_LENGTH) {
    realsize = mem->size <= MAX_RESPONSE_LENGTH
        ? MAX_RESPONSE_LENGTH - mem->size
        : 0;
  }
  if (realsize < 1) return 0;
  
  // "If realloc() fails the original block is left untouched" (man 3 realloc)
  newmem = realloc(mem->memory, mem->size + realsize);
  if (newmem != NULL) {
    mem->memory = newmem;
    memcpy(&(mem->memory[mem->size]), ptr, realsize);
    mem->size += realsize;
  } else return 0;
  return realsize;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %rcx
movq %rdi, %r15
imulq %rdx, %rcx
movq 0x8(%rbx), %rsi
leaq (%rsi,%rcx), %rdx
movl $0x3e8, %r14d           # imm = 0x3E8
subq %rsi, %r14
xorl %eax, %eax
movl $0x3e9, %edi            # imm = 0x3E9
cmpq %rdi, %rsi
cmovaeq %rax, %r14
cmpq %rdi, %rdx
cmovbq %rcx, %r14
testq %r14, %r14
je 0x58da
movq (%rbx), %rdi
addq %r14, %rsi
callq 0x23e0
testq %rax, %rax
je 0x58d8
movq %rax, (%rbx)
movq 0x8(%rbx), %r12
addq %r12, %rax
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2170
addq %r14, %r12
movq %r12, 0x8(%rbx)
movq %r14, %rax
jmp 0x58da
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/otrtool[P]otrtool/src/main.c
// Function: decryptResponse
char * decryptResponse(char *response, int length, void *bigkey) {
  bf_state_t blowfish;
  
  if (length < BF_IV_LEN)
    return NULL;
  length -= BF_IV_LEN;
  
  char *result = malloc(length);
  memcpy(result, response+BF_IV_LEN, length);
  
  bf_init(&blowfish, bigkey, 28);
  bf_cbc_decrypt(&blowfish, result, length, response);
  
  char *padding = strstr(result, "&D=");
  if (padding == NULL)
    ERROR("Corrupted response: could not find padding");
  *padding = 0;
  
  if (opts.verbosity >= VERB_DEBUG) {
    fputs("\nDecrypted response:\n", stderr);
    dumpQuerystring(result);
    fputs("\n", stderr);
  }
  
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1050, %rsp           # imm = 0x1050
cmpl $0x8, %esi
jge 0x58ff
xorl %ebx, %ebx
jmp 0x596c
movq %rdx, %r12
movl %esi, %r15d
movq %rdi, %r14
addl $-0x8, %r15d
movq %r15, %rdi
callq 0x2310
movq %rax, %rbx
leaq 0x8(%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2170
leaq 0x8(%rsp), %r13
movl $0x1c, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x46fc
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x4abb
leaq 0x3cab(%rip), %rsi      # 0x95fe
movq %rbx, %rdi
callq 0x2060
testq %rax, %rax
je 0x598a
movb $0x0, (%rax)
cmpb $0x1, 0x792e(%rip)      # 0xd298
je 0x5980
movq %rbx, %rax
addq $0x1050, %rsp           # imm = 0x1050
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x2fe8
jmp 0x596c
callq 0x3024
// File: /workspace/github_c_makefile_star2_O3/otrtool[P]otrtool/src/main.c
// Function: keycache_get
char *keycache_get(const char *fh) {
  char *cachephrase, *cachefh;
  static char line[512];
  
  if (fh == NULL || keyfile == NULL) return NULL;
  rewind(keyfile);
  while (fgets(line, sizeof(line), keyfile) != NULL) {
    cachefh = strtok(line, " \t\r\n");
    cachephrase = strtok(NULL, " \t\r\n");
    if (cachephrase == NULL || cachefh == NULL) continue;
    if (strcmp(cachefh, fh) == 0) return cachephrase;
  }
  if (!feof(keyfile)) PERROR("fgets");
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
movq 0x764c(%rip), %rdi      # 0xd310
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x5d68
callq 0x2050
movq 0x7632(%rip), %rdx      # 0xd310
leaq 0x763b(%rip), %rdi      # 0xd320
movl $0x200, %esi            # imm = 0x200
callq 0x23c0
testq %rax, %rax
je 0x5d58
leaq 0x7625(%rip), %r14      # 0xd320
leaq 0x39f1(%rip), %r15      # 0x96f3
movq %r14, %rdi
movq %r15, %rsi
callq 0x23a0
movq %rax, %r13
xorl %edi, %edi
movq %r15, %rsi
callq 0x23a0
movq %rax, %r12
testq %rax, %rax
sete %al
testq %r13, %r13
sete %cl
orb %al, %cl
cmpb $0x1, %cl
je 0x5d3f
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2330
testl %eax, %eax
je 0x5d6b
movq 0x75ca(%rip), %rdx      # 0xd310
movq %r14, %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x23c0
testq %rax, %rax
jne 0x5d02
movq 0x75b1(%rip), %rdi      # 0xd310
callq 0x2380
testl %eax, %eax
je 0x5d78
xorl %r12d, %r12d
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x3132
// File: /workspace/github_c_makefile_star2_O3/otrtool[P]otrtool/src/main.c
// Function: keycache_put
void keycache_put(const char *fh, const char *keyphrase) {
  char *cachephrase, *fn;
  
  if (fh == NULL || keyfile == NULL) return;
  if ((cachephrase = keycache_get(fh)) != NULL) {
    if (strcmp(keyphrase, cachephrase) != 0)
      fputs("warning: differing keyphrase was found in cache file!\n", stderr);
    else
      fputs("info: keyphrase was already in cache\n", stderr);
    return;
  }
  fn = queryGetParam(header, "FN");
  if (fprintf(keyfile, "%s\t%s\t# %s\n", fh, keyphrase, fn) < 0)
    PERROR("fprintf");
  fflush(keyfile);
  fprintf(stderr, "info: saved keyphrase to %s\n", keyfileshortname);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5d90
cmpq $0x0, 0x7582(%rip)      # 0xd310
jne 0x5d98
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5cab
testq %rax, %rax
jne 0x5de4
movq 0x7549(%rip), %rdi      # 0xd2f8
leaq 0x36e8(%rip), %rsi      # 0x949e
callq 0x4f51
movq 0x754e(%rip), %rdi      # 0xd310
leaq 0x3992(%rip), %rsi      # 0x975b
movq %r14, %rdx
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x2340
testl %eax, %eax
js 0x5e19
callq 0x3184
jmp 0x5d90
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2330
movq 0x71e2(%rip), %rcx      # 0xcfd8
movq (%rcx), %rsi
testl %eax, %eax
jne 0x5e06
leaq 0x3931(%rip), %rdi      # 0x9735
jmp 0x5e0d
leaq 0x38f1(%rip), %rdi      # 0x96fe
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2250
callq 0x31b1
// File: /workspace/github_c_makefile_star2_O3/otrtool[P]otrtool/src/main.c
// Function: openFile
void openFile() {
  if (strcmp("-", filename) == 0)
    file = stdin;
  else
    file = fopen(filename, "rb");
  
  if (file == NULL)
    PERROR("Error opening file");
  
  char magic[11] = { 0 };
  if (fread(magic, 10, 1, file) < 1 && !feof(file))
    PERROR("Error reading file");
  if (feof(file))
    ERROR("Error: unexpected end of file");
  if (strcmp(magic, "OTRKEYFILE") != 0)
    ERROR("Wrong file format");
  
  header = getHeader();
}

// Assembly:
subq $0x18, %rsp
movq 0x7472(%rip), %rdi      # 0xd540
movzbl (%rdi), %eax
subl $0x2d, %eax
jne 0x60da
movzbl 0x1(%rdi), %eax
negl %eax
testl %eax, %eax
je 0x60f1
leaq 0x388a(%rip), %rsi      # 0x9971
callq 0x2280
movq %rax, %rcx
jmp 0x60fb
movq 0x6ed8(%rip), %rax      # 0xcfd0
movq (%rax), %rcx
movq %rcx, 0x71de(%rip)      # 0xd2e0
testq %rcx, %rcx
je 0x6182
leaq 0x8(%rsp), %rdi
movl $0x0, 0x7(%rdi)
movq $0x0, (%rdi)
movl $0xa, %esi
movl $0x1, %edx
callq 0x2370
testq %rax, %rax
jne 0x613e
movq 0x71ab(%rip), %rdi      # 0xd2e0
callq 0x2380
testl %eax, %eax
je 0x6191
movq 0x719b(%rip), %rdi      # 0xd2e0
callq 0x2380
testl %eax, %eax
jne 0x6187
movabsq $0x494659454b52544f, %rax # imm = 0x494659454B52544F
xorq 0x8(%rsp), %rax
movabsq $0x454c494659454b, %rcx # imm = 0x454C494659454B
xorq 0xb(%rsp), %rcx
orq %rax, %rcx
jne 0x618c
callq 0x5336
movq %rax, 0x717b(%rip)      # 0xd2f8
addq $0x18, %rsp
retq
callq 0x36e6
callq 0x3616
callq 0x3655
callq 0x3694
// File: /workspace/github_c_makefile_star2_O3/otrtool[P]otrtool/src/main.c
// Function: verifyFile_init
void verifyFile_init(vfy_t *vfy, int input) {
  char *hash_hex, *hash;
  int i;
  
  memset(vfy, 0, sizeof(*vfy));
  vfy->input = input;
  
  /* get MD5 sum from 'OH' or 'FH' header field */
  hash_hex = queryGetParam(header, vfy->input?"OH":"FH");
  if (hash_hex == NULL || strlen(hash_hex) != 48)
    ERROR("Missing hash in file header / unexpected format");
  for (i=1; i<16; ++i) {
    hash_hex[2*i] = hash_hex[3*i];
    hash_hex[2*i+1] = hash_hex[3*i+1];
  }
  hash_hex[32] = 0;
  if (opts.verbosity >= VERB_DEBUG)
    fprintf(stderr, "Checking %s against MD5 sum: %s\n",
      vfy->input?"input":"output", hash_hex);
  hash = hex2bin(hash_hex);
  memcpy(vfy->hash1, hash, 16);
  
  /* calculate MD5 sum of file (without header) */
  memset(&vfy->ctx, 0, sizeof(vfy->ctx));
  MD5_Init(&vfy->ctx);
  
  free(hash_hex);
  free(hash);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0xa8, %edx
xorl %esi, %esi
callq 0x2100
movl %ebp, 0xa8(%rbx)
movq 0x713d(%rip), %rdi      # 0xd2f8
testl %ebp, %ebp
leaq 0x37aa(%rip), %rax      # 0x996e
leaq 0x32d6(%rip), %rsi      # 0x94a1
cmoveq %rax, %rsi
callq 0x4f51
testq %rax, %rax
je 0x627e
movq %rax, %r14
movq %rax, %rdi
callq 0x20c0
cmpq $0x30, %rax
jne 0x627e
leaq 0xa8(%rbx), %rdi
movq %r14, %rax
addq $0x4, %rax
movl $0x1, %ecx
movb -0x1(%rax), %dl
movb %dl, (%r14,%rcx,2)
movb (%rax), %dl
movb %dl, 0x1(%r14,%rcx,2)
incq %rcx
addq $0x3, %rax
cmpq $0x10, %rcx
jne 0x6205
movb $0x0, 0x20(%r14)
cmpb $0x1, 0x706c(%rip)      # 0xd298
je 0x6274
movq %r14, %rdi
callq 0x4c94
movq %rax, %r15
movups (%rax), %xmm0
movups %xmm0, 0x98(%rbx)
movl $0x98, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2100
movq %rbx, %rdi
callq 0x3bec
movq %r14, %rdi
callq 0x2290
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2290
movq %r14, %rsi
callq 0x3738
jmp 0x622e
callq 0x376b
// File: /workspace/github_c_makefile_star2_O3/otrtool[P]otrtool/src/main.c
// Function: verifyFile_final
void verifyFile_final(vfy_t *vfy) {
  unsigned char md5[16];
  
  MD5_Final(md5, &vfy->ctx);
  if (memcmp(vfy->hash1, md5, 16) != 0) {
    if (vfy->input)
      ERROR("Input file had errors. Output may or may not be usable.");
    else
      ERROR("Output verification failed. Wrong key?");
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4545
movdqu 0x98(%rbx), %xmm0
pcmpeqb (%r14), %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x62c0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl 0xa8(%rbx), %ebx
movq 0x6d0b(%rip), %r14      # 0xcfd8
movq (%r14), %rsi
movl $0xa, %edi
callq 0x22d0
movq (%r14), %rdi
testl %ebx, %ebx
jne 0x62e6
callq 0x37da
callq 0x37aa
// File: /workspace/github_c_makefile_star2_O3/otrtool[P]otrtool/src/main.c
// Function: processFile
void processFile() {
  int storeKeyphrase;
  switch (opts.action) {
    case ACTION_INFO:
      // TODO: output something nicer than just the querystring
      dumpQuerystring(header);
      break;
    case ACTION_FETCHKEY:
      fetchKeyphrase();
      break;
    case ACTION_DECRYPT:
      storeKeyphrase = 1;
      if (opts.keyphrase == NULL) {
        storeKeyphrase = 0;
        keyphrase = keycache_get(queryGetParam(header, "FH"));
        if (keyphrase)
          fprintf(stderr, "Keyphrase from cache: %s\n", keyphrase);
        else
          fetchKeyphrase();
      }
      else {
        keyphrase = strdup(opts.keyphrase);
      }
      decryptFile();
      if (storeKeyphrase)
        keycache_put(queryGetParam(header, "FH"), keyphrase);
      break;
    case ACTION_VERIFY:
      verifyOnly();
      break;
  }
}

// Assembly:
pushq %rax
movl 0x67c2(%rip), %eax      # 0xd290
cmpq $0x3, %rax
ja 0x6b37
leaq 0x2665(%rip), %rcx      # 0x9140
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x680d(%rip), %rdi      # 0xd2f8
popq %rax
jmp 0x50b5
movq 0x67c8(%rip), %rdi      # 0xd2c0
testq %rdi, %rdi
je 0x6b39
callq 0x2450
movq %rax, 0x6a2f(%rip)      # 0xd538
callq 0x64a8
movq 0x67e3(%rip), %rdi      # 0xd2f8
leaq 0x2e52(%rip), %rsi      # 0x996e
callq 0x4f51
movq 0x6a10(%rip), %rsi      # 0xd538
movq %rax, %rdi
popq %rax
jmp 0x5d7d
popq %rax
jmp 0x5e1e
popq %rax
retq
movq 0x67b8(%rip), %rdi      # 0xd2f8
leaq 0x2e27(%rip), %rsi      # 0x996e
callq 0x4f51
movq %rax, %rdi
callq 0x5cab
movq %rax, 0x69dd(%rip)      # 0xd538
testq %rax, %rax
jne 0x6b71
callq 0x5e1e
popq %rax
jmp 0x64a8
popq %rax
jmp 0x28ad
movq 0x6460(%rip), %rcx      # 0xcfd8
movq (%rcx), %rdi
leaq 0x3150(%rip), %rsi      # 0x9cd2
movq %rax, %rdx
xorl %eax, %eax
callq 0x2340
jmp 0x6b65
// File: /workspace/github_c_makefile_star2_O3/kkanellis[P]matvec-sparse/matvec_mpi_p2p.c
// Function: create_mpi_datatypes
void create_mpi_datatypes(MPI_Datatype *proc_info_type) {
    MPI_Datatype oldtypes[2];
    MPI_Aint offsets[2];
    int blockcounts[2];

    /* create `proc_info_t` datatype */
    offsets[0] = 0;
    oldtypes[0] = MPI_INT;
    blockcounts[0] = 6;

    MPI_Type_create_struct(1, blockcounts, offsets, oldtypes, proc_info_type);
    MPI_Type_commit(proc_info_type);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
movq $0x0, (%rdx)
movq 0x3f3b(%rip), %rax      # 0x7fa8
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x8(%rsp), %rsi
movl $0x6, (%rsi)
movl $0x1, %edi
movq %rbx, %r8
callq 0x2150
movq %rbx, %rdi
callq 0x2180
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/martintopholm[P]xping/icmp.c
// Function: probe_setup
void
probe_setup()
{
	int i;

	if (fd4 < 0) {
		errno = fd4errno;
		perror("socket (IPv4)");
		exit(1);
	}
	if (fd6 < 0) {
		errno = fd6errno;
		perror("socket (IPv6)");
		exit(1);
	}

	/* Prepare datapacket */
	ident = getpid() & 0xffff;
	for (i=0; i<datalen; i++) {
		outpacket[ICMP_MINLEN + i] = '0' + i;
		outpacket6[ICMP6_MINLEN + i] = '0' + i;
	}

	evutil_make_socket_nonblocking(fd4);
	ev_read4 = event_new(ev_base, fd4, EV_READ|EV_PERSIST, read_packet4, NULL);
	event_add(ev_read4, NULL);
	evutil_make_socket_nonblocking(fd6);
	ev_read6 = event_new(ev_base, fd6, EV_READ|EV_PERSIST, read_packet6, NULL);
	event_add(ev_read6, NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x358e(%rip), %r14      # 0x7230
cmpl $0x0, (%r14)
js 0x3d6b
leaq 0x3585(%rip), %rbx      # 0x7238
cmpl $0x0, (%rbx)
js 0x3d70
callq 0x2290
movzwl %ax, %eax
movl %eax, 0x359e(%rip)      # 0x7268
movslq 0x350f(%rip), %rax      # 0x71e0
testq %rax, %rax
jle 0x3cfb
xorl %ecx, %ecx
leaq 0x3591(%rip), %rdx      # 0x7270
leaq 0x1358a(%rip), %rsi     # 0x17270
leal 0x30(%rcx), %edi
movb %dil, 0x8(%rcx,%rdx)
movb %dil, 0x8(%rcx,%rsi)
incq %rcx
cmpq %rcx, %rax
jne 0x3ce6
movl (%r14), %edi
callq 0x2270
leaq 0x351e(%rip), %r15      # 0x7228
movq (%r15), %rdi
movl (%r14), %esi
leaq 0x5e(%rip), %rcx        # 0x3d75
movl $0x12, %edx
xorl %r8d, %r8d
callq 0x2160
movq %rax, 0x23545(%rip)     # 0x27270
movq %rax, %rdi
xorl %esi, %esi
callq 0x20b0
movl (%rbx), %edi
callq 0x2270
movq (%r15), %rdi
movl (%rbx), %esi
leaq 0x135(%rip), %rcx       # 0x3e7d
movl $0x12, %edx
xorl %r8d, %r8d
callq 0x2160
movq %rax, 0x2351c(%rip)     # 0x27278
movq %rax, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x20b0
callq 0x241a
callq 0x23f5
// File: /workspace/github_c_makefile_star2_O3/martintopholm[P]xping/icmp.c
// Function: read_packet4
static void
read_packet4(int fd, short what, void *thunk)
{
	char inpacket[IP_MAXPACKET];
	struct sockaddr_in sin;
	struct ip *ip;
	struct ip *oip;
	struct icmp *icp;
	struct icmp *oicp;
	socklen_t salen;
	int hlen;
	int seq;
	int n;

	salen = sizeof(sin);
	memset(inpacket, 0, sizeof(inpacket));
	n = recvfrom(fd, inpacket, sizeof(inpacket), 0,
	    (struct sockaddr *)&sin, &salen);
	if (n < 0) {
		return;
	}

	ip = (struct ip *)inpacket;
	hlen = ip->ip_hl << 2;
	if (ip->ip_p != IPPROTO_ICMP) {
		return;
	}
	if (n < hlen + ICMP_MINLEN) {
		return;
	}

	icp = (struct icmp *)(inpacket + hlen);
	if (icp->icmp_type == ICMP_ECHOREPLY) {
		if (icp->icmp_id != htons(ident))
			return; /*  skip other ping sessions */

		seq = ntohs(icp->icmp_seq);
		find_marktarget(AF_INET, &sin.sin_addr, seq, '.');
	} else {
		/* Skip short icmp error packets. */
		if (n < ICMP_MINLEN * 2 + sizeof(struct ip))
			return;

		/* Check aspects of the original packet */
		oip = (struct ip *)icp->icmp_data;
		oicp = (struct icmp *)(oip + 1);
		if (oip->ip_p != IPPROTO_ICMP)
			return;
		if (oicp->icmp_type != ICMP_ECHO)
			return;
		if (oicp->icmp_id != htons(ident))
			return;

		seq = ntohs(oicp->icmp_seq);
		if (icp->icmp_type == ICMP_UNREACH)
			find_marktarget(AF_INET, &oip->ip_dst, seq, '#');
		else
			find_marktarget(AF_INET, &oip->ip_dst, seq, '%');
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10020, %rsp          # imm = 0x10020
movl %edi, %ebx
leaq 0xc(%rsp), %r14
movl $0x10, (%r14)
leaq 0x20(%rsp), %r15
movl $0xffff, %edx           # imm = 0xFFFF
movq %r15, %rdi
xorl %esi, %esi
callq 0x20e0
leaq 0x10(%rsp), %r8
movl $0xffff, %edx           # imm = 0xFFFF
movl %ebx, %edi
movq %r15, %rsi
xorl %ecx, %ecx
movq %r14, %r9
callq 0x2120
testl %eax, %eax
js 0x3e69
cmpb $0x1, 0x29(%rsp)
jne 0x3e69
movl 0x20(%rsp), %ecx
shll $0x2, %ecx
andl $0x3c, %ecx
leal 0x8(%rcx), %edx
cmpl %eax, %edx
ja 0x3e69
leaq (%rsp,%rcx), %rsi
addq $0x20, %rsi
movb (%rsi), %cl
testb %cl, %cl
je 0x3e39
andl $0x7ffffffc, %eax       # imm = 0x7FFFFFFC
cmpl $0x24, %eax
jb 0x3e69
cmpb $0x1, 0x11(%rsi)
jne 0x3e69
cmpb $0x8, 0x1c(%rsi)
jne 0x3e69
movzwl 0x3459(%rip), %eax      # 0x7268
rolw $0x8, %ax
cmpw %ax, 0x20(%rsi)
jne 0x3e69
movzwl 0x22(%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %edx
addq $0x18, %rsi
movl $0x2, %edi
cmpb $0x3, %cl
jne 0x3e76
movl $0x23, %ecx
jmp 0x3e64
movzwl 0x3428(%rip), %eax      # 0x7268
rolw $0x8, %ax
cmpw %ax, 0x4(%rsi)
jne 0x3e69
movzwl 0x6(%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %edx
leaq 0x14(%rsp), %rsi
movl $0x2, %edi
movl $0x2e, %ecx
callq 0x4295
addq $0x10020, %rsp          # imm = 0x10020
popq %rbx
popq %r14
popq %r15
retq
movl $0x25, %ecx
jmp 0x3e64
// File: /workspace/github_c_makefile_star2_O3/martintopholm[P]xping/icmp.c
// Function: read_packet6
static void
read_packet6(int fd, short what, void *thunk)
{
	char inpacket[IP_MAXPACKET];
	struct sockaddr_in6 sin6;
	struct ip6_hdr *oip6;
	struct icmp6_hdr *icmp6h;
	struct icmp6_hdr *oicmp6h;
	socklen_t salen;
	int seq;
	int n;

	salen = sizeof(sin6);
	memset(inpacket, 0, sizeof(inpacket));
	n = recvfrom(fd, inpacket, sizeof(inpacket), 0,
	    (struct sockaddr *)&sin6, &salen);
	if (n < 0) {
		return;
	}
	if (n < ICMP6_MINLEN) {
		return;
	}

	/* SOCK_RAW for IPPROTO_ICMPV6 doesn't include IPv6 header */
	icmp6h = (struct icmp6_hdr *)(inpacket);
	if (icmp6h->icmp6_type == ICMP6_ECHO_REPLY) {
		if (icmp6h->icmp6_id != htons(ident))
			return; /*  skip other ping sessions */
		if (n != sizeof(struct icmp6_hdr) + datalen)
			return;

		seq = ntohs(icmp6h->icmp6_seq);
		find_marktarget(AF_INET6, &sin6.sin6_addr, seq, '.');
	} else {
		/* Skip short icmp error packets. */
		if (n < ICMP6_MINLEN * 2 + sizeof(struct ip6_hdr))
			return;

		/* Check aspects of the original packet */
		oip6 = (struct ip6_hdr *)(icmp6h + 1);
		oicmp6h = (struct icmp6_hdr *)(oip6 + 1);
		if (oip6->ip6_nxt != IPPROTO_ICMPV6)
			return;
		if (oicmp6h->icmp6_type != ICMP6_ECHO_REQUEST)
			return;
		if (oicmp6h->icmp6_id != htons(ident))
			return;

		seq = ntohs(oicmp6h->icmp6_seq);
		if (icmp6h->icmp6_type == ICMP6_DST_UNREACH)
			find_marktarget(AF_INET6, &oip6->ip6_dst, seq, '#');
		else
			find_marktarget(AF_INET6, &oip6->ip6_dst, seq, '%');
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10020, %rsp          # imm = 0x10020
movl %edi, %ebx
movq %rsp, %r14
movl $0x1c, (%r14)
leaq 0x20(%rsp), %r15
movl $0xffff, %edx           # imm = 0xFFFF
movq %r15, %rdi
xorl %esi, %esi
callq 0x20e0
leaq 0x4(%rsp), %r8
movl $0xffff, %edx           # imm = 0xFFFF
movl %ebx, %edi
movq %r15, %rsi
xorl %ecx, %ecx
movq %r14, %r9
callq 0x2120
testl %eax, %eax
js 0x3ed1
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpq $0x8, %rax
jae 0x3ede
addq $0x10020, %rsp          # imm = 0x10020
popq %rbx
popq %r14
popq %r15
retq
movb 0x20(%rsp), %cl
cmpb $-0x7f, %cl
jne 0x3f26
movzwl 0x337a(%rip), %ecx      # 0x7268
rolw $0x8, %cx
cmpw %cx, 0x24(%rsp)
jne 0x3ed1
movslq 0x32e0(%rip), %rcx      # 0x71e0
addq $0x8, %rcx
cmpq %rcx, %rax
jne 0x3ed1
movzwl 0x26(%rsp), %eax
rolw $0x8, %ax
movzwl %ax, %edx
leaq 0xc(%rsp), %rsi
movl $0xa, %edi
movl $0x2e, %ecx
jmp 0x3f72
cmpl $0x38, %eax
jb 0x3ed1
cmpb $0x3a, 0x2e(%rsp)
jne 0x3ed1
movb 0x50(%rsp), %al
negb %al
jno 0x3ed1
movzwl 0x3327(%rip), %eax      # 0x7268
rolw $0x8, %ax
cmpw %ax, 0x54(%rsp)
jne 0x3ed1
leaq 0x40(%rsp), %rsi
movzwl 0x16(%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %edx
movl $0xa, %edi
cmpb $0x1, %cl
jne 0x3f6d
movl $0x23, %ecx
jmp 0x3f72
movl $0x25, %ecx
callq 0x4295
jmp 0x3ed1
// File: /workspace/github_c_makefile_star2_O3/martintopholm[P]xping/icmp.c
// Function: probe_cleanup
void
probe_cleanup()
{

	HASH_CLEAR(hh, hash);
	if (ev_read4)
		event_free(ev_read4);
	if (ev_read6)
		event_free(ev_read6);
}

// Assembly:
pushq %rax
movq 0x32dc(%rip), %rax      # 0x7260
testq %rax, %rax
je 0x3fb0
movq 0x70(%rax), %rax
movq (%rax), %rdi
callq 0x21c0
movq 0x32c4(%rip), %rax      # 0x7260
movq 0x70(%rax), %rdi
callq 0x21c0
movq $0x0, 0x32b0(%rip) # 0x7260
movq 0x232b9(%rip), %rdi     # 0x27270
testq %rdi, %rdi
je 0x3fc1
callq 0x22f0
movq 0x232b0(%rip), %rdi     # 0x27278
testq %rdi, %rdi
je 0x3fd3
popq %rax
jmp 0x22f0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/martintopholm[P]xping/icmp.c
// Function: probe_new
struct probe *
probe_new(const char *line, void *owner)
{
	union addr sa;
	struct probe *prb;
	int salen;

	prb = calloc(1, sizeof(*prb));
	if (prb == NULL) {
		perror("malloc");
		return (prb);
	}
	prb->owner = owner;
	strncat(prb->host, line, sizeof(prb->host) - 1);

	salen = sizeof(sa);
	if (evutil_parse_sockaddr_port(prb->host, &sa.sa, &salen) == 0) {
		sa(prb)->sa_family = sa.sa.sa_family;
		if (sa.sa.sa_family == AF_INET6) {
			memcpy(&sin6(prb)->sin6_addr, &sa.sin6.sin6_addr,
			    sizeof(sin6(prb)->sin6_addr));
		} else {
			memcpy(&sin(prb)->sin_addr, &sa.sin.sin_addr,
			    sizeof(sin(prb)->sin_addr));
		}
		prb->resolved = 1;
		activate(prb);
	} else {
		prb->dnstask = dnstask_new(prb->host, resolved, prb);
		if (prb->dnstask == NULL) {
			free(prb);
			return NULL;
		}
	}
	return (prb);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x1, %edi
movl $0xb8, %esi
callq 0x2100
testq %rax, %rax
je 0x408a
movq %rax, %rbx
movq %r15, 0xb0(%rax)
movl $0x3f, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2110
movq %rsp, %rdx
movl $0x1c, (%rdx)
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x20a0
testl %eax, %eax
je 0x4058
leaq 0x6e(%rip), %rsi        # 0x40a5
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x4c20
movq %rax, 0xa8(%rbx)
testq %rax, %rax
jne 0x4098
movq %rbx, %rdi
callq 0x21c0
jmp 0x4096
movzwl 0x4(%rsp), %eax
movw %ax, 0x44(%rbx)
cmpw $0xa, %ax
jne 0x4072
movups 0xc(%rsp), %xmm0
movups %xmm0, 0x4c(%rbx)
jmp 0x4079
movl 0x8(%rsp), %eax
movl %eax, 0x48(%rbx)
movl $0x1, 0x40(%rbx)
movq %rbx, %rdi
callq 0x2fc4
jmp 0x4098
leaq 0x105d(%rip), %rdi      # 0x50ee
callq 0x2150
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/martintopholm[P]xping/icmp.c
// Function: probe_free
void
probe_free(struct probe *prb)
{

	if (prb->dnstask)
		dnstask_free(prb->dnstask);
	deactivate(prb);
	free(prb);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xa8(%rdi), %rdi
testq %rdi, %rdi
je 0x4129
callq 0x4d24
movq %rbx, %rdi
callq 0x367d
movq %rbx, %rdi
popq %rbx
jmp 0x21c0
// File: /workspace/github_c_makefile_star2_O3/martintopholm[P]xping/icmp.c
// Function: probe_send
void
probe_send(struct probe *prb, int seq)
{
	int len;
	int n;

	prb->last_seq = seq;
	if (!prb->resolved) {
		target_mark(prb->owner, seq, '@');
		return;
	}

	if (prb->duplicate) {
		target_mark(prb->owner, seq, '"'); /* transmit error */
		return;
	}

	if (sa(prb)->sa_family == AF_INET6) {
		n = write_packet6(sa(prb), seq & 0xffff);
		len = ICMP6_MINLEN + datalen;
	} else {
		n = write_packet4(sa(prb), seq & 0xffff);
		len = ICMP_MINLEN + datalen;
	}

	if (n < 0) {
		target_mark(prb->owner, seq, '!'); /* transmit error */
	} else if (n != len) {
		target_mark(prb->owner, seq, '$'); /* partial transmit */
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, 0x68(%rdi)
cmpl $0x0, 0x40(%rdi)
je 0x41b6
movl $0x22, %edx
cmpq $0x0, 0x60(%r14)
jne 0x41bb
leaq 0x44(%r14), %r8
movl 0x307e(%rip), %ecx      # 0x71e0
leal 0x8(%rcx), %eax
movl %ebx, %edx
rolw $0x8, %dx
cmpw $0xa, 0x44(%r14)
jne 0x41d0
movl $0x80, 0x130f3(%rip)    # 0x17270
leaq 0x130ec(%rip), %rsi     # 0x17270
movw %dx, 0x130eb(%rip)      # 0x17276
movzwl 0x30d6(%rip), %ecx      # 0x7268
rolw $0x8, %cx
movw %cx, 0x130d7(%rip)      # 0x17274
leaq 0x3094(%rip), %rcx      # 0x7238
movl (%rcx), %edi
movslq %eax, %rdx
xorl %ecx, %ecx
movl $0x1c, %r9d
jmp 0x4264
movl $0x40, %edx
movq 0xb0(%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2554
movl $0x8, 0x3096(%rip)      # 0x7270
movw %dx, 0x3095(%rip)       # 0x7276
movzwl 0x3080(%rip), %edx      # 0x7268
rolw $0x8, %dx
movw %dx, 0x3081(%rip)       # 0x7274
cmpl $-0x6, %ecx
jl 0x421a
addl $0xa, %ecx
leaq 0x306e(%rip), %rsi      # 0x7270
xorl %edx, %edx
movzwl (%rsi), %edi
addq $0x2, %rsi
addl %edi, %edx
addl $-0x2, %ecx
cmpl $0x3, %ecx
ja 0x4204
addl $-0x2, %ecx
jmp 0x4225
leaq 0x304f(%rip), %rsi      # 0x7270
xorl %edx, %edx
movl %eax, %ecx
cmpl $0x1, %ecx
jne 0x422f
movzbl (%rsi), %ecx
addl %ecx, %edx
movl %edx, %ecx
sarl $0x10, %ecx
movzwl %dx, %edx
addl %ecx, %edx
movl %edx, %ecx
shrl $0x10, %ecx
addl %edx, %ecx
notl %ecx
movw %cx, 0x3029(%rip)       # 0x7272
leaq 0x3020(%rip), %rsi      # 0x7270
leaq 0x2fd9(%rip), %rcx      # 0x7230
movl (%rcx), %edi
movslq %eax, %rdx
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x2050
testl %eax, %eax
js 0x428b
movl 0x2f6d(%rip), %ecx      # 0x71e0
addl $0x8, %ecx
movl $0x24, %edx
cmpl %eax, %ecx
jne 0x41bb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x21, %edx
jmp 0x41bb
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: find_method
static s7_pointer find_method(s7_scheme *sc, s7_pointer env, s7_pointer symbol)
    {
        s7_pointer x;
        if (symbol_id(symbol) == 0) /* this means the symbol has never been used locally, so how can it be a method? */
            return(sc->undefined);

        if (let_id(env) == symbol_id(symbol))
            return(slot_value(local_slot(symbol)));

        for (x = env; symbol_id(symbol) < let_id(x); x = outlet(x));

        if (let_id(x) == symbol_id(symbol))
            return(slot_value(local_slot(symbol)));

        for (; is_let(x); x = outlet(x))
        {
            s7_pointer y;
            for (y = let_slots(x); tis_slot(y); y = next_slot(y))
                if (slot_symbol(y) == symbol)
                    return(slot_value(y));
        }
        return(sc->undefined);
    }

// Assembly:
movq 0x20(%rdx), %rax
testq %rax, %rax
je 0x8a4f
movq 0x18(%rsi), %rcx
cmpq %rax, %rcx
je 0x8a25
jle 0x8a20
movq 0x10(%rsi), %rsi
movq 0x18(%rsi), %rcx
cmpq %rcx, %rax
jl 0x8a13
cmpq %rax, %rcx
jne 0x8a2f
movq 0x18(%rdx), %rdi
addq $0x10, %rdi
jmp 0x8a56
cmpb $0x1c, (%rsi)
jne 0x8a4f
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x8a49
cmpq %rdx, 0x8(%rax)
je 0x8a5a
movq 0x18(%rax), %rax
jmp 0x8a38
movq 0x10(%rsi), %rsi
jmp 0x8a2f
addq $0x128, %rdi            # imm = 0x128
movq (%rdi), %rax
retq
addq $0x10, %rax
movq %rax, %rdi
jmp 0x8a56
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: find_let
static s7_pointer find_let(s7_scheme *sc, s7_pointer obj)
    {
        if (is_let(obj)) return(obj);
        switch (type(obj))
        {
            case T_MACRO:   case T_MACRO_STAR:
            case T_BACRO:   case T_BACRO_STAR:
            case T_CLOSURE: case T_CLOSURE_STAR:
                return(closure_let(obj));

            case T_C_OBJECT:
                return(c_object_let(obj));

            case T_C_POINTER:
                if ((is_let(c_pointer_info(obj))) &&
                        (c_pointer_info(obj) != sc->rootlet))
                    return(c_pointer_info(obj));
        }
        return(sc->nil);
    }

// Assembly:
movq %rsi, %rax
movzbl (%rsi), %ecx
cmpl $0x27, %ecx
jle 0x8a81
addl $-0x28, %ecx
cmpl $0x5, %ecx
ja 0x8aa2
addq $0x18, %rax
movq %rax, %rdi
movq (%rdi), %rax
retq
cmpl $0x14, %ecx
je 0x8a76
cmpl $0x1c, %ecx
je 0x8a80
cmpl $0x21, %ecx
jne 0x8aa2
movq 0x18(%rax), %rax
cmpb $0x1c, (%rax)
jne 0x8aa2
cmpq 0x150(%rdi), %rax
jne 0x8a80
addq $0x110, %rdi            # imm = 0x110
jmp 0x8a7d
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_gc_protect
s7_inline s7_int s7_gc_protect(s7_scheme *sc, s7_pointer x)
    {
        s7_int loc;
        if (sc->gpofl_loc < 0)
            resize_gc_protect(sc);
        loc = sc->gpofl[sc->gpofl_loc--];
        vector_element(sc->protected_objects, loc) = x;
        return(loc);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x108(%rdi)
js 0x8b43
movq 0xe8(%r14), %rax
jmp 0x8bf8
movq 0xd0(%r14), %rax
movq 0xf0(%r14), %r12
leaq (%r12,%r12), %r13
movq 0x18(%rax), %rsi
movq %r12, %r15
shlq $0x4, %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x9fd6
movq $0x0, 0x20(%rax)
movq 0xd0(%r14), %rcx
movq %rax, 0x18(%rcx)
movq (%rax), %rax
movq 0xd0(%r14), %rcx
movq %rax, 0x10(%rcx)
movq 0xd0(%r14), %rax
movq %r13, 0x8(%rax)
movq %r13, 0xf0(%r14)
movq 0xe8(%r14), %rdi
movq %r15, %rsi
callq 0x8510
movq %rax, 0xe8(%r14)
cmpq %r13, %r12
jge 0x8bf8
movq 0x140(%r14), %rcx
movq %r12, %rdx
movq 0xd0(%r14), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax,%rdx,8)
movq 0xe8(%r14), %rax
movq 0x108(%r14), %rsi
leaq 0x1(%rsi), %rdi
movq %rdi, 0x108(%r14)
movq %rdx, 0x8(%rax,%rsi,8)
incq %rdx
decq %r12
jne 0x8bc3
movq 0xd0(%r14), %rcx
movq 0x108(%r14), %rdx
leaq -0x1(%rdx), %rsi
movq %rsi, 0x108(%r14)
movq (%rax,%rdx,8), %rax
movq 0x10(%rcx), %rcx
movq %rbx, (%rcx,%rax,8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_gc_unprotect
void s7_gc_unprotect(s7_scheme *sc, s7_pointer x)
    {
        s7_int i;
        for (i = 0; i < sc->protected_objects_size; i++)
            if (vector_element(sc->protected_objects, i) == x)
            {
                vector_element(sc->protected_objects, i) = sc->unused;
                sc->gpofl[++sc->gpofl_loc] = i;
                return;
            }
    }

// Assembly:
movq 0xf0(%rdi), %rcx
testq %rcx, %rcx
jle 0x8c4e
movq 0xd0(%rdi), %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
cmpq %rsi, (%rdx,%rax,8)
je 0x8c4f
incq %rax
cmpq %rax, %rcx
jne 0x8c40
retq
movq 0x140(%rdi), %rcx
movq %rcx, (%rdx,%rax,8)
movq 0xe8(%rdi), %rcx
movq 0x108(%rdi), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x108(%rdi)
movq %rax, 0x8(%rcx,%rdx,8)
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_gc_unprotect_at
void s7_gc_unprotect_at(s7_scheme *sc, s7_int loc)
    {
        if (loc < sc->protected_objects_size)
        {
            if (vector_element(sc->protected_objects, loc) != sc->unused)
                sc->gpofl[++sc->gpofl_loc] = loc;
            vector_element(sc->protected_objects, loc) = sc->unused;
        }
    }

// Assembly:
cmpq %rsi, 0xf0(%rdi)
jle 0x8cc0
movq 0xd0(%rdi), %rcx
movq 0x140(%rdi), %rax
movq 0x10(%rcx), %rdx
cmpq %rax, (%rdx,%rsi,8)
je 0x8cbc
movq 0xe8(%rdi), %rdx
movq 0x108(%rdi), %r8
leaq 0x1(%r8), %r9
movq %r9, 0x108(%rdi)
movq %rsi, 0x8(%rdx,%r8,8)
movq 0x10(%rcx), %rdx
movq %rax, (%rdx,%rsi,8)
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_gc_protected_at
s7_pointer s7_gc_protected_at(s7_scheme *sc, s7_int loc)
    {
        s7_pointer obj;

        obj = sc->unspecified;
        if (loc < sc->protected_objects_size)
            obj = vector_element(sc->protected_objects, loc);
        if (obj == sc->unused)
            return(sc->unspecified);

        return(obj);
    }

// Assembly:
leaq 0x130(%rdi), %rcx
movq %rcx, %rax
cmpq %rsi, 0xf0(%rdi)
jle 0x8ce6
movq 0xd0(%rdi), %rax
shlq $0x3, %rsi
addq 0x10(%rax), %rsi
movq %rsi, %rax
movq (%rax), %rax
cmpq 0x140(%rdi), %rax
je 0x8cf3
retq
movq (%rcx), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_symbol_table_find_name
s7_pointer s7_symbol_table_find_name(s7_scheme *sc, const char *name)
    {
        uint64_t hash;
        uint32_t location;
        s7_pointer result;

        hash = raw_string_hash((const uint8_t *)name, safe_strlen(name));
        location = hash % SYMBOL_TABLE_SIZE;
        result = symbol_table_find_by_name(sc, name, hash, location);
        if (is_null(result))
            return(NULL);

        return(result);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
testq %rsi, %rsi
je 0x8f83
cmpb $0x0, (%rbx)
je 0x8f83
xorl %edx, %edx
cmpb $0x0, 0x1(%rbx,%rdx)
leaq 0x1(%rdx), %rdx
jne 0x8f33
movq $0x0, 0x8(%rsp)
cmpq $0x8, %rdx
jle 0x8f8e
movq (%rbx), %r14
leaq 0x10(%rsp), %r12
movq $0x0, (%r12)
leaq 0x8(%rbx), %rsi
cmpq $0x10, %rdx
movl $0x10, %eax
cmovbq %rdx, %rax
addq $-0x8, %rax
movq %r12, %rdi
movq %rax, %rdx
callq 0x83e0
addq (%r12), %r14
jmp 0x8fa1
movq $0x0, 0x8(%rsp)
xorl %edx, %edx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x83e0
movq (%r14), %r14
movabsq $-0x7fecfd2d94c4151b, %rcx # imm = 0x801302D26B3BEAE5
movq %r14, %rax
mulq %rcx
shrq $0xe, %rdx
imull $0x7fed, %edx, %eax     # imm = 0x7FED
movl %r14d, %edx
subl %eax, %edx
movq 0x110(%r15), %rcx
movq 0x148(%r15), %rax
movq 0x10(%rax), %rax
movq (%rax,%rdx,8), %rax
movq %rcx, %rdx
cmpq %rcx, %rax
je 0x9016
cmpq %r14, 0x18(%rax)
jne 0x9004
movq 0x20(%rax), %rdx
xorl %esi, %esi
movb (%rbx,%rsi), %dil
movb (%rdx,%rsi), %r8b
testb %dil, %dil
je 0x8fff
incq %rsi
cmpb %r8b, %dil
je 0x8fea
cmpb %r8b, %dil
je 0x9012
movq 0x10(%rax), %rax
cmpq %rcx, %rax
jne 0x8fde
movq %rcx, %rdx
jmp 0x9016
movq 0x8(%rax), %rdx
xorl %eax, %eax
cmpq %rcx, %rdx
cmovneq %rdx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_for_each_symbol_name
bool s7_for_each_symbol_name(s7_scheme *sc, bool (*symbol_func)(const char *symbol_name, void *data), void *data)
    {
        /* this includes the special constants #<unspecified> and so on for simplicity -- are there any others? */
        int32_t i;
        s7_pointer x;

        for (i = 0; i < SYMBOL_TABLE_SIZE; i++)
            for (x = vector_element(sc->symbol_table, i); is_not_null(x); x = cdr(x))
                if (symbol_func(symbol_name(car(x)), data))
                    return(true);

        return((symbol_func("#t", data))             ||
                (symbol_func("#f", data))             ||
                (symbol_func("#<unspecified>", data)) ||
                (symbol_func("#<undefined>", data))   ||
                (symbol_func("#<eof>", data))         ||
                (symbol_func("#true", data))          ||
                (symbol_func("#false", data)));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
movq 0x110(%rdi), %rax
xorl %r15d, %r15d
movq 0x148(%r14), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx,%r15,8), %r12
cmpq %rax, %r12
je 0x9087
movq 0x8(%r12), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq *%r13
testb %al, %al
jne 0x90f9
movq 0x10(%r12), %r12
movq %r12, %rax
cmpq 0x110(%r14), %r12
jne 0x905b
incq %r15
cmpq $0x7fed, %r15           # imm = 0x7FED
jne 0x9047
leaq 0x1024a2(%rip), %rdi    # 0x10b53c
movq %rbx, %rsi
callq *%r13
testb %al, %al
jne 0x90f9
leaq 0x102c10(%rip), %rdi    # 0x10bcbb
movq %rbx, %rsi
callq *%r13
testb %al, %al
jne 0x90f9
leaq 0x102d77(%rip), %rdi    # 0x10be33
movq %rbx, %rsi
callq *%r13
testb %al, %al
jne 0x90f9
leaq 0x100f17(%rip), %rdi    # 0x109fe4
movq %rbx, %rsi
callq *%r13
testb %al, %al
jne 0x90f9
leaq 0x100f13(%rip), %rdi    # 0x109ff1
movq %rbx, %rsi
callq *%r13
testb %al, %al
jne 0x90f9
leaq 0x100f09(%rip), %rdi    # 0x109ff8
movq %rbx, %rsi
callq *%r13
testb %al, %al
je 0x9105
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x100ef2(%rip), %rdi    # 0x109ffe
movq %rbx, %rsi
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_for_each_symbol
bool s7_for_each_symbol(s7_scheme *sc, bool (*symbol_func)(const char *symbol_name, void *data), void *data)
    {
        int32_t i;
        s7_pointer x;

        for (i = 0; i < SYMBOL_TABLE_SIZE; i++)
            for (x = vector_element(sc->symbol_table, i); is_not_null(x); x = cdr(x))
                if (symbol_func(symbol_name(car(x)), data))
                    return(true);

        return(false);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x110(%rdi), %rax
movb $0x1, %bl
xorl %r13d, %r13d
movq 0x148(%r12), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx,%r13,8), %rbp
cmpq %rax, %rbp
je 0x9179
movq 0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq *%r15
testb %al, %al
jne 0x9195
movq 0x10(%rbp), %rbp
movq %rbp, %rax
cmpq 0x110(%r12), %rbp
jne 0x9152
cmpq $0x7fec, %r13           # imm = 0x7FEC
leaq 0x1(%r13), %rcx
setb %bl
movq %rcx, %r13
cmpq $0x7fed, %rcx           # imm = 0x7FED
jne 0x913d
xorl %ebx, %ebx
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_gensym
s7_pointer s7_gensym(s7_scheme *sc, const char *prefix)
    {
        block_t *b;
        char *name;
        uint32_t location;
        s7_int len;
        uint64_t hash;
        s7_pointer x;

        len = safe_strlen(prefix) + 32;
        b = mallocate(sc, len);
        name = (char *)block_data(b);
        /* there's no point in heroic efforts here to avoid name collisions -- the user can screw up no matter what we do */
        name[0] = '\0';
        len = catstrs(name, len, "{", (prefix) ? prefix : "", "}-", pos_int_to_str_direct(sc, sc->gensym_counter++), NULL);
        hash = raw_string_hash((const uint8_t *)name, len);
        location = hash % SYMBOL_TABLE_SIZE;
        x = new_symbol(sc, name, len, hash, location);  /* not T_GENSYM -- might be called from outside */
        liberate(sc, b);
        return(x);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x20, %r13d
testq %rsi, %rsi
je 0x91db
movq %rsi, %r12
cmpb $0x0, (%rsi)
je 0x91e2
cmpb $0x0, -0x1f(%r12,%r13)
leaq 0x1(%r13), %r13
jne 0x91cd
jmp 0x91e2
leaq 0x1132ec(%rip), %r12    # 0x11c4ce
movq %rbx, %rdi
movq %r13, %rsi
callq 0x9357
movq %rax, %r14
movq (%rax), %r15
xorl %eax, %eax
movb %al, (%r15)
movl 0x220(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x220(%rbx)
leaq 0xb6f(%rbx), %r9
movb %al, 0xb6f(%rbx)
leaq 0x10d325(%rip), %rsi    # 0x116540
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %rdi
shrq $0x3, %rdx
leaq (%rdx,%rdx), %rax
leaq (%rax,%rax,4), %rax
movq %rcx, %r8
subq %rax, %r8
movb (%rsi,%r8), %al
movb %al, -0x1(%r9)
decq %r9
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x9225
xorl %ebp, %ebp
movq %rbp, (%rsp)
leaq 0x100da7(%rip), %rdx    # 0x10a005
leaq 0x100da2(%rip), %r8     # 0x10a007
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0x9517
movq %rax, %r12
movq %rbp, 0x8(%rsp)
cmpq $0x8, %rax
jg 0x929c
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x83e0
movq (%r13), %r13
jmp 0x92cd
movq (%r15), %r13
leaq 0x10(%rsp), %rbp
movq $0x0, (%rbp)
leaq 0x8(%r15), %rsi
cmpq $0x10, %r12
movl $0x10, %edx
cmovbq %r12, %rdx
addq $-0x8, %rdx
movq %rbp, %rdi
callq 0x83e0
addq (%rbp), %r13
movabsq $-0x7fecfd2d94c4151b, %rcx # imm = 0x801302D26B3BEAE5
movq %r13, %rax
mulq %rcx
shrq $0xe, %rdx
imull $0x7fed, %edx, %eax     # imm = 0x7FED
movl %r13d, %r8d
subl %eax, %r8d
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x9632
movq %rax, %r15
movslq 0x8(%r14), %rax
cmpq $0x11, %rax
jne 0x9330
movq (%r14), %rdi
testq %rdi, %rdi
je 0x931f
callq 0x8050
movq $0x0, (%r14)
movl $0x0, 0x8(%r14)
addq $0x838, %rbx            # imm = 0x838
jmp 0x933b
leaq (%rbx,%rax,8), %rbx
addq $0x838, %rbx            # imm = 0x838
movq (%rbx), %rax
movq %rax, 0x18(%r14)
movq %r14, (%rbx)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: catstrs
static size_t catstrs(char *dst, size_t len, ...) /* NULL-terminated arg list */
    {
        const char *s, *dend;
        char *d;
        va_list ap;
        d = dst;
        dend = (const char *)(dst + len);
        while ((*d) && (d < dend)) d++;
        va_start(ap, len);
        for (s = va_arg(ap, const char *); s != NULL; s = va_arg(ap, const char *))
            while ((*s) && (d < dend)) {*d++ = *s++;}
        *d = '\0';
        va_end (ap);
        return(d - dst);
    }

// Assembly:
subq $0x58, %rsp
movq %rdx, -0x50(%rsp)
movq %rcx, -0x48(%rsp)
movq %r8, -0x40(%rsp)
movq %r9, -0x38(%rsp)
testb %al, %al
je 0x955a
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
addq %rdi, %rsi
movq %rdi, %rcx
leaq 0x1(%rcx), %rax
cmpb $0x0, (%rcx)
je 0x9571
cmpq %rsi, %rcx
movq %rax, %rcx
jb 0x9560
leaq -0x60(%rsp), %rcx
movq %rcx, -0x70(%rsp)
leaq 0x60(%rsp), %rcx
movq %rcx, -0x78(%rsp)
movabsq $0x3000000010, %rcx     # imm = 0x3000000010
movq %rcx, -0x80(%rsp)
movl $0x10, %ecx
movl $0x10, %edx
cmpq $0x28, %rdx
ja 0x95b2
addq -0x70(%rsp), %rdx
addl $0x8, %ecx
movl %ecx, -0x80(%rsp)
jmp 0x95c0
movq -0x78(%rsp), %rdx
leaq 0x8(%rdx), %r8
movq %r8, -0x78(%rsp)
decq %rax
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x9627
movb (%rdx), %r8b
testb %r8b, %r8b
setne %r9b
cmpq %rsi, %rax
setb %r10b
andb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x9602
incq %rdx
movb %r8b, (%rax)
incq %rax
movb (%rdx), %r8b
testb %r8b, %r8b
je 0x95fe
incq %rdx
cmpq %rsi, %rax
jb 0x95e8
movl -0x80(%rsp), %ecx
cmpl $0x28, %ecx
ja 0x9617
movl %ecx, %edx
addq -0x70(%rsp), %rdx
addl $0x8, %ecx
movl %ecx, -0x80(%rsp)
jmp 0x95c3
movq -0x78(%rsp), %rdx
leaq 0x8(%rdx), %r8
movq %r8, -0x78(%rsp)
jmp 0x95c3
movb $0x0, (%rax)
subq %rdi, %rax
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: liberate
static inline void liberate(s7_scheme *sc, block_t *p)
    {
        if (block_index(p) != TOP_BLOCK_LIST)
        {
            block_next(p) = (struct block_t *)sc->block_lists[block_index(p)];
            sc->block_lists[block_index(p)] = p;
        }
        else
        {
            if (block_data(p))
            {
#if S7_DEBUGGING
                permanent_string_len -= block_size(p);
#endif
                free(block_data(p));
                block_data(p) = NULL;
            }
            block_set_index(p, BLOCK_LIST);
            block_next(p) = (struct block_t *)sc->block_lists[block_index(p)];
            sc->block_lists[block_index(p)] = p;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x8(%rsi), %rax
cmpq $0x11, %rax
jne 0x9a4a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x9a3a
callq 0x8050
movq $0x0, (%rbx)
movl $0x0, 0x8(%rbx)
addq $0x838, %r14            # imm = 0x838
jmp 0x9a55
leaq (%r14,%rax,8), %r14
addq $0x838, %r14            # imm = 0x838
movq (%r14), %rax
movq %rax, 0x18(%rbx)
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq