#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <numeric>


#define ll              long long 
#define F               first
# define S              second
#define all(v)          v.begin(),v.end()
#define ld              long double
#define pll             std::pair<ll,ll>
#define pi              std::pair<int,int>
#define vi              std::vector<int>
#define vll             std::vector<ll>
#define len(x)          (int)x.size()
#define vec(T)          std::vector<T>


template<typename T, typename = void>
struct is_printable : std::false_type {};

template<typename T>
struct is_printable<T, std::void_t<decltype(std::declval<std::ostream&>() << std::declval<T>())>> : std::true_type {};
template <typename T>
void print(const std::pair<T, T>& pair) {
    std::cout << "(" << pair.first << ", " << pair.second << ")";
}

// General print function
template <typename T>
void print(const T& val) {
    std::cout << val;
}

// Print function for std::vector
template <typename T>
void print(const std::vector<T>& vec) {
    std::cout << '[';
    int n = vec.size();
    for (int i = 0; i < n; i++) {
        print(vec[i]);
        if (i < n - 1) {
            std::cout << ",";
        }
    }
    std::cout << ']' << '\n';
}

// Variadic template print function
template<typename T, typename... Args>
void print(const T& t, const Args&... args) {
    print(t);
    std::cout << (is_printable<T>::value ? ' ' : '\0');
    print(args...);
    if (sizeof...(args) == 1 && is_printable<T>::value) std::cout << '\n';

}


struct card {
    ll d, k, c;
};

struct record {
    ll p, q;
};


int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int n, m, l = 0, idx = 0;
    ll r;
    std::cin >> n >> m >> r;
    vec(card) c(n);
    vec(record) tmp(m);
    for (int i = 0; i < n; i++) {
        std::cin >> c[i].d >> c[i].k >> c[i].c;
    }
    for (int i = 0; i < m; i++) {
        std::cin >> tmp[i].p >> tmp[i].q;
        l += tmp[i].q;
    }
    vi rec(l);
    std::sort(all(tmp), [&](record i, record j) {return i.p < j.p;});
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < tmp[i].q; j++) {
            rec[idx++] = tmp[i].p;
        }
    }
    vll dp(l + 1);
    for (int i = 0; i < l; i++) {
        dp[i + 1] = dp[i] + r;
        for (int j = 0; j < n; j++) {
            ll k = std::lower_bound(rec.begin(), rec.begin() + i, rec[i] - c[j].d + 1) - rec.begin();
            k = std::max(k, i - c[j].k + 1);
            dp[i + 1] = std::min(dp[i + 1], dp[k] + c[j].c);
        }    
    }
    std::cout << dp[l] << '\n';
    return 0;
}