LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/xuchanglong[P]SimpleReactorImplemention-comments/eventDemultiplexer/event_demultiplexer.cc
// Function: reactor::EpollDemultiplexer::WaitEvents(std::map<int, reactor::EventHandler*, std::less<int>, std::allocator<std::pair<int const, reactor::EventHandler*>>>*, int, time_heap*)
int EpollDemultiplexer::WaitEvents(std::map<handle_t, EventHandler *> *handlers,
    int timeout, time_heap *event_timer)
{
    //  申请用于保存已发送事件的 epoll_event 。
    std::vector<epoll_event> ep_evts(m_fd_num);
    //  获取已发生事件的 epoll_event 。
    int num = epoll_wait(m_epoll_fd, &ep_evts[0], ep_evts.size(), timeout);
    if (num > 0) {
        for (int idx = 0; idx < num; ++idx) {
            handle_t handle = ep_evts[idx].data.fd;
            assert(handlers->find(handle) != handlers->end());
            if ((ep_evts[idx].events & EPOLLERR) || (ep_evts[idx].events & EPOLLHUP)) {
                (*handlers)[handle]->HandleError();
            } else {
                /**
                 * 调用该句柄对应的事件处理器的读写函数。
                */
                if (ep_evts[idx].events & EPOLLIN) {
                    (*handlers)[handle]->HandleRead();
                }
                if (ep_evts[idx].events & EPOLLOUT) {
                    (*handlers)[handle]->HandleWrite();
                }
            }
        }
    }
    if (event_timer != nullptr) {
        event_timer->tick();
    }

    return num;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movslq 0xc(%rdi), %rsi
leaq 0x10(%rsp), %r12
leaq 0x4(%rsp), %rdx
movq %r12, %rdi
callq 0x2d86
movl 0x8(%r15), %edi
movq (%r12), %rsi
movq 0x8(%r12), %rax
subq %rsi, %rax
pushq $0xc
popq %rcx
cqto
idivq %rcx
movl %eax, %edx
movl %ebp, %ecx
callq 0x2110
movq %rbx, 0x8(%rsp)
movl %eax, (%rsp)
testl %eax, %eax
jle 0x2c67
leaq 0x8(%r14), %r12
movl (%rsp), %eax
imulq $0xc, %rax, %r13
xorl %ebx, %ebx
leaq 0x4(%rsp), %r15
pushq $0x28
popq %rbp
cmpq %rbx, %r13
je 0x2c67
movq 0x10(%rsp), %rax
movl 0x4(%rax,%rbx), %eax
movl %eax, 0x4(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3052
cmpq %r12, %rax
je 0x2c94
movq 0x10(%rsp), %rax
movl (%rax,%rbx), %eax
testb $0x18, %al
je 0x2c23
movq %r14, %rdi
movq %r15, %rsi
callq 0x2dd8
movq %rbp, %rcx
jmp 0x2c55
testb $0x1, %al
je 0x2c43
movq %r14, %rdi
movq %r15, %rsi
callq 0x2dd8
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movl (%rax,%rbx), %eax
testb $0x4, %al
je 0x2c5e
movq %r14, %rdi
movq %r15, %rsi
callq 0x2dd8
pushq $0x20
popq %rcx
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax,%rcx)
addq $0xc, %rbx
jmp 0x2bdd
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
movl (%rsp), %ebx
je 0x2c79
callq 0x2e26
leaq 0x10(%rsp), %rdi
callq 0x2f50
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1594(%rip), %rdi      # 0x422f
leaq 0x1531(%rip), %rsi      # 0x41d3
leaq 0x15b0(%rip), %rcx      # 0x4259
pushq $0x1d
popq %rdx
callq 0x2160
jmp 0x2cb5
jmp 0x2cb5
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2f50
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/xuchanglong[P]SimpleReactorImplemention-comments/eventDemultiplexer/event_demultiplexer.cc
// Function: reactor::EpollDemultiplexer::RequestEvent(int, unsigned int)
int EpollDemultiplexer::RequestEvent(handle_t handle, event_t evt)
{
    epoll_event ep_evt;
    ep_evt.data.fd = handle;
    ep_evt.events = 0;

    if (evt & kReadEvent) {
        ep_evt.events |= EPOLLIN;
    }
    if (evt & kWriteEvent) {
        ep_evt.events |= EPOLLOUT;
    }
    ep_evt.events |= EPOLLONESHOT;

    if (epoll_ctl(m_epoll_fd, EPOLL_CTL_MOD, handle, &ep_evt) != 0) {
        if (errno == ENOENT) {
            if (epoll_ctl(m_epoll_fd, EPOLL_CTL_ADD, handle, &ep_evt) != 0) {
                return -errno;
            }
            ++m_fd_num;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0xc(%rsp), %rcx
movl %esi, 0x4(%rcx)
movl %edx, %eax
andl $0x1, %eax
andl $0x2, %edx
leal (%rax,%rdx,2), %eax
addl $0x40000000, %eax       # imm = 0x40000000
movl %eax, (%rcx)
movl 0x8(%rdi), %edi
pushq $0x3
popq %rsi
movl %r14d, %edx
callq 0x2270
xorl %ebp, %ebp
testl %eax, %eax
je 0x2d36
callq 0x2040
cmpl $0x2, (%rax)
jne 0x2d36
movq %rax, %r15
movl 0x8(%rbx), %edi
pushq $0x1
popq %rsi
leaq 0xc(%rsp), %rcx
movl %r14d, %edx
callq 0x2270
testl %eax, %eax
je 0x2d33
xorl %ebp, %ebp
subl (%r15), %ebp
jmp 0x2d36
incl 0xc(%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xuchanglong[P]SimpleReactorImplemention-comments/./other/timeheap.hpp
// Function: time_heap::tick()
void tick()
    {
        heap_timer *tmp = array[0];
        time_t cur = time(nullptr);
        while (!empty()) {
            if (!tmp) {
                break;
            }
            if (tmp->expire > cur) {
                break;
            }
            if (array[0]->cb_func) {
                array[0]->cb_func(array[0]->user_data);
            }
            pop_timer();
            tmp = array[0];
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %r15
xorl %edi, %edi
callq 0x21e0
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
je 0x2e74
testq %r15, %r15
je 0x2e74
cmpq %r14, (%r15)
jg 0x2e74
movq (%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rax
testq %rax, %rax
je 0x2e64
movq 0x10(%rcx), %rdi
callq *%rax
movq %rbx, %rdi
callq 0x2e7a
movq (%rbx), %rax
movq (%rax), %r15
jmp 0x2e3e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/xuchanglong[P]SimpleReactorImplemention-comments/./other/timeheap.hpp
// Function: time_heap::percolate_down(unsigned long)
void percolate_down(size_t hole)
    {
        heap_timer *temp = array[hole];
        size_t child = 0;
        for (; ((hole * 2 + 1) <= (cur_size - 1)); hole = child) {
            child = hole * 2 + 1;
            if ((child < (cur_size - 1)) && (array[child + 1]->expire < array[child]->expire)) {
                ++child;
            }
            if (array[child]->expire < temp->expire) {
                array[hole] = array[child];
            } else {
                break;
            }
        }
        array[hole] = temp;
    }

// Assembly:
movq (%rdi), %rax
movq 0x10(%rdi), %rdx
movq (%rax,%rsi,8), %rcx
decq %rdx
leaq (%rsi,%rsi), %r9
cmpq %rdx, %r9
jae 0x2f18
leaq 0x1(,%rsi,2), %r8
cmpq %rdx, %r8
jae 0x2f00
movq 0x10(%rax,%r9,8), %r10
movq (%r10), %r10
movq (%rax,%r8,8), %r11
cmpq (%r11), %r10
jge 0x2f00
addq $0x2, %r9
movq %r9, %r8
movq (%rax,%r8,8), %r9
movq (%r9), %r10
cmpq (%rcx), %r10
jge 0x2f18
movq %r9, (%rax,%rsi,8)
movq (%rdi), %rax
movq %r8, %rsi
jmp 0x2ed2
movq %rcx, (%rax,%rsi,8)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xuchanglong[P]SimpleReactorImplemention-comments/reactor/reactor.cc
// Function: reactor::ReactorImplementation::RegisterHandler(reactor::EventHandler*, unsigned int)
int ReactorImplementation::RegisterHandler(EventHandler *handler, event_t evt)
{
    if (handler == nullptr) {
        return -1;
    }
    handle_t handle = handler->GetHandle();
    std::map<handle_t, EventHandler *>::iterator it = m_handlers.find(handle);
    if (it == m_handlers.end()) {
        m_handlers[handle] = handler;
    }
    return m_demultiplexer->RequestEvent(handle, evt);
}

// Assembly:
testq %rsi, %rsi
je 0x33bb
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x8(%r14), %r12
movq %r12, %rdi
callq 0x3052
leaq 0x10(%r14), %rcx
cmpq %rcx, %rax
jne 0x33a0
leaq 0x4(%rsp), %rsi
movq %r12, %rdi
callq 0x2dd8
movq %r15, (%rax)
movq (%r14), %rdi
movl 0x4(%rsp), %esi
movq (%rdi), %rax
movl %ebx, %edx
callq *0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $-0x1
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xuchanglong[P]SimpleReactorImplemention-comments/reactor/reactor.cc
// Function: reactor::ReactorImplementation::RemoveHandler(reactor::EventHandler*)
int ReactorImplementation::RemoveHandler(EventHandler *handler)
{
    if (handler == nullptr) {
        return -1;
    }

    handle_t handle = handler->GetHandle();
    m_handlers.erase(handle);
    return m_demultiplexer->UnrequestEvent(handle);
}

// Assembly:
testq %rsi, %rsi
je 0x3405
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
leaq 0x4(%rsp), %r14
movl %eax, (%r14)
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x36c0
movq (%rbx), %rdi
movl (%r14), %esi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $-0x1
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xuchanglong[P]SimpleReactorImplemention-comments/reactor/reactor.cc
// Function: reactor::ReactorImplementation::HandleEvents()
void ReactorImplementation::HandleEvents()
{
    int timeout = 0;
    if (m_eventtimer->top() == nullptr) {
        timeout = 0;
    } else {
        timeout = ((m_eventtimer->top())->expire - time(nullptr)) * 1000;
    }
    m_demultiplexer->WaitEvents(&m_handlers, timeout, m_eventtimer);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rcx
xorl %edx, %edx
cmpq $0x0, 0x10(%rcx)
je 0x3445
movq (%rcx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x3445
movl (%rax), %ebp
xorl %edi, %edi
callq 0x21e0
subl %eax, %ebp
imull $0x3e8, %ebp, %edx      # imm = 0x3E8
movq 0x38(%rbx), %rcx
movq (%rbx), %rdi
addq $0x8, %rbx
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/xuchanglong[P]SimpleReactorImplemention-comments/./other/timeheap.hpp
// Function: time_heap::time_heap(unsigned long)
time_heap(size_t cap)
        : capacity(cap)
        , cur_size(0)
    {
        array = new heap_timer *[capacity];
        if (array == nullptr) {
            throw std::exception();
        }
        for (size_t i = 0; i < capacity; ++i) {
            array[i] = nullptr;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %rax
shrq $0x3d, %rax
leaq (,%rsi,8), %rcx
xorl %r15d, %r15d
negq %rax
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x2030
movq %rax, (%r14)
cmpq %r15, %rbx
je 0x3578
movq (%r14), %rax
andq $0x0, (%rax,%r15,8)
incq %r15
jmp 0x3566
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/xuchanglong[P]SimpleReactorImplemention-comments/./other/timeheap.hpp
// Function: time_heap::add_timer(heap_timer*)
int add_timer(heap_timer *timer)
    {
        if (timer == nullptr) {
            return -1;
        }
        if (cur_size >= capacity) {
            resize();
        }
        int hole = cur_size++;
        int parent = 0;
        for (; hole > 0; hole = parent) {
            parent = (hole - 1) / 2;
            if (array[parent]->expire <= timer->expire) {
                break;
            }
            array[hole] = array[parent];
        }
        array[hole] = timer;
        return 0;
    }

// Assembly:
testq %rsi, %rsi
je 0x35dd
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
cmpq 0x8(%rdi), %rax
jb 0x35a3
movq %r14, %rdi
callq 0x363a
movq 0x10(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%r14)
movq (%r14), %rcx
testl %eax, %eax
jle 0x35cd
leal -0x1(%rax), %edx
shrl %edx
movq (%rcx,%rdx,8), %rsi
movq (%rsi), %rdi
cmpq (%rbx), %rdi
jle 0x35cd
movl %eax, %eax
movq %rsi, (%rcx,%rax,8)
movl %edx, %eax
jmp 0x35ab
cltq
movq %rbx, (%rcx,%rax,8)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $-0x1
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xuchanglong[P]SimpleReactorImplemention-comments/./other/timeheap.hpp
// Function: time_heap::resize()
void resize()
    {
        heap_timer **temp = new heap_timer *[2 * capacity];
        for (size_t i = 0; i < 2 * capacity; ++i) {
            temp[i] = nullptr;
        }
        if (!temp) {
            throw std::exception();
        }
        capacity = 2 * capacity;
        for (size_t i = 0; i < cur_size; ++i) {
            temp[i] = array[i];
        }
        delete[] array;
        array = temp;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movabsq $0x7000000000000000, %rax # imm = 0x7000000000000000
andq %r15, %rax
movq %r15, %rcx
shlq $0x4, %rcx
xorl %r12d, %r12d
negq %rax
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x2030
movq %rax, %r14
addq %r15, %r15
cmpq %r12, %r15
je 0x3688
andq $0x0, (%r14,%r12,8)
incq %r12
jmp 0x3679
movq %r15, 0x8(%rbx)
movq (%rbx), %rdi
movq 0x10(%rbx), %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x36a7
movq (%rdi,%rcx,8), %rdx
movq %rdx, (%r14,%rcx,8)
incq %rcx
jmp 0x3695
testq %rdi, %rdi
je 0x36b1
callq 0x2260
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/rvthak[P]Makefile-Maker/input.cpp
// Function: InputManager(int, char const**, Makefile&)
void InputManager(int argc, char const **argv, Makefile &mk){

	// No parameters
	if(argc==1){ printf(" (i) > No arguments given using defaults..\n"); return; }
	
	// Only one parameter => use it as a name
	else if(argc==2){ 
		if( argv[1][0]!='-' ){
			printf(" (i) > Only one argument given. Using '%s' as a Name\n", argv[1]);
			mk.setName(argv[1]);
			return;
		}
	}

	// More than one parameter
	int count=1; // Start from 2nd argument
	argc=argc-1; // Use argc as a total counter

	while(count<=argc){
		// HandleParameter changes count for ease
		if( HandleParameter(count, argc, argv, mk)!=0 ){ exit(1); } 
	}

	// Compilation Parameter read mode
	if(mk.getCompParam()){ mk.readCompParam(); }

	// Execution Parameter read mode
	if(mk.getExecParam()){ mk.readExecParam(); }

	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
cmpl $0x2, %edi
je 0x2476
cmpl $0x1, %r15d
jne 0x247f
leaq 0x1e7e(%rip), %rdi      # 0x42e2
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2200
movq 0x8(%r14), %rsi
cmpb $0x2d, (%rsi)
jne 0x24e7
leaq 0x10(%rsp), %r12
movl $0x1, (%r12)
leal -0x1(%r15), %eax
leaq 0xc(%rsp), %r13
movl %eax, (%r13)
cmpl %r15d, 0x10(%rsp)
jge 0x24bd
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2543
testl %eax, %eax
je 0x2499
pushq $0x1
popq %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x360a
testb %al, %al
je 0x24d1
movq %rbx, %rdi
callq 0x38e0
movq %rbx, %rdi
callq 0x3612
testb %al, %al
je 0x2520
movq %rbx, %rdi
callq 0x3916
jmp 0x2520
leaq 0x1b16(%rip), %rdi      # 0x4004
xorl %eax, %eax
callq 0x2030
movq 0x8(%r14), %rsi
leaq 0x10(%rsp), %r14
leaq 0xb(%rsp), %rdx
movq %r14, %rdi
callq 0x30c2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3664
leaq 0x10(%rsp), %rdi
callq 0x20b0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/rvthak[P]Makefile-Maker/input.cpp
// Function: printInputFormat()
void printInputFormat(void){
	printf("\n          ------ Argument Format ------ \n // Default values on ()\n");
	printf(" >> Set Executable Name:     -n < name (a.out) >\n");
	printf(" >> Set Source file Format:  -f < source file format (.cpp) >\n");
	printf(" >> Set Header file Format:  -h < header file format (.hpp) >\n");
	printf(" >> Set Compiler:            -c < compiler name (g++) >\n");
	printf(" >> Toggle gdb:                     -db  (1)\n");
	printf(" >> Toggle valgrind:                -vg  (1)\n");
	printf(" >> Toggle compilation parameters:  -p   (0)\n");
	printf(" >> Toggle execution parameters:    -e   (0)\n");
	printf(" >> Toggle auto project organizer:  -org (0)\n");
	printf(" >> Print help:                     --help\n");
	
	printf("\n (i)> The <...> fields are REQUIRED right after their corresponding parameter\n");
	printf(" (i)> Rogue Strings and Non-Supported parameters will cause termination\n");
	printf(" (i)> Give Format by writing just the last chars (example: file.c => -f c) \n");
	return;
}

// Assembly:
pushq %rax
leaq 0x1927(%rip), %rdi      # 0x430d
callq 0x2200
leaq 0x195e(%rip), %rdi      # 0x4350
callq 0x2200
leaq 0x1983(%rip), %rdi      # 0x4381
callq 0x2200
leaq 0x19b5(%rip), %rdi      # 0x43bf
callq 0x2200
leaq 0x19e7(%rip), %rdi      # 0x43fd
callq 0x2200
leaq 0x1a13(%rip), %rdi      # 0x4435
callq 0x2200
leaq 0x1a34(%rip), %rdi      # 0x4462
callq 0x2200
leaq 0x1a55(%rip), %rdi      # 0x448f
callq 0x2200
leaq 0x1a76(%rip), %rdi      # 0x44bc
callq 0x2200
leaq 0x1a97(%rip), %rdi      # 0x44e9
callq 0x2200
leaq 0x1ab8(%rip), %rdi      # 0x4516
callq 0x2200
leaq 0x1ad7(%rip), %rdi      # 0x4541
callq 0x2200
leaq 0x1b1a(%rip), %rdi      # 0x4590
callq 0x2200
leaq 0x1b56(%rip), %rdi      # 0x45d8
popq %rax
jmp 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/rvthak[P]Makefile-Maker/input.cpp
// Function: getDesision(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool getDesision(const string msg){
	string str;
	cout << msg << ": ";
	
	while(1){
		cout << " ";
		cin >> str;

		if (cin.fail()){
	    	cin.clear(); 
	    	cin.ignore(numeric_limits<streamsize>::max(), '\n');
	    	cout << " > Wrong input try again: (y/n)" << endl;
    	}
		else if(str=="y"){
			cin.get();
			return 1;
		}
		else if(str=="n"){
			cin.get();
			return 0;
		}
		else{
			cout << " > Wrong input try again: (y/n)" << endl;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rsi
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x404a(%rip), %rdi      # 0x6fd0
callq 0x2140
leaq 0x12c9(%rip), %rsi      # 0x425b
movq %rax, %rdi
callq 0x2160
movq 0x402f(%rip), %rbx      # 0x6fd0
leaq 0x16fc(%rip), %r14      # 0x46a4
movq 0x4031(%rip), %r15      # 0x6fe0
leaq 0x8(%rsp), %r12
leaq 0x12c5(%rip), %rbp      # 0x4280
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2160
movq %r15, %rdi
movq %r12, %rsi
callq 0x21a0
movq (%r15), %rax
movq -0x18(%rax), %rdi
testb $0x5, 0x20(%r15,%rdi)
je 0x3001
addq %r15, %rdi
xorl %esi, %esi
callq 0x2220
movq %r15, %rdi
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
pushq $0xa
popq %rdx
callq 0x20f0
jmp 0x302a
movq %r12, %rdi
leaq 0x1295(%rip), %rsi      # 0x42a0
callq 0x30fd
movl %eax, %r13d
testb %al, %al
jne 0x3042
movq %r12, %rdi
leaq 0x1059(%rip), %rsi      # 0x407a
callq 0x30fd
testb %al, %al
jne 0x3042
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20c0
jmp 0x2fbb
movq 0x3f97(%rip), %rdi      # 0x6fe0
callq 0x2180
leaq 0x8(%rsp), %rdi
callq 0x20b0
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x306c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/rvthak[P]Makefile-Maker/input.cpp
// Function: changeFormat(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 changeFormat(string &str, const string frm){
	int pos=str.find_last_of(".");
	int len=str.length() - pos;
	str.erase(pos+1, len);
	str+=frm;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x112b(%rip), %rsi      # 0x41bd
pushq $-0x1
popq %rdx
callq 0x2150
movl 0x8(%r14), %ecx
subl %eax, %ecx
incl %eax
movslq %eax, %rsi
movslq %ecx, %rdx
movq %r14, %rdi
callq 0x2060
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/rvthak[P]Makefile-Maker/main.cpp
// Function: main
int main(int argc, char const **argv){

	// Create a Makefile with default values
	Makefile mk;

	// Parse the user arguments and update Makefile values
	InputManager(argc, argv, mk);

	// Get a list of files from the targeted directory
	SystemInput(mk);

	// Create and write the actual makefile
	Output(mk);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3264
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x243c
leaq 0x8(%rsp), %rdi
callq 0x2ab4
leaq 0x8(%rsp), %rdi
callq 0x394c
leaq 0x8(%rsp), %rdi
callq 0x320c
xorl %eax, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x320c
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O2/rvthak[P]Makefile-Maker/makefileS.cpp
// Function: Makefile::Makefile()
Makefile::Makefile(){
	Name=NAME;
	Compiler=COMP;
	SourceFormat=FRMT;
	HeaderFormat=HEAD;
	debugEnable=DEBG;
	valgrindEnable=VALG;
	installEnable=INST;
	parameterEnable=PARM;
	execParamEnable=EXEC;
	organizeEnable=ORGN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x70(%rdi), %rcx
movq %rcx, 0x60(%rdi)
andq $0x0, 0x68(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x40(%rdi), %r15
movb %al, 0x70(%rdi)
leaq 0x98(%rdi), %rcx
movq %rcx, 0x88(%rdi)
andq $0x0, 0x90(%rdi)
leaq 0x60(%rdi), %r12
leaq 0x88(%rdi), %rcx
movq %rcx, 0x10(%rsp)
movb %al, 0x98(%rdi)
leaq 0xb8(%rdi), %rcx
movq %rcx, 0xa8(%rdi)
andq $0x0, 0xb0(%rdi)
leaq 0xa8(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movb %al, 0xb8(%rdi)
leaq 0xc8(%rdi), %r13
leaq 0xd8(%rdi), %rcx
movq %rcx, 0xc8(%rdi)
andq $0x0, 0xd0(%rdi)
movb %al, 0xd8(%rdi)
leaq 0xe8(%rdi), %rbp
leaq 0xf8(%rdi), %rcx
movq %rcx, 0xe8(%rdi)
andq $0x0, 0xf0(%rdi)
movb %al, 0xf8(%rdi)
leaq 0x1305(%rip), %rsi      # 0x4664
callq 0x2270
leaq 0x12ff(%rip), %rsi      # 0x466a
movq %r14, %rdi
callq 0x2270
leaq 0x12f4(%rip), %rsi      # 0x466e
movq %r15, %rdi
callq 0x2270
leaq 0x12e9(%rip), %rsi      # 0x4672
movq %r12, %rdi
callq 0x2270
movl $0x10101, 0x80(%rbx)    # imm = 0x10101
andw $0x0, 0x84(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, (%rsp)
movq %rbp, %rdi
callq 0x20b0
movq %r13, %rdi
callq 0x20b0
movq 0x8(%rsp), %rdi
callq 0x20b0
movq 0x10(%rsp), %rdi
callq 0x20b0
movq %r12, %rdi
callq 0x20b0
movq %r15, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x20b0
movq (%rsp), %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O2/rvthak[P]Makefile-Maker/makefileS.cpp
// Function: Makefile::Makefile(Makefile const&)
Makefile::Makefile(const Makefile &mkfl){
	Name=mkfl.Name;
	Compiler=mkfl.Compiler;
	SourceFormat=mkfl.SourceFormat;
	HeaderFormat=mkfl.HeaderFormat;
	debugEnable=mkfl.debugEnable;
	valgrindEnable=mkfl.valgrindEnable;
	installEnable=mkfl.installEnable;
	parameterEnable=mkfl.parameterEnable;
	execParamEnable=mkfl.execParamEnable;
	organizeEnable=mkfl.organizeEnable;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
movq %rsi, %r13
movb %al, 0x50(%rdi)
leaq 0x70(%rdi), %rcx
movq %rcx, 0x60(%rdi)
andq $0x0, 0x68(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x40(%rdi), %r15
movb %al, 0x70(%rdi)
leaq 0x98(%rdi), %rcx
movq %rcx, 0x88(%rdi)
andq $0x0, 0x90(%rdi)
leaq 0x60(%rdi), %r12
leaq 0x88(%rdi), %rcx
movq %rcx, 0x10(%rsp)
movb %al, 0x98(%rdi)
leaq 0xb8(%rdi), %rcx
movq %rcx, 0xa8(%rdi)
andq $0x0, 0xb0(%rdi)
leaq 0xa8(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movb %al, 0xb8(%rdi)
leaq 0xc8(%rdi), %rcx
movq %rcx, (%rsp)
leaq 0xd8(%rdi), %rcx
movq %rcx, 0xc8(%rdi)
andq $0x0, 0xd0(%rdi)
movb %al, 0xd8(%rdi)
leaq 0xe8(%rdi), %rbp
leaq 0xf8(%rdi), %rcx
movq %rcx, 0xe8(%rdi)
andq $0x0, 0xf0(%rdi)
movb %al, 0xf8(%rdi)
callq 0x20d0
leaq 0x20(%r13), %rsi
movq %r14, %rdi
callq 0x20d0
leaq 0x40(%r13), %rsi
movq %r15, %rdi
callq 0x20d0
leaq 0x60(%r13), %rsi
movq %r12, %rdi
callq 0x20d0
movl 0x80(%r13), %eax
movl %eax, 0x80(%rbx)
movb 0x84(%r13), %al
movb %al, 0x84(%rbx)
movb 0x85(%r13), %al
movb %al, 0x85(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
movq %rbp, %rdi
callq 0x20b0
movq (%rsp), %rdi
callq 0x20b0
movq 0x8(%rsp), %rdi
callq 0x20b0
movq 0x10(%rsp), %rdi
callq 0x20b0
movq %r12, %rdi
callq 0x20b0
movq %r15, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x20b0
movq %r13, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/rvthak[P]Makefile-Maker/makefileS.cpp
// Function: Makefile::print() const
void Makefile::print(void)const{
	cout << " (i) Current Makefile State:" << endl;
	cout << " Name:            " << Name << endl;
	cout << " Compiler:        " << Compiler << endl;
	cout << " SourceFormat:    " << SourceFormat << endl;
	cout << " HeaderFormat:    " << HeaderFormat << endl;
	cout << " debugEnable:     " << debugEnable << endl;
	cout << " valgrindEnable:  " << valgrindEnable << endl;
	cout << " parameterEnable: " << parameterEnable << endl;
	if(parameterEnable){
		cout << " Compilation parameters: " << CompParameters << endl;
	}
	cout << " execparamEnable: " << execParamEnable << endl;
	if(execParamEnable){
		cout << " Execution parameters: " << ExecParameters << endl;
	}
	cout << " organizeEnable:  " << organizeEnable << endl;
	cout << " File List: " << FileList << endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38f2(%rip), %r14      # 0x6fd0
leaq 0xf91(%rip), %rsi       # 0x4676
movq %r14, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20c0
leaq 0xf97(%rip), %rsi       # 0x4693
movq %r14, %rdi
callq 0x2160
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2140
movq %rax, %rdi
callq 0x20c0
leaq 0xf88(%rip), %rsi       # 0x46a6
movq %r14, %rdi
callq 0x2160
leaq 0x20(%rbx), %rsi
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x20c0
leaq 0xf78(%rip), %rsi       # 0x46b9
movq %r14, %rdi
callq 0x2160
leaq 0x40(%rbx), %rsi
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x20c0
leaq 0xf68(%rip), %rsi       # 0x46cc
movq %r14, %rdi
callq 0x2160
leaq 0x60(%rbx), %rsi
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x20c0
leaq 0xf58(%rip), %rsi       # 0x46df
movq %r14, %rdi
callq 0x2160
movzbl 0x80(%rbx), %esi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x20c0
leaq 0xf45(%rip), %rsi       # 0x46f2
movq %r14, %rdi
callq 0x2160
movzbl 0x81(%rbx), %esi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x20c0
leaq 0xf32(%rip), %rsi       # 0x4705
movq %r14, %rdi
callq 0x2160
movzbl 0x83(%rbx), %esi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x20c0
cmpb $0x1, 0x83(%rbx)
jne 0x3825
movq 0x37ce(%rip), %rdi      # 0x6fd0
leaq 0xf0f(%rip), %rsi       # 0x4718
callq 0x2160
leaq 0x88(%rbx), %rsi
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x20c0
movq 0x37a4(%rip), %rdi      # 0x6fd0
leaq 0xeff(%rip), %rsi       # 0x4732
callq 0x2160
movzbl 0x84(%rbx), %esi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x20c0
cmpb $0x1, 0x84(%rbx)
jne 0x3882
movq 0x3771(%rip), %rdi      # 0x6fd0
leaq 0xedf(%rip), %rsi       # 0x4745
callq 0x2160
leaq 0xa8(%rbx), %rsi
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x20c0
movq 0x3747(%rip), %r14      # 0x6fd0
leaq 0xecd(%rip), %rsi       # 0x475d
movq %r14, %rdi
callq 0x2160
movzbl 0x85(%rbx), %esi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x20c0
leaq 0xeba(%rip), %rsi       # 0x4770
movq %r14, %rdi
callq 0x2160
addq $0xc8, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2140
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/rvthak[P]Makefile-Maker/output.cpp
// Function: mkflBody[abi:cxx11]()
string mkflBody(void){
	string buf;
	buf+="\nall: $(OUT)\n\n";
	buf+="$(OUT): $(OBJS)\n";
	buf+="\t$(CXX) -o $(OUT) $(OBJS)\n\n";
	buf+="%.o: %.c\n";
	buf+="\t$(CXX) -c -o $@ $<\n\n";
	buf+="run: $(OUT)\n";
	buf+="\t./$(OUT) $(EXECUTION_PARAMETERS)\n\n";
	return buf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0xbb3(%rip), %rsi       # 0x4856
callq 0x2260
leaq 0xbb6(%rip), %rsi       # 0x4865
movq %rbx, %rdi
callq 0x2260
leaq 0xbb8(%rip), %rsi       # 0x4876
movq %rbx, %rdi
callq 0x2260
leaq 0xbc5(%rip), %rsi       # 0x4892
movq %rbx, %rdi
callq 0x2260
leaq 0xbc0(%rip), %rsi       # 0x489c
movq %rbx, %rdi
callq 0x2260
leaq 0xbc7(%rip), %rsi       # 0x48b2
movq %rbx, %rdi
callq 0x2260
leaq 0xbc5(%rip), %rsi       # 0x48bf
movq %rbx, %rdi
callq 0x2260
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/rvthak[P]Makefile-Maker/output.cpp
// Function: mkflInst[abi:cxx11]()
string mkflInst(void){
	string buf;
	buf+="\ninstall: $(OUT)\n";
	buf+="\tsudo cp $(OUT) /usr/local/bin\n";
	buf+="\t@echo Program Installed in /usr/local/bin\n";
	buf+="\t@echo You can now delete this folder safely\n\n";
	return buf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0xba5(%rip), %rsi       # 0x48e3
callq 0x2260
leaq 0xbab(%rip), %rsi       # 0x48f5
movq %rbx, %rdi
callq 0x2260
leaq 0xbbc(%rip), %rsi       # 0x4915
movq %rbx, %rdi
callq 0x2260
leaq 0xbd9(%rip), %rsi       # 0x4941
movq %rbx, %rdi
callq 0x2260
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/rvthak[P]Makefile-Maker/output.cpp
// Function: mkflDB[abi:cxx11]()
string mkflDB(void){
	string buf;
	buf+="db: clean param\n";
	buf+="param: CXXFLAGS += -g\n";
	buf+="param: $(OUT)\n\n";
	buf+="gdb: db\n";
	buf+="\tgdb $(OUT)\n\n";
	return buf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0xbc4(%rip), %rsi       # 0x4970
callq 0x2260
leaq 0xbc9(%rip), %rsi       # 0x4981
movq %rbx, %rdi
callq 0x2260
leaq 0xbd1(%rip), %rsi       # 0x4998
movq %rbx, %rdi
callq 0x2260
leaq 0xbd2(%rip), %rsi       # 0x49a8
movq %rbx, %rdi
callq 0x2260
leaq 0xbcc(%rip), %rsi       # 0x49b1
movq %rbx, %rdi
callq 0x2260
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/rvthak[P]Makefile-Maker/output.cpp
// Function: mkflVal[abi:cxx11](bool)
string mkflVal(bool dbflag){
	string buf;

	if(!dbflag){
		buf+="db: clean param\n";
		buf+="param: CXXFLAGS += -g\n";
		buf+="param: $(OUT)\n\n";
	}
	
	buf+="vg: db\n";
	buf+="\tvalgrind $(EXECUTION_PARAMETERS) ./$(OUT)\n\n";

	buf+="vgleak: db\n";
	buf+="\tvalgrind --leak-check=full ./$(OUT) $(EXECUTION_PARAMETERS)\n\n";

	buf+="vgext: db\n";
	buf+="\tvalgrind --leak-check=full --show-leak-kinds=all --leak-resolution=high --track-origins=yes --vgdb=yes ./$(OUT) $(EXECUTION_PARAMETERS)\n\n";

	return buf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testl %esi, %esi
jne 0x3e53
leaq 0xb43(%rip), %rsi       # 0x4970
movq %rbx, %rdi
callq 0x2260
leaq 0xb45(%rip), %rsi       # 0x4981
movq %rbx, %rdi
callq 0x2260
leaq 0xb4d(%rip), %rsi       # 0x4998
movq %rbx, %rdi
callq 0x2260
leaq 0xb65(%rip), %rsi       # 0x49bf
movq %rbx, %rdi
callq 0x2260
leaq 0xb5e(%rip), %rsi       # 0x49c7
movq %rbx, %rdi
callq 0x2260
leaq 0xb7c(%rip), %rsi       # 0x49f4
movq %rbx, %rdi
callq 0x2260
leaq 0xb79(%rip), %rsi       # 0x4a00
movq %rbx, %rdi
callq 0x2260
leaq 0xba9(%rip), %rsi       # 0x4a3f
movq %rbx, %rdi
callq 0x2260
leaq 0xba5(%rip), %rsi       # 0x4a4a
movq %rbx, %rdi
callq 0x2260
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/rvthak[P]Makefile-Maker/output.cpp
// Function: mkflClean[abi:cxx11]()
string mkflClean(void){
	string buf;

	buf+=".PHONY: clean\n";
	buf+="clean:\n";
	buf+="\trm -f *.o\n";
	
	return buf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0xbec(%rip), %rsi       # 0x4ad5
callq 0x2260
leaq 0xbef(%rip), %rsi       # 0x4ae4
movq %rbx, %rdi
callq 0x2260
leaq 0xbe8(%rip), %rsi       # 0x4aec
movq %rbx, %rdi
callq 0x2260
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_07.cc
// Function: populate(std::shared_ptr<std::vector<int, std::allocator<int>>>)
shared_ptr<vector<int>> populate(shared_ptr<vector<int>> vec)
{
	int item;

	while (cin >> item) {
		vec->push_back(item);
	}

	return vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2d40(%rip), %r15      # 0x3fe0
leaq -0x24(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1080
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
movq (%rbx), %rdi
jne 0x12ca
movq %r12, %rsi
callq 0x13f4
jmp 0x12a4
movq %rdi, (%r14)
movq 0x8(%rbx), %rax
andq $0x0, 0x8(%rbx)
movq %rax, 0x8(%r14)
andq $0x0, (%rbx)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/Environment.cpp
// Function: (anonymous namespace)::conv_str(Srl::String const&, std::vector<unsigned char, std::allocator<unsigned char>>&, Srl::Encoding)
MemBlock conv_str(const String& in, vector<uint8_t>& buffer, Encoding encoding)
    {
        if(in.encoding() == encoding) {
            return MemBlock(in.data(), in.size());
        }
        auto size = Tools::conv_charset(encoding, in, buffer, true);

        return MemBlock(buffer.data(), size);
    }

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rsi
cmpb $0x1, 0xd(%rdi)
jne 0x14729
cmpb $0x0, 0xe(%rsi)
movq %rsi, %rax
jne 0x14724
movq (%rsi), %rax
movl 0x8(%rsi), %edx
jmp 0x1473f
pushq $0x1
popq %rcx
movl %ecx, %edi
movq %rbx, %rdx
xorl %r8d, %r8d
callq 0x12590
movq %rax, %rdx
movq (%rbx), %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::store_string(Srl::String const&)
pair<const String*, size_t> Environment::store_string(const String& str)
{
    if(str.size() < 1) {
        return { &Environment::EmptyString, EmptyStringHash };
    }

    auto conv = conv_str(str, this->str_buffer, Environment::Str_Encoding);
    auto hash = hash_fnc(conv);

    auto* str_ptr = this->str_table.get(conv);

    if(str_ptr) {
        return { str_ptr, hash };
    }

    String new_str(conv);

    if(!new_str.block.try_store_local()) {
        new_str.block.extern_data = Aux::copy(this->heap, conv).ptr;
    }

    str_ptr = this->str_table.insert(new_str, new_str).second;
    return { str_ptr, hash };
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpl $0x0, 0x8(%rsi)
je 0x14824
movq %rdi, %r14
leaq 0x220(%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1470b
movq %rax, %r12
movq %rdx, %r13
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rax, %rdi
movq %rdx, %rsi
callq 0x11900
movq %rax, %rbx
leaq 0x58(%r14), %r15
movq %rsp, %rsi
movq %r12, (%rsi)
movl %r13d, 0x8(%rsi)
movw $0x10c, 0xc(%rsi)       # imm = 0x10C
movb $0x0, 0xe(%rsi)
movq %r15, %rdi
callq 0x11d90
testq %rax, %rax
jne 0x14832
movq %rsp, %rdi
movq %r12, (%rdi)
movl %r13d, 0x8(%rdi)
movw $0x10c, 0xc(%rdi)       # imm = 0x10C
movb $0x0, 0xe(%rdi)
callq 0x11ae0
testb %al, %al
jne 0x14811
addq $0x8, %r14
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x117a0
movq %rax, (%rsp)
movq %rsp, %rdx
movq %r15, %rdi
movq %rdx, %rsi
callq 0x118b0
movq %rdx, %rax
jmp 0x14832
movq 0x17715(%rip), %rax     # 0x2bf40
movq 0x1890e(%rip), %rbx     # 0x2d140
movq %rbx, %rdx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::create_node(Srl::Type, Srl::String const&)
Link<Node>* Environment::create_node(Type type, const String& name)
{
    auto strp = this->store_string(name);
    auto* link = this->heap.create<Link<Node>>(strp.second, Node(this->tree, type));
    link->field.name_ptr = strp.first;

    return link;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x115c0
leaq 0x10(%rsp), %r14
movq %rax, -0x8(%r14)
movq %rdx, (%r14)
movq (%rbx), %rdi
addq $0x8, %rbx
callq 0x12af0
leaq 0x28(%rsp), %rcx
movq %rax, -0x10(%rcx)
addq $0x8, %rax
movq %rax, -0x8(%rcx)
movq %rcx, 0x8(%rcx)
movq %rcx, (%rcx)
andq $0x0, 0x10(%rcx)
movq %rax, 0x18(%rcx)
leaq 0x48(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movb %bpl, 0x20(%rax)
movb $0x1, 0x21(%rax)
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11e80
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x12c70
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rbx)
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x12c70
movq %rbx, %rdi
callq 0x12990
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::store_value(Srl::Node&, Srl::Value const&, Srl::String const&)
Link<Value>* Environment::store_value(Node& parent, const Value& value, const String& name)
{
    auto* link = this->create_link(parent.values, value, name);
    auto& block = link->field.block;

    if(!block.stored_local && !block.try_store_local()) {
        block.extern_data = Aux::copy(this->heap, { block.extern_data, block.size }).ptr;
    }

    return link;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x28, %rsi
callq 0x12570
movq %rax, %r14
cmpb $0x0, 0x1e(%rax)
jne 0x14b6c
movq %r14, %rdi
addq $0x10, %rdi
callq 0x11ae0
testb %al, %al
jne 0x14b6c
addq $0x8, %rbx
movq 0x10(%r14), %rax
movl 0x18(%r14), %ecx
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
movq %rbx, %rdi
callq 0x117a0
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::write_conv(Srl::Value const&, Srl::String const&)
void Environment::write_conv(const Value& value, const String& val_name)
{
    MemBlock name_conv;

    if(val_name.encoding() == Encoding::UTF8) {
        name_conv = MemBlock(val_name.data(), val_name.size());

    } else {
        auto& buffer = this->str_buffer;
        auto size = Tools::conv_charset(Encoding::UTF8, val_name, buffer, true);
        name_conv = MemBlock(buffer.data(), size);
    }

    auto type = value.type();

    bool no_conversion_needed =
        /* scope types don't need conversion */
        TpTools::is_scope(type) || type == Type::Scope_End ||
        /* strings must be UTF8 in text formats */
        (type == Type::String && parser->get_format() != Format::Text &&
         value.encoding() == Encoding::UTF8) ||
        /* binary types must be converted to string in text formats */
        (type != Type::String && parser->get_format() == Format::Binary);

    if(no_conversion_needed) {
        parser->write(value, name_conv, this->out);

    } else {
        parser->write(this->conv_type(value), name_conv, this->out);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0xd(%rdx)
jne 0x14ba0
cmpb $0x0, 0xe(%rdx)
movq %rdx, %rcx
jne 0x14b9b
movq (%rdx), %rcx
movl 0x8(%rdx), %eax
jmp 0x14bc1
leaq 0x220(%rbx), %rax
pushq $0x1
popq %rcx
movl %ecx, %edi
movq %rdx, %rsi
movq %rax, %rdx
xorl %r8d, %r8d
callq 0x12590
movq 0x220(%rbx), %rcx
movq %rcx, (%rsp)
movq %rax, 0x8(%rsp)
movzbl 0x14(%r14), %eax
leal -0xe(%rax), %ecx
cmpl $0x3, %ecx
jae 0x14bf0
movq 0x250(%rbx), %rdi
addq $0x2b0, %rbx            # imm = 0x2B0
movq (%rdi), %rax
movq %rsp, %rdx
movq %r14, %rsi
jmp 0x14c4b
cmpl $0xc, %eax
jne 0x14c0e
movq 0x250(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpb $0x1, %al
je 0x14c1e
cmpb $0x1, 0x15(%r14)
je 0x14bd7
jmp 0x14c1e
movq 0x250(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
je 0x14bd7
movq 0x250(%rbx), %r15
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x11320
addq $0x2b0, %rbx            # imm = 0x2B0
movq (%r15), %rax
movq %rsp, %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rcx
callq *0x8(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::conv_type(Srl::Value const&)
Value Environment::conv_type(const Value& value)
{
    size_t data_size = 0;
    auto& buffer = this->type_buffer;

    if(value.type() == Type::String) {

        String wrap(value.data(), value.size(), value.encoding());
        data_size = Tools::conv_charset(Encoding::UTF8, wrap, buffer, true);

    } else if(TpTools::is_scalar(value.type())) {

        data_size = Tools::type_to_str(value, buffer);

    } else {

        assert(value.type() == Type::Binary && "Value type invalid.");

        data_size = Tools::bytes_to_base64(value.data(), value.size(), buffer);
    }

    return Value( { buffer.data(), data_size }, value.type());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x238, %r15            # imm = 0x238
movb 0x14(%rdx), %al
cmpb $0xc, %al
jne 0x14cff
cmpb $0x0, 0x16(%r14)
jne 0x14d0e
movq 0x8(%r14), %rax
jmp 0x14d12
jae 0x14d40
movq %r14, %rdi
movq %r15, %rsi
callq 0x119c0
jmp 0x14d61
leaq 0x8(%r14), %rax
movl 0x10(%r14), %ecx
movb 0x15(%r14), %dl
movq %rsp, %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movb $0xc, 0xc(%rsi)
movb %dl, 0xd(%rsi)
movb $0x0, 0xe(%rsi)
pushq $0x1
popq %rcx
movl %ecx, %edi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0x12590
jmp 0x14d61
cmpb $0xd, %al
jne 0x14d88
cmpb $0x0, 0x16(%r14)
jne 0x14d51
movq 0x8(%r14), %rdi
jmp 0x14d55
leaq 0x8(%r14), %rdi
movl 0x10(%r14), %esi
movq %r15, %rdx
callq 0x11be0
movq (%r15), %rcx
movb 0x14(%r14), %dl
andq $0x0, (%rbx)
movq %rcx, 0x8(%rbx)
movl %eax, 0x10(%rbx)
movb %dl, 0x14(%rbx)
andw $0x0, 0x15(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xc317(%rip), %rdi      # 0x210a6
leaq 0xc346(%rip), %rsi      # 0x210dc
leaq 0xc357(%rip), %rcx      # 0x210f4
movl $0xd4, %edx
callq 0x11890
nop
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::clear()
void Environment::clear()
{
    this->heap.clear();
    this->str_table.clear();
    this->shared_table_store.clear();
    this->shared_table_restore.clear();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x11830
leaq 0x58(%rbx), %rdi
callq 0x11070
leaq 0xf0(%rbx), %rdi
callq 0x11140
addq $0x188, %rbx            # imm = 0x188
movq %rbx, %rdi
popq %rbx
jmp 0x12cb0
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/include/Srl/Hash.hpp
// Function: Srl::Lib::HTable<Srl::String, Srl::String, Srl::Lib::HashSrl<Srl::String, void>>::get(Srl::String const&)
V* HTable<K, V, H>::get(const K& key)
    {
        if(elements < 1) {
            return nullptr;
        }

        auto hash    = hash_fnc(key);
        auto bucket  = get_bucket(hash);
        Entry* entry = table[bucket];

        while(entry) {

            if(entry->hash == hash && entry->key == key) {
                return &entry->val;
            }

            entry = entry->next;
        }

        return nullptr;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq $0x0, 0x18(%rdi)
je 0x14f3e
movq %rsi, %rbx
movq %rdi, %r13
addq $0x40, %rdi
callq 0x11fa0
movq %rax, %r15
movq 0x8(%r13), %rcx
movq %rcx, %rdx
shrq $0x20, %rdx
shrq $0x20, %rax
xorl %r14d, %r14d
testq %rdx, %rdx
cmovneq %r14, %rax
xorq %r15, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %r12
shlq $0x3, %r12
addq 0x20(%r13), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x14f4a
cmpq %r15, (%r12)
jne 0x14f38
leaq 0x10(%r12), %rdi
movq %rbx, %rsi
callq 0x114d0
testb %al, %al
jne 0x14f43
addq $0x8, %r12
jmp 0x14f18
xorl %r14d, %r14d
jmp 0x14f4a
addq $0x20, %r12
movq %r12, %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/include/Srl/Aux.h
// Function: Srl::Lib::Aux::copy(Srl::Lib::Heap&, Srl::Lib::MemBlock const&)
inline MemBlock copy (Heap& heap, const MemBlock& block)
    {
        if(block.size < 1) return block;

        auto* mem = heap.get_mem(block.size);
        memcpy(mem, block.ptr, block.size);

        return { mem, block.size };
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x14fb6
callq 0x117f0
movq %rax, %r14
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %rax, %rdi
callq 0x11bf0
movq 0x8(%rbx), %rdx
jmp 0x14fbb
movq (%rbx), %r14
xorl %edx, %edx
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Link<Srl::Node>* Srl::Lib::Environment::create_link<Srl::Node>(std::__cxx11::list<Srl::Lib::Link<Srl::Node>, Srl::Lib::HeapAllocator<Srl::Lib::Link<Srl::Node>>>&, Srl::Node const&, Srl::String const&)
Link<T>* Environment::create_link(Lib::Items<T>& lst, const T& val, const String& name)
{
    auto strp = this->store_string(name);
    lst.emplace_back(strp.second, val);
    auto& link = lst.back();
    link.field.name_ptr = strp.first;

    return &link;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rsi
callq 0x115c0
leaq 0x8(%rsp), %r15
movq %rax, -0x8(%r15)
movq %rdx, (%r15)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12260
movq 0x10(%r14), %rax
movq -0x8(%r15), %rcx
movq %rcx, 0x60(%rax)
addq $0x10, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/include/Srl/Hash.hpp
// Function: Srl::Lib::HTable<unsigned long, std::shared_ptr<void>, Srl::Lib::HashSrl<unsigned long, void>>::clear()
void HTable<K, V, H>::clear()
    {
        if(this->elements < 1) {
            return;
        }

        this->destroy_all<K, V>();
        this->heap.clear();
        this->mem_cache.clear();
        this->elements = 0;
        this->limit    = 0;
    }

// Assembly:
cmpq $0x0, 0x18(%rdi)
je 0x15161
pushq %rbx
movq %rdi, %rbx
callq 0x12b10
leaq 0x48(%rbx), %rdi
callq 0x11830
movq 0x28(%rbx), %rax
cmpq %rax, 0x30(%rbx)
je 0x15159
movq %rax, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
popq %rbx
retq