LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/hunterlxt[P]swim-membership-protocol/EmulNet.cpp
// Function: EmulNet::ENrecv(Address*, int (*)(void*, char*, int), timeval*, int, void*)
int EmulNet::ENrecv(Address *myaddr, int (* enq)(void *, char *, int), struct timeval *t, int times, void *queue){
	// times is always assumed to be 1
	int i;
	char* tmp;
	int sz;
	en_msg *emsg;

	for( i = emulnet.currbuffsize - 1; i >= 0; i-- ) {
		emsg = emulnet.buff[i];

		if ( 0 == strcmp(emsg->to.addr, myaddr->addr) ) {
			sz = emsg->size;
			tmp = (char *) malloc(sz * sizeof(char));
			memcpy(tmp, (char *)(emsg+1), sz);

			emulnet.buff[i] = emulnet.buff[emulnet.currbuffsize-1];
			emulnet.currbuffsize--;

			(*enq)(queue, (char *)tmp, sz);

			free(emsg);

			int dst = *(int *)(myaddr->addr);
			int time = par->getcurrtime();

			assert(dst <= MAX_NODES);
			assert(time < MAX_TIME);

			recv_msgs[dst][time]++;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movslq 0x1b7e4a4(%rdi), %r14
testq %r14, %r14
jle 0x40a1
movq %rsi, %r15
movq %rdi, %r12
leaq 0xdbf250(%rdi), %rax
movq %rax, (%rsp)
movq 0x1b7e4a8(%r12,%r14,8), %r13
leaq 0xa(%r13), %rdi
movq %r15, %rsi
callq 0x2240
testl %eax, %eax
jne 0x4090
movl (%r13), %eax
movslq %eax, %rbp
movq %rbp, %rdi
callq 0x2230
movq %rax, %rbx
leaq 0x10(%r13), %rsi
movq %rax, %rdi
movq %rbp, %rdx
callq 0x2120
movslq 0x1b7e4a4(%r12), %rax
leal -0x1(%rax), %ecx
movq 0x1b7e4a8(%r12,%rax,8), %rax
movq %rax, 0x1b7e4a8(%r12,%r14,8)
movl %ecx, 0x1b7e4a4(%r12)
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq *0x8(%rsp)
movq %r13, %rdi
callq 0x2200
movslq (%r15), %rbx
movq 0x8(%r12), %rdi
callq 0x5534
cmpq $0x3e9, %rbx            # imm = 0x3E9
jge 0x40d1
cmpl $0xe10, %eax            # imm = 0xE10
jge 0x40b2
cltq
imulq $0x3840, %rbx, %rcx     # imm = 0x3840
addq (%rsp), %rcx
incl (%rcx,%rax,4)
decq %r14
leaq 0x1(%r14), %rax
cmpq $0x1, %rax
ja 0x3fed
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x306b(%rip), %rdi      # 0x7124
leaq 0x3021(%rip), %rsi      # 0x70e1
leaq 0x30ac(%rip), %rcx      # 0x7173
movl $0xaa, %edx
callq 0x20e0
leaq 0x308a(%rip), %rdi      # 0x7162
leaq 0x3002(%rip), %rsi      # 0x70e1
leaq 0x308d(%rip), %rcx      # 0x7173
movl $0xa9, %edx
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/hunterlxt[P]swim-membership-protocol/Application.cpp
// Function: handler(int)
void handler(int sig) {
	void *array[10];
	size_t size;

	// get void*'s for all entries on the stack
	size = backtrace(array, 10);

	// print out all the frames to stderr
	fprintf(stderr, "Error: signal %d:\n", sig);
	backtrace_symbols_fd(array, size, STDERR_FILENO);
	exit(1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2270
movl %eax, %ebp
movq 0x6cdd(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x2f47(%rip), %rsi      # 0x724c
movl %ebx, %edx
xorl %eax, %eax
callq 0x2250
movq %r14, %rdi
movl %ebp, %esi
movl $0x2, %edx
callq 0x2290
movl $0x1, %edi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/hunterlxt[P]swim-membership-protocol/Application.cpp
// Function: main
int main(int argc, char *argv[]) {
	//signal(SIGSEGV, handler);
	if ( argc != ARGS_COUNT ) {
		cout<<"Configuration (i.e., *.conf) file File Required"<<endl;
		return FAILURE;
	}

	// Create a new application object
	Application *app = new Application(argv[1]);
	// Call the run function
	app->run();
	// When done delete the application object
	delete(app);

	return SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jne 0x4361
movq %rsi, %r14
movl $0x48, %edi
callq 0x2190
movq %rax, %rbx
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x444a
movq %rbx, %rdi
callq 0x43c8
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %eax, %eax
jmp 0x43a8
movq 0x6c68(%rip), %rbx      # 0xafd0
leaq 0x2ef0(%rip), %rsi      # 0x725f
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x48, %esi
movq %rbx, %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O3/hunterlxt[P]swim-membership-protocol/Application.cpp
// Function: Application::run()
int Application::run()
{
	int i;
	int timeWhenAllNodesHaveJoined = 0;
	// boolean indicating if all nodes have joined
	bool allNodesJoined = false;
	srand(time(NULL));

	// As time runs along
	for( par->globaltime = 0; par->globaltime < TOTAL_RUNNING_TIME; ++par->globaltime ) {
		// Run the membership protocol
		mp1Run();
		// Fail some nodes
		fail();
	}

	// Clean up
	en->ENcleanup();

	for(i=0;i<=par->EN_GPSZ-1;i++) {
		 mp1[i]->finishUpThisNode();
	}

	return SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
callq 0x2140
movl %eax, %edi
callq 0x2160
movq 0x40(%rbx), %rax
movl $0x0, 0x28(%rax)
movq %rbx, %rdi
callq 0x46c6
movq %rbx, %rdi
callq 0x4900
movq 0x40(%rbx), %rax
movl 0x28(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x28(%rax)
cmpl $0x2bb, %ecx            # imm = 0x2BB
jl 0x43e8
movq 0x28(%rbx), %rdi
callq 0x40f0
movq 0x40(%rbx), %rax
cmpl $0x0, 0x18(%rax)
jle 0x4440
xorl %r14d, %r14d
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x27de
incq %r14
movq 0x40(%rbx), %rax
movslq 0x18(%rax), %rax
cmpq %rax, %r14
jl 0x4423
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/hunterlxt[P]swim-membership-protocol/Application.cpp
// Function: Application::~Application()
Application::~Application() {
	delete log;
	delete en;
	for ( int i = 0; i < par->EN_GPSZ; i++ ) {
		delete mp1[i];
	}
	free(mp1);
	delete par;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x66f2(%rip), %rax      # 0xad30
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x4650
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x465f
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x40(%rbx), %rax
cmpl $0x0, 0x18(%rax)
jle 0x468f
xorl %r14d, %r14d
movq 0x38(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x4683
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x40(%rbx), %rax
incq %r14
movslq 0x18(%rax), %rcx
cmpq %rcx, %r14
jl 0x466c
movq 0x38(%rbx), %rdi
callq 0x2200
movq 0x40(%rbx), %rdi
movl $0x38, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x492d
callq 0x5534
movq 0x40(%rbx), %rdi
cmpl $0x32, %eax
jne 0x492d
movl $0x1, 0x24(%rdi)
cmpl $0x0, 0x4(%rdi)
je 0x4995
callq 0x5534
cmpl $0x64, %eax
jne 0x4991
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 0x5534
leaq 0x2963(%rip), %rdx      # 0x72d0
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %ecx
xorl %eax, %eax
callq 0x502c
movq 0x38(%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x20(%rax), %rax
movb $0x1, 0x10(%rax)
jmp 0x4a1e
movq 0x40(%rbx), %rdi
callq 0x5534
cmpl $0x64, %eax
jne 0x4a1e
callq 0x2050
movq 0x40(%rbx), %rdi
movl 0x18(%rdi), %ecx
cltd
idivl %ecx
cmpl $0x2, %ecx
jl 0x4a1e
movl %edx, %ebp
shrl $0x1f, %ebp
addl %edx, %ebp
sarl %ebp
movslq %ebp, %r13
movq 0x38(%rbx), %rax
leaq 0x291d(%rip), %r14      # 0x72e7
movq 0x30(%rbx), %r15
movq (%rax,%r13,8), %rax
movq 0x20(%rax), %r12
addq $0x8, %r12
callq 0x5534
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %eax, %ecx
xorl %eax, %eax
callq 0x502c
movq 0x38(%rbx), %rax
movq (%rax,%r13,8), %rcx
movq 0x20(%rcx), %rcx
movb $0x1, 0x10(%rcx)
incq %r13
movq 0x40(%rbx), %rdi
movl 0x18(%rdi), %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
addl %ebp, %edx
movslq %edx, %rcx
cmpq %rcx, %r13
jl 0x49ca
movq 0x40(%rbx), %rdi
cmpl $0x0, 0x20(%rdi)
je 0x4a3f
callq 0x5534
cmpl $0x12c, %eax            # imm = 0x12C
jne 0x4a3f
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_O3/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 0x2004(%rip), %rsi      # 0x7491
movq %rax, %rdi
callq 0x21f0
movq %rax, %r14
leaq 0x1ff4(%rip), %rsi      # 0x7493
xorl %ebp, %ebp
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x22f0
leaq 0x4(%rbx), %rdx
leaq 0x1fe6(%rip), %rsi      # 0x749f
movq %r14, %rdi
xorl %eax, %eax
callq 0x22f0
leaq 0x20(%rbx), %rdx
leaq 0x1fe5(%rip), %rsi      # 0x74b3
movq %r14, %rdi
xorl %eax, %eax
callq 0x22f0
leaq 0x8(%rbx), %rdx
leaq 0x1fde(%rip), %rsi      # 0x74c1
movq %r14, %rdi
xorl %eax, %eax
callq 0x22f0
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 0x5525
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_O3/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 0x51e5
xorl %r15d, %r15d
movabsq $0x6db6db6db6db6db7, %r12 # imm = 0x6DB6DB6DB6DB6DB7
xorl %r13d, %r13d
addq %r15, %rsi
movq %rbx, %rdi
callq 0x5f16
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 0x51bc
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5e20
movq %r14, %rdi
callq 0x4470
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %rsi, %r14
movq (%rdi), %r13
movq 0x8(%rdi), %rax
subq %r13, %rax
je 0x5275
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %rbp # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rbp
movq (%r14), %rbx
movq 0x8(%r14), %r15
cmpq $0x1, %rbp
adcq $0x0, %rbp
addq $0x8, %r13
xorl %r12d, %r12d
cmpq %r15, (%r13)
jne 0x5269
testq %r15, %r15
je 0x52be
movq -0x8(%r13), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x42d0
testl %eax, %eax
je 0x52be
incq %r12
addq $0x38, %r13
cmpq %r12, %rbp
jne 0x524b
movl $0x28, %edi
callq 0x4170
movq %rax, %rbx
leaq 0xfe8f(%rip), %rsi      # 0x15118
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x5bb7
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5c40
xorl %ebp, %ebp
leaq 0x18801(%rip), %rsi     # 0x1dab0
leaq 0xa1c(%rip), %rdx       # 0x5cd2
movq %rbx, %rdi
callq 0x4460
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52ee
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42b0
testb %bpl, %bpl
jne 0x52f8
jmp 0x5300
movq %rax, %r14
movq %rbx, %rdi
callq 0x4210
movq %r14, %rdi
callq 0x4470
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x3b5a(%rip)      # 0x7170
jne 0x3685
movl %esi, %ebp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2200
leaq 0x1b4c(%rip), %rsi      # 0x517a
movl $0x2, %edx
movq %r14, %rdi
callq 0x21e0
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0x2250
leaq 0x1b31(%rip), %rsi      # 0x517f
movl $0x1, %edx
movq %rax, %rdi
callq 0x21e0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2230
movq 0x3951(%rip), %rsi      # 0x6fc0
leaq 0x8(%rsp), %rdi
callq 0x20f0
leaq 0x78(%rsp), %rdi
callq 0x2080
jmp 0x369e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1a71(%rip), %rdx      # 0x5104
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x3804
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x3909(%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_O3/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, 0x3a88(%rip)      # 0x7170
jne 0x3757
movl %esi, %ebp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2200
leaq 0x1a7a(%rip), %rsi      # 0x517a
movl $0x2, %edx
movq %r14, %rdi
callq 0x21e0
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0x2250
leaq 0x1a8b(%rip), %rsi      # 0x51ab
movl $0x1, %edx
movq %rax, %rdi
callq 0x21e0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2230
movq 0x387f(%rip), %rsi      # 0x6fc0
leaq 0x8(%rsp), %rdi
callq 0x20f0
leaq 0x78(%rsp), %rdi
callq 0x2080
jmp 0x3770
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x199f(%rip), %rdx      # 0x5104
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x3804
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x3837(%rip), %rsi      # 0x6fc0
leaq 0x8(%rsp), %rdi
callq 0x20f0
leaq 0x78(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3a7e
movb %cl, (%r14,%rax)
movb 0x1(%rdi,%rax), %cl
incq %rax
testb %cl, %cl
jne 0x3a69
cmpq $0x63, %rax
ja 0x3a96
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 0x3ab3
incq %r12
movb %cl, (%r14,%rax)
incq %rax
movb (%r12), %cl
incq %r12
testb %cl, %cl
jne 0x3aa1
cmpq $0x7f, %rax
ja 0x3ad1
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 0x3af6
movq (%r15), %rsi
leaq (%r14,%rax), %rdi
xorl %edx, %edx
movb (%rsi,%rdx), %r8b
movb %r8b, (%rdi,%rdx)
incq %rdx
cmpq %rdx, %rcx
jne 0x3ae3
addq %rdx, %rax
subq %rax, %rbx
jbe 0x3b16
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_O3/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 0x3297(%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 0x3da3
xorl %ebx, %ebx
movq 0x3262(%rip), %r12      # 0x6fc8
leaq 0x140b(%rip), %r13      # 0x5178
leaq 0x7(%rsp), %rbp
movb (%r15,%rbx), %al
testb %al, %al
je 0x3d8b
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %r12, %rdi
movq %rbp, %rsi
jmp 0x3d96
movl $0x1, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x21e0
incq %rbx
cmpq %rbx, %r14
jne 0x3d72
movq 0x321e(%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
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2ff5
addq $-0x8, %rax
movq %rax, 0x18(%rbx)
jmp 0x30b8
movl $0xb0, %edi
callq 0x2190
movq %rax, %r14
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7127(%rip), %rsi      # 0xa139
leaq 0x7121(%rip), %rdx      # 0xa13a
leaq 0x10(%rsp), %rdi
callq 0x8698
leaq 0xac9e(%rip), %rax      # 0xdcc8
movq %rax, (%r14)
leaq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
movq 0x10(%rsp), %rcx
cmpq %r15, %rcx
je 0x304e
movq %rcx, 0x8(%r14)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%r14)
jmp 0x3055
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%r14)
leaq 0xac83(%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 0x414c
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi
je 0x30a0
movq %r14, (%rsi)
addq $0x8, 0x18(%rbx)
jmp 0x30b4
leaq 0x10(%rbx), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0x3758
movq (%r14), %r14
movq %r14, 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 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3112
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq -0x8(%rax), %rdi
callq 0x414c
movq $0x0, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x8, %edi
callq 0x20d0
leaq 0x7018(%rip), %rcx      # 0xa13b
movq %rcx, (%rax)
movq 0xae93(%rip), %rsi      # 0xdfc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0xb0, %edi
callq 0x2190
movq %rax, %r15
leaq 0x18(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rbx), %rdx
leaq 0x18(%rbx), %rax
cmpq %rax, %rdx
je 0x3ef2
movq %rdx, 0x8(%r15)
movq (%rax), %rcx
movq %rcx, 0x18(%r15)
jmp 0x3ef8
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 0x9dd1(%rip), %rax      # 0xdce8
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r15)
movups %xmm0, 0x40(%r15)
movups %xmm0, 0x50(%r15)
movups %xmm0, 0x60(%r15)
movups %xmm0, 0x70(%r15)
movups %xmm0, 0x80(%r15)
movups %xmm0, 0x90(%r15)
movups %xmm0, 0x9a(%r15)
movq %r15, 0x8(%rsp)
movq %r14, 0x28(%r15)
movl $0x2, 0x10(%rsp)
movq 0x38(%r14), %rsi
cmpq 0x40(%r14), %rsi
je 0x3f79
movl $0x2, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x38(%r14)
jmp 0x3f87
leaq 0x30(%r14), %rdi
leaq 0x10(%rsp), %rdx
callq 0x3d78
movq 0x68(%r14), %rsi
cmpq 0x70(%r14), %rsi
je 0x3f9b
movq %r15, (%rsi)
addq $0x8, 0x68(%r14)
jmp 0x3faf
leaq 0x60(%r14), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x3758
movq (%r15), %r15
movw $0x0, 0xa8(%r14)
movq 0x58(%r15), %rax
movups 0x48(%rbx), %xmm0
movups 0x48(%r15), %xmm1
movups %xmm0, 0x48(%r15)
movq 0x58(%rbx), %rcx
movq %rcx, 0x58(%r15)
leaq 0x10(%rsp), %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
movq $0x0, 0x58(%rbx)
callq 0x4094
leaq 0x30(%rbx), %rsi
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0x40dc
leaq 0x60(%rbx), %rsi
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
callq 0x4114
movq 0x60(%rbx), %rax
cmpq %rax, 0x68(%rbx)
je 0x4042
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 0x4023
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rcx
movq 0x68(%rax), %rdx
subq %rcx, %rdx
je 0x4072
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 0x4062
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4170
movq %rax, (%rsi)
addq $0x8, 0x68(%rbx)
jmp 0x417e
leaq 0x60(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0x3758
movl $0x2, 0x4(%rsp)
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x41a0
movl $0x2, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x38(%rbx)
jmp 0x41ae
leaq 0x30(%rbx), %rdi
leaq 0x4(%rsp), %rdx
callq 0x3d78
movq 0x8(%rsp), %rax
movq %rbx, 0x28(%rax)
movb $0x0, 0xa9(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4c75
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x9414
movq %r14, %rdi
movq %rbx, %rsi
callq 0x98de
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x3877
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4cc0
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 0x6354
jmp 0x4cdb
movq 0x10(%rdi), %rsi
movq (%rsi), %r10
movq 0x8(%rsi), %rsi
movzbl 0x8(%rdi), %r11d
movq %r10, %rdi
pushq %r11
pushq %rax
callq 0x64b6
addq $0x10, %rsp
shrq $0x20, %rax
testl %eax, %eax
setg %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6409
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 0x21c0
movq %rbx, %rdi
callq 0x2030
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21c0
movq %rbx, %rdi
callq 0x65d6
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 0x2260
movb $0x0, (%r14,%r13)
cmpl $0x1, %ebp
jne 0x640f
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movq %r13, %rsi
callq 0x66ac
jmp 0x642f
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x647b
movzbl 0x80(%rsp), %r9d
leaq 0x10(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %r14, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x6ac4
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 0x646c
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 0x648f
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x64ae
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6524
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 0x7abe
leaq -0x3(%rbx), %r13
testl %eax, %eax
cmovneq %rbx, %r13
movb %r14b, (%r12,%r13)
cmpl $0x1, %ebp
jne 0x652a
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %r12, %rdi
movq %r13, %rsi
callq 0x66ac
jmp 0x654a
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x659d
movzbl 0x88(%rsp), %r9d
leaq 0x10(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %r12, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x6ac4
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 0x658e
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 0x65ce
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movb $0x0, 0x4(%rdi)
movl $0x0, (%rdi)
movl $0x5, %r12d
movl $0x1, %esi
movl $0x5, %edx
movq %rbx, %rcx
callq 0x2260
movl $0x1, %ebp
testq %rax, %rax
je 0x665e
movq %rax, %r14
cmpq %r12, %rax
movl $0x5, %r15d
cmovbq %rax, %r15
movl $0x5, %eax
subq %r15, %rax
xorl %edx, %edx
cmpq %r12, %r14
cmovbq %rax, %rdx
leaq (%rsp,%r15), %rdi
addq $0x3, %rdi
xorl %esi, %esi
callq 0x2100
leaq 0x3(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x2130
cmpq $0x3, %r14
jae 0x6685
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x2060
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x21c0
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
leaq 0x3c22(%rip), %rcx      # 0xa2b0
movb 0x8(%rax,%rcx), %dl
cmpb 0x3(%rsp,%rax), %dl
jne 0x665e
incq %rax
cmpq $0x3, %rax
jne 0x668e
xorl %ebp, %ebp
movl $0x3, %r14d
jmp 0x6661
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7b4b
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 0x7b50
xorl %ecx, %ecx
leaq 0x277e(%rip), %rdx      # 0xa2b0
movb 0x8(%rcx,%rdx), %sil
cmpb 0x13(%rsp,%rcx), %sil
jne 0x7b50
incq %rcx
cmpq $0x3, %rcx
jne 0x7b32
xorl %eax, %eax
jmp 0x7b50
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x872e
movq %r14, 0x8(%rsp)
movq %rbx, 0x28(%r14)
movl $0x2, 0x4(%rsp)
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x814a
movl $0x2, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x38(%rbx)
jmp 0x8158
leaq 0x30(%rbx), %rdi
leaq 0x4(%rsp), %rdx
callq 0x3d78
movq 0x68(%rbx), %rsi
cmpq 0x70(%rbx), %rsi
je 0x816c
movq %r14, (%rsi)
addq $0x8, 0x68(%rbx)
jmp 0x817a
leaq 0x60(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0x3758
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 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x30(%rdi), %rdi
movq 0x40(%rbx), %rsi
xorps %xmm1, %xmm1
movups %xmm1, 0x30(%rbx)
movq $0x0, 0x40(%rbx)
testq %rdi, %rdi
je 0x8223
subq %rdi, %rsi
callq 0x21a0
xorps %xmm1, %xmm1
movq 0x58(%rbx), %rax
movups 0x48(%rbx), %xmm0
movups %xmm1, 0x48(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x58(%rbx)
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
movq %rax, 0x10(%rdi)
movq %rsp, %r14
movaps %xmm1, (%r14)
movq %rcx, 0x10(%r14)
callq 0x4094
movq %r14, %rdi
callq 0x4094
movq %rbx, %rdi
callq 0x9414
movq 0x78(%rbx), %rax
cmpq %rax, 0x80(%rbx)
je 0x8275
movq %rax, 0x80(%rbx)
movq 0x90(%rbx), %rax
cmpq %rax, 0x98(%rbx)
je 0x828c
movq %rax, 0x98(%rbx)
movw $0x0, 0xa8(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x903c
leaq 0x28(%rsp), %rbx
leaq 0x28(%r14), %rdi
movq %rbx, %rsi
callq 0x2200
movb 0x20(%rbx), %al
movb %al, 0x48(%r14)
movq %r15, %rdi
callq 0x3b3a
movq %r14, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9466
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x9454
callq 0x9572
movq 0x60(%rbx), %rax
movq $0x0, (%rax,%r14,8)
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
incq %r14
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r14
jb 0x9432
cmpq %rax, %rcx
je 0x946f
movq %rax, 0x68(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rax
cmpq %rdi, %rax
je 0x94f3
xorl %r12d, %r12d
movq %rsp, %r14
leaq 0x24(%rsp), %r15
cmpl $0x1, (%rdi,%r12,4)
jne 0x94d6
movl $0x1, 0x24(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x94c3
movl $0x1, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x94d6
movq %r14, %rdi
movq %r15, %rdx
callq 0x3d78
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rax
incq %r12
movq %rax, %rcx
subq %rdi, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r12
jb 0x9497
movaps (%rsp), %xmm0
movq 0x10(%rsp), %rax
jmp 0x94f5
xorl %eax, %eax
movq 0x40(%rbx), %rsi
movups %xmm0, 0x30(%rbx)
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testq %rdi, %rdi
je 0x953d
subq %rdi, %rsi
callq 0x21a0
movq (%rsp), %rdi
movb $0x0, 0xa9(%rbx)
testq %rdi, %rdi
je 0x9544
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
jmp 0x9544
movb $0x0, 0xa9(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x9569
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x38, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
leaq 0x20(%rsp), %rdx
movq %rdi, (%rdx)
movq %rcx, 0x8(%rdx)
movq 0x68(%rdi), %rcx
subq 0x60(%rdi), %rcx
sarq $0x3, %rcx
movq %rcx, 0x10(%rdx)
movq %rax, %rdi
xorl %esi, %esi
callq 0x96b4
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
cmpq %rsi, %rdi
je 0x9677
movq %rsp, %rbx
leaq 0x20(%rsp), %r14
movq -0x10(%rsi), %rax
cmpq -0x8(%rsi), %rax
jae 0x9625
movq -0x18(%rsi), %rcx
movq 0x60(%rcx), %rcx
movq (%rcx,%rax,8), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x68(%rax), %rcx
subq 0x60(%rax), %rcx
sarq $0x3, %rcx
movq %rcx, 0x30(%rsp)
cmpq 0x10(%rsp), %rsi
je 0x965a
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsi)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x966a
movq -0x18(%rsi), %rdi
movq 0x60(%rdi), %rax
cmpq %rax, 0x68(%rdi)
je 0x9637
movq %rax, 0x68(%rdi)
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
leaq -0x18(%rax), %rsi
movq %rsi, 0x8(%rsp)
cmpq %rsi, %rdi
je 0x9677
incq -0x28(%rax)
jmp 0x966a
movq %rbx, %rdi
movq %r14, %rdx
callq 0x96b4
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
cmpq %rsi, %rdi
jne 0x95c8
testq %rdi, %rdi
je 0x9689
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x9693
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x96ac
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x30, %rsi
addq $0x30, %rdi
callq 0x40dc
movq 0x58(%r14), %rax
movups 0x48(%rbx), %xmm0
movups 0x48(%r14), %xmm1
movups %xmm0, 0x48(%r14)
movq 0x58(%rbx), %rcx
movq %rcx, 0x58(%r14)
movq %rsp, %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
movq $0x0, 0x58(%rbx)
callq 0x4094
movw $0x0, 0xa8(%r14)
leaq 0x60(%r14), %r15
movq 0x68(%rbx), %rsi
subq 0x60(%rbx), %rsi
sarq $0x3, %rsi
movq %r15, %rdi
callq 0x7fe2
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
cmpq %rax, %rcx
je 0x99a4
xorl %r12d, %r12d
leaq (%rax,%r12,8), %rsi
movq %r15, %rdi
callq 0x91aa
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 0x9966
cmpq %rax, %rcx
je 0x99ad
movq %rax, 0x68(%rbx)
movq 0x78(%r14), %rax
cmpq %rax, 0x80(%r14)
je 0x99c1
movq %rax, 0x80(%r14)
movq 0x90(%r14), %rax
cmpq %rax, 0x98(%r14)
je 0x99d8
movq %rax, 0x98(%r14)
movq 0x78(%rbx), %rax
cmpq %rax, 0x80(%rbx)
je 0x99ec
movq %rax, 0x80(%rbx)
movq 0x90(%rbx), %rax
cmpq %rax, 0x98(%rbx)
je 0x9a03
movq %rax, 0x98(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x30(%rdi), %rdi
movq 0x40(%rbx), %rsi
xorps %xmm1, %xmm1
movups %xmm1, 0x30(%rbx)
movq $0x0, 0x40(%rbx)
testq %rdi, %rdi
je 0x9a41
subq %rdi, %rsi
callq 0x21a0
xorps %xmm1, %xmm1
movq 0x58(%rbx), %rax
movups 0x48(%rbx), %xmm0
movups %xmm1, 0x48(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x58(%rbx)
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
movq %rax, 0x10(%rdi)
movq %rsp, %r14
movaps %xmm1, (%r14)
movq %rcx, 0x10(%r14)
callq 0x4094
movq %r14, %rdi
callq 0x4094
movq 0x78(%rbx), %rax
cmpq %rax, 0x80(%rbx)
je 0x9a8b
movq %rax, 0x80(%rbx)
movq 0x90(%rbx), %rax
cmpq %rax, 0x98(%rbx)
je 0x9aa2
movq %rax, 0x98(%rbx)
movw $0x0, 0xa8(%rbx)
movq %rbx, %rdi
callq 0x9414
addq $0x38, %rsp
popq %rbx
popq %r14
retq