// implement 35min
// debug 30min
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <set>
#include <numeric>

using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);

#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))

const int n = 12;
int seq[20];
int card[3][2];

int UseActionCard(int rest, int player, const vector<int> &cs, int i) {
  int skip = 0;
  int pos = 0;
  if (i == 0 || i == 1) {
    if (!((cs[player] >> i) & 1)) { return -1; }
    skip = card[player][i];
  }
  while (skip >= 0 && pos < n) {
    if (skip == 0 && ((rest >> pos) & 1)) { break; }
    else if ((rest >> pos) & 1) { skip--; }
    pos++;
  }
  assert(pos <= n);
  assert(skip >= 0);
  if (pos >= n) { return -1; }
  return pos;
}

vector<int> CalcNcs(int player, const vector<int> &cs, int i) {
  vector<int> ncs = cs;
  if (i == 0 || i == 1) {
    ncs[player] ^= 1 << i;
  }
  return ncs;
}

vector<int> memo[1 << n][4][4][4][2];
vector<int> Calc(int rest, int player, const vector<int> &cs, int routine) {
  if (rest == 0) { return vector<int>(3, 0); }
  vector<int> &ret = memo[rest][cs[0]][cs[1]][cs[2]][routine];
  if (ret[0] != -1) { return ret; }
  int nplayer = (player + 1) % 3;
  int best = -1000000;
  if (player == 1 && routine == 1) { best = 1000000; }
  int bestIndex = -2;
  FOR(i, -1, 2) {
    int pos = UseActionCard(rest, player, cs, i);
    if (pos == -1) { continue; }
    int nrest = rest ^ (1 << pos);
    vector<int> ncs = CalcNcs(player, cs, i);
    vector<int> points = Calc(nrest, nplayer, ncs, (routine == 1 && player == 1) ? 1 : 0);
    points[player] += seq[pos];
    if (player == 1 && routine == 1) {
      if (points[0] < best) {
        best = points[0];
        bestIndex = i;
      }
    } else {
      if (points[player] > best) {
        best = points[player];
        bestIndex = i;
      }
    }
  }
  int pos = UseActionCard(rest, player, cs, bestIndex);
  int nrest = rest ^ (1 << pos);
  assert(__builtin_popcount(nrest) + 1 == __builtin_popcount(rest));
  vector<int> ncs = CalcNcs(player, cs, bestIndex);
  ret = Calc(nrest, nplayer, ncs, routine);
  ret[player] += seq[pos];
  return ret;
}

int main() {
  while (true) {
    REP(i, 1 << n) REP(j, 4) REP(k, 4) REP(l, 4) REP(m, 2) { memo[i][j][k][l][m] = vector<int>(3, -1); }
    REP(i, n) {
      int v = scanf("%d", &seq[i]);
      if (v != 1) { return 0; }
    }
    reverse(seq, seq + n);
    REP(i, 3) {
      REP(j, 2) {
        int v = scanf("%d", &card[i][j]);
        card[i][j]--;
        assert(v == 1);
      }
      if (card[i][0] > card[i][1]) { swap(card[i][0], card[i][1]); }
    }
    vector<int> ans = Calc((1 << n) - 1, 0, vector<int>(3, 3), 1);
    printf("%d %d %d\n", ans[0], ans[1], ans[2]);
    assert(accumulate(ans.begin(), ans.end(), 0) == accumulate(seq, seq + n, 0));
  }
}