stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;



#define ll long long

#define li long int



int n;

li a[200005],f[200005];



int main(){

    ios_base::sync_with_stdio(0);

    cin.tie(0);

    cout.tie(0);

    cin>>n;

    for(int i=1;i<=n;i++){

        cin>>a[i];

    }



    sort(a+1,a+1+n);

    for(int i=2;i<=n;i++){

        if(a[i]==a[i-1]){

            cout<<"NO";

            return 0;

        }

    }

    cout<<"YES";

    return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.34940954515545x):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200000];

int main()

{

	int i,n,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

	  scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

	   if(a[i]==a[i+1])

	   {

	      flag=1;

	      break;

	   }

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;	

 }
// Slower C++ solution:




#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>

#include <ext/pb_ds/tree_policy.hpp>

using namespace std;

using namespace __gnu_pbds;

 

#define watch(x) cout<<(#x)<<"="<<(x)<<'\n'

#define mset(d,val) memset(d,val,sizeof(d))

#define setp(x) cout<<fixed<<setprecision(x)

#define forn(i,a,b) for(int i=a;i<b;i++)

#define fore(i,a,b) for(int i=a;i<=b;i++)

#define pb push_back

#define mp make_pair

#define F first

#define S second

#define INF ll(1e18)

#define MOD 998244353

#define pqueue priority_queue

#define fbo find_by_order

#define ook order_of_key

typedef long long ll;

typedef pair<ll,ll> ii;

typedef vector<ll> vi;

typedef vector<ii> vii;

typedef long double ld;

typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update> pbds;

 

#define MAXN 1000000007

 

 

int main() {

	ll n;

	cin>>n;

	ll arr[n];

	for (ll i=0;i<n;i++) {

		cin>>arr[i];

		

	}

	ll counter=0;

	sort(arr,arr+n);

	for (ll i=0;i<n-1;i++) {

		if (arr[i]==arr[i+1]) {

			counter=1;

			

		}

		

		

	}

	if (counter) {

		cout<<"NO";

	}

	else {

		cout<<"YES";

	}

}

	




// Faster C++ solution for the same problem (measured speedup: 5.274639888977235x):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200000];

int main()

{

	int i,n,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

	  scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

	   if(a[i]==a[i+1])

	   {

	      flag=1;

	      break;

	   }

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;	

 }
// Slower C++ solution:
#include <iostream>

#include <algorithm>

#include <stdio.h>

#include <string>

#include <string.h>

#include <math.h>

#include<map>

using namespace std;

#define debug freopen("in.txt","r",stdin),freopen("out.txt","w",stdout);

#define ios ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);

#define PI acos(-1)

typedef long long ll;

const int maxn=2e6+10;





map<ll,int> mp;

int main()

{

	ios;

	ll x;

	int N;

	bool bl=0;

	cin>>N;

	for(int i=0;i<N;i++)

	{

		cin>>x;

		if(bl==1)

			continue;

		mp[x]++;

		if(mp[x]>=2)

			bl=1;

	}

	if(bl==1) cout<<"NO";

	else cout<<"YES";

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.375988823881238x):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200000];

int main()

{

	int i,n,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

	  scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

	   if(a[i]==a[i+1])

	   {

	      flag=1;

	      break;

	   }

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;	

 }
// Slower C++ solution:
#include <bits/stdc++.h>

#pragma GCC optimize("O2")

using namespace std;



# define mp make_pair

# define pb push_back

# define PI acos(-1)

# define ff first 

# define ss second 

# define endl '\n'

# define vt vector

# define all(c) (c).begin(), (c).end()

# define rep(i,a,b) for(int i = a ; i < b ; ++i)



typedef long long ll ; 

typedef long double ld ; 

typedef pair<int,int> pii ; 

typedef pair<ll,ll> pll ;



template<class T> bool umin(T& a, const T& b) { return b < a ? a = b, 1 : 0; }

template<class T> bool umax(T& a, const T& b) { return a < b ? a = b, 1 : 0; }



const int MOD = 1e9+9 ;

const ll inf = 1e18 ;  

const ll mod = 1e9+7 ;  



ll nCr(ll n,ll r){ll t=1;if(r>n)return 0;if(r>n-r)r=n-r;for(ll i=0;i<r;i++){t*=(n-i);t/=(i+1);}return t;}

ll power(ll a, ll n) { ll r=1;while(n){if(n&1)r=(r*a)%MOD;n>>=1;a=(a*a)%MOD;}return r%MOD;}







vt<pii> dir =  {{-1,0} , {1, 0} , {0,-1} , {0,1}} ; 



// ==========Start Here==============



int main()

{

	ios_base::sync_with_stdio(false);

	cin.tie(NULL) ; 

 		

 	int n ; 

 	cin >> n ; 

 	map<int,int> present ;

 	bool ok = 1 ; 

 	vt<int> a(n) ; 

 	rep(i,0,n) {

 		cin >> a[i] ; 

 		if(present[a[i]]) 

 			ok = 0 ; 

 		present[a[i]]++; 

 	}

 	if(ok) {

 		cout << "YES" ; 

 	} else {

 		cout << "NO" ; 

 	}





	return 0 ; 

}

// Faster C++ solution for the same problem (measured speedup: 5.367952379610066x):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200000];

int main()

{

	int i,n,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

	  scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

	   if(a[i]==a[i+1])

	   {

	      flag=1;

	      break;

	   }

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;	

 }
// Slower C++ solution:
#include<iostream>

#include <bits/stdc++.h>

#include<algorithm>

#include <cstring>

#define endl "\n"

#define SRK ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);

#define EPS 1e-6

typedef long long ll;

using namespace std;







int main()

{

    SRK;

    int n,x,i;

    cin >> n;

    set <int> st;

    for (i = 0; i < n; i++)

    {

        cin >> x;

        st.insert(x);

    }

    if (st.size() == n)

    {

        cout << "YES\n";

    }

    else

    {

        cout << "NO\n";

    }







}


// Faster C++ solution for the same problem (measured speedup: 5.362009046925175x):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200000];

int main()

{

	int i,n,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

	  scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

	   if(a[i]==a[i+1])

	   {

	      flag=1;

	      break;

	   }

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;	

 }
// Slower C++ solution:
#include <bits/stdc++.h>



using namespace std;



typedef long long ll;



#define faster ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0)

#define read freopen("in.txt","r",stdin)

#define write freopen("out.txt","w",stdout)

#define mem(x,n) memset(x,n,sizeof(x))

#define all(x) x.begin(), x.end()

#define endl "\n"



int main()

{

	faster;



	int n;

	cin >> n;



	set<int> a;

	for(int i = 0; i < n; i++){

		int in;

		cin>>in;

		a.insert(in);

	}



	if(n == a.size()) cout << "YES" << endl;

	else cout << "NO" << endl;



	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.404465173872149x):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200000];

int main()

{

	int i,n,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

	  scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

	   if(a[i]==a[i+1])

	   {

	      flag=1;

	      break;

	   }

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;	

 }
// Slower C++ solution:
#include <bits/stdc++.h>



typedef long long ll;



using namespace std;



int main()

{

    //ios_base::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL);



    //freopen("in.txt","r",stdin);

    //freopen("out.txt","w",stdout);



    set <int> s;

    int N;

    cin >> N;



    int a;

    for(int i=0; i<N; i++)

    {

        cin >> a;

        s.insert(a);

    }



    if(s.size() != N)

    {

        cout << "NO" << endl;

    }



    else

    {

        cout << "YES" << endl;

    }



}


// Faster C++ solution for the same problem (measured speedup: 5.344905709355774x):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200000];

int main()

{

	int i,n,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

	  scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

	   if(a[i]==a[i+1])

	   {

	      flag=1;

	      break;

	   }

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;	

 }
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

map <int , int> freq;

int n;



int main() {

   scanf("%d" , &n);

   for (int i = 0 ; i < n ; i++) {

      int u; scanf("%d" , &u);

      freq[u]++;

   }

   bool distinct = true;

   for (auto it = freq.begin() ; it != freq.end() ; it++) {

      if ((*it).second > 1) {

         distinct = false;

      }

   }

   printf(distinct ? "YES\n" : "NO\n");

}


// Faster C++ solution for the same problem (measured speedup: 5.278050242471896x):
#include<stdio.h>

#include<algorithm>

using namespace std;

int a[200010];

int main()

{

	int n,i,flag=0;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

		scanf("%d",&a[i]);

	}

	sort(a,a+n);

	for(i=0;i<n-1;i++)

	{

		if(a[i]==a[i+1])

		{

			flag=1;

			break;

		}

	}

	if(flag==1)

	{

		printf("NO\n");

	}

	else

	{

		printf("YES\n");

	}

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

map <int , int> freq;

int n;



int main() {

   scanf("%d" , &n);

   for (int i = 0 ; i < n ; i++) {

      int u; scanf("%d" , &u);

      freq[u]++;

   }

   bool distinct = true;

   for (auto it = freq.begin() ; it != freq.end() ; it++) {

      if ((*it).second > 1) {

         distinct = false;

      }

   }

   printf(distinct ? "YES\n" : "NO\n");

}


// Faster C++ solution for the same problem (measured speedup: 4.702292718356423x):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000],flag=1;

	scanf("%d",&N);

	for(int i=0;i<N;i++)

	scanf("%d",&a[i]);

	sort(a,a+N);

	for(int i=1;i<N;i++)

	{

		if(a[i]==a[i-1])

		{

			flag=0;

			break;

		}

	}

	if(flag==1)	printf("YES\n");

	else	printf("NO\n");

}
// Slower C++ solution:
#include<iostream>

#include<stdio.h>

#include<string.h>

#include<string>

#include<algorithm>

#include<map>

using namespace std;

map<int,int>cnt;

int main()

{

	int n;

	cin >>n;

	while(n--)

	{

		int  a;

		cin>>a;

		cnt[a]++;

	}

	int flag=0;

	for(map<int ,int>::iterator it=cnt.begin();it!=cnt.end();it++)

	{

		if(it->second!=1)

		{

			flag=1;

			break;

		}

		

	}

	if(flag)

	printf("NO\n");

	else

	printf("YES\n");

	return 0;

 } 

// Faster C++ solution for the same problem (measured speedup: 4.705774748224517x):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000],flag=1;

	scanf("%d",&N);

	for(int i=0;i<N;i++)

	scanf("%d",&a[i]);

	sort(a,a+N);

	for(int i=1;i<N;i++)

	{

		if(a[i]==a[i-1])

		{

			flag=0;

			break;

		}

	}

	if(flag==1)	printf("YES\n");

	else	printf("NO\n");

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

map <int,int>frq;

int n;



int main()

{

    cin>>n;

    while (n--)

    {

        int u;

        cin>>u;

        frq[u]++;

    }

    bool dis = true;



    for (auto  it = frq.begin(); it != frq.end(); it++)

    {

        if ((*it).second>1)

        {

            dis = false;

        }

        

    }



    if (dis)

    {

        cout<<"YES"<<endl;

    }else

    {

        cout<<"NO"<<endl;

    }

    

    

    



    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 4.726899919308127x):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000],flag=1;

	scanf("%d",&N);

	for(int i=0;i<N;i++)

	scanf("%d",&a[i]);

	sort(a,a+N);

	for(int i=1;i<N;i++)

	{

		if(a[i]==a[i-1])

		{

			flag=0;

			break;

		}

	}

	if(flag==1)	printf("YES\n");

	else	printf("NO\n");

}
// Slower C++ solution:
#include <bits/stdc++.h>



#define ll long long



using namespace std;



map<ll, bool>mp;



int main()

{

    bool f = false;

    int n;

    cin >> n;

    ll arr[n];

    cin >> arr[0];

    mp[ arr[0] ] = true;

    for(int i = 1; i < n; i++)

    {

        cin >> arr[i];

        if( mp[ arr[i] ] )

            f = true;

        mp [ arr[i] ] = true;

    }

    if( f )

        cout << "NO" << endl;

    else cout << "YES" << endl;



   return 0;



}


// Faster C++ solution for the same problem (measured speedup: 4.740271762442761x):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000],flag=1;

	scanf("%d",&N);

	for(int i=0;i<N;i++)

	scanf("%d",&a[i]);

	sort(a,a+N);

	for(int i=1;i<N;i++)

	{

		if(a[i]==a[i-1])

		{

			flag=0;

			break;

		}

	}

	if(flag==1)	printf("YES\n");

	else	printf("NO\n");

}
// Slower C++ solution:
#include<iostream>

#include<algorithm>

using namespace std;

int main(){

	int n;

	int a[200000];

	cin>>n;

	for(int i=0;i<n;i++){

		cin>>a[i];

		

		

	}

	sort(a,a+n);

	for(int i=0;i<n;i++){

		if(a[i]==a[i-1]){

			cout<<"NO"<<endl;

			return 0;

		}

	}

	cout<<"YES"<<endl;

	

	

	return 0;

} 

// Faster C++ solution for the same problem (measured speedup: 4.783650546550815x):
#include<cstdio>

#include<algorithm>

using namespace std;

int main()

{

	int N,a[200000],flag=1;

	scanf("%d",&N);

	for(int i=0;i<N;i++)

	scanf("%d",&a[i]);

	sort(a,a+N);

	for(int i=1;i<N;i++)

	{

		if(a[i]==a[i-1])

		{

			flag=0;

			break;

		}

	}

	if(flag==1)	printf("YES\n");

	else	printf("NO\n");

}
// Slower C++ solution:
#include <cstdio>

#include <algorithm>

#include <cmath>

#include <set>



int main()

{

	std::set<int> set;

	int n;

	scanf("%d", &n);

	for (int i = 0; i < n; ++i)

	{

		int a;

		scanf("%d", &a);

		if (set.count(a))

		{

			puts("NO");

			return 0;

		}

		set.insert(a);

	}

	puts("YES");

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 4.366539990727068x):
#include <cstdio>

#include <algorithm>



int main()

{

	int n;

	scanf("%d", &n);

	int a[200000];

	for (int i = 0; i < n; ++i)

    {

		scanf("%d", a + i);

    }

	std::sort(a, a + n);

	for (int i = 0; i < n - 1; ++i)

    {

		if (a[i] == a[i + 1])

        {

			puts("NO");

			return 0;

        }

    }

	puts("YES");

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



const int N = 1e5+7;

vector<int> adj[N];



int dfs(int u, int par)

{

    int gr = 0;

    for (auto v : adj[u])

        if (v!=par)

            gr ^= dfs(v, u);

    return 1 + gr;

}



int main()

{

  //  ios::sync_with_stdio(0);

  //  cin.tie(0);



    int t;

    t=1;



    while(t--) {

        fill(adj, adj+N, vector<int>());



        int n;

        cin>>n;



        for (int i=1; i<n; i++) {

            int u, v;

            cin>>u>>v;

            adj[u].push_back(v);

            adj[v].push_back(u);

        }

        int gr = dfs(1, -1) - 1;

        cout<<(gr ? "Alice\n" : "Bob\n");

    }

}


// Faster C++ solution for the same problem (measured speedup: 19.848057193429923x):
#include<cstdio>

#include<cstring>

#include<algorithm>

using namespace std;

typedef long long ll;

const int N=2e6+5;

struct node{

    int u,v,nxt;

}edge[N];

int head[N],mcnt;

void add_edge(int u,int v){

    mcnt++;

    edge[mcnt].u=u;

    edge[mcnt].v=v;

    edge[mcnt].nxt=head[u];

    head[u]=mcnt;

}

int g[N];

int SG(int u,int fa=0){

    g[u]=0;

    for(int i=head[u];i;i=edge[i].nxt){

        int v=edge[i].v;

        if(v==fa)

            continue ;

        g[u]^=SG(v,u)+1;

    }

    return g[u];

}

int n;

int main()

{

    scanf("%d",&n);

    for(int i=1;i<n;i++){

        int u,v;

        scanf("%d%d",&u,&v);

        add_edge(u,v);

        add_edge(v,u);

    }

    puts(SG(1)?"Alice":"Bob");

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



const int N = 1e5+10;

int n, nim[N];

vector<int> g[N];



void dfs(int u, int f) {

	for(int v : g[u]) if(v != f)

		dfs(v,u);

	for(int v : g[u]) if(v != f) {

		nim[u] ^= (nim[v] + 1);

	}

}



int main() {

	scanf("%d", &n);

	for(int i = 1; i < n; i++) {

		int u, v;

		scanf("%d %d", &u, &v);

		g[u].push_back(v);

		g[v].push_back(u);

	}

	dfs(1,-1);

	if(nim[1] == 0) puts("Bob");

	else puts("Alice");

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 18.62809259268748x):
#include<cstdio>

#include<cstring>

#include<algorithm>

using namespace std;

typedef long long ll;

const int N=2e6+5;

struct node{

    int u,v,nxt;

}edge[N];

int head[N],mcnt;

void add_edge(int u,int v){

    mcnt++;

    edge[mcnt].u=u;

    edge[mcnt].v=v;

    edge[mcnt].nxt=head[u];

    head[u]=mcnt;

}

int g[N];

int SG(int u,int fa=0){

    g[u]=0;

    for(int i=head[u];i;i=edge[i].nxt){

        int v=edge[i].v;

        if(v==fa)

            continue ;

        g[u]^=SG(v,u)+1;

    }

    return g[u];

}

int n;

int main()

{

    scanf("%d",&n);

    for(int i=1;i<n;i++){

        int u,v;

        scanf("%d%d",&u,&v);

        add_edge(u,v);

        add_edge(v,u);

    }

    puts(SG(1)?"Alice":"Bob");

}
// Slower C++ solution:
#include<bits/stdc++.h>

#define int long long

#define rint register int

using namespace std;



template<typename tp> inline void read(tp &x) {

  x = 0; char c = getchar(); int f = 0;

  for (; c < '0' || c > '9'; f |= c == '-', c = getchar());

  for (; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + c - '0', c = getchar());

  if (f) x = -x;

}

int n;

vector<int> g[233333];



inline int dfs(int u, int fat) {

  int now = 0;

  for (int v : g[u])

    if (v != fat)

      now ^= 1 + dfs(v, u);

  return now;

}



main(void) {

  read(n);

  for (int i = 2; i <= n; i ++) {

    int x, y; read(x); read(y);

    g[x].push_back(y); g[y].push_back(x);

  }

  puts( dfs(1, 0) ? "Alice" : "Bob" );

}


// Faster C++ solution for the same problem (measured speedup: 39.290534962404514x):
#include<cstdio>

#include<cstring>

#include<algorithm>

using namespace std;

typedef long long ll;

const int N=2e6+5;

struct node{

    int u,v,nxt;

}edge[N];

int head[N],mcnt;

void add_edge(int u,int v){

    mcnt++;

    edge[mcnt].u=u;

    edge[mcnt].v=v;

    edge[mcnt].nxt=head[u];

    head[u]=mcnt;

}

int g[N];

int SG(int u,int fa=0){

    g[u]=0;

    for(int i=head[u];i;i=edge[i].nxt){

        int v=edge[i].v;

        if(v==fa)

            continue ;

        g[u]^=SG(v,u)+1;

    }

    return g[u];

}

int n;

int main()

{

    scanf("%d",&n);

    for(int i=1;i<n;i++){

        int u,v;

        scanf("%d%d",&u,&v);

        add_edge(u,v);

        add_edge(v,u);

    }

    puts(SG(1)?"Alice":"Bob");

}
// Slower C++ solution:
#include<bits/stdc++.h>

int n;

std::vector<int> g[100005];

int dfs(int u,int fa){

	int sg=0;

	for(int v:g[u])if(v!=fa)sg^=dfs(v,u)+1;

	return sg;

}

int main(){

	scanf("%d",&n);

	for(int i=1,x,y;i<n;i++){

		scanf("%d%d",&x,&y);

		g[x].push_back(y),g[y].push_back(x);

	}

	puts(dfs(1,0)?"Alice":"Bob");

}


// Faster C++ solution for the same problem (measured speedup: 18.982611120038662x):
#include <cstdio>



int read()

{

  int x=0,f=1;

  char ch=getchar();

  while((ch<'0')||(ch>'9'))

    {

      if(ch=='-')

        {

          f=-f;

        }

      ch=getchar();

    }

  while((ch>='0')&&(ch<='9'))

    {

      x=x*10+ch-'0';

      ch=getchar();

    }

  return x*f;

}



const int maxn=100000;



int n,pre[maxn*2+10],now[maxn+10],son[maxn*2+10],tot,f[maxn+10];



int ins(int a,int b)

{

  pre[++tot]=now[a];

  now[a]=tot;

  son[tot]=b;

  return 0;

}



int search(int u,int fa)

{

  for(int i=now[u]; i; i=pre[i])

    {

      int v=son[i];

      if(v==fa)

        {

          continue;

        }

      search(v,u);

      f[u]^=(f[v]+1);

    }

  return 0;

}



int main()

{

  n=read();

  for(int i=1; i<n; ++i)

    {

      int a=read(),b=read();

      ins(a,b);

      ins(b,a);

    }

  search(1,0);

  puts(f[1]?"Alice":"Bob");

  return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

int n;

std::vector<int> g[100005];

int dfs(int u,int fa){

	int sg=0;

	for(int v:g[u])if(v!=fa)sg^=dfs(v,u)+1;

	return sg;

}

int main(){

	scanf("%d",&n);

	for(int i=1,x,y;i<n;i++){

		scanf("%d%d",&x,&y);

		g[x].push_back(y),g[y].push_back(x);

	}

	puts(dfs(1,0)?"Alice":"Bob");

}


// Faster C++ solution for the same problem (measured speedup: 3.5863055072636625x):
#include<iostream>

#include<cstdio>

#define N 200009

using namespace std;

double ans;

int head[N],tot,sg[N],n;

inline int rd(){

	int x=0;char c=getchar();bool f=0;

	while(!isdigit(c)){if(c=='-')f=1;c=getchar();}

	while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=getchar();}

	return f?-x:x;

}

struct edge{int n,to;}e[N<<1];

inline void add(int u,int v){e[++tot].n=head[u];e[tot].to=v;head[u]=tot;}

void dfs(int u,int fa){

	for(int i=head[u];i;i=e[i].n)if(e[i].to!=fa){

		int v=e[i].to;dfs(v,u);

		sg[u]^=(sg[v]+1);

	}

}

int main(){

    n=rd();int u,v;

	for(int i=1;i<n;++i){

		u=rd();v=rd();

		add(u,v);add(v,u);

	}

	dfs(1,0);

	if(sg[1])puts("Alice");

	else puts("Bob");

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

#define MAX 300000

vector<int>g[MAX];

int dfs(int u,int p){

    int l=0;

    for(int v:g[u]){

        if(v!=p){

         l^=1+dfs(v,u);   

        }

    }

    return l;

}

int main() {

	int n,u,v;

	cin>>n;

	for(int i=0;i<n-1;i++){

	    cin>>u>>v;

	    g[u].push_back(v);

	    g[v].push_back(u);

	}

	cout<<(dfs(1,0)?"Alice":"Bob");

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 49.65476120883561x):
#include<cstdio>

#include<cstring>

#include<algorithm>

#include<cmath>

#include<vector>

#define SF scanf

#define PF printf

#define MAXN 200010

using namespace std;

int n;

struct node{

	int x;

	node *nxt;	

}edge[MAXN*2];

node *head[MAXN],*ncnt=edge;

void add_edge(int x,int y){

	ncnt++;

	ncnt->x=y;

	ncnt->nxt=head[x];

	head[x]=ncnt;

}

int sg[MAXN];

void dfs(int x,int fa){

	for(node *v=head[x];v!=NULL;v=v->nxt){

		int u=v->x;

		if(u==fa)

			continue;

		dfs(u,x);

		sg[x]^=(sg[u]+1);	

	}

}

int main(){

	SF("%d",&n);

	int u,v;

	for(int i=1;i<n;i++){

		SF("%d%d",&u,&v);

		add_edge(u,v);

		add_edge(v,u);

	}

	dfs(1,0);

	if(sg[1]==0)

		PF("Bob");

	else

		PF("Alice");

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

#define MAX 300000

vector<int>g[MAX];

int dfs(int u,int p){

    int l=0;

    for(int v:g[u]){

        if(v!=p){

         l^=1+dfs(v,u);   

        }

    }

    return l;

}

int main() {

	int n,u,v;

	cin>>n;

	for(int i=0;i<n-1;i++){

	    cin>>u>>v;

	    g[u].push_back(v);

	    g[v].push_back(u);

	}

	cout<<(dfs(1,0)?"Alice":"Bob");

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 2.658858958623229x):
#include <bits/stdc++.h>

using namespace std;

typedef long long i64;

const int MAXN = 100000 + 10;



int N;

vector <int> Adj[MAXN];



int DFS(int cur, int fa)

{

	int SG = 0;



	for(const int & x : Adj[cur])

		if(x != fa)

			SG ^= (1 + DFS(x, cur));



	return SG;

}



int main()

{

	cin >> N ;

	for(int i = 1; i < N; i++)

	{

		int u, v;

		cin >> u >> v ;

		Adj[u].push_back(v);

		Adj[v].push_back(u);

	}



	cout << (DFS(1, 0) == 0 ? "Bob" : "Alice") << endl ;



	return 0;

}