n = int(eval(input()))

A= list(map(int, input().split()))



mod = int(1e9+7)

def invmod(a, mod):

    if a==1:

        return 1

    return -invmod(mod%a, mod) * (mod//a) %mod





memo={}

for i, a in enumerate(A):

  if a in memo:

    L = memo[a]

    C = i - memo[a] -1

    R = len(A) - i-1

    break

  else:

    memo[a] = i

    

#print(L,C,R)

_LR = [0]*(n+3)

_LCR = [0] * (n+3) # _LCR[k] = (L+C+R)C(k)

_k = [0] * (n+3)

_LR[0] = _LCR[0] = _k[0] = 1



LR = [0]*(n+2) #LR[k] = (L+R)C(k)

LR[0] = 1

#LDR = [0]*(n+2)

#LDDR = [0]*(n+2)



LCR = [0] * (n+2) # LCR[k] = _LCR[k] - LR[k]

#LDCR = [0] * (n+2) #最後に*2を忘れないこと

#LDCDR = [0] * (n+2)



for k in range(1,n+2):

  _LR[k] = (_LR[k-1] * (L+R+1-k)) %mod

  _LCR[k] = (_LCR[k-1] * (L+C+R+1-k))% mod

  _k[k] = (_k[k-1] * invmod(k,mod)) %mod

  

  LR[k] = (_LR[k] * _k[k])%mod

#  LDR[k] = LR[k-1]

#  LDDR[k] = LDR[k-1]

  

  LCR[k] = (_LCR[k] * _k[k])%mod - LR[k]

#  LDCR[k] = LCR[k-1]

#  LDCDR[k] = LDCR[k-1]

  #print(LR, LCR)

  print(((LR[k] + LR[k-1] + LR[k-2] + LCR[k] + 2*LCR[k-1] + LCR[k-2])%mod))

  

#print(LR)

#print(LDR)

#print(LDDR)

#print(_LCR)

#print(LCR)

#print(LDCR)

#print(LDCDR)
n = int(eval(input()))

A= list(map(int, input().split()))



mod = 10**9+7



class combinationmod():

  def __init__(self,MAX, mod):

    self.mod =mod

    self.fac=[0]*(MAX+1)

    self.finv=[0]*(MAX+1)

    self.inv=[0]*(MAX+1)

    self.fac[0]=self.fac[1]=1

    self.finv[0]=self.finv[1]=1

    self.inv[1]=1

    for i in range(2,MAX+1):

      self.fac[i] = self.fac[i-1]*i%self.mod

      self.inv[i] = (-self.inv[mod%i]*(mod//i))%self.mod

      self.finv[i] = self.finv[i-1]* self.inv[i] %self.mod



  def nCk(self,n,k):

    if n<k or n<0 or k<0:

      return 0

    return self.fac[n]*(self.finv[k]*self.finv[n-k]%self.mod)%self.mod

  

memo={}

for i, a in enumerate(A):

  if a in memo:

    L = memo[a]

    R = len(A) - i-1

    break

  else:

    memo[a] = i

    

c = combinationmod(n+1,mod)

for k in range(1,n+2):

  print(((c.nCk(n+1,k) - c.nCk(L+R,k-1))%mod))

n = int(eval(input()))
A = list(map(int, input().split()))
mod = int(1e9 + 7)


def invmod(a, mod):
    if a == 1:
        return 1
    return -invmod(mod % a, mod) * (mod // a) % mod


memo = {}
for i, a in enumerate(A):
    if a in memo:
        L = memo[a]
        C = i - memo[a] - 1
        R = len(A) - i - 1
        break
    else:
        memo[a] = i
# print(L,C,R)
_LR = [0] * (n + 3)
_LCR = [0] * (n + 3)  # _LCR[k] = (L+C+R)C(k)
_k = [0] * (n + 3)
_LR[0] = _LCR[0] = _k[0] = 1
LR = [0] * (n + 2)  # LR[k] = (L+R)C(k)
LR[0] = 1
# LDR = [0]*(n+2)
# LDDR = [0]*(n+2)
LCR = [0] * (n + 2)  # LCR[k] = _LCR[k] - LR[k]
# LDCR = [0] * (n+2) #最後に*2を忘れないこと
# LDCDR = [0] * (n+2)
for k in range(1, n + 2):
    _LR[k] = (_LR[k - 1] * (L + R + 1 - k)) % mod
    _LCR[k] = (_LCR[k - 1] * (L + C + R + 1 - k)) % mod
    _k[k] = (_k[k - 1] * invmod(k, mod)) % mod
    LR[k] = (_LR[k] * _k[k]) % mod
    #  LDR[k] = LR[k-1]
    #  LDDR[k] = LDR[k-1]
    LCR[k] = (_LCR[k] * _k[k]) % mod - LR[k]
    #  LDCR[k] = LCR[k-1]
    #  LDCDR[k] = LDCR[k-1]
    # print(LR, LCR)
    print(
        ((LR[k] + LR[k - 1] + LR[k - 2] + LCR[k] + 2 * LCR[k - 1] + LCR[k - 2]) % mod)
    )
# print(LR)
# print(LDR)
# print(LDDR)
# print(_LCR)
# print(LCR)
# print(LDCR)
# print(LDCDR)

n = int(eval(input()))
A = list(map(int, input().split()))
mod = 10**9 + 7


class combinationmod:
    def __init__(self, MAX, mod):
        self.mod = mod
        self.fac = [0] * (MAX + 1)
        self.finv = [0] * (MAX + 1)
        self.inv = [0] * (MAX + 1)
        self.fac[0] = self.fac[1] = 1
        self.finv[0] = self.finv[1] = 1
        self.inv[1] = 1
        for i in range(2, MAX + 1):
            self.fac[i] = self.fac[i - 1] * i % self.mod
            self.inv[i] = (-self.inv[mod % i] * (mod // i)) % self.mod
            self.finv[i] = self.finv[i - 1] * self.inv[i] % self.mod

    def nCk(self, n, k):
        if n < k or n < 0 or k < 0:
            return 0
        return self.fac[n] * (self.finv[k] * self.finv[n - k] % self.mod) % self.mod


memo = {}
for i, a in enumerate(A):
    if a in memo:
        L = memo[a]
        R = len(A) - i - 1
        break
    else:
        memo[a] = i
c = combinationmod(n + 1, mod)
for k in range(1, n + 2):
    print(((c.nCk(n + 1, k) - c.nCk(L + R, k - 1)) % mod))

-mod = int(1e9 + 7) +mod = 10**9 + 7 -def invmod(a, mod): -    if a == 1: -        return 1 -    return -invmod(mod % a, mod) * (mod // a) % mod +class combinationmod: +    def __init__(self, MAX, mod): +        self.mod = mod +        self.fac = [0] * (MAX + 1) +        self.finv = [0] * (MAX + 1) +        self.inv = [0] * (MAX + 1) +        self.fac[0] = self.fac[1] = 1 +        self.finv[0] = self.finv[1] = 1 +        self.inv[1] = 1 +        for i in range(2, MAX + 1): +            self.fac[i] = self.fac[i - 1] * i % self.mod +            self.inv[i] = (-self.inv[mod % i] * (mod // i)) % self.mod +            self.finv[i] = self.finv[i - 1] * self.inv[i] % self.mod + +    def nCk(self, n, k): +        if n < k or n < 0 or k < 0: +            return 0 +        return self.fac[n] * (self.finv[k] * self.finv[n - k] % self.mod) % self.mod -        C = i - memo[a] - 1 -# print(L,C,R) -_LR = [0] * (n + 3) -_LCR = [0] * (n + 3)  # _LCR[k] = (L+C+R)C(k) -_k = [0] * (n + 3) -_LR[0] = _LCR[0] = _k[0] = 1 -LR = [0] * (n + 2)  # LR[k] = (L+R)C(k) -LR[0] = 1 -# LDR = [0]*(n+2) -# LDDR = [0]*(n+2) -LCR = [0] * (n + 2)  # LCR[k] = _LCR[k] - LR[k] -# LDCR = [0] * (n+2) #最後に*2を忘れないこと -# LDCDR = [0] * (n+2) +c = combinationmod(n + 1, mod) -    _LR[k] = (_LR[k - 1] * (L + R + 1 - k)) % mod -    _LCR[k] = (_LCR[k - 1] * (L + C + R + 1 - k)) % mod -    _k[k] = (_k[k - 1] * invmod(k, mod)) % mod -    LR[k] = (_LR[k] * _k[k]) % mod -    #  LDR[k] = LR[k-1] -    #  LDDR[k] = LDR[k-1] -    LCR[k] = (_LCR[k] * _k[k]) % mod - LR[k] -    #  LDCR[k] = LCR[k-1] -    #  LDCDR[k] = LDCR[k-1] -    # print(LR, LCR) -    print( -        ((LR[k] + LR[k - 1] + LR[k - 2] + LCR[k] + 2 * LCR[k - 1] + LCR[k - 2]) % mod) -    ) -# print(LR) -# print(LDR) -# print(LDDR) -# print(_LCR) -# print(LCR) -# print(LDCR) -# print(LDCDR) +    print(((c.nCk(n + 1, k) - c.nCk(L + R, k - 1)) % mod))