#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>

using namespace std;

const long long MOD = 1e9 + 7;

// Lũy thừa nhị phân tối ưu
long long power(long long base, long long exp) {
    long long res = 1;
    base %= MOD;
    while (exp > 0) {
        if (exp % 2 == 1) res = (res * base) % MOD;
        base = (base * base) % MOD;
        exp /= 2;
    }
    return res;
}

// Hàm sinh và sắp xếp các key cho unordered_map
vector<long long> generate_keys(long long X) {
    vector<long long> keys;
    keys.push_back(0); // Trạng thái 0 (tích vượt quá X)
    if (X == 0) return keys;
    
    for (long long i = 1; i <= X; ) {
        long long q = X / i;
        keys.push_back(q);
        long long next_i = X / q + 1;
        i = next_i;
    }
    // Sort bắt buộc để duyệt đúng chiều DP Knapsack
    sort(keys.begin(), keys.end()); 
    return keys;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int Q;
    long long L, R;
    if (!(cin >> Q >> L >> R)) return 0;

    // Sinh keys
    vector<long long> keysR = generate_keys(R);
    vector<long long> keysL = generate_keys(L - 1);

    // Sử dụng unordered_map theo đúng định hướng
    unordered_map<long long, long long> dpR;
    unordered_map<long long, long long> dpL;

    // Khởi tạo Base Case (Tập rỗng có tích = 1, luôn <= k với mọi k >= 1)
    for (long long k : keysR) if (k > 0) dpR[k] = 1;
    for (long long k : keysL) if (k > 0) dpL[k] = 1;

    long long cnt1 = 0;

    while (Q--) {
        char type;
        long long x;
        cin >> type >> x;

        if (type == '+') {
            if (x == 1) {
                cnt1++;
            } else {
                // Thêm: Duyệt từ lớn xuống bé
                for (int i = keysR.size() - 1; i >= 0; --i) {
                    long long v = keysR[i];
                    dpR[v] = (dpR[v] + dpR[v / x]) % MOD;
                }
                if (L > 1) {
                    for (int i = keysL.size() - 1; i >= 0; --i) {
                        long long v = keysL[i];
                        dpL[v] = (dpL[v] + dpL[v / x]) % MOD;
                    }
                }
            }
        } 
        else if (type == '-') {
            if (x == 1) {
                cnt1--;
            } else {
                // Xoá (Rollback): Duyệt từ bé lên lớn
                for (size_t i = 0; i < keysR.size(); ++i) {
                    long long v = keysR[i];
                    dpR[v] = (dpR[v] - dpR[v / x] + MOD) % MOD;
                }
                if (L > 1) {
                    for (size_t i = 0; i < keysL.size(); ++i) {
                        long long v = keysL[i];
                        dpL[v] = (dpL[v] - dpL[v / x] + MOD) % MOD;
                    }
                }
            }
        }

        // Tính kết quả
        long long ansR = dpR[R];
        long long ansL = (L > 1) ? dpL[L - 1] : 0;
        
        long long final_ans = (ansR - ansL + MOD) % MOD;
        final_ans = (final_ans * power(2, cnt1)) % MOD;
        
        cout << final_ans << "\n";
    }

    return 0;
}