Problem: Snuke got a present from his mother on his birthday. The present was a pair of two sequences a and b, consisting of positive integers. They satisfied all of the following properties:

* The sum of all elements of a is N.
* The sum of all elements of b is N.
* Any string of length N that satisfies the following two conditions (1) and (2) will also satisfy the condition (3).
* (1) Any of the following forms a palindrome: the first a_1 letters, the following a_2 letters, the following a_3 letters and so on.
* (2) Any of the following forms a palindrome: the first b_1 letters, the following b_2 letters, the following b_3 letters and so on.
* (3) All N letters are the same.



He was happy, until one day he lost both of the sequences. Now, he only remembers that the sequence a was a permutation of another sequence A of length M.

To bring him happiness again, his mother has decided to give him another pair of sequences a and b that satisfies his favorite properties and is consistent with his memory.

Constraints

* 1≦N≦10^5
* 1≦M≦100
* 1≦A_i≦10^5
* The sum of all A_i equals N.

Input

The input is given from Standard Input in the following format:


N M
A_1 A_2 ... A_M


Output

If there exists a pair of sequences a and b that satisfies the properties and is consistent with Snuke's memory, print three lines. The first line must contain the sequence a, the second line must contain the length of the sequence b, and the third line must contain the sequence b.

If such a pair does not exist (because Snuke's memory is wrong or some other reason), print a single line containing the word `Impossible` (case-sensitive).

Examples

Input

3 2
2 1


Output

1 2
1
3


Input

6 1
6


Output

6
3
1 2 3


Input

55 10
1 2 3 4 5 6 7 8 9 10


Output

Impossible

Solution (in JAVA):

Solution:
// package atcoder.agc.agc001;

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.List;

/**
 * Created by hama_du on 2016/07/16.
 */
public class Main {
    public static void main(String[] args) {
        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int n = in.nextInt();
        int m = in.nextInt();

        int[] a = new int[m];
        for (int i = 0; i < m ; i++) {
            a[i] = in.nextInt();
        }
        int odd = 0;
        for (int i = 0; i < m ; i++) {
            odd += a[i] % 2;
        }
        if (odd >= 3) {
            out.println("Impossible");
            out.flush();
            return;
        }

        List<Integer> od = new ArrayList<>();
        List<Integer> ev = new ArrayList<>();
        for (int i = 0; i < m ; i++) {
            if (a[i] % 2 == 1) {
                od.add(a[i]);
            } else {
                ev.add(a[i]);
            }
        }

        List<Integer> desireOrder = new ArrayList<>();
        if (od.size() >= 1) {
            desireOrder.add(od.get(0));
        }
        desireOrder.addAll(ev);
        if (od.size() == 2) {
            desireOrder.add(od.get(1));
        }

        if (desireOrder.size() == 1) {
            if (n == 1) {
                out.println(1);
                out.println(1);
                out.println(1);
                out.flush();
                return;
            } else {
                out.println(n);
                out.println(2);
                out.println(1 + " " + (n-1));
                out.flush();
                return;
            }
        }

        List<Integer> b = new ArrayList<>();
        int sum = 0;
        for (int i = 0 ; i < m ; i++) {
            if (sum == n) {
                break;
            }
            if (i == 0) {
                b.add(desireOrder.get(0)+1);
            } else if (i+1 < m) {
                b.add(desireOrder.get(i));
            } else {
                b.add(desireOrder.get(m-1)-1);
            }
            sum += b.get(b.size()-1);
        }

        out.println(buildLine(desireOrder));
        out.println(b.size());
        out.println(buildLine(b));
        out.flush();
    }

    private static String buildLine(List<Integer> o) {
        StringBuilder line = new StringBuilder();
        for (int i : o) {
            line.append(' ').append(i);
        }
        return line.substring(1);
    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        private int next() {
            if (numChars == -1)
                throw new InputMismatchException();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public char nextChar() {
            int c = next();
            while (isSpaceChar(c))
                c = next();
            if ('a' <= c && c <= 'z') {
                return (char) c;
            }
            if ('A' <= c && c <= 'Z') {
                return (char) c;
            }
            throw new InputMismatchException();
        }

        public String nextToken() {
            int c = next();
            while (isSpaceChar(c))
                c = next();
            StringBuilder res = new StringBuilder();
            do {
                res.append((char) c);
                c = next();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public int nextInt() {
            int c = next();
            while (isSpaceChar(c))
                c = next();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = next();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c-'0';
                c = next();
            } while (!isSpaceChar(c));
            return res*sgn;
        }

        public long nextLong() {
            int c = next();
            while (isSpaceChar(c))
                c = next();
            long sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = next();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c-'0';
                c = next();
            } while (!isSpaceChar(c));
            return res*sgn;
        }

        public boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }

    static void debug(Object... o) {
        System.err.println(Arrays.deepToString(o));
    }
}