/* KSP 14-1-4
 * k-Klidna posloupnost
 * 
 * Petr Baudis
 * Rocnik: 2
 * Skola: Ad Fontes
 */


/*
 * Vstup:
 * 
 * K N
 * N-krat A kde A je clen posloupnosti
 *
 * Vystup:
 * 
 * J-krat A kde A je clen nejdelsi klidne posloupnosti a J jeji delka.
 *
 * Algoritmus:
 *
 * Pri nacitani posloupnosti si ji postupne ukladame do pole, setrideneho podle
 * poradi zadavani posloupnosti (kvuli vyhledavani si vytvorime i pomocne pole,
 * jehoz indexem budou primo cisla v posloupnosti a obsahem pozice daneho cisla
 * v posloupnosti). Zaroven si u kazdeho cisla budeme ukladat i nasledujici
 * cislo v klidne posloupnosti a celkovou zbyvajici delku klidne posloupnosti
 * (od daneho cisla do konce posloupnosti), zatim tyto cisla nezinicializujeme.
 * Dale si u kazdeho cisla ulozime, jestli uz jsme ho otestovali, tudiz jestli
 * jsou tyto hodnoty platne. Tento priznak inicializujeme na nulu.
 *
 * Po nacteni cele posloupnosti projdeme postupne po rade celou posloupnost, a
 * otestujeme kazde cislo, ktere jsme jeste netestovali. Po projiti cele
 * posloupnosti vypiseme cislo s nejdelsi delkou klidne posloupnosti a postupne
 * pomoci ulozenych odkazu na nasledujici cislo v posloupnosti celou tuto
 * posloupnost.
 *
 * Testovani probiha nasledujicim zpusobem. Postupne budeme zkouset kazde i+n,
 * kde i je testovane cislo a pro n plati -k <= n <= k && n != 0. Pokud n bylo
 * clenem posloupnosti a vyskytlo se v ni az po cislu, ktere prave testujeme,
 * zkontrolujeme, jestli jiz bylo otestovano - pokud ne, otestujeme ho. Po
 * projiti vsech n vybereme to, jehoz zbytkova delka klidne posloupnosti je
 * nejdelsi (pokud jich je nekolik, libovolne z nich), delku klidne
 * posloupnosti zvysime o jednicku a k testovanemu cislu priradime jako
 * nasledujici prvek klidne posloupnosti ono n. Pokud jsme zadne vyhovujici n
 * nenasli, nasledujici prvek klidne posloupnosti nastavime na -1, tim
 * indikujeme konec posloupnosti.
 *
 * Pametova slozitost je O(N) (pro kazdy prvek alokujeme pouze jednu polozku v
 * poli), casova slozitost taktez O(N) (kazdy prvek testujeme pouze jednou).
 */

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


typedef struct {
  int val;
  int tested;
  int len;
  int next; /* index v p1 */
} num_t;

num_t *p1 = NULL; /* pole cisel */
int *p2 = NULL; /* indexovano hodnotou cisla, obsah -1 nebo index v p1 */
int p1max = 0, p2max = 0;

int k;
int maxlen = 0, maxlen_i = -1;


void
classify(int i) {
  int n;

  p1[i].tested = 1;
  p1[i].len = 0;
  p1[i].next = -1;

  for (n = p1[i].val-k; n <= p1[i].val+k; n++) {
    if (n == p1[i].val || n > p2max || n < 0 || p2[n] < i)
      continue;

    if (! p1[p2[n]].tested)
      classify(p2[n]);

    if (p1[p2[n]].len > p1[i].len) {
      p1[i].len = p1[p2[n]].len;
      p1[i].next = p2[n];
    }
  }

  p1[i].len++;
}


int
main() {
  int n;

  scanf("%d", &k);
  scanf("%d", &p1max);
  p1 = calloc(p1max, sizeof(num_t));
  if (! p1) {
    fprintf(stderr, "NE\n");
    exit(1);
  }

  for (n = 0; n < p1max; n++) {
    int num;
    scanf("%d", &num);
    
    /* musime realokovat pole */
    if (num > p2max) {
      int n2;

      p2 = realloc(p2, (num + 1) * sizeof(int));
      if (! p2) {
	printf("NE\n");
	exit(2);
      }

      /* inicializuj cerstvou cast */
      for (n2 = p2max + 1; n2 <= num; n2++)
	p2[n2] = -1;

      p2max = num;
    }

    p1[n].val = num;
    p2[num] = n;
  }

  for (n = 0; n < p1max; n++) {
    if (! p1[n].tested) {
      classify(n);

      if (p1[n].len > maxlen) {
        maxlen = p1[n].len;
	maxlen_i = n;
      }
    }
  }

  {
    while (maxlen_i + 1) {
      printf("%d ", p1[maxlen_i].val);
      maxlen_i = p1[maxlen_i].next;
    }
  }
  printf("\n");

  return 0;
}