L R

def mergeSort(L, R):

if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
LR
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
LR
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
 L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
 L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:

if array[a] <= array[b]:
tmp[c++] = array[
else:
0 0 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:

if array[a] <= array[b]:
tmp[c++] = array[
else:
0 0 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:

if array[a] <= array[b]:
tmp[c++] = array[
else:
0 0 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:

if array[a] <= array[b]:
tmp[c++] = array[
else:
0 0 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:

if array[a] <= array[b]:
tmp[c++] = array[
else:
10 0 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:

if array[a] <= array[b]:
tmp[c++] = array[
else:
10 0 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:

if array[a] <= array[b]:
tmp[c++] = array[
else:
10 0 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:

if array[a] <= array[b]:
tmp[c++] = array[
else:
10 0 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:

if array[a] <= array[b]:
tmp[c++] = array[
else:
10 40 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:

if array[a] <= array[b]:
tmp[c++] = array[
else:
10 40 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:

if array[a] <= array[b]:
tmp[c++] = array[
else:
10 40 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:

if array[a] <= array[b]:
tmp[c++] = array[
else:
10 40 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
 L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
 L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
 L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
 L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
 L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
 L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
 L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
 L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
 L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):

a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:

if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]