Tokitsukaze and CSL are playing a little game of stones.

In the beginning, there are $n$ piles of stones, the $i$-th pile of which has $a_i$ stones. The two players take turns making moves. Tokitsukaze moves first. On each turn the player chooses a nonempty pile and removes exactly one stone from the pile. A player loses if all of the piles are empty before his turn, or if after removing the stone, two piles (possibly empty) contain the same number of stones. Supposing that both players play optimally, who will win the game?

Consider an example: $n=3$ and sizes of piles are $a_1=2$, $a_2=3$, $a_3=0$. It is impossible to choose the empty pile, so Tokitsukaze has two choices: the first and the second piles. If she chooses the first pile then the state will be $[1, 3, 0]$ and it is a good move. But if she chooses the second pile then the state will be $[2, 2, 0]$ and she immediately loses. So the only good move for her is to choose the first pile. 

Supposing that both players always take their best moves and never make mistakes, who will win the game?

Note that even if there are two piles with the same number of stones at the beginning, Tokitsukaze may still be able to make a valid first move. It is only necessary that there are no two piles with the same number of stones after she moves.


-----Input-----

The first line contains a single integer $n$ ($1 \le n \le 10^5$) — the number of piles.

The second line contains $n$ integers $a_1, a_2, \ldots, a_n$ ($0 \le a_1, a_2, \ldots, a_n \le 10^9$), which mean the $i$-th pile has $a_i$ stones.


-----Output-----

Print "sjfnb" (without quotes) if Tokitsukaze will win, or "cslnb" (without quotes) if CSL will win. Note the output characters are case-sensitive.


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

Output
cslnb

Input
2
1 0

Output
cslnb

Input
2
2 2

Output
sjfnb

Input
3
2 3 1

Output
sjfnb



-----Note-----

In the first example, Tokitsukaze cannot take any stone, so CSL will win.

In the second example, Tokitsukaze can only take a stone from the first pile, and then, even though they have no stone, these two piles will have the same number of stones, which implies CSL will win.

In the third example, Tokitsukaze will win. Here is one of the optimal ways:

  Firstly, Tokitsukaze can choose the first pile and take a stone from that pile.  Then, CSL can only choose the first pile, because if he chooses the second pile, he will lose immediately.  Finally, Tokitsukaze can choose the second pile, and then CSL will have no choice but to lose. 

In the fourth example, they only have one good choice at any time, so Tokitsukaze can make the game lasting as long as possible and finally win.

Difficulty: MEDIUM_HARD
Tags: Game theory
Expected Time Complexity: O(N)

Starter code:

Solutions:
from collections import defaultdict as dd, deque
n = int(input())
A = [int(x) for x in input().split()]
n = len(A)
C = dd(int)
for a in A:
	C[a] += 1
thedup = None
ndup = 0
screwed = False
for c in C:
	if C[c] > 2:
		screwed = True
	elif C[c] == 2:
		if c == 0:
			screwed = True
		thedup = c
		ndup += 1
import sys
if screwed or ndup > 1:
	print('cslnb')
else:
	if ndup == 1:
		if C[thedup - 1] != 0:
			print('cslnb')
			sys.exit()
	target = sum(range(n))
	cur = sum(A)
	togo = cur - target
	if togo % 2 == 0:
		print('cslnb')
	else:
		print('sjfnb')


n = int(input())
a = sorted(list(map(int, input().split())))
bal = 0
if a.count(0) > 1:
	print('cslnb')
	return
if n - len(set(a)) > 1:
	print('cslnb')
	return
if n - len(set(a)) == 1:
	for i in range(1, n):
		if a[i] == a[i - 1]:
			if a[i] - 1 in a:
				print('cslnb')
				return
			break
if n == 1:
	print('cslnb' if not a[0] % 2 else 'sjfnb')
	return
for i in range(n):
	bal += a[i] - i
print('sjfnb' if bal % 2 else 'cslnb')


n = int(input())
a = list(map(int, input().split()))
dupes = 0
dupeVal = -1
d = set()
for el in a:
	if el in d:
		dupes += 1
		dupeVal = el
	else:
		d.add(el)
inPlay = True
if dupes > 1:
	print('cslnb')
	inPlay = False
elif dupes == 1:
	if dupeVal == 0 or dupeVal - 1 in d:
		print('cslnb')
		inPlay = False
if inPlay:
	finalSum = n * (n - 1) // 2
	Sum = sum(a)
	if (Sum - finalSum) % 2 == 0:
		print('cslnb')
	else:
		print('sjfnb')


import os
import sys
from io import BytesIO, IOBase
from collections import Counter
import math as mt
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 gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def lcm(a, b):
	return a * b / gcd(a, b)
mod = int(1000000000.0) + 7

def power(k, n):
	if n == 0:
		return 1
	if n % 2:
		return power(k, n - 1) * k % mod
	t = power(k, n // 2)
	return t * t % mod

def totalPrimeFactors(n):
	count = 0
	if n % 2 == 0:
		count += 1
		while n % 2 == 0:
			n //= 2
	i = 3
	while i * i <= n:
		if n % i == 0:
			count += 1
			while n % i == 0:
				n //= i
		i += 2
	if n > 2:
		count += 1
	return count

def main():
	n = int(input())
	a = list(map(int, input().split()))
	a.sort()
	same = 0
	ind = -1
	poss = 1
	for i in range(1, n):
		same += a[i] == a[i - 1]
		if a[i] == a[i - 1]:
			ind = i - 1
			if a[i] == 0:
				poss = 0
	if same > 1 or poss == 0:
		print('cslnb')
	else:
		if ind > 0:
			if a[ind] - a[ind - 1] == 1:
				print('cslnb')
				return
		c = 0
		for i in range(n):
			c += a[i] - i
		if c % 2:
			print('sjfnb')
		else:
			print('cslnb')
	return
main()


import sys
input = sys.stdin.readline
n = int(input())
A = list(map(int, input().split()))
A.sort()
from collections import Counter
C = Counter(A)
dou = 0
for c in C:
	dou += C[c] - 1
	if C[c] >= 2 and C[c - 1] != 0:
		print('cslnb')
		return
if dou >= 2:
	print('cslnb')
	return
ANS = 0
for i in range(n):
	if A[i] < i:
		print('cslnb')
		return
	ANS += (A[i] - i) % 2
if ANS % 2 == 0:
	print('cslnb')
	return
else:
	print('sjfnb')
	return


n = int(input())
a = list(map(int, input().split()))
d = set()
t = {}
rep = set()
if a.count(0) >= 2:
	print('cslnb')
	return
for i in a:
	if i in d:
		if t[i] + 1 == 3:
			print('cslnb')
			return
		else:
			t[i] += 1
			rep.add(i)
			if len(rep) >= 2:
				print('cslnb')
				return
	else:
		t[i] = 1
		d.add(i)
if rep:
	for c in rep:
		if c - 1 in d:
			print('cslnb')
			return
s = 0
a.sort()
for i in range(n):
	s += a[i] - i
if s % 2 == 1:
	print('sjfnb')
else:
	print('cslnb')


n = int(input())
a = list(map(int, input().split()))
a.sort()
lose = False
pair = False
for i in range(n - 1):
	if a[i] == a[i + 1] == 0:
		lose = True
	if a[i] == a[i + 1]:
		if pair:
			lose = True
		pair = True
		if i >= 1:
			if a[i] == a[i - 1] + 1:
				lose = True
if lose:
	print('cslnb')
else:
	eventual = n * (n - 1) // 2
	curr = sum(a)
	if (curr - eventual) % 2 == 0:
		print('cslnb')
	else:
		print('sjfnb')


import sys

def rl(proc=None):
	if proc is not None:
		return proc(sys.stdin.readline())
	else:
		return sys.stdin.readline().rstrip()

def srl(proc=None):
	if proc is not None:
		return list(map(proc, rl().split()))
	else:
		return rl().split()

def main():
	rl()
	a = srl(int)
	a.sort()
	cnt = 0
	for i in range(0, len(a) - 1):
		if a[i] == a[i + 1]:
			a[i] -= 1
			cnt += 1
			break
	if a[0] < 0:
		print('cslnb')
		return
	for i in range(0, len(a) - 1):
		if a[i] == a[i + 1]:
			print('cslnb')
			return
	for (i, x) in enumerate(a):
		cnt += x - i
	print('sjfnb' if cnt & 1 else 'cslnb')
main()


ans = ['sjfnb', 'cslnb']
n = int(input())
l = list(map(int, input().split()))
l.sort()
d = set()
e = 0
s = 0
for i in range(n):
	if l[i] in d:
		e += 1
		s = l[i]
	d.add(l[i])
if e > 1 or l.count(0) > 1 or s - 1 in d:
	print(ans[1])
else:
	l = [l[i] - i for i in range(n)]
	print(ans[1 - sum(l) % 2])


from sys import stdin, stdout
import heapq
import cProfile, math
from collections import Counter, defaultdict, deque
from bisect import bisect_left, bisect, bisect_right
import itertools
from copy import deepcopy
from fractions import Fraction
import sys, threading
import operator as op
from functools import reduce
import sys
sys.setrecursionlimit(10 ** 6)
threading.stack_size(2 ** 27)
fac_warm_up = False
printHeap = str()
memory_constrained = False
P = 10 ** 9 + 7

class MergeFind:

	def __init__(self, n):
		self.parent = list(range(n))
		self.size = [1] * n
		self.num_sets = n
		self.lista = [[_] for _ in range(n)]

	def find(self, a):
		to_update = []
		while a != self.parent[a]:
			to_update.append(a)
			a = self.parent[a]
		for b in to_update:
			self.parent[b] = a
		return self.parent[a]

	def merge(self, a, b):
		a = self.find(a)
		b = self.find(b)
		if a == b:
			return
		if self.size[a] < self.size[b]:
			(a, b) = (b, a)
		self.num_sets -= 1
		self.parent[b] = a
		self.size[a] += self.size[b]
		self.lista[a] += self.lista[b]

	def set_size(self, a):
		return self.size[self.find(a)]

	def __len__(self):
		return self.num_sets

def display(string_to_print):
	stdout.write(str(string_to_print) + '\n')

def prime_factors(n):
	factors = dict()
	for i in range(2, math.ceil(math.sqrt(n)) + 1):
		while n % i == 0:
			if i in factors:
				factors[i] += 1
			else:
				factors[i] = 1
			n = n // i
	if n > 2:
		factors[n] = 1
	return factors

def all_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 fibonacci_modP(n, MOD):
	if n < 2:
		return 1
	return (cached_fn(fibonacci_modP, (n + 1) // 2, MOD) * cached_fn(fibonacci_modP, n // 2, MOD) + cached_fn(fibonacci_modP, (n - 1) // 2, MOD) * cached_fn(fibonacci_modP, (n - 2) // 2, MOD)) % MOD

def factorial_modP_Wilson(n, p):
	if p <= n:
		return 0
	res = p - 1
	for i in range(n + 1, p):
		res = res * cached_fn(InverseEuler, i, p) % p
	return res

def binary(n, digits=20):
	b = bin(n)[2:]
	b = '0' * (digits - len(b)) + b
	return b

def is_prime(n):
	if n < 4:
		return True
	if n % 2 == 0:
		return False
	if n % 3 == 0:
		return False
	i = 5
	w = 2
	while i * i <= n:
		if n % i == 0:
			return False
		i += w
		w = 6 - w
	return True

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

def warm_up_fac(MOD):
	nonlocal factorial_modP, fac_warm_up
	if fac_warm_up:
		return
	factorial_modP = [1 for _ in range(fac_warm_up_size + 1)]
	for i in range(2, fac_warm_up_size):
		factorial_modP[i] = factorial_modP[i - 1] * i % MOD
	fac_warm_up = True

def InverseEuler(n, MOD):
	return pow(n, MOD - 2, MOD)

def nCr(n, r, MOD):
	nonlocal fac_warm_up, factorial_modP
	if not fac_warm_up:
		warm_up_fac(MOD)
		fac_warm_up = True
	return factorial_modP[n] * (pow(factorial_modP[r], MOD - 2, MOD) * pow(factorial_modP[n - r], MOD - 2, MOD) % MOD) % MOD

def test_print(*args):
	if testingMode:
		print(args)

def display_list(list1, sep=' '):
	stdout.write(sep.join(map(str, list1)) + '\n')

def display_2D_list(li):
	for i in li:
		print(i)

def prefix_sum(li):
	sm = 0
	res = []
	for i in li:
		sm += i
		res.append(sm)
	return res

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()))
memory = dict()

def clear_cache():
	nonlocal memory
	memory = dict()

def cached_fn(fn, *args):
	nonlocal memory
	if args in memory:
		return memory[args]
	else:
		result = fn(*args)
		memory[args] = result
		return result

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

def binary_search(i, li):
	fn = lambda x: li[x] - x // i
	x = -1
	b = len(li)
	while b >= 1:
		while b + x < len(li) and fn(b + x) > 0:
			x += b
		b = b // 2
	return x
TestCases = False
fac_warm_up_size = 10 ** 5 + 100
optimise_for_recursion = False

def main():
	n = get_int()
	li = get_list()
	li.sort()
	res = 0
	for (i, ele) in enumerate(li):
		if ele < i:
			print('cslnb')
			return
		else:
			res += ele - i
	counter = Counter(li)
	cnt2 = 0
	for i in counter.keys():
		if counter[i] > 2 or counter[0] > 1:
			print('cslnb')
			return
		elif counter[i] == 2:
			cnt2 += 1
			if cnt2 > 1 or i - 1 in counter:
				print('cslnb')
				return
	print('cslnb') if res % 2 == 0 else print('sjfnb')
if TestCases:
	for i in range(get_int()):
		main()
else:
	main() if not optimise_for_recursion else threading.Thread(target=main).start()


import sys

def is_winning_state(nims, n):
	keys = set(nims)
	counts = dict.fromkeys(keys, 0)
	for nim in nims:
		counts[nim] += 1
	if 0 in keys and counts[0] > 1:
		return True
	lose_count = 0
	for k in keys:
		if counts[k] > 2:
			return True
		if counts[k] > 1 and k - 1 in keys and (counts[k - 1] > 0):
			return True
		if counts[k] > 1:
			lose_count += 1
	if lose_count > 1:
		return True
	return False

def main():
	n = int(input())
	nims = list(map(int, input().split()))
	if is_winning_state(nims, n):
		print('cslnb')
	else:
		x = sum(nims) - n * (n - 1) // 2
		if x % 2 == 0:
			print('cslnb')
		else:
			print('sjfnb')
main()


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')
n = int(input())
vals = sorted(map(int, input().split()))
reps = 0
zreps = 0
rep = []
broke = False
for s in range(1, n):
	if vals[s] == vals[s - 1]:
		if vals[s] == 0:
			zreps += 1
			broke = True
			break
		else:
			reps += 1
			rep.append(vals[s])
if reps > 1:
	broke = True
elif len(rep) == 1:
	setty = set(vals)
	if rep[0] - 1 in setty:
		broke = True
if broke == True:
	print('cslnb')
else:
	count = 0
	for s in range(n):
		count += vals[s] - s
	if count % 2 == 0:
		print('cslnb')
	else:
		print('sjfnb')


from sys import stdin
n = int(stdin.readline())
stones = sorted([int(x) for x in stdin.readline().split()])
if n == 1:
	if stones[0] % 2 == 0:
		print('cslnb')
	else:
		print('sjfnb')
else:
	chilly = -1
	chill = 2
	prev = stones[0]
	for x in stones[1:]:
		if x == prev:
			chill -= 1
			chilly = x
		else:
			streak = 1
			prev = x
	s = sum(stones)
	if n % 4 == 0 or n % 4 == 1:
		s += 1
	if chill <= 0 or stones.count(0) > 1:
		print('cslnb')
	elif chill == 1 and chilly - 1 in stones:
		print('cslnb')
	elif s % 2 == 1:
		print('cslnb')
	else:
		print('sjfnb')


n = int(input())
arr = list(map(int, input().split(' ')))
arr.sort()
stop = 0
equal = -1
tempcounter = 0
for i in range(1, n):
	if arr[i] == arr[i - 1]:
		equal = arr[i]
		tempcounter += 1
		if tempcounter == 2:
			break
if tempcounter == 1 and equal != 0:
	for j in range(n):
		if arr[j] == equal - 1:
			print('cslnb')
			stop = 1
if tempcounter == 1 and equal == 0:
	print('cslnb')
elif tempcounter < 2 and stop == 0:
	moves = arr[0]
	counter = 0
	for i in range(1, n):
		moves += arr[i] - i
	if counter == 0:
		if moves % 2 == 0:
			print('cslnb')
		else:
			print('sjfnb')
elif stop == 0:
	print('cslnb')


def find(A):
	from collections import defaultdict
	A = sorted(A)
	N = len(A)
	dic = defaultdict(int)
	for i in range(N):
		dic[A[i]] += 1
	checked = []
	count = set([])
	for x in A:
		if dic[x] > 2:
			return 'cslnb'
		if dic[x] == 2:
			count.add(x)
			y = x - 1
			if y in dic:
				return 'cslnb'
	if len(count) > 1:
		return 'cslnb'
	if 0 in count:
		return 'cslnb'
	temp = 0
	for i in range(N):
		temp += A[i] - i
	if temp % 2 == 1:
		return 'sjfnb'
	return 'cslnb'
input()
A = list(map(int, input().strip().split(' ')))
print(find(A))


n = int(input())
u = list(map(int, input().split()))
u.sort()
ans = 0
k = 1
ok = False
for i in range(1, n):
	if u[i] == u[i - 1]:
		k += 1
		if k == 3:
			print('cslnb')
			return
		if k == 2:
			if ok or u[i] == 0 or u[i] - u[i - 2] == 1:
				print('cslnb')
				return
			ok = True
	else:
		k = 1
for i in range(n):
	ans += u[i] - i
if ans % 2 == 0:
	print('cslnb')
else:
	print('sjfnb')


n = int(input())
a = sorted(list(map(int, input().split())))
win = None
first = True
if n == 1:
	win = a[0] % 2 == 1
elif a[1] == 0:
	win = False
if n > 2:
	for i in range(n - 1):
		if a[i] == a[i + 1]:
			if i > 0:
				if a[i - 1] == a[i] - 1:
					win = False
					break
			if not first:
				win = False
				break
			first = False
if win is None:
	win = (sum(a) - n * (n - 1) // 2) % 2 == 1
if win:
	print('sjfnb')
else:
	print('cslnb')


from collections import Counter
import sys
readline = sys.stdin.readline

def check(A):
	CA = Counter(A)
	if CA[0] >= 2:
		return False
	cnt = 0
	for (k, v) in list(CA.items()):
		if v > 2:
			return False
		if v == 2 and CA[k - 1] >= 1:
			return False
		if v >= 2:
			cnt += 1
	if cnt >= 2:
		return False
	L = len(A)
	if (sum(A) - L * (L - 1) // 2) % 2 == 0:
		return False
	return True
N = int(readline())
if check(list(map(int, readline().split()))):
	print('sjfnb')
else:
	print('cslnb')


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
from typing import List

def solve(N, A):
	wc = collections.Counter(A)
	if wc[0] > 1:
		return False
	if any([v > 2 for v in wc.values()]):
		return False
	if len([v for v in wc.values() if v > 1]) > 1:
		return False
	if any([c > 1 and w - 1 in wc for (w, c) in wc.items()]):
		return False
	taken = sum(A) - N * (N - 1) // 2
	return taken % 2 != 0
N = int(input())
A = [int(x) for x in input().split()]
s = solve(N, A)
print('sjfnb' if s else 'cslnb')


import math, sys, bisect, heapq, os
from collections import defaultdict, Counter, deque
from itertools import groupby, accumulate
from functools import lru_cache
pr = lambda x: x

def input():
	return sys.stdin.readline().rstrip('\r\n')
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])

def solve():
	(n,) = aj()
	A = aj()
	if A.count(0) >= 2:
		print('cslnb')
	elif n == 1:
		if A[0] % 2:
			print('sjfnb')
		else:
			print('cslnb')
	else:
		g2 = 0
		flag = 1
		C = Counter(A)
		for i in C.keys():
			if C[i] >= 3:
				flag = 0
			if C[i] == 2 and C[i - 1] >= 1:
				flag = 0
			if C[i] == 2:
				g2 += 1
		if g2 >= 2:
			flag = 0
		if not flag:
			print('cslnb')
		else:
			movescount = 0
			A.sort()
			for (ii, i) in enumerate(A):
				movescount += i - ii
			if movescount % 2 == 0:
				print('cslnb')
			else:
				print('sjfnb')
try:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
	from aj import *
except:
	pass
solve()


n = int(input())
a = sorted(list(map(int, input().split())))
duplicates = {}
d = None
delta = 0
for (i, el) in enumerate(a, 1):
	if el not in duplicates:
		duplicates[el] = 0
	else:
		d = el
		duplicates[el] += 1
	min_value = i - 1
	delta += el - min_value
if sum(duplicates.values()) > 1 or duplicates.get(0, 0) >= 1 or (d is not None and d - 1 in duplicates):
	print('cslnb')
elif delta == 0:
	print('cslnb')
elif delta % 2 == 1:
	print('sjfnb')
else:
	print('cslnb')


from collections import Counter
n = int(input())
arr = list(map(int, input().split()))
c = Counter(arr)
common = c.most_common(2)
if common[0][1] > 2 or (common[0][1] == 2 and (common[0][0] == 0 or common[0][0] - 1 in c)) or (len(common) == 2 and common[1][1] == 2):
	print('cslnb')
elif (sum(arr) - n * (n - 1) // 2) % 2 == 1:
	print('sjfnb')
else:
	print('cslnb')


import sys
n = int(sys.stdin.readline().strip())
a = list(map(int, sys.stdin.readline().strip().split()))
a.sort()
if n == 1:
	if a[0] % 2 == 1:
		v = True
	else:
		v = False
else:
	v = True
	c = 0
	for i in range(0, n - 1):
		if a[i] == a[i + 1]:
			c = c + 1
			j = i
	if c > 1:
		v = False
	elif c == 1:
		if a[j] == 0:
			v = False
		if j > 0:
			if a[j - 1] + 1 == a[j]:
				v = False
	if (sum(a) - n * (n - 1) // 2) % 2 == 0:
		v = False
if v == True:
	print('sjfnb')
else:
	print('cslnb')


n = int(input())
x = list(map(int, input().split()))
x.sort()
(count, count2) = (0, 0)
ans = 1
for i in range(n):
	count += x[i] - i
	if i >= 2 and x[i] == x[i - 1] == x[i - 2]:
		ans = 0
	if i >= 2 and x[i] == x[i - 1] == x[i - 2] + 1:
		ans = 0
	if i >= 1 and x[i] == x[i - 1]:
		count2 += 1
if n >= 3 and x[0] == x[1] == 0:
	ans = 0
for i in range(n):
	if x[i] > 0:
		break
	if i == n - 1:
		ans = 0
if ans == 0 or count % 2 == 0 or count2 > 1:
	print('cslnb')
else:
	print('sjfnb')


import os
import sys
from io import BytesIO, IOBase
from collections import Counter

def main():
	n = int(input())
	a = list(map(int, input().split()))
	d = dict()
	z = 0
	s = 0
	for item in a:
		if item in d:
			d[item] += 1
			z = item
		else:
			d[item] = 1
		s += item
	if len(a) - len(d) >= 2:
		print('cslnb')
		exit()
	if len(a) == len(d):
		z = n * (n - 1) // 2
		if (s - z) % 2:
			print('sjfnb')
		else:
			print('cslnb')
	elif z - 1 in d or z == 0:
		print('cslnb')
	else:
		zz = n * (n - 1) // 2
		if (s - zz) % 2:
			print('sjfnb')
		else:
			print('cslnb')
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()


n = int(input())
game = list(map(int, input().split()))
game.append(-1)
game.sort()
bitSum = game[1] % 2
rep = False
for i in range(1, n):
	bitSum += game[i + 1] % 2
	if game[i] == game[i + 1]:
		if rep:
			print('cslnb')
			return
		else:
			if game[i - 1] == game[i] - 1:
				print('cslnb')
				return
			rep = True
Goal = n * (n - 1) / 2 % 2
if (bitSum + Goal) % 2 == 0:
	print('cslnb')
else:
	print('sjfnb')


import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
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())
a = list(map(int, input().split()))
d = dict()
st = set(a)
t = set()
for i in a:
	if i in d:
		d[i] += 1
	else:
		d[i] = 1
two = 0
more = 0
for i in d:
	if d[i] == 2:
		two += 1
		t.add(i)
	elif d[i] > 2:
		more += 1
a.sort()
if two > 1 or more > 0 or sum(a) == 0 or (a.count(0) > 1):
	print('cslnb')
else:
	c = 0
	for i in range(n):
		m = max(0, a[i] - i)
		c += m
	for i in t:
		if i - 1 in st:
			c = 0
	if c % 2 == 0:
		print('cslnb')
	else:
		print('sjfnb')