// File: /workspace/github_c_makefile_star2_O3/luixmao[P]verilog/vlg_parser_man.cpp
// Function: VlgParser::parse(char*)
Design* VlgParser::parse(char *filename) {


  //take text into ifile
  ifstream ifile(filename);

  //initializers
  Design* ptr_des1; //needs to be inialized later    // = new Design(designName);
  int next_line_no=1;//line number 
  bool hasModule=false; //whether it has module
  bool hasEndmodule=false; //whether it has endmodule

  //check that the first thing is module
  while ( !ifile.eof() ){
    string line_of_text;
    //get a line of text
    getline(ifile, line_of_text);
    //increase to the next line
    next_line_no++;
    //clean up, erase comments and repeated spaces
    line_of_text= errase_comments_and_spaces(line_of_text);

    stringstream ss(line_of_text);
    string token;
    ss >>token;
          //check that first thing is module
          if(token!="module" && token!=" "  && !token.empty()){
	      cout << " error: line " << next_line_no-1 << ": need module   " <<endl;
	      return NULL;
          } 
          //if module, set name
          else if (token=="module"){
            hasModule=true;
            string designName;
            getline(ss , designName, '(' );
            designName= remove_side_spaces( designName);//might contain side spaces, so remove them
            if(! (isID(designName)) ){
		 cout << " error: line " << next_line_no-1 << ": not a valid name   " <<endl; 
                 return NULL;
            }
            ptr_des1= new Design(designName);

            //check inside the parentesis
               //check proper close parenthesis ')'
               string pos_parentesis;
               getline(ss , pos_parentesis );
               if(!has_proper_parentesis(pos_parentesis) ){
	  	  cout << " error: line " << next_line_no-1 << ": not proper parenthesis   " <<endl; 
                  delete ptr_des1;
                  return NULL;
               }

               //check for validity inside parentesis
               stringstream temp(pos_parentesis);
               string inside_parentesis; 
               getline(temp , inside_parentesis ,')'); 
               inside_parentesis=remove_side_spaces(inside_parentesis);
 
               if (inside_parentesis[inside_parentesis.length()-1] == ','){//error if last item is ',' 
                  cout << " error: line " << next_line_no-1 << ":  additional ','  " <<endl; 
                  delete ptr_des1;
                  return NULL;
               }
               //check parentesis are right
               stringstream temp2(inside_parentesis);
               string name_id;
               int count_elements=0;
               while( temp2.good() ){ //while there are inputs
                 count_elements++;
                 getline(temp2,name_id, ',');
                 name_id=remove_side_spaces(name_id);
                 //check valid id
                 if( !isID(name_id)){
	  	   cout << " error: line " << next_line_no-1 << ": not valid ID, or issue with ','    " <<endl;
                   delete ptr_des1; 
                   return NULL;
                 }
               }
               //if not enough elements display error
 	       if(count_elements<2){
	  	   cout << " error: line " << next_line_no-1 << ": needs at least one input and one output ','   " <<endl; 
                   delete ptr_des1;
                   return NULL;
               }
            //end check inside parentesis
            break;
          }
  }
  //if didn't find module, error
  if(!hasModule){
     cout << " error: missing module declaration" <<endl;
     return NULL;
  }

     // cout << " error: line " << next_line_no-1 << ": not a valid name   " <<endl;


  //run while until there is no more text
  while ( !ifile.eof() ){
    string line_of_text;
    //get a line of text
    getline(ifile, line_of_text);
    //increase to the next line
    next_line_no++;
    //clean up, erase comments and repeated spaces
    line_of_text= errase_comments_and_spaces(line_of_text);

    stringstream ss(line_of_text);
    string token;
    ss >>token;
    if(ss.fail() || (token.length()==1 && token[0]==' ')){ //if no text in this line
      continue;
    }
    else{
       //if it has semicolon
       if(!has_proper_Semicolon(remove_spaces(line_of_text)) && token!="endmodule"){//has one ';' and it is last item 
          cout << " error: line " << next_line_no-1 << ":  improper ';'  " <<endl;
          delete ptr_des1;
          return NULL;
       }
       else{
          if( token=="endmodule" ){
             hasEndmodule=true;
             //check if there is anything after endmodule
             while ( !ifile.eof() ){
      	        getline(ifile, line_of_text);
  	        //increase to the next line
  	        next_line_no++;
  	        //clean up, erase comments and repeated spaces
  	        line_of_text= errase_comments_and_spaces(line_of_text);
   	        for(unsigned int i=0 ; i!=line_of_text.length();i++){
    	           if(line_of_text!=" "){
    	              cout << " error: line " << next_line_no-1 << ": nothing allowed after endmodule   " <<endl;
                      delete ptr_des1;
     	              return NULL;
     	           }
   	        }

             }
          }     
          //add input if it is possible ID
          else if( token=="input" ){
            string input_name;
 	    getline(ss , input_name, ';' );
            input_name= remove_side_spaces( input_name);//might contain spaces on sides, so remove them
            if(! (isID(input_name)) ){
		 cout << " error: line " << next_line_no-1 << ": not a valid name   " <<endl; 
                 delete ptr_des1;
                 return NULL;
            }
   	    ptr_des1->addPI(input_name); //add new input
          }     
          //add output if it is possible ID
          else if( token=="output" ){
            string output_name;
 	    getline(ss , output_name, ';' );
            output_name= remove_side_spaces( output_name);//might contain spaces on sides, so remove them
            if(! (isID(output_name)) ){
		 cout << " error: line " << next_line_no-1 << ": not a valid name   " <<endl; 
                 delete ptr_des1;
                 return NULL;
            }
   	    ptr_des1->addPO(output_name); //add new input
          }     

          //add wire if it is possible ID
          else if( token=="wire" ){
            string wire_name;
 	    getline(ss , wire_name, ';' );
            wire_name= remove_side_spaces( wire_name); //might contain spaces on sides, so remove them
            if(! (isID(wire_name)) ){
		 cout << " error: line " << next_line_no-1 << ": not a valid name   " <<endl; 
                 delete ptr_des1;
                 return NULL;
            }
   	    ptr_des1->addFindNet(wire_name); //add new input
          }     
          else if(token == "and" || token == "or" || token == "nand"|| token == "nor"|| token == "xor"|| token == "not"){
             int gate_type =  find_gate_type(token);
	     string pre_parentesis; //rest of the line after "and" declaration
             getline(ss , pre_parentesis, '(' );
             vector<string>* ptr_vec =return_words(pre_parentesis);
 	     int num_elements=ptr_vec->size();
             if(num_elements >2){
                 cout << " error: line " << next_line_no-1 << ": too many entries before '('   " <<endl; 
                 delete ptr_vec;
                 delete ptr_des1;
                 return NULL;
             }
             else if(num_elements ==1 || num_elements ==2){
               string gate_name;//gate name
               if(num_elements ==1 ){
                 gate_name =(*ptr_vec)[0];
                 if(! (isID(gate_name)) ){
  	  	    cout << " error: line " << next_line_no-1 << ": not a valid gate name   " <<endl; 
                    delete ptr_vec;
                    delete ptr_des1;
                    return NULL;
                 }
                 ptr_des1->addFindGate(gate_type, gate_name);
               }
               else{ //if(num_elements ==2)
                 //check proper name
                 gate_name =(*ptr_vec)[1];
                 if(! (isID(gate_name)) ){
	    	    cout << " error: line " << next_line_no-1 << ": not a valid gate name   " <<endl; 
                    delete ptr_vec;
                    delete ptr_des1;
                    return NULL;
                 }
                  
                 //check proper delay
                 string delay_str =(*ptr_vec)[0];// delay with
                 if(! (isDelay(delay_str)) ){
	  	    cout << " error: line " << next_line_no-1 << ": not a valid delay   " <<endl; 
                    delete ptr_vec;
                    delete ptr_des1;
                    return NULL;
                 }
                 delay_str.erase(delay_str.begin());
                 int delay = atoi( delay_str.c_str() );
                 ptr_des1->addFindGate(gate_type, gate_name)->setDelay(delay);
               }



               //check proper close parenthesis ')'

               string pos_parentesis;
               getline(ss , pos_parentesis );
               if(!has_proper_parentesis(pos_parentesis) ){
	  	  cout << " error: line " << next_line_no-1 << ": not proper parenthesis   " <<endl; 
                  delete ptr_vec;
                  delete ptr_des1;
                  return NULL;
               }

               //check for validity inside parentesis
               stringstream temp(pos_parentesis);
               string inside_parentesis; 
               getline(temp , inside_parentesis ,')'); 
               inside_parentesis=remove_side_spaces(inside_parentesis);
 
               if (inside_parentesis[inside_parentesis.length()-1] == ','){//error if last item is ',' 
                  cout << " error: line " << next_line_no-1 << ": not additional ','  " <<endl; 
                  delete ptr_vec;
                  delete ptr_des1;
                  return NULL;
               }
               
               stringstream temp2(inside_parentesis);
               string name_id;
               bool isOutput = true;
               int count_elements=0;
           
               while( temp2.good() ){ //while there are inputs, get the names and make new nets if valid name
                 count_elements++;
                 getline(temp2,name_id, ',');
                 name_id=remove_side_spaces(name_id);
                 //check valid id
                 if( !isID(name_id)){
	  	   cout << " error: line " << next_line_no-1 << ": not valid ID or missing ','   " <<endl;
                   delete ptr_vec;
                   delete ptr_des1; 
                   return NULL;
                 }
                 if(isOutput){ //first item is output
                   //add output
                   ptr_des1->addFindGate(gate_type, gate_name)->addOutput(ptr_des1->addFindNet(name_id));
		   isOutput=false;//to not enter again
                 }
                 else{
                   //add inputs
                   ptr_des1->addFindGate(gate_type, gate_name)->addInput(ptr_des1->addFindNet(name_id));
                 }
               }
               //error if elements is not enough
 	       if(count_elements<2){
	  	   cout << " error: line " << next_line_no-1 << ": needs at least one input and one output    " <<endl;
                   delete ptr_vec; 
                   delete ptr_des1;
                   return NULL;
               }

             }
             else{  
                  cout << " error: line " << next_line_no-1 << ": expected gate name   " <<endl; 
                  delete ptr_vec;
                  delete ptr_des1;
                  return NULL;
             }
           
             delete ptr_vec;
          }

          else{ //if it is not one of the expected declarations
    	     cout << " error: line " << next_line_no-1 << ": not a valid declaration   " <<endl;
             delete ptr_des1;
     	     return NULL;
          }
         
      }
    }

  }


  //if didn't find module, error
  if(!hasEndmodule){
     cout << " error: missing endmodule " <<endl;
     delete ptr_des1;
     return NULL;
  }


 
  ifile.close();
  return ptr_des1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4c8, %rsp            # imm = 0x4C8
leaq -0x4e8(%rbp), %rdi
movl $0x8, %edx
callq 0x22d0
movl $0x1, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
leaq -0x138(%rbp), %r13
leaq -0xb8(%rbp), %r14
leaq -0x118(%rbp), %rbx
movq -0x4e8(%rbp), %rax
movq -0x18(%rax), %rcx
testb $0x2, -0x4c8(%rbp,%rcx)
jne 0x5fe9
leaq -0x88(%rbp), %rcx
movq %rcx, -0x98(%rbp)
movq $0x0, -0x90(%rbp)
movb $0x0, -0x88(%rbp)
movq -0x18(%rax), %rdi
leaq -0x4e8(%rbp), %r15
addq %r15, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %edx
movq %r15, %rdi
leaq -0x98(%rbp), %rsi
callq 0x22e0
leaq -0x128(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
addq %rsi, %rdx
movq %r13, %r15
movq %r13, %rdi
callq 0x28b4
leaq -0x2e0(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6234
leaq -0x98(%rbp), %rdi
movq %r12, %rsi
callq 0x21f0
movq -0x2e0(%rbp), %rdi
leaq -0x2d0(%rbp), %rax
cmpq %rax, %rdi
je 0x5b34
movq -0x2d0(%rbp), %rsi
incq %rsi
callq 0x2190
movq -0x138(%rbp), %rdi
leaq -0x128(%rbp), %rax
cmpq %rax, %rdi
je 0x5b56
movq -0x128(%rbp), %rsi
incq %rsi
callq 0x2190
leaq -0x2e0(%rbp), %r15
movq %r15, %rdi
leaq -0x98(%rbp), %rsi
movl $0x18, %edx
callq 0x2250
leaq -0xa8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq $0x0, -0xb0(%rbp)
movb $0x0, -0xa8(%rbp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2200
movq %r14, %r15
movq %r14, %rdi
leaq 0x15c2(%rip), %rsi      # 0x716b
callq 0x2080
testl %eax, %eax
je 0x5c3d
movq %r15, %rdi
leaq 0x15e5(%rip), %rsi      # 0x71a5
callq 0x2080
testl %eax, %eax
je 0x5c3d
cmpq $0x0, -0xb0(%rbp)
je 0x5c3d
movl $0xd, %edx
movq 0x53f1(%rip), %rdi      # 0xafd0
leaq 0x15a2(%rip), %rsi      # 0x7188
callq 0x21d0
movq 0x53de(%rip), %rdi      # 0xafd0
movl -0x2c(%rbp), %esi
callq 0x2290
movq %rax, %r15
movl $0x10, %edx
movq %rax, %rdi
leaq 0x158a(%rip), %rsi      # 0x7196
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
jmp 0x5f72
movq %r15, %rdi
leaq 0x1524(%rip), %rsi      # 0x716b
callq 0x2080
movb $0x1, %r15b
testl %eax, %eax
jne 0x5f75
leaq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movb $0x0, -0x48(%rbp)
leaq -0x2e0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movl $0x28, %edx
callq 0x22e0
leaq -0x108(%rbp), %rax
movq %rax, -0x118(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
addq %rsi, %rdx
movq %rbx, %r15
movq %rbx, %rdi
callq 0x28b4
leaq -0x78(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6348
leaq -0x58(%rbp), %rdi
movq %r12, %rsi
callq 0x21f0
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x5cd8
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x2190
movq -0x118(%rbp), %rdi
leaq -0x108(%rbp), %rax
cmpq %rax, %rdi
je 0x5cfa
movq -0x108(%rbp), %rsi
incq %rsi
callq 0x2190
leaq -0x148(%rbp), %rax
movq %rax, -0x158(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
addq %rsi, %rdx
leaq -0x158(%rbp), %rdi
callq 0x28b4
leaq -0x158(%rbp), %rdi
callq 0x63de
movl %eax, %r15d
movq -0x158(%rbp), %rdi
leaq -0x148(%rbp), %rax
cmpq %rax, %rdi
je 0x5d50
movq -0x148(%rbp), %rsi
incq %rsi
callq 0x2190
testb %r15b, %r15b
je 0x5eef
movl $0xd8, %edi
callq 0x2180
movq %rax, -0x38(%rbp)
leaq -0xe8(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
addq %rsi, %rdx
leaq -0xf8(%rbp), %r15
movq %r15, %rdi
callq 0x28b4
movq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x3d7e
movq -0xf8(%rbp), %rdi
leaq -0xe8(%rbp), %rax
cmpq %rax, %rdi
je 0x5dbd
movq -0xe8(%rbp), %rsi
incq %rsi
callq 0x2190
leaq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
movq $0x0, -0x70(%rbp)
movb $0x0, -0x68(%rbp)
movq -0x2e0(%rbp), %rax
movq -0x18(%rax), %rdi
leaq -0x2e0(%rbp), %rax
addq %rax, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %edx
leaq -0x2e0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x22e0
leaq -0xc8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
addq %rsi, %rdx
leaq -0xd8(%rbp), %rdi
callq 0x28b4
leaq -0xd8(%rbp), %rdi
callq 0x6451
movq -0xd8(%rbp), %rdi
leaq -0xc8(%rbp), %rax
cmpq %rax, %rdi
je 0x5e56
movq -0xc8(%rbp), %rsi
incq %rsi
callq 0x2190
movl $0xd, %edx
movq 0x516e(%rip), %rdi      # 0xafd0
leaq 0x131f(%rip), %rsi      # 0x7188
callq 0x21d0
movq 0x515b(%rip), %rdi      # 0xafd0
movl -0x2c(%rbp), %esi
callq 0x2290
movq %rax, %r15
movl $0x1b, %edx
movq %rax, %rdi
leaq 0x132e(%rip), %rsi      # 0x71bd
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x3ef4
movl $0xd8, %esi
movq %r15, %rdi
callq 0x2190
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x5f54
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x2190
jmp 0x5f54
movl $0xd, %edx
movq 0x50d5(%rip), %rdi      # 0xafd0
leaq 0x1286(%rip), %rsi      # 0x7188
callq 0x21d0
movq 0x50c2(%rip), %rdi      # 0xafd0
movl -0x2c(%rbp), %esi
callq 0x2290
movq %rax, %r15
movl $0x15, %edx
movq %rax, %rdi
leaq 0x127f(%rip), %rsi      # 0x71a7
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x5f6d
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2190
movb $0x1, %al
movl %eax, -0x30(%rbp)
xorl %r15d, %r15d
movq -0xb8(%rbp), %rdi
leaq -0xa8(%rbp), %rax
cmpq %rax, %rdi
je 0x5f97
movq -0xa8(%rbp), %rsi
incq %rsi
callq 0x2190
leaq -0x2e0(%rbp), %rdi
movq 0x500b(%rip), %rsi      # 0xafb0
callq 0x2110
leaq -0x260(%rbp), %rdi
callq 0x2090
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x5fd8
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x2190
incl -0x2c(%rbp)
testb %r15b, %r15b
jne 0x5a64
jmp 0x609b
testb $0x1, -0x30(%rbp)
je 0x6055
movq 0x4fda(%rip), %rbx      # 0xafd0
leaq 0x1210(%rip), %rsi      # 0x720d
movl $0x1a, %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 0x4fa8(%rip), %rdi      # 0xafd0
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq -0x38(%rbp), %rbx
testq %rbx, %rbx
je 0x6046
movq %rbx, %rdi
callq 0x3ef4
movl $0xd8, %esi
movq %rbx, %rdi
callq 0x2190
jmp 0x609b
movq 0x4f74(%rip), %rbx      # 0xafd0
leaq 0x1176(%rip), %rsi      # 0x71d9
movl $0x22, %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 0x4f42(%rip), %rdi      # 0xafd0
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq -0x4e8(%rbp), %rdi
callq 0x2060
xorl %eax, %eax
addq $0x4c8, %rsp            # imm = 0x4C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0xd8(%rbp), %rdi
leaq -0xc8(%rbp), %rax
cmpq %rax, %rdi
je 0x617c
movq -0xc8(%rbp), %rsi
incq %rsi
callq 0x2190
jmp 0x617c
movq %rax, %rbx
movq -0xf8(%rbp), %rdi
leaq -0xe8(%rbp), %rax
cmpq %rax, %rdi
je 0x6113
movq -0xe8(%rbp), %rsi
incq %rsi
callq 0x2190
jmp 0x6113
movq %rax, %rbx
movl $0xd8, %esi
movq -0x38(%rbp), %rdi
jmp 0x6190
movq %rax, %rbx
jmp 0x6220
jmp 0x6197
movq %rax, %rbx
movq -0x118(%rbp), %rdi
leaq -0x108(%rbp), %rax
cmpq %rax, %rdi
je 0x619a
movq -0x108(%rbp), %rsi
jmp 0x618d
jmp 0x61b5
movq %rax, %rbx
movq -0x138(%rbp), %rdi
leaq -0x128(%rbp), %rax
cmpq %rax, %rdi
je 0x61fe
movq -0x128(%rbp), %rsi
incq %rsi
callq 0x2190
jmp 0x61fe
jmp 0x61b5
movq %rax, %rbx
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x619a
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x2190
jmp 0x619a
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x61bd
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2190
jmp 0x61bd
movq %rax, %rbx
jmp 0x61fe
movq %rax, %rbx
movq -0xb8(%rbp), %rdi
leaq -0xa8(%rbp), %rax
cmpq %rax, %rdi
je 0x61df
movq -0xa8(%rbp), %rsi
incq %rsi
callq 0x2190
movq 0x4dca(%rip), %rsi      # 0xafb0
leaq -0x2e0(%rbp), %rdi
callq 0x2110
leaq -0x260(%rbp), %rdi
callq 0x2090
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x6220
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x2190
leaq -0x4e8(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x22b0