uvm_void
virtual class uvm_void;
uvm_object
virtual class uvm_object extends uvm_void;
    static bit use_uvm_seeding = 1;

    function new (string name = "");
    function void reseed ();

    /* Identification */
    virtual function void               set_name         (string name);
    virtual function string             get_name         ();
    virtual function string             get_full_name    ();
    virtual function int                get_inst_id      ();
    static  function int                get_inst_count   ();
    static  function uvm_object_wrapper get_type         ();
    virtual function uvm_object_wrapper get_object_type  ();
    virtual function string             get_type_name    ();

    /* Creation */
    virtual function uvm_object         create           (string name = "");
    virtual function uvm_object         clone            ();

    /* Printing */
            function void               print            (uvm_printer printer=null);
            function string             sprint           (uvm_printer printer=null); 
    virtual function void               do_print         (uvm_printer printer);
    virtual function string             convert2string   ();
    
    /* Recording */
            function void               record           (uvm_recorder recorder=null);
    virtual function void               do_record        (uvm_recorder recorder);
    
    /* Copying */
            function void               copy             (uvm_object rhs);
    virtual function void               do_copy          (uvm_object rhs);
    
    /* Comparing */
            function bit                compare          (uvm_object rhs, uvm_comparer comparer=null);
    virtual function bit                do_compare       (uvm_object  rhs, uvm_comparer comparer);
    
    /* Packing */
            function int                pack             (ref bit bitstream[], input uvm_packer packer=null);
            function int                pack_bytes       (ref byte unsigned bytestream[], input uvm_packer packer=null);
            function int                pack_ints        (ref int unsigned intstream[], input uvm_packer packer =null);
    virtual function void               do_pack          (uvm_packer packer);
    
    /* Unpacking */
            function int                unpack           (ref bit bitstream[], input uvm_packer packer=null);
            function int                unpack_bytes     (ref byte unsigned bytestream[], input uvm_packer packer=null);
            function int                unpack_ints      (ref int unsigned intstream[], input uvm_packer packer=null);
    virtual function void               do_unpack        (uvm_packer packer);
    
    /* Configuration */
    virtual function void               set_int_local    (string field_name, input uvm_packer packer=null);
    virtual function void               set_string_local (string field_name, input uvm_packer packer=null);
    virtual function void               set_object_local (string field_name, input uvm_packer packer=null);

endclass
uvm_component

virtual class uvm_component extends uvm_report_object;
	function new (string name, uvm_component parent);
	
	// Hierarchy Interface
    virtual function uvm_component  get_parent          ();
    virtual function string         get_full_name       ();
            function void           get_children        (ref uvm_component children [$]);
            function uvm_component  get_child           (string name);
            function int            get_next_child      (ref string name);
            function int            get_first_child     (ref string name);
            function int            get_num_children    ();
            function int            has_child           (string name);
            function uvm_component  lookup              (string name);
            function int unsigned   get_depth           ();
			
    // Phasing Interface
    virtual function void           build_phase                 (uvm_phase phase);
    virtual function void           connect_phase               (uvm_phase phase);
    virtual function void           end_of_elaboration_phase    (uvm_phase phase);
    virtual function void           start_of_simulation_phase   (uvm_phase phase);
    virtual task                    run_phase                   (uvm_phase phase);
    virtual task                    pre_reset_phase             (uvm_phase phase);
    virtual task                    reset_phase                 (uvm_phase phase);
    virtual task                    post_reset_phase            (uvm_phase phase);
    virtual task                    pre_configure_phase         (uvm_phase phase);
    virtual task                    configure_phase             (uvm_phase phase);
    virtual task                    post_configure_phase        (uvm_phase phase);
    virtual task                    pre_main_phase              (uvm_phase phase);
    virtual task                    main_phase                  (uvm_phase phase);
    virtual task                    post_main_phase             (uvm_phase phase);
    virtual task                    pre_shutdown_phase          (uvm_phase phase);
    virtual task                    shutdown_phase              (uvm_phase phase);
    virtual task                    post_shutdown_phase         (uvm_phase phase);
    virtual function void           extract_phase               (uvm_phase phase);
    virtual function void           check_phase                 (uvm_phase phase);
    virtual function void           report_phase                (uvm_phase phase);
    virtual function void           final_phase                 (uvm_phase phase);
    virtual function void           phase_started               (uvm_phase phase);
    virtual function void           phase_ready_to_end          (uvm_phase phase);
    virtual function void           phase_ended                 (uvm_phase phase);
            function void           set_domain                  (uvm_domain domain, int hier=1);
            function uvm_domain     get_domain                  ();
    virtual protected function void define_domain               (uvm_domain domain);
            function void           set_phase_imp               (uvm_phase phase, uvm_phase imp, int hier=1);
    virtual task                    suspend                     ();
    virtual task                    resume                      ();
            function string         status                      ();
    virtual function void           kill                        ();
    virtual function void           do_kill_all                 ();
    virtual task                    stop_phase                  (uvm_phase phase);
    virtual task                    stop                        (string ph_name);
    virtual function void           resolve_bindings            ();
    
    // Configuration Interface
            function string         massage_scope                    (string scope);
    virtual function void           set_config_int                   (string inst_name,  
    virtual function void           set_config_string                (string inst_name,  
    virtual function void           set_config_object                (string inst_name,  
    virtual function bit            get_config_int                   (string field_name,
    virtual function bit            get_config_string                (string field_name,
    virtual function bit            get_config_object                (string field_name,
            function void           check_config_usage               (bit recurse=1);
    virtual function void           apply_config_settings            (bit verbose=0);
            function void           print_config_settings            (string field="", 
            function void           print_config                     (bit recurse = 0, bit audit = 0);
            function void           print_config_with_audit          (bit recurse = 0);
            function uvm_component  create_component                 (string requested_type_name, 
            function uvm_object     create_object                    (string requested_type_name,
    static  function void           set_type_override_by_type
            function void           set_inst_override_by_type        (string relative_inst_path,  
    static  function void           set_type_override                (string original_type_name, 
            function void           set_inst_override                (string relative_inst_path,  
            function void           print_override_info              (string requested_type_name,
            function void           set_report_id_verbosity_hier     (string id,
            function void           set_report_severity_id_verbosity_hier(uvm_severity severity,
            function void           set_report_severity_action_hier  (uvm_severity severity,
            function void           set_report_id_action_hier        (string id,
            function void           set_report_severity_id_action_hier(uvm_severity severity,
            function void           set_report_default_file_hier     (UVM_FILE file);
            function void           set_report_severity_file_hier    (uvm_severity severity,
            function void           set_report_id_file_hier          (string id,
            function void           set_report_severity_id_file_hier (uvm_severity severity,
            function void           set_report_verbosity_level_hier  (int verbosity);
            function void           accept_tr                        (uvm_transaction tr, time accept_time=0);
    virtual protected function void  do_accept_tr                     (uvm_transaction tr);
            function integer        begin_tr                         (uvm_transaction tr,
            function integer        begin_child_tr                   (uvm_transaction tr,
    virtual protected function void  end_tr                           (uvm_transaction tr,
    virtual protected function void  do_end_tr                        (uvm_transaction tr,
            function integer        record_error_tr                  (string stream_name="main",
            function integer        record_event_tr                  (string stream_name="main",
            function void           set_int_local                    (string field_name, 
    virtual protected function bit   m_add_child                      (uvm_component child);
    virtual local function void      m_set_full_name                  ();
            function void           do_resolve_bindings              ();
            function void           do_flush                         ();
    virtual function void           flush                            ();
            local function void     m_extract_name                   (string name ,
    virtual function uvm_object     create                           (string name=""); 
    virtual function uvm_object     clone                            ();
    protected function integer       m_begin_tr                       (uvm_transaction tr,
             function void           do_print                         (uvm_printer printer);
             function void           m_set_cl_msg_args;
             function void           m_set_cl_verb;
             function void           m_set_cl_action;
             function void           m_set_cl_sev;
             function void           m_apply_verbosity_settings(uvm_phase phase);
    /*local*/ function void          m_do_pre_abort;
endclass
uvm_test

virtual class uvm_test extends uvm_component;
	function new (string name, uvm_component parent);
endclass
uvm_agent

virtual class uvm_agent extends uvm_component;
	         function                            new                 (string name, uvm_component parent);
	virtual  function uvm_passive_active_enum    get_is_active       ();
endclass
uvm_sequencer

class uvm_sequencer #(type REQ = uvm_sequence_item, RSP = REQ) extends uvm_sequencer_param_base #(REQ, RSP);
	         function      new                  (string name, uvm_component parent = null);
	 virtual function void stop_sequences       ();
	 
	 /* Sequencer TLM Interface */
	 uvm_seq_item_pull_imp   #( REQ, RSP, this_type) seq_item_export;
	 
	 virtual task          get_next_item        (output REQ t);
	 virtual task          try_next_item        (output REQ t);
	 virtual function void item_done            (RSP item = null);
	 virtual task          put                  (RSP t);
	         task          get                  (output REQ t);
	         task          peek                 (output REQ t);
	         task          wait_for_sequences   ();
	 virtual function bit  has_do_available     ();
endclass
uvm_driver

class uvm_driver  #(type REQ = uvm_sequence_item, type RSP = REQ) extends uvm_component;

	function new (string name, uvm_component parent);
	
	/* Driver TLM interface */
	uvm_seq_item_pull_port  #(REQ, RSP)    seq_item_port;
	uvm_analysis_port       #(RSP)         rsp_port;
	
	virtual function string get_type_name ();
	
endclass
uvm_monitor

virtual class uvm_monitor extends uvm_component;
    function new (string name, uvm_component parent);
endclass
uvm_phase

class uvm_phase extends uvm_object;
		     function                      new (string name="uvm_phase", 
	         function uvm_phase_type       get_phase_type();
	         function uvm_phase_state      get_state();
	         function int                  get_run_count();
	         function uvm_phase            find_by_name(string name, bit stay_in_scope=1);
	         function uvm_phase            find(uvm_phase phase, bit stay_in_scope=1);
	         function bit                  is(uvm_phase phase);
	         function bit                  is_before(uvm_phase phase);
	         function bit                  is_after(uvm_phase phase);
	         function void                 add(uvm_phase phase,
	         function uvm_phase            get_parent();
	virtual  function string               get_full_name();
	         function uvm_phase            get_schedule(bit hier=0);
	         function string               get_schedule_name(bit hier=0);
	         function uvm_domain           get_domain();
	         function uvm_phase            get_imp();
	         function string               get_domain_name();
	virtual  function void                 raise_objection (uvm_object obj, 
	virtual  function void                 drop_objection (uvm_object obj, 
	         function void                 sync(uvm_domain target,
	         function void                 unsync(uvm_domain target,
	         task                          wait_for_state(uvm_phase_state state, uvm_wait_op op=UVM_EQ);
	         function void                 jump(uvm_phase phase);
	static   function void                 jump_all(uvm_phase phase);
	         function uvm_phase            get_jump_target();
	         function uvm_phase            m_find_predecessor(uvm_phase phase, bit stay_in_scope=1, uvm_phase orig_phase=null);
	         function uvm_phase            m_find_successor(uvm_phase phase, bit stay_in_scope=1, uvm_phase orig_phase=null);
	         function uvm_phase            m_find_predecessor_by_name(string name, bit stay_in_scope=1, uvm_phase orig_phase=null);
	         function uvm_phase            m_find_successor_by_name(string name, bit stay_in_scope=1, uvm_phase orig_phase=null);
	         function void                 m_print_successors();
	local    function void                 get_predecessors_for_successors(output bit pred_of_succ[uvm_phase]);
	local    task                          m_wait_for_pred();
	         function void                 clear(uvm_phase_state state = UVM_PHASE_DORMANT);
	         function void                 clear_successors(
	static   task                          m_run_phases();
	local    task                          execute_phase();
	local    function void                 m_terminate_phase();
	local    function void                 m_print_termination_state();
	local    task                          wait_for_self_and_siblings_to_drop();
	         function void                 kill();
	         function void                 kill_successors();
endclass
uvm_sequencer_base

class uvm_sequencer_base extends uvm_component;
            function                        new (string name, uvm_component parent);
            function bit                    is_child (uvm_sequence_base parent, uvm_sequence_base child);
    virtual function integer                user_priority_arbitration (integer avail_sequences [$]);
    virtual task                            execute_item (uvm_sequence_item item);
    virtual function void                   start_phase_sequence (uvm_phase phase);
    virtual function void                   stop_phase_sequence (uvm_phase phase);
    virtual task                            wait_for_grant (uvm_sequence_base sequence_ptr,
                                                            int               item_priority = -1,
                                                            bit               lock_request = 0);
                                                            
    virtual task                            wait_for_item_done (uvm_sequence_base sequence_ptr,
                                                                int               transaction_id);
                                                                
            function bit                    is_blocked (uvm_sequence_base sequence_ptr);
            function bit                    has_lock (uvm_sequence_base sequence_ptr);
    virtual task                            lock (uvm_sequence_base sequence_ptr);
    virtual task                            grab (uvm_sequence_base sequence_ptr);
    virtual function void                   unlock (uvm_sequence_base sequence_ptr);
    virtual function void                   ungrab (uvm_sequence_base sequence_ptr);
    virtual function void                   stop_sequences ();
    virtual function uvm_sequence_base      current_grabber ();
    virtual function bit                    has_do_available ();
            function void                   set_arbitration (UVM_SEQ_ARB_TYPE val);
            function UVM_SEQ_ARB_TYPE       get_arbitration ();
    virtual task                            wait_for_sequences ();
    virtual function void                   send_request (uvm_sequence_base sequence_ptr,
                                                          uvm_sequence_item t,
                                                          bit               rerandomize = 0);
                                                          
    virtual function void                   set_max_zero_time_wait_relevant_count (int new_val);
endclass
uvm_sequencer

class uvm_sequencer #(type REQ = uvm_sequence_item, RSP = REQ) extends uvm_sequencer_param_base #(REQ, RSP);
            function                        new (string name, uvm_component parent = null);
    virtual function void                   stop_sequences ();
    virtual task                            get_next_item ( output REQ t );
    virtual task                            try_next_item (output REQ t);
    virtual function void                   item_done (RSP item = null);
    virtual task                            put (RSP t);
            task                            get (output REQ t);
            task                            peek (output REQ t);
    
    // Sequencer Interface
    uvm_seq_item_pull_imp #(REQ, RSP, this_type) seq_item_export;
endclass
uvm_sequence_item

class uvm_sequence_item extends uvm_transaction;
	        function                      new                    (string name = "uvm_sequence_item");
	        function int                  get_sequence_id        ();
	        function void                 set_item_context       (uvm_sequence_base parent_seq,
	                                                              uvm_sequencer_base sequencer = null);
	        function void                 set_use_sequence_info  (bit value);
	        function bit                  get_use_sequence_info  ();
	        function void                 set_id_info            (uvm_sequence_item item);
    virtual function void                 set_sequencer          (uvm_sequencer_base sequencer);
            function uvm_sequencer_base   get_sequencer          ();
            function void                 set_parent_sequence    (uvm_sequence_base parent);
            function uvm_sequence_base    get_parent_sequence    ();
            function void                 set_depth              (int value);
            function int                  get_depth              ();
    virtual function bit                  is_item                ();
            function string               get_root_sequence_name ();
            function uvm_sequence_base    get_root_sequence      ();
            function string               get_sequence_path      ();
endclass
uvm_sequence_base

class uvm_sequence_base extends uvm_sequence_item;
	        function                           new                     (string name = "uvm_sequence");
	virtual function bit                       is_item                 ();
	        function uvm_sequence_state_enum   get_sequence_state      ();
	        task                               wait_for_sequence_state (int unsigned state_mask);
	        function integer                   get_tr_handle           ();
	        
	// Sequence Execution
	virtual task                               start                   (uvm_sequencer_base sequencer,
	                                                                    uvm_sequence_base  parent_sequence = null,
	                                                                    int                this_priority = -1,
	                                                                    bit                call_pre_post = 1);
	virtual task                               pre_start               ();
	virtual task                               pre_body                ();
	virtual task                               pre_do                  (bit is_item);
	virtual function void                      mid_do                  (uvm_sequence_item   this_item);
	virtual task                               body                    ();
	virtual function void                      post_do                 (uvm_sequence_item   this_item);
	virtual task                               post_body               ();
	virtual task                               post_start              ();
	
	// Run-time phasing
	        function uvm_phase                 get_starting_phase             ();
	        function void                      set_starting_phase             (uvm_phase phase);
	        function void                      set_automatic_phase_objection  (bit value);
	        function bit                       get_automatic_phase_objection  ();
	        
	// Sequence Control
	        function void                      set_priority            (int value);
	        function int                       get_priority            ();
	virtual function bit                       is_relevant             ();
	virtual task                               wait_for_relevant       ();
	        task                               lock                    (uvm_sequencer_base sequencer = null);
	        task                               grab                    (uvm_sequencer_base sequencer = null);
	        function void                      unlock                  (uvm_sequencer_base sequencer = null);
	        function void                      ungrab                  (uvm_sequencer_base sequencer = null);
	        function bit                       is_blocked              ();
	        function bit                       has_lock                ();
	        function void                      kill                    ();
	virtual function void                      do_kill                 ();
	
	// Sequence Item Execution
	protected function uvm_sequence_item       create_item             (uvm_object_wrapper   type_var,
	                                                                    uvm_sequencer_base   l_sequencer,
	                                                                    string               name);
	virtual   task                             start_item              (uvm_sequence_item    item,
	                                                                    int                  set_priority = -1,
	                                                                    uvm_sequencer_base   sequencer = null);
	virtual   task                             finish_item             (uvm_sequence_item    item,
	                                                                    int                  set_priority = -1);
	virtual   task                             wait_for_grant          (int                  item_priority = -1,
	                                                                    bit                  lock_request = 0);
    virtual   function void                    send_request            (uvm_sequence_item    request,
                                                                        bit                  rerandomize = 0);
    virtual   task                             wait_for_item_done      (int                  transaction_id = -1);
    
    // Response API
            function void                      use_response_handler                     (bit enable);
            function bit                       get_use_response_handler                 ();
    virtual function void                      response_handler                         (uvm_sequence_item response);
            function void                      set_response_queue_error_report_disabled (bit value);
            function bit                       get_response_queue_error_report_disabled ();
            function void                      set_response_queue_depth                 (int value);
            function int                       get_response_queue_depth                 ();
    virtual function void                      clear_response_queue                     ();
    
endclass
uvm_sequence

virtual class uvm_sequence # (type REQ = uvm_sequence_item, type RSP = REQ) extends uvm_sequence_base;
            function                      new                    (string name = "uvm_sequence");
            function void                 send_request           (uvm_sequence_item request, 
                                                                  bit               rerandomize = 0);
            function REQ                  get_current_item       ();
    virtual task                          get_response           (output RSP response, 
                                                                  input  int transaction_id = -1);
endclass