LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x2340
movl %eax, -0x4(%rbp)
movb $0x1, %al
cmpl $0x19, 0x498b(%rip)     # 0x6b64
movb %al, -0x11(%rbp)
je 0x21f9
movb $0x1, %al
cmpl $0x1a, 0x497d(%rip)     # 0x6b64
movb %al, -0x11(%rbp)
je 0x21f9
cmpl $0x1b, 0x4971(%rip)     # 0x6b64
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x2205
jmp 0x2336
leaq 0x4974(%rip), %rdi      # 0x6b80
callq 0x1340
movq %rax, -0x10(%rbp)
cmpl $0x1b, 0x4948(%rip)     # 0x6b64
jne 0x2285
cmpl $0x3, -0x4(%rbp)
je 0x2283
cmpl $0x4, -0x4(%rbp)
je 0x2283
leaq 0x3e6f(%rip), %rax      # 0x60a0
movl (%rax), %esi
leaq 0x1e93(%rip), %rdi      # 0x40cd
movb $0x0, %al
callq 0x1080
movl -0x4(%rbp), %edi
callq 0x13c0
movq %rax, %rsi
leaq 0x1fc0(%rip), %rdi      # 0x4213
movb $0x0, %al
callq 0x1080
leaq 0x3f83(%rip), %rax      # 0x61e4
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x3f77(%rip), %rax      # 0x61e4
movl %ecx, (%rax)
leaq 0x3f6a(%rip), %rax      # 0x61e0
movl $0x1, (%rax)
movl $0x4, -0x4(%rbp)
jmp 0x2285
movl 0x48d9(%rip), %edi      # 0x6b64
callq 0x1490
callq 0x2340
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
je 0x230f
cmpl $0x4, -0x4(%rbp)
je 0x230f
leaq 0x3df3(%rip), %rax      # 0x60a0
movl (%rax), %esi
leaq 0x1e17(%rip), %rdi      # 0x40cd
movb $0x0, %al
callq 0x1080
movl -0x8(%rbp), %edi
callq 0x13c0
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %edi
callq 0x13c0
movq -0x20(%rbp), %rsi
movq %rax, %rdx
leaq 0x1f6b(%rip), %rdi      # 0x424a
movb $0x0, %al
callq 0x1080
leaq 0x3ef7(%rip), %rax      # 0x61e4
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x3eeb(%rip), %rax      # 0x61e4
movl %ecx, (%rax)
leaq 0x3ede(%rip), %rax      # 0x61e0
movl $0x1, (%rax)
movl $0x4, -0x4(%rbp)
movq 0x4842(%rip), %rdi      # 0x6b58
movq -0x10(%rbp), %rdx
leaq 0x23b1(%rip), %rsi      # 0x46d2
movb $0x0, %al
callq 0x10b0
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x21d0
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x24d0
movl %eax, -0x4(%rbp)
movb $0x1, %al
cmpl $0x1d, 0x480b(%rip)     # 0x6b64
movb %al, -0x11(%rbp)
je 0x2387
movb $0x1, %al
cmpl $0x1e, 0x47fd(%rip)     # 0x6b64
movb %al, -0x11(%rbp)
je 0x2387
movb $0x1, %al
cmpl $0x1f, 0x47ef(%rip)     # 0x6b64
movb %al, -0x11(%rbp)
je 0x2387
cmpl $0x1c, 0x47e3(%rip)     # 0x6b64
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x2393
jmp 0x24c4
leaq 0x47e6(%rip), %rdi      # 0x6b80
callq 0x1340
movq %rax, -0x10(%rbp)
cmpl $0x1c, 0x47ba(%rip)     # 0x6b64
jne 0x2413
cmpl $0x3, -0x4(%rbp)
je 0x2411
cmpl $0x4, -0x4(%rbp)
je 0x2411
leaq 0x3ce1(%rip), %rax      # 0x60a0
movl (%rax), %esi
leaq 0x1d05(%rip), %rdi      # 0x40cd
movb $0x0, %al
callq 0x1080
movl -0x4(%rbp), %edi
callq 0x13c0
movq %rax, %rsi
leaq 0x1e90(%rip), %rdi      # 0x4271
movb $0x0, %al
callq 0x1080
leaq 0x3df5(%rip), %rax      # 0x61e4
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x3de9(%rip), %rax      # 0x61e4
movl %ecx, (%rax)
leaq 0x3ddc(%rip), %rax      # 0x61e0
movl $0x1, (%rax)
movl $0x4, -0x4(%rbp)
jmp 0x2413
movl 0x474b(%rip), %edi      # 0x6b64
callq 0x1490
callq 0x24d0
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
je 0x249d
cmpl $0x4, -0x4(%rbp)
je 0x249d
leaq 0x3c65(%rip), %rax      # 0x60a0
movl (%rax), %esi
leaq 0x1c89(%rip), %rdi      # 0x40cd
movb $0x0, %al
callq 0x1080
movl -0x8(%rbp), %edi
callq 0x13c0
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %edi
callq 0x13c0
movq -0x20(%rbp), %rsi
movq %rax, %rdx
leaq 0x1ddd(%rip), %rdi      # 0x424a
movb $0x0, %al
callq 0x1080
leaq 0x3d69(%rip), %rax      # 0x61e4
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x3d5d(%rip), %rax      # 0x61e4
movl %ecx, (%rax)
leaq 0x3d50(%rip), %rax      # 0x61e0
movl $0x1, (%rax)
movl $0x4, -0x4(%rbp)
movq 0x46b4(%rip), %rdi      # 0x6b58
movq -0x10(%rbp), %rdx
leaq 0x2223(%rip), %rsi      # 0x46d2
movb $0x0, %al
callq 0x10b0
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x2350
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/g3ida[P]g3idaCompiler/lexical.c
// Function: unilexId
static Symbole unilexId (char * s)
{ int i;
  for (i=0;i<NUM_RESERVED;i++)
    if (!strcmp(s,reserved[i].str))
      return reserved[i].tok;
  return ID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xf, -0x14(%rbp)
jge 0x2fb3
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x3168(%rip), %rax      # 0x60e0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x10a0
cmpl $0x0, %eax
jne 0x2fa6
movslq -0x14(%rbp), %rcx
leaq 0x3149(%rip), %rax      # 0x60e0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2fba
jmp 0x2fa8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2f63
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jg 0x3006
leaq 0x1688(%rip), %rdi      # 0x467b
movb $0x0, %al
callq 0x1080
movl $0x0, -0x4(%rbp)
jmp 0x30ee
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xfff(%rip), %rsi       # 0x4014
callq 0x10e0
movq %rax, %rcx
leaq 0x3b4c(%rip), %rax      # 0x6b70
movq %rcx, (%rax)
leaq 0x3b42(%rip), %rax      # 0x6b70
cmpq $0x0, (%rax)
jne 0x3056
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x1664(%rip), %rdi      # 0x46a7
movb $0x0, %al
callq 0x1080
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x30ee
leaq 0x1068(%rip), %rdi      # 0x40c5
leaq 0x1672(%rip), %rsi      # 0x46d6
callq 0x10e0
movq %rax, %rcx
leaq 0x3ae5(%rip), %rax      # 0x6b58
movq %rcx, (%rax)
callq 0x13e0
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x315c(%rip), %rcx      # 0x61e8
cmpl (%rcx), %eax
jge 0x30d8
movslq -0x14(%rbp), %rcx
leaq 0x3155(%rip), %rax      # 0x61f0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x10(%rax)
jne 0x30cb
movslq -0x14(%rbp), %rcx
leaq 0x313d(%rip), %rax      # 0x61f0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0x1614(%rip), %rdi      # 0x46d8
movb $0x0, %al
callq 0x1080
jmp 0x30cd
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3082
leaq 0x3a91(%rip), %rax      # 0x6b70
movq (%rax), %rdi
callq 0x1050
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x12c, -0x14(%rbp)     # imm = 0x12C
movl $0x1e, -0x18(%rbp)
leaq 0xead(%rip), %rdi       # 0x2018
movb $0x0, %al
callq 0x1030
leaq 0xeaf(%rip), %rdi       # 0x2028
movb $0x0, %al
callq 0x1030
cvtsi2ssl -0x10(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm1
cvtsi2ssl -0x14(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jb 0x11d9
cvttss2si -0x8(%rbp), %edi
callq 0x11f0
movss %xmm0, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0xc(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
leaq 0xe7f(%rip), %rdi       # 0x2040
movb $0x2, %al
callq 0x1030
cvtsi2ssl -0x18(%rbp), %xmm0
addss -0x8(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
jmp 0x118a
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movw %cx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0xe, %edi
callq 0x21b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rcx
movq -0x18(%rbp), %rdx
movl (%rdx), %esi
movl %esi, (%rcx)
movw 0x4(%rdx), %dx
movw %dx, 0x4(%rcx)
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %edx
movl %edx, 0x6(%rax)
movw 0x4(%rcx), %cx
movw %cx, 0xa(%rax)
movzwl -0x1a(%rbp), %edi
callq 0x2060
movw %ax, %cx
movq -0x28(%rbp), %rax
movq (%rax), %rax
movw %cx, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movw %si, %dx
movq %rdi, -0x8(%rbp)
movw %dx, -0xa(%rbp)
andb $0x1, %cl
movb %cl, -0xb(%rbp)
movb %al, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x2, %edi
callq 0x21b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movw -0xa(%rbp), %si
movq (%rax), %rcx
movw (%rcx), %dx
andw $0x7ff, %si             # imm = 0x7FF
andw $0xf800, %dx            # imm = 0xF800
orw %si, %dx
movw %dx, (%rcx)
movb -0xb(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
movw %cx, %si
movq (%rax), %rcx
movw (%rcx), %dx
andw $0x1, %si
shlw $0xb, %si
andw $0xf7ff, %dx            # imm = 0xF7FF
orw %si, %dx
movw %dx, (%rcx)
movzbl -0xc(%rbp), %ecx
movw %cx, %dx
movq (%rax), %rax
movw (%rax), %cx
andw $0xf, %dx
shlw $0xc, %dx
andw $0xfff, %cx             # imm = 0xFFF
orw %dx, %cx
movw %cx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x470, %rsp            # imm = 0x470
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x454(%rbp)
movl $0x2, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x2090
movl %eax, -0x458(%rbp)
cmpl $-0x1, -0x458(%rbp)
jne 0x2da8
leaq 0x357(%rip), %rdi       # 0x30f8
movb $0x0, %al
callq 0x2050
movl $0x400, -0x48(%rbp)     # imm = 0x400
leaq -0x450(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x458(%rbp), %edi
movl $0x8912, %esi           # imm = 0x8912
leaq -0x48(%rbp), %rdx
movb $0x0, %al
callq 0x2230
cmpl $-0x1, %eax
jne 0x2de3
leaq 0x329(%rip), %rdi       # 0x3105
movb $0x0, %al
callq 0x2050
movq -0x40(%rbp), %rax
movq %rax, -0x460(%rbp)
movq -0x460(%rbp), %rax
movq %rax, -0x470(%rbp)
movslq -0x48(%rbp), %rax
movl $0x28, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x470(%rbp), %rax
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x468(%rbp)
movq -0x460(%rbp), %rax
cmpq -0x468(%rbp), %rax
je 0x2ebf
leaq -0x38(%rbp), %rdi
movq -0x460(%rbp), %rsi
callq 0x2180
movl -0x458(%rbp), %edi
movl $0x8913, %esi           # imm = 0x8913
leaq -0x38(%rbp), %rdx
movb $0x0, %al
callq 0x2230
cmpl $0x0, %eax
jne 0x2e98
movswl -0x28(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x2e96
movl -0x458(%rbp), %edi
movl $0x8927, %esi           # imm = 0x8927
leaq -0x38(%rbp), %rdx
movb $0x0, %al
callq 0x2230
cmpl $0x0, %eax
jne 0x2e94
movl $0x1, -0x454(%rbp)
jmp 0x2ebf
jmp 0x2e96
jmp 0x2ea6
leaq 0x27e(%rip), %rdi       # 0x311d
movb $0x0, %al
callq 0x2050
jmp 0x2ea8
movq -0x460(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x460(%rbp)
jmp 0x2e22
cmpl $0x0, -0x454(%rbp)
je 0x2ed9
movq -0x8(%rbp), %rax
movl -0x26(%rbp), %ecx
movl %ecx, (%rax)
movw -0x22(%rbp), %cx
movw %cx, 0x4(%rax)
cmpl $0x0, -0x454(%rbp)
je 0x2eef
movb $0x1, %al
andb $0x1, %al
addq $0x470, %rsp            # imm = 0x470
popq %rbp
retq
ud2
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl 0x8(%rcx), %eax
movl 0xc(%rcx), %ecx
addl -0x1c(%rbp), %ecx
cmpl %ecx, %eax
jge 0x2fae
movb $0x0, -0x1(%rbp)
jmp 0x2fda
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movslq 0xc(%rax), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x2140
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/mixer/mixer.c
// Function: parse_opt
static error_t parse_opt(int key, char *arg, struct argp_state *state){

	// remove cast in full C
	struct arguments *arguments = ((struct arguments*)(state->input));

	switch(key){
		case 'i':
			arguments->in_1_filename = arg;
			break;
		case 'k':
			arguments->in_2_filename = arg;
			break;
		case 'o':
			arguments->out_filename = arg;
			break;
		default:
			return ARGP_ERR_UNKNOWN;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x69, %eax
je 0x13ec
jmp 0x13d8
movl -0x24(%rbp), %eax
subl $0x6b, %eax
je 0x13f9
jmp 0x13e2
movl -0x24(%rbp), %eax
subl $0x6f, %eax
je 0x1407
jmp 0x1415
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x141e
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x141e
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x141e
movl $0x7, -0x4(%rbp)
jmp 0x1425
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x1028, %rsp           # imm = 0x1028
movq %rdi, 0x1020(%rsp)
movl %esi, 0x101c(%rsp)
movq 0x1020(%rsp), %rdi
callq 0x484e60
movq %rax, 0x1010(%rsp)
cmpq $0x0, %rax
jne 0x402656
jmp 0x40277e
jmp 0x402658
movq 0x1010(%rsp), %rdi
callq 0x4850c0
movq %rax, 0x1008(%rsp)
cmpq $0x0, %rax
je 0x402771
movq 0x1008(%rsp), %rax
movsbl 0x13(%rax), %eax
cmpl $0x2e, %eax
jne 0x40268a
jmp 0x402658
movq 0x1008(%rsp), %rax
movzbl 0x12(%rax), %eax
cmpl $0x4, %eax
jne 0x402744
movq 0x1008(%rsp), %rdi
addq $0x13, %rdi
leaq 0xe0cd7(%rip), %rsi     # 0x4e3389
callq 0x4010b8
cmpl $0x0, %eax
je 0x4026d9
movq 0x1008(%rsp), %rdi
addq $0x13, %rdi
leaq 0xe0cb9(%rip), %rsi     # 0x4e3388
callq 0x4010b8
cmpl $0x0, %eax
jne 0x4026de
jmp 0x402658
movq %rsp, %rdi
movq 0x1020(%rsp), %rcx
movq 0x1008(%rsp), %r8
addq $0x13, %r8
movl $0x1000, %esi           # imm = 0x1000
leaq 0xe0c8a(%rip), %rdx     # 0x4e338b
movb $0x0, %al
callq 0x432ca0
movl 0x101c(%rsp), %esi
movq 0x1008(%rsp), %rcx
addq $0x13, %rcx
leaq 0xe0c6f(%rip), %rdi     # 0x4e3391
leaq 0x104df4(%rip), %rdx    # 0x50751d
movb $0x0, %al
callq 0x432bd0
movq %rsp, %rdi
movl 0x101c(%rsp), %esi
addl $0x4, %esi
callq 0x402620
jmp 0x40276c
movl 0x101c(%rsp), %esi
movq 0x1008(%rsp), %rcx
addq $0x13, %rcx
leaq 0xe0c3d(%rip), %rdi     # 0x4e339b
leaq 0x104db8(%rip), %rdx    # 0x50751d
movb $0x0, %al
callq 0x432bd0
jmp 0x402658
movq 0x1010(%rsp), %rdi
callq 0x485090
addq $0x1028, %rsp           # imm = 0x1028
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/briandowns[P]pass/main.c
// Function: mkdir_p
static void mkdir_p(const char *dir) {
    char tmp[256];
    char *p = NULL;
    size_t len;

    snprintf(tmp, sizeof(tmp),"%s",dir);
    len = strlen(tmp);
    if (tmp[len - 1] == '/') {
        tmp[len - 1] = 0;
    }

    for (p = tmp + 1; *p; p++) {
        if (*p == '/') {
            *p = 0;
            mkdir(tmp, S_IRWXU);
            *p = '/';
        }
    }

    mkdir(tmp, S_IRWXU);
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x110(%rsp)
movq $0x0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x110(%rsp), %rcx
movl $0x100, %esi            # imm = 0x100
leaq 0x105e50(%rip), %rdx    # 0x508611
movb $0x0, %al
callq 0x432ca0
leaq 0x10(%rsp), %rdi
callq 0x4010e8
movq %rax, (%rsp)
movq (%rsp), %rax
subq $0x1, %rax
movsbl 0x10(%rsp,%rax), %eax
cmpl $0x2f, %eax
jne 0x4027f5
movq (%rsp), %rax
subq $0x1, %rax
movb $0x0, 0x10(%rsp,%rax)
leaq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x40284b
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x402839
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
leaq 0x10(%rsp), %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x485b60
movq 0x8(%rsp), %rax
movb $0x2f, (%rax)
jmp 0x40283b
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x402803
leaq 0x10(%rsp), %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x485b60
addq $0x118, %rsp            # imm = 0x118
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x20c8, %rsp           # imm = 0x20C8
movq %rdi, 0x20c0(%rsp)
movq %rsi, 0x20b8(%rsp)
movq %rdx, 0x20b0(%rsp)
movq 0x20c0(%rsp), %rdi
leaq 0xe0b06(%rip), %rsi     # 0x4e33a4
callq 0x441ab0
movq %rax, 0x20(%rsp)
leaq 0x70(%rsp), %rsi
movq 0x20b0(%rsp), %rdx
leaq 0x3c(%rsp), %rdi
callq 0x402f90
leaq 0x70(%rsp), %rdi
movq 0x20(%rsp), %rcx
movl $0x1, %esi
movl $0x18, %edx
callq 0x441cb0
movq 0x20b8(%rsp), %rdi
callq 0x4010e8
movq %rax, 0x18(%rsp)
movb $0x3, 0x2f(%rsp)
leaq 0x90(%rsp), %rsi
movq 0x20b8(%rsp), %rcx
movq 0x18(%rsp), %r8
leaq 0x3c(%rsp), %rdi
leaq 0x30(%rsp), %rdx
xorl %eax, %eax
movl %eax, %r9d
movq $0x0, (%rsp)
movzbl 0x2f(%rsp), %eax
movl %eax, 0x8(%rsp)
callq 0x4030d0
leaq 0x90(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl $0x1, %esi
callq 0x441cb0
movq 0x20(%rsp), %rdi
callq 0x441220
xorl %eax, %eax
addq $0x20c8, %rsp           # imm = 0x20C8
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x20b8, %rsp           # imm = 0x20B8
movq %rdi, 0x20b0(%rsp)
movq %rsi, 0x20a8(%rsp)
movl $0xffffffff, 0x28(%rsp) # imm = 0xFFFFFFFF
movq 0x20b0(%rsp), %rdi
leaq 0xe0a19(%rip), %rsi     # 0x4e33a7
callq 0x441ab0
movq %rax, 0x18(%rsp)
leaq 0x70(%rsp), %rdi
movq 0x18(%rsp), %rcx
movl $0x1, %esi
movl $0x18, %edx
callq 0x441bb0
leaq 0x70(%rsp), %rsi
movq 0x20a8(%rsp), %rdx
leaq 0x3c(%rsp), %rdi
callq 0x402ff0
cmpl $0x0, %eax
je 0x4029d2
jmp 0x402ab2
jmp 0x4029d4
leaq 0x1090(%rsp), %rdi
movq 0x18(%rsp), %rcx
movl $0x1, %esi
movl $0x1011, %edx           # imm = 0x1011
callq 0x441bb0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x444090
movl %eax, 0x2c(%rsp)
leaq 0x90(%rsp), %rsi
leaq 0x1090(%rsp), %r8
movq 0x10(%rsp), %r9
leaq 0x3c(%rsp), %rdi
leaq 0x30(%rsp), %rdx
leaq 0x27(%rsp), %rcx
xorl %eax, %eax
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x403330
cmpl $0x0, %eax
je 0x402a46
jmp 0x402ab2
movzbl 0x27(%rsp), %eax
cmpl $0x3, %eax
jne 0x402a59
cmpl $0x0, 0x2c(%rsp)
jne 0x402a59
jmp 0x402ab2
leaq 0x90(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq $0x520a70, %rax         # imm = 0x520A70
movq (%rax), %rcx
movl $0x1, %esi
callq 0x441cb0
movq $0x520a70, %rax         # imm = 0x520A70
movq (%rax), %rcx
leaq 0xe95bf(%rip), %rdi     # 0x4ec04a
movl $0x1, %edx
movq %rdx, %rsi
callq 0x441cb0
cmpl $0x0, 0x2c(%rsp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4029d4
movl $0x0, 0x28(%rsp)
movq 0x18(%rsp), %rdi
callq 0x441220
movl 0x28(%rsp), %eax
addq $0x20b8, %rsp           # imm = 0x20B8
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x402f80
movq 0x38(%rsp), %rdi
leaq 0xe08bb(%rip), %rsi     # 0x4e33aa
callq 0x441ab0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x402b0b
movl $0x1, 0x44(%rsp)
jmp 0x402b36
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rcx
movl $0x1, %esi
movl $0x20, %edx
callq 0x441cb0
movq 0x8(%rsp), %rdi
callq 0x441220
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x484c30
movl %eax, %edi
callq 0x431600
movl $0x1000, %edi           # imm = 0x1000
callq 0x450f40
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x402bae
callq 0x404280
movl %eax, %eax
movl $0x57, %ecx
xorl %edx, %edx
divq %rcx
leaq 0xe081b(%rip), %rax     # 0x4e33ac
movb (%rax,%rdx), %dl
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x402b6f
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/briandowns[P]pass/pass.c
// Function: check
void check(const char *pass) {
    printf("report:\n");

    int score = 0;

    size_t pass_size = strlen(pass);

    printf("  greater than 8:");
    if (pass_size > 8) {
        score++;
        printf(" y\n");
    } else {
        printf(" n\n");
    }

    printf("  has lower:");
    if (has_lower_char(pass)) {
        score++;
        printf("      y\n");
    } else {
        printf("      n\n");
    }

    printf("  has upper:");
    if (has_upper_char(pass)) {
        score++;
        printf("      y\n");
    } else {
        printf("      n\n");
    }

    printf("  has special:");
    if (has_special_char(pass)) {
        score++;
        printf("    y\n");
    } else {
        printf("    n\n");
    }

    printf("  in dictionary:");
    if (in_dict(pass)) {
        score--;
        printf("  y\n");
    } else {
        printf("  n\n");
    }

    return;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0xe0834(%rip), %rdi     # 0x4e3404
movb $0x0, %al
callq 0x432bd0
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x4010e8
movq %rax, (%rsp)
leaq 0xe0819(%rip), %rdi     # 0x4e340d
movb $0x0, %al
callq 0x432bd0
cmpq $0x8, (%rsp)
jbe 0x402c1d
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
leaq 0xe081d(%rip), %rdi     # 0x4e3431
movb $0x0, %al
callq 0x432bd0
jmp 0x402c2b
leaq 0xe0816(%rip), %rdi     # 0x4e343a
movb $0x0, %al
callq 0x432bd0
leaq 0xe07ed(%rip), %rdi     # 0x4e341f
movb $0x0, %al
callq 0x432bd0
movq 0x10(%rsp), %rdi
callq 0x402d50
testb $0x1, %al
jne 0x402c49
jmp 0x402c64
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
leaq 0xe07d1(%rip), %rdi     # 0x4e342c
movb $0x0, %al
callq 0x432bd0
jmp 0x402c72
leaq 0xe07ca(%rip), %rdi     # 0x4e3435
movb $0x0, %al
callq 0x432bd0
leaq 0xe07c5(%rip), %rdi     # 0x4e343e
movb $0x0, %al
callq 0x432bd0
movq 0x10(%rsp), %rdi
callq 0x402dd0
testb $0x1, %al
jne 0x402c90
jmp 0x402cab
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
leaq 0xe078a(%rip), %rdi     # 0x4e342c
movb $0x0, %al
callq 0x432bd0
jmp 0x402cb9
leaq 0xe0783(%rip), %rdi     # 0x4e3435
movb $0x0, %al
callq 0x432bd0
leaq 0xe078b(%rip), %rdi     # 0x4e344b
movb $0x0, %al
callq 0x432bd0
movq 0x10(%rsp), %rdi
callq 0x402e50
testb $0x1, %al
jne 0x402cd7
jmp 0x402cf2
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
leaq 0xe0745(%rip), %rdi     # 0x4e342e
movb $0x0, %al
callq 0x432bd0
jmp 0x402d00
leaq 0xe073e(%rip), %rdi     # 0x4e3437
movb $0x0, %al
callq 0x432bd0
leaq 0xe0753(%rip), %rdi     # 0x4e345a
movb $0x0, %al
callq 0x432bd0
movq 0x10(%rsp), %rdi
callq 0x402ed0
testb $0x1, %al
jne 0x402d1e
jmp 0x402d39
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
leaq 0xe0700(%rip), %rdi     # 0x4e3430
movb $0x0, %al
callq 0x432bd0
jmp 0x402d47
leaq 0xe06f9(%rip), %rdi     # 0x4e3439
movb $0x0, %al
callq 0x432bd0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/briandowns[P]pass/pass.c
// Function: has_lower_char
static bool has_lower_char(const char *pass) {
    for (int i = 0; i < strlen(pass); i++) {
        if (strchr(LOWER_CHARS, pass[i]) ) {
            return true;
        }
    }

    return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movslq 0x14(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4010e8
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x402db8
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0xe06d4(%rip), %rdi     # 0x4e346b
callq 0x4010f0
cmpq $0x0, %rax
je 0x402da9
movb $0x1, 0x27(%rsp)
jmp 0x402dbd
jmp 0x402dab
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x402d61
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/briandowns[P]pass/pass.c
// Function: has_upper_char
static bool has_upper_char(const char *pass) {
    for (int i = 0; i < strlen(pass); i++) {
        if (strchr(UPPER_CHARS, pass[i]) ) {
            return true;
        }
    }

    return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movslq 0x14(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4010e8
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x402e38
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0xe066f(%rip), %rdi     # 0x4e3486
callq 0x4010f0
cmpq $0x0, %rax
je 0x402e29
movb $0x1, 0x27(%rsp)
jmp 0x402e3d
jmp 0x402e2b
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x402de1
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/briandowns[P]pass/pass.c
// Function: has_special_char
static bool has_special_char(const char *pass) {
    for (int i = 0; i < strlen(pass); i++) {
        if (strchr(SPECIAL_CHARS, pass[i]) ) {
            return true;
        }
    }

    return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movslq 0x14(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4010e8
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x402eb8
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0xe0553(%rip), %rdi     # 0x4e33ea
callq 0x4010f0
cmpq $0x0, %rax
je 0x402ea9
movb $0x1, 0x27(%rsp)
jmp 0x402ebd
jmp 0x402eab
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x402e61
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/briandowns[P]pass/pass.c
// Function: in_dict
static bool in_dict(const char *pass) {
    char line[26];

    FILE *fp = fopen(WORD_LOCATION, "r");
    if (!fp) {
        perror("could not find the file");
        exit(0);
    }

    while (fgets(line, 26, fp) != NULL ) {
        line[strcspn(line, "\r\n")] = 0;

        if (!strcmp(line, pass)) {
            return true;   
        }
    }

    fclose(fp);

    return false;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
leaq 0xe05c1(%rip), %rdi     # 0x4e34a1
leaq 0x104580(%rip), %rsi    # 0x507467
callq 0x441ab0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x402f0c
leaq 0xe05b7(%rip), %rdi     # 0x4e34b7
callq 0x432ec0
xorl %edi, %edi
callq 0x431310
jmp 0x402f0e
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0x1a, %esi
callq 0x441800
cmpq $0x0, %rax
je 0x402f5b
leaq 0x10(%rsp), %rdi
leaq 0xe059b(%rip), %rsi     # 0x4e34cf
callq 0x4010d0
movb $0x0, 0x10(%rsp,%rax)
leaq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x4010b8
cmpl $0x0, %eax
jne 0x402f59
movb $0x1, 0x47(%rsp)
jmp 0x402f6a
jmp 0x402f0e
movq 0x8(%rsp), %rdi
callq 0x441220
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/kevinp89[P]Operating-System-EXT2-file-system-with-commands/ext2_restore.c
// Function: align
int align(int val) {
	if (val % 4 == 0) {
		return val;
	} else {
	    return val + 4 - (val % 4);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x176f
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x178b
movl -0x8(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl -0xc(%rbp), %eax
subl %edx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0xa8a0(%rip), %xmm0     # 0xe008
movsd %xmm0, -0x20(%rbp)
movl $0x17d78400, %edi       # imm = 0x17D78400
callq 0x33c0
movq %rax, 0x10df2(%rip)     # 0x14570
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq 0x10d80(%rip), %rax     # 0x14510
jge 0x37c6
movq 0x10d5f(%rip), %rax     # 0x144f8
movslq -0x4(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movsd -0x20(%rbp), %xmm0
callq 0x80e0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3785
movl $0x0, -0x8(%rbp)
movq 0x10d24(%rip), %rax     # 0x144f8
movslq -0x8(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movsd -0x20(%rbp), %xmm0
callq 0x80e0
divsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x5f5e100, -0x4(%rbp)  # imm = 0x5F5E100
jge 0x3895
movl -0x8(%rbp), %edx
movq 0x10d5c(%rip), %rax     # 0x14570
movslq -0x4(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
cvtsi2sdl -0x4(%rbp), %xmm0
movsd 0xa7e8(%rip), %xmm1     # 0xe010
divsd %xmm1, %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x386a
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movq 0x10cb5(%rip), %rax     # 0x144f8
movslq -0x8(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movsd -0x20(%rbp), %xmm0
callq 0x80e0
divsd -0x10(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movslq -0x8(%rbp), %rax
cmpq 0x10c9b(%rip), %rax     # 0x14510
jl 0x3885
movq 0x10c92(%rip), %rax     # 0x14510
subq $0x1, %rax
movl %eax, -0x8(%rbp)
jmp 0x3887
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x37fd
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3130
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x39d3
imulq $0x101, -0x18(%rbp), %rax # imm = 0x101
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rdx
movsbq (%rcx,%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x398c
movq -0x18(%rbp), %rax
movl $0x1c9c380, %ecx        # imm = 0x1C9C380
xorl %edx, %edx
divq %rcx
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3130
addq $0x1, %rax
movl %eax, -0x10(%rbp)
cmpl $0x64, -0x10(%rbp)
jbe 0x3af9
movl $0x64, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x31b0
movq %rax, %rcx
movq 0x109e6(%rip), %rax     # 0x144f8
imulq $0x28, 0x109f6(%rip), %rdx # 0x14510
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq 0x109d0(%rip), %rax     # 0x144f8
imulq $0x28, 0x109e0(%rip), %rcx # 0x14510
addq %rcx, %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x3260
movq 0x109b1(%rip), %rax     # 0x144f8
imulq $0x28, 0x109c1(%rip), %rcx # 0x14510
addq %rcx, %rax
movq $0x0, (%rax)
movq 0x109b0(%rip), %rax     # 0x14510
addq $0x1, %rax
movq %rax, 0x109a5(%rip)     # 0x14510
movq 0x1099e(%rip), %rax     # 0x14510
addq $0x2, %rax
cmpq 0x1077b(%rip), %rax     # 0x142f8
jl 0x3bae
movq 0x10772(%rip), %rax     # 0x142f8
addq $0x3e8, %rax            # imm = 0x3E8
movq %rax, 0x10765(%rip)     # 0x142f8
movq 0x1095e(%rip), %rdi     # 0x144f8
imulq $0x28, 0x10756(%rip), %rsi # 0x142f8
callq 0x3490
movq %rax, 0x1094a(%rip)     # 0x144f8
movq -0x8(%rbp), %rdi
callq 0x3970
movl %eax, -0xc(%rbp)
movq 0x10947(%rip), %rax     # 0x14508
movl -0xc(%rbp), %ecx
cmpl $-0x1, (%rax,%rcx,4)
je 0x3bde
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl $0x1c9c380, %ecx        # imm = 0x1C9C380
xorl %edx, %edx
divl %ecx
movl %edx, -0xc(%rbp)
jmp 0x3bba
movq 0x1092b(%rip), %rax     # 0x14510
subq $0x1, %rax
movl %eax, %edx
movq 0x10916(%rip), %rax     # 0x14508
movl -0xc(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movq 0x10911(%rip), %rax     # 0x14510
subq $0x1, %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xfe31(%rip), %rdi      # 0x14420
leaq 0x9ac9(%rip), %rsi      # 0xe0bf
callq 0x3330
movq %rax, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq 0xfefe(%rip), %rax      # 0x14510
jge 0x4659
movq -0x10(%rbp), %rdi
movq 0xfed9(%rip), %rax      # 0x144f8
imulq $0x28, -0x8(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdx
movq 0xfec6(%rip), %rax      # 0x144f8
imulq $0x28, -0x8(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rcx
leaq 0x9a7e(%rip), %rsi      # 0xe0c2
movb $0x0, %al
callq 0x33f0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x4607
movq -0x10(%rbp), %rdi
callq 0x3280
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq $0x0, -0x10(%rbp)
leaq 0xfe06(%rip), %rdi      # 0x14490
leaq 0x99d0(%rip), %rsi      # 0xe061
callq 0x3330
movq %rax, -0x88(%rbp)
cmpq $0x0, -0x88(%rbp)
jne 0x46bf
leaq 0x9a1d(%rip), %rdi      # 0xe0cb
movb $0x0, %al
callq 0x3060
movl $0x1, %edi
callq 0x3350
movq $0x0, -0x8(%rbp)
cmpq $0x1c9c380, -0x8(%rbp)  # imm = 0x1C9C380
jge 0x46f1
movq 0xfe30(%rip), %rax      # 0x14508
movq -0x8(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x46c7
movq $0x0, 0xfe14(%rip) # 0x14510
leaq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x38a0
movq -0x88(%rbp), %rdi
callq 0x3430
cmpl $0x0, %eax
je 0x471f
jmp 0x4764
leaq -0x80(%rbp), %rdi
callq 0x3ad0
cltq
movq %rax, -0x8(%rbp)
movq -0x88(%rbp), %rdi
movq 0xfdbc(%rip), %rdx      # 0x144f8
imulq $0x28, -0x8(%rbp), %rax
addq %rax, %rdx
leaq 0x999b(%rip), %rsi      # 0xe0e6
leaq -0x11(%rbp), %rcx
movb $0x0, %al
callq 0x3520
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x46fc
callq 0x3c30
cmpl $0x0, 0xfb74(%rip)      # 0x142e4
jle 0x479c
movq 0xfd97(%rip), %rsi      # 0x14510
leaq 0x9912(%rip), %rdi      # 0xe092
movb $0x0, %al
callq 0x3060
movq 0xfd8a(%rip), %rsi      # 0x14518
leaq 0x990f(%rip), %rdi      # 0xe0a4
movb $0x0, %al
callq 0x3060
leaq 0xfb9d(%rip), %rdi      # 0x14340
leaq 0x98b7(%rip), %rsi      # 0xe061
callq 0x3330
movq %rax, -0x88(%rbp)
cmpq $0x0, -0x88(%rbp)
jne 0x47d8
leaq 0x989d(%rip), %rdi      # 0xe064
movb $0x0, %al
callq 0x3060
movl $0x1, %edi
callq 0x3350
movq -0x88(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x3300
movq -0x88(%rbp), %rdi
callq 0x3030
movq %rax, 0xfd28(%rip)      # 0x14528
movq -0x88(%rbp), %rdi
callq 0x3280
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8130
cmpq $0x0, %rax
jne 0x67f8
leaq -0x30(%rbp), %rdi
callq 0x8160
movq -0x50(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x8180
movq %rax, -0x58(%rbp)
jmp 0x67c7
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x81b0
jmp 0x67d6
leaq -0x30(%rbp), %rdi
callq 0x8400
jmp 0x67f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8400
jmp 0x6817
movq -0x50(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x8180
movq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x8460
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x34c0