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.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.util.Locale;

public class LittleElephantAndFunction 
{
    public static void main(String[] args) throws IOException 
    {
        setStandardIO();
        //setFileIO("littleelephantandfunction");       
        
        int n = nextInt();
        
        print(n + " ");
        for (int i = 1; i < n; i++)
            print(i + " ");
        
        flush();
    }

    // ~ -----------------------------------------------------------------------
    // ~ - Auxiliary code ------------------------------------------------------
    // ~ -----------------------------------------------------------------------
    static InputStream in;
    static PrintWriter out;

    /**
     * Simple buffered reader class. Reads if buffer is empty. Try to fill up
     * whole buffer.
     */
    public static class SimpleBufferedInputStream extends InputStream 
    {
        // ~ Static fields / Initializers --------------------------------------
        private static int defaultCharBufferSize = 16384;
        private InputStream in;
        byte[] buffer;
        int pos = 0;
        int len = 0;
        
        // ~ Constructors ------------------------------------------------------
        public SimpleBufferedInputStream(InputStream in) {
            this(in, defaultCharBufferSize);
        }

        public SimpleBufferedInputStream(InputStream in, int size) {
            this.in = in;
            this.buffer = new byte[size];
        }
        
        // ~ Methods -----------------------------------------------------------
        @Override
        public int read() throws IOException {
            if (pos < len)
                return buffer[pos++];
            
            len = in.read(buffer);
            if (len == -1)
                return len;
            
            pos = 0;
            if (len <= 0)
                return -1;
            
            return buffer[pos++];
        }
    }

    public static void setStandardIO() {
        in = new SimpleBufferedInputStream(System.in);
        out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    }

    public static void setFileIO(String fileName) throws IOException {
        in = new SimpleBufferedInputStream(new FileInputStream(fileName + ".in"));
        out = new PrintWriter(new BufferedWriter(new FileWriter(fileName + ".out")));
    }

    public static int skipWhitespaces() throws IOException {
        int c;
        for (;;) {
            c = in.read();
            if (c == -1) throw new IOException();
            if (!isWhitespace(c)) break;
        }   
        
        return c;
    }
    
    public static int nextNoWhitespace() throws IOException {
        int c = in.read();
        if (c == -1 || isWhitespace(c)) return -1;
        
        return c;
    }

    public static long nextLong() throws IOException {
        int c;
        for (;;) {
            c = in.read();
            if (!isWhitespace(c)) break;
            if (c == -1) throw new RuntimeException();
        }   

        boolean neg = false;
        long val = 0;
        if (c == '-')
            neg = true;
        else 
            val = c - '0';
        
        for (;;) {
            c = in.read();
            if (isWhitespace(c) || c == -1) 
                break;
            
            val = val * 10 + (c - '0');
        }

        if (neg) 
            return -val;
        
        return val;
    }

    public static int nextInt() throws IOException {
        int c;
        for (;;) {
            c = in.read();
            if (!isWhitespace(c)) break;
            if (c == -1) throw new RuntimeException();
        }   
        
        boolean neg = false;        
        int val = 0;
        if (c == '-')
            neg = true;
        else 
            val = c - '0';
        
        for (;;) {
            c = in.read();
            if (isWhitespace(c) || c == -1) 
                break;
            
            val = val * 10 + (c - '0');
        }

        if (neg) 
            return -val;
        
        return val;
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' ? true : false;
    }
    
    public static byte nextByte() throws IOException {
        return (byte) nextInt();
    }

    public static String nextString() throws IOException {
        int c = (char) skipWhitespaces();
        
        StringBuilder sb = new StringBuilder();
        sb.append((char) c);
        
        for (;;) {
            c = nextNoWhitespace();
            if (c == -1)
                break;
            
            sb.append((char) c);
        }

        return sb.toString();
    }

    public static BigDecimal nextBigDecimal() throws IOException {
        return new BigDecimal(nextString());
    }
    
    public static void flush() {
        out.flush();
    }

    public static void println(Object object) {
        out.println(object);
    }

    public static void print(Object object) {
        out.print(object);
    }

    public static void println(double d, int precision) {
        String s = "%1$." + precision + "f";
        out.format(Locale.ENGLISH, s, d);
        out.println();
    }

    public static void println(BigDecimal d, int precision) {
        String s = "%1$." + precision + "f";
        out.format(Locale.ENGLISH, s, d);
        out.println();
    }
}
