#include <algorithm>
#include <iostream>
#include <numeric>
#include <set>
#include <tuple>
#include <vector>

using namespace std;

struct Skill {
    int in_development;
    int in_managment;
};

struct DifferenceId {
    int difference; //skill in development - skill in managment
    int id;
};

bool operator<(const DifferenceId& lhs, const DifferenceId& rhs) {
    if (lhs.difference != rhs.difference) return lhs.difference > rhs.difference;
    return lhs.id < rhs.id;
}

vector<Skill> GetSkills() {
    int ppc; //project participants count
    cin >> ppc;
    vector<Skill> skills(ppc);
    for (Skill& skill : skills) {
        cin >> skill.in_development;
    }
    for (Skill& skill : skills) {
        cin >> skill.in_managment;
    }
    return skills;
}

void GetSkillImprovement(vector<Skill>& skills, int id) {
    int skill_type, skill_improvement;
    cin >> skill_type >> skill_improvement;

    //if (participant_number > skills.size()) throw logic_error("wrong participant number");
    Skill& participant_skill = skills[id - 1];

    if (skill_type == 1) participant_skill.in_development += skill_improvement;
    else if (skill_type == 2) participant_skill.in_managment += skill_improvement;
    //else throw logic_error("wrong skill type");
}

void GetSkillImprovement(vector<Skill>& skills) {
    int participant_number, skill_type, skill_improvement;
    cin >> participant_number >> skill_type >> skill_improvement;

    //if (participant_number > skills.size()) throw logic_error("wrong participant number");
    Skill& participant_skill = skills[participant_number - 1];

    if (skill_type == 1) participant_skill.in_development += skill_improvement;
    else if (skill_type == 2) participant_skill.in_managment += skill_improvement;
    //else throw logic_error("wrong skill type");
}

DifferenceId GetDifferenceId(vector<Skill>& skills, int id) {
    return { skills[id - 1].in_development - skills[id - 1].in_managment, id};
};

int GetCurrentTotalBenefitOfAllParticipants(const vector<Skill>& skills) {
    vector<Skill> skills_copy = skills;
    sort(skills_copy.begin(), skills_copy.end(), [](const Skill& lhs, const Skill& rhs) {
        return (lhs.in_development - lhs.in_managment) > (rhs.in_development - rhs.in_managment);
    });

    int benefit_of_developers = accumulate(skills_copy.begin(), skills_copy.begin() + skills_copy.size() / 2,
        0, [](int sum, const Skill& skill) {
        return sum + skill.in_development;
    });

    int benefit_of_managers = accumulate(skills_copy.begin() + skills_copy.size() / 2, skills_copy.end(),
        0, [](int sum, const Skill& skill) {
        return sum + skill.in_managment;
    });

    return benefit_of_developers + benefit_of_managers;
}

//O(m * n * log(n)), O(certificates_count * ppc * log(ppc))
int NaiveSolution(vector<Skill>& skills) {
    GetSkillImprovement(skills);
    return GetCurrentTotalBenefitOfAllParticipants(skills);
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);

    vector<Skill> skills = GetSkills();
    vector<Skill> skills_copy = skills;

    set<DifferenceId> developers;
    set<DifferenceId> managers;
    for (int i = 0; i < skills.size(); ++i) {
        DifferenceId difference_id = GetDifferenceId(skills, i + 1);
        developers.insert(difference_id);
        managers.insert(difference_id);
    }
    for (int i = 0; i < skills.size() / 2; ++i) {
        developers.erase(prev(developers.end()));
        managers.erase(managers.begin());
    }

    int developers_benefit = 0;
    for (const auto&[_, id] : developers) {
        developers_benefit += skills[id - 1].in_development;
    }

    int managers_benefit = 0;
    for (const auto& [_, id] : managers) {
        managers_benefit += skills[id - 1].in_managment;
    }

    int certificates_count;
    cin >> certificates_count;
    for (int i = 0; i < certificates_count; ++i) {
        int id; //id - participant id
        cin >> id;

        DifferenceId old_diference_id = GetDifferenceId(skills, id);
        GetSkillImprovement(skills, id);
        DifferenceId new_diference_id = GetDifferenceId(skills, id);

        if (developers.count(old_diference_id)) {
            developers.erase(old_diference_id);
            developers_benefit -= skills[old_diference_id.id - 1].in_development;
        } else {
            managers.erase(old_diference_id);
            managers_benefit -= skills[old_diference_id.id - 1].in_managment;
        }

        developers.insert(new_diference_id);
        developers_benefit += skills[new_diference_id.id - 1].in_development;

        managers.insert(new_diference_id);
        managers_benefit += skills[new_diference_id.id - 1].in_managment;

        if (developers.rbegin()->difference < managers.begin()->difference) {
            if (developers.size() < managers.size()) {
                developers_benefit -= skills[prev(developers.end())->id - 1].in_development;
                developers.erase(prev(developers.end()));

                developers.insert(*managers.begin());
                developers_benefit += skills[managers.begin()->id - 1].in_development;

                managers_benefit -= skills[managers.begin()->id - 1].in_managment;
                managers.erase(managers.begin());
            } else {
                managers_benefit -= skills[managers.begin()->id - 1].in_managment;
                managers.erase(managers.begin());

                managers.insert(*prev(developers.end()));
                managers_benefit += skills[prev(developers.end())->id - 1].in_managment;

                developers_benefit -= skills[prev(developers.end())->id - 1].in_development;
                developers.erase(prev(developers.end()));
            }
        } else {
            if (developers.size() > managers.size()) {
                developers_benefit -= skills[prev(developers.end())->id - 1].in_development;
                developers.erase(prev(developers.end()));
            } else {
                managers_benefit -= skills[managers.begin()->id - 1].in_managment;
                managers.erase(managers.begin());
            }
        }


        cout << developers_benefit + managers_benefit << '\n';
    }
}

/*
test1
4
7 15 3 4
10 10 0 6
3
1 1 4
4 1 6
2 2 10

34
35
43
*/






int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);

    vector<Skill> skills = GetSkills();
    int certificates_count;
    cin >> certificates_count;
    for (int i = 0; i < certificates_count; ++i) {
        cout << NaiveSolution(skills) << '\n';
    }
}