LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]spiped/perftests/standalone-enc/standalone_pipe_socketpair_one.c
// Function: pipe_callback_status
static int
pipe_callback_status(void * cookie)
{
	struct pipeinfo * pipeinfo = cookie;

	/* Was there an error? */
	if (pipeinfo->status) {
		warn0("proto_pipe callback status: %d", pipeinfo->status);
		return (-1);
	}

	/* We've finished. */
	pipeinfo->done = 1;

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

// Assembly:
movl 0x20(%rdi), %esi
testl %esi, %esi
je 0x376a
pushq %rax
leaq 0x8c15(%rip), %rdi      # 0xc368
xorl %eax, %eax
callq 0x96ec
callq 0x2370
andl $0x0, (%rax)
pushq $-0x1
popq %rax
addq $0x8, %rsp
retq
movl $0x1, 0x24(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x37c8
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x6286
movq %rax, (%rbx)
testq %rax, %rax
je 0x37c0
movq %rbx, %rdi
addq $0x8, %rdi
addq $0x20, %r14
pushq $0x20
popq %rdx
movq %r14, %rsi
callq 0x4252
andq $0x0, 0xd8(%rbx)
jmp 0x37ca
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_O2/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)
pushq $0x20
popq %rsi
pushq $0x40
popq %rcx
pushq $0x1
popq %r8
leaq 0x10(%rsp), %r14
movq %r14, %r9
callq 0x4529
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_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movq %rdi, %rbx
pushq $0x20
popq %r15
movq %rsp, %r12
movl $0x100, %ecx            # imm = 0x100
movq %rsi, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r12, %r8
callq 0x4486
leaq 0x100(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x7928
pushq $0x1
popq %rbp
testb %al, %al
jne 0x3b0d
movq %rbx, %rdi
callq 0x751d
testl %eax, %eax
jne 0x3b0d
testl %r14d, %r14d
je 0x3b0b
xorl %eax, %eax
xorl %ecx, %ecx
cmpq $0xff, %rax
je 0x3afb
orb (%rbx,%rax), %cl
incq %rax
jmp 0x3aeb
movsbl %cl, %eax
movzbl 0xff(%rbx), %ecx
decl %ecx
orl %eax, %ecx
je 0x3b0d
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rdi, %rbx
testl %ecx, %ecx
je 0x3b5e
movl $0xff, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2080
movb $0x1, 0xff(%rbx)
leaq 0x100(%rbx), %r8
pushq $0x20
popq %rsi
movl $0x100, %ecx            # imm = 0x100
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4486
xorl %eax, %eax
jmp 0x3b6d
movq %rbx, %rdi
callq 0x746e
testl %eax, %eax
je 0x3b40
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
cmpl $0x0, 0x200(%rsp)
movq %rdx, %rax
cmoveq %rsi, %rax
cmoveq %rdx, %rsi
movq %rdi, %rbx
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)
pushq $-0x1
popq %rbp
testl %r9d, %r9d
je 0x3c4e
movl $0xff, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x2080
movb $0x1, 0x1cf(%rsp)
movq 0x208(%rsp), %r15
movq $0x80, (%rsp)
pushq $0x20
popq %rsi
leaq 0x90(%rsp), %rdx
pushq $0x1
popq %r8
leaq 0x10(%rsp), %r14
movl $0x140, %ecx            # imm = 0x140
movq %rbx, %rdi
movq %r14, %r9
callq 0x4529
movq %r14, %rdi
callq 0x3774
movq %rax, (%r15)
testq %rax, %rax
je 0x3c60
movq 0x210(%rsp), %rbx
leaq 0x50(%rsp), %rdi
callq 0x3774
movq %rax, %rcx
movq %rax, (%rbx)
xorl %eax, %eax
testq %rcx, %rcx
jne 0x3c62
movq (%r15), %rdi
callq 0x3c70
jmp 0x3c60
movq %rcx, %rdi
movq %r8, %rsi
movq %rax, %rdx
callq 0x74a5
testl %eax, %eax
je 0x3be1
movl %ebp, %eax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3d6e
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)
andw $0x0, 0x400(%r14)
movq (%rbx), %rdi
movq 0xd8(%rbx), %rsi
movl $0x404, %r8d            # imm = 0x404
movq %r14, %rdx
movq %r14, %rcx
callq 0x6cb9
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 0x43aa
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x43aa
addq $0x404, %r14            # imm = 0x404
movq %r14, %rdi
movq %r15, %rsi
callq 0x43da
incq 0xd8(%rbx)
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x8692(%rip), %rdi      # 0xc407
leaq 0x86a0(%rip), %rsi      # 0xc41c
leaq 0x86b7(%rip), %rcx      # 0xc43a
movl $0x14b, %edx            # imm = 0x14B
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/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 0x43aa
pushq $0x8
popq %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x43aa
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x43da
leaq 0x404(%rbx), %rsi
pushq $0x20
popq %rdx
movq %r13, %rdi
callq 0x7928
pushq $-0x1
popq %r12
testb %al, %al
jne 0x3e60
movq (%r15), %rdi
movq 0xd8(%r15), %rsi
movl $0x404, %r8d            # imm = 0x404
movq %rbx, %rdx
movq %rbx, %rcx
callq 0x6cb9
incq 0xd8(%r15)
movl 0x400(%rbx), %eax
bswapl %eax
leal -0x401(%rax), %ecx
cmpl $0xfffffc00, %ecx       # imm = 0xFFFFFC00
jb 0x3e60
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
// File: /workspace/github_c_makefile_star2_O2/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 0x6f5d
movq %rax, %rbx
pushq $0x2
popq %rsi
movq %rax, %rdi
callq 0x2280
testl %eax, %eax
je 0x6f87
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6fc0
testl %eax, %eax
jne 0x6faf
movq %rbx, %rdi
callq 0x20b0
xorl %eax, %eax
jmp 0x6fba
callq 0x24d0
movq %rax, %rdi
xorl %esi, %esi
callq 0x22e0
leaq 0x548a(%rip), %rdi      # 0xc3fd
movq %rax, %rsi
xorl %eax, %eax
callq 0x96ec
callq 0x2370
andl $0x0, (%rax)
jmp 0x6fb7
callq 0x24d0
movq %rax, %rdi
xorl %esi, %esi
callq 0x22e0
leaq 0x5460(%rip), %rdi      # 0xc3fd
movq %rax, %rsi
xorl %eax, %eax
callq 0x96ec
callq 0x2370
andl $0x0, (%rax)
movq %rbx, %rdi
callq 0x20b0
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, %rbx
movq %rdi, %r14
movups 0xaf55(%rip), %xmm0     # 0x12698
movq %rsp, %r15
movaps %xmm0, (%r15)
movups 0xaf57(%rip), %xmm0     # 0x126a8
movaps %xmm0, 0x10(%r15)
movups 0xaf5b(%rip), %xmm0     # 0x126b8
leaq 0x20(%rsp), %r12
movaps %xmm0, (%r12)
movups 0xaf5a(%rip), %xmm0     # 0x126c8
movaps %xmm0, 0x10(%r12)
movb $0x0, 0x20(%r12)
leaq 0x48(%rsp), %r13
pushq $0x20
popq %rbp
movq %r13, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x4252
pushq $0x21
popq %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x43aa
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x43aa
movq %r15, %rdi
movq %r13, %rsi
callq 0x43da
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %rbp, %rcx
movq %r12, %r8
callq 0x4486
testq %rbx, %rbx
je 0x782e
leaq 0x20(%rsp), %r15
movb $0x1, 0x20(%r15)
leaq 0x48(%rsp), %r12
movq %rsp, %r13
pushq $0x20
popq %rbp
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x4252
pushq $0x21
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x43aa
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x43aa
movq %r13, %rdi
movq %r12, %rsi
callq 0x43da
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %rbp, %rcx
movq %r15, %r8
callq 0x4486
movq %rsp, %rdi
movaps (%rdi), %xmm0
movaps 0x10(%rdi), %xmm1
movups %xmm1, 0xae69(%rip)     # 0x126a8
movups %xmm0, 0xae52(%rip)     # 0x12698
leaq 0x20(%rsp), %rbx
movaps (%rbx), %xmm0
movaps 0x10(%rbx), %xmm1
movups %xmm0, 0xae5f(%rip)     # 0x126b8
movups %xmm1, 0xae68(%rip)     # 0x126c8
leaq 0xad71(%rip), %r14      # 0x125d8
movq (%r14), %rax
pushq $0x20
popq %rsi
callq *%rax
movq (%r14), %rax
pushq $0x21
popq %rsi
movq %rbx, %rdi
callq *%rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x7941
movb (%rsi,%rcx), %r8b
xorb (%rdi,%rcx), %r8b
orb %r8b, %al
incq %rcx
jmp 0x792c
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x8dfe
movl 0xc(%rsp), %eax
movl %eax, %edx
andl $0x7f, %edx
je 0x8e1e
movl %edx, %eax
shll $0x18, %eax
addl $0x1000000, %eax        # imm = 0x1000000
movslq %ebx, %rsi
cmpl $0x2000000, %eax        # imm = 0x2000000
jl 0x8e23
leaq 0x4455(%rip), %rdi      # 0xd24a
xorl %eax, %eax
callq 0x96ec
jmp 0x8e31
callq 0x2370
cmpl $0x0, (%rax)
je 0x8e3b
movq %rax, %rbx
leaq 0x4430(%rip), %rdi      # 0xd242
xorl %eax, %eax
callq 0x955d
andl $0x0, (%rbx)
jmp 0x8e49
movzbl %ah, %eax
jmp 0x8e4c
leaq 0x4443(%rip), %rdi      # 0xd26d
xorl %eax, %eax
callq 0x96ec
callq 0x2370
andl $0x0, (%rax)
jmp 0x8e49
leaq 0x4400(%rip), %rdi      # 0xd242
xorl %eax, %eax
callq 0x96ec
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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, %rbp
movq %r8, %r12
movq %rcx, (%rsp)
movl %edx, %r15d
movl %esi, %r13d
movl %edi, %r14d
movl $0x2178, %edi           # imm = 0x2178
callq 0x2160
testq %rax, %rax
je 0x9934
movq %rax, %rbx
movq 0x40(%rsp), %rax
movq %rbp, (%rbx)
movq %rax, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movl %r14d, 0x18(%rbx)
movl %r13d, 0x1c(%rbx)
movl %r15d, 0x20(%rbx)
movq (%rsp), %rax
movq %rax, 0x28(%rbx)
andq $0x0, 0x2158(%rbx)
movl %r14d, %edi
callq 0xa1f0
movq %rax, 0x2150(%rbx)
testq %rax, %rax
je 0x992c
testl %r15d, %r15d
pushq $0x1
popq %rsi
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        # 0x9948
movq %rax, %rdi
movq %rbx, %rcx
callq 0xa26c
testl %eax, %eax
je 0x9936
movq 0x2150(%rbx), %rdi
callq 0xa503
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_O2/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 %rax
callq 0x1181
movl %eax, %edi
callq 0x1030
pushq $-0x1
popq %rdi
callq 0x11a2
callq 0x1181
movl %eax, %edi
callq 0x1030
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2618
leaq 0x3a47(%rip), %rdi      # 0x6058
xorl %eax, %eax
callq 0x50a8
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rax
andq $-0x10, %rax
subq %rax, %r12
movq %r12, %rsp
leal 0x1(%rsi), %eax
movq %rsp, %r14
movq %rax, -0x30(%rbp)
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
cmpq %rax, %rcx
je 0x26a6
xorl %edx, %edx
btl %eax, %edi
setb %dl
movl %edx, (%r12,%rax,4)
incq %rax
jmp 0x2690
movslq %esi, %rbx
xorl %r15d, %r15d
xorl %r13d, %r13d
cmpq %rbx, %r15
jg 0x26e2
movl %r13d, %edi
addq %r14, %rdi
movq -0x30(%rbp), %rax
subl %r13d, %eax
movslq %eax, %rsi
movl (%r12,%r15,4), %ecx
leaq 0x3998(%rip), %rdx      # 0x6067
xorl %eax, %eax
callq 0x2070
testl %eax, %eax
jle 0x26e2
addl %eax, %r13d
incq %r15
jmp 0x26af
movslq -0x30(%rbp), %rsi
leaq 0x397d(%rip), %rdx      # 0x606a
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_O2/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 0x20(%rdi), %rdi
leaq 0x6ea3(%rip), %rax      # 0x95c0
movq (%rax), %rax
testq %rax, %rax
je 0x27eb
leaq 0x30(%rax), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x2741
cmpq %rdi, 0x38(%rcx)
je 0x274f
addq $0x28, %rcx
jmp 0x272d
andq $0x0, 0x6d87(%rip)      # 0x94d0
addq $0x48, %rax
jmp 0x271d
movq %rax, 0x6d82(%rip)      # 0x94d8
movq %rcx, 0x6d73(%rip)      # 0x94d0
cmpq 0x6d84(%rip), %rax      # 0x94e8
je 0x2774
movq %rax, %rdi
xorl %esi, %esi
callq 0x45b1
movq 0x20(%rbx), %rdi
callq 0x4b6c
testq %rax, %rax
je 0x27e5
movq %rax, %r14
movq 0x30(%rax), %rsi
cmpq 0x28(%rsi), %rax
je 0x279c
movl 0x4(%rsi), %edx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x3eb5
movq 0x30(%r14), %rsi
movq %rsi, %rdi
callq 0x3b63
movq 0x6d15(%rip), %rdi      # 0x94c0
pushq $0x2
popq %rsi
xorl %edx, %edx
callq 0x22b0
pushq $0x10
popq %r14
leaq 0x6570(%rip), %r15      # 0x8d30
cmpq $0x40, %r14
je 0x27e5
movl -0xc(%r14,%r15), %eax
cmpl 0x54(%rbx), %eax
jne 0x27df
cmpl $0x40, 0x50(%rbx)
jne 0x27df
movq (%r14,%r15), %rdi
callq 0x4096
addq $0x18, %r14
jmp 0x27c0
popq %rbx
popq %r14
popq %r15
retq
andq $0x0, 0x6ce5(%rip)      # 0x94d8
jmp 0x2774
// File: /workspace/github_c_makefile_star2_O2/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 0x2843
cmpl $0x2, 0x54(%rdi)
jne 0x2852
movq 0x20(%rdi), %rdi
cmpq 0x6d62(%rip), %rdi      # 0x95b0
je 0x2856
jmp 0x28a3
movq 0x20(%rdi), %rdi
callq 0x4b6c
testq %rax, %rax
je 0x28a3
movq %rax, %rbx
movq 0x6c7e(%rip), %rax      # 0x94e8
cmpq 0x28(%rax), %rbx
je 0x28a3
movq 0x30(%rbx), %rsi
testq %rsi, %rsi
sete %cl
cmpq %rax, %rsi
sete %al
orb %cl, %al
jne 0x2895
pushq $0x1
popq %rax
movq %rsi, %rdi
movl %eax, %esi
callq 0x45b1
movq 0x30(%rbx), %rsi
movl 0x4(%rsi), %edx
movq %rbx, %rdi
xorl %ecx, %ecx
popq %rbx
jmp 0x3eb5
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6bae(%rip), %rdi      # 0x94c0
movq 0x28(%rbx), %rsi
leaq 0x8(%rsp), %rdx
callq 0x23f0
testl %eax, %eax
je 0x294a
cmpl $0x0, 0x80(%rsp)
jne 0x294a
movq 0x28(%rbx), %rdi
callq 0x4b6c
testq %rax, %rax
jne 0x294a
movq 0x28(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x4e38
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6c52(%rip), %rax      # 0x95b0
jne 0x29ee
pushq %rax
movl 0x38(%rdi), %eax
movl %eax, 0x6c5e(%rip)      # 0x95cc
movl 0x3c(%rdi), %eax
movl %eax, 0x6c59(%rip)      # 0x95d0
callq 0x4bbb
leaq 0x6c3d(%rip), %rax      # 0x95c0
movq (%rax), %rdi
movq %rdi, 0x6b4b(%rip)      # 0x94d8
testq %rdi, %rdi
je 0x29ea
addq $0x30, %rdi
movq (%rdi), %rdi
movq %rdi, 0x6b30(%rip)      # 0x94d0
testq %rdi, %rdi
je 0x29d1
cmpl $0x0, 0x18(%rdi)
je 0x29cb
movq 0x6b26(%rip), %rax      # 0x94d8
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
movl 0x14(%rax), %ecx
movl 0x10(%rax), %r8d
callq 0x3c26
movq 0x6b05(%rip), %rdi      # 0x94d0
addq $0x28, %rdi
jmp 0x2996
movq 0x6b00(%rip), %rdi      # 0x94d8
callq 0x3a60
movq 0x6af4(%rip), %rax      # 0x94d8
addq $0x48, %rax
jmp 0x2983
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/gitluin[P]sara/src/sara.c
// Function: configurerequest
void
configurerequest(XEvent* e){
	client* c;
	monitor* m;
	XWindowChanges wc;
	XConfigureRequestEvent* ev = &e->xconfigurerequest;

	if ( (c = findclient(ev->window)) ){
		if (c->isfloat){
			m = c->mon;
			if (ev->value_mask & CWX)
				c->x = m->mx + ev->x;
			if (ev->value_mask & CWY)
				c->y = (ev->y < barpx) ? barpx : ev->y;
			if (ev->value_mask & CWWidth)
				c->w = ev->width;
			if (ev->value_mask & CWHeight)
				c->h = ev->height;
			if ((c->x + c->w) > m->mx + m->mw)
				c->x = m->mx + (m->mw / 2 - c->w / 2);
			if ((c->y + c->h) > m->wy + m->wh)
				c->y = m->wy + (m->wh / 2 - c->h / 2);
			if ((ev->value_mask & (CWX|CWY)) && !(ev->value_mask & (CWWidth|CWHeight)))
				configure(c);
			if (ISVISIBLE(c))
				XMoveResizeWindow(dis, c->win, c->x, c->y, c->w, c->h);

		} else {
			configure(c);
		}

	} else {
		wc.x = ev->x;
		wc.y = ev->y;
		wc.width = ev->width;
		wc.height = ev->height;
		wc.sibling = ev->above;
		wc.stack_mode = ev->detail;
		XConfigureWindow(dis, ev->window, ev->value_mask, &wc);
	}

	XSync(dis, False);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x28(%rdi), %rdi
callq 0x4b6c
testq %rax, %rax
je 0x2b04
movq %rax, %rbx
cmpl $0x0, 0x10(%rax)
je 0x2b34
movq 0x30(%rbx), %rdi
movq 0x58(%r14), %r8
testb $0x1, %r8b
je 0x2a2f
movl 0x30(%r14), %eax
addl 0x8(%rdi), %eax
movl %eax, (%rbx)
testb $0x2, %r8b
je 0x2a45
movl 0x34(%r14), %eax
cmpl $0x15, %eax
pushq $0x14
popq %rcx
cmovgel %eax, %ecx
movl %ecx, 0x4(%rbx)
testb $0x4, %r8b
je 0x2a52
movl 0x38(%r14), %eax
movl %eax, 0x8(%rbx)
testb $0x8, %r8b
je 0x2a5f
movl 0x3c(%r14), %eax
movl %eax, 0xc(%rbx)
movl 0x8(%rbx), %ecx
movl (%rbx), %edx
addl %ecx, %edx
movl 0x8(%rdi), %r11d
movl 0x14(%rdi), %eax
leal (%rax,%r11), %esi
pushq $0x2
popq %r10
pushq $-0x2
popq %r9
cmpl %esi, %edx
jle 0x2a92
cltd
idivl %r10d
movl %eax, %esi
movl %ecx, %eax
cltd
idivl %r9d
addl %eax, %r11d
addl %esi, %r11d
movl %r11d, (%rbx)
movl 0xc(%rbx), %ecx
movl 0x4(%rbx), %edx
addl %ecx, %edx
movl 0x18(%rdi), %r11d
movl 0x1c(%rdi), %eax
leal (%rax,%r11), %esi
cmpl %esi, %edx
jle 0x2abf
cltd
idivl %r10d
movl %eax, %esi
movl %ecx, %eax
cltd
idivl %r9d
addl %eax, %r11d
addl %esi, %r11d
movl %r11d, 0x4(%rbx)
testb $0x3, %r8b
sete %al
testb $0xc, %r8b
setne %cl
orb %al, %cl
jne 0x2add
movq %rbx, %rdi
callq 0x4d43
movq 0x30(%rbx), %rdi
movl 0x24(%rdi), %eax
testl %eax, 0x1c(%rbx)
je 0x2b3c
movq 0x69d4(%rip), %rdi      # 0x94c0
movq 0x38(%rbx), %rsi
movl (%rbx), %edx
movl 0x4(%rbx), %ecx
movl 0x8(%rbx), %r8d
movl 0xc(%rbx), %r9d
callq 0x2250
jmp 0x2b3c
movups 0x30(%r14), %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movq 0x48(%r14), %rax
movq %rax, 0x18(%rcx)
movl 0x50(%r14), %eax
movl %eax, 0x20(%rcx)
movq 0x699b(%rip), %rdi      # 0x94c0
movq 0x28(%r14), %rsi
movl 0x58(%r14), %edx
callq 0x20a0
jmp 0x2b3c
movq %rbx, %rdi
callq 0x4d43
movq 0x697d(%rip), %rdi      # 0x94c0
xorl %esi, %esi
callq 0x2330
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6986(%rip), %rsi      # 0x94e0
callq *0x6858(%rip)           # 0x93b8
movq 0x6981(%rip), %rdi      # 0x94e8
movss (%rdi), %xmm0
cvtss2sd %xmm0, %xmm2
movl 0x14(%rdi), %eax
cvtsi2sd %eax, %xmm3
movsd 0x348a(%rip), %xmm1     # 0x6008
mulsd %xmm3, %xmm1
ucomisd %xmm2, %xmm1
movss 0x6952(%rip), %xmm1     # 0x94e0
jbe 0x2b98
xorps %xmm4, %xmm4
ucomiss %xmm4, %xmm1
ja 0x2bb2
mulsd 0x3470(%rip), %xmm3     # 0x6010
ucomisd %xmm3, %xmm2
xorps %xmm2, %xmm2
jbe 0x2bbd
xorpd %xmm3, %xmm3
ucomiss %xmm1, %xmm3
jbe 0x2bbd
cvtsi2ss %eax, %xmm2
mulss %xmm2, %xmm1
movaps %xmm1, %xmm2
addss %xmm2, %xmm0
movss %xmm0, (%rdi)
popq %rax
jmp 0x3a60
// File: /workspace/github_c_makefile_star2_O2/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 0x69ee(%rip), %rax      # 0x95c0
cmpq $0x0, 0x48(%rax)
je 0x2c05
pushq %rax
leaq 0x68ff(%rip), %rsi      # 0x94e0
callq *0x67c9(%rip)           # 0x93b0
movl 0x68f3(%rip), %edi      # 0x94e0
callq 0x48b8
testq %rax, %rax
leaq 0x8(%rsp), %rsp
je 0x2c06
cmpq 0x68e5(%rip), %rax      # 0x94e8
jne 0x2c06
retq
pushq $0x1
popq %rsi
movq %rax, %rdi
jmp 0x45b1
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq 0x68c3(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x2d50
movq 0x38(%rax), %rbx
movq 0x6883(%rip), %rdi      # 0x94c0
leaq 0x34ca(%rip), %rsi      # 0x610e
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x23c0
movq %rax, %r14
movq 0x6869(%rip), %rdi      # 0x94c0
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
movq %rbx, %rsi
callq 0x2450
testl %eax, %eax
je 0x2d01
movslq 0xc(%rsp), %rax
movq 0x10(%rsp), %rdi
leaq -0x1(%rax), %rcx
testl %ebp, %ebp
jne 0x2c9b
cmpq $-0x1, %rcx
je 0x2cf7
decq %rax
xorl %ebp, %ebp
cmpq %r14, (%rdi,%rcx,8)
sete %bpl
decq %rcx
jmp 0x2c7f
movl %eax, 0xc(%rsp)
callq 0x2040
leaq 0x18(%rsp), %r15
movl $0x21, (%r15)
movq %rbx, 0x20(%r15)
movq 0x6805(%rip), %rdi      # 0x94c0
leaq 0x345d(%rip), %rsi      # 0x611f
pushq $0x1
popq %rdx
callq 0x23c0
movq %rax, 0x28(%r15)
movl $0x20, 0x30(%r15)
movq %r14, 0x38(%r15)
andq $0x0, 0x40(%r15)
movq 0x67da(%rip), %rdi      # 0x94c0
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r15, %r8
callq 0x2350
jmp 0x2d50
orl $-0x1, 0xc(%rsp)
callq 0x2040
movq 0x67b8(%rip), %rdi      # 0x94c0
callq 0x20b0
movq 0x67ac(%rip), %rdi      # 0x94c0
xorl %esi, %esi
callq 0x20e0
movq 0x679e(%rip), %rdi      # 0x94c0
movq 0x67bf(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
movq 0x38(%rax), %rsi
callq 0x24d0
movq 0x6783(%rip), %rdi      # 0x94c0
xorl %esi, %esi
callq 0x2330
movq 0x6775(%rip), %rdi      # 0x94c0
callq 0x2240
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq 0x677f(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x2e2d
cmpl $0x0, 0x18(%rax)
jne 0x2e2d
leaq 0x6759(%rip), %rsi      # 0x94e0
callq *0x6623(%rip)           # 0x93b0
movl 0x674d(%rip), %eax      # 0x94e0
leal 0x1(%rax), %ecx
cmpl $0x2, %ecx
ja 0x2e2d
movq 0x6742(%rip), %rcx      # 0x94e8
movq 0x28(%rcx), %rbx
testl %eax, %eax
jg 0x2dbd
movq 0x28(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x3a34
movq %rax, %rbx
testq %rbx, %rbx
je 0x2e2d
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %edx, %esi
callq 0x3b04
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3b04
testq %r14, %r14
setne %cl
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x2e1d
movq 0x30(%rbx), %rdx
addq $0x30, %rdx
movq %rdx, %rcx
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x2e0e
leaq 0x28(%rsi), %rdx
cmpq %r14, %rsi
jne 0x2dfa
movq 0x28(%rbx), %rdx
movq %rdx, 0x28(%rax)
movq %r14, 0x28(%rbx)
movq %rbx, (%rcx)
movq 0x30(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3a60
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x66ab(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x2e4c
cmpl $0x0, 0x18(%rax)
je 0x2e4e
popq %rax
retq
leaq 0x668b(%rip), %rsi      # 0x94e0
callq *0x6555(%rip)           # 0x93b0
cmpl $0x0, 0x667e(%rip)      # 0x94e0
jle 0x2e93
movq 0x667d(%rip), %rcx      # 0x94e8
leaq 0x30(%rcx), %rax
xorl %edi, %edi
movq (%rax), %rax
testq %rax, %rax
je 0x2eed
cmpq 0x28(%rcx), %rax
je 0x2ebc
movq 0x30(%rax), %rdx
movl 0x24(%rdx), %edx
testl %edx, 0x1c(%rax)
cmovneq %rax, %rdi
addq $0x28, %rax
jmp 0x2e71
jns 0x2e4c
movq 0x664c(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
movq 0x28(%rax), %rdi
xorl %esi, %esi
callq 0x3a34
movq 0x6636(%rip), %rsi      # 0x94e8
testq %rax, %rax
je 0x2edf
movq %rax, %rdi
jmp 0x2efd
testq %rdi, %rdi
jne 0x2ef6
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 0x2ec3
jmp 0x2eed
movq 0x30(%rsi), %rdi
xorl %esi, %esi
callq 0x3a34
movq %rax, %rdi
testq %rdi, %rdi
je 0x2e4c
movq 0x65eb(%rip), %rsi      # 0x94e8
cmpq 0x28(%rsi), %rdi
je 0x2e4c
movl 0x4(%rsi), %edx
xorl %ecx, %ecx
callq 0x3eb5
movq 0x65d0(%rip), %rdi      # 0x94e8
popq %rax
jmp 0x3b63
// File: /workspace/github_c_makefile_star2_O2/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 0x6599(%rip), %rax      # 0x94e8
cmpq $0x0, 0x28(%rax)
je 0x2f83
leaq 0x6583(%rip), %rsi      # 0x94e0
callq *0x644d(%rip)           # 0x93b0
movl 0x6577(%rip), %ecx      # 0x94e0
cmpl $0x9, %ecx
ja 0x2f83
pushq $0x1
popq %rdx
shll %cl, %edx
movq 0x656e(%rip), %rsi      # 0x94e8
movq 0x28(%rsi), %rdi
cmpl %edx, 0x1c(%rdi)
jne 0x2f85
popq %rax
retq
movl %edx, 0x1c(%rdi)
andl $0x0, 0x20(%rdi)
pushq $0x1
popq %rcx
callq 0x3eb5
movq 0x654d(%rip), %rdi      # 0x94e8
callq 0x3a60
popq %rax
jmp 0x4701
// File: /workspace/github_c_makefile_star2_O2/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 0x653a(%rip), %rax      # 0x94e8
cmpq $0x0, 0x28(%rax)
je 0x2fe7
leaq 0x6524(%rip), %rsi      # 0x94e0
callq *0x63ee(%rip)           # 0x93b0
movl 0x6518(%rip), %ecx      # 0x94e0
leal 0x1(%rcx), %eax
cmpl $0xa, %eax
ja 0x2fe7
movq 0x6511(%rip), %rsi      # 0x94e8
movq 0x28(%rsi), %rdi
movl 0x1c(%rdi), %eax
pushq $0x1
popq %rdx
shll %cl, %edx
cmpl %edx, %eax
jne 0x2fe9
popq %rax
retq
xorl %edx, %eax
movl %eax, 0x1c(%rdi)
xorl %ecx, %ecx
testl %eax, 0x24(%rsi)
sete %cl
callq 0x3eb5
movq 0x64e6(%rip), %rdi      # 0x94e8
callq 0x3a60
popq %rax
jmp 0x4701
// File: /workspace/github_c_makefile_star2_O2/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 0x64d4(%rip), %rdi      # 0x94e8
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x3023
cmpl $0x0, 0x18(%rax)
je 0x3024
retq
movq 0x40(%rdi), %rcx
leaq 0x1454(%rip), %rdx      # 0x4483
cmpq %rdx, 0x8(%rcx)
je 0x3023
xorl %ecx, %ecx
cmpl $0x0, 0x10(%rax)
sete %cl
movl %ecx, 0x10(%rax)
jmp 0x3a60
// File: /workspace/github_c_makefile_star2_O2/gitluin[P]sara/src/sara.c
// Function: togglefs
void
togglefs(const Arg arg){
	if (!curmon->current)
		return;

	if ( (curmon->current->isfull = !curmon->current->isfull) ){
		curmon->current->oldfloat = curmon->current->isfloat;
		curmon->current->isfloat = 0;

		resizeclient(curmon->current, curmon->mx, curmon->my,
				curmon->mw, curmon->mh);
#ifdef _SHAPE_H_
		unroundcorners(curmon->current);
#endif
		XRaiseWindow(dis, curmon->current->win);

	} else {
		curmon->current->isfloat = curmon->current->oldfloat;
		arrange(curmon);
	}
}

// Assembly:
movq 0x649b(%rip), %rdi      # 0x94e8
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x306f
xorl %ecx, %ecx
cmpl $0x0, 0x18(%rax)
sete %cl
movl %ecx, 0x18(%rax)
je 0x3070
movl 0x14(%rax), %ecx
movl %ecx, 0x10(%rax)
jmp 0x3a60
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl 0x10(%rax), %ecx
movl %ecx, 0x14(%rax)
andl $0x0, 0x10(%rax)
movl 0x8(%rdi), %esi
movl 0xc(%rdi), %edx
movl 0x14(%rdi), %ecx
movl 0x10(%rdi), %r8d
movq %rax, %rdi
callq 0x3c26
movq 0x6449(%rip), %rax      # 0x94e8
movq 0x28(%rax), %r15
testq %r15, %r15
je 0x3169
movq 0x640d(%rip), %rdi      # 0x94c0
movq 0x38(%r15), %rsi
movl 0x8(%r15), %edx
movl 0xc(%r15), %ecx
pushq $0x1
popq %r8
callq 0x2480
testq %rax, %rax
je 0x3169
movq %rax, %rbx
movq 0x63e5(%rip), %rdi      # 0x94c0
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22f0
movq 0x63d2(%rip), %rdi      # 0x94c0
testq %rax, %rax
je 0x3161
movq %rax, %r14
pushq $0x1
popq %rdx
movq %rax, %rsi
callq 0x21f0
movq 0x63b8(%rip), %rdi      # 0x94c0
movl 0x8(%r15), %r9d
movl 0xc(%r15), %eax
movl %eax, (%rsp)
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2200
movq 0x6396(%rip), %rdi      # 0x94c0
movq 0x38(%r15), %rsi
andl $0x0, (%rsp)
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x2380
movq 0x6378(%rip), %rdi      # 0x94c0
movq %rbx, %rsi
callq 0x2420
movq 0x6369(%rip), %rdi      # 0x94c0
movq %r14, %rsi
callq 0x2230
jmp 0x3169
movq %rbx, %rsi
callq 0x2420
movq 0x6350(%rip), %rdi      # 0x94c0
movq 0x6371(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
movq 0x38(%rax), %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O2/gitluin[P]sara/src/sara.c
// Function: toggleview
void
toggleview(const Arg arg){
	int i;
	unsigned int tagmask;

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

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

	if (parg.i < 0)
		tagmask = ~(curmon->seldesks);
	else
		tagmask = 1 << parg.i;

	/* if this would leave nothing visible */
	if ((curmon->seldesks ^ tagmask) == 0)
		return;

	if (curmon->current && curmon->current->isfull)
		togglefs(dumbarg);

	curmon->seldesks ^= tagmask;

	if (!(curmon->seldesks & 1 << curmon->curdesk)){
		for (i=0;i < NUMTAGS;i++){
			if (curmon->seldesks & 1 << i){
				loaddesktop(i);
				curmon->curdesk = i;
				break;
			}
		}
	}

	/* refocuses, toggles off curmon->current's currentness */
	if (curmon->current && !ISVISIBLE(curmon->current))
		changecurrent(curmon->current, curmon, curmon->curdesk, 1);

	arrange(curmon);
	outputstats();
}

// Assembly:
pushq %rbx
leaq 0x634b(%rip), %rsi      # 0x94e0
callq *0x6215(%rip)           # 0x93b0
movl 0x633f(%rip), %ecx      # 0x94e0
leal 0x1(%rcx), %eax
cmpl $0xa, %eax
ja 0x31c0
testl %ecx, %ecx
js 0x31c2
pushq $0x1
popq %rbx
shll %cl, %ebx
movq 0x632f(%rip), %rsi      # 0x94e8
movl 0x24(%rsi), %eax
cmpl %ebx, %eax
jne 0x31d0
popq %rbx
retq
movq 0x631f(%rip), %rsi      # 0x94e8
movl 0x24(%rsi), %eax
movl %eax, %ebx
notl %ebx
movq 0x28(%rsi), %rcx
testq %rcx, %rcx
je 0x31ee
cmpl $0x0, 0x18(%rcx)
je 0x31ee
callq 0x3046
movq 0x62fd(%rip), %rsi      # 0x94e8
movl 0x24(%rsi), %eax
xorl %ebx, %eax
movl %eax, 0x24(%rsi)
movl 0x4(%rsi), %ecx
btl %ecx, %eax
jae 0x3231
movl %ecx, %ebx
movq 0x28(%rsi), %rdi
testq %rdi, %rdi
je 0x3223
movq 0x30(%rdi), %rax
movl 0x24(%rax), %eax
testl %eax, 0x1c(%rdi)
jne 0x3223
pushq $0x1
popq %rcx
movl %ebx, %edx
callq 0x3eb5
movq 0x62c5(%rip), %rsi      # 0x94e8
movq %rsi, %rdi
callq 0x3a60
popq %rbx
jmp 0x4701
xorl %ebx, %ebx
cmpl $0x9, %ebx
je 0x31fb
btl %ebx, %eax
jb 0x3241
incl %ebx
jmp 0x3233
movl %ebx, %edi
callq 0x4b22
movq 0x6299(%rip), %rsi      # 0x94e8
movl %ebx, 0x4(%rsi)
jmp 0x31fd
// File: /workspace/github_c_makefile_star2_O2/gitluin[P]sara/src/sara.c
// Function: tomon
void
tomon(const Arg arg){
	if (!curmon->current || !mhead->next)
		return;
	
	parser[WantInt](arg.s, &parg);

	sendmon(curmon->current, dirtomon(parg.i));
	outputstats();
}

// Assembly:
movq 0x628d(%rip), %rax      # 0x94e8
cmpq $0x0, 0x28(%rax)
je 0x32a5
movq 0x6357(%rip), %rax      # 0x95c0
cmpq $0x0, 0x48(%rax)
je 0x32a5
pushq %rbx
leaq 0x6268(%rip), %rsi      # 0x94e0
callq *0x6132(%rip)           # 0x93b0
movq 0x6263(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rbx
movl 0x6251(%rip), %edi      # 0x94e0
callq 0x48b8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x44fc
popq %rbx
jmp 0x4701
retq
// File: /workspace/github_c_makefile_star2_O2/gitluin[P]sara/src/sara.c
// Function: setlayout
void
setlayout(const Arg arg){
	int i;
	for (i=0;i < TABLENGTH(layouts);i++)
		if (STREQ(arg.s, layouts[i].name))
			curmon->curlayout = (layout*) &layouts[i];

	arrange(curmon);
	outputstats();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x6230(%rip), %rbx      # 0x94e8
xorl %r15d, %r15d
leaq 0x5a9e(%rip), %r12      # 0x8d60
cmpq $0x48, %r15
je 0x32e7
movq 0x10(%r15,%r12), %rsi
movq %r14, %rdi
callq 0x2370
testl %eax, %eax
jne 0x32e1
leaq (%r12,%r15), %rax
movq %rax, 0x40(%rbx)
addq $0x18, %r15
jmp 0x32c2
movq %rbx, %rdi
callq 0x3a60
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4701