LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/speech.C
// Function: Speech::Info()
void Speech::Info(){
    cout<<"# of input channels = "<<_channels.size()<<endl;
    for(int i = 0; i < _channels.size(); i++) cout<<_channels[i]->SizeSpikeT()<<"\t";
    cout<<endl;
    cout<<"# of reservoir channels = "<<_rChannels.size()<<endl;
    for(int i = 0; i < _rChannels.size(); i++) cout<<_rChannels[i]->SizeSpikeT()<<"\t";
    cout<<endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x1c227(%rip), %rbx     # 0x20fd0
leaq 0x12460(%rip), %rsi     # 0x17210
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3340
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x3, %rsi
movq %rbx, %rdi
callq 0x31d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x4e52
xorl %r13d, %r13d
movq 0x1c1c3(%rip), %r15     # 0x20fd0
leaq 0x1221c(%rip), %r12     # 0x17030
movq (%rax,%r13,8), %rax
movq 0x20(%rax), %rsi
subq 0x18(%rax), %rsi
shrq $0x2, %rsi
movq %r15, %rdi
callq 0x3560
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3340
incq %r13
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x4e14
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
leaq 0x123a7(%rip), %rsi     # 0x17227
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x3340
movq 0x20(%r14), %rsi
subq 0x18(%r14), %rsi
sarq $0x3, %rsi
movq %rbx, %rdi
callq 0x31d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movq 0x18(%r14), %rax
cmpq %rax, 0x20(%r14)
je 0x4f25
xorl %r13d, %r13d
movq 0x1c0f1(%rip), %r15     # 0x20fd0
leaq 0x1214a(%rip), %r12     # 0x17030
movq (%rax,%r13,8), %rax
movq 0x20(%rax), %rsi
subq 0x18(%rax), %rsi
shrq $0x2, %rsi
movq %r15, %rdi
callq 0x3560
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3340
incq %r13
movq 0x18(%r14), %rax
movq 0x20(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x4ee6
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x31e0
nop
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/speech.C
// Function: Speech::PrintSpikesPerChannels(std::vector<Channel*, std::allocator<Channel*>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Speech::PrintSpikesPerChannels(const vector<Channel*>& channels, const string & filename){
    ofstream f_out(filename.c_str());
    if(!f_out.is_open()){
        cout<<"Cannot open file : "<<filename<<" for dumping the spikes!"<<endl;
        assert(f_out.is_open());
    }
    f_out<<"-1\t-1"<<endl;
    for(int i = 0; i < channels.size(); i++){ 
        channels[i]->Print(f_out);
    }
    f_out<<"-1\t-1"<<endl;
    f_out.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdx, %r15
movq %rsi, %rbx
movq (%rdx), %rsi
movq %rsp, %rdi
movl $0x10, %edx
callq 0x3320
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x30b0
testb %al, %al
jne 0x5002
movq 0x1c040(%rip), %rdi     # 0x20fd0
leaq 0x122ab(%rip), %rsi     # 0x17242
movl $0x13, %edx
callq 0x3340
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x1c021(%rip), %rdi     # 0x20fd0
callq 0x3340
movq %rax, %r15
leaq 0x12298(%rip), %rsi     # 0x17256
movl $0x18, %edx
movq %rax, %rdi
callq 0x3340
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movq %r14, %rdi
callq 0x30b0
testb %al, %al
je 0x50f7
leaq 0x122b5(%rip), %rsi     # 0x172be
movq %rsp, %r14
movl $0x5, %edx
movq %r14, %rdi
callq 0x3340
movq (%rsp), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %rsp, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x5072
xorl %r15d, %r15d
movq %rsp, %r14
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x418c
incq %r15
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x5050
leaq 0x12245(%rip), %rsi     # 0x172be
movq %rsp, %rbx
movl $0x5, %edx
movq %rbx, %rdi
callq 0x3340
movq (%rsp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %rsp, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movq %rsp, %rdi
callq 0x3410
movq 0x1bf08(%rip), %rax     # 0x20fc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, (%rsp,%rcx)
callq 0x3240
leaq 0xf8(%rsp), %rdi
callq 0x3120
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
leaq 0x11f7e(%rip), %rdi     # 0x1707c
leaq 0x11feb(%rip), %rsi     # 0x170f0
leaq 0x12163(%rip), %rcx     # 0x1726f
movl $0x63, %edx
callq 0x31b0
jmp 0x5118
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3450
movq %rbx, %rdi
callq 0x3570
nop
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/speech.C
// Function: Speech::PrintSpikeFreq(char const*, std::basic_ofstream<char, std::char_traits<char>>&)
int Speech::PrintSpikeFreq(const char * type, ofstream & f_out){
    assert(type);
    bool f;
    if(strcmp(type, "input") == 0) f = false;
    else if(strcmp(type, "reservoir") == 0) f = true;
    else assert(0);

    if(!f){
        SpikeFreq(f_out, _channels);	
    }
    else{
        SpikeFreq(f_out, _rChannels);
    }
    return _class;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x5ff9
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x11308(%rip), %rsi     # 0x172c4
movq %r15, %rdi
callq 0x33f0
movq %rbx, %rdx
testl %eax, %eax
je 0x5fe2
leaq 0x11327(%rip), %rsi     # 0x172f9
movq %r15, %rdi
callq 0x33f0
testl %eax, %eax
jne 0x6018
leaq 0x18(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6038
movl 0x80(%rbx), %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x11331(%rip), %rdi     # 0x17331
leaq 0x110e9(%rip), %rsi     # 0x170f0
leaq 0x11328(%rip), %rcx     # 0x17336
movl $0x7e, %edx
callq 0x31b0
leaq 0x12311(%rip), %rdi     # 0x18330
leaq 0x110ca(%rip), %rsi     # 0x170f0
leaq 0x11309(%rip), %rcx     # 0x17336
movl $0x82, %edx
callq 0x31b0
nop
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/speech.C
// Function: Speech::SpikeFreq(std::basic_ofstream<char, std::char_traits<char>>&, std::vector<Channel*, std::allocator<Channel*>> const&)
void Speech::SpikeFreq(ofstream & f_out, const vector<Channel*> & channels){
    // find out the stop time for each speech:
    int stop_t = EndTime();

    for(int i = 0; i < channels.size(); i++){ 
        //f_out<<(double)channels[i]->SizeSpikeT()/stop_t<<"\t";
        f_out<<channels[i]->SizeSpikeT()<<"\t";
    }
    f_out<<endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
callq 0x60ce
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x609c
xorl %r12d, %r12d
leaq 0x10fd2(%rip), %r15     # 0x17030
movq (%rax,%r12,8), %rax
movq 0x20(%rax), %rsi
subq 0x18(%rax), %rsi
shrq $0x2, %rsi
movq %rbx, %rdi
callq 0x3560
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3340
incq %r12
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
ja 0x605e
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x31e0
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/speech.C
// Function: Speech::EndTime()
int Speech::EndTime(){
    int stop_t = INT_MIN;
    for(int i = 0; i < _channels.size(); i++){
        assert(_channels[i]);
        stop_t = max(stop_t, _channels[i]->LastSpikeT());
    }
    if(stop_t == INT_MIN){
        cout<<"The speech:  "<<_index<<" contains "<<_channels.size()<<" input channels."<<endl;
        assert(stop_t != INT_MIN);
    }
    return stop_t;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
je 0x6120
sarq $0x3, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
movl $0x80000000, %edi       # imm = 0x80000000
xorl %esi, %esi
movq (%rcx,%rsi,8), %rax
testq %rax, %rax
je 0x6133
movq 0x20(%rax), %r8
cmpq %r8, 0x18(%rax)
je 0x610d
movl -0x4(%r8), %eax
jmp 0x610f
xorl %eax, %eax
cmpl %eax, %edi
cmovgl %edi, %eax
incq %rsi
movl %eax, %edi
cmpq %rsi, %rdx
jne 0x60f4
jmp 0x6125
movl $0x80000000, %eax       # imm = 0x80000000
movl %eax, %ecx
negl %ecx
jo 0x6152
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x11231(%rip), %rdi     # 0x1736b
leaq 0x10faf(%rip), %rsi     # 0x170f0
leaq 0x11230(%rip), %rcx     # 0x17378
movl $0x9d, %edx
callq 0x31b0
movq 0x1ae77(%rip), %r14     # 0x20fd0
leaq 0x1122e(%rip), %rsi     # 0x1738e
movl $0xd, %edx
movq %r14, %rdi
callq 0x3340
movl 0x84(%rbx), %esi
movq %r14, %rdi
callq 0x3560
movq %rax, %r14
leaq 0x11217(%rip), %rsi     # 0x1739c
movl $0xa, %edx
movq %rax, %rdi
callq 0x3340
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x3, %rsi
movq %r14, %rdi
callq 0x31d0
movq %rax, %rbx
leaq 0x111f8(%rip), %rsi     # 0x173a7
movl $0x10, %edx
movq %rax, %rdi
callq 0x3340
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
leaq 0x111ce(%rip), %rdi     # 0x173b8
leaq 0x10eff(%rip), %rsi     # 0x170f0
leaq 0x11180(%rip), %rcx     # 0x17378
movl $0xa2, %edx
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/neuron.C
// Function: Neuron::LSMPrintInputSyns(std::basic_ofstream<char, std::char_traits<char>>&)
void NeuronGroup::WriteSynWeightsToFile(ofstream& f_out, int& index, const string& post_g){
    for(Neuron* neuron : _neurons){
        assert(neuron);
        neuron->WriteOutputWeights(f_out, index, post_g);
    }
    if(_b_neuron)   _b_neuron->WriteOutputWeights(f_out, index, post_g);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x30(%rdi), %r13
movq 0x38(%rdi), %rbp
cmpq %rbp, %r13
je 0x7105
movq %rsi, %rbx
leaq 0x10014(%rip), %r14     # 0x17030
movq (%r13), %r15
movq %r15, %rdi
callq 0xc3de
movq 0x10(%rax), %r12
testq %r12, %r12
je 0x7049
movq %r12, %rdi
callq 0x3150
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x3340
jmp 0x7060
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x3550
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3340
movq %r15, %rdi
callq 0xc3e2
movq 0x10(%rax), %r12
testq %r12, %r12
je 0x7099
movq %r12, %rdi
callq 0x3150
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x3340
jmp 0x70b0
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x3550
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3340
movsd 0x38(%r15), %xmm0
movq %rbx, %rdi
callq 0x34f0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x701c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/neuron.C
// Function: Neuron::SpiKL_IP(int)
void Neuron::SpiKL_IP(int t){
	double Tau_Lower_Bound=32;
	double Tau_Upper_Bound=512;
	double R_Lower_Bound=32;
	double R_Upper_Bound=512;
	double y=_lsm_calcium/(TAU_C-1);
	double LR1=5;
	double LR2=5;
	double beta=5;  //reciprocal of miu
    if(!(_name[0] == 'r' && _name[9] == '_'))   return;	
	double X;
	if(y>0.01){
		X=_lsm_v_thresh/(exp((1/_lsm_t_m_c)*(1/y-LSM_T_REFRAC))-1);
		_lsm_R+=LR1*(2*y*_lsm_t_m_c*_lsm_v_thresh-X-_lsm_v_thresh-beta*_lsm_t_m_c*_lsm_v_thresh*y*y)/(_lsm_R*X);
		_lsm_t_m_c+=LR2*(2*LSM_T_REFRAC*y-1-beta*(LSM_T_REFRAC*y*y-y))/_lsm_t_m_c;		
	}
	else{
		_lsm_R+=LR1*0.1;
		_lsm_t_m_c-=LR2*0.1;
	}
	if(_lsm_R<R_Lower_Bound)
		_lsm_R=R_Lower_Bound;
	if(_lsm_R>R_Upper_Bound)
		_lsm_R=R_Upper_Bound;

	if(_lsm_t_m_c<Tau_Lower_Bound)
		_lsm_t_m_c=Tau_Lower_Bound;
	if(_lsm_t_m_c>Tau_Upper_Bound)
		_lsm_t_m_c=Tau_Upper_Bound;
	

}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x10(%rdi), %rax
cmpb $0x72, (%rax)
jne 0x79c8
cmpb $0x5f, 0x9(%rax)
jne 0x79c8
movq %rdi, %rbx
movsd 0x178(%rdi), %xmm2
divsd 0xfe03(%rip), %xmm2     # 0x17610
ucomisd 0xfe03(%rip), %xmm2     # 0x17618
jbe 0x7928
movsd 0x1d0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xfdaf(%rip), %xmm0     # 0x175e0
movapd %xmm0, %xmm1
divsd 0x1f0(%rbx), %xmm1
divsd %xmm2, %xmm0
addsd 0xfde7(%rip), %xmm0     # 0x17630
mulsd %xmm1, %xmm0
movsd %xmm2, (%rsp)
callq 0x35a0
movsd 0xfdd9(%rip), %xmm5     # 0x17638
addsd %xmm5, %xmm0
movsd 0x8(%rsp), %xmm8
divsd %xmm0, %xmm8
movsd (%rsp), %xmm9
movapd %xmm9, %xmm0
addsd %xmm9, %xmm0
movsd 0x1f0(%rbx), %xmm3
movapd %xmm0, %xmm2
mulsd %xmm3, %xmm2
movsd 0x1d0(%rbx), %xmm4
movsd 0x1d8(%rbx), %xmm1
mulsd %xmm4, %xmm2
subsd %xmm8, %xmm2
subsd %xmm4, %xmm2
movsd 0xfd8c(%rip), %xmm6     # 0x17640
movsd 0xfd8c(%rip), %xmm7     # 0x17648
mulsd %xmm9, %xmm7
addsd %xmm5, %xmm7
movsd 0xfd3b(%rip), %xmm5     # 0x17608
mulsd %xmm9, %xmm0
subsd %xmm9, %xmm0
mulsd %xmm6, %xmm0
addsd %xmm7, %xmm0
mulsd %xmm5, %xmm0
divsd %xmm3, %xmm0
addsd %xmm3, %xmm0
mulsd %xmm6, %xmm3
mulsd %xmm4, %xmm3
mulsd %xmm9, %xmm3
mulsd %xmm9, %xmm3
addsd %xmm2, %xmm3
mulsd %xmm5, %xmm3
movapd %xmm8, %xmm2
mulsd %xmm1, %xmm2
divsd %xmm2, %xmm3
addsd %xmm1, %xmm3
movsd %xmm3, 0x1d8(%rbx)
movsd %xmm0, 0x1f0(%rbx)
jmp 0x7958
movsd 0x1d8(%rbx), %xmm0
movsd 0x1f0(%rbx), %xmm1
addsd 0xfce0(%rip), %xmm0     # 0x17620
movsd %xmm0, 0x1d8(%rbx)
addsd 0xfcd8(%rip), %xmm1     # 0x17628
movsd %xmm1, 0x1f0(%rbx)
movsd 0xfcf0(%rip), %xmm0     # 0x17650
ucomisd 0x1d8(%rbx), %xmm0
movabsq $0x4040000000000000, %rax # imm = 0x4040000000000000
jbe 0x797b
movq %rax, 0x1d8(%rbx)
movsd 0x1d8(%rbx), %xmm1
ucomisd 0xfccd(%rip), %xmm1     # 0x17658
movabsq $0x4080000000000000, %rcx # imm = 0x4080000000000000
jbe 0x799e
movq %rcx, 0x1d8(%rbx)
ucomisd 0x1f0(%rbx), %xmm0
jbe 0x79af
movq %rax, 0x1f0(%rbx)
movsd 0x1f0(%rbx), %xmm0
ucomisd 0xfc99(%rip), %xmm0     # 0x17658
jbe 0x79c8
movq %rcx, 0x1f0(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/neuron.C
// Function: Neuron::GetSpikeTimes(std::vector<int, std::allocator<int>>&)
void Neuron::GetSpikeTimes(vector<int>& times){
    if((_name[0] == 'o' || _name[0] == 'h') || !_fire_timings.empty()){
        times = _fire_timings;
    }
    else{
        if(_lsm_channel == NULL){
            times = vector<int>();
        }
        else
            _lsm_channel->GetAllSpikes(times);
    }
}

// Assembly:
movq %rsi, %rcx
movq %rdi, %rax
movq 0x10(%rdi), %rdx
movzbl (%rdx), %edx
cmpl $0x68, %edx
je 0x7a49
cmpl $0x6f, %edx
je 0x7a49
movq 0x88(%rax), %rdx
cmpq 0x90(%rax), %rdx
je 0x7a5a
addq $0x88, %rax
movq %rcx, %rdi
movq %rax, %rsi
jmp 0xa936
movq 0x210(%rax), %rsi
testq %rsi, %rsi
je 0x7a72
addq $0x18, %rsi
movq %rcx, %rdi
jmp 0xa936
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rcx, %rdi
movq %rbx, %rsi
callq 0xb150
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7aa8
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x32f0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/neuron.C
// Function: Neuron::CollectPreSynAct(double&, double&, int&)
void Neuron::CollectPreSynAct(double& p_n, double& avg_i_n, int& max_i_n){
    if(_presyn_act.empty()){
        cout<<"Do you forget to record the pre-synaptic firing activities??\n"
            <<"Or do you mistakenly clear the vector<bool> _presyn_act ?"<<endl;
        assert(!_presyn_act.empty());
    }

    int sum_intvl = 0, cnt_f = 0, max_i = 0;
    int start = -1;
    for(int i = 0; i < _presyn_act.size(); ++i){
        if(_presyn_act[i]){
            ++cnt_f;
            max_i = max(max_i, i - start - 1);
            sum_intvl += i - start - 1;
            start = i;
        }
    }
    max_i = max(max_i, (int)_presyn_act.size() - start - 1);
    sum_intvl += _presyn_act.size() - start - 1;

    p_n = ((double)cnt_f)/((double)_presyn_act.size());
    avg_i_n = ((double)sum_intvl)/(cnt_f+1);
    max_i_n = max_i;
    // clear the presynaptic neuron activity vector after visiting it!
    _presyn_act.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x60(%rdi), %rax
cmpq 0x70(%rdi), %rax
jne 0x7b7e
cmpl $0x0, 0x78(%r14)
jne 0x7b7e
movq 0x194b7(%rip), %r13     # 0x20fd0
leaq 0xfc9f(%rip), %rsi      # 0x177bf
movl $0x3d, %edx
movq %r13, %rdi
callq 0x3340
leaq 0xfcc9(%rip), %rsi      # 0x177fd
movl $0x39, %edx
movq %r13, %rdi
callq 0x3340
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r13, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movq 0x60(%r14), %rax
cmpq 0x70(%r14), %rax
jne 0x7b7e
cmpl $0x0, 0x78(%r14)
je 0x7c54
movq 0x60(%r14), %rax
movq 0x70(%r14), %rdx
movl 0x78(%r14), %ecx
subq %rax, %rdx
shlq $0x3, %rdx
addq %rcx, %rdx
je 0x7bde
xorl %r9d, %r9d
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %esi, %esi
xorl %edi, %edi
xorl %ecx, %ecx
movq %r9, %r10
shrq $0x6, %r10
movq (%rax,%r10,8), %r10
btq %r9, %r10
jae 0x7bd1
incl %esi
leal -0x1(%r9), %r10d
subl %r8d, %r10d
cmpl %r10d, %ecx
cmovlel %r10d, %ecx
addl %r9d, %edi
decl %edi
subl %r8d, %edi
movl %r9d, %r8d
incq %r9
cmpq %r9, %rdx
ja 0x7ba5
notl %r8d
jmp 0x7be7
xorl %ecx, %ecx
xorl %edi, %edi
xorl %esi, %esi
xorl %r8d, %r8d
addl %edx, %r8d
cmpl %r8d, %ecx
cmovlel %r8d, %ecx
cvtsi2sd %esi, %xmm0
movq %rdx, %xmm1
punpckldq 0xf9ae(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xf9b6(%rip), %xmm1     # 0x175c0
addl %r8d, %edi
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
movsd %xmm0, (%r12)
xorps %xmm0, %xmm0
cvtsi2sd %edi, %xmm0
incl %esi
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%r15)
movl %ecx, (%rbx)
movq %rax, 0x70(%r14)
movl $0x0, 0x78(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xfbdc(%rip), %rdi      # 0x17837
leaq 0xfa87(%rip), %rsi      # 0x176e9
leaq 0xfbe3(%rip), %rcx      # 0x1784c
movl $0x1c9, %edx            # imm = 0x1C9
callq 0x31b0
nop
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/neuron.C
// Function: Neuron::RMZeroSyns(synapsetype_t, char const*)
int Neuron::RMZeroSyns(synapsetype_t syn_t, const char * t){
    bool f;
    int cnt = 0;
    if(strcmp(t, "in") == 0)  f = false;
    else if(strcmp(t, "out") == 0)  f = true;
    else assert(0);
    vector<Synapse*>& syns = !f ? _inputSyns : _outputSyns;

    for(auto iter = syns.begin(); iter != syns.end(); ){
        assert(*iter);
        bool flag = syn_t == INPUT_SYN ? (*iter)->IsInputSyn() :
            syn_t == READOUT_SYN ? (*iter)->IsReadoutSyn() : 
            syn_t == RESERVOIR_SYN ? (*iter)->IsLiquidSyn() : false;
        flag &= (*iter)->IsWeightZero();
        if(flag){
            (*iter)->DisableStatus(true); 
            iter = syns.erase(iter);
            cnt++;
        }
        else
            iter++;	       
    }
    return cnt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
leaq 0xf934(%rip), %rsi      # 0x178ff
movq %rdx, %rdi
callq 0x33f0
testl %eax, %eax
je 0x800f
leaq 0x118f2(%rip), %rsi     # 0x198d0
movq %r15, %rdi
callq 0x33f0
movl $0x18, %r12d
testl %eax, %eax
je 0x8015
leaq 0x10339(%rip), %rdi     # 0x18330
leaq 0xf6eb(%rip), %rsi      # 0x176e9
leaq 0xf8fd(%rip), %rcx      # 0x17902
movl $0x235, %edx            # imm = 0x235
callq 0x31b0
movl $0x30, %r12d
movq (%r14,%r12), %r15
cmpq 0x8(%r14,%r12), %r15
je 0x809c
xorl %ebp, %ebp
movq (%r15), %rdi
testq %rdi, %rdi
je 0x80a9
testl %ebx, %ebx
je 0x8046
cmpl $0x2, %ebx
je 0x803f
cmpl $0x1, %ebx
jne 0x804b
callq 0xc29a
jmp 0x8044
callq 0xc268
jmp 0x804d
movb 0x12(%rdi), %al
jmp 0x804d
xorl %eax, %eax
testb %al, %al
je 0x808f
movq (%r15), %rax
movsd 0x38(%rax), %xmm0
ucomisd 0xf5ff(%rip), %xmm0     # 0x17660
jne 0x808f
jp 0x808f
movb $0x1, 0x13(%rax)
movq %r15, %rsi
addq $0x8, %rsi
movq 0x8(%r14,%r12), %rdx
cmpq %rdx, %rsi
je 0x8085
subq %rsi, %rdx
movq %r15, %rdi
callq 0x3520
addq $-0x8, 0x8(%r14,%r12)
incl %ebp
jmp 0x8093
addq $0x8, %r15
cmpq 0x8(%r14,%r12), %r15
jne 0x8022
jmp 0x809e
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf886(%rip), %rdi      # 0x17936
leaq 0xf632(%rip), %rsi      # 0x176e9
leaq 0xf844(%rip), %rcx      # 0x17902
movl $0x239, %edx            # imm = 0x239
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/neuron.C
// Function: Neuron::DeleteSyn(char const*, char)
void Neuron::DeleteSyn(const char * t, const char s){
    bool f;
    if(strcmp(t, "in") == 0)  f = false;
    else if(strcmp(t, "out") == 0)  f = true;
    else assert(0);
    vector<Synapse*>& syns = !f ? _inputSyns : _outputSyns;

    // delete all the input synapses starts with 's':
    for(auto it=syns.begin();it != syns.end(); ){
        Neuron * pre = (*it)->PreNeuron();  assert(pre);
        char * pre_name = pre->Name();  assert(pre_name);
        if(pre_name[0] == s)   it = syns.erase(it);
        else ++it;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0xf820(%rip), %rsi      # 0x178ff
movq %r15, %rdi
callq 0x33f0
testl %eax, %eax
je 0x8123
leaq 0x117de(%rip), %rsi     # 0x198d0
movq %r15, %rdi
callq 0x33f0
movl $0x18, %r12d
testl %eax, %eax
je 0x8129
leaq 0x10225(%rip), %rdi     # 0x18330
leaq 0xf5d7(%rip), %rsi      # 0x176e9
leaq 0xf823(%rip), %rcx      # 0x1793c
movl $0x250, %edx            # imm = 0x250
callq 0x31b0
movl $0x30, %r12d
movq (%r14,%r12), %r15
cmpq 0x8(%r14,%r12), %r15
je 0x8178
movq (%r15), %rdi
callq 0xc3de
testq %rax, %rax
je 0x8184
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x81a3
cmpb %bl, (%rax)
jne 0x8172
movq %r15, %rsi
addq $0x8, %rsi
movq 0x8(%r14,%r12), %rdx
cmpq %rdx, %rsi
je 0x816a
subq %rsi, %rdx
movq %r15, %rdi
callq 0x3520
addq $-0x8, 0x8(%r14,%r12)
jmp 0x812d
addq $0x8, %r15
jmp 0x812d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xf7e2(%rip), %rdi      # 0x1796d
leaq 0xf557(%rip), %rsi      # 0x176e9
leaq 0xf7a3(%rip), %rcx      # 0x1793c
movl $0x255, %edx            # imm = 0x255
callq 0x31b0
leaq 0xf7c7(%rip), %rdi      # 0x17971
leaq 0xf538(%rip), %rsi      # 0x176e9
leaq 0xf784(%rip), %rcx      # 0x1793c
movl $0x256, %edx            # imm = 0x256
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/neuron.C
// Function: Neuron::GetInputSynSqSum(double)
double Neuron::GetInputSynSqSum(double weight_limit){
    if(_inputsyn_sq_sum == -1){
        double sum = 0;
        for(auto it = _inputSyns.begin(); it != _inputSyns.end(); ++it){
            double weight = (*it)->Weight();
            sum += (weight/weight_limit)*(weight/weight_limit);
        }
        _inputsyn_sq_sum = _inputSyns.empty() ? 0 : sum/_inputSyns.size();
    }
    return _inputsyn_sq_sum;
}

// Assembly:
movsd 0x1e0(%rdi), %xmm1
ucomisd 0xf23a(%rip), %xmm1     # 0x17638
jne 0x8471
jp 0x8471
movq 0x30(%rdi), %rcx
movq 0x38(%rdi), %rax
xorpd %xmm2, %xmm2
xorpd %xmm1, %xmm1
cmpq %rax, %rcx
je 0x8437
movq %rcx, %rdx
movq (%rdx), %rsi
movsd 0x38(%rsi), %xmm3
divsd %xmm0, %xmm3
mulsd %xmm3, %xmm3
addsd %xmm3, %xmm1
addq $0x8, %rdx
cmpq %rax, %rdx
jne 0x841a
subq %rcx, %rax
je 0x8469
sarq $0x3, %rax
movq %rax, %xmm0
punpckldq 0xf163(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xf16b(%rip), %xmm0     # 0x175c0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
divsd %xmm2, %xmm1
movapd %xmm1, %xmm2
movsd %xmm2, 0x1e0(%rdi)
movsd 0x1e0(%rdi), %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/neuron.C
// Function: BiasNeuron::LSMNextTimeStep(int, _IO_FILE*, bool, int)
void BiasNeuron::LSMNextTimeStep(int t, FILE * Foutp, bool train, int end_time){
    assert(_mode == NORMAL);
    _fired = false;
    if(t % _dummy_freq == 0){
        HandleFiringActivity(true, t, train);
        _fired = true;
        ++_f_count;
        assert(t > (_fire_timings.empty() ? -1 : _fire_timings.back()));
        _fire_timings.push_back(t);
    }  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, 0xc(%rsp)
cmpl $0x3, 0x8(%rdi)
jne 0x85ad
movq %rdi, %rbx
movb $0x0, 0x130(%rdi)
movl %esi, %eax
cltd
idivl 0x21c(%rdi)
testl %edx, %edx
jne 0x85a0
movq 0x18(%rbx), %r15
movq 0x20(%rbx), %r12
cmpq %r12, %r15
je 0x8545
movzbl %cl, %ebp
movq (%r15), %r14
movq %r14, %rdi
callq 0xc3e2
cmpl $0x0, 0x8(%rax)
je 0x84ff
cmpb $0x0, 0x13(%r14)
je 0x850a
addq $0x8, %r15
cmpq %r12, %r15
jne 0x84e7
jmp 0x8545
movq %r14, %rdi
callq 0xc3f0
movq 0x10(%rbx), %rax
cmpb $0x69, (%rax)
je 0x84ff
cmpl $0x1, 0x8(%rbx)
jne 0x84ff
movq %r14, %rdi
callq 0xc268
testb %al, %al
je 0x84ff
movq 0x120(%rbx), %rsi
movq %r14, %rdi
movl $0x1, %edx
movl %ebp, %ecx
callq 0xc44c
jmp 0x84ff
movb $0x1, 0x130(%rbx)
incl 0x12c(%rbx)
movl 0xc(%rsp), %eax
movq 0x90(%rbx), %rsi
cmpq %rsi, 0x88(%rbx)
je 0x856b
movl -0x4(%rsi), %ecx
jmp 0x8570
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jle 0x85cc
cmpq 0x98(%rbx), %rsi
je 0x858c
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x90(%rbx)
jmp 0x85a0
addq $0x88, %rbx
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x4476
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf406(%rip), %rdi      # 0x179ba
leaq 0xf12e(%rip), %rsi      # 0x176e9
leaq 0xf408(%rip), %rcx      # 0x179ca
movl $0x297, %edx            # imm = 0x297
callq 0x31b0
leaq 0xf0de(%rip), %rdi      # 0x176b1
leaq 0xf10f(%rip), %rsi      # 0x176e9
leaq 0xf3e9(%rip), %rcx      # 0x179ca
movl $0x29d, %edx            # imm = 0x29D
callq 0x31b0
nop
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/neuron.C
// Function: NeuronGroup::Collect4State(int&, int&, int&, int&, int&, int&, int&, int&, int&)
void NeuronGroup::Collect4State(int& ep_max, int& ep_min, int& ip_max, int& ip_min, 
        int& en_max, int& en_min, int& in_max, int& in_min, int& pre_active_max)
{
    for(size_t i = 0; i < _neurons.size(); ++i){
        assert(_neurons[i]);
        ep_max = max(ep_max, _neurons[i]->GetEPMax()), ep_min = min(ep_min, _neurons[i]->GetEPMin());
        en_max = max(en_max, _neurons[i]->GetENMax()), en_min = min(en_min, _neurons[i]->GetENMin());
        ip_max = max(ip_max, _neurons[i]->GetIPMax()), ip_min = min(ip_min, _neurons[i]->GetIPMin());
        in_max = max(in_max, _neurons[i]->GetINMax()), in_min = min(in_min, _neurons[i]->GetINMin());
        pre_active_max = max(pre_active_max, _neurons[i]->GetPreActiveMax());
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
movq 0x30(%rdi), %rdi
subq %rax, %rdi
je 0x97a2
movq 0x58(%rsp), %r10
movq 0x50(%rsp), %r11
movq 0x48(%rsp), %rbx
movq 0x40(%rsp), %r14
sarq $0x3, %rdi
cmpq $0x1, %rdi
adcq $0x0, %rdi
xorl %r15d, %r15d
movq (%rax,%r15,8), %r12
testq %r12, %r12
je 0x97b1
movl 0x144(%r12), %ebp
movl (%rsi), %r13d
cmpl %ebp, %r13d
cmovgl %r13d, %ebp
movl %ebp, (%rsi)
movl 0x148(%r12), %ebp
movl (%rdx), %r13d
cmpl %r13d, %ebp
cmovll %ebp, %r13d
movl %r13d, (%rdx)
movl 0x14c(%r12), %ebp
movl (%r9), %r13d
cmpl %ebp, %r13d
cmovgl %r13d, %ebp
movl %ebp, (%r9)
movl 0x150(%r12), %ebp
movl (%r14), %r13d
cmpl %r13d, %ebp
cmovll %ebp, %r13d
movl %r13d, (%r14)
movl 0x154(%r12), %ebp
movl (%rcx), %r13d
cmpl %ebp, %r13d
cmovgl %r13d, %ebp
movl %ebp, (%rcx)
movl 0x158(%r12), %ebp
movl (%r8), %r13d
cmpl %r13d, %ebp
cmovll %ebp, %r13d
movl %r13d, (%r8)
movl 0x15c(%r12), %ebp
movl (%rbx), %r13d
cmpl %ebp, %r13d
cmovgl %r13d, %ebp
movl %ebp, (%rbx)
movl 0x160(%r12), %ebp
movl (%r11), %r13d
cmpl %r13d, %ebp
cmovll %ebp, %r13d
movl %r13d, (%r11)
movl 0x164(%r12), %ebp
movl (%r10), %r12d
cmpl %ebp, %r12d
cmovgl %r12d, %ebp
movl %ebp, (%r10)
incq %r15
cmpq %r15, %rdi
jne 0x96cf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe5d0(%rip), %rdi      # 0x17d88
leaq 0xdf2a(%rip), %rsi      # 0x176e9
leaq 0xe5ce(%rip), %rcx      # 0x17d94
movl $0x3ce, %edx            # imm = 0x3CE
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/neuron.C
// Function: NeuronGroup::CollectPreSynAct(double&, double&, int&)
void NeuronGroup::CollectPreSynAct(double & p_r, double & avg_i_r, int & max_i_r){
    double p_n = 0.0, avg_i_n = 0.0;
    int max_i_n = 0;
    for(size_t i = 0; i < _neurons.size(); ++i){
        assert(_neurons[i]);
        _neurons[i]->CollectPreSynAct(p_n, avg_i_n, max_i_n);
        p_r += p_n,  avg_i_r += avg_i_n, max_i_r = max(max_i_r, max_i_n);
    }
    p_r = _neurons.empty() ? 0 : p_r/((double)_neurons.size());
    avg_i_r = _neurons.empty() ? 0 : avg_i_r/((double)_neurons.size());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x28(%rdi), %rax
movq 0x30(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
je 0x987f
movq %rdi, %r12
xorl %ebp, %ebp
leaq 0x4(%rsp), %r13
movq (%rax,%rbp,8), %rdi
testq %rdi, %rdi
je 0x98dc
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r13, %rcx
callq 0x7aec
movsd 0x10(%rsp), %xmm0
addsd (%r14), %xmm0
movsd %xmm0, (%r14)
movsd 0x8(%rsp), %xmm0
addsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
movl (%r15), %eax
movl 0x4(%rsp), %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
movl %ecx, (%r15)
incq %rbp
movq 0x28(%r12), %rax
movq 0x30(%r12), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rbp
jb 0x9815
jmp 0x9883
sarq $0x3, %rdx
movq %rdx, %xmm1
punpckldq 0xdd20(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xdd28(%rip), %xmm1     # 0x175c0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
cmpq %rcx, %rax
je 0x98ba
movsd (%r14), %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, (%r14)
je 0x98c9
movsd (%rbx), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe4a5(%rip), %rdi      # 0x17d88
leaq 0xddff(%rip), %rsi      # 0x176e9
leaq 0xe502(%rip), %rcx      # 0x17df3
movl $0x3dd, %edx            # imm = 0x3DD
callq 0x31b0
nop
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/neuron.C
// Function: NeuronGroup::MaxFireCount()
int NeuronGroup::MaxFireCount(){
    int max_count = -1;
    for(int i = 0; i < _neurons.size(); ++i){
        assert(_neurons[i]);
        max_count = max(_neurons[i]->FireCount(), max_count);
    }
    return max_count;
}

// Assembly:
pushq %rax
movq 0x28(%rdi), %rcx
movq 0x30(%rdi), %rdx
subq %rcx, %rdx
je 0x9b7d
sarq $0x3, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdi
testq %rdi, %rdi
je 0x9b84
movl 0x12c(%rdi), %edi
cmpl %eax, %edi
cmovgl %edi, %eax
incq %rsi
cmpq %rsi, %rdx
jne 0x9b5f
jmp 0x9b82
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
leaq 0xe1fd(%rip), %rdi      # 0x17d88
leaq 0xdb57(%rip), %rsi      # 0x176e9
leaq 0xe2d5(%rip), %rcx      # 0x17e6e
movl $0x3fe, %edx            # imm = 0x3FE
callq 0x31b0
nop
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/neuron.C
// Function: NeuronGroup::LSMSetTeacherSignal(int)
void NeuronGroup::LSMSetTeacherSignal(int index){
    assert((index >= 0)&&(index < _neurons.size()));
    for(int i = 0; i < _neurons.size(); i++) _neurons[i]->SetTeacherSignal(-1);
    _neurons[index]->SetTeacherSignal(1);
    //  cout<<"Teacher Signal Set!!!"<<endl;
}

// Assembly:
pushq %rax
testl %esi, %esi
js 0xa2fb
movl %esi, %eax
movq 0x28(%rdi), %rcx
movq 0x30(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0xa2fb
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdi
movl $0xffffffff, 0x114(%rdi) # imm = 0xFFFFFFFF
incq %rsi
cmpq %rsi, %rdx
jne 0xa2d5
movq (%rcx,%rax,8), %rax
movl $0x1, 0x114(%rax)
popq %rax
retq
leaq 0xd981(%rip), %rdi      # 0x17c83
leaq 0xd3e0(%rip), %rsi      # 0x176e9
leaq 0xdcdd(%rip), %rcx      # 0x17fed
movl $0x448, %edx            # imm = 0x448
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/neuron.C
// Function: NeuronGroup::LSMRemoveTeacherSignal(int)
void NeuronGroup::LSMRemoveTeacherSignal(int index){
    assert((index >= 0)&&(index < _neurons.size()));
    //  _neurons[index]->SetTeacherSignal(0);
    for(int i = 0; i < _neurons.size(); i++) _neurons[i]->SetTeacherSignal(0);
    //  cout<<"Teacher Sginal Removed..."<<endl;
}

// Assembly:
pushq %rax
testl %esi, %esi
js 0xa34f
movl %esi, %edx
movq 0x28(%rdi), %rax
movq 0x30(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rdx, %rcx
jbe 0xa34f
xorl %edx, %edx
movq (%rax,%rdx,8), %rsi
movl $0x0, 0x114(%rsi)
incq %rdx
cmpq %rdx, %rcx
jne 0xa337
popq %rax
retq
leaq 0xd92d(%rip), %rdi      # 0x17c83
leaq 0xd38c(%rip), %rsi      # 0x176e9
leaq 0xdcb4(%rip), %rcx      # 0x18018
movl $0x44f, %edx            # imm = 0x44F
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/neuron.C
// Function: NeuronGroup::PrintResSyn(std::basic_ofstream<char, std::char_traits<char>>&)
void NeuronGroup::PrintResSyn(ofstream & f_out){
    assert(f_out.is_open());
    for(size_t i = 0; i < _neurons.size(); ++i){
        _neurons[i]->PrintSyn(f_out,"in", 'r');
        _neurons[i]->PrintSyn(f_out,"out", 'r');
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x70(%rsi), %rdi
callq 0x30b0
testb %al, %al
je 0xa4a4
movq 0x28(%r14), %rax
cmpq %rax, 0x30(%r14)
je 0xa49a
xorl %r13d, %r13d
leaq 0xd4af(%rip), %r15      # 0x178ff
leaq 0xf479(%rip), %r12      # 0x198d0
movq (%rax,%r13,8), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x72, %ecx
callq 0x81c2
movq 0x28(%r14), %rax
movq (%rax,%r13,8), %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl $0x72, %ecx
callq 0x81c2
incq %r13
movq 0x28(%r14), %rax
movq 0x30(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jb 0xa457
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xcbd1(%rip), %rdi      # 0x1707c
leaq 0xd237(%rip), %rsi      # 0x176e9
leaq 0xdb8d(%rip), %rcx      # 0x18046
movl $0x466, %edx            # imm = 0x466
callq 0x31b0
nop
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/synapse.C
// Function: Synapse::IsReadoutSyn()
bool Synapse::IsReadoutSyn(){
    char * name_post = _post->Name();
    // if the post neuron is the readout/hidden neuron:
    if((name_post[0] == 'o' && name_post[6] == '_') || (name_post[0] == 'h' && name_post[6] == '_')){
        return true;
    }
    else{
        return false;
    }
}

// Assembly:
pushq %rax
movq 0x8(%rdi), %rdi
callq 0x6f9c
movzbl (%rax), %edx
cmpl $0x68, %edx
je 0xc28c
cmpl $0x6f, %edx
jne 0xc294
movb $0x1, %cl
cmpb $0x5f, 0x6(%rax)
je 0xc296
cmpb $0x68, %dl
jne 0xc294
movb $0x1, %cl
cmpb $0x5f, 0x6(%rax)
je 0xc296
xorl %ecx, %ecx
movl %ecx, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/synapse.C
// Function: Synapse::IsInputSyn()
bool Synapse::IsInputSyn(){
    char * name_pre = _pre->Name();

    if((name_pre[0] == 'i')&&(name_pre[5] == '_'))
        return true;
    else
        return false;
}

// Assembly:
pushq %rax
movq (%rdi), %rdi
callq 0x6f9c
cmpb $0x69, (%rax)
jne 0xc2b3
movq %rax, %rcx
movb $0x1, %al
cmpb $0x5f, 0x5(%rcx)
je 0xc2b5
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/synapse.C
// Function: Synapse::IsValid()
bool Synapse::IsValid(){
    assert(_pre && _post); 
    return !(_pre->LSMCheckNeuronMode(DEACTIVATED) ||
            _post->LSMCheckNeuronMode(DEACTIVATED) ||
            _disable);
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0xc2de
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0xc2de
cmpl $0x0, 0x8(%rax)
je 0xc2db
cmpl $0x0, 0x8(%rcx)
je 0xc2db
movb 0x13(%rdi), %al
xorb $0x1, %al
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0xbf62(%rip), %rdi      # 0x18248
leaq 0xbebf(%rip), %rsi      # 0x181ac
leaq 0xbf62(%rip), %rcx      # 0x18256
movl $0x4d, %edx
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/synapse.C
// Function: Synapse::LSMLearn(int, int)
void Synapse::LSMLearn(int t, int iteration){
    assert((_fixed==false)&&(_lsm_active==true));
    _lsm_active = false;

    int iter = iteration + 1;

    if(iteration <= 50) iter = 1;
    else if(iteration <= 100) iter = 2;
    else if(iteration <= 150) iter = 4;
    else if(iteration <= 200) iter = 8;
    else if(iteration <= 250) iter = 16;
    else if(iteration <= 300) iter = 32;
    else iter = iteration/4; 

    double weight_old = _lsm_weight;
    _lsm_c = _post->GetCalciumPre();
	int signal=_post->GetTeacherSignal();
    if(_lsm_c>LSM_CAL_MID){
        if((_lsm_c < LSM_CAL_MID+LSM_CAL_BOUND)){
            _lsm_weight += LSM_DELTA_POT/( 1 + iteration/ITER_SEARCH_CONV);
        }
    }else{
        if((_lsm_c > LSM_CAL_MID-LSM_CAL_BOUND)){ 
            _lsm_weight -= LSM_DELTA_DEP/( 1+ iteration/ITER_SEARCH_CONV);
        }
    }
    CheckReadoutWeightOutBound();
}

// Assembly:
cmpb $0x0, 0x11(%rdi)
jne 0xc3be
cmpb $0x0, 0x14(%rdi)
je 0xc3be
movb $0x0, 0x14(%rdi)
movq 0x8(%rdi), %rax
movsd 0x180(%rax), %xmm0
movsd %xmm0, 0x30(%rdi)
ucomisd 0xbe41(%rip), %xmm0     # 0x18170
jbe 0xc360
movsd 0xbe57(%rip), %xmm1     # 0x18190
ucomisd %xmm0, %xmm1
jbe 0xc394
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
divsd 0xbe32(%rip), %xmm1     # 0x18180
addsd 0xb28a(%rip), %xmm1     # 0x175e0
movsd 0xbe3a(%rip), %xmm0     # 0x18198
jmp 0xc386
ucomisd 0xbe10(%rip), %xmm0     # 0x18178
jbe 0xc394
cvtsi2sd %edx, %xmm1
divsd 0xbe0a(%rip), %xmm1     # 0x18180
addsd 0xb262(%rip), %xmm1     # 0x175e0
movsd 0xbe02(%rip), %xmm0     # 0x18188
divsd %xmm1, %xmm0
addsd 0x38(%rdi), %xmm0
movsd %xmm0, 0x38(%rdi)
movsd 0x38(%rdi), %xmm1
movsd 0x40(%rdi), %xmm0
ucomisd %xmm0, %xmm1
jb 0xc3a9
movsd %xmm0, 0x38(%rdi)
xorpd 0xac6f(%rip), %xmm0     # 0x17020
ucomisd 0x38(%rdi), %xmm0
jbe 0xc3bd
movsd %xmm0, 0x38(%rdi)
retq
pushq %rax
leaq 0xbea8(%rip), %rdi      # 0x1826e
leaq 0xbddf(%rip), %rsi      # 0x181ac
leaq 0xbebf(%rip), %rcx      # 0x18293
movl $0x55, %edx
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/synapse.C
// Function: Synapse::LSMActivate(Network*, bool, bool)
void Synapse::LSMActivate(Network * network, bool need_learning, bool train){
    if(_lsm_active)
        cout<<_pre->Name()<<"\t"<<_post->Name()<<endl;

    assert(_lsm_active == false);
    // 1. Add the synapses for firing processing

    //network->LSMAddActiveSyn(this);

    // 2. For the readout synapses, if we are using stdp training in reservoir/input,
    //  just ignore the learning in the readout:
    //  But Make sure that we are going to train this readout synapse if not:
    if(need_learning == true && _fixed == false && train == true){
        network->LSMAddActiveLearnSyn(this);
        // 3. Mark the readout synapse active state:
        _lsm_active = true;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x14(%rdi)
jne 0xc53f
movq (%rbx), %rdi
callq 0x6f9c
testq %rax, %rax
je 0xc498
movq %rax, %r12
movq %rax, %rdi
callq 0x3150
movq 0x14b45(%rip), %rdi     # 0x20fd0
movq %r12, %rsi
movq %rax, %rdx
callq 0x3340
jmp 0xc4b6
movq 0x14b31(%rip), %rax     # 0x20fd0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x3550
movq 0x14b13(%rip), %r12     # 0x20fd0
leaq 0xab6c(%rip), %rsi      # 0x17030
movl $0x1, %edx
movq %r12, %rdi
callq 0x3340
movq 0x8(%rbx), %rdi
callq 0x6f9c
testq %rax, %rax
je 0xc4fe
movq %rax, %r13
movq %rax, %rdi
callq 0x3150
movq 0x14adf(%rip), %rdi     # 0x20fd0
movq %r13, %rsi
movq %rax, %rdx
callq 0x3340
jmp 0xc517
movq (%r12), %rax
movq -0x18(%rax), %rax
leaq (%r12,%rax), %rdi
movl 0x20(%r12,%rax), %esi
orl $0x1, %esi
callq 0x3550
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r12, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
cmpb $0x0, 0x14(%rbx)
jne 0xc592
cmpb $0x0, 0x11(%rbx)
sete %al
andb %r15b, %bpl
andb %al, %bpl
cmpb $0x1, %bpl
jne 0xc583
leaq 0x160(%r14), %r15
movl $0x18, %edi
callq 0x32e0
movq %rbx, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x3060
incq 0x170(%r14)
movb $0x1, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbd1b(%rip), %rdi      # 0x182b4
leaq 0xbc0c(%rip), %rsi      # 0x181ac
leaq 0xbd22(%rip), %rcx      # 0x182c9
movl $0xac, %edx
callq 0x31b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/network.C
// Function: Network::CheckExistence(char*)
bool Network::CheckExistence(char * name){
    for(list<Neuron*>::iterator iter = _individualNeurons.begin(); iter != _individualNeurons.end(); iter++)
        if(strcmp((*iter)->Name(),name) == 0) return true;

    if(_groupNeurons.find(string(name)) != _groupNeurons.end()) return true;

    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, %r15
movq (%r15), %r15
cmpq %rbx, %r15
je 0xcfcf
movq 0x10(%r15), %rdi
callq 0x6f9c
movq %rax, %rdi
movq %r14, %rsi
callq 0x33f0
testl %eax, %eax
jne 0xcfa7
movb $0x1, %bpl
cmpq %rbx, %r15
jne 0xd015
addq $0x18, %rbx
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xaa0c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11b50
testq %rax, %rax
setne %bpl
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd015
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd040
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x3570
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/network.C
// Function: Network::AddNeuron(char*, bool, double)
void Network::AddNeuron(char * name, bool excitatory, double v_mem){
    for(list<Neuron*>::iterator iter = _individualNeurons.begin(); iter != _individualNeurons.end(); iter++)
        assert(strcmp((*iter)->Name(),name) != 0);

    assert(_groupNeurons.find(string(name)) == _groupNeurons.end());

    Neuron * neuron = new Neuron(name, excitatory, this, v_mem);
    _individualNeurons.push_back(neuron);
    _allNeurons.push_back(neuron);
    if(excitatory == true){
        _allExcitatoryNeurons.push_back(neuron);
        neuron->SetExcitatory();
    }else _allInhibitoryNeurons.push_back(neuron);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, 0x10(%rsp)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, %r15
movq (%r15), %r15
cmpq %rbx, %r15
je 0xd0a2
movq 0x10(%r15), %rdi
callq 0x6f9c
movq %rax, %rdi
movq %r14, %rsi
callq 0x33f0
testl %eax, %eax
jne 0xd063
leaq 0xb286(%rip), %rdi      # 0x18310
leaq 0xb2a1(%rip), %rsi      # 0x18332
leaq 0xb2a4(%rip), %rcx      # 0x1833c
movl $0x47, %edx
callq 0x31b0
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0xaa0c
leaq 0x18(%rbx), %rdi
leaq 0x18(%rsp), %rsi
callq 0x11b50
testq %rax, %rax
jne 0xd1a3
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd0e6
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x32f0
movl $0x220, %edi            # imm = 0x220
callq 0x32e0
movq %rax, %r15
movzbl %bpl, %edx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rcx
movsd 0x10(%rsp), %xmm0
callq 0x6c78
movl $0x18, %edi
callq 0x32e0
movq %r15, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3060
incq 0x10(%rbx)
leaq 0x88(%rbx), %r14
movl $0x18, %edi
callq 0x32e0
movq %r15, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3060
incq 0x98(%rbx)
movl $0x18, %edi
callq 0x32e0
movq %r15, 0x10(%rax)
testb %bpl, %bpl
je 0xd182
leaq 0xa0(%rbx), %rsi
movq %rax, %rdi
callq 0x3060
incq 0xb0(%rbx)
movb $0x1, 0x110(%r15)
jmp 0xd198
leaq 0xb8(%rbx), %rsi
movq %rax, %rdi
callq 0x3060
incq 0xc8(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb1c0(%rip), %rdi      # 0x1836a
leaq 0xb181(%rip), %rsi      # 0x18332
leaq 0xb184(%rip), %rcx      # 0x1833c
movl $0x49, %edx
callq 0x31b0
movq %rax, %rbx
movl $0x220, %esi            # imm = 0x220
movq %r15, %rdi
jmp 0xd1e8
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd1f2
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0xd1f2
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3570
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/network.C
// Function: Network::LSMAddSynapse(NeuronGroup*, int, int, int, int, bool)
void Network::LSMAddSynapse(NeuronGroup * pre, int npre, int npost, int value, int random, bool fixed){
    assert(npre == -1 && npost == -1);
    assert(fixed);
    assert(value > 0);
    pre->SetLateral();
    pre->SetLateralWeight(double(value));
    for(Neuron * pre_neuron = pre->First(); pre_neuron != NULL; pre_neuron = pre->Next()){
        for(int i = 0; i < pre->Size(); ++i){
            Neuron * post_neuron = pre->Order(i);
            if(pre_neuron == post_neuron)   continue;
            // weight_value, fixed, weight_limit, is_in_liquid
            LSMAddSynapse(pre_neuron, post_neuron, double(-value), fixed, double(value), false);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
andl %ecx, %edx
cmpl $-0x1, %edx
jne 0xdd09
cmpb $0x0, 0x40(%rsp)
je 0xdd28
movl %r8d, %ebp
testl %r8d, %r8d
jle 0xdd47
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, 0x82(%rsi)
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd %xmm0, 0x88(%rsi)
movq %rsi, %rdi
callq 0x91dc
testq %rax, %rax
je 0xdcfe
movq %rax, %r15
negl %ebp
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rbx), %rax
subq 0x28(%rbx), %rax
shrq $0x3, %rax
testl %eax, %eax
jle 0xdcee
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x930c
cmpq %rax, %r15
je 0xdcdc
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
movsd 0x8(%rsp), %xmm0
movl $0x1, %ecx
movsd 0x10(%rsp), %xmm1
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xaa7c
incl %ebp
movq 0x30(%rbx), %rax
subq 0x28(%rbx), %rax
shrq $0x3, %rax
cmpl %eax, %ebp
jl 0xdca8
movq %rbx, %rdi
callq 0x9222
movq %rax, %r15
testq %rax, %rax
jne 0xdc96
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa7c3(%rip), %rdi      # 0x184d3
leaq 0xa61b(%rip), %rsi      # 0x18332
leaq 0xa7cf(%rip), %rcx      # 0x184ed
movl $0xc8, %edx
callq 0x31b0
leaq 0xa803(%rip), %rdi      # 0x18532
leaq 0xa5fc(%rip), %rsi      # 0x18332
leaq 0xa7b0(%rip), %rcx      # 0x184ed
movl $0xc9, %edx
callq 0x31b0
leaq 0xa7ea(%rip), %rdi      # 0x18538
leaq 0xa5dd(%rip), %rsi      # 0x18332
leaq 0xa791(%rip), %rcx      # 0x184ed
movl $0xca, %edx
callq 0x31b0