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: competition

Starter code:

Solutions:
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 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")


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
    
    


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')
            return
        

    target = sum(range(n))
    cur = sum(A)
    togo = cur - target

    if togo%2 == 0:
        print('cslnb')
    else:
        print('sjfnb')


3
# -*- coding: utf-8 -*-

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')


def __starting_point():
    main()

__starting_point()

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 = 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')


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")

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


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')

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 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()


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')


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")


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')


''' CODED WITH LOVE BY SATYAM KUMAR '''

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)  # max depth of recursion
threading.stack_size(2 ** 27)  # new thread will get stack of such size
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):  # n**0.5 complex
    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):
    """Returns True if n is prime."""
    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:  # Change this condition 2 to whatever you like
            x += b
        b = b // 2
    return x


# -------------------------------------------------------------- MAIN PROGRAM


TestCases = False
fac_warm_up_size = 10 ** 5 + 100
optimise_for_recursion = False  # Can not be used clubbed with TestCases WHen using recursive functions, use Python 3


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")

# --------------------------------------------------------------------- END=


if TestCases:
    for i in range(get_int()):
        main()
else:
    main() if not optimise_for_recursion else threading.Thread(target=main).start()


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')


# -*- coding: utf-8 -*-
"""
Created on Sat Oct  5 21:40:29 2019

@author: Mridul Garg
"""

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 == 1 and n == 3 and stop == 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")    
    


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')
else:
    if (sum(arr) - (n * (n - 1))//2) % 2 == 1:
        print('sjfnb')
    else:
        print('cslnb')

# -*- coding: utf-8 -*-

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

"""
created by shhuan at 2020/1/8 22:06

"""


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')

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")

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(l)
    print(ans[1-sum(l)%2])

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')


# whatsibucket
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")