code: def determine_elected_candidates_in_order(self, candidate_votes):
          
          eligible_by_vote = defaultdict(list)
          for candidate_id, votes in candidate_votes.candidate_votes_iter():
              if candidate_id in self.candidates_elected:
                  continue
              if votes < self.quota:
                  continue
              eligible_by_vote[votes].append(candidate_id)
  
          elected = []
          for votes in reversed(sorted(eligible_by_vote)):
              candidate_ids = eligible_by_vote[votes]
              # we sort here to ensure stability, so external callers can hard-coded their response
              candidate_ids.sort(key=self.candidate_order_fn)
              if len(candidate_ids) == 1:
                  elected.append(candidate_ids[0])
              else:
                  tie_breaker_round = self.find_tie_breaker(candidate_ids)
                  if tie_breaker_round is not None:
                      self.results.provision_used(
                          ActProvision("Multiple candidates elected with %d votes. Tie broken from previous totals." % (votes)))
                      for candidate_id in reversed(sorted(candidate_ids, key=tie_breaker_round.get_vote_count)):
                          elected.append(candidate_id)
                  else:
                      self.results.provision_used(
                          ActProvision("Multiple candidates elected with %d votes. Input required from Australian Electoral Officer." % (votes)))
                      permutations = list(itertools.permutations(candidate_ids))
                      permutations.sort()
                      choice = self.resolve_election_order(permutations)
                      for candidate_id in permutations[choice]:
                          elected.append(candidate_id)
          return elected
docs: determine all candidates with at least a quota of votes in `candidate_votes'. returns results in
          order of decreasing vote count. Any ties are resolved within this method.