#include <bits/stdc++.h>
using namespace std;
#define faster ios_base::sync_with_stdio(false); cin.tie(NULL)
#define Bit(mask , i) ((mask >> i) & 1)
#define fi first
#define se second
#define _LOG2(nl) 31 - __builtin_clz(nl)
#define c_bit(nl) __builtin_popcount(nl)
#define ii pair<long long , int>
#define lll pair<long long , pair<long long , long long>>
#define lii pair<long long , pair<long long , int>>
#define iii pair<int , pair<int , int>>
#define iiii pair<pair<int , int> , pair<int , int>>
#define llll pair<pair<__int128 , __int128> , pair<__int128 , __int128>>
#define li pair<long long , int>
#define db long double
#define onBit(mask , i) (mask | (1 << i))
#define offBit(mask , i) (mask & (~(1 << i)))

const long long INF = 1e16;
const int N = 1e5 + 7;
int n , X , Y , Z;
long long BIT_val[N] , BIT_val_c[N] , A[N] , B[N];
int BIT_id[N] , BIT_id_c[N] , c[N];

struct gv{
    long long a , b , c , d;
};

gv a[N];

bool cmp(gv x , gv y){
    return x.d > y.d;
}

struct gv1{
    long long val;
    int id;
};

gv1 b[N];

bool cmp1(gv1 x , gv1 y){
    return x.val < y.val;
}

void update_id(int x , int val){
    while (x <= n){
        BIT_id[x] += val;
        x += x & -x;
    }
}

int get_id(int x){
    int res = 0;
    while (x > 0){
        res += BIT_id[x];
        x -= x & -x;
    }

    return res;
}

void update_val(int x , long long val){
    while (x <= n){
        BIT_val[x] += val;
        x += x & -x;
    }
}

long long get_val(int x){
    long long res = 0;
    while (x > 0){
        res += BIT_val[x];
        x -= x & -x;
    }

    return res;
}

void update_id_c(int x , int val){
    while (x > 0){
        BIT_id_c[x] += val;
        x -= x & -x;
    }
}

int get_id_c(int x){
    int res = 0;
    while (x <= n){
        res += BIT_id_c[x];
        x += x & -x;
    }

    return res;
}

void update_val_c(int x , long long val){
    while (x > 0){
        BIT_val_c[x] += val;
        x -= x & -x;
    }
}

long long get_val_c(int x){
    long long res = 0;
    while (x <= n){
        res += BIT_val_c[x];
        x += x & -x;
    }

    return res;
}

long long get_max(int k){
    if (k == 0) return 0;
    int l = 1 , r = n , mid , pos = 0;
    while (l <= r){
        mid = (l + r) >> 1;
        if (get_id_c(mid) >= k){
            pos = mid;
            l = mid + 1;
        }
        else r = mid - 1;
    }

    return get_val_c(pos);
}

long long get_min(int k){
    if (k == 0) return 0;
    int l = 1 , r = n , mid , pos = 0;
    while (l <= r){
        mid = (l + r) >> 1;
        if (get_id(mid) >= k){
            pos = mid;
            r = mid - 1;
        }
        else l = mid + 1;
    }

    return get_val(pos);
}

void ktao(){
    for (int i = 1 ; i <= n ; ++i){
        c[b[i].id] = i;
    }

    for (int i = 1 ; i <= X ; ++i){
        update_id_c(c[i] , 1);
        update_val_c(c[i] , a[i].a);
        update_id(c[i] , 1);
        update_val(c[i] , a[i].c);
    }
    A[X] = get_max(X);
    for (int i = X + 1 ; i <= n ; ++i){
        update_id_c(c[i] , 1);
        update_val_c(c[i] , a[i].a);
        update_id(c[i] , 1);
        update_val(c[i] , a[i].c);
        A[i] = get_max(X) + get_min(i - X);
    }
}

void ktao1(){
    memset(BIT_id , 0 , sizeof BIT_id);
    memset(BIT_val , 0 , sizeof BIT_val);
    memset(BIT_id_c , 0 , sizeof BIT_id_c);
    memset(BIT_val_c , 0 , sizeof BIT_val_c);
    for (int i = 1 ; i <= n ; ++i){
        c[b[i].id] = i;
    }

    for (int i = n ; i >= n - Y + 1 ; --i){
        update_id_c(c[i] , 1);
        update_val_c(c[i] , a[i].b);
        update_id(c[i] , 1);
        update_val(c[i] , a[i].c);
    }
    B[n - Y + 1] = get_max(Y);
    for (int i = n - Y ; i >= 1 ; --i){
        update_id_c(c[i] , 1);
        update_val_c(c[i] , a[i].b);
        update_id(c[i] , 1);
        update_val(c[i] , a[i].c);
        B[i] = get_max(Y) + get_min((n - i + 1) - Y);
    }
}

void inp(){
    cin >> X >> Y >> Z;
    n = X + Y + Z;
    for (int i = 1 ; i <= n ; ++i){
        cin >> a[i].a >> a[i].b >> a[i].c;
        a[i].d = a[i].a - a[i].b;
    }

    sort(a + 1 , a + n + 1, cmp);

    for (int i = 1 ; i <= n ; ++i){
        b[i].val = a[i].a - a[i].c;
        b[i].id = i;
    }

    sort(b + 1 , b + n + 1 , cmp1);
    ktao();

    for (int i = 1 ; i <= n ; ++i){
        b[i].val = a[i].b - a[i].c;
        b[i].id = i;
    }

    sort(b + 1 , b + n + 1 , cmp1);
    ktao1();
}

void solve(){
    long long res = -INF;
    for (int i = X ; i <= n - Y ; ++i){
        res = max(res , A[i] + B[i + 1]);
    }

    cout << res;
}

int main(){
//    freopen("difmax.inp" , "r" , stdin);
//    freopen("difmax.out" , "w" , stdout);
    faster;
    inp();
    solve();
    return 0;
}