free(): Invalid next size (normal)

I have an array of non-overlapping intervals and I have to insert and merge a new interval in the list. For example given the list [2, 3], [6, 8], [9, 12] and the interval [7, 10] the new list is [2, 3], [6, 12].

My code works for simple inputs but for larger inputs I get this error:

* Error in `./solution': free(): invalid next size (normal): 0x0000000001554010 * Aborted

I have found similar questions but I wasn't able to find a solution for my problem.

Why am I getting this error?

Here's my code:

 /**
 * Definition for an interval.
 * struct Interval {
 *     int start;
 *     int end;
 * };
 *
 * typedef struct Interval interval;
 */
/*
 * intervals : the array of interval
 * sz : number of entries in intervals
 * newInterval : new Interval to be inserted
 * len : populate the length of returned array of intervals in len
 */ 

int Overlap(interval X, interval Y) {
    if ((X.start>=Y.start && X.start<=Y.end) || (X.end>=Y.start && X.end<=Y.end))
        return 1;
    return 0;
}
int max(int a, int b) {
    if (a>b) return a;
    return b;
}
int min(int a, int b) {
    if(a<b) return a;
    return b;
} 

interval* insert(interval *intervals, int sz, interval newInterval, int *len) {

if (newInterval.start>newInterval.end) {
    int aux;
    aux = newInterval.start;
    newInterval.start=newInterval.end;
    newInterval.end=aux;
}

int i, first=-1, last=-1;
int s, f;
for (i=0; i<sz; i++) {
    if (Overlap(newInterval, intervals[i]) || Overlap(intervals[i], newInterval)) {
        if (first==-1) {
            first=i;
            last=i;
            s=intervals[i].start;
            f=intervals[i].end;
        }
        else { 
           last = i;
           f=intervals[i].end;
        }
        }
    }


if (first ==-1 && last==-1) 
{
    if (newInterval.end<intervals[0].start) {
        *len=sz+1;
        for(i=*len-1; i>=1; i--) intervals[i]=intervals[i-1];
        intervals[0]=newInterval;
    }
    else if (newInterval.start>intervals[sz-1].end) {
        *len=sz+1;
        intervals[*len-1]=newInterval;
    }

    return intervals;
}

int k=last-first;

for(i=first+1; i<sz-k; i++) {
    intervals[i]=intervals[i+k];
}

newInterval.start=min(s, newInterval.start);
newInterval.end=max(f, newInterval.end);

intervals[first]=newInterval;
*len=sz-k;

return intervals;

}