import java.awt.Point;
import java.util.Scanner;

/**
 * Copyright © 2010 McKesson Corporation and/or one of its subsidiaries.
 * All rights reserved.
 */

/**
 * @author BoHao Li
 */
public class G
{
    public static String[] DIRECTIONS = { "east", "north", "south", "west" };

    public void process(Point[] vamps, Point[] mortals, String[] mirrorDir, Point[] mirrorStart, Point[] mirrorEnd, int biggestX, int biggestY)
    {
        System.err.println("biggestX/Y: " + biggestX + " " + biggestY);

        char[][] grid = new char[biggestX + 1][biggestY + 1];
        boolean[][] exposed = new boolean[vamps.length][4]; // E N S W

        for (Point v : vamps)
        {
            grid[v.x][v.y] = 'V';
        }

        for (Point m : mortals)
        {
            grid[m.x][m.y] = 'M';
        }

        for (int i = 0; i < mirrorDir.length; i++)
        {
            // System.err.println("mirror: " + i);

            // vertical mirror
            if (mirrorStart[i].x == mirrorEnd[i].x)
            {
                int dir = mirrorStart[i].y < mirrorEnd[i].y ? 1 : -1;
                for (int j = mirrorStart[i].y; j != mirrorEnd[i].y + dir; j += dir)
                {
                    grid[mirrorStart[i].x][j] = mirrorDir[i].charAt(0);
                }
            }
            // horiz mirror
            else if (mirrorStart[i].y == mirrorEnd[i].y)
            {
                int dir = mirrorStart[i].x < mirrorEnd[i].x ? 1 : -1;

                for (int j = mirrorStart[i].x; j != mirrorEnd[i].x + dir; j += dir)
                {
                    System.err.println("j: " + j);
                    grid[j][mirrorStart[i].y] = mirrorDir[i].charAt(0);
                }
            }
            else
            {
                System.err.println("mirror neither horizontal nor vertical?");
            }
        }

        // debug print grid
        // for (char[] row : grid)
        // {
        // System.err.println(Arrays.toString(row));
        // }

        // expand from V to find interesting grid squares
        for (int i = 0; i < vamps.length; i++)
        {

            // up
            for (int y = vamps[i].y; y >= 0; y--)
            {
                char v = grid[vamps[i].x][y];
                if (v == 'M' || v == 'N' || v == 'E' || v == 'W')
                {
                    break;
                }
                if (v == 'W')
                {
                    exposed[i][2] = true;
                    break;
                }
            }

            // down
            for (int y = vamps[i].y; y <= biggestY; y++)
            {
                char v = grid[vamps[i].x][y];
                if (v == 'M' || v == 'S' || v == 'E' || v == 'W')
                {
                    break;
                }
                if (v == 'N')
                {
                    exposed[i][1] = true;
                    break;
                }
            }

            // left
            for (int x = vamps[i].x; x >= 0; x--)
            {
                char v = grid[x][vamps[i].y];
                if (v == 'M' || v == 'N' || v == 'S' || v == 'W')
                {
                    break;
                }
                if (v == 'E')
                {
                    exposed[i][0] = true;
                    break;
                }
            }

            // right
            for (int x = vamps[i].x; x <= biggestX; x++)
            {
                char v = grid[x][vamps[i].y];
                if (v == 'M' || v == 'N' || v == 'S' || v == 'E')
                {
                    break;
                }
                if (v == 'W')
                {
                    System.out.println("x: " + x + " v: " + v);
                    exposed[i][3] = true;
                    break;
                }
            }
        }

        // see if printing necessary
        boolean oneHit = false;
        boolean[] vampHit = new boolean[vamps.length];
        for (int i = 0; i < vamps.length; i++)
        {
            vampHit[i] = (exposed[i][0] || exposed[i][1] || exposed[i][2] || exposed[i][3]);
            oneHit |= vampHit[i];
        }

        // if not print none
        if (!oneHit)
        {
            System.out.println("none");
            return;
        }

        // otherwise go through and tell about each vampire
        for (int i = 0; i < vamps.length; i++)
        {
            if (vampHit[i])
            {
                System.out.print("vampire " + i);
                for (int j = 0; j < 4; j++)
                {
                    if (exposed[i][j])
                    {
                        System.out.print(DIRECTIONS[j]);
                    }
                }
                System.out.println();
            }
        }

    }

    public void doIt()
    {
        Scanner scan = new Scanner(System.in);

        int v, o, m;
        v = scan.nextInt();
        o = scan.nextInt();
        m = scan.nextInt();
        int c = 0;
        while (v != 0 && o != 0 && m != 0)
        {
            c++;
            int biggestX = -1;
            int biggestY = -1;

            Point[] vamps = new Point[v];
            for (int i = 0; i < v; i++)
            {
                vamps[i] = new Point(scan.nextInt(), scan.nextInt());
                biggestX = Math.max(biggestX, vamps[i].x);
                biggestY = Math.max(biggestY, vamps[i].y);
            }

            Point[] mortals = new Point[o];
            for (int i = 0; i < o; i++)
            {
                mortals[i] = new Point(scan.nextInt(), scan.nextInt());
                biggestX = Math.max(biggestX, mortals[i].x);
                biggestY = Math.max(biggestY, mortals[i].y);
            }

            String[] mirrorDir = new String[m];
            Point[] mirrorStart = new Point[m];
            Point[] mirrorEnd = new Point[m];
            for (int i = 0; i < m; i++)
            {
                mirrorDir[i] = scan.next();
                mirrorStart[i] = new Point(scan.nextInt(), scan.nextInt());
                mirrorEnd[i] = new Point(scan.nextInt(), scan.nextInt());

                biggestX = Math.max(biggestX, mirrorStart[i].x);
                biggestY = Math.max(biggestY, mirrorStart[i].y);

                biggestX = Math.max(biggestX, mirrorEnd[i].x);
                biggestY = Math.max(biggestY, mirrorEnd[i].y);
            }

            System.out.println("Case " + c + ":");
            process(vamps, mortals, mirrorDir, mirrorStart, mirrorEnd, biggestX, biggestY);

            v = scan.nextInt();
            o = scan.nextInt();
            m = scan.nextInt();
        }
    }

    public static void main(String[] args) throws Exception
    {
        new G().doIt();
    }
}