#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#define INF 0x3f3f3f3f
#define rep0(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define rep_0(i, n) for (int i = n - 1; i >= 0; i--)
#define rep_1(i, n) for (int i = n; i > 0; i--)
#define MAX(x, y) (((x) > (y)) ? (x) : (y))
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
#define mem(x, y) memset(x, y, sizeof(x))
#include <map>
#define MAXN (10000 + 10)
#define MAXK 1000
/**
題目大意
N * N的區域內，有K個格子不能到達，機器人從(0, 0)出發有均等的該概率
留在原地和到達上下左右可到達的區域，問無窮遠的時間以後有多大概率到達
x + y >= n - 1 的區域
思路
計算除了不能到達的格子之外的格子能通往多少方向d，則格子的權值為d + 1
ans = x + y >= n - 1 的格子的權值之和 / 總權值和

*******************************************************

馬爾科夫鏈的隨機遊走模型
可建立狀態轉移矩陣，對n * n 的圖中n * n 個點編號為0 ~[ (n - 1) * n + n – 1]  設最大編號為max
P = p(i, j) = [p(0, 0) p(0, 1) … p(0, max)
               P(1, 0) p(1, 1) … p(1, max)
               …
               P(max, 0) p(max, 1) … p(max, max)]
π(i) 為i時間各點的概率
π(n + 1) = π(n) * P
當時間->無窮 π(n + 1)->π
可以通過 π * P = π 計算  
驗證猜測結果正確

*******************************************************
找規律的答案 有待證明
現在能想到的是 整個封閉系統每個格子以出現機器人的概率作為權值 在很長的時間線上是一個熵增的
過程(想到元胞自動機)，如果要模擬這個概率擴散的過程的話，格子的權值的更新是一個用他所能到達的格子的權值
和他自身的權值迭代的過程，這個過程中可以發現他的相鄰的格子的權值是在不斷同化的，因此，在無窮遠後
(0, 0)的和他周圍的格子的權值不在體現優勢，而更加開放的格子則更佔優(可根據迭代公式理解)

*/

using namespace std;
typedef long long LL;
int n, k;
map<LL, int> mp;
int dir[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
int g[MAXK][2];
LL gcd(LL x, LL y)
{
    if (y == 0)
        return x;
    else return gcd(y, x % y);
}

int main()
{
    #ifndef ONLINE_JUDGE
        freopen("in.txt", "r", stdin);
    #endif // ONLINE_JUDGE
    int t, kase = 0;
    scanf("%d", &t);

    while(t--)
    {
        mp.clear();
        scanf("%d %d", &n, &k);
        LL a = 0, b = 0;
        if (n > 2)
        {
            a += (LL)(n - 2) * 4 * 2 + 3 * 3 + (LL)(n - 2) * (n - 1) / 2 * 5;
            b += 4 * 3 + (LL)(n - 2) * 4 * 4 + (LL)(n - 2) * (n - 2) * 5;
        }
        else
        {
            a += 3 * 3;
            b += 4 * 3;
        }
        //cout << a << "   " << b << endl;
        int x, y;
        for (int i = 0; i < k; i++)
        {
            scanf("%d %d", &x, &y);
            pair<LL, int> tmp;
            tmp.first = (LL)x * MAXN + y;
            tmp.second = i;
            mp.insert(tmp);

        }

        map<LL, int> :: iterator itr;
        map<LL, int> :: iterator itr1;
        for (itr = mp.begin(); itr != mp.end(); itr++)
        {
            x = (itr->first) / MAXN;
            y = (itr->first) % MAXN;
            int cnt = 0;
            for (int i = 0; i < 4; i++)
            {
                int nx = x + dir[i][0], ny = y + dir[i][1];
                if (nx < 0 || nx >= n || ny < 0 || ny >= n)
                    continue;

                cnt++;
                bool t = (itr1 = mp.find( (LL) nx * MAXN + ny) ) == mp.end();
                if (t && nx + ny >=  n - 1)
                {

                    b--;
                    a--;

                }
                else if (t)
                    b--;

            }

            b -= cnt + 1;
            if (x + y >= n - 1)
                a -= cnt + 1;
        }

        LL g = gcd(a, b);

        printf("Case #%d: %lld/%lld\n", ++kase, a / g, b / g);

    }

    return 0;
}