LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/perftests/standalone-enc/standalone_pipe_socketpair_one.c
// Function: pipe_init
static int
pipe_init(void * cookie, uint8_t * buf, size_t buflen)
{
	struct pipeinfo * pipeinfo = cookie;
	uint8_t kbuf[64];
	size_t i;

	/* Set up encryption key. */
	memset(kbuf, 0, 64);
	if ((pipeinfo->k = mkkeypair(kbuf)) == NULL)
		goto err0;

	/* Create socket pairs for the input and output. */
	if (socketpair(AF_UNIX, SOCK_STREAM, 0, pipeinfo->in)) {
		warnp("socketpair");
		goto err0;
	}
	if (socketpair(AF_UNIX, SOCK_STREAM, 0, pipeinfo->out)) {
		warnp("socketpair");
		goto err0;
	}

	/* Set the input. */
	for (i = 0; i < buflen; i++)
		buf[i] = (uint8_t)(i & 0xff);

	/* We haven't finished the event loop. */
	pipeinfo->done = 0;

	/* Create the pipe processes. */
	if ((pipeinfo->out_pid = fd_drain_fork(pipeinfo->out[R])) == -1)
		goto err0;
	if ((pipeinfo->enc_pid = fork_func(pipe_enc, pipeinfo)) == -1)
		goto err0;

	/* Success! */
	return (0);

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x3988
movq %rax, (%rbx)
testq %rax, %rax
je 0x3723
leaq 0x10(%rbx), %rcx
movl $0x1, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x22b0
testl %eax, %eax
jne 0x36f2
leaq 0x18(%rbx), %rcx
movl $0x1, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x22b0
testl %eax, %eax
je 0x3732
callq 0x2370
cmpl $0x0, (%rax)
je 0x3715
movq %rax, %rbx
leaq 0x8caa(%rip), %rdi      # 0xc3b0
xorl %eax, %eax
callq 0x9f98
movl $0x0, (%rbx)
jmp 0x3723
leaq 0x8c94(%rip), %rdi      # 0xc3b0
xorl %eax, %eax
callq 0xa0b7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
testq %r14, %r14
je 0x3745
xorl %eax, %eax
movb %al, (%r15,%rax)
incq %rax
cmpq %rax, %r14
jne 0x3739
movl $0x0, 0x24(%rbx)
movl 0x18(%rbx), %edi
callq 0x2b2d
movl %eax, 0x8(%rbx)
cmpl $-0x1, %eax
je 0x3723
leaq 0x14d(%rip), %rdi       # 0x38b0
movq %rbx, %rsi
callq 0x9710
movl %eax, %ecx
movl %eax, 0xc(%rbx)
xorl %eax, %eax
cmpl $-0x1, %ecx
jne 0x3728
jmp 0x3723
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/perftests/standalone-enc/standalone_pipe_socketpair_one.c
// Function: pipe_func
static int
pipe_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	struct pipeinfo * pipeinfo = cookie;
	size_t i;

	/* Send bytes. */
	for (i = 0; i < nreps; i++) {
		if (noeintr_write(pipeinfo->in[W], buf, buflen)
		    != (ssize_t)buflen) {
			warnp("network_write");
			goto err0;
		}
	}

	/* We've finished writing stuff. */
	if (shutdown(pipeinfo->in[W], SHUT_WR)) {
		warnp("shutdown");
		goto err0;
	}

	/* Wait for the processes to finish. */
	if (fork_func_wait(pipeinfo->enc_pid))
		goto err0;
	if (fork_func_wait(pipeinfo->out_pid))
		goto err0;

	/* Success! */
	return (0);

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rcx, %rcx
je 0x37aa
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl 0x14(%rbx), %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x9a68
cmpq %r15, %rax
jne 0x37d1
decq %r14
jne 0x3792
movl 0x14(%rbx), %edi
movl $0x1, %esi
callq 0x2090
testl %eax, %eax
je 0x37f4
callq 0x2370
cmpl $0x0, (%rax)
je 0x3810
movq %rax, %rbx
leaq 0x8bb8(%rip), %rdi      # 0xc387
jmp 0x37e5
callq 0x2370
cmpl $0x0, (%rax)
je 0x3819
movq %rax, %rbx
leaq 0x8b36(%rip), %rdi      # 0xc31b
xorl %eax, %eax
callq 0x9f98
movl $0x0, (%rbx)
jmp 0x3827
movl 0xc(%rbx), %edi
callq 0x9772
testl %eax, %eax
jne 0x3827
movl 0x8(%rbx), %edi
callq 0x9772
testl %eax, %eax
jne 0x3827
xorl %eax, %eax
jmp 0x382c
leaq 0x8b70(%rip), %rdi      # 0xc387
jmp 0x3820
leaq 0x8afb(%rip), %rdi      # 0xc31b
xorl %eax, %eax
callq 0xa0b7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/perftests/standalone-enc/standalone_pipe_socketpair_one.c
// Function: pipe_cleanup
static int
pipe_cleanup(void * cookie)
{
	struct pipeinfo * pipeinfo = cookie;

	/* Clean up encryption key. */
	proto_crypt_free(pipeinfo->k);

	/* Clean up sockets. */
	if (close(pipeinfo->in[W])) {
		warnp("close");
		goto err0;
	}
	if (close(pipeinfo->in[R])) {
		warnp("close");
		goto err0;
	}
	if (close(pipeinfo->out[W])) {
		warnp("close");
		goto err0;
	}
	if (close(pipeinfo->out[R])) {
		warnp("close");
		goto err0;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3eef
movl 0x14(%rbx), %edi
callq 0x20a0
testl %eax, %eax
jne 0x3874
movl 0x10(%rbx), %edi
callq 0x20a0
testl %eax, %eax
jne 0x3874
movl 0x1c(%rbx), %edi
callq 0x20a0
testl %eax, %eax
jne 0x3874
movl 0x18(%rbx), %edi
callq 0x20a0
testl %eax, %eax
je 0x38ac
callq 0x2370
cmpl $0x0, (%rax)
je 0x3897
movq %rax, %rbx
leaq 0x8b7b(%rip), %rdi      # 0xc403
xorl %eax, %eax
callq 0x9f98
movl $0x0, (%rbx)
jmp 0x38a5
leaq 0x8b65(%rip), %rdi      # 0xc403
xorl %eax, %eax
callq 0xa0b7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
xorl %eax, %eax
jmp 0x38aa
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/perftests/standalone-enc/standalone_pipe_socketpair_one.c
// Function: pipe_enc
static int
pipe_enc(void * cookie)
{
	struct pipeinfo * pipeinfo = cookie;
	void * cancel_cookie;

	/* Create the pipe. */
	if ((cancel_cookie = proto_pipe(pipeinfo->in[R], pipeinfo->out[W], 0,
	    pipeinfo->k, &pipeinfo->status, pipe_callback_status, pipeinfo))
	    == NULL) {
		warn0("proto_pipe");
		goto err0;
	}

	/* Let events happen. */
	if (events_spin(&pipeinfo->done))
		warnp("events_spin");

	/* Clean up the pipe. */
	proto_pipe_cancel(cancel_cookie);

	/* Success! */
	return (0);

err0:
	/* Failure!  This value will be the pid's exit code. */
	return (1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x10(%rdi), %edi
movl 0x1c(%r14), %esi
movq (%r14), %rcx
leaq 0x20(%r14), %r8
movq %r14, (%rsp)
leaq 0x83(%rip), %r9         # 0x3953
xorl %edx, %edx
callq 0xa1dc
testq %rax, %rax
je 0x3913
movq %rax, %rbx
addq $0x24, %r14
movq %r14, %rdi
callq 0x82d5
testl %eax, %eax
je 0x3941
callq 0x2370
cmpl $0x0, (%rax)
je 0x3933
movq %rax, %r14
leaq 0x8a59(%rip), %rdi      # 0xc35c
xorl %eax, %eax
callq 0x9f98
movl $0x0, (%r14)
jmp 0x3941
leaq 0x8a37(%rip), %rdi      # 0xc351
xorl %eax, %eax
callq 0xa0b7
callq 0x2370
movl $0x0, (%rax)
movl $0x1, %eax
jmp 0x394b
leaq 0x8a22(%rip), %rdi      # 0xc35c
xorl %eax, %eax
callq 0xa0b7
movq %rbx, %rdi
callq 0xa483
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/perftests/standalone-enc/../../lib/proto/proto_crypt.c
// Function: mkkeypair
static struct proto_keys *
mkkeypair(uint8_t kbuf[64])
#endif
{
	struct proto_keys * k;

	/* Allocate a structure. */
	if ((k = malloc(sizeof(struct proto_keys))) == NULL)
		goto err0;

	/* Expand the AES key. */
	if ((k->k_aes = crypto_aes_key_expand(&kbuf[0], 32)) == NULL)
		goto err1;

	/* Initialize the HMAC_SHA256 context. */
	HMAC_SHA256_Init(&k->ctx_init, &kbuf[32], 32);

	/* The first packet will be packet number zero. */
	k->pnum = 0;

	/* Success! */
	return (k);

err1:
	free(k);
err0:
	/* Failure! */
	return (NULL);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0xe0, %edi
callq 0x2160
testq %rax, %rax
je 0x39e3
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x67c7
movq %rax, (%rbx)
testq %rax, %rax
je 0x39db
movq %rbx, %rdi
addq $0x8, %rdi
addq $0x20, %r14
movl $0x20, %edx
movq %r14, %rsi
callq 0x4615
movq $0x0, 0xd8(%rbx)
jmp 0x39e5
movq %rbx, %rdi
callq 0x2220
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/perftests/standalone-enc/../../lib/proto/proto_crypt.c
// Function: proto_crypt_dhmac
void
proto_crypt_dhmac(const struct proto_secret * K,
    const uint8_t nonce_l[PCRYPT_NONCE_LEN],
    const uint8_t nonce_r[PCRYPT_NONCE_LEN],
    uint8_t dhmac_l[PCRYPT_DHMAC_LEN], uint8_t dhmac_r[PCRYPT_DHMAC_LEN],
    int decr)
{
	uint8_t nonce_CS[PCRYPT_NONCE_LEN * 2];
	uint8_t dk_1[PCRYPT_DHMAC_LEN * 2];
	const uint8_t * nonce_c, * nonce_s;
	uint8_t * dhmac_c, * dhmac_s;

	/* Figure out how {c, s} maps to {l, r}. */
	nonce_c = decr ? nonce_r : nonce_l;
	dhmac_c = decr ? dhmac_r : dhmac_l;
	nonce_s = decr ? nonce_l : nonce_r;
	dhmac_s = decr ? dhmac_l : dhmac_r;

	/* Copy in nonces (in the right order). */
	memcpy(&nonce_CS[0], nonce_c, PCRYPT_NONCE_LEN);
	memcpy(&nonce_CS[PCRYPT_NONCE_LEN], nonce_s, PCRYPT_NONCE_LEN);

	/* Compute dk_1. */
	PBKDF2_SHA256(K->K, 32, nonce_CS, PCRYPT_NONCE_LEN * 2, 1,
	    dk_1, PCRYPT_DHMAC_LEN * 2);

	/* Copy out diffie-hellman parameter MAC keys (in the right order). */
	memcpy(dhmac_c, &dk_1[0], PCRYPT_DHMAC_LEN);
	memcpy(dhmac_s, &dk_1[PCRYPT_DHMAC_LEN], PCRYPT_DHMAC_LEN);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rcx, %rbx
testl %r9d, %r9d
movq %rdx, %rax
cmoveq %rsi, %rax
movq %r8, %r15
cmoveq %rcx, %r15
cmoveq %rdx, %rsi
cmoveq %r8, %rbx
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
leaq 0x50(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm1, 0x10(%rdx)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm0, 0x20(%rdx)
movaps %xmm1, 0x30(%rdx)
movq $0x40, (%rsp)
leaq 0x10(%rsp), %r14
movl $0x20, %esi
movl $0x40, %ecx
movl $0x1, %r8d
movq %r14, %r9
callq 0x4902
movaps (%r14), %xmm0
movaps 0x10(%r14), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movaps 0x20(%r14), %xmm0
movaps 0x30(%r14), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/perftests/standalone-enc/../../lib/proto/proto_crypt.c
// Function: proto_crypt_dh_validate
int
proto_crypt_dh_validate(const uint8_t yh_r[PCRYPT_YH_LEN],
    const uint8_t dhmac_r[PCRYPT_DHMAC_LEN], int requirepfs)
{
	uint8_t hbuf[32];

	/* Compute HMAC. */
	HMAC_SHA256_Buf(dhmac_r, PCRYPT_DHMAC_LEN, yh_r, CRYPTO_DH_PUBLEN,
	    hbuf);

	/* Check that the MAC matches. */
	if (crypto_verify_bytes(&yh_r[CRYPTO_DH_PUBLEN], hbuf, 32))
		return (1);

	/* Sanity-check the diffie-hellman value. */
	if (crypto_dh_sanitycheck(&yh_r[0]))
		return (1);

	/* If necessary, enforce that the diffie-hellman value is != 1. */
	if (requirepfs) {
		if (! is_not_one(&yh_r[0], CRYPTO_DH_PUBLEN))
			return (1);
	}

	/* Everything is good. */
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movq %rsi, %rax
movq %rdi, %rbx
movq %rsp, %r15
movl $0x20, %esi
movl $0x100, %ecx            # imm = 0x100
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %r8
callq 0x485d
leaq 0x100(%rbx), %rdi
movl $0x20, %edx
movq %r15, %rsi
callq 0x7ff4
movl $0x1, %ebp
testb %al, %al
jne 0x3d72
movq %rbx, %rdi
callq 0x7b83
testl %eax, %eax
jne 0x3d72
testl %r14d, %r14d
je 0x3d70
xorl %eax, %eax
xorl %ecx, %ecx
orb (%rbx,%rcx), %al
incq %rcx
cmpq $0xff, %rcx
jne 0x3d51
movsbl %al, %eax
movzbl 0xff(%rbx), %ecx
decl %ecx
orl %eax, %ecx
je 0x3d72
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/perftests/standalone-enc/../../lib/proto/proto_crypt.c
// Function: proto_crypt_dh_generate
int
proto_crypt_dh_generate(uint8_t yh_l[PCRYPT_YH_LEN], uint8_t x[PCRYPT_X_LEN],
    const uint8_t dhmac_l[PCRYPT_DHMAC_LEN], int nopfs)
{

	/* Are we skipping the diffie-hellman generation? */
	if (nopfs) {
		/* Set y_l to a big-endian 1. */
		memset(yh_l, 0, CRYPTO_DH_PUBLEN - 1);
		yh_l[CRYPTO_DH_PUBLEN - 1] = 1;
	} else {
		/* Generate diffie-hellman parameters x and y. */
		if (crypto_dh_generate(yh_l, x))
			goto err0;
	}

	/* Append an HMAC. */
	HMAC_SHA256_Buf(dhmac_l, PCRYPT_DHMAC_LEN, yh_l, CRYPTO_DH_PUBLEN,
	    &yh_l[CRYPTO_DH_PUBLEN]);

	/* Success! */
	return (0);

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
testl %ecx, %ecx
je 0x3dc4
movl $0xff, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2080
movb $0x1, 0xff(%r14)
leaq 0x100(%r14), %r8
movl $0x20, %esi
movl $0x100, %ecx            # imm = 0x100
movq %rbx, %rdi
movq %r14, %rdx
callq 0x485d
xorl %eax, %eax
jmp 0x3dd7
movq %r14, %rdi
callq 0x7acb
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
je 0x3da4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/perftests/standalone-enc/../../lib/proto/proto_crypt.c
// Function: proto_crypt_mkkeys
int
proto_crypt_mkkeys(const struct proto_secret * K,
    const uint8_t nonce_l[PCRYPT_NONCE_LEN],
    const uint8_t nonce_r[PCRYPT_NONCE_LEN],
    const uint8_t yh_r[PCRYPT_YH_LEN], const uint8_t x[PCRYPT_X_LEN],
    int nopfs, int decr,
    struct proto_keys ** eh_c, struct proto_keys ** eh_s)
{
	uint8_t nonce_y[PCRYPT_NONCE_LEN * 2 + CRYPTO_DH_KEYLEN];
	uint8_t dk_2[128];
	const uint8_t * nonce_c, * nonce_s;

	/* Copy in nonces (in the right order). */
	nonce_c = decr ? nonce_r : nonce_l;
	nonce_s = decr ? nonce_l : nonce_r;
	memcpy(&nonce_y[0], nonce_c, PCRYPT_NONCE_LEN);
	memcpy(&nonce_y[PCRYPT_NONCE_LEN], nonce_s, PCRYPT_NONCE_LEN);

	/* Are we bypassing the diffie-hellman computation? */
	if (nopfs) {
		/* We sent y_l = 1, so y_SC is also 1. */
		memset(&nonce_y[PCRYPT_NONCE_LEN * 2], 0,
		    CRYPTO_DH_KEYLEN - 1);
		nonce_y[PCRYPT_NONCE_LEN * 2 + CRYPTO_DH_KEYLEN - 1] = 1;
	} else {
		/* Perform the diffie-hellman computation. */
		if (crypto_dh_compute(yh_r, x,
		    &nonce_y[PCRYPT_NONCE_LEN * 2]))
			goto err0;
	}

	/* Compute dk_2. */
	PBKDF2_SHA256(K->K, 32, nonce_y,
	    PCRYPT_NONCE_LEN * 2 + CRYPTO_DH_KEYLEN, 1, dk_2, 128);

	/* Create key structures. */
	if ((*eh_c = mkkeypair(&dk_2[0])) == NULL)
		goto err0;
	if ((*eh_s = mkkeypair(&dk_2[64])) == NULL)
		goto err1;

	/* Success! */
	return (0);

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
cmpl $0x0, 0x1f0(%rsp)
movq %rdi, %rbx
movq %rdx, %rax
cmoveq %rsi, %rax
cmoveq %rdx, %rsi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
leaq 0xd0(%rsp), %rax
movaps %xmm0, -0x40(%rax)
movaps %xmm1, -0x30(%rax)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
testl %r9d, %r9d
je 0x3ec5
movl $0xff, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x2080
movb $0x1, 0x1cf(%rsp)
movq 0x1f8(%rsp), %r15
movq $0x80, (%rsp)
leaq 0x90(%rsp), %rdx
leaq 0x10(%rsp), %r14
movl $0x20, %esi
movl $0x140, %ecx            # imm = 0x140
movl $0x1, %r8d
movq %rbx, %rdi
movq %r14, %r9
callq 0x4902
movq %r14, %rdi
callq 0x3988
movq %rax, %rcx
movq %rax, (%r15)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x3ee2
movq 0x200(%rsp), %rbx
leaq 0x50(%rsp), %rdi
callq 0x3988
movq %rax, %rcx
movq %rax, (%rbx)
xorl %eax, %eax
testq %rcx, %rcx
jne 0x3ee2
movq (%r15), %rdi
callq 0x3eef
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3ee2
movq %rcx, %rdi
movq %r8, %rsi
movq %rax, %rdx
callq 0x7b06
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
je 0x3e47
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/perftests/standalone-enc/../../lib/proto/proto_crypt.c
// Function: proto_crypt_enc
void
proto_crypt_enc(uint8_t * ibuf, size_t len, uint8_t obuf[PCRYPT_ESZ],
    struct proto_keys * k)
{
	HMAC_SHA256_CTX ctx;
	uint8_t pnum_exp[8];

	/* Sanity-check the length. */
	assert(len <= PCRYPT_MAXDSZ);

	/* Copy the decrypted data into the encrypted buffer. */
	memcpy(obuf, ibuf, len);

	/* Pad up to PCRYPT_MAXDSZ with zeroes. */
	memset(&obuf[len], 0, PCRYPT_MAXDSZ - len);

	/* Add the length. */
	be32enc(&obuf[PCRYPT_MAXDSZ], (uint32_t)len);

	/* Encrypt the buffer in-place. */
	crypto_aesctr_buf(k->k_aes, k->pnum, obuf, obuf, PCRYPT_MAXDSZ + 4);

	/* Copy the original (initialized) context. */
	memcpy(&ctx, &k->ctx_init, sizeof(HMAC_SHA256_CTX));

	/* Append an HMAC. */
	be64enc(pnum_exp, k->pnum);
	HMAC_SHA256_Update(&ctx, obuf, PCRYPT_MAXDSZ + 4);
	HMAC_SHA256_Update(&ctx, pnum_exp, 8);
	HMAC_SHA256_Final(&obuf[PCRYPT_MAXDSZ + 4], &ctx);

	/* Increment packet number. */
	k->pnum += 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r15
cmpq $0x401, %rsi            # imm = 0x401
jae 0x3ff0
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %rsi
movq %rdx, %rdi
movq %r15, %rdx
callq 0x24b0
leaq (%r14,%r15), %rdi
movl $0x400, %edx            # imm = 0x400
subq %r15, %rdx
xorl %esi, %esi
callq 0x2080
rolw $0x8, %r15w
movw %r15w, 0x402(%r14)
movw $0x0, 0x400(%r14)
movq (%rbx), %rdi
movq 0xd8(%rbx), %rsi
movl $0x404, %r8d            # imm = 0x404
movq %r14, %rdx
movq %r14, %rcx
callq 0x72f6
leaq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %r15
movl $0xd0, %edx
movq %r15, %rdi
callq 0x24b0
movq 0xd8(%rbx), %rax
bswapq %rax
movq %rsp, %r12
movq %rax, (%r12)
movl $0x404, %edx            # imm = 0x404
movq %r15, %rdi
movq %r14, %rsi
callq 0x477d
movl $0x8, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x477d
addq $0x404, %r14            # imm = 0x404
movq %r14, %rdi
movq %r15, %rsi
callq 0x47ad
incq 0xd8(%rbx)
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x8412(%rip), %rdi      # 0xc409
leaq 0x8420(%rip), %rsi      # 0xc41e
leaq 0x8437(%rip), %rcx      # 0xc43c
movl $0x14b, %edx            # imm = 0x14B
callq 0x2130
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/perftests/standalone-enc/../../lib/proto/proto_crypt.c
// Function: proto_crypt_dec
ssize_t
proto_crypt_dec(uint8_t ibuf[PCRYPT_ESZ], uint8_t * obuf,
    struct proto_keys * k)
{
	HMAC_SHA256_CTX ctx;
	uint8_t hbuf[32];
	uint8_t pnum_exp[8];
	size_t len;

	/* Copy the original (initialized) context. */
	memcpy(&ctx, &k->ctx_init, sizeof(HMAC_SHA256_CTX));

	/* Verify HMAC. */
	be64enc(pnum_exp, k->pnum);
	HMAC_SHA256_Update(&ctx, ibuf, PCRYPT_MAXDSZ + 4);
	HMAC_SHA256_Update(&ctx, pnum_exp, 8);
	HMAC_SHA256_Final(hbuf, &ctx);
	if (crypto_verify_bytes(hbuf, &ibuf[PCRYPT_MAXDSZ + 4], 32))
		return (-1);

	/* Decrypt the buffer in-place. */
	crypto_aesctr_buf(k->k_aes, k->pnum, ibuf, ibuf, PCRYPT_MAXDSZ + 4);

	/* Increment packet number. */
	k->pnum += 1;

	/* Parse length. */
	len = be32dec(&ibuf[PCRYPT_MAXDSZ]);

	/* Make sure nobody is being evil here... */
	if ((len == 0) || (len > PCRYPT_MAXDSZ))
		return (-1);

	/* Copy the bytes into the output buffer. */
	memcpy(obuf, ibuf, len);

	/* Return the decrypted length. */
	return ((ssize_t)len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdx), %rsi
leaq 0x30(%rsp), %r12
movl $0xd0, %edx
movq %r12, %rdi
callq 0x24b0
movq 0xd8(%r15), %rax
bswapq %rax
leaq 0x8(%rsp), %r13
movq %rax, (%r13)
movl $0x404, %edx            # imm = 0x404
movq %r12, %rdi
movq %rbx, %rsi
callq 0x477d
movl $0x8, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x477d
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x47ad
leaq 0x404(%rbx), %rsi
movl $0x20, %edx
movq %r13, %rdi
callq 0x7ff4
movq $-0x1, %r12
testb %al, %al
jne 0x40e9
movq (%r15), %rdi
movq 0xd8(%r15), %rsi
movl $0x404, %r8d            # imm = 0x404
movq %rbx, %rdx
movq %rbx, %rcx
callq 0x72f6
incq 0xd8(%r15)
movl 0x400(%rbx), %eax
bswapl %eax
leal -0x401(%rax), %ecx
cmpl $0xfffffc00, %ecx       # imm = 0xFFFFFC00
jb 0x40e9
movl %eax, %r12d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x24b0
movq %r12, %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/liball/../libcperciva/crypto/crypto_dh.c
// Function: crypto_dh_generate_pub
int
crypto_dh_generate_pub(uint8_t pub[CRYPTO_DH_PUBLEN],
    const uint8_t priv[CRYPTO_DH_PRIVLEN])
{
	BIGNUM * two;

	/* Generate BN representation for 2. */
	if ((two = BN_new()) == NULL) {
		warn0("%s", ERR_error_string(ERR_get_error(), NULL));
		goto err0;
	}
	if (!BN_set_word(two, 2)) {
		warn0("%s", ERR_error_string(ERR_get_error(), NULL));
		goto err1;
	}

	/* Compute pub = two^(2^258 + priv). */
	if (blinded_modexp(pub, two, priv))
		goto err1;

	/* Free storage allocated by BN_new. */
	BN_free(two);

	/* Success! */
	return (0);

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x21b0
testq %rax, %rax
je 0x758b
movq %rax, %rbx
movl $0x2, %esi
movq %rax, %rdi
callq 0x2280
testl %eax, %eax
je 0x75b8
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x75f6
testl %eax, %eax
jne 0x75e3
movq %rbx, %rdi
callq 0x20b0
xorl %eax, %eax
jmp 0x75f0
callq 0x24d0
movq %rax, %rdi
xorl %esi, %esi
callq 0x22e0
leaq 0x4e5e(%rip), %rdi      # 0xc3ff
movq %rax, %rsi
xorl %eax, %eax
callq 0xa0b7
callq 0x2370
movl $0x0, (%rax)
jmp 0x75eb
callq 0x24d0
movq %rax, %rdi
xorl %esi, %esi
callq 0x22e0
leaq 0x4e31(%rip), %rdi      # 0xc3ff
movq %rax, %rsi
xorl %eax, %eax
callq 0xa0b7
callq 0x2370
movl $0x0, (%rax)
movq %rbx, %rdi
callq 0x20b0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/liball/../libcperciva/crypto/crypto_entropy.c
// Function: update
static void
update(const uint8_t * data, size_t datalen)
{
	HMAC_SHA256_CTX ctx;
	uint8_t K[32];
	uint8_t Vx[33];

	/* Load (Key, V) into (K, Vx). */
	memcpy(K, drbg.Key, 32);
	memcpy(Vx, drbg.V, 32);

	/* K <- HMAC(K, V || 0x00 || data). */
	Vx[32] = 0x00;
	HMAC_SHA256_Init(&ctx, K, 32);
	HMAC_SHA256_Update(&ctx, Vx, 33);
	HMAC_SHA256_Update(&ctx, data, datalen);
	HMAC_SHA256_Final(K, &ctx);

	/* V <- HMAC(K, V). */
	HMAC_SHA256_Buf(K, 32, Vx, 32, Vx);

	/* If the provided data is non-Null, perform another mixing stage. */
	if (datalen != 0) {
		/* K <- HMAC(K, V || 0x01 || data). */
		Vx[32] = 0x01;
		HMAC_SHA256_Init(&ctx, K, 32);
		HMAC_SHA256_Update(&ctx, Vx, 33);
		HMAC_SHA256_Update(&ctx, data, datalen);
		HMAC_SHA256_Final(K, &ctx);

		/* V <- HMAC(K, V). */
		HMAC_SHA256_Buf(K, 32, Vx, 32, Vx);
	}

	/* Copy (K, Vx) back to (Key, V). */
	memcpy(drbg.Key, K, 32);
	memcpy(drbg.V, Vx, 32);

	/* Clean the stack. */
	insecure_memzero(K, 32);
	insecure_memzero(Vx, 33);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rsi, %rbx
movq %rdi, %r14
movups 0xa85a(%rip), %xmm0     # 0x12698
movq %rsp, %r15
movaps %xmm0, (%r15)
movups 0xa85c(%rip), %xmm0     # 0x126a8
movaps %xmm0, 0x10(%r15)
movups 0xa860(%rip), %xmm0     # 0x126b8
leaq 0x20(%rsp), %r12
movaps %xmm0, (%r12)
movups 0xa85f(%rip), %xmm0     # 0x126c8
movaps %xmm0, 0x10(%r12)
movb $0x0, 0x20(%r12)
leaq 0x50(%rsp), %r13
movl $0x20, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x4615
movl $0x21, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x477d
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x477d
movq %r15, %rdi
movq %r13, %rsi
callq 0x47ad
movl $0x20, %esi
movl $0x20, %ecx
movq %r15, %rdi
movq %r12, %rdx
movq %r12, %r8
callq 0x485d
testq %rbx, %rbx
je 0x7f33
leaq 0x20(%rsp), %r15
movb $0x1, 0x20(%r15)
leaq 0x50(%rsp), %r13
movq %rsp, %r12
movl $0x20, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x4615
movl $0x21, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x477d
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x477d
movq %r12, %rdi
movq %r13, %rsi
callq 0x47ad
movl $0x20, %esi
movl $0x20, %ecx
movq %r12, %rdi
movq %r15, %rdx
movq %r15, %r8
callq 0x485d
movq %rsp, %rdi
movaps (%rdi), %xmm0
movaps 0x10(%rdi), %xmm1
movups %xmm1, 0xa764(%rip)     # 0x126a8
movups %xmm0, 0xa74d(%rip)     # 0x12698
leaq 0x20(%rsp), %rbx
movaps (%rbx), %xmm0
movaps 0x10(%rbx), %xmm1
movups %xmm0, 0xa75a(%rip)     # 0x126b8
movups %xmm1, 0xa763(%rip)     # 0x126c8
leaq 0xa66c(%rip), %r14      # 0x125d8
movq (%r14), %rax
movl $0x20, %esi
callq *%rax
movq (%r14), %rax
movl $0x21, %esi
movq %rbx, %rdi
callq *%rax
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/liball/../libcperciva/crypto/crypto_verify_bytes.c
// Function: crypto_verify_bytes
uint8_t
crypto_verify_bytes(const uint8_t * buf0, const uint8_t * buf1, size_t len)
{
	uint8_t rc = 0;
	size_t i;

	for (i = 0; i < len; i++)
		rc = rc | (buf0[i] ^ buf1[i]);

	return (rc);
}

// Assembly:
testq %rdx, %rdx
je 0x8011
xorl %ecx, %ecx
xorl %eax, %eax
movb (%rsi,%rcx), %r8b
xorb (%rdi,%rcx), %r8b
orb %r8b, %al
incq %rcx
cmpq %rcx, %rdx
jne 0x7ffd
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/liball/../libcperciva/util/fork_func.c
// Function: fork_func_wait
int
fork_func_wait(pid_t pid)
{
	int status;
	int rc = -1;

	/* Wait for the process to finish. */
	if (waitpid(pid, &status, 0) == -1) {
		warnp("waitpid");
		goto err0;
	}

	/* Print the error status, if applicable. */
	if (WIFEXITED(status)) {
		/* Child ${pid} exited cleanly. */
		rc = WEXITSTATUS(status);
	} else {
		/*
		 * Child ${pid} did not exit cleanly; warn about the reason
		 * for the unclean exit.
		 */
		if (WIFSIGNALED(status))
			warn0("pid %jd: terminated with signal %d",
			    (intmax_t)pid, WTERMSIG(status));
		else
			warn0("pid %jd: exited for an unknown reason",
			    (intmax_t)pid);
	}

err0:
	/* Done! */
	return (rc);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0xc(%rsp), %rsi
xorl %edx, %edx
callq 0x2340
cmpl $-0x1, %eax
je 0x97b9
movl 0xc(%rsp), %eax
movl %eax, %edx
andl $0x7f, %edx
je 0x97dc
movl %edx, %eax
shll $0x18, %eax
addl $0x1000000, %eax        # imm = 0x1000000
movslq %ebx, %rsi
cmpl $0x2000000, %eax        # imm = 0x2000000
jl 0x97e1
leaq 0x3a8a(%rip), %rdi      # 0xd23a
xorl %eax, %eax
callq 0xa0b7
jmp 0x97ef
callq 0x2370
cmpl $0x0, (%rax)
je 0x97fc
movq %rax, %rbx
leaq 0x3a65(%rip), %rdi      # 0xd232
xorl %eax, %eax
callq 0x9f98
movl $0x0, (%rbx)
jmp 0x980a
movzbl %ah, %eax
jmp 0x980f
leaq 0x3a75(%rip), %rdi      # 0xd25d
xorl %eax, %eax
callq 0xa0b7
callq 0x2370
movl $0x0, (%rax)
jmp 0x980a
leaq 0x3a2f(%rip), %rdi      # 0xd232
xorl %eax, %eax
callq 0xa0b7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/liball/../lib/proto/proto_pipe.c
// Function: proto_pipe
void *
proto_pipe(int s_in, int s_out, int decr, struct proto_keys * k,
    int * status, int (* callback)(void *), void * cookie)
{
	struct pipe_cookie * P;

	/* Bake a cookie. */
	if ((P = malloc(sizeof(struct pipe_cookie))) == NULL)
		goto err0;
	P->callback = callback;
	P->cookie = cookie;
	P->status = status;
	P->s_in = s_in;
	P->s_out = s_out;
	P->decr = decr;
	P->k = k;
	P->write_cookie = NULL;

	/* Initialize reader. */
	if ((P->R = netbuf_read_init(P->s_in)) == NULL)
		goto err1;

	/* Set the minimum number of bytes to read. */
	P->minread = P->decr ? PCRYPT_ESZ : 1;

	/* Set the number of bytes in a full buffer. */
	P->full_buflen = P->decr ? PCRYPT_ESZ : PCRYPT_MAXDSZ;

	/* Start reading. */
	if (netbuf_read_wait(P->R, P->minread, callback_pipe_read, P))
		goto err2;

	/* Success! */
	return (P);

err2:
	netbuf_read_free(P->R);
err1:
	free(P);
err0:
	/* Failure! */
	return (NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r12
movq %rcx, (%rsp)
movl %edx, %r15d
movl %esi, %r13d
movl %edi, %ebp
movl $0x2178, %edi           # imm = 0x2178
callq 0x2160
testq %rax, %rax
je 0xa2a3
movq %rax, %rbx
movq 0x40(%rsp), %rax
movq %r14, (%rbx)
movq %rax, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movl %ebp, 0x18(%rbx)
movl %r13d, 0x1c(%rbx)
movl %r15d, 0x20(%rbx)
movq (%rsp), %rax
movq %rax, 0x28(%rbx)
movq $0x0, 0x2158(%rbx)
movl %ebp, %edi
callq 0xabd0
movq %rax, 0x2150(%rbx)
testq %rax, %rax
je 0xa29b
cmpl $0x0, 0x20(%rbx)
movl $0x1, %esi
movl $0x424, %ecx            # imm = 0x424
cmovneq %rcx, %rsi
movq %rsi, 0x2168(%rbx)
movl $0x400, %edx            # imm = 0x400
cmovneq %rcx, %rdx
movq %rdx, 0x2170(%rbx)
leaq 0x37(%rip), %rdx        # 0xa2b7
movq %rax, %rdi
movq %rbx, %rcx
callq 0xac4e
testl %eax, %eax
je 0xa2a5
movq 0x2150(%rbx), %rdi
callq 0xaef8
movq %rbx, %rdi
callq 0x2220
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_09/getch.c
// Function: main
int main(void)
{
  int c;

  c = getch();
  putchar(c);

  ungetch(EOF);

  c = getch();
  putchar(c);

  return 0;
}

// Assembly:
pushq %rbx
movl 0x2eed(%rip), %eax      # 0x4050
leaq 0x2ef6(%rip), %rbx      # 0x4060
testl %eax, %eax
jle 0x117b
decl %eax
movl %eax, 0x2eda(%rip)      # 0x4050
movl (%rbx,%rax,4), %edi
jmp 0x1182
callq 0x1050
movl %eax, %edi
callq 0x1030
movslq 0x2ec2(%rip), %rax      # 0x4050
cmpq $0x64, %rax
jl 0x11a2
leaq 0xe69(%rip), %rdi       # 0x2004
callq 0x1040
jmp 0x11b2
leal 0x1(%rax), %ecx
movl %ecx, 0x2ea5(%rip)      # 0x4050
movl $0xffffffff, (%rbx,%rax,4) # imm = 0xFFFFFFFF
movl 0x2e98(%rip), %eax      # 0x4050
testl %eax, %eax
jle 0x11c9
decl %eax
movl %eax, 0x2e8c(%rip)      # 0x4050
movl (%rbx,%rax,4), %edi
jmp 0x11d0
callq 0x1050
movl %eax, %edi
callq 0x1030
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/gitluin[P]sara/src/sara.c
// Function: ecalloc
void*
ecalloc(size_t nmemb, size_t size){
	void* p;

	if ( !(p = calloc(nmemb, size)) )
		die("ecalloc failed");

	return p;
}

// Assembly:
pushq %rbx
callq 0x23a0
movq %rax, %rbx
testq %rax, %rax
jne 0x2678
leaq 0x39bf(%rip), %rdi      # 0x6030
xorl %eax, %eax
callq 0x5440
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/gitluin[P]sara/src/sara.c
// Function: uitos
void
uitos(unsigned int ui, int len, char* dest){
	int i, j, res;
	int bytearray[len];
	char bytestr[len + 1];

	/* reverse the array, as tags are printed left to right, not right to left */
	for (i=0;i < len;i++)
		bytearray[i] = ui >> i & 1;

	for (i=0, j=0;
	(i < (len + 1)) && (res = snprintf(bytestr + j, (len + 1) - j, "%d", bytearray[i])) > 0;
	i++)
		j += res;

	snprintf(dest, len + 1, "%s", bytestr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x38(%rbp)
movl %esi, %eax
movq %rsp, %r12
leaq 0xf(,%rax,4), %rcx
andq $-0x10, %rcx
subq %rcx, %r12
movq %r12, %rsp
leal 0x1(%rsi), %ecx
movq %rsp, %r14
movq %rcx, -0x30(%rbp)
addq $0xf, %rcx
andq $-0x10, %rcx
subq %rcx, %r14
movq %r14, %rsp
testl %esi, %esi
jle 0x2700
xorl %ecx, %ecx
xorl %edx, %edx
btl %ecx, %edi
setb %dl
movl %edx, (%r12,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x26ec
testl %esi, %esi
js 0x273e
movl -0x30(%rbp), %ebx
xorl %r15d, %r15d
xorl %r13d, %r13d
movl %r13d, %edi
addq %r14, %rdi
movq -0x30(%rbp), %rax
subl %r13d, %eax
movslq %eax, %rsi
movl (%r12,%r15,4), %ecx
leaq 0x3917(%rip), %rdx      # 0x603f
xorl %eax, %eax
callq 0x2070
testl %eax, %eax
jle 0x273e
addl %eax, %r13d
incq %r15
cmpq %r15, %rbx
jne 0x270d
movslq -0x30(%rbp), %rsi
leaq 0x38f9(%rip), %rdx      # 0x6042
movq -0x38(%rbp), %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2070
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gitluin[P]sara/src/sara.c
// Function: buttonpress
void
buttonpress(XEvent* e){
	int i;
	client* c;
	monitor* m;
	XButtonPressedEvent* ev = &e->xbutton;

	if ( (m = findmon(ev->window)) && m != curmon )
		changemon(m, NoFocus);

	if ( (c = findclient(ev->window)) ){
		if (c != c->mon->current)
			changecurrent(c, c->mon, c->mon->curdesk, 0);

		restack(c->mon);
		XAllowEvents(dis, ReplayPointer, CurrentTime);

		/* "all" our button functions are performed on a client */
		for (i=0;i < TABLENGTH(buttons);i++)
			if (buttons[i].func && buttons[i].btn == ev->button
			&& buttons[i].mask == ev->state)
				buttons[i].func(buttons[i].arg);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x6e4b(%rip), %rax      # 0x95c0
testq %rax, %rax
je 0x27a3
movq 0x20(%rbx), %rcx
movq 0x30(%rax), %rdx
testq %rdx, %rdx
je 0x2793
cmpq %rcx, 0x38(%rdx)
je 0x27b3
movq 0x28(%rdx), %rdx
jmp 0x2782
movq %rdx, 0x6d36(%rip)      # 0x94d0
movq 0x48(%rax), %rax
testq %rax, %rax
jne 0x277e
movq %rax, 0x6d2e(%rip)      # 0x94d8
leaq 0x6d37(%rip), %rax      # 0x94e8
jmp 0x27c8
movq %rax, 0x6d1e(%rip)      # 0x94d8
leaq 0x6d17(%rip), %rax      # 0x94d8
movq %rdx, 0x6d08(%rip)      # 0x94d0
movq (%rax), %r14
testq %r14, %r14
sete %cl
movq 0x6d10(%rip), %rax      # 0x94e8
cmpq %rax, %r14
sete %dl
orb %cl, %dl
jne 0x27fe
testq %rax, %rax
je 0x27f7
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x27f7
xorl %esi, %esi
callq 0x429d
movq %r14, 0x6cea(%rip)      # 0x94e8
movq 0x20(%rbx), %rdi
callq 0x4e5b
testq %rax, %rax
je 0x287a
movq %rax, %r14
movq 0x30(%rax), %rsi
cmpq 0x28(%rsi), %rax
je 0x2826
movl 0x4(%rsi), %edx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x4162
movq 0x30(%r14), %rdi
callq 0x3ded
movq 0x6c8a(%rip), %rdi      # 0x94c0
xorl %r14d, %r14d
movl $0x2, %esi
xorl %edx, %edx
callq 0x22b0
leaq 0x64e4(%rip), %r15      # 0x8d30
movq 0x8(%r14,%r15), %rax
testq %rax, %rax
je 0x2870
movl 0x4(%r14,%r15), %ecx
cmpl 0x54(%rbx), %ecx
jne 0x2870
movl (%r14,%r15), %ecx
cmpl 0x50(%rbx), %ecx
jne 0x2870
movq 0x10(%r14,%r15), %rdi
callq *%rax
addq $0x18, %r14
cmpq $0x18, %r14
je 0x284c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/gitluin[P]sara/src/sara.c
// Function: enternotify
void
enternotify(XEvent* e){
	client* c;
	monitor* m;
	XCrossingEvent* ev = &e->xcrossing;

	if ((ev->mode != NotifyNormal || ev->detail == NotifyInferior) && ev->window != root)
		return;

	if ( !(c = findclient(ev->window)) || c == curmon->current )
		return;

	if ( (m = c->mon) && m != curmon )
		changemon(m, YesFocus);

	changecurrent(c, c->mon, c->mon->curdesk, 0);
}

// Assembly:
pushq %rbx
cmpl $0x0, 0x50(%rdi)
jne 0x28cd
cmpl $0x2, 0x54(%rdi)
jne 0x28da
movq 0x20(%rdi), %rax
cmpq 0x6cd8(%rip), %rax      # 0x95b0
jne 0x2928
movq 0x20(%rdi), %rdi
callq 0x4e5b
testq %rax, %rax
je 0x2928
movq %rax, %rbx
movq 0x6bf6(%rip), %rax      # 0x94e8
cmpq 0x28(%rax), %rbx
je 0x2928
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
sete %cl
cmpq %rax, %rdi
sete %al
orb %cl, %al
jne 0x2916
movl $0x1, %esi
callq 0x48ff
movq 0x30(%rbx), %rsi
movl 0x4(%rsi), %edx
movq %rbx, %rdi
xorl %ecx, %ecx
popq %rbx
jmp 0x4162
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/gitluin[P]sara/src/sara.c
// Function: maprequest
void
maprequest(XEvent* e){
	XWindowAttributes wa;
	XMapRequestEvent* ev = &e->xmaprequest;

	if (!XGetWindowAttributes(dis, ev->window, &wa) || wa.override_redirect)
		return;

	if (!findclient(ev->window))
		manage(ev->window, &wa);
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq 0x6b27(%rip), %rdi      # 0x94c0
movq 0x28(%rbx), %rsi
leaq 0x8(%rsp), %rdx
callq 0x23f0
testl %eax, %eax
je 0x29d1
cmpl $0x0, 0x80(%rsp)
jne 0x29d1
movq 0x28(%rbx), %rdi
callq 0x4e5b
testq %rax, %rax
jne 0x29d1
movq 0x28(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x519f
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/gitluin[P]sara/src/sara.c
// Function: configurenotify
void
configurenotify(XEvent* e){
	XConfigureEvent* ev = &e->xconfigure;

	if (ev->window == root){
		sw = ev->width; sh = ev->height;
		updategeom();

		for EACHMON(mhead){
			for EACHCLIENT(im->head)
				if (ic->isfull)
					resizeclient(ic, im->mx, im->my, im->mw, im->mh);

			arrange(im);
		}
	}
}

// Assembly:
movq 0x28(%rdi), %rax
cmpq 0x6bcb(%rip), %rax      # 0x95b0
jne 0x2a6f
pushq %rax
movl 0x38(%rdi), %eax
movl %eax, 0x6bd7(%rip)      # 0x95cc
movl 0x3c(%rdi), %eax
movl %eax, 0x6bd2(%rip)      # 0x95d0
callq 0x4ea2
movq 0x6bb6(%rip), %rax      # 0x95c0
movq %rax, 0x6ac7(%rip)      # 0x94d8
testq %rax, %rax
je 0x2a6b
movq 0x30(%rax), %rdi
movq %rdi, 0x6aaf(%rip)      # 0x94d0
testq %rdi, %rdi
je 0x2a52
cmpl $0x0, 0x18(%rdi)
je 0x2a45
movq 0x6aa5(%rip), %rax      # 0x94d8
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
movl 0x14(%rax), %ecx
movl 0x10(%rax), %r8d
callq 0x3eb9
movq 0x6a84(%rip), %rax      # 0x94d0
movq 0x28(%rax), %rdi
jmp 0x2a1a
movq 0x6a7f(%rip), %rdi      # 0x94d8
callq 0x3d4c
movq 0x6a73(%rip), %rax      # 0x94d8
movq 0x48(%rax), %rax
jmp 0x2a0a
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/gitluin[P]sara/src/sara.c
// Function: changemsize
void
changemsize(const Arg arg){
	parser[WantFloat](arg.s, &parg);
	curmon->msize += ( ((curmon->msize < 0.95 * curmon->mw) && (parg.f > 0))
			|| ((curmon->msize > 0.05 * curmon->mw) && (parg.f < 0)) )
		? parg.f * curmon->mw : 0;

	arrange(curmon);
}

// Assembly:
pushq %rax
leaq 0x68f7(%rip), %rsi      # 0x94e0
callq *0x67c9(%rip)           # 0x93b8
movq 0x68f2(%rip), %rdi      # 0x94e8
movss (%rdi), %xmm0
cvtss2sd %xmm0, %xmm2
movl 0x14(%rdi), %eax
cvtsi2sd %eax, %xmm3
movsd 0x33fb(%rip), %xmm1     # 0x6008
mulsd %xmm3, %xmm1
ucomisd %xmm2, %xmm1
movss 0x68c3(%rip), %xmm1     # 0x94e0
jbe 0x2c27
xorps %xmm4, %xmm4
ucomiss %xmm4, %xmm1
ja 0x2c41
mulsd 0x33e1(%rip), %xmm3     # 0x6010
ucomisd %xmm3, %xmm2
xorps %xmm2, %xmm2
jbe 0x2c4f
xorpd %xmm3, %xmm3
ucomiss %xmm1, %xmm3
jbe 0x2c4f
xorps %xmm2, %xmm2
cvtsi2ss %eax, %xmm2
mulss %xmm2, %xmm1
movaps %xmm1, %xmm2
addss %xmm2, %xmm0
movss %xmm0, (%rdi)
popq %rax
jmp 0x3d4c
// File: /workspace/github_c_makefile_star2_O1/gitluin[P]sara/src/sara.c
// Function: focusmon
void
focusmon(const Arg arg){
	monitor* m;

	if (!mhead->next)
		return;

	parser[WantInt](arg.s, &parg);

	if ( (m = dirtomon(parg.i)) && m == curmon )
		return;
	changemon(m, YesFocus);
}

// Assembly:
movq 0x695c(%rip), %rax      # 0x95c0
cmpq $0x0, 0x48(%rax)
je 0x2cd4
pushq %rax
leaq 0x686d(%rip), %rsi      # 0x94e0
callq *0x6737(%rip)           # 0x93b0
cmpl $0x0, 0x6860(%rip)      # 0x94e0
movq 0x6861(%rip), %rcx      # 0x94e8
jle 0x2c9b
movq 0x48(%rcx), %rdi
testq %rdi, %rdi
jne 0x2cc1
movq 0x6927(%rip), %rdi      # 0x95c0
jmp 0x2cc1
movq 0x691e(%rip), %rax      # 0x95c0
cmpq %rax, %rcx
je 0x2cb5
movq %rax, %rdi
movq 0x48(%rax), %rax
cmpq %rcx, %rax
jne 0x2ca7
jmp 0x2cc1
movq %rax, %rdi
movq 0x48(%rax), %rax
testq %rax, %rax
jne 0x2cb5
testq %rdi, %rdi
leaq 0x8(%rsp), %rsp
je 0x2cd5
cmpq 0x6816(%rip), %rdi      # 0x94e8
jne 0x2cd5
retq
movl $0x1, %esi
jmp 0x48ff
// File: /workspace/github_c_makefile_star2_O1/gitluin[P]sara/src/sara.c
// Function: killclient
void
killclient(const Arg arg){
	if (!curmon->current)
		return;

	if (!xsendkill(curmon->current->win)){
		XGrabServer(dis);
		XSetCloseDownMode(dis, DestroyAll);
		XKillClient(dis, curmon->current->win);
		XSync(dis, False);
		XUngrabServer(dis);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq 0x67f6(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x2e24
movq 0x38(%rax), %rbx
movq 0x67b6(%rip), %rdi      # 0x94c0
leaq 0x33d5(%rip), %rsi      # 0x60e6
xorl %edx, %edx
callq 0x23c0
movq %rax, %r14
movq 0x679e(%rip), %rdi      # 0x94c0
leaq 0x8(%rsp), %rdx
leaq 0x4(%rsp), %rcx
movq %rbx, %rsi
callq 0x2450
testl %eax, %eax
je 0x2dd5
movslq 0x4(%rsp), %rax
movq 0x8(%rsp), %rdi
testq %rax, %rax
je 0x2dc8
decq %rax
movq (%rdi,%rax,8), %r15
cmpq %r14, %r15
je 0x2d62
addq $-0x1, %rax
jb 0x2d4e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x4(%rsp)
callq 0x2040
cmpq %r14, %r15
jne 0x2dd5
leaq 0x10(%rsp), %r15
movl $0x21, (%r15)
movq %rbx, 0x20(%r15)
movq 0x6739(%rip), %rdi      # 0x94c0
leaq 0x3369(%rip), %rsi      # 0x60f7
movl $0x1, %edx
callq 0x23c0
movq %rax, 0x28(%r15)
movl $0x20, 0x30(%r15)
movq %r14, 0x38(%r15)
movq $0x0, 0x40(%r15)
movq 0x6709(%rip), %rdi      # 0x94c0
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r15, %r8
callq 0x2350
jmp 0x2e24
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
callq 0x2040
movq 0x66e4(%rip), %rdi      # 0x94c0
callq 0x20b0
movq 0x66d8(%rip), %rdi      # 0x94c0
xorl %esi, %esi
callq 0x20e0
movq 0x66ca(%rip), %rdi      # 0x94c0
movq 0x66eb(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
movq 0x38(%rax), %rsi
callq 0x24d0
movq 0x66af(%rip), %rdi      # 0x94c0
xorl %esi, %esi
callq 0x2330
movq 0x66a1(%rip), %rdi      # 0x94c0
callq 0x2240
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/gitluin[P]sara/src/sara.c
// Function: moveclient
void
moveclient(const Arg arg){
	client* c;

	if (!curmon->current || curmon->current->isfull)
		return;
	
	parser[WantInt](arg.s, &parg);

	if (!(SAFEPARG(-1,1)))
		return;

	/* move current up, or move next visible up (i.e. move current down) */
	c = (parg.i > 0) ? curmon->current : findvisclient(curmon->current->next, WantTiled);

	if (c){
		moveclientup(c);
		arrange(c->mon);
	}
}

// Assembly:
pushq %rax
movq 0x66af(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x2ef1
cmpl $0x0, 0x18(%rax)
jne 0x2ef1
leaq 0x6689(%rip), %rsi      # 0x94e0
callq *0x6553(%rip)           # 0x93b0
movl 0x667d(%rip), %ecx      # 0x94e0
leal 0x1(%rcx), %eax
cmpl $0x2, %eax
ja 0x2ef1
movq 0x6672(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
testl %ecx, %ecx
jg 0x2ea5
movq 0x28(%rax), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x2e9e
movq 0x30(%rcx), %rdx
movl 0x24(%rdx), %edx
testl %edx, 0x1c(%rcx)
jne 0x2e9b
movq 0x28(%rcx), %rcx
jmp 0x2e84
movq %rcx, %rax
movq %rcx, 0x662b(%rip)      # 0x94d0
testq %rax, %rax
je 0x2ef1
movq 0x30(%rax), %rcx
movq 0x30(%rcx), %rsi
addq $0x30, %rcx
xorl %edi, %edi
movq %rsi, %r9
movq %r9, %r8
testq %r9, %r9
je 0x2ef3
movl $0x0, %edx
cmpq %rax, %r8
je 0x2ef5
movq 0x30(%r8), %rdx
movl 0x24(%rdx), %edx
testl %edx, 0x1c(%r8)
je 0x2ee3
cmpl $0x0, 0x10(%r8)
cmoveq %r8, %rdi
movq 0x28(%r8), %r9
movq %rdi, %rdx
cmpq %rax, %r9
jne 0x2ebb
jmp 0x2ef5
popq %rax
retq
xorl %edx, %edx
movq %r8, 0x65d4(%rip)       # 0x94d0
xorl %edi, %edi
movq %rsi, %r8
testq %rsi, %rsi
je 0x2f17
cmpq %rax, %r8
je 0x2f17
movq 0x28(%r8), %rsi
cmpq %rax, %rsi
jne 0x2efe
movq %r8, %rdi
movq %r8, 0x65b2(%rip)       # 0x94d0
testq %rdx, %rdx
je 0x2f4b
testq %rdi, %rdi
je 0x2f4b
movq %rcx, %rsi
movq (%rcx), %r8
testq %r8, %r8
je 0x2f3c
leaq 0x28(%r8), %rcx
cmpq %rdx, %r8
jne 0x2f28
movq 0x28(%rax), %rcx
movq %rcx, 0x28(%rdi)
movq %rdx, 0x28(%rax)
movq %rax, (%rsi)
movq 0x30(%rax), %rdi
popq %rax
jmp 0x3d4c
// File: /workspace/github_c_makefile_star2_O1/gitluin[P]sara/src/sara.c
// Function: movefocus
void
movefocus(const Arg arg){
	client* j, * c = NULL;

	if (!curmon->current || curmon->current->isfull)
		return;

	parser[WantInt](arg.s, &parg);

	/* up stack */
	if (parg.i > 0){
		for (j=curmon->head;j && j != curmon->current;j=j->next)
			if (ISVISIBLE(j))
				c = j;

		/* if curmon->current was highest, go to the bottom */
		if (!c)
			for (;j;j=j->next)
				if (ISVISIBLE(j))
					c = j;

	/* down stack, wrap around */
	} else if (parg.i < 0) {
		if ( !(c = findvisclient(curmon->current->next, WantFloating)) )
			c = findvisclient(curmon->head, WantFloating);
	}

	if (c && c != curmon->current){
		changecurrent(c, curmon, curmon->curdesk, 0);
		restack(curmon);
	}
}

// Assembly:
pushq %rax
movq 0x658b(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x2f6c
cmpl $0x0, 0x18(%rax)
je 0x2f6e
popq %rax
retq
leaq 0x656b(%rip), %rsi      # 0x94e0
callq *0x6435(%rip)           # 0x93b0
movl 0x655f(%rip), %eax      # 0x94e0
testl %eax, %eax
jle 0x2ff8
movq 0x655c(%rip), %rdx      # 0x94e8
movq 0x30(%rdx), %rax
testq %rax, %rax
setne %cl
je 0x2fc7
movq 0x28(%rdx), %rdx
cmpq %rdx, %rax
je 0x2fc7
xorl %edi, %edi
movq 0x30(%rax), %rcx
movl 0x24(%rcx), %ecx
testl %ecx, 0x1c(%rax)
cmovneq %rax, %rdi
movq 0x28(%rax), %rax
testq %rax, %rax
setne %cl
cmpq %rdx, %rax
je 0x2fc9
testq %rax, %rax
jne 0x2fa3
jmp 0x2fc9
xorl %edi, %edi
testq %rdi, %rdi
setne %dl
xorb $0x1, %cl
orb %dl, %cl
jne 0x3068
xorl %edi, %edi
movq 0x30(%rax), %rcx
movl 0x24(%rcx), %ecx
testl %ecx, 0x1c(%rax)
cmovneq %rax, %rdi
movq 0x28(%rax), %rcx
movq %rcx, %rax
testq %rcx, %rcx
jne 0x2fdc
jmp 0x3068
js 0x2ffe
xorl %edi, %edi
jmp 0x3068
movq 0x64e3(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rcx
movq 0x28(%rcx), %rcx
xorl %edi, %edi
testq %rcx, %rcx
je 0x302f
movq 0x30(%rcx), %rdx
movl 0x24(%rdx), %edx
testl %edx, 0x1c(%rcx)
je 0x3026
cmpl $0x0, 0x10(%rcx)
je 0x302c
movq 0x28(%rcx), %rcx
jmp 0x300f
movq %rcx, %rdi
movq %rcx, 0x649a(%rip)      # 0x94d0
testq %rdi, %rdi
jne 0x3068
movq 0x30(%rax), %rax
xorl %edi, %edi
testq %rax, %rax
je 0x3061
movq 0x30(%rax), %rcx
movl 0x24(%rcx), %ecx
testl %ecx, 0x1c(%rax)
je 0x3058
cmpl $0x0, 0x10(%rax)
je 0x305e
movq 0x28(%rax), %rax
jmp 0x3041
movq %rax, %rdi
movq %rax, 0x6468(%rip)      # 0x94d0
testq %rdi, %rdi
je 0x2f6c
movq 0x6470(%rip), %rsi      # 0x94e8
cmpq 0x28(%rsi), %rdi
je 0x2f6c
movl 0x4(%rsi), %edx
xorl %ecx, %ecx
callq 0x4162
movq 0x6455(%rip), %rdi      # 0x94e8
popq %rax
jmp 0x3ded
// File: /workspace/github_c_makefile_star2_O1/gitluin[P]sara/src/sara.c
// Function: todesktop
void
todesktop(const Arg arg){
	if (!curmon->current)
		return;

	parser[WantInt](arg.s, &parg);

	if (!SAFEPARG(0,NUMTAGS))
		return;

	if (curmon->current->desks == (1 << parg.i))
		return;

	curmon->current->desks = 1 << parg.i;
	curmon->current->iscur = 0;
	changecurrent(curmon->current, curmon, 1 << parg.i, 1);

	arrange(curmon);
	outputstats();
}

// Assembly:
pushq %rax
movq 0x641e(%rip), %rax      # 0x94e8
cmpq $0x0, 0x28(%rax)
je 0x3100
leaq 0x6408(%rip), %rsi      # 0x94e0
callq *0x62d2(%rip)           # 0x93b0
movl 0x63fc(%rip), %ecx      # 0x94e0
cmpl $0x9, %ecx
ja 0x3100
movl $0x1, %edx
shll %cl, %edx
movq 0x63f1(%rip), %rsi      # 0x94e8
movq 0x28(%rsi), %rdi
cmpl %edx, 0x1c(%rdi)
jne 0x3102
popq %rax
retq
movl %edx, 0x1c(%rdi)
movl $0x0, 0x20(%rdi)
movl $0x1, %ecx
callq 0x4162
movq 0x63cb(%rip), %rdi      # 0x94e8
callq 0x3d4c
popq %rax
jmp 0x4a48
// File: /workspace/github_c_makefile_star2_O1/gitluin[P]sara/src/sara.c
// Function: toggledesktop
void
toggledesktop(const Arg arg){
	unsigned int newdesks;

	if (!curmon->current)
		return;

	parser[WantInt](arg.s, &parg);

	if (!SAFEPARG(-1,NUMTAGS))
		return;

	if (parg.i < 0)
		newdesks = curmon->current->desks | ~(curmon->current->desks);
	else
		newdesks = curmon->current->desks ^ (1 << parg.i);

	if (newdesks){
		curmon->current->desks = newdesks;
		/* set current to be current on new desktop
		 * if it will no longer be visible, adjust current
		 */
		changecurrent(curmon->current, curmon, 1 << parg.i,
			(curmon->current->desks & curmon->seldesks) ? 0 : 1);

		arrange(curmon);
		outputstats();
	}
}

// Assembly:
pushq %rax
movq 0x63b8(%rip), %rax      # 0x94e8
cmpq $0x0, 0x28(%rax)
je 0x31a6
leaq 0x63a2(%rip), %rsi      # 0x94e0
callq *0x626c(%rip)           # 0x93b0
movl 0x6396(%rip), %ecx      # 0x94e0
leal 0x1(%rcx), %eax
cmpl $0xa, %eax
ja 0x31a6
testl %ecx, %ecx
js 0x3169
movq 0x638b(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
movl 0x1c(%rax), %eax
btcl %ecx, %eax
jmp 0x316e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x31a6
movq 0x636f(%rip), %rsi      # 0x94e8
movq 0x28(%rsi), %rdi
movl %eax, 0x1c(%rdi)
movl $0x1, %edx
shll %cl, %edx
xorl %ecx, %ecx
testl %eax, 0x24(%rsi)
sete %cl
callq 0x4162
movq 0x634d(%rip), %rdi      # 0x94e8
callq 0x3d4c
popq %rax
jmp 0x4a48
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/gitluin[P]sara/src/sara.c
// Function: togglefloat
void
togglefloat(const Arg arg){
	if (!curmon->current || curmon->current->isfull)
		return;

	if (curmon->curlayout->arrange == &floaty)
		return;

	curmon->current->isfloat = !curmon->current->isfloat;
	arrange(curmon);
}

// Assembly:
movq 0x6339(%rip), %rdi      # 0x94e8
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x31be
cmpl $0x0, 0x18(%rax)
je 0x31bf
retq
movq 0x40(%rdi), %rcx
leaq 0x15f4(%rip), %rdx      # 0x47be
cmpq %rdx, 0x8(%rcx)
je 0x31be
xorl %ecx, %ecx
cmpl $0x0, 0x10(%rax)
sete %cl
movl %ecx, 0x10(%rax)
jmp 0x3d4c