This is the easy version of the problem. The difference between the versions is that the easy version does not require you to output the numbers of the rods to be removed. You can make hacks only if all versions of the problem are solved.

Stitch likes experimenting with different machines with his friend Sparky. Today they built another machine.

The main element of this machine are n rods arranged along one straight line and numbered from 1 to n inclusive. Each of these rods must carry an electric charge quantitatively equal to either 1 or -1 (otherwise the machine will not work). Another condition for this machine to work is that the sign-variable sum of the charge on all rods must be zero.

More formally, the rods can be represented as an array of n numbers characterizing the charge: either 1 or -1. Then the condition must hold: a_1 - a_2 + a_3 - a_4 + … = 0, or ∑_{i=1}^n (-1)^{i-1} ⋅ a_i = 0.

Sparky charged all n rods with an electric current, but unfortunately it happened that the rods were not charged correctly (the sign-variable sum of the charge is not zero). The friends decided to leave only some of the rods in the machine. Sparky has q questions. In the ith question Sparky asks: if the machine consisted only of rods with numbers l_i to r_i inclusive, what minimal number of rods could be removed from the machine so that the sign-variable sum of charges on the remaining ones would be zero? Perhaps the friends got something wrong, and the sign-variable sum is already zero. In that case, you don't have to remove the rods at all.

If the number of rods is zero, we will assume that the sign-variable sum of charges is zero, that is, we can always remove all rods.

Help your friends and answer all of Sparky's questions!

Input

Each test contains multiple test cases.

The first line contains one positive integer t (1 ≤ t ≤ 10^3), denoting the number of test cases. Description of the test cases follows.

The first line of each test case contains two positive integers n and q (1 ≤ n, q ≤ 3 ⋅ 10^5) — the number of rods and the number of questions.

The second line of each test case contains a non-empty string s of length n, where the charge of the i-th rod is 1 if s_i is the "+" symbol, or -1 if s_i is the "-" symbol.

Each next line from the next q lines contains two positive integers l_i ans r_i (1 ≤ l_i ≤ r_i ≤ n) — numbers, describing Sparky's questions.

It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5, and the sum of q over all test cases does not exceed 3 ⋅ 10^5.

Output

For each test case, print a single integer — the minimal number of rods that can be removed.

Example

Input


3
14 1
+--++---++-++-
1 14
14 3
+--++---+++---
1 14
6 12
3 10
4 10
+-+-
1 1
1 2
1 3
1 4
2 2
2 3
2 4
3 3
3 4
4 4


Output


2
2
1
0
1
2
1
2
1
2
1
1
2
1

Note

In the first test case for the first query you can remove the rods numbered 5 and 8, then the following set of rods will remain: +--+--++-++-. It is easy to see that here the sign-variable sum is zero.

In the second test case:

  * For the first query, we can remove the rods numbered 1 and 11, then the following set of rods will remain: --++---++---. It is easy to see that here the sign-variable sum is zero. 
  * For the second query we can remove the rod numbered 9, then the following set of rods will remain: ---++-. It is easy to see that here the variable sum is zero. 
  * For the third query we can not remove the rods at all. 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

import static java.lang.Math.log;
import static java.lang.Math.min;

public class CodeForces {

    //------------------------------------------CONSTANTS---------------------------------------------------------------
    public static final int MOD = (int) (1e9 + 7);

    //---------------------------------------------I/0------------------------------------------------------------------

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            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;
        }
    }

    public static void print(String s) {
        System.out.println(s);
    }

    public static void main(String[] args) {
        FastReader sc = new FastReader();

        int t = 1;
        t = sc.nextInt();

        for(int i = 0; i<t; i++) {
            System.out.println(solve(sc));
        }
    }

    //------------------------------------------------SOLVE-------------------------------------------------------------

    public static String solve(FastReader sc) {
        int n = sc.nextInt(), q = sc.nextInt();
        char[] s = sc.next().toCharArray();
        int[] a = new int[n];
        for (int i = 0; i<n; i++) {
            if (s[i]=='-') {
                a[i] = -1;
            } else {
                a[i] = 1;
            }
        }

        int[] l = new int[q], r = new int[q];
        for (int i = 0; i<q; i++) {
            l[i] = sc.nextInt(); r[i] = sc.nextInt();
        }

        int[] ps1 = new int[n];
        int[] ps2 = new int[n];

        ps1[0] = a[0];
        ps2[0] = -a[0];

        for (int i = 1; i<n; i++) {
            if (i%2==0) {
                ps1[i] = ps1[i-1] + a[i];
                ps2[i] = ps2[i-1] - a[i];
            } else {
                ps1[i] = ps1[i-1] - a[i];
                ps2[i] = ps2[i-1] + a[i];
            }
        }

        StringBuilder res = new StringBuilder("");

        for (int i = 0; i<q; i++) {
            l[i]--; r[i]--;
            if (l[i]%2==0) {
                if (l[i] >= 1) {
                    int rr = Math.abs(ps1[r[i]] - ps1[l[i] - 1]);
                    if (rr!=0 && rr%2==0) {
                        rr = 2;
                    } else if (rr!=0 && rr%2==1) {
                        rr = 1;
                    }
                    res.append(rr + "\n");
                } else {
                    int rr = Math.abs(ps1[r[i]]);
                    if (rr!=0 && rr%2==0) {
                        rr = 2;
                    } else if (rr!=0 && rr%2==1) {
                        rr = 1;
                    }
                    res.append(rr + "\n");
                }
            } else {
                int rr = Math.abs(ps2[r[i]] - ps2[l[i] - 1]);
                if (rr!=0 && rr%2==0) {
                    rr = 2;
                } else if (rr!=0 && rr%2==1) {
                    rr = 1;
                }
                res.append( rr+ "\n");
            }
        }

        return res.toString();
    }


    //-----------------------------------------------FUNCTIONS----------------------------------------------------------

    public static void printArray(int[] a) {
        for(int i = 0; i<a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

    // first element that is not less than target
    public static int lowerBound(int[] arr, int begin, int end, int target) {
        while(begin < end) {
            int mid = begin + (end - begin) / 2;
            // When the element is less than the mid target
            if(arr[mid] < target)
                // begin to mid + 1, arr [begin] value is less than or equal target
                begin = mid + 1;
                // When the mid target element when greater than or equal
            else if(arr[mid] >= target)
                end = mid;
        }
        return begin;
    }

    // first element that is greater than target
    public static int upperBound(int[] arr, int begin, int end, int target) {
        while(begin < end) {
            int mid = begin + (end - begin) / 2;
            if(arr[mid] <= target)
                begin = mid + 1;
            else if(arr[mid] < target)
                end = mid;
        }
        return begin;
    }

    // generate permutations (call search and access through permutations)
    public static class Permutations {
        List<List<Integer>> permutations = new ArrayList<>();
        List<Integer> permutation = new ArrayList<>();
        boolean[] taken;
        int[] a;

        public Permutations(int[] a) {
            this.a = a;
            taken = new boolean[a.length];
        }

        void search() {
            if (permutation.size()==a.length) {
                permutations.add(new ArrayList<>(permutation));
            } else {
                for (int i = 0; i<a.length; i++) {
                    if (taken[i]) {
                        continue;
                    }
                    taken[i] = true;
                    permutation.add(a[i]);
                    search();
                    taken[i] = false;
                    permutation.remove(permutation.size()-1);
                }
            }
        }
    }

    // generate subsets (call search and access subsets)
    public static class Subsets {
        List<List<Integer>> subsets = new ArrayList<>();
        List<Integer> subset = new ArrayList<>();

        void search(int[] a, int x) {
            if (x == a.length) {
                subsets.add(new ArrayList<>(subset));
            } else {
                subset.add(a[x]);
                search(a, x+1);
                subset.remove(subset.size() - 1);
                search(a, x+1);
            }
        }
    }

    public static int gcd(int a, int b) {
        while (b != 0) {
            int t = b;
            b = a % b;
            a = t;
        }
        return a;
    }

    public static int lcm(int a, int b) {
        return (a*b)/gcd(a, b);
    }

    public static int[] prefixSum(int[] a) {
        int n = a.length;
        int[] ps = new int[n];
        ps[0] = a[0];

        for (int i = 1; i<n; i++) {
            ps[i] = ps[i-1] + a[i];
        }

        return ps;
    }

    public static int[][] prefixSum2D(int[][] a) {
        int n = a.length;
        int m = a[0].length;
        int[][] ps = new int[n][m];
        ps[0][0] = a[0][0];

        for (int j = 1; j<m; j++) {
            ps[0][j] = ps[0][j-1] + a[0][j];
        }
        for (int i = 1; i<n; i++) {
            ps[i][0] = ps[i-1][0] + a[i][0];
        }

        for (int i = 1; i<n; i++) {
            for (int j = 1; j<m; j++) {
                ps[i][j] = ps[i-1][j] + ps[i][j-1] - ps[i-1][j-1] + a[i][j];
            }
        }

        return ps;
    }

    public static double log2(double a) {
        return log(a)/log(2);
    }

    //----------------------------------------DATA-STRUCTURES-----------------------------------------------------------

    // Range queries (i.e. RMQ) in O(1), others with functions in O(log n)
    public static class SparseTable {
        int[][] st;
        int n;
        int k;

        public SparseTable(int[] a) {
            n = a.length;
            k = (int) log2(n);
            st = new int[n][k+1];

            for (int i = 0; i<n; i++) {
                st[i][0] = a[i];
            }

            // 1<<j == 2^j
            for (int j = 1; j<=k; j++) {
                for (int i = 0; i + (1 << j) <= n; i++) {
                    st[i][j] = min(st[i][j-1], st[i + (1 << (j - 1))][j - 1]);
                }
            }
        }

        //not always available O(log n) -- change the constructor to use it
        public long sumQuery(int l, int r) {
            long sum = 0;
            for (int j = k; j>=0; j--) {
                if ((1 << j) <= r - l + 1) {
                    sum += st[l][j];
                    l += 1 << j;
                }
            }

            return sum;
        }

        //always available O(1) -- change this and the constructor for rangeMaxQuery
        public int rangeMinQuery(int l, int r) {
            int j = (int) log2(r - l + 1);
            int min = min(st[l][j], st[r - (1 << j) + 1][j]);
            return min;
        }

    }

    //Range Sum Dynamic Queries O(log n)
    public static class BinaryIndexedTree {

        int[] bit;

        public BinaryIndexedTree(int[] a) {
            int n = a.length;
            bit = new int[n+1];
            // Store the actual values in BITree[]
            // using update()
            for(int i = 0; i < n; i++)
                updateBit(i, a[i]);
        }

        // O(log n) update delta at index in the array (do it on the array and then call this function)
        public void updateBit(int index, int delta) {
            index += 1;

            while (index <= bit.length) {
                bit[index] += delta;

                index += index & (-index);
            }
        }

        // Computes sum a[0...index] in O(log n)
        public int getSum(int index) {
            int sum = 0;

            index += 1;

            while (index > 0) {
                sum += bit[index];

                index -= index & (-index);
            }

            return sum;
        }
    }

    public static class UnionFind {

        int[] link;
        int[] size;

        UnionFind(int n) {
            link = new int[n];
            size = new int[n];
            for (int i = 0; i<n; i++) {
                link[i] = i;
                size[i] = 1;
            }
        }

        int find(int x) {
            while (x != link[x]) x = link[x];
            return x;
        }

        boolean same(int a, int b) {
            return find(a) == find(b);
        }

        void unite(int a, int b) {
            a = find(a);
            b = find(b);

            if (size[a] < size[b]) {
                int temp = a;
                a = b;
                b = temp;
            }

            size[a] += size[b];
            link[b] = a;
        }
    }

    public static class SegmentTree {

        int st[];

        public SegmentTree(int arr[]) {
            int n = arr.length;

            int x = (int) (Math.ceil(log2(n)));

            int maxSize = 2 * (int) Math.pow(2, x) - 1;

            st = new int[maxSize];

            build(arr, 0, n-1, 0);
        }

        int build(int arr[], int ss, int se, int si) {
            if (ss == se) {
                st[si] = arr[ss];
                return arr[ss];
            }

            int mid = ss + (se - ss) / 2; //ss+se/2

            st[si] = build(arr, ss, mid, si * 2 + 1) +
                    build(arr, mid + 1, se, si * 2 + 2);
            return st[si];
        }

        private int getSumUtil(int ss, int se, int l, int r, int si) {
            if (l <= ss && r >= se) {
                return st[si];
            }

            if (se < l || ss > r) {
                return 0;
            }

            int mid = ss + (se - ss) / 2;
            return getSumUtil(ss, mid, l, r, 2 * si + 1) +
                    getSumUtil(mid + 1, se, l, r, 2 * si + 2);
        }

        void updateValueUtil(int ss, int se, int i, int diff, int si) {
            if (i < ss || i > se) {
                return;
            }

            st[si] = st[si] + diff;
            if (se != ss) {
                int mid = ss + (se - ss) / 2;
                updateValueUtil(ss, mid, i, diff, 2 * si + 1);
                updateValueUtil(mid + 1, se, i, diff, 2 * si + 2);
            }
        }

        int getSum(int n, int l, int r) {
            if (l < 0 || r > n - 1 || l > r) {
                return -1;
            }

            return getSumUtil(0, n-1, l, r, 0);
        }

        // don't do it directly on the array but use this function that will
        // do everything for you
        void updateValue(int arr[], int n, int i, int newValue) {
            if (i < 0 || i > n - 1) {
                return;
            }

            int diff = newValue - arr[i];

            arr[i] = newValue;

            updateValueUtil(0, n - 1, i, diff, 0);
        }
    }

    // Similar to Pair in c++, non-null objects as parameters
    public static class Pair<T extends Comparable<T>, Q extends Comparable<Q>> implements Comparable<Pair<T, Q>>{
        T a;
        Q b;

        public Pair(T a, Q b) {
            this.a = a;
            this.b = b;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Pair<?, ?> pair = (Pair<?, ?>) o;
            return a.equals(pair.a) && b.equals(pair.b);
        }

        @Override
        public int hashCode() {
            return Objects.hash(a, b);
        }


        @Override
        public int compareTo(Pair<T, Q> tqPair) {
            int compareA = this.a.compareTo(tqPair.a);

            if (compareA == 0) {
                return this.b.compareTo(tqPair.b);
            } else {
                return compareA;
            }
        }
    }


}