code: def add_to_number_linking_scores(self,
                                       all_numbers: Set[str],
                                       number_linking_scores: Dict[str, Tuple[str, str, List[int]]],
                                       get_number_linking_dict: Callable[[str, List[Token]],
                                                                         Dict[str, List[int]]],
                                       current_tokenized_utterance: List[Token],
                                       nonterminal: str) -> None:
          
          number_linking_dict: Dict[str, List[int]] = {}
          for utterance, tokenized_utterance in zip(self.utterances, self.tokenized_utterances):
              number_linking_dict = get_number_linking_dict(utterance, tokenized_utterance)
              all_numbers.update(number_linking_dict.keys())
          all_numbers_list: List[str] = sorted(all_numbers, reverse=True)
          for number in all_numbers_list:
              entity_linking = [0 for token in current_tokenized_utterance]
              # ``number_linking_dict`` is for the last utterance here. If the number was triggered
              # before the last utterance, then it will have linking scores of 0's.
              for token_index in number_linking_dict.get(number, []):
                  if token_index < len(entity_linking):
                      entity_linking[token_index] = 1
              action = format_action(nonterminal, number, is_number=True, keywords_to_uppercase=KEYWORDS)
              number_linking_scores[action] = (nonterminal, number, entity_linking)
docs: This is a helper method for adding different types of numbers (eg. starting time ranges) as entities.
          We first go through all utterances in the interaction and find the numbers of a certain type and add
          them to the set ``all_numbers``, which is initialized with default values. We want to add all numbers
          that occur in the interaction, and not just the current turn because the query could contain numbers
          that were triggered before the current turn. For each entity, we then check if it is triggered by tokens
          in the current utterance and construct the linking score.