# https://www.acmicpc.net/problem/10605
# Greedy - kill dragon at start(xi>Si) or by crowd(sum(xi) > max(Ni))

from bisect import *
from collections import deque
from sys import stdin


def solve(n, m, k):
    graph = [[] for _ in range(n)]
    for _ in range(m):
        a, b = map(int, stdin.readline().split())
        graph[a - 1].append(b - 1)
        graph[b - 1].append(a - 1)

    dragons = [[] for _ in range(n)]
    for _ in range(k):
        ci, si, ni = map(int, stdin.readline().split())
        dragons[ci - 1].append([ni, si])  # change order for simpler implementation

    ans = 0
    visited = [False for _ in range(n)]
    for node in range(n):
        if not visited[node]:
            # Make partial solution for connected component
            target = dragons[node]
            Q = deque([node])
            visited[node] = True
            while Q:
                curr = Q.popleft()
                for child in graph[curr]:
                    if not visited[child]:
                        visited[child] = True
                        target.extend(dragons[child])
                        Q.append(child)
            if len(target) == 0:  # no dragon in this connected component.
                continue

            target.sort()  # Ni, Si
            si_partial = [0 for _ in range(len(target) + 1)]
            acc = 0
            for i in range(len(target)):
                acc += target[i][1]
                si_partial[i + 1] = acc
            curr_ans = 0

            for hero in range(1, 10 ** 5 + 1):
                start_idx = bisect_left(target, [hero, -1])
                if start_idx == len(target):  # num of hero exceeds sum of ni
                    curr_ans = hero
                    break
                if si_partial[-1] - si_partial[start_idx] <= hero:
                    curr_ans = hero
                    break
            ans += curr_ans
    print(ans)


while True:
    n, m, k = map(int, stdin.readline().split())
    if n == m == k == 0:
        break
    else:
        solve(n, m, k)

from sys import stdin

c, n = map(int, stdin.readline().split())
colors = {stdin.readline().strip() for _ in range(c)}
names = {stdin.readline().strip() for _ in range(n)}
queries = [stdin.readline().strip() for _ in range(int(stdin.readline().strip()))]
for query in queries:
    flag = False
    for i in range(1, len(query) - 1):
        if query[:i] in colors and query[i:] in names:
            flag = True
            break

    print('Yes' if flag else 'No')

# https://www.acmicpc.net/problem/19585
# Trie
from sys import stdin

c, n = map(int, stdin.readline().split())
container = ['']
nxt = [[]]
end = [False]


def add(word):
    pos = i = 0
    while i < len(word):
        for next_pos in nxt[pos]:
            # if next letter matches: move to that node
            if container[next_pos] == word[i]:
                pos = next_pos
                i += 1
                break
        # if nothing matches: insert new node
        else:
            nxt[pos].append(len(container))
            nxt.append([])
            end.append(False)
            pos = len(container)
            container.append(word[i])
            i += 1
    end[pos] = True


# search in trie and yield index whenever available
def find(word):
    pos = i = 0
    while i < len(word) - 1:
        for next_pos in nxt[pos]:
            # if next letter matches: move to that node
            if container[next_pos] == word[i]:
                pos = next_pos
                i += 1
                if end[pos]:
                    yield i
                break
        # if nothing matches: end of iteration
        else:
            return


for _ in range(c):
    color = stdin.readline().strip()
    add(color)

names = {stdin.readline().strip() for _ in range(n)}
for _ in range(int(stdin.readline().strip())):
    query = stdin.readline().strip()
    for i in find(query):
        # print(query[i:])
        if query[i:] in names:
            print('Yes')
            break
    else:
        print('No')

# https://www.acmicpc.net/problem/23291

from sys import stdin

n, k = map(int, stdin.readline().split())
fishbowl = [list(map(int, stdin.readline().split()))]  # save at zeroth floor


# move fish and linearize to zeroth floor
def move_and_linearize(fishbowl):
    delta = []
    # horizontal
    for floor in range(len(fishbowl)):
        temp = [0 for _ in range(len(fishbowl[floor]))]
        for i in range(len(fishbowl[floor]) - 1):
            diff = int((fishbowl[floor][i + 1] - fishbowl[floor][i]) / 5)
            temp[i] += diff
            temp[i + 1] -= diff
        delta.append(temp)
    # vertical
    for pos in range(len(fishbowl[1])):
        for floor in range(len(fishbowl) - 1):
            diff = int((fishbowl[floor + 1][pos] - fishbowl[floor][pos]) / 5)
            delta[floor][pos] += diff
            delta[floor + 1][pos] -= diff
    # apply
    for floor in range(len(fishbowl)):
        for i in range(len(fishbowl[floor])):
            fishbowl[floor][i] += delta[floor][i]

    new_bowl = []
    for wow in zip(*fishbowl):
        new_bowl.extend(wow)
    new_bowl.extend(fishbowl[0][len(fishbowl[1]):])
    return [new_bowl]


for t in range(100000):
    # end condition
    minimum = min(fishbowl[0])
    maximum = max(fishbowl[0])
    if maximum - minimum <= k:
        print(t)
        break

    # add fish
    for i in range(n):
        if fishbowl[0][i] == minimum:
            fishbowl[0][i] += 1

    # stacking
    first = fishbowl[0].pop(0)
    fishbowl.append([first])
    while True:
        if len(fishbowl) <= len(fishbowl[0]) - len(fishbowl[1]):
            new_bowl = [list(wow) for wow in zip(*fishbowl)]
            new_bowl.reverse()
            fishbowl = [fishbowl[0][len(fishbowl[1]):], *new_bowl]
        else:
            break

    fishbowl = move_and_linearize(fishbowl)

    # flip half and add to second floor.
    first = fishbowl[0][n // 2:]
    second = fishbowl[0][:n // 2][::-1]
    fishbowl = [first[n // 4:], second[n // 4:], second[:n // 4][::-1], first[:n // 4][::-1]]

    fishbowl = move_and_linearize(fishbowl)

#include <algorithm>
#include <iostream>

using namespace std;

int N, Q, board_size;
int board[64][64];
int temp[64][64];
bool visited[64][64] = {false};
int dx[4] = {0, 1, 0, -1};
int dy[4] = {-1, 0, 1, 0};
int sum = 0;

// rotate and check ice-melting condition.
void firestrom(int len) {
    for (int row = 0; row < board_size; row += len) {
        for (int col = 0; col < board_size; col += len) {
            // rotate for each subgrid, given its top-left point (row,col)
            for (int i = 0; i < len; i++) {
                for (int j = 0; j < len; j++) {
                    temp[row + j][col + len - 1 - i] = board[row + i][col + j];
                }
            }
        }
    }
    // check for ice-melting condition
    for (int i = 0; i < board_size; i++) {
        for (int j = 0; j < board_size; j++) {
            int ice_count = 0;
            for (int d = 0; d < 4; d++) {
                int ni = i + dx[d];
                int nj = j + dy[d];
                if (0 <= ni && ni < board_size && 0 <= nj && nj < board_size && temp[ni][nj] > 0) {
                    ice_count++;
                }
            }
            if (ice_count >= 3) {
                board[i][j] = temp[i][j];
            } else {
                board[i][j] = max(0, temp[i][j] - 1);
            }
        }
    }
}

// return the number of connected ices adjacent to (row, col)
int dfs(int row, int col) {
    int ret = 0;
    for (int d = 0; d < 4; d++) {
        int nrow = row + dx[d];
        int ncol = col + dy[d];
        if (0 <= nrow && nrow < board_size && 0 <= ncol && ncol < board_size && !visited[nrow][ncol] && board[nrow][ncol] > 0) {
            visited[nrow][ncol] = true;
            ret += 1 + dfs(nrow, ncol);
        }
    }
    return ret;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    // get input
    cin >> N >> Q;
    board_size = 1 << N;
    for (int i = 0; i < board_size; i++) {
        for (int j = 0; j < board_size; j++) {
            cin >> board[i][j];
        }
    }
    // do firestorm
    int L;
    for (int i = 0; i < Q; i++) {
        cin >> L;
        firestrom(1 << L);
    }
    for (int i = 0; i < board_size; i++) {
        for (int j = 0; j < board_size; j++) {
            sum += board[i][j];
        }
    }
    // find maximum mTE
    int maximum = 0;
    for (int i = 0; i < board_size; i++) {
        for (int j = 0; j < board_size; j++) {
            if (!visited[i][j] && board[i][j] > 0) {
                visited[i][j] = true;
                maximum = max(maximum, 1 + dfs(i, j));
            }
        }
    }
    cout << sum << '\n'
         << maximum;
    return 0;
}

#include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <vector>

using namespace std;

int N, M, F;
int x, y;
int board[20][20] = {0};
int distance_board[20][20];
int MAX_DIST = 1000;
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};
map<pair<int, int>, pair<int, int>> customer;

void get_all_distance() {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            distance_board[i][j] = MAX_DIST;
        }
    }
    deque<pair<int, int>> Q;
    Q.push_back(make_pair(x, y));
    distance_board[x][y] = 0;
    while (Q.size() != 0) {
        int row, col;
        tie(row, col) = Q.front();
        Q.pop_front();
        for (int d = 0; d < 4; d++) {
            int nrow = row + dx[d];
            int ncol = col + dy[d];
            int ndist = distance_board[row][col] + 1;
            if (0 <= nrow && nrow < N && 0 <= ncol && ncol < N && board[nrow][ncol] != 1 && ndist < distance_board[nrow][ncol]) {
                distance_board[nrow][ncol] = ndist;
                Q.push_back(make_pair(nrow, ncol));
            }
        }
    }
}

bool taxi() {
    // first, do bfs to find next target customer.
    get_all_distance();
    pair<int, int> nearest_customer;
    int nearest_distance = MAX_DIST;
    for (auto iter : customer) {
        pair<int, int> key = iter.first;
        if (distance_board[key.first][key.second] < nearest_distance) {
            nearest_distance = distance_board[key.first][key.second];
            nearest_customer = key;
        }
    }
    // stop iteration if customer was not found
    if (nearest_distance == MAX_DIST) {
        if (customer.size() != 0) {
            F = -1;
        }
        return false;
    }
    // stop iteration if fuel is low
    if (F < nearest_distance) {
        F = -1;
        return false;
    }
    // move taxi to customer position
    F -= nearest_distance;
    x = nearest_customer.first;
    y = nearest_customer.second;

    // move taxi to goal.
    get_all_distance();
    pair<int, int> goal = customer[nearest_customer];
    x = goal.first;
    y = goal.second;
    int used = distance_board[x][y];
    customer.erase(nearest_customer);
    if (used == MAX_DIST || F < used) {
        F = -1;
        return false;
    }
    // refill fuel twice.
    F += used;
    return true;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    // get input
    cin >> N >> M >> F;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            cin >> board[i][j];
        }
    }
    cin >> x >> y;
    x--, y--;  // zero-based index
    for (int i = 0; i < M; i++) {
        int a, b, c, d;
        cin >> a >> b >> c >> d;
        customer[make_pair(a - 1, b - 1)] = make_pair(c - 1, d - 1);
    }
    while (taxi()) {
    }
    cout << F;
    return 0;
}

# https://www.acmicpc.net/problem/19237
# Implementation

from sys import stdin

dx = [-1, 1, 0, 0]  # up, down, left, right
dy = [0, 0, -1, 1]

n, m, k = map(int, stdin.readline().split())
shark = [[] for _ in range(m)]
for i in range(n):
    line = list(map(int, stdin.readline().split()))
    for j in range(n):
        if line[j] != 0:
            shark[line[j] - 1] = [i, j]

board = [[[-1, -1] for _ in range(n)] for _ in range(n)]  # initially there's no fragrance.
direction = list(map(lambda x: int(x) - 1, stdin.readline().split()))
prefer = [[list(map(lambda x: int(x) - 1, stdin.readline().split())) for _ in range(4)] for _ in range(m)]
count = m

for t in range(1, 1001):
    # first, make smell
    for i in range(m):
        row, col = shark[i]
        if row == -1:
            continue
        board[row][col] = [i, k]  # shark number, duration

    # then, move
    new_board = [[[-1, -1] for _ in range(n)] for _ in range(n)]
    for i in range(m):
        row, col = shark[i]
        if row == -1:
            continue
        d = direction[i]
        target_direction = None
        my_fragrance = None
        # first, find for no-fragrance cell
        for target in prefer[i][d]:
            nrow = row + dx[target]
            ncol = col + dy[target]
            if 0 <= nrow < n and 0 <= ncol < n:
                if board[nrow][ncol][0] == -1:  # no-fragrance
                    target_direction = target
                    break
                if board[nrow][ncol][0] == i and my_fragrance is None:  # my-fragrance
                    my_fragrance = target
        # if there was no empty cell, go to my-fragrance
        if target_direction is None:
            target_direction = my_fragrance
        # actually moving
        nrow = row + dx[target_direction]
        ncol = col + dy[target_direction]
        direction[i] = target_direction
        shark[i] = [nrow, ncol]
        # when two sharks collide
        if new_board[nrow][ncol][0] != -1:
            other = new_board[nrow][ncol][0]
            count -= 1
            # lose
            if other < i:
                shark[i] = [-1, -1]
            else:
                shark[other] = [-1, -1]
                new_board[nrow][ncol] = [i, -1]
        else:
            new_board[nrow][ncol] = [i, -1]

    # finally, decrease smell.
    for i in range(n):
        for j in range(n):
            num, dur = board[i][j]
            if num != -1 and dur > 1:
                new_board[i][j] = [num, dur - 1]

    board = new_board
    if count == 1:
        print(t)
        break

else:
    print(-1)

# https://www.acmicpc.net/problem/19236
# Implementation

from sys import stdin
from copy import deepcopy

direction = [[-1, 0], [-1, -1], [0, -1], [1, -1], [1, 0], [1, 1], [0, 1], [-1, 1]]
board = []
for i in range(4):
    line = list(map(lambda x: int(x) - 1, stdin.readline().split()))
    board.append([[line[0], line[1]], [line[2], line[3]], [line[4], line[5]], [line[6], line[7]]])

fish = [[] for _ in range(16)]
for row in range(4):
    for col in range(4):
        pos, d = board[row][col]
        fish[pos] = [row, col, d]


def dfs(shark_x, shark_y, shark_d, acc):
    # first move fish
    global fish, board
    save_fish = deepcopy(fish)
    save_board = deepcopy(board)
    for i in range(16):
        r, c, d = fish[i]
        if r == -1:  # already eaten.
            continue
        nr = r + direction[d][0]
        nc = c + direction[d][1]
        nd = d
        # maybe fish can always move??
        while not (0 <= nr < 4 and 0 <= nc < 4 and (nr, nc) != (shark_x, shark_y)):
            nd = (nd + 1) % 8
            nr = r + direction[nd][0]
            nc = c + direction[nd][1]
        # swap position
        target_num, target_d = board[nr][nc]

        fish[i] = [nr, nc, nd]
        if target_num != -1:
            fish[target_num] = r, c, target_d
        board[nr][nc] = [i, nd]
        board[r][c] = [target_num, target_d]

    # then, move shark.
    ret = acc
    for mult in range(1, 4):
        nx = shark_x + mult * direction[shark_d][0]
        ny = shark_y + mult * direction[shark_d][1]
        if not (0 <= nx < 4 and 0 <= ny < 4):
            break
        target_num, target_d = board[nx][ny]
        if target_num == -1:
            continue
        fish[target_num] = [-1, -1, -1]
        board[nx][ny] = [-1, -1]
        ret = max(ret, dfs(nx, ny, target_d, acc + target_num + 1))
        board[nx][ny] = [target_num, target_d]
        fish[target_num] = [nx, ny, target_d]
    fish = save_fish
    board = save_board
    return ret


num, d = board[0][0]
fish[num] = [-1, -1, -1]
board[0][0] = [-1, -1]

print(dfs(0, 0, d, num + 1))

#include <algorithm>
#include <deque>
#include <iostream>
#include <vector>

using namespace std;

int N;
int green[6][4] = {0};
int blue[6][4] = {0};

// delete a row and move all upper rows downward.
void burst_row(int arr[][4], int row) {
    for (int i = 0; row - i - 1 >= 0; i++) {
        for (int j = 0; j < 4; j++) {
            arr[row - i][j] = arr[row - i - 1][j];
        }
    }
    for (int j = 0; j < 4; j++) {
        arr[0][j] = 0;
    }
}

// check if a row is full and delete it.
int check_and_burst(int arr[][4], int row) {
    int ret = 0;
    bool check_burst = true;
    for (int i = 0; i < 4; i++) {
        if (arr[row][i] == 0) {
            check_burst = false;
            break;
        }
    }
    if (check_burst) {
        // add point
        ret++;
        burst_row(arr, row);
    }
    return ret;
}

// debug function
void print_minos() {
    cout << "green" << '\n';
    for (int i = 0; i < 6; i++) {
        for (int j = 0; j < 4; j++) {
            cout << green[i][j] << ' ';
        }
        cout << '\n';
    }
    cout << "blue" << '\n';
    for (int i = 0; i < 6; i++) {
        for (int j = 0; j < 4; j++) {
            cout << blue[i][j] << ' ';
        }
        cout << '\n';
    }
}

int put_mino(int arr[][4], int t, int x, int y) {
    int row = 0;
    int ret = 0;
    if (t == 1) {
        while (arr[row][y] == 0 && row < 6) {
            row++;
        }
        arr[--row][y] = 1;
        ret += check_and_burst(arr, row);
        // check special cells
        for (int j = 0; j < 4; j++) {
            if (arr[1][j] == 1) {
                burst_row(arr, 5);
                break;
            }
        }
    } else if (t == 2) {
        // find available position
        while (arr[row][y] == 0 && arr[row][y + 1] == 0 && row < 6) {
            row++;
        }
        row--;
        arr[row][y] = 1;
        arr[row][y + 1] = 1;
        ret += check_and_burst(arr, row);
        // special cells
        for (int j = 0; j < 4; j++) {
            if (arr[1][j] == 1) {
                burst_row(arr, 5);
                break;
            }
        }
    } else {  // t== 3
        // find available position
        while (arr[row + 1][y] == 0 && row + 1 < 6) {
            row++;
        }
        row--;
        arr[row][y] = 1;
        arr[row + 1][y] = 1;
        // check line burst
        ret += check_and_burst(arr, row);      // upper
        ret += check_and_burst(arr, row + 1);  // lower
        // special cells
        // do it twice.
        for (int foo = 0; foo < 2; foo++) {
            for (int j = 0; j < 4; j++) {
                if (arr[1][j] == 1) {
                    burst_row(arr, 5);
                    break;
                }
            }
        }
    }
    return ret;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    // get input
    cin >> N;
    int ans = 0;
    while (N--) {
        int t, x, y;
        cin >> t >> x >> y;
        ans += put_mino(green, t, x, y);
        if (t == 1) {
            ans += put_mino(blue, 1, y, 3 - x);
        } else if (t == 2) {
            ans += put_mino(blue, 3, y, 3 - x);
        } else {
            ans += put_mino(blue, 2, y, 2 - x);
        }
        // print_minos();
    }

    int num = 0;
    for (int i = 2; i < 6; i++) {
        for (int j = 0; j < 4; j++) {
            num += green[i][j];
            num += blue[i][j];
        }
    }

    cout << ans << '\n'
         << num;
    return 0;
}