/*
AM 02:54 -> AM 06:45
 */
#include<iostream>
#include<map>
#include<set>
#include<vector>
#include<algorithm>
#include<sstream>
#include<iomanip>
#include<cassert>
#include<bitset>
#include<cmath>
#include<climits>
#include<unordered_map>
#include<unordered_set>

#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define IINF (INT_MAX)
#define MAX 200
#define all(a) (a).begin(),(a).end()

using namespace std;

int N,limit,tail;
int d[MAX];
int remain[10000];
int town[30];

set<vector<int>> result;

pair<vector<int>,bool> check(int state,int pos,int value){

  if((state>>pos) & 1)return pair<vector<int>,bool>(vector<int>(),false);
  assert(value >= 0);
  int pstate = state;
  vector<int> add;
  pstate = pstate & ((1<<N)-2);
  while(pstate){
    int use = log2(pstate & -pstate);

    int diff1 = abs(town[use]-value);

    if(remain[diff1] == 0){
      break;
    }
    pstate -= (pstate & -pstate);
    add.push_back(diff1);
    remain[diff1]--;
  }

  return pair<vector<int>,bool>(add,(pstate == 0));

}

void dfs(int state,int last){
  if(state == (1<<N)-1){
    vector<int> vec;
    REP(i,1,N){
      vec.push_back(town[i]-town[i-1]);
    }
    result.insert(vec);
    return;
  }

  while(last >= 0 && remain[d[last]] == 0)last--;
  if(last < 0 || ( last >= 0 && remain[d[last]] == 0))return;

  int value = d[last];
  int rstate = ~state & ((1<<N)-1);
  int use = log2(~state & ((1<<N)-1));
  vector<int> add;
  remain[value]--;
  pair<vector<int>,bool> F = check(state,use,value);
  add = F.first;
  if(F.second){//Nテッツセツ?ッツセツ?ッツスツカテッツスツイテッツセツ偲ッツスツウ
    town[use] = value;
    dfs(state|(1<<use),last);
    town[use] = -1;
  }

  remain[value]++;

  for(int i : add){
    remain[i]++;
  }

  if(remain[tail-value] == 0)return;
  use = log2(rstate & -rstate);

  remain[tail-value]--;
  F = check(state,use,tail-value);

  add = F.first;
  if(F.second){// 0テッツセツ?ッツセツ?ッツスツカテッツスツイテッツセツ偲ッツスツウ
    town[use] = tail - value;
    dfs(state|(1<<use),last);
    town[use] = -1; 
  }

  remain[tail-value]++;

  for(int i : add){
    remain[i]++;
  }
}

void compute(){
  town[0] = 0;
  town[N-1] = d[limit-1];
  remain[d[limit-1]]--;
  tail = d[limit-1];

  dfs(1|(1<<(N-1)),limit-1);

  for(vector<int> i : result){
    rep(j,i.size()){
      if(j)cout << ' ';
      cout << i[j];
    }
    cout << endl;
  }

}

int main()
{
  while(cin >> N,N){
    result.clear();
    
    limit = (int)(N*(N-1)*0.5);
    for(int& i : remain){
      i = 0;
    }

    vector<int> input;
    rep(i,N)town[i] = -1;
    rep(i,limit){
      cin >> d[i];
      assert(d[i]);
      input.push_back(d[i]);
      remain[d[i]]++;
    }

    sort(all(input));
    input.erase(unique(all(input)),input.end());
    limit = input.size();
    rep(i,limit)d[i] = input[i];

    compute();
    puts("-----");
  }

  return 0;
}


/*
void dfs(int x,int cur){

  cout << "(" << x << "," << 0 << ")" << endl;

  cout << "...." << endl;
  rep(i,N-1){
    cout << string(3*i,' ');
    rep(j,N-1-i){
      cout << setw(3) << mat[i][i+j];
    }
    cout << endl;
  }
  cout << endl;


  if( x >= N - 2 ){
    vector<int> vec;
    vec.push_back(mat[0][0]);
    REP(i,1,N-1){
      vec.push_back(mat[0][i]-mat[0][i-1]);
    }
    result.insert(vec);
    return;
  }

  REP(next,cur,limit){

    if(remain[ d[next] ] == 0)continue;
    //cout << "x = " << x << " d[" << next << "] = " << d[next] << endl;
    mat[0][x] = d[next];
    remain[d[next]]--;

    if(remain[ mat[0][N-2] - d[next] ] == 0){
      remain[d[next]]++;
      continue;
    }
    int value = mat[0][N-2] - mat[0][x];
    mat[x+1][N-2] = value;
    remain[value]--;

    int cnt = 0;
    bool ok = true;
    if( x != 0 ){

      for(int y=0;y<=x-1;y++){
	int diff = mat[y][x] - mat[y][y];
	if( remain[diff] == 0 ){
	  ok = false;
	  break;
	}
	mat[y+1][x] = diff;
	remain[diff]--;
	cnt++;
      }

    }

    if(ok){
      //cout << x << " go to next, the value is " << d[next] << endl;
      dfs(x+1,next+1);
    }

    rep(i,cnt){
      remain[mat[i+1][x]]++;
      mat[i+1][x] = -1;
    }
    remain[d[next]]++;
    mat[0][x] = -1;
    remain[value]++;
    mat[x+1][N-2] = -1;
  }

}
*/

Measured memory_bytes: 1292