func_code_string: #include <bits/stdc++.h>   #pragma GCC target( pclmul )   using ul = std::uint32_t;   using ull = std::uint64_t;   using li = std::int32_t;   using ll = std::int64_t;   using llf = long double;   using uss = std::uint8_t;   const ul tau = 15;   const ul fib[] = {       1,       1,       2,       3,        5,        8,        13,      21,       34,      55,      89,      144,      233,      377,      610,     987,       1597,    2584,    4181,    6765,     10946,    17711,    28657,   46368,       75025,   121393,  196418,  317811,   514229,   832040,   1346269, 2178309,       3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986};   const ul sz = fib[tau];   char f[tau + 1][sz + 1];   ul ord[sz + sz];   class sam_t {    public:     ul las;     class node {      public:       ul ch[2];       ul len = 0;       ul fa = 0;       ul cnt = 0;       node() { std::memset(ch, 0, sizeof(ch)); }     };     std::vector<node> st = std::vector<node>(sz + sz);     void add(ul c) {       ul p = las;       ul np = las = st.size();       st.push_back(node());       st[np].len = st[p].len + 1;       for (; p && !st[p].ch[c]; p = st[p].fa) {         st[p].ch[c] = np;       }       if (!p) {         st[np].fa = 1;       } else {         ul q = st[p].ch[c];         if (st[q].len == st[p].len + 1) {           st[np].fa = q;         } else {           ul nq = st.size();           st.push_back(node());           st[nq] = st[q];           st[nq].cnt = 0;           st[nq].len = st[p].len + 1;           st[q].fa = st[np].fa = nq;           for (; p && st[p].ch[c] == q; p = st[p].fa) {             st[p].ch[c] = nq;           }         }       }     }     void init() {       las = 1;       st.resize(0);       st.resize(2);     }   };   sam_t sams[tau + 1];   ul n, m;   ull k;   const ul maxn = 200;   ull lambda[maxn + 1][4];   const ul maxm = 200;   ul tim = 0;   char ans[maxm + 2];   ul currs[4];   ul nexts0[4];   ul nexts1[4];   ull getnum(ul st[4]) {     ull ret = 0;     for (ul i = 0; i != 4; ++i) {       ret += lambda[n][i] * sams[tau - i].st[st[i]].cnt;     }     return ret;   }   int main() {     f[0][1] =  0 ;     f[1][1] =  1 ;     std::scanf( %u%llu%u , &n, &k, &m);     for (ul x = 2; x <= std::min(n, tau); ++x) {       std::memcpy(f[x] + 1, f[x - 2] + 1, fib[x - 2]);       std::memcpy(f[x] + fib[x - 2] + 1, f[x - 1] + 1, fib[x - 1]);     }     if (n <= tau) {       sams[n].init();       for (ul i = 1; i <= fib[n]; ++i) {         sams[n].add(f[n][i] -  0 );         ++sams[n].st[sams[n].las].cnt;       }       for (ul i = 1; i != sams[n].st.size(); ++i) {         ord[i] = i;       }       std::sort(ord + 1, ord + sams[n].st.size(), [&](ul a, ul b) {         return sams[n].st[a].len < sams[n].st[b].len;       });       for (ul it = sams[n].st.size() - 1; it >= 2; --it) {         ul i = ord[it];         sams[n].st[sams[n].st[i].fa].cnt += sams[n].st[i].cnt;       }       ul curr = 1;       ull cc = sams[n].st[1].cnt;       while (tim < m) {         ul next0 = sams[n].st[curr].ch[0];         ul next1 = sams[n].st[curr].ch[1];         ull cn0 = sams[n].st[next0].cnt;         ull cn1 = sams[n].st[next1].cnt;         if (cc - cn0 - cn1 >= k) {           break;         } else {           k -= cc - cn0 - cn1;         }         if (cn0 >= k) {           ++tim;           ans[tim] =  0 ;           curr = next0;           cc = cn0;         } else {           ++tim;           ans[tim] =  1 ;           curr = next1;           k -= cn0;           cc = cn1;         }       }       std::printf(ans + 1);       std::putchar(  n );     } else {       for (ul x = tau - 3; x <= tau; ++x) {         sams[x].init();         for (ul i = 1; i <= fib[x]; ++i) {           sams[x].add(f[x][i] -  0 );           ++sams[x].st[sams[x].las].cnt;         }         for (ul i = 1; i != sams[x].st.size(); ++i) {           ord[i] = i;         }         std::sort(ord + 1, ord + sams[x].st.size(), [&](ul a, ul b) {           return sams[x].st[a].len < sams[x].st[b].len;         });         for (ul it = sams[x].st.size() - 1; it >= 2; --it) {           ul i = ord[it];           sams[x].st[sams[x].st[i].fa].cnt += sams[x].st[i].cnt;         }         lambda[x][tau - x] = 1;       }       for (ul x = tau + 1; x <= n; ++x) {         for (ul i = 0; i != 4; ++i) {           lambda[x][i] = lambda[x - 1][i] + lambda[x - 2][i] + lambda[x - 2][i] -                          lambda[x - 3][i] - lambda[x - 4][i];         }       }       for (ul i = 0; i != 4; ++i) {         currs[i] = 1;       }       ull cc = getnum(currs);       while (tim < m) {         for (ul i = 0; i != 4; ++i) {           nexts0[i] = sams[tau - i].st[currs[i]].ch[0];           nexts1[i] = sams[tau - i].st[currs[i]].ch[1];         }         ull cn0 = getnum(nexts0);         ull cn1 = getnum(nexts1);         if (cc - cn0 - cn1 >= k) {           break;         } else {           k -= cc - cn0 - cn1;         }         if (cn0 >= k) {           ++tim;           ans[tim] =  0 ;           std::memcpy(currs, nexts0, sizeof(currs));           cc = cn0;         } else {           ++tim;           ans[tim] =  1 ;           std::memcpy(currs, nexts1, sizeof(currs));           k -= cn0;           cc = cn1;         }       }       std::printf(ans + 1);       std::putchar(  n );     }     return 0;   }   