LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x7b6(%rip), %rdi       # 0x219d
leaq 0x632(%rip), %r15       # 0x2020
movq %r15, %rsi
xorl %eax, %eax
callq 0x10e0
movq %r15, %rdi
movq %r14, %rsi
callq 0x1130
cmpl $-0x1, %eax
jne 0x1a77
leaq 0x611(%rip), %rdi       # 0x2020
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x1060
cmpl $-0x1, %eax
je 0x1b01
leaq 0x7f0(%rip), %rdi       # 0x2219
xorl %r15d, %r15d
movl %ebx, %esi
xorl %eax, %eax
callq 0x10e0
testl %ebx, %ebx
cmovgl %ebx, %r15d
negl %r15d
pushq $0x1
popq %rbx
leaq 0x5d8(%rip), %r14       # 0x2020
leal (%r15,%rbx), %eax
cmpl $0x1, %eax
je 0x1a5f
movq %r14, %rdi
movl %ebx, %esi
callq 0x16fe
incl %ebx
jmp 0x1a48
leaq 0x7cd(%rip), %rdi       # 0x2233
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1070
movq 0x257a(%rip), %r14      # 0x3ff8
movq (%r14), %rcx
leaq 0x6ff(%rip), %rdi       # 0x2187
pushq $0x9
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x11b0
movq (%r14), %rcx
leaq 0x6ed(%rip), %rdi       # 0x218d
pushq $0x3
popq %rsi
movq %rbx, %rdx
callq 0x11b0
movq (%r14), %rdi
leaq 0x70e(%rip), %rsi       # 0x21c3
leaq 0x564(%rip), %rdx       # 0x2020
xorl %eax, %eax
callq 0x1120
movq (%r14), %rcx
leaq 0x585(%rip), %rdi       # 0x2052
pushq $0x2
popq %rsi
movq %rbx, %rdx
callq 0x11b0
movq (%r14), %rdi
leaq 0x573(%rip), %rsi       # 0x2055
leaq 0x64f(%rip), %rdx       # 0x2138
xorl %eax, %eax
callq 0x1120
movq (%r14), %rdi
leaq 0x577(%rip), %rsi       # 0x2071
pushq $0x37
jmp 0x1b86
movq 0x24f0(%rip), %r14      # 0x3ff8
movq (%r14), %rcx
leaq 0x675(%rip), %rdi       # 0x2187
pushq $0x9
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x11b0
movq (%r14), %rcx
leaq 0x663(%rip), %rdi       # 0x218d
pushq $0x3
popq %rsi
movq %rbx, %rdx
callq 0x11b0
movq (%r14), %rdi
leaq 0x6bd(%rip), %rsi       # 0x21fc
leaq 0x4da(%rip), %rdx       # 0x2020
xorl %eax, %eax
callq 0x1120
movq (%r14), %rcx
leaq 0x4fb(%rip), %rdi       # 0x2052
pushq $0x2
popq %rsi
movq %rbx, %rdx
callq 0x11b0
movq (%r14), %rdi
leaq 0x4e9(%rip), %rsi       # 0x2055
leaq 0x5c5(%rip), %rdx       # 0x2138
xorl %eax, %eax
callq 0x1120
movq (%r14), %rdi
leaq 0x4ed(%rip), %rsi       # 0x2071
pushq $0x3a
popq %rdx
xorl %eax, %eax
callq 0x1120
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x1100
movq (%r14), %rcx
leaq 0x4db(%rip), %rdi       # 0x207e
pushq $0xa
popq %rsi
movq %rbx, %rdx
callq 0x11b0
pushq $0x1
popq %rdi
callq 0x11a0
// File: /workspace/github_c_makefile_star2_O2/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 0x23e7(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
xorl %esi, %esi
callq 0x10d0
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x132d
movl (%r14), %edi
callq 0x19c0
callq 0x15fe
xorl %eax, %eax
addq $0x2010, %rsp           # imm = 0x2010
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq 0x3443(%rip), %r14      # 0x4fe0
movq (%r14), %rdi
leaq 0x156b(%rip), %rsi      # 0x3112
leaq 0x1593(%rip), %rdx      # 0x3141
xorl %eax, %eax
callq 0x10b0
movq (%r14), %rcx
leaq 0x1586(%rip), %rdi      # 0x3145
pushq $0x3b
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x1130
movq (%r14), %rcx
leaq 0x15aa(%rip), %rdi      # 0x3181
pushq $0x29
popq %rsi
movq %rbx, %rdx
callq 0x1130
movq (%r14), %rcx
leaq 0x15bf(%rip), %rdi      # 0x31ab
pushq $0x28
popq %rsi
movq %rbx, %rdx
callq 0x1130
pushq $0x1
popq %rdi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/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 0x33b2(%rip), %r15      # 0x4fe0
movq (%r15), %rcx
leaq 0x159c(%rip), %rdi      # 0x31d4
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
callq 0x1130
movq (%r15), %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10b0
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x1120
pushq $0x1
popq %rdi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0x4(%rsp)
cmpl $0x2, %edx
jl 0x1da6
movq %rsi, %r14
movq %rdi, %r15
movl 0x4(%rsp), %eax
movl %eax, %r12d
shrl %r12d
movq %r12, %rcx
shlq $0x4, %rcx
leaq (%rsi,%rcx), %r13
xorl %eax, %eax
cmpq %rax, %rcx
je 0x1cc0
movups (%r15,%rax,2), %xmm0
movups %xmm0, (%r14,%rax)
movupd 0x10(%r15,%rax,2), %xmm0
movupd %xmm0, (%r13,%rax)
addq $0x10, %rax
jmp 0x1c9d
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
movq %rcx, 0x8(%rsp)
callq 0x1c65
movq 0x8(%rsp), %rax
leaq (%r15,%rax), %rsi
movq %r13, %rdi
movl %r12d, %edx
callq 0x1c65
movq 0x8(%rsp), %rax
leaq (%r15,%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rsp)
addq $0x8, %r15
leaq (%r14,%rax), %rbx
addq $0x8, %rbx
addq $0x8, %r14
xorl %ebp, %ebp
xorl %r13d, %r13d
cmpq %rbp, %rax
je 0x1da6
movl $0x800, %eax            # imm = 0x800
xorl %edx, %edx
divl 0x4(%rsp)
movl %eax, %r12d
movq %r13, %rax
shlq $0x4, %rax
leaq 0x338d(%rip), %rcx      # 0x50c0
movsd (%rax,%rcx), %xmm0
movsd 0x8(%rax,%rcx), %xmm1
movsd -0x8(%rbx,%rbp), %xmm2
movsd (%rbx,%rbp), %xmm3
callq 0x1ff3
movq 0x8(%rsp), %rax
movsd -0x8(%r14,%rbp), %xmm2
addsd %xmm0, %xmm2
movsd (%r14,%rbp), %xmm3
addsd %xmm1, %xmm3
movsd %xmm2, -0x8(%r15,%rbp)
movsd %xmm3, (%r15,%rbp)
movsd -0x8(%r14,%rbp), %xmm2
movsd (%r14,%rbp), %xmm3
subsd %xmm0, %xmm2
subsd %xmm1, %xmm3
movq 0x10(%rsp), %rcx
movsd %xmm2, -0x8(%rcx,%rbp)
movsd %xmm3, (%rcx,%rbp)
addq %r12, %r13
addq $0x10, %rbp
jmp 0x1d0e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0xa94(%rip), %rsi       # 0x316c
movq %rbx, %rdi
callq 0x2673
testq %rax, %rax
je 0x2714
movq %rax, %r14
leaq 0xa81(%rip), %rsi       # 0x3170
movq %rbx, %rdi
callq 0x2673
testq %rax, %rax
je 0x271d
cmpl $0x0, (%r14)
je 0x2707
cmpl $0x0, (%rax)
jne 0x272a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2662
pushq $0x2
jmp 0x2724
callq 0x2662
pushq $0x3
popq %rdi
callq 0x11a0
movslq 0x4(%rax), %rax
movq 0x8(%rbx,%rax,8), %rdi
callq 0x1170
movl %eax, %r15d
movslq 0x4(%r14), %rax
movq 0x8(%rbx,%rax,8), %rdi
callq 0x1170
movl %r15d, %edi
movl %eax, %esi
callq 0x232f
// File: /workspace/github_c_makefile_star2_O2/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 0x338b
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 0x7c66(%rip), %r15      # 0xaff8
movq (%r15), %rax
movl 0x10(%rdi), %edx
movl 0x14(%rdi), %ecx
leaq 0x3c7e(%rip), %rsi      # 0x7020
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_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movl %edi, %r14d
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
callq 0x36b3
cmpl $0x2, %r14d
jl 0x3549
movq 0x8(%rbx), %rax
cmpb $0x2d, (%rax)
jne 0x3549
cmpb $0x63, 0x1(%rax)
jne 0x349c
cmpb $0x0, 0x2(%rax)
je 0x34e7
cmpb $0x72, 0x1(%rax)
jne 0x34a8
cmpb $0x0, 0x2(%rax)
je 0x34f3
cmpb $0x74, 0x1(%rax)
jne 0x3549
cmpl $0x2, %r14d
je 0x3549
cmpb $0x0, 0x2(%rax)
jne 0x3549
movq 0x10(%rbx), %rdi
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x373c
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x1, %rcx
sbbl %eax, %eax
jmp 0x35b7
callq 0x36ec
xorl %eax, %eax
jmp 0x35b7
cmpl $0x2, %r14d
je 0x3549
addl $-0x2, %r14d
movq 0x7c2c(%rip), %r13      # 0xb130
xorl %r12d, %r12d
pushq $0x20
popq %r15
leaq 0x7c1e(%rip), %rbp      # 0xb130
cmpq %r12, %r14
je 0x3569
movq %r15, %rdi
callq 0x3180
movl $0x2, 0x10(%rax)
movq 0x10(%rbx,%r12,8), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x7bfa(%rip)      # 0xb130
movq %rbp, 0x8(%rax)
movq %r13, (%rax)
movq %rax, 0x8(%r13)
incq %r12
movq %rax, %r13
jmp 0x3512
movq 0x7aa8(%rip), %rax      # 0xaff8
movq (%rax), %rcx
leaq 0x3af1(%rip), %rdi      # 0x704b
pushq $0x27
popq %rsi
pushq $0x1
popq %rdx
callq 0x3210
pushq $0x1
jmp 0x35b6
leaq 0x8bc8(%rip), %rax      # 0xc138
movq 0x8(%rax), %rdx
leaq 0x3af8(%rip), %rdi      # 0x7073
leaq 0x7bbe(%rip), %rsi      # 0xb140
pushq $0x1
popq %rcx
callq 0x4e1c
movq 0x10(%rbx), %rdi
leaq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x373c
testq %rax, %rax
je 0x35b4
leaq 0x10(%rsp), %rdi
movq %rsp, %rdx
movq %rax, %rsi
callq 0x566c
shrl $0x1f, %eax
jmp 0x35b7
pushq $-0x1
popq %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
movq %r14, %rdi
callq 0x3725
andl $0x1f, %eax
leaq 0x8a2b(%rip), %rcx      # 0xc010
leaq (%rcx,%rax,8), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x3606
movq (%r15), %rdi
movq %r14, %rsi
callq 0x3110
testl %eax, %eax
je 0x362c
addq $0x20, %r15
jmp 0x35e9
movq %rbx, %rdi
callq 0x3f14
movl %eax, %ecx
pushq $0x1
popq %rax
testl %ecx, %ecx
jne 0x3637
movq (%rbx), %rdx
cmpb $0x23, (%rdx)
jne 0x363d
leaq 0x7b2a(%rip), %rcx      # 0xb150
movq %rcx, 0x8(%rbx)
jmp 0x3637
addq $0x8, %r15
movq %r15, 0x8(%rbx)
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3a34(%rip), %rsi      # 0x7078
movq %rbx, %rdi
xorl %eax, %eax
callq 0x332c
pushq $-0x1
jmp 0x3636
// File: /workspace/github_c_makefile_star2_O2/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 0x414d
callq 0x4600
callq 0x3acc
callq 0x4a84
callq 0x4fa1
callq 0x5164
callq 0x576a
callq 0x5989
callq 0x64da
callq 0x6c24
popq %rax
jmp 0x68c7
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rdi, %r15
pushq $0x38
popq %rdi
callq 0x3180
movq %rax, %rbx
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x31a0
testl %eax, %eax
js 0x3818
movl %eax, %r15d
movl $0x400, %edi            # imm = 0x400
callq 0x3180
xorl %r12d, %r12d
movq %rax, (%rbx)
addq %r12, %rax
movl $0x400, %edx            # imm = 0x400
movl %r15d, %edi
movq %rax, %rsi
callq 0x30e0
testl %eax, %eax
js 0x3829
je 0x37bf
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
leaq (%rax,%r12), %r13
movq (%rbx), %rdi
leaq (%rax,%r12), %rsi
addq $0x400, %rsi            # imm = 0x400
callq 0x3190
movq %r13, %r12
jmp 0x377e
movl %r15d, %edi
callq 0x30c0
movq (%rbx), %rax
movq %rax, 0x8(%rbx)
addq %rax, %r12
movq %r12, 0x10(%rbx)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x18(%rbx)
movb %bpl, 0x20(%rbx)
andq $0x0, 0x28(%rbx)
leaq 0x891d(%rip), %rax      # 0xc110
movq %rax, 0x8(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x386f
testl %eax, %eax
js 0x384f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x3030
leaq 0x3888(%rip), %rdi      # 0x70af
jmp 0x3848
movq (%rbx), %rdi
callq 0x3030
movq %rbx, %rdi
callq 0x3030
movl %r15d, %edi
callq 0x30c0
leaq 0x3877(%rip), %rdi      # 0x70bf
callq 0x31c0
jmp 0x386b
movq 0x77a2(%rip), %rax      # 0xaff8
movq (%rax), %rcx
leaq 0x383e(%rip), %rdi      # 0x709e
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
callq 0x3210
xorl %ebx, %ebx
jmp 0x3806
// File: /workspace/github_c_makefile_star2_O2/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 0x3ac6
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 0x3aac
andl $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)
pushq $0x1
popq %rax
retq
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x3e30
pushq $-0x1
popq %rbp
testl %eax, %eax
jle 0x3bcb
movl 0x20(%rsp), %eax
cmpl $0x1, %eax
je 0x3ba0
cmpl $0x2, %eax
je 0x3b3e
cmpl $0x3, %eax
jne 0x3bba
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rsi
addq $0x18, %rbx
movq %rbx, %rdx
callq 0x489c
movl %eax, %ebp
jmp 0x3bcb
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 0x3bb5
movl $0x1, 0x18(%rbx)
movq 0x50(%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x20(%rbx)
pushq $0x1
popq %rbp
jmp 0x3bcb
leaq 0x3566(%rip), %rsi      # 0x7127
movq %rbx, %rdi
xorl %eax, %eax
callq 0x332c
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_O2/xemul[P]cylang/aryth.c
// Function: eval_sub
static int eval_sub(struct cy_token *t, struct cy_file *f)
{
	struct cy_token a, b;

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

	if (a.v.t == CY_V_LIST) {
		if (cy_eval_next_x(f, &b, CY_V_NUMBER) <= 0)
			return -1;

		return cy_list_del(&a.v, &b.v);
	}

	if (a.v.t == CY_V_MAP) {
		if (cy_eval_next_x(f, &b, CY_V_STRING) <= 0)
			return -1;

		return cy_map_del(&a.v, &b.v);
	}

	if (a.v.t == CY_V_NUMBER) {
		if (cy_eval_next_x(f, &b, CY_V_NUMBER) <= 0)
			return -1;

		t->v.t = CY_V_NUMBER;
		t->v.v_i = a.v.v_i - b.v.v_i;
		return 1;
	}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r12
movq %rdi, %r14
leaq 0x28(%rsp), %rsi
movq %r12, %rdi
callq 0x3e67
pushq $-0x1
popq %rbx
testl %eax, %eax
jle 0x3ca1
movl 0x40(%rsp), %eax
cmpl $0x1, %eax
je 0x3c62
leaq 0x40(%rsp), %r15
cmpl $0x4, %eax
je 0x3c3f
cmpl $0x3, %eax
jne 0x3c90
movq %rsp, %rsi
pushq $0x1
popq %rdx
movq %r12, %rdi
callq 0x3ec6
testl %eax, %eax
jle 0x3ca1
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x4944
jmp 0x3c5e
movq %rsp, %rsi
pushq $0x2
popq %rdx
movq %r12, %rdi
callq 0x3ec6
testl %eax, %eax
jle 0x3ca1
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x4f71
movl %eax, %ebx
jmp 0x3ca1
movq %rsp, %rsi
pushq $0x1
popq %rbp
movq %r12, %rdi
movl %ebp, %edx
callq 0x3ec6
testl %eax, %eax
jle 0x3ca1
movl $0x1, 0x18(%r14)
movq 0x48(%rsp), %rax
subq 0x20(%rsp), %rax
movq %rax, 0x20(%r14)
movl %ebp, %ebx
jmp 0x3ca1
leaq 0x34d2(%rip), %rsi      # 0x7169
movq %r14, %rdi
xorl %eax, %eax
callq 0x332c
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3e30
pushq $-0x1
popq %rbp
testl %eax, %eax
jle 0x3d35
movl 0x20(%rsp), %edi
movl %edi, 0x18(%rbx)
cmpl $0x1, %edi
jne 0x3cf9
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rcx
cmpq $0x3, %rcx
jne 0x3d14
movq 0x50(%rsp), %rax
imulq 0x28(%rsp), %rax
jmp 0x3d2e
callq 0x33ef
leaq 0x3484(%rip), %rsi      # 0x7189
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x332c
jmp 0x3d35
movq 0x50(%rsp), %rsi
testq %rsi, %rsi
je 0x3d3e
movq 0x28(%rsp), %rax
cqto
idivq %rsi
cmpq $0x1, %rcx
jne 0x3d51
movq %rax, 0x20(%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3433(%rip), %rsi      # 0x7178
movq %rbx, %rdi
xorl %eax, %eax
callq 0x332c
jmp 0x3d35
movq %rdx, 0x20(%rbx)
jmp 0x3d32
// File: /workspace/github_c_makefile_star2_O2/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 0x3e30
pushq $-0x1
popq %rbx
testl %eax, %eax
jle 0x3dea
movl 0x20(%rsp), %edi
movl %edi, 0x18(%r14)
cmpl $0x6, %edi
jne 0x3daf
movq 0x8(%r14), %rax
movq 0x10(%rax), %rax
pushq $0x1
popq %rbx
cmpq $0x4, %rax
je 0x3ddd
cmpq $0x2, %rax
je 0x3dca
cmpq $0x1, %rax
jne 0x3dea
xorl %eax, %eax
cmpb $0x0, 0x28(%rsp)
jne 0x3dd3
jmp 0x3dd7
callq 0x33ef
leaq 0x33db(%rip), %rsi      # 0x7196
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x332c
jmp 0x3dea
cmpb $0x0, 0x28(%rsp)
movl %ebx, %eax
jne 0x3dd7
movl 0x50(%rsp), %eax
movb %al, 0x20(%r14)
jmp 0x3dea
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_O2/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 0x3a7d
testl %eax, %eax
js 0x3ea2
je 0x3e98
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x3e9a
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
movq 0x714f(%rip), %rax      # 0xaff8
movq (%rax), %rcx
leaq 0x3283(%rip), %rdi      # 0x7136
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
callq 0x3210
pushq $0x1
popq %rdi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/./cy.h
// Function: cy_eval_next_x
static inline int cy_eval_next_x(struct cy_file *f, struct cy_token *t, int want_type)
{
	int ret;

	ret = cy_eval_next(f, t);
	if (ret == 1 && t->v.t != want_type) {
		show_token_err(t, "Expected %s token, got %s",
				vtype2s(want_type), vtype2s(t->v.t));
		ret = -1;
	}

	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3a7d
testl %eax, %eax
js 0x54c8
je 0x548f
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x5480
movq %rbx, %rdi
movq %r14, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x54c0
cmpl $0x2, 0x18(%rbx)
jne 0x5493
pushq $0x1
jmp 0x54bf
xorl %eax, %eax
jmp 0x54c0
pushq $0x2
popq %rdi
callq 0x33ef
movq %rax, %r14
movl 0x18(%rbx), %edi
callq 0x33ef
leaq 0x1ca2(%rip), %rsi      # 0x714f
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x332c
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x5b29(%rip), %rax      # 0xaff8
movq (%rax), %rcx
leaq 0x1c5d(%rip), %rdi      # 0x7136
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
callq 0x3210
pushq $0x1
popq %rdi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O2/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)
movb (%rdi), %cl
movq %rdi, %rax
cmpb $0x2d, %cl
jne 0x3f37
leaq 0x1(%rdi), %rax
movq %rax, (%rsp)
movb 0x1(%rdi), %cl
cmpb $0x30, %cl
jne 0x3f4e
xorl %ecx, %ecx
cmpb $0x78, 0x1(%rax)
sete %cl
leal 0x8(,%rcx,8), %edx
jmp 0x3f51
pushq $0xa
popq %rdx
movq %rsp, %r14
movq %r14, %rsi
callq 0x3140
movq %rax, 0x20(%rbx)
movq (%r14), %rax
cmpb $0x0, (%rax)
je 0x3f93
movq (%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x27, %ecx
je 0x3f78
cmpl $0x22, %ecx
jne 0x3faa
leaq 0x73d1(%rip), %rcx      # 0xb350
movq %rcx, 0x8(%rbx)
movl $0x2, 0x18(%rbx)
incq %rax
movq %rax, 0x20(%rbx)
jmp 0x3fa5
leaq 0x73ce(%rip), %rax      # 0xb368
movq %rax, 0x8(%rbx)
movl $0x1, 0x18(%rbx)
pushq $0x1
popq %rax
jmp 0x3fbb
movq %rbx, %rdi
callq 0x3feb
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x4021
movzbl 0x1(%rax), %ecx
cmpl $0x5f, %ecx
je 0x408e
cmpl $0x2e, %ecx
je 0x4032
testl %ecx, %ecx
jne 0x4094
leaq 0x737c(%rip), %rax      # 0xb398
jmp 0x40bd
andb $-0x21, %cl
addb $-0x41, %cl
xorl %ebp, %ebp
cmpb $0x19, %cl
ja 0x40c4
pushq $0x1
popq %rcx
movzbl (%rax,%rcx), %edx
testl %edx, %edx
je 0x4070
cmpq $0x40, %rcx
jge 0x4079
leal -0x30(%rdx), %esi
cmpb $0xa, %sil
jb 0x4061
movl %edx, %esi
andb $-0x21, %sil
addb $-0x41, %sil
cmpb $0x1a, %sil
jb 0x4061
cmpl $0x5f, %edx
jne 0x4066
incq %rcx
jmp 0x4035
cmpl $0x2e, %edx
jne 0x40b2
addq %rcx, %rax
jmp 0x4032
leaq 0x7309(%rip), %rax      # 0xb380
jmp 0x40bd
leaq 0x3131(%rip), %rsi      # 0x71b1
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x332c
jmp 0x40c4
cmpb $0x0, 0x2(%rax)
je 0x40b6
movq %rbx, %rdi
callq 0x6470
testl %eax, %eax
jne 0x40c1
movq %rbx, %rdi
callq 0x6838
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
jmp 0x40c4
xorl %ebp, %ebp
jmp 0x40c4
leaq 0x72f3(%rip), %rax      # 0xb3b0
movq %rax, 0x8(%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3feb
pushq $-0x1
popq %rbx
testl %eax, %eax
je 0x4124
movq 0x10(%rsp), %rax
leaq 0x7283(%rip), %rcx      # 0xb380
cmpq %rcx, %rax
setne %cl
andb %bpl, %cl
cmpb $0x1, %cl
je 0x412f
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq *0x8(%rax)
testl %eax, %eax
js 0x4124
movups 0x20(%rsp), %xmm0
movups %xmm0, (%r14)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x6ec2(%rip), %rax      # 0xaff8
movq (%rax), %rcx
leaq 0x3081(%rip), %rdi      # 0x71c1
pushq $0x1e
popq %rsi
pushq $0x1
popq %rdx
callq 0x3210
jmp 0x4124
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0x3a7d
pushq $-0x1
popq %rbx
testl %eax, %eax
jle 0x43b0
leaq 0x6fe8(%rip), %rax      # 0xb380
cmpq %rax, 0x50(%rsp)
je 0x43c1
leaq 0x2eb5(%rip), %rsi      # 0x725b
movq %r14, %rdi
xorl %eax, %eax
callq 0x332c
movl %ebx, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
leaq 0x70(%rsp), %rcx
callq 0x418f
testl %eax, %eax
jle 0x43b0
cmpl $0x2, (%rsp)
jne 0x4450
cmpl $0x4, 0x10(%rsp)
jne 0x445c
movq 0x8(%r14), %rax
cmpq $0x0, 0x10(%rax)
je 0x4468
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x4ece
testq %rax, %rax
je 0x4468
movq %rax, %r12
movups 0x20(%rax), %xmm0
movups %xmm0, 0x7d10(%rip)     # 0xc128
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x45a1
testl %eax, %eax
jle 0x43b0
addq $0x20, %r12
andl $0x0, 0x7cf4(%rip)      # 0xc128
movups (%r12), %xmm0
movups %xmm0, 0x18(%r14)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%r12)
pushq $0x1
popq %rbx
jmp 0x43b0
leaq 0x2e1e(%rip), %rsi      # 0x7275
jmp 0x43a6
leaq 0x2e2b(%rip), %rsi      # 0x728e
jmp 0x43a6
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x45a1
testl %eax, %eax
jle 0x43b0
movq 0x8(%rsp), %rdi
callq 0x3220
leaq 0x38(%rsp), %rsi
movq 0x18(%rsp), %rdx
pushq $0x1
popq %rcx
movq %rax, %rdi
callq 0x4e1c
movl %eax, %ebx
sarl $0x1f, %ebx
orl $0x1, %ebx
jmp 0x43b0
// File: /workspace/github_c_makefile_star2_O2/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, %rdi
movq %rsp, %rsi
callq 0x45a1
cmpl $0x1, %eax
jne 0x44f7
cmpl $0x4, 0x18(%rsp)
je 0x44f9
pushq $0x4
popq %rdi
callq 0x33ef
movq %rax, %rbx
movq %rsp, %r14
movl 0x18(%r14), %edi
callq 0x33ef
leaq 0x2c6a(%rip), %rsi      # 0x714f
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x332c
jmp 0x4509
jl 0x4509
movups 0x18(%rsp), %xmm0
movups %xmm0, 0x7c33(%rip)     # 0xc138
pushq $0x1
jmp 0x450b
pushq $-0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x45a1
pushq $-0x1
popq %rbx
testl %eax, %eax
jle 0x4595
movq %rsp, %rsi
movq %r15, %rdi
callq 0x45a1
testl %eax, %eax
jle 0x4595
leaq 0x40(%rsp), %rsi
movl (%rsi), %edi
cmpl $0x4, %edi
je 0x4566
cmpl $0x3, %edi
jne 0x457c
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x49ac
jmp 0x4573
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x4f2a
testl %eax, %eax
jle 0x4595
pushq $0x1
popq %rbx
jmp 0x4595
callq 0x33ef
leaq 0x2c76(%rip), %rsi      # 0x71fe
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x332c
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rdi
movq %rsp, %rsi
callq 0x46ac
cmpl $0x1, %eax
jne 0x4691
cmpl $0x2, 0x18(%rsp)
je 0x4693
pushq $0x2
popq %rdi
callq 0x33ef
movq %rax, %rbx
movq %rsp, %r14
movl 0x18(%r14), %edi
callq 0x33ef
leaq 0x2ad0(%rip), %rsi      # 0x714f
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x332c
jmp 0x46a1
jl 0x46a1
movq 0x20(%rsp), %rdi
callq 0x3060
pushq $0x1
jmp 0x46a3
pushq $-0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl (%rdi), %eax
cmpq $0x6, %rax
ja 0x47fd
movl %esi, %ebx
leaq 0x2b7a(%rip), %rcx      # 0x72a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzbl %bl, %esi
leaq 0x2b9f(%rip), %rdi      # 0x72e0
jmp 0x4836
movq 0x8(%rdi), %r15
leaq 0x2bc7(%rip), %rdi      # 0x7318
xorl %eax, %eax
callq 0x30b0
movq %r15, %rdi
callq 0x6377
movq %rax, %r13
leaq 0x2bb1(%rip), %r15      # 0x731b
pushq $0x20
popq %r12
pushq $0x1
popq %rbp
testq %r13, %r13
je 0x487a
movq -0x8(%r13), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x30b0
leaq 0x18(%r13), %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x470b
testl %eax, %eax
jle 0x4869
movq %r13, %rdi
callq 0x63a7
movq %rax, %r13
jmp 0x4771
movq 0x8(%rdi), %rsi
movzbl %bl, %edx
leaq 0x2b36(%rip), %rdi      # 0x72f0
jmp 0x485f
movq 0x8(%rdi), %r12
leaq 0x2b47(%rip), %rdi      # 0x7311
xorl %eax, %eax
callq 0x30b0
pushq $0x20
popq %r15
pushq $0x1
popq %rbp
movq %r12, %r13
movq 0x8(%r13), %r13
cmpq %r12, %r13
je 0x4886
leaq 0x10(%r13), %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x470b
testl %eax, %eax
jg 0x47db
jmp 0x4869
movl %eax, %edi
callq 0x33ef
leaq 0x2ac7(%rip), %rsi      # 0x72d2
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x332c
pushq $-0x1
jmp 0x4868
movq 0x8(%rdi), %rsi
movzbl %bl, %edx
leaq 0x2ac0(%rip), %rdi      # 0x72ea
jmp 0x485f
movzbl %bl, %esi
leaq 0x2ad1(%rip), %rdi      # 0x7307
xorl %eax, %eax
callq 0x30b0
jmp 0x4866
leaq 0x2ab6(%rip), %rax      # 0x72fc
cmpb $0x0, 0x8(%rdi)
leaq 0x2ab0(%rip), %rsi      # 0x7301
cmovneq %rax, %rsi
movzbl %bl, %edx
leaq 0x2a98(%rip), %rdi      # 0x72f7
xorl %eax, %eax
callq 0x30b0
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl %bl, %esi
leaq 0x2a9b(%rip), %rdi      # 0x731f
jmp 0x4890
movzbl %bl, %esi
leaq 0x2a84(%rip), %rdi      # 0x7314
xorl %eax, %eax
callq 0x30b0
jmp 0x4869
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdx, %rdi
callq 0x48d5
movq 0x8(%r15), %rdi
movq 0x8(%rbx), %rsi
callq 0x48f4
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x48f4
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/list.c
// Function: copy_list
static void copy_list(struct list_head *from, struct list_head *to)
{
	struct cy_list_value *lf, *lt;

	list_for_each_entry(lf, from, l) {
		lt = malloc(sizeof(*lt));
		lt->v = lf->v;
		list_add_tail(&lt->l, to);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x20
popq %r15
movq %rdi, %r12
movq 0x8(%r12), %r12
cmpq %r14, %r12
je 0x4938
movq %r15, %rdi
callq 0x3180
movups 0x10(%r12), %xmm0
movups %xmm0, 0x10(%rax)
movq (%rbx), %rcx
movq %rax, (%rbx)
movq %rbx, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, 0x8(%rcx)
jmp 0x4909
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/list.c
// Function: cy_list_del
int cy_list_del(struct cy_value *l, struct cy_value *i)
{
	struct cy_list_value *lv;

	if (i->v_i < 0) {
		fprintf(stderr, "List removal should be by positive index\n");
		return -1;
	}

	lv = cy_list_find(l, i->v_i);
	if (lv) {
		list_del_init(&lv->l);
		return 1;
	}

	return -1;
}

// Assembly:
pushq %rax
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
js 0x4971
callq 0x4992
testq %rax, %rax
je 0x498d
movq (%rax), %rcx
movq 0x8(%rax), %rdx
movq %rcx, (%rdx)
movq %rdx, 0x8(%rcx)
movq %rax, 0x8(%rax)
movq %rax, (%rax)
pushq $0x1
jmp 0x498f
movq 0x6680(%rip), %rax      # 0xaff8
movq (%rax), %rcx
leaq 0x29a1(%rip), %rdi      # 0x7323
pushq $0x29
popq %rsi
pushq $0x1
popq %rdx
callq 0x3210
pushq $-0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/list.c
// Function: dereference_list_elem
int dereference_list_elem(struct cy_token *t, struct cy_value *l, struct cy_value *kv)
{
	struct cy_list_value *lv;
	int n;
	char *end;

	if (kv->t == CY_V_STRING) {
		n = strtol(kv->v_str, &end, 10);
		if (*end != '\0' || n < 0) {
			show_token_err(t, "Bad list index %s", kv->v_str);
			return -1;
		}
	} else if (kv->t == CY_V_NUMBER)
		n = kv->v_i;
	else {
		show_token_err(t, "Bad list deref %s", vtype2s(kv->t));
		return -1;
	}

	lv = cy_list_find(l, n);
	if (lv)
		t->v = lv->v;
	else
		t->v.t = CY_V_NOVALUE;

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdx), %edi
cmpl $0x1, %edi
je 0x4a04
cmpl $0x2, %edi
jne 0x4a22
movq 0x8(%r15), %rdi
movq %rsp, %r12
pushq $0xa
popq %rdx
movq %r12, %rsi
callq 0x3140
movq %rax, %rsi
movq (%r12), %rax
cmpb $0x0, (%rax)
setne %al
testl %esi, %esi
sets %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x4a08
movq 0x8(%r15), %rdx
leaq 0x294e(%rip), %rsi      # 0x734d
movq %rbx, %rdi
jmp 0x4a34
movl 0x8(%r15), %esi
movq %r14, %rdi
callq 0x4992
addq $0x18, %rbx
testq %rax, %rax
je 0x4a3f
movups 0x10(%rax), %xmm0
movups %xmm0, (%rbx)
jmp 0x4a42
callq 0x33ef
leaq 0x2931(%rip), %rsi      # 0x735f
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x332c
pushq $-0x1
jmp 0x4a44
andl $0x0, (%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/list.c
// Function: eval_list
static int eval_list(struct cy_token *t, struct cy_file *f)
{
	make_list(&t->v);
	list_depth++;
	while (1) {
		struct cy_token vt;
		struct cy_list_value *lv;

		if (cy_eval_next(f, &vt) <= 0) {
			list_depth--;
			return -1;
		}

		if (vt.v.t & CY_V_TERMINATOR) {
			list_depth--;
			if (vt.v.t == CY_V_LIST_END)
				return 1;
			else {
				show_token_err(&vt, "Unexpected terminator");
				return -1;
			}
		}

		lv = malloc(sizeof(*lv));
		lv->v = vt.v;
		list_add_tail(&lv->l, &t->v.v_list->h);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
callq 0x48d5
incl 0x7696(%rip)            # 0xc148
leaq 0x20(%rsp), %r13
leaq 0x8(%rsp), %r15
pushq $0x20
popq %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4d6d
testl %eax, %eax
jle 0x4b02
movl 0x20(%rsp), %eax
testl $0x70000000, %eax       # imm = 0x70000000
jne 0x4b0a
movq %r12, %rdi
callq 0x3180
movups (%r13), %xmm0
movups %xmm0, 0x10(%rax)
movq 0x20(%r14), %rcx
movq (%rcx), %rdx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
movq %rdx, (%rax)
movq %rax, 0x8(%rdx)
jmp 0x4ac0
decl 0x7640(%rip)            # 0xc148
jmp 0x4b2e
decl 0x7638(%rip)            # 0xc148
cmpl $0x70000003, %eax       # imm = 0x70000003
jne 0x4b1b
pushq $0x1
jmp 0x4b30
leaq 0x28dd(%rip), %rsi      # 0x73ff
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x332c
pushq $-0x1
popq %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/list.c
// Function: eval_list_cut
static int eval_list_cut(struct cy_token *t, struct cy_file *f)
{
	int i, from, to;
	struct cy_token lht, ct;
	struct cy_list_value *lv;

	if (cy_eval_next_x(f, &lht, CY_V_LIST) <= 0)
		return -1;

	if (cy_eval_next_x(f, &ct, CY_V_NUMBER) <= 0)
		return -1;

	if (t->typ->priv == OP_CUT_BOTH) {
		struct cy_token ct2;

		if (cy_eval_next_x(f, &ct2, CY_V_NUMBER) <= 0)
			return -1;

		from = ct.v.v_i;
		to = ct2.v.v_i;
	} else if (t->typ->priv == OP_CUT_HEAD) {
		from = ct.v.v_i;
		to = 0x7fffffff;
	} else {
		from = 0;
		to = ct.v.v_i;
	}

	make_list(&t->v);

	i = 0;
	list_for_each_entry(lv, &lht.v.v_list->h, l) {
		struct cy_list_value *nv;

		if (i < from) {
			i++;
			continue;
		}

		if (i >= to)
			break;

		nv = malloc(sizeof(*lv));
		nv->v = lv->v;
		list_add_tail(&nv->l, &t->v.v_list->h);
		i++;
	}

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rsi
pushq $0x3
popq %rdx
movq %r15, %rdi
callq 0x4dcc
pushq $-0x1
popq %r14
testl %eax, %eax
jle 0x4c66
movq %rsp, %rsi
pushq $0x1
popq %rdx
movq %r15, %rdi
callq 0x4dcc
testl %eax, %eax
jle 0x4c66
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
cmpq $0x1, %rax
je 0x4bf3
cmpq $0x3, %rax
jne 0x4c00
leaq 0x50(%rsp), %rsi
pushq $0x1
popq %rdx
movq %r15, %rdi
callq 0x4dcc
testl %eax, %eax
jle 0x4c66
movl 0x20(%rsp), %r15d
movl 0x70(%rsp), %r12d
jmp 0x4c08
movl 0x20(%rsp), %r15d
movl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
jmp 0x4c08
movl 0x20(%rsp), %r12d
xorl %r15d, %r15d
leaq 0x18(%rbx), %rdi
callq 0x48d5
xorl %r13d, %r13d
movq 0x48(%rsp), %rax
pushq $0x20
popq %r14
movq %rax, %rbp
movq 0x8(%rbp), %rbp
cmpq %rax, %rbp
je 0x4c62
cmpl %r15d, %r13d
jl 0x4c5d
cmpl %r12d, %r13d
jge 0x4c62
movq %r14, %rdi
callq 0x3180
movups 0x10(%rbp), %xmm0
movups %xmm0, 0x10(%rax)
movq 0x20(%rbx), %rcx
movq (%rcx), %rdx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
movq %rdx, (%rax)
movq %rax, 0x8(%rdx)
movq 0x48(%rsp), %rax
incl %r13d
jmp 0x4c20
pushq $0x1
popq %r14
movl %r14d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/list.c
// Function: eval_list_add
static int eval_list_add(struct cy_token *t, struct cy_file *f)
{
	struct cy_token lst, vt;
	struct cy_list_value *lv;

	if (cy_eval_next_x(f, &lst, CY_V_LIST) <= 0)
		return -1;

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

	lv = malloc(sizeof(*lv));
	lv->v = vt.v;

	if (t->typ->priv == OP_LIST_HEAD)
		list_add(&lv->l, &lst.v.v_list->h);
	else
		list_add_tail(&lv->l, &lst.v.v_list->h);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rsi
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x4dcc
pushq $-0x1
popq %rbp
testl %eax, %eax
jle 0x4cf8
movq %rsp, %rsi
movq %r14, %rdi
callq 0x4d6d
testl %eax, %eax
jle 0x4cf8
pushq $0x20
popq %rdi
callq 0x3180
movups 0x18(%rsp), %xmm0
movups %xmm0, 0x10(%rax)
movq 0x8(%rbx), %rcx
cmpq $0x1, 0x10(%rcx)
movq 0x48(%rsp), %rdx
jne 0x4ce1
leaq 0x8(%rdx), %rcx
movq 0x8(%rdx), %rsi
movq %rax, (%rsi)
movq %rsi, 0x8(%rax)
movq %rdx, (%rax)
jmp 0x4cf2
movq (%rdx), %rcx
movq %rax, (%rdx)
movq %rdx, 0x8(%rax)
movq %rcx, (%rax)
addq $0x8, %rcx
movq %rax, (%rcx)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/list.c
// Function: eval_list_pop
static int eval_list_pop(struct cy_token *t, struct cy_file *f)
{
	struct cy_token lst;
	struct cy_list_value *lv;

	if (cy_eval_next_x(f, &lst, CY_V_LIST) <= 0)
		return -1;

	if (list_empty(&lst.v.v_list->h)) {
		t->v.t = CY_V_NOVALUE;
		return 1;
	}

	if (t->typ->priv == OP_LIST_HEAD)
		lv = list_entry(lst.v.v_list->h.next, struct cy_list_value, l);
	else
		lv = list_entry(lst.v.v_list->h.prev, struct cy_list_value, l);

	list_del_init(&lv->l);
	t->v = lv->v;
	free(lv);

	return 1;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
pushq $0x3
popq %rdx
movq %rax, %rdi
callq 0x4dcc
testl %eax, %eax
jle 0x4d5c
movq 0x28(%rsp), %rax
cmpq %rax, 0x8(%rax)
je 0x4d60
movq 0x8(%rbx), %rcx
xorl %edx, %edx
cmpq $0x1, 0x10(%rcx)
sete %dl
movq (%rax,%rdx,8), %rdi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
movups 0x10(%rdi), %xmm0
movups %xmm0, 0x18(%rbx)
callq 0x3030
jmp 0x4d64
pushq $-0x1
jmp 0x4d66
andl $0x0, 0x18(%rbx)
pushq $0x1
popq %rax
addq $0x30, %rsp
popq %rbx
retq