#include<bits/stdc++.h>
#define ll long long
#define eps 1e-7
#define inf 1e9
#define linf 1e18
#define pb push_back
#define mod 1e9 + 7
#define mp make_pair
#define ld long double
#define pi 3.141592653589793238462643
using namespace std;

ll null = 0;

struct segment;
struct line;
struct point;
struct vec;
struct ray;

struct point{
    ld x, y;
    point(){}
    point(ld x1, ld y1){
        x = x1;
        y = y1;
    }
    ld dist_to_point(point p){
        return sqrt((p.x - x) * (p.x - x) + (p.y - y) * (p.y - y));
    }
    bool operator < (point p){
        return (x < p.x) || ((x == p.x) && (y < p.y));
    }
};

struct vec{
    ld x, y;
    vec (ld x1, ld y1){
        x = x1;
        y = y1;
    }
    vec (point a, point b){
        x = b.x - a.x;
        y = b.y - a.y;
    }
    vec normal(){
        vec ans;
        ans.x = y;
        ans.y = -x;
        return ans;
    }
    vec opposite(){
        vec ans;
        ans.x = -x;
        ans.y = -y;
        return ans;
    }
    vec sum(vec b){
        vec ans;
        ans.x = x + b.x;
        ans.y = y + b.y;
        return ans;
    }
    ld cross_product(vec v){
        return x * v.y - v.x * y;
    }
    ld dot_product(vec v){
        return x * v.x + y * v.y;
    }
    vec resize(ld size){
        vec ans;
        ans.x = (x * size) / len();
        ans.y = (y * size) / len();
        return ans;
    }
    vec(){}
    ld len(){
        return sqrt(x * x + y * y);
    }
};


struct line{
    ld a, b, c;
    line (point a1, point b1){
        a = a1.y - b1.y;
        b = b1.x - a1.x;
        c = -a1.x * a - a1.y * b;
    }
    line (ld a1, ld b1, ld c1){
        a = a1;
        b = b1;
        c = c1;
    }
    line(){}
    vec normal_vec(){
        vec ans;
        ans.x = a;
        ans.y = b;
        return ans;
    }
    line normal_line(point p){
        line ans;
        ans.a = -b;
        ans.b = a;
        ans.c = -ans.a * p.x - ans.b * p.y;
        return ans;
    }
    ld get_x(ld y1){
        if (a == 0) return 0;
        return (-c - b * y1) / a;
    }
    ld get_y(ld x1){
        if (b == 0) return 0;
        return (-c - a * x1) / b;
    }
    point intersection(line l){
        point ans;
        ans.x = (-c * l.b + l.c * b) / (a * l.b - l.a * b);
        ans.y = (-a * l.c + l.a * c) / (a * l.b - l.a * b);
        return ans;
    }
    bool parallels(line l){
        return a * l.b - l.a * b == 0;
    }
    ld dist_to_point(point p){
        return abs((a * p.x + b * p.y + c) / (sqrt(a * a + b * b)));
    }
    ll is_inside(point p){
        ld k = a * p.x + b * p.y + c;
        if (k < 0) return -1;
        else if (k == 0) return 0;
        return 1;
    }
};

struct segment{
    point a, b;
    segment(){}
    segment(point a1, point b1){
        a = a1;
        b = b1;
    }
    ld len(){
        return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
    }
    bool is_inside(point p){
        line l(a, b);
        if (l.is_inside(p) != 0) return false;
        vec v(p, a), v1(p, b);
        if (v.dot_product(v1) > 0) return false;
        return true;
    }
    long double dist_to_point(point p){
        vec v(a, p), v1(a, b), v2(b, p), v3(b, a);
        if (v.dot_product(v1) < 0) return p.dist_to_point(a);
        if (v2.dot_product(v3) < 0) return p.dist_to_point(b);
        line l(a, b);
        return l.dist_to_point(p);
    }
    point get_center(){
        point ans;
        ans.x = (a.x + b.x) / 2;
        ans.y = (a.y + b.y) / 2;
        return ans;
    }
};

struct ray{
    point a, b;
    ray(point p, point p1){
        a = p;
        b = p1;
    }
    ray(){}
    ld dist_to_point(point p){
        vec v(a, p), v1(a, b);
        if (v.dot_product(v1) < 0) return a.dist_to_point(p);
        line l(a, b);
        return l.dist_to_point(p);
    }
    bool is_inside(point p){
        line l(a, b);
        if (l.is_inside(p) != 0) return false;
        vec v(a, p), v1(a, b);
        if (v.dot_product(v1) < 0) return false;
        return true;
    }
};

struct angle{
    point a, b, c;
    angle(){};
    angle (point a1, point b1, point c1){
        a = a1;
        b = b1;
        c = c1;
    }
    ld get_angle(){
        vec v(b, a), v1(b, c);
        return acos(v.dot_product(v1) / (v.len() * v1.len()));
    }
    ld get_grad_angle(){
        vec v(b, a), v1(b, c);
        return 180 * acos(v.dot_product(v1) / (v.len() * v1.len())) / pi;
    }
};

struct polygon{
    ll n;
    vector <point> points;
    ld get_area(){
        point a(0, 0);
        vec v(a, points[0]);
        ld ans = 0;
        for (ll i = 1; i < n; ++i){
            vec v1(a, points[i]);
            ans = ans + v.cross_product(v1);
            v = v1;
        }
        vec v2(a, points[0]);
        vec v1(a, points[n - 1]);
        return abs(ans + v1.cross_product(v2)) / 2;
    }
};

struct triangle{
    point a, b, c;
    triangle(){}
    triangle(point a1, point b1, point c1){
        a = a1;
        b = b1;
        c = c1;
    }
    ld get_area(){
        point d(0, 0);
        vec v(a, d), v1(b, d), v2(c, d);
        return (v.cross_product(v1) + v1.cross_product(v2) + v2.cross_product(v)) / 2;
    }
    point get_center(){
        segment s(a, b), s1(a, c);
        point p = s.get_center(), p1 = s1.get_center();
        line l(a, b), l1(a, c), l2(b, c);
        l = l.normal_line(p);
        l1 = l1.normal_line(p1);
        return l.intersection(l1);
    }
    ld get_R(){
        triangle t(a, b, c);
        point p = t.get_center();
        return p.dist_to_point(a);
    }
};

ll power(ll a, ll b){
    if (b == 0) return 1;
    else if (b == 1) return a;
    else {
        ll k = power(a, b / 2);
        return k * k * power(a, b % 2);
    }
}

ll power_mod(ll a, ll b, ll MOD){
    if (b == 0) return 1;
    else if (b == 1) return a % MOD;
    else{
        ll k = power_mod(a, b / 2, MOD);
        return ((k * k) % MOD * power_mod(a, b % 2, MOD)) % MOD;
    }
}

ll sum_mod(ll a, ll b, ll MOD){
    return (a + b) % MOD;
}

ll mul_mod(ll a, ll b, ll MOD){
    return (a * b) % MOD;
}

ll ord(char a){
    return a;
}

char chr(ll a){
    return a;
}

ll strtoint(string s){
    ll ans = 0;
    for (ll i = 0; i < s.size(); ++i){
        ans *= 10;
        ans += ord(s[i]) - 48;
    }
    return ans;
}

string rev_string(string s){
    string ans = "";
    for (ll i = s.size(); i >= 0; --i){
        ans += s[i];
    }
    return ans;
}

string inttostr(ll a){
    string ans = "", ans1 = "";
    while (a > 0){
        ans += chr(a % 10 + 48);
        a /= 10;
    }
    for (ll i = ans.size() - 1; i >= 0; --i){
        ans1 += ans[i];
    }
    return ans1;
}

ll gcd(ll a, ll b){
    if (a == 0) return b;
    return gcd(b % a, a);
}

ll nok(ll a, ll b){
    return a * b / gcd(a, b);
}



/*
_________________________________________________________________________________________________________________________________________________
start programm
_________________________________________________________________________________________________________________________________________________
*/

#define len 128

struct new_struct{
    ll num, x, y, k;
    bool operator< ( const new_struct& a)const{
        return num > a.num;
    }
};

struct new_struct1{
    ll x, y, k;
};

ll a[400000], b[400000];
vector <new_struct1> stash;
vector <new_struct> arr[400000];
set <new_struct> mas;
ll n;

void remake(){
    for (ll i = 0; i < stash.size(); ++i){
        new_struct a;
        a.num = i;
        a.x = stash[i].x;
        a.y = stash[i].y;
        a.k = stash[i].k;
        arr[stash[i].y].pb(a);
    }
    for (ll i = 0; i < n; ++i){
        for (ll j = 0; j < arr[i].size(); ++j){
            mas.insert(arr[i][j]);
        }
        if (mas.size() == 0) continue;
        set <new_struct> :: iterator it = mas.begin();
        while ((mas.size() > 0) && (it->y + it->k <= i)){
            mas.erase(it);
            if (mas.size() == 0) break;
            it = mas.begin();
        }
        if (mas.size() == 0) continue;
        b[i] = a[i - it->y + it->x];
    }
    mas.clear();
    stash.clear();
}

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    srand(time(0));
    ll m;

    cin>>n>>m;
    for (ll i = 0; i < n; ++i){
        cin>>a[i];
    }
    for (ll i = 0; i < n; ++i){
        cin>>b[i];
    }

    for (ll i = 0; i < m; ++i){
        ll t;
        cin>>t;
        if (t == 1){
            ll x, y, k;
            cin>>x>>y>>k;
            --x;
            --y;
            new_struct1 a;
            a.x = x;
            a.y = y;
            a.k = k;
            stash.pb(a);
            if (stash.size() > len){
                remake();
            }
        }
        else{
            ll x;
            cin>>x;
            --x;
            if (stash.size() == 0){
                cout<<b[x]<<endl;
                continue;
            }
            ll j;
            for (j = stash.size() - 1; j >= 0; --j){
                if ((stash[j].y + stash[j].k > x) && (stash[j].y <= x)){
                    cout<<a[x - stash[j].y + stash[j].x]/*<<" &"*/<<endl;
                    break;
                }
            }
            if (j == -1) cout<<b[x]<<endl;
        }
    }
}