Consider the following recursive mergesort algorithm (another classic divide and conquer algorithm). The basic idea is to divide an unsorted list x of m elements into two sublistas of about half the size of the original list. Repeat this operation on each sublist, adn continue until we have lists of size 1 in length. Then starthing with sublists of length 1, "merge the two sublists into a single sorted list.

Mergesort (m) var list left, right, result if length(m) 1 return m else var middle-1ength(m)/2 for each x in m up to middle add x to left for each x in m after middle add x to right left-Mergesort(left) right-Mergesort (right) result-Merge(left, right) return result The merge step is carried out by the following code: Merge(left,right) var list result while length(left) 0 and length(right) 0 if first(left) S first(right) to result append first (left) left res t ( l eft) else append first(right) to result right- rest (right) if length(left) 0 if length(right) 0 return result append rest(left) to result append rest (right) to result 6.5.1 [10] Assume that you have Y cores on a multicore processor to run MergeSort. Assuming that Y is much smaller than length(m), express the speedup factor you might expect to obtain for values of Y and length(m). Plot these on a graph