class BSTIterator {
    stack<TreeNode *> myStack;
public:
    BSTIterator(TreeNode *root) {
        pushAll(root);
    }

    /** @return whether we have a next smallest number */
    bool hasNext() {
        return !myStack.empty();
    }

    /** @return the next smallest number */
    int next() {
        TreeNode *tmpNode = myStack.top();
        myStack.pop();
        pushAll(tmpNode->right);
        return tmpNode->val;
    }

private:
    // 从root开始不断向左，将遇到的每个节点入栈
    void pushAll(TreeNode *node) {
        for (; node != NULL; myStack.push(node), node = node->left);
    }
};

int threeSumClosest(vector<int>& nums, int target) {
    if(nums.size() < 3) return 0;
    int closest = nums[0]+nums[1]+nums[2];
    sort(nums.begin(), nums.end());
    for(int first = 0 ; first < nums.size()-2 ; ++first) {
        if(first > 0 && nums[first] == nums[first-1]) continue;
        int second = first+1;
        int third = nums.size()-1;
        while(second < third) {
            int curSum = nums[first]+nums[second]+nums[third];
            if(curSum == target) return curSum;
            if(abs(target-curSum)<abs(target-closest)) {
                closest = curSum;
            }
            if(curSum > target) {
                --third;
            } else {
                ++second;
            }
        }
    }
    return closest;
}

int findMin(vector<int> &num) {
    int start=0,end=num.size()-1;

    while (start<end) {
        if (num[start] < num[end])
            return num[start];
        int mid = start+(end-start)/2;
        if (num[mid] > num[start]) {
            start = mid+1;
        } else {
            end = mid;
        }
    }

    return num[start];
}

class Solution {
public:
    int findMin(vector<int> &num) {
        int lo = 0;
        int hi = num.size() - 1;
        int mid = 0;

        while(lo < hi) {
            mid = lo + (hi - lo) / 2;

            if (num[mid] > num[hi]) {
                lo = mid + 1;
            }
            else if (num[mid] < num[hi]) {
                hi = mid;
            }
            else { // when num[mid] and num[hi] are same
                hi--;
            }
        }
        return num[lo];
    }
};

int binary_search(int *a, int left, int right, int target) {
    // 循环结束判断
    while (left <= right) {
        int mid = left + (right-left)/2;
        if (a[mid] == target)
            return mid;
        // 如果left=2, right=3,并且a[2]<target是将陷入死循环
        if (a[mid] < target)
            left = mid+1;
        else
            right = mid-1;
    }

}

class Solution {
public:
    // check if nums can be divided into m subsets s.t each subset's summation <= sum
    bool canSplit(vector<int>& nums, int m, long sum) {
        int c = 1;
        long s = 0;
        for (auto& num : nums) {
            s += num;
            if (s > sum) {
                s = num; // first element
                ++c;  // a new subset
            }
        }
        // c<=m indicates nums can be divided into m subsets s.t each subset's summation <= sum
        return c <= m;
    }

    int splitArray(vector<int>& nums, int m) {
        long left = 0, right = 0;
        for (auto& num : nums) {
            left = max(left, (long)num);
            right += num;
        }
        while (left < right) {
            if (left == right) return left; // answer found
            long mid = left + (right-left)/2;
            if (canSplit(nums, m, mid)) right = mid; // be smaller.
            else left = mid+1; // be bigger
        }
        return left;
    }
};

class Solution {
public:
    int trap(int A[], int n) {
        int left=0; int right=n-1;
        int res=0;
        int maxleft=0, maxright=0;
        while(left<=right){
            // 先处理小的一方，保证对面方总有更大的数
            if(A[left]<=A[right]){
                // 更新最大值
                if(A[left]>=maxleft) maxleft=A[left];
                // 因为另一边总有大于maxleft的值，所以，此时可盛水maxleft-A[left]
                else res+=maxleft-A[left];
                left++;
            } else { // 同左边
                if(A[right]>=maxright) maxright= A[right];
                else res+=maxright-A[right];
                right--;
            }
        }
        return res;
    }
};

public class Solution {

    public class Cell {
        int row;
        int col;
        int height;
        public Cell(int row, int col, int height) {
            this.row = row;
            this.col = col;
            this.height = height;
        }
    }

    public int trapRainWater(int[][] heights) {
        if (heights == null || heights.length == 0 || heights[0].length == 0)
            return 0;

        PriorityQueue<Cell> queue = new PriorityQueue<>(1, new Comparator<Cell>(){
            public int compare(Cell a, Cell b) {
                return a.height - b.height;
            }
        });

        int m = heights.length;
        int n = heights[0].length;
        boolean[][] visited = new boolean[m][n];

        // Initially, add all the Cells which are on borders to the queue.
        for (int i = 0; i < m; i++) {
            visited[i][0] = true;
            visited[i][n - 1] = true;
            queue.offer(new Cell(i, 0, heights[i][0]));
            queue.offer(new Cell(i, n - 1, heights[i][n - 1]));
        }

        for (int i = 0; i < n; i++) {
            visited[0][i] = true;
            visited[m - 1][i] = true;
            queue.offer(new Cell(0, i, heights[0][i]));
            queue.offer(new Cell(m - 1, i, heights[m - 1][i]));
        }

        // from the borders, pick the shortest cell visited and check its neighbors:
        // if the neighbor is shorter, collect the water it can trap and update its height as its height plus the water trapped
       // add all its neighbors to the queue.
        int[][] dirs = new int[][]{{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
        int res = 0;
        while (!queue.isEmpty()) {
            Cell cell = queue.poll();
            for (int[] dir : dirs) {
                int row = cell.row + dir[0];
                int col = cell.col + dir[1];
                if (row >= 0 && row < m && col >= 0 && col < n && !visited[row][col]) {
                    visited[row][col] = true;
                    res += Math.max(0, cell.height - heights[row][col]);
                    queue.offer(new Cell(row, col, Math.max(heights[row][col], cell.height)));
                }
            }
        }

        return res;
    }
}

public class Solution {

    int[] dx = {0, 0, 1, -1};
    int[] dy = {1, -1, 0, 0};

    List<int[]>[] g;
    int start;

    private int[] dijkstra() {
        int[] dist = new int[g.length];
        Arrays.fill(dist, Integer.MAX_VALUE / 2);
        dist[start] = 0;
        TreeSet<int[]> tree = new TreeSet<>((u, v) -> u[1] == v[1] ? u[0] - v[0] : u[1] - v[1]);
        tree.add(new int[]{start, 0});
        while (!tree.isEmpty()) {
            int u = tree.first()[0], d = tree.pollFirst()[1];
            for (int[] e : g[u]) {
                int v = e[0], w = e[1];
                if (Math.max(d, w) < dist[v]) {
                    tree.remove(new int[]{v, dist[v]});
                    dist[v] = Math.max(d, w);
                    tree.add(new int[]{v, dist[v]});
                }
            }
        }
        return dist;
    }

    public int trapRainWater(int[][] a) {
        if (a == null || a.length == 0 || a[0].length == 0) return 0;
        int r = a.length, c = a[0].length;

        start = r * c;
        g = new List[r * c + 1];
        for (int i = 0; i < g.length; i++) g[i] = new ArrayList<>();
        for (int i = 0; i < r; i++)
            for (int j = 0; j < c; j++) {
                if (i == 0 || i == r - 1 || j == 0 || j == c - 1) g[start].add(new int[]{i * c + j, 0});
                for (int k = 0; k < 4; k++) {
                    int x = i + dx[k], y = j + dy[k];
                    if (x >= 0 && x < r && y >= 0 && y < c) g[i * c + j].add(new int[]{x * c + y, a[i][j]});
                }
            }

        int ans = 0;
        int[] dist = dijkstra();
        for (int i = 0; i < r; i++)
            for (int j = 0; j < c; j++) {
                int cb = dist[i * c + j];
                if (cb > a[i][j]) ans += cb - a[i][j];
            }

        return ans;
    }
}

int countZero(int N) {
      int ret = 0;
      while (N) {
        ret += N/5;
           N /= 5;
      }
      return ret;
}

bool isMatch(string s, string p) {
    int star=-1, s1=0, p1=0, matched=0;
    while (s1 < s.length()) {
        if (p[p1]=='?' || s[s1]==p[p1]) {++s1, ++p1;}
        else if (p[p1] == '*') {star = p1++; matched = s1;}
        else if (star>=0) {p1 = star+1; s1 = ++matched;}
        else return false;
    }
    while (p1<p.length() && p[p1]=='*') ++p1;
    return p1==p.length();
}

/*
node： 当前节点在静态数组segTree中的位置
begin：题目给定数组的下标起始位置
end：  题目给定数组的下标终止位置
*/
void build(int node, int begin, int end) {
    if (begin == end)
        segTree[node] = array[begin]; /* 只有一个元素,节点记录该单元素 */
    else {
        /* 递归构造左右子树 */
        build(2*node, begin, (begin+end)/2);
        build(2*node+1, (begin+end)/2+1, end);

        /* 回溯时得到当前node节点的线段信息 */
        if (segTree[2 * node] <= segTree[2 * node + 1])
            segTree[node] = segTree[2 * node];
        else
            segTree[node] = segTree[2 * node + 1];
    }
}

/*
node：当前查询节点
begin,end：当前节点存储的区间，即当前结点的范围
left,right：此次query所要查询的区间
*/
int query(int node, int begin, int end, int left, int right) {
    int p1, p2;

    /*  查询区间和要求的区间没有交集  */
    if (left > end || right < begin)
        return -1;

    // 查询范围和当前结点的范围重合
    if (begin == left && end == right)
        return segTree[node];

    // 分别查询当前结点的左右孩子
    p1 = query(2 * node, begin, (begin + end) / 2, left, right);
    p2 = query(2 * node + 1, (begin + end) / 2 + 1, end, left, right);

    /*  return the expect value  */
    if (p1 == -1)
        return p2;
    if (p2 == -1)
        return p1;
    return  p1 + p2;
}

/*
node：当前节点的下标
left,right：当前节点的表示范围
ind,add：将原数组中ind位置元素增加add
*/
void Updata(int node, int left, int right, int ind, int add) {
    // 当前是叶节点了，直接更新
    if( begin == end ) {
        segTree[node] += add;
        return ;
    }
    int m = ( left + right ) >> 1;
    if(ind <= m)
        Updata(node * 2,left, m, ind, add);
    else
        Updata(node * 2 + 1, m + 1, right, ind, add);
    /*回溯更新父节点*/
    segTree[node] = segTree[node * 2] + segTree[node * 2 + 1];

}

public class NumArray {
    SegmentTreeNode root = null;
    // 线段树的节点，包含左右孩子，和其全部孩子值的和
    class SegmentTreeNode {
        int sum;
        int start, end;
        public SegmentTreeNode left, right;

        public SegmentTreeNode(int start, int end) {
            this.start = start;
            this.end = end;
            this.left = null;
            this.right = null;
            this.sum = 0;
        }
    }
    // 将数据index位置的值转换成value，树中只需要更改sum值就好
    public void Update(SegmentTreeNode root, int index, int value) {
        // 到叶节点时，直接修改sum值
        if (root.start == root.end)
            root.sum = value;
        else { // 非叶节点，要考虑修改树的中间结点
            int mid = root.start + (root.end - root.start) / 2;
            if (index <= mid) // 如果需要修改的节点在左子树，右子树不需要修改
                Update(root.left, index, value);
            else // 只修改右子树
                Update(root.right, index, value);
            // 修改根节点的sum值
            root.sum = root.left.sum + root.right.sum;
        }
    }
    // 返回从索引start到end的值的和
    public int SumRange(SegmentTreeNode root, int start, int end) {
        // root对应的范围正好是查询的范围
        if (root.start == start && root.end == end)
            return root.sum;
        int mid = root.start + (root.end - root.start) / 2;
        // 查询范围在左子树上
        if (end <= mid)
            return SumRange(root.left, start, end);
        // 查询范围在右子树上
        else if (start > mid)
            return SumRange(root.right, start, end);
        // 查询范围在左、右子树上
        return SumRange(root.left, start, mid) + SumRange(root.right, mid + 1, end);
    }

    public SegmentTreeNode ConstructSegmentTree(int[] nums, int start, int end) {
        if (start > end)
            return null;
        SegmentTreeNode ret = new SegmentTreeNode(start, end);
        if (start == end) {
            ret.sum = nums[start];
        } else {
            int mid = start + (end - start) / 2;
            ret.left = ConstructSegmentTree(nums, start, mid);
            ret.right = ConstructSegmentTree(nums, mid + 1, end);
            ret.sum = ret.left.sum + ret.right.sum;
        }
        return ret;
    }

    public NumArray(int[] nums) {
        root = ConstructSegmentTree(nums, 0, nums.length - 1);
    }

    void update(int i, int val) {
        Update(root, i, val);
    }

    public int sumRange(int i, int j) {
        return SumRange(root, i, j);
    }
}

//返回前i个元素和
int Sum(int i) {
    int s=0;
    while (i > 0) {
        s += C[i];
        i -= i & (-i);
    }
    return s;
}

// A[i]的改变值为value
void Update(int i,int value)  {
    while(i<=n) {
        C[i] += value;
        i += i & (-i);
    }
}

void Update(int x,int y,int val) {
    while(x<=n) {
        int y1 = y;
         while (y1 <= n) {
            C[x][y1] += val;
            y1 += y1 & (-y1);
        }
        x += x & (-x);
    }
}

int GetSum(int x,int y) {
    int sum=0;
    while (x > 0) {
        int y1 = y;
        while (y1 > 0) {
            sum += C[x][y1];
            y1 -= y1 & (-y1);
        }
        x -= x & (-x);
    }
    return sum;
}

#include<stdio.h>
#include<string.h>
#define n 32001
int c[n+5], total[n+5];
int Lowbit(int t) {
    return t&(t^(t-1));
}
int Sum(int end) {
    int sum = 0;
    while(end > 0) {
        sum += c[end];
        end -= Lowbit(end);
    }
    return sum;
}
void add(int li, int val) {
    while(li<=n) {
        c[li] += val;
        li += Lowbit(li);
    }
}
int main() {
    int i, j, x, y, nn;
    scanf("%d", &nn);
    memset(c, 0, sizeof(c));
    memset(total, 0, sizeof(total));
    for(i=1; i<=nn; i++) {
        scanf("%d%d", &x, &y);  //由于坐标x可能为0，因此输入坐标要+1，不然会超时0&(-0)=0;
        add(x+1, 1);
        total[Sum(x+1)-1]++;
    }
    for(i=0; i<nn; i++)
        printf("%d\n", total[i]);
}

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;
int sum[200000];
struct node {
    int x,y;
} p[20000];
void push_up(int root) {
    sum[root]=sum[root*2]+sum[root*2+1];
}
void update(int root,int l,int r,int p,int v) {
    int mid=(l+r)/2;
    if(l==r) {
        sum[root]++;
        return;
    }
    if(p<=mid)update(root*2,l,mid,p,v);
    else update(root*2+1,mid+1,r,p,v);
    push_up(root);
}
int q_sum(int root,int l,int r,int ql,int qr) {
    if(ql>r||qr<l)return 0;
    if(ql<=l&&r<=qr)return sum[root];
    int mid=(l+r)/2;
    return q_sum(root*2,l,mid,ql,qr)+q_sum(root*2+1,mid+1,r,ql,qr);
}
int main() {
    int n,i,j,m=32000;
    int _hash[20000];
    scanf("%d",&n);
    memset(_hash,0,sizeof(_hash));
    for(i=0; i<n; i++) {
        scanf("%d%d",&p[i].x,&p[i].y);
        _hash[q_sum(1,0,m,0,p[i].x)]++;
        update(1,0,m,p[i].x,1);
    }
    for(i=0; i<n; i++)
        printf("%d\n",_hash[i]);
    return 0;
}

int Sum(int i, int j){
    int result = 0;
    for (int x = i; x > 0; x -= lowbit(x)) {
        for(int y = j; y > 0; y -= lowbit(y)) {
            result += C[x][y];
        }
    }
    return result;
}

private void Modify(int i, int j, int delta){
    A[i][j]+=delta;
    for(int x = i; x< A.length; x += lowbit(x)) {
        for(int y = j; y <A[i].length; y += lowbit(y)) {
            C[x][y] += delta;
        }
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;
const int MAX = 1010;
int c[MAX][MAX];
int n;
int Lowbit(int x) {
    return x & (-x);
}

// 是将以(n,n)为右下角，(x,y)为左上角的矩形区域反转
// 需要把所有包含(x, y)的c数组元素更新
void Updata(int x,int y) {
    int i,k;
    for(i=x; i<=n; i+=Lowbit(i))
        for(k=y; k<=n; k+=Lowbit(k))
            c[i][k]++;
}

// 包含点(x, y)的所有区间的总反转次数
// 因为反转都是左上->右下，所以包含点(x, y)的区间端点不会在(x, y)右、下角
int Get(int x,int y) {
    int i,k,sum = 0;
    for(i=x; i>0; i-=Lowbit(i))
        for(k=y; k>0; k-=Lowbit(k))
            sum += c[i][k];
    return sum;
}
int main() {
    int ncases,m;
    int x1,y1,x2,y2;
    char ch[2];
    scanf("%d",&ncases);
    while( ncases-- ) {
        memset(c,0,sizeof(c));
        scanf("%d%d",&n,&m);
        while( m-- ) {
            scanf("%s",ch);
            if( ch[0] == 'C' ) {
                scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
                x1++; y1++; x2++; y2++;
                Updata(x2,y2);
                Updata(x1-1,y1-1);
                Updata(x1-1,y2);
                Updata(x2,y1-1);
            } else {
                scanf("%d%d",&x1,&y1);
                printf("%d/n",Get(x1,y1)%2);
            }
        }
        printf("/n");
    }
return 0;
}