// Smart Carts
// Solution by Jacob Plachta

#include <algorithm>
#include <functional>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <cassert>
#include <string>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <unordered_set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <sstream>
using namespace std;

#define LL long long
#define LD long double
#define PR pair<int,int>

#define Fox(i,n) for (i=0; i<n; i++)
#define Fox1(i,n) for (i=1; i<=n; i++)
#define FoxI(i,a,b) for (i=a; i<=b; i++)
#define FoxR(i,n) for (i=(n)-1; i>=0; i--)
#define FoxR1(i,n) for (i=n; i>0; i--)
#define FoxRI(i,a,b) for (i=b; i>=a; i--)
#define Foxen(i,s) for (i=s.begin(); i!=s.end(); i++)
#define Min(a,b) a=min(a,b)
#define Max(a,b) a=max(a,b)
#define Sz(s) int((s).size())
#define All(s) (s).begin(),(s).end()
#define Fill(s,v) memset(s,v,sizeof(s))
#define pb push_back
#define mp make_pair
#define x first
#define y second

template<typename T> T Abs(T x) { return(x < 0 ? -x : x); }
template<typename T> T Sqr(T x) { return(x * x); }
string plural(string s) { return(Sz(s) && s[Sz(s) - 1] == 'x' ? s + "en" : s + "s"); }

const int INF = (int)1e9;
const LD EPS = 1e-12;
const LD PI = acos(-1.0);

#define GETCHAR getchar_unlocked

bool Read(int& x)
{
  char c, r = 0, n = 0;
  x = 0;
  for (;;)
  {
    c = GETCHAR();
    if ((c < 0) && (!r))
      return(0);
    if ((c == '-') && (!r))
      n = 1;
    else
      if ((c >= '0') && (c <= '9'))
        x = x * 10 + c - '0', r = 1;
      else
        if (r)
          break;
  }
  if (n)
    x = -x;
  return(1);
}

#define LIM 705

int N;
int nxt[2][LIM], prv[2][LIM];
vector<int> seq[2][2];
int L[2][2];
PR pos[2][LIM];

int F[2], subS[2];
vector<int> CS;
int csInd, sumC, baseAns;

int ProcessQuery0(int* K)
{
  int i, ans = 0;
  // check whether either initial line is too long to be valid
  Fox(i, 2)
    if (L[0][i] > K[i])
      return(-1);
  // count initially-satisfied carts
  Fox(i, N)
    ans += nxt[0][i] == nxt[1][i];
  return(ans);
}

void PrecomputeForQuery1(int C)
{
  int i, j;
  // determine which carts are free
  Fox(i, 2)
    F[i] = min(C - L[0][1 - i], L[0][i]);
  auto IsFree = [&](int i, int e) { // if e=1, include non-free, accessible latches
    PR p = pos[0][i];
    return(p.y > L[0][p.x] - F[p.x] - e);
  };
  // compute number of potentially-satisfiable carts
  baseAns = 0;
  Fox(i, N)
    baseAns += nxt[0][i] == nxt[1][i] || // initially satisfied?
    (IsFree(i, 0) && IsFree(nxt[1][i], 1)); // free, and target accessible?
  // split free, potentially-satisfiable carts into chains
  // and compute achievable subset sums of chain lengths
  sumC = 0;
  Fill(subS, 0);
  bitset<LIM> BC = 1;
  Fox(i, 2)
  {
    auto& s = seq[1][i];
    int c = 0, f = -1;
    Fox(j, Sz(s))
    {
      if (!IsFree(s[j], 0))
        continue;
      c++;
      // chain forced to belong to a certain line?
      if (c == 1 && j && IsFree(s[j - 1], 1))
        f = pos[0][s[j - 1]].x;
      // chain ends with this cart?
      if (j + 1 == Sz(s) || !IsFree(s[j + 1], 0))
      {
        if (f < 0)
          sumC += c, BC |= (BC << c);
        else
          subS[f] += c;
        c = 0, f = -1;
      }
    }
  }
  // store results
  CS.clear();
  Fox(i, sumC + 1)
    if (BC[i])
      CS.pb(i);
  csInd = 0;
}

int ProcessQuery1(int* K)
{
  // compute space for free carts in each line
  int i, S[2];
  Fox(i, 2)
    S[i] = K[i] - (L[0][i] - F[i]) - subS[i];
  // check whether all free cart chains may be packed into the lines
  if (min(S[0], S[1]) < 0)
    return(baseAns - 1);
  while (csInd + 1 < Sz(CS) && CS[csInd + 1] <= S[0])
    csInd++;
  if (sumC - CS[csInd] <= S[1])
    return(baseAns);
  return(baseAns - 1); // 1 cart must remain unsatisfied due to chain breakage
}

int ProcessQuery2(int* K)
{
  int i;
  // check whether either target line is too long to be fully satisfied
  Fox(i, 2)
    if (L[1][i] > K[i])
      return(N - 1);
  return(N);
}

int ProcessQuery(int d, int c, int x, int y)
{
  int i, K[2] = { min(c, x), min(c, y) };
  // check whether either initial line is too long to be valid
  Fox(i, 2)
    if (L[0][i] > c)
      return(-1);
  // check whether there are too many carts to form valid final lines
  if (N > K[0] + K[1])
    return(-1);
  return d == 0
    ? ProcessQuery0(K)
    : d == 1
    ? ProcessQuery1(K)
    : ProcessQuery2(K);
}

void ProcessCase()
{
  int i, j, z;
  // init
  Fill(prv, -1);
  // input
  Read(N);
  Fox(i, N)
  {
    Fox(z, 2)
    {
      Read(nxt[z][i]), nxt[z][i]--;
      prv[z][nxt[z][i]] = i;
    }
  }
  // split into lines (initial/target)
  Fox(z, 2)
  {
    Fox(i, 2)
    {
      seq[z][i].clear();
      j = N + i;
      while (j >= 0)
      {
        pos[z][j] = mp(i, Sz(seq[z][i]));
        seq[z][i].pb(j);
        j = prv[z][j];
      }
      L[z][i] = Sz(seq[z][i]) - 1;
    }
  }
  // process queries
  int d, c, x, y;
  LL G[LIM] = { 0 };
  Fox(d, min(3, N + 1))
  {
    Fox(c, N + 1)
    {
      if (d == 1)
        PrecomputeForQuery1(c);
      Fox(x, N + 1)
      {
        Fox(y, N + 1)
          G[ProcessQuery(d, c, x, y) + 1] += d == 2 ? N - 1 : 1;
      }
    }
  }
  Fox(i, N + 2)
    printf(" %lld", G[i]);
  printf("\n");
}

int main()
{
  int T, t;
  Read(T);
  Fox1(t, T)
  {
    printf("Case #%d:", t);
    ProcessCase();
  }
  return(0);
}