output_description: In the first line, print the sequence S. Two consequtive elements should be
  separated by a space character.
  
  In the second line, print the number of comparisons.
input_description: In the first line _n_ is given. In the second line, _n_ integers are given.
attempt: # def merge(arr, l, mid, r):
  #     L = [arr[i] for i in range(l, mid)]
  #     R = [arr[i] for i in range(mid, r)]
  #     L.append(int(1e9 + 10))
  #     R.append(int(1e9 + 10))
  #     i, j = 0, 0
  #     cnt = 0
  #     for k in range(l, r):
  #         if L[i] <= R[j]:
  #             arr[k] = L[i]
  #             i += 1
  #         else:
  #             arr[k] = R[j]
  #             j += 1
  #         cnt += 1
  #     return cnt
  
  # def mergeSort(arr, l, r):
  #     cnt = 0
  #     if l + 1 < r:
  #         mid = (l + r) >> 1
  #         cnt += mergeSort(arr, l, mid)
  #         cnt += mergeSort(arr, mid, r)
  #         cnt += merge(arr, l, mid, r)
  #     return cnt
  
  # triky
  
  
  def count(l, r):
      cnt = 0
      if l + 1 < r:
          mid = (l + r) >> 1
          cnt += count(l, mid)
          cnt += count(mid, r)
          cnt += r - l
      return cnt
  
  
  cnt = count(0, int(input()))
  arr = list(map(int, input().split()))
  arr.sort()
  print(*arr)
  print(cnt)
  
problem_description: Merge Sort
  
  Write a program of a Merge Sort algorithm implemented by the following
  pseudocode. You should also report the number of comparisons in the Merge
  function.
  
      
      
      Merge(A, left, mid, right)
        n1 = mid - left;
        n2 = right - mid;
        create array L[0...n1], R[0...n2]
        for i = 0 to n1-1
          do L[i] = A[left + i]
        for i = 0 to n2-1
          do R[i] = A[mid + i]
        L[n1] = SENTINEL
        R[n2] = SENTINEL
        i = 0;
        j = 0;
        for k = left to right-1
          if L[i] <= R[j]
            then A[k] = L[i]
                 i = i + 1
            else A[k] = R[j]
                 j = j + 1
      
      Merge-Sort(A, left, right){
        if left+1 < right
          then mid = (left + right)/2;
               call Merge-Sort(A, left, mid)
               call Merge-Sort(A, mid, right)
               call Merge(A, left, mid, right)
samples: [{"input": "10\n    8 5 9 2 6 3 7 1 10 4", "output": "1 2 3 4 5 6 7 8 9 10\n    34"}]