class LinkedListNode {
  constructor(value) {
    this.value = value;
    this.next = null;
    this.prev = null;
  }
}
//DoublyLinkedList

class DoublyLinkedList {
  constructor() {
    this.head = null;
    this.tail = null;
    this.count = 0;
    this.map = new Map();
  }

  moveBefore(value1, value2) {
    let valueToMove = this.find(value1); //miro
    let staticValue = this.find(value2); //gosho

    this.remove(valueToMove);
    this.insertBefore(staticValue, value1);
  }

  moveAfter(value1, value2) {
    let valueToMove = this.find(value1); //miro
    let staticValue = this.find(value2); //gosho

    this.remove(valueToMove);
    this.insertAfter(staticValue, value1);
  }

  remove(node) {
    this.map.delete(node.value);

    let firstNodePrevious = node.prev; //penka
    let firstNodeNext = node.next; //stanka

    if (firstNodePrevious === null && firstNodeNext === null) {
      //do not handle
    } else if (firstNodePrevious === null) {
      firstNodeNext.prev = null;
      this.head = firstNodeNext;
    } else if (firstNodeNext === null) {
      firstNodePrevious.next = null;
      this.tail = firstNodePrevious;
    } else {
      firstNodePrevious.next = firstNodeNext; //penka.next = stanka
      firstNodeNext.prev = firstNodePrevious; //stanka.prev = penka
    }
  }

  addLast(value) {
    let node = new LinkedListNode(value);

    if (this.count === 0) {
      this.map.set(value, node);
      this.head = node;
      this.tail = node;
    } else {
      this.map.set(value, node);
      this.tail.next = node;
      node.prev = this.tail;
      this.tail = node;
    }

    this.count++;
  }

  insertBefore(prevNode, value) {
    //insert an element with the given value before the given node
    let newNode = new LinkedListNode(value);
    this.count++;

    this.map.set(value, newNode);

    let tempPrevNode = prevNode;
    let previousNode = tempPrevNode.prev;

    if (previousNode !== null) {
      newNode.next = tempPrevNode;
      tempPrevNode.prev = newNode;
      previousNode.next = newNode;
      newNode.prev = previousNode;
    } else {
      newNode.next = tempPrevNode;
      tempPrevNode.prev = newNode;
      newNode.prev = null;
      this.head = newNode;
    }
  }

  insertAfter(prevNode, value) {
    // insert an element with the given value after the given node
    let newNode = new LinkedListNode(value);
    this.count++;

    this.map.set(value, newNode);

    let tempPrevNode = prevNode;
    let nextNode = prevNode.next;

    if (nextNode !== null) {
      newNode.prev = tempPrevNode;
      tempPrevNode.next = newNode;
      newNode.next = nextNode;
      nextNode.prev = newNode;
    } else {
      newNode.prev = tempPrevNode;
      tempPrevNode.next = newNode;
      newNode.next = null;
      this.tail = newNode;
    }
  }

  find(value) {
    // returns the first node that has the given value or undefined if no such value exists
    if (this.map.has(value)) {
      let node = this.map.get(value);
      return node;
    } else {
      return null;
    }
  }

  values() {
    let values = [];
    let tempHead = this.head;

    while (tempHead !== null) {
      values.push(tempHead.value);
      tempHead = tempHead.next;
    }
    return values;
  }
}

//Solution

let list = new DoublyLinkedList();

let [numbers, countOfNumberToBeMoved] = gets()
  .split(" ")
  .map((el) => Number(el)); //7,4

//1,2,3,4,5,6,7
for (let index = 1; index <= numbers; index++) {
  list.addLast(index);
}

let numbersToBeMoved = gets().split(" "); //1 5 4 7

for (let index = 0; index < numbersToBeMoved.length; index++) {
  const number = Number(numbersToBeMoved[index]); //1

  if (number % 2 == 0) {
    let after = number / 2;
    if (number === after) {
      continue;
    }
    //move the number after the after
    list.moveAfter(number, after);
  } else {
    let after = number * 2;

    if (after >= numbers) {
      //move it after the numbers -> 7
      if (number === numbers) {
        continue;
      }
      list.moveAfter(number, numbers);
    } else {
      if (number === after) {
        continue;
      }
      //move the number after the after
      list.moveAfter(number, after);
    }
  }

  //if number and after are the same - do nothing??
}
print(list.values().join(" "));