LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x19178
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 0x191c1
leaq 0x5ff2(%rip), %rdi      # 0x1f1a7
xorl %eax, %eax
callq 0xab99
jmp 0x19248
leaq 0x5690(%rip), %rsi      # 0x1e858
leaq 0x20(%rsp), %rdi
callq 0x6510
testq %rax, %rax
je 0x19260
movq %rax, %r14
movq %rbx, %rdi
movl $0xff, %esi
movq %rax, %rdx
callq 0x62c0
testq %rax, %rax
je 0x1922d
movq %r14, %rdi
callq 0x61c0
movq %rbx, %rdi
callq 0x6160
testl %eax, %eax
jle 0x19218
movl %eax, %ecx
cmpb $0xa, -0x1(%rbx,%rcx)
jne 0x19258
leal -0x1(%rcx), %eax
cmpl $0x1, %ecx
jg 0x19207
leaq 0x5fc0(%rip), %rdi      # 0x1f1df
leaq 0x20(%rsp), %rsi
xorl %eax, %eax
callq 0xab99
jmp 0x19248
leaq 0x5f87(%rip), %rdi      # 0x1f1bb
leaq 0x20(%rsp), %rsi
xorl %eax, %eax
callq 0xab99
movq %r14, %rdi
callq 0x61c0
movl $0x1, %eax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
retq
movb $0x0, (%rbx,%rcx)
xorl %eax, %eax
jmp 0x1924d
leaq 0x5abc(%rip), %rdi      # 0x1ed23
callq 0x6530
jmp 0x19248
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x19914
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 0x199ad
movl %eax, %ecx
movq (%r14), %rdx
cmpq %rcx, %rdx
jbe 0x199ad
testl %ebp, %ebp
sete %sil
testl %eax, %eax
sete %al
orb %sil, %al
jne 0x1999d
leaq 0xb9de(%rip), %rax      # 0x25345
movb (%rax), %sil
leaq 0xb9d3(%rip), %rdx      # 0x25344
movb (%rdx), %r8b
xorl %edi, %edi
movq (%r15), %r9
movb (%r9,%rdi), %r10b
cmpb %sil, %r10b
je 0x19987
cmpb %r8b, %r10b
jne 0x19992
movb $0x3f, (%r9,%rdi)
movb (%rax), %sil
movb (%rdx), %r8b
incq %rdi
cmpq %rdi, %rcx
jne 0x19976
movq (%r14), %rdx
addq %rcx, (%r15)
subq %rcx, %rdx
movq %rdx, (%r14)
movq %rcx, (%rbx)
xorl %eax, %eax
jmp 0x199c0
leaq 0x5a65(%rip), %rdi      # 0x1f419
xorl %eax, %eax
callq 0xab99
movl $0x5, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8(%rdi), %rsi
movq 0x10(%rdi), %r14
subq %rsi, %r14
testq %r14, %r14
jle 0x19a21
movq %rdi, %rbx
cmpl $0x0, 0x28(%rdi)
je 0x199fb
leaq 0xcc8e(%rip), %rdi      # 0x26680
callq 0x6620
movq 0x8(%rbx), %rsi
movl (%rbx), %edi
movq %r14, %rdx
callq 0x6120
xorl %ebp, %ebp
cmpq %r14, %rax
je 0x19a3f
callq 0x6060
movl (%rax), %edi
testl %edi, %edi
je 0x19a25
callq 0x65d0
movq %rax, %rsi
jmp 0x19a2c
xorl %ebp, %ebp
jmp 0x19a51
leaq 0x59e5(%rip), %rsi      # 0x1f411
leaq 0x59b7(%rip), %rdi      # 0x1f3ea
xorl %eax, %eax
callq 0xab99
movl $0x1, %ebp
cmpl $0x0, 0x28(%rbx)
je 0x19a51
leaq 0xcc34(%rip), %rdi      # 0x26680
callq 0x63d0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x24fe
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %r14d
xorl %r15d, %r15d
leaq 0x18b78(%rip), %r12     # 0x1b030
testq %r15, %r15
je 0x24dd
movl %r15d, %eax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
shrq $0x25, %rax
imull $-0x64, %eax, %eax
addl %r15d, %eax
jne 0x24dd
movl $0xa, %edi
callq 0x1040
movsbq (%rbx,%r15), %rax
movl (%r12,%rax,4), %edi
callq 0x1040
incq %r15
cmpq %r15, %r14
jne 0x24b8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xa, %edi
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O3/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 0x8659
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 0x866e
testq %rax, %rax
je 0x8659
cmpl %ebx, 0x4(%rsp)
je 0x865c
addq %rax, %rbp
cmpq %r15, %rbp
jb 0x8631
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_O3/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 0x2bc(%rip), %rcx       # 0x1490
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_O3/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, -0x40(%rbp)
movq %rsi, %r12
movl %edi, %ebx
movl $0x10, %edi
callq 0x1090
movq %rax, %r15
movl $0x18, %edi
callq 0x1090
movq %rax, -0x48(%rbp)
movq %rax, %rdi
callq 0x1ccc
movq $0x0, 0x8(%r15)
movq %r15, %rdi
movl %ebx, %esi
callq 0x1c26
movq 0x20(%r12), %rax
movslq %ebx, %rcx
movl %r14d, (%rax,%rcx,4)
cmpq $0x0, 0x8(%r15)
je 0x1387
movq %r15, -0x30(%rbp)
movq (%r15), %rax
movslq 0x10(%rax), %rbx
movq 0x8(%r12), %rax
leaq (%rbx,%rbx,2), %r15
cmpq $0x0, 0x10(%rax,%r15,8)
je 0x135e
leaq (%rax,%r15,8), %rax
movb $0x1, %cl
xorl %r13d, %r13d
movl %ecx, -0x34(%rbp)
movq 0x20(%r12), %rcx
movq (%rax), %rdx
movslq (%rdx,%r13,4), %rax
movl (%rcx,%rax,4), %esi
testl %esi, %esi
je 0x1331
cmpl %r14d, %esi
jne 0x131d
movl 0x2c(%r12), %esi
imull %ebx, %esi
addl %eax, %esi
movq -0x48(%rbp), %rdi
callq 0x1d72
incq %r13
movq 0x8(%r12), %rax
leaq (%rax,%r15,8), %rax
cmpq %r13, 0x10(%rax)
ja 0x12f2
jmp 0x1358
movl %r14d, (%rcx,%rax,4)
movl (%rdx,%r13,4), %esi
movq -0x30(%rbp), %rdi
callq 0x1c26
incq %r13
movq 0x8(%r12), %rax
leaq (%rax,%r15,8), %rax
xorl %ecx, %ecx
cmpq %r13, 0x10(%rax)
ja 0x12ef
jmp 0x1378
testb $0x1, -0x34(%rbp)
je 0x1378
movq -0x40(%rbp), %rax
incl 0x14(%rax)
movq (%rax), %rdi
movl %ebx, %esi
callq 0x1d72
movq -0x30(%rbp), %rdi
callq 0x1be4
movq -0x30(%rbp), %r15
cmpq $0x0, 0x8(%r15)
jne 0x12ce
movq -0x48(%rbp), %rdi
callq 0x11bc
movq -0x40(%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_O3/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 0x13c2
movl $0x2, 0x10(%rdi)
jmp 0x13d6
testl %eax, %eax
je 0x13cf
movl $0x1, 0x10(%rdi)
jmp 0x13d6
movl $0x0, 0x10(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x13f1
movq 0x18(%rdi), %rax
addq $0x18, %rdi
movq %rsi, 0x8(%rax)
jmp 0x13f9
movq %rsi, 0x10(%rdi)
addq $0x18, %rdi
movq %rsi, (%rdi)
movq $0x0, 0x8(%rsi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1447
movl $0x2, 0x10(%r14)
jmp 0x145d
testl %eax, %eax
je 0x1455
movl $0x1, 0x10(%r14)
jmp 0x145d
movl $0x0, 0x10(%r14)
cmpq $0x0, 0x10(%rbx)
je 0x1472
movq 0x18(%rbx), %rax
addq $0x18, %rbx
movq %r14, 0x8(%rax)
jmp 0x147a
movq %r14, 0x10(%rbx)
addq $0x18, %rbx
movq %r14, (%rbx)
movq $0x0, 0x8(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xa9b(%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 0x1c6c
testl %eax, %eax
je 0x15ba
movq %r14, %rdi
callq 0x149a
testl %eax, %eax
je 0x15c2
movslq 0x2c(%r14), %rdi
shlq $0x2, %rdi
callq 0x1090
movq %rax, 0x20(%r14)
xorl %ebx, %ebx
testq %rax, %rax
setne %bl
jmp 0x15c2
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_O3/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 0x17e3
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 0x17bc
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1833
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 0x180a
movq (%rbx), %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x17ac
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1030
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x1550
testl %eax, %eax
jne 0x1894
xorl %edi, %edi
callq 0x1780
movq %rbx, %rdi
callq 0x16a5
testl %eax, %eax
jne 0x18aa
movl $0x1, %edi
callq 0x1780
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1c26
cmpq $0x0, 0x8(%r15)
je 0x197d
movq (%r15), %rax
movslq 0x10(%rax), %r12
movq 0x20(%r14), %rax
movl $0x1, (%rax,%r12,4)
movq (%r14), %rdx
leaq (%r12,%r12,2), %r13
cmpq $0x0, 0x10(%rdx,%r13,8)
je 0x1964
leaq (%rdx,%r13,8), %rcx
movb $0x1, %al
xorl %ebx, %ebx
movq 0x20(%r14), %rdi
leaq (%rdx,%r13,8), %rdx
movq (%rcx), %rcx
movslq (%rcx,%rbx,4), %rsi
cmpl $0x0, (%rdi,%rsi,4)
je 0x1944
incq %rbx
movq %rdx, %rcx
cmpq %rbx, 0x10(%rdx)
ja 0x1929
jmp 0x1960
movq %r15, %rdi
callq 0x1c26
movq (%r14), %rdx
incq %rbx
leaq (%rdx,%r13,8), %rcx
xorl %eax, %eax
cmpq %rbx, 0x10(%rcx)
ja 0x1921
jmp 0x18ec
testb $0x1, %al
je 0x18ec
movq -0x30(%rbp), %rdi
movl %r12d, %esi
callq 0x1c26
movq %r15, %rdi
callq 0x1be4
jmp 0x18ec
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_O3/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
movl 0x2c(%rbx), %eax
testl %eax, %eax
jle 0x19f9
xorl %r15d, %r15d
movq 0x20(%rbx), %rcx
cmpl $0x0, (%rcx,%r15,4)
jne 0x19ee
movl %r15d, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x18b4
movl 0x2c(%rbx), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x19d2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a5b
movq 0x20(%r14), %rax
movq (%rbx), %rcx
movslq 0x10(%rcx), %rsi
cmpl $0x0, (%rax,%rsi,4)
jne 0x1a51
movl 0x28(%r14), %edx
incl %edx
movl %edx, 0x28(%r14)
movq %r14, %rdi
callq 0x1406
movq %rbx, %rdi
callq 0x1be4
jmp 0x1a27
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1860
movq %rax, %rbx
movq %rax, %rdi
callq 0x1a60
movq %rbx, %rdi
callq 0x1ab8
movq %rbx, %rdi
callq 0x17e8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1ae2
leaq 0x571(%rip), %rdi       # 0x204a
xorl %eax, %eax
callq 0x1070
jmp 0x1af0
leaq 0x598(%rip), %rdi       # 0x2081
xorl %eax, %eax
callq 0x1070
testq %rbx, %rbx
je 0x1bd3
leaq 0x614(%rip), %r14       # 0x2114
leaq 0x5dc(%rip), %r12       # 0x20e3
leaq 0x60a(%rip), %r13       # 0x2118
movl 0x10(%rbx), %eax
cmpl $0x1, %eax
je 0x1b41
testl %eax, %eax
jne 0x1b80
leaq 0x59a(%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 0x1bc6
movl 0x14(%rbx), %esi
leaq 0x59c(%rip), %rdi       # 0x20e7
xorl %eax, %eax
callq 0x1070
movq (%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x1bbc
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 0x1b5f
jmp 0x1bbc
movl 0x14(%rbx), %edx
movl 0x18(%rbx), %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x1070
movq (%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x1bbc
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 0x1b9d
movl $0xa, %edi
callq 0x1040
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x1b0e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x37c7
cmpl $0x7a, %edi
jg 0x37e9
cmpl $0x73, %edi
je 0x381c
cmpl $0x74, %edi
jne 0x3835
movl $0xb, %ebx
jmp 0x3896
leal -0x5b(%rdi), %eax
cmpl $0x13, %eax
ja 0x37fd
leaq 0x15996(%rip), %rcx     # 0x1916c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xe, %ebx
jmp 0x3896
cmpl $0x7b, %edi
je 0x3823
cmpl $0x7d, %edi
jne 0x3835
movl $0x11, %ebx
jmp 0x3896
leal -0x28(%rdi), %eax
cmpl $0x7, %eax
ja 0x382a
leaq 0x15940(%rip), %rcx     # 0x1914c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xc, %ebx
jmp 0x3896
movl $0x9, %ebx
jmp 0x3896
movl $0x10, %ebx
jmp 0x3896
testl %edi, %edi
jne 0x3835
movl $0x12, %ebx
jmp 0x3896
leaq 0x15df7(%rip), %rdi     # 0x19633
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x8ce5
jmp 0x3896
movl $0xa, %ebx
jmp 0x3896
movl $0xf, %ebx
jmp 0x3896
movl $0x8, %ebx
jmp 0x3896
movl $0x4, %ebx
jmp 0x3896
movl $0x7, %ebx
jmp 0x3896
movl $0x5, %ebx
jmp 0x3896
movl $0x6, %ebx
jmp 0x3896
xorl %ebx, %ebx
jmp 0x3896
movl $0x3, %ebx
jmp 0x3896
movl $0x2, %ebx
jmp 0x3896
movl $0x1, %ebx
jmp 0x3896
movl $0xd, %ebx
movl %ebx, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x7191
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 0x91dc
addq $0x8, %r14
cmpq $0x28, %r14
jne 0x716f
jmp 0x71df
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 0x8c2c
leaq (%r14,%r12), %rdi
movl $0x64, %edx
movq %r15, %rsi
callq 0x2040
addq $0x64, %r12
cmpq $0x1f4, %r12            # imm = 0x1F4
jne 0x71a9
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x158e0(%rip), %rdi     # 0x1cafe
callq 0x8d7a
movq %rax, %r15
movq %r12, %rdi
movl $0xc8, %esi
movq %rbx, %rdx
callq 0x2120
movq %rax, %rdi
callq 0x8c2c
movl $0x6c666e69, %eax       # imm = 0x6C666E69
xorl (%r12), %eax
movl $0x776f6c, %ecx         # imm = 0x776F6C
xorl 0x3(%r12), %ecx
orl %eax, %ecx
je 0x727a
movabsq $0x776f6c6674756f, %rax # imm = 0x776F6C6674756F
cmpq %rax, (%rsp)
jne 0x72ab
movq 0x3b8(%r14), %rax
movl %ebp, %ecx
movl $0x1, (%rax,%rcx,4)
jmp 0x735c
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 0x7150
jmp 0x735c
movabsq $0x6c61772070696c73, %rax # imm = 0x6C61772070696C73
xorq (%rsp), %rax
movzwl 0x8(%rsp), %ecx
xorq $0x6c, %rcx
orq %rax, %rcx
je 0x7312
movabsq $0x772070696c736f6e, %rax # imm = 0x772070696C736F6E
xorq (%rsp), %rax
movl 0x8(%rsp), %ecx
xorq $0x6c6c61, %rcx         # imm = 0x6C6C61
orq %rax, %rcx
je 0x7324
movabsq $0x6369646f69726570, %rax # imm = 0x6369646F69726570
xorq (%rsp), %rax
movzbl 0x8(%rsp), %ecx
orq %rax, %rcx
je 0x736c
leaq 0x14a3b(%rip), %rdi     # 0x1bd3f
movq %rsp, %rdx
movl %ebp, %esi
xorl %eax, %eax
callq 0x8d7e
jmp 0x735c
movq 0x3b8(%r14), %rax
movl %ebp, %ecx
movl $0x2, (%rax,%rcx,4)
jmp 0x7334
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 0x91dc
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 0x735c
// File: /workspace/github_c_makefile_star2_O3/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 0x778e
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1450c(%rip), %rcx     # 0x1bb60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x14d47(%rip), %rdi     # 0x1c3ab
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 0x14979(%rip), %rsi     # 0x1c00b
movq %rbx, %rdi
movb $0x1, %al
callq 0x2160
movq 0x3c8(%r14), %rax
movsd 0x8(%rax,%r15), %xmm0
leaq 0x14d11(%rip), %rsi     # 0x1c3c2
movq %rbx, %rdi
movb $0x1, %al
callq 0x2160
movq 0x3c8(%r14), %rax
movsd 0x10(%rax,%r15), %xmm0
leaq 0x14d04(%rip), %rsi     # 0x1c3d4
movq %rbx, %rdi
movb $0x1, %al
callq 0x2160
movq 0x3c8(%r14), %rax
movsd 0x18(%rax,%r15), %xmm0
leaq 0x14cf7(%rip), %rsi     # 0x1c3e6
movq %rbx, %rdi
movb $0x1, %al
callq 0x2160
movq 0x3c8(%r14), %rax
movsd 0x20(%rax,%r15), %xmm0
leaq 0x14cea(%rip), %rsi     # 0x1c3f8
jmp 0x7761
leaq 0x14d3f(%rip), %rdi     # 0x1c456
movl $0x18, %esi
jmp 0x777c
leaq 0x14cfb(%rip), %rdi     # 0x1c420
movl $0x19, %esi
jmp 0x7738
leaq 0x14d07(%rip), %rdi     # 0x1c43a
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 0x148b9(%rip), %rsi     # 0x1c01a
movq %rbx, %rdi
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
jmp 0x2160
leaq 0x14c91(%rip), %rdi     # 0x1c408
movl $0x17, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x2200
leaq 0x14cda(%rip), %rdi     # 0x1c46f
movl %edx, %esi
movl %eax, %edx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x8d7e
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x14b2f(%rip), %xmm3    # 0x1c5c0
addsd 0x14b17(%rip), %xmm4    # 0x1c5b0
movapd %xmm5, %xmm6
addsd %xmm5, %xmm6
mulsd %xmm6, %xmm5
divsd %xmm5, %xmm4
movsd 0x11557(%rip), %xmm5    # 0x19008
divsd %xmm6, %xmm5
movslq %edi, %rax
leaq 0x1c201(%rip), %rcx     # 0x23cc0
movq (%rcx,%rax,8), %rax
movq %rdx, %rdi
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/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 0x14ab7(%rip), %xmm5    # 0x1c5c0
movslq %edi, %rax
leaq 0x1c1cd(%rip), %rcx     # 0x23ce0
movq (%rcx,%rax,8), %rax
movq %rdx, %rdi
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/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 0x14a4b(%rip), %xmm5    # 0x1c5b8
divsd %xmm0, %xmm5
addsd %xmm8, %xmm5
movapd %xmm8, %xmm4
addsd 0x14a2d(%rip), %xmm6    # 0x1c5b0
divsd %xmm0, %xmm4
mulsd %xmm6, %xmm5
movslq %edi, %rax
leaq 0x1c16b(%rip), %rcx     # 0x23d00
movq (%rcx,%rax,8), %rax
movq %rdx, %rdi
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/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 0x14964(%rip), %xmm2    # 0x1c5b8
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 0x14931(%rip), %xmm0    # 0x1c5b0
mulsd %xmm2, %xmm0
movsd %xmm0, 0x20(%rsi)
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x148a8(%rip), %xmm4    # 0x1c5c0
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 0x14870(%rip), %xmm0    # 0x1c5b0
movsd 0x20(%rdi), %xmm1
divsd %xmm0, %xmm1
addsd %xmm3, %xmm1
movsd %xmm1, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7d82
cmpl %edi, 0x14(%rcx)
jle 0x7d82
cmpl %esi, 0x8(%rcx)
jg 0x7d82
cmpl %esi, 0xc(%rcx)
jle 0x7d82
cmpl %edx, (%rcx)
jg 0x7d82
xorl %eax, %eax
cmpl %edx, 0x4(%rcx)
setg %al
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1125f(%rip), %xmm2    # 0x19040
movl $0x1, %eax
movsd 0x147fa(%rip), %xmm3    # 0x1c5e8
ucomisd %xmm2, %xmm3
jae 0x7e19
movapd 0x11244(%rip), %xmm3    # 0x19040
andpd %xmm3, %xmm0
andpd %xmm3, %xmm1
maxsd %xmm1, %xmm0
mulsd 0x147e0(%rip), %xmm0    # 0x1c5f0
xorl %eax, %eax
ucomisd %xmm2, %xmm0
setae %al
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movdqu 0x8(%rdi), %xmm0
movdqa 0x11103(%rip), %xmm2    # 0x19040
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 0x7f9e
testl %eax, %eax
jne 0x7fc4
movdqa %xmm0, %xmm4
punpckhqdq %xmm0, %xmm4    # xmm4 = xmm4[1],xmm0[1]
pxor 0x14698(%rip), %xmm4    # 0x1c620
movq $0x0, (%rsi)
movq %xmm4, 0x8(%rsi)
pxor %xmm2, %xmm2
movdqa %xmm0, %xmm3
jmp 0x7fe1
movdqa %xmm0, %xmm2
punpckhqdq %xmm0, %xmm2    # xmm2 = xmm2[1],xmm0[1]
movhpd %xmm0, (%rsi)
movq $0x0, 0x8(%rsi)
movdqa 0x14666(%rip), %xmm3    # 0x1c620
pxor %xmm1, %xmm3
pxor %xmm4, %xmm4
jmp 0x7fe1
movdqa 0x14654(%rip), %xmm2    # 0x1c620
pxor %xmm0, %xmm2
movq %xmm2, (%rsi)
movq %xmm1, 0x8(%rsi)
pxor %xmm3, %xmm3
movdqa %xmm1, %xmm4
movq %xmm3, 0x10(%rsi)
mulsd %xmm4, %xmm4
mulsd %xmm2, %xmm2
addsd %xmm4, %xmm2
mulsd %xmm3, %xmm3
addsd %xmm2, %xmm3
xorps %xmm2, %xmm2
sqrtsd %xmm3, %xmm2
xorl %eax, %eax
movsd (%rsi,%rax,8), %xmm3
divsd %xmm2, %xmm3
movsd %xmm3, (%rsi,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x8003
movsd (%rsi), %xmm2
movupd 0x8(%rsi), %xmm3
movapd %xmm3, %xmm4
shufpd $0x1, %xmm2, %xmm4      # xmm4 = xmm4[1],xmm2[0]
mulpd %xmm0, %xmm4
mulsd %xmm0, %xmm2
shufpd $0x1, %xmm1, %xmm0      # xmm0 = xmm0[1],xmm1[0]
mulpd %xmm3, %xmm0
subpd %xmm4, %xmm0
movupd %xmm0, (%rdx)
mulsd %xmm3, %xmm1
subsd %xmm1, %xmm2
movsd %xmm2, 0x10(%rdx)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10fc1(%rip), %xmm0    # 0x19040
andpd %xmm1, %xmm0
addsd 0x20(%rdi), %xmm0
subsd %xmm1, %xmm0
xorl %eax, %eax
movsd 0x1452a(%rip), %xmm1    # 0x1c5c0
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 0x8096
retq
// File: /workspace/github_c_makefile_star2_O3/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: EigenvectorRX
static void EigenvectorRX(const Real u, const Real v, const Real w, const Real hT,
        const Real c, const Real q, Real R[restrict][DIMU])
{
    R[0][0] = 1.0;         R[0][1] = 1.0;        R[0][2] = 0.0;  R[0][3] = 0.0;  R[0][4] = 1.0;
    R[1][0] = u - c;       R[1][1] = u;          R[1][2] = 0.0;  R[1][3] = 0.0;  R[1][4] = u + c;
    R[2][0] = v;           R[2][1] = 0.0;        R[2][2] = 1.0;  R[2][3] = 0.0;  R[2][4] = v;
    R[3][0] = w;           R[3][1] = 0.0;        R[3][2] = 0.0;  R[3][3] = 1.0;  R[3][4] = w;
    R[4][0] = hT - u * c;  R[4][1] = u * u - q;  R[4][2] = v;    R[4][3] = w;    R[4][4] = hT + u * c;
    return;
}

// Assembly:
movaps 0x1408c(%rip), %xmm6    # 0x1c650
movups %xmm6, (%rdi)
xorps %xmm6, %xmm6
movups %xmm6, 0x10(%rdi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x20(%rdi)
movapd %xmm0, %xmm7
subsd %xmm4, %xmm7
movsd %xmm7, 0x28(%rdi)
movsd %xmm0, 0x30(%rdi)
movapd %xmm0, %xmm7
addsd %xmm4, %xmm7
movups %xmm6, 0x38(%rdi)
movsd %xmm7, 0x48(%rdi)
movsd %xmm1, 0x50(%rdi)
xorpd %xmm7, %xmm7
movhpd 0x109f8(%rip), %xmm7    # xmm7 = xmm7[0],mem[0]
movupd %xmm7, 0x58(%rdi)
movq $0x0, 0x68(%rdi)
movsd %xmm1, 0x70(%rdi)
movsd %xmm2, 0x78(%rdi)
movups %xmm6, 0x80(%rdi)
movq %rax, 0x90(%rdi)
movsd %xmm2, 0x98(%rdi)
movapd 0x13fdb(%rip), %xmm6    # 0x1c620
movapd %xmm0, %xmm7
xorpd %xmm6, %xmm7
xorpd %xmm6, %xmm5
unpcklpd %xmm0, %xmm7            # xmm7 = xmm7[0],xmm0[0]
movapd %xmm4, %xmm6
unpcklpd %xmm0, %xmm6            # xmm6 = xmm6[0],xmm0[0]
mulpd %xmm7, %xmm6
mulsd %xmm4, %xmm0
addsd %xmm3, %xmm0
unpcklpd %xmm5, %xmm3            # xmm3 = xmm3[0],xmm5[0]
addpd %xmm6, %xmm3
movupd %xmm3, 0xa0(%rdi)
movsd %xmm1, 0xb0(%rdi)
movsd %xmm2, 0xb8(%rdi)
movsd %xmm0, 0xc0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: EigenvectorRY
static void EigenvectorRY(const Real u, const Real v, const Real w, const Real hT,
        const Real c, const Real q, Real R[restrict][DIMU])
{
    R[0][0] = 1.0;         R[0][1] = 0.0;  R[0][2] = 1.0;        R[0][3] = 0.0;  R[0][4] = 1.0;
    R[1][0] = u;           R[1][1] = 1.0;  R[1][2] = 0.0;        R[1][3] = 0.0;  R[1][4] = u;
    R[2][0] = v - c;       R[2][1] = 0.0;  R[2][2] = v;          R[2][3] = 0.0;  R[2][4] = v + c;
    R[3][0] = w;           R[3][1] = 0.0;  R[3][2] = 0.0;        R[3][3] = 1.0;  R[3][4] = w;
    R[4][0] = hT - v * c;  R[4][1] = u;    R[4][2] = v * v - q;  R[4][3] = w;    R[4][4] = hT + v * c;
    return;
}

// Assembly:
movsd 0x1096e(%rip), %xmm6    # 0x19008
movups %xmm6, (%rdi)
movups %xmm6, 0x10(%rdi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x20(%rdi)
movsd %xmm0, 0x28(%rdi)
movq %rax, 0x30(%rdi)
xorps %xmm6, %xmm6
movups %xmm6, 0x38(%rdi)
movsd %xmm0, 0x48(%rdi)
movapd %xmm1, %xmm7
subsd %xmm4, %xmm7
movsd %xmm7, 0x50(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x58(%rdi)
movsd %xmm1, 0x60(%rdi)
movq %rcx, 0x68(%rdi)
movapd %xmm1, %xmm7
addsd %xmm4, %xmm7
movsd %xmm7, 0x70(%rdi)
movsd %xmm2, 0x78(%rdi)
movups %xmm6, 0x80(%rdi)
movq %rax, 0x90(%rdi)
movsd %xmm2, 0x98(%rdi)
mulsd %xmm1, %xmm4
movapd %xmm3, %xmm6
subsd %xmm4, %xmm6
movsd %xmm6, 0xa0(%rdi)
movsd %xmm0, 0xa8(%rdi)
mulsd %xmm1, %xmm1
subsd %xmm5, %xmm1
movsd %xmm1, 0xb0(%rdi)
movsd %xmm2, 0xb8(%rdi)
addsd %xmm3, %xmm4
movsd %xmm4, 0xc0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: EigenvectorRZ
static void EigenvectorRZ(const Real u, const Real v, const Real w, const Real hT,
        const Real c, const Real q, Real R[restrict][DIMU])
{
    R[0][0] = 1.0;         R[0][1] = 0.0;  R[0][2] = 0.0;  R[0][3] = 1.0;        R[0][4] = 1.0;
    R[1][0] = u;           R[1][1] = 1.0;  R[1][2] = 0.0;  R[1][3] = 0.0;        R[1][4] = u;
    R[2][0] = v;           R[2][1] = 0.0;  R[2][2] = 1.0;  R[2][3] = 0.0;        R[2][4] = v;
    R[3][0] = w - c;       R[3][1] = 0.0;  R[3][2] = 0.0;  R[3][3] = w;          R[3][4] = w + c;
    R[4][0] = hT - w * c;  R[4][1] = u;    R[4][2] = v;    R[4][3] = w * w - q;  R[4][4] = hT + w * c;
    return;
}

// Assembly:
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rdi)
xorps %xmm6, %xmm6
movups %xmm6, 0x8(%rdi)
movaps 0x13eec(%rip), %xmm7    # 0x1c650
movups %xmm7, 0x18(%rdi)
movsd %xmm0, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movups %xmm6, 0x38(%rdi)
movsd %xmm0, 0x48(%rdi)
xorps %xmm7, %xmm7
movhps 0x10884(%rip), %xmm7    # xmm7 = xmm7[0,1],mem[0,1]
movsd %xmm1, 0x50(%rdi)
movups %xmm7, 0x58(%rdi)
movq $0x0, 0x68(%rdi)
movsd %xmm1, 0x70(%rdi)
movapd %xmm2, %xmm7
subsd %xmm4, %xmm7
movsd %xmm7, 0x78(%rdi)
movups %xmm6, 0x80(%rdi)
movsd %xmm2, 0x90(%rdi)
movapd %xmm2, %xmm6
addsd %xmm4, %xmm6
movsd %xmm6, 0x98(%rdi)
movapd %xmm2, %xmm6
mulsd %xmm4, %xmm6
xorpd 0x13e4a(%rip), %xmm5    # 0x1c620
unpcklpd %xmm3, %xmm5            # xmm5 = xmm5[0],xmm3[0]
subsd %xmm6, %xmm3
movsd %xmm3, 0xa0(%rdi)
movsd %xmm0, 0xa8(%rdi)
movsd %xmm1, 0xb0(%rdi)
movapd %xmm2, %xmm0
unpcklpd %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0]
unpcklpd %xmm4, %xmm2            # xmm2 = xmm2[0],xmm4[0]
mulpd %xmm0, %xmm2
addpd %xmm2, %xmm5
movupd %xmm5, 0xb8(%rdi)
retq