LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %xmm0, 0x14(%rsp)
movss %xmm1, 0x10(%rsp)
movss %xmm2, 0xc(%rsp)
movss %xmm3, 0x8(%rsp)
movl $0x30, %edi
callq 0x11b0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x36ce
movss 0x14(%rsp), %xmm0
movq (%rsp), %rax
movss %xmm0, (%rax)
movss 0x10(%rsp), %xmm0
movq (%rsp), %rax
movss %xmm0, 0x4(%rax)
movss 0xc(%rsp), %xmm0
movq (%rsp), %rax
movss %xmm0, 0x8(%rax)
movss 0x8(%rsp), %xmm0
movq (%rsp), %rax
movss %xmm0, 0xc(%rax)
movss 0x14(%rsp), %xmm0
movq (%rsp), %rax
movss %xmm0, 0x14(%rax)
movss 0x14(%rsp), %xmm0
movq (%rsp), %rax
movss %xmm0, 0x18(%rax)
movq (%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x10(%rax)
movq (%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1c(%rax)
movq (%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x20(%rax)
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movss 0x10(%rax), %xmm1
movq -0x8(%rsp), %rax
movss (%rax), %xmm0
movq -0x8(%rsp), %rax
addss 0x8(%rax), %xmm0
xorl %eax, %eax
ucomiss %xmm1, %xmm0
movb %al, -0x11(%rsp)
jb 0x37ab
movq -0x10(%rsp), %rax
movss 0x10(%rax), %xmm0
movq -0x8(%rsp), %rax
movss (%rax), %xmm1
movq -0x8(%rsp), %rax
subss 0x8(%rax), %xmm1
xorl %eax, %eax
ucomiss %xmm1, %xmm0
movb %al, -0x11(%rsp)
jb 0x37ab
movq -0x10(%rsp), %rax
movss 0x14(%rax), %xmm1
movq -0x8(%rsp), %rax
movss 0x4(%rax), %xmm0
movq -0x8(%rsp), %rax
addss 0xc(%rax), %xmm0
xorl %eax, %eax
ucomiss %xmm1, %xmm0
movb %al, -0x11(%rsp)
jb 0x37ab
movq -0x10(%rsp), %rax
movss 0x14(%rax), %xmm0
movq -0x8(%rsp), %rax
movss 0x4(%rax), %xmm1
movq -0x8(%rsp), %rax
subss 0xc(%rax), %xmm1
ucomiss %xmm1, %xmm0
setae %al
movb %al, -0x11(%rsp)
movb -0x11(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movss %xmm0, 0x14(%rsp)
movss %xmm1, 0x10(%rsp)
movss %xmm2, 0xc(%rsp)
movss %xmm3, 0x8(%rsp)
movl $0x28, %edi
callq 0x11b0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x3868
movss 0x14(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
movss 0xc(%rsp), %xmm2
movss 0x8(%rsp), %xmm3
callq 0x3610
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x38d5
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3880
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x3880
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x3880
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x3880
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x11a0
movq (%rsp), %rdi
callq 0x11a0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x3abe
movq 0x10(%rsp), %rdi
callq 0x38e0
testb $0x1, %al
jne 0x3978
jmp 0x3abe
movq 0x10(%rsp), %rax
movq (%rax), %rax
movss 0x8(%rax), %xmm0
movss 0x6fb(%rip), %xmm1      # 0x4088
divss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movss 0xc(%rax), %xmm0
movss 0x6dc(%rip), %xmm1      # 0x4088
divss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movss (%rax), %xmm0
addss 0xc(%rsp), %xmm0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movss 0x4(%rax), %xmm1
addss 0x8(%rsp), %xmm1
movss 0xc(%rsp), %xmm2
movss 0x8(%rsp), %xmm3
callq 0x37e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movss (%rax), %xmm0
subss 0xc(%rsp), %xmm0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movss 0x4(%rax), %xmm1
addss 0x8(%rsp), %xmm1
movss 0xc(%rsp), %xmm2
movss 0x8(%rsp), %xmm3
callq 0x37e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movss (%rax), %xmm0
subss 0xc(%rsp), %xmm0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movss 0x4(%rax), %xmm1
subss 0x8(%rsp), %xmm1
movss 0xc(%rsp), %xmm2
movss 0x8(%rsp), %xmm3
callq 0x37e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movss (%rax), %xmm0
addss 0xc(%rsp), %xmm0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movss 0x4(%rax), %xmm1
subss 0x8(%rsp), %xmm1
movss 0xc(%rsp), %xmm2
movss 0x8(%rsp), %xmm3
callq 0x37e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x3d71
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movss 0x2ba(%rip), %xmm0      # 0x4088
mulss 0x8(%rax), %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movss 0x14(%rax), %xmm0
movq 0x18(%rsp), %rax
subss 0x10(%rax), %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movss 0x18(%rax), %xmm0
movq 0x18(%rsp), %rax
subss 0x14(%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x10(%rsp), %xmm0
movss 0xc(%rsp), %xmm1
callq 0x1080
movss %xmm0, 0x8(%rsp)
movss 0x14(%rsp), %xmm1
divss 0x8(%rsp), %xmm1
movss 0x26a(%rip), %xmm0      # 0x40a8
ucomiss %xmm1, %xmm0
seta %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x3e6e
cmpq $0x0, 0x10(%rsp)
jne 0x3e73
jmp 0x3f5b
movq 0x10(%rsp), %rdi
callq 0x38e0
testb $0x1, %al
jne 0x3e83
jmp 0x3ec5
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x37c0
testb $0x1, %al
jne 0x3ec5
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x3700
testb $0x1, %al
jne 0x3ec5
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x33c0
jmp 0x3f5b
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3db0
testb $0x1, %al
jne 0x3eda
jmp 0x3f0d
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rax
movss 0x10(%rax), %xmm0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movss 0x14(%rax), %xmm1
movq 0x10(%rsp), %rax
movq (%rax), %rax
movss 0x18(%rax), %xmm2
callq 0x3510
jmp 0x3f59
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x3e50
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x3e50
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x3e50
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x3e50
jmp 0x3f5b
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x4c0, %rsp            # imm = 0x4C0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x5e89
leaq 0x16e3(%rip), %rdi      # 0x7559
movb $0x0, %al
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5fed
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x4b8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1080
movq %rax, %rcx
movq -0x4b8(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x5ede
movq -0x18(%rbp), %rsi
leaq 0x16b1(%rip), %rdi      # 0x757c
movb $0x0, %al
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5fed
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1280
movl $0x0, -0x1c(%rbp)
leaq -0x420(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x10b0
movq -0x18(%rbp), %rdi
leaq -0x420(%rbp), %rsi
xorl %edx, %edx
movl $0x400, %ecx            # imm = 0x400
callq 0x5a50
movl %eax, -0x424(%rbp)
movl $0x400, -0x428(%rbp)    # imm = 0x400
cmpl $0x0, -0x424(%rbp)
jle 0x5fa0
leaq -0x420(%rbp), %rsi
movslq -0x424(%rbp), %rdx
movl $0x1, %edi
callq 0x1070
movl -0x424(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
leaq -0x420(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x10b0
movq -0x18(%rbp), %rdi
leaq -0x420(%rbp), %rsi
movl -0x428(%rbp), %edx
movl $0x400, %ecx            # imm = 0x400
callq 0x5a50
movl %eax, -0x424(%rbp)
movl -0x428(%rbp), %eax
addl $0x400, %eax            # imm = 0x400
movl %eax, -0x428(%rbp)
jmp 0x5f2c
leaq -0x4b0(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0x15ec(%rip), %rsi      # 0x759d
movb $0x0, %al
callq 0x1160
leaq -0x4b0(%rbp), %rax
movq %rax, -0x4c0(%rbp)
leaq -0x4b0(%rbp), %rdi
callq 0x1080
movq -0x4c0(%rbp), %rsi
movq %rax, %rdx
movl $0x2, %edi
callq 0x1070
movb $0x0, %al
callq 0x12e0
movl -0x4(%rbp), %eax
addq $0x4c0, %rsp            # imm = 0x4C0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/num/num.h
// Function: tt_vec_div_sca
static inline void _tt_vec_div_sca(double *vec, int n, double sca)
{
	if (_tt_is_zero(sca))
		tt_error("Divide by 0!");

	for (int i = 0; i < n; i++)
		vec[i] /= sca;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x1ed0
testb $0x1, %al
jne 0x1f14
jmp 0x1f2b
xorl %edi, %edi
leaq 0x62df(%rip), %rsi      # 0x81fc
leaq 0x62e8(%rip), %rdx      # 0x820c
movb $0x0, %al
callq 0x3600
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x1f68
movsd 0x10(%rsp), %xmm1
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1f33
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
cmpl $0x0, 0x54(%rsp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2136
xorl %edi, %edi
leaq 0x6103(%rip), %rsi      # 0x8219
leaq 0x606f(%rip), %rdx      # 0x818c
leaq 0x60fc(%rip), %rcx      # 0x8220
movl $0x18, %r8d
movb $0x0, %al
callq 0x3600
callq 0x1040
jmp 0x2138
movq $0x0, 0x48(%rsp)
movl 0x54(%rsp), %eax
cvtsi2sd %rax, %xmm1
movsd 0x61ee(%rip), %xmm0     # 0x8340
divsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x54(%rsp), %eax
jae 0x2297
movq 0x60(%rsp), %rax
movl 0x3c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq 0x60(%rsp), %rax
movl 0x3c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x54(%rsp), %eax
jae 0x2275
movsd 0x30(%rsp), %xmm0
callq 0x10d0
movsd %xmm0, 0x10(%rsp)
movsd 0x30(%rsp), %xmm0
callq 0x1130
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x18(%rsp)
movq %rsp, %rdi
movq 0x58(%rsp), %rsi
movl 0x2c(%rsp), %eax
shlq $0x4, %rax
addq %rax, %rsi
leaq 0x10(%rsp), %rdx
callq 0x22a0
movsd (%rsp), %xmm0
movq 0x60(%rsp), %rax
movl 0x3c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd 0x8(%rsp), %xmm0
movq 0x60(%rsp), %rax
movl 0x3c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x48(%rsp), %xmm0
addsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x21b2
movsd 0x40(%rsp), %xmm0
addsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x2164
xorl %eax, %eax
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/include/tt/num/complex.h
// Function: tt_complex_mul
static inline void tt_complex_mul(double *out,
		const double *in1, const double *in2)
{
	/* (a+bi)(c+di) */
	double ac = in1[0] * in2[0];
	double bd = in1[1] * in2[1];

#if 0
	/* This "smart" way is in fact slower than naive implementation */
	out[1] = (in1[0] + in1[1]) * (in2[0] + in2[1]) - ac - bd;
#else
	out[1] = in1[0] * in2[1] + in2[0] * in1[1];
#endif
	out[0] = ac - bd;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movq -0x18(%rsp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, -0x20(%rsp)
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rsp), %rax
mulsd 0x8(%rax), %xmm0
movsd %xmm0, -0x28(%rsp)
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movq -0x18(%rsp), %rax
movsd 0x8(%rax), %xmm2
movq -0x18(%rsp), %rax
movsd (%rax), %xmm1
movq -0x10(%rsp), %rax
mulsd 0x8(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x20(%rsp), %xmm0
subsd -0x28(%rsp), %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, (%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
cmpl $0x0, 0x54(%rsp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2386
xorl %edi, %edi
leaq 0x5ec8(%rip), %rsi      # 0x822e
leaq 0x5e1f(%rip), %rdx      # 0x818c
leaq 0x5eac(%rip), %rcx      # 0x8220
movl $0x3c, %r8d
movb $0x0, %al
callq 0x3600
callq 0x1040
jmp 0x2388
movq $0x0, 0x48(%rsp)
movl 0x54(%rsp), %eax
cvtsi2sd %rax, %xmm1
movsd 0x5f9e(%rip), %xmm0     # 0x8340
divsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x54(%rsp), %eax
jae 0x251b
movq 0x60(%rsp), %rax
movl 0x3c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq 0x60(%rsp), %rax
movl 0x3c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x54(%rsp), %eax
jae 0x24ae
movsd 0x30(%rsp), %xmm0
callq 0x10d0
movsd %xmm0, 0x10(%rsp)
movsd 0x30(%rsp), %xmm0
callq 0x1130
movsd %xmm0, 0x18(%rsp)
movq %rsp, %rdi
movq 0x58(%rsp), %rsi
movl 0x2c(%rsp), %eax
shlq $0x4, %rax
addq %rax, %rsi
leaq 0x10(%rsp), %rdx
callq 0x22a0
movsd (%rsp), %xmm0
movq 0x60(%rsp), %rax
movl 0x3c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd 0x8(%rsp), %xmm0
movq 0x60(%rsp), %rax
movl 0x3c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x48(%rsp), %xmm0
addsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2402
movl 0x54(%rsp), %eax
cvtsi2sd %rax, %xmm1
movq 0x60(%rsp), %rax
movl 0x3c(%rsp), %ecx
shlq $0x4, %rcx
movsd (%rax,%rcx), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx)
movl 0x54(%rsp), %eax
cvtsi2sd %rax, %xmm1
movq 0x60(%rsp), %rax
movl 0x3c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x40(%rsp), %xmm0
addsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x23b4
xorl %eax, %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2586
xorl %edi, %edi
leaq 0x5cd0(%rip), %rsi      # 0x8236
leaq 0x5c1f(%rip), %rdx      # 0x818c
leaq 0x5cac(%rip), %rcx      # 0x8220
movl $0x59, %r8d
movb $0x0, %al
callq 0x3600
callq 0x1040
jmp 0x2588
movq $0x0, 0x28(%rsp)
movl 0x34(%rsp), %eax
cvtsi2sd %rax, %xmm1
movsd 0x5d9e(%rip), %xmm0     # 0x8340
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x34(%rsp), %eax
jae 0x26df
movq 0x40(%rsp), %rax
movl 0x1c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq 0x40(%rsp), %rax
movl 0x1c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x34(%rsp), %eax
jae 0x26bd
movsd 0x10(%rsp), %xmm0
callq 0x10d0
movq 0x38(%rsp), %rax
movl 0xc(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm2
movq 0x40(%rsp), %rax
movl 0x1c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movsd 0x10(%rsp), %xmm0
callq 0x1130
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x38(%rsp), %rax
movl 0xc(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm2
movq 0x40(%rsp), %rax
movl 0x1c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x28(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2602
movsd 0x20(%rsp), %xmm0
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x25b4
xorl %eax, %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movl %edi, 0x3c(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
cvtsi2sdl 0x3c(%rsp), %xmm1
movsd 0x5bf1(%rip), %xmm0     # 0x8340
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x3c(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movslq %eax, %rdi
shlq $0x4, %rdi
callq 0x1120
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x27a3
xorl %edi, %edi
leaq 0x5b57(%rip), %rsi      # 0x82de
leaq 0x5b5b(%rip), %rdx      # 0x82e9
movb $0x0, %al
callq 0x3600
movq $0x0, 0x40(%rsp)
jmp 0x28f6
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x3c(%rsp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x18(%rsp), %eax
cmpl %ecx, %eax
jge 0x28ec
movsd 0x30(%rsp), %xmm0
callq 0x10d0
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm0, (%rax)
movsd 0x30(%rsp), %xmm0
callq 0x1130
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm0, 0x8(%rax)
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %ecx
movl 0x3c(%rsp), %eax
movl $0x4, %esi
cltd
idivl %esi
movl %eax, %edx
movq 0x8(%rsp), %rax
addl %edx, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm0, (%rax)
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x1c(%rsp), %ecx
movl 0x3c(%rsp), %eax
movl $0x4, %esi
cltd
idivl %esi
movl %eax, %edx
movq 0x10(%rsp), %rax
addl %edx, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm0, 0x8(%rax)
movsd 0x28(%rsp), %xmm0
addsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x27ab
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
cmpl $0x1, 0xc(%rsp)
jbe 0x293b
movl 0xc(%rsp), %eax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x2972
movl 0xc(%rsp), %ecx
movl $0x1, %edi
leaq 0x592b(%rip), %rsi      # 0x8276
leaq 0x592b(%rip), %rdx      # 0x827d
movb $0x0, %al
callq 0x3600
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x20e0
movl %eax, 0x24(%rsp)
jmp 0x2990
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
leaq 0x129(%rip), %rcx       # 0x2ab0
callq 0x29a0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movq %rcx, 0x30(%rsp)
movl 0x3c(%rsp), %edi
leaq 0x24(%rsp), %rsi
callq 0x31a0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x29df
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x2a9e
movl 0x3c(%rsp), %eax
tzcntl %eax, %eax
movl %eax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jae 0x2a4f
movq 0x48(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %edi
movl 0x20(%rsp), %esi
callq 0x3500
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
movl %eax, %eax
shlq $0x4, %rax
addq %rax, %rsi
callq 0x3240
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x29f3
movl $0x1, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x20(%rsp), %eax
jg 0x2a8c
movq 0x30(%rsp), %rax
movq 0x48(%rsp), %rdi
movl 0x18(%rsp), %esi
movl 0x3c(%rsp), %edx
movq 0x28(%rsp), %rcx
movl 0x24(%rsp), %r8d
callq *%rax
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x2a57
movq 0x28(%rsp), %rdi
callq 0x3220
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
cmpl $0x1, 0xc(%rsp)
jbe 0x2ceb
movl 0xc(%rsp), %eax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x2d25
movl 0xc(%rsp), %ecx
movl $0x1, %edi
leaq 0x55a8(%rip), %rsi      # 0x82a3
leaq 0x55a9(%rip), %rdx      # 0x82ab
movb $0x0, %al
callq 0x3600
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x2330
movl %eax, 0x24(%rsp)
jmp 0x2dc8
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
leaq 0xa6(%rip), %rcx        # 0x2de0
callq 0x29a0
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
je 0x2d54
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x2dc8
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0xc(%rsp), %eax
jae 0x2dc0
movl 0xc(%rsp), %eax
cvtsi2sd %rax, %xmm1
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
movsd (%rax,%rcx), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx)
movl 0xc(%rsp), %eax
cvtsi2sd %rax, %xmm1
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2d5c
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
cmpl $0x1, 0x2c(%rsp)
jbe 0x305b
movl 0x2c(%rsp), %eax
movl 0x2c(%rsp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x3095
movl 0x2c(%rsp), %ecx
movl $0x1, %edi
leaq 0x5267(%rip), %rsi      # 0x82d2
leaq 0x520b(%rip), %rdx      # 0x827d
movb $0x0, %al
callq 0x3600
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x2c(%rsp), %edx
callq 0x2530
movl %eax, 0x44(%rsp)
jmp 0x3188
movl 0x2c(%rsp), %edi
leaq 0x1c(%rsp), %rsi
callq 0x31a0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x30bd
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x3188
movl 0x2c(%rsp), %eax
tzcntl %eax, %eax
movl %eax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jae 0x313b
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %edi
movl 0x18(%rsp), %esi
callq 0x3500
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm0
movq 0x38(%rsp), %rax
movslq 0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm0, (%rax)
movq 0x38(%rsp), %rax
movslq 0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x30d1
movl $0x1, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x18(%rsp), %eax
jg 0x3176
movq 0x38(%rsp), %rdi
movl 0x10(%rsp), %esi
movl 0x2c(%rsp), %edx
movq 0x20(%rsp), %rcx
movl 0x1c(%rsp), %r8d
callq 0x2ab0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x3143
movq 0x20(%rsp), %rdi
callq 0x3220
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0xc(%rsp)
movq %rsi, (%rsp)
cmpl $0x2000, 0xc(%rsp)      # imm = 0x2000
jle 0x31ef
movl $0x2, %edi
leaq 0x5135(%rip), %rsi      # 0x82f7
leaq 0x5139(%rip), %rdx      # 0x8302
movl $0x2000, %ecx           # imm = 0x2000
movb $0x0, %al
callq 0x3600
movq (%rsp), %rax
movl $0x1, (%rax)
movl 0xc(%rsp), %edi
callq 0x2730
movq %rax, 0x10(%rsp)
jmp 0x320d
movl $0x2000, %eax           # imm = 0x2000
cltd
idivl 0xc(%rsp)
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movq 0x7f30(%rip), %rax      # 0xb138
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movl %edi, -0x4(%rsp)
movl $0x1, -0x8(%rsp)
movl -0x4(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rsp)
cmpl $0x0, -0x4(%rsp)
je 0x33f0
movl -0x4(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rsp)
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x33cc
movl -0x8(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movl $0x1, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x8(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0x344a
movq -0x8(%rsp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x8(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x3421
movl -0xc(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
je 0x3482
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x3490
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x3492
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x34d0
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x34b6
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0x34c0
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0x34eb
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x3492
movq 0x18(%rsp), %rdi
callq 0x1140
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl -0x4(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0x8(%rsp), %eax
subl $0x1, %eax
movl %eax, -0x10(%rsp)
movl -0x8(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rsp)
movl -0x4(%rsp), %eax
shrl %eax
movl %eax, -0x4(%rsp)
cmpl $0x0, -0x4(%rsp)
je 0x356b
movl -0xc(%rsp), %eax
shll %eax
movl %eax, -0xc(%rsp)
movl -0x4(%rsp), %eax
andl $0x1, %eax
orl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0x10(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rsp)
movl -0x4(%rsp), %eax
shrl %eax
movl %eax, -0x4(%rsp)
jmp 0x3534
movl -0x10(%rsp), %ecx
movl -0xc(%rsp), %eax
shll %cl, %eax
movl %eax, -0xc(%rsp)
movl -0x14(%rsp), %eax
subl $0x1, %eax
andl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/common/log.c
// Function: tt_log_set_level
int tt_log_set_level(int level)
{
	tt_assert(level >= 0 && level < TT_LOG_MAX);

	int old_level = __level;
	__level = level;

	return old_level;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x14(%rsp)
movb %al, 0xf(%rsp)
jl 0x3971
cmpl $0x4, 0x14(%rsp)
setl %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x39b1
xorl %edi, %edi
leaq 0x4a1a(%rip), %rsi      # 0x83ab
leaq 0x47f4(%rip), %rdx      # 0x818c
leaq 0x49fb(%rip), %rcx      # 0x839a
movl $0x1d, %r8d
movb $0x0, %al
callq 0x3600
callq 0x1040
jmp 0x39b3
movl 0x7707(%rip), %eax      # 0xb0c0
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x76f9(%rip)      # 0xb0c0
movl 0x10(%rsp), %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movl %edi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jl 0x39e8
movl 0x4(%rsp), %eax
movl %eax, 0x76de(%rip)      # 0xb0c4
jmp 0x3a0f
cmpl $0x0, 0x76d5(%rip)      # 0xb0c4
jl 0x3a0d
xorl %edi, %edi
callq 0x3590
movl 0x76c6(%rip), %edi      # 0xb0c4
callq 0x10c0
movl $0xffffffff, 0x76b7(%rip) # imm = 0xFFFFFFFF
jmp 0x3a0f
popq %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3a4d
movq 0x8(%rsp), %rax
movl (%rax), %edi
callq 0x3ab0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3a7a
xorl %edi, %edi
leaq 0x49e9(%rip), %rsi      # 0x844b
leaq 0x49f1(%rip), %rdx      # 0x845a
movb $0x0, %al
callq 0x3600
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0x3a9a
movq 0x8(%rsp), %rax
movl (%rax), %edi
callq 0x3bc0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/common/key.c
// Function: tt_swap_select
static void (*tt_swap_select(uint size))
	(const struct tt_key *, void *, void *)
{
	switch (size) {
	case 1:
		tt_debug("8-bit swap");
		return tt_swap_8;
	case 2:
		tt_debug("16-bit swap");
		return tt_swap_16;
	case 4:
		tt_debug("32-bit swap");
		return tt_swap_32;
	case 8:
		tt_debug("64-bit swap");
		return tt_swap_64;
	default:
		tt_debug("General swap");
		return tt_swap_general;
	}
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0xc(%rsp)
movl 0xc(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x7, %eax
ja 0x3b84
movq (%rsp), %rax
leaq 0x4870(%rip), %rcx      # 0x8348
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, %edi
leaq 0x4980(%rip), %rsi      # 0x846d
leaq 0x4988(%rip), %rdx      # 0x847c
movb $0x0, %al
callq 0x3600
leaq 0x1ce(%rip), %rax       # 0x3cd0
movq %rax, 0x10(%rsp)
jmp 0x3baa
movl $0x3, %edi
leaq 0x4955(%rip), %rsi      # 0x846d
leaq 0x4968(%rip), %rdx      # 0x8487
movb $0x0, %al
callq 0x3600
leaq 0x1e3(%rip), %rax       # 0x3d10
movq %rax, 0x10(%rsp)
jmp 0x3baa
movl $0x3, %edi
leaq 0x492d(%rip), %rsi      # 0x846d
leaq 0x494c(%rip), %rdx      # 0x8493
movb $0x0, %al
callq 0x3600
leaq 0x1fb(%rip), %rax       # 0x3d50
movq %rax, 0x10(%rsp)
jmp 0x3baa
movl $0x3, %edi
leaq 0x4905(%rip), %rsi      # 0x846d
leaq 0x4930(%rip), %rdx      # 0x849f
movb $0x0, %al
callq 0x3600
leaq 0x213(%rip), %rax       # 0x3d90
movq %rax, 0x10(%rsp)
jmp 0x3baa
movl $0x3, %edi
leaq 0x48dd(%rip), %rsi      # 0x846d
leaq 0x4914(%rip), %rdx      # 0x84ab
movb $0x0, %al
callq 0x3600
leaq 0x22b(%rip), %rax       # 0x3dd0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/common/key.c
// Function: tt_set_select
static void (*tt_set_select(uint size))
	(const struct tt_key *, void *, const void *)
{
	switch (size) {
	case 1:
		tt_debug("8-bit set");
		return tt_set_8;
	case 2:
		tt_debug("16-bit set");
		return tt_set_16;
	case 4:
		tt_debug("32-bit set");
		return tt_set_32;
	case 8:
		tt_debug("64-bit set");
		return tt_set_64;
	default:
		tt_info("General set");
		return tt_set_general;
	}
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0xc(%rsp)
movl 0xc(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x7, %eax
ja 0x3c94
movq (%rsp), %rax
leaq 0x4780(%rip), %rcx      # 0x8368
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, %edi
leaq 0x48bb(%rip), %rsi      # 0x84b8
leaq 0x48c2(%rip), %rdx      # 0x84c6
movb $0x0, %al
callq 0x3600
leaq 0x29e(%rip), %rax       # 0x3eb0
movq %rax, 0x10(%rsp)
jmp 0x3cba
movl $0x3, %edi
leaq 0x4890(%rip), %rsi      # 0x84b8
leaq 0x48a1(%rip), %rdx      # 0x84d0
movb $0x0, %al
callq 0x3600
leaq 0x293(%rip), %rax       # 0x3ed0
movq %rax, 0x10(%rsp)
jmp 0x3cba
movl $0x3, %edi
leaq 0x4868(%rip), %rsi      # 0x84b8
leaq 0x4884(%rip), %rdx      # 0x84db
movb $0x0, %al
callq 0x3600
leaq 0x28b(%rip), %rax       # 0x3ef0
movq %rax, 0x10(%rsp)
jmp 0x3cba
movl $0x3, %edi
leaq 0x4840(%rip), %rsi      # 0x84b8
leaq 0x4867(%rip), %rdx      # 0x84e6
movb $0x0, %al
callq 0x3600
leaq 0x283(%rip), %rax       # 0x3f10
movq %rax, 0x10(%rsp)
jmp 0x3cba
movl $0x2, %edi
leaq 0x4818(%rip), %rsi      # 0x84b8
leaq 0x484a(%rip), %rdx      # 0x84f1
movb $0x0, %al
callq 0x3600
leaq 0x27b(%rip), %rax       # 0x3f30
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movl (%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movl (%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, -0x20(%rsp)
movl -0x1c(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rsp)
cmpl $0x0, %eax
je 0x3e59
movq -0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rsp)
movq -0x18(%rsp), %rax
movl (%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
movl -0x24(%rsp), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rsp)
movq -0x18(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rsp)
jmp 0x3e05
jmp 0x3e5b
movl -0x20(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x20(%rsp)
cmpl $0x0, %eax
je 0x3eaf
movq -0x10(%rsp), %rax
movb (%rax), %al
movb %al, -0x25(%rsp)
movq -0x18(%rsp), %rax
movb (%rax), %cl
movq -0x10(%rsp), %rax
movb %cl, (%rax)
movb -0x25(%rsp), %cl
movq -0x18(%rsp), %rax
movb %cl, (%rax)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x3e5b
retq
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/common/round.c
// Function: tt_set_rounding
int tt_set_rounding(uint rnd)
{
	tt_assert(rnd < TT_ROUND_MAX);

	int r = _rounding;

	if (rnd == 0)
		_rounding = TT_ROUND_HALF_EVEN;
	else
		_rounding = rnd;

	return r;
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
cmpl $0x4, 0x4(%rsp)
setb %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3fa9
xorl %edi, %edi
leaq 0x4574(%rip), %rsi      # 0x84fd
leaq 0x41fc(%rip), %rdx      # 0x818c
leaq 0x4576(%rip), %rcx      # 0x850d
movl $0xd, %r8d
movb $0x0, %al
callq 0x3600
callq 0x1040
jmp 0x3fab
movl 0x711b(%rip), %eax      # 0xb0cc
movl %eax, (%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x3fc7
movl $0x1, 0x7107(%rip)      # 0xb0cc
jmp 0x3fd1
movl 0x4(%rsp), %eax
movl %eax, 0x70fb(%rip)      # 0xb0cc
movl (%rsp), %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/common/round.c
// Function: tt_round
int _tt_round(int odd, uint dig, int rnd)
{
	if (dig < 5)
		return 0;
	else if (dig > 5)
		return 1;

	if (rnd == 0)
		rnd = _rounding;

	switch (rnd) {
	case TT_ROUND_HALF_AWAY0:
		return 1;
	case TT_ROUND_HALF_EVEN:
		return !!odd;
	default:
		return 0;
	}
}

// Assembly:
movl %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
cmpl $0x5, -0xc(%rsp)
jae 0x3ffd
movl $0x0, -0x4(%rsp)
jmp 0x4064
cmpl $0x5, -0xc(%rsp)
jbe 0x400e
movl $0x1, -0x4(%rsp)
jmp 0x4064
jmp 0x4010
cmpl $0x0, -0x10(%rsp)
jne 0x4021
movl 0x70af(%rip), %eax      # 0xb0cc
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
movl %eax, -0x14(%rsp)
subl $0x1, %eax
je 0x4045
jmp 0x4030
movl -0x14(%rsp), %eax
subl $0x2, %eax
jne 0x405c
jmp 0x403b
movl $0x1, -0x4(%rsp)
jmp 0x4064
cmpl $0x0, -0x8(%rsp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
jmp 0x4064
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/common/rand.c
// Function: _tt_srand
static void __tt_srand(uint seed)
{
	_sv[0] = seed;
	for (int i = 1; i < MT_CNT; i++)
		_sv[i] = 1812433253ULL * (_sv[i-1] ^ (_sv[i-1] >> 30)) + i;
	_si = MT_CNT;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
movl %eax, 0x70d2(%rip)      # 0xb180
movl $0x1, -0x8(%rsp)
cmpl $0x270, -0x8(%rsp)      # imm = 0x270
jge 0x411c
movl -0x8(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x70af(%rip), %rax      # 0xb180
movl (%rax,%rcx,4), %eax
movl -0x8(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rdx
leaq 0x709b(%rip), %rcx      # 0xb180
movl (%rcx,%rdx,4), %ecx
shrl $0x1e, %ecx
xorl %ecx, %eax
movl %eax, %eax
imulq $0x6c078965, %rax, %rax # imm = 0x6C078965
movslq -0x8(%rsp), %rcx
addq %rcx, %rax
movl %eax, %edx
movslq -0x8(%rsp), %rcx
leaq 0x7074(%rip), %rax      # 0xb180
movl %edx, (%rax,%rcx,4)
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x40b6
movl $0x270, 0x6faa(%rip)    # imm = 0x270
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/common/rand.c
// Function: tt_rand
uint _tt_rand(void)
{
	uint r;

	pthread_mutex_lock(&_mtx);
	if (_si == -1)
		__tt_srand(clock());
	r = __tt_rand();
	pthread_mutex_unlock(&_mtx);

	return r;
}

// Assembly:
pushq %rax
leaq 0x7018(%rip), %rdi      # 0xb150
callq 0x1150
cmpl $-0x1, 0x6f8c(%rip)     # 0xb0d0
jne 0x4152
callq 0x1070
movl %eax, %edi
callq 0x40a0
callq 0x4170
movl %eax, 0x4(%rsp)
leaq 0x6fee(%rip), %rdi      # 0xb150
callq 0x1110
movl 0x4(%rsp), %eax
popq %rcx
retq
nopl (%rax)