code: def _categorize_states(self, simgr):
          
  
          past_active_states = len(simgr.active)
          # past_deprioritized_states = len(simgr.deprioritized)
  
          for goal in self._goals:
              for p in simgr.active:
                  if self._check_goals(goal, p):
                      if self._goal_satisfied_callback is not None:
                          self._goal_satisfied_callback(goal, p, simgr)
  
          simgr.stash(
              filter_func=lambda p: all(not goal.check(self._cfg, p, peek_blocks=self._peek_blocks) for goal in
                                        self._goals
                                        ),
              from_stash='active',
              to_stash='deprioritized',
          )
  
          if simgr.active:
              # TODO: pick some states from depriorized stash to active stash to avoid overfitting
              pass
  
          active_states = len(simgr.active)
          # deprioritized_states = len(simgr.deprioritized)
  
          l.debug('%d/%d active states are deprioritized.', past_active_states - active_states, past_active_states)
  
          return simgr
docs: Categorize all states into two different groups: reaching the destination within the peek depth, and not
          reaching the destination within the peek depth.
  
          :param SimulationManager simgr:    The simulation manager that contains states. All active states (state belonging to "active" stash)
                                  are subjected to categorization.
          :return:                The categorized simulation manager.
          :rtype:                 angr.SimulationManager