#include<bits/stdc++.h>
using namespace std;
using ll = long long;

#define int ll

struct S{
    bool cur[4] = {}, inv[4] = {};
    char first = '\0', last = '\0';
    int len = 0;

    void inverse() {
        for (int i = 0; i < 4; ++i) swap(cur[i], inv[i]);
        first = first ^ 'a' ^ 'b';
        last = last ^ 'a' ^ 'b';
    }

    explicit S(char c): first(c), last(c), len(1) {
        cur[1] = cur[2] = 1;
        inv[1] = inv[2] = 1;
        if (c == 'a') cur[0] = 1;
        if (c == 'b') inv[0] = 1;
    }

    S() = default;

    friend S unite(S a, S b) {
        if (a.len == 0) return b;
        if (b.len == 0) return a;
        S res;
        res.cur[0] = (a.cur[0] && b.cur[0]) || (a.cur[2] && a.last != b.first && b.cur[1]);
        res.cur[1] = (a.cur[1] && b.cur[0]) || (a.cur[3] && a.last != b.first && b.cur[1]);
        res.cur[2] = (a.cur[0] && b.cur[2]) || (a.cur[2] && a.last != b.first && b.cur[3]);
        res.cur[3] = (a.cur[1] && b.cur[2]) || (a.cur[3] && a.last != b.first && b.cur[3]);
        res.len = a.len + b.len;
        res.first = a.first;
        res.last = b.last;
        return res;
    }
};

template<typename T>
struct SegmentTree {
    int n;
    vector<T> data;
    SegmentTree(int n2, const string& s) : n(2 << __lg(n2)), data(2 * n) {
        for (int i = 0; i < n2; ++i) data[i + n] = T(s[i]);
        for (int i = n - 1; i > 0; --i) data[i] = unite(data[2 * i], data[2 * i + 1]);
    }

    void set(int i) {
        data[i += n].inverse();
        for (i /= 2; i > 0; i /= 2) {
            data[i] = unite(data[2 * i], data[2 * i + 1]);
        }
    }

    T get(int l, int r) {
        T lans = T(), rans = T();
        for (l += n, r += n; l < r; l /= 2, r /= 2) {
            if (l & 1) lans = unite(lans, data[l++]);
            if (r & 1) rans = unite(data[--r], rans);
        }
        return unite(lans, rans);
    }
};

void gen(int os, string cur, vector <string> &ans) {
    if (os == 0) {
        ans.push_back(cur);
        return;
    }
    for (char c = 'a'; c <= 'c'; ++c) {
        auto t = cur; t += c;
        gen(os-1,t,ans);
    }
}
vector <string> a;
vector <string> b,c;

string ans;
map<vector<string>,bool> u[4][4];
bool can(int len, int h, vector <string> cand) {
    if ((int)cand.size()<=1) {
        return true;
    }
    if (h == 0) {
        return false;
    }
    if(u[len][h].count(cand)) return u[len][h][cand];
    for (int i = 0; i + 2 <= len; ++i) {
        for (auto e : b) {
            vector <vector <string>>go(3);
            for (auto x : cand) {
                int cnt = 0;
                for (int j = 0; j < 2; ++j) {
                    cnt += e[j]==x[i+j];
                }
                go[cnt].push_back(x);
            }
            bool ok = 1;
            for (auto v : go) {
                ok &= can(len, h - 1, v);
            }
            if (ok) {
                u[len][h][cand]=true;
                return true;
            }
        }
    }
    u[len][h][cand]=false;
    return false;
}
int que=0;int n;
string guess(int l, int len, int h, vector <string> cand) {
    assert(!cand.empty());
    if ((int)cand.size()<=1) {
        return cand.front();
    }
    if(h==0)assert(0);
    for (int i = 0; i + 2 <= len; ++i) {
        for (auto e : b) {
            vector <vector <string>>go(3);
            for (auto x : cand) {
                int cnt = 0;
                for (int j = 0; j < 2; ++j) {
                    cnt += e[j]==x[i+j];
                }
                go[cnt].push_back(x);
            }
            bool ok = 1;
            for (auto v : go) {
                ok &= can(len, h - 1, v);
            }
            if (ok) {
                cout << "? " << l + i + 1 << ' ' << e << endl;++que;assert(que<=(4*n+2)/3);
                int ans; cin >> ans;
                return guess(l, len, h - 1, go[ans]);
            }
        }
    }
    assert(0);
}
const int inf = 1e9;
int f[3][3];
int dp[107][107][2];
int32_t main() {
    int x,y;cin>>x>>y;
    int p, q;cin>>p>>q;
    for (int i = 0; i < 107; ++i) {
        for (int j = 0; j < 107; ++j) {
            for (int t = 0; t < 2; ++t) {
                dp[i][j][t] = inf;
            }
        }
    }
    queue <array<int,3>>qu;qu.push({x,y,0});
    dp[x][y][0] = 0;
    auto check = [&] (int s, int w ) {
        if (s == 0 || w <= s + q) {
            return true;
        }
        else {
            return false;
        }
    };
    auto ok = [&] (int ls, int lw, int t) {
        int rs = x - ls, rw = y - lw;
        if (t == 0 && !check(rs,rw)) {
            return false;
        }
        if (t == 1 && !check(ls,lw)) {
            return false;
        }
        return true;
    };
    auto relax = [&] (int ls, int lw, int t, int d) {
        if (d < dp[ls][lw][t]) {
            dp[ls][lw][t] = d;
            qu.push({ls,lw,t});
        }
    };
    while (qu.size()) {
        auto [ls, lw, t] = qu.front(); qu.pop();
        if (ls == 0) {
            cout << dp[ls][lw][t]<<endl;
            exit(0);
        }
        int d = dp[ls][lw][t];
        //cout << ls << ' ' << lw << ' ' << t << ' ' << d << endl;
        int rs = x - ls, rw = y - lw;
        if (t == 0) {
            for (int s = 0; s <= ls; ++s) {
                for (int w = 0; w <= lw; ++w) {
                    if (s + w <= p) {
                            if (ok(ls - s, lw - w, 1)) {
                                relax(ls - s, lw - w, 1, d+1);
                            }
                    }
                }
            }
        }
        else {
            for (int s = 0; s <= rs; ++s) {
                for (int w = 0; w <= rw; ++w) {
                    if (s + w <= p) {
                            if (ok(ls + s, lw + w, 0)) {
                                relax(ls + s, lw + w, 0,d+1);
                            }
                        }
                }
            }
        }
    }
    cout<<-1<<endl;

    return 0;
}