Problem: Tanya is now five so all her friends gathered together to celebrate her birthday. There are n children on the celebration, including Tanya.

The celebration is close to its end, and the last planned attraction is gaming machines. There are m machines in the hall, they are numbered 1 through m. Each of the children has a list of machines he wants to play on. Moreover, for each of the machines he knows the exact time he wants to play on it. For every machine, no more than one child can play on this machine at the same time.

It is evening already, so every adult wants to go home. To speed up the process, you can additionally rent second copies of each of the machines. To rent the second copy of the j-th machine, you have to pay pj burles. After you rent a machine, you can use it for as long as you want.

How long it will take to make every child play according to his plan, if you have a budget of b burles for renting additional machines? There is only one copy of each machine, so it's impossible to rent a third machine of the same type.

The children can interrupt the game in any moment and continue it later. If the i-th child wants to play on the j-th machine, it is allowed after you rent the copy of the j-th machine that this child would play some part of the time on the j-th machine and some part of the time on its copy (each of these parts could be empty). The interruptions and changes take no time and can be performed in any integer moment of time. Of course, a child can't play on more than one machine at the same time.

Remember, that it is not needed to save money (no one saves money at the expense of children happiness!), it is needed to minimize the latest moment of time some child ends his game.

Input

The first line contains three integers n, m and b (1 ≤ n ≤ 40, 1 ≤ m ≤ 10, 0 ≤ b ≤ 106) — the number of children, the number of gaming machines and the budget for renting additional machines.

The second line contains m integers p1, p2, ..., pm (1 ≤ pj ≤ 106), where pj is the rent price for the second copy of the j-th machine.

n lines follow, i-th of them describes the wishes of the i-th child. The line starts with an integer ki (0 ≤ ki ≤ m) — the number of machines, the i-th child wants to play on. Then there are ki pairs in the line, the y-th of them is xiy, tiy. It means that, the i-th child wants to play tiy (1 ≤ tiy ≤ 2500) minutes on the xiy-th (1 ≤ xiy ≤ m) machine. In each of these n lines the values xiy are distinct.

Output

In the first line print the minimum time in which all the children can finish their games.

In the second line print a string of length m consisting of zeros and ones. The j-th character is '1', if the copy of j-th machine should be rated, and '0' otherwise.

In the third line print integer g (0 ≤ g ≤ 106) — the total number of time segments of continuous playing for all of the children. Then in g lines print the segments as four integers i, j, s, d, meaning that the i-th child was playing on the j-th machine or its copy from the time moment s (s ≥ 0) for d minutes (d ≥ 1). You can print these lines in arbitrary order.

If there are multiple answers, print any of them.

Examples

Input

2 2 100
3 7
2 1 3 2 1
2 1 3 2 1


Output

4
10
8
1 1 0 1
2 2 0 1
1 1 1 1
2 1 1 1
2 1 2 1
1 1 2 1
1 2 3 1
2 1 3 1


Input

3 2 15
11 7
2 2 10 1 5
1 2 20
2 1 4 2 3


Output

20
01
17
2 2 0 4
2 2 4 1
1 1 5 2
2 2 5 2
1 2 7 5
2 2 7 5
2 2 12 1
1 2 12 1
3 1 13 4
2 2 13 4
1 2 13 4
1 1 17 2
3 2 17 2
2 2 17 2
1 1 19 1
2 2 19 1
3 2 19 1

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
const int INF = 1e9 + 7;
int ps[10];
int desire[40][10];
int child_deg[40];
int machine_deg[10];
int N, M;
int graph[60][60];
int deg[60];
int match[60];
bool vis[60];
bool need[60];
std::vector<std::array<int, 4> > segments;
void add_edge(int child, int machine, int weight) {
  int u = child;
  int v = machine + N;
  graph[u][v] = graph[v][u] = weight;
  deg[u] += weight;
  deg[v] += weight;
}
bool dfs_match(int u) {
  if (vis[u]) return false;
  vis[u] = true;
  if (!need[u] && match[u] != -1) {
    match[match[u]] = -1;
    match[u] = -1;
    return true;
  }
  for (int v = 0; v < 60; v++) {
    if (!graph[u][v]) continue;
    if (v == match[u]) continue;
    if (match[v] == -1 || dfs_match(match[v])) {
      match[u] = v, match[v] = u;
      return true;
    }
  }
  return false;
}
int find_matching() {
  std::fill(need, need + 60, true);
  std::fill(match, match + 60, -1);
  for (int i = 0; i < 60; i++) {
    if (match[i] == -1) {
      std::fill(vis, vis + 60, false);
      dfs_match(i);
    }
  }
  std::fill(deg, deg + 60, 0);
  for (int i = 0; i < 60; i++) {
    for (int j = 0; j < 60; j++) {
      deg[i] += graph[i][j];
    }
  }
  int D = *std::max_element(deg, deg + 60);
  for (int i = 0; i < 60; i++) {
    need[i] = (deg[i] == D);
  }
  for (int i = 0; i < 60; i++) {
    if (need[i] && match[i] == -1) {
      std::fill(vis, vis + 60, false);
      dfs_match(i);
    }
  }
  return D;
}
int main() {
  int B;
  scanf("%d %d %d", &N, &M, &B);
  for (int i = 0; i < M; i++) {
    scanf("%d", &ps[i]);
  }
  for (int i = 0; i < N; i++) {
    int K;
    scanf("%d", &K);
    while (K-- > 0) {
      int X, T;
      scanf("%d %d", &X, &T);
      X--;
      desire[i][X] = T;
      child_deg[i] += T;
      machine_deg[X] += T;
    }
  }
  int best_mask = 0;
  int best_wait = INF;
  for (int mask = 0; mask < (1 << M); mask++) {
    int cost = 0;
    for (int i = 0; i < M; i++) {
      if (mask & (1 << i)) {
        cost += ps[i];
      }
    }
    if (cost > B) continue;
    int wait = 0;
    for (int i = 0; i < N; i++) {
      wait = std::max(wait, child_deg[i]);
    }
    for (int i = 0; i < M; i++) {
      if (mask & (1 << i)) {
        wait = std::max(wait, (machine_deg[i] + 1) / 2);
      } else {
        wait = std::max(wait, machine_deg[i]);
      }
    }
    if (wait < best_wait) {
      best_wait = wait;
      best_mask = mask;
    }
  }
  printf("%d\n", best_wait);
  for (int i = 0; i < M; i++) {
    printf("%d", (best_mask >> i) & 1);
  }
  printf("\n");
  for (int j = 0; j < M; j++) {
    if (best_mask & (1 << j)) {
      machine_deg[j] = (machine_deg[j] + 1) / 2;
    }
    int flag = 0;
    for (int i = 0; i < N; i++) {
      int use = std::min(machine_deg[j], desire[i][j]);
      add_edge(i, (j << 1) | flag, use);
      machine_deg[j] -= use;
      desire[i][j] -= use;
      if (desire[i][j] > 0) {
        flag = 1;
        machine_deg[j] = INF;
        i--;
      }
    }
  }
  int T = 0;
  while (true) {
    int D = find_matching();
    if (D == 0) break;
    int stay = INF;
    for (int i = 0; i < 60; i++) {
      if (match[i] != -1) {
        stay = std::min(stay, graph[i][match[i]]);
      } else {
        stay = std::min(stay, D - deg[i]);
      }
    }
    for (int i = 0; i < N; i++) {
      if (match[i] != -1) {
        segments.push_back({i + 1, (match[i] - N) / 2 + 1, T, stay});
        graph[i][match[i]] -= stay;
        graph[match[i]][i] -= stay;
      }
    }
    T += stay;
  }
  printf("%d\n", (int)segments.size());
  for (std::array<int, 4> seg : segments) {
    printf("%d %d %d %d\n", seg[0], seg[1], seg[2], seg[3]);
  }
  return 0;
}