LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/xmalloc.c
// Function: xmalloc_init
struct __xmem_struct* xmalloc_init( void* ptr, size_t size, int flags )
{
	struct __xmem_struct* xm = (struct __xmem_struct*)
		calloc(1,sizeof(struct __xmem_struct));

	xm->malloc_cache = 16;

	xm->malloc_hint = 0;

	malloc_init(xm);
	
	xm->membrk = xm->memlo = ptr;
	xm->memhi = (void*)((intptr_t)ptr + size);

	return xm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1, %edi
movl $0x98, %esi
callq 0x1170
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x10, 0x18(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x6c(%rax)
movq -0x20(%rbp), %rdi
callq 0x2470
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x20(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rcx
addq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/xmalloc.c
// Function: xposix_memalign
int
xposix_memalign(struct __xmem_struct* xm, void **memptr, size_t alignment, 
	size_t size)
{
    int err;
    void *result;

    /* Make sure that alignment is a large enough power of 2. */
    if (((alignment - 1) & alignment) != 0 || alignment < sizeof(void *))
	    return EINVAL;

    /* 
     * (size & alignment) is enough to assure the requested alignment, since
     * the allocator always allocates power-of-two blocks.
     */
    err = errno; /* Protect errno against changes in pubrealloc(). */
    result = pubrealloc(xm, NULL, (size & alignment),
		" in xposix_memalign()");
    errno = err;

    if (result == NULL)
	return ENOMEM;

    *memptr = result;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
subq $0x1, %rax
andq -0x20(%rbp), %rax
cmpq $0x0, %rax
jne 0x2a61
cmpq $0x8, -0x20(%rbp)
jae 0x2a6a
movl $0x16, -0x4(%rbp)
jmp 0x2ac6
callq 0x1060
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
andq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
leaq 0x287f(%rip), %rcx      # 0x530a
callq 0x2840
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x1060
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
cmpq $0x0, -0x38(%rbp)
jne 0x2ab4
movl $0xc, -0x4(%rbp)
jmp 0x2ac6
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/xmalloc.c
// Function: xcalloc
void *
xcalloc(struct __xmem_struct* xm, size_t num, size_t size)
{
    void *ret;

    if (size != 0 && (num * size) / size != num) {
	/* size_t overflow. */
	errno = ENOMEM;
	return (NULL);
    }

    ret = pubrealloc(xm, NULL, num * size, " in dcalloc():");

    if (ret != NULL)
	memset(ret, 0, num * size);

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2b17
movq -0x18(%rbp), %rax
imulq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x20(%rbp)
cmpq -0x18(%rbp), %rax
je 0x2b17
callq 0x1060
movl $0xc, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x2b5b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
imulq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
leaq 0x27f1(%rip), %rcx      # 0x5320
callq 0x2840
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2b53
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
imulq -0x20(%rbp), %rdx
xorl %esi, %esi
callq 0x1130
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/xmalloc.c
// Function: _sbrk
static void* __sbrk( struct __xmem_struct* xm, intptr_t incr )
{
	void* addr = xm->membrk + incr;
	if (addr < (void*)xm->memlo || addr > (void*)xm->memhi) 
		return (void*)-1;
	void* b = xm->membrk;
	xm->membrk = addr;
	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x80(%rcx), %rax
jb 0x2c81
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x88(%rcx), %rax
jbe 0x2c8e
movq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2cb4
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/xmalloc.c
// Function: ifree
static void
ifree( struct __xmem_struct* xm, void *ptr)
{
    struct pginfo *info;
    size_t idx;

    /* This is legal */
    if (ptr == NULL)
	return;

    idx = ptr2idx(ptr);

    if (idx < xm->malloc_pageshift) {
	wrtwarning("junk pointer, too low to make sense.\n");
	return;
    }

    if (idx > xm->last_idx) {
	wrtwarning("junk pointer, too high to make sense.\n");
	return;
    }

    info = xm->page_dir[idx];

    if (info < MALLOC_MAGIC)
        free_pages(xm, ptr, idx, info);
    else
	free_bytes(xm, ptr, idx, info);

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2d3c
jmp 0x2ddc
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
shrq %cl, %rax
movq -0x8(%rbp), %rcx
subq 0x20(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2d73
leaq 0x2697(%rip), %rdi      # 0x5403
callq 0x2ce0
jmp 0x2ddc
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jbe 0x2d8f
leaq 0x26a1(%rip), %rdi      # 0x5429
callq 0x2ce0
jmp 0x2ddc
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movl $0x4, %eax
cmpq %rax, -0x18(%rbp)
jae 0x2dc5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x31d0
jmp 0x2dda
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x36f0
jmp 0x2ddc
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/xmalloc.c
// Function: imalloc
static void *
imalloc( struct __xmem_struct* xm, size_t size)
{
    void *result;

    if ((size + xm->malloc_pagesize) < size)	/* Check for overflow */
	result = NULL;
    else if ((size + xm->malloc_pagesize) >= (uintptr_t)xm->page_dir)
	result = NULL;
    else if (size <= malloc_maxsize)
	result = malloc_bytes(xm, size);
    else
	result = malloc_pages(xm, size);

    if (malloc_abort && result == NULL)
	wrterror("allocation failed.\n");

    if (malloc_zero && result != NULL)
	memset(result, 0, size);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
addq (%rcx), %rax
cmpq -0x10(%rbp), %rax
jae 0x2e1b
movq $0x0, -0x18(%rbp)
jmp 0x2e78
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
addq (%rcx), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
cmpq %rcx, %rax
jb 0x2e3d
movq $0x0, -0x18(%rbp)
jmp 0x2e76
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
shrq %rcx
cmpq %rcx, %rax
ja 0x2e63
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x39a0
movq %rax, -0x18(%rbp)
jmp 0x2e74
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3b60
movq %rax, -0x18(%rbp)
jmp 0x2e76
jmp 0x2e78
cmpl $0x0, 0x4611(%rip)      # 0x7490
je 0x2e94
cmpq $0x0, -0x18(%rbp)
jne 0x2e94
leaq 0x2678(%rip), %rdi      # 0x5507
callq 0x2c00
cmpl $0x0, 0x4605(%rip)      # 0x74a0
je 0x2eb3
cmpq $0x0, -0x18(%rbp)
je 0x2eb3
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x1130
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/xmalloc.c
// Function: extend_pgdir
static int
extend_pgdir(struct __xmem_struct* xm, size_t idx)
{
    struct  pginfo **new, **old;
    size_t newlen, oldlen;

    /* check for overflow */
    if ((((~(1UL << ((sizeof(size_t) * NBBY) - 1)) / sizeof(*xm->page_dir)) + 1)
	+ (xm->malloc_pagesize / sizeof(*xm->page_dir))) < idx) {
	errno = ENOMEM;
	return 0;
    }

    /* Make it this many pages */
    newlen = pageround(idx * sizeof(*xm->page_dir)) + xm->malloc_pagesize;

    /* remember the old mapping size */
    oldlen = xm->malloc_ninfo * sizeof(*xm->page_dir);

    /*
     * NOTE: we allocate new pages and copy the directory rather than tempt
     * fate by trying to "grow" the region.. There is nothing to prevent
     * us from accidentally re-mapping space that's been allocated by our caller
     * via dlopen() or other mmap().
     *
     * The copy problem is not too bad, as there is 4K of page index per
     * 4MB of malloc arena.
     *
     * We can totally avoid the copy if we open a file descriptor to associate
     * the anon mappings with.  Then, when we remap the pages at the new
     * address, the old pages will be "magically" remapped..  But this means
     * keeping open a "secret" file descriptor.....
     */

    /* Get new pages */
    new = MMAP(newlen);
    if (new == MAP_FAILED)
	return 0;

    /* Copy the old stuff */
    memcpy(new, xm->page_dir, oldlen);

    /* register the new size */
    xm->malloc_ninfo = newlen / sizeof(*xm->page_dir);

    /* swap the pointers */
    old = xm->page_dir;
    xm->page_dir = new;

    /* Now free the old stuff */
    munmap(old, oldlen);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movabsq $0x1000000000000000, %rcx # imm = 0x1000000000000000
addq %rcx, %rax
cmpq -0x18(%rbp), %rax
jae 0x4225
callq 0x1060
movl $0xc, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x42eb
movq -0x18(%rbp), %rax
shlq $0x3, %rax
movq -0x10(%rbp), %rcx
addq 0x10(%rcx), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq -0x10(%rbp), %rcx
addq (%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
shlq $0x3, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r9d
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x10e0
movq %rax, -0x20(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x20(%rbp)
jne 0x429a
movl $0x0, -0x4(%rbp)
jmp 0x42eb
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x38(%rbp), %rdx
callq 0x1190
movq -0x30(%rbp), %rcx
shrq $0x3, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x11c0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/autogen/shmem_fcollect64.c
// Function: shmem_fcollect64
void shmem_fcollect64(void *dest, const void *source, size_t nelems, 
	int pe_start, int log_pe_stride, int pe_size, long* psync)
{
	const int step = 1 << log_pe_stride;
	const int pe_shift = pe_size << log_pe_stride;
	const int pe_end = pe_start + pe_shift;
	const int my_pe = __shmem.my_pe;

	const int nbytes = nelems << 3;

	const ptrdiff_t offset = nbytes * ((my_pe - pe_start) >> log_pe_stride);
	const void* target = (void*)((intptr_t)dest + offset);

	int pe = my_pe;

	do {
		shmemx_memcpy(shmem_ptr(target,pe), source, nelems*sizeof(int64_t));
		pe += step;
	} while (pe < pe_end);

	pe -= pe_shift;
	while (pe < my_pe) {
		shmemx_memcpy(shmem_ptr(target,pe), source, nelems*sizeof(int64_t));
		pe += step;
	}
	shmem_barrier(pe_start, log_pe_stride, pe_size, psync);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl -0x20(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl -0x20(%rbp), %ecx
shll %cl, %eax
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
leaq 0x2ea5(%rip), %rax      # 0x71f0
movl 0x4(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
shlq $0x3, %rax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl -0x34(%rbp), %edx
subl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
sarl %cl, %edx
movl %edx, %ecx
imull %ecx, %eax
cltq
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rdi
movl -0x4c(%rbp), %esi
callq 0x2130
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
shlq $0x3, %rdx
callq 0x4510
movl -0x28(%rbp), %eax
addl -0x4c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jl 0x4387
movl -0x2c(%rbp), %ecx
movl -0x4c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x43f6
movq -0x48(%rbp), %rdi
movl -0x4c(%rbp), %esi
callq 0x2130
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
shlq $0x3, %rdx
callq 0x4510
movl -0x28(%rbp), %eax
addl -0x4c(%rbp), %eax
movl %eax, -0x4c(%rbp)
jmp 0x43c3
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
movq 0x10(%rbp), %rcx
callq 0x4410
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/shmem_sync.c
// Function: shmem_sync
SHMEM_SCOPE
void shmem_sync(int pe_start, int log_pe_stride, int pe_size, long *psync)
{
	debug("[%d] shmem_sync begin",__shmem.my_pe);

	int pe_size_stride = pe_size << log_pe_stride;
	int pe_end = pe_size_stride + pe_start;

	int c, r;
	for (c = 0, r = (1 << log_pe_stride); r < pe_size_stride; c++, r <<= 1)
	{
		int to = __shmem.my_pe + r;
		if (to >= pe_end) to -= pe_size_stride;

		volatile long* lock = (volatile long*)(psync + c);
		long * remote_lock = (long*)shmem_ptr((void*)lock, to);

		__set_spin_lock(remote_lock);

		__clear_spin_lock(lock);
	}

	debug("[%d] shmem_sync end",__shmem.my_pe);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl -0x8(%rbp), %ecx
shll %cl, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x8(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4500
leaq 0x2d54(%rip), %rax      # 0x71f0
movl 0x4(%rax), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0x44b8
movl -0x1c(%rbp), %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x2130
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x4590
movq -0x38(%rbp), %rdi
callq 0x4550
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
shll %eax
movl %eax, -0x28(%rbp)
jmp 0x448d
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/src/test_liop.c
// Function: main
int main(){
  vl_int i ;
  VlLiopDesc * liop ;
  vl_size size = 11*11 ;
  float mat[] = {
    6,6,6,6,6,6,6,6,6,6,6,
    6,6,6,5,4,4,4,5,6,6,6,
    6,6,5,4,3,3,3,4,5,6,6,
    6,5,4,3,2,2,2,3,4,5,6,
    6,4,3,2,2,1,2,2,3,4,6,
    6,4,3,2,1,1,1,2,3,4,6,
    6,4,3,2,2,1,2,2,3,4,6,
    6,5,4,3,2,2,2,3,4,5,6,
    6,6,5,4,3,3,3,4,5,6,6,
    6,6,6,5,4,4,4,5,6,6,6,
    6,6,6,6,6,6,6,6,6,6,6};
  float * patch = vl_malloc(sizeof(float)*size);

  for(i = 0; i < (signed)size; i++){
    patch[i] = mat[i];
  }

  liop = vl_liopdesc_new(4,6,2,11);

  vl_liopdesc_delete(liop) ;
  vl_free(patch) ;
}

// Assembly:
subq $0x218, %rsp            # imm = 0x218
movl $0x0, 0x214(%rsp)
movq $0x79, 0x200(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0xe66(%rip), %rsi       # 0x2010
movl $0x1e4, %edx            # imm = 0x1E4
callq 0x1050
movq 0x200(%rsp), %rdi
shlq $0x2, %rdi
callq 0x1060
movq %rax, 0x8(%rsp)
movl $0x0, 0x210(%rsp)
movl 0x210(%rsp), %eax
movq 0x200(%rsp), %rcx
cmpl %ecx, %eax
jge 0x121b
movslq 0x210(%rsp), %rax
movss 0x10(%rsp,%rax,4), %xmm0
movq 0x8(%rsp), %rax
movslq 0x210(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x210(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x210(%rsp)
jmp 0x11d5
movl $0x4, %edi
movl $0x6, %esi
movss 0xdd7(%rip), %xmm0      # 0x2004
movl $0xb, %edx
callq 0x1070
movq %rax, 0x208(%rsp)
movq 0x208(%rsp), %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1040
movl 0x214(%rsp), %eax
addq $0x218, %rsp            # imm = 0x218
retq
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/aux_funcs.c
// Function: create_state
t_qlayer	*create_state(int node, t_vect *path)
{
	t_qlayer	*new = (t_qlayer*)malloc(sizeof(t_qlayer));
	t_vect		*copy = (t_vect*)malloc(sizeof(t_vect));

	init_vector(copy);
	for (int i = 0;i < (int)path->used; i++)
		push_back(copy, path->tab[i]);
	new->prefix = copy;
	new->node = node;
	return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x20, %edi
callq 0x1060
movq %rax, -0x18(%rbp)
movl $0x18, %edi
callq 0x1060
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x25c0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl %ecx, %eax
jge 0x122c
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x26f0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x11fb
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/aux_funcs.c
// Function: append
t_vect	*append(t_vect *src, int add)
{
	t_vect		*copy = (t_vect*)malloc(sizeof(t_vect));

	init_vector(copy);
	for (int i = 0; i < (int)src->used; i++)
		push_back(copy, src->tab[i]);
	push_back(copy, add);
	return copy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x18, %edi
callq 0x1060
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x25c0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl %ecx, %eax
jge 0x12ae
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x26f0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x127d
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x26f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/comparators.c
// Function: cmp_path
int		cmp_path(const void *p, const void *q)
{
	size_t lastp = ((t_vect*)p)->used;
	size_t lastq = ((t_vect*)q)->used;
	if ((*(t_vect*)p).tab[lastp-1] == (*(t_vect*)q).tab[lastq-1])
		return (((t_vect*)p)->used - ((t_vect*)q)->used);
	return ((*(t_vect*)p).tab[lastp-1] - (*(t_vect*)q).tab[lastq-1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq -0x28(%rbp), %rdx
subq $0x1, %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x132f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
subq 0x10(%rcx), %rax
movl %eax, -0x4(%rbp)
jmp 0x1356
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq -0x28(%rbp), %rdx
subq $0x1, %rdx
subl (%rcx,%rdx,4), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/error.c
// Function: error
void	error(int a)
{
	if (a == WRONG_INPUT)
		printf("WRONG NUMBER OF VERTICES OF EDGES\n");
	else if (a == WRONG_EDGE)
		printf("WRONG EDGE\n");
	exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x13e1
leaq 0x1c3f(%rip), %rdi      # 0x3017
movb $0x0, %al
callq 0x1040
jmp 0x13f7
cmpl $0x1, -0x4(%rbp)
jne 0x13f5
leaq 0x1c4c(%rip), %rdi      # 0x303a
movb $0x0, %al
callq 0x1040
jmp 0x13f7
xorl %edi, %edi
callq 0x1080
nop
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/graph.c
// Function: add_edge
void	add_edge(t_graph *g, int a, int b)
{
	g->edg++;
	push_back(&g->adj[a],b);
	if (g->direct == 0)
	{
		g->edg++;
		push_back(&g->adj[b],a);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x26f0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jne 0x146a
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x26f0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/graph.c
// Function: init_adj
int	init_adj(t_graph *g)
{
	if(!(g->adj = (t_vect*)malloc(sizeof(t_vect)*g->vertx)))
		return 0;
	for (int i = 0; i < g->vertx; i++)
		if (!(init_vector(&g->adj[i])))
			return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movslq 0x28(%rax), %rax
imulq $0x18, %rax, %rdi
callq 0x1060
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x1503
movl $0x0, -0x4(%rbp)
jmp 0x154f
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x1548
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x25c0
cmpl $0x0, %eax
jne 0x153b
movl $0x0, -0x4(%rbp)
jmp 0x154f
jmp 0x153d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x150a
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/graph.c
// Function: get_dimensions
int		get_dimensions(t_graph *new)
{
	int n, m, dir, search;

	scanf("%d %d %d %d", &n, &m, &dir, &search);
	if (!valid_dimensions(n,m,new))
	{
		free(new);
		return 0;
	}
	if (!valid_params(dir, search, new))
	{
		free(new);
		return 0;
	}
	if (!init_adj(new))
		return 0;
	new->vis = (int*)malloc(sizeof(int) * new->vertx);
	new->rank = (int*)malloc(sizeof(int) * new->vertx);
	new->search = search - 1;
	memset(new->vis, 0, new->vertx * sizeof(int));
	memset(new->rank, 0 , new->vertx * sizeof(int));
	new->ranked = (t_vect*)malloc(sizeof(t_vect) * (new->vertx + 1));
	for (int i = 0; i < new->vertx + 1 ; i++)
		init_vector(&(new->ranked[i]));
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x1ad3(%rip), %rdi      # 0x3046
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x1c(%rbp), %rcx
leaq -0x20(%rbp), %r8
movb $0x0, %al
callq 0x1070
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x2490
cmpl $0x0, %eax
jne 0x15b3
movq -0x10(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
jmp 0x16d3
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x2330
cmpl $0x0, %eax
jne 0x15dc
movq -0x10(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
jmp 0x16d3
movq -0x10(%rbp), %rdi
callq 0x14d0
cmpl $0x0, %eax
jne 0x15f6
movl $0x0, -0x4(%rbp)
jmp 0x16d3
movq -0x10(%rbp), %rax
movslq 0x28(%rax), %rdi
shlq $0x2, %rdi
callq 0x1060
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movslq 0x28(%rax), %rdi
shlq $0x2, %rdi
callq 0x1060
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x28(%rax), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x1050
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x28(%rax), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x1050
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
addl $0x1, %eax
cltq
imulq $0x18, %rax, %rdi
callq 0x1060
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x28(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x16cc
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x24(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x25c0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1698
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/graph.c
// Function: get_edges
int 	get_edges(t_graph *g)
{
	t_pair *got = (t_pair*)malloc(sizeof(t_pair)*g->in_edg);

	for (int i = 0; i < g->in_edg; i++)
	{
		scanf("%d %d",&(got[i].x),&(got[i].y));
		if (!valid_edge(got, i, g))
			return (error_edge(got, i));
	}
	insert_edges(got, g);
	free(got);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movslq 0x30(%rax), %rdi
shlq $0x3, %rdi
callq 0x1060
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0x1777
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
movslq -0x1c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
addq $0x4, %rdx
leaq 0x190f(%rip), %rdi      # 0x304c
movb $0x0, %al
callq 0x1070
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x23a0
cmpl $0x0, %eax
jne 0x176a
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1380
movl %eax, -0x4(%rbp)
jmp 0x1794
jmp 0x176c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1708
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1470
movq -0x18(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/graph.c
// Function: generate_graph
t_graph *generate_graph()
{
	t_graph *new = (t_graph*)malloc(sizeof(t_graph));
	if (!get_dimensions(new))
		error(WRONG_INPUT);
	if (!get_edges(new))
		error(WRONG_EDGE);
	return (new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x40, %edi
callq 0x1060
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1560
cmpl $0x0, %eax
jne 0x17cb
xorl %edi, %edi
callq 0x13c0
movq -0x8(%rbp), %rdi
callq 0x16e0
cmpl $0x0, %eax
jne 0x17e3
movl $0x1, %edi
callq 0x13c0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/main_rank.c
// Function: all_paths_are_good
int		all_paths_are_good(t_graph *g, int src, int dest, int rank)
{
	size_t pos = 0;
	int		tag = 0;

	while (pos < g->paths[src]->used)
	{
		if (g->paths[src]->path[pos].tab[g->paths[src]->path[pos].used - 1] != dest )
		{
			pos++;
			continue;
		}
		tag = 0;
		if ((int)g->paths[src]->path[pos].used <= 2)
			return 0;
		for (int i = 1; i < (int)g->paths[src]->path[pos].used - 1; i++)
		{
			if (g->rank[g->paths[src]->path[pos].tab[i]] == 0 || g->rank[g->paths[src]->path[pos].tab[i]] > rank)
			{
				tag = 1;
				break;
			}
		}
		if (!tag)
			return 0;
		pos++;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq 0x10(%rcx), %rax
jae 0x1b73
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rcx), %rcx
imulq $0x18, -0x28(%rbp), %rdx
addq %rdx, %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x18(%rbp), %eax
je 0x1a65
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x19f0
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
cmpl $0x2, %eax
jg 0x1a9c
movl $0x0, -0x4(%rbp)
jmp 0x1b7a
movl $0x1, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rcx), %rcx
imulq $0x18, -0x28(%rbp), %rdx
addq %rdx, %rcx
movq 0x10(%rcx), %rcx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1b53
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rcx), %rcx
imulq $0x18, -0x28(%rbp), %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
movslq -0x30(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x1b3a
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rcx), %rcx
imulq $0x18, -0x28(%rbp), %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
movslq -0x30(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x1c(%rbp), %eax
jle 0x1b43
movl $0x1, -0x2c(%rbp)
jmp 0x1b53
jmp 0x1b45
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1aa3
cmpl $0x0, -0x2c(%rbp)
jne 0x1b62
movl $0x0, -0x4(%rbp)
jmp 0x1b7a
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x19f0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/main_rank.c
// Function: main
int main()
{
	t_graph *g;
	g = generate_graph();
	init_paths(g);
	int unexplored = 1;
	// finds all paths between all points
	for (int i = 0; i < g->vertx; i++)
		find_all_paths(g, i);
	// loops over all scc s
	while (unexplored)
	{
		unexplored = 0;
		// greedy search for a minimal ranking
		rank(g, g->search);
		// check for unexplored vertices
		for (int i = 0; i < g->vertx; i++)
			if (g->rank[i] == 0)
			{
			   unexplored = 1;
			   g->search = i;
			}
	}
	for (int i = 0; i < g->vertx; i++)
		printf("%d ", g->rank[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movb $0x0, %al
callq 0x17a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ea0
movl $0x1, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x1df4
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x17f0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1dd1
jmp 0x1df6
cmpl $0x0, -0x14(%rbp)
je 0x1e58
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x38(%rax), %esi
callq 0x1b80
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x1e56
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x1e49
movl $0x1, -0x14(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
jmp 0x1e4b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1e1a
jmp 0x1df6
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x1e93
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x11d1(%rip), %rdi      # 0x3052
movb $0x0, %al
callq 0x1040
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1e5f
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/path_routines.c
// Function: init_paths
void	init_paths(t_graph *g)
{
	t_paths **new = (t_paths**)malloc(sizeof(t_paths*) * g->vertx);

	for (int i = 0; i < g->vertx ; i++)
	{
		new[i] = (t_paths*)malloc(sizeof(t_paths));
		new[i]->path = (t_vect*)malloc(sizeof(t_vect)*50);
		for (int j = 0; j < 50; j++)
			init_vector(&new[i]->path[j]);
		new[i]->size = 50;
		new[i]->used = 0;
	}
	g->paths = new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rdi
shlq $0x3, %rdi
callq 0x1060
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x1f7a
movl $0x18, %edi
callq 0x1060
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x4b0, %edi            # imm = 0x4B0
callq 0x1060
movq %rax, %rcx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, (%rax)
movl $0x0, -0x18(%rbp)
cmpl $0x32, -0x18(%rbp)
jge 0x1f44
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
movslq -0x18(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x25c0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1f14
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq $0x32, 0x8(%rax)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq $0x0, 0x10(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1ec8
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/path_routines.c
// Function: extend_paths
void	extend_paths(t_graph *g, int start)
{
	size_t new_size = g->paths[start]->size * 2;

	t_vect *copy = (t_vect*)malloc(sizeof(t_vect)*new_size); 
	for (int i = 0; i < (int)new_size; i++)
		init_vector(&copy[i]);
	for (int i = 0; i < (int)g->paths[start]->size; i++)
	{
		for (int j = 0; j < (int)g->paths[start]->path[i].used; j++)
			push_back(&copy[i],g->paths[start]->path[i].tab[j]);
	}
	g->paths[start]->path = copy;
	g->paths[start]->size = new_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x18(%rbp)
imulq $0x18, -0x18(%rbp), %rdi
callq 0x1060
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl %ecx, %eax
jge 0x1ff9
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x25c0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1fcf
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x8(%rcx), %rcx
cmpl %ecx, %eax
jge 0x20a6
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rcx), %rcx
movslq -0x28(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq 0x10(%rcx), %rcx
cmpl %ecx, %eax
jge 0x2096
movq -0x20(%rbp), %rdi
movslq -0x28(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movslq -0x28(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x26f0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2026
jmp 0x2098
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2000
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/path_routines.c
// Function: add_path
void	add_path(t_graph *g, t_vect *new, int start)
{
	size_t pos = g->paths[start]->used;
	size_t size = g->paths[start]->size;

	if (pos >= size)
		extend_paths(g, start);
	for (int i = 0 ; i < (int)new->used; i++)
		push_back(&g->paths[start]->path[pos], new->tab[i]);
	g->paths[start]->used++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x2139
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1f90
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl %ecx, %eax
jge 0x2188
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
imulq $0x18, -0x20(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x26f0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2140
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/queue.c
// Function: push_q
void	push_q(t_queue *que, t_qlayer *new)
{
	if (que->size == 0)
	{
		new->next = NULL;
		new->prev = NULL;
		que->head = new;
		que->tail = new;
	}
	else
	{
		new->prev = que->tail;
		que->tail->next = new;
		que->tail = new;
		new->next = NULL;
	}
	que->size++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x21f8
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2230
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/queue.c
// Function: pop_q
void	pop_q(t_queue *que)
{
	t_qlayer *tmp;
	if (que->size < 1)
	{
		free(que->head->prefix->tab);
		free(que->head->prefix);
		free(que->head);
		return;
	}
	else
	{
		tmp = que->head->next;
		free(que->head->prefix->tab);
		free(que->head->prefix);
		free(que->head);
		que->head = tmp;
		que->size--;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x1, 0x10(%rax)
jae 0x2296
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
jmp 0x22ed
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/validation.c
// Function: valid_params
int		valid_params(int dir, int node, t_graph *g)
{
	if (dir != 0 && dir != 1)
		return 0;
	if (node <= 0 || node > g->vertx)
		return 0;
	g->search = node - 1;
	g->direct = dir;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x2353
cmpl $0x1, -0x8(%rbp)
je 0x2353
movl $0x0, -0x4(%rbp)
jmp 0x238c
cmpl $0x0, -0xc(%rbp)
jle 0x2365
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jle 0x236e
movl $0x0, -0x4(%rbp)
jmp 0x238c
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x38(%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x34(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/validation.c
// Function: valid_edge
int		valid_edge(t_pair *got, int i, t_graph *g)
{
	got[i].x--;
	got[i].y--;
	if (got[i].x < 0 || got[i].x >= g->vertx)
	   return 0;
	if (got[i].y < 0 || got[i].y >= g->vertx)
		return 0;
	if (g->direct == 0 && got[i].x > got[i].y)
		swap(&got[i].x, &got[i].y);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,8), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %edx
addl $-0x1, %edx
movl %edx, 0x4(%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,8)
jl 0x23f9
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movq -0x20(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jl 0x2402
movl $0x0, -0x4(%rbp)
jmp 0x2480
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x0, 0x4(%rax,%rcx,8)
jl 0x2426
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %eax
movq -0x20(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jl 0x242f
movl $0x0, -0x4(%rbp)
jmp 0x2480
movq -0x20(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jne 0x2479
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
cmpl 0x4(%rcx,%rdx,8), %eax
jle 0x2479
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
addq $0x4, %rsi
callq 0x1190
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/validation.c
// Function: valid_dimensions
int 	valid_dimensions(int n, int m, t_graph *g)
{
	if (n < 0 || m < 0)
		return 0;
	g->vertx = n;
	g->edg = 0;
	g->in_edg = m;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x24aa
cmpl $0x0, -0xc(%rbp)
jge 0x24b3
movl $0x0, -0x4(%rbp)
jmp 0x24d9
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x2c(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x30(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/queue_int.c
// Function: push_q_i
void	push_q_i(t_queue_int *que, t_qlayer_int *new)
{
	if (que->size == 0)
	{
		new->next = NULL;
		new->prev = NULL;
		que->head = new;
		que->tail = new;
	}
	else
	{
		new->prev = que->tail;
		que->tail->next = new;
		que->tail = new;
		new->next = NULL;
	}
	que->size++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x2527
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x255e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/queue_int.c
// Function: pop_q_i
void	pop_q_i(t_queue_int *que)
{
	t_qlayer_int *tmp;
	if (que->size < 1)
		return;
	else
		tmp = que->head->next;
		que->head = tmp;
		que->size--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x1, 0x10(%rax)
jae 0x2585
jmp 0x25af
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/vector.c
// Function: init_vector
int	init_vector(t_vect *v)
{
	v->size = 50;
	v->used = 0;
	if (!(v->tab = (int*)malloc(sizeof(int)*50)))
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x32, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movl $0xc8, %edi
callq 0x1060
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x2604
movl $0x0, -0x4(%rbp)
jmp 0x260b
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/vector.c
// Function: extend_vector
void	extend_vector(t_vect *v, int a)
{
	size_t	size = v->size;
	size_t	new_size = size * 2;
	int		*new_nodes = (int*)malloc(sizeof(int)*new_size);

	copy_vector(v->tab, new_nodes, size);
	free(v->tab);
	v->size = new_size;
	v->tab = new_nodes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1060
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x26a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)