Let's define the permutation of length *n* as an array *p* = [*p*<sub class="lower-index">1</sub>, *p*<sub class="lower-index">2</sub>, ..., *p*<sub class="lower-index">*n*</sub>] consisting of *n* distinct integers from range from 1 to *n*. We say that this permutation maps value 1 into the value *p*<sub class="lower-index">1</sub>, value 2 into the value *p*<sub class="lower-index">2</sub> 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.
The first line will contain two integers *n*, *k* (1 ≤ *n* ≤ 50, 1 ≤ *k* ≤ *min*{10<sup class="upper-index">18</sup>, *l*} where *l* is the length of the Kyoya's list).
"""
#If FastIO not needed, used this and don't forget to strip
#import sys, math
#input = sys.stdin.readline
"""

import os
import sys
from io import BytesIO, IOBase
import heapq as h 
from bisect import bisect_left, bisect_right

from types import GeneratorType
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
 
    def __init__(self, file):
        import os
        self.os = os
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
 
    def read(self):
        while True:
            b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
 
    def readline(self):
        while self.newlines == 0:
            b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
 
    def flush(self):
        if self.writable:
            self.os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
 
 
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
 
 
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

from collections import defaultdict as dd, deque as dq
import math, string

def getInts():
    return [int(s) for s in input().split()]

def getInt():
    return int(input())

def getStrs():
    return [s for s in input().split()]

def getStr():
    return input()

def listStr():
    return list(input())

MOD = 10**9+7

"""
-I'm pretty confident that the internal ordering is only preserved in pairs
-The cyclic pairs must be adjacent and of the form (i, i+1)
-The pairs must already occupy the correct blocks

[2,1] 3 [5,4] 6... etc

So the questions are: how many permutations begin with 1, and how many begin with 2?
Number beginning with 1 = dp[N-1][1] + dp[N-1][2]
Number beginning with 2 = dp[N-2][1] + dp[N-2][2]

1 2 3 4 5 6
1 2 3 4 (6 5)
1 2 3 (5 4) 6
1 2 (4 3) 5 6
1 2 (4 3) (6 5)
1 (3 2) 4 5 6
1 (3 2) 4 (6 5)
1 (3 2) (5 4) 6
(2 1) 3 4 5 6
(2 1) 3 4 (6 5)
(2 1) 3 (5 4) 6
(2 1) (4 3) 5 6
(2 1) (4 3) (6 5)

"""


def solve():
    N, K = getInts()
    if N == 1:
        print(1)
        return
    dp = [[0 for j in range(2)] for i in range(N+1)]
    dp[1][0] = 1
    dp[2][0] = 1
    dp[2][1] = 1
    for j in range(3,N+1):
        dp[j][0] = dp[j-1][0] + dp[j-1][1]
        dp[j][1] = dp[j-2][0] + dp[j-2][1]
    #there are sum(dp[N]) sequences, and we need to know whether K <= dp[N][0] or not
    ans = []
    to_fill = N
    curr = 1
    while len(ans) < N:
        if K <= dp[to_fill][0]:
            ans.append(curr)
            to_fill -= 1
            curr += 1
        else:
            K -= dp[to_fill][0]
            ans.append(curr+1)
            ans.append(curr)
            to_fill -= 2
            curr += 2
    print(*ans)
    return
    
#for _ in range(getInt()):
solve()