LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/g3ida[P]g3idaCompiler/parse.c
// Function: expr
exprType expr(void)
{
    exprType tlhs, trhs;
    Symbole op;
    tlhs = simple_expr();
    op = token;
    if ((token==LT)||(token==EQ)||(token==NEQ)|| (token==LTE) || (token==GT) || (token==GTE)) {
        accepter(token);
        trhs = simple_expr();
        if(trhs != tlhs && tlhs !=TypeError) {
            ERROR_MSG("type misaccepter cannot convert %s to %s\n", typeToStr(trhs), typeToStr(tlhs));

         tlhs = TypeError;
        }

        switch(op) {
        case LT:
            EMETTRE("comparer-si-inf\n");
            CONDITION_FLAG = 0;
            break;
        case GT:
            EMETTRE("comparer-si-sup\n");
            CONDITION_FLAG = 0;
            break;
        case EQ:
            EMETTRE( "comparer-si-egal\n");
            CONDITION_FLAG = 0;
            break;
        case LTE:
            EMETTRE("comparer-si-sup\n");
            CONDITION_FLAG = 1;
            break;
        case GTE:
            EMETTRE("comparer-si-inf\n");
            CONDITION_FLAG = 1;
            break;
        case NEQ:
            EMETTRE( "comparer-si-egal\n");
            CONDITION_FLAG = 1;
            break;
        default:
            break;
        }
        tlhs = Boolean;
    }
    return tlhs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x1cdb
movl %eax, %ebx
movl 0x3e86(%rip), %edi      # 0x5a54
leal -0x13(%rdi), %r15d
cmpl $0x5, %r15d
ja 0x1cce
callq 0x1517
callq 0x1cdb
movl %eax, %ebp
cmpl %ebx, %eax
sete %al
cmpl $0x4, %ebx
sete %cl
orb %al, %cl
jne 0x1c49
leaq 0x34b2(%rip), %rax      # 0x50b0
movl (%rax), %esi
leaq 0x14da(%rip), %rdi      # 0x30e1
xorl %eax, %eax
callq 0x10a0
movl %ebp, %edi
callq 0x1316
movq %rax, %r14
movl %ebx, %edi
callq 0x1316
leaq 0x1564(%rip), %rdi      # 0x318a
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a0
leaq 0x349a(%rip), %rax      # 0x50d4
incl (%rax)
leaq 0x348d(%rip), %rax      # 0x50d0
movl $0x1, (%rax)
movq 0x3df8(%rip), %rcx      # 0x5a48
leaq 0x1445(%rip), %rax      # 0x309c
movslq (%rax,%r15,4), %rdx
addq %rax, %rdx
jmpq *%rdx
leaq 0x156f(%rip), %rdi      # 0x31d6
movl $0x11, %esi
jmp 0x1c8c
leaq 0x1550(%rip), %rdi      # 0x31c5
jmp 0x1caf
leaq 0x1536(%rip), %rdi      # 0x31b4
jmp 0x1c87
leaq 0x153e(%rip), %rdi      # 0x31c5
movl $0x10, %esi
movl $0x1, %edx
callq 0x1120
xorl %eax, %eax
jmp 0x1cc3
leaq 0x1535(%rip), %rdi      # 0x31d6
movl $0x11, %esi
jmp 0x1cb4
leaq 0x1505(%rip), %rdi      # 0x31b4
movl $0x10, %esi
movl $0x1, %edx
callq 0x1120
movl $0x1, %eax
movl %eax, 0x3d87(%rip)      # 0x5a50
movl $0x3, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/g3ida[P]g3idaCompiler/parse.c
// Function: simple_expr
exprType simple_expr(void)
{
    exprType tlhs, trhs;
    char* opstr;
    tlhs = term();
    while ((token==PLUS)||(token==MINUS) || (token==OR))
    {
        opstr = copyString(lexeme);
        if(token == OR) {
        if(tlhs != Boolean && tlhs !=TypeError) {
            ERROR_MSG("expected Boolean operand for 'OR' operator (found %s)\n", typeToStr(tlhs));
            tlhs = TypeError;
        }
      }
      accepter(token);
      trhs = term();
      if(trhs != tlhs && tlhs !=TypeError) {
         ERROR_MSG("type mismatch cannot convert %s to %s\n", typeToStr(trhs), typeToStr(tlhs));
         tlhs = TypeError;
      }
      EMETTRE("%s\n", opstr);
      free(opstr);
    }
    return tlhs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x1e28
movl %eax, %ebp
movl 0x3d61(%rip), %eax      # 0x5a54
addl $-0x19, %eax
cmpl $0x2, %eax
ja 0x1e17
leaq 0x33ce(%rip), %rbx      # 0x50d4
leaq 0x33c3(%rip), %r14      # 0x50d0
leaq 0x1900(%rip), %r13      # 0x3614
leaq 0x3d55(%rip), %rdi      # 0x5a70
callq 0x12d5
movq %rax, %r15
movl 0x3d2b(%rip), %edi      # 0x5a54
cmpl $0x1b, %edi
sete %al
leal -0x5(%rbp), %ecx
cmpl $-0x2, %ecx
setb %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1d82
leaq 0x336a(%rip), %rax      # 0x50b0
movl (%rax), %esi
leaq 0x1392(%rip), %rdi      # 0x30e1
xorl %eax, %eax
callq 0x10a0
movl %ebp, %edi
callq 0x1316
leaq 0x1484(%rip), %rdi      # 0x31e8
movq %rax, %rsi
xorl %eax, %eax
callq 0x10a0
incl (%rbx)
movl $0x1, (%r14)
movl $0x4, %ebp
movl 0x3cd2(%rip), %edi      # 0x5a54
callq 0x1517
callq 0x1e28
movl %eax, %r12d
cmpl %ebp, %eax
sete %al
cmpl $0x4, %ebp
sete %cl
orb %al, %cl
jne 0x1de9
leaq 0x330b(%rip), %rax      # 0x50b0
movl (%rax), %esi
leaq 0x1333(%rip), %rdi      # 0x30e1
xorl %eax, %eax
callq 0x10a0
movl %r12d, %edi
callq 0x1316
movq %rax, %r12
movl %ebp, %edi
callq 0x1316
leaq 0x1451(%rip), %rdi      # 0x321f
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a0
incl (%rbx)
movl $0x1, (%r14)
movl $0x4, %ebp
movq 0x3c58(%rip), %rdi      # 0x5a48
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x10d0
movq %r15, %rdi
callq 0x1030
movl 0x3c49(%rip), %eax      # 0x5a54
addl $-0x19, %eax
cmpl $0x3, %eax
jb 0x1d14
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/g3ida[P]g3idaCompiler/parse.c
// Function: term
exprType term(void)
{
    exprType tlhs, trhs;
    char* opstr;
    tlhs = factor();
    while ((token==MULT)||(token==DIV) || (token == MOD) || (token == AND))
    {
      opstr = copyString(lexeme);
      if(token == AND) {
        if(tlhs != Boolean && tlhs !=TypeError) {
            ERROR_MSG("expected Boolean operand for 'AND' operator (found %s)\n", typeToStr(tlhs));
            tlhs = TypeError;
        }
      }
      accepter(token);
      trhs = factor();
      if(trhs != tlhs && tlhs !=TypeError) {
         ERROR_MSG("type mismatch cannot convert %s to %s\n", typeToStr(trhs), typeToStr(tlhs));
         tlhs = TypeError;
      }
      EMETTRE("%s\n", opstr);
      free(opstr);
    }
    return tlhs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x1f75
movl %eax, %ebp
movl 0x3c14(%rip), %eax      # 0x5a54
andl $-0x4, %eax
cmpl $0x1c, %eax
jne 0x1f64
leaq 0x3281(%rip), %rbx      # 0x50d4
leaq 0x3276(%rip), %r14      # 0x50d0
leaq 0x17b3(%rip), %r13      # 0x3614
leaq 0x3c08(%rip), %rdi      # 0x5a70
callq 0x12d5
movq %rax, %r15
movl 0x3bde(%rip), %edi      # 0x5a54
cmpl $0x1c, %edi
sete %al
leal -0x5(%rbp), %ecx
cmpl $-0x2, %ecx
setb %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1ecf
leaq 0x321d(%rip), %rax      # 0x50b0
movl (%rax), %esi
leaq 0x1245(%rip), %rdi      # 0x30e1
xorl %eax, %eax
callq 0x10a0
movl %ebp, %edi
callq 0x1316
leaq 0x1395(%rip), %rdi      # 0x3246
movq %rax, %rsi
xorl %eax, %eax
callq 0x10a0
incl (%rbx)
movl $0x1, (%r14)
movl $0x4, %ebp
movl 0x3b85(%rip), %edi      # 0x5a54
callq 0x1517
callq 0x1f75
movl %eax, %r12d
cmpl %ebp, %eax
sete %al
cmpl $0x4, %ebp
sete %cl
orb %al, %cl
jne 0x1f36
leaq 0x31be(%rip), %rax      # 0x50b0
movl (%rax), %esi
leaq 0x11e6(%rip), %rdi      # 0x30e1
xorl %eax, %eax
callq 0x10a0
movl %r12d, %edi
callq 0x1316
movq %rax, %r12
movl %ebp, %edi
callq 0x1316
leaq 0x1304(%rip), %rdi      # 0x321f
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a0
incl (%rbx)
movl $0x1, (%r14)
movl $0x4, %ebp
movq 0x3b0b(%rip), %rdi      # 0x5a48
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x10d0
movq %r15, %rdi
callq 0x1030
movl 0x3afc(%rip), %eax      # 0x5a54
andl $-0x4, %eax
cmpl $0x1c, %eax
je 0x1e61
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/g3ida[P]g3idaCompiler/parse.c
// Function: factor
exprType factor(void)
{
    exprType t = Void;
    int p;
    switch (token) {
    case NUM :
        EMETTRE("empiler %d\n", atoi(lexeme));
        accepter(NUM);
        t = Integer;
        break;
    case ID :
        EMETTRE("valeurd %s\n",lexeme);
        if((p = idExists(lexeme)) == -1) {
            ERROR_MSG("variable '%s' undeclared\n", lexeme);
        }
        t = idTable[p].type;
        accepter(ID);
      break;
    case LPAREN:
        accepter(LPAREN);
        t = simple_expr();
        accepter(RPAREN);
        break;
    default:
        EMETTRE("halte\n");
        ERROR_MSG("unexprected symbol '");
        printSymbole(token,lexeme);
        printf("' \n");
        printSymbole(token,lexeme);
        token = analLex();
        break;
    }
    return t;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x3ad5(%rip), %eax      # 0x5a54
testl %eax, %eax
je 0x1fe1
cmpl $0x11, %eax
je 0x1fc6
cmpl $0x1, %eax
jne 0x206f
movq 0x3ab0(%rip), %rbx      # 0x5a48
leaq 0x3ad1(%rip), %rdi      # 0x5a70
callq 0x1110
leaq 0x12d3(%rip), %rsi      # 0x327e
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x10d0
movl $0x1, %ebx
movl $0x1, %edi
jmp 0x2065
movl $0x11, %edi
callq 0x1517
callq 0x1cdb
movl %eax, %ebx
movl $0x12, %edi
jmp 0x2065
movq 0x3a60(%rip), %rdi      # 0x5a48
leaq 0x129b(%rip), %rsi      # 0x328a
leaq 0x3a7a(%rip), %rbx      # 0x5a70
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10d0
movq %rbx, %rdi
callq 0x123c
movl %eax, %ebx
cmpl $-0x1, %eax
jne 0x2051
leaq 0x309a(%rip), %rax      # 0x50b0
movl (%rax), %esi
leaq 0x10c2(%rip), %rdi      # 0x30e1
xorl %eax, %eax
callq 0x10a0
leaq 0x1269(%rip), %rdi      # 0x3296
leaq 0x3a3c(%rip), %rsi      # 0x5a70
xorl %eax, %eax
callq 0x10a0
leaq 0x3092(%rip), %rax      # 0x50d4
incl (%rax)
leaq 0x3085(%rip), %rax      # 0x50d0
movl $0x1, (%rax)
movslq %ebx, %rax
leaq (%rax,%rax,2), %rax
leaq 0x3081(%rip), %rcx      # 0x50e0
movl 0x8(%rcx,%rax,8), %ebx
xorl %edi, %edi
callq 0x1517
jmp 0x2103
movq 0x39d2(%rip), %rcx      # 0x5a48
leaq 0x1233(%rip), %rdi      # 0x32b0
movl $0x6, %esi
movl $0x1, %edx
callq 0x1120
leaq 0x301d(%rip), %rax      # 0x50b0
movl (%rax), %esi
leaq 0x1045(%rip), %rdi      # 0x30e1
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10a0
leaq 0x120b(%rip), %rdi      # 0x32b7
xorl %eax, %eax
callq 0x10a0
leaq 0x301a(%rip), %rax      # 0x50d4
incl (%rax)
leaq 0x300d(%rip), %rax      # 0x50d0
movl $0x1, (%rax)
movl 0x3985(%rip), %edi      # 0x5a54
leaq 0x399a(%rip), %r14      # 0x5a70
movq %r14, %rsi
callq 0x2110
leaq 0x1294(%rip), %rdi      # 0x3379
callq 0x1060
movl 0x3964(%rip), %edi      # 0x5a54
movq %r14, %rsi
callq 0x2110
callq 0x22e3
movl %eax, 0x3951(%rip)      # 0x5a54
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/g3ida[P]g3idaCompiler/main.c
// Function: main
int main(int argc, char* argv[])
{
	int i;
    if(argc <= 1) {
        printf(" g3idaCompiler: fatal error no input files\n");
        return 0;
    }

    input = fopen(argv[1], "r");
    if(input == NULL) {
        printf(" g3idaCompiler: fatal error file not found %s\n", argv[1]);
        return -1;
    }

    output = fopen("out.txt", "w");

    parse();

    for(i=1; i<idTableMax; ++i) {
        if(!idTable[i].used)
        printf("WARNING : variable '%s' declared but not used\n", idTable[i].id);
    }

    fclose(input);


    #ifdef __WIN32
        system("PAUSE");
    #endif

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x1, %edi
jg 0x26c7
leaq 0xf8c(%rip), %rdi       # 0x3649
callq 0x1060
jmp 0x2766
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
leaq 0x953(%rip), %rsi       # 0x3028
callq 0x1100
leaq 0x337f(%rip), %r14      # 0x5a60
movq %rax, (%r14)
testq %rax, %rax
je 0x2772
leaq 0x9e5(%rip), %rdi       # 0x30d9
leaq 0xf1d(%rip), %rsi       # 0x3618
callq 0x1100
leaq 0x3341(%rip), %rcx      # 0x5a48
movq %rax, (%rcx)
callq 0x1328
leaq 0x29c2(%rip), %r15      # 0x50d8
movl (%r15), %eax
cmpl $0x2, %eax
jl 0x275e
leaq 0x29bb(%rip), %r12      # 0x50e0
addq $0x28, %r12
movl $0x1, %r13d
leaq 0xee4(%rip), %rbx       # 0x361a
cmpl $0x0, (%r12)
jne 0x274f
movq -0x10(%r12), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10a0
movl (%r15), %eax
incq %r13
movslq %eax, %rcx
addq $0x18, %r12
cmpq %rcx, %r13
jl 0x2736
movq (%r14), %rdi
callq 0x1070
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rsi
leaq 0xe6c(%rip), %rdi       # 0x35e9
xorl %eax, %eax
callq 0x10a0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x2768
// File: /workspace/github_c_makefile_star2_O3/zetwhite[P]SimpleEtherCATMaster/util/util.cpp
// Function: getMyMac(unsigned char*, char*)
bool getMyMac(uint8_t macAddress[6],char* dev){
    struct ifreq ifr;
    struct ifconf ifc;
    char buf[1024];
    int success = 0;

    int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
    if (sock == -1) { printf("socek error\n");};

    ifc.ifc_len = sizeof(buf);
    ifc.ifc_buf = buf;
    if (ioctl(sock, SIOCGIFCONF, &ifc) == -1) { printf("getmac_ erro set ioctl\n");  }

    struct ifreq* it = ifc.ifc_req;
    const struct ifreq* const end = it + (ifc.ifc_len / sizeof(struct ifreq));

    for (; it != end; ++it) {
        strcpy(ifr.ifr_name, it->ifr_name);
        if (ioctl(sock, SIOCGIFFLAGS, &ifr) == 0) {
            if (! (ifr.ifr_flags & IFF_LOOPBACK)) { // don't count loopback
                if (ioctl(sock, SIOCGIFHWADDR, &ifr) == 0) {
                    success = 1;
                    break;
                }
            }
        }
        else { printf("getmac _ error ioctl\n"); }
    }

    if (success) 
        memcpy(macAddress, ifr.ifr_hwaddr.sa_data, 6);
    if (success) 
        return true; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp            # imm = 0x438
movq %rdi, %rbx
movl $0x2, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1080
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0x1900
leaq 0x81b(%rip), %rdi       # 0x2116
callq 0x11a0
leaq -0x38(%rbp), %rdx
movl $0x400, (%rdx)          # imm = 0x400
leaq -0x460(%rbp), %rax
movq %rax, 0x8(%rdx)
movl $0x8912, %esi           # imm = 0x8912
movl %r14d, %edi
xorl %eax, %eax
callq 0x1180
cmpl $-0x1, %eax
jne 0x1935
leaq 0x7f2(%rip), %rdi       # 0x2122
callq 0x11a0
movq -0x30(%rbp), %r15
leaq -0x60(%rbp), %r12
leaq 0x7f5(%rip), %r13       # 0x2139
movq %r12, %rdi
movq %r15, %rsi
callq 0x1110
movl $0x8913, %esi           # imm = 0x8913
movl %r14d, %edi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1180
testl %eax, %eax
je 0x196f
movq %r13, %rdi
callq 0x11a0
jmp 0x198b
testb $0x8, -0x50(%rbp)
jne 0x198b
movl $0x8927, %esi           # imm = 0x8927
movl %r14d, %edi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1180
testl %eax, %eax
je 0x1991
addq $0x28, %r15
jmp 0x1944
movzwl -0x4a(%rbp), %eax
movw %ax, 0x4(%rbx)
movl -0x4e(%rbp), %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x438, %rsp            # imm = 0x438
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/mixer/mixer.c
// Function: main
int main(int argc, char **argv){

	struct arguments arguments;
	argp_parse(&argp, argc, argv, 0, 0, &arguments);

	FILE *data_file1 = NULL;
	FILE *data_file2 = NULL;

	data_file1 = fopen(arguments.in_1_filename, "r");
	if(data_file1 == NULL){
		fprintf(stderr, "Error: couldn't open input file 1\n");
		return -1;
	}

	data_file2 = fopen(arguments.in_2_filename, "r");
	if(data_file2 == NULL){
		fprintf(stderr, "Error: couldn't open input file 2\n");
		fclose(data_file1);
		return -1;
	}

	FILE *output_file = fopen(arguments.out_filename, "w");
	if(output_file == NULL){
		fprintf(stderr, "Error: unable to create output file\n");
		fclose(data_file1);
		fclose(data_file2);
		return -1;
	}

	bool eof1 = false, eof2 = false;
	char byte1, byte2;

	while(!eof1 && !eof2){

		byte1 = getc(data_file1);
		byte2 = getc(data_file2);

		fputc(byte1*byte2/16384, output_file);

		eof1 = feof(data_file1);
		eof2 = feof(data_file2);

		if(eof1 != eof2){
			fprintf(stderr, "Error: input file sizes do not match!\n");
			return -1;
		}

	}

	fclose(data_file1);
	fclose(data_file2);
	fclose(output_file);

	return 0;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rdx
movl %edi, %esi
leaq 0x2e0e(%rip), %rdi      # 0x4070
movq %rsp, %rbx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x1050
movq (%rbx), %rdi
leaq 0xda9(%rip), %rsi       # 0x2025
callq 0x1070
testq %rax, %rax
je 0x1351
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0xd8c(%rip), %rsi       # 0x2025
callq 0x1070
testq %rax, %rax
je 0x1358
movq %rax, %r14
movq 0x10(%rsp), %rdi
leaq 0xdb7(%rip), %rsi       # 0x206d
callq 0x1070
testq %rax, %rax
je 0x1362
movq %rax, %r15
xorl %ebp, %ebp
xorl %eax, %eax
testb $0x1, %bpl
jne 0x1335
testb $0x1, %al
jne 0x1335
movq %rbx, %rdi
callq 0x1090
movl %eax, %ebp
movq %r14, %rdi
callq 0x1090
movsbl %bpl, %ecx
movsbl %al, %eax
imull %ecx, %eax
leal 0x3fff(%rax), %ecx
testw %ax, %ax
cmovnsl %eax, %ecx
movswl %cx, %eax
shrl $0xe, %eax
movzwl %ax, %edi
movq %r15, %rsi
callq 0x1040
movq %rbx, %rdi
callq 0x1060
testl %eax, %eax
setne %bpl
movq %r14, %rdi
callq 0x1060
testl %eax, %eax
setne %al
cmpb %al, %bpl
je 0x12cb
callq 0x10b0
jmp 0x136d
movq %rbx, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq %r15, %rdi
callq 0x1030
xorl %eax, %eax
jmp 0x1372
callq 0x113a
jmp 0x136d
movq %rbx, %rdi
callq 0x1110
jmp 0x136d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10d2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/briandowns[P]pass/main.c
// Function: list
static void list(const char *name, const int indent) {
    DIR *dir;
    struct dirent *de;

    if (!(dir = opendir(name))) {
        return;
    }

    while ((de = readdir(dir)) != NULL) {
        if (de->d_name[0] == '.') {
                continue;
        }

        if (de->d_type == DT_DIR) {
            char path[PATH_MAX];
            
            if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) {
                continue;
            }
        
            snprintf(path, sizeof(path), "%s/%s", name, de->d_name);
            printf("%*s- %s/\n", indent, "", de->d_name);
            
            list(path, indent + 4);
        } else {
            printf("%*s- %s\n", indent, "", de->d_name);
        }
    }

    closedir(dir);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1018, %rsp           # imm = 0x1018
movl %esi, %ebx
movq %rdi, %r14
callq 0x484b60
testq %rax, %rax
je 0x402494
movq %rax, %r15
movq %rax, %rdi
callq 0x484dc0
testq %rax, %rax
je 0x40248c
leal 0x4(%rbx), %ecx
movl %ecx, 0xc(%rsp)
leaq 0x104109(%rip), %r12    # 0x50651d
cmpb $0x2e, 0x13(%rax)
je 0x40247f
leaq 0x13(%rax), %r13
cmpb $0x4, 0x12(%rax)
jne 0x402469
movl $0x1000, %esi           # imm = 0x1000
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
leaq 0xdff44(%rip), %rdx     # 0x4e237c
movq %r14, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0x4326c0
leaq 0xdff36(%rip), %rdi     # 0x4e2382
movl %ebx, %esi
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x4325f0
movq %rbp, %rdi
movl 0xc(%rsp), %esi
callq 0x4023ce
jmp 0x40247f
leaq 0xdff1c(%rip), %rdi     # 0x4e238c
movl %ebx, %esi
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x4325f0
movq %r15, %rdi
callq 0x484dc0
testq %rax, %rax
jne 0x402414
movq %r15, %rdi
callq 0x484d90
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/briandowns[P]pass/pass.c
// Function: encrypt_password
int encrypt_password(const char *target_file, const char *password, const unsigned char key[crypto_secretstream_xchacha20poly1305_KEYBYTES]) {
    unsigned char buf_in[MAX_PASS_SIZE];
    unsigned char buf_out[MAX_PASS_SIZE + crypto_secretstream_xchacha20poly1305_ABYTES];
    unsigned char header[crypto_secretstream_xchacha20poly1305_HEADERBYTES];

    crypto_secretstream_xchacha20poly1305_state st;

    unsigned long long out_len;
    unsigned char tag;
    
    FILE *fp_t = fopen(target_file, "wb");

    crypto_secretstream_xchacha20poly1305_init_push(&st, header, key);
    
    fwrite(header, 1, sizeof header, fp_t);

    size_t pass_len = strlen(password);
    do {
        tag = EOF ? crypto_secretstream_xchacha20poly1305_TAG_FINAL : 0;
        crypto_secretstream_xchacha20poly1305_push(&st, buf_out, &out_len, password, pass_len, NULL, 0, tag);
        fwrite(buf_out, 1, (size_t)out_len, fp_t);
    } while (!EOF);

    fclose(fp_t);

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1080, %rsp           # imm = 0x1080
movq %rdx, %r15
movq %rsi, %r14
leaq 0xdfeeb(%rip), %rsi     # 0x4e23b0
callq 0x4414d0
movq %rax, %rbx
leaq 0x2c(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x4029b0
movl $0x1, %esi
movl $0x18, %edx
movq %r13, %rdi
movq %rbx, %rcx
callq 0x4416d0
movq %r14, %rdi
callq 0x4010e8
leaq 0x60(%rsp), %r15
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
pushq $0x3
pushq $0x0
callq 0x402af0
addq $0x10, %rsp
movq (%r13), %rdx
movl $0x1, %esi
movq %r15, %rdi
movq %rbx, %rcx
callq 0x4416d0
movq %rbx, %rdi
callq 0x440c40
xorl %eax, %eax
addq $0x1080, %rsp           # imm = 0x1080
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/briandowns[P]pass/pass.c
// Function: decrypt_password
int decrypt_password(const char *source_file, const unsigned char key[crypto_secretstream_xchacha20poly1305_KEYBYTES]) {
    unsigned char buf_in[MAX_PASS_SIZE + crypto_secretstream_xchacha20poly1305_ABYTES];
    unsigned char buf_out[MAX_PASS_SIZE];
    unsigned char header[crypto_secretstream_xchacha20poly1305_HEADERBYTES];

    crypto_secretstream_xchacha20poly1305_state st;

    unsigned long long out_len;
    int eof;
    int ret = -1;
    unsigned char tag;

    FILE *fp_s = fopen(source_file, "rb");
    fread(header, 1, sizeof(header), fp_s);
    
    if (crypto_secretstream_xchacha20poly1305_init_pull(&st, header, key) != 0) {
        goto ret;
    }

    do {
        size_t rlen = fread(buf_in, 1, sizeof buf_in, fp_s);
        
        eof = feof(fp_s);
        
        if (crypto_secretstream_xchacha20poly1305_pull(&st, buf_out, &out_len, &tag, buf_in, rlen, NULL, 0) != 0) {
            goto ret;
        }

        if (tag == crypto_secretstream_xchacha20poly1305_TAG_FINAL && ! eof) {
            goto ret;
        }

        fwrite(buf_out, 1, (size_t)out_len, stdout);
        fwrite("\n", 1, (size_t)1, stdout);
    } while (!eof);

    ret = 0;
ret:
    fclose(fp_s);
    
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2088, %rsp           # imm = 0x2088
movq %rsi, %r14
leaq 0xdfe3e(%rip), %rsi     # 0x4e23b3
callq 0x4414d0
movq %rax, %rbx
leaq 0x20(%rsp), %r15
movl $0x1, %esi
movl $0x18, %edx
movq %r15, %rdi
movq %rax, %rcx
callq 0x4415d0
leaq 0x3c(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x402a10
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x402651
leaq 0x1070(%rsp), %r14
leaq 0x70(%rsp), %r12
movq $0x520a70, %rbp         # imm = 0x520A70
movl $0x1, %esi
movl $0x1011, %edx           # imm = 0x1011
movq %r14, %rdi
movq %rbx, %rcx
callq 0x4415d0
movq %rax, %r13
movq %rbx, %rdi
callq 0x443c50
movl %eax, %r15d
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
leaq 0x3c(%rsp), %rdi
movq %r12, %rsi
leaq 0x18(%rsp), %rdx
leaq 0x17(%rsp), %rcx
movq %r14, %r8
movq %r13, %r9
callq 0x402d50
testl %eax, %eax
jne 0x40264c
testl %r15d, %r15d
jne 0x40261f
cmpb $0x3, 0x17(%rsp)
je 0x40264c
movq 0x18(%rsp), %rdx
movq (%rbp), %rcx
movl $0x1, %esi
movq %r12, %rdi
callq 0x4416d0
movq (%rbp), %rsi
movl $0xa, %edi
callq 0x443d50
testl %r15d, %r15d
je 0x4025c8
xorl %ebp, %ebp
jmp 0x402651
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x440c40
movl %ebp, %eax
addq $0x2088, %rsp           # imm = 0x2088
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/briandowns[P]pass/pass.c
// Function: create_key
int create_key(const char *key_file)  {
    unsigned char key[crypto_secretstream_xchacha20poly1305_KEYBYTES];
    crypto_secretstream_xchacha20poly1305_keygen(key);

    FILE *f = fopen(key_file, "w");
    if (!f) {
        return 1;
    }

    fwrite(key, 1, crypto_secretstream_xchacha20poly1305_KEYBYTES, f);
    fclose(f);

    return 0;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x4029a0
leaq 0xdfd32(%rip), %rsi     # 0x4e23b6
movq %rbx, %rdi
callq 0x4414d0
testq %rax, %rax
je 0x4026b5
movq %rax, %rbx
movq %rsp, %rdi
movl $0x1, %esi
movl $0x20, %edx
movq %rax, %rcx
callq 0x4416d0
movq %rbx, %rdi
callq 0x440c40
xorl %eax, %eax
jmp 0x4026ba
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/briandowns[P]pass/pass.c
// Function: generate_password
char* generate_password(const int size) {
    srand(time(NULL));

    char *password = malloc(MAX_PASS_SIZE);

    for(int i = 0; i < size; i++) {
        password[i] = ALL_CHARS[randombytes_random() % (sizeof(ALL_CHARS) - 1)];
    }

    return password;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebp
xorl %edi, %edi
callq 0x484930
movl %eax, %edi
callq 0x431020
movl $0x1000, %edi           # imm = 0x1000
callq 0x450c40
movq %rax, %rbx
testl %ebp, %ebp
jle 0x40271d
movl %ebp, %r14d
xorl %r15d, %r15d
leaq 0xdfcc2(%rip), %r12     # 0x4e23b8
callq 0x403ca0
movl %eax, %ecx
imulq $0x2f149903, %rcx, %rcx # imm = 0x2F149903
shrq $0x24, %rcx
imull $0x57, %ecx, %ecx
subl %ecx, %eax
movb (%rax,%r12), %al
movb %al, (%rbx,%r15)
incq %r15
cmpq %r15, %r14
jne 0x4026f6
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Leeheng86[P]word2vec/word2vec.c
// Function: InitUnigramTable()
void InitUnigramTable() {
  int a, i;
  double train_words_pow = 0;
  double d1, power = 0.75;
  table = (int *)malloc(table_size * sizeof(int));
  for (a = 0; a < vocab_size; a++) train_words_pow += pow(vocab[a].cn, power);
  i = 0;
  d1 = pow(vocab[i].cn, power) / train_words_pow;
  for (a = 0; a < table_size; a++) {
    table[a] = i;
    if (a / (double)table_size > d1) {
      i++;
      d1 += pow(vocab[i].cn, power) / train_words_pow;
    }
    if (i >= vocab_size) i = vocab_size - 1;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x17d78400, %edi       # imm = 0x17D78400
callq 0x2300
movq %rax, 0x8e4b(%rip)      # 0xb4f0
cmpq $0x0, 0x8de3(%rip)      # 0xb490
jle 0x26fa
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorl %ebx, %ebx
xorl %r14d, %r14d
movq 0x8db4(%rip), %rax      # 0xb478
xorps %xmm0, %xmm0
cvtsi2sdq (%rax,%rbx), %xmm0
movsd 0x4933(%rip), %xmm1     # 0x7008
callq 0x23e0
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incq %r14
addq $0x28, %rbx
cmpq %r14, 0x8d9a(%rip)      # 0xb490
jg 0x26bd
jmp 0x2703
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x8d6e(%rip), %rax      # 0xb478
xorps %xmm0, %xmm0
cvtsi2sdq (%rax), %xmm0
movsd 0x48ee(%rip), %xmm1     # 0x7008
callq 0x23e0
movapd %xmm0, %xmm2
movsd (%rsp), %xmm1
divsd %xmm1, %xmm2
xorl %ebx, %ebx
movq 0x8dbb(%rip), %rax      # 0xb4f0
movsd 0x48d3(%rip), %xmm3     # 0x7010
xorl %ebp, %ebp
movsd %xmm1, (%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
movl %ebp, (%rax,%rbx,4)
divsd %xmm3, %xmm0
ucomisd %xmm2, %xmm0
jbe 0x27a8
incl %ebp
movq 0x8d17(%rip), %rax      # 0xb478
movslq %ebp, %r14
leaq (%r14,%r14,4), %rcx
xorps %xmm0, %xmm0
cvtsi2sdq (%rax,%rcx,8), %xmm0
movsd 0x488f(%rip), %xmm1     # 0x7008
movsd %xmm2, 0x8(%rsp)
callq 0x23e0
movsd 0x4884(%rip), %xmm3     # 0x7010
movsd 0x8(%rsp), %xmm2
movsd (%rsp), %xmm1
divsd %xmm1, %xmm0
addsd %xmm0, %xmm2
movq 0x8d4a(%rip), %rax      # 0xb4f0
jmp 0x27ab
movslq %ebp, %r14
movq 0x8cde(%rip), %rcx      # 0xb490
leal -0x1(%rcx), %edx
cmpq %r14, %rcx
cmovlel %edx, %ebp
incq %rbx
cmpq $0x5f5e100, %rbx        # imm = 0x5F5E100
jne 0x2744
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Leeheng86[P]word2vec/word2vec.c
// Function: SaveVocab()
void SaveVocab() {
  long long i;
  FILE *fo = fopen(save_vocab_file, "wb");
  for (i = 0; i < vocab_size; i++) fprintf(fo, "%s %lld\n", vocab[i].word, vocab[i].cn);
  fclose(fo);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x80e8(%rip), %rdi      # 0xb3a0
leaq 0x3e4a(%rip), %rsi      # 0x7109
callq 0x22a0
movq %rax, %rbx
cmpq $0x0, 0x81c1(%rip)      # 0xb490
jle 0x330e
movl $0x10, %r15d
leaq 0x3e2e(%rip), %r14      # 0x710c
xorl %r12d, %r12d
movq 0x8190(%rip), %rax      # 0xb478
movq -0x10(%rax,%r15), %rcx
movq (%rax,%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2330
incq %r12
addq $0x28, %r15
cmpq 0x8184(%rip), %r12      # 0xb490
jl 0x32e1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2220
// File: /workspace/github_c_makefile_star2_O3/Leeheng86[P]word2vec/word2vec.c
// Function: ReadVocab()
void ReadVocab() {
  long long a, i = 0;
  char c;
  char word[MAX_STRING];
  FILE *fin = fopen(read_vocab_file, "rb");
  if (fin == NULL) {
    printf("Vocabulary file not found\n");
    exit(1);
  }
  for (a = 0; a < vocab_hash_size; a++) vocab_hash[a] = -1;
  vocab_size = 0;
  while (1) {
    ReadWord(word, fin);
    if (feof(fin)) break;
    a = AddWordToVocab(word);
    fscanf(fin, "%lld%c", &vocab[a].cn, &c);
    i++;
  }
  SortVocab();
  if (debug_mode > 0) {
    printf("Vocab size: %lld\n", vocab_size);
    printf("Words in train file: %lld\n", train_words);
  }
  fin = fopen(train_file, "rb");
  if (fin == NULL) {
    printf("ERROR: training data file not found!\n");
    exit(1);
  }
  fseek(fin, 0, SEEK_END);
  file_size = ftell(fin);
  fclose(fin);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq 0x80dd(%rip), %rdi      # 0xb410
leaq 0x3d97(%rip), %rsi      # 0x70d1
callq 0x22a0
testq %rax, %rax
je 0x345b
movq %rax, %rbx
movq 0x8136(%rip), %rdi      # 0xb488
movl $0x7270e00, %edx        # imm = 0x7270E00
movl $0xff, %esi
callq 0x2150
movq $0x0, 0x8124(%rip) # 0xb490
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x27d4
movq %rbx, %rdi
callq 0x2370
testl %eax, %eax
jne 0x33d6
leaq 0x10(%rsp), %r14
leaq 0x3d84(%rip), %r15      # 0x7115
leaq 0xf(%rsp), %r12
movq %r14, %rdi
callq 0x29a9
cltq
leaq (%rax,%rax,4), %rdx
shlq $0x3, %rdx
addq 0x80c9(%rip), %rdx      # 0xb478
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0x2440
movq %r14, %rdi
movq %rbx, %rsi
callq 0x27d4
movq %rbx, %rdi
callq 0x2370
testl %eax, %eax
je 0x3396
callq 0x2adb
cmpl $0x0, 0x7e7a(%rip)      # 0xb25c
jle 0x340e
movq 0x80a5(%rip), %rsi      # 0xb490
leaq 0x3cea(%rip), %rdi      # 0x70dc
xorl %eax, %eax
callq 0x2050
movq 0x8098(%rip), %rsi      # 0xb498
leaq 0x3ce7(%rip), %rdi      # 0x70ee
xorl %eax, %eax
callq 0x2050
leaq 0x7eab(%rip), %rdi      # 0xb2c0
leaq 0x3cb5(%rip), %rsi      # 0x70d1
callq 0x22a0
testq %rax, %rax
je 0x3464
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2270
movq %rbx, %rdi
callq 0x2030
movq %rax, 0x8061(%rip)      # 0xb4a8
movq %rbx, %rdi
callq 0x2220
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3f3b(%rip), %rdi      # 0x739d
jmp 0x346b
leaq 0x3f65(%rip), %rdi      # 0x73d0
callq 0x2360
movl $0x1, %edi
callq 0x22c0
// File: /workspace/github_c_makefile_star2_O3/Leeheng86[P]word2vec/word2vec.c
// Function: addLink(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void addLink(std::unordered_map<std::string, std::vector<std::string> > &umap, std::string from, std::string to) {
  if (!umap.count(from)) {
    std::vector<std::string> tmp;
    umap[from] = tmp;
  }
  umap[from].push_back(to);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x62e4
testq %rax, %rax
jne 0x49b5
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x643c
movq %rsp, %rsi
movq %rax, %rdi
callq 0x5e58
movq %rsp, %rdi
callq 0x5fee
movq %r15, %rdi
movq %r14, %rsi
callq 0x643c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x604c
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5fee
movq %rbx, %rdi
callq 0x23f0
// File: /workspace/github_c_makefile_star2_O3/Leeheng86[P]word2vec/word2vec.c
// Function: append(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void append(std::vector<std::string> &v, std::string node) {
  if (discard == 0) {
    v.push_back(node);
  } else if (discard == 1 && !left_node.count(node)) {
    v.push_back(node);
  } else if (discard == 2 && !right_node.count(node)) {
    v.push_back(node);
  }
  return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x6a91(%rip), %eax      # 0xb4fc
testl %eax, %eax
je 0x4abd
cmpl $0x1, %eax
jne 0x4a95
leaq 0x6abd(%rip), %rdi      # 0xb538
movq %rbx, %rsi
callq 0x6b36
leaq 0x6ab6(%rip), %rcx      # 0xb540
cmpq %rcx, %rax
je 0x4abd
movl 0x6a67(%rip), %eax      # 0xb4fc
cmpl $0x2, %eax
jne 0x4ab5
leaq 0x6ac7(%rip), %rdi      # 0xb568
movq %rbx, %rsi
callq 0x6b36
leaq 0x6ac0(%rip), %rcx      # 0xb570
cmpq %rcx, %rax
je 0x4abd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x604c
// File: /workspace/github_c_makefile_star2_O3/taeguk[P]Compiler-Proj-Cminus/src/analyze.c
// Function: buildSymtab
void buildSymtab(TreeNode * syntaxTree)
{
  registerIO();

  insertNode(syntaxTree, 0);
  printSymTab(listing);
  typeCheck(syntaxTree);
  mainCheck(syntaxTree);
  /*
  if (TraceAnalyze)
  { fprintf(listing,"\nSymbol table:\n\n");
    printSymTab(listing);
  }
  */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x107, %edi            # imm = 0x107
callq 0x5780
movq %rax, %r14
leaq 0x504a(%rip), %rdi      # 0x63ab
callq 0x5699
movq %rax, %r15
xorl %edi, %edi
xorl %esi, %esi
callq 0x548c
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x53f5
movq %rax, %r14
movq %rax, %rdi
callq 0x1bd7
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl %r13d, 0x8(%r15)
movq 0x28(%r14), %rdi
movq %rax, %rsi
callq 0x1ec7
movl $0x109, %edi            # imm = 0x109
callq 0x5780
movq %rax, %r15
leaq 0x502b(%rip), %rdi      # 0x63e2
callq 0x5699
movq %rax, %r14
movl $0x107, %edi            # imm = 0x107
callq 0x5780
movq %rax, %r12
leaq 0x5e53(%rip), %rdi      # 0x7226
callq 0x5699
movq %r12, %rdi
movq %rax, %rsi
callq 0x5436
movq %rax, %r12
xorl %edi, %edi
xorl %esi, %esi
callq 0x548c
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x53f5
movq %rax, %r15
movq %rax, %rdi
callq 0x1bd7
movl %r13d, 0x8(%r14)
movq 0x28(%r15), %rdi
movq %rax, %rsi
callq 0x1ec7
movq %rbx, %rdi
xorl %esi, %esi
callq 0x14e6
leaq 0x9dd4(%rip), %rax      # 0xb200
movq (%rax), %rdi
callq 0x4e38
movq %rbx, %rdi
callq 0x166c
testq %rbx, %rbx
je 0x147e
movq %rbx, %r14
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x1441
cmpl $0x3, 0xc(%r14)
jne 0x146b
movq 0x28(%r14), %rax
movq 0x20(%rax), %rdi
leaq 0x50b5(%rip), %rsi      # 0x6517
callq 0x1110
testl %eax, %eax
je 0x14a3
leaq 0x5085(%rip), %rsi      # 0x64f7
leaq 0x50a3(%rip), %rdx      # 0x651c
movq %r14, %rdi
jmp 0x148e
leaq 0x5072(%rip), %rsi      # 0x64f7
leaq 0x5070(%rip), %rdx      # 0x64fc
xorl %edi, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1b13
movq 0x20(%r14), %rax
cmpl $0x109, 0x20(%rax)      # imm = 0x109
jne 0x14c7
cmpq $0x0, 0x30(%r14)
je 0x14d7
leaq 0x5039(%rip), %rsi      # 0x64f7
leaq 0x50b3(%rip), %rdx      # 0x6578
jmp 0x1479
leaq 0x4bda(%rip), %rsi      # 0x60a8
leaq 0x5083(%rip), %rdx      # 0x6558
jmp 0x1479
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/taeguk[P]Compiler-Proj-Cminus/src/analyze.c
// Function: printError
static void printError(TreeNode * t, const char *error_type, const char *fmt, ...)
{
  va_list args;
  fprintf(listing, "%s error at line %d: ", error_type, t->lineno);

  va_start(args, fmt);
  vfprintf(listing, fmt, args);
  va_end(args);

  fprintf(listing, "\n");
  Error = TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
leaq -0xe0(%rbp), %r14
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x1b69
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq 0x9690(%rip), %r15      # 0xb200
movq (%r15), %rax
movl 0x8(%rdi), %ecx
leaq 0x4a20(%rip), %rsi      # 0x659d
movq %rax, %rdi
xorl %eax, %eax
callq 0x1120
movabsq $0x3000000018, %rax     # imm = 0x3000000018
leaq -0x30(%rbp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x1190
movq (%r15), %rsi
movl $0xa, %edi
callq 0x10f0
leaq 0x9631(%rip), %rax      # 0xb1f4
movl $0x1, (%rax)
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/taeguk[P]Compiler-Proj-Cminus/src/analyze.c
// Function: registerSymbol
static int registerSymbol(TreeNode *regNode, TreeNode *varNode, SymbolInfo * symbolInfo)
{
  int is_cur_scope;
  if (st_lookup(varNode->attr.ID, &is_cur_scope) == NULL || !is_cur_scope)
    {
      /* not yet in table, so treat as new definition */
      st_register(varNode->attr.ID, varNode->lineno, symbolInfo);
      varNode->nodeType = symbolInfo->nodeType;
      varNode->symbolInfo = symbolInfo;
      return TRUE;
    }
  else /* redeclaration */
    {
      printError(varNode, "Declaration", "Redeclaration of symbol \"%s\"", varNode->attr.ID);
      varNode->nodeType = ErrorT;
      return FALSE;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
leaq -0x14(%rbp), %rsi
callq 0x4d7b
movq 0x20(%rbx), %rcx
testq %rax, %rax
je 0x1f16
cmpl $0x0, -0x14(%rbp)
je 0x1f16
leaq 0x45bc(%rip), %rsi      # 0x64b7
leaq 0x45c1(%rip), %rdx      # 0x64c3
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1b13
movl $0x1, %eax
jmp 0x1f31
movl 0x8(%rbx), %esi
movq %rcx, %rdi
movq %r14, %rdx
callq 0x4a14
movl (%r14), %eax
movq %r14, 0x18(%rbx)
movl $0x1, %r14d
movl %eax, 0x10(%rbx)
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/taeguk[P]Compiler-Proj-Cminus/src/symtab.c
// Function: st_pop_scope
int st_pop_scope(void)
{
  if (cur_scope_level - 1 < 0)
    return -1;

  int i;
  for (i = valid_hash_arr_base[cur_scope_level];
       i < valid_hash_arr_cnt; ++i)
    {
      int h = valid_hash_arr[i];
      BucketList l = hashTable[h];
      
      while ((l != NULL) && l->scope_level >= cur_scope_level)
        {
          struct BucketListRec *tmp = l;
          l = l->next;

          free(tmp);
        }
      hashTable[h] = l;
    }

  valid_hash_arr_cnt = valid_hash_arr_base[cur_scope_level--];

  return 0;
}

// Assembly:
movslq 0x68b4(%rip), %rcx      # 0xb210
testq %rcx, %rcx
jle 0x4a0e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x68a6(%rip), %rdx      # 0xb220
movslq (%rdx,%rcx,4), %r14
movl 0x6890(%rip), %eax      # 0xb214
cmpl %eax, %r14d
jge 0x49e8
leaq 0x6a20(%rip), %r15      # 0xb3b0
leaq 0x1a299(%rip), %r12     # 0x1ec30
movslq (%r15,%r14,4), %r13
movq (%r12,%r13,8), %rdi
testq %rdi, %rdi
je 0x49ca
movl 0x20(%rdi), %eax
cmpl 0x6863(%rip), %eax      # 0xb210
jl 0x49c2
movq 0x28(%rdi), %rbx
callq 0x1030
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x49a4
xorl %edi, %edi
movl 0x684c(%rip), %eax      # 0xb214
jmp 0x49cc
xorl %edi, %edi
movq %rdi, (%r12,%r13,8)
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x4997
movl 0x682f(%rip), %ecx      # 0xb210
leaq 0x6838(%rip), %rdx      # 0xb220
leal -0x1(%rcx), %eax
movl %eax, 0x681f(%rip)      # 0xb210
movslq %ecx, %rax
movl (%rdx,%rax,4), %eax
movl %eax, 0x6817(%rip)      # 0xb214
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/taeguk[P]Compiler-Proj-Cminus/src/symtab.c
// Function: st_refer
void st_refer(char * name, int lineno)
{
  assert(name != NULL);

  int h = hash(name);
  BucketList l =  hashTable[h];

  while (l != NULL && strcmp(name,l->name) != 0)
    l = l->next;

  assert(l != NULL);

  LineList t = l->lines;
  while (t->next != NULL) 
    t = t->next;
  MALLOC(t->next, sizeof(struct LineListRec));
  t->next->lineno = lineno;
  t->next->next = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4d13
movl %esi, %ebx
movq %rdi, %r14
movb (%rdi), %dl
xorl %eax, %eax
testb %dl, %dl
je 0x4c97
leaq 0x1(%r14), %rcx
movsbl %dl, %edx
shll $0x4, %eax
addl %edx, %eax
cltq
imulq $0x4da637d, %rax, %rdx  # imm = 0x4DA637D
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x22, %rdx
addl %esi, %edx
imull $0xd3, %edx, %edx
subl %edx, %eax
movb (%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x4c66
cltq
leaq 0x19f92(%rip), %rcx     # 0x1ec30
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0x4cf4
movq (%r15), %rsi
movq %r14, %rdi
callq 0x1110
testl %eax, %eax
je 0x4cbc
movq 0x28(%r15), %r15
jmp 0x4ca2
movq 0x8(%r15), %rax
movq %rax, %r14
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x4cc0
movl $0x10, %edi
callq 0x1160
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x4d32
movl %ebx, (%rax)
movq $0x0, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2c7c(%rip), %rdi      # 0x7977
leaq 0x2bd8(%rip), %rsi      # 0x78da
leaq 0x2c53(%rip), %rcx      # 0x795c
movl $0x7c, %edx
callq 0x10e0
leaq 0x2bb3(%rip), %rdi      # 0x78cd
leaq 0x2bb9(%rip), %rsi      # 0x78da
leaq 0x2c34(%rip), %rcx      # 0x795c
movl $0x74, %edx
callq 0x10e0
leaq 0x64c7(%rip), %rax      # 0xb200
movq (%rax), %rdi
leaq 0x166e(%rip), %rsi      # 0x63b1
leaq 0x2b90(%rip), %rbx      # 0x78da
leaq 0x2c30(%rip), %r8       # 0x7981
movq %rbx, %rdx
movl $0x81, %ecx
xorl %eax, %eax
callq 0x1120
leaq 0x1679(%rip), %rdi      # 0x63e0
leaq 0x2bee(%rip), %rcx      # 0x795c
movq %rbx, %rsi
movl $0x81, %edx
callq 0x10e0
// File: /workspace/github_c_makefile_star2_O3/taeguk[P]Compiler-Proj-Cminus/src/symtab.c
// Function: st_lookup
SymbolInfo* st_lookup ( char * name, int * is_cur_scope /* 0 or 1 */ )
{
  int h = hash(name);
  BucketList l =  hashTable[h];

  while ((l != NULL) && (strcmp(name,l->name) != 0))
    {
      l = l->next;
    }

  if (l != NULL)
    {
      *is_cur_scope = (cur_scope_level == l->scope_level);
    }

  return l ? l->symbolInfo : NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movb (%rdi), %dl
xorl %eax, %eax
testb %dl, %dl
je 0x4dc9
leaq 0x1(%r14), %rcx
movsbl %dl, %edx
shll $0x4, %eax
addl %edx, %eax
cltq
imulq $0x4da637d, %rax, %rdx  # imm = 0x4DA637D
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x22, %rdx
addl %esi, %edx
imull $0xd3, %edx, %edx
subl %edx, %eax
movb (%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x4d98
cltq
leaq 0x19e60(%rip), %rcx     # 0x1ec30
movq (%rcx,%rax,8), %r12
xorl %r15d, %r15d
testq %r12, %r12
je 0x4e0a
movq (%r12), %rsi
movq %r14, %rdi
callq 0x1110
testl %eax, %eax
je 0x4df3
movq 0x28(%r12), %r12
jmp 0x4dd7
movl 0x6417(%rip), %eax      # 0xb210
xorl %ecx, %ecx
cmpl 0x20(%r12), %eax
sete %cl
movl %ecx, (%rbx)
movq 0x18(%r12), %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: addSibling
TreeNode*
addSibling(TreeNode *origin, TreeNode *follow)
{
  if (origin != NULL) {
    TreeNode *t = origin;
    while (t->sibling != NULL) t = t->sibling;
    t->sibling = follow;
  }
  else {
    origin = follow;
  }
  return origin;
}

// Assembly:
testq %rdi, %rdi
je 0x5335
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq %rdi, %rdx
movq %rdx, %rcx
movq (%rdx), %rdx
testq %rdx, %rdx
jne 0x5325
movq %rsi, (%rcx)
popq %rbp
retq
movq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: allocateTreeNode
TreeNode*
allocateTreeNode(void)
{
  TreeNode *t = calloc(1, sizeof(TreeNode));
  if (t == NULL)
    {
      fprintf(listing,
              "Out of memory error at line %d\n",
              lineno);
    }
  else
    {
      t->sibling = NULL;
      t->lineno = lineno;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl $0x1, %edi
movl $0x40, %esi
callq 0x1100
movq %rax, %rbx
testq %rax, %rax
je 0x5364
leaq 0x5e8b(%rip), %rax      # 0xb1e8
movl (%rax), %eax
movl %eax, 0x8(%rbx)
jmp 0x5385
leaq 0x5e95(%rip), %rax      # 0xb200
movq (%rax), %rdi
leaq 0x5e73(%rip), %rax      # 0xb1e8
movl (%rax), %edx
leaq 0x28ed(%rip), %rsi      # 0x7c6b
xorl %eax, %eax
callq 0x1120
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newVariableDeclarationNode
TreeNode*
newVariableDeclarationNode(TreeNode *type_specifier,
                           TreeNode *_var)
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = VariableDeclarationK;
      t->attr.varDecl.type_spec = type_specifier;
      t->attr.varDecl._var = _var;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5339
testq %rax, %rax
je 0x53b5
movl $0x1, 0xc(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newArrayDeclarationNode
TreeNode*
newArrayDeclarationNode(TreeNode *type_specifier,
                        TreeNode *_var,
                        TreeNode *_num)
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = ArrayDeclarationK;
      t->attr.arrDecl.type_spec = type_specifier;
      t->attr.arrDecl._var = _var;
      t->attr.arrDecl._num = _num;

    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x5339
testq %rax, %rax
je 0x53ea
movl $0x2, 0xc(%rax)
movq %r15, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newFunctionDeclarationNode
TreeNode*
newFunctionDeclarationNode(TreeNode *type_specifier,
                           TreeNode *_var,
                           TreeNode *params,
                           TreeNode *compound_stmt)
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = FunctionDeclarationK;
      t->attr.funcDecl.type_spec = type_specifier;
      t->attr.funcDecl._var = _var;
      t->attr.funcDecl.params = params;
      t->attr.funcDecl.cmpd_stmt = compound_stmt;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x5339
testq %rax, %rax
je 0x542d
movl $0x3, 0xc(%rax)
movq %r12, 0x20(%rax)
movq %r15, 0x28(%rax)
movq %r14, 0x30(%rax)
movq %rbx, 0x38(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq