LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/channel.C
// Function: Channel::Read(_IO_FILE*)
void Channel::Read(FILE * fp){
	char linestring[8192];
	char * token;
	int spike_t;
	int index;
	while(1){
		if(fgets(linestring,8191,fp)==NULL||linestring[0]=='\n'){
			assert(0);
		}
		token=strtok(linestring," \t\n,");
		index=atoi(token);
		if(index==-1){
			break;
		}
		if(index!=_index)
			assert(0);
		token=strtok(NULL," \t\n,");
		spike_t=atoi(token);
		AddSpike(atoi(token));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2030, %rsp           # imm = 0x2030
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2028(%rbp)
leaq -0x2010(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x1fff, %esi           # imm = 0x1FFF
callq 0x45f0
cmpq $0x0, %rax
je 0x5435
movsbl -0x2010(%rbp), %eax
cmpl $0xa, %eax
jne 0x5454
leaq 0x2fedc(%rip), %rdi     # 0x35318
leaq 0x2ec00(%rip), %rsi     # 0x34043
movl $0x76, %edx
leaq 0x2ec55(%rip), %rcx     # 0x340a4
callq 0x4210
leaq -0x2010(%rbp), %rdi
leaq 0x2ec5d(%rip), %rsi     # 0x340bf
callq 0x45d0
movq %rax, -0x2018(%rbp)
movq -0x2018(%rbp), %rdi
callq 0x45c0
movl %eax, -0x2020(%rbp)
cmpl $-0x1, -0x2020(%rbp)
jne 0x548b
jmp 0x5504
movq -0x2028(%rbp), %rcx
movl -0x2020(%rbp), %eax
cmpl 0x40(%rcx), %eax
je 0x54bc
leaq 0x2fe74(%rip), %rdi     # 0x35318
leaq 0x2eb98(%rip), %rsi     # 0x34043
movl $0x7e, %edx
leaq 0x2ebed(%rip), %rcx     # 0x340a4
callq 0x4210
xorl %eax, %eax
movl %eax, %edi
leaq 0x2ebf8(%rip), %rsi     # 0x340bf
callq 0x45d0
movq %rax, -0x2018(%rbp)
movq -0x2018(%rbp), %rdi
callq 0x45c0
movl %eax, -0x201c(%rbp)
movq -0x2018(%rbp), %rdi
callq 0x45c0
movq -0x2028(%rbp), %rdi
movl %eax, %esi
callq 0x4c60
jmp 0x540e
addq $0x2030, %rsp           # imm = 0x2030
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/speech.C
// Function: Speech::SetNumChannel(int, channelmode_t)
void Speech::SetNumChannel(int size, channelmode_t mode){
    assert(size >= 0);
    while(_channel_map[mode]->size() < size){
        Channel * channel = new Channel(_channel_map[mode]->size());
        channel->SetMode(mode);
        _channel_map[mode]->push_back(channel);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x7222
jmp 0x7241
leaq 0x2cebb(%rip), %rdi     # 0x340e4
leaq 0x2cebe(%rip), %rsi     # 0x340ee
movl $0x25, %edx
leaq 0x2cebb(%rip), %rcx     # 0x340f7
callq 0x4210
jmp 0x7243
movq -0x40(%rbp), %rdi
addq $0x48, %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x8610
movq (%rax), %rdi
callq 0x8860
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jae 0x730b
movl $0x48, %edi
callq 0x4380
movq -0x40(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x48, %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x8610
movq %rax, -0x48(%rbp)
jmp 0x729a
movq -0x48(%rbp), %rax
movq (%rax), %rdi
callq 0x8860
movq -0x50(%rbp), %rdi
movl %eax, %esi
callq 0x4bd0
jmp 0x72b3
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x8880
movq -0x40(%rbp), %rdi
addq $0x48, %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x8610
movq (%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x87f0
jmp 0x7243
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x48, %esi
callq 0x4390
jmp 0x7311
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x46d0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/speech.C
// Function: Speech::ClearChannel(channelmode_t)
void Speech::ClearChannel(channelmode_t channelmode){
    if(_channel_map.find(channelmode) == _channel_map.end()){
        cout<<"Invalid channel type: "<<channelmode<<endl;
        exit(EXIT_FAILURE);
    }

    for(size_t i = 0; i < _channel_map[channelmode]->size(); ++i){
        Channel * channel = (*_channel_map[channelmode])[i]; 
        assert(channel);
        channel->Clear();
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x48, %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x88f0
movq -0x50(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x48, %rdi
callq 0x8920
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x88c0
testb $0x1, %al
jne 0x74b2
jmp 0x74e9
movq 0x45b0f(%rip), %rdi     # 0x4cfc8
leaq 0x2ccb8(%rip), %rsi     # 0x34178
callq 0x4360
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x46c0
movq %rax, %rdi
movq 0x45ade(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movl $0x1, %edi
callq 0x4440
movq $0x0, -0x30(%rbp)
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x48, %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x8610
movq (%rax), %rdi
callq 0x8860
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x7590
movq -0x50(%rbp), %rdi
addq $0x48, %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x44(%rbp)
leaq -0x44(%rbp), %rsi
callq 0x8610
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x88a0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x7557
jmp 0x7576
leaq 0x2d1be(%rip), %rdi     # 0x3471c
leaq 0x2cb89(%rip), %rsi     # 0x340ee
movl $0x42, %edx
leaq 0x2cc1e(%rip), %rcx     # 0x3418f
callq 0x4210
movq -0x40(%rbp), %rdi
callq 0x52b0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x74f1
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x458ed(%rip), %rdi     # 0x4cfc8
leaq 0x2cb2c(%rip), %rsi     # 0x3420e
callq 0x4360
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x8860
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x40d0
movq %rax, %rdi
movq 0x458ae(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x8860
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x7770
movq -0x20(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x88a0
movq (%rax), %rdi
callq 0x8970
movl %eax, %esi
movq 0x45877(%rip), %rdi     # 0x4cfc8
callq 0x46c0
movq %rax, %rdi
leaq 0x2c8c8(%rip), %rsi     # 0x34028
callq 0x4360
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7716
movq 0x45851(%rip), %rdi     # 0x4cfc8
movq 0x4583a(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movq 0x4583e(%rip), %rdi     # 0x4cfc8
leaq 0x2ca94(%rip), %rsi     # 0x34225
callq 0x4360
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x18, %rdi
callq 0x8860
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x40d0
movq %rax, %rdi
movq 0x457fb(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x18, %rdi
callq 0x8860
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x782b
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0x88a0
movq (%rax), %rdi
callq 0x8970
movl %eax, %esi
movq 0x457bc(%rip), %rdi     # 0x4cfc8
callq 0x46c0
movq %rax, %rdi
leaq 0x2c80d(%rip), %rsi     # 0x34028
callq 0x4360
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x77c9
movq 0x45796(%rip), %rdi     # 0x4cfc8
movq 0x4577f(%rip), %rsi     # 0x4cfb8
callq 0x43b0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4160
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movq %rdi, -0x238(%rbp)
movl $0x10, %edx
callq 0x43e0
movq -0x238(%rbp), %rdi
callq 0x4270
movb %al, -0x229(%rbp)
jmp 0x789f
movb -0x229(%rbp), %al
testb $0x1, %al
jne 0x797b
jmp 0x78af
movq 0x45712(%rip), %rdi     # 0x4cfc8
leaq 0x2c983(%rip), %rsi     # 0x34240
callq 0x4360
movq %rax, -0x240(%rbp)
jmp 0x78cb
movq -0x240(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4300
movq %rax, -0x248(%rbp)
jmp 0x78e4
movq -0x248(%rbp), %rdi
leaq 0x2c962(%rip), %rsi     # 0x34254
callq 0x4360
movq %rax, -0x250(%rbp)
jmp 0x7900
movq -0x250(%rbp), %rdi
movq 0x456aa(%rip), %rsi     # 0x4cfb8
callq 0x43b0
jmp 0x7915
leaq -0x218(%rbp), %rdi
callq 0x4270
movb %al, -0x251(%rbp)
jmp 0x7929
movb -0x251(%rbp), %al
testb $0x1, %al
jne 0x7935
jmp 0x7937
jmp 0x7979
leaq 0x2c736(%rip), %rdi     # 0x34074
leaq 0x2c7a9(%rip), %rsi     # 0x340ee
movl $0x63, %edx
leaq 0x2c91c(%rip), %rcx     # 0x3426d
callq 0x4210
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x4570
jmp 0x7a64
jmp 0x797b
leaq 0x2c93a(%rip), %rsi     # 0x342bc
leaq -0x218(%rbp), %rdi
callq 0x4360
movq %rax, -0x260(%rbp)
jmp 0x7997
movq -0x260(%rbp), %rdi
movq 0x45613(%rip), %rsi     # 0x4cfb8
callq 0x43b0
jmp 0x79ac
movl $0x0, -0x228(%rbp)
movslq -0x228(%rbp), %rax
movq %rax, -0x268(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8860
movq %rax, %rcx
movq -0x268(%rbp), %rax
cmpq %rcx, %rax
jae 0x7a10
movq -0x10(%rbp), %rdi
movslq -0x228(%rbp), %rsi
callq 0x8990
movq (%rax), %rdi
leaq -0x218(%rbp), %rsi
callq 0x52d0
jmp 0x79fd
jmp 0x79ff
movl -0x228(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x228(%rbp)
jmp 0x79b6
leaq 0x2c8a5(%rip), %rsi     # 0x342bc
leaq -0x218(%rbp), %rdi
callq 0x4360
movq %rax, -0x270(%rbp)
jmp 0x7a2c
movq -0x270(%rbp), %rdi
movq 0x4557e(%rip), %rsi     # 0x4cfb8
callq 0x43b0
jmp 0x7a41
leaq -0x218(%rbp), %rdi
callq 0x4530
jmp 0x7a4f
leaq -0x218(%rbp), %rdi
callq 0x4570
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8065
jmp 0x8084
leaq 0x2c2c3(%rip), %rdi     # 0x3432f
leaq 0x2c07b(%rip), %rsi     # 0x340ee
movl $0x7e, %edx
leaq 0x2c2b5(%rip), %rcx     # 0x34334
callq 0x4210
movq -0x10(%rbp), %rdi
leaq 0x2c233(%rip), %rsi     # 0x342c2
callq 0x4520
cmpl $0x0, %eax
jne 0x809f
movb $0x0, -0x19(%rbp)
jmp 0x80db
movq -0x10(%rbp), %rdi
leaq 0x2c24d(%rip), %rsi     # 0x342f7
callq 0x4520
cmpl $0x0, %eax
jne 0x80ba
movb $0x1, -0x19(%rbp)
jmp 0x80d9
leaq 0x2d257(%rip), %rdi     # 0x35318
leaq 0x2c026(%rip), %rsi     # 0x340ee
movl $0x82, %edx
leaq 0x2c260(%rip), %rcx     # 0x34334
callq 0x4210
jmp 0x80db
testb $0x1, -0x19(%rbp)
jne 0x80f3
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rsi
movq %rdx, %rdi
callq 0x8120
jmp 0x8107
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rdi, %rdx
addq $0x18, %rdx
callq 0x8120
movq -0x28(%rbp), %rax
movl 0x80(%rax), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x81c0
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8860
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x81a6
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x8990
movq (%rax), %rdi
callq 0x8970
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x46c0
movq %rax, %rdi
leaq 0x2be92(%rip), %rsi     # 0x34028
callq 0x4360
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8147
movq -0x10(%rbp), %rdi
movq 0x44e07(%rip), %rsi     # 0x4cfb8
callq 0x43b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x80000000, -0xc(%rbp) # imm = 0x80000000
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x8860
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x826b
movq -0x20(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x88a0
cmpq $0x0, (%rax)
je 0x8214
jmp 0x8233
leaq 0x2c14e(%rip), %rdi     # 0x34369
leaq 0x2becc(%rip), %rsi     # 0x340ee
movl $0x9d, %edx
leaq 0x2c148(%rip), %rcx     # 0x34376
callq 0x4210
movq -0x20(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x88a0
movq (%rax), %rdi
callq 0x8cb0
movl %eax, -0x14(%rbp)
leaq -0xc(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x8c70
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x81e2
cmpl $0x80000000, -0xc(%rbp) # imm = 0x80000000
jne 0x830f
movq 0x44d49(%rip), %rdi     # 0x4cfc8
leaq 0x2c106(%rip), %rsi     # 0x3438c
callq 0x4360
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0x84(%rax), %esi
callq 0x46c0
movq %rax, %rdi
leaq 0x2c0f3(%rip), %rsi     # 0x3439a
callq 0x4360
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x8860
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x40d0
movq %rax, %rdi
leaq 0x2c0d6(%rip), %rsi     # 0x343a5
callq 0x4360
movq %rax, %rdi
movq 0x44cda(%rip), %rsi     # 0x4cfb8
callq 0x43b0
cmpl $0x80000000, -0xc(%rbp) # imm = 0x80000000
je 0x82ee
jmp 0x830d
leaq 0x2c0c1(%rip), %rdi     # 0x343b6
leaq 0x2bdf2(%rip), %rsi     # 0x340ee
movl $0xa2, %edx
leaq 0x2c06e(%rip), %rcx     # 0x34376
callq 0x4210
jmp 0x830f
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/neuron.C
// Function: Neuron::UpdateDeltaEffect()
void Neuron::UpdateDeltaEffect(){
    if(_mode == DEACTIVATED  || _mode == READCHANNEL)
        return;
    
    _prev_delta_ep = _curr_delta_ep;
    _prev_delta_en = _curr_delta_en;
    _prev_delta_ip = _curr_delta_ip;
    _prev_delta_in = _curr_delta_in;
   
    _curr_delta_ep = 0; 
    _curr_delta_en = 0; 
    _curr_delta_ip = 0; 
    _curr_delta_in = 0; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x8(%rax)
je 0xc320
movq -0x10(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0xc322
jmp 0xc392
movq -0x10(%rbp), %rax
movsd 0xf0(%rax), %xmm0
movsd %xmm0, 0xd0(%rax)
movsd 0xf8(%rax), %xmm0
movsd %xmm0, 0xd8(%rax)
movsd 0x100(%rax), %xmm0
movsd %xmm0, 0xe0(%rax)
movsd 0x108(%rax), %xmm0
movsd %xmm0, 0xe8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0xf0(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0xf8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x100(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x108(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x6f, %eax
je 0xcde8
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x68, %eax
je 0xcde8
movq -0x30(%rbp), %rdi
addq $0x88, %rdi
callq 0x56b0
testb $0x1, %al
jne 0xcdfe
movq -0x30(%rbp), %rsi
addq $0x88, %rsi
movq -0x10(%rbp), %rdi
callq 0x123f0
jmp 0xce53
movq -0x30(%rbp), %rax
cmpq $0x0, 0x210(%rax)
jne 0xce3d
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x41b0
leaq -0x28(%rbp), %rdi
callq 0x5550
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x12640
leaq -0x28(%rbp), %rdi
callq 0x9550
jmp 0xce51
movq -0x30(%rbp), %rax
movq 0x210(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x12670
jmp 0xce53
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/neuron.C
// Function: Neuron::DisableOutputSyn(synapsetype_t)
void Neuron::DisableOutputSyn(synapsetype_t syn_t){
    for(Synapse* synapse : _outputSyns){
        bool flag = syn_t == INPUT_SYN ? synapse->IsInputSyn() :
            syn_t == READOUT_SYN ? synapse->IsReadoutSyn() : 
            syn_t == RESERVOIR_SYN ? synapse->IsLiquidSyn() : false;
        if(flag){
            synapse->DisableStatus(true);
        }
    }

}

// erase the ptr of the input syns given the name of the presynaptic neuron
void Neuron::LSMDeleteInputSynapse(char * pre_name){
    Neuron * pre;
    for(auto iter = _inputSyns.begin(); iter != _inputSyns.end(); ){
        pre = (*iter)->PreNeuron();
        assert(pre != NULL);
        //cout<<pre->Name()<<endl;
        if(strcmp(pre->Name(),pre_name) == 0){
            iter = _inputSyns.erase(iter);
            break;
        }
        else
            iter++;	       
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12080
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x120b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x120e0
testb $0x1, %al
jne 0xd42b
jmp 0xd4b6
leaq -0x20(%rbp), %rdi
callq 0x12120
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0xd44f
movq -0x30(%rbp), %rdi
callq 0x1be50
movb %al, -0x32(%rbp)
jmp 0xd48a
cmpl $0x2, -0xc(%rbp)
jne 0xd463
movq -0x30(%rbp), %rdi
callq 0x1bde0
movb %al, -0x33(%rbp)
jmp 0xd484
cmpl $0x0, -0xc(%rbp)
jne 0xd477
movq -0x30(%rbp), %rdi
callq 0x12960
movb %al, -0x34(%rbp)
jmp 0xd47e
xorl %eax, %eax
movb %al, -0x34(%rbp)
jmp 0xd47e
movb -0x34(%rbp), %al
movb %al, -0x33(%rbp)
movb -0x33(%rbp), %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
andb $0x1, %al
movb %al, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
je 0xd4a6
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x12980
jmp 0xd4a8
leaq -0x20(%rbp), %rdi
callq 0x12160
jmp 0xd415
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x270af(%rip), %rsi     # 0x348b7
callq 0x4520
cmpl $0x0, %eax
jne 0xd818
movb $0x0, -0x12(%rbp)
jmp 0xd854
movq -0x10(%rbp), %rdi
leaq 0x2909d(%rip), %rsi     # 0x368c0
callq 0x4520
cmpl $0x0, %eax
jne 0xd833
movb $0x1, -0x12(%rbp)
jmp 0xd852
leaq 0x27ade(%rip), %rdi     # 0x35318
leaq 0x26e60(%rip), %rsi     # 0x346a1
movl $0x250, %edx            # imm = 0x250
leaq 0x270a7(%rip), %rcx     # 0x348f4
callq 0x4210
jmp 0xd854
testb $0x1, -0x12(%rbp)
jne 0xd868
movq -0x58(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x60(%rbp)
jmp 0xd874
movq -0x58(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x12080
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x120b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x120e0
testb $0x1, %al
jne 0xd8ac
jmp 0xd96b
leaq -0x28(%rbp), %rdi
callq 0x12120
movq (%rax), %rdi
callq 0x1c140
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xd8ca
jmp 0xd8e9
leaq 0x27054(%rip), %rdi     # 0x34925
leaq 0x26dc9(%rip), %rsi     # 0x346a1
movl $0x255, %edx            # imm = 0x255
leaq 0x27010(%rip), %rcx     # 0x348f4
callq 0x4210
movq -0x38(%rbp), %rdi
callq 0xbea0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xd8ff
jmp 0xd91e
leaq 0x27023(%rip), %rdi     # 0x34929
leaq 0x26d94(%rip), %rsi     # 0x346a1
movl $0x256, %edx            # imm = 0x256
leaq 0x26fdb(%rip), %rcx     # 0x348f4
callq 0x4210
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0xd95d
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x12a10
movq -0x68(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x129a0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xd966
leaq -0x28(%rbp), %rdi
callq 0x12160
jmp 0xd889
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movsd 0x1e0(%rax), %xmm0
movsd 0x269af(%rip), %xmm1    # 0x34598
ucomisd %xmm1, %xmm0
jne 0xdcf7
jp 0xdcf7
movq -0x38(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
addq $0x30, %rdi
callq 0x12080
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
callq 0x120b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x120e0
testb $0x1, %al
jne 0xdc36
jmp 0xdc7d
leaq -0x20(%rbp), %rdi
callq 0x12120
movq (%rax), %rdi
callq 0x12140
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
divsd -0x10(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
divsd -0x10(%rbp), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x12160
jmp 0xdc12
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
callq 0x12ae0
testb $0x1, %al
jne 0xdc90
jmp 0xdc9a
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0xdce6
movq -0x38(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
addq $0x30, %rdi
callq 0x12b20
movsd -0x48(%rbp), %xmm0
movq %rax, %xmm1
movaps 0x2696e(%rip), %xmm2    # 0x34630
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x26972(%rip), %xmm2    # 0x34640
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x38(%rbp), %rax
movsd -0x40(%rbp), %xmm0
movsd %xmm0, 0x1e0(%rax)
movq -0x38(%rbp), %rax
movsd 0x1e0(%rax), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x3, 0x8(%rax)
jne 0xddae
jmp 0xddcd
leaq 0x26bbd(%rip), %rdi     # 0x34972
leaq 0x268e5(%rip), %rsi     # 0x346a1
movl $0x297, %edx            # imm = 0x297
leaq 0x26bba(%rip), %rcx     # 0x34982
callq 0x4210
movq -0x28(%rbp), %rcx
movb $0x0, 0x130(%rcx)
movl -0xc(%rbp), %eax
cltd
idivl 0x21c(%rcx)
cmpl $0x0, %edx
jne 0xde94
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %edx
movb -0x19(%rbp), %al
movl $0x1, %esi
andb $0x1, %al
movzbl %al, %ecx
callq 0x121a0
movq -0x28(%rbp), %rdi
movb $0x1, 0x130(%rdi)
movl 0x12c(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x12c(%rdi)
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x88, %rdi
callq 0x56b0
testb $0x1, %al
jne 0xde36
jmp 0xde40
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x30(%rbp)
jmp 0xde55
movq -0x28(%rbp), %rdi
addq $0x88, %rdi
callq 0x6ce0
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
movl -0x30(%rbp), %ecx
cmpl %ecx, %eax
jle 0xde61
jmp 0xde80
leaq 0x26801(%rip), %rdi     # 0x34669
leaq 0x26832(%rip), %rsi     # 0x346a1
movl $0x29d, %edx            # imm = 0x29D
leaq 0x26b07(%rip), %rcx     # 0x34982
callq 0x4210
movq -0x28(%rbp), %rdi
addq $0x88, %rdi
leaq -0xc(%rbp), %rsi
callq 0x5640
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x28, %rdi
callq 0x12d80
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x101b7
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movslq -0x10(%rbp), %rsi
callq 0x12c70
cmpq $0x0, (%rax)
je 0x1015c
jmp 0x1017b
leaq 0x24bdd(%rip), %rdi     # 0x34d40
leaq 0x24537(%rip), %rsi     # 0x346a1
movl $0x3fe, %edx            # imm = 0x3FE
leaq 0x24cb0(%rip), %rcx     # 0x34e26
callq 0x4210
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movslq -0x10(%rbp), %rsi
callq 0x12c70
movq (%rax), %rdi
callq 0x13810
movl %eax, -0x14(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x8c70
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x10122
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/neuron.C
// Function: NeuronGroup::WriteSynWeightsToFile(std::basic_ofstream<char, std::char_traits<char>>&, int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x28, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x13370
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x133e0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x133a0
testb $0x1, %al
jne 0x10215
jmp 0x1026d
leaq -0x30(%rbp), %rdi
callq 0x13410
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x1022e
jmp 0x1024d
leaq 0x24c11(%rip), %rdi     # 0x34e46
leaq 0x24465(%rip), %rsi     # 0x346a1
movl $0x407, %edx            # imm = 0x407
leaq 0x24c05(%rip), %rcx     # 0x34e4d
callq 0x4210
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xd110
leaq -0x30(%rbp), %rdi
callq 0x13930
jmp 0x10202
movq -0x48(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x10291
movq -0x48(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xd110
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x11(%rbp)
jl 0x10ae7
movq -0x20(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x28, %rdi
callq 0x12d80
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
setb %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x10af0
jmp 0x10af2
jmp 0x10b11
leaq 0x24142(%rip), %rdi     # 0x34c3b
leaq 0x23ba1(%rip), %rsi     # 0x346a1
movl $0x448, %edx            # imm = 0x448
leaq 0x24499(%rip), %rcx     # 0x34fa5
callq 0x4210
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x28, %rdi
callq 0x12d80
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x10b62
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movslq -0x10(%rbp), %rsi
callq 0x12c70
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x13a40
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x10b18
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movslq -0xc(%rbp), %rsi
callq 0x12c70
movq (%rax), %rdi
movl $0x1, %esi
callq 0x13a40
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x11(%rbp)
jl 0x10bd7
movq -0x20(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x28, %rdi
callq 0x12d80
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
setb %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x10be0
jmp 0x10be2
jmp 0x10c01
leaq 0x24052(%rip), %rdi     # 0x34c3b
leaq 0x23ab1(%rip), %rsi     # 0x346a1
movl $0x44f, %edx            # imm = 0x44F
leaq 0x243d4(%rip), %rcx     # 0x34fd0
callq 0x4210
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x28, %rdi
callq 0x12d80
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x10c4f
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movslq -0x10(%rbp), %rsi
callq 0x12c70
movq (%rax), %rdi
xorl %esi, %esi
callq 0x13a40
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x10c08
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4270
testb $0x1, %al
jne 0x10da7
jmp 0x10da9
jmp 0x10dc8
leaq 0x232c4(%rip), %rdi     # 0x34074
leaq 0x238ea(%rip), %rsi     # 0x346a1
movl $0x466, %edx            # imm = 0x466
leaq 0x2423b(%rip), %rcx     # 0x34ffe
callq 0x4210
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x28, %rdi
callq 0x12d80
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x10e54
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
callq 0x12c70
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq 0x23aa7(%rip), %rdx     # 0x348b7
movl $0x72, %ecx
callq 0xd980
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
callq 0x12c70
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq 0x25a87(%rip), %rdx     # 0x368c0
movl $0x72, %ecx
callq 0xd980
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x10dd0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/neuron.C
// Function: NeuronGroup::RemoveZeroSyns(synapsetype_t)
void NeuronGroup::RemoveZeroSyns(synapsetype_t syn_type){
    int cnt = 0;
    for(size_t i = 0; i < _neurons.size(); ++i){
        assert(_neurons[i]);
        cnt += _neurons[i]->RMZeroSyns(syn_type, "in");
        cnt += _neurons[i]->RMZeroSyns(syn_type, "out");
    }
    cout<<"The number of zero-out synapses: "<<cnt/2<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x28, %rdi
callq 0x12d80
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x10f46
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
callq 0x12c70
cmpq $0x0, (%rax)
je 0x10ec4
jmp 0x10ee3
leaq 0x23e75(%rip), %rdi     # 0x34d40
leaq 0x237cf(%rip), %rsi     # 0x346a1
movl $0x471, %edx            # imm = 0x471
leaq 0x2414a(%rip), %rcx     # 0x35028
callq 0x4210
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
callq 0x12c70
movq (%rax), %rdi
movl -0xc(%rbp), %esi
leaq 0x239b6(%rip), %rdx     # 0x348b7
callq 0xd5c0
movq -0x20(%rbp), %rdi
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
callq 0x12c70
movq (%rax), %rdi
movl -0xc(%rbp), %esi
leaq 0x25996(%rip), %rdx     # 0x368c0
callq 0xd5c0
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x10e86
movq 0x3c07b(%rip), %rdi     # 0x4cfc8
leaq 0x24104(%rip), %rsi     # 0x35058
callq 0x4360
movq %rax, %rdi
movl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
callq 0x46c0
movq %rax, %rdi
movq 0x3c040(%rip), %rsi     # 0x4cfb8
callq 0x43b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/neuron.C
// Function: Neuron::HandleFiringActivity(bool, int, bool)
inline void Neuron::HandleFiringActivity(bool isInput, int time, bool train){

    for(Synapse * synapse : _outputSyns){
        // need to get rid of the deactivated neuron !
        if(synapse->PostNeuron()->LSMCheckNeuronMode(DEACTIVATED) == true)  continue;

        // need to get rid of the deactivated synapse !
        if(synapse->DisableStatus())  continue;
    
        synapse->LSMDeliverSpike();  
		if(isInput){
			if(_name[0] != 'i'&&_mode == READCHANNEL){
				if(synapse->IsReadoutSyn())
					synapse->LSMActivate(_network, true, train);
			}
		}
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
movl %edx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x12080
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x120b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x120e0
testb $0x1, %al
jne 0x121ff
jmp 0x122ac
leaq -0x28(%rbp), %rdi
callq 0x12120
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1c160
movq %rax, %rdi
xorl %esi, %esi
callq 0x13c70
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1222e
jmp 0x1229e
movq -0x38(%rbp), %rdi
callq 0x13c90
testb $0x1, %al
jne 0x1223d
jmp 0x1223f
jmp 0x1229e
movq -0x38(%rbp), %rdi
callq 0x1c1c0
testb $0x1, -0x9(%rbp)
je 0x1229c
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x69, %eax
je 0x1229a
movq -0x40(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x1229a
movq -0x38(%rbp), %rdi
callq 0x1bde0
testb $0x1, %al
jne 0x12277
jmp 0x12298
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movq 0x120(%rax), %rsi
movb -0x11(%rbp), %al
movl $0x1, %edx
andb $0x1, %al
movzbl %al, %ecx
callq 0x1c2b0
jmp 0x1229a
jmp 0x1229c
jmp 0x1229e
leaq -0x28(%rbp), %rdi
callq 0x12160
jmp 0x121e9
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xbea0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6f, %eax
jne 0x1be16
movq -0x18(%rbp), %rax
movsbl 0x6(%rax), %eax
cmpl $0x5f, %eax
je 0x1be2f
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x68, %eax
jne 0x1be35
movq -0x18(%rbp), %rax
movsbl 0x6(%rax), %eax
cmpl $0x5f, %eax
jne 0x1be35
movb $0x1, -0x1(%rbp)
jmp 0x1be39
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xbea0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x69, %eax
jne 0x1be8b
movq -0x18(%rbp), %rax
movsbl 0x5(%rax), %eax
cmpl $0x5f, %eax
jne 0x1be8b
movb $0x1, -0x1(%rbp)
jmp 0x1be8f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/synapse.C
// Function: Synapse::IsValid()
bool Synapse::IsValid(){
    assert(_pre && _post); 
    return !(_pre->LSMCheckNeuronMode(DEACTIVATED) ||
            _post->LSMCheckNeuronMode(DEACTIVATED) ||
            _disable);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x9(%rbp)
je 0x1bece
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x1bed7
jmp 0x1bed9
jmp 0x1bef8
leaq 0x19350(%rip), %rdi     # 0x35230
leaq 0x192ad(%rip), %rsi     # 0x35194
movl $0x4d, %edx
leaq 0x1934b(%rip), %rcx     # 0x3523e
callq 0x4210
movq -0x18(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x13c70
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0x1bf37
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x13c70
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0x1bf37
movq -0x18(%rbp), %rax
movb 0x13(%rax), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/synapse.C
// Function: Synapse::LSMDeliverSpike()
void Synapse::LSMDeliverSpike(){
    double effect = _lsm_weight;

    if(_excitatory){
        _post->IncreaseEP(effect);
        _post->IncreaseEN(effect);
    }
    else{
        _post->IncreaseIP(effect);
        _post->IncreaseIN(effect);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsd 0x38(%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
testb $0x1, 0x10(%rax)
je 0x1c20a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x1c4f0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x1c520
jmp 0x1c22e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x1c550
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x1c580
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/synapse.C
// Function: Synapse::LSMClear()
void Synapse::LSMClear(){
    _lsm_active = false;

    _mem_pos = 0;
    _mem_neg = 0;    

    _lsm_spike = 0;
    _lsm_delay = 0;
    _lsm_c = 0;


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x14(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
movl $0x0, 0x28(%rax)
movl $0x0, 0x2c(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x14(%rax)
je 0x1c336
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xbea0
movq %rax, %rsi
movq 0x30cd5(%rip), %rdi     # 0x4cfc8
callq 0x4360
movq %rax, %rdi
leaq 0x17d26(%rip), %rsi     # 0x34028
callq 0x4360
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rdi
callq 0xbea0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x4360
movq %rax, %rdi
movq 0x30c87(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movq -0x20(%rbp), %rax
movb 0x14(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1c349
jmp 0x1c368
leaq 0x18f4c(%rip), %rdi     # 0x3529c
leaq 0x18e3d(%rip), %rsi     # 0x35194
movl $0xac, %edx
leaq 0x18f4e(%rip), %rcx     # 0x352b1
callq 0x4210
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1c3a8
movq -0x20(%rbp), %rax
movb 0x11(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1c3a8
movb -0x12(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1c3a8
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x1c5b0
movq -0x20(%rbp), %rax
movb $0x1, 0x14(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x239e0
movq %rax, -0x20(%rbp)
movq -0x80(%rbp), %rdi
callq 0x23a40
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x23a10
testb $0x1, %al
jne 0x1d204
jmp 0x1d242
leaq -0x20(%rbp), %rdi
callq 0x23a70
movq (%rax), %rdi
callq 0xbea0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x4520
cmpl $0x0, %eax
jne 0x1d22f
movb $0x1, -0x1(%rbp)
jmp 0x1d323
jmp 0x1d231
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x23a90
movq %rax, -0x30(%rbp)
jmp 0x1d1e4
movq -0x80(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x46f0
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x12880
jmp 0x1d285
movq -0x98(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x23f10
movq %rax, -0xa0(%rbp)
jmp 0x1d29e
movq -0x80(%rbp), %rdi
movq -0xa0(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x18, %rdi
callq 0x23af0
movq %rax, -0x78(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x23b20
movb %al, -0xa1(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4200
leaq -0x59(%rbp), %rdi
callq 0x43d0
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x1d2eb
jmp 0x1d31f
movb $0x1, -0x1(%rbp)
jmp 0x1d323
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x1d314
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4200
leaq -0x59(%rbp), %rdi
callq 0x43d0
jmp 0x1d331
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x46d0
nopw (%rax,%rax)