LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-s3/s3state.c
// Function: s3state_append
int
s3state_append(struct s3state * S, struct proto_lbs_request * R,
    int (* callback)(void *, struct proto_lbs_request *, uint64_t),
    void * cookie)
{
	struct append_cookie * C;

	/* Bake a cookie. */
	if ((C = malloc(sizeof(struct append_cookie))) == NULL)
		goto err0;
	C->S = S;
	C->R = R;
	C->callback = callback;
	C->cookie = cookie;

	/* Sanity check. */
	assert(R->r.append.blkno % BLKSPEROBJECT == 0);

	/* Send the S3 request. */
	if (proto_s3_request_put(S->Q_S3, S->bucket,
	    objmap(BLK2OBJECT(R->r.append.blkno)),
	    R->r.append.nblks * S->blklen, R->r.append.buf,
	    callback_append, C))
		goto err1;

	/* We will be performing a callback later. */
	S->npending += 1;

	/* Success! */
	return (0);

err1:
	free(C);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x20, %edi
callq 0x2290
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x4231
jmp 0x4324
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
andq $0xffffff, %rax         # imm = 0xFFFFFF
cmpq $0x0, %rax
jne 0x4276
jmp 0x4295
leaq 0x10465(%rip), %rdi     # 0x146e2
leaq 0x103be(%rip), %rsi     # 0x14642
movl $0xe0, %edx
leaq 0x10479(%rip), %rcx     # 0x14709
callq 0x21c0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
shrq $0x18, %rdi
addq $0x1, %rdi
callq 0x5060
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
imull (%rcx), %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %r8
movq -0x30(%rbp), %rax
leaq 0x4e(%rip), %r9         # 0x4340
movq %rax, (%rsp)
callq 0xea80
cmpl $0x0, %eax
je 0x4302
jmp 0x431b
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x432b
movq -0x30(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-s3/s3state.c
// Function: callback_append
static int
callback_append(void * cookie, int failed)
{
	struct append_cookie * C = cookie;
	struct s3state * S = C->S;
	int rc;

	/* If S3 isn't talking to us, we're screwed. */
	if (failed)
		goto err1;

	/* Update the last-block and next-block values based on this append. */
	S->nextblk = C->R->r.append.blkno + BLKSPEROBJECT;
	S->lastblk = C->R->r.append.blkno + C->R->r.append.nblks - 1;

	/* Tell the dispatcher to send its response back. */
	rc = (C->callback)(C->cookie, C->R, S->nextblk);

	/* We've done a callback. */
	S->npending -= 1;

	/* Free our cookie. */
	free(C);

	/* Return status from callback. */
	return (rc);

err1:
	free(C);

	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x436d
jmp 0x43f4
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rcx
addq $0x1000000, %rcx        # imm = 0x1000000
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
addq %rax, %rcx
subq $0x1, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rdx
callq *%rax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rdi
callq 0x2040
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4404
movq -0x20(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-s3/deleteto.c
// Function: deleteto_init
struct deleteto *
deleteto_init(struct wire_requestqueue * Q_S3, const char * bucket)
{
	struct deleteto * D;

	/* Allocate and initialize a DeleteTo structure. */
	if ((D = malloc(sizeof(struct deleteto))) == NULL)
		goto err0;
	D->Q = Q_S3;
	D->N = 0;
	D->npending = 0;
	D->idle = 1;
	D->updateDeletedTo = 0;
	D->shuttingdown = 0;
	if ((D->bucket = strdup(bucket)) == NULL)
		goto err1;

	/* Check if a DeletedMarker exists (if not, we treat it as 1). */
	D->done = 0;
	if (proto_s3_request_head(D->Q, D->bucket, "DeletedMarker",
	    callback_deletedmarker_head, D))
		goto err2;
	if (events_spin(&D->done))
		goto err2;

	/*
	 * If a marker exists, read it.  Eventual consistency is fine here
	 * since at worst we'll get an old marker and re-issue some deletes.
	 */
	if (D->M == 0) {
		D->done = 0;
		if (proto_s3_request_get(D->Q, D->bucket, "DeletedMarker", 8,
		    callback_deletedmarker_get, D))
			goto err2;
		if (events_spin(&D->done))
			goto err2;
	}

	/* Success! */
	return (D);

err2:
	free(D->bucket);
err1:
	free(D);
err0:
	/* Failure! */
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x40, %edi
callq 0x2290
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x44c9
jmp 0x45f3
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x30(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x18(%rbp), %rdi
callq 0x23a0
movq -0x20(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x4529
jmp 0x45ea
movq -0x20(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %r8
leaq 0x10270(%rip), %rdx     # 0x147be
leaq 0xbb(%rip), %rcx        # 0x4610
callq 0xf650
cmpl $0x0, %eax
je 0x4561
jmp 0x45dd
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x6d20
cmpl $0x0, %eax
je 0x4575
jmp 0x45dd
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x45d3
movq -0x20(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %r9
leaq 0x10219(%rip), %rdx     # 0x147be
movl $0x8, %ecx
leaq 0x11f(%rip), %r8        # 0x46d0
callq 0xee30
cmpl $0x0, %eax
je 0x45bd
jmp 0x45dd
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x6d20
cmpl $0x0, %eax
je 0x45d1
jmp 0x45dd
jmp 0x45d3
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x45fb
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq -0x20(%rbp), %rdi
callq 0x2040
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/Tarsnap[P]kivaloo/lbs-s3/deleteto.c
// Function: callback_deletedmarker_head
static int
callback_deletedmarker_head(void * cookie, int status, size_t len)
{
	struct deleteto * D = cookie;

	/* If we've got a 404, DeletedMarker is initialized to 1. */
	if (status == 404) {
		D->M = 1;
	} else if (status == 200) {
		/* If we have a 200, the length should be 8. */
		if (len != 8) {
			warn0("DeletedMarker has incorrect size: %zu", len);
			goto err0;
		}

		/* Set to 0 to mean "read the value". */
		D->M = 0;
	} else {
		warn0("Unexpected HEAD response code from S3: %d", status);
		goto err0;
	}

	/* We're done. */
	D->done = 1;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x194, -0x14(%rbp)     # imm = 0x194
jne 0x4642
movq -0x28(%rbp), %rax
movq $0x1, 0x18(%rax)
jmp 0x46a3
cmpl $0xc8, -0x14(%rbp)
jne 0x4681
cmpq $0x8, -0x20(%rbp)
je 0x4673
jmp 0x4654
movq -0x20(%rbp), %rsi
leaq 0x1016d(%rip), %rdi     # 0x147cc
movb $0x0, %al
callq 0xe050
callq 0x20a0
movl $0x0, (%rax)
jmp 0x46b7
movq -0x28(%rbp), %rax
movq $0x0, 0x18(%rax)
jmp 0x46a1
jmp 0x4683
movl -0x14(%rbp), %esi
leaq 0x10165(%rip), %rdi     # 0x147f2
movb $0x0, %al
callq 0xe050
callq 0x20a0
movl $0x0, (%rax)
jmp 0x46b7
jmp 0x46a3
movq -0x28(%rbp), %rax
movl $0x1, 0x20(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x46be
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-s3/deleteto.c
// Function: callback_deletedmarker_get
static int
callback_deletedmarker_get(void * cookie, int failed,
    size_t len, const uint8_t * buf)
{
	struct deleteto * D = cookie;

	/* If we failed to read the file, die. */
	if (failed) {
		warn0("Could not read DeletedMarker from S3");
		goto err0;
	}

	/* We should have 8 bytes. */
	if (len != 8) {
		warn0("DeletedMarker has incorrect size: %zu", len);
		goto err0;
	}

	/* Parse the value. */
	D->M = be64dec(buf);

	/* We're done. */
	D->done = 1;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x4712
jmp 0x46f7
leaq 0x1011e(%rip), %rdi     # 0x1481c
movb $0x0, %al
callq 0xe050
callq 0x20a0
movl $0x0, (%rax)
jmp 0x4762
cmpq $0x8, -0x20(%rbp)
je 0x473a
jmp 0x471b
movq -0x20(%rbp), %rsi
leaq 0x100a6(%rip), %rdi     # 0x147cc
movb $0x0, %al
callq 0xe050
callq 0x20a0
movl $0x0, (%rax)
jmp 0x4762
movq -0x28(%rbp), %rdi
callq 0x4b00
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rax
movl $0x1, 0x20(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x4769
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-s3/deleteto.c
// Function: deleteto_stop
int
deleteto_stop(struct deleteto * D)
{
	int rc;

	/* We don't want to do any more DELETEs, just shut down. */
	D->shuttingdown = 1;

	/* Wait for S3 operations to finish. */
	rc = events_spin(&D->idle);

	/* Free the DeleteTo structure. */
	free(D->bucket);
	free(D);

	/* Return status from events_spin. */
	return (rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x6d20
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x2040
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-s3/deleteto.c
// Function: callback_done
static int
callback_done(void * cookie, int failed)
{
	struct deleteto * D = cookie;

	/* Sanity-checks. */
	assert(D->idle == 0);
	assert(D->npending > 0);

	/* Failures are bad, m'kay? */
	if (failed)
		goto err0;

	/* We've finished an operation. */
	D->npending -= 1;

	/* Have we finished all of them? */
	if (D->npending == 0) {
		D->idle = 1;
		if (poke(D))
			goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x4c83
jmp 0x4ca2
leaq 0xfbde(%rip), %rdi      # 0x14868
leaq 0xfbb0(%rip), %rsi      # 0x14841
movl $0x106, %edx            # imm = 0x106
leaq 0xfbd8(%rip), %rcx      # 0x14875
callq 0x21c0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jbe 0x4caf
jmp 0x4cce
leaq 0xfbde(%rip), %rdi      # 0x14894
leaq 0xfb84(%rip), %rsi      # 0x14841
movl $0x107, %edx            # imm = 0x107
leaq 0xfbac(%rip), %rcx      # 0x14875
callq 0x21c0
cmpl $0x0, -0x14(%rbp)
je 0x4cd6
jmp 0x4d17
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x4d0e
movq -0x20(%rbp), %rax
movl $0x1, 0x30(%rax)
movq -0x20(%rbp), %rdi
callq 0x47c0
cmpl $0x0, %eax
je 0x4d0c
jmp 0x4d17
jmp 0x4d0e
movl $0x0, -0x4(%rbp)
jmp 0x4d1e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-s3/findlast.c
// Function: head
static int
head(struct wire_requestqueue * Q_S3, const char * bucket, uint64_t N,
    int * status, size_t * clen)
{
	struct headdata hd;

	/* Issue a HEAD request. */
	hd.done = 0;
	if (proto_s3_request_head(Q_S3, bucket, objmap(N), callback_head, &hd))
		goto err1;

	/* Wait for the request to finish. */
	if (events_spin(&hd.done))
		goto err1;

	/* If the status is 0, we failed. */
	if (status == 0)
		goto err1;

	/* Return results. */
	*status = hd.status;
	*clen = hd.clen;

	/* Success! */
	return (0);

err1:
	warnp("Error issuing HEAD request");

	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5060
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
leaq 0x92(%rip), %rcx        # 0x5020
leaq -0x40(%rbp), %r8
callq 0xf650
cmpl $0x0, %eax
je 0x4f9e
jmp 0x4fd4
leaq -0x40(%rbp), %rdi
callq 0x6d20
cmpl $0x0, %eax
je 0x4fae
jmp 0x4fd4
cmpq $0x0, -0x28(%rbp)
jne 0x4fb7
jmp 0x4fd4
movl -0x3c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x5012
jmp 0x4fd6
callq 0x20a0
cmpl $0x0, (%rax)
je 0x4ffb
leaq 0xf8f6(%rip), %rdi      # 0x148dd
movb $0x0, %al
callq 0xde00
callq 0x20a0
movl $0x0, (%rax)
jmp 0x5009
leaq 0xf8db(%rip), %rdi      # 0x148dd
movb $0x0, %al
callq 0xe050
jmp 0x500b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-s3/findlast.c
// Function: callback_head
static int
callback_head(void * cookie, int status, size_t len)
{
	struct headdata * hd = cookie;

	/* Record callback data. */
	hd->status = status;
	hd->clen = len;

	/* This request is done. */
	hd->done = 1;

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-s3/objmap.c
// Function: objmap
const char *
objmap(uint64_t N)
{
	uint8_t Nbuf[8];
	uint8_t hbuf[16];
	static char oname[22]; /* HASH_0123456789012345 */

	/* Serialize the value N. */
	be64enc(Nbuf, N);

	/* Hash the (serialized) value. */
	MD5_Buf(Nbuf, 8, hbuf);

	/* Hexify the first two bytes of hash. */
	hexify(hbuf, &oname[0], 2);

	/* Separator character. */
	oname[4] = '_';

	/* Hexify the 8-byte integer. */
	hexify(Nbuf, &oname[5], 8);

	/* NUL-terminate. */
	oname[21] = '\0';

	/* Return the constructed string. */
	return (oname);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x50e0
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rdx
movl $0x8, %esi
callq 0x66b0
leaq -0x20(%rbp), %rdi
leaq 0x165ba(%rip), %rsi     # 0x1b650
movl $0x2, %edx
callq 0xb6b0
movb $0x5f, 0x165ad(%rip)    # 0x1b654
leaq -0x10(%rbp), %rdi
leaq 0x1659e(%rip), %rsi     # 0x1b650
addq $0x5, %rsi
movl $0x8, %edx
callq 0xb6b0
movb $0x0, 0x1659e(%rip)     # 0x1b665
leaq 0x16582(%rip), %rax     # 0x1b650
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/trumabrat[P]GrandProjet/chaineMain.c
// Function: main
int main()
{
    /* 
        lecture et creation d'une instance de Chaines
        on peut decommenter pour choisir l'instance qu'on va verifier
    */

    // FILE* f = fopen("00014_burma.cha", "r");
    // FILE* f = fopen("05000_USA-road-d-NY.cha", "r");
    FILE* f = fopen("07397_pla.cha", "r");
    // FILE* f = fopen("test.cha", "r");
    
    // FILE *f2 = fopen("00014_burma_res.txt", "w");
    // FILE* f2 = fopen("05000_USA-road-d-NY_res.txt", "w");
    FILE* f2 = fopen("07397_pla.cha_res", "w");
    // FILE* f2 = fopen("test_res.cha", "w");
    Chaines *c = lectureChaines(f);
    ecrireChaines(c, f2);

    // affichage de cette Chaines
    afficheChainesSVG(c, "Chaines");
    printf("LongueurTotal = %lf, nombre de points = %d\n", longueurTotale(c), comptePointsTotal(c));

    // fermeture des fichiers et liberation
    liberer_chaines(c);
    fclose(f);
    fclose(f2);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xdde(%rip), %rdi       # 0x2004
leaq 0xde5(%rip), %rsi       # 0x2012
callq 0x10c0
movq %rax, -0x10(%rbp)
leaq 0xdd7(%rip), %rdi       # 0x2014
leaq 0xde2(%rip), %rsi       # 0x2026
callq 0x10c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1450
movq -0x20(%rbp), %rdi
leaq 0xdb6(%rip), %rsi       # 0x2028
callq 0x1580
movq -0x20(%rbp), %rdi
callq 0x19c0
movsd %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1a20
movsd -0x28(%rbp), %xmm0
movl %eax, %esi
leaq 0xd94(%rip), %rdi       # 0x2030
movb $0x1, %al
callq 0x1080
movq -0x20(%rbp), %rdi
callq 0x1b20
movq -0x10(%rbp), %rdi
callq 0x1070
movq -0x18(%rbp), %rdi
callq 0x1070
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_01/buffered.c
// Function: main
int main(void)
{
	int n;
	char buf[DATA_SIZE];

	memset(buf, 0, DATA_SIZE);
	for (n = 0; n < DATA_SIZE; n++)
		if (fputc(buf[n], stdout) != buf[n]) {
			err("write error\n");
			break;
		}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20010, %rsp          # imm = 0x20010
movl $0x0, -0x4(%rbp)
leaq -0x20010(%rbp), %rdi
xorl %esi, %esi
movl $0x20000, %edx          # imm = 0x20000
callq 0x1040
movl $0x0, -0x8(%rbp)
cmpl $0x20000, -0x8(%rbp)    # imm = 0x20000
jge 0x11e5
movslq -0x8(%rbp), %rax
movsbl -0x20010(%rbp,%rax), %edi
movq 0x2e30(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1050
movslq -0x8(%rbp), %rcx
movsbl -0x20010(%rbp,%rcx), %ecx
cmpl %ecx, %eax
je 0x11d8
movq 0x2e31(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xe33(%rip), %rdi       # 0x2004
callq 0x1030
jmp 0x11e5
jmp 0x11da
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x118c
xorl %eax, %eax
addq $0x20010, %rsp          # imm = 0x20010
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: setfullscreen
void setfullscreen(client *c, bool fullscrn)
{
    DEBUGP("xcb: set fullscreen: %d\n", fullscrn);

    if (fullscrn) {
        long data[] = { ewmh->_NET_WM_STATE_FULLSCREEN };
        c->isfullscreen = True;
        xcb_border_width(dis, c->win, 0);
        xcb_move_resize(dis, c->win, 0, 0, screen->width_in_pixels, screen->height_in_pixels, &c->position_info);
        xcb_change_property(dis, XCB_PROP_MODE_REPLACE,
                            c->win, ewmh->_NET_WM_STATE,
                            XCB_ATOM_ATOM, 32, True, data);
        create_display(c);
    }
    else {
        c->isfullscreen = False;
        xcb_border_width(dis, c->win, BORDER_WIDTH);
        xcb_remove_property(dis, c->win, ewmh->_NET_WM_STATE, ewmh->_NET_WM_STATE_FULLSCREEN);
        destroy_display(c);
    }
    update_current(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x3c23
movq 0x9c43(%rip), %rax      # 0xd7b8
movl 0x128(%rax), %eax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x1b(%rax)
movq 0x9c12(%rip), %rdi      # 0xd7a0
movq -0x8(%rbp), %rax
movl 0x20(%rax), %esi
xorl %edx, %edx
callq 0x3c90
movq 0x9bfd(%rip), %rdi      # 0xd7a0
movq -0x8(%rbp), %rax
movl 0x20(%rax), %esi
movq 0x9c0f(%rip), %rax      # 0xd7c0
movzwl 0x14(%rax), %r8d
movq 0x9c03(%rip), %rax      # 0xd7c0
movzwl 0x16(%rax), %r9d
movq -0x8(%rbp), %rax
addq $0x30, %rax
xorl %ecx, %ecx
movl %ecx, %edx
movq %rax, (%rsp)
callq 0x3cd0
movq 0x9bc2(%rip), %rdi      # 0xd7a0
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edx
movq 0x9bcc(%rip), %rax      # 0xd7b8
movl 0x84(%rax), %ecx
leaq -0x18(%rbp), %rax
xorl %esi, %esi
movl $0x4, %r8d
movl $0x20, %r9d
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x35d0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3d60
jmp 0x3c76
movq -0x8(%rbp), %rax
movb $0x0, 0x1b(%rax)
movq 0x9b6e(%rip), %rdi      # 0xd7a0
movq -0x8(%rbp), %rax
movl 0x20(%rax), %esi
xorl %edx, %edx
callq 0x3c90
movq 0x9b59(%rip), %rdi      # 0xd7a0
movq -0x8(%rbp), %rax
movl 0x20(%rax), %esi
movq 0x9b63(%rip), %rax      # 0xd7b8
movl 0x84(%rax), %edx
movq 0x9b56(%rip), %rax      # 0xd7b8
movl 0x128(%rax), %ecx
callq 0x3800
movq -0x8(%rbp), %rdi
callq 0x3ef0
movq -0x8(%rbp), %rdi
callq 0x4010
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: xcb_move_resize
static inline void xcb_move_resize(xcb_connection_t *con, xcb_window_t win, int x, int y, int w, int h, posxy_t *pi)
{
    unsigned int pos[4] = { x, y, w, h };

    if (pi) {
        pi->previous_x = pi->current_x;
        pi->previous_y = pi->current_y;
        pi->current_x = x;
        pi->current_y = y;
    }
    xcb_configure_window(con, win, XCB_MOVE_RESIZE, pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpq $0x0, 0x10(%rbp)
je 0x3d3f
movq 0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq 0x10(%rbp), %rax
movl %ecx, (%rax)
movq 0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq 0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x10(%rbp), %ecx
movq 0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq 0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x30(%rbp), %rcx
movl $0xf, %edx
callq 0x32c0
movl %eax, -0x34(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: destroy_display
static void destroy_display(client *c)
{
    desktop *desk=NULL;
    monitor *moni=NULL;
    display *disp=NULL, *next;

    getparents(c, &disp, &moni, &desk);     /* get the client's display, monitor and desktop. */
    if (!(next = (display *)get_next(&disp->link)))     /* cannot destroy the last display. */
        return;
    for (client *t = (client *)rem_head(&disp->clients); t; t = (client *)rem_head(&disp->clients)) {
    /* relink entire clientlist to the tail of next display clientlist. */
        add_tail(&next->clients, &t->link);
    }
    rem_node(&disp->link);                   /* unlink now empty display */
    select_desktop(current_desktop_number);     /* update global pointers */
    for (alien *t = (alien *)get_head(&aliens); t; t = (alien *)get_next(&t->link))   /* show aliens */
        xcb_move(dis, t->win, t->position_info.previous_x, t->position_info.previous_y, &t->position_info);
    if (current_display == next) {
        update_current(c);
    }
    free(disp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x10(%rbp), %rcx
callq 0x5260
movq -0x20(%rbp), %rdi
callq 0x5490
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x3f41
jmp 0x3fff
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x5660
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3f7d
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq -0x30(%rbp), %rsi
callq 0x56a0
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x5660
movq %rax, -0x30(%rbp)
jmp 0x3f52
movq -0x20(%rbp), %rdi
callq 0x5300
movl 0x986c(%rip), %edi      # 0xd7f8
callq 0x5570
leaq 0x9848(%rip), %rdi      # 0xd7e0
callq 0x54c0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x3fe0
movq 0x97f1(%rip), %rdi      # 0xd7a0
movq -0x38(%rbp), %rax
movl 0x18(%rax), %esi
movq -0x38(%rbp), %rax
movl 0x20(%rax), %edx
movq -0x38(%rbp), %rax
movl 0x24(%rax), %ecx
movq -0x38(%rbp), %r8
addq $0x20, %r8
callq 0x5410
movq -0x38(%rbp), %rdi
callq 0x5490
movq %rax, -0x38(%rbp)
jmp 0x3fa1
movq 0x97e9(%rip), %rax      # 0xd7d0
cmpq -0x28(%rbp), %rax
jne 0x3ff6
movq -0x8(%rbp), %rdi
callq 0x4010
movq -0x20(%rbp), %rdi
callq 0x3050
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: main
int main(int argc, char *argv[])
{
    setvbuf(stdout, NULL, _IOLBF, 0);
    setvbuf(stderr, NULL, _IOLBF, 0);
    if (argc == 2 && argv[1][0] == '-') switch (argv[1][1]) {
        case 'v':
            errx(EXIT_SUCCESS,
            "mmWM - by kaugm (a million thanks to sulami and FrankenWM)");
        case 'h':
            errx(EXIT_SUCCESS, "%s", USAGE);
        default:
            errx(EXIT_FAILURE, "%s", USAGE);
    } else if (argc != 1) {
        errx(EXIT_FAILURE, "%s", USAGE);
    }
    if (xcb_connection_has_error((dis = xcb_connect(NULL, &default_screen))))
        errx(EXIT_FAILURE, "error: cannot open display\n");
    DEBUG("connected to display");
    if (setup(default_screen) != -1) {
        desktopinfo(); /* zero out every desktop on (re)start */
        run();
    }
    cleanup();
    xcb_aux_sync(dis);
    xcb_disconnect(dis);
    ungrab_focus();
    return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x8bcb(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %ecx
movl $0x1, %edx
movq %rcx, %rsi
callq 0x34a0
movq 0x8bd0(%rip), %rax      # 0xcff8
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %ecx
movl $0x1, %edx
movq %rcx, %rsi
callq 0x34a0
cmpl $0x2, -0x8(%rbp)
jne 0x44b3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x44b3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl 0x1(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x68, %eax
je 0x4482
jmp 0x4468
movl -0x14(%rbp), %eax
subl $0x76, %eax
jne 0x4499
jmp 0x4472
xorl %edi, %edi
leaq 0x5bfd(%rip), %rsi      # 0xa078
movb $0x0, %al
callq 0x31b0
xorl %edi, %edi
leaq 0x5dee(%rip), %rsi      # 0xa279
leaq 0x5c21(%rip), %rdx      # 0xa0b3
movb $0x0, %al
callq 0x31b0
movl $0x1, %edi
leaq 0x5dd4(%rip), %rsi      # 0xa279
leaq 0x5c07(%rip), %rdx      # 0xa0b3
movb $0x0, %al
callq 0x31b0
cmpl $0x1, -0x8(%rbp)
je 0x44d3
movl $0x1, %edi
leaq 0x5db4(%rip), %rsi      # 0xa279
leaq 0x5be7(%rip), %rdx      # 0xa0b3
movb $0x0, %al
callq 0x31b0
jmp 0x44d5
xorl %eax, %eax
movl %eax, %edi
leaq 0x92e8(%rip), %rsi      # 0xd7c8
callq 0x3120
movq %rax, %rdi
movq %rdi, 0x92b1(%rip)      # 0xd7a0
callq 0x3520
cmpl $0x0, %eax
je 0x450c
movl $0x1, %edi
leaq 0x5bc4(%rip), %rsi      # 0xa0c9
movb $0x0, %al
callq 0x31b0
movl 0x92b6(%rip), %edi      # 0xd7c8
callq 0x4560
cmpl $-0x1, %eax
je 0x4526
callq 0x4f80
callq 0x50e0
callq 0x5190
movq 0x926e(%rip), %rdi      # 0xd7a0
callq 0x30e0
movq 0x9262(%rip), %rdi      # 0xd7a0
callq 0x3510
callq 0x5220
movl 0x927e(%rip), %eax      # 0xd7cc
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: desktopinfo
void desktopinfo(void)
{
#ifndef EWMH_TASKBAR
    bool urgent = false;
    int cd = current_desktop_number, n = 0, d = 0;
    xcb_get_property_cookie_t cookie;
    xcb_ewmh_get_utf8_strings_reply_t wtitle;
    wtitle.strings = NULL;

    if (M_CURRENT) {
        cookie = xcb_ewmh_get_wm_name_unchecked(ewmh, M_CURRENT->win);
        xcb_ewmh_get_wm_name_reply(ewmh, cookie, &wtitle, (void *)0);
    }

    for (client *c; d < DESKTOPS; d++) {
        for (select_desktop(d), c = M_HEAD, n = 0, urgent = false;
             c; c = M_GETNEXT(c), ++n)
            if (c->isurgent)
                urgent = true;
        fprintf(stdout, "%d:%d:%d:%d:%d ", d, n, M_MODE, current_desktop_number == cd,
                urgent);
    }

    if (wtitle.strings) {
        xcb_ewmh_get_utf8_strings_reply_wipe(&wtitle);
    }

    fflush(stdout);
    if (cd != d - 1)
        select_desktop(cd);
#else
    Update_EWMH_Taskbar_Properties();
#endif /* EWMH_TASKBAR */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb $0x0, -0x1(%rbp)
movl 0x8866(%rip), %eax      # 0xd7f8
movl %eax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq 0x881e(%rip), %rax      # 0xd7d0
cmpq $0x0, 0x30(%rax)
je 0x4ff3
movq 0x87f8(%rip), %rdi      # 0xd7b8
movq 0x8809(%rip), %rax      # 0xd7d0
movq 0x30(%rax), %rax
movl 0x20(%rax), %esi
callq 0x3470
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x14(%rbp)
movq 0x87d5(%rip), %rdi      # 0xd7b8
movl -0x14(%rbp), %esi
leaq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x9250
jmp 0x4ff5
cmpl $0xa, -0x10(%rbp)
jge 0x50a4
movl -0x10(%rbp), %edi
callq 0x5570
movq 0x87c2(%rip), %rax      # 0xd7d0
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0xc(%rbp)
movb $0x0, -0x1(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x5050
movq -0x40(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0x5036
movb $0x1, -0x1(%rbp)
jmp 0x5038
movq -0x40(%rbp), %rdi
callq 0x5490
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5021
movq 0x7f81(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
movl -0x10(%rbp), %edx
movl -0xc(%rbp), %ecx
movq 0x8769(%rip), %rax      # 0xd7d0
movl 0x5c(%rax), %r8d
movl 0x8787(%rip), %eax      # 0xd7f8
cmpl -0x8(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %r9d
movb -0x1(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
leaq 0x53cf(%rip), %rsi      # 0xa45b
movl %eax, (%rsp)
movb $0x0, %al
callq 0x3380
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4ff5
cmpq $0x0, -0x28(%rbp)
je 0x50b4
leaq -0x30(%rbp), %rdi
callq 0x35c0
movq 0x7f1d(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
callq 0x3410
movl -0x8(%rbp), %eax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x50d8
movl -0x8(%rbp), %edi
callq 0x5570
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: run
void run(void)
{
    xcb_generic_event_t *ev;

    while(running) {
        xcb_flush(dis);
        if (xcb_connection_has_error(dis))
            err(EXIT_FAILURE, "error: X11 connection got interrupted\n");
        if ((ev = xcb_wait_for_event(dis))) {
            if (events[ev->response_type & ~0x80]) {
                events[ev->response_type & ~0x80](ev);
            } else {
                DEBUGP("xcb: unimplemented event: %s\n", xcb_event_str(ev));
            }
            free(ev);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb $0x1, 0x85d9(%rip)      # 0xd6c8
je 0x518a
movq 0x86a4(%rip), %rdi      # 0xd7a0
callq 0x3190
movq 0x8698(%rip), %rdi      # 0xd7a0
callq 0x3520
cmpl $0x0, %eax
je 0x5125
movl $0x1, %edi
leaq 0x534d(%rip), %rsi      # 0xa46b
movb $0x0, %al
callq 0x3400
movq 0x8674(%rip), %rdi      # 0xd7a0
callq 0x34e0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x5185
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0xffffff7f, %eax       # imm = 0xFFFFFF7F
movslq %eax, %rcx
leaq 0x86ff(%rip), %rax      # 0xd850
cmpq $0x0, (%rax,%rcx,8)
je 0x517a
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0xffffff7f, %eax       # imm = 0xFFFFFF7F
movslq %eax, %rcx
leaq 0x86e2(%rip), %rax      # 0xd850
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rdi
callq *%rax
jmp 0x517c
jmp 0x517c
movq -0x8(%rbp), %rdi
callq 0x3050
jmp 0x50e8
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: cleanup
void cleanup(void)
{
#ifdef EWMH_TASKBAR
    Cleanup_Global_Strut();
    Cleanup_EWMH_Taskbar_Support();
#endif /* EWMH_TASKBAR */

    xcb_ewmh_connection_wipe(ewmh);
    free(ewmh);

    xcb_delete_property(dis, screen->root, ewmh->_NET_SUPPORTED);
    xcb_destroy_window(dis, checkwin);

    cleanup_display();

    alien *a;
    while ((a = (alien *)rem_head(&aliens)))
        free(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x8619(%rip), %rdi      # 0xd7b8
callq 0x96c0
movq 0x860d(%rip), %rdi      # 0xd7b8
callq 0x3050
movq 0x85e9(%rip), %rdi      # 0xd7a0
movq 0x8602(%rip), %rax      # 0xd7c0
movl (%rax), %esi
movq 0x85f1(%rip), %rax      # 0xd7b8
movl 0x20(%rax), %edx
callq 0x3670
movl %eax, -0x4(%rbp)
movq 0x85c7(%rip), %rdi      # 0xd7a0
movl 0x8665(%rip), %esi      # 0xd844
callq 0x3060
movl %eax, -0x8(%rbp)
callq 0x96f0
leaq 0x85ed(%rip), %rdi      # 0xd7e0
callq 0x5660
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x520d
movq -0x10(%rbp), %rdi
callq 0x3050
jmp 0x51ec
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: getparents
static void getparents(client *c, display **di, monitor **mo, desktop **de)
{
    display *disp;
    monitor *moni;
    desktop *desk;
    list *l;

/* backpointer mambo-jambo */
    if (!c) return;
    l = c->link.parent;
    disp = l->master;
    l = disp->link.parent;
    moni = l->master;
    l = moni->link.parent;
    desk = l->master;

    if (di)
        *di = disp;
    if (mo)
        *mo = moni;
    if (de)
        *de = desk;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x527d
jmp 0x52fb
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x52d7
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x52e9
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x52fb
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: rem_node
static node *rem_node(node *n)
{
    list *l;

    if (!n)
        return NULL;
    l = n->parent;
    if (l) {
        if (n == l->head) {
            l->head = l->head->next;
            if(l->head)
                l->head->prev = NULL;
            else
                l->tail = NULL;
        }
        else if (n == l->tail) {
            l->tail = l->tail->prev;
            l->tail->next = NULL;
        }
        else {
            n->prev->next = n->next;
            n->next->prev = n->prev;
        }
    }
    n->prev = n->next = NULL;
    n->parent = NULL;
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x531c
movq $0x0, -0x8(%rbp)
jmp 0x5401
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x53d6
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x537a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x536c
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq $0x0, (%rax)
jmp 0x5378
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x53d4
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x53ad
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x8(%rax)
jmp 0x53d2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
jmp 0x53d4
jmp 0x53d6
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: xcb_move
static inline void xcb_move(xcb_connection_t *con, xcb_window_t win, int x, int y, posxy_t *pi)
{
    unsigned int pos[2] = { x, y };

    if (pi) {
        pi->previous_x = pi->current_x;
        pi->previous_y = pi->current_y;
        pi->current_x = x;
        pi->current_y = y;
    }
    xcb_configure_window(con, win, XCB_MOVE, pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x546b
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x28(%rbp), %rcx
movl $0x3, %edx
callq 0x32c0
movl %eax, -0x2c(%rbp)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: add_head
static void add_head(list *l, node *i)
{
    node *o = l->head;
    if (o == NULL) {
        l->head = i;
        l->tail = i;
    }
    else {
        l->head = i;
        i->prev = NULL;
        i->next = o;
        o->prev = i;
    }
    i->parent = l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5527
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x5554
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: select_desktop
void select_desktop(int i)
{
    if (i < 0 || i >= DESKTOPS)
        return;
    current_desktop = find_desktop(i);
    if (!current_desktop)
        current_desktop = (desktop *)get_head(&desktops);
    current_desktop_number = current_desktop->num;
    current_monitor = (monitor *)get_head(&current_desktop->monitors);
    current_display = (display *)get_head(&current_monitor->displays);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x5587
cmpl $0xa, -0x4(%rbp)
jl 0x5589
jmp 0x55f3
movl -0x4(%rbp), %edi
callq 0x5600
movq %rax, 0x8268(%rip)      # 0xd800
cmpq $0x0, 0x8260(%rip)      # 0xd800
jne 0x55b5
leaq 0x825f(%rip), %rdi      # 0xd808
callq 0x54c0
movq %rax, 0x824b(%rip)      # 0xd800
movq 0x8244(%rip), %rax      # 0xd800
movl 0x30(%rax), %eax
movl %eax, 0x8233(%rip)      # 0xd7f8
movq 0x8234(%rip), %rdi      # 0xd800
addq $0x18, %rdi
callq 0x54c0
movq %rax, 0x81fc(%rip)      # 0xd7d8
movq 0x81f5(%rip), %rdi      # 0xd7d8
addq $0x18, %rdi
callq 0x54c0
movq %rax, 0x81dd(%rip)      # 0xd7d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: find_desktop
static desktop *find_desktop(unsigned int n)
{
    desktop *d;
    for (d = (desktop *)get_head(&desktops);
            d && d->num != n; d = (desktop *)get_next(&d->link)) ;
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0x81f6(%rip), %rdi      # 0xd808
callq 0x54c0
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x5637
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
cmpl -0x4(%rbp), %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x5640
jmp 0x5651
jmp 0x5642
movq -0x10(%rbp), %rdi
callq 0x5490
movq %rax, -0x10(%rbp)
jmp 0x561b
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: add_tail
static void add_tail(list *l, node *i)
{
    if(l->head == NULL)
        add_head(l, i);
    else {
        node *o = l->tail;
        l->tail = i;
        o->next = i;
        i->prev = o;
        i->next = NULL;
    }
    i->parent = l;
}

// 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 0x56c9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x54f0
jmp 0x5704
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: tile
void tile(void)
{
    desktopinfo();
    if (!M_HEAD)
        return; /* nothing to arange */
#ifndef EWMH_TASKBAR
    layout[M_MODE](M_WH + (M_SHOWPANEL ? 0 : PANEL_HEIGHT),
                                (TOP_PANEL && M_SHOWPANEL ? PANEL_HEIGHT : 0));
#else
    Update_Global_Strut();
    layout[M_MODE](M_WH, M_WY);
#endif /* EWMH_TASKBAR */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x4f80
movq 0x7fd0(%rip), %rax      # 0xd7d0
cmpq $0x0, 0x18(%rax)
jne 0x5809
jmp 0x5841
movq 0x7fc0(%rip), %rax      # 0xd7d0
movslq 0x5c(%rax), %rcx
leaq 0x7b45(%rip), %rax      # 0xd360
movq (%rax,%rcx,8), %rax
movq 0x7fb2(%rip), %rcx      # 0xd7d8
movl 0x38(%rcx), %edi
movq 0x7fa0(%rip), %rcx      # 0xd7d0
movb 0x68(%rcx), %dl
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %ecx
addl %ecx, %edi
xorl %esi, %esi
callq *%rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: sendevent
static bool sendevent(xcb_window_t win, xcb_atom_t proto)
{
    bool got = check_wmproto(win, proto);
    if (got) {
        xcb_client_message_event_t ev = {0};

        ev.response_type = XCB_CLIENT_MESSAGE;
        ev.window = win;
        ev.format = 32;
        ev.sequence = 0;
        ev.type = wmatoms[WM_PROTOCOLS];
        ev.data.data32[0] = proto;
        ev.data.data32[1] = XCB_CURRENT_TIME;
        xcb_send_event(dis, 0, win, XCB_EVENT_MASK_NO_EVENT, (char *)&ev);
    }

    return got;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x6040
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x5988
leaq -0x2c(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3270
movb $0x21, -0x2c(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x28(%rbp)
movb $0x20, -0x2b(%rbp)
movw $0x0, -0x2a(%rbp)
movl 0x7ed2(%rip), %eax      # 0xd830
movl %eax, -0x24(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movq 0x7e2b(%rip), %rdi      # 0xd7a0
movl -0x4(%rbp), %edx
xorl %ecx, %ecx
leaq -0x2c(%rbp), %r8
movl %ecx, %esi
callq 0x3540
movl %eax, -0x30(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: check_wmproto
static bool check_wmproto(xcb_window_t win, xcb_atom_t proto)
{
    xcb_icccm_get_wm_protocols_reply_t reply;
    bool got = false;

    if (xcb_icccm_get_wm_protocols_reply(dis,
        xcb_icccm_get_wm_protocols(dis, win, wmatoms[WM_PROTOCOLS]), &reply, NULL)) {
        /* TODO: Handle error? */
        unsigned int n;
        for (n = 0; n != reply.atoms_len; ++n)
            if ((got = reply.atoms[n] == proto))
                break;
        xcb_icccm_get_wm_protocols_reply_wipe(&reply);
    }
    return got;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movb $0x0, -0x21(%rbp)
movq 0x7747(%rip), %rax      # 0xd7a0
movq %rax, -0x38(%rbp)
movq 0x773c(%rip), %rdi      # 0xd7a0
movl -0x4(%rbp), %esi
movl 0x77c3(%rip), %edx      # 0xd830
callq 0x30c0
movq -0x38(%rbp), %rdi
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %esi
leaq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x3110
cmpb $0x0, %al
je 0x60d2
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
je 0x60c9
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
sete %al
movb %al, %cl
andb $0x1, %cl
movb %cl, -0x21(%rbp)
testb $0x1, %al
jne 0x60ba
jmp 0x60bc
jmp 0x60c9
jmp 0x60be
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6094
leaq -0x20(%rbp), %rdi
callq 0x30a0
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: xcb_screen_of_display
static xcb_screen_t *xcb_screen_of_display(xcb_connection_t *con, int screen)
{
    xcb_screen_iterator_t iter;

    iter = xcb_setup_roots_iterator(xcb_get_setup(con));
    for (; iter.rem; --screen, xcb_screen_next(&iter))
        if (screen == 0)
            return iter.data;

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3560
movq %rax, %rdi
callq 0x3310
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x6144
cmpl $0x0, -0x14(%rbp)
jne 0x612e
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x614c
jmp 0x6130
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3290
jmp 0x6118
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)