LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/cbmdosinode.c
// Function: CbmdosInode_blocks
SOEXPORT uint16_t CbmdosInode_blocks(const CbmdosInode *self)
{
    if (!self->data)
    {
	return 0;
    }
    size_t size = FileData_size(self->data);
    uint16_t blocks = size / 254;
    if (size % 254) ++blocks;
    return blocks;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xf80e
movw $0x0, -0x2(%rbp)
jmp 0xf858
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5550
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0xfe, %ecx
xorl %edx, %edx
divq %rcx
movw %ax, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movl $0xfe, %ecx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
je 0xf850
movw -0x1a(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x1a(%rbp)
movw -0x1a(%rbp), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/cbmdosinode.c
// Function: CbmdosInode_setOptOverrides
SOEXPORT void CbmdosInode_setOptOverrides(
        CbmdosInode *self, CbmdosFsOptOverrides overrides)
{
    if (overrides.mask != self->overrides.mask
	    || overrides.flags != self->overrides.flags)
    {
	self->overrides = overrides;
	CbmdosInodeEventArgs args = { CIE_OPTOVERRIDESCHANGED };
	Event_raise(self->changedEvent, &args);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0xf8b8
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
je 0xf8de
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl 0x420e(%rip), %eax      # 0x13ad8
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x14(%rbp), %rsi
callq 0x5620
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/cbmdosinode.c
// Function: CbmdosInode_detach
SOLOCAL void CbmdosInode_detach(CbmdosInode *self)
{
    if (!self->refcount)
    {
	logmsg(L_ERROR, "CbmdosInode_detach(): trying to detach an inode "
		"that isn't attached.");
	return;
    }
    --self->refcount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xf959
movl $0x1, %edi
leaq 0x4bd1(%rip), %rsi      # 0x14523
callq 0x5a60
jmp 0xf966
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/cbmdosinode.c
// Function: CbmdosInode_tryDestroy
SOLOCAL void CbmdosInode_tryDestroy(CbmdosInode *self)
{
    if (!self) return;
    if (self->refcount) return;
    Event_destroy(self->changedEvent);
    FileData_destroy(self->data);
    free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xf985
jmp 0xf9b3
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0xf991
jmp 0xf9b3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5180
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x5410
movq -0x8(%rbp), %rdi
callq 0x5070
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/lynx.c
// Function: isLynx
SOEXPORT int isLynx(const FileData *file)
{
    size_t size = FileData_size(file);
    const uint8_t *content = FileData_rcontent(file);
    size_t sigpos;
    uint8_t dirblocks;
    size_t dirpos;
    if (findHeader(&sigpos, &dirblocks, &dirpos, content, size) < 0) return 0;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5550
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x56a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %r8
leaq -0x28(%rbp), %rdi
leaq -0x29(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xfa20
cmpl $0x0, %eax
jge 0xfa0d
movl $0x0, -0x4(%rbp)
jmp 0xfa14
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/lynx.c
// Function: archiveLynx
SOEXPORT FileData *archiveLynx(const CbmdosVfs *vfs)
{
    unsigned filecount = CbmdosVfs_fileCount(vfs);
    if (!filecount) return 0;
    const CbmdosFile **files = xmalloc(filecount * sizeof *files);
    unsigned realFilecount = 0;
    for (unsigned i = 0; i < filecount; ++i)
    {
	const CbmdosFile *file = CbmdosVfs_rfile(vfs, i);
	if (CbmdosFile_type(file) != CFT_DEL)
	{
	    files[realFilecount++] = file;
	}
    }
    if (!realFilecount)
    {
	free(files);
	return 0;
    }
    FileData *archive = archiveLynxFiles(files, realFilecount);
    free(files);
    return archive;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5260
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x111bb
movq $0x0, -0x8(%rbp)
jmp 0x11261
movl -0x14(%rbp), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x58d0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x11227
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x5360
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x57f0
cmpl $0x0, %eax
je 0x1121a
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x1121c
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x111db
cmpl $0x0, -0x24(%rbp)
jne 0x11240
movq -0x20(%rbp), %rdi
callq 0x5070
movq $0x0, -0x8(%rbp)
jmp 0x11261
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x54a0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5070
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/petscii.c
// Function: petscii_mapUpperGfxToLower
SOEXPORT void petscii_mapUpperGfxToLower(char *str, size_t len)
{
    for (size_t i = 0; i < len; ++i)
    {
	if (str[i] == (char)0x62 || str[i] == (char)0xc2)
	{
	    str[i] = (char)0x7d;
	}
	else if (str[i] == (char)0x63 || str[i] == (char)0xc3)
	{
	    str[i] = (char)0x60;
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x1154e
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x62, %eax
je 0x11500
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $-0x3e, %eax
jne 0x1150e
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x7d, (%rax,%rcx)
jmp 0x1153e
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x63, %eax
je 0x11530
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $-0x3d, %eax
jne 0x1153c
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x60, (%rax,%rcx)
jmp 0x1153e
jmp 0x11540
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x114d4
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/petscii.c
// Function: petscii_toUtf8
SOEXPORT size_t petscii_toUtf8(
        char *buf, size_t bufsz, const char *str, size_t len, int lowercase,
        int onlyPrintable, const char *unknown, const char *shiftspace)
{
    size_t bufpos = 0;
    size_t result = 0;
    for (size_t i = 0; i < len; ++i)
    {
        unsigned char petsciiChar = (unsigned char)str[i];
        if (shiftspace && petsciiChar == 0xa0)
        {
            result += appendUtf8(buf, bufsz, &bufpos, shiftspace);
            continue;
        }
        char screencode = toScreencode(petsciiChar);
        const char *utf8Char = 0;
        if (screencode < 0)
        {
            if (!onlyPrintable) utf8Char = nonprintable(petsciiChar);
        }
        else
        {
            utf8Char = screencodeToUtf8(screencode, lowercase);
        }
        if (utf8Char)
        {
            result += appendUtf8(buf, bufsz, &bufpos, utf8Char);
        }
        else if (unknown)
        {
            result += appendUtf8(buf, bufsz, &bufpos, unknown);
        }
    }
    return result + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x11683
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x41(%rbp)
cmpq $0x0, 0x18(%rbp)
je 0x115e0
movzbl -0x41(%rbp), %eax
cmpl $0xa0, %eax
jne 0x115e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x18(%rbp), %rcx
leaq -0x30(%rbp), %rdx
callq 0x116a0
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x11672
movzbl -0x41(%rbp), %edi
callq 0x11710
movb %al, -0x42(%rbp)
movq $0x0, -0x50(%rbp)
movsbl -0x42(%rbp), %eax
cmpl $0x0, %eax
jge 0x11612
cmpl $0x0, -0x28(%rbp)
jne 0x11610
movzbl -0x41(%rbp), %edi
callq 0x117c0
movq %rax, -0x50(%rbp)
jmp 0x11624
movb -0x42(%rbp), %al
movl -0x24(%rbp), %esi
movsbl %al, %edi
callq 0x11850
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x1164a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x50(%rbp), %rcx
leaq -0x30(%rbp), %rdx
callq 0x116a0
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x11670
cmpq $0x0, 0x10(%rbp)
je 0x1166e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x10(%rbp), %rcx
leaq -0x30(%rbp), %rdx
callq 0x116a0
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x11670
jmp 0x11672
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x11590
movq -0x38(%rbp), %rax
addq $0x1, %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/petscii.c
// Function: appendUtf8
static size_t appendUtf8(
	char *buf, size_t bufsz, size_t *bufpos, const char *chrStr)
{
    size_t chrLen = strlen(chrStr);
    if (bufsz > *bufpos + chrLen + 1)
    {
        strcpy(buf + *bufpos, chrStr);
    }
    *bufpos += chrLen;
    return chrLen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5270
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
addq -0x28(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x116f1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
addq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x5100
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/petscii.c
// Function: toScreencode
static char toScreencode(unsigned char petsciiChar)
{
    if ((petsciiChar & 0x7f) < 0x20) return -1;
    if (petsciiChar >= 0x20 && petsciiChar < 0x40) return petsciiChar;
    if (petsciiChar >= 0x40 && petsciiChar < 0x60) return petsciiChar - 0x40;
    if (petsciiChar >= 0x60 && petsciiChar < 0x80) return petsciiChar - 0x20;
    if (petsciiChar >= 0xa0 && petsciiChar < 0xc0) return petsciiChar - 0x40;
    return petsciiChar - 0x80;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
andl $0x7f, %eax
cmpl $0x20, %eax
jge 0x1172f
movb $-0x1, -0x1(%rbp)
jmp 0x117b5
movzbl -0x2(%rbp), %eax
cmpl $0x20, %eax
jl 0x11749
movzbl -0x2(%rbp), %eax
cmpl $0x40, %eax
jge 0x11749
movb -0x2(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x117b5
movzbl -0x2(%rbp), %eax
cmpl $0x40, %eax
jl 0x11767
movzbl -0x2(%rbp), %eax
cmpl $0x60, %eax
jge 0x11767
movzbl -0x2(%rbp), %eax
subl $0x40, %eax
movb %al, -0x1(%rbp)
jmp 0x117b5
movzbl -0x2(%rbp), %eax
cmpl $0x60, %eax
jl 0x11787
movzbl -0x2(%rbp), %eax
cmpl $0x80, %eax
jge 0x11787
movzbl -0x2(%rbp), %eax
subl $0x20, %eax
movb %al, -0x1(%rbp)
jmp 0x117b5
movzbl -0x2(%rbp), %eax
cmpl $0xa0, %eax
jl 0x117a9
movzbl -0x2(%rbp), %eax
cmpl $0xc0, %eax
jge 0x117a9
movzbl -0x2(%rbp), %eax
subl $0x40, %eax
movb %al, -0x1(%rbp)
jmp 0x117b5
movzbl -0x2(%rbp), %eax
subl $0x80, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/petscii.c
// Function: nonprintable
static const char* nonprintable(unsigned char petsciiChar)
{
    if ((petsciiChar & 0x7f) > 0x1f) return 0;
    switch (petsciiChar)
    {
        case 0x3: return "\x03";
        case 0xd: return "\x0a";
        case 0x14: return "\x08";
        case 0x8d: return "\x0d";
        default: return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
andl $0x7f, %eax
cmpl $0x1f, %eax
jle 0x117e0
movq $0x0, -0x8(%rbp)
jmp 0x1184a
movzbl -0x9(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x3, %eax
je 0x1180e
jmp 0x117ee
movl -0x10(%rbp), %eax
subl $0xd, %eax
je 0x1181b
jmp 0x117f8
movl -0x10(%rbp), %eax
subl $0x14, %eax
je 0x11828
jmp 0x11802
movl -0x10(%rbp), %eax
subl $0x8d, %eax
je 0x11835
jmp 0x11842
leaq 0x313f(%rip), %rax      # 0x14954
movq %rax, -0x8(%rbp)
jmp 0x1184a
leaq 0x3134(%rip), %rax      # 0x14956
movq %rax, -0x8(%rbp)
jmp 0x1184a
leaq 0x3129(%rip), %rax      # 0x14958
movq %rax, -0x8(%rbp)
jmp 0x1184a
leaq 0x311e(%rip), %rax      # 0x1495a
movq %rax, -0x8(%rbp)
jmp 0x1184a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/petscii.c
// Function: petscii_fromUtf8
SOEXPORT size_t petscii_fromUtf8(
	char *buf, size_t bufsz, const char *str, size_t len,
	PetsciiCase casemode, int onlyPrintable, char unknown)
{
    size_t strpos = 0;
    size_t bufpos = 0;
    size_t result = 0;

    while (strpos < len)
    {
	if ((unsigned char)str[strpos] < 0x20)
	{
	    if (!onlyPrintable)
	    {
		unsigned char npp = nppetscii(str[strpos]);
		if (npp) result += appendPetscii(buf, bufsz, &bufpos, npp);
	    }
	    ++strpos;
	}
	else
	{
	    char screencode = screencodeFromUtf8(str, len, &strpos, &casemode);
	    if ((unsigned char)screencode < 0x80)
	    {
		result += appendPetscii(
			buf, bufsz, &bufpos, toPetsciiChar(screencode));
	    }
	    else if (unknown)
	    {
		result += appendPetscii(buf, bufsz, &bufpos, unknown);
	    }
	}
    }
    return result + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x119e0
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jge 0x1195a
cmpl $0x0, -0x28(%rbp)
jne 0x11949
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x119f0
movb %al, -0x41(%rbp)
cmpb $0x0, -0x41(%rbp)
je 0x11947
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movzbl -0x41(%rbp), %ecx
callq 0x11a50
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x11949
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x119db
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0x11ab0
movb %al, -0x42(%rbp)
movzbl -0x42(%rbp), %eax
cmpl $0x80, %eax
jge 0x119b4
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movsbl -0x42(%rbp), %edi
callq 0x125f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movzbl %al, %ecx
callq 0x11a50
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x119d9
cmpb $0x0, 0x10(%rbp)
je 0x119d7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movzbl 0x10(%rbp), %ecx
callq 0x11a50
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x119d9
jmp 0x119db
jmp 0x118eb
movq -0x40(%rbp), %rax
addq $0x1, %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/petscii.c
// Function: nppetscii
static unsigned char nppetscii(char utf8char)
{
    switch (utf8char)
    {
	case 0x3: return 0x3;
	case 0x8: return 0x14;
	case 0xa: return 0xd;
	case 0xd: return 0x8d;
	default: return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
addl $-0x3, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0xa, %eax
ja 0x11a38
movq -0x10(%rbp), %rax
leaq 0x2e9d(%rip), %rcx      # 0x148b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x3, -0x1(%rbp)
jmp 0x11a3c
movb $0x14, -0x1(%rbp)
jmp 0x11a3c
movb $0xd, -0x1(%rbp)
jmp 0x11a3c
movb $-0x73, -0x1(%rbp)
jmp 0x11a3c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/petscii.c
// Function: appendPetscii
static size_t appendPetscii(char *buf, size_t bufsz, size_t *bufpos,
	unsigned char petscii)
{
    if (*bufpos + 1 < bufsz)
    {
	buf[(*bufpos)++] = petscii;
	buf[*bufpos] = 0;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x1, %rax
cmpq -0x10(%rbp), %rax
jae 0x11aa0
movb -0x19(%rbp), %dl
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rsi
movq (%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, (%rsi)
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
movl $0x1, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/petscii.c
// Function: toPetsciiChar
static unsigned char toPetsciiChar(char screencode)
{
    if ((unsigned char)screencode > 0x7f) return 0;
    if (screencode < 0x20 || screencode >= 0x60) return screencode + 0x40;
    if (screencode >= 0x40) return screencode + 0x20;
    return screencode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
cmpl $0x7f, %eax
jle 0x12609
movb $0x0, -0x1(%rbp)
jmp 0x12642
movsbl -0x2(%rbp), %eax
cmpl $0x20, %eax
jl 0x1261b
movsbl -0x2(%rbp), %eax
cmpl $0x60, %eax
jl 0x12627
movsbl -0x2(%rbp), %eax
addl $0x40, %eax
movb %al, -0x1(%rbp)
jmp 0x12642
movsbl -0x2(%rbp), %eax
cmpl $0x40, %eax
jl 0x1263c
movsbl -0x2(%rbp), %eax
addl $0x20, %eax
movb %al, -0x1(%rbp)
jmp 0x12642
movb -0x2(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/petscii.c
// Function: lcScreenChar
static const char *lcScreenChar(char screencode)
{
    if (screencode == 0x5e) return "\xf0\x9f\xae\x95";
    if (screencode == 0x5f) return "\xf0\x9f\xae\x98";
    if (screencode == 0x69) return "\xf0\x9f\xae\x99";
    if (screencode == 0x7a) return "\xe2\x9c\x93";
    if (screencode > 0 && screencode < 0x1b) return lcChars[screencode-1];
    if (screencode > 0x40 && screencode < 0x5b)
        return screenChars[screencode-0x40];
    return screenChars[(unsigned char)screencode];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x5e, %eax
jne 0x12673
leaq 0x22f2(%rip), %rax      # 0x1495c
movq %rax, -0x8(%rbp)
jmp 0x1272a
movsbl -0x9(%rbp), %eax
cmpl $0x5f, %eax
jne 0x1268c
leaq 0x22de(%rip), %rax      # 0x14961
movq %rax, -0x8(%rbp)
jmp 0x1272a
movsbl -0x9(%rbp), %eax
cmpl $0x69, %eax
jne 0x126a5
leaq 0x22ca(%rip), %rax      # 0x14966
movq %rax, -0x8(%rbp)
jmp 0x1272a
movsbl -0x9(%rbp), %eax
cmpl $0x7a, %eax
jne 0x126bb
leaq 0x22b6(%rip), %rax      # 0x1496b
movq %rax, -0x8(%rbp)
jmp 0x1272a
movsbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jle 0x126e8
movsbl -0x9(%rbp), %eax
cmpl $0x1b, %eax
jge 0x126e8
movsbl -0x9(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x71a2(%rip), %rax      # 0x19880
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x1272a
movsbl -0x9(%rbp), %eax
cmpl $0x40, %eax
jle 0x12715
movsbl -0x9(%rbp), %eax
cmpl $0x5b, %eax
jge 0x12715
movsbl -0x9(%rbp), %eax
subl $0x40, %eax
movslq %eax, %rcx
leaq 0x6d75(%rip), %rax      # 0x19480
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x1272a
movzbl -0x9(%rbp), %eax
movl %eax, %ecx
leaq 0x6d5e(%rip), %rax      # 0x19480
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/petscii.c
// Function: guessCase
static void guessCase(PetsciiCase *casemode, int lowercase)
{
    if (*casemode & PC_GUESS)
    {
	*casemode &= ~PC_GUESS;
	if (lowercase) *casemode |= PC_LOWER;
	else *casemode &= ~PC_LOWER;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x12824
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $-0x5, %ecx
movl %ecx, (%rax)
cmpl $0x0, -0xc(%rbp)
je 0x12817
movq -0x8(%rbp), %rax
movl (%rax), %ecx
orl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x12822
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $-0x2, %ecx
movl %ecx, (%rax)
jmp 0x12824
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/opp.c
// Function: opp_init_file
void opp_init_file(const char* fname, struct Opp_Scan* s)
{
	long size = 0;
	s->io.file = fopen(fname, "r");
	s->io.fname = fname;

	if (!s->io.file)
		printf("\"%s\" Is not a file...\n", fname), exit(1);

	fseek(s->io.file, 0, SEEK_END);
	size = ftell(s->io.file);
	s->io.fsize = size;
	rewind(s->io.file);
	char* content = calloc(1, size + 2);

	if (content == NULL)
		INTERNAL_ERROR("Malloc fail");

	int _ = fread(content, size, 1, s->io.file);
	fclose(s->io.file);

	init_opp_lex(s, content);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x1364d(%rip), %rsi     # 0x14980
callq 0x11c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x137b
movq 0x20(%rsp), %rsi
leaq 0x11ca6(%rip), %rdi     # 0x13010
movb $0x0, %al
callq 0x10c0
movl $0x1, %edi
callq 0x11f0
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1170
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1130
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x10d0
movq 0x10(%rsp), %rsi
addq $0x2, %rsi
movl $0x1, %edi
callq 0x1100
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x13f4
leaq 0x11c3f(%rip), %rdi     # 0x13027
leaq 0x11c44(%rip), %rsi     # 0x13033
callq 0x114a0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rcx
movl $0x1, %edx
callq 0x1050
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1080
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11660
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/opp.c
// Function: run_main
void run_main(struct OppIr* ir)
{
	void *mem = mmap(NULL, 4096, PROT_WRITE | PROT_EXEC,
        32 | MAP_PRIVATE, -1, 0);

	memcpy(mem, ir->code.bytes, ir->code.idx);

	long (*run)(int) = mem;
	printf("%ld\n", run(2));
	munmap(mem, 4096);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
xorl %eax, %eax
movl %eax, %r9d
movl $0x1000, %esi           # imm = 0x1000
movl $0x6, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x10a0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x1150
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movl $0x2, %edi
callq *(%rsp)
movq %rax, %rsi
leaq 0x1316f(%rip), %rdi     # 0x14615
movb $0x0, %al
callq 0x10c0
movq 0x8(%rsp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x1190
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/opp.c
// Function: opp_debug_info
static void opp_debug_info(Opp_Stats* s, struct Opp_Context* opp)
{
	printf("%s### Opp Compiler Debug Info ###\n%s", CL_GREEN, CL_RESET);
	printf("File: %s\n", opp->parser->lex->io.fname);
	printf("Size: %ld\n", opp->parser->lex->io.fsize);
	printf("Benchmarks:\n");
	printf(" - Parser:   %lf\n", s->list[S_PARSER]);
	printf(" - Analizer: %lf\n", s->list[S_ANALIZE]);
	printf(" - Compiler: %lf\n", s->list[S_COMPILER]);
	printf(" - Ir:       %lf\n", s->list[S_IR]);
	printf("Total: %lf\n", s->list[S_PARSER] + s->list[S_ANALIZE] 
		+ s->list[S_COMPILER] + s->list[S_IR]);
	#ifdef X86_CPU
	printf("ARCH: x86-64\n");
	#else
	printf("ARCH: ERROR\n");
	#endif
	#ifdef OS_ERROR
	printf("OS: ERROR\n");
	#elif defined(LINUX64)
	printf("OS: Linux64\n");
	#elif defined(MAC64)
	printf("OS: Macos64\n");
	#endif
	printf("%s################################%s\n", CL_GREEN, CL_RESET);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
leaq 0x11900(%rip), %rdi     # 0x130a5
leaq 0x1191e(%rip), %rsi     # 0x130ca
leaq 0x1191d(%rip), %rdx     # 0x130d0
movb $0x0, %al
callq 0x10c0
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rsi
leaq 0x11905(%rip), %rdi     # 0x130d5
movb $0x0, %al
callq 0x10c0
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x20(%rax), %rsi
leaq 0x118f2(%rip), %rdi     # 0x130df
movb $0x0, %al
callq 0x10c0
leaq 0x118ef(%rip), %rdi     # 0x130ea
movb $0x0, %al
callq 0x10c0
movq 0x10(%rsp), %rax
movsd 0x10(%rax), %xmm0
leaq 0x118e4(%rip), %rdi     # 0x130f7
movb $0x1, %al
callq 0x10c0
movq 0x10(%rsp), %rax
movsd 0x18(%rax), %xmm0
leaq 0x118de(%rip), %rdi     # 0x13109
movb $0x1, %al
callq 0x10c0
movq 0x10(%rsp), %rax
movsd 0x20(%rax), %xmm0
leaq 0x118d8(%rip), %rdi     # 0x1311b
movb $0x1, %al
callq 0x10c0
movq 0x10(%rsp), %rax
movsd 0x28(%rax), %xmm0
leaq 0x118d2(%rip), %rdi     # 0x1312d
movb $0x1, %al
callq 0x10c0
movq 0x10(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq 0x10(%rsp), %rax
addsd 0x18(%rax), %xmm0
movq 0x10(%rsp), %rax
addsd 0x20(%rax), %xmm0
movq 0x10(%rsp), %rax
addsd 0x28(%rax), %xmm0
leaq 0x118ae(%rip), %rdi     # 0x1313f
movb $0x1, %al
callq 0x10c0
leaq 0x118ac(%rip), %rdi     # 0x1314b
movb $0x0, %al
callq 0x10c0
leaq 0x118ac(%rip), %rdi     # 0x13159
movb $0x0, %al
callq 0x10c0
leaq 0x118ab(%rip), %rdi     # 0x13166
leaq 0x11808(%rip), %rsi     # 0x130ca
leaq 0x11807(%rip), %rdx     # 0x130d0
movb $0x0, %al
callq 0x10c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/opp.c
// Function: opp_add_module
void opp_add_module(struct Opp_Parser* old, char* fname)
{
	struct Opp_Scan* new_scan = (struct Opp_Scan*)malloc(sizeof(struct Opp_Scan));

	if (new_scan == NULL)
		INTERNAL_ERROR("Malloc fail");

	char* path = fname;
	if (access(path, F_OK) == -1) {
		if (stdheader_path == NULL)
			INTERNAL_ERROR("Unknown path to stdlib");
		path = (char*)malloc(strlen(fname) + strlen(stdheader_path) + 1);
		sprintf(path, "%s%s", stdheader_path, fname);
	}

	opp_init_file(path, new_scan);

	struct Opp_Scan* temp = old->lex;
	old->lex = new_scan;

	opp_parser_begin(old);

	old->lex = temp;
	
	opp_free_lex(new_scan, 1);
	free(path);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x50, %edi
callq 0x1160
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x1918
leaq 0x1171b(%rip), %rdi     # 0x13027
leaq 0x1174e(%rip), %rsi     # 0x13061
callq 0x114a0
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x11b0
cmpl $-0x1, %eax
jne 0x19a0
cmpq $0x0, 0x178c5(%rip)     # 0x19200
jne 0x1950
leaq 0x1172c(%rip), %rdi     # 0x13070
leaq 0x11716(%rip), %rsi     # 0x13061
callq 0x114a0
movq 0x28(%rsp), %rdi
callq 0x1090
movq %rax, 0x8(%rsp)
movq 0x1789a(%rip), %rdi     # 0x19200
callq 0x1090
movq 0x8(%rsp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
callq 0x1160
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x17873(%rip), %rdx     # 0x19200
movq 0x28(%rsp), %rcx
leaq 0x116ee(%rip), %rsi     # 0x13087
movb $0x0, %al
callq 0x11e0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x1310
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rdi
callq 0xebb0
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x116f0
movq 0x18(%rsp), %rdi
callq 0x1030
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/opp.c
// Function: main
int main(int argc, const char** argv) 
{
	struct Opp_Options opts = {0};

	if (!opp_init())
		exit(1);

	if (!allocator_init())
		INTERNAL_ERROR("Allocator init fail");

	if (argc < 2) {
		opp_help();
		return 0;
	}

	opp_args(argc, argv, &opts);
	
	if (opts.live)
		opp_live_compiler(&opts, argv[argc-1]);
	else
		opp_init_module(argv[argc-1], &opts);

	// objdump -b binary -D -m i386:x86-64 -M intel out.bin 

	allocator_free();

	return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0xf(%rsp), %rdi
xorl %esi, %esi
movl $0x9, %edx
callq 0x10f0
callq 0x1ed0
testb $0x1, %al
jne 0x1a39
movl $0x1, %edi
callq 0x11f0
movb $0x0, %al
callq 0xe110
testb $0x1, %al
jne 0x1a57
leaq 0x11641(%rip), %rdi     # 0x1308c
leaq 0x1164e(%rip), %rsi     # 0x130a0
callq 0x114a0
cmpl $0x2, 0x20(%rsp)
jge 0x1a6d
callq 0x1ee0
movl $0x0, 0x24(%rsp)
jmp 0x1ad2
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
leaq 0xf(%rsp), %rdx
callq 0x1ae0
testb $0x1, 0x17(%rsp)
je 0x1aa6
movq 0x18(%rsp), %rax
movl 0x20(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xf(%rsp), %rdi
callq 0x1d80
jmp 0x1ac3
movq 0x18(%rsp), %rax
movl 0x20(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xf(%rsp), %rsi
callq 0x14d0
movb $0x0, %al
callq 0xe310
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/opp.c
// Function: opp_live_compiler
static void opp_live_compiler(struct Opp_Options* opts, const char* fname)
{
	printf("%s### Opp Live Compiler ###%s\n", CL_GREEN, CL_RESET);
	unsigned int amount = 0;

	struct Opp_Scan* scan = (struct Opp_Scan*)malloc(sizeof(struct Opp_Scan));
	opp_init_file(fname, scan);

	struct Opp_Parser* parser = opp_parser_init(scan);
	opp_parser_begin(parser);

	struct Opp_Analize* ctx = opp_init_analize(parser, opts);
	analize_tree(ctx);

	struct stat filestat;
	stat(fname, &filestat);
	time_t past = filestat.st_mtime;
	time_t current;


	for (;;) {
		stat(fname, &filestat);
		current = filestat.st_mtime;

		if (past < current) {
			printf(">> %sOpp file '%s' has been modified [%u]%s\n", CL_BLUE, fname, amount++, CL_RESET);
			
			// allocator_reset();

			// opp_free_analize(ctx);
			// opp_free_parser(parser);
			// opp_free_lex(scan, true);

			opp_init_file(fname, scan);

			// parser = opp_parser_init(scan);
			// opp_parser_begin(parser);

			// ctx = opp_init_analize(parser, opts);
			// analize_tree(ctx);

			past = current;
		}
	}

}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
leaq 0x1169f(%rip), %rdi     # 0x1343d
leaq 0x11325(%rip), %rsi     # 0x130ca
leaq 0x11324(%rip), %rdx     # 0x130d0
movb $0x0, %al
callq 0x10c0
movl $0x0, 0xc4(%rsp)
movl $0x50, %edi
callq 0x1160
movq %rax, 0xb8(%rsp)
movq 0xc8(%rsp), %rdi
movq 0xb8(%rsp), %rsi
callq 0x1310
movq 0xb8(%rsp), %rdi
callq 0xe420
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
callq 0xebb0
movq 0xb0(%rsp), %rdi
movq 0xd0(%rsp), %rsi
callq 0x1fc0
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x20b0
movq 0xc8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1140
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xc8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1140
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jge 0x1ecb
movq 0xc8(%rsp), %rdx
movl 0xc4(%rsp), %ecx
movl %ecx, %eax
addl $0x1, %eax
movl %eax, 0xc4(%rsp)
leaq 0x115c5(%rip), %rdi     # 0x1345c
leaq 0x115eb(%rip), %rsi     # 0x13489
leaq 0x1122b(%rip), %r8      # 0x130d0
movb $0x0, %al
callq 0x10c0
movq 0xc8(%rsp), %rdi
movq 0xb8(%rsp), %rsi
callq 0x1310
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x1e4d
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/opp.c
// Function: opp_help
static void opp_help()
{
	printf("\x1b[32mO++ Programming Language\x1b[0m\n");
	printf("\x1b[32mVersion: %s\x1b[0m\n", OPP_VERISION);
	printf("\n\x1b[31mFormat: opp [flags] [file]\x1b[0m\n");
	printf("\trun             | Generate executable and run\n");
	printf("\tbuild (default) | Generate obj file from source\n");
	printf("\ttest            | Only analize file do not compile\n");
	printf("\tlive            | Live compilation\n");
	printf("\t-d              | For dumping file tokens\n");
	printf("\t-lc             | Link C's standard library\n");
	printf("\t-nostd          | Don't link Opp stdlib\n");
	printf("\t-w              | Hide warnings\n");
	printf("\t-debug          | Debug compiler statistics\n");
	printf("\t-Wall           | Turn warnings to errors\n");
	printf("\t-path [path]    | Specify std headers path\n");
	printf("\n");
}

// Assembly:
pushq %rax
leaq 0x112a4(%rip), %rdi     # 0x1318c
movb $0x0, %al
callq 0x10c0
leaq 0x112b9(%rip), %rdi     # 0x131af
leaq 0x112c8(%rip), %rsi     # 0x131c5
movb $0x0, %al
callq 0x10c0
leaq 0x112c0(%rip), %rdi     # 0x131cb
movb $0x0, %al
callq 0x10c0
leaq 0x112d8(%rip), %rdi     # 0x131f1
movb $0x0, %al
callq 0x10c0
leaq 0x112fa(%rip), %rdi     # 0x13221
movb $0x0, %al
callq 0x10c0
leaq 0x1131e(%rip), %rdi     # 0x13253
movb $0x0, %al
callq 0x10c0
leaq 0x11345(%rip), %rdi     # 0x13288
movb $0x0, %al
callq 0x10c0
leaq 0x1135c(%rip), %rdi     # 0x132ad
movb $0x0, %al
callq 0x10c0
leaq 0x1137a(%rip), %rdi     # 0x132d9
movb $0x0, %al
callq 0x10c0
leaq 0x1139a(%rip), %rdi     # 0x13307
movb $0x0, %al
callq 0x10c0
leaq 0x113b6(%rip), %rdi     # 0x13331
movb $0x0, %al
callq 0x10c0
leaq 0x113ca(%rip), %rdi     # 0x13353
movb $0x0, %al
callq 0x10c0
leaq 0x113ea(%rip), %rdi     # 0x13381
movb $0x0, %al
callq 0x10c0
leaq 0x11408(%rip), %rdi     # 0x133ad
movb $0x0, %al
callq 0x10c0
leaq 0x13298(%rip), %rdi     # 0x1524b
movb $0x0, %al
callq 0x10c0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_init_analize
struct Opp_Analize* opp_init_analize(struct Opp_Parser* parser, struct Opp_Options* opts)
{
	struct Opp_Analize* ctx = (struct Opp_Analize*)malloc(sizeof(struct Opp_Analize));

	if (ctx == NULL)
		goto err;

	ctx->opts = opts;

	ctx->parser = parser;
	ctx->debug.scope = NULL;
	ctx->debug.ret = 0;

	// Namespace
	ctx->ns = init_namespace(NULL, (void*)alloc);
	ctx->curr_ns = ctx->ns;
	ctx->parser->scope = ctx->ns;

	return ctx;

err:
	INTERNAL_ERROR("Malloc Fail");
	return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x48, %edi
callq 0x1160
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1fea
jmp 0x206b
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x28(%rax)
xorl %eax, %eax
movl %eax, %edi
leaq 0xc16a(%rip), %rsi      # 0xe190
callq 0x12990
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x2087
leaq 0x11596(%rip), %rdi     # 0x13608
leaq 0x1159b(%rip), %rsi     # 0x13614
callq 0x114a0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_analize_global
static void opp_analize_global(struct Opp_Analize* ctx, struct Opp_Node* node)
{
	switch (node->type)
	{
		case STMT_FUNC:
			opp_analize_func(ctx, node);
			break;

		case STMT_EXTERN:
			opp_analize_extern(ctx, node);
			break;

		case STMT_VAR:
			opp_analize_var(ctx, node);
			break;

		case STMT_STRUCT:
			opp_analize_struct(ctx, node);
			break;

		case STMT_IMPORT:
			break;

		default: break;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
addl $-0x13, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0xb, %eax
ja 0x218d
movq (%rsp), %rax
leaq 0x11352(%rip), %rcx     # 0x13490
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x21a0
jmp 0x218f
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2450
jmp 0x218f
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x24d0
jmp 0x218f
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x27a0
jmp 0x218f
jmp 0x218f
jmp 0x218f
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_analize_extern
static void opp_analize_extern(struct Opp_Analize* ctx, struct Opp_Node* node)
{
	struct Opp_Bucket* b;
	opp_analize_global(ctx, node->extrn_stmt.stmt);

	b = env_get_item(ctx->curr_ns, (char*)ctx->debug.res_name);

	assert(b != NULL);

	b->predef = false;
	b->type = TYPE_EXTERN;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x2110
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rsi
callq 0x12c10
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2495
jmp 0x24b4
leaq 0x1195b(%rip), %rdi     # 0x13df7
leaq 0x118ba(%rip), %rsi     # 0x13d5d
movl $0xd1, %edx
leaq 0x11952(%rip), %rcx     # 0x13e01
callq 0x10e0
movq (%rsp), %rax
movb $0x0, 0x20(%rax)
movq (%rsp), %rax
movl $0x4, 0x8(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_semantics_error
static void opp_semantics_error(struct Opp_Analize* ctx, 
		struct Opp_Node* node, const char* str, ...)
{
	va_list ap;
	va_start(ap, str);
	
	printf("%s:%u:%u ", ctx->parser->lex->io.fname, 
			node->debug.line, node->debug.colum);
	#ifdef UNX
		printf(CL_RED);
	#endif

	if (ctx->debug.scope != NULL)
		printf("semantics error: in function \"%s(...)\"\n\t", ctx->debug.scope);
	else
		printf("semantics error: in declaration\n\t");

	#ifdef UNX
		printf(CL_RESET);
	#endif
	vfprintf(stdout, str, ap);
	fprintf(stdout, "\n");
	va_end(ap);
	exit(1);
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x2b4c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq 0xe0(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rsi
movq 0xd8(%rsp), %rax
movl 0x4(%rax), %edx
movq 0xd8(%rsp), %rax
movl 0x8(%rax), %ecx
leaq 0x10af9(%rip), %rdi     # 0x136c4
movb $0x0, %al
callq 0x10c0
leaq 0x1085e(%rip), %rdi     # 0x13437
movb $0x0, %al
callq 0x10c0
movq 0xe0(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x2c0b
movq 0xe0(%rsp), %rax
movq 0x20(%rax), %rsi
leaq 0x10acc(%rip), %rdi     # 0x136ce
movb $0x0, %al
callq 0x10c0
jmp 0x2c19
leaq 0x10ae5(%rip), %rdi     # 0x136f7
movb $0x0, %al
callq 0x10c0
leaq 0x104b0(%rip), %rdi     # 0x130d0
movb $0x0, %al
callq 0x10c0
movq 0x163b2(%rip), %rax     # 0x18fe0
movq (%rax), %rdi
movq 0xd0(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x11d0
movq 0x16393(%rip), %rax     # 0x18fe0
movq (%rax), %rdi
leaq 0x125f4(%rip), %rsi     # 0x1524b
movb $0x0, %al
callq 0x1120
leaq 0xb0(%rsp), %rax
movl $0x1, %edi
callq 0x11f0
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_analize_args
static void opp_analize_args(struct Opp_Analize* ctx, struct Opp_Node* fn, struct Opp_Bucket* bucket)
{
	for (unsigned int i = 0; i < fn->fn_stmt.len; i++) {
		switch (fn->fn_stmt.args[i].var_stmt.var->type)
		{
			case EUNARY:
			case EELEMENT:
			break;

			default:
				opp_semantics_error(ctx, fn, "Unexpected function argument declaration #%d", i+1);
		}

		if (fn->fn_stmt.args[i].var_stmt.type.decl->t_type == TYPE_STRUCT && 
			fn->fn_stmt.args[i].var_stmt.type.depth == 0)
			opp_semantics_error(ctx, fn, "Cannot have struct object as parameter");

		opp_analize_stmt(ctx, &fn->fn_stmt.args[i]);
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x30(%rcx), %eax
jae 0x2d61
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movl 0xc(%rsp), %ecx
leaq (%rcx,%rcx,8), %rcx
movq 0x20(%rax,%rcx,8), %rax
movl (%rax), %eax
orl $0x2, %eax
subl $0x7, %eax
je 0x2cbf
jmp 0x2cc1
jmp 0x2ce0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0xc(%rsp), %ecx
addl $0x1, %ecx
leaq 0x10a40(%rip), %rdx     # 0x13719
movb $0x0, %al
callq 0x2b10
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movl 0xc(%rsp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
cmpl $0x8, 0x8(%rax)
jne 0x2d33
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movl 0xc(%rsp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movzwl 0x18(%rax), %eax
cmpl $0x0, %eax
jne 0x2d33
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x10a1a(%rip), %rdx     # 0x13746
movb $0x0, %al
callq 0x2b10
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rsi
movl 0xc(%rsp), %eax
imulq $0x48, %rax, %rax
addq %rax, %rsi
callq 0x2d70
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2c8b
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_analize_stmt
static void opp_analize_stmt(struct Opp_Analize* ctx, struct Opp_Node* node)
{
	switch (node->type)
	{
		case STMT_VAR:
			opp_analize_var(ctx, node);
			break;

		case STMT_RET:
			opp_analize_ret(ctx, node);
			break;

		case EASSIGN:
			opp_analize_assign(ctx, node);
			break;

		case ECALL:
			opp_analize_call(ctx, node);
			break;

		case STMT_IF:
			opp_analize_if(ctx, node);
			break;

		case STMT_WHILE:
			opp_analize_while(ctx, node);
			break;

		case STMT_BLOCK:
			opp_analize_block(ctx, node);
			break;

		case STMT_BREAK:
		case STMT_CASE:
			break; // add these

		default:
			// node->type = IGNORE;
			opp_warning(ctx, node, "Unused expression found");

			opp_analize_expr(ctx, node);
			break;
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movl (%rax), %eax
addl $-0x3, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x1a, %eax
ja 0x2e41
movq (%rsp), %rax
leaq 0x1071e(%rip), %rcx     # 0x134c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x24d0
jmp 0x2e72
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x3030
jmp 0x2e72
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x3130
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
jmp 0x2e72
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x3300
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x2e72
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x3590
jmp 0x2e72
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x3640
jmp 0x2e72
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x36d0
jmp 0x2e72
jmp 0x2e72
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
leaq 0x1091b(%rip), %rdx     # 0x1376d
movb $0x0, %al
callq 0x2e80
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x3770
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_warning
static void opp_warning(struct Opp_Analize* ctx, 
		struct Opp_Node* node, const char* str, ...)
{
	if (!ctx->opts->warning)
		return;

	if (ctx->opts->wall) {
		opp_semantics_error(ctx, node, str);
		return;
	}

	va_list ap;
	va_start(ap, str);
	
	printf("%s:%u:%u ", ctx->parser->lex->io.fname, 
			node->debug.line, node->debug.colum);
	#ifdef UNX
		printf(CL_YELLOW);
	#endif

	if (ctx->debug.scope != NULL)
		printf("warning: in function \"%s(...)\"\n\t", ctx->debug.scope);
	else 
		printf("warning: in declaration\n\t");

	#ifdef UNX
		printf(CL_RESET);
	#endif 
	vfprintf(stdout, str, ap);
	fprintf(stdout, "\n");
	va_end(ap);
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x2ebc
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xe0(%rsp), %rax
movq (%rax), %rax
testb $0x1, 0x4(%rax)
jne 0x2ef9
jmp 0x3021
movq 0xe0(%rsp), %rax
movq (%rax), %rax
testb $0x1, 0x6(%rax)
je 0x2f2e
movq 0xe0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
movb $0x0, %al
callq 0x2b10
jmp 0x3021
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq 0xe0(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rsi
movq 0xd8(%rsp), %rax
movl 0x4(%rax), %edx
movq 0xd8(%rsp), %rax
movl 0x8(%rax), %ecx
leaq 0x1073e(%rip), %rdi     # 0x136c4
movb $0x0, %al
callq 0x10c0
leaq 0x10e22(%rip), %rdi     # 0x13db6
movb $0x0, %al
callq 0x10c0
movq 0xe0(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x2fc6
movq 0xe0(%rsp), %rax
movq 0x20(%rax), %rsi
leaq 0x10dff(%rip), %rdi     # 0x13dbc
movb $0x0, %al
callq 0x10c0
jmp 0x2fd4
leaq 0x10e10(%rip), %rdi     # 0x13ddd
movb $0x0, %al
callq 0x10c0
leaq 0x100f5(%rip), %rdi     # 0x130d0
movb $0x0, %al
callq 0x10c0
movq 0x15ff7(%rip), %rax     # 0x18fe0
movq (%rax), %rdi
movq 0xd0(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x11d0
movq 0x15fd8(%rip), %rax     # 0x18fe0
movq (%rax), %rdi
leaq 0x12239(%rip), %rsi     # 0x1524b
movb $0x0, %al
callq 0x1120
leaq 0xb0(%rsp), %rax
addq $0xe8, %rsp
retq
nopl (%rax)