class CountIntervals:
    def __init__(self):
        # A set is used as our special collection to automatically handle duplicate numbers.

        self.covered_numbers = set()

    def add(self, left_boundary: int, right_boundary: int) -> None:
        # We must iterate through every integer in the new range to ensure each one is individually added.

        for current_number in range(left_boundary, right_boundary + 1):
            self.covered_numbers.add(current_number)

    def count(self) -> int:
        # The size of the set directly gives the total count of unique integers covered by all intervals.

        return len(self.covered_numbers)

class CountIntervals:
    def __init__(self):
        self.intervals = []
        self.total_covered_count = 0

    def add(self, left_boundary: int, right_boundary: int) -> None:
        indices_of_conflicting_intervals = []
        
        # Find all existing ranges that overlap or are directly next to the new range.
        for index, current_interval in enumerate(self.intervals):
            current_start, current_end = current_interval
            if current_start <= right_boundary + 1 and current_end >= left_boundary - 1:
                indices_of_conflicting_intervals.append(index)

        merged_start, merged_end = left_boundary, right_boundary
        
        # If conflicts exist, combine them all into a single new continuous range.
        if indices_of_conflicting_intervals:
            for index in indices_of_conflicting_intervals:
                start_to_merge, end_to_merge = self.intervals[index]
                merged_start = min(merged_start, start_to_merge)
                merged_end = max(merged_end, end_to_merge)

            # We must remove the old intervals and subtract their sizes from the total count.
            for index in reversed(indices_of_conflicting_intervals):
                old_start, old_end = self.intervals.pop(index)
                self.total_covered_count -= (old_end - old_start + 1)

        self.total_covered_count += (merged_end - merged_start + 1)

        # To keep the collection neat and simplified, insert the new range in sorted order.
        insertion_point = 0
        while insertion_point < len(self.intervals) and self.intervals[insertion_point][0] < merged_start:
            insertion_point += 1
        self.intervals.insert(insertion_point, [merged_start, merged_end])

    def count(self) -> int:
        return self.total_covered_count