Problem: SmallR is a biologist. Her latest research finding is how to change the sex of dogs. In other words, she can change female dogs into male dogs and vice versa.

She is going to demonstrate this technique. Now SmallR has n dogs, the costs of each dog's change may be different. The dogs are numbered from 1 to n. The cost of change for dog i is vi RMB. By the way, this technique needs a kind of medicine which can be valid for only one day. So the experiment should be taken in one day and each dog can be changed at most once.

This experiment has aroused extensive attention from all sectors of society. There are m rich folks which are suspicious of this experiment. They all want to bet with SmallR forcibly. If SmallR succeeds, the i-th rich folk will pay SmallR wi RMB. But it's strange that they have a special method to determine whether SmallR succeeds. For i-th rich folk, in advance, he will appoint certain ki dogs and certain one gender. He will think SmallR succeeds if and only if on some day the ki appointed dogs are all of the appointed gender. Otherwise, he will think SmallR fails.

If SmallR can't satisfy some folk that isn't her friend, she need not pay him, but if someone she can't satisfy is her good friend, she must pay g RMB to him as apologies for her fail.

Then, SmallR hope to acquire money as much as possible by this experiment. Please figure out the maximum money SmallR can acquire. By the way, it is possible that she can't obtain any money, even will lose money. Then, please give out the minimum money she should lose.

Input

The first line contains three integers n, m, g (1 ≤ n ≤ 104, 0 ≤ m ≤ 2000, 0 ≤ g ≤ 104). The second line contains n integers, each is 0 or 1, the sex of each dog, 0 represent the female and 1 represent the male. The third line contains n integers v1, v2, ..., vn (0 ≤ vi ≤ 104).

Each of the next m lines describes a rich folk. On the i-th line the first number is the appointed sex of i-th folk (0 or 1), the next two integers are wi and ki (0 ≤ wi ≤ 104, 1 ≤ ki ≤ 10), next ki distinct integers are the indexes of appointed dogs (each index is between 1 and n). The last number of this line represents whether i-th folk is SmallR's good friend (0 — no or 1 — yes).

Output

Print a single integer, the maximum money SmallR can gain. Note that the integer is negative if SmallR will lose money. 

Examples

Input

5 5 9
0 1 1 1 0
1 8 6 2 3
0 7 3 3 2 1 1
1 8 1 5 1
1 0 3 2 1 4 1
0 8 3 4 2 1 0
1 7 2 4 1 1


Output

2


Input

5 5 8
1 0 1 1 1
6 5 4 2 8
0 6 3 2 3 4 0
0 8 3 3 2 4 0
0 0 3 3 4 1 1
0 10 3 4 3 1 1
0 4 3 3 4 1 1


Output

16

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(0.0) * 2.0;
const double eps = 1e-12;
const int step[8][2] = {{1, 0}, {-1, 0}, {0, 1},  {0, -1},
                        {1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
template <class T>
inline T abs1(T a) {
  return a < 0 ? -a : a;
}
template <class T>
inline T max1(T a, T b, T c = -1234567, T d = -1234567) {
  T ans = a > b ? a : b;
  if (c != -1234567) ans = max1(ans, c);
  if (d != -1234567) ans = max1(ans, d);
  return ans;
}
template <class T>
inline T min1(T a, T b, T c = -1234567, T d = -1234567) {
  T ans = a < b ? a : b;
  if (c != -1234567) ans = min(ans, c);
  if (d != -1234567) ans = min(ans, d);
  return ans;
}
template <class T>
inline T gcd1(T a, T b) {
  if (a < b) swap(a, b);
  if (a % b == 0) return b;
  return gcd1(b, a % b);
}
template <class T>
inline T lb(T num) {
  return num & (-num);
}
inline int jud(double a, double b) {
  if (abs1(a - b) < eps) return 0;
  if (a < b) return -1;
  return 1;
}
template <typename it, typename t1>
inline int find(t1 val, it a, int na, bool f_small = 1, bool f_lb = 1) {
  if (na == 1) return 0;
  int be = 0, en = na - 1;
  if (*a <= *(a + na - 1)) {
    if (f_lb == 0)
      while (be < en) {
        int mid = (be + en + 1) / 2;
        if (jud(*(a + mid), val) != 1)
          be = mid;
        else
          en = mid - 1;
      }
    else
      while (be < en) {
        int mid = (be + en) / 2;
        if (jud(*(a + mid), val) != -1)
          en = mid;
        else
          be = mid + 1;
      }
    if (f_small && jud(*(a + be), val) == 1 && be != 0) be--;
    if (!f_small && jud(*(a + be), val) == -1 && be != na - 1) be++;
  } else {
    if (f_lb)
      while (be < en) {
        int mid = (be + en + 1) / 2;
        if (jud(*(a + mid), val) != -1)
          be = mid;
        else
          en = mid - 1;
      }
    else
      while (be < en) {
        int mid = (be + en) / 2;
        if (jud(*(a + mid), val) != 1)
          en = mid;
        else
          be = mid + 1;
      }
    if (!f_small && jud(*(a + be), val) == -1 && be != 0) be--;
    if (f_small && jud(*(a + be), val) == 1 && be != na - 1) be++;
  }
  return be;
}
inline int bitnum(unsigned long long nValue) {
  nValue = ((0xaaaaaaaaaaaaaaaaull & nValue) >> 1) +
           (0x5555555555555555ull & nValue);
  nValue = ((0xccccccccccccccccull & nValue) >> 2) +
           (0x3333333333333333ull & nValue);
  nValue = ((0xf0f0f0f0f0f0f0f0ull & nValue) >> 4) +
           (0x0f0f0f0f0f0f0f0full & nValue);
  nValue = ((0xff00ff00ff00ff00ull & nValue) >> 8) +
           (0x00ff00ff00ff00ffull & nValue);
  nValue = ((0xffff0000ffff0000ull & nValue) >> 16) +
           (0x0000ffff0000ffffull & nValue);
  nValue = ((0xffffffff00000000ull & nValue) >> 32) +
           (0x00000000ffffffffull & nValue);
  return nValue;
}
long long pow(long long n, long long m, long long mod = 0) {
  long long ans = 1;
  long long k = n;
  while (m) {
    if (m & 1) {
      ans *= k;
      if (mod) ans %= mod;
    }
    k *= k;
    if (mod) k %= mod;
    m >>= 1;
  }
  return ans;
}
struct edge {
  int to, cap, next;
} e[121000 * 2];
int p = 2, head[20300], h[20300], vh[20300];
int n, m, s, t, maxFlow, ans;
inline int min(int a, int b) { return a < b ? a : b; }
inline void addEdge(int a, int b, int c) {
  e[p].to = b, e[p].cap = c, e[p].next = head[a], head[a] = p++;
  e[p].to = a, e[p].cap = 0, e[p].next = head[b], head[b] = p++;
}
int dfs(int u, int pre) {
  if (u == t) return pre;
  int now, aug, mh = n + 10, to, tmp = pre;
  for (now = head[u]; now; now = e[now].next) {
    to = e[now].to;
    if (e[now].cap) {
      if (pre && h[u] == h[to] + 1) {
        aug = dfs(to, min(pre, e[now].cap));
        pre -= aug;
        e[now].cap -= aug;
        e[now ^ 1].cap += aug;
        if (h[s] >= n) return tmp - pre;
      }
      mh = min(mh, h[to]);
    }
  }
  if (tmp - pre > 0) return tmp - pre;
  --vh[h[u]];
  if (!vh[h[u]]) {
    h[s] = n;
    return 0;
  }
  ++vh[h[u] = mh + 1];
  return 0;
}
void init(int ss, int tt) {
  maxFlow = 0;
  memset(h, 0, sizeof(h));
  memset(vh, 0, sizeof(vh));
  vh[0] = n;
  s = ss, t = tt;
}
void SAP(int ss, int tt) {
  init(ss, tt);
  while (h[s] < n) maxFlow += dfs(s, 0x5fffffff);
}
void input() {
  int ndog, npeople, pay;
  scanf("%d%d%d", &ndog, &npeople, &pay);
  p = 2;
  memset(head, 0, sizeof(head));
  bool isfe[20300] = {0};
  for (int i = 0; i < ndog; i++) {
    int a;
    scanf("%d", &a);
    if (a) isfe[i] = 1;
  }
  for (int i = 0; i < ndog; i++) {
    int a;
    scanf("%d", &a);
    if (isfe[i])
      addEdge(0, 0 + i + 1, a);
    else
      addEdge(0 + i + 1, ndog + npeople + 1, a);
  }
  for (int i = 0; i < npeople; i++) {
    int a, w, nd;
    scanf("%d%d%d", &a, &w, &nd);
    ans += w;
    for (int j = 0; j < nd; j++) {
      int num;
      scanf("%d", &num);
      if (a)
        addEdge(ndog + i + 1, num, 0x5fffffff);
      else
        addEdge(num, ndog + i + 1, 0x5fffffff);
    }
    scanf("%d", &nd);
    if (nd) w += pay;
    if (a)
      addEdge(0, ndog + i + 1, w);
    else
      addEdge(ndog + i + 1, ndog + npeople + 1, w);
  }
  n = ndog + npeople + 2;
  SAP(0, n - 1);
}
int main() {
  input();
  cout << ans - maxFlow << endl;
  return 0;
}