LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_lbs/proto_lbs_client.c
// Function: proto_lbs_request_append
int
proto_lbs_request_append(struct wire_requestqueue * Q,
    uint32_t nblks, uint64_t blkno, size_t blklen, const uint8_t * buf,
    int (* callback)(void *, int, int, uint64_t), void * cookie)
{
	const uint8_t ** bufv;
	size_t i;

	/* Allocate vector of pointers to blocks. */
	if (IMALLOC(bufv, nblks, const uint8_t *))
		goto err0;

	/* Fill in vector. */
	for (i = 0; i < nblks; i++)
		bufv[i] = &buf[i * blklen];

	/* Send the request. */
	if (proto_lbs_request_append_blks(Q, nblks, blkno, blklen, bufv,
	    callback, cookie))
		goto err1;

	/* Free the vector. */
	free(bufv);

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x1aaf0
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x1aa57
cmpl $0x0, -0x14(%rbp)
jbe 0x1aa57
jmp 0x1aadb
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jae 0x1aa95
movq -0x30(%rbp), %rdx
movq -0x48(%rbp), %rax
imulq -0x28(%rbp), %rax
addq %rax, %rdx
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x1aa5f
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x1a6f0
cmpl $0x0, %eax
je 0x1aac0
jmp 0x1aad2
movq -0x40(%rbp), %rdi
callq 0x2040
movl $0x0, -0x4(%rbp)
jmp 0x1aae2
movq -0x40(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_lbs/proto_lbs_client.c
// Function: proto_lbs_request_free
int
proto_lbs_request_free(struct wire_requestqueue * Q, uint64_t blkno,
    int (* callback)(void *, int), void * cookie)
{
	struct free_cookie * C;
	uint8_t * buf;

	/* Sanity check. */
	assert(callback != NULL);

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

	/* Start writing a request. */
	if ((buf = wire_requestqueue_add_getbuf(Q, 12,
	    callback_free, C)) == NULL)
		goto err1;

	/* Construct request. */
	be32enc(&buf[0], PROTO_LBS_FREE);
	be64enc(&buf[4], blkno);

	/* Finish writing request. */
	if (wire_requestqueue_add_done(Q, buf, 12))
		goto err1;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1abb1
jmp 0x1abd0
leaq 0x648d(%rip), %rdi      # 0x21045
leaq 0x6497(%rip), %rsi      # 0x21056
movl $0x1ca, %edx            # imm = 0x1CA
leaq 0x66b1(%rip), %rcx      # 0x2127c
callq 0x21d0
movl $0x10, %edi
callq 0x22a0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x1abe9
jmp 0x1ac6f
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rcx
movl $0xc, %esi
leaq 0x6c(%rip), %rdx        # 0x1ac80
callq 0x1b970
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x1ac25
jmp 0x1ac66
movq -0x38(%rbp), %rdi
movl $0x3, %esi
callq 0x1a0a0
movq -0x38(%rbp), %rdi
addq $0x4, %rdi
movq -0x18(%rbp), %rsi
callq 0x1a620
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0xc, %edx
callq 0x1bb00
cmpl $0x0, %eax
je 0x1ac5d
jmp 0x1ac66
movl $0x0, -0x4(%rbp)
jmp 0x1ac76
movq -0x30(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_lbs/proto_lbs_client.c
// Function: callback_free
static int
callback_free(void * cookie, uint8_t * buf, size_t buflen)
{
	struct free_cookie * C = cookie;
	int failed = 1;
	int rc;

	/* If we have a packet, parse it. */
	if (buf != NULL) {
		/* Is the status code sane? */
		if (buflen < 4)
			BAD("FREE", "bogus length");
		if (be32dec(&buf[0]) > 0)
			BAD("FREE", "bogus status code");

		/* We successfully parsed this response. */
		failed = 0;
	}

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1ad20
cmpq $0x4, -0x18(%rbp)
jae 0x1acde
jmp 0x1acb3
jmp 0x1acb5
leaq 0x661f(%rip), %rdi      # 0x212db
leaq 0x6686(%rip), %rsi      # 0x21349
leaq 0x6635(%rip), %rdx      # 0x212ff
movb $0x0, %al
callq 0x182f0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x1ad22
movq -0x10(%rbp), %rdi
callq 0x1ad50
cmpl $0x0, %eax
jbe 0x1ad19
jmp 0x1acee
jmp 0x1acf0
leaq 0x65e4(%rip), %rdi      # 0x212db
leaq 0x664b(%rip), %rsi      # 0x21349
leaq 0x6613(%rip), %rdx      # 0x21318
movb $0x0, %al
callq 0x182f0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x1ad22
movl $0x0, -0x24(%rbp)
jmp 0x1ad22
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0x24(%rbp), %esi
callq *%rax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2040
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/4-ProcessKernel/printf_example_fast.c
// Function: main
int main(void) {
	int i = 0;
	for(i = 0; i < MAX / 5; i++) {
		printf("x\nx\nx\nx\nx\n");
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x30d40, -0x8(%rbp)    # imm = 0x30D40
jge 0x117f
leaq 0xe97(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x115d
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/alexgirao[P]aimant/chargenx.c
// Function: write_exact
static int write_exact(int fd, void *buf, int len)
{
	int i, wrote = 0;
	do {
		if ((i = write(fd, buf + wrote, len - wrote)) <= 0) return i;
		wrote += i;
	} while (wrote < len);
	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rax
addq %rax, %rsi
movl -0x14(%rbp), %eax
subl -0x1c(%rbp), %eax
movslq %eax, %rdx
callq 0x20c0
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jg 0x4515
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x452c
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x44e9
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexgirao[P]aimant/chargenx.c
// Function: open_stdout0
static int open_stdout0(int flags)
{
	int fd;
	assert(*args->out_file);
	if ((fd = open(args->out_file, flags, 0644)) < 0) {
		int save_errno = errno;
		assert(fd == -1);
		DEBUG("open(args->out_file=[%s], flags=%i, 0644), errno=%i", args->out_file, flags, save_errno);
		errno = save_errno;
		perror(args->out_file);
		return -1;
	}
	if (fd != STDOUT_FILENO) {
		assert(dup2(fd, STDOUT_FILENO) == STDOUT_FILENO);
		assert(close(fd) == 0);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
cmpb $0x0, 0x6d92(%rip)      # 0xb2f4
je 0x4566
jmp 0x4585
leaq 0x42c8(%rip), %rdi      # 0x8835
leaq 0x3ce8(%rip), %rsi      # 0x825c
movl $0x1f1, %edx            # imm = 0x1F1
leaq 0x42c5(%rip), %rcx      # 0x8845
callq 0x2140
movl -0x8(%rbp), %esi
leaq 0x6bd1(%rip), %rdi      # 0xb160
addq $0x194, %rdi            # imm = 0x194
movl $0x1a4, %edx            # imm = 0x1A4
movb $0x0, %al
callq 0x2210
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jge 0x463d
callq 0x2060
movl (%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x45c0
jmp 0x45df
leaq 0x4294(%rip), %rdi      # 0x885b
leaq 0x3c8e(%rip), %rsi      # 0x825c
movl $0x1f4, %edx            # imm = 0x1F4
leaq 0x426b(%rip), %rcx      # 0x8845
callq 0x2140
jmp 0x45e1
movl -0x8(%rbp), %r8d
movl -0x10(%rbp), %r9d
leaq 0x3c6c(%rip), %rdi      # 0x825c
movl $0x1f5, %esi            # imm = 0x1F5
leaq 0x4268(%rip), %rdx      # 0x8864
leaq 0x6b5d(%rip), %rcx      # 0xb160
addq $0x194, %rcx            # imm = 0x194
movb $0x0, %al
callq 0x7000
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
callq 0x2060
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
leaq 0x6b38(%rip), %rdi      # 0xb160
addq $0x194, %rdi            # imm = 0x194
callq 0x2220
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x46ad
cmpl $0x1, -0xc(%rbp)
je 0x46a6
movl -0xc(%rbp), %edi
movl $0x1, %esi
callq 0x20f0
cmpl $0x1, %eax
jne 0x4657
jmp 0x4676
leaq 0x423a(%rip), %rdi      # 0x8898
leaq 0x3bf7(%rip), %rsi      # 0x825c
movl $0x1fb, %edx            # imm = 0x1FB
leaq 0x41d4(%rip), %rcx      # 0x8845
callq 0x2140
movl -0xc(%rbp), %edi
callq 0x2180
cmpl $0x0, %eax
jne 0x4685
jmp 0x46a4
leaq 0x4235(%rip), %rdi      # 0x88c1
leaq 0x3bc9(%rip), %rsi      # 0x825c
movl $0x1fc, %edx            # imm = 0x1FC
leaq 0x41a6(%rip), %rcx      # 0x8845
callq 0x2140
jmp 0x46a6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexgirao[P]aimant/chargenx.c
// Function: open_stderr0
static int open_stderr0(int flags)
{
	int fd;
	assert(*args->err_file);
	if ((fd = open(args->err_file, flags, 0644)) < 0) {
		int save_errno = errno;
		assert(fd == -1);
		DEBUG("open(args->err_file=[%s], flags=%i, 0644), errno=%i", args->err_file, flags, save_errno);
		errno = save_errno;
		perror(args->err_file);
		return -1;
	}
	if (fd != STDERR_FILENO) {
		assert(dup2(fd, STDERR_FILENO) == STDERR_FILENO);
		assert(close(fd) == 0);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
cmpb $0x0, 0x6cd2(%rip)      # 0xb3f4
je 0x4726
jmp 0x4745
leaq 0x4252(%rip), %rdi      # 0x897f
leaq 0x3b28(%rip), %rsi      # 0x825c
movl $0x204, %edx            # imm = 0x204
leaq 0x424f(%rip), %rcx      # 0x898f
callq 0x2140
movl -0x8(%rbp), %esi
leaq 0x6a11(%rip), %rdi      # 0xb160
addq $0x294, %rdi            # imm = 0x294
movl $0x1a4, %edx            # imm = 0x1A4
movb $0x0, %al
callq 0x2210
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jge 0x47fd
callq 0x2060
movl (%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x4780
jmp 0x479f
leaq 0x40d4(%rip), %rdi      # 0x885b
leaq 0x3ace(%rip), %rsi      # 0x825c
movl $0x207, %edx            # imm = 0x207
leaq 0x41f5(%rip), %rcx      # 0x898f
callq 0x2140
jmp 0x47a1
movl -0x8(%rbp), %r8d
movl -0x10(%rbp), %r9d
leaq 0x3aac(%rip), %rdi      # 0x825c
movl $0x208, %esi            # imm = 0x208
leaq 0x41e9(%rip), %rdx      # 0x89a5
leaq 0x699d(%rip), %rcx      # 0xb160
addq $0x294, %rcx            # imm = 0x294
movb $0x0, %al
callq 0x7000
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
callq 0x2060
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
leaq 0x6978(%rip), %rdi      # 0xb160
addq $0x294, %rdi            # imm = 0x294
callq 0x2220
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x486d
cmpl $0x2, -0xc(%rbp)
je 0x4866
movl -0xc(%rbp), %edi
movl $0x2, %esi
callq 0x20f0
cmpl $0x2, %eax
jne 0x4817
jmp 0x4836
leaq 0x41bb(%rip), %rdi      # 0x89d9
leaq 0x3a37(%rip), %rsi      # 0x825c
movl $0x20e, %edx            # imm = 0x20E
leaq 0x415e(%rip), %rcx      # 0x898f
callq 0x2140
movl -0xc(%rbp), %edi
callq 0x2180
cmpl $0x0, %eax
jne 0x4845
jmp 0x4864
leaq 0x4075(%rip), %rdi      # 0x88c1
leaq 0x3a09(%rip), %rsi      # 0x825c
movl $0x20f, %edx            # imm = 0x20F
leaq 0x4130(%rip), %rcx      # 0x898f
callq 0x2140
jmp 0x4866
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexgirao[P]aimant/getopt_x.c
// Function: getopt_x_option
int getopt_x_option(struct getopt_x *state, int c, struct option *opt)
{
	assert(opt);
	if (c < 0) {
		return -1;
	} else if (c < state->n_short_options) {
		opt->name = NULL;
		opt->val = state->optstring0_alnum[c];
		opt->has_arg = FD_ISSET_HAS_ARG(opt->val, state->optset);
	} else if (c < state->n_all_options) {
		*opt = state->longopts[c - state->n_short_options];
	} else {
		return -1;
	}
	return c + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5aac
jmp 0x5acb
leaq 0x30c4(%rip), %rdi      # 0x8b77
leaq 0x2fe0(%rip), %rsi      # 0x8a9a
movl $0x177, %edx            # imm = 0x177
leaq 0x30b5(%rip), %rcx      # 0x8b7b
callq 0x2140
cmpl $0x0, -0x14(%rbp)
jge 0x5add
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5bf2
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x180(%rcx), %eax
jge 0x5b8a
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl 0x11c(%rax,%rcx), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
andl $0xff, %eax
addl $0x100, %eax            # imm = 0x100
movl $0x40, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
movq 0x90(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
andl $0xff, %eax
addl $0x100, %eax            # imm = 0x100
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x28(%rbp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x5be7
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x184(%rcx), %eax
jge 0x5bdc
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rsi
subl 0x180(%rsi), %edx
movslq %edx, %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
jmp 0x5be5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5bf2
jmp 0x5be7
jmp 0x5be9
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexgirao[P]aimant/bsd-getopt_long.c
// Function: pure_permute_args
static void pure_permute_args(int panonopt_start, int panonopt_end, 
                              int opt_end, char * const *nargv)
{
    int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
    char *swap;
    
    /*
     * compute lengths of blocks and number and size of cycles
     */
    nnonopts = panonopt_end - panonopt_start;
    nopts = opt_end - panonopt_end;
    ncycle = pure_gcd(nnonopts, nopts);
    cyclelen = (opt_end - panonopt_start) / ncycle;
    
    for (i = 0; i < ncycle; i++) {
        cstart = panonopt_end+i;
        pos = cstart;
        for (j = 0; j < cyclelen; j++) {
            if (pos >= panonopt_end)
                pos -= nnonopts;
            else
                pos += nopts;
            swap = nargv[pos];
            /* LINTED const cast */
            ((char **) nargv)[pos] = nargv[cstart];
            /* LINTED const cast */
            ((char **)nargv)[cstart] = swap;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x8(%rbp), %eax
subl -0x4(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0xc(%rbp), %eax
subl -0x8(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %edi
movl -0x34(%rbp), %esi
callq 0x6fc0
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
subl -0x4(%rbp), %eax
cltd
idivl -0x2c(%rbp)
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x6b74
movl -0x8(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x6b64
movl -0x38(%rbp), %eax
cmpl -0x8(%rbp), %eax
jl 0x6b18
movl -0x30(%rbp), %ecx
movl -0x38(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x38(%rbp)
jmp 0x6b21
movl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x40(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6afb
jmp 0x6b66
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6ad9
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexgirao[P]aimant/bsd-getopt_long.c
// Function: pure_gcd
static int pure_gcd(int a, int b)
{
    int c;
    
    c = a % b;
    while (c != 0) {
        a = b;
        b = c;
        c = a % b;
    }    
    return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x6ff2
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movl %edx, -0xc(%rbp)
jmp 0x6fd4
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexgirao[P]aimant/debug0.c
// Function: write_exact
static int write_exact(int fd, void *buf, int len)
{
	int i, wrote = 0;
	do {
		if ((i = write(fd, buf + wrote, len - wrote)) <= 0) {
			return i;
		}
		wrote += i;
	} while (wrote < len);
	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rax
addq %rax, %rsi
movl -0x14(%rbp), %eax
subl -0x1c(%rbp), %eax
movslq %eax, %rdx
callq 0x20c0
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jg 0x7365
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x737c
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x7339
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: big_alloc
BIG* big_alloc(size_t cap) {
    ASSERT(cap >= 2);
    BIG* out = calloc(1, sizeof(*out) + cap*sizeof(*out->radix) + 4);
    EXPECT(out, "Ran out of memory.");
    out->refs = 1;
    out->cap = cap;
    out->size = 0;
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x2, -0x8(%rbp)
jae 0x528d
movl $0x2, %edi
leaq 0x34eb15(%rip), %rsi    # 0x353d84
movl $0x35, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x528f
movq -0x8(%rbp), %rsi
shlq $0x2, %rsi
addq $0x18, %rsi
addq $0x4, %rsi
movl $0x1, %edi
callq 0x50c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x52de
movl $0x2, %edi
leaq 0x34eafa(%rip), %rsi    # 0x353dba
movl $0x13, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x52e0
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: trace_stack
static void trace_stack (void) {
    TRACE("??");
    for (long i = STACK_MAX-1; i >= (long)stack_counter; i--) {
        TRACE(" ");
        value_trace_(stack[i], 2);
    }
    TRACE("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2, %edi
leaq 0x351b53(%rip), %rsi    # 0x356e77
movl $0x2, %edx
callq 0x5060
movq $0x7ffff, -0x8(%rbp)    # imm = 0x7FFFF
movq -0x8(%rbp), %rax
cmpq 0x38bdbf(%rip), %rax    # 0x391100
jl 0x538a
movl $0x2, %edi
leaq 0x350257(%rip), %rsi    # 0x3555a6
movl $0x1, %edx
callq 0x5060
movq -0x8(%rbp), %rcx
leaq 0x38e0fc(%rip), %rax    # 0x393460
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movl $0x2, %edx
callq 0x5bc0
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x5336
movl $0x2, %edi
leaq 0x34fd97(%rip), %rsi    # 0x35512d
movl $0x1, %edx
callq 0x5060
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: u64_repr
void u64_repr(uint64_t x, char* c, size_t m, char** out_ptr, size_t *out_size) {
    ASSERT(m >= 4);
    memset(c, 0, m);
    char* p = c+(m-1);
    size_t n = 0;
    do {
        *--p = '0' + (x % 10);
        x /= 10;
        n++;
    } while (x && (p > c));
    *out_ptr = p;
    *out_size = n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x4, -0x18(%rbp)
jae 0x540d
movl $0x2, %edi
leaq 0x34e9df(%rip), %rsi    # 0x353dce
movl $0x34, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x540f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x5080
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
addq $0x30, %rdx
movb %dl, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, -0x1(%rax)
movq -0x8(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x8(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x39(%rbp)
je 0x5497
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
seta %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x5439
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: i64_repr
void i64_repr(int64_t y, char* c, size_t m, char** out_ptr, size_t *out_size) {
    ASSERT(m >= 5);
    c[0] = 0;
    char* p;
    size_t n;
    uint64_t x;
    if (y < 0) {
        if (y == INT64_MIN) {
            x = 1+(uint64_t)INT64_MAX;
        } else {
            x = (uint64_t)-y;
        }
    } else {
        x = (uint64_t)y;
    }
    u64_repr(x,c+1,m-1,&p,&n);
    if (y<0) { *--p = '-'; n++; }
    *out_ptr = p;
    *out_size = n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x5, -0x18(%rbp)
jae 0x550d
movl $0x2, %edi
leaq 0x34e914(%rip), %rsi    # 0x353e03
movl $0x34, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x550f
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
cmpq $0x0, -0x8(%rbp)
jge 0x5549
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x8(%rbp)
jne 0x553d
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, -0x40(%rbp)
jmp 0x5547
xorl %eax, %eax
subq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x5551
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
leaq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq 0x53c0
cmpq $0x0, -0x8(%rbp)
jge 0x5598
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0x2d, -0x1(%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: main
int main (int argc, char** argv) {
	global_argc = argc;
	global_argv = argv;
	mw_mirth_main_main();
	push_resource(MKI64(0));
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, 0x38de71(%rip)    # 0x393450
movq -0x10(%rbp), %rax
movq %rax, 0x38de6e(%rip)    # 0x393458
callq 0x5620
movq $0x0, -0x20(%rbp)
leaq 0x38baba(%rip), %rax    # 0x3910b8
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5b40
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: value_trace_
static void value_trace_(VAL v, int fd) {
    if (VTYPE(v) && VTYPE(v)->trace_) {
        VTYPE(v)->trace_(v,fd);
    } else if (VTYPE(v)) {
        const char* name = VTYPE(v)->name;
        write(fd, "<", 1);
        write(fd, name, strlen(name));
        write(fd, ">", 1);
    } else {
        write(fd, "<NULL>", 6);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0x14(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x8(%rbp), %rax
cmpq $0x0, %rax
je 0x5c20
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x5c20
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq *%rax
jmp 0x5caf
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x8(%rbp), %rax
cmpq $0x0, %rax
je 0x5c99
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
leaq 0x34e1e5(%rip), %rsi    # 0x353e38
movl $0x1, %edx
callq 0x5060
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5070
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x5060
movl -0x14(%rbp), %edi
leaq 0x3675e2(%rip), %rsi    # 0x36d26f
movl $0x1, %edx
callq 0x5060
jmp 0x5cad
movl -0x14(%rbp), %edi
leaq 0x34e197(%rip), %rsi    # 0x353e3a
movl $0x6, %edx
callq 0x5060
jmp 0x5caf
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_std_result_Result_2_Ok
static VAL mtp_std_result_Result_2_Ok (struct std_result_Result_2 in_Result_1) {
	struct std_result_Result_2_Ok v3 = *in_Result_1.ptr.Ok;
	if (!--(in_Result_1.ptr.Ok->refs)) {
		free(in_Result_1.ptr.Ok);
	} else {
		incref(v3.m0);
	}
	return v3.m0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x7c35
movq -0x18(%rbp), %rdi
callq 0x5030
jmp 0x7c80
jmp 0x7c37
movq -0x28(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x7c7c
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x30(%rbp), %rax
cmpq $0x0, %rax
je 0x7c7c
movq -0x30(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x7c7c
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x30(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x7c7e
jmp 0x7c80
movups -0x30(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_std_result_Result_2_Err
static VAL mtp_std_result_Result_2_Err (struct std_result_Result_2 in_Result_1) {
	struct std_result_Result_2_Err v3 = *in_Result_1.ptr.Err;
	if (!--(in_Result_1.ptr.Err->refs)) {
		free(in_Result_1.ptr.Err);
	} else {
		incref(v3.m0);
	}
	return v3.m0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0xb655
movq -0x18(%rbp), %rdi
callq 0x5030
jmp 0xb6a0
jmp 0xb657
movq -0x28(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xb69c
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x30(%rbp), %rax
cmpq $0x0, %rax
je 0xb69c
movq -0x30(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0xb69c
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x30(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xb69e
jmp 0xb6a0
movups -0x30(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: str_make
static STR* str_make (const char* data, USIZE size) {
    ASSERT(data);
    ASSERT(size <= SIZE_MAX - sizeof(STR) - 4);
    STR* str = str_alloc(size);
    str->size = size;
    memcpy(str->data, data, (size_t)size);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xb701
movl $0x2, %edi
leaq 0x363193(%rip), %rsi    # 0x36e876
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0xb703
jmp 0xb705
cmpq $-0x1d, -0x10(%rbp)
jbe 0xb736
movl $0x2, %edi
leaq 0x363190(%rip), %rsi    # 0x36e8a8
movl $0x4f, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0xb738
movq -0x10(%rbp), %rdi
callq 0x1f850
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x50e0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: tup_decref_outer
static void tup_decref_outer(PTUP ptup) {
    if (PTRISPTR(ptup)) {
        TUP* tup = PTRPTR(ptup);
        if (tup->refs == 1) {
            free(tup);
        } else {
            for (size_t i = 0; i < tup->size; i++) {
                incref(tup->cells[i]);
            }
            if (!--tup->refs) tup_free(MKTUP(ptup));
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x8(%rbp), %rax
cmpq $0x0, %rax
je 0xb939
movq -0x8(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0xb939
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xb83f
movq -0x10(%rbp), %rdi
callq 0x5030
jmp 0xb937
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl 0x6(%rcx), %ecx
cmpq %rcx, %rax
jae 0xb901
jmp 0xb85e
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xb8ec
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
movq -0x18(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq (%rcx), %rax
cmpq $0x0, %rax
je 0xb8ec
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0xb8ec
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
movq -0x18(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq (%rcx), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xb8ee
jmp 0xb8f0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xb847
movq -0x10(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0xb935
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x385a78(%rip), %rax    # 0x391398
orq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1f900
jmp 0xb937
jmp 0xb939
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: do_panic
static void do_panic(STR* m) {
    if (m) {
        size_t n = (m->size < SIZE_MAX) ? (size_t)(m->size) : SIZE_MAX;
        write(2, m->data, n);
        TRACE("\n");
    } else {
        TRACE("panic!\n");
    }
    trace_stack();
    trace_rstack();
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc68f
movq -0x8(%rbp), %rax
cmpq $-0x1, 0x10(%rax)
jae 0xc64c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xc659
movq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xc659
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
movq -0x10(%rbp), %rdx
movl $0x2, %edi
callq 0x5060
movl $0x2, %edi
leaq 0x348aaa(%rip), %rsi    # 0x35512d
movl $0x1, %edx
callq 0x5060
jmp 0xc6a5
movl $0x2, %edi
leaq 0x3623aa(%rip), %rsi    # 0x36ea45
movl $0x7, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_std_maybe_Maybe_1_Some
static struct std_maybe_Maybe_1 mtw_std_maybe_Maybe_1_Some (VAL in_t_1) {
	struct std_maybe_Maybe_1_Some* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->m0 = in_t_1;
	struct std_maybe_Maybe_1 v4 = { .tag=std_maybe_Maybe_1_Some, .ptr.Some=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x50c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xca64
movl $0x2, %edi
leaq 0x347742(%rip), %rsi    # 0x354188
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0xca66
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
movq -0x28(%rbp), %rax
movups -0x20(%rbp), %xmm0
movups %xmm0, 0x8(%rax)
movl $0x1, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_argzeparser_types_ArgpOptionType_Short
static struct argzeparser_types_ArgpOptionType mtw_argzeparser_types_ArgpOptionType_Short (enum std_byte_Byte in_Byte_1) {
	struct argzeparser_types_ArgpOptionType_Short* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mByte = in_Byte_1;
	struct argzeparser_types_ArgpOptionType v4 = { .tag=argzeparser_types_ArgpOptionType_Short, .ptr.Short=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x14(%rbp)
movl $0x1, %edi
movl $0x8, %esi
callq 0x50c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xcaef
movl $0x2, %edi
leaq 0x3476e9(%rip), %rsi    # 0x3541ba
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0xcaf1
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_argzeparser_types_ArgpOption_ArgpOption
static struct argzeparser_types_ArgpOption* mtw_argzeparser_types_ArgpOption_ArgpOption (struct std_maybe_Maybe_1 in_Maybe_1, struct argzeparser_types_ArgpOptionType in_ArgpOptionType_2, struct std_maybe_Maybe_1 in_Maybe_3, struct std_maybe_Maybe_1 in_Maybe_4, struct std_maybe_Maybe_1 in_Maybe_5) {
	struct argzeparser_types_ArgpOption* v7 = calloc(1, sizeof *v7);
	ASSERT(v7);
	v7->refs = 1;
	v7->mgroup = in_Maybe_5;
	v7->mdoc = in_Maybe_4;
	v7->margzedoc = in_Maybe_3;
	v7->mflagzetype = in_ArgpOptionType_2;
	v7->mname = in_Maybe_1;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x30(%rbp)
movq %r9, -0x28(%rbp)
movl $0x1, %edi
movl $0x58, %esi
callq 0x50c0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xcba2
movl $0x2, %edi
leaq 0x347668(%rip), %rsi    # 0x3541ec
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0xcba4
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rdx
movq -0x38(%rbp), %rax
movl $0x1, (%rax)
movq -0x38(%rbp), %rax
movq (%rdx), %rsi
movq %rsi, 0x48(%rax)
movq 0x8(%rdx), %rdx
movq %rdx, 0x50(%rax)
movq -0x38(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x38(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x40(%rax)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_list_zaLister_1_pushzx
static void mw_std_list_zaLister_1_pushzx (VAL in_t_1, struct std_list_List_1 in_zaLister_2, struct std_list_List_1 *out_zaLister_3) {
	incref(MK_std_list_List_1(in_zaLister_2));
	struct std_list_List_1 v4 = mw_std_list_List_1_cons(in_t_1, in_zaLister_2);
	decref(MK_std_list_List_1(in_zaLister_2));
	*out_zaLister_3 = v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x28(%rbp)
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x12780
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x30(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xcce3
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x12780
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x48(%rbp), %rax
cmpq $0x0, %rax
je 0xcce3
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x12780
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x58(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0xcce3
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x12780
movq %rax, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x68(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xcce5
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x20(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x12740
movl %eax, -0x78(%rbp)
movq %rdx, -0x70(%rbp)
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x12780
movq %rax, -0x88(%rbp)
movq %rdx, -0x80(%rbp)
movq -0x80(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xcdef
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x12780
movq %rax, -0x98(%rbp)
movq %rdx, -0x90(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x98(%rbp), %rax
cmpq $0x0, %rax
je 0xcdef
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x12780
movq %rax, -0xa8(%rbp)
movq %rdx, -0xa0(%rbp)
movq -0xa8(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0xcdef
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x12780
movq %rax, -0xb8(%rbp)
movq %rdx, -0xb0(%rbp)
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq -0xb8(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0xcded
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x12780
movq %rax, -0xc8(%rbp)
movq %rdx, -0xc0(%rbp)
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x127c0
jmp 0xcdef
jmp 0xcdf1
movq -0x28(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, (%rax)
movq -0x70(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_argzeparser_types_ArgpOptionType_LongOnly
static struct argzeparser_types_ArgpOptionType mtw_argzeparser_types_ArgpOptionType_LongOnly (STR* in_Str_1) {
	struct argzeparser_types_ArgpOptionType_LongOnly* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mStr = in_Str_1;
	struct argzeparser_types_ArgpOptionType v4 = { .tag=argzeparser_types_ArgpOptionType_LongOnly, .ptr.LongOnly=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xce60
movl $0x2, %edi
leaq 0x34747e(%rip), %rsi    # 0x3542c0
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0xce62
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mb_mirth_options_parsezeoptionszx_0
static void mb_mirth_options_parsezeoptionszx_0 (void) {
	struct argzeparser_types_ArgpOptionType v0 = V_argzeparser_types_ArgpOptionType(pop_value());
	struct std_maybe_Maybe_1 v1 = V_std_maybe_Maybe_1(pop_value());
	struct mirth_options_Options* v2 = V_mirth_options_Options(pop_value());
	struct argzeparser_types_zaArgumentParser_1* r3 = V_argzeparser_types_zaArgumentParser_1(pop_resource());
	struct argzeparser_types_zaArgumentParser_1* v4;
	struct mirth_options_Options* v5 = mw_mirth_options_compilerzeparsezeargs(r3, v2, v1, v0, &v4);
	push_resource(MK_argzeparser_types_zaArgumentParser_1(v4));
	push_value(MK_mirth_options_Options(v5));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
callq 0x138a0
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13860
movl %eax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
callq 0x138a0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x135d0
movl %eax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
callq 0x138a0
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x13920
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl -0x30(%rbp), %edx
movq -0x28(%rbp), %rcx
movl -0x10(%rbp), %r8d
movq -0x8(%rbp), %r9
leaq -0x78(%rbp), %rax
movq %rax, (%rsp)
callq 0x139a0
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq 0x3843cf(%rip), %rax    # 0x391350
movq %rax, -0x88(%rbp)
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x5b40
movq -0x80(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq 0x384283(%rip), %rax    # 0x391230
orq $0x1, %rax
movq %rax, -0x98(%rbp)
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x12cc0
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_argzeparser_types_ArgumentParser_1_ArgumentParser
static struct argzeparser_types_ArgumentParser_1* mtw_argzeparser_types_ArgumentParser_1_ArgumentParser (struct std_list_List_1 in_List_1, VAL in__2, struct std_maybe_Maybe_1 in_Maybe_3, STR* in_Str_4) {
	struct argzeparser_types_ArgumentParser_1* v6 = calloc(1, sizeof *v6);
	ASSERT(v6);
	v6->refs = 1;
	v6->mdoc = in_Str_4;
	v6->margszedoc = in_Maybe_3;
	v6->mparser = in__2;
	v6->moptions = in_List_1;
	return v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x30(%rbp)
movq %r9, -0x28(%rbp)
movl $0x1, %edi
movl $0x40, %esi
callq 0x50c0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xd047
movl $0x2, %edi
leaq 0x347d94(%rip), %rsi    # 0x354dbd
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0xd049
movq -0x38(%rbp), %rax
movl $0x1, (%rax)
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_options_Options_Options
static struct mirth_options_Options* mtw_mirth_options_Options_Options (STR* in_Path_1, struct std_maybe_Maybe_1 in_Maybe_2, struct std_maybe_Maybe_1 in_Maybe_3, struct std_list_List_1 in_List_4, struct std_list_List_1 in_List_5, bool in_Bool_6) {
	struct mirth_options_Options* v8 = calloc(1, sizeof *v8);
	ASSERT(v8);
	v8->refs = 1;
	v8->memitzedebugzeinfo = in_Bool_6;
	v8->mpackagezesearchzepaths = in_List_5;
	v8->mpackages = in_List_4;
	v8->mentryzepoint = in_Maybe_3;
	v8->moutputzefile = in_Maybe_2;
	v8->minputzefile = in_Path_1;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %r9b, %al
leaq 0x20(%rbp), %r9
movq %r9, -0x48(%rbp)
leaq 0x10(%rbp), %r9
movq %r9, -0x40(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movl $0x1, %edi
movl $0x58, %esi
callq 0x50c0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x12226
movl $0x2, %edi
leaq 0x341deb(%rip), %rsi    # 0x353ff3
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x12228
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rdx
movq -0x38(%rbp), %rax
movl $0x1, (%rax)
movb -0x29(%rbp), %sil
movq -0x38(%rbp), %rax
andb $0x1, %sil
movb %sil, 0x50(%rax)
movq -0x38(%rbp), %rax
movq (%rdx), %rsi
movq %rsi, 0x40(%rax)
movq 0x8(%rdx), %rdx
movq %rdx, 0x48(%rax)
movq -0x38(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x30(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x38(%rax)
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop