using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

namespace Swappings
{
    class Program
    {
        static void Main()
        {
            int endNumber = int.Parse(Console.ReadLine());

            List<int> numbers = Console.ReadLine().Split(' ').Select(int.Parse).ToList();

            MyLinkedList<int> collectionOfNumbers = new MyLinkedList<int>();

            for (int i = endNumber; i >= 1; i--)
            {
                collectionOfNumbers.AddHead(i);
            }

            foreach (int number in numbers)
            {
                var currentElement = collectionOfNumbers.Find(number);

                if (currentElement.Next != null && currentElement.Previous!=null)
                {
                    var toBeTheHead = currentElement.Next;
                    var toBeTheNext = collectionOfNumbers.Head;
                    var toBeBeforeCurrent = collectionOfNumbers.Tail;
                    var toBeTail = currentElement.Previous;

                    toBeTheHead.Previous = null;
                    toBeTheNext.Previous = currentElement;
                    currentElement.Next = toBeTheNext;
                    currentElement.Previous = toBeBeforeCurrent;
                    toBeBeforeCurrent.Next = currentElement;


                    collectionOfNumbers.Head = toBeTheHead;
                    collectionOfNumbers.Tail = toBeTail;
                    toBeTail.Next = null;
                }

                else if (currentElement.Next==null)
                {
                    var toBeTheHead = currentElement;
                    var toBeTheNext = collectionOfNumbers.Head;
                    var toBeTail = currentElement.Previous;

                    toBeTheHead.Previous = null;
                    toBeTheHead.Next = toBeTheNext;
                    toBeTheNext.Previous = toBeTheHead;
                    currentElement.Next = toBeTheNext;
                    toBeTheNext.Previous = currentElement;

                    collectionOfNumbers.Head = toBeTheHead;
                    collectionOfNumbers.Tail = toBeTail;
                    toBeTail.Next = null;
                }

                else if (currentElement.Previous==null)
                {
                    var toBeTheHead = currentElement.Next;
                    var toBeBeforeTheCurrent = collectionOfNumbers.Tail;
                    var toBeTheTail = currentElement;

                    toBeTheHead.Previous = null;
                    toBeBeforeTheCurrent.Next = currentElement;
                    currentElement.Previous = toBeBeforeTheCurrent;
                    currentElement.Next = null;

                    collectionOfNumbers.Head = toBeTheHead;
                    collectionOfNumbers.Tail = toBeTheTail;
                    toBeTheTail.Next = null;

                }

            }

            Console.WriteLine(string.Join(" ", collectionOfNumbers));
        }
    }

    //[DebuggerDisplay("{string.Join(\" \", this)}")]
    public class MyLinkedList<T> : IEnumerable<T> where T : struct
    {
        public void AddHead(T value)
        {
            MyNode<T> newHead = new MyNode<T>(value);

            if (this.Head != null)
            {
                this.Head.Previous = newHead;
            }

            newHead.Next = this.Head;
            this.Head = newHead;

            if (this.Head.Next == null)
            {
                this.Tail = this.Head;
            }
        }

        public void AddTail(T value)
        {
            MyNode<T> newTail = new MyNode<T>(value);

            if (this.Tail != null)
            {
                this.Tail.Next = newTail;
            }

            newTail.Previous = this.Tail;
            this.Tail = newTail;
        }

        public MyNode<T> Find(T value)
        {
            MyNode<T> currentNode = this.Head;

            while (!currentNode.Value.Equals(value) && currentNode.Next != null)
            {
                currentNode = currentNode.Next;
            }

            if (!currentNode.Value.Equals(value))
            {
                throw new ArgumentOutOfRangeException("No Such Node!");
            }

            return currentNode;

        }

        public void RemoveHead()
        {
            if (this.Head?.Next == null)
            {
                this.Head = null;
                this.Tail = null;
            }

            else
            {
                this.Head = this.Head.Next;
            }
        }

        public void RemoveTail()
        {
            if (this.Tail?.Previous == null)
            {
                this.Tail = null;
                this.Head = null;
            }

            else
            {
                this.Tail = this.Tail.Previous;
            }
        }

        public void RemoveNode(MyNode<T> node)
        {
            if (node.Next == null)
            {
                RemoveTail();
            }

            else if (node.Previous == null)
            {
                RemoveHead();
            }

            else
            {
                MyNode<T> previousNode = node.Previous;
                MyNode<T> nextNode = node.Next;
                previousNode.Next = nextNode;
                nextNode.Previous = previousNode;
            }
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }

        public IEnumerator<T> GetEnumerator()
        {
            var currentElement = this.Head;

            if (this.Head != this.Tail)
            {
                while (currentElement != null)
                {
                    yield return currentElement.Value;
                    currentElement = currentElement.Next;
                }
            }

            else
            {
                yield return currentElement.Value;
            }
        }



        public MyNode<T> Head { get; set; }

        public MyNode<T> Tail { get; set; }
    }

    //[DebuggerDisplay("value = {Value}, next = {Next.Value}, previous = {Previous.Value}")]
    public class MyNode<T>
    {

        public MyNode(T value)
        {
            this.Value = value;
        }

        public MyNode<T> Next { get; set; }
        public MyNode<T> Previous { get; set; }
        public T Value { get; set; }
    }
}