Problem:
 Score : 300 points    Problem Statement You drew lottery N times. In the i -th draw, you got an item of the kind represented by a string S_i .  How many kinds of items did you get?      Constraints  1 \leq N \leq 2\times 10^5  S_i consists of lowercase English letters and has a length between 1 and 10 (inclusive).         Input Input is given from Standard Input in the following format:  N  S_1  :  S_N       Output Print the number of kinds of items you got.        Sample Input 1 3
apple
orange
apple      Sample Output 1 2  You got two kinds of items: apple and orange .       Sample Input 2 5
grape
grape
grape
grape
grape      Sample Output 2 1       Sample Input 3 4
aaaa
a
aaa
aa      Sample Output 3 4

Solution (Python):

MOD = 10 ** 9 + 7

def main():
    for _ in inputt(1):
        n, = inputi()
        S = inputl(n, input)
        print(len(set(S)))







from math import *
from heapq import *
from itertools import *
from functools import reduce, lru_cache, partial
from collections import Counter, defaultdict
import re, copy, operator, cmath
import sys, io, os, builtins
sys.setrecursionlimit(1000)





BUFSIZE = 8192
class FastIO(io.IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = io.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(io.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")
def print(*args, **kwargs):
    if args:
        sys.stdout.write(str(args[0]))
        split = kwargs.pop("split", " ")
        for arg in args[1:]:
            sys.stdout.write(split)
            sys.stdout.write(str(arg))
    sys.stdout.write(kwargs.pop("end", "\n"))
def debug(*args, **kwargs):
    print("debug", *args, **kwargs)
    sys.stdout.flush()
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip()
inputt = lambda t = 0: range(t) if t else range(int(input()))
inputs = lambda: input().split()
inputi = lambda: map(int, inputs())
inputl = lambda t = 0, k = lambda: list(inputi()): [k() for _ in range(t)] if t else list(k())





def len(a):
    if isinstance(a, range):
        return -((a.start - a.stop) // a.step)
    return builtins.len(a)
def bisect_left(a, x, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    if key == None: key = do_nothing
    while lo < hi:
        mid = (lo + hi) // 2
        if key(a[mid]) < x: lo = mid + 1
        else: hi = mid
    return lo
def bisect_right(a, x, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    if key == None: key = do_nothing
    while lo < hi:
        mid = (lo + hi) // 2
        if x < key(a[mid]): hi = mid
        else: lo = mid + 1
    return lo
def insort_left(a, x, key = None, lo = 0, hi = None):
    lo = bisect_left(a, x, key, lo, hi)
    a.insert(lo, x)
def insort_right(a, x, key = None, lo = 0, hi = None):
    lo = bisect_right(a, x, key, lo, hi)
    a.insert(lo, x)
do_nothing = lambda x: x
bisect = bisect_right
insort = insort_right
def index(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    if key == None: key = do_nothing
    i = bisect_left(a, x, key, lo, hi)
    if lo <= i < hi and key(a[i]) == x: return a[i]
    if default != None: return default
    raise ValueError
def find_lt(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_left(a, x, key, lo, hi)
    if lo < i <= hi: return a[i - 1]
    if default != None: return default
    raise ValueError
def find_le(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_right(a, x, key, lo, hi)
    if lo < i <= hi: return a[i - 1]
    if default != None: return default
    raise ValueError
def find_gt(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_right(a, x, key, lo, hi)
    if lo <= i < hi: return a[i]
    if default != None: return default
    raise ValueError
def find_ge(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_left(a, x, key, lo, hi)
    if lo <= i < hi: return a[i]
    if default != None: return default
    raise ValueError






class Tree:
    def __init__(n):
        self._n = n
        self._conn = [[] for _ in range(n)]
        self._list = [0] * n
    def connect(a, b):
        pass






class Sieve:
    def __init__(self):
        self._n = 6
        self._list = [2, 3, 5, 7, 11, 13]
    def extend(self, n):
        pass


sieve = Sieve()
def isprime(n):
    pass
def prime(n):
    pass
def factorint(n):
    factordict = defaultdict(int)
    for i in sieve:
        if n <= i * i:
            break
        while not n % i:
            factordict[i] += 1
            n //= i
    if n != 1:
        factordict[n] += 1
    return factordict





if __name__ == "__main__":
    main()

Solution (Python):
n = int(input())


s = [input() for _ in range(n)]
print(len(set(s)))

Solution (Python):
import sys
si = sys.stdin.readline


def main():
    n = int(si())
    strSet = set()
    for _ in range(n):
        s = si()[:-1]
        if s not in strSet:
            strSet.add(s)
    print(len(strSet))


if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())
s = []
for _ in range(N):
  s.append(input())
print(len(set(s)))

Solution (Python):
N = int(input())

S = set()
for i in range(N):
    item = input()
    if item not in S:
        S.add(item)

print(len(list(S)))

Solution (Python):
n=int(input())
l=[]
for i in range(n):
    l.append(input())

l.sort()
cnt=1
for i in range(1,n):
    if l[i] != l[i-1]:
        cnt += 1

print(cnt)

Solution (Python):
N = int(input())
ab = [input() for i in range(N)]

abset = set(ab)
print(len(abset))

Solution (Python):
def main():
    n = int(input())
    S = [input() for e in range(n)]

    A = set(S)
    print(len(A))


if __name__ == '__main__':
    main()

Solution (Python):
t=int(input())
l=[]
for k in range(t):
    s=str(input())
    l.append(s)
l= list(dict.fromkeys(l))
print(len(l))

Solution (Python):
N = int(input())
lis = []
for i in range(N):
    s = input()
    lis.append(s)
lis = set(lis)
print(len(lis))

Solution (Python):
n= int(input())

s = set([])

for i in range(n):
    tmp = input()
    if tmp not in s:
        s.add(tmp)

print(len(s))

Solution (Python):
from collections import defaultdict
d = defaultdict(int)
s=[]
n=int(input())
for _ in range(n):
    s.append(input())
for i in range(n):
    d[s[i]]+=1
print(len(d))

Solution (Python):
H = int(input())
S = [input() for _ in range(H)]

S_ = set(S)
print(len(S_))

Solution (Python):
import sys
import math
def i():return int(sys.stdin.readline().replace("\n",""))
def i2():return map(int,sys.stdin.readline().replace("\n","").split())
def s():return str(sys.stdin.readline().replace("\n",""))
def l():return list(sys.stdin.readline().replace("\n",""))
def intl():return [str(k) for k in sys.stdin.readline().replace("\n","").split()]
def lx(k):return list(map(lambda x:int(x)*-k,sys.stdin.readline().replace("\n","").split()))
def t():return tuple(map(int,sys.stdin.readline().replace("\n","").split()))
n = i()
l = []
for i in range(n):
    k = input()
    l.append(k)
print(len(list(set(l))))

Solution (Python):
import sys
input = sys.stdin.readline

def main():
    n = int(input())

    s_li = []

    for i in range(n):
        s_i = input()
        s_li.append(s_i)

    print(len(set(s_li)))


if __name__ == '__main__':
    main()

Solution (Python):
import collections
n = int(input())
lst = [input() for i in range(n)]
print(len(collections.Counter(lst)))

Solution (Python):
n  = int(input())
print(len(set([input() for _ in range(n)])))

Solution (Python):
from sys import stdin

def main():
	inp=stdin.readline
	n=int(inp())
	s=set()
	for i in range(n):
		k=inp().strip()
		s.add(k)
	print(len(s))

main()

Solution (Python):
from collections import Counter

n = int(input())
s = [input() for i in range(n)]
c = Counter(s)
print(len(c))

Solution (Python):
from collections import Counter
N = int(input())

data = [0] * N
for i in range(N):
    data[i] = input()

d0 = Counter(data)
d1 = d0.most_common()
d2 = len(d1)
print(d2)

Solution (Python):
n=int(input())

keihin=[]

for i in range(n):
    keihin.append(input())

keihin.sort()


ans=n

for i in range(1,n):
    if(keihin[i]==keihin[i-1]):
        ans-=1

print(ans)

Solution (Python):
n=int(input())
l=[input() for i in range(n)]
print(len(set(l)))

Solution (Python):
N = int(input())

dict = {}
for i in range(N):
	item = input()
	if item in dict.keys():
		dict[item] += 1
	else:
		dict[item] = 1

print(len(dict))

Solution (Python):
n=int(input())
lis=[input() for i in range(n)]
print(len(set(lis)))

Solution (Python):
import sys
from collections import deque

n=int(input())
p=[input() for _ in range(n)]
P=set(p)

print(len(P))

Solution (Python):
N=int(input())
S=[input() for i in range(N)]
S=list(set(S))
print(len(S))

Solution (Python):
n=int(input())
s=[]
for i in range(n):
    s.append(input())
print(len(set(s)))

Solution (Python):
n = int(input())
di = {}
for i in range(n):
    s = input()
    if s in di:
        pass
    else:
        di[s] = 1

print(len(di))

Solution (Python):
n = int(input())
dic={}
for i in range(n):
  s = input()
  dic[s]=True
print(len(dic.keys()))

Solution (Python):
def main():
    N = int(input())
    S = {}
    for i in range(N):
        s = input()
        if s not in S:
            S.update({s:0})
    print(len(S))

if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())
A = set(input() for i in range (N))
print(len(A))

Solution (Python):
n=int(input())
s=[input() for _ in range(n)]
print(len(set(s)))

Solution (Python):
N=int(input())
S=list(set(input() for i in range(N)))
print(len(S))

Solution (Python):
def main():
    loop = int(input())
    s = set()
    for i in range(0, loop):
        s.add(input())
    print(len(s))




if __name__ == '__main__':
    main()

Solution (Python):
N=int(input())
S=set(list(input() for i in range(N)))

print(len(S))

Solution (Python):



import sys
input = sys.stdin.readline

def main():
    N = int(input())
    a = set([])
    for i in range(N):
        a.add(input())
    print(len(a))


if __name__ == '__main__':
    main()

Solution (Python):
N=int(input())
S=[]
for i in range(N):
    S.append(input())
print(len(set(S)))

Solution (Python):
n = int(input())
print(len(set([input() for _ in range(n)])))

Solution (Python):
import sys

n = int(sys.stdin.readline())
s_list = []
for i in range(n):
    s_list.append(sys.stdin.readline())

s = set(s_list)
print(len(list(s)))

Solution (Python):
n=int(input())
s=[]
for _ in range(n):
    s.append(input())
s=set(s)
print(len(s))

Solution (Python):
n=int(input())
s=[]
for i in range(n):
    s.append(input())
print(len(set(s)))

Solution (Python):
n = int(input())
s_list = list()
for _ in range(n):
    s_list.append(input())
s_set = set(s_list)
print(len(s_set))

Solution (Python):
import collections
n=int(input())
l=[input() for i in range(n)]
c=collections.Counter(l)
print(len(c))

Solution (Python):
from sys import stdin


def run():
    n = int(stdin.readline().rstrip())
    data = [stdin.readline().rstrip() for _ in range(n)]

    print(len(set(data)))


if __name__ == '__main__':
    run()

Solution (Python):
N=int(input())
l=[input() for i in range(N)]
k=sorted(l)
cnt=1

for i in range(N-1):
    if k[i]!=k[i+1]:
        cnt+=1

print(cnt)

Solution (Python):
n = int(input())
data = set([input() for _ in range(n)])
print(len(data))

Solution (Python):
n = int(input())
s = set()
for _ in range(n):
    s.add(input())
print(len(s))

Solution (Python):
n = int(input())
s = [str(input()) for _ in range(n)]
print(len(set(s)))

Solution (Python):
n=int(input())
items=[]
for i in range(n):
  items.append(input())
print(len(set(items)))

Solution (Python):
N = int(input())
S = []
for i in range(N):
  S.append(input())

print(len(set(S)))

Solution (Python):
N=int(input())
S=set([input() for _ in range(N)])
print(len(S))

Solution (Python):
n = int(input())
s = [input() for i in range(n)]

print(len(set(s)))

Solution (Python):
n=int(input())
s=set()
for i in range(n):
  s.add(input())
print(len(s))

Solution (Python):

n = int(input())
kuji = []
for i in range(n):
    s = input()
    kuji.append(s)

print(len(set(kuji)))

Solution (Python):
N = int(input())

li = list()

for i in range(N):
    li.append(input())

set(li)

print(len(set(li)))

Solution (Python):
N = int(input())

W = []
for i in range(N):
  w = input()
  W.append(w)

Ws = set(W)
print(len(Ws))

Solution (Python):
N = int(input())

S_list = []
for i in range(N):
  S_list.append(input())
print(len(set(S_list)))

Solution (Python):
import sys
input = sys.stdin.readline
dic={}
N=int(input())
a=0
for i in [0]*(N):
 b=input()
 if b in dic:
  continue
 else:
  a+=1
  dic[b]=1
print(a)

Solution (Python):

N = int(input())
S = [str(input()) for s in range(N)]
print(len(set(S)))

Solution (Python):
N = int(input())
s_set = set()
for i in range(N):
    s_set.add(input())
print(len(s_set))

Solution (Python):
import collections

n = int(input())
S = []
for i in range(n):
    s=input()
    S.append(s)

c=collections.Counter(S)

print(len(c))

Solution (Python):
s=set()
n=int(input())
for i in range(n):
    s.add(input())
print(len(s))

Solution (Python):



n = int(input())
s = []
for i in range(n):
    tmp = input()
    s.append(tmp)


d = {}
for i in s:
    d[i] = True

print(len(d.keys()))

Solution (Python):
import collections

n = int(input())
s = []
for i in range(n):
    s.append(input())
c = collections.Counter(s)

print(len(c))

Solution (Python):
n = int(input())
set_ = set()
for i in range(n):
    set_.add(input())
print(len(set_))

Solution (Python):
if __name__ == "__main__":
    a = dict()
    for _ in range(int(input())):
        a[str(input())] = 1
    print(a.__len__())

Solution (Python):
N = int(input())
Sn = [str(input()) for s in range(N)]
print(len(set(Sn)))

Solution (Python):



import sys


def input():
    return sys.stdin.readline()


def resolve():
    n = int(input())
    s_list = []
    for _ in range(n):
        s_list.append(input().rstrip())

    s_set = set(s_list)

    print(len(s_set))


if __name__ == "__main__":
    resolve()

Solution (Python):
N = int(input())

S = []
for i in range(N):
    S.append(input())

print(len(set(S)))

Solution (Python):
n = int(input())
s = []
for _ in range(n):
    s.append(input())

s_set = set(s)
print(len(s_set))

Solution (Python):
N = int(input())
S = [input() for i in range(N)]
ans = set(S)
print(len(ans))

Solution (Python):
a = int(input())

d={}
r=0
for _ in range(a):
    b= input()
    if d.get(b): continue
    else: d[b]= True; r+=1

print(r)

Solution (Python):
N = int(input())

l = {}

for _ in range(N):
  key = input()
  l[key] = l.get(key, 0)
  
print(len(l))

Solution (Python):
N = int(input())
S = [input() for _ in range(N)]
print(len(set(S)))

Solution (Python):
import collections
N=int(input())
L=[input() for i in range(N)] 
C = collections.Counter(L)
D = list(C.values())
print(len(D))

Solution (Python):
def main():
    n = int(input())
    s = [input() for _ in range(n)]
    kind = set(s)
    print(len(kind))

if __name__ == "__main__":
    main()

Solution (Python):
ans=[]
for _ in range(int(input())):
  s=input()
  ans.append(s)
print(len(set(ans)))

Solution (Python):
N = int(input())
S = [input() for _ in range(N)]
print(len(set(S)))

Solution (Python):



def solve(*args: str) -> str:
    n = int(args[0])
    S = set(args[1:])

    return str(len(S))


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

Solution (Python):
n = int(input())

l = {}

for _ in range(n):
  s = input()
  l[s] = l.get(s, 0)

print(len(l))

Solution (Python):
n=int(input())
x=[]
y=[]
for i in range(n):
    g=input()
    x.append(g)
y=set(x)
print(len(y))

Solution (Python):
n = int(input())
s = list(input() for _ in range(n))
print(len(set(s)))

Solution (Python):
def main():
  n = int(input())
  s = []
  
  for _ in range(n):
    s.append(input())
  
  print(len(set(s)))

main()

Solution (Python):



N = int(input())

s = set()

for i in range(N):
    s.add(input())

print(len(s))

Solution (Python):
n=int(input())
s={input() for _ in range(n)}
print(len(s))

Solution (Python):
n=int(input())
b={}
for i in range(n):
    a=input()
    b[a]=1
print(len(b))

Solution (Python):

import sys

input = sys.stdin.buffer.readline


n = int(input())

s = set()

for _ in range(n):

    st = input()

    s.add(st)

print (len(s))

Solution (Python):
n = int(input())
ans = []
for i in range(n):
  ans.append(str(input()))
print(len(set(ans)))

Solution (Python):
N = int(input())
keihin = []

for _ in range(N):
    keihin.append(input())

print(len(set(keihin)))

Solution (Python):
n = int(input())
arr = []
  
for i in range(n):
  s = input()
  arr.append(s)

print(len(set(arr)))

Solution (Python):
n = int(input())
lst = {}
ans = 0
for i in range(n):
    s = input()
    if not(s in lst.keys()):
        lst[s] = 1
        ans += 1
print(ans)

Solution (Python):
import sys
from math import sqrt
from collections import Counter, defaultdict, deque

input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)


def I():
    return int(input())


def MI():
    return map(int, input().split())


def LI():
    return list(MI())


def LIN(n: int):
    return [I() for _ in range(n)]


inf = float("inf")
mod = 10 ** 9 + 7


def main():
    n = I()
    sl = [input().rstrip() for _ in range(n)]

    print(len(set(sl)))


if __name__ == "__main__":
    main()

Solution (Python):
import sys

def main():
    input=sys.stdin.readline
    N=int(input())

    d = {}
    cnt=0

    for i in range(N):
        key=input()
        if key not in d:
            cnt+=1
            d[key] = 0

    print(cnt)

if __name__ =='__main__': 
    main()

Solution (Python):
n=int(input())
s=['']*n
for i in range(n):
	s[i]=input()
print(len(set(s)))

Solution (Python):
import collections
num = int(input())
list = []
for x in range(num):
    list.append(input())
c = collections.Counter(list)
print(len(c))

Solution (Python):
n = int(input())
p = {input() for i in range(n)}
print(len(p))

Solution (Python):
n = int(input())

items = []

for i in range(n):
  items.append(input())

print(len(set(items)))

Solution (Python):
N=int(input())
word_set=set()
for i in range(N):
    S=str(input())
    word_set.add(S)
print(len(word_set))

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()

def main():
  N = int(input())

  a = set([])
  for i in range(N):
    a.add(input())
  print(len(a))

if __name__ == '__main__':
  main()

Solution (Python):
n = int(input())
s = set()
for i in range(n):
    s.add(input())

print(len(s))

Solution (Python):
n = int(input())

list = list()
for i in range(n):
    s = input()
    list.append(s)

set = set(list)

print(len(set))

Solution (Python):
N = int(input())
S = []
for i in range(N):
    S.append(input())

print(len(set(S)))

Solution (Python):
N = int(input())
s = set()
for i in range(N):
    s.add(input())
print(len(s))

Solution (Python):
n=int(input())
S=[input() for i in range(n)]
print(len(set(S)))

Solution (Python):
n = int(input())
s = []
for i in range(n):
    s.append(input())
print(len(set(s)))

Solution (Python):
n,*s = open(0).read().split()
print(len(set(s)))

Solution (Python):
import numpy as np
num = int(input())

str_list =[]
for _ in range(num):
  str_list.append(input())
  
print(len(np.unique(str_list)))

Solution (Python):
import collections
N = int(input())
S = [input() for i in range(N)]
c = collections.Counter(S)

print(len(c))

Solution (Python):
n = int(input())
a = [input() for _ in range(n)]

a.sort()
cnt = 1
for i in range(1, n):
  if a[i-1] != a[i]:
    cnt += 1
print(cnt)

Solution (Python):
n=int(input())
s=[]
for i in range(n):
    S=input()
    s.append(S)
s2=set(s)
print(len(s2))

Solution (Python):


def main():

    n = int(input())
    l = []
    for i in range(n):
        l.append(input())
    
    
    print(len(list(set(l))))

if __name__ == '__main__':
    main()

Solution (Python):
from collections import Counter

n = int(input())

tmp = []
for i in range(n):
    s = str(input())
    tmp.append(s)

c = list(Counter(tmp).values())

print(len(c))

Solution (Python):
import collections

N = int(input())
Sn = [input().rstrip() for _ in range(N)] 
c = collections.Counter(Sn)
ans = 0
for cc in c:
  ans += 1
print(ans)

Solution (Python):
import collections
N = int(input())
s = [input() for i in range(N)]
c = collections.Counter(s)
print(len(c))

Solution (Python):
from collections import Counter
N = int(input())
S = [None for _ in range(N)]
for i in range(N):
  S[i] = input()
count = Counter(S)
print(len(count))

Solution (Python):
n = int(input())
sss = [input() for _ in range(n)]
sss = list(set(sss))
print(len(sss))

Solution (Python):
N = int(input())
fruits = [input() for i in range(N)]
print(len(set(fruits)))

Solution (Python):
n = int(input())

d = {}

for i in range(n):
    s = input()
    d[s] = 1

cnt = 0

for key, value in d.items():
    cnt += 1

print(cnt)

Solution (Python):
n = int(input())
s = [input() for _ in range(n)]

print(len(set(s)))

Solution (Python):
n = int(input())
s = set()
for i in range(n):
    s.add(input())

print(len(s))

Solution (Python):


def main():
    n = int(input())
    S = []

    for _ in range(n):
        s = input()
        S.append(s)
    
    print(len(set(S)))

if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
s = set()
for _ in range(n):
    s.add(input())
print(len(s))

Solution (Python):
N = int(input())

a = [input() for _ in range(N)]

print(len(set(a)))

Solution (Python):
a=int(input())
b=['']*a
for i in range(a):
    b[i]=input()
print(len(set(b)))

Solution (Python):
n = int(input())

slist = []
for _ in range(n):
    s = input()
    slist.append(s)

print(len(set(slist)))

Solution (Python):
N = int(input())
S = []
for i in range(N):
    S.append(input())
print(len(set(S)))

Solution (Python):

N = int(input())
S = []
for _ in range(N):
    S.append(str(input()))

print(len(list(set(S))))

Solution (Python):
N = int(input())
dict_lotte = {}
for _ in range(N):
    s = input()
    dict_lotte[s] = True

print(len(dict_lotte.keys()))

Solution (Python):
N = int(input())
S = []
for i in range(N):
    S.append(input())
ans = len(list(set(S)))
print(ans)

Solution (Python):
import sys
import decimal
input=sys.stdin.readline
n=int(input())
se=set()
ans=0
for i in range(n):
    s=input()
    if s not in se:
        ans+=1
        se.add(s)
print(ans)

Solution (Python):
N = int(input())
S = [0 for i in range(N)] 
for _ in range(N):
    S[_] = input()

print(len(set(S)))

Solution (Python):
N=int(input())
line=[input() for i in range(N)]

print(len(list(set(line))))

Solution (Python):
n = int(input())
s = [input() for i in range(n)]
print(len(set(s)))

Solution (Python):
N=int(input())
S=[]
for i in range(N):
  S.append(input())
d=set(S)

print(len(d))

Solution (Python):
n = int(input())

s = [input() for i in range(n)]

print(len(set(s)))

Solution (Python):
from collections import Counter

N = int(input())
S = Counter([input() for _ in range(N)])
print(len(S.keys()))

Solution (Python):
t=int(input())
s=set()
for _ in range(t):
     s.add(input())
print(len(s))

Solution (Python):
n = int(input())
items = set([input() for i in range(n)])
print(len(items))

Solution (Python):
n = int(input())
d = {}
for i in range(n):
	inp = input()
	d[inp] = 1
print(len(d.keys()))

Solution (Python):
import math, sys
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from copy import deepcopy
from functools import lru_cache
from heapq import heapify, heappop, heappush
from itertools import accumulate, combinations, permutations
input = sys.stdin.readline
mod = 10**9 + 7
ns = lambda: input().strip()
ni = lambda: int(input().strip())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))

def main():
    n = ni()
    s = (ns() for _ in range(n))

    ans = len(set(s))
    
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
import sys

ma = lambda : map(int,input().split())
ni = lambda : int(input())
import collections
co = collections.Counter()
n= ni()
for i in range(n):
    s = input()
    co[s] +=1
ans = 0
for i,w in co.items():
    ans +=1
print(ans)

Solution (Python):
N = int(input())
S = [input() for _ in range(N)]
print(len(set(S)))

Solution (Python):
N = int(input())
S = [input() for i in range(N)]
print(len(set(S)))

Solution (Python):
import collections

N = int(input())
memory = []
counter = 0

for i in range(N):
    tmp = input()
    memory.append(tmp)

c = collections.Counter(memory)

print(len(c))

Solution (Python):
N = int(input())
gacha = {}
for i in range(N):
  s = input()
  if not s in gacha:
    gacha[s] = 1

print(sum(gacha.values()))

Solution (Python):
import collections

n = int(input())
s = [input() for i in range(n)]

c = collections.Counter(s)
print(len(c.keys()))

Solution (Python):
def main():
	s = int(input())
	l = [str(input()) for i in range(s)]
	print(len(set(l)))

	

if __name__ == '__main__':
	main()

Solution (Python):
N = int(input())

list1 = set([])
for i in range(N):
    list1.add(input())
print(len(list1))

Solution (Python):
n = int(input())
d = {}
c=0
for i in range(n):
    a = input()
    try:
        d[a]+=1
    except KeyError:
        c+=1
        d[a]=1
print(c)

Solution (Python):
import collections

N = int(input())
S = [input() for i in range(N)]

c = collections.Counter(S)

print(len(c))

Solution (Python):
n = int(input())
s = [input() for _ in range(n)]

dic = {}
for i in range(n):
    dic[s[i]] = 0

print(len(dic.keys()))

Solution (Python):
N = int(input())
C = {}
for _ in range(N):
    s = input().strip()
    if s not in C:
        C[s] = 0
    C[s] += 1
print(len(C))

Solution (Python):


n = int(input())
s = set(input() for i in range(n))
print(len(s))

Solution (Python):
import collections

N = int(input())
S=[input() for i in range(N)]
c = collections.Counter(S)
print(len(c))

Solution (Python):
N = int(input())
d = {}
ans = 0
for i in range(N):
    S = input()
    if S in d:
        continue
    d[S] = 1
    ans += 1
print(ans)

Solution (Python):
N = int(input())
goods = set()
ans = 0
for _ in range(N):
    good = input()
    if good not in goods:
        goods.add(good)
        ans += 1
print(ans)

Solution (Python):
N = int(input())

prise = {}
for i in range(N):
    S = input()
    prise[S] = 1

print(len(prise))

Solution (Python):
from collections import defaultdict
n = int(input())
dic = defaultdict(int)
for _ in range(n):
  x = input()
  dic[x] += 1
print(len(dic))

Solution (Python):
n = int(input())
li = []
for i in range(n):
  li.append(input())
li_1 = list(sorted(li))
a = n
for i in range(n-1):
  if li_1[i] == li_1[i+1]:
    a -= 1
print(a)

Solution (Python):
N = int(input())
arr = []

for i in range(N):
  S = input()
  arr.append(S)
    
arr.sort()
cnt = 1
for i in range(N-1):
  a = arr[i]
  b = arr[i+1]
  if a != b:
    cnt += 1

print(int(cnt))

Solution (Python):
n = int(input())
s = []
for i in range(n):
    s.append(input())
set_s = set(s)
print(len(set_s))

Solution (Python):
from collections import Counter
n = int(input())
s = [input() for i in range(n)]
scount = Counter(s)
print(len(list(scount.keys())))

Solution (Python):
N = int(input())
S = set()
for i in range(N):
    S.add(input())
print(len(S))

Solution (Python):
N = int(input())
D = [input() for j in range(N)]
S = list(set(D))
print(len(S))

Solution (Python):
N=int(input())
s=set([])
for i in range(N):
  x=input()
  s.add(x)
print(len(s))

Solution (Python):
import collections
a = int(input())
b = []
for i in range(a):
    b.append(input())
print(len(collections.Counter(b)))

Solution (Python):
N=int(input())
dic={}
for i in range(N):
    st=input()
    if st in dic:
        dic[st]+=1
    else:
        dic[st]=1
print(len(dic))

Solution (Python):
import collections

N = int(input())
K = []
for i in range(N):
    S = input()
    K.append(S)
    i = i + 1
    
A = collections.Counter(K)

print(len(A))

Solution (Python):
N = int(input())
items = []
for i in range(N):
    items.append(input())
item_set = set(items)
print(len(item_set))

Solution (Python):
N = int(input())
S = set()
for i in range(N):
    S.add(input())
print(len(S))

Solution (Python):

N=int(input())


l=[]
for k in range(N):
    s=input()
    l.append(s)

print(len(set(l)))

Solution (Python):
n = int(input())
itm = []
for _ in range(n):
    itm.append(input())
print(len(set(itm)))

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
from itertools import permutations,  combinations, accumulate
from functools import *
from collections import deque, defaultdict, Counter
from heapq import heapify, heappop, heappush, heappushpop

INF = float('inf')
NIL = - 1

""" Input
S = input().rstrip()
N, A, B = map(int, input().split())
A = list(map(int, input().split()))
A = np.array(input().split(), dtype=np.float64)
D = [int(input()) for _ in range(N)]
AB = [[int(x) for x in input().split()] for _ in range(N)]
PX = [[int(x) for x in input().split()] for _ in range(Q)]
"""

N = int(input())
keihin = [input().rstrip() for _ in range(N)]

counter = Counter(keihin)
print(len(counter))

Solution (Python):
n=int(input())
s=[]
for i in range(n):
    s.append(input())
    
print(len(set(s)))

Solution (Python):
N = int(input())

kv = {}

for i in range(N):
	s = input()
	if s in kv.keys():
		kv[s] = kv[s] + 1
	else:
		kv[s] = 1

print(len(kv.keys()))

Solution (Python):
import collections
N = int(input())
S=[]
for i in range(N):
    S.append(input())
c = collections.Counter(S)
print(len(c))

Solution (Python):
N = int(input())
ans = []
for i in range(N):
    ans.append(input())
print(len(set(ans)))

Solution (Python):
def solution():
    n = int(input())
    s = set([input() for i in range(n)])
    print(len(s))

solution()