#include <bits/stdc++.h>
#define int long long
using namespace std;

string to_string(string s) { return s; }
template <typename T> string to_string(T v) {
  bool first = true;
  string res = "[";
  for (const auto &x : v) {
    if (!first)
      res += ", ";
    first = false;
    res += to_string(x);
  }
  res += "]";
  return res;
}

void dbg_out() { cout << endl; }
template <typename Head, typename... Tail> void dbg_out(Head H, Tail... T) {
  cout << ' ' << to_string(H);
  dbg_out(T...);
}

#ifdef DEBUG
#define dbg(...) cout << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)
#else
#define dbg(...)
#endif

const int MAXN = 7;
int alice[MAXN], bob[MAXN];
int cntL, cntR;
map<tuple<vector<int>, vector<int>, vector<int>, vector<int>, int>,
    tuple<double, double, double>>
    cache;

tuple<double, double, double> solve(vector<int> killedA, vector<int> killedB,
                                    int side, vector<int> freqA,
                                    vector<int> freqB) {
  if (cache.count({killedA, killedB, freqA, freqB, side}))
    return cache[{killedA, killedB, freqA, freqB, side}];

  int aliveA = 0, aliveB = 0;
  for (int x : killedA)
    if (x == -1)
      aliveA++;
  for (int x : killedB)
    if (x == -1)
      aliveB++;

  double probA = 0, probDraw = 0, probB = 0;

  if (aliveA == 0 and aliveB == 0) {
    probDraw = 1;
    return cache[{killedA, killedB, freqA, freqB, side}] =
               tuple(probA, probDraw, probB);
  } else if (aliveA == 0) {
    probB = 1;
    return cache[{killedA, killedB, freqA, freqB, side}] =
               tuple(probA, probDraw, probB);
  } else if (aliveB == 0) {
    probA = 1;
    return cache[{killedA, killedB, freqA, freqB, side}] =
               tuple(probA, probDraw, probB);
  }
  vector<int> hpAlice(cntL), hpBob(cntR);
  for (int i = 0; i < cntL; ++i)
    hpAlice[i] = alice[i];
  for (int i = 0; i < cntR; ++i)
    hpBob[i] = bob[i];
  for (int i = 0; i < cntL; ++i)
    if (killedA[i] >= 0)
      hpBob[killedA[i]] -= alice[i];
  for (int i = 0; i < cntR; ++i)
    if (killedB[i] >= 0)
      hpAlice[killedB[i]] -= bob[i];

  auto playAlice = [&]() {
    int pos = 0;
    while (killedA[pos] != -1)
      ++pos;
    for (int i = pos + 1; i < cntL; ++i)
      if (killedA[i] == -1 and freqA[i] < freqA[pos])
        pos = i;
    double a = 0, d = 0, b = 0;
    for (int i = 0; i < cntR; ++i)
      if (killedB[i] == -1) {
        if (alice[pos] >= hpBob[i])
          killedB[i] = pos;
        if (bob[i] >= hpAlice[pos])
          killedA[pos] = i;
        freqA[pos]++;
        auto [aa, dd, bb] = solve(killedA, killedB, 1, freqA, freqB);
        freqA[pos]--;
        killedA[pos] = -1;
        killedB[i] = -1;
        a += aa / aliveB, d += dd / aliveB, b += bb / aliveB;
      }
    return tuple(a, d, b);
  };
  auto playBob = [&]() {
    int pos = 0;
    while (killedB[pos] != -1)
      ++pos;
    for (int i = pos + 1; i < cntR; ++i)
      if (killedB[i] == -1 and freqB[i] < freqB[pos])
        pos = i;
    double a = 0, d = 0, b = 0;
    for (int i = 0; i < cntL; ++i)
      if (killedA[i] == -1) {
        if (alice[i] >= hpBob[pos])
          killedB[pos] = i;
        if (bob[pos] >= hpAlice[i])
          killedA[i] = pos;
        freqB[pos]++;
        auto [aa, dd, bb] = solve(killedA, killedB, -1, freqA, freqB);
        freqB[pos]--;
        killedA[i] = -1;
        killedB[pos] = -1;
        a += aa / aliveA, d += dd / aliveA, b += bb / aliveA;
      }
    return tuple(a, d, b);
  };

  if (side == 0) {
    if (aliveA > aliveB) {
      auto [a, d, b] = playAlice();
      probA = a, probDraw = d, probB = b;
    } else if (aliveA < aliveB) {
      auto [a, d, b] = playBob();
      probA = a, probDraw = d, probB = b;
    } else {
      auto [a, d, b] = playAlice();
      probA = a, probDraw = d, probB = b;
      tie(a, d, b) = playBob();
      probA += a, probDraw += d, probB += b;
      probA /= 2, probDraw /= 2, probB /= 2;
    }
  } else if (side == -1) {
    auto [a, d, b] = playAlice();
    probA = a, probDraw = d, probB = b;
  } else if (side == 1) {
    auto [a, d, b] = playBob();
    probA = a, probDraw = d, probB = b;
  }
  dbg(aliveA, aliveB, side);
  dbg(killedA, killedB, probA, probDraw, probB);
  return cache[{killedA, killedB, freqA, freqB, side}] =
             tuple(probA, probDraw, probB);
}

signed main(void) {
  ios_base::sync_with_stdio(false);
  cin.tie(0);

  cin >> cntL >> cntR;

  for (int i = 0; i < cntL; ++i)
    cin >> alice[i];
  for (int i = 0; i < cntR; ++i)
    cin >> bob[i];

  vector<int> killedA(cntL, -1), killedB(cntR, -1);
  vector<int> freqA(cntL, 0), freqB(cntR, 0);
  auto [a, d, b] = solve(killedA, killedB, 0, freqA, freqB);

  cout << setprecision(15) << fixed << a << ' ' << b << ' ' << d << endl;
}