#include <iostream>
#include <fstream>
#include <vector>
#include <climits>
#include <queue>
#include <cstring>

using namespace std;

int V;

bool bfs(vector<vector<int>> rGraph, int s, int t, int parent[], int scale){
    bool visited[V];

    memset(visited, 0, sizeof(visited));

    queue<int> q;
    q.push(s);
    visited[s] = true;
    parent[s] = -1;
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int v = 0; v < V; v++){
            if (!visited[v] && rGraph[u][v] >= scale){
                if (v == t){
                    parent[v] = u;
                    return true;
                }
                q.push(v);
                parent[v] = u;
                visited[v] = true;
            }
        }
    }
    return false;
}

int karp(vector<vector<int>>& graph, int s, int t, int scale){
    int u, v;
    vector<vector<int>> rGraph(V, vector<int>(V));
    for (u = 0; u < V; u++)
        for (v = 0; v < V; v++)
            rGraph[u][v] = graph[u][v];

    int parent[V];
    int max_flow = 0;
    while(bfs(rGraph, s, t, parent, scale)){
        int path_flow = INT_MAX;
        for (v = t; v != s; v = parent[v]) {
            u = parent[v];
            path_flow = min(path_flow, rGraph[u][v]);
        }
        for (v = t; v != s; v = parent[v]) {
            u = parent[v];
            rGraph[u][v] -= path_flow;
            rGraph[v][u] += path_flow;
            graph[u][v] -= path_flow;
            graph[v][u] += path_flow;
        }
        max_flow += path_flow;
    }
    return max_flow;
}



signed main(){

    int max_scale = 0;
    int n, m, k, e;
    cin >> n >> m >> k >> e;
    int source = 0;
    int sink = n + m + 2*k + 1;
    V = sink + 1;
    vector<vector<int>> capacity(sink + 1, vector<int>(sink + 1, 0));
    vector<int> prod1(k), prod2(k);
    for (int i = 1; i <= n; ++i) {
        int a;
        cin >> a;
        capacity[source][i] = a;
        max_scale = max(max_scale, a);
    }
    for (int i = n + 1; i <= n + m; ++i) {
        int b;
        cin >> b;
        capacity[source][i] = b;
        max_scale = max(max_scale, b);
    }
    for (int i = 0; i < e; ++i) {
        int type, producer, factory, count;
        cin >> type >> producer >> factory >> count;
        max_scale = max(max_scale, count);
        if (type == 1) {
            capacity[producer][n + m + factory] = count;
            prod1[factory] += count;
        } else {
            capacity[n + producer][n + m + factory] = count;
            prod2[factory] += count;
        }
    }
    for(int i = 1; i <= k; ++i){
        capacity[n + m + i][n + m + k + i] = min(prod1[i], prod2[i]);
    }
    for (int i = 1; i <= k; ++i) {
        int c;
        cin >> c;
        capacity[n + m + k + i][sink] = c;
        max_scale = max(max_scale, c);
    }

    int scale = 1;
    while(2*scale <= max_scale) scale *= 2;
    int topflow = 0;
    while(scale >= 1){
        topflow += karp(capacity, 0, V - 1, scale);
        scale /= 2;
    }

    cout << topflow;
    return 0;
}