LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mesbahamin[P]star-sim/src/star.c
// Function: star_attract_to_mass
void star_attract_to_mass(struct Star *star, float mass, float mass_x, float mass_y)
{
    float dx = star->x - mass_x;
    float dy = star->y - mass_y;
    float distance = hypotf(dx, dy);

    float theta = atan2f(dy, dx);
    float force = GRAVITATION * (star->mass * mass / powf(distance, 2));
    star_accelerate(star, theta - (0.5 * M_PI), force / star->mass);
    //printf("%f\n", force);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
movss 0x10(%rdi), %xmm0
movss 0x14(%rdi), %xmm3
subss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
subss %xmm2, %xmm3
movss %xmm3, (%rsp)
movaps %xmm3, %xmm1
callq 0x1080
movss %xmm0, 0x8(%rsp)
movss (%rsp), %xmm0
movss 0x4(%rsp), %xmm1
callq 0x11d0
movss 0x8(%rbx), %xmm1
movss 0xc(%rsp), %xmm3
mulss %xmm1, %xmm3
movss 0x8(%rsp), %xmm2
mulss %xmm2, %xmm2
divss %xmm2, %xmm3
mulss 0x165d(%rip), %xmm3     # 0x4100
cvtss2sd %xmm0, %xmm0
addsd 0x1649(%rip), %xmm0     # 0x40f8
xorps %xmm2, %xmm2
cvtsd2ss %xmm0, %xmm2
divss %xmm1, %xmm3
movss (%rbx), %xmm0
movss 0x4(%rbx), %xmm1
callq 0x27f4
movsd (%rax), %xmm0
movsd %xmm0, (%rbx)
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x11a0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/mesbahamin[P]star-sim/src/barnes_hut.c
// Function: cell_init
struct Cell *cell_init(float center_x, float center_y, float distance_x, float distance_y)
{
    struct Cell *cell = (struct Cell *)malloc(sizeof(struct Cell));
    if (cell)
    {
        cell->center_x = center_x;
        cell->center_y = center_y;
        cell->distance_x = distance_x;
        cell->distance_y = distance_y;
        cell->mass_center_x = center_x;
        cell->mass_center_y = center_x;
        cell->mass_total = 0;
        cell->stars_sum_x = 0;
        cell->stars_sum_y = 0;
        cell->star = NULL;
    }
    return cell;
}

// Assembly:
subq $0x18, %rsp
movss %xmm3, 0x14(%rsp)
movss %xmm2, 0xc(%rsp)
movss %xmm1, 0x8(%rsp)
movss %xmm0, 0x10(%rsp)
movl $0x30, %edi
callq 0x11b0
testq %rax, %rax
je 0x2b51
movss 0x10(%rsp), %xmm1
movss %xmm1, (%rax)
movss 0x8(%rsp), %xmm0
movss %xmm0, 0x4(%rax)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x8(%rax)
movss 0x14(%rsp), %xmm0
movss %xmm0, 0xc(%rax)
movss %xmm1, 0x14(%rax)
movss %xmm1, 0x18(%rax)
movl $0x0, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x1c(%rax)
movq %rcx, 0x28(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/mesbahamin[P]star-sim/src/barnes_hut.c
// Function: cell_contains_star
bool cell_contains_star(struct Cell *c, struct Star *s)
{
    return (s->x <= c->center_x + c->distance_x
        && s->x >= c->center_x - c->distance_x
        && s->y <= c->center_y + c->distance_y
        && s->y >= c->center_y - c->distance_y);
}

// Assembly:
movss 0x10(%rsi), %xmm0
movss (%rdi), %xmm1
movss 0x8(%rdi), %xmm2
movaps %xmm1, %xmm3
addss %xmm2, %xmm3
xorl %eax, %eax
ucomiss %xmm0, %xmm3
jb 0x2ba2
subss %xmm2, %xmm1
ucomiss %xmm1, %xmm0
jb 0x2ba2
movss 0x14(%rsi), %xmm0
movss 0x4(%rdi), %xmm1
movss 0xc(%rdi), %xmm2
movaps %xmm1, %xmm3
addss %xmm2, %xmm3
ucomiss %xmm0, %xmm3
jae 0x2ba3
xorl %eax, %eax
retq
subss %xmm2, %xmm1
ucomiss %xmm1, %xmm0
setae %al
retq
// File: /workspace/github_c_makefile_star2_O1/mesbahamin[P]star-sim/src/barnes_hut.c
// Function: quad_tree_node_init
struct QuadTreeNode *quad_tree_node_init(float center_x, float center_y, float distance_x, float distance_y)
{
    struct QuadTreeNode *node = (struct QuadTreeNode *)malloc(sizeof (struct QuadTreeNode));
    if (node)
    {
        node->cell = cell_init(center_x, center_y, distance_x, distance_y);
        node->ne = NULL;
        node->nw = NULL;
        node->sw = NULL;
        node->se = NULL;
    }
    return node;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movss %xmm3, 0xc(%rsp)
movss %xmm2, 0x4(%rsp)
movss %xmm1, (%rsp)
movss %xmm0, 0x8(%rsp)
movl $0x28, %edi
callq 0x11b0
movq %rax, %rbx
testq %rax, %rax
je 0x2c47
movl $0x30, %edi
callq 0x11b0
testq %rax, %rax
je 0x2c39
movss 0x8(%rsp), %xmm1
movss %xmm1, (%rax)
movss (%rsp), %xmm0
movss %xmm0, 0x4(%rax)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x8(%rax)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0xc(%rax)
movss %xmm1, 0x14(%rax)
movss %xmm1, 0x18(%rax)
movl $0x0, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x1c(%rax)
movq %rcx, 0x28(%rax)
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/mesbahamin[P]star-sim/src/barnes_hut.c
// Function: quad_tree_node_free
void quad_tree_node_free(struct QuadTreeNode *node)
{
    if (node)
    {
        quad_tree_node_free(node->ne);
        quad_tree_node_free(node->nw);
        quad_tree_node_free(node->sw);
        quad_tree_node_free(node->se);
        free(node->cell);
        free(node);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x2c8e
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x2c50
movq 0x10(%rbx), %rdi
callq 0x2c50
movq 0x18(%rbx), %rdi
callq 0x2c50
movq 0x20(%rbx), %rdi
callq 0x2c50
movq (%rbx), %rdi
callq 0x11a0
movq %rbx, %rdi
popq %rbx
jmp 0x11a0
retq
// File: /workspace/github_c_makefile_star2_O1/mesbahamin[P]star-sim/src/barnes_hut.c
// Function: quad_tree_node_subdivide
void quad_tree_node_subdivide(struct QuadTreeNode *node)
{
    if (node && quad_tree_node_is_leaf(node))
    {
        float child_distance_x = node->cell->distance_x / 2;
        float child_distance_y = node->cell->distance_y / 2;

        node->ne = quad_tree_node_init(node->cell->center_x + child_distance_x, node->cell->center_y + child_distance_y, child_distance_x, child_distance_y);
        node->nw = quad_tree_node_init(node->cell->center_x - child_distance_x, node->cell->center_y + child_distance_y, child_distance_x, child_distance_y);
        node->sw = quad_tree_node_init(node->cell->center_x - child_distance_x, node->cell->center_y - child_distance_y, child_distance_x, child_distance_y);
        node->se = quad_tree_node_init(node->cell->center_x + child_distance_x, node->cell->center_y - child_distance_y, child_distance_x, child_distance_y);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x2da7
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x2ce8
cmpq $0x0, 0x10(%rbx)
je 0x2ce8
cmpq $0x0, 0x18(%rbx)
je 0x2ce8
cmpq $0x0, 0x20(%rbx)
jne 0x2da2
movq (%rbx), %rax
movss 0x139d(%rip), %xmm3     # 0x4090
movss 0x8(%rax), %xmm2
mulss %xmm3, %xmm2
movss %xmm2, 0x8(%rsp)
mulss 0xc(%rax), %xmm3
movss %xmm3, 0xc(%rsp)
movss (%rax), %xmm0
addss %xmm2, %xmm0
movss 0x4(%rax), %xmm1
addss %xmm3, %xmm1
callq 0x2bb7
movq %rax, 0x8(%rbx)
movq (%rbx), %rax
movss (%rax), %xmm0
movss 0x8(%rsp), %xmm2
subss %xmm2, %xmm0
movss 0x4(%rax), %xmm1
movss 0xc(%rsp), %xmm3
addss %xmm3, %xmm1
callq 0x2bb7
movq %rax, 0x10(%rbx)
movq (%rbx), %rax
movss (%rax), %xmm0
movss 0x4(%rax), %xmm1
movss 0x8(%rsp), %xmm2
subss %xmm2, %xmm0
movss 0xc(%rsp), %xmm3
subss %xmm3, %xmm1
callq 0x2bb7
movq %rax, 0x18(%rbx)
movq (%rbx), %rax
movss (%rax), %xmm0
movss 0x8(%rsp), %xmm2
addss %xmm2, %xmm0
movss 0x4(%rax), %xmm1
movss 0xc(%rsp), %xmm3
subss %xmm3, %xmm1
callq 0x2bb7
movq %rax, 0x20(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/mesbahamin[P]star-sim/src/barnes_hut.c
// Function: quad_tree_init
struct QuadTree *quad_tree_init(void)
{
    struct QuadTree *qt = (struct QuadTree *)malloc(sizeof (struct QuadTree));
    if (qt)
    {
        qt->root = NULL;
    }
    return qt;
}

// Assembly:
pushq %rax
movl $0x8, %edi
callq 0x11b0
testq %rax, %rax
je 0x2f4c
movq $0x0, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/mesbahamin[P]star-sim/src/barnes_hut.c
// Function: node_is_sufficiently_far
bool node_is_sufficiently_far(struct QuadTreeNode *node, struct Star *star)
{
    float s = node->cell->distance_x * 2;
    float dx = node->cell->mass_center_x - star->x;
    float dy = node->cell->mass_center_y - star->y;
    float d = hypotf(dx, dy);

    return s / d < THETA;
}

// Assembly:
pushq %rax
movq (%rdi), %rax
movss 0x8(%rax), %xmm1
movss 0x14(%rax), %xmm0
subss 0x10(%rsi), %xmm0
addss %xmm1, %xmm1
movss %xmm1, 0x4(%rsp)
movss 0x18(%rax), %xmm1
subss 0x14(%rsi), %xmm1
callq 0x1080
movss 0x4(%rsp), %xmm1
divss %xmm0, %xmm1
movss 0x10e9(%rip), %xmm0     # 0x4090
ucomiss %xmm1, %xmm0
seta %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/mesbahamin[P]star-sim/src/barnes_hut.c
// Function: quad_tree_calc_force_on_star
void quad_tree_calc_force_on_star(struct QuadTreeNode *node, struct Star *star)
{
    if (!star || !node)
    {
        return;
    }

    if (quad_tree_node_is_leaf(node) && !cell_is_empty(node->cell) && !cell_contains_star(node->cell, star))
    {
        star_attract(node->cell->star, star);
    }
    else if (node_is_sufficiently_far(node, star))
    {
        star_attract_to_mass(star,
                node->cell->mass_total,
                node->cell->mass_center_x,
                node->cell->mass_center_y);
    }
    else
    {
        quad_tree_calc_force_on_star(node->ne, star);
        quad_tree_calc_force_on_star(node->nw, star);
        quad_tree_calc_force_on_star(node->sw, star);
        quad_tree_calc_force_on_star(node->se, star);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %r14, %r14
je 0x30c0
testq %rbx, %rbx
je 0x30c0
cmpq $0x0, 0x8(%r14)
je 0x2fe7
cmpq $0x0, 0x10(%r14)
je 0x2fe7
cmpq $0x0, 0x18(%r14)
je 0x2fe7
cmpq $0x0, 0x20(%r14)
jne 0x3042
movq (%r14), %rax
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x3042
movss 0x10(%rbx), %xmm0
movss (%rax), %xmm1
movss 0x8(%rax), %xmm2
movaps %xmm1, %xmm3
addss %xmm2, %xmm3
ucomiss %xmm0, %xmm3
jb 0x30b1
subss %xmm2, %xmm1
ucomiss %xmm1, %xmm0
jb 0x30b1
movss 0x14(%rbx), %xmm0
movss 0x4(%rax), %xmm1
movss 0xc(%rax), %xmm2
movaps %xmm1, %xmm3
addss %xmm2, %xmm3
ucomiss %xmm0, %xmm3
jb 0x30b1
subss %xmm2, %xmm1
ucomiss %xmm1, %xmm0
jb 0x30b1
movq (%r14), %rax
movss 0x8(%rax), %xmm1
movss 0x14(%rax), %xmm0
subss 0x10(%rbx), %xmm0
addss %xmm1, %xmm1
movss %xmm1, 0x4(%rsp)
movss 0x18(%rax), %xmm1
subss 0x14(%rbx), %xmm1
callq 0x1080
movss 0x4(%rsp), %xmm1
divss %xmm0, %xmm1
movss 0x1011(%rip), %xmm0     # 0x4090
ucomiss %xmm1, %xmm0
ja 0x30c8
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x2faf
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x2faf
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x2faf
movq 0x20(%r14), %r14
jmp 0x2fb9
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2918
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rax
movss 0x10(%rax), %xmm0
movss 0x14(%rax), %xmm1
movss 0x18(%rax), %xmm2
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a35
// File: /workspace/github_c_makefile_star2_O1/carlitosmarin[P]Sistema-Ficheros-SOII/mi_cat.c
// Function: main
int main (int argc, char **argv) {
	if (argc != 3) {
		printf("Número de parametros incorrectos\n");
		return -1;
	}

	char *camino = argv[2];
    if(camino[strlen(camino)-1] == '/'){
        printf("ERROR: ( %s ) no es un fichero.\n",camino);
        return -1;
    }

	bmount(argv[1]);

 	int leidos = 0;
	unsigned char buf[tamBloque];
	memset(buf,0,tamBloque);
	int x = mi_read(camino,buf,0,tamBloque);
	unsigned int bucle;
	for(bucle = tamBloque; x > 0; bucle += tamBloque){ // Mientras no de error seguimos leyendo
		write(1,buf,x); //Mostrar los resultados por pantalla
		leidos += x;
		memset(buf,0,tamBloque);
		x = mi_read(camino,buf,bucle,tamBloque);
	}

	char string[128];
	sprintf(string, "Bytes Leídos %d\n", leidos); //Hay que mostrar el valor del num de bytes leidos y del tamanyo en bytes logico del inodo
	write(2, string, strlen(string)); //No sumara lo que ocupe esa informacion al fichero externo

	bumount();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x488, %rsp            # imm = 0x488
cmpl $0x3, %edi
jne 0x3e50
movq %rsi, %rbx
movq 0x10(%rsi), %r14
movq %r14, %rdi
callq 0x1080
cmpb $0x2f, -0x1(%r14,%rax)
jne 0x3e66
leaq 0x6e6(%rip), %rdi       # 0x452a
movq %r14, %rsi
xorl %eax, %eax
callq 0x1090
jmp 0x3e5c
leaq 0x706(%rip), %rdi       # 0x455d
callq 0x1060
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x3f2e
movq 0x8(%rbx), %rdi
callq 0x127c
leaq 0x80(%rsp), %r15
xorl %ebx, %ebx
movl $0x400, %edx            # imm = 0x400
movq %r15, %rdi
xorl %esi, %esi
callq 0x10b0
movl $0x400, %ebp            # imm = 0x400
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl $0x400, %ecx            # imm = 0x400
callq 0x3b91
movl $0x0, %r15d
testl %eax, %eax
jle 0x3ef8
movl %eax, %r13d
xorl %r15d, %r15d
leaq 0x80(%rsp), %r12
movl %r13d, %edx
movl $0x1, %edi
movq %r12, %rsi
callq 0x1070
addl %r13d, %r15d
movl $0x400, %edx            # imm = 0x400
movq %r12, %rdi
xorl %esi, %esi
callq 0x10b0
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
movl $0x400, %ecx            # imm = 0x400
callq 0x3b91
movl %eax, %r13d
addl $0x400, %ebp            # imm = 0x400
testl %eax, %eax
jg 0x3eb7
leaq 0x64c(%rip), %rsi       # 0x454b
movq %rsp, %r14
movq %r14, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x1160
movq %r14, %rdi
callq 0x1080
movl $0x2, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1070
xorl %eax, %eax
callq 0x12ba
movl %ebx, %eax
addq $0x488, %rsp            # imm = 0x488
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/tests/matrix.c
// Function: main
int main(void)
{
	int r;
	struct tt_mtx m, b, b2;
	double vm[6][6] = {
		{ 10, 15, 11, 6, 1, 1 },
		{ 106, 15, 114, 63, 12, 11 },
		{ 1, -82, 83, -4, 5, -86 },
		{ -16, 15, -14, 13, -12, 11 },
		{ 11, 61, 21, 401, 355, 511 },
		{ 50, 30, 40, 20, 60, 10 },
	};
	double vb[6] = { 100, 99, 101, 98, -200, -321 };
	double vm2[6][6];
	memcpy(vm2, vm, sizeof(vm));

	m.cols = m.rows = 6;
	m.v = (double *)vm;

	b.cols = 1;
	b.rows = 6;
	b.v = vb;

	r = tt_mtx_gaussj(&m, &b);
	printf("%f, %f, %f, %f, %f, %f\n",
			vb[0], vb[1], vb[2], vb[3], vb[4], vb[5]);
	printf("%d\n", r);

	int i, j;
	for (i = 0; i < 6; i++) {
		for (j = 0; j < 6; j++)
			printf("%f, ", m.v[i*6+j]);
		printf("\n");
	}

	m.v = (double *)vm2;
	b2.cols = 1;
	b2.rows = 6;
	double vb2[6];
	b2.v = vb2;
	tt_mtx_mul(&b2, &m, &b);
	for (i = 0; i < 6; i++)
		printf("%f, ", b2.v[i]);
	printf("\n");

	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2d8, %rsp            # imm = 0x2D8
leaq 0x394c(%rip), %rbx      # 0x5040
leaq 0x1b0(%rsp), %r15
movl $0x120, %edx            # imm = 0x120
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1100
movaps 0x38fd(%rip), %xmm0     # 0x5010
leaq 0x60(%rsp), %r13
movaps %xmm0, (%r13)
movaps 0x38fc(%rip), %xmm0     # 0x5020
movaps %xmm0, 0x10(%r13)
movaps 0x3900(%rip), %xmm0     # 0x5030
movaps %xmm0, 0x20(%r13)
leaq 0x90(%rsp), %rdi
movl $0x120, %edx            # imm = 0x120
movq %rbx, %rsi
callq 0x1100
movabsq $0x600000006, %rax      # imm = 0x600000006
movq %rsp, %rdi
movq %rax, (%rdi)
movq %r15, 0x8(%rdi)
movabsq $0x100000006, %r12      # imm = 0x100000006
leaq 0x20(%rsp), %rsi
movq %r12, (%rsi)
movq %r13, 0x8(%rsi)
callq 0x19ac
movl %eax, %ebx
movsd (%r13), %xmm0
movsd 0x8(%r13), %xmm1
movsd 0x10(%r13), %xmm2
movsd 0x18(%r13), %xmm3
movsd 0x20(%r13), %xmm4
movsd 0x28(%r13), %xmm5
leaq 0x39ba(%rip), %rdi      # 0x5160
movb $0x6, %al
callq 0x10a0
leaq 0x39c4(%rip), %rdi      # 0x5178
xorl %r13d, %r13d
movl %ebx, %esi
xorl %eax, %eax
callq 0x10a0
leaq 0x39b5(%rip), %r15      # 0x517c
xorl %ebp, %ebp
xorl %r14d, %r14d
movq 0x8(%rsp), %rax
addq %r13, %rax
movsd (%rax,%r14,8), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x10a0
incq %r14
cmpq $0x6, %r14
jne 0x17cc
movl $0xa, %edi
callq 0x1040
incq %rbp
addq $0x30, %r13
cmpq $0x6, %rbp
jne 0x17c9
movq %rsp, %rsi
leaq 0x90(%rsp), %rax
movq %rax, 0x8(%rsi)
leaq 0x10(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rdi)
leaq 0x20(%rsp), %rdx
callq 0x1874
xorl %r15d, %r15d
leaq 0x3944(%rip), %r14      # 0x517c
movq 0x18(%rsp), %rax
movsd (%rax,%r15,8), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x10a0
incq %r15
cmpq $0x6, %r15
jne 0x1838
movl $0xa, %edi
callq 0x1040
movl %ebx, %eax
addq $0x2d8, %rsp            # imm = 0x2D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/num/mtx.c
// Function: tt_mtx_mul
int tt_mtx_mul(struct tt_mtx *mo,
		const struct tt_mtx *mi1, const struct tt_mtx *mi2)
{
	tt_assert(mi1->cols == mi2->rows);
	tt_assert(mo->rows == mi1->rows);
	tt_assert(mo->cols == mi2->cols);

	for (int i = 0; i < mi1->rows; i++) {
		double *v1 = _tt_mtx_row(mi1, i);
		for (int j = 0; j < mi2->cols; j++) {
			double o = 0.0f;
			double *v2 = _tt_mtx_el(mi2, 0, j);
			for (int k = 0; k < mi1->cols; k++) {
				o += (*v1) * (*v2);
				v1++;
				v2 += mi2->cols;
			}
			*_tt_mtx_el(mo, i, j) = o;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl 0x4(%rsi), %r10d
movq %rdx, 0x10(%rsp)
movl (%rdx), %eax
movl %eax, 0xc(%rsp)
cmpl %eax, %r10d
jne 0x199d
movslq (%rdi), %r8
movl (%rsi), %r9d
cmpl %r9d, %r8d
jne 0x19a2
movslq 0x4(%rdi), %rdx
movq 0x10(%rsp), %rax
movl 0x4(%rax), %r11d
cmpl %r11d, %edx
jne 0x19a7
testl %r9d, %r9d
jle 0x197d
movslq %r10d, %rax
movq %rax, 0x20(%rsp)
movslq %r11d, %r14
movq 0x8(%rsi), %rax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
testl %edx, %edx
movl $0x0, %r12d
cmovgl %edx, %r12d
shlq $0x3, %r14
testl %r11d, %r11d
jle 0x1971
cmpl $0x0, 0xc(%rsp)
jle 0x1998
movq %r15, %rax
imulq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
leaq (%rcx,%rax,8), %r13
movq %r15, %rbp
imulq %rdx, %rbp
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
shlq $0x3, %rbp
xorl %ebx, %ebx
xorpd %xmm0, %xmm0
testl %r10d, %r10d
jle 0x194f
movq %rsi, %rcx
movl %r10d, %eax
movsd (%r13), %xmm1
mulsd (%rcx), %xmm1
addsd %xmm1, %xmm0
addq $0x8, %r13
addq %r14, %rcx
decl %eax
jne 0x1936
cmpq %r8, %r15
jge 0x198e
cmpq %r12, %rbx
je 0x1993
movq 0x8(%rdi), %rax
addq %rbp, %rax
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
addq $0x8, %rsi
cmpq %r11, %rbx
jne 0x1927
incq %r15
cmpq %r9, %r15
jne 0x18ef
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1220
callq 0x1248
callq 0x11f8
callq 0x1180
callq 0x11a8
callq 0x11d0
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/num/dft.c
// Function: tt_dft
int tt_dft(double (*out)[2], double (*in)[2], uint N)
{
	tt_assert(N);

	double em = 0;
	double edelta = 2 * _TT_PI / N;
	for (uint m = 0; m < N; m++) {
		out[m][0] = out[m][1] = 0;

		double emn = 0;
		for (uint n = 0; n < N; n++) {
			double e[2] = { cos(emn), -sin(emn) };
			double t[2];
			tt_complex_mul(t, in[n], e);
			out[m][0] += t[0];
			out[m][1] += t[1];

			emn += em;
		}

		em += edelta;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testl %edx, %edx
je 0x1f0c
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r12d
cvtsi2sd %r12, %xmm0
movsd 0x3528(%rip), %xmm1     # 0x5360
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r12, 0x10(%rsp)
shlq $0x4, %r12
xorpd %xmm2, %xmm2
xorl %r13d, %r13d
movq %r13, %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rbp
xorpd %xmm1, %xmm1
movupd %xmm1, (%r14,%rax)
xorl %r15d, %r15d
xorpd %xmm0, %xmm0
movsd %xmm2, 0x18(%rsp)
movsd %xmm0, (%rsp)
callq 0x10d0
movapd %xmm0, 0x20(%rsp)
movsd (%rsp), %xmm0
callq 0x1130
movsd (%rbx,%r15), %xmm1
movsd 0x8(%rbx,%r15), %xmm2
movapd 0x20(%rsp), %xmm4
movapd %xmm4, %xmm3
mulsd %xmm1, %xmm3
mulsd %xmm2, %xmm4
mulsd %xmm0, %xmm1
subsd %xmm1, %xmm4
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
unpcklpd %xmm4, %xmm0            # xmm0 = xmm0[0],xmm4[0]
movupd (%rbp), %xmm1
addpd %xmm0, %xmm1
movsd 0x18(%rsp), %xmm2
movupd %xmm1, (%rbp)
movsd (%rsp), %xmm0
addsd %xmm2, %xmm0
addq $0x10, %r15
cmpq %r15, %r12
jne 0x1e74
addsd 0x8(%rsp), %xmm2
incq %r13
cmpq 0x10(%rsp), %r13
jne 0x1e52
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13d8
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/num/dft.c
// Function: tt_idft
int tt_idft(double (*out)[2], double (*in)[2], uint N)
{
	tt_assert(N);

	double en = 0;
	double edelta = 2 * _TT_PI / N;
	for (uint n = 0; n < N; n++) {
		out[n][0] = out[n][1] = 0;

		double enm = 0;
		for (uint m = 0; m < N; m++) {
			double e[2] = { cos(enm), sin(enm) };
			double t[2];
			tt_complex_mul(t, in[m], e);
			out[n][0] += t[0];
			out[n][1] += t[1];

			enm += en;
		}
		out[n][0] /= N;
		out[n][1] /= N;

		en += edelta;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testl %edx, %edx
je 0x202f
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r12d
cvtsi2sd %r12, %xmm0
movsd 0x3423(%rip), %xmm1     # 0x5360
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd %xmm0, 0x20(%rsp)
movq %r12, 0x10(%rsp)
shlq $0x4, %r12
xorpd %xmm1, %xmm1
xorl %r13d, %r13d
movq %r13, %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rbp
xorpd %xmm0, %xmm0
movupd %xmm0, (%r14,%rax)
xorl %r15d, %r15d
xorpd %xmm0, %xmm0
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
callq 0x10d0
movaps %xmm0, 0x30(%rsp)
movsd (%rsp), %xmm0
callq 0x1130
movsd (%rbx,%r15), %xmm1
movsd 0x8(%rbx,%r15), %xmm2
movapd 0x30(%rsp), %xmm4
movapd %xmm4, %xmm3
mulsd %xmm1, %xmm3
mulsd %xmm0, %xmm1
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm4
addsd %xmm1, %xmm4
movsd 0x18(%rsp), %xmm1
subsd %xmm0, %xmm3
unpcklpd %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0]
movupd (%rbp), %xmm0
addpd %xmm3, %xmm0
movupd %xmm0, (%rbp)
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
addq $0x10, %r15
cmpq %r15, %r12
jne 0x1f83
movupd (%rbp), %xmm0
divpd 0x20(%rsp), %xmm0
movupd %xmm0, (%rbp)
addsd 0x8(%rsp), %xmm1
incq %r13
cmpq 0x10(%rsp), %r13
jne 0x1f61
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1400
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/num/dft.c
// Function: tt_dft_real
int tt_dft_real(double (*out)[2], const double *in, uint N)
{
	tt_assert(N);

	double em = 0;
	double edelta = 2 * _TT_PI / N;
	for (uint m = 0; m < N; m++) {
		out[m][0] = out[m][1] = 0;

		double emn = 0;
		for (uint n = 0; n < N; n++) {
			out[m][0] += cos(emn) * in[n];
			out[m][1] += -sin(emn) * in[n];

			emn += em;
		}

		em += edelta;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %edx, %edx
je 0x2102
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r15d
cvtsi2sd %r15, %xmm0
movsd 0x3300(%rip), %xmm1     # 0x5360
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
xorpd %xmm2, %xmm2
xorl %r12d, %r12d
movq %r12, %rax
shlq $0x4, %rax
leaq (%r14,%rax), %r13
xorpd %xmm1, %xmm1
movupd %xmm1, (%r14,%rax)
xorl %ebp, %ebp
xorpd %xmm0, %xmm0
movsd %xmm2, 0x10(%rsp)
movsd %xmm0, (%rsp)
callq 0x10d0
mulsd (%rbx,%rbp,8), %xmm0
addsd (%r13), %xmm0
movsd %xmm0, (%r13)
movsd (%rsp), %xmm0
callq 0x1130
movsd 0x8(%r13), %xmm1
mulsd (%rbx,%rbp,8), %xmm0
subsd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm2
movsd %xmm1, 0x8(%r13)
movsd (%rsp), %xmm0
addsd %xmm2, %xmm0
incq %rbp
cmpq %rbp, %r15
jne 0x2092
addsd 0x8(%rsp), %xmm2
incq %r12
cmpq %r15, %r12
jne 0x2071
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1428
nop
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/num/fft.c
// Function: gen_wn_tbl
static double (*gen_wn_tbl(int N))[2]
{
	double wn = 0;
	const double step = 2 * _TT_PI / N;
	double (*tbl)[2] = malloc(N / 2 * sizeof(*tbl));

	if (tbl == NULL) {
		tt_error("Out of memory");
		return NULL;
	}

	for (int i = 0; i < N / 4; i++) {
		tbl[i][0] = cos(wn);
		tbl[i][1] = -sin(wn);
		tbl[i+N/4][0] = tbl[i][1];
		tbl[i+N/4][1] = -tbl[i][0];
		wn += step;
	}

	return tbl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %r14d
shrl %edi
shlq $0x4, %rdi
callq 0x1120
testq %rax, %rax
je 0x2201
movq %rax, %rbx
cmpl $0x4, %r14d
jb 0x221a
cvtsi2sd %r14d, %xmm0
movsd 0x31e3(%rip), %xmm1     # 0x5360
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
shrl $0x2, %r14d
shlq $0x4, %r14
leaq (%r14,%rbx), %r15
addq $0x8, %r15
xorpd %xmm0, %xmm0
xorl %r12d, %r12d
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x10d0
movsd %xmm0, (%rbx,%r12)
movsd 0x8(%rsp), %xmm0
callq 0x1130
movapd 0x3178(%rip), %xmm1     # 0x5340
xorpd %xmm1, %xmm0
movlpd %xmm0, 0x8(%rbx,%r12)
movlpd %xmm0, -0x8(%r15,%r12)
movsd (%rbx,%r12), %xmm0
xorpd %xmm1, %xmm0
movlpd %xmm0, (%r15,%r12)
movsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
addq $0x10, %r12
cmpq %r12, %r14
jne 0x219e
jmp 0x221a
leaq 0x30d6(%rip), %rsi      # 0x52de
leaq 0x30da(%rip), %rdx      # 0x52e9
xorl %ebx, %ebx
xorl %edi, %edi
xorl %eax, %eax
callq 0x296e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/num/fft.c
// Function: tt_fft
int tt_fft(double (*out)[2], double (*in)[2], uint N)
{
	/* Check if N is 2^n */
	if (N <= 1 || (N & (N-1))) {
		tt_warn("%d is not power of 2, fallback to DFT", N);
		return tt_dft(out, in, N);
	}

	return do_stage(out, in, N, fft_stage);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x2, %edx
jb 0x2294
movl %ebx, %eax
shrl %eax
andl $0x55555555, %eax       # imm = 0x55555555
movl %ebx, %ecx
subl %eax, %ecx
movl $0x33333333, %eax       # imm = 0x33333333
movl %ecx, %edx
andl %eax, %edx
shrl $0x2, %ecx
andl %eax, %ecx
addl %edx, %ecx
movl %ecx, %eax
shrl $0x4, %eax
addl %ecx, %eax
andl $0xf0f0f0f, %eax        # imm = 0xF0F0F0F
imull $0x1010101, %eax, %eax  # imm = 0x1010101
shrl $0x18, %eax
cmpl $0x2, %eax
jae 0x2294
leaq 0x13c(%rip), %rcx       # 0x23c1
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x22c2
leaq 0x2fdb(%rip), %rsi      # 0x5276
leaq 0x2fdb(%rip), %rdx      # 0x527d
movl $0x1, %edi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x296e
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x1e0c
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/num/fft.c
// Function: do_stage
static int do_stage(double (*out)[2], double (*in)[2], uint N,
		void (*stage)(double (*)[2], int, uint, double (*)[2], int))
{
	double (*tbl)[2];
	int delta;

	tbl = get_wn_tbl(N, &delta);
	if (!tbl)
		return TT_ENOMEM;

	/* Bit reversal */
	const int nb = __builtin_ctz(N);
	for (int i = 0; i < N ; i++)
		tt_complex_set(out[i], in[_tt_bitrev(i, nb)]);

	for (int i = 1; i <= nb; i++)
		stage(out, i, N, tbl, delta);

	put_wn_tbl(tbl);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r14
leaq 0x14(%rsp), %rsi
movl %edx, %edi
callq 0x2819
testq %rax, %rax
je 0x23ab
movq %rax, 0x18(%rsp)
movq %r14, %r15
movq %rbx, 0x20(%rsp)
movl %ebp, 0xc(%rsp)
bsfl %ebp, %r12d
je 0x2346
movl 0xc(%rsp), %r14d
leaq 0x8(%r15), %rbp
xorl %ebx, %ebx
movl %ebx, %edi
movl %r12d, %esi
callq 0x292a
movl %eax, %eax
shlq $0x4, %rax
movsd (%r13,%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd 0x8(%r13,%rax), %xmm0
movsd %xmm0, (%rbp)
incq %rbx
addq $0x10, %rbp
cmpq %rbx, %r14
jne 0x2312
testl %r12d, %r12d
movq 0x20(%rsp), %rbp
movl 0xc(%rsp), %edx
movq 0x18(%rsp), %r14
je 0x2396
movq %r15, %rbx
movl 0x14(%rsp), %ecx
movl %ecx, 0x10(%rsp)
negl %r12d
movl $0x1, %r13d
movq %rbx, %rdi
movl %r13d, %esi
movl %edx, %r15d
movq %r14, %rcx
movl 0x10(%rsp), %r8d
callq *%rbp
movl %r15d, %edx
leal (%r12,%r13), %eax
incl %eax
movl %r13d, %ecx
incl %ecx
movl %ecx, %r13d
cmpl $0x1, %eax
jne 0x236d
xorl %ebx, %ebx
cmpq %r14, 0x5d79(%rip)      # 0x8118
je 0x23b0
movq %r14, %rdi
callq 0x1030
jmp 0x23b0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/num/fft.c
// Function: fft_stage
static void fft_stage(double (*x)[2], int stage, uint N,
		double (*tbl)[2], int delta)
{
	const int idx_step = 1 << (stage - 1);
	int idx;
	double tmp[2];

	/* Multiply W(N,k) */
	const int tbl_step = delta * (N >> stage);
	idx = idx_step;
	for (int i = 0; i < (N >> stage); i++) {
		int tbl_idx = 0;
		for (int j = 0; j < idx_step; j++) {
			tt_complex_mul(x[idx], x[idx], tbl[tbl_idx]);
			idx++;
			tbl_idx += tbl_step;
		}
		idx += idx_step;
	}

	/* Cross add/sub */
	idx = 0;
	for (int i = 0; i < (N >> stage); i++) {
		for (int j = 0; j < idx_step; j++) {
			tt_complex_add(tmp, x[idx], x[idx+idx_step]);
			tt_complex_sub(x[idx+idx_step], x[idx], x[idx+idx_step]);
			tt_complex_set(x[idx], tmp);
			idx++;
		}
		idx += idx_step;
	}
}

// Assembly:
movq %rcx, %r9
leal -0x1(%rsi), %eax
movl $0x1, %r11d
movl $0x1, %r10d
movl %eax, %ecx
shll %cl, %r10d
movl %esi, %ecx
shrl %cl, %edx
testl %edx, %edx
je 0x24e7
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
imull %edx, %r8d
movslq %r8d, %rcx
cmpl $0x2, %r10d
cmovgel %r10d, %r11d
leaq 0x8(%rdi), %rsi
addq $0x8, %r9
shlq $0x4, %rcx
negl %r11d
xorl %r8d, %r8d
movl %r10d, %ebx
cmpl $0x1f, %eax
je 0x246f
movslq %ebx, %r14
shlq $0x4, %r14
addq %rsi, %r14
xorl %ebp, %ebp
movq %r9, %r15
movsd -0x8(%r14), %xmm0
movsd (%r14), %xmm1
movsd -0x8(%r15), %xmm2
movsd (%r15), %xmm3
movapd %xmm0, %xmm4
mulsd %xmm2, %xmm4
mulsd %xmm1, %xmm2
mulsd %xmm3, %xmm1
subsd %xmm1, %xmm4
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
movsd %xmm0, (%r14)
movsd %xmm4, -0x8(%r14)
addq $0x10, %r14
decl %ebp
addq %rcx, %r15
cmpl %ebp, %r11d
jne 0x2422
subl %ebp, %ebx
addl %r10d, %ebx
incl %r8d
cmpl %edx, %r8d
jne 0x240e
movslq %r10d, %rcx
cmpl $0x2, %r10d
movl $0x1, %esi
cmovgel %r10d, %esi
shlq $0x4, %rcx
negl %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpl $0x1f, %eax
je 0x24d6
movslq %r9d, %r11
shlq $0x4, %r11
addq %rdi, %r11
xorl %ebx, %ebx
movupd (%r11), %xmm0
movupd (%r11,%rcx), %xmm1
movapd %xmm0, %xmm2
addpd %xmm1, %xmm2
subpd %xmm1, %xmm0
movupd %xmm0, (%r11,%rcx)
movupd %xmm2, (%r11)
addq $0x10, %r11
decl %ebx
cmpl %ebx, %esi
jne 0x24a7
subl %ebx, %r9d
addl %r10d, %r9d
incl %r8d
cmpl %edx, %r8d
jne 0x2496
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/num/fft.c
// Function: tt_ifft
int tt_ifft(double (*out)[2], double (*in)[2], uint N)
{
	if (N <= 1 || (N & (N-1))) {
		tt_warn("%d is not power of 2, fallback to IDFT", N);
		return tt_idft(out, in, N);
	}

	int ret = do_stage(out, in, N, ifft_stage);
	if (ret)
		return ret;

	/* Divide N */
	for (int i = 0; i < N; i++) {
		out[i][0] /= N;
		out[i][1] /= N;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x2, %edx
jb 0x2577
movl %ebp, %eax
shrl %eax
andl $0x55555555, %eax       # imm = 0x55555555
movl %ebp, %ecx
subl %eax, %ecx
movl $0x33333333, %eax       # imm = 0x33333333
movl %ecx, %edx
andl %eax, %edx
shrl $0x2, %ecx
andl %eax, %ecx
addl %edx, %ecx
movl %ecx, %eax
shrl $0x4, %eax
addl %ecx, %eax
andl $0xf0f0f0f, %eax        # imm = 0xF0F0F0F
imull $0x1010101, %eax, %eax  # imm = 0x1010101
shrl $0x18, %eax
cmpl $0x2, %eax
jae 0x2577
leaq 0x6d(%rip), %rcx        # 0x25a4
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x22c2
testl %eax, %eax
jne 0x2572
movl %ebp, %ecx
cvtsi2sd %rcx, %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
shlq $0x4, %rcx
xorl %eax, %eax
xorl %edx, %edx
movupd (%rbx,%rdx), %xmm1
divpd %xmm0, %xmm1
movupd %xmm1, (%rbx,%rdx)
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0x255b
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2d25(%rip), %rsi      # 0x52a3
leaq 0x2d26(%rip), %rdx      # 0x52ab
movl $0x1, %edi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x296e
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x1f11
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/num/fft.c
// Function: ifft_stage
static void ifft_stage(double (*x)[2], int stage, uint N,
		double (*tbl)[2], int delta)
{
	const int idx_step = 1 << (stage - 1);
	int idx;
	double tmp[2];

	const int tbl_step = delta * (N >> stage);
	idx = idx_step;
	for (int i = 0; i < (N >> stage); i++) {
		int tbl_idx = 0;
		for (int j = 0; j < idx_step; j++) {
			tmp[0] = tbl[tbl_idx][0];
			tmp[1] = -tbl[tbl_idx][1];
			tt_complex_mul(x[idx], x[idx], tmp);
			idx++;
			tbl_idx += tbl_step;
		}
		idx += idx_step;
	}

	idx = 0;
	for (int i = 0; i < (N >> stage); i++) {
		for (int j = 0; j < idx_step; j++) {
			tt_complex_add(tmp, x[idx], x[idx+idx_step]);
			tt_complex_sub(x[idx+idx_step], x[idx], x[idx+idx_step]);
			tt_complex_set(x[idx], tmp);
			idx++;
		}
		idx += idx_step;
	}
}

// Assembly:
movq %rcx, %r9
leal -0x1(%rsi), %eax
movl $0x1, %r11d
movl $0x1, %r10d
movl %eax, %ecx
shll %cl, %r10d
movl %esi, %ecx
shrl %cl, %edx
testl %edx, %edx
je 0x26ca
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
imull %edx, %r8d
movslq %r8d, %rcx
cmpl $0x2, %r10d
cmovgel %r10d, %r11d
leaq 0x8(%rdi), %rsi
addq $0x8, %r9
shlq $0x4, %rcx
negl %r11d
xorl %r8d, %r8d
movl %r10d, %ebx
cmpl $0x1f, %eax
je 0x2652
movslq %ebx, %r14
shlq $0x4, %r14
addq %rsi, %r14
xorl %ebp, %ebp
movq %r9, %r15
movsd -0x8(%r15), %xmm0
movsd (%r15), %xmm1
movsd -0x8(%r14), %xmm2
movsd (%r14), %xmm3
movapd %xmm0, %xmm4
mulsd %xmm2, %xmm4
mulsd %xmm3, %xmm0
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, (%r14)
mulsd %xmm3, %xmm1
addsd %xmm4, %xmm1
movsd %xmm1, -0x8(%r14)
addq $0x10, %r14
decl %ebp
addq %rcx, %r15
cmpl %ebp, %r11d
jne 0x2605
subl %ebp, %ebx
addl %r10d, %ebx
incl %r8d
cmpl %edx, %r8d
jne 0x25f1
movslq %r10d, %rcx
cmpl $0x2, %r10d
movl $0x1, %esi
cmovgel %r10d, %esi
shlq $0x4, %rcx
negl %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpl $0x1f, %eax
je 0x26b9
movslq %r9d, %r11
shlq $0x4, %r11
addq %rdi, %r11
xorl %ebx, %ebx
movupd (%r11), %xmm0
movupd (%r11,%rcx), %xmm1
movapd %xmm0, %xmm2
addpd %xmm1, %xmm2
subpd %xmm1, %xmm0
movupd %xmm0, (%r11,%rcx)
movupd %xmm2, (%r11)
addq $0x10, %r11
decl %ebx
cmpl %ebx, %esi
jne 0x268a
subl %ebx, %r9d
addl %r10d, %r9d
incl %r8d
cmpl %edx, %r8d
jne 0x2679
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/num/fft.c
// Function: tt_fft_real
int tt_fft_real(double (*out)[2], const double *in, uint N)
{
	if (N <= 1 || (N & (N-1))) {
		tt_warn("%d is not power of 2, fallback to DFT", N);
		return tt_dft_real(out, in, N);
	}

	double (*tbl)[2];
	int delta;

	tbl = get_wn_tbl(N, &delta);
	if (!tbl)
		return TT_ENOMEM;

	const int nb = __builtin_ctz(N);
	for (int i = 0; i < N ; i++) {
		out[i][0] = in[_tt_bitrev(i, nb)];
		out[i][1] = 0;
	}

	for (int i = 1; i <= nb; i++)
		fft_stage(out, i, N, tbl, delta);

	put_wn_tbl(tbl);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x2, %edx
jb 0x27cc
movl %ebp, %eax
shrl %eax
andl $0x55555555, %eax       # imm = 0x55555555
movl %ebp, %ecx
subl %eax, %ecx
movl $0x33333333, %eax       # imm = 0x33333333
movl %ecx, %edx
andl %eax, %edx
shrl $0x2, %ecx
andl %eax, %ecx
addl %edx, %ecx
movl %ecx, %eax
shrl $0x4, %eax
addl %ecx, %eax
andl $0xf0f0f0f, %eax        # imm = 0xF0F0F0F
imull $0x1010101, %eax, %eax  # imm = 0x1010101
shrl $0x18, %eax
cmpl $0x2, %eax
jae 0x27cc
leaq 0xc(%rsp), %rsi
movl %ebp, %edi
callq 0x2819
testq %rax, %rax
je 0x2803
movq %rax, %r15
movl %ebp, %r12d
bsfl %ebp, %r13d
movq %rbx, 0x10(%rsp)
addq $0x8, %rbx
xorl %ebp, %ebp
movl %ebp, %edi
movl %r13d, %esi
callq 0x292a
movl %eax, %eax
movsd (%r14,%rax,8), %xmm0
movsd %xmm0, -0x8(%rbx)
movq $0x0, (%rbx)
incq %rbp
addq $0x10, %rbx
cmpq %rbp, %r12
jne 0x274f
testl %r13d, %r13d
movq 0x10(%rsp), %rbx
je 0x27b7
movl 0xc(%rsp), %ebp
negl %r13d
movl $0x1, %r14d
movq %rbx, %rdi
movl %r14d, %esi
movl %r12d, %edx
movq %r15, %rcx
movl %ebp, %r8d
callq 0x23c1
leal (%r14,%r13), %eax
incl %eax
movl %r14d, %ecx
incl %ecx
movl %ecx, %r14d
cmpl $0x1, %eax
jne 0x2790
xorl %ebx, %ebx
cmpq %r15, 0x5958(%rip)      # 0x8118
je 0x2808
movq %r15, %rdi
callq 0x1030
jmp 0x2808
leaq 0x2aff(%rip), %rsi      # 0x52d2
leaq 0x2aa3(%rip), %rdx      # 0x527d
movl $0x1, %edi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x296e
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2034
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/num/fft.c
// Function: get_wn_tbl
static double (*get_wn_tbl(int N, int *delta))[2]
{
	if (N > WN_PTS) {
		tt_info("Points > %d, new lookup table created.", WN_PTS);
		*delta = 1;
		return gen_wn_tbl(N);
	} else {
		*delta = WN_PTS / N;
		return wn_ftbl;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
cmpl $0x2001, %edi           # imm = 0x2001
jl 0x285b
leaq 0x2ac7(%rip), %rsi      # 0x52f7
leaq 0x2acb(%rip), %rdx      # 0x5302
movl $0x2, %edi
movl $0x2000, %ecx           # imm = 0x2000
xorl %eax, %eax
callq 0x296e
movl $0x1, (%rbx)
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2141
movl $0x2000, %eax           # imm = 0x2000
xorl %edx, %edx
idivl %ebp
movl %eax, (%rbx)
movq 0x58ab(%rip), %rax      # 0x8118
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/lib.c
// Function: tt_digits
int _tt_digits(int n)
{
	int d = 1;
	n /= 10;

	while (n) {
		n /= 10;
		d++;
	}

	return d;
}

// Assembly:
leal 0x9(%rdi), %ecx
movl $0x1, %eax
cmpl $0x13, %ecx
jb 0x28a5
movslq %edi, %rcx
imulq $0x66666667, %rcx, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
leal (%rcx,%rdx), %edi
incl %eax
addl %edx, %ecx
addl $0x9, %ecx
cmpl $0x12, %ecx
ja 0x2881
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/lib.c
// Function: tt_digits_ll
int _tt_digits_ll(long long int n)
{
	int d = 1;
	n /= 10;

	while (n) {
		n /= 10;
		d++;
	}

	return d;
}

// Assembly:
leaq 0x9(%rdi), %rdx
movl $0x1, %ecx
cmpq $0x13, %rdx
jb 0x28e3
movq %rdi, %rax
movabsq $0x6666666666666667, %rsi # imm = 0x6666666666666667
imulq %rsi
movq %rdx, %rdi
shrq $0x3f, %rdi
sarq $0x2, %rdx
leaq (%rdx,%rdi), %rax
incl %ecx
addq %rdi, %rdx
addq $0x9, %rdx
cmpq $0x12, %rdx
ja 0x28c2
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/lib.c
// Function: tt_atoi
int _tt_atoi(const char *str, int *i)
{
	const char *s = str;

	/* Check syntax */
	if (*s == '+' || *s == '-')
		s++;
	while (*s) {
		if (*s < '0' || *s > '9')
			return TT_EINVAL;
		s++;
	}

	/* XXX: check overflow/underflow */
	*i = atoi(str);
	return 0;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movzbl (%rdi), %ecx
cmpl $0x2d, %ecx
je 0x28fa
movq %rdi, %rax
cmpl $0x2b, %ecx
jne 0x28fe
leaq 0x1(%rdi), %rax
movb (%rax), %cl
testb %cl, %cl
je 0x2918
incq %rax
addb $-0x3a, %cl
cmpb $-0xa, %cl
jb 0x2923
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0x2907
callq 0x1140
movl %eax, (%rbx)
xorl %eax, %eax
jmp 0x2928
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/lib.c
// Function: tt_bitrev
uint _tt_bitrev(uint n, int bits)
{
	uint rev = n;
	uint cnt = bits - 1;
	uint N = 1 << bits;

	for (n >>= 1; n; n >>= 1) {
		rev <<= 1;
		rev |= (n & 1);
		cnt--;
	}

	rev <<= cnt;
	rev &= (N - 1);

	return rev;
}

// Assembly:
leal -0x1(%rsi), %ecx
cmpl $0x2, %edi
jb 0x294c
bsrl %edi, %eax
subl %eax, %ecx
movl %edi, %edx
shrl %edi
movl %edi, %r8d
andl $0x1, %r8d
leal (%r8,%rdx,2), %edx
decl %eax
jne 0x2939
movl %edx, %edi
shll %cl, %edi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %esi, %ecx
shll %cl, %eax
notl %eax
andl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/log.c
// Function: tt_log
void tt_log(int level, const char *func, const char *format, ...)
{
	tt_assert(level >= 0 && level < TT_LOG_MAX);

	if (__target == TT_LOG_TARGET_NULL)
		return;
	if (level > __level)
		return;

	va_list ap;
	va_start(ap, format);

	char msg[512+12];
	if (vsnprintf(msg, 512, format, ap) >= 512)
		snprintf(msg+511, 13, "<Truncated>");

	char meta[32];
	const char *prefix = "", *suffix = "";

	switch (__target) {
	case TT_LOG_TARGET_STDERR:
		if (level == TT_LOG_ERROR)
			prefix = "\x1B[1;31m";	/* Red bold */
		else if (level == TT_LOG_WARN)
			prefix = "\x1B[1;33m";	/* Yellow bold */
		else if (level == TT_LOG_INFO)
			prefix = "\x1B[1;37m";  /* White bold */
		if (prefix[0])
			suffix = "\x1B[0m";
		fprintf(stderr, "[%c]%s: %s%s%s\n", level2char[level], func,
				prefix, msg, suffix);
		break;

	case TT_LOG_TARGET_FD:
		snprintf(meta, 32, "\n[%c]%s: ", level2char[level], func);
		if (write(__fd, meta, strlen(meta)) < 0 ||
				write(__fd, msg, strlen(msg)) < 0) {
			tt_log_set_fd(-1);
			fprintf(stderr, "Error writing logs to file descriptor,"
					" redirect messges to console.\n");
			tt_log_set_target(TT_LOG_TARGET_STDERR);
		}
		break;

	default:
		break;
	}

	va_end(ap);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x300, %rsp            # imm = 0x300
movq %rcx, 0x58(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x68(%rsp)
testb %al, %al
je 0x29c9
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
cmpl $0x4, %edi
jae 0x2af8
cmpl $0x2, 0x5747(%rip)      # 0x8120
je 0x2ae5
movl %edi, %ebp
cmpl %edi, 0x56e1(%rip)      # 0x80c8
jl 0x2ae5
movq %rsi, %rbx
leaq 0x40(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x320(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rcx)
leaq 0xf0(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x1060
cmpl $0x200, %eax            # imm = 0x200
jl 0x2a4b
movabsq $0x7461636e7572543c, %rax # imm = 0x7461636E7572543C
movq %rax, 0x2ef(%rsp)
movl $0x3e6465, 0x2f7(%rsp) # imm = 0x3E6465
movl 0x56cf(%rip), %eax      # 0x8120
cmpl $0x1, %eax
je 0x2a72
testl %eax, %eax
jne 0x2ae5
leaq 0xf0(%rsp), %rdx
movl %ebp, %edi
movq %rbx, %rsi
callq 0x14be
jmp 0x2ae5
movl %ebp, %eax
leaq 0x2d22(%rip), %rcx      # 0x579d
movsbl (%rax,%rcx), %ecx
leaq 0x29a2(%rip), %rdx      # 0x5428
leaq 0x20(%rsp), %r14
movl $0x20, %esi
movq %r14, %rdi
movq %rbx, %r8
xorl %eax, %eax
callq 0x10b0
movl 0x5629(%rip), %ebx      # 0x80cc
movq %r14, %rdi
callq 0x1090
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1070
testq %rax, %rax
js 0x2af1
movl 0x5609(%rip), %ebx      # 0x80cc
leaq 0xf0(%rsp), %r14
movq %r14, %rdi
callq 0x1090
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1070
testq %rax, %rax
js 0x2af1
addq $0x300, %rsp            # imm = 0x300
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1478
jmp 0x2ae5
callq 0x151f
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/log.c
// Function: tt_log_set_fd
void tt_log_set_fd(int fd)
{
	if (fd >= 0) {
		__fd = fd;
	} else if (__fd >= 0) {
		tt_log_set_target(TT_LOG_TARGET_STDERR);
		close(__fd);
		__fd = -1;
	}
}

// Assembly:
testl %edi, %edi
jns 0x2b3c
movl 0x55ad(%rip), %edi      # 0x80cc
testl %edi, %edi
js 0x2b42
pushq %rax
movl $0x0, 0x55f2(%rip)      # 0x8120
callq 0x10c0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
addq $0x8, %rsp
movl %edi, 0x558a(%rip)      # 0x80cc
retq
nop
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/key.c
// Function: tt_key_select
int _tt_key_select(struct tt_key *num)
{
	if (!num->swap)
		num->swap = tt_swap_select(num->size);
	if (!num->cmp) {
		tt_error("No compare routine");
		return TT_EINVAL;
	}
	num->_set = tt_set_select(num->size);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
jne 0x2b9d
movl (%rbx), %eax
decl %eax
cmpl $0x7, %eax
ja 0x2b78
movl %eax, %eax
leaq 0x2830(%rip), %rcx      # 0x5394
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
leaq 0x520e(%rip), %rcx      # 0x7d80
movq (%rcx,%rax,8), %r14
jmp 0x2b86
leaq 0x14d(%rip), %r14       # 0x2ccc
leaq 0x2951(%rip), %rdx      # 0x54d7
leaq 0x290c(%rip), %rsi      # 0x5499
movl $0x3, %edi
xorl %eax, %eax
callq 0x296e
movq %r14, 0x10(%rbx)
cmpq $0x0, 0x8(%rbx)
je 0x2be7
movl (%rbx), %eax
decl %eax
cmpl $0x7, %eax
ja 0x2c71
leaq 0x27bc(%rip), %rcx      # 0x5374
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x291c(%rip), %rsi      # 0x54e4
leaq 0x2923(%rip), %rdx      # 0x54f2
movl $0x3, %edi
xorl %eax, %eax
callq 0x296e
leaq 0x151(%rip), %rax       # 0x2d33
jmp 0x2c92
leaq 0x2889(%rip), %rsi      # 0x5477
leaq 0x2891(%rip), %rdx      # 0x5486
xorl %edi, %edi
xorl %eax, %eax
callq 0x296e
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x2c98
leaq 0x28d5(%rip), %rsi      # 0x54e4
leaq 0x28f1(%rip), %rdx      # 0x5507
movl $0x3, %edi
xorl %eax, %eax
callq 0x296e
leaq 0x116(%rip), %rax       # 0x2d3f
jmp 0x2c92
leaq 0x28b2(%rip), %rsi      # 0x54e4
leaq 0x28c3(%rip), %rdx      # 0x54fc
movl $0x3, %edi
xorl %eax, %eax
callq 0x296e
leaq 0xec(%rip), %rax        # 0x2d38
jmp 0x2c92
leaq 0x288f(%rip), %rsi      # 0x54e4
leaq 0x28b6(%rip), %rdx      # 0x5512
movl $0x3, %edi
xorl %eax, %eax
callq 0x296e
leaq 0xd5(%rip), %rax        # 0x2d44
jmp 0x2c92
leaq 0x286c(%rip), %rsi      # 0x54e4
leaq 0x289e(%rip), %rdx      # 0x551d
movl $0x2, %edi
xorl %eax, %eax
callq 0x296e
leaq 0xb9(%rip), %rax        # 0x2d4b
movq %rax, 0x18(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/key.c
// Function: tt_swap_general
static void tt_swap_general(const struct tt_key *num, void *v1, void *v2)
{
	int size4 = num->size / 4;
	int size1 = num->size % 4;

	while (size4--) {
		int32_t tmp = *(int32_t *)v1;
		*(int32_t *)v1 = *(int32_t *)v2;
		*(int32_t *)v2 = tmp;
		v1 += 4;
		v2 += 4;
	}

	while (size1--) {
		int8_t tmp = *(int8_t *)v1;
		*(int8_t *)v1 = *(int8_t *)v2;
		*(int8_t *)v2 = tmp;
		v1++;
		v2++;
	}
}

// Assembly:
movl (%rdi), %eax
leal 0x3(%rax), %edi
testl %eax, %eax
movl %eax, %ecx
cmovsl %edi, %ecx
movl %ecx, %r8d
andl $-0x4, %r8d
subl %r8d, %eax
cmpl $0x7, %edi
jb 0x2d13
sarl $0x2, %ecx
movl %ecx, %edi
xorl %ecx, %ecx
xorl %r8d, %r8d
movl (%rsi,%r8,4), %r9d
movl (%rdx,%r8,4), %r10d
movl %r10d, (%rsi,%r8,4)
movl %r9d, (%rdx,%r8,4)
incq %r8
addq $-0x4, %rcx
cmpl %r8d, %edi
jne 0x2cf1
subq %rcx, %rsi
subq %rcx, %rdx
testl %eax, %eax
je 0x2d32
movl %eax, %eax
xorl %ecx, %ecx
movb (%rsi,%rcx), %dil
movb (%rdx,%rcx), %r8b
movb %r8b, (%rsi,%rcx)
movb %dil, (%rdx,%rcx)
incq %rcx
cmpl %ecx, %eax
jne 0x2d1b
retq