LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movl 0x6f06(%rip), %eax      # 0x90b0
andl $0x80, %eax
cmpl $0x0, %eax
je 0x22c9
movl 0x6ef6(%rip), %eax      # 0x90b4
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
movsd 0xe73(%rip), %xmm0      # 0x3040
callq 0x10e0
movsd %xmm0, 0x30(%rsp)
movl 0x6eda(%rip), %eax      # 0x90b8
subl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x2c(%rsp)
movl 0x6ebd(%rip), %eax      # 0x90b0
andl $0x8, %eax
cmpl $0x0, %eax
je 0x2218
movl 0x2c(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x6ec4(%rip), %rax      # 0x90d0
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rsp)
jmp 0x222e
movslq 0x2c(%rsp), %rcx
leaq 0x6eac(%rip), %rax      # 0x90d0
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0xe11(%rip), %xmm1      # 0x3058
subsd %xmm1, %xmm0
movsd 0x30(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x6e45(%rip), %eax      # 0x90b8
jge 0x22c7
movslq 0x14(%rsp), %rcx
leaq 0x6e4f(%rip), %rax      # 0x90d0
movsd (%rax,%rcx,8), %xmm0
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x30(%rsp), %xmm0
callq 0x28d0
divsd 0x30(%rsp), %xmm0
movslq 0x14(%rsp), %rcx
leaq 0x6e1b(%rip), %rax      # 0x90d0
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2269
jmp 0x22c9
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkshape.C
// Function: compute_ht()
static void compute_ht() /* Hilbert Transformer */
{
  int h = (numcoeffs - 1) / 2;
  xcoeffs[h] = 0.0;
  for (int i = 1; i <= h; i++) {
    double x = (i & 1) ? (1.0 / (double)i) : 0.0;
    xcoeffs[h + i] = -x;
    xcoeffs[h - i] = +x;
  }
}

// Assembly:
movl 0x6de2(%rip), %eax      # 0x90b8
subl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rsp)
movslq -0x4(%rsp), %rcx
leaq 0x6ddf(%rip), %rax      # 0x90d0
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl $0x1, -0x8(%rsp)
movl -0x8(%rsp), %eax
cmpl -0x4(%rsp), %eax
jg 0x23ad
movl -0x8(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2335
cvtsi2sdl -0x8(%rsp), %xmm1
movsd 0xd2f(%rip), %xmm0      # 0x3058
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rsp)
jmp 0x2340
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rsp)
jmp 0x2340
movsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x10(%rsp)
movsd -0x10(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movl -0x4(%rsp), %eax
addl -0x8(%rsp), %eax
movslq %eax, %rcx
leaq 0x6d55(%rip), %rax      # 0x90d0
movsd %xmm0, (%rax,%rcx,8)
movsd -0x10(%rsp), %xmm0
movl -0x4(%rsp), %eax
subl -0x8(%rsp), %eax
movslq %eax, %rcx
leaq 0x6d38(%rip), %rax      # 0x90d0
movsd %xmm0, (%rax,%rcx,8)
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x2301
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x10a1(%rip), %rsi      # 0x4212
callq 0x30a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x318f
callq 0x3080
movl $0x2, %edi
callq 0x11c0
movq -0x10(%rbp), %rdi
leaq 0x107c(%rip), %rsi      # 0x4216
callq 0x30a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x31b8
callq 0x3080
movl $0x3, %edi
callq 0x11c0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x320b
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x320b
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1190
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1190
movl -0x24(%rbp), %edi
movl %eax, %esi
callq 0x2bb0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x3348
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xbc85(%rip), %rax      # 0xeff8
movq %rax, -0xf0(%rbp)
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
movl 0x14(%rax), %ecx
leaq 0x7c76(%rip), %rsi      # 0xb004
xorl %eax, %eax
movb %al, -0xe1(%rbp)
callq 0x3110
movq -0xf0(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, -0x20(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x31c0
movq -0xf0(%rbp), %rcx
movb -0xe1(%rbp), %al
movq (%rcx), %rdi
leaq 0x7c74(%rip), %rsi      # 0xb05e
callq 0x3110
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/cyvm.c
// Function: vtype2s
char *vtype2s(unsigned int t)
{
	switch (t) {
	case CY_V_NUMBER:
		return "interer";
	case CY_V_STRING:
		return "string";
	case CY_V_LIST:
		return "list";
	case CY_V_MAP:
		return "map";
	case CY_V_BOOL:
		return "bool";
	case CY_V_CBLOCK:
		return "cblock";
	case CY_V_NOVALUE:
		return "novalue";
	case CY_V_CBLOCK_END:
	case CY_V_LIST_END:
	case CY_V_MAP_END:
		return "terminator";
	default:
		return "unknown";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x34b0
jmp 0x3417
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x3462
jmp 0x3421
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x346f
jmp 0x342b
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0x347c
jmp 0x3435
movl -0x10(%rbp), %eax
subl $0x4, %eax
je 0x3489
jmp 0x343f
movl -0x10(%rbp), %eax
subl $0x5, %eax
je 0x34a3
jmp 0x3449
movl -0x10(%rbp), %eax
subl $0x6, %eax
je 0x3496
jmp 0x3453
movl -0x10(%rbp), %eax
addl $0x8ffffffd, %eax       # imm = 0x8FFFFFFD
subl $0x3, %eax
jb 0x34bd
jmp 0x34ca
leaq 0x7baa(%rip), %rax      # 0xb013
movq %rax, -0x8(%rbp)
jmp 0x34d5
leaq 0x7fc4(%rip), %rax      # 0xb43a
movq %rax, -0x8(%rbp)
jmp 0x34d5
leaq 0x7efb(%rip), %rax      # 0xb37e
movq %rax, -0x8(%rbp)
jmp 0x34d5
leaq 0x7fce(%rip), %rax      # 0xb45e
movq %rax, -0x8(%rbp)
jmp 0x34d5
leaq 0x7b7e(%rip), %rax      # 0xb01b
movq %rax, -0x8(%rbp)
jmp 0x34d5
leaq 0x7b76(%rip), %rax      # 0xb020
movq %rax, -0x8(%rbp)
jmp 0x34d5
leaq 0x8142(%rip), %rax      # 0xb5f9
movq %rax, -0x8(%rbp)
jmp 0x34d5
leaq 0x7f36(%rip), %rax      # 0xb3fa
movq %rax, -0x8(%rbp)
jmp 0x34d5
leaq 0x7b56(%rip), %rax      # 0xb027
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30b0
callq 0x3960
cmpl $0x2, -0x8(%rbp)
jge 0x351a
jmp 0x3629
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x7b06(%rip), %rsi      # 0xb02f
callq 0x3100
cmpl $0x0, %eax
jne 0x3544
callq 0x39a0
movl $0x0, -0x4(%rbp)
jmp 0x3648
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x7adf(%rip), %rsi      # 0xb032
callq 0x3100
cmpl $0x0, %eax
jne 0x35d3
cmpl $0x3, -0x8(%rbp)
jge 0x3568
jmp 0x3629
movl -0x8(%rbp), %edi
subl $0x2, %edi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3660
movq -0x18(%rbp), %rdi
callq 0x36f0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x48(%rbp), %rsi
xorl %edx, %edx
callq 0x3a50
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x35ae
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3648
movq -0x20(%rbp), %rsi
leaq -0x48(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x7620
movl %eax, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovgel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x3648
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x7a53(%rip), %rsi      # 0xb035
callq 0x3100
cmpl $0x0, %eax
jne 0x3627
cmpl $0x3, -0x8(%rbp)
jge 0x35f4
jmp 0x3629
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x48(%rbp), %rsi
movl $0x1, %edx
callq 0x3a50
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x361e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3648
movl $0x0, -0x4(%rbp)
jmp 0x3648
jmp 0x3629
movq 0xb9c8(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x79fe(%rip), %rsi      # 0xb038
movb $0x0, %al
callq 0x3110
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/cyvm.c
// Function: init_args
static void init_args(int argc, char **argv)
{
	int i;

	for (i = 0; i < argc; i++) {
		struct cy_list_value *lv;

		lv = malloc(sizeof(*lv));
		lv->v.t = CY_V_STRING;
		lv->v.v_str = argv[i];
		list_add_tail(&lv->l, &args_list.h);
	}

	map_add_value("Args", &args, &symbols.v_map->r, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x36c6
movl $0x20, %edi
callq 0x3170
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x2, 0x10(%rax)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rdi
leaq 0xba6a(%rip), %rsi      # 0xf120
callq 0x3700
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3676
leaq 0xcabb(%rip), %rax      # 0x10188
movq 0x8(%rax), %rdx
leaq 0x7988(%rip), %rdi      # 0xb060
leaq 0xba51(%rip), %rsi      # 0xf130
movl $0x1, %ecx
callq 0x65f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3800
cmpl $0x0, %eax
je 0x3793
movl $0x1, -0x4(%rbp)
jmp 0x37f1
movq -0x10(%rbp), %rdi
callq 0x4930
cmpl $0x0, %eax
je 0x37aa
movl $0x1, -0x4(%rbp)
jmp 0x37f1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x37d1
movq -0x10(%rbp), %rax
leaq 0xb97c(%rip), %rcx      # 0xf140
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x37f1
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x7882(%rip), %rsi      # 0xb065
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/resolver.c
// Function: try_resolve_command
static int try_resolve_command(struct cy_token *t)
{
	unsigned int hv;
	struct cy_command *cmd;

	hv = strhash(t->val) & CY_CMD_HASH_MASK;
	for (cmd = cmd_hash[hv]; cmd != NULL; cmd = cmd->n)
		if (strcmp(cmd->name, t->val) == 0) {
			t->typ = &cmd->t;
			return 1;
		}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x39f0
andl $0x1f, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0xc836(%rip), %rax      # 0x10060
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x387a
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x3100
cmpl $0x0, %eax
jne 0x386a
movq -0x20(%rbp), %rcx
addq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x3881
jmp 0x386c
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3832
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/resolver.c
// Function: add_command
static void add_command(struct cy_command *cmd)
{
	unsigned int hv;

	hv = strhash(cmd->name) & CY_CMD_HASH_MASK;
	cmd->n = cmd_hash[hv];
	cmd_hash[hv] = cmd;
	cmd->l = NULL;

	*last = cmd;
	last = &cmd->l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x39f0
andl $0x1f, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xc756(%rip), %rax      # 0x10060
movq (%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xc73a(%rip), %rax      # 0x10060
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rcx
movq 0xb817(%rip), %rax      # 0xf158
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, 0xb805(%rip)      # 0xf158
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
callq 0x4e10
callq 0x55f0
callq 0x4280
callq 0x5eb0
callq 0x6950
callq 0x6cf0
callq 0x7790
callq 0x7b60
callq 0x9370
callq 0xa0a0
callq 0x9ac0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/resolver.c
// Function: strhash
static unsigned int strhash(const char *val)
{
	unsigned int ret = 0, s = 0;

	while (1) {
		unsigned int uv;

		if (*val == '\0')
			return ret;
		uv = *val;
		ret += uv << s;
		val++;
		s++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3a17
movl -0xc(%rbp), %eax
popq %rbp
retq
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0x10(%rbp), %ecx
shll %cl, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3a06
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b00
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3a85
movq $0x0, -0x8(%rbp)
jmp 0x3aed
movb -0x19(%rbp), %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
leaq 0xc6b7(%rip), %rcx      # 0x10160
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3c60
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x3ae5
movq 0xb52e(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x75b7(%rip), %rsi      # 0xb08b
movb $0x0, %al
callq 0x3110
movq $0x0, -0x8(%rbp)
jmp 0x3aed
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/tokenizer.c
// Function: cy_read
static struct cy_file *cy_read(const char *filename)
{
	int fd, ret;
	unsigned long len;
	struct cy_file *cf;

	cf = malloc(sizeof(*cf));

	fd = open(filename, O_RDONLY);
	if (fd < 0) {
		free(cf);
		perror("Can't open file");
		return NULL;
	}

	cf->buf = malloc(CY_BUF_SIZE);
	len = 0;

	while (1) {
		ret = read(fd, cf->buf + len, CY_BUF_SIZE);
		if (ret < 0) {
			free(cf->buf);
			free(cf);
			close(fd);
			perror("Can't read file");
			return NULL;
		}

		if (ret == 0) {
			close(fd);
			cf->cur = cf->buf;
			cf->end = cf->buf + len;
			cf->ln = 1;
			cf->tn = 1;
			return cf;
		}

		len += ret;
		cf->buf = realloc(cf->buf, len + CY_BUF_SIZE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x38, %edi
callq 0x3170
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x3190
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x3b52
movq -0x28(%rbp), %rdi
callq 0x3030
leaq 0x755c(%rip), %rdi      # 0xb09c
callq 0x31b0
movq $0x0, -0x8(%rbp)
jmp 0x3c47
movl $0x400, %edi            # imm = 0x400
callq 0x3170
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x20(%rbp)
movl -0x14(%rbp), %edi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
addq -0x20(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x30d0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x3bc5
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x28(%rbp), %rdi
callq 0x3030
movl -0x14(%rbp), %edi
callq 0x30c0
leaq 0x74f9(%rip), %rdi      # 0xb0ac
callq 0x31b0
movq $0x0, -0x8(%rbp)
jmp 0x3c47
cmpl $0x0, -0x18(%rbp)
jne 0x3c15
movl -0x14(%rbp), %edi
callq 0x30c0
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
addq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x28(%rbp), %rax
movl $0x1, 0x1c(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3c47
movslq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x400, %rsi            # imm = 0x400
callq 0x3180
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3b6e
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/tokenizer.c
// Function: read_cblocks
static int read_cblocks(struct cy_token *t, struct cy_file *f)
{
	int ret;

	t->v.t = CY_V_CBLOCK;
	t->v.v_cblk = malloc(sizeof(struct cy_cblock));
	INIT_LIST_HEAD(&t->v.v_cblk->h);

	while (1) {
		struct cy_ctoken *cb;

		cb = malloc(sizeof(*cb));

		ret = cy_read_next_token(f, &cb->t);
		if (ret <= 0) {
			free(cb);
			return ret;
		}

		if (cb->t.typ->priv == OP_CBLOCK || cb->t.typ->priv == OP_CBLOCK_SHORT) {
			ret = read_cblocks(&cb->t, f);
			if (ret <= 0) {
				free(cb);
				return ret;
			}
		} else if (cb->t.typ->priv == OP_CBLOCK_END) {
			free(cb);
			return 1;
		} else if (cb->t.typ->priv == OP_COMMENT) {
			free(cb);
			continue;
		}

		list_add_tail(&cb->l, &t->v.v_cblk->h);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x5, 0x18(%rax)
movl $0x10, %edi
callq 0x3170
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3ef0
movl $0x38, %edi
callq 0x3170
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x10, %rsi
callq 0x3f20
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x3cd9
movq -0x28(%rbp), %rdi
callq 0x3030
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3d88
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x70000001, 0x10(%rax) # imm = 0x70000001
je 0x3cfd
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x70000005, 0x10(%rax) # imm = 0x70000005
jne 0x3d2a
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x3c60
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x3d28
movq -0x28(%rbp), %rdi
callq 0x3030
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3d88
jmp 0x3d72
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x70000002, 0x10(%rax) # imm = 0x70000002
jne 0x3d4e
movq -0x28(%rbp), %rdi
callq 0x3030
movl $0x1, -0x4(%rbp)
jmp 0x3d88
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x7fffffff, 0x10(%rax) # imm = 0x7FFFFFFF
jne 0x3d6e
movq -0x28(%rbp), %rdi
callq 0x3030
jmp 0x3c9d
jmp 0x3d70
jmp 0x3d72
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x3f60
jmp 0x3c9d
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/tokenizer.c
// Function: init_tokenizer
void init_tokenizer(struct cy_file *f, struct cy_cblock *blks)
{
	f->main = blks;
	if (!list_empty(&f->main->h))
		f->nxt = list_first_entry(&f->main->h, struct cy_ctoken, l);
	else
		f->nxt = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3e10
cmpl $0x0, %eax
jne 0x3df4
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x3e00
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x3e57
movl $0x0, -0x4(%rbp)
jmp 0x3edd
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
addq $0x10, %rsi
movl $0x28, %edx
callq 0x3140
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x3e8b
movq -0x18(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
cmpq %rcx, %rax
jne 0x3eba
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
jmp 0x3ed6
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/tokenizer.c
// Function: cy_read_next_token
static inline int cy_read_next_token(struct cy_file *cf, struct cy_token *t)
{
	int ret;

	ret = cy_advance(cf, t);
	if (ret == 1)
		ret = cy_resolve(t);

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3f90
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x3f52
movq -0x10(%rbp), %rdi
callq 0x3770
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x4760
cmpl $0x0, %eax
jg 0x42d2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x436f
cmpl $0x3, -0x28(%rbp)
jne 0x42fa
leaq -0x40(%rbp), %rdi
addq $0x18, %rdi
leaq -0x68(%rbp), %rsi
addq $0x18, %rsi
movq -0x10(%rbp), %rdx
addq $0x18, %rdx
callq 0x5aa0
movl %eax, -0x4(%rbp)
jmp 0x436f
cmpl $0x1, -0x28(%rbp)
jne 0x4324
movq -0x10(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x20(%rbp), %rcx
addq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x436f
cmpl $0x2, -0x28(%rbp)
jne 0x4356
movq -0x10(%rbp), %rax
movl $0x2, 0x18(%rax)
movq -0x20(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x47b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x436f
movq -0x10(%rbp), %rdi
leaq 0x6db3(%rip), %rsi      # 0xb114
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4830
cmpl $0x0, %eax
jg 0x43ae
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4497
cmpl $0x3, -0x28(%rbp)
jne 0x43f4
movq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x1, %edx
callq 0x48b0
cmpl $0x0, %eax
jg 0x43d7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4497
leaq -0x40(%rbp), %rdi
addq $0x18, %rdi
leaq -0x68(%rbp), %rsi
addq $0x18, %rsi
callq 0x5bd0
movl %eax, -0x4(%rbp)
jmp 0x4497
cmpl $0x4, -0x28(%rbp)
jne 0x4434
movq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x2, %edx
callq 0x48b0
cmpl $0x0, %eax
jg 0x441a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4497
leaq -0x40(%rbp), %rdi
addq $0x18, %rdi
leaq -0x68(%rbp), %rsi
addq $0x18, %rsi
callq 0x68e0
movl %eax, -0x4(%rbp)
jmp 0x4497
cmpl $0x1, -0x28(%rbp)
jne 0x447e
movq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x1, %edx
callq 0x48b0
cmpl $0x0, %eax
jg 0x445a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4497
movq -0x10(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x20(%rbp), %rcx
subq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4497
movq -0x10(%rbp), %rdi
leaq 0x6ccd(%rip), %rsi      # 0xb156
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x4760
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x44d9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x45a6
movl -0x30(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x30(%rbp), %eax
subl $0x1, %eax
jne 0x4571
jmp 0x44f1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x3, 0x10(%rax)
jne 0x4513
movq -0x28(%rbp), %rcx
imulq -0x50(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x456f
cmpq $0x0, -0x50(%rbp)
jne 0x4535
movq -0x10(%rbp), %rdi
leaq 0x6c40(%rip), %rsi      # 0xb165
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x45a6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x1, 0x10(%rax)
jne 0x455b
movq -0x28(%rbp), %rax
cqto
idivq -0x50(%rbp)
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x456d
movq -0x28(%rbp), %rax
cqto
idivq -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rdx, 0x20(%rax)
jmp 0x456f
jmp 0x459f
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x30(%rbp), %edi
callq 0x3400
movq -0x78(%rbp), %rdi
movq %rax, %rdx
leaq 0x6be7(%rip), %rsi      # 0xb176
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x45a6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x4760
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x45f9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x46e5
movl -0x30(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
subl $0x6, %eax
jne 0x46aa
jmp 0x4615
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x78(%rbp)
subq $0x1, %rax
je 0x4645
jmp 0x462d
movq -0x78(%rbp), %rax
subq $0x2, %rax
je 0x4665
jmp 0x4639
movq -0x78(%rbp), %rax
subq $0x4, %rax
je 0x4685
jmp 0x46a8
xorl %eax, %eax
testb $0x1, -0x28(%rbp)
movb %al, -0x79(%rbp)
je 0x4656
movb -0x50(%rbp), %al
movb %al, -0x79(%rbp)
movb -0x79(%rbp), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
jmp 0x46a8
movb $0x1, %al
testb $0x1, -0x28(%rbp)
movb %al, -0x7a(%rbp)
jne 0x4676
movb -0x50(%rbp), %al
movb %al, -0x7a(%rbp)
movb -0x7a(%rbp), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
jmp 0x46a8
movb -0x28(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x50(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
setne %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
jmp 0x46de
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0x30(%rbp), %edi
callq 0x3400
movq -0x88(%rbp), %rdi
movq %rax, %rdx
leaq 0x6ab5(%rip), %rsi      # 0xb183
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x46e5
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x6, %edx
callq 0x48b0
cmpl $0x0, %eax
jg 0x4730
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4752
movq -0x10(%rbp), %rax
movl $0x6, 0x18(%rax)
movb -0x20(%rbp), %cl
xorb $-0x1, %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/aryth.c
// Function: xstrcat
static char *xstrcat(const char *s1, const char *s2)
{
	int l1, l2;
	char *ret;

	l1 = strlen(s1);
	l2 = strlen(s2);
	ret = malloc(l1 + l2 + 1);
	memcpy(ret, s1, l1);
	memcpy(ret + l1, s2, l2 + 1);

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3080
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3080
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x3170
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x3140
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x3140
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3e30
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x4878
movq 0xa79b(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x68bc(%rip), %rsi      # 0xb123
movb $0x0, %al
callq 0x3110
movl $0x1, %edi
callq 0x31f0
cmpl $0x0, -0x14(%rbp)
jle 0x48a6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x48a6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq *%rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4830
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
jne 0x4925
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
je 0x4925
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edi
callq 0x3400
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x3400
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq %rax, %rcx
leaq 0x6825(%rip), %rsi      # 0xb13c
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49d0
cmpl $0x0, %eax
je 0x4953
movl $0x1, -0x4(%rbp)
jmp 0x49c5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0x4971
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
jne 0x49a7
movq -0x10(%rbp), %rax
leaq 0xa9c4(%rip), %rcx      # 0xf340
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x2, 0x18(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x49c5
movq -0x10(%rbp), %rdi
callq 0x4b00
cmpl $0x0, %eax
je 0x49be
movl $0x1, -0x4(%rbp)
jmp 0x49c5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/syms.c
// Function: try_resolve_number
static int try_resolve_number(struct cy_token *t)
{
	const char *aux = t->val;
	int base = 0;

	if (aux[0] == '-')
		aux++;

	if (aux[0] == '0') {
		if (aux[1] == 'x') {
			base = 16;
		} else {
			base = 8;
		}
	} else {
		base = 10;
	}

	t->v.v_i = strtol(t->val, (char **)&aux, base);
	if (*aux != '\0')
		return 0;

	t->typ = &cy_number;
	t->v.t = CY_V_NUMBER;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x4a06
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x4a31
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x78, %eax
jne 0x4a28
movl $0x10, -0x1c(%rbp)
jmp 0x4a2f
movl $0x8, -0x1c(%rbp)
jmp 0x4a38
movl $0xa, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %edx
leaq -0x18(%rbp), %rsi
callq 0x3130
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x4a6b
movl $0x0, -0x4(%rbp)
jmp 0x4a8c
movq -0x10(%rbp), %rax
leaq 0xa8e2(%rip), %rcx      # 0xf358
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x18(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4b00
cmpl $0x0, %eax
jne 0x4d96
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4e01
testb $0x1, -0x19(%rbp)
je 0x4dca
leaq -0x48(%rbp), %rdi
callq 0x4ae0
testb $0x1, %al
jne 0x4dca
movq 0xa248(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x63f4(%rip), %rsi      # 0xb1ae
movb $0x0, %al
callq 0x3110
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4e01
movq -0x40(%rbp), %rax
leaq -0x48(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *0x8(%rax)
cmpl $0x0, %eax
jge 0x4de7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4e01
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/declare.c
// Function: nest_get_key
static char *nest_get_key(const char *val, struct cy_value *kv, char *buf)
{
	char *end;
	bool sym = false;

	if (*val == '.') {
		val++;
		sym = true;
	}

	end = strchrnul(val, '.');
	if (*end == '.') {
		strncpy(buf, val, end - val);
		buf[end - val] = '\0';
		val = buf;
		end++;
	}

	if (sym) {
		if (try_deref_symbol(val, kv, true) < 0)
			return NULL;
	} else {
		kv->t = CY_V_STRING;
		kv->v_str = val;
	}

	return end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x50d4
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movb $0x1, -0x29(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x3070
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x5131
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
callq 0x3040
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rdx
subq %rdx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
testb $0x1, -0x29(%rbp)
je 0x515a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x4d60
cmpl $0x0, %eax
jge 0x5158
movq $0x0, -0x8(%rbp)
jmp 0x5178
jmp 0x5170
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x4, %edx
callq 0x5570
cmpl $0x0, %eax
jg 0x53d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x53ed
movq -0x28(%rbp), %rax
movq %rax, 0xadad(%rip)      # 0x10188
movq -0x20(%rbp), %rax
movq %rax, 0xadaa(%rip)      # 0x10190
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x54f0
cmpl $0x0, %eax
jg 0x5431
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x54e4
movq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x54f0
cmpl $0x0, %eax
jg 0x544f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x54e4
movl -0x28(%rbp), %eax
movl %eax, -0x70(%rbp)
subl $0x3, %eax
je 0x5466
jmp 0x545c
movl -0x70(%rbp), %eax
subl $0x4, %eax
je 0x5484
jmp 0x54a2
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
addq $0x18, %rsi
leaq -0x68(%rbp), %rdx
addq $0x18, %rdx
callq 0x5d10
movl %eax, -0x6c(%rbp)
jmp 0x54ce
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
addq $0x18, %rsi
leaq -0x68(%rbp), %rdx
addq $0x18, %rdx
callq 0x6850
movl %eax, -0x6c(%rbp)
jmp 0x54ce
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x28(%rbp), %edi
callq 0x3400
movq -0x78(%rbp), %rdi
movq %rax, %rdx
leaq 0x5d2b(%rip), %rsi      # 0xb1eb
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x6c(%rbp) # imm = 0xFFFFFFFF
cmpl $0x0, -0x6c(%rbp)
jg 0x54dd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x54e4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x2, %edx
callq 0x5a20
cmpl $0x0, %eax
jg 0x5690
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x56a9
movq -0x20(%rbp), %rsi
leaq 0x5c74(%rip), %rdi      # 0xb30f
movb $0x0, %al
callq 0x30a0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)