Let's define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on.

Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place. 

Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63).

Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3].

Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list.

Input

The first line will contain two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ min{1018, l} where l is the length of the Kyoya's list).

Output

Print n space-separated integers, representing the permutation that is the answer for the question. 

Examples

Input

4 3


Output

1 3 2 4


Input

10 1


Output

1 2 3 4 5 6 7 8 9 10

Note

The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3].
import java.io.*;
import java.util.*;

public class R309qB {

	static long p[];
	static int ans[];
	
	public static void main(String args[]) {
		InputReader in = new InputReader(System.in);
		PrintWriter w = new PrintWriter(System.out);

		int n = in.nextInt();
		long k = in.nextLong();
		
		p = new long[51];
		p[1] = 1;
		p[2] = 2;
		for(int i=3;i<=50;i++)
			p[i] = p[i-1] + p[i - 2];
		
		ans = new int[n + 1];
		go2(1,n,k,0);
		for(int i=1;i<=n;i++)
			w.print(ans[i] + " ");
		w.println();
		
		w.close();
	}
	
	public static void go2(int curr,int n,long k,int offset){
		if(n == 1)
			ans[curr] = 1 + offset;
		else if(n == 0)
			return;
		else{
			if(k <= p[n-1]){
				ans[curr] = 1 + offset;
				go2(curr+1,n-1,k,offset+1);
			}
			else{
				ans[curr] = 2 + offset;
				ans[curr + 1] = 1 + offset;
				go2(curr+2,n-2,k - p[n-1],offset+2);
			}
		}
	}
	
	public static void go(int curr,int n,int[] a,int d[]){
		if(curr == n + 1){
			if(check(a,n)){
				if(!check2(a,n))
					System.out.println(Arrays.toString(a));
			}
			return;
		}
		for(int i=1;i<=n;i++){
			if(d[i] == 0){
				d[i] = 1;
				a[curr] = i;
				go(curr+1,n,a,d);
				d[i] = 0;
			}
		}
	}
	
	public static boolean check2(int []a,int n){
		for(int i=1;i<=n;i++)
			if(a[i] != i && a[i] != i - 1 && a[i] != i + 1)
				return false;
		return true;
	}
	
	public static boolean check(int[] a,int n){
		int ans[] = new int[n + 1];
		ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();
		boolean vis[] = new boolean[n + 1];
		for(int i=1;i<=n;i++){
			if(!vis[i]){
				vis[i] = true;
				ArrayList<Integer> temp = new ArrayList<Integer>();
				temp.add(i);
				int x = i;
				while(true){
					x = a[x];
					if(vis[x] == true)
						break;
					vis[x] = true;
					temp.add(x);
				}
				make(temp);
				list.add(temp);
			}
		}
		Collections.sort(list,new MyComp());
		int k = 1;
		for(ArrayList<Integer> x : list)
			for(int z : x)
				ans[k++] = z;
		for(int i=1;i<=n;i++)
			if(a[i] != ans[i])
				return false;
		return true;
	}
	
	public static void make(ArrayList<Integer> l){
		int max = 0;
		for(int x : l)
			max = Math.max(x,max);
		while(l.get(0) != max)
			l.add(l.remove(0));
	}
	
	static class MyComp implements Comparator<ArrayList<Integer>>{
		public int compare(ArrayList<Integer> a,ArrayList<Integer> b){
			return Integer.compare(a.get(0), b.get(0));
		}
	}

	static class InputReader {

		private InputStream stream;
		private byte[] buf = new byte[8192];
		private int curChar;
		private int snumChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		public int snext() {
			if (snumChars == -1)
				throw new InputMismatchException();
			if (curChar >= snumChars) {
				curChar = 0;
				try {
					snumChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (snumChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public int nextInt() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}

			int res = 0;

			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));

			return res * sgn;
		}
		
		public long nextLong() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}

			long res = 0;

			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));

			return res * sgn;
		}
		
		public String readString() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = snext();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public boolean isSpaceChar(int c) {
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public interface SpaceCharFilter {
			public boolean isSpaceChar(int ch);
		}
	}

}
