def count_grouping_ways_brute_force(ranges):
    number_of_ranges = len(ranges)
    count = 0

    def overlap(range1, range2):
        return not (range1[1] < range2[0] or range2[1] < range1[0])

    def solve(index, current_groups):
        nonlocal count

        # Base case: all ranges have been processed
        if index == number_of_ranges:
            count += 1
            return

        # Try adding the current range to existing groups
        for group_index in range(len(current_groups)):
            can_add_to_group = True
            for existing_range in current_groups[group_index]:
                if not overlap(ranges[index], existing_range):
                    continue
                else:
                    break
            else:
                # Create a new copy of the groups and add the current range.
                new_groups = [group[:] for group in current_groups]
                new_groups[group_index].append(ranges[index])
                solve(index + 1, new_groups)

        # Always consider starting a new group
        # This ensures that every possibility is explored
        new_groups = [group[:] for group in current_groups]
        new_groups.append([ranges[index]])
        solve(index + 1, new_groups)

    # Start with an empty list of groups.
    solve(0, [])
    return count

def count_grouping_ways(ranges):
    ranges.sort(key=lambda interval: interval[0])

    merged_ranges = []
    for interval in ranges:
        if not merged_ranges or interval[0] > merged_ranges[-1][1]:
            merged_ranges.append(interval)
        else:
            merged_ranges[-1] = [merged_ranges[-1][0], max(merged_ranges[-1][1], interval[1])]

    # The number of independent ranges determines the exponent for 2.
    number_of_independent_ranges = len(merged_ranges)

    #Calculate the total number of ways to group the ranges.
    total_ways = pow(2, number_of_independent_ranges)

    return total_ways