class Solution:
    """
    This code solves the problem of inserting a new interval into a sorted list of non-overlapping intervals. Here's what it does in everyday language:
    
    First, it creates an empty result list and starts looking at the existing intervals one by one.
    Step 1: It copies over all intervals that come completely before the new interval (no overlap). It's like placing smaller time slots that finish before our new time slot begins.
    Step 2: When it finds intervals that overlap with our new interval, it merges them together:
    It takes the earliest start time between the overlapping intervals
    It takes the latest end time between the overlapping intervals This is like when you have two meetings that overlap, you combine them into one longer meeting.
    Step 3: After handling all overlapping intervals, it adds the final merged interval to the result.
    Finally, it copies over any remaining intervals that come after the merged interval.
    For example, if you had time slots like [[1,3], [6,9]] and wanted to insert [2,5]:
    
    [1,3] overlaps with [2,5], so they merge into [1,5]
    [6,9] comes after, so the final result is [[1,5], [6,9]]
    The code ensures that the resulting list maintains non-overlapping, sorted intervals.
    """
    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
        result = [] 
        index = 0
        while index < len(intervals) and intervals[index][1] < newInterval[0]:
            result.append(intervals[index])
            index = index + 1
        while index < len(intervals) and newInterval[1] >= intervals[index][0]:
            newInterval = [min(intervals[index][0], newInterval[0]), max(intervals[index][1], newInterval[1])]
            index = index + 1
        result.append(newInterval)
        while index < len(intervals):
            result.append(intervals[index])
            index = index + 1
        return result