import scala.annotation.tailrec
import scala.collection.{immutable, mutable}


object Main extends App {

  import scala.io.StdIn._

  val idx = readLong()
  var min = 1L
  var max = idx
  while (min < max) {
    val mid = (min + max) / 2
    if (calDigitUnder(mid) < idx) min = mid + 1
    else max = mid
  }
  val rest = idx - calDigitUnder(min - 1) - 1
  println(toSequence(min, min + 20).substring(rest.toInt, rest.toInt + 20))
  def toSequence(from: Long, until: Long): String = {
    (from until until).map{
      case n if n % 15 == 0 ⇒ "FizzBuzz"
      case n if n % 3 == 0 ⇒ "Fizz"
      case n if n % 5 == 0 ⇒ "Buzz"
      case n ⇒ n.toString
    }.mkString("")
  }

  def calDigitJustDigit(digit: Int): Long = {
    val value = power(10, digit) - 1
    val nonStr = value - value / 3 - value / 5 + value / 15
    val underValue = value / 10
    val underNonStr = underValue - underValue / 3 - underValue / 5 + underValue / 15
    (nonStr - underNonStr) * digit + (value / 3 - underValue / 3) * 4 + (value / 5 - underValue / 5) * 4
  }

  def calDigitUnder(number: Long): Long = {
    val digit = calDigit(number)
    val under = power(10, digit - 1) - 1
    val underDigit = (1 until digit).map(calDigitJustDigit).sum
    val underStr = under / 3 + under / 5 - under / 15
    val str = number / 3 + number / 5 - number / 15 - underStr
    val nonStr = number - under - str
    underDigit + nonStr * digit + (number / 3 - under / 3 + number / 5 - under / 5) * 4
  }

  def calDigit(number: Long): Int = {
    if (number < 10) 1 else 1 + calDigit(number / 10)
  }

  def power(base: Long, exp: Int): Long = {
    exp match {
      case 0 ⇒ 1L
      case 1 ⇒ base
      case _ ⇒ power(base * base, exp / 2) * power(base, exp % 2)
    }
  }
}
