stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
 #include<bits/stdc++.h>

 using namespace std;

 inline int read(){

    int x=0,f=1; char ch=getchar();

    while(ch<'0' || ch>'9') {if(ch=='-') f=-1; ch=getchar();}

    while(ch>='0' && ch<='9') {x=x*10+ch-'0'; ch=getchar();}

    return x*f;

 }

 #define LL long long

 #define MAXN 100010

 LL N;

 int a[100010];

 int main(){

	cin>>N;

	int cnt = 0;

	LL base = 26;

	while (N){

		a[++cnt] = N%26;

		N /= 26;

	}

	//if (cnt>1 && a[cnt]==1) cnt--,a[cnt]+=26;

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

		if (a[i] <= 0){

			a[i] += 26; 

			a[i+1] --;

		}

	}

	while (a[cnt]<=0) cnt--;

	/*

	for (int i=cnt; i; i--){

		//putchar(a[i] + 'a'-1);

		printf("%d\n",a[i]);

	}

	*/

	for (int i=cnt; i; i--){

		putchar(a[i] + 'a'-1);

	}

	puts("");

 	return 0;

 }

 

 

 /*

2



27



123456789



1



26



702



475253

 */

// Faster C++ solution for the same problem (measured speedup: 5.266116616119013x):
#include<stdio.h>

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

	for(ll j = i - 1; j >= 0; j--){

		printf("%c", str[j]);

	}

	puts("");

	return 0;

}
// Slower C++ solution:
#include<iostream>

#include<stack>

using namespace std;

int ans[100];

int main(){

    long long N;

    while(~scanf("%lld",&N)){

        int temp = 0;

        while(N){

            ans[temp++]=(N-1)%26;

            N--;

            N/=26;

        }

        for(int i=temp-1;i>=0;i--){

            cout << (char)('a'+ans[i]);

        }

        cout << endl;

    }

}

// Faster C++ solution for the same problem (measured speedup: 5.290322987520418x):
#include<stdio.h>

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

	for(ll j = i - 1; j >= 0; j--){

		printf("%c", str[j]);

	}

	puts("");

	return 0;

}
// Slower C++ solution:
#include<iostream>

#include<algorithm>

#include<cmath>

#include<queue>

#include<list>

#include<cstdio>

#include<set>

using namespace std;

int  main()

{

	long long n;

	cin>>n;

	int a;

	int x[1000];

	int num=0;

	while(n)

	{

		a=(n-1)%26;

		x[num++]=a;

		n--;

		n=n/26;

	}

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

		cout<<static_cast<char>(x[i]+'a');

    return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.275526355740573x):
#include<stdio.h>

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

	for(ll j = i - 1; j >= 0; j--){

		printf("%c", str[j]);

	}

	puts("");

	return 0;

}
// Slower C++ solution:
#include <iostream>

#include <cstring>

#include <algorithm>

#include <cmath>

#define N 100006

#define ll long long

#define dd double

#define esp 1e-10

using namespace std;



ll n;

int a[106],cnt;



int main(){

	scanf("%lld",&n);

	--n;

	cnt=0;

	while(n>0){

		a[++cnt]=n%26;

		n/=26;

		--n;

	}

	if(n==0)

		++cnt;

	for(int i=cnt;i>=1;--i)

		cout<<(char)(a[i]+'a');

}

// Faster C++ solution for the same problem (measured speedup: 5.275285949997204x):
#include<stdio.h>

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

	for(ll j = i - 1; j >= 0; j--){

		printf("%c", str[j]);

	}

	puts("");

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N=25;

const int M=26;

#define endl '\n'



char str[N];



int main(){

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

	cout.setf(ios::fixed),cout.precision(3);

	ll n,base=26,cnt=0;

	cin>>n;

	n--;

	while(n>=base){

		n-=base;

		base*=M;

	}

	base/=M;

	while(base){

		str[cnt++]=(n/base)+'a';

		n%=base;

		base/=M;

	}

	str[cnt]='\0';

	cout<<str<<endl;

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.352851894994812x):
#include<stdio.h>

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

	for(ll j = i - 1; j >= 0; j--){

		printf("%c", str[j]);

	}

	puts("");

	return 0;

}
// Slower C++ solution:
#include <iostream>

#include <algorithm>

#include <vector>



using namespace std;



typedef long long ll;

typedef unsigned long long ull;







int main(){

    ll n;

    cin >> n;

    string s = "";

    while (n){

        if (n%26==0){

            s += 'z';

            n--;

        }

        else s += (char) ((n%26)-1) + 'a';

        n/=26;

    }

    reverse(s.begin(), s.end());

    cout << s;

    

}

// Faster C++ solution for the same problem (measured speedup: 5.272558645360935x):
#include<stdio.h>

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

	for(ll j = i - 1; j >= 0; j--){

		printf("%c", str[j]);

	}

	puts("");

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int main()

{

    ios::sync_with_stdio(0);

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

    long long n; cin >> n;

    string s = "";

    while (n)

    {

        s += (char)((--n % 26) + 'a');

        n /= 26;

    }

    reverse(s.begin(), s.end());

    cout << s << '\n';

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.353328311860569x):
#include<stdio.h>

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

	for(ll j = i - 1; j >= 0; j--){

		printf("%c", str[j]);

	}

	puts("");

	return 0;

}
// Slower C++ solution:
#include <iostream>

#include <bits/stdc++.h>

#include <string>

using namespace std;

int main()

{

    string s;

    long long n, k;

    cin >> n;

    while (n--)

    {

        k = n % 26 + 97;

        n /= 26;

        s += char (k);

    }

    reverse (s.begin(), s.end());

    cout << s;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.272052878705036x):
#include<stdio.h>

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

	for(ll j = i - 1; j >= 0; j--){

		printf("%c", str[j]);

	}

	puts("");

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

#define ll long long

#define endl "\n"

#define pb push_back

#define READ(FILE) freopen(FILE,"r",stdin)

#define WRITE(FILE) freopen(FILE,"w",stdout)

#define loop(i,s,e) for(int i=s;i<e;i++)

#define mego fast();

using namespace std;

void fast()

{

    ios::sync_with_stdio(0);

    cin.tie(0);

    cout.tie(0);

}



ll lcm(ll x, ll y)

{

    return (x*y)/__gcd(x,y);

}

int sum(string s)

{

    int x=0,sz=s.size();

    loop(i,0,sz)x+=(s[i]-'0');

    return x;

}

int main()

{

    mego

ll x,y=1;

cin>>x;

string ans="";

while(x)

{

    x--;

    ans+=('a'+((x%26)));

    x/=26;

}

    reverse(ans.begin(),ans.end());

    cout<<ans;

    return 0;

}

/*26*/


// Faster C++ solution for the same problem (measured speedup: 5.351875589992136x):
#include<stdio.h>

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

	for(ll j = i - 1; j >= 0; j--){

		printf("%c", str[j]);

	}

	puts("");

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

#define ll long long

#define _ ios::sync_with_stdio(false);cout.tie(NULL);cin.tie(NULL);

using namespace std;



int main() { _

    ll n; cin >> n;

    string s;

    while(n != 0){

        n--;

        ll temp = n % 26;

        s += 'a' + temp;

        n /= 26;

    }

    for(ll i = s.size() - 1; i >= 0 ; i--){

        cout << s[i];

    }

}

// Faster C++ solution for the same problem (measured speedup: 5.352928643911281x):
#include<stdio.h>

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

	for(ll j = i - 1; j >= 0; j--){

		printf("%c", str[j]);

	}

	puts("");

	return 0;

}
// Slower C++ solution:
#include <iostream>

#include <algorithm>

#include <string>

using namespace std;

typedef long long ll ;

char a[30]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};

int main()

{

    ll n,x;

    string s;

    cin>>n;

    while(n)

    {

        x=n%26;

        if(x==0)x=26;

        s+=a[x-1];

        n=(n-1)/26;

    }

    reverse(s.begin(),s.end());

    cout<<s<<endl;

}

// Faster C++ solution for the same problem (measured speedup: 5.334127470832843x):
#include<stdio.h>

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

	for(ll j = i - 1; j >= 0; j--){

		printf("%c", str[j]);

	}

	puts("");

	return 0;

}
// Slower C++ solution:
#include <iostream>

#include <vector>



using namespace std;



unsigned long long int power(int times)

{

    unsigned long long int pow = 1;

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

        pow *= 26;

    return pow;

}



int main()

{

    unsigned long long int n, mini = 1, maxi = 26, diff, sub;

    int i;

    cin >> n;

    for (i = 1 ; i <= 15 ; i++)

    {

        if (n >= mini && n <= maxi)

            break;

        mini = maxi + 1;

        maxi = maxi + power(i+1);

    }

    vector<int> digits(i, 0);

    diff = n - mini;

    sub = diff / 26;

    digits[0] = diff - 26 * sub;

    for (int j = 1 ; sub > 0 ; j++)

    {

        if (sub < 26)

        {

            digits[j] = sub;

            break;

        }

        else

        {

            diff = sub;

            sub /= 26;

            digits[j] = diff - 26 * sub;

        }

    }

    for (int j = digits.size()-1 ; j >= 0 ; j--)

    {

        cout << char('a' + digits[j]);

    }

    cout << endl;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.346074319318868x):
#include<stdio.h>

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

	for(ll j = i - 1; j >= 0; j--){

		printf("%c", str[j]);

	}

	puts("");

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

int main()

{

    ll n,mod,div,i;

    string s;

    vector<char>v;

    cin>>n;

    while(n>0)

    {

        n--;

        mod=n%26;

        //div=n/26;

        n/=26;

        /*if(mod==0)

        {

            mod=26;

            n--;

        }*/

        char j='a'+mod;

        v.push_back(j);

        //cout<<mod<<endl;

    }

    reverse(v.begin(),v.end());

    for(i=0; i<v.size(); i++)

        cout<<v[i];

    v.clear();

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.327392414541744x):
#include<stdio.h>

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

	for(ll j = i - 1; j >= 0; j--){

		printf("%c", str[j]);

	}

	puts("");

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

long long n;

stack<char>s;

int main()

{

	cin>>n;

	while(n)

	{

		n--;

		long long shang=n/26;

		long long yu=n%26;

		n=shang;

		s.push((char)('a'+yu));

	}

	while(!s.empty())

	{

		cout<<s.top();s.pop();

	}

}

// Faster C++ solution for the same problem (measured speedup: 5.325557588939709x):
#include<stdio.h>

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

	for(ll j = i - 1; j >= 0; j--){

		printf("%c", str[j]);

	}

	puts("");

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

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

#define REP(i,n) FOR(i,0,n)

#define ALL(v) (v).begin(),(v).end()

#define fi first

#define se second

template<typename A, typename B> inline bool chmax(A &a, B b) { if (a<b) { a=b; return 1; } return 0; }

template<typename A, typename B> inline bool chmin(A &a, B b) { if (a>b) { a=b; return 1; } return 0; }

typedef long long ll;

typedef pair<int, int> pii;

typedef pair<ll, ll> pll;

typedef pair<pll, int> plp;

const ll INF = 1e9+100;

const ll MOD = 1e9+7;

const double EPS = 1e-10;

const bool debug = 0;

//--------------------------------//



int N;

int c[100];

bool dp[100][101][10];



int main() {

	cin >> N;

	REP(i, N) scanf("%d", c + i);

	

	REP(i, N - 1) if (c[i] == c[i + 1]) dp[i][i + 2][c[i]] = true;

	

	FOR(s, 2, N + 1) {

		REP(l, N - s + 1) {

			int r = l + s;

			

			REP(i, 10) REP(j, 10) {

				FOR(k, l + 1, r) {

					dp[l][r][0] |= dp[l][k][i] & dp[k][r][j]; // xx

					

					if (c[l] == c[r - 1]) {

						dp[l][r][c[l]] |= dp[l + 1][r - 1][i]; // 1x1

						if (c[l] == c[k]) dp[l][r][c[l]] |= dp[l + 1][k][i] & dp[k + 1][r - 1][j]; // 1x1x1

					}

				}

			}

			

			if (l > 0) dp[l - 1][r][c[l - 1]] |= dp[l][r][c[l - 1]];

			if (r < N) dp[l][r + 1][c[r]] |= dp[l][r][c[r]];

		}

	}

	

	bool ans = false;

	REP(i, 10) ans |= dp[0][N][i];

	puts(ans ? "yes" : "no");

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.1078950249935133x):
#include <bits/stdc++.h>

using namespace std;

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

#define REP(i,n) FOR(i,0,n)

#define ALL(v) (v).begin(),(v).end()

#define fi first

#define se second

template<typename A, typename B> inline bool chmax(A &a, B b) { if (a<b) { a=b; return 1; } return 0; }

template<typename A, typename B> inline bool chmin(A &a, B b) { if (a>b) { a=b; return 1; } return 0; }

typedef long long ll;

typedef pair<int, int> pii;

typedef pair<ll, ll> pll;

typedef pair<pll, int> plp;

const ll INF = 1e9+100;

const ll MOD = 1e9+7;

const double EPS = 1e-10;

const bool debug = 0;

//--------------------------------//



int N;

int c[100];

bool dp[100][101];



int main() {

	cin >> N;

	REP(i, N) scanf("%d", c + i);

	

	REP(i, N - 1) if (c[i] == c[i + 1]) dp[i][i + 2] = true;

	

	FOR(s, 2, N + 1) {

		REP(l, N - s + 1) {

			int r = l + s;

			

			FOR(k, l + 1, r) {

				dp[l][r] |= dp[l][k] & dp[k][r]; // xx

				

				if (c[l] == c[r - 1]) {

					dp[l][r] |= dp[l + 1][r - 1]; // 1x1

					if (c[l] == c[k]) dp[l][r] |= dp[l + 1][k] & dp[k + 1][r - 1]; // 1x1x1

				}

			}

			

			if (c[l] && c[r - 1]) {

				if (l > 0 && c[l - 1] == c[l]) dp[l - 1][r] |= dp[l][r];

				if (r < N && c[r - 1] == c[r]) dp[l][r + 1] |= dp[l][r];

			}

		}

	}

	

	puts(dp[0][N] ? "yes" : "no");

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main(){

	int a,b;

	cin>>a>>b;

	cout<<a*a-b<<"\n";

	return 0;

}

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

#include<cstring>

#include<algorithm>



using namespace std;



typedef long long LL;



int main()

{

    int n, m;

    scanf("%d%d", &n, &m);

    printf("%d\n", n * n - m);

    return 0;

}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main(){

	long long  N,A;

	cin>>N>>A;

	cout<<N*N-A<<endl;

	return 0;

} 

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

#include<cstring>

#include<algorithm>



using namespace std;



typedef long long LL;



int main()

{

    int n, m;

    scanf("%d%d", &n, &m);

    printf("%d\n", n * n - m);

    return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;

int main()

{

	int n,a;

	cin>>n>>a;

	cout<<n*n-a<<endl;

	return 0;

} 

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

int main(){

    int n,a;

    scanf("%d\n%d",&n,&a);

    printf("%d",n*n-a);

}
// Slower C++ solution:
/***

*  author  :_shamim

*  created : 06.05.2020

*

***/



#include <iostream>

#include <string.h>

#include <stdio.h>

#include <math.h>

#include <list>

#include <set>

#include <queue>

#include <iterator>

#include <bitset>

#include <bits/stdc++.h>

#include <vector>

#include <algorithm>

#define ll             long long

#define _              ios_base::sync_with_stdio(0);cin.tie(0);

#define loop           for(i=0;i<n;i++)

#define pb             push_back

#define tc()           int t;cin>>t;while(t--)          



using namespace std;



ll i,j,temp;



int main()

{_



	int x,a;

	cin>>x>>a;

	cout<<x*x - a<<endl;

	return 0;



}

// Faster C++ solution for the same problem (measured speedup: 5.330920110669092x):
#include<stdio.h>



int main(){

	

	int a,b;

	

	scanf("%d %d", &a, &b);

	

	a = a * a;

	printf("%d\n", a-b);

	

	return 0;

}
// Slower C++ solution:
#include<iostream>

#include<string>

#include<vector>

#include<cmath>

#include<queue>

#include<stack>

#include<set>

#include<algorithm>

#include<utility>

#include<map>

using namespace std;

typedef long long ll;

const int mod = 1000000007;

const int INF = 1001001001;



ll pow_mod(ll p, ll n, ll m) {

	if (n == 0) return 1;

	else if (n == 1) return p % m;

	else if (n % 2 == 1) return p * pow_mod(p, n - 1, m) % m;

	else {

		ll tmp = pow_mod(p, n / 2, m);

		return (tmp * tmp) % m;

	}

}



ll gcd(ll x, ll y) {

	if (y == 0) {

		return x;

	}

	return gcd(y, x % y);

}



ll com_mod(ll n, ll k, ll m) {

	if (k == 0) return 1;

	else {

		ll x = 1;

		ll y = 1;

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

			x = (x * (n - i)) % m;

			y = (y * (i + 1)) % m;

		}

		ll res = (x * pow_mod(y, m - 2, m)) % m;

		return res;

	}

}



int main() {

	int n, a; cin >> n >> a;

	cout << n * n - a << endl;

 	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.264760440633241x):
#include<stdio.h>

int main(){

  int n,a; scanf("%d",&n); scanf("%d",&a);

  printf("%d",n*n-a);

}
// Slower C++ solution:
#include<iostream>

#include<cstdio>

#include<cmath>

#include<algorithm>

#include<cstring>

#include <vector>

#include <map>

using namespace std;

long long Read() {

	long long x=0,f=1;

	char c=getchar();

	while(c<'0'||c>'9') {

		if(c=='-')f=-1;

		c=getchar();

	}

	while(c>='0'&&c<='9')x=x*10+c-'0',c=getchar();

	return x*f;

}

int main() {

	long long n,b;

	 n=Read(),b=Read();

	 cout<<n*n-b; 

	return 0;

}

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

int n,a;

int main()

{

	scanf("%d%d",&n,&a);

	printf("%d",n*n-a);

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

const int N=105;

int n,a[N],ans;

int main()

{

	scanf("%d",&n);

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

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

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

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

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

			for(int k=j+1;k<=n;k++)

				if(a[i]+a[j]>a[k]&&a[i]!=a[j]&&a[j]!=a[k])

					ans++;

	printf("%d\n",ans);

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.1609228476571225x):
#include <stdio.h>

int main(){

    int n,ans=0;

    scanf("%d",&n);

    int arr[n];

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

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

    }

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

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

            for(int k=j+1;k<n;k++){

                if(arr[i]!=arr[j]&&arr[j]!=arr[k]&&arr[k]!=arr[i]&&arr[i]+arr[j]>arr[k]&&arr[j]+arr[k]>arr[i]&&arr[k]+arr[i]>arr[j]){

                    ans++;

                }

            }

        }

    }

    printf("%d\n",ans);

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

const int N=105;

int n,a[N],ans;

int main()

{

	scanf("%d",&n);

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

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

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

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

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

			for(int k=j+1;k<=n;k++)

				if(a[i]+a[j]>a[k]&&a[i]!=a[j]&&a[j]!=a[k])

					ans++;

	printf("%d\n",ans);

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.16078541040606x):
#include <stdio.h>

#include <string.h>

#define ll long long int



int main(){

	int n, cek = 0;

	scanf("%d", &n);

	int num[n];

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

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

	}

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

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

			for(int k = j+1; k<n; k++){

				if((num[i] != num[j]) && (num[j] != num[k]) && (num[k] != num[i])){

					if((num[i] + num[j] > num[k]) && (num[j] + num[k] > num[i]) && (num[k] + num[i] > num[j])){

						cek++;

				}

			}

		}

	}

}

	printf("%d\n",	cek);

	

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

#define rep(i, n) for(int i = 0; i < (int)(n); i++)

typedef long long int ll;

typedef pair<int, int> P;



int n, m, k;

vector<vector<int>> friends(101010, vector<int>(0)), blocks(101010, vector<int>(0));

vector<int> groups(101010), population(101010);



int dfs(int a, int c){

  int ret = 1;

  groups[a] = c;

  

  for(int x : friends[a]){

    if(groups[x] != 0) continue;

    ret += dfs(x, c);

  }

  return ret;

}



int main(){

  cin >> n >> m >> k;

  rep(i, m){

    int a, b;

    cin >> a >> b;

    friends[a].push_back(b);

    friends[b].push_back(a);

  }

  rep(i, k){

    int c, d;

    cin >> c >> d;

    blocks[c].push_back(d);

    blocks[d].push_back(c);

  }

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

    if(groups[i] != 0)continue;

    population[i] = dfs(i, i);

  }

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

    int res = population[groups[i]] - 1;

    res -= friends[i].size();

    for(int x : blocks[i]){

      if(groups[x] == groups[i])

        res--;

    }

    cout << res << ((i == n)? "\n" : " ");

  }

  return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.9481632520000647x):
#include <bits/stdc++.h>

using namespace std;

#define rep(i, n) for(int i = 0; i < (int)(n); i++)

typedef long long int ll;

typedef pair<int, int> P;



struct UnionFind {

  vector<int> data;

  

  UnionFind(int sz){

    data.assign(sz, -1);

  }

  

  bool unite(int x, int y){

    x = root(x), y = root(y);

    if(x == y) return false;

    if(data[x] > data[y]) swap(x, y); //rank?

    data[x] += data[y];

    data[y] = x;

    return true;

  }

  

  int root(int x){

    if(data[x] < 0) return x;

    return data[x] = root(data[x]); //経路圧縮

  }

  

  bool same(int x, int y){

    return root(x) == root(y);

  }

  

  int size(int x){

    return (-data[root(x)]);

  }

};



int n, m, k;

vector<int> num_of_friends(101010, 0);

vector<vector<int>> blocks(101010, vector<int>(0));



int main(){

  cin >> n >> m >> k;

  UnionFind uf(n + 1);

  

  rep(i, m){

    int a, b;

    cin >> a >> b;

    num_of_friends[a]++;

    num_of_friends[b]++;

    uf.unite(a, b);

  }

  

  rep(i, k){

    int c, d;

    cin >> c >> d;

    blocks[c].push_back(d);

    blocks[d].push_back(c);

  }

  

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

    int res = uf.size(i) - 1;

    res -= num_of_friends[i];

    for(int x : blocks[i]){

      if(uf.same(i, x))

        res--;

    }

    cout << res << ((i == n)? "\n" : " ");

  }

  

  return 0;

}