Baekjoon #5676

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) {
        FastReader rd = new FastReader();

        while (rd.hasMoreLine()) {
            int N = rd.nextInt();
            int M = rd.nextInt();

            int a[] = new int[N + 1];
            for (int i = 1; i <= N; i++) {
                int num = rd.nextInt();
                if (num > 0) a[i] = 1;
                else if (num < 0) a[i] = -1;
            }

            int h = (int) Math.ceil((Math.log(N) / Math.log(2)));
            int tree[] = new int[1 << (h + 1)];
            init(tree, a, 1, 1, N);

            for (int i = 0; i < M; i++) {
                String cmd = rd.next();
                int n1 = rd.nextInt();
                int n2 = rd.nextInt();

                if (cmd.equals("C")) {
                    if (n2 > 0) n2 = 1;
                    else if (n2 < 0) n2 = -1;
                    else n2 = 0;
                    update(tree, 1, 1, N, n1, n2);
                } else {
                    int ret = query(tree, 1, 1, N, n1, n2);
                    if (ret < 0) {
                        System.out.print("-");
                    } else if (ret == 0) {
                        System.out.print(0);
                    } else {
                        System.out.print("+");
                    }
                }
            }
            System.out.println();
        }

    }

    private static int query(int[] tree, int idx, int st, int ed, int l, int r) {
        if (r < st || l > ed) {
            return 1;
        }

        if (l <= st && ed <= r) {
            return tree[idx];
        }

        int mid = (st + ed) >> 1;
        int left = query(tree, idx * 2, st, mid, l, r);
        int right = query(tree, idx * 2 + 1, mid + 1, ed, l, r);
        return left * right;
    }

    private static void update(int[] tree, int idx, int st, int ed, int curr_idx, int val) {
        if (curr_idx < st || ed < curr_idx) {
            return;
        }

        if (st == ed) {
            tree[idx] = val;
            return;
        }

        int mid = (st + ed) >> 1;
        update(tree, idx * 2, st, mid, curr_idx, val);
        update(tree, idx * 2 + 1, mid + 1, ed, curr_idx, val);
        tree[idx] = tree[idx * 2] * tree[idx * 2 + 1];
    }

    private static void init(int[] tree, int[] a, int idx, int st, int ed) {
        if (st == ed) {
            tree[idx] = a[st];
            return;
        }

        int mid = (st + ed) >> 1;
        init(tree, a, idx * 2, st, mid);
        init(tree, a, idx * 2 + 1, mid + 1, ed);
        tree[idx] = tree[idx * 2] * tree[idx * 2 + 1];
    }

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        boolean hasMoreLine() {
            String str;
            try {
                if ((str = br.readLine()) != null) {
                    st = new StringTokenizer(str);
                    return true;
                }
                throw new IOException();
            } catch (IOException e) {
                return false;
            }
        }

        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;
        }
    }
}