#include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define T     \
  ll rrr;     \
  cin >> rrr; \
  for (ll w1 = 0; w1 < rrr; w1++)
#define cin(vec, a) for (ll i = 0; i < a && cin >> vec[i]; i++)
#define cout(vec, a) for (ll i = 0; i < a && cout << vec[i] << " "; i++)
#define MOD 1000000007
#define PI 3.14159265
#define ceil(a, b) ((a / b) + (a % b ? 1 : 0))
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#include <iostream>
#define INF 1e9
#define mod 1000000007
#include <string>
#define el '\n'
#define sp ' '
#define loop(n) for (int i = 0; i < n; i++)
typedef long long ll;
#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
#define multi_ordered_set tree<ll, null_type, greater_equal<ll>, rb_tree_tag, tree_order_statistics_node_update>
/*  /////////////    dsu   //////////////
vector<int> parent;
vector<int> ran;

void init(int n)
{
  parent[n] = n;
  ran[n] = 0;
}
int find(int n)
{
  if (parent[n] == n)
    return n;
  return parent[n] = find(parent[n]);
}
void union1(int a, int b)
{
  a = find(a);
  b = find(b);
  if (a != b)
  {
    if (ran[a] < ran[b])
      swap(a, b);

    parent[b] = a;
    if (ran[a] == ran[b])
      ran[a]++;
  }
}
  /////////////    dsu   //////////////
*/
/*  /////////////    sparse_table   //////////////
vector<vector<ll>> sparse_table;
int op1(int a, int b, string s)
{
  if (s == "min")
    return min(a, b);
  else if (s == "max")
    return max(a, b);
  else if (s == "gcd")
    return __gcd(a, b);
  else if (s == "lcm")
    return (a * b) / __gcd(a, b);
  else if (s == "sum")
    return a + b;
  else if (s == "mul")
    return a * b;
}
void full(int n, int k, string s)
{
  for (int i = 1; i < k; i++)
    for (int j = 0; j + (1 << i) <= n; j++)
      sparse_table[i][j] = op1(sparse_table[i - 1][j], sparse_table[i - 1][j + (1 << (i - 1))], s);
}
int op2(int l, int r, int k)
{
  long long sum = 0;
  for (int i = k; i >= 0; i--)
  {
    if ((1 << i) <= r - l + 1)
    {
      sum += sparse_table[i][l];
      l += 1 << i;
    }
  }
  return sum;
}
void init1()
{

  int n, q;
  cin >> n;
  int k = log2(n) + 1;
  sparse_table = vector<vector<ll>>(k, vector<ll>(n, 0));
  for (int i = 0; i < n; i++)
    cin >> sparse_table[0][i];
  full(n, k, "sum");
  cin >> q;
  while (q--)
  {
    int l, r;
    cin >> l >> r;
    int len = r - l + 1;
    int k = log2(len);
    cout << op2(l, r, k) << el;
  }

}
  /////////////    sparse_table   //////////////
*/
/*  /////////////    fenwick_tree   //////////////
class FenwickTree {
private:
    vector<int> tree;
    int n;

public:
    FenwickTree(int size) {
        n = size;
        tree.resize(n+1);
    }

    void update(int idx, int val) {
        idx++;
        while (idx <= n) {
            tree[idx] += val;
            idx += idx & (-idx);
        }
    }

    int query(int idx) {
        idx++;
        int sum = 0;
        while (idx > 0) {
            sum += tree[idx];
            idx -= idx & (-idx);
        }
        return sum;
    }

    int rangeQuery(int l, int r) {
        return query(r) - query(l-1);
    }
};
///////////    fenwick_tree   //////////////
*/
void sasa()
{
  ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
#ifndef ONLINE_JUDGE
  freopen("input4.txt", "r", stdin), freopen("output4.txt", "w", stdout);
#endif
}
///////////////////////////////////////// code //////////////////////////////////////////////////////////////////////////
struct sa
{
  ll a, b, c;
};
vector<sa> v;
vector<vector<vector<ll>>> dp;
ll n, w1, w2;
ll mix(ll idx, ll r1, ll r2)
{
  if (idx == v.size())
  {
    ll t1 = __gcd(r1, r2);
    if (t1 != 0 && (r1 / t1) == w1 && (r2 / t1) == w2)
      return 0;
    else
      return INF;
  }

  if (dp[idx][r1][r2] != -1)
    return dp[idx][r1][r2];

  ll t1 = __gcd(r1, r2);
  if (t1 != 0 && (r1 / t1) == w1 && (r2 / t1) == w2)
    return dp[idx][r1][r2] = 0;

  ll ans = INF;
  ans = min(ans, v[idx].c + mix(idx + 1, r1 + v[idx].a, r2 + v[idx].b));
  ans = min(ans, mix(idx + 1, r1, r2));

  return dp[idx][r1][r2] = ans;
}
void solve()
{
  cin >> n >> w1 >> w2;
  v = vector<sa>(n);
  dp = vector<vector<vector<ll>>>(n + 1, vector<vector<ll>>(460 + 1, vector<ll>(460, -1)));
  for (ll i = 0; i < n; i++)
  {
    cin >> v[i].a >> v[i].b >> v[i].c;
  }
  ll l = mix(0, 0, 0);
  cout << (l == INF ? -1 : l);
}

int main()
{
  sasa();
  ll t = 1, i = 1;
  // cin >> t;
  while (t--)
  {
    // cout << "test #" << i << ":\n";
    solve();
    i++;
    if (!t)
      break;
    cout << "\n";
  }

  return 0;
}