stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

int main()

{

    int n;

    scanf("%d",&n);

    int a[n],i,cnt=0;

    for(i=0;i<n;i++)

    {

        scanf("%d",&a[i]);

    }

    sort(a,a+n);

    for(i=0;i<n;i++)

    {

        if(a[i]==a[i+1])

        {

            cnt++;

        }



    }

    if(cnt>0)

        printf("NO\n");

    else

        printf("YES\n");

    return 0;



}


// Optimized solution to the same problem (faster):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000],flag=1;

	scanf("%d",&N);

	for(int i=0;i<N;i++)

	scanf("%d",&a[i]);

	sort(a,a+N);

	for(int i=N-1;i>0;i--)

	{

		if(a[i]==a[i-1])

		{

			flag=0;

			break;

		}

	}

	if(flag==1)	printf("YES\n");

	else	printf("NO\n");

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <algorithm>



using namespace std;



int N;

long long arr[200005];



int main(){

    cin >> N;

    for (int i = 1; i <= N; i ++)

        cin >> arr[i];

    sort(arr + 1, arr + 1 + N);

    for (int i = 2; i <= N; i ++){

        if (arr[i] == arr[i - 1]){

            cout << "NO";

            return 0;

        }

    }

    cout << "YES";

    return 0;

}


// Optimized solution to the same problem (faster):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000],flag=1;

	scanf("%d",&N);

	for(int i=0;i<N;i++)

	scanf("%d",&a[i]);

	sort(a,a+N);

	for(int i=N-1;i>0;i--)

	{

		if(a[i]==a[i-1])

		{

			flag=0;

			break;

		}

	}

	if(flag==1)	printf("YES\n");

	else	printf("NO\n");

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

set<int> kk;

int main()

{

    int n;

    cin>>n;

    for(int i=0;i<n;i++)

    {

        int k;

        cin>>k;

        kk.insert(k);

    }



    if(kk.size()==n)

        printf("YES\n");

    else

        printf("NO\n");

}

// Optimized solution to the same problem (faster):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000],flag=1;

	scanf("%d",&N);

	for(int i=0;i<N;i++)

	scanf("%d",&a[i]);

	sort(a,a+N);

	for(int i=N-1;i>0;i--)

	{

		if(a[i]==a[i-1])

		{

			flag=0;

			break;

		}

	}

	if(flag==1)	printf("YES\n");

	else	printf("NO\n");

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

#define ios ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)

#define debug  freopen("in.txt","r",stdin),freopen("out.txt","w",stdout);

#define fs first

#define sc second

using namespace std;

typedef long long ll;

typedef pair<int,int> pii;

const int maxn = 1e6+10;

using namespace std;



int N;

int a[maxn];

int main(){

	// debug;

	ios;



	cin>>N;

	for(int i = 0;i<N;i++) cin>>a[i];

	sort(a,a+N);

	for(int i = 1;i<N;i++){

		if(a[i] == a[i-1]) {

			cout<<"NO"<<'\n';

			return 0;

		}

	}

	cout<<"YES\n";



	return 0;

}


// Optimized solution to the same problem (faster):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000],flag=1;

	scanf("%d",&N);

	for(int i=0;i<N;i++)

	scanf("%d",&a[i]);

	sort(a,a+N);

	for(int i=N-1;i>0;i--)

	{

		if(a[i]==a[i-1])

		{

			flag=0;

			break;

		}

	}

	if(flag==1)	printf("YES\n");

	else	printf("NO\n");

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<cstdio>

#include<set> 

using namespace std;

int main()

{

	int N,t;

	scanf("%d",&N);

	set<int> a;

	for(int i=0;i<N;i++)

	{

		scanf("%d",&t);

		a.insert(t);

	}

	if(N==a.size())	printf("YES\n");

	else	printf("NO\n");

}


// Optimized solution to the same problem (faster):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000],flag=1;

	scanf("%d",&N);

	for(int i=0;i<N;i++)

	scanf("%d",&a[i]);

	sort(a,a+N);

	for(int i=N-1;i>0;i--)

	{

		if(a[i]==a[i-1])

		{

			flag=0;

			break;

		}

	}

	if(flag==1)	printf("YES\n");

	else	printf("NO\n");

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

#define rush() int T;scanf("%d",&T);int kase=1;while(T--)

#define all(x) (x).begin(),(x).End()

#define max(x,y) ((x)>(y)?(x):(y))

#define min(x,y) ((x)<(y)?(x):(y))

#define pb(x) push_back(x)

#define mem(a) memset(a,0,sizeof(a))

using namespace std;

using std::bitset;

typedef long long ll;

const ll maxn=1e6+5;

const ll mod=998244353;

const ll INF=0x3f3f3f3f3f3f3f3f;

const long double PI=acos(-1.0);

const long double eps=1e-5;

inline ll read(){ll ans=0,flag=1;char c;c=getchar();while(c<'0' || c>'9'){if(c=='-')flag=-1;c=getchar();}while(c>='0' && c<='9'){ans=ans*10+(ll)(c-'0');c=getchar();}return ans*flag;}

ll quickpow(ll x,ll y,ll mod){ll ans=1;while(y){if(y&1)ans=ans*x%mod;x=x*x%mod;y>>=1;}return ans;}



map<string,int>mp;



int main()

{

    int n,f;

    cin>>n;

        string t;

        f=1;

        for(int i=0;i<n;i++)

        {

            cin>>t;

            mp[t]++;

            if(mp[t]>1)

                f=0;

        }

        if(f)

            cout<<"YES"<<endl;

        else

            cout<<"NO"<<endl;

}


// Optimized solution to the same problem (faster):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000],flag=1;

	scanf("%d",&N);

	for(int i=0;i<N;i++)

	scanf("%d",&a[i]);

	sort(a,a+N);

	for(int i=N-1;i>0;i--)

	{

		if(a[i]==a[i-1])

		{

			flag=0;

			break;

		}

	}

	if(flag==1)	printf("YES\n");

	else	printf("NO\n");

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<set>



using namespace std;



set<int> st;



int main(){

   int n;

   cin>>n;

   int res;

   for(int i=1;i<=n;i++){

   	cin>>res;

   	st.insert(res);

   }

   if(st.size() == n) cout<<"YES";

   else cout<<"NO"<<endl;

	return 0;

} 

// Optimized solution to the same problem (faster):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000],flag=1;

	scanf("%d",&N);

	for(int i=0;i<N;i++)

	scanf("%d",&a[i]);

	sort(a,a+N);

	for(int i=N-1;i>0;i--)

	{

		if(a[i]==a[i-1])

		{

			flag=0;

			break;

		}

	}

	if(flag==1)	printf("YES\n");

	else	printf("NO\n");

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

#define ll long long

int main(){

	std::ios::sync_with_stdio(false);

	int n, a[200005];

	cin >> n;

	for(int i=0; i<n; i++) cin >> a[i];

	sort(a,a+n);

	int flag = 0;

	for(int i=0; i<n-1; i++){

		if(a[i]==a[i+1]){

			flag = 1;

			break;

		}

	}

	if(flag) cout << "NO"<<endl;

	else cout << "YES" <<endl;

	return 0;

}

// Optimized solution to the same problem (faster):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000],flag=1;

	scanf("%d",&N);

	for(int i=0;i<N;i++)

	scanf("%d",&a[i]);

	sort(a,a+N);

	for(int i=N-1;i>0;i--)

	{

		if(a[i]==a[i-1])

		{

			flag=0;

			break;

		}

	}

	if(flag==1)	printf("YES\n");

	else	printf("NO\n");

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;



int main () {

    bool d = true;

    int n;

    int a[300000];

    cin>>n;

    map <int, int> c;

    for (int i = 0; i < n; i++) {

        cin>>a[i];

        c[a[i]]++;

        if (c[a[i]] == 2) {

            d = false;

        }

    }

    if (d == false) {

        cout<<"NO";

    }

    else cout<<"YES";

    return 0;

}


// Optimized solution to the same problem (faster):
#include <cstdio>

#include <algorithm>

using namespace std;



int main(){

	int N,ant[200000],i;

	scanf("%d",&N);

	for(i=0;i<N;i++){

		scanf("%d",&ant[i]);

	}

	sort(ant,ant+N);

	for(i=1;i<N;i++){

		if(ant[i]==ant[i-1]){

			printf("NO\n");

			return 0;

		}

	}

	printf("YES\n");

	return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

int main(){

    ios_base::sync_with_stdio(0); cin.tie(0);

    vector <int> a;

    int n,x;

    cin>>n;

    for (int i=1;i<=n;i++){

        cin>>x;

        a.push_back(x);

    }

    sort(a.begin(),a.end());

    while(a.size()>1){

        x=a.back();

        a.pop_back();

        if (x==a.back()){

            cout<<"NO";

            return 0;

        }

    }

    cout<<"YES";

    return 0;

 }


// Optimized solution to the same problem (faster):
#include <cstdio>

#include <algorithm>

using namespace std;



int main(){

	int N,ant[200000],i;

	scanf("%d",&N);

	for(i=0;i<N;i++){

		scanf("%d",&ant[i]);

	}

	sort(ant,ant+N);

	for(i=1;i<N;i++){

		if(ant[i]==ant[i-1]){

			printf("NO\n");

			return 0;

		}

	}

	printf("YES\n");

	return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

int n,a[200005];

int main()

{

    cin>>n;

    for(int i=1;i<=n;i++)

        cin>>a[i];

    sort(a+1,a+n+1);

    for(int i=1;i<n;i++)

        if(a[i]==a[i+1])

        {

            cout<<"NO";

            return 0;

        }

    cout<<"YES";

    return 0;

}

// Optimized solution to the same problem (faster):
#include <cstdio>

#include <algorithm>

using namespace std;



int main(){

	int N,ant[200000],i;

	scanf("%d",&N);

	for(i=0;i<N;i++){

		scanf("%d",&ant[i]);

	}

	sort(ant,ant+N);

	for(i=1;i<N;i++){

		if(ant[i]==ant[i-1]){

			printf("NO\n");

			return 0;

		}

	}

	printf("YES\n");

	return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include<stdio.h>

#include<vector>

#include<string.h>

#include<string>

#include<algorithm>

using namespace std;

long long a[200000]={0};

int erfen(int low,int high,int i)

{

    int mid;

    while(low<=high)

    {

       mid=(low+high)/2;

       if(a[mid]==a[i])

            return 1;

        else if(a[mid]<a[i])

            low=mid+1;

        else

            high=mid-1;

    }

    return 0;

}

int main()

{

    int N,i,low,high,flag;

    scanf("%d",&N);

    for(i=0;i<N;i++)

    {

        scanf("%lld",&a[i]);

    }

    sort(a,a+N);

    for(i=0;i<N;i++)

    {

        low=i+1;

        high=N-1;

        flag=erfen(low,high,i);

        if(flag==1)

        {

            printf("NO\n");

            break;

        }

    }

    if(flag==0)

        printf("YES\n");

    return 0;

}

// Optimized solution to the same problem (faster):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000],flag=1;

	scanf("%d",&N);

	for(int i=0;i<N;i++)

	scanf("%d",&a[i]);

	sort(a,a+N);

	for(int i=1;i<N;i++)

	{

		if(a[i]==a[i-1])

		{

			printf("NO\n");

			return 0;

		}

	}

	printf("YES\n");

	return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <algorithm>

#include <queue>

#include <vector>

#include <stdio.h>

#include <string.h>

#include <iostream>

#include <algorithm>

#define ll long long

#define N 1000000005

using namespace std;

int main()

{

    long long  n;

    scanf("%lld",&n);

    int a[200005];

    int i;

    for( i=0;i<n;i++)

    {

        scanf("%d",&a[i]);

    }

    sort(a,a+n);

    for(int j=0; j<n; j++)

    {

        if(a[j]==a[j+1])

        {

            printf("NO\n");

            return 0;

        }



    }

    printf("YES\n");

}

// Optimized solution to the same problem (faster):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000],flag=1;

	scanf("%d",&N);

	for(int i=0;i<N;i++)

	scanf("%d",&a[i]);

	sort(a,a+N);

	for(int i=1;i<N;i++)

	{

		if(a[i]==a[i-1])

		{

			printf("NO\n");

			return 0;

		}

	}

	printf("YES\n");

	return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>



using namespace std;



int main() {

  int n;

  cin >> n;

  set<int> st;

  for (int i = 0; i < n; i++) {

    int x;

    cin >> x;

    st.insert(x);

  }

  puts(st.size() == n ? "YES" : "NO");

 

  return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200000];

int main()

{

	int i,n,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

	  scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

	   if(a[i]==a[i+1])

	   {

	      flag=1;

	      break;

	   }

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;	

 } 

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

#define sz(x) ((int)x.size())

#define pb push_back

#define ii pair<int,int>

#define ppb pop_back

#define orta ((bas+son)>>1)

#define st first

#define nd second

#define ll long long

#define N 200005

#define inf 1000000005

#define MOD 1000000007

#define LOG 20

#define EPS 0.000000001

#define M 305

using namespace std;



int n,k;

int h[N];



int main() {



	ios_base::sync_with_stdio(0);

	cin.tie(0);cout.tie(0);



	cin>>n;

	map<int,int> mp;

	for(int i=1;i<=n;i++) {

		int x;

		cin>>x;

		if(mp[x]) {

			cout<<"NO";

			return 0;

		}

		mp[x]=1;

	}

	cout<<"YES";



}

// Optimized solution to the same problem (faster):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200000];

int main()

{

	int i,n,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

	  scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

	   if(a[i]==a[i+1])

	   {

	      flag=1;

	      break;

	   }

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;	

 } 

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

int a[200005];

map<int, int> freq;



int main() {

    int n, maxim = INT_MIN;

    scanf("%d", &n);

    for(int i = 1; i <= n; i++) {

        scanf("%d", &a[i]);

        freq[a[i]]++;

    }

    for(int i = 1; i <= n; i++) {

        maxim = max(maxim, freq[a[i]]);

    }

    if(maxim == 1) {

        printf("YES\n");

    } else {

        printf("NO\n");

    }

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200000];

int main()

{

	int i,n,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

	  scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

	   if(a[i]==a[i+1])

	   {

	      flag=1;

	      break;

	   }

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;	

 } 

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <algorithm>

#include <map>

#include <string>

#include <queue>

#include <vector>

#include <set>

using namespace std;

const int maxn = 2e6+10;

typedef pair<int,int> pii;

typedef long long ll;



int N;

set<int> st;

int main(){

//    freopen("in.txt","r",stdin);

//    freopen("out.txt","w",stdout);



    cin>>N;int t;

    while(N--){

        scanf("%d",&t);

        if(st.find(t) == st.end()){

            st.insert(t);

        }else{

            cout<<"NO"<<endl;

            return 0;

        }

    }

    cout<<"YES"<<endl;

    return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200000];

int main()

{

	int i,n,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

	  scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

	   if(a[i]==a[i+1])

	   {

	      flag=1;

	      break;

	   }

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;	

 } 

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

int main() {

    int n, temp;

    vector <int> v;

    set <int> s;

    cin>>n;

    while(n--) {

        cin>>temp;

        v.push_back(temp);

        s.insert(temp);

    }

    if(s.size()==v.size()) cout<<"YES"<<endl;

    else cout<<"NO"<<endl;

    return 0;

}


// Optimized solution to the same problem (faster):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200000];

int main()

{

	int i,n,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

	  scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

	   if(a[i]==a[i+1])

	   {

	      flag=1;

	      break;

	   }

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;	

 } 

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

set<int> kk;

int main()

{

    ios::sync_with_stdio(false);

    cin.tie(nullptr);

    int n;

    cin>>n;

    for(int i=0;i<n;i++)

    {

        int k;

        cin>>k;

        kk.insert(k);

    }



    if(kk.size()==n)

        cout<<"YES";

    else

        cout<<"NO";

}


// Optimized solution to the same problem (faster):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200000];

int main()

{

	int i,n,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

	  scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

	   if(a[i]==a[i+1])

	   {

	      flag=1;

	      break;

	   }

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;	

 } 

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

int main(){

 

 

    long long n;

    cin >> n;

    long long a[n+1];

    for(int i=1; i<=n; i++) cin >> a[i];

    sort(a+1, a+n+1);

    for(int i=2; i<=n; i++)

    {

        if(a[i]==a[i-1])

        {

            cout << "NO";

            return 0;

        }

    }

    cout << "YES";

    return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200000];

int main()

{

	int i,n,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

	  scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

	   if(a[i]==a[i+1])

	   {

	      flag=1;

	      break;

	   }

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;	

 } 

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

#define int long long



signed main()

{

    int a[200002], res=0;

    int n;

    cin>>n;

    for (int i=1; i<=n; i++) {cin>>a[i];}

    sort(a+1,a+n+1);

    for (int i=1; i<n; i++)

    {

        if (a[i]==a[i+1]) {cout<<"NO"; return 0;}

    }

    cout<<"YES";

}


// Optimized solution to the same problem (faster):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200000];

int main()

{

	int i,n,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

	  scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

	   if(a[i]==a[i+1])

	   {

	      flag=1;

	      break;

	   }

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;	

 } 

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;



#define int long long



int n, a[200010];



signed main()

{

    cin >> n;

    for(int i = 1; i <= n; i++)

    {

        cin >> a[i];



    }

    sort(a + 1, a + 1 + n);



    for(int i = 1; i < n; i++)

    {

        if(a[i] == a[i + 1])

        {

            cout << "NO";

            return 0;

        }

    }

    cout << "YES";

}


// Optimized solution to the same problem (faster):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200000];

int main()

{

	int i,n,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

	  scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

	   if(a[i]==a[i+1])

	   {

	      flag=1;

	      break;

	   }

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;	

 } 

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;



#define ll long long

#define li long int



int n;

li a[200005],f[200005];



int main(){

    ios_base::sync_with_stdio(0);

    cin.tie(0);

    cout.tie(0);

    cin>>n;

    for(int i=1;i<=n;i++){

        cin>>a[i];

    }



    sort(a+1,a+1+n);

    for(int i=2;i<=n;i++){

        if(a[i]==a[i-1]){

            cout<<"NO";

            return 0;

        }

    }

    cout<<"YES";

    return 0;

}




// Optimized solution to the same problem (faster):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200000];

int main()

{

	int i,n,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

	  scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

	   if(a[i]==a[i+1])

	   {

	      flag=1;

	      break;

	   }

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;	

 } 

// Fastest known solution for this problem:
// Original C++ solution (slower):




#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>

#include <ext/pb_ds/tree_policy.hpp>

using namespace std;

using namespace __gnu_pbds;

 

#define watch(x) cout<<(#x)<<"="<<(x)<<'\n'

#define mset(d,val) memset(d,val,sizeof(d))

#define setp(x) cout<<fixed<<setprecision(x)

#define forn(i,a,b) for(int i=a;i<b;i++)

#define fore(i,a,b) for(int i=a;i<=b;i++)

#define pb push_back

#define mp make_pair

#define F first

#define S second

#define INF ll(1e18)

#define MOD 998244353

#define pqueue priority_queue

#define fbo find_by_order

#define ook order_of_key

typedef long long ll;

typedef pair<ll,ll> ii;

typedef vector<ll> vi;

typedef vector<ii> vii;

typedef long double ld;

typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update> pbds;

 

#define MAXN 1000000007

 

 

int main() {

	ll n;

	cin>>n;

	ll arr[n];

	for (ll i=0;i<n;i++) {

		cin>>arr[i];

		

	}

	ll counter=0;

	sort(arr,arr+n);

	for (ll i=0;i<n-1;i++) {

		if (arr[i]==arr[i+1]) {

			counter=1;

			

		}

		

		

	}

	if (counter) {

		cout<<"NO";

	}

	else {

		cout<<"YES";

	}

}

	




// Optimized solution to the same problem (faster):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200000];

int main()

{

	int i,n,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

	  scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

	   if(a[i]==a[i+1])

	   {

	      flag=1;

	      break;

	   }

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;	

 } 

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <algorithm>

#include <stdio.h>

#include <string>

#include <string.h>

#include <math.h>

#include<map>

using namespace std;

#define debug freopen("in.txt","r",stdin),freopen("out.txt","w",stdout);

#define ios ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);

#define PI acos(-1)

typedef long long ll;

const int maxn=2e6+10;





map<ll,int> mp;

int main()

{

	ios;

	ll x;

	int N;

	bool bl=0;

	cin>>N;

	for(int i=0;i<N;i++)

	{

		cin>>x;

		if(bl==1)

			continue;

		mp[x]++;

		if(mp[x]>=2)

			bl=1;

	}

	if(bl==1) cout<<"NO";

	else cout<<"YES";

	return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200000];

int main()

{

	int i,n,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

	  scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

	   if(a[i]==a[i+1])

	   {

	      flag=1;

	      break;

	   }

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;	

 } 

// Fastest known solution for this problem: