from collections import defaultdict
import os
import sys
from io import BytesIO, IOBase
 
class UF:
    def __init__(self, N):
        self.par = list(range(N))
        self.sz = [1] * N
 
    def find(self, x):
        if self.par[x] != x:
            self.par[x] = self.find(self.par[x])
        return self.par[x]
 
    def union(self, x, y):
        xr, yr = self.find(x), self.find(y)
        if xr == yr:
            return False
        if self.sz[xr] < self.sz[yr]:
            xr, yr = yr, xr
        self.par[yr] = xr
        self.sz[xr] += self.sz[yr]
        return True
 
    def size(self, x):
        return self.sz[self.find(x)]
 
    def connected(self, x, y):
        return self.find(x) == self.find(y)
 
def dfs(start, adj, arr):
    stack = [start]
    while len(stack) > 0:
        cur = stack.pop()
        arr[cur] = 1
        for val in adj[cur]:
            if arr[val] != 1:
                arr[val] = 1
                stack.append(val)
        adj[cur] = []
 
def main():
    n,m = list(map(int, input().split(' ')))
    arr = [0 for i in range(m+1)]
    adj = defaultdict(list)
    cur_count = 1
    cur_lst = []
    uf = UF(m+1)
    for i in range(n):
        bit_lst = list(map(int, input().split(' ')))
        bit1 = bit_lst[1]
        if bit_lst[0] == 1:
           if arr[bit1] == 0:
                arr[bit1] = 1
           else:
                continue
        else:
            bit2 = bit_lst[2]
            if arr[bit1] == 1 and arr[bit2] == 1:
                continue
            elif arr[bit1] == 1:
                dfs(bit2, adj, arr)
            elif arr[bit2] == 1:
                dfs(bit1, adj, arr)
            elif not uf.connected(bit1, bit2):
                adj[bit1].append(bit2)
                adj[bit2].append(bit1)
                uf.union(bit1, bit2)
        cur_lst.append(str(i+1))
        cur_count *= 2 
        cur_count %= 10**9 + 7
     
    print(cur_count, len(cur_lst))
    print(" ".join(cur_lst))
 
# region fastio
 
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):
        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)
input = lambda: sys.stdin.readline().rstrip("\r\n")
 
# endregion
 
if __name__ == "__main__":
    main()