//复杂度更好且比较好写的写法是，直接用树状数组二分找到可能的最长公共前缀，记为 x
//此时如果下一个位置可以让 Z 更大就已经 win 了，否则我们尝试改前面一个位置 p，让它尽量靠后
//注意到如果前面有相邻两个位置是“上升”的，则交换二者一定合法，所以 p 最坏就是最后一个“上升”那里
//那么在这次上升之后是一个不增的段，则更改最后一个肯定是不劣的。
//换言之，我们要不就改 x，要不就把最后一个“上升”的第一个值改大，封装一个 query(x) 求在 x-1 前完全相同的情况下，x 最小的取值使得严格比 Y 大。

//当然用为的方法加一些 ds 技巧可以也可以做到 O(lognc+log^2n)，但是要难写很多
#include<bits/stdc++.h>
#define ci const int
using namespace std;
#define ll long long
#define rep(i, x, y) for(int i = (x), stOxrj = (y); i <= stOxrj; ++i)
#define irep(i, x, y) for(int i = (x), stOxrj = (y); i >= stOxrj; --i)
#define pb emplace_back
#define all(S) S.begin(), S.end()
#define Size(S) (int)S.size()
#define fi first
#define se second
#define il inline
#define let const auto
using pii = pair<int, int>;
using vint = vector<int>;
template<typename T>
il void tmax(T &x, const T &y) { if(x < y) x = y; }
template<typename T>
il void tmin(T &x, const T &y) { if(x > y) x = y; }
const int N = (1 << 17) + 20;
int n;
struct zkw {
    int tr[N << 1], inits[N];
    // void build() { inits[n + 1] = 0; }
    // void upds(int x, int v) { inits[x] = v; }
    // int query(int lef, int rig) { return accumulate(inits + lef, inits + rig + 1, 0); }
    // int bound(int x) { rep(i, x, n + 1) if(!inits[i]) return i; }
    #define ls rt << 1
    #define rs rt << 1 | 1
    void pu(int rt) { tr[rt] = tr[ls] + tr[rs]; }
    void build(int rt = 1, int l = 1, int r = n) {
        if(l == r) return tr[rt] = inits[l], void();
        int mid = (l + r) >> 1;
        build(ls, l, mid), build(rs, mid + 1, r);
        pu(rt);
    }
    void upds(int x, int v, int rt = 1, int l = 1, int r = n) {
        if(l == r) return tr[rt] = v, void();
        int mid = (l + r) >> 1;
        x <= mid ? upds(x, v, ls, l, mid) : upds(x, v, rs, mid + 1, r);
        pu(rt);
    }
    int query(int lef, int rig, int rt = 1, int l = 1, int r = n) {
        if(!rig) return 0;
        if(lef <= l && r <= rig) return tr[rt];
        int mid = (l + r) >> 1, res = 0;
        if(lef <= mid) res = query(lef, rig, ls, l, mid);
        if(rig > mid) res += query(lef, rig, rs, mid + 1, r);
        return res;
    }
    int bound(int x, int rt = 1, int l = 1, int r = n) {
        if(tr[rt] == r - l + 1) return n + 1;
        if(l == r) return l;
        int mid = (l + r) >> 1;
        if(x <= mid) {
            int res = bound(x, ls, l, mid);
            if(res != n + 1) return res;
        }
        return bound(x, rs, mid + 1, r);
    }
}ds[10];

int cnt[10], a[N];

int ncnt[10];
bool check(int x) {
    rep(v, 0, 9) {
        int t = ds[v].query(1, x);
        if(t > cnt[v]) return false;
        ncnt[v] = cnt[v] - t;
    }
    int np = x + 1;
    irep(v, 9, 0) if(ncnt[v]) {
        int p = ds[v].bound(np);
        if(p >= np + ncnt[v]) {
            np += ncnt[v];
            continue;
        }
        return a[p] < v;
    }
    return true;
}

int solve(int p, int ed) {
    if(p <= ed) return a[p];
    rep(v, 0, 9) ncnt[v] = cnt[v] - ds[v].query(1, ed);
    bool has = false;
    rep(i, a[ed + 1] + 1, 9) if(ncnt[i]) {
        has = true;
        if(p == ed + 1) return i;
        ncnt[i]--;
        break;
    }
    if(!has) return -1;
    int np = ed + 2;
    rep(v, 0, 9) {
        int nxt = np + ncnt[v];
        if(p < nxt) return v;
        np = nxt;
    }
    return -1;
}
signed main() {
    // freopen("1.in", "r", stdin); 
    // freopen("1.out", "w", stdout);
    ios::sync_with_stdio(false), cout.tie(0);
    string s1, s2;
    cin >> s1 >> s2;
    n = s1.length();
    for(char s : s1) cnt[s - '0']++;
    rep(i, 1, n) a[i] = s2[i - 1] - '0', ds[a[i]].inits[i] = 1;
    rep(v, 0, 9) ds[v].build();
    int Q;
    cin >> Q;
    while(Q--) {
        int op, p, x;
        cin >> op >> p;
        if(op == 1) {
            cin >> x;
            ds[a[p]].upds(p, 0);
            ds[a[p] = x].upds(p, 1);
            continue;
        }
        int l = 1, r = n, ans = 0;
        while(l <= r) {
            int x = (l + r) >> 1;
            if(check(x)) l = x + 1, ans = x;
            else r = x - 1;
        }
        // cerr << p << ' ' << ans << "haha\n";
        cout << solve(p, ans) << '\n';
    }
   return 0;
}