#include <bits/stdc++.h>
using namespace std;
bool customS(pair<int64_t, int64_t> a, pair<int64_t, int64_t> b) {
  if (a.first == b.first) return a.second < b.second;
  return a.first < b.first;
}
class CompareDist {
 public:
  bool operator()(pair<int64_t, int64_t> a, pair<int64_t, int64_t> b) {
    return a.first < b.first;
  }
};
int64_t gcd(int64_t a, int64_t b) {
  if (b == 0) return a;
  return gcd(b, a % b);
}
double gcdfloat(double a, double b) {
  if (a < b) return gcd(b, a);
  if (fabs(b) < 0.001)
    return a;
  else
    return (gcd(b, a - floor(a / b) * b));
}
void DFS(int64_t start, vector<vector<int> > nodes, vector<int> visited,
         vector<int> path, vector<vector<int> > &route) {
  visited[start] = 1;
  path.push_back(start);
  if (start == nodes.size() - 1) {
    route.push_back(path);
  }
  for (int i = 0; i < nodes[start].size(); i++) {
    if (visited[nodes[start][i]] == 0) {
      DFS(nodes[start][i], nodes, visited, path, route);
    }
  }
}
vector<int64_t> ra(int64_t n) {
  vector<int64_t> arr(n);
  for (int i = 0; i < n; i++) cin >> arr[i];
  return arr;
}
int64_t binary_search_lower(vector<int64_t> &arr, int64_t n) {
  int64_t low = 0, high = arr.size() - 1, mid, ans = -1;
  while (low <= high) {
    mid = (low + high) / 2;
    if (arr[mid] <= n) {
      ans = mid;
      low = mid + 1;
    } else {
      high = mid - 1;
    }
  }
  return ans;
}
int64_t binary_search_upper(vector<int64_t> &arr, int64_t n) {
  int64_t low = 0, high = arr.size() - 1, mid, ans = -1;
  while (low <= high) {
    mid = (low + high) / 2;
    if (arr[mid] >= n) {
      ans = mid;
      high = mid - 1;
    } else {
      low = mid + 1;
    }
  }
  return ans;
}
int64_t gcdExtended(int64_t a, int64_t b, int64_t *x, int64_t *y) {
  if (a == 0) {
    *x = 0, *y = 1;
    return b;
  }
  int64_t x1, y1;
  int64_t gcd = gcdExtended(b % a, a, &x1, &y1);
  *x = y1 - (b / a) * x1;
  *y = x1;
  return gcd;
}
int64_t modInverse(int64_t a, int64_t m) {
  int64_t x, y;
  int64_t g = gcdExtended(a, m, &x, &y);
  if (g != 1)
    return -1;
  else {
    int64_t res = (x % m + m) % m;
    return res;
  }
}
int check(int cNode, int *start, int parent, vector<vector<int> > &nodes,
          vector<int64_t> &arr) {
  vector<int> temp_2 = nodes[cNode];
  temp_2.erase(remove(temp_2.begin(), temp_2.end(), parent), temp_2.end());
  int nChild = temp_2.size();
  if (nChild == 0) return 1;
  vector<int> temp;
  int ctr = 0;
  for (int i = *start; ctr < nChild; i++, ctr++) {
    temp.push_back(arr[i]);
  }
  sort(temp.begin(), temp.end());
  sort(temp_2.begin(), temp_2.end());
  int before = *start;
  *start = *start + nChild;
  if (temp == temp_2) {
    int x = 1;
    for (int i = before; i < min(before + nChild, int(arr.size())); i++) {
      x = x & check(arr[i], start, cNode, nodes, arr);
    }
    return x;
  }
  return 0;
}
int main() {
  int trial, t;
  cin >> trial;
  for (t = 1; t <= trial; t++) {
    int64_t i, j, a = 0, b = 0, c = 0, d = 0, n, m, k, sum = 0, x = 0, y = 0,
                  z = 0, flag = 0, zero = 0, ans = 0;
    int64_t mod = 1000000007;
    string s, newS, s1, s2;
    cin >> n;
    vector<int64_t> arr(n);
    for (i = 0; i < n; i++) {
      cin >> x;
      arr[i] = ((x + i) % n + n) % n;
    }
    sort(arr.begin(), arr.end());
    for (i = 1; i < n; i++) {
      if (arr[i] == arr[i - 1]) {
        flag = 1;
        break;
      }
    }
    if (flag == 1)
      cout << "NO\n";
    else
      cout << "YES\n";
  }
  return 0;
}
