import sys
input = sys.stdin.readline

mod=10**9+7

n,m=map(int,input().split())

class Union_find():
    def __init__(self, N): # N要素のUnion_find. A.Union_find(N)で作る.
        self.Group = [i for i in range(N)]
        self.Nodes = [1]*(N)
        
    def find(self,x): # find(a)=find(b)のとき同じグループ
        while self.Group[x] != x:
            x = self.Group[x]
        return x

    def Union(self,x,y):
        if self.find(x) != self.find(y):
            if self.Nodes[self.find(x)] < self.Nodes[self.find(y)]:
                
                self.Nodes[self.find(y)] += self.Nodes[self.find(x)]
                self.Nodes[self.find(x)] = 0
                self.Group[self.find(x)] = self.find(y)
                
            else:
                self.Nodes[self.find(x)] += self.Nodes[self.find(y)]
                self.Nodes[self.find(y)] = 0
                self.Group[self.find(y)] = self.find(x)


uf1=Union_find(n)
uf2=Union_find(n)

TO=[i for i in range(n)]
TO2=[i for i in range(n)]

Parent=[-1]*(2*n+1)

for i in range(m):
    x,y=map(int,input().split())

    x-=1
    y-=1

    k=uf1.find(x)
    l=uf1.find(y)

    to_k=TO[k]
    to_l=TO[l]

    if k==l:
        continue

    if uf1.Nodes[k]<uf1.Nodes[l]:
        uf1.Union(k,l)
        TO[uf1.find(x)]=to_l
    elif uf1.Nodes[l]<uf1.Nodes[k]:
        uf1.Union(k,l)
        TO[uf1.find(x)]=to_k
    else:
        uf2.Union(to_k,to_l)
        
        Parent[TO2[to_k]]=len(Parent)
        Parent[TO2[to_l]]=len(Parent)
        Parent.append(-1)
        
        uf1.Union(k,l)
        TO[uf1.find(x)]=uf2.find(to_k)
        TO2[uf2.find(to_k)]=len(Parent)-1

ANS=[0]*n

from functools import lru_cache
@lru_cache(maxsize=None)
def depth(x):
    if Parent[x]==-1:
        return 0
    else:
        return depth(Parent[x])+1

INV=pow(2,mod-2,mod)

for i in range(n):
    x=uf1.find(i)
    to=TO[x]

    if uf2.find(i)==to:
        print(pow(INV,depth(i),mod))

    else:
        print(0)