inf = 10000000000

def merge_sort(A, left, right, count):
    if left + 1 < right:
        mid = (left + right) // 2
        count_l = merge_sort(A, left, mid, count)
        count_r = merge_sort(A, mid, right, count)
        return merge(A, left, mid, right) + count_l + count_r
    return 0

def merge(A, left, mid, right):
    L = A[left:mid] + [inf]
    R = A[mid:right] + [inf]

    i = j = 0
    for k in range(left, right):
        if L[i] <= R[j]:
            A[k] = L[i]
            i += 1
        else:
            A[k] = R[j]
            j += 1
    
    return right - left

if __name__ == "__main__":
    n = int(input())
    *A, = map(int, input().split())
    ans = merge_sort(A, 0, n, 0)
    print(*A)
    print(ans) inf = 10000000000 inf 10000000000 def merge_sort(A, left, right, count):
    if left + 1 < right:
        mid = (left + right) // 2
        count_l = merge_sort(A, left, mid, count)
        count_r = merge_sort(A, mid, right, count)
        return merge(A, left, mid, right) + count_l + count_r
    return 0 merge_sort if left + 1 < right:
        mid = (left + right) // 2
        count_l = merge_sort(A, left, mid, count)
        count_r = merge_sort(A, mid, right, count)
        return merge(A, left, mid, right) + count_l + count_r
     left + 1 < right left + 1 left 1 right mid = (left + right) // 2 mid (left + right) // 2 left + right left right 2 count_l = merge_sort(A, left, mid, count) count_l merge_sort(A, left, mid, count) merge_sort A left mid count count_r = merge_sort(A, mid, right, count) count_r merge_sort(A, mid, right, count) merge_sort A mid right count return merge(A, left, mid, right) + count_l + count_r merge(A, left, mid, right) + count_l + count_r merge(A, left, mid, right) + count_l merge(A, left, mid, right) merge A left mid right count_l count_r return 0 0 A A left left right right count count def merge(A, left, mid, right):
    L = A[left:mid] + [inf]
    R = A[mid:right] + [inf]

    i = j = 0
    for k in range(left, right):
        if L[i] <= R[j]:
            A[k] = L[i]
            i += 1
        else:
            A[k] = R[j]
            j += 1
    
    return right - left merge L = A[left:mid] + [inf] L A[left:mid] + [inf] A[left:mid] A left:mid left mid [inf] inf R = A[mid:right] + [inf] R A[mid:right] + [inf] A[mid:right] A mid:right mid right [inf] inf i = j = 0 i 0 = j = 0 j 0 for k in range(left, right):
        if L[i] <= R[j]:
            A[k] = L[i]
            i += 1
        else:
            A[k] = R[j]
            j += 1
    
     k range(left, right) range left right if L[i] <= R[j]:
            A[k] = L[i]
            i += 1
        else:
            A[k] = R[j]
            j += 1
    
     L[i] <= R[j] L[i] L i R[j] R j A[k] = L[i] A[k] A k L[i] L i i += 1 i 1 A[k] = R[j] A[k] A k R[j] R j j += 1 j 1 return right - left right - left right left A A left left mid mid right right if __name__ == "__main__":
    n = int(input())
    *A, = map(int, input().split())
    ans = merge_sort(A, 0, n, 0)
    print(*A)
    print(ans) __name__ == "__main__" __name__ "__main__" n = int(input()) n int(input()) int input() input *A, = map(int, input().split()) *A A map(int, input().split()) map int input().split() ().split () input split ans = merge_sort(A, 0, n, 0) ans merge_sort(A, 0, n, 0) merge_sort A 0 n 0 print(*A) print *A A print(ans) print ans def merge(A, left, mid, right):
    L = A[left:mid] + [inf]
    R = A[mid:right] + [inf]

    i = j = 0
    for k in range(left, right):
        if L[i] <= R[j]:
            A[k] = L[i]
            i += 1
        else:
            A[k] = R[j]
            j += 1
    
    return right - left def merge(A, left, mid, right):
    L = A[left:mid] + [inf]
    R = A[mid:right] + [inf]

    i = j = 0
    for k in range(left, right):
        if L[i] <= R[j]:
            A[k] = L[i]
            i += 1
        else:
            A[k] = R[j]
            j += 1
    
    return right - left merge inf = 10000000000 10000000000 inf n = int(input()) int(input()) n def merge_sort(A, left, right, count):
    if left + 1 < right:
        mid = (left + right) // 2
        count_l = merge_sort(A, left, mid, count)
        count_r = merge_sort(A, mid, right, count)
        return merge(A, left, mid, right) + count_l + count_r
    return 0 def merge_sort(A, left, right, count):
    if left + 1 < right:
        mid = (left + right) // 2
        count_l = merge_sort(A, left, mid, count)
        count_r = merge_sort(A, mid, right, count)
        return merge(A, left, mid, right) + count_l + count_r
    return 0 merge_sort ans = merge_sort(A, 0, n, 0) merge_sort(A, 0, n, 0) ans
inf = 10000000000

def merge_sort(A, left, right, count):
    if left + 1 < right:
        mid = (left + right) // 2
        count_l = merge_sort(A, left, mid, count)
        count_r = merge_sort(A, mid, right, count)
        return merge(A, left, mid, right) + count_l + count_r
    return 0

def merge(A, left, mid, right):
    L = A[left:mid] + [inf]
    R = A[mid:right] + [inf]

    i = j = 0
    for k in range(left, right):
        if L[i] <= R[j]:
            A[k] = L[i]
            i += 1
        else:
            A[k] = R[j]
            j += 1
    
    return right - left

if __name__ == "__main__":
    n = int(input())
    *A, = map(int, input().split())
    ans = merge_sort(A, 0, n, 0)
    print(*A)
    print(ans)
