The Little Elephant enjoys recursive functions.

This time he enjoys the sorting function. Let a is a permutation of an integers from 1 to n, inclusive, and ai denotes the i-th element of the permutation. The Little Elephant's recursive function f(x), that sorts the first x permutation's elements, works as follows:

  * If x = 1, exit the function. 
  * Otherwise, call f(x - 1), and then make swap(ax - 1, ax) (swap the x-th and (x - 1)-th elements of a). 



The Little Elephant's teacher believes that this function does not work correctly. But that-be do not get an F, the Little Elephant wants to show the performance of its function. Help him, find a permutation of numbers from 1 to n, such that after performing the Little Elephant's function (that is call f(n)), the permutation will be sorted in ascending order.

Input

A single line contains integer n (1 ≤ n ≤ 1000) — the size of permutation.

Output

In a single line print n distinct integers from 1 to n — the required permutation. Numbers in a line should be separated by spaces.

It is guaranteed that the answer exists.

Examples

Input

1


Output

1 

Input

2


Output

2 1 
import java.io.*;
import java.util.StringTokenizer;
import java.util.*;
import java.math.*; 



// public
class Solution{

  static int[] sieve(int n)
    {
        boolean height[] = new boolean[n+1];
        int prime[] = new int[n+1];
        for(int i=0;i<=n;i++)
            height[i] = true;
        height[0] = false;
        height[1] = false;
        int count=0;
        for(int i=2;i*i<=n;i++)
        {
            if(height[i])
            {
                for(int j=i*i;j<=n;j+=i)
                {
                    height[j] = false;
                }
            }
        }
        int prime_prime_count = 0;
        for(int i=0;i<=n;i++)
        {
            if(height[i])
            {
               count++;
               if(height[count])
               {
                prime_prime_count++;
                prime[i] = prime_prime_count;
               }
               else
                prime[i] =prime_prime_count;

            }
            else
            {
                if(height[count])
               {
                prime_prime_count++;
                prime[i] = prime_prime_count;
               }
               else
                prime[i] =prime_prime_count;
            }
        }
        // for(int i=0;i<=n;i++)
            // System.out.println(height[i]+" "+prime[i]);
       return prime;
    }
  static class Pair{
    int strength;
    int bonus;
    Pair(int strength,int bonus)
    {
        this.strength = strength;
        this.bonus = bonus;
    }

  }
 static class SortbyStrength implements Comparator<Pair> 
{ 
    public int compare(Pair a, Pair b) 
    { 
        return a.strength - b.strength; 
    } 
} 
  private static BigInteger ncr(int n, int r) {
    BigInteger top = BigInteger.ONE;
    BigInteger bot = BigInteger.ONE;
    if(n==r)
        return top;
    for(int i = n; i >n-r; --i){
        top = top.multiply(BigInteger.valueOf(i));
    }

    for(int i = r; i > 1; --i){
        bot = bot.multiply(BigInteger.valueOf(i));
    }

    return top.divide(bot);
}
   
   public static int getCeil(ArrayList<Integer> A, int x)
    {
        int left = 0, right = A.size() - 1;
 
        int ceil = -1;
 
         while (left <= right)
        {
                int mid = (left + right) / 2;
 
              if (A.get(mid) == x) {
                return A.get(mid);
            }
 
                  else if (x < A.get(mid))
            {
                ceil = A.get(mid);
                right = mid - 1;
            }
 
            else
                left = mid + 1;
        }
 
        return ceil;
    }
     public static int getFloor(ArrayList<Integer> A, int x)
    {
        int left = 0, right = A.size() - 1;
 
        int floor = -1;
       while (left <= right)
        {
              int mid = (left + right) / 2;
 
           if (A.get(mid) == x) {
                return A.get(mid);
            }
 
                else if (x < A.get(mid)) {
                right = mid - 1;
            }
 
          else {
                floor = A.get(mid);
                left = mid + 1;
            }
        }
 
        return floor;
    }
   static ArrayList<Integer> sieveOfEratosthenes(int n) 
    { 
        ArrayList<Integer> height = new ArrayList<>();
        boolean prime[] = new boolean[n+1]; 
        for(int i=0;i<n;i++) 
            prime[i] = true; 
        
        for(int p = 2; p*p <=n; p++) 
        { 
            if(prime[p] == true) 
            { 
                for(int i = p*p; i <= n; i += p) 
                    prime[i] = false; 
            } 
        }

        for(int i = 2; i <= n; i++) 
        { 
            if(prime[i] == true) 
                height.add(i);
        } 
        return height;
    } 
      
      static void merge(int height[], int l, int m, int r) 
    { 
       
        int n1 = m - l + 1; 
        int n2 = r - m; 

        int L[] = new int [n1]; 
        int R[] = new int [n2]; 
  

        for (int i=0; i<n1; ++i) 
            L[i] = height[l + i]; 
        for (int j=0; j<n2; ++j) 
            R[j] = height[m + 1+ j]; 
  
  
        
        int i = 0, j = 0; 
  
       
        int k = l; 
        while (i < n1 && j < n2) 
        { 
            if (L[i] <= R[j]) 
            { 
                height[k] = L[i]; 
                i++; 
            } 
            else
            { 
                height[k] = R[j]; 
                j++; 
            } 
            k++; 
        } 
  
    
        while (i < n1) 
        { 
            height[k] = L[i]; 
            i++; 
            k++; 
        } 
  
        while (j < n2) 
        { 
            height[k] = R[j]; 
            j++; 
            k++; 
        } 
    } 
  
  
   static void sort(int height[], int l, int r) 
    { 
        if (l < r) 
        { 
            int m = (l+r)/2; 
  
            sort(height, l, m); 
            sort(height , m+1, r); 
  
           merge(height, l, m, r); 
        } 
    } 
      
      public static long fibologn(long n,HashMap<Long,Long> map)
      {
        if(map.get(n)!=null) return map.get(n);
        long k = n/2;
        if(n%2==0)
        {
             map.put(n,((fibologn(k,map)*fibologn(k,map))+(fibologn(k-1,map)*fibologn(k-1,map)))%1000000007);
            return map.get(n);
        }
        else
        {
             map.put(n,((fibologn(k,map)*fibologn(k+1,map))+(fibologn(k-1,map)*fibologn(k,map)))%1000000007);
             return map.get(n);
        }

      }
    static int ceilSearch(int height[], int low, int high, int x) 
    { 
      int mid;     
        
      if(x <= height[low]) 
        return low;  
    
      if(x > height[high]) 
        return -1;   
       
      mid = (low + high)/2;  

      if(height[mid] == x) 
        return mid; 
    
      else if(height[mid] < x) 
      { 
        if(mid + 1 <= high && x <= height[mid+1]) 
          return mid + 1; 
        else
          return ceilSearch(height, mid+1, high, x); 
      } 
       
    
      { 
        if(mid - 1 >= low && x > height[mid-1]) 
          return mid; 
        else    
          return ceilSearch(height, low, mid - 1, x); 
      } 
    }
    static long countOdd(long L, long R) 
    { 
        long N = (R - L) / 2; 
        if (R % 2 != 0 || L % 2 != 0) 
            N++; 
  
        return N; 
    } 
      
      public static void main(String[] args) throws Exception {
        FastScanner cin = new FastScanner(System.in);
        StringBuffer ans = new StringBuffer();
        int n = cin.nextInt();
        if(n==1)
        {
            System.out.println("1");
        }
        else
        {
             System.out.print(n+" ");
            for(int i=1;i<=n-1;i++)
            {
                if(i==n-1)
                    System.out.println(i);
                else
                System.out.print(i+" ");
            }
           
        }

    }
        
    static class FastScanner {
        private BufferedReader reader = null;
        private StringTokenizer tokenizer = null;
 
        public FastScanner(InputStream in) {
            reader = new BufferedReader(new InputStreamReader(in));
            tokenizer = null;
        }
 
        public String next() {
            if (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
 
        public String nextLine() {
            if (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    return reader.readLine();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
 
            return tokenizer.nextToken("\n");
        }
 
        public long nextLong() {
            return Long.parseLong(next());
        }
         
        public int nextInt() {
            return Integer.parseInt(next());
        }
    }
}