#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cctype>

#include <algorithm>
#include <random>
#include <bitset>
#include <queue>
#include <functional>
#include <set>
#include <map>
#include <vector>
#include <chrono>
#include <iostream>
#include <limits>
#include <numeric>

#define LOG(FMT...) fprintf(stderr, FMT)

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

struct IO_Tp {
  const static int _I_Buffer_Size = 15 << 20;
  char _I_Buffer[_I_Buffer_Size], *_I_pos = _I_Buffer;

  const static int _O_Buffer_Size = 1 << 20;
  char _O_Buffer[_O_Buffer_Size], *_O_pos = _O_Buffer;

  IO_Tp() {
    fread(_I_Buffer, 1, _I_Buffer_Size, stdin);
  }

  ~IO_Tp() {
    fwrite(_O_Buffer, 1, _O_pos - _O_Buffer, stdout);
  }

  IO_Tp &operator>>(int &res) {
    while (!isdigit(*_I_pos)) ++_I_pos;
    res = *_I_pos++ & 15;
    while (isdigit(*_I_pos)) res = res * 10 + (*_I_pos++ & 15);
    return *this;
  }

  IO_Tp &operator>>(ll &res) {
    while (!isdigit(*_I_pos)) ++_I_pos;
    res = *_I_pos++ & 15;
    while (isdigit(*_I_pos)) res = res * 10 + (*_I_pos++ & 15);
    return *this;
  }

  IO_Tp &operator<<(ll n) {
    static char _buf[20];
    char *_pos = _buf;
    do
      *_pos++ = '0' + n % 10;
    while (n /= 10);
    while (_pos != _buf) *_O_pos++ = *--_pos;
    return *this;
  }

  IO_Tp &operator<<(char ch) {
    *_O_pos++ = ch;
    return *this;
  }

  IO_Tp &operator<<(const char* s) {
    while (*s) *_O_pos++ = *s++;
    return *this;
  }
} IO;

#define ls first
#define rs second
#define fir first
#define sec second

int main() {

  int T;
  IO >> T;
  while (T--) {
    int m;
    IO >> m;
    vector<vector<pair<int, int>>> tr(m);
    for (int i = 0; i < m; ++i) {
      int n;
      IO >> n;
      tr[i].resize(n + 1);
      for (int j = 1; j <= n; ++j) IO >> tr[i][j].ls >> tr[i][j].rs;
    }
    function<bool(const vector<pair<int, int>>&)> dfs = [&](const vector<pair<int, int>>& vec) {
      if (vec.empty()) return true;
      vector<vector<pair<int, int>>> node(4);
      for (auto [id, u] : vec) {
        int mask = 0;
        if (tr[id][u].ls) mask |= 1;
        if (tr[id][u].rs) mask |= 2;
        node[mask].emplace_back(id, u);
      }
      if (!node[0].empty()) return false;

      vector<pair<int, int>> tmp;
      for (auto [id, u] : node[1])
        tmp.emplace_back(id, tr[id][u].ls);
      if (dfs(tmp)) return true;

      tmp.clear();
      for (auto [id, u] : node[2])
        tmp.emplace_back(id, tr[id][u].rs);
      if (dfs(tmp)) return true;

      tmp.clear();
      for (auto [id, u] : node[3])
        if (tr[id][tr[id][u].rs] == make_pair(0, 0))
          tmp.emplace_back(id, tr[id][u].ls);
      if (dfs(tmp)) return true;

      tmp.clear();
      for (auto [id, u] : node[3])
        if (tr[id][tr[id][u].ls] == make_pair(0, 0))
          tmp.emplace_back(id, tr[id][u].rs);
      if (dfs(tmp)) return true;

      return false;
    };
    vector<pair<int, int>> tmp;
    for (int i = 0; i < m; ++i) tmp.emplace_back(i, 1);
    IO << (dfs(tmp) ? "No" : "Almost Complete") << '\n';
  }

  return 0;
}