LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/millimat[P]Soft-Heap/softheap.c
// Function: update_suffix_min
static void update_suffix_min(tree *T) {
  while(T != NULL) {
    if(T->next == NULL || T->root->ckey <= T->next->sufmin->root->ckey) T->sufmin = T;
    else T->sufmin = T->next->sufmin;
    T = T->prev;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1d7b
movq 0x8(%rdi), %rcx
movq %rdi, %rax
testq %rcx, %rcx
je 0x1d72
movq 0x18(%rdi), %rax
movl 0x20(%rax), %edx
movq 0x10(%rcx), %rax
movq 0x18(%rax), %rcx
cmpl 0x20(%rcx), %edx
cmovleq %rdi, %rax
movq %rax, 0x10(%rdi)
movq (%rdi), %rdi
jmp 0x1d4b
retq
// File: /workspace/github_c_makefile_star2_O1/cirocosta[P]stress/src/./common.h
// Function: stress_is_num
char
stress_is_num(char str[])
{
	int i = 0;
	for (; str[i] != 0; i++) {
		if (!isdigit(str[i]))
			return _STRESS_FALSE;
	}

	return _STRESS_TRUE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movb (%rdi), %bpl
movb $0x1, %bl
testb %bpl, %bpl
je 0x1942
movq %rdi, %r14
callq 0x11d0
movq (%rax), %rax
incq %r14
movsbq %bpl, %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x1940
movb (%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0x1928
jmp 0x1942
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cirocosta[P]stress/src/./common.h
// Function: stress_parse_args
void
stress_parse_args(int argc, char** argv, stress_args_t* args)
{
	int c;
	size_t arglen;

	_STRESS_MUST(argc > 1, "%s\n", "Argument -n must be specified.");

	opterr = 0;
	while ((c = getopt(argc, argv, "bd:f:n:")) != -1) {
		arglen = 0;
		if (optarg != NULL) {
			arglen = strlen(optarg);
			_STRESS_MUST(arglen < ARG_VALUE_MAX,
			             "-f option can't take more than "
			             "%d characters",
			             ARG_VALUE_MAX);
		}

		switch (c) {
			case 'n':
				_STRESS_MUST(stress_is_num(optarg),
				             "Argument (n=%s) must be an int",
				             optarg);
				args->n = atoi(optarg);
				break;
			case 'b':
				args->b = 1;
				break;
			case 'f':
				strncpy(args->f, optarg, arglen);
				break;
			case 'd':
				strncpy(args->d, optarg, arglen);
				break;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, (%rsp)
cmpl $0x1, %edi
jle 0x1a5d
movq %rsi, %r14
movl %edi, %ebp
movq 0x2680(%rip), %rax      # 0x3ff0
movl $0x0, (%rax)
leaq 0x70c(%rip), %rdx       # 0x2089
callq 0x1180
cmpl $-0x1, %eax
je 0x1a44
movl %eax, %r12d
movq (%rsp), %rax
leaq 0x1005(%rax), %rcx
movq %rcx, 0x10(%rsp)
addq $0x5, %rax
movq %rax, 0x8(%rsp)
leaq 0x6db(%rip), %r13       # 0x2089
leaq 0x64f(%rip), %rbx       # 0x2004
movq 0x2614(%rip), %rax      # 0x3fd0
movq (%rax), %r15
testq %r15, %r15
je 0x19d6
movq %r15, %rdi
callq 0x10c0
cmpq $0x100, %rax            # imm = 0x100
jb 0x19d8
jmp 0x1a53
xorl %eax, %eax
addl $-0x62, %r12d
rorl %r12d
cmpl $0x6, %r12d
ja 0x1a2b
movslq (%rbx,%r12,4), %rcx
addq %rbx, %rcx
jmpq *%rcx
movq (%rsp), %rax
movb $0x1, 0x4(%rax)
jmp 0x1a2b
movq 0x8(%rsp), %rdi
jmp 0x1a04
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1050
jmp 0x1a2b
movq %r15, %rdi
callq 0x190c
testb %al, %al
je 0x1a58
movq %r15, %rdi
callq 0x1190
movq (%rsp), %rcx
movl %eax, (%rcx)
movl %ebp, %edi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1180
movl %eax, %r12d
cmpl $-0x1, %eax
jne 0x19b5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x12a9
callq 0x1360
callq 0x11f0
// File: /workspace/github_c_makefile_star2_O1/cirocosta[P]stress/src/./common.h
// Function: stress_wait_until_signalized
void
stress_wait_until_signalized()
{
	struct sigaction action;
	memset(&action, 0, sizeof(struct sigaction));
	action.sa_handler = stress_handle_sigint;
	sigaction(SIGINT, &action, NULL);

	printf("[%d] Waiting for SIGINT\n", getpid());
	sleep(36000);
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
leaq 0x8(%rsp), %rbx
movl $0x98, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10f0
leaq -0x33(%rip), %rax       # 0x1a62
movq %rax, (%rbx)
movl $0x2, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1080
callq 0x10b0
leaq 0x641(%rip), %rdi       # 0x20f4
movl %eax, %esi
xorl %eax, %eax
callq 0x10e0
movl $0x8ca0, %edi           # imm = 0x8CA0
callq 0x11c0
addq $0xa0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/cirocosta[P]stress/src/./common.h
// Function: stress_write_n
ssize_t
stress_write_n(int fd, const void* vptr, size_t n)
{
	size_t nleft;
	ssize_t nwritten;
	const char* ptr;

	ptr = vptr;
	nleft = n;

	while (nleft > 0) {
		nwritten = write(fd, ptr, nleft);
		if (nwritten < 0) {
			if (errno == EINTR) {
				nwritten = 0;
				break;
			}

			return nwritten;
		}

		nleft -= nwritten;
		ptr += nwritten;
	}

	return n - nleft;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdx, %r14
testq %rdx, %rdx
je 0x1b13
movq %rsi, %r15
movl %edi, %ebp
movq %rbx, %r14
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x10a0
movq %rax, %r12
testq %rax, %rax
js 0x1b09
addq %r12, %r15
subq %r12, %r14
jne 0x1aea
jmp 0x1b13
callq 0x1040
cmpl $0x4, (%rax)
jne 0x1b19
subq %r14, %rbx
movq %rbx, %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cirocosta[P]stress/src/./common.h
// Function: stress_read_n
ssize_t
stress_read_n(int fd, void* vptr, size_t n)
{
	size_t nleft;
	ssize_t nread;
	char* ptr;

	ptr = vptr;
	nleft = n;

	while (nleft > 0) {
		nread = read(fd, ptr, nleft);
		if (nread < 0) {
			if (errno == EINTR) {
				nread = 0;
				break;
			}

			return nread;
		}

		nleft -= nread;
		ptr += nread;
	}

	return n - nleft;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdx, %r14
testq %rdx, %rdx
je 0x1b69
movq %rsi, %r15
movl %edi, %ebp
movq %rbx, %r14
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1110
movq %rax, %r12
testq %rax, %rax
js 0x1b5f
addq %r12, %r15
subq %r12, %r14
jne 0x1b40
jmp 0x1b69
callq 0x1040
cmpl $0x4, (%rax)
jne 0x1b6f
subq %r14, %rbx
movq %rbx, %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cirocosta[P]stress/src/locks-fcntl.c
// Function: create_file
void
create_file(const char* base, const int i)
{
	FILE* fp;
	char* filename;
	struct flock lock = { 0 };

	lock.l_type = F_WRLCK;

	_STRESS_MUST(asprintf(&filename, "%s/file%d", base, i) > 0,
	             "Couldn't create name for file %d",
	             i);
	_STRESS_MUST(
	  (fp = fopen(filename, "a")), "Couldn't create file %s", filename);

	_STRESS_MUST_P(fcntl(fileno(fp), F_SETLKW, &lock) != -1,
	               "fcntl",
	               "Couldn't acquire lock on %s",
	               filename);

	fprintf(fp, "dummy");
	free(filename);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movq %rdi, %rdx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movw $0x1, 0x10(%rsp)
leaq 0x56d(%rip), %rsi       # 0x210d
leaq 0x8(%rsp), %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1150
testl %eax, %eax
jle 0x1c14
movq 0x8(%rsp), %rdi
leaq 0x58c(%rip), %rsi       # 0x214a
callq 0x1160
testq %rax, %rax
je 0x1c1b
movq %rax, %rbx
movq %rax, %rdi
callq 0x1140
leaq 0x10(%rsp), %rdx
movl %eax, %edi
movl $0x7, %esi
xorl %eax, %eax
callq 0x1090
cmpl $-0x1, %eax
je 0x1c25
leaq 0x5a5(%rip), %rdi       # 0x2197
movl $0x5, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11b0
movq 0x8(%rsp), %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbx
retq
movl %ebx, %edi
callq 0x141c
leaq 0x8(%rsp), %rdi
callq 0x15d3
leaq 0x8(%rsp), %rdi
callq 0x14d2
// File: /workspace/github_c_makefile_star2_O1/cirocosta[P]stress/src/locks-fcntl.c
// Function: create_files
void
create_files(int n)
{
	struct stat st = { 0 };
	int i = 0;

	printf("creating directory for files at '%s'\n", files_directory);
	_STRESS_MUST(stat(files_directory, &st) == -1,
	             "Directory %s already exists. Please delete it and rerun.",
	             files_directory);
	_STRESS_MUST(mkdir(files_directory, 0700) != -1,
	             "Couldn't create %s directory",
	             files_directory);

	printf("%d files will be created\n", n);
	for (; i++ < n;) {
		create_file(files_directory, i);
	}

	printf("\nDone.\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movl %edi, %ebx
movq %rsp, %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x10f0
leaq 0x547(%rip), %rdi       # 0x219d
leaq 0x3c3(%rip), %r15       # 0x2020
movq %r15, %rsi
xorl %eax, %eax
callq 0x10e0
movq %r15, %rdi
movq %r14, %rsi
callq 0x1130
cmpl $-0x1, %eax
jne 0x1ce6
leaq 0x3a2(%rip), %rdi       # 0x2020
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x1060
cmpl $-0x1, %eax
je 0x1ceb
leaq 0x585(%rip), %rdi       # 0x2219
movl %ebx, %esi
xorl %eax, %eax
callq 0x10e0
testl %ebx, %ebx
jle 0x1cce
negl %ebx
movl $0x1, %r15d
leaq 0x370(%rip), %r14       # 0x2020
movq %r14, %rdi
movl %r15d, %esi
callq 0x1b7b
leal (%rbx,%r15), %eax
incl %eax
movl %r15d, %ecx
incl %ecx
movl %ecx, %r15d
cmpl $0x1, %eax
jne 0x1cb0
leaq 0x55e(%rip), %rdi       # 0x2233
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1070
callq 0x168c
callq 0x1745
// File: /workspace/github_c_makefile_star2_O1/cirocosta[P]stress/src/locks-fcntl.c
// Function: main
int
main(int argc, char** argv)
{
	stress_args_t args = { 0 };

	setbuf(stdout, NULL);
	stress_parse_args(argc, argv, &args);

	create_files(args.n);
	stress_wait_until_signalized();

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2010, %rsp           # imm = 0x2010
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %r14
movl $0x2008, %edx           # imm = 0x2008
movq %r14, %rdi
xorl %esi, %esi
callq 0x10f0
movq 0x22ad(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
xorl %esi, %esi
callq 0x10d0
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1949
movl (%r14), %edi
callq 0x1c2f
callq 0x1a72
xorl %eax, %eax
addq $0x2010, %rsp           # imm = 0x2010
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/randyrossi[P]fisher-modem/mkfilter/src/mkshape.C
// Function: usage()
static void usage() {
  fprintf(stderr, "Mkshape V.%s from <fisher@minster.york.ac.uk>\n", VERSION);
  fprintf(stderr,
          "Usage: mkshape -{cr} <alpha> <beta> <len> [-{lwx}] [-b nb]\n");
  fprintf(stderr, "       mkshape -i <len> [-{lwx}] [-b nb]\n");
  fprintf(stderr, "       mkshape -h <len> [-{lw}] [-b nb]\n");
  exit(1);
}

// Assembly:
pushq %rbx
movq 0x3565(%rip), %rbx      # 0x4fe0
movq (%rbx), %rdi
leaq 0x168d(%rip), %rsi      # 0x3112
leaq 0x16b5(%rip), %rdx      # 0x3141
xorl %eax, %eax
callq 0x10b0
movq (%rbx), %rcx
leaq 0x16a8(%rip), %rdi      # 0x3145
movl $0x3b, %esi
movl $0x1, %edx
callq 0x1130
movq (%rbx), %rcx
leaq 0x16cb(%rip), %rdi      # 0x3181
movl $0x29, %esi
movl $0x1, %edx
callq 0x1130
movq (%rbx), %rcx
leaq 0x16dc(%rip), %rdi      # 0x31ab
movl $0x28, %esi
movl $0x1, %edx
callq 0x1130
movl $0x1, %edi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/randyrossi[P]fisher-modem/mkfilter/src/mkshape.C
// Function: giveup(char const*, int)
static void giveup(const char* msg, int p1) {
  fprintf(stderr, "mkshape: ");
  fprintf(stderr, msg, p1);
  putc('\n', stderr);
  exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x34e7(%rip), %r15      # 0x4fe0
movq (%r15), %rcx
leaq 0x16d1(%rip), %rdi      # 0x31d4
movl $0x9, %esi
movl $0x1, %edx
callq 0x1130
movq (%r15), %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10b0
movq (%r15), %rsi
movl $0xa, %edi
callq 0x1120
movl $0x1, %edi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/randyrossi[P]fisher-modem/mkfilter/src/mkshape.C
// Function: apply_window()
static void apply_window() /* apply Hamming window to impulse response */
{
  if (options & opt_w) {
    int h = (numcoeffs - 1) / 2;
    for (int i = 1; i <= h; i++) {
      double w =
          0.54 - 0.46 * cos(TWOPI * (double)(h + i) / (double)(numcoeffs - 1));
      xcoeffs[h + i] *= w;
      xcoeffs[h - i] *= w;
    }
  }
}

// Assembly:
testb $0x20, 0x7581(%rip)     # 0x90c0
je 0x1bf9
movl 0x757d(%rip), %eax      # 0x90c8
cmpl $0x3, %eax
jl 0x1bf9
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %eax, %ecx
decl %ecx
shrl $0x1f, %ecx
addl %ecx, %eax
decl %eax
sarl %eax
movslq %eax, %rbx
cmpl $0x2, %ebx
movl $0x1, %r14d
cmovgel %ebx, %r14d
leaq 0x755f(%rip), %r15      # 0x90e0
leaq (%r15,%rbx,8), %r12
addq $-0x8, %r12
incq %rbx
negq %r14
xorl %r13d, %r13d
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
mulsd 0x146f(%rip), %xmm0     # 0x3010
movl 0x7521(%rip), %eax      # 0x90c8
decl %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
callq 0x1110
mulsd 0x146f(%rip), %xmm0     # 0x3030
addsd 0x146f(%rip), %xmm0     # 0x3038
movsd (%r15,%rbx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%r15,%rbx,8)
mulsd (%r12,%r13,8), %xmm0
movsd %xmm0, (%r12,%r13,8)
decq %r13
incq %rbx
cmpq %r13, %r14
jne 0x1b92
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/randyrossi[P]fisher-modem/mkfilter/src/mkshape.C
// Function: trunc_coeffs()
static void trunc_coeffs() {
  if (options & opt_b) {
    double fac = pow(2.0, (double)(truncbits - 1));
    int h = (numcoeffs - 1) / 2;
    double max =
        (options & opt_h) ? xcoeffs[h - 1] : xcoeffs[h]; /* max coeff */
    double scale = (fac - 1.0) / (fac * max);
    for (int i = 0; i < numcoeffs; i++) {
      double x = xcoeffs[i] * scale; /* scale coeffs so max is (fac-1.0)/fac */
      xcoeffs[i] = fix(x * fac) / fac; /* truncate */
    }
  }
}

// Assembly:
testb $-0x80, 0x74bf(%rip)    # 0x90c0
je 0x1cf0
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl 0x74ae(%rip), %edi      # 0x90c4
decl %edi
movsd 0x13e8(%rip), %xmm0     # 0x3008
callq 0x10c0
movslq 0x749c(%rip), %rbx      # 0x90c8
testq %rbx, %rbx
jle 0x1ce7
movapd %xmm0, %xmm1
leal -0x1(%rbx), %eax
shrl $0x1f, %eax
addl %ebx, %eax
decl %eax
sarl %eax
movl 0x7475(%rip), %ecx      # 0x90c0
shll $0x1c, %ecx
sarl $0x1f, %ecx
addl %eax, %ecx
movslq %ecx, %rax
leaq 0x7483(%rip), %r14      # 0x90e0
movsd 0x13db(%rip), %xmm2     # 0x3040
addsd %xmm0, %xmm2
movsd (%r14,%rax,8), %xmm0
mulsd %xmm1, %xmm0
divsd %xmm0, %xmm2
movsd %xmm2, (%rsp)
shlq $0x3, %rbx
xorl %r15d, %r15d
movsd %xmm1, 0x8(%rsp)
movsd (%r15,%r14), %xmm0
mulsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
ucomisd 0x13a8(%rip), %xmm0     # 0x3048
jae 0x1cc1
movsd 0x1376(%rip), %xmm1     # 0x3020
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x10f0
xorpd 0x1391(%rip), %xmm0     # 0x3050
jmp 0x1cce
addsd 0x1357(%rip), %xmm0     # 0x3020
callq 0x10f0
movsd 0x8(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%r15,%r14)
addq $0x8, %r15
cmpq %r15, %rbx
jne 0x1c89
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/randyrossi[P]fisher-modem/mkfilter/src/mkshape.C
// Function: fft(complex*, complex*, int)
static void fft(complex* data, complex* temp, int n) {
  if (n > 1) {
    int h = n / 2;
    for (int i = 0; i < h; i++) {
      int i2 = i * 2;
      temp[i] = data[i2];         /* even */
      temp[h + i] = data[i2 + 1]; /* odd	*/
    }
    fft(&temp[0], &data[0], h);
    fft(&temp[h], &data[h], h);
    int p = 0, t = SEQLEN / n;
    for (int i = 0; i < h; i++) {
      complex wkt = circle[p] * temp[h + i];
      data[i] = temp[i] + wkt;
      data[h + i] = temp[i] - wkt;
      p += t;
    }
  }
}

// Assembly:
cmpl $0x2, %edx
jl 0x1e28
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r12d
shrl %r12d
movq %r12, %rax
shlq $0x4, %rax
leaq (%rsi,%rax), %rcx
xorl %edx, %edx
movups (%r14,%rdx,2), %xmm0
movups %xmm0, (%rbx,%rdx)
movupd 0x10(%r14,%rdx,2), %xmm0
movupd %xmm0, (%rcx,%rdx)
addq $0x10, %rdx
cmpq %rdx, %rax
jne 0x1d23
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x1cf1
movl %r12d, %r15d
shlq $0x4, %r15
leaq (%rbx,%r15), %rdi
leaq (%r14,%r15), %rsi
movl %r12d, %edx
callq 0x1cf1
cmpl $0x1, %r12d
adcl $0x0, %r12d
xorl %r13d, %r13d
movl $0x800, %eax            # imm = 0x800
xorl %edx, %edx
divl %ebp
movq %rax, 0x10(%rsp)
leaq (%r14,%r15), %rbp
addq $0x8, %rbp
addq %rbx, %r15
addq $0x8, %r15
shlq $0x4, %r12
movq %r12, 0x8(%rsp)
xorl %r12d, %r12d
movq %r12, %rax
shlq $0x4, %rax
leaq 0x3318(%rip), %rcx      # 0x50c0
movsd (%rax,%rcx), %xmm0
movsd 0x8(%rax,%rcx), %xmm1
movsd -0x8(%r15,%r13), %xmm2
movsd (%r15,%r13), %xmm3
callq 0x20b1
movsd (%rbx,%r13), %xmm2
addsd %xmm0, %xmm2
movsd 0x8(%rbx,%r13), %xmm3
addsd %xmm1, %xmm3
movsd %xmm2, (%r14,%r13)
movsd %xmm3, 0x8(%r14,%r13)
movsd (%rbx,%r13), %xmm2
movsd 0x8(%rbx,%r13), %xmm3
subsd %xmm0, %xmm2
subsd %xmm1, %xmm3
movsd %xmm2, -0x8(%rbp,%r13)
movsd %xmm3, (%rbp,%r13)
addq 0x10(%rsp), %r12
addq $0x10, %r13
cmpq %r13, 0x8(%rsp)
jne 0x1d9a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ulisses[P]ftp-client-server/servidorc2.c
// Function: main
int main(int args, char **argv) {
        Flag *tp = NULL;
        Flag *te = NULL;

        if((tp = contem(argv,"-tp"))==NULL) {
                errorMsg();
                exit(2);
        }

        if((te = contem(argv,"-te"))==NULL) {
                errorMsg();
                exit(3);
        }

        if(tp->bool && te->bool) {
                servidor(atoi(argv[te->pos+1]),atoi(argv[tp->pos+1]));
        }
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x7e3(%rip), %rsi       # 0x3188
movq %rbx, %rdi
callq 0x2931
testq %rax, %rax
je 0x29e1
movq %rax, %r14
leaq 0x7d0(%rip), %rsi       # 0x318c
movq %rbx, %rdi
callq 0x2931
testq %rax, %rax
je 0x29f0
cmpl $0x0, (%r14)
je 0x29d4
cmpl $0x0, (%rax)
jne 0x29ff
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2920
movl $0x2, %edi
callq 0x11b0
callq 0x2920
movl $0x3, %edi
callq 0x11b0
movslq 0x4(%rax), %rax
movq 0x8(%rbx,%rax,8), %rdi
callq 0x1180
movl %eax, %r15d
movslq 0x4(%r14), %rax
movq 0x8(%rbx,%rax,8), %rdi
callq 0x1180
movl %r15d, %edi
movl %eax, %esi
callq 0x25b1
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/cyvm.c
// Function: show_token_err
void show_token_err(struct cy_token *t, const char *fmt, ...)
{
	va_list args;

	fprintf(stderr, "Error @%d.%d: ", t->ln, t->tn);

	va_start(args, fmt);
	vfprintf(stderr, fmt, args);
	va_end(args);

	fprintf(stderr, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
leaq 0x20(%rsp), %r14
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x329f
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x9d52(%rip), %r15      # 0xcff8
movq (%r15), %rax
movl 0x10(%rdi), %edx
movl 0x14(%rdi), %ecx
leaq 0x5d6a(%rip), %rsi      # 0x9020
movq %rax, %rdi
xorl %eax, %eax
callq 0x3120
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x31d0
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x30d0
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/cyvm.c
// Function: main
int main(int argc, char **argv, char **env)
{
	struct cy_file *cf;
	struct cy_token mt;
	struct cy_value rv = {};

	init_resolver();

	if (argc < 2)
		goto usage;

	if (!strcmp(argv[1], "-c")) {
		show_commands();
		return 0;
	}

	if (!strcmp(argv[1], "-r")) {
		if (argc < 3)
			goto usage;

		init_args(argc - 2, argv + 2);
		init_envs(env);

		cf = cy_open(argv[2], &mt, false);
		if (!cf)
			return -1;

		return cy_call_cblock(&mt, cf, &rv) >= 0 ? 0 : 1;
	}

	if (!strcmp(argv[1], "-t")) {
		if (argc < 3)
			goto usage;

		cf = cy_open(argv[2], &mt, true);
		if (!cf)
			return -1;

		return 0;
	}

usage:
	fprintf(stderr, "Use -c, -r <filename> or -t <filename>\n");
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movl %edi, %r14d
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
callq 0x3efb
cmpl $0x2, %r14d
jl 0x3dac
movq 0x8(%rbx), %r15
leaq 0x53b1(%rip), %rsi      # 0x904b
movq %r15, %rdi
callq 0x3110
testl %eax, %eax
je 0x3cfd
leaq 0x53a1(%rip), %rsi      # 0x904e
movq %r15, %rdi
callq 0x3110
testl %eax, %eax
je 0x3d09
leaq 0x5391(%rip), %rsi      # 0x9051
movq %r15, %rdi
callq 0x3110
cmpl $0x2, %r14d
je 0x3dac
testl %eax, %eax
jne 0x3dac
movq 0x10(%rbx), %rdi
leaq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x3f70
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x1, %rcx
sbbl %eax, %eax
jmp 0x3dbd
callq 0x3f34
xorl %eax, %eax
jmp 0x3dbd
cmpl $0x2, %r14d
je 0x3dac
addl $-0x2, %r14d
movq 0x9412(%rip), %r13      # 0xd130
xorl %r15d, %r15d
leaq 0x9408(%rip), %r12      # 0xd130
movl $0x20, %edi
callq 0x3180
movl $0x2, 0x10(%rax)
movq 0x10(%rbx,%r15,8), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x93e7(%rip)      # 0xd130
movq %r12, 0x8(%rax)
movq %r13, (%rax)
movq %rax, 0x8(%r13)
incq %r15
movq %rax, %r13
cmpq %r15, %r14
jne 0x3d28
leaq 0xa3d2(%rip), %rax      # 0xe138
movq 0x8(%rax), %rdx
leaq 0x530b(%rip), %rdi      # 0x907c
leaq 0x93c8(%rip), %rsi      # 0xd140
movl $0x1, %ecx
callq 0x5c00
movq 0x10(%rbx), %rdi
leaq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0x3f70
testq %rax, %rax
je 0x3db8
leaq 0x18(%rsp), %rdi
movq %rsp, %rdx
movq %rax, %rsi
callq 0x6710
shrl $0x1f, %eax
jmp 0x3dbd
callq 0x3303
movl $0x1, %eax
jmp 0x3dbd
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/resolver.c
// Function: cy_resolve
int cy_resolve(struct cy_token *t)
{
	if (try_resolve_command(t))
		return 1;

	if (try_resolve_sym(t))
		return 1;

	if (t->val[0] == '#') {
		t->typ = &comment;
		return 1;
	}

	show_token_err(t, "Can't resolve token value %s", t->val);
	return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
xorl %eax, %eax
movq %r14, %rdx
xorl %ecx, %ecx
movsbl (%rdx), %edi
testl %edi, %edi
je 0x3df5
movl %edi, %r8d
shll %cl, %r8d
addl %r8d, %eax
incq %rdx
incl %ecx
jmp 0x3df7
movl %eax, %esi
testb %dil, %dil
jne 0x3dde
andl $0x1f, %esi
leaq 0xa20a(%rip), %rax      # 0xe010
movq (%rax,%rsi,8), %r15
testq %r15, %r15
je 0x3e24
movq (%r15), %rdi
movq %r14, %rsi
callq 0x3110
testl %eax, %eax
je 0x3e4c
movq 0x20(%r15), %r15
jmp 0x3e0a
movq %rbx, %rdi
callq 0x49b8
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x3e71
movq (%rbx), %rdx
cmpb $0x23, (%rdx)
jne 0x3e5b
leaq 0x930a(%rip), %rcx      # 0xd150
movq %rcx, 0x8(%rbx)
jmp 0x3e71
addq $0x8, %r15
movq %r15, 0x8(%rbx)
movl $0x1, %eax
jmp 0x3e71
leaq 0x521f(%rip), %rsi      # 0x9081
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/resolver.c
// Function: init_resolver
void init_resolver(void)
{
	init_declare();
	init_show();
	init_aryth();
	init_list();
	init_map();
	init_string();
	init_cblocks();
	init_cond();
	init_misc();
	init_iter();
	init_stream();
}

// Assembly:
pushq %rax
callq 0x4bfd
callq 0x5198
callq 0x4350
callq 0x5613
callq 0x5e2c
callq 0x6034
callq 0x6801
callq 0x6b4d
callq 0x788f
callq 0x81f4
popq %rax
jmp 0x7d7c
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/tokenizer.c
// Function: cy_open
struct cy_file *cy_open(const char *filename, struct cy_token *mt, bool verbose)
{
	int ret;
	struct cy_file *cf;
	static struct cy_type root_cblock = {};

	cf = cy_read(filename);
	if (!cf)
		return NULL;

	cf->verbose = verbose;
	cf->main = NULL;
	mt->typ = &root_cblock;
	ret = read_cblocks(mt, cf);
	if (ret < 0) {
		fprintf(stderr, "Can't parse file");
		return NULL;
	}

	return cf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movl $0x38, %edi
callq 0x3180
movq %rax, %r14
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x31a0
testl %eax, %eax
js 0x407c
movl %eax, %r15d
movl $0x400, %edi            # imm = 0x400
callq 0x3180
movq %rax, (%r14)
movl $0x400, %edx            # imm = 0x400
movl %r15d, %edi
movq %rax, %rsi
callq 0x30e0
testl %eax, %eax
js 0x4006
xorl %r12d, %r12d
testl %eax, %eax
je 0x4013
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
leaq (%rax,%r12), %r13
movq (%r14), %rdi
leaq (%rax,%r12), %rsi
addq $0x400, %rsi            # imm = 0x400
callq 0x3190
movq %rax, (%r14)
leaq (%rax,%r13), %rsi
movl $0x400, %edx            # imm = 0x400
movl %r15d, %edi
callq 0x30e0
movq %r13, %r12
testl %eax, %eax
jns 0x3fcb
movq %r14, %rdi
movl %r15d, %esi
callq 0x331f
jmp 0x4090
movl %r15d, %edi
callq 0x30c0
movq (%r14), %rax
movq %rax, 0x8(%r14)
addq %rax, %r12
movq %r12, 0x10(%r14)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x18(%r14)
testq %r14, %r14
je 0x4067
movb %bpl, 0x20(%r14)
movq $0x0, 0x28(%r14)
leaq 0xa0c1(%rip), %rax      # 0xe110
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4095
testl %eax, %eax
jns 0x406a
callq 0x3352
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x3030
leaq 0x502d(%rip), %rdi      # 0x90b8
callq 0x31c0
xorl %r14d, %r14d
jmp 0x4037
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/tokenizer.c
// Function: cy_next
int cy_next(struct cy_file *cf, struct cy_token *t)
{
	struct list_head *n;

	if (cf->nxt == NULL)
		return 0;

	*t = cf->nxt->t;
	if (t->typ->eval != NULL)
		t->v.t = CY_V_NOVALUE;

	n = cf->nxt->l.next;
	if (n == &cf->main->h)
		cf->nxt = NULL;
	else
		cf->nxt = list_entry(n, struct cy_ctoken, l);

	return 1;
}

// Assembly:
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x434b
movups 0x10(%rax), %xmm0
movups 0x20(%rax), %xmm1
movups %xmm0, (%rsi)
movq 0x30(%rax), %rax
movq %rax, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movq 0x8(%rsi), %rax
cmpq $0x0, 0x8(%rax)
je 0x432f
movl $0x0, 0x18(%rsi)
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rax
xorl %ecx, %ecx
cmpq 0x28(%rdi), %rax
cmovneq %rax, %rcx
movq %rcx, 0x30(%rdi)
movl $0x1, %eax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/aryth.c
// Function: eval_add
static int eval_add(struct cy_token *t, struct cy_file *f)
{
	struct cy_token a, b;

	if (eval_2arg_math(&a, &b, f) <= 0)
		return -1;

	if (a.v.t == CY_V_LIST)
		return cy_list_splice(&a.v, &b.v, &t->v);

	if (a.v.t == CY_V_NUMBER) {
		t->v.t = CY_V_NUMBER;
		t->v.v_i = a.v.v_i + b.v.v_i;
		return 1;
	}

	if (a.v.t == CY_V_STRING) {
		t->v.t = CY_V_STRING;
		t->v.v_str = xstrcat(a.v.v_str, b.v.v_str);
		return 1;
	}

	show_token_err(t, "Bad op for add");
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x48ea
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x4453
movl 0x20(%rsp), %eax
cmpl $0x1, %eax
je 0x4426
cmpl $0x2, %eax
je 0x43c4
cmpl $0x3, %eax
jne 0x4442
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rsi
addq $0x18, %rbx
movq %rbx, %rdx
callq 0x5428
movl %eax, %ebp
jmp 0x4453
movl $0x2, 0x18(%rbx)
movq 0x28(%rsp), %r15
movq 0x50(%rsp), %r14
movq %r15, %rdi
callq 0x3090
movq %rax, %r12
movq %r14, %rdi
callq 0x3090
movq %rax, %r13
addl %r12d, %eax
incl %eax
movslq %eax, %rdi
callq 0x3180
movq %rax, %rbp
movslq %r12d, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3150
addq %rbp, %r12
incl %r13d
movslq %r13d, %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x3150
movq %rbp, 0x20(%rbx)
jmp 0x443b
movl $0x1, 0x18(%rbx)
movq 0x50(%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x20(%rbx)
movl $0x1, %ebp
jmp 0x4453
leaq 0x4ce7(%rip), %rsi      # 0x9130
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3240
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/aryth.c
// Function: eval_nr_op
static int eval_nr_op(struct cy_token *t, struct cy_file *f)
{
	int ret;
	struct cy_token a, b;

	ret = eval_2arg_math(&a, &b, f);
	if (ret <= 0)
		return -1;

	t->v.t = a.v.t;

	switch (a.v.t) {
	case CY_V_NUMBER:
		if (t->typ->priv == OP_MUL) {
			t->v.v_i = a.v.v_i * b.v.v_i;
		} else {
			if (b.v.v_i == 0) {
				show_token_err(t, "Division by zero");
				return -1;
			}

			if (t->typ->priv == OP_DIV)
				t->v.v_i = a.v.v_i / b.v.v_i;
			else
				t->v.v_i = a.v.v_i % b.v.v_i;
		}
		break;
	default:
		show_token_err(t, "Can't DIV %s", vtype2s(a.v.t));
		return -1;
	}

	return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x48ea
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x476b
movl 0x20(%rsp), %edi
movl %edi, 0x18(%rbx)
cmpl $0x1, %edi
jne 0x472d
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rcx
cmpq $0x3, %rcx
jne 0x4748
movq 0x50(%rsp), %rax
imulq 0x28(%rsp), %rax
jmp 0x4762
callq 0x3bfc
leaq 0x4a59(%rip), %rsi      # 0x9192
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
jmp 0x476b
movq 0x50(%rsp), %rsi
testq %rsi, %rsi
je 0x4774
movq 0x28(%rsp), %rax
cqto
idivq %rsi
cmpq $0x1, %rcx
jne 0x4787
movq %rax, 0x20(%rbx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4a06(%rip), %rsi      # 0x9181
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3240
jmp 0x476b
movq %rdx, 0x20(%rbx)
jmp 0x4766
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/aryth.c
// Function: eval_bool_op
static int eval_bool_op(struct cy_token *t, struct cy_file *f)
{
	int ret;
	struct cy_token a, b;

	ret = eval_2arg_math(&a, &b, f);
	if (ret <= 0)
		return -1;

	t->v.t = a.v.t;

	switch (t->v.t) {
	case CY_V_BOOL:
		switch (t->typ->priv) {
		case OP_AND: t->v.v_bool = a.v.v_bool && b.v.v_bool; break;
		case OP_OR:  t->v.v_bool = a.v.v_bool || b.v.v_bool; break;
		case OP_XOR: t->v.v_bool = a.v.v_bool ^  b.v.v_bool; break;
		}
		break;
	default:
		show_token_err(t, "Bool command on %s", vtype2s(a.v.t));
		return -1;
	}

	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x48ea
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x4827
movl 0x20(%rsp), %edi
movl %edi, 0x18(%r14)
cmpl $0x6, %edi
jne 0x47e9
movq 0x8(%r14), %rax
movq 0x10(%rax), %rax
movl $0x1, %ebx
cmpq $0x4, %rax
je 0x481a
cmpq $0x2, %rax
je 0x4804
cmpq $0x1, %rax
jne 0x4827
xorl %eax, %eax
cmpb $0x0, 0x28(%rsp)
jne 0x4810
jmp 0x4814
callq 0x3bfc
leaq 0x49aa(%rip), %rsi      # 0x919f
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
jmp 0x4827
cmpb $0x0, 0x28(%rsp)
movl $0x1, %eax
jne 0x4814
movl 0x50(%rsp), %eax
movb %al, 0x20(%r14)
jmp 0x4827
movb 0x28(%rsp), %al
cmpb 0x50(%rsp), %al
setne 0x20(%r14)
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/aryth.c
// Function: eval_bool_not
static int eval_bool_not(struct cy_token *t, struct cy_file *f)
{
	struct cy_token a;

	if (cy_eval_next_x(f, &a, CY_V_BOOL) <= 0)
		return -1;

	t->v.t = CY_V_BOOL;
	t->v.v_bool = !a.v.v_bool;
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x48e5
je 0x4871
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x4873
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x4873
xorl %eax, %eax
cmpl $0x1, %eax
jne 0x48bb
movl $0x1, %eax
cmpl $0x6, 0x20(%rsp)
je 0x48bb
movl $0x6, %edi
callq 0x3bfc
movq %rax, %r14
leaq 0x8(%rsp), %r15
movl 0x18(%r15), %edi
callq 0x3bfc
leaq 0x48b2(%rip), %rsi      # 0x9158
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x48d6
movl $0x6, 0x18(%rbx)
movb 0x28(%rsp), %al
xorb $0x1, %al
movb %al, 0x20(%rbx)
movl $0x1, %eax
jmp 0x48db
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x341e
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/syms.c
// Function: try_resolve_sym
int try_resolve_sym(struct cy_token *t)
{
	if (try_resolve_number(t))
		return 1;

	if (t->val[0] == '"' || t->val[0] == '\'') {
		t->typ = &cy_string;
		t->v.t = CY_V_STRING;
		t->v.v_str = t->val + 1;
		return 1;
	}

	if (try_resolve_symbol(t))
		return 1;

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq %rdi, (%rsp)
cmpb $0x2d, (%rdi)
jne 0x49d3
leaq 0x1(%rdi), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0xa, %edx
cmpb $0x30, (%rax)
jne 0x49f1
xorl %ecx, %ecx
cmpb $0x78, 0x1(%rax)
sete %cl
leal 0x8(,%rcx,8), %edx
movq %rsp, %r14
movq %r14, %rsi
callq 0x3140
movq %rax, 0x20(%rbx)
movq (%r14), %rax
cmpb $0x0, (%rax)
je 0x4a33
movq (%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x27, %ecx
je 0x4a18
cmpl $0x22, %ecx
jne 0x4a4c
leaq 0x8931(%rip), %rcx      # 0xd350
movq %rcx, 0x8(%rbx)
movl $0x2, 0x18(%rbx)
incq %rax
movq %rax, 0x20(%rbx)
jmp 0x4a45
leaq 0x892e(%rip), %rax      # 0xd368
movq %rax, 0x8(%rbx)
movl $0x1, 0x18(%rbx)
movl $0x1, %eax
jmp 0x4a5d
movq %rbx, %rdi
callq 0x4a92
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/declare.c
// Function: try_resolve_symbol
int try_resolve_symbol(struct cy_token *t)
{
	const char *val = t->val, *aux;
	struct cy_type *ret;

	t->v.v_sym = val;

	if (val[0] == '_') {
		if (val[1] == '.')
			/*
			 * this is a _.... construciton which
			 * is valid nested symbol, but requires
			 * additional checking
			 */
			goto sym;

		if (val[1] == '\0') {
			t->typ = &cy_cursor;
			return 1;
		}

		if (val[1] == '_' && val[2] == '\0') {
			t->typ = &cy_curns;
			return 1;
		}

		if (try_resolve_cvalue(t))
			return 1;

		if (try_resolve_stream(t))
			return 1;

		return 0;
	}

	if (!is_alpha(val[0]))
		return 0;

sym:
	ret = &cy_sym;
	aux = val; /* sym len counting */
	for (val++; *val != '\0'; val++) {
		if (val - aux >= MAX_SYM_LEN) {
			show_token_err(t, "Too long symbol");
			return 0;
		}

		if (is_alpha(*val))
			continue;
		if (is_num(*val))
			continue;
		if (*val == '_')
			continue;
		if (*val == '.') {
			aux = val;
			continue;
		}

		return 0;
	}

	t->typ = ret;
	return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq %rax, 0x20(%rdi)
movb (%rax), %cl
cmpb $0x5f, %cl
jne 0x4ac9
movzbl 0x1(%rax), %ecx
cmpl $0x5f, %ecx
je 0x4b43
cmpl $0x2e, %ecx
je 0x4ada
testl %ecx, %ecx
jne 0x4b49
leaq 0x88d1(%rip), %rax      # 0xd398
jmp 0x4b38
andb $-0x21, %cl
addb $-0x41, %cl
xorl %ebp, %ebp
cmpb $0x19, %cl
ja 0x4b7f
movb 0x1(%rax), %sil
testb %sil, %sil
je 0x4b31
leaq 0x1(%rax), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, %rdi
subq %rax, %rdi
cmpq $0x40, %rdi
jge 0x4b6c
leal -0x30(%rsi), %edi
cmpb $0xa, %dil
jb 0x4b22
movl %esi, %edi
andb $-0x21, %dil
addb $-0x41, %dil
cmpb $0x1a, %dil
jb 0x4b22
cmpb $0x5f, %sil
je 0x4b22
movzbl %sil, %eax
cmpl $0x2e, %eax
jne 0x4b91
movq %rcx, %rax
movb 0x1(%rcx), %sil
incq %rcx
incq %rdx
testb %sil, %sil
jne 0x4aeb
leaq 0x8848(%rip), %rax      # 0xd380
movq %rax, 0x8(%rbx)
movl $0x1, %ebp
jmp 0x4b7f
cmpb $0x0, 0x2(%rax)
je 0x4b88
movq %rbx, %rdi
callq 0x7814
movl $0x1, %ebp
testl %eax, %eax
jne 0x4b7f
movq %rbx, %rdi
callq 0x7cec
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
jmp 0x4b7f
leaq 0x4647(%rip), %rsi      # 0x91ba
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3240
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x8821(%rip), %rax      # 0xd3b0
jmp 0x4b38
xorl %ebp, %ebp
jmp 0x4b7f
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/declare.c
// Function: try_deref_symbol
int try_deref_symbol(const char *val, struct cy_value *sv, bool strict)
{
	struct cy_token ft;

	ft.val = val;
	if (!try_resolve_symbol(&ft))
		return -1;

	if (strict && !is_symbol_token(&ft)) {
		fprintf(stderr, "Nested resolve is not a symbol");
		return -1;
	}

	if (ft.typ->eval(&ft, NULL) < 0)
		return -1;

	*sv = ft.v;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rsi, %r14
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
movq %rax, %rdi
callq 0x4a92
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x4beb
testb %bpl, %bpl
je 0x4bce
leaq 0x87b9(%rip), %rax      # 0xd380
cmpq %rax, 0x10(%rsp)
jne 0x4bf6
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rax
xorl %esi, %esi
callq *0x8(%rax)
testl %eax, %eax
js 0x4beb
movups 0x20(%rsp), %xmm0
movups %xmm0, (%r14)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x348d
jmp 0x4beb
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/declare.c
// Function: eval_declare
static int eval_declare(struct cy_token *t, struct cy_file *f)
{
	struct cy_token st, vt;
	struct cy_value in, last;
	char buf[MAX_SYM_LEN + 1];

	if (cy_next(f, &st) <= 0)
		return -1;

	if (!is_symbol_token(&st)) {
		show_token_err(t, "Declaration to non-symbol");
		return -1;
	}

	if (dereference(&st, &in, &last, buf) <= 0)
		return -1;

	if (last.t != CY_V_STRING) {
		show_token_err(t, "Last sym is not a string");
		return -1;
	}

	if (in.t != CY_V_MAP) {
		show_token_err(t, "Can't declare in non-map");
		return -1;
	}

	if (t->typ->priv) { /* swap */
		struct cy_map_value *mv;

		mv = find_in_map(&in.v_map->r, last.v_str, 0);
		if (mv == NULL)
			goto set;

		set_cursor(&mv->v);
		if (cy_eval_next(f, &vt) <= 0)
			return -1;

		set_cursor(NULL);
		t->v = mv->v;
		mv->v = vt.v;

		return 1;
	}

set:
	if (cy_eval_next(f, &vt) <= 0)
		return -1;

	if (map_add_value(strdup(last.v_str), &vt.v, &in.v_map->r, true) < 0)
		return -1;

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x42fd
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x4e86
leaq 0x8512(%rip), %rax      # 0xd380
cmpq %rax, 0x50(%rsp)
je 0x4e96
leaq 0x43e8(%rip), %rsi      # 0x9264
movq %r14, %rdi
xorl %eax, %eax
callq 0x3240
movl %ebp, %eax
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
leaq 0x70(%rsp), %rcx
callq 0x4c44
testl %eax, %eax
jle 0x4e86
cmpl $0x2, (%rsp)
jne 0x4f28
cmpl $0x4, 0x10(%rsp)
jne 0x4f34
movq 0x8(%r14), %rax
cmpq $0x0, 0x10(%rax)
je 0x4f50
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x5cd0
movq %rax, %r15
testq %rax, %rax
je 0x4f40
movups 0x20(%r15), %xmm0
movups %xmm0, 0x9236(%rip)     # 0xe128
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x5158
testl %eax, %eax
jle 0x4f42
leaq 0x20(%r15), %rax
movl $0x0, 0x9217(%rip)      # 0xe128
movups (%rax), %xmm0
movups %xmm0, 0x18(%r14)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rax)
movl $0x1, %ebp
jmp 0x4f47
leaq 0x434f(%rip), %rsi      # 0x927e
jmp 0x4e7c
leaq 0x435c(%rip), %rsi      # 0x9297
jmp 0x4e7c
jmp 0x4f47
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %r15, %r15
jne 0x4e86
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x42fd
testl %eax, %eax
js 0x4fba
je 0x4f7d
movq 0x28(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x4f7f
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq *%rcx
jmp 0x4f7f
xorl %eax, %eax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x4e86
movq 0x8(%rsp), %rdi
callq 0x3220
leaq 0x38(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
movl $0x1, %ecx
callq 0x5c00
movl %eax, %ebp
sarl $0x1f, %ebp
orl $0x1, %ebp
jmp 0x4e86
callq 0x34af
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/declare.c
// Function: eval_nsenter
static int eval_nsenter(struct cy_token *t, struct cy_file *f)
{
	struct cy_token nst;

	if (cy_eval_next_x(f, &nst, CY_V_MAP) <= 0)
		return -1;

	symbols = nst.v;
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x42fd
testl %eax, %eax
js 0x5062
je 0x4ff6
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x4ff8
movq %rsp, %rdi
movq %rbx, %rsi
callq *%rcx
jmp 0x4ff8
xorl %eax, %eax
cmpl $0x1, %eax
jne 0x503e
movl $0x1, %eax
cmpl $0x4, 0x18(%rsp)
je 0x503e
movl $0x4, %edi
callq 0x3bfc
movq %rax, %rbx
movq %rsp, %r14
movl 0x18(%r14), %edi
callq 0x3bfc
leaq 0x412f(%rip), %rsi      # 0x9158
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x5055
movups 0x18(%rsp), %xmm0
movups %xmm0, 0x90ea(%rip)     # 0xe138
movl $0x1, %eax
jmp 0x505a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x34d4
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/declare.c
// Function: eval_deref
static int eval_deref(struct cy_token *t, struct cy_file *f)
{
	struct cy_token st, kt;
	int ret;

	if (cy_eval_next(f, &st) <= 0)
		return -1;
	if (cy_eval_next(f, &kt) <= 0)
		return -1;

	switch (st.v.t) {
		case CY_V_LIST:
			ret = dereference_list_elem(t, &st.v, &kt.v);
			break;
		case CY_V_MAP:
			ret = dereference_map_elem(t, &st.v, &kt.v);
			break;
		default:
			show_token_err(t, "Unknown symbol (%s) for nesting", vtype2s(st.v.t));
			ret = -1;
			break;
	}

	if (ret <= 0)
		return -1;

	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x514e
je 0x50a6
movq 0x30(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x50a8
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x50a8
xorl %eax, %eax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x5143
movq %rsp, %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x5153
je 0x50e2
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x50e4
movq %rsp, %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x50e4
xorl %eax, %eax
testl %eax, %eax
jle 0x5143
leaq 0x40(%rsp), %rsi
movl (%rsi), %edi
cmpl $0x4, %edi
je 0x5108
cmpl $0x3, %edi
jne 0x5117
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x551e
jmp 0x5135
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x5d2e
jmp 0x5135
callq 0x3bfc
leaq 0x40e4(%rip), %rsi      # 0x9207
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
testl %eax, %eax
setg %cl
leal -0x1(,%rcx,2), %ebp
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x351e
callq 0x34f9
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/./cy.h
// Function: cy_eval_next
static inline int cy_eval_next(struct cy_file *f, struct cy_token *t)
{
	int ret;

	ret = cy_next(f, t);
	if (ret < 0) {
		fprintf(stderr, "FATAL: Next token error\n");
		exit(1);
	}

	if (ret > 0 && t->typ->eval)
		ret = t->typ->eval(t, f);

	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x42fd
testl %eax, %eax
js 0x5193
je 0x5189
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x518b
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x3543
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/show.c
// Function: eval_show
static int eval_show(struct cy_token *t, struct cy_file *f)
{
	struct cy_token st;

	if (cy_eval_next(f, &st) <= 0)
		return -1;

	return show_value(&st.v, '\n', t);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x5201
je 0x51da
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x51dc
movq %rsp, %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x51dc
xorl %eax, %eax
testl %eax, %eax
jle 0x51f4
leaq 0x18(%rsp), %rdi
movl $0xa, %esi
movq %rbx, %rdx
callq 0x52ac
jmp 0x51f9
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x3568
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/show.c
// Function: eval_print
static int eval_print(struct cy_token *t, struct cy_file *f)
{
	struct cy_token st;

	if (cy_eval_next_x(f, &st, CY_V_STRING) <= 0)
		return -1;

	printf("%s\n", st.v.v_str);
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x42fd
testl %eax, %eax
js 0x52a7
je 0x523d
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x523f
movq %rsp, %rdi
movq %rbx, %rsi
callq *%rcx
jmp 0x523f
xorl %eax, %eax
cmpl $0x1, %eax
jne 0x5285
movl $0x1, %eax
cmpl $0x2, 0x18(%rsp)
je 0x5285
movl $0x2, %edi
callq 0x3bfc
movq %rax, %rbx
movq %rsp, %r14
movl 0x18(%r14), %edi
callq 0x3bfc
leaq 0x3ee8(%rip), %rsi      # 0x9158
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x529a
movq 0x20(%rsp), %rdi
callq 0x3060
movl $0x1, %eax
jmp 0x529f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x358d
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/show.c
// Function: show_value
static int show_value(struct cy_value *v, char tc, struct cy_token *st)
{
	switch (v->t) {
	default:
		show_token_err(st, "Can't show %s", vtype2s(v->t));
		return -1;
	case CY_V_NOVALUE:
		printf("NOVALUE%c", tc);
		break;
	case CY_V_NUMBER:
		printf("%li%c", v->v_i, tc);
		break;
	case CY_V_STRING:
		printf("\"%s\"%c", v->v_str, tc);
		break;
	case CY_V_LIST:
		show_list(&v->v_list->h, tc, st);
		break;
	case CY_V_MAP:
		show_map(&v->v_map->r, tc, st);
		break;
	case CY_V_BOOL:
		printf("%s%c", v->v_bool ? "TRUE" : "FALSE", tc);
		break;
	case CY_V_CBLOCK:
		printf("$CBLOCK%c", tc);
		break;
	}

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl (%rdi), %eax
cmpq $0x6, %rax
ja 0x539d
movl %esi, %ebx
leaq 0x3fe4(%rip), %rcx      # 0x92b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzbl %bl, %esi
leaq 0x4009(%rip), %rdi      # 0x92e8
jmp 0x540e
movq 0x8(%rdi), %r15
leaq 0x4031(%rip), %rdi      # 0x9320
xorl %eax, %eax
callq 0x30b0
movq %r15, %rdi
callq 0x771c
testq %rax, %rax
je 0x5344
movq %rax, %r15
leaq 0x4016(%rip), %r12      # 0x9323
movq -0x8(%r15), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x30b0
leaq 0x18(%r15), %rdi
movl $0x20, %esi
movq %r14, %rdx
callq 0x52ac
testl %eax, %eax
jle 0x5415
movq %r15, %rdi
callq 0x774c
movq %rax, %r15
testq %rax, %rax
jne 0x530d
movzbl %bl, %esi
leaq 0x3fd9(%rip), %rdi      # 0x9327
jmp 0x540e
movq 0x8(%rdi), %rsi
movzbl %bl, %edx
leaq 0x3f97(%rip), %rdi      # 0x92f8
jmp 0x53fb
movq 0x8(%rdi), %r15
leaq 0x3fa8(%rip), %rdi      # 0x9319
xorl %eax, %eax
callq 0x30b0
movq %r15, %r12
movq 0x8(%r12), %r12
cmpq %r15, %r12
je 0x5404
leaq 0x10(%r12), %rdi
movl $0x20, %esi
movq %r14, %rdx
callq 0x52ac
testl %eax, %eax
jg 0x537b
jmp 0x5415
movl %eax, %edi
callq 0x3bfc
leaq 0x3f2f(%rip), %rsi      # 0x92da
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x541a
movq 0x8(%rdi), %rsi
movzbl %bl, %edx
leaq 0x3f25(%rip), %rdi      # 0x92f2
jmp 0x53fb
movzbl %bl, %esi
leaq 0x3f36(%rip), %rdi      # 0x930f
jmp 0x540e
leaq 0x3f22(%rip), %rax      # 0x9304
cmpb $0x0, 0x8(%rdi)
leaq 0x3f1c(%rip), %rsi      # 0x9309
cmovneq %rax, %rsi
movzbl %bl, %edx
leaq 0x3f04(%rip), %rdi      # 0x92ff
xorl %eax, %eax
callq 0x30b0
jmp 0x5415
movzbl %bl, %esi
leaq 0x3f0e(%rip), %rdi      # 0x931c
xorl %eax, %eax
callq 0x30b0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/list.c
// Function: cy_list_splice
int cy_list_splice(struct cy_value *l1, struct cy_value *l2, struct cy_value *r)
{
	make_list(r);

	copy_list(&l1->v_list->h, &r->v_list->h);
	copy_list(&l2->v_list->h, &r->v_list->h);

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x3, (%rdx)
movl $0x10, %edi
callq 0x3180
movq %rax, 0x8(%rbx)
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq 0x8(%r15), %rdi
movq %rax, %rsi
callq 0x5475
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x5475
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq