// // // // // // // // 	// //AUTHOR:BlackBox Inc.//
// // // // // // // // 	// #include<bits/stdc++.h>
// // // // // // // // 	// #include<unordered_map>
// // // // // // // // 	// #include<tr1/unordered_map>
// // // // // // // // 	// #define ll long long
// // // // // // // // 	// #define ull unsigned long long
// // // // // // // // 	// #define vi vector<int>
// // // // // // // // 	// #define vlli vector<long long int>
// // // // // // // // 	// #define vvi vector<vector<int>>
// // // // // // // // 	// #define vpii vector<pair<int,int>>
// // // // // // // // 	// #define vs vector<string>
// // // // // // // // 	// #define lin1(x) ll int x; x = scan();
// // // // // // // // 	// #define lin2(x,y) ll int x, y; x = scan(), y = scan();
// // // // // // // // 	// #define lin3(x,y,z) ll int x, y, z; x = scan(), y = scan(), z = scan();
// // // // // // // // 	// #define pb(x) push_back(x)
// // // // // // // // 	// #define makep(x,y) make_pair(x,y)
// // // // // // // // 	// #define mx(a,b) (a)>(b)?(a):(b)
// // // // // // // // 	// #define mn(a,b) (a)<(b)?(a):(b)
// // // // // // // // 	// #define fori(s,e) for(i=s;i<=e;i++)
// // // // // // // // 	// #define forj(s,e) for(j=s;j<=e;j++)
// // // // // // // // 	// #define fork(s,e) for(k=s;k<=e;k++)
// // // // // // // // 	// #define rep(i,s,e) for(int i=s;i<=e;i++)
// // // // // // // // 	// #define brep(i,s,e) for(int i=s;i>=e;i--)
// // // // // // // // 	// #define all(x) x.begin(),x.end()
// // // // // // // // 	// #define mem(x,y) memset(x,y,sizeof(x));
// // // // // // // // 	// #define bits1(x) __builtin_popcount(x)
// // // // // // // // 	// #define pi 3.14159265358979323846264338327950
// // // // // // // // 	// #define MOD7 1000000007
// // // // // // // // 	// #define MOD9 1000000009
// // // // // // // // 	// #define fast std::ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
// // // // // // // // 	// using namespace std;
// // // // // // // // 	// using namespace std::tr1;

// // // // // // // // 	// int main()
// // // // // // // // 	// {
// // // // // // // // 	// #ifdef RAHUL
// // // // // // // // 	//     freopen("input.txt","r",stdin);
// // // // // // // // 	// #endif


// // // // // // // // 	// ll a, b;
// // // // // // // // 	// cin>>a>>b;

// // // // // // // // 	// ll arr[b];
// // // // // // // // 	// ll sum=0;
// // // // // // // // 	// for (int i = 0; i < b; ++i)
// // // // // // // // 	// {
// // // // // // // // 	// 	/* code */
// // // // // // // // 	// 	cin>>arr[i];
// // // // // // // // 	// 	sum+=arr[i];
// // // // // // // // 	// }

// // // // // // // // 	// if(a-sum<0){
// // // // // // // // 	// 	cout<<"-1"<<endl;
// // // // // // // // 	// }
// // // // // // // // 	// else{
// // // // // // // // 	// 	cout<<a-sum<<endl;
// // // // // // // // 	// }

// // // // // // // // 	// return 0;
// // // // // // // // 	// }
// // // // // // // // //AUTHOR:BlackBox Inc.//
// // // // // // // // #include<bits/stdc++.h>
// // // // // // // // #include<unordered_map>
// // // // // // // // #include<tr1/unordered_map>
// // // // // // // // #define ll long long
// // // // // // // // #define ull unsigned long long
// // // // // // // // #define vi vector<int>
// // // // // // // // #define vlli vector<long long int>
// // // // // // // // #define vvi vector<vector<int>>
// // // // // // // // #define vpii vector<pair<int,int>>
// // // // // // // // #define vs vector<string>
// // // // // // // // #define lin1(x) ll int x; x = scan();
// // // // // // // // #define lin2(x,y) ll int x, y; x = scan(), y = scan();
// // // // // // // // #define lin3(x,y,z) ll int x, y, z; x = scan(), y = scan(), z = scan();
// // // // // // // // #define pb(x) push_back(x)
// // // // // // // // #define makep(x,y) make_pair(x,y)
// // // // // // // // #define mx(a,b) (a)>(b)?(a):(b)
// // // // // // // // #define mn(a,b) (a)<(b)?(a):(b)
// // // // // // // // #define fori(s,e) for(i=s;i<=e;i++)
// // // // // // // // #define forj(s,e) for(j=s;j<=e;j++)
// // // // // // // // #define fork(s,e) for(k=s;k<=e;k++)
// // // // // // // // #define rep(i,s,e) for(int i=s;i<=e;i++)
// // // // // // // // #define brep(i,s,e) for(int i=s;i>=e;i--)
// // // // // // // // #define all(x) x.begin(),x.end()
// // // // // // // // #define mem(x,y) memset(x,y,sizeof(x));
// // // // // // // // #define bits1(x) __builtin_popcount(x)
// // // // // // // // #define pi 3.14159265358979323846264338327950
// // // // // // // // #define MOD7 1000000007
// // // // // // // // #define MOD9 1000000009
// // // // // // // // #define fast std::ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
// // // // // // // // using namespace std;
// // // // // // // // using namespace std::tr1;

// // // // // // // // int main()
// // // // // // // // {
// // // // // // // // #ifdef RAHUL
// // // // // // // //     freopen("input.txt","r",stdin);
// // // // // // // // #endif


// // // // // // // // int t;
// // // // // // // // cin>>t;
// // // // // // // // double rahul;
// // // // // // // // rahul=2*pi*t;
// // // // // // // // std :: cout << std :: setprecision (20)<< std :: fixed << rahul << std :: endl ;
// // // // // // // // return 0;
// // // // // // // // }

// // // // // // // //AUTHOR:BlackBox Inc.//
// // // // // // // #include<bits/stdc++.h>
// // // // // // // #include<unordered_map>
// // // // // // // #include<tr1/unordered_map>
// // // // // // // #define ll long long
// // // // // // // #define ull unsigned long long
// // // // // // // #define vi vector<int>
// // // // // // // #define vlli vector<long long int>
// // // // // // // #define vvi vector<vector<int>>
// // // // // // // #define vpii vector<pair<int,int>>
// // // // // // // #define vs vector<string>
// // // // // // // #define lin1(x) ll int x; x = scan();
// // // // // // // #define lin2(x,y) ll int x, y; x = scan(), y = scan();
// // // // // // // #define lin3(x,y,z) ll int x, y, z; x = scan(), y = scan(), z = scan();
// // // // // // // #define pb(x) push_back(x)
// // // // // // // #define makep(x,y) make_pair(x,y)
// // // // // // // #define mx(a,b) (a)>(b)?(a):(b)
// // // // // // // #define mn(a,b) (a)<(b)?(a):(b)
// // // // // // // #define fori(s,e) for(i=s;i<=e;i++)
// // // // // // // #define forj(s,e) for(j=s;j<=e;j++)
// // // // // // // #define fork(s,e) for(k=s;k<=e;k++)
// // // // // // // #define rep(i,s,e) for(int i=s;i<=e;i++)
// // // // // // // #define brep(i,s,e) for(int i=s;i>=e;i--)
// // // // // // // #define all(x) x.begin(),x.end()
// // // // // // // #define mem(x,y) memset(x,y,sizeof(x));
// // // // // // // #define bits1(x) __builtin_popcount(x)
// // // // // // // #define pi 3.14159265358979323846264338327950
// // // // // // // #define MOD7 1000000007
// // // // // // // #define MOD9 1000000009
// // // // // // // #define fast std::ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
// // // // // // // using namespace std;
// // // // // // // using namespace std::tr1;

// // // // // // // int main()
// // // // // // // {
// // // // // // // #ifdef RAHUL
// // // // // // //     freopen("input.txt","r",stdin);
// // // // // // // #endif
// // // // // // // making the world the be
// // // // // // //AUTHOR:BlackBox Inc.//
// // // // // // #include<bits/stdc++.h>
// // // // // // #include<unordered_map>
// // // // // // #include<tr1/unordered_map>
// // // // // // #define ll long long
// // // // // // #define ull unsigned long long
// // // // // // #define vi vector<int>
// // // // // // #define vlli vector<long long int>
// // // // // // #define vvi vector<vector<int>>
// // // // // // #define vpii vector<pair<int,int>>
// // // // // // #define vs vector<string>
// // // // // // #define lin1(x) ll int x; x = scan();
// // // // // // #define lin2(x,y) ll int x, y; x = scan(), y = scan();
// // // // // // #define lin3(x,y,z) ll int x, y, z; x = scan(), y = scan(), z = scan();
// // // // // // #define pb(x) push_back(x)
// // // // // // #define makep(x,y) make_pair(x,y)
// // // // // // #define mx(a,b) (a)>(b)?(a):(b)
// // // // // // #define mn(a,b) (a)<(b)?(a):(b)
// // // // // // #define fori(s,e) for(i=s;i<=e;i++)
// // // // // // #define forj(s,e) for(j=s;j<=e;j++)
// // // // // // #define fork(s,e) for(k=s;k<=e;k++)
// // // // // // #define rep(i,s,e) for(int i=s;i<=e;i++)
// // // // // // #define brep(i,s,e) for(int i=s;i>=e;i--)
// // // // // // #define all(x) x.begin(),x.end()
// // // // // // #define mem(x,y) memset(x,y,sizeof(x));
// // // // // // #define bits1(x) __builtin_popcount(x)
// // // // // // #define pi 3.14159265358979323846264338327950
// // // // // // #define MOD7 1000000007
// // // // // // #define MOD9 1000000009
// // // // // // #define fast std::ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
// // // // // // using namespace std;
// // // // // // using namespace std::tr1;
// // // // // // bool check(string s){
// // // // // // 	int x=s.length();
// // // // // // 	int y=x-1;
// // // // // // 	for(int i=0;i<x/2;i++){
// // // // // // 		if(s[i]!=s[y]){
// // // // // // 			return false;
// // // // // // 		}
// // // // // // 		y--;
// // // // // // 	}
// // // // // // 	return true;
// // // // // // }
// // // // // // int main()
// // // // // // {
// // // // // // #ifdef RAHUL
// // // // // //     freopen("input.txt","r",stdin);
// // // // // // #endif
// // // // // // string s;
// // // // // // cin>>s;
// // // // // // string rahul;
// // // // // // string rohan;
// // // // // // int l1=(s.length()-1)/2;
// // // // // // int l2=(s.length()+3)/2;
// // // // // // for(int i=0;i<l1;i++){
// // // // // // 	rohan+=s[i];
// // // // // // }

// // // // // // for(int i=l2-1;i<s.length();i++){
// // // // // // 	rahul+=s[i];
// // // // // // }
// // // // // // if(check(s) and check(rohan)==true and check(rahul)==true){
// // // // // // 	cout<<"Yes"<<endl;
// // // // // // }
// // // // // // else{
// // // // // // 	cout<<"No"<<endl;
// // // // // // }

// // // // // // return 0;
// // // // // // }


// // // // // //AUTHOR:BlackBox Inc.//
// // // // // #include<bits/stdc++.h>
// // // // // #include<unordered_map>
// // // // // #include<tr1/unordered_map>
// // // // // #define ll long long
// // // // // #define ull unsigned long long
// // // // // #define vi vector<int>
// // // // // #define vlli vector<long long int>
// // // // // #define vvi vector<vector<int>>
// // // // // #define vpii vector<pair<int,int>>
// // // // // #define vs vector<string>
// // // // // #define lin1(x) ll int x; x = scan();
// // // // // #define lin2(x,y) ll int x, y; x = scan(), y = scan();
// // // // // #define lin3(x,y,z) ll int x, y, z; x = scan(), y = scan(), z = scan();
// // // // // #define pb(x) push_back(x)
// // // // // #define makep(x,y) make_pair(x,y)
// // // // // #define mx(a,b) (a)>(b)?(a):(b)
// // // // // #define mn(a,b) (a)<(b)?(a):(b)
// // // // // #define fori(s,e) for(i=s;i<=e;i++)
// // // // // #define forj(s,e) for(j=s;j<=e;j++)
// // // // // #define fork(s,e) for(k=s;k<=e;k++)
// // // // // #define rep(i,s,e) for(int i=s;i<=e;i++)
// // // // // #define brep(i,s,e) for(int i=s;i>=e;i--)
// // // // // #define all(x) x.begin(),x.end()
// // // // // #define mem(x,y) memset(x,y,sizeof(x));
// // // // // #define bits1(x) __builtin_popcount(x)
// // // // // #define pi 3.14159265358979323846264338327950
// // // // // #define MOD7 1000000007
// // // // // #define MOD9 1000000009
// // // // // #define fast std::ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
// // // // // using namespace std;
// // // // // using namespace std::tr1;

// // // // // int main()
// // // // // {
// // // // // #ifdef RAHUL
// // // // //     freopen("input.txt","r",stdin);
// // // // // #endif

// // // // // int t;
// // // // // cin>>t;

// // // // // cout<<setprecision(20)<<fixed<<(double)t*t*t/27<<endl;

// // // // // return 0;
// // // // // }
// // // // //AUTHOR:BlackBox Inc.//
// // // // #include<bits/stdc++.h>
// // // // #include<unordered_map>
// // // // #include<tr1/unordered_map>
// // // // #define ll long long
// // // // #define ull unsigned long long
// // // // #define vi vector<int>
// // // // #define vlli vector<long long int>
// // // // #define vvi vector<vector<int>>
// // // // #define vpii vector<pair<int,int>>
// // // // #define vs vector<string>
// // // // #define lin1(x) ll int x; x = scan();
// // // // #define lin2(x,y) ll int x, y; x = scan(), y = scan();
// // // // #define lin3(x,y,z) ll int x, y, z; x = scan(), y = scan(), z = scan();
// // // // #define pb(x) push_back(x)
// // // // #define makep(x,y) make_pair(x,y)
// // // // #define mx(a,b) (a)>(b)?(a):(b)
// // // // #define mn(a,b) (a)<(b)?(a):(b)
// // // // #define fori(s,e) for(i=s;i<=e;i++)
// // // // #define forj(s,e) for(j=s;j<=e;j++)
// // // // #define fork(s,e) for(k=s;k<=e;k++)
// // // // #define rep(i,s,e) for(int i=s;i<=e;i++)
// // // // #define brep(i,s,e) for(int i=s;i>=e;i--)
// // // // #define all(x) x.begin(),x.end()
// // // // #define mem(x,y) memset(x,y,sizeof(x));
// // // // #define bits1(x) __builtin_popcount(x)
// // // // #define pi 3.14159265358979323846264338327950
// // // // #define MOD7 1000000007
// // // // #define MOD9 1000000009
// // // // #define fast std::ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
// // // // using namespace std;
// // // // using namespace std::tr1;

// // // // int main()
// // // // {
// // // // #ifdef RAHUL
// // // //     freopen("input.txt","r",stdin);
// // // // #endif
// // // //     int arr[3][3];
// // // // std::vector<int>rohan;
// // // // for (int i = 0; i < 3; ++i)
// // // // {
// // // // 	for(int j=0;j<3;j++){
// // // // 		cin>>arr[i][j];
// // // // 		int x=arr[i][j];
// // // // 		rohan[x];
// // // // 	}
// // // // 	/* code */
// // // // }
// // // // int x;
// // // // cin>>x;
// // // // int arr1[x];
// // // // int count=0;
// // // // for (int i = 0; i < x; ++i)
// // // // {
// // // // 	/* code */
// // // // 	cin>>arr1[i];
// // // // }
// // // // for (int i = 0; i < x; ++i)
// // // // {
// // // // 	for(int j=0;j<rohan.size();j++){
// // // // 		if(rohan[j]==arr1[i]){
// // // // 			continue;
// // // // 		}
// // // // 		else{
// // // // 			cout<<"No"<<endl;
// // // // 			count=1;
// // // // 			break;
// // // // 		}
// // // // 	}
// // // // }
// // // // if(count==0){
// // // // 	cout<<"Yes"<<endl;
// // // // }


// // // // return 0;
// // // // }

// // // //AUTHOR:BlackBox Inc.//
// // // #include<bits/stdc++.h>
// // // #include<unordered_map>
// // // #include<tr1/unordered_map>
// // // #define ll long long
// // // #define ull unsigned long long
// // // #define vi vector<int>
// // // #define vlli vector<long long int>
// // // #define vvi vector<vector<int>>
// // // #define vpii vector<pair<int,int>>
// // // #define vs vector<string>
// // // #define lin1(x) ll int x; x = scan();
// // // #define lin2(x,y) ll int x, y; x = scan(), y = scan();
// // // #define lin3(x,y,z) ll int x, y, z; x = scan(), y = scan(), z = scan();
// // // #define pb(x) push_back(x)
// // // #define makep(x,y) make_pair(x,y)
// // // #define mx(a,b) (a)>(b)?(a):(b)
// // // #define mn(a,b) (a)<(b)?(a):(b)
// // // #define fori(s,e) for(i=s;i<=e;i++)
// // // #define forj(s,e) for(j=s;j<=e;j++)
// // // #define fork(s,e) for(k=s;k<=e;k++)
// // // #define rep(i,s,e) for(int i=s;i<=e;i++)
// // // #define brep(i,s,e) for(int i=s;i>=e;i--)
// // // #define all(x) x.begin(),x.end()
// // // #define mem(x,y) memset(x,y,sizeof(x));
// // // #define bits1(x) __builtin_popcount(x)
// // // #define pi 3.14159265358979323846264338327950
// // // #define MOD7 1000000007
// // // #define MOD9 1000000009
// // // #define fast std::ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
// // // using namespace std;
// // // using namespace std::tr1;

// // // int main()
// // // {
// // // #ifdef RAHUL
// // //     freopen("input.txt","r",stdin);
// // // #endif

// // // std::vector<int> v;
// // // cin>>v;

// // // return 0;
// // // }
// // //AUTHOR:BlackBox Inc.//
// // #include<bits/stdc++.h>
// // #include<unordered_map>
// // #include<tr1/unordered_map>
// // #define ll long long
// // #define ull unsigned long long
// // #define vi vector<int>
// // #define vlli vector<long long int>
// // #define vvi vector<vector<int>>
// // #define vpii vector<pair<int,int>>
// // #define vs vector<string>
// // #define lin1(x) ll int x; x = scan();
// // #define lin2(x,y) ll int x, y; x = scan(), y = scan();
// // #define lin3(x,y,z) ll int x, y, z; x = scan(), y = scan(), z = scan();
// // #define pb(x) push_back(x)
// // #define makep(x,y) make_pair(x,y)
// // #define mx(a,b) (a)>(b)?(a):(b)
// // #define mn(a,b) (a)<(b)?(a):(b)
// // #define fori(s,e) for(i=s;i<=e;i++)
// // #define forj(s,e) for(j=s;j<=e;j++)
// // #define fork(s,e) for(k=s;k<=e;k++)
// // #define rep(i,s,e) for(int i=s;i<=e;i++)
// // #define brep(i,s,e) for(int i=s;i>=e;i--)
// // #define all(x) x.begin(),x.end()
// // #define mem(x,y) memset(x,y,sizeof(x));
// // #define bits1(x) __builtin_popcount(x)
// // #define pi 3.14159265358979323846264338327950
// // #define MOD7 1000000007
// // #define MOD9 1000000009
// // #define fast std::ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
// // using namespace std;
// // using namespace std::tr1;

// // int main()
// // {
// // #ifdef RAHUL
// //     freopen("input.txt","r",stdin);
// // #endif


// // int a, b;
// // cin>>a>>b;
// // if(a==b or b>a){
// // 	cout<<"unsafe"<<"\n";
// // }
// // else{
// // 	cout<<"safe"<<"\n";
// // }

// // return 0;
// // }
// //AUTHOR:BlackBox Inc.//
// #include<bits/stdc++.h>
// #include<unordered_map>
// #include<tr1/unordered_map>
// #define ll long long
// #define ull unsigned long long
// #define vi vector<int>
// #define vlli vector<long long int>
// #define vvi vector<vector<int>>
// #define vpii vector<pair<int,int>>
// #define vs vector<string>
// #define lin1(x) ll int x; x = scan();
// #define lin2(x,y) ll int x, y; x = scan(), y = scan();
// #define lin3(x,y,z) ll int x, y, z; x = scan(), y = scan(), z = scan();
// #define pb(x) push_back(x)
// #define makep(x,y) make_pair(x,y)
// #define mx(a,b) (a)>(b)?(a):(b)
// #define mn(a,b) (a)<(b)?(a):(b)
// #define fori(s,e) for(i=s;i<=e;i++)
// #define forj(s,e) for(j=s;j<=e;j++)
// #define fork(s,e) for(k=s;k<=e;k++)
// #define rep(i,s,e) for(int i=s;i<=e;i++)
// #define brep(i,s,e) for(int i=s;i>=e;i--)
// #define all(x) x.begin(),x.end()
// #define mem(x,y) memset(x,y,sizeof(x));
// #define bits1(x) __builtin_popcount(x)
// #define pi 3.14159265358979323846264338327950
// #define MOD7 1000000007
// #define MOD9 1000000009
// #define fast std::ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
// using namespace std;
// using namespace std::tr1;

// int main()
// {
// #ifdef RAHUL
//     freopen("input.txt","r",stdin);
// #endif

//     long a,b,c,d;

// cin>>a>>b>>c>>d;
//     if(a-c>0 and b-d>0)
//     {
//     	cout<<"Yes"<<"\n";
//     }
//     else{
//     	cout<<"No"<<"\n";
//     }

//     return 0;
// }

//AUTHOR:BlackBox Inc.//
#include<bits/stdc++.h>
#include<unordered_map>
#include<tr1/unordered_map>
#define ll long long
#define ull unsigned long long
#define vi vector<int>
#define vlli vector<long long int>
#define vvi vector<vector<int>>
#define vpii vector<pair<int,int>>
#define vs vector<string>
#define lin1(x) ll int x; x = scan();
#define lin2(x,y) ll int x, y; x = scan(), y = scan();
#define lin3(x,y,z) ll int x, y, z; x = scan(), y = scan(), z = scan();
#define pb(x) push_back(x)
#define makep(x,y) make_pair(x,y)
#define mx(a,b) (a)>(b)?(a):(b)
#define mn(a,b) (a)<(b)?(a):(b)
#define fori(s,e) for(i=s;i<=e;i++)
#define forj(s,e) for(j=s;j<=e;j++)
#define fork(s,e) for(k=s;k<=e;k++)
#define rep(i,s,e) for(int i=s;i<=e;i++)
#define brep(i,s,e) for(int i=s;i>=e;i--)
#define all(x) x.begin(),x.end()
#define mem(x,y) memset(x,y,sizeof(x));
#define bits1(x) __builtin_popcount(x)
#define pi 3.14159265358979323846264338327950
#define MOD7 1000000007
#define MOD9 1000000009
#define fast std::ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
using namespace std;
using namespace std::tr1;

int main()
{
#ifdef RAHUL
    freopen("input.txt","r",stdin);
#endif



    long long n;
    cin>>n;
    string arr[n];
    std::map<string, int> map;
    for (int i = 0; i < n; ++i)
    {
    	cin>>arr[i];
    	map[arr[i]]++;
    	/* code */
    }
    long long count=0;

    for(auto x:map){
    	count++;
    }
    cout<<count<<endl;

    return 0;
}