#include<stdio.h>

int main(){

        int ball;
	int tag=1;
        int a,j,i,k,l=0;

        scanf("%d",&ball);

        int size[1000];
	int si[1000];

        for(i=0; i<ball; i++){
            scanf("%d",&size[i]);
        }

	for (i = 0; i < ball; i++) {
        for (j = i + 1; j < ball;) {
         if (size[j] == size[i]) {
            for (k = j; k < ball; k++) {
               size[k] = size[k + 1];
            }
            ball--;
         } else
            j++;
      }
   }

	for (i = 0; i < ball; i++)
        {

            for ( j = i + 1; j < ball; j++)
            {

                if (size[i] > size[j])
                {

                     a =  size[i];
                    size[i] = size[j];
                    size[j] = a;

                }

	    }
       }

 for ( i = 0; i < ball; i++) {

            if ((size[i + 1] - size[i]) == 1 && (size[i + 2] - size[i]) == 2) {
                     tag=1;
		     break;
                }

	    else tag=0;
           }

 	    if(tag==1)printf("YES");
 	    else if(tag==0)printf("NO");

        return 0;

        }

#include <stdio.h>

void quicksort(int a[],int first,int last);

int main(){
	int n, i, j, k, sol;
	scanf("%d", &n);
	int balls[n-1];
	for(i=0; i<n; i++){
		scanf("%d", &balls[i]);
	}
	quicksort(balls, 0, n-1);
	for(i=0; i < n-2; i++){
		sol = 0;
		for(j = i+1; j < n-1; j++){
			if(balls[j] == balls[i]+1){
				sol++;
				for(k = i+2; k < n; k++){
					if(balls[k] == balls[i]+2){
						sol++;
						i=j=k=n;
					}
				}
			}
		}
	}
	if(sol == 2){
		printf("YES");
	}else{
		printf("NO");
	}
	return 0;
}

void quicksort(int a[],int first,int last)
{
  int pivot,j,temp,i;

      if(first<last)
  {
         pivot=first;
         i=first;
         j=last;

         while(i<j)
  {
             while(a[i]<=a[pivot]&&i<last)
             i++;
             while(a[j]>a[pivot])
             j--;

             if(i<j)
   {
                 temp=a[i];
                  a[i]=a[j];
                  a[j]=temp;
             }
         }

         temp=a[pivot];
         a[pivot]=a[j];
         a[j]=temp;

         quicksort(a,first,j-1);
         quicksort(a,j+1,last);

    }
}

//problema6
#include <stdio.h>

int main(){
    int n,i,k,j,b=0;
    scanf("%d",&n);
    int v[n];
    for (i=0; i<n; i++){
        scanf("%d",&v[i]);
    }
    for(i=0;i<n;i++){
        for(j=0;j<n;j++){
            for(k=0;k<n;k++){
                if(v[i]==v[j]+1){
                    if(v[i]==v[k]+2){
                        b=1;
                        break;
                    }
                }
            }
        }
    }
    if(b)
        printf("YES");
    else
        printf("NO");
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int cmpfunc (const void * a, const void * b) {
   return ( *(int*)a - *(int*)b );
}

int main () {
	int n,i,bd=1,j;
	scanf("%d",&n);
   	int v[n];
	for( i = 0 ; i < n; i++ ) {
		scanf("%d",&v[i]);
	}
	qsort(v, n, sizeof(int), cmpfunc);
	for (i = 0; i < n - 2; i++){
        for (j = i + 1; j < n - 1; j++){
                if(v[i] + 1==v[j] && v[i] + 2==v[j+1]){
                    bd=0;
                }
        }
	}
	if(bd==0){
		printf("YES");
	}else{
		printf("NO");
	}
	return(0);
}

//problema6
#include <stdio.h>

int main(){
    int n,i,k,j,b=0;

    scanf("%d",&n);//se ingresan los datos

    int v[n];

    for (i=0; i<n; i++)
    {
        scanf("%d",&v[i]);
    }
    for(i=0;i<n;i++){//comprobamos si los tama�os de las bolas cumplen lo que pide el problema
        for(j=0;j<n;j++){
            for(k=0;k<n;k++){
                if(v[i]==v[j]+1){
                    if(v[i]==v[k]+2){
                        b=1;
                        break;
                    }
                }
            }
        }
    }
    if(b)
        printf("YES");//si cumple
    else
        printf("NO");//no cumple
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int compare(const void *a, const void *b) {
	int ia = *(int *) a;
	int ib = *(int *) b;

	return ia - ib;
}

int main() {
	int i, k, n, t, yes;
	static int tt[50], used[1001];

	scanf("%d", &n);
	k = 0;
	for (i = 0; i < n; i++) {
		scanf("%d", &t);
		if (!used[t])
			tt[k++] = t;
		used[t] = 1;
	}
	qsort(tt, k, sizeof(*tt), compare);
	yes = 0;
	for (i = 2; i < k; i++)
		if (tt[i - 2] + 1 == tt[i - 1] && tt[i - 1] + 1 == tt[i]) {
			yes = 1;
			break;
		}
	printf("%s\n", yes ? "YES" : "NO");
	return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void q_sort(int *a, int left, int right)
{
    int i, j, k, t;
    if (left < right) {
        i = k = left;
        j = right + 1;
        while (1) {
            while (a[++i] < a[k]);
            while (a[--j] > a[k]);
            if (i >= j) break;
            t = a[i];
            a[i] = a[j];
            a[j] = t;
        }
        t = a[k];
        a[k] = a[j];
        a[j] = t;
        q_sort(a, left, j-1);
        q_sort(a, j+1, right);
    }
}

int visit(int *a, int i, int j)
{
    if (j>1 && (a[i] + 1) == a[i+1]) {
        //printf("%d -> %d\n", a[i], a[i+1]);
        return visit(a, i+1, j-1);
    } else if (j>1 && (a[i]) == a[i+1]) {
        return visit(a, i+1, j);
    }
    if (j == 1) return 1;
    return 0;
}
int main(void)
{
    int a[1000];
    int n;
    int i, j;

    memset(a, 0, sizeof(a));

    scanf("%d", &n);
    for (i=0; i<n; i++)
        scanf("%d", &a[i]);

    i = 0;
    q_sort(a, i, n-1);

#if 0
    for (i=0; i<n; i++)
        printf("%d ", a[i]);
    printf("\n");
#endif

    for (i=0; i<(n-2); i++) {
        j = visit(a, i, 3);
        if (j) {
            printf("Yes\n");
            return 0;
        }
    }
    printf("No\n");

    return 0;
}

#include <stdio.h>
void swap (int *v, int i, int j);
void quick (int *v, int ini, int fin);

int main (){
	//TAMAÑO ARREGLO
	int N;
	scanf ("%d", &N);
	//CARGAR ARREGLO
	int V[N];
	int cont;
	for (cont = 0; cont < N; cont++){
		scanf ("%d", &V[cont]);
	}
	//ORDENAR ARREGLO
	quick(V, 0, N-1);
	//BUSCAR MENOR
	char *R[2] = {"YES", "NO"};
	int a, cont2;
	a=1;
	for (cont = 0; cont < N-2; cont++){
		if( (V[cont+1]-V[cont]) == 1){
			for (cont2 = cont+2; cont2 < N; cont2++){
				if ((V[cont2]-V[cont+1]) == 1){
					a = 0;
					cont2 = N;
					cont = N;
				}
			}
		}
	}
	printf ("%s", R[a]);

	return 0;
}
void swap (int *v, int i, int j){
	int aux;

	aux = *(v+i);
	*(v+i) = *(v+j);
	*(v+j) = aux;
}
int pivot(int *v, int izq, int der){
	int i, pivote, valor_pivote;

	pivote = izq;
	valor_pivote = *(v+pivote);
	for(i = izq+1; i <=der; i++){
		if (*(v+i) < valor_pivote){
			pivote++;
			swap(v, i, pivote);
		}
	}
	swap(v, izq, pivote);

	return pivote;
}
void quick (int *v, int ini, int fin){
	int pivote;
	if(ini < fin){
		pivote = pivot(v, ini, fin);
		quick(v, ini, pivote-1);
		quick(v, pivote+1, fin);
	}
}

#include<stdio.h>
#define T 1001
int main() {
	//因为ti的值最大是1000，所以我选择用exist方法
	int n;
	scanf("%d",&n);
	char exist[T];
	int i;
	for(i=0;i<T;i++){
		exist[i]=0;
	}
	for(i=0;i<n;i++){
		int t;
		scanf("%d",&t);
		exist[t]=1;
	}
	int count=0;
	for(i=1;i<T;i++){
		if(exist[i]){
			count++;
			if(count>=3){
				printf("YES\n");
				return 0;
			}
		}else{
			count=0;
		}
	}
	printf("NO\n");
	return 0;
}

#include <stdio.h>

int main(){
                                    //este problema trata sobre un oso que posee n pelotas y quiere regalar 3 de ellas
                                    //a sus amigos, pero solo puede regalar 3 pelotas cuyos tama�os sean x-1,x y x+1
    int n=0;                        //n es la cantidad de pelotas que posee el oso
    int i,j;
    int b1=-1;                      //b1 y b2 son dos banderas
    int b2=0;
    scanf("%d",&n);                 //pedimos al usuario que ingrese la cantidad de pelotas
    int v[n];                       //declaramos un vector donde se guardaran los tama�os de las n pelotas
    for(i=0; i<n; i++){
        scanf("%d",&v[i]);          //Insertamos en el vector el tama�o de cada pelota
    }
    for(i=0; i<n; i++){
        b1=-1;                      //inicializamos las banderas al comienzo de cada ciclo con nros negativos diferentes
        b2=-2;                      //
        for(j=0; j<n; j++){         //en este for anidado comparamos el resto del vector con el elemento v[i]
            if(v[i]==(v[j]+1)) {    // si encontramos una pelota con un tama�o mayor en 1 unidad al tama�o de la pelota v[i]
                b1=i;               //cargamos en b1 el indice de dicha pelota
                }
            if(v[i]==(v[j]-1)){     // si encontramos una pelota con un tama�o menor en 1 unidad al tama�o de la pelota v[i]
                b2=i;               //cargamos en b1 el indice de dicha pelota
                }
        }
        if(b2 ==i && b1==i){        //Si ambas banderas son iguales al indice actual significa que se encontraron dos tama�os
            break;                  // x+1 y x-1 en relacion a v[i], entonces salimos del ciclo con break
        }
    }
    if(b1==b2 && b2==i){           //este if controla si se consigui� encontrar las dos pelotas que cumplan la condicion anterior
        printf("YES");              //de ser asi imprime YES, se encontraron 3 pelotas de tama�os x, x+1 y x-1
    }else{
        printf("NO");               //caso contrario imprime NO, mostrando que no se encontraron las pelotas de tama�os
    }                               //buscados
    return 0;
}

#include<stdio.h>
int main() {
    int n;
scanf("%d",&n);

        int a[n];
    int i;
    for(i=0; i<n; i++) {
        scanf("%d",&a[i]);
    }
    int j;
    int swap;
    for (i = 0 ; i < ( n - 1 ); i++)
        {
        for (j = 0 ; j < n - i - 1; j++)
        {
            if (a[j] > a[j+1]) {
                  swap=a[j];
                a[j] = a[j+1];
                a[j+1]=swap;
            }
        }
    }
    int y=0;
    int x=1;
    int temp=a[0];
   for(i=1;i<n;i++)
   {
       int m=a[i]-temp;
       if(m==0)
       {
           temp=a[i];
       }
       else if(m==1)
       {
           x++;
           temp=a[i];
       }
       else
       {
           x=1;
           temp=a[i];
       }
       if(x==3)
       {
           printf("YES\n");
           y=1;
           break;
       }
   }
   if(y==0)
   printf("NO\n");
    return 0;
}

 #include <stdio.h>
#include <stdlib.h>

int asc(const void *p, const void *q);

int main()
{
  int n,i,bandera=0;

  scanf("%d", &n);
  int bolas[n];
  //cargamos los tamanios de las bolas
  for(i=0; i<n; ++i)
    scanf("%d", &bolas[i]);
  //ordenamos
  qsort(bolas, n, sizeof(int), &asc);
  //quitmos los duplicados
  int b=0;
  bolas[b]=bolas[0];
  for(int i=0;i<n;i++)
  {
    if (bolas[b]!=bolas[i])
    {
      b++;
      bolas[b]=bolas[i];
    }
  }
  n = b+1;
  puts("");
  for(i=0; i<n-2; ++i)
  {
    // si hay diferencia de 1 entre el primer elemento en comparacion y el utimo
    // cumple condicion; ademas deben ser distintos
    if(( bolas[i+2] != bolas[i] ) && (( bolas[i+2] - bolas[i]) <= 2 ))
    {
      bandera=1;
      //printf("%d %d %d\n",bolas[i],bolas[i+1],bolas[i+2]);
    }
  }
  printf("%s", bandera? "YES": "NO");
  return 0;
}

//funcion de comparacion
int asc(const void *p, const void *q) {
    int x = *(const int *)p;
    int y = *(const int *)q;
    if (x < y)
        return -1;
    else if (x > y)
        return 1;

    return 0;
}

#include<stdio.h>
#include<stdbool.h>

void quicksort(int arr[], int first, int last)
{
    int i = first, j = last, pivot;
    pivot = arr[(first + last)/2];
    do
    {
        while (arr[i] < pivot){
            i++;
        }
        while(arr[j] > pivot){
            j--;
        }

        if(i <= j)
        {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
    }while(i <= j);
    if(first < j) quicksort(arr, first, j);
    if(last > i) quicksort(arr, i, last);
}

int main(void)
{
    int n, num1, num2, num3, j;
    scanf("%d", &n);
    int array[n];
    for(int i = 0; i < n; i++)
    {
        scanf("%d", &array[i]);
    }
    quicksort(array, 0, n-1);
    for(int i = 0; i < n; i++)
    {
       num1 = array[i];
       for(j = i + 1; j < n && array[j] == array[i]; j++);
       if(j < n)
       {
           num2 = array[j];
            if(num1 + 1 == num2)
            {
                for(j = j + 1; j < n && array[j] == num2; j++);
                if(j < n)
                {
                    num3 = array[j];
                    if(num3 - 2 == num1)
                    {
                        printf("YES");
                        return 0;
                    }
                }
            }
       }
       //printf("%d %d %d\n", num1, num2, num3);
    }
    printf("NO");
    return 0;
}

#include<stdio.h>
#include<stdlib.h>
int cmp(const void *a,const void *b){
	return (*(int *)a - *(int *)b);
}
int main(){
	int n,t[1001],i,j,found=0;
	scanf("%d",&n);
	for(i=0;i<n;++i){
		scanf("%d",&t[i]);
	}
	qsort(t,n,sizeof(int),cmp);
	j=0;

	for(i=1;i<n;++i){
		if(t[i]!=t[j]){
			t[++j] = t[i];
		}
	}
	n = j + 1;
	for(i=0;i<n-2;++i){
		if(t[i+1]==(t[i]+1) && t[i+2]==(t[i+1]+1)){
			found=1;
			break;
		}
	}
	if(found==1){
		printf("YES");
	}else{
		printf("NO");
	}
	return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <math.h>

int cmp( const void * a , const void *b ){
	return ( *(int*)a - *(int*)b );
}

int main(){
	int i,n,balls[100],new_n=0,ballz[100];
	bool flag=false;
	scanf(" %d",&n);
	for ( i=0 ; i<n ; i++ ){
		scanf(" %d",&balls[i]);
	}
	qsort( balls , n , sizeof(int) , cmp );
	for ( i=0 ; i<n ; i++ ){
		if ( i+1 < n && balls[i] != balls[i+1] ){
			ballz[new_n] = balls[i];
			new_n++;
		}
	}
	ballz[new_n] = balls[n-1];
	new_n++;
	for ( i=0 ; i<new_n ; i++ ){
		if ( i+2 < new_n && ballz[i] + 1 == ballz[i+1] && ballz[i+1] + 1 == ballz[i+2] ){
			flag = true;
		}
	}
	/*printf("\n");
	for ( i=0 ; i<new_n ; i++ ){
		printf("%d\t",ballz[i]);
	}
	printf("\n");
	for ( i=0 ; i<n ; i++ ){
		printf("%d\t",balls[i]);
	}*/
	if ( flag == true )
		printf("YES");
	else
		printf("NO");
	return 0;
}

#include<stdio.h>
main()
{
    int n,i,c=0,j,a,b,temp,k=0;
    scanf("%d",&n);
    int arr[n],narr[n];
    for(i=0;i<n;i++)
    {
        scanf("%d",&arr[i]);
    }
    for(i=0;i<n;i++)
    {
        for(j=i+1;j<n;j++)
        {
            if(arr[i]>arr[j])
            {
                temp=arr[i];
                arr[i]=arr[j];
                arr[j]=temp;
            }
        }
    }
    for(i=0;i<n;i++)
    {
        narr[k]=arr[i];
        while(arr[i]==arr[i+1])
        {
            i++;
        }
        k++;
    }

    for(i=0;i<k-1;i++)
    {
        a=narr[i+1]-narr[i];
        b=narr[i+2]-narr[i+1];
        if(a*b==1)
        {
            c=1;
            printf("YES");
            break;
        }
    }
    if(c==0)
    {
        printf("NO");
    }
}

// Bear and the three balls
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

	// solución por fuerza bruta: comparar cada bola con otras dos, si antres de terminar el ciclo hay dos que difieren en menos de 2 en valor absoluto, se puede
	// Si se acaba el ciclo sin encontrar nada, se imprime NO

	int particion (int a[],int ini, int fin);
	void quicksort (int a[],int ini, int fin);
	void swap (int a[],int x,int y);

int main(void){
	int n;
	int *vec;
	int i, cont = 0;

	scanf ( "%d", &n );

	vec = (int*)malloc(n*sizeof(int));

	for ( i = 0; i < n; i++){
			scanf ( "%d", &vec[i] );
	}

	quicksort( vec, 0, n - 1 );

	/*for ( i = 0; i < n; i++ ){
		printf ( "%d - ", vec[i] );
	}*/

	for ( i = 1; i < n; i++ ){
		if ( vec[i - 1] == (vec[i] - 1) )
			cont++;
		else if ( vec[i - 1] != vec[i] )
			cont = 0;
		if ( cont == 2 ){
			printf ( "YES" );
			break;
			//exit(1);
		}
	}

	if ( cont != 2 )
		printf ( "NO" );

	return 0;
}

void quicksort (int a[],int ini, int fin)		//cada vez que se llama a quicksort un nuevo pivot va colocandose en su posicion
{
	int piv;
	if (ini<fin)
	{	//cont++;
		piv=particion(a,ini,fin);
		quicksort(a,ini,piv-1);				//como el pivot ya esta en su ubicacion se divide en dos y se vuelve a llamar
		quicksort(a,piv+1,fin);				//a quicksort pero sin tocar el pivot
	}
}

int particion (int a[],int ini, int fin)		//particion ubica al pivot en su posicion y devulve esa posicion
{
	int pivot,i,j;
	pivot=a[fin];
	i=ini;
	for (j=ini;j<fin;j++)
	{
		if (a[j]<pivot)
		{
			swap(a,j,i);
			i++;
		}
	}
	swap(a,i,fin);
	return i;
}

void swap (int a[],int x,int y)
{
	int aux;
	aux=a[x];
	a[x]=a[y];
	a[y]=aux;
}

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <stdbool.h>
int main()
{
    int n;
    scanf("%d",&n);
    int a[n],i,b[1001];
    memset(b,0,1001*sizeof(int));
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
        b[a[i]]=1;
    }
    int k=0,c[n];
    for(i=0;i<1001;i++)
        if(b[i]==1)
          c[k++]=i;
    for(i=0;i<k-2;i++)
    {
        if(c[i+1]-c[i]==1&&c[i+2]-c[i+1]==1)
            break;
    }
    if(i<k-2)
        printf("YES\n");
    else printf("NO\n");
}

#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<math.h>
#include<ctype.h>

#define MAX( a, b ) ( ( a > b) ? a : b )
#define MIN( a, b ) ( ( a < b) ? a : b )
#define FOR(ii,aa,bb) for(ii=aa;ii<bb;ii++)

int x=0,n=0,s=0,i,j,a[10000],c[10000];
int main () {

	scanf("%d",&n);
	FOR(i,0,n){
		scanf("%d",&a[i]);
		c[a[i]]++;}
	FOR(i,0,10000)
		if(c[i-1]&&c[i]&&c[i+1]){
				printf("YES");return 0;}
	printf("NO");

		return 0;
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

#define lli long long int
#define MAX INT_MAX
#define sd second
#define fs first
#define endll '\n'
#define PI acos(-1)
#define mp make_pair
#define pb push_back
#define best 1000000007
#define FOR(i,a,b) for(int i=a;i<=b;i++)
#define ROF(i,a,b) for(int i=a;i>b;i--)
#define buyuk(a,b) (a<b)? b:a
#define kucuk(a,b) (a<b)? a:b
#define ort(a,b) (a+b)/2
#define carp(a,b) (a)*(b)
#include<stdio.h>
		int main (){

			int i,j,arr[10005],x,min=0,t=0,h[10005]={0};
			scanf("%d",&x);
			for(i=0;i<x;i++){
			scanf("%d",&arr[i]);
			h[arr[i]]++;
			}
		for(i=0;i<1000;i++){
			if(h[i]&&h[i+1]&&h[i+2]){
					printf("YES");
					return 0;}
	}
		printf("NO");
	}

#include <stdio.h>

void ordenar (int a[],int primero,int ultimo){
    int i,j,central;
    double pivote;
    central = (primero+ultimo)/2;
    pivote = a[central];
    i=primero;
    j=ultimo;
    do
    {
        while (a[i]<pivote) i++;
        while (a[j]>pivote) j--;
        if (i<=j)
        {
            int aux;
            aux= a[i];
            a[i]=a[j];
            a[j]=aux;
            i++;
            j--;
        }
    } while (i<=j);
    if (primero<j)
    {
        ordenar (a,primero,j);
    }
    if (i< ultimo)
    {
        ordenar (a,i,ultimo);
    }
}

int main()
{
    int n;
    int i;
    int j;
    int k;

    int BAN=0;
    scanf("%d",&n);
    int size[n];

    for (i=0;i<n;i++)
    {
        scanf("%d",&size[i]);
    }

    ordenar(size,0,n-1);

    for (i=0;i<n-2;i++)
    {
        for (j=i+1;j<n-1;j++)
        {
            for (k=j+1;k<n;k++)
            {
                if (size[i]+1==size[j] && size[j]+1==size[k])
                {
                    BAN=1;
                    j=n;
                    i=n;
                    k=n;
                }
            }
        }
    }
    if (BAN==1)
    {
        printf("YES");
    }else{
        printf("NO");
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
void merge(int *p, int l, int m, int r);
void mergeSort (int *p, int l, int r);

int main(int argc, char const *argv[])
{
	int n, i, h=0,j,k;
	scanf("%d", &n);
	int balls[n];
	for(i = 0; i < n; i++){
		scanf("%d", &balls[i]);
	}
	mergeSort(balls, 0, n-1);
	/*for(i = 0; i < n; i++){
		printf("%d ", balls[i]);
	}*/
	for (i = 0; i < n-2; i++){
		for (j = i+1; j < n-1; j++){
			if (abs(balls[i]-balls[j]) < 3 && balls[i] != balls[j]){
				for (k = j+1; k < n; k++){
					if(abs(balls[i]-balls[k]) < 3 && abs(balls[j] - balls[k]) < 3 && balls[i] != balls[k] && balls[k] != balls[j]){
						if(balls[i] != balls[j] && balls[j] != balls[k] && balls[i] != balls[k]){
							h = 1;
						}else{
							h = 0;
						}
					}
				}
			}
		}
	}

	if (h)
	{
		printf("YES");
	}else{
		printf("NO");
	}

	return 0;
}

void mergeSort (int *p, int l, int r){
	if(l<r){
		int m=(l+r)/2;
		mergeSort(p, l, m);
		mergeSort(p, m+1, r);
		merge(p, l, m, r);

	}
}

void merge(int *p, int l, int m, int r){
	int n1, n2, i, j, k;
	n1=m-l+1;
	n2=r-m;
	int v1[n1], v2[n2];
	for (i=0; i<n1;i++){
		v1[i]=*(p+(l+i));
	}
	for (j=0; j<n2;j++){
		v2[j]= *(p+(j+m+1));
	}
	i=0;
	j=0;
	k=l;
	while(i<n1 && j<n2){
		if(v1[i]<=v2[j]){
			*(p+k)=v1[i];
			i++;
		}else{
			*(p+k)= v2[j];
			j++;
		}
		k++;
	}
	while(i<n1){
		*(p+k)=v1[i];
		i++;
		k++;
	}
	while(j<n2){
		*(p+k)=v2[j];
		k++;
		j++;
	}

}

#include<stdio.h>
int main()
{
          int n,i,j,t,count,a[1001];
          scanf("%d",&n);
          for(i=1;i<=n;i++)
          scanf("%d",&a[i]);
          for(i=1;i<n;i++)
          {
                    for(j=1;j<=n-i;j++)
                    {
                              if(a[j]>a[j+1])
                              {
                                        t=a[j];
                                        a[j]=a[j+1];
                                        a[j+1]=t;
                              }
                    }
          }
          count=1;
          for(i=1;i<n;i++)
          {
                    if(a[i]==a[i+1])
                    continue;
                    if(a[i]+1==a[i+1])
                    count++;
                    else
                    count=1;
                    if(count==3)
                    {
                              break;
                    }
          }
          if(count==3)
          printf("YES\n");
          else
          printf("NO");
          return 0;
}

#include<stdio.h>
#include<stdlib.h>

struct llst_int
{
	int a;
	struct llst_int *next;
};
typedef struct llst_int __llst_int;

__llst_int* receive_sort(__llst_int *head, int *p);
int check(__llst_int *head);

int main()
{
	__llst_int *head;
	__llst_int *temp;
	int n;
	char flag;

	scanf("%d",&n);
	head = (__llst_int *)malloc(sizeof(__llst_int));
	head = receive_sort(head, &n);
	flag=check(head);
	if(flag)
		puts("YES");
	else
		puts("NO");

	return 0;
}

__llst_int* receive_sort(__llst_int *head, int *p)
{
	__llst_int *k;
	__llst_int *temp;
	__llst_int *t;
	int i;
	int j;

	scanf("%d",&head->a);
	head->next = NULL;

	i=1;
	while(i<*p)
	{
		temp = (__llst_int *)malloc(sizeof(__llst_int));
		temp->next=NULL;
		scanf("%d",&temp->a);
		t=head;
		j=0;
		if(temp->a > t->a)
			j++;
		while(j<i && t->next && temp->a > t->next->a)
		{
			t = t->next;
			j++;
		}
		if(j==i)
		{
			if(i>1)
				t->next=temp;
			else
				head->next=temp;
			i++;
		}
		else
		{
			if(j)
			{
				if(temp->a == t->next->a)
				{
					free(temp);
					(*p)--;
				}
				else
				{
					k=t->next;
					t->next=temp;
					temp->next=k;
					i++;
				}
			}
			else
			{
				if(temp->a == t->a)
				{
					free(temp);
					(*p)--;
				}
				else
				{
					k=head;
					head=temp;
					head->next=k;
					i++;
				}
			}
		}
	}
	return head;
}

int check(__llst_int *head)
{
	__llst_int *temp;

	temp=head;
	if(temp->next)
	{
		while(temp->next->next)
		{
			if(temp->a+1==temp->next->a && temp->a+2==temp->next->next->a)
				return 1;
			temp=temp->next;
		}
	}
	return 0;
}

#include <stdio.h>

void quicksort(int v[],int inicio, int fin);

short int repartirBolas(int *v , int dim );

int main(){

	int k,i;

	scanf("%d",&k);
	int bolas[k];

	for(i=0; i<k;i++){

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

	}

	quicksort(bolas,0,k-1);

	if( repartirBolas ( bolas , k ) )

		printf("%s" , "YES" );

	else

		printf( "%s" , "NO" );

	return 0;

}
//Ordena el vector de bolas
void quicksort(int v[],int inicio, int fin){
	int i,j,central;
	int pivote;
	int temp;
	central=(inicio+fin)/2;
	pivote=v[central];
	i=inicio;
	j=fin;
	do{
		while(v[i]<pivote)
			i++;
		while(v[j]>pivote)
			j--;
		if(i<=j){
			temp=v[i];
			v[i]=v[j];
			v[j]=temp;
			i++;
			j--;
		}
	}while(i<=j);
	if(inicio<j)
		quicksort(v,inicio,j);
	if(i<fin)
		quicksort(v,i,fin);
}

short int repartirBolas(int *v , int dim ){

	int i,j;
	int retorna = 0;
    short int count = 0;

	for( i = 0 ; i < dim - 2; i ++ ){

        for( j = i + 1 ; j < dim ; j ++ ){

		    if(  ( v[i] + 1 ) == v[j]  ){ /* buscar un mayor inmediato */

                i = j; /* cambiar el indice del numero a comparar con el encontrado */
                count++; /* contar la cantidad de numeros inmediatos superiores ya encontrados */

            }

            if( count == 2 ){ /* ver si ya se encontro dos numeros inmediatos superiores */

                retorna = 1; /* se coloca el valor a retornar en 1 */
                j = dim; /* se finalizan ambos ciclos */
                i = dim;

            }

            if( v[j] > v[i] + 1 ){ /* si es mayor al imnediato superior, finalizar la busqueda y borrar el contador */

                count = 0;
                i = j - 1;
                j = dim;

            }

		}

	}

	return retorna;

}

#include<stdio.h>

int puede(unsigned int v[], int n);
int hay(unsigned int v[],int x, int pos, int ult);

int main(){
	int n;

	scanf("%d",&n);

	unsigned int v[n];

	for(int i=0; i<n; i++){
		scanf("%u",&v[i]);
	}

	n = puede(v, n);

	if(n){
		puts("YES");
	}else{
		puts("NO");
	}
	return 0;
}

int puede(unsigned int v[], int n){
int c=0,j,i,b,z=0;

	for(i=0; i<n; i++){
		for(j=0;j<n-i;j++){
			if(v[i]>v[j]){
				b=v[i];
				v[i]=v[j];
				v[i]=b;
			}
		}
	}

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

		b=2;
		z=2;

		if(hay(v, -2,i,n )){
			c++;
			z=0;
		}
		if(hay(v, -1 ,i,n)){
			c++;
			b=0;
		}
if(z ){

		if(hay(v, 1,i,n ) ){
			c++;
		}
}

if( z ){

	if(b ){

		if(hay(v, 2,i,n ) ){
			c++;
		}
	}
}

		if(c>=2){
			return 1;
		}
		c=0;
	}

	return 0;
}

int hay(unsigned int v[],int x, int pos, int ult){
int i;

	for(i=0; i < ult ;i++ ){
		if(pos != i){
			if(v[pos] - v[i] == x){
				return 1;
			}

		}
	}

	return 0;
}

#include <stdio.h>
#include <string.h>
int main()
{
     int n, i;
     int flag[1010];
     memset(flag,0,sizeof(flag));
     int x;
    while(~scanf("%d",&n))
    {
       for(i=0;i<n;i++)
         {
             scanf("%d",&x);
             flag[x]=1;
         }
        for(i=0;i<1010;i++)
        {
            if(flag[i]==1&&flag[i+1]==1&&flag[i+2]==1)
            {
                printf("YES\n");
                return 0;
            }
        }
        printf("NO\n");

    }
     return 0;
}

/*
    Bear and three balls
    Autor: francisco.bogado
    Fecha: 19-05-2018
*/

#include<stdio.h>
#include<stdlib.h> //se importa porque se usara la funcion qsort de esta libreria

//prototipos de funciones
short int repartirBolas(int * vector , const int dim);
int cmpfunc (const void * a, const void * b);
void cargarVector(const int dim, int vector[dim]);
void input(int * k);

//funcion principal
int main(){
	int k,i;

	input(&k);
	int bolas[k];
	cargarVector(k, bolas);
	qsort(bolas, k, sizeof(int), cmpfunc);//funcion que ordena el vector
    printf("%s", repartirBolas(bolas,k)?"YES":"NO");
	return 0;
}

//funcion de comparacion que utiliza el qsort
int cmpfunc (const void * a, const void * b) {
   return ( *(int*)a - *(int*)b );
}

//se encarga de la carga de los elementos del vector
void cargarVector(const int dim, int vector[dim]){
    int i;
    for(i=0;i<dim;i++){
        scanf("%d",&vector[i]);
    }
}

//se encarga de leer la cantidad de bolas
void input(int * k){
    do{
        scanf("%d", k);
    }while(*k > 50 || *k < 3);
}

//funcion que verifica que las bolas no sean repetidas ni esten separadas por mas de dos lugares
short int repartirBolas(int *v , const int dim ){
	int i,j,c=0;
	int retorna = 0;
	for( i = 0 ; i < dim - 2; i ++ ){//ciclo que se encarga de recorrer el array buscando las bolas
		for (j = i + 1; j < dim; j ++){//ciclo auxiliar para el control de bolas de igual tamanho
			if(v[i] + 1 == v[j]){//checquea que el numero en la posicion siguiente seaa un inmediato superior
				i=j;//desplaza el indice para ignorar el numero y continuar con la busqueda
				c++;//se utiliza para controlar la cantidad de bolas ya encontradas
			}
			/*estructura selectiva que controla si el nuevo numero encontrado es el tercero en una sucesion
			si es asi retorna el caso de exito y finaliza los ciclos.*/
			if(c==2){
				retorna = 1;
				j = dim;
				i = dim;
			}
			/*en caso de que la busqueda no sea exitosa inicializa el contador y mueve el indice de busqueda
			al valor mayor encontrado para continuar. Descarta parte del array donde no se pueden encontrar las
			tres bolas sucesivas*/
			if(v[j]>v[i]+1){
				c=0;
				i=j-1;
				j=dim;
			}
		}
	}
	return retorna;
}

#include<stdio.h>
void quicksort(int [], int, int);
int main(){
    int i,j,k,n;
    scanf("%d",&n);
    int ball[n];
    for(i=0;i<n;i++){
        scanf("%d",&ball[i]);
    }
    quicksort(ball,0,n-1);
    i=0;
    j=1;
	k=2;
    while(i<n-2){
	//Mientras i no ocupe el antepenultimo lugar
        while(ball[i]==ball[j]){
        	//Busca una posicion j tal que ball[j]!=ball[i]
                j++;
                if(j==n-1){
                	//Si llega al ultimo lugar del vector significa que no hay una terna de numeros que cumpla la condicion
                    printf("NO");
                    return 0;
                }
        }

        if(ball[j]-ball[i]<=2){
        	//Si la diferencia en tamaño de las pelotas es menor o igual a dos se realiza la busqueda del tercero para esos valores de i,j
            k=j+1;

            while(ball[j]==ball[k]){
                //Se incrementa k hasta encontrar ball[k]!=ball[j]
				k++;
                if(k==n){
                	//Si llega al final, no encontro una terna de numeros que cumpla la condicion
                    printf("NO");
                    return 0;
                }
            }
            if(ball[k]-ball[j]<=2 && ball[k]-ball[i]<=2){
            	//Si encontro un valor de k y cumple la condicion del tamaño se encontro la solucion al problema y termina el programa
                printf("YES");
                return 0;
            }

        }

            i=j;
            /*j=k;
            while(ball[j]==ball[k]){
                k++;
                if(k==n){
                  printf("NO");
                  return 0;
                }
            }*/
    }
    printf("NO");
    return 0;
}
void quicksort(int A[], int ini, int fin){
    int central = (ini + fin)/2;
    int pivote = A[central];
    int i=ini,j=fin,aux;
    do{
        while(A[i]<pivote) i++;
        while(A[j]>pivote) j--;
        if(i<=j){
            aux = A[i];
            A[i]=A[j];
            A[j]=aux;
            i++;
            j--;
        }
    }
    while(i<=j);
    if(ini<j){
        quicksort(A,ini,j);
    }
    if(fin>i){
        quicksort(A,i,fin);
    }
}

#include <stdio.h>
#include <stdlib.h>

int cnt[2000];

int main()
{
    int n, x;
    scanf("%d", &n);
    while (n--){
        scanf("%d", &x);
        cnt[x]++;
        if (((cnt[x - 1]) && (cnt[x - 2])) ||
            ((cnt[x + 1]) && (cnt[x + 2])) ||
            ((cnt[x - 1]) && (cnt[x + 1]))) {
                printf("YES\n");
                return 0;
        }
    }
    printf("NO\n");
    return 0;
}

#include<stdio.h>

int main(){
    int n;
    scanf("%d",&n);
    int balls[n];
    int i,j,k;
    int a,b,c;
    int aux;
    int puede;
    puede = 0;

    for (i = 0;i < n; i++){
        scanf("%d",&balls[i]);
    }

     for (i = 0; i < n-1; i++){
       for (j = 0; j < n-i-1; j++){
           if (balls[j] > balls[j+1]){
                aux        = balls[j];
                balls[j]   = balls[j+1];
                balls[j+1] = aux;
            }
        }
    }

         for (i = 0; i < n; i++) {
      for (j = i + 1; j < n;) {
         if (balls[j] == balls[i]) {
            for (k = j; k < n; k++) {
               balls[k] = balls[k + 1];
            }
            n--;
         } else
            j++;
      }
   }
    for (i = 1; i<n-1; i++){
        a = balls[i-1];
        b = balls[i];
        c = balls[i+1];

        if(b - a == 1 && c - b == 1  && (a+b+c)/3 == b){
            puede = 1;
        }
    }
    if(puede == 1){
        printf("YES");
    }
    else{
        printf("NO");
    }
}

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>

#define SORT while(t--){for(i=0;i<x-1;i++)if(arr[i]>arr[i+1]){o=arr[i];arr[i]=arr[i+1];arr[i+1]=o;}}
#define R return 0;
#define and &&
#define or ||
#define buyuk(a,b) (a<b)? b:a
#define kucuk(a,b) (a<b)? a:b
main(){
	int arr[10005],x,i,t,o,h[10005]={0};
	scanf("%d",&x);
	for(i=0;i<x;i++){
		scanf("%d",&arr[i]);
		h[arr[i]]++;
	}
	for(i=0;i<10000;i++){
		if(h[i] and h[i+1] and h[i+2]){
			printf("YES");
			return 0;
		}
	}
		printf("NO");
}

#include <stdio.h>
#include <stdlib.h>

struct nodoLista{
    int dato;
    struct nodoLista * ptrSiguiente;
};

typedef struct nodoLista NodoLista;
typedef NodoLista *ptrNodoLista;

void insertar(ptrNodoLista *ptrS, int valor, int *tam);
int main(){
    int n;
    scanf("%d", &n);
    int array[n];
    int i, tamLista;
    tamLista = n;
    for( i = 0; i < n; i++ )
    scanf("%d", &array[i]);

    ptrNodoLista ptrInicial = NULL;

    for( i = 0; i < n; i++)
        insertar(&ptrInicial, array[i], &tamLista);

    int resp = 0;

    if( tamLista >= 3 ){
        ptrNodoLista ptrAnterior, ptrCentro, ptrPosterior, temp;
        temp = ptrInicial;
        do{
            ptrAnterior = temp;
            ptrCentro = temp->ptrSiguiente;
            ptrPosterior = ptrCentro->ptrSiguiente;
            if( (ptrAnterior->dato + 1) == ptrCentro->dato )
                if( (ptrCentro->dato + 1) == ptrPosterior->dato ){
                    resp = 1;
                    break;
                }
                temp = ptrCentro;
            }while( ptrPosterior->ptrSiguiente != NULL );
    }/* end if */

    resp?printf("YES"):printf("NO");

    return 0;

}/* fin de main */

void insertar(ptrNodoLista *ptrS, int valor, int *tam)
{
    ptrNodoLista ptrNuevo;
    ptrNodoLista ptrAnterior;
    ptrNodoLista ptrActual;

    ptrNuevo = malloc(sizeof(NodoLista));

    if(ptrNuevo != NULL){
        ptrNuevo->dato = valor;
        ptrNuevo->ptrSiguiente = NULL;

        ptrAnterior = NULL;
        ptrActual = *ptrS;

        while( ptrActual != NULL && valor >= ptrActual->dato){
            ptrAnterior = ptrActual;
            ptrActual = ptrActual->ptrSiguiente;
        }/* fin de while */

        if(ptrAnterior == NULL){
            if(*ptrS == NULL || (*ptrS)->dato != valor){
                ptrNuevo->ptrSiguiente = *ptrS;
                *ptrS = ptrNuevo;
            }else{
                --(*tam);
            }
        }
        else{
            if( ptrAnterior->dato != ptrNuevo->dato ){
                ptrAnterior->ptrSiguiente = ptrNuevo;
                ptrNuevo->ptrSiguiente = ptrActual;
            }else{
                --(*tam);
            }
        }/* en de else */

    }/* fin de if */
    else{
        printf("No se inserto %c. No hay memoria disponible.\n", valor);
    }/* fin de else */

}/* fin de la función insertar */

#include <stdio.h>

int n;
int arr[55];

int main(){
	scanf("%d",&n);
	for(register int i=1;i<=n;i++) scanf("%d",&arr[i]);
	for(register int i=1;i<=n;i++){
		for(register int j=1;j<=n;j++){
			for(register int k=1;k<=n;k++){
				if(arr[k]==arr[j]+1 && arr[j]==arr[i]+1){
					printf("YES\n");
					return 0;
				}
			}
		}
	}
	printf("NO\n");
	return 0;
}

#include<stdio.h>
#include<stdlib.h>
int cmpfunc (const void * a, const void * b)
{
   return ( *(int*)a - *(int*)b );
}
int main()
{
	int a[50],t;
	int n;scanf("%d",&n);
	int i,j,count=0;
	for(i=0;i<n;i++)
		scanf("%d",&a[i]);
	qsort(a,n,sizeof(int),cmpfunc);
	for(i=0;i<n;i++)
	{
		count=0;
		for(j=i+1;j<n;j++)
		{
			if(a[j]-a[i]<=2 && a[j]-a[i]!=0 && a[j]!=a[j+1] && j<n)
				count++;
			if(count==2){printf("YES\n");exit(0);}
		}
	}
	if(count!=2)printf("NO\n");
	return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#define pi 3.1415926
#define rep(x,ini,end) for(x=(ini);x<(end);x++)
#define per(x,ini,end) for(x=(end-1);x>=(ini);x--)
#define max(x,y) ((x)>(y)?(x):(y))
#define min(x,y) ((x)<(y)?(x):(y))

int t[100] = {0};

void quickSort(int a[], int beginPos, int endPos)
{
    int i = beginPos, j = endPos;
    int flag = a[beginPos];
    //int bePos_L, bePos_R, endPos_L, endPos_R;
    //int countL = 0, countR = 0;
    if (beginPos>=endPos)
    {
        return;
    }

    while (i<j)
    {
        while ((a[j]>flag) && (i<j))
        {
            --j;
        }
        if (i == j)
        {
            break;
        }

        a[i] = a[j]; a[j] = flag;
        ++i;

        while ((a[i]<flag) && (i<j))
        {
            ++i;
        }
        if (i == j)
        {
            break;
        }

        a[j] = a[i]; a[i] = flag;
        --j;
    }

    quickSort(a, beginPos, i-1);
    quickSort(a, i+1, endPos);
}

int main()
{
    int n;
    scanf("%d", &n);

    int i;
    rep(i,0,n)
    {
        scanf("%d", &t[i]);
    }
    quickSort(t, 0, n-1);

    int count = 1;
    int flag = t[0];

    rep(i,1,n)
    {
        if ((t[i]!=flag) && (t[i]-flag<2))
        {
            count++; flag = t[i];
            if (count == 3)
            {
                printf("YES"); return 0;
            }
            continue;
        }
        if (t[i]-flag>=2)
        {
            count = 1; flag = t[i];
        }
    }
    if (count == 3)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }

    return 0;
}

#include<stdio.h>
int b[100000];
int i;
int tog;
int cmpfunc (const void * a, const void * b)
{
	return ( *(int*)a - *(int*)b );
}

int main()
{
	int a,c;
	scanf("%d",&a);
	for(i=0;i<a;i++)
	{
		scanf("%d",&c);
		b[c]=1;
	}
	int count=0;
	for(i=0;i<1001;i++)
	{
		if(b[i]==1)
		{
			count++;
		}
		else
			count=0;
		if(count==3)
		{
			tog=1;
			break;
		}
	}
	if(tog==1)
	{
		printf("YES");
	}
	else
		printf("NO");
	printf("\n");

	return 0;
}

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int N;
	scanf("%d",&N);

	int V[N];

	int I,J;

	for (I=0;I<N;I++)
	{
		scanf("%d",&V[I]);
	}
	int ban,auxx;

	int cont;
	for( I=0;I<N;I++)//ordenar
	{
		for(J=0;J<N-1-I;J++)
		{
			if (V[J]>V[J+1])
			{
				auxx = V[J];
				V[J] = V[J+1] ;
				V[J+1] = auxx;
			}
		}
	}
	int first=V[1];
	cont=1;

	//for( I=0; I<N && cont<3 ;I++){printf("%d,",V[I]);}

	cont=1;
	int aux[3];
	for( I=0; I<N-2 && cont<3 ;I++)
	{
		aux[0]=V[I];
		cont=1;
		for (J=I;J<N && cont<3 ;J++)
		{
			if(V[J]-aux[0]<=2 && V[J]!=aux[cont-1])
			{
				aux[cont]=V[J];
				cont++;
			}
			else if (V[J]-aux[0]>2)
				break;
		}
	}

	if (cont!=3)
	{
		printf("NO");
	}
	else
	{
		printf("YES");
	}
	//for( I=0; I<3 ;I++){printf("%d,",aux[I]);}
	//printf("cont:%d\n",cont);
	return 0;
}

#include<stdio.h>
void rev(int v[],int n);
void quicksort(int lista[],int n);
void qs(int lista[],int limite_izq,int limite_der);
void leervector(int *v,int n);
void regre(int v[],int n,int *i);
int  main(){
 int n,k;
 scanf("%d",&n);
 int v[n];
 leervector(v,n);
 rev(v,n);
return 0;
}

void leervector(int *v,int n){
 int i;
 for(i=0;i<n;i++){
  scanf("%d",v+i);
 }
}

void rev(int v[],int n){
int i,x,z;
 quicksort(v,n);
 for(i=0;i<n-2;i++){
  if(v[i]==v[i+1]){
   regre(v,n,&i);
  }
  x=i+1;
  if(v[x]==v[x+1]){
    regre(v,n,&x);
  }
  z=x+1;
  if(v[i]+1==v[x] && v[x]+1==v[z]){
   printf("YES");
   exit(0);
  }
 }
 printf("NO");
}
void regre(int v[],int n,int *i){
 while(*i<n  && v[*i]==v[*i+1])(*i)++;
}

void quicksort(int lista[],int n){
 qs(lista,0,n-1);
}

void qs(int lista[],int limite_izq,int limite_der){
    int izq,der,temporal,pivote;
    izq=limite_izq;
    der = limite_der;
    pivote = lista[(izq+der)/2];
    do{
        while(lista[izq]<pivote && izq<limite_der)izq++;
        while(pivote<lista[der] && der > limite_izq)der--;
        if(izq <=der)
        {
            temporal= lista[izq];
            lista[izq]=lista[der];
            lista[der]=temporal;
            izq++;
            der--;
        }
    }while(izq<=der);
    if(limite_izq<der){qs(lista,limite_izq,der);}
    if(limite_der>izq){qs(lista,izq,limite_der);}
}

#include<stdio.h>
int main() {
    int n;
scanf("%d",&n);

        int a[n];
    int i;
    for(i=0; i<n; i++) {
        scanf("%d",&a[i]);
    }
    int j;
    int swap;
    for (i = 0 ; i < ( n - 1 ); i++)
        {
        for (j = 0 ; j < n - i - 1; j++)
        {
            if (a[j] > a[j+1]) {
                  swap=a[j];
                a[j] = a[j+1];
                a[j+1]=swap;
            }
        }
    }
    int y=0;
    int x=1;
    int temp=a[0];
   for(i=1;i<n;i++)
   {
       int m=a[i]-temp;
       if(m==0)
       {
           temp=a[i];
       }
       else if(m==1)
       {
           x++;
           temp=a[i];
       }
       else
       {
           x=1;
           temp=a[i];
       }
       if(x==3)
       {
           printf("YES\n");
           y=1;
           break;
       }
   }
   if(y==0)
   printf("NO\n");
    return 0;
}

#include<stdio.h>
#define T 1001
int main() {
	//因为ti的值最大是1000，所以我选择用exist方法
	int n;
	scanf("%d",&n);
	char exist[T];
	int i;
	for(i=0;i<T;i++){
		exist[i]=0;
	}
	for(i=0;i<n;i++){
		int t;
		scanf("%d",&t);
		exist[t]=1;
	}
	for(i=1;i<T-3;i++){
		if(exist[i] && exist[i+1] && exist[i+2]){
			printf("YES\n");
			return 0;
		}
	}
	printf("NO\n");
	return 0;
}

#include <stdio.h>

void leerbolas(int [], int);
void ordenarbolas(int [], int, int);
int compararbolas(int [], int);

int main(){
    int n;
    scanf("%d", &n);
    int V[n];
    leerbolas(V, n);
    ordenarbolas(V, 0, n-1);
    if(compararbolas(V, n)){
        printf("YES");
    }else{
        printf("NO");
    }
    return 0;
}

void leerbolas(int V[], int n){
    int i;
    for(i=0; i<n; i++){
        scanf("%d", &V[i]);
    }
}

void ordenarbolas(int V[], int pri, int ult){
    int i, j, cen, piv, aux;
    cen=(pri+ult)/2;
    piv=V[cen];
    i=pri;
    j=ult;
	do{
        while(V[i]<piv) i++;
        while(V[j]>piv) j--;
        if(i<=j){
            aux=V[i];
            V[i]=V[j];
            V[j]=aux;
            i++;
            j--;
        }
	}while(i<=j);
	if(pri<j){
        ordenarbolas(V, pri, j);
	}
	if(i<ult){
        ordenarbolas(V, i, ult);
	}
}

int compararbolas(int V[], int n){
    int i, validez=0;
    for(i=0; i<n-2; i++){
        if((V[i]!=V[i+1] && V[i+1]-V[i]<=2) && (V[i+1]!=V[i+2] && V[i+2]-V[i+1]<=2) && (V[i]!=V[i+2] && V[i+2]-V[i]<=2)){
            validez=1;
        }
    }
    return validez;
}

#include<stdio.h>
#include <math.h>
void quicksort(int [], int, int);
int main(){
    int i,j,k,n;
    scanf("%d",&n);
    int ball[n];
    for(i=0;i<n;i++){
        scanf("%d",&ball[i]);
    }
    quicksort(ball,0,n-1);
    i=0;
    j=1;

    while(i<n-2){

        while(ball[i]==ball[j])j++;
        if(fabs(ball[i]-ball[j])<=2){
            k=j+1;
            while(ball[j]==ball[k]){
                k++;
                if(k==n){
                    printf("NO");
                    return 0;
                }
            }
            if(fabs(ball[j]-ball[k])<=2 && fabs(ball[i]-ball[k])<=2){
                printf("YES");
                return 0;
            }
        }
            i=j;
            j=k;
            while(ball[j]==ball[k]){
                k++;
                if(k==n){
                  printf("NO");
                  return 0;
                }
            }
    }
    return 0;
}
void quicksort(int A[], int ini, int fin){
    int central = (ini + fin)/2;
    int pivote = A[central];
    int i=ini,j=fin,aux;
    do{
        while(A[i]<pivote) i++;
        while(A[j]>pivote) j--;
        if(i<=j){
            aux = A[i];
            A[i]=A[j];
            A[j]=aux;
            i++;
            j--;
        }
    }
    while(i<=j);
    if(ini<j){
        quicksort(A,ini,j);
    }
    if(fin>i){
        quicksort(A,i,fin);
    }
}

#include<stdio.h>
#define T 1001
int main() {
	//因为ti的值最大是1000，所以我选择用count方法
	int n;
	scanf("%d",&n);
	int count[T];
	int i;
	for(i=0;i<T;i++){
		count[i]=0;
	}
	for(i=0;i<n;i++){
		int t;
		scanf("%d",&t);
		count[t]++;
	}
	for(i=1;i<T-3;i++){
		if(count[i]>0 && count[i+1]>0 && count[i+2]>0){
			printf("YES\n");
			return 0;
		}
	}
	printf("NO\n");
	return 0;
}

#include<stdio.h>
void quicksort(int v[],int ini,int fin);
int main(){
	int i, n, encuentro=0;
	scanf("%d",&n);										//n es la cantidad de pelotas del oso
	int v[n];											//dimensionamos un vector para almacenar los numeros contenidos en las pelotas
	for(i=0;i<n;i++){
		scanf("%d",&v[i]);								//cargamos los valores de las pelotas
	}
	if(n>=3){											//solo sera posible la operacion en caso de contar con 3 o mas pelotas
		quicksort(v,0,n-1);								//llamo a la funcion quicksort
	}
	i=0;
	while(encuentro==0 && i<n-2){
		if(v[i+2]-v[i+1]==1 && v[i+1]-v[i]==1){			//verifico que haya tres pelotas con numeros consecutivos
			encuentro=1;
		}
		i++;
	}
	if(encuentro==1){
		puts("SI");
	}else{
		puts("NO");
	}
	return 0;
}
void quicksort(int v[],int ini,int fin){
	int j,i,pivote,medio,aux;
	medio=(ini+fin)/2;
	i=ini;
	j=fin;
	pivote=v[medio];
	do{
		while(v[i]<pivote){i++;}
		while(v[j]>pivote){j--;}
		if(i<=j){
			aux=v[i];
			v[i]=v[j];
			v[j]=aux;
			i++;
			j--;
		}
	}while(i<=j);
	if(ini<j){
		quicksort(v,ini,j);
	}
	if(i<fin){
		quicksort(v,i,fin);
	}
}

#include <stdio.h>
int main()
{
    int n, p1, p2, p3, i=0, j=0, k=0, menor, mayor;
    scanf("%d", &n);
    int tam[n];
    for(i=0; i<n; i++)
    {
        scanf("%d", &tam[i]);
    }
    i=0;
    j=0;
    k=0;
    for(i=0; i<n; i++)
    {
        for(j=i; j<n; j++)
        {
            if((tam[i]+1==tam[j]) || (tam[j]+1==tam[i]) || (tam[i]+2==tam[j]) || (tam[j]+2==tam[i]))
            {
                p1=tam[i];
                p2=tam[j];
                if(p1<p2)
                {
                    menor=p1;
                    mayor=p2;
                }
                else
                {
                    menor=p2;
                    mayor=p1;
                }
                for(k=j; k<n; k++)
                {
                    if(((tam[k]==menor+2) && (tam[k]==mayor+1)) || ((tam[k]==menor+1) && (tam[k]==mayor-1)))
                    {
                        p3=tam[k];
                        printf("YES");
                        return 0;
                    }
                }
            }
        }
    }
    printf("NO");
    return 0;
}

#include <stdio.h>
int main()
{
    int n, p1, p2, p3, i=0, j=0, k=0, menor, mayor;
    scanf("%d", &n);
    int tam[n];
    for(i=0; i<n; i++)
    {
        scanf("%d", &tam[i]);
    }
    i=0;
    j=0;
    k=0;
    for(i=0; i<n; i++)
    {
        for(j=i+1; j<n; j++)
        {
            if(tam[i]+1==tam[j] || tam[j]+1==tam[i] || tam[i]+2==tam[j] || tam[j]+2==tam[i])
            {
                p1=tam[i];
                p2=tam[j];
                if(p1<p2)
                {
                    menor=p1;
                    mayor=p2;
                }
                else if(p1>p2)
                {
                    menor=p2;
                    mayor=p1;
                }
                for(k=i+1; k<n; k++)
                {
                    if(tam[k]+2==menor || tam[k]+1==mayor)
                    {
                        p3=tam[k];
                        printf("YES");
                        return 0;
                    }
                }
            }
        }
    }
    printf("NO");
    return 0;
}

#include<stdio.h>

int main()
{
    int balls,i,j,temp,size[1000];
    scanf("%d",&balls);
    for(i=0; i<balls; i++)scanf("%d",&size[i]);
    for (i=0; i<balls; i++)
    {
        for(j=0; j<(balls-i-1); j++)
        {
            if(size[j]>size[j+1])
            {
                size[j]^=size[j+1]^=size[j]^=size[j+1];
            }
        }
    }
    for (j= 0; j<balls; j++)
    {
        if(size[j+1]==size[j]+1)
        {
            if(size[j+2]==size[j+1]+1)
            {
                printf("Yes");
                break;
            }
            else
            {
                printf("No");
                break;
            }
        }
    }
    return 0;
}

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int N;
	scanf("%d",&N);

	int V[N];

	int I,J;

	for (I=0;I<N;I++)
	{
		scanf("%d",&V[I]);
	}
	int ban,auxx;

	int cont;
	for( I=0;I<N;I++)//ordenar
	{
		for(J=0;J<N-1-I;J++)
		{
			if (V[J]>V[J+1])
			{
				auxx = V[J];
				V[J] = V[J+1] ;
				V[J+1] = auxx;
			}
		}
	}
	int first=V[1];
	cont=1;

	//for( I=0; I<N && cont<3 ;I++){printf("%d,",V[I]);}

	cont=1;
	int aux[3];
	for( I=0; I<N-2 && cont<3 ;I++)
	{
		aux[0]=V[I];
		cont=1;
		for (J=0;J<N && cont<3 ;J++)
		{
			if(V[J]-aux[0]<=2 && V[J]!=aux[cont-1])
			{
				aux[cont]=J;
				cont++;
			}
			else if (V[J]-aux[0]>2)
				break;
		}
	}

	if (cont!=3)
	{
		printf("NO");
	}
	else
	{
		printf("YES");
	}
	//printf("cont:%d\n",cont);
	return 0;
}

#include <stdio.h>
#include <stdlib.h>
void merge(int *p, int l, int m, int r);
void mergeSort (int *p, int l, int r);

int main(int argc, char const *argv[])
{
	int n, i, h=0;
	scanf("%d", &n);
	int balls[n];
	for(i = 0; i < n; i++){
		scanf("%d", &balls[i]);
	}
	mergeSort(balls, 0, n-1);
	for(i = 0; i < n-3; i += 3){
		if(abs(balls[i]-balls[i+1]) < 3 && abs(balls[i+1]-balls[i+2]) < 3 && abs(balls[i]-balls[i+2]) < 3 && balls[i] != balls[i+1] && balls[i+1] != balls[i+2] && balls[i] != balls[i+2] ){
			h = 1;
		}
	}

	if (h)
	{
		printf("YES");
	}else{
		printf("NO");
	}

	return 0;
}

void mergeSort (int *p, int l, int r){
	if(l<r){
		int m=(l+r)/2;
		mergeSort(p, l, m);
		mergeSort(p, m+1, r);
		merge(p, l, m, r);

	}
}

void merge(int *p, int l, int m, int r){
	int n1, n2, i, j, k;
	n1=m-l+1;
	n2=r-m;
	int v1[n1], v2[n2];
	for (i=0; i<n1;i++){
		v1[i]=*(p+(l+i));
	}
	for (j=0; j<n2;j++){
		v2[j]= *(p+(j+m+1));
	}
	i=0;
	j=0;
	k=l;
	while(i<n1 && j<n2){
		if(v1[i]<=v2[j]){
			*(p+k)=v1[i];
			i++;
		}else{
			*(p+k)= v2[j];
			j++;
		}
		k++;
	}
	while(i<n1){
		*(p+k)=v1[i];
		i++;
		k++;
	}
	while(j<n2){
		*(p+k)=v2[j];
		k++;
		j++;
	}

}

#include <stdio.h>

int a[60], n;

void swap(int *x, int *y){
	int temp;
	temp = *x;
	*x = *y;
	*y = temp;
}

int partition(int left, int right){
	int pivot, i, j;
	pivot = a[left];
	i = right;
	for(j=right; j>left; j--){
		if(a[j] >= pivot){
			swap(&a[j], &a[i]);
			i--;
		}
	}
	swap(&a[left], &a[i]);
	return i;
}

void quick_sort(int left, int right){
	int p;
	if(left >= right) return;
	else{
		p = partition(left, right);
		quick_sort(left, p-1);
		quick_sort(p+1, right);
	}
}

int main(){

	int i, done=0;

	scanf("%d", &n);
	for(i=0; i<n; i++) scanf("%d", &a[i]);
	quick_sort(0, n-1);
	for(i=1; i<n-1; i++)
		if(a[i]-a[i-1]==1 && a[i+1]-a[i]==1) done=1;
	if(done) printf("YES\n");
	else printf("NO\n");

	return 0;
}

#include<stdio.h>
#include<stdlib.h>
int cmpfunc (const void * a, const void * b)
{
   return ( *(int*)a - *(int*)b );
}
int main()
{
	int a[50],t;
	int n;scanf("%d",&n);
	int i,j,count=0;
	for(i=0;i<n;i++)
		scanf("%d",&a[i]);
	qsort(a,n,sizeof(int),cmpfunc);
	for(i=0;i<n;i++)
	{
		count=0;
		for(j=i+1;j<i+3;j++)
		{
			if(a[j]-a[i]<=2 && a[j]-a[i]!=0 && a[j]!=a[j+1] && j<n)
				count++;
			if(count==2){printf("YES\n");exit(0);}
		}
	}
	if(count!=2)printf("NO\n");
	return 0;
}

#include <stdio.h>
#include <stdlib.h>
void merge(int *p, int l, int m, int r);
void mergeSort (int *p, int l, int r);

int main(int argc, char const *argv[])
{
	int n, i, h=0,j,k;
	scanf("%d", &n);
	int balls[n];
	for(i = 0; i < n; i++){
		scanf("%d", &balls[i]);
	}
//	mergeSort(balls, 0, n-1);
	/*for(i = 0; i < n; i++){
		printf("%d ", balls[i]);
	}*/
	for (i = 0; i < n-2; i++){
		for (j = i+1; j < n-1; j++){
			if (abs(balls[i]-balls[j]) < 3){
				for (k = j+1; k < n; k++){
					if(abs(balls[i])-balls[k] < 3){
						if(balls[i] != balls[j] && balls[j] != balls[k] && balls[i] != balls[k]){
							h = 1;
						}
					}
				}
			}
		}
	}

	if (h)
	{
		printf("YES");
	}else{
		printf("NO");
	}

	return 0;
}

void mergeSort (int *p, int l, int r){
	if(l<r){
		int m=(l+r)/2;
		mergeSort(p, l, m);
		mergeSort(p, m+1, r);
		merge(p, l, m, r);

	}
}

void merge(int *p, int l, int m, int r){
	int n1, n2, i, j, k;
	n1=m-l+1;
	n2=r-m;
	int v1[n1], v2[n2];
	for (i=0; i<n1;i++){
		v1[i]=*(p+(l+i));
	}
	for (j=0; j<n2;j++){
		v2[j]= *(p+(j+m+1));
	}
	i=0;
	j=0;
	k=l;
	while(i<n1 && j<n2){
		if(v1[i]<=v2[j]){
			*(p+k)=v1[i];
			i++;
		}else{
			*(p+k)= v2[j];
			j++;
		}
		k++;
	}
	while(i<n1){
		*(p+k)=v1[i];
		i++;
		k++;
	}
	while(j<n2){
		*(p+k)=v2[j];
		k++;
		j++;
	}

}

#include<stdio.h>

int main () {

	int n;								// cantidad de bolas a ingresar
	int i;								// indice para recorrer
	int j;								// indice para recorrer
	int cont=0;							// cuenta la cantidad de numeros distintos ingresados
	int ban;							// bandera

	//do{								// validacion
		scanf ( "%d", &n );					// se ingresan la cantidad de bolas
	//} while( !(3 <= n && n <= 50) );

	int v[n];							// vector de bolas y sus respectivos pesos, pueden haber bolas repetidas

	for (i=0; i<n; i++) {						// recorre para contar la cantidad de numeros sin repeticion

		//do{							// validacion
			scanf ( "%d", &v[i] );				// se ingresan las respectivas bolas
		//} while ( !((1 <= v[i]) && (v[i] <= 1000)) );

		cont++;
		for ( j=0; j<i; j++ ) {
			if ( v[i]==v[j] ) {
				cont--;
				j=i;
			}
		}
	}

	int b[cont];							// bolas y sus respectivos pesos, sin haber bolas repetidas
	for ( i=0; i<cont; i++ ) {					// se inicializa a cero dicho vector
		b[i]=0;
	}

	for ( i=0; i<n; i++ ) {						// recorre el vector v para cargar los no repetidos en b
		ban=1;
		for ( j=0; (j<cont && ban!=0 && b[j]!=0); j++ ) {	// recorre el vector b para cargar en el los no repetidos de v
			if ( v[i]==b[j] ) {
				ban=0;
			}
		}
		if ( ban ) {
			b[j]=v[i];
		}
	}

	for ( i=1; i<cont; i++ ) {					// recorre b para ordenarlo por burbuja
		for ( j=0; j<cont-i; j++ ) {
			if ( b[j]>b[j+1] ) {				// si se cumple dicha condicion se intercambian las bolas
				b[j]=b[j]+b[j+1];
				b[j+1]=b[j]-b[j+1];
				b[j]=b[j]-b[j+1];
			}
		}
	}

	for ( i=0; i<cont-2; i++ ) {					// compara los numeros con sus dos siguientes para determinar si cumple
		if ( b[i+1]-b[i] <= 2 && b[i+2]-b[i] <= 2 && b[i+2]-b[i+1] <= 2 ) {
			ban=1;
			i=cont-2;
		}
	}

	if ( ban ) {							// si hay uno que cumple ban=1 y se imprime SI caso contrario NO
		printf( "YES" );
	}else{
		printf( "NO" );
	}

	return 0;

}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

#define lli long long int
#define MAX INT_MAX
#define sd second
#define fs first
#define endll '\n'
#define PI acos(-1)
#define mp make_pair
#define pb push_back
#define best 1000000007
#define FOR(i,a,b) for(int i=a;i<=b;i++)
#define ROF(i,a,b) for(int i=a;i>b;i--)
#define buyuk(a,b) (a<b)? b:a
#define kucuk(a,b) (a<b)? a:b
#define ort(a,b) (a+b)/2
#define carp(a,b) (a)*(b)
#include<stdio.h>
		int main (){

			int as[1005],i,j,arr[1005],x,min=0,t=0;
			scanf("%d",&x);
			for(i=0;i<x;i++)
			scanf("%d",&arr[i]);
		for(i=0; i<x; i++)
		{
			for(j=0;j<x;j++){
				if(arr[j]<arr[min])
					min=j;
			}
			as[t]=arr[min];
			t++;

			arr[min] = 100000000;
		}
		for(i=0;i<x;i++){

		if(as[i]+1==as[i+1] && as[i+1]+1==as[i+2]){
			printf("YES");
		return 0;
		}
		}
		printf("NO");

	}

#include <stdio.h>
#include <stdlib.h>

int eliminadup(int a[], int n);
void mezcla(int a[], int izda, int medio, int drcha, int tam);
void mergesort(int a[], int primero, int ultimo, int M);

int main()
{
    int n, posible, i;
    posible = 0;
    scanf("%d", &n);

    int array[n];
    //se lee size de los balls
    for(i=0; i<n; i++)
        scanf("%d", &array[i]);
    //se ordena de menor a mayor de acuerdo el size de los balls
    mergesort(array, 0, n, n);
    n = eliminadup(array, n);
    int dif;
    for(i=0; i<n-2; i++)
        if(array[i+2]-array[i] <= 2){
            posible = 1;
            printf(" YES");
            i=n;//para salir del bucle
        }

    if(posible == 0)
        printf("NO");

    return 0;
}//end main

void mergesort(int a[], int primero, int ultimo, int M){
    int central;
    if(primero < ultimo){
        central = (primero + ultimo)/2;
        mergesort(a, primero, central, M);
        mergesort(a, central+1, ultimo, M);
        mezcla(a, primero, central, ultimo, M);
    }//end if
}//end mergesort

void mezcla(int a[], int izda, int medio, int drcha, int tam)
{
    int tmp[tam];
    int x, y, z;
    x=z=izda;
    y = medio+1;
    /* bucle de mezcla, utiliza tmp[] como array auxiliar,
    z es el índice de tmp[] */
    while(x <= medio && y <= drcha)
    {
        if(a[x] <= a[y])
            tmp[z++] = a[x++];
        else
            tmp[z++] = a[y++];
    }
    /* bucle para mover elementos que quedan de sublistas */
    while(x <= medio)
        tmp[z++] = a[x++];
    while(y <= drcha)
        tmp[z++] = a[y++];
    /* Copia de elementos de tmp[] al array a[] */
    for(z = izda; z <= drcha; z++)
        a[z] = tmp[z];
}//end mezcla

int eliminadup(int a[], int n){
   int i, j, k;
   for (i = 0; i < n; i++) {
      for (j = i + 1; j < n;) {
         if (a[j] == a[i]) {
            for (k = j; k < n; k++) {
               a[k] = a[k + 1];
            }//end for
            n--;
         } else
            j++;
      }//end for
   }//end for
   return n;
}

#include <stdio.h>
int main()
{
    int n, p1, p2, p3, i=0, j=0, k=0, menor, mayor;
    scanf("%d", &n);
    int tam[n];
    for(i=0; i<n; i++)
    {
        scanf("%d", &tam[i]);
    }
    i=0;
    j=0;
    k=0;
    for(i=0; i<n; i++)
    {
        for(j=i+1; j<n; j++)
        {
            if(tam[i]+1==tam[j] || tam[j]+1==tam[i] || tam[i]+2==tam[j] || tam[j]+2==tam[i])
            {
                p1=tam[i];
                p2=tam[j];
                if(p1<p2)
                {
                    menor=p1;
                    mayor=p2;
                }
                else if(p1>p2)
                {
                    menor=p2;
                    mayor=p1;
                }
                for(k=i+1; k<n; k++)
                {
                    if(tam[k]+2==menor || tam[k]+1==mayor)
                    {
                        if(tam[k] != menor && tam[k] != mayor)
                        {
                            p3=tam[k];
                            printf("YES");
                            return 0;
                        }
                    }
                }
            }
        }
    }
    printf("NO");
    return 0;
}

#include<stdio.h>
#include<stdlib.h>

int cmpfunc (const void * a, const void * b)
{
   return ( *(int*)a - *(int*)b );
}

int main()
{

int n;
int arr[53],i;
scanf("%d",&n);
for( i=0;i<n;i++)
{
scanf("%d",&arr[i]);
}
qsort(arr, n, sizeof(int), cmpfunc);

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

if(arr[i]!=arr[i-1] && (arr[i] == (arr[i-1]+1)))
counts++;
else
counts=0;
if(counts ==2)
{
printf("YES");
flag =1;
break;
}
}
if(flag==0)
printf("NO");

return 0;
}

#include <stdio.h>
#include <string.h>
 // 5 5 5 6 7
int main()
{
    int n, aux;
    scanf("%d", &n);
    int bolas[n];
    int i, j;

    for(i = 0; i < n; i++)
    {
        scanf("%d", &bolas[i]);
    }
    for(i=1; i<n; i++)
	{
		for(j=0; j<n-i; j++)
		{
			if(bolas[j]>bolas[j+1])
			{
			    aux    = bolas[j+1];
				bolas[j+1] = bolas[j];
				bolas[j]   = aux;
			}
		}
	}
	char si[] = "YES";
	char no[] = "NO";
    int b = 0;
	if(n > 3)
    {
        for(i = 0; i < n-2; i++)
        {
            if((bolas[i]+1 == bolas[i+1])&&(bolas[i]+2 == bolas[i+2])) b = 1;
        }
    }else if(n == 3) if((bolas[i]+1 == bolas[i+1])&&(bolas[i]+2 == bolas[i+2])) b = 1;

    if (b == 1)
    {
        printf("%s", si);
    }else
    {
        printf("%s", no);
    }
    return 0;
}

#include<stdio.h>

void quick(int V[], int inicio, int fin);

int main(){

    int n, x, F = 0;

    do{

            fflush(stdin);
            scanf("%d", &n);

    }while(!(n >= 3 && n <= 50));

    int peso[n];

    for(x = 0; x < n; x++){

        do{

            scanf("%d", &peso[x]);

        }while(!(n >= 1 && n <= 1000));

    }

    quick(peso, 0, n-1);

    for(x = 0; x < n; x++){

        if(peso[x]+1 == peso[x+1] && peso[x]+2 == peso[x+2]){

            F++;
            break;

        }

    }

    if(F){
        printf("YES");
    }else{
        printf("NO");
    }

    return 0;

}

void quick(int V[], int inicio, int fin){

    int x, y, centro, pivot;

    centro = (inicio + fin) / 2;
    pivot = V[centro];

    x = inicio;
    y = fin;

    do{

        while(V[x] < pivot){
            x++;
        }

        while(V[y] > pivot){
            y--;
        }

        if(x <= y){

            int t;

            t = V[x];
            V[x] = V[y];
            V[y] = t;

            x++;
            y--;

        }

    }while(x <= y);

    if(inicio < y){
        quick(V, inicio, y);
    }

    if(x < fin){
        quick(V, x, fin);
    }

}

#include <stdio.h>
#include <stdlib.h>

int cnt[2000];

int main()
{
    int n, x;
    scanf("%d", &n);
    while (n--){
        scanf("%d", &x);
        cnt[x]++;
        if (((cnt[x - 1]) && (cnt[x - 2])) ||
            ((cnt[x + 1]) && (cnt[x + 2])) ||
            ((cnt[x - 1]) && (cnt[x + 1]))) printf("YES\n");
    }
    printf("NO\n");
    return 0;
}

#include<stdio.h>
#include <math.h>
void quicksort(int [], int, int);
int main(){
    int i,j,k,n;
    scanf("%d",&n);
    int ball[n];
    for(i=0;i<n;i++){
        scanf("%d",&ball[i]);
    }
    quicksort(ball,0,n-1);
    i=0;
    j=1;
	k=3;
    while(i<n-2){

        while(ball[i]==ball[j]){
                j++;
                if(j==n-1){
                    printf("NO");
                    return 0;
                }
        }
        if(fabs(ball[i]-ball[j])<=2){
            k=j+1;
            while(ball[j]==ball[k]){
                k++;
                if(k==n){
                    printf("NO");
                    return 0;
                }
            }
            if(fabs(ball[j]-ball[k])<=2 && fabs(ball[i]-ball[k])<=2){
                printf("YES");
                return 0;
            }
        }
            i=j;
            j=k;
            while(ball[j]==ball[k]){
                k++;
                if(k==n){
                  printf("NO");
                  return 0;
                }
            }
    }
    return 0;
}
void quicksort(int A[], int ini, int fin){
    int central = (ini + fin)/2;
    int pivote = A[central];
    int i=ini,j=fin,aux;
    do{
        while(A[i]<pivote) i++;
        while(A[j]>pivote) j--;
        if(i<=j){
            aux = A[i];
            A[i]=A[j];
            A[j]=aux;
            i++;
            j--;
        }
    }
    while(i<=j);
    if(ini<j){
        quicksort(A,ini,j);
    }
    if(fin>i){
        quicksort(A,i,fin);
    }
}

#include<stdio.h>

void qs(int lista[], int limizq, int limder );

int main(){

	int i, b, n,resta,cont;
	scanf("%d", &n);

	int lista[n];

	for(i=0; i<n; i++){
		scanf("%d",&lista[i]);

	}
	qs(lista,0,n);

	for(i=0; i<n-2; i++){
		resta = lista[i+1]-lista[i];
		if(resta==1){

			resta=lista[i+2]-lista[i+1];
			if(resta==1){
				b=1;
			}
		}
		if(b==1){

			break;
		}
	}

	if(b==1){
		puts("YES");
	}else{
		puts("NO");
	}

	return 0;
}

void qs(int lista[], int limizq, int limder){

	int izq, der, temp , pivot;

	izq=limizq;

	der=limder;

	pivot=lista[(izq+der)/2];

	do{
		while(lista[izq]<pivot && izq<limder) izq++;
		while(lista[der]>pivot && der>limizq) der--;

		if(izq<=der){
			temp=lista[izq];
			lista[izq]=lista[der];
			lista[der]=temp;
			izq++;
			der--;
		}
	}while(izq<=der);

	if(limizq<der){
		qs(lista, limizq,der);
	}
	if(limder>izq){
		qs(lista,izq,limder);
	}

}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int eliminadup(int a[], int n);
void mezcla(int a[], int izda, int medio, int drcha, int tam);
void mergesort(int a[], int primero, int ultimo, int M);

int main()
{
    int n, i;
    char answer[4]="NO";
    scanf("%d", &n);

    int array[n];
    //se lee size de los balls
    for(i=0; i<n; i++)
        scanf("%d", &array[i]);
    //se ordena de menor a mayor de acuerdo el size de los balls
    mergesort(array, 0, n, n);
    n = eliminadup(array, n);
    for(i=0; i<n; i++)
        printf("%d", array[i]);

    for(i=0; i < n-2; i++){
        if(array[i+2]-array[i] <= 2){
            strcpy(answer,"YES");
            i=n;//para salir del bucle
        }
    }
        printf("%s", answer);

    return 0;
}//end main

void mergesort(int a[], int primero, int ultimo, int M){
    int central;
    if(primero < ultimo){
        central = (primero + ultimo)/2;
        mergesort(a, primero, central, M);
        mergesort(a, central+1, ultimo, M);
        mezcla(a, primero, central, ultimo, M);
    }//end if
}//end mergesort

void mezcla(int a[], int izda, int medio, int drcha, int tam)
{
    int tmp[tam];
    int x, y, z;
    x=z=izda;
    y = medio+1;
    /* bucle de mezcla, utiliza tmp[] como array auxiliar,
    z es el índice de tmp[] */
    while(x <= medio && y <= drcha)
    {
        if(a[x] <= a[y])
            tmp[z++] = a[x++];
        else
            tmp[z++] = a[y++];
    }
    /* bucle para mover elementos que quedan de sublistas */
    while(x <= medio)
        tmp[z++] = a[x++];
    while(y <= drcha)
        tmp[z++] = a[y++];
    /* Copia de elementos de tmp[] al array a[] */
    for(z = izda; z <= drcha; z++)
        a[z] = tmp[z];
}//end mezcla

int eliminadup(int a[], int n){
   int i, j, k;
   for (i = 0; i < n; i++) {
      for (j = i + 1; j < n;) {
         if (a[j] == a[i]) {
            for (k = j; k < n; k++) {
               a[k] = a[k + 1];
            }//end for
            n--;
         } else
            j++;
      }//end for
   }//end for
   return n;
}

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>

#define SORT while(t--){for(i=0;i<x-1;i++)if(arr[i]>arr[i+1]){o=arr[i];arr[i]=arr[i+1];arr[i+1]=o;}}
#define R return 0;
#define and &&
#define or ||
#define buyuk(a,b) (a<b)? b:a
#define kucuk(a,b) (a<b)? a:b
main(){
	int arr[105],x,i,t,o;
	scanf("%d",&x);
	for(i=0;i<x;i++)
		scanf("%d",&arr[i]);
	t=x;
	SORT
	for(i=0;i<x;i++){
		if(arr[i]==arr[i+1]-1 and arr[i]==arr[i+2]-2 and arr[i+1]-1==arr[i+2]-2){
			printf("YES");
			return 0;
		}
	}
	printf("NO");
}

#include <stdio.h>
#include <stdlib.h>

int eliminadup(int a[], int n);
void mezcla(int a[], int izda, int medio, int drcha, int tam);
void mergesort(int a[], int primero, int ultimo, int M);

int main()
{
    int n, posible, i;
    posible = 0;
    scanf("%d", &n);

    int array[n];
    //se lee size de los balls
    for(i=0; i<n; i++)
        scanf("%d", &array[i]);
    //se ordena de menor a mayor de acuerdo el size de los balls
    mergesort(array, 0, n, n);
    n = eliminadup(array, n);
    int dif;
    for(i=0; i<n-2; i++)
        if(array[i+2]-array[i] <= 2){
            posible = 1;
            printf("YES");
            i=n;//para salir del bucle
        }

    if(posible == 0)
        printf("NO");

    return 0;
}//end main

void mergesort(int a[], int primero, int ultimo, int M){
    int central;
    if(primero < ultimo){
        central = (primero + ultimo)/2;
        mergesort(a, primero, central, M);
        mergesort(a, central+1, ultimo, M);
        mezcla(a, primero, central, ultimo, M);
    }//end if
}//end mergesort

void mezcla(int a[], int izda, int medio, int drcha, int tam)
{
    int tmp[tam];
    int x, y, z;
    x=z=izda;
    y = medio+1;
    /* bucle de mezcla, utiliza tmp[] como array auxiliar,
    z es el índice de tmp[] */
    while(x <= medio && y <= drcha)
    {
        if(a[x] <= a[y])
            tmp[z++] = a[x++];
        else
            tmp[z++] = a[y++];
    }
    /* bucle para mover elementos que quedan de sublistas */
    while(x <= medio)
        tmp[z++] = a[x++];
    while(y <= drcha)
        tmp[z++] = a[y++];
    /* Copia de elementos de tmp[] al array a[] */
    for(z = izda; z <= drcha; z++)
        a[z] = tmp[z];
}//end mezcla

int eliminadup(int a[], int n){
   int i, j, k;
   for (i = 0; i < n; i++) {
      for (j = i + 1; j < n;) {
         if (a[j] == a[i]) {
            for (k = j; k < n; k++) {
               a[k] = a[k + 1];
            }//end for
            n--;
         } else
            j++;
      }//end for
   }//end for
   return n;
}

/*
  En geometria analitica hay
  un teorema que dice que tres puntos
  forma un triangulo y si solo si el
  determinante
  Area = 1/2* | x1 y1 1 |
              | x2 y2 1 |
              | x3 y3 1 |
  es distinto de cero
*/

int asc(const void * a, const void * b)
{
   return ( *(int*)a - *(int*)b );
}

typedef struct Punto
{
   int x, y;
}Punto;

//determinante
int det(int x1, int y1, int x2, int y2, int x3, int y3)
{
   return x1*(y2 - y3) - y1*(x2 - x3) + 1*(x2*y3 - y2*x3);
}

//calcula la catindad de triangulos
int cuantosTriangulos(Punto puntos[], int n)
{
    int resultado = 0;

    //cuando el determinante de tres puntos es distinto de cero
    //aumentamos resultado
    for (int i=0; i<n; i++)
        for (int j=i+1; j<n; j++)
            for (int k=j+1; k<n; k++)
                if (det(puntos[i].x, puntos[i].y, puntos[j].x,
                        puntos[j].y, puntos[k].x, puntos[k].y))
                    resultado++;

    return resultado;
}

int main()
{
    int n;
    scanf("%d",&n);
    Punto puntos[n];
    for(int i=0; i<n; ++i)
    {
      scanf("%d %d",&puntos[i].x,&puntos[i].y);
    }
    printf("%d", cuantosTriangulos(puntos, n));
    return 0;
}

#include<stdio.h>
int main()
{
    int n,flag=0,midindex=0,i,j,temp;
    scanf("%d",&n);
    int a[1000];
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    for(i=0;i<n-1;i++)
    {
        midindex=i;
        for(j=i+1;j<n;j++)
        {
            if(a[midindex]>a[j])
            midindex=j;
        }
        if(midindex!=i)
        {
            temp=a[midindex];
            a[midindex]=a[i];
            a[i]=temp;
        }
    }
    for(i=0;i<=n-3;i++)
    {
        if(a[i]+1==a[i+1]&&a[i]+2==a[i+2])
        flag++;
    }
    if(flag>0)
    printf("YES");
    else
    printf("NO");
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
void merge(int *p, int l, int m, int r);
void mergeSort (int *p, int l, int r);

int main(int argc, char const *argv[])
{
	int n, i, h=0,j,k;
	scanf("%d", &n);
	int balls[n];
	for(i = 0; i < n; i++){
		scanf("%d", &balls[i]);
	}
	mergeSort(balls, 0, n-1);
	/*for(i = 0; i < n; i++){
		printf("%d ", balls[i]);
	}*/
	for (i = 0; i < n-2; i++){
		for (j = i+1; j < n-1; j++){
			if (abs(balls[i]-balls[j]) < 3 && balls[i] != balls[j]){
				for (k = j+1; k < n; k++){
					if(abs(balls[i])-balls[k] < 3 && abs(balls[j] - balls[k]) < 3 && balls[i] != balls[k]){
						if(balls[i] != balls[j] && balls[j] != balls[k] && balls[i] != balls[k]){
							h = 1;
						}else{
							h = 0;
						}
					}
				}
			}
		}
	}

	if (h)
	{
		printf("YES");
	}else{
		printf("NO");
	}

	return 0;
}

void mergeSort (int *p, int l, int r){
	if(l<r){
		int m=(l+r)/2;
		mergeSort(p, l, m);
		mergeSort(p, m+1, r);
		merge(p, l, m, r);

	}
}

void merge(int *p, int l, int m, int r){
	int n1, n2, i, j, k;
	n1=m-l+1;
	n2=r-m;
	int v1[n1], v2[n2];
	for (i=0; i<n1;i++){
		v1[i]=*(p+(l+i));
	}
	for (j=0; j<n2;j++){
		v2[j]= *(p+(j+m+1));
	}
	i=0;
	j=0;
	k=l;
	while(i<n1 && j<n2){
		if(v1[i]<=v2[j]){
			*(p+k)=v1[i];
			i++;
		}else{
			*(p+k)= v2[j];
			j++;
		}
		k++;
	}
	while(i<n1){
		*(p+k)=v1[i];
		i++;
		k++;
	}
	while(j<n2){
		*(p+k)=v2[j];
		k++;
		j++;
	}

}

#include <stdio.h>
#include <math.h>

int verificar(int a, int b, int c);
void ordenarAscendente(int lista[], int n);

int main() {
	int n, i, aux, x, j, N=0;
	scanf("%d", &n);
	int lista[n];

	for(i=0; i<n; ++i) {
		scanf("%d", &x);
		if(i==0) {
			lista[0]=x;
			++N;
		}else {
			aux=1;
			for(j=0; j<N; ++j) {
				if(lista[j]==x) {
					aux=0;
					break;
				}
			}
			if(aux) {
				++N;
				lista[N-1]=x;
			}
		}
	}

	ordenarAscendente(lista, N);

	for(i=0; i<=N-3; ++i) {
		aux=verificar(lista[i], lista[i+1], lista[i+2]);
		if(aux) break;
	}

	if(aux) printf("YES");
	else printf("NO");

	return 0;
}

void ordenarAscendente(int lista[], int n) {
	/*ordenacion burbuja*/
	int interruptor=1;
	int pasada, i, aux;
	for(pasada=0; pasada<=n-2 && interruptor; ++pasada) {
		interruptor=0;
		for(i=0; i<n-pasada-1; ++i) {
			if(lista[i]>lista[i+1]) {
				interruptor=1;
				aux=lista[i];
				lista[i]=lista[i+1];
				lista[i+1]=aux;
			}
		}
	}
}

int verificar(int a, int b, int c) {
	if(fabs(a-b)<=2.00 && fabs(a-c)<=2.00 && fabs(b-c)<=2.00) return 1;
	else return 0;
}

#include<stdio.h>
#include<stdbool.h>

void quicksort(int arr[], int first, int last)
{
    int i = first, j = last, pivot;
    pivot = arr[(first + last)/2];
    do
    {
        while (arr[i] < pivot){
            i++;
        }
        while(arr[j] > pivot){
            j--;
        }

        if(i <= j)
        {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
    }while(i <= j);
    if(first < j) quicksort(arr, first, j);
    if(last > i) quicksort(arr, i, last);
}

int main(void)
{
    int n, num1, num2, num3, j;
    scanf("%d", &n);
    int array[n];
    for(int i = 0; i < n; i++)
    {
        scanf("%d", &array[i]);
    }
    quicksort(array, 0, n-1);
    for(int i = 0; i < n; i++)
    {
       num1 = array[i];
       for(j = i + 1; j < n && array[j] == array[i]; j++);
       if(j < n)
       {
           num2 = array[j];
            if(num1 + 1 == num2)
            {
                for(j = j + 1; j < n && array[j] == num2; j++);
                if(j < n)
                {
                    num3 = array[j];
                    if(num3 - 2 == num1)
                    {
                        printf("YES");
                        return 0;
                    }
                }
            }
       }
       printf("%d %d %d\n", num1, num2, num3);
    }
    printf("NO");
    return 0;
}

#include <stdio.h>
#include <string.h>

int main()
{
    int n, aux;
    scanf("%d", &n);
    int bolas[n];
    int i, j;

    for(i = 0; i < n; i++)
    {
        scanf("%d", &bolas[i]);
    }
    for(i=1; i<n; i++)
	{
		for(j=0; j<n-i; j++)
		{
			if(bolas[j]>bolas[j+1])
			{
			    aux    = bolas[j+1];
				bolas[j+1] = bolas[j];
				bolas[j]   = aux;
			}
		}
	}
	char si[] = "S�";
	char no[] = "NO";
    int b = 0;
	if(n > 3)
    {
        for(i = 0; i < n-3; i++)
        {
            if((bolas[i]+1 == bolas[i+1])&&(bolas[i]+2 == bolas[i+2])) b = 1;
        }
    }else if(n == 3) if((bolas[i]+1 == bolas[i+1])&&(bolas[i]+2 == bolas[i+2])) b = 1;

    if (b == 1)
    {
        printf("%s", si);
    }else
    {
        printf("%s", no);
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int eliminadup(int a[], int n);
void mezcla(int a[], int izda, int medio, int drcha, int tam);
void mergesort(int a[], int primero, int ultimo, int M);

int main()
{
    int n, i;
    char answer[4]="NO";
    scanf("%d", &n);

    int array[n];
    //se lee size de los balls
    for(i=0; i<n; i++)
        scanf("%d", &array[i]);
    //se ordena de menor a mayor de acuerdo el size de los balls
    mergesort(array, 0, n, n);

    for(i=0; i < n-2; i++){
        if(array[i+2]-array[i] <= 2){
            strcpy(answer,"YES");
            i=n;//para salir del bucle
        }
    }
        printf("%s", answer);

    return 0;
}//end main

void mergesort(int a[], int primero, int ultimo, int M){
    int central;
    if(primero < ultimo){
        central = (primero + ultimo)/2;
        mergesort(a, primero, central, M);
        mergesort(a, central+1, ultimo, M);
        mezcla(a, primero, central, ultimo, M);
    }//end if
}//end mergesort

void mezcla(int a[], int izda, int medio, int drcha, int tam)
{
    int tmp[tam];
    int x, y, z;
    x=z=izda;
    y = medio+1;
    /* bucle de mezcla, utiliza tmp[] como array auxiliar,
    z es el índice de tmp[] */
    while(x <= medio && y <= drcha)
    {
        if(a[x] <= a[y])
            tmp[z++] = a[x++];
        else
            tmp[z++] = a[y++];
    }
    /* bucle para mover elementos que quedan de sublistas */
    while(x <= medio)
        tmp[z++] = a[x++];
    while(y <= drcha)
        tmp[z++] = a[y++];
    /* Copia de elementos de tmp[] al array a[] */
    for(z = izda; z <= drcha; z++)
        a[z] = tmp[z];
}//end mezcla

int eliminadup(int a[], int n){
   int i, j, k;
   for (i = 0; i < n; i++) {
      for (j = i + 1; j < n;) {
         if (a[j] == a[i]) {
            for (k = j; k < n; k++) {
               a[k] = a[k + 1];
            }//end for
            n--;
         } else
            j++;
      }//end for
   }//end for
   return n;
}

#include<stdio.h>
int main()
{
    int n,flag=0,midindex=0,i,j,temp;
    scanf("%d",&n);
    int a[1000];
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    for(i=0;i<n-1;i++)
    {
        midindex=i;
        for(j=i+1;j<n;j++)
        {
            if(a[midindex]>a[j])
            midindex=j;
        }
        if(midindex!=i)
        {
            temp=a[midindex];
            a[midindex]=a[i];
            a[i]=temp;
        }
    }
    for(i=0;i<=n-3;i++)
    {
        if(a[i]+1>=a[i+1]||a[i]+2>=a[i+2])
        flag++;
    }
    if(flag>0)
    printf("YES");
    else
    printf("NO");
    return 0;
}

#include<stdio.h>

int puede(unsigned int v[], int n);
int hay(unsigned int v[],int x, int pos, int ult);

int main(){
	int n;

	scanf("%d",&n);

	unsigned int v[n];

	for(int i=0; i<n; i++){
		scanf("%u",&v[i]);
	}

	n = puede(v, n);

	if(n){
		puts("YES");
	}else{
		puts("NO");
	}
	return 0;
}

int puede(unsigned int v[], int n){
int c=0,j,i,b;

	for(i=0; i<n; i++){
		for(j=0;j<n-i;j++){
			if(v[i]>v[j]){
				b=v[i];
				v[i]=v[j];
				v[i]=b;
			}
		}
	}

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

		if(hay(v, -2,i,n )){
			c++;
			b=0;
		}

		if(hay(v, -1 ,i,n)){
			c++;
			b=1;
		}

		if(hay(v, 0 ,i,n)){
			c++;
		}

		if(hay(v, 1,i,n ) && b != 0){
			c++;
		}

		if(hay(v, 2,i,n ) && b != 1){
			c++;
		}
		if(c>=2){
			return 1;
		}
		c=0;
	}

	return 0;
}

int hay(unsigned int v[],int x, int pos, int ult){
int i;

	for(i=0; i < ult ;i++ ){
		if(pos != i){
			if(v[pos] - v[i] == 2){
				return 1;
			}

		}
	}

	return 0;
}

/*
    Bear and three balls
    Autor: francisco.bogado
    Fecha: 19-05-2018
*/

#include<stdio.h>
#include<stdlib.h> //se importa porque se usara la funcion qsort de esta libreria

//prototipos de funciones
short int repartirBolas(int * vector , const int dim);
int cmpfunc (const void * a, const void * b);
void cargarVector(const int dim, int vector[dim]);
void input(int * k);

//funcion principal
int main(){
	int k,i;

	input(&k);
	int bolas[k];
	cargarVector(k, bolas);
	qsort(bolas, k, sizeof(int), cmpfunc);//funcion que ordena el vector
    printf("%s", repartirBolas(bolas,k)?"YES":"NO");
	return 0;
}

//funcion de comparacion que utiliza el qsort
int cmpfunc (const void * a, const void * b) {
   return ( *(int*)a - *(int*)b );
}

//se encarga de la carga de los elementos del vector
void cargarVector(const int dim, int vector[dim]){
    int i;
    for(i=0;i<dim;i++){
        scanf("%d",&vector[i]);
    }
}

//se encarga de leer la cantidad de bolas
void input(int * k){
    do{
        scanf("%d", k);
    }while(*k > 50 || *k < 3);
}

//funcion que verifica que las bolas no sean repetidas ni esten separadas por mas de dos lugares
short int repartirBolas(int *v , const int dim ){
	int i;
	int retorna = 0;
	for( i = 0 ; i < dim - 2; i ++ ){
		if( ( v[i] + 1 == v[i + 1] ) && ( v[i] + 2 == v[i + 2] && v[i] != v[i+1] && v[i+1] != v[i+2] ) ){
			retorna = 1;
			i=dim -3;
		}
	}
	return retorna;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int eliminadup(int a[], int n);
void mezcla(int a[], int izda, int medio, int drcha, int tam);
void mergesort(int a[], int primero, int ultimo, int M);

int main()
{
    int n, i;
    char answer[4]="NO";
    scanf("%d", &n);

    int array[n];
    //se lee size de los balls
    for(i=0; i<n; i++)
        scanf("%d", &array[i]);
    //se ordena de menor a mayor de acuerdo el size de los balls
    mergesort(array, 0, n, n);
    n = eliminadup(array, n);

    for(i=0; i < n-2; i++){
        if(array[i+2]-array[i] <= 2){
            strcpy(answer,"YES");
            i=n;//para salir del bucle
        }
    }
        printf("%s", answer);

    return 0;
}//end main

void mergesort(int a[], int primero, int ultimo, int M){
    int central;
    if(primero < ultimo){
        central = (primero + ultimo)/2;
        mergesort(a, primero, central, M);
        mergesort(a, central+1, ultimo, M);
        mezcla(a, primero, central, ultimo, M);
    }//end if
}//end mergesort

void mezcla(int a[], int izda, int medio, int drcha, int tam)
{
    int tmp[tam];
    int x, y, z;
    x=z=izda;
    y = medio+1;
    /* bucle de mezcla, utiliza tmp[] como array auxiliar,
    z es el índice de tmp[] */
    while(x <= medio && y <= drcha)
    {
        if(a[x] <= a[y])
            tmp[z++] = a[x++];
        else
            tmp[z++] = a[y++];
    }
    /* bucle para mover elementos que quedan de sublistas */
    while(x <= medio)
        tmp[z++] = a[x++];
    while(y <= drcha)
        tmp[z++] = a[y++];
    /* Copia de elementos de tmp[] al array a[] */
    for(z = izda; z <= drcha; z++)
        a[z] = tmp[z];
}//end mezcla

int eliminadup(int a[], int n){
   int i, j, k;
   for (i = 0; i < n; i++) {
      for (j = i + 1; j < n;) {
         if (a[j] == a[i]) {
            for (k = j; k < n; k++) {
               a[k] = a[k + 1];
            }//end for
            n--;
         } else
            j++;
      }//end for
   }//end for
   return n;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int eliminadup(int a[], int n);
void mezcla(int a[], int izda, int medio, int drcha, int tam);
void mergesort(int a[], int primero, int ultimo, int M);

int main()
{
    int n, i;

    int ball1, ball3, flag, h;
    ball1 = ball3 = flag = h = 0;

    scanf("%d", &n);

    int array[n];
    //se lee size de los balls
    for(i=0; i<n; i++)
        scanf("%d", &array[i]);
    //se ordena de menor a mayor de acuerdo el size de los balls
    mergesort(array, 0, n, n);
    n = eliminadup(array, n);

    if( n >= 3){
        for(h = 0; h < n-2; h++){
            ball1 = array[h];
            ball3 = array[h+2];
            if( (ball3-ball1) <= 2){
                flag = 1;
                h=n;
            }
        }//end for

    }//end if

    if(flag == 0)
        printf("NO");
    else
        printf("YES");

    return 0;
}//end main

void mergesort(int a[], int primero, int ultimo, int M){
    int central;
    if(primero < ultimo){
        central = (primero + ultimo)/2;
        mergesort(a, primero, central, M);
        mergesort(a, central+1, ultimo, M);
        mezcla(a, primero, central, ultimo, M);
    }//end if
}//end mergesort

void mezcla(int a[], int izda, int medio, int drcha, int tam)
{
    int tmp[tam];
    int x, y, z;
    x=z=izda;
    y = medio+1;
    /* bucle de mezcla, utiliza tmp[] como array auxiliar,
    z es el índice de tmp[] */
    while(x <= medio && y <= drcha)
    {
        if(a[x] <= a[y])
            tmp[z++] = a[x++];
        else
            tmp[z++] = a[y++];
    }
    /* bucle para mover elementos que quedan de sublistas */
    while(x <= medio)
        tmp[z++] = a[x++];
    while(y <= drcha)
        tmp[z++] = a[y++];
    /* Copia de elementos de tmp[] al array a[] */
    for(z = izda; z <= drcha; z++)
        a[z] = tmp[z];
}//end mezcla

int eliminadup(int a[], int n){
   int i, j, k;
   for (i = 0; i < n; i++) {
      for (j = i + 1; j < n;) {
         if (a[j] == a[i]) {
            for (k = j; k < n; k++) {
               a[k] = a[k + 1];
            }//end for
            n--;
         } else
            j++;
      }//end for
   }//end for
   return n;
}

#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>
#include <stdbool.h>

int comp(const void *a, const void *b){
	const int *da = (const int*)a;
	const int *db = (const int*)b;
    return *da - *db;
}

int main(){
    int n,i,flag=0;
    scanf("%d",&n);
    int arr[n];
    for(i=0;i<n;i++){
        scanf("%d",&arr[i]);
    }
    qsort(arr,n,sizeof(int),comp);
    for(i=2;i<n;i++){
        if(arr[i]-arr[i-2] <= 2 && arr[i-2]!=arr[i-1] && arr[i-1]!=arr[i]){
            flag = 1;
            break;
        }
    }
    if(flag)
        printf("YES");
    else
        printf("NO");
    return 0;
}

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <stdbool.h>
int main()
{
    int n;
    scanf("%d",&n);
    int a[n],i,b[1001];
    memset(b,0,n*sizeof(int));
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
        b[a[i]]=1;
    }
    int k=0,c[n];
    for(i=0;i<1001;i++)
        if(b[i]==1)
          c[k++]=i;
    for(i=0;i<k-2;i++)
    {
        if(c[i+1]-c[i]==1&&c[i+2]-c[i+1]==1)
            break;
    }
    if(i<k-2)
        printf("YES\n");
    else printf("NO\n");
}

#include <stdio.h>

void quicksort( int v[] , int inicio , int fin );
void leerV( int v[] , int tamanio );
int canGivingGifts( int v[] , int tamanio );

int main(){

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

    int v[ n ];
    leerV( v , n );

    quicksort( v , 0 , n - 1 ); /* Ordena el vector de mayor a menor*/

    if( canGivingGifts( v , n ) )
        printf( "YES" );

    else
        printf( "NO" );

    return 0;
}

int canGivingGifts( int v[] , int tamanio ){

    int r = 0;
    int i;

    for( i = 0 ; i < tamanio - 2 ; i++ ){

         if( ( v[ i ] == v[ i + 1 ] + 1 ) && ( v[ i ] == v[ i + 2 ] + 2 ) ){

            r = 1;
            break;

        }
    }

    return r;
}

void leerV( int v[] , int tamanio ){

    int i;

    for( i = 0 ; i < tamanio ; i++ )
        scanf( "%d" , &v[ i ] );

}

void quicksort( int v[] , int inicio , int fin ){   /* se pasa como argumento el vector a ordenar, la posicion del inicio del vector, y el vector de la ultima  */

    void swap( int *a , int *b );
    int i , j , pivote;

    if( inicio < fin ){

        i = inicio;
        j = fin;
        pivote = v[ ( inicio + fin ) / 2 ];

        do{

            while( v[ i ] > pivote )i++;
            while( v[ j ] < pivote )j--;

            if( i <= j ){

                swap( &v[ i ] , &v[ j ] );

                if( i == pivote )
                    pivote = j;

                else if( j == pivote )
                    pivote = i;

                i++;
                j--;

            }
        }while( i <= j );

        if( inicio < j )
            quicksort( v , inicio , j );

        if( i < fin )
        quicksort( v , i , fin );

    }
}

void swap( int *a , int *b ){

    int temp = *a;
    *a = *b;
    *b = temp;

}

#include<stdio.h>

int main () {

	int n;								// cantidad de bolas a ingresar
	int i;								// indice para recorrer
	int j;								// indice para recorrer
	int cont=0;							// cuenta la cantidad de numeros distintos ingresados
	int ban;							// bandera

	//do{								// validacion
		scanf ( "%d", &n );					// se ingresan la cantidad de bolas
	//} while( !(3 <= n && n <= 50) );

	int v[n];							// vector de bolas y sus respectivos pesos, pueden haber bolas repetidas

	for (i=0; i<n; i++) {						// recorre para contar la cantidad de numeros sin repeticion

		//do{							// validacion
			scanf ( "%d", &v[i] );				// se ingresan las respectivas bolas
		//} while ( !((1 <= v[i]) && (v[i] <= 1000)) );

		cont++;
		for ( j=0; j<i; j++ ) {
			if ( v[i]==v[j] ) {
				cont--;
				j=i;
			}
		}
	}

	int b[cont];							// bolas y sus respectivos pesos, sin haber bolas repetidas
	for ( i=0; i<cont; i++ ) {					// se inicializa a cero dicho vector
		b[i]=0;
	}

	for ( i=0; i<n; i++ ) {						// recorre el vector v para cargar los no repetidos en b
		ban=1;
		for ( j=0; (j<cont && ban!=0 && b[j]!=0); j++ ) {	// recorre el vector b para cargar en el los no repetidos de v
			if ( v[i]==b[j] ) {
				ban=0;
			}
		}
		if ( ban ) {
			b[j]=v[i];
		}
	}

	for ( i=1; i<cont; i++ ) {					// recorre b para ordenarlo por burbuja
		for ( j=0; j<cont-i; j++ ) {
			if ( b[j]>b[j+1] ) {				// si se cumple dicha condicion se intercambian las bolas
				b[j]=b[j]+b[j+1];
				b[j+1]=b[j]-b[j+1];
				b[j]=b[j]-b[j+1];
			}
		}
	}

	for ( i=0; i<cont-2; i++ ) {					// compara los numeros con sus dos siguientes para determinar si cumple
		if ( b[i+1]-b[i] <= 2 && b[i+2]-b[i] <= 2 && b[i+2]-b[i+1] <= 2 ) {
			ban=1;
			i=cont-2;
		}
	}

	if ( ban ) {							// si hay uno que cumple ban=1 y se imprime SI caso contrario NO
		printf( "SÍ" );
	}else{
		printf( "NO" );
	}

	return 0;

}

#include <stdio.h>
int main()
{
    int n, p1, p2, p3, i=0, j=0, k=0, menor, mayor;
    scanf("%d", &n);
    int tam[n];
    for(i=0; i<n; i++)
    {
        scanf("%d", &tam[i]);
    }
    i=0;
    j=0;
    k=0;
    for(i=0; i<n; i++)
    {
        for(j=i+1; j<n; j++)
        {
            if(tam[i]+1==tam[j] || tam[j]+1==tam[i] || tam[i]+2==tam[j] || tam[j]+2==tam[i])
            {
                p1=tam[i];
                p2=tam[j];
                if(p1<p2)
                {
                    menor=p1;
                    mayor=p2;
                }
                else if(p1>p2)
                {
                    menor=p2;
                    mayor=p1;
                }
                for(k=i+1; k<n; k++)
                {
                    if(tam[k]+2==menor || tam[k]+1==mayor)
                    {
                        p3=tam[k];
                        printf("YES");
                        return 0;
                    }
                }
            }
        }
    }
    printf("NO");
    return 0;
}

#include<stdio.h>
int main()
{
        int n,c,d=1,b,flag=0,x,y,w,q;
        scanf("%d",&n);
        int a[n];
        for(c=0;c<n;c++)
        {
                scanf("%d",&a[c]);
        }
        for(c=0;c<n-1;c++)
        {
                for(b=c+1;b<n;b++)
                {
                        if(a[c]==a[b]) continue;
                        else if((a[c]-a[b])>2||(a[c]-a[b])<-2) continue;
                        else
                        {
                                d++;
                                if(d==2)
                                {
                                        flag=1;
                                        x=c;
                                        y=b;
                                        goto yes;
                                }
                        }
                }
        }
        yes:
        if(flag==0) printf("NO");
        else if(flag==1)
        {
                flag=0;
                for(c=0;c<n;c++)
                {
                        if(c==x||c==y) continue;
                        else if(a[c]!=a[x]&&a[c]!=a[y])
                        {
                                q=a[c]-a[x];
                                if(q<0) q=q*-1;
                                w=a[c]-a[y];
                                if(w<0) w=w*-1;
                                if(q<2&&q>0&&w<2&&w>0)
                                {
                                        flag=1;
                                        break;
                                }
                        }
                }
                if(flag==1) printf("YES");
                else printf("NO");
        }
}

//by ahmeterdem™
#include <stdio.h>
#include <string.h>
#include <math.h>
#define min(a,b) (a<b)?a:b
#define max(a,b) (a<b)?b:a
#define FOR (i,a,b) for(i=a;i<b;i++)
#define ROF(i,a,b) for(i=b;i>=0;i--)
long long	int i,n,t,arr[1003],a[1040];
int main() {
	scanf("%lld",&n);
	for(i=0;i<n;i++){
		scanf("%lld",&t);
		a[t]++;
	}

	for(i=2;i<1000;i++)
		if(a[i-2] && a[i-1] && a[i]){
			printf("YES");
			return 0 ;
		}
	printf("NO");
}

#include <stdio.h>
void swap (int *v, int i, int j);
void quick (int *v, int ini, int fin);

int main (){
	//TAMAÑO ARREGLO
	int N;
	scanf ("%d", &N);
	//CARGAR ARREGLO
	int V[N];
	int cont;
	for (cont = 0; cont < N; cont++){
		scanf ("%d", &V[cont]);
	}
	//ORDENAR ARREGLO
	quick(V, 0, N-1);
	//BUSCAR MENOR
	char *R[2] = {"YES", "NO"};
	int a, cont2;
	a=1;
	for (cont = 0; cont < N-2; cont++){
		if( (V[cont+1]-V[cont]) == 1){
			for (cont2 = cont+2; cont < N; cont2++){
				if ((V[cont2]-V[cont+1]) == 1){
					a = 0;
					cont2 = N;
					cont = N;
				}
			}
		}
	}
	printf ("%s", R[a]);

	return 0;
}
void swap (int *v, int i, int j){
	int aux;

	aux = *(v+i);
	*(v+i) = *(v+j);
	*(v+j) = aux;
}
int pivot(int *v, int izq, int der){
	int i, pivote, valor_pivote;

	pivote = izq;
	valor_pivote = *(v+pivote);
	for(i = izq+1; i <=der; i++){
		if (*(v+i) < valor_pivote){
			pivote++;
			swap(v, i, pivote);
		}
	}
	swap(v, izq, pivote);

	return pivote;
}
void quick (int *v, int ini, int fin){
	int pivote;
	if(ini < fin){
		pivote = pivot(v, ini, fin);
		quick(v, ini, pivote-1);
		quick(v, pivote+1, fin);
	}
}

#include<stdio.h>
#define T 1001
int main() {
	//因为ti的值最大是1000，所以我选择用exist方法
	int n;
	scanf("%d",&n);
	char exist[T];
	int i;
	for(i=0;i<T;i++){
		exist[i]=0;
	}
	for(i=0;i<n;i++){
		int t;
		scanf("%d",&t);
		exist[t]=1;
	}
	int count=0;
	for(i=1;i<T;i++){
		if(exist[i]){
			count++;
			if(count>=3){
				printf("YES\n");
			}
		}else{
			count=0;
		}
	}
	printf("NO\n");
	return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int eliminadup(int a[], int n);
void mezcla(int a[], int izda, int medio, int drcha, int tam);
void mergesort(int a[], int primero, int ultimo, int M);

int main()
{
    int n, i;
    char answer[4]="NO";
    scanf("%d", &n);

    int array[n];
    //se lee size de los balls
    for(i=0; i<n; i++)
        scanf("%d", &array[i]);
    //se ordena de menor a mayor de acuerdo el size de los balls
    mergesort(array, 0, n, n);
    n = eliminadup(array, n);
    for(i=0; i<n; i++)
        printf("%d", array[i]);

    for(i=0; i < n-2; i++)
        if(array[i+2]-array[i] <= 2){
            strcpy(answer,"YES");
            i=n;//para salir del bucle
        }

        printf("%s", answer);

    return 0;
}//end main

void mergesort(int a[], int primero, int ultimo, int M){
    int central;
    if(primero < ultimo){
        central = (primero + ultimo)/2;
        mergesort(a, primero, central, M);
        mergesort(a, central+1, ultimo, M);
        mezcla(a, primero, central, ultimo, M);
    }//end if
}//end mergesort

void mezcla(int a[], int izda, int medio, int drcha, int tam)
{
    int tmp[tam];
    int x, y, z;
    x=z=izda;
    y = medio+1;
    /* bucle de mezcla, utiliza tmp[] como array auxiliar,
    z es el índice de tmp[] */
    while(x <= medio && y <= drcha)
    {
        if(a[x] <= a[y])
            tmp[z++] = a[x++];
        else
            tmp[z++] = a[y++];
    }
    /* bucle para mover elementos que quedan de sublistas */
    while(x <= medio)
        tmp[z++] = a[x++];
    while(y <= drcha)
        tmp[z++] = a[y++];
    /* Copia de elementos de tmp[] al array a[] */
    for(z = izda; z <= drcha; z++)
        a[z] = tmp[z];
}//end mezcla

int eliminadup(int a[], int n){
   int i, j, k;
   for (i = 0; i < n; i++) {
      for (j = i + 1; j < n;) {
         if (a[j] == a[i]) {
            for (k = j; k < n; k++) {
               a[k] = a[k + 1];
            }//end for
            n--;
         } else
            j++;
      }//end for
   }//end for
   return n;
}

#include<stdio.h>
void quicksort(int vec[] , int inicio, int fin);
int main()
{
    int n,i,j;
    int c;
    scanf("%d",&n);
    int v[n];
    for(i=0; i<n;i++)
    {
        scanf("%d",&v[i]);
    }
    quicksort(v, 0, n-1);
    c=0;
    for (i=0; i<n ; i++)
    {
        if(v[i+1]-v[i]==1 && v[i+2]-v[i]==2)
        {
            c++;
        }
    }
    if(c!=0)
        printf("YES");
    else
        printf("NO");

    return 0;
}

void quicksort(int vec[], int inicio, int fin){
  int pivote, i, j, temp;
  if(inicio < fin) {
    pivote = inicio;
    i = inicio;
    j = fin;
    while(i < j) {
     while(vec[i] <= vec[pivote] && i <= fin){
        i++;
      }
      while(vec[j] > vec[pivote] && j >= inicio){
        j--;
      }
      if(i < j) {
        temp = vec[i];
        vec[i] = vec[j];
        vec[j] = temp;
      }
    }
    temp = vec[j];
    vec[j] = vec[pivote];
    vec[pivote] = temp;
    quicksort(vec, inicio, j-1);
    quicksort(vec, j+1, fin);
  }
}

#include<stdio.h>
#define T 1001
int main() {
	//因为ti的值最大是1000，所以我选择用exist方法
	int n;
	scanf("%d",&n);
	char exist[T];
	int i;
	for(i=0;i<T;i++){
		exist[i]=0;
	}
	for(i=0;i<n;i++){
		int t;
		scanf("%d",&t);
		exist[t]=1;
	}
	for(i=1;i<T-3;i++){
		if(exist[i] && exist[i+1] && exist[i+2]){
			printf("YES\n");
			return 0;
		}
	}
	printf("NO\n");
	return 0;
}

#include <stdio.h>
int main()
{
    int n, p1, p2, p3, i=0, j=0, k=0, menor, mayor;
    scanf("%d", &n);
    int tam[n];
    for(i=0; i<n; i++)
    {
        scanf("%d", &tam[i]);
    }
    i=0;
    j=0;
    k=0;
    for(i=0; i<n; i++)
    {
        for(j=i+1; j<n; j++)
        {
            if(tam[i]+1==tam[j] || tam[j]+1==tam[i] || tam[i]+2==tam[j] || tam[j]+2==tam[i])
            {
                p1=tam[i];
                p2=tam[j];
                if(p1<p2)
                {
                    menor=p1;
                    mayor=p2;
                }
                else
                {
                    menor=p2;
                    mayor=p1;
                }
                for(k=j+1; k<n; k++)
                {
                    if(tam[k]+2==menor || tam[k]+1==mayor)
                    {
                        p3=tam[k];
                        printf("YES");
                        return 0;
                    }
                }
            }
        }
    }
    printf("NO");
    return 0;
}

#include<stdio.h>
typedef unsigned u;
u D[1111];
int main()
{
	u n,i=-1,j;
	for(scanf("%u",&n);++i<n;++D[j])scanf("%u",&j);
	for(i=-1;++i<1000;)
    {
        if(D[i]&&D[i+1]&&D[i+2])
        {
            printf("YES\n");
        }else
        {
           	printf("NO\n");
        }
    }
	return 0;
}

#include <stdio.h>

int f(const void *a, const void *b){
    return (*(int*)a - *(int*)b);
}

int main()
{
    int n, x[52];
    scanf("%d", &n);
    for(int i=0; i<n; i++)scanf("%d", &x[i]);
    qsort(x, n, sizeof(x[0]), f);
    for(int i=0; i<n-2; i++)if(x[i]==x[i+1]-1 && x[i]==x[i+2]-2) return 0*printf("YES");
    printf("NO");
}

#include<stdio.h>
#include<stdlib.h>
int cmpfunc (const void * a, const void * b)
{
   return ( *(int*)a - *(int*)b );
}
int main()
{
	int a[50],t;
	scanf("%d",&t);
	while(t--)
	{
		int n;scanf("%d",&n);
		int i,j,count=0;
		for(i=0;i<n;i++)
			scanf("%d",&a[i]);
		qsort(a,n,sizeof(int),cmpfunc);
		for(i=0;i<n;i++)
		{
			for(j=i+1;j<i+3;j++)
			{
				if(a[j]-a[i]<=2 &&a[j]-a[i]!=0)
					count++;
				if(count==2){printf("YES\n");goto y;}
			}
		}
		y:if(count!=2)printf("NO\n");
	}
	return 0;
}

#include <stdio.h>

void ordenar (int a[],int primero,int ultimo){
    int i,j,central;
    double pivote;
    central = (primero+ultimo)/2;
    pivote = a[central];
    i=primero;
    j=ultimo;
    do
    {
        while (a[i]<pivote) i++;
        while (a[j]>pivote) j--;
        if (i<=j)
        {
            int aux;
            aux= a[i];
            a[i]=a[j];
            a[j]=aux;
            i++;
            j--;
        }
    } while (i<=j);
    if (primero<j)
    {
        ordenar (a,primero,j);
    }
    if (i< ultimo)
    {
        ordenar (a,i,ultimo);
    }
}

int main()
{
    int n;
    int i;
    int BAN=0;
    scanf("%d",&n);
    int size[n];

    for (i=0;i<n;i++)
    {
        scanf("%d",&size[i]);
    }

    ordenar(size,0,n-1);

    for (i=0;i<n-2;i++)
    {
        if(size[i]+1==size[i+1] && size[i+1]+1==size[i+2])
        {
            BAN=1;
            i=n;
        }
    }

    if (BAN==1)
    {
        printf("YES");
    }else{
        printf("NO");
    }

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
int compare (const void* a, const void* b)
{
    return *(int*)(a) - *(int*)(b);
}
int main()
{
    int n;
    bool r = false;
    int t[1001];
    scanf("%d",&n);
    for(int i=0;i<n;i++)
        scanf("%d",&t[i]);
   qsort(t,n,sizeof(int),compare);
   for(int i=0;i<n-2;i++)
   {
       if(t[i]+1==t[i+1] && t[i+1]+1==t[i+2])
       {
           r = true;
           break;
       }

   }
   if(r)printf("yes"); else printf("no");
   return 0;
}

#include<stdio.h>
int main()
{
    int n,flag=0,midindex=0,i,j,temp;
    scanf("%d",&n);
    int a[1000];
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    for(i=0;i<n-1;i++)
    {
        midindex=i;
        for(j=i+1;j<n;j++)
        {
            if(a[midindex]>a[j])
            midindex=j;
        }
        if(midindex!=i)
        {
            temp=a[midindex];
            a[midindex]=a[i];
            a[i]=temp;
        }
    }
    for(i=0;i<=n-3;i++)
    {
        if(a[i]+1==a[i+1]&&a[i]+2==a[i+2])
        flag++;
    }
    if(flag>0)
    printf("YES");
    else
    printf("NO");
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int eliminadup(int a[], int n);
void mezcla(int a[], int izda, int medio, int drcha, int tam);
void mergesort(int a[], int primero, int ultimo, int M);

int main()
{
    int n, i;
    char answer[4]="NO";
    scanf("%d", &n);

    int array[n];
    //se lee size de los balls
    for(i=0; i<n; i++)
        scanf("%d", &array[i]);
    //se ordena de menor a mayor de acuerdo el size de los balls
    mergesort(array, 0, n, n);
    n = eliminadup(array, n);

    for(i=0; i < n-2; i++)
        if(array[i+2]-array[i] <= 2){
            strcpy(answer,"YES");
            i=n;//para salir del bucle
        }

        printf("%s", answer);

    return 0;
}//end main

void mergesort(int a[], int primero, int ultimo, int M){
    int central;
    if(primero < ultimo){
        central = (primero + ultimo)/2;
        mergesort(a, primero, central, M);
        mergesort(a, central+1, ultimo, M);
        mezcla(a, primero, central, ultimo, M);
    }//end if
}//end mergesort

void mezcla(int a[], int izda, int medio, int drcha, int tam)
{
    int tmp[tam];
    int x, y, z;
    x=z=izda;
    y = medio+1;
    /* bucle de mezcla, utiliza tmp[] como array auxiliar,
    z es el índice de tmp[] */
    while(x <= medio && y <= drcha)
    {
        if(a[x] <= a[y])
            tmp[z++] = a[x++];
        else
            tmp[z++] = a[y++];
    }
    /* bucle para mover elementos que quedan de sublistas */
    while(x <= medio)
        tmp[z++] = a[x++];
    while(y <= drcha)
        tmp[z++] = a[y++];
    /* Copia de elementos de tmp[] al array a[] */
    for(z = izda; z <= drcha; z++)
        a[z] = tmp[z];
}//end mezcla

int eliminadup(int a[], int n){
   int i, j, k;
   for (i = 0; i < n; i++) {
      for (j = i + 1; j < n;) {
         if (a[j] == a[i]) {
            for (k = j; k < n; k++) {
               a[k] = a[k + 1];
            }//end for
            n--;
         } else
            j++;
      }//end for
   }//end for
   return n;
}

#include <stdio.h>
#include <stdlib.h>
void merge(int *p, int l, int m, int r);
void mergeSort (int *p, int l, int r);

int main(int argc, char const *argv[])
{
	int n, i, h=0,j,k;
	scanf("%d", &n);
	int balls[n];
	/*for(i = 0; i < n; i++){
		scanf("%d", &balls[i]);
	}*/
//	mergeSort(balls, 0, n-1);
	for(i = 0; i < n; i++){
		printf("%d ", balls[i]);
	}
	for (i = 0; i < n-2; i++){
		for (j = i+1; j < n-1; j++){
			if (abs(balls[i]-balls[j]) < 3){
				for (k = j+1; k < n; k++){
					if(abs(balls[i])-balls[k] < 3){
						if(balls[i] != balls[j] && balls[j] != balls[k] && balls[i] != balls[k]){
							h = 1;
						}
					}
				}
			}
		}
	}

	if (h)
	{
		printf("YES");
	}else{
		printf("NO");
	}

	return 0;
}

void mergeSort (int *p, int l, int r){
	if(l<r){
		int m=(l+r)/2;
		mergeSort(p, l, m);
		mergeSort(p, m+1, r);
		merge(p, l, m, r);

	}
}

void merge(int *p, int l, int m, int r){
	int n1, n2, i, j, k;
	n1=m-l+1;
	n2=r-m;
	int v1[n1], v2[n2];
	for (i=0; i<n1;i++){
		v1[i]=*(p+(l+i));
	}
	for (j=0; j<n2;j++){
		v2[j]= *(p+(j+m+1));
	}
	i=0;
	j=0;
	k=l;
	while(i<n1 && j<n2){
		if(v1[i]<=v2[j]){
			*(p+k)=v1[i];
			i++;
		}else{
			*(p+k)= v2[j];
			j++;
		}
		k++;
	}
	while(i<n1){
		*(p+k)=v1[i];
		i++;
		k++;
	}
	while(j<n2){
		*(p+k)=v2[j];
		k++;
		j++;
	}

}

#include<stdio.h>

int main()
{
    int balls,i,j,c=0,temp,size[1000];
    scanf("%d",&balls);
    if(balls>2&&balls<51)
    {
        for(i=0; i<balls; i++)scanf("%d",&size[i]);
        for (i=0; i<balls; i++)
        {
            for(j=0; j<(balls-i-1); j++)
            {
                if(size[j]>size[j+1])
                {
                    size[j]^=size[j+1]^=size[j]^=size[j+1];
                }
            }
        }
        for(i=0; i<balls; i++)
        {
            if(size[i+1]==size[i])
            {
                c++;
                for( j=i; j<balls-c; j++)
                    size[j]=size[j+1];
                size[balls-c--]=0;
                printf("-");
            }

        }
        for (i = 0; i < balls; i++)
        {
            printf("%d ", size[i]);
        }
        for (j=0; j<balls; j++)
        {
            c++;

            if(size[j+1]==size[j]+1)
            {
                if(size[j+2]==size[j+1]+1)
                {
                    printf("YES");
                    return 0;
                }
                else
                {
                    printf("NO");
                    return 0;
                }
            }
            else if(size[j+1]!=size[j]+1)
            {
                if(c==balls&&(size[j+2]!=size[j+1]+1))
                {
                    printf("NO");
                    break;
                }
            }

        }
    }
    else return 0;
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#define pi 3.1415926
#define rep(x,ini,end) for(x=(ini);x<(end);x++)
#define per(x,ini,end) for(x=(end-1);x>=(ini);x--)
#define max(x,y) ((x)>(y)?(x):(y))
#define min(x,y) ((x)<(y)?(x):(y))

int t[100] = {0};

void quickSort(int a[], int beginPos, int endPos)
{
    int i = beginPos, j = endPos;
    int flag = a[beginPos];
    //int bePos_L, bePos_R, endPos_L, endPos_R;
    //int countL = 0, countR = 0;
    if (beginPos>=endPos)
    {
        return;
    }

    while (i<j)
    {
        while ((a[j]>flag) && (i<j))
        {
            --j;
        }
        if (i == j)
        {
            break;
        }

        a[i] = a[j]; a[j] = flag;
        ++i;

        while ((a[i]<flag) && (i<j))
        {
            ++i;
        }
        if (i == j)
        {
            break;
        }

        a[j] = a[i]; a[i] = flag;
        --j;
    }

    quickSort(a, beginPos, i-1);
    quickSort(a, i+1, endPos);
}

int main()
{
    int n;
    scanf("%d", &n);

    int i;
    rep(i,0,n)
    {
        scanf("%d", &t[i]);
    }
    quickSort(t, 0, n-1);

    int count = 1;
    int flag = t[0];

    rep(i,1,n)
    {
        if ((t[i]!=flag) && (t[i]-flag<3))
        {
            count++; flag = t[i];
            if (count == 3)
            {
                printf("YES"); return 0;
            }
            continue;
        }
        count = 1;
    }
    if (count == 3)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int col[30], row[30];

int main()
{
    int n, i, j, ans = 0;
    scanf("%d", &n);
    int arr[n][n];
    for (i = 0; i < n; i++){
        for (j = 0; j < n; j++){
            scanf("%d", &arr[i][j]);
            row[i] += arr[i][j];
            col[j] += arr[i][j];
        }
    }
    for (i = 0; i < n; i++){
        for (j = 0; j < n; j++){
            if (col[j] > row[i]) ans++;
        }
    }
    printf("%d\n", ans);
    return 0;
}

#include<stdio.h>

int main(){
    int n;
    scanf("%d",&n);
    int balls[n];
    int i,j;
    int a,b,c;
    int aux;
    int puede;
    puede = 0;

    for (i = 0;i < n; i++){
        scanf("%d",&balls[i]);
    }
     for (i = 0; i < n-1; i++){
       for (j = 0; j < n-i-1; j++){
           if (balls[j] > balls[j+1]){
                aux        = balls[j];
                balls[j]   = balls[j+1];
                balls[j+1] = aux;
            }
        }
    }
    for (i = 1; i<n-1; i++){
        a = balls[i-1];
        b = balls[i];
        c = balls[i+1];

        if(b - a == 1 && c - b == 1  && (a+b+c)/3 == b){
            puede = 1;
        }
    }
    if(puede == 1){
        printf("YES");
    }
    else{
        printf("NO");
    }
}

#include <stdio.h>
#include <stdlib.h>

int main(){
    int n,t,vector[50],m,i,bandera =0,a,b,c,dif,dif2,dif3;
    scanf("%d",&n);
    if(n<3 || n>50){
        do{
        printf("Valor incorrecto. Vuelva a intentarlo\n");
        scanf("%d",&n);
        }while(n<3 || n>50);
    }

    for(i = 0; i < n; i++){
        scanf("%d",&t);
        if(t<1 || t>1000){
            do{
            printf("Valor incorrecto. Vuelva a intentarlo\n");
            scanf("%d",&t);
            }while(n<3 || n>50);
        }
        vector[i] = t;
    }

    for(a = 0; a < n-2; a++){
        for(b = a+1; b < n-1; b++){
            for(c = b+1; c < n; c++){
                    dif = abs(vector[a]-vector[b]);
                    dif2 = abs(vector[a]-vector[c]);
                    dif3 = abs(vector[c]-vector[b]);
                    if(dif < 3 && dif2 < 3 && dif3 < 3 && vector[a] != vector[b] && vector[a] != vector[c] && vector[b] != vector[c]){
                        printf("YES");
                        bandera = 1;
                    }
            }
        }
    }
    if(bandera != 1){
        printf("NO");
    }
        return 0;
}

#include<stdio.h>
#include<stdlib.h>

int cmpfunc (const void * a, const void * b)
{
   return ( *(int*)a - *(int*)b );
}

int main()
{

int n;
int arr[53],i;
scanf("%d",&n);
for( i=0;i<n;i++)
{
scanf("%d",&arr[i]);
}
qsort(arr, n, sizeof(int), cmpfunc);

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

if(arr[i]!=arr[i-1] && (arr[i] == (arr[i-1]+1)))
counts++;
else
counts=0;
if(counts ==2)
{
printf("YES");
flag =1;
break;
}
}
if(flag==0)
printf("NO");

return 0;
}