code: def sort_and_run_forward(self,
                               module: Callable[[PackedSequence, Optional[RnnState]],
                                                Tuple[Union[PackedSequence, torch.Tensor], RnnState]],
                               inputs: torch.Tensor,
                               mask: torch.Tensor,
                               hidden_state: Optional[RnnState] = None):
          batch_size = mask.size(0)
          num_valid = torch.sum(mask[:, 0]).int().item()
          sequence_lengths = get_lengths_from_binary_sequence_mask(mask)
          sorted_inputs, sorted_sequence_lengths, restoration_indices, sorting_indices =\
              sort_batch_by_length(inputs, sequence_lengths)
          packed_sequence_input = pack_padded_sequence(sorted_inputs[:num_valid, :, :],
                                                       sorted_sequence_lengths[:num_valid].data.tolist(),
                                                       batch_first=True)
          if not self.stateful:
              if hidden_state is None:
                  initial_states = hidden_state
              elif isinstance(hidden_state, tuple):
                  initial_states = [state.index_select(1, sorting_indices)[:, :num_valid, :].contiguous()
                                    for state in hidden_state]
              else:
                  initial_states = hidden_state.index_select(1, sorting_indices)[:, :num_valid, :].contiguous()
          else:
              initial_states = self._get_initial_states(batch_size, num_valid, sorting_indices)
          module_output, final_states = module(packed_sequence_input, initial_states)
          return module_output, final_states, restoration_indices