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

struct mint {
    static constexpr int mod = 1'000'000'007;
    int value = 0;

    mint() = default;
    mint(int value) : value(value) {}
};

mint operator+(const mint &A, const mint &B) {
    int value = A.value + B.value;
    if (value >= mint::mod) {
        value -= mint::mod;
    }
    return mint(value);
}

mint operator-(const mint &A, const mint &B) {
    int value = A.value + mint::mod - B.value;
    if (value >= mint::mod) {
        value -= mint::mod;
    }
    return mint(value);
}

mint operator*(const mint &A, const mint &B) {
    return mint(1ll * A.value * B.value % mint::mod);
}

mint recA(int l, int i, int j);
mint recB(int l, int i, int j);

map<tuple<int, int, int>, mint> savedA;

tuple<int, int, int> gett(int l, int i, int j) {
    if (i == 0) {
        return tuple(l, j, 0);
    } else {
        return tuple(l, i, 1);
    }
}

mint recA(int l, int i, int j) {
    if (i > j) {
        if (l % 2 == 0) {
            return recB(l, j, i);
        } else {
            return recA(l, j, i);
        }
    }

    if (savedA.contains(gett(l, i, j))) {
        return savedA[gett(l, i, j)];
    }
    
    if (l == 1) {
        if (i == 0 && j == 0) {
            return 1;
        } else {
            return 0;
        }
    }
    
    if (i == j) {
        return 0;
    }

    if (i == 0) {
        mint res = 0;
        if (l % 2 == 0) {
            if (j == 1) {
                for (int k = 0; k < j; k++) {
                    res = res + recA(l - 1, 0, k);
                }
            } else {
                res = recA(l, 0, j - 1) + recA(l - 1, 0, j - 1);
            }
        } else {
            if (j == 1) {
                for (int k = j; k <= l - 2; k++) {
                    res = res + recA(l - 1, 0, k);
                }
            } else {
                res = recA(l, 0, j - 1) - recA(l - 1, 0, j - 1);
            }
        }
        return savedA[gett(l, i, j)] = res;
    }

    return savedA[gett(l, i, j)] = recA(l, i - 1, j) - recB(l - 1, i - 1, j - 1);
}

map<tuple<int, int, int>, mint> savedB;

mint recB(int l, int i, int j) {
    if (i > j) {
        if (l % 2 == 0) {
            return recA(l, j, i);
        } else {
            return recB(l, j, i);
        }
    }

    if (savedB.contains(gett(l, i, j))) {
        return savedB[gett(l, i, j)];
    }

    if (l == 1) {
        if (i == 0 && j == 0) {
            return 1;
        } else {
            return 0;
        }
    }
    
    if (i == j) {
        return 0;
    }

    if (i == 0) {
        return savedB[gett(l, i, j)] = 0;
    }

    return savedB[gett(l, i, j)] = recB(l, i - 1, j) + recA(l - 1, i - 1, j - 1);
}

signed main() {
#ifndef LOCAL
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
#else
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif

    int n, s, f;
    cin >> n >> s >> f;
    s--, f--;

    cout << (recA(n, s, f) + recB(n, s, f)).value << '\n';
    return 0;
}