perfe

const input =
    [
        '7 4',
        '1 5 4 7'
    ]

let print = this.print || console.log;
let gets = this.gets || ((arr, index) => () => arr[index++])(input, 0);

try {
    class NodeList {
        constructor(val) {
            this.val = val;
            this.next = null;
            this.prev = null;
        }
    }

    class DLL {

        constructor() {
            this.tail;
            this.head;
            this.map = new Map();
        }

        createList(num) {
            for (let i = 1; i <= num; i++) {

                if (!this.head) {
                    const newNode = new NodeList(i);
                    this.head = newNode
                    this.tail = newNode;
                    this.map.set(i, newNode);
                } else {
                    const newNode = new NodeList(i);
                    newNode.prev = this.tail;
                    this.tail.next = newNode;
                    this.tail = newNode;
                    this.map.set(i, newNode);
                }
            }
        }

        toString() {
            let temp = this.head
            let str = ''
            while (temp != null) {
                if (temp.next === null) {
                    str += temp.val;
                    temp = temp.next;
                } else {
                    str += temp.val + ' '
                    temp = temp.next;
                }
            }
            return str;
        }

        shuffle(shuffleNumber) {
            let insertAfter;

            if (shuffleNumber % 2 === 0)
                insertAfter = shuffleNumber / 2;

            if (shuffleNumber % 2 != 0)
                insertAfter = shuffleNumber * 2;

            if (insertAfter > this.map.size)
                insertAfter = this.map.size;

            if (insertAfter === shuffleNumber) return;

            const removeNode = this.map.get(shuffleNumber);

            if (removeNode === this.head) {
                this.head = this.head.next;
                this.head.prev = null;
                removeNode.next = null;
                removeNode.prev = null;
            } else if (removeNode === this.tail) {
                this.tail = this.tail.prev;
                this.tail.next = null;
                removeNode.next = null;
                removeNode.prev = null;
            } else {
                removeNode.prev.next = removeNode.next;
                removeNode.next.prev = removeNode.prev;
                removeNode.next = null;
                removeNode.prev = null;
            }

            const insertNode = this.map.get(insertAfter);

            if (insertNode === this.head) {
                removeNode.next = this.head.next;
                removeNode.prev = this.head;
                this.head.next.prev = removeNode;
                this.head.next = removeNode;
            } else if (insertNode === this.tail) {
                removeNode.prev = this.tail;
                this.tail.next = removeNode;
                this.tail = removeNode;
            } else {
                removeNode.next = insertNode.next;
                removeNode.prev = insertNode
                insertNode.next.prev = removeNode;
                insertNode.next = removeNode;
            }
        }
    }

    const N = gets().split(' ').map(Number)
    const M = gets().split(' ').map(Number)
    const list = new DLL();

    list.createList(N[0]);

    for (let i = 0; i < N[1]; i++) {
        list.shuffle(M[i]);
    }

    print(list.toString());

} catch (error) {
    console.log(error)
}