def _timestamp_regulator(self):
        """
        Makes a dictionary whose keys are audio file basenames and whose
        values are a list of word blocks from unregulated timestamps and
        updates the main timestamp attribute. After all done, purges
        unregulated ones.
        In case the audio file was large enough to be splitted, it adds seconds
        to correct timing and in case the timestamp was manually loaded, it
        leaves it alone.

        Note that the difference between self.__timestamps and
        self.__timestamps_unregulated is that in the regulated version,
        right after the word, a list of word blocks must appear. However in the
        unregulated version, after a word, a list of individual splits
        containing word blocks would appear!
        """
        unified_timestamps = _PrettyDefaultDict(list)
        staged_files = self._list_audio_files(sub_dir="staging")
        for timestamp_basename in self.__timestamps_unregulated:
            if len(self.__timestamps_unregulated[timestamp_basename]) > 1:
                # File has been splitted
                timestamp_name = ''.join(timestamp_basename.split('.')[:-1])
                staged_splitted_files_of_timestamp = list(
                    filter(lambda staged_file: (
                        timestamp_name == staged_file[:-3] and
                        all([(x in set(map(str, range(10))))
                             for x in staged_file[-3:]])), staged_files))
                if len(staged_splitted_files_of_timestamp) == 0:
                    self.__errors[(time(), timestamp_basename)] = {
                        "reason": "Missing staged file",
                        "current_staged_files": staged_files}
                    continue
                staged_splitted_files_of_timestamp.sort()
                unified_timestamp = list()
                for staging_digits, splitted_file in enumerate(
                        self.__timestamps_unregulated[timestamp_basename]):
                    prev_splits_sec = 0
                    if int(staging_digits) != 0:
                        prev_splits_sec = self._get_audio_duration_seconds(
                            "{}/staging/{}{:03d}".format(
                                self.src_dir, timestamp_name,
                                staging_digits - 1))
                    for word_block in splitted_file:
                        unified_timestamp.append(
                            _WordBlock(
                                word=word_block.word,
                                start=round(word_block.start +
                                            prev_splits_sec, 2),
                                end=round(word_block.end +
                                          prev_splits_sec, 2)))
                unified_timestamps[
                    str(timestamp_basename)] += unified_timestamp
            else:
                unified_timestamps[
                    timestamp_basename] += self.__timestamps_unregulated[
                        timestamp_basename][0]

        self.__timestamps.update(unified_timestamps)
        self.__timestamps_unregulated = _PrettyDefaultDict(list)
Makes a dictionary whose keys are audio file basenames and whose
        values are a list of word blocks from unregulated timestamps and
        updates the main timestamp attribute. After all done, purges
        unregulated ones.
        In case the audio file was large enough to be splitted, it adds seconds
        to correct timing and in case the timestamp was manually loaded, it
        leaves it alone.

        Note that the difference between self.__timestamps and
        self.__timestamps_unregulated is that in the regulated version,
        right after the word, a list of word blocks must appear. However in the
        unregulated version, after a word, a list of individual splits
        containing word blocks would appear!