~E

use std::collections::VecDeque;
use std::io;

fn input() -> u32 {
    let mut input: String = String::new();
    io::stdin().read_line(&mut input).unwrap();
    input.trim().parse().unwrap()
}

fn find(pn: &Vec<u32>, value: u32) -> Option<usize> {
    for i in 0..pn.len() {
        unsafe {
            if value == *pn.get_unchecked(i) {
                return Some(i);
            }
        }
    }
    return None;
}

fn find_deque(pn: &VecDeque<u32>, value: u32) -> Option<usize> {
    for i in 0..pn.len() {
        if value == pn[i] {
            return Some(i);
        }
    }
    return None;
}

fn binary_add(x: &mut VecDeque<u32>) {
    let mut size: usize = 0;
    {
        size = x.len()
    }
    if *x.back().unwrap() == 0 {
        x[size - 1] = 1;
    } else {
        let mut end_ptr: usize = 1;
        while x[size - end_ptr] == 1 {
            x[size - end_ptr] = 0;
            end_ptr += 1;
        }
        x[size - end_ptr] = 1;
    }
}

fn remove_all_sums(ans: &Vec<u32>, list: &mut Vec<u32>, mut permute: &mut VecDeque<u32>) {
    while find_deque(&permute, 0) != None {
        binary_add(&mut permute);

        let mut sum: u32 = 0;

        for i in 0..ans.len() {
            unsafe {
                if permute[i] == 1 {
                    sum += *ans.get_unchecked(ans.len() - 1 - i) as u32;
                }
            }
        }
        let x: usize;
        {
            x = find(&list, sum).unwrap();
        }
        list.remove(x);
    }
}

fn main() {
    let n: u32 = input();
    let mut list: Vec<u32> = Vec::with_capacity(2_usize.pow(n));

    for _i in 0..2_usize.pow(n) {
        let x: u32 = input();
        list.push(x);
    }
    list.sort();

    let mut ans: Vec<u32> = Vec::with_capacity(n as usize);

    let mut correct: bool = true;

    for i in 0..list.len() / 2 {
        unsafe {
            if *list.get_unchecked(i)
                != list.last().unwrap() - *list.get_unchecked(list.len() - 1 - i)
            {
                correct = false;
                break;
            }
        }
    }

    if !correct {
        print!("impossible");
    } else {
        list.remove(0); // убрали 0
        ans.push(*list.first().unwrap());
        list.remove(0); // убрали 1 элемент
        if !list.is_empty() {
            ans.push(*list.first().unwrap());
            list.remove(0);
        }

        let mut permute: VecDeque<u32> = VecDeque::with_capacity(n as usize);
        permute.push_back(1);
        permute.push_back(1);
        if !list.is_empty() {
            unsafe {
                let z: usize;
                {
                    z = find(&list, ans.get_unchecked(0) + ans.get_unchecked(1)).unwrap();
                }
                list.remove(z);
            }
        }

        while ans.len() < n as usize - 1 {
            ans.push(*list.first().unwrap());
            permute.push_front(0);
            remove_all_sums(&ans, &mut list, &mut permute);
        }
        if n > 2 {
            ans.push(*list.first().unwrap());
        }

        for i in ans {
            println!("{}", i);
        }
    }
}