#include<bits/stdc++.h>

using namespace std;
int pos[1000005];
int neg[1000005];
int main()
{
  freopen("input.txt","r",stdin);
  freopen("output.txt","w",stdout);

    int n;
    scanf("%d",&n);
    long long arr[100005];
    for(int i=0;i<n;i++)
    scanf("%I64d",&arr[i]);

    if(arr[0]>=0)
    {
      pos[0]=2;
      neg[0]=1;
    }
    for(int i=1;i<n;i++)
    {
        if(arr[i]>0)
        {
            neg[i]=neg[i-1]+1;
            pos[i]=min(pos[i-1],neg[i-1]);
        }
        else if(arr[i]<0)
        {
            neg[i]=neg[i-1];
            pos[i]=min(pos[i-1],neg[i-1])+1;
        }
        else
        {
            pos[i]=pos[i-1]+1;
            neg[i]=neg[i-1]+1;
        }
    }
    /*for(int i=0;i<n;i++)
    {
        printf("%d ",pos[i]);
    }
        for(int i=0;i<n;i++)
    {
        printf("%d ",neg[i]);
    }*/
    printf("%d",pos[n-1]);
}


#include<bits/stdc++.h>

using namespace std;
int pos[1000005];
int neg[1000005];
int main()
{
    int n,i;
    scanf("%d",&n);
    long long arr[100005];
    for(i=0;i<n;i++)
    scanf("%I64d",&arr[i]);
    if(arr[0]<0)
    neg[0]=0;
    else
    neg[0]=1;
    for(i=1;i<n;i++)
    {
        if(arr[i]>0)
        {
            neg[i]=neg[i-1]+1;
            pos[i]=min(pos[i-1],neg[i-1]);
        }
        else if(arr[i]<0)
        {
            neg[i]=neg[i-1];
            pos[i]=min(pos[i-1],neg[i-1])+1;
        }
        else
        {
            pos[i]=pos[i-1]+1;
            neg[i]=neg[i-1]+1;
        }
    }
    /*for(int i=0;i<n;i++)
    {
        printf("%d ",pos[i]);
    }
        for(int i=0;i<n;i++)
    {
        printf("%d ",neg[i]);
    }*/
    printf("%d",min(pos[n-1],neg[n-1]));
}


#include<bits/stdc++.h>

using namespace std;
int dp1[100005],dp2[100005];
int main()
{
    long long arr[100005];
    long long arr1[100005];
    int count=0;
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%lld",&arr[i]);
        if(arr[i]==0)
        continue;
        arr1[count]=arr[i];
        count++;
    }
    int zeroes=n-count;
    int len=count;
    //initialise
    if(arr[0]>0)
    dp2[0]=1;
    else
    dp1[0]=1;
    int i;
    for(  i=1 ; i < len; i++ )
    {
        if(arr[i]<0)
        {
            dp1[i] = dp1[i-1];     //stays uppercase
            dp2[i] = min(dp1[i-1] , dp2[i-1]) + 1;  //convert to lower one

        }
        else
        {
            dp1[i] = dp1[i-1] + 1;   //convert to upper
            dp2[i] = min(dp1[i-1] , dp2[i-1]); //stayslower
        }
    }
    int ans=min(dp1[len-1] , dp2[len-1]);

    printf("%d",ans+zeroes);
    return 0;
}


#include<bits/stdc++.h>

using namespace std;
int dp1[100005],dp2[100005];
int main()
{
    long long arr[100005];
    long long arr1[100005];
    int count=0;
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%I64d",&arr[i]);
        if(arr[i]==0)
        continue;
        arr1[count]=arr[i];
        count++;
    }
    int zeroes=n-count;
    int len=count;
    //initialise
    if(arr[0]>0)
    dp2[0]=1;
    else
    dp1[0]=1;
    int i;
    for(  i=1 ; i < len; i++ )
    {
        if(arr[i]<0)
        {
            dp1[i] = dp1[i-1];     //stays uppercase
            dp2[i] = min(dp1[i-1] , dp2[i-1]) + 1;  //convert to lower one

        }
        else
        {
            dp1[i] = dp1[i-1] + 1;   //convert to upper
            dp2[i] = min(dp1[i-1] , dp2[i-1]); //stayslower
        }
    }
    int ans=min(dp1[len-1] , dp2[len-1]);

    printf("%d",ans+zeroes);
    return 0;
}


#include<bits/stdc++.h>

using namespace std;
int pos[1000005];
int neg[1000005];
int main()
{
  freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);

    int n;
    scanf("%d",&n);
    long long arr[100005];
    for(int i=0;i<n;i++)
    scanf("%I64d",&arr[i]);

    if(arr[0]>=0)
    {
      pos[0]=2;
      neg[0]=1;
    }
    for(int i=1;i<n;i++)
    {
        if(arr[i]>0)
        {
            neg[i]=neg[i-1]+1;
            pos[i]=min(pos[i-1],neg[i-1]);
        }
        else if(arr[i]<0)
        {
            neg[i]=neg[i-1];
            pos[i]=min(pos[i-1],neg[i-1])+1;
        }
        else
        {
            if(i!=1)
            {

            pos[i]=pos[i-1]+1;
            neg[i]=neg[i-1]+1;
        }
        else
        {
            //missing case when i=1
            pos[i]=neg[i-1]+1;
            neg[i]=neg[i-1]+1;
        }
        }
    }
    /*for(int i=0;i<n;i++)
    {
        printf("%d ",pos[i]);
    }
        for(int i=0;i<n;i++)
    {
        printf("%d ",neg[i]);
    }*/
    printf("%d",pos[n-1]);
}


#include<bits/stdc++.h>

using namespace std;
int pos[1000005];
int neg[1000005];
int main()
{
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);

    int n;
    scanf("%d",&n);
    long long arr[100005];
    for(int i=0;i<n;i++)
    scanf("%I64d",&arr[i]);
    if(arr[0]<0)
    neg[0]=0;
    else
    neg[0]=1;
    for(int i=1;i<n;i++)
    {
        if(arr[i]>0)
        {
            neg[i]=neg[i-1]+1;
            pos[i]=min(pos[i-1],neg[i-1]);
        }
        else if(arr[i]<0)
        {
            neg[i]=neg[i-1];
            pos[i]=min(pos[i-1],neg[i-1])+1;
        }
        else
        {
            pos[i]=pos[i-1]+1;
            neg[i]=neg[i-1]+1;
        }
    }
    /*for(int i=0;i<n;i++)
    {
        printf("%d ",pos[i]);
    }
        for(int i=0;i<n;i++)
    {
        printf("%d ",neg[i]);
    }*/
    printf("%d",min(pos[n-1],neg[n-1]));
}


#include<bits/stdc++.h>

using namespace std;
int pos[1000005];
int neg[1000005];
int main()
{
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);

    int n;
    scanf("%d",&n);
    long long arr[100005];
    for(int i=0;i<n;i++)
    scanf("%I64d",&arr[i]);
    if(arr[0]<0)
    pos[0]=0;
    else if(arr[0]>0)
    neg[0]=1;
    else
    {
      pos[0]=1;
      neg[0]=1;
    }
    for(int i=1;i<n;i++)
    {
        if(arr[i]>0)
        {
            neg[i]=neg[i-1]+1;
            pos[i]=min(pos[i-1],neg[i-1]);
        }
        else if(arr[i]<0)
        {
            neg[i]=neg[i-1];
            pos[i]=min(pos[i-1],neg[i-1])+1;
        }
        else
        {
            pos[i]=pos[i-1]+1;
            neg[i]=neg[i-1]+1;
        }
    }
    /*for(int i=0;i<n;i++)
    {
        printf("%d ",pos[i]);
    }
        for(int i=0;i<n;i++)
    {
        printf("%d ",neg[i]);
    }*/
    printf("%d",min(pos[n-1],neg[n-1]));
}


#include<fstream>
#include<iostream>
#include<string>
#include<map>
#include<cmath>
#include<algorithm>
#include<vector>
#include<list>
#include<set>
#include<cstring>
#include<climits>
#include<deque>
#include<stack>

#define PI 3.14159265
#define MOD 1000000007
#define LL long long

using namespace std ;

#define cin F
#define cout G

ifstream F("input.txt") ;
ofstream G("output.txt") ;

LL gcd(LL a, LL b);
//ABx * BCy - ABy * BCx
LL cross_prod(LL ax, LL ay, LL bx, LL by, LL cx, LL cy) ;
LL sum_digit(LL A) ;
LL get_mask(LL x) ;
LL get_nr(string &S, int pos, int lg) ;
class SegmentTree {
public:
    vector<int> V ;
    void init(int dim) ;
    int query(int start, int end, int pos, int node) ;
    void build(int start, int end, int node) ;
} ;

/**************************************************************************/

vector< int > V1, V2 ;
int N ;

int main() {
    int i, neg = 0, pos = 0, minn = INT_MAX ;
    cin >> N ;
    V1.resize(N + 2) ;
    V2.resize(N + 2) ;
    for (i = 1; i <= N; ++i) {
        cin >> V2[i] ;
        if (V2[i] < 0) {
            ++neg ;
        }
        V1[i] = i - neg ;
    }
    minn = V1[N] ;
    for (i = N; i; --i) {
        if (V2[i] <= 0) {
            ++pos ;
        }
        minn = min(minn, pos + V1[i - 1]) ;
    }
    cout << minn ;
   cout.close() ;
   cin.close() ;
    return 0 ;
}

/**************************************************************************/

LL gcd(LL a, LL b) {
    return (b ? gcd(b, a % b) : a) ;
}

LL cross_prod(LL ax, LL ay, LL bx, LL by, LL cx, LL cy) {
    return (bx - ax) * (cy - ay)  - (by - ay) *(cx - ax) ;
}

LL sum_digit(LL A) {
    LL sum = 0 ;
    do {
        sum += A % 10 ;
        A /= 10 ;
    } while (A) ;
    return sum ;
}

LL get_mask(LL x) {
    LL mask = 0, c ;
    while (x) {
        c = x % 10 ;
        x /= 10 ;
        if (c == 4 || c == 7) {
            mask = mask * 10 + c ;
        }
    }
    return mask ;
}

void SegmentTree::init(int dim) {
    V.resize((dim  + 1) << 2) ;
}
void SegmentTree::build(int start, int end, int node) {
    V[node] = end - start + 1 ;
    if (start == end) {
         return ;
    }
    int mid ;
    mid = (start + end) >> 1 ;
    build (start, mid, (node << 1)) ;
    build (mid + 1, end, ((node << 1) | 1)) ;
}
int SegmentTree::query(int start, int end, int pos, int node) {
    --V[node] ;
     if (start == end) return end ;
     int L, R ;
     L = node << 1 ;
     R = L | 1 ;
     int mid ;
     mid = (start + end) >> 1 ;
     if (pos <= V[L]) {
        return query(start, mid, pos, L) ;
     }
     else {
         return query(mid + 1, end, pos - V[L], R) ;
     }
}

LL get_nr(string &S, int pos, int lg) {
    LL nr = 0 ;
    while (lg) {
        nr = nr * 10 + (S[pos] - '0') ;
        ++pos;
        --lg ;
    }
    return nr ;
}


#include<fstream>
#include<iostream>
#include<string>
#include<map>
#include<cmath>
#include<algorithm>
#include<vector>
#include<list>
#include<set>
#include<cstring>
#include<climits>
#include<deque>
#include<stack>

#define PI 3.14159265
#define MOD 1000000007
#define LL long long

using namespace std ;

#define cin F
#define cout G

ifstream F("input.txt") ;
ofstream G("output.txt") ;

LL gcd(LL a, LL b);
//ABx * BCy - ABy * BCx
LL cross_prod(LL ax, LL ay, LL bx, LL by, LL cx, LL cy) ;
LL sum_digit(LL A) ;
LL get_mask(LL x) ;
LL get_nr(string &S, int pos, int lg) ;
class SegmentTree {
public:
    vector<int> V ;
    void init(int dim) ;
    int query(int start, int end, int pos, int node) ;
    void build(int start, int end, int node) ;
} ;

/**************************************************************************/

vector< int > V1, V2 ;
int N ;

int main() {
    int i, r = 0, neg = 0, pos = 0, minn = INT_MAX, nrz = 0 ;
    cin >> N ;
    V1.resize(N + 2) ;
    V2.resize(N + 2) ;
    for (i = 1; i <= N; ++i) {
        cin >> V1[i] ;
    }
    if (V1[1] >= 0) {
        ++r ;
    }
    if (V1[N] <= 0) {
        ++r ;
    }
    for (i = 2; i < N; ++i) {
        if (V1[i] < 0) {
            ++neg ;
        }
        V2[i] = i - neg - 1 ;
    }
    minn = r + V2[N - 1] ;
    for (i = N - 1; i > 1; --i) {
        if (V1[i] <= 0) {
            ++pos ;
        }
        minn = min( minn, r + pos + V2[i-1]) ;
    }
    cout << minn ;
   cout.close() ;
   cin.close() ;
    return 0 ;
}

/**************************************************************************/

LL gcd(LL a, LL b) {
    return (b ? gcd(b, a % b) : a) ;
}

LL cross_prod(LL ax, LL ay, LL bx, LL by, LL cx, LL cy) {
    return (bx - ax) * (cy - ay)  - (by - ay) *(cx - ax) ;
}

LL sum_digit(LL A) {
    LL sum = 0 ;
    do {
        sum += A % 10 ;
        A /= 10 ;
    } while (A) ;
    return sum ;
}

LL get_mask(LL x) {
    LL mask = 0, c ;
    while (x) {
        c = x % 10 ;
        x /= 10 ;
        if (c == 4 || c == 7) {
            mask = mask * 10 + c ;
        }
    }
    return mask ;
}

void SegmentTree::init(int dim) {
    V.resize((dim  + 1) << 2) ;
}
void SegmentTree::build(int start, int end, int node) {
    V[node] = end - start + 1 ;
    if (start == end) {
         return ;
    }
    int mid ;
    mid = (start + end) >> 1 ;
    build (start, mid, (node << 1)) ;
    build (mid + 1, end, ((node << 1) | 1)) ;
}
int SegmentTree::query(int start, int end, int pos, int node) {
    --V[node] ;
     if (start == end) return end ;
     int L, R ;
     L = node << 1 ;
     R = L | 1 ;
     int mid ;
     mid = (start + end) >> 1 ;
     if (pos <= V[L]) {
        return query(start, mid, pos, L) ;
     }
     else {
         return query(mid + 1, end, pos - V[L], R) ;
     }
}

LL get_nr(string &S, int pos, int lg) {
    LL nr = 0 ;
    while (lg) {
        nr = nr * 10 + (S[pos] - '0') ;
        ++pos;
        --lg ;
    }
    return nr ;
}


#include<fstream>
#include<iostream>
#include<string>
#include<map>
#include<cmath>
#include<algorithm>
#include<vector>
#include<list>
#include<set>
#include<cstring>
#include<climits>
#include<deque>
#include<stack>

#define PI 3.14159265
#define MOD 1000000007
#define LL long long

using namespace std ;

#define cin F
#define cout G

ifstream F("input.txt") ;
ofstream G("output.txt") ;

LL gcd(LL a, LL b);
//ABx * BCy - ABy * BCx
LL cross_prod(LL ax, LL ay, LL bx, LL by, LL cx, LL cy) ;
LL sum_digit(LL A) ;
LL get_mask(LL x) ;
LL get_nr(string &S, int pos, int lg) ;
class SegmentTree {
public:
    vector<int> V ;
    void init(int dim) ;
    int query(int start, int end, int pos, int node) ;
    void build(int start, int end, int node) ;
} ;

/**************************************************************************/

vector< int > V1, V2 ;
int N ;

int main() {
    int i, neg = 0, pos = 0, minn = INT_MAX ;
    cin >> N ;
    V1.resize(N + 1) ;
    V2.resize(N + 1) ;
    for (i = 1; i <= N; ++i) {
        cin >> V2[i] ;
        if (V2[i] < 0) {
            ++neg ;
        }
        V1[i] = i - neg ;
    }
    for (i = N; i; --i) {
        if (V2[i] < 0) {
            ++pos ;
        }
        minn = min(minn, pos + V1[i - 1]) ;
    }
    cout << minn ;
    cout.close() ;
    cin.close() ;
    return 0 ;
}

/**************************************************************************/

LL gcd(LL a, LL b) {
    return (b ? gcd(b, a % b) : a) ;
}

LL cross_prod(LL ax, LL ay, LL bx, LL by, LL cx, LL cy) {
    return (bx - ax) * (cy - ay)  - (by - ay) *(cx - ax) ;
}

LL sum_digit(LL A) {
    LL sum = 0 ;
    do {
        sum += A % 10 ;
        A /= 10 ;
    } while (A) ;
    return sum ;
}

LL get_mask(LL x) {
    LL mask = 0, c ;
    while (x) {
        c = x % 10 ;
        x /= 10 ;
        if (c == 4 || c == 7) {
            mask = mask * 10 + c ;
        }
    }
    return mask ;
}

void SegmentTree::init(int dim) {
    V.resize((dim  + 1) << 2) ;
}
void SegmentTree::build(int start, int end, int node) {
    V[node] = end - start + 1 ;
    if (start == end) {
         return ;
    }
    int mid ;
    mid = (start + end) >> 1 ;
    build (start, mid, (node << 1)) ;
    build (mid + 1, end, ((node << 1) | 1)) ;
}
int SegmentTree::query(int start, int end, int pos, int node) {
    --V[node] ;
     if (start == end) return end ;
     int L, R ;
     L = node << 1 ;
     R = L | 1 ;
     int mid ;
     mid = (start + end) >> 1 ;
     if (pos <= V[L]) {
        return query(start, mid, pos, L) ;
     }
     else {
         return query(mid + 1, end, pos - V[L], R) ;
     }
}

LL get_nr(string &S, int pos, int lg) {
    LL nr = 0 ;
    while (lg) {
        nr = nr * 10 + (S[pos] - '0') ;
        ++pos;
        --lg ;
    }
    return nr ;
}


#include<fstream>
#include<iostream>
#include<string>
#include<map>
#include<cmath>
#include<algorithm>
#include<vector>
#include<list>
#include<set>
#include<cstring>
#include<climits>
#include<deque>
#include<stack>

#define PI 3.14159265
#define MOD 1000000007
#define LL long long

using namespace std ;

#define cin F
#define cout G

ifstream F("input.txt") ;
ofstream G("output.txt") ;

LL gcd(LL a, LL b);
//ABx * BCy - ABy * BCx
LL cross_prod(LL ax, LL ay, LL bx, LL by, LL cx, LL cy) ;
LL sum_digit(LL A) ;
LL get_mask(LL x) ;
LL get_nr(string &S, int pos, int lg) ;
class SegmentTree {
public:
    vector<int> V ;
    void init(int dim) ;
    int query(int start, int end, int pos, int node) ;
    void build(int start, int end, int node) ;
} ;

/**************************************************************************/

vector< int > V1, V2 ;
int N ;

int main() {
    int i, neg = 0, pos = 0, minn = INT_MAX ;
    cin >> N ;
    V1.resize(N + 1) ;
    V2.resize(N + 1) ;
    for (i = 1; i <= N; ++i) {
        scanf("%d", &V2[i]) ;
        if (V2[i] < 0) {
            ++neg ;
        }
        V1[i] = i - neg ;
    }
    for (i = N; i; --i) {
        if (V2[i] < 0) {
            ++pos ;
        }
        minn = min(minn, pos + V1[i - 1]) ;
    }
    cout << minn ;
    return 0 ;
}

/**************************************************************************/

LL gcd(LL a, LL b) {
    return (b ? gcd(b, a % b) : a) ;
}

LL cross_prod(LL ax, LL ay, LL bx, LL by, LL cx, LL cy) {
    return (bx - ax) * (cy - ay)  - (by - ay) *(cx - ax) ;
}

LL sum_digit(LL A) {
    LL sum = 0 ;
    do {
        sum += A % 10 ;
        A /= 10 ;
    } while (A) ;
    return sum ;
}

LL get_mask(LL x) {
    LL mask = 0, c ;
    while (x) {
        c = x % 10 ;
        x /= 10 ;
        if (c == 4 || c == 7) {
            mask = mask * 10 + c ;
        }
    }
    return mask ;
}

void SegmentTree::init(int dim) {
    V.resize((dim  + 1) << 2) ;
}
void SegmentTree::build(int start, int end, int node) {
    V[node] = end - start + 1 ;
    if (start == end) {
         return ;
    }
    int mid ;
    mid = (start + end) >> 1 ;
    build (start, mid, (node << 1)) ;
    build (mid + 1, end, ((node << 1) | 1)) ;
}
int SegmentTree::query(int start, int end, int pos, int node) {
    --V[node] ;
     if (start == end) return end ;
     int L, R ;
     L = node << 1 ;
     R = L | 1 ;
     int mid ;
     mid = (start + end) >> 1 ;
     if (pos <= V[L]) {
        return query(start, mid, pos, L) ;
     }
     else {
         return query(mid + 1, end, pos - V[L], R) ;
     }
}

LL get_nr(string &S, int pos, int lg) {
    LL nr = 0 ;
    while (lg) {
        nr = nr * 10 + (S[pos] - '0') ;
        ++pos;
        --lg ;
    }
    return nr ;
}


#include<fstream>
#include<iostream>
#include<string>
#include<map>
#include<cmath>
#include<algorithm>
#include<vector>
#include<list>
#include<set>
#include<cstring>
#include<climits>
#include<deque>
#include<stack>

#define PI 3.14159265
#define MOD 1000000007
#define LL long long

using namespace std ;

#define cin F
#define cout G

ifstream F("input.txt") ;
ofstream G("output.txt") ;

LL gcd(LL a, LL b);
//ABx * BCy - ABy * BCx
LL cross_prod(LL ax, LL ay, LL bx, LL by, LL cx, LL cy) ;
LL sum_digit(LL A) ;
LL get_mask(LL x) ;
LL get_nr(string &S, int pos, int lg) ;
class SegmentTree {
public:
    vector<int> V ;
    void init(int dim) ;
    int query(int start, int end, int pos, int node) ;
    void build(int start, int end, int node) ;
} ;

/**************************************************************************/

vector< int > V1, V2 ;
int N ;

int main() {
    int i, neg = 0, pos = 0, minn = INT_MAX ;
    cin >> N ;
    V1.resize(N + 2) ;
    V2.resize(N + 2) ;
    for (i = 1; i <= N; ++i) {
        cin >> V2[i] ;
        if (V2[i] < 0) {
            ++neg ;
        }
        V1[i] = i - neg ;
    }
    for (i = N + 1; i; --i) {
        if (V2[i] < 0) {
            ++pos ;
        }
        minn = min(minn, pos + V1[i - 1]) ;
    }
    cout << minn ;
    cout.close() ;
    cin.close() ;
    return 0 ;
}

/**************************************************************************/

LL gcd(LL a, LL b) {
    return (b ? gcd(b, a % b) : a) ;
}

LL cross_prod(LL ax, LL ay, LL bx, LL by, LL cx, LL cy) {
    return (bx - ax) * (cy - ay)  - (by - ay) *(cx - ax) ;
}

LL sum_digit(LL A) {
    LL sum = 0 ;
    do {
        sum += A % 10 ;
        A /= 10 ;
    } while (A) ;
    return sum ;
}

LL get_mask(LL x) {
    LL mask = 0, c ;
    while (x) {
        c = x % 10 ;
        x /= 10 ;
        if (c == 4 || c == 7) {
            mask = mask * 10 + c ;
        }
    }
    return mask ;
}

void SegmentTree::init(int dim) {
    V.resize((dim  + 1) << 2) ;
}
void SegmentTree::build(int start, int end, int node) {
    V[node] = end - start + 1 ;
    if (start == end) {
         return ;
    }
    int mid ;
    mid = (start + end) >> 1 ;
    build (start, mid, (node << 1)) ;
    build (mid + 1, end, ((node << 1) | 1)) ;
}
int SegmentTree::query(int start, int end, int pos, int node) {
    --V[node] ;
     if (start == end) return end ;
     int L, R ;
     L = node << 1 ;
     R = L | 1 ;
     int mid ;
     mid = (start + end) >> 1 ;
     if (pos <= V[L]) {
        return query(start, mid, pos, L) ;
     }
     else {
         return query(mid + 1, end, pos - V[L], R) ;
     }
}

LL get_nr(string &S, int pos, int lg) {
    LL nr = 0 ;
    while (lg) {
        nr = nr * 10 + (S[pos] - '0') ;
        ++pos;
        --lg ;
    }
    return nr ;
}


#include<fstream>
#include<iostream>
#include<string>
#include<map>
#include<cmath>
#include<algorithm>
#include<vector>
#include<list>
#include<set>
#include<cstring>
#include<climits>
#include<deque>
#include<stack>

#define PI 3.14159265
#define MOD 1000000007
#define LL long long

using namespace std ;

#define cin F
#define cout G

ifstream F("input.txt") ;
ofstream G("output.txt") ;

LL gcd(LL a, LL b);
//ABx * BCy - ABy * BCx
LL cross_prod(LL ax, LL ay, LL bx, LL by, LL cx, LL cy) ;
LL sum_digit(LL A) ;
LL get_mask(LL x) ;
LL get_nr(string &S, int pos, int lg) ;
class SegmentTree {
public:
    vector<int> V ;
    void init(int dim) ;
    int query(int start, int end, int pos, int node) ;
    void build(int start, int end, int node) ;
} ;

/**************************************************************************/

vector< int > V1, V2 ;
int N ;

int main() {
    int i, neg = 0, pos = 0, minn = INT_MAX ;
    scanf("%d", &N) ;
    V1.resize(N + 1) ;
    V2.resize(N + 1) ;
    for (i = 1; i <= N; ++i) {
        scanf("%d", &V2[i]) ;
        if (V2[i] < 0) {
            ++neg ;
        }
        V1[i] = i - neg ;
    }
    for (i = N; i; --i) {
        if (V2[i] < 0) {
            ++pos ;
        }
        minn = min(minn, pos + V1[i - 1]) ;
    }
    cout << minn ;
    cout.close() ;
    cin.close() ;
    return 0 ;
}

/**************************************************************************/

LL gcd(LL a, LL b) {
    return (b ? gcd(b, a % b) : a) ;
}

LL cross_prod(LL ax, LL ay, LL bx, LL by, LL cx, LL cy) {
    return (bx - ax) * (cy - ay)  - (by - ay) *(cx - ax) ;
}

LL sum_digit(LL A) {
    LL sum = 0 ;
    do {
        sum += A % 10 ;
        A /= 10 ;
    } while (A) ;
    return sum ;
}

LL get_mask(LL x) {
    LL mask = 0, c ;
    while (x) {
        c = x % 10 ;
        x /= 10 ;
        if (c == 4 || c == 7) {
            mask = mask * 10 + c ;
        }
    }
    return mask ;
}

void SegmentTree::init(int dim) {
    V.resize((dim  + 1) << 2) ;
}
void SegmentTree::build(int start, int end, int node) {
    V[node] = end - start + 1 ;
    if (start == end) {
         return ;
    }
    int mid ;
    mid = (start + end) >> 1 ;
    build (start, mid, (node << 1)) ;
    build (mid + 1, end, ((node << 1) | 1)) ;
}
int SegmentTree::query(int start, int end, int pos, int node) {
    --V[node] ;
     if (start == end) return end ;
     int L, R ;
     L = node << 1 ;
     R = L | 1 ;
     int mid ;
     mid = (start + end) >> 1 ;
     if (pos <= V[L]) {
        return query(start, mid, pos, L) ;
     }
     else {
         return query(mid + 1, end, pos - V[L], R) ;
     }
}

LL get_nr(string &S, int pos, int lg) {
    LL nr = 0 ;
    while (lg) {
        nr = nr * 10 + (S[pos] - '0') ;
        ++pos;
        --lg ;
    }
    return nr ;
}


#include<fstream>
#include<iostream>
#include<string>
#include<map>
#include<cmath>
#include<algorithm>
#include<vector>
#include<list>
#include<set>
#include<cstring>
#include<climits>
#include<deque>
#include<stack>

#define PI 3.14159265
#define MOD 1000000007
#define LL long long

using namespace std ;

#define cin F
#define cout G

ifstream F("input.txt") ;
ofstream G("output.txt") ;

LL gcd(LL a, LL b);
//ABx * BCy - ABy * BCx
LL cross_prod(LL ax, LL ay, LL bx, LL by, LL cx, LL cy) ;
LL sum_digit(LL A) ;
LL get_mask(LL x) ;
LL get_nr(string &S, int pos, int lg) ;
class SegmentTree {
public:
    vector<int> V ;
    void init(int dim) ;
    int query(int start, int end, int pos, int node) ;
    void build(int start, int end, int node) ;
} ;

/**************************************************************************/

vector< int > V1, V2 ;
int N ;

int main() {
    int i, neg = 0, pos = 0, minn = INT_MAX, nrz = 0 ;
    cin >> N ;
    V1.resize(N + 2) ;
    V2.resize(N + 2) ;
    for (i = 1; i <= N; ++i) {
        cin >> V2[i] ;
        if (V2[i] < 0) {
            ++neg ;
        }
        if (V2[i] == 0) {
            ++nrz ;
        }
        V1[i] = i - neg ;
    }
    minn = V1[N] ;
    for (i = N; i; --i) {
        if (V2[i] <= 0) {
            ++pos ;
        }
        minn = min(minn, pos + V1[i - 1]) ;
    }
    if (minn == nrz + neg && neg) ++minn ;
    cout << minn ;
    cout.close() ;
    cin.close() ;
    return 0 ;
}

/**************************************************************************/

LL gcd(LL a, LL b) {
    return (b ? gcd(b, a % b) : a) ;
}

LL cross_prod(LL ax, LL ay, LL bx, LL by, LL cx, LL cy) {
    return (bx - ax) * (cy - ay)  - (by - ay) *(cx - ax) ;
}

LL sum_digit(LL A) {
    LL sum = 0 ;
    do {
        sum += A % 10 ;
        A /= 10 ;
    } while (A) ;
    return sum ;
}

LL get_mask(LL x) {
    LL mask = 0, c ;
    while (x) {
        c = x % 10 ;
        x /= 10 ;
        if (c == 4 || c == 7) {
            mask = mask * 10 + c ;
        }
    }
    return mask ;
}

void SegmentTree::init(int dim) {
    V.resize((dim  + 1) << 2) ;
}
void SegmentTree::build(int start, int end, int node) {
    V[node] = end - start + 1 ;
    if (start == end) {
         return ;
    }
    int mid ;
    mid = (start + end) >> 1 ;
    build (start, mid, (node << 1)) ;
    build (mid + 1, end, ((node << 1) | 1)) ;
}
int SegmentTree::query(int start, int end, int pos, int node) {
    --V[node] ;
     if (start == end) return end ;
     int L, R ;
     L = node << 1 ;
     R = L | 1 ;
     int mid ;
     mid = (start + end) >> 1 ;
     if (pos <= V[L]) {
        return query(start, mid, pos, L) ;
     }
     else {
         return query(mid + 1, end, pos - V[L], R) ;
     }
}

LL get_nr(string &S, int pos, int lg) {
    LL nr = 0 ;
    while (lg) {
        nr = nr * 10 + (S[pos] - '0') ;
        ++pos;
        --lg ;
    }
    return nr ;
}


#include<fstream>
#include<iostream>
#include<string>
#include<map>
#include<cmath>
#include<algorithm>
#include<vector>
#include<list>
#include<set>
#include<cstring>
#include<climits>
#include<deque>
#include<stack>

#define PI 3.14159265
#define MOD 1000000007
#define LL long long

using namespace std ;

#define cin F
#define cout G

ifstream F("input.txt") ;
ofstream G("output.txt") ;

LL gcd(LL a, LL b);
//ABx * BCy - ABy * BCx
LL cross_prod(LL ax, LL ay, LL bx, LL by, LL cx, LL cy) ;
LL sum_digit(LL A) ;
LL get_mask(LL x) ;
LL get_nr(string &S, int pos, int lg) ;
class SegmentTree {
public:
    vector<int> V ;
    void init(int dim) ;
    int query(int start, int end, int pos, int node) ;
    void build(int start, int end, int node) ;
} ;

/**************************************************************************/

vector< int > V1, V2 ;
int N ;

int main() {
    int i, neg = 0, pos = 0, minn = INT_MAX ;
    scanf("%d", &N) ;
    V1.resize(N + 1) ;
    V2.resize(N + 1) ;
    for (i = 1; i <= N; ++i) {
        scanf("%d", &V2[i]) ;
        if (V2[i] < 0) {
            ++neg ;
        }
        V1[i] = i - neg ;
    }
    for (i = N; i; --i) {
        if (V2[i] < 0) {
            ++pos ;
        }
        minn = min(minn, pos + V1[i - 1]) ;
    }
    cout << minn ;
    return 0 ;
}

/**************************************************************************/

LL gcd(LL a, LL b) {
    return (b ? gcd(b, a % b) : a) ;
}

LL cross_prod(LL ax, LL ay, LL bx, LL by, LL cx, LL cy) {
    return (bx - ax) * (cy - ay)  - (by - ay) *(cx - ax) ;
}

LL sum_digit(LL A) {
    LL sum = 0 ;
    do {
        sum += A % 10 ;
        A /= 10 ;
    } while (A) ;
    return sum ;
}

LL get_mask(LL x) {
    LL mask = 0, c ;
    while (x) {
        c = x % 10 ;
        x /= 10 ;
        if (c == 4 || c == 7) {
            mask = mask * 10 + c ;
        }
    }
    return mask ;
}

void SegmentTree::init(int dim) {
    V.resize((dim  + 1) << 2) ;
}
void SegmentTree::build(int start, int end, int node) {
    V[node] = end - start + 1 ;
    if (start == end) {
         return ;
    }
    int mid ;
    mid = (start + end) >> 1 ;
    build (start, mid, (node << 1)) ;
    build (mid + 1, end, ((node << 1) | 1)) ;
}
int SegmentTree::query(int start, int end, int pos, int node) {
    --V[node] ;
     if (start == end) return end ;
     int L, R ;
     L = node << 1 ;
     R = L | 1 ;
     int mid ;
     mid = (start + end) >> 1 ;
     if (pos <= V[L]) {
        return query(start, mid, pos, L) ;
     }
     else {
         return query(mid + 1, end, pos - V[L], R) ;
     }
}

LL get_nr(string &S, int pos, int lg) {
    LL nr = 0 ;
    while (lg) {
        nr = nr * 10 + (S[pos] - '0') ;
        ++pos;
        --lg ;
    }
    return nr ;
}


#include<fstream>
#include<iostream>
#include<string>
#include<map>
#include<cmath>
#include<algorithm>
#include<vector>
#include<list>
#include<set>
#include<cstring>
#include<climits>
#include<deque>
#include<stack>

#define PI 3.14159265
#define MOD 1000000007
#define LL long long

using namespace std ;

#define cin F
#define cout G

ifstream F("input.txt") ;
ofstream G("output.txt") ;

LL gcd(LL a, LL b);
//ABx * BCy - ABy * BCx
LL cross_prod(LL ax, LL ay, LL bx, LL by, LL cx, LL cy) ;
LL sum_digit(LL A) ;
LL get_mask(LL x) ;
LL get_nr(string &S, int pos, int lg) ;
class SegmentTree {
public:
    vector<int> V ;
    void init(int dim) ;
    int query(int start, int end, int pos, int node) ;
    void build(int start, int end, int node) ;
} ;

/**************************************************************************/

vector< int > V1, V2 ;
int N ;

int main() {
    int i, neg = 0, pos = 0, minn = INT_MAX ;
    cin >> N ;
    V1.resize(N + 2) ;
    V2.resize(N + 2) ;
    for (i = 1; i <= N; ++i) {
        cin >> V2[i] ;
        if (V2[i] < 0) {
            ++neg ;
        }
        V1[i] = i - neg ;
    }
    for (i = N + 1; i; --i) {
        if (V2[i] <= 0) {
            ++pos ;
        }
        minn = min(minn, pos + V1[i - 1]) ;
    }
    cout << minn ;
   cout.close() ;
   cin.close() ;
    return 0 ;
}

/**************************************************************************/

LL gcd(LL a, LL b) {
    return (b ? gcd(b, a % b) : a) ;
}

LL cross_prod(LL ax, LL ay, LL bx, LL by, LL cx, LL cy) {
    return (bx - ax) * (cy - ay)  - (by - ay) *(cx - ax) ;
}

LL sum_digit(LL A) {
    LL sum = 0 ;
    do {
        sum += A % 10 ;
        A /= 10 ;
    } while (A) ;
    return sum ;
}

LL get_mask(LL x) {
    LL mask = 0, c ;
    while (x) {
        c = x % 10 ;
        x /= 10 ;
        if (c == 4 || c == 7) {
            mask = mask * 10 + c ;
        }
    }
    return mask ;
}

void SegmentTree::init(int dim) {
    V.resize((dim  + 1) << 2) ;
}
void SegmentTree::build(int start, int end, int node) {
    V[node] = end - start + 1 ;
    if (start == end) {
         return ;
    }
    int mid ;
    mid = (start + end) >> 1 ;
    build (start, mid, (node << 1)) ;
    build (mid + 1, end, ((node << 1) | 1)) ;
}
int SegmentTree::query(int start, int end, int pos, int node) {
    --V[node] ;
     if (start == end) return end ;
     int L, R ;
     L = node << 1 ;
     R = L | 1 ;
     int mid ;
     mid = (start + end) >> 1 ;
     if (pos <= V[L]) {
        return query(start, mid, pos, L) ;
     }
     else {
         return query(mid + 1, end, pos - V[L], R) ;
     }
}

LL get_nr(string &S, int pos, int lg) {
    LL nr = 0 ;
    while (lg) {
        nr = nr * 10 + (S[pos] - '0') ;
        ++pos;
        --lg ;
    }
    return nr ;
}


#include<algorithm>
#include<iostream>
#include<cstdio>
#include<vector>
#include<fstream>
#include<iomanip>
#include<bitset>
#include<deque>
#include<queue>
#include<string>
#include<map>
#include<cstring>
#include<sstream>
#include<cmath>
#include<cassert>
using namespace std;

int main()
{
	int n;
	scanf("%d", &n);
	cout << n << endl;
	int arr[n];
	for (int i = 0; i < n; i++)
		scanf("%d", &arr[i]);
	for (int i = 0; i < n; i++)
		printf("%d ", arr[i]);
	printf("\n");
	// int minus[n];
	// int plus[n];
	// int zero[n];
	// minus[0] = plus[0] = zero[0] = 0;
	// if (arr[0] == 0)
	// 	zero[0] = 1;
	// else if (arr[0] > 0)
	// 	plus[0] = 1;
	// else
	// 	minus[0] = 1;
	// for (int i = 1; i < n; i++)
	// {
	// 	if (arr[i] == 0)
	// 	{
	// 		zero[i] = zero[i-1]+1;
	// 		plus[i] = plus[i-1];
	// 		minus[i] = minus[i-1];
	// 	}
	// 	else if (arr[i] > 0)
	// 	{
	// 		zero[i] = zero[i-1];
	// 		plus[i] = plus[i-1]+1;
	// 		minus[i] = minus[i-1];
	// 	}
	// 	else
	// 	{
	// 		zero[i] = zero[i-1];
	// 		plus[i] = plus[i-1];
	// 		minus[i] = minus[i-1]+1;
	// 	}
	// }
	// for (int i = 0; i < n; i++)
	// 	printf("%d ", zero[i]);
	// printf("\n");
	// for (int i = 0; i < n; i++)
	// 	printf("%d ", plus[i]);
	// printf("\n");
	// for (int i = 0; i < n; i++)
	// 	printf("%d ", minus[i]);
	// printf("\n");
	// int min = n;
	// for (int i = 0; i < n-1; i++)
	// {
	// 	int change = zero[i]+plus[i]+zero[n-1]-zero[i]+minus[n-1]-minus[i];
	// 	if (change < min)
	// 		min = change;
	// }
	//printf("%d\n", min);
	return 0;
}


#include<algorithm>
#include<iostream>
#include<cstdio>
#include<vector>
#include<fstream>
#include<iomanip>
#include<bitset>
#include<deque>
#include<queue>
#include<string>
#include<map>
#include<cstring>
#include<sstream>
#include<cmath>
#include<cassert>
using namespace std;

int main()
{
	int n;
	cin >> n;
	int arr[n];
	for (int i = 0; i < n; i++)
		cin >> arr[i];
	int minus[n];
	int plus[n];
	int zero[n];
	minus[0] = plus[0] = zero[0] = 0;
	if (arr[0] == 0)
		zero[0] = 1;
	else if (arr[0] > 0)
		plus[0] = 1;
	else
		minus[0] = 1;
	for (int i = 1; i < n; i++)
	{
		if (arr[i] == 0)
		{
			zero[i] = zero[i-1]+1;
			plus[i] = plus[i-1];
			minus[i] = minus[i-1];
		}
		else if (arr[i] > 0)
		{
			zero[i] = zero[i-1];
			plus[i] = plus[i-1]+1;
			minus[i] = minus[i-1];
		}
		else
		{
			zero[i] = zero[i-1];
			plus[i] = plus[i-1];
			minus[i] = minus[i-1]+1;
		}
	}
	int min = n;
	for (int i = 0; i < n-1; i++)
	{
		int change = zero[i]+plus[i]+zero[n-1]-zero[i]+minus[n-1]-minus[i];
		if (change < min)
			min = change;
	}
	printf("%d\n", min);
	return 0;
}


#include<algorithm>
#include<iostream>
#include<cstdio>
#include<vector>
#include<fstream>
#include<iomanip>
#include<bitset>
#include<deque>
#include<queue>
#include<string>
#include<map>
#include<cstring>
#include<sstream>
#include<cmath>
#include<cassert>
using namespace std;

int main()
{
	int n;
	scanf("%d", &n);
	int arr[n];
	for (int i = 0; i < n; i++)
		scanf("%d", &arr[i]);
	for (int i = 0; i < n; i++)
		printf("%d ", arr[i]);
	printf("\n");
	int minus[n];
	int plus[n];
	int zero[n];
	minus[0] = plus[0] = zero[0] = 0;
	if (arr[0] == 0)
		zero[0] = 1;
	else if (arr[0] > 0)
		plus[0] = 1;
	else
		minus[0] = 1;
	for (int i = 1; i < n; i++)
	{
		if (arr[i] == 0)
		{
			zero[i] = zero[i-1]+1;
			plus[i] = plus[i-1];
			minus[i] = minus[i-1];
		}
		else if (arr[i] > 0)
		{
			zero[i] = zero[i-1];
			plus[i] = plus[i-1]+1;
			minus[i] = minus[i-1];
		}
		else
		{
			zero[i] = zero[i-1];
			plus[i] = plus[i-1];
			minus[i] = minus[i-1]+1;
		}
	}
	for (int i = 0; i < n; i++)
		printf("%d ", zero[i]);
	printf("\n");
	for (int i = 0; i < n; i++)
		printf("%d ", plus[i]);
	printf("\n");
	for (int i = 0; i < n; i++)
		printf("%d ", minus[i]);
	printf("\n");
	int min = n;
	for (int i = 0; i < n-1; i++)
	{
		int change = zero[i]+plus[i]+zero[n-1]-zero[i]+minus[n-1]-minus[i];
		if (change < min)
			min = change;
	}
	printf("%d\n", min);
	return 0;
}


#include<algorithm>
#include<iostream>
#include<cstdio>
#include<vector>
#include<fstream>
#include<iomanip>
#include<bitset>
#include<deque>
#include<queue>
#include<string>
#include<map>
#include<cstring>
#include<sstream>
#include<cmath>
#include<cassert>
using namespace std;

int main()
{
	int n;
	cin >> n;
	int arr[n];
	for (int i = 0; i < n; i++)
		cin >> arr[i];
	int minus[n];
	int plus[n];
	int zero[n];
	minus[0] = plus[0] = zero[0] = 0;
	if (arr[0] == 0)
		zero[0] = 1;
	else if (arr[0] > 0)
		plus[0] = 1;
	else
		minus[0] = 1;
	for (int i = 1; i < n; i++)
	{
		if (arr[i] == 0)
		{
			zero[i] = zero[i-1]+1;
			plus[i] = plus[i-1];
			minus[i] = minus[i-1];
		}
		else if (arr[i] > 0)
		{
			zero[i] = zero[i-1];
			plus[i] = plus[i-1]+1;
			minus[i] = minus[i-1];
		}
		else
		{
			zero[i] = zero[i-1];
			plus[i] = plus[i-1];
			minus[i] = minus[i-1]+1;
		}
	}
	for (int i = 0; i < n; i++)
		printf("%d ", zero[i]);
	printf("\n");
	for (int i = 0; i < n; i++)
		printf("%d ", plus[i]);
	printf("\n");
	for (int i = 0; i < n; i++)
		printf("%d ", minus[i]);
	printf("\n");
	int min = n;
	for (int i = 0; i < n-1; i++)
	{
		int change = zero[i]+plus[i]+zero[n-1]-zero[i]+minus[n-1]-minus[i];
		if (change < min)
			min = change;
	}
	printf("%d\n", min);
	return 0;
}


#include<algorithm>
#include<iostream>
#include<cstdio>
#include<vector>
#include<fstream>
#include<iomanip>
#include<bitset>
#include<deque>
#include<queue>
#include<string>
#include<map>
#include<cstring>
#include<sstream>
#include<cmath>
#include<cassert>
using namespace std;

int main()
{
	FILE *fp_in = fopen("input.txt", "r");
	FILE *fp_out = fopen("output.txt", "w");
	int n;
	fscanf(fp_in, "%d", &n);
	int arr[n];
	for (int i = 0; i < n; i++)
		fscanf(fp_in, "%d", &arr[i]);
	int minus[n];
	int plus[n];
	int zero[n];
	minus[0] = plus[0] = zero[0] = 0;
	if (arr[0] == 0)
		zero[0] = 1;
	else if (arr[0] > 0)
		plus[0] = 1;
	else
		minus[0] = 1;
	for (int i = 1; i < n; i++)
	{
		if (arr[i] == 0)
		{
			zero[i] = zero[i-1]+1;
			plus[i] = plus[i-1];
			minus[i] = minus[i-1];
		}
		else if (arr[i] > 0)
		{
			zero[i] = zero[i-1];
			plus[i] = plus[i-1]+1;
			minus[i] = minus[i-1];
		}
		else
		{
			zero[i] = zero[i-1];
			plus[i] = plus[i-1];
			minus[i] = minus[i-1]+1;
		}
	}
	for (int i = 0; i < n; i++)
		printf("%d ", zero[i]);
	printf("\n");
	for (int i = 0; i < n; i++)
		printf("%d ", plus[i]);
	printf("\n");
	for (int i = 0; i < n; i++)
		printf("%d ", minus[i]);
	printf("\n");
	int min = n;
	for (int i = 0; i < n-1; i++)
	{
		int change = zero[i]+plus[i]+zero[n-1]-zero[i]+minus[n-1]-minus[i];
		if (change < min)
			min = change;
	}
	fprintf(fp_out, "%d\n", min);
	return 0;
}


#include<algorithm>
#include<iostream>
#include<cstdio>
#include<vector>
#include<fstream>
#include<iomanip>
#include<bitset>
#include<deque>
#include<queue>
#include<string>
#include<map>
#include<cstring>
#include<sstream>
#include<cmath>
#include<cassert>
using namespace std;

int main()
{
	int n;
	scanf("%d", &n);
	int arr[n];
	for (int i = 0; i < n; i++)
		scanf("%d", &arr[i]);
	for (int i = 0; i < n; i++)
		printf("%d ", arr[i]);
	printf("\n");
	// int minus[n];
	// int plus[n];
	// int zero[n];
	// minus[0] = plus[0] = zero[0] = 0;
	// if (arr[0] == 0)
	// 	zero[0] = 1;
	// else if (arr[0] > 0)
	// 	plus[0] = 1;
	// else
	// 	minus[0] = 1;
	// for (int i = 1; i < n; i++)
	// {
	// 	if (arr[i] == 0)
	// 	{
	// 		zero[i] = zero[i-1]+1;
	// 		plus[i] = plus[i-1];
	// 		minus[i] = minus[i-1];
	// 	}
	// 	else if (arr[i] > 0)
	// 	{
	// 		zero[i] = zero[i-1];
	// 		plus[i] = plus[i-1]+1;
	// 		minus[i] = minus[i-1];
	// 	}
	// 	else
	// 	{
	// 		zero[i] = zero[i-1];
	// 		plus[i] = plus[i-1];
	// 		minus[i] = minus[i-1]+1;
	// 	}
	// }
	// for (int i = 0; i < n; i++)
	// 	printf("%d ", zero[i]);
	// printf("\n");
	// for (int i = 0; i < n; i++)
	// 	printf("%d ", plus[i]);
	// printf("\n");
	// for (int i = 0; i < n; i++)
	// 	printf("%d ", minus[i]);
	// printf("\n");
	// int min = n;
	// for (int i = 0; i < n-1; i++)
	// {
	// 	int change = zero[i]+plus[i]+zero[n-1]-zero[i]+minus[n-1]-minus[i];
	// 	if (change < min)
	// 		min = change;
	// }
	//printf("%d\n", min);
	return 0;
}


#include<algorithm>
#include<iostream>
#include<cstdio>
#include<vector>
#include<fstream>
#include<iomanip>
#include<bitset>
#include<deque>
#include<queue>
#include<string>
#include<map>
#include<cstring>
#include<sstream>
#include<cmath>
#include<cassert>
using namespace std;

int main()
{
	int n;
	scanf("%d", &n);
	int arr[n];
	for (int i = 0; i < n; i++)
		scanf("%d", &arr[i]);
	for (int i = 0; i < n; i++)
		printf("%d ", arr[i]);
	printf("\n");
	// int minus[n];
	// int plus[n];
	// int zero[n];
	// minus[0] = plus[0] = zero[0] = 0;
	// if (arr[0] == 0)
	// 	zero[0] = 1;
	// else if (arr[0] > 0)
	// 	plus[0] = 1;
	// else
	// 	minus[0] = 1;
	// for (int i = 1; i < n; i++)
	// {
	// 	if (arr[i] == 0)
	// 	{
	// 		zero[i] = zero[i-1]+1;
	// 		plus[i] = plus[i-1];
	// 		minus[i] = minus[i-1];
	// 	}
	// 	else if (arr[i] > 0)
	// 	{
	// 		zero[i] = zero[i-1];
	// 		plus[i] = plus[i-1]+1;
	// 		minus[i] = minus[i-1];
	// 	}
	// 	else
	// 	{
	// 		zero[i] = zero[i-1];
	// 		plus[i] = plus[i-1];
	// 		minus[i] = minus[i-1]+1;
	// 	}
	// }
	// for (int i = 0; i < n; i++)
	// 	printf("%d ", zero[i]);
	// printf("\n");
	// for (int i = 0; i < n; i++)
	// 	printf("%d ", plus[i]);
	// printf("\n");
	// for (int i = 0; i < n; i++)
	// 	printf("%d ", minus[i]);
	// printf("\n");
	// int min = n;
	// for (int i = 0; i < n-1; i++)
	// {
	// 	int change = zero[i]+plus[i]+zero[n-1]-zero[i]+minus[n-1]-minus[i];
	// 	if (change < min)
	// 		min = change;
	// }
	printf("%d\n", min);
	return 0;
}


#include<algorithm>
#include<iostream>
#include<cstdio>
#include<vector>
#include<fstream>
#include<iomanip>
#include<bitset>
#include<deque>
#include<queue>
#include<string>
#include<map>
#include<cstring>
#include<sstream>
#include<cmath>
#include<cassert>
using namespace std;

int main()
{
	int n;
	cin >> n;
	int arr[n];
	for (int i = 0; i < n; i++)
		cin >> arr[i];
	int minus[n];
	int plus[n];
	int zero[n];
	minus[0] = plus[0] = zero[0] = 0;
	if (arr[0] == 0)
		zero[0] = 1;
	else if (arr[0] > 0)
		plus[0] = 1;
	else
		minus[0] = 1;
	for (int i = 1; i < n; i++)
	{
		if (arr[i] == 0)
		{
			zero[i] = zero[i-1]+1;
			plus[i] = plus[i-1];
			minus[i] = minus[i-1];
		}
		else if (arr[i] > 0)
		{
			zero[i] = zero[i-1];
			plus[i] = plus[i-1]+1;
			minus[i] = minus[i-1];
		}
		else
		{
			zero[i] = zero[i-1];
			plus[i] = plus[i-1];
			minus[i] = minus[i-1]+1;
		}
	}
	int ans = n;
	for (int i = 0; i < n-1; i++)
	{
		int change = zero[i]+plus[i]+zero[n-1]-zero[i]+minus[n-1]-minus[i];
		if (change < ans)
			ans = change;
	}
	printf("%d\n", ans);
	return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<vector>
#include<queue>
#include<map>
#include<stack>
#include<algorithm>

using namespace std;
//#pragma comment(linker,"/STACK:1000000000,1000000000")

#define LL long long

const int INF=0x3f3f3f3f;
const int N=100005;
int a[N];
int Lnum[N];
int Rnum[N];
int main()
{
    //freopen("data.txt","r",stdin);
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=0;i<n;++i)
        scanf("%d",&a[i]);
        Lnum[0]=0;
        for(int i=1;i<n;++i)
        {
            Lnum[i]=Lnum[i-1];
            if(a[i-1]>=0)
            ++Lnum[i];
        }
        Rnum[n-1]=0;
        for(int i=n-2;i>=0;--i)
        {
            Rnum[i]=Rnum[i+1];
            if(a[i+1]<=0)
            ++Rnum[i];
        }
        int ans=n;
        for(int i=1;i<n-1;++i)
        {
            ans=min(ans,Lnum[i]+Rnum[i]);
        }
        if(a[0]>=0)
        ans=min(ans,1+Rnum[0]);
        else
        ans=min(ans,Rnum[0]);
        if(a[n-1]<=0)
        ans=min(ans,1+Lnum[n-1]);
        else
        ans=min(ans,Lnum[n-1]);
        printf("%d\n",ans);
    }
    return 0;
}


//#pragma comment(linker,"/STACK:327680000,327680000")
#include <iostream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <cstring>
#include <algorithm>
#include <string>
#include <set>
#include <functional>
#include <numeric>
#include <sstream>
#include <stack>
#include <map>
#include <queue>

#define CL(arr, val) memset(arr, val, sizeof(arr))
#define REP(i, n)for((i) = 0; (i) < (n); ++(i))
#define FOR(i, l, h)for((i) = (l); (i) <= (h); ++(i))
#define FORD(i, h, l)for((i) = (h); (i) >= (l); --(i))
#define L(x)(x) << 1
#define R(x)(x) << 1 | 1
#define MID(l, r)(l + r) >> 1
#define Min(x, y)x < y ? x : y
#define Max(x, y)x < y ? y : x
#define E(x)(1 << (x))
#define iabs(x) (x) < 0 ? -(x) : (x)
#define OUT(x)printf("%I64d\n", x)
#define lowbit(x)(x)&(-x)
#define Read()freopen("data.in", "r", stdin)
#define Write()freopen("data.out", "w", stdout);

const double eps = 1e-8;
typedef long long LL;
const int inf = ~0u>>2;

using namespace std;

const int  N = 100010;

int dl[N], dr[N];
int num[N];

int main() {
   // freopen("data.in", "r", stdin);

    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);

    int n, i, ans;
    while(~scanf("%d", &n)) {
        for(i = 1; i <= n; ++i) {
            scanf("%d", num + i);
        }
        dl[0] = 0;
        for(i = 1; i <= n; ++i) {
            if(num[i] >= 0) dl[i] = dl[i-1] + 1;
            else    dl[i] = dl[i-1];
        }
        dr[n+1] = 0;
        for(i = n; i >= 1; --i) {
            if(num[i] <= 0) dr[i] = dr[i+1] + 1;
            else    dr[i] = dr[i+1];
        }
        ans = inf;
        for(i = 1; i < n; ++i) {
            ans = min(ans, dl[i] + dr[i+1]);
        }
        printf("%d\n", ans);
    }
    return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<vector>
#include<queue>
#include<map>
#include<stack>
#include<algorithm>

using namespace std;
//#pragma comment(linker,"/STACK:1000000000,1000000000")

#define LL long long

const int INF=0x3f3f3f3f;
const int N=100005;
int a[N];
int Lnum[N];
int Rnum[N];
int main()
{
    //freopen("data.txt","r",stdin);
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=0;i<n;++i)
        scanf("%d",&a[i]);
        Lnum[0]=0;
        for(int i=1;i<n;++i)
        {
            Lnum[i]=Lnum[i-1];
            if(a[i-1]>=0)
            ++Lnum[i];
        }
        Rnum[n-1]=0;
        for(int i=n-2;i>=0;--i)
        {
            Rnum[i]=Rnum[i+1];
            if(a[i+1]<=0)
            ++Rnum[i];
        }
        int ans=n;
        for(int i=0;i<n;++i)
        {
            ans=min(ans,Lnum[i]+Rnum[i]);
        }
        printf("%d\n",ans);
    }
    return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<vector>
#include<queue>
#include<map>
#include<stack>
#include<algorithm>

using namespace std;
//#pragma comment(linker,"/STACK:1000000000,1000000000")

#define LL long long

const int INF=0x3f3f3f3f;
const int N=100005;
int a[N];
int Lnum[N];
int Rnum[N];
int main()
{
    //freopen("data.txt","r",stdin);
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=0;i<n;++i)
        scanf("%d",&a[i]);
        Lnum[0]=0;
        for(int i=1;i<n;++i)
        {
            Lnum[i]=Lnum[i-1];
            if(a[i-1]>=0)
            ++Lnum[i];
        }
        Rnum[n-1]=0;
        for(int i=n-2;i>=0;--i)
        {
            Rnum[i]=Rnum[i+1];
            if(a[i+1]<=0)
            ++Rnum[i];
        }
        int ans=n;
        for(int i=1;i<n-1;++i)
        {
            if(a[i]==0)
            ans=min(ans,Lnum[i]+Rnum[i]+1);
            else
            ans=min(ans,Lnum[i]+Rnum[i]);
        }
        if(a[0]>=0)
        ans=min(ans,1+Rnum[0]);
        else
        ans=min(ans,Rnum[0]);
        if(a[n-1]<=0)
        ans=min(ans,1+Lnum[n-1]);
        else
        ans=min(ans,Lnum[n-1]);
        printf("%d\n",ans);
    }
    return 0;
}


#include <iostream>

using namespace std;

int MIN(int x, int y)
{
	if (y < x)
		return y;
	else
		return x;
}

int main()
{
	int n;
	cin >> n;
	int a[100001];
	for (int i = 0; i < n; i++)
		cin >> a[i];
	int t = 0;
	if (a[0] == 0)
	{
		a[0] = -1;
		t = 1;
	}
	int min = 1000000;
	int otr, pol;
	for (int i = 1; i < n - 1; i++)
	{
		if (a[i] <= 0)
		{
			otr = 1;
			pol = 0;
		}
		else if (a[i] >= 0)
		{
			otr = 0;
			pol = 1;
		}
		for (int j = i - 1; j >= 0; j--)
			if (a[j] >= 0)
				pol++;
		for (int j = i + 1; j < n; j++)
			if(a[j]	<=	0)
				otr++;
		if (min > (otr + pol - 1))
			min = (otr + pol - 1);
	}

	cout << min + t;

	return 0;
}


#include <iostream>
#include <fstream>

using namespace std;

int MIN(int x, int y)
{
	if (y < x)
		return y;
	else
		return x;
}

int main()
{
	ifstream in("input.txt");
	ofstream out("output.txt");
	int n;
	in >> n;
	int a[100001] ={0};
	for (int i = 0; i < n; i++)
		in >> a[i];
	int t = 0;
	if (a[0] == 0)
	{
		a[0] = -1;
		t = 1;
	}
	if (a[n-1] <= 0)
	{
		t++;
		a[n-1] = 1;
	}
	int min = 1000000;
	int otr = 0, pol = 0;
	for (int i = 1; i < n ; i++)
	{
		if (a[i] < 0)
		{
			otr = 1;
			pol = 0;
		}
		else if (a[i] > 0)
		{
			otr = 0;
			pol = 1;
		} else{
					otr = 1;
					pol = 1;
				}
		for (int j = i - 1; j >= 0; j--)
			if (a[j] >= 0)
				pol++;
		for (int j = i + 1; j < n; j++)
			if(a[j]	<=	0)
				otr++;
		if (min > (otr + pol - 1))
			min = (otr + pol - 1);
	}

	out << min + t;

	return 0;
}


#include <iostream>
#include <fstream>

using namespace std;

int MIN(int x, int y)
{
	if (y < x)
		return y;
	else
		return x;
}

int main()
{
	ifstream in("input.txt");
	ofstream out("output.txt");
	int n;
	in >> n;
	int a[100001];
	for (int i = 0; i < n; i++)
		in >> a[i];
	/*int t = 0;
	if (a[0] == 0)
	{
		a[0] = -1;
		t = 1;
	}*/
	int min = 1000000;
	int otr, pol;
	for (int i = 1; i < n - 1; i++)
	{
		if (a[i] <= 0)
		{
			otr = 1;
			pol = 0;
		}
		else if (a[i] >= 0)
		{
			otr = 0;
			pol = 1;
		}
		for (int j = i - 1; j >= 0; j--)
			if (a[j] >= 0)
				pol++;
		for (int j = i + 1; j < n; j++)
			if(a[j]	<=	0)
				otr++;
		if (min > (otr + pol - 1))
			min = (otr + pol - 1);
	}

	out << min ;

	return 0;
}


#include <iostream>
#include <fstream>

using namespace std;

int MIN(int x, int y)
{
	if (y < x)
		return y;
	else
		return x;
}

int main()
{
	ifstream in("input.txt");
	ofstream out("output.txt");
	int n;
	in >> n;
	int a[100001] ={0};
	for (int i = 0; i < n; i++)
		in >> a[i];
	int t = 0;
	if (a[0] == 0)
	{
		a[0] = -1;
		t = 1;
	}
	if (a[n-1] <= 0)
	{
		t++;
		a[n-1] = 1;
	}
	int min = 1000000;
	int otr = 0, pol = 0;
	for (int i = 1; i < n ; i++)
	{
		if (a[i] < 0)
		{
			otr = 1;
			pol = 0;
		}
		else if (a[i] > 0)
		{
			otr = 0;
			pol = 1;
		} else{
					otr = 1;
					pol = 1;
				}
		for (int j = i - 1; j >= 0; j--)
			if (a[j] >= 0)
				pol++;
		for (int j = i + 1; j < n; j++)
			if(a[j]	<=	0)
				otr++;
		if (min > (otr + pol - 1))
			min = (otr + pol - 1);
		if (min == 1 || min == 0)
		{
			out << min;
			return 0;
		}
	}

	out << min + t;

	return 0;
}


#include <iostream>
#include <fstream>

using namespace std;

int MIN(int x, int y)
{
	if (y < x)
		return y;
	else
		return x;
}

int main()
{
	ifstream in("input.txt");
	ofstream out("output.txt");
	int n;
	in >> n;
	int a[100001] ={0};
	int otrs[100001] = {0};
	int poloj[100001] = {0};
	for (int i = 0; i < n; i++)
		in >> a[i];
	int otr = 0, pol = 0;
	int t = 0;
	if (a[0] >= 0)
	{
		a[0] = -1;
		t = 1;
	}
	if (a[n-1] <= 0)
	{
		t++;
		a[n-1] = 1;
	}
	int min = 1000000;
	for (int i = 0; i < n ; i++)
	{
		if (a[i] >= 0)
			pol++;
		poloj[i] = pol;
	}
	for (int i = n - 1; i >= 0; i--)
	{
		if (a[i] <= 0)
			otr++;
		otrs[i] = otr;
	}

	for (int i = 0; i < n; i++)
		if (min > otrs[i] + poloj[i] - 1)
			min = otrs[i] + poloj[i] - 1;

	out << min + t;

	return 0;
}


#include <iostream>
#include <fstream>

using namespace std;

int MIN(int x, int y)
{
	if (y < x)
		return y;
	else
		return x;
}

int main()
{
	ifstream in("input.txt");
	ofstream out("output.txt");
	int n;
	in >> n;
	int a[100001];
	for (int i = 0; i < n; i++)
		in >> a[i];
	int t = 0;
	if (a[0] == 0)
	{
		a[0] = -1;
		t = 1;
	}
	int min = 1000000;
	int otr, pol;
	for (int i = 1; i < n - 1; i++)
	{
		if (a[i] <= 0)
		{
			otr = 1;
			pol = 0;
		}
		else if (a[i] >= 0)
		{
			otr = 0;
			pol = 1;
		}
		for (int j = i - 1; j >= 0; j--)
			if (a[j] >= 0)
				pol++;
		for (int j = i + 1; j < n; j++)
			if(a[j]	<=	0)
				otr++;
		if (min > (otr + pol - 1))
			min = (otr + pol - 1);
	}

	out << min + t;

	return 0;
}


#include <iostream>
#include <fstream>

using namespace std;

int MIN(int x, int y)
{
	if (y < x)
		return y;
	else
		return x;
}

int main()
{
	ifstream in("input.txt");
	ofstream out("output.txt");
	int n;
	in >> n;
	int a[100001];
	for (int i = 0; i < n; i++)
		in >> a[i];
	int t = 0;
	if (a[0] == 0)
	{
		a[0] = -1;
		t = 1;
	}
	if (a[n-1] <= 0)
	{
		t++;
		a[n-1] = 1;
	}
	int min = 1000000;
	int otr, pol;
	for (int i = 1; i < n - 1; i++)
	{
		if (a[i] < 0)
		{
			otr = 1;
			pol = 0;
		}
		else if (a[i] > 0)
		{
			otr = 0;
			pol = 1;
		} else{
					otr = 1;
					pol = 1;
				}
		for (int j = i - 1; j >= 0; j--)
			if (a[j] >= 0)
				pol++;
		for (int j = i + 1; j < n; j++)
			if(a[j]	<=	0)
				otr++;
		if (min > (otr + pol - 1))
			min = (otr + pol - 1);
	}

	out << min + t;

	return 0;
}


#include <iostream>
#include <fstream>

using namespace std;

int MIN(int x, int y)
{
	if (y < x)
		return y;
	else
		return x;
}

int main()
{
	ifstream in("input.txt");
	ofstream out("output.txt");
	int n;
	in >> n;
	int a[100001] ={0};
	for (int i = 0; i < n; i++)
		in >> a[i];
	int t = 0;
	if (a[0] == 0)
	{
		a[0] = -1;
		t = 1;
	}
	if (a[n-1] <= 0)
	{
		t++;
		a[n-1] = 1;
	}
	int min = 1000000;
	int otr = 0, pol = 0;
	for (int i = 1; i < n ; i++)
	{
		if (a[i] < 0)
		{
			otr = 1;
			pol = 0;
		}
		else if (a[i] > 0)
		{
			otr = 0;
			pol = 1;
		} else{
					otr = 1;
					pol = 1;
				}
		for (int j = i - 1; j >= 0; j--)
			if (a[j] >= 0)
				pol++;
		for (int j = i + 1; j < n; j++)
			if(a[j]	<=	0)
				otr++;
		if (min > (otr + pol - 1))
			min = (otr + pol - 1);
		if (min == 1)
		{
			out << min;
			return 0;
		}
	}

	out << min + t;

	return 0;
}


#include <iostream>
#include <fstream>

using namespace std;

int MIN(int x, int y)
{
	if (y < x)
		return y;
	else
		return x;
}

int main()
{
	ifstream in("input.txt");
	ofstream out("output.txt");
	int n;
	in >> n;
	int a[100001] ={0};
	int otrs[100001] = {0};
	int poloj[100001] = {0};
	for (int i = 0; i < n; i++)
		in >> a[i];
	int t = 0;
	if (a[0] >= 0)
	{
		a[0] = -1;
		t = 1;
	}
	if (a[n-1] <= 0)
	{
		t++;
		a[n-1] = 1;
	}
	int min = 1000000;
	int otr = 0, pol = 0;
	for (int i = 0; i < n ; i++)
	{
		if (a[i] < 0)
		{
			otr = 1;
			pol = 0;
		}
		else if (a[i] > 0)
		{
			otr = 0;
			pol = 1;
		} else{
					otr = 1;
					pol = 1;
				}
		for (int j = i - 1; j >= 0; j--)
			if (a[j] >= 0)
				pol++;
		for (int j = i + 1; j < n; j++)
			if(a[j]	<=	0)
				otr++;
		otrs[i] = otr;
		poloj[i] = pol;
	}

	for (int i = 0; i < n; i++)
		if (min > otrs[i] + poloj[i] - 1)
			min = otrs[i] + poloj[i] - 1;

	out << min + t;

	return 0;
}


#include<iostream>
#include<fstream>
using namespace std;
int main()
{
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    int n,count1=0,count2=0,k=0,count0=0,a[100001],i,l=-1,r=1;
    cin>>n>>a[0];
    if(a[0]>=0)
    k=1;
    cin>>a[1];
    if(a[1]==0)
    count0++;
    for(i=2;i<n-1&&a[i-1]<1;i++)
    {
        cin>>a[i];
        if(a[i]==0)
        count0++;
    }
    if(i!=n-1)
    {
        //count1++;
        for(;i<n-1;i++)
        {
            cin>>a[i];
            if(a[i]==0)
            count0++;
            else if((a[i]*l)>0)
            {
                if(l<0)
                {
                    count2=count2+r;
                    //cout<<" a ";
                }
                else
                count1=count1+r;
                r=1;
                l=l*(-1);
            }
            else
            r++;
        }
    }
    if(l>0)
    count2=count2+r;
    cin>>a[i];
    if(a[i]<=0)
    k++;
    //cout<<count0<<" "<<count1<<" "<<count2<<" "<<k<<" ";
    if(count1>count2)
    cout<<count2+count0+k<<"\n";
    else
    cout<<count1+count0+k<<"\n";
    fclose(stdin);
    fclose(stdout);
}


#include<iostream>
#include<fstream>
using namespace std;
int main()
{
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    int n,count1=0,count2=0,k=0,count0=0,a[100001],i,l=-1;
    cin>>n>>a[0];
    if(a[0]>=0)
    k=1;
    cin>>a[1];
    if(a[1]==0)
    count0++;
    for(i=2;i<n-1&&a[i-1]<1;i++)
    {
        cin>>a[i];
        if(a[i]==0)
        count0++;
    }
    if(i!=n-1)
    {
        count1++;
        for(;i<n-1;i++)
        {
            cin>>a[i];
            if(a[i]==0)
            count0++;
            else if((a[i]*l)>0)
            {
                if(l<0)
                {
                    count2++;
                    //cout<<" a ";
                }
                else
                count1++;
                l=l*(-1);
            }
            else
            {
                if(l<0)
                count1++;
                else
                {
                    count2++;
                    //cout<<" b ";
                }
            }
        }
    }
    cin>>a[i];
    if(a[i]<=0)
    k++;
    //cout<<count0<<" "<<count1<<" "<<count2<<" "<<k<<" ";
    if(count1>count2)
    cout<<count2+count0+k<<"\n";
    else
    cout<<count1+count0+k<<"\n";
}


#include<iostream>
#include<fstream>
using namespace std;
int main()
{
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    int n,a[100001],b[100001]={0},c[100001]={0},k=0,i=0,count0=0,count=0;
    cin>>n;
    for(;i<n;i++)
    {
        cin>>a[i];
        if(a[i]==0)
        count0++;
    }
    if(a[0]>0)
    k++;
    if(a[n-1]<0)
    k++;
    for(i=2;i<n;i++)
    {
        if(a[i-1]>0)
        b[i]=b[i-1]+1;
        else
        b[i]=b[i-1];
    }
    for(i=n-3;i>0;i--)
    {
        if(a[i+1]<0)
        c[i]=c[i+1]+1;
        else
        c[i]=c[i+1];
    }
    //i--;
    count=b[1]+c[1];
    for(i=2;i<n-1;i++)
    {
        //i--;
        int l=b[i]+c[i];
        if(l<count)
        count=l;
    }
    //cout<<count<<" "<<count0<<" "<<k<<" ";
    cout<<count+count0+k<<endl;
    fclose(stdin);
    fclose(stdout);
}


#include<iostream>
#include<fstream>
using namespace std;
int main()
{
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    int n,a[100001],b[100001]={0},c[100001]={0},k=0,i=0,count0=0,count=0;
    cin>>n;
    for(;i<n;i++)
    {
        cin>>a[i];
        if(a[i]==0)
        count0++;
    }
    if(a[0]>0)
    k++;
    if(a[--i]<0)
    k++;
    i--;
    while(i>1)
    {
        if(a[i]<0)
        b[--i]=b[i]+1;
        else
        b[--i]=b[i];
    }
    while(i<n-1)
    {
        if(a[i]>0)
        b[++i]=b[i]+1;
        else
        b[++i]=b[i];
    }
    i--;
    count=b[i]+c[i];
    while(i>1)
    {
        i--;
        int l=b[i]+c[i];
        if(l<count)
        count=l;
    }
    cout<<count+count0+k<<endl;
    fclose(stdin);
    fclose(stdout);
}


#include<iostream>
#include<fstream>
using namespace std;
int main()
{
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    int n,count1=0,count2=0,k=0,count0=0,a[100001],i,l=-1,r=1;
    cin>>n>>a[0];
    if(a[0]>=0)
    k=1;
    cin>>a[1];
    if(a[1]==0)
    count0++;
    for(i=2;i<n-1&&a[i-1]<1;i++)
    {
        cin>>a[i];
        if(a[i]==0)
        count0++;
    }
    if(i!=n-1)
    {
        //count1++;
        for(;i<n-1;i++)
        {
            cin>>a[i];
            if(a[i]==0)
            count0++;
            else if((a[i]*l)>0)
            {
                if(l<0)
                {
                    count1=count1+r;
                    //cout<<" a ";
                }
                else
                count2=count2+r;
                r=1;
                l=l*(-1);
            }
            else
            r++;
        }
    }
    if(l>0)
    count2=count2+r;
    cin>>a[i];
    if(a[i]<=0)
    k++;
    //cout<<count0<<" "<<count1<<" "<<count2<<" "<<k<<" ";
    if(count1>count2)
    cout<<count2+count0+k<<"\n";
    else
    cout<<count1+count0+k<<"\n";
    fclose(stdin);
    fclose(stdout);
}


#include<iostream>
#include<fstream>
using namespace std;
int main()
{
    //freopen("input.txt","r",stdin);
    //freopen("output.txt","w",stdout);
    int n,a[100001],b[100001]={0},c[100001]={0},k=0,i=0,count0=0,count=0;
    cin>>n;
    for(;i<n;i++)
    {
        cin>>a[i];
        if(a[i]==0)
        count0++;
    }
    if(a[0]>0)
    k++;
    if(a[--i]<0)
    k++;
    i--;
    while(i>1)
    {
        if(a[i]<0)
        b[--i]=b[i]+1;
        else
        b[--i]=b[i];
    }
    while(i<n-1)
    {
        if(a[i]>0)
        b[++i]=b[i]+1;
        else
        b[++i]=b[i];
    }
    i--;
    count=b[i]+c[i];
    while(i>1)
    {
        i--;
        int l=b[i]+c[i];
        if(l<count)
        count=l;
    }
    cout<<count+count0+k<<endl;
    //fclose(stdin);
    //fclose(stdout);
}


#include<bits/stdc++.h>
using namespace std;
#define INF 1000000000
int main(){
    int n;
    cin>>n;
    vector<int> v(n);
    int ans = 0;
    for (int i=0;i<n;i++)
        cin>>v[i], ans += v[i]%2;
    sort(v.begin(),v.end());
    if (v.size() == 1){
        if (v[0] == 0 || v[0]%2)
            cout<<"cslnb";
        else cout<<"sjfnb";
        return 0;
    }
    if (v[0] == v[1] && !v[0]){
        cout<<"cslnb";
        return 0;
    }
    int pairs = 0;
    for (int i=0;i<v.size()-1;i++)
        if (v[i] == v[i+1])
            pairs++;
    if (pairs > 1){
        cout<<"cslnb";
        return 0;
    }
    for (int i=1;i<v.size()-1;i++)
        if (v[i] == v[i+1] && v[i-1] + 1 == v[i]){
            cout<<"cslnb";
            return 0;
        }
    if (ans%2==0)
        cout<<"sjfnb";
    else cout<<"cslnb";
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define ll long long

int main(){
    ll n; cin>>n;
    ll arr[n];
    ll sm=0,sm2=0, z=0;
    for(ll i=0;i<n;i++){ cin>>arr[i];  sm+=arr[i]; if(arr[i]==0) z++; }
    sort(arr, arr+n);

    ll last=0;
    sm2=0;
    for(ll i=1;i<n;i++){
    if(arr[i] > last) last++;
    sm2+=last;
    }

    int c=0;
    for(int i=1;i<n;i++){ if(arr[i]==arr[i-1]) c++; }

    if(z>1 || c>1 || ((sm-sm2)%2==0) ){
        cout<<"cslnb"<<endl;
        return 0;
    }

    cout<<"sjfnb"<<endl;
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define ll long long

int main(){
    ll n; cin>>n;
    ll arr[n];
    ll sm=0,sm2=0;
    for(ll i=0;i<n;i++){ cin>>arr[i];  sm+=arr[i];}
    sort(arr, arr+n);

    ll last=1;
    sm2=0;
    for(ll i=1;i<n;i++){
    if(arr[i] > last) last++;
    sm2+=last;
    }

    int c=0;
    for(int i=1;i<n;i++){ if(arr[i]==arr[i-1]) c++; }

    if(c>1 || ((sm-sm2)%2==0) ){
        cout<<"cslnb"<<endl;
        return 0;
    }

    cout<<"sjfnb"<<endl;
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define ll long long

int main(){
    ll n; cin>>n;
    ll arr[n];
    ll sm=0,sm2=0;
    for(ll i=0;i<n;i++){ cin>>arr[i];  }
    sort(arr, arr+n);
    for(ll i=0;i<n;i++){  sm+=arr[i]; sm2+=min(arr[i], i);  }

    int c=0;
    for(int i=1;i<n;i++){ if(arr[i]==arr[i-1]) c++; }

    if(c>1 || ((sm-sm2)%2==0) ){
        cout<<"cslnb"<<endl;
        return 0;
    }

    cout<<"sjfnb"<<endl;
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define ll long long

int main(){
    ll n; cin>>n;
    ll arr[n];
    ll sm=0,sm2=0;
    for(ll i=0;i<n;i++){ cin>>arr[i]; sm+=arr[i]; sm2+=min(arr[i], i);  }
    sort(arr, arr+n);
    int c=0;
    for(int i=1;i<n;i++){ if(arr[i]==arr[i-1]) c++; }

    if(c>1 || (n==1 && arr[0]==0)){
        cout<<"cslnb"<<endl;
        return 0;
    }

    if( (sm-sm2)%2 ){
        cout<<"sjfnb"<<endl;
    }
    else cout<<"cslnb"<<endl;

    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define ll long long

int main(){
    ll n; cin>>n;
    ll arr[n];
    ll sm=0,sm2=0;
    for(ll i=0;i<n;i++){ cin>>arr[i];  sm+=arr[i];}
    sort(arr, arr+n);

    ll last=0;
    for(ll i=0;i<n;i++){
    if(arr[i] > last) last++;
    sm2+=last;
    }

    int c=0;
    for(int i=1;i<n;i++){ if(arr[i]==arr[i-1]) c++; }

    if(c>1 || ((sm-sm2)%2==0) ){
        cout<<"cslnb"<<endl;
        return 0;
    }

    cout<<"sjfnb"<<endl;
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define ll long long

int main(){
    ll n; cin>>n;
    ll arr[n];
    map<ll, ll> mp;
    ll sm=0,sm2=0, z=0;
    for(ll i=0;i<n;i++){ cin>>arr[i];  sm+=arr[i]; if(arr[i]==0) z++; mp[arr[i]]++; }
    sort(arr, arr+n);

    for(map<ll,ll>::iterator it=mp.begin();it!=mp.end() ; it++){
        ll x=it->first;
        if(mp[x]>1 && mp[x-1]>0){
              cout<<"cslnb"<<endl;
        return 0;
        }
    }

    ll last=0;
    sm2=0;
    for(ll i=1;i<n;i++){
    if(arr[i] > last) last++;
    sm2+=last;
    }

    int c=0;
    for(int i=1;i<n;i++){ if(arr[i]==arr[i-1]) c++; }

    if(z>1 || c>1 || ((sm-sm2)%2==0) ){
        cout<<"cslnb"<<endl;
        return 0;
    }

    cout<<"sjfnb"<<endl;
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define ll long long

int main(){
    ll n; cin>>n;
    ll arr[n];
    ll sm=0,sm2=0;
    for(ll i=0;i<n;i++){ cin>>arr[i];  sm+=arr[i];}
    sort(arr, arr+n);

    ll last=0;
    sm2=0;
    for(ll i=1;i<n;i++){
    if(arr[i] > last) last++;
    sm2+=last;
    }

    int c=0;
    for(int i=1;i<n;i++){ if(arr[i]==arr[i-1]) c++; }

    if(c>1 || ((sm-sm2)%2==0) ){
        cout<<"cslnb"<<endl;
        return 0;
    }

    cout<<"sjfnb"<<endl;
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define ll long long

int main(){
    ll n; cin>>n;
    ll arr[n];
    map<ll, ll> mp;
    ll sm=0,sm2=0;
    for(ll i=0;i<n;i++){ cin>>arr[i];  sm+=arr[i];  mp[arr[i]]++; }
    sort(arr, arr+n);

    for(map<ll,ll>::iterator it=mp.begin();it!=mp.end() ; it++){
        ll x=it->first;
        if(mp[x]>1 && mp[x-1]>0){
             cout<<"cslnb"<<endl;
             return 0;
        }
    }

    ll last=0;
    sm2=0;
    for(ll i=1;i<n;i++){
    if(arr[i] > last) last++;
    sm2+=last;
    }

    int c=0;
    for(int i=1;i<n;i++){ if(arr[i]==arr[i-1]) c++; }

    if(mp[0]>1 || c>1 || ((sm-sm2)%2==0) ){
        cout<<"cslnb"<<endl;
        return 0;
    }

    cout<<"sjfnb"<<endl;
    return 0;
}


#include <bits/stdc++.h>

using namespace std;
typedef long long ll ;
const int N = 2e5 + 9;
int a[N] , eq ;
ll sum;
int main() {

     int n , z = 0 ;
     cin >> n;
     for(int i = 0 ; i < n ; ++i){
        cin >> a[i];
        z+=(a[i] == 0);
     }
     sort(a , a + n);
     for(int i = 1 ; i < n ; ++i) eq+=(a[i] == a[i-1]);
     for(int i = 2 ; i < n ; ++i){
        if(a[i] == a[i-2] +1){
            cout << "cslnb";
            return 0;
        }
     }
     if(eq > 1 || z > 1  ){
        cout << "cslnb";
        return 0;
     }
     for(int i = 0 ; i < n ; ++i) sum+=(a[i] - i);
     cout << (sum & 1 ? "sjfnb" : "cslnb");

	return 0;
}


#include <bits/stdc++.h>

using namespace std;
typedef long long ll ;
const int N = 2e5 + 9;
int a[N] , eq ;
ll sum;
int main() {

     int n , z ;
     cin >> n;
     for(int i = 0 ; i < n ; ++i){
        cin >> a[i];
        z+=(a[i] == 0);
     }
     sort(a , a + n);
     for(int i = 1 ; i < n ; ++i) eq+=(a[i] == a[i-1]);
     if(eq > 1 || z > 1 ){
        cout << "cslnb";
        return 0;
     }
     for(int i = 0 ; i < n ; ++i) sum+=(a[i] - i);
     cout << (sum & 1 ? "sjfnb" : "cslnb");

	return 0;
}


#include <bits/stdc++.h>

using namespace std;
typedef long long ll ;
const int N = 2e5 + 9;
int a[N] , eq ;
ll sum;
int main() {

     int n , z = 0 ;
     cin >> n;
     for(int i = 0 ; i < n ; ++i){
        cin >> a[i];
        z+=(a[i] == 0);
     }
     sort(a , a + n);
     for(int i = 1 ; i < n ; ++i) eq+=(a[i] == a[i-1]);
     for(int i = 2 ; i < n ; ++i){
        if(a[i] == a[i-2] +1){
            cout << "cslnb";
            return 0;
        }
     }
     if(eq > 1  ){
        cout << "cslnb";
        return 0;
     }
     for(int i = 0 ; i < n ; ++i) sum+=(a[i] - i);
     cout << (sum & 1 ? "sjfnb" : "cslnb");

	return 0;
}


#include <bits/stdc++.h>

using namespace std;
typedef long long ll ;
const int N = 2e5 + 9;
int a[N] , eq ;
ll sum;
int main() {

     int n ;
     cin >> n;
     for(int i = 0 ; i < n ; ++i){
        cin >> a[i];
     }
     sort(a , a + n);
     for(int i = 1 ; i < n ; ++i) eq+=(a[i] == a[i-1]);
     if(eq > 1){
        cout << "cslnb";
        return 0;
     }
     for(int i = 0 ; i < n ; ++i) sum+=(a[i] - i);
     cout << (sum & 1 ? "sjfnb" : "cslnb");

	return 0;
}


#include <bits/stdc++.h>

using namespace std;
typedef long long ll ;
const int N = 2e5 + 9;
int a[N] , eq ;
ll sum;
int main() {

     int n , z = 0 ;
     cin >> n;
     for(int i = 0 ; i < n ; ++i){
        cin >> a[i];
        z+=(a[i] == 0);
     }
     sort(a , a + n);
     for(int i = 1 ; i < n ; ++i) eq+=(a[i] == a[i-1]);
     for(int i = 2 ; i < n ; ++i){
        if(a[i] == a[i-1] && a[i] == a[i-2] +1){
            cout << "cslnb";
            return 0;
        }
     }
     if(eq > 1 || z > 1  ){
        cout << "cslnb";
        return 0;
     }
     for(int i = 0 ; i < n ; ++i) sum+=(a[i] - i);
     cout << (sum & 1 ? "sjfnb" : "cslnb");

	return 0;
}


#include <bits/stdc++.h>

using namespace std;
typedef long long ll ;
const int N = 2e5 + 9;
int a[N] ;
ll sum;
int main() {

     int n ;
     cin >> n;
     for(int i = 0 ; i < n ; ++i){
        cin >> a[i];
     }
     sort(a , a + n);
     for(int i = 0 ; i < n ; ++i) sum+=(a[i] - i);
     cout << (sum & 1 ? "sjfnb" : "cslnb");

	return 0;
}


#include <bits/stdc++.h>

using namespace std;
typedef long long ll ;
const int N = 2e5 + 9;
int a[N] , eq ;
ll sum;
int main() {

     int n , z = 0 ;
     cin >> n;
     for(int i = 0 ; i < n ; ++i){
        cin >> a[i];
        z+=(a[i] == 0);
     }
     sort(a , a + n);
     for(int i = 1 ; i < n ; ++i) eq+=(a[i] == a[i-1]);
     if(eq > 1  ){
        cout << "cslnb";
        return 0;
     }
     for(int i = 0 ; i < n ; ++i) sum+=(a[i] - i);
     cout << (sum & 1 ? "sjfnb" : "cslnb");

	return 0;
}


#include <bits/stdc++.h>

using namespace std;
typedef long long ll ;
const int N = 2e5 + 9;
int a[N] , eq ;
ll sum;
int main() {

     int n , z = 0 ;
     cin >> n;
     for(int i = 0 ; i < n ; ++i){
        cin >> a[i];
        z+=(a[i] == 0);
     }
     sort(a , a + n);
     for(int i = 1 ; i < n ; ++i) eq+=(a[i] == a[i-1]);
     for(int i = 2 ; i < n ; ++i){
        if(a[i-1] == a[i-2]){
            cout << "cslnb";
            return 0;
        }
     }
     if(eq > 1  ){
        cout << "cslnb";
        return 0;
     }
     for(int i = 0 ; i < n ; ++i) sum+=(a[i] - i);
     cout << (sum & 1 ? "sjfnb" : "cslnb");

	return 0;
}


/*

 * This code is written by Sanskar Agarwal

*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

#define ll long long
typedef tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
#define PII pair<int,int>
#define PLL pair<ll,ll>
#define VPLL vector<PLL>
#define VPII vector<PII>
#define PQ priority_queue<PLL,VPLL, greater<PLL> >
#define PQI priority_queue<PII,VPII,greater<PII> >
#define S second
#define F first
#define PB push_back

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #endif

    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    ll n;cin>>n;
    ll a[n],i;
    unordered_map<ll,ll> mp;
    for(i=0;i<n;i++)
    {
        cin>>a[i];
        mp[a[i]]++;
    }
    bool flag=true;
    if(mp[0]>1)
        flag=false;
    for(auto it=mp.begin();it!=mp.end();it++)
    {
        if(it->S > 2) {
            flag=false;
            break;
        }
    }
    if(flag==false) {
        cout << "cslnb";
        return 0;
    }
    sort(a,a+n);
    ll maxi=0;
    ll cnt=a[0]-0;
    for(i=1;i<n;i++)
    {
        if(a[i]<=maxi)
            continue;
        if(a[i]==maxi+1) {
            maxi++;
            continue;
        }
        cnt+=a[i]-maxi-1;
        maxi++;
    }
    // cout << cnt << " ";
    if(cnt%2==0) {
        cout << "cslnb";
    } else {
        cout << "sjfnb";
    }

    #ifndef ONLINE_JUDGE
        cout<<"\nTime Elapsed : " << 1.0*clock() / CLOCKS_PER_SEC << " s\n";
    #endif
    return 0;
}


/*

 * This code is written by Sanskar Agarwal

*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

#define ll long long
typedef tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
#define PII pair<int,int>
#define PLL pair<ll,ll>
#define VPLL vector<PLL>
#define VPII vector<PII>
#define PQ priority_queue<PLL,VPLL, greater<PLL> >
#define PQI priority_queue<PII,VPII,greater<PII> >
#define S second
#define F first
#define PB push_back

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #endif

    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    ll n;cin>>n;
    ll a[n],i,ccnt=0;
    unordered_map<ll,ll> mp;
    for(i=0;i<n;i++)
    {
        cin>>a[i];
        mp[a[i]]++;
    }
    bool flag=true;
    if(mp[0]>1)
        flag=false;
    for(auto it=mp.begin();it!=mp.end();it++)
    {
        if(it->S > 2) {
            flag=false;
            break;
        } else if(it->S == 2)
        ccnt++;
    }
    if(flag==false||ccnt>1) {
        cout << "cslnb";
        return 0;
    }
    sort(a,a+n);
    ll maxi=0;
    ll cnt=a[0]-0;
    for(i=1;i<n;i++)
    {
        if(a[i]<=maxi)
            continue;
        if(a[i]==maxi+1) {
            maxi++;
            continue;
        }
        cnt+=a[i]-maxi-1;
        maxi++;
    }
    // cout << cnt << " ";
    if(cnt%2==0) {
        cout << "cslnb";
    } else {
        cout << "sjfnb";
    }

    #ifndef ONLINE_JUDGE
        cout<<"\nTime Elapsed : " << 1.0*clock() / CLOCKS_PER_SEC << " s\n";
    #endif
    return 0;
}


/*

 * This code is written by Sanskar Agarwal

*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

#define ll long long
typedef tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
#define PII pair<int,int>
#define PLL pair<ll,ll>
#define VPLL vector<PLL>
#define VPII vector<PII>
#define PQ priority_queue<PLL,VPLL, greater<PLL> >
#define PQI priority_queue<PII,VPII,greater<PII> >
#define UMLL unordered_map<ll,ll>
#define UMII unordered_map<int,int>
#define S second
#define F first
#define PB push_back

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #endif

    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    ll n;cin>>n;
    ll a[n],i,ccnt=0;
    unordered_map<ll,ll> mp;
    for(i=0;i<n;i++)
    {
        cin>>a[i];
        mp[a[i]]++;
    }
    bool flag=true;
    if(mp[0]>1)
        flag=false;
    for(auto it=mp.begin();it!=mp.end();it++)
    {
        if(it->S > 2) {
            flag=false;
            break;
        } else if(it->S == 2) {
            ccnt++;
            int prev=it->F;
            prev--;
            if(mp.find(prev)!=mp.end())
            {
                if(mp[prev]>0)
                {
                    flag=false;
                    break;
                }
            }
        }
    }
    if(flag==false||ccnt>1) {
        cout << "cslnb";
        return 0;
    }
    sort(a,a+n);
    ll maxi=0;
    ll cnt=a[0]-0;
    for(i=1;i<n;i++)
    {
        if(a[i]<=maxi)
            continue;
        if(a[i]==maxi+1) {
            maxi++;
            continue;
        }
        cnt+=a[i]-maxi-1;
        maxi++;
    }
    // cout << cnt << " ";
    if(cnt%2==0) {
        cout << "cslnb";
    } else {
        cout << "sjfnb";
    }

    #ifndef ONLINE_JUDGE
        cout<<"\nTime Elapsed : " << 1.0*clock() / CLOCKS_PER_SEC << " s\n";
    #endif
    return 0;
}


/*

 * This code is written by Sanskar Agarwal

*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

#define ll long long
typedef tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
#define PII pair<int,int>
#define PLL pair<ll,ll>
#define VPLL vector<PLL>
#define VPII vector<PII>
#define PQ priority_queue<PLL,VPLL, greater<PLL> >
#define PQI priority_queue<PII,VPII,greater<PII> >
#define UMLL unordered_map<ll,ll>
#define UMII unordered_map<int,int>
#define S second
#define F first
#define PB push_back

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #endif

    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    ll n;cin>>n;
    ll a[n],i,ccnt=0;
    unordered_map<ll,ll> mp;
    for(i=0;i<n;i++)
    {
        cin>>a[i];
        mp[a[i]]++;
    }
    bool flag=true;
    if(mp[0]>1)
        flag=false;
    for(auto it=mp.begin();it!=mp.end();it++)
    {
        if(it->S > 2) {
            flag=false;
            break;
        } else if(it->S == 2) {
            ccnt++;
            if(mp[it->F - 1]>0)
            {
                flag=false;
                break;
            }
        }
    }
    if(flag==false||ccnt>1) {
        cout << "cslnb";
        return 0;
    }
    sort(a,a+n);
    ll maxi=0;
    ll cnt=a[0]-0;
    for(i=1;i<n;i++)
    {
        if(a[i]<=maxi)
            continue;
        if(a[i]==maxi+1) {
            maxi++;
            continue;
        }
        cnt+=a[i]-maxi-1;
        maxi++;
    }
    // cout << cnt << " ";
    if(cnt%2==0) {
        cout << "cslnb";
    } else {
        cout << "sjfnb";
    }

    #ifndef ONLINE_JUDGE
        cout<<"\nTime Elapsed : " << 1.0*clock() / CLOCKS_PER_SEC << " s\n";
    #endif
    return 0;
}


ll n;cin>>n;
    ll a[n],i,ccnt=0;
    unordered_map<ll,ll> mp;
    for(i=0;i<n;i++)
    {
        cin>>a[i];
        mp[a[i]]++;
    }
    bool flag=true;
    if(mp[0]>1)
        flag=false;
    for(auto it=mp.begin();it!=mp.end();it++)
    {
        if(it->S > 2) {
            flag=false;
            break;
        } else if(it->S == 2)
        ccnt++;
    }
    if(flag==false||ccnt>1) {
        cout << "cslnb";
        return 0;
    }
    sort(a,a+n);
    ll maxi=0;
    ll cnt=a[0]-0;
    for(i=1;i<n;i++)
    {
        if(a[i]<=maxi)
            continue;
        if(a[i]==maxi+1) {
            maxi++;
            continue;
        }
        cnt+=a[i]-maxi-1;
        maxi++;
    }
    // cout << cnt << " ";
    if(cnt%2==0) {
        cout << "cslnb";
    } else {
        cout << "sjfnb";
    }


/*

 * This code is written by Sanskar Agarwal

*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

#define ll long long
typedef tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
#define PII pair<int,int>
#define PLL pair<ll,ll>
#define VPLL vector<PLL>
#define VPII vector<PII>
#define PQ priority_queue<PLL,VPLL, greater<PLL> >
#define PQI priority_queue<PII,VPII,greater<PII> >
#define S second
#define F first
#define PB push_back

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #endif

    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    ll n;cin>>n;
    ll a[n],i;
    unordered_map<ll,ll> mp;
    for(i=0;i<n;i++)
    {
        cin>>a[i];
        mp[a[i]]++;
    }
    bool flag=true;
    if(mp[0]>1)
        flag=false;
    for(auto it=mp.begin();it!=mp.end();it++)
    {
        if(it->S > 2) {
            flag=false;
            break;
        }
    }
    if(flag==false) {
        cout << "cslnb";
        return 0;
    }
    sort(a,a+n);
    ll maxi=0;
    ll cnt=a[0]-0;
    for(i=1;i<n;i++)
    {
        if(a[i]==maxi+1)
            continue;
        cnt+=a[i]-maxi-1;
        maxi++;
    }
    // cout << cnt << " ";
    if(cnt%2==0) {
        cout << "cslnb";
    } else {
        cout << "sjfnb";
    }

    #ifndef ONLINE_JUDGE
        cout<<"\nTime Elapsed : " << 1.0*clock() / CLOCKS_PER_SEC << " s\n";
    #endif
    return 0;
}


/*

 * This code is written by Sanskar Agarwal

*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

#define ll long long
typedef tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
#define PII pair<int,int>
#define PLL pair<ll,ll>
#define VPLL vector<PLL>
#define VPII vector<PII>
#define PQ priority_queue<PLL,VPLL, greater<PLL> >
#define PQI priority_queue<PII,VPII,greater<PII> >
#define UMLL unordered_map<ll,ll>
#define UMII unordered_map<int,int>
#define S second
#define F first
#define PB push_back

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #endif

    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    ll n;cin>>n;
    ll a[n],i,ccnt=0;
    unordered_map<ll,ll> mp;
    for(i=0;i<n;i++)
    {
        cin>>a[i];
        mp[a[i]]++;
    }
    bool flag=true;
    if(mp[0]>1)
        flag=false;
    for(auto it=mp.begin();it!=mp.end();it++)
    {
        if(it->S > 2) {
            flag=false;
            break;
        } else if(it->S == 2) {
            ccnt++;
            int prev=it->F;
            prev--;
            if(mp.find(prev)!=mp.end())
            {
            	if(mp[prev]>1)
            	{
	                flag=false;
	                break;
	            }
            }
        }
    }
    if(flag==false||ccnt>1) {
        cout << "cslnb";
        return 0;
    }
    sort(a,a+n);
    ll maxi=0;
    ll cnt=a[0]-0;
    for(i=1;i<n;i++)
    {
        if(a[i]<=maxi)
            continue;
        if(a[i]==maxi+1) {
            maxi++;
            continue;
        }
        cnt+=a[i]-maxi-1;
        maxi++;
    }
    // cout << cnt << " ";
    if(cnt%2==0) {
        cout << "cslnb";
    } else {
        cout << "sjfnb";
    }

    #ifndef ONLINE_JUDGE
        cout<<"\nTime Elapsed : " << 1.0*clock() / CLOCKS_PER_SEC << " s\n";
    #endif
    return 0;
}


#include<bits/stdc++.h>
#define int long long
//#define test_
#define MP make_pair
#define pb push_back
#define S second
#define F first
#define sz(x) (int)(x).size()
#define all(x) (x).begin(),(x).end()
#define __IO ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
#define pii pair<int,int>
#define et cout<<'\n';
#define rep(i , n) for(int mm=i ; mm<n ; ++mm)
using namespace std;
vector<int> v;
int sum;
map<int,int> mp;
signed main(){
//__IO
	int n; cin >> n;
	v.resize(n);
	for(int i=0 ; i<n ; ++i){
		cin >> v[i] , mp[v[i]]++;
		if(mp[v[i]] > 2) return cout << "cslnb",0;
	}
	sort(all(v));
	sum += v[0] , v[0]=0;
	sum %= 2;
	for(int i=1 ; i<v.size() ; ++i){
		sum += v[i] - v[i-1] -1;
		sum %= 2;
		v[i] = min(v[i] , i);
	}
	if(sum == 1) cout << "sjfnb";
	else cout << "cslnb";
}


#include<bits/stdc++.h>
#define int long long
//#define test_
#define MP make_pair
#define pb push_back
#define S second
#define F first
#define sz(x) (int)(x).size()
#define all(x) (x).begin(),(x).end()
#define __IO ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
#define pii pair<int,int>
#define et cout<<'\n';
#define rep(i , n) for(int mm=i ; mm<n ; ++mm)
using namespace std;
vector<int> v;
int sum;
map<int,int> mp;
signed main(){
__IO
	int n; cin >> n;
	v.resize(n);
	int duo = 0;
	for(int i=0 ; i<n ; ++i){
		cin >> v[i] , mp[v[i]]++;
		if(mp[v[i]] > 3) return cout << "cslnb",0;
	}

	for(auto &c : mp){
		if(c.S >= 2) duo++;
		if(duo >= 2) return cout << "cslnb",0;
	}

	sort(all(v));
	sum += v[0] , v[0]=0;
	sum %= 2;
	for(int i=1 ; i<v.size() ; ++i){
		sum += v[i] - v[i-1] -1;
		sum %= 2;
		v[i] = min(v[i] , i);
	}
	if(sum == 1) cout << "sjfnb";
	else cout << "cslnb";
}


#include<bits/stdc++.h>
#define int long long
//#define test_
#define MP make_pair
#define pb push_back
#define S second
#define F first
#define sz(x) (int)(x).size()
#define all(x) (x).begin(),(x).end()
#define __IO ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
#define pii pair<int,int>
#define et cout<<'\n';
#define rep(i , n) for(int mm=i ; mm<n ; ++mm)
using namespace std;
vector<int> v;
int sum;
map<int,int> mp;
signed main(){
//__IO
	int n; cin >> n;
	v.resize(n);
	for(int i=0 ; i<n ; ++i){
		cin >> v[i] , mp[v[i]]++;
		if(mp[v[i]] >= 2) return cout << "cslnb",0;
	}
	sort(all(v));
	sum += v[0] , v[0]=0;
	sum %= 2;
	for(int i=1 ; i<v.size() ; ++i){
		sum += v[i] - v[i-1] -1;
		sum %= 2;
		v[i] = min(v[i] , i);
	}
	if(sum == 1) cout << "sjfnb";
	else cout << "cslnb";
}


#include<bits/stdc++.h>
#define int long long
//#define test_
#define MP make_pair
#define pb push_back
#define S second
#define F first
#define sz(x) (int)(x).size()
#define all(x) (x).begin(),(x).end()
#define __IO ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
#define pii pair<int,int>
#define et cout<<'\n';
#define rep(i , n) for(int mm=i ; mm<n ; ++mm)
using namespace std;
vector<int> v;
int sum;
signed main(){
__IO
	int n; cin >> n;
	v.resize(n);
	for(int i=0 ; i<n ; ++i) cin >> v[i];
	sort(all(v));
	sum += v[0] , v[0]=0;
	sum %= 2;
	for(int i=1 ; i<v.size() ; ++i){
		sum += v[i] - v[i-1] -1;
		sum %= 2;
		v[i] = i;
	}
	if(sum == 1) cout << "sjfnb";
	else cout << "cslnb";
}


#include<bits/stdc++.h>
#define int long long
//#define test_
#define MP make_pair
#define pb push_back
#define S second
#define F first
#define sz(x) (int)(x).size()
#define all(x) (x).begin(),(x).end()
#define __IO ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
#define pii pair<int,int>
#define et cout<<'\n';
#define rep(i , n) for(int mm=i ; mm<n ; ++mm)
using namespace std;
vector<int> v;
int sum;
signed main(){
//__IO
	int n; cin >> n;
	v.resize(n);
	for(int i=0 ; i<n ; ++i) cin >> v[i];
	sort(all(v));
	sum += v[0] , v[0]=0;
	sum %= 2;
	for(int i=1 ; i<v.size() ; ++i){
		sum += v[i] - v[i-1] -1;
		sum %= 2;
		v[i] = min(v[i] , i);
	}
	if(sum == 1) cout << "sjfnb";
	else cout << "cslnb";
}


#include<bits/stdc++.h>
#define int long long
//#define test_
#define MP make_pair
#define pb push_back
#define S second
#define F first
#define sz(x) (int)(x).size()
#define all(x) (x).begin(),(x).end()
#define __IO ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
#define pii pair<int,int>
#define et cout<<'\n';
#define rep(i , n) for(int mm=i ; mm<n ; ++mm)
using namespace std;
vector<int> v;
int sum , duo;
map<int,int> mp;
signed main(){
__IO
	int n; cin >> n;
	v.resize(n);
	for(int i=0 ; i<n ; ++i){
		cin >> v[i] , mp[v[i]]++;
		if(mp[v[i]] >= 3) return cout << "cslnb",0;
	}
	if(mp[0] >= 2) return cout << "cslnb" , 0;
	for(auto &c : mp){
		if(c.S >= 2) duo++;
		if(duo >= 2) return cout << "cslnb",0;
		if(c.S >= 2 and mp[c.F-1]) return cout << "cslnb" , 0;
	}

	sort(all(v));
	sum += v[0] , v[0]=0;
	sum %= 2;
	for(int i=1 ; i<v.size() ; ++i){
		sum += v[i] - v[i-1] -1;
		sum %= 2;
		v[i] = min(v[i] , i);
	}
	if(sum == 1) cout << "sjfnb";
	else cout << "cslnb";
}


#include<bits/stdc++.h>
#define int long long
//#define test_
#define MP make_pair
#define pb push_back
#define S second
#define F first
#define sz(x) (int)(x).size()
#define all(x) (x).begin(),(x).end()
#define __IO ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
#define pii pair<int,int>
#define et cout<<'\n';
#define rep(i , n) for(int mm=i ; mm<n ; ++mm)
using namespace std;
vector<int> v;
int sum;
map<int,int> mp;
signed main(){
__IO
	int n; cin >> n;
	v.resize(n);
	int duo = 0;
	for(int i=0 ; i<n ; ++i){
		cin >> v[i] , mp[v[i]]++;
		if(mp[v[i]] >= 3) return cout << "cslnb",0;
	}

	for(auto &c : mp){
		if(c.S >= 2) duo++;
		if(duo >= 2) return cout << "cslnb",0;
	}

	sort(all(v));
	sum += v[0] , v[0]=0;
	sum %= 2;
	for(int i=1 ; i<v.size() ; ++i){
		sum += v[i] - v[i-1] -1;
		sum %= 2;
		v[i] = min(v[i] , i);
	}
	if(sum == 1) cout << "sjfnb";
	else cout << "cslnb";
}


#include<bits/stdc++.h>
#define int long long
//#define test_
#define MP make_pair
#define pb push_back
#define S second
#define F first
#define sz(x) (int)(x).size()
#define all(x) (x).begin(),(x).end()
#define __IO ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
#define pii pair<int,int>
#define et cout<<'\n';
#define rep(i , n) for(int mm=i ; mm<n ; ++mm)
using namespace std;
vector<int> v;
int sum , duo;
map<int,int> mp;
signed main(){
__IO
	int n; cin >> n;
	v.resize(n);
	for(int i=0 ; i<n ; ++i){
		cin >> v[i] , mp[v[i]]++;
		if(mp[v[i]] >= 3) return cout << "cslnb",0;
	}
	if(mp[0] >= 2) return cout << "cslnb" , 0;
	for(auto &c : mp){
		if(c.S >= 2) duo++;
		if(duo >= 2) return cout << "cslnb",0;
	}

	sort(all(v));
	sum += v[0] , v[0]=0;
	sum %= 2;
	for(int i=1 ; i<v.size() ; ++i){
		sum += v[i] - v[i-1] -1;
		sum %= 2;
		v[i] = min(v[i] , i);
	}
	if(sum == 1) cout << "sjfnb";
	else cout << "cslnb";
}


#include<bits/stdc++.h>
#define int long long
//#define test_
#define MP make_pair
#define pb push_back
#define S second
#define F first
#define sz(x) (int)(x).size()
#define all(x) (x).begin(),(x).end()
#define __IO ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
#define pii pair<int,int>
#define et cout<<'\n';
#define rep(i , n) for(int mm=i ; mm<n ; ++mm)
using namespace std;
vector<int> v;
int sum , duo;
map<int,int> mp;
signed main(){__IO
	int n; cin >> n;
	v.resize(n);
	for(int i=0 ; i<n ; ++i){
		cin >> v[i] , mp[v[i]]++;
		if(mp[v[i]] >= 3) return cout << "cslnb",0;
	}
	if(mp[0] >= 2) return cout << "cslnb" , 0;
	for(auto &c : mp){
		if(c.S >= 2) duo++;
		if((duo >= 2) or (c.S >= 2 and mp[c.F-1])) return cout << "cslnb",0;
	}
	sort(all(v));
	sum += v[0] , v[0]=0 , sum %= 2;
	for(int i=1 ; i<sz(v) ; ++i){
		sum += v[i] - v[i-1] -1 , sum %= 2;
		v[i] = min(v[i] , i);
	}
	if(sum) cout << "sjfnb";
	else cout << "cslnb";
}


#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back

int main()
{
    int n;
    cin >> n;
    ll arr[n];
    int x = 0;

    for(int i = 0 ; i < n ; i++)
    {
        cin >> arr[i];
        x = x ^ arr[i];
    }
    if(n == 1)
    {
        if(arr[0] % 2 == 0)
        {
            cout << "cslnb" << endl;
        }
        else
        {
            cout << "sjfnb" << endl;
        }
        return 0;
    }
    sort(arr,arr+n);

    int z = 0, o = 0;
    for(int i = 0 ; i < n ; i++)
    {
        if(arr[i] == 0)
        z++;
        if(arr[i] == 1)
        o++;
    }
    if(z == n)
    {
        cout << "cslnb" << endl;
        return 0;
    }
    if(z+o == n && n >= 3)
    {
         cout << "cslnb" << endl;
         return 0;
    }
    for(int i = 0 ; i < n-2 ; i++)
    {
        if(arr[i] == arr[i+1] && arr[i+1] == arr[i+2])
        {
            cout << "cslnb" << endl;
            return 0;
        }
    }
    if(x == 0)
    {
        cout << "sjfnb" << endl;
    }
    else
    {
        cout << "cslnb" << endl;
    }
}


#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back

int main()
{
    int n;
    cin >> n;
    ll arr[n];
    int x = 0;

    for(int i = 0 ; i < n ; i++)
    {
        cin >> arr[i];
        x = x ^ arr[i];
    }
    if(n == 1)
    {
        if(arr[0] % 2 == 0)
        {
            cout << "cslnb" << endl;
        }
        else
        {
            cout << "sjfnb" << endl;
        }
        return 0;
    }
    if(x == 0)
    {
        cout << "sjfnb" << endl;
    }
    else
    {
        cout << "cslnb" << endl;
    }
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    cin >> n;
    int arr[n];
    int z = 0;
    long long sum = 0;

    for(int i = 0 ; i < n ; i++)
    {
        cin >> arr[i];
        sum += arr[i];
        if(arr[i] == 0)
        z++;
    }
    if(z > 1)
    {
        cout << "cslnb" << endl;
        return 0;
    }
    sort(arr,arr+n);

    if(n == 1)
    {
        if(arr[0] == 0)
        cout << "cslnb" << endl;
        return 0;
    }
    if(n == 2)
    {
        if(arr[0] == 0 && arr[1] == 1)
        {
            cout << "cslnb" << endl;
            return 0;
        }
    }
    for(int i = 2 ; i < n ; i++)
    {
        if(arr[i] == arr[i-1] && arr[i-1] == arr[i-2])
        {
            cout << "cslnb" << endl;
            return 0;
        }
        if(arr[i] == arr[i-1] && arr[i-1] - arr[i-2] == 1)
        {
            cout << "cslnb" << endl;
            return 0;
        }
        if(i > 2)
        {
            if(arr[i] == arr[i-1] && arr[i-2] == arr[i-3])
            {
                cout << "cslnb" << endl;
                return 0;
            }
        }
    }
    // sum = sum - (n * (n-1L)/2);
    if(sum % 2 == 0)
    cout << "sjfnb" << endl;
    else
    cout << "cslnb" << endl;
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    cin >> n;
    int arr[n];
    int z = 0;
    long long sum = 0;

    for(int i = 0 ; i < n ; i++)
    {
        cin >> arr[i];
        sum += arr[i];
        if(arr[i] == 0)
        z++;
    }
    if(z > 1)
    {
        cout << "cslnb" << endl;
        return 0;
    }
    sort(arr,arr+n);

    if(n == 2)
    {
        if(arr[0] == 0 && arr[1] == 1)
        {
            cout << "cslnb" << endl;
            return 0;
        }
    }
    for(int i = 2 ; i < n ; i++)
    {
        if(arr[i] == arr[i-1] && arr[i-1] == arr[i-2])
        {
            cout << "cslnb" << endl;
            return 0;
        }
        if(arr[i] == arr[i-1] && arr[i-1] - arr[i-2] == 1)
        {
            cout << "cslnb" << endl;
            return 0;
        }
        if(i > 2)
        {
            if(arr[i] == arr[i-1] && arr[i-2] == arr[i-3])
            {
                cout << "cslnb" << endl;
                return 0;
            }
        }
    }
    sum = sum - (n * (n-1L)/2);
    if(sum % 2 == 0)
    cout << "sjfnb" << endl;
    else
    cout << "cslnb" << endl;
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    cin >> n;
    int arr[n];
    int z = 0;
    long long sum = 0;

    for(int i = 0 ; i < n ; i++)
    {
        cin >> arr[i];
        sum += arr[i];
        if(arr[i] == 0)
        z++;
    }
    if(z > 1)
    {
        cout << "cslnb" << endl;
        return 0;
    }
    sort(arr,arr+n);

    if(n == 1)
    {
        if(arr[0] == 0)
        cout << "cslnb" << endl;
        return 0;
    }
    if(n == 2)
    {
        if(arr[0] == 0 && arr[1] == 1)
        {
            cout << "cslnb" << endl;
            return 0;
        }
    }
    for(int i = 2 ; i < n ; i++)
    {
        if(arr[i] == arr[i-1] && arr[i-1] == arr[i-2])
        {
            cout << "cslnb" << endl;
            return 0;
        }
        if(arr[i] == arr[i-1] && arr[i-1] - arr[i-2] == 1)
        {
            cout << "cslnb" << endl;
            return 0;
        }
        if(i > 2)
        {
            if(arr[i] == arr[i-1] && arr[i-2] == arr[i-3])
            {
                cout << "cslnb" << endl;
                return 0;
            }
        }
    }
    sum = sum - (n * (n-1L)/2);
    if(sum % 2 == 0)
    cout << "sjfnb" << endl;
    else
    cout << "cslnb" << endl;
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    cin >> n;
    int arr[n];
    int z = 0;

    for(int i = 0 ; i < n ; i++)
    {
        cin >> arr[i];
        if(arr[i] == 0)
        z++;
    }
    if(z > 1)
    {
        cout << "cslnb" << endl;
        return 0;
    }
    sort(arr,arr+n);

    if(n == 2)
    {
        if(arr[0] == 0 && arr[1] == 1)
        {
            cout << "cslnb" << endl;
            return 0;
        }
    }
    for(int i = 2 ; i < n ; i++)
    {
        if(arr[i] == arr[i-1] && arr[i-1] == arr[i-2])
        {
            cout << "cslnb" << endl;
            return 0;
        }
        if(arr[i] == arr[i-1] && arr[i-1] - arr[i-2] == 1)
        {
            cout << "cslnb" << endl;
            return 0;
        }
        if(i > 2)
        {
            if(arr[i] == arr[i-1] && arr[i-2] == arr[i-3])
            {
                cout << "cslnb" << endl;
                return 0;
            }
        }
    }
    int x = 0;
    for(int i = 0 ; i < n ; i++)
    {
        x = x ^ (arr[i]+i)&1;
    }
    //cout << x << endl;
    if(x != 0)
    cout << "sjfnb" << endl;
    else
    cout << "cslnb" << endl;
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    cin >> n;
    int arr[n];
    int z = 0;
    long long sum = 0;
    map<int,int> m;

    for(int i = 0 ; i < n ; i++)
    {
        cin >> arr[i];
        //sum += arr[i] - i;
        if(arr[i] == 0)
        z++;
    }
    if(z > 1)
    {
        cout << "cslnb" << endl;
        return 0;
    }
    sort(arr,arr+n);

    if(n == 1)
    {
        if(arr[0] == 0){
        cout << "cslnb" << endl;
        return 0;
        }
    }
    if(n == 2)
    {
        if(arr[0] == 0 && arr[1] == 1)
        {
            cout << "cslnb" << endl;
            return 0;
        }
    }
    int f = 0;
    for(int i = 2 ; i < n ; i++)
    {
        if(arr[i] == arr[i-1] && arr[i-1] == arr[i-2])
        {
            cout << "cslnb" << endl;
            return 0;
        }
        if(arr[i] == arr[i-1] && arr[i-1] - arr[i-2] == 1)
        {
            cout << "cslnb" << endl;
            return 0;
        }
    }
    for(int i = 1 ; i < n ; i++)
    {
        if(arr[i] == arr[i-1])
        {
            f++;
        }
    }
    if(f > 1)
    {
        cout << "cslnb" << endl;
        return 0;
    }
    for(int i = 0 ; i < n ; i++)
    {
        sum += arr[i] - i;
    }
    if(sum % 2 == 1)
    cout << "sjfnb" << endl;
    else
    cout << "cslnb" << endl;
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    cin >> n;
    int arr[n];
    int z = 0;
    long long sum = 0;
    map<int,int> m;

    for(int i = 0 ; i < n ; i++)
    {
        cin >> arr[i];
        //sum += arr[i] - i;
        if(arr[i] == 0)
        z++;
    }
    if(z > 1)
    {
        cout << "cslnb" << endl;
        return 0;
    }
    sort(arr,arr+n);

    if(n == 1)
    {
        if(arr[0] == 0){
        cout << "cslnb" << endl;
        return 0;
        }
    }
    if(n == 2)
    {
        if(arr[0] == 0 && arr[1] == 1)
        {
            cout << "cslnb" << endl;
            return 0;
        }
    }
    int f = 0;
    for(int i = 2 ; i < n ; i++)
    {
        if(arr[i] == arr[i-1] && arr[i-1] == arr[i-2])
        {
            cout << "cslnb" << endl;
            return 0;
        }
        if(arr[i] == arr[i-1] && arr[i-1] - arr[i-2] == 1)
        {
            cout << "cslnb" << endl;
            return 0;
        }
        if(i > 2)
        {
            if(arr[i-1] == arr[i-2] || arr[i] == arr[i-1])
            {
                f++;
                if(f == 2)
                {
                    cout << "cslnb" << endl;
                    return 0;
                }
            }
        }
    }
    for(int i = 0 ; i < n ; i++)
    {
        sum += arr[i] - i;
    }
    if(sum % 2 == 1)
    cout << "sjfnb" << endl;
    else
    cout << "cslnb" << endl;
    return 0;
}