LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0x14(%rbp)
movb %al, -0x41(%rbp)
jne 0x1e643
cmpl $-0x1, -0x18(%rbp)
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x1e64c
jmp 0x1e64e
jmp 0x1e66d
leaq 0x16e66(%rip), %rdi     # 0x354bb
leaq 0x16cbe(%rip), %rsi     # 0x3531a
movl $0xc8, %edx
leaq 0x16e6d(%rip), %rcx     # 0x354d5
callq 0x4210
testb $0x1, -0x21(%rbp)
je 0x1e675
jmp 0x1e694
leaq 0x16e9e(%rip), %rdi     # 0x3551a
leaq 0x16c97(%rip), %rsi     # 0x3531a
movl $0xc9, %edx
leaq 0x16e46(%rip), %rcx     # 0x354d5
callq 0x4210
cmpl $0x0, -0x1c(%rbp)
jle 0x1e69c
jmp 0x1e6bb
leaq 0x16e7d(%rip), %rdi     # 0x35520
leaq 0x16c70(%rip), %rsi     # 0x3531a
movl $0xca, %edx
leaq 0x16e1f(%rip), %rcx     # 0x354d5
callq 0x4210
movq -0x10(%rbp), %rdi
callq 0x24090
movq -0x10(%rbp), %rdi
cvtsi2sdl -0x1c(%rbp), %xmm0
callq 0x240b0
movq -0x10(%rbp), %rdi
callq 0xf110
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1e773
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
callq 0x24070
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jge 0x1e75f
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0xf490
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x40(%rbp), %rax
jne 0x1e725
jmp 0x1e754
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdx
xorl %eax, %eax
subl -0x1c(%rbp), %eax
cvtsi2sd %eax, %xmm0
movb -0x21(%rbp), %al
cvtsi2sdl -0x1c(%rbp), %xmm1
xorl %r8d, %r8d
xorl %ecx, %ecx
movl %ecx, %r9d
andb $0x1, %al
movzbl %al, %ecx
callq 0x12da0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1e6f1
jmp 0x1e761
movq -0x10(%rbp), %rdi
callq 0xf1d0
movq %rax, -0x30(%rbp)
jmp 0x1e6df
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/network.C
// Function: Network::LSMAddSynapse(NeuronGroup*, NeuronGroup*, int, int, int, int, bool)
void Network::LSMAddSynapse(NeuronGroup * pre, NeuronGroup * post, int npre, int npost, int value, int random, bool fixed){
    assert((npre == 1)||(npre == -1));
    for(Neuron * neuron = pre->First(); neuron != NULL; neuron = pre->Next()){
        LSMAddSynapse(neuron,post,npost,value, random, fixed);
    }
    if(pre->GetBiasNeuron() != NULL){
        BiasNeuron * b_neuron = pre->GetBiasNeuron();
        LSMAddSynapse(b_neuron, post, npost, value, 0, fixed);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb 0x18(%rbp), %al
movl 0x10(%rbp), %r10d
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
andb $0x1, %al
movb %al, -0x25(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x1, %al
cmpl $0x1, -0x1c(%rbp)
movb %al, -0x39(%rbp)
je 0x1e7c8
cmpl $-0x1, -0x1c(%rbp)
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x1e7d1
jmp 0x1e7d3
jmp 0x1e7f2
leaq 0x16d50(%rip), %rdi     # 0x3552a
leaq 0x16b39(%rip), %rsi     # 0x3531a
movl $0xd8, %edx
leaq 0x16d57(%rip), %rcx     # 0x35544
callq 0x4210
movq -0x10(%rbp), %rdi
callq 0xf110
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1e83c
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
movl 0x10(%rbp), %r9d
movb -0x25(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, (%rsp)
callq 0x1e390
movq -0x10(%rbp), %rdi
callq 0xf1d0
movq %rax, -0x30(%rbp)
jmp 0x1e7ff
movq -0x10(%rbp), %rdi
callq 0x240d0
cmpq $0x0, %rax
je 0x1e87e
movq -0x10(%rbp), %rdi
callq 0x240d0
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
movb -0x25(%rbp), %al
xorl %r9d, %r9d
andb $0x1, %al
movzbl %al, %eax
movl %eax, (%rsp)
callq 0x1e390
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/network.C
// Function: Network::LSMAddSynapse(char*, char*, int, int, int, int, bool)
void Network::LSMAddSynapse(char * pre, char * post, int npre, int npost, int value, int random, bool fixed){
    NeuronGroup * preNeuronGroup = SearchForNeuronGroup(pre);
    NeuronGroup * postNeuronGroup = SearchForNeuronGroup(post);
    assert((preNeuronGroup != NULL)&&(postNeuronGroup != NULL));
    
    // add synapses
    if(strcmp(pre, post) != 0) // between layer connections
        LSMAddSynapse(preNeuronGroup, postNeuronGroup, npre, npost, value, random, fixed);
    else{ // laterial inhibition
        assert(preNeuronGroup == postNeuronGroup);
        LSMAddSynapse(preNeuronGroup, npre, npost, value, random, fixed);
    } 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb 0x18(%rbp), %al
movl 0x10(%rbp), %r10d
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
andb $0x1, %al
movb %al, -0x25(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1e9c0
movq -0x48(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1e9c0
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x39(%rbp)
je 0x1e8f8
cmpq $0x0, -0x38(%rbp)
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x1e901
jmp 0x1e903
jmp 0x1e922
leaq 0x16c8e(%rip), %rdi     # 0x35598
leaq 0x16a09(%rip), %rsi     # 0x3531a
movl $0xe5, %edx
leaq 0x16caf(%rip), %rcx     # 0x355cc
callq 0x4210
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4520
cmpl $0x0, %eax
je 0x1e966
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movl 0x10(%rbp), %r10d
movb -0x25(%rbp), %al
andb $0x1, %al
movl %r10d, (%rsp)
movzbl %al, %eax
movl %eax, 0x8(%rsp)
callq 0x1e780
jmp 0x1e9b7
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0x1e972
jmp 0x1e991
leaq 0x16c99(%rip), %rdi     # 0x35612
leaq 0x1699a(%rip), %rsi     # 0x3531a
movl $0xeb, %edx
leaq 0x16c40(%rip), %rcx     # 0x355cc
callq 0x4210
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
movl 0x10(%rbp), %r9d
movb -0x25(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, (%rsp)
callq 0x1e600
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/network.C
// Function: Network::PrintSize()
void Network::PrintSize(){
    cout<<"Total Number of neurons: "<<_allNeurons.size()<<endl;
    cout<<"Total Number of synapses: "<<_synapses.size()<<endl;
    int numExitatory = 0;
    int numLearning = 0;
    for(list<Synapse*>::iterator iter = _synapses.begin(); iter != _synapses.end(); iter++){
        if((*iter)->Excitatory()==true) numExitatory++;
        if((*iter)->Fixed()==false) numLearning++;
    }
    cout<<"\tNumber of excitatory synapses: "<<numExitatory<<endl;
    cout<<"\tNumber of learning synapses: "<<numLearning<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x2e45d(%rip), %rdi     # 0x4cfc8
leaq 0x16ac2(%rip), %rsi     # 0x35634
callq 0x4360
movq -0x30(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x88, %rdi
callq 0x240f0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x40d0
movq %rax, %rdi
movq 0x2e417(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movq 0x2e41b(%rip), %rdi     # 0x4cfc8
leaq 0x16a9a(%rip), %rsi     # 0x3564e
callq 0x4360
movq -0x30(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x100, %rdi            # imm = 0x100
callq 0x24120
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x40d0
movq %rax, %rdi
movq 0x2e3d5(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movq -0x30(%rbp), %rdi
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
addq $0x100, %rdi            # imm = 0x100
callq 0x23bb0
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x172a0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x23be0
testb $0x1, %al
jne 0x1ec31
jmp 0x1ec8f
leaq -0x18(%rbp), %rdi
callq 0x23c10
movq (%rax), %rdi
callq 0x1c180
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1ec55
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x23c10
movq (%rax), %rdi
callq 0x1c1a0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1ec79
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1ec7b
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x24150
movq %rax, -0x28(%rbp)
jmp 0x1ec0a
movq 0x2e332(%rip), %rdi     # 0x4cfc8
leaq 0x169cc(%rip), %rsi     # 0x35669
callq 0x4360
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x46c0
movq %rax, %rdi
movq 0x2e301(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movq 0x2e305(%rip), %rdi     # 0x4cfc8
leaq 0x169c0(%rip), %rsi     # 0x3568a
callq 0x4360
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x46c0
movq %rax, %rdi
movq 0x2e2d4(%rip), %rsi     # 0x4cfb8
callq 0x43b0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/network.C
// Function: Network::LSMClearSignals()
void Network::LSMClearSignals(){
    for(list<Neuron*>::iterator iter = _allNeurons.begin(); iter != _allNeurons.end(); iter++) (*iter)->LSMClear();
    for(list<Synapse*>::iterator iter = _synapses.begin(); iter != _synapses.end(); iter++) (*iter)->LSMClear();
    // Remember to clear the list to store the synapses:      
    _lsmActiveLearnSyns.clear();                              
    _lsmActiveSyns.clear();
    _sp = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x88, %rdi
callq 0x239e0
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rdi
addq $0x88, %rdi
callq 0x23a40
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x23a10
testb $0x1, %al
jne 0x1f0cb
jmp 0x1f0ed
leaq -0x10(%rbp), %rdi
callq 0x23a70
movq (%rax), %rdi
callq 0xc020
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x23a90
movq %rax, -0x20(%rbp)
jmp 0x1f0a4
movq -0x40(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x23bb0
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x172a0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x23be0
testb $0x1, %al
jne 0x1f128
jmp 0x1f14a
leaq -0x28(%rbp), %rdi
callq 0x23c10
movq (%rax), %rdi
callq 0x1c240
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x24150
movq %rax, -0x38(%rbp)
jmp 0x1f101
movq -0x40(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
callq 0x24200
movq -0x40(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
callq 0x24200
movq -0x40(%rbp), %rax
movq $0x0, 0x260(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/network.C
// Function: Network::LoadFirstSpeech(bool, networkmode_t, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Network::LoadFirstSpeech(bool train, networkmode_t networkmode, const string sample_type){
    LSMLoadLayers();

    neuronmode_t neuronmode_input = NORMAL, neuronmode_reservoir = NORMAL, neuronmode_readout = NORMAL;
    // determine the neuron mode by the network mode:
    DetermineNetworkNeuronMode(networkmode, neuronmode_input, neuronmode_reservoir, neuronmode_readout); 
    auto sp_end_ptr = _speeches.end();
    _sp_iter = _speeches.begin();

    if(_sp_iter != sp_end_ptr){
        LoadSpeeches(*_sp_iter, neuronmode_input, neuronmode_reservoir, neuronmode_readout, train);
        return (*_sp_iter)->Index();
    }else{
        _sp = NULL;
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x21060
movq -0x48(%rbp), %rdi
movl $0x3, -0x24(%rbp)
movl $0x3, -0x28(%rbp)
movl $0x3, -0x2c(%rbp)
leaq -0x18(%rbp), %rsi
leaq -0x24(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x2c(%rbp), %r8
callq 0x211b0
movq -0x48(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
callq 0x23d20
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x208, %rdi            # imm = 0x208
callq 0x23cb0
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, 0x220(%rdi)
addq $0x220, %rdi            # imm = 0x220
leaq -0x38(%rbp), %rsi
callq 0x23ce0
testb $0x1, %al
jne 0x1f223
jmp 0x1f26f
movq -0x48(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
callq 0x23d50
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
movl -0x2c(%rbp), %r8d
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %r9d
callq 0x20dc0
movq -0x48(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
callq 0x23d50
movq (%rax), %rdi
callq 0x24310
movl %eax, -0x4(%rbp)
jmp 0x1f285
movq -0x48(%rbp), %rax
movq $0x0, 0x260(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/network.C
// Function: Network::SpeechEndTime()
int Network::SpeechEndTime(){
    if(_sp == NULL){
        cout<<"In Network::EndSpeechTime(), find out the attached _sp in network"
            <<" is valid!!"<< endl;
        assert(_sp != NULL);
    }
    return _sp->EndTime();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x260(%rax)
jne 0x1f310
movq 0x2dd13(%rip), %rdi     # 0x4cfc8
leaq 0x16459(%rip), %rsi     # 0x35715
callq 0x4360
movq %rax, %rdi
leaq 0x1648c(%rip), %rsi     # 0x35757
callq 0x4360
movq %rax, %rdi
movq 0x2dcde(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x260(%rax)
je 0x1f2ef
jmp 0x1f30e
leaq 0x1646d(%rip), %rdi     # 0x35763
leaq 0x1601d(%rip), %rsi     # 0x3531a
movl $0x1a7, %edx            # imm = 0x1A7
leaq 0x16466(%rip), %rcx     # 0x3576f
callq 0x4210
jmp 0x1f310
movq -0x10(%rbp), %rax
movq 0x260(%rax), %rdi
callq 0x81c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/network.C
// Function: Network::LSMEndOfSpeech(networkmode_t, int)
bool Network::LSMEndOfSpeech(networkmode_t networkmode, int end_time){

    if((networkmode == TRANSIENTSTATE)&&(_lsm_input>0)){
        return false;
    }
    if((networkmode != VOID)&&(_lsm_reservoir > 0 || _lsm_input > 0)){
        return false;
    }
    return true;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1f35f
movq -0x20(%rbp), %rax
cmpl $0x0, 0x2b0(%rax)
jle 0x1f35f
movb $0x0, -0x1(%rbp)
jmp 0x1f389
cmpl $0x2, -0x14(%rbp)
je 0x1f385
movq -0x20(%rbp), %rax
cmpl $0x0, 0x2b4(%rax)
jg 0x1f37f
movq -0x20(%rbp), %rax
cmpl $0x0, 0x2b0(%rax)
jle 0x1f385
movb $0x0, -0x1(%rbp)
jmp 0x1f389
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/network.C
// Function: Network::LSMNextTimeStep(int, bool, int, int, _IO_FILE*)
void Network::LSMNextTimeStep(int t, bool train,int iteration,int end_time, FILE * Foutp){
    _lsm_t = t;
	vector<int> state; 

    _lsmActiveSyns.clear();

    // Please remember that the neuron firing activity will change the list: 
    // _lsmActiveSyns, _lsmActiveSTDPLearnSyns, and _lsmActiveLearnSyns:
    for(Neuron * neuron : _allNeurons){
		neuron->LSMNextTimeStep(t, Foutp, train, end_time);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x2bc(%rax)
leaq -0x38(%rbp), %rdi
callq 0x5550
movq -0xb0(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
callq 0x24200
movq -0xb0(%rbp), %rax
addq $0x88, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x239e0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x23a40
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x23a10
testb $0x1, %al
jne 0x1f422
jmp 0x1f479
leaq -0x48(%rbp), %rdi
callq 0x23a70
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x18(%rbp), %r8d
movq (%rdi), %rax
movq (%rax), %rax
movzbl -0xd(%rbp), %ecx
andl $0x1, %ecx
callq *%rax
jmp 0x1f452
jmp 0x1f454
leaq -0x48(%rbp), %rdi
callq 0x24230
jmp 0x1f40f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9550
jmp 0x1f5bc
movq -0xb0(%rbp), %rax
addq $0x88, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x239e0
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
callq 0x23a40
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x23a10
testb $0x1, %al
jne 0x1f4b7
jmp 0x1f4e5
leaq -0x78(%rbp), %rdi
callq 0x23a70
movq (%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
callq 0xc300
jmp 0x1f4d8
jmp 0x1f4da
leaq -0x78(%rbp), %rdi
callq 0x24230
jmp 0x1f4a4
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1f5aa
movq -0xb0(%rbp), %rax
cmpl $0x1, 0x2c0(%rax)
jne 0x1f5aa
movq -0xb0(%rbp), %rax
addq $0x160, %rax            # imm = 0x160
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
callq 0x23bb0
movq %rax, -0x98(%rbp)
movq -0x90(%rbp), %rdi
callq 0x172a0
movq %rax, -0xa0(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x23be0
testb $0x1, %al
jne 0x1f55d
jmp 0x1f597
leaq -0x98(%rbp), %rdi
callq 0x23c10
movq (%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x1bf50
jmp 0x1f587
jmp 0x1f589
leaq -0x98(%rbp), %rdi
callq 0x23c90
jmp 0x1f544
movq -0xb0(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
callq 0x24200
leaq -0x38(%rbp), %rdi
callq 0x9550
addq $0xb0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/network.C
// Function: Network::LSMClearSignalsIP()
void Network::LSMClearSignalsIP(){
    for(list<Neuron*>::iterator iter = _allNeurons.begin(); iter != _allNeurons.end(); iter++) (*iter)->LSMClearIP();
    for(list<Synapse*>::iterator iter = _synapses.begin(); iter != _synapses.end(); iter++) (*iter)->LSMClear();
    // Remember to clear the list to store the synapses:      
    _lsmActiveLearnSyns.clear();                              
    _lsmActiveSyns.clear();
    _sp = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x88, %rdi
callq 0x239e0
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rdi
addq $0x88, %rdi
callq 0x23a40
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x23a10
testb $0x1, %al
jne 0x1f9ab
jmp 0x1f9cd
leaq -0x10(%rbp), %rdi
callq 0x23a70
movq (%rax), %rdi
callq 0xc1a0
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x23a90
movq %rax, -0x20(%rbp)
jmp 0x1f984
movq -0x40(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x23bb0
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x172a0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x23be0
testb $0x1, %al
jne 0x1fa08
jmp 0x1fa2a
leaq -0x28(%rbp), %rdi
callq 0x23c10
movq (%rax), %rdi
callq 0x1c240
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x24150
movq %rax, -0x38(%rbp)
jmp 0x1f9e1
movq -0x40(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
callq 0x24200
movq -0x40(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
callq 0x24200
movq -0x40(%rbp), %rax
movq $0x0, 0x260(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/network.C
// Function: Network::LoadSpeechAgain(bool, networkmode_t, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Network::LoadSpeechAgain(bool train, networkmode_t networkmode, const string sample_type){
    assert(_lsm_input_layer != NULL);
    assert(_lsm_reservoir_layer != NULL);
    assert(_lsm_output_layer != NULL);

    neuronmode_t neuronmode_input = NORMAL, neuronmode_reservoir = NORMAL, neuronmode_readout = NORMAL;
    // determine the neuron mode by the network mode:
    DetermineNetworkNeuronMode(networkmode, neuronmode_input, neuronmode_reservoir, neuronmode_readout);

    if(train == true) _lsm_output_layer->LSMRemoveTeacherSignal((*_sp_iter)->Class());

    LoadSpeeches(*_sp_iter, neuronmode_input, neuronmode_reservoir, neuronmode_readout, train);
    return (*_sp_iter)->Index();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x268(%rax)
je 0x1fa8f
jmp 0x1faae
leaq 0x15df5(%rip), %rdi     # 0x3588b
leaq 0x1587d(%rip), %rsi     # 0x3531a
movl $0x233, %edx            # imm = 0x233
leaq 0x15ea9(%rip), %rcx     # 0x35952
callq 0x4210
movq -0x30(%rbp), %rax
cmpq $0x0, 0x270(%rax)
je 0x1fabe
jmp 0x1fadd
leaq 0x15dfc(%rip), %rdi     # 0x358c1
leaq 0x1584e(%rip), %rsi     # 0x3531a
movl $0x234, %edx            # imm = 0x234
leaq 0x15e7a(%rip), %rcx     # 0x35952
callq 0x4210
movq -0x30(%rbp), %rax
cmpq $0x0, 0x2a8(%rax)
je 0x1faed
jmp 0x1fb0c
leaq 0x15dea(%rip), %rdi     # 0x358de
leaq 0x1581f(%rip), %rsi     # 0x3531a
movl $0x235, %edx            # imm = 0x235
leaq 0x15e4b(%rip), %rcx     # 0x35952
callq 0x4210
movq -0x30(%rbp), %rdi
movl $0x3, -0x1c(%rbp)
movl $0x3, -0x20(%rbp)
movl $0x3, -0x24(%rbp)
leaq -0x10(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x24(%rbp), %r8
callq 0x211b0
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1fb75
movq -0x30(%rbp), %rdi
movq 0x2a8(%rdi), %rax
movq %rax, -0x38(%rbp)
addq $0x220, %rdi            # imm = 0x220
callq 0x23d50
movq (%rax), %rdi
callq 0x242f0
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x10b90
movq -0x30(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
callq 0x23d50
movq -0x30(%rbp), %rdi
movq (%rax), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %r9d
callq 0x20dc0
movq -0x30(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
callq 0x23d50
movq (%rax), %rdi
callq 0x24310
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/network.C
// Function: Network::LoadFirstSpeechTestCV(networkmode_t)
int Network::LoadFirstSpeechTestCV(networkmode_t networkmode){
    assert((_fold_ind>=0)&&(_fold_ind<_fold));

    LSMLoadLayers();
    neuronmode_t neuronmode_input = NORMAL, neuronmode_reservoir = NORMAL, neuronmode_readout = NORMAL;
    // determine the neuron mode by the network mode:
    DetermineNetworkNeuronMode(networkmode, neuronmode_input, neuronmode_reservoir, neuronmode_readout); 


    assert(!_CVspeeches.empty());
    _cv_test_sp_iter = _CVspeeches[_fold_ind].begin();
    if(_cv_test_sp_iter != _CVspeeches[_fold_ind].end()){
        LoadSpeeches(*_cv_test_sp_iter, neuronmode_input, neuronmode_reservoir, neuronmode_readout, false);
        return (*_cv_test_sp_iter)->Index();
    }else{
        _sp = NULL;
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x40(%rbp)
xorl %eax, %eax
cmpl $0x0, 0x22c(%rcx)
movb %al, -0x31(%rbp)
jl 0x2065b
movq -0x40(%rbp), %rcx
movl 0x22c(%rcx), %eax
cmpl 0x228(%rcx), %eax
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x20664
jmp 0x20666
jmp 0x20685
leaq 0x15325(%rip), %rdi     # 0x35992
leaq 0x14ca6(%rip), %rsi     # 0x3531a
movl $0x27d, %edx            # imm = 0x27D
leaq 0x153d9(%rip), %rcx     # 0x35a59
callq 0x4210
movq -0x40(%rbp), %rdi
callq 0x21060
movq -0x40(%rbp), %rdi
movl $0x3, -0x18(%rbp)
movl $0x3, -0x1c(%rbp)
movl $0x3, -0x20(%rbp)
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x1c(%rbp), %rcx
leaq -0x20(%rbp), %r8
callq 0x211b0
movq -0x40(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
callq 0x24370
xorb $-0x1, %al
testb $0x1, %al
jne 0x206d4
jmp 0x206d6
jmp 0x206f5
leaq 0x1530a(%rip), %rdi     # 0x359e7
leaq 0x14c36(%rip), %rsi     # 0x3531a
movl $0x285, %edx            # imm = 0x285
leaq 0x15369(%rip), %rcx     # 0x35a59
callq 0x4210
movq -0x40(%rbp), %rax
movq %rax, %rdi
addq $0x238, %rdi            # imm = 0x238
movslq 0x22c(%rax), %rsi
callq 0x243b0
movq %rax, %rdi
callq 0x23cb0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x258(%rax)
movq %rax, %rcx
addq $0x258, %rcx            # imm = 0x258
movq %rcx, -0x48(%rbp)
movq %rax, %rdi
addq $0x238, %rdi            # imm = 0x238
movslq 0x22c(%rax), %rsi
callq 0x243b0
movq %rax, %rdi
callq 0x23d20
movq -0x48(%rbp), %rdi
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x23ce0
testb $0x1, %al
jne 0x20770
jmp 0x207b6
movq -0x40(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
callq 0x23d50
movq -0x40(%rbp), %rdi
movq (%rax), %rsi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
xorl %r9d, %r9d
callq 0x20dc0
movq -0x40(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
callq 0x23d50
movq (%rax), %rdi
callq 0x24310
movl %eax, -0x4(%rbp)
jmp 0x207cc
movq -0x40(%rbp), %rax
movq $0x0, 0x260(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/network.C
// Function: Network::ReadoutJudge(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&)
void Network::ReadoutJudge(vector<pair<int, int> >& correct, vector<pair<int, int> >& wrong, vector<pair<int, int> >& even){
    pair<int, int> res = this->LSMJudge(); // +/- 1, true cls

    if(res.first == 1) correct.push_back(res);
    else if(res.first == -1) wrong.push_back(res);
    else if(res.first == 0) even.push_back(res);
    else{
        cout<<"In Network::ReadoutJudge(vector<pair<int, int> >&, vector<pair<int, int> >&, vector<pair<int, int> >&)\n"
            <<"Undefined return type: "<<res.first<<" returned by Network::LSMJudge()"
            <<endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x216e0
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x28(%rbp)
jne 0x2081a
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x243d0
jmp 0x20893
cmpl $-0x1, -0x28(%rbp)
jne 0x2082f
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x243d0
jmp 0x20891
cmpl $0x0, -0x28(%rbp)
jne 0x20844
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x243d0
jmp 0x2088f
movq 0x2c77d(%rip), %rdi     # 0x4cfc8
leaq 0x152f6(%rip), %rsi     # 0x35b48
callq 0x4360
movq %rax, %rdi
leaq 0x1534f(%rip), %rsi     # 0x35bb0
callq 0x4360
movq %rax, %rdi
movl -0x28(%rbp), %esi
callq 0x46c0
movq %rax, %rdi
leaq 0x1534d(%rip), %rsi     # 0x35bc8
callq 0x4360
movq %rax, %rdi
movq 0x2c72e(%rip), %rsi     # 0x4cfb8
callq 0x43b0
jmp 0x20891
jmp 0x20893
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/network.C
// Function: Network::LSMNetworkRemoveSpeech()
void Network::LSMNetworkRemoveSpeech(){
    _sp = NULL;
    assert(_lsm_input_layer || _lsm_output_layer);

    if(_lsm_input_layer)
        _lsm_input_layer->LSMRemoveSpeech();
    _lsm_input_layer = NULL;

    if(_lsm_output_layer)
        _lsm_output_layer->LSMRemoveSpeech();
    _lsm_output_layer = NULL;

    if(_lsm_reservoir_layer == NULL)
        _lsm_reservoir_layer->LSMRemoveSpeech();

    _lsm_reservoir_layer = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq $0x0, 0x260(%rcx)
movb $0x1, %al
cmpq $0x0, 0x268(%rcx)
movb %al, -0x9(%rbp)
jne 0x20fb0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x2a8(%rax)
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x20fb9
jmp 0x20fbb
jmp 0x20fda
leaq 0x14845(%rip), %rdi     # 0x35807
leaq 0x14351(%rip), %rsi     # 0x3531a
movl $0x1d7, %edx            # imm = 0x1D7
leaq 0x14858(%rip), %rcx     # 0x3582d
callq 0x4210
movq -0x18(%rbp), %rax
cmpq $0x0, 0x268(%rax)
je 0x20ff8
movq -0x18(%rbp), %rax
movq 0x268(%rax), %rdi
callq 0x10940
movq -0x18(%rbp), %rax
movq $0x0, 0x268(%rax)
cmpq $0x0, 0x2a8(%rax)
je 0x21021
movq -0x18(%rbp), %rax
movq 0x2a8(%rax), %rdi
callq 0x10940
movq -0x18(%rbp), %rax
movq $0x0, 0x2a8(%rax)
cmpq $0x0, 0x270(%rax)
jne 0x2104a
movq -0x18(%rbp), %rax
movq 0x270(%rax), %rdi
callq 0x10940
movq -0x18(%rbp), %rax
movq $0x0, 0x270(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/network.C
// Function: Network::LSMLoadLayers()
void Network::LSMLoadLayers(){
    assert(_lsm_input_layer == NULL);
    _lsm_input_layer = SearchForNeuronGroup("input");
    assert(_lsm_input_layer != NULL);

    assert(_lsm_reservoir_layer == NULL);
    _lsm_reservoir_layer = SearchForNeuronGroup("reservoir");
    assert(_lsm_reservoir_layer != NULL);

    _lsm_output_layer = SearchForNeuronGroup("output");
    assert(_lsm_output_layer != NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x268(%rax)
jne 0x21080
jmp 0x2109f
leaq 0x147cd(%rip), %rdi     # 0x35854
leaq 0x1428c(%rip), %rsi     # 0x3531a
movl $0x1e9, %edx            # imm = 0x1E9
leaq 0x147d3(%rip), %rcx     # 0x3586d
callq 0x4210
movq -0x10(%rbp), %rdi
leaq 0x13218(%rip), %rsi     # 0x342c2
callq 0x1e9c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x268(%rax)
cmpq $0x0, 0x268(%rax)
je 0x210c9
jmp 0x210e8
leaq 0x147bb(%rip), %rdi     # 0x3588b
leaq 0x14243(%rip), %rsi     # 0x3531a
movl $0x1eb, %edx            # imm = 0x1EB
leaq 0x1478a(%rip), %rcx     # 0x3586d
callq 0x4210
movq -0x10(%rbp), %rax
cmpq $0x0, 0x270(%rax)
jne 0x210f8
jmp 0x21117
leaq 0x147a5(%rip), %rdi     # 0x358a4
leaq 0x14214(%rip), %rsi     # 0x3531a
movl $0x1ed, %edx            # imm = 0x1ED
leaq 0x1475b(%rip), %rcx     # 0x3586d
callq 0x4210
movq -0x10(%rbp), %rdi
leaq 0x131d5(%rip), %rsi     # 0x342f7
callq 0x1e9c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x270(%rax)
cmpq $0x0, 0x270(%rax)
je 0x21141
jmp 0x21160
leaq 0x14779(%rip), %rdi     # 0x358c1
leaq 0x141cb(%rip), %rsi     # 0x3531a
movl $0x1ef, %edx            # imm = 0x1EF
leaq 0x14712(%rip), %rcx     # 0x3586d
callq 0x4210
movq -0x10(%rbp), %rdi
leaq 0x14267(%rip), %rsi     # 0x353d2
callq 0x1e9c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x2a8(%rax)
cmpq $0x0, 0x2a8(%rax)
je 0x2118a
jmp 0x211a9
leaq 0x1474d(%rip), %rdi     # 0x358de
leaq 0x14182(%rip), %rsi     # 0x3531a
movl $0x1f2, %edx            # imm = 0x1F2
leaq 0x146c9(%rip), %rcx     # 0x3586d
callq 0x4210
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/network.C
// Function: Network::DetermineNetworkNeuronMode(networkmode_t const&, neuronmode_t&, neuronmode_t&, neuronmode_t&)
void Network::DetermineNetworkNeuronMode(const networkmode_t & networkmode, neuronmode_t & neuronmode_input, neuronmode_t & neuronmode_reservoir, neuronmode_t & neuronmode_readout){
    if(networkmode == TRANSIENTSTATE){
        neuronmode_input = READCHANNEL;
        neuronmode_reservoir = WRITECHANNEL;
        neuronmode_readout = DEACTIVATED;
    }else if(networkmode == READOUT){
        neuronmode_input = DEACTIVATED;
        neuronmode_reservoir = READCHANNEL;
        neuronmode_readout = NORMAL;
    }else{
        cout<<"Unrecognized network mode!"<<endl;
        exit(EXIT_FAILURE);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x211f5
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x20(%rbp), %rax
movl $0x2, (%rax)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
jmp 0x2124c
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x2121e
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x28(%rbp), %rax
movl $0x3, (%rax)
jmp 0x2124a
movq 0x2bda3(%rip), %rdi     # 0x4cfc8
leaq 0x146cc(%rip), %rsi     # 0x358f8
callq 0x4360
movq %rax, %rdi
movq 0x2bd7d(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movl $0x1, %edi
callq 0x4440
jmp 0x2124c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/network.C
// Function: Network::PrintSpikeCount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Network::PrintSpikeCount(string layer){
    NeuronGroup * ng = SearchForNeuronGroup(layer.c_str());
    assert(ng);
#ifdef CV
    assert(*_cv_test_sp_iter);
    ng->PrintSpikeCount((*_cv_test_sp_iter)->Class());
#else
    assert(*_sp_iter);
    ng->PrintSpikeCount((*_sp_iter)->Class());
#endif

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x4160
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x1e9c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x21651
jmp 0x21670
leaq 0x15099(%rip), %rdi     # 0x366f1
leaq 0x13cbb(%rip), %rsi     # 0x3531a
movl $0x2f7, %edx            # imm = 0x2F7
leaq 0x144ad(%rip), %rcx     # 0x35b18
callq 0x4210
movq -0x20(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
callq 0x23d50
cmpq $0x0, (%rax)
je 0x21688
jmp 0x216a7
leaq 0x144af(%rip), %rdi     # 0x35b3e
leaq 0x13c84(%rip), %rsi     # 0x3531a
movl $0x2fc, %edx            # imm = 0x2FC
leaq 0x14476(%rip), %rcx     # 0x35b18
callq 0x4210
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x220, %rdi            # imm = 0x220
callq 0x23d50
movq (%rax), %rdi
callq 0x242f0
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x10850
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/network.C
// Function: Network::DetermineSynType(char const*, synapsetype_t&, char const*)
void Network::DetermineSynType(const char * syn_type, synapsetype_t & ret_syn_type, const char * func_name){
    if(strcmp(syn_type, "reservoir") == 0){
        // Write reservoir syns into the file
        ret_syn_type = RESERVOIR_SYN;
    }else if(strcmp(syn_type, "readout") == 0){
        ret_syn_type = READOUT_SYN;
    }else if(strcmp(syn_type, "input") == 0){
        ret_syn_type = INPUT_SYN;
    }else{
        cout<<"In Network::"<<func_name<<", undefined synapse type: "<<syn_type<<endl;
        exit(EXIT_FAILURE);
    } 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x120c4(%rip), %rsi     # 0x342f7
callq 0x4520
cmpl $0x0, %eax
jne 0x2224c
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
jmp 0x222e5
movq -0x10(%rbp), %rdi
leaq 0x14665(%rip), %rsi     # 0x368bc
callq 0x4520
cmpl $0x0, %eax
jne 0x2226d
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
jmp 0x222e3
movq -0x10(%rbp), %rdi
leaq 0x1204a(%rip), %rsi     # 0x342c2
callq 0x4520
cmpl $0x0, %eax
jne 0x2228e
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
jmp 0x222e1
movq 0x2ad33(%rip), %rdi     # 0x4cfc8
leaq 0x13cd6(%rip), %rsi     # 0x35f72
callq 0x4360
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x4360
movq %rax, %rdi
leaq 0x13cc8(%rip), %rsi     # 0x35f7f
callq 0x4360
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x4360
movq %rax, %rdi
movq 0x2ace6(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movl $0x1, %edi
callq 0x4440
jmp 0x222e3
jmp 0x222e5
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/network.C
// Function: Network::RemoveZeroWeights(char const*)
void Network::RemoveZeroWeights(const char * type){
    synapsetype_t  syn_type = INVALID;
    DetermineSynType(type, syn_type, "RemoveZeroWeights()");
    assert(syn_type != INVALID);

    if(syn_type == RESERVOIR_SYN){
        NeuronGroup * reservoir = SearchForNeuronGroup("reservoir");
        reservoir->RemoveZeroSyns(syn_type);
    }
    else if(syn_type == READOUT_SYN){
        NeuronGroup * output = SearchForNeuronGroup("output");
        if(!output){
            cout<<"In Network::RemoveZeroWeights(), no 'output' layer is found!!"<<endl;
            assert(output);
        }
        output->RemoveZeroSyns(syn_type);
    }
    else{
        assert(0); // your code shoule never go here.
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x3, -0x14(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x14(%rbp), %rdx
leaq 0x13a60(%rip), %rcx     # 0x3602e
callq 0x22210
cmpl $0x3, -0x14(%rbp)
je 0x225db
jmp 0x225fa
leaq 0x13d20(%rip), %rdi     # 0x36302
leaq 0x12d31(%rip), %rsi     # 0x3531a
movl $0x3be, %edx            # imm = 0x3BE
leaq 0x13a4d(%rip), %rcx     # 0x36042
callq 0x4210
cmpl $0x0, -0x14(%rbp)
jne 0x22625
movq -0x30(%rbp), %rdi
leaq 0x11cec(%rip), %rsi     # 0x342f7
callq 0x1e9c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x10e60
jmp 0x226c1
cmpl $0x2, -0x14(%rbp)
jne 0x226a0
movq -0x30(%rbp), %rdi
leaq 0x12d9c(%rip), %rsi     # 0x353d2
callq 0x1e9c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x22692
movq 0x2a97b(%rip), %rdi     # 0x4cfc8
leaq 0x13a1c(%rip), %rsi     # 0x36070
callq 0x4360
movq %rax, %rdi
movq 0x2a955(%rip), %rsi     # 0x4cfb8
callq 0x43b0
cmpq $0x0, -0x28(%rbp)
je 0x22671
jmp 0x22690
leaq 0x12d5a(%rip), %rdi     # 0x353d2
leaq 0x12c9b(%rip), %rsi     # 0x3531a
movl $0x3c8, %edx            # imm = 0x3C8
leaq 0x139b7(%rip), %rcx     # 0x36042
callq 0x4210
jmp 0x22692
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x10e60
jmp 0x226bf
leaq 0x12c71(%rip), %rdi     # 0x35318
leaq 0x12c6c(%rip), %rsi     # 0x3531a
movl $0x3cd, %edx            # imm = 0x3CD
leaq 0x13988(%rip), %rcx     # 0x36042
callq 0x4210
jmp 0x226c1
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/./util.h
// Function: std::vector<int, std::allocator<int>> operator+<int>(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&)
std::vector<T> operator+(const std::vector<T>& a, const std::vector<T>& b)
{
    if(a.empty())   return b;
    if(b.empty())   return a;
    assert(a.size() == b.size());
    std::vector<T> res;
    res.reserve(a.size());
    std::transform(a.begin(), a.end(), b.begin(), std::back_inserter(res), std::plus<T>());
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x56b0
testb $0x1, %al
jne 0x24841
jmp 0x24853
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x26570
jmp 0x24970
movq -0x18(%rbp), %rdi
callq 0x56b0
testb $0x1, %al
jne 0x24862
jmp 0x24874
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x26570
jmp 0x24970
movq -0x10(%rbp), %rdi
callq 0x5600
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5600
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jne 0x24898
jmp 0x248b7
leaq 0x11bdc(%rip), %rdi     # 0x3647b
leaq 0x11bea(%rip), %rsi     # 0x36490
movl $0x45, %edx
leaq 0x11be7(%rip), %rcx     # 0x36499
callq 0x4210
movq -0x70(%rbp), %rdi
movb $0x0, -0x19(%rbp)
callq 0x5550
movq -0x10(%rbp), %rdi
callq 0x5600
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x2aa20
jmp 0x248db
movq -0x10(%rbp), %rdi
callq 0x5a60
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5a90
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5a60
movq -0x70(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x2abc0
movq %rax, -0x80(%rbp)
jmp 0x24911
movq -0x80(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x2ab20
movq %rax, -0x88(%rbp)
jmp 0x24937
movq -0x88(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x2496e
jmp 0x24965
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x9550
jmp 0x2497d
movq -0x70(%rbp), %rdi
callq 0x9550
jmp 0x24970
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/parser.C
// Function: Parser::ParseNeuronGroup(char*, int, char*, double)
void Parser::ParseNeuronGroup(char * name, int num, char * e_i, double v_mem){
	cout<<std::string(name)<<endl;
    assert(_network->CheckExistence(name) == false);
    assert(num > 1);
    assert((strcmp(e_i,"excitatory")==0)||(strcmp(e_i,"inhibitory")==0));
    bool excitatory;
    if(strcmp(e_i,"excitatory") == 0) excitatory = true;
    else excitatory = false;
    _network->AddNeuronGroup(name, num, excitatory, v_mem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x46f0
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x12880
jmp 0x2b87f
movq 0x21742(%rip), %rdi     # 0x4cfc8
leaq -0x48(%rbp), %rsi
callq 0x4300
movq %rax, -0x80(%rbp)
jmp 0x2b895
movq -0x80(%rbp), %rdi
movq 0x21718(%rip), %rsi     # 0x4cfb8
callq 0x43b0
jmp 0x2b8a7
leaq -0x48(%rbp), %rdi
callq 0x4200
leaq -0x49(%rbp), %rdi
callq 0x43d0
movq -0x78(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d1c0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2b8d5
jmp 0x2b925
leaq 0xad67(%rip), %rdi      # 0x36643
leaq 0xac24(%rip), %rsi      # 0x36507
movl $0x71, %edx
leaq 0xad7c(%rip), %rcx      # 0x3666b
callq 0x4210
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2b917
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4200
leaq -0x49(%rbp), %rdi
callq 0x43d0
jmp 0x2b9fc
cmpl $0x1, -0x14(%rbp)
jle 0x2b92d
jmp 0x2b94c
leaq 0xad72(%rip), %rdi      # 0x366a6
leaq 0xabcc(%rip), %rsi      # 0x36507
movl $0x72, %edx
leaq 0xad24(%rip), %rcx      # 0x3666b
callq 0x4210
movq -0x20(%rbp), %rdi
leaq 0x90ff(%rip), %rsi      # 0x34a56
callq 0x4520
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x81(%rbp)
je 0x2b987
movq -0x20(%rbp), %rdi
leaq 0x90eb(%rip), %rsi      # 0x34a61
callq 0x4520
cmpl $0x0, %eax
sete %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x2b993
jmp 0x2b995
jmp 0x2b9b4
leaq 0xad12(%rip), %rdi      # 0x366ae
leaq 0xab64(%rip), %rsi      # 0x36507
movl $0x73, %edx
leaq 0xacbc(%rip), %rcx      # 0x3666b
callq 0x4210
movq -0x20(%rbp), %rdi
leaq 0x9097(%rip), %rsi      # 0x34a56
callq 0x4520
cmpl $0x0, %eax
jne 0x2b9cf
movb $0x1, -0x5d(%rbp)
jmp 0x2b9d3
movb $0x0, -0x5d(%rbp)
movq -0x78(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movb -0x5d(%rbp), %al
movsd -0x28(%rbp), %xmm0
andb $0x1, %al
movzbl %al, %ecx
callq 0x1d5e0
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/parser.C
// Function: Parser::ParseLSMSynapse(char*, char*, int, int, int, int, char*)
void Parser::ParseLSMSynapse(char * from, char * to, int fromN, int toN, int value, int random, char * fixed_learning){
    bool fixed;
    if(strcmp(fixed_learning,"fixed") == 0) fixed = true;
    else if(strcmp(fixed_learning,"learning") == 0) fixed = false;
    else{
        cout<<fixed_learning<<endl;
        assert(0);
    }
    _network->LSMAddSynapse(from, to, fromN, toN, value, random, fixed);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x18(%rbp), %rdi
leaq 0x9ad1(%rip), %rsi      # 0x3551a
callq 0x4520
cmpl $0x0, %eax
jne 0x2ba59
movb $0x1, -0x25(%rbp)
jmp 0x2bab4
movq 0x18(%rbp), %rdi
leaq 0xac87(%rip), %rsi      # 0x366eb
callq 0x4520
cmpl $0x0, %eax
jne 0x2ba74
movb $0x0, -0x25(%rbp)
jmp 0x2bab2
movq 0x18(%rbp), %rsi
movq 0x21549(%rip), %rdi     # 0x4cfc8
callq 0x4360
movq %rax, %rdi
movq 0x2152a(%rip), %rsi     # 0x4cfb8
callq 0x43b0
leaq 0x987e(%rip), %rdi      # 0x35318
leaq 0xaa66(%rip), %rsi      # 0x36507
movl $0x81, %edx
leaq 0xac47(%rip), %rcx      # 0x366f4
callq 0x4210
jmp 0x2bab4
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movl 0x10(%rbp), %r10d
movb -0x25(%rbp), %al
andb $0x1, %al
movl %r10d, (%rsp)
movzbl %al, %eax
movl %eax, 0x8(%rsp)
callq 0x1e890
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/simulator.C
// Function: Simulator::InitializeFile(char const*)
void Simulator::InitializeFile(const char * filename){
    FILE * Foutp = fopen(filename,"w");
    assert(Foutp != NULL);
    fprintf(Foutp,"%d\t%d\n",-1,-1);
    fclose(Foutp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xa018(%rip), %rsi      # 0x368e3
callq 0x4430
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2c8dd
jmp 0x2c8fc
leaq 0xa001(%rip), %rdi      # 0x368e5
leaq 0x9ec9(%rip), %rsi      # 0x367b4
movl $0x6a, %edx
leaq 0x9ffc(%rip), %rcx      # 0x368f3
callq 0x4210
movq -0x18(%rbp), %rdi
leaq 0xa019(%rip), %rsi      # 0x36920
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, %edx
movb $0x0, %al
callq 0x4540
movq -0x18(%rbp), %rdi
callq 0x4370
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop