#include <bits/stdc++.h>
using namespace std;
// #define int long long
// #define double long double
#define rep(i,n) for (int i=0; i<(int)(n); ++i)
#define rep1(i,n) for (int i=1; i<(int)(n); ++i)
#define repeq(i,n) for (int i=0; i<=(int)(n); ++i)
#define rep1eq(i,n) for (int i=1; i<=(int)(n); ++i)
#define rrep(i,n) for (int i=(int)(n)-1; i>=0; --i)
#define rrep1(i,n) for (int i=(int)(n)-1; i>0; --i)
#define rrepeq(i,n) for (int i=(int)(n); i>=0; --i)
#define rrep1eq(i,n) for (int i=(int)(n); i>0; --i)
#define REP(i,a,b) for (int i=(int)(a); i<=(int)(b); ++i)
#define RREP(i,a,b) for (int i=(int)(a); i>=(int)(b); --i)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
using vb = vector<bool>;
template<typename T> using Graph = vector<vector<T>>;
template<typename T> using Spacial = vector<vector<vector<T>>>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template<typename T> using greater_priority_queue = priority_queue<T, vector<T>, greater<T>>;
const int MOD = 1e9+7;
const int MOD2 = 998244353;
// const double EPS = 1e-9;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
string interval[2] = {" ", "\n"}; // {" ", "\n"}

template<typename T> struct is_plural : false_type{};
template<typename T1, typename T2> struct is_plural<pair<T1, T2>> : true_type{};
template<typename T> struct is_plural<vector<T>> : true_type{};
template<typename T> struct is_plural<complex<T>> : true_type{};
 
template<typename T1, typename T2> istream &operator>>(istream &is, pair<T1, T2> &p) { return is >> p.first >> p.second; }
template<typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &p) { return os << p.first << " " << p.second; }
template<typename T> istream &operator>>(istream &is, vector<T> &vec) { for (auto itr = vec.begin(); itr != vec.end(); ++itr) is >> *itr; return is; }
template<typename T> ostream &operator<<(ostream &os, const vector<T> &vec) { if (vec.empty()) return os; bool pl = is_plural<T>(); os << vec.front(); for (auto itr = ++vec.begin(); itr != vec.end(); ++itr) os << interval[pl] << *itr; return os; }
 
bool CoutYN(bool a, string y = "Yes", string n = "No") { cout << (a ? y : n) << "\n"; return a; }

template<typename T1, typename T2> inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
template<typename T1, typename T2> inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }

long long modpow(int a, long long n, int mod = MOD) { long long ret = 1; do { if (n & 1) ret = ret * a % mod; a = 1LL * a * a % mod; } while (n >>= 1); return ret; }

template<typename T> T GCD(T a, T b) { return b ? GCD(b, a%b) : a; }
template<typename T> T LCM(T a, T b) { return a / GCD(a, b) * b; }

template<typename T1, typename T2> bool CompareBySecond(pair<T1, T2> a, pair<T1, T2> b) { return a.second != b.second ? a.second < b.second : a.first < b.first; }
template<typename T1, typename T2> bool CompareByInverse(pair<T1, T2> a, pair<T1, T2> b) { return a.first != b.first ? a.first < b.first : a.second > b.second; }


/* -------- <templates end> -------- */


struct coin {
  int x, y, z;

  coin(int x, int y, int z) : x(x), y(y), z(z) {}

  inline int yx() { return y - x; }
  inline int zx() { return z - x; }
  inline int zy() { return z - y; }
};

struct compAg {
  bool operator()(const coin &a, const coin &b) const {
    if (a.y - a.x != b.y - b.x) return a.y - a.x < b.y - b.x;
    return a.x != b.x ? a.x < b.x : a.z < b.z;
  }
};

struct compCu {
  bool operator()(const coin &a, const coin &b) const {
    if (a.z - a.x != b.z - b.x) return a.z - a.x < b.z - b.x;
    return a.x != b.x ? a.x < b.x : a.y < b.y;
  }
};

struct compAgCu {
  bool operator()(const coin &a, const coin &b) const {
    if (a.z - a.y != b.z - b.y) return a.z - a.y < b.z - b.y;
    return a.y != b.y ? a.y < b.y : a.x < b.x;
  }
};

void solve() {
  int x, y, z; cin >> x >> y >> z;
  int n = x + y + z;
  vector<coin> Au, Ag, Cu;
  rep(_,n) {
    int a, b, c; cin >> a >> b >> c;
    int MAX = max({a, b, c});
    if (a == MAX) Au.emplace_back(a, b, c);
    else if (b == MAX) Ag.emplace_back(a, b, c);
    else Cu.emplace_back(a, b, c);
  }

  auto AuAg = [&]() {
    swap(x, y);
    swap(Au, Ag);
    for (auto &c : Au) swap(c.x, c.y);
    for (auto &c : Ag) swap(c.x, c.y);
    for (auto &c : Cu) swap(c.x, c.y);
  };

  auto AuCu = [&]() {
    swap(x, z);
    swap(Au, Cu);
    for (auto &c : Au) swap(c.x, c.z);
    for (auto &c : Ag) swap(c.x, c.z);
    for (auto &c : Cu) swap(c.x, c.z);
  };

  auto AgCu = [&]() {
    swap(y, z);
    swap(Ag, Cu);
    for (auto &c : Au) swap(c.y, c.z);
    for (auto &c : Ag) swap(c.y, c.z);
    for (auto &c : Cu) swap(c.y, c.z);
  };

  if (x - (int)Au.size() < y - (int)Ag.size()) AuAg();
  if (x - (int)Au.size() < z - (int)Cu.size()) AuCu();
  if (y - (int)Ag.size() < z - (int)Cu.size()) AgCu();

  ll ans = 0;
  for (auto &c : Au) ans += c.x;
  for (auto &c : Ag) ans += c.y;
  for (auto &c : Cu) ans += c.z;

  if (x == (int)Au.size()) {
    cout << ans << endl;
    return;
  }

  if (y < (int)Ag.size()) {
    sort(RALL(Ag), [](const coin &a, const coin &b) {
      return a.y - a.x < b.y - b.x;
    });
    sort(RALL(Cu), [](const coin &a, const coin &b) {
      return a.z - a.x < b.z - b.x;
    });
    int i = Ag.size() - y;
    int j = Cu.size() - z;
    while (i && j) {
      int ag = Ag.back().yx();
      int cu = Cu.back().zx();
      if (ag < cu) {
        ans -= ag;
        --i, --x;
        Ag.pop_back();
      } else {
        ans -= cu;
        --j, --x;
        Cu.pop_back();
      }
    }
    if (j == 0) AgCu();
  } else if (y > (int)Ag.size()) {
    sort(RALL(Cu), [](const coin &a, const coin &b) {
      return a.z - max(a.x, a.y) < b.z - max(b.x, b.y);
    });
    int i = x - Au.size();
    int j = y - Ag.size();
    while (i && j) {
      if (Cu.back().x > Cu.back().y) {
        ans -= Cu.back().zx();
        --i;
        Au.emplace_back(Cu.back());
        Cu.pop_back();
      } else {
        ans -= Cu.back().zy();
        --j;
        Ag.emplace_back(Cu.back());
        Cu.pop_back();
      }
    }
    if (i == 0) AuAg();
  }

  multiset<coin, compAg> sAg;
  multiset<coin, compCu> sCu;
  multiset<coin, compAgCu> sAgCu;
  for (auto &c : Ag) sAg.emplace(c);
  for (auto &c : Cu) sCu.emplace(c), sAgCu.emplace(c);

  int cnt = x - Au.size();
  while (cnt--) {
    auto cu = *begin(sCu);
    auto ag = *begin(sAg);
    auto agcu = *begin(sAgCu);
    if (cu.zx() < agcu.zy() + ag.yx()) {
      ans -= cu.zx();
      sCu.erase(begin(sCu));
      sAgCu.erase(sAgCu.find(cu));
    } else {
      ans -= agcu.zy() + ag.yx();
      sCu.erase(sCu.find(agcu));
      sAg.erase(begin(sAg));
      sAgCu.erase(begin(sAgCu));
      sAg.emplace(agcu);
    }
  }

  cout << ans << endl;
}


/* -------- <programs end> -------- */


signed main() {
  cin.tie(nullptr);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(10);
  solve();
  return 0;
}


Measured memory_bytes: 16816