LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/agentpns.h
// Function: Morat::Pentago::AgentPNS::AgentPNS()
AgentPNS() : pool(this) {
		ab = 1;
		df = true;
		epsilon = 0.25;
		ties = Side::NONE;
		numthreads = 1;
		pool.set_num_threads(numthreads);
		gclimit = 5;

		nodes = 0;
		reset();

		set_memlimit(1000*1024*1024);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
callq 0xe9fa
leaq 0x18667(%rip), %rax     # 0x30c48
leaq 0x50(%r15), %rbx
movq %rbx, %rdi
addq $0x10, %rax
movq %rax, (%r15)
callq 0x18da4
leaq 0x1410(%r15), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x18e02
leaq 0xc604(%rip), %rax      # 0x24c11
leaq 0x1520(%r15), %r12
movb (%rax), %al
movw $0xefc, 0x1532(%r15)    # imm = 0xEFC
andq $0x0, 0x1538(%r15)
pushq $0x1
popq %rsi
movl %esi, 0x1508(%r15)
movb $0x1, 0x150c(%r15)
movl $0x3e800000, 0x1510(%r15) # imm = 0x3E800000
movb %al, 0x1514(%r15)
movl %esi, 0x1518(%r15)
movq %r14, %rdi
callq 0x14b22
movl $0x5, 0x48(%r15)
andq $0x0, 0x38(%r15)
andq $0x0, 0x14f8(%r15)
movb $0x0, 0x8(%r15)
movq (%r15), %rax
movl $0x3e800000, %esi       # imm = 0x3E800000
movq %r15, %rdi
callq *0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x186a7
movq %r12, %rdi
movq %rax, %r15
callq 0x13ef6
movq %r14, %rdi
callq 0x15040
movq %rbx, %rdi
callq 0x1507e
movq %r15, %rdi
callq 0x5690
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/agentab.h
// Function: Morat::Pentago::AgentAB::AgentAB()
AgentAB() {
		maxdepth = 0;
		nodes_seen = 0;
		time_used = 0;
		TT = NULL;
		set_memlimit(100*1024*1024);

		randomness = 2;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xe9fa
leaq 0x181e8(%rip), %rax     # 0x308b0
leaq 0x68(%rbx), %rdi
xorl %esi, %esi
addq $0x10, %rax
movq %rax, (%rbx)
callq 0x112f6
vxorps %xmm0, %xmm0, %xmm0
andl $0x0, 0x50(%rbx)
andq $0x0, 0x38(%rbx)
movl $0x6400000, %esi        # imm = 0x6400000
movq %rbx, %rdi
vmovups %xmm0, 0x58(%rbx)
movq (%rbx), %rax
callq *0x30(%rax)
movl $0x2, 0x6c(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/CDISC2020[P]Projet_satellite_agile/src/communication/comGroundManager.cpp
// Function: getdir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
int getdir (string dir, vector<string> &files)
{
    DIR *dp;
    struct dirent *dirp;
    if((dp  = opendir(dir.c_str())) == NULL)
    {
        cout << "Error(" << errno << ") opening " << dir << endl;
        return errno;
    }

    while ((dirp = readdir(dp)) != NULL)
    {
        files.push_back(string(dirp->d_name));
    }
    closedir(dp);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x2370
testq %rax, %rax
je 0x2f4d
movq %rax, %r14
leaq -0x48(%rbp), %r15
leaq -0x21(%rbp), %r12
movq %r14, %rdi
callq 0x2380
testq %rax, %rax
je 0x2f41
addq $0x13, %rax
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x2100
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3c48
movq %r15, %rdi
callq 0x2150
jmp 0x2f0d
movq %r14, %rdi
callq 0x23b0
xorl %eax, %eax
jmp 0x2f9a
movq 0x4084(%rip), %rdi      # 0x6fd8
leaq 0x12ef(%rip), %rsi      # 0x424a
callq 0x2260
movq %rax, %rbx
callq 0x2030
movq %rax, %r14
movl (%rax), %esi
movq %rbx, %rdi
callq 0x2400
leaq 0x12d5(%rip), %rsi      # 0x4251
movq %rax, %rdi
callq 0x2260
movq %rax, %rdi
movq %r15, %rsi
callq 0x2200
movq %rax, %rdi
callq 0x2160
movl (%r14), %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2420
// File: /workspace/github_cpp_makefile_star2_O2/CDISC2020[P]Projet_satellite_agile/src/communication/comGroundManager.cpp
// Function: tryFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool tryFile (string file_dir, string file_name)
{
	string path = file_dir + file_name;
	fstream filestr;
 	filestr.open(path.c_str());

	if (filestr.is_open())
	{
    		filestr.close();
		return true;
  	}
	else
	{
		cout << "Error to open file" << endl;
		Status S;
		S.errorID = 9; // A changer.
		sprintf(S.description, "File corrupted");
		string str(S.description);
		sm.newNotification(S.errorID, str);
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x300, %rsp            # imm = 0x300
movq %rsi, %rdx
movq %rdi, %rsi
leaq -0x78(%rbp), %rdi
callq 0x3bc8
leaq -0x310(%rbp), %rdi
callq 0x22a0
movq -0x78(%rbp), %rsi
leaq -0x310(%rbp), %rdi
pushq $0x18
popq %rdx
callq 0x2210
leaq -0x290(%rbp), %rdi
callq 0x20b0
movl %eax, %ebx
testb %al, %al
je 0x301a
leaq -0x310(%rbp), %rdi
callq 0x2060
jmp 0x30a4
movq 0x3fb7(%rip), %rdi      # 0x6fd8
leaq 0x1234(%rip), %rsi      # 0x425c
callq 0x2260
movq %rax, %rdi
callq 0x2160
leaq -0xf8(%rbp), %rsi
movl $0x9, -0x4(%rsi)
movabsq $0x726f6320656c6946, %rax # imm = 0x726F6320656C6946
movq %rax, (%rsi)
movabsq $0x64657470757272, %rax # imm = 0x64657470757272
movq %rax, 0x7(%rsi)
leaq -0x58(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x2100
movl -0xfc(%rbp), %r14d
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2310
leaq 0x41ea(%rip), %rdi      # 0x7270
leaq -0x38(%rbp), %rdx
movl %r14d, %esi
callq 0x2d96
leaq -0x38(%rbp), %rdi
callq 0x2150
leaq -0x58(%rbp), %rdi
callq 0x2150
leaq -0x310(%rbp), %rdi
callq 0x20a0
leaq -0x78(%rbp), %rdi
callq 0x2150
movl %ebx, %eax
addq $0x300, %rsp            # imm = 0x300
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2150
jmp 0x30d8
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2150
jmp 0x30ed
jmp 0x30ea
movq %rax, %rbx
jmp 0x30f9
movq %rax, %rbx
leaq -0x310(%rbp), %rdi
callq 0x20a0
leaq -0x78(%rbp), %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2420
// File: /workspace/github_cpp_makefile_star2_O2/CDISC2020[P]Projet_satellite_agile/src/communication/comGroundManager.cpp
// Function: Communic_Interne(void*)
void* Communic_Interne(void* args)
{
	QueuingPort channelIn(1, 18003, s); 		// Server
	usleep(500000);
	channelIn.Display();
	usleep(300000);

	while(1)
	{
		channelIn.RecvQueuingMsg(buffer);

		status = (Status*)buffer;

 		/**************[ PM ---IMG---> CGM ]**************/
		// Remplir le tableau avec des photos prises
		if (status->code == 3)		// utilisation d'un type p
		{
			imageName = (PlanFilePath*)buffer;
			string aux(imageName->filepath);
			imageList[ptImageReceived] = aux;
			ptImageReceived = (ptImageReceived + 1)%128;
		}

 		/**************[ PM ---LOG---> CGM ]**************/
		// Plan manager --> Comunication Manager
		// Error identifier and description
		else if(status->code == 4)
		{
			string str(status->description);
			sm.newNotification(status->errorID, str);
		}

		/*************[ FDIR ---MODE---> CGM ]*************/
		// changement mode primary ou backup
		else if(status->code == 6)
		{
			m = (ModeStruct*)buffer;
			mode = m->rpiMode;
		}

		usleep(100);
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x518, %rsp            # imm = 0x518
leaq 0x4b14(%rip), %rcx      # 0x82c0
leaq -0x538(%rbp), %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
movl $0x4653, %edx           # imm = 0x4653
callq 0x270e
movl $0x7a120, %edi          # imm = 0x7A120
callq 0x2320
movq %rbx, %rdi
callq 0x2a72
movl $0x493e0, %edi          # imm = 0x493E0
leaq 0x4b4f(%rip), %r14      # 0x8330
pushq $0x64
popq %r15
leaq -0x50(%rbp), %r12
leaq -0x70(%rbp), %r13
callq 0x2320
leaq -0x538(%rbp), %rdi
movq %r14, %rsi
callq 0x292a
movq %r14, 0x3a88(%rip)      # 0x7290
movl 0x4b22(%rip), %eax      # 0x8330
cmpl $0x6, %eax
je 0x38c4
cmpl $0x4, %eax
je 0x3873
movl %r15d, %edi
cmpl $0x3, %eax
jne 0x37ed
movq %r14, 0x3a7d(%rip)      # 0x72a8
movq %r12, %rdi
leaq 0x4aff(%rip), %rsi      # 0x8334
leaq -0x29(%rbp), %rdx
callq 0x2100
movslq 0x4a6b(%rip), %rdi      # 0x82b0
shlq $0x5, %rdi
leaq 0x3a60(%rip), %rax      # 0x72b0
addq %rax, %rdi
movq %r12, %rsi
callq 0x2180
movl 0x4a4f(%rip), %eax      # 0x82b0
incl %eax
cltd
movl $0x80, %ecx
idivl %ecx
movl %edx, 0x4a3f(%rip)      # 0x82b0
jmp 0x38b4
movq %r12, %rdi
leaq 0x4abb(%rip), %rsi      # 0x8338
leaq -0x29(%rbp), %rdx
callq 0x2100
movq 0x3a03(%rip), %rax      # 0x7290
movl 0x4(%rax), %ebx
movq %r13, %rdi
movq %r12, %rsi
callq 0x2310
leaq 0x39ce(%rip), %rdi      # 0x7270
movl %ebx, %esi
movq %r13, %rdx
callq 0x2d96
movq %r13, %rdi
callq 0x2150
movq %r12, %rdi
callq 0x2150
movl %r15d, %edi
jmp 0x37ed
movq %r14, 0x39d5(%rip)      # 0x72a0
movb 0x4a63(%rip), %al       # 0x8334
movb %al, 0x49e1(%rip)       # 0x82b8
movl %r15d, %edi
jmp 0x37ed
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x2150
jmp 0x38f2
jmp 0x38ef
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2150
jmp 0x3902
jmp 0x38ff
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2420
// File: /workspace/github_cpp_makefile_star2_O2/CDISC2020[P]Projet_satellite_agile/src/communication/comGroundManager.cpp
// Function: am_alive(void*)
void* am_alive(void* args)
{
	QueuingPort channelFDIR(0, 18002, s); // Client FDIR
	usleep(500000);
	channelFDIR.Display();

	char str[2]="C";
	while (1) 
	{
		if(wtc == 1)
		{
			channelFDIR.SendQueuingMsg(str, sizeof(str));
			wtc = 0;
		}
		usleep(10*1000); //10 ms
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x4d8, %rsp            # imm = 0x4D8
leaq 0x499f(%rip), %rcx      # 0x82c0
leaq -0x4e8(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x4652, %edx           # imm = 0x4652
callq 0x270e
movl $0x7a120, %edi          # imm = 0x7A120
callq 0x2320
movq %rbx, %rdi
callq 0x2a72
leaq -0x1a(%rbp), %r14
movw $0x43, (%r14)
pushq $0x2
popq %r15
cmpl $0x1, 0x4e36(%rip)      # 0x8794
jne 0x3975
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x28e2
andl $0x0, 0x4e1f(%rip)      # 0x8794
movl $0x2710, %edi           # imm = 0x2710
callq 0x2320
jmp 0x3957
// File: /workspace/github_cpp_makefile_star2_O2/thunlp[P]KB2E/TransR/Train_TransR.cpp
// Function: Train::norm(std::vector<double, std::allocator<double>>&)
void norm(vector<double> &a)
    {
        double x = vec_len(a);
        if (x>1)
        for (int ii=0; ii<a.size(); ii++)
                a[ii]/=x;
    }

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x28dc
ucomisd 0x2ec6(%rip), %xmm0     # 0x7020
jbe 0x4184
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x4184
movsd (%rax,%rdx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rdx,8)
incq %rdx
jmp 0x416c
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/thunlp[P]KB2E/TransR/Train_TransR.cpp
// Function: Train::train_kb(int, int, int, int, int, int)
void train_kb(int e1_a,int e2_a,int rel_a,int e1_b,int e2_b,int rel_b)
    {
        double sum1 = calc_sum(e1_a,e2_a,rel_a,1);
        double sum2 = calc_sum(e1_b,e2_b,rel_b,1);
        if (sum1+margin>sum2)
        {
        	res+=margin+sum1-sum2;
        	gradient( e1_a, e2_a, rel_a, e1_b, e2_b, rel_b);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movl %r8d, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r13
movl 0x50(%rsp), %ebx
pushq $0x1
popq %r8
movl %ecx, 0x4(%rsp)
callq 0x5874
movsd %xmm0, 0x10(%rsp)
movq %r13, %rdi
movl %r14d, 0x8(%rsp)
movl %r14d, %esi
movl %ebp, 0xc(%rsp)
movl %ebp, %edx
movl %ebx, %ecx
pushq $0x1
popq %r8
callq 0x5874
movsd 0x10(%rsp), %xmm1
addsd 0x50(%r13), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x50a4
subsd %xmm0, %xmm1
addsd 0x40(%r13), %xmm1
movsd %xmm1, 0x40(%r13)
movq %r13, %rdi
movl %r12d, %esi
movl %r15d, %edx
movl 0x4(%rsp), %ecx
movl 0x8(%rsp), %r8d
movl 0xc(%rsp), %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5a72
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/thunlp[P]KB2E/TransR/Train_TransR.cpp
// Function: Train::norm(std::vector<double, std::allocator<double>>&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
void norm(vector<double> &a, vector<vector<double> > &A)
    {
    	while (true)
    	{
		    double x=0;
		    for (int ii=0; ii<m; ii++)
		    {
		        double tmp = 0;
		        for (int jj=0; jj<n; jj++)
		            tmp+=A[jj][ii]*a[jj];
		        x+=sqr(tmp);
		    }
		    if (x>1)
		    {
		        double lambda=1;
		        for (int ii=0; ii<m; ii++)
		        {
		            double tmp = 0;
		            for (int jj=0; jj<n; jj++)
		                tmp+=A[jj][ii]*a[jj];
		            tmp*=2;
		            for (int jj=0; jj<n; jj++)
		            {
		                A[jj][ii]-=rate*lambda*tmp*a[jj];
		                a[jj]-=rate*lambda*tmp*A[jj][ii];
		            }
		        }
		    }
		    else
		    	break;
		}
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x34(%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movsd 0x1f55(%rip), %xmm0     # 0x7020
movl 0x30(%rdi), %r8d
movq (%rdx), %r9
movq (%rsi), %r10
testl %r8d, %r8d
cmovlel %ecx, %r8d
xorpd %xmm1, %xmm1
xorl %r11d, %r11d
cmpq %rax, %r11
je 0x5120
xorpd %xmm2, %xmm2
movq %r9, %rbx
xorl %r14d, %r14d
cmpq %r14, %r8
je 0x5113
movq (%rbx), %r15
movsd (%r15,%r11,8), %xmm3
mulsd (%r10,%r14,8), %xmm3
addsd %xmm3, %xmm2
incq %r14
addq $0x18, %rbx
jmp 0x50f2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm1
incq %r11
jmp 0x50e3
ucomisd %xmm0, %xmm1
jbe 0x51be
xorl %r9d, %r9d
cmpq %rax, %r9
je 0x50cb
movq (%rdx), %r10
movq (%rsi), %r11
xorpd %xmm1, %xmm1
movq %r10, %rbx
xorl %r14d, %r14d
cmpq %r14, %r8
je 0x5163
movq (%rbx), %r15
movsd (%r15,%r9,8), %xmm2
mulsd (%r11,%r14,8), %xmm2
addsd %xmm2, %xmm1
incq %r14
addq $0x18, %rbx
jmp 0x5142
addsd %xmm1, %xmm1
xorl %ebx, %ebx
cmpq %rbx, %r8
je 0x51b6
movq (%r10), %r14
movsd (%r14,%r9,8), %xmm2
movsd 0x48(%rdi), %xmm3
mulsd %xmm1, %xmm3
mulsd (%r11,%rbx,8), %xmm3
subsd %xmm3, %xmm2
movsd %xmm2, (%r14,%r9,8)
movsd (%r11,%rbx,8), %xmm3
movsd 0x48(%rdi), %xmm4
mulsd %xmm1, %xmm4
mulsd %xmm2, %xmm4
subsd %xmm4, %xmm3
movsd %xmm3, (%r11,%rbx,8)
incq %rbx
addq $0x18, %r10
jmp 0x5169
incq %r9
jmp 0x512d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mertyildiran[P]Plexus/plexus/plexus.cpp
// Function: Neuron::partially_subscribe()
void Neuron::partially_subscribe()
{
    if (this->subscriptions.size() == 0) {
        unsigned seed = std::chrono::system_clock::now()
            .time_since_epoch().count();
        std::default_random_engine generator (seed);
        std::normal_distribution<double> distribution(
            this->network->connectivity,
            this->network->connectivity_sqrt
        );
        unsigned int sample_length = distribution(generator);
        if (sample_length > this->network->nonmotor_neurons.size())
            sample_length = this->network->nonmotor_neurons.size();
        if (sample_length <= 0)
            sample_length = 0;
        std::vector<Neuron*> elected = random_sample(
            this->network->nonmotor_neurons,
            sample_length
        );
        for (auto const& target_neuron: elected) {
            if (target_neuron != this) {
                this->subscriptions.insert(
                    std::pair<Neuron*, double>(
                        target_neuron,
                        Random::get(-1.0, 1.0)
                    )
                );
                target_neuron->publications.insert(
                    std::pair<Neuron*, double>(this, 0.0)
                );
            }
        }
        this->network->increase_initiated_neurons();
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %fs:0x28, %rax
movq %rax, 0x70(%rsp)
cmpq $0x0, 0x48(%rdi)
jne 0x981f
movq %rdi, %rbx
callq 0x9030
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
divl %ecx
cmpl $0x1, %edx
adcl $0x0, %edx
leaq 0x48(%rsp), %rsi
movq %rdx, (%rsi)
movq 0x28(%rbx), %rax
cvtdq2pd 0x4(%rax), %xmm0
leaq 0x50(%rsp), %rdi
movapd %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
callq 0xaa62
cvttsd2si %xmm0, %rax
movl %eax, %ecx
movq 0x28(%rbx), %rdx
leaq 0x160(%rdx), %rsi
movq 0x168(%rdx), %r12
subq 0x160(%rdx), %r12
sarq $0x3, %r12
cmpq %rcx, %r12
cmovael %eax, %r12d
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0xab3a
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0xaa6a
leaq 0x30(%rbx), %r15
leaq 0x18(%rsp), %rdi
callq 0xc5aa
movq 0x30(%rsp), %r13
movq 0x38(%rsp), %rbp
leaq 0x8(%rsp), %r12
cmpq %rbp, %r13
je 0x980b
cmpq %rbx, (%r13)
je 0x9805
movsd 0x5845(%rip), %xmm0     # 0xf008
movsd 0x5835(%rip), %xmm1     # 0xf000
callq 0xaa04
movq (%r13), %rax
movq %rax, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xc5ee
movq (%r13), %rdi
addq $0x68, %rdi
movq %rbx, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movq %r12, %rsi
callq 0xc5ee
addq $0x8, %r13
jmp 0x97b0
movq 0x28(%rbx), %rax
incl 0x98(%rax)
leaq 0x30(%rsp), %rdi
callq 0xc5aa
movq %fs:0x28, %rax
cmpq 0x70(%rsp), %rax
jne 0x986b
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %r14
jmp 0x984b
jmp 0x9848
movq %rax, %rbx
movq %r14, %rdi
callq 0xc5aa
movq %fs:0x28, %rax
cmpq 0x70(%rsp), %rax
jne 0x986b
movq %rbx, %rdi
callq 0x9470
callq 0x92d0
// File: /workspace/github_cpp_makefile_star2_O2/mertyildiran[P]Plexus/plexus/plexus.cpp
// Function: Neuron::fire()
bool Neuron::fire()
{
    if (this->type != SENSORY_NEURON) {

        this->potential = this->calculate_potential();
        this->network->fire_counter++;
        this->fire_counter++;

        if (! std::isnan(this->desired_potential)) {

            this->loss = this->calculate_loss();
            int alteration_sign;
            if (this->loss > 0) {
                alteration_sign = -1;
            } else if (this->loss < 0) {
                alteration_sign = 1;
            } else {
                this->desired_potential = std::nan("None");
                return true;
            }

            double alteration_value = pow(this->loss, 2);
            alteration_value = alteration_value * pow(
                this->network->decay_factor,
                (this->network->fire_counter/1000)
            );

            for (auto& it: this->subscriptions) {
                it.first->desired_potential = it.first->potential
                    + alteration_sign
                    * this->derivative(it.first->potential);
                this->subscriptions[it.first] = it.second
                    + (alteration_value * alteration_sign)
                    * this->derivative(it.first->potential);
            }
        }
    }
    return false;
}

// Assembly:
cmpl $0x1, 0xa8(%rdi)
jne 0x98f4
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x9878
movapd %xmm0, %xmm1
movsd %xmm0, 0xa0(%rbx)
movq 0x28(%rbx), %rcx
movq 0x180(%rcx), %rax
incq %rax
movq %rax, 0x180(%rcx)
incl 0x10(%rbx)
movsd (%rbx), %xmm0
ucomisd %xmm0, %xmm0
jp 0x9a06
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rbx)
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jbe 0x9952
movsd 0x56b8(%rip), %xmm0     # 0xf008
jmp 0x9964
ucomisd %xmm1, %xmm0
jbe 0x9a0a
movsd 0x569c(%rip), %xmm0     # 0xf000
movsd %xmm0, (%rsp)
mulsd %xmm1, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x90(%rcx), %xmm0
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divq %rcx
cvtsi2sd %rax, %xmm1
callq 0x9440
mulsd 0x8(%rsp), %xmm0
leaq 0x30(%rbx), %r14
addq $0x40, %rbx
mulsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x9a06
leaq 0x8(%rbx), %rsi
movq 0x8(%rbx), %rax
movsd 0xa0(%rax), %xmm0
movsd 0x5638(%rip), %xmm2     # 0xf000
subsd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movsd (%rsp), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rax)
mulsd 0x10(%rsp), %xmm2
addsd 0x10(%rbx), %xmm2
movsd %xmm2, 0x8(%rsp)
movq %r14, %rdi
callq 0xc908
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x99a8
xorl %eax, %eax
jmp 0x9a1c
leaq 0x565b(%rip), %rdi      # 0xf06c
callq 0x9050
movsd %xmm0, (%rbx)
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mertyildiran[P]Plexus/plexus/plexus.cpp
// Function: Network::get_neurons_by_type(NeuronType)
void Network::get_neurons_by_type(NeuronType neuron_type)
{
    std::vector<Neuron*> available_neurons;
    for (auto const& neuron: this->neurons) {
        switch (neuron_type) {
            case NON_SENSORY_NEURON:
                if (neuron->type != SENSORY_NEURON) {
                    this->nonsensory_neurons.push_back(neuron);
                }
                break;
            case NON_MOTOR_NEURON:
                if (neuron->type != MOTOR_NEURON) {
                    this->nonmotor_neurons.push_back(neuron);
                }
                break;
            case INTER_NEURON:
                if (neuron->type == INTER_NEURON) {
                    this->interneurons.push_back(neuron);
                }
                break;
            default:
                throw std::invalid_argument(
                    "Network::pick_neurons_by_type(int input_dim, "
                    "NeuronType neuron_type) function only accepts "
                    "NON_SENSORY_NEURON, NON_MOTOR_NEURON or "
                    "INTER_NEURON as the neuron type!"
                );
                break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq 0x148(%rdi), %r15
movq 0x150(%rdi), %r12
leaq 0x68(%rdi), %r13
leaq 0x160(%rdi), %rbp
addq $0x50, %r14
cmpq %r12, %r15
je 0xa0a7
testl %ebx, %ebx
je 0xa08a
cmpl $0x3, %ebx
je 0xa079
cmpl $0x4, %ebx
jne 0xa0d2
movq (%r15), %rax
cmpl $0x1, 0xa8(%rax)
movq %r14, %rdi
jne 0xa099
jmp 0xa0a1
movq (%r15), %rax
cmpl $0x2, 0xa8(%rax)
movq %rbp, %rdi
jne 0xa099
jmp 0xa0a1
movq (%r15), %rax
cmpl $0x0, 0xa8(%rax)
movq %r13, %rdi
jne 0xa0a1
movq %r15, %rsi
callq 0xad14
addq $0x8, %r15
jmp 0xa055
movq %rsp, %rdi
callq 0xc5aa
movq %fs:0x28, %rax
cmpq 0x20(%rsp), %rax
jne 0xa144
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x9120
movq %rax, %r14
leaq 0x5144(%rip), %rsi      # 0xf228
movq %rax, %rdi
callq 0x94b0
movq %fs:0x28, %rax
cmpq 0x20(%rsp), %rax
jne 0xa144
movq 0x9edd(%rip), %rsi      # 0x13fe0
movq 0x9eb6(%rip), %rdx      # 0x13fc0
movq %r14, %rdi
callq 0x9420
jmp 0xa121
movq %rax, %rbx
movq %r14, %rdi
callq 0x91c0
jmp 0xa124
movq %rax, %rbx
movq %rsp, %rdi
callq 0xc5aa
movq %fs:0x28, %rax
cmpq 0x20(%rsp), %rax
jne 0xa144
movq %rbx, %rdi
callq 0x9470
callq 0x92d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mertyildiran[P]Plexus/plexus/plexus.cpp
// Function: Network::initiate_subscriptions()
void Network::initiate_subscriptions()
{
    for (auto& neuron: this->neurons) {
        if (neuron->type != SENSORY_NEURON) {
            neuron->partially_subscribe();
            std::cout << "Initiated: " << this->initiated_neurons
                << " neuron(s)\r" << std::flush;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x148(%rdi), %r13
movq 0x150(%rdi), %rbp
movq 0x9e33(%rip), %r14      # 0x13fa0
leaq 0x4f7a(%rip), %r15      # 0xf0ee
leaq 0x4f7f(%rip), %r12      # 0xf0fa
cmpq %rbp, %r13
je 0xa1c4
movq (%r13), %rdi
cmpl $0x1, 0xa8(%rdi)
je 0xa1be
callq 0x96e2
movq %r14, %rdi
movq %r15, %rsi
callq 0x9290
movl 0x98(%rbx), %esi
movq %rax, %rdi
callq 0x9430
movq %rax, %rdi
movq %r12, %rsi
callq 0x9290
movq %rax, %rdi
callq 0x91a0
addq $0x8, %r13
jmp 0xa17b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mertyildiran[P]Plexus/plexus/plexus.cpp
// Function: Network::ignite()
void Network::ignite()
{
    this->freezer = false;
    this->thread1 = std::thread{Network::_ignite, this};
    this->thread1.detach();
    //this->thread1.join();
    std::cout << "Network has been ignited" << '\n';
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x128(%rdi)
movq %rsp, %rdx
movq %rdi, (%rdx)
leaq 0x6a(%rip), %rsi        # 0xa26a
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xad32
addq $0x130, %rbx            # imm = 0x130
movq %rbx, %rdi
movq %r14, %rsi
callq 0xade0
movq %r14, %rdi
callq 0xacb4
movq %rbx, %rdi
callq 0x9450
movq 0x9d6a(%rip), %rdi      # 0x13fa0
leaq 0x4ec9(%rip), %rsi      # 0xf106
callq 0x9290
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x9310
movq %fs:0x28, %rax
cmpq 0x10(%rsp), %rax
jne 0xa265
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x92d0
// File: /workspace/github_cpp_makefile_star2_O2/mertyildiran[P]Plexus/plexus/plexus.cpp
// Function: Network::print_output() const
void Network::print_output() const
{
    std::vector<double> output = this->get_output();
    std::cout << "\r";
    std::cout << "Output: ";
    for (const auto& i: output)
        std::cout << i << ' ';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rsi
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
leaq 0x8(%rsp), %rdi
callq 0xa6d2
movq 0x9974(%rip), %rdi      # 0x13fa0
leaq 0x4ad1(%rip), %rsi      # 0xf104
callq 0x9290
movq 0x9961(%rip), %rdi      # 0x13fa0
leaq 0x4c86(%rip), %rsi      # 0xf2cc
callq 0x9290
movq 0x8(%rsp), %r14
movq 0x10(%rsp), %r15
movq 0x9944(%rip), %rbx      # 0x13fa0
pushq $0x20
popq %rbp
cmpq %r15, %r14
je 0xa681
movsd (%r14), %xmm0
movq %rbx, %rdi
callq 0x93d0
movq %rax, %rdi
movl %ebp, %esi
callq 0x9310
addq $0x8, %r14
jmp 0xa65f
leaq 0x8(%rsp), %rdi
callq 0xca0c
movq %fs:0x28, %rax
cmpq 0x20(%rsp), %rax
jne 0xa6cd
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa6a8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xca0c
movq %fs:0x28, %rax
cmpq 0x20(%rsp), %rax
jne 0xa6cd
movq %rbx, %rdi
callq 0x9470
callq 0x92d0
// File: /workspace/github_cpp_makefile_star2_O2/mertyildiran[P]Plexus/plexus/plexus.cpp
// Function: Network::get_output() const
std::vector<double> Network::get_output() const
{
    std::vector<double> output;
    for (auto& neuron: this->motor_neurons) {
        int decimals = pow(10, this->precision);
        output.push_back(roundf(neuron->potential * decimals) / decimals);
    }
    return output;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x30(%rsi), %r12
movq 0x38(%rsi), %r13
leaq 0x10(%rsp), %r15
cmpq %r13, %r12
je 0xa767
cvtsi2sdl (%r14), %xmm1
movsd 0x48f3(%rip), %xmm0     # 0xf010
callq 0x9440
movq (%r12), %rax
cvttpd2dq %xmm0, %xmm0
movapd %xmm0, (%rsp)
cvtdq2pd %xmm0, %xmm0
mulsd 0xa0(%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x92c0
cvtdq2ps (%rsp), %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xcf64
addq $0x8, %r12
jmp 0xa70b
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0xa7ab
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xca0c
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0xa7ab
movq %r14, %rdi
callq 0x9470
callq 0x92d0
// File: /workspace/github_cpp_makefile_star2_O2/mertyildiran[P]Plexus/plexus/network.hpp
// Function: std::vector<Neuron*, std::allocator<Neuron*>> random_sample<std::vector<Neuron*, std::allocator<Neuron*>>>(std::vector<Neuron*, std::allocator<Neuron*>>, unsigned int)
RandomSampling random_sample(
    RandomSampling neurons,
    unsigned int sample_length
)
{
    RandomSampling sample;
    std::sample(neurons.begin(), neurons.end(), std::back_inserter(sample),
        sample_length, std::mt19937{std::random_device{}()});
    return sample;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2718, %rsp           # imm = 0x2718
movl %edx, %ebp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x2710(%rsp)
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq (%rsi), %r14
movq 0x8(%rsi), %r15
movq %rsp, %rdi
callq 0xb7aa
movq %rsp, %rdi
callq 0x9350
movl %eax, %esi
leaq 0x1388(%rsp), %rdi
callq 0xc572
movl %ebp, %ecx
leaq 0x1388(%rsp), %r8
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xc2bd
movq %rsp, %rdi
callq 0xb8dc
movq %fs:0x28, %rax
cmpq 0x2710(%rsp), %rax
jne 0xab35
movq %rbx, %rax
addq $0x2718, %rsp           # imm = 0x2718
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xab12
movq %rax, %r14
movq %rsp, %rdi
callq 0xb8dc
movq %rbx, %rdi
callq 0xc5aa
movq %fs:0x28, %rax
cmpq 0x2710(%rsp), %rax
jne 0xab35
movq %r14, %rdi
callq 0x9470
callq 0x92d0
// File: /workspace/github_cpp_makefile_star2_O2/mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: parse_iterable(std::vector<double, std::allocator<double>>&, _object*)
void parse_iterable(std::vector<double> &arr, PyObject *iter)
{
    while (true) {
        PyObject *next = PyIter_Next(iter);
        if (!next) {
            // nothing left in the iterator
            Py_XDECREF(next);
            break;
        }

        if (!PyFloat_Check(next)) {
            throw
                "One of the arguments contains an illegal "
                "value (other than float)"
            ;
        }

        double val = PyFloat_AsDouble(next);
        Py_XDECREF(next);
        arr.push_back(val);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
callq 0x9460
testq %rax, %rax
je 0xd10b
movq %rax, %r12
movq %rax, %rdi
callq 0xd16e
testl %eax, %eax
je 0xd127
movq %r12, %rdi
callq 0x91e0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0xd15f
movq %r14, %rdi
movq %r15, %rsi
callq 0xe2f6
jmp 0xd0cc
movq %fs:0x28, %rax
cmpq 0x10(%rsp), %rax
jne 0xd15a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x8
popq %rdi
callq 0x9120
leaq 0x237c(%rip), %rcx      # 0xf4b2
movq %rcx, (%rax)
movq %fs:0x28, %rcx
cmpq 0x10(%rsp), %rcx
jne 0xd15a
movq 0x6e28(%rip), %rsi      # 0x13f78
movq %rax, %rdi
xorl %edx, %edx
callq 0x9420
callq 0x92d0
// File: /workspace/github_cpp_makefile_star2_O2/mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: PyNetwork_init(PyNetwork*, _object*, _object*)
static int PyNetwork_init(PyNetwork *self, PyObject *args, PyObject *kwargs)
{
    int size;
    int input_dim = 0;
    int output_dim = 0;
    double connectivity = 0.01;
    int precision = 2;
    int randomly_fire = false;
    int dynamic_output = false;
    int visualization = false;
    double decay_factor =  1.0;

    static char *kwlist[] = {
        "size",
        "input_dim",
        "output_dim",
        "connectivity",
        "precision",
        "randomly_fire",
        "dynamic_output",
        "visualization",
        "decay_factor",
        NULL
    };

    if (! PyArg_ParseTupleAndKeywords(
        args,
        kwargs,
        "i|iidipppd",
        kwlist,
        &size,
        &input_dim,
        &output_dim,
        &connectivity,
        &precision,
        &randomly_fire,
        &dynamic_output,
        &visualization,
        &decay_factor
    ))
        return -1;

    self->ptrObj = new Network(
        size,
        input_dim,
        output_dim,
        connectivity,
        precision,
        randomly_fire,
        dynamic_output,
        visualization,
        decay_factor
    );

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x30(%rsp)
leaq 0x28(%rsp), %r9
andl $0x0, (%r9)
leaq 0x24(%rsp), %r10
andl $0x0, (%r10)
movabsq $0x3f847ae147ae147b, %rax # imm = 0x3F847AE147AE147B
leaq 0x18(%rsp), %r11
movq %rax, (%r11)
leaq 0x14(%rsp), %r14
leaq 0x10(%rsp), %r15
andl $0x0, (%r15)
leaq 0xc(%rsp), %r12
andl $0x0, (%r12)
leaq 0x8(%rsp), %r13
andl $0x0, (%r13)
movl $0x2, (%r14)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rsp, %rbp
movq %rax, (%rbp)
subq $0x8, %rsp
leaq 0x26a2(%rip), %rax      # 0xfa64
leaq 0x7807(%rip), %rcx      # 0x14bd0
leaq 0x34(%rsp), %r8
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
xorl %eax, %eax
pushq %rbp
pushq %r13
pushq %r12
pushq %r15
pushq %r14
pushq %r11
pushq %r10
callq 0x9110
addq $0x40, %rsp
testl %eax, %eax
je 0xd453
movl $0x188, %edi            # imm = 0x188
callq 0x92a0
movq %rax, %r14
movl 0x2c(%rsp), %esi
movl 0x28(%rsp), %edx
movl 0x24(%rsp), %ecx
movsd 0x18(%rsp), %xmm0
movl 0x14(%rsp), %r8d
xorl %r9d, %r9d
cmpl $0x0, 0x10(%rsp)
setne %r9b
xorl %eax, %eax
cmpl $0x0, 0xc(%rsp)
setne %al
xorl %r10d, %r10d
cmpl $0x0, 0x8(%rsp)
setne %r10b
movsd (%rsp), %xmm1
movq %r14, %rdi
pushq %r10
pushq %rax
callq 0x9a24
popq %rax
popq %rcx
movq %r14, 0x10(%rbx)
xorl %eax, %eax
jmp 0xd456
pushq $-0x1
popq %rax
movq %fs:0x28, %rcx
cmpq 0x30(%rsp), %rcx
jne 0xd49d
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x188, %esi            # imm = 0x188
movq %r14, %rdi
callq 0x92b0
movq %fs:0x28, %rax
cmpq 0x30(%rsp), %rax
jne 0xd49d
movq %rbx, %rdi
callq 0x9470
callq 0x92d0
// File: /workspace/github_cpp_makefile_star2_O2/mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: PyNeuron_init(PyNeuron*, _object*)
static int PyNeuron_init(PyNeuron *self, PyObject *args)
{
    PyNetwork * network;

    if (! PyArg_ParseTuple(args, "O", &network))
        return -1;

    Py_XINCREF(network);

    self->ptrObj = new Neuron(*network->ptrObj);

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %fs:0x28, %rcx
movq %rcx, 0x8(%rsp)
leaq 0x2089(%rip), %rsi      # 0xf58d
movq %rsp, %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x93b0
testl %eax, %eax
je 0xd542
movq (%rsp), %r15
testq %r15, %r15
je 0xd521
incq (%r15)
movl $0xb0, %edi
callq 0x92a0
movq %rax, %r14
movq 0x10(%r15), %rsi
movq %rax, %rdi
callq 0x95ec
movq %r14, 0x10(%rbx)
xorl %eax, %eax
jmp 0xd545
pushq $-0x1
popq %rax
movq %fs:0x28, %rcx
cmpq 0x8(%rsp), %rcx
jne 0xd587
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0xb0, %esi
movq %r14, %rdi
callq 0x92b0
movq %fs:0x28, %rax
cmpq 0x8(%rsp), %rax
jne 0xd587
movq %rbx, %rdi
callq 0x9470
callq 0x92d0
// File: /workspace/github_cpp_makefile_star2_O2/mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: main
int main(int argc, char *argv[])
{
    glob_argc = argc;
    glob_argv = argv;

    wchar_t *program = Py_DecodeLocale(argv[0], NULL);

    /* Pass argv[0] to the Python interpreter */
    Py_SetProgramName(program);

    /* Initialize the Python interpreter.  Required. */
    Py_Initialize();

    /* Add a static module */
    initcplexus();
}

// Assembly:
pushq %rax
movq 0x69d7(%rip), %rax      # 0x13f70
movl %edi, (%rax)
movq 0x6a26(%rip), %rax      # 0x13fc8
movq %rsi, (%rax)
movq (%rsi), %rdi
xorl %esi, %esi
callq 0x9340
movq %rax, %rdi
callq 0x9300
callq 0x94a0
callq 0xd19a
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: PyNetwork_get_output(PyNetwork*, void*)
static PyObject * PyNetwork_get_output(PyNetwork *self, void *closure)
{
    std::vector<double> output;

    output = (self->ptrObj)->get_output();

    PyObject *PList = PyList_New(0);

    for (const auto& i: output) {
        PyObject *value = Py_BuildValue("d", i);
        PyList_Append(PList, value);
        Py_XDECREF(value);
    }

    return PList;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, 0x38(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
movq 0x10(%rdi), %rsi
leaq 0x8(%rsp), %rdi
callq 0xa6d2
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0xcb94
movq %rbx, %rdi
callq 0xca0c
xorl %edi, %edi
callq 0x9240
movq %rax, %rbx
movq 0x20(%rsp), %r12
movq 0x28(%rsp), %r13
leaq 0x1b34(%rip), %r14      # 0xf525
cmpq %r13, %r12
je 0xda22
movsd (%r12), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x9200
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9160
movq %r15, %rdi
callq 0xd15f
addq $0x8, %r12
jmp 0xd9f1
leaq 0x20(%rsp), %rdi
callq 0xca0c
movq %fs:0x28, %rax
cmpq 0x38(%rsp), %rax
jne 0xda76
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xda51
jmp 0xda51
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xca0c
movq %fs:0x28, %rax
cmpq 0x38(%rsp), %rax
jne 0xda76
movq %rbx, %rdi
callq 0x9470
callq 0x92d0
// File: /workspace/github_cpp_makefile_star2_O2/mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: PyNetwork_neuron_PyList_builder(std::vector<Neuron*, std::allocator<Neuron*>>)
static PyObject * PyNetwork_neuron_PyList_builder(std::vector<Neuron*> neurons)
{
    PyObject *PList = PyList_New(0);
    Py_XINCREF(PList);

    for (Neuron* i: neurons) {
        PyNeuron * neuron = PyObject_New(PyNeuron, &PyNeuronType);
        neuron->ptrObj = i;
        PyList_Append(PList, Py_BuildValue("O", neuron));
    }
    return PList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %edi, %edi
callq 0x9240
movq %rax, %rbx
testq %rax, %rax
je 0xde8d
incq (%rbx)
movq (%r14), %r12
movq 0x8(%r14), %r13
leaq 0x6955(%rip), %r14      # 0x147f0
leaq 0x16eb(%rip), %r15      # 0xf58d
cmpq %r13, %r12
je 0xded5
movq (%r12), %rbp
movq %r14, %rdi
callq 0x9170
movq %rbp, 0x10(%rax)
movq %r15, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x9200
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9160
addq $0x8, %r12
jmp 0xdea2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: PyNeuron_set_index(PyNeuron*, _object*, void*)
static int PyNeuron_set_index(PyNeuron *self, PyObject *value, void *closue)
{
    if (value == NULL) {
        PyErr_SetString(
            PyExc_TypeError,
            "Cannot delete the position attribute"
        );
        return -1;
    }

    if (! PyLong_Check(value)) {
        PyErr_SetString(
            PyExc_TypeError,
            "The position attribute value must be an integer"
        );
        return -1;
    }

    self->ptrObj->index = PyLong_AsLong(value);

    return 0;
}

// Assembly:
pushq %rbx
testq %rsi, %rsi
je 0xdf65
movq 0x8(%rsi), %rax
testb $0x1, 0xab(%rax)
jne 0xdf80
movq 0x605f(%rip), %rax      # 0x13fb8
movq (%rax), %rdi
leaq 0x1cba(%rip), %rsi      # 0xfc1d
jmp 0xdf76
movq 0x604c(%rip), %rax      # 0x13fb8
movq (%rax), %rdi
leaq 0x1c82(%rip), %rsi      # 0xfbf8
callq 0x92f0
pushq $-0x1
popq %rax
jmp 0xdf95
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x9040
movq 0x10(%rbx), %rcx
movq %rax, 0x20(%rcx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: PyNeuron_get_position(PyNeuron*, void*)
static PyObject * PyNeuron_get_position(PyNeuron *self, void *closure)
{
    PyObject *PList = PyList_New(0);
    Py_XINCREF(PList);
    PyList_Append(
        PList,
        Py_BuildValue(
            "i",
            std::get<0>(self->ptrObj->position)
        )
    );
    PyList_Append(
        PList,
        Py_BuildValue(
            "i",
            std::get<1>(self->ptrObj->position)
        )
    );
    return PyList_AsTuple(PList);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %edi, %edi
callq 0x9240
movq %rax, %rbx
testq %rax, %rax
je 0xdffb
incq (%rbx)
movq 0x10(%r14), %rax
movl 0x18(%rax), %esi
leaq 0x1a44(%rip), %r15      # 0xfa4d
movq %r15, %rdi
xorl %eax, %eax
callq 0x9200
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9160
movq 0x10(%r14), %rax
movl 0x14(%rax), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x9200
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9160
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x9100
// File: /workspace/github_cpp_makefile_star2_O2/mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: PyNeuron_set_position(PyNeuron*, _object*, void*)
static int PyNeuron_set_position(PyNeuron *self, PyObject *value, void *closue)
{
    if (value == NULL) {
        PyErr_SetString(
            PyExc_TypeError,
            "Cannot delete the position attribute"
        );
        return -1;
    }

    if (! PyTuple_Check(value)) {
        PyErr_SetString(
            PyExc_TypeError,
            "The position attribute value must be a tuple"
        );
        return -1;
    }

    PyObject *x = PyTuple_GetItem(value, 0);
    PyObject *y = PyTuple_GetItem(value, 1);

    if (! PyFloat_Check(x) || ! PyFloat_Check(y)) {
        PyErr_SetString(
            PyExc_TypeError,
            "The elements of position attribute must be float"
        );
        return -1;
    }

    std::get<0>(self->ptrObj->position) = PyFloat_AsDouble(x);
    std::get<1>(self->ptrObj->position) = PyFloat_AsDouble(y);

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xe077
movq %rsi, %r14
movq 0x8(%rsi), %rax
testb $0x4, 0xab(%rax)
jne 0xe08a
movq 0x5f50(%rip), %rax      # 0x13fb8
movq (%rax), %rdi
leaq 0x1bdb(%rip), %rsi      # 0xfc4d
jmp 0xe0fb
movq 0x5f3a(%rip), %rax      # 0x13fb8
movq (%rax), %rdi
leaq 0x1b70(%rip), %rsi      # 0xfbf8
jmp 0xe0fb
movq %rdi, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x94c0
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x94c0
movq %rax, %r14
movq %r15, %rdi
callq 0xd16e
testl %eax, %eax
je 0xe0ea
movq %r14, %rdi
callq 0xd16e
testl %eax, %eax
je 0xe0ea
movq %r15, %rdi
callq 0x91e0
cvttsd2si %xmm0, %eax
movq 0x10(%rbx), %rcx
movl %eax, 0x18(%rcx)
movq %r14, %rdi
callq 0x91e0
cvttsd2si %xmm0, %eax
movq 0x10(%rbx), %rcx
movl %eax, 0x14(%rcx)
xorl %eax, %eax
jmp 0xe103
movq 0x5ec7(%rip), %rax      # 0x13fb8
movq (%rax), %rdi
leaq 0x1b7f(%rip), %rsi      # 0xfc7a
callq 0x92f0
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: PyNeuron_connections_PyDict_build(std::unordered_map<Neuron*, double, std::hash<Neuron*>, std::equal_to<Neuron*>, std::allocator<std::pair<Neuron* const, double>>>)
static PyObject * PyNeuron_connections_PyDict_build(
    std::unordered_map<Neuron*,
    double> connections
)
{
    PyObject *PDict = PyDict_New();
    Py_XINCREF(PDict);

    for (auto& it: connections) {
        PyNeuron * neuron = PyObject_New(PyNeuron, &PyNeuronType);
        neuron->ptrObj = it.first;
        PyDict_SetItem(
            PDict,
            Py_BuildValue("O", neuron),
            Py_BuildValue("d", it.second)
        );
    }
    return PDict;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x92e0
movq %rax, %r14
testq %rax, %rax
je 0xe283
incq (%r14)
addq $0x10, %rbx
leaq 0x6562(%rip), %r15      # 0x147f0
leaq 0x12f8(%rip), %r12      # 0xf58d
leaq 0x1289(%rip), %r13      # 0xf525
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xe2e3
movq %r15, %rdi
callq 0x9170
movq 0x8(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %r12, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x9200
movq %rax, %rbp
movsd 0x10(%rbx), %xmm0
movq %r13, %rdi
movb $0x1, %al
callq 0x9200
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x90b0
jmp 0xe29c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Funcke[P]cpp_server/lib/http_request_lifecycle.cpp
// Function: http::HttpRequestLifecycle::HttpRequestLifecycle(int)
HttpRequestLifecycle::HttpRequestLifecycle(int socket) {
        this->socket = socket;
        this->request.first_line(this->read_line());
        printf("%s\n", this->request.protocol.c_str());
        while(true) {
            std::string* raw_header = this->read_line();
            if(raw_header->length() == 1)
                break;
            this->request.add_header_from_string(raw_header);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %r14
leaq 0x5701(%rip), %rax      # 0x7d40
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x274a
movl %r15d, 0xc8(%r14)
movq %r14, %rdi
callq 0x26ae
movq %rbx, %rdi
movq %rax, %rsi
callq 0x28b8
movq 0x48(%r14), %rdi
callq 0x22e0
movq %r14, %rdi
callq 0x26ae
cmpq $0x1, 0x8(%rax)
je 0x268d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x29be
jmp 0x2671
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x269a
movq %rax, %r14
movq %rbx, %rdi
callq 0x27ce
movq %r14, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O2/Funcke[P]cpp_server/lib/http_request_lifecycle.cpp
// Function: http::HttpRequestLifecycle::read_line[abi:cxx11]()
std::string* HttpRequestLifecycle::read_line() {
        std::string* line = new std::string();
        char next;
        do{
        read(this->socket, &next, 1); 
        if(next != '\n')
            *line += next;
        }while(next != '\n');
        return line;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x21f0
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
andq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
leaq -0x21(%rbp), %r15
pushq $0x1
popq %r12
movl 0xc8(%rbx), %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0x22a0
movb -0x21(%rbp), %al
cmpb $0xa, %al
je 0x2709
movsbl %al, %esi
movq %r14, %rdi
callq 0x21b0
jmp 0x26e4
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Funcke[P]cpp_server/lib/request.cpp
// Function: http::Request::first_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void Request::first_line(std::string* first) {
        std::istringstream iss(*first);
        std::vector<std::string> results(std::istream_iterator<std::string>{iss},std::istream_iterator<std::string>());
        this->method = results[0];
        this->path = results[1];
        this->protocol = results[2];                   
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
leaq -0x210(%rbp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2310
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0x2bd8
leaq -0x88(%rbp), %r14
andq $0x0, -0x8(%r14)
leaq -0x78(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
movb %cl, 0x10(%rax)
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x90(%rbp), %rdx
leaq -0x11(%rbp), %rcx
callq 0x2c18
movq %r14, %rdi
callq 0x20f0
leaq -0x58(%rbp), %rdi
callq 0x20f0
movq -0x30(%rbp), %rsi
leaq 0x20(%rbx), %rdi
callq 0x2140
movq -0x30(%rbp), %rsi
addq $0x20, %rsi
movq %rbx, %rdi
callq 0x2140
movq -0x30(%rbp), %rsi
addq $0x40, %rsi
addq $0x40, %rbx
movq %rbx, %rdi
callq 0x2140
leaq -0x30(%rbp), %rdi
callq 0x2ca4
leaq -0x210(%rbp), %rdi
callq 0x2110
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x20f0
leaq -0x58(%rbp), %rdi
callq 0x20f0
jmp 0x29a9
movq %rax, %rbx
jmp 0x29a9
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2ca4
leaq -0x210(%rbp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2330
nop