lezy prop segment

///      TANVIR HASAN

#include <bits/stdc++.h>
using namespace std;

#define uu         first
#define vv         second
#define pb         push_back
#define mp         make_pair
#define LL         long long
#define inf        INT_MAX/3
#define mod        1000000007ll
#define PI         acos(-1.0)
#define linf       (1ll<<60)-1
#define pii        pair<int,int>
#define vl        vector<LL>
#define vi        vector<int>
#define vs        vector<string>
#define pii        pair<int,int>

#define ALL(A)     (A).begin(),(A).end()
#define mset(a,v)     memset(a,v,sizeof a)
#define setinf(ar)  memset(ar,126,sizeof ar)
#define vsort(v)   sort(v.begin(),v.end())

#define FOR(I,A,B) for (__typeof (B) I = (A) ; I <= B ; ++I)
#define rof(i, a, b)	for (__typeof (b)i = (b) ; i >= a ; --i)
#define rep(I, n)		for (__typeof (n) I = 0 ; I < n ; ++I)
#define per(i, n)		for (__typeof (n)i = (n-1) ; i >= 0 ; --i)
#define forstl(I, s)	for (__typeof ((s).end ()) I = (s).begin (); I != (s).end (); ++I)
#define rofstl(I, s)	for (__typeof ((s).end ()) I = (s).end ()-1; I != (s).begin (); --I)

#define Int ({int a; scanf("%d", &a); a;})
#define I64 ({LL a; scanf("%I64d", &a); a;})
#define Double ({double a; scanf("%lf", &a); a;})
#define Char ({char a; scanf("%c", &a); a;})

#define En "\n"
#define round(a,b,n) ((a-1+b)% n + n)% n + 1  /// 1 base round,, a starting index ,,+b for left to right,,-b for left,|b| turn,,total n gor
#define tata return 0
///           error////////////////////

#define error(args...) { vector<string> _v = split(#args, ','); err(_v.begin(), args); puts(""); }

vector<string> split(const string& s, char c) {
	vector<string> v;
	stringstream ss(s);
	string x;
	while (getline(ss, x, c))
		v.emplace_back(x);
	return move(v);
}

void err(vector<string>::iterator it) {}
template<typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
	cerr << it -> substr((*it)[0] == ' ', it -> length()) << " = " << a << "  ";
	err(++it, args...);
}



#define dbg(x) cout<<#x<<" : "<<x<<endl
///          eeerrrrooooooorrrrrrr //////////////////

template <class T> inline T bigmod(T p,T e,T M){LL ret = 1;for(; e > 0; e >>= 1){if(e & 1) ret = (ret * p) % M;p = (p * p) % M;}return (T)ret;}
template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}   // M is prime}
template <class T> inline T bpow(T p,T e){LL ret = 1;for(; e > 0; e >>= 1){if(e & 1) ret = (ret * p);p = (p * p);}return (T)ret;}

/// ///////////////////////////////////////////////////////////////////////////////////////////////////////////
///                                      Let's do it                                                        ///
///                                      Let's try it                                                       ///
/// ///////////////////////////////////////////////////////////////////////////////////////////////////////////


int const _n=2e5 + 9;

char dir[_n];

struct  it
{
    int isfor=0,isbak=0;;
    it(){
        isfor=0,isbak=0;
    }

};
it tree[4*_n];int n,m;

void init(int l,int r,int node){
    if(l<0 || r>=n) return ;
    if(l==r){
        tree[node].isbak+= dir[l]=='<';
        tree[node].isfor+= dir[l]=='>';
        // error(tree[node].isfor,tree[node].isbak,node);

        return;
    }
    int left=node<<1;
    int r8=left+1;
    int mid=(l+r)>>1;
    init(l,mid,left);
    init(mid+1,r,r8);
    tree[node].isfor=tree[left].isfor+tree[r8].isfor;
    tree[node].isbak=tree[left].isbak+tree[r8].isbak;

}

it query(int strt,int end,int l,int r,int node){
    if(l<=strt && r>=end) return tree[node];
    if(r<strt || l>end ) {
        it p;
        return p;
    }
    int mid=(strt+end)>>2;
    int left = node<<1;
    int r8 =left+1;
    it p1=query(strt,mid,l,r,left);
    it p2=query(mid+1,end,l,r,r8);
    it q;
    q.isfor=tree[left].isfor+tree[r8].isfor;
    q.isbak=tree[left].isbak+tree[r8].isbak;
    return q;
}
void updateRange(int strt,int end,int l,int r,int node){
     if(r<strt || l>end  ||strt>end) return ;
     if(l<=strt && r>=end) {
           swap( tree[node].isfor,tree[node].isbak);
           return;
     }
     // dbg(node);

    int mid=(strt+end)>>1;
    int left = node*2;
    int r8 =left+1;
    updateRange(strt,mid,l,r,left);
    updateRange(mid+1,end,l,r,r8);

    tree[node].isfor=tree[left].isfor+tree[r8].isfor;
    tree[node].isbak=tree[left].isbak+tree[r8].isbak;

    return ;
}


int main()
{


     freopen("in.txt","r",stdin); freopen("output.txt","w",stdout);
/// main start

    n=Int,m=Int;
    scanf("%s",dir+1);
    init(1,n-1,1);
    // cout<<En<<En<<En;

    while(m--){
        int sin=Int;
        int l=Int;
        int r=Int;
        if(sin==2){
            if(l>r) cout<< query(1,n-1,r,l-1,1).isfor<<En;
            else  cout<< query(1,n-1,l,r-1,1).isbak<<En;

        }
        if(sin==1){
                 updateRange(1,n-1,l,r-1,1);
                 // cout<<En<<En<<En;
        }
    }





  return 0;
}