LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
imulq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x30(%rbp), %rax
cmpq $0x3e8, %rax            # imm = 0x3E8
jbe 0x5f02
movq -0x38(%rbp), %rax
cmpq $0x3e8, 0x8(%rax)       # imm = 0x3E8
ja 0x5ef2
movq -0x38(%rbp), %rcx
movl $0x3e8, %eax            # imm = 0x3E8
subq 0x8(%rcx), %rax
movq %rax, -0x48(%rbp)
jmp 0x5efa
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x5efa
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x1, -0x30(%rbp)
jae 0x5f13
movq $0x0, -0x8(%rbp)
jmp 0x5f81
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
addq -0x30(%rbp), %rsi
callq 0x23d0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x5f6f
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rax
addq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x2170
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
jmp 0x5f79
movq $0x0, -0x8(%rbp)
jmp 0x5f81
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x1080, %rsp           # imm = 0x1080
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x5fb9
movq $0x0, -0x8(%rbp)
jmp 0x60e8
movl -0x14(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
callq 0x2300
movq %rax, -0x1070(%rbp)
movq -0x1070(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movslq -0x14(%rbp), %rdx
callq 0x2170
movq -0x20(%rbp), %rsi
leaq -0x1068(%rbp), %rdi
movl $0x1c, %edx
callq 0x3a50
movq -0x1070(%rbp), %rsi
movslq -0x14(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq -0x1068(%rbp), %rdi
callq 0x40d0
movq -0x1070(%rbp), %rdi
leaq 0x4576(%rip), %rsi      # 0xa59e
callq 0x2060
movq %rax, -0x1078(%rbp)
cmpq $0x0, -0x1078(%rbp)
jne 0x6092
jmp 0x6040
movq 0x6f91(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x47c5(%rip), %rsi      # 0xa816
movb $0x0, %al
callq 0x2330
movq 0x6f79(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x4539(%rip), %rsi      # 0xa5a2
movb $0x0, %al
callq 0x2330
movq 0x6f61(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x4795(%rip), %rsi      # 0xa816
movb $0x0, %al
callq 0x2330
movl $0x1, %edi
callq 0x2290
movq -0x1078(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x1, 0x7201(%rip)      # 0xd2a4
jb 0x60dd
movq 0x6f2c(%rip), %rax      # 0xcfd8
movq (%rax), %rsi
leaq 0x4517(%rip), %rdi      # 0xa5cd
callq 0x2240
movq -0x1070(%rbp), %rdi
callq 0x4c20
movq 0x6f0a(%rip), %rax      # 0xcfd8
movq (%rax), %rsi
leaq 0x473e(%rip), %rdi      # 0xa816
callq 0x2240
movq -0x1070(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1080, %rsp           # imm = 0x1080
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x656d
cmpq $0x0, 0x6da5(%rip)      # 0xd310
jne 0x657a
movq $0x0, -0x8(%rbp)
jmp 0x6673
movq 0x6d8f(%rip), %rdi      # 0xd310
callq 0x2050
movq 0x6d83(%rip), %rdx      # 0xd310
leaq 0x6d8c(%rip), %rdi      # 0xd320
movl $0x200, %esi            # imm = 0x200
callq 0x23b0
cmpq $0x0, %rax
je 0x65fd
leaq 0x6d75(%rip), %rdi      # 0xd320
leaq 0x40e3(%rip), %rsi      # 0xa695
callq 0x2390
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x40cf(%rip), %rsi      # 0xa695
callq 0x2390
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x65dd
cmpq $0x0, -0x20(%rbp)
jne 0x65df
jmp 0x6586
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2320
cmpl $0x0, %eax
jne 0x65fb
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6673
jmp 0x6586
movq 0x6d0c(%rip), %rdi      # 0xd310
callq 0x2370
cmpl $0x0, %eax
jne 0x666b
jmp 0x6610
movq 0x69c1(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x41f5(%rip), %rsi      # 0xa816
movb $0x0, %al
callq 0x2330
movq 0x69a9(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x4061(%rip), %rsi      # 0xa69a
movb $0x0, %al
callq 0x2330
movq 0x6991(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x4158(%rip), %rsi      # 0xa7a9
movb $0x0, %al
callq 0x2330
xorl %eax, %eax
movl %eax, %edi
callq 0x2180
movl $0x1, %edi
callq 0x2290
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x66a1
cmpq $0x0, 0x6c71(%rip)      # 0xd310
jne 0x66a6
jmp 0x67c3
movq -0x8(%rbp), %rdi
callq 0x6550
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x66fe
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2320
cmpl $0x0, %eax
je 0x66e3
movq 0x6906(%rip), %rax      # 0xcfd8
movq (%rax), %rsi
leaq 0x3fc4(%rip), %rdi      # 0xa6a0
callq 0x2240
jmp 0x66f9
movq 0x68ee(%rip), %rax      # 0xcfd8
movq (%rax), %rsi
leaq 0x3fe3(%rip), %rdi      # 0xa6d7
callq 0x2240
jmp 0x67c3
movq 0x6bf3(%rip), %rdi      # 0xd2f8
leaq 0x3d32(%rip), %rsi      # 0xa43e
callq 0x49e0
movq %rax, -0x20(%rbp)
movq 0x6bf4(%rip), %rdi      # 0xd310
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq 0x3fce(%rip), %rsi      # 0xa6fd
movb $0x0, %al
callq 0x2330
cmpl $0x0, %eax
jge 0x6798
jmp 0x673d
movq 0x6894(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x40c8(%rip), %rsi      # 0xa816
movb $0x0, %al
callq 0x2330
movq 0x687c(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x3fa3(%rip), %rsi      # 0xa709
movb $0x0, %al
callq 0x2330
movq 0x6864(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x402b(%rip), %rsi      # 0xa7a9
movb $0x0, %al
callq 0x2330
xorl %eax, %eax
movl %eax, %edi
callq 0x2180
movl $0x1, %edi
callq 0x2290
movq 0x6b71(%rip), %rdi      # 0xd310
callq 0x2260
movq 0x682d(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
movq 0x6b53(%rip), %rdx      # 0xd308
leaq 0x3f55(%rip), %rsi      # 0xa711
movb $0x0, %al
callq 0x2330
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3720
movq -0x8(%rbp), %rax
addq $0x98, %rax
leaq -0x20(%rbp), %rcx
movups (%rcx), %xmm1
movups (%rax), %xmm0
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
subl $0xffff, %eax           # imm = 0xFFFF
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x74be
movq -0x8(%rbp), %rax
cmpl $0x0, 0xa8(%rax)
je 0x746a
jmp 0x7418
movq 0x5bb9(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x33ed(%rip), %rsi      # 0xa816
movb $0x0, %al
callq 0x2330
movq 0x5ba1(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x3565(%rip), %rsi      # 0xa9a6
movb $0x0, %al
callq 0x2330
movq 0x5b89(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x33bd(%rip), %rsi      # 0xa816
movb $0x0, %al
callq 0x2330
movl $0x1, %edi
callq 0x2290
jmp 0x746c
movq 0x5b65(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x3399(%rip), %rsi      # 0xa816
movb $0x0, %al
callq 0x2330
movq 0x5b4d(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x3549(%rip), %rsi      # 0xa9de
movb $0x0, %al
callq 0x2330
movq 0x5b35(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x3369(%rip), %rsi      # 0xa816
movb $0x0, %al
callq 0x2330
movl $0x1, %edi
callq 0x2290
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x4cd2(%rip), %eax      # 0xd2a0
movq %rax, -0x10(%rbp)
subq $0x3, %rax
ja 0x86be
movq -0x10(%rbp), %rax
leaq 0x1a79(%rip), %rcx      # 0xa060
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x4d01(%rip), %rdi      # 0xd2f8
callq 0x4c20
jmp 0x86be
callq 0x67d0
jmp 0x86be
movl $0x1, -0x4(%rbp)
cmpq $0x0, 0x4ca6(%rip)      # 0xd2c0
jne 0x8677
movl $0x0, -0x4(%rbp)
movq 0x4cce(%rip), %rdi      # 0xd2f8
leaq 0x22df(%rip), %rsi      # 0xa910
callq 0x49e0
movq %rax, %rdi
callq 0x6550
movq %rax, 0x4eeb(%rip)      # 0xd530
cmpq $0x0, 0x4ee3(%rip)      # 0xd530
je 0x8670
movq 0x4982(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
movq 0x4ed0(%rip), %rdx      # 0xd530
leaq 0x260f(%rip), %rsi      # 0xac76
movb $0x0, %al
callq 0x2330
jmp 0x8675
callq 0x67d0
jmp 0x868a
movq 0x4c42(%rip), %rdi      # 0xd2c0
callq 0x2440
movq %rax, 0x4ea6(%rip)      # 0xd530
callq 0x7b00
cmpl $0x0, -0x4(%rbp)
je 0x86b7
movq 0x4c5c(%rip), %rdi      # 0xd2f8
leaq 0x226d(%rip), %rsi      # 0xa910
callq 0x49e0
movq %rax, %rdi
movq 0x4e7e(%rip), %rsi      # 0xd530
callq 0x6680
jmp 0x86be
callq 0x74d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x2f9f(%rip), %rax      # 0x7fa8
movq %rax, 0x20(%rsp)
movl $0x6, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq 0x30(%rsp), %r8
movl $0x1, %edi
callq 0x2150
movq 0x30(%rsp), %rdi
callq 0x2180
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/5-Signal/handle_int.c
// Function: sig_handler
void sig_handler(int sig)
{
	if(sig == SIGINT)
		printf("I've received Ctrl + C\n");
	else if(sig == SIGQUIT)
		printf("I've received Ctrl + \\\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x2, -0x4(%rbp)
jne 0x1181
leaq 0xe8c(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
jmp 0x1197
cmpl $0x3, -0x4(%rbp)
jne 0x1195
leaq 0xe8e(%rip), %rdi       # 0x201c
movb $0x0, %al
callq 0x1030
jmp 0x1197
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/5-Signal/handle_int.c
// Function: main
int main(void)
{
	int c;
	signal(SIGINT, sig_handler);
	signal(SIGQUIT, sig_handler);
	printf("Press enter\n");
	c = getchar();
	printf("End of program (%c) \n", c);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x2, %edi
leaq -0x5b(%rip), %rsi       # 0x1160
callq 0x1050
movl $0x3, %edi
leaq -0x6c(%rip), %rsi       # 0x1160
callq 0x1050
leaq 0xe5c(%rip), %rdi       # 0x2034
movb $0x0, %al
callq 0x1030
callq 0x1040
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %esi
leaq 0xe50(%rip), %rdi       # 0x2041
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x4101(%rip), %rax      # 0x9240
cmpl $0x0, (%rax)
jge 0x5170
leaq 0x40f9(%rip), %rax      # 0x9244
movl (%rax), %eax
movl %eax, -0x8(%rbp)
callq 0x2040
movl -0x8(%rbp), %ecx
movl %ecx, (%rax)
leaq 0x213f(%rip), %rdi      # 0x72a0
callq 0x2180
movl $0x1, %edi
callq 0x21f0
leaq 0x40d1(%rip), %rax      # 0x9248
cmpl $0x0, (%rax)
jge 0x51a8
leaq 0x40c9(%rip), %rax      # 0x924c
movl (%rax), %eax
movl %eax, -0xc(%rbp)
callq 0x2040
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
leaq 0x2115(%rip), %rdi      # 0x72ae
callq 0x2180
movl $0x1, %edi
callq 0x21f0
callq 0x22b0
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, 0x40c0(%rip)      # 0x9278
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x4028(%rip), %eax      # 0x91f0
jge 0x520a
movl -0x4(%rbp), %eax
addl $0x30, %eax
movb %al, %dl
movl -0x4(%rbp), %eax
addl $0x8, %eax
movslq %eax, %rcx
leaq 0x409e(%rip), %rax      # 0x9280
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x30, %eax
movb %al, %dl
movslq -0x4(%rbp), %rcx
addq $0x8, %rcx
leaq 0x14084(%rip), %rax     # 0x19280
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x51bf
leaq 0x402f(%rip), %rax      # 0x9240
movl (%rax), %edi
callq 0x2290
leaq 0x4019(%rip), %rax      # 0x9238
movq (%rax), %rdi
leaq 0x4017(%rip), %rax      # 0x9240
movl (%rax), %esi
movl $0x12, %edx
leaq 0x79(%rip), %rcx        # 0x52b0
xorl %eax, %eax
movl %eax, %r8d
callq 0x2190
movq %rax, 0x24038(%rip)     # 0x29280
movq 0x24031(%rip), %rdi     # 0x29280
xorl %eax, %eax
movl %eax, %esi
callq 0x20c0
leaq 0x3fe9(%rip), %rax      # 0x9248
movl (%rax), %edi
callq 0x2290
leaq 0x3fcb(%rip), %rax      # 0x9238
movq (%rax), %rdi
leaq 0x3fd1(%rip), %rax      # 0x9248
movl (%rax), %esi
movl $0x12, %edx
leaq 0x28b(%rip), %rcx       # 0x5510
xorl %eax, %eax
movl %eax, %r8d
callq 0x2190
movq %rax, 0x23ff2(%rip)     # 0x29288
movq 0x23feb(%rip), %rdi     # 0x29288
xorl %eax, %eax
movl %eax, %esi
callq 0x20c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
jmp 0x5756
cmpq $0x0, 0x3b12(%rip)      # 0x9270
je 0x578e
movq 0x3b09(%rip), %rax      # 0x9270
movq 0x70(%rax), %rax
movq (%rax), %rdi
callq 0x21e0
movq 0x3af6(%rip), %rax      # 0x9270
movq 0x70(%rax), %rdi
callq 0x21e0
movq $0x0, 0x3ae2(%rip) # 0x9270
jmp 0x5790
cmpq $0x0, 0x23ae8(%rip)     # 0x29280
je 0x57a6
movq 0x23adf(%rip), %rdi     # 0x29280
callq 0x2310
cmpq $0x0, 0x23ada(%rip)     # 0x29288
je 0x57bc
movq 0x23ad1(%rip), %rdi     # 0x29288
callq 0x2310
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0xb8, %esi
callq 0x2120
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x5803
leaq 0x19e9(%rip), %rdi      # 0x71da
callq 0x2180
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x58d9
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0xb0(%rax)
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x3f, %edx
callq 0x2130
movl $0x1c, -0x44(%rbp)
movq -0x40(%rbp), %rdi
leaq -0x34(%rbp), %rsi
leaq -0x44(%rbp), %rdx
callq 0x20b0
cmpl $0x0, %eax
jne 0x588c
movw -0x34(%rbp), %cx
movq -0x40(%rbp), %rax
movw %cx, 0x44(%rax)
movzwl -0x34(%rbp), %eax
cmpl $0xa, %eax
jne 0x586c
movq -0x40(%rbp), %rax
movq -0x2c(%rbp), %rcx
movq %rcx, 0x4c(%rax)
movq -0x24(%rbp), %rcx
movq %rcx, 0x54(%rax)
jmp 0x5876
movq -0x40(%rbp), %rax
movl -0x30(%rbp), %ecx
movl %ecx, 0x48(%rax)
movq -0x40(%rbp), %rax
movl $0x1, 0x40(%rax)
movq -0x40(%rbp), %rdi
callq 0x3270
jmp 0x58d1
movq -0x40(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x55(%rip), %rsi        # 0x58f0
callq 0x6af0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0xa8(%rax)
movq -0x40(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x58cf
movq -0x40(%rbp), %rdi
callq 0x21e0
movq $0x0, -0x8(%rbp)
jmp 0x58d9
jmp 0x58d1
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x59ea
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x6c90
movq -0x8(%rbp), %rdi
callq 0x4340
movq -0x8(%rbp), %rdi
callq 0x21e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jne 0x5a50
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rdi
movl -0xc(%rbp), %esi
movl $0x40, %edx
callq 0x24c0
jmp 0x5b19
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x5a78
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rdi
movl -0xc(%rbp), %esi
movl $0x22, %edx
callq 0x24c0
jmp 0x5b19
movq -0x8(%rbp), %rax
movzwl 0x44(%rax), %eax
cmpl $0xa, %eax
jne 0x5ab0
movq -0x8(%rbp), %rdi
addq $0x44, %rdi
movl -0xc(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movzwl %ax, %esi
callq 0x5b20
movl %eax, -0x14(%rbp)
movslq 0x3749(%rip), %rax      # 0x91f0
addq $0x8, %rax
movl %eax, -0x10(%rbp)
jmp 0x5ad7
movq -0x8(%rbp), %rdi
addq $0x44, %rdi
movl -0xc(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movzwl %ax, %esi
callq 0x5bc0
movl %eax, -0x14(%rbp)
movl 0x371f(%rip), %eax      # 0x91f0
addl $0x8, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x5af7
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rdi
movl -0xc(%rbp), %esi
movl $0x21, %edx
callq 0x24c0
jmp 0x5b19
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x5b17
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rdi
movl -0xc(%rbp), %esi
movl $0x24, %edx
callq 0x24c0
jmp 0x5b19
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/icmp.c
// Function: write_packet6
static int
write_packet6(struct sockaddr *sa, unsigned short seq)
{
	struct icmp6_hdr *icmp6h;
	int len;

	len = ICMP6_MINLEN + datalen;
	icmp6h = (struct icmp6_hdr *)outpacket6;
	icmp6h->icmp6_type = ICMP6_ECHO_REQUEST;
	icmp6h->icmp6_code = 0;
	icmp6h->icmp6_cksum = 0;
	icmp6h->icmp6_seq = htons(seq);
	icmp6h->icmp6_id = htons(ident);
	return sendto(fd6, outpacket6, len, 0, sa,
	    sizeof(struct sockaddr_in6));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movslq 0x36b6(%rip), %rax      # 0x91f0
addq $0x8, %rax
movl %eax, -0x1c(%rbp)
leaq 0x13738(%rip), %rax     # 0x19280
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $-0x80, (%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x18(%rbp), %rax
movw $0x0, 0x2(%rax)
movzwl -0xa(%rbp), %edi
callq 0x2050
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x6(%rax)
movl 0x36f9(%rip), %eax      # 0x9278
movzwl %ax, %edi
callq 0x2050
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x4(%rax)
leaq 0x36af(%rip), %rax      # 0x9248
movl (%rax), %edi
movslq -0x1c(%rbp), %rdx
movq -0x8(%rbp), %r8
leaq 0x136d6(%rip), %rsi     # 0x19280
xorl %ecx, %ecx
movl $0x1c, %r9d
callq 0x2060
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/icmp.c
// Function: write_packet4
static int
write_packet4(struct sockaddr *sa, unsigned short seq)
{
	struct icmp *icp;
	int len;

	len = ICMP_MINLEN + datalen;
	icp = (struct icmp *)outpacket;
	icp->icmp_type = ICMP_ECHO;
	icp->icmp_code = 0;
	icp->icmp_cksum = 0;
	icp->icmp_seq = htons(seq);
	icp->icmp_id = htons(ident);
	icp->icmp_cksum = in_cksum((u_short *)icp, len);

	return sendto(fd4, outpacket, len, 0, sa,
	    sizeof(struct sockaddr_in));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl 0x3617(%rip), %eax      # 0x91f0
addl $0x8, %eax
movl %eax, -0x1c(%rbp)
leaq 0x369a(%rip), %rax      # 0x9280
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x8, (%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x18(%rbp), %rax
movw $0x0, 0x2(%rax)
movzwl -0xa(%rbp), %edi
callq 0x2050
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x6(%rax)
movl 0x365b(%rip), %eax      # 0x9278
movzwl %ax, %edi
callq 0x2050
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x4(%rax)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x5d00
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x2(%rax)
leaq 0x35f2(%rip), %rax      # 0x9240
movl (%rax), %edi
movslq -0x1c(%rbp), %rdx
movq -0x8(%rbp), %r8
leaq 0x3621(%rip), %rsi      # 0x9280
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x2060
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/icmp.c
// Function: find_marktarget
static void
find_marktarget(int af, void *address, int seq, int ch)
{
	struct probe *prb;
	int npkts;

	prb = find(af, address);
	if (prb == NULL)
		return; /* unknown source address */
	npkts = prb->last_seq;
	if ((npkts & 0xffff) < seq)
	    npkts -= 1<<16;
	target_mark(prb->owner, (npkts & ~0xffff) | seq, ch);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x4b60
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5cae
jmp 0x5cef
movq -0x20(%rbp), %rax
movl 0x68(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
cmpl -0x14(%rbp), %eax
jge 0x5cd0
movl -0x24(%rbp), %eax
subl $0x10000, %eax          # imm = 0x10000
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0xb0(%rax), %rdi
movl -0x24(%rbp), %esi
andl $0xffff0000, %esi       # imm = 0xFFFF0000
orl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x24c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/icmp.c
// Function: in_cksum
static u_short
in_cksum(u_short *addr, int len)
{
	int nleft, sum;
	u_short *w;
	union {
		u_short us;
		u_char  uc[2];
	} last;
	u_short answer;

	nleft = len;
	sum = 0;
	w = addr;

	/*
	 * Our algorithm is simple, using a 32 bit accumulator (sum), we add
	 * sequential 16 bit words to it, and at the end, fold back all the
	 * carry bits from the top 16 bits into the lower 16 bits.
	 */
	while (nleft > 1)  {
		sum += *w++;
		nleft -= 2;
	}

	/* mop up an odd byte, if necessary */
	if (nleft == 1) {
		last.uc[0] = *(u_char *)w;
		last.uc[1] = 0;
		sum += last.us;
	}

	/* add back carry outs from top 16 bits to low 16 bits */
	sum = (sum >> 16) + (sum & 0xffff);     /* add hi 16 to low 16 */
	sum += (sum >> 16);                     /* add carry */
	answer = ~sum;                          /* truncate to 16 bits */
	return(answer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x10(%rbp)
jle 0x5d49
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x2, %rcx
movq %rcx, -0x20(%rbp)
movzwl (%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x10(%rbp)
jmp 0x5d20
cmpl $0x1, -0x10(%rbp)
jne 0x5d66
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x22(%rbp)
movb $0x0, -0x21(%rbp)
movzwl -0x22(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
sarl $0x10, %eax
movl -0x14(%rbp), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
sarl $0x10, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
xorl $-0x1, %eax
movw %ax, -0x24(%rbp)
movw -0x24(%rbp), %ax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x9901
movq -0x10(%rsp), %rax
movq 0x128(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x99fe
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x992c
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x99fe
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jge 0x995c
jmp 0x994c
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0x9936
movq -0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x9984
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x99fe
jmp 0x9986
movq -0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0x99ed
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rsp)
cmpq $0x0, -0x30(%rsp)
je 0x99db
movq -0x30(%rsp), %rax
movq 0x8(%rax), %rax
cmpq -0x20(%rsp), %rax
jne 0x99c9
movq -0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x99fe
jmp 0x99cb
movq -0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rsp)
jmp 0x99a1
jmp 0x99dd
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0x9986
movq -0x10(%rsp), %rax
movq 0x128(%rax), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0x9a36
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x9acd
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
movl %eax, -0x1c(%rsp)
subl $0x14, %eax
je 0x9a72
jmp 0x9a49
movl -0x1c(%rsp), %eax
subl $0x21, %eax
je 0x9a82
jmp 0x9a54
movl -0x1c(%rsp), %eax
addl $-0x28, %eax
subl $0x5, %eax
ja 0x9abc
jmp 0x9a62
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x9acd
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x9acd
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0x9aba
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x150(%rcx), %rax
je 0x9aba
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x9acd
jmp 0x9abc
movq -0x10(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x108(%rax)
jge 0x9cd7
movq 0x10(%rsp), %rdi
callq 0x9d30
movq 0x10(%rsp), %rax
movq 0xe8(%rax), %rax
movq 0x10(%rsp), %rdx
movq 0x108(%rdx), %rcx
movq %rcx, %rsi
addq $-0x1, %rsi
movq %rsi, 0x108(%rdx)
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0xd0(%rax), %rax
movq 0x10(%rax), %rax
movq (%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: resize_gc_protect
static void resize_gc_protect(s7_scheme *sc)
    {
        s7_int i, size, new_size;
        block_t *ob, *nb;
        size = sc->protected_objects_size;
        new_size = 2 * size;
        ob = vector_block(sc->protected_objects);
        nb = reallocate(sc, ob, new_size * sizeof(s7_pointer));
        block_info(nb) = NULL;
        vector_block(sc->protected_objects) = nb;
        vector_elements(sc->protected_objects) = (s7_pointer *)block_data(nb);
        vector_length(sc->protected_objects) = new_size;
        sc->protected_objects_size = new_size;
        sc->gpofl = (s7_int *)realloc(sc->gpofl, new_size * sizeof(s7_int));
        for (i = size; i < new_size; i++)
        {
            vector_element(sc->protected_objects, i) = sc->unused;
            sc->gpofl[++sc->gpofl_loc] = i;
        }
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
shlq %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0xd0(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
shlq $0x3, %rdx
callq 0xbb60
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
movq 0xd0(%rax), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x30(%rsp), %rax
movq 0xd0(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
movq 0xd0(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0xf0(%rax)
movq 0x30(%rsp), %rax
movq 0xe8(%rax), %rdi
movq 0x18(%rsp), %rsi
shlq $0x3, %rsi
callq 0x9510
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0xe8(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x18(%rsp), %rax
jge 0x9e8d
movq 0x30(%rsp), %rax
movq 0x140(%rax), %rdx
movq 0x30(%rsp), %rax
movq 0xd0(%rax), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rax
movq 0xe8(%rax), %rax
movq 0x30(%rsp), %rsi
movq 0x108(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x108(%rsi)
movq %rdx, 0x8(%rax,%rcx,8)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x9e1c
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0xf0(%rcx), %rax
jge 0x9f56
movq -0x8(%rsp), %rax
movq 0xd0(%rax), %rax
movq 0x10(%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x10(%rsp), %rax
jne 0x9f41
movq -0x8(%rsp), %rax
movq 0x140(%rax), %rdx
movq -0x8(%rsp), %rax
movq 0xd0(%rax), %rax
movq 0x10(%rax), %rax
movq -0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rsp), %rdx
movq -0x8(%rsp), %rax
movq 0xe8(%rax), %rax
movq -0x8(%rsp), %rsi
movq 0x108(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x108(%rsi)
movq %rdx, 0x8(%rax,%rcx,8)
jmp 0x9f56
jmp 0x9f43
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x9eb3
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0xf0(%rcx), %rax
jge 0x9ff9
movq -0x8(%rsp), %rax
movq 0xd0(%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rsp), %rcx
cmpq 0x140(%rcx), %rax
je 0x9fd4
movq -0x10(%rsp), %rdx
movq -0x8(%rsp), %rax
movq 0xe8(%rax), %rax
movq -0x8(%rsp), %rsi
movq 0x108(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x108(%rsi)
movq %rdx, 0x8(%rax,%rcx,8)
movq -0x8(%rsp), %rax
movq 0x140(%rax), %rdx
movq -0x8(%rsp), %rax
movq 0xd0(%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x130(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0xf0(%rcx), %rax
jge 0xa04c
movq -0x10(%rsp), %rax
movq 0xd0(%rax), %rax
movq 0x10(%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x140(%rcx), %rax
jne 0xa072
movq -0x10(%rsp), %rax
movq 0x130(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0xa07c
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_symbol_with_length
static inline s7_pointer make_symbol_with_length(s7_scheme *sc, const char *name, s7_int len)
    {
        s7_pointer x;
        uint64_t hash;
        uint32_t location;

        hash = raw_string_hash((const uint8_t *)name, len);
        location = hash % SYMBOL_TABLE_SIZE;

        if (len <= 8)
        {
            for (x = vector_element(sc->symbol_table, location); is_pair(x); x = cdr(x))
                if ((hash == pair_raw_hash(x)) &&
                        (len == pair_raw_len(x)))
                    return(car(x));
        }
        else
        {
            for (x = vector_element(sc->symbol_table, location); is_pair(x); x = cdr(x))
                if ((hash == pair_raw_hash(x)) &&
                        (len == pair_raw_len(x)) &&
                        (strings_are_equal_with_length(name, pair_raw_name(x), len))) /* length here because name might not be null-terminated */
                    return(car(x));
        }
        return(new_symbol(sc, name, len, hash, location));
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xa540
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x7fed, %ecx           # imm = 0x7FED
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0x4(%rsp)
cmpq $0x8, 0x18(%rsp)
jg 0xa36a
movq 0x28(%rsp), %rax
movq 0x148(%rax), %rax
movq 0x10(%rax), %rax
movl 0x4(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xa365
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jne 0xa353
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movl 0x2c(%rcx), %ecx
cmpq %rcx, %rax
jne 0xa353
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0xa41b
jmp 0xa355
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xa311
jmp 0xa3f8
movq 0x28(%rsp), %rax
movq 0x148(%rax), %rax
movq 0x10(%rax), %rax
movl 0x4(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xa3f6
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jne 0xa3e4
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movl 0x2c(%rcx), %ecx
cmpq %rcx, %rax
jne 0xa3e4
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rsi
movq 0x18(%rsp), %rdx
callq 0xc08f0
testb $0x1, %al
jne 0xa3d4
jmp 0xa3e4
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0xa41b
jmp 0xa3e6
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xa387
jmp 0xa3f8
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rcx
movl 0x4(%rsp), %r8d
callq 0xaec0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: safe_strlen
static inline s7_int safe_strlen(const char *str)
    {
        /* this is safer than strlen, and slightly faster */
        const char *tmp = str;
        if ((!tmp) || (!(*tmp))) return(0);
        for (; *tmp; ++tmp);
        return(tmp - str);
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0xa451
movq -0x18(%rsp), %rax
cmpb $0x0, (%rax)
jne 0xa45c
movq $0x0, -0x8(%rsp)
jmp 0xa48c
jmp 0xa45e
movq -0x18(%rsp), %rax
cmpb $0x0, (%rax)
je 0xa47a
jmp 0xa46a
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0xa45e
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0xa430
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xa540
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl $0x7fed, %ecx           # imm = 0x7FED
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ecx
callq 0xa620
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0xa522
movq $0x0, 0x30(%rsp)
jmp 0xa52c
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: raw_string_hash
static inline uint64_t raw_string_hash(const uint8_t *key, s7_int len)
    {
        uint64_t x;
        uint8_t *cx = (uint8_t *)&x;
        x = 0;
        if (len <= 8)
            memcpy((void *)cx, (void *)key, len);
        else
        {
            uint64_t y;
            uint8_t *cy = (uint8_t *)&y;
            memcpy((void *)cx, (void *)key, 8);
            y = 0;
            len -= 8;
            memcpy((void *)cy, (void *)(key + 8), (len > 8) ? 8 : len);
            x += y;  /* better than |= but still not great if (for example) > 1B gensyms -- maybe add z? */
        }
        return(x);
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
cmpq $0x8, 0x38(%rsp)
jg 0xa582
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x93e0
jmp 0xa609
leaq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x40(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq $0x0, 0x20(%rsp)
movq 0x38(%rsp), %rax
subq $0x8, %rax
movq %rax, 0x38(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
cmpq $0x8, 0x38(%rsp)
jle 0xa5de
movl $0x8, %eax
movq %rax, (%rsp)
jmp 0xa5e7
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
callq 0x93e0
movq 0x20(%rsp), %rax
addq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: symbol_table_find_by_name
static s7_pointer symbol_table_find_by_name(s7_scheme *sc, const char *name, uint64_t hash, uint32_t location)
    {
        s7_pointer x;
        for (x = vector_element(sc->symbol_table, location); is_not_null(x); x = cdr(x))
            if ((hash == pair_raw_hash(x)) &&
                    (strings_are_equal(name, pair_raw_name(x))))
                return(car(x));
        return(sc->nil);
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x28(%rsp), %rax
movq 0x148(%rax), %rax
movq 0x10(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0xa6b2
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jne 0xa6a0
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0xc0a00
testb $0x1, %al
jne 0xa690
jmp 0xa6a0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0xa6c3
jmp 0xa6a2
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xa654
movq 0x28(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)