use std::collections::BTreeMap;
use std::fmt::Display;
use std::ops::Neg;
use std::ops::Div;
use std::ops::Mul;
use std::ops::Add;
use std::ops::Sub;
use std::cmp::max;
use std::collections::VecDeque;
use std::cmp::min;
use std::collections::BTreeSet;
use std::cmp::Ordering;
use std::fmt::Debug;

fn read_line() -> String {
    let mut buffer = String::new();
    std::io::stdin().read_line(&mut buffer).expect("No Line");
    buffer
}
fn read_lines<T: std::str::FromStr>(count: usize) -> Vec<T> {
    let mut buffer = String::new();
    let mut vec = Vec::with_capacity(count);
    for _ in 0 .. count {
        std::io::stdin().read_line(&mut buffer).expect("No Line");
        vec.push(buffer.trim().parse().ok().expect("Can't Parse"));
        buffer.clear();
    }
    vec
}
fn read_tabulate<R, T: Fn(&str)->R> (count: usize, transformer: T) -> Vec<R> {
    let mut buffer = String::new();
    let mut vec = Vec::with_capacity(count);
    for _ in 0 .. count {
        std::io::stdin().read_line(&mut buffer).expect("No Line");
        vec.push(transformer(buffer.trim()));
        buffer.clear();
    }
    vec
}
fn read_value<T: std::str::FromStr>() -> T {
    read_line().trim().parse().ok().unwrap()
}
fn read_values<T: std::str::FromStr>() -> Vec<T> {
    read_line().trim().split(' ').map(|x| x.parse().ok().expect("Can't Parse")).collect::<Vec<T>>()
}
macro_rules! freeze {
    ($($id:ident), *) => {
        $(let $id = $id;)*
    };
}
macro_rules! read {
    (mut $ident: ident: [$ty:ty]) => {
        let mut $ident = read_values::<$ty>();
    };
    ($ident: ident: [$ty:ty]) => {
        let $ident = read_values::<$ty>();
    };
    (mut $ident: ident: [[$ty:ty]; $size: expr]) => {
        let mut $ident = (0 .. $size).into_iter().map(|_| read_values::<$ty>()).collect::<Vec<_>>();
    };
    ($ident: ident: [[$ty:ty]; $size: expr]) => {
        let $ident = (0 .. $size).into_iter().map(|_| read_values::<$ty>()).collect::<Vec<_>>();
    };
    (mut $ident: ident: [$ty:ty; $size:expr]) => {
        let mut $ident = read_lines::<$ty>($size);
    };
    ($ident: ident: [$ty:ty; $size:expr]) => {
        let $ident = read_lines::<$ty>($size);
    };
    ($($token: tt)*) => {
        let mut iter = read_values::<String>().into_iter();
        read_from_iter!(iter; $($token)*);
    };
}
macro_rules! read_from_iter {
    ($iter:expr; mut $ident:ident:$ty:ty, $($rest:tt)*) => {
        let mut $ident = $iter.next().unwrap().parse::<$ty>().expect("Can't Parse");
        read_from_iter!($iter; $($rest)*);
    };
    ($iter:expr; $ident:ident:$ty:ty, $($rest:tt)*) => {
        let $ident = $iter.next().unwrap().parse::<$ty>().expect("Can't Parse");
        read_from_iter!($iter; $($rest)*);
    };
    ($iter:expr; mut $ident:ident:$ty:ty) => {
        let mut $ident = $iter.next().unwrap().parse::<$ty>().expect("Can't Parse");
    };
    ($iter:expr; $ident:ident:$ty:ty) => {
        let $ident = $iter.next().unwrap().parse::<$ty>().expect("Can't Parse");
    };
    ($iter: expr; ) => {};
}
struct KeyValue<K, V> {
    key: K,
    value: V
}
impl <K: PartialOrd, V> PartialEq for KeyValue<K, V> {
    fn eq(&self, other: &Self) -> bool {
        self.key.eq(&other.key)
    }
}
impl <K: PartialOrd, V> Eq for KeyValue<K, V> {}
impl <K: PartialOrd, V> PartialOrd for KeyValue<K, V> {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        self.key.partial_cmp(&other.key)
    }
}
impl <K: PartialOrd, V> Ord for KeyValue<K, V> {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.key.partial_cmp(&other.key).ok_or("Can't Compare").unwrap()
    }
}
fn show_vec(vec: &Vec<i32>) {
    let mut vec = vec.clone();
    vec.sort();
    for i in 1 .. vec.len() {
        if i != 1 {
            print!(" ");
        }
        print!("{}", vec[i] - vec[i - 1]);
    }
    print!("\n");
}
fn show(vec: &mut Vec<i32>, set: &mut Vec<usize>, max: i32, rest_count: usize) {
    if rest_count == 0 {
        show_vec(vec);
        return ;
    }
    let max_len = (set.len() - 1) as i32;
    let max_diff = (1usize .. (max + 1) as usize).rev().find(|&v| set[v] > 0).unwrap() as i32;
    if max_diff + vec.last().unwrap() == max_len {
        return ;
    }
    let next = max_len - max_diff;
    let mut stop = vec.len();
    for i in 0 .. vec.len() {
        if set[(vec[i] - next).abs() as usize] == 0 {
            stop = i;
            break;
        }
        set[(vec[i] - next).abs() as usize] -= 1;
    }
    if stop == vec.len() {
        vec.push(next);
        show(vec, set, max_diff, rest_count - 1);
        vec.pop();
    }
    for i in 0 .. stop {
        set[(vec[i] - next).abs() as usize] += 1;
    }
    if max_len - next == next {return ;}
    let next = max_len - next;
    stop = vec.len();
    for i in 0 .. vec.len() {
        if set[(vec[i] - next).abs() as usize] == 0 {
            stop = i;
            break;
        }
        set[(vec[i] - next as i32).abs() as usize] -= 1;
    }
    if stop == vec.len() {
        vec.push(next as i32);
        show(vec, set, max_diff, rest_count - 1);
        vec.pop();
    }
    for i in 0 .. stop {
        set[(vec[i] - next as i32).abs() as usize] += 1;
    }
}
fn main() {
    loop {
        read!{n: usize};
        if n == 0 {break;}
        let mut dist = Vec::with_capacity(n * (n - 1) >> 1);
        loop {
            read!{line: [i32]};
            for l in line {
                dist.push(l);
            }
            if dist.len() == n * (n - 1) >> 1 {
                break;
            }
        }
        let max_len = dist.first().unwrap();
        let mut set = vec![0usize; *max_len as usize + 1usize];
        for i in 1 .. dist.len() {
            set[dist[i] as usize] += 1;
        }
        let mut vec = Vec::with_capacity(n + 1);
        vec.push(0); vec.push(*max_len);
        show(&mut vec, &mut set, *max_len, n - 2);
        println!("-----");
    }
}



Measured memory_bytes: 5040