There are some websites that are accessible through several different addresses. For example, for a long time Codeforces was accessible with two hostnames codeforces.com and codeforces.ru.

You are given a list of page addresses being queried. For simplicity we consider all addresses to have the form http://&lt;hostname&gt;[/&lt;path&gt;], where:
 -  &lt;hostname&gt; — server name (consists of words and maybe some dots separating them), -  /&lt;path&gt; — optional part, where &lt;path&gt; consists of words separated by slashes. 
We consider two &lt;hostname&gt; to correspond to one website if for each query to the first &lt;hostname&gt; there will be exactly the same query to the second one and vice versa — for each query to the second &lt;hostname&gt; there will be the same query to the first one. Take a look at the samples for further clarifications.

Your goal is to determine the groups of server names that correspond to one website. Ignore groups consisting of the only server name.

Please note, that according to the above definition queries http://&lt;hostname&gt; and http://&lt;hostname&gt;/ are different.
The first line of the input contains a single integer *n* (1 ≤ *n* ≤ 100 000) — the number of page queries. Then follow *n* lines each containing exactly one address. Each address is of the form http://&lt;hostname&gt;[/&lt;path&gt;], where:
 -  &lt;hostname&gt; consists of lowercase English letters and dots, there are no two consecutive dots, &lt;hostname&gt; doesn't start or finish with a dot. The length of &lt;hostname&gt; is positive and doesn't exceed 20. -  &lt;path&gt; consists of lowercase English letters, dots and slashes. There are no two consecutive slashes, &lt;path&gt; doesn't start with a slash and its length doesn't exceed 20. 
Addresses are not guaranteed to be distinct.
none
10
http://abacaba.ru/test
http://abacaba.ru/
http://abacaba.com
http://abacaba.com/test
http://abacaba.de/
http://abacaba.ru/test
http://abacaba.de/test
http://abacaba.com/
http://abacaba.com/t
http://abacaba.com/test
1
http://abacaba.de http://abacaba.ru 
14
http://c
http://ccc.bbbb/aba..b
http://cba.com
http://a.c/aba..b/a
http://abc/
http://a.c/
http://ccc.bbbb
http://ab.ac.bc.aa/
http://a.a.a/
http://ccc.bbbb/
http://cba.com/
http://cba.com/aba..b
http://a.a.a/aba..b/a
http://abc/aba..b/a
2
http://cba.com http://ccc.bbbb 
http://a.a.a http://a.c http://abc 
10
http://tqr.ekdb.nh/w
http://p.ulz/ifw
http://w.gw.dw.xn/kpe
http://byt.mqii.zkv/j/xt
http://ovquj.rbgrlw/k..
http://bv.plu.e.dslg/j/xt
http://udgci.ufgi.gwbd.s/
http://l.oh.ne.o.r/.vo
http://l.oh.ne.o.r/w
http://tqr.ekdb.nh/.vo
2
http://l.oh.ne.o.r http://tqr.ekdb.nh 
http://bv.plu.e.dslg http://byt.mqii.zkv 
12
http://ickght.ck/mr
http://a.exhel/.b
http://a.exhel/
http://ti.cdm/
http://ti.cdm/x/wd/lm.h.
http://ickght.ck/a
http://ickght.ck
http://c.gcnk.d/.b
http://c.gcnk.d/x/wd/lm.h.
http://ti.cdm/.b
http://a.exhel/x/wd/lm.h.
http://c.gcnk.d/
1
http://a.exhel http://c.gcnk.d http://ti.cdm 
14
http://jr/kgb
http://ps.p.t.jeua.x.a.q.t
http://gsqqs.n/t/
http://w.afwsnuc.ff.km/cohox/u.
http://u.s.wbumkuqm/
http://u.s.wbumkuqm/cohox/u.
http://nq.dzjkjcwv.f.s/bvm/
http://zoy.shgg
http://gsqqs.n
http://u.s.wbumkuqm/b.pd.
http://w.afwsnuc.ff.km/
http://w.afwsnuc.ff.km/b.pd.
http://nq.dzjkjcwv.f.s/n
http://nq.dzjkjcwv.f.s/ldbw
2
http://ps.p.t.jeua.x.a.q.t http://zoy.shgg 
http://u.s.wbumkuqm http://w.afwsnuc.ff.km 
15
http://l.edzplwqsij.rw/
http://m.e.mehd.acsoinzm/s
http://yg.ttahn.xin.obgez/ap/
http://qqbb.pqkaqcncodxmaae
http://lzi.a.flkp.lnn.k/o/qfr.cp
http://lzi.a.flkp.lnn.k/f
http://p.ngu.gkoq/.szinwwi
http://qqbb.pqkaqcncodxmaae/od
http://qqbb.pqkaqcncodxmaae
http://wsxvmi.qpe.fihtgdvi/e./
http://p.ngu.gkoq/zfoh
http://m.e.mehd.acsoinzm/xp
http://c.gy.p.h.tkrxt.jnsjt/j
http://wsxvmi.qpe.fihtgdvi/grkag.z
http://p.ngu.gkoq/t
0
15
http://w.hhjvdn.mmu/.ca.p
http://m.p.p.lar/
http://lgmjun.r.kogpr.ijn/./t
http://bapchpl.mcw.a.lob/d/ym/./g.q
http://uxnjfnjp.kxr.ss.e.uu/jwo./hjl/
http://fd.ezw.ykbb.xhl.t/
http://i.xcb.kr/.ca.p
http://jofec.ry.fht.gt
http://qeo.gghwe.lcr/d/ym/./g.q
http://gt
http://gjvifpf.d/d/ym/./g.q
http://oba
http://rjs.qwd/v/hi
http://fgkj/
http://ivun.naumc.l/.ca.p
4
http://gt http://jofec.ry.fht.gt http://oba 
http://fd.ezw.ykbb.xhl.t http://fgkj http://m.p.p.lar 
http://i.xcb.kr http://ivun.naumc.l http://w.hhjvdn.mmu 
http://bapchpl.mcw.a.lob http://gjvifpf.d http://qeo.gghwe.lcr 
20
http://gjwr/xsoiagp/
http://gdnmu/j
http://yfygudx.e.aqa.ezh/j
http://mpjxue.cuvipq/
http://a/
http://kr/..n/c.
http://a/xsoiagp/
http://kr/z
http://kr/v.cv/rk/k
http://lvhpz
http://qv.v.jqzhq
http://y.no/
http://kr/n
http://y.no/xsoiagp/
http://kr/ebe/z/
http://olsvbxxw.win.n/j
http://p.ct/j
http://mpjxue.cuvipq/xsoiagp/
http://kr/j
http://gjwr/
3
http://lvhpz http://qv.v.jqzhq 
http://a http://gjwr http://mpjxue.cuvipq http://y.no 
http://gdnmu http://olsvbxxw.win.n http://p.ct http://yfygudx.e.aqa.ezh 
1
http://a
0
3
http://abacaba.com/test
http://abacaba.de/test
http://abacaba.de/test
1
http://abacaba.com http://abacaba.de 
import sys
input = lambda: sys.stdin.buffer.readline().decode().strip()
from math import inf, gcd, lcm, log, log2, floor, ceil, sqrt, isqrt
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from functools import lru_cache
from itertools import permutations, accumulate, groupby
from bisect import insort, bisect_left, bisect_right
import random

#template taken from https://codeforces.com/contest/1703/submission/164030692 - Author mkawa2
class DefaultDict:
    def __init__(self, default=None):
        self.default = default
        self.x = random.randrange(1, 1 << 31)
        self.dd = defaultdict(default)
    def __repr__(self):
        return "{"+", ".join(f"{k ^ self.x}: {v}" for k, v in self.dd.items())+"}"
    def __eq__(self, other):
        for k in set(self) | set(other):
            if self[k] != other[k]: return False
        return True
    def __or__(self, other):
        res = DefaultDict(self.default)
        for k, v in self.dd: res[k] = v
        for k, v in other.dd: res[k] = v
        return res
    def __len__(self):
        return len(self.dd)
    def __getitem__(self, item):
        return self.dd[item ^ self.x]
    def __setitem__(self, key, value):
        self.dd[key ^ self.x] = value
    def __delitem__(self, key):
        del self.dd[key ^ self.x]
    def __contains__(self, item):
        return item ^ self.x in self.dd
    def items(self):
        for k, v in self.dd.items(): yield (k ^ self.x, v)
    def keys(self):
        for k in self.dd: yield k ^ self.x
    def values(self):
        for v in self.dd.values(): yield v
    def __iter__(self):
        for k in self.dd: yield k ^ self.x
class CounterInt(DefaultDict):
    def __init__(self, aa=[]):
        super().__init__(int)
        for a in aa: self.dd[a ^ self.x] += 1
    def __add__(self, other):
        res = CounterInt()
        for k in set(self) | set(other):
            v = self[k]+other[k]
            if v > 0: res[k] = v
        return res
    def __sub__(self, other):
        res = CounterInt()
        for k in set(self) | set(other):
            v = self[k]-other[k]
            if v > 0: res[k] = v
        return res
    def __and__(self, other):
        res = CounterInt()
        for k in self:
            v = min(self[k], other[k])
            if v > 0: res[k] = v
        return res
    def __or__(self, other):
        res = CounterInt()
        for k in set(self) | set(other):
            v = max(self[k], other[k])
            if v > 0: res[k] = v
        return res
class Set:
    def __init__(self, aa=[]):
        self.x = random.randrange(1, 1 << 31)
        self.st = set()
        for a in aa: self.st.add(a ^ self.x)
    def __repr__(self):
        return "{"+", ".join(str(k ^ self.x) for k in self.st)+"}"
    def __len__(self):
        return len(self.st)
    def add(self, item):
        self.st.add(item ^ self.x)
    def discard(self, item):
        self.st.discard(item ^ self.x)
    def __contains__(self, item):
        return item ^ self.x in self.st
    def __iter__(self):
        for k in self.st: yield k ^ self.x
    def pop(self):
        return self.st.pop() ^ self.x
    def __or__(self, other):
        res = Set(self)
        for a in other: res.add(a)
        return res
    def __and__(self, other):
        res = Set()
        for a in self:
            if a in other: res.add(a)
        for a in other:
            if a in self: res.add(a)
        return res
    
class SortedList:
    def __init__(self, iterable=[], _load=200):
        """Initialize sorted list instance."""
        values = sorted(iterable)
        self._len = _len = len(values)
        self._load = _load
        self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
        self._list_lens = [len(_list) for _list in _lists]
        self._mins = [_list[0] for _list in _lists]
        self._fen_tree = []
        self._rebuild = True

    def _fen_build(self):
        """Build a fenwick tree instance."""
        self._fen_tree[:] = self._list_lens
        _fen_tree = self._fen_tree
        for i in range(len(_fen_tree)):
            if i | i + 1 < len(_fen_tree):
                _fen_tree[i | i + 1] += _fen_tree[i]
        self._rebuild = False

    def _fen_update(self, index, value):
        """Update `fen_tree[index] += value`."""
        if not self._rebuild:
            _fen_tree = self._fen_tree
            while index < len(_fen_tree):
                _fen_tree[index] += value
                index |= index + 1

    def _fen_query(self, end):
        """Return `sum(_fen_tree[:end])`."""
        if self._rebuild:
            self._fen_build()

        _fen_tree = self._fen_tree
        x = 0
        while end:
            x += _fen_tree[end - 1]
            end &= end - 1
        return x

    def _fen_findkth(self, k):
        """Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
        _list_lens = self._list_lens
        if k < _list_lens[0]:
            return 0, k
        if k >= self._len - _list_lens[-1]:
            return len(_list_lens) - 1, k + _list_lens[-1] - self._len
        if self._rebuild:
            self._fen_build()

        _fen_tree = self._fen_tree
        idx = -1
        for d in reversed(range(len(_fen_tree).bit_length())):
            right_idx = idx + (1 << d)
            if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
                idx = right_idx
                k -= _fen_tree[idx]
        return idx + 1, k

    def _delete(self, pos, idx):
        """Delete value at the given `(pos, idx)`."""
        _lists = self._lists
        _mins = self._mins
        _list_lens = self._list_lens

        self._len -= 1
        self._fen_update(pos, -1)
        del _lists[pos][idx]
        _list_lens[pos] -= 1

        if _list_lens[pos]:
            _mins[pos] = _lists[pos][0]
        else:
            del _lists[pos]
            del _list_lens[pos]
            del _mins[pos]
            self._rebuild = True

    def _loc_left(self, value):
        """Return an index pair that corresponds to the first position of `value` in the sorted list."""
        if not self._len:
            return 0, 0

        _lists = self._lists
        _mins = self._mins

        lo, pos = -1, len(_lists) - 1
        while lo + 1 < pos:
            mi = (lo + pos) >> 1
            if value <= _mins[mi]:
                pos = mi
            else:
                lo = mi

        if pos and value <= _lists[pos - 1][-1]:
            pos -= 1

        _list = _lists[pos]
        lo, idx = -1, len(_list)
        while lo + 1 < idx:
            mi = (lo + idx) >> 1
            if value <= _list[mi]:
                idx = mi
            else:
                lo = mi

        return pos, idx

    def _loc_right(self, value):
        """Return an index pair that corresponds to the last position of `value` in the sorted list."""
        if not self._len:
            return 0, 0

        _lists = self._lists
        _mins = self._mins

        pos, hi = 0, len(_lists)
        while pos + 1 < hi:
            mi = (pos + hi) >> 1
            if value < _mins[mi]:
                hi = mi
            else:
                pos = mi

        _list = _lists[pos]
        lo, idx = -1, len(_list)
        while lo + 1 < idx:
            mi = (lo + idx) >> 1
            if value < _list[mi]:
                idx = mi
            else:
                lo = mi

        return pos, idx

    def add(self, value):
        """Add `value` to sorted list."""
        _load = self._load
        _lists = self._lists
        _mins = self._mins
        _list_lens = self._list_lens

        self._len += 1
        if _lists:
            pos, idx = self._loc_right(value)
            self._fen_update(pos, 1)
            _list = _lists[pos]
            _list.insert(idx, value)
            _list_lens[pos] += 1
            _mins[pos] = _list[0]
            if _load + _load < len(_list):
                _lists.insert(pos + 1, _list[_load:])
                _list_lens.insert(pos + 1, len(_list) - _load)
                _mins.insert(pos + 1, _list[_load])
                _list_lens[pos] = _load
                del _list[_load:]
                self._rebuild = True
        else:
            _lists.append([value])
            _mins.append(value)
            _list_lens.append(1)
            self._rebuild = True

    def discard(self, value):
        """Remove `value` from sorted list if it is a member."""
        _lists = self._lists
        if _lists:
            pos, idx = self._loc_right(value)
            if idx and _lists[pos][idx - 1] == value:
                self._delete(pos, idx - 1)

    def remove(self, value):
        """Remove `value` from sorted list; `value` must be a member."""
        _len = self._len
        self.discard(value)
        if _len == self._len:
            raise ValueError('{0!r} not in list'.format(value))

    def pop(self, index=-1):
        """Remove and return value at `index` in sorted list."""
        pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
        value = self._lists[pos][idx]
        self._delete(pos, idx)
        return value

    def bisect_left(self, value):
        """Return the first index to insert `value` in the sorted list."""
        pos, idx = self._loc_left(value)
        return self._fen_query(pos) + idx

    def bisect_right(self, value):
        """Return the last index to insert `value` in the sorted list."""
        pos, idx = self._loc_right(value)
        return self._fen_query(pos) + idx

    def count(self, value):
        """Return number of occurrences of `value` in the sorted list."""
        return self.bisect_right(value) - self.bisect_left(value)

    def __len__(self):
        """Return the size of the sorted list."""
        return self._len

    def __getitem__(self, index):
        """Lookup value at `index` in sorted list."""
        pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
        return self._lists[pos][idx]

    def __delitem__(self, index):
        """Remove value at `index` from sorted list."""
        pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
        self._delete(pos, idx)

    def __contains__(self, value):
        """Return true if `value` is an element of the sorted list."""
        _lists = self._lists
        if _lists:
            pos, idx = self._loc_left(value)
            return idx < len(_lists[pos]) and _lists[pos][idx] == value
        return False

    def __iter__(self):
        """Return an iterator over the sorted list."""
        return (value for _list in self._lists for value in _list)

    def __reversed__(self):
        """Return a reverse iterator over the sorted list."""
        return (value for _list in reversed(self._lists) for value in reversed(_list))

    def __repr__(self):
        """Return string representation of sorted list."""
        return 'SortedList({0})'.format(list(self))
 
#https://leetcode.com/problems/create-sorted-array-through-instructions/discuss/1245397/C%2B%2BJavaPython-Binary-Indexed-Tree-Feel-free-to-reuse   
class BIT:
    def __init__(self, size):
        self.bit = [0] * (size + 1)

    def getSum(self, idx):  # Get sum in range [0..idx], 1-based indexing
        s = 0
        while idx > 0:
            s += self.bit[idx]
            idx -= idx & (-idx)
        return s

    def getSumRange(self, left, right):  # left, right inclusive, 1-based indexing
        return self.getSum(right) - self.getSum(left - 1)

    def addValue(self, idx, val):  # 1-based indexing
        while idx < len(self.bit):
            self.bit[idx] += val
            idx += idx & (-idx)
            
class TrieNode:
    def __init__(self):
        self.children = defaultdict(TrieNode)
        self.word = None

    def addWord(self, word):
        cur = self
        for c in word:
            cur = cur.children[c]
        cur.word = "*"

class UnionFind:
    def __init__(self, n):
        self.parent = list(range(n))
        self.size = [1] * n
        self.num_sets = n

    def find(self, a):
        acopy = a
        while a != self.parent[a]:
            a = self.parent[a]
        while acopy != a:
            self.parent[acopy], acopy = a, self.parent[acopy]
        return a

    def union(self, a, b):
        a, b = self.find(a), self.find(b)
        if a != b:
            if self.size[a] < self.size[b]:
                a, b = b, a

            self.num_sets -= 1
            self.parent[b] = a
            self.size[a] += self.size[b]

    def set_size(self, a):
        return self.size[self.find(a)]

    def __len__(self):
        return self.num_sets
    
class LazySegmentTree:
    def __init__(self, data, default=0, func=max):
        """initialize the lazy segment tree with data"""
        self._default = default
        self._func = func

        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()
        self._lazy = [0] * (4 * _size)

        self.data = [default] * (4 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __len__(self):
        return self._len

    def _push(self, idx):
        """push query on idx to its children"""
        # Let the children know of the queries
        q, self._lazy[idx] = self._lazy[idx], 0

        self._lazy[2 * idx] += q
        self._lazy[2 * idx + 1] += q
        self.data[2 * idx] += q
        self.data[2 * idx + 1] += q

    def _update(self, idx):
        """updates the node idx to know of all queries applied to it via its ancestors"""
        for i in reversed(range(1, idx.bit_length())):
            self._push(idx >> i)

    def _build(self, idx):
        """make the changes to idx be known to its ancestors"""
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1]) + self._lazy[idx]
            idx >>= 1

    def add(self, start, stop, value):
        """lazily add value to [start, stop)"""
        start = start_copy = start + self._size
        stop = stop_copy = stop + self._size
        while start < stop:
            if start & 1:
                self._lazy[start] += value
                self.data[start] += value
                start += 1
            if stop & 1:
                stop -= 1
                self._lazy[stop] += value
                self.data[stop] += value
            start >>= 1
            stop >>= 1

        # Tell all nodes above of the updated area of the updates
        self._build(start_copy)
        self._build(stop_copy - 1)

    def query(self, start, stop, default=0):
        """func of data[start, stop)"""
        start += self._size
        stop += self._size

        # Apply all the lazily stored queries
        self._update(start)
        self._update(stop - 1)

        res = default
        while start < stop:
            if start & 1:
                res = self._func(res, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res = self._func(res, self.data[stop])
            start >>= 1
            stop >>= 1
        return res

    def __repr__(self):
        return "LazySegmentTree({0})".format(self.data)
    
#Author: beethoven97
def sieve(n):
    prim = [False] * (n + 1)
    ret = []
    for i in range(2, n + 1):
        if not prim[i]:
            ret.append(i)
            for j in range(i, n + 1, i):
                prim[j] = 1
 
    return ret

# find smallest prime factor for all numbers <= n
class Prime:
    
    def __init__(self,n):
        self.n = n
        self.smallest_prime = [0]*(self.n+5)

        for i in range(2, self.n + 1):
            if not self.smallest_prime[i]:
                for j in range(i, self.n + 1, i):
                    self.smallest_prime[j] = i
                    
    def factorise(self,num):
        
        ans = []
        while self.smallest_prime[num] != 0:
            k = self.smallest_prime[num]
            ans.append(k)
            while num % k == 0:
                num //= k
                
        return ans
    

# Function to find the value of
# P * Q^-1 mod 998244353 (G4G)
def mod_inverse(p, q, mod):
    
    expo = 0
    expo = mod - 2
 
    # Loop to find the value
    # until the expo is not zero
    while (expo):
 
        # Multiply p with q
        # if expo is odd
        if (expo & 1):
            p = (p * q) % mod
        q = (q * q) % mod
 
        # Reduce the value of
        # expo by 2
        expo >>= 1
 
    return p

#PyRival
def bootstrap(f, stack=[]):
    def wrappedfunc(*args, **kwargs):
        if stack:
            return f(*args, **kwargs)
        to = f(*args, **kwargs)
        while True:
            if type(to) is GeneratorType:
                stack.append(to)
                to = next(to)
            else:
                stack.pop()
                if not stack:
                    break
                to = stack[-1].send(to)
        return to

    return wrappedfunc

#Author: huikang
def remove_consecutive_duplicates(lst):
    res = []
    for x in lst:
        if res and x == res[-1]:
            continue
        res.append(x)
    return res

# nmax = (2*(10**3))+2
 
# fact = [1] * (nmax+1)
# for i in range(2, nmax+1):
#     fact[i] = fact[i-1] * i % MOD
    
# inv = [1] * (nmax+1)
# for i in range(2, nmax+1):
#     inv[i] = pow(fact[i], MOD-2, MOD)
 
 
# def C(n, m):
#     return fact[n] * inv[m] % MOD * inv[n-m] % MOD if 0 <= m <= n else 0

def sumtoN(n):
    return ((n)*(n+1)) // 2

def powerOf2(n):
    return n > 0 and n & (n-1) == 0

def query(a,b):
    print("? {} {}".format(a,b), flush=True)
    response = int(input())
    return response
 
def alert(num):
    print("! {}".format(num), flush=True)

# d4 = [(0, 1), (-1, 0), (0, -1), (1, 0)]
# d8 = [(0, 1), (-1, 0), (0, -1), (1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]
#mod = 1000000007

'''
Key formulas:
1 XOR n = n-1 when n is odd
1 XOR n = n+1 when n is even
a|b = a + b - a & b
XOR and AND is commutative
When gcd appears also consider lcm
lowest_ind = graph.index(min(graph, key = len)) #doesnt give the index with minimum length
ceiling more feasible to take (val+1)//2 instead of ceil(val/2)
'''



def read_int(): return(int(input()))
def read_ints(): return(map(int,input().split()))
def read_list(): return(list(map(int,input().split())))
def read_matrix(m,n):
    ans = []
    for _ in range(m):
        ans.append(read_list())
    return ans

#for Counter on integers use CounterInt, else use Counter
def solve(websites):
    
    paths = defaultdict(set)
    for x in websites:
        splits = x.split("/")
        host = "/".join(splits[:3])
        if len(splits) > 3 and splits[3] == "":
            splits[3] = "1"
        path = "/".join(splits[3:])
        paths[host].add(path)
    
    rev_paths = defaultdict(list)
    for k,v in paths.items():
        rev_paths[tuple(sorted(v))].append(k)
        
    groups = []
    for x in rev_paths:
        if len(rev_paths[x]) > 1:
            groups.append(rev_paths[x])
            
    print(len(groups))
    for x in groups:
        print(*x)
       
 
n = read_int()
#n,k = read_ints()
#arr = input()
websites = []
for _ in range(n):
    websites.append(input())
solve(websites)
#if solve(n,arr):
#    print("YES")
#else:
#    print("NO")
    