Petya once wrote a sad love song and shared it to Vasya. The song is a string consisting of lowercase English letters. Vasya made up q questions about this song. Each question is about a subsegment of the song starting from the l-th letter to the r-th letter. Vasya considers a substring made up from characters on this segment and repeats each letter in the subsegment k times, where k is the index of the corresponding letter in the alphabet. For example, if the question is about the substring "abbcb", then Vasya repeats letter 'a' once, each of the letters 'b' twice, letter 'c" three times, so that the resulting string is "abbbbcccbb", its length is 10. Vasya is interested about the length of the resulting string.

Help Petya find the length of each string obtained by Vasya.

Input

The first line contains two integers n and q (1≤ n≤ 100 000, 1≤ q ≤ 100 000) — the length of the song and the number of questions. 

The second line contains one string s — the song, consisting of n lowercase letters of English letters.

Vasya's questions are contained in the next q lines. Each line contains two integers l and r (1 ≤ l ≤ r ≤ n) — the bounds of the question.

Output

Print q lines: for each question print the length of the string obtained by Vasya.

Examples

Input


7 3
abacaba
1 3
2 5
1 7


Output


4
7
11


Input


7 4
abbabaa
1 3
5 7
6 6
2 4


Output


5
4
1
5


Input


13 7
sonoshikumiwo
1 5
2 10
7 7
1 13
4 8
2 5
3 9


Output


82
125
9
191
62
63
97

Note

In the first example Vasya is interested in three questions. In the first question Vasya considers the substring "aba", that transforms to "abba", so the answer is equal to 4. In the second question Vasya considers "baca", that transforms to "bbaccca", so the answer is 7. In the third question Vasya considers the string "abacaba",that transforms to "abbacccabba" of length 11.
/*
                   /$$$$$  /$$$$$$  /$$    /$$  /$$$$$$          
                   |__  $$ /$$__  $$| $$   | $$ /$$__  $$         
                      | $$| $$  \ $$| $$   | $$| $$  \ $$         
                      | $$| $$$$$$$$|  $$ / $$/| $$$$$$$$         
                 /$$  | $$| $$__  $$ \  $$ $$/ | $$__  $$         
                | $$  | $$| $$  | $$  \  $$$/  | $$  | $$         
                |  $$$$$$/| $$  | $$   \  $/   | $$  | $$         
                 \______/ |__/  |__/    \_/    |__/  |__/         
*/ 
import java.util.*;
import java.io.*;
import java.math.*;
import java.io.FileWriter; 
import java.io.IOException; 
public class cf{

static class Pair{
        int x;
        int y;
        Pair(int a,int b){
            x=a;
            y=b;
        
        }
    }


////////////////////////////////////**********Code-Start**********/////////////////////////////////////////////////    
public static void main(String[] args) {
    InputStream inputStream = System.in;
    OutputStream outputStream = System.out;
    if (System.getProperty("ONLINE_JUDGE") == null) {
        try {
            System.setOut(new PrintStream(
                new FileOutputStream("output.txt")));
             sc = new InputReader(new FileInputStream("input.txt"));
        }
        catch (Exception e) {
        }
        // int t=s(0);
        // while(t-->0)
            solve();
    }
     else{
        sc = new InputReader(inputStream);
        pw = new PrintWriter(outputStream);
        // int t=s(0);
        // while(t-->0) 
            solve();
        pw.close();
   }
   

}
// static ArrayList<HashSet<Integer>>arr=new ArrayList<>();
// static PriorityQueue<Integer> pq=new PriorityQueue<>();

public static void solve() {
  int n=s(0);   
  int q=s(0);
  String s=s("s");
  int a[]=new int[n];
  a[0]=(s.charAt(0)-'a'+1);
  for(int i=1;i<n;i++){
      a[i]=a[i-1]+(s.charAt(i)-'a'+1);
  }
  // for(int i=0;i<n;i++){
  //  System.out.print(a[i]+" ");   
  // }
  for(int i=0;i<q;++i){
    boolean c[]=new boolean[26];
    int fr[]=new int[26];
      int l=s(0);
      int e=s(0);
      if(l==1)
        System.out.println(a[e-1]);
     else
      System.out.println(a[e-1]-a[l-2]);
  }

}

 
////////////////////////////////////**********Code-End**********//////////////////////////////////////////////////

// Arrays.sort(a,(c,b)->(c.x==b.x)?c.y-b.y:c.x-b.x); sort the array ont the basis of y if x1==x2
// set precision --> String.format("%.df",ans);  
static int inf=Integer.MAX_VALUE;
static int minf=Integer.MIN_VALUE;
static InputReader sc;
static PrintWriter pw;
static ArrayList<ArrayList<Integer>> adj;
static int mod=1000000007;
static int mod1= 998244353;
static int max(int ...a){int m=a[0];for(int e:a)m=(m>=e)?m:e;return m;}
static int min(int ...a){int m=a[0];for(int e:a)m=(m<=e)?m:e;return m;}
static int abs(int a){return Math.abs(a);}
static long max(long ...a){long m=a[0];for(long e:a)m=(m>=e)?m:e;return m;}
static long min(long ...a){long m=a[0];for(long e:a)m=(m<=e)?m:e;return m;}
static long abs(long a){return Math.abs(a);}

static void subset(int a[],int n,ArrayList<Integer> arr){
    if(n==a.length){
        System.out.println(arr);
        return;
    }
    ArrayList<Integer> b=new ArrayList<>();
    ArrayList<Integer> c=new ArrayList<>();
    b.addAll(arr);
    c.addAll(arr);
    b.add(a[n]);
    subset(a,n+1,b);
    subset(a,n+1,c);
 }


static boolean prime[];
static int smallestFactor[];
static ArrayList<Integer> allPrimes;
static void sieveOfEratosthenes(int n)
{
    prime = new boolean[n+1];
    smallestFactor = new int[n+1];
    allPrimes=new ArrayList<>();
    smallestFactor[1] = 1;
    for(int i=2;i<n;i++) {
        prime[i] = true;
        smallestFactor[i] = i;
    }

    for(int p = 2; p*p <=n; p++)
    {
        if(prime[p])
        {
            smallestFactor[p] = p;
            for(int i = p*p; i <= n; i += p) {
                prime[i] = false;
                smallestFactor[i] = Math.min(p,smallestFactor[i]);
            }
        }
    }

    for(int i=0;i<prime.length;i++){
        if(prime[i]){
            allPrimes.add(i);
        }
    }

}
// static void initial(int n){
//    for(int i=0;i<=n;i++){
//        arr.add(new ArrayList<>());
//    }
// }
 static int numSum(int n){
  int sum=0;
  while(n!=0){
    sum+=n%10;
    n/=10;
  }
  return sum;
}
 static void sort(ArrayList<Integer> brr){
    Collections.sort(brr);
}
static void Lsort(ArrayList<Long> arr){
    Collections.sort(arr);
}
static void sort(int[] a) {
    ArrayList<Integer> l=new ArrayList<>();
    for (int i:a) l.add(i);
    Collections.sort(l);
    for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static void sort(long[] a) {
        ArrayList<Long> l=new ArrayList<>();
        for (Long i:a) l.add(i);
        Collections.sort(l);
        for (int i=0; i<a.length; i++) a[i]=l.get(i);
}


static boolean isperfect(double number)    
{   
    double sqrt=Math.sqrt(number);  
    return ((sqrt - Math.floor(sqrt)) == 0);   
}   

static boolean isPrime(long n){
    if(n<2){
        return false;
    }
    for(int i = 2; i*i<=n; i++){
        if(n%i==0){
            return false;
        }
    }
    return true;
}
static int lowerBound(int[] arr, int low, int high, long element) {
    int middle;
    while (low < high) {
        middle = low + (high - low) / 2;
        if (element > arr[middle])
            low = middle + 1;
        else
            high = middle;
    }
    if (low < arr.length && arr[low] < element)
        return -1;
    return low;
}

static  int upperBound(int[] arr, int low, int high, long element) {
    int middle;
    while (low < high) {
        middle = low + (high - low) / 2;
        if (arr[middle] > element)
            high = middle;
        else
            low = middle + 1;
    }
    if (low<arr.length &&arr[low] <= element)
        return -1;
    return low;
}

public static String sortString(String inputString) 
{ 
    char tempArray[] = inputString.toCharArray(); 
    Arrays.sort(tempArray); 
    return new String(tempArray); 
} 

public static int ask(int l, int r){
    System.out.println("? "+l+" "+r);
    System.out.flush();
    return sc.nextInt();
}
public static void swap(char []chrr, int i, int j){
    char temp=chrr[i];
    chrr[i]=chrr[j];
    chrr[j]=temp;
}
public static void swap(int []chrr, int i, int j){
    int temp=chrr[i];
    chrr[i]=chrr[j];
    chrr[j]=temp;
}
public static int countSetBits(int n){
    int a=0;
    while(n>0){
        a+=(n&1);
        n>>=1;
    }
    return a;
}
public static boolean isPowerOfTwo(long x){
    return x!=0 && ((x&(x-1)) == 0);
}

static int gcd(int a, int b)
{
  if (b == 0)
    return a;
  return gcd(b, a % b);
}
public static int lcm(int a , int b )
{
    int gc = gcd(a,b);
    return (a/gc)*b;
}
static long fast_pow(long base,long n,long M){
    if(n==0)
       return 1;
    if(n==1)
    return base;
    long halfn=fast_pow(base,n/2,M);
    if(n%2==0)
        return ( halfn * halfn ) % M;
    else
        return ( ( ( halfn * halfn ) % M ) * base ) % M;
}
static long modInverse(long n,long M){
    return fast_pow(n,M-2,M);
}
public static String reverse(String input)
{
    StringBuilder str  = new StringBuilder("") ;

    for(int i =input.length()-1 ; i >= 0  ; i-- )
    {
        str.append(input.charAt(i));
    }

    return str.toString() ;
}

public static long nCr(int n,int k)
{
    long ans=1L;
    k=k>n-k?n-k:k;
    int j=1;
    for(;j<=k;j++,n--)
    {
        if(n%j==0)
        {
            ans*=n/j;
        }else
        if(ans%j==0)
        {
            ans=ans/j*n;
        }else
        {
            ans=(ans*n)/j;
        }
    }
    return ans;
}
public static long kadanesAlgorithm(long[] arr)
{

    if(arr.length == 0)return  0 ;
    
      long[] dp = new long[arr.length] ;
      
      dp[0] = arr[0] ;
      long max =  dp[0] ;
      
      
      for(int i = 1; i <  arr.length ; i++)
      {
            if(dp[i-1] > 0)
            {
                  dp[i] = dp[i-1] + arr[i] ;
            }
            else{
                  dp[i] = arr[i] ;
            }
            
            if(dp[i] >  max)max = dp[i] ;
            
      }
      
      return max  ;
  
}

private static int countDigits(int l) {
        if (l >= 1000000000) return 10;
        if (l >= 100000000) return 9;
        if (l >= 10000000) return 8;
        if (l >= 1000000) return 7;
        if (l >= 100000) return 6;
        if (l >= 10000) return 5;
        if (l >= 1000) return 4;
        if (l >= 100) return 3;
        if (l >= 10) return 2;
        return 1;
    }

    private static int countDigits(long l) {
        if (l >= 1000000000000000000L) return 19;
        if (l >= 100000000000000000L) return 18;
        if (l >= 10000000000000000L) return 17;
        if (l >= 1000000000000000L) return 16;
        if (l >= 100000000000000L) return 15;
        if (l >= 10000000000000L) return 14;
        if (l >= 1000000000000L) return 13;
        if (l >= 100000000000L) return 12;
        if (l >= 10000000000L) return 11;
        if (l >= 1000000000L) return 10;
        if (l >= 100000000L) return 9;
        if (l >= 10000000L) return 8;
        if (l >= 1000000L) return 7;
        if (l >= 100000L) return 6;
        if (l >= 10000L) return 5;
        if (l >= 1000L) return 4;
        if (l >= 100L) return 3;
        if (l >= 10L) return 2;
        return 1;
    }   
public static int s(int n){
    return sc.nextInt();
}
public static long s(long n){
    return sc.nextLong();
}
public static String s(String n){
    return sc.next();
}
public static double s(double n){
    return sc.nextDouble();
}
public static void p(int n){
    pw.print(n);
}
public static void p(long n){
    pw.print(n);
}
public static void p(String n){
    pw.print(n);
}
public static void p(double n){
    pw.print(n);
}
public static void pln(int n){
    pw.println(n);
}
public static void pln(long n){
    pw.println(n);
}
public static void pln(String n){
    pw.println(n);
}
public static void pln(double n){
    pw.println(n);
}
public static void feedArr(long []arr){
    for(int i=0;i<arr.length;++i)
        arr[i]=sc.nextLong();
}
public static void feedArr(double []arr){
    for(int i=0;i<arr.length;++i)
        arr[i]=sc.nextDouble();
}
public static void feedArr(int []arr){
    for(int i=0;i<arr.length;++i)
        arr[i]=sc.nextInt();
}
public static void feedArr(String []arr){
    for(int i=0;i<arr.length;++i)
        arr[i]=sc.next();
}
public static String printArr(int []arr){
    StringBuilder sbr=new StringBuilder();
    for(int i:arr)
        sbr.append(i+" ");
    return sbr.toString();
}
public  static String printArr(long []arr){
    StringBuilder sbr=new StringBuilder();
    for(long i:arr)
        sbr.append(i+" ");
    return sbr.toString();
}
public static String printArr(String []arr){
    StringBuilder sbr=new StringBuilder();
    for(String i:arr)
        sbr.append(i+" ");
    return sbr.toString();
}
public static String printArr(double []arr){
    StringBuilder sbr=new StringBuilder();
    for(double i:arr)
        sbr.append(i+" ");
    return sbr.toString();
}
static class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }
    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }
    public int nextInt() {
        return Integer.parseInt(next());
    }
    public long nextLong() {
        return Long.parseLong(next());
    }
    public double nextDouble() {
        return Double.parseDouble(next());
    }
}
}


// smallest lcm(a,b) => a+b=n will be n/smallPrimefactor ans n-(n/smallestprimefactor).
