LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/gates.cpp
// Function: And::eval()
char And::eval(){
  unsigned int count1=0;
  for(unsigned i = 0; i!=inputs->size() ; i++){
    char value_in =(*inputs)[i]->getVal() ;
    if(value_in=='0'){
      return '0';
    }
    if(value_in=='1'){
      count1++;
    }
  }
  if(count1==inputs->size()){ 
    return '1';
  }
//if they is no '0' and there is at least one 'x'
return 'x';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rdi
callq 0x5bc0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0x4e1d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x5be0
movq (%rax), %rdi
callq 0x5c00
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x30, %eax
jne 0x4dfe
movb $0x30, -0x1(%rbp)
jmp 0x4e47
movsbl -0x19(%rbp), %eax
cmpl $0x31, %eax
jne 0x4e10
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4e12
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4db2
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %ecx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rdi
callq 0x5bc0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0x4e43
movb $0x31, -0x1(%rbp)
jmp 0x4e47
movb $0x78, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/gates.cpp
// Function: Or::eval()
char Or::eval(){
  unsigned int count0=0;
  for(unsigned i = 0; i!=inputs->size() ; i++){
    char value_in =(*inputs)[i]->getVal() ;
    if(value_in=='1'){
      return '1';
    }
    if(value_in=='0'){
      count0++;
    }
  }

  if(count0==inputs->size()){ 
    return '0';
  }
//if they is no '1' and there is at least 'x'
return 'x';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rdi
callq 0x5bc0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0x50ad
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x5be0
movq (%rax), %rdi
callq 0x5c00
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x31, %eax
jne 0x508e
movb $0x31, -0x1(%rbp)
jmp 0x50d7
movsbl -0x19(%rbp), %eax
cmpl $0x30, %eax
jne 0x50a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x50a2
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5042
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %ecx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rdi
callq 0x5bc0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0x50d3
movb $0x30, -0x1(%rbp)
jmp 0x50d7
movb $0x78, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/gates.cpp
// Function: Nor::eval()
char Nor::eval(){
  unsigned int count0=0;
  for(unsigned i = 0; i!=inputs->size() ; i++){
    char value_in =(*inputs)[i]->getVal() ;
    if(value_in=='1'){
      return '0';//'1';
    }
    if(value_in=='0'){
      count0++;
    }
  }

  if(count0==inputs->size()){ 
    return '1';//'0';
  }
//if they is no '1' and there is one 'x'
return 'x';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rdi
callq 0x5bc0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0x533d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x5be0
movq (%rax), %rdi
callq 0x5c00
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x31, %eax
jne 0x531e
movb $0x30, -0x1(%rbp)
jmp 0x5367
movsbl -0x19(%rbp), %eax
cmpl $0x30, %eax
jne 0x5330
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5332
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x52d2
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %ecx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rdi
callq 0x5bc0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0x5363
movb $0x31, -0x1(%rbp)
jmp 0x5367
movb $0x78, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/gates.cpp
// Function: Xor::eval()
char Xor::eval(){ //odd number of '1' gives true
  bool unknown=false;
  unsigned int count1=0;
  for(unsigned i = 0; i!=inputs->size() ; i++){
    char value_in =(*inputs)[i]->getVal() ;
    if(value_in=='x'){
      unknown=true;
    }
    if(value_in=='0'){
      count1++;
    }
  }
  
 
  bool isOdd=count1%2;
  if( isOdd ){ //if it is odd number
    return '1';
  }
  if(unknown){
    return 'x';
  }


return '0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rdi
callq 0x5bc0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0x585f
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x5be0
movq (%rax), %rdi
callq 0x5c00
movb %al, -0x1d(%rbp)
movsbl -0x1d(%rbp), %eax
cmpl $0x78, %eax
jne 0x5840
movb $0x1, -0x11(%rbp)
movsbl -0x1d(%rbp), %eax
cmpl $0x30, %eax
jne 0x5852
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5854
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x57f6
movl -0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1e(%rbp)
testb $0x1, -0x1e(%rbp)
je 0x587c
movb $0x31, -0x1(%rbp)
jmp 0x588c
testb $0x1, -0x11(%rbp)
je 0x5888
movb $0x78, -0x1(%rbp)
jmp 0x588c
movb $0x30, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/gates.cpp
// Function: Not::eval()
char Not::eval(){
  char value_in =(*inputs)[0]->getVal() ;

  if(value_in=='1'){
    return '0';
  }
  if(value_in=='0'){
    return '1';
  }

return 'x';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5be0
movq (%rax), %rdi
callq 0x5c00
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x31, %eax
jne 0x5aa7
movb $0x30, -0x1(%rbp)
jmp 0x5aba
movsbl -0x11(%rbp), %eax
cmpl $0x30, %eax
jne 0x5ab6
movb $0x31, -0x1(%rbp)
jmp 0x5aba
movb $0x78, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/design.cpp
// Function: Design::Design(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Design::Design(string n){
  desname = n;
  PINets = new vector<Net *>(); // " () " used for initializing size to 0 
  PONets = new vector<Net *>();
  WireNets = new vector<Net*>();
  all_Nets = new vector<Net*>();
  all_Gates = new vector<Gate *>();
  //pis.clear();
  //pos.clear();


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x3330
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x50(%rbp)
callq 0x7c10
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x48(%rbp)
callq 0x7c30
movq -0x30(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0x40(%rbp)
callq 0x7c50
movq -0x30(%rbp), %rdi
addq $0x98, %rdi
movq %rdi, -0x38(%rbp)
callq 0x7c50
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3050
jmp 0x6601
movl $0x18, %edi
callq 0x3230
movq %rax, -0x60(%rbp)
jmp 0x6611
movq -0x60(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x5ad0
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0xb0(%rax)
movl $0x18, %edi
callq 0x3230
movq %rax, -0x68(%rbp)
jmp 0x6647
movq -0x68(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x5ad0
movq -0x68(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0xb8(%rax)
movl $0x18, %edi
callq 0x3230
movq %rax, -0x70(%rbp)
jmp 0x667d
movq -0x70(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x5ad0
movq -0x70(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0xc0(%rax)
movl $0x18, %edi
callq 0x3230
movq %rax, -0x78(%rbp)
jmp 0x66b3
movq -0x78(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x5ad0
movq -0x78(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0xc8(%rax)
movl $0x18, %edi
callq 0x3230
movq %rax, -0x80(%rbp)
jmp 0x66e9
movq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3130
movq -0x80(%rbp), %rdi
callq 0x3a60
movq -0x80(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0xd0(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x7c70
movq -0x40(%rbp), %rdi
callq 0x7c70
movq -0x48(%rbp), %rdi
callq 0x7cd0
movq -0x50(%rbp), %rdi
callq 0x7cf0
movq -0x30(%rbp), %rdi
callq 0x3150
movq -0x18(%rbp), %rdi
callq 0x3410
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/design.cpp
// Function: Design::addPI(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Design::addPI(string n){
  pis.push_back(n);
  Net* ptr_net = new Net(n);//make net
  PINets->push_back(ptr_net); 
  designNets[n]=ptr_net;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
subq $-0x80, %rdi
callq 0x7f30
movl $0x40, %edi
callq 0x3230
movq -0x58(%rbp), %rsi
movq %rax, -0x50(%rbp)
movb $0x1, -0x45(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3100
jmp 0x6a26
movq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3700
jmp 0x6a35
movb $0x0, -0x45(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3150
movq -0x50(%rbp), %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0xb0(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x5b50
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x20, %rdi
callq 0x7fa0
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x6aa7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3150
testb $0x1, -0x45(%rbp)
jne 0x6aaf
jmp 0x6abd
movq -0x50(%rbp), %rdi
movl $0x40, %esi
callq 0x3240
jmp 0x6abf
movq -0x40(%rbp), %rdi
callq 0x3410
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/design.cpp
// Function: Design::addPO(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Design::addPO(string n){ 
  pos.push_back(n);
  Net* ptr_net = new Net(n);//make net
  PONets->push_back(ptr_net); 
  designNets[n]=ptr_net; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x98, %rdi
callq 0x7f30
movl $0x40, %edi
callq 0x3230
movq -0x58(%rbp), %rsi
movq %rax, -0x50(%rbp)
movb $0x1, -0x45(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3100
jmp 0x6b19
movq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3700
jmp 0x6b28
movb $0x0, -0x45(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3150
movq -0x50(%rbp), %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0xb8(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x5b50
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x20, %rdi
callq 0x7fa0
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x6b9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3150
testb $0x1, -0x45(%rbp)
jne 0x6ba2
jmp 0x6bb0
movq -0x50(%rbp), %rdi
movl $0x40, %esi
callq 0x3240
jmp 0x6bb2
movq -0x40(%rbp), %rdi
callq 0x3410
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/design.cpp
// Function: Design::findNet(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Net* Design::findNet(string net_name){
  map<string, Net *>::iterator it;
  it=designNets.find(net_name);
  if(it!=designNets.end() ){
    return it->second;
  }
  else{
    return NULL;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7d10
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
callq 0x8080
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x20, %rdi
callq 0x7d90
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7d60
testb $0x1, %al
jne 0x6c26
jmp 0x6c39
leaq -0x20(%rbp), %rdi
callq 0x7dc0
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6c41
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/design.cpp
// Function: Design::addFindNet(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Net* Design::addFindNet(string n){
  map<string, Net *>::iterator it;
  it=designNets.find(n);
  if(it!=designNets.end() ){
    return it->second;
  }
  else{
    Net* net_ptr = new Net(n);
    designNets[n]= net_ptr;
    WireNets->push_back(net_ptr);

    return net_ptr;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7d10
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdi
addq $0x20, %rdi
callq 0x8080
movq -0x70(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x20, %rdi
callq 0x7d90
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7d60
testb $0x1, %al
jne 0x6cb9
jmp 0x6ccf
leaq -0x20(%rbp), %rdi
callq 0x7dc0
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6d96
movl $0x40, %edi
callq 0x3230
movq -0x78(%rbp), %rsi
movq %rax, -0x80(%rbp)
movb $0x1, -0x65(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3100
jmp 0x6cf0
movq -0x80(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3700
jmp 0x6cff
movb $0x0, -0x65(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3150
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x88(%rbp)
addq $0x20, %rdi
callq 0x7fa0
movq -0x88(%rbp), %rdx
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rdx, (%rcx)
movq 0xc0(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5b50
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6d96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x6d7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3150
testb $0x1, -0x65(%rbp)
jne 0x6d86
jmp 0x6d94
movq -0x80(%rbp), %rdi
movl $0x40, %esi
callq 0x3240
jmp 0x6da3
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3410
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/design.cpp
// Function: Design::findGate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Gate * Design::findGate(string inst_name){
  map<string, Gate*>::iterator it;
  it=designGates.find(inst_name);
  if(it!=designGates.end() ){
    return it->second;
  }
  else{
    return NULL;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7e20
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
addq $0x50, %rdi
callq 0x80b0
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x50, %rdi
callq 0x7ea0
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7e70
testb $0x1, %al
jne 0x6e16
jmp 0x6e29
leaq -0x20(%rbp), %rdi
callq 0x7ed0
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6e31
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/design.cpp
// Function: Design::allNets()
vector<Net *> * Design::allNets(){
  map<string, Net *>::iterator it_net;
  for(it_net=designNets.begin() ; it_net!=designNets.end(); it_net++){
     all_Nets->push_back( it_net->second );
  }
  return all_Nets;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7d10
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x7d30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x7d90
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7d60
testb $0x1, %al
jne 0x7b0a
jmp 0x7b43
movq -0x30(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7dc0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x5b50
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x7de0
movq %rax, -0x28(%rbp)
jmp 0x7ae6
movq -0x30(%rbp), %rax
movq 0xc8(%rax), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/design.cpp
// Function: Design::allGates()
vector<Gate *> * Design::allGates(){
  map<string, Gate *>::iterator it_gate;
  for(it_gate=designGates.begin() ; it_gate!=designGates.end(); it_gate++){
     all_Gates->push_back( it_gate->second );
  }
  return all_Gates;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7e20
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
callq 0x7e40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
callq 0x7ea0
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7e70
testb $0x1, %al
jne 0x7bba
jmp 0x7bf3
movq -0x30(%rbp), %rax
movq 0xd0(%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7ed0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x3ae0
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x7ef0
movq %rax, -0x28(%rbp)
jmp 0x7b96
movq -0x30(%rbp), %rax
movq 0xd0(%rax), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/vlg_parser_man.cpp
// Function: remove_side_spaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string remove_side_spaces(string s){
  while(s[0] == ' '){
    s.erase(s.begin()); 
  }
  unsigned int i=s.length()-1;
  while(s[i] == ' '){
    s.erase(s.begin()+i); 
  }
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3480
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0xe841
movq -0x68(%rbp), %rdi
callq 0x31e0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xf300
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x32f0
movq %rax, -0x28(%rbp)
jmp 0xe7ff
movq -0x68(%rbp), %rdi
callq 0x3370
subq $0x1, %rax
movl %eax, -0x2c(%rbp)
movq -0x68(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x3480
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0xe8a6
movq -0x68(%rbp), %rdi
callq 0x31e0
movq %rax, -0x48(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %esi
leaq -0x48(%rbp), %rdi
callq 0xf340
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xf300
movq -0x68(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x32f0
movq %rax, -0x50(%rbp)
jmp 0xe851
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0x3140
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/vlg_parser_man.cpp
// Function: isID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isID(string s){
   if( !isalpha(s[0]) && s[0]!='_'){
      return false;
   }
   for( unsigned int i =1 ; i<s.length();i++){
     if( !isalnum(s[i]) && s[i]!='_' ){
       return false;
     }
   }
   
return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3480
movsbl (%rax), %edi
callq 0x33b0
cmpl $0x0, %eax
jne 0xe901
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3480
movsbl (%rax), %eax
cmpl $0x5f, %eax
je 0xe901
movb $0x0, -0x1(%rbp)
jmp 0xe96c
movl $0x1, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x3370
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0xe968
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3480
movsbl (%rax), %edi
callq 0x3250
cmpl $0x0, %eax
jne 0xe95b
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3480
movsbl (%rax), %eax
cmpl $0x5f, %eax
je 0xe95b
movb $0x0, -0x1(%rbp)
jmp 0xe96c
jmp 0xe95d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xe908
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/vlg_parser_man.cpp
// Function: has_proper_Semicolon(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool has_proper_Semicolon(string s){
    s=remove_side_spaces( s);
    string str2 (";");
    unsigned found = s.find(str2);
    if (found==(s.length()-1)){
      return true;
    }

return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, %rsi
movq %rsi, -0xa0(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3100
movq -0x98(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xe7e0
jmp 0xec5b
movq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
callq 0x32e0
movq -0xb0(%rbp), %rdi
callq 0x3150
leaq -0x50(%rbp), %rdi
callq 0x3150
leaq -0x81(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3420
movq -0xa8(%rbp), %rdx
leaq 0x13f7(%rip), %rsi      # 0x1009f
leaq -0x80(%rbp), %rdi
callq 0xf380
jmp 0xecb3
leaq -0x81(%rbp), %rdi
callq 0x3290
movq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3490
movq -0xa0(%rbp), %rdi
movl %eax, -0x88(%rbp)
movl -0x88(%rbp), %eax
movq %rax, -0xb8(%rbp)
callq 0x3370
movq %rax, %rcx
movq -0xb8(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0xed46
movb $0x1, -0x1(%rbp)
movl $0x1, -0x8c(%rbp)
jmp 0xed54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3150
jmp 0xed6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x81(%rbp), %rdi
callq 0x3290
jmp 0xed6b
movb $0x0, -0x1(%rbp)
movl $0x1, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3150
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/vlg_parser_man.cpp
// Function: remove_spaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string remove_spaces(string s){
  unsigned int i=0;
  while(i!=s.length()){
    if(s[i] == ' '){
       s.erase(s.begin()+i); 
    }
    else{
       i++;
    }
  }
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x50(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x58(%rbp)
callq 0x3370
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
je 0xee22
movq -0x50(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3480
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0xee17
movq -0x50(%rbp), %rdi
callq 0x31e0
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0xf340
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xf300
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x32f0
movq %rax, -0x38(%rbp)
jmp 0xee20
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xeda6
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x3140
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/vlg_parser_man.cpp
// Function: find_gate_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int find_gate_type(string s){
  if (s=="and"){ return AND; }
  if (s=="or"){ return OR; }
  if (s=="nand"){ return NAND; }
  if (s=="nor"){ return NOR; }
  if (s=="xor"){ return XOR; }
  if (s=="not"){ return NOT; }
return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x13fb(%rip), %rsi      # 0x10252
callq 0xf2d0
testb $0x1, %al
jne 0xee62
jmp 0xee6e
movl $0x0, -0x4(%rbp)
jmp 0xef13
movq -0x18(%rbp), %rdi
leaq 0x13de(%rip), %rsi      # 0x10257
callq 0xf2d0
testb $0x1, %al
jne 0xee84
jmp 0xee90
movl $0x1, -0x4(%rbp)
jmp 0xef13
movq -0x18(%rbp), %rdi
leaq 0x13b6(%rip), %rsi      # 0x10251
callq 0xf2d0
testb $0x1, %al
jne 0xeea6
jmp 0xeeaf
movl $0x2, -0x4(%rbp)
jmp 0xef13
movq -0x18(%rbp), %rdi
leaq 0x139c(%rip), %rsi      # 0x10256
callq 0xf2d0
testb $0x1, %al
jne 0xeec5
jmp 0xeece
movl $0x3, -0x4(%rbp)
jmp 0xef13
movq -0x18(%rbp), %rdi
leaq 0x1381(%rip), %rsi      # 0x1025a
callq 0xf2d0
testb $0x1, %al
jne 0xeee4
jmp 0xeeed
movl $0x4, -0x4(%rbp)
jmp 0xef13
movq -0x18(%rbp), %rdi
leaq 0x1366(%rip), %rsi      # 0x1025e
callq 0xf2d0
testb $0x1, %al
jne 0xef03
jmp 0xef0c
movl $0x5, -0x4(%rbp)
jmp 0xef13
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/vlg_parser_man.cpp
// Function: return_words(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string>* return_words(string line_of_text){ //note that this will not have additional spaces given that line of text dont have contiguous spaces
  vector<string>* words=new vector<string>();
  stringstream ss (line_of_text);
  string word;
  while (ss >> word){
//cout<<word<<endl;
    words->push_back(word);
  }
  return words;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0x3230
movq %rax, %rdi
movq %rdi, -0x1d8(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x3130
movq -0x1d8(%rbp), %rdi
callq 0x7c50
movq -0x1d8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0xf280
movq -0x1d0(%rbp), %rsi
movl %eax, %edx
leaq -0x198(%rbp), %rdi
callq 0x33a0
leaq -0x1b8(%rbp), %rdi
callq 0x3330
leaq -0x198(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x3320
movq %rax, -0x1e0(%rbp)
jmp 0xefb9
movq -0x1e0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3310
movb %al, -0x1e1(%rbp)
jmp 0xefd7
movb -0x1e1(%rbp), %al
testb $0x1, %al
jne 0xefe3
jmp 0xf023
movq -0x10(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x7f30
jmp 0xeff5
jmp 0xef9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x3150
leaq -0x198(%rbp), %rdi
callq 0x3190
jmp 0xf056
movq -0x10(%rbp), %rax
movq %rax, -0x1f0(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x3150
leaq -0x198(%rbp), %rdi
callq 0x3190
movq -0x1f0(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1c0(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/vlg_parser_man.cpp
// Function: isDelay(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isDelay(string s){
  remove_side_spaces(s);
  if(s[0]!='#'){
     return false;
  }
  else{
     s.erase(s.begin() );
     return isNum(s);
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, %rsi
movq %rsi, -0xa8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3100
movq -0xa0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xe7e0
jmp 0xf0ab
leaq -0x30(%rbp), %rdi
callq 0x3150
leaq -0x50(%rbp), %rdi
callq 0x3150
movq -0xa8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3480
movsbl (%rax), %eax
cmpl $0x23, %eax
je 0xf0f8
movb $0x0, -0x1(%rbp)
jmp 0xf18a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3150
jmp 0xf198
movq -0xa8(%rbp), %rdi
callq 0x31e0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xf300
movq -0xa8(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x32f0
movq -0xa8(%rbp), %rsi
movq %rax, -0x78(%rbp)
leaq -0x98(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3100
movq -0xb8(%rbp), %rdi
callq 0xf1b0
movb %al, -0xa9(%rbp)
jmp 0xf157
movb -0xa9(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x3150
jmp 0xf18a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x3150
jmp 0xf198
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/vlg_parser_man.cpp
// Function: isNum(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isNum(string s){
  remove_side_spaces(s);
  for( unsigned int i =0 ; i<s.length();i++){
     if(!isdigit(s[i])){
       return false;
     }
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, %rsi
movq %rsi, -0x70(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3100
movq -0x68(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xe7e0
jmp 0xf1e2
leaq -0x30(%rbp), %rdi
callq 0x3150
leaq -0x50(%rbp), %rdi
callq 0x3150
movl $0x0, -0x60(%rbp)
movq -0x70(%rbp), %rdi
movl -0x60(%rbp), %eax
movq %rax, -0x78(%rbp)
callq 0x3370
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0xf25c
movq -0x70(%rbp), %rdi
movl -0x60(%rbp), %eax
movl %eax, %esi
callq 0x3480
movsbl (%rax), %edi
callq 0x3210
cmpl $0x0, %eax
jne 0xf24f
movb $0x0, -0x1(%rbp)
jmp 0xf260
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3150
jmp 0xf26e
jmp 0xf251
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0xf1fb
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/examples/line_reader.c
// Function: main
int main(int argc, char **argv) {
  
  const char *input = 
    "abcHVwufvyuevuy3y436782\n"
    "\n"
    "\n"
    "rehre\n"
    "rew\n"
    "-ql.;qa\n"
    "eg";
		
  mpc_parser_t* Line = mpc_many(
    mpcf_strfold, 
    mpc_apply(mpc_re("[^\\n]*(\\n|$)"), read_line));
  
  mpc_result_t r;

  (void)argc; (void)argv;

  mpc_parse("input", input, Line, &r);
  printf("\nParsed String: %s", (char*)r.output);
  free(r.output);
  
  mpc_delete(Line);
  
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xdd17(%rip), %rax      # 0xf004
movq %rax, -0x18(%rbp)
leaq 0xdd3b(%rip), %rdi      # 0xf033
callq 0x6160
movq %rax, %rdi
leaq 0x69(%rip), %rsi        # 0x1370
callq 0x4640
movq %rax, %rsi
leaq 0x3f1a(%rip), %rdi      # 0x5230
callq 0x4b20
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0xe2c7(%rip), %rdi      # 0xf5f5
leaq -0x28(%rbp), %rcx
callq 0x2d70
movq -0x28(%rbp), %rsi
leaq 0xdcfe(%rip), %rdi      # 0xf040
movb $0x0, %al
callq 0x1090
movq -0x28(%rbp), %rdi
callq 0x11d0
movq -0x20(%rbp), %rdi
callq 0x3630
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_09/date_conversion_pointers.c
// Function: main
int main(void)
{
  int day = day_of_year(2021, 2, 12);
  printf("day of the year: %d\n", day);

  int month_invalid = day_of_year(2021, 13, 1);
  if (month_invalid == -1)
  {
    printf("Warning: invalid month detected.\n");
  }

  int day_invalid = day_of_year(2021, 12, 32);
  if (day_invalid == -2)
  {
    printf("Warning: invalid day detected.\n");
  }

  int month;
  int day_month;

  month_day(2021, 43, &month, &day_month);
  printf("month: %d, day: %d\n", month, day_month);

  month_day(2021, 365, &month, &day_month);
  printf("month: %d, day: %d\n", month, day_month);

  month_day(2021, 366, &month, &day_month);
  printf("month: %d, day: %d\n", month, day_month);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x7e5, %edi            # imm = 0x7E5
movl $0x2, %esi
movl $0xc, %edx
callq 0x1260
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %esi
leaq 0xe94(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl $0x7e5, %edi            # imm = 0x7E5
movl $0xd, %esi
movl $0x1, %edx
callq 0x1260
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x11a2
leaq 0xe7e(%rip), %rdi       # 0x2019
movb $0x0, %al
callq 0x1030
movl $0x7e5, %edi            # imm = 0x7E5
movl $0xc, %esi
movl $0x20, %edx
callq 0x1260
movl %eax, -0x10(%rbp)
cmpl $-0x2, -0x10(%rbp)
jne 0x11cd
leaq 0xe75(%rip), %rdi       # 0x203b
movb $0x0, %al
callq 0x1030
movl $0x7e5, %edi            # imm = 0x7E5
movl $0x2b, %esi
leaq -0x14(%rbp), %rdx
leaq -0x18(%rbp), %rcx
callq 0x1370
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
leaq 0xe6a(%rip), %rdi       # 0x205b
movb $0x0, %al
callq 0x1030
movl $0x7e5, %edi            # imm = 0x7E5
movl $0x16d, %esi            # imm = 0x16D
leaq -0x14(%rbp), %rdx
leaq -0x18(%rbp), %rcx
callq 0x1370
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
leaq 0xe3f(%rip), %rdi       # 0x205b
movb $0x0, %al
callq 0x1030
movl $0x7e5, %edi            # imm = 0x7E5
movl $0x16e, %esi            # imm = 0x16E
leaq -0x14(%rbp), %rdx
leaq -0x18(%rbp), %rcx
callq 0x1370
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
leaq 0xe14(%rip), %rdi       # 0x205b
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_09/date_conversion_pointers.c
// Function: day_of_year
int day_of_year(int year, int month, int day)
{
  int leap = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;

  // Additional checks for month.
  if (month > 12)
  {
    printf("Error: a year has 12 months, so please choose a number betweeen 1 and 12.\n");
    return -1;
  }

  // Additional checks for day.
  if (day > daytab[leap][month])
  {
    printf("Error: the %d month has a maximum of %d days.\n", month, daytab[leap][month]);
    return -2;
  }

  int i;
  for (i = 1; i < month; i++)
  {
    day += daytab[leap][i];
  }

  return day;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x1296
movl -0x8(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movb $0x1, %al
cmpl $0x0, %edx
movb %al, -0x19(%rbp)
jne 0x12aa
movl -0x8(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
cmpl $0x0, %edx
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
cmpl $0xc, -0xc(%rbp)
jle 0x12d5
leaq 0xdad(%rip), %rdi       # 0x206f
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1361
movl -0x10(%rbp), %eax
movslq -0x14(%rbp), %rdx
leaq 0x2d4d(%rip), %rcx      # 0x4030
movq (%rcx,%rdx,8), %rcx
movslq -0xc(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jle 0x1324
movl -0xc(%rbp), %esi
movslq -0x14(%rbp), %rcx
leaq 0x2d2f(%rip), %rax      # 0x4030
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %edx
leaq 0xda6(%rip), %rdi       # 0x20ba
movb $0x0, %al
callq 0x1030
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x1361
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x135b
movslq -0x14(%rbp), %rcx
leaq 0x2cf2(%rip), %rax      # 0x4030
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x132b
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_09/date_conversion_pointers.c
// Function: month_day
void month_day(int year, int yearday, int *pmonth, int *pda)
{
  int leap = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;

  // Additional check for yearday.
  if ((!leap && yearday > 365) || (leap && yearday > 366))
  {
    // Reset the provided month and day.
    *pmonth = 0;
    *pda = 0;
    printf("Error: year %d has %d days.\n", year, leap ? 366 : 365);

    return;
  }

  int i;
  for (i = 0; yearday > daytab[leap][i]; i++)
  {
    yearday -= daytab[leap][i];
  }

  *pmonth = i;
  *pda = yearday;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x13ab
movl -0x4(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movb $0x1, %al
cmpl $0x0, %edx
movb %al, -0x21(%rbp)
jne 0x13bf
movl -0x4(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
cmpl $0x0, %edx
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x13d9
cmpl $0x16d, -0x8(%rbp)      # imm = 0x16D
jg 0x13e8
cmpl $0x0, -0x1c(%rbp)
je 0x1422
cmpl $0x16e, -0x8(%rbp)      # imm = 0x16E
jle 0x1422
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl -0x4(%rbp), %esi
movl -0x1c(%rbp), %ecx
movl $0x16d, %edx            # imm = 0x16D
movl $0x16e, %eax            # imm = 0x16E
cmpl $0x0, %ecx
cmovnel %eax, %edx
leaq 0xcd0(%rip), %rdi       # 0x20e9
movb $0x0, %al
callq 0x1030
jmp 0x1483
movl $0x0, -0x20(%rbp)
movl -0x8(%rbp), %eax
movslq -0x1c(%rbp), %rdx
leaq 0x2bf9(%rip), %rcx      # 0x4030
movq (%rcx,%rdx,8), %rcx
movslq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jle 0x1471
movslq -0x1c(%rbp), %rcx
leaq 0x2bde(%rip), %rax      # 0x4030
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movl -0x8(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1429
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/benchmarks/bench_activation.c
// Function: bench_sigmoid
void bench_sigmoid(int n, const char *message, int size, double *x) {
  double *y = calloc(size*size, sizeof(double));
  double start = get_time();
  for (int i = 0; i < n; ++i) {
    morpheus_sigmoid(size*size, x, y);
  }
  double finish = get_time();
  free(y);
  double ms = (finish-start)/n;
  printf("Benchmark %s: %f ms\n", message, ms);
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movl 0x34(%rsp), %eax
imull 0x34(%rsp), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x10e0
movq %rax, 0x20(%rsp)
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x12d5
movl 0x34(%rsp), %edi
imull 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x26f0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x12a6
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1090
movsd 0x8(%rsp), %xmm0
subsd 0x18(%rsp), %xmm0
cvtsi2sdl 0x44(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x38(%rsp), %rsi
movsd (%rsp), %xmm0
leaq 0x3cec(%rip), %rdi      # 0x5004
movb $0x1, %al
callq 0x1030
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/benchmarks/bench_activation.c
// Function: bench_sigmoid_gradient
void bench_sigmoid_gradient(int n, const char *message, int size, double *x) {
  double *y = calloc(size*size, sizeof(double));
  double start = get_time();
  for (int i = 0; i < n; ++i) {
    morpheus_sigmoid_gradient(size*size, x, y);
  }
  double finish = get_time();
  free(y);
  double ms = (finish-start)/n;
  printf("Benchmark %s: %f ms\n", message, ms);
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movl 0x34(%rsp), %eax
imull 0x34(%rsp), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x10e0
movq %rax, 0x20(%rsp)
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x13a5
movl 0x34(%rsp), %edi
imull 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x2780
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1376
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1090
movsd 0x8(%rsp), %xmm0
subsd 0x18(%rsp), %xmm0
cvtsi2sdl 0x44(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x38(%rsp), %rsi
movsd (%rsp), %xmm0
leaq 0x3c1c(%rip), %rdi      # 0x5004
movb $0x1, %al
callq 0x1030
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/benchmarks/bench_activation.c
// Function: bench_relu_gradient
void bench_relu_gradient(int n, const char *message, int size, double *x) {
  double *y = calloc(size*size, sizeof(double));
  double start = get_time();
  for (int i = 0; i < n; ++i) {
    morpheus_relu_gradient(size*size, x, y);
  }
  double finish = get_time();
  free(y);
  double ms = (finish-start)/n;
  printf("Benchmark %s: %f ms\n", message, ms);
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movl 0x34(%rsp), %eax
imull 0x34(%rsp), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x10e0
movq %rax, 0x20(%rsp)
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x1545
movl 0x34(%rsp), %edi
imull 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x28b0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1516
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1090
movsd 0x8(%rsp), %xmm0
subsd 0x18(%rsp), %xmm0
cvtsi2sdl 0x44(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x38(%rsp), %rsi
movsd (%rsp), %xmm0
leaq 0x3a7c(%rip), %rdi      # 0x5004
movb $0x1, %al
callq 0x1030
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/benchmarks/bench_activation.c
// Function: bench_tanh_gradient
void bench_tanh_gradient(int n, const char *message, int size, double *x) {
  double *y = calloc(size*size, sizeof(double));
  double start = get_time();
  for (int i = 0; i < n; ++i) {
    morpheus_tanh_gradient(size*size, x, y);
  }
  double finish = get_time();
  free(y);
  double ms = (finish-start)/n;
  printf("Benchmark %s: %f ms\n", message, ms);
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movl 0x34(%rsp), %eax
imull 0x34(%rsp), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x10e0
movq %rax, 0x20(%rsp)
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x16e5
movl 0x34(%rsp), %edi
imull 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x2980
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x16b6
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1090
movsd 0x8(%rsp), %xmm0
subsd 0x18(%rsp), %xmm0
cvtsi2sdl 0x44(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x38(%rsp), %rsi
movsd (%rsp), %xmm0
leaq 0x38dc(%rip), %rdi      # 0x5004
movb $0x1, %al
callq 0x1030
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/benchmarks/bench_matrix_reduce.c
// Function: bench_column_pred
void bench_column_pred(int n, const char *message,
                       double (*pred)(double, double),
                       morpheus_layout_e layout,
                       int size, double *x) {
  double *y = calloc(size, sizeof(double));
  double start = get_time();
  for (int i = 0; i < n; ++i) {
    y[0] = i;
    morpheus_column_predicate(pred, layout, size, size, x, y);
  }
  double finish = get_time();
  free(y);
  double ms = (finish-start)/n;
  printf("Benchmark %s: %f ms\n", message, ms);
}

// Assembly:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movl %r8d, 0x38(%rsp)
movq %r9, 0x30(%rsp)
movslq 0x38(%rsp), %rdi
movl $0x8, %esi
callq 0x10e0
movq %rax, 0x28(%rsp)
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x54(%rsp), %eax
jge 0x17cf
cvtsi2sdl 0x1c(%rsp), %xmm0
movq 0x28(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %edx
movl 0x38(%rsp), %ecx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
callq 0x2a10
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1789
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1090
movsd 0x10(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
cvtsi2sdl 0x54(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x48(%rsp), %rsi
movsd 0x8(%rsp), %xmm0
leaq 0x37f0(%rip), %rdi      # 0x5004
movb $0x1, %al
callq 0x1030
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/benchmarks/bench_matrix_reduce.c
// Function: bench_row_pred
void bench_row_pred(int n, const char *message,
                    double (*pred)(double, double),
                    morpheus_layout_e layout,
                    int size, double *x) {
  double *y = calloc(size, sizeof(double));
  double start = get_time();
  for (int i = 0; i < n; ++i) {
    y[0] = i;
    morpheus_row_predicate(pred, layout, size, size, x, y);
  }
  double finish = get_time();
  free(y);
  double ms = (finish-start)/n;
  printf("Benchmark %s: %f ms\n", message, ms);
}

// Assembly:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movl %r8d, 0x38(%rsp)
movq %r9, 0x30(%rsp)
movslq 0x38(%rsp), %rdi
movl $0x8, %esi
callq 0x10e0
movq %rax, 0x28(%rsp)
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x54(%rsp), %eax
jge 0x18af
cvtsi2sdl 0x1c(%rsp), %xmm0
movq 0x28(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %edx
movl 0x38(%rsp), %ecx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
callq 0x2be0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1869
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1090
movsd 0x10(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
cvtsi2sdl 0x54(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x48(%rsp), %rsi
movsd 0x8(%rsp), %xmm0
leaq 0x3710(%rip), %rdi      # 0x5004
movb $0x1, %al
callq 0x1030
addq $0x58, %rsp
retq