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

using namespace std;



int main()

{

	char c;

	cin>>c;

	cout<<++c;

}

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



int main()

{

	char x;

	scanf("%c", &x);

	printf("%c", x+1);

	

	return 0;

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

using namespace std;

int main()

{

 char a;

 cin>>a;

cout<<++a;

}

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



int main()

{

	char x;

	scanf("%c", &x);

	printf("%c", x+1);

	

	return 0;

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

using namespace std;

int main()

{ 

     char c;

     int a ;

     cin>>c;

     a = (int )c;

     cout<<(char)(a+1);

     return 0;

}

     


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



int main()

{

	char x;

	scanf("%c", &x);

	printf("%c", x+1);

	

	return 0;

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

using namespace std;

#define int  long long

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

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

#define endl   "\n"















int32_t main()

{

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);

     char alpa;

     cin>>alpa;

     int asi=alpa;

     asi++;

     char answer=asi;

     cout<<answer<<endl;

     













}

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



int main()

{

	char x;

	scanf("%c", &x);

	printf("%c", x+1);

	

	return 0;

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

#define ll long long

#define vl vector<ll int>

#define vs vector<string>

#define v vector<int>

#define mi map<int,int>

#define mc map<char,int>

//ios_base::sync_with_stdio(false);cin.tie(NULL);



using namespace std;



int main(){

	ios_base::sync_with_stdio(false);cin.tie(NULL);

	char get,res;

	cin>>get;

	res=get+1;

	cout<<res;

}


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



int main()

{

	char x;

	scanf("%c", &x);

	printf("%c", x+1);

	

	return 0;

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

using namespace std;



int main() {

	char c,x;

	cin>>c; 

	x=c+1;	

	cout<<x;



	return 0;

}


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

int main()

{

	char C;

	scanf("%c", &C);

	getchar();

	printf("%c\n", C+1);

	

	

	

	return 0;

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

using namespace std;

int main(){

    char a;

    cin >> a;

    cout << (char)(a+1);

}

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

int main()

{

	char C;

	scanf("%c", &C);

	getchar();

	printf("%c\n", C+1);

	

	

	

	return 0;

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

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long ll;

const int inf = 0x3f3f3f3f;

const int mod = (1 ? 1e9+7 : 998244353);







int main()

{

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

	ll a, b, c, d, e, f, g, T;

	char z;

	cin >> z;

	z++;

	cout << z << endl;

}






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

int main()

{

	char C;

	scanf("%c", &C);

	getchar();

	printf("%c\n", C+1);

	

	

	

	return 0;

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

using namespace std;



int main()

{

	char c;

	cin>>c;

	cout<<++c;

}

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

int main()

{

	char C;

	scanf("%c", &C);

	getchar();

	printf("%c\n", C+1);

	

	

	

	return 0;

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

using namespace std;

int main()

{

 char a;

 cin>>a;

cout<<++a;

}

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

int main()

{

	char C;

	scanf("%c", &C);

	getchar();

	printf("%c\n", C+1);

	

	

	

	return 0;

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

using namespace std;

int main()

{ 

     char c;

     int a ;

     cin>>c;

     a = (int )c;

     cout<<(char)(a+1);

     return 0;

}

     


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

int main()

{

	char C;

	scanf("%c", &C);

	getchar();

	printf("%c\n", C+1);

	

	

	

	return 0;

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

using namespace std;

#define int  long long

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

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

#define endl   "\n"















int32_t main()

{

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);

     char alpa;

     cin>>alpa;

     int asi=alpa;

     asi++;

     char answer=asi;

     cout<<answer<<endl;

     













}

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

int main()

{

	char C;

	scanf("%c", &C);

	getchar();

	printf("%c\n", C+1);

	

	

	

	return 0;

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

#define ll long long

#define vl vector<ll int>

#define vs vector<string>

#define v vector<int>

#define mi map<int,int>

#define mc map<char,int>

//ios_base::sync_with_stdio(false);cin.tie(NULL);



using namespace std;



int main(){

	ios_base::sync_with_stdio(false);cin.tie(NULL);

	char get,res;

	cin>>get;

	res=get+1;

	cout<<res;

}


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

int main()

{

	char C;

	scanf("%c", &C);

	getchar();

	printf("%c\n", C+1);

	

	

	

	return 0;

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

using namespace std;



int main() {

	char c,x;

	cin>>c; 

	x=c+1;	

	cout<<x;



	return 0;

}


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



int main()

{

	int a;

		scanf("%c", &a);

			printf("%c", a + 1);

			

	return 0;

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

using namespace std;

int main(){

    char a;

    cin >> a;

    cout << (char)(a+1);

}

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



int main()

{

	int a;

		scanf("%c", &a);

			printf("%c", a + 1);

			

	return 0;

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

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long ll;

const int inf = 0x3f3f3f3f;

const int mod = (1 ? 1e9+7 : 998244353);







int main()

{

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

	ll a, b, c, d, e, f, g, T;

	char z;

	cin >> z;

	z++;

	cout << z << endl;

}






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



int main()

{

	int a;

		scanf("%c", &a);

			printf("%c", a + 1);

			

	return 0;

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

using namespace std;



int main()

{

	char c;

	cin>>c;

	cout<<++c;

}

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



int main()

{

	int a;

		scanf("%c", &a);

			printf("%c", a + 1);

			

	return 0;

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

using namespace std;

int main()

{

 char a;

 cin>>a;

cout<<++a;

}

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



int main()

{

	int a;

		scanf("%c", &a);

			printf("%c", a + 1);

			

	return 0;

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

using namespace std;

int main()

{ 

     char c;

     int a ;

     cin>>c;

     a = (int )c;

     cout<<(char)(a+1);

     return 0;

}

     


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



int main()

{

	int a;

		scanf("%c", &a);

			printf("%c", a + 1);

			

	return 0;

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

using namespace std;

#define int  long long

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

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

#define endl   "\n"















int32_t main()

{

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);

     char alpa;

     cin>>alpa;

     int asi=alpa;

     asi++;

     char answer=asi;

     cout<<answer<<endl;

     













}

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



int main()

{

	int a;

		scanf("%c", &a);

			printf("%c", a + 1);

			

	return 0;

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

#define ll long long

#define vl vector<ll int>

#define vs vector<string>

#define v vector<int>

#define mi map<int,int>

#define mc map<char,int>

//ios_base::sync_with_stdio(false);cin.tie(NULL);



using namespace std;



int main(){

	ios_base::sync_with_stdio(false);cin.tie(NULL);

	char get,res;

	cin>>get;

	res=get+1;

	cout<<res;

}


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



int main()

{

	int a;

		scanf("%c", &a);

			printf("%c", a + 1);

			

	return 0;

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

using namespace std;

long long s,sum,n,a[1000001],b[1000001],cnt,ans;

long long f(long long x,long long y)

{

	if (x*y%9!=0)

		return x*y%9;

	if (x==0)

		return 0;

	return 9; 

} 

int main()

{

	cin>>n;

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

	{

		cin>>a[i]>>b[i];

		ans+=b[i];

	}

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

	{

		cnt=0;

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

			if (f(a[i],j)+a[i]>9)

				cnt++;

		cnt*=(b[i]/9);

		for (int j=0;j<=b[i]%9-1;++j)

			if (f(a[i],j)+a[i]>9)

				cnt++;

		if (f(a[i],0)+a[i]>9)

			cnt--;

		ans+=cnt;

	}

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

		a[i]=f(a[i],b[i]);

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

		{

			sum+=a[i];

			if (sum>9)

			{

				sum-=9;

				ans++;

			}

		}

	cout<<ans-1<<endl;

	return 0;

}

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

int main(){

	long long t=0,sum=0,n,k[200010],s[200010];

	scanf("%lld",&n);

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

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

		sum+=k[i]*s[i];

		t+=s[i];

	}

	if(sum%9==0) printf("%lld",sum/9+t-2);

	else printf("%lld",sum/9+t-1);

	return 0;

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

#include<cstdio>

#include<cstdlib>

#include<cmath>

#include<cstring>

#include<algorithm>

#include<queue>

#define LL long long

#define inl inline

#define re register

#define MAXN 201000

using namespace std;

struct dig

{

	int d;

	LL c;

}g[MAXN];

int m;

int map[11][11],t[11][11];

int now;

LL ans;

void push(int x){ans+=t[now][x];now=map[now][x];}

void work(int d,LL c)

{

	if(c==0)return ;

	ans+=c/2*t[d][d];

	if(c&1)push(d);

	work(map[d][d],c/2);

}

int main()

{

	scanf("%d",&m);

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

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

		{

			map[i][j]=i+j;t[i][j]=1;

			while(map[i][j]>=10)

			{

				map[i][j]=map[i][j]/10+map[i][j]%10;

				t[i][j]++;

			}

		}

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

	{

		int d;LL c;

		scanf("%d%lld",&d,&c);

		work(d,c);

	}

	cout<<ans-1;

	return 0;

}




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

int main(){

	long long t=0,sum=0,n,k[200010],s[200010];

	scanf("%lld",&n);

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

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

		sum+=k[i]*s[i];

		t+=s[i];

	}

	if(sum%9==0) printf("%lld",sum/9+t-2);

	else printf("%lld",sum/9+t-1);

	return 0;

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

#define WR "txt"



void Open() { freopen(WR".in", "r", stdin); freopen(WR".out", "w", stdout); }

void Close() { fclose(stdin); fclose(stdout); }

using namespace std;

long long Read()  {

	long long val = 0, opt = 1; char ch;

	while (!isdigit(ch = getchar() )) if (ch == '-') opt = -1;

	while (isdigit( ch )) (val *= 10) += ch - '0', ch= getchar();

	return val * opt;

}



long long Sum, n, b, c, Ans;



void work()  {

	n = Read();

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

		b = Read(), c = Read();

		Ans += (c - 1) + (b * c - 1) / 9;

		Sum += (b * c - 1) % 9 + 1; 

	}

	Ans += (n - 1) + (Sum - 1) / 9;

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

}



int main(void)  {

	//Open();

	work();

	//Close();

	return 0;

}

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

int main(){

	long long t=0,sum=0,n,k[200010],s[200010];

	scanf("%lld",&n);

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

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

		sum+=k[i]*s[i];

		t+=s[i];

	}

	if(sum%9==0) printf("%lld",sum/9+t-2);

	else printf("%lld",sum/9+t-1);

	return 0;

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

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

#define RREP(i, n) for (int i = (n); i >= 0; i--)

#define FOR(i, m, n) for (int i = (m); i < (n); i++)

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

using namespace std;

using llong = long long;



const int INF = 100100100;

const int MOD = 1e9 + 7;



int main() {

    cin.tie(0);

    ios::sync_with_stdio(false);



    llong M;

    cin >> M;



    llong d[300000];

    llong c[300000];

    REP(i, M) {

        llong tmp_d, tmp_c;

        cin >> tmp_d >> tmp_c;

        d[i] = tmp_d;

        c[i] = tmp_c;

    }



    llong now = d[0];

    c[0]--;

    llong index = 0;

    llong count = 0;

    while (index < M) {

        llong sum = now + c[index] * d[index];

        if (sum >= 10) {

            if (sum % 9 == 0) {

                count += c[index] + sum / 9 - 1;

                now = 9;

            } else {

                count += c[index] + sum / 9;

                now = sum % 9;

            }

        } else {

            count += c[index];

            now = sum;

        }



        /*

        while (c[index] >= 1) {

            now += d[index];

            c[index]--;

            count++;

            if (now >= 10) {

                now = now - 9;

                count++;

            }

        }

        */

        index++;

    }



    cout << count << "\n";



    return 0;

}


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

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

#define RREP(i, n) for (int i = (n); i >= 0; i--)

#define FOR(i, m, n) for (int i = (m); i < (n); i++)

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

using namespace std;

using llong = long long;



const int INF = 100100100;

const int MOD = 1e9 + 7;



int main() {

    cin.tie(0);

    ios::sync_with_stdio(false);



    llong M;

    cin >> M;



    llong sum = 0;

    llong ans = 0;

    REP(i, M) {

        llong d, c;

        cin >> d >> c;

        ans += c;

        sum += d * c;

    }



    cout << ((sum - 1) / 9) + ans - 1 << "\n";



    return 0;

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

using namespace std;



typedef complex<double> C;



int solve(int N, vector<double>& x, vector<double>& y) {

    vector<C> point(N);



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

        point[j] = C(x[j], y[j]);

    }



    int ret = 1;



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

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

            C mid = (point[j] + point[k]) * 0.5;



            C normal = (point[j] - point[k]) * C(0, 1);

            normal /= abs(point[j] - point[k]);



            double a = sqrt(1 - norm(mid - point[j]));



            C centre1 = mid + a * normal;

            int count = 0;

            for (int l = 0; l < N; ++l) {

                if (abs(centre1 - point[l]) < 1.0 + 1e-9) {

                    ++count;

                }

            }

            ret = max(ret, count);



            C centre2 = mid - a * normal;

            count = 0;

            for (int l = 0; l < N; ++l) {

                if (abs(centre2 - point[l]) < 1.0 + 1e-9) {

                    ++count;

                }

            }

            ret = max(ret, count);



        }

    }



    return ret;

}



int main () {

    int N;

    vector<double> x, y;



    while (true) {

        cin >> N;

        if (N == 0) break;



        x.resize(N);

        y.resize(N);



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

            cin >> x[j] >> y[j];

        }



        cout << solve(N, x, y) << endl;

    }



    return 0;

}

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

#include <algorithm>

#include <cmath>

using namespace std;



constexpr double EPS = 1e-6;



inline double sq(double x) { return x*x; }



struct point {

    double x, y;

    point() {}

    point(double x, double y): x(x), y(y) {}



    point operator + (const point& o) const { return point(x+o.x, y+o.y); }

    point operator - (const point& o) const { return point(x-o.x, y-o.y); }

    point operator * (const double a) const { return point(x*a, y*a); }

    point operator / (const double a) const { return point(x/a, y/a); }

};



double fabs(point a) { return sqrt(a.x*a.x + a.y*a.y); }

double dist(point a, point b) { return fabs(a - b); }



int N;

point P[300];



int solve() {

    int ans = 1;

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

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

            if (dist(P[i], P[j]) > 2) continue;



            point d = (P[j] - P[i]) / dist(P[i], P[j]);

            point t = (P[i] + P[j]) / 2;

            double k = sqrt(1 - sq(dist(P[i], P[j]) / 2));

            point cs[2] = {t + point(d.y, -d.x) * k, t + point(-d.y, d.x) * k};



            for (point c : cs) {

                int count = 0;

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

                    if (dist(c, P[i]) <= 1 + EPS) ++count;

                }

                ans = max(ans, count);

            }

        }

    }



    return ans;

}



int main(void) {

    while (true) {

        cin >> N; if (N == 0) break;

        for (int i = 0; i < N; ++i) cin >> P[i].x >> P[i].y;

        cout << solve() << endl;

    }

    return 0;

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

using namespace std;



typedef complex<double> C;



const double EPS = 1e-9;



int solve(int N, vector<double>& x, vector<double>& y) {

    vector<C> point(N);



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

        point[j] = C(x[j], y[j]);

    }



    int ret = 1;



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

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

            C mid = (point[j] + point[k]) * 0.5;



            C normal = (point[j] - point[k]) * C(0, 1);

            normal /= abs(point[j] - point[k]);



            double a = sqrt(1 - norm(mid - point[j]));



            C centre1 = mid + a * normal;

            int count = 0;

            for (int l = 0; l < N; ++l) {

                if (abs(centre1 - point[l]) < 1.0+EPS) {

                    ++count;

                }

            }

            ret = max(ret, count);



            C centre2 = mid - a * normal;

            count = 0;

            for (int l = 0; l < N; ++l) {

                if (abs(centre2 - point[l]) < 1.0+EPS) {

                    ++count;

                }

            }

            ret = max(ret, count);



        }

    }



    return ret;

}



int main () {

    int N;

    vector<double> x, y;



    while (true) {

        cin >> N;

        if (N == 0) break;



        x.resize(N);

        y.resize(N);



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

            cin >> x[j] >> y[j];

        }



        cout << solve(N, x, y) << endl;

    }



    return 0;

}

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

#include <algorithm>

#include <cmath>

using namespace std;



constexpr double EPS = 1e-6;



inline double sq(double x) { return x*x; }



struct point {

    double x, y;

    point() {}

    point(double x, double y): x(x), y(y) {}



    point operator + (const point& o) const { return point(x+o.x, y+o.y); }

    point operator - (const point& o) const { return point(x-o.x, y-o.y); }

    point operator * (const double a) const { return point(x*a, y*a); }

    point operator / (const double a) const { return point(x/a, y/a); }

};



double fabs(point a) { return sqrt(a.x*a.x + a.y*a.y); }

double dist(point a, point b) { return fabs(a - b); }



int N;

point P[300];



int solve() {

    int ans = 1;

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

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

            if (dist(P[i], P[j]) > 2) continue;



            point d = (P[j] - P[i]) / dist(P[i], P[j]);

            point t = (P[i] + P[j]) / 2;

            double k = sqrt(1 - sq(dist(P[i], P[j]) / 2));

            point cs[2] = {t + point(d.y, -d.x) * k, t + point(-d.y, d.x) * k};



            for (point c : cs) {

                int count = 0;

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

                    if (dist(c, P[i]) <= 1 + EPS) ++count;

                }

                ans = max(ans, count);

            }

        }

    }



    return ans;

}



int main(void) {

    while (true) {

        cin >> N; if (N == 0) break;

        for (int i = 0; i < N; ++i) cin >> P[i].x >> P[i].y;

        cout << solve() << endl;

    }

    return 0;

}
// Slower C++ solution:
#pragma GCC optimize("Ofast")

#pragma GCC optimize("inline")

#include <bits/stdc++.h>

#define rint register int

using namespace std;

const int MOD = 1000000007;

const int N = 3001;

int n,cur;

long long dp[2][N];

char ch;

inline void adj(long long &x) {if(x>=MOD)x-=MOD;}

int main()

{

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

    dp[0][1]=1LL;

    for (rint i=2;i<=n;i++,cur^=1)

    {

        scanf("%c",&ch);

        if (ch=='<')

        {

            dp[cur^1][1]=0LL;

            for (rint j=2;j<=i;j++) 

            {

                dp[cur^1][j]=dp[cur^1][j-1]+dp[cur][j-1];

                adj(dp[cur^1][j]);

            }

        }

        else 

        {

            dp[cur^1][i]=0LL;

            for (rint j=i-1;j>=1;j--) 

            {

                dp[cur^1][j]=dp[cur^1][j+1]+dp[cur][j];

                adj(dp[cur^1][j]);

            }

        }

    }

    for (rint i=1;i<n;i++) dp[cur][n]+=dp[cur][i];

    printf("%lld\n",dp[cur][n]%MOD);

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.1631807593950345x):
#pragma GCC optimize("Ofast")

#include <cstdio>

#define rint register int

using namespace std;

const int MOD = 1000000007;

const int N = 3001;

int n,cur;

long long dp[2][N];

char ch;

inline void adj(long long &x) {if(x>=MOD)x-=MOD;}

int main()

{

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

    dp[0][1]=1LL;

    for (rint i=2;i<=n;i++,cur^=1)

    {

        scanf("%c",&ch);

        if (ch=='<')

        {

            dp[cur^1][1]=0LL;

            for (rint j=2;j<=i;j++) 

            {

                dp[cur^1][j]=dp[cur^1][j-1]+dp[cur][j-1];

                adj(dp[cur^1][j]);

            }

        }

        else 

        {

            dp[cur^1][i]=0LL;

            for (rint j=i-1;j>=1;j--) 

            {

                dp[cur^1][j]=dp[cur^1][j+1]+dp[cur][j];

                adj(dp[cur^1][j]);

            }

        }

    }

    for (rint i=1;i<n;i++) dp[cur][n]+=dp[cur][i];

    printf("%lld\n",dp[cur][n]%MOD);

    return 0;

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

#include<cstdio>

using namespace std;

typedef long long LL;

int main()

{

      int  n,m;

      LL sum_even,sum_odd,mul;

      while(cin>>n>>m)

      {

           sum_even=sum_odd=0;

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

           {

                mul=(LL) i*m;

                if(mul%2==1)continue;

                if(mul/2>n)break;

                if(mul/2%m==0)++sum_even;

                else ++sum_odd;

           }

           cout<<sum_odd*sum_odd*sum_odd+sum_even*sum_even*sum_even<<endl;

      }

}


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

using namespace std;

long long N,K,zj,cnt;

int main()

{

	scanf("%lld %lld",&N,&K);

	if(K%2==0)

	{

		zj=N/K;

		cnt+=zj*(zj-1)*(zj-2);

		cnt+=zj*(zj-1)*3;

		cnt+=zj;

		if(N%K>=K/2)

		zj++;

		cnt+=zj*(zj-1)*(zj-2);

		cnt+=zj*(zj-1)*3;

		cnt+=zj;

	}

	else

	{

		zj=N/K;

		cnt+=zj*(zj-1)*(zj-2);

		cnt+=zj*(zj-1)*3;

		cnt+=zj;

	}

	printf("%lld",cnt);

	return 0;

}