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):
n=int(input())
strs=set()
for i in range(0,n):
    temp=input()
    strs.add(temp)
print(len(strs))

Solution (Python):
from collections import Counter

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

newS = dict(Counter(S))
print(len(newS))

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

    L.append(S)

print(len(set(L)))

Solution (Python):
import sys

N = int(input())
S = list(str(input()) for _ in range(N))

mydict = {}

for i in range(N):
    mydict[S[i]] = 0

for i in range(N):
    mydict[S[i]] += 1

cnt = 0
for key in mydict.keys():
    cnt += 1
print(cnt)

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

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

set = set(s)

print(len(set))

Solution (Python):
from collections import Counter
 
n = int(input())
 
items = []
for _ in range(n):
  items.append(input())
  
freq = Counter(items)
print(len(freq))

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

print(len(set(s)))

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

Solution (Python):
n = int(input())
gacha = []

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

import collections
c = collections.Counter(gacha)  
  
print(len(c))

Solution (Python):
n=int(input())
a=[]

for i in range(n):

    a.append(input())

a=set(a)

print(len(a))

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

set_list = set(list)
print(len(set_list))

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

print(len(set(s_list)))

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

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

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

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

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

keihin = []

for i in range(N):
    keihin.append(input())
    
print(len(set(keihin)))

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

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

print(len(set(ansl)))

Solution (Python):
num_val = int(input())
item_list = [input() for i in range(num_val)]

print(len(set(item_list)))

Solution (Python):
import sys


N = int(input())





S = list(str(input()) for i in range(N))
S2 = sorted(S)
ans = N

    
for i in range(1,N):
    if S2[i-1] == S2[i]:
        ans -= 1
print(ans)

Solution (Python):
"""
import random
import functools
import copy
import bisect
import array
import re
import collections
import heapq
import fractions
import itertools
import string
import math
from operator import itemgetter as ig
from bisect import bisect_left, bisect_right, insort_left, insort_right
from itertools import permutations, combinations, product, accumulate, groupby
from heapq import heappush, heappop
from collections import deque, defaultdict, Counter
import sys
sys.setrecursionlimit(10 ** 7)


inf = 10 ** 20
INF = float("INF")
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = dd + [(-1, 1), (1, 1), (1, -1), (-1, -1)]
ddn9 = ddn + [(0, 0)]
'''for dx, dy in dd:
        nx = j + dx; ny = i + dy
            if 0 <= nx < w and 0 <= ny < h:'''
"""
from collections import deque, defaultdict, Counter
import math
import sys
sys.setrecursionlimit(10 ** 7)


def wi(): return list(map(int, sys.stdin.readline().split()))



def wip(): return [int(x) - 1 for x in sys.stdin.readline().split()]


def ws(): return sys.stdin.readline().split()


def si(): return int(sys.stdin.readline())  


def ss(): return input()


def hi(n): return [si() for _ in range(n)]


def hs(n): return [ss() for _ in range(n)]  


def s_list(): return list(input())


def mi(n): return [wi() for _ in range(n)]  


def mip(n): return [wip() for _ in range(n)]


def ms(n): return [ws() for _ in range(n)]


def num_grid(n): return [[int(i) for i in sys.stdin.readline().split()[
    0]] for _ in range(n)]  


def grid(n): return [s_list() for _ in range(n)]


def gcd(a, b):
    while b:
        a, b = b, a % b
    return a




def round_up(a, b):
    """ a/b の切り上げ """
    c = (a + b - 1) / b
    return c


def lcm(a, b):
    """a,bの最小公倍数"""
    return a * b // gcd(a, b)


def main():
    n = int(input())
    s = defaultdict(int)
    for i in range(n):
        s[input()] += 1

    print(len(s))


if __name__ == '__main__':
    main()

Solution (Python):

N = int(input())
ans_set = set()
for i in range(N):
    ans_set.add(str(input()))
print(len(ans_set))

Solution (Python):
def main():
    n = int(input())
    l = [input() for _ in range(n)]
    return len(set(l))


if __name__ == '__main__':
    print(main())

Solution (Python):

"""
Created on Sun Apr 26 20:57:43 2020
"""

import sys


sys.setrecursionlimit(10 ** 9)


mod = 10**9+7

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


s = set(S)
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):
N = int(input())
S = [input() for i in range(N)]

dicts = {}
ans = 0
for i in S:
    if i not in dicts.keys():
        ans += 1
        dicts[i] = 0

print(ans)

Solution (Python):
a = int(input())
dict = {}
for i in range(a):
  dict[input()]=0
print(len(dict))

Solution (Python):
n = int(input())
s = [0]*n

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

print(len(set(s)))

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

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

Solution (Python):
N=int(input())
d=dict()
for i in range(N):
    S=input()
    if S in d:
        d[S]+=1
    else:
        d[S]=1
print(len(d))

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

kinds = []

for i in range(N):
  kinds.append(input())
  
print(len(set(kinds)))

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

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



kind = {}

for i in range( n ):
    try:
        kind[ s[i] ] += 1
    except KeyError:
        kind[ s[i] ] = 0

print( len( kind.keys() ) )

Solution (Python):

N = int(input())
S = [""] * N
for i in range(N):
    S[i] = str(input())


a = set(S)
print(len(a))

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

Solution (Python):
def m():
    n = int(input())
    d = {}
    for _ in range(n):
        d[str(input())] = 1
    return len(d.keys())


print(m())

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

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

Solution (Python):
def resolve():
    n = int(input())
    ans = {}
    for i in range(n):
        a = input()
        if a in ans:
            ans[a] += 1
        else:
            ans[a] = 1
    print(len(ans))

resolve()

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

l = []
for _ in range(n):
  l.append(str(input()))
  
print(set(l).__len__())

Solution (Python):
n = input()
s = set()

for _ in xrange(n):
  m = raw_input()
  s.add(m)
print len(s)

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

for _ in range(N):
    s = str(input())
    ss_list[s] = 0

print(len(ss_list))

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

print(len(set(a)))

Solution (Python):

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

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

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

for i in range(n):
    a = input()
    s.add(a)

print(len(s))

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

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

s = []

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

print(len(set(s)))

Solution (Python):
N=int(input())
d={}
for i in range(N):
    S=input()
    d[S]=1
print(len(d))

Solution (Python):
from collections import Counter

N=int(input())

A=[]

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

c=Counter(A)

print(len(c))

Solution (Python):
n = int(input())
l = list("")
for i in range(n):
    l.append(input())
ans = set(l)
print(len(ans))

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

Solution (Python):
def main(N=None):
    if not N:
        N = int(input())
    s = set()
    for i in range(N):
        s.add(input())
    print(len(s))


if __name__ == "__main__":
    main()

Solution (Python):
t=int(input())
x=set()
for i in range(t):
  j=input()
  x.add(j)
print(len(x))

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

A=[]

for _ in range(N):
    a=input()
    A.append(a)

A=set(A)

print(len(A))

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

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

D = {}
for s in S:
    if s not in D:
        D[s] = 0
    else:
        D[s] += 1

print(len(D))

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

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

Solution (Python):
n = int(input())
slist=[]

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

print(len(list(set(slist))))

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

S_types = set(S)
print(len(S_types))

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

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

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

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

ans = {}

for _ in range(n):
    s = input()

    ans[s] = 1

print(len(ans))

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

for n in range(N):
    praise.add(input())

print(len(praise))

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

d = dict()

for i in range(n):
    temp = input()
    if temp in d:
        d[temp] += 1
    else:
        d[temp] = 1

print(len(d))

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

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

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

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

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

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

ans = list(set(S))
print(len(ans))

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

Solution (Python):
import sys

lines = int(sys.stdin.readline().strip())

inp = list()

for _ in range(lines):
    inp.append(sys.stdin.readline().strip())


print(len(set(inp)))

Solution (Python):
import collections
n = int(input())
s = [0 for _ in range(n)]
for i in range(n):
    s[i] = input()
l = collections.Counter(s)
print(len(list(l.values())))

Solution (Python):


import sys
import math
import bisect
from fractions import gcd
from itertools import count, permutations
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint

INF = float('inf')

ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
lmtx = lambda h: [list(map(int, lmis())) for _ in range(h)]
sys.setrecursionlimit(1000000000)


def lcm(a, b):
    return (a * b) // gcd(a, b)



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

print(len(set(slist)))

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

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

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

gacha = collections.deque()

for i in range(N):
    gacha.append(input())
   
print(len(collections.Counter(gacha)))

Solution (Python):

import sys
sysread = sys.stdin.readline
def run():
    N = int(input())
    S = []
    for _ in range(N):
        S.append(input())
    ret = set()
    for s in S:
        ret.add(s)
    print(len(ret))

if __name__ == "__main__":
    run()

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

Solution (Python):


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

Solution (Python):
n = int(input())
d = {}
for _ in range(n):
    item = input()
    if item not in d:
        d[item] = 1
    else: 
        d[item] += 1
print(len(d))

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

l = [input() for _ in range(n)] 

l = set(l)

print(len(l))

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

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

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

print(len(set(l)))

Solution (Python):
N = int(input())
S = [(input()) for i 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):
N = int(input())
S = [ input() for i in range(N)]

print(len(set(S)))

Solution (Python):
n=int(input())
s={input() for i in range(n)}

print(len(s))

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

goods_list=[input() for i in range(N)]
print(len(list(set(goods_list))))

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

if __name__ == "__main__":
    main()

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

gacha_set = set()
for _ in range(n):
    s = input()
    gacha_set.add(s)

print(len(gacha_set))

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

print(len(set(S)))

Solution (Python):

from sys import stdin
from operator import itemgetter
from collections import deque, Counter
import math
import pprint
from functools import reduce


MOD = 1000000007

def keta(kazu):
    kazu_str = str(kazu)
    kazu_list = [int(kazu_str[i]) for i in range(0, len(kazu_str))]
    return kazu_list

def gcd(*numbers):
    return reduce(math.gcd, numbers)

def combination(m,n):
    if n > m:
        return 'すまん'
    return math.factorial(m) // (math.factorial(m-n) * math.factorial(n))

N = int(stdin.readline().rstrip())
result = []

while N > 0:
    result.append(stdin.readline().rstrip())
    N -= 1
    
ans = list(set(result))
print(len(ans))

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

Solution (Python):
N = int(input())
s = [input() for i in range(N)]
s_set = set(s)

print(len(s_set))

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

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

s = []

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

t = collections.Counter(s)
tt = list(t)

print(len(tt))

Solution (Python):
N = int(input())
items = {}
for i in range(N):
    a = str(input())
    items[a] = 0
print(len(items))

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

ans = set()
for i in range(N):
    ans.add(s[i])

print(len(ans))

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

import collections

c = collections.Counter(s)

print(len(c.keys()))

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

s=sorted(s)
for i in range(0,n-1):
    if s[i]!=s[i+1]:
        count+=1
print(count)

Solution (Python):
cnt = int(input())
gets = [input() for _ in range(cnt)]

gacha_set = set()
for g in gets:
  gacha_set.add(g)

print(len(gacha_set))

Solution (Python):
"""def power(x, y): 
    res = 1
    x=x
    while (y > 0): 
        if ((y & 1) == 1) : 
            res = (res * x) 
        y = y >> 1
        x = (x * x)
    return res""" 
"""def fact(n):
    if(n==0):
        return 1
    if(n==1):
        return 1
    return fact(n-1)+fact(n-2)"""

import math



t=int(input())
d={}
count=0
for _ in range(t):
    
    s=input()
    
    
    
    
    
    
    if s not in d:
        count+=1
        d[s]=1
    else:
        d[s]+=1
print(count)

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

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

Solution (Python):
N, = map(int, input().split())
s = set()
for _ in range(N):
    s.add(input())
print(len(s))

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

Solution (Python):
from math import ceil

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

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

    s = set()

    for i in S:
        s.add(i)

    print(len(s))

if __name__ == '__main__':
    main()

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

Solution (Python):
n = int(input())
l = []
while n > 0 :
    l.append(input())
    n -= 1

uniq = set(l)
print(len(uniq))

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

print(len(set(list)))

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

Solution (Python):
from collections import defaultdict
N = int(input())
s = defaultdict(int)
for i in range(N):
    s[input()] += 1
print(len(s))

Solution (Python):
import collections

N = int(input())
S = [0]*N
for i in range(N):
    S[i] = input()
c = collections.Counter(S)

print(len(c.most_common()))

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

print(len(set(s)))

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

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

s = []

for _ in range(n):
    s.append(input())

s = set(s)

print(len(s))

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

keihin = []

for i in range(N) :
  keihin.append(str(input()))
  
print(len(set(keihin)))

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

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

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

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

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

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

Solution (Python):
N=int(input())
S=['0']*N
for i in range(0,N):
    S[i]=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(str(input()) for i in range(N))
L=set(S)
print(len(L))

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

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

li = set(s)
print(len(li))

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

Solution (Python):
from collections import Counter

n = int(input())
ans = []
for i in range(n):
    s = input()
    ans.append(s)
answer = Counter(ans)
print(len(list(answer.keys())))

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

print(len(s))

Solution (Python):
nums = int(input())
itemlist = []
for i in range(nums):
	item = input()
	itemlist.append(item)
listtoset = set(itemlist)
print(len(listtoset))

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


def main():
    N = int(input())
    S = list(input().strip() for _ in range(N))
    items = collections.Counter(S)
    print(len(items))


if __name__ == "__main__":
    main()

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

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

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

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

print(len(list(set(l))))

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

prize = set()
for i in range(n):
    prize.add(input())

print(len(prize))

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

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

unbo = []


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

setList = set(unbo)

print(len(setList))

Solution (Python):
from collections import defaultdict
from collections import deque
from string import ascii_uppercase
import sys, bisect, math, heapq

stdin = sys.stdin
read_int = lambda : list(map(int,stdin.readline().split()))
read_str = lambda : stdin.readline().rstrip()

N = read_int()[0]
S = [list(read_str().split())[0] for _ in range(N)]

def solve():
    return len(set(S))

if __name__ == "__main__":
    print(solve())

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

Solution (Python):
n = int(input())
res = []

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


print(len(set(res)))

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

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

s=[0]*n

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


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

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())
S = [input() for i in range(N)]

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

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

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

print(len(dict))

Solution (Python):


n = 0
s = []

def format_input(filename = None):
	global n
	global s
	if filename == None:
		n = int(input())
		s = [str(input()) for i in range(n)]

	elif filename == '__random__':
		from random import randint as rng
		from random import choices
		n = rng(1, 2 * 10**5)
		s = [''.join(choices('abcdefghijklmnopqrstuvwxyz', k = rng(1, 10))) for i in range(n)]
		print(n)
		[print(s_i) for s_i in s]

def get_answer():
	answer = len(set(s))
	return answer

if __name__ == '__main__':
	format_input()

	ans = get_answer()
	print(ans)

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

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

print(len(set(s)))

Solution (Python):
from math import ceil
f=0
    
    
    
    
n=int(input())
m={}
for i in range(n):
    s=input()
    m[s]=1

print(len(m))

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

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

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

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

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

print(len(set(s_list)))

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

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

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

print(len(s))

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

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

print(len(s))

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


if __name__ == "__main__":
    c()

Solution (Python):
N = int(input())
s = list()
for a in range(N):
    s.append(input())

print(len(list((set(s)))))

Solution (Python):
N=int(input())
S=[input() for _ in range(N)]
S.sort()
cnt=1
sb=S[0]
for s in S:
    if sb!=s:
        cnt+=1
    sb=s

print(cnt)

Solution (Python):
from collections import Counter as Cnt
n=int(input())
s=[0]*n
for i in range(n):
    s[i]=input()
C=Cnt(s)

cnt = len(C.values())
print(cnt)

Solution (Python):
from collections import Counter

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

Solution (Python):
from collections import defaultdict

N = int(input())
keihin = defaultdict(int)
for i in range(N):
    S = input()
    keihin[S] += 1
print(len(keihin))

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

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

print(len(S))

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

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

from collections import Counter
s_cnt = Counter(s)

ans = len(s_cnt)

print(ans)

Solution (Python):
def main():
    
    

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

    print(len(set(S)))


if __name__ == "__main__":
    main()

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

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

prize = []

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

prize_kind = set(prize)

print(len(prize_kind))

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

arr = [input() for _ in range(n)]
dic={}
for i in range(n):
 if arr[i] not in dic:
   dic[arr[i]]=1

print(len(dic))

Solution (Python):

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

print(len(set(a)))

Solution (Python):
from collections import defaultdict as dd
N=int(input())
a=[input() for _ in range(N)]
dic=dd(int)
for val in a:
    dic[val] += 1
print(len(dic.keys()))

Solution (Python):
import numpy as np
from collections import defaultdict
from math import gcd
import time
import sys
from collections import Counter
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
start = time.time()
N = int(input())
s = set()
for i in range(N):
    s.add(input())

print(len(s))

Solution (Python):
import collections
def slove(n, s):
    counter = collections.Counter()
    for i in s:
        counter[i] += 1


    ans = len(counter.keys())
    return ans

if __name__ == "__main__":

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

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

print(len(set(s)))