function f;                                                   
begin                                                         
                                                              
end                                                           
endfunction : f                                               
task t;                                                       
                                                              
begin                                                         
    state = something();                                      
    begin : block1                                            
        state = 2'b00;                                        
        if (a <= b) begin                                     
            begin : block2                                    
            end 
            state = 2'b11;                                    
            begin                                             
            end                                               
        end                                                   
        begin : block3                                        
        end 
        begin                                                 
        end                                                   
    end 
end                                                           
                                                              
endtask : t                                                   
                                                            
extern                        function    e_func (x, y);      
extern              static    function   es_func (x, y);      
extern              protected function   ep_func (x, y);      
extern              local     function   el_func (x, y);      
       pure virtual           function   pv_func (x);         
       pure virtual static    function  pvs_func (x);         
       pure virtual protected function  pvp_func (x);         
       pure virtual local     function  pvl_func (x);         
extern      virtual           function   ev_func (x);         
extern      virtual static    function  evs_func (x);         
extern      virtual protected function  evp_func (x);         
extern      virtual local     function  evl_func (x);         
extern pure virtual           function  epv_func (x);         
extern pure virtual static    function epvs_func (x);         
extern pure virtual protected function epvp_func (x);         
extern pure virtual local     function epvl_func (x);         
extern                        task        e_task (x, y);      
extern              static    task       es_task (x, y);      
extern              protected task       ep_task (x, y);      
extern              local     task       el_task (x, y);      
       pure virtual           task       pv_task (x);         
       pure virtual static    task      pvs_task (x);         
       pure virtual protected task      pvp_task (x);         
       pure virtual local     task      pvl_task (x);         
extern      virtual           task       ev_task (x, y);      
extern      virtual static    task      evs_task (x, y);      
extern      virtual protected task      evp_task (x, y);      
extern      virtual local     task      evl_task (x, y);      
extern pure virtual           task      epv_task (x, y);      
extern pure virtual static    task     epvs_task (x, y);      
extern pure virtual protected task     epvp_task (x, y);      
extern pure virtual local     task     epvl_task (x, y);      
                                                            
static function f1;                                           
endfunction                                                   
specify                                                       
                                                              
endspecify                                                    
covergroup cov;                                               
                                                              
endgroup                                                      
property prop;                                                
endproperty                                                   
sequence                                                      
endsequence                                                   
class class_a;                                                
                                                              
endclass : class_a                                            
class class_b;                                                
  class class_b1;                                             
                                                              
  endclass : class_b1                                         
                                                              
  class class_b2;                                             
                                                              
  endclass : class_b2                                         
endclass : class_b                                            
interface a;                                                  
                                                              
  interface class b;                                          
  endclass : b                                                
                                                              
  clocking cb @ (posedge Clk);                                
  endclocking : cb                                            
                                                              
endinterface : a                                              
typedef interface class my_itf_class;                         
`ifdef A                                                      
reg test;                                                     
                                                              
                                                              
`else                                                         
                                                              
`endif                                                        
`ifndef B                                                     
                                                              
`elsif C                                                      
                                                              
`elsif D                                                      
                                                              
`else                                                         
                                                              
`endif                                                        
`ifdef E                                                      
                                                              
  `ifndef E_1                                                 
                                                              
  `else                                                       
                                                              
  `endif                                                      
                                                              
  `ifndef E_2                                                 
                                                              
  `elsif E_3                                                  
                                                              
  `endif                                                      
                                                              
`endif                                                        
`ifdef A                                                      
                                                              
  `ifdef B                                                    
                                                              
  `else                                                       
                                                              
  `endif                                                      
                                                              
`elsif C                                                      
                                                              
`else                                                         
                                                              
`endif                                                        
                                                            
   module_name #(                                             
       .PARAM1 (VALUE1)                                       
   )                                                          
   instance_name(                                             
       .port1 (net1),                                         
       .port2 (net2)                                          
   );                                                         
module_name instance_name(                                    
    .port1 (net1),                                            
    .port2 (net2)                                             
);                                                            
module_name #(VALUE1) instance_name (                         
    .port1 (net1),                                            
    .port2 (net2)                                             
);                                                            
module_name #(VALUE1) instance_name                           
(                                                             
    .port1 (net1),                                            
    .port2 (net2)                                             
);                                                            
uvm_blocking_put_port #(trans) out;                           
task t_multi_line(                                            
  input an_input                                              
);                                                            
                                                              
endtask : t_multi_line                                        
  task t_multi_line_indented(                                 
    input an_input                                            
  );                                                          
                                                              
  endtask : t_multi_line                                      
if (cond1) begin                                              
    do1();                                                    
end else if (cond2) begin                                     
    do2();                                                    
    do3();                                                    
    do4();                                                    
end else begin                                                
    do5();                                                    
end                                                           
if (cond1)                                                    
    do1();                                                    
else if (cond2) begin                                         
    do2();                                                    
    begin                                                     
    do2_1();                                                  
    end                                                       
    do3();                                                    
    do4();                                                    
end else begin                                                
    do5();                                                    
end                                                           
if (cond1) begin : b1                                         
    do1();                                                    
end else if (cond2) begin : b2                                
    do2();                                                    
    do3();                                                    
    do4();                                                    
end else begin : b3                                           
    do5();                                                    
end                                                           
if (cond1)                                                    
    do1();                                                    
else if (cond2) begin : b1                                    
    do2();                                                    
    begin:b2                                                  
    do2_1();                                                  
    end                                                       
    do3();                                                    
    do4();                                                    
end else begin                                                
    do5();                                                    
end else begin:b3                                             
    do5();                                                    
end                                                           
task something;                                               
fork                                                          
    begin                                                     
        begin                                                 
        end                                                   
        
                                                    
    end                                                       
join                                                          
endtask                                                       
assign a = b & c;