stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include<iostream>

using namespace std;



int main()

{

    int a,b,c;

    cin>>a>>b>>c;

    if(c>=a && c<=b){

        cout<<"Yes";

    }

    else{

        cout<<"No";

    }

    return 0;

}


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

int main(){

	int a, b, c;

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

		if(c>=a && c<=b){

			printf("Yes\n");

		}

		else{

			printf("No\n");

		}

	return 0;

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

using namespace std;



int main()

{

    int a,b,c;

    cin>>a>>b>>c;

    if(c>=a && c<=b){

        cout<<"Yes";

    }

    else{

        cout<<"No";

    }

    return 0;

}


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



int main()

{

	int a,b,c,d=0,e=0;

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



	if(c>=a && c<=b)

		printf("Yes\n");

	else

		printf("No\n");

		

	return 0;

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

using namespace std;

#define MN 200005

char c[MN];

int n,num[26];

long long ans;

int main(){

	scanf("%s",c+1);

	n=strlen(c+1);

	for(int i=n;i>=1;i--) ans+=(n-i)-num[c[i]-'a']++;

	ans++;

	printf("%lld",ans);

	return 0;

}

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

char c[200005];

int n;

long long ans,t[26];

int main()

{

	scanf("%s",c);

	for(int i=0;c[i]!='\0';++i)++n,t[c[i]-'a']++;

	for(int i=0;i<26;++i)ans+=t[i]*(n-t[i]);

	printf("%lld\n",ans/2+1);

	return 0;

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

using namespace std;

#define MN 200005

char c[MN];

int n,num[26];

long long ans;

int main(){

	scanf("%s",c+1);

	n=strlen(c+1);

	for(int i=n;i>=1;i--) ans+=(n-i)-num[c[i]-'a']++;

	ans++;

	printf("%lld",ans);

	return 0;

}

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

#include<algorithm>

#include<cstring>

using namespace std;

#define MAXN 200010

#define LL long long

char s[MAXN];

int cnt[30];

LL ans;

int main()

{

	scanf("%s",s);

	int n=strlen(s);

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

		cnt[s[i]-'a']++;

	ans=1LL*n*(n-1)/2;

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

		if(cnt[i]>1)

			ans-=1LL*cnt[i]*(cnt[i]-1)/2;

	ans++;

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

}
// Slower C++ solution:
//============================================================================

// Name        : training.cpp

// Author      : CoNKeR The Red Squirrel

//============================================================================

#include <bits/stdc++.h>



#define MAX_N 200005

#define INF 1000000000

#define bit(mask, i) (mask & (1<<i))



using namespace std;



typedef pair<int, int> ii;

typedef pair<ii, int> iii;

typedef vector<ii> vii;

typedef vector<int> vi;

typedef vector<vi> vvi;

typedef vector<vii> vvii;

typedef long long ll;

typedef double lf;



ll dp[MAX_N], frec[30], n;



int main() {

    ios_base::sync_with_stdio(0);

    cin.tie(0);



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

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



    string s;

    cin>>s;

    n = (ll)s.size();

    dp[0] = 1;

    frec[s[0] - 'a']++;

    for(ll i = 1; i < n; ++i) { dp[i] = dp[i - 1] + i - frec[s[i] - 'a']++; }

    cout<<dp[n - 1]<<"\n";



    return 0;

}

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

#include<algorithm>

#include<cstring>

using namespace std;

#define MAXN 200010

#define LL long long

char s[MAXN];

int cnt[30];

LL ans;

int main()

{

	scanf("%s",s);

	int n=strlen(s);

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

		cnt[s[i]-'a']++;

	ans=1LL*n*(n-1)/2;

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

		if(cnt[i]>1)

			ans-=1LL*cnt[i]*(cnt[i]-1)/2;

	ans++;

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

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

using namespace std;



using VS = vector<string>;    using LL = long long;

using VI = vector<int>;       using VVI = vector<VI>;

using PII = pair<int, int>;   using PLL = pair<LL, LL>;

using VL = vector<LL>;        using VVL = vector<VL>;



#define ALL(a)  begin((a)),end((a))

#define RALL(a) (a).rbegin(), (a).rend()

#define PB push_back

#define EB emplace_back

#define MP make_pair

#define SZ(a) int((a).size())

#define SORT(c) sort(ALL((c)))

#define RSORT(c) sort(RALL((c)))

#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))

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

#define FORR(i, s, e) for (int(i) = (s); (i) > (e); (i)--)

#define debug(x) cerr << #x << ": " << x << endl

const int INF = 1e9;                          const LL LINF = 1e16;

const LL MOD = 1000000007;                    const double PI = acos(-1.0);

int DX[8] = { 0, 0, 1, -1, 1, 1, -1, -1 };    int DY[8] = { 1, -1, 0, 0, 1, -1, 1, -1 };



/* -----  2018/03/03  Problem: 019_agc_b / Link: https://agc019.contest.atcoder.jp/tasks/agc019_b ----- */

/* ------問題------



英小文字からなる文字列 A=A1A2…An があります。

あなたは 1≤i≤j≤n であるような任意の二つの添字 i,j を選び、A のうち部分文字列 AiAi+1…Aj を反転することができます。

この操作は一回まで行うことができます。

これによって得られる文字列は何通りあるでしょうか？



-----問題ここまで----- */

/* -----解説等-----



アルファベットについての累積和を取ると、部分問題として見れるので、重複数え上げがないようにすればよい。

[str] +'a'のとき、aを含む反転をして一致するのは反転の区間の左端がaとなる場合である。

ex: strstrstr|abca| -> strstrstr|abca|

なぜなら、[str]内の計算で cを右端とした場合にbc->cbを事前に計算終えているからである。

したがって文字列の先頭から走査し、現在見ている文字を両端としない場合は反転をしてuniqueになることが保証あされるので、

これを答えとしてよい。

この方法では反転するものしか数えないので、全く反転しない場合の数1を加える。





----解説ここまで---- */



LL N;



LL ans = 0LL;



int main() {

	cin.tie(0);

	ios_base::sync_with_stdio(false);



	string s;

	cin >> s;



	VVI cnt(SZ(s) + 1, VI(26, 0));

	FOR(i, 0, SZ(s)) {

		FOR(j, 0, 26) {

			cnt[i + 1][j] += cnt[i][j] + (s[i] - 'a' == j);

		}

	}

	ans = 1;

	FOR(i, 0, SZ(s)) {

		ans += i - cnt[i][s[i] - 'a'];

	}

	cout << ans << "\n";



	return 0;

}


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

#include<algorithm>

#include<cstring>

#define MN 200005

using namespace std;

int n,sum[MN][26];long long f[MN];

char ch[MN];

int main(){

	scanf("%s",ch+1);int n=strlen(ch+1);

	for(int i=1;i<=n;i++)memcpy(sum[i],sum[i-1],sizeof(sum[i-1])),sum[i][ch[i]-'a']++;f[0]=1;

	for(int i=1;i<=n;i++)f[i]=f[i-1]+i-sum[i][ch[i]-'a'];

	printf("%lld\n",f[n]);

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

using namespace std;



using VS = vector<string>;    using LL = long long;

using VI = vector<int>;       using VVI = vector<VI>;

using PII = pair<int, int>;   using PLL = pair<LL, LL>;

using VL = vector<LL>;        using VVL = vector<VL>;



#define ALL(a)  begin((a)),end((a))

#define RALL(a) (a).rbegin(), (a).rend()

#define PB push_back

#define EB emplace_back

#define MP make_pair

#define SZ(a) int((a).size())

#define SORT(c) sort(ALL((c)))

#define RSORT(c) sort(RALL((c)))

#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))

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

#define FORR(i, s, e) for (int(i) = (s); (i) > (e); (i)--)

#define debug(x) cerr << #x << ": " << x << endl

const int INF = 1e9;                          const LL LINF = 1e16;

const LL MOD = 1000000007;                    const double PI = acos(-1.0);

int DX[8] = { 0, 0, 1, -1, 1, 1, -1, -1 };    int DY[8] = { 1, -1, 0, 0, 1, -1, 1, -1 };



/* -----  2018/03/03  Problem: 019_agc_b / Link: https://agc019.contest.atcoder.jp/tasks/agc019_b ----- */

/* ------問題------



英小文字からなる文字列 A=A1A2…An があります。

あなたは 1≤i≤j≤n であるような任意の二つの添字 i,j を選び、A のうち部分文字列 AiAi+1…Aj を反転することができます。

この操作は一回まで行うことができます。

これによって得られる文字列は何通りあるでしょうか？



-----問題ここまで----- */

/* -----解説等-----



アルファベットについての累積和を取ると、部分問題として見れるので、重複数え上げがないようにすればよい。

[str] +'a'のとき、aを含む反転をして一致するのは反転の区間の左端がaとなる場合である。

ex: strstrstr|abca| -> strstrstr|abca|

なぜなら、[str]内の計算で cを右端とした場合にbc->cbを事前に計算終えているからである。

したがって文字列の先頭から走査し、現在見ている文字を両端としない場合は反転をしてuniqueになることが保証あされるので、

これを答えとしてよい。

この方法では反転するものしか数えないので、全く反転しない場合の数1を加える。





----解説ここまで---- */



LL N;



LL ans = 0LL;



int main() {

	cin.tie(0);

	ios_base::sync_with_stdio(false);



	string s;

	cin >> s;



	VVI cnt(SZ(s) + 1, VI(26, 0));

	FOR(i, 0, SZ(s)) {

		FOR(j, 0, 26) {

			cnt[i + 1][j] += cnt[i][j] + (s[i] - 'a' == j);

		}

	}

	ans = 1;

	FOR(i, 0, SZ(s)) {

		ans += i - cnt[i][s[i] - 'a'];

	}

	cout << ans << "\n";



	return 0;

}


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

#include<cstdio>

using namespace std;

int n,kk[27];char s[200005];long long ans;

int main()

{

	scanf("%s",s);n=strlen(s);

	for(int i=n-1;i>=0;i--){ans+=(n-i-1)-kk[s[i]-'a']++;}

	printf("%lld",ans+1);

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

using namespace std;



using VS = vector<string>;    using LL = long long;

using VI = vector<int>;       using VVI = vector<VI>;

using PII = pair<int, int>;   using PLL = pair<LL, LL>;

using VL = vector<LL>;        using VVL = vector<VL>;



#define ALL(a)  begin((a)),end((a))

#define RALL(a) (a).rbegin(), (a).rend()

#define PB push_back

#define EB emplace_back

#define MP make_pair

#define SZ(a) int((a).size())

#define SORT(c) sort(ALL((c)))

#define RSORT(c) sort(RALL((c)))

#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))

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

#define FORR(i, s, e) for (int(i) = (s); (i) > (e); (i)--)

#define debug(x) cerr << #x << ": " << x << endl

const int INF = 1e9;                          const LL LINF = 1e16;

const LL MOD = 1000000007;                    const double PI = acos(-1.0);

int DX[8] = { 0, 0, 1, -1, 1, 1, -1, -1 };    int DY[8] = { 1, -1, 0, 0, 1, -1, 1, -1 };



/* -----  2018/03/03  Problem: 019_agc_b / Link: https://agc019.contest.atcoder.jp/tasks/agc019_b ----- */

/* ------問題------



英小文字からなる文字列 A=A1A2…An があります。

あなたは 1≤i≤j≤n であるような任意の二つの添字 i,j を選び、A のうち部分文字列 AiAi+1…Aj を反転することができます。

この操作は一回まで行うことができます。

これによって得られる文字列は何通りあるでしょうか？



-----問題ここまで----- */

/* -----解説等-----



アルファベットについての累積和を取ると、部分問題として見れるので、重複数え上げがないようにすればよい。

[str] +'a'のとき、aを含む反転をして一致するのは反転の区間の左端がaとなる場合である。

ex: strstrstr|abca| -> strstrstr|abca|

なぜなら、[str]内の計算で cを右端とした場合にbc->cbを事前に計算終えているからである。

したがって文字列の先頭から走査し、現在見ている文字を両端としない場合は反転をしてuniqueになることが保証あされるので、

これを答えとしてよい。

この方法では反転するものしか数えないので、全く反転しない場合の数1を加える。





----解説ここまで---- */



LL N;



LL ans = 0LL;



int main() {

	cin.tie(0);

	ios_base::sync_with_stdio(false);



	string s;

	cin >> s;



	VVI cnt(SZ(s) + 1, VI(26, 0));

	FOR(i, 0, SZ(s)) {

		FOR(j, 0, 26) {

			cnt[i + 1][j] += cnt[i][j] + (s[i] - 'a' == j);

		}

	}

	ans = 1;

	FOR(i, 0, SZ(s)) {

		ans += i - cnt[i][s[i] - 'a'];

	}

	cout << ans << "\n";



	return 0;

}


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

#include<cstring>

#include<algorithm>

#include<cmath>

#define SF scanf

#define PF printf

#define MAXN 200010

using namespace std;

typedef long long ll;

char s[MAXN];

ll ans,cnt[30];

int main(){

	SF("%s",s);

	int len=strlen(s);

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

		ans+=(i-cnt[s[i]-'a']);

		cnt[s[i]-'a']++;

	}

	PF("%lld",ans+1ll);

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

#include <vector>

#include <deque>

#include <math.h>

#include <set>

#include <iomanip>

#include <time.h>

#include <list>

#include <stdio.h>

#include <queue>

#include <map>

#include <algorithm>

#include <assert.h>

#include <memory.h>



#define mk make_pair

#define sc second

#define fr first

#define pb emplace_back

#define all(s) s.begin(), s.end()

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

#define int long long



using namespace std;



string s;



int mp[1500], n, res;



main ()

{

    cin >> s;

    s = ' ' + s;

    n = sz(s) - 1;

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

        mp[ s[i] ]++;



    res = n * (n + 1) / 2;



    for (int i = 'a'; i <= 'z'; i++)

        res -= mp[i] * (mp[i] + 1) / 2;



    cout << res + 1 << endl;

}


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

#include<cstring>

const int MAXN=200005;



int n;

char str[MAXN];

int cnt[30];



int main()

{

	scanf("%s",str);

	n=strlen(str);

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

		cnt[str[i]-'a']++;

	long long ans=1LL*n*(n-1)/2;

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

		ans-=1LL*cnt[i]*(cnt[i]-1)/2;

	ans++;

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

	

	return 0;

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



char str[200005];

int num[40],n;

long long ans;



int main(){

	scanf("%s",str+1); n=strlen(str+1);

	for(int i=n;i>=1;--i) ans+=(n-i)-num[str[i]-'a']++;

	printf("%lld",ans+1);

	return 0;

}

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

#include <string.h>

#define MN 200005

int c[26],n;

long long ans=0;

char str[MN];

int main(){

	scanf("%s",str+1); n=strlen(str+1);

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

		ans+=i-(++c[str[i]-'a']);

	printf("%lld",ans+1);

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

#include <iostream>

using namespace std;

string s; int c[26];

int main() {

	cin >> s;

	for (char i : s) c[i - 97]++;

	long long ret = 1LL * s.size() * (s.size() - 1) / 2 + 1;

	for (int i = 0; i < 26; i++) ret -= 1LL * c[i] * (c[i] - 1) / 2;

	cout << ret << endl;

	return 0;

}

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

#pragma warning(disable : 4996)

int c[29]; long long ret; char s[200009];

int main() {

	scanf("%s", s);

	for (int i = 0; s[i]; i++) ret -= c[s[i] - 97], c[s[i] - 97]++, ret += i;

	printf("%lld\n", ret + 1);

	return 0;

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

#include <cstdio>

#include <cstring>

#include <cmath>

using namespace std;

typedef long long LL;

LL vis[200001];

char s[200010];

int main() {

	scanf("%s",s);

	int len=strlen(s);

	for (int i=0;i<len;i++) vis[s[i]-97]++;

	LL ans=0;

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

		ans+=vis[i]*(len-vis[i]);

	ans/=2;

	ans++;

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

	return 0;

}

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

#include<cstring>

using namespace std;

char c[200005];int cnt[27];

long long ans;

int main(){

	scanf("%s",c+1);int n=strlen(c+1);

	for(int i=n;i>=1;--i) ans+=(n-i)-cnt[c[i]-'a']++;

	printf("%lld",ans+1);

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

#include <sstream>

#include <iomanip>

#include <cstdio>

#include <cstdlib>

#include <cmath>

#include <cctype>

#include <cstring>

#include <vector>

#include <list>

#include <queue>

#include <deque>

#include <stack>

#include <map>

#include <set>

#include <algorithm>

#include <iterator>

#include <bitset>

#include <ctime>

#include <complex>



using namespace std;



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

#define RFOR(i,b,a) for (int i = (b)-1; i >= (a); i--)

#define ITER(it,a) for (__typeof(a.begin()) it = a.begin(); it != a.end(); it++)

#define FILL(a,value) memset(a, value, sizeof(a))



#define SZ(a) (int)a.size()

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

#define PB push_back

#define MP make_pair



typedef unsigned long long LL;

typedef vector<int> VI;

typedef pair<int, int> PII;



const double PI = acos(-1.0);

const int INF = 1000 * 1000 * 1000 + 7;

const LL LINF = INF * (LL) INF;



const double EPS = 1e-6;

const int MAX = 200 * 1000 + 47;



char S[MAX];

int C[255];



int main()

{

    scanf("%s", S);

    int n = strlen(S);

    LL ans = 0;

    FOR(i, 0, n)

        ans += C[S[i]]++;

    ans =  n * 1LL * (n - 1) / 2 - ans;

    ans ++;

    cout << ans << endl;

    

}


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

#include<cstring>

using namespace std;

char c[200005];int cnt[27];

long long ans;

int main(){

	scanf("%s",c+1);int n=strlen(c+1);

	for(int i=n;i>=1;--i) ans+=(n-i)-cnt[c[i]-'a']++;

	printf("%lld",ans+1);

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

using namespace std;

typedef long long ll;

typedef pair<int, int> pii;

typedef pair<ll, ll> pll;

const int INF = 1e9;

const ll LINF = 1e18;



/*

<url:https://agc019.contest.atcoder.jp/tasks/agc019_b>

問題文============================================================

 英小文字からなる文字列 A=A1A2…An があります。

 

 あなたは 1≤i≤j≤n であるような任意の二つの添字 i,j を選び、

 A のうち部分文字列 AiAi+1…Aj を反転することができます。

 

 この操作は一回まで行うことができます。

 

 これによって得られる文字列は何通りあるでしょうか？

=================================================================



解説=============================================================

 abcda と abcba という文字列があるとする



 [1,5]を反転させると adcba , abcba

 [2,4]を反転させると adcba , abcba

 

 となる。　このことから ある文字(l)を基準とした時,それよりも右側の同一文字(r)を示して反転させることは

 [l-1,r-1] を反転させることに等しい

 よって、ある文字を見た時、それよりも右側にある別の文字と交換して行くことによって重複の文字を防ぐことができる。

 また、両端が別の文字で反転を行っているので回文となる心配がない

 

 よって、右側にいくつ、どのような文字が存在するのかというテーブルを作っておき、順に見ていけば良い

 O(N)

================================================================

*/

ll solve(){

    ll ret = 1;

    string S; cin >> S;

    int alpha[26] = {};

    for(int i = (int)S.length()-1; i >= 0;i--){

        for(int j = 0; j < 26;j++){

            if(j == S[i]-'a')continue;

            ret += alpha[j];

        }

        alpha[S[i]-'a']++;

    }

    return ret;

}

int main(void) {

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

    cout << solve() << endl;

	return 0;

}


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

#include<cstring>

using namespace std;

char c[200005];int cnt[27];

long long ans;

int main(){

	scanf("%s",c+1);int n=strlen(c+1);

	for(int i=n;i>=1;--i) ans+=(n-i)-cnt[c[i]-'a']++;

	printf("%lld",ans+1);

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

#include<cstring>

#include<cstdio>

using namespace std;

int num[27];char c[300100];

long long ans=0;

int main()

{

	scanf("%s",c+1);int n=strlen(c+1);

	for(int i=n;i>=1;i--)ans+=(n-i)-num[c[i]-'a']++;

	printf("%lld",ans+1);return 0;

 } 

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

#include<cstring>

using namespace std;

char c[200005];int cnt[27];

long long ans;

int main(){

	scanf("%s",c+1);int n=strlen(c+1);

	for(int i=n;i>=1;--i) ans+=(n-i)-cnt[c[i]-'a']++;

	printf("%lld",ans+1);

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

#include <cstdio>

#include <cstring>

#include <cmath>

using namespace std;

typedef long long LL;

LL vis[200001];

char s[200010];

int main() {

	scanf("%s",s);

	int len=strlen(s);

	for (int i=0;i<len;i++) vis[s[i]-97]++;

	LL ans=0;

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

		ans+=vis[i]*(len-vis[i]);

	ans/=2;

	ans++;

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

	return 0;

}

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

#include<cstring>

#include<algorithm>

using namespace std;



typedef long long ll;

const int MAXN=2e5+5;



int n;

ll d[MAXN],cnt[30],sum;

char s[MAXN];



int main(){

    scanf("%s",s+1);

    n=strlen(s+1);

    d[1]=1,sum=1,cnt[s[1]-'a']=1;

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

        d[i]=(ll)d[i-1]+sum-cnt[s[i]-'a'];

        cnt[s[i]-'a']++;

        sum++;

    }

    printf("%lld",d[n]);

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

#include <sstream>

#include <iomanip>

#include <cstdio>

#include <cstdlib>

#include <cmath>

#include <cctype>

#include <cstring>

#include <vector>

#include <list>

#include <queue>

#include <deque>

#include <stack>

#include <map>

#include <set>

#include <algorithm>

#include <iterator>

#include <bitset>

#include <ctime>

#include <complex>



using namespace std;



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

#define RFOR(i,b,a) for (int i = (b)-1; i >= (a); i--)

#define ITER(it,a) for (__typeof(a.begin()) it = a.begin(); it != a.end(); it++)

#define FILL(a,value) memset(a, value, sizeof(a))



#define SZ(a) (int)a.size()

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

#define PB push_back

#define MP make_pair



typedef unsigned long long LL;

typedef vector<int> VI;

typedef pair<int, int> PII;



const double PI = acos(-1.0);

const int INF = 1000 * 1000 * 1000 + 7;

const LL LINF = INF * (LL) INF;



const double EPS = 1e-6;

const int MAX = 200 * 1000 + 47;



char S[MAX];

int C[255];



int main()

{

    scanf("%s", S);

    int n = strlen(S);

    LL ans = 0;

    FOR(i, 0, n)

        ans += C[S[i]]++;

    ans =  n * 1LL * (n - 1) / 2 - ans;

    ans ++;

    cout << ans << endl;

    

}


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

#include<cstring>

#include<algorithm>

using namespace std;



typedef long long ll;

const int MAXN=2e5+5;



int n;

ll d[MAXN],cnt[30],sum;

char s[MAXN];



int main(){

    scanf("%s",s+1);

    n=strlen(s+1);

    d[1]=1,sum=1,cnt[s[1]-'a']=1;

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

        d[i]=(ll)d[i-1]+sum-cnt[s[i]-'a'];

        cnt[s[i]-'a']++;

        sum++;

    }

    printf("%lld",d[n]);

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

using namespace std;

typedef long long ll;

typedef pair<int, int> pii;

typedef pair<ll, ll> pll;

const int INF = 1e9;

const ll LINF = 1e18;



/*

<url:https://agc019.contest.atcoder.jp/tasks/agc019_b>

問題文============================================================

 英小文字からなる文字列 A=A1A2…An があります。

 

 あなたは 1≤i≤j≤n であるような任意の二つの添字 i,j を選び、

 A のうち部分文字列 AiAi+1…Aj を反転することができます。

 

 この操作は一回まで行うことができます。

 

 これによって得られる文字列は何通りあるでしょうか？

=================================================================



解説=============================================================

 abcda と abcba という文字列があるとする



 [1,5]を反転させると adcba , abcba

 [2,4]を反転させると adcba , abcba

 

 となる。　このことから ある文字(l)を基準とした時,それよりも右側の同一文字(r)を示して反転させることは

 [l-1,r-1] を反転させることに等しい

 よって、ある文字を見た時、それよりも右側にある別の文字と交換して行くことによって重複の文字を防ぐことができる。

 また、両端が別の文字で反転を行っているので回文となる心配がない

 

 よって、右側にいくつ、どのような文字が存在するのかというテーブルを作っておき、順に見ていけば良い

 O(N)

================================================================

*/

ll solve(){

    ll ret = 1;

    string S; cin >> S;

    int alpha[26] = {};

    for(int i = (int)S.length()-1; i >= 0;i--){

        for(int j = 0; j < 26;j++){

            if(j == S[i]-'a')continue;

            ret += alpha[j];

        }

        alpha[S[i]-'a']++;

    }

    return ret;

}

int main(void) {

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

    cout << solve() << endl;

	return 0;

}


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

#include<cstring>

#include<algorithm>

using namespace std;



typedef long long ll;

const int MAXN=2e5+5;



int n;

ll d[MAXN],cnt[30],sum;

char s[MAXN];



int main(){

    scanf("%s",s+1);

    n=strlen(s+1);

    d[1]=1,sum=1,cnt[s[1]-'a']=1;

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

        d[i]=(ll)d[i-1]+sum-cnt[s[i]-'a'];

        cnt[s[i]-'a']++;

        sum++;

    }

    printf("%lld",d[n]);

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

#include<cstring>

#include<cstdio>

using namespace std;

int num[27];char c[300100];

long long ans=0;

int main()

{

	scanf("%s",c+1);int n=strlen(c+1);

	for(int i=n;i>=1;i--)ans+=(n-i)-num[c[i]-'a']++;

	printf("%lld",ans+1);return 0;

 } 

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

#include<cstring>

#include<algorithm>

using namespace std;



typedef long long ll;

const int MAXN=2e5+5;



int n;

ll d[MAXN],cnt[30],sum;

char s[MAXN];



int main(){

    scanf("%s",s+1);

    n=strlen(s+1);

    d[1]=1,sum=1,cnt[s[1]-'a']=1;

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

        d[i]=(ll)d[i-1]+sum-cnt[s[i]-'a'];

        cnt[s[i]-'a']++;

        sum++;

    }

    printf("%lld",d[n]);

}