LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/Application.cpp
// Function: Application::fail()
void Application::fail() {
	int i, removed;

	// fail half the members at time t=400
	if( par->DROP_MSG && par->getcurrtime() == 50 ) {
		par->dropmsg = 1;
	}

	if( par->SINGLE_FAILURE && par->getcurrtime() == 100 ) {
		removed = (rand() % par->EN_GPSZ);
		#ifdef DEBUGLOG
		log->LOG(&mp1[removed]->getMemberNode()->addr, "Node failed at time=%d", par->getcurrtime());
		#endif
		mp1[removed]->getMemberNode()->bFailed = true;
	}
	else if( par->getcurrtime() == 100 ) {
		removed = rand() % par->EN_GPSZ/2;
		for ( i = removed; i < removed + par->EN_GPSZ/2; i++ ) {
			#ifdef DEBUGLOG
			log->LOG(&mp1[i]->getMemberNode()->addr, "Node failed at time = %d", par->getcurrtime());
			#endif
			mp1[i]->getMemberNode()->bFailed = true;
		}
	}

	if( par->DROP_MSG && par->getcurrtime() == 300) {
		par->dropmsg=0;
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
cmpl $0x0, 0x20(%rdi)
je 0x4991
callq 0x55e0
cmpl $0x32, %eax
jne 0x4991
movq 0x40(%rbx), %rax
movl $0x1, 0x24(%rax)
movq 0x40(%rbx), %rdi
cmpl $0x0, 0x4(%rdi)
je 0x49f9
callq 0x55e0
cmpl $0x64, %eax
jne 0x49f9
callq 0x2050
movq 0x40(%rbx), %rdi
cltd
idivl 0x18(%rdi)
movq 0x30(%rbx), %r14
movq 0x38(%rbx), %rax
movslq %edx, %r12
movq (%rax,%r12,8), %rax
movq 0x20(%rax), %r15
addq $0x8, %r15
callq 0x55e0
leaq 0x38fb(%rip), %rdx      # 0x82d0
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %ecx
xorl %eax, %eax
callq 0x5090
movq 0x38(%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x20(%rax), %rax
movb $0x1, 0x10(%rax)
jmp 0x4a86
movq 0x40(%rbx), %rdi
callq 0x55e0
cmpl $0x64, %eax
jne 0x4a86
callq 0x2050
movq 0x40(%rbx), %rdi
movl 0x18(%rdi), %ecx
cltd
idivl %ecx
cmpl $0x2, %ecx
jl 0x4a86
movl %edx, %ebp
shrl $0x1f, %ebp
addl %edx, %ebp
sarl %ebp
movslq %ebp, %r13
leaq 0x38b9(%rip), %r14      # 0x82e7
movq 0x30(%rbx), %r15
movq 0x38(%rbx), %rax
movq (%rax,%r13,8), %rax
movq 0x20(%rax), %r12
addq $0x8, %r12
callq 0x55e0
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %eax, %ecx
xorl %eax, %eax
callq 0x5090
movq 0x38(%rbx), %rax
movq (%rax,%r13,8), %rax
movq 0x20(%rax), %rax
movb $0x1, 0x10(%rax)
incq %r13
movq 0x40(%rbx), %rdi
movl 0x18(%rdi), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %ebp, %ecx
movslq %ecx, %rax
cmpq %rax, %r13
jl 0x4a2e
movq 0x40(%rbx), %rdi
cmpl $0x0, 0x20(%rdi)
je 0x4aa7
callq 0x55e0
cmpl $0x12c, %eax            # imm = 0x12C
jne 0x4aa7
movq 0x40(%rbx), %rax
movl $0x0, 0x24(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/Params.cpp
// Function: Params::setparams(char*)
void Params::setparams(char *config_file) {
	FILE *fp = fopen(config_file,"r");

	fscanf(fp,"MAX_NNB: %d", &MAX_NNB);
	fscanf(fp,"\nSINGLE_FAILURE: %d", &SINGLE_FAILURE);
	fscanf(fp,"\nDROP_MSG: %d", &DROP_MSG);
	fscanf(fp,"\nMSG_DROP_PROB: %lf", &MSG_DROP_PROB);

	//printf("Parameters of the test case: %d %d %d %lf\n", MAX_NNB, SINGLE_FAILURE, DROP_MSG, MSG_DROP_PROB);

	EN_GPSZ = MAX_NNB;
	STEP_RATE=.25;
	MAX_MSG_SIZE = 4000;
	globaltime = 0;
	dropmsg = 0;
	allNodesJoined = 0;
	for ( unsigned int i = 0; i < EN_GPSZ; i++ ) {
		allNodesJoined += i;
	}
	fclose(fp);
	return;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x2f9c(%rip), %rsi      # 0x84d5
movq %rax, %rdi
callq 0x21f0
movq %rax, %r14
leaq 0x2f8c(%rip), %rsi      # 0x84d7
xorl %ebp, %ebp
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2300
leaq 0x4(%rbx), %rdx
leaq 0x2f7e(%rip), %rsi      # 0x84e3
movq %r14, %rdi
xorl %eax, %eax
callq 0x2300
leaq 0x20(%rbx), %rdx
leaq 0x2f7d(%rip), %rsi      # 0x84f7
movq %r14, %rdi
xorl %eax, %eax
callq 0x2300
leaq 0x8(%rbx), %rdx
leaq 0x2f76(%rip), %rsi      # 0x8505
movq %r14, %rdi
xorl %eax, %eax
callq 0x2300
movl (%rbx), %eax
movl %eax, 0x18(%rbx)
movabsq $0x3fd0000000000000, %rcx # imm = 0x3FD0000000000000
movq %rcx, 0x10(%rbx)
movl $0xfa0, 0x1c(%rbx)      # imm = 0xFA0
movq $0x0, 0x24(%rbx)
testl %eax, %eax
je 0x55d1
leal -0x1(%rax), %ecx
leal -0x2(%rax), %edx
imulq %rcx, %rdx
shrq %rdx
leal (%rax,%rdx), %ebp
decl %ebp
movl %ebp, 0x2c(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2180
// File: /workspace/github_cpp_makefile_star2_O1/eecs280staff[P]unit_test_framework/./unit_test_framework.hpp
// Function: decltype(print(fp, fp0.first), print(fp, fp0.second))& unit_test_framework::Diagnostic::print_helper<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::ostream&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, int, int)
static auto print_helper(std::ostream& os,
                             const std::pair<First, Second>& t, int,
                             int)
      -> decltype(print(os, t.first), print(os, t.second))& {
      os << '(';
      print(os, t.first);
      os << ',';
      print(os, t.second);
      return os << ')';
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x5(%rsp), %rsi
movb $0x28, (%rsi)
movl $0x1, %edx
callq 0x2230
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x2230
leaq 0x6(%rsp), %rsi
movb $0x2c, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2230
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x2230
leaq 0x7(%rsp), %rsi
movb $0x29, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2230
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tanguysegarra[P]libcsv/src/reader.hxx
// Function: csv::Reader::get_column_names[abi:cxx11]() const
std::vector<std::string> Reader::get_column_names() const
    {
        auto colnames = std::vector<std::string>{};
        for (size_t i = 0; i < rows_.size(); i++)
            colnames.push_back(rows_[i].first);

        return colnames;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rsi
cmpq %rsi, 0x8(%r14)
je 0x51d3
xorl %r15d, %r15d
movabsq $0x6db6db6db6db6db7, %r12 # imm = 0x6DB6DB6DB6DB6DB7
xorl %r13d, %r13d
addq %r15, %rsi
movq %rbx, %rdi
callq 0x5f28
incq %r13
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
imulq %r12, %rax
addq $0x38, %r15
cmpq %rax, %r13
jb 0x51aa
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5e34
movq %r14, %rdi
callq 0x4470
nop
// File: /workspace/github_cpp_makefile_star2_O1/tanguysegarra[P]libcsv/src/reader.hxx
// Function: csv::Reader::find_column_id(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
size_t Reader::find_column_id(const std::string& id) const
    {
        for (size_t i = 0; i < rows_.size(); i++)
            if (rows_[i].first == id)
                return i;

        throw InvalidArgumentException("Could not find column: " + id);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x8(%rsp)
movq (%rdi), %r12
movq 0x8(%rdi), %rax
subq %r12, %rax
setne %bpl
je 0x5280
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %r14 # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %r14
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rbx
cmpq $0x1, %r14
movq %r14, %r13
adcq $0x0, %r13
addq $0x8, %r12
xorl %r15d, %r15d
movq (%r12), %rdx
cmpq %rbx, %rdx
jne 0x526d
testq %rdx, %rdx
je 0x52cb
movq -0x8(%r12), %rdi
movq 0x10(%rsp), %rsi
callq 0x42d0
testl %eax, %eax
je 0x52cb
incq %r15
cmpq %r14, %r15
setb %bpl
addq $0x38, %r12
cmpq %r15, %r13
jne 0x524c
movl $0x28, %edi
callq 0x4170
movq %rax, %r14
leaq 0xfe84(%rip), %rsi      # 0x15118
leaq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
callq 0x5bc7
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x5c50
xorl %ebp, %ebp
leaq 0x187c4(%rip), %rsi     # 0x1da80
leaq 0xa1f(%rip), %rdx       # 0x5ce2
movq %r14, %rdi
callq 0x4460
testb $0x1, %bpl
je 0x5280
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5309
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42b0
jmp 0x5309
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x5316
movq %r14, %rdi
callq 0x4210
movq %rbx, %rdi
callq 0x4470
// File: /workspace/github_cpp_makefile_star2_O1/KinderRiven[P]rdma_demo/server.cc
// Function: sock_read(int, void*, unsigned long)
size_t sock_read(int sock_fd, void* buffer, size_t len)
{
    size_t nr, tot_read;
    char* buf = (char*)buffer; // avoid pointer arithmetic on void pointer
    tot_read = 0;

    while (len != 0 && (nr = read(sock_fd, buf, len)) != 0) {
        if (nr < 0) {
            if (errno == EINTR) {
                continue;
            } else {
                return -1;
            }
        }
        len -= nr;
        buf += nr;
        tot_read += nr;
    }

    return tot_read;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x1347
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %r12d
xorl %ebx, %ebx
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x11b0
testq %rax, %rax
je 0x1349
addq %rax, %r15
addq %rax, %rbx
subq %rax, %r14
jne 0x1327
jmp 0x1349
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/KinderRiven[P]rdma_demo/server.cc
// Function: sock_write(int, void*, unsigned long)
size_t sock_write(int sock_fd, void* buffer, size_t len)
{
    size_t nw, tot_written;
    char* buf = (char*)buffer; // avoid pointer arithmetic on void pointer

    for (tot_written = 0; tot_written < len;) {
        nw = write(sock_fd, buf, len - tot_written);

        if (nw <= 0) {
            if (nw == -1 && errno == EINTR) {
                continue;
            } else {
                return -1;
            }
        }

        tot_written += nw;
        buf += nw;
    }
    return tot_written;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x1393
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %r12d
xorl %ebx, %ebx
movq %r14, %rdx
subq %rbx, %rdx
movl %r12d, %edi
movq %r15, %rsi
callq 0x10b0
testq %rax, %rax
je 0x1397
addq %rax, %rbx
addq %rax, %r15
cmpq %r14, %rbx
jb 0x1370
jmp 0x139e
xorl %ebx, %ebx
jmp 0x139e
movq $-0x1, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AraKhachatryan[P]messenger/./namespace_terminal.hpp
// Function: terminal::Cursor_Previous_Line[abi:cxx11](int)
inline std::string Cursor_Previous_Line( int n = 1 )
	{
		if ( ::terminal_color ) {
			std::ostringstream stringStream;
			stringStream << "\x1B[" << n << "F";
			return stringStream.str();
		} else {
			return "";
		}
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rdi, %rbx
cmpb $0x1, 0x3b87(%rip)      # 0x7170
jne 0x3658
movl %esi, %ebp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2200
leaq 0x1b79(%rip), %rsi      # 0x517a
movl $0x2, %edx
movq %r14, %rdi
callq 0x21e0
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0x2250
leaq 0x1b5e(%rip), %rsi      # 0x517f
movl $0x1, %edx
movq %rax, %rdi
callq 0x21e0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2230
movq 0x397e(%rip), %rsi      # 0x6fc0
leaq 0x8(%rsp), %rdi
callq 0x20f0
leaq 0x78(%rsp), %rdi
callq 0x2080
jmp 0x3671
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1a9e(%rip), %rdx      # 0x5104
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x37d4
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x3936(%rip), %rsi      # 0x6fc0
leaq 0x8(%rsp), %rdi
callq 0x20f0
leaq 0x78(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/AraKhachatryan[P]messenger/./namespace_terminal.hpp
// Function: terminal::Erase_Line[abi:cxx11](int)
inline std::string Erase_Line( int n = 2 )
	{
		if ( ::terminal_color ) {
			std::ostringstream stringStream;
			stringStream << "\x1B[" << n << "K";
			return stringStream.str();
		} else {
			return "";
		}
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rdi, %rbx
cmpb $0x1, 0x3ab5(%rip)      # 0x7170
jne 0x372a
movl %esi, %ebp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2200
leaq 0x1aa7(%rip), %rsi      # 0x517a
movl $0x2, %edx
movq %r14, %rdi
callq 0x21e0
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0x2250
leaq 0x1ab8(%rip), %rsi      # 0x51ab
movl $0x1, %edx
movq %rax, %rdi
callq 0x21e0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2230
movq 0x38ac(%rip), %rsi      # 0x6fc0
leaq 0x8(%rsp), %rdi
callq 0x20f0
leaq 0x78(%rsp), %rdi
callq 0x2080
jmp 0x3743
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x19cc(%rip), %rdx      # 0x5104
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x37d4
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x3864(%rip), %rsi      # 0x6fc0
leaq 0x8(%rsp), %rdi
callq 0x20f0
leaq 0x78(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/AraKhachatryan[P]messenger/encode_decode.cpp
// Function: make_encoded_message(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, char*)
void make_encoded_message( const char * dest_name, const char * message_info,
                          const std::string& message, size_t io_buffer_length, char * output )
{
    size_t j = 0;

    for( size_t i = 0; dest_name[i] != 0; ++i )
    {
        output[j] = dest_name[i];
        ++j;
    }

    for( ; j < 100; )
    {
        output[j] = 0x00;
        ++j;
    }

    for(  size_t i = 0; message_info[i] != 0; ++i  )
    {
        output[j] = message_info[i];
        ++j;
    }

    for( ; j < 128; )
    {
        output[j] = 0x00;
        ++j;
    }

    for(auto& c: message)
    {
        output[j] = c;
        ++j;
    }

        for( ; j < io_buffer_length; )
    {
        output[j] = 0x00;
        ++j;
    }

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movb (%rdi), %cl
xorl %eax, %eax
testb %cl, %cl
je 0x3a51
movb %cl, (%r14,%rax)
movb 0x1(%rdi,%rax), %cl
incq %rax
jmp 0x3a40
cmpq $0x63, %rax
ja 0x3a6f
leaq (%r14,%rax), %rdi
movl $0x64, %edx
subq %rax, %rdx
xorl %esi, %esi
callq 0x2100
movl $0x64, %eax
movb (%r12), %cl
testb %cl, %cl
je 0x3a8c
incq %r12
movb %cl, (%r14,%rax)
incq %rax
movb (%r12), %cl
incq %r12
testb %cl, %cl
jne 0x3a7a
cmpq $0x7f, %rax
ja 0x3aaa
leaq (%r14,%rax), %rdi
movl $0x80, %edx
subq %rax, %rdx
xorl %esi, %esi
callq 0x2100
movl $0x80, %eax
movq 0x8(%r15), %rcx
testq %rcx, %rcx
je 0x3acf
movq (%r15), %rsi
leaq (%r14,%rax), %rdi
xorl %edx, %edx
movb (%rsi,%rdx), %r8b
movb %r8b, (%rdi,%rdx)
incq %rdx
cmpq %rdx, %rcx
jne 0x3abc
addq %rdx, %rax
subq %rax, %rbx
jbe 0x3aef
addq %rax, %r14
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2100
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/AraKhachatryan[P]messenger/encode_decode.cpp
// Function: print_encoded_message(char const*, unsigned long)
void print_encoded_message( const char * encoded_message, size_t io_buffer_length )
{
    std::cout << std::endl;
    for( size_t i = 0; i < io_buffer_length; ++i )
    {
        if(encoded_message[i] == 0x00){
            std::cout << ".";
        }else{
            std::cout << encoded_message[i];
        }
    }
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq 0x32be(%rip), %rbx      # 0x6fc8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
testq %r14, %r14
je 0x3d7c
xorl %ebx, %ebx
movq 0x3289(%rip), %r12      # 0x6fc8
leaq 0x1432(%rip), %r13      # 0x5178
leaq 0x7(%rsp), %rbp
movb (%r15,%rbx), %al
testb %al, %al
je 0x3d64
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %r12, %rdi
movq %rbp, %rsi
jmp 0x3d6f
movl $0x1, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x21e0
incq %rbx
cmpq %rbx, %r14
jne 0x3d4b
movq 0x3245(%rip), %rbx      # 0x6fc8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::Maker::EndGroup()
Maker& EndGroup() {
			if (_stack.empty()) {
				UserType* new_ut = new UserType("#");

				new_ut->LinkUserType(ut);
				_stack.push_back(new_ut);
				ut = new_ut;

				return *this;
			}
			_stack.pop_back();
			return *this;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq %rax, 0x10(%rdi)
je 0x3015
addq $-0x8, %rax
movq %rax, 0x18(%rbx)
jmp 0x30ef
movl $0xb0, %edi
callq 0x2190
movq %rax, %r14
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7107(%rip), %rsi      # 0xa139
leaq 0x7101(%rip), %rdx      # 0xa13a
leaq 0x10(%rsp), %rdi
callq 0x85d2
leaq 0xac7e(%rip), %rax      # 0xdcc8
movq %rax, (%r14)
leaq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
movq 0x10(%rsp), %rcx
cmpq %r15, %rcx
je 0x306e
movq %rcx, 0x8(%r14)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%r14)
jmp 0x3075
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%r14)
movq %r15, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
leaq 0xac50(%rip), %rax      # 0xdce8
movq %rax, (%r14)
movq %r14, %rdi
addq $0x28, %rdi
movl $0x82, %edx
xorl %esi, %esi
callq 0x2100
movq %r14, 0x8(%rsp)
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x417e
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi
je 0x30d8
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x18(%rbx)
jmp 0x30e6
leaq 0x10(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0x3786
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0xb0, %esi
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::Maker::NewGroup(clau_parser::Maker&)
Maker& NewGroup(Maker& other) {
			if (this->ut == other.ut) {
				throw "New Group this == other";
			}

			_stack.back()->LinkUserType(other.ut);
			other.ut = nullptr;
			return *this;
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x8(%rsi), %rsi
cmpq %rsi, 0x8(%rdi)
je 0x3148
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq -0x8(%rax), %rdi
callq 0x417e
movq $0x0, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x8, %edi
callq 0x20d0
leaq 0x6fe2(%rip), %rcx      # 0xa13b
movq %rcx, (%rax)
movq 0xae5d(%rip), %rsi      # 0xdfc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::UserType::AddUserTypeItem(clau_parser::UserType&&)
void AddUserTypeItem(UserType&& item) {
			UserType* temp = new UserType(std::move(item.GetName()));

			temp->parent = this;

			ilist.push_back(2);

			userTypeList.push_back(temp);

			useSortedUserTypeList = false;
			useSortedItemList = false;


			{
				temp->itemList = std::move(item.itemList);
				temp->ilist = std::move(item.ilist);
				temp->userTypeList = std::move(item.userTypeList);

				for (size_t i = 0; i < item.GetUserTypeListSize(); ++i) {
					item.userTypeList[i] = nullptr;
				}
				for (size_t i = 0; i < temp->GetUserTypeListSize(); ++i) {
					temp->userTypeList[i]->parent = temp;
				}
			}
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0xb0, %edi
callq 0x2190
movq %rax, %r15
leaq 0x9dd1(%rip), %rax      # 0xdcc8
movq %rax, (%r15)
leaq 0x18(%r15), %rcx
movq %rcx, 0x8(%r15)
movq 0x8(%rbx), %rdx
leaq 0x18(%rbx), %rax
cmpq %rax, %rdx
je 0x3f1c
movq %rdx, 0x8(%r15)
movq (%rax), %rcx
movq %rcx, 0x18(%r15)
jmp 0x3f22
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%r15)
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
leaq 0x9da7(%rip), %rax      # 0xdce8
movq %rax, (%r15)
movq %r15, %rdi
addq $0x28, %rdi
movl $0x82, %edx
xorl %esi, %esi
callq 0x2100
movq %r15, (%rsp)
movq %r14, 0x28(%r15)
movl $0x2, 0xc(%rsp)
movq 0x38(%r14), %rsi
cmpq 0x40(%r14), %rsi
je 0x3f81
movl $0x2, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x38(%r14)
jmp 0x3f8f
leaq 0x30(%r14), %rdi
leaq 0xc(%rsp), %rdx
callq 0x3d98
movq 0x68(%r14), %rsi
cmpq 0x70(%r14), %rsi
je 0x3fa7
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x68(%r14)
jmp 0x3fb3
leaq 0x60(%r14), %rdi
movq %rsp, %rdx
callq 0x3786
movw $0x0, 0xa8(%r14)
leaq 0x48(%rbx), %rsi
movq (%rsp), %rdi
addq $0x48, %rdi
callq 0x406c
leaq 0x30(%rbx), %rsi
movq (%rsp), %rdi
addq $0x30, %rdi
callq 0x410e
leaq 0x60(%rbx), %rsi
movq (%rsp), %rdi
addq $0x60, %rdi
callq 0x4146
movq 0x60(%rbx), %rax
cmpq %rax, 0x68(%rbx)
je 0x401b
xorl %ecx, %ecx
movq $0x0, (%rax,%rcx,8)
incq %rcx
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rcx
jb 0x3ffc
movq (%rsp), %rax
movq 0x60(%rax), %rcx
movq 0x68(%rax), %rdx
subq %rcx, %rdx
je 0x404a
sarq $0x3, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdi
movq %rax, 0x28(%rdi)
incq %rsi
cmpq %rsi, %rdx
jne 0x403a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::UserType::LinkUserType(clau_parser::UserType*)
void LinkUserType(UserType* ut) // friend?
		{
			userTypeList.push_back(ut);
			ilist.push_back(2);
			ut->parent = this;

			useSortedUserTypeList = false;
		}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq 0x68(%rdi), %rsi
cmpq 0x70(%rdi), %rsi
je 0x41a2
movq %rax, (%rsi)
addq $0x8, 0x68(%rbx)
jmp 0x41b0
leaq 0x60(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0x3786
movl $0x2, 0x4(%rsp)
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x41d2
movl $0x2, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x38(%rbx)
jmp 0x41e0
leaq 0x30(%rbx), %rdi
leaq 0x4(%rsp), %rdx
callq 0x3d98
movq 0x8(%rsp), %rax
movq %rbx, 0x28(%rax)
movb $0x0, 0xa9(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::UserType::operator=(clau_parser::UserType&&)
void operator=(UserType&& ut) noexcept {
			if (this == &ut) { return; }

			Type::operator=(ut);
			RemoveUserTypeList();
			Reset2(std::move(ut));
			return;
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq %rsi, %rdi
je 0x4c9b
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x9324
movq %r14, %rdi
movq %rbx, %rsi
callq 0x97e8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x38a5
nop
// File: /workspace/github_cpp_makefile_star2_O1/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::InFileReserver::operator()(int, char*&, unsigned long*, long*&, unsigned long*)
bool operator() (int thr_num, char*& buffer, size_t* buffer_len, int64_t*& token_arr, size_t* token_arr_len)
		{
			if (pInFile) {
				bool x = Scan(pInFile, thr_num, buffer, buffer_len, token_arr, token_arr_len, use_simd).second > 0;

				return x;
			}
			else {
				bool x = Scan2(const_cast<char*>(str->c_str()), str->size(), thr_num, buffer, buffer_len, token_arr, token_arr_len, use_simd).second > 0;

				return x;
			}
		}

// Assembly:
pushq %rax
movq %r9, %rax
movq %r8, %r9
movq %rcx, %r8
movq %rdx, %rcx
movl %esi, %edx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x4ce6
movzbl 0x8(%rdi), %r10d
subq $0x8, %rsp
movq %rsi, %rdi
movl %edx, %esi
movq %rcx, %rdx
movq %r8, %rcx
movq %r9, %r8
movq %rax, %r9
pushq %r10
callq 0x63f4
jmp 0x4d01
movq 0x10(%rdi), %rsi
movq (%rsi), %r10
movq 0x8(%rsi), %rsi
movzbl 0x8(%rdi), %r11d
movq %r10, %rdi
pushq %r11
pushq %rax
callq 0x6556
addq $0x10, %rsp
shrq $0x20, %rax
testl %eax, %eax
setg %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::LoadData::FindDivisionPlace(char const*, long const*, long, long)
static int64_t FindDivisionPlace(const char* buffer, const int64_t* token_arr, int64_t start, int64_t last)
		{
			for (int64_t a = last; a >= start; --a) {
				int64_t len = Utility::GetLength(token_arr[a]);
				int64_t val = Utility::GetType(token_arr[a]);


				if (len == 1 && (-1 != Utility::Equal(TYPE_RIGHT, val))) { // right
					return a;
				}

				bool pass = false;
				if (len == 1 && (-1 != Utility::Equal(TYPE_LEFT, val))) { // left
					return a;
				}
				else if (len == 1 && -1 != Utility::Equal(TYPE_ASSIGN, val)) { // assignment
					//
					pass = true;
				}

				if (a < last && pass == false) {
					int64_t len = Utility::GetLength(token_arr[a + 1]);
					int64_t val = Utility::GetType(token_arr[a + 1]);

					if (!(len == 1 && -1 != Utility::Equal(TYPE_ASSIGN, val))) // assignment
					{ // NOT
						return a;
					}
				}
			}
			return -1;
		}

// Assembly:
movq $-0x1, %rax
cmpq %rdx, %rcx
jl 0x4e2c
leaq 0x1(%rcx), %rdi
leaq -0x1(%rdi), %r9
movq -0x8(%rsi,%rdi,8), %r10
movl %r10d, %r11d
andl $-0x8, %r11d
cmpl $0x8, %r11d
jne 0x4de5
shrl %r10d
andl $0x3, %r10d
leaq -0x1(%r10), %r11
cmpq $0x2, %r11
jb 0x4e19
movb $0x1, %r11b
testq %r10, %r10
jne 0x4de8
xorl %r11d, %r11d
cmpq %rcx, %r9
setge %r10b
orb %r11b, %r10b
movb $0x1, %r10b
jne 0x4e1f
movq (%rsi,%rdi,8), %r10
movl %r10d, %r11d
andl $-0x8, %r11d
cmpl $0x8, %r11d
jne 0x4e19
notl %r10d
testb $0x6, %r10b
sete %r10b
cmovneq %r9, %r8
jmp 0x4e1f
xorl %r10d, %r10d
movq %r9, %r8
testb %r10b, %r10b
je 0x4e2d
decq %rdi
cmpq %rdx, %rdi
jg 0x4db6
retq
movq %r8, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::InFileReserver::Scan(_IO_FILE*, int, char*&, unsigned long*, long*&, unsigned long*, bool)
static std::pair<bool, int> Scan(FILE* inFile, int thr_num,
			char*& _buffer, size_t* _buffer_len, int64_t*& _token_arr, size_t* _token_arr_len, bool use_simd)
		{
			if (inFile == nullptr) {
				return { false, 0 };
			}

			std::string temp;
			char* buffer = nullptr;
			size_t file_length;

			{
				fseek(inFile, 0, SEEK_END);
				size_t length = ftell(inFile);
				fseek(inFile, 0, SEEK_SET);

				Utility::BomType x = Utility::ReadBom(inFile);

				//	clau_parser::Out << "length " << length << "\n";
				if (x == Utility::BomType::UTF_8) {
					length = length - 3;
				}

				file_length = length;
				buffer = new char[file_length + 1]; // 

				//int a = clock();
				// read data as a block:
				fread(buffer, sizeof(char), file_length, inFile);
				//int b = clock();
				////std::cout << b - a << " " << file_length <<"\n";

				buffer[file_length] = '\0';

				{
					int64_t* token_arr;
					size_t token_arr_size;

					if (thr_num == 1) {
						Scanning(buffer, file_length, token_arr, token_arr_size);
					}
					else {
						ScanningNew(buffer, file_length, thr_num, token_arr, token_arr_size, use_simd);
					}

					_buffer = buffer;
					_token_arr = token_arr;
					*_token_arr_len = token_arr_size;
					*_buffer_len = file_length;
				}
			}

			return{ true, 1 };
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testq %rdi, %rdi
je 0x64a9
movq %r8, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq %rcx, 0x18(%rsp)
movq %r9, 0x20(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %esi, %esi
movl $0x2, %edx
callq 0x21d0
movq %rbx, %rdi
callq 0x2030
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21d0
movq %rbx, %rdi
callq 0x6676
leaq -0x3(%r14), %r13
testl %eax, %eax
cmovneq %r14, %r13
leaq 0x1(%r13), %rdi
callq 0x2040
movq %rax, %r14
movl $0x1, %esi
movq %rax, %rdi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x2270
movb $0x0, (%r14,%r13)
cmpl $0x1, %ebp
jne 0x64af
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movq %r13, %rsi
callq 0x6782
jmp 0x64cf
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x651b
movzbl 0x80(%rsp), %r9d
leaq 0x10(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %r14, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x6b4a
movq %r14, (%r12)
movq 0x10(%rsp), %rax
movq %rax, (%r15)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rax, (%rcx)
movq 0x18(%rsp), %rax
movq %r13, (%rax)
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x650c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
movabsq $0x100000000, %rcx      # imm = 0x100000000
movl $0x1, %eax
orq %rcx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x652f
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x654e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::InFileReserver::Scan2(char*, unsigned long, int, char*&, unsigned long*, long*&, unsigned long*, bool)
static std::pair<bool, int> Scan2(char* str, size_t len, int thr_num,
			char*& _buffer, size_t* _buffer_len, int64_t*& _token_arr, size_t* _token_arr_len, bool use_simd)
		{
			if (str == nullptr) {
				return { false, 0 };
			}

			std::string temp;
			char* buffer = str;
			size_t file_length;

			{
				size_t length = len;

				Utility::BomType x = Utility::ReadBom(str, length);

				//	clau_parser::Out << "length " << length << "\n";
				if (x == Utility::BomType::UTF_8) {
					length = length - 3;
				}

				file_length = length;

				buffer[file_length] = '\0';

				{
					int64_t* token_arr;
					size_t token_arr_size;

					if (thr_num == 1) {
						Scanning(buffer, file_length, token_arr, token_arr_size);
					}
					else {
						ScanningNew(buffer, file_length, thr_num, token_arr, token_arr_size, use_simd);
					}

					_buffer = buffer;
					_token_arr = token_arr;
					*_token_arr_len = token_arr_size;
					*_buffer_len = file_length;
				}
			}

			return{ true, 1 };
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testq %rdi, %rdi
je 0x65c4
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r12
movq %r9, 0x18(%rsp)
movq %r8, 0x20(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
xorl %r14d, %r14d
movb %r14b, (%rax)
callq 0x7962
leaq -0x3(%rbx), %r13
testl %eax, %eax
cmovneq %rbx, %r13
movb %r14b, (%r12,%r13)
cmpl $0x1, %ebp
jne 0x65ca
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %r12, %rdi
movq %r13, %rsi
callq 0x6782
jmp 0x65ea
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x663d
movzbl 0x88(%rsp), %r9d
leaq 0x10(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %r12, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x6b4a
movq 0x80(%rsp), %rax
movq %r12, (%r15)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
movq %rcx, (%rdx)
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq %r13, (%rax)
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x662e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
movabsq $0x100000000, %rcx      # imm = 0x100000000
movl $0x1, %eax
orq %rcx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x666e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::Utility::ReadBom(_IO_FILE*)
static BomType ReadBom(FILE* file) {
			char btBom[5] = { 0, };
			size_t readSize = fread(btBom, sizeof(char), 5, file);


			if (0 == readSize) {
				clearerr(file);
				fseek(file, 0, SEEK_SET);

				return BomType::ANSI;
			}

			BomInfo stBom = { 0, };
			BomType type = ReadBom(btBom, readSize, stBom);

			if (type == BomType::ANSI) { // ansi
				clearerr(file);
				fseek(file, 0, SEEK_SET);
				return BomType::ANSI;
			}

			clearerr(file);
			fseek(file, static_cast<long>(stBom.bom_size * sizeof(char)), SEEK_SET);
			return type;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movb $0x0, 0x4(%rdi)
movl $0x0, (%rdi)
movl $0x5, %r13d
movl $0x1, %esi
movl $0x5, %edx
movq %rbx, %rcx
callq 0x2270
testq %rax, %rax
je 0x673b
movq %rax, %r14
cmpq %r13, %rax
movl $0x5, %r15d
cmovbq %rax, %r15
movl $0x5, %edx
subq %r15, %rdx
xorl %r12d, %r12d
cmpq %r13, %rax
cmovaeq %r12, %rdx
leaq (%rsp,%r15), %rdi
addq $0xb, %rdi
xorl %esi, %esi
callq 0x2100
leaq 0xb(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x2130
movl $0x1, %r15d
movb $0x1, %r13b
movl $0x1, %ebp
cmpq $0x3, %r14
jb 0x6751
xorl %r12d, %r12d
leaq 0x3b98(%rip), %rax      # 0xa2b0
xorl %ecx, %ecx
movb 0x8(%rcx,%rax), %dl
cmpb 0xb(%rsp,%rcx), %dl
setne %r13b
jne 0x674c
incq %rcx
cmpq $0x3, %rcx
jne 0x671a
xorl %ebp, %ebp
movl $0x3, %r12d
jmp 0x6751
movq %rbx, %rdi
callq 0x2060
movl $0x1, %ebp
xorl %esi, %esi
jmp 0x6766
movl $0x1, %ebp
movq %rbx, %rdi
callq 0x2060
xorl %esi, %esi
testb %r13b, %r13b
cmoveq %r12, %rsi
cmovnel %r15d, %ebp
movq %rbx, %rdi
xorl %edx, %edx
callq 0x21d0
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::Utility::ReadBom(char const*, unsigned long)
static BomType ReadBom(const char* contents, size_t length) {
			char btBom[5] = { 0, };
			size_t readSize = std::min((size_t)5, length);


			if (0 == readSize) {
				return BomType::ANSI;
			}

			BomInfo stBom = { 0, };
			BomType type = ReadBom(btBom, readSize, stBom);

			if (type == BomType::ANSI) { // ansi
				return BomType::ANSI;
			}

			return type;
		}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movb $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
testq %rsi, %rsi
je 0x79ef
movq %rsi, %rbx
movl $0x5, %eax
cmpq %rax, %rsi
movl $0x5, %r14d
cmovbq %rsi, %r14
movl $0x5, %ecx
subq %r14, %rcx
xorl %edx, %edx
cmpq %rax, %rsi
cmovbq %rcx, %rdx
leaq (%rsp,%r14), %rdi
addq $0x13, %rdi
xorl %esi, %esi
callq 0x2100
leaq 0x13(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movq %r14, %rdx
callq 0x2130
movl $0x1, %eax
cmpq $0x3, %rbx
jb 0x79f4
xorl %ecx, %ecx
leaq 0x28da(%rip), %rdx      # 0xa2b0
movb 0x8(%rcx,%rdx), %sil
cmpb 0x13(%rsp,%rcx), %sil
jne 0x79f4
incq %rcx
cmpq $0x3, %rcx
jne 0x79d6
xorl %eax, %eax
jmp 0x79f4
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::UserType::AddUserTypeItem(clau_parser::UserType const&)
void AddUserTypeItem(const UserType& item) {
			UserType* temp = new UserType(item);
			temp->parent = this;

			ilist.push_back(2);

			userTypeList.push_back(temp);

			useSortedUserTypeList = false;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0xb0, %edi
callq 0x2190
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x8662
movq %r14, 0x8(%rsp)
movq %rbx, 0x28(%r14)
movl $0x2, 0x4(%rsp)
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x7fe8
movl $0x2, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x38(%rbx)
jmp 0x7ff6
leaq 0x30(%rbx), %rdi
leaq 0x4(%rsp), %rdx
callq 0x3d98
movq 0x68(%rbx), %rsi
cmpq 0x70(%rbx), %rsi
je 0x800f
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x68(%rbx)
jmp 0x801d
leaq 0x60(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0x3786
movb $0x0, 0xa9(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0xb0, %esi
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::UserType::Remove()
void Remove()
		{
			ilist = std::vector<int>();
			itemList = std::vector< ItemType<std::string> >();

			RemoveUserTypeList();

			sortedItemList.clear();
			sortedUserTypeList.clear();

			useSortedItemList = false;
			useSortedUserTypeList = false;
		}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
addq $0x30, %rdi
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq %r14, %rsi
callq 0x410e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x8155
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
xorl %eax, %eax
leaq 0x20(%rsp), %r14
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq %rsp, %rdi
movq %rax, 0x10(%rdi)
movaps %xmm0, (%rdi)
movups 0x48(%rbx), %xmm0
movq 0x58(%rbx), %rax
movaps (%r14), %xmm1
movups %xmm1, 0x48(%rbx)
movq 0x10(%r14), %rcx
movq %rcx, 0x58(%rbx)
movq 0x10(%rdi), %rcx
movq %rax, 0x10(%rdi)
movaps (%rdi), %xmm1
movaps %xmm0, (%rdi)
movaps %xmm1, (%r14)
movq %rcx, 0x10(%r14)
callq 0x40cc
movq %r14, %rdi
callq 0x40cc
movq %rbx, %rdi
callq 0x9324
movq 0x78(%rbx), %rax
cmpq %rax, 0x80(%rbx)
je 0x81c8
movq %rax, 0x80(%rbx)
movq 0x90(%rbx), %rax
cmpq %rax, 0x98(%rbx)
je 0x81df
movq %rax, 0x98(%rbx)
movw $0x0, 0xa8(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::ItemType<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator=(clau_parser::ItemType<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
ItemType<T>& operator=(const ItemType<T>& ta)
		{
			Type::operator=(ta);
			ItemType<T> temp = ta;

			data = std::move(temp.data);
			inited = temp.inited;
			return *this;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x20f0
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8f5a
leaq 0x28(%rsp), %rbx
leaq 0x28(%r14), %rdi
movq %rbx, %rsi
callq 0x2210
movb 0x20(%rbx), %al
movb %al, 0x48(%r14)
movq %r15, %rdi
callq 0x3b60
movq %r14, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::UserType::RemoveUserTypeList()
void RemoveUserTypeList() {
			for (size_t i = 0; i < userTypeList.size(); i++) {
				if (nullptr != userTypeList[i]) {
					Delete(userTypeList[i]); //
					userTypeList[i] = nullptr;
				}
			}

			userTypeList.clear();

			std::vector<int> temp;
			for (size_t i = 0; i < ilist.size(); ++i) {
				if (ilist[i] == 1)
				{
					temp.push_back(1);
				}
			}
			ilist = move(temp);

			useSortedUserTypeList = false;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rcx
cmpq %rax, %rcx
je 0x9376
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x935c
callq 0x9450
movq 0x60(%rbx), %rax
movq $0x0, (%rax,%r14,8)
incq %r14
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r14
jb 0x9342
cmpq %rax, %rcx
je 0x937f
movq %rax, 0x68(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x30(%rbx), %rax
cmpq %rax, 0x38(%rbx)
je 0x93f5
xorl %r12d, %r12d
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
cmpl $0x1, (%rax,%r12,4)
jne 0x93de
movl $0x1, 0xc(%rsp)
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x93d3
movl $0x1, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x93de
movq %r14, %rdi
movq %r15, %rdx
callq 0x3d98
incq %r12
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r12
jb 0x93a7
leaq 0x30(%rbx), %rdi
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x410e
movb $0x0, 0xa9(%rbx)
movq (%r14), %rdi
testq %rdi, %rdi
je 0x9422
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x9448
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::UserType::Delete(void*)
static BomType ReadBom(const char* contents, size_t length, BomInfo& outInfo) {
			char btBom[5] = { 0, };
			size_t testLength = length < 5 ? length : 5;
			memcpy(btBom, contents, testLength);

			size_t i, j;
			for (i = 0; i < BOM_COUNT; ++i) {
				const BomInfo& bom = bomInfo[i];

				if (bom.bom_size > testLength) {
					continue;
				}

				bool matched = true;

				for (j = 0; j < bom.bom_size; ++j) {
					if (bom.seq[j] == btBom[j]) {
						continue;
					}

					matched = false;
					break;
				}

				if (!matched) {
					continue;
				}

				outInfo = bom;

				return (BomType)i;
			}

			return BomType::ANSI;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movups %xmm0, 0x20(%rsp)
movq 0x68(%rdi), %rax
subq 0x60(%rdi), %rax
sarq $0x3, %rax
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x94a7
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsi)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x18, 0x8(%rsp)
jmp 0x94b4
movq %rsp, %rdi
leaq 0x18(%rsp), %rdx
callq 0x95be
movq 0x8(%rsp), %rsi
cmpq %rsi, (%rsp)
je 0x957b
leaq 0x20(%rsp), %r15
movq %rsp, %rbx
leaq 0x18(%rsp), %r14
movq -0x10(%rsi), %rax
cmpq -0x8(%rsi), %rax
jae 0x9527
movq -0x18(%rsi), %rax
movq -0x10(%rsi), %rcx
movq 0x60(%rax), %rax
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq 0x68(%rax), %rcx
subq 0x60(%rax), %rcx
sarq $0x3, %rcx
movq %rcx, 0x28(%rsp)
cmpq 0x10(%rsp), %rsi
je 0x9561
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsi)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x18, 0x8(%rsp)
jmp 0x956c
movq -0x18(%rsi), %rdi
movq 0x60(%rdi), %rax
cmpq %rax, 0x68(%rdi)
je 0x9539
movq %rax, 0x68(%rdi)
testq %rdi, %rdi
je 0x9544
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
leaq -0x18(%rax), %rdx
movq %rdx, 0x8(%rsp)
cmpq %rdx, %rcx
je 0x957b
incq -0x28(%rax)
jmp 0x956c
movq %rbx, %rdi
movq %r14, %rdx
callq 0x95be
movq 0x8(%rsp), %rsi
cmpq %rsi, (%rsp)
jne 0x94d0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x9591
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x959d
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x95b6
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::UserType::Reset2(clau_parser::UserType&&)
void Reset2(UserType&& ut) {
			ilist = std::move(ut.ilist);
			itemList = std::move(ut.itemList);

			//sortedItemList = std::move(ut.sortedItemList);
			//sortedUserTypeList = std::move(ut.sortedUserTypeList);

			useSortedItemList = false; // ut.useSortedItemList;
			useSortedUserTypeList = false; // ut.useSortedUserTypeList;

			userTypeList.reserve(ut.userTypeList.size());

			for (size_t i = 0; i < ut.userTypeList.size(); ++i) {
				userTypeList.push_back(std::move(ut.userTypeList[i]));
				ut.userTypeList[i] = nullptr;
				userTypeList.back()->parent = this;
			}
			ut.userTypeList.clear();


			sortedItemList.clear();
			sortedUserTypeList.clear();

			ut.sortedItemList.clear();
			ut.sortedUserTypeList.clear();
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x30, %rsi
addq $0x30, %rdi
callq 0x410e
leaq 0x48(%rbx), %rsi
leaq 0x48(%r14), %rdi
callq 0x406c
movw $0x0, 0xa8(%r14)
leaq 0x60(%r14), %r15
movq 0x68(%rbx), %rsi
subq 0x60(%rbx), %rsi
sarq $0x3, %rsi
movq %r15, %rdi
callq 0x7e86
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
cmpq %rax, %rcx
je 0x9880
xorl %r12d, %r12d
leaq (%rax,%r12,8), %rsi
movq %r15, %rdi
callq 0x90c8
movq 0x60(%rbx), %rax
movq $0x0, (%rax,%r12,8)
movq 0x68(%r14), %rax
movq -0x8(%rax), %rax
movq %r14, 0x28(%rax)
incq %r12
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r12
jb 0x9842
cmpq %rax, %rcx
je 0x9889
movq %rax, 0x68(%rbx)
movq 0x78(%r14), %rax
cmpq %rax, 0x80(%r14)
je 0x989d
movq %rax, 0x80(%r14)
movq 0x90(%r14), %rax
cmpq %rax, 0x98(%r14)
je 0x98b4
movq %rax, 0x98(%r14)
movq 0x78(%rbx), %rax
cmpq %rax, 0x80(%rbx)
je 0x98c8
movq %rax, 0x80(%rbx)
movq 0x90(%rbx), %rax
cmpq %rax, 0x98(%rbx)
je 0x98df
movq %rax, 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::UserType::_Remove()
void _Remove()
		{
			//parent = nullptr;
			ilist = std::vector<int>();
			itemList = std::vector< ItemType<std::string> >();

			sortedItemList.clear();
			sortedUserTypeList.clear();

			useSortedItemList = false;
			useSortedUserTypeList = false;
			RemoveUserTypeList();
		}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
addq $0x30, %rdi
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq %r14, %rsi
callq 0x410e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x9929
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
xorl %eax, %eax
leaq 0x20(%rsp), %r14
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq %rsp, %rdi
movq %rax, 0x10(%rdi)
movaps %xmm0, (%rdi)
movups 0x48(%rbx), %xmm0
movq 0x58(%rbx), %rax
movaps (%r14), %xmm1
movups %xmm1, 0x48(%rbx)
movq 0x10(%r14), %rcx
movq %rcx, 0x58(%rbx)
movq 0x10(%rdi), %rcx
movq %rax, 0x10(%rdi)
movaps (%rdi), %xmm1
movaps %xmm0, (%rdi)
movaps %xmm1, (%r14)
movq %rcx, 0x10(%r14)
callq 0x40cc
movq %r14, %rdi
callq 0x40cc
movq 0x78(%rbx), %rax
cmpq %rax, 0x80(%rbx)
je 0x9994
movq %rax, 0x80(%rbx)
movq 0x90(%rbx), %rax
cmpq %rax, 0x98(%rbx)
je 0x99ab
movq %rax, 0x98(%rbx)
movw $0x0, 0xa8(%rbx)
movq %rbx, %rdi
callq 0x9324
addq $0x38, %rsp
popq %rbx
popq %r14
retq