stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#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;

}


// Optimized solution to the same problem (faster):
#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;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

    

}


// Optimized solution to the same problem (faster):
#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);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}


// Optimized solution to the same problem (faster):
#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);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

 } 

// Optimized solution to the same problem (faster):
#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);

}

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

#include <iostream>

#include <string>

using namespace std;

typedef long long i64;



i64 result;

int N;

int cnt[30];

string str;



int main(int argc, char **argv)

{

	cin >> str ;

	for(const char & x : str)

		cnt[x - 'a']++, N++;



	result = 1LL * N * (N - 1) / 2 + 1;

	for(const int & x : cnt)

		if(x != 0)

			result -= 1LL * x * (x - 1) / 2;

	cout << result << endl ;

	return 0;

}




// Optimized solution to the same problem (faster):
#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]);

}


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

using namespace std;



#define OUT(x)  cerr << #x << " = " << x << endl;

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

#define mp      make_pair

#define pii     pair<int, int>

#define pll     pair<long long, long long>

#define ll      long long



//long long extgcd(long long a, long long b, long long& x, long long& y) { //拡張gcdによる逆元

//        long long d = a;

//        if (b != 0) {

//                d = extgcd(b, a % b, y, x);

//                y -= (a / b) * x;

//        } else {

//                x = 1;

//                y = 0;

//        }

//        return d;

//}

//long long inv(long long a) {

//        long long x, y;

//        extgcd(a, MOD, x, y);

//        return (x % MOD + MOD) % MOD;

//}

//long long inv(long long a) { //フェルマーの小定理と繰り返し2乗法による逆元

//        long long res = 1;

//        long long n = MOD - 2;

//        while (n > 0) {

//                if (n & 1) res = res * a % MOD;

//                a = a * a % MOD;

//                n >>= 1;

//        }

//        return res;

//}

//

//long long nCr(long long n, long long r) {

//        if (n < r) return 0;

//        if (n - r < r) r = n - r;

//        long long ret = 1;

//        for (int i = 0; i < r; i ++) {

//                ret = ret * n % MOD;

//                n --;

//                ret = ret * inv(i + 1) % MOD;

//        }

//        return ret;

//}

long long fact[202020];

long long nCr(long long n, long long r){

        long long ans = fact[n];

        ans /= fact[r] * fact[n - r];

        return ans;

}



//long long nHr(long long n, long long r) { //n個のものから重複を許してr個をとる場合の数

//        return nCr(n + r - 1, r);

//}



void init() {

        fact[0] = 1;

        for (int i = 1; i < 202020; i ++) fact[i] = fact[i - 1] * i;

}



int main() {

        init();

        string s;

        cin >> s;

        vector<long long> cnt(26, 0);

        long long n = s.size();

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

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

        }

        long long ans = 1;

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

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

                if (cnt[i] < 2) continue;

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

        }

        cout << ans << endl;

        return 0;

}




// Optimized solution to the same problem (faster):
#include "bits/stdc++.h"

using namespace std;



int main() {

        string s; cin >> s;

        vector<long long> cnt(26, 0);

        long long n = s.size();

        for (int i = 0; i < n; i ++) cnt[s[i] - 'a'] ++;

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

        for (int i = 0; i < 26; i ++) if (cnt[i] >= 2) ans -= cnt[i] * (cnt[i] - 1) / 2;

        cout << ans << endl;

        return 0;

}




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

#include<iostream>



using namespace std;



typedef long long ll;

ll a, b, x, ans;



int main(){

	char c;

	while(~scanf("%c", &c)){

		getchar();

		if(c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u')

			cout << "vowel" << endl;

		else

			cout << "consonant" << endl;

	}

	return 0;

}

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

int main()

{

	char x;

	scanf("%c",&x);

	if(x==97||x==101||x==105||x==117||x==111)

	printf("vowel") ;

	else

	printf("consonant");

	return 0;

 } 

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

#include<cstring>

#include<iostream>

#include<cmath>

#include<algorithm>

using namespace std;



int main()

{

	char c,a = 'a',e = 'e',i = 'i',o = 'o',u = 'u';

	scanf("%c",&c);

	if(c == a||c == e||c == i||c == o||c == u)

		printf("vowel");

	else printf("consonant");

	return 0;

}

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

int main()

{

	char x;

	scanf("%c",&x);

	if(x==97||x==101||x==105||x==117||x==111)

	printf("vowel") ;

	else

	printf("consonant");

	return 0;

 } 

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

#include <cmath>

#include <cstdio>

#include <cstring>

#include <string>

#include <map>

#include <iomanip>

#include <algorithm>

#include <queue>

#include <stack>

#include <set>

#include <vector>

//const int maxn = 1e5+5;

#define ll long long

#define MAX INT_MAX

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



using namespace std;

char c;



int main()

{

    cin>>c;

    if(c=='a'||c=='e'||c=='i'||c=='o'||c=='u')

    {

        printf("vowel");

    }

    else

    {

        printf("consonant");

    }



}




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

int main()

{

	char x;

	scanf("%c",&x);

	if(x==97||x==101||x==105||x==117||x==111)

	printf("vowel") ;

	else

	printf("consonant");

	return 0;

 } 

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

#include<cstdio>

#include<cstring>

#include<cmath>

#include<algorithm>

#include<string>

using namespace std;

int main(){

    char s;

    s = getchar();

    if(s=='a'||s=='e'||s=='i'||s=='o'||s=='u')

        printf("vowel\n");

    else printf("consonant\n");

    return 0;

}


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

int main()

{

    char a;

    scanf("%c", &a);



    switch(a)

    {

    case 'a' :

        printf("vowel");

        break;

    case 'e' :

        printf("vowel");

        break;

    case 'i' :

        printf("vowel");

        break;

    case 'o' :

        printf("vowel");

        break;

    case 'u' :

        printf("vowel");

        break;

    default :

        printf("consonant");

        break;

    }

    return 0;

}


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

#include<cstdio>

#include<string>

using namespace std;

int main(){

    string str;

    while(cin >> str){

        if(str[0] == 'a' || str[0] == 'e' ||str[0] == 'i' ||str[0] == 'o'||str[0] == 'u'){

            cout << "vowel" << endl;

        }else cout << "consonant" << endl;

    }

    return 0;

}


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

int main()

{

    char a;

    scanf("%c", &a);



    switch(a)

    {

    case 'a' :

        printf("vowel");

        break;

    case 'e' :

        printf("vowel");

        break;

    case 'i' :

        printf("vowel");

        break;

    case 'o' :

        printf("vowel");

        break;

    case 'u' :

        printf("vowel");

        break;

    default :

        printf("consonant");

        break;

    }

    return 0;

}


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

#include <iostream>

#include <cstring>

#include <algorithm>

#include <set>

using namespace std;

set<char> s;

int main()

{

    char str;

    while (cin>>str)

    {

     s.insert('a');s.insert('e');s.insert('i');

    s.insert('o'); s.insert('u');

    if (s.find(str)!=s.end())

        cout<<"vowel\n";

    else cout<<"consonant\n";

    }



    return 0;

}


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

int main()

{

    char a;

    scanf("%c", &a);



    switch(a)

    {

    case 'a' :

        printf("vowel");

        break;

    case 'e' :

        printf("vowel");

        break;

    case 'i' :

        printf("vowel");

        break;

    case 'o' :

        printf("vowel");

        break;

    case 'u' :

        printf("vowel");

        break;

    default :

        printf("consonant");

        break;

    }

    return 0;

}


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

using namespace std;

int main()

{

  char a;

  cin>>a;

  if(a=='a' || a=='e' || a=='i' || a=='o' ||a=='u')

    cout<<"vowel"<<endl;

  else

    cout<<"consonant"<<endl;



}


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

int main()

{

    char a;

    scanf("%c", &a);



    switch(a)

    {

    case 'a' :

        printf("vowel");

        break;

    case 'e' :

        printf("vowel");

        break;

    case 'i' :

        printf("vowel");

        break;

    case 'o' :

        printf("vowel");

        break;

    case 'u' :

        printf("vowel");

        break;

    default :

        printf("consonant");

        break;

    }

    return 0;

}


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

using namespace std;

int main()

{

    char ch=getchar();

    (ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u') && cout<<"vowel"<<endl || cout<<"consonant"<<endl;

    return 0;

}

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

#include<cmath>

#include<cstring>

#include<string>



using namespace std;



int main()

{

	char c;

	scanf("%c",&c);

	if(c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u')

	printf("vowel\n");

	else

	printf("consonant\n");

	return 0;

}


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


#include<bits/stdc++.h>

#define lln long long int

#define llu unsigned lln

#define sc(n) scanf("%d",&n);

#define scl(n) scanf("%lld",&n);

#define scd(n) scanf("%lf",&n);

#define pf(res) printf("%d\n",res);

#define pfl(res) printf("%lld\n",res);

#define pfd(res) printf("%lf\n",res);

#define maxii 200005

using namespace std;

typedef pair<int,int> pii;

typedef pair<lln,lln> pll;

 vector<int> vi[maxii];

 vector<int>::iterator child;

typedef vector<lln> vl;

typedef vector<pii> vii;

typedef vector<pll> vll;





int arr[maxii];

int arr2[maxii];





int main()

{

    char a;

    cin>>a;

    if(a=='a'|| a=='e'|| a=='i'|| a=='o'|| a=='u' )cout<<"vowel";

    else cout<<"consonant";

}










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

using namespace std;

int main()

{

    char c;

    cin>>c;

    if(c=='a' || c=='e' || c=='i' || c=='o' || c=='u')

        cout<<"vowel";

    else

        cout<<"consonant";

    return 0;

}


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

using namespace std;

int main()

{

    char n;

    cin>>n;

    if(n=='a'||n=='e'||n=='i'||n=='o'||n=='u')

    {

        cout<<"vowel";

    }

    else

    {

        cout<<"consonant";

    }

    return 0;

}

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

signed main()

{

	char c=getchar();

	printf(c!='a'&&c!='e'&&c!='i'&&c!='o'&&c!='u'?"consonant\n":"vowel\n");

}


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

#include<cstdio>

#include<algorithm>

using namespace std;

char ch;

int main()

{

    cin>>ch;

    if(ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u') cout<<"vowel";

    else cout<<"consonant";

    return 0; 

}

// Optimized solution to the same problem (faster):
#pragma GCC optimize(s)

#include "stdio.h"

signed main()

{

	char c=getchar();

	printf(c!='a'&&c!='e'&&c!='i'&&c!='o'&&c!='u'?"consonant\n":"vowel\n");

}

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

#include<iostream>

using namespace std;

int main()

{

	char a;

	cin >> a;

	if(a=='a'||a=='e'||a=='i'||a=='o'||a=='u')

	{

		cout << "vowel" <<endl;

	}

	else

	{

		cout << "consonant" <<endl;

	}

	return 0;

}

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



int main() {

	char ch;

	scanf("%c", &ch);

	if (ch == 'a' || ch == 'o' || ch == 'e' || ch == 'i' || ch == 'u')

		puts("vowel");

	else puts("consonant");

	return 0;

}


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



using namespace std;



int main()

{

    char x;

    cin >> x ;

    if (x=='a'||x=='e'||x=='o'||x=='i'||x=='u'||x=='A'||x=='E'||x=='O'||x=='U'||x=='I'){

        cout<<" vowel"<<endl;

    }else{

    cout<<"consonant"<<endl;

    }

       return 0;

}


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



int main() {

	char ch;

	scanf("%c", &ch);

	if (ch == 'a' || ch == 'o' || ch == 'e' || ch == 'i' || ch == 'u')

		puts("vowel");

	else puts("consonant");

	return 0;

}


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

#include <string>

#include <math.h>

    using namespace std;



    int main() {

        string s="aeiuo";

        char c;

        cin>>c;

        for (int i = 0; i <s.size() ; ++i) {

            if(c==s[i]){

            cout<<"vowel";

                return 0;

            }

        }

        cout<<"consonant";}

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



int main() {

	char ch;

	scanf("%c", &ch);

	if (ch == 'a' || ch == 'o' || ch == 'e' || ch == 'i' || ch == 'u')

		puts("vowel");

	else puts("consonant");

	return 0;

}


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

using namespace std;

int main ()

{



    char c;

    cin >>c;

    if (c == 'e' || c == 'a' || c == 'o' || c == 'u' || c == 'i') {

        cout << "vowel";

    } else {

        cout << "consonant";

    }

    return 0;

}


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



int main() {

	char ch;

	scanf("%c", &ch);

	if (ch == 'a' || ch == 'o' || ch == 'e' || ch == 'i' || ch == 'u')

		puts("vowel");

	else puts("consonant");

	return 0;

}


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



using namespace std;



int main()

{

      char c;

      cin >> c;

      if(c == 'a' || c == 'i' || c == 'u' || c == 'e' || c == 'o')

            cout << "vowel";

      else

      {

            cout << "consonant";

      }

      return 0;

}


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



int main() {

	char ch;

	scanf("%c", &ch);

	if (ch == 'a' || ch == 'o' || ch == 'e' || ch == 'i' || ch == 'u')

		puts("vowel");

	else puts("consonant");

	return 0;

}


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



using namespace std;



int main()

{

 char c;

 cin >>c;

 if(c=='a'|| c=='e' || c=='u'|| c=='i' || c=='o'){

     cout<<"vowel";

 }

 else {

     cout<<"consonant";

 }



    return 0;

}

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



int main() {

	char ch;

	scanf("%c", &ch);

	if (ch == 'a' || ch == 'o' || ch == 'e' || ch == 'i' || ch == 'u')

		puts("vowel");

	else puts("consonant");

	return 0;

}


// Fastest known solution for this problem: