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.*;
import java.*;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Random;
import java.lang.*;
 



 
 
public class zad {
private static BufferedReader in;
private static StringTokenizer tok;
private static PrintWriter out;
final static boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") !=null;
 
public static void init() throws FileNotFoundException{
if(ONLINE_JUDGE){
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
}
else{
in = new BufferedReader(new FileReader("input.txt"));
out = new PrintWriter("out.txt");
}
}
 
private static String readString() throws IOException {
while (tok == null || !tok.hasMoreTokens()) {
tok = new StringTokenizer(in.readLine());
}
return tok.nextToken();
}
 
private static int readInt() throws IOException {
return Integer.parseInt(readString());
}
private static double readDouble() throws IOException {
return Double.parseDouble(readString());
}
private static long readLong() throws IOException {
return Long.parseLong(readString());
}
private static float readFloat() throws IOException{
    return Float.parseFloat(readString());
}
 
 
public static class Point implements Comparable{
    
    private int x;
    private int y;
    
    Point(int x, int mum){
        this.x = x;
        y = mum;
    }
    
    
    public int getX(){
        return x;
    }
    public  void setX(int x){
        this.x = x;
    }
    public int getY(){
        return y;
    }
    public boolean equals(Point b){
        if(this.x == b.getX() && this.y == b.getY())
            return true;
        return false;
    }
    public int compareTo(Object obj)
    {
      Point tmp = (Point)obj;
      if(this.x < tmp.getX())
      {
        /* текущее меньше полученного */
        return -1;
      }   
      else if(this.x > tmp.getX())
      {
        /* текущее больше полученного */
        return 1;
      }
      /* текущее равно полученному */
      return 0;  
    }
    
}



public static void Solve() throws IOException{
    
   int n =readInt();
   
   out.print(n+" ");
   for(int i=1;i<n;i++){
       out.print(i+" ");
   }
   
   
  
   
   
   
   
}
    



    
    




public static void main(String[] args) throws IOException {
init();
Solve();
 
 
in.close();
out.close();
}
}