LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/codeplea[P]tinyexpr/tinyexpr.c
// Function: term
static te_expr *term(state *s) {
    /* <term>      =    <factor> {("*" | "/" | "%") <factor>} */
    te_expr *ret = factor(s);
    CHECK_NULL(ret);

    while (s->type == TOK_INFIX && (s->function == mul || s->function == divide || s->function == fmod)) {
        te_fun2 t = s->function;
        next_token(s);
        te_expr *f = factor(s);
        CHECK_NULL(f, te_free(ret));

        te_expr *prev = ret;
        ret = NEW_EXPR(TE_FUNCTION2 | TE_FLAG_PURE, ret, f);
        CHECK_NULL(ret, te_free(f), te_free(prev));

        ret->function = t;
    }

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
callq 0x7136
testq %rax, %rax
je 0x7122
movq %rax, %rbx
movq 0x4f36(%rip), %r13      # 0xbfe0
leaq 0x8(%rsp), %r15
cmpl $0x20, 0x10(%r14)
jne 0x7124
movq 0x18(%r14), %rbp
cmpq %r13, %rbp
je 0x70d7
leaq -0xba3(%rip), %rax      # 0x6523
cmpq %rax, %rbp
je 0x70d7
leaq -0xbaa(%rip), %rax      # 0x6528
cmpq %rax, %rbp
jne 0x7124
movq %r14, %rdi
callq 0x623c
movq %r14, %rdi
callq 0x7136
testq %rax, %rax
je 0x711a
movq %rax, %r12
movq %rbx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
pushq $0x2a
popq %rdi
movq %r15, %rsi
callq 0x7001
testq %rax, %rax
je 0x7112
movq %rbp, 0x8(%rax)
movq %rax, %rbx
jmp 0x70af
movq %r12, %rdi
callq 0x6224
movq %rbx, %rdi
callq 0x6224
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/codeplea[P]tinyexpr/tinyexpr.c
// Function: factor
static te_expr *factor(state *s) {
    /* <factor>    =    <power> {"^" <power>} */
    te_expr *ret = power(s);
    CHECK_NULL(ret);

    int neg = 0;

    if (ret->type == (TE_FUNCTION1 | TE_FLAG_PURE) && ret->function == negate) {
        te_expr *se = ret->parameters[0];
        free(ret);
        ret = se;
        neg = 1;
    }

    te_expr *insertion = 0;

    while (s->type == TOK_INFIX && (s->function == pow)) {
        te_fun2 t = s->function;
        next_token(s);

        if (insertion) {
            /* Make exponentiation go right-to-left. */
            te_expr *p = power(s);
            CHECK_NULL(p, te_free(ret));

            te_expr *insert = NEW_EXPR(TE_FUNCTION2 | TE_FLAG_PURE, insertion->parameters[1], p);
            CHECK_NULL(insert, te_free(p), te_free(ret));

            insert->function = t;
            insertion->parameters[1] = insert;
            insertion = insert;
        } else {
            te_expr *p = power(s);
            CHECK_NULL(p, te_free(ret));

            te_expr *prev = ret;
            ret = NEW_EXPR(TE_FUNCTION2 | TE_FLAG_PURE, ret, p);
            CHECK_NULL(ret, te_free(p), te_free(prev));

            ret->function = t;
            insertion = ret;
        }
    }

    if (neg) {
        te_expr *prev = ret;
        ret = NEW_EXPR(TE_FUNCTION1 | TE_FLAG_PURE, ret);
        CHECK_NULL(ret, te_free(prev));

        ret->function = negate;
    }

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
callq 0x727a
testq %rax, %rax
je 0x724a
movq %rax, %rbx
cmpl $0x29, (%rax)
leaq 0x1b1(%rip), %rax       # 0x7313
jne 0x716e
cmpq %rax, 0x8(%rbx)
je 0x725e
movb $0x1, %al
movl %eax, 0xc(%rsp)
xorl %r13d, %r13d
movq 0x4e5a(%rip), %r12      # 0xbfd8
pushq $0x2a
popq %rbp
cmpl $0x20, 0x10(%r14)
jne 0x720e
cmpq %r12, 0x18(%r14)
jne 0x720e
movq %r14, %rdi
callq 0x623c
movq %r14, %rdi
callq 0x727a
movq %rax, %r15
testq %r13, %r13
je 0x71df
testq %r15, %r15
je 0x7242
movq 0x18(%r13), %rax
movq %rax, 0x20(%rsp)
movq %r15, 0x28(%rsp)
movl %ebp, %edi
leaq 0x20(%rsp), %rsi
callq 0x7001
testq %rax, %rax
je 0x723a
movq %r12, 0x8(%rax)
movq %rax, 0x18(%r13)
movq %rax, %r13
jmp 0x7181
testq %r15, %r15
je 0x7242
movq %rbx, 0x10(%rsp)
movq %r15, 0x18(%rsp)
movl %ebp, %edi
leaq 0x10(%rsp), %rsi
callq 0x7001
testq %rax, %rax
je 0x723a
movq %rax, %r13
movq %r12, 0x8(%rax)
movq %rax, %rbx
jmp 0x7181
cmpb $0x0, 0xc(%rsp)
jne 0x724c
leaq 0x30(%rsp), %rsi
movq %rbx, (%rsi)
pushq $0x29
popq %rdi
callq 0x7001
testq %rax, %rax
je 0x7242
leaq 0xe2(%rip), %rcx        # 0x7313
movq %rcx, 0x8(%rax)
movq %rax, %rbx
jmp 0x724c
movq %r15, %rdi
callq 0x6224
movq %rbx, %rdi
callq 0x6224
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rbx), %r15
movq %rbx, %rdi
callq 0x3030
movl $0x0, 0xc(%rsp)
movq %r15, %rbx
jmp 0x7174
// File: /workspace/github_c_makefile_star2_O2/codeplea[P]tinyexpr/tinyexpr.c
// Function: power
static te_expr *power(state *s) {
    /* <power>     =    {("-" | "+")} <base> */
    int sign = 1;
    while (s->type == TOK_INFIX && (s->function == add || s->function == sub)) {
        if (s->function == sub) sign = -sign;
        next_token(s);
    }

    te_expr *ret;

    if (sign == 1) {
        ret = base(s);
    } else {
        te_expr *b = base(s);
        CHECK_NULL(b);

        ret = NEW_EXPR(TE_FUNCTION1 | TE_FLAG_PURE, b);
        CHECK_NULL(ret, te_free(b));

        ret->function = negate;
    }

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
leaq -0xd75(%rip), %r14      # 0x6519
leaq -0xd77(%rip), %r15      # 0x651e
cmpl $0x20, 0x10(%rbx)
jne 0x72c3
movq 0x18(%rbx), %rax
cmpq %r14, %rax
setne %cl
cmpq %r15, %rax
setne %dl
testb %dl, %cl
jne 0x72c3
movl %ebp, %ecx
negl %ecx
cmpq %r15, %rax
cmovel %ecx, %ebp
movq %rbx, %rdi
callq 0x623c
jmp 0x7295
movq %rbx, %rdi
callq 0x731b
movq %rax, %rbx
cmpl $0x1, %ebp
je 0x7305
testq %rbx, %rbx
je 0x7303
movq %rsp, %rsi
movq %rbx, (%rsi)
pushq $0x29
popq %rdi
callq 0x7001
testq %rax, %rax
je 0x72fb
leaq 0x21(%rip), %rcx        # 0x7313
movq %rcx, 0x8(%rax)
movq %rax, %rbx
jmp 0x7305
movq %rbx, %rdi
callq 0x6224
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/eridanhq[P]miraclelib/setsig.c
// Function: main
int main(int argc, char *argv[])
{
	char filename[100];
	int memfd;
	void *mapped_base;

	strcpy(filename,"/mnt/");
	strcat(filename,argv[1]);
	strcat(filename,".bin");

	memfd = open("/dev/mem", O_RDWR | O_SYNC);
	if (memfd == -1) {
		printf("Can't open /dev/mem.\n");
		exit(0);
	}

	// Map one page of memory into user space such that the device is in that page, but it may not
	// be at the start of the page

	mapped_base = mmap( (void *) MEM0_BASE_ADDRESS, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, memfd, FIFO_BASE_ADDRESS);
	if (mapped_base == (void *) -1) {
		printf("Can't map the memory to user space.\n");
		exit(0);
	}
	
	/* ----------- INSERT CODE BELOW THIS LINE ------------ */

	set_sig_tx(filename, mapped_base);

	/* ----------- INSERT CODE ABOVE THIS LINE ------------ */
	if (munmap(mapped_base, MAP_SIZE) == -1) {
		printf("Can't unmap memory from user space.\n");
		exit(0);
	}
	close(memfd);
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsp, %rbx
movw $0x2f, 0x4(%rbx)
movl $0x746e6d2f, (%rbx)     # imm = 0x746E6D2F
movq 0x8(%rsi), %rsi
movq %rbx, %rdi
callq 0x1120
movq %rbx, %rdi
callq 0x1080
movl $0x6e69622e, (%rsp,%rax) # imm = 0x6E69622E
movb $0x0, 0x4(%rsp,%rax)
leaq 0xd76(%rip), %rdi       # 0x200f
movl $0x101002, %esi         # imm = 0x101002
xorl %eax, %eax
callq 0x1100
cmpl $-0x1, %eax
je 0x1301
movl %eax, %ebx
pushq $0x3
popq %rdx
pushq $0x11
popq %rcx
movl $0x40000000, %edi       # imm = 0x40000000
movl $0x400000, %esi         # imm = 0x400000
movl $0x60000000, %r9d       # imm = 0x60000000
movl %eax, %r8d
callq 0x1090
cmpq $-0x1, %rax
je 0x130a
movq %rax, %r14
movq %rsp, %rdi
movq %rax, %rsi
callq 0x13da
movl $0x400000, %esi         # imm = 0x400000
movq %r14, %rdi
callq 0x10f0
cmpl $-0x1, %eax
je 0x1313
movl %ebx, %edi
callq 0x10d0
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0xd58(%rip), %rdi       # 0x2060
jmp 0x131a
leaq 0xd2b(%rip), %rdi       # 0x203c
jmp 0x131a
leaq 0xcfe(%rip), %rdi       # 0x2018
callq 0x1060
xorl %edi, %edi
callq 0x1140
nop
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/form9.c
// Function: StrNCaseCmp
int StrNCaseCmp(const char *a, const char *b, unsigned int n)
{
   unsigned int i,l,m;

   l = strlen(a);
   m = strlen(b);

   for (i=0 ; i < n && i <= l && i <= m ; ++i)
   {
      if (toupper(a[i]) < toupper(b[i])) return -1;
      if (toupper(a[i]) > toupper(b[i])) return  1;
   }
   return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1040
movq %rax, %r15
movq %rbx, %rdi
callq 0x1040
movl %ebp, %r12d
movl %r15d, %r13d
movl %eax, %ebp
xorl %r15d, %r15d
cmpq %r12, %r15
jae 0x1250
cmpq %r13, %r15
ja 0x1250
cmpq %rbp, %r15
ja 0x1250
callq 0x1030
movq (%rax), %rcx
movsbq (%r14,%r15), %rax
movl (%rcx,%rax,4), %eax
movsbq (%rbx,%r15), %rdx
movl (%rcx,%rdx,4), %ecx
cmpl %ecx, %eax
jl 0x1254
incq %r15
cmpl %ecx, %eax
jle 0x121a
pushq $0x1
jmp 0x1256
xorl %eax, %eax
jmp 0x1257
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/form9.c
// Function: IsEquate
int IsEquate(void)
{
   char *e;
   char *p;
   e = strchr(Line,'=');
   if (e)
   {
      p = strchr(Line,';');
      if (p && p < e) return -1; // '=' after comment character
      p = strchr(Line,'*');
      if (p && p < e) return -1; // ignore * = syntax for PC setting
      return e-Line;
   }
   return -1; // no equate character found
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x523f(%rip), %rdi      # 0x64b0
pushq $0x3d
popq %rsi
callq 0x1050
pushq $-0x1
popq %rbx
testq %rax, %rax
je 0x12cf
movq %rax, %r14
leaq 0x5225(%rip), %rdi      # 0x64b0
pushq $0x3b
popq %rsi
callq 0x1050
testq %rax, %rax
setne %cl
cmpq %r14, %rax
setb %al
testb %al, %cl
jne 0x12cf
leaq 0x5206(%rip), %rdi      # 0x64b0
pushq $0x2a
popq %rsi
callq 0x1050
testq %rax, %rax
setne %cl
cmpq %r14, %rax
setb %al
testb %al, %cl
jne 0x12cf
leaq 0x51e7(%rip), %rax      # 0x64b0
subl %eax, %r14d
movl %r14d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/form9.c
// Function: IsInstruction
int IsInstruction(int *l)
{
   int i,j,ll;
   char c;

   if (Line[0] == '*') return -1;
   if (Line[0] == ';') return -1;
   ll = strlen(Line);
   if (ll < 4) return -1;
   *l = 0;
   for (j=0 ; j < ll-3 ; ++j)
   {
      if (Line[j] == ';') return -1;
      if (Line[j] == '"') return -1;
      if (Line[j] ==  39) return -1;
      if (j > 0)
      {
         c = Line[j-1];
         if (c != ' ') continue;
      }
      for (i = 0 ; i < (int) DIMOP ; ++i)
      {
         *l = strlen(Mat[i].Mne);
         if (strlen(Line+j) >= (size_t) *l)
         {
            if (!StrNCaseCmp(Line+j,Mat[i].Mne,*l)
            && Line[j+ *l] <= ' ') return j;
         }
      }
   }
   return -1; // No mnemonic
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movzbl 0x51c5(%rip), %eax      # 0x64b0
pushq $-0x1
popq %rbx
cmpl $0x2a, %eax
je 0x13ea
cmpl $0x3b, %eax
je 0x13ea
movq %rdi, %r14
leaq 0x51a6(%rip), %rdi      # 0x64b0
callq 0x1040
movq %rax, %rcx
cmpl $0x4, %ecx
jl 0x13ea
andl $0x0, (%r14)
addl $-0x3, %ecx
xorl %r12d, %r12d
movq %rcx, (%rsp)
cmpq %rcx, %r12
je 0x13e2
leaq 0x5177(%rip), %rax      # 0x64b0
movzbl (%r12,%rax), %eax
cmpq $0x3b, %rax
ja 0x1358
movabsq $0x800008400000000, %rdx # imm = 0x800008400000000
btq %rax, %rdx
jb 0x13e2
testq %r12, %r12
je 0x136c
leaq 0x514c(%rip), %rax      # 0x64b0
cmpb $0x20, -0x1(%r12,%rax)
jne 0x13d6
leaq 0x513d(%rip), %rax      # 0x64b0
leaq (%rax,%r12), %r13
xorl %r15d, %r15d
cmpq $0x2300, %r15           # imm = 0x2300
je 0x13d6
leaq 0x2d16(%rip), %rax      # 0x40a0
leaq (%rax,%r15), %rbx
movq %rbx, %rdi
callq 0x1040
movq %rax, %rbp
movl %ebp, (%r14)
movq %r13, %rdi
callq 0x1040
movslq %ebp, %rcx
cmpq %rcx, %rax
jb 0x13d0
movq %r13, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x11ec
testl %eax, %eax
jne 0x13d0
addl %r12d, %ebp
movslq %ebp, %rax
leaq 0x50e6(%rip), %rcx      # 0x64b0
cmpb $0x21, (%rax,%rcx)
jl 0x13e7
addq $0x28, %r15
jmp 0x137a
incq %r12
movq (%rsp), %rcx
jmp 0x1329
pushq $-0x1
popq %rbx
jmp 0x13ea
movl %r12d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/form9.c
// Function: IsPseudo
int IsPseudo(int *l)
{
   int i,j,ll;
   char c;

   if (Line[0] == '*') return -1;
   if (Line[0] == ';') return -1;
   ll = strlen(Line);
   if (ll < 4) return -1;
   *l = 0;
   for (j=0 ; j < ll-3 ; ++j)
   {
      if (Line[j] == ';') return -1;
      if (Line[j] == '"') return -1;
      if (Line[j] ==  39) return -1;
      if (j > 0)
      {
         c = Line[j-1];
         if (c != ' ') continue;
      }
      for (i = 0 ; i < PSEUDOS ; ++i)
      {
         *l = strlen(PseudoTab[i]);
         if (strlen(Line+j) >= (size_t) *l)
         {
            if (!StrNCaseCmp(Line+j,PseudoTab[i],*l)
            && Line[j+ *l] <= ' ') return j;
         }
      }
   }
   return -1; // No pseudo
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movzbl 0x50a3(%rip), %eax      # 0x64b0
pushq $-0x1
popq %rbx
cmpl $0x2a, %eax
je 0x150c
cmpl $0x3b, %eax
je 0x150c
movq %rdi, %r14
leaq 0x5084(%rip), %rdi      # 0x64b0
callq 0x1040
movq %rax, %rcx
cmpl $0x4, %ecx
jl 0x150c
andl $0x0, (%r14)
addl $-0x3, %ecx
xorl %r12d, %r12d
movq %rcx, (%rsp)
cmpq %rcx, %r12
je 0x1504
leaq 0x5055(%rip), %rax      # 0x64b0
movzbl (%r12,%rax), %eax
cmpq $0x3b, %rax
ja 0x147a
movabsq $0x800008400000000, %rdx # imm = 0x800008400000000
btq %rax, %rdx
jb 0x1504
testq %r12, %r12
je 0x148e
leaq 0x502a(%rip), %rax      # 0x64b0
cmpb $0x20, -0x1(%r12,%rax)
jne 0x14f8
leaq 0x501b(%rip), %rax      # 0x64b0
leaq (%rax,%r12), %r13
xorl %r15d, %r15d
cmpq $0xf8, %r15
je 0x14f8
leaq 0x4ef4(%rip), %rax      # 0x63a0
movq (%r15,%rax), %rbx
movq %rbx, %rdi
callq 0x1040
movq %rax, %rbp
movl %ebp, (%r14)
movq %r13, %rdi
callq 0x1040
movslq %ebp, %rcx
cmpq %rcx, %rax
jb 0x14f2
movq %r13, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x11ec
testl %eax, %eax
jne 0x14f2
addl %r12d, %ebp
movslq %ebp, %rax
leaq 0x4fc4(%rip), %rcx      # 0x64b0
cmpb $0x21, (%rax,%rcx)
jl 0x1509
addq $0x8, %r15
jmp 0x149c
incq %r12
movq (%rsp), %rcx
jmp 0x144b
pushq $-0x1
popq %rbx
jmp 0x150c
movl %r12d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/form9.c
// Function: Usage
void Usage(void)
{
   fprintf(stderr,"Usage: form9 [options] <in >out\n");
   fprintf(stderr,"Options:\n");
   fprintf(stderr,"   -l print mnemonics in lower case\n");
   fprintf(stderr,"   -u print mnemonics in upper case\n");
   fprintf(stderr,"   -o print pseudos   in lower case\n");
   fprintf(stderr,"   -p print pseudos   in upper case\n");
   fprintf(stderr,"   -m col   mnemonic/pseudo  column ( 8)\n");
   fprintf(stderr,"   -a col   argument/operand column (16)\n");
   fprintf(stderr,"   -e col   equate column           (16)\n");
   fprintf(stderr,"   -c col  code line comment column (32)\n");
   exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x2acf(%rip), %r15      # 0x3ff8
movq (%r15), %rcx
leaq 0xb78(%rip), %rdi       # 0x20ab
pushq $0x20
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x10d0
movq (%r15), %rcx
leaq 0xb81(%rip), %rdi       # 0x20cc
pushq $0x9
popq %rsi
movq %rbx, %rdx
callq 0x10d0
movq (%r15), %rcx
leaq 0xb76(%rip), %rdi       # 0x20d6
pushq $0x24
popq %r14
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10d0
movq (%r15), %rcx
leaq 0xb82(%rip), %rdi       # 0x20fb
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10d0
movq (%r15), %rcx
leaq 0xb92(%rip), %rdi       # 0x2120
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10d0
movq (%r15), %rcx
leaq 0xba2(%rip), %rdi       # 0x2145
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10d0
movq (%r15), %rcx
leaq 0xbb2(%rip), %rdi       # 0x216a
pushq $0x29
popq %r14
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10d0
movq (%r15), %rcx
leaq 0xbc3(%rip), %rdi       # 0x2194
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10d0
movq (%r15), %rcx
leaq 0xbd8(%rip), %rdi       # 0x21be
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10d0
movq (%r15), %rcx
leaq 0xbed(%rip), %rdi       # 0x21e8
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10d0
pushq $0x1
popq %rdi
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/form9.c
// Function: MoveLine
int MoveLine(int i, int col)
{
   int l;
   if (col >= 0)
   {
      l = strlen(Line)-i+1;
      if (col > i)
      {
         memmove(Line+col,Line+i,l);
         memset(Line+i,' ',col-i);
         return col; // moved to this column
      }
      while (col < i)
      {
         if (i > 0 && Line[i-1] != ' ') break;
         if (i > 1 && Line[i-2] != ' ') break;
         --i;
         memmove(Line+i,Line+i+1,l);
      }
      return i; // moved to this column
   }
   return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %r14d
testl %esi, %esi
js 0x1664
movl %esi, %ebx
leaq 0x4e87(%rip), %r15      # 0x64b0
movq %r15, %rdi
callq 0x1040
subl %r14d, %eax
incl %eax
movl %ebx, %ebp
subl %r14d, %ebp
jle 0x1676
movslq %r14d, %r14
movl %ebx, %edi
addq %r15, %rdi
addq %r15, %r14
movslq %eax, %rdx
movq %r14, %rsi
callq 0x10a0
movslq %ebp, %rdx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x1070
movl %ebx, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq %eax, %r12
cmpl %ebx, %r14d
jle 0x1661
leal -0x1(%r14), %r13d
cmpb $0x20, (%r13,%r15)
jne 0x1664
cmpl $0x2, %r14d
jl 0x169b
leal -0x2(%r14), %eax
cmpb $0x20, (%rax,%r15)
jne 0x1664
leaq (%r15,%r13), %rdi
leaq 0x1(%rdi), %rsi
movq %r12, %rdx
callq 0x10a0
movl %r13d, %r14d
jmp 0x1679
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/form9.c
// Function: MoveOperand
void MoveOperand(int i)
{
   int l;
   if (ocol >= 0)
   {
      while (Line[i] == ' ') ++i;
      l = strlen(Line)-i+1;
      if (ocol > i)
      {
         memmove(Line+ocol,Line+i,l);
         memset(Line+i,' ',ocol-i);
      }
      while (ocol < i)
      {
         if (Line[i-1] != ' ') break;
         if (i > 1 && Line[i-2] != ' ') break;
         --i;
         memmove(Line+i,Line+i+1,l);
      }
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x29d2(%rip), %r13      # 0x4094
testq %r13, %r13
js 0x1789
movl %edi, %r14d
movslq %edi, %rbp
xorl %r12d, %r12d
leaq 0x4dd5(%rip), %rax      # 0x64b0
leaq (%r12,%rbp), %rcx
incq %r12
cmpb $0x20, (%rax,%rcx)
je 0x16db
leal (%r14,%r12), %r15d
decl %r15d
leaq 0x4dba(%rip), %rbx      # 0x64b0
movq %rbx, %rdi
callq 0x1040
movl %r14d, %ecx
negl %ecx
addq %rax, %rcx
subq %r12, %rcx
addq $0x2, %rcx
cmpl %r15d, %r13d
jle 0x174c
leaq (%rbx,%rbp), %rax
leaq (%r12,%rax), %rsi
decq %rsi
movq %rsi, (%rsp)
leaq (%rbx,%r13), %rdi
movslq %ecx, %r15
movq %r15, %rdx
callq 0x10a0
movl %r13d, %eax
subl %r14d, %eax
subl %r12d, %eax
incl %eax
movslq %eax, %rdx
pushq $0x20
popq %rsi
movq (%rsp), %rdi
callq 0x1070
jmp 0x174f
movslq %ecx, %r15
leaq (%r12,%rbp), %r14
decq %r14
cmpq %r13, %r14
jle 0x1789
cmpb $0x20, -0x1(%r14,%rbx)
jne 0x1789
cmpq $0x2, %r14
jl 0x1771
cmpb $0x20, -0x2(%r14,%rbx)
jne 0x1789
leaq (%r14,%rbx), %rdi
decq %rdi
leaq 0x1(%rdi), %rsi
movq %r15, %rdx
callq 0x10a0
decq %r14
jmp 0x1756
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/form9.c
// Function: MoveComment
void MoveComment(int i)
{
   char *p;
   int j;

   p = strchr(Line+i,';');
   if (!p) p = strchr(Line+i,'*');
   if (p)
   {
      j = p - Line;
      if (p[1] != ' ') MoveLine(j+1,j+2);
      MoveLine(j,ccol);
   }
}

// Assembly:
pushq %rbx
movslq %edi, %rax
leaq 0x4d0d(%rip), %rbx      # 0x64b0
addq %rax, %rbx
pushq $0x3b
popq %rsi
movq %rbx, %rdi
callq 0x1050
testq %rax, %rax
jne 0x17c6
pushq $0x2a
popq %rsi
movq %rbx, %rdi
callq 0x1050
testq %rax, %rax
je 0x17f0
leaq 0x4ce3(%rip), %rcx      # 0x64b0
movl %eax, %ebx
subl %ecx, %ebx
cmpb $0x20, 0x1(%rax)
je 0x17e2
leal 0x1(%rbx), %edi
leal 0x2(%rbx), %esi
callq 0x160e
movl 0x28b4(%rip), %esi      # 0x409c
movl %ebx, %edi
popq %rbx
jmp 0x160e
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/fileloader.c
// Function: free_buffer
void free_buffer(arraylist_t *buffer) {
    line_t *line = NULL;

    if(!buffer) return;

    for(size_t i = 0; i < buffer->size; i++) {
        line = get_line(buffer, i);
        free(line->line);
        free(line->source);
        free(line);
    }
    arraylist_free(buffer, 0);
}

// Assembly:
testq %rdi, %rdi
je 0x2a88
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq 0x8(%rbx), %r14
jae 0x2a79
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2a1e
movq %rax, %r15
movq (%rax), %rdi
callq 0x2030
movq 0x8(%r15), %rdi
callq 0x2030
movq %r15, %rdi
callq 0x2030
incq %r14
jmp 0x2a47
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x69f4
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/test.c
// Function: test_variable_declaration_parsing
static void test_variable_declaration_parsing(char *line) {
	arraylist_t *list = NULL;

	printf("%sInput: %s\"%s\"%s\n", COLOR_BLUE, COLOR_YELLOW, line, FORMAT_RESET);
	list = get_variables_from_declaration(0, line);
	if(list != NULL) {
		printf("%sOutput: %s\n", COLOR_BLUE, FORMAT_RESET);
		print_variables(list, 0);
		field_list_free(list);
	} else
		printf("%sOutput: %sNULL%s\n", COLOR_BLUE, COLOR_RED, FORMAT_RESET);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x874f(%rip), %rdi      # 0xd423
leaq 0x875b(%rip), %rsi      # 0xd436
leaq 0x833d(%rip), %rdx      # 0xd01f
leaq 0x833c(%rip), %r8       # 0xd025
movq %rbx, %rcx
xorl %eax, %eax
callq 0x20d0
xorl %edi, %edi
movq %rbx, %rsi
callq 0x83c6
testq %rax, %rax
je 0x4d34
movq %rax, %rbx
leaq 0x8730(%rip), %rdi      # 0xd43c
leaq 0x8723(%rip), %rsi      # 0xd436
leaq 0x830b(%rip), %rdx      # 0xd025
xorl %eax, %eax
callq 0x20d0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4d58
movq %rbx, %rdi
popq %rbx
jmp 0x6605
leaq 0x870f(%rip), %rdi      # 0xd44a
leaq 0x86f4(%rip), %rsi      # 0xd436
leaq 0x82d0(%rip), %rdx      # 0xd019
leaq 0x82d5(%rip), %rcx      # 0xd025
xorl %eax, %eax
popq %rbx
jmp 0x20d0
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/test.c
// Function: print_variables
static void print_variables(arraylist_t *variables, unsigned int tabs) {
	field_t *variable = NULL;
	if(variables != NULL) {
		for(unsigned int i = 0 ; i < variables->size ; i++) {
			variable = arraylist_get(variables, i);

			for(unsigned int j = 0 ; j < tabs ; j++)
				printf("\t");

			printf(" %s%2d:  %sName:       %s%s\n",
				COLOR_MAGENTA, i,
				COLOR_CYAN, FORMAT_RESET, variable->name);

			for(unsigned int j = 0 ; j < tabs ; j++)
				printf("\t");
			printf("      %sType:       %s%s\n", COLOR_CYAN, FORMAT_RESET, variable->type.name);

			for(unsigned int j = 0 ; j < tabs ; j++)
				printf("\t");
			printf("      %sIs pointer: %s%d\n", COLOR_CYAN, FORMAT_RESET, variable->type.is_pointer);
		}
	}
}

// Assembly:
testq %rdi, %rdi
je 0x4e47
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
pushq $0x9
popq %r15
xorl %r12d, %r12d
movl %r12d, %r12d
cmpq %r12, 0x8(%r14)
jbe 0x4e39
movq %r14, %rdi
movq %r12, %rsi
callq 0x6978
movq %rax, %r13
movl %ebp, %ebx
subl $0x1, %ebx
jb 0x4da4
movl %r15d, %edi
callq 0x2040
jmp 0x4d95
movq (%r13), %r9
leaq 0x86af(%rip), %rdi      # 0xd45e
leaq 0x86c5(%rip), %rsi      # 0xd47b
movl %r12d, %edx
leaq 0x86c1(%rip), %rcx      # 0xd481
leaq 0x825e(%rip), %r8       # 0xd025
xorl %eax, %eax
callq 0x20d0
movl %ebp, %ebx
subl $0x1, %ebx
jb 0x4ddf
movl %r15d, %edi
callq 0x2040
jmp 0x4dd0
movq 0x10(%r13), %rcx
leaq 0x869d(%rip), %rdi      # 0xd487
leaq 0x8690(%rip), %rsi      # 0xd481
leaq 0x822d(%rip), %rdx      # 0xd025
xorl %eax, %eax
callq 0x20d0
movl %ebp, %ebx
subl $0x1, %ebx
jb 0x4e10
movl %r15d, %edi
callq 0x2040
jmp 0x4e01
movsbl 0x18(%r13), %ecx
leaq 0x8685(%rip), %rdi      # 0xd4a1
leaq 0x865e(%rip), %rsi      # 0xd481
leaq 0x81fb(%rip), %rdx      # 0xd025
xorl %eax, %eax
callq 0x20d0
incl %r12d
jmp 0x4d78
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/test.c
// Function: test_function_declaration_parsing
static void test_function_declaration_parsing(char *line) {
	function_t *function = get_function_from_declaration(0, line);

	printf("%sInput: %s\"%s\"%s\n", COLOR_BLUE, COLOR_YELLOW, line, FORMAT_RESET);
	if(function != NULL) {
		printf("%sOutput: %s\n", COLOR_BLUE, FORMAT_RESET);
		print_function(function, 0);
		function_free(function);
	} else
		printf("%sOutput: %sNULL%s\n", COLOR_BLUE, COLOR_RED, FORMAT_RESET);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0xa4ba
movq %rax, %rbx
leaq 0x85c0(%rip), %rdi      # 0xd423
leaq 0x85cc(%rip), %rsi      # 0xd436
leaq 0x81ae(%rip), %rdx      # 0xd01f
leaq 0x81ad(%rip), %r8       # 0xd025
movq %r14, %rcx
xorl %eax, %eax
callq 0x20d0
testq %rbx, %rbx
je 0x4ebc
leaq 0x85ae(%rip), %rdi      # 0xd43c
leaq 0x85a1(%rip), %rsi      # 0xd436
leaq 0x8189(%rip), %rdx      # 0xd025
xorl %eax, %eax
callq 0x20d0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4ee6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xaefe
leaq 0x8587(%rip), %rdi      # 0xd44a
leaq 0x856c(%rip), %rsi      # 0xd436
leaq 0x8148(%rip), %rdx      # 0xd019
leaq 0x814d(%rip), %rcx      # 0xd025
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20d0
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/test.c
// Function: print_function
static void print_function(function_t *function, unsigned int tabs) {
	if(function != NULL) {
		for(unsigned int j = 0 ; j < tabs ; j++)
			printf("\t");
		printf("      %sName:         %s%s\n", COLOR_CYAN, FORMAT_RESET, function->name);

		for(unsigned int j = 0 ; j < tabs ; j++)
			printf("\t");
		printf("      %sIs prototype: %s%d\n", COLOR_CYAN, FORMAT_RESET, function->is_prototype);

		for(unsigned int j = 0 ; j < tabs ; j++)
			printf("\t");
		printf("      %sType:         %s%s\n", COLOR_CYAN, FORMAT_RESET, function->return_type.name);

		for(unsigned int j = 0 ; j < tabs ; j++)
			printf("\t");
		printf("      %sIs pointer:   %s%d\n", COLOR_CYAN, FORMAT_RESET, function->return_type.is_pointer);

		for(unsigned int j = 0 ; j < tabs ; j++)
			printf("\t");
		printf("      %sParameters:   %s", COLOR_CYAN, FORMAT_RESET);
		if(function->params->size == 0) {
			printf("%sNone%s\n", COLOR_RED, FORMAT_RESET);
		} else {
			printf("\n");
			print_variables(function->params, tabs + 1);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x502b
movl %esi, %ebx
movq %rdi, %r14
pushq $0x9
popq %rbp
movl %esi, %r15d
subl $0x1, %r15d
jb 0x4f10
movl %ebp, %edi
callq 0x2040
jmp 0x4f01
movq (%r14), %rcx
leaq 0x86bf(%rip), %rdi      # 0xd5d9
leaq 0x8560(%rip), %rsi      # 0xd481
leaq 0x80fd(%rip), %rdx      # 0xd025
xorl %eax, %eax
callq 0x20d0
pushq $0x9
popq %rbp
movl %ebx, %r15d
subl $0x1, %r15d
jb 0x4f44
movl %ebp, %edi
callq 0x2040
jmp 0x4f35
movzbl 0x18(%r14), %ecx
leaq 0x86a5(%rip), %rdi      # 0xd5f5
leaq 0x852a(%rip), %rsi      # 0xd481
leaq 0x80c7(%rip), %rdx      # 0xd025
xorl %eax, %eax
callq 0x20d0
pushq $0x9
popq %rbp
movl %ebx, %r15d
subl $0x1, %r15d
jb 0x4f7a
movl %ebp, %edi
callq 0x2040
jmp 0x4f6b
movq 0x8(%r14), %rcx
leaq 0x868c(%rip), %rdi      # 0xd611
leaq 0x84f5(%rip), %rsi      # 0xd481
leaq 0x8092(%rip), %rdx      # 0xd025
xorl %eax, %eax
callq 0x20d0
pushq $0x9
popq %rbp
movl %ebx, %r15d
subl $0x1, %r15d
jb 0x4faf
movl %ebp, %edi
callq 0x2040
jmp 0x4fa0
movsbl 0x10(%r14), %ecx
leaq 0x8672(%rip), %rdi      # 0xd62d
leaq 0x84bf(%rip), %rsi      # 0xd481
leaq 0x805c(%rip), %rdx      # 0xd025
xorl %eax, %eax
callq 0x20d0
pushq $0x9
popq %rbp
movl %ebx, %r15d
subl $0x1, %r15d
jb 0x4fe5
movl %ebp, %edi
callq 0x2040
jmp 0x4fd6
leaq 0x865d(%rip), %rdi      # 0xd649
leaq 0x848e(%rip), %rsi      # 0xd481
leaq 0x802b(%rip), %rdx      # 0xd025
xorl %eax, %eax
callq 0x20d0
movq 0x20(%r14), %rax
cmpq $0x0, 0x8(%rax)
je 0x5036
pushq $0xa
popq %rdi
callq 0x2040
movq 0x20(%r14), %rdi
incl %ebx
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4d58
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8625(%rip), %rdi      # 0xd662
leaq 0x7fd5(%rip), %rsi      # 0xd019
leaq 0x7fda(%rip), %rdx      # 0xd025
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/display.c
// Function: print_message
void print_message(char *file, int line_index, char *line, const char *message, const char *type, const char *color) {
	if(line == NULL)
		printf("%s[%s]%s At %s%s:%d%s: %s\n", color, type, FORMAT_RESET, COLOR_CYAN_BOLD, file, line_index, FORMAT_RESET, message);
	else
		printf("%s[%s]%s At %s%s:%d%s: %s\n  %s\n", color, type, FORMAT_RESET, COLOR_CYAN_BOLD, file, line_index, FORMAT_RESET, message, line);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rax
movq %r8, %r14
movq %rcx, %r11
movl %esi, %r10d
movq %rdi, %r9
testq %rdx, %rdx
je 0x565a
movq %rdx, %rbx
leaq 0x79e4(%rip), %rcx      # 0xd025
leaq 0x90d2(%rip), %rdi      # 0xe71a
leaq 0x8234(%rip), %r8       # 0xd883
movq %rax, %rsi
movq %r14, %rdx
xorl %eax, %eax
pushq %rbx
jmp 0x567b
subq $0x8, %rsp
leaq 0x79c0(%rip), %rcx      # 0xd025
leaq 0x9093(%rip), %rdi      # 0xe6ff
leaq 0x8210(%rip), %r8       # 0xd883
movq %rax, %rsi
movq %r14, %rdx
xorl %eax, %eax
pushq %r11
pushq %rcx
pushq %r10
callq 0x20d0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: exclude_conf_file
void exclude_conf_file(arraylist_t *conf, char *name){
    if(strlen(name) <= 0) return;

    rule_t *e;

    e = malloc(sizeof(rule_t));
    e->name = malloc(sizeof(char) * 1048);

    strcpy(e->name, "conf_inc_");
    strcat(e->name, name);

    e->enable = 1;
    e->value = 0;
    arraylist_add(conf, e);
}

// Assembly:
cmpb $0x0, (%rsi)
je 0x58f0
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x2130
movq %rax, %r15
movl $0x418, %edi            # imm = 0x418
callq 0x2130
movq %rax, (%r15)
movabsq $0x636e695f666e6f63, %rcx # imm = 0x636E695F666E6F63
movq %rcx, (%rax)
movw $0x5f, 0x8(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x2170
movq $0x1, 0x8(%r15)
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x68b5
retq
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: find_rule_index
int find_rule_index(arraylist_t *conf, char *name){
    if(strlen(name) <= 0) return -2;

    for(size_t i = 0; i < conf->size; i++){
        if(strcmp(name, ((rule_t*)(conf->array[i]))->name) == 0){
            return i;
        }
    }
    return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpb $0x0, (%rsi)
je 0x592f
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %r13
xorl %r12d, %r12d
pushq $-0x1
popq %rbx
cmpq %r12, %r13
je 0x5937
movq (%r15), %rax
movq (%rax,%r12,8), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x2110
testl %eax, %eax
je 0x5934
incq %r12
jmp 0x590f
pushq $-0x2
popq %rbx
jmp 0x5937
movl %r12d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: exclude_file
void exclude_file(FILE *src, arraylist_t *conf){
    if(src == NULL) return;
    char *line;
    int found;
    char *tmp;
    char *get;
    rule_t *e;

    line = malloc(sizeof(char) * 1048);
    tmp = malloc(sizeof(char) * 1048);

    get = fgets(line, 1048, src);
    if(get == NULL) { //Unexpected EOF reached
        free(line);
        free(tmp);
        return;
    }

    while(!is_whitespace(line[0]) && line[0] != '#'){
        strcpy(tmp, "exfile_");
        if(line[1] == ' '){
            strcat(tmp, line+2);
        }else{
            strcat(tmp, line+1);
        }
        strformat(tmp, 1048);

        found = find_rule_index(conf, tmp);
        if(found == -1 ){
            e = malloc(sizeof(rule_t));
            e->name = malloc(sizeof(char) * 1048);
            strcpy(e->name, tmp);
            e->value = 0;
            e->enable = 0;
            arraylist_add(conf, e);
        }
        get = fgets(line, 1048, src);
        if(get == NULL) break;
    }
    free(line);
    free(tmp);
}

// Assembly:
testq %rdi, %rdi
je 0x5c65
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbp
movq %rdi, %r14
movl $0x418, %edi            # imm = 0x418
callq 0x2130
movq %rax, %r12
movl $0x418, %edi            # imm = 0x418
callq 0x2130
movq %rax, %r15
movq %r12, %rdi
movl $0x418, %esi            # imm = 0x418
movq %r14, %rdx
callq 0x2100
testq %rax, %rax
je 0x5c47
leaq 0x1(%r12), %r13
movq %r12, %rbx
addq $0x2, %rbx
movq %rbx, (%rsp)
movsbl (%r12), %edi
callq 0x7ace
testb %al, %al
jne 0x5c47
cmpb $0x23, (%r12)
je 0x5c47
cmpb $0x20, (%r13)
movabsq $0x5f656c69667865, %rax # imm = 0x5F656C69667865
movq %rax, (%r15)
movq %r13, %rsi
cmoveq %rbx, %rsi
movq %r15, %rdi
callq 0x2170
movl $0x418, %esi            # imm = 0x418
movq %r15, %rdi
callq 0x7cfb
movq %rbp, %rdi
movq %r15, %rsi
callq 0x58f1
cmpl $-0x1, %eax
jne 0x5c2e
pushq $0x10
popq %rdi
callq 0x2130
movq %r14, %rbx
movq %rbp, %r14
movq %rax, %rbp
movl $0x418, %edi            # imm = 0x418
callq 0x2130
movq %rax, (%rbp)
movq %rax, %rdi
movq %r15, %rsi
callq 0x2080
andq $0x0, 0x8(%rbp)
movq %r14, %rdi
movq %rbp, %rsi
movq %r14, %rbp
movq %rbx, %r14
movq (%rsp), %rbx
callq 0x68b5
movq %r12, %rdi
movl $0x418, %esi            # imm = 0x418
movq %r14, %rdx
callq 0x2100
testq %rax, %rax
jne 0x5b8f
movq %r12, %rdi
callq 0x2030
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2030
retq
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: recursive_activation
void recursive_activation(FILE *src, arraylist_t *conf){
    if(src == NULL) return;

    char *line;
    char *get; //fgets return
    int found;
    int enable;
    enable = 0;
    rule_t *e;

    line = malloc(sizeof(char) * 1048);

    get = fgets(line, 1048, src);
    if(get == NULL) { //Unexpected EOF reached
        free(line);
        return;
    }
    if(!is_whitespace(line[0]) && line[0] != '#'){

        found = find_rule_index(conf, "recursive");

        if(strstr(line, "true")){
            enable = 1;
        }
        if(strstr(line, "false")){
            enable = 0;
        }

        if(found >= 0){
            ((rule_t*)(conf->array[found]))->enable= enable;
        }else if(found == -1){
            e = malloc(sizeof(rule_t));

            e->name = malloc(sizeof(char) * 1048);

            strcpy(e->name, "recursive");
            e->value = 0;
            e->enable = enable;
            arraylist_add(conf, e);
        }
    }
    free(line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x5d12
movq %rsi, %r14
movq %rdi, %r15
movl $0x418, %edi            # imm = 0x418
callq 0x2130
movq %rax, %rbx
movq %rax, %rdi
movl $0x418, %esi            # imm = 0x418
movq %r15, %rdx
callq 0x2100
testq %rax, %rax
je 0x5d5f
movsbl (%rbx), %edi
callq 0x7ace
testb %al, %al
jne 0x5d5f
cmpb $0x23, (%rbx)
je 0x5d5f
leaq 0x8aa1(%rip), %rsi      # 0xe764
movq %r14, %rdi
callq 0x58f1
movl %eax, %ebp
leaq 0x8a9a(%rip), %rsi      # 0xe76e
movq %rbx, %rdi
callq 0x21b0
testq %rax, %rax
setne %r15b
leaq 0x8a89(%rip), %rsi      # 0xe773
movq %rbx, %rdi
callq 0x21b0
testq %rax, %rax
sete %al
andb %r15b, %al
movzbl %al, %r12d
testl %ebp, %ebp
js 0x5d1b
movq (%r14), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %rax
movl %r12d, 0x8(%rax)
jmp 0x5d5f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $-0x1, %ebp
jne 0x5d5f
pushq $0x10
popq %rdi
callq 0x2130
movq %rax, %r15
movl $0x418, %edi            # imm = 0x418
callq 0x2130
movq %rax, (%r15)
movabsq $0x7669737275636572, %rcx # imm = 0x7669737275636572
movq %rcx, (%rax)
movw $0x65, 0x8(%rax)
andl $0x0, 0xc(%r15)
movl %r12d, 0x8(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x68b5
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: get_rule
rule_t *get_rule(arraylist_t *conf, char *name){
    if(conf == NULL || strlen(name) <= 0) return NULL;
    int index = find_rule_index(conf, name);
    if(index >= 0) return ((rule_t*)(arraylist_get(conf, (unsigned int)index)));
    return NULL;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x5dc1
cmpb $0x0, (%rsi)
je 0x5dc1
movq %rdi, %rbx
callq 0x58f1
testl %eax, %eax
js 0x5dc1
movl %eax, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x6978
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: exclude_filepath
void exclude_filepath(arraylist_t *conf, char *filepath){
    if(strlen(filepath) <= 0) return;

    rule_t *e;

    e = malloc(sizeof(rule_t));
    e->name = malloc(sizeof(char) * 1048);

    strcpy(e->name, "incfilepath_");
    strcat(e->name, filepath);

    e->enable = 1;
    e->value = 0;
    arraylist_add(conf, e);
}

// Assembly:
cmpb $0x0, (%rsi)
je 0x5e2b
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x2130
movq %rax, %r15
movl $0x418, %edi            # imm = 0x418
callq 0x2130
movq %rax, (%r15)
movabsq $0x70656c6966636e69, %rcx # imm = 0x70656C6966636E69
movq %rcx, (%rax)
movabsq $0x5f68746170656c, %rcx # imm = 0x5F68746170656C
movq %rcx, 0x5(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x2170
movq $0x1, 0x8(%r15)
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x68b5
retq
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: is_excluded
int is_excluded(arraylist_t *conf, char *path) {
    char *name;
    name = malloc(sizeof(char) * 1048);

    strcpy(name, "exfile_");
    strcat(name, path);
    if(get_rule(conf, name) == NULL) {
        free(name);
        return 0;
    } else {
        free(name);
        return 1;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x418, %edi            # imm = 0x418
callq 0x2130
movq %rax, %r15
movabsq $0x5f656c69667865, %rax # imm = 0x5F656C69667865
movq %rax, (%r15)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2170
movq %r14, %rdi
movq %r15, %rsi
callq 0x5d9f
xorl %ebx, %ebx
testq %rax, %rax
setne %bl
movq %r15, %rdi
callq 0x2030
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: free_conf
void free_conf(arraylist_t *conf) {
    if(!conf) return;
    for(size_t i = 0; i < conf->size; i++){
        free(((rule_t*)(arraylist_get(conf,i)))->name);
        free(conf->array[i]);
    }
    arraylist_free(conf, 0);
}

// Assembly:
testq %rdi, %rdi
je 0x5ec9
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq 0x8(%rbx), %r14
jae 0x5eb8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6978
movq (%rax), %rdi
callq 0x2030
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2030
incq %r14
jmp 0x5e8e
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x69f4
retq
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: field_init
field_t *field_init(char *name, char *type, char type_is_pointer, int line_index) {
	field_t *field = malloc(sizeof(field_t));

	if(field != NULL) {
		field->name            = name;
		field->type.name       = type;
		field->type.is_pointer = type_is_pointer;
		field->type.is_literal = 0;
		field->line            = line_index;
		field->is_param        = 0;
		field->value           = NULL;
	}
	return field;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
pushq $0x28
popq %rdi
callq 0x2130
testq %rax, %rax
je 0x5f1d
movq %r15, (%rax)
movq %r14, 0x10(%rax)
movb %bpl, 0x18(%rax)
xorl %ecx, %ecx
movb %cl, 0x19(%rax)
movl %ebx, 0x20(%rax)
movb %cl, 0x24(%rax)
andq $0x0, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: scope_init
scope_t *scope_init(scope_t *parent) {
	scope_t *scope = malloc(sizeof(scope_t));

	if(scope != NULL) {
		scope->parent    = parent;
		scope->children  = linkedlist_init();
		scope->variables = arraylist_init(10);
		scope->functions = arraylist_init(10);
		scope->from_line = -1;
		scope->to_line   = -1;
		scope->from_char = -1;
		scope->to_char   = -1;
	}

	return scope;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x30
popq %rdi
callq 0x2130
movq %rax, %rbx
testq %rax, %rax
je 0x5f6f
movq %r14, (%rbx)
xorl %eax, %eax
callq 0x8810
movq %rax, 0x8(%rbx)
pushq $0xa
popq %rbp
movl %ebp, %edi
callq 0x67e4
movq %rax, 0x18(%rbx)
movl %ebp, %edi
callq 0x67e4
movq %rax, 0x10(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: is_in_child_scope
scope_t *is_in_child_scope(scope_t *scope, int line) {
	scope_t *child;
	node_t * current = scope->children->head;
	if(current != NULL) {
		do {
			child = (scope_t*) current->val;
			if(line >= child->from_line && line <= child->to_line)
				return child;
		} while ((current = current->next) != NULL);
	}

	return NULL;
}

// Assembly:
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x5f97
movq (%rcx), %rax
cmpl %esi, 0x20(%rax)
jg 0x5f91
cmpl %esi, 0x28(%rax)
jge 0x5f99
movq 0x8(%rcx), %rcx
jmp 0x5f7f
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: parse_scope_content
static void parse_scope_content(arraylist_t *file, scope_t *scope) {
	char *line;
	arraylist_t *variables;

	for(int i = scope->from_line ; i <= scope->to_line ; i++) {
		if(is_in_child_scope(scope, i)) continue; //Ignore lines inside child scopes
		line = (char*) arraylist_get(file, i);
		variables = get_variables_from_declaration(i,line);
		if(variables != NULL) {
			arraylist_add_all(scope->variables, variables);
			arraylist_free(variables, 0);
			variables = NULL;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x20(%rsi), %r15
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jg 0x64a9
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5f77
testq %rax, %rax
jne 0x64a4
movq %r14, %rdi
movq %r15, %rsi
callq 0x6978
movl %r15d, %edi
movq %rax, %rsi
callq 0x83c6
testq %rax, %rax
je 0x64a4
movq %rax, %r12
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x6947
movq %r12, %rdi
xorl %esi, %esi
callq 0x69f4
incq %r15
jmp 0x6457
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: scope_free
void scope_free(scope_t *scope) {
	node_t * current;

	//Don't free parent !
	
	//Recursively free children
	current = scope->children->head;
	while (current != NULL) {
		scope_free(current->val);
		current->val = NULL;
		current = current->next;
	}
	linkedlist_free(scope->children);

	//Free functions
	for(size_t i = 0 ; i < scope->functions->size; i++) {
		function_free(scope->functions->array[i]);
		scope->functions->array[i] = NULL;
	}
	arraylist_free(scope->functions, 1);

	//Free variables
	field_list_free(scope->variables);

	free(scope);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x64d7
movq (%r14), %rdi
callq 0x64b5
andq $0x0, (%r14)
jmp 0x64c0
movq 0x8(%rbx), %rdi
callq 0x89d5
xorl %r14d, %r14d
movq 0x10(%rbx), %rdi
cmpq 0x8(%rdi), %r14
jae 0x650a
movq (%rdi), %rax
movq (%rax,%r14,8), %rdi
callq 0xaefe
movq 0x10(%rbx), %rax
movq (%rax), %rax
andq $0x0, (%rax,%r14,8)
incq %r14
jmp 0x64e3
pushq $0x1
popq %rsi
callq 0x69f4
movq 0x18(%rbx), %rdi
callq 0x6605
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: type_exists
unsigned char type_exists(char *type) {
	static const char *known_types[] = {"char","short","int","unsigned","signed","long","signed","float","double","size_t","void"};
	for(unsigned i = 0 ; i < 11 ; i++)
		if(!strcmp(type, known_types[i]))
			return 1;

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x82b2(%rip), %r14      # 0xe854
xorl %ecx, %ecx
movq %r14, %r15
movq %rcx, %r12
cmpq $0xb, %rcx
je 0x65cb
movslq (%r15), %rsi
addq %r14, %rsi
movq %rbx, %rdi
callq 0x2110
leaq 0x1(%r12), %rcx
addq $0x4, %r15
testl %eax, %eax
jne 0x65a7
cmpq $0xb, %r12
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: field_free
void field_free(field_t *field) {
	free(field->name);
	if(field->value != NULL) {
		free(field->value);
	}
	free(field->type.name);
	free(field);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2030
movq 0x8(%rbx), %rdi
callq 0x2030
movq 0x10(%rbx), %rdi
callq 0x2030
movq %rbx, %rdi
popq %rbx
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: field_list_free
void field_list_free(arraylist_t *list) {
	field_t *field = NULL;
	for(unsigned int i = 0 ; i < list->size ; i++) {
		field = arraylist_get(list, i);
		field_free(field);
	}
	arraylist_free(list, 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, %r14d
cmpq %r14, 0x8(%rbx)
jbe 0x6630
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6978
movq %rax, %rdi
callq 0x65de
leal 0x1(%r14), %eax
jmp 0x660e
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x69f4
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: function_list_free
void function_list_free(arraylist_t *list) {
	function_t *function = NULL;
	for(unsigned int i = 0 ; i < list->size ; i++) {
		function = arraylist_get(list, i);
		function_free(function);
	}
	arraylist_free(list, 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, %r14d
cmpq %r14, 0x8(%rbx)
jbe 0x666c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6978
movq %rax, %rdi
callq 0xaefe
leal 0x1(%r14), %eax
jmp 0x664a
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x69f4
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: find_function
function_t *find_function(scope_t *scope, char *name, unsigned char allow_prototypes) {
	scope_t *root = get_root_scope(scope);
	function_t *function = NULL;
	for(size_t i = 0 ; i < root->functions->size ; i++) {
		function = arraylist_get(root->functions, i);
		if(!strcmp(name, function->name) && (allow_prototypes || !function->is_prototype))
			return function;
	}
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
callq 0x667d
movq %rax, %r15
xorl %r12d, %r12d
movq 0x10(%r15), %rdi
cmpq 0x8(%rdi), %r12
jae 0x66ed
movq %r12, %rsi
callq 0x6978
movq %rax, %r13
movq (%rax), %rsi
movq %r14, %rdi
callq 0x2110
testl %eax, %eax
jne 0x66e8
testb %bl, %bl
jne 0x66f0
cmpb $0x0, 0x18(%r13)
je 0x66f0
incq %r12
jmp 0x66b9
xorl %r13d, %r13d
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq