description: Let's call the string beautiful if it does not contain a substring of length at least 2, which is a palindrome. Recall that a palindrome is a string that reads the same way from the first character to the last and from the last character to the first. For example, the strings a, bab, acca, bcabcbacb are palindromes, but the strings ab, abbbaa, cccb are not.
  
  Let's define cost of a string as the minimum number of operations so that the string becomes beautiful, if in one operation it is allowed to change any character of the string to one of the first 3 letters of the Latin alphabet (in lowercase).
  
  You are given a string s of length n, each character of the string is one of the first 3 letters of the Latin alphabet (in lowercase).
  
  You have to answer m queries — calculate the cost of the substring of the string s from l_i-th to r_i-th position, inclusive.
  
  Input
  
  The first line contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the length of the string s and the number of queries.
  
  The second line contains the string s, it consists of n characters, each character one of the first 3 Latin letters.
  
  The following m lines contain two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — parameters of the i-th query.
  
  Output
  
  For each query, print a single integer — the cost of the substring of the string s from l_i-th to r_i-th position, inclusive.
  
  Example
  
  Input
  
  
  5 4
  baacb
  1 3
  1 5
  4 5
  2 3
  
  
  Output
  
  
  1
  2
  0
  1
  
  Note
  
  Consider the queries of the example test.
  
    * in the first query, the substring is baa, which can be changed to bac in one operation; 
    * in the second query, the substring is baacb, which can be changed to cbacb in two operations; 
    * in the third query, the substring is cb, which can be left unchanged; 
    * in the fourth query, the substring is aa, which can be changed to ba in one operation. 
solution: import java.io.BufferedOutputStream;
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.PrintWriter;
  import java.util.*;
  
  
  public class Main {
  	
  	static int mod = 1000000007;
      
      // -------------------- Solve ------------------------------------------------ //
      
      public static void A(Scanner s) {
          
          long n = s.nextLong();
          
          long res = 5 * n;
          
          if (res % 2 != 0)
              res += 5;
          
          res /= 2;
          System.out.println(Math.max(res , 15));
          
      }
      
      public static void B(Scanner s) {
          int W = s.nextInt() , H = s.nextInt();
          
          int x1 = s.nextInt() , y1 = s.nextInt() , x2 = s.nextInt() , y2 = s.nextInt();
          
          int w = s.nextInt() , h = s.nextInt();
          
          int x = Math.abs(x1 - x2);
          int y = Math.abs(y1 - y2);
          double res = -1;
          if (w <= W - x2 || w <= x1 || h <= H - y2 || h <= y1)
              res = 0;
          else if (x + w <= W && y + h <= H) 
              res = Math.min(Math.min(w - W + x2 , w - x1) , Math.min(h - H + y2 , h - y1));
          else if (x + w <= W) 
              res = Math.min(w - W + x2 , w - x1);    
          else if (y + h <= H) 
              res = Math.min(h - H + y2 , h - y1);
          
          System.out.println(res);
      }
      
      public static void C(Scanner s) {
          int m = s.nextInt();
          
          int sum = 0;
          int[][] arr = new int[2][m];
          for (int i = 0 ; i < m ; i++) {
              arr[0][i] = s.nextInt();
              sum += arr[0][i];
          }
          for (int i = 0 ; i < m ; i++) {
              arr[1][i] = s.nextInt();
              sum += arr[1][i];
          }
          
          int[][] dp = new int[2][m];
          
          dp[0][0] = arr[0][0];
          dp[1][0] = arr[1][0];
          for (int i = 1 ; i < m ; i++) {
              dp[0][i] = dp[0][i - 1] + arr[0][i];
              dp[1][i] = dp[1][i - 1] + arr[1][i];
          }
          
          int res = Integer.MAX_VALUE;
          for (int i = 0 ; i < m ; i++) {
              int ans = Integer.MAX_VALUE;
              if (i == 0) 
                  ans = dp[0][m - 1] - dp[0][0];
              else if (i == m - 1)
                  ans = dp[1][m - 2];
              else 
                  ans = Math.max(dp[0][m - 1] - dp[0][i] , dp[1][i - 1]);
              res = Math.min(res , ans);
          }
          
          System.out.println(res);
          
      }
      
      public static void D(Scanner s) {
          
          int n = s.nextInt() , m = s.nextInt();
          String str = s.next();
          int[][] dp = new int[6][n];
          
          String[] seq = {"abc" , "acb" , "bac" , "bca" , "cab" , "cba"};
          for (int i = 0 ; i < 6 ; i++) {
              for (int j = 0 ; j < n ; j++) {
                  if (str.charAt(j) != seq[i].charAt(j % 3)) {
                      if (j == 0)
                          dp[i][j] = 1;
                      else
                          dp[i][j] = dp[i][j - 1] + 1;
                  } else {
                      if (j != 0)
                          dp[i][j] = dp[i][j - 1];
                  } 
                      
              }
          }
          
  //         for (int i = 0 ; i < 6 ; i++) {
  //             for (int j = 0 ; j < n ; j++) {
  //                 System.out.print(dp[i][j] + " ");    
  //             }
  //             System.out.println();
              
  //         }
          
          for (int i = 0 ; i < m ; i++) {
              int l = s.nextInt();
              int r = s.nextInt();
              int res = Integer.MAX_VALUE;
              for (int j = 0 ; j < 6 ; j++) {
                  int ans = dp[j][r - 1];
                  //print(ans);
                  if (l != 1)
                      ans = ans - dp[j][l - 2];
                  res = Math.min(res , ans);
              }
              print(res);
          }
      }
  	
  	
  	public static void main(String[] args) {
  		Scanner s = new Scanner(System.in);
  //	    PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
  //	    multiply();
  //		seive();
  //		ps(1000000);
  //		prime_number_set.add(1);
          //int t = s.nextInt();
          //solve(s);
  //	    s.nextLine();
  	    //while(t-->0) {
              
  	    	//A(s);
              //B(s);
              //C(s);
              D(s);
              
          //}
  
  	    
  //		e(s);
  //	    int n      = s.nextInt();        // read input as integer
  //	    long k     = s.nextLong();       // read input as long
  //	    double d   = s.nextDouble();     // read input as double
  //	    String str = s.next();           // read input as String
  //	    String str2  = s.nextLine();       // read whole line as String
  //	    long result = 3*k;
  //	    out.println(result);                    // print via PrintWriter	   
  //	    out.close();
  	
  	}
      
      
      
      
      
      
      
      
      
      
      
      
      
      
  	
  	//--------------------------------- Scanner --------------------------------------//
  	
  // 	public static class Scanner {
  // 	    BufferedReader br;
  // 	    StringTokenizer st;
  // 	    public Scanner() {
  // 	       br = new BufferedReader(new InputStreamReader(System.in));
  // 	    }
  // 	    String next() {
  // 	        while (st == null || !st.hasMoreElements()) {
  // 	            try {
  // 	                st = new StringTokenizer(br.readLine());
  // 	            } catch (IOException e) {
  // 	                e.printStackTrace();
  // 	            }
  // 	        }
  // 	        return st.nextToken();
  // 	    }
  // 	    int nextInt() {
  // 	        return Integer.parseInt(next());
  // 	    }
  // 	    long nextLong() {
  // 	        return Long.parseLong(next());
  // 	    }
  // 	    double nextDouble() {
  // 	        return Double.parseDouble(next());
  // 	    }
  // 	    String nextLine(){
  // 	        String str = "";
  // 	    try {
  // 	       str = br.readLine();
  // 	    } catch (IOException e) {
  // 	       e.printStackTrace();
  // 	    }
  // 	    return str;
  // 	    }
  
  // 	}
  	
  	// -------------------------- Print and Flush ------------------------------------ //
  	
  	public static void print(int[] arr) {
  		for(int i=0 ; i<arr.length ; i++) System.out.print(arr[i]+" ");
  		System.out.println();
  	}
  	
  	public static void print(int[][] arr) {
  		for(int i=0 ; i<arr.length ; i++) {
  			for(int j=0 ; j<arr[0].length ; j++) System.out.print(arr[i][j]+" ");
  			System.out.println();
  		}
  	}
  	
  	public static void print(int res) {
  		System.out.println(res);
  	}
      
      public static void print(long res) {
  		System.out.println(res);
  	}
  	
  	public static void print(String res) {
  		System.out.println(res);
  	}
  	
  	public static void print(int a , int b) {
  		System.out.println(a + " " + b);
  	}
  	
  	public static void print(char[] res) {
  		for (int i = 0 ; i < res.length ; i++) 
  			System.out.print(res[i]);
  		System.out.println();
  	}
  	
  	public static void flush() {
  		System.out.flush();
  	}
  	
  	// --------------------------- Is Palindrome ------------------------------------- //
  	
  	public static boolean isPalindrome(String str) {
  		for (int i = 0 ; i < str.length() ; i++) { 
  			if (str.charAt(i) != str.charAt(str.length() - i - 1))
  				return false;
  		}
  		return true;
  	}
  	
  	//-------------------------------- Pair ------------------------------------------ //
  	
  	public static class Pair {
  		int x;
  		int y;
  		Pair(int x, int y) {
  			this.x = x;
  			this.y = y;
  		}
  		Pair(Pair p) {
  			x = p.x;
  			y = p.y;
  		}
  	}
  	
  	//------------------------------- Comparator ------------------------------------ //
  	
  	static class cmp implements Comparator<int[]> {
  		public int compare(int[] a , int[] b) {
  			if (a[0] > b[0])
  				return 1;
              else if (a[0] == b[0] && a[1] < b[1])
                  return -1;
                  
  			return -1;
  		}
  	}
  	
  	// ----------------------------- Tries ------------------------------------------- //
  	
  	static class Tries {
  		char ch = '\u0000';
  		int count = 0;
  		Tries[] arr = new Tries[26];
  		boolean isEnd = false;
  		Tries(char ch) {
  			this.ch = ch;
  		}
  		Tries () { }
  	}
  	static Tries dummy = new Tries(); 
  	static int tries_insert(String str) {
  		Tries temp = dummy;
  		for (int i = 0 ; i < str.length() ; i++) {
  			int pos = str.charAt(i) - 'a';
  			if (temp.arr[pos] == null) 
  				temp.arr[pos] = new Tries(str.charAt(i));
  			temp = temp.arr[pos];
  		}
  		temp.isEnd = true;
  		temp.count += 1;
  		return temp.count;
  	}
  	
  	// ------------------------- Prime Number (seive) ------------------------------- //
  	
  	static int len = 10001;
  	static int[] prime_number = new int[len];
  	static Set<Integer> prime_number_set = new HashSet<>();
  	static Set<Long> three_factor_set = new HashSet<>(); 
  	static void seive() {
  		prime_number[0] = 1;
  		prime_number[1] = 1;
  		for (int i = 2 ; i < len ; i++) {
  			if (prime_number[i] == 0) {
  				long val = i;
  				prime_number_set.add(i);
  				//three_factor_set.add(val * val);
  				for (int j = i + i ; j < len ; j+=i) 
  					prime_number[j] = 1;
  			}
  		}
  	}
  	
  	static long[] product = new long[200001];
  	static void multiply() {
  		product[0] = 1;
  		product[1] = 1;
  		for (int i = 2 ; i < 200001 ; i++)
  			product[i] = (product[i - 1] * i) % mod;
  	}
  	
  	//--------------------------- perfect square ------------------------------------ //
  	
  	static Set<Integer> perfect_square = new HashSet();
  	static void ps(int len) {
  		for (int i = 1 ; i <= len ; i++) {
  			perfect_square.add(i * i);
  		}
  	}
  	
  	
  	// ---------------------------------- Sqrt -------------------------------------- //
  		
  	static long pow(long a , long b , long M) {
  		if (b == 0)
  			return 1;
  		long mid = pow(a , b/2 , M) % M;
  		if (b % 2 == 0) 
  			return (mid * mid) % M;
  		return (((mid * mid) % M) * a) % M;
  	}
  	
  	static long sumDigit(long num) {
  		long res = 0;
  		while (num > 0) {
  			res += num % 10;
  			num = num / 10;
  		}
  		return res;
  	}
  	
  	static long fact(int len , long M) {
  		long res = 1;
  		for (int i = 1 ; i < len ; i++) {
  			res = (res * i) % M;
  		}
  		return res % M;
  	}
  	
  	// ------------------------------- GCD ---------------------------------------- // 
  	
  	static long longGcd(long a , long b) {
  		if (a > b) 
  			longGcd(b , a);
  		if (a == 0)
  			return b; 
  		return longGcd(b % a , a);
  	}
      
      static int gcd(int a , int b) {
  		if (a > b) 
  			gcd(b , a);
  		if (a == 0)
  			return b; 
  		return gcd(b % a , a);
  	}
  	
  	
  	// ----------------------------- LOWER BOND ------------------------------------ //
  	
  	static int upperBond(int[] arr , int target) {
  		int st = 0 , end = arr.length - 1 , mid = 0;
  		while (st < end) {
  			mid = st + ((end - st) >> 1);
  			if (arr[mid] < target) 
  				st = mid + 1;
  			else 
  				end = mid;
  		}
  		return arr[end];
  	}
  	
  	static int lowerBond(int[] arr , int target) {
  		int st = 0 , end = arr.length - 1 , mid = 0;
  		while (st < end) {
  			mid = st + ((end - st) >> 1); 
  			if (arr[mid] > target)
  				end = mid - 1;
  			else 
  				st = mid;
  		}
  		return arr[st];
  	}
      
      
      // --------------------------- print YES NO -------------------------------------//
      
      static void py() {
          System.out.println("YES");
      }
      
      static void pn() {
          System.out.println("NO");
      }
  	
  	
  	// -------------------------- Binary Search ------------------------------------- //
       
      static int bs(int[] arr , int target) {
          int st = 0 , end = arr.length , mid = 0;
          
          while (st <= end) {
              mid = st + ((end - st) >> 1);
              
              if (arr[mid] == target)
                  return mid;
              else if (arr[mid] < target) 
                  st = mid + 1;
              else
                  end = mid - 1;
          }
          
          return end;
      }
      
      
      // -------------- Merge Sort ---------------------------------------------------//
      static void merge(int[] arr , int st , int mid , int end , int[] index) {
          
          int leftSize = mid - st;
          int[] left = new int[leftSize];
          
          for (int i = 0 ; i < leftSize ; i++) {
              left[i] = index[i + st];
          }
          
          int rightSize = end - mid + 1;
          int[] right = new int[rightSize];
          
          
          for (int i = 0 ; i < rightSize ; i++) {
              right[i] = index[i + mid];
          }
          
          int l = 0 , r = 0 , k = st;
          while (l < leftSize && r < rightSize) {
              
              if (arr[left[l]] <= arr[right[r]]) {
                  index[k] = left[l];
                  k += 1;
                  l += 1;
              } else {
                  index[k] = right[r];
                  k += 1;
                  r += 1;
              }
              
          }
          
          while (l < leftSize) {
              index[k] = left[l];    
              k += 1;
              l += 1;
          }
          
          while (r < rightSize) {
              index[k] = right[r];
              k += 1;
              r += 1;
          }
          
      }
      
      
      static void mergeSort(int[] arr , int st , int end , int[] index) {
          
          if (st == end)
              return ;
          
          int mid = st + ((end - st) >> 1);
          
          mergeSort(arr , st , mid , index);
          mergeSort(arr , mid + 1 , end , index);
          
          merge(arr , st , mid + 1 , end , index);
      }
      
  }
  
  