Limak is a little polar bear. He has n balls, the i-th ball has size ti.Limak wants to give one ball to each of his three friends. Giving gifts isn't easy — there are two rules Limak must obey to make friends happy:  No two friends can get balls of the same size.  No two friends can get balls of sizes that differ by more than 2. For example, Limak can choose balls with sizes 4, 5 and 3, or balls with sizes 90, 91 and 92. But he can't choose balls with sizes 5, 5 and 6 (two friends would get balls of the same size), and he can't choose balls with sizes 30, 31 and 33 (because sizes 30 and 33 differ by more than 2).Your task is to check whether Limak can choose three balls that satisfy conditions above.

The first line of the input contains one integer n (3 ≤ n ≤ 50) — the number of balls Limak has. The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 1000) where ti denotes the size of the i-th ball.

Print "YES" (without quotes) if Limak can choose three balls of distinct sizes, such that any two of them differ by no more than 2. Otherwise, print "NO" (without quotes).

NoteIn the first sample, there are 4 balls and Limak is able to choose three of them to satisfy the rules. He must must choose balls with sizes 18, 16 and 17.In the second sample, there is no way to give gifts to three friends without breaking the rules.In the third sample, there is even more than one way to choose balls:  Choose balls with sizes 3, 4 and 5.  Choose balls with sizes 972, 970, 971.

#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>
#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>
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>
#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 <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>
#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>
#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<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>

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>
#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>
#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>
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>
#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 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>
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;
}

//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<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>
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 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>
#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 <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);
}

#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");
    }
}

#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++;
	}

}

// 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>

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>

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>
#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 <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>
#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 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>

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>

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>
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>
#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>
#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>

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>
#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);
}

#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>

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>
#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>
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>
#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>

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>
#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;
}