// use std::ops::{Index, IndexMut};
// use std::cmp::{Ordering, min, max};
// use std::collections::{BinaryHeap, BTreeMap};
// use std::collections::btree_map::Entry::{Occupied, Vacant};
// use std::clone::Clone;

fn getline() -> String{
    let mut res = String::new();
    std::io::stdin().read_line(&mut res).ok();
    res
}

macro_rules! readl {
    ($t: ty) => {
        {
            let s = getline();
            s.trim().parse::<$t>().unwrap()
        }
    };
    ($( $t: ty),+ ) => {
        {
            let s = getline();
            let mut iter = s.trim().split(' ');
            ($(iter.next().unwrap().parse::<$t>().unwrap(),)*) 
        }
    };
}

macro_rules! readlvec {
    ($t: ty) => {
        {
            let s = getline();
            let iter = s.trim().split(' ');
            iter.map(|x| x.parse().unwrap()).collect::<Vec<$t>>()
        }
    }
}

macro_rules! mvec {
    ($v: expr, $s: expr) => {
        vec![$v; $s]
    };
    ($v: expr, $s: expr, $($t: expr),*) => {
        vec![mvec!($v, $($t),*); $s]
    };
}

macro_rules! debug {
    ($x: expr) => {
        println!("{}: {:?}", stringify!($x), $x)
    }
}

fn printiter<'a, T>(v: &'a T)
where
    &'a T: std::iter::IntoIterator, 
    <&'a T as std::iter::IntoIterator>::Item: std::fmt::Display {
    for (i,e) in v.into_iter().enumerate() {
        if i != 0 {
            print!(" ");
        }
        print!("{}", e);
    }
    println!("");
}

fn solve(n: usize, m: usize, a: Vec<usize>) -> Option<(Vec<usize>, Vec<usize>)> {
    let mut ans0 = {
        let mut v1: Vec<_> = a.iter().filter(|&x| x%2 == 1).map(|x| *x).collect();
        if v1.len() > 2 {
            return None;
        }
        let mut res = Vec::new();
        if let Some(&x) = v1.last() {
            res.push(x);
            v1.pop();
        }
        res.extend(a.iter().filter(|&x| x%2 == 0).map(|x| *x));
        if let Some(&x) = v1.last() {
            res.push(x);
            v1.pop();
        }
        res
    };
    assert_eq!(ans0.len(), a.len());
    
    let ans = if ans0.len() == 1 {
        if ans0[0] == 1 {
            vec![1]
        } else {
            vec![ans0[0]-1, 1]
        }
    } else { 
        let mut ans = Vec::new();
        for (i, &e) in ans0.iter().enumerate() {
            if e%2 == 1 {
                if i == 0 {
                    if e != 1 {
                        ans.push(e-1);
                    }
                } else {
                    ans.push(e+1);
                }
            } else {
                if i == 0 {
                    ans.push(e-1);
                } else {
                    ans.push(e);
                    if i == ans0.len()-1 {
                        ans.push(1);
                    }
                }
            }
        }
        ans
    };
    Some((ans0, ans))
}

fn main() {
    let(n, m) = readl!(usize, usize);
    let a = readlvec!(usize);
    if let Some((ans0, ans1)) = solve(n, m, a) {
        printiter(&ans0);
        println!("{}", ans1.len());
        printiter(&ans1);
        assert_eq!(ans0.iter().sum::<usize>(), n);
        assert_eq!(ans1.iter().sum::<usize>(), n);
    } else {
        println!("Impossible");
    }
}



Measured memory_bytes: 4352