$\text{Foreword}$

人都道正难则反，我偏说正也不难。

这里介绍一种正面直接统计的做法。
和补集做法相比，没有那么多的分类讨论，更多的是对问题的正向分析和逐层化简、转化，也并不麻烦。
由于需要写很多线段树的操作，码量较大，本人在210行左右（但都是较为基础的操作，写起来很舒适）。
本来这就是一道码农题不是吗！
我们开始吧。

$\text{Solution}$

前置规定：
以下设截下的串的两端点（即题面描述 $i+1,j-1$）为 $x,y$，$x,y\in (1,n)$。
设询问串长度为 $len$。
设 $s(a,b)={\sum }_{i=a}^{b}i$，$a>b$ 时，规定 $s(a,b)=0$。

（以下基本模拟我做本题的思维过程）

SA 和本题感觉不是很搭，那基本就是 SAM 了。
给的限制乍一看非常恶心，但细想想还挺有话说的。

Part 1

设询问串第一次出现的右端点 位置为 $a$，最后一次出现左端点 位置为 $b$，那么当中间截下的字符串 $x>a$ 或 $y<b$ 的时候，必然是合法的。
SAM 反串先建出后缀树，记录出现的最早和最晚位置并向父亲传递，即可维护这两个值。
容易统计这个时候的答案，应该是：
$$s(1,n-a-1)+s(1,b-2)-s(1,(b-1)-(a+1)+1)$$
最后减去的是为了容斥掉左右端点同时满足条件算重的方案数。

Part 2

那么现在的问题就转化为了：

求 $x\le a,y\ge b$ 且包含询问串的字符串 $(x,y)$ 对数。

这个东西并太不好做。
暴力怎么做？
暴力是不是我们固定一个 $x$，然后设左端点在 $x$ 右侧的最靠左的字符串的右端点为 $pos$，那么 $r$ 的取值范围就是 $[\max (b,pos),n-1]$。
随着左端点右移， $pos$ 单调不升，右端点可以取到的范围肯定是逐渐变大，最后变成 $[b,n-1]$。
我们尝试掐头去尾的计算这部分的答案。

Part 2.1

我们找到满足 $r\le b$ 的最靠左询问串，设其左端点为 $u$，那么当 $x\le u$ 时，$y$ 的取值范围就变成了 $[b,n-1]$。
这部分的贡献是：
$$(u-1)(n-b)$$
需要注意一些边界情况，如果 $u\ge a$，那么整个 part2 的贡献就是 $(a-1)(n-b)$，加上后直接返回即可。

Part 2.2

设 $l>a$ 的最靠左的询问串的左端点为 $suf$，$l\le a$ 的最靠右的询问串左端点为 $pre$，那么当 $x\in (pre,a]$ 时，$y$ 一直是在受 $suf$ 这个串约束，其范围是 $[suf+len-1,n-1]$。
这部分的贡献就是：
$$(a-pre)(n-suf)$$

Part 2.3

现在我们只剩下 $x\in [u+1,pre]$ 这一段的贡献了。

我们想想最理想的情况：每个位置都有一个询问串的左端点，那么答案显然就是：
$$\sum _{i=u+1}^{pre}n-(i+len-1)=s(n-(pre+len-1),n-(u+1+len-1))$$
但是现实很骨感，真实答案可能会取不到这么多，那么会少多少呢？
举个栗子，设左端点出现集合为 $101001$，考虑它和 $111111$ 相比少了多少答案。
不难发现，第一段长度为 $1$ 的 $0$ 串使答案减少了 $1$，第二段答案为 $2$ 的 $0$ 串使答案减少了 $1+2=3$。
一般的，一段长度为 $L$ 的极长 $0$ 串，会使答案减少 $s(1,L)$。
那么问题就变成求 $[u+1,pre]$ 这部分 $0$ 串减少的答案之和，利用线段树合并 $startpos$ 集合即可轻松维护。
(startpos这个名字是我瞎起的，就是正常SAM的endpos)

然后本题就做完了。
时间复杂度 $O((n+m)\log n)$。

$\text{Code}$

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define ok debug("OK\n")
using namespace std;const int N=4e5+100;
const int C=10;inline ll read(){ll x(0),f(1);char c=getchar();while(!isdigit(c)) {if(c=='-')f=-1;c=getchar();}while(isdigit(c)) {x=(x<<1)+(x<<3)+c-'0';c=getchar();}return x*f;
}int n,m,k;int tag[N],mn[N],mx[N];
int pos[N];
int pl[N][20];
vector<int>v[N];#define calc(x) (1ll*(x)*((x)+1)/2)
struct node{int llen,rlen,siz;ll sum;
};
node operator + (const node &a,const node &b){node o;o.siz=a.siz+b.siz;o.llen=a.llen==a.siz?a.siz+b.llen:a.llen;o.rlen=b.rlen==b.siz?b.siz+a.rlen:b.rlen;o.sum=a.sum+b.sum;o.sum+=calc(a.rlen+b.llen)-calc(a.rlen)-calc(b.llen);return o;
}
inline node emp(int len){return (node){len,len,len,calc(len)};
}struct tree{int ls,rs;node o;
};
int rt[N],tot;
struct Seg{tree tr[N*20];#define mid ((l+r)>>1)inline void pushup(int k,int l,int r){node x=tr[k].ls?tr[tr[k].ls].o:emp(mid-l+1);node y=tr[k].rs?tr[tr[k].rs].o:emp(r-mid);tr[k].o=x+y;return;}inline int copy(int x){tr[++tot]=tr[x];return tot;}void upd(int &k,int l,int r,int p){k=copy(k);if(l==r){tr[k].o=(node){0,0,1,0};return;}if(p<=mid) upd(tr[k].ls,l,mid,p);else upd(tr[k].rs,mid+1,r,p);pushup(k,l,r);}int merge(int x,int y,int l,int r){if(!x||!y) return x|y;int now=copy(x);tr[now].ls=merge(tr[now].ls,tr[y].ls,l,mid);tr[now].rs=merge(tr[now].rs,tr[y].rs,mid+1,r);pushup(now,l,r);return now;}int findsuf(int k,int l,int r,int p){if(!k) return 0;if(l==r) return (l>=p)?l:0;if(p>mid) return findsuf(tr[k].rs,mid+1,r,p);else{int res=findsuf(tr[k].ls,l,mid,p);if(res) return res;else return findsuf(tr[k].rs,mid+1,r,p);}}int findpre(int k,int l,int r,int p){if(!k) return 0;if(l==r) return (l<=p)?l:0;if(p<=mid) return findpre(tr[k].ls,l,mid,p);else{int res=findpre(tr[k].rs,mid+1,r,p);if(res) return res;else return findpre(tr[k].ls,l,mid,p);}}node query(int k,int l,int r,int x,int y){if(!k) return emp(min(r,y)-max(l,x)+1);if(x<=l&&r<=y) return tr[k].o;if(y<=mid) return query(tr[k].ls,l,mid,x,y);else if(x>mid) return query(tr[k].rs,mid+1,r,x,y);else return query(tr[k].ls,l,mid,x,y)+query(tr[k].rs,mid+1,r,x,y);}
}seg;void dfs(int x,int fa){pl[x][0]=fa;for(int k=1;pl[x][k-1];k++) pl[x][k]=pl[pl[x][k-1]][k-1];for(int to:v[x]){dfs(to,x);mn[x]=min(mn[x],mn[to]);mx[x]=max(mx[x],mx[to]);rt[x]=seg.merge(rt[x],rt[to],1,n);}if(tag[x]){seg.upd(rt[x],1,n,tag[x]);}return;
}struct SAM{int tr[N][C],fa[N],len[N],tot,lst;SAM(){tot=lst=1;}inline void ins(int c,int id){c-='0';int cur=++tot,p=lst;lst=tot;len[cur]=len[p]+1;pos[id]=cur;tag[cur]=id;mn[cur]=mx[cur]=id;for(;p&&!tr[p][c];p=fa[p]) tr[p][c]=cur;if(!p) fa[cur]=1;else{int q=tr[p][c];if(len[q]==len[p]+1) fa[cur]=q;else{int nq=++tot;mn[nq]=n+1;mx[nq]=0;len[nq]=len[p]+1;fa[nq]=fa[q];for(int i=0;i<C;i++) tr[nq][i]=tr[q][i];fa[cur]=fa[q]=nq;for(;p&&tr[p][c]==q;p=fa[p]) tr[p][c]=nq;}}return;}void build(){for(int i=2;i<=tot;i++) v[fa[i]].push_back(i);dfs(1,0);}int find(int l,int r){int x=pos[l],L=r-l+1;for(int k=18;k>=0;k--){if(len[pl[x][k]]>=L) x=pl[x][k];}return x;}
}sam;inline ll Sum(ll x,ll y){if(x>y) return 0;else return (x+y)*(y-x+1)/2;
}
ll work(int l,int r){int x=sam.find(l,r),len=r-l+1;int a=mn[x]+len-1,b=mx[x];ll ans=Sum(1,n-a-1)+Sum(1,b-2);int w=(b-1)-(a+1)+1;if(w>=1) ans-=calc(w);a=min(a,b);int pre=seg.findpre(rt[x],1,n,a),suf=seg.findsuf(rt[x],1,n,a+1);int u=seg.findpre(rt[x],1,n,b-len+1);if(u>=a){ans+=1ll*(a-1)*(n-b);return ans;}if(suf){ans+=1ll*(a-pre)*(n-(suf+len-1));}if(u) ans+=1ll*(u-1)*(n-b);//calc: [u+1,pre]u=max(u,1);if(u+1<=pre){ans+=Sum(n-(pre+len-1),n-(u+1+len-1));		node o=seg.query(rt[x],1,n,u+1,pre);ans-=o.sum;}return ans;
}char s[N];
signed main(){
#ifndef ONLINE_JUDGEfreopen("a.in","r",stdin);freopen("a.out","w",stdout);
#endifn=read();m=read();scanf(" %s",s+1);for(int i=n;i>=1;i--) sam.ins(s[i],i);sam.build();for(int i=1;i<=m;i++){int l=read(),r=read();printf("%lld\n",work(l,r));}return 0;
}
/*
*/