description: n towns are arranged in a circle sequentially. The towns are numbered from 1 to n in clockwise order. In the i-th town, there lives a singer with a repertoire of a_i minutes for each i ∈ [1, n].
  
  Each singer visited all n towns in clockwise order, starting with the town he lives in, and gave exactly one concert in each town. In addition, in each town, the i-th singer got inspired and came up with a song that lasts a_i minutes. The song was added to his repertoire so that he could perform it in the rest of the cities.
  
  Hence, for the i-th singer, the concert in the i-th town will last a_i minutes, in the (i + 1)-th town the concert will last 2 ⋅ a_i minutes, ..., in the ((i + k) mod n + 1)-th town the duration of the concert will be (k + 2) ⋅ a_i, ..., in the town ((i + n - 2) mod n + 1) — n ⋅ a_i minutes.
  
  You are given an array of b integer numbers, where b_i is the total duration of concerts in the i-th town. Reconstruct any correct sequence of positive integers a or say that it is impossible.
  
  Input
  
  The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of test cases. Then the test cases follow.
  
  Each test case consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 4 ⋅ 10^4) — the number of cities. The second line contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ 10^{9}) — the total duration of concerts in i-th city.
  
  The sum of n over all test cases does not exceed 2 ⋅ 10^5.
  
  Output
  
  For each test case, print the answer as follows:
  
  If there is no suitable sequence a, print NO. Otherwise, on the first line print YES, on the next line print the sequence a_1, a_2, ..., a_n of n integers, where a_i (1 ≤ a_i ≤ 10^{9}) is the initial duration of repertoire of the i-th singer. If there are multiple answers, print any of them.
  
  Example
  
  Input
  
  
  4
  3
  12 16 14
  1
  1
  3
  1 2 3
  6
  81 75 75 93 93 87
  
  
  Output
  
  
  YES
  3 1 3 
  YES
  1 
  NO
  YES
  5 5 4 1 4 5 
  
  Note
  
  Let's consider the 1-st test case of the example:
  
    1. the 1-st singer in the 1-st city will give a concert for 3 minutes, in the 2-nd — for 6 minutes, in the 3-rd — for 9 minutes; 
    2. the 2-nd singer in the 1-st city will give a concert for 3 minutes, in the 2-nd — for 1 minute, in the 3-rd - for 2 minutes; 
    3. the 3-rd singer in the 1-st city will give a concert for 6 minutes, in the 2-nd — for 9 minutes, in the 3-rd — for 3 minutes. 
solution: import array
  import bisect
  import heapq
  import math
  import collections
  import sys
  import copy
  from functools import reduce
  import decimal
  from io import BytesIO, IOBase
  import os
  import itertools
  import functools
  from types import GeneratorType
  
  #
  # sys.setrecursionlimit(10 ** 9)
  decimal.getcontext().rounding = decimal.ROUND_HALF_UP
  
  graphDict = collections.defaultdict
  
  queue = collections.deque
  
  
  ################## pypy deep recursion handling ##############
  # Author = @pajenegod
  def bootstrap(f, stack=[]):
      def wrappedfunc(*args, **kwargs):
          to = f(*args, **kwargs)
          if stack:
              return to
          else:
              while True:
                  if type(to) is GeneratorType:
                      stack.append(to)
                      to = next(to)
                  else:
                      stack.pop()
                      if not stack:
                          return to
                      to = stack[-1].send(to)
  
      return wrappedfunc
  
  
  ################## Graphs ###################
  class Graphs:
      def __init__(self):
          self.graph = graphDict(set)
  
      def add_edge(self, u, v):
          self.graph[u].add(v)
          self.graph[v].add(u)
  
      def dfs_utility(self, nodes, visited_nodes, colors, parity, level):
          global count
          if nodes == 1:
              colors[nodes] = -1
          else:
              if len(self.graph[nodes]) == 1 and parity % 2 == 0:
                  if q == 1:
                      colors[nodes] = 1
                  else:
                      colors[nodes] = -1
                      count += 1
              else:
                  if parity % 2 == 0:
                      colors[nodes] = -1
                  else:
                      colors[nodes] = 1
          visited_nodes.add(nodes)
          for neighbour in self.graph[nodes]:
              new_level = level + 1
              if neighbour not in visited_nodes:
                  self.dfs_utility(neighbour, visited_nodes, colors, level - 1, new_level)
  
      def dfs(self, node):
          Visited = set()
          color = collections.defaultdict()
          self.dfs_utility(node, Visited, color, 0, 0)
          return color
  
      def bfs(self, node, f_node):
          count = float("inf")
          visited = set()
          level = 0
          if node not in visited:
              queue.append([node, level])
              visited.add(node)
          flag = 0
          while queue:
              parent = queue.popleft()
              if parent[0] == f_node:
                  flag = 1
                  count = min(count, parent[1])
              level = parent[1] + 1
              for item in self.graph[parent[0]]:
                  if item not in visited:
                      queue.append([item, level])
                      visited.add(item)
          return count if flag else -1
          return False
  
  
  ################### Tree Implementaion ##############
  class Tree:
      def __init__(self, data):
          self.data = data
          self.left = None
          self.right = None
  
  
  def inorder(node, lis):
      if node:
          inorder(node.left, lis)
          lis.append(node.data)
          inorder(node.right, lis)
      return lis
  
  
  def leaf_node_sum(root):
      if root is None:
          return 0
      if root.left is None and root.right is None:
          return root.data
      return leaf_node_sum(root.left) + leaf_node_sum(root.right)
  
  
  def hight(root):
      if root is None:
          return -1
      if root.left is None and root.right is None:
          return 0
      return max(hight(root.left), hight(root.right)) + 1
  
  
  ################## Union Find #######################
  class UnionFind():
      parents = []
      sizes = []
      count = 0
  
      def __init__(self, n):
          self.count = n
          self.parents = [i for i in range(n)]
          self.sizes = [1 for i in range(n)]
  
      def find(self, i):
          if self.parents[i] == i:
              return i
          else:
              self.parents[i] = self.find(self.parents[i])
              return self.parents[i]
  
      def unite(self, i, j):
          root_i = self.find(i)
          root_j = self.find(j)
          if root_i == root_j:
              return
          elif root_i < root_j:
              self.parents[root_j] = root_i
              self.sizes[root_i] += self.sizes[root_j]
          else:
              self.parents[root_i] = root_j
              self.sizes[root_j] += self.sizes[root_i]
  
      def same(self, i, j):
          return self.find(i) == self.find(j)
  
      def size(self, i):
          return self.sizes[self.find(i)]
  
      def group_count(self):
          return len(set(self.find(i) for i in range(self.count)))
  
      def answer(self, extra, p, q):
          dic = collections.Counter()
          for q in range(n):
              dic[self.find(q)] = self.size(q)
          hq = list(dic.values())
          heapq._heapify_max(hq)
          ans = -1
          for z in range(extra + 1):
              if hq:
                  ans += heapq._heappop_max(hq)
              else:
                  break
          return ans
  
  
  #################################################
  
  def rounding(n):
      return int(decimal.Decimal(f'{n}').to_integral_value())
  
  
  def factors(n):
      return set(reduce(list.__add__,
                        ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
  
  
  def p_sum(array):
      return list(itertools.accumulate(array))
  
  
  def base_change(nn, bb):
      if nn == 0:
          return [0]
      digits = []
      while nn:
          digits.append(int(nn % bb))
          nn //= bb
      return digits[::-1]
  
  
  def diophantine(a: int, b: int, c: int):
      d, x, y = extended_gcd(a, b)
      r = c // d
      return r * x, r * y
  
  
  @bootstrap
  def extended_gcd(a: int, b: int):
      if b == 0:
          d, x, y = a, 1, 0
      else:
          (d, p, q) = yield extended_gcd(b, a % b)
          x = q
          y = p - q * (a // b)
  
      yield d, x, y
  
  
  ######################################################################################
  
  '''
  Knowledge and awareness are vague, and perhaps better called illusions.
  Everyone lives within their own subjective interpretation.
                                                              ~Uchiha Itachi
  '''
  
  ################################ <fast I/O> ###########################################
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self, **kwargs):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  
  
  #############################################<I/O Region >##############################################
  
  
  def inp():
      return sys.stdin.readline().strip()
  
  
  def map_inp(v_type):
      return map(v_type, inp().split())
  
  
  def list_inp(v_type):
      return list(map_inp(v_type))
  
  
  ######################################## Solution ####################################
  
  for _ in range(int(inp())):
      n = int(inp())
      b = list_inp(int)
      total = sum(b)
      div = ((n * (n + 1)) // 2)
      if total % div == 0:
          single_sum = total // div
          ans = []
          flag = 1
          for i in range(n):
              if b[i] < single_sum:
                  flag = 0
                  break
              x = (b[(i - 1) % n] - (b[i] - single_sum))
              if x % n == 0 and x // n > 0:
                  ans.append(x // n)
              else:
                  flag = 0
                  break
          if flag:
              print("YES")
              print(*ans)
          else:
              print("NO")
      else:
          print("NO")
  