#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 7;
int n;
long long S;
pair<long long, long long> a[N];

template <typename T>
inline void minimize(T &x, T y)
{
    if (x > y)
        x = y;
}

template <typename T>
inline pair<T, T> operator+(const pair<T, T> &x, const pair<T, T> &y)
{
    return make_pair(x.first + y.first, x.second + y.second);
}

template <typename T>
inline pair<T, T> operator-(const pair<T, T> &x, const pair<T, T> &y)
{
    return make_pair(x.first - y.first, x.second - y.second);
}

template <typename T>
void operator+=(pair<T, T> &x, const pair<T, T> &y)
{
    x = x + y;
}

template <typename T>
void operator-=(pair<T, T> &x, const pair<T, T> &y)
{
    x = x - y;
}

struct GroupDecomposition
{
    const int BLOCK_SIZE = 316;
    int SIZE, NUM_BLOCK;
    vector<pair<long long, long long>> org, bucket, sum;
    void init()
    {
        SIZE = n;
        NUM_BLOCK = SIZE / BLOCK_SIZE + bool(SIZE % BLOCK_SIZE);
        org.resize(SIZE);
        bucket.resize(SIZE);
        sum.resize(NUM_BLOCK);
        for (int i = 0; i < SIZE; ++i)
        {
            org[i] = a[i];
            bucket[i] = a[i];
            sum[getId(i)] += a[i];
        }
        for (int i = 0; i < NUM_BLOCK; ++i)
        {
            int lef = getLef(i);
            int rig = getRig(i);
            for (int j = rig - 2; j >= lef; --j)
            {
                bucket[j] += bucket[j + 1];
            }
            sort(bucket.begin() + lef, bucket.begin() + rig);
            for (int j = rig - 2; j >= lef; --j)
            {
                minimize(bucket[j].second, bucket[j + 1].second);
            }
        }
    }
    inline int getId(int p)
    {
        return p / BLOCK_SIZE;
    }
    inline int getLef(int id)
    {
        return id * BLOCK_SIZE;
    }
    inline int getRig(int id)
    {
        return min(SIZE, (id + 1) * BLOCK_SIZE);
    }
    void update(int p, int x, int y)
    {
        int id = getId(p);
        sum[id] -= org[p];
        org[p] = make_pair(x, y);
        sum[id] += org[p];
        int lef = getLef(id);
        int rig = getRig(id);
        for (int i = lef; i < rig; ++i)
        {
            bucket[i] = org[i];
        }
        for (int i = rig - 2; i >= lef; --i)
        {
            bucket[i] += bucket[i + 1];
        }
        sort(bucket.begin() + lef, bucket.begin() + rig);
        for (int i = rig - 2; i >= lef; --i)
        {
            minimize(bucket[i].second, bucket[i + 1].second);
        }
    }
    long long getMin(int p)
    {
        int id = getId(p);
        long long res = LLONG_MAX;
        pair<long long, long long> cur = make_pair(0, 0);
        for (int i = p; i >= getLef(id); --i)
        {
            cur += org[i];
            if (cur.first >= S)
            {
                minimize(res, cur.second);
            }
        }
        for (int i = id - 1; i >= 0; --i)
        {
            int lef = getLef(i);
            int rig = getRig(i);
            auto it = lower_bound(bucket.begin() + lef, bucket.begin() + rig, make_pair(S - cur.first, LLONG_MIN));
            if (it != bucket.begin() + rig)
            {
                int pos = it - bucket.begin();
                minimize(res, bucket[pos].second + cur.second);
            }
            cur += sum[i];
        }
        return res == LLONG_MAX ? -1 : res;
    }
} group;

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
#ifdef NHPHUCQT
    freopen("SEG.inp", "r", stdin);
    freopen("SEG.out", "w", stdout);
#endif

    cin >> n >> S;
    for (int i = 0; i < n; ++i)
    {
        cin >> a[i].first;
    }
    for (int j = 0; j < n; ++j)
    {
        cin >> a[j].second;
    }
    group.init();
    int q;
    cin >> q;
    while (q--)
    {
        int t;
        cin >> t;
        if (t == 1)
        {
            int i, x, y;
            cin >> i >> x >> y;
            group.update(i - 1, x, y);
        }
        else
        {
            int h;
            cin >> h;
            cout << group.getMin(h - 1) << '\n';
        }
    }
    return 0;
}