#include <stdio.h>
#define MAX 1010
#define SWAP(x, y) (x)^=((y)^=((x)^=(y)))

typedef struct
{
    int x, y;
}Point;

Point quene1[MAX * 4], quene2[MAX * 4];
int map[MAX][MAX];
char input[100];

inline char* getUInt(register char buffer[], register unsigned int* dst)
{
    while (*buffer < '0')
        if (!*buffer++) return NULL;
    *dst = *buffer ^ '0';
    while (*++buffer >= '0')
        * dst = (*dst << 3) + (*dst << 1) + (*buffer ^ '0');
    return buffer;
}

inline void setMap(int map[][MAX], Point s, Point e, int val)
{
    if (e.x < s.x) SWAP(e.x, s.x);
    if (e.y < s.y) SWAP(e.y, s.y);
    for (int i = s.x; i <= e.x; i++)
    {
        for (int j = s.y; j <= e.y; j++)
            map[i][j] = val;
    }
}

int getAns(int row, int col, register Point* nowTop)
{
    Point* now = quene1, * next = quene2, * nextTop, * tmp;
    for (int step = 1;; step++)
    {
        if (nowTop == now)
            return -1;
        nextTop = next;
        while (now <= --nowTop)
        {
            if (map[nowTop->x][nowTop->y]) continue;
            map[nowTop->x][nowTop->y] = step;
            if (nowTop->x > 0)
            {
                if (map[nowTop->x - 1][nowTop->y])
                {
                    if (map[nowTop->x - 1][nowTop->y] == -2)
                        return step;
                }
                else nextTop->x = nowTop->x - 1, nextTop++->y = nowTop->y;
            }
            if (nowTop->x < row)
            {
                if (map[nowTop->x + 1][nowTop->y])
                {
                    if (map[nowTop->x + 1][nowTop->y] == -2)
                        return step;
                }
                else nextTop->x = nowTop->x + 1, nextTop++->y = nowTop->y;
            }
            if (nowTop->y > 0)
            {
                if (map[nowTop->x][nowTop->y - 1])
                {
                    if (map[nowTop->x][nowTop->y - 1] == -2)
                        return step;
                }
                else nextTop->x = nowTop->x, nextTop++->y = nowTop->y - 1;
            }
            if (nowTop->y < col)
            {
                if (map[nowTop->x][nowTop->y + 1])
                {
                    if (map[nowTop->x][nowTop->y + 1] == -2)
                        return step;
                }
                else nextTop->x = nowTop->x, nextTop++->y = nowTop->y + 1;
            }
        }
        tmp = now, now = next, next = tmp;
        nowTop = nextTop;
    }
}

int main()
{
    char* st;
    int n, m, ans;
    Point s, e, * nowTop = quene1;
    scanf("%d %d", &n, &m);
    scanf("%*s %d %d %d %d", &s.x, &s.y, &e.x, &e.y);
    if (e.x < s.x) SWAP(e.x, s.x);
    if (e.y < s.y) SWAP(e.y, s.y);
    int idx = 0;
    for (int i = s.x; i <= e.x; i++)
    {
        for (int j = s.y; j <= e.y; j++)
            nowTop->x = i, nowTop++->y = j;
    }
    scanf("%*s %d %d %d %d %*s", &s.x, &s.y, &e.x, &e.y);
    setMap(map, s, e, -2);
    getchar();
    while (gets(input) && input[1] != 'b')
    {
        st = getUInt(input, &s.x), st = getUInt(st, &s.y);
        st = getUInt(st, &e.x), st = getUInt(st, &e.y);
        setMap(map, s, e, -3);
    }
    ans = getAns(n - 1, m - 1, nowTop);
    if (ans == -1)
        puts("no path");
    else
        printf("%d", ans);
    return 0;
}

#include <stdio.h>

int main()
{
    puts("^ & << ta tb");
    return 0;
}

#include <stdio.h>

int sum, eng[26] = { 10 ,11 ,12 ,13 ,14 ,15 ,16 ,17 ,34 ,18 ,19 ,20 ,21
                    ,22 ,35 ,23 ,24 ,25 ,26 ,27 ,28 ,29 ,32 ,30 ,31 ,33 };
char input[11];

int main()
{
    while (gets(input) != NULL)
    {
        sum = eng[input[0] - 'A'] / 10 + (eng[input[0] - 'A'] % 10) * 9 + (input[8] - '0') + (input[9] - '0');
        for (int i = 1; i < 8; i++)
            sum += (input[i] - '0') * (9 - i);
        if (sum % 10 == 0) puts("real");
        else puts("fake");
    }
    return 0;
}

typedef int Node;

#include <stdio.h>
#define HEAPSIZ 1024

typedef int Node;

typedef struct
{
    Node val[HEAPSIZ];
    int _last;
}Heap;

inline int cmp(register const Node* lhs, register const Node* rhs)
{
    return *lhs - *rhs;
}

inline void swap(register Node* lhs, register Node* rhs)
{
    Node tmp = *lhs;
    *lhs = *rhs, * rhs = tmp;
}

void insNode(register Heap* heap, register Node val)
{
    heap->val[++heap->_last] = val;
    int now = heap->_last, base = now >> 1;
    while (base && cmp(&heap->val[base], &heap->val[now]) < 0)
        swap(&heap->val[now], &heap->val[base]), now >>= 1, base >>= 1;
}

Node delNode(register Heap* heap)
{
    swap(&heap->val[1], &heap->val[heap->_last--]);
    int now = 1, derived = 2;
    while (derived <= heap->_last)
    {
        if (cmp(&heap->val[derived], &heap->val[derived + 1]) < 0 && derived < heap->_last) derived++;
        if (cmp(&heap->val[derived], &heap->val[now]) < 0) break;
        swap(&heap->val[derived], &heap->val[now]), now <<= 1, derived <<= 1;
    }
}

int main()
{
    Heap heap = { 0 };
    insNode(&heap, 5);
    insNode(&heap, 9);
    insNode(&heap, 1);
    insNode(&heap, 9);
    insNode(&heap, 7);
    printf("%d\n", heap.val[1]);
    delNode(&heap);
    printf("%d\n", heap.val[1]);
    delNode(&heap);
    printf("%d\n", heap.val[1]);
    delNode(&heap);
    printf("%d\n", heap.val[1]);
    delNode(&heap);
    printf("%d\n", heap.val[1]);
    delNode(&heap);
    return 0;
}

#include <stdio.h>
#define ENTSIZ 1024

typedef struct
{
    struct Data
    {
        int a, b;
    };
    struct Node* _next;
}Node;

typedef struct
{
    Node* front, * last;
}Queue;

Node entries[ENTSIZ], * entry = entries, * freeBuk;

inline void push(register Queue* que, register Node val)
{
    if (freeBuk)
    {
        Node* tmp = freeBuk->_next;
        *freeBuk = val, freeBuk->_next = NULL;
        if (que->last)  que->last = que->last->_next = freeBuk;
        else que->front = que->last = freeBuk;
        freeBuk = tmp;
    }
    else
    {
        *entry = val;
        if (que->last) que->last = que->last->_next = entry++;
        else que->front = que->last = entry++;
    }
}

inline Node pop(register Queue* que)
{
    Node* tmp = que->front;
    que->front = que->front->_next;
    tmp->_next = freeBuk;
    return *(freeBuk = tmp);
}

int main()
{
    Queue queue = { 0 };
    Node n = { 0, 1 };
    push(&queue, n);
    n.b = 2;
    push(&queue, n);
    push(&queue, pop(&queue));
    n.b = 3;
    push(&queue, n);
    n = pop(&queue);
    printf("%d,%d\n", n.a, n.b);
    printf("%d,%d\n", queue.front->a, queue.front->b);
    printf("%d,%d\n", queue.last->a, queue.last->b);
    return 0;
}

#include <stdio.h>
#define ENTSIZ 1024

typedef struct
{
    struct Data
    {
        int a, b;
    };
    struct Node* _next;
}Node;

typedef struct
{
    Node* top;
}Stack;

Node entries[ENTSIZ], * entry = entries, * freeBuk;

inline void push(register Stack* stk, register Node val)
{
    if (freeBuk)
    {
        Node* tmp = freeBuk->_next;
        *freeBuk = val, freeBuk->_next = stk->top;
        stk->top = freeBuk;
        freeBuk = tmp;
    }
    else
    {
        *entry = val, entry->_next = stk->top;
        stk->top = entry++;
    }
}

inline Node pop(register Stack* stk)
{
    Node* tmp = stk->top;
    stk->top = stk->top->_next;
    tmp->_next = freeBuk;
    return *(freeBuk = tmp);
}

int main()
{
    Stack stack1 = { 0 }, stack2 = { 0 };
    Node n = { 0, 1 };
    push(&stack1, n);
    n.b = 2;
    push(&stack2, n);
    push(&stack1, pop(&stack2));
    n = pop(&stack1);
    printf("%d,%d\n", n.a, n.b);
    printf("%d,%d\n", stack1.top->a, stack1.top->b);
    n = pop(&stack1);
    printf("%d,%d", n.a, n.b);
    return 0;
}

#include <stdio.h>
#define MAX 255
#define MAX2 62500

typedef struct
{
    int val[4], * top;
}Stack;

typedef struct
{
    int val, next;
}Query;

Stack list[MAX2];
Query qList[50005];
int map[MAX][MAX], parent[MAX2], query[MAX2], depth[MAX2],sum, len, qTop;
char input[MAX][MAX];

void dfs(int i, int j, int dep)
{
    int idx = ++len;
    parent[idx] = map[i][j] = idx;
    depth[idx] = dep;
    list[idx].top = list[idx].val;
    if (input[i + 1][j] == '.' && !map[i + 1][j])
        dfs(i + 1, j, dep + 1), * list[idx].top++ = map[i + 1][j];
    if (input[i - 1][j] == '.' && !map[i - 1][j])
        dfs(i - 1, j, dep + 1), * list[idx].top++ = map[i - 1][j];
    if (input[i][j + 1] == '.' && !map[i][j + 1])
        dfs(i, j + 1, dep + 1), * list[idx].top++ = map[i][j + 1];
    if (input[i][j - 1] == '.' && !map[i][j - 1])
        dfs(i, j - 1, dep + 1), * list[idx].top++ = map[i][j - 1];
}

inline void setDepth(int n, int m)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            if (input[i][j] == '.')
            {
                dfs(i, j, 0);
                return;
            }
        }
    }
}

inline void addQuery(int from, int to)
{
    qTop++;
    qList[qTop].val = to;
    qList[qTop].next = query[from];
    query[from] = qTop;
}

int find(int i)
{
    return i == parent[i] ? i : (parent[i] = find(parent[i]));
}

void tarjan(int i)
{
    for (Query* j = &qList[query[i]]; j->val; j = &qList[j->next])
        sum += depth[i] + depth[j->val] - (depth[find(j->val)] << 1);
    for (int* j = list[i].val; j < list[i].top; j++)
    {
        tarjan(*j);
        parent[*j] = i;
    }
}

int main()
{
    int n, m, q, sX, sY, eX, eY, s, e;
    scanf(" %d %d %d", &n, &m, &q);
    getchar();
    for (int i = 0, idx = 0; i < n; i++)
        gets(input[i]);
    setDepth(n, m);
    for (int i = 0; i < q; i++)
    {
        scanf(" %d %d %d %d", &sX, &sY, &eX, &eY);
        s = map[sX][sY], e = map[eX][eY];
        if (s < e)
            addQuery(e, s);
        else
            addQuery(s, e);
    }
    tarjan(1);
    printf("%d\n", sum);
    return 0;
}

#include <stdio.h>
#define MAX 255
#define MAX2 62500
#define BUFSIZ 1048576

typedef struct
{
    int val[4], * top;
}Stack;

typedef struct
{
    int val, next;
}Query;

Stack list[MAX2];
Query qList[50005];
int map[MAX][MAX], parent[MAX2], query[MAX2], depth[MAX2], sum, len, qTop;
char input[MAX][MAX];

inline char readChar()
{
    static char buffer[BUFSIZ], * now = buffer + BUFSIZ, * end = buffer + BUFSIZ;
    if (now == end)
    {
        if (end < buffer + BUFSIZ)
            return EOF;
        end = (buffer + fread(buffer, 1, BUFSIZ, stdin));
        now = buffer;
    }
    return *now++;
}

inline char readString(register unsigned char* dst)
{
    register char ch;
    while ((ch = readChar()) <= ' ')
        if (ch == EOF) return 0;
    *dst++ = ch;
    while ((ch = readChar()) > ' ')
        * dst++ = ch;
    return 1;
}

inline char readUInt(register unsigned int* dst)
{
    register char ch;
    while ((ch = readChar()) < '0')
        if (ch == EOF) return 0;
    *dst = ch ^ '0';
    while ((ch = readChar()) >= '0')
        * dst = (*dst << 3) + (*dst << 1) + (ch ^ '0');
    return 1;
}

void dfs(int i, int j, int dep)
{
    int idx = ++len;
    parent[idx] = map[i][j] = idx;
    depth[idx] = dep;
    list[idx].top = list[idx].val;
    if (input[i + 1][j] == '.' && !map[i + 1][j])
        dfs(i + 1, j, dep + 1), * list[idx].top++ = map[i + 1][j];
    if (input[i - 1][j] == '.' && !map[i - 1][j])
        dfs(i - 1, j, dep + 1), * list[idx].top++ = map[i - 1][j];
    if (input[i][j + 1] == '.' && !map[i][j + 1])
        dfs(i, j + 1, dep + 1), * list[idx].top++ = map[i][j + 1];
    if (input[i][j - 1] == '.' && !map[i][j - 1])
        dfs(i, j - 1, dep + 1), * list[idx].top++ = map[i][j - 1];
}

inline void setDepth(int n, int m)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            if (input[i][j] == '.')
            {
                dfs(i, j, 0);
                return;
            }
        }
    }
}

inline void addQuery(int from, int to)
{
    qTop++;
    qList[qTop].val = to;
    qList[qTop].next = query[from];
    query[from] = qTop;
}

int find(int i)
{
    return i == parent[i] ? i : (parent[i] = find(parent[i]));
}

void tarjan(int i)
{
    for (Query* j = &qList[query[i]]; j->val; j = &qList[j->next])
        sum += depth[i] + depth[j->val] - (depth[find(j->val)] << 1);
    for (int* j = list[i].val; j < list[i].top; j++)
    {
        tarjan(*j);
        parent[*j] = i;
    }
}

int main()
{
    int n, m, q, sX, sY, eX, eY, s, e;
    scanf(" %d %d %d", &n, &m, &q);
    for (int i = 0, idx = 0; i < n; i++)
        readString(input[i]);
    setDepth(n, m);
    for (int i = 0; i < q; i++)
    {
        readUInt(&sX), readUInt(&sY);
        readUInt(&eX), readUInt(&eY);
        s = map[sX][sY], e = map[eX][eY];
        if (s < e)
            addQuery(e, s);
        else
            addQuery(s, e);
    }
    tarjan(1);
    printf("%d\n", sum);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

typedef struct
{
    int suit, num;
}Poker;

cmp(const Poker* lhs, const Poker* rhs)
{
    return lhs->num - rhs->num;
}

int main()
{
    Poker list[5];
    int kase, tmp, count, s, n;
    scanf(" %d", &kase);
    while (kase--)
    {
        int  pair[5] = { 0 };
        for (int i = 0; i < 5; i++)
        {
            scanf(" %d", &tmp);
            count = 1, tmp--;
            list[i].suit = tmp / 13;
            list[i].num = tmp % 13;
            for (int j = i - 1; ~j; j--)
            {
                if (list[j].num == list[i].num)
                    count++;
            }
            pair[count]++, pair[count - 1]--;
        }
        if (pair[4]) puts("6");
        else if (pair[3])
        {
            if (pair[2]) puts("5");
            else puts("3");
        }
        else if (pair[2])
        {
            if (pair[2] == 2) puts("2");
            else puts("1");
        }
        else
        {
            qsort(list, 5, sizeof(Poker), cmp);
            s = n = 1;
            for (int i = 1; i < 4; i++)
            {
                if (list[i].num - 1 != list[i - 1].num)
                {
                    n = 0;
                    break;
                }
                if (list[i].suit != list[i - 1].suit)
                    s = 0;
            }
            if (n)
            {
                if (s) puts("7");
                else puts("4");
            }
            else puts("0");
        }
    }
    return 0;
}