LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x1fb8
movl %eax, %ebp
movl 0x3bcf(%rip), %eax      # 0x5a54
andl $-0x4, %eax
cmpl $0x1c, %eax
jne 0x1fa7
leaq 0x323c(%rip), %rbx      # 0x50d4
leaq 0x3231(%rip), %r14      # 0x50d0
leaq 0x176e(%rip), %r13      # 0x3614
leaq 0x3bc3(%rip), %rdi      # 0x5a70
callq 0x12d5
movq %rax, %r15
cmpl $0x1c, 0x3b98(%rip)     # 0x5a54
sete %al
leal -0x5(%rbp), %ecx
cmpl $-0x2, %ecx
setb %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1f0c
leaq 0x31da(%rip), %rax      # 0x50b0
movl (%rax), %esi
leaq 0x1202(%rip), %rdi      # 0x30e1
xorl %eax, %eax
callq 0x10a0
movl %ebp, %edi
callq 0x132d
leaq 0x1352(%rip), %rdi      # 0x3246
movq %rax, %rsi
xorl %eax, %eax
callq 0x10a0
incl (%rbx)
movl $0x1, (%r14)
movl $0x4, %ebp
movl 0x3b42(%rip), %edi      # 0x5a54
callq 0x152f
callq 0x1fb8
movl %eax, %r12d
cmpl %ebp, %eax
sete %al
cmpl $0x4, %ebp
sete %cl
orb %al, %cl
jne 0x1f79
leaq 0x317b(%rip), %rax      # 0x50b0
movl (%rax), %esi
leaq 0x11a3(%rip), %rdi      # 0x30e1
xorl %eax, %eax
callq 0x10a0
movl %r12d, %edi
callq 0x132d
movq %rax, %r12
movl %ebp, %edi
callq 0x132d
leaq 0x12c1(%rip), %rdi      # 0x321f
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a0
incl (%rbx)
movl $0x1, (%r14)
movl $0x4, %ebp
movq 0x3ac8(%rip), %rdi      # 0x5a48
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x10d0
movq %r15, %rdi
callq 0x1030
movl 0x3ab9(%rip), %eax      # 0x5a54
andl $-0x4, %eax
cmpl $0x1c, %eax
je 0x1ea6
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_O1/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 0x3a92(%rip), %eax      # 0x5a54
testl %eax, %eax
je 0x2024
cmpl $0x11, %eax
je 0x2009
cmpl $0x1, %eax
jne 0x20b2
movq 0x3a6d(%rip), %rbx      # 0x5a48
leaq 0x3a8e(%rip), %rdi      # 0x5a70
callq 0x1110
leaq 0x1290(%rip), %rsi      # 0x327e
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x10d0
movl $0x1, %ebx
movl $0x1, %edi
jmp 0x20a8
movl $0x11, %edi
callq 0x152f
callq 0x1d22
movl %eax, %ebx
movl $0x12, %edi
jmp 0x20a8
movq 0x3a1d(%rip), %rdi      # 0x5a48
leaq 0x1258(%rip), %rsi      # 0x328a
leaq 0x3a37(%rip), %rbx      # 0x5a70
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10d0
movq %rbx, %rdi
callq 0x123c
movl %eax, %ebx
cmpl $-0x1, %eax
jne 0x2094
leaq 0x3057(%rip), %rax      # 0x50b0
movl (%rax), %esi
leaq 0x107f(%rip), %rdi      # 0x30e1
xorl %eax, %eax
callq 0x10a0
leaq 0x1226(%rip), %rdi      # 0x3296
leaq 0x39f9(%rip), %rsi      # 0x5a70
xorl %eax, %eax
callq 0x10a0
leaq 0x304f(%rip), %rax      # 0x50d4
incl (%rax)
leaq 0x3042(%rip), %rax      # 0x50d0
movl $0x1, (%rax)
movslq %ebx, %rax
leaq (%rax,%rax,2), %rax
leaq 0x303e(%rip), %rcx      # 0x50e0
movl 0x8(%rcx,%rax,8), %ebx
xorl %edi, %edi
callq 0x152f
jmp 0x2146
movq 0x398f(%rip), %rcx      # 0x5a48
leaq 0x11f0(%rip), %rdi      # 0x32b0
movl $0x6, %esi
movl $0x1, %edx
callq 0x1120
leaq 0x2fda(%rip), %rax      # 0x50b0
movl (%rax), %esi
leaq 0x1002(%rip), %rdi      # 0x30e1
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10a0
leaq 0x11c8(%rip), %rdi      # 0x32b7
xorl %eax, %eax
callq 0x10a0
leaq 0x2fd7(%rip), %rax      # 0x50d4
incl (%rax)
leaq 0x2fca(%rip), %rax      # 0x50d0
movl $0x1, (%rax)
movl 0x3942(%rip), %edi      # 0x5a54
leaq 0x3957(%rip), %r14      # 0x5a70
movq %r14, %rsi
callq 0x2150
leaq 0x1251(%rip), %rdi      # 0x3379
callq 0x1060
movl 0x3921(%rip), %edi      # 0x5a54
movq %r14, %rsi
callq 0x2150
callq 0x2323
movl %eax, 0x390e(%rip)      # 0x5a54
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x270b
leaq 0xf48(%rip), %rdi       # 0x3649
callq 0x1060
jmp 0x27a5
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
leaq 0x90f(%rip), %rsi       # 0x3028
callq 0x1100
leaq 0x333b(%rip), %r14      # 0x5a60
movq %rax, (%r14)
testq %rax, %rax
je 0x27b1
leaq 0x9a1(%rip), %rdi       # 0x30d9
leaq 0xed9(%rip), %rsi       # 0x3618
callq 0x1100
leaq 0x32fd(%rip), %rcx      # 0x5a48
movq %rax, (%rcx)
callq 0x1340
leaq 0x297e(%rip), %r15      # 0x50d8
cmpl $0x2, (%r15)
jl 0x279d
leaq 0x2979(%rip), %r12      # 0x50e0
addq $0x28, %r12
movl $0x1, %r13d
leaq 0xea2(%rip), %rbx       # 0x361a
cmpl $0x0, (%r12)
jne 0x278e
movq -0x10(%r12), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10a0
incq %r13
movslq (%r15), %rax
addq $0x18, %r12
cmpq %rax, %r13
jl 0x2778
movq (%r14), %rdi
callq 0x1070
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rsi
leaq 0xe2d(%rip), %rdi       # 0x35e9
xorl %eax, %eax
callq 0x10a0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x27a7
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_15/temperature_conversion.c
// Function: main
int main(void)
{
  float celsius, fahr;
  int lower, upper, step;

  lower = 0;
  upper = 300;
  step = 30;

  // Printing a heading abouve the table
  printf("Celsius\t\tFahr.\n");
  printf("----------------------\n");

  celsius = lower;
  while (celsius <= upper)
  {
    fahr = celsius_to_fahrenheit(celsius);
    printf("%3.0f\t\t%6.1f\n", celsius, fahr);
    celsius += step;
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0xed8(%rip), %rdi       # 0x202e
callq 0x1030
leaq 0xedb(%rip), %rdi       # 0x203d
callq 0x1030
xorpd %xmm0, %xmm0
movl $0xffffffe2, %ebp       # imm = 0xFFFFFFE2
leaq 0xea9(%rip), %rbx       # 0x2020
movsd %xmm0, (%rsp)
addl $0x1e, %ebp
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
movsd (%rsp), %xmm1
mulsd 0xe75(%rip), %xmm1      # 0x2008
addsd 0xe75(%rip), %xmm1      # 0x2010
cvtsd2ss %xmm1, %xmm1
cvtss2sd %xmm0, %xmm0
cvtss2sd %xmm1, %xmm1
movq %rbx, %rdi
movb $0x2, %al
callq 0x1040
movsd (%rsp), %xmm0
addsd 0xe5a(%rip), %xmm0      # 0x2018
cmpl $0x10f, %ebp            # imm = 0x10F
jb 0x1177
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zetwhite[P]SimpleEtherCATMaster/layer2/ethernetHelper.cpp
// Function: EthernetHelper::EthernetHelper(unsigned char*, unsigned char*, unsigned short)
EthernetHelper::EthernetHelper (uint8_t srcMac[6], uint8_t destMac[6], uint16_t type){
    ptr = new struct ethhdr; 
    memcpy(ptr->h_dest, destMac, 6); 
    memcpy(ptr->h_source, srcMac, 6); 
    ptr->h_proto = htons(type);   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0xe, %edi
callq 0x1140
movq %rax, (%r12)
movl (%r14), %ecx
movl %ecx, (%rax)
movzwl 0x4(%r14), %ecx
movw %cx, 0x4(%rax)
movl (%r15), %ecx
movl %ecx, 0x6(%rax)
movzwl 0x4(%r15), %ecx
movw %cx, 0xa(%rax)
rolw $0x8, %bx
movw %bx, 0xc(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zetwhite[P]SimpleEtherCATMaster/layer3/ethercatHeader.cpp
// Function: EthercatHelper::EthercatHelper(unsigned short, bool, unsigned char)
EthercatHelper::EthercatHelper(uint16_t len, bool reserve, uint8_t type){
    ptr = new struct ecathdr; 
    ptr->length = len; 
    ptr->reserve = reserve; 
    ptr->type = type; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
movl $0x2, %edi
callq 0x1140
movq %rax, (%r12)
andl $0x7ff, %r15d           # imm = 0x7FF
shll $0xb, %r14d
orl %r15d, %r14d
shll $0xc, %ebx
orl %r14d, %ebx
movw %bx, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x448, %rsp            # imm = 0x448
movq %rdi, -0x30(%rbp)
movl $0x2, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1080
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0x18fd
leaq 0x81e(%rip), %rdi       # 0x2116
callq 0x11a0
leaq -0x40(%rbp), %rdx
movl $0x400, (%rdx)          # imm = 0x400
leaq -0x470(%rbp), %rax
movq %rax, 0x8(%rdx)
movl $0x8912, %esi           # imm = 0x8912
movl %r14d, %edi
xorl %eax, %eax
callq 0x1180
cmpl $-0x1, %eax
jne 0x1932
leaq 0x7f5(%rip), %rdi       # 0x2122
callq 0x11a0
movslq -0x40(%rbp), %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %rdx
cmpq $0x28, %rcx
jb 0x19b8
movq -0x38(%rbp), %r15
shrq $0x5, %rdx
shlq $0x3, %rdx
leaq (%rdx,%rdx,4), %rbx
leaq -0x68(%rbp), %r12
leaq 0x7d2(%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 0x1992
movq %r13, %rdi
callq 0x11a0
jmp 0x19ae
testb $0x8, -0x58(%rbp)
jne 0x19ae
movl $0x8927, %esi           # imm = 0x8927
movl %r14d, %edi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1180
testl %eax, %eax
je 0x19cc
addq $0x28, %r15
addq $-0x28, %rbx
jne 0x1967
movb $0x1, %al
addq $0x448, %rsp            # imm = 0x448
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl -0x52(%rbp), %eax
movq -0x30(%rbp), %rcx
movw %ax, 0x4(%rcx)
movl -0x56(%rbp), %eax
movl %eax, (%rcx)
jmp 0x19b8
// File: /workspace/github_c_makefile_star2_O1/zetwhite[P]SimpleEtherCATMaster/util/packet.cpp
// Function: Packet::addFrame(unsigned char*, int)
bool Packet::addFrame(unsigned char* frame, int size){
    if(capacity < length + size)
        return false; 
    memcpy(buff + length, frame, size); 
    length += size; 
    return true; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %r15d
movslq 0xc(%rdi), %rdi
leal (%rdi,%rdx), %r12d
cmpl %r12d, %r15d
jl 0x1acd
addq (%rbx), %rdi
movslq %edx, %r14
movq %r14, %rdx
callq 0x10f0
addl %r14d, 0xc(%rbx)
cmpl %r12d, %r15d
setge %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x134a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0xd8c(%rip), %rsi       # 0x2025
callq 0x1070
testq %rax, %rax
je 0x1351
movq %rax, %r14
movq 0x10(%rsp), %rdi
leaq 0xdb7(%rip), %rsi       # 0x206d
callq 0x1070
testq %rax, %rax
je 0x135b
movq %rax, %r15
xorl %ebp, %ebp
xorl %eax, %eax
testb $0x1, %bpl
jne 0x132e
testb $0x1, %al
jne 0x132e
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), %edi
testl %eax, %eax
cmovnsl %eax, %edi
sarl $0xe, %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 0x1366
movq %rbx, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq %r15, %rdi
callq 0x1030
xorl %eax, %eax
jmp 0x136b
callq 0x113a
jmp 0x1366
movq %rbx, %rdi
callq 0x1110
jmp 0x1366
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_O1/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 0x484be0
testq %rax, %rax
je 0x40250f
movq %rax, %r15
movq %rax, %rdi
callq 0x484e40
testq %rax, %rax
je 0x402507
leal 0x4(%rbx), %ecx
movl %ecx, 0xc(%rsp)
leaq 0xdff3e(%rip), %r13     # 0x4e239b
cmpb $0x2e, 0x13(%rax)
je 0x4024f6
leaq 0x13(%rax), %r12
cmpb $0x4, 0x12(%rax)
jne 0x4024e0
movq %r12, %rdi
leaq 0xdff0e(%rip), %rsi     # 0x4e2389
callq 0x4010b8
testl %eax, %eax
je 0x4024f6
movq %r12, %rdi
leaq 0xdfefa(%rip), %rsi     # 0x4e2388
callq 0x4010b8
testl %eax, %eax
je 0x4024f6
movl $0x1000, %esi           # imm = 0x1000
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
leaq 0xdfee0(%rip), %rdx     # 0x4e238b
movq %r14, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x432760
leaq 0xdfed2(%rip), %rdi     # 0x4e2391
movl %ebx, %esi
leaq 0x104095(%rip), %rdx    # 0x50655d
movq %r12, %rcx
xorl %eax, %eax
callq 0x432690
movq %rbp, %rdi
movl 0xc(%rsp), %esi
callq 0x402417
jmp 0x4024f6
movq %r13, %rdi
movl %ebx, %esi
leaq 0x104071(%rip), %rdx    # 0x50655d
movq %r12, %rcx
xorl %eax, %eax
callq 0x432690
movq %r15, %rdi
callq 0x484e40
testq %rax, %rax
jne 0x40245d
movq %r15, %rdi
callq 0x484e10
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xdfe7f(%rip), %rsi     # 0x4e23c0
callq 0x441570
movq %rax, %rbx
leaq 0x2c(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x402a40
movl $0x1, %esi
movl $0x18, %edx
movq %r13, %rdi
movq %rbx, %rcx
callq 0x441770
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 0x402b80
addq $0x10, %rsp
movq (%r13), %rdx
movl $0x1, %esi
movq %r15, %rdi
movq %rbx, %rcx
callq 0x441770
movq %rbx, %rdi
callq 0x440ce0
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_O1/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 0xdfdd2(%rip), %rsi     # 0x4e23c3
callq 0x441570
movq %rax, %rbx
leaq 0x20(%rsp), %r15
movl $0x1, %esi
movl $0x18, %edx
movq %r15, %rdi
movq %rax, %rcx
callq 0x441670
leaq 0x3c(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x402aa0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x4026cd
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 0x441670
movq %rax, %r13
movq %rbx, %rdi
callq 0x443cf0
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 0x402de0
testl %eax, %eax
jne 0x4026c8
testl %r15d, %r15d
jne 0x40269b
cmpb $0x3, 0x17(%rsp)
je 0x4026c8
movq 0x18(%rsp), %rdx
movq (%rbp), %rcx
movl $0x1, %esi
movq %r12, %rdi
callq 0x441770
movq (%rbp), %rsi
movl $0xa, %edi
callq 0x443df0
testl %r15d, %r15d
je 0x402644
xorl %ebp, %ebp
jmp 0x4026cd
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x440ce0
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_O1/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 0x402a30
leaq 0xdfcc6(%rip), %rsi     # 0x4e23c6
movq %rbx, %rdi
callq 0x441570
testq %rax, %rax
je 0x402731
movq %rax, %rbx
movq %rsp, %rdi
movl $0x1, %esi
movl $0x20, %edx
movq %rax, %rcx
callq 0x441770
movq %rbx, %rdi
callq 0x440ce0
xorl %eax, %eax
jmp 0x402736
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4849b0
movl %eax, %edi
callq 0x4310c0
movl $0x1000, %edi           # imm = 0x1000
callq 0x450ce0
movq %rax, %rbx
testl %ebp, %ebp
jle 0x402799
movl %ebp, %r14d
xorl %r15d, %r15d
leaq 0xdfc56(%rip), %r12     # 0x4e23c8
callq 0x403d30
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 0x402772
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movl $0x17d78400, %edi       # imm = 0x17D78400
callq 0x2300
movq %rax, 0x8e4c(%rip)      # 0xb4f0
cmpq $0x0, 0x8de4(%rip)      # 0xb490
jle 0x26fc
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%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 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
incq %r14
addq $0x28, %rbx
cmpq %r14, 0x8d98(%rip)      # 0xb490
jg 0x26bd
jmp 0x2706
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x8d6b(%rip), %rax      # 0xb478
xorps %xmm0, %xmm0
cvtsi2sdq (%rax), %xmm0
movsd 0x48eb(%rip), %xmm1     # 0x7008
callq 0x23e0
movapd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm1
divsd %xmm1, %xmm2
xorl %ebx, %ebx
movsd 0x48d6(%rip), %xmm3     # 0x7010
xorl %r14d, %r14d
movsd %xmm1, 0x8(%rsp)
movq 0x8da6(%rip), %rax      # 0xb4f0
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
movl %r14d, (%rax,%rbx,4)
divsd %xmm3, %xmm0
ucomisd %xmm2, %xmm0
jbe 0x27a8
incl %r14d
movq 0x8d0f(%rip), %rax      # 0xb478
movslq %r14d, %rcx
leaq (%rcx,%rcx,4), %rcx
xorps %xmm0, %xmm0
cvtsi2sdq (%rax,%rcx,8), %xmm0
movsd 0x4887(%rip), %xmm1     # 0x7008
movsd %xmm2, 0x10(%rsp)
callq 0x23e0
movsd 0x487c(%rip), %xmm3     # 0x7010
movsd 0x10(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
divsd %xmm1, %xmm0
addsd %xmm0, %xmm2
movslq %r14d, %r14
movq 0x8cde(%rip), %rax      # 0xb490
leal -0x1(%rax), %ecx
cmpq %r14, %rax
cmovlel %ecx, %r14d
incq %rbx
cmpq $0x5f5e100, %rbx        # imm = 0x5F5E100
jne 0x2743
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Leeheng86[P]word2vec/word2vec.c
// Function: GetWordHash(char*)
int GetWordHash(char *word) {
  unsigned long long a, hash = 0;
  for (a = 0; a < strlen(word); a++) hash = hash * 257 + word[a];
  hash = hash % vocab_hash_size;
  return hash;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2110
xorl %ecx, %ecx
testq %rax, %rax
je 0x28b7
xorl %edx, %edx
movq %rcx, %rsi
shlq $0x8, %rsi
addq %rcx, %rsi
movsbq (%rbx,%rdx), %rcx
addq %rsi, %rcx
incq %rdx
cmpq %rdx, %rax
jne 0x287d
movq %rcx, %rax
shrq $0x7, %rax
movabsq $0x23ca98ce50e9b5d, %rdx # imm = 0x23CA98CE50E9B5D
mulq %rdx
shrq $0xb, %rdx
imull $0x1c9c380, %edx, %eax  # imm = 0x1C9C380
subl %eax, %ecx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Leeheng86[P]word2vec/word2vec.c
// Function: AddWordToVocab(char*)
int AddWordToVocab(char *word) {
  unsigned int hash, length = strlen(word) + 1;
  if (length > MAX_STRING) length = MAX_STRING;
  vocab[vocab_size].word = (char *)calloc(length, sizeof(char));
  strcpy(vocab[vocab_size].word, word);
  vocab[vocab_size].cn = 0;
  vocab_size++;
  // Reallocate memory if needed
  if (vocab_size + 2 >= vocab_max_size) {
    vocab_max_size += 1000;
    vocab = (struct vocab_word *)realloc(vocab, vocab_max_size * sizeof(struct vocab_word));
  }
  hash = GetWordHash(word);
  while (vocab_hash[hash] != -1) hash = (hash + 1) % vocab_hash_size;
  vocab_hash[hash] = vocab_size - 1;
  return vocab_size - 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2110
incl %eax
cmpl $0x64, %eax
movl $0x64, %edi
cmovbl %eax, %edi
movl $0x1, %esi
callq 0x2160
movq 0x8aa8(%rip), %rcx      # 0xb478
movq 0x8ab9(%rip), %rdx      # 0xb490
shlq $0x3, %rdx
leaq (%rdx,%rdx,4), %rdx
movq %rax, 0x10(%rcx,%rdx)
movq 0x8a8d(%rip), %rax      # 0xb478
movq 0x10(%rax,%rdx), %rdi
movq %rbx, %rsi
callq 0x2200
movq 0x8a79(%rip), %rdi      # 0xb478
movq 0x8a8a(%rip), %rax      # 0xb490
leaq (%rax,%rax,4), %rax
movq $0x0, (%rdi,%rax,8)
movq 0x8a77(%rip), %rcx      # 0xb490
leaq 0x1(%rcx), %rax
movq %rax, 0x8a6c(%rip)      # 0xb490
addq $0x3, %rcx
movq 0x8841(%rip), %rax      # 0xb270
cmpq %rax, %rcx
jl 0x2a5a
leaq 0x3e8(%rax), %rcx
movq %rcx, 0x882e(%rip)      # 0xb270
leaq 0x1f40(,%rax,8), %rax
leaq (%rax,%rax,4), %rsi
callq 0x23c0
movq %rax, 0x8a1e(%rip)      # 0xb478
movq %rbx, %rdi
callq 0x2110
xorl %ecx, %ecx
testq %rax, %rax
je 0x2aa5
xorl %edx, %edx
movq %rcx, %rsi
shlq $0x8, %rsi
addq %rcx, %rsi
movsbq (%rbx,%rdx), %rcx
addq %rsi, %rcx
incq %rdx
cmpq %rdx, %rax
jne 0x2a6b
movq %rcx, %rax
shrq $0x7, %rax
movabsq $0x23ca98ce50e9b5d, %rdx # imm = 0x23CA98CE50E9B5D
mulq %rdx
shrq $0xb, %rdx
imull $0x1c9c380, %edx, %eax  # imm = 0x1C9C380
subl %eax, %ecx
movq 0x89dc(%rip), %rdx      # 0xb488
movl %ecx, %esi
cmpl $-0x1, (%rdx,%rsi,4)
je 0x2ac9
xorl %eax, %eax
movl %ecx, %esi
incl %esi
cmpl $0x1c9c380, %esi        # imm = 0x1C9C380
cmovel %eax, %esi
cmpl $-0x1, (%rdx,%rsi,4)
jne 0x2ab8
movl 0x89c1(%rip), %eax      # 0xb490
decl %eax
movl %eax, (%rdx,%rsi,4)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x81c0(%rip), %rdi      # 0xb3a0
leaq 0x3ed6(%rip), %rsi      # 0x70bd
callq 0x22a0
movq %rax, %rbx
cmpq $0x0, 0x8299(%rip)      # 0xb490
jle 0x3236
movl $0x10, %r15d
leaq 0x3eba(%rip), %r14      # 0x70c0
xorl %r12d, %r12d
movq 0x8268(%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 0x825c(%rip), %r12      # 0xb490
jl 0x3209
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2220
// File: /workspace/github_c_makefile_star2_O1/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 0x81b5(%rip), %rdi      # 0xb410
leaq 0x3e23(%rip), %rsi      # 0x7085
callq 0x22a0
testq %rax, %rax
je 0x3383
movq %rax, %rbx
movq 0x820e(%rip), %rdi      # 0xb488
movl $0x7270e00, %edx        # imm = 0x7270E00
movl $0xff, %esi
callq 0x2150
movq $0x0, 0x81fc(%rip) # 0xb490
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x27d4
movq %rbx, %rdi
callq 0x2370
testl %eax, %eax
jne 0x32fe
leaq 0x10(%rsp), %r14
leaq 0x3e10(%rip), %r15      # 0x70c9
leaq 0xf(%rsp), %r12
movq %r14, %rdi
callq 0x29a9
cltq
leaq (%rax,%rax,4), %rdx
shlq $0x3, %rdx
addq 0x81a1(%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 0x32be
callq 0x2adb
cmpl $0x0, 0x7f52(%rip)      # 0xb25c
jle 0x3336
movq 0x817d(%rip), %rsi      # 0xb490
leaq 0x3d76(%rip), %rdi      # 0x7090
xorl %eax, %eax
callq 0x2050
movq 0x8170(%rip), %rsi      # 0xb498
leaq 0x3d73(%rip), %rdi      # 0x70a2
xorl %eax, %eax
callq 0x2050
leaq 0x7f83(%rip), %rdi      # 0xb2c0
leaq 0x3d41(%rip), %rsi      # 0x7085
callq 0x22a0
testq %rax, %rax
je 0x338c
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2270
movq %rbx, %rdi
callq 0x2030
movq %rax, 0x8139(%rip)      # 0xb4a8
movq %rbx, %rdi
callq 0x2220
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3fc7(%rip), %rdi      # 0x7351
jmp 0x3393
leaq 0x3ff1(%rip), %rdi      # 0x7384
callq 0x2360
movl $0x1, %edi
callq 0x22c0
// File: /workspace/github_c_makefile_star2_O1/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 0x5ff2
testq %rax, %rax
jne 0x470b
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x614a
movq %rsp, %rsi
movq %rax, %rdi
callq 0x5b8a
movq %rsp, %rdi
callq 0x5d04
movq %r15, %rdi
movq %r14, %rsi
callq 0x614a
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5d60
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5d04
movq %rbx, %rdi
callq 0x23f0
// File: /workspace/github_c_makefile_star2_O1/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 0x6d3b(%rip), %eax      # 0xb4fc
testl %eax, %eax
je 0x4811
cmpl $0x1, %eax
jne 0x47e5
leaq 0x6d67(%rip), %rdi      # 0xb538
movq %rbx, %rsi
callq 0x6886
leaq 0x6d60(%rip), %rcx      # 0xb540
cmpq %rcx, %rax
je 0x4811
cmpl $0x2, 0x6d10(%rip)      # 0xb4fc
jne 0x4809
leaq 0x6d73(%rip), %rdi      # 0xb568
movq %rbx, %rsi
callq 0x6886
leaq 0x6d6c(%rip), %rcx      # 0xb570
cmpq %rcx, %rax
je 0x4811
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5d60
// File: /workspace/github_c_makefile_star2_O1/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 0x594b
movq %rax, %r14
leaq 0x504a(%rip), %rdi      # 0x63ab
callq 0x5864
movq %rax, %r15
xorl %edi, %edi
xorl %esi, %esi
callq 0x5657
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x55c0
movq %rax, %r14
movq %rax, %rdi
callq 0x1c50
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl %r13d, 0x8(%r15)
movq 0x28(%r14), %rdi
movq %rax, %rsi
callq 0x1f40
movl $0x109, %edi            # imm = 0x109
callq 0x594b
movq %rax, %r15
leaq 0x502b(%rip), %rdi      # 0x63e2
callq 0x5864
movq %rax, %r14
movl $0x107, %edi            # imm = 0x107
callq 0x594b
movq %rax, %r12
leaq 0x5e53(%rip), %rdi      # 0x7226
callq 0x5864
movq %r12, %rdi
movq %rax, %rsi
callq 0x5601
movq %rax, %r12
xorl %edi, %edi
xorl %esi, %esi
callq 0x5657
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x55c0
movq %rax, %r15
movq %rax, %rdi
callq 0x1c50
movl %r13d, 0x8(%r14)
movq 0x28(%r15), %rdi
movq %rax, %rsi
callq 0x1f40
movq %rbx, %rdi
xorl %esi, %esi
callq 0x14e6
leaq 0x9dd4(%rip), %rax      # 0xb200
movq (%rax), %rdi
callq 0x4ffb
movq %rbx, %rdi
callq 0x168a
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 0x1b8c
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_O1/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 0x1be2
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 0x9617(%rip), %r15      # 0xb200
movq (%r15), %rax
movl 0x8(%rdi), %ecx
leaq 0x49a7(%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 0x95b8(%rip), %rax      # 0xb1f4
movl $0x1, (%rax)
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4f3e
movq 0x20(%rbx), %rcx
testq %rax, %rax
je 0x1f91
cmpl $0x0, -0x14(%rbp)
je 0x1f91
leaq 0x4543(%rip), %rsi      # 0x64b7
leaq 0x4548(%rip), %rdx      # 0x64c3
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1b8c
movl $0x1, 0x10(%rbx)
jmp 0x1faf
movl 0x8(%rbx), %esi
movq %rcx, %rdi
movq %r14, %rdx
callq 0x4bd1
movl (%r14), %eax
movl %eax, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movl $0x1, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x66f0(%rip), %rax      # 0xb210
testq %rax, %rax
jle 0x4bcb
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x66e2(%rip), %rcx      # 0xb220
movslq (%rcx,%rax,4), %r14
cmpl 0x66cb(%rip), %r14d     # 0xb214
jge 0x4b9a
leaq 0x685e(%rip), %r15      # 0xb3b0
leaq 0x1a0d7(%rip), %r12     # 0x1ec30
movslq (%r15,%r14,4), %r13
movq (%r12,%r13,8), %rdi
testq %rdi, %rdi
je 0x4b84
movl 0x20(%rdi), %eax
cmpl 0x66a1(%rip), %eax      # 0xb210
jl 0x4b84
movq 0x28(%rdi), %rbx
callq 0x1030
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x4b66
jmp 0x4b87
movq %rdi, %rbx
movq %rbx, (%r12,%r13,8)
incq %r14
movslq 0x667f(%rip), %rax      # 0xb214
cmpq %rax, %r14
jl 0x4b59
movslq 0x666f(%rip), %rax      # 0xb210
leal -0x1(%rax), %ecx
movl %ecx, 0x6666(%rip)      # 0xb210
leaq 0x666f(%rip), %rcx      # 0xb220
movl (%rcx,%rax,4), %eax
movl %eax, 0x665a(%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_O1/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 0x4ed6
movl %esi, %ebx
movq %rdi, %r14
movb (%rdi), %dl
xorl %eax, %eax
testb %dl, %dl
je 0x4e5a
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 0x4e29
cltq
leaq 0x19dcf(%rip), %rcx     # 0x1ec30
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0x4eb7
movq (%r15), %rsi
movq %r14, %rdi
callq 0x1110
testl %eax, %eax
je 0x4e7f
movq 0x28(%r15), %r15
jmp 0x4e65
movq 0x8(%r15), %rax
movq %rax, %r14
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x4e83
movl $0x10, %edi
callq 0x1160
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x4ef5
movl %ebx, (%rax)
movq $0x0, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ab9(%rip), %rdi      # 0x7977
leaq 0x2a15(%rip), %rsi      # 0x78da
leaq 0x2a90(%rip), %rcx      # 0x795c
movl $0x7c, %edx
callq 0x10e0
leaq 0x29f0(%rip), %rdi      # 0x78cd
leaq 0x29f6(%rip), %rsi      # 0x78da
leaq 0x2a71(%rip), %rcx      # 0x795c
movl $0x74, %edx
callq 0x10e0
leaq 0x6304(%rip), %rax      # 0xb200
movq (%rax), %rdi
leaq 0x14ab(%rip), %rsi      # 0x63b1
leaq 0x29cd(%rip), %rbx      # 0x78da
leaq 0x2a6d(%rip), %r8       # 0x7981
movq %rbx, %rdx
movl $0x81, %ecx
xorl %eax, %eax
callq 0x1120
leaq 0x14b6(%rip), %rdi      # 0x63e0
leaq 0x2a2b(%rip), %rcx      # 0x795c
movq %rbx, %rsi
movl $0x81, %edx
callq 0x10e0
// File: /workspace/github_c_makefile_star2_O1/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 0x4f8c
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 0x4f5b
cltq
leaq 0x19c9d(%rip), %rcx     # 0x1ec30
movq (%rcx,%rax,8), %r12
xorl %r15d, %r15d
testq %r12, %r12
je 0x4fcd
movq (%r12), %rsi
movq %r14, %rdi
callq 0x1110
testl %eax, %eax
je 0x4fb6
movq 0x28(%r12), %r12
jmp 0x4f9a
movl 0x6254(%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_O1/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 0x54f9
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq %rdi, %rdx
movq %rdx, %rcx
movq (%rdx), %rdx
testq %rdx, %rdx
jne 0x54e9
movq %rsi, (%rcx)
popq %rbp
retq
movq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x552f
movq $0x0, (%rbx)
leaq 0x5cc0(%rip), %rax      # 0xb1e8
movl (%rax), %eax
movl %eax, 0x8(%rbx)
jmp 0x5550
leaq 0x5cca(%rip), %rax      # 0xb200
movq (%rax), %rdi
leaq 0x5ca8(%rip), %rax      # 0xb1e8
movl (%rax), %edx
leaq 0x2722(%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_O1/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 0x54fd
testq %rax, %rax
je 0x5580
movl $0x1, 0xc(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
popq %rbx
popq %r14
popq %rbp
retq