LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/x.c
// Function: mouseaction
int
mouseaction(XEvent *e, uint release)
{
	MouseShortcut *ms;

	/* ignore Button<N>mask for Button<N> - it's set on release */
	uint state = e->xbutton.state & ~buttonmask(e->xbutton.button);

	for (ms = mshortcuts; ms < mshortcuts + LEN(mshortcuts); ms++) {
		if (ms->release == release &&
		    ms->button == e->xbutton.button &&
		    (!ms->altscrn || (ms->altscrn == (tisaltscr() ? 1 : -1))) &&
		    (match(ms->mod, state) ||  /* exact or forced */
		     match(ms->mod, state & ~forcemousemod))) {
			ms->func(&(ms->arg));
			return 1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x50(%rdi), %eax
movl 0x54(%rdi), %ecx
leal -0x1(%rcx), %edx
cmpl $0x4, %edx
jae 0xfa32
movl %edx, %ecx
leaq 0x22a3(%rip), %rdx      # 0x11cd0
movl (%rdx,%rcx,4), %ebp
jmp 0xfa43
xorl %ebp, %ebp
cmpl $0x5, %ecx
setne %bpl
negl %ebp
orl $0xffffefff, %ebp       # imm = 0xFFFFEFFF
andl %eax, %ebp
movl %ebp, %eax
andl $0xffff9fef, %eax       # imm = 0xFFFF9FEF
movl %eax, 0x4(%rsp)
andl $0xffff9fee, %ebp       # imm = 0xFFFF9FEE
leaq 0x9973(%rip), %r13      # 0x193d0
xorl %r15d, %r15d
cmpq $0xdf, %r15
ja 0xfab5
cmpl %ebx, 0x18(%r15,%r13)
jne 0xfaaf
movl 0x4(%r15,%r13), %eax
cmpl 0x54(%r14), %eax
jne 0xfaaf
movl 0x1c(%r15,%r13), %r12d
testl %r12d, %r12d
je 0xfa9c
callq 0x8327
cmpl $0x1, %eax
movl $0x0, %eax
sbbl %eax, %eax
orl $0x1, %eax
cmpl %eax, %r12d
jne 0xfaaf
movl (%r15,%r13), %eax
cmpl $-0x1, %eax
je 0xfac6
cmpl %eax, 0x4(%rsp)
je 0xfac6
cmpl %eax, %ebp
je 0xfac6
addq $0x20, %r15
jmp 0xfa60
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq (%r15,%r13), %rdi
addq $0x10, %rdi
callq *-0x8(%rdi)
pushq $0x1
popq %rax
jmp 0xfab7
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/boxdraw.c
// Function: boxdrawindex
ushort
boxdrawindex(const Glyph *g)
{
	if (boxdraw_braille && (g->u & ~0xff) == 0x2800)
		return BRL | (uint8_t)g->u;
	if (boxdraw_bold && (g->mode & ATTR_BOLD))
		return BDB | boxdata[(uint8_t)g->u];
	return boxdata[(uint8_t)g->u];
}

// Assembly:
leaq 0x2049(%rip), %rax      # 0x11c5c
cmpl $0x0, (%rax)
je 0xfc33
movl (%rdi), %eax
movl %eax, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
cmpl $0x2800, %ecx           # imm = 0x2800
jne 0xfc33
movzbl %al, %eax
orl $0x1800, %eax           # imm = 0x1800
retq
leaq 0x201e(%rip), %rax      # 0x11c58
cmpl $0x0, (%rax)
je 0xfc59
testb $0x1, 0x4(%rdi)
movzbl (%rdi), %eax
je 0xfc5c
leaq 0x2b21(%rip), %rcx      # 0x12770
movzwl (%rcx,%rax,2), %eax
orl $0x8000, %eax           # imm = 0x8000
retq
movzbl (%rdi), %eax
movl %eax, %eax
leaq 0x2b0b(%rip), %rcx      # 0x12770
movzwl (%rcx,%rax,2), %eax
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/perftests/dynamodb_kv/main.c
// Function: callback_get
static int
callback_get(void * cookie, int status, const uint8_t * buf, size_t buflen)
{
	struct status * C = cookie;

	C->done = 1;
	C->status = status;
	if (status == 0) {
		fprintf(stderr, "value returned: \"");
		fwrite(buf, buflen, 1, stderr);
		fprintf(stderr, "\"\n");
	} else if (status == 2) {
		fprintf(stderr, "no value associated\n");
	}

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, (%rdi)
movl %esi, 0x4(%rdi)
cmpl $0x2, %esi
je 0x2d51
testl %esi, %esi
je 0x2d05
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rcx, %rbx
movq %rdx, %r14
movq 0xc2e6(%rip), %r12      # 0xeff8
movq (%r12), %rcx
leaq 0x6563(%rip), %rdi      # 0x9280
pushq $0x11
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
callq 0x22a0
movq (%r12), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x22a0
movq (%r12), %rcx
leaq 0x64da(%rip), %rdi      # 0x9223
pushq $0x2
popq %rsi
movq %r15, %rdx
jmp 0x2d68
movq 0xc2a0(%rip), %rax      # 0xeff8
movq (%rax), %rcx
leaq 0x6530(%rip), %rdi      # 0x9292
pushq $0x14
popq %rsi
pushq $0x1
popq %rdx
callq 0x22a0
jmp 0x2cf7
nop
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../lib/proto_dynamodb_kv/proto_dynamodb_kv_client.c
// Function: proto_dynamodb_kv_request_get
int
proto_dynamodb_kv_request_get(struct wire_requestqueue * Q, const char * key,
    int (* callback)(void *, int, const uint8_t *, size_t), void * cookie)
{
	struct data_cookie * C;
	uint8_t *rbuf, *p;
	size_t rlen;

	/* Validate key length. */
	if (strlen(key) > 255) {
		warn0("Key is too long");
		goto err0;
	}

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

	/* Compute request packet size. */
	rlen = 4 + 1 + strlen(key);

	/* Start writing a request. */
	if ((p = rbuf = wire_requestqueue_add_getbuf(Q,
	    rlen, callback_data, C)) == NULL)
		goto err1;

	/* Construct request. */
	be32enc(p, PROTO_DDBKV_GET);
	p += 4;
	*p++ = (uint8_t)strlen(key);
	memcpy(p, key, strlen(key));
	p += strlen(key);

	/* Sanity check. */
	assert(p == &rbuf[rlen]);

	/* Finish writing request. */
	if (wire_requestqueue_add_done(Q, rbuf, rlen))
		goto err1;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x20f0
cmpq $0x100, %rax            # imm = 0x100
jb 0x589d
leaq 0x4034(%rip), %rdi      # 0x98ba
xorl %eax, %eax
callq 0x5170
callq 0x2090
andl $0x0, (%rax)
pushq $-0x1
popq %rbx
jmp 0x5948
movq %rax, %r15
movq %rbx, (%rsp)
pushq $0x10
popq %rdi
callq 0x21d0
pushq $-0x1
popq %rbx
testq %rax, %rax
je 0x5948
movq %rax, %r12
movq %r14, (%rax)
movq %rbp, 0x8(%rax)
addq $0x5, %r15
leaq 0xab(%rip), %rdx        # 0x5978
movq (%rsp), %rdi
movq %r15, %rsi
movq %rax, %rcx
callq 0x5f07
testq %rax, %rax
je 0x593c
movq %rax, %rbp
movl $0x10010100, (%rax)     # imm = 0x10010100
movq %r13, %rdi
callq 0x20f0
leaq 0x5(%rbp), %r14
movb %al, 0x4(%rbp)
movq %r13, %rdi
callq 0x20f0
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x21b0
movq %r13, %rdi
callq 0x20f0
addq %rbp, %rax
addq $0x5, %rax
movq %rbp, %rcx
addq %r15, %rcx
cmpq %rcx, %rax
jne 0x5959
movq (%rsp), %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x6129
testl %eax, %eax
je 0x5946
movq %r12, %rdi
callq 0x2040
jmp 0x5948
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3f7c(%rip), %rdi      # 0x98dc
leaq 0x3f86(%rip), %rsi      # 0x98ed
leaq 0x4159(%rip), %rcx      # 0x9ac7
movl $0x18b, %edx            # imm = 0x18B
callq 0x2140
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../lib/proto_dynamodb_kv/proto_dynamodb_kv_client.c
// Function: callback_data
static int
callback_data(void * cookie, uint8_t * buf, size_t buflen)
{
	struct data_cookie * C = cookie;
	int failed = 1;
	uint32_t status;
	uint32_t len = 0;
	uint8_t * dbuf = NULL;
	int rc;

	/* If we have a packet, parse it. */
	if (buf != NULL) {
		/* Do we have the right packet length? */
		if (buflen < 4)
			BAD("GET", "bogus length");

		/* Parse the status. */
		status = be32dec(&buf[0]);

		/* Non-zero status is a failure. */
		switch (status) {
		case 0:
			break;
		case 1:
		case 2:
			if (buflen != 4)
				BAD("GET", "bogus length");
			failed = (int)status;
			goto failed;
		default:
			BAD("GET", "invalid status");
		}

		/* Parse the data length. */
		if (buflen < 8)
			BAD("GET", "bogus length");
		len = be32dec(&buf[4]);

		/* Do we have the right packet length? */
		if (buflen != 8 + len)
			BAD("GET", "bogus length");

		/* Success!  Point at the data. */
		failed = 0;
		dbuf = &buf[8];
	}

failed:
	/* Invoke the upstream callback. */
	rc = (C->callback)(C->cookie, failed, dbuf, len);

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
testq %rsi, %rsi
je 0x59bd
movq %rdx, %r12
cmpq $0x3, %rdx
ja 0x59e6
leaq 0x42a0(%rip), %rdi      # 0x9c3b
leaq 0x42d2(%rip), %rsi      # 0x9c74
leaq 0x42af(%rip), %rdx      # 0x9c58
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x5170
callq 0x2090
andl $0x0, (%rax)
jmp 0x59c0
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rdi
movl %r14d, %ecx
movl %ebp, %esi
movq %r15, %rdx
callq *(%rbx)
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2040
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r15
movq %rsi, %rdi
callq 0x5cb5
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x5a09
cmpq $0x4, %r12
jne 0x5994
xorl %r14d, %r14d
xorl %r15d, %r15d
movl %eax, %ebp
jmp 0x59c3
testl %eax, %eax
jne 0x5a2f
cmpq $0x7, %r12
jbe 0x5994
leaq 0x4(%r15), %rdi
callq 0x5cb5
movl %eax, %r14d
addl $0x8, %eax
cmpq %r12, %rax
jne 0x5a49
addq $0x8, %r15
xorl %ebp, %ebp
jmp 0x59c3
leaq 0x4205(%rip), %rdi      # 0x9c3b
leaq 0x4237(%rip), %rsi      # 0x9c74
leaq 0x4221(%rip), %rdx      # 0x9c65
jmp 0x59a9
leaq 0x41eb(%rip), %rdi      # 0x9c3b
leaq 0x421d(%rip), %rsi      # 0x9c74
leaq 0x41fa(%rip), %rdx      # 0x9c58
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x5170
callq 0x2090
andl $0x0, (%rax)
jmp 0x59c3
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../lib/proto_dynamodb_kv/proto_dynamodb_kv_client.c
// Function: proto_dynamodb_kv_request_getc
int
proto_dynamodb_kv_request_getc(struct wire_requestqueue * Q, const char * key,
    int (* callback)(void *, int, const uint8_t *, size_t), void * cookie)
{
	struct data_cookie * C;
	uint8_t *rbuf, *p;
	size_t rlen;

	/* Validate key length. */
	if (strlen(key) > 255) {
		warn0("Key is too long");
		goto err0;
	}

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

	/* Compute request packet size. */
	rlen = 4 + 1 + strlen(key);

	/* Start writing a request. */
	if ((p = rbuf = wire_requestqueue_add_getbuf(Q,
	    rlen, callback_data, C)) == NULL)
		goto err1;

	/* Construct request. */
	be32enc(p, PROTO_DDBKV_GETC);
	p += 4;
	*p++ = (uint8_t)strlen(key);
	memcpy(p, key, strlen(key));
	p += strlen(key);

	/* Sanity check. */
	assert(p == &rbuf[rlen]);

	/* Finish writing request. */
	if (wire_requestqueue_add_done(Q, rbuf, rlen))
		goto err1;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x20f0
cmpq $0x100, %rax            # imm = 0x100
jb 0x5aba
leaq 0x3e17(%rip), %rdi      # 0x98ba
xorl %eax, %eax
callq 0x5170
callq 0x2090
andl $0x0, (%rax)
pushq $-0x1
popq %rbx
jmp 0x5b65
movq %rax, %r15
movq %rbx, (%rsp)
pushq $0x10
popq %rdi
callq 0x21d0
pushq $-0x1
popq %rbx
testq %rax, %rax
je 0x5b65
movq %rax, %r12
movq %r14, (%rax)
movq %rbp, 0x8(%rax)
addq $0x5, %r15
leaq -0x172(%rip), %rdx      # 0x5978
movq (%rsp), %rdi
movq %r15, %rsi
movq %rax, %rcx
callq 0x5f07
testq %rax, %rax
je 0x5b59
movq %rax, %rbp
movl $0x11010100, (%rax)     # imm = 0x11010100
movq %r13, %rdi
callq 0x20f0
leaq 0x5(%rbp), %r14
movb %al, 0x4(%rbp)
movq %r13, %rdi
callq 0x20f0
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x21b0
movq %r13, %rdi
callq 0x20f0
addq %rbp, %rax
addq $0x5, %rax
movq %rbp, %rcx
addq %r15, %rcx
cmpq %rcx, %rax
jne 0x5b76
movq (%rsp), %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x6129
testl %eax, %eax
je 0x5b63
movq %r12, %rdi
callq 0x2040
jmp 0x5b65
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3d5f(%rip), %rdi      # 0x98dc
leaq 0x3d69(%rip), %rsi      # 0x98ed
leaq 0x3fbf(%rip), %rcx      # 0x9b4a
movl $0x1c4, %edx            # imm = 0x1C4
callq 0x2140
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../lib/proto_dynamodb_kv/proto_dynamodb_kv_client.c
// Function: proto_dynamodb_kv_request_delete
int
proto_dynamodb_kv_request_delete(struct wire_requestqueue * Q,
    const char * key, int (* callback)(void *, int), void * cookie)
{
	struct status_cookie * C;
	uint8_t *rbuf, *p;
	size_t rlen;

	/* Validate key length. */
	if (strlen(key) > 255) {
		warn0("Key is too long");
		goto err0;
	}

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

	/* Compute request packet size. */
	rlen = 4 + 1 + strlen(key);

	/* Start writing a request. */
	if ((p = rbuf = wire_requestqueue_add_getbuf(Q,
	    rlen, callback_status, C)) == NULL)
		goto err1;

	/* Construct request. */
	be32enc(p, PROTO_DDBKV_DELETE);
	p += 4;
	*p++ = (uint8_t)strlen(key);
	memcpy(p, key, strlen(key));
	p += strlen(key);

	/* Sanity check. */
	assert(p == &rbuf[rlen]);

	/* Finish writing request. */
	if (wire_requestqueue_add_done(Q, rbuf, rlen))
		goto err1;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x20f0
cmpq $0x100, %rax            # imm = 0x100
jb 0x5bda
leaq 0x3cf7(%rip), %rdi      # 0x98ba
xorl %eax, %eax
callq 0x5170
callq 0x2090
andl $0x0, (%rax)
pushq $-0x1
popq %rbx
jmp 0x5c85
movq %rax, %r15
movq %rbx, (%rsp)
pushq $0x10
popq %rdi
callq 0x21d0
pushq $-0x1
popq %rbx
testq %rax, %rax
je 0x5c85
movq %rax, %r12
movq %r14, (%rax)
movq %rbp, 0x8(%rax)
addq $0x5, %r15
leaq -0x78f(%rip), %rdx      # 0x547b
movq (%rsp), %rdi
movq %r15, %rsi
movq %rax, %rcx
callq 0x5f07
testq %rax, %rax
je 0x5c79
movq %rax, %rbp
movl $0x20010100, (%rax)     # imm = 0x20010100
movq %r13, %rdi
callq 0x20f0
leaq 0x5(%rbp), %r14
movb %al, 0x4(%rbp)
movq %r13, %rdi
callq 0x20f0
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x21b0
movq %r13, %rdi
callq 0x20f0
addq %rbp, %rax
addq $0x5, %rax
movq %rbp, %rcx
addq %r15, %rcx
cmpq %rcx, %rax
jne 0x5c96
movq (%rsp), %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x6129
testl %eax, %eax
je 0x5c83
movq %r12, %rdi
callq 0x2040
jmp 0x5c85
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3c3f(%rip), %rdi      # 0x98dc
leaq 0x3c49(%rip), %rsi      # 0x98ed
leaq 0x3f23(%rip), %rcx      # 0x9bce
movl $0x1ff, %edx            # imm = 0x1FF
callq 0x2140
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/omdsha512k128n128tau128v2/ref/omdsha512.c
// Function: double_block
void
double_block (hashblock res, const hashblock in)
{
    unsigned int i;
    /* create bitmask from msb using signed shift */
    unsigned char carry = in[0] & 0x80;

    for (i = 0; i < OMD_n-1; i++)
       {
	  /* shift with carry from next block */
	  res[i] = (in[i] << 1) | (in[i+1] >> 7);
       }
	
	res[OMD_n -1] = (in[OMD_n -1] << 1);

    /* xor P(x) if msb */
	if(carry) {
	    res[OMD_n -2] = res[OMD_n -2] ^ 0x01;
	    res[OMD_n -1] = res[OMD_n -1] ^ 0x25;
	}
}

// Assembly:
movb (%rsi), %al
xorl %ecx, %ecx
cmpq $0x3f, %rcx
je 0x12be
movb (%rsi,%rcx), %dl
movb 0x1(%rsi,%rcx), %r8b
shrb $0x7, %r8b
addb %dl, %dl
orb %r8b, %dl
movb %dl, (%rdi,%rcx)
incq %rcx
jmp 0x129f
movb 0x3f(%rsi), %cl
addb %cl, %cl
movb %cl, 0x3f(%rdi)
testb %al, %al
js 0x12cb
retq
xorb $0x1, 0x3e(%rdi)
xorb $0x25, %cl
movb %cl, 0x3f(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/omdsha512k128n128tau128v2/ref/omdsha512.c
// Function: triple_block
void
triple_block (hashblock res, const hashblock in)
{
    unsigned int i;
    /* create bitmask from msb using signed shift */
    unsigned char carry = in[0] & 0x80;

    for (i = 0; i < OMD_n -1; i++)
       {
	  /* shift and xor */
	  res[i] = in[i] ^ ((in[i] << 1) | (in[i+1] >> 7));
       }

	res[OMD_n -1] = in[OMD_n -1] ^ (in[OMD_n -1] << 1);

    /* xor P(x) if msb */
	if(carry) {
	    res[OMD_n -2] = res[OMD_n -2] ^ 0x01;
	    res[OMD_n -1] = res[OMD_n -1] ^ 0x25;
	}
}

// Assembly:
movb (%rsi), %al
xorl %ecx, %ecx
cmpq $0x3f, %rcx
je 0x12ff
movb (%rsi,%rcx), %dl
movb 0x1(%rsi,%rcx), %r8b
shrb $0x7, %r8b
leal (%rdx,%rdx), %r9d
orb %r8b, %r9b
xorb %dl, %r9b
movb %r9b, (%rdi,%rcx)
incq %rcx
jmp 0x12da
movb 0x3f(%rsi), %dl
leal (%rdx,%rdx), %ecx
xorb %dl, %cl
movb %cl, 0x3f(%rdi)
testb %al, %al
js 0x130f
retq
xorb $0x1, 0x3e(%rdi)
xorb $0x25, %cl
movb %cl, 0x3f(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/omdsha512k128n128tau128v2/ref/omdsha512.c
// Function: l2b
void
l2b (hashblock bit_string, int value)
{
   int ptr = value*8;
   unsigned int i = OMD_n;

   memset(bit_string, 0x00, OMD_n);

   while (i--)
      {   /* write the bytes of value into tau */
	 bit_string[i] = ptr & 0xff;
	 ptr >>= 8;
      }
}

// Assembly:
shll $0x3, %esi
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x20(%rdi)
vmovups %ymm0, (%rdi)
pushq $0x3f
popq %rax
cmpq $-0x1, %rax
je 0x1341
movl %eax, %ecx
movb %sil, (%rdi,%rcx)
sarl $0x8, %esi
decq %rax
jmp 0x132d
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/omdsha512k128n128tau128v2/ref/omdsha512.c
// Function: increment_masking_message
void
increment_masking_message (hashblock delta_n, const hashblock delta_o,
			   const hashblock lzero, int i)
{
   hashblock l;

   if (i < 1)
      {
	 return;
      }

   /* \delta_{N, i, 0} = \delta_{N, i-1, 0} ^ L[ntz(i)]  */
   calc_L_i (l, lzero, ntz(i));
   xor_block (delta_n, delta_o, l);

}

// Assembly:
testl %ecx, %ecx
jle 0x1418
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl %ecx, %edi
callq 0x1110
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x10d0
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1120
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/omdsha512k128n128tau128v2/ref/omdsha512.c
// Function: final_masking_message
void
final_masking_message (hashblock delta_n, const hashblock delta_o,
		       const hashblock lstar, int j)
{
   hashblock l;

   switch (j)
      {
	 /* \delta_{N, i, 1} = \delta_{N, i, 0} ^ 2*L_*  */
	 case 1: double_block (l, lstar); break;

	 /* \delta_{N, i, 2} = \delta_{N, i, 0} ^ 3*L_*  */
	 case 2: triple_block (l, lstar); break;
      }

	xor_block (delta_n, delta_o, l);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x2, %ecx
je 0x143d
cmpl $0x1, %ecx
jne 0x1448
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x1070
jmp 0x1448
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x10e0
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1120
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/dev.c
// Function: dev_read
int
dev_read(void *buf, size_t len)
{
	char tmp[4096];
	struct ps3dm_header *hdr;
	int ret;

	if (fd < 0)
		return (-1);

	hdr = (struct ps3dm_header *) tmp;

	while (1) {
		ret = read(fd, hdr, sizeof(*hdr));
		if (ret < 0) {
			if (errno != EAGAIN)
				return (-1);
		} else if (ret > 0) {
			break;
		}
	}

	while (1) {
		ret = read(fd, hdr + 1, hdr->reply_length);
		if (ret < 0) {
			if (errno != EAGAIN)
				return (-1);
		} else if (ret > 0) {
			break;
		}
	}

	if (len > (sizeof(*hdr) + hdr->reply_length))
		len = sizeof(*hdr) + hdr->reply_length;

	memcpy(buf, tmp, len);

	return (len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdi, %r14
movl 0x4d56(%rip), %edi      # 0x7230
pushq $-0x1
popq %rbx
testl %edi, %edi
js 0x2557
movq %rsi, %r15
movq %rsp, %r12
pushq $0x10
popq %r13
movq %r12, %rsi
movq %r13, %rdx
callq 0x20a0
testl %eax, %eax
js 0x24fe
je 0x2508
jmp 0x2510
callq 0x2030
cmpl $0xb, (%rax)
jne 0x2557
movl 0x4d22(%rip), %edi      # 0x7230
jmp 0x24eb
leaq 0x10(%rsp), %r12
movl 0x4d15(%rip), %edi      # 0x7230
movl 0xc(%rsp), %edx
movq %r12, %rsi
callq 0x20a0
testl %eax, %eax
js 0x252f
je 0x2515
jmp 0x253b
callq 0x2030
cmpl $0xb, (%rax)
je 0x2515
jmp 0x2557
movq %rsp, %rsi
movl 0xc(%rsi), %ebx
addq $0x10, %rbx
cmpq %r15, %rbx
cmovaeq %r15, %rbx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x20e0
movl %ebx, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/sm/cmd_sm_drive_auth.c
// Function: cmd_sm_drive_auth_exec
int
cmd_sm_drive_auth_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_sm_drive_auth drive_auth;
	uint64_t arg, laid, paid;
	char *endptr;
	int ret;

	arg = strtoull(argv[0], &endptr, 0);
	if (*endptr != '\0')
		return (CMD_EINVAL);

	laid = opts.laid_valid ? opts.laid : 0x1070000002000001ull;
	paid = opts.paid_valid ? opts.paid : 0x10700003ff000001ull;

	ps3dm_init_header(&drive_auth.dm_hdr, 1, PS3DM_FID_SM,
	    sizeof(drive_auth) - sizeof(struct ps3dm_header),
	    sizeof(drive_auth) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&drive_auth.ss_hdr, PS3DM_PID_SM_DRIVE_AUTH,
	    laid, paid);
	drive_auth.arg = arg;

	ret = dev_write(&drive_auth, sizeof(drive_auth));
	if (ret != sizeof(drive_auth))
		return (CMD_EIO);

	ret = dev_read(&drive_auth, sizeof(drive_auth));
	if (ret != sizeof(drive_auth))
		return (CMD_EIO);

	if (opts.do_verbose > 0)
		fprintf(stderr, "ss status %d\n", drive_auth.ss_hdr.status);

	if (drive_auth.ss_hdr.status)
		return (CMD_EIO);

	return (CMD_EOK);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq (%rcx), %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x20b0
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
je 0x25a5
pushq $0x2
popq %rbx
jmp 0x263b
leaq 0x4b14(%rip), %r14      # 0x70c0
cmpl $0x0, 0x20(%r14)
je 0x25b9
movq 0x18(%r14), %rcx
jmp 0x25c3
movabsq $0x1070000002000001, %rcx # imm = 0x1070000002000001
cmpl $0x0, 0x30(%r14)
je 0x25d0
movq 0x28(%r14), %rdx
jmp 0x25da
movabsq $0x10700003ff000001, %rdx # imm = 0x10700003FF000001
movaps 0x1b8f(%rip), %xmm0     # 0x4170
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x5004, 0x10(%rdi)     # imm = 0x5004
movq $0x5000, 0x18(%rdi)     # imm = 0x5000
movq %rcx, 0x28(%rdi)
movq %rdx, 0x30(%rdi)
movq %rax, 0x38(%rdi)
pushq $0x40
popq %rsi
callq 0x24a2
pushq $0x3
popq %rbx
cmpl $0x40, %eax
jne 0x263b
leaq 0x10(%rsp), %rdi
pushq $0x40
popq %rsi
callq 0x24c1
cmpl $0x40, %eax
jne 0x263b
cmpl $0x0, 0x8(%r14)
jg 0x2645
xorl %eax, %eax
cmpl $0x0, 0x30(%rsp)
setne %al
leal (%rax,%rax,2), %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq 0x49ac(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movl 0x30(%rsp), %edx
leaq 0x1b26(%rip), %rsi      # 0x4180
xorl %eax, %eax
callq 0x20d0
jmp 0x262e
nop
// File: /workspace/github_c_makefile_star2_O2/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/sm/cmd_sm_get_rnd.c
// Function: cmd_sm_get_rnd_exec
int
cmd_sm_get_rnd_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_sm_get_rnd get_rnd;
	uint64_t laid, paid;
	int len;
	int ret;

	laid = opts.laid_valid ? opts.laid : 0x1070000002000001ull;
	paid = opts.paid_valid ? opts.paid : 0x1070000031000001ull;

	ps3dm_init_header(&get_rnd.dm_hdr, 1, PS3DM_FID_SM,
	    sizeof(struct ps3dm_ss_header),
	    sizeof(get_rnd) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&get_rnd.ss_hdr, PS3DM_PID_SM_GET_RND,
	    laid, paid);

	len = sizeof(struct ps3dm_header) + sizeof(struct ps3dm_ss_header);

	ret = dev_write(&get_rnd, len);
	if (ret != len)
		return (CMD_EIO);

	ret = dev_read(&get_rnd, sizeof(get_rnd));
	if (ret != sizeof(get_rnd))
		return (CMD_EIO);

	if (opts.do_verbose > 0)
		fprintf(stderr, "ss status %d\n", get_rnd.ss_hdr.status);

	if (get_rnd.ss_hdr.status)
		return (CMD_EIO);

	fwrite((char *) get_rnd.rnd, 1, sizeof(get_rnd.rnd), stdout);

	return (CMD_EOK);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
leaq 0x4a4e(%rip), %r14      # 0x70c0
cmpl $0x0, 0x20(%r14)
movabsq $0x1070000002000001, %rax # imm = 0x1070000002000001
movq %rax, %rcx
je 0x268a
movq 0x18(%r14), %rcx
cmpl $0x0, 0x30(%r14)
je 0x2697
movq 0x28(%r14), %rax
jmp 0x269d
addq $0x2f000000, %rax       # imm = 0x2F000000
movaps 0x1b1c(%rip), %xmm0     # 0x41c0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x5003, 0x10(%rdi)     # imm = 0x5003
movq $0x5000, 0x18(%rdi)     # imm = 0x5000
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
pushq $0x38
popq %rsi
callq 0x24a2
pushq $0x3
popq %rbx
cmpl $0x38, %eax
jne 0x270c
movq %rsp, %rdi
pushq $0x50
popq %rsi
callq 0x24c1
cmpl $0x50, %eax
jne 0x270c
cmpl $0x0, 0x8(%r14)
jg 0x2716
cmpl $0x0, 0x20(%rsp)
jne 0x270c
leaq 0x38(%rsp), %rdi
movq 0x48cc(%rip), %rax      # 0x6fc8
movq (%rax), %rcx
pushq $0x1
popq %rsi
pushq $0x18
popq %rdx
callq 0x2130
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq 0x48db(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movl 0x20(%rsp), %edx
leaq 0x1a55(%rip), %rsi      # 0x4180
xorl %eax, %eax
callq 0x20d0
jmp 0x26e9
// File: /workspace/github_c_makefile_star2_O2/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/sm/cmd_sm_get_version.c
// Function: cmd_sm_get_version_exec
int
cmd_sm_get_version_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_sm_get_version get_version;
	uint64_t laid, paid;
	int len;
	int ret;

	laid = opts.laid_valid ? opts.laid : 0x1070000002000001ull;
	paid = opts.paid_valid ? opts.paid : 0x10700003ff000001ull;

	ps3dm_init_header(&get_version.dm_hdr, 1, PS3DM_FID_SM,
	    sizeof(struct ps3dm_ss_header),
	    sizeof(get_version) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&get_version.ss_hdr, PS3DM_PID_SM_GET_VERSION,
	    laid, paid);

	len = sizeof(struct ps3dm_header) + sizeof(struct ps3dm_ss_header);

	ret = dev_write(&get_version, len);
	if (ret != len)
		return (CMD_EIO);

	ret = dev_read(&get_version, sizeof(get_version));
	if (ret != sizeof(get_version))
		return (CMD_EIO);

	if (opts.do_verbose > 0)
		fprintf(stderr, "ss status %d\n", get_version.ss_hdr.status);

	if (get_version.ss_hdr.status)
		return (CMD_EIO);

	hex_fprintf(stdout, (char *) get_version.version,
	    sizeof(get_version.version));

	return (CMD_EOK);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq 0x497e(%rip), %r14      # 0x70c0
cmpl $0x0, 0x20(%r14)
je 0x274f
movq 0x18(%r14), %rax
jmp 0x2759
movabsq $0x1070000002000001, %rax # imm = 0x1070000002000001
cmpl $0x0, 0x30(%r14)
je 0x2766
movq 0x28(%r14), %rcx
jmp 0x2770
movabsq $0x10700003ff000001, %rcx # imm = 0x10700003FF000001
movaps 0x1a79(%rip), %xmm0     # 0x41f0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x5006, 0x10(%rdi)     # imm = 0x5006
movq $0x5000, 0x18(%rdi)     # imm = 0x5000
movq %rax, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
pushq $0x38
popq %rsi
callq 0x24a2
pushq $0x3
popq %rbx
cmpl $0x38, %eax
jne 0x27dc
movq %rsp, %rdi
pushq $0x40
popq %rsi
callq 0x24c1
cmpl $0x40, %eax
jne 0x27dc
cmpl $0x0, 0x8(%r14)
jg 0x27e6
cmpl $0x0, 0x20(%rsp)
jne 0x27dc
movq 0x47fe(%rip), %rax      # 0x6fc8
movq (%rax), %rdi
leaq 0x38(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x39c0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq 0x480b(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movl 0x20(%rsp), %edx
leaq 0x1985(%rip), %rsi      # 0x4180
xorl %eax, %eax
callq 0x20d0
jmp 0x27bc
// File: /workspace/github_c_makefile_star2_O2/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/sm/cmd_sm_set_del_encdec_key.c
// Function: cmd_sm_set_del_encdec_key_exec
int
cmd_sm_set_del_encdec_key_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_sm_set_del_encdec_key set_del_encdec_key;
	uint64_t arg, laid, paid;
	char *endptr;
	int ret;

	arg = strtoull(argv[0], &endptr, 0);
	if (*endptr != '\0')
		return (CMD_EINVAL);

	laid = opts.laid_valid ? opts.laid : 0x1070000002000001ull;
	paid = opts.paid_valid ? opts.paid : 0x10700003ff000001ull;

	ps3dm_init_header(&set_del_encdec_key.dm_hdr, 1, PS3DM_FID_SM,
	    sizeof(set_del_encdec_key) - sizeof(struct ps3dm_header),
	    sizeof(set_del_encdec_key) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&set_del_encdec_key.ss_hdr, PS3DM_PID_SM_SET_DEL_ENCDEC_KEY,
	    laid, paid);
	set_del_encdec_key.arg = arg;

	ret = dev_write(&set_del_encdec_key, sizeof(set_del_encdec_key));
	if (ret != sizeof(set_del_encdec_key))
		return (CMD_EIO);

	ret = dev_read(&set_del_encdec_key, sizeof(set_del_encdec_key));
	if (ret != sizeof(set_del_encdec_key))
		return (CMD_EIO);

	if (opts.do_verbose > 0)
		fprintf(stderr, "ss status %d\n", set_del_encdec_key.ss_hdr.status);

	if (set_del_encdec_key.ss_hdr.status)
		return (CMD_EIO);

	return (CMD_EOK);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq (%rcx), %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x20b0
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
je 0x282d
pushq $0x2
popq %rbx
jmp 0x28c3
leaq 0x488c(%rip), %r14      # 0x70c0
cmpl $0x0, 0x20(%r14)
je 0x2841
movq 0x18(%r14), %rcx
jmp 0x284b
movabsq $0x1070000002000001, %rcx # imm = 0x1070000002000001
cmpl $0x0, 0x30(%r14)
je 0x2858
movq 0x28(%r14), %rdx
jmp 0x2862
movabsq $0x10700003ff000001, %rdx # imm = 0x10700003FF000001
movaps 0x1907(%rip), %xmm0     # 0x4170
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x5002, 0x10(%rdi)     # imm = 0x5002
movq $0x5000, 0x18(%rdi)     # imm = 0x5000
movq %rcx, 0x28(%rdi)
movq %rdx, 0x30(%rdi)
movq %rax, 0x38(%rdi)
pushq $0x40
popq %rsi
callq 0x24a2
pushq $0x3
popq %rbx
cmpl $0x40, %eax
jne 0x28c3
leaq 0x10(%rsp), %rdi
pushq $0x40
popq %rsi
callq 0x24c1
cmpl $0x40, %eax
jne 0x28c3
cmpl $0x0, 0x8(%r14)
jg 0x28cd
xorl %eax, %eax
cmpl $0x0, 0x30(%rsp)
setne %al
leal (%rax,%rax,2), %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq 0x4724(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movl 0x30(%rsp), %edx
leaq 0x189e(%rip), %rsi      # 0x4180
xorl %eax, %eax
callq 0x20d0
jmp 0x28b6
nop
// File: /workspace/github_c_makefile_star2_O2/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/sm/cmd_sm_set_encdec_key.c
// Function: cmd_sm_set_encdec_key_exec
int
cmd_sm_set_encdec_key_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_sm_set_encdec_key set_encdec_key;
	uint64_t laid, paid;
	uint8_t key[24];
	int key_length;
	int ret;

	key_length = parse_hex(argv[0], key, sizeof(key));
	if (key_length <= 0)
		return (CMD_EINVAL);

	laid = opts.laid_valid ? opts.laid : 0x1070000002000001ull;
	paid = opts.paid_valid ? opts.paid : 0x10700003ff000001ull;

	ps3dm_init_header(&set_encdec_key.dm_hdr, 1, PS3DM_FID_SM,
	    sizeof(set_encdec_key) - sizeof(struct ps3dm_header),
	    sizeof(set_encdec_key) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&set_encdec_key.ss_hdr, PS3DM_PID_SM_SET_ENCDEC_KEY,
	    laid, paid);
	memset(set_encdec_key.key, 0, sizeof(set_encdec_key.key));
	memcpy(set_encdec_key.key, key, key_length);
	set_encdec_key.key_length = key_length;

	ret = dev_write(&set_encdec_key, sizeof(set_encdec_key));
	if (ret != sizeof(set_encdec_key))
		return (CMD_EIO);

	ret = dev_read(&set_encdec_key, sizeof(set_encdec_key));
	if (ret != sizeof(set_encdec_key))
		return (CMD_EIO);

	if (opts.do_verbose > 0)
		fprintf(stderr, "ss status %d\n", set_encdec_key.ss_hdr.status);

	if (set_encdec_key.ss_hdr.status)
		return (CMD_EIO);

	fprintf(stdout, "%llx\n", set_encdec_key.key_index);

	return (CMD_EOK);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq (%rcx), %rdi
movq %rsp, %rsi
pushq $0x18
popq %rdx
callq 0x38d4
testl %eax, %eax
jle 0x291e
leaq 0x47af(%rip), %r15      # 0x70c0
cmpl $0x0, 0x20(%r15)
je 0x2926
movq 0x18(%r15), %rcx
jmp 0x2930
pushq $0x2
popq %rbx
jmp 0x29f6
movabsq $0x1070000002000001, %rcx # imm = 0x1070000002000001
cmpl $0x0, 0x30(%r15)
je 0x293d
movq 0x28(%r15), %rdx
jmp 0x2947
movabsq $0x10700003ff000001, %rdx # imm = 0x10700003FF000001
movaps 0x1932(%rip), %xmm0     # 0x4280
leaq 0x58(%rsp), %rbx
movaps %xmm0, -0x38(%rbx)
movq $0x5001, -0x28(%rbx)    # imm = 0x5001
movq $0x5000, -0x20(%rbx)    # imm = 0x5000
movq %rcx, -0x10(%rbx)
movq %rdx, -0x8(%rbx)
movl %eax, %r14d
pushq $0x18
popq %rcx
subq %r14, %rcx
xorl %edx, %edx
cmpl $0x18, %eax
cmovbq %rcx, %rdx
leaq (%rsp,%r14), %rdi
addq $0x58, %rdi
xorl %esi, %esi
callq 0x2070
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x20e0
movq %r14, 0x18(%rbx)
leaq 0x20(%rsp), %rdi
pushq $0x60
popq %rsi
callq 0x24a2
pushq $0x3
popq %rbx
cmpl $0x60, %eax
jne 0x29f6
leaq 0x20(%rsp), %rdi
pushq $0x60
popq %rsi
callq 0x24c1
cmpl $0x60, %eax
jne 0x29f6
cmpl $0x0, 0x8(%r15)
jg 0x2a05
cmpl $0x0, 0x40(%rsp)
jne 0x29f6
movq 0x45ea(%rip), %rax      # 0x6fc8
movq (%rax), %rdi
movq 0x78(%rsp), %rdx
leaq 0x18a3(%rip), %rsi      # 0x4290
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x20d0
movl %ebx, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x45ec(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movl 0x40(%rsp), %edx
leaq 0x1766(%rip), %rsi      # 0x4180
xorl %eax, %eax
callq 0x20d0
jmp 0x29d0
nop
// File: /workspace/github_c_makefile_star2_O2/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/srtc/cmd_srtc_get_time.c
// Function: cmd_srtc_get_time_exec
int
cmd_srtc_get_time_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_srtc_get_time get_time;
	uint64_t epoch;
	char *endptr;
	uint64_t laid, paid;
	int len;
	int ret;

	epoch = strtoull(argv[0], &endptr, 0);
	if (*endptr != '\0' || epoch > 1)
		return (CMD_EINVAL);

	laid = opts.laid_valid ? opts.laid : 0x1070000002000001ull;
	paid = opts.paid_valid ? opts.paid : 0x10700003ff000001ull;

	ps3dm_init_header(&get_time.dm_hdr, 1, PS3DM_FID_SRTC,
	    sizeof(get_time) - sizeof(struct ps3dm_header),
	    sizeof(get_time) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&get_time.ss_hdr, PS3DM_PID_SRTC_GET_TIME,
	    laid, paid);
	get_time.epoch = epoch;

	len = sizeof(get_time);

	ret = dev_write(&get_time, len);
	if (ret != len)
		return (CMD_EIO);

	ret = dev_read(&get_time, sizeof(get_time));
	if (ret != sizeof(get_time))
		return (CMD_EIO);

	if (opts.do_verbose > 0)
		fprintf(stderr, "ss status %d\n", get_time.ss_hdr.status);

	if (get_time.ss_hdr.status)
		return (CMD_EIO);

	fprintf(stdout, "%lld\n", get_time.time);

	return (CMD_EOK);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq (%rcx), %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x20b0
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
setne %cl
cmpq $0x2, %rax
setae %dl
orb %cl, %dl
je 0x2a69
pushq $0x2
popq %rbx
jmp 0x2b18
leaq 0x4650(%rip), %r14      # 0x70c0
cmpl $0x0, 0x20(%r14)
je 0x2a7d
movq 0x18(%r14), %rcx
jmp 0x2a87
movabsq $0x1070000002000001, %rcx # imm = 0x1070000002000001
cmpl $0x0, 0x30(%r14)
je 0x2a94
movq 0x28(%r14), %rdx
jmp 0x2a9e
movabsq $0x10700003ff000001, %rdx # imm = 0x10700003FF000001
movaps 0x184b(%rip), %xmm0     # 0x42f0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x3002, 0x10(%rdi)     # imm = 0x3002
movq $0x3000, 0x18(%rdi)     # imm = 0x3000
movq %rcx, 0x28(%rdi)
movq %rdx, 0x30(%rdi)
movq %rax, 0x38(%rdi)
pushq $0x50
popq %rsi
callq 0x24a2
pushq $0x3
popq %rbx
cmpl $0x50, %eax
jne 0x2b18
leaq 0x10(%rsp), %rdi
pushq $0x50
popq %rsi
callq 0x24c1
cmpl $0x50, %eax
jne 0x2b18
cmpl $0x0, 0x8(%r14)
jg 0x2b22
cmpl $0x0, 0x30(%rsp)
jne 0x2b18
movq 0x44c8(%rip), %rax      # 0x6fc8
movq (%rax), %rdi
movq 0x50(%rsp), %rdx
leaq 0x17f1(%rip), %rsi      # 0x4300
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x20d0
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq 0x44cf(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movl 0x30(%rsp), %edx
leaq 0x1649(%rip), %rsi      # 0x4180
xorl %eax, %eax
callq 0x20d0
jmp 0x2af2
// File: /workspace/github_c_makefile_star2_O2/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/srtc/cmd_srtc_set_time.c
// Function: cmd_srtc_set_time_exec
int
cmd_srtc_set_time_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_srtc_set_time set_time;
	uint64_t time;
	char *endptr;
	uint64_t laid, paid;
	int len;
	int ret;

	time = strtoull(argv[0], &endptr, 0);
	if (*endptr != '\0' || time > 0xffffffffull)
		return (CMD_EINVAL);

	laid = opts.laid_valid ? opts.laid : 0x1070000002000001ull;
	paid = opts.paid_valid ? opts.paid : 0x10700003ff000001ull;

	ps3dm_init_header(&set_time.dm_hdr, 1, PS3DM_FID_SRTC,
	    sizeof(set_time) - sizeof(struct ps3dm_header),
	    sizeof(set_time) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&set_time.ss_hdr, PS3DM_PID_SRTC_SET_TIME,
	    laid, paid);
	set_time.time = time;

	len = sizeof(set_time);

	ret = dev_write(&set_time, len);
	if (ret != len)
		return (CMD_EIO);

	ret = dev_read(&set_time, sizeof(set_time));
	if (ret != sizeof(set_time))
		return (CMD_EIO);

	if (opts.do_verbose > 0)
		fprintf(stderr, "ss status %d\n", set_time.ss_hdr.status);

	if (set_time.ss_hdr.status)
		return (CMD_EIO);

	return (CMD_EOK);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq (%rcx), %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x20b0
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
setne %cl
movq %rax, %rdx
shrq $0x20, %rdx
setne %dl
orb %cl, %dl
je 0x2b78
pushq $0x2
popq %rbx
jmp 0x2c0e
leaq 0x4541(%rip), %r14      # 0x70c0
cmpl $0x0, 0x20(%r14)
je 0x2b8c
movq 0x18(%r14), %rcx
jmp 0x2b96
movabsq $0x1070000002000001, %rcx # imm = 0x1070000002000001
cmpl $0x0, 0x30(%r14)
je 0x2ba3
movq 0x28(%r14), %rdx
jmp 0x2bad
movabsq $0x10700003ff000001, %rdx # imm = 0x10700003FF000001
movaps 0x177c(%rip), %xmm0     # 0x4330
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x3003, 0x10(%rdi)     # imm = 0x3003
movq $0x3000, 0x18(%rdi)     # imm = 0x3000
movq %rcx, 0x28(%rdi)
movq %rdx, 0x30(%rdi)
movq %rax, 0x38(%rdi)
pushq $0x40
popq %rsi
callq 0x24a2
pushq $0x3
popq %rbx
cmpl $0x40, %eax
jne 0x2c0e
leaq 0x10(%rsp), %rdi
pushq $0x40
popq %rsi
callq 0x24c1
cmpl $0x40, %eax
jne 0x2c0e
cmpl $0x0, 0x8(%r14)
jg 0x2c18
xorl %eax, %eax
cmpl $0x0, 0x30(%rsp)
setne %al
leal (%rax,%rax,2), %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq 0x43d9(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movl 0x30(%rsp), %edx
leaq 0x1553(%rip), %rsi      # 0x4180
xorl %eax, %eax
callq 0x20d0
jmp 0x2c01
nop
// File: /workspace/github_c_makefile_star2_O2/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/vtrm/cmd_vtrm_init.c
// Function: cmd_vtrm_init_exec
int
cmd_vtrm_init_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_vtrm_init init;
	uint64_t laid, paid;
	int len;
	int ret;

	laid = opts.laid_valid ? opts.laid : 0x1070000002000001ull;
	paid = opts.paid_valid ? opts.paid : 0x10700003ff000001ull;

	ps3dm_init_header(&init.dm_hdr, 1, PS3DM_FID_SM,
	    sizeof(struct ps3dm_ss_header),
	    sizeof(init) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&init.ss_hdr, PS3DM_PID_VTRM_INIT,
	    laid, paid);

	len = sizeof(struct ps3dm_header) + sizeof(struct ps3dm_ss_header);

	ret = dev_write(&init, len);
	if (ret != len)
		return (CMD_EIO);

	ret = dev_read(&init, sizeof(init));
	if (ret != sizeof(init))
		return (CMD_EIO);

	if (opts.do_verbose > 0)
		fprintf(stderr, "ss status %d\n", init.ss_hdr.status);

	if (init.ss_hdr.status)
		return (CMD_EIO);

	return (CMD_EOK);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x446a(%rip), %r14      # 0x70c0
cmpl $0x0, 0x20(%r14)
je 0x2c63
movq 0x18(%r14), %rax
jmp 0x2c6d
movabsq $0x1070000002000001, %rax # imm = 0x1070000002000001
cmpl $0x0, 0x30(%r14)
je 0x2c7a
movq 0x28(%r14), %rcx
jmp 0x2c84
movabsq $0x10700003ff000001, %rcx # imm = 0x10700003FF000001
movaps 0x1705(%rip), %xmm0     # 0x4390
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x2001, 0x10(%rdi)     # imm = 0x2001
movq $0x2000, 0x18(%rdi)     # imm = 0x2000
movq %rax, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
pushq $0x38
popq %rsi
callq 0x24a2
pushq $0x3
popq %rbx
cmpl $0x38, %eax
jne 0x2cdd
movq %rsp, %rdi
pushq $0x38
popq %rsi
callq 0x24c1
cmpl $0x38, %eax
jne 0x2cdd
cmpl $0x0, 0x8(%r14)
jg 0x2ce7
xorl %eax, %eax
cmpl $0x0, 0x20(%rsp)
setne %al
leal (%rax,%rax,2), %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq 0x430a(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movl 0x20(%rsp), %edx
leaq 0x1484(%rip), %rsi      # 0x4180
xorl %eax, %eax
callq 0x20d0
jmp 0x2cd0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/vtrm/cmd_vtrm_retrieve.c
// Function: cmd_vtrm_retrieve_exec
int
cmd_vtrm_retrieve_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_vtrm_retrieve retrieve;
	char *endptr;
	uint64_t nth;
	uint64_t laid, paid;
	int len;
	int ret;

	nth = strtoull(argv[0], &endptr, 0);
	if (*endptr != '\0')
		return (CMD_EINVAL);

	laid = opts.laid_valid ? opts.laid : 0x1070000002000001ull;
	paid = opts.paid_valid ? opts.paid : 0x10700003ff000001ull;

	if (opts.do_verbose > 0)
		fprintf(stderr, "laid %016llx paid %016llx\n", laid, paid);

	ps3dm_init_header(&retrieve.dm_hdr, 1, PS3DM_FID_VTRM,
	    sizeof(retrieve) - sizeof(struct ps3dm_header),
	    sizeof(retrieve) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&retrieve.ss_hdr, PS3DM_PID_VTRM_RETRIEVE,
	    laid, paid);
	retrieve.nth = nth;

	len = sizeof(retrieve);

	ret = dev_write(&retrieve, len);
	if (ret != len)
		return (CMD_EIO);

	ret = dev_read(&retrieve, sizeof(retrieve));
	if (ret < (sizeof(struct ps3dm_header) + sizeof(struct ps3dm_ss_header)))
		return (CMD_EIO);

	if (opts.do_verbose > 0)
		fprintf(stderr, "ss status %d\n", retrieve.ss_hdr.status);

	if (retrieve.ss_hdr.status)
		return (CMD_EIO);

	if (ret != sizeof(retrieve))
		return (CMD_EIO);

	fwrite(retrieve.data, 1, sizeof(retrieve.data), stdout);

	return (CMD_EOK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq (%rcx), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x20b0
movq %rax, %rbx
movq (%r14), %rax
cmpb $0x0, (%rax)
je 0x2d3c
pushq $0x2
popq %rbx
jmp 0x2e09
leaq 0x437d(%rip), %r12      # 0x70c0
cmpl $0x0, 0x20(%r12)
je 0x2d52
movq 0x18(%r12), %r14
jmp 0x2d5c
movabsq $0x1070000002000001, %r14 # imm = 0x1070000002000001
cmpl $0x0, 0x30(%r12)
je 0x2d6b
movq 0x28(%r12), %r15
jmp 0x2d75
movabsq $0x10700003ff000001, %r15 # imm = 0x10700003FF000001
cmpl $0x0, 0x8(%r12)
jg 0x2e1b
movaps 0x1638(%rip), %xmm0     # 0x43c0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x2005, 0x10(%rdi)     # imm = 0x2005
movq $0x2000, 0x18(%rdi)     # imm = 0x2000
movq %r14, 0x28(%rdi)
movq %r15, 0x30(%rdi)
movq %rbx, 0x78(%rdi)
movl $0x80, %esi
callq 0x24a2
pushq $0x3
popq %rbx
cmpl $0x80, %eax
jne 0x2e09
leaq 0x10(%rsp), %rdi
movl $0x80, %esi
callq 0x24c1
cmpl $0x38, %eax
jb 0x2e09
movl %eax, %ebp
cmpl $0x0, 0x8(%r12)
jg 0x2e3e
cmpl $0x80, %ebp
jne 0x2e09
cmpl $0x0, 0x30(%rsp)
jne 0x2e09
leaq 0x48(%rsp), %rdi
movq 0x41cf(%rip), %rax      # 0x6fc8
movq (%rax), %rcx
pushq $0x1
popq %rsi
pushq $0x40
popq %rdx
callq 0x2130
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x41d6(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x15a4(%rip), %rsi      # 0x43d0
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x20d0
jmp 0x2d81
movq 0x41b3(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movl 0x30(%rsp), %edx
leaq 0x132d(%rip), %rsi      # 0x4180
xorl %eax, %eax
callq 0x20d0
jmp 0x2dde
// File: /workspace/github_c_makefile_star2_O2/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/iim/cmd_iim_get_data_size.c
// Function: cmd_iim_get_data_size_exec
int
cmd_iim_get_data_size_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_iim_get_data_size get_data_size;
	uint64_t index;
	char *endptr;
	uint64_t laid, paid;
	int len;
	int ret;

	index = strtoull(argv[0], &endptr, 0);
	if (*endptr != '\0')
		return (CMD_EINVAL);

	laid = opts.laid_valid ? opts.laid : 0x1070000002000001ull;
	paid = opts.paid_valid ? opts.paid : 0x1070000300000001ull;

	ps3dm_init_header(&get_data_size.dm_hdr, 1, PS3DM_FID_IIM,
	    sizeof(get_data_size) - sizeof(struct ps3dm_header),
	    sizeof(get_data_size) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&get_data_size.ss_hdr, PS3DM_PID_IIM_GET_DATA_SIZE,
	    laid, paid);
	get_data_size.index = index;

	len = sizeof(struct ps3dm_iim_get_data_size);

	ret = dev_write(&get_data_size, len);
	if (ret != len)
		return (CMD_EIO);

	ret = dev_read(&get_data_size, sizeof(get_data_size));
	if (ret != sizeof(get_data_size))
		return (CMD_EIO);

	if (opts.do_verbose > 0)
		fprintf(stderr, "ss status %d\n", get_data_size.ss_hdr.status);

	if (get_data_size.ss_hdr.status)
		return (CMD_EIO);

	fprintf(stdout, "%llx\n", get_data_size.size);

	return (CMD_EOK);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq (%rcx), %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x20b0
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
je 0x3129
pushq $0x2
popq %rbx
jmp 0x31d8
leaq 0x3f90(%rip), %r14      # 0x70c0
cmpl $0x0, 0x20(%r14)
je 0x313d
movq 0x18(%r14), %rcx
jmp 0x3147
movabsq $0x1070000002000001, %rcx # imm = 0x1070000002000001
cmpl $0x0, 0x30(%r14)
je 0x3154
movq 0x28(%r14), %rdx
jmp 0x315e
movabsq $0x1070000300000001, %rdx # imm = 0x1070000300000001
movaps 0x136b(%rip), %xmm0     # 0x44d0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x17001, 0x10(%rdi)    # imm = 0x17001
movq $0x17000, 0x18(%rdi)    # imm = 0x17000
movq %rcx, 0x28(%rdi)
movq %rdx, 0x30(%rdi)
movq %rax, 0x38(%rdi)
pushq $0x48
popq %rsi
callq 0x24a2
pushq $0x3
popq %rbx
cmpl $0x48, %eax
jne 0x31d8
leaq 0x10(%rsp), %rdi
pushq $0x48
popq %rsi
callq 0x24c1
cmpl $0x48, %eax
jne 0x31d8
cmpl $0x0, 0x8(%r14)
jg 0x31e2
cmpl $0x0, 0x30(%rsp)
jne 0x31d8
movq 0x3e08(%rip), %rax      # 0x6fc8
movq (%rax), %rdi
movq 0x50(%rsp), %rdx
leaq 0x10c1(%rip), %rsi      # 0x4290
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x20d0
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq 0x3e0f(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movl 0x30(%rsp), %edx
leaq 0xf89(%rip), %rsi       # 0x4180
xorl %eax, %eax
callq 0x20d0
jmp 0x31b2
// File: /workspace/github_c_makefile_star2_O2/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/aim/cmd_aim_get_dev_id.c
// Function: cmd_aim_get_dev_id_exec
int
cmd_aim_get_dev_id_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_aim_get_dev_id get_dev_id;
	uint64_t laid, paid;
	int len;
	int ret;

	laid = opts.laid_valid ? opts.laid : 0x1070000002000001ull;
	paid = opts.paid_valid ? opts.paid : 0x10700003ff000001ull;

	ps3dm_init_header(&get_dev_id.dm_hdr, 1, PS3DM_FID_AIM,
	    sizeof(get_dev_id) - sizeof(struct ps3dm_header),
	    sizeof(get_dev_id) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&get_dev_id.ss_hdr, PS3DM_PID_AIM_GET_DEV_ID,
	    laid, paid);

	len = sizeof(get_dev_id);

	ret = dev_write(&get_dev_id, len);
	if (ret != len)
		return (CMD_EIO);

	ret = dev_read(&get_dev_id, sizeof(get_dev_id));
	if (ret != sizeof(get_dev_id))
		return (CMD_EIO);

	if (opts.do_verbose > 0)
		fprintf(stderr, "ss status %d\n", get_dev_id.ss_hdr.status);

	if (get_dev_id.ss_hdr.status)
		return (CMD_EIO);

	hex_fprintf(stdout, (char *) get_dev_id.data, sizeof(get_dev_id.data));

	return (CMD_EOK);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq 0x3ea2(%rip), %r14      # 0x70c0
cmpl $0x0, 0x20(%r14)
je 0x322b
movq 0x18(%r14), %rax
jmp 0x3235
movabsq $0x1070000002000001, %rax # imm = 0x1070000002000001
cmpl $0x0, 0x30(%r14)
je 0x3242
movq 0x28(%r14), %rcx
jmp 0x324c
movabsq $0x10700003ff000001, %rcx # imm = 0x10700003FF000001
movaps 0x12dd(%rip), %xmm0     # 0x4530
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x19003, 0x10(%rdi)    # imm = 0x19003
movq $0x19000, 0x18(%rdi)    # imm = 0x19000
movq %rax, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
pushq $0x48
popq %rsi
callq 0x24a2
pushq $0x3
popq %rbx
cmpl $0x48, %eax
jne 0x32b8
movq %rsp, %rdi
pushq $0x48
popq %rsi
callq 0x24c1
cmpl $0x48, %eax
jne 0x32b8
cmpl $0x0, 0x8(%r14)
jg 0x32c2
cmpl $0x0, 0x20(%rsp)
jne 0x32b8
movq 0x3d22(%rip), %rax      # 0x6fc8
movq (%rax), %rdi
leaq 0x38(%rsp), %rsi
pushq $0x10
popq %rdx
callq 0x39c0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq 0x3d2f(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movl 0x20(%rsp), %edx
leaq 0xea9(%rip), %rsi       # 0x4180
xorl %eax, %eax
callq 0x20d0
jmp 0x3298