#include <bits/stdc++.h>

using namespace std;

#define INF 100000000
#define YJ 1145141919
#define INF_INT_MAX 2147483647
#define INF_LL 9223372036854775
#define INF_LL_MAX 9223372036854775807
#define EPS 1e-10
#define MOD 1000000007
#define Pi acos(-1)
#define LL long long
#define ULL unsigned long long
#define LD long double

#define int long long

#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(a)  begin((a)), end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())

const int MAX_N = 200005;
const int MAX_Q = 200005;

int N;
int Q;
int A[MAX_N];
int B[MAX_N];
int P[MAX_Q], X[MAX_Q], Y[MAX_Q];

//l:偶数個　r:奇数個
class Node {
public:
    Node(LL v = unitValue, LL v2 = unitValue) : l(v), r(v2) {

    }

    Node operator + (const Node& monoid) const {
        Node node;
        if(l != -INF_LL && monoid.l != -INF_LL) {
            node.l = max(node.l, l + monoid.l);
        }
        if(r != -INF_LL && monoid.r != -INF_LL) {
            node.l = max(node.l, r + monoid.r);
        }

        if(l != -INF_LL && monoid.r != -INF_LL) {
            node.r = max(node.r, l + monoid.r);
        }
        if(r != -INF_LL && monoid.l != -INF_LL) {
            node.r = max(node.r, r + monoid.l);
        }
        
        if(l == -INF_LL && r == -INF_LL) {
            node.l = max(node.l, monoid.l);
            node.r = max(node.r, monoid.r);
        }
        if(monoid.l == -INF_LL && monoid.r == -INF_LL) {
            node.l = max(node.l, l);
            node.r = max(node.r, r);
        }

        return node;
    }

    static Node unit() {
        return Node(unitValue);
    }

    LL getL() const {
        return this->l;
    }

    LL getR() const {
        return this->r;
    }

    void print() {
        cerr << l << "," << r << endl;
    }

private:
    LL l, r;
    static const LL unitValue = -INF_LL;
};

template <class T>
class SegmentTree {
public:
    SegmentTree(int size) {
        init(size);
    }

    void init(int size) {
        vec.clear();
        k = 1;
        while(k < size) {
            k *= 2;
        }
        for(int i = 0; i < 2*k; i++) {
            vec.push_back(T::unit());
        }
    }

    void update(int i, T x) { //iをxに変更する
        i += k-1;
        vec[i] = x;
        while(i > 0) {
            i = (i-1)/2;
            vec[i] = vec[i*2+1] + vec[i*2+2];
        }
    }

    T find(int l, int r) {
        return _find(l, r, 0, 0, k);
    }

    void print() {
        REP(i,vec.size()) {
            T t = vec[i];
            cerr << i << ": "; t.print();
        }
    }

private:
    vector<T> vec;
    int k;

    T _find(int l, int r, int k, int x, int y) {
        if (r <= x || y <= l) { //重なってない場合
            return T::unit();
        } else if (l <= x && y <= r) { //完全にかぶってる場合
            return vec[k];
        } else { //中途半端にかぶってる場合
            int mid = (x+y)/2;
            T lNode = _find(l, r, 2*k+1, x, mid);
            T rNode = _find(l, r, 2*k+2, mid, y);
            return lNode + rNode;
        }
    }
};

signed main()
{
    cin >> N >> Q;
    REP(i,2*N) {
        cin >> A[i];
    }
    REP(i,2*N) {
        cin >> B[i];
    }
    REP(q,Q) {
        cin >> P[q] >> X[q] >> Y[q];
        P[q]--;
    }

    SegmentTree<Node> seg(2*N);

    int ans = A[0] + A[2*N-1];
    seg.update(0,Node(-INF_LL, A[0]));
    seg.update(2*N-1,Node(-INF_LL, A[2*N-1]));
    FOR(i,1,2*N-1) {
        // cerr << i << endl;
        seg.update(i,Node(B[i], A[i]));
    }


    // Node n1 = seg.find(0,2*N);
    // cerr << "Debug: " << n1.getL() << " " << n1.getR() << endl;
    // seg.print();

    REP(q,Q) {
        if(P[q] == 0 || P[q] == 2*N-1) {
            seg.update(P[q], Node(-INF_LL, X[q]));
        } else {
            seg.update(P[q], Node(Y[q], X[q]));
        }
        // cerr << "*** " << endl;
        // seg.print();
        cout << seg.find(0,2*N).getL() << endl;
    }

    return 0;
}

Measured memory_bytes: 17388