LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/adsr[P]phpspy/pgrep.c
// Function: wait_for_turn
static int wait_for_turn(char producer_or_consumer) {
    struct timespec timeout;
    pthread_mutex_lock(&mutex);
    while (!done) {
        if (producer_or_consumer == 'p' && avail_pids_count < opt_num_workers) {
            break;
        } else if (avail_pids_count > 0) {
            break;
        }
        clock_gettime(CLOCK_REALTIME, &timeout);
        timeout.tv_sec += 2;
        pthread_cond_timedwait(
            producer_or_consumer == 'p' ? &can_produce : &can_consume,
            &mutex,
            &timeout
        );
    }
    if (done) {
        pthread_mutex_unlock(&mutex);
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
leaq 0xf5ee(%rip), %r14      # 0x26200
movq %r14, %rdi
callq 0x6620
leaq 0xf4f3(%rip), %r13      # 0x26114
leaq 0x8(%rsp), %r15
leaq 0xf573(%rip), %rbp      # 0x261a0
cmpl $0x0, (%r13)
jne 0x16c80
movl 0xf556(%rip), %ecx      # 0x26190
cmpb $0x70, %bl
jne 0x16c59
xorl %eax, %eax
testl %ecx, %ecx
jg 0x16c93
leaq 0xf584(%rip), %r12      # 0x261d0
leaq 0xe6e1(%rip), %rdx      # 0x25334
cmpl (%rdx), %ecx
jge 0x16c60
jmp 0x16c93
movq %rbp, %r12
testl %ecx, %ecx
jg 0x16c91
xorl %edi, %edi
movq %r15, %rsi
callq 0x6110
addq $0x2, 0x8(%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x64a0
jmp 0x16c2d
leaq 0xf579(%rip), %rdi      # 0x26200
callq 0x63d0
pushq $0x1
popq %rax
jmp 0x16c93
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/adsr[P]phpspy/top.c
// Function: func_list_compare
static int func_list_compare(const void *a, const void *b) {
    func_entry_t *fa, *fb;
    fa = *((func_entry_t**)a);
    fb = *((func_entry_t**)b);
    if (fb->count_excl == fa->count_excl) {
        if (fb->count_incl == fa->count_incl) {
            if (fb->total_count_excl == fa->total_count_excl) {
                if (fb->total_count_incl == fa->total_count_incl) {
                    return 0;
                }
                return fb->total_count_incl > fa->total_count_incl ? 1 : -1;
            }
            return fb->total_count_excl > fa->total_count_excl ? 1 : -1;
        }
        return fb->count_incl > fa->count_incl ? 1 : -1;
    }
    return fb->count_excl > fa->count_excl ? 1 : -1;
}

// Assembly:
movq (%rdi), %rax
movq (%rsi), %rcx
movq 0x100(%rcx), %rdx
movq 0x100(%rax), %rsi
cmpq %rsi, %rdx
jne 0x17d9e
movq 0x108(%rcx), %rdx
movq 0x108(%rax), %rsi
cmpq %rsi, %rdx
jne 0x17d9e
movq 0x110(%rcx), %rdx
movq 0x110(%rax), %rsi
cmpq %rsi, %rdx
jne 0x17d9e
movq 0x118(%rcx), %rcx
movq 0x118(%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x17da9
xorl %eax, %eax
cmpq %rcx, %rdx
jmp 0x17da3
xorl %eax, %eax
cmpq %rdx, %rsi
adcl $-0x1, %eax
orl $0x1, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/adsr[P]phpspy/addr_objdump.c
// Function: shell_escape
int shell_escape(const char *arg, char *buf, size_t buf_size, const char *what) {
    int rv = 0;
    char *const buf_end = buf + buf_size;
    assert(buf_size >= 1);
    *buf++ = '\'';

    while (*arg) {
        /* logic based on https://stackoverflow.com/a/3669819 */
        if (*arg == '\'') {
            if (buf_end - buf < 4) {
                rv = 1;
                goto shell_escape_end;
            }

            *buf++ = '\''; /* close quoting */
            *buf++ = '\\'; /* escape ... */
            *buf++ = '\''; /* ... a single quote */
            *buf++ = '\''; /* reopen quoting */
            arg++;
        } else {
            if (buf_end - buf < 1) {
                rv = 1;
                goto shell_escape_end;
            }

            *buf++ = *arg++;
        }
    }

    if (buf_end - buf < 2) {
        rv = 1;
        goto shell_escape_end;
    }

    *buf++ = '\'';
    *buf = '\0';

shell_escape_end:
    if (rv != 0) {
        log_error("shell_escape: Buffer too small to escape %s: %s\n", what, arg);
    }

    return rv;
}

// Assembly:
pushq %rax
testq %rdx, %rdx
je 0x17e1a
movq %rdi, %rax
addq %rsi, %rdx
movb $0x27, (%rsi)
incq %rsi
movzbl (%rax), %edi
movq %rdx, %r8
subq %rsi, %r8
cmpl $0x27, %edi
je 0x17ddd
testl %edi, %edi
je 0x17df2
testq %r8, %r8
jle 0x17df8
movb %dil, (%rsi)
incq %rsi
jmp 0x17ded
cmpq $0x4, %r8
jl 0x17df8
movl $0x27275c27, (%rsi)     # imm = 0x27275C27
addq $0x4, %rsi
incq %rax
jmp 0x17dbe
cmpq $0x2, %r8
jge 0x17e11
leaq 0x62c6(%rip), %rdi      # 0x1e0c5
movq %rcx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xa442
pushq $0x1
popq %rax
popq %rcx
retq
movw $0x27, (%rsi)
xorl %eax, %eax
jmp 0x17e0f
leaq 0x624a(%rip), %rdi      # 0x1e06b
leaq 0x6251(%rip), %rsi      # 0x1e079
leaq 0x6259(%rip), %rcx      # 0x1e088
pushq $0xc
popq %rdx
callq 0x6220
// File: /workspace/github_c_makefile_star2_O2/adsr[P]phpspy/addr_objdump.c
// Function: popen_read_line
static int popen_read_line(char *buf, size_t buf_size, char *cmd_fmt, ...) {
    FILE *fp;
    char cmd[PHPSPY_STR_SIZE];
    int buf_len;
    va_list cmd_args;
    va_start(cmd_args, cmd_fmt);
    if (vsnprintf(cmd, sizeof(cmd), cmd_fmt, cmd_args) >= (int)(sizeof(cmd) - 1)) {
        log_error("vsnprintf overflow\n");
        return 1;
    }
    va_end(cmd_args);
    if (!(fp = popen(cmd, "r"))) {
        perror("popen");
        return 1;
    }
    if (fgets(buf, buf_size-1, fp) == NULL) {
        log_error("popen_read_line: No stdout; cmd=%s\n", cmd);
        pclose(fp);
        return 1;
    }
    pclose(fp);
    buf_len = strlen(buf);
    while (buf_len > 0 && buf[buf_len-1] == '\n') {
        --buf_len;
    }
    if (buf_len < 1) {
        log_error("popen_read_line: Expected strlen(buf)>0; cmd=%s\n", cmd);
        return 1;
    }
    buf[buf_len] = '\0';
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, %rbx
leaq 0x120(%rsp), %rsi
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x180e0
movaps %xmm0, 0x150(%rsp)
movaps %xmm1, 0x160(%rsp)
movaps %xmm2, 0x170(%rsp)
movaps %xmm3, 0x180(%rsp)
movaps %xmm4, 0x190(%rsp)
movaps %xmm5, 0x1a0(%rsp)
movaps %xmm6, 0x1b0(%rsp)
movaps %xmm7, 0x1c0(%rsp)
movq %rsp, %rcx
movq %rsi, 0x10(%rcx)
leaq 0x1f0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rcx)
leaq 0x20(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x60f0
cmpl $0xff, %eax
jl 0x18129
leaq 0x608a(%rip), %rdi      # 0x1e1a7
xorl %eax, %eax
callq 0xa442
jmp 0x181ae
leaq 0x5728(%rip), %rsi      # 0x1d858
leaq 0x20(%rsp), %rdi
callq 0x6510
testq %rax, %rax
je 0x181bc
movq %rax, %r14
movq %rbx, %rdi
movl $0xff, %esi
movq %rax, %rdx
callq 0x62c0
testq %rax, %rax
je 0x1817e
movq %r14, %rdi
callq 0x61c0
movq %rbx, %rdi
callq 0x6160
testl %eax, %eax
jle 0x1819b
movl %eax, %ecx
decl %eax
cmpb $0xa, -0x1(%rbx,%rcx)
je 0x18167
movb $0x0, (%rbx,%rcx)
xorl %eax, %eax
jmp 0x181b1
leaq 0x6036(%rip), %rdi      # 0x1e1bb
leaq 0x20(%rsp), %rsi
xorl %eax, %eax
callq 0xa442
movq %r14, %rdi
callq 0x61c0
jmp 0x181ae
leaq 0x603d(%rip), %rdi      # 0x1e1df
leaq 0x20(%rsp), %rsi
xorl %eax, %eax
callq 0xa442
pushq $0x1
popq %rax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
retq
leaq 0x5b60(%rip), %rdi      # 0x1dd23
callq 0x6530
jmp 0x181ae
nop
// File: /workspace/github_c_makefile_star2_O2/adsr[P]phpspy/event_fout.c
// Function: event_handler_fout_snprintf
static int event_handler_fout_snprintf(char **s, size_t *n, size_t *ret_len, int repl_delim, const char *fmt, ...) {
    int len, i;
    va_list vl;
    char *c;

    va_start(vl, fmt);
    len = vsnprintf(*s, *n, fmt, vl);
    va_end(vl);

    if (len < 0 || (size_t)len >= *n) {
        log_error("event_handler_fout_snprintf: Not enough space in buffer; truncating\n");
        return PHPSPY_ERR | PHPSPY_ERR_BUF_FULL;
    }

    if (repl_delim) {
        for (i = 0; i < len; i++) { /* TODO optimize */
            c = *s + i;
            if (*c == opt_trace_delim || *c == opt_frame_delim) {
                *c = '?';
            }
        }
    }

    *s += len;
    *n -= len;
    *ret_len = (size_t)len;

    return PHPSPY_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rsp), %rdx
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x188c7
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 %rsp, %rcx
movq %rdx, 0x10(%rcx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000028, %rax     # imm = 0x3000000028
movq %rax, (%rcx)
movq (%rdi), %rdi
movq (%rsi), %rsi
movq %r8, %rdx
callq 0x60f0
testl %eax, %eax
js 0x18936
movl %eax, %eax
movq (%r14), %rcx
cmpq %rax, %rcx
jbe 0x18936
testl %ebp, %ebp
je 0x1894c
xorl %ecx, %ecx
leaq 0xca35(%rip), %rdx      # 0x25345
leaq 0xca2d(%rip), %rsi      # 0x25344
cmpq %rcx, %rax
je 0x18949
movq (%r15), %rdi
movb (%rdi,%rcx), %r8b
cmpb (%rdx), %r8b
je 0x1892d
cmpb (%rsi), %r8b
jne 0x18931
movb $0x3f, (%rdi,%rcx)
incq %rcx
jmp 0x18917
leaq 0x5adc(%rip), %rdi      # 0x1e419
xorl %eax, %eax
callq 0xa442
pushq $0x5
popq %rax
jmp 0x1895a
movq (%r14), %rcx
addq %rax, (%r15)
subq %rax, %rcx
movq %rcx, (%r14)
movq %rax, (%rbx)
xorl %eax, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DASedit.c
// Function: Print_Seq
void Print_Seq(char *target, int tlen)
{ static int letter[4] = { 'a', 'c', 'g', 't' };
  int i;

  for (i = 0; i < tlen; i++)
    { if (i%100 == 0 && i != 0)
        printf("\n");
      printf("%c",letter[(int) target[i]]);
    }
  printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
xorl %r14d, %r14d
testl %esi, %esi
cmovlel %r14d, %ebx
movq %rdi, %r15
pushq $0x64
popq %r12
pushq $0xa
popq %rbp
leaq 0x17c3d(%rip), %r13     # 0x19030
movl %r14d, %eax
xorl %edx, %edx
divl %r12d
cmpq %r14, %rbx
je 0x1428
testq %r14, %r14
je 0x1414
imull $-0x64, %eax, %eax
addl %r14d, %eax
jne 0x1414
movl %ebp, %edi
callq 0x1040
movsbq (%r15,%r14), %rax
movl (%r13,%rax,4), %edi
callq 0x1040
incq %r14
jmp 0x13f3
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/emmett1[P]st/st.c
// Function: utf8strchr
char *
utf8strchr(char *s, Rune u)
{
	Rune r;
	size_t i, j, len;

	len = strlen(s);
	for (i = 0, j = 0; i < len; i += j) {
		if (!(j = utf8decode(&s[i], &r, len - i)))
			break;
		if (r == u)
			return &(s[i]);
	}

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x5320
movq %rax, %r15
xorl %ebp, %ebp
leaq 0x4(%rsp), %r12
movq %r15, %rdx
subq %rbp, %rdx
jbe 0x7a83
leaq (%r14,%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x7a98
testq %rax, %rax
je 0x7a83
addq %rax, %rbp
cmpl %ebx, 0x4(%rsp)
jne 0x7a5c
jmp 0x7a86
xorl %r13d, %r13d
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jalalium[P]graph_algorithms_task/src_scc/components.c
// Function: process_traversed
int		process_traversed(t_vect *edgs)
{
	int num = 0;

	qsort(edgs->tab, edgs->used, sizeof(int), cmp_int);
	for (int i = 0; i < edgs->used; i++)
		if (i == 0 || edgs->tab[i] != edgs->tab[i-1])
			num++;
	free(edgs->tab);
	free(edgs);
	return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x10(%rbx), %rsi
leaq 0x250(%rip), %rcx       # 0x1424
pushq $0x4
popq %rdx
callq 0x1060
movq 0x10(%rbx), %rax
xorl %ecx, %ecx
xorl %r14d, %r14d
cmpq %rcx, %rax
je 0x1203
testq %rcx, %rcx
je 0x11fb
movq (%rbx), %rdx
movl (%rdx,%rcx,4), %esi
cmpl -0x4(%rdx,%rcx,4), %esi
je 0x11fe
incl %r14d
incq %rcx
jmp 0x11e5
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jalalium[P]graph_algorithms_task/src_scc/components.c
// Function: init_component
t_component *init_component()
{
	t_component *new = (t_component*)malloc(sizeof(t_component));
	t_vect *l = (t_vect*)malloc(sizeof(t_vect));

	init_vector(l);
	new->vrx_nb = 0;
	new->edg_nb = 0;
	new->list = l;
	return (new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
pushq $0x20
popq %rdi
callq 0x1090
movq %rax, %rbx
pushq $0x18
popq %rdi
callq 0x1090
movq %rax, %r14
movq %rax, %rdi
callq 0x1bc4
andq $0x0, 0x14(%rbx)
movq %r14, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jalalium[P]graph_algorithms_task/src_scc/components.c
// Function: fill_component
void	fill_component(int x, t_graph *g, t_component *new, int cycl)
{
	t_stack	*stk = (t_stack*)malloc(sizeof(t_stack));
	t_vect	*edgs = (t_vect*)malloc(sizeof(t_vect));
	init_vector(edgs);
	stk->size = 0;
	int tag;
	int top;
	int cnt = 0;

	push(stk,x);
	g->visited[x] = cycl;
	while (stk->size > 0)
	{
		tag = 0;
		top = stk->top->val;
		for (int i = 0; i < g->rev_adj[top].used; i++)
		{
			if (g->visited[g->rev_adj[top].tab[i]] == 0)
			{
				g->visited[g->rev_adj[top].tab[i]] = cycl;
				push(stk, g->rev_adj[top].tab[i]);
				tag = 1;
			}
			else if (g->visited[g->rev_adj[top].tab[i]] == cycl)
				push_back(edgs, g->vertx * top + g->rev_adj[top].tab[i]);
		}
		if (!tag)
		{
			new->vrx_nb++;
			push_back(new->list,top);
			pop(stk);
		}
	}
	new->edg_nb = process_traversed(edgs);
	free(stk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r14d
movq %rdx, -0x30(%rbp)
movq %rsi, %r12
movl %edi, %ebx
pushq $0x10
popq %rdi
callq 0x1090
movq %rax, %r15
pushq $0x18
popq %rdi
callq 0x1090
movq %rax, -0x38(%rbp)
movq %rax, %rdi
callq 0x1bc4
andq $0x0, 0x8(%r15)
movq %r15, %rdi
movl %ebx, %esi
callq 0x1b27
movq 0x20(%r12), %rax
movslq %ebx, %rcx
movl %r14d, (%rax,%rcx,4)
movq %r15, -0x48(%rbp)
cmpq $0x0, 0x8(%r15)
je 0x1348
movq (%r15), %rax
movslq 0x10(%rax), %rcx
xorl %r13d, %r13d
movq %rcx, -0x40(%rbp)
imulq $0x18, %rcx, %r15
xorl %ebx, %ebx
movq 0x8(%r12), %rax
cmpq %r13, 0x10(%rax,%r15)
jbe 0x1320
addq %r15, %rax
movq 0x20(%r12), %rcx
movq (%rax), %rdx
movslq (%rdx,%r13,4), %rax
movl (%rcx,%rax,4), %esi
testl %esi, %esi
je 0x1307
cmpl %r14d, %esi
jne 0x131b
movl 0x2c(%r12), %esi
imull -0x40(%rbp), %esi
addl %eax, %esi
movq -0x38(%rbp), %rdi
callq 0x1c68
jmp 0x131b
movl %r14d, (%rcx,%rax,4)
movl (%rdx,%r13,4), %esi
movq -0x48(%rbp), %rdi
callq 0x1b27
pushq $0x1
popq %rbx
incq %r13
jmp 0x12ca
testl %ebx, %ebx
movq -0x48(%rbp), %r15
jne 0x12ab
movq -0x30(%rbp), %rax
incl 0x14(%rax)
movq (%rax), %rdi
movq -0x40(%rbp), %rsi
callq 0x1c68
movq %r15, %rdi
callq 0x1ae8
jmp 0x12ab
movq -0x38(%rbp), %rdi
callq 0x11bc
movq -0x30(%rbp), %rcx
movl %eax, 0x18(%rcx)
movq %r15, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/jalalium[P]graph_algorithms_task/src_scc/components.c
// Function: classify_component
void	classify_component(t_component *c)
{
	if (c->edg_nb > c->vrx_nb)
		c->type = 2;
	else if (c->edg_nb == 0)
		c->type = 0;
	else
		c->type = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x18(%rdi), %eax
cmpl 0x14(%rdi), %eax
jle 0x1383
movl $0x2, 0x10(%rdi)
jmp 0x1394
testl %eax, %eax
je 0x1390
movl $0x1, 0x10(%rdi)
jmp 0x1394
andl $0x0, 0x10(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jalalium[P]graph_algorithms_task/src_scc/components.c
// Function: add_component
void	add_component(t_graph *g, t_component *c)
{
	if (g->head == NULL)
	{
		g->head = c;
		g->tail = c;
		c->next = NULL;
	}
	else
	{
		g->tail->next = c;
		c->next = NULL;
		g->tail = c;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x10(%rdi)
je 0x13af
movq 0x18(%rdi), %rax
addq $0x18, %rdi
movq %rsi, 0x8(%rax)
jmp 0x13b7
movq %rsi, 0x10(%rdi)
addq $0x18, %rdi
movq %rsi, (%rdi)
andq $0x0, 0x8(%rsi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jalalium[P]graph_algorithms_task/src_scc/components.c
// Function: get_component
void	get_component(t_graph *g, int src, int cycl)
{
	t_component *new = init_component();

	fill_component(src,g,new, cycl);
	classify_component(new);
	add_component(g, new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
callq 0x121b
movq %rax, %r14
movl %r12d, %edi
movq %rbx, %rsi
movq %rax, %rdx
movl %r15d, %ecx
callq 0x1250
movq %r14, %rdi
callq 0x136e
cmpq $0x0, 0x10(%rbx)
je 0x140b
movq 0x18(%rbx), %rax
addq $0x18, %rbx
movq %r14, 0x8(%rax)
jmp 0x1413
movq %r14, 0x10(%rbx)
addq $0x18, %rbx
movq %r14, (%rbx)
andq $0x0, 0x8(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jalalium[P]graph_algorithms_task/src_scc/create_graph.c
// Function: get_dimensions
int		get_dimensions(t_graph *new)
{
	int n,m;

	scanf("%d %d", &n, &m);
	if (!valid_dimensions(n,m,new))
	{
		free(new);
		return 0;
	}
	if (!init_adj(new))
		return 0;
	if (!(new->visited = (int*)malloc(sizeof(int) * new->vertx)))
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0xb1d(%rip), %rdi       # 0x2004
xorl %ebx, %ebx
leaq -0x28(%rbp), %r15
leaq -0x24(%rbp), %r12
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x10a0
movl (%r15), %edi
movl (%r12), %esi
movq %r14, %rdx
callq 0x1b68
testl %eax, %eax
je 0x1538
movq %r14, %rdi
callq 0x142e
testl %eax, %eax
je 0x1540
movslq 0x2c(%r14), %rdi
shlq $0x2, %rdi
callq 0x1090
movq %rax, 0x20(%r14)
xorl %ebx, %ebx
testq %rax, %rax
setne %bl
jmp 0x1540
movq %r14, %rdi
callq 0x1030
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jalalium[P]graph_algorithms_task/src_scc/freeing.c
// Function: free_components
void	free_components(t_graph *g)
{
	t_component *tmp;
	t_component *tmp1;

	tmp = g->head;
	while (tmp != NULL)
	{
		tmp1 = tmp->next;
		free(tmp->list->tab);
		free(tmp->list);
		free(tmp);
		tmp = tmp1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x10(%rdi), %rbx
testq %rbx, %rbx
je 0x1734
movq (%rbx), %rax
movq 0x8(%rbx), %r14
movq (%rax), %rdi
callq 0x1030
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
movq %r14, %rbx
jmp 0x170b
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jalalium[P]graph_algorithms_task/src_scc/freeing.c
// Function: free_graph
void	free_graph(t_graph *g)
{
	free(g->visited);
	for (int i = 0; i < g->vertx; i++)
	{
		free(g->adj[i].tab);
		free(g->rev_adj[i].tab);
	}
	free(g->adj);
	free(g->rev_adj);
	free_components(g);
	free(g);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x1030
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq 0x2c(%rbx), %rax
movq (%rbx), %rdi
cmpq %rax, %r15
jge 0x1780
movq (%rdi,%r14), %rdi
callq 0x1030
movq 0x8(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x1030
incq %r15
addq $0x18, %r14
jmp 0x1755
callq 0x1030
movq 0x8(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1700
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/jalalium[P]graph_algorithms_task/src_scc/main_scc.c
// Function: generate_graph
t_graph *generate_graph()
{
	t_graph *new = (t_graph*)malloc(sizeof(t_graph));
	new->head = NULL;
	new->tail = NULL;
	new->components = 0;
	if (!get_dimensions(new))
		error(WRONG_INPUT);
	if (!get_edges(new))
		error(WRONG_EDGE);
	return (new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
pushq $0x38
popq %rdi
callq 0x1090
movq %rax, %rbx
andl $0x0, 0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %rax, %rdi
callq 0x14ce
testl %eax, %eax
jne 0x17d7
xorl %edi, %edi
callq 0x16d4
movq %rbx, %rdi
callq 0x15ff
testl %eax, %eax
jne 0x17eb
pushq $0x1
popq %rdi
callq 0x16d4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jalalium[P]graph_algorithms_task/src_scc/main_scc.c
// Function: dfs
void	dfs(int x, t_graph *g, t_stack *out)
{
	t_stack	*stk = (t_stack*)malloc(sizeof(t_stack));
	stk->size = 0;
	int tag;
	int top;

	push(stk,x);
	while (stk->size > 0)
	{
		tag = 0;
		top = stk->top->val;
		g->visited[top] = 1;
		for (int i = 0; i < g->adj[top].used; i++)
		{
			if (g->visited[g->adj[top].tab[i]] == 0)
			{
				push(stk, g->adj[top].tab[i]);
				tag = 1;
			}
		}
		if (!tag)
		{
			push(out, top);
			pop(stk);
		}
	}
	free(stk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %r14
movl %edi, %r12d
pushq $0x10
popq %rdi
callq 0x1090
movq %rax, %r15
andq $0x0, 0x8(%rax)
movq %rax, %rdi
movl %r12d, %esi
callq 0x1b27
pushq $0x1
popq %r13
cmpq $0x0, 0x8(%r15)
je 0x189d
movq (%r15), %rax
movslq 0x10(%rax), %rcx
movq 0x20(%r14), %rax
movl $0x1, (%rax,%rcx,4)
xorl %ebx, %ebx
movq %rcx, -0x38(%rbp)
imulq $0x18, %rcx, %r12
xorl %eax, %eax
movq (%r14), %rcx
cmpq %rbx, 0x10(%rcx,%r12)
jbe 0x1882
addq %r12, %rcx
movq 0x20(%r14), %rdx
movq (%rcx), %rcx
movslq (%rcx,%rbx,4), %rsi
cmpl $0x0, (%rdx,%rsi,4)
jne 0x187d
movq %r15, %rdi
callq 0x1b27
movl %r13d, %eax
incq %rbx
jmp 0x1854
testl %eax, %eax
jne 0x182f
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1b27
movq %r15, %rdi
callq 0x1ae8
jmp 0x182f
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/jalalium[P]graph_algorithms_task/src_scc/main_scc.c
// Function: first_pass
t_stack	*first_pass(t_graph *g)
{
	t_stack	*out = (t_stack*)malloc(sizeof(t_stack));
	out->size = 0;
	memset(g->visited,0,sizeof(int)*g->vertx);
	for (int i = 0; i < g->vertx; i++)
	{
		if (g->visited[i] == 0)
			dfs(i, g, out);
	}
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x1090
movq %rax, %r14
andq $0x0, 0x8(%rax)
movq 0x20(%rbx), %rdi
movslq 0x2c(%rbx), %rdx
shlq $0x2, %rdx
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x1080
movslq 0x2c(%rbx), %rax
cmpq %rax, %r15
jge 0x190d
movq 0x20(%rbx), %rax
cmpl $0x0, (%rax,%r15,4)
jne 0x1908
movl %r15d, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x17f5
incq %r15
jmp 0x18e6
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jalalium[P]graph_algorithms_task/src_scc/main_scc.c
// Function: second_pass
void	second_pass(t_graph *g, t_stack *stk)
{
	memset(g->visited,0,sizeof(int)*g->vertx);
	while (stk->size > 0)
	{
		if (g->visited[stk->top->val] == 0)
			get_component(g,stk->top->val,++g->components);
		pop(stk);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
movslq 0x2c(%r14), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x1080
cmpq $0x0, 0x8(%rbx)
je 0x196f
movq 0x20(%r14), %rax
movq (%rbx), %rcx
movslq 0x10(%rcx), %rsi
cmpl $0x0, (%rax,%rsi,4)
jne 0x1965
movl 0x28(%r14), %edx
incl %edx
movl %edx, 0x28(%r14)
movq %r14, %rdi
callq 0x13c1
movq %rbx, %rdi
callq 0x1ae8
jmp 0x193b
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jalalium[P]graph_algorithms_task/src_scc/main_scc.c
// Function: main
int main()
{
	t_graph *g;
	g = generate_graph();
	find_scc(g);
	print_components(g);
	free_graph(g);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x17a8
movq %rax, %rbx
movq %rax, %rdi
callq 0x1974
movq %rbx, %rdi
callq 0x19cc
movq %rbx, %rdi
callq 0x1739
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jalalium[P]graph_algorithms_task/src_scc/print_component.c
// Function: print_components
void	print_components(t_graph *g)
{
	t_component *tmp = g->head;

	if (g->components == 1)
		printf(BOLDWHITE "There is 1 strongly connected component:\n" RESET);
	else
		printf(BOLDWHITE "There are %d strongly connected components:\n" RESET, g->components);
	while (tmp != NULL)
	{
		if (tmp->type == 0)
		{
			printf(CYAN "A simple vertex and contains:\n" RESET);
			printf("%d\n", tmp->list->tab[0] + 1);
		}
		else if (tmp->type == 1)
		{
			printf(CYAN "A cycle of length %d and contains:\n" RESET,tmp->vrx_nb);
			for (int i = 0 ; i < tmp->list->used; i++)
				printf("%d ", tmp->list->tab[i] + 1);
			puts("");
		}
		else
		{
			printf(CYAN "A complex strong component with %d edges and %d vertices and contains:\n" RESET, tmp->edg_nb, tmp->vrx_nb);
			for (int i = 0 ; i < tmp->list->used; i++)
				printf("%d ", tmp->list->tab[i] + 1);
			puts("");
		}
		tmp = tmp->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %r12
movl 0x28(%rdi), %esi
cmpl $0x1, %esi
jne 0x19f6
leaq 0x65d(%rip), %rdi       # 0x204a
xorl %eax, %eax
callq 0x1070
jmp 0x1a04
leaq 0x684(%rip), %rdi       # 0x2081
xorl %eax, %eax
callq 0x1070
leaq 0x709(%rip), %r14       # 0x2114
pushq $0xa
popq %r15
leaq 0x702(%rip), %rbx       # 0x2118
testq %r12, %r12
je 0x1ad9
movl 0x10(%r12), %eax
cmpl $0x1, %eax
je 0x1a56
testl %eax, %eax
jne 0x1a8e
leaq 0x687(%rip), %rdi       # 0x20bb
xorl %eax, %eax
callq 0x1070
movq (%r12), %rax
movq (%rax), %rax
movl (%rax), %esi
incl %esi
leaq 0x696(%rip), %rdi       # 0x20e3
xorl %eax, %eax
callq 0x1070
jmp 0x1acf
movl 0x14(%r12), %esi
leaq 0x685(%rip), %rdi       # 0x20e7
xorl %eax, %eax
callq 0x1070
xorl %r13d, %r13d
movq (%r12), %rax
cmpq %r13, 0x10(%rax)
jbe 0x1ac7
movq (%rax), %rax
movl (%rax,%r13,4), %esi
incl %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1070
incq %r13
jmp 0x1a6c
movl 0x14(%r12), %edx
movl 0x18(%r12), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1070
xorl %r13d, %r13d
movq (%r12), %rax
cmpq %r13, 0x10(%rax)
jbe 0x1ac7
movq (%rax), %rax
movl (%rax,%r13,4), %esi
incl %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1070
incq %r13
jmp 0x1aa5
movl %r15d, %edi
callq 0x1040
movq 0x8(%r12), %r12
jmp 0x1a16
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/calculator.c
// Function: PushOperator
static int PushOperator(Operator *oprt, const char op)
{
    if ((oprt->top - oprt->bom) >= oprt->size) {
        ShowWarning("operator stack is overflowing...");
        return 1;
    }
    *oprt->top = op;
    ++(oprt->top);
    return 0;
}

// Assembly:
movq 0x8(%rdi), %rax
movq %rax, %rcx
subq (%rdi), %rcx
movslq 0x10(%rdi), %rdx
cmpq %rdx, %rcx
jge 0x3672
movb %sil, (%rax)
incq 0x8(%rdi)
xorl %eax, %eax
retq
pushq %rax
leaq 0x14f78(%rip), %rdi     # 0x185f2
xorl %eax, %eax
callq 0x84d1
pushq $0x1
popq %rax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/calculator.c
// Function: PushOperand
static int PushOperand(Operand *oprd, const Real op)
{
    if ((oprd->top - oprd->bom) >= oprd->size) {
        ShowWarning("operand stack is overflowing...");
        return 1;
    }
    *oprd->top = op;
    ++(oprd->top);
    return 0;
}

// Assembly:
movq 0x8(%rdi), %rax
movq %rax, %rcx
subq (%rdi), %rcx
sarq $0x3, %rcx
movslq 0x10(%rdi), %rdx
cmpq %rdx, %rcx
jge 0x36af
movsd %xmm0, (%rax)
addq $0x8, %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
retq
pushq %rax
leaq 0x14f5c(%rip), %rdi     # 0x18613
xorl %eax, %eax
callq 0x84d1
pushq $0x1
popq %rax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/calculator.c
// Function: PopOperator
static int PopOperator(Operator *oprt, char *pop)
{
    if (oprt->top == oprt->bom) {
        ShowWarning("no sufficient operators in expression...");
        return 1;
    }
    --(oprt->top);
    *pop = *oprt->top;
    return 0;
}

// Assembly:
movq 0x8(%rdi), %rax
cmpq (%rdi), %rax
je 0x36df
leaq -0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movb -0x1(%rax), %al
movb %al, (%rsi)
xorl %eax, %eax
retq
pushq %rax
leaq 0x14f62(%rip), %rdi     # 0x18649
xorl %eax, %eax
callq 0x84d1
pushq $0x1
popq %rax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/calculator.c
// Function: PopOperand
static int PopOperand(Operand *oprd, Real *pop)
{
    if (oprd->top == oprd->bom) {
        ShowWarning("no sufficient operands in expression...");
        return 1;
    }
    --(oprd->top);
    *pop = *oprd->top;
    return 0;
}

// Assembly:
movq 0x8(%rdi), %rax
cmpq (%rdi), %rax
je 0x3713
leaq -0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movsd -0x8(%rax), %xmm0
movsd %xmm0, (%rsi)
xorl %eax, %eax
retq
pushq %rax
leaq 0x14f57(%rip), %rdi     # 0x18672
xorl %eax, %eax
callq 0x84d1
pushq $0x1
popq %rax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/calculator.c
// Function: QueryIndex
static int QueryIndex(const char op)
{
    int i = 0;
    switch(op) {
        case '+':
            i = 0; break;
        case '-':
            i = 1; break;
        case '*':
            i = 2; break;
        case '/':
            i = 3; break;
        case '^':
            i = 4; break;
        case 'e':
            i = 5; break;
        case 'n':
            i = 6; break;
        case 'g':
            i = 7; break;
        case 'a':
            i = 8; break;
        case 's':
            i = 9; break;
        case 'c':
            i = 10; break;
        case 't':
            i = 11; break;
        case '(':
            i = 12; break;
        case ')':
            i = 13; break;
        case '[':
            i = 14; break;
        case ']':
            i = 15; break;
        case '{':
            i = 16; break;
        case '}':
            i = 17; break;
        case '\0':
            i = 18; break;
        default:
            ShowWarning("unidentified operator");
            break;
    }
    return i;
}

// Assembly:
pushq %rbx
leal -0x5b(%rdi), %eax
cmpl $0x13, %eax
jbe 0x3752
leal -0x28(%rdi), %eax
cmpl $0x7, %eax
ja 0x3766
leaq 0x14a0a(%rip), %rcx     # 0x1814c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0xc
jmp 0x37d2
leaq 0x14a13(%rip), %rcx     # 0x1816c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0xe
jmp 0x37d2
testl %edi, %edi
je 0x37d0
cmpl $0x73, %edi
je 0x37c4
cmpl $0x74, %edi
je 0x37cc
cmpl $0x7b, %edi
je 0x37c8
cmpl $0x7d, %edi
jne 0x3782
pushq $0x11
jmp 0x37d2
leaq 0x14eaa(%rip), %rdi     # 0x18633
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x84d1
jmp 0x37d3
pushq $0x7
jmp 0x37d2
pushq $0x8
jmp 0x37d2
pushq $0x6
jmp 0x37d2
pushq $0x5
jmp 0x37d2
pushq $0x4
jmp 0x37d2
pushq $0xf
jmp 0x37d2
pushq $0xa
jmp 0x37d2
pushq $0x1
jmp 0x37d2
pushq $0x2
jmp 0x37d2
xorl %ebx, %ebx
jmp 0x37d3
pushq $0xd
jmp 0x37d2
pushq $0x3
jmp 0x37d2
pushq $0x9
jmp 0x37d2
pushq $0x10
jmp 0x37d2
pushq $0xb
jmp 0x37d2
pushq $0x12
popq %rbx
movl %ebx, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/case_loader.c
// Function: ReadConsecutiveData
static void ReadConsecutiveData(FILE *fp, const int n, const char *fmt,
        Real *preal, char pstr[][VARSTR])
{
    if (NULL != preal) {
        for (int m = 0; m < n; ++m) {
            Sread(fp, 1, fmt, preal + m);
        }
    } else {
        String str = {'\0'};
        for (int m = 0; m < n; ++m) {
            ParseCommand(fgets(str, sizeof str, fp));
            strncpy(pstr[m], str, sizeof pstr[m]);
        }
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x6a62
movq %rdx, %r15
movq %rsi, %r12
pushq $0x1
popq %rbp
xorl %r14d, %r14d
cmpq $0x28, %r14
je 0x6ab4
leaq (%r15,%r14), %rcx
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
xorl %eax, %eax
callq 0x89d6
addq $0x8, %r14
jmp 0x6a43
movq %rcx, %r14
movq %rsp, %r15
xorl %r13d, %r13d
movl $0xc8, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x20d0
pushq $0x64
popq %r12
cmpq $0x1f4, %r13            # imm = 0x1F4
je 0x6ab4
movq %r15, %rdi
movl $0xc8, %esi
movq %rbx, %rdx
callq 0x2120
movq %rax, %rdi
callq 0x841c
leaq (%r14,%r13), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2040
addq $0x64, %r13
jmp 0x6a7e
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/case_loader.c
// Function: ReadBoundaryData
static void ReadBoundaryData(FILE *fp, Space *space, const int n)
{
    Partition *const part = &(space->part);
    String str = {'\0'}; /* store the current read line */
    const char *fmtI = ParseFormat("%lg");
    ParseCommand(fgets(str, sizeof str, fp));
    if (0 == strncmp(str, "inflow", sizeof str)) {
        part->typeBC[n] = INFLOW;
        ReadConsecutiveData(fp, VARBC - 1, fmtI, part->varBC[n], NULL);
        return;
    }
    if (0 == strncmp(str, "outflow", sizeof str)) {
        part->typeBC[n] = OUTFLOW;
        return;
    }
    if (0 == strncmp(str, "slip wall", sizeof str)) {
        part->typeBC[n] = SLIPWALL;
        Sread(fp, 1, fmtI, &(part->varBC[n][VARBC-1]));
        return;
    }
    if (0 == strncmp(str, "noslip wall", sizeof str)) {
        part->typeBC[n] = NOSLIPWALL;
        Sread(fp, 1, fmtI, &(part->varBC[n][VARBC-1]));
        return;
    }
    if (0 == strncmp(str, "periodic", sizeof str)) {
        part->typeBC[n] = PERIODIC;
        return;
    }
    ShowError("unidentified boundary type: n: %d, type: %s", n, str);
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movl $0xc8, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x20d0
leaq 0x14ef0(%rip), %rdi     # 0x1b9e6
callq 0x8566
movq %rax, %r15
movq %r12, %rdi
movl $0xc8, %esi
movq %rbx, %rdx
callq 0x2120
movq %rax, %rdi
callq 0x841c
leaq 0x140f6(%rip), %rsi     # 0x1ac13
pushq $0x7
popq %rdx
movq %r12, %rdi
callq 0x2190
testl %eax, %eax
je 0x6b51
movabsq $0x776f6c6674756f, %rax # imm = 0x776F6C6674756F
cmpq %rax, (%rsp)
jne 0x6b7b
movq 0x3b8(%r14), %rax
movl %ebp, %ecx
movl $0x1, (%rax,%rcx,4)
jmp 0x6c16
movq 0x3b8(%r14), %rax
movl %ebp, %ecx
andl $0x0, (%rax,%rcx,4)
imulq $0x30, %rcx, %rdx
addq 0x3c8(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x6a1e
jmp 0x6c16
leaq 0x1409a(%rip), %rsi     # 0x1ac1c
movq %rsp, %rdi
pushq $0xa
popq %rdx
callq 0x2190
testl %eax, %eax
je 0x6bd2
leaq 0x14082(%rip), %rsi     # 0x1ac1a
movq %rsp, %rdi
pushq $0xc
popq %rdx
callq 0x2190
testl %eax, %eax
je 0x6be4
leaq 0x14078(%rip), %rsi     # 0x1ac26
movq %rsp, %rdi
pushq $0x9
popq %rdx
callq 0x2190
testl %eax, %eax
je 0x6c26
leaq 0x1406b(%rip), %rdi     # 0x1ac2f
movq %rsp, %rdx
movl %ebp, %esi
xorl %eax, %eax
callq 0x856a
jmp 0x6c16
movq 0x3b8(%r14), %rax
movl %ebp, %ecx
movl $0x2, (%rax,%rcx,4)
jmp 0x6bf4
movq 0x3b8(%r14), %rax
movl %ebp, %ecx
movl $0x3, (%rax,%rcx,4)
movq 0x3c8(%r14), %rax
imulq $0x30, %rcx, %rcx
addq %rax, %rcx
addq $0x28, %rcx
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x89d6
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x3b8(%r14), %rax
movl %ebp, %ecx
movl $0x4, (%rax,%rcx,4)
jmp 0x6c16
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/case_loader.c
// Function: WriteBoundaryData
static void WriteBoundaryData(FILE *fp, const Space *space, const int n)
{
    const Partition *const part = &(space->part);
    switch (part->typeBC[n]) {
        case INFLOW:
            fprintf(fp, "boundary type: inflow\n");
            fprintf(fp, "density: %.6g\n", part->varBC[n][0]);
            fprintf(fp, "x velocity: %.6g\n", part->varBC[n][1]);
            fprintf(fp, "y velocity: %.6g\n", part->varBC[n][2]);
            fprintf(fp, "z velocity: %.6g\n", part->varBC[n][3]);
            fprintf(fp, "pressure: %.6g\n", part->varBC[n][4]);
            break;
        case OUTFLOW:
            fprintf(fp, "boundary type: outflow\n");
            break;
        case SLIPWALL:
            fprintf(fp, "boundary type: slip wall\n");
            fprintf(fp, "temperature: %.6g\n", part->varBC[n][VARBC-1]);
            break;
        case NOSLIPWALL:
            fprintf(fp, "boundary type: noslip wall\n");
            fprintf(fp, "temperature: %.6g\n", part->varBC[n][VARBC-1]);
            break;
        case PERIODIC:
            fprintf(fp, "boundary type: periodic\n");
            break;
        default:
            ShowError("unidentified boundary type: n: %d, type: %d", n, part->typeBC[n]);
            break;
    }
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x3b8(%rsi), %rax
movl %edx, %r15d
movl (%rax,%r15,4), %eax
cmpq $0x4, %rax
ja 0x701e
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x13b52(%rip), %rcx     # 0x1aa50
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1438d(%rip), %rdi     # 0x1b29b
pushq $0x16
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x2210
movq 0x3c8(%r14), %rax
imulq $0x30, %r15, %r15
movsd (%rax,%r15), %xmm0
leaq 0x13fc7(%rip), %rsi     # 0x1aefb
movq %rbx, %rdi
movb $0x1, %al
callq 0x2160
movq 0x3c8(%r14), %rax
movsd 0x8(%rax,%r15), %xmm0
leaq 0x1435f(%rip), %rsi     # 0x1b2b2
movq %rbx, %rdi
movb $0x1, %al
callq 0x2160
movq 0x3c8(%r14), %rax
movsd 0x10(%rax,%r15), %xmm0
leaq 0x14352(%rip), %rsi     # 0x1b2c4
movq %rbx, %rdi
movb $0x1, %al
callq 0x2160
movq 0x3c8(%r14), %rax
movsd 0x18(%rax,%r15), %xmm0
leaq 0x14345(%rip), %rsi     # 0x1b2d6
movq %rbx, %rdi
movb $0x1, %al
callq 0x2160
movq 0x3c8(%r14), %rax
movsd 0x20(%rax,%r15), %xmm0
leaq 0x14338(%rip), %rsi     # 0x1b2e8
jmp 0x6ff5
leaq 0x1438d(%rip), %rdi     # 0x1b346
pushq $0x18
jmp 0x700d
leaq 0x1434c(%rip), %rdi     # 0x1b310
pushq $0x19
jmp 0x6fd1
leaq 0x1435b(%rip), %rdi     # 0x1b32a
pushq $0x1b
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x2210
movq 0x3c8(%r14), %rax
imulq $0x30, %r15, %rcx
movsd 0x28(%rax,%rcx), %xmm0
leaq 0x13f15(%rip), %rsi     # 0x1af0a
movq %rbx, %rdi
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
jmp 0x2160
leaq 0x142ed(%rip), %rdi     # 0x1b2f8
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x2210
leaq 0x1433a(%rip), %rdi     # 0x1b35f
movl %edx, %esi
movl %eax, %edx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x856a
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: EigenvectorL
void EigenvectorL(const int s, const Real gamma, const Real Uo[restrict], Real L[restrict][DIMU])
{
    const Real u = Uo[1];
    const Real v = Uo[2];
    const Real w = Uo[3];
    const Real c = Uo[5];
    const Real q = 0.5 * (u * u + v * v + w * w);
    const Real b = (gamma - 1.0) / (2.0 * c * c);
    const Real d = 1.0 / (2.0 * c);
    ComputeEigenvectorL[s](u, v, w, q, b, d, L);
    return;
}

// Assembly:
movapd %xmm0, %xmm4
movsd 0x8(%rsi), %xmm0
movsd 0x10(%rsi), %xmm1
movsd 0x18(%rsi), %xmm2
movsd 0x28(%rsi), %xmm5
movapd %xmm1, %xmm3
mulsd %xmm1, %xmm3
movapd %xmm0, %xmm6
mulsd %xmm0, %xmm6
addsd %xmm3, %xmm6
movapd %xmm2, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm6, %xmm3
mulsd 0x14195(%rip), %xmm3    # 0x1b4b0
addsd 0x1417d(%rip), %xmm4    # 0x1b4a0
movapd %xmm5, %xmm6
addsd %xmm5, %xmm6
mulsd %xmm6, %xmm5
divsd %xmm5, %xmm4
movsd 0x10ccd(%rip), %xmm5    # 0x18008
divsd %xmm6, %xmm5
movslq %edi, %rax
leaq 0x1c977(%rip), %rcx     # 0x23cc0
movq (%rcx,%rax,8), %rax
movq %rdx, %rdi
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: EigenvectorR
void EigenvectorR(const int s, const Real Uo[restrict], Real R[restrict][DIMU])
{
    const Real u = Uo[1];
    const Real v = Uo[2];
    const Real w = Uo[3];
    const Real hT = Uo[4];
    const Real c = Uo[5];
    const Real q = 0.5 * (u * u + v * v + w * w);
    ComputeEigenvectorR[s](u, v, w, hT, c, q, R);
    return;
}

// Assembly:
movsd 0x8(%rsi), %xmm0
movsd 0x10(%rsi), %xmm1
movsd 0x18(%rsi), %xmm2
movsd 0x20(%rsi), %xmm3
movsd 0x28(%rsi), %xmm4
movapd %xmm1, %xmm5
mulsd %xmm1, %xmm5
movapd %xmm0, %xmm6
mulsd %xmm0, %xmm6
addsd %xmm5, %xmm6
movapd %xmm2, %xmm5
mulsd %xmm2, %xmm5
addsd %xmm6, %xmm5
mulsd 0x1411d(%rip), %xmm5    # 0x1b4b0
movslq %edi, %rax
leaq 0x1c943(%rip), %rcx     # 0x23ce0
movq (%rcx,%rax,8), %rax
movq %rdx, %rdi
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: ConvectiveFlux
void ConvectiveFlux(const int s, const Real gamma, const Real U[restrict], Real F[restrict])
{
    const Real rho = U[0];
    const Real u = U[1] / U[0];
    const Real v = U[2] / U[0];
    const Real w = U[3] / U[0];
    const Real eT = U[4] / U[0];
    const Real p = ComputePressure(gamma, U);
    ComputeConvectiveFlux[s](rho, u, v, w, eT, p, F);
    return;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %edi, %ebp
movsd (%rsi), %xmm1
movsd %xmm1, (%rsp)
movsd 0x8(%rsi), %xmm2
divsd %xmm1, %xmm2
movsd %xmm2, 0x20(%rsp)
movsd 0x10(%rsi), %xmm2
divsd %xmm1, %xmm2
movsd %xmm2, 0x18(%rsp)
movsd 0x18(%rsi), %xmm2
divsd %xmm1, %xmm2
movsd %xmm2, 0x10(%rsp)
movsd 0x20(%rsi), %xmm2
divsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
movq %rsi, %rdi
callq 0x7437
movaps %xmm0, %xmm5
movslq %ebp, %rax
leaq 0x1c8f5(%rip), %rcx     # 0x23d00
movq (%rcx,%rax,8), %rax
movsd (%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm3
movsd 0x8(%rsp), %xmm4
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: MapPrimitive
void MapPrimitive(const Real gamma, const Real gasR, const Real U[restrict], Real Uo[restrict])
{
    Uo[0] = U[0];
    Uo[1] = U[1] / U[0];
    Uo[2] = U[2] / U[0];
    Uo[3] = U[3] / U[0];
    Uo[4] = (U[4] - 0.5 * (U[1] * U[1] + U[2] * U[2] + U[3] * U[3]) / U[0]) * (gamma - 1.0);
    Uo[5] = Uo[4] / (Uo[0] * gasR);
    return;
}

// Assembly:
movupd 0x8(%rdi), %xmm4
movapd %xmm4, %xmm3
movsd 0x18(%rdi), %xmm2
movapd %xmm4, %xmm5
mulpd %xmm4, %xmm5
unpckhpd %xmm5, %xmm5            # xmm5 = xmm5[1,1]
mulsd %xmm4, %xmm4
addsd %xmm5, %xmm4
movapd %xmm2, %xmm5
mulsd %xmm2, %xmm2
addsd %xmm4, %xmm2
movsd (%rdi), %xmm4
movsd %xmm4, (%rsi)
mulsd 0x13fbb(%rip), %xmm2    # 0x1b4a8
divsd %xmm4, %xmm5
divsd %xmm4, %xmm2
mulsd %xmm4, %xmm1
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
divpd %xmm4, %xmm3
movupd %xmm3, 0x8(%rsi)
movsd %xmm5, 0x18(%rsi)
addsd 0x20(%rdi), %xmm2
addsd 0x13f88(%rip), %xmm0    # 0x1b4a0
mulsd %xmm2, %xmm0
movsd %xmm0, 0x20(%rsi)
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: MapConservative
void MapConservative(const Real gamma, const Real Uo[restrict], Real U[restrict])
{
    U[0] = Uo[0];
    U[1] = Uo[0] * Uo[1];
    U[2] = Uo[0] * Uo[2];
    U[3] = Uo[0] * Uo[3];
    U[4] = 0.5 * Uo[0] * (Uo[1] * Uo[1] + Uo[2] * Uo[2] + Uo[3] * Uo[3]) + Uo[4] / (gamma - 1.0);
    return;
}

// Assembly:
movsd 0x10(%rdi), %xmm1
movupd (%rdi), %xmm2
movapd %xmm2, %xmm3
shufpd $0x1, %xmm2, %xmm3      # xmm3 = xmm3[1],xmm2[0]
movlpd %xmm2, (%rsi)
movapd %xmm2, %xmm4
unpcklpd %xmm1, %xmm4            # xmm4 = xmm4[0],xmm1[0]
mulpd %xmm3, %xmm4
movupd %xmm4, 0x8(%rsi)
movsd 0x18(%rdi), %xmm3
movapd %xmm2, %xmm4
mulsd %xmm3, %xmm4
movsd %xmm4, 0x18(%rsi)
movsd 0x13eff(%rip), %xmm4    # 0x1b4b0
mulsd %xmm2, %xmm4
mulsd %xmm1, %xmm1
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
mulsd %xmm2, %xmm2
addsd %xmm1, %xmm2
mulsd %xmm3, %xmm3
addsd %xmm2, %xmm3
mulsd %xmm4, %xmm3
addsd 0x13ec7(%rip), %xmm0    # 0x1b4a0
movsd 0x20(%rdi), %xmm1
divsd %xmm0, %xmm1
addsd %xmm3, %xmm1
movsd %xmm1, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: InPartBox
int InPartBox(const int k, const int j, const int i, const int pbox[restrict][LIMIT])
{
    return
        (pbox[Z][MIN] <= k) && (pbox[Z][MAX] > k) &&
        (pbox[Y][MIN] <= j) && (pbox[Y][MAX] > j) &&
        (pbox[X][MIN] <= i) && (pbox[X][MAX] > i);
}

// Assembly:
xorl %eax, %eax
cmpl %edi, 0x10(%rcx)
jg 0x761b
cmpl %edi, 0x14(%rcx)
jle 0x761b
cmpl %esi, 0x8(%rcx)
jg 0x761b
cmpl %esi, 0xc(%rcx)
jle 0x761b
cmpl %edx, (%rcx)
jg 0x761b
xorl %eax, %eax
cmpl %edx, 0x4(%rcx)
setg %al
retq
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: EqualReal
int EqualReal(const Real x, const Real y)
{
    const Real epsilon = DBL_EPSILON;
    const Real diffMax = FLT_MIN;
    const Real diff = fabs(x - y);
    if (diff <= diffMax) {
        return 1;
    }
    const Real absx = fabs(x);
    const Real absy = fabs(y);
    const Real absMax = (absx > absy) ? absx : absy;
    return (diff <= epsilon * absMax);
}

// Assembly:
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
andpd 0x109c6(%rip), %xmm2    # 0x18040
movsd 0x13e56(%rip), %xmm3    # 0x1b4d8
ucomisd %xmm2, %xmm3
jae 0x76ae
movapd 0x109b0(%rip), %xmm3    # 0x18040
andpd %xmm3, %xmm0
andpd %xmm3, %xmm1
maxsd %xmm1, %xmm0
mulsd 0x13e3c(%rip), %xmm0    # 0x1b4e0
xorl %eax, %eax
ucomisd %xmm2, %xmm0
setae %al
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: Cross
void Cross(const Real V1[restrict], const Real V2[restrict], Real V[restrict])
{
    V[X] = V1[Y] * V2[Z] - V1[Z] * V2[Y];
    V[Y] = V1[Z] * V2[X] - V1[X] * V2[Z];
    V[Z] = V1[X] * V2[Y] - V1[Y] * V2[X];
    return;
}

// Assembly:
movsd (%rsi), %xmm0
movsd (%rdi), %xmm1
movupd 0x8(%rdi), %xmm2
movupd 0x8(%rsi), %xmm3
movapd %xmm2, %xmm4
shufpd $0x1, %xmm1, %xmm4      # xmm4 = xmm4[1],xmm1[0]
mulpd %xmm3, %xmm4
mulsd %xmm3, %xmm1
shufpd $0x1, %xmm0, %xmm3      # xmm3 = xmm3[1],xmm0[0]
mulpd %xmm2, %xmm3
subpd %xmm4, %xmm3
movupd %xmm3, (%rdx)
mulsd %xmm2, %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: OrthogonalSpace
void OrthogonalSpace(const Real N[restrict], Real Ta[restrict], Real Tb[restrict])
{
    int mark = Z; /* default mark for minimum component */
    if (fabs(N[mark]) > fabs(N[Y])) {
        mark = Y;
    }
    if (fabs(N[mark]) > fabs(N[X])) {
        mark = X;
    }
    if (X == mark) {
        Ta[X] = 0.0;
        Ta[Y] = -N[Z];
        Ta[Z] = N[Y];
    } else {
        if (Y == mark) {
            Ta[X] = N[Z];
            Ta[Y] = 0.0;
            Ta[Z] = -N[X];
        } else {
            Ta[X] = -N[Y];
            Ta[Y] = N[X];
            Ta[Z] = 0.0;
        }
    }
    Normalize(DIMS, Norm(Ta), Ta);
    Cross(Ta, N, Tb);
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movdqu 0x8(%rdi), %xmm0
movdqa 0x10886(%rip), %xmm2    # 0x18040
movdqa %xmm0, %xmm1
pand %xmm2, %xmm1
pshufd $0xee, %xmm1, %xmm3     # xmm3 = xmm1[2,3,2,3]
xorl %ecx, %ecx
ucomisd %xmm1, %xmm3
setbe %cl
incl %ecx
movq (%rdi,%rcx,8), %xmm3
pand %xmm2, %xmm3
movq (%rdi), %xmm1
pand %xmm1, %xmm2
xorl %eax, %eax
ucomisd %xmm2, %xmm3
cmovbel %ecx, %eax
cmpl $0x1, %eax
je 0x7811
testl %eax, %eax
jne 0x7829
andq $0x0, (%r15)
movdqa %xmm0, %xmm1
punpckhqdq %xmm0, %xmm1    # xmm1 = xmm1[1],xmm0[1]
pxor 0x13d07(%rip), %xmm1    # 0x1b510
movq %xmm1, 0x8(%r15)
jmp 0x7840
movhpd %xmm0, (%r15)
andq $0x0, 0x8(%r15)
pxor 0x13ced(%rip), %xmm1    # 0x1b510
movdqa %xmm1, %xmm0
jmp 0x7840
pxor 0x13cdf(%rip), %xmm0    # 0x1b510
movq %xmm0, (%r15)
movq %xmm1, 0x8(%r15)
pxor %xmm0, %xmm0
movq %xmm0, 0x10(%r15)
movq %r15, %rdi
callq 0x76f1
pushq $0x3
popq %rdi
movq %r15, %rsi
callq 0x786c
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x775d