LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
testq %rdx, %rdx
je 0x195f3
movq %rdi, %rax
addq %rsi, %rdx
movb $0x27, (%rsi)
incq %rsi
movzbl (%rax), %edi
cmpl $0x27, %edi
je 0x195a1
testl %edi, %edi
je 0x195bc
movq %rdx, %r8
subq %rsi, %r8
testq %r8, %r8
jle 0x195c7
movb %dil, (%rsi)
incq %rsi
jmp 0x195b7
movq %rdx, %rdi
subq %rsi, %rdi
cmpq $0x4, %rdi
jl 0x195c7
movl $0x27275c27, (%rsi)     # imm = 0x27275C27
addq $0x4, %rsi
incq %rax
jmp 0x19582
subq %rsi, %rdx
xorl %ebx, %ebx
cmpq $0x2, %rdx
jge 0x195ea
movl $0x1, %ebx
xorl %edx, %edx
testb %dl, %dl
jne 0x195e6
leaq 0x5af5(%rip), %rdi      # 0x1f0ce
movq %rcx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xadcf
movl %ebx, %eax
popq %rbx
retq
movw $0x27, (%rsi)
movb $0x1, %dl
jmp 0x195ce
leaq 0x5a7a(%rip), %rdi      # 0x1f074
leaq 0x5a81(%rip), %rsi      # 0x1f082
leaq 0x5a89(%rip), %rcx      # 0x1f091
movl $0xc, %edx
callq 0x6220
// File: /workspace/github_c_makefile_star2_O1/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 0x198e2
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 0x1992b
leaq 0x5891(%rip), %rdi      # 0x1f1b0
xorl %eax, %eax
callq 0xadcf
jmp 0x199d2
leaq 0x4f26(%rip), %rsi      # 0x1e858
leaq 0x20(%rsp), %rdi
callq 0x6510
testq %rax, %rax
je 0x199c6
movq %rax, %r14
movq %rbx, %rdi
movl $0xff, %esi
movq %rax, %rdx
callq 0x62c0
testq %rax, %rax
je 0x19994
movq %r14, %rdi
callq 0x61c0
movq %rbx, %rdi
callq 0x6160
testl %eax, %eax
jle 0x19986
movl %eax, %ecx
cmpb $0xa, -0x1(%rbx,%rcx)
jne 0x19986
leal -0x1(%rax), %ecx
cmpl $0x1, %eax
movl %ecx, %eax
jg 0x19971
xorl %eax, %eax
testl %eax, %eax
jle 0x199b1
movl %eax, %eax
movb $0x0, (%rbx,%rax)
xorl %eax, %eax
jmp 0x199d7
leaq 0x5829(%rip), %rdi      # 0x1f1c4
leaq 0x20(%rsp), %rsi
xorl %eax, %eax
callq 0xadcf
movq %r14, %rdi
callq 0x61c0
jmp 0x199d2
leaq 0x5830(%rip), %rdi      # 0x1f1e8
leaq 0x20(%rsp), %rsi
xorl %eax, %eax
callq 0xadcf
jmp 0x199d2
leaq 0x5356(%rip), %rdi      # 0x1ed23
callq 0x6530
movl $0x1, %eax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1a0ab
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 0x1a12c
movl %eax, %ecx
cmpq %rcx, (%r14)
jbe 0x1a12c
testl %ebp, %ebp
sete %dl
testl %eax, %eax
sete %al
orb %dl, %al
jne 0x1a11f
xorl %eax, %eax
leaq 0xb24a(%rip), %rdx      # 0x25345
leaq 0xb242(%rip), %rsi      # 0x25344
movq (%r15), %rdi
movb (%rdi,%rax), %r8b
cmpb (%rdx), %r8b
je 0x1a113
cmpb (%rsi), %r8b
jne 0x1a117
movb $0x3f, (%rdi,%rax)
incq %rax
cmpq %rax, %rcx
jne 0x1a102
addq %rcx, (%r15)
subq %rcx, (%r14)
movq %rcx, (%rbx)
xorl %eax, %eax
jmp 0x1a13f
leaq 0x52ee(%rip), %rdi      # 0x1f421
xorl %eax, %eax
callq 0xadcf
movl $0x5, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/adsr[P]phpspy/event_fout.c
// Function: event_handler_fout_write
static int event_handler_fout_write(event_handler_fout_udata_t *udata) {
    int rv;
    ssize_t write_len;

    rv = PHPSPY_OK;
    write_len = (udata->cur - udata->buf);

    if (write_len < 1) {
        /* nothing to write */
        return rv;
    }

    if (udata->use_mutex) {
        pthread_mutex_lock(&event_handler_fout_mutex);
    }

    if (write(udata->fd, udata->buf, write_len) != write_len) {
        log_error("event_handler_fout: Write failed (%s)\n", errno != 0 ? strerror(errno) : "partial");
        rv = PHPSPY_ERR;
    }

    if (udata->use_mutex) {
        pthread_mutex_unlock(&event_handler_fout_mutex);
    }

    return rv;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
subq 0x8(%rdi), %r14
testq %r14, %r14
jle 0x1a19d
movq %rdi, %rbx
cmpl $0x0, 0x28(%rdi)
je 0x1a173
leaq 0xc512(%rip), %rdi      # 0x26680
callq 0x6620
movl (%rbx), %edi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0x6120
xorl %ebp, %ebp
cmpq %r14, %rax
je 0x1a1bb
callq 0x6060
movl (%rax), %edi
testl %edi, %edi
je 0x1a1a1
callq 0x65d0
movq %rax, %rsi
jmp 0x1a1a8
xorl %ebp, %ebp
jmp 0x1a1cd
leaq 0x5271(%rip), %rsi      # 0x1f419
leaq 0x5243(%rip), %rdi      # 0x1f3f2
xorl %eax, %eax
callq 0xadcf
movl $0x1, %ebp
cmpl $0x0, 0x28(%rbx)
je 0x1a1cd
leaq 0xc4b8(%rip), %rdi      # 0x26680
callq 0x63d0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %esi, %esi
jle 0x258e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %r14d
xorl %r15d, %r15d
leaq 0x17ae8(%rip), %r12     # 0x1a030
testq %r15, %r15
je 0x256d
movl %r15d, %eax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
shrq $0x25, %rax
imull $-0x64, %eax, %eax
addl %r15d, %eax
jne 0x256d
movl $0xa, %edi
callq 0x1040
movsbq (%rbx,%r15), %rax
movl (%r12,%rax,4), %edi
callq 0x1040
incq %r15
cmpq %r15, %r14
jne 0x2548
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xa, %edi
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/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
testq %rax, %rax
je 0x8193
movq %rax, %r15
leaq 0x4(%rsp), %r12
xorl %ebp, %ebp
leaq (%r14,%rbp), %r13
movq %r15, %rdx
subq %rbp, %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x81a8
testq %rax, %rax
je 0x8193
cmpl %ebx, 0x4(%rsp)
je 0x8196
addq %rax, %rbp
cmpq %r15, %rbp
jb 0x816b
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_O1/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 0x2b4(%rip), %rcx       # 0x1488
movl $0x4, %edx
callq 0x1060
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x120a
xorl %ecx, %ecx
xorl %r14d, %r14d
testq %rcx, %rcx
je 0x11fd
movq (%rbx), %rdx
movl (%rdx,%rcx,4), %esi
cmpl -0x4(%rdx,%rcx,4), %esi
je 0x1200
incl %r14d
incq %rcx
cmpq %rcx, %rax
jne 0x11ec
jmp 0x120d
xorl %r14d, %r14d
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_O1/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
movl $0x20, %edi
callq 0x1090
movq %rax, %rbx
movl $0x18, %edi
callq 0x1090
movq %rax, %r14
movq %rax, %rdi
callq 0x1d08
movq $0x0, 0x14(%rbx)
movq %r14, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x10, %edi
callq 0x1090
movq %rax, %r15
movl $0x18, %edi
callq 0x1090
movq %rax, -0x38(%rbp)
movq %rax, %rdi
callq 0x1d08
movq $0x0, 0x8(%r15)
movq %r15, %rdi
movl %ebx, %esi
callq 0x1c62
movq 0x20(%r12), %rax
movslq %ebx, %rcx
movl %r14d, (%rax,%rcx,4)
cmpq $0x0, 0x8(%r15)
je 0x1377
movq %r15, -0x48(%rbp)
movq (%r15), %rax
movslq 0x10(%rax), %rcx
movq 0x8(%r12), %rax
movq %rcx, -0x40(%rbp)
leaq (%rcx,%rcx,2), %r13
cmpq $0x0, 0x10(%rax,%r13,8)
je 0x1351
leaq (%rax,%r13,8), %rax
xorl %r15d, %r15d
xorl %ebx, %ebx
movq 0x20(%r12), %rcx
movq (%rax), %rdx
movslq (%rdx,%r15,4), %rax
movl (%rcx,%rax,4), %esi
testl %esi, %esi
je 0x1321
cmpl %r14d, %esi
jne 0x1337
movl 0x2c(%r12), %esi
imull -0x40(%rbp), %esi
addl %eax, %esi
movq -0x38(%rbp), %rdi
callq 0x1dae
jmp 0x1337
movl %r14d, (%rcx,%rax,4)
movl (%rdx,%r15,4), %esi
movq -0x48(%rbp), %rdi
callq 0x1c62
movl $0x1, %ebx
incq %r15
movq 0x8(%r12), %rax
leaq (%rax,%r13,8), %rax
cmpq %r15, 0x10(%rax)
ja 0x12f3
testl %ebx, %ebx
movq -0x48(%rbp), %r15
jne 0x136c
movq -0x30(%rbp), %rax
incl 0x14(%rax)
movq (%rax), %rdi
movq -0x40(%rbp), %rsi
callq 0x1dae
movq %r15, %rdi
callq 0x1c20
cmpq $0x0, 0x8(%r15)
jne 0x12ce
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_O1/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 0x13b2
movl $0x2, 0x10(%rdi)
jmp 0x13c6
testl %eax, %eax
je 0x13bf
movl $0x1, 0x10(%rdi)
jmp 0x13c6
movl $0x0, 0x10(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq $0x0, 0x10(%rdi)
je 0x13e9
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rdi), %rax
movq %rsi, 0x8(%rax)
movq $0x0, 0x8(%rsi)
movq %rsi, 0x18(%rdi)
popq %rbp
retq
movq %rsi, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movq $0x0, 0x8(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1225
movq %rax, %r14
movl %r12d, %edi
movq %rbx, %rsi
movq %rax, %rdx
movl %r15d, %ecx
callq 0x1261
movl 0x18(%r14), %eax
cmpl 0x14(%r14), %eax
jle 0x143b
movl $0x2, 0x10(%r14)
jmp 0x1451
testl %eax, %eax
je 0x1449
movl $0x1, 0x10(%r14)
jmp 0x1451
movl $0x0, 0x10(%r14)
cmpq $0x0, 0x10(%rbx)
je 0x146e
movq 0x18(%rbx), %rax
movq %r14, 0x8(%rax)
movq $0x0, 0x8(%r14)
movq %r14, 0x18(%rbx)
jmp 0x147e
movq %r14, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movq $0x0, 0x8(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xa71(%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 0x1ca8
testl %eax, %eax
je 0x15e4
movq %r14, %rdi
callq 0x1492
testl %eax, %eax
je 0x15ec
movslq 0x2c(%r14), %rdi
shlq $0x2, %rdi
callq 0x1090
movq %rax, 0x20(%r14)
xorl %ebx, %ebx
testq %rax, %rax
setne %bl
jmp 0x15ec
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_O1/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 0x1837
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
testq %r14, %r14
jne 0x1810
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x0, 0x2c(%rbx)
jle 0x1887
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x1030
movq 0x8(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x1030
incq %r15
movslq 0x2c(%rbx), %rax
addq $0x18, %r14
cmpq %rax, %r15
jl 0x185e
movq (%rbx), %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1800
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1030
nop
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x38, %edi
callq 0x1090
movq %rax, %rbx
movl $0x0, 0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %rax, %rdi
callq 0x157a
testl %eax, %eax
jne 0x18e8
xorl %edi, %edi
callq 0x17d4
movq %rbx, %rdi
callq 0x16cf
testl %eax, %eax
jne 0x18fe
movl $0x1, %edi
callq 0x17d4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq %rdx, -0x30(%rbp)
movq %rsi, %r14
movl %edi, %r12d
movl $0x10, %edi
callq 0x1090
movq %rax, %r15
movq $0x0, 0x8(%rax)
movq %rax, %rdi
movl %r12d, %esi
callq 0x1c62
cmpq $0x0, 0x8(%r15)
je 0x19b9
movq (%r15), %rax
movslq 0x10(%rax), %r12
movq 0x20(%r14), %rax
movl $0x1, (%rax,%r12,4)
movq (%r14), %rax
leaq (%r12,%r12,2), %r13
cmpq $0x0, 0x10(%rax,%r13,8)
je 0x19a3
leaq (%rax,%r13,8), %rcx
xorl %ebx, %ebx
xorl %eax, %eax
movq 0x20(%r14), %rdx
movq (%rcx), %rcx
movslq (%rcx,%rbx,4), %rsi
cmpl $0x0, (%rdx,%rsi,4)
jne 0x198f
movq %r15, %rdi
callq 0x1c62
movl $0x1, %eax
incq %rbx
movq (%r14), %rcx
leaq (%rcx,%r13,8), %rcx
cmpq %rbx, 0x10(%rcx)
ja 0x1971
testl %eax, %eax
jne 0x1940
movq -0x30(%rbp), %rdi
movl %r12d, %esi
callq 0x1c62
movq %r15, %rdi
callq 0x1c20
jmp 0x1940
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x10, %edi
callq 0x1090
movq %rax, %r14
movq $0x0, 0x8(%rax)
movq 0x20(%rbx), %rdi
movslq 0x2c(%rbx), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x1080
cmpl $0x0, 0x2c(%rbx)
jle 0x1a32
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
cmpl $0x0, (%rax,%r15,4)
jne 0x1a26
movl %r15d, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1908
incq %r15
movslq 0x2c(%rbx), %rax
cmpq %rax, %r15
jl 0x1a0d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1a94
movq 0x20(%r14), %rax
movq (%rbx), %rcx
movslq 0x10(%rcx), %rsi
cmpl $0x0, (%rax,%rsi,4)
jne 0x1a8a
movl 0x28(%r14), %edx
incl %edx
movl %edx, 0x28(%r14)
movq %r14, %rdi
callq 0x13fa
movq %rbx, %rdi
callq 0x1c20
jmp 0x1a60
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x18b4
movq %rax, %rbx
movq %rax, %rdi
callq 0x1a99
movq %rbx, %rdi
callq 0x1af4
movq %rbx, %rdi
callq 0x183c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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), %rbx
movl 0x28(%rdi), %esi
cmpl $0x1, %esi
jne 0x1b1e
leaq 0x535(%rip), %rdi       # 0x204a
xorl %eax, %eax
callq 0x1070
jmp 0x1b2c
leaq 0x55c(%rip), %rdi       # 0x2081
xorl %eax, %eax
callq 0x1070
testq %rbx, %rbx
je 0x1c0f
leaq 0x5d8(%rip), %r14       # 0x2114
leaq 0x5a0(%rip), %r12       # 0x20e3
leaq 0x5ce(%rip), %r13       # 0x2118
movl 0x10(%rbx), %eax
cmpl $0x1, %eax
je 0x1b7d
testl %eax, %eax
jne 0x1bbc
leaq 0x55e(%rip), %rdi       # 0x20bb
xorl %eax, %eax
callq 0x1070
movq (%rbx), %rax
movq (%rax), %rax
movl (%rax), %esi
incl %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x1070
jmp 0x1c02
movl 0x14(%rbx), %esi
leaq 0x560(%rip), %rdi       # 0x20e7
xorl %eax, %eax
callq 0x1070
movq (%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x1bf8
xorl %r15d, %r15d
movq (%rax), %rax
movl (%rax,%r15,4), %esi
incl %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1070
incq %r15
movq (%rbx), %rax
cmpq %r15, 0x10(%rax)
ja 0x1b9b
jmp 0x1bf8
movl 0x14(%rbx), %edx
movl 0x18(%rbx), %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x1070
movq (%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x1bf8
xorl %r15d, %r15d
movq (%rax), %rax
movl (%rax,%r15,4), %esi
incl %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1070
incq %r15
movq (%rbx), %rax
cmpq %r15, 0x10(%rax)
ja 0x1bd9
movl $0xa, %edi
callq 0x1040
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x1b4a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x72, %edi
jle 0x3958
cmpl $0x7a, %edi
jg 0x397a
cmpl $0x73, %edi
je 0x39ad
cmpl $0x74, %edi
jne 0x39c6
movl $0xb, %ebx
jmp 0x3a27
leal -0x5b(%rdi), %eax
cmpl $0x13, %eax
ja 0x398e
leaq 0x16805(%rip), %rcx     # 0x1a16c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xe, %ebx
jmp 0x3a27
cmpl $0x7b, %edi
je 0x39b4
cmpl $0x7d, %edi
jne 0x39c6
movl $0x11, %ebx
jmp 0x3a27
leal -0x28(%rdi), %eax
cmpl $0x7, %eax
ja 0x39bb
leaq 0x167af(%rip), %rcx     # 0x1a14c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xc, %ebx
jmp 0x3a27
movl $0x9, %ebx
jmp 0x3a27
movl $0x10, %ebx
jmp 0x3a27
testl %edi, %edi
jne 0x39c6
movl $0x12, %ebx
jmp 0x3a27
leaq 0x16c66(%rip), %rdi     # 0x1a633
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x8f21
jmp 0x3a27
movl $0xa, %ebx
jmp 0x3a27
movl $0xf, %ebx
jmp 0x3a27
movl $0x8, %ebx
jmp 0x3a27
movl $0x4, %ebx
jmp 0x3a27
movl $0x7, %ebx
jmp 0x3a27
movl $0x5, %ebx
jmp 0x3a27
movl $0x6, %ebx
jmp 0x3a27
xorl %ebx, %ebx
jmp 0x3a27
movl $0x3, %ebx
jmp 0x3a27
movl $0x2, %ebx
jmp 0x3a27
movl $0x1, %ebx
jmp 0x3a27
movl $0xd, %ebx
movl %ebx, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x72a5
movq %rdx, %r15
movq %rsi, %r12
xorl %r14d, %r14d
leaq (%r15,%r14), %rcx
movq %rbx, %rdi
movl $0x1, %esi
movq %r12, %rdx
xorl %eax, %eax
callq 0x941f
addq $0x8, %r14
cmpq $0x28, %r14
jne 0x7283
jmp 0x72f3
movq %rcx, %r14
movq %rsp, %r15
xorl %r12d, %r12d
movl $0xc8, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x20d0
movq %r15, %rdi
movl $0xc8, %esi
movq %rbx, %rdx
callq 0x2120
movq %rax, %rdi
callq 0x8e6c
leaq (%r14,%r12), %rdi
movl $0x64, %edx
movq %r15, %rsi
callq 0x2040
addq $0x64, %r12
cmpq $0x1f4, %r12            # imm = 0x1F4
jne 0x72bd
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1674c(%rip), %rdi     # 0x1da7e
callq 0x8fb6
movq %rax, %r15
movq %r12, %rdi
movl $0xc8, %esi
movq %rbx, %rdx
callq 0x2120
movq %rax, %rdi
callq 0x8e6c
movl $0x6c666e69, %eax       # imm = 0x6C666E69
xorl (%r12), %eax
movl $0x776f6c, %ecx         # imm = 0x776F6C
xorl 0x3(%r12), %ecx
orl %eax, %ecx
je 0x738e
movabsq $0x776f6c6674756f, %rax # imm = 0x776F6C6674756F
cmpq %rax, (%rsp)
jne 0x73bf
movq 0x3b8(%r14), %rax
movl %ebp, %ecx
movl $0x1, (%rax,%rcx,4)
jmp 0x7470
movq 0x3b8(%r14), %rax
movl %ebp, %ecx
movl $0x0, (%rax,%rcx,4)
leaq (%rcx,%rcx,2), %rdx
shlq $0x4, %rdx
addq 0x3c8(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x7264
jmp 0x7470
movabsq $0x6c61772070696c73, %rax # imm = 0x6C61772070696C73
xorq (%rsp), %rax
movzwl 0x8(%rsp), %ecx
xorq $0x6c, %rcx
orq %rax, %rcx
je 0x7426
movabsq $0x772070696c736f6e, %rax # imm = 0x772070696C736F6E
xorq (%rsp), %rax
movl 0x8(%rsp), %ecx
xorq $0x6c6c61, %rcx         # imm = 0x6C6C61
orq %rax, %rcx
je 0x7438
movabsq $0x6369646f69726570, %rax # imm = 0x6369646F69726570
xorq (%rsp), %rax
movzbl 0x8(%rsp), %ecx
orq %rax, %rcx
je 0x7480
leaq 0x15927(%rip), %rdi     # 0x1cd3f
movq %rsp, %rdx
movl %ebp, %esi
xorl %eax, %eax
callq 0x8fba
jmp 0x7470
movq 0x3b8(%r14), %rax
movl %ebp, %ecx
movl $0x2, (%rax,%rcx,4)
jmp 0x7448
movq 0x3b8(%r14), %rax
movl %ebp, %ecx
movl $0x3, (%rax,%rcx,4)
movq 0x3c8(%r14), %rax
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
addq %rax, %rcx
addq $0x28, %rcx
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0x941f
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 0x7470
// File: /workspace/github_c_makefile_star2_O1/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 0x78a2
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x153f8(%rip), %rcx     # 0x1cb60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x15c33(%rip), %rdi     # 0x1d3ab
movl $0x16, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2200
movq 0x3c8(%r14), %rax
shlq $0x4, %r15
leaq (%r15,%r15,2), %r15
movsd (%rax,%r15), %xmm0
leaq 0x15865(%rip), %rsi     # 0x1d00b
movq %rbx, %rdi
movb $0x1, %al
callq 0x2150
movq 0x3c8(%r14), %rax
movsd 0x8(%rax,%r15), %xmm0
leaq 0x15bfd(%rip), %rsi     # 0x1d3c2
movq %rbx, %rdi
movb $0x1, %al
callq 0x2150
movq 0x3c8(%r14), %rax
movsd 0x10(%rax,%r15), %xmm0
leaq 0x15bf0(%rip), %rsi     # 0x1d3d4
movq %rbx, %rdi
movb $0x1, %al
callq 0x2150
movq 0x3c8(%r14), %rax
movsd 0x18(%rax,%r15), %xmm0
leaq 0x15be3(%rip), %rsi     # 0x1d3e6
movq %rbx, %rdi
movb $0x1, %al
callq 0x2150
movq 0x3c8(%r14), %rax
movsd 0x20(%rax,%r15), %xmm0
leaq 0x15bd6(%rip), %rsi     # 0x1d3f8
jmp 0x7875
leaq 0x15c2b(%rip), %rdi     # 0x1d456
movl $0x18, %esi
jmp 0x7890
leaq 0x15be7(%rip), %rdi     # 0x1d420
movl $0x19, %esi
jmp 0x784c
leaq 0x15bf3(%rip), %rdi     # 0x1d43a
movl $0x1b, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2200
movq 0x3c8(%r14), %rax
leaq (%r15,%r15,2), %rcx
shlq $0x4, %rcx
movsd 0x28(%rax,%rcx), %xmm0
leaq 0x157a5(%rip), %rsi     # 0x1d01a
movq %rbx, %rdi
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
jmp 0x2150
leaq 0x15b7d(%rip), %rdi     # 0x1d408
movl $0x17, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x2200
leaq 0x15bc6(%rip), %rdi     # 0x1d46f
movl %edx, %esi
movl %eax, %edx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x8fba
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: Eigenvalue
void Eigenvalue(const int s, const Real Uo[restrict], Real Lambda[restrict])
{
    Lambda[0] = Uo[s+1] - Uo[5];
    Lambda[1] = Uo[s+1];
    Lambda[2] = Uo[s+1];
    Lambda[3] = Uo[s+1];
    Lambda[4] = Uo[s+1] + Uo[5];
    return;
}

// Assembly:
movslq %edi, %rax
movsd 0x8(%rsi,%rax,8), %xmm0
movsd 0x28(%rsi), %xmm1
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
movsd %xmm2, (%rdx)
movsd %xmm0, 0x8(%rdx)
movsd %xmm0, 0x10(%rdx)
movsd %xmm0, 0x18(%rdx)
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rdx)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x159e2(%rip), %xmm3    # 0x1d5c0
addsd 0x159ca(%rip), %xmm4    # 0x1d5b0
movapd %xmm5, %xmm6
addsd %xmm5, %xmm6
mulsd %xmm6, %xmm5
divsd %xmm5, %xmm4
movsd 0x1240a(%rip), %xmm5    # 0x1a008
divsd %xmm6, %xmm5
movslq %edi, %rax
leaq 0x1d084(%rip), %rcx     # 0x24c90
movq (%rcx,%rax,8), %rax
movq %rdx, %rdi
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/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 0x1596a(%rip), %xmm5    # 0x1d5c0
movslq %edi, %rax
leaq 0x1d050(%rip), %rcx     # 0x24cb0
movq (%rcx,%rax,8), %rax
movq %rdx, %rdi
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/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:
movapd %xmm0, %xmm6
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm4
movapd %xmm4, %xmm1
divsd %xmm0, %xmm1
movsd 0x10(%rsi), %xmm7
movapd %xmm7, %xmm2
divsd %xmm0, %xmm2
movsd 0x18(%rsi), %xmm5
movapd %xmm5, %xmm3
divsd %xmm0, %xmm3
movsd 0x20(%rsi), %xmm8
mulsd %xmm7, %xmm7
mulsd %xmm4, %xmm4
addsd %xmm7, %xmm4
mulsd %xmm5, %xmm5
addsd %xmm4, %xmm5
mulsd 0x158fe(%rip), %xmm5    # 0x1d5b8
divsd %xmm0, %xmm5
addsd %xmm8, %xmm5
movapd %xmm8, %xmm4
addsd 0x158e0(%rip), %xmm6    # 0x1d5b0
divsd %xmm0, %xmm4
mulsd %xmm6, %xmm5
movslq %edi, %rax
leaq 0x1cfee(%rip), %rcx     # 0x24cd0
movq (%rcx,%rax,8), %rax
movq %rdx, %rdi
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/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:
movsd (%rdi), %xmm2
movsd %xmm2, (%rsi)
movsd 0x8(%rdi), %xmm3
movapd %xmm3, %xmm4
divsd %xmm2, %xmm4
movsd %xmm4, 0x8(%rsi)
movsd 0x10(%rdi), %xmm4
movapd %xmm4, %xmm5
divsd %xmm2, %xmm5
movsd %xmm5, 0x10(%rsi)
movsd 0x18(%rdi), %xmm5
movapd %xmm5, %xmm6
mulsd %xmm4, %xmm4
mulsd %xmm3, %xmm3
addsd %xmm4, %xmm3
mulsd %xmm5, %xmm5
addsd %xmm3, %xmm5
mulsd 0x15804(%rip), %xmm5    # 0x1d5b8
divsd %xmm2, %xmm6
divsd %xmm2, %xmm5
addsd 0x20(%rdi), %xmm5
movsd %xmm6, 0x18(%rsi)
addsd 0x157e2(%rip), %xmm0    # 0x1d5b0
mulsd %xmm5, %xmm0
movsd %xmm0, 0x20(%rsi)
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 (%rdi), %xmm1
movsd %xmm1, (%rsi)
movsd 0x8(%rdi), %xmm2
movapd %xmm1, %xmm3
mulsd %xmm2, %xmm3
movsd %xmm3, 0x8(%rsi)
movsd 0x10(%rdi), %xmm3
movapd %xmm1, %xmm4
mulsd %xmm3, %xmm4
movsd %xmm4, 0x10(%rsi)
movsd 0x18(%rdi), %xmm4
movapd %xmm1, %xmm5
mulsd %xmm4, %xmm5
movsd %xmm5, 0x18(%rsi)
mulsd 0x15750(%rip), %xmm1    # 0x1d5c0
mulsd %xmm3, %xmm3
mulsd %xmm2, %xmm2
addsd %xmm3, %xmm2
mulsd %xmm4, %xmm4
addsd %xmm2, %xmm4
mulsd %xmm1, %xmm4
addsd 0x15720(%rip), %xmm0    # 0x1d5b0
movsd 0x20(%rdi), %xmm1
divsd %xmm0, %xmm1
addsd %xmm4, %xmm1
movsd %xmm1, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7ed2
cmpl %edi, 0x14(%rcx)
jle 0x7ed2
cmpl %esi, 0x8(%rcx)
jg 0x7ed2
cmpl %esi, 0xc(%rcx)
jle 0x7ed2
cmpl %edx, (%rcx)
jg 0x7ed2
xorl %eax, %eax
cmpl %edx, 0x4(%rcx)
setg %al
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1210f(%rip), %xmm2    # 0x1a040
movl $0x1, %eax
movsd 0x156aa(%rip), %xmm3    # 0x1d5e8
ucomisd %xmm2, %xmm3
jae 0x7f69
movapd 0x120f4(%rip), %xmm3    # 0x1a040
andpd %xmm3, %xmm0
andpd %xmm3, %xmm1
maxsd %xmm1, %xmm0
mulsd 0x15690(%rip), %xmm0    # 0x1d5f0
xorl %eax, %eax
ucomisd %xmm2, %xmm0
setae %al
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8(%rsi), %xmm0
movsd 0x10(%rsi), %xmm1
movsd 0x8(%rdi), %xmm2
movsd 0x10(%rdi), %xmm3
movapd %xmm2, %xmm4
mulsd %xmm1, %xmm4
movsd (%rdi), %xmm5
mulsd %xmm5, %xmm1
mulsd %xmm0, %xmm5
mulsd %xmm3, %xmm0
subsd %xmm0, %xmm4
movsd %xmm4, (%rdx)
movsd (%rsi), %xmm0
mulsd %xmm0, %xmm3
subsd %xmm1, %xmm3
movsd %xmm3, 0x8(%rdx)
mulsd %xmm2, %xmm0
subsd %xmm0, %xmm5
movsd %xmm5, 0x10(%rdx)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movsd 0x10(%rdi), %xmm3
movapd 0x11f7f(%rip), %xmm0    # 0x1a040
movapd %xmm3, %xmm1
andpd %xmm0, %xmm1
movsd 0x8(%rdi), %xmm4
movapd %xmm4, %xmm2
andpd %xmm0, %xmm2
xorl %ecx, %ecx
ucomisd %xmm2, %xmm1
setbe %cl
movsd (%rdi), %xmm5
incl %ecx
movsd (%rdi,%rcx,8), %xmm1
andpd %xmm0, %xmm1
andpd %xmm5, %xmm0
xorl %eax, %eax
ucomisd %xmm0, %xmm1
cmovbel %ecx, %eax
cmpl $0x1, %eax
je 0x8123
testl %eax, %eax
jne 0x813e
movq $0x0, (%r14)
movapd 0x154fd(%rip), %xmm0    # 0x1d610
xorpd %xmm3, %xmm0
movlpd %xmm0, 0x8(%r14)
movapd %xmm4, %xmm0
jmp 0x8159
movsd %xmm3, (%r14)
movq $0x0, 0x8(%r14)
movapd 0x154d8(%rip), %xmm0    # 0x1d610
xorpd %xmm5, %xmm0
jmp 0x8159
movapd 0x154ca(%rip), %xmm0    # 0x1d610
xorpd %xmm4, %xmm0
movlpd %xmm0, (%r14)
movsd %xmm5, 0x8(%r14)
xorpd %xmm0, %xmm0
movsd %xmm0, 0x10(%r14)
movsd (%r14), %xmm1
movsd 0x8(%r14), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x818e
sqrtsd %xmm0, %xmm0
jmp 0x81b5
movapd %xmm3, 0x20(%rsp)
movapd %xmm4, 0x10(%rsp)
movapd %xmm5, (%rsp)
callq 0x2210
movapd (%rsp), %xmm5
movapd 0x10(%rsp), %xmm4
movapd 0x20(%rsp), %xmm3
xorl %eax, %eax
movsd (%r14,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r14,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x81b7
movsd 0x8(%r14), %xmm0
movsd 0x10(%r14), %xmm1
movapd %xmm4, %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm5, %xmm1
mulsd %xmm0, %xmm5
mulsd %xmm3, %xmm0
subsd %xmm2, %xmm0
movsd %xmm0, (%rbx)
movsd (%r14), %xmm0
mulsd %xmm0, %xmm3
subsd %xmm3, %xmm1
movsd %xmm1, 0x8(%rbx)
mulsd %xmm4, %xmm0
subsd %xmm5, %xmm0
movsd %xmm0, 0x10(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: LocalLaxFriedrichs
static void LocalLaxFriedrichs(const Real Lambda[restrict],
        Real LambdaP[restrict], Real LambdaN[restrict])
{
    /* set local maximum as (|Vs| + c) */
    const Real lambdaStar = fabs(Lambda[2]) + Lambda[4] - Lambda[2];
    for (int r = 0; r < DIMU; ++r) {
        LambdaP[r] = 0.5 * (Lambda[r] + lambdaStar);
        LambdaN[r] = 0.5 * (Lambda[r] - lambdaStar);
    }
    return;
}

// Assembly:
movsd 0x10(%rdi), %xmm1
movapd 0x11df5(%rip), %xmm0    # 0x1a040
andpd %xmm1, %xmm0
addsd 0x20(%rdi), %xmm0
subsd %xmm1, %xmm0
xorl %eax, %eax
movsd 0x1535e(%rip), %xmm1    # 0x1d5c0
movsd (%rdi,%rax,8), %xmm2
movapd %xmm0, %xmm3
addsd %xmm2, %xmm3
mulsd %xmm1, %xmm3
movsd %xmm3, (%rsi,%rax,8)
subsd %xmm0, %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, (%rdx,%rax,8)
incq %rax
cmpq $0x5, %rax
jne 0x8262
retq
// File: /workspace/github_c_makefile_star2_O1/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: StegerWarming
static void StegerWarming(const Real Lambda[restrict],
        Real LambdaP[restrict], Real LambdaN[restrict])
{
    const Real epsilon = 1.0e-3;
    for (int r = 0; r < DIMU; ++r) {
        LambdaP[r] = 0.5 * (Lambda[r] + sqrt(Lambda[r] * Lambda[r] + epsilon * epsilon));
        LambdaN[r] = 0.5 * (Lambda[r] - sqrt(Lambda[r] * Lambda[r] + epsilon * epsilon));
    }
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
xorpd %xmm1, %xmm1
movsd 0x1530e(%rip), %xmm2    # 0x1d5c0
movsd (%r15,%r12,8), %xmm3
movapd %xmm3, %xmm4
mulsd %xmm3, %xmm4
addsd 0x15330(%rip), %xmm4    # 0x1d5f8
xorps %xmm5, %xmm5
sqrtsd %xmm4, %xmm5
ucomisd %xmm1, %xmm4
movapd %xmm5, %xmm0
movsd %xmm3, (%rsp)
jae 0x8310
movapd %xmm4, %xmm0
movsd %xmm4, 0x10(%rsp)
movsd %xmm5, 0x8(%rsp)
callq 0x2210
movsd 0x8(%rsp), %xmm5
movsd 0x10(%rsp), %xmm4
movsd (%rsp), %xmm3
movsd 0x152b4(%rip), %xmm2    # 0x1d5c0
xorpd %xmm1, %xmm1
addsd %xmm3, %xmm0
mulsd %xmm2, %xmm0
movsd %xmm0, (%r14,%r12,8)
ucomisd %xmm1, %xmm4
jae 0x8342
movapd %xmm4, %xmm0
callq 0x2210
movsd (%rsp), %xmm3
movsd 0x15286(%rip), %xmm2    # 0x1d5c0
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm5
subsd %xmm5, %xmm3
mulsd %xmm2, %xmm3
movsd %xmm3, (%rbx,%r12,8)
incq %r12
cmpq $0x5, %r12
jne 0x82b2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq