import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.container, std.math, std.typecons;

immutable int mod = 10^^9 + 7;
immutable int inf = 20000;

long s;

void main() {
    s = readln.chomp.to!long;
    solve(s).writeln;
}

string solve(long s) {
    long top = s, btm = 0, mid;

    while (top - btm > 1) {
        mid = btm + (top - btm) / 2;

        if (calc(mid) < s) {
            btm = mid;
        }
        else {
            top = mid;
        }
    }

    debug {
        writeln("btm:", btm);
    }

    int dif = cast(int)(s - calc(btm) - 1);

    string ans;
    long i = btm + 1;

    while (ans.length < 20 + dif) {
        if (i % 15 == 0) ans ~= "FizzBuzz";
        else if (i % 3 == 0) ans ~= "Fizz";
        else if (i % 5 == 0) ans ~= "Buzz";
        else ans ~= i.to!string;
        i++;
    }

    ans = ans.drop(dif).to!string;
    ans = ans[0 .. 20];

    return ans;
}

unittest {
    assert(solve(1) == "12Fizz4BuzzFizz78Fiz");
    assert(solve(20) == "zzBuzz11Fizz1314Fizz");

    //stderr.writeln(solve(10000000000));
    assert(solve(10000000000) == "93FizzBuzz1418650796");
}

long calc(long n) {
    if (n == 0) return 0L;

    static long[] nonfz = new long[](21);
    static bool fc = true;

    if (fc) {
        foreach (i ; 1 .. 21) {
            nonfz[i] = countnonfz(10L^^i - 1) - countnonfz(10L^^(i - 1));
            if (i == 1) nonfz[i]++;
        }

        debug {
            writeln("nonfz:", nonfz);
        }

        fc = false;
    }

    long res = (n / 3 + n / 5) * 4;

    int keta = calcdig(n);

    foreach (i ; 1 .. keta) {
        res += nonfz[i] * i;
    }

    res += (countnonfz(n) - countnonfz(10L^^(keta - 1) - 1)) * keta;
    return res;
}

unittest {
    assert(calc(4) == 7);
    assert(calc(10) == 25);
    assert(calc(2) == 2);
    assert(calc(100) == 313);
    assert(calc(1000) == 3673);
    assert(calc(983) == 3609);
}

int calcdig(long n) {
    return n > 0 ? calcdig(n / 10) + 1 : 0;
}

unittest {
    assert(calcdig(8) == 1);
    assert(calcdig(132) == 3);
    assert(calcdig(101010101010) == 12);
}

long countnonfz(long n) {
    return n - n / 3 - n / 5 + n / 15;
}

unittest {
    assert(countnonfz(10) == 5);
    assert(countnonfz(3) == 2);
    assert(countnonfz(100) == 53);
}