LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/yangtau[P]hedgehog/src/test/../hashset.c
// Function: hashset_resize
static void hashset_resize(struct hg_hashset* set, size_t capacity) {
    struct hg_hashset new_set;
    hg_hashset_init(&new_set, capacity, set->hash, set->eq);
    for (size_t i = 0; i < set->capacity; i++) {
        struct hg_hashset_bucket* ptr = &set->buckets[i];
        if (ptr->state == HG_HASHSET_BUCKET_OCCUPIED)
            hg_hashset_put(&new_set, ptr->item);
    }
    hg_hashset_destroy(set);
    *set = new_set;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
leaq -0x40(%rbp), %rdi
callq 0x11f0
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x1883
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x48(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x1873
movq -0x50(%rbp), %rax
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x12e0
jmp 0x1875
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x1835
movq -0x8(%rbp), %rdi
callq 0x1290
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x30, %edx
callq 0x10b0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/yangtau[P]hedgehog/src/test/hashset_test.c
// Function: hash_int
uint32_t hash_int(const void* item) {
    uint32_t x = (uint32_t)(uint64_t)(item);

    x = ((x >> 16) ^ x) * 0x119de1f3;
    // x = ((x >> 16) ^ x) * 0x119de1f3;
    // x = (x >> 16) ^ x;
    return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
xorl -0xc(%rbp), %eax
imull $0x119de1f3, %eax, %eax # imm = 0x119DE1F3
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yangtau[P]hedgehog/src/test/hashset_test.c
// Function: test_hashset_init
void test_hashset_init() {
    struct hg_hashset set;
    size_t Ns[] = {1, 2, 3, 4, 5, 7, 11, 13, 17, 19};

    for (size_t i = 0; i < sizeof(Ns) / sizeof(size_t); i++) {
        size_t N = Ns[i];

        test_println("hashset init %zu items", N);

        hg_hashset_init(&set, N, hash_int, eq_int);
        test_assert(hg_hashset_len(&set) == 0);

        // put N
        for (size_t i = 0; i < N; i++) {
            hg_hashset_put(&set, (void*)(uint64_t)i);
        }
        test_assert(hg_hashset_len(&set) == (size_t)N);

        // continas N?
        test_assert(!hg_hashset_contains(&set, (void*)(uint64_t)N));

        hg_hashset_destroy(&set);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0x80(%rbp), %rdi
leaq 0xcea(%rip), %rsi       # 0x3430
movl $0x50, %edx
callq 0x10b0
movq $0x0, -0x88(%rbp)
cmpq $0xa, -0x88(%rbp)
jae 0x28e3
movq -0x88(%rbp), %rax
movq -0x80(%rbp,%rax,8), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rsi
leaq 0xbc5(%rip), %rdi       # 0x334f
movb $0x0, %al
callq 0x1070
movq -0x90(%rbp), %rsi
leaq -0x30(%rbp), %rdi
leaq -0xef3(%rip), %rdx      # 0x18b0
leaq -0xeca(%rip), %rcx      # 0x18e0
callq 0x11f0
leaq -0x30(%rbp), %rdi
callq 0x2710
cmpq $0x0, %rax
jne 0x27c0
jmp 0x27f2
movq 0x2831(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x91b(%rip), %rsi       # 0x30ec
leaq 0x940(%rip), %rdx       # 0x3118
movl $0x97, %ecx
leaq 0xb91(%rip), %r8        # 0x3375
leaq 0xa5b(%rip), %r9        # 0x3246
movb $0x0, %al
callq 0x10a0
movq $0x0, -0x98(%rbp)
movq -0x98(%rbp), %rax
cmpq -0x90(%rbp), %rax
jae 0x2831
movq -0x98(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x12e0
movq -0x98(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x98(%rbp)
jmp 0x27fd
jmp 0x2833
leaq -0x30(%rbp), %rdi
callq 0x2710
cmpq -0x90(%rbp), %rax
jne 0x2847
jmp 0x2879
movq 0x27aa(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x894(%rip), %rsi       # 0x30ec
leaq 0x8b9(%rip), %rdx       # 0x3118
movl $0x9d, %ecx
leaq 0xb0a(%rip), %r8        # 0x3375
leaq 0xb15(%rip), %r9        # 0x3387
movb $0x0, %al
callq 0x10a0
jmp 0x287b
movq -0x90(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1620
testb $0x1, %al
jne 0x2891
jmp 0x28c3
movq 0x2760(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x84a(%rip), %rsi       # 0x30ec
leaq 0x86f(%rip), %rdx       # 0x3118
movl $0xa0, %ecx
leaq 0xac0(%rip), %r8        # 0x3375
leaq 0xaed(%rip), %r9        # 0x33a9
movb $0x0, %al
callq 0x10a0
leaq -0x30(%rbp), %rdi
callq 0x1290
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x275b
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sushant8421[P]create_your_own_shell/searchstring.c
// Function: main
int main(int argc, char *argv[]) {
	int result, errno;

	if(argc < 4 || argc > 4) {
		Usage(argv[0]);
		exit(1);
	}

	result = Search_in_File(argv[2], argv[3] , argv[1]);
	if(result == -1) {
		perror("Error");
		printf("Error number = %d\n", errno);
		exit(1);
	}
	return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x8(%rbp)
jl 0x11d2
cmpl $0x4, -0x8(%rbp)
jle 0x11e8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1240
movl $0x1, %edi
callq 0x1090
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x1260
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x1235
leaq 0xdef(%rip), %rdi       # 0x2004
callq 0x1080
movl -0x18(%rbp), %esi
leaq 0xde6(%rip), %rdi       # 0x200a
movb $0x0, %al
callq 0x1040
movl $0x1, %edi
callq 0x1090
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/veltzer[P]xmeltdown/src/dance.c
// Function: ReadRoutineFile
int*ReadRoutineFile(char* filename)
{
	FILE* infile;
	int okayflag=1;
	int* retval;
	int numread=0;

	infile=fopen(filename, "r");
	if (infile == NULL) {
		fprintf(stderr, "Cannot open file %s\n", filename);
		exit(1);
	}
	retval=(int *) calloc (1, sizeof (int));
	numread=0;
	while (okayflag >= 0) {
		okayflag=fscanf(infile, "%d\n", &(retval[numread]));
		if (okayflag >= 0) {
			numread++;
			retval=(int *) realloc (retval, (numread+1)*sizeof (int));
		}
	}
	retval[numread]=-1;
	return (retval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0x14(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x182e(%rip), %rsi      # 0x3063
callq 0x10a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x186b
movq 0x379c(%rip), %rax      # 0x4fe8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x180b(%rip), %rsi      # 0x3065
movb $0x0, %al
callq 0x11b0
movl $0x1, %edi
callq 0x1080
movl $0x1, %edi
movl $0x4, %esi
callq 0x1160
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x18da
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movslq -0x24(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
leaq 0x181c(%rip), %rsi      # 0x30c1
movb $0x0, %al
callq 0x1050
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x18d8
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x1190
movq %rax, -0x20(%rbp)
jmp 0x1885
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/veltzer[P]xmeltdown/src/dance.c
// Function: HandleKeyPress
void HandleKeyPress(XKeyEvent* pevent)
{
	char charback;
	/* int	i; */

	XLookupString(pevent, &charback, 1, NULL, NULL);
	if (charback == 'q')
		exit(0);
	if (charback == '+') {
		steps++;
		printf ("Dancing at speed %d\n", steps);
	}
	if (charback == '-') {
		steps--;
		printf ("Dancing at speed %d\n", steps);
	}
	if (charback >= '1' && charback <= '9') {
		steps=(int) (charback-'1')+1;
		printf ("Dancing at speed %d\n", steps);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x1060
movsbl -0x9(%rbp), %eax
cmpl $0x71, %eax
jne 0x1fa6
xorl %edi, %edi
callq 0x1080
movsbl -0x9(%rbp), %eax
cmpl $0x2b, %eax
jne 0x1fd2
movl 0x316b(%rip), %eax      # 0x5120
addl $0x1, %eax
movl %eax, 0x3162(%rip)      # 0x5120
movl 0x315c(%rip), %esi      # 0x5120
leaq 0x1083(%rip), %rdi      # 0x304e
movb $0x0, %al
callq 0x1030
movsbl -0x9(%rbp), %eax
cmpl $0x2d, %eax
jne 0x1ffe
movl 0x313f(%rip), %eax      # 0x5120
addl $-0x1, %eax
movl %eax, 0x3136(%rip)      # 0x5120
movl 0x3130(%rip), %esi      # 0x5120
leaq 0x1057(%rip), %rdi      # 0x304e
movb $0x0, %al
callq 0x1030
movsbl -0x9(%rbp), %eax
cmpl $0x31, %eax
jl 0x2034
movsbl -0x9(%rbp), %eax
cmpl $0x39, %eax
jg 0x2034
movsbl -0x9(%rbp), %eax
subl $0x31, %eax
addl $0x1, %eax
movl %eax, 0x3100(%rip)      # 0x5120
movl 0x30fa(%rip), %esi      # 0x5120
leaq 0x1021(%rip), %rdi      # 0x304e
movb $0x0, %al
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/veltzer[P]xmeltdown/src/dance.c
// Function: RandomMove
void RandomMove()
{
	int i;
	int randnum;
	static int lastnum=999;
	do {
		randnum=rand()%numread;
	} while (randnum == lastnum);
	lastnum=randnum;
	for (i=0; i < PLAYERS; i++) {
		fromskel[i]=tweenskel[0];
		toskel[i]=skellist[randnum];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x11a0
cltd
idivl 0x35a4(%rip)            # 0x55f8
movl %edx, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x30a8(%rip), %eax      # 0x5108
je 0x2048
movl -0x8(%rbp), %eax
movl %eax, 0x309d(%rip)      # 0x5108
movl $0x0, -0x4(%rbp)
cmpl $0x3, -0x4(%rbp)
jge 0x20b7
movq 0x3501(%rip), %rdx      # 0x5580
movslq -0x4(%rbp), %rcx
leaq 0x3536(%rip), %rax      # 0x55c0
movq %rdx, (%rax,%rcx,8)
movq 0x3523(%rip), %rax      # 0x55b8
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x3538(%rip), %rax      # 0x55e0
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2072
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/apps/parasail_aligner.cpp
// Function: set_signal_handler()
void set_signal_handler()
{
    /* register our signal handlers */
    {
        struct sigaction sig_action = {};
        sig_action.sa_sigaction = posix_signal_handler;
        sigemptyset(&sig_action.sa_mask);
        sig_action.sa_flags = SA_SIGINFO;
        if (sigaction(SIGSEGV, &sig_action, NULL) != 0) { err(1, "sigaction"); }
        if (sigaction(SIGFPE, &sig_action, NULL) != 0) { err(1, "sigaction"); }
        if (sigaction(SIGINT, &sig_action, NULL) != 0) { err(1, "sigaction"); }
        if (sigaction(SIGILL, &sig_action, NULL) != 0) { err(1, "sigaction"); }
        if (sigaction(SIGTERM, &sig_action, NULL) != 0) { err(1, "sigaction"); }
        if (sigaction(SIGABRT, &sig_action, NULL) != 0) { err(1, "sigaction"); }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x2af140
leaq 0x140b(%rip), %rax      # 0x2b5fa0
movq %rax, -0x98(%rbp)
leaq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x2af3d0
movl $0x4, -0x10(%rbp)
movl $0xb, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2af3e0
cmpl $0x0, %eax
je 0x2b4be0
movl $0x1, %edi
leaq 0xafaef7(%rip), %rsi    # 0xdafad0
movb $0x0, %al
callq 0x2af270
movl $0x8, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2af3e0
cmpl $0x0, %eax
je 0x2b4c0d
movl $0x1, %edi
leaq 0xafaeca(%rip), %rsi    # 0xdafad0
movb $0x0, %al
callq 0x2af270
movl $0x2, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2af3e0
cmpl $0x0, %eax
je 0x2b4c3a
movl $0x1, %edi
leaq 0xafae9d(%rip), %rsi    # 0xdafad0
movb $0x0, %al
callq 0x2af270
movl $0x4, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2af3e0
cmpl $0x0, %eax
je 0x2b4c67
movl $0x1, %edi
leaq 0xafae70(%rip), %rsi    # 0xdafad0
movb $0x0, %al
callq 0x2af270
movl $0xf, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2af3e0
cmpl $0x0, %eax
je 0x2b4c94
movl $0x1, %edi
leaq 0xafae43(%rip), %rsi    # 0xdafad0
movb $0x0, %al
callq 0x2af270
movl $0x6, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2af3e0
cmpl $0x0, %eax
je 0x2b4cc1
movl $0x1, %edi
leaq 0xafae16(%rip), %rsi    # 0xdafad0
movb $0x0, %al
callq 0x2af270
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/apps/parasail_aligner.cpp
// Function: stdin_has_data()
static int stdin_has_data() {
    int timeout = 100; /* wait 100ms */
    struct pollfd fd;
    fd.fd = 0;
    fd.events = POLLIN;
    fd.revents = 0;
    int ret = poll(&fd, 1, timeout);
    return (ret > 0 && (fd.revents & POLLIN));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x64, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
movw $0x1, -0x8(%rbp)
movw $0x0, -0x6(%rbp)
movl -0x4(%rbp), %edx
leaq -0xc(%rbp), %rdi
movl $0x1, %esi
callq 0x2af470
movl %eax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
jle 0x2b53b1
movswl -0x6(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/apps/parasail_aligner.cpp
// Function: self_score(char const*, int, parasail_matrix const*)
inline static int self_score(
        const char * const restrict seq,
        int len,
        const parasail_matrix_t *matrix)
{
    int score = 0;
    for (int i=0; i<len; ++i) {
        unsigned char mapped = matrix->mapper[(unsigned char)seq[i]];
        score += matrix->matrix[matrix->size*mapped+mapped];
    }
    return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2b6542
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movl (%rax,%rcx,4), %eax
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x18(%rcx), %ecx
movzbl -0x21(%rbp), %edx
imull %edx, %ecx
movzbl -0x21(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2b64ed
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/apps/parasail_aligner.cpp
// Function: print_array(char const*, int const*, char const*, int, char const*, int)
inline static void print_array(
        const char * filename_,
        const int * const restrict array,
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len)
{
    int i;
    int j;
    FILE *f = NULL;
    const char *filename = filename_;

    f = fopen(filename, "w");
    if (NULL == f) {
        eprintf(stderr, "fopen(\"%s\") error: %s\n", filename, strerror(errno));
        exit(-1);
    }
    fprintf(f, " ");
    for (j=0; j<s2Len; ++j) {
        fprintf(f, "%4c", s2[j]);
    }
    fprintf(f, "\n");
    for (i=0; i<s1Len; ++i) {
        fprintf(f, "%c", s1[i]);
        for (j=0; j<s2Len; ++j) {
            fprintf(f, "%4d", array[i*s2Len + j]);
        }
        fprintf(f, "\n");
    }
    fclose(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
leaq 0xb7db33(%rip), %rsi    # 0xe35bfd
callq 0x2af380
movq %rax, -0x40(%rbp)
xorl %eax, %eax
cmpq -0x40(%rbp), %rax
jne 0x2b8120
movq 0xcc2eee(%rip), %rax    # 0xf7afd0
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x2af030
movl (%rax), %edi
callq 0x2af0b0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
leaq 0xaf78d1(%rip), %rsi    # 0xdaf9e0
movb $0x0, %al
callq 0x2af440
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2af3b0
movq -0x40(%rbp), %rdi
leaq 0xaf667f(%rip), %rsi    # 0xdae7aa
movb $0x0, %al
callq 0x2af440
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x2b816a
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsbl (%rax,%rcx), %edx
leaq 0xaf789f(%rip), %rsi    # 0xdaf9f7
movb $0x0, %al
callq 0x2af440
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2b8139
movq -0x40(%rbp), %rdi
leaq 0xaf7055(%rip), %rsi    # 0xdaf1ca
movb $0x0, %al
callq 0x2af440
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2b8209
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %edx
leaq 0xaf7e58(%rip), %rsi    # 0xdafffa
movb $0x0, %al
callq 0x2af440
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x2b81e9
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x30(%rbp), %ecx
imull -0x2c(%rbp), %ecx
addl -0x34(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
leaq 0xaf7824(%rip), %rsi    # 0xdaf9fb
movb $0x0, %al
callq 0x2af440
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2b81b0
movq -0x40(%rbp), %rdi
leaq 0xaf6fd6(%rip), %rsi    # 0xdaf1ca
movb $0x0, %al
callq 0x2af440
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2b8183
movq -0x40(%rbp), %rdi
callq 0x2af2b0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/traceback.c
// Function: parasail_traceback_free
void parasail_traceback_free(parasail_traceback_t *traceback)
{
    free(traceback->query);
    free(traceback->comp);
    free(traceback->ref);
    free(traceback);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2af3a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2af3a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2af3a0
movq -0x8(%rbp), %rdi
callq 0x2af3a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/backoff.c
// Function: lock_forward
void *lock_forward(void *arg)
{
	(void)arg;

	for (int iterate = 0; iterate < ITERATIONS; iterate++)
	{
		int backoffs = 0;
		for (int i = 0; i < 3; i++)
		{
			if (i == 0 || !backoff)
				pthread_mutex_lock(&mutex[i]);
			else
			{
				if (pthread_mutex_trylock(&mutex[i]) == EBUSY)
				{
					backoffs++;
					while (--i >= 0)
						pthread_mutex_unlock(&mutex[i]);
				}

				switch (yf)
				{
					case YIELD:
						sched_yield();
						break;
					case SLEEP:
						sleep(1);
						break;
					default:
						break;
				}
			}
		}

		printf("F: %d\n", backoffs);
		pthread_mutex_unlock(&mutex[2]);
		pthread_mutex_unlock(&mutex[1]);
		pthread_mutex_unlock(&mutex[0]);
		sched_yield();
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jge 0x12fc
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0x12ac
cmpl $0x0, -0x14(%rbp)
je 0x1204
testb $0x1, 0x2e6e(%rip)      # 0x4070
jne 0x121d
movslq -0x14(%rbp), %rax
leaq 0x2e81(%rip), %rdi      # 0x4090
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x10b0
jmp 0x129c
movslq -0x14(%rbp), %rax
leaq 0x2e68(%rip), %rdi      # 0x4090
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x1040
cmpl $0x10, %eax
jne 0x126b
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jl 0x1269
movslq -0x14(%rbp), %rax
leaq 0x2e35(%rip), %rdi      # 0x4090
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x1060
jmp 0x1242
jmp 0x126b
movl 0x2e97(%rip), %eax      # 0x4108
movl %eax, -0x18(%rbp)
subl $-0x1, %eax
je 0x128c
jmp 0x127b
movl -0x18(%rbp), %eax
subl $0x1, %eax
jne 0x1298
jmp 0x1285
callq 0x1050
jmp 0x129a
movl $0x1, %edi
callq 0x10a0
jmp 0x129a
jmp 0x129a
jmp 0x129c
jmp 0x129e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11eb
movl -0x10(%rbp), %esi
leaq 0xd4e(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
leaq 0x2dcc(%rip), %rdi      # 0x4090
addq $0x50, %rdi
callq 0x1060
leaq 0x2dbc(%rip), %rdi      # 0x4090
addq $0x28, %rdi
callq 0x1060
leaq 0x2dac(%rip), %rdi      # 0x4090
callq 0x1060
callq 0x1050
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x11d3
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/backoff.c
// Function: lock_backward
void *lock_backward(void *arg)
{
	(void)arg;

	for (int iterate = 0; iterate < ITERATIONS; iterate++)
	{
		int backoffs = 0;
		for (int i = 2; i >= 0 ; i--)
		{
			if (i == 2 || !backoff)
				pthread_mutex_lock(&mutex[i]);
			else
			{
				if (pthread_mutex_trylock(&mutex[i]) == EBUSY)
				{
					backoffs++;
					while (++i < 3)
						pthread_mutex_unlock(&mutex[i]);
				}

				switch (yf)
				{
					case YIELD:
						sched_yield();
						break;
					case SLEEP:
						sleep(1);
						break;
					default:
						break;
				}
			}
		}

		printf("B: %d\n", backoffs);
		pthread_mutex_unlock(&mutex[0]);
		pthread_mutex_unlock(&mutex[1]);
		pthread_mutex_unlock(&mutex[2]);
		sched_yield();
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jge 0x144c
movl $0x0, -0x10(%rbp)
movl $0x2, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x13fc
cmpl $0x2, -0x14(%rbp)
je 0x1354
testb $0x1, 0x2d1e(%rip)      # 0x4070
jne 0x136d
movslq -0x14(%rbp), %rax
leaq 0x2d31(%rip), %rdi      # 0x4090
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x10b0
jmp 0x13ec
movslq -0x14(%rbp), %rax
leaq 0x2d18(%rip), %rdi      # 0x4090
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x1040
cmpl $0x10, %eax
jne 0x13bb
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x3, %eax
jge 0x13b9
movslq -0x14(%rbp), %rax
leaq 0x2ce5(%rip), %rdi      # 0x4090
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x1060
jmp 0x1392
jmp 0x13bb
movl 0x2d47(%rip), %eax      # 0x4108
movl %eax, -0x18(%rbp)
subl $-0x1, %eax
je 0x13dc
jmp 0x13cb
movl -0x18(%rbp), %eax
subl $0x1, %eax
jne 0x13e8
jmp 0x13d5
callq 0x1050
jmp 0x13ea
movl $0x1, %edi
callq 0x10a0
jmp 0x13ea
jmp 0x13ea
jmp 0x13ec
jmp 0x13ee
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x133b
movl -0x10(%rbp), %esi
leaq 0xc05(%rip), %rdi       # 0x200b
movb $0x0, %al
callq 0x1030
leaq 0x2c7c(%rip), %rdi      # 0x4090
callq 0x1060
leaq 0x2c70(%rip), %rdi      # 0x4090
addq $0x28, %rdi
callq 0x1060
leaq 0x2c60(%rip), %rdi      # 0x4090
addq $0x50, %rdi
callq 0x1060
callq 0x1050
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1323
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/backoff.c
// Function: main
int main(int argc, const char **argv)
{
	pthread_t forward, backward;

	if (argc > 1)
		backoff = atoi(argv[1]);
	if (argc > 2)
		yf = atoi(argv[2]);

	pthread_create(&forward, NULL, lock_forward, NULL);
	pthread_create(&backward, NULL, lock_backward, NULL);

	pthread_exit(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x1497
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1090
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x2bd9(%rip)       # 0x4070
cmpl $0x2, -0x8(%rbp)
jle 0x14b0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1090
movl %eax, 0x2c58(%rip)      # 0x4108
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x2ff(%rip), %rdx      # 0x11c0
movq %rcx, %rsi
callq 0x1080
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x1c6(%rip), %rdx      # 0x1310
movq %rcx, %rsi
callq 0x1080
xorl %eax, %eax
movl %eax, %edi
callq 0x1070
// File: /workspace/github_c_makefile_star2_O0/vanhauser-thc[P]vulntest/encrypt.c
// Function: encrypt
int encrypt(unsigned char *plaintext, int plaintext_len, unsigned char *key, unsigned char *iv, unsigned char *ciphertext) {
  EVP_CIPHER_CTX *ctx;
  int len;
  int ciphertext_len;

  /* Create and initialise the context */
  if (!(ctx = EVP_CIPHER_CTX_new()))
    exit(-1);

  /*
   * Initialise the encryption operation. IMPORTANT - ensure you use a key
   * and IV size appropriate for your cipher
   * In this example we are using 256 bit AES (i.e. a 256 bit key). The
   * IV size for *most* modes is the same as the block size. For AES this
   * is 128 bits
   */
  if (1 != EVP_EncryptInit_ex(ctx, EVP_des_ecb(), NULL, key, iv))
    exit(-1);

  /*
   * Provide the message to be encrypted, and obtain the encrypted output.
   * EVP_EncryptUpdate can be called multiple times if necessary
   */
  if (1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len))
    exit(-1);
  ciphertext_len = len;

  /*
   * Finalise the encryption. Further ciphertext bytes may be written at
   * this stage.
   */
  if (1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len))
    exit(-1);
  ciphertext_len += len;

  /* Clean up */
  EVP_CIPHER_CTX_free(ctx);

  return ciphertext_len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
callq 0x1080
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x11f4
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1030
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x10a0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x1090
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
je 0x122e
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1030
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %r8d
leaq -0x34(%rbp), %rdx
callq 0x10b0
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
je 0x125c
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1030
movl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq -0x34(%rbp), %rax
addq %rax, %rsi
leaq -0x34(%rbp), %rdx
callq 0x1050
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
je 0x128f
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1030
movl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1070
movl -0x38(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vanhauser-thc[P]vulntest/encrypt.c
// Function: main
int main(int argc, char *argv[]) {
  /*
   * Set up the key and iv. Do I need to say to not hard code these in a
   * real application? :-)
   */
  if (argc < 3)
    exit(-1);

  /* A 256 bit key */
  unsigned char *key = argv[1];

  /* A 128 bit IV */
  unsigned char *iv = (unsigned char *)"0123456789012345";

  /* Message to be encrypted */
  unsigned char *plaintext = argv[2];

  /*
   * Buffer for ciphertext. Ensure the buffer is long enough for the
   * ciphertext which may be longer than the plaintext, depending on the
   * algorithm and mode.
   */
  unsigned char ciphertext[1024];

  int ciphertext_len;

  /* Encrypt the plaintext */
  ciphertext_len = encrypt(plaintext, strlen((char *)plaintext), key, iv, ciphertext);

  /* Do something useful with the ciphertext here */
  BIO_dump_fp(stdout, (const char *)ciphertext, ciphertext_len);

  return ciphertext_len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0x12d9
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0xd18(%rip), %rax       # 0x2004
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x440(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1040
movq -0x440(%rbp), %rdi
movl %eax, %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x430(%rbp), %r8
callq 0x11c0
movl %eax, -0x434(%rbp)
movq 0x2cbe(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq -0x430(%rbp), %rsi
movl -0x434(%rbp), %edx
callq 0x1060
movl -0x434(%rbp), %eax
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_06/getop.c
// Function: main
int main(void)
{
  char s[100] = "";

  int type = getop(s);

  printf("%d ", type);
  puts(s);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x64, %edx
callq 0x1050
leaq -0x70(%rbp), %rdi
callq 0x11f0
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %esi
leaq 0xe3c(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
leaq -0x70(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_06/getop.c
// Function: getop
int getop(char *s)
{
  char c;

  // Skip blanks (spaces and tabs)
  while ((*s = c = getchar()) == ' ' || c == '\t')
    ;

  *(s + 1) = '\0';

  // Not a number
  if (!isdigit(c) && c != '.')
    return c;

  // Collect the integer part
  if (isdigit(c) && c != '.')
    while (isdigit(*(++s) = c = getchar()))
      ;

  // Collect the fraction part
  if (c == '.')
  {
    while (isdigit(*(++s) = c = getchar()))
      ;
  }

  if (c != EOF)
    ungetc(c, stdin);

  *s = '\0';

  return NUMBER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
callq 0x1060
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rcx
movb %al, (%rcx)
movsbl %al, %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x12(%rbp)
je 0x1224
movsbl -0x11(%rbp), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
testb $0x1, %al
jne 0x122d
jmp 0x122f
jmp 0x11fc
movq -0x10(%rbp), %rax
movb $0x0, 0x1(%rax)
callq 0x1080
movq (%rax), %rax
movsbl -0x11(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x1269
movsbl -0x11(%rbp), %eax
cmpl $0x2e, %eax
je 0x1269
movsbl -0x11(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x134e
callq 0x1080
movq (%rax), %rax
movsbl -0x11(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x12d5
movsbl -0x11(%rbp), %eax
cmpl $0x2e, %eax
je 0x12d5
jmp 0x1291
callq 0x1080
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x1060
movl %eax, %ecx
movq -0x20(%rbp), %rax
movb %cl, -0x11(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x10(%rbp)
movb %cl, 0x1(%rdx)
movsbl %cl, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x12d3
jmp 0x1291
jmp 0x12d5
movsbl -0x11(%rbp), %eax
cmpl $0x2e, %eax
jne 0x1324
jmp 0x12e0
callq 0x1080
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x1060
movl %eax, %ecx
movq -0x28(%rbp), %rax
movb %cl, -0x11(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x10(%rbp)
movb %cl, 0x1(%rdx)
movsbl %cl, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x1322
jmp 0x12e0
jmp 0x1324
movsbl -0x11(%rbp), %eax
cmpl $-0x1, %eax
je 0x1340
movsbl -0x11(%rbp), %edi
movq 0x2ca8(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x1070
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/martin-decky[P]ichiglyph/interpreter/brainfuck/brainfuck.c
// Function: opcode_decode
static instruction_t opcode_decode(uint8_t opcode)
{
	switch (opcode) {
	case '>':
		return INST_DP_INC;
	case '<':
		return INST_DP_DEC;
	case '+':
		return INST_VAL_INC;
	case '-':
		return INST_VAL_DEC;
	case '.':
		return INST_VAL_OUTPUT;
	case ',':
		return INST_VAL_ACCEPT;
	case '[':
		return INST_JMP_FORWARD;
	case ']':
		return INST_JMP_BACK;
	default:
		return INST_NOP;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
addl $-0x2b, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x32, %eax
ja 0x1848
movq -0x10(%rbp), %rax
leaq 0x831(%rip), %rcx       # 0x2028
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x184f
movl $0x1, -0x4(%rbp)
jmp 0x184f
movl $0x2, -0x4(%rbp)
jmp 0x184f
movl $0x3, -0x4(%rbp)
jmp 0x184f
movl $0x4, -0x4(%rbp)
jmp 0x184f
movl $0x5, -0x4(%rbp)
jmp 0x184f
movl $0x6, -0x4(%rbp)
jmp 0x184f
movl $0x7, -0x4(%rbp)
jmp 0x184f
movl $0x8, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martin-decky[P]ichiglyph/interpreter/brainfuck/brainfuck.c
// Function: data_inc
static int data_inc(data_t *data, size_t dp)
{
	int ret = data_bound(data, dp);
	if (ret != 0)
		return ret;
	
	data->data[dp]++;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a00
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x188e
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x18a9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movb (%rax,%rcx), %dl
addb $0x1, %dl
movb %dl, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martin-decky[P]ichiglyph/interpreter/brainfuck/brainfuck.c
// Function: data_dec
static int data_dec(data_t *data, size_t dp)
{
	int ret = data_bound(data, dp);
	if (ret != 0)
		return ret;
	
	data->data[dp]--;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a00
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x18ee
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1909
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movb (%rax,%rcx), %dl
addb $-0x1, %dl
movb %dl, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martin-decky[P]ichiglyph/interpreter/brainfuck/brainfuck.c
// Function: data_set
static int data_set(data_t *data, size_t dp, uint8_t val)
{
	int ret = data_bound(data, dp);
	if (ret != 0)
		return ret;
	
	data->data[dp] = val;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a00
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x1993
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x19ab
movb -0x19(%rbp), %dl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martin-decky[P]ichiglyph/interpreter/brainfuck/brainfuck.c
// Function: data_bound
static int data_bound(data_t *data, size_t dp)
{
	if (dp >= data->size) {
		size_t size = dp + 1 + DATA_GRANULARITY;
		data->data = (uint8_t *) realloc(data->data, size);
		if (data->data == NULL)
			return -1;
		
		memset(data->data + data->size, 0, size - data->size);
		data->size = size;
	}
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x1a8b
movq -0x18(%rbp), %rax
addq $0x1, %rax
addq $0x8000, %rax           # imm = 0x8000
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x10b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1a5d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1a92
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
subq 0x8(%rax), %rdx
xorl %esi, %esi
callq 0x1050
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vi[P]simple_cbor_stream_parse/simple_example.c
// Function: main
int main() {
    
    struct scsp_callbacks cb;
    memset(&cb, 0, sizeof(cb));
    
    cb.array_opened = &array_opened;
    cb.array_closed = &array_closed;
    cb.integer = &integer;
    cb.string_chunk = &string_chunk;
    
    const char *cbor_data = 
        "\x9F"                        // [
            "\x1A" "\x00\x12\xD6\x87" //     1234567,
            "\x63" "ABC"              //     "ABC",
            "\x84"                    //     [
                "\x05"                //         5,
                "\x05"                //         5,
                "\x29"                //         -10,
                "\x29"                //         -10,
                                      //     ]
        "\xFF"                        // ]
    ;
    size_t cbor_data_len = 2+5+4+1+4;
    
    assert(scsp_parse_from_memory(cbor_data, cbor_data_len, &cb, (void*)0x5645) == 0);
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x1060
leaq -0x19c(%rip), %rax      # 0x11b0
movq %rax, -0x60(%rbp)
leaq -0x157(%rip), %rax      # 0x1200
movq %rax, -0x50(%rbp)
leaq -0x122(%rip), %rax      # 0x1240
movq %rax, -0x98(%rbp)
leaq -0xd0(%rip), %rax       # 0x12a0
movq %rax, -0x70(%rbp)
leaq 0x1e1b(%rip), %rax      # 0x3196
movq %rax, -0xa0(%rbp)
movq $0x10, -0xa8(%rbp)
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
leaq -0x98(%rbp), %rdx
movl $0x5645, %ecx           # imm = 0x5645
callq 0x2a80
cmpq $0x0, %rax
jne 0x13b4
jmp 0x13d3
leaq 0x1d86(%rip), %rdi      # 0x3141
leaq 0x1c5c(%rip), %rsi      # 0x301e
movl $0x33, %edx
leaq 0x1dbd(%rip), %rcx      # 0x318b
callq 0x1050
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/seojangho[P]clee/sandbox.c
// Function: onSeccomp
void onSeccomp() {
    printf("[Detected] %s(%d)\n", clee_syscall_name(), clee_syscall_num());
    if (option_enforcing) {
        printf("No mercy!...\n");
        clee_behave(terminate, 0);
    } else {
        getchar();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x0, %al
callq 0x3be0
movq %rax, -0x8(%rbp)
movb $0x0, %al
callq 0x3bb0
movq -0x8(%rbp), %rsi
movq %rax, %rdx
leaq 0x1d63(%rip), %rdi      # 0x92eb
movb $0x0, %al
callq 0x3090
testb $0x1, 0x5d7a(%rip)      # 0xd310
je 0x75b1
leaq 0x1d5f(%rip), %rdi      # 0x92fe
movb $0x0, %al
callq 0x3090
xorl %esi, %esi
movl %esi, %edi
callq 0x41c0
jmp 0x75b6
callq 0x3140
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/seojangho[P]clee/sandbox.c
// Function: showpolicy
void showpolicy() {
    printf("List of forbidden system calls:\n");
    int i;
    for (i = 0;; i++)
    {
        if (forbidden[i] == -1) {
            break;
        }
        printf("%s(%d)\n", clee_syscall_num2name(forbidden[i]), forbidden[i]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1b3f(%rip), %rdi      # 0x941e
movb $0x0, %al
callq 0x3090
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x1678(%rip), %rax      # 0x8f70
cmpl $-0x1, (%rax,%rcx,4)
jne 0x7900
jmp 0x793d
movslq -0x4(%rbp), %rcx
leaq 0x1665(%rip), %rax      # 0x8f70
movl (%rax,%rcx,4), %edi
callq 0x4380
movq %rax, %rsi
movslq -0x4(%rbp), %rcx
leaq 0x164f(%rip), %rax      # 0x8f70
movl (%rax,%rcx,4), %edx
leaq 0x19cb(%rip), %rdi      # 0x92f6
movb $0x0, %al
callq 0x3090
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x78ed
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rouming[P]io/io-test.c
// Function: on_signal
static int on_signal(struct io_req *req, int err)
{
	int rc;
	struct signalfd_siginfo *siginfo;
	struct loop_ctx *ctx = req->data;

	if (err < 0)
		return err;
	assert(err == sizeof(struct signalfd_siginfo));
	siginfo = req->buf.iov[0].iov_base;
	if (siginfo->ssi_signo == SIGINT) {
		/* Graceful exit */
		ctx->shutdown = true;
		return err;
	}

	/* Repeat signal REQ_RD request */
	req->buf.pos.iov_off = 0;
	req->buf.pos.iov_ind = 0;
	rc = io_queue_submit(req);
	assert(rc == 0);

	actions[action_ind++](ctx);
	action_ind %= ARRAY_SIZE(actions);

	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x177c
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1869
movslq -0x14(%rbp), %rax
cmpq $0x80, %rax
jne 0x178a
jmp 0x17a9
leaq 0x68fe(%rip), %rdi      # 0x808f
leaq 0x689a(%rip), %rsi      # 0x8032
movl $0x181, %edx            # imm = 0x181
leaq 0x6912(%rip), %rcx      # 0x80b6
callq 0x1090
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x17d4
movq -0x28(%rbp), %rax
movb $0x1, 0x2f0(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1869
movq -0x10(%rbp), %rax
movq $0x0, 0x130(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x128(%rax)
movq -0x10(%rbp), %rdi
callq 0x4950
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x1806
jmp 0x1825
leaq 0x68cd(%rip), %rdi      # 0x80da
leaq 0x681e(%rip), %rsi      # 0x8032
movl $0x18d, %edx            # imm = 0x18D
leaq 0x6896(%rip), %rcx      # 0x80b6
callq 0x1090
movl 0xa985(%rip), %eax      # 0xc1b0
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0xa97a(%rip)      # 0xc1b0
movslq %eax, %rcx
leaq 0xa8b0(%rip), %rax      # 0xc0f0
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rdi
callq *%rax
movslq 0xa95f(%rip), %rax      # 0xc1b0
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0xa94d(%rip)      # 0xc1b0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rouming[P]io/io-test.c
// Function: do_vari_len_req1
static void do_vari_len_req1(struct loop_ctx *ctx)
{
	int rc;
	struct io_req *m_s_req1, *s_m_req1;

	/* Write master->slave, part1 */
	m_s_req1 = io_req_create(&ctx->master, REQ_WR, ctx,
				 on_write_vari_len_req1_1__master_to_slave);
	assert(m_s_req1);
	m_s_req1->buf = (struct io_buf){
		.iov[0] = {
			.iov_base = "<msg>",
			.iov_len  = strlen("<msg>")
		},
		.iov[1] = {
			.iov_base = "1 vari length 1",
			.iov_len  = strlen("1 vari length 1")
		},
		.iov_num  = 2,
		.is_vari_len = false
	};
	rc = io_queue_submit(m_s_req1);
	assert(rc == 0);

	/* Read slave<-master, part1 */
	s_m_req1 = io_req_create(&ctx->slave, REQ_RD, ctx,
				 on_read_vari_len_req1_1__slave_from_master);
	s_m_req1->buf = (struct io_buf){
		.iov[0] = {
			.iov_base = NULL,
			.iov_len  = 0
		},
		.iov_num  = 1,
		.is_vari_len = true
	};
	rc = io_queue_submit(s_m_req1);
	assert(rc == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp            # imm = 0x2C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0x1, %esi
leaq 0x36d(%rip), %rcx       # 0x1ec0
callq 0x4e10
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1b65
jmp 0x1b84
leaq 0x6576(%rip), %rdi      # 0x80e2
leaq 0x64bf(%rip), %rsi      # 0x8032
movl $0x11f, %edx            # imm = 0x11F
leaq 0x6688(%rip), %rcx      # 0x8207
callq 0x1090
movq -0x18(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x2b8(%rbp)
leaq -0x168(%rbp), %rdi
xorl %esi, %esi
movl $0x148, %edx            # imm = 0x148
callq 0x10a0
leaq -0x168(%rbp), %rdi
leaq 0x9f44(%rip), %rsi      # 0xbaf8
movl $0x100, %edx            # imm = 0x100
callq 0x1140
movq -0x2b8(%rbp), %rdi
movq $0x2, -0x48(%rbp)
movb $0x0, -0x40(%rbp)
leaq -0x168(%rbp), %rsi
movl $0x148, %edx            # imm = 0x148
callq 0x1140
movq -0x18(%rbp), %rdi
callq 0x4950
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x1bf6
jmp 0x1c15
leaq 0x64dd(%rip), %rdi      # 0x80da
leaq 0x642e(%rip), %rsi      # 0x8032
movl $0x12d, %edx            # imm = 0x12D
leaq 0x65f7(%rip), %rcx      # 0x8207
callq 0x1090
movq -0x8(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
movq -0x8(%rbp), %rdx
xorl %esi, %esi
leaq 0x3c3(%rip), %rcx       # 0x1ff0
callq 0x4e10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x2c0(%rbp)
leaq -0x2b0(%rbp), %rdi
xorl %esi, %esi
movl $0x148, %edx            # imm = 0x148
callq 0x10a0
movq -0x2c0(%rbp), %rdi
movq $0x1, -0x190(%rbp)
movb $0x1, -0x188(%rbp)
leaq -0x2b0(%rbp), %rsi
movl $0x148, %edx            # imm = 0x148
callq 0x1140
movq -0x20(%rbp), %rdi
callq 0x4950
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x1c96
jmp 0x1cb5
leaq 0x643d(%rip), %rdi      # 0x80da
leaq 0x638e(%rip), %rsi      # 0x8032
movl $0x13b, %edx            # imm = 0x13B
leaq 0x6557(%rip), %rcx      # 0x8207
callq 0x1090
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rouming[P]io/io-test.c
// Function: do_vari_len_req2
static void do_vari_len_req2(struct loop_ctx *ctx)
{
	int rc;
	struct io_req *s_m_req;

	/*
	 * Here we test, that on the previous action
	 * something was stashed and here we submit
	 * new read request out of the IO loop, i.e.
	 * prewait actions should be called.
	 */

	/* Read slave<-master, reuse callback from do_vari_len_req1 */
	s_m_req = io_req_create(&ctx->slave, REQ_RD, ctx,
				on_read_vari_len_req2__slave_from_master);
	s_m_req->buf = (struct io_buf){
		.iov[0] = {
			.iov_base = NULL,
			.iov_len  = 0
		},
		.iov_num  = 1,
		.is_vari_len = true
	};
	rc = io_queue_submit(s_m_req);
	assert(rc == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
movq -0x8(%rbp), %rdx
xorl %esi, %esi
leaq 0x759(%rip), %rcx       # 0x2440
callq 0x4e10
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x168(%rbp)
leaq -0x160(%rbp), %rdi
xorl %esi, %esi
movl $0x148, %edx            # imm = 0x148
callq 0x10a0
movq -0x168(%rbp), %rdi
movq $0x1, -0x40(%rbp)
movb $0x1, -0x38(%rbp)
leaq -0x160(%rbp), %rsi
movl $0x148, %edx            # imm = 0x148
callq 0x1140
movq -0x18(%rbp), %rdi
callq 0x4950
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x1d4a
jmp 0x1d69
leaq 0x6389(%rip), %rdi      # 0x80da
leaq 0x62da(%rip), %rsi      # 0x8032
movl $0x170, %edx            # imm = 0x170
leaq 0x66dc(%rip), %rcx      # 0x8440
callq 0x1090
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopw %cs:(%rax,%rax)