LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/dxwc[P]sfeed/sfeed_atom.c
// Function: main
int
main(int argc, char *argv[])
{
	FILE *fp;
	char *name;
	int i;

	if (argc == 1) {
		if (pledge("stdio", NULL) == -1)
			err(1, "pledge");
	} else {
		if (pledge("stdio rpath", NULL) == -1)
			err(1, "pledge");
	}

	fputs("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
	      "<feed xmlns=\"http://www.w3.org/2005/Atom\" xml:lang=\"en\">\n",
	      stdout);

	if (argc == 1) {
		printfeed(stdin, "");
	} else {
		for (i = 1; i < argc; i++) {
			if (!(fp = fopen(argv[i], "r")))
				err(1, "fopen: %s", argv[i]);
			name = ((name = strrchr(argv[i], '/'))) ? name + 1 : argv[i];
			printfeed(fp, name);
			if (ferror(fp))
				err(1, "ferror: %s", argv[i]);
			fclose(fp);
		}
	}

	fputs("</feed>\n", stdout);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movq 0x2ce5(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
leaq 0xd07(%rip), %rdi       # 0x2004
callq 0x10d0
cmpl $0x1, %ebp
jne 0x131f
movq 0x2cd2(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0xd4c(%rip), %rsi       # 0x2064
callq 0x13d3
jmp 0x1384
jle 0x1384
movl %ebp, %ebp
movl $0x1, %r13d
leaq 0xd35(%rip), %r14       # 0x2065
movq (%rbx,%r13,8), %rdi
movq %r14, %rsi
callq 0x1190
movq (%rbx,%r13,8), %r12
testq %rax, %rax
je 0x13ab
movq %rax, %r15
movq %r12, %rdi
movl $0x2f, %esi
callq 0x10c0
leaq 0x1(%rax), %rsi
testq %rax, %rax
cmoveq %r12, %rsi
movq %r15, %rdi
callq 0x13d3
movq %r15, %rdi
callq 0x1070
testl %eax, %eax
jne 0x13bc
movq %r15, %rdi
callq 0x1080
incq %r13
cmpq %r13, %rbp
jne 0x1330
movq 0x2c4d(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
leaq 0xce7(%rip), %rdi       # 0x207c
callq 0x10d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcb5(%rip), %rsi       # 0x2067
movl $0x1, %edi
movq %r12, %rdx
jmp 0x13cc
movq (%rbx,%r13,8), %rdx
leaq 0xcaa(%rip), %rsi       # 0x2071
movl $0x1, %edi
xorl %eax, %eax
callq 0x1180
// File: /workspace/github_c_makefile_star2_O1/begriffs[P]pthread-test/trylock.c
// Function: counter_thread
void *counter_thread(void *arg)
{
	int spin;

	(void)arg;

	while (time(NULL) < end_time)
	{
		pthread_mutex_lock(&mutex);
		for (spin = 0; spin < SPIN; spin++)
			counter++;
		pthread_mutex_unlock(&mutex);
		sleep(1);
	}
	return NULL;
}

// Assembly:
pushq %rbx
xorl %edi, %edi
callq 0x1060
cmpq 0x2ed5(%rip), %rax      # 0x40a0
jge 0x1209
leaq 0x2ea4(%rip), %rbx      # 0x4078
movq %rbx, %rdi
callq 0x10b0
addq $0x989680, 0x2ec1(%rip) # imm = 0x989680
movq %rbx, %rdi
callq 0x1070
movl $0x1, %edi
callq 0x10a0
xorl %edi, %edi
callq 0x1060
cmpq 0x2e99(%rip), %rax      # 0x40a0
jl 0x11d4
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/begriffs[P]pthread-test/trylock.c
// Function: monitor_thread
void *monitor_thread(void *arg)
{
	int status;

	(void)arg;

	while (time(NULL) < end_time)
	{
		sleep(3);
		status = pthread_mutex_trylock(&mutex);
		if (status != EBUSY)
		{
			printf("Counter is %ld\n", counter/SPIN);
			pthread_mutex_unlock(&mutex);
		}
		else
			puts("(missed)");
	}
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %edi, %edi
callq 0x1060
cmpq 0x2e7d(%rip), %rax      # 0x40a0
jge 0x12a9
leaq 0x2e48(%rip), %rbx      # 0x4078
leaq 0xddd(%rip), %r14       # 0x2014
movabsq $-0x29406b2a1a85bd43, %r12 # imm = 0xD6BF94D5E57A42BD
leaq 0xdbc(%rip), %r15       # 0x2004
movl $0x3, %edi
callq 0x10a0
movq %rbx, %rdi
callq 0x1050
cmpl $0x10, %eax
jne 0x1269
movq %r14, %rdi
callq 0x1030
jmp 0x1299
movq 0x2e38(%rip), %rsi      # 0x40a8
movq %rsi, %rax
imulq %r12
addq %rdx, %rsi
movq %rsi, %rax
shrq $0x3f, %rax
sarq $0x17, %rsi
addq %rax, %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x1070
xorl %edi, %edi
callq 0x1060
cmpq 0x2df9(%rip), %rax      # 0x40a0
jl 0x1248
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/begriffs[P]pthread-test/trylock.c
// Function: main
int main(void)
{
	pthread_t counter_thread_id, monitor_thread_id;

	end_time = time(NULL) + 60;
	pthread_create(&counter_thread_id, NULL, counter_thread, NULL);
	pthread_create(&monitor_thread_id, NULL, monitor_thread, NULL);

	pthread_join(counter_thread_id, NULL);
	pthread_join(monitor_thread_id, NULL);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
xorl %edi, %edi
callq 0x1060
addq $0x3c, %rax
movq %rax, 0x2dd0(%rip)      # 0x40a0
leaq -0x11b(%rip), %rdx      # 0x11bc
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1080
leaq -0xe2(%rip), %rdx       # 0x120d
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1080
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x1090
movq (%r14), %rdi
xorl %esi, %esi
callq 0x1090
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/vanhauser-thc[P]vulntest/bof.c
// Function: main
int main(int argc, char *argv[]) {
  FILE *f;
  char line[64], *data;
  int size;

  if (argc < 3)
    return -1;

  if ((f = fopen(argv[1], "r")) == NULL)
    return -1;

  if (fgets(line, sizeof(line), f) == NULL)
    return -1;

  size = atoi(line);

  if ((data = malloc(size)) == NULL)
    return -1;

  fread(data, 1, 1024, f);
  data[1023] = 0;

  printf("Data: %s\n", data);

  fclose(f);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x3, %edi
jl 0x122c
movq 0x8(%rsi), %rdi
leaq 0xe4a(%rip), %rsi       # 0x2004
callq 0x1080
testq %rax, %rax
je 0x122c
movq %rax, %r14
movq %rsp, %rdi
movl $0x40, %esi
movq %rax, %rdx
callq 0x1060
testq %rax, %rax
je 0x122c
movq %rsp, %rdi
callq 0x1090
movslq %eax, %rdi
callq 0x1070
testq %rax, %rax
je 0x122c
movq %rax, %r15
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
movq %rax, %rdi
movq %r14, %rcx
callq 0x1030
movb $0x0, 0x3ff(%r15)
leaq 0xdee(%rip), %rdi       # 0x2006
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0x1050
movq %r14, %rdi
callq 0x1040
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/marcespie[P]unix-samples/chapter1/fork3.c
// Function: main
int
main()
{

	for (int i = 15; i < 35; i += 2) {
		int pid = fork();
		switch(pid) {
		case -1: 
			err(1, "fork");
		case 0:
			perform_computation(i);
			exit(0);
		}
	}

	// parent
	int rc = 0; // by default we succeed

	// XXX don't do that! this is example code.
	// Here we catch all children, remember that wait is a
	// "destructive" call, it gives you the status of one
	// deceased child, and removes all traces from the system.
	// If you have *other* children in other parts of your code
	// using wait means you *will* get any child that's dead.
	// (there's zero guarantee that you get the deceased in
	// any order at all).

	// there are several solutions
	// - have a central hub where you register all your children
	// and somehow demultiplex any status to the correct part of
	// the code (algorithmic)
	// - use waitpid NOHANG on each child you want (doesn't scale
	// with more than a few processes
	// - put processes into their own groups and use a pgrp
	int status, r;
	while ((r = wait(&status)) != -1)
		if (bad_status(status))
			rc = 1;
	// this normally exits with ECHILD, when we reaped every child
	if (errno != ECHILD)
		err(1, "wait");

	exit(rc);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0xf, %ebx
callq 0x10a0
testl %eax, %eax
je 0x12b6
cmpl $-0x1, %eax
je 0x12c4
leal 0x2(%rbx), %eax
cmpl $0x21, %ebx
movl %eax, %ebx
jb 0x1255
leaq 0xc(%rsp), %rdi
callq 0x1090
xorl %ebx, %ebx
cmpl $-0x1, %eax
je 0x12a5
xorl %ebx, %ebx
movl $0x1, %ebp
leaq 0xc(%rsp), %r14
movl 0xc(%rsp), %edi
callq 0x11c4
testb %al, %al
cmovnel %ebp, %ebx
movq %r14, %rdi
callq 0x1090
cmpl $-0x1, %eax
jne 0x128a
callq 0x1030
cmpl $0xa, (%rax)
jne 0x12cd
movl %ebx, %edi
callq 0x1080
movl %ebx, %edi
callq 0x11ac
xorl %edi, %edi
callq 0x1080
leaq 0xda9(%rip), %rsi       # 0x2074
jmp 0x12d4
leaq 0xda5(%rip), %rsi       # 0x2079
movl $0x1, %edi
xorl %eax, %eax
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/lacework-dev[P]strace_lab_PUBLIC/./src/example_2.c
// Function: main
int main(int argc, char *argv[])
{
	
	char password[] = "secret123\n";

	for (int i = 0; i < 7; i+=1) {
		fork();

		char fout[10];
		strcpy(fout, &password[i]);

		char *fname = (char *)malloc(100);
		srand(31337);
		sprintf(fname, "/tmp/%d.log", ( getpid() ^ rand()));

		FILE *fd = fopen(fname, "a+");
		fputs(fout, fd);

		free(fname);
		fclose(fd);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq -0x32(%rbp), %rbx
leaq 0xe23(%rip), %r15       # 0x201b
xorl %r14d, %r14d
callq 0x10c0
leaq 0xdfd(%rip), %rax       # 0x2004
leaq (%rax,%r14), %rsi
movq %rbx, %rdi
callq 0x1040
movl $0x64, %edi
callq 0x1090
movq %rax, %r12
movl $0x7a69, %edi           # imm = 0x7A69
callq 0x1080
callq 0x1050
movl %eax, %r13d
callq 0x10d0
xorl %eax, %r13d
movq %r12, %rdi
leaq 0xdcb(%rip), %rsi       # 0x200f
movl %r13d, %edx
xorl %eax, %eax
callq 0x10b0
movq %r12, %rdi
movq %r15, %rsi
callq 0x10a0
movq %rax, %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1070
movq %r12, %rdi
callq 0x1030
movq %r13, %rdi
callq 0x1060
incq %r14
cmpq $0x7, %r14
jne 0x11fb
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ramirezsebas[P]TP-LISTINGS/./src/capitulo_5/5.7/pipe.c
// Function: writer
void writer(const char *message, int count, FILE *stream)
{
    for (; count > 0; --count)
    {
        /* Write the message to the stream, and send it off immediately.  */
        fprintf(stream, "%s\n", message);
        fflush(stream);
        /* Snooze a while. */
        sleep(1);
    }
}

// Assembly:
testl %esi, %esi
jle 0x1231
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
incl %r14d
leaq 0xe06(%rip), %r12       # 0x2004
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1080
movq %rbx, %rdi
callq 0x10a0
movl $0x1, %edi
callq 0x10c0
decl %r14d
cmpl $0x1, %r14d
jg 0x11fe
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ramirezsebas[P]TP-LISTINGS/./src/capitulo_5/5.7/pipe.c
// Function: reader
void reader(FILE *stream)
{
    char buffer[1024];
    /*Read until we hit the end of the stream. fgets reads until
  either a newline or the end-of-file.*/

    while (!feof(stream) && !ferror(stream) && fgets(buffer, sizeof(buffer), stream) != NULL)
        fputs(buffer, stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
callq 0x1090
testl %eax, %eax
je 0x125c
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x420(%rbp), %r14
movq 0x2d76(%rip), %r15      # 0x3fe0
movq %rbx, %rdi
callq 0x1030
testl %eax, %eax
jne 0x124e
movq %r14, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x1070
testq %rax, %rax
je 0x124e
movq (%r15), %rsi
movq %r14, %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1090
testl %eax, %eax
je 0x126a
jmp 0x124e
// File: /workspace/github_c_makefile_star2_O1/YanjieZe[P]CacheLab/test-trans.c
// Function: usage
void usage(char *argv[]){
    printf("Usage: %s [-h] -M <rows> -N <cols>\n", argv[0]);
    printf("Options:\n");
    printf("  -h          Print this help message.\n");
    printf("  -M <rows>   Number of matrix rows (max %d)\n", MAXN);
    printf("  -N <cols>   Number of  matrix columns (max %d)\n", MAXN);
    printf("Example: %s -M 8 -N 8\n", argv[0]);       
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0x4bae(%rip), %rdi      # 0x628c
xorl %eax, %eax
callq 0x1070
leaq 0x4d1c(%rip), %rdi      # 0x6408
callq 0x1040
leaq 0x4d19(%rip), %rdi      # 0x6411
callq 0x1040
leaq 0x4bac(%rip), %rdi      # 0x62b0
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
callq 0x1070
leaq 0x4bc7(%rip), %rdi      # 0x62de
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
callq 0x1070
movq (%rbx), %rsi
leaq 0x4be3(%rip), %rdi      # 0x6310
xorl %eax, %eax
popq %rbx
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/YanjieZe[P]CacheLab/test-trans.c
// Function: sigsegv_handler
void sigsegv_handler(int signum){
    printf("Error: Segmentation Fault.\n");
    printf("TEST_TRANS_RESULTS=0:0\n");
    fflush(stdout);
    exit(1);
}

// Assembly:
pushq %rax
leaq 0x4cfb(%rip), %rdi      # 0x6438
callq 0x1040
leaq 0x4d60(%rip), %rdi      # 0x64a9
callq 0x1040
movq 0x687b(%rip), %rax      # 0x7fd0
movq (%rax), %rdi
callq 0x1110
movl $0x1, %edi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O1/YanjieZe[P]CacheLab/test-trans.c
// Function: sigalrm_handler
void sigalrm_handler(int signum){
    printf("Error: Program timed out.\n");
    printf("TEST_TRANS_RESULTS=0:0\n");
    fflush(stdout);
    exit(1);
}

// Assembly:
pushq %rax
leaq 0x4ce4(%rip), %rdi      # 0x6453
callq 0x1040
leaq 0x4d2e(%rip), %rdi      # 0x64a9
callq 0x1040
movq 0x6849(%rip), %rax      # 0x7fd0
movq (%rax), %rdi
callq 0x1110
movl $0x1, %edi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O1/icarroll[P]clunk/playthud.c
// Function: main
int main(int numargs, char * args[])
{
    struct thudboard * board = & board_data;
    struct move * move = & move_data;

    int memuse = 1024 * 1024 * (numargs > 1 ? strtol(args[1], NULL, 10)
                                            : sizeof(struct tableentry));

    setupgame(board, memuse);

    int c = toupper(getchar());

    if (getchar() != '\n') exit(EXIT_FAILURE);

    if (c == 'T') goto troll;
    else if (c != 'D') exit(EXIT_FAILURE);

    while (true)
    {
        * move = iterdeepen(board, SEARCHSECS);
        showmove(move);
        domoveupdatecapts(board, move);

troll:
        * move = getmove();
        if (! legalmove(board, move)) exit(EXIT_FAILURE);
        domoveupdatecapts(board, move);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rax
movl $0x2000000, %esi        # imm = 0x2000000
cmpl $0x2, %edi
jl 0x1348
movq 0x8(%rax), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x1110
movq %rax, %rsi
shll $0x14, %esi
leaq 0x6e99(%rip), %rdi      # 0x81e8
callq 0x1570
callq 0x1130
movl %eax, %edi
callq 0x1070
movl %eax, %ebx
callq 0x1130
cmpl $0xa, %eax
jne 0x1376
cmpl $0x44, %ebx
je 0x1380
cmpl $0x54, %ebx
je 0x13c3
movl $0x1, %edi
callq 0x1080
leaq 0x6e61(%rip), %rbx      # 0x81e8
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1e, %edx
callq 0x1835
leaq 0x6ec5(%rip), %r15      # 0x8268
movl $0x16, %ecx
movq %r15, %rdi
movq %r14, %rsi
rep  movsl (%rsi), %es:(%rdi)
movq %r15, %rdi
callq 0x390d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3770
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1413
leaq 0x6e91(%rip), %rax      # 0x8268
movl $0x16, %ecx
movq %rax, %rdi
movq %rbx, %rsi
rep  movsl (%rsi), %es:(%rdi)
leaq 0x6dfd(%rip), %rdi      # 0x81e8
movq %rax, %rsi
callq 0x3360
testb %al, %al
je 0x1376
leaq 0x6de6(%rip), %rdi      # 0x81e8
leaq 0x6e5f(%rip), %rsi      # 0x8268
callq 0x3770
jmp 0x1380
// File: /workspace/github_c_makefile_star2_O1/icarroll[P]clunk/playthud.c
// Function: getmove
struct move getmove(void)
{
    struct move move;

    char * line = NULL;
    size_t size = 0;
    int _ = getline(& line, & size, stdin);

    char * cur = line;

    skipspace(& cur);
    if (toupper(* cur) == 'D') move.isdwarfmove = true;
    else if (toupper(* cur) == 'T') move.isdwarfmove = false;
    else exit(EXIT_FAILURE);
    cur += 1;

    bool valid;

    skipspace(& cur);
    valid = getpos(& cur, & move.from);
    if (! valid) exit(EXIT_FAILURE);

    skipspace(& cur);
    if (* cur++ != '-') exit(EXIT_FAILURE);

    skipspace(& cur);
    valid = getpos(& cur, & move.to);
    if (! valid) exit(EXIT_FAILURE);

    move.numcapts = 0;
    while (move.numcapts <= NUMDIRS)
    {
        skipspace(& cur);
        if (* cur == '\0' || * cur == '\n') break;

        skipspace(& cur);
        if (toupper(* cur++) != 'X') exit(EXIT_FAILURE);

        skipspace(& cur);
        valid = getpos(& cur, & move.capts[move.numcapts++]);
        if (! valid) exit(EXIT_FAILURE);
    }

    free(line);
    return move;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq 0x6ba6(%rip), %rax      # 0x7fe0
movq (%rax), %rdx
movq %r14, %rdi
callq 0x1150
movq (%r14), %rax
movq %rsp, %r15
movq %rax, (%r15)
movq %r15, %rdi
callq 0x37ad
callq 0x10d0
movq %rax, %r14
movq (%rax), %rcx
movq (%r15), %rax
movsbq (%rax), %rdx
movl (%rcx,%rdx,4), %edx
movb $0x1, %cl
cmpl $0x44, %edx
je 0x147d
cmpl $0x54, %edx
jne 0x154c
xorl %ecx, %ecx
movb %cl, (%rbx)
incq %rax
movq %rsp, %r15
movq %rax, (%r15)
movq %r15, %rdi
callq 0x37ad
leaq 0x4(%rbx), %rsi
movq %r15, %rdi
callq 0x3806
testb %al, %al
je 0x154c
movq %rsp, %r15
movq %r15, %rdi
callq 0x37ad
movq (%r15), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%r15)
cmpb $0x2d, (%rax)
jne 0x154c
movq %rsp, %r15
movq %r15, %rdi
callq 0x37ad
leaq 0xc(%rbx), %rsi
movq %r15, %rdi
callq 0x3806
testb %al, %al
je 0x154c
movl $0x0, 0x14(%rbx)
leaq 0x18(%rbx), %r12
movq %rsp, %r15
cmpl $0x8, 0x14(%rbx)
jg 0x1556
movq %r15, %rdi
callq 0x37ad
movq (%rsp), %rax
movzbl (%rax), %eax
testl %eax, %eax
je 0x1556
cmpl $0xa, %eax
je 0x1556
movq %r15, %rdi
callq 0x37ad
movq (%r14), %rax
movq (%rsp), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rsp)
movsbq (%rcx), %rcx
cmpl $0x58, (%rax,%rcx,4)
jne 0x154c
movq %r15, %rdi
callq 0x37ad
movslq 0x14(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x14(%rbx)
leaq (%r12,%rax,8), %rsi
movq %r15, %rdi
callq 0x3806
testb %al, %al
jne 0x14eb
movl $0x1, %edi
callq 0x1080
movq 0x8(%rsp), %rdi
callq 0x10f0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/fm4dd[P]learn-ssl/certverify-adv.c
// Function: X509_load_ca_file
STACK_OF(X509_INFO) *X509_load_ca_file(int *cert_count, 
                                       struct stat fstat, const char *file) {
  STACK_OF(X509_INFO) *st = NULL;
  BIO *inbio=NULL;

  /* complain if we got an empty filename */
  if (file == NULL)
    BIO_printf(outbio, "Error receiving a valid CA bundle file name.\n");

  /* get file status data */
  if (stat(file, &fstat) != 0) {
    BIO_printf(outbio, "Error cannot stat cert bundle file: %s.\n", file);
    exit(1);
  }

  /* complain if the file is empty (0 bytes) */
  if(fstat.st_size == 0)
    BIO_printf(outbio, "Error cert bundle file size is zero bytes.\n");

  inbio=BIO_new(BIO_s_file());

  /* check if we can open the file for reading */
  if ((inbio == NULL) || (BIO_read_filename(inbio, file) <= 0))
    BIO_printf(outbio, "Error loading cert bundle file into memory.\n");

  /* read all certificates from file */
  if (! (st = PEM_X509_INFO_read_bio(inbio, NULL, NULL, NULL)))
    BIO_printf(outbio, "Error reading certs from BIO.\n");

  /* get the number of certs that are now on the stack */
  *cert_count = sk_X509_INFO_num(st);

  /* return the STACK_OF(X509_INFO) pointer, or exit */
  if (cert_count > 0) return st;
  else exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
testq %rsi, %rsi
jne 0x290c
movq 0x3dd2(%rip), %rdi      # 0x66d0
leaq 0x13ef(%rip), %rsi      # 0x3cf4
xorl %eax, %eax
callq 0x22b0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
testl %eax, %eax
jne 0x29bc
cmpq $0x0, 0x30(%r15)
jne 0x293b
movq 0x3da3(%rip), %rdi      # 0x66d0
leaq 0x1417(%rip), %rsi      # 0x3d4b
xorl %eax, %eax
callq 0x22b0
callq 0x2060
movq %rax, %rdi
callq 0x2260
movq %rax, %r15
testq %rax, %rax
je 0x2969
movl $0x3, %edx
movq %r15, %rdi
movl $0x6c, %esi
movq %r14, %rcx
callq 0x2050
testl %eax, %eax
jg 0x297e
movq 0x3d60(%rip), %rdi      # 0x66d0
leaq 0x1400(%rip), %rsi      # 0x3d77
xorl %eax, %eax
callq 0x22b0
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2070
movq %rax, %r14
testq %rax, %rax
jne 0x29a9
movq 0x3d35(%rip), %rdi      # 0x66d0
leaq 0x1402(%rip), %rsi      # 0x3da4
xorl %eax, %eax
callq 0x22b0
movq %r14, %rdi
callq 0x20a0
movl %eax, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x3d0d(%rip), %rdi      # 0x66d0
leaq 0x1358(%rip), %rsi      # 0x3d22
movq %r14, %rdx
xorl %eax, %eax
callq 0x22b0
movl $0x1, %edi
callq 0x21c0
// File: /workspace/github_c_makefile_star2_O1/fm4dd[P]learn-ssl/certverify-adv.c
// Function: verify_mem_store
X509_STORE_CTX  *verify_mem_store(STACK_OF(X509_INFO) *st) {
  X509_STORE         *store = NULL;
  X509_STORE_CTX       *ctx = NULL;
  //STACK_OF(X509)  *ca_stack = NULL;
  X509_INFO      *list_item = NULL;
  int cert_count            = 0;
  int i                     = 0;

  /* ---------------------------------------------------------- *
   * Initialize the global certificate validation store object. *
   * ---------------------------------------------------------- */
  if (!(store=X509_STORE_new()))
     BIO_printf(outbio, "Error creating X509_STORE_CTX object\n");

  /* ---------------------------------------------------------- *
   * Create the context structure for the validation operation. *
   * ---------------------------------------------------------- */
  ctx = X509_STORE_CTX_new();

  /* ---------------------------------------------------------- *
   * Get the number of certs on the stack                       *
   * ---------------------------------------------------------- */
  cert_count = sk_X509_INFO_num(st);

  /* ---------------------------------------------------------- *
   * Complain if there is no cert                               *
   * ---------------------------------------------------------- */
  if (! (cert_count > 0)) {
    BIO_printf(outbio, "Error no certs on stack.\n");
    exit(1);
  }

  /* ---------------------------------------------------------- *
   * Cycle through all info stack items, extract the X509 cert  *
   * and put it into the X509_STORE called store.               *
   * ---------------------------------------------------------- */
  for (i = 0; i < cert_count; i++) {
    list_item = sk_X509_INFO_value(st, i);
    X509_STORE_add_cert(store, list_item->x509);
  }

  /* ---------------------------------------------------------- *
   * Initialize the ctx structure for a verification operation: *
   * Set the trusted cert store, the unvalidated cert, and any  *
   * potential certs that could be needed (here we set it NULL) *
   * ---------------------------------------------------------- */
  X509_STORE_CTX_init(ctx, store, cert, NULL);

  return ctx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
callq 0x21b0
movq %rax, %rbx
testq %rax, %rax
jne 0x2a0b
movq 0x3cd3(%rip), %rdi      # 0x66d0
leaq 0x12a5(%rip), %rsi      # 0x3ca9
xorl %eax, %eax
callq 0x22b0
callq 0x2160
movq %rax, %r15
movq %r14, %rdi
callq 0x20a0
testl %eax, %eax
jle 0x2a62
movl %eax, %ebp
xorl %r12d, %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0x21e0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x20c0
incl %r12d
cmpl %r12d, %ebp
jne 0x2a24
movq 0x3c97(%rip), %rdx      # 0x66e0
movq %r15, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x20d0
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x3c67(%rip), %rdi      # 0x66d0
leaq 0x1353(%rip), %rsi      # 0x3dc3
xorl %eax, %eax
callq 0x22b0
movl $0x1, %edi
callq 0x21c0
// File: /workspace/github_c_makefile_star2_O1/fm4dd[P]learn-ssl/certverify-adv.c
// Function: verify_file_direct
X509_STORE_CTX  *verify_file_direct(const char *file) {
  X509_STORE         *store = NULL;
  X509_STORE_CTX  *vrfy_ctx = NULL;

  /* ---------------------------------------------------------- *
   * Initialize the global certificate validation store object. *
   * ---------------------------------------------------------- */
  if (!(store=X509_STORE_new()))
     BIO_printf(outbio, "Error creating X509_STORE_CTX object\n");

  /* ---------------------------------------------------------- *
   * Create the context structure for the validation operation. *
   * ---------------------------------------------------------- */
  vrfy_ctx = X509_STORE_CTX_new();

  /* ---------------------------------------------------------- *
   * Load the certificate and cacert chain from file (PEM).     *
   * ---------------------------------------------------------- */
  if ((X509_STORE_load_locations(store, file, NULL)) != 1)
    BIO_printf(outbio, "Error loading CA cert or chain file\n");

  /* ---------------------------------------------------------- *
   * Initialize the ctx structure for a verification operation: *
   * Set the trusted cert store, the unvalidated cert, and any  *
   * potential certs that could be needed (here we set it NULL) *
   * ---------------------------------------------------------- */
  X509_STORE_CTX_init(vrfy_ctx, store, cert, NULL);

  return vrfy_ctx; 
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
callq 0x21b0
movq %rax, %rbx
testq %rax, %rax
jne 0x2c30
movq 0x3aae(%rip), %rdi      # 0x66d0
leaq 0x1080(%rip), %rsi      # 0x3ca9
xorl %eax, %eax
callq 0x22b0
callq 0x2160
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x22a0
cmpl $0x1, %eax
je 0x2c5f
movq 0x3a7f(%rip), %rdi      # 0x66d0
leaq 0x1077(%rip), %rsi      # 0x3ccf
xorl %eax, %eax
callq 0x22b0
movq 0x3a7a(%rip), %rdx      # 0x66e0
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x20d0
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/antonblanchard[P]will-it-scale/tests/dup1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkstemp(tmpfile);

	assert(fd >= 0);
	unlink(tmpfile);

	while (1) {
		int fd2 = dup(fd);

		assert(fd2 >= 0);
		close(fd2);

		(*iterations)++;
	}

	close(fd);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movaps 0x6e4(%rip), %xmm0      # 0x32e0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movabsq $0x5858585858582e, %rax # imm = 0x5858585858582E
movq %rax, 0x10(%rdi)
callq 0x21e0
testl %eax, %eax
js 0x2c59
movl %eax, %ebp
movq %rsp, %rdi
callq 0x2080
movl %ebp, %edi
callq 0x2120
testl %eax, %eax
js 0x2c3a
movl %eax, %edi
callq 0x2150
incq (%rbx)
jmp 0x2c23
leaq 0x687(%rip), %rdi       # 0x32c8
leaq 0x640(%rip), %rsi       # 0x3288
leaq 0x646(%rip), %rcx       # 0x3295
movl $0x12, %edx
callq 0x2130
leaq 0x620(%rip), %rdi       # 0x3280
leaq 0x621(%rip), %rsi       # 0x3288
leaq 0x627(%rip), %rcx       # 0x3295
movl $0xc, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O1/eric-lo[P]3150/8-Synchronization/pthread_producer_consumer.c
// Function: producer
void *producer(void *nothing) {
	int item;
	unsigned int s;		// needed by thread-safe rand_r()

	while(1) {
		pthread_mutex_lock(&mutex);	// start of mutual exclusion.

			if(IS_FULL(head, tail, N))
				pthread_cond_wait(&full, &mutex);	// wait and unlock mutual exclusion.

			if(IS_EMPTY(head, tail, N))
				pthread_cond_signal(&empty);		// wake up the consumer.

			item = (rand_r(&s) % 26) + 'A';	// produce an item.
			buffer[tail] = item;		// insert an item.
			tail = NEXT_SLOT(tail, N);	// occupy one empty slot.
			drawing(PRODUCER_TURN, item);	// draw the change inside mutex.

		pthread_mutex_unlock(&mutex);	// end of mutual exclusion.

		if(rand_r(&s) % SLEEP_CHANCE == 0)
			sleep(1);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x2cd1(%rip), %rbx      # 0x40a0
leaq 0x2cf2(%rip), %r14      # 0x40c8
leaq 0x2d1b(%rip), %r15      # 0x40f8
leaq 0xc(%rsp), %r12
leaq 0x2d47(%rip), %r13      # 0x4130
movq %rbx, %rdi
callq 0x10f0
movl 0x2d35(%rip), %eax      # 0x412c
incl %eax
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
cmpl 0x2d0c(%rip), %eax      # 0x4128
jne 0x1429
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1030
movl 0x2cfd(%rip), %eax      # 0x412c
cmpl 0x2cf3(%rip), %eax      # 0x4128
jne 0x143f
movq %r15, %rdi
callq 0x1060
movq %r12, %rdi
callq 0x1040
cltq
imulq $0x4ec4ec4f, %rax, %rcx # imm = 0x4EC4EC4F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x23, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %edx
leal (%rdx,%rdx,4), %edx
addl %ecx, %edx
negl %edx
leal (%rax,%rdx), %esi
addl $0x41, %esi
movslq 0x2cb8(%rip), %rax      # 0x412c
movl %esi, (%r13,%rax,4)
incl %eax
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
movl %eax, 0x2c8e(%rip)      # 0x412c
xorl %edi, %edi
callq 0x11fc
movq %rbx, %rdi
callq 0x1090
movq %r12, %rdi
callq 0x1040
testb $0x3, %al
jne 0x13e9
movl $0x1, %edi
callq 0x10e0
jmp 0x13e9
// File: /workspace/github_c_makefile_star2_O1/eric-lo[P]3150/8-Synchronization/pthread_producer_consumer.c
// Function: consumer
void *consumer(void *nothing) {
	int item;
	unsigned int s;

	while(1) {
		pthread_mutex_lock(&mutex);	// start of mutual exclusion.

			if(IS_EMPTY(head, tail, N))
				pthread_cond_wait(&empty, &mutex);	// wait and unlock mutual exclusion.

			if(IS_FULL(head, tail, N))
				pthread_cond_signal(&full);		// wakeup the producer.

			item = buffer[head];		// consume an item.
			head = NEXT_SLOT(head, N);	// free one slot.
			drawing(CONSUMER_TURN, item);	// draw the change inside mutex.

		pthread_mutex_unlock(&mutex);	// end of mutual exclusion.

		if(rand_r(&s) % SLEEP_CHANCE == 0)
			sleep(1);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x2bc0(%rip), %rbx      # 0x40a0
leaq 0x2c11(%rip), %r14      # 0x40f8
leaq 0x2bda(%rip), %r15      # 0x40c8
leaq 0x2c3b(%rip), %r13      # 0x4130
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
callq 0x10f0
movl 0x2c24(%rip), %eax      # 0x412c
cmpl 0x2c1a(%rip), %eax      # 0x4128
jne 0x151b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1030
movl 0x2c0b(%rip), %eax      # 0x412c
incl %eax
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
cmpl 0x2be2(%rip), %eax      # 0x4128
jne 0x1550
movq %r15, %rdi
callq 0x1060
movslq 0x2bd1(%rip), %rax      # 0x4128
movl (%r13,%rax,4), %esi
incl %eax
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
movl %eax, 0x2ba7(%rip)      # 0x4128
movl $0x1, %edi
callq 0x11fc
movq %rbx, %rdi
callq 0x1090
movq %r12, %rdi
callq 0x1040
testb $0x3, %al
jne 0x14fa
movl $0x1, %edi
callq 0x10e0
jmp 0x14fa
// File: /workspace/github_c_makefile_star2_O1/eric-lo[P]3150/8-Synchronization/pthread_producer_consumer.c
// Function: main
int main(void) {
	pthread_t tid1, tid2;

	srand(time(NULL));
	pthread_create(&tid1, NULL, producer, NULL);	// create producer
	pthread_create(&tid2, NULL, consumer, NULL);	// create consumer

	// The join statements are just used for suspending the main threads.
	pthread_join(tid1, NULL);	// never reached.
	pthread_join(tid2, NULL);	// never reached.

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
xorl %edi, %edi
callq 0x1080
movl %eax, %edi
callq 0x1050
leaq -0x213(%rip), %rdx      # 0x13bb
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x10b0
leaq -0x11a(%rip), %rdx      # 0x14cc
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x10b0
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x10d0
movq (%r14), %rdi
xorl %esi, %esi
callq 0x10d0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/asg.c
// Function: asg_arc_del_short
int asg_arc_del_short(asg_t *g, float drop_ratio)
{
	uint32_t v, n_vtx = g->n_seq * 2, n_short = 0;
	for (v = 0; v < n_vtx; ++v) {
		asg_arc_t *av = asg_arc_a(g, v);
		uint32_t i, thres, nv = asg_arc_n(g, v);
		if (nv < 2) continue;
		thres = (uint32_t)(av[0].ol * drop_ratio + .499);
		for (i = nv - 1; i >= 1 && av[i].ol < thres; --i);
		for (i = i + 1; i < nv; ++i)
			av[i].del = 1, ++n_short;
	}
	if (n_short) {
		asg_cleanup(g);
		asg_symm(g);
	}
	fprintf(stderr, "[M::%s] removed %d short overlaps\n", __func__, n_short);
	return n_short;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x14(%rdi), %eax
xorl %ebx, %ebx
addl %eax, %eax
je 0x133f
movl %eax, %eax
xorl %ecx, %ecx
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movsd 0x8dd4(%rip), %xmm1     # 0xa060
pushq $0x1
popq %rsi
xorl %ebx, %ebx
movq 0x20(%r14), %rdi
movq (%rdi,%rcx,8), %r9
cmpl $0x2, %r9d
jb 0x1333
movq 0x8(%r14), %rdi
movq %r9, %r8
shrq $0x20, %r8
shlq $0x4, %r8
leaq (%rdi,%r8), %r10
movl 0xc(%r10), %r10d
andl %edx, %r10d
cvtsi2ss %r10d, %xmm2
mulss %xmm0, %xmm2
cvtss2sd %xmm2, %xmm2
addsd %xmm1, %xmm2
cvttsd2si %xmm2, %r15
movl %r9d, %r10d
leal 0x1(%r9), %r11d
movq %r10, %r12
shlq $0x4, %r12
leaq (%rdi,%r8), %r13
addq $-0x4, %r13
cmpq $0x10, %r12
je 0x1304
movl (%r13,%r12), %ebp
andl %edx, %ebp
decl %r11d
addq $-0x10, %r12
cmpl %r15d, %ebp
jb 0x12e9
jmp 0x1307
movl %esi, %r11d
cmpl %r9d, %r11d
jae 0x1333
movl %r11d, %r15d
addl %r9d, %ebx
subq %r15, %r10
shlq $0x4, %r15
addq %r15, %r8
addq %r8, %rdi
addq $0xc, %rdi
orb $-0x80, 0x3(%rdi)
addq $0x10, %rdi
decq %r10
jne 0x1323
subl %r11d, %ebx
incq %rcx
cmpq %rax, %rcx
jne 0x1291
testl %ebx, %ebx
je 0x1360
movq %r14, %rdi
callq 0x41c9
movq %r14, %rdi
callq 0x1392
movq %r14, %rdi
callq 0x1461
orb $-0x80, 0x17(%r14)
movq 0xdc91(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x8cf7(%rip), %rsi      # 0xa068
leaq 0x8d13(%rip), %rdx      # 0xa08b
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1120
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_O1/rikuu[P]kermit/miniasm/asg.c
// Function: asg_arc_del_multi
int asg_arc_del_multi(asg_t *g)
{
	uint32_t *cnt, n_vtx = g->n_seq * 2, n_multi = 0, v;
	cnt = (uint32_t*)calloc(n_vtx, 4);
	for (v = 0; v < n_vtx; ++v) {
		asg_arc_t *av = asg_arc_a(g, v);
		int32_t i, nv = asg_arc_n(g, v);
		if (nv < 2) continue;
		for (i = nv - 1; i >= 0; --i) ++cnt[av[i].v];
		for (i = nv - 1; i >= 0; --i)
			if (--cnt[av[i].v] != 0)
				av[i].del = 1, ++n_multi;
	}
	free(cnt);
	if (n_multi) asg_cleanup(g);
	fprintf(stderr, "[M::%s] removed %d multi-arcs\n", __func__, n_multi);
	return n_multi;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x14(%rdi), %r14d
addl %r14d, %r14d
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x10f0
xorl %ebp, %ebp
testl %r14d, %r14d
je 0x1425
movl %r14d, %ecx
xorl %edx, %edx
xorl %ebp, %ebp
movq 0x20(%rbx), %rsi
movq (%rsi,%rdx,8), %rdi
cmpl $0x2, %edi
jl 0x141d
movq 0x8(%rbx), %r8
movq %rdi, %r9
shrq $0x20, %r9
decl %edi
leaq 0x1(%rdi), %rsi
shlq $0x4, %r9
shlq $0x4, %rdi
addq %r9, %rdi
leaq (%r8,%rdi), %r9
addq $0x8, %r9
movq %rsi, %r10
movl (%r9), %r11d
incl (%rax,%r11,4)
addq $-0x10, %r9
decq %r10
jg 0x13ed
addq %r8, %rdi
addq $0xc, %rdi
movl -0x4(%rdi), %r8d
decl (%rax,%r8,4)
je 0x1414
orb $-0x80, 0x3(%rdi)
incl %ebp
addq $-0x10, %rdi
decq %rsi
jg 0x1404
incq %rdx
cmpq %rcx, %rdx
jne 0x13b9
movq %rax, %rdi
callq 0x1040
testl %ebp, %ebp
je 0x1439
movq %rbx, %rdi
callq 0x41c9
movq 0xdbb8(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x8c53(%rip), %rsi      # 0xa09d
leaq 0x8c6b(%rip), %rdx      # 0xa0bc
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1120
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/asg.c
// Function: asg_arc_del_asymm
int asg_arc_del_asymm(asg_t *g)
{
	uint32_t e, n_asymm = 0;
	for (e = 0; e < g->n_arc; ++e) {
		uint32_t v = g->arc[e].v^1, u = g->arc[e].ul>>32^1;
		uint32_t i, nv = asg_arc_n(g, v);
		asg_arc_t *av = asg_arc_a(g, v);
		for (i = 0; i < nv; ++i)
			if (av[i].v == u) break;
		if (i == nv) g->arc[e].del = 1, ++n_asymm;
	}
	if (n_asymm) asg_cleanup(g);
	fprintf(stderr, "[M::%s] removed %d asymmetric arcs\n", __func__, n_asymm);
	return n_asymm;
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
testl $0x7fffffff, 0x4(%rdi)  # imm = 0x7FFFFFFF
je 0x14ea
xorl %eax, %eax
xorl %ebx, %ebx
movq 0x8(%rdi), %rcx
movq 0x20(%rdi), %rsi
movq %rax, %rdx
shlq $0x4, %rdx
movl 0x8(%rcx,%rdx), %r8d
xorq $0x1, %r8
movq (%rsi,%r8,8), %rsi
movl $0x0, %r8d
testl %esi, %esi
je 0x14cd
movl 0x4(%rcx,%rdx), %r9d
movq %rsi, %r8
shrq $0x20, %r8
shlq $0x4, %r8
leaq (%rcx,%r8), %r10
addq $0x8, %r10
xorl %r8d, %r8d
movl (%r10), %r11d
xorl %r9d, %r11d
cmpl $0x1, %r11d
je 0x14cd
incl %r8d
addq $0x10, %r10
cmpl %r8d, %esi
jne 0x14b2
movl %esi, %r8d
cmpl %esi, %r8d
jne 0x14d9
orb $-0x80, 0xf(%rcx,%rdx)
incl %ebx
incq %rax
movl 0x4(%rdi), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpq %rcx, %rax
jb 0x1471
testl %ebx, %ebx
je 0x14f3
callq 0x41c9
movq 0xdafe(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x8bca(%rip), %rsi      # 0xa0ce
leaq 0x8be7(%rip), %rdx      # 0xa0f2
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1120
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/asg.c
// Function: asg_cut_tip
int asg_cut_tip(asg_t *g, int max_ext)
{
	asg64_v a = {0,0,0};
	uint32_t n_vtx = g->n_seq * 2, v, i, cnt = 0;
	for (v = 0; v < n_vtx; ++v) {
		if (g->seq[v>>1].del) continue;
		if (asg_is_utg_end(g, v, 0) != ASG_ET_TIP) continue; // not a tip
		if (asg_extend(g, v, max_ext, &a) == ASG_ET_MERGEABLE) continue; // not a short unitig
		for (i = 0; i < a.n; ++i)
			asg_seq_del(g, (uint32_t)a.a[i]>>1);
		++cnt;
	}
	free(a.a);
	if (cnt > 0) asg_cleanup(g);
	fprintf(stderr, "[M::%s] cut %d tips\n", __func__, cnt);
	return cnt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, 0xc(%rsp)
movq %rdi, %r14
xorps %xmm0, %xmm0
andq $0x0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movl 0x14(%rdi), %ebp
xorl %ebx, %ebx
addl %ebp, %ebp
je 0x18a5
xorl %ebx, %ebx
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
xorl %r12d, %r12d
movl %ebp, 0x8(%rsp)
movq 0x18(%r14), %rax
movl %r12d, %ecx
shrl %ecx
cmpl $0x0, (%rax,%rcx,4)
js 0x1899
movq 0x20(%r14), %rax
movl %r12d, %ecx
xorl $0x1, %ecx
movq (%rax,%rcx,8), %rcx
movq %rcx, %rax
andq %r15, %rax
je 0x178f
movq 0x8(%r14), %rdx
shrq $0x20, %rcx
shlq $0x4, %rcx
addq %rdx, %rcx
addq $0xc, %rcx
xorl %edx, %edx
xorl %esi, %esi
movl (%rcx), %edi
notl %edi
shrl $0x1f, %edi
addl %edi, %esi
incq %rdx
addq $0x10, %rcx
cmpq %rdx, %rax
jne 0x1772
testl %esi, %esi
jne 0x1899
movq %r14, %rdi
movl %r12d, %esi
movl 0xc(%rsp), %edx
leaq 0x10(%rsp), %rcx
callq 0x4218
testl %eax, %eax
je 0x1899
movq %rbx, 0x28(%rsp)
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x188e
movq 0x20(%rsp), %rcx
movq %rcx, 0x30(%rsp)
xorl %edx, %edx
movq 0x30(%rsp), %rcx
movq (%rcx,%rdx,8), %rsi
movl %esi, %edi
shrl %edi
movq 0x18(%r14), %r8
orl $0x80000000, (%r8,%rdi,4) # imm = 0x80000000
andl $-0x2, %esi
xorl %edi, %edi
leaq (%rdi,%rsi), %r8
movq 0x20(%r14), %r9
movq (%r9,%r8,8), %r9
movq %r9, %r10
andq %r15, %r10
je 0x1870
shrq $0x1c, %r9
andq $-0x10, %r9
addq 0x8(%r14), %r9
xorl %r11d, %r11d
movq %r11, %rbx
shlq $0x4, %rbx
orb $-0x80, 0xf(%r9,%rbx)
movl 0x8(%r9,%rbx), %ebx
xorq $0x1, %rbx
movq 0x20(%r14), %r13
movq (%r13,%rbx,8), %rbx
movq %rbx, %rbp
andq %r15, %rbp
je 0x1868
movq 0x8(%r14), %r13
shrq $0x20, %rbx
shlq $0x4, %rbp
shlq $0x4, %rbx
addq %r13, %rbx
addq $0xc, %rbx
xorl %r13d, %r13d
movl -0x4(%rbx,%r13), %ecx
xorl %r8d, %ecx
cmpl $0x1, %ecx
jne 0x185f
orb $-0x80, 0x3(%rbx,%r13)
addq $0x10, %r13
cmpq %r13, %rbp
jne 0x184c
incq %r11
cmpq %r10, %r11
jne 0x180b
leaq 0x1(%rdi), %rcx
testq %rdi, %rdi
movq %rcx, %rdi
je 0x17e8
incq %rdx
movl %edx, %ecx
cmpq %rcx, %rax
ja 0x17ca
movq 0x28(%rsp), %rbx
incl %ebx
movl 0x8(%rsp), %ebp
incl %r12d
cmpl %ebp, %r12d
jne 0x1732
movq 0x20(%rsp), %rdi
callq 0x1040
testl %ebx, %ebx
je 0x18bb
movq %r14, %rdi
callq 0x41c9
movq 0xd736(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x8870(%rip), %rsi      # 0xa13c
leaq 0x887e(%rip), %rdx      # 0xa151
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1120
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/color.c
// Function: km_cut_cross
int km_cut_cross(asg_t *g, km_color_t *c, int max_distance)
{
	size_t n_cross = 0;
	for (uint32_t e = 0; e < g->n_arc; ++e) {
		uint32_t v = g->arc[e].ul>>33, u = g->arc[e].v>>1;
		// if run with no propagation, we allow arcs to/from uncolored reads
		if (!COLORED(c[v]) || !COLORED(c[u])) continue;
		if (overlap(c[v], c[u], max_distance)) continue;
		g->arc[e].del = 1, ++n_cross;
	}
	fprintf(stderr, "[M::%s] removed %ld color crossing arcs\n", __func__, n_cross);
	if (n_cross)
		asg_cleanup(g);
	return n_cross;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl $0x7fffffff, 0x4(%rdi)  # imm = 0x7FFFFFFF
jne 0x20a0
xorl %r14d, %r14d
jmp 0x212b
movslq %edx, %rax
pushq $0xc
popq %rcx
xorl %edx, %edx
xorl %r14d, %r14d
movq 0x8(%rbx), %rdi
movq -0xc(%rdi,%rcx), %r8
movl -0x4(%rdi,%rcx), %r10d
shrq $0x1d, %r8
andq $-0x10, %r8
leaq (%rsi,%r8), %r9
movq (%rsi,%r8), %r8
testq %r8, %r8
jne 0x20d5
cmpq $0x0, 0x8(%r9)
je 0x2116
shrl %r10d
shlq $0x4, %r10
leaq (%rsi,%r10), %r11
movq (%rsi,%r10), %r10
testq %r10, %r10
jne 0x20f0
cmpq $0x0, 0x8(%r11)
je 0x2116
movq 0x8(%r9), %r9
movq 0x8(%r11), %r11
cmpq %r10, %r8
cmovaq %r8, %r10
cmpq %r11, %r9
cmovbq %r9, %r11
addq %rax, %r11
cmpq %r10, %r11
jae 0x2116
orb $-0x80, 0x3(%rdi,%rcx)
incq %r14
incq %rdx
movl 0x4(%rbx), %edi
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
addq $0x10, %rcx
cmpq %rdi, %rdx
jb 0x20ab
movq 0xcec6(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x873b(%rip), %rsi      # 0xa877
leaq 0x875d(%rip), %rdx      # 0xa8a0
movq %r14, %rcx
xorl %eax, %eax
callq 0x1120
testq %r14, %r14
je 0x215a
movq %rbx, %rdi
callq 0x41c9
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/sys.c
// Function: sys_timestamp
const char *sys_timestamp()
{
	static char buf[256];
	double rt, ct;
	rt = sys_realtime();
	ct = sys_cputime();
	snprintf(buf, 255, "%.3f*%.2f", rt, ct/rt);
	return buf;
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
leaq 0x10(%rsp), %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x10b0
cvtsi2sdq (%rbx), %xmm0
cvtsi2sdq 0x8(%rbx), %xmm1
mulsd 0x6fb7(%rip), %xmm1     # 0xa008
addsd %xmm0, %xmm1
subsd 0xc0f3(%rip), %xmm1     # 0xf150
movsd %xmm1, (%rsp)
leaq 0x10(%rsp), %rbx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x11b0
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
addq (%rbx), %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
addq 0x8(%rbx), %rcx
xorps %xmm1, %xmm1
cvtsi2sd %rcx, %xmm1
mulsd 0x6f70(%rip), %xmm1     # 0xa008
addsd %xmm0, %xmm1
movsd (%rsp), %xmm0
divsd %xmm0, %xmm1
leaq 0xc0b4(%rip), %rbx      # 0xf160
leaq 0x6f5d(%rip), %rdx      # 0xa010
movl $0xff, %esi
movq %rbx, %rdi
movb $0x2, %al
callq 0x10a0
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/sdict.c
// Function: sd_destroy
void sd_destroy(sdict_t *d)
{
	uint32_t i;
	if (d == 0) return;
	if (d->h) kh_destroy(str, (shash_t*)d->h);
	for (i = 0; i < d->n_seq; ++i)
		free(d->seq[i].name);
	free(d->seq);
	free(d);
}

// Assembly:
testq %rdi, %rdi
je 0x3170
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0x3134
movq 0x18(%r14), %rdi
callq 0x1040
movq 0x10(%r14), %rdi
callq 0x1040
movq 0x20(%r14), %rdi
callq 0x1040
movq %r14, %rdi
callq 0x1040
cmpl $0x0, (%rbx)
je 0x315a
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x1040
incq %r15
movl (%rbx), %eax
addq $0x10, %r14
cmpq %rax, %r15
jb 0x313f
movq 0x8(%rbx), %rdi
callq 0x1040
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/sdict.c
// Function: sd_put
int32_t sd_put(sdict_t *d, const char *name, uint32_t len)
{
	shash_t *h = (shash_t*)d->h;
	khint_t k;
	int absent;
	k = kh_put(str, h, name, &absent);
	if (absent) {
		sd_seq_t *s;
		if (d->n_seq == d->m_seq) {
			d->m_seq = d->m_seq? d->m_seq<<1 : 16;
			d->seq = (sd_seq_t*)realloc(d->seq, d->m_seq * sizeof(sd_seq_t));
		}
		s = &d->seq[d->n_seq];
		s->len = len, s->aux = 0, s->del = 0;
		kh_key(h, k) = s->name = strdup(name);
		kh_val(h, k) = d->n_seq++;
	} // TODO: test if len is the same;
	return kh_val(h, k);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rdi), %rbx
leaq 0x4(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3229
cmpl $0x0, (%r12)
movl %eax, %r12d
je 0x3212
movl %ebp, (%rsp)
movl 0x4(%r14), %eax
cmpl %eax, (%r14)
jne 0x31d0
leal (%rax,%rax), %ecx
testl %eax, %eax
movl $0x10, %esi
cmovnel %ecx, %esi
movl %esi, 0x4(%r14)
movq 0x8(%r14), %rdi
shlq $0x4, %rsi
callq 0x1180
movq %rax, 0x8(%r14)
movq 0x8(%r14), %r13
movl (%r14), %ebp
shlq $0x4, %rbp
movl (%rsp), %eax
movl %eax, 0x8(%r13,%rbp)
movl $0x0, 0xc(%r13,%rbp)
movq %r15, %rdi
callq 0x1230
movq %rax, (%r13,%rbp)
movq 0x18(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
movl (%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%r14)
movq 0x20(%rbx), %rcx
movl %eax, (%rcx,%r12,4)
movq 0x20(%rbx), %rax
movl (%rax,%r12,4), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/sdict.c
// Function: sd_get
int32_t sd_get(const sdict_t *d, const char *name)
{
	shash_t *h = (shash_t*)d->h;
	khint_t k;
	k = kh_get(str, h, name);
	return k == kh_end(h)? -1 : kh_val(h, k);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %ecx
testl %ecx, %ecx
je 0x3480
movq %rsi, %r14
leal -0x1(%rcx), %edi
movsbl (%rsi), %r13d
testl %r13d, %r13d
movq %rcx, 0x18(%rsp)
je 0x3488
movb 0x1(%r14), %al
testb %al, %al
je 0x348b
leaq 0x2(%r14), %rcx
movl %r13d, %edx
shll $0x5, %edx
subl %r13d, %edx
movsbl %al, %r13d
addl %edx, %r13d
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x3465
jmp 0x348b
xorl %r15d, %r15d
jmp 0x3516
xorl %r13d, %r13d
andl %edi, %r13d
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdx
movl $0x1, %ebx
movl %r13d, %r15d
movl %edi, 0x14(%rsp)
movq %rdx, 0x20(%rsp)
movl %r15d, %eax
shrl $0x4, %eax
movl (%rdx,%rax,4), %r12d
leal (%r15,%r15), %ebp
andl $0x1e, %ebp
movl %r12d, %eax
movl %ebp, %ecx
shrl %cl, %eax
testb $0x2, %al
jne 0x3504
testb $0x1, %al
jne 0x34ed
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl %r15d, %ecx
movq (%rax,%rcx,8), %rdi
movq %r14, %rsi
callq 0x1100
movq 0x20(%rsp), %rdx
movl 0x14(%rsp), %edi
testl %eax, %eax
je 0x3504
addl %ebx, %r15d
andl %edi, %r15d
incl %ebx
cmpl %r13d, %r15d
jne 0x34a8
movq 0x18(%rsp), %rcx
movl %ecx, %r15d
jmp 0x3516
movl %ebp, %ecx
shrl %cl, %r12d
testb $0x3, %r12b
movq 0x18(%rsp), %rcx
cmovnel %ecx, %r15d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %r15d
je 0x352f
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movl %r15d, %ecx
movl (%rax,%rcx,4), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/sdict.c
// Function: sd_hash
void sd_hash(sdict_t *d)
{
	uint32_t i;
	shash_t *h;
	if (d->h) return;
	d->h = h = kh_init(str);
	for (i = 0; i < d->n_seq; ++i) {
		int absent;
		khint_t k;
		k = kh_put(str, h, d->seq[i].name, &absent);
		kh_val(h, k) = i;
	}
}

// Assembly:
cmpq $0x0, 0x10(%rdi)
je 0x3546
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %edi
movl $0x28, %esi
callq 0x10f0
movq %rax, 0x10(%rbx)
cmpl $0x0, (%rbx)
je 0x35a7
movq %rax, %r14
xorl %r12d, %r12d
leaq 0xc(%rsp), %r15
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq (%rax,%r12), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x3229
movq 0x20(%r14), %rcx
movl %eax, %eax
movl %r13d, (%rcx,%rax,4)
incq %r13
movl (%rbx), %eax
addq $0x10, %r12
cmpq %rax, %r13
jb 0x357c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq