Karl likes Codeforces and subsequences. He wants to find a string of lowercase English letters that contains at least $k$ subsequences codeforces. Out of all possible strings, Karl wants to find a shortest one.

Formally, a codeforces subsequence of a string $s$ is a subset of ten characters of $s$ that read codeforces from left to right. For example, codeforces contains codeforces a single time, while codeforcesisawesome contains codeforces four times: codeforcesisawesome, codeforcesisawesome, codeforcesisawesome, codeforcesisawesome.

Help Karl find any shortest string that contains at least $k$ codeforces subsequences.


-----Input-----

The only line contains a single integer $k$ ($1 \leq k \leq 10^{16})$.


-----Output-----

Print a shortest string of lowercase English letters that contains at least $k$ codeforces subsequences. If there are several such strings, print any of them.


-----Examples-----
Input
1

Output
codeforces

Input
3

Output
codeforcesss

Source: codeforces | Difficulty: MEDIUM
Tags: Constructive algorithms

String algorithms

Greedy algorithms

Complete search

Mathematics


Solutions:
import math
n = int(input())
k = int(math.log(n, 10))
l = ['s', 'e', 'c', 'r', 'o', 'f', 'e', 'd', 'o', 'c']
p = 2
i = 0
c = 0
f = 0
k = 1
while k < n:
	if f == 1:
		k //= p - 1
	k = k * p
	i += 1
	if i % 10 == 0:
		c += 1
		p += 1
		f = 1
ans = ''
o = i % 10
for j in range(10):
	if j < o:
		ans += l[j] * p
	else:
		ans += l[j] * (p - 1)
print(ans[::-1])


from sys import stdin
input = stdin.readline
k = int(input())
a = [1 for i in range(10)]
b = 'codeforces'
p = 1
i = 0
while 1:
	if p >= k:
		break
	p = p // a[i % 10]
	a[i % 10] += 1
	p = p * a[i % 10]
	i += 1
for i in range(10):
	print(b[i] * a[i], end='')


from sys import stdin, stdout
from math import gcd, sqrt
from collections import deque
input = stdin.readline
R = lambda : map(int, input().split())
I = lambda : int(input())
S = lambda : input().rstrip('\n')
L = lambda : list(R())
P = lambda x: stdout.write(x)
hg = lambda x, y: (y + x - 1) // x * x
pw = lambda x: 1 if x == 1 else 1 + pw(x // 2)
chk = lambda x: chk(x // 2) if not x % 2 else True if x == 1 else False
N = 10 ** (-6)
h = 'codeforces'
d = [1] * 10
k = I()
x = 1
while x < k:
	for i in range(10):
		m = 1
		for j in range(10):
			if j != i:
				m *= d[j]
		x += m
		d[i] += 1
		if x >= k:
			break
for i in range(10):
	P(h[i] * d[i])


import math
k = int(input())
s = 'codeforces'
if k == 1:
	print(s)
else:
	for i in range(2, 41):
		if k > i ** 10:
			continue
		else:
			for j in range(11):
				if i ** j * (i - 1) ** (10 - j) >= k:
					break
			val = j
			for j in s:
				if val > 0:
					print(j * i, end='')
				else:
					print(j * (i - 1), end='')
				val -= 1
			break


def main():
	n = int(input())
	s = 'codeforces'
	x = int(n ** 0.1)
	ans = ''
	a = 0
	if x ** 10 < n:
		for a in range(10, -1, -1):
			if x ** a * (1 + x) ** (10 - a) >= n:
				break
		a = 10 - a
	for i in range(10):
		if a > 0:
			ans += s[i] * (x + 1)
			a -= 1
		else:
			ans += s[i] * x
	print(ans)
main()


k = int(input())
x = 1
while x ** 10 < k:
	x += 1
b = 0
for t in range(10):
	tt = (x - 1) ** t
	tt *= x ** (10 - t)
	if tt >= k:
		b = t
cf = 'codeforces'
for i in range(b):
	print(cf[i] * (x - 1), end='')
for i in range(10 - b):
	print(cf[b + i] * x, end='')


n = int(input())
(sum, t) = (1, 0)
v = [1] * 10
while sum < n:
	v[t] += 1
	t = (t + 1) % 10
	sum = 1
	for i in range(10):
		sum *= v[i]
p = [i for i in 'codeforces']
for i in range(10):
	print(p[i] * v[i], end='')


k = int(input())
arr = [1] * 10
min1 = min(arr)
minpos = arr.index(min(arr))
kmax = 1
for i in range(10):
	kmax = kmax * arr[i]
if kmax >= k:
	print('c' * arr[0] + 'o' * arr[1] + 'd' * arr[2] + 'e' * arr[3] + 'f' * arr[4] + 'o' * arr[5] + 'r' * arr[6] + 'c' * arr[7] + 'e' * arr[8] + 's' * arr[9])
else:
	while k > kmax:
		kmax = 1
		minpos = arr.index(min(arr))
		arr[minpos] = arr[minpos] + 1
		for i in range(10):
			kmax = kmax * arr[i]
	print('c' * arr[0] + 'o' * arr[1] + 'd' * arr[2] + 'e' * arr[3] + 'f' * arr[4] + 'o' * arr[5] + 'r' * arr[6] + 'c' * arr[7] + 'e' * arr[8] + 's' * arr[9])


def mul(d):
	prod = 1
	for i in d:
		prod = prod * i
	return prod

def ansp(d):
	ans = ''
	ans += 'c' * d[0]
	ans += 'o' * d[1]
	ans += 'd' * d[2]
	ans += 'e' * d[3]
	ans += 'f' * d[4]
	ans += 'o' * d[5]
	ans += 'r' * d[6]
	ans += 'c' * d[7]
	ans += 'e' * d[8]
	ans += 's' * d[9]
	print(ans)
k = int(input())
d = [1 for i in range(10)]
j = 0
while True:
	if mul(d) < k:
		d[j] += 1
		j = (j + 1) % 10
	else:
		ansp(d)
		break


import os
import operator
from collections import defaultdict
import sys
from io import BytesIO, IOBase
import bisect

def main():
	k = int(input())
	arr = list('codeforces')
	freq = [1] * 10
	if k == 1:
		print('codeforces')
	else:
		temp = 1
		while True:
			for i in range(10):
				temp = temp // freq[i]
				freq[i] += 1
				temp = temp * freq[i]
				if temp >= k:
					break
			if temp >= k:
				break
		ans = ''
		for i in range(10):
			ans += arr[i] * freq[i]
		print(ans)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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')
main()


def rt10(n):
	ret = 0
	mn = 64
	while mn > 0:
		if (ret + mn) ** 10 <= n:
			ret += mn
		mn //= 2
	return ret

def fl(n):
	x = n // 10
	kolvo = n % 10
	ret = [x for i in range(10)]
	for i in range(kolvo):
		ret[i] += 1
	prod = 1
	for x in ret:
		prod *= x
	return (prod, ret)
k = int(input())
n = 10 * rt10(k)
(res, li) = fl(n)
while res < k:
	n += 1
	(res, li) = fl(n)
startstr = 'codeforces'
retstr = []
for i in range(10):
	retstr.append(startstr[i] * li[i])
retstr = ''.join(retstr)
print(retstr)


def root_floor(x, p):
	l_ = 0
	r = x + 1
	while r - l_ > 1:
		m = (l_ + r) // 2
		if m ** p > x:
			r = m
		else:
			l_ = m
	return l_

def solve(rf, k):
	l_ = -1
	r = 10
	while r - l_ > 1:
		m = (l_ + r) // 2
		if (rf + 1) ** m * rf ** (10 - m) < k:
			l_ = m
		else:
			r = m
	return r

def main():
	k = int(input())
	rf = root_floor(k, 10)
	s = solve(rf, k)
	print(''.join((c * (rf + (i < s)) for (i, c) in enumerate('codeforces'))))
main()


import sys
LI = lambda : list(map(int, sys.stdin.readline().strip('\n').split()))
MI = lambda : map(int, sys.stdin.readline().strip('\n').split())
SI = lambda : sys.stdin.readline().strip('\n')
II = lambda : int(sys.stdin.readline().strip('\n'))
k = II()
s = 'codeforces'
(num, cnt, l) = (1, [1] * 10, 0)
while num < k:
	num //= cnt[l]
	cnt[l] += 1
	num *= cnt[l]
	l = l + 1 if l < 9 else 0
for i in range(10):
	print(s[i] * cnt[i], end='')


k = int(input())
s = 'codeforces'
v = [1] * len(s)
c = 1
while c < k:
	for i in range(len(s)):
		if c < k:
			c //= v[i]
			v[i] += 1
			c *= v[i]
		else:
			break
t = ''
for i in range(len(s)):
	t += s[i] * v[i]
print(t)


a = int(input())
i = 0
while pow(i, 10) < a:
	i += 1
i -= 1
l = [i] * 10
for x in range(10):
	l[x] += 1
	y = 1
	for j in l:
		y *= j
	if y >= a:
		break
st = 'codeforces'
sol = ''
for i in range(10):
	for j in range(l[i]):
		sol += st[i]
print(sol)


n = int(input())
div = 0
rem = 0
ans = 1
name = 'codeforces'
flag = 0
if n == 1:
	print(name)
else:
	for i in range(1, 50):
		for j in range(1, 11):
			if ans >= n:
				div = i - 1
				rem = j - 1
				flag = 1
				break
			ans *= i
			if i != 1:
				ans //= i - 1
		if flag == 1:
			break
	for i in range(len(name)):
		print(name[i] * div, end='')
		if i <= rem - 1:
			print(name[i], end='')


n = int(input())
s = 'codeforces'
prod = 1
i = 0
a = [1] * 10
while prod < n:
	prod //= a[i]
	a[i] += 1
	prod *= a[i]
	i = (i + 1) % 10
t = ''
for i in range(10):
	t += s[i] * a[i]
print(t)


import math

def power(k):
	b = 2
	while b ** 10 < k:
		b += 1
	return b

def powerof(k, b):
	num_b = 1
	while b ** num_b * (b - 1) ** (10 - num_b) < k:
		num_b += 1
	return num_b

def answer(k):
	if k == 1:
		print('codeforces')
		return
	b = power(k)
	num_b = powerof(k, b)
	s = 'codeforces'
	for i in range(10):
		if i + 1 <= num_b:
			print(s[i] * b, end='')
		else:
			print(s[i] * (b - 1), end='')
	print()
	return

def main():
	k = int(input())
	answer(k)
	return
main()


from sys import stdin, stdout

def smallest(b):
	x = [0, b[0]]
	for y in range(10):
		if b[y] < x[1]:
			x[1] = b[y]
			x[0] = y
	return x[0]

def product(b):
	x = 1
	for y in range(10):
		x *= b[y]
	return x
codeforces = [1] * 10
k = int(stdin.readline())
count = 0
while product(codeforces) < k:
	count += 1
	codeforces[smallest(codeforces)] += 1
mylist = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
for x in range(10):
	for y in range(codeforces[x]):
		stdout.write(mylist[x])
stdout.write('\n')


k = int(input())
s = 'codeforces'
s = list(s)
cur = 1
for i in range(len(s)):
	left = 1
	right = 41
	best = None
	while left <= right:
		mid = (left + right) // 2
		temp = cur * mid ** (len(s) - i)
		if temp < k:
			left = mid + 1
		if temp >= k:
			best = mid
			right = mid - 1
	cur *= best
	if best:
		s[i] = s[i] * best
print(''.join(s))


from __future__ import division, print_function
import os, sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip

def ii():
	return int(input())

def fi():
	return float(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())

def read():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def powerMod(x, y, p):
	res = 1
	x %= p
	while y > 0:
		if y & 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
mod = 1000000007
from math import *
import bisect
from decimal import *
getcontext().prec = 50
abc = 'abcdefghijklmnopqrstuvwxyz'
pi = 3.141592653589793

def main():
	n = ii()
	f = 'codeforces'
	for i in range(1, 101):
		if i ** 10 >= n:
			c = i
			break
	d = c - 1
	for i in range(1, 11):
		s = c ** i * d ** (10 - i)
		if s >= n:
			x = i
			break
	ans = ''
	for i in range(x):
		ans += f[i] * c
	for i in range(x, 10):
		ans += f[i] * d
	print(ans)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


n = int(input())
s = 'codeforces'
i = 10
s1 = ''
while i >= 1:
	num = n ** (1 / i)
	if int(num) == round(num, 10):
		if int(num) ** i == n:
			num = int(num)
		else:
			num = int(num) + 1
	else:
		num = int(num) + 1
	n = n / num
	s1 += s[10 - i] * num
	i -= 1
print(s1)


def mul(d):
	s = 1
	for i in d:
		s *= i
	return s
n = int(input())
d = [1] * 10
i = 0
while mul(d) < n:
	d[i % 10] += 1
	i += 1
s = 'codeforces'
for i in range(10):
	print(s[i] * d[i], end='')


n = int(input())
if n == 1:
	print('codeforces')
	exit()
else:
	s = 'codeforces'
	d = {}
	i = 0
	while i < len(s):
		x = s[i]
		d[i] = x
		i = i + 1
	l = [1] * 10
	pr = 1
	i = 0
	while pr < n:
		e = l[i]
		l[i] = l[i] + 1
		pr = pr * l[i] // e
		if i == len(l) - 1:
			i = 0
		else:
			i = i + 1
	s = ''
	i = 0
	while i < len(l):
		x = l[i]
		r = d[i]
		s = s + r * x
		i = i + 1
	print(s)


import math
k = int(input())
ave = math.floor(k ** 0.1)
n = ave ** 10
seq = []
for ch in 'codeforces':
	if n < k:
		seq.append(ch * (ave + 1))
		n //= ave
		n *= ave + 1
	else:
		seq.append(ch * ave)
print(''.join(seq))


n = int(input())
if n == 1:
	print('codeforces')
	exit()
num = 1
while num ** 10 < n:
	num += 1
s = list('codeforces')
temp = 10
for i in reversed(range(11)):
	if num ** i * (num - 1) ** (10 - i) < n:
		temp = i + 1
		break
ans = ''
for i in range(10):
	ans += s[i] * num
	if i + 1 == temp:
		num -= 1
print(ans)


def func(n):
	if n == 1:
		return 'codeforces'
	curr = 1
	for i in range(2, 41):
		for j in range(1, 11):
			curr = i ** j * (i - 1) ** (10 - j)
			if curr >= n:
				return sec(i, j)

def sec(i, j):
	res = ''
	s = 'codeforces'
	rem = 10 - j
	for k in range(rem):
		res += s[k] * (i - 1)
	for k in range(rem, 10):
		res += s[k] * i
	return res
n = int(input())
print(func(n))


import sys
n = int(input())
k = int(n ** 0.1)
index = 0
num = k ** 10
while num < n:
	index += 1
	num *= (k + 1) / k
array = [char for char in 'codeforces']
for i in range(index):
	char = array[i]
	sys.stdout.write(char * (k + 1))
for i in range(index, 10):
	char = array[i]
	sys.stdout.write(char * k)


def count(a, b):
	m = len(a)
	n = len(b)
	lookup = [[0] * (n + 1) for i in range(m + 1)]
	for i in range(n + 1):
		lookup[0][i] = 0
	for i in range(m + 1):
		lookup[i][0] = 1
	for i in range(1, m + 1):
		for j in range(1, n + 1):
			if a[i - 1] == b[j - 1]:
				lookup[i][j] = lookup[i - 1][j - 1] + lookup[i - 1][j]
			else:
				lookup[i][j] = lookup[i - 1][j]
	return lookup[m][n]
s = 'codeforces'
ans = []
ch = []
y = list(s)
a = [1] * len(y)
for k in range(40):
	for i in range(len(a)):
		a[i] += 1
		d = []
		for j in range(len(s)):
			d.append(a[j] * y[j])
		e = ''.join(d)
		ch.append(e)
		f = count(e, s)
		if f <= 10 ** 16:
			ans.append(f)
		if f > 10 ** 16:
			ans.append(f)
			break
k = int(input())
if k == 1:
	print(s)
else:
	for i in range(len(ans)):
		if ans[i] >= k:
			print(ch[i])
			break


k = int(input())
s = 'codeforces'
cnt = 1
obj = {}
for i in range(len(s)):
	obj[i] = 1
cur = 2
ind = 0
while cnt < k:
	cnt /= cur - 1
	cnt *= cur
	cnt = int(cnt)
	obj[ind] = cur
	ind += 1
	if ind == len(s):
		cur += 1
		ind = 0
ans = ''
for i in range(len(s)):
	for j in range(obj[i]):
		ans += s[i]
print(ans)


k = int(input())
rt = k ** (1 / 10)
rt = int(rt)
arr = []
mul = 1
for i in range(10):
	arr.append(rt)
	mul *= rt
ind = 0
while k > mul:
	arr[ind] += 1
	mul = mul // (arr[ind] - 1) * arr[ind]
	ind += 1
	if ind == 10:
		ind = 0
s = 'codeforces'
res = ''
for i in range(10):
	for j in range(arr[i]):
		res += s[i]
print(res)


k = int(input())
s = list('codeforces')
(l, r) = (0, 0)
for i in range(1, 42):
	p = pow(i, 10)
	if p >= k:
		r = i
		break
	else:
		l = i
for i in range(0, 11):
	t = pow(r, i) * pow(l, 10 - i)
	if t >= k:
		ans = ''
		for j in range(len(s)):
			if j < i:
				ans += s[j] * r
			else:
				ans += s[j] * l
		print(ans)
		break


n = int(input())
s = 'codeforces'
freq = 10 * [1]
prod = 1
temp = 0
while prod < n:
	freq[temp] += 1
	temp = (temp + 1) % 10
	prod = 1
	for i in freq:
		prod *= i
for i in range(10):
	print(s[i] * freq[i], end='')


n = int(input())
a = [1] * 10
s = 'codeforces'
ans = 1
i = 0
while ans < n:
	ans = ans // a[i]
	a[i] = a[i] + 1
	ans *= a[i]
	i = (i + 1) % 10
curr = ''
for i in range(0, 10):
	curr += s[i] * a[i]
print(curr)


import math
t = int(input())
u = 'codeforces'
a = [1] * 10
prod = 1
i = 0
while prod < t:
	prod = prod // a[i] * (a[i] + 1)
	a[i] += 1
	i = (i + 1) % 10
s = ''
for i in range(10):
	s += u[i] * a[i]
print(s)


k = int(input())
a = [1] * 10
mul = 1
x = 0
while mul < k:
	i = a[x % 10]
	mul = mul // i
	a[x % 10] += 1
	mul *= a[x % 10]
	x += 1
str1 = 'codeforces'
for i in range(10):
	for j in range(0, a[i]):
		print(str1[i], end='')


from sys import stdin, exit, setrecursionlimit
from collections import deque
setrecursionlimit(10000000)
from math import *
from collections import deque
input = stdin.readline
lmi = lambda : list(map(int, input().split()))
mi = lambda : map(int, input().split())
si = lambda : input().strip('\n')
ssi = lambda : input().strip('\n').split()
n = int(input())
s = 'codeforces'
amt = [1 for i in range(10)]
tmp = 1
i = 0
while tmp < n:
	tmp //= amt[i % 10]
	amt[i % 10] += 1
	tmp *= amt[i % 10]
	i += 1
for i in range(10):
	print(s[i] * amt[i], end='')


k = int(input())
q = [1] * 10
r = 1
o = 0
while r < k:
	r //= q[o]
	q[o] += 1
	r *= q[o]
	o = (o + 1) % 10
s = 'codeforces'
print(''.join([s[i] * q[i] for i in range(10)]))


def find_ten_root(n):
	i = 0
	while i ** 10 < n:
		i += 1
	return i
n = int(input())
k = find_ten_root(n)
ans = [k] * 10
adad = k ** 10
p = 0
while adad > n:
	if adad * (ans[p] - 1) / ans[p] >= n:
		adad = adad * ((ans[p] - 1) / ans[p])
		ans[p] -= 1
		p = (p + 1) % 10
	else:
		break
a = 'codeforces'
p = 0
answer = ''
for i in a:
	answer += i * ans[p]
	p += 1
print(answer)


k = int(input())
t = int(pow(k, 1 / 10))
a = pow(t, 10)
l = [t for i in range(10)]
s = 'codeforces'
for i in range(10):
	if a < k:
		a = a // l[i]
		a = a * (l[i] + 1)
		l[i] = l[i] + 1
	print(s[i] * l[i], end='')


import math
ttt = int(input())
if ttt == 1:
	print('codeforces')
else:
	k = ttt ** 0.1
	a = [math.floor(k)] * 10
	balancer = 0
	for i in range(10):
		if math.ceil(k) ** balancer * math.floor(k) ** (10 - balancer) >= ttt:
			break
		balancer += 1
	for i in range(balancer):
		a[i] = math.ceil(k)
	print('c' * a[0] + 'o' * a[1] + 'd' * a[2] + 'e' * a[3] + 'f' * a[4] + 'o' * a[5] + 'r' * a[6] + 'c' * a[7] + 'e' * a[8] + 's' * a[9])


t = int(input())
a = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
flag = 0
for i in range(1, 41):
	if i ** 10 > t:
		i -= 1
		flag = 1
		break
	if i ** 10 == t:
		for j in a:
			print(i * j, end='')
		break
if flag == 1:
	for j in range(1, 11):
		c = i ** (10 - j) * (i + 1) ** j
		if c >= t:
			f = 10 - j
			break
	for k in range(10 - j):
		print(a[k] * i, end='')
	for k in range(j):
		print(a[10 - j + k] * (i + 1), end='')


k = int(input())
c = 'codeforces'
n = len(c)
t = int(k ** (1 / n))
s = t ** 10
a = [t] * n
i = 0
res = ''
while s < k:
	s /= t
	s *= t + 1
	a[i] += 1
	i += 1
for (idx, val) in enumerate(c):
	res += val * a[idx]
print(res)


import math
k = int(input())
num = math.floor(k ** 0.1)
tot = num ** 10
count = 0
while tot < k:
	tot = tot // num * (num + 1)
	count += 1
ind = [num] * (10 - count) + [num + 1] * count
ans = []
word = 'codeforces'
for i in range(10):
	for j in range(ind[i]):
		ans.append(word[i])
print(''.join(ans))


import sys
import math as mt
input = sys.stdin.buffer.readline
t = 1
for __ in range(t):
	k = int(input())
	s = 'codeforces'
	d = [1] * len(s)
	cnt = 1
	s1 = 's'
	j = 0
	mod = 10
	suma = [2] * 10
	k1 = 2
	cnt1 = 0
	while cnt < k:
		d[j % mod] += 1
		if suma[j % mod] != k1:
			cnt //= suma[j % mod]
			suma[j % mod] = k1
			cnt *= k1
		else:
			cnt *= 2
		j += 1
		cnt1 += 1
		if cnt1 == 10:
			cnt1 = 0
			k1 += 1
	for i in range(len(s)):
		for j in range(d[i]):
			print(s[i], end='')


k = int(input().strip())
res = [1] * 10
cur_pos = 0
cur_k = 1
while cur_k < k:
	r = res[cur_pos]
	res[cur_pos] += 1
	cur_k = cur_k // r * (r + 1)
	cur_pos += 1
	cur_pos = cur_pos % 10
print(''.join((ch * res[ind] for (ind, ch) in enumerate('codeforces'))))


def subsequence():
	k = int(input())
	x = int(k ** 0.1) + 1
	if k == 1:
		print('codeforces')
		return
	for i in range(0, 17):
		if (x - 1) ** (10 - i) * x ** i >= k:
			y = i
			break
	st = 'codeforces'
	li = list(st)
	ls = [x * i for i in li[:y]] + [(x - 1) * i for i in li[y:]]
	st = ''.join(ls)
	print(st)
subsequence()


import math
k = int(input())
base = math.floor(k ** 0.1)
repvec = [base for i in range(10)]
extra = (base + 1) / base
nextra = 0
curval = base ** 10
while curval < k:
	repvec[nextra] += 1
	nextra += 1
	curval *= extra
ans = ''
letter = 'codeforces'
for i in range(len(repvec)):
	ans += letter[i] * repvec[i]
print(ans)


from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
from math import sqrt, floor, factorial, gcd, log
from collections import deque, Counter, defaultdict
from itertools import permutations, combinations
from math import gcd
from bisect import bisect
input = lambda : sys.stdin.readline().rstrip('\r\n')
read = lambda : list(map(int, input().strip().split(' ')))

def solve():
	n = int(input())
	arr = list('codeforces')
	lis = [1] * 10
	m = 1
	i = 0
	while m < n:
		m //= lis[i % 10]
		lis[i % 10] += 1
		m *= lis[i % 10]
		i += 1
	arr = [arr[i] * lis[i] for i in range(10)]
	print(''.join(arr))
solve()


import math
n = int(input())
if n == 3:
	print('codeforcesss')
else:
	s = 'codeforces'
	c = -1
	for i in range(1, 40):
		for j in range(10):
			count = i ** (10 - j) * (i + 1) ** j
			if count >= n:
				break
		if count >= n:
			break
	s1 = ''
	l = 0
	for k in range(10 - j):
		s1 += s[l] * i
		l += 1
	for k in range(j):
		s1 += s[l] * (i + 1)
		l += 1
	print(s1)


for _ in range(1):
	k = int(input())
	i = 1
	if k == 1:
		print('codeforces')
		continue
	while True:
		if i ** 10 >= k:
			break
		i += 1
	ans = i - 1
	l = ans ** 10
	for i in range(10):
		if l // ans * (ans + 1) >= k:
			break
		else:
			l = l // ans * (ans + 1)
	kk = i
	f = list('codeforces')
	for i in range(10):
		if i <= kk:
			print(f[i] * (ans + 1), end='')
		else:
			print(f[i] * ans, end='')


n = int(input())
num = [1 for i in range(10)]
po = 1
i = 0
while po < n:
	k = i % 10
	num[k] += 1
	co1 = 0
	ke = num[0]
	for j in range(10):
		if num[j] == ke:
			co1 += 1
	rem = 10 - co1
	p1 = pow(ke, co1)
	p2 = pow(ke - 1, rem)
	po = p1 * p2
	i += 1
st = 'codeforces'
for i in range(10):
	print(st[i] * num[i], end='')
print()


import math

def dtod(a):
	s = ''
	while a != 0:
		s += str(a % 2)
		a = int(a / 2)
	return s[::-1]

def _8_(a):
	return a[0] * a[1] * a[2] * a[3] * a[4] * a[5] * a[6] * a[7] * a[8] * a[9]
q = int(input())
a = [1] * 10
i = 0
while _8_(a) < q:
	a[i] += 1
	i += 1
	if i == 10:
		i = 0
print('c' * a[0] + 'o' * a[1] + 'd' * a[2] + 'e' * a[3] + 'f' * a[4] + 'o' * a[5] + 'r' * a[6] + 'c' * a[7] + 'e' * a[8] + 's' * a[9])


from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip

def main():
	k = int(input())
	val = [1] * 10
	s = 'codeforces'
	prod = 1
	while prod < k:
		for i in range(10):
			val[i] += 1
			prod /= val[i] - 1
			prod *= val[i]
			if prod >= k:
				break
	for i in range(10):
		while val[i] > 0:
			print(s[i], end='')
			val[i] -= 1
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


from math import *
k = int(input())
s = 'codeforces'
l = [1] * 10
if k == 1:
	print(s)
else:
	i = 1
	c = 0
	n = 10
	while i < k:
		i = i // l[c] * (l[c] + 1)
		l[c] = l[c] + 1
		c = c + 1
		if c == 10:
			c = 0
	a = ''
	for i in range(10):
		a = a + s[i] * l[i]
	print(a)


k = int(input())
arr = [1] * 11
pro = 1
i = 1
while pro < k:
	if i == 11:
		i = 1
	pro = pro / arr[i]
	arr[i] = arr[i] + 1
	pro = pro * arr[i]
	i = i + 1
str = 'codeforces'
ans = ''
for i in range(1, 11):
	for j in range(1, arr[i] + 1):
		ans = ans + str[i - 1]
print(ans)


k = int(input())
repeat = k ** 0.1
low = int(repeat)
high = int(repeat + 1)
if low ** 10 >= k:
	print(''.join([x * low for x in 'codeforces']))
else:
	low_count = 9
	high_count = 1
	while low ** low_count * high ** high_count < k:
		low_count -= 1
		high_count += 1
	print(''.join([x * low for x in 'codeforces'[:low_count]] + [x * high for x in 'codeforces'[low_count:]]))


s = 'codeforces'
a = [1] * len(s)
(ans, cp, n) = (1, 0, len(s))
k = int(input())
while ans < k:
	ans = ans // a[cp]
	a[cp] += 1
	ans *= a[cp]
	cp = (cp + 1) % n
print(''.join([s[x] * y for (x, y) in enumerate(a)]))


n = int(input())
s = 'codeforces'
l = [1] * 10
w = 1
while w < n:
	for i in range(len(l)):
		w //= l[i]
		l[i] += 1
		w *= l[i]
		if w >= n:
			break
s1 = ''
for (i, x) in enumerate(s):
	s1 += x * l[i]
print(s1)


n = int(input())
if n == 1:
	print('codeforces')
else:
	a = [0] * 10
	s = 'codeforces'
	cnt = 1
	i = 0
	while n > cnt:
		a[i] += 1
		i = (i + 1) % 10
		cnt = 1
		for j in range(10):
			cnt = cnt * a[j]
	for i in range(10):
		print(s[i] * a[i], end='')


import copy
s = 'codeforces'
k = int(input())
a = [1] * 10
c = copy.copy(a)
t = 1
i = 0
while t < k:
	t = t // a[i] * (a[i] + 1)
	a[i] += 1
	c[i] += 1
	i = (i + 1) % 10
ans = ''
for i in range(10):
	ans += s[i] * c[i]
print(ans)


for i in range(1):
	n = int(input())
	t1 = 0
	t2 = 0
	s = 'codeforces'
	min1 = 1000000000
	cnt = 1
	l = []
	tmp1 = 0
	for i in range(10):
		l.append(1)
	while cnt < n:
		cnt = 1
		l[tmp1] += 1
		for i in range(10):
			cnt *= l[i]
		tmp1 += 1
		tmp1 = tmp1 % 10
	for i in range(10):
		print(s[i] * l[i], end='')


k = int(input())
p = 1
while p ** 10 <= k:
	p += 1
p -= 1
q = 0
while p ** (10 - q) * (p + 1) ** q < k:
	q += 1
ans = []
cf = list('codeforces')
for i in range(q):
	ans.extend((p + 1) * [cf[i]])
for i in range(10 - q):
	ans.extend(p * [cf[q + i]])
print(''.join(ans))


from sys import stdin, stdout, setrecursionlimit
from math import gcd, ceil, sqrt
from collections import Counter, deque
from bisect import bisect_left, bisect_right
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()
setrecursionlimit(100000)
mod = 1000000007

def check(arr):
	res = 1
	for i in arr:
		res *= i
	return res
s = 'codeforces'
arr = [1] * len(s)
k = ii1()
(ans, i) = (1, 0)
while ans < k:
	arr[i] += 1
	i += 1
	i %= len(s)
	ans = check(arr)
res = ''
for i in range(len(s)):
	res += s[i] * arr[i]
print(res)


import sys
import math
strInp = lambda : input().strip().split()
intInp = lambda : list(map(int, strInp()))
k = int(input())
init = 'codeforces'
code = {}
arr = [1] * len(init)
ans = 1
i = 0
while ans < k:
	arr[i] += 1
	_ans = 1
	for j in arr:
		_ans *= j
	ans = _ans
	i += 1
	i = i % 10
for i in range(len(arr)):
	print(init[i] * arr[i], end='')


n = int(input())
c = 'codeforces'
cnt = [1] * 10
now = 1
while now < n:
	for i in range(10):
		now /= cnt[i]
		cnt[i] += 1
		now *= cnt[i]
		if now >= n:
			break
s = []
for (i, j) in zip(cnt, c):
	s.append(i * j)
print(''.join(s))


k = int(input())
a = [1 for i in range(10)]
sum = 1
while sum < k:
	for i in range(10):
		if sum < k:
			sum //= a[i]
			a[i] += 1
			sum *= a[i]
		if sum >= k:
			break
s = 'codeforces'
out = ''
for i in range(10):
	out += s[i] * a[i]
print(out)


num = int(input())
str = 'codeforces'
arr = [1] * 10
c = 1
f = 0
while c < num:
	for i in range(10):
		f += 1
		c = c / arr[i]
		f += 1
		c = c * (arr[i] + 1)
		f += 1
		arr[i] += 1
		f += 1
		if c >= num:
			break
for i in range(10):
	f += 1
	print(str[i] * arr[i], end='')


def mul(a):
	r = 1
	for item in a:
		r *= item
	return r
m = int(input())
n = [0] * 10
a = 0
while a < m:
	for i in range(10):
		n[i] += 1
		a = mul(n)
		if a >= m:
			break
sol = ''
for _ in range(n[0]):
	sol += 'c'
for _ in range(n[1]):
	sol += 'o'
for _ in range(n[2]):
	sol += 'd'
for _ in range(n[3]):
	sol += 'e'
for _ in range(n[4]):
	sol += 'f'
for _ in range(n[5]):
	sol += 'o'
for _ in range(n[6]):
	sol += 'r'
for _ in range(n[7]):
	sol += 'c'
for _ in range(n[8]):
	sol += 'e'
for _ in range(n[9]):
	sol += 's'
print(sol)


n = int(input())
word = 'codeforces'
outstr = ''
arr = [1] * 10
combinations = 1
time = 1
i = 0
while combinations < n:
	arr[i] += 1
	combinations /= time
	combinations *= time + 1
	i += 1
	if i == 10:
		i = 0
		time += 1
for i in range(10):
	outstr += word[i] * arr[i]
print(outstr)


from math import log10, ceil
k = int(input())
num = [0] * 10
for i in range(10):
	num[i] = max(int(k ** 0.1), 1)
ans = 1
for i in range(10):
	ans *= num[i]
for i in range(10):
	if ans < k:
		ans = ans // num[i] * (num[i] + 1)
		num[i] += 1
s = 'codeforces'
for i in range(10):
	print(s[i] * num[i], end='')


import sys
_INPUT_LINES = sys.stdin.read().splitlines()
input = iter(_INPUT_LINES).__next__
t = int(input())
s = 'codeforces'
arr = [1] * 10
cur = 1
i = 0
while cur < t:
	pos = i % 10
	arr[pos] += 1
	cur = 1
	for j in range(10):
		cur *= arr[j]
	i += 1
ans = ['']
for i in range(10):
	ans.append(s[i] * arr[i])
print(''.join(ans))


from fractions import Fraction
from collections import defaultdict
import math
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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))

def input():
	return sys.stdin.readline().rstrip('\r\n')
k = int(input())
s = 'codeforces'
n = int(k ** 0.1)
c = n ** 10
for i in s:
	c1 = max(1, n)
	if c < k:
		c /= c1
		c *= c1 + 1
		c1 += 1
	print(i * c1, end='')
print()


def pr(a):
	ans = 1
	for j in range(10):
		ans *= a[j]
	return ans
k = int(input())
mas = [1 for t in range(10)]
i = 0
while pr(mas) < k:
	mas[i] += 1
	i += 1
	i = i % 10
sl = 'codeforces'
otv = ''
for i in range(10):
	otv += sl[i] * mas[i]
print(otv)


import math
n = int(input())
s = 'codeforces'
opti = -1
optj = -1
anss = ''
chk = -1
ans = int(10 ** 18)
for i in range(1, 100):
	for j in range(1, 100):
		if i ** 10 >= n:
			if 10 * i < ans:
				chk = 10
				ans = min(10 * i, ans)
				opti = i
				optj = j
		if i ** 9 * j >= n:
			if 9 * i + j < ans:
				chk = 9
				ans = min(9 * i + j, ans)
				opti = i
				optj = j
		if i ** 8 * j ** 2 >= n:
			if 8 * i + 2 * j < ans:
				chk = 8
				ans = min(8 * i + j * 2, ans)
				opti = i
				optj = j
		if i ** 7 * j ** 3 >= n:
			if 7 * i + 3 * j < ans:
				chk = 7
				ans = min(7 * i + 3 * j, ans)
				opti = i
				optj = j
		if i ** 6 * j ** 4 >= n:
			if 6 * i + 4 * j < ans:
				chk = 6
				ans = min(6 * i + 4 * j, ans)
				opti = i
				optj = j
		if i ** 5 * j ** 5 >= n:
			if 5 * i + 5 * j < ans:
				chk = 5
				ans = min(5 * i + 5 * j, ans)
				opti = i
				optj = j
i = opti
j = optj
for m in range(chk):
	for l in range(i):
		anss += s[m]
for m in range(chk, len(s)):
	for l in range(j):
		anss += s[m]
print(anss)


y = int(input())
a = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
i = 0
while True:
	x = 'c' * a[0] + 'o' * a[1] + 'd' * a[2] + 'e' * a[3] + 'f' * a[4] + 'o' * a[5] + 'r' * a[6] + 'c' * a[7] + 'e' * a[8] + 's' * a[9]
	if a[0] * a[1] * a[2] * a[3] * a[4] * a[5] * a[6] * a[7] * a[8] * a[9] >= y:
		print(x)
		break
	else:
		if i > 9:
			i = 0
		a[i] += 1
	i += 1


k = int(input())
s = 'codeforces'
key = 0
for i in range(1, 41):
	if pow(i - 1, 10) <= k <= pow(i, 10):
		key = i
		break
you = 0
for j in range(1, 11):
	if k <= pow(key, j) * pow(key - 1, 10 - j):
		you = j
		break
reuslt = ''
for i in range(you):
	t = s[i] * key
	reuslt += t
for i in range(you, len(s)):
	reuslt += s[i] * (key - 1)
print(reuslt)


import math

def cal(ss):
	c = 1
	for j in range(10):
		c *= len(ss[j])
	return c
n = int(input())
if n != 0:
	nn = math.floor(math.log2(n))
	init = 'codeforces'
	s = list('codeforces')
	c = 0
	lop = 1 + nn // 10
	i = 0
	while i < 10:
		s[i] = list(s[i]) * lop
		i += 1
	i = 0
	while cal(s) < n:
		s[i] = s[i] + list(init[i])
		i = (i + 1) % 10
	i = 0
	while i < 10:
		s[i] = ''.join(s[i])
		i += 1
	print(''.join(s))


t = int(input())
s = 'codeforces'
x = tot = 1
start = 0
a = {}
for i in range(10):
	a[i] = 1
while x < t:
	temp = x // a[start % 10]
	a[start % 10] += 1
	x = a[start % 10] * temp
	start += 1
s1 = ''
for i in range(10):
	s1 += s[i] * a[i]
print(s1)


s = 'codeforces'
ans = 0
n = int(input())
z = [1] * 10
y = [2] + [1] * 9
(Z, Y) = (1, 1)
ans = []
for i in range(10 * 100):
	if Z >= n:
		ans = sum(z)
		break
	p = z[i % 10]
	z[i % 10] += 1
	Z //= p
	Z *= p + 1
a = []
for j in range(10):
	a += [s[j] * z[j]]
print(''.join(a))


import math
from collections import defaultdict, Counter, deque
INF = float('inf')

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a

def primeFactor(n):
	if n % 2 == 0:
		return 2
	i = 3
	while i ** 2 <= n:
		if n % i == 0:
			return i
		i += 1
	return n

def main():
	n = int(input())
	freq = [1 for i in range(10)]
	s = 'codeforces'
	ans = 1
	i = 0
	while ans < n:
		old = freq[i]
		freq[i] += 1
		ans = ans / old * freq[i]
		i = (i + 1) % len(s)
	res = ''
	for i in range(10):
		res += s[i] * freq[i]
	print(res)
t = 1
for _ in range(t):
	main()


dic = {0: 'c', 1: 'o', 2: 'd', 3: 'e', 4: 'f', 5: 'o', 6: 'r', 7: 'c', 8: 'e', 9: 's'}
k = int(input())
count = [1] * 10
al = 1
index = 0
now = 2
while al < k:
	al //= now - 1
	al *= now
	count[index] += 1
	if index == 9:
		now += 1
	index = (index + 1) % 10
res = []
for i in range(10):
	res += dic[i] * count[i]
print(''.join(res))


k = int(input())
ans = 'codeforces'
ans1 = ''
if k > 1:
	base = 1
	while (base + 1) ** 10 < k:
		base += 1
	tot = base ** 10
	extra = 0
	while tot < k:
		tot /= base
		tot *= base + 1
		extra += 1
	for i in ans:
		if extra:
			ans1 += i * (base + 1)
			extra -= 1
		else:
			ans1 += i * base
	print(ans1)
else:
	print(ans)


from sys import stdin
n = int(stdin.readline())
string = 'codeforces'
a = int(n ** 0.1)
cur = a ** 10
for i in 'codeforces':
	print(i * (a + (cur < n)), end='')
	cur = cur // a
	n /= a + 1


import math
k = int(input())
x = int(math.pow(k, 0.1))
temp = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
n = int(math.pow(x, 10))
if n == k:
	for i in temp:
		for j in range(x):
			print(i, end='')
else:
	x1 = k / math.pow(x, 10)
	x2 = (x + 1) / x
	a = int(math.log(x1, x2))
	x1 = math.pow(x + 1, a) * math.pow(x, 10 - a)
	if x1 < k:
		a += 1
	count = 0
	for i in temp:
		for j in range(x):
			print(i, end='')
		count += 1
		if count <= a:
			print(i, end='')
print()


import sys
input = sys.stdin.readline

def int_array():
	return list(map(int, input().strip().split()))

def str_array():
	return input().strip().split()

def lower_letters():
	lowercase = [chr(i) for i in range(97, 97 + 26)]
	return lowercase

def upper_letters():
	uppercase = [chr(i) for i in range(65, 65 + 26)]
	return uppercase
k = int(input())
x = 1
while True:
	if x ** 10 == k:
		break
	if x ** 10 > k:
		x -= 1
		break
	x += 1
indexes = [x] * 10
curr = x ** 10
thing = 0
while curr < k:
	thing += 1
	curr = curr // x
	curr *= x + 1
i = 0
while thing != 0:
	indexes[i] += 1
	thing -= 1
	i += 1
ans = []
s = 'codeforces'
for i in range(10):
	for _ in range(indexes[i]):
		ans.append(list(s)[i])
ans = ''.join(ans)
print(ans)


import sys, math
input = lambda : sys.stdin.readline().rstrip()

def check(m):
	ans = 1
	for i in range(10):
		ans *= m[i]
	return ans
a = int(input())
mas = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
cur = 0
while check(mas) < a:
	mas[cur] += 1
	cur += 1
	cur %= 10
print('c' * mas[0] + 'o' * mas[1] + 'd' * mas[2] + 'e' * mas[3] + 'f' * mas[4] + 'o' * mas[5] + 'r' * mas[6] + 'c' * mas[7] + 'e' * mas[8] + 's' * mas[9])


def mul(i_listt):
	m = 1
	for i in i_listt:
		m *= i
	return m
k = int(input())
i_list = [0] + [1] * 9
c = 0
while True:
	i_list[c] += 1
	if mul(i_list) < k:
		c += 1
		c %= 10
	else:
		break
str = ''
for ii in range(len(i_list)):
	str += 'codeforces'[ii] * i_list[ii]
print(str)


k = int(input())
val = [1 for i in range(10)]
s = 'codeforces'
i = 0
prod = 1
while prod < k:
	prod //= val[i]
	val[i] += 1
	prod *= val[i]
	i = (i + 1) % 10
for i in range(10):
	print(s[i] * val[i], end='')
print('')


k = int(input())
counter = 1
torf = True
while torf == True:
	if counter ** 10 >= k:
		torf = False
	else:
		counter += 1
for i in range(10):
	if (counter - 1) ** (9 - i) * counter ** (i + 1) >= k:
		j = 9 - i
		break
codeforces = 'codeforces'
string = ''
for i in range(10):
	if i <= j - 1:
		string += codeforces[i] * (counter - 1)
	else:
		string += codeforces[i] * counter
print(string)


n = int(input())
s = 'codeforces'
l = [1] * 10
count = 1
while count < n:
	for i in range(10):
		l[i] += 1
		count = int(count / (l[i] - 1))
		count = count * l[i]
		if count >= n:
			break
for i in range(10):
	print(s[i] * l[i], end='')
print()


a = int(input())
x = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

def multiply():
	ans = 1
	for i in range(10):
		ans = ans * x[i]
	return ans
tt = False
while True:
	for i in range(10):
		if multiply() >= a:
			tt = True
			break
		x[i] += 1
	if tt:
		break
ans = 0
for i in range(10):
	if i == 0:
		for j in range(x[i]):
			print('c', end='')
	if i == 1:
		for j in range(x[i]):
			print('o', end='')
	if i == 2:
		for j in range(x[i]):
			print('d', end='')
	if i == 3:
		for j in range(x[i]):
			print('e', end='')
	if i == 4:
		for j in range(x[i]):
			print('f', end='')
	if i == 5:
		for j in range(x[i]):
			print('o', end='')
	if i == 6:
		for j in range(x[i]):
			print('r', end='')
	if i == 7:
		for j in range(x[i]):
			print('c', end='')
	if i == 8:
		for j in range(x[i]):
			print('e', end='')
	if i == 9:
		for j in range(x[i]):
			print('s', end='')


import math
k = int(input())
s = 1

def req(x, l):
	for i in range(1, 51):
		s = i
		if i ** l >= x:
			break
	return s
a = 'codeforces'
ans = ''
p = 1
d = {}
for i in range(len(a)):
	d[i] = 1
for i in range(10):
	d[i] = req(k, 10 - i)
	k = math.ceil(k / d[i])
for i in range(10):
	ans += a[i] * d[i]
print(ans)


import sys
k = int(input())
if k == 1:
	print('codeforces')
	sys.exit()
a = [1] * 10
for i in range(1, 40):
	for j in range(10):
		if k > (i + 1) ** j * i ** (10 - j):
			a[j] += 1
		else:
			break
s = ''
arr = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
for i in range(10):
	s += arr[i] * a[i]
print(s)


INT_MAX = 10 ** 11 + 7
MOD = 10 ** 9 + 7

def INPUT():
	return list((int(i) for i in input().split()))

def LIST_1D_ARRAY(n):
	return [0 for _ in range(n)]

def LIST_2D_ARRAY(m, n):
	return [[0 for _ in range(n)] for _ in range(m)]
import math
n = int(input())
s = 'codeforces'
dp = list(s)
i = 1
while i <= 50:
	if i ** 10 >= n:
		break
	i += 1
max = i
if i ** 10 == n:
	for k in range(len(dp)):
		print(dp[k] * i, end='')
else:
	i -= 1
	y = 1
	while i ** (10 - y) * max ** y < n:
		y += 1
	for k in range(10 - y):
		print(dp[k] * i, end='')
	for k in range(10 - y, 10):
		print(dp[k] * max, end='')


k = int(input())
ex = 0
while k > ex ** 10:
	ex += 1
i = 0
j = 10
while ex ** i * (ex - 1) ** j < k:
	i += 1
	j -= 1
ip = 'codeforces'
op = []
for x in range(i):
	op.extend([ip[x]] * ex)
for x in range(j):
	op.extend([ip[i + x]] * (ex - 1))
print(''.join(op))


k = int(input())
out = ''
t = list('codeforces')
d = [1] * 10
m = 1
i = 0
while m < k:
	d[i] += 1
	i = (i + 1) % 10
	m = 1
	for j in range(10):
		m *= d[j]
out = ''
for i in range(10):
	out += t[i] * d[i]
print(out)


def p(a):
	k = 1
	for i in a:
		k = k * i
	return k
k = int(input())
s = 'codeforces'
a = [1 for i in range(10)]
c = 1
i = 0
while c < k:
	a[i % 10] += 1
	c = p(a)
	i = i + 1
ans = ''
for i in range(len(a)):
	ans = ans + s[i] * a[i]
print(ans)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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 math import gcd, ceil

def pre(s):
	n = len(s)
	pi = [0] * n
	for i in range(1, n):
		j = pi[i - 1]
		while j and s[i] != s[j]:
			j = pi[j - 1]
		if s[i] == s[j]:
			j += 1
		pi[i] = j
	return pi

def prod(a):
	ans = 1
	for each in a:
		ans = ans * each
	return ans

def lcm(a, b):
	return a * b // gcd(a, b)

def binary(x, length=16):
	y = bin(x)[2:]
	return y if len(y) >= length else '0' * (length - len(y)) + y
for _ in range(int(input()) if not True else 1):
	n = int(input())
	from math import log2
	v = [1] * 10
	cnt = 0
	while prod(v) < n:
		v[cnt % 10] += 1
		cnt += 1
	ans = ''
	for i in range(10):
		ans += [k for k in 'codeforces'][i] * v[i]
	print(ans)


from bisect import *
from collections import *
from math import *
from heapq import *
from typing import List
from itertools import *
from operator import *
from functools import *

@lru_cache(None)
def fact(x):
	if x < 2:
		return 1
	return fact(x - 1) * x

@lru_cache(None)
def per(i, j):
	return fact(i) // fact(i - j)

@lru_cache(None)
def com(i, j):
	return per(i, j) // fact(j)

def linc(f, t, l, r):
	while l < r:
		mid = (l + r) // 2
		if t > f(mid):
			l = mid + 1
		else:
			r = mid
	return l

def rinc(f, t, l, r):
	while l < r:
		mid = (l + r + 1) // 2
		if t < f(mid):
			r = mid - 1
		else:
			l = mid
	return l

def ldec(f, t, l, r):
	while l < r:
		mid = (l + r) // 2
		if t < f(mid):
			l = mid + 1
		else:
			r = mid
	return l

def rdec(f, t, l, r):
	while l < r:
		mid = (l + r + 1) // 2
		if t > f(mid):
			r = mid - 1
		else:
			l = mid
	return l

def isprime(n):
	for i in range(2, int(n ** 0.5) + 1):
		if n % i == 0:
			return False
	return True

def power2(n):
	while not n & 1:
		n >>= 1
	return n == 1
k = int(input())
mi = int(pow(k, 0.1))
t = (mi + 1) / mi
res = mi ** 10
a = 0
while res < k:
	res *= t
	a += 1
ans = ''
st = 'codeforces'
for i in range(10 - a):
	ans += st[i] * mi
for i in range(10 - a, 10):
	ans += st[i] * (mi + 1)
print(ans)


import math

def multiply_manual(iterable):
	prod = 1
	for x in iterable:
		prod *= x
	return prod
a = int(input())
kk = a ** 0.1
l = math.ceil(kk)
c = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
d = [l] * 10
s = ''
ans = d[:]
p = multiply_manual(d)
i = 0
while p >= a:
	ans = d[:]
	temp = d[i] - 1
	d[i] = temp
	i += 1
	i = i % 10
	p = multiply_manual(d)
	if p < a:
		break
for i in range(10):
	s += c[i] * ans[i]
print(s)


import math
t = int(input())
string = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
i = 0
ans = 1
while ans < t:
	string[i % 10] += string[i % 10][-1]
	i += 1
	ans = 1
	for j in string:
		ans *= len(j)
print(''.join(string))


import concurrent.futures
import multiprocessing
import os
import sys
from io import BytesIO, IOBase

def main():
	k = int(input())
	string = 'codeforces'
	if k == 1:
		print(string)
	else:
		(sum_, t) = (1, 0)
		list_ = [1 for i in range(10)]
		while sum_ < k:
			list_[t] += 1
			t = (t + 1) % 10
			sum_ = 1
			for i in range(10):
				sum_ *= list_[i]
		for i in range(10):
			for _ in range(list_[i]):
				print(string[i], end='')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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')
main()


arr = [1] * 10
word = list('codeforces')
res = 1
k = int(input())
i = 0
while res < k:
	res //= arr[i]
	arr[i] += 1
	res *= arr[i]
	i = (i + 1) % 10
output = ''
for i in range(10):
	output += word[i] * arr[i]
print(output)


str = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
n = int(input())
list = [1] * 10
multiplier = 1
i = 0
while multiplier < n:
	a = list[i % 10]
	list[i % 10] += 1
	multiplier = multiplier * list[i % 10] // a
	i += 1
for i in range(0, 10):
	print(str[i] * list[i], end='')


k = int(input())
a = [1 for i in range(10)]
pro = 1
for i in range(2, 50):
	if pro >= k:
		break
	for j in range(10):
		pro //= a[j]
		pro *= i
		a[j] = i
		if pro >= k:
			break
	if pro >= k:
		break
s = 'codeforces'
ans = ''
for i in range(10):
	ans += s[i] * a[i]
print(ans)


from collections import defaultdict as dd
from collections import deque
import bisect
import heapq

def ri():
	return int(input())

def rl():
	return list(map(int, input().split()))

def solve():
	n = ri()
	word = 'codeforces'
	mult = [1] * 10
	count = 1
	i = -1
	while count < n:
		i = (i + 1) % 10
		mult[i] += 1
		count = count // (mult[i] - 1) * mult[i]
	out = ''
	for i in range(10):
		out += word[i] * mult[i]
	print(out)
mode = 's'
if mode == 'T':
	t = ri()
	for i in range(t):
		solve()
else:
	solve()


k = int(input())
ans = 1
s = 'codeforces'
a = [1 for i in range(10)]
last = 0
while ans < k:
	ans = 1
	a[last] += 1
	if last == 9:
		last = 0
	else:
		last += 1
	for i in range(10):
		ans = ans * a[i]
for i in range(10):
	for j in range(a[i]):
		print(s[i], end='')


import sys
input = sys.stdin.readline
n = int(input())
s = 'codeforces'
count = 1
l = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
j = 0

def mult(l):
	s1 = 1
	for i in l:
		s1 = s1 * i
	return s1
while count < n:
	j = j % len(s)
	l[j] += 1
	j += 1
	count = mult(l)
ans = ''
for i in range(len(l)):
	ans += s[i] * l[i]
print(ans)


k = int(input())
i = 1
n = 10
while i ** n < k:
	i += 1
t = [i] * n

def prod(t):
	res = 1
	for i in t:
		res *= i
	return res
kk = 0
while True:
	tt = [t[_] if _ != kk else t[_] - 1 for _ in range(n)]
	kk += 1
	if prod(tt) < k:
		break
	t = tt
w = 'codeforces'
print(''.join([w[i] * t[i] for i in range(n)]))


n = int(input())
cur = 1
i = 1
while cur < n:
	if i % 10 == 0:
		cur = (1 + i // 10) ** 10
	else:
		cur = cur * (2 + i // 10) // (1 + i // 10)
	i += 1
i -= 1
ans = ['c'] * (i // 10 + 1)
if i % 10 > 0:
	ans.append('c')
ans += ['o'] * (i // 10 + 1)
if i % 10 > 1:
	ans.append('o')
ans += ['d'] * (i // 10 + 1)
if i % 10 > 2:
	ans.append('d')
ans += ['e'] * (i // 10 + 1)
if i % 10 > 3:
	ans.append('e')
ans += ['f'] * (i // 10 + 1)
if i % 10 > 4:
	ans.append('f')
ans += ['o'] * (i // 10 + 1)
if i % 10 > 5:
	ans.append('o')
ans += ['r'] * (i // 10 + 1)
if i % 10 > 6:
	ans.append('r')
ans += ['c'] * (i // 10 + 1)
if i % 10 > 7:
	ans.append('c')
ans += ['e'] * (i // 10 + 1)
if i % 10 > 8:
	ans.append('e')
ans += ['s'] * (i // 10 + 1)
if i % 10 > 9:
	ans.append('s')
q = ''
for x in ans:
	q += x
print(q)


import functools
import operator
k = int(input())
K = [1] * 10
idx = 0
while functools.reduce(operator.mul, K) < k:
	K[idx] += 1
	idx = (idx + 1) % 10
s = [c * K[i] for (i, c) in enumerate('codeforces')]
print(''.join(s))


k = int(input())
res = 1
c = 1
counter = 0
while res < k:
	if counter != 10:
		counter += 1
		res //= c
		res *= c + 1
	else:
		counter = 1
		c += 1
		res //= c
		res *= c + 1
a = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
i = 0
ans = ''
if counter == 10:
	c += 1
	counter = 0
while i < counter:
	ans += a[i] * (c + 1)
	i += 1
while i < 10:
	ans += a[i] * c
	i += 1
print(ans)


T = 1
for i in range(T):
	k = int(input())
	ans = 1
	ansS = 'c,o,d,e,f,o,r,c,e,s'
	ansS = ansS.split(',')
	ansC = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
	j = 0
	while ans < k:
		v = ansC[j]
		ansC[j] += 1
		ans = ans / v * (v + 1)
		j += 1
		if j > 9:
			j = 0
	for j in range(10):
		ansS[j] = ansS[j] * ansC[j]
	print(''.join(ansS))


arr = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
k = int(input())
n = int(k ** (1 / 10))
s = n ** 10
t = 0
while s < k:
	s = s / n
	s = s * (n + 1)
	t += 1
for i in range(0, 10):
	if t > 0:
		for j in range(0, n + 1):
			print(arr[i], end='')
		t -= 1
	else:
		for j in range(0, n):
			print(arr[i], end='')
print()


import math, sys, bisect, heapq
from collections import defaultdict, Counter, deque
from itertools import groupby, accumulate
from functools import lru_cache
int1 = lambda x: int(x) - 1
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
aj = lambda : list(map(int, input().split()))

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def Y(c):
	print(['NO', 'YES'][c])

def y(c):
	print(['no', 'yes'][c])

def Yy(c):
	print(['No', 'Yes'][c])
s = 'codeforces'
dp = [1] * 10
k = int(input())
count = 1
i = 0
while True:
	if count >= k:
		break
	count //= dp[i]
	dp[i] += 1
	count *= dp[i]
	i += 1
	i %= 10
ans = ''
for (ii, i) in enumerate(dp):
	ans += s[ii] * i
print(ans)


import sys
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep='\n')

def II():
	return int(sys.stdin.readline())

def MI():
	return map(int, sys.stdin.readline().split())

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number):
	return [LI() for _ in range(rows_number)]

def SI():
	return sys.stdin.readline()[:-1]

def main():
	k = II()
	base = 1
	while base ** 10 < k:
		base += 1
	s = base ** 10
	cnt = 0
	while s // base * (base - 1) >= k:
		s = s // base * (base - 1)
		cnt += 1
	ans = ''
	st = 'codeforces'
	for i in range(cnt):
		ans += st[i] * (base - 1)
	for i in range(10 - cnt):
		ans += st[cnt + i] * base
	print(ans)
main()


def solve():
	K = int(input())
	minimum = 1
	for i in range(1, 42):
		if i ** 10 <= K:
			minimum = i
		else:
			break
	ans = [minimum] * 10
	prod = minimum ** 10
	i = 9
	while i >= 0:
		if prod >= K:
			break
		prod = prod // ans[i]
		ans[i] += 1
		prod *= ans[i]
		i -= 1
	cf = 'codeforces'
	ansString = ''
	for i in range(10):
		ansString += cf[i] * ans[i]
	return ansString

def main():
	print(solve())
main()


n = int(input())
t = int(n ** 0.1)
mv = t ** 10
for ch in 'codeforces':
	l = t + (mv < n)
	print(ch * l, end='')
	mv = mv // t * l


n = int(input())
a = [1] * 10
pro = 1
temp = 0
s = 'codeforces'
while pro < n:
	a[temp] += 1
	temp = (temp + 1) % 10
	pro = a[0]
	for i in range(1, 10):
		pro *= a[i]
for i in range(10):
	print(s[i] * a[i], end='')


import re
k = int(input())
s = 'codeforces'
n = len(s)
prod = 1
a = [1] * 10
it = 0
while prod < k:
	prod = prod // a[it] * (a[it] + 1)
	a[it] += 1
	it = (it + 1) % n
for i in range(n):
	for j in range(a[i]):
		print(s[i], end='')


def gns():
	return list(map(int, input().split()))
k = int(input())
for l in range(1, 100):
	if (l + 1) ** 10 > k:
		break
r = l + 1
for i in reversed(range(11)):
	if l ** i * r ** (10 - i) >= k:
		break
s = 'codeforces'
for j in range(10):
	if j < i:
		print(s[j] * l, end='')
	else:
		print(s[j] * r, end='')
print()


import sys
import bisect as b
import math
from collections import defaultdict as dd
input = sys.stdin.readline
mo = 10 ** 9 + 7

def cin():
	return map(int, sin().split())

def ain():
	return list(map(int, sin().split()))

def sin():
	return input()

def inin():
	return int(input())

def pref(a, n):
	pre = [0] * n
	pre[0] = a[0]
	for i in range(1, n):
		pre[i] = a[i] + pre[i - 1]
	return pre
FibArray = [0, 1]

def fibonacci(n):
	if n < 0:
		print('Incorrect input')
	elif n <= len(FibArray):
		return FibArray[n - 1]
	else:
		temp_fib = fibonacci(n - 1) + fibonacci(n - 2)
		FibArray.append(temp_fib)
		return temp_fib
n = inin()
dp = [0] * 400
dp[0] = 2
c = 1
fact = 2
for i in range(1, 400):
	if c == 10:
		c = 0
		fact = fact + 1
	if c < 10:
		dp[i] = dp[i - 1] * fact // (fact - 1)
	c += 1
po = b.bisect(dp, n)
if n not in dp and n != 1:
	po += 1
mul = po // 10
mod = po % 10
l = [1] * 10
s = 'codeforces'
for i in range(10):
	l[i] += mul
	if i < mod:
		l[i] += 1
for i in range(10):
	print(s[i] * l[i], end='')
print()


k = int(input())
s = 'codeforces'
l = [1 for i in range(0, 10)]
mul = 1
i = 0
while mul < k:
	a = l[i % 10]
	l[i % 10] += 1
	mul = mul * l[i % 10] // a
	i += 1
for i in range(10):
	print(s[i] * l[i], end='')


k = int(input())
n = int(k ** 0.1)
m = n ** 10
r = ''
for c in 'codeforces':
	r += c * (n + (m < k))
	m = m // n * (n + 1)
print(r)


import sys, os, io

def rs():
	return sys.stdin.readline().rstrip()

def ri():
	return int(sys.stdin.readline())

def ria():
	return list(map(int, sys.stdin.readline().split()))

def ws(s):
	sys.stdout.write(s + '\n')

def wi(n):
	sys.stdout.write(str(n) + '\n')

def wia(a):
	sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math as mt
from collections import deque

def main():
	z = [1, 1024, 59049, 1048576, 9765625, 60466176, 282475249, 1073741824, 3486784401, 10000000000, 25937424601, 61917364224, 137858491849, 289254654976, 576650390625, 1099511627776, 2015993900449, 3570467226624, 6131066257801, 10240000000000, 16679880978201, 26559922791424, 41426511213649, 63403380965376, 95367431640625, 141167095653376, 205891132094649, 296196766695424, 420707233300201, 590490000000000, 819628286980801, 1125899906842624, 1531578985264449, 2064377754059776, 2758547353515625, 3656158440062976, 4808584372417849, 6278211847988224, 8140406085191601, 10485760000000000]
	k = int(input())
	s = 'codeforces'
	nz = []
	mv = 0
	cn = 0
	for i in range(1, 40):
		if z[i] > k:
			nz = [i + 1] * 10
			mv = z[i]
			cn = i + 1
			break
	e = 0
	for i in range(1, 11):
		mv = mv / cn * (cn - 1)
		if mv < k:
			break
		else:
			e += 1
	ans = [cn - 1] * e + [cn] * (10 - e)
	for i in range(10):
		print(s[i] * ans[i], end='')

class FastReader(io.IOBase):
	newlines = 0

	def __init__(self, fd, chunk_size=1024 * 8):
		self._fd = fd
		self._chunk_size = chunk_size
		self.buffer = io.BytesIO()

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
			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, size=-1):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
			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()

class FastWriter(io.IOBase):

	def __init__(self, fd):
		self._fd = fd
		self.buffer = io.BytesIO()
		self.write = self.buffer.write

	def flush(self):
		os.write(self._fd, self.buffer.getvalue())
		(self.buffer.truncate(0), self.buffer.seek(0))

class FastStdin(io.IOBase):

	def __init__(self, fd=0):
		self.buffer = FastReader(fd)
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

class FastStdout(io.IOBase):

	def __init__(self, fd=1):
		self.buffer = FastWriter(fd)
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.flush = self.buffer.flush
sys.stdin = FastStdin()
sys.stdout = FastStdout()
main()


k = int(input())
n = int(k ** (1 / 10))
re = n ** 10
lo = 10
while re < k:
	re = re * (n + 1) // n
	lo = lo - 1
s = 'codeforces'
ans = ''
for i in range(lo):
	ans = ans + n * s[i]
for i in range(lo, 10):
	ans = ans + (n + 1) * s[i]
print(ans)


k = int(input())
a = [1] * 10
s = 'codeforces'
(i, c) = (0, 1)
s1 = ''
while c < k:
	c /= a[i]
	a[i] += 1
	c *= a[i]
	i = (i + 1) % 10
for j in range(10):
	s1 += s[j] * a[j]
print(s1)


n = int(input())
if n == 1:
	print('codeforces')
else:
	mul = 1
	arr = [1] * 10
	while mul < n:
		flag = 0
		for i in range(10):
			mul /= arr[i]
			arr[i] += 1
			if arr[i] * mul < n:
				mul *= arr[i]
			else:
				flag = 1
				break
		if flag == 1:
			break
	c = 'codeforces'
	ans = ''
	for i in range(10):
		ans += c[i] * arr[i]
	print(ans)


n = int(input())
t = int(n ** 0.1)
p = t ** 10
for c in 'codeforces':
	l = t + (p < n)
	print(c * l, end='')
	p = p // t * l


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import ceil, floor, gcd, sqrt, trunc, inf
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
mod = pow(10, 9) + 7
mod2 = 998244353

def data():
	return sys.stdin.readline().strip()

def out(var, end='\n'):
	sys.stdout.write(var + end)

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
n = int(data())
(s, temp) = (1, 0)
answer = 'codeforces'
arr = [1] * 10
while s < n:
	arr[temp] += 1
	temp = (temp + 1) % 10
	s = 1
	for i in range(10):
		s *= arr[i]
for i in range(10):
	for j in range(arr[i]):
		out(answer[i], end='')


k = int(input())
num = int(k ** 0.1)
s = 'codeforces'
for i in range(10):
	if num ** (10 - i) * (num + 1) ** i >= k:
		print(s[i] * num, end='')
	else:
		print(s[i] * (num + 1), end='')


import math
k = int(input())
A = [1 for i in range(10)]
pdt = 1
while pdt < k:
	for i in range(10):
		pdt = pdt // A[i]
		A[i] = A[i] + 1
		pdt = pdt * A[i]
		if pdt >= k:
			break
s = 'codeforces'
a = ''
for i in range(10):
	a = a + s[i] * A[i]
print(a)


k = int(input())
org = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
if k == 1:
	print('codeforces')
else:
	n = 1
	i = 2
	j = 1
	ans = ''
	ans2 = ''
	cont = True
	while cont:
		for s in range(1, 11):
			n = n * i // j
			if k <= n:
				dup = org[:s]
				dup2 = org[s:]
				for z in dup:
					ans += z * i
				for z in dup2:
					ans2 += z * j
				print(ans + ans2)
				cont = False
				break
		i += 1
		j += 1


import sys
from fractions import gcd
from math import ceil, sqrt, sin, pi, tan
from collections import defaultdict
read = sys.stdin.buffer.readline
import heapq
mi = lambda : map(int, read().split())
li = lambda : list(mi())
cin = lambda : int(read())
for _t in range(1):
	k = cin()
	pw = 1
	i = 1
	while pw < k:
		i += 1
		pw = pow(i, 10)
	ans = ''
	for el in 'codeforces':
		if pw // i * (i - 1) >= k:
			pw = pw // i * (i - 1)
			ans += el * (i - 1)
		else:
			ans += el * i
	print(ans)


from sys import stdin, stdout

def INI():
	return int(stdin.readline())

def INL():
	return [int(_) for _ in stdin.readline().split()]

def INS():
	return stdin.readline()

def MOD():
	return pow(10, 9) + 7

def OPS(ans):
	stdout.write(str(ans) + '\n')

def OPL(ans):
	[stdout.write(str(_) + ' ') for _ in ans]
	stdout.write('\n')
from math import log, ceil
n = INI()
kitna = int(pow(n, 0.1))
c = kitna ** 10
ans = ''
for _ in 'codeforces':
	if c < n:
		c = c // kitna * (kitna + 1)
		ans += _ * (kitna + 1)
	else:
		ans += _ * kitna
OPS(ans)


k = int(input())
c = int(k ** 0.1)
l = [c] * 10
p = c ** 10
ind = -1
while p < k:
	l[ind] += 1
	p //= c
	p *= l[ind]
	ind -= 1
for c in 'codeforces':
	print(c * l.pop(0), end='')
print()


from __future__ import division, print_function
import os, sys
import math
import collections
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().strip().split(' '))

def msi():
	return map(str, input().strip().split(' '))

def li():
	return list(mi())

def dmain():
	sys.setrecursionlimit(100000000)
	threading.stack_size(40960000)
	thread = threading.Thread(target=main)
	thread.start()
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def getKey(item):
	return item[1]

def sort2(l):
	return sorted(l, key=getKey, reverse=True)

def d2(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def ntl(n):
	return [int(i) for i in str(n)]

def ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(n - r))

def binary_search(arr, low, high, x):
	if high >= low:
		mid = (high + low) // 2
		if arr[mid] == x:
			return mid
		elif arr[mid] > x:
			return binary_search(arr, low, mid - 1, x)
		else:
			return binary_search(arr, mid + 1, high, x)
	else:
		return -1

def ceil(x, y):
	if x % y == 0:
		return x // y
	else:
		return x // y + 1

def powerMod(x, y, p):
	res = 1
	x %= p
	while y > 0:
		if y & 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def read():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def padded_bin_with_complement(x):
	if x < 0:
		return bin(2 ** 16 - abs(x))[2:].zfill(16)
	else:
		return bin(x)[2:].zfill(16)

def binaryToDecimal(binary):
	binary1 = binary
	(decimal, i, n) = (0, 0, 0)
	while binary != 0:
		dec = binary % 10
		decimal = decimal + dec * pow(2, i)
		binary = binary // 10
		i += 1
	print(decimal)

def CountFrequency(arr):
	return collections.Counter(arr)

def pos(a):
	b = [0] * len(a)
	c = sorted(a)
	for i in range(len(a)):
		for j in range(len(a)):
			if c[j] == a[i]:
				b[i] = j
				break
	return b

def smallestDivisor(n):
	if n % 2 == 0:
		return 2
	i = 3
	while i * i <= n:
		if n % i == 0:
			return i
		i += 2
	return n

def commonn(a, b, n):
	c = []
	for i in range(n):
		if a[i] == b[i]:
			c.append('-1')
		else:
			c.append(b[i])
	return c

def main():
	k = ii()
	c = 0
	s = 'codeforces'
	for i in range(1, 1000):
		if i ** 10 >= k:
			c = i
			break
	d = c - 1
	for i in range(1, 11):
		g = c ** i * d ** (10 - i)
		if g >= k:
			f = i
			break
	s = list(s)
	ans = ''
	for i in range(len(s)):
		if i < f:
			ans += s[i] * c
		else:
			ans += s[i] * d
	print(ans)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


def prod(l):
	a = 1
	for i in l:
		a *= i
	return a
k = int(input())
l = [1] * 10
m = 'codeforces'
p = prod(l)
while p < k:
	for i in range(10):
		l[i] += 1
		p = prod(l)
		if p >= k:
			break
s = ''
for i in range(10):
	x = str(m[i])
	s += x * l[i]
print(s)


import io
import os
from collections import Counter, defaultdict, deque

def solve(N):
	M = len('codeforces')
	for p in range(1000):
		if p ** M <= N < (p + 1) ** M:
			for i in range(M + 1):
				if p ** (M - i) * (p + 1) ** i >= N:
					ans = []
					for (ch, count) in zip('codeforces', [p] * (M - i) + [p + 1] * i):
						ans.append(ch * count)
					return ''.join(ans)
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
(N,) = [int(x) for x in input().split()]
ans = solve(N)
print(ans)


n = int(input())
temp = 1
mul = 1
ans = 0
count = 0
while mul < n:
	count += 1
	ans += 1
	mul /= temp
	mul *= temp + 1
	if count == 10:
		temp += 1
		count = 0
os = ans % 10
answer = ''
for i in 'codeforces':
	if os > 0:
		answer += i * (temp + 1)
		os -= 1
	else:
		answer += i * temp
print(answer)


def prod(arr):
	ans = 1
	for i in arr:
		ans *= i
	return ans

def find_opt(arr, n):
	if prod(arr) >= n:
		return arr
	m = min(arr)
	min_idx = arr.index(m)
	arr[min_idx] += 1
	return find_opt(arr, n)
n = int(input())
arr = find_opt([1] * 10, n)
ans = ''
brr = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
for i in range(10):
	ans += brr[i] * arr[i]
print(ans)


from functools import reduce
n = int(input())
s = 'codeforces'
c = [0] * len(s)
ci = 0
while reduce(int.__mul__, c) < n:
	c[ci] += 1
	ci += 1
	ci %= len(s)
x = ''
for (j, i) in enumerate(s):
	print(i * c[j], end='')


n = int(input())
lst = [1 for i in range(10)]

def prod():
	ans = 1
	for i in range(10):
		ans *= lst[i]
	return ans
t = 0
while prod() < n:
	t += 1
	lst[t % 10] += 1
s = 'codeforces'
p = []
for i in range(len(lst)):
	p.append(s[i] * lst[i])
ans = ''.join(p)
print(ans)


n = int(input())
string = 'codeforces'
a = [1] * 10
k = 1
while k < n:
	for i in range(10):
		a[i] += 1
		k = 1
		for j in a:
			k *= j
		if k >= n:
			break
output = ''
for i in range(10):
	output += string[i] * a[i]
print(output)


k = int(input())
l = [1] * 10
i = 0
while True:
	x = l[0] * l[1] * l[2] * l[3] * l[4] * l[5] * l[6] * l[7] * l[8] * l[9]
	if x >= k:
		break
	l[i] += 1
	i = (i + 1) % 10
s = str()
s += 'c' * l[0]
s += 'o' * l[1]
s += 'd' * l[2]
s += 'e' * l[3]
s += 'f' * l[4]
s += 'o' * l[5]
s += 'r' * l[6]
s += 'c' * l[7]
s += 'e' * l[8]
s += 's' * l[9]
print(s)


k = int(input())
p = int(k ** 0.1)
tmp = p ** 10
s = 'codeforces'
for i in range(10):
	if tmp >= k:
		print(s[i] * p, end='')
	else:
		print(s[i] * (p + 1), end='')
		tmp = tmp // p * (p + 1)


k = int(input())
s = 'codeforces'
count = 0
check = 0
val = ''
for i in range(1, 51):
	if k <= i ** 10:
		if i == 1:
			break
		check = i - 1
		x = (i - 1) ** 10
		for j in range(0, 10):
			x = int(x * i / (i - 1))
			if x >= k:
				count = j + 1
				break
		break
for m in range(0, 10):
	val = val + s[m] * check
	if count:
		val = val + s[m]
		count = count - 1
if check == 0:
	print(s)
else:
	print(val)


from collections import *
from math import *

def get_input_array(element_data_type):
	arr = list(map(element_data_type, input().split()))
	return arr

def prod(arr):
	ans = 1
	for i in arr:
		ans *= i
	return ans

def solve():
	k = int(input())
	val = -1
	for i in range(1, 100):
		if pow(i, 10) <= k < pow(i + 1, 10):
			val = i
			break
	arr = [val] * 10
	for i in range(10):
		if prod(arr) >= k:
			break
		arr[i] += 1
	cf = list('codeforces')
	ans = ''
	for i in range(10):
		ans += cf[i] * arr[i]
	return ans
print(solve())


k = int(input())
string = 'codeforces'
min = 0
for i in range(50):
	if i ** 10 >= k:
		min = i
		break
init = (min - 1) ** 10
for i in range(1, 11):
	if (min - 1) ** (10 - i) * min ** i >= k:
		string2 = ''
		for j in range(i):
			string2 += string[j] * min
		for j in range(i, 10):
			string2 += string[j] * (min - 1)
		print(string2)
		break


k = int(input())
idx = 1
for i in range(1, 100):
	l = i ** 10
	u = (i + 1) ** 10
	if l <= k and u >= k:
		idx = i
		break
a = [idx] * 10
sm = pow(idx, 10)
i = 1
while i <= 10 and sm < k:
	sm = (idx + 1) ** i * idx ** (10 - i)
	a[i - 1] += 1
	if sm >= k:
		break
	i += 1
s = 'codeforces'
ans = ''
for i in range(len(s)):
	for j in range(a[i]):
		ans += s[i]
print(ans)


import math
t1 = 1
for _ in range(t1):
	k = int(input())
	s = 'codeforces'
	if k == 1:
		print(s)
		break
	count = math.floor(k ** 0.1)
	if count >= 1:
		res = count ** 10
		if count == k:
			ans = ''
			for i in s:
				ans = ans + str(s[i]) * count
			print(ans)
			break
		t = 0
		res = count ** 10
		for i in range(0, len(s)):
			if res >= k:
				break
			res = res * (count + 1) / count
			t = t + 1
		ans = ''
		crnt = 0
		for i in range(t):
			ans = ans + str(s[i]) * (count + 1)
			crnt = crnt + 1
		for i in range(len(s) - t):
			ans = ans + str(s[crnt]) * count
			crnt = crnt + 1
		print(ans)


k = int(input())
string = 'codeforces'
if k == 1:
	print(string)
else:
	(s, t) = (1, 0)
	l = [1 for _ in range(10)]
	while s < k:
		l[t] += 1
		t = (t + 1) % 10
		s = 1
		for i in range(10):
			s *= l[i]
	for i in range(10):
		for _ in range(l[i]):
			print(string[i], end='')


n = int(input())
arr = [1] * 10
ans = 1
pos = 9
val = 1
while ans < n:
	ans = 1
	for i in range(10):
		ans *= arr[i]
	if ans < n:
		if pos == 0:
			val += 1
			pos = 9
			arr[pos] = val
		else:
			pos -= 1
			arr[pos] = val
res = ''
s = 'codeforces'
for i in range(10):
	res += s[i] * arr[i]
print(res)


k = int(input())
i = 1
res = 0
st = 'codeforces'
while True:
	res = i ** 10
	if res >= k:
		break
	i += 1
ans = ''
if res == k:
	for m in range(10):
		s = st[m] * i
		ans += s
	print(ans)
else:
	j = 1
	while True:
		res = i ** j * (i - 1) ** (10 - j)
		if res >= k:
			break
		j += 1
	if res == k:
		for m in range(j):
			s = st[m] * i
			ans += s
		for m in range(j, 10):
			s = st[m] * (i - 1)
			ans += s
		print(ans)
	else:
		for m in range(j):
			s = st[m] * i
			ans += s
		for m in range(j, 10):
			s = st[m] * (i - 1)
			ans += s
		print(ans)


n = int(input())
for i in range(99):
	if i ** 10 >= n:
		break
for j in range(11):
	if i ** j * (i - 1) ** (10 - j) >= n:
		break
s = 'codeforces'
ans = []
for x in s[:j]:
	ans.append(x * i)
for x in s[j:]:
	ans.append(x * (i - 1))
print(''.join(ans))


k = int(input())
st = 'codeforces'
n = 1
while n ** 10 < k:
	n += 1
st_ar = [n] * 10
d = n ** 10
i = 0
while d >= k:
	st_ar[i] -= 1
	i += 1
	d = 1
	for el in st_ar:
		d *= el
st_ar[i - 1] += 1
r = ''
for i in range(10):
	r += st[i] * st_ar[i]
print(r)


def f(arr, k):
	count = 1
	for i in arr:
		count *= i
	if count >= k:
		return True
	return False
k = int(input())
s = 'codeforces'
arr = [1 for x in range(10)]
var = k
i = 0
while True:
	if f(arr, k):
		break
	arr[i % 10] += 1
	i += 1
k = -1
for i in s:
	k += 1
	for j in range(arr[k]):
		print(i, end='')


k = int(input())
st = 'codeforces'
l = [1] * 10
prod = 1
i = 0
while prod < k:
	prev = l[i % 10]
	l[i % 10] += 1
	prod = prod * l[i % 10] // prev
	i += 1
for i in range(10):
	print(st[i] * l[i], end='')


l = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
x = 1
z = 0
n = int(input())
while x < n:
	x = 1
	if z > 9:
		z = 10 - z
	l[z] += 1
	for i in range(10):
		x *= l[i]
	z += 1
s = 'codeforces'
for i in range(10):
	print(s[i] * l[i], end='')


b = [1] * 10
k = int(input())
l = 0
while 1:
	n = 1
	for i in range(10):
		n *= b[i]
	if n >= k:
		break
	b[l] += 1
	l = (l + 1) % 10
e = 'codeforces'
s = ''
l = 0
for i in e:
	s += i * b[l]
	l += 1
print(s)


def make_str(l):
	s = 'codeforces'
	ns = ''
	for i in range(10):
		ns += l[i] * s[i]
	return ns

def main():
	k = int(input())
	if k == 1:
		print('codeforces')
		return
	l = [1 for _ in range(10)]
	p = 1
	for i in range(40):
		for j in range(10):
			p //= i + 1
			p *= i + 2
			l[j] += 1
			if p >= k:
				print(make_str(l))
				return
main()


def amount(times):
	res = 1
	for i in times:
		res *= i
	return res
k = int(input().strip())
times = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
string = 'codeforces'
i = 0
while amount(times) < k:
	times[i] += 1
	i += 1
	if i == 10:
		i = 0
out = ''
for i in range(10):
	out += string[i] * times[i]
print(out)


from functools import reduce
from operator import mul
k = int(input())
cnt = [1] * 10
i = 0
while reduce(mul, cnt) < k:
	cnt[i % 10] += 1
	i += 1
print(*(c * cnt[i] for (i, c) in enumerate('codeforces')), sep='')


from collections import defaultdict as dd
import math
import sys
input = sys.stdin.readline

def nn():
	return int(input())

def li():
	return list(input())

def mi():
	return map(int, input().split())

def lm():
	return list(map(int, input().split()))
n = nn()
k = 1
while (k + 1) ** 10 < n:
	k += 1
base = k ** 10
bigs = 0
while k ** (10 - bigs) * (k + 1) ** bigs < n:
	bigs += 1
s = 'codeforces'
ans = []
for i in range(bigs):
	for j in range(k + 1):
		ans.append(s[i])
for i in range(bigs, 10):
	for j in range(k):
		ans.append(s[i])
print(''.join(ans))


k = int(input())
x = [1] * 10
p = 1
s = 'codeforces'
while p < k:
	for i in range(len(x)):
		x[i] += 1
		p = p // (x[i] - 1)
		p = p * x[i]
		if p >= k:
			break
t = ''
for i in range(len(x)):
	t += s[i] * x[i]
print(t)


def invalid(n, k):
	m = 1
	for x in n:
		m *= x
	return m < k
k = int(input())
count = [1] * 10
n = 0
while invalid(count, k):
	count[n] += 1
	n += 1
	n %= 10
for (i, c) in enumerate('codeforces'):
	print(count[i] * c, end='')


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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')

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
from math import floor
INF = 10 ** 18
MOD = 10 ** 9 + 7
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
k = int(ri())
val = floor(pow(k, 0.1))
if val ** 10 >= k:
	ans = 'codeforces'
	tans = ''
	for i in range(10):
		tans += ans[i] * val
	print(tans)
else:
	tot = val ** 10
	cnt = 0
	while tot < k:
		tot = tot // val
		tot = tot * (val + 1)
		cnt += 1
	ans = 'codeforces'
	tans = ''
	for i in range(cnt):
		tans = tans + ans[i] * (val + 1)
	for i in range(0, 10 - cnt):
		tans = tans + ans[i + cnt] * val
	print(tans)


from __future__ import division, print_function
from sys import stdin, stdout
import bisect
import math
import heapq
i_m = 9223372036854775807

def inin():
	return int(input())

def stin():
	return input()

def spin():
	return map(int, stin().split())

def lin():
	return list(map(int, stin().split()))

def matrix(n):
	return [list(map(int, input().split())) for i in range(n)]

def count2Dmatrix(i, list):
	return sum((c.count(i) for c in list))

def modinv(n, p):
	return pow(n, p - 2, p)

def GCD(x, y):
	x = abs(x)
	y = abs(y)
	if min(x, y) == 0:
		return max(x, y)
	while y:
		(x, y) = (y, x % y)
	return x

def Divisors(n):
	l = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
	return l
prime = []

def SieveOfEratosthenes(n):
	global prime
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	f = []
	for p in range(2, n):
		if prime[p]:
			f.append(p)
	return f
q = []

def dfs(n, d, v, c):
	global q
	v[n] = 1
	x = d[n]
	q.append(n)
	j = c
	for i in x:
		if i not in v:
			f = dfs(i, d, v, c + 1)
			j = max(j, f)
	return j
n = inin()
s = 'codeforces'
(m, c) = (0, 1)
l = [1] * 10
while c < n:
	c = c // l[m]
	l[m] += 1
	c *= l[m]
	m = (m + 1) % 10
ans = [s[i] * l[i] for i in range(10)]
print(''.join(ans))


k = int(input())
a = [1] * 10
i = 0
count = 1
total = 1
while total < k:
	a[i] = count
	if count != 1:
		total = total * count // (count - 1)
	if i == 9:
		count += 1
	i = (i + 1) % 10
r = ''
q = 1
total = 'codeforces'
for i in range(10):
	q *= a[i]
	r += total[i] * a[i]
print(r)


import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
mod = 10 ** 9 + 7
mod1 = 998244353
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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')

class SegmentTree1:

	def __init__(self, data, default=9999999, func=lambda a, b: min(a, b)):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)

class SegmentTree:

	def __init__(self, data, default=0, func=lambda a, b: a + b):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)

class Factorial:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorials = [1, 1]
		self.invModulos = [0, 1]
		self.invFactorial_ = [1, 1]

	def calc(self, n):
		if n <= -1:
			print('Invalid argument to calculate n!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.factorials):
			return self.factorials[n]
		nextArr = [0] * (n + 1 - len(self.factorials))
		initialI = len(self.factorials)
		prev = self.factorials[-1]
		m = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * i % m
		self.factorials += nextArr
		return self.factorials[n]

	def inv(self, n):
		if n <= -1:
			print('Invalid argument to calculate n^(-1)')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		p = self.MOD
		pi = n % p
		if pi < len(self.invModulos):
			return self.invModulos[pi]
		nextArr = [0] * (n + 1 - len(self.invModulos))
		initialI = len(self.invModulos)
		for i in range(initialI, min(p, n + 1)):
			next = -self.invModulos[p % i] * (p // i) % p
			self.invModulos.append(next)
		return self.invModulos[pi]

	def invFactorial(self, n):
		if n <= -1:
			print('Invalid argument to calculate (n^(-1))!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.invFactorial_):
			return self.invFactorial_[n]
		self.inv(n)
		nextArr = [0] * (n + 1 - len(self.invFactorial_))
		initialI = len(self.invFactorial_)
		prev = self.invFactorial_[-1]
		p = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * self.invModulos[i % p] % p
		self.invFactorial_ += nextArr
		return self.invFactorial_[n]

class Combination:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorial = Factorial(MOD)

	def ncr(self, n, k):
		if k < 0 or n < k:
			return 0
		k = min(k, n - k)
		f = self.factorial
		return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD

def powm(a, n, m):
	if a == 1 or n == 0:
		return 1
	if n % 2 == 0:
		s = powm(a, n // 2, m)
		return s * s % m
	else:
		return a * powm(a, n - 1, m) % m

def sort_list(list1, list2):
	zipped_pairs = zip(list2, list1)
	z = [x for (_, x) in sorted(zipped_pairs)]
	return z

def product(l):
	por = 1
	for i in range(len(l)):
		por *= l[i]
	return por

def binarySearchCount(arr, n, key):
	left = 0
	right = n - 1
	count = 0
	while left <= right:
		mid = int((right + left) / 2)
		if arr[mid] <= key:
			count = mid + 1
			left = mid + 1
		else:
			right = mid - 1
	return count

def countdig(n):
	c = 0
	while n > 0:
		n //= 10
		c += 1
	return c

def countGreater(arr, n, k):
	l = 0
	r = n - 1
	leftGreater = n
	while l <= r:
		m = int(l + (r - l) / 2)
		if arr[m] > k:
			leftGreater = m
			r = m - 1
		else:
			l = m + 1
	return n - leftGreater
n = int(input())
r = 'codeforces'
a = int(n ** 0.1)
c = a ** 10
for i in r:
	n1 = max(1, a)
	if c < n:
		c /= n1
		c *= n1 + 1
		n1 += 1
	print(i * n1, end='')
print()


import math
n = int(input())
a = max(1, math.ceil(n ** 0.1))
mot = 'codeforces'
sortie = ''
if n == 1:
	print('codeforces')
else:
	for x in range(10):
		if a ** x * (a - 1) ** (10 - x) < n:
			sortie += mot[x] * a
		else:
			sortie += mot[x] * (a - 1)
	print(sortie)


s = list('codeforces')
k = int(input())
l = [1] * 10
(i, prod) = (0, 1)
while prod < k:
	prod //= l[i]
	l[i] += 1
	prod *= l[i]
	i = (i + 1) % 10
for i in range(10):
	print(s[i] * l[i], end='')


k = int(input())
L = [1] * 10
ind = 0
while True:
	x = 1
	for item in L:
		x *= item
	if x >= k:
		break
	L[ind] += 1
	ind += 1
	ind %= 10
s = ''
q = 'codeforces'
for i in range(10):
	s += q[i] * L[i]
print(s)


n = int(input())
ans = [1] * 10
this = 1
i = 0
while this < n:
	i %= 10
	this //= ans[i]
	ans[i] += 1
	this *= ans[i]
	i += 1
s = 'codeforces'
for i in range(10):
	print(s[i] * ans[i], end='')
print()


A = list('codeforces')
K = int(input())
X = [1] * 10
s = 1
for _ in range(100):
	for i in range(10):
		if s >= K:
			ans = ''
			for j in range(10):
				ans += A[j] * X[j]
			print(ans)
			exit()
		s = s // X[i] * (X[i] + 1)
		X[i] += 1
print(len(A))
print(A)


n = int(input())
(n_c1, n_o1, n_d, n_e1, n_f, n_o2, n_r, n_c2, n_e2, n_s) = (1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
while n_c1 * n_o1 * n_d * n_e1 * n_f * n_o2 * n_r * n_c2 * n_e2 * n_s < n:
	n_c1 += 1
	if n_c1 * n_o1 * n_d * n_e1 * n_f * n_o2 * n_r * n_c2 * n_e2 * n_s >= n:
		break
	n_o1 += 1
	if n_c1 * n_o1 * n_d * n_e1 * n_f * n_o2 * n_r * n_c2 * n_e2 * n_s >= n:
		break
	n_d += 1
	if n_c1 * n_o1 * n_d * n_e1 * n_f * n_o2 * n_r * n_c2 * n_e2 * n_s >= n:
		break
	n_e1 += 1
	if n_c1 * n_o1 * n_d * n_e1 * n_f * n_o2 * n_r * n_c2 * n_e2 * n_s >= n:
		break
	n_f += 1
	if n_c1 * n_o1 * n_d * n_e1 * n_f * n_o2 * n_r * n_c2 * n_e2 * n_s >= n:
		break
	n_o2 += 1
	if n_c1 * n_o1 * n_d * n_e1 * n_f * n_o2 * n_r * n_c2 * n_e2 * n_s >= n:
		break
	n_r += 1
	if n_c1 * n_o1 * n_d * n_e1 * n_f * n_o2 * n_r * n_c2 * n_e2 * n_s >= n:
		break
	n_c2 += 1
	if n_c1 * n_o1 * n_d * n_e1 * n_f * n_o2 * n_r * n_c2 * n_e2 * n_s >= n:
		break
	n_e2 += 1
	if n_c1 * n_o1 * n_d * n_e1 * n_f * n_o2 * n_r * n_c2 * n_e2 * n_s >= n:
		break
	n_s += 1
	if n_c1 * n_o1 * n_d * n_e1 * n_f * n_o2 * n_r * n_c2 * n_e2 * n_s >= n:
		break
print('c' * n_c1 + 'o' * n_o1 + 'd' * n_d + 'e' * n_e1 + 'f' * n_f + 'o' * n_o2 + 'r' * n_r + 'c' * n_c2 + 'e' * n_e2 + 's' * n_s)


ans = [1 for i in range(10)]
s = int(input())
t = 'codeforces'
prod = 1
mul = 2
i = 0
while prod < s:
	if i == 10:
		i = 0
		mul += 1
	prod = prod // ans[i]
	prod = prod * mul
	ans[i] = mul
	i += 1
temp = ''
for i in range(len(ans)):
	temp += t[i] * ans[i]
print(temp)


s = 'codeforces'
k = int(input())
c = len(s)
l = [1 for i in range(c)]
count = 1
i = 0
while count < k:
	pre = l[i]
	l[i] += 1
	count = count // pre * (pre + 1)
	i = (i + 1) % c
for i in range(c):
	print(s[i] * l[i], end='')


k = int(input())
a = [1] * 10
s = 'codeforces'
p = 1
for i in a:
	p *= i
while p < k:
	for j in range(10):
		p /= a[j]
		a[j] += 1
		p *= a[j]
		if p >= k:
			break
for k in range(10):
	print(s[k] * a[k], end='')


def solve(x, n):
	if n == 1:
		return x
	p = [1] * 10
	sn = ''
	product = 1
	i = 0
	while product < n:
		product = product // p[i]
		p[i] += 1
		product = product * p[i]
		i = (i + 1) % 10
	for i in range(10):
		sn += x[i] * p[i]
	return sn
t = int(input())
s = 'codeforces'
print(solve(s, t))


from functools import reduce
from sys import stdin, stdout
import bisect
from bisect import bisect_left as bl
from bisect import bisect_right as br
import itertools
from collections import Counter
import collections
import math
import heapq
import re

def modinv(n, p):
	return pow(n, p - 2, p)

def cin():
	return map(int, sin().split())

def ain():
	return list(map(int, sin().split()))

def sin():
	return input()

def inin():
	return int(input())

def Divisors(n):
	l = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
	return l

def most_frequent(list):
	return max(set(list), key=list.count)

def GCD(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def ncr(n, r, p):
	t = fact[n] * (ifact[r] * ifact[n - r] % p) % p
	return t

def Convert(string):
	li = list(string.split(''))
	return li

def SieveOfEratosthenes(n):
	global prime
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	f = []
	for p in range(2, n):
		if prime[p]:
			f.append(p)
	return f
prime = []
q = []

def dfs(n, d, v, c):
	global q
	v[n] = 1
	x = d[n]
	q.append(n)
	j = c
	for i in x:
		if i not in v:
			f = dfs(i, d, v, c + 1)
			j = max(j, f)
	return j

def main():
	n = inin()
	a = [1] * 10
	k = 1
	s = 'codeforces'
	j = 0
	while k < n:
		a[j] += 1
		j = (j + 1) % 10
		k = 1
		d = k
		k += 20
		k = d
		for i in range(10):
			k *= a[i]
	for i in range(10):
		for j in range(a[i]):
			print(s[i], end='')
	print()
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			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')
main()


import sys
input = sys.stdin.readline
I = lambda : list(map(int, input().split()))
(k,) = I()
s = list('codeforces')
p = [1] * 10
m = 1
while m < k:
	j = 0
	while j < 10 and m < k:
		o = p[j]
		p[j] += 1
		m = m // o * p[j]
		j += 1
an = ''
for i in range(10):
	an += s[i] * p[i]
print(an)


def prog():
	k = int(input())
	least_needed = 1
	while least_needed ** 10 < k:
		least_needed += 1
	for i in range(1, 11):
		if least_needed ** i * (least_needed - 1) ** (10 - i) >= k:
			break
	letters = 'codeforces'
	frequency = [least_needed] * i + [least_needed - 1] * (10 - i)
	output = ''
	for i in range(10):
		output += letters[i] * frequency[i]
	print(output + '\n')
prog()


def prod(ways):
	ans = 1
	for i in range(len(ways)):
		ans *= ways[i]
	return ans
k = int(input())
arr = list('codeforces')
ways = [1] * 10
ans = 1
i = 0
while prod(ways) < k:
	ways[i % 10] += 1
	i += 1
for i in range(10):
	print(arr[i] * ways[i], end='')


from math import ceil, log, floor, sqrt
import math

def mod_expo(n, p, m):
	result = 1
	while p != 0:
		if p % 2 == 1:
			result = result * n % m
		p //= 2
		n = n * n % m
	return result

def get_string(n):
	s = 'codeforces'
	l = []
	res = ''
	flag = True
	if n == 1:
		return s
	for i in range(10):
		l.append(1)
	m = 1
	while flag:
		for i in range(10):
			m = m * (l[i] + 1) // l[i]
			l[i] += 1
			if m >= n:
				flag = False
				break
	for i in range(10):
		for j in range(l[i]):
			res += s[i]
	return res
t = 1
while t:
	t = t - 1
	k = int(input())
	print(get_string(k))


n = int(input())
string = 'codeforces'
t = int(pow(n, 1 / 10))
x = pow(t, 10)
l = [t for i in range(10)]
for i in range(n):
	if x < n:
		x = x // l[i]
		l[i] = l[i] + 1
		x = x * l[i]
	else:
		break
result = ''
for i in range(10):
	result = result + string[i] * l[i]
print(result)


k = int(input())
ans = [['c', 1], ['o', 1], ['d', 1], ['e', 1], ['f', 1], ['o', 1], ['r', 1], ['c', 1], ['e', 1], ['s', 1]]
product = 1
point = 0
while product < k:
	product //= ans[point][1]
	ans[point][1] += 1
	product *= ans[point][1]
	point = (point + 1) % 10
s = ''
for i in range(10):
	temp = ans[i][0] * ans[i][1]
	s += temp
print(s)


am = int(input())
arr = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
coefs = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
ind = 0
tot = 0
tot = 1
while True:
	if tot < am:
		tot /= coefs[ind]
		tot *= coefs[ind] + 1
		coefs[ind] += 1
	else:
		break
	ind += 1
	ind %= 10
for i in range(len(coefs)):
	print(arr[i] * coefs[i], end='')


N = int(input())
(A, B, C, D, E, F, G, H, I, J) = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
while A * B * C * D * E * F * G * H * I * J < N:
	A += 1
	if A * B * C * D * E * F * G * H * I * J >= N:
		break
	B += 1
	if A * B * C * D * E * F * G * H * I * J >= N:
		break
	C += 1
	if A * B * C * D * E * F * G * H * I * J >= N:
		break
	D += 1
	if A * B * C * D * E * F * G * H * I * J >= N:
		break
	E += 1
	if A * B * C * D * E * F * G * H * I * J >= N:
		break
	F += 1
	if A * B * C * D * E * F * G * H * I * J >= N:
		break
	G += 1
	if A * B * C * D * E * F * G * H * I * J >= N:
		break
	H += 1
	if A * B * C * D * E * F * G * H * I * J >= N:
		break
	I += 1
	if A * B * C * D * E * F * G * H * I * J >= N:
		break
	J += 1
	if A * B * C * D * E * F * G * H * I * J >= N:
		break
print(*['c'] * A + ['o'] * B + ['d'] * C + ['e'] * D + ['f'] * E + ['o'] * F + ['r'] * G + ['c'] * H + ['e'] * I + ['s'] * J, sep='')


def solve():
	k = int(input())
	freq = [1] * 10
	prod = 1
	while prod < k:
		for i in range(len(freq)):
			if prod >= k:
				break
			prod //= freq[i]
			freq[i] += 1
			prod *= freq[i]
	ans = ''
	string = 'codeforces'
	for i in range(10):
		temp = []
		n = freq[i]
		ch = string[i]
		temp = [ch] * n
		ans += ''.join(temp)
	return ans

def main():
	print(solve())
main()


from copy import *
from math import *

def multiplyList(myList):
	result = 1
	for x in myList:
		result = result * x
	return result
n = int(input())
s = 'codeforces'
l = list(s)
i = 0
counter = 1
if n == 1:
	print(s)
	exit()
counter = 1
dad = 1
FINALE = [1] * 10
for i in range(40):
	j = 0
	aa = False
	for kk in range(10):
		l.insert(j + counter, l[j])
		j += counter + 1
		FINALE[kk] += 1
		if multiplyList(FINALE) >= n:
			aa = True
			break
	if aa == True:
		break
	counter += 1
print(''.join(l))


n = int(input())
cnt = 1
while cnt ** 10 < n:
	cnt += 1
for i in range(10):
	tmp = 1
	for j in range(10):
		if j <= i:
			tmp *= cnt
		else:
			tmp *= cnt - 1
	if tmp >= n:
		for (j, c) in enumerate('codeforces'):
			print(c * cnt if j <= i else c * (cnt - 1), end='')
		print()
		exit(0)


import math

def solution():
	k = int(input())
	s = 'codeforces'
	(i, sm) = (0, 1)
	l = [1] * 10
	while sm < k:
		sm //= l[i]
		l[i] += 1
		sm *= l[i]
		i = (i + 1) % 10
	ans = [s[i] * l[i] for i in range(10)]
	print(''.join(ans))
solution()


times = int(input())
s = 'codeforces'
ans = ''
comb = 1
rem = 10
for c in s:
	iter = 1
	while comb * iter ** rem < times:
		iter = iter + 1
	comb = comb * iter
	rem = rem - 1
	ans = c * iter
	print(ans, end='')


import itertools as it
n = int(input())
ans = 'codeforces'
a = [1] * 10
c = list('codeforces')
act = 1
while act < n:
	i = 0
	while i < 10 and act < n:
		a[i] += 1
		act = a[i] ** (i + 1) * (a[i] - 1) ** (10 - (i + 1))
		i += 1
for i in range(10):
	print(c[i] * a[i], end='')


k = int(input())
s = 'codeforces'
cnt = [1] * 10
n = 1
while n < k:
	for i in range(10):
		n /= cnt[i]
		cnt[i] += 1
		n *= cnt[i]
		if n >= k:
			break
ans = list()
for i in range(10):
	for _ in range(cnt[i]):
		ans.append(s[i])
print(''.join(ans))


n = int(input())
sp = [1] * 10
now = 0
f = 1
while f < n:
	f //= sp[now]
	sp[now] += 1
	f *= sp[now]
	now += 1
	now %= 10
s = 'codeforces'
for i in range(10):
	print(s[i] * sp[i], end='')


k = int(input())
s = [1] * 10
p = 1
while p < k:
	for i in range(10):
		p //= s[i]
		s[i] += 1
		p *= s[i]
		if p >= k:
			break
ans = ''
c = 'codeforces'
for i in range(10):
	ans += c[i] * s[i]
print(ans)


def ntvdm():
	k = int(input())
	min_reps = int(k ** 0.1)
	count = min_reps ** 10
	letters = list('codeforces')
	idx = 0
	while count < k:
		count = count // min_reps * (min_reps + 1)
		print(f'{letters[idx] * (min_reps + 1)}', end='')
		idx += 1
	for idx in range(idx, len(letters)):
		print(f'{letters[idx] * min_reps}', end='')
	print()
ntvdm()


n = int(input())
s = 'codeforces'
l = [1] * 10
pro = 1
ss = ''
while pro < n:
	for i in range(10):
		x = l[i]
		l[i] += 1
		pro = pro * l[i] // x
		if pro >= n:
			break
for i in range(10):
	ss += s[i] * l[i]
print(ss)


def main():
	no_of_occur = int(input())
	string = 'codeforces'
	arr = [1 for i in range(len(string))]
	arr_idx = 0
	total_count = 1
	while total_count < no_of_occur:
		arr[arr_idx % len(string)] += 1
		total_count = 1
		for each in arr:
			total_count *= int(each)
		arr_idx += 1
	newstr = ''
	i = 0
	for each in arr:
		temp = string[i] * each
		newstr += temp
		i += 1
	print(newstr)
main()


n = int(input())
p = 1
while p ** 10 < n:
	p += 1
freqArr = [0 for _ in range(10)]
if p ** 10 == n:
	for i in range(10):
		freqArr[i] = p
else:
	p -= 1
	for i in range(10):
		freqArr[i] = p
	for i in range(10):
		tmpCurr = (p + 1) ** (i + 1) * p ** (9 - i)
		freqArr[i] += 1
		if tmpCurr >= n:
			break
ans = ''
s = 'codeforces'
for i in range(10):
	ans += s[i] * freqArr[i]
print(ans)


def answer(k):
	l = list('codeforces')
	dp = [1] * 10
	count = 1
	i = 0
	while count < k:
		dp[i % 10] += 1
		count = 1
		for j in range(10):
			count *= dp[j]
		i += 1
	t = ''
	for i in range(10):
		t += dp[i] * l[i]
	return t
k = int(input())
print(answer(k))


import sys
import math
from math import factorial, inf, gcd, sqrt
from heapq import *
from functools import *
from itertools import *
from collections import *
from typing import *
from bisect import *
import random
sys.setrecursionlimit(10 ** 5)

def rarray():
	return [int(i) for i in input().split()]
t = 1
for ii in range(t):
	k = int(input())
	t = int(k ** 0.1)
	a = [t] * 10
	s = t ** 10
	for (i, j) in enumerate(a):
		if s < k:
			s //= a[i]
			a[i] += 1
			s *= a[i]
	for (i, j) in enumerate('codeforces'):
		print(j * a[i], end='')
	print()


n = int(input())
l = []
l.append(1)
for i in range(40):
	for j in range(10):
		l.append(l[-1] * (i + 2) // (i + 1))
for i in range(len(l)):
	if l[i] >= n:
		p = i
		break
c = 1 + p // 10
s = 'codeforces'
ans = ''
r = p % 10
for i in range(10):
	if i < 10 - r:
		ans += s[i] * c
	else:
		ans += s[i] * (c + 1)
print(ans)


import functools as f
k = int(input())
l = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
q = 'codeforces'
co = 0
while True:
	a = f.reduce(lambda x, y: x * y, l)
	if a >= k:
		break
	else:
		if co > 9:
			co = 0
		l[co] += 1
		co += 1
ans = ''
for i in range(10):
	k = l[i] * q[i]
	ans += k
print(ans)


def mul(l):
	res = 1
	for i in l:
		res = res * i
	return res
n = int(input())
s = 'codeforces'
d = [1] * 10
i = 0
while True:
	if mul(d) >= n:
		break
	d[i % 10] = d[i % 10] + 1
	i += 1
for i in range(10):
	print(s[i] * d[i], end='')


t = int(input())
sd = list('codeforces')
k = int(pow(t, 0.1))
if pow(k, 10) == t:
	for i in range(10):
		sd[i] = sd[i] * k
else:
	sm = pow(k, 10)
	tg = 0
	hj = 10
	while sm < t:
		sm = pow(k + 1, tg) * pow(k, hj)
		tg += 1
		hj -= 1
	tg -= 1
	hj += 1
	for i in range(tg):
		sd[i] = sd[i] * (k + 1)
	i += 1
	for j in range(hj):
		sd[i] = sd[i] * k
		i += 1
for i in range(10):
	print(sd[i], end='')


s = 'codeforces'
a = [1] * len(s)
k = int(input())
while True:
	c = 1
	for x in a:
		c *= x
	if c >= k:
		break
	a[a.index(min(a))] += 1
for i in range(len(s)):
	print(s[i] * a[i], end='')
print()


k = int(input())
s = 'codeforces'
n = len(s)
d = int(k ** (1 / n))
p = d ** n
i = 0
while p < k:
	p /= d
	p *= d + 1
	i += 1
ans = []
for j in range(n):
	if j < n - i:
		ans += [s[j]] * d
	else:
		ans += [s[j]] * (d + 1)
print(''.join(ans))


n = int(input())
a = [1] * 10
p = 1
while p < n:
	i = a.index(min(a))
	p /= a[i]
	a[i] += 1
	p *= a[i]
for i in range(10):
	print('codeforces'[i] * a[i], end='')


inp = lambda : int(input())
inpm = lambda : map(int, input().split())
inpl = lambda : list(inpm())
l2mn = lambda _n, _m: [[0 for __ in range(_m)] for _ in range(_n)]
l2n = lambda _n: l2mn(_n, _n)
INF = int(1e+18)
MOD = int(1000000000.0) + 7
N = 2000009

def solve():
	k = inp()
	s = 'codeforces'
	n = len(s)
	a = [1] * n
	count = 1
	i = 0
	while count < k:
		count = count // a[i] * (a[i] + 1)
		a[i] += 1
		i = (i + 1) % n
	for i in range(n):
		print(s[i] * a[i], end='')

def main():
	t = 1
	for i in range(t):
		solve()
main()


k = int(input())
a = [1 for i in range(10)]
mul = 1
i = 0
while mul < k:
	mul = mul // a[i] * (a[i] + 1)
	a[i] = a[i] + 1
	i = (i + 1) % 10
st = 'codeforces'
s = ''
for i in range(10):
	s += st[i] * a[i]
print(s)


k = int(input())
s = 'codeforces'
length = 10
count = 1
num_letters = 1
while count < k:
	new_s = s
	adder = 0
	for i in range(0, length, num_letters):
		new_s = new_s[:i + adder] + s[i] + new_s[i + adder:]
		adder += 1
		count *= num_letters + 1
		count = count // num_letters
		if count >= k:
			print(new_s)
			exit()
	s = new_s
	num_letters += 1
	length += 10
print(s)


import sys
input = sys.stdin.readline

def get_divs(k):
	divs = []
	upper_limit = int(k ** 0.5) + 1
	for i in range(int(k ** 0.5) + 1):
		if k % i == 0:
			divs.append(i)
	return divs

def product(lst):
	res = 1
	for v in lst:
		res *= v
	return res
k = int(input())
if k <= 4:
	print('codeforce' + 's' * k)
else:
	base = 1
	while base ** 10 <= k:
		base += 1
	bases = [base] * 10
	cur = base ** 10
	for i in range(10):
		bases[i] -= 1
		if product(bases) >= k:
			continue
		else:
			bases[i] += 1
			break
	res = []
	for (char, freq) in zip('codeforces', bases):
		res.append(char * freq)
	print(''.join(res))


from sys import stdin
input = stdin.readline

def main():
	k = int(input())
	if k == 1:
		print('codeforces')
	else:
		val = 1
		while pow(val, 10) < k:
			val += 1
		l = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
		s = ''
		n = 10
		m = pow(val, n)
		while m > k:
			n -= 1
			m = pow(val, n) * pow(val - 1, 10 - n)
		if m != k:
			n += 1
		for i in l:
			if n > 0:
				s += val * i
				n -= 1
			else:
				s += (val - 1) * i
		print(s)
main()


import sys
import math

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_string():
	return sys.stdin.readline().strip()

def get_int():
	return int(sys.stdin.readline().strip())

def get_list_strings():
	return list(map(str, sys.stdin.readline().strip().split()))

def solve():
	k = get_int()
	ans = [1 for i in range(10)]
	prod = 1
	flag = 0
	while flag == 0:
		for (i, ele) in enumerate(ans):
			if prod < k:
				prod = prod // ele
				prod *= ele + 1
				ans[i] += 1
			else:
				flag = 1
				break
	final = ''
	temp = 'codeforces'
	for i in range(10):
		final += temp[i] * ans[i]
	print(final)
solve()


from functools import reduce

def solve():
	k = int(input())
	current_pow = 1
	s = 'codeforces'
	while current_pow ** 10 < k:
		current_pow += 1
	if current_pow ** 10 == k:
		cols = [current_pow] * 10
		vals = ''.join((s_c * col for (s_c, col) in zip(s, cols)))
		return vals
	current_pow -= 1
	cols = [current_pow] * 10
	while reduce(lambda x, y: x * y, cols) < k:
		min_index = 0
		for i in range(10):
			if cols[i] < cols[min_index]:
				min_index = i
		cols[min_index] += 1
	vals = ''.join((s_c * col for (s_c, col) in zip(s, cols)))
	return vals

def main():
	t = 1
	for _ in range(t):
		print(solve())
main()


def multiply(list2):
	res = 1
	for elem in list2:
		res *= elem
	return res
k = int(input())
list1 = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
while multiply(list1[:]) < k:
	for i in range(10):
		list1[i] += 1
		if multiply(list1[:]) >= k:
			break
str1 = 'c' * list1[0] + 'o' * list1[1] + 'd' * list1[2] + 'e' * list1[3] + 'f' * list1[4] + 'o' * list1[5] + 'r' * list1[6] + 'c' * list1[7] + 'e' * list1[8] + 's' * list1[9]
print(str1)


def pr(q):
	ans = 1
	for i in range(10):
		ans *= q[i]
	return ans
k = int(input())
b = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
i = 0
if k == 1:
	print('codeforces')
	exit()
while True:
	b[i] += 1
	if pr(b) >= k:
		print('c' * b[0] + 'o' * b[1] + 'd' * b[2] + 'e' * b[3] + 'f' * b[4] + 'o' * b[5] + 'r' * b[6] + 'c' * b[7] + 'e' * b[8] + 's' * b[9])
		exit()
	else:
		i += 1
		if i == 10:
			i = 0


n = int(input())
items = [1] * 10
last = 0
s = 'codeforces'
while True:
	val = 1
	for _ in range(10):
		val *= items[_]
	if val >= n:
		break
	items[last] += 1
	last = (last + 1) % 10
for i in range(10):
	print(s[i] * items[i], end='')


import sys
input = sys.stdin.readline
k = int(input())
w = 'codeforces'
nums = [1] * 10
prod = 1
i = 0
while prod < k:
	prod //= nums[i]
	nums[i] += 1
	prod *= nums[i]
	i += 1
	if i == 10:
		i = 0
sol = ''
for i in range(10):
	for j in range(nums[i]):
		sol += w[i]
print(sol)


import sys
from sys import stdin, stdout, setrecursionlimit
for _ in range(1):
	k = int(stdin.readline())
	if k == 1:
		print('codeforces')
		break
	chk = False
	t = -1
	for i in range(1, 41):
		if i ** 10 == k:
			chk = True
			t = i
			break
		elif i ** 10 > k:
			t = i - 1
			break
		else:
			continue
	if chk:
		ans = ''
		for i in 'codeforces':
			ans += i * t
		print(ans)
		break
	ans = ''
	d = {}
	for i in range(10):
		d[i] = t
	rem = k - t ** 10
	cnt = 0
	st = 'codeforces'
	while rem > 0:
		rem -= t ** (9 - cnt) * (t + 1) ** cnt
		d[cnt] += 1
		cnt += 1
	ans = ''
	for i in range(10):
		ans += st[i] * d[i]
	print(ans)


def main():
	k = int(input())
	line = 'codeforces'
	for i in range(1, 50):
		if i ** 10 >= k:
			n = i ** 10
			n_cnt = 10
			n_1 = 0
			while n * (i - 1) / i >= k:
				n = n * (i - 1) // i
				n_cnt -= 1
				n_1 += 1
			new_line = ''
			for k in range(n_cnt):
				new_line += line[k] * i
			for k in range(n_cnt, n_cnt + n_1):
				new_line += line[k] * (i - 1)
			print(new_line)
			return
t = 1
for i in range(t):
	main()


n = int(input())
arr = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
arrr = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
prod = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
ctr = 0
j = 1
while n > j:
	j = j * (prod[ctr] + 1) // prod[ctr]
	prod[ctr] += 1
	arr[ctr] = arr[ctr] + arrr[ctr]
	ctr += 1
	if ctr == 10:
		ctr = 0
for i in arr:
	print(i, end='')


n = int(input())
if n == 1:
	print('codeforces')
	exit()
arr = []
op = 0
tmp = -1
for i in range(1, 41):
	if pow(i, 10) >= n:
		op = i
		tmp = pow(i, 10)
		break
for i in range(1, 11):
	if tmp // op * (op - 1) >= n:
		tmp = tmp // op * (op - 1)
		arr.append(op - 1)
	else:
		arr.append(op)
st = 'codeforces'
ans = ''
for i in range(10):
	ans += st[i] * arr[i]
print(ans)


k = int(input())
org = {i: 1 for i in range(10)}
s = 'codeforces'
mult = 1
itr = 0
while mult < k:
	mult //= org[itr]
	org[itr] += 1
	mult *= org[itr]
	itr += 1
	itr %= 10
ans = ''
for i in range(10):
	ans += s[i] * org[i]
print(ans)


n = int(input())
a = [1] * 10
i = 1
j = 0
s = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
while i < n:
	i = i // a[j]
	i = i * (a[j] + 1)
	a[j] += 1
	j += 1
	if j == 10:
		j = 0
for i in range(10):
	while a[i] > 0:
		print(s[i], end='')
		a[i] -= 1


import math
k = int(input(''))
sub = 1
while True:
	if k <= sub ** 10:
		break
	else:
		sub += 1
answer = ''
ans = 1
i = 0
if sub == 1:
	answer = 'codeforces'
	ans = 1
	i = 10
initial = 'codeforces'
counter = 0
while ans < k:
	answer += initial[i] * sub
	counter += 1
	ans = sub ** counter * (sub - 1) ** (10 - counter)
	i += 1
for j in initial[i:]:
	answer += j * (sub - 1)
print(answer)


def mult(arr):
	ans = 1
	for a in arr:
		ans *= a
	return ans
t = 1
while t != 0:
	t -= 1
	k = int(input())
	string = 'codeforces'
	lt = [1 for i in range(10)]
	i = 0
	while mult(lt) < k:
		lt[i] += 1
		i = (i + 1) % 10
	out = ''
	for p in range(10):
		out += string[p] * lt[p]
	print(out)


import math
k = int(input())
s = 'codeforces'
occ = [1] * 10
for i in range(9, -1, -1):
	minn = int(10 ** math.floor(math.log10(k) / (i + 1)))
	while minn ** (i + 1) < k:
		minn += 1
	occ[9 - i] = minn
	k = k / occ[9 - i]
ans_s = ''
for i in range(10):
	ans_s += s[i] * occ[i]
print(ans_s)


from math import log
n = int(input())
val = log(n)
v_2 = [val / log(i) for i in range(2, 51)]
(a, b) = (1, 2)
for i in reversed(range(len(v_2))):
	if v_2[i] > 10:
		a = i + 2
		b = i + 3
		break
out = []
for i in range(11):
	comb = b ** i * a ** (10 - i)
	if comb >= n:
		out = [b] * i
		out.extend([a] * (10 - i))
		break
str_demo = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
output_str = []
for i in range(len(str_demo)):
	rep = out[i]
	letter = str_demo[i]
	output_str.append(letter * rep)
print(''.join(output_str))


k = int(input())
l = [1 for i in range(10)]
prod = 1
string = 'codeforces'
i = 0
while prod < k:
	prod //= l[i]
	l[i] += 1
	prod *= l[i]
	i = (i + 1) % 10
res = ''
for i in range(10):
	res += string[i] * l[i]
print(res)


k = int(input())
s = 'codeforces'
n = int(k ** 0.1)
Ans = ''
m = n ** 10
t = 0
for i in range(10):
	if m >= k:
		break
	m = m // n
	m *= n + 1
	Ans += (n + 1) * s[i]
	t = i + 1
s = s[t:]
for i in s:
	Ans += n * i
print(Ans)


import math
n = int(input())
t = 0
for i in range(1, 1000):
	if math.pow(i, 10) >= n:
		t = i
		break
k = int(math.pow(t, 10))
ans = ''
temp = 'codeforces'
if k == n:
	for i in temp:
		for j in range(t):
			ans += i
	print(ans)
else:
	e = 0
	for i in range(1, 11):
		k = math.pow(t, 10 - i) * math.pow(t - 1, i)
		if k < n:
			e = i
			break
	for i in range(0, e - 1):
		for j in range(t - 1):
			ans += temp[i]
	for i in range(e - 1, 10):
		for j in range(t):
			ans += temp[i]
	print(ans)


n = int(input())
s = 'codeforces'
l = list(s)
d = dict()
for i in range(len(l)):
	d[i] = 1
fact = 1
while fact < n:
	for i in d.keys():
		fact = fact // d[i]
		d[i] += 1
		fact = fact * d[i]
		if fact >= n:
			break
for k in d.keys():
	print(l[k] * d[k], end='')


import sys
import math
input = sys.stdin.readline

def inp():
	return int(input())

def inara():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
k = inp()
cnt = [1] * 10
now = 1
curr = 0
while now < k:
	cnt[curr] += 1
	now = 1
	for num in cnt:
		now *= num
	curr += 1
	curr %= 10
ans = 'codeforces'
for i in range(10):
	for j in range(cnt[i]):
		print(ans[i], end='')


import math
k = int(input())
s = 'codeforces'
n = len(s)
freq = [1] * n
prod = 1
i = 0
while prod < k:
	prod = prod / freq[i] * (freq[i] + 1)
	freq[i] += 1
	i = (i + 1) % n
for i in range(len(freq)):
	print(s[i] * freq[i], end='')
print('')


k = int(input())
m = int(k ** 0.1)
s = m ** 10
j = 0
while s < k:
	s = s / m * (m + 1)
	j += 1
ans = [m] * 10
for i in range(j):
	ans[i] += 1
w = 'codeforces'
for i in range(len(ans)):
	for j in range(ans[i]):
		print(w[i], end='')


from sys import stdin, stdout
n = int(stdin.readline())
v = [1] * 10
p = 1
i = 0
while p < n:
	p //= v[i]
	v[i] += 1
	p *= v[i]
	i = (i + 1) % 10
s = 'codeforces'
i = 0
for c in s:
	stdout.write(c * v[i])
	i += 1


def poss(l):
	numBig = l % 10
	numNorm = 10 - numBig
	return (l // 10 + 1) ** numBig * (l // 10) ** numNorm
k = int(input())
l = 10
while poss(l) < k:
	l += 1
split = [l // 10] * 10
for i in range(l % 10):
	split[i] += 1
print(''.join(map(lambda i: 'codeforces'[i] * split[i], range(10))))


n = int(input())
word = [x for x in 'codeforces']
arr = [1] * 10
ans = 1
pos = 0
while ans < n:
	ans = ans / arr[pos] * (arr[pos] + 1)
	arr[pos] += 1
	pos += 1
	pos %= 10
for a in range(10):
	print(word[a] * arr[a], end='')


n = int(input())
t = [1 for i in range(10)]
mul = 1
pos = 0
while mul < n:
	mul = mul // t[pos]
	t[pos] += 1
	mul = mul * t[pos]
	pos = (pos + 1) % 10
ans = 'codeforces'
for i in range(len(ans)):
	for j in range(t[i]):
		print(ans[i], end='')


k = int(input())
s = 'codeforces'
l = len('codeforces')
count = 0
while count ** l < k:
	count += 1
if count ** l == k:
	ans = ''
	for ch in 'codeforces':
		temp = [ch for x in range(count)]
		ans += ''.join(temp)
	print(ans)
else:
	List = [count - 1] * l
	j = l - 1
	val = (count - 1) ** l
	ans = ''
	while val < k:
		List[j] += 1
		val = List[j] ** (l - j) * (List[j] - 1) ** j
		j -= 1
	for i in range(l):
		temp = [s[i] for x in range(List[i])]
		ans += ''.join(temp)
	print(ans)


i = int(input())
s = 'codeforces'
A = [1] * 10
(mul, idx) = (1, 0)
while mul < i:
	j = idx % 10
	mul /= A[j]
	A[j] += 1
	mul *= A[j]
	idx += 1
ans = ''
for (id, val) in enumerate(s):
	ans += val * A[id]
print(ans)


k = int(input())
cnt = [1] * 10
cur = 1
ind = 0
while cur < k:
	cur /= cnt[ind]
	cnt[ind] += 1
	cur *= cnt[ind]
	ind = (ind + 1) % 10
s = list('codeforces')
for i in range(10):
	print(s[i] * cnt[i], end='')


s = 'codeforces'
k = int(input())
n = int(k ** 0.1)
m = n ** 10
r = list(s)
r = []
i = 0
for i in s:
	r.append(i * n)
r = ''.join(r)
cnt = 0
xx = 0
if m == k:
	print(r)
else:
	r = list(r)
	for i in range(10):
		cnt += 1
		xx += n
		r.insert(xx, s[i])
		xx += 1
		if (n + 1) ** cnt * n ** (10 - cnt) >= k:
			r = ''.join(r)
			print(r)
			break


import sys
from collections import defaultdict as dd
from collections import Counter as cc
from queue import Queue
import math
import itertools
try:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
except:
	pass
a = 'codeforces'
q = int(input())
i = 1
while i ** 10 < q:
	i += 1
j = 0
while (i - 1) ** j * i ** (10 - j) > q:
	j += 1
if j != 0 and (i - 1) ** j * i ** (10 - j) != q:
	j -= 1
e = ''
r = 0
for t in range(j):
	e += a[r] * (i - 1)
	r += 1
for t in range(10 - j):
	e += a[r] * i
	r += 1
print(e)


from collections import defaultdict
N = int(input())
S = 'codeforces'
Dict = defaultdict(int)
for i in range(10):
	Dict[i] = 1
i = 1
count = 0
phase = 1
while i < N:
	if count % 10 == 0:
		phase += 1
	Dict[count % 10] += 1
	i *= phase
	i //= phase - 1
	count += 1
Ans = ''
for i in range(10):
	Ans += S[i] * Dict[i]
print(Ans)


from collections import *
from functools import *
import math
import sys
inp = sys.stdin.readline
out = sys.stdout.write

def mi():
	return map(int, inp().split())

def li():
	return list(mi())

def ii():
	return int(inp())

def main():
	k = ii()
	s = 'codeforces'
	arr = [1] * len(s)
	prod = 1
	i = 0
	while prod < k:
		prod = prod // arr[i] * (arr[i] + 1)
		arr[i] += 1
		i = (i + 1) % len(s)
	final = ''
	for i in range(len(s)):
		final += s[i] * arr[i]
	print(final)
main()


t = int(input())
s = 'codeforces'
c1 = 1
o1 = 1
d1 = 1
e1 = 1
f1 = 1
o2 = 1
r1 = 1
c2 = 1
e2 = 1
s1 = 1

def calc():
	return c1 * o1 * d1 * e1 * f1 * o2 * r1 * c2 * e2 * s1
l = 10
while t > calc():
	if l == 10:
		s1 += 1
	elif l == 9:
		e2 += 1
	elif l == 8:
		c2 += 1
	elif l == 7:
		r1 += 1
	elif l == 6:
		o2 += 1
	elif l == 5:
		f1 += 1
	elif l == 4:
		e1 += 1
	elif l == 3:
		d1 += 1
	elif l == 2:
		o1 += 1
	elif l == 1:
		c1 += 1
	l -= 1
	if l < 1:
		l = 10
ans = 'c' * c1 + 'o' * o1 + 'd' * d1 + 'e' * e1 + 'f' * f1 + 'o' * o2 + 'r' * r1 + 'c' * c2 + 'e' * e2 + 's' * s1
print(ans)


import time, math, bisect, sys
from sys import stdin, stdout
from collections import deque
from fractions import Fraction
from collections import Counter
from collections import OrderedDict
from itertools import count
pi = 3.141592653589793

def II():
	return int(stdin.readline())

def IO():
	return stdin.readline()

def IP():
	return map(int, stdin.readline().split())

def L():
	return list(map(int, stdin.readline().split()))

def P(x):
	return stdout.write(str(x))

def PI(x, y):
	return stdout.write(str(x) + ' ' + str(y) + '\n')

def lcm(a, b):
	return a * b // gcd(a, b)

def gcd(a, b):
	if a == 0:
		return b
	elif b == 0:
		return a
	if a > b:
		return gcd(a % b, b)
	else:
		return gcd(a, b % a)

def readTree():
	v = int(input())
	adj = [set() for i in range(v + 1)]
	for i in range(v - 1):
		(u1, u2) = In()
		adj[u1].add(u2)
		adj[u2].add(u1)
	return (adj, v)

def bfs(adj, v):
	visited = [False] * (v + 1)
	q = deque()
	while q:
		pass

def sieve():
	li = [True] * 1000001
	(li[0], li[1]) = (False, False)
	for i in range(2, len(li), 1):
		if li[i] == True:
			for j in range(i * i, len(li), i):
				li[j] = False
	prime = []
	for i in range(1000001):
		if li[i] == True:
			prime.append(i)
	return prime

def setBit(n):
	count = 0
	while n != 0:
		n = n & n - 1
		count += 1
	return count

def solve():
	k = II()
	s = 'codeforces'
	for i in range(1, 51):
		if i ** 10 >= k:
			note = i
			break
	for j in range(11):
		if note ** j * (note - 1) ** (10 - j) >= k:
			nt = j
			break
	n = ''
	for i in range(10):
		if i <= nt - 1:
			n += s[i] * note
		else:
			n += s[i] * (note - 1)
	print(n)
solve()


k = int(input())
i = 0
while i ** 10 <= k:
	i += 1
i -= 1
x = 0
y = 10
while i ** y * (i + 1) ** x < k:
	x += 1
	y -= 1
f = [i] * y + [i + 1] * x
s = 'codeforces'
r = ''
for i in range(10):
	r += s[i] * f[i]
print(r)


import sys, io, os, time
from collections import defaultdict
from collections import OrderedDict
from collections import deque
from itertools import combinations
from itertools import permutations
import bisect, math, heapq
alphabet = 'abcdefghijklmnopqrstuvwxyz'
input = sys.stdin.readline
k = int(input())
ans = 1
freq = [1] * 10
while ans < k:
	i = 0
	while ans < k and i < 10:
		ans = ans / freq[i]
		freq[i] += 1
		ans = ans * freq[i]
		i += 1
s = 'codeforces'
for i in range(10):
	print(s[i] * freq[i], end='')
print()


from math import ceil
n = int(input())
m = ceil(n ** 0.1)
l1 = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
if m ** 10 == n:
	for i in l1:
		print(i * m, end='')
	print()
else:
	for i in range(0, 11):
		if m ** i * (m - 1) ** (10 - i) >= n:
			for j in range(i):
				print(l1[j] * m, end='')
			for j in range(i, 10):
				print(l1[j] * (m - 1), end='')
			break
	print()


k = int(input())
s = 'codeforces'
nums = [1] * 10
i = 0
counter = 1
while counter < k:
	counter //= nums[i]
	nums[i] += 1
	counter *= nums[i]
	i += 1
	i %= 10
for i in range(10):
	print(s[i] * nums[i], end='')


def prod(count):
	a = 1
	for i in count:
		a *= i
	return a
n = int(input())
count = [1] * 10
c = 0
while prod(count) < n:
	count[c % 10] += 1
	c += 1
s = 'codeforces'
ans = ''
for i in range(len(count)):
	ans += s[i] * count[i]
print(ans)


s = 'codeforces'
k = int(input())
a = 1
while (a + 1) ** 10 <= k:
	a += 1
for z in range(10, -1, -1):
	if k <= a ** z * (a + 1) ** (10 - z):
		break
res = []
for i in range(10):
	if i < z:
		res.append(s[i] * a)
	else:
		res.append(s[i] * (a + 1))
print(''.join(res))


import sys
input = sys.stdin.readline

def multiply(arr):
	ret = 1
	for i in range(10):
		ret *= arr[i]
	return ret
k = int(input())
dic = []
s = 'codeforces'
res = ''
if k == 1:
	print(s)
else:
	rep = [1] * 10
	m = 1
	idx = 0
	while True:
		rep[idx] += 1
		idx = (idx + 1) % 10
		if multiply(rep) >= k:
			break
	for i in range(10):
		res += s[i] * rep[i]
	print(res)


k = int(input())
ln = [1] * 10
lt = list('codeforces')
i = 1
j = 0
s = ''
while i < k:
	i = i // ln[j]
	i = i * (ln[j] + 1)
	ln[j] += 1
	j += 1
	if j == 10:
		j = 0
for x in range(10):
	s += ln[x] * lt[x]
print(s)


a = int(input())
s = 'codeforces'
x = [1] * 10
k = 1
(flag, i) = (0, 0)
res = 1
if res < a:
	while i < 10:
		x[i] += 1
		res = 1
		for j in range(10):
			res = res * x[j]
			if res >= a:
				flag = 1
				break
		if flag == 1:
			break
		if i == 9:
			i = 0
		else:
			i = i + 1
l = ''
for i in range(10):
	for j in range(x[i]):
		l = l + s[i]
print(l)


k = int(input())
for i in range(10, 500):
	letter1 = i // 10
	letter2 = (i + 1) // 10
	letter3 = (i + 2) // 10
	letter4 = (i + 3) // 10
	letter5 = (i + 4) // 10
	letter6 = (i + 5) // 10
	letter7 = (i + 6) // 10
	letter8 = (i + 7) // 10
	letter9 = (i + 8) // 10
	letter10 = (i + 9) // 10
	if letter1 * letter2 * letter3 * letter4 * letter5 * letter6 * letter7 * letter8 * letter9 * letter10 >= k:
		break
print('c' * letter1 + 'o' * letter2 + 'd' * letter3 + 'e' * letter4 + 'f' * letter5 + 'o' * letter6 + 'r' * letter7 + 'c' * letter8 + 'e' * letter9 + 's' * letter10)


import math, sys, bisect
from collections import defaultdict, Counter, deque
from itertools import groupby, accumulate
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda : map(int, input().split())
alele = lambda : list(map(int, input().split()))

def Y(c):
	print(['NO', 'YES'][c])

def y(c):
	print(['no', 'yes'][c])
N = int(input())
z = 'codeforces'
c = [1] * 10
count = 1
i = 0
while count < N:
	count = count // c[i]
	c[i] += 1
	count = count * c[i]
	i += 1
	if i >= 10:
		i = 0
for i in range(10):
	print(z[i] * c[i], end='')
print()


from sys import *
import math
k = int(input())
str1 = 'codeforces'
if k == 1:
	print(str1)
else:
	i = 2
	found = False
	while not found:
		j = 1
		while j < 11 and (not found):
			if int(math.pow(i, j) * int(math.pow(i - 1, 10 - j))) < k:
				j = j + 1
			else:
				found = True
		if not found:
			i = i + 1
	result = ''
	for k in range(j):
		for l in range(i):
			result = result + str1[k]
	for k in range(j, 10):
		for l in range(i - 1):
			result = result + str1[k]
	print(result)


n = int(input())
s = 'codeforces'
(x, k) = (0, 1)
a = [1 for _ in range(10)]
while k < n:
	ok = a[x % 10]
	k /= ok
	a[x % 10] += 1
	k *= a[x % 10]
	x += 1
for i in range(10):
	for j in range(a[i]):
		print(s[i], end='')


import sys, os
from io import BytesIO, IOBase
import collections, itertools, bisect, heapq, math, string
from decimal import *
BUFSIZE = 8192
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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')

def main():
	k = int(input())
	if k == 1:
		print('codeforces')
	else:
		s = 1
		c = [1] * 10
		f = False
		cf = 'codeforces'
		while True:
			for i in range(10):
				s = s // c[i]
				c[i] += 1
				s = s * c[i]
				if s >= k:
					f = True
					break
			if f:
				break
		ans = ''
		for i in range(10):
			ans += cf[i] * c[i]
		print(ans)
main()


def product(a):
	if len(a) == 1:
		return a[0]
	return a[0] * product(a[1:])

def result(p):
	r = ''
	for i in range(len(p)):
		r = r + s[i] * p[i]
	return r
k = int(input())
s = 'codeforces'
index = [0] * len(s)
while True:
	for i in range(len(s)):
		index[i] += 1
		if product(index) >= k:
			print(result(index))
			exit()


import math
n = int(input())
r = [1] * 10
i = 0
while math.prod(r) < n:
	r[i % 10] += 1
	i += 1
w = 'codeforces'
for i in range(10):
	print(w[i] * r[i], end='')


import sys

def input():
	return sys.stdin.readline().rstrip()

def input_split():
	return [int(i) for i in input().split()]
k = int(input())
counts = [1 for i in range(10)]

def get_count(lis):
	a = 1
	for x in lis:
		a = a * x
	return a
counter = 0
while True:
	x = get_count(counts)
	if x >= k:
		break
	counts[counter % 10] += 1
	counter += 1
ans = ''
s = 'codeforces'
for i in range(10):
	ans += s[i] * counts[i]
print(ans)


n = int(input())
arr = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
brr = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
(temp, k) = (9, 0)
if n == 1:
	print('codeforces')
	exit(0)
elif n == 2:
	print('ccodeforces')
	exit(0)
elif n == 3 or n == 4:
	print('ccoodeforces')
	exit(0)
elif n >= 4 and n <= 9:
	print('ccooddeforces')
	exit(0)
while temp < n:
	arr[k] += 1
	temp = 1
	for i in arr:
		temp *= i
	k += 1
	if k == 10:
		k = 0
for i in range(10):
	for j in range(arr[i]):
		print(brr[i], end='')


k = int(input())
s = 'codeforces'
l = [1] * 10
temp = 1
i = 0
while temp < k:
	temp /= l[i]
	l[i] += 1
	temp *= l[i]
	i = (i + 1) % 10
ans = ''
for i in range(10):
	ans += s[i] * l[i]
print(ans)


import sys
import math
from collections import Counter
from operator import itemgetter
import queue

def IO():
	sys.stdin = open('pyinput.txt', 'r')
	sys.stdout = open('pyoutput.txt', 'w')

def GCD(a, b):
	if b == 0:
		return a
	else:
		return GCD(b, a % b)

def LCM(a, b):
	return a * (b // GCD(a, b))

def scan(TYPE_1, TYPE_2=0):
	if TYPE_1 == int:
		return map(int, sys.stdin.readline().strip().split())
	elif TYPE_1 == float:
		return map(float, sys.stdin.readline().strip().split())
	elif TYPE_1 == list and TYPE_2 == float:
		return list(map(float, sys.stdin.readline().strip().split()))
	elif TYPE_1 == list and TYPE_2 == int:
		return list(map(int, sys.stdin.readline().strip().split()))
	elif TYPE_1 == str:
		return sys.stdin.readline().strip()
	else:
		print('ERROR!!!!')

def main():
	n = int(input())
	s = 'codeforces'
	cnt = [1 for i in range(15)]
	x = 1
	idx = 0
	while x < n:
		x = x // cnt[idx]
		cnt[idx] += 1
		x *= cnt[idx]
		idx = (idx + 1) % 10
	for i in range(len(s)):
		print(s[i] * cnt[i], end='')
main()


def mul_all(arr):
	res = 1
	for a in arr:
		res *= a
	return res
cf = 'codeforces'
ans = [0] * 10
k = int(input().strip())
i = 0
while mul_all(ans) < k:
	ans[i] += 1
	i = (i + 1) % 10
for i in range(len(ans)):
	ans[i] = cf[i] * ans[i]
print(''.join(ans))


n = int(input())
a = [1] * 10
ptr = 0
if n == 1:
	print('codeforces')
else:
	prev = 2
	nex = 1
	count = 1
	while count < n:
		a[ptr] += 1
		count = count + prev ** ptr * nex ** (10 - (ptr + 1))
		if ptr == 9:
			prev += 1
			nex += 1
		ptr = (ptr + 1) % 10
	s = 'codeforces'
	for i in range(10):
		while a[i] > 0:
			print(s[i], end='')
			a[i] -= 1
	print()


import sys
input = sys.stdin.buffer.readline
a = int(input())
f = 'codeforces'
j = [1] * 10
x = 0
k = 1
while k < a:
	k = k / j[x] * (j[x] + 1)
	j[x] += 1
	x = (x + 1) % 10
for x in range(10):
	print(f[x] * j[x], end='')


n = int(input())
l = [1] * 10
p = 1
j = 0
while p < n:
	k = l[j]
	l[j] += 1
	p = p // k * l[j]
	j = (j + 1) % 10
ss = 'codeforces'
m = [ss[i] * l[i] for i in range(10)]
print(''.join(m))


from sys import stdin, stdout
int_in = lambda : int(stdin.readline())
arr_in = lambda : [int(x) for x in stdin.readline().split()]
mat_in = lambda rows: [arr_in() for _ in range(rows)]
str_in = lambda : stdin.readline().strip()
out = lambda o: stdout.write('{}\n'.format(o))
arr_out = lambda o: out(' '.join(map(str, o)))
bool_out = lambda o: out('YES' if o else 'NO')
tests = lambda : range(1, int_in() + 1)
case_out = lambda i, o: out('Case #{}: {}'.format(i, o))

def solve(k):
	counts = [1] * 10
	i = 0
	product = 1
	while product < k:
		product //= counts[i % 10]
		counts[i % 10] += 1
		product *= counts[i % 10]
		i += 1
	result = ''
	codeforces = 'codeforces'
	for i in range(10):
		result += codeforces[i] * counts[i]
	return result
k = int_in()
out(solve(k))


import sys
input = sys.stdin.readline
getS = lambda : input().strip()
getN = lambda : int(input())
getList = lambda : list(map(int, input().split()))
getZList = lambda : [int(x) - 1 for x in input().split()]
INF = 10 ** 20
MOD = 1000000007

def solve():
	k = getN()
	if k == 1:
		print('codeforces')
		return
	for i in range(2, 100):
		if i ** 10 >= k:
			cur = i ** 10
			rep = i
			break
	strs = 'codeforces'
	for c in strs:
		if cur // rep * (rep - 1) >= k:
			print(c * (rep - 1), end='')
			cur = cur // rep * (rep - 1)
		else:
			print(c * rep, end='')
	return

def main():
	n = getN()
	for _ in range(n):
		solve()
solve()


t = int(input())
s = 'codeforces'
count = [1] * 10
ns = 1
i = 0
mod = 2
while ns < t:
	count[i] += 1
	if count[i] % mod == 0:
		if i == 9:
			i = 0
			mod += 1
		else:
			i += 1
	ns = 1
	for j in count:
		ns *= j
res = ''
for i in range(0, 10):
	res += s[i] * count[i]
print(res)


t = int(input())
a = 'codeforces'
ans = ''
frequency = [1] * 10
i = 0
subs = 1
while subs < t:
	subs = subs // frequency[i]
	frequency[i] += 1
	subs *= frequency[i]
	i = (i + 1) % 10
for i in range(10):
	ans += a[i] * frequency[i]
print(ans)


k = int(input())
letters = [1 for i in range(10)]

def multip(iterable):
	x = 1
	for i in iterable:
		x *= i
	return x
i = 0
while multip(letters) < k:
	letters[i] += 1
	i += 1
	if i >= 10:
		i = 0
s = ''
for i in range(len(letters)):
	s += 'codeforces'[i] * letters[i]
print(s)


import sys
input = sys.stdin.readline
import heapq
import copy
import math
import decimal

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def insr2():
	s = input()
	return s[:len(s) - 1]

def invr():
	return map(int, input().split())

def pr_list(a):
	print(*a, sep=' ')

def main():
	tests = 1
	mod = 1000000007
	limit = 10 ** 18
	ans = 0
	for test in range(tests):
		n = inp()
		a = [1 for i in range(10)]
		curr = 1
		while curr < n:
			for i in range(0, 10):
				curr = int(curr / a[i] * (a[i] + 1))
				a[i] = a[i] + 1
				if curr >= n:
					break
			if curr >= n:
				break
		ans = ''
		s = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
		for i in range(10):
			ans = ans + s[i] * a[i]
		print(ans)
main()


import math

def am(a):
	x = 1
	for i in a:
		x = x * i
	return x
n = int(input())
a = [1] * 10
x = n
for j in range(100):
	if am(a) >= x:
		break
	for i in range(10):
		a[i] += 1
		if am(a) >= x:
			break
s = 'codeforces'
ans = ''
l = list(s)
for i in range(10):
	for j in range(a[i]):
		ans += l[i]
ans = ''.join(ans)
print(ans)


import math
k = int(input())
r = int(math.ceil(math.sqrt(k)))
for i in range(1, k + 1):
	if i ** 10 >= k:
		break
for j in range(1, 11):
	if i ** j * (i - 1) ** (10 - j) >= k:
		break
ans = ''
q = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
diff = 10 - j
k = 0
while j > 0:
	ans += q[k] * i
	j -= 1
	k += 1
while diff > 0:
	ans += q[k] * (i - 1)
	diff -= 1
	k += 1
print(ans)


t = 1
for test in range(1, t + 1):
	n = int(input())
	freq = [1 for i in range(10)]
	ans = 'codeforces'
	count = 1
	ind = 0
	while count < n:
		count = count / freq[ind]
		freq[ind] += 1
		count = count * freq[ind]
		ind = (ind + 1) % 10
	for i in range(10):
		print(ans[i] * freq[i], end='')
	print()


k = int(input())
sqrtt = int(k ** (1 / 10))
a = []
for i in range(10):
	a.append(sqrtt)
res = 1
for x in a:
	res *= x
for i in range(10):
	if res >= k:
		break
	res //= a[i]
	res *= a[i] + 1
	a[i] += 1
s = []
s.append('c')
s.append('o')
s.append('d')
s.append('e')
s.append('f')
s.append('o')
s.append('r')
s.append('c')
s.append('e')
s.append('s')
for i in range(10):
	print(s[i] * a[i], end='')


n = int(input())
am = int(n ** 0.1)
curr = am ** 10
for i in range(11):
	if curr >= n:
		break
	else:
		curr *= (am + 1) / am
s = 'codeforces'
res = ''
for j in range(10 - i):
	res += s[j] * am
for j in range(10 - i, 10):
	res += s[j] * (am + 1)
print(res)


from sys import stdin
k = int(input())
n = int(k ** 0.1)
s = 'codeforces'
if n ** 10 == k:
	exit(print(''.join((c * n for c in s))))
for i in range(10):
	print(s[i] * (n + 1), end='')
	if n ** (10 - i - 1) * (n + 1) ** (i + 1) >= k:
		print(''.join((c * n for c in s[i + 1:])))
		break


rr = lambda : input().strip()
rri = lambda : int(rr())
rrm = lambda : [int(x) for x in rr().split()]
from sys import stdin, stdout

def sol():
	n = rri()
	x = 0
	z = 1
	a = [1 for i in range(10)]
	i = 0
	while z < n and x < 10:
		z //= a[i % 10]
		a[i % 10] += 1
		z *= a[i % 10]
		i += 1
	z = 'codeforces'
	res = ''
	for j in range(10):
		res += z[j] * a[j]
	print(res)
	return
sol()


def find_shortest_string(word, subseqs_n):
	word_length = len(word)
	duplicates_n = 1
	while duplicates_n ** word_length < subseqs_n:
		duplicates_n += 1
	can_free_n = 0
	cant_free_n = word_length
	while duplicates_n ** cant_free_n * (duplicates_n - 1) ** can_free_n >= subseqs_n:
		can_free_n += 1
		cant_free_n -= 1
	can_free_n -= 1
	cant_free_n += 1
	duplicates_counts = [duplicates_n] * cant_free_n + [duplicates_n - 1] * can_free_n
	return ''.join((char * char_n for (char, char_n) in zip(word, duplicates_counts)))

def main():
	k = int(input())
	result = find_shortest_string('codeforces', k)
	print(result)
main()


k = int(input())
str = 'codeforces'
for i in range(10, 100000000 + 1):
	x = i // 10
	z = x + 1
	y = z * 10 - i
	temp_result = 1
	for j in range(10 - y):
		temp_result *= z
	for j in range(y):
		temp_result *= x
	if temp_result >= k:
		result = ''
		for j in range(10 - y):
			result += str[j] * z
		for j in range(10 - y, 10):
			result += str[j] * x
		print(result)
		break


K = int(input())
from heapq import heappush, heappop, heapify
factors = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
heapify(factors)
num = 1
while num < K:
	f = heappop(factors)
	num *= f + 1
	num //= f
	heappush(factors, f + 1)
ans = []
for (n, c) in zip(factors, 'codeforces'):
	ans.append(c * n)
print(''.join(ans))


n = int(input())
f = [1 for i in range(10)]
total = 1
while total < n:
	for i in range(10):
		total /= f[i]
		f[i] += 1
		total *= f[i]
		if total >= n:
			break
c = list('codeforces')
for i in range(10):
	for z in range(f[i]):
		print(c[i], end='')


number = int(input())
lis = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
x = 1
for i in range(0, 10 ** 5):
	for j in range(0, 10):
		if x >= number:
			break
		x /= lis[j]
		lis[j] += 1
		x *= lis[j]
	if x > number:
		break
string = 'codeforces'
final_string = ''
for i in range(0, 10):
	final_string += string[i] * lis[i]
print(final_string)


n = int(input())
a = [1] * 10

def score():
	global a
	p = 1
	for i in range(10):
		p *= a[i]
	return p
for i in range(100000):
	if score() < n:
		a[i % 10] += 1
		i += 1
		continue
	else:
		break
s = 'codeforces'
for i in range(10):
	for j in range(a[i]):
		print(s[i], end='')
print()


k = int(input())
from math import pow, ceil, floor
if k == 1:
	print('codeforces')
else:
	l = ceil(pow(k, 1 / 10))
	i = 0
	while l ** i * (l - 1) ** (10 - i) < k:
		i += 1
	lst = 'codeforces'
	nl = ''
	for j in range(i):
		nl += lst[j] * l
	for j in range(i, 10):
		nl += lst[j] * (l - 1)
	print(nl)


from sys import stdin
input = stdin.readline

def get_prod(vec):
	prod = 1
	for x in vec:
		prod *= x
	return prod
K = int(input())
am = 0
for i in range(1, 40):
	tmp = [i] * 10
	if get_prod(tmp) <= K:
		am = i
v = [am] * 10
prod = get_prod(v)
for i in range(0, 10):
	if prod >= K:
		break
	v[i] += 1
	prod = get_prod(v)
word = 'codeforces'
for i in range(0, 10):
	for k in range(0, v[i]):
		print(word[i], end='')


import math
k = int(input())
ans = 'codeforces'
if k == 1:
	print(ans)
else:
	arr = [1] * 10
	mul = 1
	first = 0
	last = 9
	while mul < k:
		mul = mul / arr[first] * (arr[first] + 1)
		arr[first] += 1
		first = (first + 1) % 10
	a = ''
	for i in range(10):
		a += ans[i] * arr[i]
	print(a)


k = int(input())
l = len(bin(k)[2:])
a = [1 for i in range(10)]
k1 = 1
i = 0
j = 2
while k1 < k:
	if i == 10:
		i = 0
		j += 1
	else:
		a[i] = j
		i += 1
	k1 = a[0] * a[1] * a[2] * a[3] * a[4] * a[5] * a[6] * a[7] * a[8] * a[9]
c = 'c' * a[0]
c += 'o' * a[1]
c += 'd' * a[2]
c += 'e' * a[3]
c += 'f' * a[4]
c += 'o' * a[5]
c += 'r' * a[6]
c += 'c' * a[7]
c += 'e' * a[8]
c += 's' * a[9]
print(c)


k = int(input())
s = 'codeforces'
x = 1
while x ** 10 <= k:
	x += 1
x -= 1
num = x ** 10
ans = ''
for i in range(10):
	if num >= k:
		ans += s[i] * x
	else:
		ans += s[i] * (x + 1)
		num /= x
		num *= x + 1
print(ans)


arr = [1] * 10
k = int(input())
prod = 1
i = 0
while prod < k:
	a = arr[i]
	prod = prod // a * (a + 1)
	arr[i] += 1
	i = (i + 1) % 10
s = 'codeforces'
ans = ''
for i in range(10):
	ans += s[i] * arr[i]
print(ans)


import sys
import math
import itertools
import functools
import collections
import operator
import fileinput
import copy
ORDA = 97

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return [int(i) for i in input().split()]

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def revn(n):
	return str(n)[::-1]

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)

def sieve(n):
	if n < 2:
		return list()
	prime = [True for _ in range(n + 1)]
	p = 3
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 2
	r = [2]
	for p in range(3, n + 1, 2):
		if prime[p]:
			r.append(p)
	return r

def divs(n, start=1):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

def divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def convn(number, base):
	newnumber = 0
	while number > 0:
		newnumber += number % base
		number //= base
	return newnumber

def cdiv(n, k):
	return n // k + (n % k != 0)

def ispal(s):
	for i in range(len(s) // 2 + 1):
		if s[i] != s[-i - 1]:
			return False
	return True

def mul(arr):
	t = 1
	for i in arr:
		t *= i
	return t
d = 'codeforces'
n = ii()
a = [1] * 10
i = 0
while mul(a) < n:
	a[i % 10] += 1
	i += 1
s = ''
for i in range(10):
	s += d[i] * a[i]
print(s)


from math import *
str = 'codeforces'
eps = 1e-14
k = int(input())
k = float(k)
s = 10.0
x = floor(pow(k, 1.0 / s))
p = log2((x + 1.0) ** s / k) / log2((x + 1.0) / x)
p = int(p + eps)
x = int(x)
for i in range(p):
	for times in range(x):
		print(str[i], end='')
for i in range(p, int(s)):
	for times in range(x + 1):
		print(str[i], end='')
print()


k = int(input())
lst = []
str1 = []
str1.append('c')
str1.append('o')
str1.append('d')
str1.append('e')
str1.append('f')
str1.append('o')
str1.append('r')
str1.append('c')
str1.append('e')
str1.append('s')
for i in range(10):
	lst.append(1)
prod = 1
flag = 0
while True:
	for i in range(len(lst)):
		if prod >= k:
			flag = 1
			break
		prod = int(prod / lst[i])
		lst[i] += 1
		prod = prod * lst[i]
	if prod >= k:
		break
	if flag:
		break
str2 = ''
c = -1
for i in lst:
	c += 1
	for j in range(i):
		str2 += str1[c]
print(str2)


k = int(input())
j = 1
ans = ''
output = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
counts = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
if k <= j:
	for i in range(10):
		ans += output[i] * counts[i]
	print(ans)
else:
	prev = -1
	while j < k:
		if prev == 9:
			prev = 0
		else:
			prev += 1
		counts[prev] += 1
		j = j * counts[prev] // (counts[prev] - 1)
	ans = ''
	for i in range(10):
		ans += output[i] * counts[i]
	print(ans)


import sys
input = sys.stdin.readline
from math import log2, log, ceil

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def nCr(n, k):
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return res

def upper_bound(a, x, lo=0):
	hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	while x != link[x]:
		x = link[x]
	return x

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(1000000.0 + 5)
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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')

def find_parent(parent, i, cnt):
	cnt += 1
	if parent[i - 1] == i:
		return cnt
	if parent[i - 1] != i:
		find_parent(parent, parent[i - 1], cnt)
from collections import Counter
n = int(input())
t = list('codeforces')
arr = [1] * 10
s = 1
while s < n:
	for i in range(10):
		if s >= n:
			break
		s /= arr[i]
		arr[i] += 1
		s *= arr[i]
for i in range(10):
	print(t[i] * arr[i], end='')


k = int(input())
(l, pas) = (1, 1 << 54)
while pas:
	if (l + pas) ** 10 < k:
		l += pas
	pas >>= 1
d = [l] * 10
(i, p) = (0, l ** 10)
while i < 10 and p < k:
	d[i] += 1
	p = p // l * (l + 1)
	i += 1
for i in range(10):
	print('codeforces'[i] * d[i], end='')


import math

def multiplyList(myList):
	result = 1
	for x in myList:
		result = result * x
	return result
n = int(input())
i = 0
l = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
c = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
while multiplyList(l) < n:
	l[i] += 1
	i += 1
	if i > 9:
		i = 0
str_l = ''
for (a, b) in zip(l, c):
	str_l += a * b
print(str_l)


n = int(input())
arr = [1] * 10
Flag = True
i = 0
occ = 1
while True and Flag:
	for idx in range(10):
		if occ >= n:
			Flag = False
			break
		occ //= arr[idx]
		arr[idx] += 1
		occ *= arr[idx]
	i += 1
tar = 'codeforces'
ans = ''
for j in range(10):
	ans += tar[j] * arr[j]
print(ans)


def tc():
	k = int(input())
	base = 1
	while pow(base, 10) < k:
		base += 1
	less = 0
	while pow(base, 10 - less) * pow(base - 1, less) > k:
		less += 1
	if pow(base, 10 - less) * pow(base - 1, less) < k:
		less -= 1
	ans = ''
	s = 'codeforces'
	for ch in s[:less]:
		ans += ch * (base - 1)
	for ch in s[less:]:
		ans += ch * base
	print(ans)
tc()


k = int(input())
n = 1
l = [1] * 10
s = 'codeforces'
for i in range(1, 100):
	if n >= k:
		break
	for j in range(10):
		n //= i
		n *= i + 1
		l[j] = i + 1
		if n >= k:
			break
	else:
		continue
	break
ans = ''
for i in range(10):
	ans += s[i] * l[i]
print(ans)


k = int(input())
s = 'codeforces'
if k == 1:
	print(s)
elif k == 2:
	print(s + 's')
elif k == 3:
	print(s + 'ss')
else:
	x = 1
	lst = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
	while x < k:
		for i in range(0, 10):
			x = x // lst[i]
			lst[i] += 1
			x *= lst[i]
			if x >= k:
				break
	ns = ''
	for i in range(0, 10):
		ns = ns + s[i] * lst[i]
	print(ns)


from sys import stdin, stdout

def II():
	return int(stdin.readline())
k = II()
s = 'codeforces'
ans = 0
v = [1] * 10
prod = 1
while prod < k:
	for i in range(10):
		p = v[i]
		v[i] = p + 1
		prod = prod // p * (p + 1)
		if prod >= k:
			break
for i in range(10):
	stdout.write(s[i] * v[i])
stdout.write('\n')


import math
k = int(input())
s = 'codeforces'
lis = []
for i in range(40):
	lis.append(math.pow(i + 1, 10))
for i in range(40):
	if k <= lis[i]:
		n = i + 1
		break
if k == lis[n - 1]:
	ans = ''
	for i in range(10):
		for j in range(n):
			ans += s[i]
	print(ans)
else:
	for i in range(10):
		if k <= pow(n, i + 1) * pow(n - 1, 10 - i - 1):
			arr = [n, i + 1, n - 1, 10 - i - 1]
			break
	ans = ''
	for j in range(10):
		if j <= arr[1] - 1:
			for k in range(n):
				ans += s[j]
		else:
			for k in range(n - 1):
				ans += s[j]
	print(ans)


def prod(arr):
	ret = 1
	for a in arr:
		ret *= a
	return ret

def smallestPow(k):
	for i in range(1, 100000):
		if i ** 10 > k:
			return i - 1

def ans(K):
	s = smallestPow(K)
	ret = [s] * 10
	while prod(ret) < K:
		ret[ret.index(min(ret))] += 1
	retStr = ''
	for i in range(10):
		retStr += 'codeforces'[i] * ret[i]
	return retStr
K = int(input())
print(ans(K))


k = int(input())
in_str = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
ele_tot = 1
ans = ''
ele_val = [1] * 10
i = 0
while ele_tot < k:
	ele_tot = ele_tot / ele_val[i] * (ele_val[i] + 1)
	ele_val[i] = ele_val[i] + 1
	i = (i + 1) % 10
for i in range(10):
	for _ in range(ele_val[i]):
		ans = ans + in_str[i]
print(ans)


import math

def solve():
	t = int(input())
	current = 0
	letters = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
	arr = [1] * len(letters)
	product = 1
	while product < t:
		product /= arr[current]
		arr[current] += 1
		product *= arr[current]
		current = (current + 1) % len(arr)
	for i in range(len(letters)):
		print(letters[i] * arr[i], end='')
	print()
solve()


n = int(input())
if n <= 3:
	print('codeforce' + 's' * n)
else:
	i = 2
	while i ** 10 < n:
		i += 1
	if i ** 10 > n:
		i -= 1
	left = 0
	index = 0
	while (i + 1) ** index * i ** (10 - index) < n:
		index += 1
	st = 'codeforces'
	for s in range(10):
		if s < index:
			print(st[s] * (i + 1), end='')
		else:
			print(st[s] * i, end='')
	print()


k = int(input())
if k == 1:
	print('codeforces')
	exit()
number = 1
pointer = 0
multiply = 1
prevmul = -1
count = 1
string = 'codeforces'
while number < k:
	pointer = pointer % 10
	if pointer == 0:
		count += 1
		prevmul = multiply
		multiply += 1
		number = number // prevmul * multiply
		pointer += 1
		continue
	number = number // prevmul * multiply
	pointer += 1
string2 = ''
for i in range(pointer):
	string2 += string[i] * count
length = len(string)
for i in range(pointer, length):
	string2 += string[i] * (count - 1)
print(string2)


n = int(input())
lst1 = [1] * 10
ans = 1
j = 0
while 1:
	ans = 1
	for i in range(10):
		ans *= lst1[i]
	if ans < n:
		lst1[j] += 1
		j += 1
		if j == 10:
			j = 0
	else:
		break
s = 'codeforces'
for i in range(10):
	print(s[i] * lst1[i], end='')


k = int(input())
lower_bound = max(1, int(k ** (1 / 10)) - 1)
arr = [lower_bound for _ in range(10)]
prod = int(lower_bound ** 10)
i = 0
while prod < k:
	prod /= arr[i % 10]
	arr[i % 10] += 1
	prod *= arr[i % 10]
	i += 1
print(''.join([count * char for (count, char) in zip('codeforces', arr)]))


k = int(input())
s = 'codeforces'
s = list(s)
p = int(pow(k, 1 / 10))
t = pow(p, 10)
c = [p for i in range(10)]
ans = t
for i in range(10):
	if ans < k:
		ans //= c[i]
		ans *= c[i] + 1
		c[i] += 1
	print(c[i] * s[i], end='')


n = int(input())
s = 'codeforces'
cmn_rpt = 1
while True:
	if (cmn_rpt - 1) ** 10 < n <= cmn_rpt ** 10:
		break
	else:
		cmn_rpt += 1
(cmn_rpt, ans) = (cmn_rpt - 1, '')
if not cmn_rpt:
	print(s)
else:
	pos = 0
	for i in range(1, 11):
		if (cmn_rpt + 1) ** i * cmn_rpt ** (10 - i) >= n:
			pos = i - 1
			break
	for i in s:
		if pos + 1:
			print(i * (cmn_rpt + 1), end='')
			pos -= 1
		else:
			print(i * cmn_rpt, end='')


def subseq():
	k = int(input())
	i = 1
	while i ** 10 < k:
		i += 1
	ans = ''
	i -= 1
	arr = [i] * 10
	for j in range(len(arr)):
		arr[j] += 1
		prod = 1
		for m in arr:
			prod *= m
		if prod >= k:
			break
	for (ctr, letter) in enumerate('codeforces'):
		ans += letter * arr[ctr]
	print(ans)
subseq()


T = int(input())
import math
chars = 'codeforces'
if T == 1:
	print(chars)
else:
	max_repetition = math.ceil(pow(10, math.log10(T) / 10))
	higher_repetition = 0
	for higher_power in range(0, 11):
		if T <= pow(max_repetition - 1, 10 - higher_power) * pow(max_repetition, higher_power):
			higher_repetition = higher_power
			break
	final_string = ''
	for (index, char) in enumerate(chars):
		if index < higher_repetition:
			final_string += char * max_repetition
		else:
			final_string += char * (max_repetition - 1)
	print(final_string)


n = int(input())
s = 'codeforces'
li = [1] * 10
p = 1
i = 0
while p < n:
	temp = li[i]
	li[i] += 1
	p = p * li[i] // temp
	i += 1
	if i == 10:
		i = 0
for i in range(10):
	print(s[i] * li[i], end='')


k = int(input())
x = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
a = 'codeforces'
ans = 1
ind = 0
while ans < k:
	x[ind] += 1
	ans = 1
	for i in range(0, len(x)):
		ans *= x[i]
	ind += 1
	if ind == len(x):
		ind = 0
final = ''
for i in range(0, len(x)):
	final += x[i] * a[i]
print(final)


import sys
import math
import heapq
from collections import defaultdict, deque
input = sys.stdin.readline

def r():
	return int(input())

def rm():
	return map(int, input().split())

def rl():
	return list(map(int, input().split()))
nums = [0] * 10
num = 10
poww = (num // 10) ** (10 - num % 10) * (num // 10 + 1) ** (num % 10)
while poww <= 10 ** 17:
	nums.append(poww)
	num += 1
	poww = (num // 10) ** (10 - num % 10) * (num // 10 + 1) ** (num % 10)
n = r()
i = 10
while nums[i] < n:
	i += 1
a = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
s = ''
j = (i // 10, 10 - i % 10)
k = (i // 10 + 1, i % 10)
for l in range(j[1]):
	s += a[l] * j[0]
for l in range(j[1], 10):
	s += a[l] * k[0]
print(s)


from sys import stdout
from sys import stdin

def get():
	return stdin.readline().strip()

def getf():
	return [int(i) for i in get().split()]

def put(a, end='\n'):
	stdout.write(str(a) + end)

def putf(a, sep=' ', end='\n'):
	stdout.write(sep.join(map(str, a)) + end)

def main():
	k = int(get())
	a = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
	b = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
	q = 1
	i = 0
	while q < k:
		q //= b[i]
		q *= b[i] + 1
		b[i] += 1
		i = (i + 1) % 10
	ans = ''
	for i in range(10):
		ans += a[i] * b[i]
	put(ans)
main()


n = int(input())
k = 1
i = 0
v = [1] * 10
while k < n:
	p = v[i % 10]
	k //= p
	v[i % 10] += 1
	k *= v[i % 10]
	i += 1
s = 'codeforces'
for i in range(10):
	print(s[i] * v[i], end='')


k = int(input())
i = 2
while i ** 10 < k:
	i += 1
j = 1
while i ** j * (i - 1) ** (10 - j) < k:
	j += 1
if k == 1:
	print('codeforces')
else:
	l = 1
	mul = i
	t = ''
	for c in 'codeforces':
		t += c * mul
		l += 1
		if l > j:
			mul = i - 1
	print(t)


k = int(input())
for i in range(1, 100):
	if i ** 10 <= k < (i + 1) ** 10:
		for n in range(11):
			if (i + 1) ** n * i ** (10 - n) >= k:
				print(''.join((c * (i + 1 if j < n else i) for (j, c) in enumerate('codeforces'))))
				exit(0)


k = int(input())
a = []
for i in range(0, 10):
	a.append(1)
i = 0
pro = 1
while pro < k:
	pro = pro / a[i]
	a[i] += 1
	pro = pro * a[i]
	i += 1
	i = i % 10
ans = ''
string = 'codeforces'
for i in range(0, 10):
	ans += a[i] * string[i]
print(ans)


import sys
sys.setrecursionlimit(10000)
k = int(input())
s = 'codeforces'
length = 10
for x in range(k):
	times = x // length + 1
	extra = x % length
	ans = times ** (10 - extra) * (times + 1) ** extra
	if ans >= k:
		break
for (ind, letter) in enumerate(s):
	if 10 - ind <= extra:
		till = 1
	else:
		till = 0
	for _ in range(times + till):
		print(letter, end='')
print()


n = int(input())
import math
m = 10
a = 1
for i in ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']:
	print(i * math.ceil(n ** (1 / m) - 10 ** (-14)), end='')
	a *= math.ceil(n ** (1 / m) - 10 ** (-14))
	n = math.ceil(n / math.ceil(n ** (1 / m)) - 10 ** (-14))
	m -= 1


l = [1]
for i in range(1, 41):
	l.append(i ** 10)
s = list('codeforces')
k = int(input())
rem = 0
for i in range(1, len(l)):
	if k < l[i]:
		rem = i - 1
		break
start = l[i - 1]
cnt = 0
while start < k:
	start = start // rem * (rem + 1)
	cnt += 1
	if cnt > 10:
		break
ans = ''
for i in range(10):
	if i < cnt:
		ans += s[i] * (rem + 1)
	else:
		ans += s[i] * rem
print(ans)


from sys import stdin, stdout
from math import log, ceil
k = int(stdin.readline())
if k == 1:
	print('codeforces')
else:
	arr = [1] * 10
	power_arr = [0] * 40
	p = 2
	while ceil(log(k, p)) > 10:
		power_arr[p - 2] = 10
		p += 1
	a1 = 10
	a2 = 0
	temp1 = (p - 1) ** a1 * p ** a2
	while temp1 < k:
		a1 -= 1
		a2 += 1
		temp1 = (p - 1) ** a1 * p ** a2
	power_arr[p - 2] = a2
	if 0 in power_arr:
		ind0 = power_arr.index(0) - 1
	else:
		ind0 = 33
	temp = 0
	for i in range(power_arr[ind0]):
		arr[i] = ind0 + 2
		temp += 1
	for i in range(temp, 10):
		arr[i] = ind0 + 1
	ans = 'c' * arr[0] + 'o' * arr[1] + 'd' * arr[2] + 'e' * arr[3] + 'f' * arr[4] + 'o' * arr[5] + 'r' * arr[6] + 'c' * arr[7] + 'e' * arr[8] + 's' * arr[9]
	stdout.write(ans + '\n')


k = int(input())
stringcode = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
score = 1
counter = 1
while score <= k:
	counter += 1
	score = counter ** 10
score = (counter - 1) ** 10
counter -= 1
for i in range(11):
	if (counter + 1) ** i * counter ** (10 - i) >= k:
		string = ''
		for j in range(i):
			string += stringcode[j] * (counter + 1)
		for j in range(i, 10):
			string += stringcode[j] * counter
		break
print(string)


def prod(arr):
	ans = 1
	for i in arr:
		ans *= i
	return ans
n = int(input())
h = []
a = [1] * 10
for i in range(1, n):
	if n <= i ** 10:
		ind = i
		break
nn = 1
arr = [1] * 10
i = 0
while prod(arr) < n:
	i = i % 10
	arr[i] += 1
	i += 1
for i in range(len(arr)):
	if arr[i] != 0:
		a[i] *= arr[i]
st = 'codeforces'
s = ''
for i in range(len(a)):
	s += st[i]
	for j in range(a[i] - 1):
		s += st[i]
print(s)


k = int(input())
s = 'codeforces'
for i in range(2, 50):
	for j in range(10):
		mul = i ** j * (i - 1) ** (10 - j)
		if mul >= k:
			ans = ''
			for l in range(10):
				if l < j:
					ans += s[l] * i
				else:
					ans += s[l] * (i - 1)
			print(ans)
			exit(0)


from sys import stdin
input = stdin.readline
k = int(input())
s = 'codeforces'
l = len(s)
c = [1] * l
cnt = 1
cur = 0
while cnt < k:
	cnt = cnt / c[cur] * (c[cur] + 1)
	c[cur] += 1
	cur = (cur + 1) % l
res = [s[i] * c[i] for i in range(l)]
print(''.join(res))


n = int(input())
l = [1] * 10
p = 1
while p < n:
	i = l.index(min(l))
	p = p // l[i]
	l[i] += 1
	p *= l[i]
st = 'codeforces'
for i in range(10):
	print(st[i] * l[i], end='')


def func(n):
	s = 'codeforces'
	ans = ''
	num = 1
	rem = 10
	curr = 0
	index = 0
	a = b = 1
	while num < n:
		if curr == 0:
			a += 1
		if curr == 10:
			b = a
			a += 1
			curr = 0
			rem = 10
		curr += 1
		rem -= 1
		num = a ** curr * b ** rem
	l = [a] * curr + [b] * rem
	for i in range(10):
		ans += s[i] * l[i]
	return ans
n = int(input())
print(func(n))


import math
k = int(input())
c = [1] * 10
s = 1
st = 'codeforces'
while s < k:
	for i in range(10):
		s //= c[i]
		c[i] += 1
		s *= c[i]
		if s >= k:
			break
for i in range(10):
	print(st[i] * c[i], end='')


from math import log, floor, ceil
k = int(input())
base = 1
while base ** 10 < k:
	base += 1
counts_base = 0
count_1 = 10
while base ** counts_base * (base - 1) ** count_1 < k:
	counts_base += 1
	count_1 -= 1
codeforces = 'codeforces'
ans = ''
for i in range(counts_base):
	ans += codeforces[i] * base
for i in range(count_1):
	ans += codeforces[counts_base + i] * (base - 1)
print(ans)


k = int(input())
x = [1] * 10
p = 1
while p < k:
	for i in range(10):
		x[i] += 1
		p = 1
		for j in range(10):
			p *= x[j]
		if p >= k:
			break
print('c' * x[0], end='')
print('o' * x[1], end='')
print('d' * x[2], end='')
print('e' * x[3], end='')
print('f' * x[4], end='')
print('o' * x[5], end='')
print('r' * x[6], end='')
print('c' * x[7], end='')
print('e' * x[8], end='')
print('s' * x[9], end='')


import sys
fast_reader = sys.stdin.readline
fast_writer = sys.stdout.write

def input():
	return fast_reader().strip()

def print(*argv):
	fast_writer(' '.join((str(i) for i in argv)))
	fast_writer('\n')

def list_input():
	return list(map(int, input().split()))

def sep_input():
	return map(int, input().split())

def f(l):
	s = 'codeforces'
	ans = ''
	for i in range(10):
		ans += s[i] * l[i]
	return ans

def calc(l):
	c = 1
	for i in range(len(l)):
		c *= l[i]
	return c
n = int(input())
l = [1 for i in range(10)]
i = 0
while True:
	if calc(l) >= n:
		break
	else:
		l[i % 10] += 1
		i += 1
print(f(l))


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
mod2 = 998244353
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def IF(c, t, f):
	return t if c else f

def YES(c):
	return IF(c, 'YES', 'NO')

def Yes(c):
	return IF(c, 'Yes', 'No')

def main():
	t = 1
	rr = []
	for _ in range(t):
		k = I()
		t = 'codeforces'
		if k == 1:
			return t
		l = len(t)
		r = [1] * l
		for i in range(1000):
			r[i % l] += 1
			u = 1
			for c in r:
				u *= c
			if u >= k:
				break
		v = [a * b for (a, b) in zip(t, r)]
		rr.append(JA(v, ''))
	return JA(rr, '\n')
print(main())


ll = lambda : list(map(int, input().split()))
st = lambda : input()
v = lambda : map(int, input().split())
ii = lambda : int(input())
from collections import *
import math
k = ii()
s = 1
i = 0
v = [1] * 10
st = 'codeforces'
while s < k:
	v[i] += 1
	i = (i + 1) % 10
	s = 1
	for j in range(10):
		s *= v[j]
ans = ''
for i in range(10):
	for j in range(v[i]):
		ans += st[i]
print(ans)


from sys import stdin

def iinput():
	return int(stdin.readline())

def sinput():
	return input()

def minput():
	return map(int, stdin.readline().split())

def linput():
	return list(map(int, stdin.readline().split()))
k = iinput()
p = 1
a = [1] * 10
s = 'codeforces'
i = 0
while p < k:
	a[i] += 1
	p = p * a[i] // (a[i] - 1)
	i = (i + 1) % 10
for i in range(10):
	print(s[i] * a[i], end='')


from math import ceil

def help():
	k = int(input())
	if k == 1:
		print('codeforces')
		return
	stri = 'codeforces'
	occurance = [1] * 10
	product = 1
	ind_ch = 0
	while True:
		if product >= k:
			for i in range(10):
				print(stri[i] * occurance[i], end='')
			print()
			return
		occurance[ind_ch] += 1
		product = 1
		for i in range(10):
			product *= occurance[i]
		ind_ch += 1
		ind_ch = ind_ch % 10
help()


from sys import stdin, stdout
import math
from itertools import permutations, combinations
from collections import defaultdict
from bisect import bisect_left
from bisect import bisect_right

def L():
	return list(map(int, stdin.readline().split()))

def In():
	return map(int, stdin.readline().split())

def I():
	return int(stdin.readline())
P = 1000000007

def main():
	k = I()
	n = int(k ** 0.1)
	m = n ** 10
	for c in 'codeforces':
		l = n + (m < k)
		print(c * l, end='')
		m = m // n * l
main()


def main():
	n = int(input())
	str = 'codeforces'
	arr = [1] * len(str)
	idx = 0
	ans = ''
	product = 1
	while product < n:
		product /= arr[idx]
		arr[idx] += 1
		product *= arr[idx]
		idx += 1
		idx %= len(str)
	for i in range(len(str)):
		ans += str[i] * arr[i]
	print(ans)
main()


def mult(a):
	b = 1
	for i in a:
		b *= i
	return b
k = int(input())
c = [1] * 10
s = 'codeforces'
n = 0
while mult(c) < k:
	i = n % 10
	c[i] += 1
	n += 1
print(''.join([s[j] * c[j] for j in range(10)]))


k = int(input())
n = int(k ** 0.1)
m = n ** 10
for c in 'codeforces':
	l = n + (m < k)
	print(c * l, end='')
	m = m // n * l


import math
k = int(input())
lst = 1
for i in range(1, 41):
	if i ** 10 <= k:
		lst = i
	else:
		break
freq = [lst for i in range(10)]
s = 'codeforces'
if lst ** 10 == k:
	print(''.join([s[i] * freq[i] for i in range(10)]))
else:
	prod = lst ** 10
	for i in range(10):
		if prod >= k:
			break
		prod /= freq[i]
		freq[i] += 1
		prod *= freq[i]
	print(''.join([s[i] * freq[i] for i in range(10)]))


k = int(input())
s = 'codeforces'
(i, sm) = (0, 1)
l = [1] * 10
while sm < k:
	sm //= l[i]
	l[i] += 1
	sm *= l[i]
	i = (i + 1) % 10
ans = [s[i] * l[i] for i in range(10)]
print(''.join(ans))


def codeforces(k):
	S = 'codeforces'
	if k == 1:
		return S
	x = 2
	while x ** 10 <= k:
		x += 1
	i = 10
	while (x - 1) ** i * x ** (10 - i) < k:
		i -= 1
	res = ''
	for j in range(i):
		res += S[j] * (x - 1)
	for j in range(i, 10):
		res += S[j] * x
	return res
k = int(input())
print(codeforces(k))


k = int(input())
l = 1
r = 40
while l + 1 != r:
	m = (l + r) // 2
	x = m ** 10
	if x > k:
		r = m
	elif x == k:
		l = m
		r = m + 1
	else:
		l = m
p = l ** 10
exp = 0
while p < k:
	p = p // l * r
	exp += 1
ls = []
for i in 'codeforces':
	if exp == 0:
		ls.extend([i] * l)
	else:
		ls.extend([i] * r)
		exp -= 1
print(''.join(ls))


from math import pow, floor, log10
s = 'codeforces'
t = int(input())
k = floor(pow(10, log10(t) / 10))
x = 0
while True:
	if pow(k + 1, x) * pow(k, 10 - x) >= t:
		break
	x = x + 1
for i in range(0, 10):
	for j in range(0, k + (i < x)):
		print(s[i], end='')


import sys
input = sys.stdin.readline
import collections
from heapq import *

def linput(_t=int):
	return list(map(_t, input().split()))

def gcd(n, m):
	while m:
		(n, m) = (m, n % m)
	return n

def lcm(n, m):
	return n * m // gcd(n, m)

def prime_factorize(n):
	r = []
	rapp = r.append
	while n % 2 < 1:
		rapp(2)
		n //= 2
	f = 3
	while f * f <= n:
		if n % f < 1:
			rapp(f)
			n //= f
		else:
			f += 2
	if n != 1:
		rapp(n)
	return r

def main():
	N = int(input())
	sT = 'codeforces'
	res = ''
	vR = [1] * len(sT)
	heapify(vR)
	cnt = 1
	while cnt < N:
		P = heappop(vR)
		heappush(vR, P + 1)
		cnt += cnt // P
	for (R, s) in zip(vR, sT):
		res += s * R
	print(res)
main()


from sys import stdin, stdout
import math
input = stdin.readline

def print(x='', end='\n'):
	stdout.write(str(x) + end)

def solve():
	k = int(input())
	s = 'codeforces'
	l = [1] * 10
	i = 0
	cur = 1
	while cur < k:
		cur //= l[i]
		l[i] += 1
		cur *= l[i]
		i = (i + 1) % 10
	for i in range(10):
		for j in range(l[i]):
			print(s[i], end='')
	print()
test = 1
for __ in range(test):
	solve()


k = int(input())
frequencies = [1] * 10
string = 'codeforces'
place = 0
while True:
	product = 1
	for j in frequencies:
		product *= j
	if product >= k:
		for k in range(10):
			print(string[k] * frequencies[k], end='')
		break
	else:
		frequencies[place] += 1
		place = (place + 1) % 10


n = int(input())
temp = [1] * 10
index = 9
val = 1
while True:
	val = 1
	for i in range(10):
		val *= temp[i]
	if val >= n:
		break
	temp[index] += 1
	index -= 1
	if index == -1:
		index = 9
str = ''
c = 'codeforces'
for i in range(10):
	str += c[i] * temp[i]
print(str)


from collections import deque
import sys
import math

def get(f):
	p = 1
	for i in f:
		p *= i
	return p

def inp():
	return sys.stdin.readline().strip()
k = int(inp())
base = 2
s = 'codeforces'
p = 1
f = [1] * 10
pos = 0
while get(f) < k:
	f[pos] += 1
	pos = (pos + 1) % 10
ans = ''
for i in range(10):
	ans += s[i] * f[i]
print(ans)


TOKEN = 'codeforces'

def solve(n: int) -> str:
	v = 1
	counts = [1] * 10
	i = 0
	while v < n:
		v = v // counts[i] * (counts[i] + 1)
		counts[i] += 1
		i = (i + 1) % 10
	return ''.join((TOKEN[_] * counts[_] for _ in range(10)))
n = int(input())
r = solve(n)
print(r)


def pr(lst):
	prr = 1
	for i in lst:
		prr *= i
	return prr

def solve():
	k = int(input())
	l = int(k ** (1 / 10))
	a = [l for i in range(10)]
	st = 'codeforces'
	for i in range(10):
		if pr(a) >= k:
			continue
		a[i] += 1
	for i in range(10):
		print(a[i] * st[i], end='')
for i in range(1):
	solve()


def prod(a):
	p = 1
	for i in a:
		p *= i
	return p
k = int(input())
a = [1] * 10
flag = True
s = 'codeforces'
if k == 1:
	flag = False
while flag:
	for i in range(10):
		a[i] += 1
		if prod(a) >= k:
			flag = False
			break
ans = ''
for i in range(10):
	ans += a[i] * s[i]
print(ans)


k = int(input())
s = 'codeforces'
a = [1] * 10
ans = 1
pointer = 0
while ans < k:
	ans = ans // a[pointer]
	a[pointer] += 1
	ans = ans * a[pointer]
	pointer = (pointer + 1) % 10
ans1 = []
for i in range(10):
	for j in range(a[i]):
		ans1.append(s[i])
print(''.join(ans1))


from functools import reduce

def solve():
	k = int(input())
	b = 1
	while b ** 10 < k:
		b += 1
	a = [b] * 10
	for i in range(10):
		if reduce(int.__mul__, a) // a[i] * (a[i] - 1) >= k:
			a[i] -= 1
	r = [i * j for (i, j) in zip('codeforces', a)]
	print(''.join(r))
solve()


n = int(input())
s = 'codeforces'
k = 0
a = [1] * 10
curr = 1
f = 0
while 1:
	if curr >= n:
		f = 1
		break
	for i in range(10):
		curr /= a[i]
		curr *= a[i] + 1
		a[i] += 1
		if curr >= n:
			f = 1
			break
	if f:
		break
for i in range(10):
	print(s[i] * a[i], end='')


k = int(input())
rk = k
ans = 'codeforces'
x = 0
if k == 1:
	print(ans)
else:
	n = 10
	ind = [1] * n
	res = ''
	pro = 1
	while pro < k:
		pro = pro // ind[x % n] * (ind[x % n] + 1)
		ind[x % n] += 1
		x += 1
	for i in range(n):
		res += ans[i] * ind[i]
	print(res)


k = int(input())
if k == 1:
	print('codeforces')
else:
	j = 0
	while j ** 10 < k:
		j += 1
	j -= 1
	r = j
	p = j + 1
	s1 = 0
	s2 = 0
	for j in range(0, 10):
		if r ** (10 - j) * p ** j >= k:
			s1 = 10 - j
			s2 = j
			break
	s = ''
	s3 = 'codeforces'
	for j in range(0, s1):
		for k in range(0, r):
			s += s3[j]
	for j in range(s1, 10):
		for k in range(0, p):
			s += s3[j]
	print(s)


def product(arr):
	p = 1
	for i in arr:
		p = p * i
	return p

def solve(n):
	arr = [1 for i in range(10)]
	k = 0
	while n > product(arr):
		arr[k] = arr[k] + 1
		k = k + 1
		if k == 10:
			k = 0
	string = 'c' * arr[0] + 'o' * arr[1] + 'd' * arr[2] + 'e' * arr[3] + 'f' * arr[4] + 'o' * arr[5] + 'r' * arr[6] + 'c' * arr[7] + 'e' * arr[8] + 's' * arr[9]
	print(string)
n = int(input())
solve(n)


k = int(input())
i = 1
while pow(i, 10) < k:
	i += 1
for j in range(1, 11):
	temp = pow(i - 1, 10 - j) * pow(i, j)
	if temp >= k:
		break
st = 'codeforces'
for l in range(j):
	print(st[l] * i, end='')
for l in range(10 - j):
	print(st[j + l] * (i - 1), end='')
print()


k = int(input())
a = [1 for i in range(10)]
cnt = 2
i = 0
prod = 1
while prod < k:
	prod = prod / a[i]
	a[i] = cnt
	prod = prod * a[i]
	i = i + 1
	if i >= 10:
		i = 0
		cnt = cnt + 1
ans = 'codeforces'
anss = []
for i in range(10):
	for j in range(a[i]):
		anss.append(ans[i])
print(*anss, sep='')


import sys
import math
from itertools import combinations
input = lambda : sys.stdin.readline().strip()
k = int(input())
res = 'codeforces'
ans = [1] * 10
l = 0
while 1:
	n = 1
	for i in range(10):
		n *= ans[i]
	if n >= k:
		break
	ans[l] += 1
	l = (l + 1) % 10
for i in range(len(ans)):
	print(res[i] * ans[i], end='')
print()


a = int(input())
p = 0
while pow(p, 10) <= a:
	p = p + 1
p = p - 1
p1 = 0
for i in range(0, 11):
	if pow(p, 10 - i) * pow(p + 1, i) >= a:
		p1 = i
		break
arr = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
ans = []
for i in range(0, len(arr)):
	if i < 10 - p1:
		ans.append(arr[i] * p)
	else:
		ans.append(arr[i] * (p + 1))
print(''.join(ans))


import sys
import functools
input = lambda : sys.stdin.readline().strip('\r\n')
k = int(input())
l = [1] * 10
pro = functools.reduce(lambda a, b: a * b, l)
i = 0
while pro < k:
	i = i % 10
	l[i] += 1
	i += 1
	pro = functools.reduce(lambda a, b: a * b, l)
ans = []
ans.append('c' * l[0])
ans.append('o' * l[1])
ans.append('d' * l[2])
ans.append('e' * l[3])
ans.append('f' * l[4])
ans.append('o' * l[5])
ans.append('r' * l[6])
ans.append('c' * l[7])
ans.append('e' * l[8])
ans.append('s' * l[9])
print(''.join(ans))


K = int(input())
S = list('codeforces')
A = [1 for _ in range(len(S))]
r = 1
i = 0
while r < K:
	r = r // A[i % 10]
	A[i % 10] += 1
	r = r * A[i % 10]
	i += 1
result = []
for i in range(10):
	result.append(S[i] * A[i])
print(''.join(result))


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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')

def inin():
	return int(input())

def inar():
	return list(map(int, input().split()))
from math import sqrt
Testcase = 1
for _ in range(Testcase):
	k = inin()
	st = 'codeforces'
	c = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
	muk = 1
	index = 0
	curr = 1
	while muk < k:
		if index % 10 == 0:
			curr += 1
			index = 0
		muk //= c[index]
		c[index] = curr
		muk *= c[index]
		index += 1
	print(''.join([st[i] * c[i] for i in range(10)]))


def func(a):
	ans = 1
	for i in a:
		ans *= i
	return ans
n = int(input())
a = [1] * 10
i = 0
while func(a) < n:
	a[i] += 1
	i += 1
	i %= 10
print('c' * a[0] + 'o' * a[1] + 'd' * a[2] + 'e' * a[3] + 'f' * a[4] + 'o' * a[5] + 'r' * a[6] + 'c' * a[7] + 'e' * a[8] + 's' * a[9])


n = int(input())
l1 = [1 for _ in range(10)]
i = 0
product = 1
while product < n:
	product = 1
	l1[i % 10] += 1
	for j in l1:
		product *= j
	i += 1
for i in range(10):
	print(l1[i] * 'codeforces'[i], end='')


n = int(input())
s = 'codeforces'
l = []
for i in range(10):
	l.append(1)
p = 1
c = ''
while p < n:
	for i in range(10):
		l[i] += 1
		p = p // (l[i] - 1)
		p *= l[i]
		if p >= n:
			break
for i in range(10):
	c += l[i] * s[i]
print(c)


k = int(input())
summ = [10]
prod = [1]
div = 1
mul = 2
while prod[-1] <= 10 ** 16:
	for i in range(10):
		prod.append(prod[-1] // div * mul)
		summ.append(summ[-1] + 1)
	mul += 1
	div += 1
for i in range(len(prod)):
	if k <= prod[i]:
		ans = summ[i]
		break
x = ans // 10
y = ans % 10
s = ''
base = 'codeforces'
for i in base:
	s += i * x
	if y > 0:
		s += i
		y -= 1
print(s)


from math import log2, floor, ceil
x = []
c = 'codeforces'
k = int(input())
l = [1] * 10
s = 1
i = 0
while s < k:
	s = s // l[i]
	l[i] += 1
	s *= l[i]
	i += 1
	if i == 10:
		i = 0
for i in range(10):
	x.append(c[i] * l[i])
print(''.join(x))


k = int(input())
i = 0
while i ** 10 <= k:
	i += 1
j = 0
while (i - 1) ** (10 - j) * i ** j < k:
	j += 1
ans = ''
c = 'codeforces'
for x in range(j):
	ans += c[x] * i
for x in range(j, 10):
	ans += c[x] * (i - 1)
print(ans)


def product(arr):
	pr = 1
	for i in arr:
		pr *= i
	return pr
k = int(input())
word = [1 for i in range(10)]
while product(word) < k:
	for i in range(10):
		word[i] += 1
		if product(word) >= k:
			break
print('c' * word[0], end='', sep='')
print('o' * word[1], end='', sep='')
print('d' * word[2], end='', sep='')
print('e' * word[3], end='', sep='')
print('f' * word[4], end='', sep='')
print('o' * word[5], end='', sep='')
print('r' * word[6], end='', sep='')
print('c' * word[7], end='', sep='')
print('e' * word[8], end='', sep='')
print('s' * word[9], end='', sep='')


from sys import stdin, stdout
import math
k = int(stdin.readline().strip())
arr = [1 for i in range(10)]
val = 1
ind = 0

def increment(arr, prev_val, ind):
	ind = ind % len(arr)
	prev_val = prev_val // arr[ind]
	arr[ind] += 1
	prev_val = prev_val * arr[ind]
	return prev_val
while True:
	val = increment(arr, val, ind)
	ind = (ind + 1) % 10
	if val >= k:
		break
s = 'codeforces'
if k > 3:
	for i in range(len(arr)):
		stdout.write(s[i] * arr[i])
elif k == 1:
	stdout.write(s)
elif k == 2:
	stdout.write(s + 's')
else:
	stdout.write(s + 'ss')


n = int(input())
string = 'codeforces'
arr = [0] * 11
for i in range(10):
	arr[i] = 1
product = 1
while product < n:
	for i in range(10):
		arr[i] += 1
		product = product // (arr[i] - 1)
		product = product * arr[i]
		if product >= n:
			break
for i in range(10):
	while arr[i] > 0:
		print(string[i], end='')
		arr[i] -= 1


import sys
input = sys.stdin.readline
from math import ceil, floor, factorial

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def nCr(n, k):
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def upper_bound(a, x, lo=0):
	hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(10000000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def factoriazation(x):
	ret = {}
	while x != 1:
		ret[spf[x]] = ret.get(spf[x], 0) + 1
		x = x // spf[x]
	return ret

def int_array():
	return list(map(int, input().strip().split()))

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
k = int(input())
x = 1
while 1:
	if k == x ** 10:
		break
	if k < x ** 10:
		x -= 1
		break
	x += 1
rem = k - x ** 10
now = x ** 10
back = 0
while now < k:
	back += 1
	now = now // x
	now *= x + 1
ans = [x] * 10
for i in range(9, -1, -1):
	if back == 0:
		break
	ans[i] += 1
	back -= 1
answer = []
s = 'codeforces'
for i in range(10):
	for j in range(ans[i]):
		answer.append(s[i])
answer = ''.join(answer)
print(answer)


from math import ceil, log
k = int(input())
S = 'codeforces'
n = int(k ** 0.1)
D = [n for i in range(10)]
P = D[0] ** 10
for i in range(10):
	if P >= k:
		break
	else:
		P = P * (n + 1) / n
		D[i] = n + 1
X = ''
for i in range(10):
	X = X + S[i] * D[i]
print(X)


k = int(input())
s = 'codeforces'
n = len(s)
times = [1] * n
count = 1
i = 0
while count < k:
	temp = times[i]
	times[i] += 1
	count = count * times[i] // temp
	i += 1
	i %= n
for i in range(n):
	print(s[i] * times[i], end='')


import math

def res(arr):
	diff = 0
	for i in range(3):
		diff = diff ^ arr[i]
	if diff == 0:
		return 1
	for i in range(2):
		if brr[i] % arr[i] != 0:
			continue
		div = brr[i] // arr[i]
		count = 0
		for j in range(i + 1, 3):
			if brr[j] % arr[j] != 0:
				continue
			if div == brr[j] // arr[j]:
				count += 1
		if count > 1:
			return 2

def solution():
	n = int(input())
	low = math.floor(n ** (1 / 10))
	st = 'codeforces'
	cal = low ** 10
	lo = [low for i in range(10)]
	for i in range(0, 10):
		if cal >= n:
			break
		lo[i] = low + 1
		cal = cal // low
		cal *= low + 1
	for i in range(10):
		print(st[i] * lo[i], end='')
solution()


from itertools import *

def pr(it):
	i = 1
	for x in it:
		i *= x
	return i
k = int(input())
s = 'codeforces'
counts = [1] * 10
while pr(counts) < k:
	counts = [counts[-1] + 1] + counts[:-1]
for i in range(10):
	print(s[i] * counts[i], end='')


import sys
pprint = lambda s: print(' '.join(map(str, s)))
input = lambda : sys.stdin.readline().strip()
ipnut = input
n = int(input())

def lg(a):
	ans = 1
	while ans ** 10 < a:
		ans += 1
	return ans
l = lg(n)
ans = 1
s = 'codeforces'
ansv = ''
for i in range(10):
	ansv += s[i] * l
	ans *= l
	if ans * (l - 1) ** (10 - i - 1) >= n:
		l -= 1
print(ansv)


k = int(input())
pro = 1
s = 'codeforces'
a = [1 for i in range(10)]
p = 0
while pro < k:
	p %= 10
	pro /= a[p]
	a[p] += 1
	pro *= a[p]
	p += 1
for i in range(10):
	for j in range(a[i]):
		print(s[i], end='')
print()


from sys import stdin, stdout
import sys
from math import *

def mul(a):
	x = 1
	for i in range(len(a)):
		x *= a[i]
	return x
n = int(input())
a = list('codeforces')
b = [1] * len(a)
x = 1
i = 0
while mul(b) < n:
	b[i % len(a)] += 1
	i += 1
for i in range(len(a)):
	print(b[i] * a[i], end='')


from sys import exit, stdin, stderr

def rl():
	return [int(w) for w in stdin.readline().split()]
(k,) = rl()
s = ''
l = 10
r = 1
for c in 'codeforces':
	ri = 1
	while r * ri ** l < k:
		ri += 1
	r *= ri
	l -= 1
	s += c * ri
print(s)


import sys

def rs():
	return sys.stdin.readline().rstrip()

def ri():
	return int(sys.stdin.readline())

def ria():
	return list(map(int, sys.stdin.readline().split()))

def ws(s):
	sys.stdout.write(s + '\n')

def wi(n):
	sys.stdout.write(str(n) + '\n')

def wia(a):
	sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
from functools import reduce
from operator import mul

def product(a):
	return reduce(mul, a, 1)

def solve(k):
	s = 'codeforces'
	n = len(s)
	f = [1] * n
	i = 0
	while product(f) < k:
		f[i % n] += 1
		i += 1
	return ''.join([s[i] * f[i] for i in range(n)])

def main():
	k = ri()
	wi(solve(k))
main()


import math

def prod(a):
	ans = 1
	for i in a:
		ans *= i
	return ans
k = int(input())
q = [1] * 10
try:
	while 1:
		for ii in range(10):
			if prod(q) >= k:
				raise ValueError()
			q[ii] += 1
except:
	pass
for (char, num) in zip('codeforces', q):
	print(char * num, end='')


from sys import stdin, stdout
n = int(input())
vfreq = [1] * 10
total = 1
i = 0
while total < n:
	total //= vfreq[i]
	vfreq[i] += 1
	total *= vfreq[i]
	i = (i + 1) % 10
s = 'codeforces'
i = 0
for c in s:
	stdout.write(c * vfreq[i])
	i += 1


def search(p, n):
	t = 1
	while t ** p < n:
		t += 1
	return t
n = int(input())
s = 'codeforces'
for i in range(10):
	t = search(10 - i, n)
	print(s[i] * t, end='')
	n = (n + t - 1) // t


k = int(input())
l = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
x = k ** 0.1
x = int(x)
index = 0
while (x + 1) ** index * x ** (10 - index) < k:
	index += 1
for i in l:
	if index:
		index -= 1
		print(i * int(x + 1), end='')
	else:
		print(i * int(x), end='')
print()


def mi():
	return map(int, input().split())
n = int(input())
v = [1] * 10
pro = 1
d = False
while not d:
	for i in range(10):
		if pro >= n:
			d = True
			break
		v[i] += 1
		pro = pro * v[i] // (v[i] - 1)
out = 'codeforces'
print(''.join([out[i] * v[i] for i in range(10)]))


import math
n = int(input())
if n == 1:
	print('codeforces')
elif n == 2:
	print('codeforcess')
elif n == 3:
	print('codeforcesss')
else:
	s = 'codeforces'
	for i in range(1, 40):
		for j in range(10):
			count = i ** (10 - j) * (i + 1) ** j
			if count >= n:
				break
		if count >= n:
			break
	ans = ''
	l = 0
	for k in range(10 - j):
		ans += s[l] * i
		l += 1
	for k in range(j):
		ans += s[l] * (i + 1)
		l += 1
	print(ans)


def solve(k):
	l = [1 for i in range(10)]
	pos = 0
	i = 0
	prod = 1
	while prod < k:
		prod = int(prod / l[pos % 10])
		l[pos % 10] += 1
		prod *= l[pos % 10]
		pos += 1
	s = 'codeforces'
	ans = ''
	for i in range(10):
		for j in range(l[i]):
			ans += str(s[i])
	return ans
k = int(input())
print(solve(k))


import bisect
import decimal
from decimal import Decimal
import os
from collections import Counter
import bisect
from collections import defaultdict
import math
import random
import heapq
from math import sqrt
import sys
from functools import reduce, cmp_to_key
from collections import deque
import threading
from itertools import combinations
from io import BytesIO, IOBase
from itertools import accumulate
decimal.getcontext().prec = 46

def primeFactors(n):
	prime = set()
	while n % 2 == 0:
		prime.add(2)
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			prime.add(i)
			n = n // i
	if n > 2:
		prime.add(n)
	return list(prime)

def getFactors(n):
	factors = []
	i = 1
	while i <= math.sqrt(n):
		if n % i == 0:
			if n // i == i:
				factors.append(i)
			else:
				factors.append(i)
				factors.append(n // i)
		i = i + 1
	return factors

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	num = []
	for p in range(2, n + 1):
		if prime[p]:
			num.append(p)
	return num

def lcm(a, b):
	return a * b // math.gcd(a, b)

def sort_dict(key_value):
	return sorted(key_value.items(), key=lambda kv: (kv[1], kv[0]))

def list_input():
	return list(map(int, input().split()))

def num_input():
	return map(int, input().split())

def string_list():
	return list(input())

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def binaryToDecimal(n):
	return int(n, 2)

def DFS(n, s, adj):
	visited = [False for i in range(n + 1)]
	stack = []
	stack.append(s)
	while len(stack):
		s = stack[-1]
		stack.pop()
		if not visited[s]:
			visited[s] = True
		for node in adj[s]:
			if not visited[node]:
				stack.append(node)

def solve():
	n = int(input())
	s = list('codeforces')
	product = 1
	arr = [1] * 10
	indx = 0
	while product < n:
		arr[indx] += 1
		indx = (indx + 1) % 10
		product = 1
		for i in range(10):
			product *= arr[i]
	for i in range(10):
		for j in range(arr[i]):
			print(s[i], end='')
	print()
t = 1
for _ in range(t):
	solve()


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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 math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush

def RL():
	return map(int, sys.stdin.readline().rstrip().split())

def RLL():
	return list(map(int, sys.stdin.readline().rstrip().split()))

def N():
	return int(input())

def comb(n, m):
	return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0

def perm(n, m):
	return factorial(n) // factorial(n - m) if n >= m else 0

def mdis(x1, y1, x2, y2):
	return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
from math import pow, floor

def main():
	n = N()
	sq = floor(pow(n, 0.1))
	s = list('codeforces')
	ret = [sq] * 10
	total = sq ** 10
	for i in range(10):
		if total < n:
			ret[i] += 1
			total = total / sq * (sq + 1)
	sret = ''
	for i in range(10):
		sret += ret[i] * s[i]
	print(sret)
main()


t = 1
import math
delay = []
s = 'codeforces'
for _ in range(t):
	n = int(input())
	ans = []
	freq = math.floor(n ** 0.1)
	for i in range(11):
		if (freq + 1) ** i * freq ** (10 - i) >= n:
			break
	for j in range(10):
		if j < i:
			ans.append(s[j] * (freq + 1))
		else:
			ans.append(s[j] * freq)
	print(''.join(ans))


from sys import stdin
input = stdin.buffer.readline
k = int(input())
s = 'codeforces'
c = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
cnt = 1
while cnt < k:
	for i in range(10):
		if cnt >= k:
			break
		cnt //= c[i]
		cnt *= c[i] + 1
		c[i] += 1
for i in range(10):
	print(s[i] * c[i], end='')


import sys
input = sys.stdin.readline

def main():
	K = int(input())
	x = int(pow(K, 0.1))
	xx = [x] * 10
	ans = 1
	i = 0
	while ans < K:
		if i >= 10:
			ans /= xx[i % 10]
			xx[i % 10] += 1
			ans *= xx[i % 10]
		else:
			ans *= xx[i % 10]
		i += 1
	S = 'codeforces'
	yy = ''
	for i in range(10):
		yy += S[i] * xx[i]
	print(yy)
main()


n = int(input())
k = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
a = []
for j in range(10):
	a.append(0)
p = ''
r = 1
j = 0
while r < n:
	r = r // max(1, a[j % 10])
	a[j % 10] += 1
	r *= a[j % 10]
	j += 1
if n == 1:
	print('codeforces')
else:
	for j in range(10):
		p += ''.join(k[j] * a[j])
	print(p)


k = int(input())
s = 'codeforces'
val = [1] * 10
prod = 1
j = 0
while prod < k:
	val[j] += 1
	prod = int(prod * val[j] / (val[j] - 1))
	j += 1
	if j > 9:
		j = 0
z = ''
for i in range(10):
	while val[i] > 0:
		z = z + s[i]
		val[i] -= 1
print(z)


import sys
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__

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())

def solve():
	(N, L) = (getInt(), 10)
	num = 1
	arr = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
	word = list('codeforces')
	curr_index = 0
	while True:
		if num >= N:
			ans = ''
			for j in range(10):
				ans += arr[j] * word[j]
			print(ans)
			return
		arr[curr_index] += 1
		num *= arr[curr_index]
		num //= arr[curr_index] - 1
		curr_index += 1
		curr_index %= 10
solve()


K = int(input())
S = 'codeforces'
if K == 1:
	print(S)
	exit()
t = [1] * 10
while 1:
	for i in range(10):
		t[i] += 1
		a = 1
		for b in t:
			a *= b
		if a >= K:
			ans = ''
			for (b, c) in zip(t, S):
				ans += c * b
			print(ans)
			exit()


def mult(arr):
	prod = 1
	for i in arr:
		prod *= i
	return prod

def code(m):
	str1 = 'codeforces'
	arr = [1] * 10
	pr = 1
	i = 0
	if m == 1:
		return str1
	else:
		while pr < m:
			if i >= 10:
				i = 0
			arr[i] += 1
			i += 1
			pr = mult(arr)
	k = ''
	for i in range(10):
		k += arr[i] * str1[i]
	return k
t = int(input())
print(code(t))


k = int(input())
c = [1] * 10
p = 1
while p < k:
	i = c.index(min(c))
	p /= c[i]
	c[i] += 1
	p *= c[i]
s = 'codeforces'
for i in range(10):
	print(s[i] * c[i], end='')


import math
from typing import List
k = int(input())
words = list('codeforces')
cnt = [1] * 10

def check():
	ret = 1
	for i in cnt:
		ret *= i
	return ret < k
x = 0
while check():
	cnt[x % 10] += 1
	x += 1
res = ''
for i in range(10):
	res += words[i] * cnt[i]
print(res)


k = int(input())
string = 'codeforces'
ans = []
num = 1
laps = 1
ans = [1] * 10
while True:
	for i in range(10):
		cnt = 1
		for j in ans:
			cnt *= j
		if cnt >= k:
			break
		else:
			ans[i] += 1
	else:
		continue
	break
res = []
for (i, char) in enumerate('codeforces'):
	for _ in range(ans[i]):
		res.append(char)
print(''.join(res))


import math
k = int(input())
default = int(k ** (1 / 10))
string = 'codeforces'
freq = [default for i in range(10)]

def print_times(char, freq):
	while freq > 0:
		print(char, end='')
		freq -= 1

def mul():
	ans = 1
	for i in freq:
		ans *= i
	return ans
for i in range(10):
	if mul() < k:
		freq[i] += 1
for i in range(10):
	print_times(string[i], freq[i])


k = int(input())
delta = [1] * 10
n = 1
i = 0
while n < k:
	temp = delta[i]
	n = n // temp
	n *= temp + 1
	delta[i] = temp + 1
	i += 1
	i = i % 10
arr = list('codeforces')
res = ''
for i in range(10):
	token = arr[i]
	for j in range(delta[i]):
		res += token
print(res)


def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())
n = inp()
res = 'codeforces'
number = 1
char = 0
char_count = 1
while number < n:
	number = number / char_count * (char_count + 1)
	char += 1
	if char == 10:
		char = 0
		char_count += 1
ans = ''
for i in range(char):
	ans += res[i] * (char_count + 1)
for j in range(char, 10):
	ans += res[j] * char_count
print(ans)


class Solve:

	def solve(self):
		k = int(input())
		char = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
		freq = [1 for i in range(10)]
		(i, tmp) = (0, 1)
		while tmp < k:
			freq[i] += 1
			i += 1
			if i == 10:
				i = 0
			tmp = 1
			for j in range(10):
				tmp *= freq[j]
		str = ''
		for i in range(10):
			str += char[i] * freq[i]
		print(str)

def main():
	s = Solve()
	s.solve()
main()


k = int(input())
sequenceArray = []
for i in range(10):
	sequenceArray.append(1)
totalSequence = 1
index = 0
while totalSequence < k:
	totalSequence = 1
	sequenceArray[index] += 1
	index = (index + 1) % 10
	for i in sequenceArray:
		totalSequence = totalSequence * i
result = 0
s = 'codeforces'
for i in range(10):
	for j in range(sequenceArray[i]):
		print(s[i], end='')


from sys import stdin
from collections import defaultdict as dd
from collections import deque as dq
import itertools as it
import math
from math import sqrt, log, log2, exp, ceil, floor
from fractions import Fraction
k = int(input())
each = k ** 0.1
lower = floor(each)
prod1 = lower ** 10
count = 0
while prod1 < k:
	count += 1
	prod1 //= lower
	prod1 *= lower + 1
lc = 10 - count
uc = count
counts = [lower] * lc + [lower + 1] * uc
ans = ''
for (i, char) in enumerate('codeforces'):
	ans += char * counts[i]
print(ans)


k = int(input())
ans = ''
ini = 0
c = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
word = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
while c[0] * c[1] * c[2] * c[3] * c[4] * c[5] * c[6] * c[7] * c[8] * c[9] < k:
	c[ini] += 1
	ini += 1
	if ini == 10:
		ini = 0
for (a, b) in zip(c, word):
	ans += a * b
print(ans)


l = [8140406085191601, 6278211847988224, 4808584372417849, 3656158440062976, 2758547353515625, 2064377754059776, 1531578985264449, 1125899906842624, 819628286980801, 590490000000000, 420707233300201, 296196766695424, 205891132094649, 141167095653376, 95367431640625, 63403380965376, 41426511213649, 26559922791424, 16679880978201, 10240000000000, 6131066257801, 3570467226624, 2015993900449, 1099511627776, 576650390625, 289254654976, 137858491849, 61917364224, 25937424601, 10000000000, 3486784401, 1073741824, 282475249, 60466176, 9765625, 1048576, 59049, 1024, 1]
k = int(input())
pos = 0
while l[pos] > k:
	pos += 1
pos = len(l) - pos
l2 = [pos] * 10

def multiply_arr(l: list) -> int:
	m = 1
	for i in l:
		m *= i
	return m
p = 0
while multiply_arr(l2) < k:
	l2[p] += 1
	p += 1
l3 = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
for i in range(len(l2)):
	print(l3[i] * l2[i], sep='', end='')


def isvalid(arr, n):
	r = 1
	for i in range(10):
		r = r * arr[i]
		if r >= n:
			return True
	return False

def solve(n):
	arr = [1] * 10
	if isvalid(arr, n):
		return arr
	last = 0
	while True:
		arr[last] = arr[last] + 1
		if isvalid(arr, n):
			return arr
		last = last + 1
		if last == 10:
			last = 0

def solution(n):
	arr = solve(n)
	ans = ''
	st = 'codeforces'
	for i in range(len(arr)):
		ans = ans + st[i] * arr[i]
	return ans
n = int(input())
op = solution(n)
print(op)


import sys
import math
import collections
import heapq

def set_debug(debug_mode=False):
	if debug_mode:
		fin = open('input.txt', 'r')
		sys.stdin = fin

def int_input():
	return list(map(int, input().split()))

def get(x):
	cur = 0
	mx = 0
	for i in range(1, len(s) + 1):
		cur += x * a[i]
		mx = max(mx, cur)
		if cur < 0:
			cur = 0
	return mx
t = 1
for ti in range(1, t + 1):
	n = int(input())
	items = [1] * 10
	last = 0
	s = 'codeforces'
	while True:
		val = 1
		for _ in range(10):
			val *= items[_]
		if val >= n:
			break
		items[last] += 1
		last = (last + 1) % 10
	for i in range(10):
		print(s[i] * items[i], end='')


t = int(input())
ss = 'codeforces'
s = ''
for x in range(2, 60):
	for i in range(0, 10):
		ans = pow(x, i) * pow(x - 1, 10 - i)
		if ans >= t:
			for j in range(0, i):
				ch = ss[j]
				for a in range(0, x):
					s = s + ch
			for j in range(i, 10):
				ch = ss[j]
				for a in range(0, x - 1):
					s = s + ch
			break
	if s != '':
		break
print(s)


import sys
input = sys.stdin.readline
import math

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input().strip()
	return list(s[:len(s)])

def invr():
	return map(int, input().strip().split())

def from_file(f):
	return f.readline

def solve(k):
	cur = 0
	p = 0
	while cur < k:
		cur = p ** 10
		p += 1
	p -= 1
	for t in range(10, -1, -1):
		cur = p ** t * (p - 1) ** (10 - t)
		if cur < k:
			break
	t += 1
	res1 = ''.join([sym * p for sym in 'codeforces'[:t]])
	res2 = ''.join([sym * (p - 1) for sym in 'codeforces'[t:]])
	return res1 + res2
k = inp()
print(solve(k))


k = int(input())

def getperm(occ):
	val = 1
	for v in occ:
		val *= v
	return val
letters = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
occurences = [1 for x in range(len(letters))]
permutations = 1
location = 0
while getperm(occurences) < k:
	occurences[location] += 1
	location += 1
	location %= len(occurences)
for (i, v) in enumerate(occurences):
	print(letters[i] * v, end='')
print()


k = int(input())
li = [1] * 10
fac = []
pro = 1
i = 0
while True:
	if pro < k:
		pro = pro * (li[i % 10] + 1) // li[i % 10]
		li[i % 10] += 1
		i += 1
	else:
		break
st = 'codeforces'
for i in range(10):
	print(st[i] * li[i], end='')


t = int(input())
d = 0
while d ** 10 < t:
	d += 1
d2 = 0
while (d - 1) ** d2 * d ** (10 - d2) >= t:
	d2 += 1
d2 -= 1
s = 'codeforces'
print(''.join([c * (d - 1) for c in s[:d2]]) + ''.join([c * d for c in s[d2:]]))


import math
n = int(input())
p = int(math.floor(math.pow(n, 0.1)))
a = 0
x = p ** 10
while n > x:
	a += 1
	x = (p + 1) ** a * p ** (10 - a)
s = 'codeforces'
ans = ''
for i in range(10):
	if i < a:
		ans += s[i] * (p + 1)
	else:
		ans += s[i] * p
print(ans)


n = int(input())
ans = 1
s = 'codeforces'
l = ['c', 'o', 'd', 'e', 'f', 'O', 'r', 'C', 'E', 's']
d = {}
for i in l:
	d[i] = 1
m = 1
while ans < n:
	for i in l:
		if d[i] == 1:
			ans *= 2
			d[i] += 1
			if ans >= n:
				break
		else:
			ans += ans // m
			d[i] += 1
			if ans >= n:
				break
	m += 1
res = ''
for i in l:
	res += d[i] * i.lower()
print(res)


import math
k = int(input())
k1 = k
d = math.ceil(pow(k, 1 / 10))
c = math.floor(pow(k, 1 / 10))
t = [d] * 10
l = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
i = 0
count0 = 0
ans = pow(d, 10)
while i < 10:
	if ans // t[i] * c >= k1:
		ans = ans // d * c
		t[i] = c
		i += 1
	else:
		break
s = ''
for i in range(10):
	s += l[i] * t[i]
print(s)


def find_product(l):
	product = 1
	for i in l:
		product *= i
	return product
n = int(input())
s = 'codeforces'
temp = 1
c = [1] * 10
i = 0
while temp < n:
	if i == 10:
		i = 0
	c[i] += 1
	temp = find_product(c)
	i += 1
for i in range(len(s)):
	print(s[i] * c[i], end='')


k = int(input())
t = 'codeforces'
if k == 1:
	print(t)
else:
	for i in range(2, 41):
		if i ** 10 >= k:
			x = i
			break
	for i in range(1, 11):
		if x ** i * (x - 1) ** (10 - i) >= k:
			y = i
			break
	for i in range(y):
		print(x * t[i], end='')
	for i in range(y, 10):
		print((x - 1) * t[i], end='')
	print()


k = int(input())
s = 'codeforces'
l = [1] * 10
(p, i) = (1, 0)
while p < k:
	p //= l[i]
	l[i] += 1
	p *= l[i]
	i = (i + 1) % 10
for i in range(10):
	print(s[i] * l[i], end='')


count = 1
k = int(input())
codeforces = list('codeforces')
ans = 1
while True:
	for i in range(len(codeforces)):
		if ans >= k:
			break
		codeforces[i] += codeforces[i][0]
		ans = ans // count
		ans *= len(codeforces[i])
		if ans >= k:
			break
	count += 1
	if ans >= k:
		break
ans = ''
for i in codeforces:
	ans += i
print(ans)


s = 'codeforces'
n = int(input())
for i in range(1, 50):
	if i ** 10 >= n:
		num = i
		for j in range(1, 11):
			if i ** j * (i - 1) ** (10 - j) >= n:
				cnt = j
				break
		break
for i in range(cnt):
	for j in range(num):
		print(s[i], end='')
for i in range(cnt, 10):
	for j in range(num - 1):
		print(s[i], end='')
print()


import sys, math, cmath, time
start_time = time.time()

def qw(a):
	q = 1
	for i in range(10):
		q = q * a[i]
	return q

def solve():
	n = inp()
	q = [1] * 10
	w = 0
	qq = ''
	ww = 'codeforces'
	while True:
		if qw(q) >= n:
			break
		q[w % 10] = q[w % 10] + 1
		w = w + 1
	for i in range(10):
		qq = qq + ww[i] * q[i]
	print(qq)

def main():
	global tt
	if not ONLINE_JUDGE:
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	t = 1
	for tt in range(t):
		solve()
	if not ONLINE_JUDGE:
		print('Time Elapsed :', time.time() - start_time, 'seconds')
		sys.stdout.close()

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	return input().strip()

def invr():
	return map(int, input().split())

def counter(a):
	q = [0] * max(a)
	for i in range(len(a)):
		q[a[i] - 1] = q[a[i] - 1] + 1
	return q

def string_counter(a):
	q = [0] * 26
	for i in range(len(a)):
		q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
	return q
ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
	input = sys.stdin.readline
main()


k = int(input())
str = 'codeforces'
n = len(str)
t = int(k ** (1 / n))
s = t ** 10
a = [t] * n
i = 0
res = ''
while s < k:
	s /= t
	s *= t + 1
	a[i] += 1
	i += 1
for (i, num) in enumerate(str):
	res += num * a[i]
print(res)


def f(n):
	A = [1] * 10
	s = 1
	i = 0
	while s < n:
		s = s * (A[i] + 1) // A[i]
		A[i] += 1
		i = (i + 1) % 10
	return 'c' * A[0] + 'o' * A[1] + 'd' * A[2] + 'e' * A[3] + 'f' * A[4] + 'o' * A[5] + 'r' * A[6] + 'c' * A[7] + 'e' * A[8] + 's' * A[9]
n = int(input())
print(f(n))


import math
k = int(input())
s = 'codeforces'
freq = [1 for i in range(len(s))]
coun = 0
temp = 1
j = 0
while temp < k:
	if j == 10:
		j = 0
	temp /= freq[j]
	freq[j] += 1
	temp *= freq[j]
	j += 1
for i in range(len(s)):
	print(s[i] * freq[i], end='')


from sys import stdin, stdout
import heapq
import cProfile
from collections import Counter, defaultdict, deque
from functools import reduce
import math

def get_int():
	return int(stdin.readline().strip())

def get_tuple():
	return map(int, stdin.readline().split())

def get_list():
	return list(map(int, stdin.readline().split()))

def solve():
	n = get_int()
	if n == 1:
		return 'codeforces'
	c = 1
	while c ** 10 < n:
		c += 1
	newn = c ** 10
	x = 10
	while newn >= n:
		newn = 1
		x -= 1
		for i in range(x):
			newn *= c
		for i in range(10 - x):
			newn *= c - 1 or 1
	x = (x + 1) % 10
	if x == 0:
		x = 10
	ans = ''
	for (i, val) in enumerate('codeforces'):
		if i < x:
			ans += val * c
		else:
			ans += val * (c - 1)
	return ans

def main():
	print(solve())
TestCases = False
if TestCases:
	for i in range(get_int()):
		main()
else:
	main()


from functools import reduce
k = int(input())
a = [1] * 10
id = 0
while True:
	if reduce(lambda x, y: x * y, a) >= k:
		break
	a[id] += 1
	id = (id + 1) % 10
print(''.join(map(lambda x: x[1] * x[0], zip(a, 'codeforces'))))


import sys, math, itertools, collections, copy
input = sys.stdin.readline
N = 10
k = int(input())
chars = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
if k == 1:
	print('codeforces')
elif k == 2:
	print('ccodeforces')
elif k == 3:
	print('cccodeforces')
else:
	a = [1] * N
	prod = 1
	i = 0
	while prod < k:
		i %= N
		prod //= a[i]
		a[i] += 1
		prod *= a[i]
		i += 1
	ans = ''
	for i in range(N):
		ans += a[i] * chars[i]
	print(ans)


import sys

def minp():
	return sys.stdin.readline().strip()

def mint():
	return int(minp())

def mints():
	return map(int, minp().split())

def solve():
	n = mint()
	s = 'codeforces'
	if n <= 3 ** len(s):
		best = (1000, 0, 0)
		for i in range(len(s) + 1):
			for j in range(len(s) - i + 1):
				if 3 ** i * 2 ** j >= n:
					best = min(best, (3 * i + 2 * j + len(s) - i - j, i, j))
		(a, b, c) = best
		for i in range(len(s)):
			if b > 0:
				b -= 1
				print(s[i] * 3, end='')
			elif c > 0:
				c -= 1
				print(s[i] * 2, end='')
			else:
				print(s[i], end='')
		return
	for i in range(1, 100):
		if i ** len(s) > n:
			m = i
			break
	for i in range(len(s) + 1):
		if m ** i * (m - 1) ** (len(s) - i) >= n:
			for z in range(i):
				print(s[z] * m, end='')
			for z in range(i, len(s)):
				print(s[z] * (m - 1), end='')
			return
solve()


n = int(input())
s = 'codeforces'
out = ''
m = [1] * 10
f = 0
while True:
	c = 1
	for i in m:
		c *= i
	if c >= n:
		break
	m[f] += 1
	f = (f + 1) % 10
f = 0
for j in s:
	out += j * m[f]
	f += 1
print(out)


def solve():
	a = int(input())
	kek = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
	p = 1
	i = 0
	while p < a:
		i = (i + 1) % 10
		kek[i] += 1
		p = p // (kek[i] - 1) * kek[i]
	magic = 'codeforces'
	for (i, _) in enumerate(kek):
		print(magic[i] * _, end='')
solve()


n = int(input())
br = 0
for i in range(1, 42):
	if n <= i ** 10:
		br = i
		break
po = 0
for j in range(1, 11):
	if n <= br ** j * (br - 1) ** (10 - j):
		po = j
		break
st = 'codeforces'
s = ''
for k in range(10 - po):
	s += st[k] * (br - 1)
for l in range(10 - po, 10):
	s += st[l] * br
print(s)


import math
t = int(input())
temp = t ** (1 / float(10))
hi = math.ceil(temp)
lo = math.floor(temp)
mn = hi * 10
inde = 0
for i in range(1, 11):
	if math.pow(hi, 10 - i) * math.pow(lo, i) >= t:
		strle = hi * (10 - i) + lo * i
		if strle < mn:
			mn = strle
			inde = i
h = [hi] * (10 - inde)
l = [lo] * inde
tot = h + l
st = 'codeforces'
for i in range(10):
	print(st[i] * tot[i], end='')


from functools import reduce

def solve(k):
	n = len('codeforces')
	mult = [1] * n
	i = 0
	while reduce(lambda x, y: x * y, mult) < k:
		mult[i % n] += 1
		i += 1
	sol = ''
	for i in range(n):
		sol += 'codeforces'[i] * mult[i]
	return sol
k = int(input())
print(solve(k))


from sys import stdin, stdout
import sys
import math

def main():
	t = 1
	for _ in range(t):
		k = int(input())
		for base in range(1, 100000):
			value = base ** 10
			if value < k:
				continue
			count_small = 0
			for i in range(0, 10):
				new_value = value / base * (base - 1)
				if new_value >= k:
					value = new_value
					count_small += 1
				else:
					break
			answer = ''
			for ch in 'codeforces':
				if count_small > 0:
					count_iter = base - 1
					count_small -= 1
				else:
					count_iter = base
				for j in range(count_iter):
					answer += ch
			print(answer)
			return
main()


import heapq
k = int(input())
ans = [1] * 10
score = 1
temp = 0
while True:
	if score >= k:
		break
	else:
		score //= ans[temp]
		ans[temp] += 1
		score *= ans[temp]
		temp += 1
		if temp == 10:
			temp = 0
ansstr = []
codeforces = 'codeforces'
heapq.heapify(ans)
for i in range(10):
	z = heapq.heappop(ans)
	for j in range(z):
		ansstr.append(codeforces[i])
print(''.join(ansstr))


k = int(input())

def calc(ans):
	res = 1
	for v in ans:
		res *= v
	return res
s = 'codeforces'
ans = [1] * len(s)
mn = 1
j = 0
while calc(ans) < k:
	if j == len(ans):
		j = 0
		mn += 1
	ans[j] += 1
	j += 1
print(''.join((s[i] * ans[i] for i in range(len(s)))))


k = int(input())
i = 1
while i ** 10 < k:
	i += 1
a = 0
b = 10
j = i - 1
if k == 1:
	print('codeforces')
elif k == 2:
	print('ccodeforces')
else:
	while i ** a * j ** b < k:
		a += 1
		b -= 1
	s = list('codeforces')
	for m in range(a):
		print(s[m] * i, end='')
	for m in range(b):
		print(s[m + a] * j, end='')


import sys
import heapq
inpy = [int(x) for x in sys.stdin.read().split()]
n = inpy[0]
for j in range(10, 1000):
	(l, r) = (j // 10, j % 10)
	cur = 1
	for i in range(10):
		if r > 0:
			cur = cur * (l + 1)
			r -= 1
		else:
			cur = cur * l
	if cur >= n:
		s = 'codeforces'
		r = j % 10
		for i in range(10):
			if r > 0:
				print(s[i] * (l + 1), end='')
				r -= 1
			else:
				print(s[i] * l, end='')
		break


import math
k = int(input())
res = 100
base = 1
while res > 10:
	base += 1
	res = math.log(k, base)
base -= 1
k /= base ** 10
letters = list((c for c in 'codeforces'))
count = 0
while k > 1:
	count += 1
	k *= base
	k /= base + 1
ans = []
for i in range(10):
	ans.append(base)
	if i < count:
		ans[i] += 1
for i in range(len(ans)):
	ans[i] = letters[i] * ans[i]
s = ''
for i in range(10):
	s += ans[i]
print(s)


k = int(input())
a = [1 for i in range(10)]
base = 'codeforces'
prod = 1
while prod < k:
	for i in range(10):
		prod //= a[i]
		a[i] += 1
		prod *= a[i]
		if prod >= k:
			break
ans = ''
for i in range(10):
	ans += a[i] * base[i]
print(ans)


import sys, os.path
if os.path.exists('input_file.txt'):
	sys.stdin = open('input_file.txt', 'r')
	sys.stdout = open('output_file.txt', 'w')
from sys import stdin, stdout
import math
from itertools import permutations, combinations
from collections import defaultdict
from bisect import bisect_left
from bisect import bisect_right

def L():
	return list(map(int, input().split()))

def In():
	return map(int, input().split())

def I():
	return int(input())
P = 1000000007

def main():
	k = I()
	n = int(k ** 0.1)
	m = n ** 10
	for c in 'codeforces':
		l = n + (m < k)
		print(c * l, end='')
		m = m // n * l
main()


n = int(input())
ans = 50
while ans ** 10 > n:
	ans -= 1
s = [ans for i in range(10)]
a = ans ** 10
while a < n:
	i = 0
	for j in range(10):
		if s[i] > s[j]:
			i = j
	a /= s[i]
	s[i] += 1
	a *= s[i]
for i in range(10):
	if i == 0:
		print('c' * s[i], end='')
	if i == 1:
		print('o' * s[i], end='')
	if i == 2:
		print('d' * s[i], end='')
	if i == 3:
		print('e' * s[i], end='')
	if i == 4:
		print('f' * s[i], end='')
	if i == 5:
		print('o' * s[i], end='')
	if i == 6:
		print('r' * s[i], end='')
	if i == 7:
		print('c' * s[i], end='')
	if i == 8:
		print('e' * s[i], end='')
	if i == 9:
		print('s' * s[i], end='')


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import ceil, floor
from copy import *
from collections import deque, defaultdict
from collections import Counter as counter
from itertools import combinations
from itertools import permutations as permutate
from bisect import bisect_left as bl
from operator import *
from bisect import bisect_right as br
from bisect import bisect
BUFSIZE = 8192
from sys import stderr

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
from types import GeneratorType

def iterative(f, stack=[]):

	def wrapped_func(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		to = f(*args, **kwargs)
		while True:
			if type(to) is GeneratorType:
				stack.append(to)
				to = next(to)
				continue
			stack.pop()
			if not stack:
				break
			to = stack[-1].send(to)
		return to
	return wrapped_func
mod = 1000000007

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def out(var):
	sys.stdout.write(str(var))

def lis():
	return list(map(int, inp().split()))

def stringlis():
	return list(map(str, inp().split()))

def sep():
	return map(int, inp().split())

def strsep():
	return map(str, inp().split())

def fsep():
	return map(float, inp().split())

def nextline():
	out('\n')

def testcase(t):
	for p in range(t):
		solve()

def pow(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res
from functools import reduce

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))

def gcd(a, b):
	if a == b:
		return a
	while b > 0:
		(a, b) = (b, a % b)
	return a

def prefix_sum(ar):
	return list(accumulate(ar))

def suffix_sum(ar):
	return list(accumulate(ar[::-1]))[::-1]
from collections import defaultdict

def numberOfSetBits(i):
	i = i - (i >> 1 & 1431655765)
	i = (i & 858993459) + (i >> 2 & 858993459)
	return ((i + (i >> 4) & 252645135) * 16843009 & 4294967295) >> 24

def solve():
	n = int(inp())
	if n == 1:
		print('codeforces')
	else:
		mi = 10 ** 20
		for k in range(2, 100):
			for a in range(1, 11):
				t = k ** a * (k - 1) ** (10 - a)
				if t >= n:
					mi = 10 * k + a - 10
					s = ''
					st = 'codeforces'
					for i in range(a):
						s += st[i] * k
					for i in range(a, 10):
						s += st[i] * (k - 1)
					print(s)
					return
solve()


k = int(input())
A = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
(i, prod) = (0, 1)
while prod < k:
	if i == 10:
		i = 0
	n = A[i]
	prod = prod // n
	prod = prod * (n + 1)
	A[i] = n + 1
	i = i + 1
(s, ans) = ('codeforces', '')
for i in range(len(s)):
	ans = ans + s[i] * A[i]
print(ans)


k = int(input())
i = 0
dp = [1] * 10
s = 'codeforces'
prod = 1
l = 0
while prod < k:
	if l == len(dp):
		l = 0
	dp[l] += 1
	prod *= dp[l]
	prod //= max(0, dp[l] - 1)
	l += 1
i = 0
cnt = 0
sett = set()
for i in range(len(dp)):
	print(s[i] * dp[i], end='')


n = int(input())
string = 'codeforces'
rep = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

def total():
	ans = 1
	for i in rep:
		ans *= i
	return ans
while total() < n:
	min = 1000
	pos = -1
	for i in range(0, len(rep)):
		if rep[i] <= min:
			min = rep[i]
			pos = i
	rep[pos] += 1
for i in range(0, len(rep)):
	print(string[i] * rep[i], end='')
print('')


k = int(input())
l = 10
s = 'codeforces'
q = 1
r = 0
while True:
	(q, r) = (l // 10, l % 10)
	cnt = pow(q, 10 - r) * pow(q + 1, r)
	if cnt >= k:
		break
	l += 1
ans = ''
for i in range(10 - r):
	ans += s[i] * q
for i in range(10 - r, 10):
	ans += s[i] * (q + 1)
print(ans)


k = int(input())
z = [1] * 10
x = 'codeforces'
p = 1
i = 0
while k > p:
	z[i] += 1
	i = (i + 1) % 10
	p = 1
	for j in range(10):
		p *= z[j]
for i in range(10):
	print(x[i] * z[i], end='')


k = int(input())
cnt = [1] * 10
sum = 1
while sum < k:
	for i in range(10):
		sum = 1
		cnt[i] += 1
		for p in cnt:
			sum *= p
		if sum >= k:
			break
s = 'codeforces'
fs = ''
for i in range(10):
	fs += s[i] * cnt[i]
print(fs)


k = int(input())
ans = list('codeforces')
nums = [1] * len(ans)
i = 0
n = 1
while n < k:
	n = n // nums[i]
	nums[i] += 1
	n = n * nums[i]
	i = (i + 1) % 10
for (i, el) in enumerate(nums):
	ans[i] *= el
print(''.join(ans))


from collections import Counter
from collections import defaultdict
from collections import deque
import math
import sys
input = sys.stdin.readline
import bisect
rs = lambda : input().strip()
ri = lambda : int(input())
rl = lambda : list(map(int, input().strip().split()))
rls = lambda : list(map(str, input().split()))
n = int(input())
a = [1] * 10
ans = 1
s1 = 'codeforces'
i = 0
while ans < n:
	a[i] = a[i] + 1
	ans = ans * a[i] // (a[i] - 1)
	i = (i + 1) % 10
s = ''
for i in range(0, 10):
	s = s + s1[i] * a[i]
print(s)


from math import *
n = int(input())
high = int(ceil(n ** (1 / 10)))
if (high - 1) ** 10 >= n:
	high = high - 1
low = int(high - 1)
highcount = 1
lowcount = 9
while True:
	if high ** highcount * low ** lowcount >= n:
		break
	else:
		highcount += 1
		lowcount -= 1
temp = 'codeforces'
temp = temp[:highcount]
for x in temp:
	print(x * high, end='')
temp = 'codeforces'
temp = temp[highcount:]
for x in temp:
	print(x * low, end='')


n = int(input())
p = 1
a = [1] * 10
f = 0
while True:
	for i in range(10):
		if p >= n:
			f = 1
			break
		p /= a[i]
		a[i] += 1
		p *= a[i]
		if p >= n:
			f = 1
			break
	if f:
		break
s = 'codeforces'
for i in range(10):
	print(s[i] * a[i], end='')
print()


import sys
import math
import collections
from sys import stdin, stdout, setrecursionlimit
import bisect as bs
setrecursionlimit(2 ** 20)
M = 10 ** 9 + 7
T = 1
for _ in range(T):
	k = int(stdin.readline())
	a = [1]
	if k == 1:
		print('codeforces')
		break
	for i in range(2, 42):
		for j in range(10):
			a.append(i ** (j + 1) * (i - 1) ** (9 - j))
	for i in range(1, len(a)):
		if k <= a[i]:
			ans = i
			break
	mx = ans // 10 + 1
	rem = ans % 10
	s = 'codeforces'
	for i in range(rem):
		print(s[i] * (mx + 1), end='')
	for i in range(rem, 10):
		print(s[i] * mx, end='')


k = int(input())
cur = 10 ** 18
best = []
for p in range(1, 41):
	for q in range(1, 41):
		for i in range(1, 10):
			res = p ** i * q ** (10 - i)
			if res >= k:
				temp = p * i + q * (10 - i) - 10
				if temp <= cur:
					cur = temp
					best = (p, q, i)
(p, q, i) = best
t = 'codeforces'
t1 = t[0:i]
t2 = t[i:]
s = ''
for j in range(len(t1)):
	s += p * t1[j]
for j in range(len(t2)):
	s += q * t2[j]
print(s)


import os
import sys
from io import BytesIO, IOBase
import math
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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')
n = int(input())
r = 'codeforces'
v = int(n ** 0.1)
ss = set()
l = ['c', 'o', 'd']
cal = v ** 10
for i in r:
	if 1 > v:
		res = 1
	else:
		res = v
	if cal < n:
		cal /= res
		sum = 0
		cal *= res + 1
		res += 1
	print(i * res, end='')
print()


import math

def product(L):
	p = 1
	for i in range(0, len(L)):
		p = p * L[i]
	return p
n = int(input())
if n == 1:
	print('codeforces')
else:
	s = 'codeforces'
	L = [1] * len(s)
	i = 0
	while product(L) < n:
		L[i] += 1
		i += 1
		if i == len(L):
			i = 0
	t = ''
	for i in range(0, len(L)):
		t += L[i] * s[i]
	print(t)


k = int(input())
l = [1] * 10
i = 0

def p(l):
	e = l[0]
	for i in range(1, 10):
		e = e * l[i]
	return e
while p(l) < k:
	l[i] += 1
	if i < 9:
		i += 1
	else:
		i = 0
print('c' * l[0] + 'o' * l[1] + 'd' * l[2] + 'e' * l[3] + 'f' * l[4] + 'o' * l[5] + 'r' * l[6] + 'c' * l[7] + 'e' * l[8] + 's' * l[9])


import sys, collections, math

def in_out():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
k = int(input())
s = 'codeforces'
prod = 1
arr = [1] * 10
idx = 0
while prod < k:
	arr[idx] += 1
	idx = (idx + 1) % 10
	prod = 1
	for i in range(10):
		prod *= arr[i]
res = ''
for i in range(10):
	res += arr[i] * s[i]
print(res)


from functools import reduce
cf = 'codeforces'
ans = [0] * 10
k = int(input().strip())
i = 0
while reduce(lambda x, y: x * y, ans) < k:
	ans[i] += 1
	i = (i + 1) % 10
for i in range(len(ans)):
	ans[i] = cf[i] * ans[i]
print(''.join(ans))


n = int(input())
k = int(n ** 0.1)
m = k ** 10
s = 'codeforces'
for i in range(len(s)):
	print(s[i] * (k + (m < n)), end='')
	m *= (k + (m < n)) / k


import sys
import random
from math import *

def input():
	return sys.stdin.readline().strip()

def iinput():
	return int(input())

def finput():
	return float(input())

def tinput():
	return input().split()

def linput():
	return list(input())

def rinput():
	return map(int, tinput())

def fiinput():
	return map(float, tinput())

def rlinput():
	return list(map(int, input().split()))

def trinput():
	return tuple(rinput())

def srlinput():
	return sorted(list(map(int, input().split())))

def YESNO(fl):
	if fl:
		print('NO')
	else:
		print('YES')

def main():
	k = iinput()
	print(0, 1)
	print(0, 2)
	print(1, 1)
	print(1, 2)
	q = [[3, 1], [3, 2], [4, 0], [4, 1], [4, 2], [4, 3], [5, 0], [5, 1], [5, 2], [5, 3], [6, 1], [6, 2]]

def main1():
	(n, g, f, res) = (iinput(), 1, 1, '')
	while g ** 10 < n:
		g += 1
	for (i, v) in enumerate('codeforces'):
		(res, f) = (res + v * g, f * g)
		g -= f * (g - 1) ** (10 - i - 1) >= n
	print(res)
for inytd in range(1):
	main1()


import math
from decimal import *
getcontext().prec = 30
k = int(input())
maxi = math.ceil(k ** 0.1)
if (maxi - 1) ** 10 == k:
	maxi -= 1
amount = 1
for i in range(1, 11):
	if maxi ** i * (maxi - 1) ** (10 - i) >= k:
		amount = i
		break
ans = ''
copy = 'codeforces'
for i in range(amount):
	ans += copy[i] * maxi
for i in range(amount, 10):
	ans += copy[i] * (maxi - 1)
print(ans)


import sys
from collections import deque, defaultdict
from math import sqrt, factorial

def solve():
	k = int(input())
	if k == 1:
		print('codeforces')
		return
	base = 1
	cur = 1
	while cur < k:
		base += 1
		cur = base ** 10
	low = base - 1
	t = 0
	while cur // base * low >= k:
		cur = cur // base * low
		t += 1
	s = 'codeforces'
	ans = ''
	for (i, e) in enumerate(s):
		if i < t:
			ans += e * max(1, low)
		else:
			ans += e * max(2, base)
	print(ans)
t = 1
for case in range(1, t + 1):
	ans = solve()


k = int(input())
c = [1] * 10
ans = 1
a = 1
while a < k:
	maxx = a
	max_ind = -1
	for i in range(10):
		b = a // c[i]
		c[i] += 1
		b *= c[i]
		if maxx < b:
			maxx = b
			max_ind = i
		c[i] -= 1
	a //= c[max_ind]
	c[max_ind] += 1
	a *= c[max_ind]
s = 'codeforces'
for i in range(10):
	print(s[i] * c[i], end='')


from math import floor

def read_int():
	return int(input())
n = read_int()
p = int(floor(n ** 0.1))
cnt = [p for i in range(10)]
tot = p ** 10
idx = 0
while tot < n:
	cnt[idx] += 1
	tot = tot // p * (p + 1)
	idx += 1
s = 'codeforces'
ans = []
for i in range(10):
	for j in range(cnt[i]):
		ans.append(s[i])
print(''.join(ans))


n = int(input())
total = 1
l = []
d = {}
for (i, c) in enumerate('codeforces'):
	d[i] = 1
while total < n:
	for (i, c) in enumerate('codeforces'):
		d[i] += 1
		total = total // (d[i] - 1) * d[i]
		if total >= n:
			break
print(''.join((c * d[i] for (i, c) in enumerate('codeforces'))))


import sys, io, os
BUFSIZE = 8192

class FastIO(io.IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = io.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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(io.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')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
K = int(input())
a = 1
if K == 1:
	print('codeforces')
	exit()
for i in range(1, 100000):
	for j in range(10):
		a = a * (i + 1) // i
		if a >= K:
			ans = ''
			for (k, c) in enumerate('codeforces'):
				ans += c * (i if j < k else i + 1)
			print(ans)
			exit()


k = int(input())
s = 'codeforces'
l = [1 for _ in range(len(s))]
curr = 1
i = 0
while curr < k:
	fixed = i % len(s)
	if l[fixed] == 1:
		l[fixed] += 1
		curr *= 2
	else:
		value = l[fixed]
		curr //= value
		l[fixed] += 1
		curr *= l[fixed]
	i += 1
result = ''
for ii in range(len(s)):
	result += ''.join([s[ii] for j in range(1, l[ii] + 1)])
print(result)


n = int(input())
A = [1] * 10
kek = 1
while kek < n:
	for i in range(10):
		kek //= A[i]
		A[i] += 1
		kek *= A[i]
		if kek >= n:
			break
ans = ''
ans += 'c' * A[0] + 'o' * A[1] + 'd' * A[2] + 'e' * A[3] + 'f' * A[4] + 'o' * A[5] + 'r' * A[6] + 'c' * A[7] + 'e' * A[8] + 's' * A[9]
print(ans)


n = int(input())
low = 10
high = 400
s = 'codeforces'
while low < high - 1:
	mid = (low + high) // 2
	x = mid % 10
	prod = 1
	for i in range(10):
		if i < x:
			prod *= mid // 10 + 1
		else:
			prod *= mid // 10
	if prod >= n:
		high = mid
	else:
		low = mid
mid = low
x = mid % 10
prod = 1
for i in range(10):
	if i < x:
		prod *= mid // 10 + 1
	else:
		prod *= mid // 10
mid = high
if prod >= n:
	mid = min(mid, low)
x = mid % 10
for i in range(10):
	if i < x:
		print(s[i] * (mid // 10 + 1), end='')
	else:
		print(s[i] * (mid // 10), end='')
print()


import os
import sys
from io import BytesIO, IOBase
import math
from itertools import permutations, combinations
from collections import defaultdict
from bisect import bisect_left
from bisect import bisect_right

def L():
	return list(map(int, input().split()))

def In():
	return map(int, input().split())

def I():
	return int(input())
mod = 1000000007

def main():
	k = I()
	n = int(k ** 0.1)
	m = n ** 10
	for c in 'codeforces':
		l = n + (m < k)
		print(c * l, end='')
		m = m // n * l
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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')
main()


k = int(input())
x = 1
while not (pow(x, 10) <= k and pow(x + 1, 10) > k):
	x += 1
c = pow(x, 10)
cnt = 0
while c < k:
	c //= x
	c *= x + 1
	cnt += 1
res = [x + 1] * cnt + [x] * (10 - cnt)
print(''.join(('codeforces'[i] * res[i] for i in range(10))))


k = int(input())
s = 'codeforces'
arr = [1] * 10
if k == 1:
	print(s)
	exit()
while True:
	for i in range(10):
		if arr[i] == min(arr):
			arr[i] += 1
			break
	prod = 1
	for x in arr:
		prod *= x
	if prod >= k:
		break
for i in range(10):
	print(s[i] * arr[i], end='')
print('')


n = int(input())
s = 1
i = 0
v = [1] * 10
st = 'codeforces'
while s < n:
	v[i] += 1
	i = (i + 1) % 10
	s = 1
	for j in range(10):
		s *= v[j]
ans = ''
for i in range(10):
	ans += st[i] * v[i]
print(ans)


def mult(x):
	res = 1
	for i in range(len(x)):
		x[i] = int(x[i])
		res = res * x[i]
	return res
import math
n = input('')
n = int(n)
k = 0
sign = 0
cnt = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
str = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
str_final = ''
i = 0
j = 0
while mult(cnt) <= n:
	if mult(cnt) == n:
		break
	cnt[i] = cnt[i] + 1
	i = i + 1
	if i > 9:
		i = 0
for i in range(10):
	str_final = str_final + str[i] * cnt[i]
print(str_final)


a = int(input())
for i in range(41):
	if (a > i ** 10) & (a <= (i + 1) ** 10):
		n1 = i + 1
		for j in range(11):
			if n1 ** j * ((n1 - 1) ** (10 - j) * (n1 != 1) + 1 * (n1 == 1)) >= a:
				n2 = j
				break
		break
a = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
b = ''
for i in range(10):
	if i < n2:
		b = b + a[i] * n1
	else:
		b = b + a[i] * (n1 - 1)
if n1 == 1:
	print('codeforces')
else:
	print(b)


import sys

def take_pro(ans):
	val = 1
	for w in range(10):
		val *= ans[w]
	return val

def solve(k):
	ans = [1] * 10
	pro = take_pro(ans)
	if pro >= k:
		return ans
	for g in range(100):
		prod = 1
		for h in range(10):
			ans[h] += 1
			prod = take_pro(ans)
			if prod >= k:
				return ans
k = int(sys.stdin.readline())
ch = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
ans = solve(k)
s = ''
for p in range(10):
	s += ch[p] * ans[p]
print(s)


import sys
from os import path
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def solve():
	n = int(input())
	prod = 1
	l = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
	while prod < n:
		for x in range(10):
			l[x] = l[x] + 1
			prod = 1
			for y in range(10):
				prod *= l[y]
			if prod >= n:
				break
	fin = 'codeforces'
	for x in range(10):
		for y in range(l[x]):
			print(fin[x], end='')
t = 1
while t:
	solve()
	t -= 1


def f(x):
	c = 1
	for x_ in x:
		c = c * x_
	return c
k = int(input().strip())
s = 'codeforces'
r = 1
while r ** 10 < k:
	r += 1
rpt = [r] * 10
changed = True
while changed:
	changed = False
	for i in range(0, 10):
		if rpt[i] > 1:
			rpt[i] -= 1
			if f(rpt) >= k:
				changed = True
				continue
			rpt[i] += 1
			break
o = ''
for (c, r) in zip(s, rpt):
	o += c * r
print(o)


def solve():
	n = int(input())
	s = 'codeforces'
	a = [1] * 10
	i = 0
	c = 1
	while c < n:
		c //= a[i]
		a[i] += 1
		c *= a[i]
		i = (i + 1) % 10
	return ''.join((a[j] * s[j] for j in range(10)))
print(solve())


def get_cnt(k):
	(l, r) = (0, 41)
	while r - l > 1:
		mid = (r + l) // 2
		if mid ** 10 < k:
			l = mid
		else:
			r = mid
	return r

def kek(i, tmp, s):
	for j in range(tmp - 1):
		print(s[i], end='')
k = int(input())
cf = 'codeforces'
t = 1
tmp = get_cnt(k)
for i in range(10):
	kek(i, tmp, cf)
	if t * (tmp - 1) * tmp ** (10 - i - 1) >= k and tmp > 1:
		t *= tmp - 1
	else:
		print(cf[i], end='')
		t *= tmp


n = int(input())
k = 2
g = 'codeforces'
while k ** 10 < n:
	k = k + 1
p = k - 1
s = 10
while k ** s * p ** (10 - s) > n:
	s = s - 1
if k ** s * p ** (10 - s) < n:
	s = s + 1
for i in range(s):
	print(g[i] * k, end='')
for i in range(s, 10):
	print(g[i] * p, end='')


k = int(input())
s = 'codeforces'
ar = [1] * 10
ct = 1
c = 0
while ct < k:
	ct //= ar[c]
	ar[c] += 1
	ct *= ar[c]
	c += 1
	c %= 10
for i in range(10):
	print(ar[i] * s[i], end='')


k = int(input())
t = 1
s = 'codeforces'
ans = [1] * 10
i = 0
while t < k:
	t = t // ans[i] * (ans[i] + 1)
	ans[i] += 1
	i = (i + 1) % 10
res = []
for (i, j) in zip(s, ans):
	res.extend([i] * j)
print(''.join(res))


n = int(input())
res = ''
code = 'codeforces'

def s(a):
	res = 1
	for i in range(len(a)):
		res *= a[i]
	return res
a = [1] * 10
for i in range(50):
	for j in range(10):
		if s(a) >= n:
			for i in range(10):
				res += code[i] * a[i]
			print(res)
			exit()
		a[j] += 1
		if s(a) >= n:
			for i in range(10):
				res += code[i] * a[i]
			print(res)
			exit()


import sys
sys.setrecursionlimit(10 ** 7)
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
K = int(input())
REP = [1] * 10
CNT = 1
i = 0
while CNT < K:
	CNT //= REP[i]
	REP[i] += 1
	CNT *= REP[i]
	i = 0 if i == 9 else i + 1
S = []
STR = list('codeforces')
for i in range(10):
	S += STR[i] * REP[i]
print(''.join(S))


from sys import stdin
input = stdin.readline
n = int(input())
powt = [1] * 10

def ilo(l):
	wyn = 1
	for i in l:
		wyn *= i
	return wyn
while ilo(powt) < n:
	powt.sort()
	powt[0] += 1
slowo = ''
dupa = 'codeforces'
for i in range(10):
	slowo += dupa[i] * powt[i]
print(slowo)


k = int(input())
l = [['c', 1], ['o', 1], ['d', 1], ['e', 1], ['f', 1], ['o', 1], ['r', 1], ['c', 1], ['e', 1], ['s', 1]]
i = 2
j = 0
count = 1
while count < k:
	l[j][1] += 1
	j += 1
	count = count * i / (i - 1)
	if j == 10:
		j = 0
		i += 1
for i in range(10):
	for j in range(l[i][1]):
		print(l[i][0], end='')


from math import inf as inf
from math import *
from collections import *
import sys
from itertools import permutations
input = sys.stdin.readline
t = 1
while t:
	t -= 1
	n = int(input())
	if n == 1:
		print('codeforces')
		continue
	l = [[1, 'c'], [1, 'o'], [1, 'd'], [1, 'e'], [1, 'f'], [1, 'o'], [1, 'r'], [1, 'c'], [1, 'e'], [1, 's']]
	ss = 0
	while 1:
		p = 1
		for i in l:
			p *= i[0]
		if p >= n:
			break
		l[ss % 10][0] += 1
		ss += 1
	c2 = 0
	for i in l:
		c2 += i[0]
		print(i[1] * i[0], end='')
	print()


from sys import stdin, setrecursionlimit, stdout
from collections import deque
from math import sqrt, floor, ceil, log, log2, log10, pi, gcd, sin, cos, asin

def ii():
	return int(stdin.readline())

def fi():
	return float(stdin.readline())

def mi():
	return map(int, stdin.readline().split())

def fmi():
	return map(float, stdin.readline().split())

def li():
	return list(mi())

def si():
	return stdin.readline().rstrip()

def lsi():
	return list(si())
res = ['Yes', 'No']
fib = [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, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073, 4807526976, 7778742049, 12586269025, 20365011074, 32951280099, 53316291173, 86267571272, 139583862445, 225851433717, 365435296162, 591286729879, 956722026041, 1548008755920, 2504730781961, 4052739537881, 6557470319842, 10610209857723, 17167680177565, 27777890035288, 44945570212853, 72723460248141, 117669030460994, 190392490709135, 308061521170129, 498454011879264, 806515533049393, 1304969544928657, 2111485077978050, 3416454622906707, 5527939700884757, 8944394323791464, 14472334024676221]
test_case = 1
while test_case:
	test_case -= 1
	n = ii()
	i = 1
	p = [1] * 10
	while True:
		for i in range(10):
			k = 1
			for j in p:
				k *= j
			if k >= n:
				break
			p[i] += 1
		if k >= n:
			break
	a = 'codeforces'
	ans = []
	for i in range(10):
		ans.append(a[i] * p[i])
	print(*ans, sep='')


k = int(input())
if k == 1:
	print('codeforces')
else:
	num = 1
	s = 'codeforces'
	t = ''
	for i in range(2, 100):
		for j in range(0, 10):
			if num < k:
				num /= i - 1
				num *= i
				if num >= k:
					for n in range(10):
						if n <= j:
							t += s[n] * i
						else:
							t += s[n] * (i - 1)
	print(t)


k = int(input())
i = 1
x = i
while k > x:
	i += 1
	x = i ** 10
temp = 0
while x > k:
	x = x // i
	x *= i - 1
	temp += 1
if k > x:
	temp -= 1
temp = 10 - temp
s = 'codeforces'
res = ''
for j in range(10):
	if temp > 0:
		res += s[j] * i
		temp -= 1
	else:
		res += s[j] * (i - 1)
print(res)


import sys
k = int(input())
if k == 1:
	print('codeforces')
	sys.exit(0)
n = 1
while n ** 10 < k:
	n += 1
n -= 1
c = [n for _ in range(10)]
s = 'codeforces'
b = n ** 10
i = 0
while b < k:
	c[i] = n + 1
	i += 1
	b = b // n * (n + 1)
print(''.join((a * c[i] for (i, a) in enumerate(s))))


import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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')

def value():
	return tuple(map(int, input().split()))

def array():
	return [int(i) for i in input().split()]

def Int():
	return int(input())

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]

def factors(n):
	ans = []
	while n % 2 == 0:
		ans.append(2)
		n = n // 2
	for i in range(3, int(sqrt(n)) + 1, 2):
		while n % i == 0:
			ans.append(i)
			n = n // i
	if n > 2:
		ans.append(n)
	return ans
for _ in range(1):
	n = Int()
	ans = 'codeforces'
	count = defaultdict(lambda : 1)
	cur = 1
	i = 0
	while cur < n:
		cur = cur // count[i]
		count[i] += 1
		cur *= count[i]
		i = (i + 1) % len(ans)
	for i in range(len(ans)):
		print(ans[i] * count[i], end='')


k = int(input())
if k == 1:
	print('codeforces')
	exit(0)
arr = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

def get_sum(arr):
	ans = 0
	for i in arr:
		ans += i
	return ans

def get_pr(arr):
	ans = 1
	for i in arr:
		ans *= i
	return ans
flag = True
while flag:
	for i in range(10):
		arr[i] += 1
		pr = get_pr(arr)
		if pr >= k:
			flag = False
			break
cf = 'codeforces'
s = ''
for i in range(10):
	s += cf[i] * arr[i]
print(s)


import sys
lines = sys.stdin.readlines()
k = int(lines[0].strip())
base = int(k ** 0.1)
if pow(base, 10) > k:
	base -= 1
for i in range(10, -1, -1):
	tmp = pow(base, i) * pow(base + 1, 10 - i)
	if tmp >= k:
		num = i
		break
s = ''
c = 'codeforces'
for i in range(10):
	if i < num:
		s += c[i] * base
	else:
		s += c[i] * (base + 1)
print(s)


import math
import sys
input = sys.stdin.readline
k = int(input())
kk = 1
i = 1
cf = [1] * 10
cff = list('codeforces')
j = 0
while kk < k:
	cf[j] += 1
	j += 1
	kk = kk // i * (i + 1)
	if j == 10:
		j = 0
		i += 1
ans = ''
for i in range(10):
	ans += cff[i] * cf[i]
print(ans)


import atexit
import io
import sys
import math
from collections import defaultdict, Counter
n = int(input())
l = [1] * 10
k = 1
j = 0
while k < n:
	l[j % 10] += 1
	j += 1
	k = 1
	for i in l:
		k *= i
s1 = ''
d = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
for i in range(10):
	s1 += d[i] * l[9 - i]
print(s1)


k = int(input())
l = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
ind = 0
prod = 1
while prod < k:
	l[ind] += 1
	ind = (ind + 1) % 10
	prod = 1
	for i in l:
		prod = prod * i
s = ''
s = s + 'c' * l[0]
s = s + 'o' * l[1]
s = s + 'd' * l[2]
s = s + 'e' * l[3]
s = s + 'f' * l[4]
s = s + 'o' * l[5]
s = s + 'r' * l[6]
s = s + 'c' * l[7]
s = s + 'e' * l[8]
s = s + 's' * l[9]
print(s)


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
k = int(input())
chars = [1 for x in range(10)]
string = 'codeforces'
ans = 1
i = 0
while ans < k:
	ans = ans // chars[i]
	chars[i] += 1
	ans = ans * chars[i]
	i = (i + 1) % 10
s = ''.join([string[i] * chars[i] for i in range(10)])
print(s)


n = int(input())
r = [1] * 10
a = ''
i = 0
s = 'codeforces'
p = 1
while n > p:
	r[i] += 1
	i = (i + 1) % 10
	p = 1
	for j in range(10):
		p *= r[j]
for i in range(10):
	a = a + s[i] + s[i] * (r[i] - 1)
print(a)


k = int(input())
list1 = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
for i in range(1000):
	product = list1[0] * list1[1] * list1[2] * list1[3] * list1[4] * list1[5] * list1[6] * list1[7] * list1[8] * list1[9]
	if product >= k:
		break
	list1[i % 10] += 1
ans = []
for i in range(list1[0]):
	ans.append('c')
for i in range(list1[1]):
	ans.append('o')
for i in range(list1[2]):
	ans.append('d')
for i in range(list1[3]):
	ans.append('e')
for i in range(list1[4]):
	ans.append('f')
for i in range(list1[5]):
	ans.append('o')
for i in range(list1[6]):
	ans.append('r')
for i in range(list1[7]):
	ans.append('c')
for i in range(list1[8]):
	ans.append('e')
for i in range(list1[9]):
	ans.append('s')
for values in ans:
	print(values, end='')
print()


k = int(input())

def prod(arr):
	ans = 1
	for i in arr:
		ans *= i
	return ans

def inc(i):
	if i == 9:
		return 0
	return i + 1
fill = 'codeforces'
tot = 0
items = [''] * 10
numbers = [0] * 10
index = 0
while tot < k:
	items[index] += fill[index]
	numbers[index] += 1
	tot = prod(numbers)
	index = inc(index)
print(''.join(items))


from functools import reduce
n = int(input())
arr = [1] * 10
while reduce(lambda x, y: x * y, arr) < n:
	if arr.count(arr[0]) == 10:
		arr[0] += 1
	else:
		i = 1
		while i < 10:
			if arr[i] != arr[i - 1]:
				arr[i] += 1
				break
			i += 1
print('c' * arr[0] + 'o' * arr[1] + 'd' * arr[2] + 'e' * arr[3] + 'f' * arr[4] + 'o' * arr[5] + 'r' * arr[6] + 'c' * arr[7] + 'e' * arr[8] + 's' * arr[9])


k = int(input())
n = int(k ** (1 / 10))
l = []
for i in range(10):
	l.append(n)
i = 0
p = 1
for i in range(10):
	p = 1
	for j in range(10):
		p = p * l[j]
	if p >= k:
		break
	l[i] += 1
s = 'codeforces'
t = ''
for i in range(10):
	t += s[i] * l[i]
print(t)


n = int(input())
s = 'codeforces'
lis = [1] * 10
ans = 1
if n == 1:
	print(s)
	exit()
for i in range(2, 50):
	for j in range(10):
		lis[j] = i
		ans = ans * i // (i - 1)
		if ans >= n:
			break
	if ans >= n:
		break
fin = ''
for i in range(10):
	fin += s[i] * lis[i]
print(fin)


import sys
ii1 = lambda : int(sys.stdin.readline())
iia = lambda : list(map(int, sys.stdin.readline().split()))
n = ii1()
dp = [1] * 10
flag = True
counter = 1
while flag:
	for i in range(10):
		if counter >= n:
			flag = False
			break
		dp[i] += 1
		counter //= dp[i] - 1
		counter *= dp[i]
s = 'codeforces'
for i in range(10):
	print(s[i] * dp[i], end='')
print()


n = int(input())
cf = list('codeforces')
count = [1 for i in range(len('codeforces'))]
val = 1
while val < n:
	for i in range(len(count)):
		count[i] += 1
		val = 1
		for x in count:
			val *= x
		if val >= n:
			break
for (c, i) in zip(count, cf):
	print(i * c, end='')


import sys
readline = sys.stdin.readline
K = int(readline())
S = 'codeforces'
arr = [1] * 10
for _ in range(1000):
	res = 1
	for a in arr:
		res *= a
	if res >= K:
		break
	arr[arr.index(min(arr))] += 1
ans = ''
for i in range(10):
	ans = ans + S[i] * arr[i]
print(ans)


import sys
input = sys.stdin.readline
t = int(input())
maxx = 0
init = [1 for i in range(10)]
for j in range(1000):
	if t == 1:
		break
	init[j % 10] += 1
	multi = 1
	for k in range(10):
		multi *= init[k]
	if multi >= t:
		break
s = 'codeforces'
ans = ''
for k in range(10):
	ans += s[k] * init[k]
print(ans)


t = 1
for tt in range(t):
	n = int(input())
	q = [1] * 10
	w = 0
	qq = ''
	ww = 'codeforces'
	while True:
		product = 1
		for i in range(10):
			product = product * q[i]
		if product >= n:
			break
		q[w % 10] = q[w % 10] + 1
		w = w + 1
	for i in range(10):
		qq = qq + ww[i] * q[i]
	print(qq)


import math
t1 = 1
zer_cnd = 0
answer_string = 'codeforces'
while t1:
	t1 = t1 - 1
	k = int(input())
	if k == 1 and zer_cnd + 1:
		print(answer_string)
		break
	count = math.floor(k ** 0.1)
	if count >= 1:
		res = count ** 10
		if count == k:
			ans = ''
			for i in answer_string:
				ans = ans + str(answer_string[i]) * count
			print(ans)
			break
		res = count ** 10
		t = 0
		for i in range(0, len(answer_string)):
			if res >= k:
				break
			res = res * (count + 1) / count
			t = t + 1
		ans = ''
		fifa = 0
		for i in range(t):
			ans = ans + str(answer_string[i]) * (count + 1)
			fifa = fifa + 1
		for i in range(len(answer_string) - t):
			ans = ans + str(answer_string[fifa]) * count
			fifa = fifa + 1
		print(ans)


import sys
from collections import defaultdict as dd
from collections import deque
from fractions import Fraction as f
from itertools import permutations

def eprint(*args):
	print(*args, file=sys.stderr)
zz = 1
from math import *
import copy
if zz:
	input = sys.stdin.readline
else:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('all.txt', 'w')

def li():
	return [int(x) for x in input().split()]

def fi():
	return int(input())

def si():
	return list(input().rstrip())

def mi():
	return map(int, input().split())

def gh():
	sys.stdout.flush()

def bo(i):
	return ord(i) - ord('a')
from copy import *
from bisect import *

def pro(f):
	c = 1
	for i in range(10):
		c *= f[i]
	return c
if 1:
	n = fi()
	dif = 10 + n - 1
	p = 1
	z = n
	if n == 1:
		print('codeforces')
		exit(0)
	s = 'codeforces'
	f = [1 for i in range(10)]
	j = 0
	while pro(f) < n:
		f[j % 10] += 1
		j += 1
	for i in range(10):
		print(f[i] * s[i], end='')


import math
k = int(input())
a = 'codeforces'
c = math.ceil(k ** (1 / 10)) - 1
list1 = list(a)
list2 = [c * i for i in list1]
mult = 1
for i in list2:
	mult *= len(i)
i = 0
if c == 0:
	print(a)
else:
	while mult < k:
		list2[i] = list2[i] + list1[i]
		mult = mult / c
		mult = mult * (c + 1)
		i += 1
	a = ''.join(list2)
	print(a)


k = int(input())
s = 'codeforces'
cnt = [1] * 10
x = 1
while x < k:
	for i in range(10):
		x /= cnt[i]
		cnt[i] += 1
		x *= cnt[i]
		if x >= k:
			break
for i in range(10):
	for _ in range(cnt[i]):
		print(s[i], end='')


n = int(input())
if n == 1:
	print('codeforces', end='')
else:
	count = 1
	i = 1
	while count < n:
		i += 1
		count = i ** 10
	if i * (i - 1) ** 9 >= n:
		print('c' * i, 'o' * (i - 1), 'd' * (i - 1), 'e' * (i - 1), 'f' * (i - 1), 'o' * (i - 1), 'r' * (i - 1), 'c' * (i - 1), 'e' * (i - 1), 's' * (i - 1), sep='')
	elif i * i * (i - 1) ** 8 >= n:
		print('c' * i, 'o' * i, 'd' * (i - 1), 'e' * (i - 1), 'f' * (i - 1), 'o' * (i - 1), 'r' * (i - 1), 'c' * (i - 1), 'e' * (i - 1), 's' * (i - 1), sep='')
	elif i * i * i * (i - 1) ** 7 >= n:
		print('c' * i, 'o' * i, 'd' * i, 'e' * (i - 1), 'f' * (i - 1), 'o' * (i - 1), 'r' * (i - 1), 'c' * (i - 1), 'e' * (i - 1), 's' * (i - 1), sep='')
	elif i * i * i * i * (i - 1) ** 6 >= n:
		print('c' * i, 'o' * i, 'd' * i, 'e' * i, 'f' * (i - 1), 'o' * (i - 1), 'r' * (i - 1), 'c' * (i - 1), 'e' * (i - 1), 's' * (i - 1), sep='')
	elif i * i * i * i * i * (i - 1) ** 5 >= n:
		print('c' * i, 'o' * i, 'd' * i, 'e' * i, 'f' * i, 'o' * (i - 1), 'r' * (i - 1), 'c' * (i - 1), 'e' * (i - 1), 's' * (i - 1), sep='')
	elif i * i * i * i * i * i * (i - 1) ** 4 >= n:
		print('c' * i, 'o' * i, 'd' * i, 'e' * i, 'f' * i, 'o' * i, 'r' * (i - 1), 'c' * (i - 1), 'e' * (i - 1), 's' * (i - 1), sep='')
	elif i * i * i * i * i * i * i * (i - 1) ** 3 >= n:
		print('c' * i, 'o' * i, 'd' * i, 'e' * i, 'f' * i, 'o' * i, 'r' * i, 'c' * (i - 1), 'e' * (i - 1), 's' * (i - 1), sep='')
	elif i * i * i * i * i * i * i * i * (i - 1) ** 2 >= n:
		print('c' * i, 'o' * i, 'd' * i, 'e' * i, 'f' * i, 'o' * i, 'r' * i, 'c' * i, 'e' * (i - 1), 's' * (i - 1), sep='')
	elif i * i * i * i * i * i * i * i * i * (i - 1) ** 1 >= n:
		print('c' * i, 'o' * i, 'd' * i, 'e' * i, 'f' * i, 'o' * i, 'r' * i, 'c' * i, 'e' * i, 's' * (i - 1), sep='')
	else:
		print('c' * i, 'o' * i, 'd' * i, 'e' * i, 'f' * i, 'o' * i, 'r' * i, 'c' * i, 'e' * i, 's' * i, sep='')


def mult(lis):
	p = 1
	for i in lis:
		p *= i
	return p
n = int(input())
lis = [0] * 10
for i in range(10):
	lis[i] = int(pow(n, 1 / 10))
while mult(lis) < n:
	i = lis.index(min(lis))
	lis[i] += 1
s = 'codeforces'
x = ''
for i in range(10):
	x += lis[i] * s[i]
print(x)


import sys
inputr = lambda : sys.stdin.readline().rstrip('\n')
input = sys.stdin.readline
S = 'codeforces'
k = int(input())
if k == 1:
	print('codeforces')
	sys.exit(0)

def build(use):
	s = ''
	for (i, v) in enumerate(use):
		s += S[i] * v
	return s
from functools import lru_cache

def num_subsequences(seq, sub):
	(m, n) = (len(seq), len(sub))

	@lru_cache(maxsize=None)
	def count(i, j):
		if j == n:
			return 1
		elif i == m:
			return 0
		return count(i + 1, j) + (count(i + 1, j + 1) if seq[i] == sub[j] else 0)
	return count(0, 0)
for num in range(2, 10 ** 18):
	use = [num - 1] * 10
	for i in range(10):
		use[i] += 1
		s = build(use)
		if num_subsequences(s, S) >= k:
			print(s)
			sys.exit(0)


import sys
import math
import collections
import operator as op
from collections import deque
from math import gcd
from functools import reduce
from sys import stdin, stdout, setrecursionlimit
setrecursionlimit(2 ** 20)

def factorial(n):
	if n == 0:
		return 1
	return n * factorial(n - 1)

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer // denom

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
T = 1
for _ in range(T):
	k = int(stdin.readline())
	if k == 1:
		print('codeforces')
		break
	check = False
	t = -1
	for i in range(1, 41):
		if i ** 10 == k:
			check = True
			t = i
			break
		elif i ** 10 > k:
			t = i - 1
			break
		else:
			continue
	if check:
		res = ''
		for i in 'codeforces':
			res += i * t
		print(res)
		break
	res = ''
	d = {}
	for i in range(10):
		d[i] = t
	rem = k - t ** 10
	cnt = 0
	st = 'codeforces'
	while rem > 0:
		rem -= t ** (9 - cnt) * (t + 1) ** cnt
		d[cnt] += 1
		cnt += 1
	res = ''
	for i in range(10):
		res += st[i] * d[i]
	print(res)


n = int(input())
sl = list('codeforces')
l = [1] * 10
cnt = 1
i = 0
while True:
	if i == 10:
		i = 0
	t = 1
	for j in range(10):
		t *= l[j]
	if t >= n:
		break
	l[i] += 1
	i += 1
s = ''
for i in range(10):
	s += sl[i] * l[i]
print(s)


a = int(input())
l = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
id = 0
g = 1
while 1:
	g = 1
	if id == 10:
		id = 0
	g = 1
	for j in range(10):
		g = g * l[j]
	if g >= a:
		break
	l[id] = l[id] + 1
	id = id + 1
for i in range(l[0]):
	print('c', end='')
for i in range(l[1]):
	print('o', end='')
for i in range(l[2]):
	print('d', end='')
for i in range(l[3]):
	print('e', end='')
for i in range(l[4]):
	print('f', end='')
for i in range(l[5]):
	print('o', end='')
for i in range(l[6]):
	print('r', end='')
for i in range(l[7]):
	print('c', end='')
for i in range(l[8]):
	print('e', end='')
for i in range(l[9]):
	print('s', end='')


k = int(input())
res = 'codeforces'
n = len(res)
cnt = [1] * n
sum = 1
pos = 0
while sum < k:
	sum /= cnt[pos]
	cnt[pos] += 1
	sum *= cnt[pos]
	pos += 1
	if pos >= n:
		pos = 0
for i in range(n):
	for j in range(cnt[i]):
		print(res[i], end='')


n = int(input())
a = [1] * 10
s = 'codeforces'
t = 1
ii = 0
while n > t:
	a[ii] += 1
	ii = (ii + 1) % 10
	t = 1
	for u in range(10):
		t *= a[u]
for i in range(10):
	print(s[i] * a[i], end='')


import sys
input = sys.stdin.readline
N = int(input())
Ss = list('codeforces')
L = len(Ss)
n = 1
while pow(n, L) < N:
	n += 1
ind = -1
for i in range(L):
	if pow(n, L - i) * pow(n - 1, i) >= N:
		ind = i
ans = ''
for (i, s) in enumerate(Ss):
	if i <= ind - 1:
		ans += s * (n - 1)
	else:
		ans += s * n
print(ans)


def prod(arr):
	p = 1
	for i in arr:
		p *= i
	return p
k = int(input())
t = [1] * 10
ch = list('codeforces')
i = 0
while prod(t) < k:
	t[i] += 1
	i += 1
	if i == 10:
		i = 0
for i in range(10):
	ch[i] *= t[i]
print(''.join(ch))


import sys

class BCodeforcesSubsequences:

	def solve(self, tc=0):
		from collections import defaultdict

		def factor(x):
			factors = []
			i = 2
			while x > 1:
				if x % i == 0:
					x = x / i
					factors.append(i)
				else:
					i += 1
			return factors
		k = int(input())

		def count(a, b):
			m = len(a)
			n = len(b)
			lookup = [[0] * (n + 1) for i in range(m + 1)]
			for i in range(n + 1):
				lookup[0][i] = 0
			for i in range(m + 1):
				lookup[i][0] = 1
			for i in range(1, m + 1):
				for j in range(1, n + 1):
					if a[i - 1] == b[j - 1]:
						lookup[i][j] = lookup[i - 1][j - 1] + lookup[i - 1][j]
					else:
						lookup[i][j] = lookup[i - 1][j]
			return lookup[m][n]
		c = [1] * 10
		cur = 9
		while 1:
			ans = ''.join(('codeforces'[i] * c[i] for i in range(10)))
			if count(ans, 'codeforces') >= k:
				print(ans)
				return
			c[cur] += 1
			cur = (cur - 1) % 10
solver = BCodeforcesSubsequences()
input = sys.stdin.readline
solver.solve()


from functools import reduce
x = int(input())
l = [1] * 10
while reduce(lambda x, y: x * y, l) < x:
	l[l.index(min(l))] += 1
s = ''
for i in range(10):
	s += 'codeforces'[i] * l[i]
print(s)


def f():
	return map(int, input().split())

def lis():
	return list(map(int, input().split()))
from functools import reduce
a = [0] * 10
k = int(input())
c = 0
s = 'codeforces'
while reduce(lambda x, y: x * y, a) < k:
	a[c % 10] += 1
	c += 1
t = ''
for i in range(10):
	t += s[i] * a[i]
print(t)


def pr(d):
	ans = 1
	for i in range(10):
		ans *= d[i]
	return ans
k = int(input())
x = 1
while x ** 10 < k:
	x += 1
d = [x] * 10
for i in range(10):
	d[i] -= 1
	if pr(d) < k:
		d[i] += 1
		break
s = list('codeforces')
for i in range(10):
	print(s[i] * d[i], end='')


n = int(input())
k = int(pow(n, 1 / 10))
t = k ** 10
s = 'codeforces'
for i in s:
	w = k
	if n > t:
		t //= k
		t *= k + 1
		w += 1
	print(i * w, end='')
print()


K = int(input())
counts = [1] * 10
n = 1
while n < K:
	for i in range(10):
		next_c = counts[i] + 1
		n = n // counts[i] * next_c
		counts[i] = next_c
		if n >= K:
			break
s = 'codeforces'
answer = ''
for i in range(10):
	answer += s[i] * counts[i]
print(answer)


n = int(input())
s = [x for x in 'codeforces']
l = [1] * 10
prod = 1
ind = 0
while prod < n:
	l[ind] += 1
	ind += 1
	ind %= 10
	prod = 1
	for i in l:
		prod *= i
for i in range(10):
	print(s[i] * l[i], end='')
print()


def solve(n):
	k = 1
	dic = {i: 1 for i in 'codefOrCEs'}
	while True:
		if k >= n:
			return dic
		for i in 'codefOrCEs':
			k = k // dic[i]
			dic[i] += 1
			k = k * dic[i]
			if k >= n:
				return dic
n = int(input())
ans = 1
dic = solve(n)
ans = [i * dic[i] for i in 'codefOrCEs']
anstr = ''.join([str.lower(str(x)) for x in ans])
print(anstr)


import sys
input = sys.stdin.readline
k = int(input())
if k == 1:
	print('codeforces')
	exit()
cnt = [1] * 10
n = 1
for i in range(1000):
	n //= cnt[i % 10]
	cnt[i % 10] += 1
	n *= cnt[i % 10]
	if n >= k:
		break
ans = ''
for (item, ch) in zip(cnt, 'codeforces'):
	ans += ch * item
print(ans)


n = int(input())
a = list('codeforces')
x = 0
for i in range(1, 80):
	k = i ** 10
	if k > n:
		(p, q) = (i - 1, i)
		for j in range(11):
			l = p ** (10 - j) * q ** j
			if l >= n:
				x = 0
				s = ''
				for z in range(j):
					s += a[z] * q
				for z in range(j, 10):
					s += a[z] * p
				print(s)
				break
		break
	if k == n:
		for k in a:
			for j in range(0, i):
				print(k, end='')
		break


k = int(input())
arr = [40] * 10
n = 40 ** 10
i = 0
while n > k:
	n = n // arr[i]
	arr[i] -= 1
	n = n * arr[i]
	i = (i + 1) % 10
if n < k:
	for i in range(10):
		if arr[i] < 40:
			arr[i] += 1
			break
s = ''
temp = 'codeforces'
for i in range(10):
	s += temp[i] * arr[i]
print(s)


def short_string(k):
	L = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
	l = len(L)
	x = 1
	while True:
		if k <= x ** l:
			break
		x = x + 1
	if k == x ** l:
		s = ''
		for st in L:
			s = s + st * x
		return s
	y = x ** l
	le = x * l
	for i in range(1, l + 1):
		y = x ** (l - i) * (x - 1) ** i
		if k > y:
			break
		le = le - 1
	p = x * l - le
	q = l - p
	s = ''
	for i in range(l):
		if i < p:
			s = s + L[i] * (x - 1)
		else:
			s = s + L[i] * x
	return s
k = int(input())
print(short_string(k))


from math import floor
k = int(input())
arr = [floor(k ** (1 / 10))] * 10

def prod(arr):
	acc = 1
	for e in arr:
		acc *= e
	return acc
for i in range(len(arr)):
	if prod(arr) >= k:
		break
	arr[i] += 1
print(''.join([arr[i] * 'codeforces'[i] for i in range(10)]))


def solve(k):
	A = [1] * 10
	while True:
		p = 1
		for x in A:
			p *= x
		if p >= k:
			break
		i = A.index(min(A))
		A[i] += 1
	ans = []
	for i in range(10):
		ans += ['codeforces'[i]] * A[i]
	return ''.join(ans)
print(solve(int(input())))


def read_int():
	return int(input().strip())

def read_ints():
	return list(map(int, input().strip().split(' ')))

def solve():
	k = read_int()
	S = 'codeforces'
	count = [1 for _ in S]
	T = 1
	i = 0
	while T < k:
		T //= count[i]
		count[i] += 1
		T *= count[i]
		i = (i + 1) % len(count)
	return ''.join([s * c for (s, c) in zip(S, count)])
print(solve())


s = 'codeforces'
slen = len(s)
k = int(input())
l = slen
r = slen * 100
while l < r:
	m = (l + r) // 2
	count = 1
	rest = m
	for ci in range(slen):
		cur = rest // (slen - ci)
		rest -= cur
		count *= cur
	if count >= k:
		r = m
	else:
		l = m + 1
ans = ''
rest = l
for (ci, c) in enumerate(s):
	cur = rest // (slen - ci)
	rest -= cur
	ans += c * cur
print(ans)


k = int(input())
l = 0
r = 1000

def chk(num, t):
	a = num // 10 + 1
	b = a + 1
	x = num % 10
	y = 10 - x
	tot = b ** x * a ** y
	return tot >= t
while l < r:
	mid = (l + r) // 2
	if chk(mid, k):
		r = mid
	else:
		l = mid + 1
a = l // 10 + 1
x = l % 10
y = 10 - x
s = 'codeforces'
for i in range(0, x):
	for j in range(0, a + 1):
		print(s[i], end='')
for i in range(x, 10):
	for j in range(0, a):
		print(s[i], end='')


cnt = int(input())
arr = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
carpm = 1
i = 0
while carpm < cnt:
	carpm /= arr[i]
	arr[i] += 1
	carpm *= arr[i]
	i += 1
	if i > 9:
		i = 0
print(arr[0] * 'c' + arr[1] * 'o' + arr[2] * 'd' + arr[3] * 'e' + arr[4] * 'f' + arr[5] * 'o' + arr[6] * 'r' + arr[7] * 'c' + arr[8] * 'e' + arr[9] * 's')


k = int(input())
n = 0
for i in range(1, 100):
	if i ** 10 > k:
		n = i - 1
		break
su = n ** 10
an = 0
while su < k:
	su //= n
	su *= n + 1
	an += 1
arr = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
for i in range(an):
	print(arr[i] * (n + 1), end='')
for i in range(an, 10):
	print(arr[i] * n, end='')


b = [0] * 500
t = 0
for i in range(500):
	b[i] = (i // 10 + 1) ** (10 - i % 10) * (i // 10 + 2) ** (i % 10)
k = int(input())
while k > b[t]:
	t += 1
print('c' * ((t - 1) // 10 + 2) + 'o' * ((t - 2) // 10 + 2) + 'd' * ((t - 3) // 10 + 2) + 'e' * ((t - 4) // 10 + 2) + 'f' * ((t - 5) // 10 + 2) + 'o' * ((t - 6) // 10 + 2) + 'r' * ((t - 7) // 10 + 2) + 'c' * ((t - 8) // 10 + 2) + 'e' * ((t - 9) // 10 + 2) + 's' * ((t - 10) // 10 + 2))


from math import *
from random import *
s = 'codeforces'
n = len(s)
k = int(input())
cnt = [1 for i in range(n)]
mlt = 1
pos = 0
while mlt < k:
	mlt //= cnt[pos]
	cnt[pos] += 1
	mlt *= cnt[pos]
	pos += 1
	if pos >= n:
		pos -= n
for i in range(n):
	for j in range(cnt[i]):
		print(s[i], end='')


production = True
import sys, math, collections

def input(input_format=0, multi=0):
	if multi > 0:
		return [input(input_format) for i in range(multi)]
	else:
		next_line = sys.stdin.readline()[:-1]
		if input_format >= 10:
			use_list = False
			input_format = int(str(input_format)[-1])
		else:
			use_list = True
		if input_format == 0:
			formatted_input = [next_line]
		elif input_format == 1:
			formatted_input = list(map(int, next_line.split()))
		elif input_format == 2:
			formatted_input = list(map(float, next_line.split()))
		elif input_format == 3:
			formatted_input = next_line.split()
		elif input_format == 4:
			formatted_input = (lambda x: [x[0], list(map(int, x[1:]))])(next_line.split())
		elif input_format == 5:
			formatted_input = (lambda x: [x[0], list(map(float, x[1:]))])(next_line.split())
		else:
			formatted_input = [next_line]
		return formatted_input if use_list else formatted_input[0]

def out(output_line, output_format=0, newline=True):
	formatted_output = ''
	if output_format == 0:
		formatted_output = str(output_line)
	elif output_format == 1:
		formatted_output = ' '.join(map(str, output_line))
	elif output_format == 1:
		formatted_output = '\n'.join(map(str, output_line))
	print(formatted_output, end='\n' if newline else '')

def log(*args):
	if not production:
		print('$$$', end='')
		print(*args)
enum = enumerate

def r(d):
	t = 1
	for i in d:
		t *= i
	return t

def solve():
	k = input(11)
	d = [1] * 10
	j = 0
	while r(d) < k:
		if j < 10:
			d[j] += 1
			j += 1
		else:
			j = 0
	y = 'codeforces'
	g = ''
	for (i, n) in zip(y, d):
		g += i * n
	out(g)
	return
solve()


k = int(input())
codeforces = 'codeforces'
ans = ''
summ = 1
char_index = 0
mult_arr = [1] * len(codeforces)
while k > summ:
	summ //= mult_arr[char_index]
	mult_arr[char_index] += 1
	summ *= mult_arr[char_index]
	char_index = (char_index + 1) % len(codeforces)
for (index, multiplier) in enumerate(mult_arr):
	ans += codeforces[index] * multiplier
print(ans)


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
sys.setrecursionlimit(int(pow(10, 6)))
mod = int(pow(10, 9) + 7)
mod2 = 998244353

def data():
	return sys.stdin.readline().strip()

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
for _ in range(1):
	k = l()[0]
	x = 1
	c = 1
	while (c + 1) ** 10 < k:
		c += 1
	x = c ** 10
	i = 0
	while i < 10 and x < k:
		x = x * (c + 1) // c
		i += 1
	s = 'codeforces'
	ans = ''
	for j in range(10):
		if j < i:
			ans += s[j] * (c + 1)
		else:
			ans += s[j] * c
	print(ans)


for _ in range(1):
	n = int(input())
	a = [1] * 10
	b = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
	pr = 1
	i = 0
	while pr < n:
		pr /= a[i]
		a[i] += 1
		pr *= a[i]
		i += 1
		i %= 10
	for i in range(10):
		print(b[i] * a[i], end='')


k = int(input())
counts = [1] * 10
string = 'codeforces'
rep = 1
index = 0
while rep < k:
	current_multiplier = counts[index % 10]
	rep = rep / current_multiplier * (current_multiplier + 1)
	counts[index % 10] = current_multiplier + 1
	index += 1
print(''.join([c * counts[i] for (i, c) in enumerate(string)]))


n = int(input())
nu = [1] * 10
p = 1
while p < n:
	for j in range(0, 10):
		p = 1
		for k in range(10):
			p *= nu[k]
		if p < n:
			nu[j] += 1
		else:
			break
print('c' * nu[0] + 'o' * nu[1] + 'd' * nu[2] + 'e' * nu[3] + 'f' * nu[4] + 'o' * nu[5] + 'r' * nu[6] + 'c' * nu[7] + 'e' * nu[8] + 's' * nu[9])


from itertools import zip_longest

def solve(k):
	n = 1
	letters = [1 for _ in range(10)]
	i = 0
	while n < k:
		n //= letters[i]
		letters[i] += 1
		n *= letters[i]
		i = (i + 1) % 10
	return ''.join((a * b for (a, b) in zip('codeforces', letters)))
K = int(input())
print(solve(K))


import sys

def gen(arr):
	result = 'codeforces'
	l = len(result)
	cnts = arr[::-1]
	if len(cnts) < l:
		cnts.extend([1] * (l - len(cnts)))
	word = [result[i] * cnts[i] for i in range(l)]
	return ''.join(word)

def solve(k):
	MAX_LEN = 10
	DP = [(1, [1]), (2, [2]), (4, [2, 2])]
	if k == 1:
		return gen(DP[0][1])
	elif k <= 2:
		return gen(DP[1][1])
	elif k <= 4:
		return gen(DP[2][1])
	full = False
	i = 2
	while True:
		(cnt, arr) = DP[i]
		if cnt >= k:
			return gen(arr)
		else:
			i += 1
			if not full:
				bst = (0, [])
				for j in range(1, i // 2 + 1):
					(c1, a1) = DP[j]
					(c2, a2) = DP[i - j]
					cand_len = MAX_LEN - len(a1) - len(a2) + sum(a1) + sum(a2)
					if cand_len > MAX_LEN + i:
						continue
					if c1 * c2 > bst[0]:
						cat = [x for x in a1]
						cat.extend(a2)
						bst = (c1 * c2, cat)
				if len(bst[1]) <= MAX_LEN:
					DP.append(bst)
				else:
					full = True
					i -= 1
					continue
			else:
				ii = i + 10
				rem = ii % MAX_LEN
				anew = [ii // MAX_LEN] * 10
				for j in range(MAX_LEN - 1, MAX_LEN - rem - 1, -1):
					anew[j] += 1
				p = 1
				for v in anew:
					p *= v
				DP.append((p, anew))
	return result
IN = [x.strip() for x in sys.stdin.readlines()]
T = int(IN[0])
word = solve(T)
print(word)


from math import ceil
k = int(input())
st = 'codeforces'
bck = [1] * len(st)
p = 1
i = 0
while p < k:
	bck[i] += 1
	p = 1
	for j in bck:
		p *= j
	i = (i + 1) % 10
s = ''
for i in range(10):
	s += st[i] * bck[i]
print(s)


def product(l):
	p = 1
	for i in l:
		p = p * i
	return p
n = int(input())
y = 0
ls = list((1 for _ in range(10)))
while product(ls) < n:
	ls[y % 10] += 1
	y += 1
w = 'codeforces'
lis = []
for i in range(10):
	lis.append(w[i] * ls[i])
print(''.join(lis))


from functools import reduce
s = 'codeforces'
a = [0] * 10
k = int(input())
p = 0
while reduce(lambda x, y: x * y, a) < k:
	a[p % 10] += 1
	p += 1
for i in range(10):
	print(s[i] * a[i], end='')


k = int(input())
s = 'codeforces'
c = [1 for i in range(10)]
ind = 0
while 1:
	x = 1
	for i in c:
		x *= i
	if x >= k:
		break
	c[ind] += 1
	ind += 1
	ind %= 10
ans = ''
for i in range(10):
	ans += s[i] * c[i]
print(ans)


import math
k = int(input())
i = 1
res = ''
s = 'codeforces'
ans = 0
while k > math.pow(i, 10):
	i = i + 1
x = i
for i in range(1, 11):
	y = math.pow(x, i)
	z = math.pow(x - 1, 10 - i)
	if y * z >= k:
		ans = i
		break
for i in range(ans):
	res = res + s[i] * x
for i in range(ans, 10):
	res = res + s[i] * (x - 1)
print(res)


n = int(input())
s = list('codeforces')
if n == 1:
	print(*s, sep='')
	exit()
for i in range(1, 10000):
	if i ** 10 >= n:
		k = i
		break
k -= 1
for i in range(1, 11):
	if (k + 1) ** i * k ** (10 - i) >= n:
		m = i
		break
ans = ''
for i in range(10):
	if i < m:
		ans += s[i] * (k + 1)
	else:
		ans += s[i] * k
print(ans)


from collections import defaultdict as dd
import sys
input = sys.stdin.readline
n = int(input())
ind = 1
for i in range(1, 100):
	if i ** 10 >= n:
		ind = i
		break
cur = ind ** 10
res = [ind] * 10
ans = ''
ss = 'codeforces'
for i in range(10):
	if cur // ind * (ind - 1) < n:
		break
	res[i] = ind - 1
	cur = cur // ind * (ind - 1)
for i in range(10):
	ans += ss[i] * res[i]
print(ans)


def solve():
	n = int(input())
	l = [1] * 10
	s = 'codeforces'
	prod = 1
	j = 0
	while prod < n:
		l[j] += 1
		j = (j + 1) % 10
		prod = 1
		for i in range(10):
			prod *= l[i]
	for i in range(10):
		print(s[i] * l[i], end='')
solve()


n = int(input())
a = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
f = lambda x, a: [(x := (x * i)) for i in a][-1]
i = 0
while f(1, a) < n:
	a[i] += 1
	i = (i + 1) % 10
print(*('codeforces'[i] * a[i] for i in range(10)), sep='')


from collections import defaultdict
import sys, math
f = None
try:
	f = open('q1.input', 'r')
except IOError:
	f = sys.stdin
if 'xrange' in dir(__builtins__):
	range = xrange
sys.setrecursionlimit(10 ** 2)

def print_case_iterable(case_num, iterable):
	print('Case #{}: {}'.format(case_num, ' '.join(map(str, iterable))))

def print_case_number(case_num, iterable):
	print('Case #{}: {}'.format(case_num, iterable))

def print_iterable(A):
	print(' '.join(A))

def read_int():
	return int(f.readline().strip())

def read_int_array():
	return [int(x) for x in f.readline().strip().split(' ')]

def rns():
	a = [x for x in f.readline().split(' ')]
	return (int(a[0]), a[1].strip())

def read_string():
	return list(f.readline().strip())

def ri():
	return int(f.readline().strip())

def ria():
	return [int(x) for x in f.readline().strip().split(' ')]

def rns():
	a = [x for x in f.readline().split(' ')]
	return (int(a[0]), a[1].strip())

def rs():
	return list(f.readline().strip())

def bi(x):
	return bin(x)[2:]
from collections import deque
import math
NUMBER = 998244353

def factorial(n):
	M = NUMBER
	f = 1
	for i in range(1, n + 1):
		f = f * i % M
	return f

def mult(a, b):
	return a * b % NUMBER

def minus(a, b):
	return (a - b) % NUMBER

def plus(a, b):
	return (a + b) % NUMBER

def egcd(a, b):
	if a == 0:
		return (b, 0, 1)
	else:
		(g, y, x) = egcd(b % a, a)
		return (g, x - b // a * y, y)

def modinv(a):
	m = NUMBER
	(g, x, y) = egcd(a, m)
	if g != 1:
		raise Exception('modular inverse does not exist')
	else:
		return x % m

def choose(n, k):
	if n < k:
		assert false
	return mult(factorial(n), modinv(mult(factorial(k), factorial(n - k))))
from collections import deque, defaultdict
import heapq
from types import GeneratorType

def bootstrap(f, stack=[]):

	def wrappedfunc(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		else:
			to = f(*args, **kwargs)
			while True:
				if type(to) is GeneratorType:
					stack.append(to)
					to = next(to)
				else:
					stack.pop()
					if not stack:
						break
					to = stack[-1].send(to)
			return to
	return wrappedfunc

def dfs(g, timeIn, timeOut, depths, parents):
	cnt = 0
	stack = [[1, 0, 0, 0]]
	while stack:
		(v, neig_i, parent, depth) = stack[-1]
		parents[v] = parent
		depths[v] = depth
		if neig_i == 0:
			timeIn[v] = cnt
			cnt += 1
		while neig_i < len(g[v]):
			u = g[v][neig_i]
			if u == parent:
				neig_i += 1
				continue
			stack[-1][1] = neig_i + 1
			stack.append([u, 0, v, depth + 1])
			break
		if neig_i == len(g[v]):
			stack.pop()
			timeOut[v] = cnt
			cnt += 1

def isAncestor(u: int, v: int, timeIn: list, timeOut: list) -> str:
	return timeIn[u] <= timeIn[v] and timeOut[v] <= timeOut[u]
cnt = 0

@bootstrap
def dfs(v, adj, timeIn, timeOut, depths, parents, parent=0, depth=0):
	global cnt
	parents[v] = parent
	depths[v] = depth
	timeIn[v] = cnt
	cnt += 1
	for u in adj[v]:
		if u == parent:
			continue
		yield dfs(u, adj, timeIn, timeOut, depths, parents, v, depth + 1)
	timeOut[v] = cnt
	cnt += 1
	yield

def solution(k):
	minrep = int(k ** 0.1)
	s = 'codeforces'
	for i in range(11):
		if minrep ** (10 - i) * (minrep + 1) ** i >= k:
			return ''.join([x * minrep for x in s[:10 - i]]) + ''.join([x * (minrep + 1) for x in s[10 - i:]])

def main():
	T = 1
	for i in range(T):
		k = ri()
		x = solution(k)
		if 'xrange' not in dir(__builtins__):
			print(x)
		else:
			(print >> output, str(x))
	if 'xrange' in dir(__builtins__):
		print(output.getvalue())
		output.close()
if 'xrange' in dir(__builtins__):
	import cStringIO
	output = cStringIO.StringIO()
main()


def mult(l):
	p = 1
	for i in l:
		p *= i
	return p
k = int(input())
s = 'codeforces'
p = [1] * 10
i = 0
while mult(p) < k:
	if i == 10:
		i = 0
	p[i] += 1
	i += 1
for i in range(10):
	print(s[i] * p[i], end='')
print()


import os

def readlist(src):
	return src.readline().split()

def solve(k):
	A = [1] * 10
	i = 0
	p = 1
	while p < k:
		p //= A[i]
		A[i] += 1
		p *= A[i]
		i = (i + 1) % 10
	ret = ''
	dict = 'codeforces'
	return ''.join([dict[i] * A[i] for i in range(10)])
test_file = 'testB.txt'
src = open(test_file) if os.path.isfile(test_file) else os.sys.stdin
n = src.readline()
print(solve(int(n)))


import os
from math import pow, ceil
k = int(input())
temp1 = 1
for i in range(1, 41):
	temp1 = pow(i, 10)
	if temp1 >= k:
		break
ans = ''
s = 'codeforces'
c = 10 * [0]
temp = 1
for j in range(10):
	c[j] = i
	temp1 //= i
	temp *= i
	if pow(i - 1, 9 - j) * temp >= k:
		for l in range(j + 1, 10):
			c[l] = i - 1
		break
for j in range(10):
	ans += c[j] * s[j]
out = ans
out = out.encode(encoding='UTF-8')
os.write(1, out)


from math import *

def rr(t):
	zzz = [t(i) for i in input().split()]
	if len(zzz) == 1:
		return zzz[0]
	return zzz

def r3(t):
	return [t(i) for i in input()]
k = int(input())
cnt = 1
s = [i for i in 'codeforces']
ts = [1 for i in s]
ci = 0
while cnt < k:
	cnt = cnt * (ts[ci] + 1) // ts[ci]
	ts[ci] += 1
	ci = (ci + 1) % len(s)
for i in range(len(ts)):
	print(s[i] * ts[i], end='')
print()


import math
n = int(input())
if n == 1:
	print('codeforces')
else:
	a = [1] * 10
	s = 'codeforces'
	i = 2
	while n > i ** 10:
		i += 1
	m = i
	ans = ''
	q1 = 9
	q2 = 1
	while m ** q2 * (m - 1) ** q1 < n:
		q2 += 1
		q1 -= 1
	arr = [m] * q2 + [m - 1] * q1
	for i in range(10):
		ans = ans + s[i] * arr[i]
	print(ans)


def read_list():
	return list(map(int, input().strip().split(' ')))

def print_list(l):
	print(' '.join(map(str, l)))
k = int(input())
tmp = int(pow(k, 0.1))
now = tmp ** 10
t2 = 0
while now < k:
	now //= tmp
	now *= tmp + 1
	t2 += 1
res = ''
for c in 'codeforces'[:t2]:
	res += c * (tmp + 1)
for c in 'codeforces'[t2:]:
	res += c * tmp
print(res)


from sys import stdin
import math
A = int(stdin.readline())
B = A ** 0.1
C = math.floor(B)
rr = C ** 10
rec = 0
Q = 0
while rr < A:
	for t in range(1, 11):
		if C ** (10 - t) * (C + 1) ** t >= A:
			rec = t
			Q = 1
			break
		if t == 10:
			Q = 1
	if Q == 1:
		break
E = ['y', 'c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
for u in range(1, 11):
	if u <= rec:
		for p in range(0, C + 1):
			print(E[u], end='')
	else:
		for w in range(0, C):
			print(E[u], end='')


import math
k = int(input())
s = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
baseVal = int(10 ** (math.log10(k) / 10))
freq = [baseVal for _ in range(10)]
(state, flag) = (baseVal ** 10, True)
while state < k:
	for i in range(10):
		freq[i] += 1
		state = state // baseVal * (baseVal + 1)
		if state >= k:
			flag = False
			break
	if flag is True:
		baseVal += 1
ans = []
for i in range(10):
	for _ in range(freq[i]):
		ans.append(s[i])
print(''.join(ans))


8140406085191601
k = int(input())
list1 = [1] * 10
prev = 1
product = 1
i = 0
while product < k:
	list1[i] += 1
	temp = 1
	for j in range(10):
		temp *= list1[j]
	i += 1
	i = i % 10
	product = temp
s = 'codeforces'
for i in range(len(s)):
	print(s[i] * list1[i], end='')


import math

def prod(nums):
	x = 1
	for i in nums:
		x *= i
	return x

def solve(n):
	nums = [1] * len('codeforces')
	temp = n
	i = 0
	while prod(nums) < temp:
		nums[i] += 1
		i = (i + 1) % len(nums)
	st = []
	for (i, j) in zip(nums, list('codeforces')):
		for x in range(i):
			st.append(j)
	print(''.join(st))
num_tests = 1
for test in range(num_tests):
	n = int(input())
	solve(n)


def pro(a):
	ret = 1
	for x in a:
		ret *= x
	return ret
n = int(input())
a = [0] * 10
while 1:
	for i in range(10):
		if pro(a) >= n:
			break
		a[i] += 1
	if pro(a) >= n:
		break
ans = a[0] * 'c' + a[1] * 'o' + a[2] * 'd' + a[3] * 'e' + a[4] * 'f' + a[5] * 'o' + a[6] * 'r' + a[7] * 'c' + a[8] * 'e' + a[9] * 's'
print(ans)


from math import ceil

def problem1():
	(a, b, n) = list(map(int, input().split()))
	if a < b:
		a = a + b
		b = a - b
		a = a - b
	c = 0
	while a <= n:
		a = a + b
		b = a - b
		c += 1
	print(c)

def problem2():
	l = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
	k = int(input())
	a = ceil(k ** 0.1)
	s = ''
	if a ** 10 == k:
		for i in l:
			s += i * a
	else:
		c = 0
		a -= 1
		b = a ** 10
		while b < k:
			b = (a + 1) * b // a
			c += 1
		for i in range(c):
			s += l[i] * (a + 1)
		for i in range(c, 10):
			s += l[i] * a
	print(s)
problem2()


k = int(input())
ten_root = int(pow(k, 0.1))
a = 10
while a > 0 and pow(ten_root, a) * pow(ten_root + 1, 10 - a) < k:
	a -= 1
word_vec = 'codeforces'
out_vec = []
for w in word_vec[:a]:
	out_vec.append(w * ten_root)
for w in word_vec[a:]:
	out_vec.append(w * (ten_root + 1))
print(''.join(out_vec))


import os
import sys
from io import BytesIO, IOBase

def main():
	s = 'codeforces'
	n = int(input())
	ct = [0] * len(s)

	def pro():
		c = 1
		for x in ct:
			c *= x
		return c
	while pro() < n:
		mn = min(ct)
		for i in range(len(ct)):
			if ct[i] == mn:
				ct[i] += 1
				break
	print(''.join((s[i] * ct[i] for i in range(len(s)))))
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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')
main()


k = int(input())
a = k ** 0.1
b = int(a)
ans = [['c'] * b, ['o'] * b, ['d'] * b, ['e'] * b, ['f'] * b, ['o'] * b, ['r'] * b, ['c'] * b, ['e'] * b, ['s'] * b]
x = b ** 10
c = 0
while x < k:
	x /= b
	x *= b + 1
	ans[c] += ans[c][0]
	c += 1
for i in ans:
	print(''.join(i), end='')


n = int(input())
(ss, x) = (1, 0)
ans = [1] * 10
while ss < n:
	ans[x] += 1
	ss = 1
	x = (x + 1) % 10
	for i in range(10):
		ss *= ans[i]
hh = [i for i in 'codeforces']
for i in range(10):
	print(hh[i] * ans[i], end='')


(z, zz) = (input, lambda : list(map(int, z().split())))
zzz = lambda : [int(i) for i in stdin.readline().split()]
(szz, graph, mod, szzz) = (lambda : sorted(zz()), {}, 10 ** 9 + 7, lambda : sorted(zzz()))
from string import *
from re import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0 and x != 2 or x == 0:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = True
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)
n = int(z())
l = 'codeforces'
cnt = [1 for _ in l]
total = 1
i = 0
while total < n:
	total /= cnt[i]
	cnt[i] += 1
	total *= cnt[i]
	i = (i + 1) % 10
print(''.join([l[i] * cnt[i] for i in range(10)]))


import sys
import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

def checker(ind, ans, tar):
	prod = 1
	for i in ans:
		prod *= i
	if prod < tar:
		ans[ind] += 1
	return (ans, prod)
t = int(input())
count = 0
ans = [1] * 10
for i in range(t):
	if t >= (count + 1) ** 10:
		count += 1
	else:
		ans = [count] * 10
		break
produ = 1
ind = 0
while produ < t:
	(ans, produ) = checker(ind, ans, t)
	ind += 1
stri = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
for i in range(10):
	ans[i] = stri[i] * ans[i]
for i in ans:
	sys.stdout.write(i)


import sys
import math
from decimal import *

def I():
	return int(sys.stdin.readline())

def IL():
	return list(map(int, sys.stdin.readline().strip().split()))

def ILS():
	return list(map(str, sys.stdin.readline().strip().split()))

def solve():
	s = 'codeforces'
	k = I()
	i = 1
	while True:
		cnt = pow(i, 10)
		if cnt < k:
			i += 1
		else:
			break
	if i > 1:
		i -= 1
	cnt = pow(i, 10)
	pp = 0
	for iii in range(10):
		if cnt >= k:
			break
		else:
			cnt = cnt // i
			cnt = cnt * (i + 1)
			pp += 1
	for ii in range(10):
		if ii < pp:
			for j in range(i + 1):
				print(s[ii], end='')
		else:
			for j in range(i):
				print(s[ii], end='')
solve()


def prod(l):
	ans = 1
	for i in l:
		ans *= i
	return ans
n = int(input())
ans = 1
while ans ** 10 < n:
	ans += 1
l = 10 * [ans]
index = 0
while prod(l) > n:
	l[index % 10] -= 1
	index += 1
if prod(l) < n:
	l[index % 10 - 1] += 1
string = 'codeforces'
ans = ''
for i in range(10):
	ans += l[i] * string[i]
print(ans)


k = int(input())
s = 'codeforces'
freq = [1] * 10
product = 1
i = 0
while product < k:
	freq[i] += 1
	product = 1
	for e in freq:
		product *= e
	i += 1
	i = i % 10
for i in range(10):
	for j in range(freq[i]):
		print(s[i], end='')


import math
k = int(input())
out = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
ps = [1] * 10

def prod(a):
	h = 1
	for i in a:
		h *= i
	return h
d = False
while True:
	for i in range(10):
		if prod(ps) >= k:
			d = True
			break
		ps[i] += 1
	if d:
		break
ret = ''
for i in range(10):
	ret += out[i] * ps[i]
print(ret)


from sys import stdin
input = stdin.readline
s = 'codeforces'
k = int(input())
l = 1
p = 1
while p ** l < k:
	l += 1
	if l == 11:
		l = 1
		p += 1
t = p - 1
t1 = 0
temp = t ** 10
while temp < k and t:
	temp //= t
	temp *= p
	t1 += 1
ans = ''
for i in s:
	if t1:
		ans += i * (t + 1)
		t1 -= 1
	else:
		ans += i * t
if k == 1:
	print(s)
else:
	print(ans)


from math import ceil, pow
n = int(input())
x = ceil(round(pow(n, 0.1) * 10, 4))
s = 'codeforces'
z = x // 10
p = 1
for i in range(10):
	if i < x % 10:
		print(s[i] * (z + 1), end='')
		p *= z + 1
	else:
		print(s[i] * z, end='')
		p *= z
if p < n:
	print('s')


n = int(input())
str = 'codeforces'
ans = ''
freq = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
count = 1
i = 0
while count < n:
	count = count // freq[i]
	freq[i] += 1
	count *= freq[i]
	i = (i + 1) % 10
for i in range(10):
	ans += str[i] * freq[i]
print(ans)


k = int(input())
L = 10 * [1]
prod = 1
index = 0
while prod < k:
	prod /= L[index]
	L[index] += 1
	prod *= L[index]
	index = (index + 1) % 10
S = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
for i in range(len(L)):
	print(L[i] * S[i], sep='', end='')


import sys
input = sys.stdin.readline
RI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]
rw = lambda : input().strip().split()
from collections import defaultdict as df
pre = []
for i in range(500):
	a = [1] * 10
	j = 0
	index = 0
	while j < i:
		a[index] += 1
		j += 1
		index = (index + 1) % 10
	temp = 1
	for j in range(10):
		temp *= a[j]
	pre.append(temp)
start = 0
end = 499
target = int(input())
while start <= end:
	mid = (start + end) // 2
	if pre[mid] < target:
		start = mid + 1
	else:
		end = mid - 1
use = end + 1
a = [1] * 10
j = 0
index = 0
while j < use:
	a[index] += 1
	j += 1
	index = (index + 1) % 10
s = 'codeforces'
for i in range(10):
	print(s[i] * a[i], end='')


import math
k = int(input())
if k == 0:
	print('codeforces')
else:
	count = 0
	prev_base = 0
	base = 2
	total = 1
	while total < k:
		count += 1
		if prev_base > 0:
			total *= base
			total //= prev_base
		else:
			total *= base
		index = count % 10
		if index == 0:
			prev_base = base
			base += 1
	A = [1 + count // 10] * 10
	for i in range(count % 10):
		A[i] += 1
	ans = ''
	code = 'codeforces'
	for i in range(len(A)):
		ans += code[i] * A[i]
	print(ans)


n = int(input())
string = 'codeforces'
arr = [1] * 10
idx = 0
count = 1
while count < n:
	arr[idx] += 1
	count = 1
	idx = (idx + 1) % 10
	for i in range(10):
		count *= arr[i]
for i in range(10):
	for j in range(arr[i]):
		print(string[i], end='')


k = int(input())
pdt = int(1)
multiplier = int(2)
a = []
for i in range(10):
	a.append(1)
while pdt < k:
	for i in range(1, 11):
		if pdt >= k:
			break
		pdt /= a[i - 1]
		pdt *= multiplier
		a[i - 1] = multiplier
	multiplier += 1
str = 'codeforces'
s = ''
i = int(0)
for x in a:
	s = s + str[i] * x
	i += 1
print(s)


k = int(input())
p = 1
a = 0
x = 0
while True:
	for x in range(1, 11):
		a = p ** x * (p - 1) ** (10 - x)
		if a >= k:
			break
	if a >= k:
		break
	p += 1
s = 'codeforces'
new_s = ''
for i in range(len(s)):
	if i < x:
		new_s += p * s[i]
	else:
		new_s += (p - 1) * s[i]
if k == 1:
	print(s)
else:
	print(new_s)


import sys
input = sys.stdin.readline
k = int(input())
S = 'codeforces'
ANS = [1] * 10
NOW = 1
ind = 0
while NOW < k:
	ANS[ind] += 1
	NOW = NOW * ANS[ind] // (ANS[ind] - 1)
	ind = (ind + 1) % 10
for i in range(10):
	print(S[i] * ANS[i], end='')
print()


import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
import sys

def main():
	k = int(input())
	s = list('codeforces')
	if k == 1:
		Ans = s
	else:
		for c in range(2, 51):
			if pow(c, 10) >= k:
				break
		for p in range(1, 11):
			if pow(c, p) * pow(c - 1, 10 - p) >= k:
				break
		Ans = []
		for i in range(p):
			Ans.append(s[i] * c)
		for i in range(p, 10):
			Ans.append(s[i] * (c - 1))
	sys.stdout.write(''.join(Ans) + '\n')
main()


def mult(s):
	b = 1
	for i in s:
		b *= i
	return b
a = [1] * 10
k = int(input())
while mult(a) < k:
	a[-1] += 1
	a.sort(reverse=True)
string = 'codeforces'
print(''.join([string[i] * a[i] for i in range(10)]))


from fractions import Fraction
import bisect
import os
import io
from collections import Counter
import bisect
from collections import defaultdict
import math
import random
import heapq as hq
from math import sqrt
import sys
from functools import reduce, cmp_to_key
from collections import deque
import threading
from itertools import combinations
from io import BytesIO, IOBase
from itertools import accumulate
from queue import Queue

def input():
	return sys.stdin.readline().strip()

def iinput():
	return int(input())

def tinput():
	return input().split()

def rinput():
	return map(int, tinput())

def rlinput():
	return list(rinput())
mod = int(1000000000.0) + 7

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))

def primeFactors(n):
	val = []
	while n % 2 == 0:
		val.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			val.append(i)
			n = n / i
	if n > 2:
		val.append(n)
	return val
t = 1
t = iinput()
ans = [0] * 10
n = t
mul = 1
ans = [1] * 10
mul = 1
for j in range(2, n):
	for i in range(10):
		val = mul // (j - 1) * j
		ans[i] = j
		mul = val
		if n <= val:
			temp = 'codeforces'
			fans = ''
			for k in range(10):
				fans += temp[k] * ans[k]
			print(fans)
			sys.exit()
if n == 2:
	ans[0] = 2
temp = 'codeforces'
fans = ''
for k in range(10):
	fans += temp[k] * ans[k]
print(fans)


k = int(input())
p = 1
for i in range(2, 41):
	if i ** 10 > k:
		p = i
		break
if p != 1:
	p += -1
tmp = p ** 10
s = 'codeforces'
for i in range(10):
	if tmp >= k:
		print(s[i] * p, end='')
	else:
		print(s[i] * (p + 1), end='')
		tmp = tmp // p * (p + 1)


from math import prod
from typing import List

def calc_score(array: List[int]) -> int:
	return prod(array)
goal = int(input())
string = 'codeforces'
counts = [1] * 10
while calc_score(counts) < goal:
	best_score = 0
	for pos in range(10):
		counts_copy = counts.copy()
		counts_copy[pos] += 1
		trial = prod(counts_copy)
		if trial > best_score:
			best_score = trial
			best_copy = counts_copy
	counts = best_copy
ans = ''.join([s * x for (s, x) in zip(string, counts)])
print(ans)


import sys
k = int(sys.stdin.readline().strip())
i = 1
while i ** 10 < k:
	i = i + 1
j = 1
while i ** j * (i - 1) ** (10 - j) < k:
	j = j + 1
w = 'codeforces'
ans = ''
for h in range(0, 10):
	if h < j:
		ans = ans + w[h] * i
	else:
		ans = ans + w[h] * (i - 1)
print(ans)


test_case = int(input())
my_char = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
my_int = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
i = 0
while i < 10:
	total = 1
	for j in range(len(my_int)):
		total = total * my_int[j]
	if total < test_case:
		my_int[i] = my_int[i] + 1
		if i == 9:
			i = 0
		else:
			i += 1
	else:
		break
arr = []
for i in range(10):
	for j in range(my_int[i]):
		arr += my_char[i]
print(''.join(arr))


k = int(input())
s = 'codeforces'
count = [1 for i in range(len(s))]
total = 1
i = 0
while total < k:
	total /= count[i]
	count[i] += 1
	total *= count[i]
	i = (i + 1) % len(s)
print(''.join([s[i] * count[i] for i in range(len(s))]))


import sys
INF = 10 ** 20
MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
from math import gcd
from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br

def count(times):
	ans = 1
	for i in times:
		ans *= i
	return ans
(k,) = I()
ok = 'codeforces'
times = [1] * 10
idx = 0
while count(times) < k:
	times[idx] += 1
	idx += 1
	idx %= 10
for i in range(10):
	print(times[i] * ok[i], end='')
print()


n = int(input())
x = 1
s = 'codeforces'
if n == 1:
	print(s)
else:
	while x ** 10 < n:
		x += 1
	c = x ** 9 * (x - 1)
	a = 0
	while c >= n:
		a += 1
		c = c // x * (x - 1)
	t = ''
	for i in range(a):
		t += s[i] * (x - 1)
	for i in range(a, 10):
		t += s[i] * x
	print(t)


k = int(input())

def dot(arr):
	r = 1
	for i in arr:
		r *= i
	return r
s = [1 for x in range(10)]
t = 'codeforces'
mul = 1
i = 0
while mul < k:
	s[i] += 1
	i += 1
	i = i % 10
	mul = dot(s)
for i in range(10):
	print(s[i] * t[i], end='')


import sys
input = sys.stdin.readline

def solve():
	n = int(input())
	s = 'codeforces'
	l = len(s)
	arr = [1] * l

	def prod(a):
		p = 1
		for el in a:
			p *= el
		return p
	m = 0
	while prod(arr) < n:
		arr[m] += 1
		m = (m + 1) % l
	ans = ''
	for i in range(l):
		ans += s[i] * arr[i]
	print(ans)
tt = 1
for test in range(tt):
	solve()


import sys
from functools import reduce
cont = sys.stdin.readlines()
n = int(cont[0].strip('\n'))
count = [1] * 10
while reduce(lambda x, y: x * y, count) < n:
	count[count.index(min(count))] += 1
ret = ''
key = 'codeforces'
for i in range(10):
	ret += key[i] * count[i]
print(ret)


n = int(input())
s = ''
string = 'codeforces'
l = 10
r = 1
for c in string:
	ll = 1
	while r * ll ** l < n:
		ll += 1
	r *= ll
	l -= 1
	s += c * ll
print(s)


n = int(input())
s = 'codeforces'
a = [1] * 10
ans = 0
count = 1
i = 0
while count < n:
	a[i] += 1
	i = (i + 1) % 10
	count = 1
	for j in range(0, 10):
		count = count * a[j]
for i in range(10):
	for j in range(a[i]):
		print(s[i], end='')


k = int(input())
c = 0
for i in range(1, 100):
	if i ** 10 <= k and (i + 1) ** 10 > k:
		c = i
		break
for i in range(11):
	if (c + 1) ** i * c ** (10 - i) >= k:
		l = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
		s = ''
		for j in range(i):
			s += l[j] * (c + 1)
		for j in range(i, 10):
			s += l[j] * c
		print(s)
		break


from collections import deque
rr = lambda : input()
rri = lambda : int(input())
rrm = lambda : list(map(int, input().split()))
INF = float('inf')

def calc(ans):
	amt = 0
	prev = 1
	for i in range(len(ans) - 1, -1, -1):
		prev *= ans[i]
	return prev

def solve(k):
	amt = 1
	chars = list('codeforces')
	ans = [1 for _ in range(len(chars))]
	idx = len(chars) - 1
	while calc(ans) < k:
		ans[idx] += 1
		if idx == -1:
			idx = len(chars) - 1
		idx -= 1
	ret = []
	for (i, n) in enumerate(ans):
		ret.append(chars[i] * n)
	return ''.join(ret)
k = rri()
print(solve(k))


import math

def summ(ans):
	a = 1
	for i in ans:
		a *= i
	return a
k = int(input())
ans = [int(pow(k, 0.1))] * 10
i = 0
while k > summ(ans):
	ans[i % 10] += 1
	i += 1
cf = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
for i in range(10):
	print(cf[i] * ans[i], end='')


import sys
import math
import heapq
import collections

def inputnum():
	return int(input())

def inputnums():
	return map(int, input().split())

def inputlist():
	return list(map(int, input().split()))

def inputstring():
	return [x for x in input()]

def inputmatrixchar(rows):
	arr2d = [[j for j in input().strip()] for i in range(rows)]
	return arr2d

def inputmatrixint(rows):
	arr2d = []
	for _ in range(rows):
		arr2d.append([int(i) for i in input().split()])
	return arr2d
k = inputnum()
s = 'codeforces'
a = 0
for i in range(1, 100):
	if pow(i, 10) >= k:
		a = i
		break
ind = 0
for i in range(1, 11):
	if pow(a, i) * pow(a - 1, 10 - i) >= k:
		ind = i
		break
rtn = ''
if ind == 10:
	for i in range(10):
		for j in range(a):
			rtn += s[i]
else:
	for i in range(ind):
		for j in range(a):
			rtn += s[i]
	for i in range(ind, 10):
		for j in range(a - 1):
			rtn += s[i]
print(rtn)


n = int(input())
arr = [1] * 10
cnt = 1
ind = 0
while cnt < n:
	cnt //= arr[ind % 10]
	arr[ind % 10] += 1
	cnt *= arr[ind % 10]
	ind += 1
s = 'codeforces'
for i in range(10):
	print(s[i] * arr[i], end='')


n = int(input())
a = [1 for i in range(10)]
p = 1
while p < n:
	for i in range(10):
		if p >= n:
			break
		p /= a[i]
		a[i] += 1
		p = p * a[i]
array = list('codeforces')
str1 = ''
for i in range(10):
	for j in range(a[i]):
		str1 += array[i]
print(str1)


k = int(input())
s = 'codeforces'
val = []
for i in range(0, 10):
	val.append(1)
product = 1
while product < k:
	for r in range(0, 10):
		val[r] += 1
		product = product / (val[r] - 1)
		product = product * val[r]
		if product >= k:
			break
l = list(s)
for i in range(0, 10):
	l[i] = l[i] * val[i]
	print(''.join(l[i]), end='')


k = int(input())
s = 'codeforces'
count = 0
for i in range(1, 41):
	if pow(i - 1, 10) <= k <= pow(i, 10):
		count = i
		break
check = 0
for j in range(1, 11):
	if k <= pow(count, j) * pow(count - 1, 10 - j):
		check = j
		break
ans = ''
for i in range(check):
	t = s[i] * count
	ans += t
for i in range(check, len(s)):
	ans += s[i] * (count - 1)
print(ans)


arr = [1 for i in range(10)]
k = int(input())

def product(list):
	ans = 1
	for i in list:
		ans *= i
	return ans
for i in range(10):
	while product(arr) < k:
		arr[i] += 1
		if i < 9:
			i += 1
		else:
			i = 0
		if product(arr) >= k:
			break
vals = {0: 'c', 1: 'o', 2: 'd', 3: 'e', 4: 'f', 5: 'o', 6: 'r', 7: 'c', 8: 'e', 9: 's'}
ar = []
for i in range(10):
	ar += [vals[i] for j in range(arr[i])]
ans = ''
for i in ar:
	ans += i
print(ans)


k = int(input())
v = int(k ** 0.1)
r = [v] * 10
n = v ** 10
j = 0
while n < k:
	r[j] = r[j] + 1
	n = n // v * r[j]
	j = j + 1
s = 'codeforces'
j = 0
res = ''
for v in s:
	res = res + v * r[j]
	j = j + 1
print(res)


k = int(input())
for i in range(41):
	if i ** 10 >= k:
		break
for j in range(11):
	if i ** j * (i - 1) ** (10 - j) >= k:
		break
s = ''
for (idx, c) in enumerate('codeforces'[::-1]):
	if idx < j:
		s += c * i
	else:
		s += c * (i - 1)
print(s[::-1])


k = int(input())
s = 'codeforces'
val = []
for i in range(len(s)):
	val.append(1)
prod = 1
while prod < k:
	for i in range(len(s)):
		val[i] += 1
		prod = prod / (val[i] - 1)
		prod = prod * val[i]
		if prod >= k:
			break
for i in range(len(s)):
	while val[i] > 0:
		print(s[i], end='')
		val[i] -= 1


from sys import stdin
input = lambda : stdin.readline().strip()
from math import ceil, sqrt, factorial, gcd
n = int(input())
t = int(pow(n, 1 / 10))
a = pow(t, 10)
s = 'codeforces'
l = [t for i in range(10)]
for i in range(10):
	if a < n:
		a = a // l[i]
		a = a * (l[i] + 1)
		l[i] = l[i] + 1
	print(s[i] * l[i], end='')


from functools import reduce
T = int(input())
string = 'codeforces'
newstring = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
nnstring = [1 for i in range(10)]
codestring = ''
counter = 1
while counter < T:
	for i in range(10):
		if counter < T:
			nnstring[i] += 1
		else:
			break
		counter = reduce(lambda x, y: x * y, nnstring)
for i in range(10):
	for j in range(nnstring[i]):
		codestring += newstring[i]
print(codestring)


from sys import stdin, stdout
import math, sys
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict
from os import path
import bisect as bi
import heapq

def yes():
	print('YES')

def no():
	print('NO')
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

	def I():
		return int(input())

	def In():
		return map(int, input().split())
else:

	def I():
		return int(stdin.readline())

	def In():
		return map(int, stdin.readline().split())

def printDivisors(n):
	i = 1
	ans = []
	while i <= math.sqrt(n):
		if n % i == 0:
			if n / i == i:
				ans.append(i)
			else:
				ans.append(i)
				ans.append(n // i)
		i = i + 1
	return ans

def main():
	try:
		n = I()
		a = 0
		while a ** 10 <= n:
			a += 1
		for i in range(1, 10):
			if a ** i * (a - 1) ** (10 - i) >= n:
				break
		l = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
		p = 0
		count = 1
		cnt = [1] * 10
		while count < n:
			count = count // cnt[i] * (cnt[i] + 1)
			cnt[i] += 1
			i = (i + 1) % 10
		ans = []
		for i in range(10):
			for j in range(cnt[i]):
				ans.append(l[i])
		print(''.join(ans))
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(1):
	main()


t = int(input())
a = [1, 1024, 59049, 1048576, 9765625, 60466176, 282475249, 1073741824, 3486784401, 10000000000, 25937424601, 61917364224, 137858491849, 289254654976, 576650390625, 1099511627776, 2015993900449, 3570467226624, 6131066257801, 10240000000000, 16679880978201, 26559922791424, 41426511213649, 63403380965376, 95367431640625, 141167095653376, 205891132094649, 296196766695424, 420707233300201, 590490000000000, 819628286980801, 1125899906842624, 1531578985264449, 2064377754059776, 2758547353515625, 3656158440062976, 4808584372417849, 6278211847988224, 8140406085191601, 10485760000000000]
k = len(a)
for i in range(k):
	if t <= a[i]:
		break
temp = a[i]
count = 0
flag = False
while temp >= t:
	temp = temp * (i / (i + 1))
	count += 1
	flag = True
if flag:
	count -= 1
a = 'codeforces'
ans = ''
for j in range(count):
	for l in range(i):
		ans += a[j]
for j in range(count, 10):
	for l in range(i + 1):
		ans += a[j]
print(ans)


t = int(input())
st = 'codeforces'
yado = []
for i in range(10):
	yado.append(1)

def achar(yado):
	vals = 1
	for i in range(10):
		vals *= yado[i]
	return vals
d = ''
shuks = 0
while achar(yado) < t:
	yado[shuks] += 1
	shuks += 1
	shuks = shuks % 10
for i in range(10):
	d += st[i] * yado[i]
print(d)


import os
from sys import stdin
import math

def solve(tc):
	k = int(stdin.readline().strip())
	cnts = [1 for i in range(10)]
	p = 0
	base = 1
	while base < k:
		base += base // cnts[p]
		cnts[p] += 1
		p += 1
		p %= 10
	seq = 'codeforces'
	ans = ''
	for i in range(len(seq)):
		ans += seq[i] * cnts[i]
	print(ans)
tcs = 1
tc = 1
while tc <= tcs:
	solve(tc)
	tc += 1


n = int(input())
x = 1
while x ** 10 <= n:
	x += 1
x -= 1
prod = x ** 10
y = 0
while prod < n:
	y += 1
	prod = prod // x * (x + 1)
a = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
i = 0
ans = ''
while i < y:
	ans += a[i] * (x + 1)
	i += 1
while i < 10:
	ans += a[i] * x
	i += 1
print(ans)


k = int(input())
s = list('codeforces')
ss = s[:]
a = 0
c = 0
b = 1
j = 0
if k == 1:
	print(''.join(s))
else:
	for i in range(1, 40):
		for j in range(10, -1, -1):
			if i ** j * (i + 1) ** (10 - j) >= k:
				a = j
				c = i
				break
		else:
			continue
		break
	m = 1
	n = 10 - a
	while c - 1 > 0:
		b += 1
		for i in range(10):
			if i == 0:
				s.insert(i, ss[i])
			else:
				j = i * b
				s.insert(j, ss[i])
		c -= 1
	while m > 0:
		b += 1
		for i in range(n):
			if i == 0:
				s.insert(i, ss[i])
			else:
				j = i * b
				s.insert(j, ss[i])
		m -= 1
	print(''.join(s))


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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')

def fact(x):
	if x == 0:
		return 1
	else:
		return x * fact(x - 1)

def lower_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] >= num:
			answer = middle
			end = middle - 1
		else:
			start = middle + 1
	return answer

def upper_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] <= num:
			answer = middle
			start = middle + 1
		else:
			end = middle - 1
	return answer

def abs(x):
	return x if x >= 0 else -x

def binary_search(li, val, lb, ub):
	ans = 0
	while lb <= ub:
		mid = (lb + ub) // 2
		if li[mid] > val:
			ub = mid - 1
		elif val > li[mid]:
			lb = mid + 1
		else:
			ans = 1
			break
	return ans

def sieve_of_eratosthenes(n):
	ans = []
	arr = [1] * (n + 1)
	(arr[0], arr[1], i) = (0, 0, 2)
	while i * i <= n:
		if arr[i] == 1:
			j = i + i
			while j <= n:
				arr[j] = 0
				j += i
		i += 1
	for k in range(n):
		if arr[k] == 1:
			ans.append(k)
	return ans

def nc2(x):
	if x == 1:
		return 0
	else:
		return x * (x - 1) // 2
from math import *
for _ in range(1):
	n = int(input())
	li = list('codeforces')
	a = int(n ** (1 / 10))
	b = a ** 10
	for i in li:
		c = max(1, a)
		if b < n:
			b //= c
			b *= c + 1
			c += 1
		print(i * c, end='')
	print()


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def instr():
	return str(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
from collections import Counter

def main():
	k = inp()
	letters = [1] * 10
	prod = 1
	while prod < k:
		for (i, l) in enumerate(letters):
			prod /= letters[i]
			letters[i] += 1
			prod *= letters[i]
			if prod >= k:
				break
	s = 'codeforces'
	res = ''
	for (letter, count) in zip(s, letters):
		for i in range(count):
			res += letter
	print(res)
main()


def combinations(s):
	c = 1
	for i in s:
		c *= i
	return c

def process(k, counts):
	while combinations(counts) < k:
		for i in range(len(counts)):
			if combinations(counts) >= k:
				break
			counts[i] += 1
	return counts

def answer(counts, s):
	ans = ''
	for i in range(len(counts)):
		ans += counts[i] * s[i]
	return ans
k = int(input())
s = 'codeforces'
counts = [1] * len(s)
counts = process(k, counts)
ans = answer(counts, s)
print(ans)


n = int(input())
d = [['c', 1], ['o', 1], ['d', 1], ['e', 1], ['f', 1], ['o', 1], ['r', 1], ['c', 1], ['e', 1], ['s', 1]]
mul = 1
if n == 1:
	print('codeforces')
else:
	i = 0
	while mul < n:
		d[i][1] += 1
		for j in range(10):
			mul *= d[j][1]
		if mul >= n:
			break
		else:
			mul = 1
		i += 1
		if i == 10:
			i = 0
	for k in range(10):
		x = d[k][1]
		for i in range(x):
			print(d[k][0], sep='', end='')


import sys

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 19
MOD = 10 ** 9 + 7

def check(A):
	res = 1
	for a in A:
		res *= a
	return res >= K
K = INT()
A = [1] * 10
done = check(A)
while not done:
	for i in range(10):
		A[i] += 1
		if check(A):
			done = True
			break
S = 'codeforces'
ans = ''
for i in range(10):
	ans += S[i] * A[i]
print(ans)


import sys
from bisect import bisect_left
from collections import defaultdict
input = lambda : sys.stdin.readline().rstrip()
R = lambda : map(int, input().split())

def readint():
	return [int(w) for w in input.split()]
for _ in range(1):
	s = 'codeforces'
	n = len(s)
	k = int(input())
	l = 1
	r = 100
	m = 50
	while l + 1 < r:
		m = (l + r) // 2
		if pow(m - 1, n) >= k:
			r = m
		else:
			l = m
	lll = l
	l = 0
	r = n + 3
	while l + 1 < r:
		m = (l + r) // 2
		if pow(lll, m - 1) * pow(lll - 1, n - m + 1) >= k:
			r = m
		else:
			l = m
	howmuch = l
	for i in range(howmuch):
		sys.stdout.write(s[i] * lll)
	for i in range(howmuch, n):
		sys.stdout.write(s[i] * (lll - 1))
	print()


n = int(input())
curr = 1
s = 'codeforces'
l = len(s)
count = 1
temp = 0
d = dict()
d2 = dict()
for i in range(len(s)):
	d[i] = s[i]
	d2[i] = 1
while curr < n:
	curr = curr // d2[temp]
	d2[temp] += 1
	curr = curr * d2[temp]
	d[temp] += s[temp]
	temp += 1
	if temp == l:
		temp = 0
out = ''
for i in range(l):
	out += d[i]
print(out)


n = int(input())
a = [1] * 10
ans = 1
s = 'codeforces'
i = 0
while ans < n:
	ans = ans // a[i] * (a[i] + 1)
	a[i] += 1
	i = (i + 1) % 10
final_ans = ''
for i in range(10):
	temp = s[i] * a[i]
	final_ans += temp
print(final_ans)


import sys

def main():
	k = int(sys.stdin.readline().strip())
	count = 1
	mult = 2
	step = 0
	while count < k:
		count //= mult - 1
		count *= mult
		step += 1
		if step == 10:
			mult += 1
			step = 0
	arr = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
	for i in range(step):
		for j in range(mult):
			print(arr[i], end='')
	for i in range(step, 10):
		for j in range(mult - 1):
			print(arr[i], end='')
	print()
main()


s = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
liste = [['c'], ['o'], ['d'], ['e'], ['f'], ['o'], ['r'], ['c'], ['e'], ['s']]
r = 1
nb = int(input())
jim = True
liste3 = []
n = 0
pp = 0
while r < nb:
	liste[n].append(s[n])
	for loop in range(len(liste)):
		r *= len(liste[loop])
	if r >= nb:
		break
	n += 1
	r = 1
	if n == 10:
		n = 0
for loop in range(len(liste)):
	for i in range(len(liste[loop])):
		liste3.append(liste[loop][i])
print(''.join(liste3))


def pr(L):
	p = 1
	for i in range(10):
		p *= L[i]
	return p
k = int(input())
L = [int(k ** 0.1)] * 10
for i in range(10):
	if pr(L) >= k:
		break
	L[i] += 1
s = 'codeforces'
s2 = ''
for i in range(10):
	s2 += s[i] * L[i]
print(s2)


n = int(input())
a = [1] * 10
product = 1
ind = 0
while product < n:
	a[ind] += 1
	ind = (ind + 1) % 10
	product = 1
	for j in a:
		product = product * j
strin = 'codeforces'
for j in range(10):
	print(strin[j] * a[j], end='')


k = int(input())
x = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

def pr(x):
	ret = 1
	for i in x:
		ret *= i
	return ret
for i in range(500):
	if pr(x) < k:
		x[i % 10] += 1
s = 'codeforces'
for i in range(10):
	print(s[i] * x[i], end='')
print()


N = int(input())
s = 'codeforces'
l = [1] * 10
k = 1

def getMinIndex():
	return l.index(min(l))
while k < N:
	miIndex = getMinIndex()
	val = l[miIndex]
	l[miIndex] += 1
	k = int(k / val)
	k *= l[miIndex]
out = ''
for i in range(len(s)):
	out += s[i] * l[i]
print(out)


from sys import stdin

def prod(lst):
	x = 1
	for i in lst:
		x *= i
	return x
k = int(stdin.readline())
lst = [1] * 10
i = 0
while prod(lst) < k:
	lst[i % 10] += 1
	i += 1
x = 'codeforces'
y = ''
for i in range(len(x)):
	y += x[i] * lst[i]
print(y)


n = int(input())
x = [1] * 10
ind = 0
pdt = 1
while True:
	if pdt >= n:
		break
	pdt = pdt * (x[ind] + 1) // x[ind]
	x[ind] += 1
	ind = (ind + 1) % 10
codeforces = list('codeforces')
for i in range(10):
	print(codeforces[i] * x[i], end='')


y = int(input())
m = [1] * 10
c = 'codeforces'
s = ''
z = 1
i = 0
while z < y:
	z = z / m[i]
	m[i] += 1
	z = z * m[i]
	if i < 9:
		i += 1
	else:
		i = 0
for i in range(10):
	s = s + c[i] * m[i]
print(s)


k = int(input())
s = 'codeforces'
lst = [1] * len(s)
(cnt, ind) = (1, 0)
while cnt < k:
	if ind == len(s):
		ind = 0
	lst[ind] += 1
	cnt = cnt / (lst[ind] - 1) * lst[ind]
	ind += 1
for i in range(len(s)):
	print(lst[i] * s[i], end='')


from sys import stdin, gettrace
from itertools import count
if gettrace():
	inputi = input
else:

	def input():
		return next(stdin)[:-1]

	def inputi():
		return stdin.buffer.readline()

def main():
	k = int(input())
	for i in count(1):
		if i ** 10 >= k:
			break
	for j in range(9, -1, -1):
		if (i - 1) ** j * i ** (10 - j) >= k:
			break
	res = []
	for l in range(j):
		c = 'codeforces'[l]
		res.append(c * (i - 1))
	for l in range(j, 10):
		c = 'codeforces'[l]
		res.append(c * i)
	print(''.join(res))
main()


(p, c, a) = (1, 'codeforces', [1] * 10)
n = int(input())
while p < n:
	for i in range(10):
		if p >= n:
			break
		a[i] += 1
		p = p // (a[i] - 1) * a[i]
for i in range(10):
	for j in range(a[i]):
		print(c[i], end='')


from sys import stdin
input = lambda : stdin.readline().strip()
char = [chr(i) for i in range(97, 123)]
CHAR = [chr(i) for i in range(65, 91)]
mp = lambda : list(map(int, input().split()))
INT = lambda : int(input())
rn = lambda : range(INT())
from math import ceil, sqrt, factorial, gcd, log
ans = 'codeforces'
n = INT()
h = int(pow(n, 1 / 10))
m = pow(h, 10)
k = [h for i in range(10)]
for i in range(10):
	if m < n:
		m //= k[i]
		m *= k[i] + 1
		k[i] = k[i] + 1
	else:
		break
res = ''
for j in range(10):
	if k[j] == 0:
		res += ans[j]
	else:
		res += ans[j] * k[j]
print(res)


import sys
import math

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_string():
	return sys.stdin.readline().strip()
t = int(input())
ans = 0
for i in range(1, 50):
	if i ** 10 <= t:
		ans = i
nox = 0
for i in range(11):
	temp = ans ** (10 - i) * (ans + 1) ** i
	if temp >= t:
		nox = i
		break
a = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
count = [ans for i in range(10)]
for i in range(nox):
	count[i] += 1
s = ''
for i in range(10):
	s += a[i] * count[i]
print(s)


from math import *
n = int(input())
s = 'codeforces'
if n == 1:
	print('codeforces')
else:
	c = 1
	for c in range(2, 41):
		f = 0
		for i in range(1, 11):
			x = pow(c, i) * (c - 1) ** (10 - i)
			if x >= n:
				f = 1
				z = i
				break
		if f == 1:
			break
	r = ''
	for j in range(z):
		r = r + s[j] * c
	for j in range(z, 10):
		r = r + s[j] * (c - 1)
	print(r)


from sys import stdout, stdin
(_input, _print) = (stdin.readline, stdout.write)
(_enumerate, _min, _range, _int) = (enumerate, min, range, int)

def solution():
	n = _int(_input())
	s = 'codeforces'
	arr = [1] * 10
	c = 1
	while c < n:
		for i in _range(0, 10):
			if c // arr[i] * (arr[i] + 1) >= n:
				c //= arr[i]
				c *= arr[i] + 1
				arr[i] += 1
				break
		else:
			l = _min(arr)
			t = arr.index(l)
			c //= arr[t]
			arr[t] += 1
			c *= arr[t]
	for (i, v) in _enumerate(arr):
		print(s[i] * v, end='')
	print()
solution()


import sys
input = sys.stdin.readline
k = int(input())
cnts = [1] * 10
pos = 0
prods = 1
while prods < k:
	prods //= cnts[pos % 10]
	cnts[pos % 10] += 1
	prods *= cnts[pos % 10]
	pos += 1
ans = ''
s = 'codeforces'
for i in range(10):
	ans += s[i] * cnts[i]
print(ans)


def product(list):
	p = 1
	for i in list:
		p *= i
	return p
from math import log
k = int(input())
numberlist = [1] * 10
i = 0
while product(numberlist) < k:
	numberlist[i] += 1
	if i == 9:
		i = 0
	else:
		i += 1
for i in range(0, 10):
	print('codeforces'[i] * numberlist[i], end='')


def calc_m3(k, a):
	(left, right) = (k, (a + 1) ** 10)
	for i in range(1, 12):
		left *= a + 1
		right *= a
		if left > right:
			return i - 1
	return -1
k = int(input())
base = 'codeforces'
a = int(k ** 0.1)
m = calc_m3(k, a)
for i in range(10 - m):
	print(base[i] * (a + 1), end='')
for i in range(10 - m, 10):
	print(base[i] * a, end='')


import sys
import math
from collections import *

def get_ints():
	return map(int, input().split())

def get_list():
	return list(get_ints())

def printspx(*args):
	return print(*args, end='')

def printsp(*args):
	return print(*args, end=' ')
UGLYMOD = int(1000000000.0 + 7)
SEXYMOD = 998244353
MAXN = int(100000.0)
n = int(input())
ans = [1] * 10
this = 1
i = 0
while this < n:
	i %= 10
	this //= ans[i]
	ans[i] += 1
	this *= ans[i]
	i += 1
s = 'codeforces'
for i in range(10):
	print(s[i] * ans[i], end='')
print()


for _ in range(1):
	k = int(input())
	mn = 1
	arr = [1] * 10
	p = 0
	while mn < k:
		mn /= arr[p]
		arr[p] += 1
		mn *= arr[p]
		p += 1
		if p == 10:
			p = 0
	s = list('codeforces')
	for i in range(10):
		print(s[i] * arr[i], end='')


n = int(input())
k = int(n ** 0.1)
s = k ** 10
cnt = 0
while s < n:
	s = s // k * (k + 1)
	cnt += 1
st = 'codeforces'
for i in st:
	for j in range(k):
		print(i, end='')
	if cnt > 0:
		print(i, end='')
		cnt -= 1


def prod(arr):
	pr = 1
	for i in arr:
		pr *= i
	return pr
n = int(input())
count = [1] * 10
word = 'codeforces'
ind = 0
while prod(count) < n:
	if ind == 9:
		count[ind] += 1
		ind = 0
	else:
		count[ind] += 1
		ind += 1
st = ''
for i in range(10):
	st += word[i] * count[i]
print(st)


import sys
import heapq
import random
import collections
import bisect

def solve(a):
	lst = []
	base = []
	for i in range(1, 40):
		for j in range(10):
			base.append((i, j))
			res = 1
			for k in range(10):
				if j > k:
					res *= i + 1
				else:
					res *= i
			lst.append(res)
	(a, b) = base[bisect.bisect_left(lst, a)]
	res = ''
	for (c, j) in zip('codeforces', range(10)):
		if j < b:
			res += c * (a + 1)
		else:
			res += c * a
	return res

def console(*args):
	print('\x1b[36m', *args, '\x1b[0m', file=sys.stderr)
k = int(input())
res = solve(k)
print(res)


k = int(input())
last = 0
for i in range(41):
	if i ** 10 > k:
		last = i - 1
		break
freq = [last] * 10
av = last ** 10
if av != k:
	for i in range(10):
		aa = av // freq[i]
		aa = aa * (freq[i] + 1)
		freq[i] += 1
		av = aa
		if av >= k:
			break
cc = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
ans = ''
for i in range(10):
	ans += cc[i] * freq[i]
print(ans)


from os import path
import sys
from functools import cmp_to_key as ctk
from collections import deque, defaultdict as dd
from bisect import bisect, bisect_left, bisect_right, insort, insort_left, insort_right
from itertools import permutations
from datetime import datetime
from math import ceil, sqrt, log, gcd

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def bo(i):
	return ord(i) - ord('a')

def solve():
	k = ii()
	s1 = 'codeforces'
	x = 2
	while 1:
		s = pow(x, 10)
		if k <= s:
			break
		x += 1
	x1 = pow(x - 1, 10)
	c = 0
	while x1 < k:
		x1 //= x - 1
		x1 *= x
		c += 1
	for i in range(c):
		print(s1[i] * x, end='')
	x -= 1
	for i in range(c, 10):
		print(s1[i] * x, end='')
solve()


def yeah_this_is_function_doing_smth_important(a):
	answ = 1
	for i in a:
		answ *= i
	return answ
k = int(input())
hello_my_friend_why_are_you_looking_at_my_code = [1 for i in range(10)]
answ = 1
index = 0
while answ < k:
	hello_my_friend_why_are_you_looking_at_my_code[index % 10] += 1
	answ = yeah_this_is_function_doing_smth_important(hello_my_friend_why_are_you_looking_at_my_code)
	index += 1
raw_string = 'codeforces'
string = ''.join([raw_string[i] * hello_my_friend_why_are_you_looking_at_my_code[i] for i in range(10)])
print(string)


from math import log2, ceil
k = int(input())
freq = [1] * 10
s = 'codeforces'
ans = ''
curr = 1
if k == curr:
	print(s)
else:
	while curr < k:
		for i in range(10):
			curr = curr // freq[i]
			freq[i] += 1
			curr *= freq[i]
			if curr >= k:
				break
	for i in range(10):
		ans += s[i] * freq[i]
	print(ans)


def main():
	from math import floor
	k = int(input())
	x = int(floor(k ** 0.1))
	a = [x] * 10
	p = x ** 10
	if p != k:
		while True:
			ok = 0
			for i in range(10):
				p = p // a[i] * (a[i] + 1)
				a[i] += 1
				if p >= k:
					ok = 1
					break
			if ok:
				break
	s = ''
	st = 'codeforces'
	for (idx, i) in enumerate(a):
		s += i * st[idx]
	print(s)
	return
main()


n = int(input())
l = [1 for _ in range(10)]
cur = 1
idx = 0
while cur < n:
	cur //= l[idx]
	l[idx] += 1
	cur *= l[idx]
	idx += 1
	if idx == 10:
		idx = 0
s = 'codeforces'
for (i, j) in enumerate(l):
	print(s[i] * j, end='')
else:
	print()


def compute(a, b, c, d):
	return a ** b * c ** d

def solve():
	k = int(input())
	[a, b, c, d] = [1, 10, 2, 0]
	while compute(a, b, c, d) < k:
		if b > 0:
			d += 1
			b -= 1
		else:
			(a, b, c, d) = (c, d, c + 1, 0)
	for l in 'codeforces':
		if b > 0:
			print(l * a, end='')
			b -= 1
		else:
			print(l * c, end='')
	return ''
print(solve())


k = int(input())
product = 1
lc = len('codeforces')
storage = [1] * lc
i = 0
while product < k:
	v = storage[i]
	storage[i] += 1
	product /= v
	product *= storage[i]
	i = (i + 1) % lc
o = ''
for (v, c) in zip(storage, 'codeforces'):
	o += v * c
print(o)


import math
k = int(input())
n = 1
for nn in range(1, 100):
	if pow(nn, 10) > k:
		n = nn - 1
		break
c = 0
for a in range(11):
	if pow(n, 10 - a) * pow(n + 1, a) >= k:
		c = a
		break
ans = ''
arr = 'codeforces'
for (i, v) in enumerate(arr):
	if i < c:
		ans += v * (n + 1)
	else:
		ans += v * n
print(ans)


k = int(input())
s = 'codeforces'
a = [1] * 10
pos = 0
while True:
	check = 1
	for i in range(10):
		check *= a[i]
	if check >= k:
		break
	else:
		a[pos] += 1
		if pos != 9:
			pos += 1
		else:
			pos = 0
ans = ''
for i in range(10):
	ans += s[i] * a[i]
print(ans)


n = int(input())
for i in range(10, 500):
	l1 = i // 10
	l2 = (i + 1) // 10
	l3 = (i + 2) // 10
	l4 = (i + 3) // 10
	l5 = (i + 4) // 10
	l6 = (i + 5) // 10
	l7 = (i + 6) // 10
	l8 = (i + 7) // 10
	l9 = (i + 8) // 10
	l10 = (i + 9) // 10
	if l1 * l2 * l3 * l4 * l5 * l6 * l7 * l8 * l9 * l10 >= n:
		break
print('c' * l1 + l2 * 'o' + l3 * 'd' + l4 * 'e' + l5 * 'f' + l6 * 'o' + l7 * 'r' + l8 * 'c' + l9 * 'e' + l10 * 's')


from math import floor
k = int(input())
f = [0] * 10
s = list('codeforces')
m = floor(k ** 0.1)
e = m
p = 1
for i in range(10):
	f[i] = e
	p *= e
i = 0
while p < k and i < 10:
	f[i] += 1
	p //= e
	p *= e + 1
	i += 1
ans = ''
for i in range(10):
	ans += s[i] * f[i]
print(ans)


k = int(input())
lst = [1 for i in range(10)]
s = 'codeforces'
prod = 1
m = 0
while prod < k:
	lst[m] += 1
	tmp_prod = 1
	for c in lst:
		tmp_prod *= c
	prod = tmp_prod
	m += 1
	m = m % 10
final_str = ''
for (i, c) in enumerate(lst):
	final_str += c * s[i]
print(final_str)


n = int(input())
ans = 'codeforces'
a = [1] * 10
k = 1
x = 0
while k < n:
	ok = a[x % 10]
	k = k // ok
	a[x % 10] += 1
	k *= a[x % 10]
	x += 1
out = ''
for i in range(10):
	for j in range(a[i]):
		out += ans[i]
print(out)


def findmul(arr):
	temp = 1
	for i in arr:
		temp *= i
	return temp
l = [40, 40, 40, 40, 40, 40, 40, 40, 40, 40]
k = int(input())
for i in range(40):
	for j in range(10):
		l[j] -= 1
		ans = findmul(l)
		if ans == k:
			break
		elif ans < k:
			l[j] += 1
			break
	else:
		continue
	break
res = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
result = ''
for i in range(10):
	result += res[i] * l[i]
print(result)


k = int(input())
ans = ''
if k == 0:
	print(ans)
else:
	codeforces = 'codeforces'
	limit = 1
	while limit ** 10 < k:
		limit += 1
	count = 1
	while limit ** count * (limit - 1) ** (10 - count) < k:
		count += 1
	for i in range(count):
		ans += codeforces[i] * limit
	for i in range(10 - count):
		ans += codeforces[i + count] * (limit - 1)
	print(ans)


from collections import *
from math import *
k = int(input())
ct = [1 for i in range(10)]
s = 'codeforces'
ans = ''
(p, ind) = (1, 0)
while p < k:
	p //= ct[ind]
	ct[ind] += 1
	p *= ct[ind]
	ind = (ind + 1) % 10
for i in range(10):
	ans += s[i] * ct[i]
print(ans)


n = int(input())
s1 = 'codeforces'
l = [1] * 10
s = 1
f = 1
while f and n != 1:
	for i in range(10):
		s = s // l[i]
		l[i] += 1
		s = s * l[i]
		if s >= n:
			f = 0
			break
ans = ''
for i in range(10):
	for j in range(l[i]):
		ans = ans + s1[i]
print(ans)


n = int(input())
a = [1] * 10
st = 'codeforces'
t = 1
s = 0
while t < n:
	t = 1
	a[s] += 1
	s = (s + 1) % 10
	for i in range(10):
		t *= a[i]
for i in range(10):
	for j in range(a[i]):
		print(st[i], end='')


k = int(input())
count = 1
s = 'codeforces'
a = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
while count < k:
	mi = min(a)
	if mi != max(a):
		i = a.index(mi)
		count = count // a[i]
		a[i] += 1
		count = count * a[i]
	else:
		count = count // a[0]
		a[0] += 1
		count = count * a[0]
for i in range(10):
	print(s[i] * a[i], end='')


s = int(input())
ans = ''
dels = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
alp = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
c = 1
i = 0
for j in range(0, 10):
	c *= dels[j]
while c < s:
	if i == 10:
		i = 0
	c //= dels[i]
	dels[i] += 1
	c *= dels[i]
	i += 1
for j in range(0, 10):
	ans = ans + alp[j] * dels[j]
print(ans)


k = int(input())
S = 'codeforces'
ANS = [1] * 10
NOW = 1
ind = 0
while NOW < k:
	ANS[ind] += 1
	NOW = NOW * ANS[ind] // (ANS[ind] - 1)
	ind = (ind + 1) % 10
for i in range(10):
	print(S[i] * ANS[i], end='')
print()


import io
import os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

def get_str():
	return input().decode().strip()

def rint():
	return map(int, input().split())

def oint():
	return int(input())
n = oint()
s = 'codeforces'
l = len(s)
r = 1
while r ** 10 < n:
	r += 1
if r ** 10 == n:
	print(''.join([s[i] * r for i in range(l)]))
	exit()
r -= 1
mul = r ** l
cnt = 0
while True:
	cnt += 1
	mul = mul * (r + 1) // r
	if mul >= n:
		break
ans = []
ans += [s[i] * (r + 1) for i in range(cnt)]
ans += [s[i] * r for i in range(cnt, l)]
print(''.join(ans))


import math
import sys
k = int(input())
s = 'codeforces'
opt = s * 100
for i in range(1, 100):
	for j in range(len(s) + 1):
		if pow(i, j) * pow(i + 1, len(s) - j) >= k:
			t = ''
			cnt = [i] * j + [i + 1] * (len(s) - j)
			for x in range(len(s)):
				t += s[x] * cnt[x]
			if len(opt) >= len(t):
				opt = t
print(opt)


from operator import mul

def isValid(arr, k):
	cnt = 1
	for i in arr:
		cnt *= i
	if cnt >= k:
		return True
	else:
		return False
k = int(input())
arr = [1 for i in range(10)]
s = list('codeforces')
i = 0
while True:
	if i == 10:
		i = 0
	if isValid(arr, k):
		break
	arr[i] += 1
	i += 1
print(''.join(list(map(mul, arr, s))))


k = int(input())
prod = 1
values = [1 for i in range(10)]
i = 0
while prod < k:
	prod /= values[i]
	values[i] += 1
	prod *= values[i]
	i = (i + 1) % 10
for j in range(10):
	print('codeforces'[j] * values[j], end='')


import math
import sys
from itertools import permutations
input = sys.stdin.readline
k = int(input())
ind = [1] * 10
mul = 1
cur = 0
while mul < k:
	ind[cur] += 1
	mul = 1
	for i in range(10):
		mul *= ind[i]
	cur = (cur + 1) % 10
s = 'codeforces'
ans = ''
for i in range(10):
	for j in range(ind[i]):
		ans += s[i]
print(ans)


word = 'codeforces'
n = int(input())
i = 1
while i ** 10 < n:
	i += 1
if i == 1:
	print('codeforces')
else:
	base = i - 1
	res = ''
	for j in range(11):
		if i ** j * base ** (10 - j) >= n:
			for (ind, l) in enumerate(word):
				if ind < j:
					res += l * i
				else:
					res += l * base
			break
	print(res)


n = int(input())
l = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
req = n ** 0.1
a = ''
if req / 1 == req // 1:
	for i in range(10):
		req = int(req)
		a += l[i] * req
else:
	req = int(req) + 1
	cnt = (req - 1) ** 10
	index = 0
	while cnt < n:
		a += req * l[index]
		cnt *= req
		cnt /= req - 1
		cnt = int(cnt)
		index += 1
	for i in range(index, 10):
		a += l[i] * (req - 1)
print(a)


def product(x):
	a = 1
	for i in x:
		a = a * i
	return a
k = int(input())
q = [1] * 10
i = 0
while product(q) < k:
	q[i] = q[i] + 1
	if i >= 9:
		i = 0
	else:
		i = i + 1
s = 'codeforces'
for i in range(10):
	print(s[i] * q[i], end='')


n = int(input())
arr = [1 for i in range(10)]
curr = 1
i = 0
while curr < n:
	curr = curr // arr[i]
	curr *= arr[i] + 1
	arr[i] += 1
	i = (i + 1) % 10
l = 'codeforces'
for i in range(10):
	for j in range(arr[i]):
		print(l[i], end='')
print()


import sys
ints = (int(x) for x in sys.stdin.read().split())
sys.setrecursionlimit(3000)

def main():
	k = next(ints)
	s = 'codeforces'
	n = len(s)
	i = 1
	while i ** 10 < k:
		i += 1
	j = n
	while j > 0 and (i - 1) ** j * i ** (n - j) < k:
		j -= 1
	for c in s[:j]:
		print(c * (i - 1), end='', flush=False)
	for c in s[j:]:
		print(c * i, end='', flush=False)
	print(flush=True)
	return
main()


num = int(input())
repeats = [1] * 10
word = 'codeforces'
while True:
	start = 1
	for x in repeats:
		start = start * x
	if start >= num:
		break
	else:
		repeats[repeats.index(min(repeats))] += 1
for times in range(10):
	print(word[times] * repeats[times], end='')


from __future__ import division, print_function
import sys
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip
import os, sys, bisect, copy
from collections import defaultdict, Counter, deque
if os.path.exists('in.txt'):
	sys.stdin = open('in.txt', 'r')
if os.path.exists('out.txt'):
	sys.stdout = open('out.txt', 'w')

def input():
	return sys.stdin.readline()

def mapi(arg=0):
	return map(int if arg == 0 else str, input().split())
n = int(input())
cnt = [1] * 10
word = 'codeforces'
i = 0
count = 1
while count < n:
	count = count // cnt[i] * (cnt[i] + 1)
	cnt[i] += 1
	i = (i + 1) % 10
res = []
for i in range(10):
	res += [word[i]] * cnt[i]
print(''.join(res))


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
			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')
k = int(input())
words = [k for k in 'codeforces']
repetitions = [1] * 10
count = 1
reps = 0
cv = 2
oldcount = 1
while count < k:
	count = count * cv // oldcount
	reps += 1
	if reps % 10 == 0:
		cv += 1
		oldcount += 1
for s in range(reps):
	repetitions[s % len(repetitions)] += 1
outy = ''
for s in range(len(words)):
	outy += repetitions[s] * words[s]
print(outy)


import sys, math, os
from io import BytesIO, IOBase
from collections import defaultdict as dd, deque, Counter

def data():
	return sys.stdin.buffer.readline().strip()

def mdata():
	return list(map(int, data().split()))

def outl(var):
	sys.stdout.write(' '.join(map(str, var)) + '\n')

def out(var):
	sys.stdout.write(str(var) + '\n')
mod = 998244353
k = int(data())
s = 1
t = 2
cnt = 0
st = 'codeforces'
while s < k:
	for i in range(10):
		s //= t - 1
		s *= t
		cnt += 1
		if s >= k:
			break
	t += 1
ans = ''
for i in range(10):
	ans += st[i] * (cnt // 10 + 1 + (1 if cnt % 10 > i else 0))
out(ans)


import math
n = int(input())
a = [1 for x in range(10)]
mul = 1
x = 0
while mul < n:
	a[x] = a[x] + 1
	mul = 1
	for t in a:
		mul = mul * t
	x = (x + 1) % 10
s = 'codeforces'
for x in range(10):
	print(s[x] * a[x], end='')


k = int(input())
codeforces = 'codeforces'
ans = [1 for _ in range(len(codeforces))]
i = 0
tot = 1
while tot < k:
	tot //= ans[i]
	ans[i] += 1
	tot *= ans[i]
	i += 1
	i %= len(codeforces)
for i in range(len(codeforces)):
	print(codeforces[i] * ans[i], end='')
print()


import math
k = int(input())
ans = 'codeforces'
answer = ''
i = math.ceil(k ** 0.1)
j = int(k ** 0.1)
for t in range(11):
	if k <= i ** t * j ** (10 - t):
		break
tt = t
for ele in ans:
	if t > 0:
		answer += ele * i
	else:
		answer += ele * j
	t -= 1
print(answer)


n = int(input())

def solve(n):
	repeats = 1
	for x in range(1, 50):
		if n <= x ** 10:
			repeats = x
			break
	ct = 10
	for z in range(1, 11):
		if repeats ** z * (repeats - 1) ** (10 - z) >= n:
			ct = z
			break
	letters = 0
	for x in 'codeforces':
		for y in range(repeats):
			print(x, end='')
		letters += 1
		if letters >= ct:
			repeats -= 1
			letters = -100000
solve(n)


from math import log10
a = int(input())
l = int(a ** (1 / 10))
x = [l for i in range(10)]
cont = x[0] ** 10
i = 0
while cont < a:
	x[i] += 1
	i += 1
	cont = int(cont / l * (l + 1))
st = 'codeforces'
for i in range(10):
	print(st[i] * x[i], end='')
print()


import math
n = int(input())
k = math.floor(n ** (1 / 10))
initial = k ** 10
li = [k] * 10
for i in range(0, 10):
	if initial >= n:
		break
	initial /= k
	initial *= k + 1
	li[i] += 1
s = 'codeforces'
for i in range(10):
	while li[i]:
		print(s[i], end='')
		li[i] -= 1


import sys
input = sys.stdin.readline
from math import log2, ceil
k = int(input())
ans = [1 for i in range(10)]
j = 0
lol = 1
while lol < k:
	lol //= ans[j % 10]
	ans[j % 10] += 1
	lol *= ans[j % 10]
	j += 1
while len(ans) < 10:
	ans.append(1)
answer = []
l = 'codeforces'
i = 0
while i < len(ans):
	answer.append(l[i % 10] * ans[i])
	i += 1
print(''.join(answer))


k = int(input())
s = 'codeforces'
ct = [1] * len(s)
ans = 1
while ans < k:
	for i in range(len(s)):
		if ans >= k:
			break
		ans /= ct[i]
		ct[i] += 1
		ans *= ct[i]
print(''.join([s[i] * ct[i] for i in range(len(s))]))


n = int(input())
c = [1] * 10
total = 1
while total < n:
	for (i, j) in enumerate('codeforces'):
		c[i] += 1
		total = total // (c[i] - 1) * c[i]
		if total >= n:
			break
for (ind, m) in enumerate('codeforces'):
	print(c[ind] * m, end='')


import math as mt
import sys, string
input = sys.stdin.readline
print = sys.stdout.write
from collections import defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
n = I()
x = 1
for i in range(50):
	if n >= i ** 10 and n <= (i + 1) ** 10:
		key = i
		break
a = [key] * 10
for i in range(10):
	product = pow(key + 1, i + 1) * pow(key, 10 - (i + 1))
	if product >= n:
		times = i + 1
		break
x = [key + 1] * times + [key] * (10 - times)
c = 0
for i in 'codeforces':
	print(x[c] * i)
	c += 1


n = int(input())
lis = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
nxt = 0
prod = 1

def product(arr):
	prod = 1
	for i in arr:
		prod = prod * i
	return prod
while prod < n:
	lis[nxt] += 1
	nxt += 1
	nxt = nxt % 10
	prod = product(lis)
s = 'codeforces'
for i in range(10):
	print(s[i] * lis[i], end='')


def prod(b):
	ans = 1
	for i in b:
		ans = ans * i
	return ans
k = int(input())
arr = [1] * 10
i = 0
while prod(arr) < k:
	if i == 10:
		i = 0
	arr[i] += 1
	i += 1
ans = ''
a = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
for i in range(10):
	ans += a[i] * arr[i]
print(ans)


from math import log
from functools import reduce

def solve():
	k = int(input())
	st = 'codeforces'
	m = 1
	s = [1] * 10
	i = 0
	while k > reduce(lambda x, y: x * y, s):
		s[i % 10] += 1
		i += 1
	for i in range(10):
		print(st[i] * s[i], end='')
	print()
t = 1
for _ in range(t):
	solve()


from math import log, ceil
k = int(input())
freq = [1] * 10
prod = 1
i = 0
while prod < k:
	prod //= freq[i]
	freq[i] += 1
	prod *= freq[i]
	i += 1
	i %= 10
for (letter, f) in zip('codeforces', freq):
	print(letter * f, end='')
print()


n = int(input())
cnt = [1 for k in range(10)]
tot = 1
while tot < n:
	for j in range(10):
		if tot >= n:
			break
		tot //= cnt[j]
		cnt[j] += 1
		tot *= cnt[j]
cf = 'codeforces'
st = ''
i = 0
for c in cf:
	st += c * cnt[i]
	i += 1
print(st)


k = int(input())

def product(s):
	res = 1
	for e in s:
		res *= e
	return res
string = 'codeforces'
nums = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
index = 0
while True:
	p = product(nums)
	if p < k:
		nums[index] += 1
		index = (index + 1) % len(nums)
	else:
		break
result = ''
for (i, e) in enumerate(nums):
	result += e * string[i]
print(result)


def solution(k):
	val = max(1, int(k ** (1 / 10)) - 1)
	arr = [val for _ in range(10)]
	curr = int(val ** 10)
	i = 0
	while curr < k:
		arr[i % 10] += 1
		curr = 1
		for a in arr:
			curr *= a
		i += 1
	return ''.join([count * char for (count, char) in zip('codeforces', arr)])
k = int(input())
print(solution(k))


import math
t = int(input())
if t == 1:
	print('codeforces')
else:
	let = 'codeforces'
	ans = str()
	i = 2
	while i ** 10 < t:
		i = i + 1
	for j in range(1, 11):
		if i ** j * (i - 1) ** (10 - j) >= t:
			con = j
			break
	for j in range(len(let)):
		if j + 1 <= con:
			for k in range(i):
				ans = ans + let[j]
		else:
			for k in range(i - 1):
				ans = ans + let[j]
	print(ans)


import math
n = int(input())

def BS(n):
	l = 0
	r = 100
	while l < r:
		mid = l + (r - l) // 2
		if mid ** 10 >= n:
			r = mid
		else:
			l = mid + 1
	return l

def BS1(x, n):
	l = 0
	r = 10
	while l < r:
		mid = l + math.ceil((r - l) / 2)
		temp = (x - 1) ** mid
		temp *= x ** (10 - mid)
		if temp < n:
			r = mid - 1
		else:
			l = mid
	return l
x = BS(n)
arr = [x for i in range(10)]
l = BS1(x, n)
for i in range(l):
	arr[i] -= 1
S = 'codeforces'
s = ''
for i in range(10):
	s += S[i] * arr[i]
print(s)


n = int(input())
s0 = 'codeforces'
x = int(n ** 0.1)
y = 10
for i in range(10):
	if x ** (10 - i) * (x + 1) ** i >= n:
		y = i
		break
ans = ''
for i in range(10):
	if i < y:
		ans += s0[i] * (x + 1)
	else:
		ans += s0[i] * x
print(ans)


import sys
import math
import operator as op
from functools import reduce
from bisect import *
from collections import OrderedDict
from collections import deque

def read_line():
	return sys.stdin.readline()[:-1]

def read_int():
	return int(sys.stdin.readline())

def read_int_line():
	return [int(v) for v in sys.stdin.readline().split()]

def read_float_line():
	return [float(v) for v in sys.stdin.readline().split()]

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer / denom

def index(a, x):
	i = bisect_left(a, x)
	if i != len(a) and a[i] == x:
		return i
	return -1

def find_lt(a, x):
	i = bisect_left(a, x)
	if i:
		return i - 1
	return -1

def find_le(a, x):
	i = bisect_right(a, x)
	if i:
		return i - 1
	return -1

def find_gt(a, x):
	i = bisect_right(a, x)
	if i != len(a):
		return i
	return -1

def find_ge(a, x):
	i = bisect_left(a, x)
	if i != len(a):
		return i
	return -1
mod = int(1000000000.0) + 7
mod2 = 998244353
t = 1
for i in range(t):
	k = read_int()
	n = math.ceil(math.log(k, 2))
	ans = 1
	an = [1] * 10
	if k == 1:
		print('codeforces')
		continue
	for i in range(2, 51):
		for j in range(10):
			if ans >= k:
				break
			else:
				an[j] = i
				ans = ans // (i - 1)
				ans *= i
	val = ''
	v = 'codeforces'
	v = [v[i] for i in range(len(v))]
	for i in range(len(v)):
		val += an[i] * v[i]
	print(val)


import sys
input = sys.stdin.readline
ipnl = lambda n: [int(input()) for _ in range(n)]
inp = lambda : int(input())
ip = lambda : [int(w) for w in input().split()]
from functools import reduce

def prod(lt):
	return reduce(lambda x, y: x * y, lt)
k = inp()
s = 'codeforces'
x = [1] * 10
i = 0
p = prod(x)
while p < k:
	x[i] += 1
	i = (i + 1) % 10
	p = prod(x)
new = ''
for i in range(10):
	new += s[i] * x[i]
print(new)


for _ in range(1):
	i = 1
	s = 'codeforces'
	m = int(input())
	if m == 1:
		print(s)
	else:
		while int(pow(i, 10)) < m:
			i += 1
		k = 1
		while int(pow(i, k) * pow(i - 1, 10 - k)) < m:
			k += 1
		for j in range(k):
			for w in range(i):
				print(s[j], end='')
		for j in range(k, 10):
			for w in range(i - 1):
				print(s[j], end='')
		print()


def mult(arr):
	out = 1
	for i in arr:
		out *= i
	return out

def solve(k):
	repeats = [1 for _ in range(len('codeforces'))]
	next_idx = -1
	while k > mult(repeats):
		next_idx += 1
		next_idx = next_idx % len('codeforces')
		repeats[next_idx] += 1
	repeats = [i * 'codeforces'[idx] for (idx, i) in enumerate(repeats)]
	return ''.join(repeats)

def main():
	k = int(input())
	print(solve(k))
main()


import sys
import math
from sys import stdin, stdout

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_string():
	return sys.stdin.readline().strip()

def main():
	n = int(input())
	z = n // 2
	c = [1] * 10
	k = 1
	l = 0
	f = 1
	if n == 1:
		print('codeforces')
	else:
		while 1:
			for i in range(9, -1, -1):
				f = f // c[i]
				if (c[i] + 1) * f >= n:
					c[i] += 1
					l = 1
					break
				c[i] = c[i] + 1
				f = f * c[i]
			if f >= n:
				break
			if l == 1:
				break
		v = ''
		g = 'codeforces'
		for i in range(10):
			for j in range(c[i]):
				v = v + g[i]
		print(v)
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			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')
main()


n = int(input())
count = 1
while count ** 10 < n:
	count += 1
word = 'codeforces'
m = 1
for i in range(len(word)):
	print(word[i] * count, end='')
	m *= count
	if m * (count - 1) ** (9 - i) >= n:
		count -= 1


a = int(input())
l = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
p = 'codeforces'
s = 1
d = 0
while s < a:
	s = 1
	l[d] = l[d] + 1
	for i in range(0, 10):
		s = s * l[i]
	d = d + 1
	if d > 9:
		d = 0
for i in range(0, 10):
	print(p[i] * l[i], end='')


n = int(input())
span = 1
ok = False
if n == 1:
	print('codeforces')
	exit()
for i in range(2, 50):
	for j in range(1, 11):
		if span // (i - 1) * i >= n:
			ok = True
			break
		span = span // (i - 1) * i
	if ok:
		break
s = list('codeforces')
ans = ''
for u in range(10):
	if u + 1 <= j:
		ans += s[u] * i
	else:
		ans += s[u] * (i - 1)
print(ans)


import sys
import math

def ints():
	return list(map(int, sys.stdin.readline().strip().split()))
T = 1
while T:
	T -= 1
	n = int(input())
	cf = 'codeforces'
	ans = ''
	for i in range(1, 100):
		if i ** 10 >= n:
			break
	a = i
	b = 0
	c = i - 1
	d = 10
	for i in range(11):
		if a ** b * c ** d >= n:
			break
		else:
			b += 1
			d -= 1
	for i in range(1, 11):
		if i <= b:
			ans += cf[i - 1] * a
		else:
			ans += cf[i - 1] * c
	print(ans)


import sys
import math
from collections import defaultdict

def solve(test):
	k = int(input())
	cnt = 1
	rec = [1] * 10
	i = 0
	while cnt < k:
		rec[i] += 1
		cnt = 1
		for j in range(10):
			cnt *= rec[j]
		i = (i + 1) % 10
	res = 'codeforces'
	ans = ''
	for i in range(10):
		ans += res[i] * rec[i]
	print(ans)
test_cases = 1
for t in range(1, test_cases + 1):
	solve(t)


def number_of_subsequences(list):
	ans = 1
	for x in list:
		ans *= len(x)
	return ans
k = input()
list = [x for x in 'codeforces']
i = 0
while number_of_subsequences(list) < int(k):
	list[i] += list[i][0]
	if i == 9:
		i = 0
	else:
		i += 1
print(*list, sep='')


import math
k = int(input())
c = [1] * 10
t = 0
while math.prod(c) < k:
	c[t] += 1
	t += 1
	if t == 10:
		t = 0
j = 0
s = 'codeforces'
for i in s:
	print(i * c[j], end='')
	j += 1
print()


import sys
input = sys.stdin.readline
n = int(input())
s = 'codeforces'
ans = [1] * 10
ind = 0
now = 1
while now < n:
	ans[ind] += 1
	now = now * ans[ind] // (ans[ind] - 1)
	ind = (ind + 1) % 10
for i in range(10):
	print(s[i] * ans[i], end='')
print()


from functools import reduce
cf = 'codeforces'
k = int(input())
ans = [1] * 10
cur = 0
while reduce(lambda a, b: a * b, ans) < k:
	ans[cur] += 1
	cur += 1
	cur %= 10
for i in range(10):
	print(cf[i] * ans[i], end='')


k = int(input())
a = int(k ** (1 / 10))
b = 0
while a ** (10 - b) * (a + 1) ** b < k:
	b += 1
s = 'codeforces'
rs = ''
for i in range(10):
	if i < b:
		rs += s[i] * (a + 1)
	else:
		rs += s[i] * a
print(rs)


import sys
from copy import copy
import math
from operator import mul
from functools import reduce
input = sys.stdin.readline
n = int(input())
x = [1] * 10
while reduce(mul, x) < n:
	x = [a + 1 for a in x]
pos = len(x) - 1
while reduce(mul, x) >= n:
	x[pos] -= 1
	pos -= 1
pos += 1
x[pos] += 1
for (a, b) in zip('codeforces', x):
	for z in range(b):
		print(a, end='')
print('')


from sys import stdin, stdout
import math
from itertools import permutations, combinations
from collections import defaultdict
from collections import Counter
from bisect import bisect_left
import sys
from queue import PriorityQueue
mod = 1000000007

def L():
	return list(map(int, stdin.readline().split()))

def In():
	return map(int, stdin.readline().split())

def I():
	return int(stdin.readline())

def printIn(ob):
	return stdout.write(str(ob) + '\n')

def powerLL(n, p):
	result = 1
	while p:
		if p & 1:
			result = result * n % mod
		p = int(p / 2)
		n = n * n % mod
	return result

def myCode():
	k = I()
	ar = [1] * 10
	string = 'codeforces'
	ct = 1
	c = 0
	while ct < k:
		ct //= ar[c]
		ar[c] += 1
		ct *= ar[c]
		c += 1
		c %= 10
	for i in range(10):
		print(ar[i] * string[i], end='')

def main():
	myCode()
main()


k = int(input())
s = 'codeforces'
m = 0
i = 0
f = ''
while i >= 0:
	if i ** 10 >= k:
		break
	i += 1
for j in range(1, 11):
	m = (i - 1) ** (10 - j) * i ** j
	if m >= k:
		break
for a in s[:j]:
	f += a * i
for a in s[j:]:
	f += a * (i - 1)
print(f)