    #include <bits/stdc++.h>
    using namespace std;
    #include <math.h>
    #include <iomanip>
    #include <cstdint>
    #include <string>
    #include <sstream>
    template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
    template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
    #define rep(i,n) for (int i = 0; i < (n); ++i)
    typedef long long ll;
    using P=pair<ll,ll>;
    const int INF=1001001001;
    const int mod=1e9+7; 
    
    struct Point{
      double x,y;
    };

    void solve(){
      double n;
      cin>>n;
      vector<Point>p(n);
      cin>>p[0].x>>p[0].y>>p[n/2].x>>p[n/2].y;
      Point mid;
      mid.x=(p[0].x+p[n/2].x)/2;
      mid.y=(p[0].y+p[n/2].y)/2;
      double deg=acos(-1)*(360/n)/180.0;
      p[1].x=(p[0].x-mid.x)*cos(deg)-(p[0].y-mid.y)*sin(deg)+mid.x;
      p[1].y=(p[0].x-mid.x)*sin(deg)+(p[0].y-mid.y)*cos(deg)+mid.y;
      cout<<p[1].x<<" "<<p[1].y<<endl;
    }
    int main(){
      solve();
      return 0;
    }

#include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i<(n); i++)
#define rep2(i,x,n) for(int i=x; i<(n); i++)
#define ALL(n) begin(n),end(n)
using namespace std;
using P = pair<int, int>;
using ll = long long;

const int mod = 1e9+7;
struct mint{
    ll x;
    mint(ll x=0):x((x%mod+mod)%mod){}
    mint operator-() const {return mint(-x);}
    mint& operator+=(const mint a){
        if((x+=a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator-=(const mint a){
        if((x+=mod-a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator*=(const mint a){(x*=a.x) %= mod; return *this;}
    mint operator+(const mint a) const{return mint(*this) += a;}
    mint operator-(const mint a) const{return mint(*this) -= a;}
    mint operator*(const mint a) const{return mint(*this) *= a;}
    mint pow(ll t) const{
        if(!t) return 1;
        mint a=pow(t>>1);
        a*=a;
        if(t&1)a *= *this;
        return a;
    }

    mint inv() const {return pow(mod-2);}
    mint& operator/=(const mint a){return *this *= a.inv();}
    mint operator/(const mint a) const{return mint(*this) /= a;}
};
istream& operator>>(istream& is, const mint& a) {return is >> a.x;}
ostream& operator<<(ostream& os, const mint& a) {return os << a.x;}

// ------------------ combination -------------------
// 組合せ nCr
struct combination{
    vector<mint> fact, ifact;
    combination(int n):fact(n+1), ifact(n+1){
        assert(n < mod);
        fact[0] = 1;
        for(int i=1; i<=n; i++)fact[i] = fact[i-1]*i;
        ifact[n] = fact[n].inv();
        for(int i=n; i>=1; i--)ifact[i-1] = ifact[i]*i;
    }
    mint operator()(int n, int k){
        if(k < 0 || k > n)return 0;
        return fact[n] * ifact[k] * ifact[n-k];
    }
};

int main()
{
    int n, m, k;
    cin >> n >> m >> k;

    combination comb(n+m+5);

    if(n - k > m){
        cout << 0 << endl;
        return 0;
    }

    mint ans = comb(n+m, n);

    if(k < n){
        ans -= comb(n+m, n-(k+1));
    }

    cout << ans << endl;
    
    return 0;
}