1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#include <bits/stdc++.h>
#define ll long long
using namespace std;

string kierunek[6] = {"A", "B", "C", "D", "E", "F"};

enum { PRAWO, PRAWY_DOL, LEWY_DOL, LEWO, LEWA_GORA, PRAWA_GORA };

string n_razy(ll n, string &wzorek) {
    if (n == 0) return "";
    string res;
    if (n == 1) {
        return wzorek;
    }

    if (n <= 9) {
        string prefix(1, (char)('0') + n);
        if (wzorek.size() == 1)
            return prefix + wzorek;
        else
            return prefix + "[" + wzorek + "]";
    } else {
        return "9[" + n_razy(n / 9, wzorek) + "]" + n_razy(n % 9, wzorek);
    }

    return res;
}

string rownoleglobok(ll wysokosc, ll szerokosc) {
    string zygzak = kierunek[LEWA_GORA] + kierunek[LEWY_DOL];
    string zygzak_w_lewo = n_razy(szerokosc - 1, zygzak) + kierunek[LEWA_GORA];
    string prosto_w_prawo = n_razy(szerokosc, kierunek[PRAWO]);
    string wiersz = prosto_w_prawo + zygzak_w_lewo;
    return n_razy(wysokosc, wiersz);
}

string podstawka(ll n) {
    string zygzak = "BF";
    return n_razy(n - 1, zygzak) + "B" + n_razy(n, kierunek[LEWO]) + "F";
}

string trojkat(ll n);

string trojkat_bez_krawedzi(ll n) {
    if (n == 1) return "";
    if (n == 2) return kierunek[LEWO] + kierunek[PRAWY_DOL] + kierunek[PRAWA_GORA];
    if (n == 3) return "DBDBFBFDF";
    string zygzak_lewy_dol = kierunek[LEWO] + kierunek[PRAWY_DOL];
    string zygzak_prawo = kierunek[PRAWA_GORA] + kierunek[PRAWY_DOL];
    string zygzak_lewa_gora = kierunek[PRAWA_GORA] + kierunek[LEWO];

    if (n % 2 == 0 && n > 4) {
        return n_razy(n - 3, zygzak_lewy_dol) + trojkat(n - 3) + n_razy(2, zygzak_lewy_dol) +
               n_razy(n - 2, zygzak_prawo) + n_razy(n - 2, zygzak_lewa_gora) + kierunek[PRAWA_GORA];
    }

    return n_razy(n - 1, zygzak_lewy_dol) + kierunek[PRAWA_GORA] + trojkat(n - 3) +
           kierunek[PRAWY_DOL] + n_razy(n - 3, zygzak_prawo) + n_razy(n - 2, zygzak_lewa_gora) +
           kierunek[PRAWA_GORA];  // TODO
}

string trojkat_z_prawa(ll n) {
    return kierunek[PRAWY_DOL] + trojkat_bez_krawedzi(n) + n_razy(n - 1, kierunek[PRAWY_DOL]);
}

string trojkat(ll n) {
    if (n == 1) {
        return "FBD";
    }

    if (n % 2 == 1) {
        return podstawka(n) + trojkat(n - 1);
    } else {
        string trojkat_prawy = trojkat_z_prawa(n / 2);
        return rownoleglobok(n / 2, n / 2) + n_razy(n / 2, kierunek[PRAWA_GORA]) +
               n_razy(2, trojkat_prawy) + n_razy(n / 2, kierunek[LEWO]) +
               n_razy(n / 2, kierunek[PRAWA_GORA]) + n_razy(n / 2, kierunek[LEWO]) +
               n_razy(n / 2, kierunek[LEWY_DOL]);
        return "";
    }
}

int32_t main() {
    ios_base::sync_with_stdio(0);
    ll n;
    cin >> n;

    cout << trojkat(n) << "\n";
}