LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x484a60
testq %rax, %rax
je 0x4023f6
movq %rax, %r15
leal 0x4(%rbx), %eax
movl %eax, 0xc(%rsp)
leaq 0x1041ac(%rip), %r12    # 0x50651d
movq %r15, %rdi
callq 0x484cc0
testq %rax, %rax
je 0x4023ee
cmpb $0x2e, 0x13(%rax)
je 0x402371
movq %rax, %r13
addq $0x13, %r13
cmpb $0x4, 0x12(%rax)
jne 0x4023d6
movl $0x1000, %esi           # imm = 0x1000
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
leaq 0xdffd7(%rip), %rdx     # 0x4e237c
movq %r14, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0x4325e0
leaq 0xdffc9(%rip), %rdi     # 0x4e2382
movl %ebx, %esi
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x432510
movq %rbp, %rdi
movl 0xc(%rsp), %esi
callq 0x40233c
jmp 0x402371
leaq 0xdffaf(%rip), %rdi     # 0x4e238c
movl %ebx, %esi
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x432510
jmp 0x402371
movq %r15, %rdi
callq 0x484c90
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1088, %rsp           # imm = 0x1088
movq %rdx, %r15
movq %rsi, %r14
leaq 0xdff8a(%rip), %rsi     # 0x4e23b0
callq 0x4413f0
movq %rax, %rbx
leaq 0x3c(%rsp), %r12
leaq 0x20(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x4028c0
pushq $0x1
popq %r15
pushq $0x18
popq %rdx
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x4415f0
movq %r14, %rdi
callq 0x4010e8
movl $0x3, 0x8(%rsp)
andq $0x0, (%rsp)
leaq 0x70(%rsp), %r13
leaq 0x18(%rsp), %rbp
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0x402a00
movq (%rbp), %rdx
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x4415f0
movq %rbx, %rdi
callq 0x440b60
xorl %eax, %eax
addq $0x1088, %rsp           # imm = 0x1088
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xdfed9(%rip), %rsi     # 0x4e23b3
callq 0x4413f0
movq %rax, %rbx
leaq 0x20(%rsp), %r15
pushq $0x1
popq %rsi
pushq $0x18
popq %rdx
movq %r15, %rdi
movq %rax, %rcx
callq 0x4414f0
leaq 0x3c(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x402920
pushq $-0x1
popq %rbp
testl %eax, %eax
jne 0x4025b1
pushq $0x1
popq %r12
leaq 0x70(%rsp), %r13
movl $0x1011, %edx           # imm = 0x1011
leaq 0x1070(%rsp), %r15
movq %r15, %rdi
movq %r12, %r14
movq %r12, %rsi
movq %rbx, %rcx
callq 0x4414f0
movq %rax, %r12
movq %rbx, %rdi
callq 0x443b70
movl %eax, %ebp
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
leaq 0x3c(%rsp), %rdi
movq %r13, %rsi
leaq 0x18(%rsp), %rdx
leaq 0x17(%rsp), %rcx
movq %r15, %r8
movq %r12, %r9
callq 0x402c60
testl %eax, %eax
jne 0x4025ae
testl %ebp, %ebp
jne 0x40257a
cmpb $0x3, 0x17(%rsp)
je 0x4025ae
movq 0x18(%rsp), %rdx
movq $0x520a70, %r15         # imm = 0x520A70
movq (%r15), %rcx
movq %r13, %rdi
movq %r14, %r12
movq %r14, %rsi
callq 0x4415f0
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x443c70
testl %ebp, %ebp
je 0x40251c
xorl %ebp, %ebp
jmp 0x4025b1
pushq $-0x1
popq %rbp
movq %rbx, %rdi
callq 0x440b60
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_O2/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 0x4028b0
leaq 0xdfdd2(%rip), %rsi     # 0x4e23b6
movq %rbx, %rdi
callq 0x4413f0
testq %rax, %rax
je 0x402611
movq %rax, %rbx
movq %rsp, %rdi
pushq $0x1
popq %rsi
pushq $0x20
popq %rdx
movq %rax, %rcx
callq 0x4415f0
movq %rbx, %rdi
callq 0x440b60
xorl %eax, %eax
jmp 0x402614
pushq $0x1
popq %rax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, %ebx
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x484830
movl %eax, %edi
callq 0x430f40
movl $0x1000, %edi           # imm = 0x1000
callq 0x450b60
movq %rax, %r14
testl %ebx, %ebx
cmovlel %r15d, %ebx
pushq $0x57
popq %rbp
leaq 0xdfd66(%rip), %r12     # 0x4e23b8
cmpq %r15, %rbx
je 0x40266d
callq 0x403bb0
xorl %edx, %edx
divl %ebp
movb (%rdx,%r12), %al
movb %al, (%r14,%r15)
incq %r15
jmp 0x402652
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Leeheng86[P]word2vec/word2vec.c
// Function: InitUnigramTable()
void InitUnigramTable() {
  int a, i;
  double train_words_pow = 0;
  double d1, power = 0.75;
  table = (int *)malloc(table_size * sizeof(int));
  for (a = 0; a < vocab_size; a++) train_words_pow += pow(vocab[a].cn, power);
  i = 0;
  d1 = pow(vocab[i].cn, power) / train_words_pow;
  for (a = 0; a < table_size; a++) {
    table[a] = i;
    if (a / (double)table_size > d1) {
      i++;
      d1 += pow(vocab[i].cn, power) / train_words_pow;
    }
    if (i >= vocab_size) i = vocab_size - 1;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x17d78400, %edi       # imm = 0x17D78400
callq 0x22f0
movq %rax, 0x8e5b(%rip)      # 0xb4f0
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorl %ebx, %ebx
xorl %r14d, %r14d
movq 0x8dce(%rip), %rax      # 0xb478
cmpq %r14, 0x8ddf(%rip)      # 0xb490
jle 0x26dd
cvtsi2sdq (%rax,%rbx), %xmm0
movsd 0x4947(%rip), %xmm1     # 0x7008
callq 0x23e0
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incq %r14
addq $0x28, %rbx
jmp 0x26a3
cvtsi2sdq (%rax), %xmm0
movsd 0x491e(%rip), %xmm1     # 0x7008
callq 0x23e0
movapd %xmm0, %xmm1
divsd (%rsp), %xmm1
xorl %ebx, %ebx
movsd 0x490e(%rip), %xmm2     # 0x7010
xorl %ebp, %ebp
cmpq $0x5f5e100, %rbx        # imm = 0x5F5E100
je 0x277f
movq 0x8ddc(%rip), %rax      # 0xb4f0
cvtsi2sd %ebx, %xmm0
movl %ebp, (%rax,%rbx,4)
divsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2767
incl %ebp
movq 0x8d4a(%rip), %rax      # 0xb478
movslq %ebp, %r14
imulq $0x28, %r14, %rcx
cvtsi2sdq (%rax,%rcx), %xmm0
movsd %xmm1, 0x8(%rsp)
movsd 0x48bf(%rip), %xmm1     # 0x7008
callq 0x23e0
movsd 0x48ba(%rip), %xmm2     # 0x7010
movsd 0x8(%rsp), %xmm1
divsd (%rsp), %xmm0
addsd %xmm0, %xmm1
jmp 0x276a
movslq %ebp, %r14
movq 0x8d1f(%rip), %rax      # 0xb490
leal -0x1(%rax), %ecx
cmpq %r14, %rax
cmovlel %ecx, %ebp
incq %rbx
jmp 0x2704
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x20f0
xorl %edx, %edx
xorl %ecx, %ecx
cmpq %rdx, %rax
je 0x2832
imulq $0x101, %rcx, %rsi      # imm = 0x101
movsbq (%rbx,%rdx), %rcx
addq %rsi, %rcx
incq %rdx
jmp 0x2819
movl $0x1c9c380, %esi        # imm = 0x1C9C380
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x20f0
incl %eax
cmpl $0x64, %eax
pushq $0x64
popq %rdi
cmovbl %eax, %edi
pushq $0x1
popq %rsi
callq 0x2160
imulq $0x28, 0x8b8f(%rip), %rcx # 0xb490
movq 0x8b70(%rip), %rdx      # 0xb478
movq %rax, 0x10(%rdx,%rcx)
movq 0x8b64(%rip), %rax      # 0xb478
movq 0x10(%rax,%rcx), %rdi
movq %rbx, %rsi
callq 0x21f0
imulq $0x28, 0x8b67(%rip), %rax # 0xb490
movq 0x8b48(%rip), %rdi      # 0xb478
andq $0x0, (%rdi,%rax)
movq 0x8b54(%rip), %rcx      # 0xb490
leaq 0x1(%rcx), %rax
movq %rax, 0x8b49(%rip)      # 0xb490
addq $0x3, %rcx
movq 0x8926(%rip), %rax      # 0xb278
cmpq %rax, %rcx
jl 0x2974
addq $0x3e8, %rax            # imm = 0x3E8
movq %rax, 0x8914(%rip)      # 0xb278
imulq $0x28, %rax, %rsi
callq 0x23c0
movq %rax, 0x8b04(%rip)      # 0xb478
movq %rbx, %rdi
callq 0x280c
movq 0x8b05(%rip), %rdx      # 0xb488
xorl %ecx, %ecx
movl %eax, %eax
cmpl $-0x1, (%rdx,%rax,4)
je 0x2999
incl %eax
cmpl $0x1c9c380, %eax        # imm = 0x1C9C380
cmovel %ecx, %eax
jmp 0x2985
movl 0x8af1(%rip), %ecx      # 0xb490
decl %ecx
movl %ecx, (%rdx,%rax,4)
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Leeheng86[P]word2vec/word2vec.c
// Function: SortVocab()
void SortVocab() {
  int a, size;
  unsigned int hash;
  // Sort the vocabulary and keep 
 at the first position
  qsort(&vocab[1], vocab_size - 1, sizeof(struct vocab_word), VocabCompare);
  for (a = 0; a < vocab_hash_size; a++) vocab_hash[a] = -1;
  size = vocab_size;
  train_words = 0;
  for (a = 0; a < size; a++) {
    // Words occuring less than min_count times will be discarded from the vocab
    if ((vocab[a].cn < min_count) && (a != 0)) {
      vocab_size--;
      free(vocab[a].word);
    } else {
      // Hash will be re-computed, as after the sorting it is not actual
      hash=GetWordHash(vocab[a].word);
      while (vocab_hash[hash] != -1) hash = (hash + 1) % vocab_hash_size;
      vocab_hash[hash] = a;
      train_words += vocab[a].cn;
    }
  }
  vocab = (struct vocab_word *)realloc(vocab, (vocab_size + 1) * sizeof(struct vocab_word));
  // Allocate memory for the binary tree construction
  for (a = 0; a < vocab_size; a++) {
    vocab[a].code = (char *)calloc(MAX_CODE_LENGTH, sizeof(char));
    vocab[a].point = (int *)calloc(MAX_CODE_LENGTH, sizeof(int));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8abb(%rip), %rdi      # 0xb478
addq $0x28, %rdi
movq 0x8ac8(%rip), %rsi      # 0xb490
decq %rsi
leaq -0x2a(%rip), %rcx       # 0x29a8
pushq $0x28
popq %rdx
callq 0x2450
xorl %eax, %eax
movq 0x8aa5(%rip), %rcx      # 0xb488
cmpq $0x1c9c380, %rax        # imm = 0x1C9C380
je 0x29f4
orl $-0x1, (%rcx,%rax,4)
incq %rax
jmp 0x29e3
movl 0x8a96(%rip), %ebx      # 0xb490
andq $0x0, 0x8a96(%rip)      # 0xb498
xorl %r14d, %r14d
testl %ebx, %ebx
cmovlel %r14d, %ebx
xorl %r15d, %r15d
movq 0x8a63(%rip), %rdi      # 0xb478
cmpq %rbx, %r15
je 0x2a7e
imulq $0x28, %r15, %rax
movq (%rdi,%rax), %r12
testq %r15, %r15
je 0x2a46
movslq 0x883e(%rip), %rcx      # 0xb26c
cmpq %rcx, %r12
jge 0x2a46
decq 0x8a56(%rip)            # 0xb490
movq 0x10(%rdi,%rax), %rdi
callq 0x2290
jmp 0x2a79
addq %rax, %rdi
movq 0x10(%rdi), %rdi
callq 0x280c
movq 0x8a2f(%rip), %rcx      # 0xb488
movl %eax, %eax
cmpl $-0x1, (%rcx,%rax,4)
je 0x2a6e
incl %eax
cmpl $0x1c9c380, %eax        # imm = 0x1C9C380
cmovel %r14d, %eax
jmp 0x2a59
movl %r15d, (%rcx,%rax,4)
addq %r12, 0x8a1f(%rip)      # 0xb498
incq %r15
jmp 0x2a0e
imulq $0x28, 0x8a0a(%rip), %rsi # 0xb490
addq $0x28, %rsi
callq 0x23c0
movq 0x89fa(%rip), %r12      # 0xb490
xorl %r13d, %r13d
testq %r12, %r12
cmovleq %r13, %r12
movq %rax, 0x89d1(%rip)      # 0xb478
pushq $0x28
popq %rbx
pushq $0x1
popq %r14
pushq $0x4
popq %r15
subq $0x1, %r12
jb 0x2aec
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2160
movq 0x89ae(%rip), %rcx      # 0xb478
movq %rax, 0x18(%rcx,%r13)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2160
movq 0x8997(%rip), %rcx      # 0xb478
movq %rax, 0x8(%rcx,%r13)
addq $0x28, %r13
jmp 0x2ab2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Leeheng86[P]word2vec/word2vec.c
// Function: LearnVocabFromTrainFile()
void LearnVocabFromTrainFile() {
  char word[MAX_STRING];
  FILE *fin;
  long long a, i;
  for (a = 0; a < vocab_hash_size; a++) vocab_hash[a] = -1;
  fin = fopen(train_file, "rb");
  if (fin == NULL) {
    printf("ERROR: training data file not found!\n");
    exit(1);
  }
  vocab_size = 0;
  AddWordToVocab((char *)"
");
  while (1) {
    ReadWord(word, fin);
    if (feof(fin)) break;
    train_words++;
    if ((debug_mode > 1) && (train_words % 100000 == 0)) {
      printf("%lldK%c", train_words / 1000, 13);
      fflush(stdout);
    }
    i = SearchVocab(word);
    if (i == -1) {
      a = AddWordToVocab(word);
      vocab[a].cn = 1;
    } else vocab[i].cn++;
    if (vocab_size > vocab_hash_size * 0.7) ReduceVocab();
  }
  SortVocab();
  if (debug_mode > 0) {
    printf("Vocab size: %lld\n", vocab_size);
    printf("Words in train file: %lld\n", train_words);
  }
  file_size = ftell(fin);
  fclose(fin);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq 0x868a(%rip), %rax      # 0xb488
xorl %ecx, %ecx
cmpq $0x1c9c380, %rcx        # imm = 0x1C9C380
je 0x2e12
orl $-0x1, (%rax,%rcx,4)
incq %rcx
jmp 0x2e00
leaq 0x84a7(%rip), %rdi      # 0xb2c0
leaq 0x4255(%rip), %rsi      # 0x7075
callq 0x2280
testq %rax, %rax
je 0x2f7d
movq %rax, %rbx
andq $0x0, 0x8657(%rip)      # 0xb490
leaq 0x4230(%rip), %rdi      # 0x7070
callq 0x28dd
movq %rsp, %r14
movl $0x186a0, %r12d         # imm = 0x186A0
leaq 0x4223(%rip), %r15      # 0x7078
pushq $0xd
popq %rbp
movq 0x8171(%rip), %r13      # 0xafd0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2788
movq %rbx, %rdi
callq 0x2370
testl %eax, %eax
jne 0x2f20
movq 0x8617(%rip), %rcx      # 0xb498
incq %rcx
movq %rcx, 0x860d(%rip)      # 0xb498
movl 0x83d3(%rip), %esi      # 0xb264
movq %rcx, %rax
cqto
idivq %r12
cmpl $0x2, %esi
jl 0x2ec8
testq %rdx, %rdx
jne 0x2ec8
movq %rcx, %rax
cqto
movl $0x3e8, %ecx            # imm = 0x3E8
idivq %rcx
movq %r15, %rdi
movq %rax, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2050
movq (%r13), %rdi
callq 0x2270
movq %r14, %rdi
callq 0x2844
cmpl $-0x1, %eax
je 0x2ee8
cltq
movq 0x859a(%rip), %rcx      # 0xb478
imulq $0x28, %rax, %rax
incq (%rcx,%rax)
jmp 0x2f05
movq %r14, %rdi
callq 0x28dd
cltq
movq 0x857f(%rip), %rcx      # 0xb478
imulq $0x28, %rax, %rax
movq $0x1, (%rcx,%rax)
cmpq $0x1406f41, 0x8580(%rip) # imm = 0x1406F41
jl 0x2e5f
callq 0x2af6
jmp 0x2e5f
callq 0x29ad
cmpl $0x0, 0x8338(%rip)      # 0xb264
jle 0x2f58
movq 0x855b(%rip), %rsi      # 0xb490
leaq 0x4144(%rip), %rdi      # 0x7080
xorl %eax, %eax
callq 0x2050
movq 0x854e(%rip), %rsi      # 0xb498
leaq 0x4141(%rip), %rdi      # 0x7092
xorl %eax, %eax
callq 0x2050
movq %rbx, %rdi
callq 0x2030
movq %rax, 0x8541(%rip)      # 0xb4a8
movq %rbx, %rdi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2210
leaq 0x43f0(%rip), %rdi      # 0x7374
callq 0x2360
pushq $0x1
popq %rdi
callq 0x22a0
// File: /workspace/github_c_makefile_star2_O2/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 0x8400(%rip), %rdi      # 0xb3a0
leaq 0x4106(%rip), %rsi      # 0x70ad
callq 0x2280
movq %rax, %rbx
pushq $0x10
popq %r15
leaq 0x40f6(%rip), %r14      # 0x70b0
xorl %r12d, %r12d
cmpq 0x84cc(%rip), %r12      # 0xb490
jge 0x2fec
movq 0x84ab(%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
jmp 0x2fbd
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2210
// File: /workspace/github_c_makefile_star2_O2/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 0x83ff(%rip), %rdi      # 0xb410
leaq 0x405d(%rip), %rsi      # 0x7075
callq 0x2280
testq %rax, %rax
je 0x311e
movq %rax, %rbx
movq 0x8458(%rip), %rax      # 0xb488
xorl %ecx, %ecx
cmpq $0x1c9c380, %rcx        # imm = 0x1C9C380
je 0x3044
orl $-0x1, (%rax,%rcx,4)
incq %rcx
jmp 0x3032
andq $0x0, 0x8444(%rip)      # 0xb490
leaq 0x10(%rsp), %r14
leaq 0x4061(%rip), %r15      # 0x70b9
leaq 0xf(%rsp), %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2788
movq %rbx, %rdi
callq 0x2370
testl %eax, %eax
jne 0x309b
movq %r14, %rdi
callq 0x28dd
cltq
imulq $0x28, %rax, %rdx
addq 0x83ef(%rip), %rdx      # 0xb478
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0x2440
jmp 0x305d
callq 0x29ad
cmpl $0x0, 0x81bd(%rip)      # 0xb264
jle 0x30d3
movq 0x83e0(%rip), %rsi      # 0xb490
leaq 0x3fc9(%rip), %rdi      # 0x7080
xorl %eax, %eax
callq 0x2050
movq 0x83d3(%rip), %rsi      # 0xb498
leaq 0x3fc6(%rip), %rdi      # 0x7092
xorl %eax, %eax
callq 0x2050
leaq 0x81e6(%rip), %rdi      # 0xb2c0
leaq 0x3f94(%rip), %rsi      # 0x7075
callq 0x2280
testq %rax, %rax
je 0x3127
movq %rax, %rbx
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x2250
movq %rbx, %rdi
callq 0x2030
movq %rax, 0x839e(%rip)      # 0xb4a8
movq %rbx, %rdi
callq 0x2210
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x421c(%rip), %rdi      # 0x7341
jmp 0x312e
leaq 0x4246(%rip), %rdi      # 0x7374
callq 0x2360
pushq $0x1
popq %rdi
callq 0x22a0
// File: /workspace/github_c_makefile_star2_O2/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 0x56f4
testq %rax, %rax
jne 0x43c7
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x5884
movq %rsp, %rsi
movq %rax, %rdi
callq 0x5316
movq %rsp, %rdi
callq 0x53e0
movq %r15, %rdi
movq %r14, %rsi
callq 0x5884
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5402
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x53e0
movq %rbx, %rdi
callq 0x23f0
// File: /workspace/github_c_makefile_star2_O2/Leeheng86[P]word2vec/word2vec.c
// Function: IsNextIElementsEnd(std::__detail::_Node_iterator<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>>>>>, false, true>, int)
bool IsNextIElementsEnd(std::unordered_map<std::string, std::vector<std::string> >::iterator it, int i) {
    std::unordered_map<std::string, std::vector<std::string> >::iterator itt = it;
    for (int j = 0; j <= i; j++) {
        if (itt == umap.end()) {
            return true;
        }
        itt++;
    }
    return false;
}

// Assembly:
xorl %eax, %eax
cmpl %esi, %eax
jg 0x4446
testq %rdi, %rdi
je 0x4446
movq (%rdi), %rdi
incl %eax
jmp 0x4436
cmpl %esi, %eax
setle %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x70a0(%rip), %eax      # 0xb4fc
testl %eax, %eax
je 0x44a0
cmpl $0x1, %eax
jne 0x447f
leaq 0x70cc(%rip), %rdi      # 0xb538
movq %rbx, %rsi
callq 0x542e
testq %rax, %rax
je 0x44a0
movl 0x707d(%rip), %eax      # 0xb4fc
cmpl $0x2, %eax
jne 0x4498
leaq 0x70dd(%rip), %rdi      # 0xb568
movq %rbx, %rsi
callq 0x542e
testq %rax, %rax
je 0x44a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5402
// File: /workspace/github_c_makefile_star2_O2/Leeheng86[P]word2vec/word2vec.c
// Function: join(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>>>>&, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void join(std::vector<std::string> &v, char c, std::string &s) {
  s.clear();
  for (std::vector<std::string>::const_iterator it = v.begin();
          it != v.end();
          it++) {
      s += *it;
      if (it != v.end() - 1) {
        s += c;
      }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
andq $0x0, 0x8(%rdx)
movq (%rdx), %rax
movb $0x0, (%rax)
movq (%rdi), %r15
movsbl %sil, %ebp
cmpq 0x8(%r14), %r15
je 0x44ff
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2490
movq 0x8(%r14), %rax
addq $-0x20, %rax
cmpq %rax, %r15
je 0x44f9
movq %rbx, %rdi
movl %ebp, %esi
callq 0x21b0
addq $0x20, %r15
jmp 0x44d1
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
movl $0x107, %edi            # imm = 0x107
callq 0x52e6
movq %rax, %r14
leaq 0x50ad(%rip), %rdi      # 0x63ab
callq 0x51ff
movq %rax, %r15
xorl %edi, %edi
xorl %esi, %esi
callq 0x4ff2
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4f5b
movq %rax, %r14
movq %rax, %rdi
callq 0x1b77
orl $-0x1, 0x8(%r15)
movq 0x28(%r14), %rdi
movq %rax, %rsi
callq 0x1e27
movl $0x109, %edi            # imm = 0x109
callq 0x52e6
movq %rax, %r15
leaq 0x5093(%rip), %rdi      # 0x63e2
callq 0x51ff
movq %rax, %r14
movl $0x107, %edi            # imm = 0x107
callq 0x52e6
movq %rax, %r12
leaq 0x5ebb(%rip), %rdi      # 0x7226
callq 0x51ff
movq %r12, %rdi
movq %rax, %rsi
callq 0x4f9c
movq %rax, %r12
xorl %edi, %edi
xorl %esi, %esi
callq 0x4ff2
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x4f5b
movq %rax, %r15
movq %rax, %rdi
callq 0x1b77
orl $-0x1, 0x8(%r14)
movq 0x28(%r15), %rdi
movq %rax, %rsi
callq 0x1e27
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1473
leaq 0x9e3b(%rip), %rax      # 0xb200
movq (%rax), %rdi
callq 0x4997
movq %rbx, %rdi
callq 0x15f1
testq %rbx, %rbx
je 0x1417
movq %rbx, %r14
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x13da
cmpl $0x3, 0xc(%r14)
jne 0x1404
movq 0x28(%r14), %rax
movq 0x20(%rax), %rdi
leaq 0x511c(%rip), %rsi      # 0x6517
callq 0x1110
testl %eax, %eax
je 0x1436
leaq 0x50ec(%rip), %rsi      # 0x64f7
leaq 0x510a(%rip), %rdx      # 0x651c
movq %r14, %rdi
jmp 0x1427
leaq 0x50d9(%rip), %rsi      # 0x64f7
leaq 0x50d7(%rip), %rdx      # 0x64fc
xorl %edi, %edi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1ab5
movq 0x20(%r14), %rax
cmpl $0x109, 0x20(%rax)      # imm = 0x109
jne 0x145a
cmpq $0x0, 0x30(%r14)
je 0x146a
leaq 0x50a6(%rip), %rsi      # 0x64f7
leaq 0x5120(%rip), %rdx      # 0x6578
jmp 0x1412
leaq 0x4c47(%rip), %rsi      # 0x60a8
leaq 0x50f0(%rip), %rdx      # 0x6558
jmp 0x1412
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x490d
movq 0x20(%rbx), %rcx
testq %rax, %rax
je 0x1e74
cmpl $0x0, -0x14(%rbp)
je 0x1e74
leaq 0x465c(%rip), %rsi      # 0x64b7
leaq 0x4661(%rip), %rdx      # 0x64c3
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1ab5
pushq $0x1
popq %rax
jmp 0x1e8d
movl 0x8(%rbx), %esi
movq %rcx, %rdi
movq %r14, %rdx
callq 0x464a
movl (%r14), %eax
movq %r14, 0x18(%rbx)
pushq $0x1
popq %r14
movl %eax, 0x10(%rbx)
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6c66(%rip), %rax      # 0xb210
testq %rax, %rax
jle 0x4646
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x6c58(%rip), %rcx      # 0xb220
movslq (%rcx,%rax,4), %r14
leaq 0x6ddd(%rip), %r15      # 0xb3b0
leaq 0x1a656(%rip), %r12     # 0x1ec30
movslq 0x6c33(%rip), %rax      # 0xb214
cmpq %rax, %r14
jge 0x4615
movslq (%r15,%r14,4), %r13
movq (%r12,%r13,8), %rdi
testq %rdi, %rdi
je 0x460c
movl 0x20(%rdi), %eax
cmpl 0x6c14(%rip), %eax      # 0xb210
jl 0x460c
movq 0x28(%rdi), %rbx
callq 0x1030
movq %rbx, %rdi
jmp 0x45ee
movq %rdi, (%r12,%r13,8)
incq %r14
jmp 0x45da
movslq 0x6bf4(%rip), %rax      # 0xb210
leal -0x1(%rax), %ecx
movl %ecx, 0x6beb(%rip)      # 0xb210
leaq 0x6bf4(%rip), %rcx      # 0xb220
movl (%rcx,%rax,4), %eax
movl %eax, 0x6bdf(%rip)      # 0xb214
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/taeguk[P]Compiler-Proj-Cminus/src/symtab.c
// Function: st_register
void st_register(char * name, int lineno, SymbolInfo * symbolInfo)
{
  assert(name != NULL);
  assert(symbolInfo != NULL);

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

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

  assert(l == NULL || l->scope_level < cur_scope_level);

  MALLOC(l, sizeof(struct BucketListRec));
  l->name = name;
  MALLOC(l->lines, sizeof(struct LineListRec));
  l->lines->lineno = lineno;
  l->symbolInfo = symbolInfo;
  l->lines->next = NULL;
  l->next = hashTable[h];
  l->scope_level = cur_scope_level;
  valid_hash_arr[valid_hash_arr_cnt++] = h;
  hashTable[h] = l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x474d
movl %esi, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
testq %rdx, %rdx
je 0x4769
movq %rdi, %r12
callq 0x47f1
movl %eax, %r15d
cltq
leaq 0x1a5a8(%rip), %rcx     # 0x1ec30
leaq (%rcx,%rax,8), %r14
movl 0x6b7e(%rip), %ebx      # 0xb210
movq %r14, %r13
movq (%r13), %r13
testq %r13, %r13
je 0x46d7
cmpl %ebx, 0x20(%r13)
jne 0x46d5
movq (%r13), %rsi
movq %r12, %rdi
callq 0x1110
addq $0x28, %r13
testl %eax, %eax
jne 0x4695
leaq 0x3263(%rip), %rdi      # 0x7922
leaq 0x3214(%rip), %rsi      # 0x78da
leaq 0x3216(%rip), %rcx      # 0x78e3
pushq $0x64
popq %rdx
callq 0x10e0
jge 0x46b8
pushq $0x30
popq %rdi
callq 0x1160
testq %rax, %rax
je 0x4785
movq %rax, %r13
movq %r12, (%rax)
pushq $0x10
popq %rdi
callq 0x1160
movq %rax, 0x8(%r13)
testq %rax, %rax
je 0x47a8
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x18(%r13)
andq $0x0, 0x8(%rax)
movq (%r14), %rax
movq %rax, 0x28(%r13)
movl %ebx, 0x20(%r13)
movslq 0x6aed(%rip), %rax      # 0xb214
leal 0x1(%rax), %ecx
movl %ecx, 0x6ae4(%rip)      # 0xb214
leaq 0x6c79(%rip), %rcx      # 0xb3b0
movl %r15d, (%rcx,%rax,4)
movq %r13, (%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3179(%rip), %rdi      # 0x78cd
leaq 0x317f(%rip), %rsi      # 0x78da
leaq 0x3181(%rip), %rcx      # 0x78e3
pushq $0x5a
jmp 0x46cf
leaq 0x319f(%rip), %rdi      # 0x790f
leaq 0x3163(%rip), %rsi      # 0x78da
leaq 0x3165(%rip), %rcx      # 0x78e3
pushq $0x5b
jmp 0x46cf
leaq 0x6a74(%rip), %rax      # 0xb200
movq (%rax), %rdi
leaq 0x1c1b(%rip), %rsi      # 0x63b1
leaq 0x313d(%rip), %rbx      # 0x78da
leaq 0x31ac(%rip), %r8       # 0x7950
pushq $0x66
jmp 0x47c9
leaq 0x6a51(%rip), %rax      # 0xb200
movq (%rax), %rdi
leaq 0x1bf8(%rip), %rsi      # 0x63b1
leaq 0x311a(%rip), %rbx      # 0x78da
leaq 0x3189(%rip), %r8       # 0x7950
pushq $0x68
popq %r14
movq %rbx, %rdx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1120
leaq 0x1c01(%rip), %rdi      # 0x63e0
leaq 0x30fd(%rip), %rcx      # 0x78e3
movq %rbx, %rsi
movl %r14d, %edx
callq 0x10e0
// File: /workspace/github_c_makefile_star2_O2/taeguk[P]Compiler-Proj-Cminus/src/symtab.c
// Function: hash
static int hash ( char * key )
{ int temp = 0;
  int i = 0;
  while (key[i] != '\0')
  { temp = ((temp << SHIFT) + key[i]) % SIZE;
    ++i;
  }
  return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl $0xd3, %ecx
movsbl (%rdi), %edx
testl %edx, %edx
je 0x4812
shll $0x4, %eax
addl %edx, %eax
cltd
idivl %ecx
incq %rdi
movl %edx, %eax
jmp 0x47fc
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x48ab
movl %esi, %ebx
movq %rdi, %r14
callq 0x47f1
cltq
leaq 0x1a3f6(%rip), %rcx     # 0x1ec30
leaq (%rcx,%rax,8), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x488e
movq (%r15), %rsi
movq %r14, %rdi
callq 0x1110
testl %eax, %eax
je 0x485b
addq $0x28, %r15
jmp 0x483e
movq 0x8(%r15), %rax
movq %rax, %r14
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x485f
pushq $0x10
popq %rdi
callq 0x1160
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x48c4
movl %ebx, (%rax)
andq $0x0, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x30e2(%rip), %rdi      # 0x7977
leaq 0x303e(%rip), %rsi      # 0x78da
leaq 0x30b9(%rip), %rcx      # 0x795c
pushq $0x7c
popq %rdx
callq 0x10e0
leaq 0x301b(%rip), %rdi      # 0x78cd
leaq 0x3021(%rip), %rsi      # 0x78da
leaq 0x309c(%rip), %rcx      # 0x795c
pushq $0x74
jmp 0x48a5
leaq 0x6935(%rip), %rax      # 0xb200
movq (%rax), %rdi
leaq 0x1adc(%rip), %rsi      # 0x63b1
leaq 0x2ffe(%rip), %rbx      # 0x78da
leaq 0x309e(%rip), %r8       # 0x7981
movq %rbx, %rdx
movl $0x81, %ecx
xorl %eax, %eax
callq 0x1120
leaq 0x1ae7(%rip), %rdi      # 0x63e0
leaq 0x305c(%rip), %rcx      # 0x795c
movq %rbx, %rsi
movl $0x81, %edx
callq 0x10e0
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x47f1
cltq
leaq 0x1a304(%rip), %rcx     # 0x1ec30
leaq (%rcx,%rax,8), %r12
xorl %r15d, %r15d
movq (%r12), %r12
testq %r12, %r12
je 0x4969
movq (%r12), %rsi
movq %r14, %rdi
callq 0x1110
testl %eax, %eax
je 0x4952
addq $0x28, %r12
jmp 0x4933
movl 0x68b8(%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_O2/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 0x4e9f
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq %rdi, %rdx
movq %rdx, %rcx
movq (%rdx), %rdx
testq %rdx, %rdx
jne 0x4e8f
movq %rsi, (%rcx)
popq %rbp
retq
movq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x40
popq %rsi
callq 0x1100
movq %rax, %rbx
testq %rax, %rax
je 0x4eca
leaq 0x6325(%rip), %rax      # 0xb1e8
movl (%rax), %eax
movl %eax, 0x8(%rbx)
jmp 0x4eeb
leaq 0x632f(%rip), %rax      # 0xb200
movq (%rax), %rdi
leaq 0x630d(%rip), %rax      # 0xb1e8
movl (%rax), %edx
leaq 0x2d87(%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_O2/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 0x4ea3
testq %rax, %rax
je 0x4f1b
movl $0x1, 0xc(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newArrayDeclarationNode
TreeNode*
newArrayDeclarationNode(TreeNode *type_specifier,
                        TreeNode *_var,
                        TreeNode *_num)
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = ArrayDeclarationK;
      t->attr.arrDecl.type_spec = type_specifier;
      t->attr.arrDecl._var = _var;
      t->attr.arrDecl._num = _num;

    }

  return t;
}

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

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x4ea3
testq %rax, %rax
je 0x4f93
movl $0x3, 0xc(%rax)
movq %r12, 0x20(%rax)
movq %r15, 0x28(%rax)
movq %r14, 0x30(%rax)
movq %rbx, 0x38(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newVariableParameterNode
TreeNode*
newVariableParameterNode(TreeNode *type_specifier,
                         TreeNode *_var)
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = VariableParameterK;
      t->attr.varParam.type_spec = type_specifier;
      t->attr.varParam._var = _var;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4ea3
testq %rax, %rax
je 0x4fc2
movl $0x4, 0xc(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newArrayParameterNode
TreeNode*
newArrayParameterNode(TreeNode *type_specifier,
                      TreeNode *_var)
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = ArrayParameterK;
      t->attr.arrParam.type_spec = type_specifier;
      t->attr.arrParam._var = _var;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4ea3
testq %rax, %rax
je 0x4fed
movl $0x5, 0xc(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newCompoundStatementNode
TreeNode*
newCompoundStatementNode(TreeNode *local_declarations, // nullable
                         TreeNode *statement_list) // nullable
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = CompoundStatementK;
      t->attr.cmpdStmt.local_decl = local_declarations;
      t->attr.cmpdStmt.stmt_list = statement_list;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4ea3
testq %rax, %rax
je 0x5018
movl $0x6, 0xc(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newExpressionStatementNode
TreeNode*
newExpressionStatementNode(TreeNode *expression) // nullable
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = ExpressionStatementK;
      t->attr.exprStmt.expr = expression;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4ea3
testq %rax, %rax
je 0x503b
movl $0x7, 0xc(%rax)
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newSelectionStatementNode
TreeNode*
newSelectionStatementNode(TreeNode *expression, // nullable
                          TreeNode *if_statement,
                          TreeNode *else_statement) // nullable
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = SelectionStatementK;
      t->attr.selectStmt.expr = expression;
      t->attr.selectStmt.if_stmt = if_statement;
      t->attr.selectStmt.else_stmt = else_statement;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x4ea3
testq %rax, %rax
je 0x5072
movl $0x8, 0xc(%rax)
movq %r15, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newIterationStatementNode
TreeNode*
newIterationStatementNode(TreeNode *expression,
                          TreeNode *statement) // nullable
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = IterationStatementK;
      t->attr.iterStmt.expr = expression;
      t->attr.iterStmt.loop_stmt = statement;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4ea3
testq %rax, %rax
je 0x50a3
movl $0x9, 0xc(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newReturnStatementNode
TreeNode*
newReturnStatementNode(TreeNode *expression) // nullable
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = ReturnStatementK;
      t->attr.retStmt.expr = expression;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4ea3
testq %rax, %rax
je 0x50c6
movl $0xa, 0xc(%rax)
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newAssignExpressionNode
TreeNode*
newAssignExpressionNode(TreeNode *var,
                        TreeNode *expression)
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = AssignExpressionK;
      t->attr.assignStmt._var = var;
      t->attr.assignStmt.expr = expression;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4ea3
testq %rax, %rax
je 0x50f3
movl $0xb, 0xc(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r14
popq %rbp
retq