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(targ, first, mid, last):
      left = targ[first:mid] + [10**9 + 1]
      right = targ[mid:last] + [10**9 + 1]
  
      leftcnt = rightcnt = 0
      global ans
      for i in range(first, last):
          ans += 1
          # print(left,right,left[leftcnt],right[rightcnt],targ,ans)
          if left[leftcnt] <= right[rightcnt]:
              targ[i] = left[leftcnt]
              leftcnt += 1
          else:
              targ[i] = right[rightcnt]
              rightcnt += 1
  
  
  def mergesort(targ, first, last):
  
      if first + 1 >= last:
          pass
      else:
          mid = (first + last) // 2
          mergesort(targ, first, mid)
          mergesort(targ, mid, last)
          merge(targ, first, mid, last)
  
  
  ans = 0
  num = int(input())
  targ = [int(n) for n in input().split(" ")]
  mergesort(targ, 0, num)
  print(" ".join([str(n) for n in targ]))
  print(ans)
  
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"}]