// #pragma GCC optimize("Ofast")
// #pragma GCC optimize("unroll-loops")
// #pragma GCC push_options
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
// #include<bits/stdc++.h>
// #include <xmmintrin.h>
// #include <immintrin.h>
// using namespace::std;
// __attribute__((constructor))void init(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);}
// #include<ext/pb_ds/assoc_container.hpp>
// #include<ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/priority_queue.hpp>
// #include<ext/pb_ds/tag_and_trait.hpp>
// // #include <boost/multiprecision/cpp_dec_float.hpp>
// // #include <boost/multiprecision/cpp_int.hpp>
// // namespace mp = boost::multiprecision;
// // typedef mp::number<mp::cpp_dec_float<0>> cdouble;
// // typedef mp::cpp_int cint;
// template<typename T>using pbds=__gnu_pbds::tree<T,__gnu_pbds::null_type,less<T>,__gnu_pbds::rb_tree_tag,__gnu_pbds::tree_order_statistics_node_update>;
// template<typename T>using pbds_map=__gnu_pbds::tree<T,T,less<T>,__gnu_pbds::rb_tree_tag,__gnu_pbds::tree_order_statistics_node_update>;
// template<typename T,typename E>using hash_map=__gnu_pbds::gp_hash_table<T,E>;
// template<typename T>using pqueue =__gnu_pbds::priority_queue<T, greater<T>,__gnu_pbds::rc_binomial_heap_tag>;
// typedef long long lint;
// #define INF (1LL<<60)
// #define IINF (1<<30)
// #define LINF (9223372036854775807LL)
// #define EPS (1e-10)
// #define endl ('\n')
// #define MOD 1000000007LL
// //#define MOD 998244353LL
// typedef vector<lint> vec;
// typedef vector<vector<lint>> mat;
// typedef vector<vector<vector<lint>>> mat3;
// typedef vector<string> svec;
// typedef vector<vector<string>> smat;
// template<typename T>inline void numout(T t){bool f=0;for(auto i:t){cout<<(f?" ":"")<<i<INF/2?i:"INF";f=1;}cout<<endl;}
// template<typename T>inline void numout2(T t){for(auto i:t)numout(i);}
// template<typename T>inline void output(T t){bool f=0;for(auto i:t){cout<<(f?" ":"")<<i;f=1;}cout<<endl;}
// template<typename T>inline void output2(T t){for(auto i:t)output(i);}
// template<typename T>inline void _output(T t){bool f=0;for(lint i=0;i<t.size();i++){cout<<f?"":" "<<t[i];f=1;}cout<<endl;}
// template<typename T>inline void _output2(T t){for(lint i=0;i<t.size();i++)output(t[i]);}
// #define rep(i,n) for(lint i=0;i<lint(n);++i)
// #define repi(i,a,b) for(lint i=lint(a);i<(lint)(b);++i)
// #define rrep(i,n) for(lint i=lint(n)-1;i>=0;--i)
// #define rrepi(i,a,b) for(lint i=lint(b)-1;i>=lint(a);--i)
// #define irep(i) for(lint i=0;;++i)
// #define all(n) begin(n),end(n)
// #define dist(a,b,c,d) sqrt(pow(a-c,2)+pow(b-d,2))
// inline lint gcd(lint A,lint B){return B?gcd(B,A%B):A;}
// inline lint lcm(lint A,lint B){return A/gcd(A,B)*B;}
// // inline cint cgcd(cint A,cint B){return B?cgcd(B,A%B):A;}
// // inline cint clcm(cint A,cint B){return A/cgcd(A,B)*B;}
// bool chmin(auto& s,const auto& t){bool res=s>t;s=min(s,t);return res;}
// bool chmax(auto& s,const auto& t){bool res=s<t;s=max(s,t);return res;}
// const vector<lint> dx={1,0,-1,0,1,1,-1,-1};
// const vector<lint> dy={0,1,0,-1,1,-1,1,-1};
// #define SUM(v) accumulate(all(v),0LL)
// auto call=[](auto f,auto... args){return f(f,args...);};

// template<typename T>
// struct AVL_BASE{
//     struct node{
//         T val;
//         int sz=1,dep=1;
//         node* ch[2]={0,0};
//         node(T val):val(val){}
//         void cpy(node* t){val=t->val;}
//     };
//     using np=node*;
//     int sz(np t){return t?t->sz:0;}
//     int dep(np t){return t?t->dep:0;}
//     np root=0;
//     np update(np t){
//         t->sz=sz(t->ch[0])+1+sz(t->ch[1]);
//         return t;
//     }
//     np merge_with_root(np s,np t,np u){
//         if(abs(sz(s)-sz(u))<2){
//             t->ch[0]=s;t->ch[1]=u;
//             return update(t);
//         }
//         if(sz(s)>sz(u)){
//             s->ch[1]=merge_with_root(s->ch[1],t,u);
//             return update(s);
//         }else{
//             u->ch[0]=merge_with_root(s,t,u->ch[0]);
//             return update(u);
//         }
//     }
//     np make_root(np& t){
//         if(t->ch[1]){
//             np res=make_root(t->ch[1]);
//             update(t);
//             return res;
//         }
//         else {
//             np res=t;
//             t=t->ch[0];
//             return res;
//         }
//     }
//     np merge(np s,np t){
//         if(!s||!t)return s?s:t;
//         np u=make_root(s);
//         return merge_with_root(s,u,t);
//     }
//     pair<np,np>split(np t,int i){
//         if(!t)return make_pair(nullptr,nullptr);
//         np s=t->ch[0],u=t->ch[1];
//         t->ch[0]=0;t->ch[1]=0;
//         if(i==sz(s)){
//             return make_pair(s,merge_with_root(0,t,u));
//         }
//         if(i<sz(s)){
//             auto r=split(s,i);
//             return make_pair(r.first,merge_with_root(r.second,t,u));
//         }else{
//             auto r=split(u,i-sz(s)-1);
//             return make_pair(merge_with_root(s,t,r.first),r.second);
//         }
//     }
//     public:
//     int size(){return sz(root);}
//     void insert(int x,T v){
//         assert(0<=x&&x<=size());
//         auto s=split(root,x);
//         root=merge_with_root(s.first,new node(v),s.second);
//     }
//     void erase(int x){
//         assert(0<=x&&x<size());
//         auto s=split(root,x);
//         auto t=split(s.second,1);
//         root=merge(s.first,t.second);
//     }
//     T sum(T l,T r){

//     }
// };

// template<typename T>
// struct AVL_array:AVL_BASE<T>{
//     using AVL_BASE<T>::AVL_BASE;
//     void push_back(T v){this->insert(this->size(),v);}
//     void pop_back(){this->erase(this->size()-1);}
// };

// template<typename E=lint,typename T=double>
// vector<T> dij(vector<vector<pair<E,T>>> list,lint s,T inf){
//     std::priority_queue<pair<T,E>,vector<pair<T,E>>,greater<pair<T,E>>>que;
//     vector<T>diff(list.size(),inf);
//     diff[s]=0;
//     que.push(make_pair(T(),s));
//     while(!que.empty()){
//         auto d=que.top();
//         que.pop();
//         T x;E now;
//         tie(x,now)=d;
//         for(auto d2:list[now]){
//             T sa;E to;
//             tie(to,sa)=d2;
//             if(chmin(diff[to],diff[now]+sa))que.emplace(diff[to],to);
//         }
//     }
//     return diff;
// }

// int main(){
//     lint n,m;
//     cin>>n>>m;
//     vector<vector<pair<lint,lint>>> v(n+m);
//     vector<map<lint,vec>> g(n);
//     rep(i,m){
//         lint s,t,c;
//         cin>>s>>t>>c;
//         s--;t--;
//         v[s].emplace_back(n+i,1);
//         v[n+i].emplace_back(s,1);
//         v[t].emplace_back(n+i,1);
//         v[n+i].emplace_back(t,1);
//         g[s][c].push_back(n+i);
//         g[t][c].push_back(n+i);
//     }
//     rep(i,n)for(auto e:g[i])rep(j,e.second.size()-1){
//         v[e.second[j]].emplace_back(e.second[j+1],0);
//         v[e.second[j+1]].emplace_back(e.second[j],0);
//     }
//     auto d=dij(v,0,INF);
//     if(d[n-1]==INF)cout<<-1<<endl;
//     else cout<<d[n-1]/2<<endl;
// }

#include <bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
using namespace std;
using ll = int64_t;
#define rep(i,n) for(int i = 0; i < ((int)(n)); i++)   // 0-indexed昇順

template<typename T>
struct fast_set{
	constexpr static int B=4;
	struct node{
		T val=0;
        bool b=0;
		node** ch=new node*[1<<B]();
	};
	using np=node*;
	np root=0,root2=0;
	T& operator[](int64_t k){
        return get(abs(k),k>0?root:root2);
    }
    bool count(int64_t k){
        return count(abs(k),k>0?root:root2);
    }
    vector<pair<int64_t,T>> out(){
        vector<pair<int64_t,T>>v;
        out(v,root2,0,-1,0);
        out(v,root,0,1,0);
        sort(v.begin(),v.end());
        return v;
    }
	T& get(int64_t k,np& t){
		if(!t)t=new node();
		if(!k){
            t->b=1;
            return t->val;
        }
		return get(k>>B,t->ch[k&((1<<B)-1)]);
	}
    bool count(int64_t k,np& t){
        if(!t)return 0;
        if(!k)return t->b;
        else return count(k>>B,t->ch[k&((1<<B)-1)]);
    }
    void out(vector<pair<int64_t,T>>&v,np& t,int64_t k,int f,int b){
        if(!t)return;
        if(t->b)v.emplace_back(k*f,t->val);
        for(int i=0;i<(1<<B);++i){
            out(v,t->ch[i],k+(i<<(B*b)),f,b+1);
        }
    }
};

int main() {
    int N, Ma, Mb; cin >> N >> Ma >> Mb;
    int A[41], B[41], C[41];
    rep(i,N) {
        int a, b, c;
        scanf("%d %d %d", &a, &b, &c);
        A[i] = a;
        B[i] = b;
        C[i] = c;
    }
    int H1 = N / 2;
    int H2 = N - H1;
    int mi = INT32_MAX;

    // (MbA0−MaB0)+(MbA1−MaB1)=0
    // MbA0 - MaB0 = MaB1 - MbA1
    
    fast_set<int> M1;
    for (int bit = 1; bit < pow(2,H1); bit++) {
        int a = 0, b = 0, c = 0;
        for (int i = 0; i < H1; i++) {
            if (bit & (1 << i)) {
                a += A[i];
                b += B[i];
                c += C[i];
            }
        }
        int s = Mb * a - Ma * b;
        if (M1[s] == 0) M1[s] = c; // Can't be zero
        else M1[s] = min(M1[s], c);
        if (s == 0) mi = min(mi, c);
    }

    fast_set<int> M2;
    for (int bit = 1; bit < pow(2,H2); bit++) {
        int a = 0, b = 0, c = 0;
        for (int i = 0; i < H2; i++) {
            if (bit & (1 << i)) {
                a += A[H1 + i];
                b += B[H1 + i];
                c += C[H1 + i];
            }
        }
        int s = Ma * b - Mb * a;
        if (M2[s] == 0) M2[s] = c;
        else M2[s] = min(M2[s], c);
        if (s == 0) mi = min(mi, c);
    }
    for (auto x : M1.out()) {
        if (M2.count(x.first)) {
            mi = min(mi, x.second + M2[x.first]);
        }
    }

    if (mi == INT32_MAX) {
        cout << -1 << endl;
    } else {
        cout << mi << endl;
    }
}


Measured memory_bytes: 640