LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/brianquinlan[P]brainfuck-jit/bf_compile_and_go.cpp
// Function: BrainfuckCompileAndGo::emit_offset_table(std::map<signed char, unsigned char, std::less<signed char>, std::allocator<std::pair<signed char const, unsigned char>>>*, signed char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void BrainfuckCompileAndGo::emit_offset_table(
    map<int8_t, uint8_t>* offset_to_change, int8_t* offset, string *code) {
  for (auto it = offset_to_change->begin();
       it != offset_to_change->end();
       ++it) {
    int8_t change_offset = it->first;
    uint8_t change_value = it->second;

    if (change_value == 0) {
      continue;
    }

    *code += "\x80\x43";                                  // addb [rbx+XX],YY
    *code += string(reinterpret_cast<char *>(&change_offset), 1);  // XX
    *code += string(reinterpret_cast<char *>(&change_value), 1);   // YY
  }

  if (*offset != 0) {
    *code += "\x48\x83\xc3";                                // add rbx ...
    *code += string(reinterpret_cast<char *>(offset), 1);   // ... offset
    *offset = 0;
  }
  offset_to_change->clear();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r15
movq %rdx, 0x30(%rsp)
movq 0x18(%rsi), %r13
movq %rsi, 0x28(%rsp)
leaq 0x8(%rsi), %r14
cmpq %r14, %r13
je 0x37e7
leaq 0x18(%rsp), %r12
movb 0x21(%r13), %bl
testb %bl, %bl
je 0x37d3
movb 0x20(%r13), %bpl
movq %r15, %rdi
leaq 0x2b74(%rip), %rsi      # 0x62d5
callq 0x22e0
movq %r12, 0x8(%rsp)
movb %bpl, 0x18(%rsp)
movq $0x1, 0x10(%rsp)
movb $0x0, 0x19(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x20a0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x379d
callq 0x2180
movq %r12, 0x8(%rsp)
movb %bl, 0x18(%rsp)
movq $0x1, 0x10(%rsp)
movb $0x0, 0x19(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x20a0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x37d3
callq 0x2180
movq %r13, %rdi
callq 0x2130
movq %rax, %r13
cmpq %r14, %rax
jne 0x3747
movq 0x30(%rsp), %rbx
cmpb $0x0, (%rbx)
je 0x3841
leaq 0x2ae0(%rip), %rsi      # 0x62d8
movq %r15, %rdi
callq 0x22e0
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movb (%rbx), %al
movb %al, (%r12)
movq $0x1, -0x8(%r12)
movb $0x0, 0x1(%r12)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x20a0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x383e
callq 0x2180
movb $0x0, (%rbx)
movq 0x28(%rsp), %rdi
callq 0x3b8c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x385e
jmp 0x385e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3870
callq 0x2180
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/Shenggan[P]SnowFlake/test/test_SnowFlake.cc
// Function: test(void*)
void *test(void *arg) {
    SnowFlake* sf;
    sf = (SnowFlake*)arg;
    for (int i = 0; i < (1<<12); i++) {
        LLOG(INFO) << sf->nextId();
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movl $0x1000, %r13d          # imm = 0x1000
leaq 0x20(%rsp), %r12
movq %rsp, %r14
leaq 0x48(%rsp), %r15
callq 0x2862
cmpl $0x0, (%rax)
jg 0x2557
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %r12, %rdi
leaq 0x1baf(%rip), %rsi      # 0x4004
leaq 0x1bbe(%rip), %rdx      # 0x401a
callq 0x3bce
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
leaq 0x1ba7(%rip), %rsi      # 0x401b
leaq 0x1ba4(%rip), %rdx      # 0x401f
callq 0x3bce
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movl $0x8, %r8d
callq 0x2938
movq %rbx, %rdi
callq 0x2d06
movq %rax, 0x40(%rsp)
movq %r15, %rdi
leaq 0x40(%rsp), %rsi
callq 0x2c2e
movq %rax, %rbp
callq 0x2862
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2f08
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x24e8
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x2504
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x2520
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2180
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x253b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x2557
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
decl %r13d
jne 0x2433
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x25a6
movq %rax, %rbx
jmp 0x258b
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3118
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x25a6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x25c2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/Shenggan[P]SnowFlake/test/test_SnowFlake.cc
// Function: main
int main() {
    LLOG_FILE(); 
    SnowFlake sf(2, 3);
    pthread_t tid;
    pthread_create(&tid, NULL, test, &sf);
    for (int i = 0; i < (1<<12); i++) {
        LLOG(INFO) << sf.nextId();
    }
    pthread_join(tid, NULL);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
callq 0x2862
movq %rax, %rbx
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1a2d(%rip), %rsi      # 0x4020
leaq 0x1a30(%rip), %rdx      # 0x402a
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0x3bce
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3166
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x2629
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x2180
xorps %xmm0, %xmm0
leaq 0xd0(%rsp), %rcx
movups %xmm0, 0x30(%rcx)
movups %xmm0, 0x20(%rcx)
movq $0x0, 0x40(%rcx)
movq $0x2, (%rcx)
movq $0x3, 0x8(%rcx)
movups %xmm0, 0x10(%rcx)
leaq -0x252(%rip), %rdx      # 0x240c
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x22a0
leaq 0x40(%rsp), %rbx
movl $0x1000, %r13d          # imm = 0x1000
movq %rsp, %r12
leaq 0x30(%rsp), %r14
leaq 0x70(%rsp), %r15
callq 0x2862
cmpl $0x0, (%rax)
jg 0x27b0
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %r12, %rdi
leaq 0x1961(%rip), %rsi      # 0x4004
leaq 0x1970(%rip), %rdx      # 0x401a
callq 0x3bce
movq %rbx, 0x30(%rsp)
movq %r14, %rdi
leaq 0x196d(%rip), %rsi      # 0x402b
leaq 0x196a(%rip), %rdx      # 0x402f
callq 0x3bce
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movl $0x13, %r8d
callq 0x2938
leaq 0xd0(%rsp), %rdi
callq 0x2d06
movq %rax, 0x20(%rsp)
movq %r15, %rdi
leaq 0x20(%rsp), %rsi
callq 0x2c2e
movq %rax, %rbp
callq 0x2862
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2f08
movq 0xb0(%rsp), %rdi
leaq 0xc0(%rsp), %rax
cmpq %rax, %rdi
je 0x2737
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x90(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x275c
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x277e
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x30(%rsp), %rdi
cmpq %rbx, %rdi
je 0x2795
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2180
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x27b0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
decl %r13d
jne 0x2682
movq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x2150
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x283b
movq 0x60(%rsp), %rsi
jmp 0x2833
movq %rax, %r14
jmp 0x2820
movq %rax, %r14
jmp 0x283b
movq %rax, %r14
jmp 0x2809
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x3118
movq 0x30(%rsp), %rdi
cmpq %rbx, %rdi
je 0x2820
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2180
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x283b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/Shenggan[P]SnowFlake/test/../utils/lightlog.h
// Function: llog::Message& llog::Message::operator<<<char [48]>(char const (&) [48])
Message& operator<<(const T & t) {
        std::stringstream ss;
        ss << t;
        msg += ss.str();
        return *this;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20c0
leaq 0x38(%rsp), %r15
movq %r14, %rdi
callq 0x2080
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x21b0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2240
leaq 0x40(%rbx), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x2050
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3dda
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x21d7(%rip), %rsi      # 0x5fb8
leaq 0x28(%rsp), %rdi
callq 0x20e0
leaq 0xa8(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3e2d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x3e2d
jmp 0x3e2a
movq %rax, %rbx
movq 0x2184(%rip), %rsi      # 0x5fb8
leaq 0x28(%rsp), %rdi
callq 0x20e0
leaq 0xa8(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/Shenggan[P]SnowFlake/test/../SnowFlake.h
// Function: SnowFlake::nextId()
uint64_t nextId() {
        std::unique_lock<std::mutex> lock(mutex_);
        uint64_t currStmp = getNewstmp();
        if (currStmp < lastStmp) {
            LLOG(ERRO) << "Clock moved backwards.  Refusing to generate id";
            exit(0);
        }

        if (currStmp == lastStmp) {
            sequence = (sequence + 1) & max_sequence_num_;
            if (sequence == 0) {
                currStmp = getNextMill();
            }
        } else {
            sequence = 0;
        }
        lastStmp = currStmp;
        return (currStmp - start_stmp_) << timestmp_left
                | datacenterId << datacenter_left
                | machineId << machine_left
                | sequence;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %rax
leaq 0x40(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x3ee4
movb $0x1, 0x8(%r14)
leaq 0x50(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x2250
movq 0x8(%r14), %rax
shrq $0x3, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
mulq %rcx
imulq $0x3e8, (%r14), %rax    # imm = 0x3E8
shrq $0x4, %rdx
addq %rdx, %rax
cmpq 0x18(%rbx), %rax
jb 0x2ddd
jne 0x2d8c
movl 0x10(%rbx), %ecx
incl %ecx
andl $0xfff, %ecx            # imm = 0xFFF
movq %rcx, 0x10(%rbx)
jne 0x2d96
movq %rbx, %rdi
callq 0x3e54
movq 0x10(%rbx), %rcx
jmp 0x2d96
movq $0x0, 0x10(%rbx)
xorl %ecx, %ecx
movq %rax, 0x18(%rbx)
shlq $0x16, %rax
movabsq $-0x562832f817c00000, %rdx # imm = 0xA9D7CD07E8400000
addq %rax, %rdx
movq (%rbx), %rax
movq 0x8(%rbx), %rbx
shlq $0x11, %rax
shlq $0xc, %rbx
orq %rax, %rbx
orq %rcx, %rbx
orq %rdx, %rbx
leaq 0x40(%rsp), %rdi
callq 0x3ece
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x2862
cmpl $0x2, (%rax)
jg 0x2ea3
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x12a8(%rip), %rsi      # 0x40a3
leaq 0x12b4(%rip), %rdx      # 0x40b6
leaq 0x20(%rsp), %rdi
callq 0x3bce
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x129b(%rip), %rsi      # 0x40b7
leaq 0x129a(%rip), %rdx      # 0x40bd
movq %rsp, %rdi
callq 0x3bce
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
movl $0x2, %esi
movl $0x43, %r8d
callq 0x2938
leaq 0x126f(%rip), %rsi      # 0x40be
leaq 0x50(%rsp), %rdi
callq 0x3d66
movq %rax, %rbx
callq 0x2862
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2f08
leaq 0x50(%rsp), %rdi
callq 0x3118
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2e8c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x2ea3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
xorl %edi, %edi
callq 0x21d0
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3118
jmp 0x2ebc
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2ed7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x2ed7
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x2ef5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x2ef5
jmp 0x2ef2
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x3ece
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/Shenggan[P]SnowFlake/test/../utils/lightlog.h
// Function: llog::Logger::operator+=(llog::Message const&)
void operator+=(const Message& m)
    {
        mtx_.lock();
        if (console_)
            std::cout << m.get_string() + '\n';
        if (file_)
            log_file << m.get_string(false) + '\n';
        mtx_.unlock();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3272(%rip), %rdi      # 0x6190
callq 0x2210
testl %eax, %eax
jne 0x30c0
cmpb $0x1, 0x4(%rbx)
jne 0x2fee
leaq 0x20(%r14), %rsi
leaq 0x40(%r14), %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x3f47
movq 0x8(%r15), %rsi
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
movl $0xa, %r8d
callq 0x22b0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2f89
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x2f90
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x3020(%rip), %rdi      # 0x5fd8
callq 0x21b0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2fd3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2fee
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
cmpb $0x1, 0x5(%rbx)
jne 0x30aa
leaq 0x40(%r14), %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3f47
movq 0x8(%r15), %rsi
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
movl $0xa, %r8d
callq 0x22b0
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x304b
movq %rsi, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x3055
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq %r14, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x21b0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x308f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30aa
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x30df(%rip), %rdi      # 0x6190
callq 0x2100
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x20a0
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
jne 0x30e3
jmp 0x30f5
jmp 0x30f2
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x30f5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x30f5
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3110
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/Shenggan[P]SnowFlake/test/../utils/lightlog.h
// Function: llog::Logger::init_log_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void init_log_file(std::string log_file_name = "output.log") {
        if (file_ == true)
            log_file.close();
        log_file.open(log_file_name);
        file_ = true;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x5(%rdi)
jne 0x317f
leaq 0x8(%rbx), %rdi
callq 0x2200
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0x2090
movb $0x1, 0x5(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/Shenggan[P]SnowFlake/test/../utils/lightlog.h
// Function: llog::Logger::Logger()
Logger() {
        if (getenv("LLOG_LV") == NULL)
            m_level_ = LOG_LEVEL_INFO;
        else{
            std::string ev_level = getenv("LLOG_LV");
            if (ev_level == "WARN")
                m_level_ = LOG_LEVEL_WARNING;
            else if (ev_level == "ERRO")
                m_level_ = LOG_LEVEL_ERROR;
            else
                m_level_ = LOG_LEVEL_INFO;
        }
        console_ = true;
        file_ = false;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x2260
leaq 0xe77(%rip), %rdi       # 0x4030
callq 0x21e0
testq %rax, %rax
je 0x3206
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x28fa
leaq 0xe5c(%rip), %rsi       # 0x4038
leaq 0x8(%rsp), %rdi
callq 0x2040
testl %eax, %eax
je 0x320e
leaq 0xe4c(%rip), %rsi       # 0x403d
leaq 0x8(%rsp), %rdi
callq 0x2040
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
addl %ecx, %ecx
jmp 0x3213
movl $0x0, (%rbx)
jmp 0x3230
movl $0x1, %ecx
movl %ecx, (%rbx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3230
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movw $0x1, 0x4(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x2220
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/Shenggan[P]SnowFlake/test/../utils/lightlog.h
// Function: llog::Message::colorStr(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
std::string colorStr(int color, int bold, const std::string & delimiter, const std::string & t, bool if_color = true) {
        std::stringstream ss;
        if (if_color)
            ss << "\033[" << bold << ";" << color << "m";
        ss << t;
        if (if_color)
            ss << "\033[0m";
        ss << delimiter;
		return ss.str();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %r9, %r15
movq %r8, %r14
movl %ecx, %r12d
movl %edx, %ebp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x20c0
cmpb $0x0, 0x1c0(%rsp)
je 0x3b28
leaq 0x10(%rsp), %r13
leaq 0x594(%rip), %rsi       # 0x406f
movl $0x2, %edx
movq %r13, %rdi
callq 0x21b0
movq %r13, %rdi
movl %r12d, %esi
callq 0x2270
movq %rax, %r12
leaq 0x575(%rip), %rsi       # 0x4072
movl $0x1, %edx
movq %rax, %rdi
callq 0x21b0
movq %r12, %rdi
movl %ebp, %esi
callq 0x2270
leaq 0x55c(%rip), %rsi       # 0x4077
movl $0x1, %edx
movq %rax, %rdi
callq 0x21b0
leaq 0x10(%rsp), %r12
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x21b0
cmpb $0x0, 0x1c0(%rsp)
je 0x3b5a
leaq 0x527(%rip), %rsi       # 0x4074
movl $0x4, %edx
movq %r12, %rdi
callq 0x21b0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0x21b0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x2240
movq 0x243b(%rip), %rsi      # 0x5fb8
movq %rsp, %rdi
callq 0x20e0
leaq 0x80(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x2407(%rip), %rsi      # 0x5fb8
movq %rsp, %rdi
callq 0x20e0
leaq 0x80(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/Shenggan[P]SnowFlake/test/../SnowFlake.h
// Function: SnowFlake::getNextMill()
uint64_t getNextMill() {
        uint64_t mill = getNewstmp();
        while (mill <= lastStmp) {
            mill = getNewstmp();
        }
        return mill;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x2250
movq 0x8(%r14), %rax
shrq $0x3, %rax
movabsq $0x20c49ba5e353f7cf, %r15 # imm = 0x20C49BA5E353F7CF
mulq %r15
imulq $0x3e8, (%r14), %rax    # imm = 0x3E8
shrq $0x4, %rdx
addq %rdx, %rax
cmpq 0x18(%rbx), %rax
ja 0x3ec4
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x2250
movq 0x8(%rsp), %rax
shrq $0x3, %rax
mulq %r15
imulq $0x3e8, (%rsp), %rax    # imm = 0x3E8
shrq $0x4, %rdx
addq %rdx, %rax
cmpq 0x18(%rbx), %rax
jbe 0x3e99
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/YerevaNN[P]pmi/pmi.cpp
// Function: model::clear()
void model::clear() {
    locked = false;
    dictionary.clear();
    words.clear();
    unlockedCount.clear();
    lockedCount.clear();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb $0x0, (%rdi)
addq $0x8, %rdi
callq 0x2ec6
leaq 0x40(%rbx), %rdi
movq 0x40(%rbx), %rsi
callq 0x328e
leaq 0x58(%rbx), %rdi
callq 0x2e56
movq 0x90(%rbx), %rax
cmpq %rax, 0x98(%rbx)
je 0x30bb
movq %rax, 0x98(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/YerevaNN[P]pmi/pmi.cpp
// Function: model::count(unsigned long, unsigned long) const
occurences model::count(ngram x, ngram y) const {
    if(x > y) {
        std::swap(x, y);
    }
    if(locked) {
        auto key = std::make_pair((pair(x) << (3 * 21)) | pair(y), occurences(0));
        auto I = std::lower_bound(lockedCount.begin(), lockedCount.end(), key);
        if(I == lockedCount.end() ||
           I->first != key.first) {
            report("%d %d %llx %llx %llx %llx\n", I == lockedCount.end() , I->first != key.first,
                   uint64(I->first >> 64),
                   uint64((I->first << 64) >> 64),
                   uint64(key.first >> 64),
                   uint64((key.first << 64) >> 64)
                   );
            return 0;
        }
        return I->second;
    } else {
        return unlockedCount.at((pair(x) << (3 * 21)) | pair(y));
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq %rdx, %rsi
movq %rdx, %rax
cmovaq %rsi, %rax
cmovbq %rsi, %rdx
cmpb $0x1, (%rdi)
jne 0x3144
movq %rdx, %rcx
shrq %rcx
shlq $0x3f, %rdx
orq %rax, %rdx
movq %rsp, %r14
movq %rcx, 0x8(%r14)
movq %rdx, (%r14)
movl $0x0, 0x10(%r14)
movq 0x90(%rbx), %rdi
movq 0x98(%rbx), %rsi
movq %r14, %rdx
callq 0x32e0
movq 0x98(%rbx), %r9
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq (%r14), %rcx
movq 0x8(%r14), %r8
cmpq %r9, %rax
je 0x3177
movq %rsi, %rdi
xorq %rcx, %rdi
movq %rdx, %r10
xorq %r8, %r10
orq %rdi, %r10
jne 0x3177
movl 0x10(%rax), %eax
jmp 0x316f
addq $0x58, %rbx
movq %rdx, %rcx
shrq %rcx
shlq $0x3f, %rdx
orq %rax, %rdx
movq %rsp, %rsi
movq %rcx, 0x8(%rsi)
movq %rdx, (%rsi)
movq %rbx, %rdi
callq 0x334a
testq %rax, %rax
je 0x3189
movl 0x20(%rax), %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
xorl %edi, %edi
cmpq %r9, %rax
sete %dil
callq 0x26ad
xorl %eax, %eax
jmp 0x316f
leaq 0x2f2f(%rip), %rdi      # 0x60bf
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/YerevaNN[P]pmi/train.cpp
// Function: model::push(unsigned long, unsigned long)
void model::push(ngram x, ngram y) {
    if(x > y) {
        std::swap(x, y);
    }
    ++unlockedCount[(pair(x) << (3 * 21)) | pair(y)];
    return;
}

// Assembly:
subq $0x18, %rsp
cmpq %rdx, %rsi
movq %rdx, %rax
cmovbq %rsi, %rax
cmovaq %rsi, %rdx
addq $0x58, %rdi
movq %rax, %rcx
shrq %rcx
shlq $0x3f, %rax
orq %rdx, %rax
movq %rsp, %rsi
movq %rcx, 0x8(%rsi)
movq %rax, (%rsi)
callq 0x4cb2
incl (%rax)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/YerevaNN[P]pmi/train.cpp
// Function: void model::processWindow<std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*>>(std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*> const&, std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*> const&)
void model::processWindow(const ForwardIterator& begin, const ForwardIterator& end) {
    auto ngrams = getNgrams(begin, end);
    for(auto i : ngrams) {
        for(auto j : ngrams) {
            push(i, j);
        }
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x4fcc
movq (%r15), %rbx
movq 0x8(%r15), %rax
movq %rax, 0x18(%rsp)
cmpq %rax, %rbx
je 0x4aa1
addq $0x58, %r14
leaq 0x20(%rsp), %r15
movq (%rsp), %r13
movq 0x8(%rsp), %rbp
cmpq %rbp, %r13
je 0x4a92
movq (%rbx), %r12
movq (%r13), %rax
cmpq %rax, %r12
movq %rax, %rcx
cmovaq %r12, %rax
cmovbq %r12, %rcx
movq %rcx, %rdx
shrq %rdx
shlq $0x3f, %rcx
orq %rax, %rcx
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4cb2
incl (%rax)
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x4a53
addq $0x8, %rbx
cmpq 0x18(%rsp), %rbx
jne 0x4a42
movq (%rsp), %rbx
testq %rbx, %rbx
je 0x4ab6
movq 0x10(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x2130
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4ade
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/YerevaNN[P]pmi/train.cpp
// Function: std::vector<unsigned long, std::allocator<unsigned long>> getUnigrams<std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*>>(std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*> const&, std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*> const&)
std::vector<ngram> getUnigrams(const T& begin, const T& end) {
    std::unordered_set<ngram> ngrams;
    for(auto I = begin; I != end; ++I) {
        ngrams.insert(hash(*I));
    }
    return std::vector<ngram> (ngrams.begin(), ngrams.end());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x50(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq (%rsi), %rbp
cmpq (%rdx), %rbp
je 0x525b
movq %rdx, %r14
movq %rbx, 0x10(%rsp)
movq 0x10(%rsi), %r12
movq 0x18(%rsi), %rbx
leaq 0x20(%rsp), %r15
leaq 0x8(%rsp), %r13
movq (%rbp), %rdi
movl $0x1fffff, %esi         # imm = 0x1FFFFF
movl $0x1fffff, %edx         # imm = 0x1FFFFF
callq 0x2fd4
movq %rax, 0x18(%rsp)
movq %r15, 0x8(%rsp)
movq %r15, %rdi
leaq 0x18(%rsp), %rsi
movq %r13, %rdx
callq 0x55a2
addq $0x8, %rbp
cmpq %r12, %rbp
jne 0x524a
movq 0x8(%rbx), %rbp
addq $0x8, %rbx
leaq 0x200(%rbp), %r12
cmpq (%r14), %rbp
jne 0x5205
movq 0x30(%rsp), %rsi
movq 0x10(%rsp), %rbx
jmp 0x525d
xorl %esi, %esi
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5560
leaq 0x20(%rsp), %rdi
callq 0x58c2
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x528a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x58c2
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/YerevaNN[P]pmi/train.cpp
// Function: std::vector<unsigned long, std::allocator<unsigned long>> getBigrams<std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*>>(std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*> const&, std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*> const&)
std::vector<ngram> getBigrams(const T& begin, const T& end) {
    std::unordered_set<ngram> ngrams;
    for(auto I = begin, J = std::next(I); J != end; ++I, ++J) {
        ngrams.insert(hash(*I, *J));
    }
    return std::vector<ngram> (ngrams.begin(), ngrams.end());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r13
movq %rdi, 0x10(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq (%rsi), %rbp
movq 0x10(%rsi), %r15
movq 0x18(%rsi), %rbx
leaq 0x8(%rbp), %r14
movq %rbx, (%rsp)
movq %r15, %r12
cmpq %r15, %r14
jne 0x5306
leaq 0x8(%rbx), %rax
movq %rax, (%rsp)
movq 0x8(%rbx), %r14
leaq 0x200(%r14), %r12
cmpq (%r13), %r14
je 0x5380
movq (%rbp), %rdi
movq (%r14), %rsi
movl $0x1fffff, %edx         # imm = 0x1FFFFF
callq 0x2fd4
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x55a2
addq $0x8, %rbp
cmpq %r15, %rbp
jne 0x5353
movq 0x8(%rbx), %rbp
addq $0x8, %rbx
leaq 0x200(%rbp), %r15
addq $0x8, %r14
cmpq %r12, %r14
jne 0x5373
movq (%rsp), %rax
movq 0x8(%rax), %r14
addq $0x8, %rax
movq %rax, (%rsp)
leaq 0x200(%r14), %r12
cmpq (%r13), %r14
jne 0x530c
movq 0x30(%rsp), %rsi
jmp 0x5382
xorl %esi, %esi
leaq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5560
leaq 0x20(%rsp), %rdi
callq 0x58c2
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x53b4
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x58c2
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/YerevaNN[P]pmi/train.cpp
// Function: std::vector<unsigned long, std::allocator<unsigned long>> getTrigrams<std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*>>(std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*> const&, std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*> const&)
std::vector<ngram> getTrigrams(const T& begin, const T& end) {
    std::unordered_set<ngram> ngrams;
    for(auto I = begin, J = std::next(I), K = std::next(J); K != end; ++I, ++J, ++K) {
        ngrams.insert(hash(*I, *J, *K));
    }
    return std::vector<ngram> (ngrams.begin(), ngrams.end());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, 0x20(%rsp)
movq %rdi, 0x30(%rsp)
leaq 0x70(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq (%rsi), %rbp
movq 0x10(%rsi), %rbx
movq 0x18(%rsi), %rax
leaq 0x8(%rbp), %r14
movq %rax, %rcx
movq %rbx, %r13
cmpq %rbx, %r14
jne 0x542d
leaq 0x8(%rax), %rcx
movq 0x8(%rax), %r14
leaq 0x200(%r14), %r13
movq %rax, 0x18(%rsp)
leaq 0x8(%r14), %r15
movq %rcx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r13, %r12
cmpq %r13, %r15
jne 0x5461
movq 0x10(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %r15
leaq 0x200(%r15), %r12
movq 0x20(%rsp), %rax
cmpq (%rax), %r15
je 0x5517
movq (%rbp), %rdi
movq (%r14), %rsi
movq (%r15), %rdx
callq 0x2fd4
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
leaq 0x38(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x55a2
addq $0x8, %rbp
cmpq %rbx, %rbp
jne 0x54be
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rbp
addq $0x8, %rax
movq %rax, 0x18(%rsp)
leaq 0x200(%rbp), %rbx
addq $0x8, %r14
cmpq %r13, %r14
jne 0x54e0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %r14
addq $0x8, %rax
movq %rax, 0x10(%rsp)
leaq 0x200(%r14), %r13
addq $0x8, %r15
cmpq %r12, %r15
jne 0x5502
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r15
addq $0x8, %rax
movq %rax, 0x8(%rsp)
leaq 0x200(%r15), %r12
movq 0x20(%rsp), %rax
cmpq (%rax), %r15
jne 0x546f
movq 0x50(%rsp), %rsi
jmp 0x5519
xorl %esi, %esi
leaq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5560
leaq 0x40(%rsp), %rdi
callq 0x58c2
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x554b
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x58c2
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/front-end_main.cpp
// Function: main
int main(const int argc, const char* argv[])
{
    FrontEndInfo info = {};
    info.input_file = argv[1];

    info.parser_dump_required = (strcmp(argv[parser_dump_flag_offset], "1") == 0);
    info.tree_dump_required   = (strcmp(argv[tree_dump_flag_offset],   "1") == 0);
    info.emit_tree_requiered  = (strcmp(argv[emit_tree_flag_offset],   "1") == 0);
    info.emit_code_requiered  = (strcmp(argv[emit_code_flag_offset],   "1") == 0);

    if (argc - 1 > emit_code_flag_offset)
    {
        info.output_file = argv[emit_code_flag_offset + 1];
    }


    if (info.emit_code_requiered)
    {
        const char* output = "translated_program.shl";
        if (info.output_file != nullptr)
        {
            output = info.output_file;
        }

        Translate(info.input_file, output);
        return 0;
    }

    Parser* parser = Parse(info.input_file);
    if (info.parser_dump_required)
    {
        ParserDump(parser);
    }

    Tree* tree = GetTree(parser);
    if (info.tree_dump_required)
    {
        TreeDump(tree);
    }

    if (info.emit_tree_requiered)
    {
        const char* output = "tree_in_written_form.txt";
        WriteToFile(tree, info.output_file);
    }
    else
    {
        WriteToFile(tree, tree_tmp_file);
    }

    DestructTree(tree);
    DeleteTree(tree);

    DestructParser(parser);
    DeleteParser(parser);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rsi), %rax
cmpb $0x31, (%rax)
jne 0x22dd
cmpb $0x0, 0x1(%rax)
sete %r15b
jmp 0x22e0
xorl %r15d, %r15d
movq 0x18(%rsi), %rax
cmpb $0x31, (%rax)
jne 0x22f3
cmpb $0x0, 0x1(%rax)
sete %r12b
jmp 0x22f6
xorl %r12d, %r12d
movq 0x20(%rsi), %rax
cmpb $0x31, (%rax)
jne 0x2309
cmpb $0x0, 0x1(%rax)
sete %r13b
jmp 0x230c
xorl %r13d, %r13d
movq 0x28(%rsi), %rax
cmpb $0x31, (%rax)
jne 0x231e
cmpb $0x0, 0x1(%rax)
sete %al
jmp 0x2320
xorl %eax, %eax
cmpl $0x7, %edi
jl 0x232b
movq 0x30(%rsi), %rbx
jmp 0x232d
xorl %ebx, %ebx
movq 0x8(%rsi), %rdi
testb %al, %al
je 0x234a
testq %rbx, %rbx
leaq 0x3cd8(%rip), %rsi      # 0x6017
cmovneq %rbx, %rsi
callq 0x4ac0
jmp 0x23ae
callq 0x30cc
movq %rax, %r14
testb %r15b, %r15b
je 0x235f
movq %r14, %rdi
callq 0x3208
movq %r14, %rdi
callq 0x3a35
movq %rax, %r15
testb %r12b, %r12b
je 0x2377
movq %r15, %rdi
callq 0x3739
testb %r13b, %r13b
jne 0x2383
movq 0x7d6d(%rip), %rbx      # 0xa0f0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x23c0
movq %r15, %rdi
callq 0x39aa
movq %r15, %rdi
callq 0x3a09
movq %r14, %rdi
callq 0x314f
movq %r14, %rdi
callq 0x31dc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/translator.cpp
// Function: Translate(char const*, char const*)
void Translate(const char* input, const char* output)
{
    assert(input);

    Tree* tree = GetTreeFromFile(input);
    TreeDump(tree);
    FILE* translate = fopen(output, "w");
    assert(translate);

    fprintf(translate, "~ THIS FILE WAS GENERATED AUTOMATICLY\n"
                       "~ TREE TAKED FROM FILE '%s'          \n"
                       "~ CHECK FILE BEFORE COMPILING      \n\n", input);

    TranslateTree(tree, translate);

    DestructTree(tree);
    DeleteTree(tree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4b35
movq %rsi, %r15
movq %rdi, %r14
callq 0x2576
movq %rax, %rbx
movq %rax, %rdi
callq 0x3739
leaq 0x158e(%rip), %rsi      # 0x607a
movq %r15, %rdi
callq 0x2100
testq %rax, %rax
je 0x4b54
movq %rax, %r15
leaq 0x2783(%rip), %rsi      # 0x7286
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2150
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4b73
movq %rbx, %rdi
callq 0x39aa
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3a09
leaq 0x1671(%rip), %rdi      # 0x61ad
leaq 0x26f1(%rip), %rsi      # 0x7234
leaq 0x2707(%rip), %rcx      # 0x7251
movl $0x18, %edx
callq 0x2090
leaq 0x2721(%rip), %rdi      # 0x727c
leaq 0x26d2(%rip), %rsi      # 0x7234
leaq 0x26e8(%rip), %rcx      # 0x7251
movl $0x1d, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/translator.cpp
// Function: TranslateTree(Tree*, _IO_FILE*)
void TranslateTree(Tree* tree, FILE* file)
{
    assert(tree);
    assert(file);

    Node* node = tree->root;

    while (node != nullptr)
    {
        TranslateFunc(node->right, file);
        node = node->left;
        fprintf(file, "\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x4bb3
movq %rsi, %rbx
testq %rsi, %rsi
je 0x4bd2
movq (%rdi), %r14
testq %r14, %r14
je 0x4bae
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x4bf1
movq 0x18(%r14), %r14
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2120
jmp 0x4b8a
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1474(%rip), %rdi      # 0x602e
leaq 0x2673(%rip), %rsi      # 0x7234
leaq 0x2730(%rip), %rcx      # 0x72f8
movl $0x2b, %edx
callq 0x2090
leaq 0x1c2a(%rip), %rdi      # 0x6803
leaq 0x2654(%rip), %rsi      # 0x7234
leaq 0x2711(%rip), %rcx      # 0x72f8
movl $0x2c, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/translator.cpp
// Function: TranslateFunc(Node*, _IO_FILE*)
void TranslateFunc(Node* node, FILE* file)
{
    assert(node);
    assert(file);

    fprintf(file, "%s %s(", OPERATORS[DECLARATOR].rus_name, node->value.name);
    TranslateArgs(node->right, file);
    fprintf(file, ")\n");
    TranslateCompound(node->left, file, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x4c5b
movq %rsi, %rbx
testq %rsi, %rsi
je 0x4c7a
movq %rdi, %r14
movq 0x8(%rdi), %rcx
leaq 0x272b(%rip), %rsi      # 0x733e
leaq 0x193f(%rip), %rdx      # 0x6559
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2150
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x4c99
leaq 0x270e(%rip), %rdi      # 0x7345
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x21b0
movq 0x18(%r14), %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x4d10
leaq 0x147a(%rip), %rdi      # 0x60dc
leaq 0x25cb(%rip), %rsi      # 0x7234
leaq 0x26ab(%rip), %rcx      # 0x731b
movl $0x3a, %edx
callq 0x2090
leaq 0x1b82(%rip), %rdi      # 0x6803
leaq 0x25ac(%rip), %rsi      # 0x7234
leaq 0x268c(%rip), %rcx      # 0x731b
movl $0x3b, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/translator.cpp
// Function: TranslateArgs(Node*, _IO_FILE*)
void TranslateArgs(Node* node, FILE* file)
{
    assert(file);

    if (node != nullptr)
    {
        fprintf(file, "%s", node->value.name);
        node = node->right;

        while (node != nullptr)
        {
            fprintf(file, ", %s", node->value.name);
            node = node->right;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x4cf1
movq %rdi, %r14
testq %rdi, %rdi
je 0x4ce6
movq %rsi, %rbx
movq 0x8(%r14), %rdi
callq 0x20f0
movq 0x20(%r14), %r15
testq %r15, %r15
je 0x4ce6
leaq 0x269f(%rip), %r14      # 0x736b
movq 0x8(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2150
movq 0x20(%r15), %r15
testq %r15, %r15
jne 0x4ccc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b0b(%rip), %rdi      # 0x6803
leaq 0x2535(%rip), %rsi      # 0x7234
leaq 0x2642(%rip), %rcx      # 0x7348
movl $0x45, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/translator.cpp
// Function: TranslateCompound(Node*, _IO_FILE*, unsigned long)
void TranslateCompound(Node* node, FILE* file, size_t num_tabs)
{
    assert(node);
    assert(file);

    if (node == nullptr)
    {
        return;
    }

    node = node->right;
    SetTabs(file, num_tabs);
    fprintf(file, "%s\n", OPERATORS[OPENING_BRACE].rus_name);

    while (node != nullptr)
    {
        TranslateStatement(node->left, file, num_tabs + 1);
        node = node->right;
    }

    SetTabs(file, num_tabs);
    fprintf(file, "%s\n", OPERATORS[CLOSING_BRACE].rus_name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x4dc3
movq %rsi, %rbx
testq %rsi, %rsi
je 0x4de2
movq %rdx, %r14
movq 0x20(%rdi), %r12
testq %rdx, %rdx
je 0x4d51
movq %r14, %r15
movl $0x9, %edi
movq %rbx, %rsi
callq 0x2120
decq %r15
jne 0x4d3f
leaq 0x2664(%rip), %rsi      # 0x73bc
leaq 0x1877(%rip), %rdx      # 0x65d6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2150
testq %r12, %r12
je 0x4d8c
leaq 0x1(%r14), %r15
movq 0x18(%r12), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4e4e
movq 0x20(%r12), %r12
testq %r12, %r12
jne 0x4d72
testq %r14, %r14
je 0x4da3
movl $0x9, %edi
movq %rbx, %rsi
callq 0x2120
decq %r14
jne 0x4d91
leaq 0x2612(%rip), %rsi      # 0x73bc
leaq 0x1834(%rip), %rdx      # 0x65e5
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2150
leaq 0x1312(%rip), %rdi      # 0x60dc
leaq 0x2463(%rip), %rsi      # 0x7234
leaq 0x25b5(%rip), %rcx      # 0x738d
movl $0x60, %edx
callq 0x2090
leaq 0x1a1a(%rip), %rdi      # 0x6803
leaq 0x2444(%rip), %rsi      # 0x7234
leaq 0x2596(%rip), %rcx      # 0x738d
movl $0x61, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/translator.cpp
// Function: TranslateExpression(Node*, _IO_FILE*)
void TranslateExpression(Node* node, FILE* file)
{
    assert(node);
    assert(file);

    switch (node->type)
    {
        case MATH_TYPE :
        {
            if (NeededBracket(node))
            {
                fprintf(file, "(");
            }
            
            TranslateExpression(node->left, file);
            fprintf(file, " %s ", STRING_MATH_OP[node->value.op]);
            TranslateExpression(node->right, file);

            if (NeededBracket(node)) 
            {
                fprintf(file, ")");
            }
            break;
        }
        case NUMB_TYPE :
        {   
            IntToDrevniyRus(file, node->value.number);   
            break;
        }
        case CALL_TYPE :
        {
            if (!TranslateStdCall(node, file))
            {
                fprintf(file, "%s(", node->left->value.name);
                TranslateParams(node->right, file);
                fprintf(file, ")");
            }
            break;
        }
        case ID_TYPE :
        {
            fprintf(file, "%s", node->value.name);
            break;
        }
        default :
        {
            fprintf(file, "can't interpret this construction");
            // printf("I'm here, but I shouldn't, line = %d\n", __LINE__);
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x5169
movq %rsi, %rbx
testq %rsi, %rsi
je 0x5188
movq %rdi, %r14
movl (%rdi), %eax
cmpl $0xd, %eax
jg 0x50a3
cmpl $0x4, %eax
je 0x5149
cmpl $0xc, %eax
jne 0x512c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x536d
testb %al, %al
jne 0x5127
movq 0x18(%r14), %rax
movq 0x8(%rax), %rdx
leaq 0x22b6(%rip), %rsi      # 0x7341
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2150
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x5458
jmp 0x5116
cmpl $0xf, %eax
je 0x5159
cmpl $0xe, %eax
jne 0x512c
cmpl $0x1, 0x8(%r14)
ja 0x50ce
movq 0x10(%r14), %rax
cmpl $0xe, (%rax)
jne 0x50ce
movl $0x28, %edi
movq %rbx, %rsi
callq 0x2120
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x5031
movslq 0x8(%r14), %rax
leaq 0x502b(%rip), %rcx      # 0xa110
movq (%rcx,%rax,8), %rdx
leaq 0x2327(%rip), %rsi      # 0x7417
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2150
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x5031
cmpl $0x1, 0x8(%r14)
ja 0x5127
movq 0x10(%r14), %rax
cmpl $0xe, (%rax)
jne 0x5127
movl $0x29, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2120
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x22bd(%rip), %rdi      # 0x73f0
movl $0x21, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x21b0
movq 0x8(%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x20f0
movl 0x8(%r14), %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5529
leaq 0xf6c(%rip), %rdi       # 0x60dc
leaq 0x20bd(%rip), %rsi      # 0x7234
leaq 0x2385(%rip), %rcx      # 0x7503
movl $0xf9, %edx
callq 0x2090
leaq 0x1674(%rip), %rdi      # 0x6803
leaq 0x209e(%rip), %rsi      # 0x7234
leaq 0x2366(%rip), %rcx      # 0x7503
movl $0xfa, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/translator.cpp
// Function: TranslateCondition(Node*, _IO_FILE*, unsigned long)
void TranslateCondition(Node* node, FILE* file, size_t num_tabs)
{
    assert(node);
    assert(file);

    fprintf(file, "%s (", OPERATORS[IF].rus_name);
    TranslateExpression(node->left, file);
    fprintf(file, ")\n");

    TranslateCompound(node->right->left, file, num_tabs);

    if (node->right->right != nullptr)
    {
        SetTabs(file, num_tabs);
        fprintf(file, "%s\n", OPERATORS[ELSE].rus_name);
        TranslateCompound(node->right->right, file, num_tabs);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x527e
movq %rsi, %r14
testq %rsi, %rsi
je 0x529d
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x22df(%rip), %rsi      # 0x74b3
leaq 0x13d0(%rip), %rdx      # 0x65ab
movq %r14, %rdi
xorl %eax, %eax
callq 0x2150
movq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0x5031
leaq 0x214d(%rip), %rdi      # 0x7345
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x21b0
movq 0x20(%r15), %rax
movq 0x18(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4d10
movq 0x20(%r15), %rax
cmpq $0x0, 0x20(%rax)
je 0x5275
testq %rbx, %rbx
je 0x5242
movq %rbx, %r12
movl $0x9, %edi
movq %r14, %rsi
callq 0x2120
decq %r12
jne 0x5230
leaq 0x2173(%rip), %rsi      # 0x73bc
leaq 0x1365(%rip), %rdx      # 0x65b5
movq %r14, %rdi
xorl %eax, %eax
callq 0x2150
movq 0x20(%r15), %rax
movq 0x20(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4d10
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe57(%rip), %rdi       # 0x60dc
leaq 0x1fa8(%rip), %rsi      # 0x7234
leaq 0x2225(%rip), %rcx      # 0x74b8
movl $0xdf, %edx
callq 0x2090
leaq 0x155f(%rip), %rdi      # 0x6803
leaq 0x1f89(%rip), %rsi      # 0x7234
leaq 0x2206(%rip), %rcx      # 0x74b8
movl $0xe0, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/translator.cpp
// Function: TranslateLoop(Node*, _IO_FILE*, unsigned long)
void TranslateLoop(Node* node, FILE* file, size_t num_tabs)
{
    assert(node);
    assert(file);

    fprintf(file, "%s (", OPERATORS[LOOP].rus_name);
    TranslateExpression(node->left, file);
    fprintf(file, ")\n");

    TranslateCompound(node->right, file, num_tabs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x532f
movq %rsi, %r14
testq %rsi, %rsi
je 0x534e
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x21d3(%rip), %rsi      # 0x74b3
leaq 0x1290(%rip), %rdx      # 0x6577
movq %r14, %rdi
xorl %eax, %eax
callq 0x2150
movq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0x5031
leaq 0x2041(%rip), %rdi      # 0x7345
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x21b0
movq 0x20(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4d10
leaq 0xda6(%rip), %rdi       # 0x60dc
leaq 0x1ef7(%rip), %rsi      # 0x7234
leaq 0x2144(%rip), %rcx      # 0x7488
movl $0xd3, %edx
callq 0x2090
leaq 0x14ae(%rip), %rdi      # 0x6803
leaq 0x1ed8(%rip), %rsi      # 0x7234
leaq 0x2125(%rip), %rcx      # 0x7488
movl $0xd4, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/translator.cpp
// Function: TranslateStdCall(Node*, _IO_FILE*)
bool TranslateStdCall(Node* node, FILE* file)
{
    assert(node);
    assert(file);

    if (strcmp(node->left->value.name, "scan") == 0)
    {
        fprintf(file, "nepravdoi()");
        return true;
    }

    if (strcmp(node->left->value.name, "print") == 0)
    {
        fprintf(file, "govoru(");
        TranslateParams(node->right, file);
        fprintf(file, ");\n");
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x541a
movq %rsi, %rbx
testq %rsi, %rsi
je 0x5439
movq %rdi, %r14
movq 0x18(%rdi), %rax
movq 0x8(%rax), %r15
leaq 0x20cb(%rip), %rsi      # 0x7469
movq %r15, %rdi
callq 0x2140
testl %eax, %eax
je 0x53c1
leaq 0x20c9(%rip), %rsi      # 0x747a
movq %r15, %rdi
callq 0x2140
testl %eax, %eax
je 0x53cf
xorl %eax, %eax
jmp 0x540f
leaq 0x20a6(%rip), %rdi      # 0x746e
movl $0xb, %esi
jmp 0x5400
leaq 0x20aa(%rip), %rdi      # 0x7480
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x21b0
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x5458
leaq 0x2021(%rip), %rdi      # 0x741c
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x21b0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcbb(%rip), %rdi       # 0x60dc
leaq 0x1e0c(%rip), %rsi      # 0x7234
leaq 0x2014(%rip), %rcx      # 0x7443
movl $0xbd, %edx
callq 0x2090
leaq 0x13c3(%rip), %rdi      # 0x6803
leaq 0x1ded(%rip), %rsi      # 0x7234
leaq 0x1ff5(%rip), %rcx      # 0x7443
movl $0xbe, %edx
callq 0x2090