stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#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;

}


// Faster C++ solution for the same problem (measured speedup: 4.774705378847554x):
#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");

}
// Slower C++ solution:
#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;

} 

// Faster C++ solution for the same problem (measured speedup: 4.719603175985462x):
#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");

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 4.842933940908928x):
#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");

}
// Slower C++ solution:
#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;

}


// Faster C++ solution for the same problem (measured speedup: 4.77281154329059x):
#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;

}
// Slower C++ solution:
#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;

} 

// Faster C++ solution for the same problem (measured speedup: 4.717731196124874x):
#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;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 4.841013043226329x):
#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;

}
// Slower C++ solution:
#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;

}


// Faster C++ solution for the same problem (measured speedup: 4.862325608069206x):
#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;

}
// Slower C++ solution:
#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;

 }


// Faster C++ solution for the same problem (measured speedup: 4.812824654699387x):
#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;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 4.700918281379606x):
#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;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 4.649166292883728x):
#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;

}
// Slower C++ solution:
#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");

}

// Faster C++ solution for the same problem (measured speedup: 4.757039941203677x):
#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;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 4.697984331869022x):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000];

	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;

}
// Slower C++ solution:
#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";



}

// Faster C++ solution for the same problem (measured speedup: 4.816376364487231x):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000];

	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;

}
// Slower C++ solution:
#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");

    }

}

// Faster C++ solution for the same problem (measured speedup: 4.701814612844779x):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000];

	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;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 4.736022787262552x):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000];

	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;

}
// Slower C++ solution:
#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;

}


// Faster C++ solution for the same problem (measured speedup: 4.766942668605037x):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000];

	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;

}
// Slower C++ solution:
#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";

}


// Faster C++ solution for the same problem (measured speedup: 4.778371993992289x):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000];

	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;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.273172502142093x):
#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;	

 }
// Slower C++ solution:
#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";



}

// Faster C++ solution for the same problem (measured speedup: 5.406059622824907x):
#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;	

 }
// Slower C++ solution:
#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");

    }

}

// Faster C++ solution for the same problem (measured speedup: 5.277471735789985x):
#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;	

 }
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.315868118567303x):
#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;	

 }
// Slower C++ solution:
#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;

}


// Faster C++ solution for the same problem (measured speedup: 5.350573612785038x):
#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;	

 }
// Slower C++ solution:
#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";

}


// Faster C++ solution for the same problem (measured speedup: 5.3634022644136214x):
#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;	

 }
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.274040304831891x):
#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;	

 }
// Slower C++ solution:
#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";

}


// Faster C++ solution for the same problem (measured speedup: 5.4760105185929255x):
#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;	

 }
// Slower C++ solution:
#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";

}


// Faster C++ solution for the same problem (measured speedup: 5.272649362913046x):
#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;	

 }