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):
from collections import defaultdict, deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys
import random
import itertools
import math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt


def LI(): return list(map(int, input().split()))


def LF(): return list(map(float, input().split()))


def LI_(): return list(map(lambda x: int(x)-1, input().split()))


def II(): return int(input())


def IF(): return float(input())


def LS(): return list(map(str, input().split()))


def S(): return list(input().rstrip())


def IR(n): return [II() for _ in range(n)]


def LIR(n): return [LI() for _ in range(n)]


def FR(n): return [IF() for _ in range(n)]


def LFR(n): return [LI() for _ in range(n)]


def LIR_(n): return [LI_() for _ in range(n)]


def SR(n): return [S() for _ in range(n)]


def LSR(n): return [LS() for _ in range(n)]


def gcd(x, y):
    if y == 0:
        return x
    return gcd(y, x % y)


def my_index_multi(l, x):
    return [i for i, _x in enumerate(l) if _x == x]


def sosu(x):
    for i in range(2, int(sqrt(x)+1)):
        if x % i == 0:
            return False
    return True


mod = 1000000007
inf = float('INF')


def A():
    S, W = LI()
    if S>W:
        print('safe')
    else:
        print('unsafe')

    
    return




def B():
    A,B,C,D=LI()
    while(1):
        C=C-B
        if C<=0:
            print('Yes')
            break
        A=A-D
        if A<=0:
            print('No')
            break



    return




def C():
    N=II()
    S=['i']*N
    for i in range(N):
        S[i]=input().rstrip()
    print(len(set(S)))

    return


def D():
    N,K=LI()
    P=LI()
    tmp=sum(P[:K])
    s=0
    pp=sorted(P, reverse=True)
    tmpmax=sum(pp[:K])
    for i in range(K,N+1):
        if (P[i-1]>P[s-1] and s!=0):
            tmp2=sum(P[s:i])
            if (tmp2==tmpmax):
                tmp=tmp2
                break
            tmp=max(tmp,tmp2)
        s+=1
        

    print((tmp+K)/2)
    return




def E():
    N, K = LI()
    A = LI()
    F = LI()
    A.sort(reverse=True)
    F.sort()
    cost = []
    for i in range(len(N)):
        cost.append(A[i]*F[i])

    a = F[cost.index(max(cost))]

    return




def F():
    N, M = LI()

    value = [0] * M
    power = [0] * M
    for i in range(M):
        a, b = LI()
        value[i] = a
        c = LI()
        L = ['0'] * N
        for k in c:
            L[k - 1] = '1'
        bint = ''.join(L)
        power[i] = int(bint, 2)
    bint = ''.join(list(['1'] * N))
    dp = [inf] * (int(bint, 2)+1)
    t = 0
    cost = 0

    dp[0] = 0
    for s in range(int(bint, 2) + 1):
        for i in range(M):
            t = s | power[i]
            cost = dp[s] + value[i]
            dp[t] = min(dp[t], cost)
    print(-1) if(dp[-1] == inf) else print(dp[-1])

    return

    



def solution(S):
    
    N = len(S)

    pass



if __name__ == '__main__':

    C()

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

for i in range(n):
    item.add(input())

print(len(item))

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

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

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


print(len(a))

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

print(len(set(s)))

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

S = list(set(S))

print(len(S))

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

n = int(input())
ans = set()
for i in range(n):
    ans.add(input().strip())

print(len(ans))

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

print(len(s))

Solution (Python):
from collections import Counter
N = int(input())
S = [input() for _ in range(N)]
S = list(set(S))

print(len(S))

Solution (Python):
from sys import stdin

def main():
    input = stdin.readline
    n = int(input())
    l = []
    for i in range(n):
        s = input()
        l.append(s)

    print(len(set(l)))

if __name__ == '__main__':
    main()

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

X = set(X)

X =list(X)

print(len(X))

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

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):
    l.append(input())
print(len(set(l)))

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

Solution (Python):
N = int(input())
present = {}
for i in range(N):
    S = input()
    if S not in present:
        present[S] = True

print(len(present))

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

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

S2 = list(set(S1))
print(len(S2))

Solution (Python):


N = int(input().strip())
S_list = [input().strip() for _ in range(N)]


check = set()

for word in S_list:
    check.add(word)

print(len(check))

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

Solution (Python):
N = int(input())
ai = [0 for i in range(N)]
for j in range(N):
    ai[j] = str(input())
s_ai = set(ai)
print(len(s_ai))

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

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

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

a = {}
for _ in range(0, n):
    s = input()
    if s not in a:
        a[s] = 1
    else:
        a[s] += 1

print(len(a))

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

dict = set()

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

print(len(dict))

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

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)]

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

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

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


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

print(len(set(S)))

Solution (Python):



dic = {}
N=int(input())
for x in range(N):
    S=str(input())
    dic[S]=1
print(len(dic.keys()))

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

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

print(len(set(s)))

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

def resolve():
    N = int(input())
    S = tuple(input() for _ in range(N))

    print(len(set(S)))

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 = 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(set(s)))

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

Solution (Python):

N = int(input())
Dict = {}
for Num in range(N):
    key = input()
    Dict[key] = 0

print(len(Dict))

Solution (Python):
import sys
import math

from collections import defaultdict
from collections import deque
def load(vtype=int):
    return vtype(input().strip())

d = set()
n  = load()
l = []
for _ in range(n):
    d.add(load(str))
print(len(d))

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

S={}

for i in range(N):
    a=input()
    if a in S:
        pass
    else:
        S[a] = 0

print(len(S))

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

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

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

Solution (Python):
def mapint_inp():
    return map(int, input().split())

def intinp():
    return int(input())

N = intinp()
item_set = set()
ans = 0

for _ in range(N):
    S = input()
    if S in item_set: continue
    item_set.add(S)
    ans += 1

print(ans)

Solution (Python):


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

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

Solution (Python):
N = int(input())
l = []
c = 0
for i in range(N):
  s = input()
  l.append(s)

a = set(l)
print(len(a))

Solution (Python):
import sys
from io import StringIO
import unittest

def resolve():

    n = int(input())

    dict = {}
    for i in range(n):
        dict[input()] = 1

    print(len(dict.items()))



class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = """3
apple
orange
apple"""
        output = """2"""
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = """5
grape
grape
grape
grape
grape"""
        output = """1"""
        self.assertIO(input, output)
    def test_入力例_3(self):
        input = """4
aaaa
a
aaa
aa"""
        output = """4"""
        self.assertIO(input, output)

if __name__ == "__main__":
    
    resolve()

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

ans = set()
for i in range(N):
    ans.add(input())

print(len(ans))

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

print(len(ls))

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

l = {}
for i in range(n):
    s = input('')
    l[s] =  'a'

print(len(l))

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

S_ = set(S)
print(len(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=[]
for _ in range(N):
    S.append(input())

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

Solution (Python):
import sys

input = sys.stdin.readline


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

    gatcha_set = set()
    for _ in range(n):
        gatcha_set.add(input())
    return len(gatcha_set)


if __name__ == '__main__':
    answer = solve()
    print(answer)

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)]

S0=set(S)

print(len(S0))

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

res = {}
for s_i in s:
    if not s_i in res:
        res[s_i] = 0
    res[s_i] += 1
print(len(res.keys()))

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

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

print(len(a_list))

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

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

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

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

for i in range(n):
    group.add(input())
print(len(group))

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

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

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

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

Solution (Python):

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

print(len(set(s_list)))

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 = int(input())

items = set()

for _ in range(N):
    items.add(input())

print(len(items))

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

print(len(set(s)))

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

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

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

Solution (Python):
from sys import stdin
import math


if __name__ == "__main__":
    _in = [_.rstrip() for _ in stdin.readlines()]
    N = int(_in[0])  
    S_arr = []
    for i in range(N):
        S = _in[i+1]   
        S_arr.append(S)
    
    
    print(len(set(S_arr)))

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

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

print(len(item_set))

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



if __name__ == '__main__':
    main()

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


st = set()
for _ in range(N):
    s = input()

    st.add(s)


print(len(st))

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

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

print(len(s))

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

Solution (Python):
arr = {}
for _ in range(int(input())):
    s = input() 
    arr[s] = 1
c=0
for i in arr:
    c+=1
print(c)

Solution (Python):
n = int(input())
s = [input() for i in range(n)]
print(len(list(set(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 = [input() for _ in range(n)]
ans = len(list(set(s)))
print(ans)

Solution (Python):
from collections import Counter

N=int(input())
i=0
list=[]

while(i<N) :
  a = str(input())
  list.append(a)
  i+=1

c = Counter(list)

print(len(c))

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

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

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

ListN = [""]*N

for i in range(N):
    ListN[i]= str(input())
    
l2 = list(set(ListN))

print (len(l2))

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

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

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

Solution (Python):

import sys
import numpy as np


def solve(N: int, S: "List[str]"):
    ans = {}
    for s in S:
        if s in ans:
            ans[s]+=1
        else:
            ans[s]=1
    print(len(ans))
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    S = [next(tokens) for _ in range(N)]  
    solve(N, S)

if __name__ == '__main__':
    main()

Solution (Python):
import numpy as np
import sys
import math

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

ss = set(S)

print(len(ss))

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

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

Solution (Python):

import heapq
from collections import defaultdict, deque
from math import ceil, factorial, gcd
from itertools import accumulate
import sys
import bisect

sys.setrecursionlimit(10 ** 7)
INF = float("inf")
MOD = 10 ** 9 + 7

si = lambda: input().strip()
ii = lambda: int(input())
mii = lambda: map(int, input().split())
lmii = lambda: list(map(int, input().split()))
lmsi = lambda: list(map(str, input().split()))
smii = lambda: sorted(map(int, input().split()))



N = ii()

S = set()
for i in range(N):
    s = si()
    S.add(s)

print(len(S))

Solution (Python):




n = int(input())
s = dict()



for i in range(n):
    ins = input()
    if s.get(ins) == None:
        s[ins] = 1
    else:
        s[ins] = s[ins] + 1
ans = len(s)

print(ans)

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

dic = {}

for i in S:
  if i not in dic:
  	dic[i] = 1
  else:
  	dic[i] += 1
else:
  print(len(dic.keys()))

Solution (Python):
N = int(input())
gift = [""]*N
for i in range(N):
    gift[i] = input()

print(len(set(gift)))

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

print(len(set(cl)))

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

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

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

print(len(set(S)))

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

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

Solution (Python):
n = int(input())
s = dict()
for i in range(n):
    tmp = input()
    s.setdefault(tmp)
print(len(s))

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

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

Solution (Python):
N = int(input())
a = [input() for _ in range(N)]
c_dict = {}
for v in a:
    c_dict[v] = 0
print(len(c_dict))

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 = set()
for i in range(n):
  s.add(input())
print(len(s))

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

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

l.sort()
cnt = 1

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

print(cnt)

Solution (Python):
N=int(input())
S=list(input() for _ in range(N))
S.sort()

out=0
L=0
for i in range(N):
    if S[i]!=L:
        out+=1
    L=S[i]
print(out)

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

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

print(len(S))

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

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

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

Solution (Python):
N = int(input())
D = {}
ans = 0

for _ in range(N):
    S = input()
    if S not in D:
        D[S] = True
        ans += 1

print(ans)

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

Solution (Python):
numOfLines = int(input())
words = []

for i in range(numOfLines):
    word = input()
    words.append(word)

print(len(set(words)))

Solution (Python):
n=int(input())
S = []
for _ in range(n):
    S.append(input())
import collections
c = collections.Counter(S)

print(len(c))

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

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

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

s = set(s)

print(len(s))

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

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

Solution (Python):
from collections import Counter


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

SsC = Counter(Ss)

print(len(SsC))

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())
L = []
for i in range(N):
    L.append(input())
print(len(set(L)))

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

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

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

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

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

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

Solution (Python):
from collections import defaultdict

a = defaultdict(int)
n = int(input())
for i in range(n):
    w = input()
    a[w] += 1

print(len(a.items()))

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

cnt = {}

for _ in range(N):
    award = input()
    cnt.setdefault(award, 0)
    cnt[award] += 1
    
print(len(cnt))

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

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

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

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

for i in range(n):
    a.append(input())
b=set(a)
print(len(b))

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

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

Solution (Python):







import sys
from functools import lru_cache

sys.setrecursionlimit(10**9)

Input = lambda: sys.stdin.readline().rstrip()
IntRead = lambda: int(Input())
LineRead = lambda: list(map(int, Input().split()))


INF = 10**18

def main():
    N = IntRead()
    s = set()
    for _ in range(N):
        word = Input()
        s.add(word)
    print(len(s))

if __name__ == "__main__":
    main()

Solution (Python):
import sys
N = int(sys.stdin.readline())
S = [sys.stdin.readline().rstrip() for i in range(N)]
print(len(set(S)))

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

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

print(len(s_unique))

Solution (Python):

import math
    
def abs(num):
    if num < 0:
        return -num
    else:
        return num



if(__name__ == '__main__'):
    
    n = int(input())
    s_dict = {}
    for _ in range(n):
        s = input()
        s_dict[s] = 1

    print(len(s_dict))

Solution (Python):
if __name__ == "__main__":

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

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

def main():
    from collections import defaultdict
    N, *S = read().split()
    d = defaultdict(int)
    for s in S:
        d[s] += 1
    print(len(d))
    return

if __name__ == '__main__':
    main()

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

S = []

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

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

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

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

print(len(set(s)))

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians

from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from functools import reduce
from bisect import bisect_left, insort_left
from heapq import heapify, heappush, heappop

INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())
MAP = lambda: map(int, INPUT().split())
S_MAP = lambda: map(str, INPUT().split())
LIST = lambda: list(map(int, INPUT().split()))
S_LIST = lambda: list(map(str, INPUT().split()))

sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7


def main():
    N = INT()
    S = [INPUT() for _ in range(N)]
    print(len(set(S)))


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
import collections

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

print(len(c))

Solution (Python):
import sys


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

d = {}
for i in s:
    d[i] = 0
print(len(d))

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 = {}
for x in range(N):
    tmp = input()
    S[tmp] = 1
print(len(S))

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

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

print(len(set(S)))

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

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

dic = {}

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

  if(s in dic) :
    dic[s] += 1
  else:
    dic[s] = 1
  


print(len(dic))

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

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

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

Solution (Python):
from collections import Counter

n = int(input())
S = [input() for _ in range(n)]
S_count = Counter(S)

print(len(S_count.keys()))

Solution (Python):
items = {}
for i in range(int(input())):
    items[input()] = True

print(len(items.keys()))

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

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

Solution (Python):
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))


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

print(len(set(s)))

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

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

print(len(set(S)))

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

Solution (Python):
def i1str():
    return input()


def istrs(n=None):
    if n is None:
        return input().split()
    a = []
    for _ in range(n):
        a.append(istrs())
    return a


def i1num():
    return int(input())


def inums(n=None):
    if n is None:
        return list(map(int, input().split()))
    a = []
    for _ in range(n):
        a.append(inums())
    return a


def ostrs(l, sp=" "):
    print(sp.join(l))


def onums(l, sp=" "):
    print(sp.join(map(str, l)))


def solve(n):
    s = set()
    for _ in range(n):
        s.add(input())
    return len(s)


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

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

Solution (Python):
def read_int():
    return int(input())

def read_int_map():
    return map(int,input().split(' '))

def read_int_list():
    return list(map(int,input().split(' ')))

def read_s_list_loop(n):
    return [input() for _ in range(n)]

N = read_int()
Sn =  {input() for _ in range(N)}
print(len(Sn))

Solution (Python):



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


ans = len(set(s_list))


print(ans)

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

S= []

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

c = collections.Counter(S)

print(len(c))

Solution (Python):

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

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

n = int(input())
s = [input().replace("\n","") for i in range(n)]

Scnt = Counter(s)
print(len(Scnt.values()))

Solution (Python):
def main():
    N = int(input())
    item = [ input() for i in range(N)]
    print(len(set(item)))
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())
s=[]
for i in range(n):
    s.append(input())
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 = int(input())
lst = [input() for _ in range(n)]

print(len(set(lst)))

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

L = []

for i in range(N):
    L.append(input())
    
A  = len(set(L)) 
print(A)

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

dic = {}
for _ in range(n):
  e = str(input())
  if e in dic:
    continue
  else:
    dic[e] = 0
print(len(dic))

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

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

print(len(set(S)))

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

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

print(len(set(lst)))

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

Solution (Python):
N = int(input())
if N!=0:
    s = [input() for i in [0]*N]
else:
    s = []

s = set(s)

ans = len(s)
print(ans)

Solution (Python):
import sys
from collections import Counter

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

m = Counter(S)
print(len(m))

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

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

Solution (Python):
import sys
n = int(input())
cnt = 1
li=['']*n
for i in range(n):
    li[i] = input()
li.sort()
for i in range(n):
    if (i + 1 == n):
        break
    if (li[i] == li[i + 1]):
        continue
    cnt+=1
print(cnt)

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
 
def main():
    n = int(input())
    s = set()
    for _ in range(n):
        x = input()
        s.add(x)
    print(len(s))
if __name__ == '__main__':
    main()