LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/xcrun.c
// Function: search_command
static int search_command(char *buf, const char *name, char *dirs)
{
	char *cmd_search_path;
	char cmd_absl_path[PATH_MAX] = { 0 };

	/* Search each path entry in dirs until we find our program. */
	cmd_search_path = strtok(dirs, ":");
	while (cmd_search_path != NULL) {
		verbose_printf(stdout, "xcrun: info: checking directory \'%s\' for command \'%s\'...\n", cmd_search_path, name);

		/* Construct our program's absolute path. */
		sprintf(cmd_absl_path, "%s/%s", cmd_search_path, name);

		/* Does it exist? Is it an executable? */
		if (access(cmd_absl_path, (F_OK | X_OK)) == 0) {
			verbose_printf(stdout, "xcrun: info: found command's absolute path: \'%s\'\n", cmd_absl_path);
			strncpy(buf, cmd_absl_path, strlen(cmd_absl_path));
			return 0;
		}

		/* If not, move onto the next entry.. */
		memset(cmd_absl_path, 0, PATH_MAX);
		cmd_search_path = strtok(NULL, ":");
	}

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1040, %rsp           # imm = 0x1040
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x1030(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20c0
movq -0x20(%rbp), %rdi
leaq 0x1329(%rip), %rsi      # 0x5b9e
callq 0x2190
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x496b
movq 0x3738(%rip), %rax      # 0x7fc8
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x135c(%rip), %rsi      # 0x5bfe
movb $0x0, %al
callq 0x3c00
leaq -0x1030(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x1379(%rip), %rsi      # 0x5c38
movb $0x0, %al
callq 0x21c0
leaq -0x1030(%rbp), %rdi
movl $0x1, %esi
callq 0x2170
cmpl $0x0, %eax
jne 0x493f
movq 0x36e5(%rip), %rax      # 0x7fc8
movq (%rax), %rdi
leaq -0x1030(%rbp), %rdx
leaq 0x134a(%rip), %rsi      # 0x5c3e
movb $0x0, %al
callq 0x3c00
movq -0x10(%rbp), %rax
movq %rax, -0x1040(%rbp)
leaq -0x1030(%rbp), %rax
movq %rax, -0x1038(%rbp)
leaq -0x1030(%rbp), %rdi
callq 0x2090
movq -0x1040(%rbp), %rdi
movq -0x1038(%rbp), %rsi
movq %rax, %rdx
callq 0x2060
movl $0x0, -0x4(%rbp)
jmp 0x4972
leaq -0x1030(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20c0
xorl %eax, %eax
movl %eax, %edi
leaq 0x1241(%rip), %rsi      # 0x5b9e
callq 0x2190
movq %rax, -0x28(%rbp)
jmp 0x487e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x1040, %rsp           # imm = 0x1040
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/xcrun.c
// Function: logging_printf
static void logging_printf(FILE *fp, const char *str, ...)
{
	va_list args;

	if (logging_mode) {
		va_start(args, str);
		vfprintf(fp, str, args);
		va_end(args);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x4d48
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x45ed(%rip)      # 0x9360
je 0x4dae
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x21a0
leaq -0x30(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingHashTable/ADTMap.c
// Function: map_create
Map map_create(CompareFunc compare, DestroyFunc destroy_key, DestroyFunc destroy_value) {
	// Δεσμεύουμε κατάλληλα τον χώρο που χρειαζόμαστε για το hash table
	Map map = malloc(sizeof(*map));
	map->capacity = prime_sizes[0];
	map->array = malloc(map->capacity * sizeof(struct map_node));

	// Αρχικοποιούμε τους κόμβους που έχουμε σαν διαθέσιμους.
	for (int i = 0; i < map->capacity; i++)
		map->array[i].state = EMPTY;

	map->size = 0;
	map->deleted = 0;
	map->compare = compare;
	map->destroy_key = destroy_key;
	map->destroy_value = destroy_value;

	return map;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x38, %edi
callq 0x2170
movq %rax, -0x20(%rbp)
movl 0x4318(%rip), %ecx      # 0xa150
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movslq 0x8(%rax), %rax
imulq $0x18, %rax, %rdi
callq 0x2170
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x5e91
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x10(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5e61
movq -0x20(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingHashTable/ADTMap.c
// Function: map_remove
bool map_remove(Map map, Pointer key) {
	MapNode node = map_find_node(map, key);
	if (node == MAP_EOF)
		return false;

	// destroy
	if (map->destroy_key != NULL)
		map->destroy_key(node->key);
	if (map->destroy_value != NULL)
		map->destroy_value(node->value);

	// θέτουμε ως "deleted", ώστε να μην διακόπτεται η αναζήτηση, αλλά ταυτόχρονα να γίνεται ομαλά η εισαγωγή
	node->state = DELETED;
	map->deleted++;
	map->size--;

	return true;
}

// 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 0x6300
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x628e
movb $0x0, -0x1(%rbp)
jmp 0x62f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x62aa
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x62c7
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x20(%rbp), %rax
movl $0x2, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingHashTable/ADTMap.c
// Function: map_find_node
MapNode map_find_node(Map map, Pointer key) {
	// Διασχίζουμε τον πίνακα, ξεκινώντας από τη θέση που κάνει hash το key, και για όσο δε βρίσκουμε EMPTY
	for (uint pos = map->hash_function(key) % map->capacity;		// ξεκινώντας από τη θέση που κάνει hash το key
		map->array[pos].state != EMPTY;							// αν φτάσουμε σε EMPTY σταματάμε
		pos = (pos + 1) % map->capacity) {						// linear probing, γυρνώντας στην αρχή όταν φτάσουμε στη τέλος του πίνακα

		// Μόνο σε OCCUPIED θέσεις (όχι DELETED), ελέγχουμε αν το key είναι εδώ
		if (map->array[pos].state == OCCUPIED && map->compare(map->array[pos].key, key) == 0)
			return &map->array[pos];
	}

	return MAP_EOF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divl 0x8(%rcx)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x10(%rax)
je 0x63af
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, 0x10(%rax)
jne 0x6396
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movl -0x1c(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x6396
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x63b7
jmp 0x6398
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divl 0x8(%rcx)
movl %edx, -0x1c(%rbp)
jmp 0x632a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingHashTable/ADTMap.c
// Function: map_find
Pointer map_find(Map map, Pointer key) {
	MapNode node = map_find_node(map, key);
	if (node != MAP_EOF)
		return node->value;
	else
		return NULL;
}

// 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 0x6300
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6406
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x640e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingHashTable/ADTMap.c
// Function: map_destroy
void map_destroy(Map map) {
	for (int i = 0; i < map->capacity; i++) {
		if (map->array[i].state == OCCUPIED) {
			if (map->destroy_key != NULL)
				map->destroy_key(map->array[i].key);
			if (map->destroy_value != NULL)
				map->destroy_value(map->array[i].value);
		}
	}

	free(map->array);
	free(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x651e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, 0x10(%rax)
jne 0x650e
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x64e1
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq -0xc(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x650c
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq -0xc(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rdi
callq *%rax
jmp 0x650e
jmp 0x6510
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6493
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2260
movq -0x8(%rbp), %rdi
callq 0x2260
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingHashTable/ADTMap.c
// Function: map_first
MapNode map_first(Map map) {
	//Ξεκινάμε την επανάληψή μας απο το 1ο στοιχείο, μέχρι να βρούμε κάτι όντως τοποθετημένο
	for (int i = 0; i < map->capacity; i++)
		if (map->array[i].state == OCCUPIED)
			return &map->array[i];

	return MAP_EOF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x6598
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, 0x10(%rax)
jne 0x658b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x65a0
jmp 0x658d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x654f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingHashTable/ADTMap.c
// Function: map_next
MapNode map_next(Map map, MapNode node) {
	// Το node είναι pointer στο i-οστό στοιχείο του array, οπότε node - array == i  (pointer arithmetic!)
	for (int i = node - map->array + 1; i < map->capacity; i++)
		if (map->array[i].state == OCCUPIED)
			return &map->array[i];

	return MAP_EOF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
addq $0x1, %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x6624
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, 0x10(%rax)
jne 0x6617
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x662c
jmp 0x6619
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x65db
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingHashTable/ADTMap.c
// Function: hash_string
uint hash_string(Pointer value) {
	// djb2 hash function, απλή, γρήγορη, και σε γενικές γραμμές αποδοτική
    uint hash = 5381;
    for (char* s = value; *s != '\0'; s++)
		hash = (hash << 5) + hash + *s;			// hash = (hash * 33) + *s. Το foo << 5 είναι γρηγορότερη εκδοχή του foo * 32.
    return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x1505, -0xc(%rbp)     # imm = 0x1505
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x66e6
movl -0xc(%rbp), %eax
shll $0x5, %eax
addl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x66b7
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: init
static void __attribute((constructor(101))) init()
{
	int r;
	D;
	r = emitInit();
	if (r)
		err("init", r);
	else {
		char b[PATH_MAX];
		procPath(b);
		emit('r', b);
	}
	DD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3010, %rsp           # imm = 0x3010
jmp 0x230d
movb $0x0, %al
callq 0x2140
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x232e
movl -0x4(%rbp), %esi
leaq 0x1cd9(%rip), %rdi      # 0x4000
callq 0x2360
jmp 0x234b
leaq -0x2010(%rbp), %rdi
callq 0x2160
leaq -0x2010(%rbp), %rsi
movl $0x72, %edi
callq 0x2370
jmp 0x234d
jmp 0x234f
addq $0x3010, %rsp           # imm = 0x3010
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: term
static void __attribute((destructor(101))) term()
{
	int r;
	r = emitTerm();
	D;
	if (r)
		err("term", r);
	DD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2010, %rsp           # imm = 0x2010
movb $0x0, %al
callq 0x2040
movl %eax, -0x4(%rbp)
jmp 0x23f7
cmpl $0x0, -0x4(%rbp)
je 0x240c
movl -0x4(%rbp), %esi
leaq 0x1bfe(%rip), %rdi      # 0x4005
callq 0x2360
jmp 0x240e
jmp 0x2410
addq $0x2010, %rsp           # imm = 0x2010
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: fopen
FILE *
fopen(const char *p, const char *m)
{
	FILE *r;
	static FILE *(*ofopen)(const char *, const char *) = 0;
	DP;
	R(fopen);
	r = ofopen(p, m);
	if (r)
		emit(strchr(m, 'r') ? 'r' : 'w', p);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x2435
leaq 0x3cec(%rip), %rdi      # 0x6128
leaq 0x1bc7(%rip), %rsi      # 0x400a
callq 0x24a0
movq 0x3cd9(%rip), %rax      # 0x6128
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x248f
movq -0x10(%rbp), %rdi
movl $0x72, %esi
callq 0x20f0
movq %rax, %rcx
movl $0x77, %edi
movl $0x72, %eax
cmpq $0x0, %rcx
cmovnel %eax, %edi
movq -0x8(%rbp), %rsi
callq 0x2370
jmp 0x2491
jmp 0x2493
movq -0x18(%rbp), %rax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: resolv
static void
resolv(void **p, const char *n)
{
	if (!*p) {
		SE;
		*p = dlsym(RTLD_NEXT, n);
		RE;
	}
	assert(*p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x24ee
callq 0x2050
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq $-0x1, %rdi
callq 0x21e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
callq 0x2050
movl -0x18(%rbp), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x24fa
jmp 0x2519
leaq 0x1bb2(%rip), %rdi      # 0x40b3
leaq 0x1bae(%rip), %rsi      # 0x40b6
movl $0x9b, %edx
leaq 0x1bb8(%rip), %rcx      # 0x40cc
callq 0x2130
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: fopen64
FILE *
fopen64(const char *p, const char *m)
{
	FILE *r;
	static FILE *(*ofopen64)(const char *, const char *) = 0;
	DP;
	R(fopen64);
	r = ofopen64(p, m);
	if (r)
		emit(strchr(m, 'r') ? 'r' : 'w', p);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x2535
leaq 0x3bf4(%rip), %rdi      # 0x6130
leaq 0x1acd(%rip), %rsi      # 0x4010
callq 0x24a0
movq 0x3be1(%rip), %rax      # 0x6130
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x258f
movq -0x10(%rbp), %rdi
movl $0x72, %esi
callq 0x20f0
movq %rax, %rcx
movl $0x77, %edi
movl $0x72, %eax
cmpq $0x0, %rcx
cmovnel %eax, %edi
movq -0x8(%rbp), %rsi
callq 0x2370
jmp 0x2591
jmp 0x2593
movq -0x18(%rbp), %rax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: open
int
open(const char *p, int f, mode_t m)
{
	int r;
	static int (*oopen)(const char *, int, mode_t) = 0;
	DP;
	R(open);
	r = oopen(p, f, m);
	if (r >= 0)
		emit(f & wmode ? 'w' : 'r', p);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
jmp 0x25b7
leaq 0x3b7a(%rip), %rdi      # 0x6138
leaq 0x1a46(%rip), %rsi      # 0x400b
callq 0x24a0
movq 0x3b67(%rip), %rax      # 0x6138
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq *%rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x2608
movl -0xc(%rbp), %ecx
andl $0x643, %ecx            # imm = 0x643
movl $0x72, %edi
movl $0x77, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
movq -0x8(%rbp), %rsi
callq 0x2370
jmp 0x260a
jmp 0x260c
movl -0x14(%rbp), %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: open64
int
open64(const char *p, int f, mode_t m)
{
	int r;
	static int (*oopen64)(const char *, int, mode_t) = 0;
	DP;
	R(open64);
	r = oopen64(p, f, m);
	if (r >= 0)
		emit(f & wmode ? 'w' : 'r', p);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
jmp 0x2637
leaq 0x3b02(%rip), %rdi      # 0x6140
leaq 0x19cc(%rip), %rsi      # 0x4011
callq 0x24a0
movq 0x3aef(%rip), %rax      # 0x6140
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq *%rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x2688
movl -0xc(%rbp), %ecx
andl $0x643, %ecx            # imm = 0x643
movl $0x72, %edi
movl $0x77, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
movq -0x8(%rbp), %rsi
callq 0x2370
jmp 0x268a
jmp 0x268c
movl -0x14(%rbp), %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: openat
int
openat(int fd, const char *p, int f, mode_t m)
{
	int r;
	DP;
	static int (*oopenat)(int, const char *, int, mode_t) = 0;
	R(openat);
	r = oopenat(fd, p, f, m);
	if (r >= 0)
		fdemit(f & wmode ? 'w' : 'r', r);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
jmp 0x26ba
leaq 0x3a87(%rip), %rdi      # 0x6148
leaq 0x1950(%rip), %rsi      # 0x4018
callq 0x24a0
movq 0x3a74(%rip), %rax      # 0x6148
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x270d
movl -0x14(%rbp), %ecx
andl $0x643, %ecx            # imm = 0x643
movl $0x72, %edi
movl $0x77, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
movl -0x1c(%rbp), %esi
callq 0x2720
jmp 0x270f
jmp 0x2711
movl -0x1c(%rbp), %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: fdemit
static void
fdemit(int c, int fd)
{
	char ap[PATH_MAX];
	int  ok;
	SE;
	ok = fdpath(fd, ap, sizeof(ap));
	emitOp(c, ok ? ap : 0, 0);
	RE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
callq 0x2050
movl (%rax), %eax
movl %eax, -0x1018(%rbp)
movl -0x8(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x3200
movl %eax, -0x1014(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x101c(%rbp)
cmpl $0x0, -0x1014(%rbp)
je 0x277a
leaq -0x1010(%rbp), %rax
movq %rax, -0x1028(%rbp)
jmp 0x2785
xorl %eax, %eax
movq %rax, -0x1028(%rbp)
jmp 0x2785
movl -0x101c(%rbp), %edi
movq -0x1028(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2120
movl -0x1018(%rbp), %eax
movl %eax, -0x102c(%rbp)
callq 0x2050
movl -0x102c(%rbp), %ecx
movl %ecx, (%rax)
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: openat64
int
openat64(int fd, const char *p, int f, mode_t m)
{
	int r;
	DP;
	static int (*oopenat64)(int, const char *, int, mode_t) = 0;
	R(openat64);
	r = oopenat64(fd, p, f, m);
	if (r >= 0)
		fdemit(f & wmode ? 'w' : 'r', r);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
jmp 0x27da
leaq 0x396f(%rip), %rdi      # 0x6150
leaq 0x1837(%rip), %rsi      # 0x401f
callq 0x24a0
movq 0x395c(%rip), %rax      # 0x6150
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x282d
movl -0x14(%rbp), %ecx
andl $0x643, %ecx            # imm = 0x643
movl $0x72, %edi
movl $0x77, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
movl -0x1c(%rbp), %esi
callq 0x2720
jmp 0x282f
jmp 0x2831
movl -0x1c(%rbp), %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: rename
int
rename(const char *p1, const char *p2)
{
	int   r;
	char  b1[PATH_MAX];
	char *rp1 = realpath(p1, b1);
	static int (*orename)(const char *, const char *) = 0;
	D;
	R(rename);
	r = orename(p1, p2);
	if (!r) {
		char  b2[PATH_MAX];
		char *rp2 = realpath(p2, b2);
		emitOp(rp1 ? 'm' : 'M', rp2, rp1);
	}
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4040, %rsp           # imm = 0x4040
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x1020(%rbp), %rsi
callq 0x2180
movq %rax, -0x1028(%rbp)
jmp 0x286c
leaq 0x38e5(%rip), %rdi      # 0x6158
leaq 0x17ae(%rip), %rsi      # 0x4028
callq 0x24a0
movq 0x38d2(%rip), %rax      # 0x6158
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x28db
movq -0x10(%rbp), %rdi
leaq -0x3030(%rbp), %rsi
callq 0x2180
movq %rax, -0x3038(%rbp)
movq -0x1028(%rbp), %rcx
movl $0x4d, %edi
movl $0x6d, %eax
cmpq $0x0, %rcx
cmovnel %eax, %edi
movq -0x3038(%rbp), %rsi
movq -0x1028(%rbp), %rdx
callq 0x2120
jmp 0x28dd
jmp 0x28df
movl -0x14(%rbp), %eax
addq $0x4040, %rsp           # imm = 0x4040
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: renamex_np
int
renamex_np(const char *p1, const char *p2, unsigned fl)
{
	int   r;
	char  b1[PATH_MAX];
	char *rp1 = realpath(p1, b1);
	static int (*orenamex_np)(const char *, const char *, unsigned) = 0;
	D;
	R(renamex_np);
	r = orenamex_np(p1, p2, fl);
	if (!r) {
		char  b2[PATH_MAX];
		char *rp2 = realpath(p2, b2);
		emitOp(rp1 ? 'm' : 'M', rp2, rp1);
	}
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4040, %rsp           # imm = 0x4040
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x1020(%rbp), %rsi
callq 0x2180
movq %rax, -0x1028(%rbp)
jmp 0x291f
leaq 0x383a(%rip), %rdi      # 0x6160
leaq 0x1702(%rip), %rsi      # 0x402f
callq 0x24a0
movq 0x3827(%rip), %rax      # 0x6160
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x2991
movq -0x10(%rbp), %rdi
leaq -0x3030(%rbp), %rsi
callq 0x2180
movq %rax, -0x3038(%rbp)
movq -0x1028(%rbp), %rcx
movl $0x4d, %edi
movl $0x6d, %eax
cmpq $0x0, %rcx
cmovnel %eax, %edi
movq -0x3038(%rbp), %rsi
movq -0x1028(%rbp), %rdx
callq 0x2120
jmp 0x2993
jmp 0x2995
movl -0x18(%rbp), %eax
addq $0x4040, %rsp           # imm = 0x4040
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: renameat2
int
renameat2(int fd1, const char *p1, int fd2, const char *p2, unsigned fl)
{
	int r;
	D;
	static int (*orenameat2)(
	    int, const char *, int, const char *, unsigned) = 0;
	char b[PATH_MAX];
	R(renameat2);
	realpathat(fd1, p1, b, sizeof(b));
	r = orenameat2(fd1, p1, fd2, p2, fl);
	if (!r)
		atemit('m', fd2, p2, b);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3030, %rsp           # imm = 0x3030
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
jmp 0x29cf
leaq 0x3792(%rip), %rdi      # 0x6168
leaq 0x165d(%rip), %rsi      # 0x403a
callq 0x24a0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x2030(%rbp), %rdx
movl $0x1000, %ecx           # imm = 0x1000
callq 0x2a50
movq 0x3767(%rip), %rax      # 0x6168
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
callq *%rax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x2a36
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq -0x2030(%rbp), %rcx
movl $0x6d, %edi
callq 0x2b20
jmp 0x2a38
jmp 0x2a3a
movl -0x28(%rbp), %eax
addq $0x3030, %rsp           # imm = 0x3030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: realpathat
static char *
realpathat(int ifd, const char *p, char *ap, size_t sz)
{
	int f;
	int ok;
	int fd;
	int cur = ifd == AT_FDCWD;
	static int (*oopenat)(int, const char *, int, mode_t) = 0;
	R(openat);
	if (cur)
		fd = oopenat(AT_FDCWD, ".", O_RDONLY, 0);
	else
		fd = ifd;
	f = oopenat(fd, p, O_RDONLY, 0);
	ok = fdpath(f, ap, sz);
	close(f);
	if (cur)
		close(fd);
	return ok ? ap : NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $-0x64, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x30(%rbp)
leaq 0x375b(%rip), %rdi      # 0x61d8
leaq 0x1594(%rip), %rsi      # 0x4018
callq 0x24a0
cmpl $0x0, -0x30(%rbp)
je 0x2aaa
movl $0xffffff9c, %edi       # imm = 0xFFFFFF9C
leaq 0x1665(%rip), %rsi      # 0x4100
xorl %ecx, %ecx
movl %ecx, %edx
callq *0x3733(%rip)           # 0x61d8
movl %eax, -0x2c(%rbp)
jmp 0x2ab0
movl -0x4(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq 0x3721(%rip), %rax      # 0x61d8
movl -0x2c(%rbp), %edi
movq -0x10(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq *%rax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3200
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %edi
callq 0x2150
cmpl $0x0, -0x30(%rbp)
je 0x2af0
movl -0x2c(%rbp), %edi
callq 0x2150
cmpl $0x0, -0x28(%rbp)
je 0x2b00
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x2b08
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x2b08
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: renameat
int
renameat(int fd1, const char *p1, int fd2, const char *p2)
{
	int r;
	D;
	static int (*orenameat)(int, const char *, int, const char *) = 0;
	char b[PATH_MAX];
	R(renameat);
	realpathat(fd1, p1, b, sizeof(b));
	r = orenameat(fd1, p1, fd2, p2);
	if (!r)
		atemit('m', fd2, p2, b);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3030, %rsp           # imm = 0x3030
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x2bbb
leaq 0x35ae(%rip), %rdi      # 0x6170
leaq 0x147b(%rip), %rsi      # 0x4044
callq 0x24a0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x2030(%rbp), %rdx
movl $0x1000, %ecx           # imm = 0x1000
callq 0x2a50
movq 0x3583(%rip), %rax      # 0x6170
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x2c1e
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq -0x2030(%rbp), %rcx
movl $0x6d, %edi
callq 0x2b20
jmp 0x2c20
jmp 0x2c22
movl -0x24(%rbp), %eax
addq $0x3030, %rsp           # imm = 0x3030
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: renameatx_np
int
renameatx_np(int fd1, const char *p1, int fd2, const char *p2, unsigned fl)
{
	int  r;
	char b[PATH_MAX];
	D;
	static int (*orenameatx_np)(
	    int, const char *, int, const char *, unsigned) = 0;
	R(renameatx_np);
	realpathat(fd1, p1, b, sizeof(b));
	r = orenameatx_np(fd1, p1, fd2, p2, fl);
	if (!r)
		atemit('m', fd2, p2, b);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3030, %rsp           # imm = 0x3030
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
jmp 0x2c4f
leaq 0x3522(%rip), %rdi      # 0x6178
leaq 0x13f0(%rip), %rsi      # 0x404d
callq 0x24a0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x1030(%rbp), %rdx
movl $0x1000, %ecx           # imm = 0x1000
callq 0x2a50
movq 0x34f7(%rip), %rax      # 0x6178
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
callq *%rax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x2cb6
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq -0x1030(%rbp), %rcx
movl $0x6d, %edi
callq 0x2b20
jmp 0x2cb8
jmp 0x2cba
movl -0x28(%rbp), %eax
addq $0x3030, %rsp           # imm = 0x3030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: unlink
int
unlink(const char *p)
{
	int   r;
	char  b[PATH_MAX];
	char *rp;
	static int (*ounlink)(const char *) = 0;
	DP;
	R(unlink);
	rp = realpath(p, b);
	r = ounlink(p);
	if (!r)
		emitOp('d', rp, 0);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3020, %rsp           # imm = 0x3020
movq %rdi, -0x8(%rbp)
jmp 0x2ce1
leaq 0x3498(%rip), %rdi      # 0x6180
leaq 0x136b(%rip), %rsi      # 0x405a
callq 0x24a0
movq -0x8(%rbp), %rdi
leaq -0x1010(%rbp), %rsi
callq 0x2180
movq %rax, -0x1018(%rbp)
movq 0x346e(%rip), %rax      # 0x6180
movq -0x8(%rbp), %rdi
callq *%rax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x2d36
movq -0x1018(%rbp), %rsi
movl $0x64, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x2120
jmp 0x2d38
jmp 0x2d3a
movl -0xc(%rbp), %eax
addq $0x3020, %rsp           # imm = 0x3020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: unlinkat
int
unlinkat(int fd, const char *p, int f)
{
	int r;
	DP;
	char  b[PATH_MAX];
	char *rp = realpathat(fd, p, b, sizeof(b));
	static int (*ounlinkat)(int, const char *, int);
	R(unlinkat);
	r = ounlinkat(fd, p, f);
	if (!r)
		emitOp(rp ? 'd' : 'D', rp ? rp : p, 0);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3040, %rsp           # imm = 0x3040
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
jmp 0x2d67
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x2020(%rbp), %rdx
movl $0x1000, %ecx           # imm = 0x1000
callq 0x2a50
movq %rax, -0x2028(%rbp)
leaq 0x33fb(%rip), %rdi      # 0x6188
leaq 0x12cd(%rip), %rsi      # 0x4061
callq 0x24a0
movq 0x33e8(%rip), %rax      # 0x6188
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x2e0e
movq -0x2028(%rbp), %rdx
movl $0x44, %eax
movl $0x64, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x3034(%rbp)
cmpq $0x0, -0x2028(%rbp)
je 0x2ded
movq -0x2028(%rbp), %rax
movq %rax, -0x3040(%rbp)
jmp 0x2df8
movq -0x10(%rbp), %rax
movq %rax, -0x3040(%rbp)
movl -0x3034(%rbp), %edi
movq -0x3040(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2120
jmp 0x2e10
jmp 0x2e12
movl -0x18(%rbp), %eax
addq $0x3040, %rsp           # imm = 0x3040
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: futimes
int
futimes(int fd, const struct timeval t[2])
{
	int r;
	static int (*ofutimes)(int, const struct timeval[2]);
	D;
	R(futimes);
	r = ofutimes(fd, t);
	if (!r)
		fdemit('t', fd);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x2e34
leaq 0x3355(%rip), %rdi      # 0x6190
leaq 0x1228(%rip), %rsi      # 0x406a
callq 0x24a0
movq 0x3342(%rip), %rax      # 0x6190
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x2e6d
movl -0x4(%rbp), %esi
movl $0x74, %edi
callq 0x2720
jmp 0x2e6f
jmp 0x2e71
movl -0x14(%rbp), %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: utimes
int
utimes(const char *p, const struct timeval t[2])
{
	int r;
	static int (*outimes)(const char *, const struct timeval[2]);
	DP;
	R(utimes);
	r = outimes(p, t);
	if (!r)
		emit('t', p);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x2e95
leaq 0x32fc(%rip), %rdi      # 0x6198
leaq 0x11c8(%rip), %rsi      # 0x406b
callq 0x24a0
movq 0x32e9(%rip), %rax      # 0x6198
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x2ed0
movq -0x8(%rbp), %rsi
movl $0x74, %edi
callq 0x2370
jmp 0x2ed2
jmp 0x2ed4
movl -0x14(%rbp), %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: _fxstat
int
__fxstat(int v, int fd, struct stat *restrict buf)
{
	int r;
	static int (*o__fxstat)(int, int, struct stat *restrict) = 0;
	D;
	R(__fxstat);
	r = o__fxstat(v, fd, buf);
	if (!r)
		fdemit('q', fd);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
jmp 0x2ef7
leaq 0x32a2(%rip), %rdi      # 0x61a0
leaq 0x116d(%rip), %rsi      # 0x4072
callq 0x24a0
movq 0x328f(%rip), %rax      # 0x61a0
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq *%rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x2f33
movl -0x8(%rbp), %esi
movl $0x71, %edi
callq 0x2720
jmp 0x2f35
jmp 0x2f37
movl -0x14(%rbp), %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: _xstat
int
__xstat(int v, const char *restrict p, struct stat *restrict buf)
{
	int r;
	static int (*o__xstat)(
	    int, const char *restrict, struct stat *restrict) = 0;
	DP;
	R(__xstat);
	r = o__xstat(v, p, buf);
	if (!r)
		emit('q', p);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x2f68
leaq 0x3239(%rip), %rdi      # 0x61a8
leaq 0x1105(%rip), %rsi      # 0x407b
callq 0x24a0
movq 0x3226(%rip), %rax      # 0x61a8
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x2fa6
movq -0x10(%rbp), %rsi
movl $0x71, %edi
callq 0x2370
jmp 0x2fa8
jmp 0x2faa
movl -0x1c(%rbp), %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: _xlstat
int
__xlstat(int v, const char *restrict p, struct stat *restrict buf)
{
	int r;
	static int (*o__xlstat)(
	    int, const char *restrict, struct stat *restrict) = 0;
	DP;
	R(__xlstat);
	r = o__xlstat(v, p, buf);
	if (!r)
		emit('q', p);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x2fd8
leaq 0x31d1(%rip), %rdi      # 0x61b0
leaq 0x109d(%rip), %rsi      # 0x4083
callq 0x24a0
movq 0x31be(%rip), %rax      # 0x61b0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x3016
movq -0x10(%rbp), %rsi
movl $0x71, %edi
callq 0x2370
jmp 0x3018
jmp 0x301a
movl -0x1c(%rbp), %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: _lxstat
int
__lxstat(int v, const char *restrict p, struct stat *restrict buf)
{
	int r;
	static int (*o__lxstat)(
	    int, const char *restrict, struct stat *restrict) = 0;
	DP;
	R(__lxstat);
	r = o__lxstat(v, p, buf);
	if (!r)
		emit('q', p);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x3048
leaq 0x3169(%rip), %rdi      # 0x61b8
leaq 0x1036(%rip), %rsi      # 0x408c
callq 0x24a0
movq 0x3156(%rip), %rax      # 0x61b8
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x3086
movq -0x10(%rbp), %rsi
movl $0x71, %edi
callq 0x2370
jmp 0x3088
jmp 0x308a
movl -0x1c(%rbp), %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: _fxstatat
int
__fxstatat(int v, int fd, const char *p, struct stat *buf, int flag)
{
	int r;
	DP;
	static int (*o__fxstatat)(
	    int, int, const char *, struct stat *restrict, int) = 0;
	R(__fxstatat);
	r = o__fxstatat(v, fd, p, buf, flag);
	if (!r)
		atemit('q', fd, p, NULL);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
jmp 0x30bf
leaq 0x30fa(%rip), %rdi      # 0x61c0
leaq 0xfc8(%rip), %rsi       # 0x4095
callq 0x24a0
movq 0x30e7(%rip), %rax      # 0x61c0
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
callq *%rax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x310b
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
movl $0x71, %edi
xorl %eax, %eax
movl %eax, %ecx
callq 0x2b20
jmp 0x310d
jmp 0x310f
movl -0x20(%rbp), %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: utimensat
int
utimensat(int fd, const char *p, const struct timespec ts[2], int flags)
{
	int r;
	static int (*outimensat)(
	    int, const char *, const struct timespec[2], int);
	DP;
	R(utimensat);
	r = outimensat(fd, p, ts, flags);
	if (!r)
		atemit('t', fd, p, NULL);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
jmp 0x313b
leaq 0x3086(%rip), %rdi      # 0x61c8
leaq 0xf57(%rip), %rsi       # 0x40a0
callq 0x24a0
movq 0x3073(%rip), %rax      # 0x61c8
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq *%rax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x3183
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
movl $0x74, %edi
xorl %eax, %eax
movl %eax, %ecx
callq 0x2b20
jmp 0x3185
jmp 0x3187
movl -0x20(%rbp), %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: futimens
int
futimens(int fd, const struct timespec ts[2])
{
	int r;
	static int (*ofutimens)(int, const struct timespec[2]);
	D;
	R(futimens);
	r = ofutimens(fd, ts);
	if (!r)
		fdemit('t', fd);
	DD;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x31b4
leaq 0x3015(%rip), %rdi      # 0x61d0
leaq 0xee8(%rip), %rsi       # 0x40aa
callq 0x24a0
movq 0x3002(%rip), %rax      # 0x61d0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x31ed
movl -0x4(%rbp), %esi
movl $0x74, %edi
callq 0x2720
jmp 0x31ef
jmp 0x31f1
movl -0x14(%rbp), %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: fdpath
static int
fdpath(int fd, char *ap, size_t sz)
{
	int ok;
#ifdef F_GETPATH
	ok = -1 != fcntl(fd, F_GETPATH, ap);
#else
	ssize_t written;
	char	fdp[100];
	snprintf(fdp, sizeof(fdp), "/proc/self/fd/%d", fd);
	ap[0] = 0;
	written = readlink(fdp, ap, sz);
	ok = written >= 0 && written < sz;
	if (ok)
		ap[written] = 0;
#endif
	if (!ok)
		ap[0] = 0;
	return ok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x90(%rbp), %rdi
movl -0x4(%rbp), %ecx
movl $0x64, %esi
leaq 0xec3(%rip), %rdx       # 0x40ef
movb $0x0, %al
callq 0x2100
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
leaq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x20a0
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x91(%rbp)
jl 0x3272
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x91(%rbp)
movb -0x91(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x3292
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x0, -0x1c(%rbp)
jne 0x329f
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movl -0x1c(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/emit.c
// Function: emitInit
int
emitInit()
{
	const char *out = mygetenv(ENVOUT);
	assert(out);
	assert(!shm.buf);
	return out ? shmInit(&shm, out, LOGSZ, 0) : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe43(%rip), %rdi       # 0x4102
callq 0x3360
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x32d1
jmp 0x32f0
leaq 0xe33(%rip), %rdi       # 0x410b
leaq 0xe30(%rip), %rsi       # 0x410f
movl $0x3b, %edx
leaq 0xe2f(%rip), %rcx       # 0x411a
callq 0x2130
cmpq $0x0, 0x2ee8(%rip)      # 0x61e0
jne 0x32fc
jmp 0x331b
leaq 0xe26(%rip), %rdi       # 0x4129
leaq 0xe05(%rip), %rsi       # 0x410f
movl $0x3c, %edx
leaq 0xe04(%rip), %rcx       # 0x411a
callq 0x2130
cmpq $0x0, -0x8(%rbp)
je 0x333e
movq -0x8(%rbp), %rsi
leaq 0x2eb3(%rip), %rdi      # 0x61e0
movl $0x1000000, %edx        # imm = 0x1000000
xorl %ecx, %ecx
callq 0x2080
movl %eax, -0xc(%rbp)
jmp 0x3348
movl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3348
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/emit.c
// Function: mygetenv
static const char *
mygetenv(const char *v)
{
	const char *out = getenv(v);
	if (!out) {
		extern char **environ;
		size_t	      l = strlen(v);
		char **	      p = environ;
		while (*p) {
			char *s = *p;
			if (0 == strncmp(s, v, l)) {
				if (s[l] == '=') {
					out = s + l + 1;
					break;
				}
			}
			p++;
		}
	}
#ifdef _WIN32
	// Workaround, bash distributed with ghc 8.6.5 seems to discard most
	// environment variables, pass environment variables as the first few
	// PATH components.
	if (!out) {
		const char *path = getenv("PATH");
		if (strcmp(v, ENVOUT) == 0) {
			static char buf[PATH_MAX];
			unsigned    i = 0;
			unsigned    j = 0;
			while (path[i] != ';')
				buf[j++] = path[i++];
			buf[j] = 0;
			out = buf;
		}
	}
#endif
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2030
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x33fe
movq -0x8(%rbp), %rdi
callq 0x20d0
movq %rax, -0x18(%rbp)
movq 0x2c4c(%rip), %rax      # 0x5fe0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x33fc
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2060
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x33ee
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
jne 0x33ec
movq -0x28(%rbp), %rax
addq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x33fc
jmp 0x33ee
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x339b
jmp 0x33fe
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)