LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpb $0x20, (%rax)
jne 0x6374
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x21e0
movq (%rbx), %rax
jmp 0x635b
movl 0x8(%rbx), %r15d
decl %r15d
cmpb $0x20, (%rax,%r15)
jne 0x6397
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21e0
movq (%rbx), %rax
jmp 0x637b
leaq 0x10(%r14), %rdx
movq %rdx, (%r14)
leaq 0x10(%rbx), %rcx
cmpq %rcx, %rax
je 0x63b3
movq %rax, (%r14)
movq (%rcx), %rax
movq %rax, 0x10(%r14)
jmp 0x63b9
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
movq %rcx, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
movsbl (%r15), %r14d
movl %r14d, %edi
callq 0x2260
cmpl $0x5f, %r14d
je 0x6409
testl %eax, %eax
jne 0x6409
xorl %eax, %eax
jmp 0x6448
movq 0x8(%rbx), %rbx
movb $0x1, %al
cmpq $0x2, %rbx
jb 0x6448
movl $0x1, %ecx
movl $0x2, %r14d
movsbl (%r15,%rcx), %edi
cmpl $0x5f, %edi
sete %r12b
callq 0x21a0
testl %eax, %eax
setne %al
orb %r12b, %al
cmpb $0x1, %al
jne 0x6448
movl %r14d, %ecx
incl %r14d
cmpq %rcx, %rbx
ja 0x6420
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/luixmao[P]verilog/vlg_parser_man.cpp
// Function: has_proper_parentesis(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool has_proper_parentesis(string s){
    s=remove_spaces( s); //removes all spaces

    //check there is only one '(' and that it is in the second to last position
    string str2 (")");
    unsigned found = s.find(str2);
    if (found!=(s.length()-2)){
      cout<< " error: improper ')' "<<endl;
      return false;
    }
   
    //check there is not aditional ;
    string str3 ("(");
    unsigned found3 = s.find(str3);
    if (found3!=string::npos){
      cout<< " error: improper '(' "<<endl;
      return false;
    }

return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq -0x68(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %r14
movq %r14, %rdi
callq 0x28b4
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x6749
leaq -0x38(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21f0
movq (%r14), %rdi
leaq -0x28(%rbp), %r14
cmpq %r14, %rdi
je 0x64b2
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2190
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x64c7
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x2190
leaq -0x38(%rbp), %rdi
movq %r14, (%rdi)
leaq 0xd53(%rip), %rsi       # 0x7228
leaq 0xd4d(%rip), %rdx       # 0x7229
callq 0x6b42
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x22a0
movl %eax, %eax
movq 0x8(%rbx), %rcx
addq $-0x2, %rcx
cmpq %rcx, %rax
jne 0x6594
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xc33(%rip), %rsi       # 0x7148
leaq 0xc2d(%rip), %rdx       # 0x7149
leaq -0x58(%rbp), %rdi
callq 0x6b42
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x22a0
movq 0x4a92(%rip), %rbx      # 0xafd0
leaq 0xcfb(%rip), %rsi       # 0x7240
movl $0x15, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq 0x4a60(%rip), %rdi      # 0xafd0
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x65da
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2190
jmp 0x65da
movq 0x4a35(%rip), %rbx      # 0xafd0
leaq 0xc88(%rip), %rsi       # 0x722a
movl $0x15, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq 0x4a03(%rip), %rdi      # 0xafd0
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x65ef
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2190
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x662f
movq %rax, %rbx
jmp 0x6647
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x6647
movq -0x68(%rbp), %rsi
jmp 0x663f
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x6632
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2190
jmp 0x6632
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x6647
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x28b4
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0x6348
leaq -0x60(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21f0
movq (%r14), %rdi
leaq -0x50(%rbp), %r12
cmpq %r12, %rdi
je 0x66b2
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2190
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x66c7
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2190
leaq -0x60(%rbp), %r15
movq %r12, (%r15)
leaq 0xa10(%rip), %rsi       # 0x70e5
leaq 0xa0a(%rip), %rdx       # 0x70e6
movq %r15, %rdi
callq 0x6b42
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x22a0
movq %rax, %r14
movq 0x8(%rbx), %rbx
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x6710
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2190
movl %r14d, %eax
decq %rbx
cmpq %rbx, %rax
sete %al
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x6741
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
xorl %r15d, %r15d
testq %rax, %rax
je 0x6790
xorl %esi, %esi
movq (%rbx), %rcx
cmpb $0x20, (%rcx,%rsi)
jne 0x6783
movl $0x1, %edx
movq %rbx, %rdi
callq 0x21e0
movq 0x8(%rbx), %rax
jmp 0x6786
incl %r15d
movl %r15d, %esi
cmpq %rsi, %rax
jne 0x6767
jmp 0x6792
xorl %eax, %eax
leaq 0x10(%r14), %rdx
movq %rdx, (%r14)
movq (%rbx), %rsi
leaq 0x10(%rbx), %rcx
cmpq %rcx, %rsi
je 0x67b1
movq %rsi, (%r14)
movq (%rcx), %rdx
movq %rdx, 0x10(%r14)
jmp 0x67b7
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, 0x8(%r14)
movq %rcx, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa15(%rip), %rsi       # 0x71fd
callq 0x2080
testl %eax, %eax
je 0x6858
leaq 0xa0a(%rip), %rsi       # 0x7202
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x685c
leaq 0x9f1(%rip), %rsi       # 0x71fc
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x6863
leaq 0x9e3(%rip), %rsi       # 0x7201
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x686a
leaq 0x9d4(%rip), %rsi       # 0x7205
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x6871
leaq 0x9c5(%rip), %rsi       # 0x7209
movq %rbx, %rdi
callq 0x2080
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leal (%rcx,%rcx,4), %eax
jmp 0x6876
xorl %eax, %eax
jmp 0x6876
movl $0x1, %eax
jmp 0x6876
movl $0x2, %eax
jmp 0x6876
movl $0x3, %eax
jmp 0x6876
movl $0x4, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %r15
movl $0x18, %edi
callq 0x2180
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %r13d, %r13d
movq %r13, 0x10(%rax)
leaq -0x1d0(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
movl $0x18, %edx
callq 0x2250
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq %r13, -0x8(%r12)
movb $0x0, (%r12)
leaq -0x48(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2200
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x6902
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4e00
jmp 0x68dc
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x6917
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2190
movq 0x4692(%rip), %rsi      # 0xafb0
leaq -0x1d0(%rbp), %rdi
callq 0x2110
leaq -0x150(%rbp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x6963
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2190
movq 0x4646(%rip), %rsi      # 0xafb0
leaq -0x1d0(%rbp), %rdi
callq 0x2110
leaq -0x150(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x28b4
leaq -0x78(%rbp), %rdi
movq %r14, %rsi
callq 0x6348
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x69dd
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x2190
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x69f2
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2190
movq (%rbx), %rax
cmpb $0x23, (%rax)
jne 0x6a48
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x21e0
movq (%rbx), %rsi
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x28b4
movq %rbx, %rdi
callq 0x6a7f
movl %eax, %ebx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x6a4a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2190
jmp 0x6a4a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
jmp 0x6a67
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x6a77
movq (%r15), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x28b4
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
callq 0x6348
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6ad2
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2190
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x6ae7
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2190
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x6b14
movq (%rbx), %rdx
movl $0x1, %esi
xorl %edi, %edi
movsbl (%rdx,%rdi), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
setb %al
jae 0x6b16
movl %esi, %edi
incl %esi
cmpq %rdi, %rcx
ja 0x6afa
jmp 0x6b16
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x6b39
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
leaq 0x9d0c(%rip), %rdi      # 0xb033
callq 0x4e53
leaq 0x61(%rip), %rsi        # 0x1394
movq %rax, %rdi
callq 0x37ef
leaq 0x2d84(%rip), %rdi      # 0x40c6
movq %rax, %rsi
callq 0x3bb4
movq %rax, %rbx
leaq 0xa11f(%rip), %rdi      # 0xb473
leaq 0x9ca9(%rip), %rsi      # 0xb004
movq %rsp, %r14
movq %rax, %rdx
movq %r14, %rcx
callq 0x28d7
movq (%r14), %rsi
leaq 0x9ccd(%rip), %rdi      # 0xb040
xorl %eax, %eax
callq 0x10b0
movq (%r14), %rdi
callq 0x1220
movq %rbx, %rdi
callq 0x2d8b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl %edi, %eax
testb $0x3, %al
jne 0x137c
movslq %eax, %rdi
imulq $0x51eb851f, %rdi, %rdi # imm = 0x51EB851F
movq %rdi, %r8
shrq $0x3f, %r8
sarq $0x25, %rdi
addl %r8d, %edi
imull $0x64, %edi, %edi
movl %eax, %r8d
subl %edi, %r8d
je 0x137c
movl $0x16e, %r8d            # imm = 0x16E
movl $0x1, %edi
jmp 0x13a2
imull $0xc28f5c29, %eax, %r8d # imm = 0xC28F5C29
addl $0x51eb850, %r8d        # imm = 0x51EB850
rorl $0x4, %r8d
xorl %edi, %edi
cmpl $0xa3d70b, %r8d         # imm = 0xA3D70B
setb %dil
leal 0x16d(%rdi), %r8d
cmpl %esi, %r8d
jge 0x13c0
xorl %esi, %esi
movl %esi, (%rdx)
movl %esi, (%rcx)
leaq 0xca8(%rip), %rdi       # 0x205c
movl %eax, %esi
movl %r8d, %edx
xorl %eax, %eax
jmp 0x1040
leaq 0x2a09(%rip), %rax      # 0x3dd0
movq (%rax,%rdi,8), %rdi
movsbl (%rdi), %r8d
xorl %eax, %eax
cmpl %esi, %r8d
jge 0x13e9
xorl %eax, %eax
subl %r8d, %esi
movsbl 0x1(%rdi,%rax), %r8d
incq %rax
cmpl %r8d, %esi
jg 0x13d8
movl %eax, (%rdx)
movl %esi, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/aligusnet[P]morpheus/src/matrix_reduce.c
// Function: morpheus_column_predicate
void morpheus_column_predicate(double (*pred)(double, double),
                               morpheus_layout_e layout,
                               int nrows,
                               int ncols,
                               const double *x,
                               double *y) {
  if (layout == morpheus_row_major) {
    /* first row is initial values */
    morpheus_dcopy(ncols, x, y);
    for (int i = 1; i < nrows; ++i) {
      const double *row = x + i*ncols;
      for (int j = 0; j < ncols; ++j) {
        y[j] = pred(y[j], row[j]);
      }
    }
  } else if (layout == morpheus_col_major) {
    for (int j = 0; j < ncols; ++j) {
      const double *column = &x[j*nrows];
      y[j] = column[0];
      for (int i = 1; i < nrows; ++i) {
        y[j] = pred(y[j], column[i]);
      }
    }
  } else {
    perror("unkwnown matrix layout");
    assert(0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %r14
cmpl $0x15, %esi
movq %r8, 0x8(%rsp)
je 0x27db
cmpl $0x16, %esi
jne 0x2863
testl %r15d, %r15d
jle 0x2854
movslq %r12d, %rax
movl %r15d, %ecx
movq %rcx, 0x10(%rsp)
movl %eax, %ebp
movq %rax, 0x18(%rsp)
leaq (,%rax,8), %rax
movq %rax, 0x20(%rsp)
xorl %r13d, %r13d
movq %r8, %r15
movq %r13, %rax
movq 0x18(%rsp), %rcx
imulq %rcx, %rax
movsd (%r8,%rax,8), %xmm0
movsd %xmm0, (%rbx,%r13,8)
cmpl $0x2, %ecx
jl 0x27c5
movl $0x1, %r12d
movsd (%r15,%r12,8), %xmm1
callq *%r14
movsd %xmm0, (%rbx,%r13,8)
incq %r12
cmpq %r12, %rbp
jne 0x27ae
incq %r13
addq 0x20(%rsp), %r15
cmpq 0x10(%rsp), %r13
movq 0x8(%rsp), %r8
jne 0x278b
jmp 0x2854
movl %r15d, %edi
movq %r8, %rsi
movq %rbx, %rdx
callq 0x2f60
movq 0x8(%rsp), %rax
cmpl $0x2, %r12d
jl 0x2854
movslq %r15d, %rcx
movl %r12d, %edx
movq %rdx, 0x10(%rsp)
movl %r15d, %r13d
leaq (%rax,%rcx,8), %rbp
shlq $0x3, %rcx
movq %rcx, 0x8(%rsp)
movl $0x1, %r12d
movl %r15d, 0x18(%rsp)
testl %r15d, %r15d
jle 0x2840
xorl %r15d, %r15d
movsd (%rbx,%r15,8), %xmm0
movsd (%rbp,%r15,8), %xmm1
callq *%r14
movsd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq %r15, %r13
jne 0x2822
incq %r12
addq 0x8(%rsp), %rbp
cmpq 0x10(%rsp), %r12
movl 0x18(%rsp), %r15d
jne 0x281a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1190
// File: /workspace/github_c_makefile_star2_O3/aligusnet[P]morpheus/src/matrix_reduce.c
// Function: morpheus_row_predicate
void morpheus_row_predicate(double (*pred)(double, double),
                            morpheus_layout_e layout,
                            int nrows, int ncols,
                            const double *x,
                            double *y) {
  if (layout == morpheus_row_major) {
    for (int i = 0; i < nrows; ++i) {
      const double *row = x + i*ncols;
      y[i] = row[0];
      for (int j = 1; j < ncols; ++j) {
        y[i] = pred(y[i], row[j]);
      }
    }
  } else if (layout == morpheus_col_major) {
    /* first column is initial values */
    morpheus_dcopy(nrows, x, y);
    for (int j = 1; j < ncols; ++j) {
      const double *column = x + j*nrows;
      for (int i = 0; i < nrows; ++i) {
        y[i] = pred(y[i], column[i]);
      }
    }
  } else {
    perror("unkwnown matrix layout");
    assert(0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %rbp
movq %rdi, %r14
cmpl $0x16, %esi
je 0x2916
cmpl $0x15, %esi
jne 0x299a
testl %edx, %edx
jle 0x298b
movslq %ecx, %rax
movl %edx, %edx
movq %rdx, 0x20(%rsp)
movl %ecx, %r15d
movq %rax, (%rsp)
leaq (,%rax,8), %rax
movq %rax, 0x18(%rsp)
xorl %r12d, %r12d
movq %rbp, %r13
movq %rbp, 0x10(%rsp)
movl %ecx, 0x8(%rsp)
movq %r12, %rax
imulq (%rsp), %rax
movsd (%rbp,%rax,8), %xmm0
movsd %xmm0, (%rbx,%r12,8)
cmpl $0x2, %ecx
jl 0x28fc
movl $0x1, %ebp
movsd (%r13,%rbp,8), %xmm1
callq *%r14
movsd %xmm0, (%rbx,%r12,8)
incq %rbp
cmpq %rbp, %r15
jne 0x28e4
incq %r12
addq 0x18(%rsp), %r13
cmpq 0x20(%rsp), %r12
movq 0x10(%rsp), %rbp
movl 0x8(%rsp), %ecx
jne 0x28c6
jmp 0x298b
movl %edx, %edi
movq %rbp, %rsi
movl %edx, (%rsp)
movq %rbx, %rdx
movl %ecx, %r15d
callq 0x2f60
movl (%rsp), %ecx
cmpl $0x2, %r15d
jl 0x298b
movslq %ecx, %rdx
movl %r15d, %eax
movq %rax, 0x8(%rsp)
movq %rbp, %rax
movl %ecx, %ebp
leaq (%rax,%rdx,8), %r12
shlq $0x3, %rdx
movq %rdx, 0x10(%rsp)
movl $0x1, %r13d
testl %ecx, %ecx
jle 0x2979
xorl %r15d, %r15d
movsd (%rbx,%r15,8), %xmm0
movsd (%r12,%r15,8), %xmm1
callq *%r14
movsd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq %r15, %rbp
jne 0x295c
incq %r13
addq 0x10(%rsp), %r12
cmpq 0x8(%rsp), %r13
movl (%rsp), %ecx
jne 0x2955
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x11ba
// File: /workspace/github_c_makefile_star2_O3/aligusnet[P]morpheus/src/matrix_reduce.c
// Function: morpheus_column_max_index
void morpheus_column_max_index(morpheus_layout_e layout,
                               int nrows, int ncols,
                               const double *x,
                               double *y,
                               int *is) {
  if (layout == morpheus_row_major) {
    for (int j = 0; j < ncols; ++j) {
      is[j] = 0;
      y[j] = x[j];
    }
    for (int i = 1; i < nrows; ++i) {
      const double *row = x + i*ncols;
      for (int j = 0; j < ncols; ++j) {
        if (y[j] < row[j]) {
          y[j] = row[j];
          is[j] = i;
        }
      }
    }
  } else if (layout == morpheus_col_major) {
    for (int j = 0; j < ncols; ++j) {
      const double *column = &x[j*nrows];
      y[j] = column[0];
      is[j] = 0;
      for (int i = 1; i < nrows; ++i) {
        if (y[j] < column[i]) {
          y[j] = column[i];
          is[j] = i;
        }
      }
    }
  } else {
    perror("unkwnown matrix layout");
    assert(0);
  }
}

// Assembly:
pushq %rbx
cmpl $0x15, %edi
je 0x2a1e
cmpl $0x16, %edi
jne 0x2a8f
testl %edx, %edx
jle 0x2a8d
movslq %esi, %rax
movl %edx, %edx
movl %eax, %esi
leaq (,%rax,8), %rdi
xorl %r10d, %r10d
movq %rcx, %r11
movq %r10, %rbx
imulq %rax, %rbx
movsd (%rcx,%rbx,8), %xmm0
movsd %xmm0, (%r8,%r10,8)
movl $0x0, (%r9,%r10,4)
cmpl $0x2, %eax
jl 0x2a11
movl $0x1, %ebx
movsd (%r11,%rbx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2a09
movsd %xmm1, (%r8,%r10,8)
movl %ebx, (%r9,%r10,4)
movapd %xmm1, %xmm0
incq %rbx
cmpq %rbx, %rsi
jne 0x29ef
incq %r10
addq %rdi, %r11
cmpq %rdx, %r10
jne 0x29cb
jmp 0x2a8d
testl %edx, %edx
jle 0x2a41
movl %edx, %eax
xorl %edi, %edi
movl $0x0, (%r9,%rdi,4)
movsd (%rcx,%rdi,8), %xmm0
movsd %xmm0, (%r8,%rdi,8)
incq %rdi
cmpq %rdi, %rax
jne 0x2a26
cmpl $0x2, %esi
jl 0x2a8d
movslq %edx, %rax
movl %esi, %esi
movl %edx, %edi
leaq (%rcx,%rax,8), %rcx
shlq $0x3, %rax
movl $0x1, %r10d
testl %edx, %edx
jle 0x2a82
xorl %r11d, %r11d
movsd (%rcx,%r11,8), %xmm0
ucomisd (%r8,%r11,8), %xmm0
jbe 0x2a7a
movsd %xmm0, (%r8,%r11,8)
movl %r10d, (%r9,%r11,4)
incq %r11
cmpq %r11, %rdi
jne 0x2a62
incq %r10
addq %rax, %rcx
cmpq %rsi, %r10
jne 0x2a5b
popq %rbx
retq
callq 0x11e4
// File: /workspace/github_c_makefile_star2_O3/aligusnet[P]morpheus/src/matrix_reduce.c
// Function: morpheus_row_max_index
void morpheus_row_max_index(morpheus_layout_e layout,
                            int nrows, int ncols,
                            const double *x,
                            double *y,
                            int *is) {
  if (layout == morpheus_row_major) {
    for (int i = 0; i < nrows; ++i) {
      const double *row = x + i*ncols;
      y[i] = row[0];
      is[i] = 0;
      for (int j = 1; j < ncols; ++j) {
        if (y[i] < row[j]) {
          y[i] = row[j];
          is[i] = j;
        }
      }
    }
  } else if (layout == morpheus_col_major) {
    for (int i = 0; i < nrows; ++i) {
      is[i] = 0;
      y[i] = x[i];
    }
    for (int j = 1; j < ncols; ++j) {
      const double *column = x + j*nrows;
      for (int i = 0; i < nrows; ++i) {
        if (y[i] < column[i]) {
          y[i] = column[i];
          is[i] = j;
        }
      }
    }
  } else {
    perror("unkwnown matrix layout");
    assert(0);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x15, %edi
je 0x2c12
cmpl $0x16, %edi
jne 0x2c86
movl %esi, %eax
testl %esi, %esi
jle 0x2bc2
xorl %edi, %edi
movl $0x0, (%r9,%rdi,4)
movsd (%rcx,%rdi,8), %xmm0
movsd %xmm0, (%r8,%rdi,8)
incq %rdi
cmpq %rdi, %rax
jne 0x2ba7
cmpl $0x2, %edx
jl 0x2c7e
movslq %esi, %rdi
movl %edx, %edx
leaq (%rcx,%rdi,8), %rcx
shlq $0x3, %rdi
movl $0x1, %r10d
testl %esi, %esi
jle 0x2c05
xorl %r11d, %r11d
movsd (%rcx,%r11,8), %xmm0
ucomisd (%r8,%r11,8), %xmm0
jbe 0x2bfd
movsd %xmm0, (%r8,%r11,8)
movl %r10d, (%r9,%r11,4)
incq %r11
cmpq %r11, %rax
jne 0x2be5
incq %r10
addq %rdi, %rcx
cmpq %rdx, %r10
jne 0x2bde
jmp 0x2c7e
testl %esi, %esi
jle 0x2c7e
movslq %edx, %rax
movl %esi, %esi
movl %edx, %edi
leaq (,%rax,8), %r10
xorl %r11d, %r11d
movq %rcx, %rbx
movq %r11, %r14
imulq %rax, %r14
movsd (%rcx,%r14,8), %xmm0
movsd %xmm0, (%r8,%r11,8)
movl $0x0, (%r9,%r11,4)
cmpl $0x2, %edx
jl 0x2c73
movl $0x1, %r14d
movsd (%rbx,%r14,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2c6b
movsd %xmm1, (%r8,%r11,8)
movl %r14d, (%r9,%r11,4)
movapd %xmm1, %xmm0
incq %r14
cmpq %r14, %rdi
jne 0x2c51
incq %r11
addq %r10, %rbx
cmpq %rsi, %r11
jne 0x2c2b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x123a
// File: /workspace/github_c_makefile_star2_O3/aligusnet[P]morpheus/src/matrix_reduce.c
// Function: morpheus_column_sum
void morpheus_column_sum(morpheus_layout_e layout,
                         int nrows, int ncols,
                         const double *x,
                         double *y) {
  if (layout == morpheus_row_major) {
    for (int j = 0; j < ncols; ++j) {
      y[j] = 0;
    }
    for (int i = 0; i < nrows; ++i) {
      const double *row = x + i*ncols;
      for (int j = 0; j < ncols; ++j) {
        y[j] += row[j];
      }
    }
  } else if (layout == morpheus_col_major) {
    for (int j = 0; j < ncols; ++j) {
      const double *column = &x[j*nrows];
      y[j] = 0;
      for (int i = 0; i < nrows; ++i) {
        y[j] += column[i];
      }
    }
  } else {
    perror("unkwnown matrix layout");
    assert(0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %r15d
movl %esi, %ebp
cmpl $0x15, %edi
je 0x2dfa
cmpl $0x16, %edi
jne 0x2e57
testl %r15d, %r15d
jle 0x2e4c
movslq %ebp, %rax
movl %r15d, %ecx
movl %eax, %edx
shlq $0x3, %rax
xorl %esi, %esi
movq $0x0, (%rbx,%rsi,8)
testl %ebp, %ebp
jle 0x2ded
xorpd %xmm0, %xmm0
xorl %edi, %edi
addsd (%r14,%rdi,8), %xmm0
movsd %xmm0, (%rbx,%rsi,8)
incq %rdi
cmpq %rdi, %rdx
jne 0x2dda
incq %rsi
addq %rax, %r14
cmpq %rcx, %rsi
jne 0x2dc8
jmp 0x2e4c
testl %r15d, %r15d
jle 0x2e10
movl %r15d, %edx
shlq $0x3, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1050
testl %ebp, %ebp
jle 0x2e4c
movslq %r15d, %rax
movl %ebp, %ecx
movl %r15d, %edx
shlq $0x3, %rax
xorl %esi, %esi
testl %r15d, %r15d
jle 0x2e41
xorl %edi, %edi
movsd (%r14,%rdi,8), %xmm0
addsd (%rbx,%rdi,8), %xmm0
movsd %xmm0, (%rbx,%rdi,8)
incq %rdi
cmpq %rdi, %rdx
jne 0x2e29
incq %rsi
addq %rax, %r14
cmpq %rcx, %rsi
jne 0x2e22
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1292
// File: /workspace/github_c_makefile_star2_O3/aligusnet[P]morpheus/src/matrix_reduce.c
// Function: morpheus_row_sum
void morpheus_row_sum(morpheus_layout_e layout,
                      int nrows, int ncols,
                      const double *x,
                      double *y) {
  if (layout == morpheus_row_major) {
    for (int i = 0; i < nrows; ++i) {
      const double *row = x + i*ncols;
      y[i] = 0;
      for (int j = 0; j < ncols; ++j) {
        y[i] += row[j];
      }
    }
  } else if (layout == morpheus_col_major) {
    for (int i = 0; i < nrows; ++i) {
      y[i] = 0;
    }
    for (int j = 0; j < ncols; ++j) {
      const double *column = x + j*nrows;
      for (int i = 0; i < nrows; ++i) {
        y[i] += column[i];
      }
    }
  } else {
    perror("unkwnown matrix layout");
    assert(0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r15d
cmpl $0x15, %edi
je 0x2ed2
cmpl $0x16, %edi
jne 0x2f1e
movl %r15d, %r12d
testl %r15d, %r15d
jle 0x2e97
leaq (,%r12,8), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1050
testl %ebp, %ebp
jle 0x2f15
movslq %r15d, %rax
movl %ebp, %ecx
shlq $0x3, %rax
xorl %edx, %edx
testl %r15d, %r15d
jle 0x2ec5
xorl %esi, %esi
movsd (%r14,%rsi,8), %xmm0
addsd (%rbx,%rsi,8), %xmm0
movsd %xmm0, (%rbx,%rsi,8)
incq %rsi
cmpq %rsi, %r12
jne 0x2ead
incq %rdx
addq %rax, %r14
cmpq %rcx, %rdx
jne 0x2ea6
jmp 0x2f15
testl %r15d, %r15d
jle 0x2f15
movslq %ebp, %rax
movl %r15d, %ecx
movl %ebp, %edx
shlq $0x3, %rax
xorl %esi, %esi
movq $0x0, (%rbx,%rsi,8)
testl %ebp, %ebp
jle 0x2f0a
xorpd %xmm0, %xmm0
xorl %edi, %edi
addsd (%r14,%rdi,8), %xmm0
movsd %xmm0, (%rbx,%rsi,8)
incq %rdi
cmpq %rdi, %rdx
jne 0x2ef7
incq %rsi
addq %rax, %r14
cmpq %rcx, %rsi
jne 0x2ee5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x12be
nop
// File: /workspace/github_c_makefile_star2_O3/aligusnet[P]morpheus/src/simple_blas.c
// Function: morpheus_dgemm
void morpheus_dgemm(const morpheus_layout_e layout,
                    const morpheus_transpose_e trans_a,
                    const morpheus_transpose_e trans_b,
                    const int m,
                    const int n,
                    const int k,
                    const double alpha,
                    const double *a,
                    const double *b,
                    const double beta,
                    double *c) {
  int lda, ldb, ldc;
  if (layout == morpheus_row_major) {
    lda = trans_a == morpheus_no_trans ? k : m;
    ldb = trans_b == morpheus_no_trans ? n : k;
    ldc = n;
  } else {
    lda = trans_a == morpheus_no_trans ? m : k;
    ldb = trans_b == morpheus_no_trans ? k : n;
    ldc = m;
  }
  cblas_dgemm(to_cblas_layout(layout),
              to_cblas_transpose(trans_a), to_cblas_transpose(trans_b),
              m, n, k, alpha, a, lda, b, ldb, beta, c, ldc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x50(%rsp), %r14
movq 0x48(%rsp), %rbx
movq 0x40(%rsp), %r11
cmpl $0x15, %edi
jne 0x3114
cmpl $0xb, %edx
movl %r9d, %r15d
cmovel %r8d, %r15d
cmpl $0xb, %esi
movl %ecx, %r12d
cmovel %r9d, %r12d
movl $0x65, %edi
movl %r8d, %r13d
jmp 0x3138
cmpl $0xb, %edx
movl %r8d, %r15d
cmovel %r9d, %r15d
cmpl $0xb, %esi
movl %r9d, %r12d
cmovel %ecx, %r12d
xorl %eax, %eax
cmpl $0x16, %edi
movl $0x66, %edi
cmovnel %eax, %edi
movl %ecx, %r13d
xorl %eax, %eax
cmpl $0xc, %esi
movl $0x70, %ebp
movl $0x0, %r10d
cmovel %ebp, %r10d
cmpl $0xb, %esi
movl $0x6f, %esi
cmovel %esi, %r10d
cmpl $0xc, %edx
cmovel %ebp, %eax
cmpl $0xb, %edx
cmovel %esi, %eax
movl %r10d, %esi
movl %eax, %edx
pushq %r13
pushq %r14
pushq %r15
pushq %rbx
pushq %r12
pushq %r11
callq 0x1140
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Carton32[P]quectel-CM/quectel-mbim-proxy.c
// Function: non_block_write
static int non_block_write(int fd, void *data, int len)
{
    int ret;
    struct pollfd pollfd = {fd, POLLOUT, 0};
    ret = poll(&pollfd, 1, 3000);

    if (ret <= 0) {
        mbim_debug("%s poll ret=%d, errno: %d(%s)\n", __func__, ret, errno, strerror(errno));
    }

    ret = write (fd, data, len);
    if (ret != len)
        mbim_debug("%s write ret=%d, errno: %d(%s)\n", __func__, ret, errno, strerror(errno));

    return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %ebp
leaq 0x10(%rsp), %rdi
movl %ebp, (%rdi)
movl $0x4, 0x4(%rdi)
movl $0x1, %esi
movl $0xbb8, %edx            # imm = 0xBB8
callq 0x1100
testl %eax, %eax
jg 0x1d8c
movl %eax, %r15d
movq 0x2285(%rip), %rax      # 0x3fd0
movq (%rax), %r12
callq 0x127c
callq 0x1040
movl (%rax), %r13d
movl %r13d, %edi
callq 0x1150
movq %rax, (%rsp)
leaq 0x3db(%rip), %rsi       # 0x2149
leaq 0x236b(%rip), %rdx      # 0x40e0
leaq 0x3ef(%rip), %rcx       # 0x216b
movq %r12, %rdi
movl %r15d, %r8d
movl %r13d, %r9d
xorl %eax, %eax
callq 0x10e0
movl %ebx, %edx
movl %ebp, %edi
movq %r14, %rsi
callq 0x1070
movq %rax, %r14
cmpl %ebx, %r14d
je 0x1de6
movq 0x2229(%rip), %rax      # 0x3fd0
movq (%rax), %r15
callq 0x127c
callq 0x1040
movl (%rax), %ebp
movl %ebp, %edi
callq 0x1150
movq %rax, (%rsp)
leaq 0x3b3(%rip), %rsi       # 0x217b
leaq 0x2311(%rip), %rdx      # 0x40e0
leaq 0x395(%rip), %rcx       # 0x216b
movq %r15, %rdi
movl %r14d, %r8d
movl %ebp, %r9d
xorl %eax, %eax
callq 0x10e0
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Carton32[P]quectel-CM/quectel-mbim-proxy.c
// Function: handle_client_disconnect
static void handle_client_disconnect(int client_fd)
{
    int i;

    for (i = 0; i < CM_MAX_CLIENT; i++) {
        if (cm_clients[i].client_fd == client_fd) {
            mbim_debug("%s client_fd=%d, client_idx=%d\n", __func__, cm_clients[i].client_fd, cm_clients[i].client_idx);
            safe_close(cm_clients[i].client_fd);
            return;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %r14d, %r14d
leaq 0x236a(%rip), %r15      # 0x4170
cmpl %edi, (%r15,%r14,8)
je 0x1e17
incq %r14
cmpq $0x20, %r14
jne 0x1e06
jmp 0x1e67
movq 0x21b2(%rip), %rax      # 0x3fd0
movq (%rax), %rbx
callq 0x127c
movl (%r15,%r14,8), %r8d
movl 0x4(%r15,%r14,8), %r9d
leaq 0x41b(%rip), %rsi       # 0x2251
leaq 0x22a3(%rip), %rdx      # 0x40e0
leaq 0x430(%rip), %rcx       # 0x2274
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10e0
movl (%r15,%r14,8), %edi
testl %edi, %edi
jle 0x1e67
shlq $0x3, %r14
callq 0x10c0
movl $0xffffffff, (%r14,%r15) # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/test-unssa.c
// Function: main
int main(int argc, char **argv)
{
	struct string_list * filelist = NULL;
	char *file;

	compile(sparse_initialize(argc, argv, &filelist));
	FOR_EACH_PTR(filelist, file) {
		compile(sparse(file));
	} END_FOR_EACH_PTR(file);

	report_stats();
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq %rbx, %rdx
callq 0x1485e
movq %rax, %rdi
callq 0xf696
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xf685
movq %rbx, %r14
movzwl (%r14), %eax
testb %al, %al
jle 0xf67c
xorl %r15d, %r15d
movq 0x18(%r14,%r15,8), %rdi
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0xf65c
testq %rdi, %rdi
je 0xf66d
callq 0x14b96
movq %rax, %rdi
callq 0xf696
movzwl (%r14), %eax
incq %r15
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r15
jl 0xf647
movq 0x10(%r14), %r14
cmpq %rbx, %r14
jne 0xf63c
callq 0x2da44
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/test-unssa.c
// Function: compile
static int compile(struct symbol_list *list)
{
	struct symbol *sym;
	FOR_EACH_PTR(list, sym) {
		struct entrypoint *ep;
		expand_symbol(sym);
		ep = linearize_symbol(sym);
		if (!(fdump_ir & PASS_FINAL))
			continue;
		if (ep)
			output_fn(ep);
		else
			output_data(sym);
	}
	END_FOR_EACH_PTR(sym);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0xf8cb
leaq 0x38752(%rip), %rbp     # 0x47e0a
movq (%rsp), %rdx
movzwl (%rdx), %eax
testb %al, %al
jle 0xf8bd
xorl %esi, %esi
movq %rdx, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rdx,%rsi,8), %r13
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xf6eb
testq %r13, %r13
je 0xf8a1
movq %r13, %rdi
callq 0xfb74
movq %r13, %rdi
callq 0x1654a
movq %rax, %r14
leaq 0x58823(%rip), %rax     # 0x67f28
testb $0x10, (%rax)
je 0xf8a1
testq %r14, %r14
je 0xf74b
leaq 0x56db6(%rip), %rax     # 0x664d0
movq (%rax), %r12
incq %r12
movq %r12, (%rax)
movq (%r14), %rbx
movq 0x18(%rbx), %rdi
callq 0x308dd
testb $0x4, 0x68(%rbx)
jne 0xf791
leaq 0x318cf(%rip), %rdi     # 0x4100b
movq %rax, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe0f0
jmp 0xf7a2
movq 0x18(%r13), %rdi
callq 0x308dd
leaq 0x318c1(%rip), %rdi     # 0x4101c
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
movq 0x60(%r13), %rax
movzbl (%rax), %esi
leaq 0x318b5(%rip), %rdi     # 0x41028
xorl %eax, %eax
callq 0xe0f0
movq 0x68(%r13), %rsi
leaq 0x318af(%rip), %rdi     # 0x41034
xorl %eax, %eax
callq 0xe0f0
jmp 0xf8a1
leaq 0x3186c(%rip), %rdi     # 0x41004
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
movq %r14, %rdi
callq 0x32000
movq 0x18(%r14), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xf8a1
movq 0x8(%rsp), %r15
movq %r12, 0x20(%rsp)
movzwl (%r15), %eax
testb %al, %al
jle 0xf892
xorl %ebx, %ebx
movq 0x18(%r15,%rbx,8), %r14
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0xf7ed
testq %r14, %r14
je 0xf87f
cmpq %r12, 0x8(%r14)
je 0xf87f
movq %r12, 0x8(%r14)
movq %r14, %rdi
callq 0x14d49
movq %rax, %rdi
callq 0xe0a0
movq 0x28(%r14), %r12
testq %r12, %r12
je 0xf86c
movq %r12, %r14
movzwl (%r14), %eax
testb %al, %al
jle 0xf863
xorl %r13d, %r13d
movq 0x18(%r14,%r13,8), %rdi
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0xf837
testq %rdi, %rdi
je 0xf854
cmpq $0x0, 0x8(%rdi)
je 0xf854
callq 0x14fd7
movq %rbp, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
movzwl (%r14), %eax
incq %r13
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r13
jl 0xf822
movq 0x10(%r14), %r14
cmpq %r12, %r14
jne 0xf817
movl $0xa, %edi
callq 0xe040
movzwl (%r15), %eax
movq 0x20(%rsp), %r12
incq %rbx
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %rbx
jl 0xf7d4
movq 0x10(%r15), %r15
cmpq 0x8(%rsp), %r15
jne 0xf7c6
movq 0x18(%rsp), %rsi
incq %rsi
movq 0x10(%rsp), %rdx
movl (%rdx), %eax
movsbq %al, %rcx
cmpq %rcx, %rsi
jl 0xf6ce
movq 0x10(%rdx), %rdx
cmpq (%rsp), %rdx
jne 0xf6bc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/saulvargas[P]re-C-sys/test_pop.c
// Function: main
int main(int argc, char** argv) {
    FILE* user_data;
    FILE* item_data;
    int N_users;
    int N_items;
    int N_prefs;
    int binary;
    recdata_t* recdata;
    int uid;
    int i;
    recommender_t* recommender;
    idpairs_t* pairs;

    if (!read_args(argc, argv, &user_data, &item_data, &N_users, &N_items, &N_prefs, &binary)) {
        return EXIT_FAILURE;
    }

    recdata = recdata_simple_create(user_data, item_data, N_users, N_items, N_prefs, binary);
    
    fclose(user_data);
    fclose(item_data);

    recommender = recommender_pop_create(recdata);

    for (uid = 0; uid < recdata->N_users; uid++) {
        pairs = recommender_recommend(recommender, uid, 100);

        for (i = 0; i < idpairs_size(pairs); i++) {
            printf("%d\t%d\t%.4f\n", uid, idpairs_keys(pairs)[i], idpairs_values(pairs)[i]);
        }
        
        idpairs_close_deep(pairs);
    }
 
    recommender_close(recommender);
 
    recdata_close(recdata);
    
    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsp, %rax
leaq 0x4(%rsp), %r10
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %rcx
leaq 0xc(%rsp), %r8
leaq 0x8(%rsp), %r9
pushq %rax
pushq %r10
callq 0x2694
addq $0x10, %rsp
testl %eax, %eax
je 0x1325
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
movl 0x4(%rsp), %r8d
movl (%rsp), %r9d
callq 0x169d
movq %rax, %rbx
movq 0x20(%rsp), %rdi
callq 0x1060
movq 0x18(%rsp), %rdi
callq 0x1060
movq %rbx, %rdi
callq 0x27ee
movq %rax, %r14
movq %rbx, 0x10(%rsp)
cmpl $0x0, (%rbx)
jle 0x130f
xorl %r15d, %r15d
leaq 0x1d64(%rip), %r12      # 0x3004
movq %r14, %rdi
movl %r15d, %esi
movl $0x64, %edx
callq 0x20d4
movq %rax, %r13
movq %rax, %rdi
callq 0x25b1
testl %eax, %eax
jle 0x12fa
xorl %ebx, %ebx
movq %r13, %rdi
callq 0x25b4
movl (%rax,%rbx,4), %ebp
movq %r13, %rdi
callq 0x25b9
movsd (%rax,%rbx,8), %xmm0
movq %r12, %rdi
movl %r15d, %esi
movl %ebp, %edx
movb $0x1, %al
callq 0x1080
incq %rbx
movq %r13, %rdi
callq 0x25b1
cltq
cmpq %rax, %rbx
jl 0x12c1
movq %r13, %rdi
callq 0x258d
incl %r15d
movq 0x10(%rsp), %rax
cmpl (%rax), %r15d
jl 0x12a0
movq %r14, %rdi
callq 0x21b9
movq 0x10(%rsp), %rdi
callq 0x1374
xorl %eax, %eax
jmp 0x132a
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/pipde[P]deos-songlib/utils/fixpitch/fixpitch.c
// Function: advance
static void
advance(FILE *in,FILE *out,RRA *h)
    {
    int i;
    int start = SamplesWritten;
    int more = replace(in,out,h);
    int thresholdReached = 0;
    int peak = 0;

    //printf("advancing\n");
    while (more && !(thresholdReached && peek(0) == 0 && peek(1) > 0))
        {
        if (abs(peek(0)) > peak) peak = abs(peek(0));
        if (thresholdReached == 0 && peak > AbsoluteThreshold)
            thresholdReached = 1;
        //printf("while advancing, first amp is %d\n",peek(0));
        //printf("while advancing, second amp is %d\n",peek(1));
        //printf("while advancing, thresholdReached is %d\n",thresholdReached);
        more = replace(in,out,h);
        }

    //printf("after advance, first amp is %d\n",peek(0));
    //printf("after advance, second amp is %d\n",peek(1));
    //printf("more: %d\n",more);
    //printf("thresholdReached: %d\n",thresholdReached);

    if (!more)
        {
        //printf("dumping the window, stored = %d\n",SamplesStored);
        int count = SamplesStored;
        for (i = 0; i < count; ++i)
            replace(in,out,h);
        //printf("done dumping the window, stored = %d\n",SamplesStored);
        }

    if (Report)
        fprintf(ReportFP,"no repitching of cycle with length %d, peak was %d\n",
            SamplesWritten - start,peak);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl 0x628a(%rip), %eax      # 0x9964
movl %eax, -0x2c(%rbp)
callq 0x37b7
xorl %ebx, %ebx
testl %eax, %eax
je 0x3752
xorl %r13d, %r13d
movq 0x6266(%rip), %rsi      # 0x9958
movl 0x6280(%rip), %ecx      # 0x9978
movl 0x6249(%rip), %r8d      # 0x9948
movl %ecx, %eax
cltd
idivl %r8d
movslq %edx, %rdi
testb $0x1, %r13b
je 0x3725
cmpl $0x0, (%rsi,%rdi,4)
jne 0x3725
incl %ecx
movl %ecx, %eax
cltd
idivl %r8d
movslq %edx, %rax
cmpl $0x0, (%rsi,%rax,4)
jg 0x3771
movl (%rsi,%rdi,4), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl %ebx, %ecx
cmovgl %ecx, %ebx
cmpl 0x6212(%rip), %ebx      # 0x994c
setg %al
orb %al, %r13b
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x37b7
testl %eax, %eax
jne 0x36eb
movl 0x6217(%rip), %r13d     # 0x9970
testl %r13d, %r13d
jle 0x3771
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x37b7
decl %r13d
jne 0x375e
cmpb $0x1, 0x61ac(%rip)      # 0x9924
jne 0x37a8
movq 0x61a7(%rip), %rdi      # 0x9928
movl 0x61dd(%rip), %edx      # 0x9964
subl -0x2c(%rbp), %edx
leaq 0x2c97(%rip), %rsi      # 0x6428
movl %ebx, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2170
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pipde[P]deos-songlib/utils/fixpitch/fixpitch.c
// Function: replace
static int 
replace(FILE *in,FILE *out,RRA *h)
    {
    int amp;
    fprintf(out,"%d\n",Window[WindowStart]);
    ++SamplesWritten;
    WindowStart = (WindowStart + 1) % WindowSize;
    --SamplesStored;
    amp = readRRAAmplitude(in,out,h->bitsPerSample,outputComment);
    if (!feof(in))
        {
        ++SamplesRead;
        ++SamplesStored;
        Window[WindowEnd] = amp;
        WindowEnd = (WindowEnd + 1) % WindowSize;
        return 1;
        }
    else
        {
        return 0;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq 0x6186(%rip), %rax      # 0x9958
movslq 0x619f(%rip), %rcx      # 0x9978
movl (%rax,%rcx,4), %edx
leaq 0x33c2(%rip), %rsi      # 0x6ba5
xorl %ebx, %ebx
movq %r15, %rdi
xorl %eax, %eax
callq 0x2170
incl 0x616f(%rip)            # 0x9964
movl 0x617d(%rip), %eax      # 0x9978
incl %eax
cltd
idivl 0x6144(%rip)            # 0x9948
movl %edx, 0x616e(%rip)      # 0x9978
decl 0x6160(%rip)            # 0x9970
movl 0x8(%r12), %edx
leaq 0x14ef(%rip), %rcx      # 0x4d0b
movq %r14, %rdi
movq %r15, %rsi
callq 0x44a8
movl %eax, %r15d
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
jne 0x3869
incl 0x6124(%rip)            # 0x9960
incl 0x612e(%rip)            # 0x9970
movq 0x610f(%rip), %rax      # 0x9958
movslq 0x6124(%rip), %rcx      # 0x9974
movl %r15d, (%rax,%rcx,4)
leal 0x1(%rcx), %eax
cltd
idivl 0x60ea(%rip)            # 0x9948
movl %edx, 0x6110(%rip)      # 0x9974
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aap[P]rx-0/pdp1/mach.c
// Function: examinereg
Word
examinereg(int a)
{
	switch(a){
	case REG_PC: return pdp1.pc;
	case REG_AC: return pdp1.ac;
	case REG_IO: return pdp1.io;
	case REG_SS: return pdp1.ss;
	case REG_PF: return pdp1.pf;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x4, %edi
ja 0x41d9
movl %edi, %eax
leaq 0x20c4(%rip), %rcx      # 0x626c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0xa3d9(%rip), %eax      # 0xe590
jmp 0x41db
movl 0xe435(%rip), %eax      # 0x125f4
jmp 0x41db
movl 0xa3bd(%rip), %eax      # 0xe584
jmp 0x41db
movl 0xe421(%rip), %eax      # 0x125f0
jmp 0x41db
movl 0xa3a9(%rip), %eax      # 0xe580
jmp 0x41db
xorl %eax, %eax
popq %rbp
retq