#include<bits/stdc++.h>
using namespace std;
#define test(t) int t;cin>>t;while(t--)
#define lli long long int
#define pb push_back
#define MAX 10000007
#define mod 1000000007
#define fast  ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0)
//a.push_back(i+'0');convert i to char;
//cout << fixed << setprecision(2) << pi ;
const lli infl=0x3f3f3f3f3f3f3f3fLL;

int main()
{ fast;
    // int t;
   //cin>>t ;
 // while(t--)
    {
       lli i,j,n,q,k,sum=0,cnt=0,ans=0,num,x,y;
       cin>>n;
  if(n%2)cout<<"Black";
  else
    cout<<"White";

              //cout<<ans<<"\n";

      cout<<endl;
    }
}

#pragma GCC target("avx2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
//#include <atcoder/all>
using namespace std;
//using namespace atcoder;
#define DEBUG
#ifdef DEBUG
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
    os << '(' << p.first << ',' << p.second << ')';
    return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
    os << '{';
    for(int i = 0; i < (int)v.size(); i++) {
        if(i) { os << ','; }
        os << v[i];
    }
    os << '}';
    return os;
}
void debugg() { cerr << endl; }
template <class T, class... Args>
void debugg(const T &x, const Args &... args) {
    cerr << " " << x;
    debugg(args...);
}
#define debug(...)                                                             \
    cerr << __LINE__ << " [" << #__VA_ARGS__ << "]: ", debugg(__VA_ARGS__)
#define dump(x) cerr << __LINE__ << " " << #x << " = " << (x) << endl
#else
#define debug(...) (void(0))
#define dump(x) (void(0))
#endif
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef pair<ll,ll> P;
typedef pair<int,int> pii;
typedef vector<P> vpl;
typedef tuple<ll,ll,ll> tapu;
#define rep(i,n) for(int i=0; i<(n); i++)
#define REP(i,a,b) for(int i=(a); i<(b); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int inf = (1<<30) - 1;
const ll linf = 1LL<<61;
const int MAX = 510000;
int dy[8] = {0,1,0,-1,1,-1,-1,1};
int dx[8] = {-1,0,1,0,1,-1,1,-1};
const double pi = acos(-1);
const double eps = 1e-7;
template<typename T1,typename T2> inline bool chmin(T1 &a,T2 b){
	if(a>b){
		a = b; return true;
	}
	else return false;
}
template<typename T1,typename T2> inline bool chmax(T1 &a,T2 b){
	if(a<b){
		a = b; return true;
	}
	else return false;
}
template<typename T> inline void print(T &a){
    int sz = a.size();
    for(auto itr = a.begin(); itr != a.end(); itr++){
		cout << *itr;
        sz--;
        if(sz) cout << " ";
	}
    cout << "\n";
}
template<typename T1,typename T2> inline void print2(T1 a, T2 b){
	cout << a << " " << b << "\n";
}
template<typename T1,typename T2,typename T3> inline void print3(T1 a, T2 b, T3 c){
	cout << a << " " << b << " " << c << "\n";
}
void mark() {cout << "#" << "\n";}
ll pcount(ll x) {return __builtin_popcountll(x);}
//const int mod = 1e9 + 7;
const int mod = 998244353;

int main(){
    int n; cin >> n;
    rep(i,n) cout << i/2+1 << " " << (i+n)/2+1 << "\n";
}


#include <bits/stdc++.h>
        #include <math.h>

        using namespace std;
        typedef long long ll;
        typedef unsigned long long ull;
        # define M_PI  3.14159265358979323846

        const int M=1e9+7;
        long long mod(long long x){
            return ((x%M + M)%M);
        }
        long long add(long long a, long long b){
            return mod(mod(a)+mod(b));
        }
        long long mul(long long a, long long b){
            return mod(mod(a)*mod(b));
        }

        ll modPow(ll a, ll b){
            if(b==0)
                return 1LL;
            if(b==1)
                return a%M;
            ll res=1;
            while(b){
                if(b%2==1)
                    res=mul(res,a);
                a=mul(a,a);
                b=b/2;
            }
            return res;
        }
        vector<int>adj[200005];
        vector<bool>vis(200005,false);
        vector<int>a(200005);
        vector<int>b(200005);
        long long suma=0;
        long long sumb=0;

        void dfs(int i){
            if(!vis[i]){
                vis[i]=true;
                suma+=(long long)a[i];
                sumb+=(long long)b[i];
                for(auto v : adj[i]){
                    dfs(v);
                }
            }
        }

        void solve (){
            int n,m;
            cin>>n>>m;
            for(int i=0;i<n;i++)
                cin>>a[i];
            for(int i=0;i<n;i++)
                cin>>b[i];
            for(int i=0;i<m;i++){
                int x,y;
                cin>>x>>y;
                --x;
                --y;
                adj[x].push_back(y);
                adj[y].push_back(x);
            }
            for(int i=0;i<n;i++){
                if(!vis[i]){
                    suma=0;
                    sumb=0;
                    dfs(i);
                    if(suma!=sumb){
                        cout<<"No";
                        return;
                    }
                }
            }
            cout<<"Yes";
        }
        int main(){
            ios::sync_with_stdio(0);
            cin.tie(0);
            cout.tie(0);
            cout<<fixed;
            cout<<setprecision(10);
    //        freopen("timber_input.txt", "r", stdin);
    //        freopen("timber_output.txt", "w", stdout);
            int t=1;
            // cin>>t;
            for(int i=1;i<=t;i++){
            //    cout<<"Case #"<<i<<": ";
                solve();
            }
            return 0;
        }

#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;++i)
#define all(x) (x).begin(),(x).end()
using namespace std;
constexpr int INF = 1e9, MOD = 1e9 + 7;
constexpr int64_t LINF = 5e18, LMOD = 998244353;
// #include <atcoder/all>
// using namespace atcoder;
// const int dy[]={0,-1,0,1,1,-1,-1,1};
// const int dx[]={1,0,-1,0,1,1,-1,-1};

vector<int> edge[200010];
int64_t dp[200010];
int main() {
	int n, m; cin >> n >> m;
	int64_t a[n]; rep(i,n) cin >> a[i];
	while(m--) {
		int x, y; cin >> x >> y;
		--x, --y;
		edge[y].push_back(x);
	}
	int64_t ans = -MOD;
	for(int i = 0; i < n; ++i) {
		dp[i] = MOD;
		if(edge[i].empty()) {
			dp[i] = a[i];
		} else {
			for(int to : edge[i]) {
				dp[i] = min(dp[to], dp[i]);
			}
			ans = max(ans, a[i] - dp[i]);
			dp[i] = min(a[i], dp[i]);
		}
	}
	cout << ans << '\n';
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)

int main(){
  int n;
  string s,t;
  cin >> n >> s >> t;
  vector<int> a,b;
  for(int i = 0;i < n;i++){
     if(s.at(i) == '0') a.push_back(i);
     if(t.at(i) == '0') b.push_back(i);
  }
  if((int)a.size() != (int)b.size()){
     cout << -1 << endl;
     return 0;
  }
  int res = 0;
  for(int i = 0;i < (int)a.size();i++){
     if(a.at(i) != b.at(i)) res++;
  }
  cout << res << endl;
}

#include <bits/stdc++.h>
constexpr int DEBUG = 0;
using namespace std;
using int64 = long long;

int64 Solve() {
  int n; cin >> n;
  string s0; cin >> s0;
  string s1; cin >> s1;
  vector<int> x0s;
  vector<int> x1s;
  for (int i = 0; i < n; i++) {
    if (s0[i] == '0') {
      x0s.push_back(i);
    }
    if (s1[i] == '0') {
      x1s.push_back(i);
    }
  }
  if (x0s.size() != x1s.size()) return -1;
  int c = 0;
  for (int i = 0; i < x0s.size(); i++) {
    if (x0s[i] != x1s[i]) {
      c++;
    }
  }
  return c;
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);

  cout << Solve() << endl;
}


#include <bits/stdc++.h>

template <typename InputIterator>
typename InputIterator::value_type summation(InputIterator first,
                                             InputIterator last) {
  return std::accumulate(first, last, typename InputIterator::value_type());
}
template <typename T>
std::istream &operator>>(std::istream &stream, std::vector<T> &v);
template <typename T1, typename T2>
std::istream &operator>>(std::istream &stream, std::pair<T1, T2> &p);
template <typename T>
std::istream &operator>>(std::istream &stream, std::vector<T> &v) {
  for (auto &i : v) {
    stream >> i;
  }
  return stream;
}
template <typename T1, typename T2>
std::istream &operator>>(std::istream &stream, std::pair<T1, T2> &p) {
  stream >> p.first >> p.second;
  return stream;
}

int main() {
  int64_t n, k, m;
  std::cin >> n >> k >> m;
  auto r = m * n;
  std::vector<int64_t> a(n - 1);
  std::cin >> a;
  r -= summation(a.cbegin(), a.cend());

  if (k < r) {
    std::cout << -1 << std::endl;
  } else {
    std::cout << std::max(static_cast<int64_t>(0), r) << std::endl;
  }
  return 0;
}

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

const long long MOD = 1e9 + 7;
const int INF = 1e9;
const long long inf = 1LL<<60;

//cout << fixed << setprecision(10) <<  << endl;
char judge(char a, char b) {
  if (a == b) return a;
  if (a == 'P') {
    if (b == 'R') {
      return a;
    } else {
      return b;
    }
  } else if (a == 'R') {
    if (b == 'S') {
      return a;
    } else {
      return b;
    }
  } else {
    if (b == 'P') {
      return a;
    } else {
      return b;
    }
  }
}

int main() {
  int n, k;
  cin >> n >> k;
  string s;
  cin >> s;
  auto run = [&]() -> void {
    string t = s + s;
    s = "";
    for (int i=0; i<n*2; i+=2) {
      s += judge(t.at(i), t.at(i+1));
    }
  };
  for (int i=0; i<k; i++) {
    run();
  }
  cout << s.at(0) << endl;
}


#include <math.h>
#include <assert.h>
#include <algorithm>
#include <set>
#include <iostream>
#include <vector>
#include <iomanip>
#include <queue>
#include <map>
#include <string>
#include <cstring>
#include <functional>
#include <stack>
#include <array>
#include <random>
#include <chrono>
#include <climits>
#include <bitset>
using namespace std ;
#define rep(i, a, b) for (int i=a; i<(b); i++)
#define forn(i, a) for (int i=0; i<(a); i++)
#define repd(i,a,b) for (int i = (b)-1; i >= a; i--)
#define ford(i,a) for (int i = (a)-1; i >= 0; i--)
#define trav(a,x) for (auto& a : x)
#define int long long
#define ii pair<int,int>
#define ar array
#define FAST_IO ios_base::sync_with_stdio(false) ;cin.tie(NULL);cout.tie(NULL)
#define ms(x,a) memset(x,(int)(a),sizeof(x))
#define sz(x) ((int)(x).size())
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
#define pb push_back
#define endl '\n'
#define ff first
#define ss second
//const int INF = 1e18 ;
//const int MOD = 1e9 + 7 ;
const int N = 2e5+5 ;
int a[N] ;
bool done[N] ;

vector<int> fact;
vector<int> ifact;
vector<int> inv;
vector<int> pow2;
const int MOD = 998244353;
int add(int a, int b)
{
    a+=b;
    while(a>=MOD) a-=MOD;
    return a;
}
void radd(int &a, int b)
{
    a=add(a,b);
}
int mult(int a, int b)
{
    return (a*1LL*b)%MOD;
}
void rmult(int &a, int b)
{
    a=mult(a,b);
}
int modpow(int a, int b)
{
    int r=1;
    while(b)
    {
        if(b&1) r=mult(r,a);
        a=mult(a,a);
        b>>=1;
    }
    return r;
}
int choose(int a, int b)
{
    if(a<0||b<0) return 0;
    if(a<b) return 0;
    if(b==0) return 1;
    if(a==b) return 1;
    return mult(fact[a],mult(ifact[b],ifact[a-b]));
}
int inverse(int a)
{
    return modpow(a,MOD-2);
}
void init(int _n)
{
    fact.clear(); ifact.clear(); inv.clear(); pow2.clear();
    fact.resize(_n+1);
    ifact.resize(_n+1);
    inv.resize(_n+1);
    pow2.resize(_n+1);
    pow2[0]=1;
    ifact[0]=1;
    fact[0]=1;
    for(int i=1;i<=_n;i++)
    {
        pow2[i]=add(pow2[i-1],pow2[i-1]);
        fact[i]=mult(fact[i-1],i);
        //ifact[i]=mult(ifact[i-1],inv[i]);
    }
    ifact[_n] = inverse(fact[_n]);
    for(int i=_n-1;i>=1;i--)
    {
        ifact[i] = mult(ifact[i + 1], i + 1);
    }
    for(int i=1;i<=_n;i++)
    {
        inv[i] = mult(fact[i-1],ifact[i]);
    }
}
vector<vector<int>> graph;
int cycles;
vector<int> vis ;
void dfs(int node) {
    if(vis[node] == 2) return ;
    if(vis[node] == 1) {
        cycles++ ;
        return ;
    }
    vis[node] = 1 ;
    for(int x : graph[node]) {
        dfs(x) ;
    }
    vis[node] = 2 ;
}

void solve(){
    int n ;
    cin >> n ;
    graph.resize(n) ;
    forn(i,n) {
        cin >> a[i] ;
        --a[i] ;
        graph[i].push_back(a[i]) ;
    }
    cycles = 0;
    vis.assign(n, 0) ;
    forn(i,n) dfs(i) ;
    int ans = pow2[cycles] ;
    radd(ans, MOD-1) ;
    cout << ans << endl ;
}

int32_t main(){
    FAST_IO ;
    int t = 1 ;
    init(N) ;
//    cin >> t ;
    while(t--){
        solve() ;
    }
}

#include <bits/stdc++.h>
using namespace std;
const long long MOD=1000000007;
// const long long MOD=998244353;
#define LOCAL
#pragma region Macros
typedef long long ll;
typedef __int128_t i128;
typedef unsigned int uint;
typedef unsigned long long ull;
#define ALL(x) (x).begin(),(x).end()
const int INF=1e9;
const long long IINF=1e18;
const int dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
const char dir[4]={'D','R','U','L'};

template<typename T>
istream &operator>>(istream &is,vector<T> &v){
    for (T &x:v) is >> x;
    return is;
}
template<typename T>
ostream &operator<<(ostream &os,const vector<T> &v){
    for (int i=0;i<v.size();++i){
        os << v[i] << (i+1==v.size()?"": " ");
    }
    return os;
}
template<typename T,typename U>
ostream &operator<<(ostream &os,const pair<T,U> &p){
    os << '(' << p.first << ',' << p.second << ')';
    return os;
}
template<typename T,typename U,typename V>
ostream&operator<<(ostream &os,const tuple<T,U,V> &t){
    os << '(' << get<0>(t) << ',' << get<1>(t) << ',' << get<2>(t) << ')';
    return os;
}
template<typename T,typename U,typename V,typename W>
ostream&operator<<(ostream &os,const tuple<T,U,V,W> &t){
    os << '(' << get<0>(t) << ',' << get<1>(t) << ',' << get<2>(t) << ',' << get<3>(t) << ')';
    return os;
}
template<typename T,typename U>
ostream &operator<<(ostream &os,const map<T,U> &m){
    os << '{';
    for (auto itr=m.begin();itr!=m.end();){
        os << '(' << itr->first << ',' << itr->second << ')';
        if (++itr!=m.end()) os << ',';
    }
    os << '}';
    return os;
}
template<typename T,typename U>
ostream &operator<<(ostream &os,const unordered_map<T,U> &m){
    os << '{';
    for (auto itr=m.begin();itr!=m.end();){
        os << '(' << itr->first << ',' << itr->second << ')';
        if (++itr!=m.end()) os << ',';
    }
    os << '}';
    return os;
}
template<typename T>
ostream &operator<<(ostream &os,const set<T> &s){
    os << '{';
    for (auto itr=s.begin();itr!=s.end();){
        os << *itr;
        if (++itr!=s.end()) os << ',';
    }
    os << '}';
    return os;
}
template<typename T>
ostream &operator<<(ostream &os,const multiset<T> &s){
    os << '{';
    for (auto itr=s.begin();itr!=s.end();){
        os << *itr;
        if (++itr!=s.end()) os << ',';
    }
    os << '}';
    return os;
}
template<typename T>
ostream &operator<<(ostream &os,const unordered_set<T> &s){
    os << '{';
    for (auto itr=s.begin();itr!=s.end();){
        os << *itr;
        if (++itr!=s.end()) os << ',';
    }
    os << '}';
    return os;
}
template<typename T>
ostream &operator<<(ostream &os,const deque<T> &v){
    for (int i=0;i<v.size();++i){
        os << v[i] << (i+1==v.size()?"": " ");
    }
    return os;
}

void debug_out(){cerr << '\n';}
template<class Head,class... Tail>
void debug_out(Head&& head,Tail&&... tail){
    cerr << head;
    if (sizeof...(Tail)>0) cerr << ", ";
    debug_out(move(tail)...);
}
#ifdef LOCAL
#define debug(...) cerr << " ";\
cerr << #__VA_ARGS__ << " :[" << __LINE__ << ":" << __FUNCTION__ << "]" << '\n';\
cerr << " ";\
debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif

template<typename T> T gcd(T x,T y){return y!=0?gcd(y,x%y):x;}
template<typename T> T lcm(T x,T y){return x/gcd(x,y)*y;}

template<class T1,class T2> inline bool chmin(T1 &a,T2 b){
    if (a>b){a=b; return true;} return false;
}
template<class T1,class T2> inline bool chmax(T1 &a,T2 b){
    if (a<b){a=b; return true;} return false;
}
#pragma endregion

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    ll n; cin >> n;

    auto c=[](ll x){return x*(x+1)/2;};
    ll lb=0,ub=2*INF;
    while (ub-lb>1LL){
        ll mid=(ub+lb)>>1LL;
        (c(mid)<=n+1?lb:ub)=mid;
    }
    cout << n-lb+1 << '\n';
}


#include <bits/stdc++.h>
#define fastio()                  \
    ios_base::sync_with_stdio(0); \
    cin.tie(0);                   \
    cout.tie(0)
#define pb push_back
#define show(x) cout << (#x) << " : " << x << endl;
#define ll long long
#define ull unsigned long long
#define ld long double
#define pow power
#define mp make_pair
#define ff first
#define ss second
#define pii pair<ll, ll>
#define sq(x) ((x) * (x))
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define siz(a) int((a).size())
#define For(i,a,b) for(int (i)=(a);(i) < (b); ++(i))
#define endl "\n"
#define pi 3.14159265
const ll mod = 1000 * 1000 * 1000 + 7;
const ll mod1 = 998244353;
const ll INF     = 1ll*1000*1000*1000*1000*1000*1000 + 7;
using namespace std;

ll power(ll x, ll y)
{
   ll res = 1;

    while (y > 0)
    {

        if (y & 1)
            res = (long long)(res*x);

        y = y>>1;

        x = (long long)(x*x);

        //cout<<x<<'\n';
    }
    return res;
}

ll pre[200005];
ll suf[200005];

int main()
{

#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif

fastio();

    ll n,m;
    cin>>n>>m;

    vector <ll> a(n); vector <ll> b(m);
    For(i,0,n)
    cin>>a[i];

    For(i,0,m)
    cin>>b[i];

    sort(all(a));
    sort(all(b));

    for(int i=0;i<n;i+=2) {
        if (i>0)
            pre[i]=a[i+1]-a[i]+pre[i-2];
        else
            pre[i]=a[i+1]-a[i];
    }

    for(int i=n-1;i>=1;i-=2) {
        if (i<n-1)
            suf[i]=a[i]-a[i-1]+suf[i+2];
        else
            suf[i]=a[i]-a[i-1];
    }

    //cout<<pre[2]<<endl;

    ll ans=INF;
    for(int i=0;i<m;i++) {
        ll pos=lower_bound(all(a),b[i])-a.begin();

            if (pos&1) {
                ans=min(ans,suf[pos+1]+(pos-3>=0?pre[pos-3]:0LL)+abs(b[i]-a[pos-1]));
            } else {
                ans=min(ans,suf[pos+2]+(pos-2>=0?pre[pos-2]:0LL)+abs(b[i]-a[pos]));
            }
    }
    cout<<ans;

return 0;
}

// check all product based operations for integer overflow

#include<iostream>
#include<algorithm>
#include<cstdlib>
#include<climits>
using namespace std;
int main(){
  int n,m;
  long long children[200005];
  long long teacher[200005];

  cin>>n>>m;
  for(int i=1;i<=n;i++){
    cin>>children[i];
  }
  for(int i=1;i<=m;i++){
    cin>>teacher[i];
  }

  sort(children+1,children+n+1);

  long long left_sum[100005]={0};
  long long right_sum[100005]={0};
  for(int i=1;i<n;i+=2){
    left_sum[(i+1)/2]=llabs(children[i]-children[i+1])+left_sum[(i+1)/2-1];
    right_sum[(i+1)/2]=llabs(children[i+1]-children[i+2])+right_sum[(i+1)/2-1];
  }

  /*
  cout<<endl<<"left"<<endl;
  for(int i=0;i<=n/2;i++){
    cout<<left_sum[i]<<endl;
  }
  cout<<endl<<"right"<<endl;
  for(int i=0;i<=n/2;i++){
    cout<<right_sum[i]<<endl;
  }
  */

  long long minimum=LLONG_MAX;
  for(int i=1;i<=m;i++){
    long long sum=0;
    int index=upper_bound(children+1,children+n+1,teacher[i])-1-children;
    if(index%2==0){
      sum+=llabs(teacher[i]-children[index+1])+right_sum[n/2]-right_sum[index/2]
	+left_sum[index/2];
    }else{
      sum+=llabs(teacher[i]-children[index])+right_sum[n/2]-right_sum[index/2]
	+left_sum[index/2];
    }
    /*
    cout<<"target="<<teacher[i]<<endl;
    cout<<"sum="<<sum<<endl<<endl;
    */
    minimum=min(minimum,sum);
  }
  cout<<minimum<<endl;
  return(0);
}


#include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp>
//namespace mp = boost::multiprecision;
//#include "atcoder/all"

using namespace std;

const double PI = 3.14159265358979323846;
typedef long long ll;
const double EPS = 1e-9;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef pair<ll, ll> P;
const ll INF = 10e17;
#define cmin(x, y) x = min(x, y)
#define cmax(x, y) x = max(x, y)
#define ret() return 0;

double equal(double a, double b) {
    return fabs(a - b) < DBL_EPSILON;
}

std::istream &operator>>(std::istream &in, set<int> &o) {
    int a;
    in >> a;
    o.insert(a);
    return in;
}

std::istream &operator>>(std::istream &in, queue<int> &o) {
    ll a;
    in >> a;
    o.push(a);
    return in;
}

bool contain(set<int> &s, int a) { return s.find(a) != s.end(); }

typedef priority_queue<ll, vector<ll>, greater<ll> > PQ_ASK;

template<class T, class F>
struct SegmentTree {
    F f;
    T ti;
    vector<T> dat;
    int sz;

    SegmentTree(const F &f, const T &ti) : f(f), ti(ti) {}

    void build(const vector<T> &v) {
        assert(v.size());
        sz = 1;
        while (sz < v.size())sz <<= 1;
        dat.resize(sz << 1, ti);
        for (int i = 0; i < v.size(); i++)dat[sz - 1 + i] = v[i];
        for (int i = sz - 2; i >= 0; i--)dat[i] = f(dat[i * 2 + 1], dat[i * 2 + 2]);
    }

    inline void update(int k, T x) {
        k += sz - 1;
        dat[k] = x;
        while (k) {
            k = (k - 1) / 2;
            dat[k] = f(dat[k * 2 + 1], dat[k * 2 + 2]);
        }
    }

    inline void add(int k, int x) {
        k += sz - 1;
        dat[k] = f(dat[k], x);
        while (k) {
            k = (k - 1) / 2;
            dat[k] = f(dat[k * 2 + 1], dat[k * 2 + 2]);
        }
    }

    inline T query(int a, int b) {
        return query(a, b, 0, 0, sz);
    }

    T query(int a, int b, int k, int l, int r) {
        if (r <= a || b <= l)return ti;
        if (a <= l && r <= b)return dat[k];
        return f(query(a, b, k * 2 + 1, l, (l + r) / 2), query(a, b, k * 2 + 2, (l + r) / 2, r));
    }
};

int main() {
    int n;
    cin >> n;
    vector<int> v(n);
    rep(i, n) cin >> v[i];

    auto f = [](ll i, ll j) { return min(i, j); };
    SegmentTree<ll, decltype(f)> segmentTree(f, INF);
    vector<ll> u(400000);
    rep(i, 400000) u[i] = i;
    segmentTree.build(u);

    rep(i, n) {
        segmentTree.update(v[i], INF);
        cout << segmentTree.query(0, 400000) << endl;
    }

}

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

#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
using P = pair<int, int>;

#define INF 1e18
#define MAX 200005

int main() {
  int n;
  cin >> n;
  set<int> a;
  rep(i,n+1) a.insert(i);
  vector<int> ans;
  rep(i,n) {
    int p;
    cin >> p;
    a.erase(p);
    ans.push_back(*(a.begin()));
  }
  for (auto a : ans) cout << a << endl;

  return 0;
}


#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef vector<ll> vl;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector<char> vc;
typedef queue<ll> ql;
typedef deque<ll> dql;
typedef priority_queue<ll> pql;
typedef set<ll> sl;
typedef pair<ll, ll> pl;
typedef map<ll, ll> ml;
typedef vector<vl> vvl;
typedef vector<pl> vpl;
#define rep(i, n) for(ll i = 0; i < ll(n); i++)
#define rep2(i, k, n) for(ll i = ll(k); i <= ll(n); i++)
#define rep3(i, n, k) for(ll i = ll(n); i >= ll(k); i--)
#define all(v) (v).begin(), (v).end()
ll mod(ll a, ll b) {return (a % b + b) % b;}
ll quo(ll a, ll b) {return (a - mod(a, b)) / b;}
template <typename T, typename U> bool chmin(T &a, const U b) {if(a > b) {a = b; return 1;} return 0;}
template <typename T, typename U> bool chmax(T &a, const U b) {if(a < b) {a = b; return 1;} return 0;}
const ll INF = 1LL << 60;
const ll MOD = 1e9 + 7;
//const ll MOD = 998244353;
const ll MAX = 2e5;
const ld eps = 1e-9;
const char newl = '\n';

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);

  using P = pair<ll, string>;

  ll n, t;
  string s;
  cin >> n;
  priority_queue<P, vector<P>, greater<P>> pique;
  rep(_, n) {
    cin >> s >> t;
    pique.push(make_pair(t, s));
    if(pique.size() > 2) pique.pop();
  }
  cout << pique.top().second << newl;
  return 0;
}

#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;

int main(){
    cin.tie(0);
    ios::sync_with_stdio(0);

    int T; cin >> T;
    while(T--){
        int N; cin >> N;
        set<int> se;
        rep(i,N){
            int a; cin >> a;
            if(se.find(a) != se.end()){
                se.erase(a);
            }else{
                se.insert(a);
            }
        }

        cout << (N & 1 || (N % 2 == 0 && se.size() == 0) ? "Second" : "First") << '\n';
    }
}


#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <iomanip>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <unordered_map>
#include <bitset>
#include <chrono>
#include <random>
#define rep(i,n) for(int i=0;i<n;i++)
#define repn(i,n) for(int i=1;i<=n;i++)
#define repr(e,x) for(auto& e:x)
using namespace std;
typedef long long ll;
typedef long double ld;
// typedef pair<int,int> P;
// typedef pair<int,P> IP;
// typedef pair<P,P> PP;
double const PI=3.141592653589793;
int const INF=1001001001;
ll const LINF=1001001001001001001;
ll const MOD=1000000007;

int N;
double x[2], y[2];

int main(){
    cin>>N;
    rep(i,2) cin>>x[i]>>y[i];

    double cx,cy;
    cx=(double)(x[0]+x[1])/2;
    cy=(double)(y[0]+y[1])/2;

    x[0]-=cx;
    y[0]-=cy;

    double a=2*PI/N;
    double ansx,ansy;
    ansx=x[0]*cos(a)-y[0]*sin(a);
    ansy=x[0]*sin(a)+y[0]*cos(a);

    ansx+=cx;
    ansy+=cy;

    cout<<setprecision(16)<<ansx<<' '<<ansy<<endl;

    return 0;
}


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

// #include <atcoder/all>
// using namespace atcoder;

#define rep(i,n) for (int i = 0; i < (n); ++i)
using ll = long long;

bool ok(long long N, std::string &S, std::vector<long long> &A, int m) {
    rep (i, m) {
        vector<ll> tmp(N+1);
        rep(j, N+1) {
            tmp[j] = A[j] / m;
            if (i < A[j] % m) {
                tmp[j]++;
            }
        }
        rep(j, N) {
            if (
                (S[j] == '>' && !(tmp[j] > tmp[j+1])) ||
                (S[j] == '<' && !(tmp[j] < tmp[j+1]))
            ) {
                return 0;
            }
        }
    }
    return 1;
}

void solve(long long N, std::string S, std::vector<long long> A){
    int l = 1, r = 10000+1;
    while (r - l > 1) {
        int m = (l + r) / 2;
        if (ok(N, S, A, m)) {
            l = m;
        } else {
            r = m;
        }
    }
    cout << l << endl;
    rep(i, l) {
        rep(j, N+1) {
            int tmp = A[j] / l;
            if (i < A[j] % l) {
                tmp++;
            }
            cout << tmp << ((j == N) ? "\n" : " ");
        }
    }

    // vector<ll> B(N+1);
    // ll mn = 0;
    // vector<int> gts(N+1);
    // vector<int> lts(N+1);
    // rep(i, N) {
    //     if (S[i] == '<') {
    //         lts[i+1] = lts[i] + 1;
    //     } else {
    //         lts[i+1] = 0;
    //     }
    // }
    // for (int i = N-1; i >= 0; i--) {
    //     if (S[i] == '>') {
    //         gts[i] = gts[i+1] + 1;
    //     } else {
    //         gts[i] = 0;
    //     }
    // }
    // rep(i, N+1) {
    //     B[i] = max(gts[i], lts[i]);
    // }
    // vector<vector<ll>> ans;
    // while (1) {
    //     vector<ll> rest = A;
    //     int ok = 1;
    //     rep(i, N+1) {
    //         if (A[i] >= B[i]) {
    //             A[i] -= B[i];
    //         } else {
    //             ok = 0;
    //             break;
    //         }
    //     }
    //     if (ok) {
    //         rep(i, N) {
    //             if (
    //                 (S[i] == '>' && !(A[i] > A[i+1])) ||
    //                 (S[i] == '<' && !(A[i] < A[i+1]))
    //             ) {
    //                 ok = 0;
    //                 break;
    //             }
    //         }
    //     }
    //     if (!ok) {
    //         ans.push_back(rest);
    //         break;
    //     }
    //     ans.push_back(B);
    // }
    // cout << ans.size() << endl;
    // rep(i, ans.size()) {
    //     rep(j, ans[i].size()) {
    //         cout << ans[i][j] << ((j == ans[i].size() - 1) ? "\n" : " ");
    //     }
    // }

}

// Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools
int main(){
    long long N;
    scanf("%lld",&N);
    std::string S;
    std::cin >> S;
    std::vector<long long> A(N-0+1);
    for(int i = 0 ; i < N-0+1 ; i++){
        scanf("%lld",&A[i]);
    }
    solve(N, S, std::move(A));
    return 0;
}

#include <bits/stdc++.h>
#define ALL(A) (A).begin(), (A).end()
#define ll long long
#define rep(i, n) for (int i = 0; i < (n); i++)

using namespace std;
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; }

int dx[] = { 0, 1, -1, 0, 1, -1, 1, -1 };  // i<4:4way i<8:8way
int dy[] = { 1, 0, 0, -1, 1, -1, -1, 1 };

const ll mod = 1e9 + 7;
const ll INF = -1 * ((1LL << 63) + 1);
const int inf = -1 * ((1 << 31) + 1);

int main(void){
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(20);
    int n;
    cin >> n;
    string s;
    cin >> s;
    vector<int> a(n+1);
    rep(i,n+1)cin >> a[i];
    int k = 1e9+7;
    for(int i=0;i<n;i++){
        chmin(k,abs(a[i] - a[i+1]));
    }
    cout << k << endl;
    for(int j=0;j<k;j++){
        for(int i=0;i<=n;i++){
            if(j < a[i] % k){
                cout << (a[i] + k - 1)/k << " ";
            }else{
                cout << a[i]/k << " ";
            }
        }
        cout << endl;
    }
}


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

typedef pair<int,int>  pint;
typedef pair<ll,ll>    pll;
typedef vector<int>    vint;
typedef vector<ll>     vll;
typedef vector<string> vstr;
typedef vector<pint>   vpint;
typedef vector<pll>    vpll;

#define vint2(v,n,m,init) vector<vector<int>> v(n, vector<int>(m, init))
#define vll2(v,n,m,init)  vector<vector<ll>>  v(n, vector<ll>(m, init))

#define rep(i,n)         for(ll i=(ll)0; i<(ll)n; i++)
#define REP(i,m,n)       for(ll i=(ll)m; i<(ll)n; i++)
#define arr(var, n)      vint var(n); rep(i,n){cin >> var[i];}
#define arrll(var, n)    vll var(n); rep(i,n){cin >> var[i];}
#define arrst(var, n)    vstr var(n); rep(i,n){cin >> var[i];}
#define ALL(var)         (var).begin(), (var).end()
#define sortall(var)     sort(ALL(var))
#define uniqueall(v)     v.erase(unique(v.begin(), v.end()), v.end());

#define prt(var)         cout << (var) << "\n"
#define prt2(v1, v2)     cout << (v1) << " " << (v2) << "\n"
#define prt3(v1, v2, v3) cout << (v1) << " " << (v2) << " " << (v3) << "\n"
#define prtd(n, var)     cout << fixed << setprecision(n) << (var) << "\n"
#define prtfill(n, var)  cout << setw(n) << setfill('0') << (var);
#define prtall(v)        rep(i,v.size()){cout<<v[i]<<(i!=v.size()-1?" ":"\n");}
template <typename T>
bool chmax(T &a, const T& b){if(a<b){a=b; return true;} return false;}
template <typename T>
bool chmin(T &a, const T& b){if(a>b){a=b; return true;} return false;}
ll gcd(ll a, ll b){ return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b){ return a/gcd(a,b)*b;}
//----------------------------------------------------------------------------
#define prt4(v1,v2,v3,v4) cout<<(v1)<<" "<<(v2)<<" "<<(v3)<<" "<<(v4)<<"\n";

int main(void) {
    arrll(a,4);

    ll k = a[0] + a[1] + a[2] + a[3];
    bool ok = false;
    rep(i,4){
        REP(j,i+1,4){
            if(a[i]+a[j]==k-a[i]-a[j]) ok = true;
        }
    }

    rep(i,4){
        if(a[i]==k-a[i]) ok = true;
    }

    prt(ok ? "Yes" : "No");
}

/// kazuki08
/*
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
*/
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define int long long
typedef long long ll;
typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>ordered_set;
typedef long double ld;
typedef vector<int> vi;
typedef pair<int,int> pi;
typedef vector<pi> vpi;
#define ar array
//#define inf 1000000000
#define mod 1000000007
#define dmp(x) cerr<<"line "<<__LINE__<<" "<<#x<<":"<<x<<endl
#define fs first
#define sc second
#define pb push_back
#define all(c) (c).begin(),(c).end()
#define mt make_tuple
#define IOS ios::sync_with_stdio(0);cin.tie(0);cout.tie(0)
template<class S,class T> ostream& operator<<(ostream& o,const pair<S,T> &p){
    return o<<"("<<p.fs<<","<<p.sc<<")";
}
template<class T> ostream& operator<<(ostream& o,const vector<T> &vc){
    o<<"{";
    for(const T& v:vc) o<<v<<",";
    o<<"}";
    return o;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

string s,t="atcoder";
int n;

int match(int x){
  if(x==0){
    int res = mod;
    for(int j=0;j<s.size();j++){
      if(s[j]>'a')return j;
    }
    return res;
  }
  int done[n+1]={0};
  int res = 0;
  for(int i=0;i<x;i++){
    int cnt = 0;
    bool f = false;
    for(int j=0;j<s.size();j++){
      if(done[j])continue;
      if(s[j]==t[i]){
        done[j]=1;
        res+=cnt;
        f = true;
        break;
      }
      cnt++;
    }
    if(!f)return mod;
  }
  if(x<t.size()){
    bool f = false;
    int cnt = 0;
    for(int j=0;j<s.size();j++){
      if(done[j])continue;
      if(t[x]<s[j]){
        res+=cnt;
        f = true;
        break;
      }
      cnt++;
    }
    if(!f)return mod;
  }
  else {
    if(s.size()>x)return res;
    else return mod;
  }
  return res;
}

signed main(){
IOS;
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);

  int T;
  cin >> T;
  while(T--){
    cin >> s;
    n = s.size();
    int ans = mod;
    for(int i=0;i<=t.size();i++){
      ans = min(ans,match(i));
      // cerr << i << " "  << ans << endl;
    }
    if(ans>=mod){
      ans = -1;
    }
    cout << ans << endl;
  }

return 0;
}
///....


// D - Game in Momotetsu World
#include "bits/stdc++.h"
using namespace std;

#ifndef DEBUG

#define fundri 108
#define debug(...) 1729
#define endl '\n'

#endif

#define int int64_t

typedef pair<int, int> pii;
typedef vector<int> vi;

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline int rnd(int l = 0, int r = INT_MAX) {return uniform_int_distribution<int>(l, r)(rng);}

bool in_range(int x, int l, int r) {return l <= x && x <= r;}
template<typename H, typename ...T>void inp(H &head) {cin >> head;}
template<typename H, typename ...T>void inp(H &head, T &...tail) {cin >> head;inp(tail...);}
template<typename T>inline istream &operator >>(istream &in, vector<T> &a) {for(T &x : a)in >> x; return in;}
template<typename T, typename U>inline istream &operator >>(istream &in, pair<T, U> &a) {in >> a.first >> a.second; return in;}

// Multi-Dimension Vector
// Usage: vec<n, data-type> dp(dimention-1, dimention-2, ..., dimention-n, default = data-type())
template<int D, typename T> struct vec : public vector<vec<D - 1, T>> {
    static_assert(D >= 1, "Vector dimensions must be greater than zero !!");
    template<typename... Args>
    vec(int n = 0, Args... args) : vector<vec<D - 1, T>>(n, vec<D - 1, T>(args...)){}
};

template<typename T> struct vec<1, T> : public vector<T> {vec(int n = 0, T val = T()) : vector<T>(n, val){}};

const int inf = 1e15;
const bool testcases = false;

const bool ready = []() -> bool {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

#ifdef DHRUV_GHEEWALA
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
    freopen("debug.txt", "w", stderr);
#endif

    return true;
}();

void solve(int tc);
int32_t main(int32_t argc, char **argv) {
    int TC = 1;
    if(testcases) cin >> TC;

    // Pre-Processing goes here...
    for(int tc = 1; tc <= TC; ++tc) {
        solve(tc);
        fundri;
    }
    exit(0);
}

int n, m;
vec<2, int> dp;
vec<2, char> grid;

int get(int i, int j) {
    if(!in_range(i, 0, n - 1) || !in_range(j, 0, m - 1)) {
        return -inf;
    }

    return grid[i][j] == '+' ? 1 : -1;
}

int rec(int i, int j) {
    if(i == n - 1 && j == m - 1)
        return 0;

    int &res = dp[i][j];
    if(res != -inf) return res;

    if(i + 1 >= n) {
        return res = get(i, j + 1) - rec(i, j + 1);
    }

    if(j + 1 >= m) {
        return res = get(i + 1, j) - rec(i + 1, j);
    }

    int down = get(i + 1, j) - rec(i + 1, j);
    int right = get(i, j + 1) - rec(i, j + 1);
    return res = max(down, right);
}

void solve(int tc) {
    cin >> n >> m;

    grid = vec<2, char>(n, m);
    cin >> grid;

    if(n == 1 && m == 1) {
        cout << "Draw" << endl;
        return;
    }

    dp = vec<2, int>(n, m, -inf);
    int diff = rec(0, 0);
    debug(dp);

    if(diff == 0) {
        cout << "Draw" << endl;
    } else if(diff > 0) {
        cout << "Takahashi" << endl;
    } else {
        cout << "Aoki" << endl;
    }
}

#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 ordered_set tree < pairs ,  null_type , greater<pairs>,  rb_tree_tag ,  tree_order_statistics_node_update >
#define ll long long
#define lld long double
#define vc vector<ll>
const ll MOD=(1e9 +7);
typedef pair<ll,ll>pairs;
ll power(ll a, ll b){ll res=1;a=a%MOD;while(b>0){if(b&1){res=(res*a)%MOD;b--;}a=(a*a)%MOD;b>>=1;}
    return res;}

int main() {
	// your code goes here
	std::ios::sync_with_stdio(false);
	cin.tie(NULL);cout.tie(NULL);
	//Read the qstn. properlyyyyy!!!
	ll t,n,i,j,k,c,f,h,w;
	cin>>h>>w;
	vector<vc>a(h+1,vc(w+1)),dp(h+1,vc(w+1)),down(h+1,vc(w+1)),diag(h+1,vc(w+1)),rt(h+1,vc(w+1));
	char ch;
	for(i=1;i<=h;i++)
	{

	    for(j=1;j<=w;j++){
	        cin>>ch;
	        if(ch=='.')
	        {
	            a[i][j]=1;
	        }
	        else a[i][j]=0;
	    }
	}
    dp[1][1]=1;
	for(i=1;i<=h;i++)
	{
	    for(j=1;j<=w;j++)
	    {

	        if(a[i][j])
	        {
	            dp[i][j]+=(rt[i][j-1]+diag[i-1][j-1]+down[i-1][j])%MOD;
	            diag[i][j]=(dp[i][j]+diag[i-1][j-1])%MOD;
	            down[i][j]=(dp[i][j]+down[i-1][j])%MOD;
	            rt[i][j]=(dp[i][j]+rt[i][j-1])%MOD;
	        }
	    }
	}
	cout<<dp[h][w];
	return 0;
}


#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;
/*---------------------DEBUGGING--------------------------------------------*/
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}

template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
/*-------------------------------------------------------------------------------------*/
#define pb push_back
#define ll long long
#define pii pair<int,int>
#define pcc pair<char,char>
#define F first
#define S second
#define int long long
#define pi 3.141592653589793238462643383279502
#define M 1000000007 //998244353
#define rep(i,a,n) for(int i=a;i<n;i++)
#define INF 1e18
#define N 100005
#define vi vector<int>
#define all(v) v.begin(),v.end()
#define endl "\n"
//typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> ordered_set;
void solve()
{   int n;
    cin>>n;
    vi a(n);
    rep(i,0,n)cin>>a[i];
    sort(all(a));
    bool f = true;
    for(int i=0;i<n;i++)
    {
        if(a[i] != (i+1))f=false;
    }
    if(f)cout<<"Yes"<<endl;
    else cout<<"No"<<endl;
}
signed main()
{
   ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
   int tests;
   tests=1;
   //cin>>tests;
   for(int i=0;i<tests;i++)
   {
       solve();
   }
}

#include<bits/stdc++.h>
using namespace std;
int n;
int chk[100001];
int main(){
    scanf("%d" , &n);
    for(int i = 0; i<n;i++){
        int tmp;
        scanf("%d" , &tmp);
        if(chk[tmp]){
            printf("No");
            return 0;
        }
        chk[tmp]=1;
    }
    printf("Yes");
}


#include <iostream>
#include <iomanip>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#include <numeric>
#include <array>
#include <complex>

using namespace std;

#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#define int long long
#define rep(i, a, b) for (int i = (a); i < (b); ++i)
#define trav(i, a) for (auto &i: (a))
#define sz(x) (int)(x).size()
#define all(v) v.begin(), v.end()
#define fr(i, a, b) for (int i = (a); i <= (b); ++i)

typedef long long ll;
typedef long double ld;

void run_case();

int32_t main () {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(3);
    #ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    #endif
    int t = 1;
    // cin >> t;
    while (t--) {
        run_case();
    }
    return 0;
}
const int N = 25;
vector<int> adj[N];
vector<int> nadj[N];
int n, m;
vector<int> vis;

bool dfs (int v, int c = 1) {
    vis[v] = c;
    bool ok = true;
    for (auto &i: nadj[v]) {
        if (vis[i] == 0) ok &= dfs(i, 3 ^ c);
        else if (vis[i] == vis[v]) return false;
    }
    return ok;
}

void run_case() {
    cin >> n >> m;
    vis.resize(n);
    for (int i = 0; i < m; ++i) {
        int a, b; cin >> a >> b; --a, --b;
        adj[a].push_back(b);
        adj[b].push_back(a);
    }
    int ans = 0;
    for (int mask = 0; mask < (1 << n); ++mask) {
        fill(all(vis), 0);
        for (int b = 0; b < n; ++b) {
            nadj[b].clear();
            if ((1 << b) & mask) {
                for (auto &j: adj[b]) {
                    if ((1 << j) & mask)
                        nadj[b].push_back(j);
                }
            }
        }
        int cnt = 0;
        bool ok = true;
        for (int b = 0; b < n; ++b) {
            if (vis[b]) continue;
            if ((1 << b) & mask) {
                if (dfs(b)) ++cnt;
                else {
                    ok = false; break;
                }
            }
        }
        if (!ok) continue;
        for (int b = 0; b < n; ++b) {
            if (!vis[b]) {
                for (auto j: adj[b]) {
                    if (!vis[j])
                        ok = false;
                }
            }
        }
        if (!ok) continue;
        int pw = 1;
        for (int j = 0; j < cnt; ++j)
            pw *= 2;
        ans += pw;
    }
    cout << ans;
}

#include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(false)
#define rep(i, n) for(ll i=0; i<(ll)n; i++)
#define ALL(obj) begin(obj), end(obj)
typedef long long ll;
vector<vector<int> > G(22);
vector<int> color(22, -1), ts;
vector<bool> vis(22, 0);
int n, m, a, b;

void dfs(int now){
	ts.push_back(now);
	vis[now]=1;

	for(int i: G[now]){
		if(vis[i])
		    continue;

		dfs(i);
	}
}

ll DFS(int i){
	if(i==ts.size())
	    return 1;

	ll res=0;
    rep(j, 3){
    	bool f=1;
    	for(int x:G[ts[i]]){
    		if(color[x]==j){
    			f=0;
    			break;
			}
		}

		if(!f)
		   continue;

		color[ts[i]]=j;
		res+=DFS(i+1);
		color[ts[i]]=-1;
	}

	return res;
}

int main()
{
    IOS;
	cin>>n>>m;
	rep(i, m){
		cin>>a>>b;
		a--;
		b--;

		G[a].push_back(b);
		G[b].push_back(a);
	}

	ll ans=1;
	rep(i, n){
		if(vis[i])
		    continue;

		dfs(i);
		fill(ALL(color), -1);
		ans*=DFS(0);
		ts.clear();
	}

	cout<<ans<<endl;

	return 0;
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, srt, end) for (long long i = (srt); i < (long long)(end); i++)
constexpr ll mod = 1000000007;

void solve() {
    ll n;
    cin >> n;
    vector<ll> a(n);
    rep(i, 0, n) cin >> a[i];
    if(n % 2) {
        cout << "Second\n";
        return;
    }
    map<ll,ll> mp;
    rep(i, 0, n) mp[a[i]]++;
    bool f = true;
    for(auto e: mp) {
        if(e.second % 2) f = false;
    }
    if(f) cout << "Second\n";
    else cout << "First\n";
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    ll t;
    cin >> t;
    while(t--) solve();
    return 0;
}

#include <iostream>
#include <stdio.h>
#include <vector>
#include <algorithm>
#include <string>
#include <iomanip>
#define _USE_MATH_DEFINES
#include <math.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
using namespace std;

int main() {
	int n;
	cin >> n;
	int i;
	int num;
	int count = 0;
	int check = 0;
	for (i = 1; i <= n; i++) {
		num = i;
		while (num/10>0||num%10!=0) {
			if (num%10==7) {
				check = 1;
				break;
			}
			num = num / 10;
		}
		num = i;
		while (num / 8 > 0 || num % 8 != 0) {
			if (num % 8 == 7) {
				check = 1;
				break;
			}
			num = num / 8;
		}
		if (check == 0) {
			count++;
		}
		check = 0;
	}
	cout << count;
	return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <queue>
#include <map>
#include <unordered_map>
using namespace std;

#define debug(x) cout << #x << '=' << x << '\n'
#define rep(i, b, e) for (int i = b; i <= e; i++)

const int N = 212345;

int n, a[N], b[N], c[N];
map<int, queue<int>> mp;

namespace Bit {
    int c[N], size;
    inline int lowbit(int x) {
        return x & (-x);
    }
    inline void add(int loc, int val) {
        for (; loc <= size; loc += lowbit(loc)) {
            c[loc] += val;
        }
    }
    inline int query(int loc) {
        int ret = 0;
        for (; loc; loc -= lowbit(loc)) {
            ret += c[loc];
        }
        return ret;
    }
}

int main(){
    cin >> n;
    rep (i, 1, n) {
        scanf("%d", a + i);
        a[i] += i;
        mp[a[i]].push(i);
    }
    rep (i, 1, n) {
        scanf("%d", b + i);
        b[i] += i;
        if (mp[b[i]].size() == 0) {
            puts("-1");
            return 0;
        }
        c[i] = mp[b[i]].front();
        mp[b[i]].pop();
    }
    //rep (i, 1, n) {
    //    debug(c[i]);
    //}
    Bit::size = n;
    long long ans = 0;
    for (int i = n; i > 0; i--) {
        ans += Bit::query(c[i] - 1);
        Bit::add(c[i], 1);
    }
    cout << ans;
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
int a[200010],b[200010];
queue<int>pos[200010];
map<int,int>id;
int tot,n;
int T[200010<<2];
int q(int rt,int l,int r,int pos){
	if(l==r)return T[rt];
	int mid=l+r>>1;
	if(pos<=mid)return T[rt]+q(rt<<1,l,mid,pos);
	else return T[rt]+q(rt<<1|1,mid+1,r,pos);
}
void ad(int rt,int l,int r,int L,int R){
	if(l==L&&r==R){
		T[rt]++;return;
	}
	int mid=l+r>>1;
	if(R<=mid)ad(rt<<1,l,mid,L,R);
	else if(L>mid)ad(rt<<1|1,mid+1,r,L,R);
	else ad(rt<<1,l,mid,L,mid),ad(rt<<1|1,mid+1,r,mid+1,R);
}
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d",&a[i]);
		a[i]+=i;
		int t=id[a[i]];
		if(!t)id[a[i]]=t=++tot;
		pos[t].push(i);
	}
	int flag=1;
	for(int i=1;i<=n;i++){
		scanf("%d",&b[i]);
		b[i]+=i;
		int t=id[b[i]];
		if(t&&!pos[t].empty()){
			b[i]=pos[t].front();
			pos[t].pop();
		}
		else flag=0;
	}
	if(!flag)printf("-1");
	else{
		long long ans=0;
		for(int i=1;i<=n;i++)ans+=q(1,1,n,b[i]),ad(1,1,n,1,b[i]);
		printf("%lld",ans);
	}
}


// Template
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <iomanip>
#include <tuple>
#include <utility>
#include <queue>
#include <set>
#include <map>
#include <array>
#include <cassert>
#include <cmath>
#define rep_override(x, y, z, name, ...) name
#define rep2(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep3(i, l, r) for (int i = (int)(l); i < (int)(r); ++i)
#define rep(...) rep_override(__VA_ARGS__, rep3, rep2)(__VA_ARGS__)
#define all(x) (x).begin(), (x).end()
using namespace std;
using ll = long long;
constexpr int inf = 1001001001;
constexpr ll infll = 3003003003003003003LL;
template <typename T>
inline bool chmin(T &x, const T &y) {
    if (x > y) {
        x = y;
        return true;
    }
    return false;
}
template <typename T>
inline bool chmax(T &x, const T &y) {
    if (x < y) {
        x = y;
        return true;
    }
    return false;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
    for (T &element : vec) is >> element;
    return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
    for (int i = 0, vec_len = (int)vec.size(); i < vec_len; ++i) {
        os << vec[i] << (i + 1 == vec_len ? "" : " ");
    }
    return os;
}
struct IOSET {
    IOSET() {
        cin.tie(nullptr);
        ios::sync_with_stdio(false);
        cout << fixed << setprecision(10);
    }
} ioset;

// Main
int main() {
    int n;
    cin >> n;
    vector<ll> a(n);
    cin >> a;

    ll mx = 0, sum = 0, sum2 = 0;
    rep(i, n) {
        chmax(mx, a[i]);
        sum += a[i];
        cout << sum + mx * (i + 1) + sum2 << '\n';
        sum2 += sum;
    }
}

#pragma GCC optimize ("Ofast")
#include<bits/stdc++.h>
using namespace std;
void*wmem;
char memarr[96000000];
template<class T> inline void walloc1d(T **arr, int x, void **mem = &wmem){
  static int skip[16] = {0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
  (*mem) = (void*)( ((char*)(*mem)) + skip[((unsigned long long)(*mem)) & 15] );
  (*arr)=(T*)(*mem);
  (*mem)=((*arr)+x);
}
template<class T1> void sortA_L(int N, T1 a[], void *mem = wmem){
  sort(a, a+N);
}
inline int my_getchar_unlocked(){
  static char buf[1048576];
  static int s = 1048576;
  static int e = 1048576;
  if(s == e && e == 1048576){
    e = fread_unlocked(buf, 1, 1048576, stdin);
    s = 0;
  }
  if(s == e){
    return EOF;
  }
  return buf[s++];
}
inline void rd(int &x){
  int k;
  int m=0;
  x=0;
  for(;;){
    k = my_getchar_unlocked();
    if(k=='-'){
      m=1;
      break;
    }
    if('0'<=k&&k<='9'){
      x=k-'0';
      break;
    }
  }
  for(;;){
    k = my_getchar_unlocked();
    if(k<'0'||k>'9'){
      break;
    }
    x=x*10+k-'0';
  }
  if(m){
    x=-x;
  }
}
inline int rd_int(void){
  int x;
  rd(x);
  return x;
}
struct MY_WRITER{
  char buf[1048576];
  int s;
  int e;
  MY_WRITER(){
    s = 0;
    e = 1048576;
  }
  ~MY_WRITER(){
    if(s){
      fwrite_unlocked(buf, 1, s, stdout);
    }
  }
}
;
MY_WRITER MY_WRITER_VAR;
void my_putchar_unlocked(int a){
  if(MY_WRITER_VAR.s == MY_WRITER_VAR.e){
    fwrite_unlocked(MY_WRITER_VAR.buf, 1, MY_WRITER_VAR.s, stdout);
    MY_WRITER_VAR.s = 0;
  }
  MY_WRITER_VAR.buf[MY_WRITER_VAR.s++] = a;
}
inline void wt_L(char a){
  my_putchar_unlocked(a);
}
inline void wt_L(const char c[]){
  int i=0;
  for(i=0;c[i]!='\0';i++){
    my_putchar_unlocked(c[i]);
  }
}
int N;
int A[100000];
int main(){
  int Lj4PdHRW;
  wmem = memarr;
  int KL2GvlyY = rd_int();
  for(Lj4PdHRW=(0);Lj4PdHRW<(KL2GvlyY);Lj4PdHRW++){
    rd(N);
    {
      int cTE1_r3A;
      for(cTE1_r3A=(0);cTE1_r3A<(N);cTE1_r3A++){
        rd(A[cTE1_r3A]);
      }
    }
    sortA_L(N,A);
    if(N%2==1){
      wt_L("Second");
      wt_L('\n');
    }
    else{
      int i;
      int fg = 1;
      for(i=(0);i<(N);i+=(2)){
        if(A[i]!=A[i+1]){
          fg = 0;
        }
      }
      if(fg){
        wt_L("Second");
        wt_L('\n');
      }
      else{
        wt_L("First");
        wt_L('\n');
      }
    }
  }
  return 0;
}
// cLay varsion 20201003-1

// --- original code ---
// int N, A[1d5];
// {
//   REP(rd_int()){
//     rd(N,A(N));
//     sortA(N,A);
//     if(N%2==1){
//       wt("Second");
//     } else {
//       int fg = 1;
//       rep(i,0,N,2) if(A[i]!=A[i+1]) fg = 0;
//       wt(if[fg, "Second", "First"]);
//     }
//   }
// }


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

const int N = 2e5 + 10;

int n, d[N], ans[N], last, fa[N], rt, st, mxd[N];

vector <int> e[N];

void dfs1_(int u) {
	mxd[u] = d[u] = d[fa[u]] + 1;

	for (int v, i = 0; i < (int) e[u].size(); i++) {
		v = e[u][i];

		if (v == fa[u]) continue;

		fa[v] = u, dfs1_(v), mxd[u] = max(mxd[u], mxd[v]);
	}

	if (d[u] > d[rt]) rt = u;
}

bool cmp_(int u, int v) {
	return mxd[u] < mxd[v];
}

void dfs2_(int u) {
	last = u;
	sort(e[u].begin(), e[u].end(), cmp_);

	for (int v, i = 0; i < (int) e[u].size(); i++) {
		v = e[u][i];

		if (v == fa[u]) continue;

		ans[v] = ans[last] + d[last] + d[v] - d[u]*2;
		dfs2_(v);
	}
}

int main() {
	scanf("%d", &n);

	for (int u, v, i = 1; i < n; i++)
		scanf("%d%d", &u, &v), e[u].push_back(v), e[v].push_back(u);

	dfs1_(1), st = rt;
	fa[st] = 0, dfs1_(st);

	ans[st] = 1, dfs2_(st);

	for (int i = 1; i <= n; i++)
		printf("%d ", ans[i]);
}

/**
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡀⠀⠀⠀⠀⢀⡀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⡖⠁⠀⠀⠀⠀⠀⠀⠈⢲⣄
⠀⠀⠀⠀⠀⠀⠀⠀⣼⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⣧
⠀⠀⠀⠀⠀⠀⠀⣸⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⣿⣇
⠀⠀⠀⠀⠀⠀⠀⣿⣿⡇⠀⢀⣀⣤⣤⣤⣤⣀⡀⠀⢸⣿⣿
⠀⠀⠀⠀⠀⠀⠀⢻⣿⣿⣔⢿⡿⠟⠛⠛⠻⢿⡿⣢⣿⣿⡟
⠀⠀⠀⠀⣀⣤⣶⣾⣿⣿⣿⣷⣤⣀⡀⢀⣀⣤⣾⣿⣿⣿⣷⣶⣤⡀
⠀⠀⢠⣾⣿⡿⠿⠿⠿⣿⣿⣿⣿⡿⠏⠻⢿⣿⣿⣿⣿⠿⠿⠿⢿⣿⣷⡀
⠀⢠⡿⠋⠁⠀⠀⢸⣿⡇⠉⠻⣿⠇⠀⠀⠸⣿⡿⠋⢰⣿⡇⠀⠀⠈⠙⢿⡄
⠀⡿⠁⠀⠀⠀⠀⠘⣿⣷⡀⠀⠰⣿⣶⣶⣿⡎⠀⢀⣾⣿⠇⠀⠀⠀⠀⠈⢿
⠀⡇⠀⠀⠀⠀⠀⠀⠹⣿⣷⣄⠀⣿⣿⣿⣿⠀⣠⣾⣿⠏⠀⠀⠀⠀⠀⠀⢸
⠀⠁⠀⠀⠀⠀⠀⠀⠀⠈⠻⢿⢇⣿⣿⣿⣿⡸⣿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠈
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣼⣿⣿⣿⣿⣧⡀
⠀⠀⠀⠐⢤⣀⣀⢀⣀⣠⣴⣿⣿⠿⠋⠙⠿⣿⣿⣦⣄⣀⠀⠀⣀⡠⠂
⠀⠀⠀⠀⠀⠈⠉⠛⠛⠛⠛⠉⠀⠀⠀⠀⠀⠈⠉⠛⠛⠛⠛⠋⠁
**/
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define nl cout<<"\n";
#define ll long long int
#define ld double
#define pb push_back
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define F(i,a,b) for(i=a;i<b;i++)
//#include <ext/pb_ds/assoc_container.hpp> // policy based data structure header files
//#include <ext/pb_ds/tree_policy.hpp> // policy based data structure header files
#define IOS ios::sync_with_stdio(false);cin.tie(0);
using namespace std;
//using namespace __gnu_pbds; // for pbds
//#define ordered_set tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update> // have functions like order_of_key, find_by_order
const double PI = 3.14159265358979323846264338327950288419716939937510582097494459230781641;
const ll M=1e18;
const ll MAXN=200200;
ll i,j,mask;
vector<vector<ll> > v(MAXN);
vector<ll> dist(MAXN), par(MAXN), ans(MAXN), vis(MAXN);
ll val=1;
void dfs0(ll p)
{
    for(auto x:v[p]) {
        if(x!=par[p]) {
            par[x]=p;
            dist[x]=dist[p]+1;
            dfs0(x);
        }
    }
}
void dfs(ll p, ll parent, ll f)
{
    if(ans[p]==0) {
        ans[p]=val;
        val++;
    }
    if(f) {
        for(auto x:v[p]) {
            if(x!=parent) {
                dfs(x, p,1);
            }
        }
        val++;
        return ;
    }
    ll node=0;
    for(auto x:v[p]) {
        if(x!=parent) {
            if(vis[x]) {
                node=x;
            } else {
                dfs(x, p, 1);
                //val++;
            }
        }
    }
    if(node!=0) {
        dfs(node, p, 0);
    }
}
void solve()
{
    ll n;
    cin>>n;
    F(i,0,n-1) {
        ll x,y;
        cin>>x>>y;
        v[x].pb(y);
        v[y].pb(x);
    }
    dfs0(1);
    ll node=0, maxx=0;
    F(i,1,n+1) {
        if(dist[i]>maxx) {
            maxx=dist[i];
            node=i;
        }
    }
    //cout<<node;nl
    dist[node]=0;
    par[node]=0;
    dfs0(node);
    maxx=0;
    F(i,1,n+1) {
        if(dist[i]>maxx) {
            maxx=dist[i];
            node=i;
        }
    }
    //cout<<node;nl
    while(par[node]!=0) {
        vis[node]=1;
        node=par[node];
    }
    //cout<<node;nl
    vis[node]=1;
    dfs(node, -1, 0);
    F(i, 1, n+1) {
        cout<<ans[i]<<" ";
    }
}
int main()
{
    IOS
    /*#ifndef ONLINE_JUDGE
       freopen("input.txt","r",stdin);
       freopen("output.txt","w",stdout);
    #endif // ONLINE_JUDGE*/
    ll t,test=1;
    //cin>>test;
    F(t,1,test+1) {
        //cout<<"Case #"<<t<<": ";
        solve();
        nl
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vl = vector<ll>;
template<class T> using vc = vector<T>;
template<class T> using vvc = vector<vector<T>>;

#define eb emplace_back
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define repr(i, n) for (ll i = (n)-1; i >= 0; i--)
#define repe(i, l, r) for (ll i = (l); i < (r); i++)
#define reper(i, l, r) for (ll i = (r)-1; i >= (l); i--)
#define repa(i,n) for (auto& i: n)

template<class T1, class T2> inline bool chmax(T1 &a, const T2 &b) {if (a<b) { a=b; return 1;} return 0;}
template<class T1, class T2> inline bool chmin(T1 &a, const T2 &b) {if (b<a) { a=b; return 1;} return 0;}
struct init{init(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);cerr<<fixed<<setprecision(15);}}init_;

#ifdef DEBUG
template <class T> void verr(const set<T> &st) { repa(a, st) cerr << a << " "; cerr << endl; }
template <class S, class T> void verr(const map<S, T> &mp) { repa(a, mp) cerr << "{" << a.first << ", " << a.second << "} "; cerr << endl; }
template <class S, class T, class N> void verr(const vector<pair<S,T>>& a, const N& n) { rep(i, n) cerr << "{" << a[i].first << ", " << a[i].second << "} "; cerr << endl; }
template <class T, class N> void verr(const vector<T>& a, const N& n) { rep(i, n) cerr << a[i] << " "; cerr << endl; }
ll dbgt = 1; void err() { cerr << "passed " << dbgt++ << endl; }
template<class H, class... T> void err(H&& h,T&&... t){ cerr<< h << (sizeof...(t)?" ":"\n") << flush; if(sizeof...(t)>0) err(forward<T>(t)...); }
#endif

const ll INF = 4e18;
const ld EPS = 1e-11;
const ld PI = acos(-1.0L);
// const ll MOD = 1e9 + 7;
const ll MOD = 998244353;
//--------------------------------------------------------------------------------//
ll modpow(ll a, ll n, ll mod) {
    ll res = 1;
    while (n > 0) {
        if (n & 1) res = res * a % mod;
        a = a * a % mod;
        n >>= 1;
    }
    return res;
}

int main() {
    ll N;
    cin >> N;
    vl A(N);
    rep(i, N) cin >> A[i];
    sort(all(A));

    ll ans = 0;
    vl acc(N + 1), p2(N + 1, 1), invp2(N + 1, 1);
    rep(i, N) p2[i + 1] = p2[i] * 2 % MOD;
    invp2[N] = modpow(p2[N], MOD - 2, MOD);
    repr(i, N) invp2[i] = (invp2[i + 1] * 2) % MOD;

    rep(i, N) acc[i + 1] = (acc[i] + p2[i] * A[i]) % MOD;

    rep(i, N){
        ans += A[i] * A[i] % MOD;
        (ans += A[i] * (acc[N] - acc[i + 1]) % MOD * invp2[i + 1] % MOD) %= MOD;
    }

    cout << (ans + MOD) % MOD << endl;
}

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <queue>
using namespace std;
const int mod = 998244353;
int A[200010];
int main() {
	int n;
	scanf("%d", &n);
	for(int i = 1; i <= n; ++i) {
		scanf("%d", &A[i]);
	}
	sort(A + 1, A + 1 + n);
	int res = 0, ans = 0;
	A[n + 1] = 0;
	for(int i = n; i >= 1; --i) {
		res = (long long)res * 2 % mod + A[i + 1];
		res %= mod;
		ans += ((long long) A[i] * res % mod);
		ans %= mod;
		ans += ((long long)A[i] * A[i] %mod);
		ans %= mod;

	}
	printf("%d\n", ans);
	return 0;
}


#include <bits/stdc++.h>

#define loop(s, e, i) for (int i = s; i < e; ++i)
#define print(s) cout << s << endl;
#define DIV 1000000007
using namespace std;

typedef long long ll;
typedef unsigned long long ull;
const ll INF = 1e18+7;

ll ceildiv(ll a, ll b) { return (a+b-1)/b; } // 切り上げ
ll floordiv(ll a, ll b) { return a/b; } // 切り下げ

int show_matrix(vector<vector<int>> &dp) {
  loop(0, dp.size(), i) {
    loop(0, dp[i].size(), j) {
      cout << dp[i][j] << " ";
    }
    cout << endl;
  }
  return 0;
}

/*
浮動小数点の入力
cout << fixed << setprecision(9) << endl;
*/

int main() {
  cin.tie(nullptr);
  ios::sync_with_stdio(false);

  ll N;
  cin >> N;
  N--;
  N /= 100;
  print(N+1);
}

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

int main() {
    long int n;
	cin>>n;
  if(n%100==0){
  cout<<n/100;
  }else{
    cout<<((n/100)+1);
  }
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+10;
const int mod=1e9+7;
char s[maxn];int n,vis[300],ans=0,cnt=0;
int dp[maxn][17],f[maxn][17][17];
int mp[300];
void dfs(int pos)
{
	if(pos>n)	return;

	for(int i=1;i<=16;i++){
		dp[pos][i]=(dp[pos][i]+1LL*i*dp[pos-1][i]%mod)%mod;
		dp[pos][i]=(dp[pos][i]+1LL*(17-i)*dp[pos-1][i-1]%mod)%mod;
	}
	if(pos!=1){
		dp[pos][1]=(dp[pos][1]+15)%mod;
	}else{
		dp[pos][1]=(dp[pos][1]+(mp[s[pos]]-1))%mod;
	}

	if(pos!=1){
		for(int i=0;i<mp[s[pos]];i++){
			if(vis[i]==0)
				dp[pos][cnt+1]=(dp[pos][cnt+1]+1)%mod;
			else
				dp[pos][cnt]=(dp[pos][cnt]+1)%mod;
		}
	}

	if(vis[mp[s[pos]]]==0)	cnt++,vis[mp[s[pos]]]=1;
	//cout<<pos<<" "<<dp[pos][1]<<endl;
	dfs(pos+1);
}
int main()
{
	for(int i=0;i<10;i++)	mp[i+'0']=i;
	for(int i=0;i<6;i++)	mp[i+'A']=i+10;
	scanf("%s",s+1);n=strlen(s+1);int k;scanf("%d",&k);
	dfs(1);if(cnt==k)	dp[n][k]++;
	cout<<dp[n][k]<<endl;
}

#include<iostream>
#include<cstdlib>
#include<utility>
#include<tuple>
#include<string>
#include<vector>
#include<numeric>
#include<algorithm>
#include<queue>
#include<deque>
#include<bitset>
#include<cmath>
#include<map>
#include<string>
#include<iomanip>
#include<set>
using namespace std;
using ll = long long;
const ll mod = 1e9 + 7;
const double PI = acos(-1);
#define rep(i, a, b) for(ll i = a; i < b; i++)

ll repeat(ll x) {
	ll res = 1;
	rep(i, 0, x)res *= 10;
	return res;
}

int main() {

	string s;
	cin >> s;
	ll n = s.size();
	bool ans = false;
	if (n == 1) {
		if (stoi(s) == 8) ans = true;
	}else if (n == 2) {
		if (stoi(s) % 8 == 0) ans = true;
		swap(s[0], s[1]);
		if (stoi(s) % 8 == 0) ans = true;
	}
	else {
		vector<ll> x(11, 0);
		rep(i, 0, n) {
			x[s[i] - '0']++;
		}

		if (x[0] >= 2 && x[8] >= 1) ans = true;
		else if (x[0] >= 1) {
			for (ll i = 16; i < 100; i += 8) {
				s = to_string(i);
				if (x[s[0]] >= 1 && x[s[1]] >= 1) ans = true;
			}
		}
		else {
			for (ll i = 104; i < 1000; i += 8) {
				s = to_string(i);
				x[s[0] - '0']--; x[s[1] - '0']--; x[s[2] - '0']--;
				if (x[s[0] - '0'] >= 0 && x[s[1] - '0'] >= 0 && x[s[2] - '0'] >= 0)
					ans = true;
				x[s[0] - '0']++; x[s[1] - '0']++; x[s[2] - '0']++;
			}
		}
	}

	if (ans)cout << "Yes" << endl;
	else cout << "No" << endl;

	return 0;
}


#include <bits/stdc++.h>

using namespace std;

#define REP(i, n)   for(int i = 0; i < (n); i++)
#define REPS(i, n)  for(int i = 1; i <= (n); i++)
#define RREP(i, n)  for(int i = (n)-1; i >= 0; i--)
#define RREPS(i, n) for(int i = (n); i > 0; i--)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define yes cout << "yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
#define no cout << "no" << endl

using ll  = long long;
using pi  = pair<int, int>;
using pl  = pair<ll, ll>;
using vi  = vector<int>;
using vl  = vector<ll>;
using vs  = vector<string>;
using vb  = vector<bool>;
using vvi = vector<vi>;
using vvl = vector<vl>;

//const int MOD = 1e9 + 7;
const int MOD = 998244353;
const int INF = 1e9 + 7;
const ll  INFL = 1e18;
const double PI = 3.141592653589793;
const double EPS = 1e-9;

template<class T> bool chmax(T &a, const T &b) { if(a < b) { a = b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if(a > b) { a = b; return true; } return false; }

signed main()
{
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(20);

    ll N; cin >> N;
    ll ans = 0;
    REP(i, N)
    {
      ll A, B; cin >> A >> B;
      A--;
      ans += B*(B+1)/2;
      ans -= A*(A+1)/2;
    }
    cout << ans << endl;
}

#include <iostream>
using namespace std;

int main() {
	int N;
	cin >> N;
	long long A[N], B[N];
	long long sum = 0;
	for (int i = 0; i < N; i++) {
		cin >> A[i] >> B[i];
		sum = sum + 0.5 * (B[i] - A[i] + 1)*(A[i] + B[i]);
	}

	cout << sum << endl;
	return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define MV 2000001
#define LMV 21
#define ff first
#define ss second
#define pb push_back
#define eb emplace_back
#define emp emplace
#define mp make_pair
#define ins insert
#define sz(x) (int)x.size()
#define whoami(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); whi(_it, args); }

void whi(istream_iterator<string> it) { cerr<<"\n"; }

template<typename T, typename... Args>
void whi(istream_iterator<string> it, T a, Args... args) { cerr<<*it<<" "<<a<<" "; whi(++it, args...); }

void FLASH() {ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);}
void SETF() {cout.ios_base::setf(ios_base::fixed); cerr.ios_base::setf(ios_base::fixed);}
void UNSETF() {cout.ios_base::unsetf(ios_base::fixed); cerr.ios_base::unsetf(ios_base::fixed);}

typedef long long ll;
typedef long double ld;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
typedef pair<PII, int> PPII;
typedef pair<PLL, ll> PPLL;
typedef map<int, int> MII;

const int MOD = 1000000007;
const ll INF = 4e18;

template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename T>
using ordered_multiset = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;

struct h_llint {
    static uint64_t splitmix64(uint64_t x) {    // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }
    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
}
};

struct h_pair{
    size_t operator()(const PLL&x)const{
        return hash<ll>()(((ll)x.ff)^(((ll)x.ss)<<32));
    }
};

typedef map<ll, ll> MLL;
typedef map<PII, int> MPII;
typedef map<PLL, ll> MPLL;
typedef set<int> SI;
typedef set<ll> SL;
//ordered_set = order_of_key(.)
//ordered_set = find_by_order(.)
typedef ordered_set<int> OSI;
typedef ordered_set<ll> OSL;
typedef ordered_multiset<int> MOSI;
typedef ordered_multiset<ll> MOSL;
typedef unordered_map<ll, int, h_llint> UMLI;
typedef unordered_map<ll, ll, h_llint> UMLL;
typedef unordered_map<PLL, int, h_pair> UMPI;
typedef unordered_map<PLL, ll, h_pair> UMPL;

int ar[MV];
ll arr[MV], lo[MV], mu[MV];
VL px;

void siever(void)
{
	lo[1] = 1;
	for(int i=2;i<MV;i++)
	{
		if(!lo[i])
		{
			lo[i] = i;
			px.pb(i);
		}
		for(int j=0;((j<sz(px)) && (px[j]<=lo[i]) && ((i*px[j])<MV));j++)
		lo[i*px[j]] = px[j];
	}
	mu[1] = 1;
	for(ll i=2;i<MV;i++)
	{
		if(lo[i/lo[i]] == lo[i])
		mu[i] = 0;
		else mu[i] = -1 * mu[i/lo[i]];
	}
	return;
}

void solve(int T)
{
    ll l,r;
    cin>>l>>r;
    ll tt = 0;
    for(ll i=2;i<=r;i++)
    {
        ll cf = (r/i) - ((l-1)/i);
        tt += (-mu[i]) * ((cf * (cf-1))>>1LL);
    }
    for(ll i=max(2LL, l);i<=r;i++)
    {
        ll cf = (r/i) - ((l-1)/i) - 1;
        tt -= cf;
    }
    tt <<= 1LL;
    cout<<tt<<"\n";
    return;
}

int main(void)
{
    FLASH();
    //freopen("cowjog.in", "r", stdin);
    //freopen("cowjog.out", "w", stdout);
    int T;
    T = 1;

#ifndef ONLINE_JUDGE
    time_t time_t1, time_t2;
    time_t1 = clock();
#endif

    siever();
    //cin>>T;
    while(T--)
    solve(T);

#ifndef ONLINE_JUDGE
    time_t2 = clock();
    SETF();
    cerr<<"Time taken: "<<setprecision(7)<<(time_t2 - time_t1)/(double)CLOCKS_PER_SEC<<"\n";
    UNSETF();
#endif

    return 0;
}

#include <bits/stdc++.h>
// clang-format off
using namespace std; using ll=long long; using ull=unsigned long long; using pll=pair<ll,ll>; const ll INF=4e18;
void print0(){}; template<typename H,typename... T> void print0(H h,T... t){cout<<h;print0(t...);}
void print(){print0("\n");}; template<typename H,typename... T>void print(H h,T... t){print0(h);if(sizeof...(T)>0)print0(" ");print(t...);}
void perr0(){}; template<typename H,typename... T> void perr0(H h,T... t){cerr<<h;perr0(t...);}
void perr(){perr0("\n");}; template<typename H,typename... T>void perr(H h,T... t){perr0(h);if(sizeof...(T)>0)perr0(" ");perr(t...);}
void ioinit() { cout << fixed << setprecision(15); cerr<<fixed<<setprecision(6); ios_base::sync_with_stdio(0); cin.tie(0); }
// clang-format on

vector<ll> mkprimes(ll n) {
    vector<ll> result;
    vector<bool> isprime(n+1, true);
    for (ll i = 2; i <= n; i++) {
        if (isprime[i]) {
            result.push_back(i);
            for (ll j = 2 * i; j <= n; j += i) {
                isprime[j]=false;
            }
        }
    }
    return result;
}

vector<ll> primefactors(ll n, vector<ll>&primes) {
    vector<ll> result;
    for (auto p: primes) {
        if(p > n) break;
        if(n % p == 0) {
            result.push_back(p);
            n = n / p;
            while(n % p == 0) {
                n = n / p;
            }
        }
    }
    if(n>1) result.push_back(n);
    return result;
}

int main() {
    ioinit();
    ll l, r;
    cin >> l >> r;

    auto prmap = mkprimes(sqrt(r)+2);
    ll ans = 0;
    for (ll x = l; x < r; x++) {
        if (x == 1) continue;

        vector<ll> primes = primefactors(x, prmap);
        ll m = primes.size();
        for (ll i = 1; i < (1LL << m); i++) {
            ll v = 1;
            for (ll j = 0; j < m; j++) {
                if ((i >> j) & 1) {
                    v *= primes[j];
                }
            }

            if (__builtin_popcount(i) % 2 == 0) {
                ans -= (r-x)/v;
            }else{
                ans += (r-x)/v;
            }
        }
        ans -= (r-x)/x;
    }
    print(ans * 2);
}


#include <bits/stdc++.h>
#define F(i,j,k) for(int i=(j);i<=(k);++i)
#define D(i,j,k) for(int i=(j);i>=(k);--i)
#define rep(it,s) for(__typeof(s.begin()) it=s.begin();it!=s.end();++it)
#define Rep(a,s) for(auto a:s)
#define PB push_back
#define MP make_pair
#define FF first
#define SS second
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
ll quick_pow(ll x,ll y,ll Mod){
    ll res=1;
    while(y){
        if(y&1)res=res*x%Mod;
        x=x*x%Mod,y>>=1;
    }
    return res;
}
ll inv(ll x,ll Mod){return quick_pow(x,Mod-2,Mod);}
namespace IO{
    template <class T>
    inline void read(T &x){
        x=0;int f=1;char ch=getchar();
        while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
        while(ch<='9'&&ch>='0')x=x*10+ch-'0',ch=getchar();
        x*=f;
    }
};
using namespace IO;
const int N=500005;
int n;
ll a[N],ans;
priority_queue<ll,vector<ll>,greater<ll>>pq;
int main(){
    #ifndef ONLINE_JUDGE
        freopen("in.txt","r",stdin);
        //freopen("out.txt","w",stdout);
    #endif
    read(n);
    F(i,1,n*2)read(a[i]);
    D(i,n,1){
    	ll x=a[i],y=a[2*n-i+1];
    	if(x<y)swap(x,y);
    	pq.push(x);
    	if(pq.top()<y)pq.pop(),pq.push(y);
	}
	ll ans=0;
	while(!pq.empty())ans+=pq.top(),pq.pop();
	cout<<ans;
    return 0;
}

#include <bits/stdc++.h>

using namespace std;
using ll = long long;
using ld = long double;

#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define ALL(x) ((x).begin()), ((x).end())

#define READ(x) (cin >> (x))
#define WRITE_N(x) (cout << (x) << endl)
#define WRITE(x) (cout << (x))
#define WRITE_YESNO(x) (WRITE_N((x) ? "Yes" : "No"))

#define PRECISE_COUT std::cout << std::setprecision(15) << std::fixed

bool xor_logic(bool x, bool y) { return (x && y) || (!x && !y); }

ll solve(ll L, ll R) {
  ll x = R - 2 * L + 1;
  if (x <= 0) {
    return 0;
  } else {
    return x * (x + 1) / 2;
  }
}

int main() {
  // get values from input
  cin.tie(0);
  ios::sync_with_stdio(false);

  int T;
  cin >> T;

  vector<ll> L(T);
  vector<ll> R(T);
  for (size_t i = 0; i < T; i++) {
    cin >> L[i] >> R[i];
  }

  // main procedure
  // output
  for (size_t i = 0; i < T; i++) {
    ll ans = solve(L[i], R[i]);
    cout << ans << endl;
  }

  return 0;
}


#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=100010,M=500010;

int n,m,s,t,x,y,u,v,a[M],b[M],c[N],d[M],e[M],cnt,f[N];bool vis[N];
inline void add(int u,int v,int D,int x){a[++cnt]=v,b[cnt]=c[u],c[u]=cnt,d[cnt]=D,e[cnt]=x;}
struct node{
    int dis,pos;
    bool operator <( const node &x)const{
        return x.dis < dis;
    }
};
priority_queue<node>q;
inline int F(int x,int y){if(!(x%y))return x;return (x/y+1)*y;}
inline void dijkstra(){
	f[s]=0,q.push((node){0,s});
    while(!q.empty()){
        node tmp=q.top();q.pop();
        int x=tmp.pos;
        if(vis[x])continue;vis[x]=1;
        for(int i=c[x];i;i=b[i]){
        	int y=a[i];
        	if(F(f[x],e[i])+d[i]<f[y]){
        		f[y]=F(f[x],e[i])+d[i];
        		if(!vis[y])q.push((node){f[y],y});
			}
		}
	}
}
signed main(){
	scanf("%lld%lld%lld%lld",&n,&m,&s,&t);
	for(int i=1;i<=n;++i)f[i]=1e18;
	for(int i=1;i<=m;++i)scanf("%lld%lld%lld%lld",&x,&y,&u,&v),add(x,y,u,v),add(y,x,u,v);
    dijkstra();
    f[t]==1e18?puts("-1"):printf("%lld\n",f[t]);
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<long long, long long>;
constexpr char ln =  '\n';
constexpr long long MOD = 1000000007;
constexpr long long INF = 1000000000 + 100;
constexpr long long LINF = 1000000000000000000 + 100;
#define all(v) v.begin(), v.end()
#define rep(i, n) for(int i=0;i<(n);i++)
#define rept(i, j, n) for(int i=(j); i<(n); i++)
#define rrep(i, n) for(int i=(n); i>=0; i--)
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; }

struct edge{ll to, time, cost;};
struct graph{
  ll V;
  vector<vector<edge> > G;
  vector<ll> d;
  vector<ll> prev;

  graph(ll n){
    init(n);
  }

  void init(ll n){
    V = n;
    G.resize(V);
    d.resize(V);
    rep(i,V){
      d[i] = LINF;
    }
  }

  void add_edge(ll s, ll t, ll cost, ll time){
    edge e;
    e.to = t, e.time = time, e.cost = cost;
    G[s].push_back(e);
  }

  void dijkstra(ll s){
    rep(i,V){
      d[i] = LINF;
    }
    d[s] = 0;
    priority_queue<pll,vector<pll>, greater<pll> > que;
    que.push(pll(0,s)); //[その頂点への最短コスト候補、頂点番号]
    prev.assign(V, -1);
    while(!que.empty()){
      pll p = que.top(); que.pop();
      ll v = p.second;
      if(d[v]<p.first) continue;
      for(auto e : G[v]){
          ll ncost = d[v];
          if(ncost % e.time){
              ncost += e.time - (ncost % e.time);
          }
          ncost += e.cost;
        if(d[e.to]>ncost){
          d[e.to] = ncost;
          prev[e.to] = v;
          que.push(pll(d[e.to],e.to));
        }
      }
    }
  }

  vector<int> get_path(int t){ //頂点tへの最短路
    vector<int> path;
    for(; t != -1;t=prev[t]){
        path.push_back(t);
    }

    reverse(path.begin(), path.end());
    return path;
  }
};

int main(){
    int N, M, X, Y; cin >> N >> M >> X >> Y; X--, Y--;
    graph g(N);
    rep(i, M){
        int a, b; ll t, k; cin >> a >> b >> t >> k; a--, b--;
        g.add_edge(a,b,t,k);
        g.add_edge(b,a,t,k);
    }

    g.dijkstra(X);
    cout << (g.d[Y] == LINF ? -1 : g.d[Y]) << ln;
}


#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repp(i, l, n) for (int i = (l); i < (int)(n); i++)
using ll = long long;
int main(){
    int n; cin>>n;
    vector<int> a(n);
    rep(i,n) cin >> a[i];
    rep(i,n){
        a[i] %= 200;

    }
    vector<int> cnt(200);
    rep(i,n) cnt[a[i]]++;

    ll ans=0;
    rep(i,200){
        ans += (ll)(cnt[i]*(ll)(cnt[i]-1))/2;
    }
    cout << ans << endl;
}

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

using ll = long long;

#define ff first
#define ss second
#define all(x) (x).begin(), (x).end()
#define len(x) int((x).size())

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define randint(n) uniform_int_distribution<int>(1, (n))(rng)

vector<int> adj[101];
bool vis[101][101];
int cnt;

void dfs(int v, int stem){
	vis[stem][v]=1;
	cnt++;
	for(auto u:adj[v]){
		if(!vis[stem][u]) dfs(u,stem);
	}
}

int main()
{
	ios_base::sync_with_stdio(0);
	cin.tie(0);

	#ifdef ARTHUR_LOCAL
		ifstream cin("input.txt");
	#endif

	int n;
	cin>>n;

	for(int i=1; i<=n; i++){
		string s;
		cin>>s;
		for(int j=0; j<n; j++){
			if(s[j]=='1') adj[j+1].push_back(i);
		}
	}

	cout << setprecision(11);

	double ans = 0;

	for(int v=1; v<=n; v++){
		cnt = 0;
		dfs(v,v);
		ans += (double)1 / (double)cnt;
	}

	cout << ans << "\n";
}


#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<cstdlib>
#include<queue>
#include<set>
#include<cstdio>
#include<map>
#include<cassert>

using namespace std;

#define ll long long
#define reps(i, a, b) for(int i = a; i < b; i++)
#define rreps(i, a, b) for(int i = a-1; i >= b; i--)
#define rep(i, n) reps(i, 0, n)
#define rrep(i, n) rreps(i, n, 0)
#define P pair<int, int>
#define vec vector<int>
#define mat vector<vec>

const ll mod = 1000000007;
const int INF = 1001001001;

int main(){
    int n;
    cin >> n;
    vector<double> x(n), y(n);
    rep(i, n) cin >> x[i] >> y[i];
    vector<vector<double> > dist(n+2, vector<double>(n+2));
    rep(i, n){
        rep(j, n){
            double dx = x[i] - x[j];
            double dy = y[i] - y[j];
            dist[i][j] = dx * dx + dy * dy;
        }
    }
    rep(i, n) {
        int dy = 100 - y[i];
        dist[n][i] = dy * dy;
        dist[i][n] = dy * dy;
    }
    rep(i, n) {
        int dy = -100 - y[i];
        dist[n+1][i] = dy * dy;
        dist[i][n+1] = dy * dy;
    }
    dist[n][n+1] = 40000;
    dist[n+1][n] = 40000;

    // rep(i, n+2){
    //     rep(j, n+2){
    //         cout << dist[i][j] << " ";
    //     }cout << endl;
    // }

    double l = 0, r = 200;
    rep(s, 100){
        double mid = (l+r) / 2;
        mat g(n+2);
        rep(i, n+2){
            rep(j, n+2){
                if((double)dist[i][j] <= mid*mid){
                    g[i].push_back(j);
                }
            }
        }
        // rep(i, n+2){
        //     rep(j, g[i].size()){
        //         cout << g[i][j] << " ";
        //     }cout << endl;
        // }

        vec pos(n+2);
        queue<int> que;
        que.push(n);
        pos[n] = 1;
        while(que.size() > 0){
            int u = que.front();
            que.pop();
            rep(i, g[u].size()){
                int v = g[u][i];
                if(pos[v] == 1) continue;
                pos[v] = 1;
                que.push(v);
            }
        }
        if(pos[n+1]) r = mid;
        else l = mid;
        // cout << l << " " << r << endl;
    }
    double ans = r / 2;
    printf("%.16lf\n", ans);
}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define re register
#define ls (o<<1)
#define rs (o<<1|1)
//#define m (l+r)/2
#define pb push_back
typedef pair<int,int> pii;
const double PI= acos(-1.0);
const int M = 1e5+7;
/*
int head[M],cnt=1;
void init(int n){cnt=1;for(int i=0;i<=n;i++)head[i]=0;}
struct EDGE{int to,nxt,w;}ee[M*2];
void add(int x,int y,int w){ee[++cnt].nxt=head[x],ee[cnt].w=w,ee[cnt].to=y,head[x]=cnt;}
*/
double eps = 1e-7;
int n;
double x[110],y[110];
double dis(double x1,double y1,double x2,double y2){
	return sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
}
int fa[210];
int gt(int x){
	if(x==fa[x])return x;
	return fa[x]=gt(fa[x]);
}
bool ck(double r){
	for(int i=1;i<=n+2;i++)fa[i]=i;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			if(dis(x[i],y[i],x[j],y[j])+eps<=2*r)
				fa[gt(i)]=gt(j);
		}
		if(100-y[i] + eps<=2*r)fa[gt(i)]=gt(n+1);
		if(y[i]+100 + eps<=2*r)fa[gt(i)]=gt(n+2);
	}
	if(gt(n+1)==gt(n+2))return false;
	return true;
}
int main()
{
	ios::sync_with_stdio(false);
  	cin.tie(0);
  	cin>>n;
  	for(int i=1;i<=n;i++){
  		cin>>x[i]>>y[i];
	}
	double l=0,r=100,ans=0;
	while(l+eps<=r){
		double mid=(l+r)/2;
		if(ck(mid))l=mid,ans=mid;
		else r=mid;
	}
	cout<<ans<<endl;
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define f first
#define s second
#define all(v) (v).begin(),(v).end()
#define rall(v) (v).rbegin(),(v).rend()

const int inf = 1e9;
const ll infll = 1e18;
const int M = 1e9 + 7;
const int N = 3e6;

int fact[N+1], inv[N+1];
int mult(ll a, ll b){
	return (a * b) %M;
}
void ad(int &a, int b){
	a += b;
	if(a >= M) a -= M;
	if(a < 0) a += M;
}
int fp(int a, int b){
	int ret  = 1;
	while(b){
		if(b&1) ret = mult(ret , a);
		b >>= 1;
		a = mult(a, a);
	}
	return ret;
}
int nck(int a, int b){
	if(b > a) return 0;
	return mult(fact[a], mult(inv[b], inv[a-b]));
}
void precompute(){
	fact[0] = inv[0] = 1;
	for (int i = 1; i <= N; ++i){
		fact[i] = mult(fact[i-1], i);
		inv[i] = fp(fact[i], M - 2);
	}
}

int W , B , k;

int main(){
	precompute();
	scanf("%d%d%d", &W, &B ,&k);
	if(W >= B + k + 1) return puts("0"), 0;
	//w = b + k + 1 = bad
	int ans = nck(W+B, W);
	ad(ans , -nck(W+B, B+k+1));
	printf("%d\n",ans);
}

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD=1000000007;
#define INF 1LL<<60
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define all(x) (x).begin(),(x).end()

template <class T>
bool chmin(T &a, const T &b) {
    if (b < a) {
        a = b;
        return 1;
    }
    return 0;
}
int V;
ll G[20][20];  // グラフ
ll dp[200000][20];
int main() {
    cin >> V;
    // グラフの初期化
    rep(i, 20) {
        rep(j, 20) { G[i][j] = INF; }
    }

    vector<ll> x(V),y(V),z(V);
    rep(i, V) {
        cin>>x[i]>>y[i]>>z[i];
    }

    rep(i,V){
        rep(j,V){
            G[i][j]=abs(x[j]-x[i])+abs(y[j]-y[i])+max(0LL,z[j]-z[i]);
        }
    }

    // dp の初期化
    rep(i, 200000) {
        rep(j, 20) { dp[i][j] = INF; }
    }
    dp[0][0] = 0;  // スタートを頂点 0 とする
    rep(S, 1 << V) {
        rep(v, V) {
            rep(u, V) {
                if ((S & (1 << v)) == 0) {
                    if (v != u) chmin(dp[S | (1 << v)][v], dp[S][u] + G[u][v]);
                }
            }
        }
    }
    if (dp[(1 << V) - 1][0] != INF) {
        cout << dp[(1 << V) - 1][0] << endl;
    } else {
        cout << -1 << endl;
    }
    return 0;
}


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

#define fi first
#define se second

typedef long long ll;
typedef pair<int,int> ii;

const int N = 1e2;
int n;
bool vis[N+2];
vector<int> adj[N+2];

int dfs(int cur) {
    vis[cur] = 1;
    int ret = 1;
    for (int nx : adj[cur]) {
        if (!vis[nx])
            ret += dfs(nx);
    }
    return ret;
}

int main() {
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    cin >> n;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            char x; cin >> x;
            if (x == '1')
                adj[j].push_back(i);
        }
    }
    double ans = 0;
    for (int i = 1; i <= n; i++) {
        memset(vis,0,sizeof(vis));
        ans += 1.0 * 1/dfs(i);
    }
    cout << fixed << setprecision(20);
    cout << ans << '\n';
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vl = vector<ll>;
template<class T> using vc = vector<T>;
template<class T> using vvc = vector<vector<T>>;

#define eb emplace_back
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define repr(i, n) for (ll i = (n)-1; i >= 0; i--)
#define repe(i, l, r) for (ll i = (l); i < (r); i++)
#define reper(i, l, r) for (ll i = (r)-1; i >= (l); i--)
#define repa(i,n) for (auto& i: n)

template<class T1, class T2> inline bool chmax(T1 &a, const T2 &b) {if (a<b) { a=b; return 1;} return 0;}
template<class T1, class T2> inline bool chmin(T1 &a, const T2 &b) {if (b<a) { a=b; return 1;} return 0;}
struct init{init(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);}}init_;

#ifdef DEBUG
template <class T, class N> void verr(const T& a, const N& n) { rep(i, n) cerr << a[i] << " "; cerr << "\n" << flush; }
ll dbgt = 1; void err() { cerr << "passed " << dbgt++ << "\n" << flush; }
template<class H, class... T> void err(H&& h,T&&... t){ cerr<< h << (sizeof...(t)?" ":"\n") << flush; if(sizeof...(t)>0) err(forward<T>(t)...); }
#endif

const ll INF = 4e18;
const ld EPS = 1e-11;
const ld PI = acos(-1.0L);
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
//--------------------------------------------------------------------------------//
struct UnionFind {
private:
    vector<int> par;
    vector<int> count;
    vector<int> rank;
public:
    UnionFind(int N) {
        count.assign(N, 1);
        rank.assign(N, 0);
        par.assign(N, 0);
        rep(i, N) par[i] = i;
    }

    int root(int x) {
        if (par[x] == x)
            return x;
        else {
            par[x] = root(par[x]);
            return par[x];
        }
    }

    void unite(int x, int y) {
        x = root(x), y = root(y);
        if (x == y) return;
        if (rank[x] < rank[y])
            swap(x, y);
        else if (rank[x] == rank[y])
            rank[y]++;
        par[y] = x;
        count[x] += count[y];
        return;
    }

    int size(int x) {
        return count[root(x)];
    }

    bool issame(int x, int y) {
        return root(x) == root(y);
    }
};
using UF = struct UnionFind;

int main() {
    ll N;
    cin >> N;
    vc<string> S(N);
    rep(i, N) cin >> S[i];

    vvc<int> child(N), parent(N);
    rep(i, N){
        vl srch(N);
        srch[i] = true, child[i].eb(i);
        queue<ll> q;
        q.emplace(i);
        while(!q.empty()){
            ll now = q.front();
            q.pop();
            rep(j, N){
                if (srch[j] or S[now][j] == '0') continue;
                srch[j] = true;
                child[i].eb(j);
                q.emplace(j);
            }
        }
        srch = vl(N), q.emplace(i), parent[i].eb(i), srch[i] = true;
        while(!q.empty()){
            ll now = q.front();
            q.pop();
            rep(j, N){
                if (srch[j] or S[j][now] == '0') continue;
                srch[j] = true;
                parent[i].eb(j);
                q.emplace(j);
            }
        }
    }

    ld ans = 0;
    rep(i, N) ans += 1.0L / parent[i].size();

    cout << ans << endl;
}


#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define e endl
#define iff(u,v)  if(abs(u-v)<1e-9)
#define f(i,p,q) for(int i=p;i<q;i++)
#define vi vector<long long>v;
#define tc int t; cin>>t; while(t--)
//#define an long long n; cin>>n; long long a[n]; for(int i=0;i<n;i++) cin>>a[i];
int main()
{
    //freopen("input.txt","r",stdin); freopen("output.txt","w",stdout);

    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);

    ll n,i,j,k=1,x,y,r,c,ans=0,size,sum=0; string s; bool flag;
    // tc{

    // }
    cin>>n>>i>>j;
    cout<<n-i+j<<e;

}

#include <bits/stdc++.h>
using namespace std;
int main() {
    int N, A, B, sum;
    cin >> N >> A >> B;
    sum = N-A+B;
    cout << sum << endl;
}


#include <bits/stdc++.h>
#define watch(x) std::cout << (#x) << " is " << (x) << std::endl
using LL = long long;
using pii = std::pair<int, int>;
using pll = std::pair<LL, LL>;

const int N = 100;
double dp[N + 1][N + 1][N + 1];
double  f(int i, int j, int k) {
	if (k > j) std::swap(j ,k);
	if (j > i) std::swap(i, j);
	return dp[i][j][k];
}
void solve() {
	for (int i = N - 1; i >= 0; --i) {
		for (int j = i; j >= 0; --j) {
			for (int k = j; k >= 0; --k) if (i + j + k) {
				dp[i][j][k] = 1 + (f(i + 1, j, k) * i + f(i, j + 1, k) * j + f(i, j, k + 1) * k) / (i + j + k);
			}
		}
	}
}

int main() {
	//freopen("in","r",stdin);
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);
	solve();
	std::vector<int> a(3);
	for (auto &x : a) std::cin >> x;
	std::sort(a.begin(), a.end());
	std::cout.precision(12);
	std::cout << std::fixed << f(a[2], a[1], a[0]) << std::endl;;
	return 0;
}

#include <bits/stdc++.h>
#include <unistd.h>
#define FAST_IO ios::sync_with_stdio(0);cin.tie(NULL)
#define all(v) (v).begin(),(v).end()
using namespace std;

void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}

template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif

typedef long long Long;
typedef long double Double;
typedef unsigned long long ULong;
typedef pair<Double, Double> Pair;

const int N = 1e6;
const Double EPS = 1e-9;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
Long random(Long a, Long b) { return uniform_int_distribution<Long> (a, b) (rng); }

Pair operator + (const Pair& a, const Pair& b) {
  return {a.first + b.first, a.second + b.second};
}

Pair operator - (const Pair& a, const Pair& b) {
  return {a.first - b.first, a.second - b.second};
}

Pair operator / (const Pair& a, Double k) {
  return {a.first / k, a.second / k};
}

void Solve(void) {
  Long n, m, k;
  cin >> n >> m >> k;
  if (k == 0) {
    vector<Double> dp(n + m + 2, 0.0);
    vector<Double> suffix(n + m + 2, 0.0);
    for (int i = n - 1; i >= 0; i--) {
      Double sum = suffix[i + 1] - suffix[i + m + 1];
      dp[i] = sum / m + 1;
      suffix[i] = dp[i] + suffix[i + 1];
    }
    cout << dp[0] << '\n';
  } else {
    vector<bool> is_hole(n + m + 2, false);
    for (int i = 0; i < k; i++) {
      int a;
      cin >> a;
      is_hole[a] = true;
    }
    vector<int> prefix(n + m + 2, 0);
    for (int i = 1; i <= n; i++) {
      prefix[i] = prefix[i - 1];
      if (is_hole[i]) prefix[i]++;
    }
    for (int i = 1; i < n - m + 1; i++) {
      if (prefix[i + m - 1] - prefix[i - 1] == m) {
        cout << -1 << '\n';
        return;
      }
    }
    vector<Pair> dp(n + m + 2, {0.0, 0.0});
    vector<Pair> suffix(n + m + 2, {0.0, 0.0});
    Pair one = {0.0, 1.0};
    for (int i = n - 1; i >= 0; i--) {
      if (is_hole[i]) {
        dp[i] = {1.0, 0};
      } else {
        Pair sum = suffix[i + 1] - suffix[i + m + 1];
        dp[i] = sum / m + one;
      }
      suffix[i] = dp[i] + suffix[i + 1];
    }
    Double ans = dp[0].second / (1.0 - dp[0].first);
    cout << fixed << setprecision(10) << ans << '\n';
  }
}

int main(void) {
  FAST_IO;
  int t = 1;
  //cin >> t;
  while (t--) Solve();
  return 0;
}


#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (a); i <= int(b); i++)
#define per(i, a, b) for (int i = (a); i >= int(b); i--)
using namespace std;

typedef long long ll;

const int maxn = 1e5;
int n, L, a[maxn + 5], b[maxn + 5];

void read(int a[], int n) {
	rep(i, 1, n - 1) {
		scanf("%d", &a[i]);
	}
	a[n] = L + 1;
	per(i, n, 1) {
		a[i] = a[i] - a[i - 1] - 1;
	}
}

int main() {
	scanf("%d %d", &n, &L), ++n;
	read(a, n), read(b, n);
	ll res = 0;
	int p = 1;
	rep(i, 1, n) if (b[i] > 0) {
		for (; p < i && a[p] == 0; p++);
		int l = p, c = 0;
		for (; p <= n && c < b[i]; p++) {
			c += a[p];
		}
		if (c > b[i]) {
			puts("-1"), exit(0);
		}
		int r = p - 1;
		res += max(r - i, 0) + max(i - l, 0);
	}
	rep(i, p, n) if (a[i] > 0) {
		puts("-1"), exit(0);
	}
	printf("%lld\n", res);
	return 0;
}

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

#define rep(i, a, b) for(int i=a; i<=b; i++)
#define trav(a, x) for(auto& a : x)
#define all(x) begin(x), end(x)
#define sz(x) (int) x.size()
#define f first
#define s second
#define nl "\n"
typedef long long ll;
typedef pair<int, int> pii;
const int MOD = 1e9+7;
template<class T> using pqg = priority_queue<T,vector<T>,greater<T>>;

int n;
int s[200001];
string t;
vector<int> vec;

int main(){
  ios::sync_with_stdio(false);
  cin.tie(0);
  // freopen("input.txt", "r", stdin);
  // freopen("output.txt", "w", stdout);

  cin >> n;
  rep(i, 0, n-1){
    char c;
    cin >> c;
    s[i]=(c-'0')%7;
  }
  cin >> t;

  int mask=1;
  int pten=1;
  for(int i=n-1; i>=0; i--){
    int oldmask=mask;
    rep(k, 0, 6){
      if(oldmask&(1<<k)){
        mask|=(1<<((k+pten*s[i])%7));
      }
    }
    if(i==0 || t[i-1]!=t[i]){
      vec.push_back(mask);
      mask=1;
    }
    pten*=10;
    pten%=7;
  }

  int need=1;
  rep(i, 0, sz(vec)-1) {
    int mask=vec[i];
    int oldneed=need;
    need=0;
    if((t[n-1]=='T' && i%2==0) || (t[n-1]=='A' && i%2==1)){
      rep(j, 0, 6){
        if(!(oldneed&(1<<j))) continue;
        rep(k, 0, 6){
          if(mask&(1<<k)){
            need|=(1<<((j-k+7)%7));
          }
        }
      }
    }
    else{
      rep(j, 0, 6){
        int get=0;
        rep(k, 0, 6){
          if(mask&(1<<k)) get|=(1<<((j+k)%7));
        }
        if(oldneed==(get|(oldneed^get))) need|=(1<<j);
      }
    }
  }

  cout << (need&1?"Takahashi":"Aoki");
}


#include<bits/stdc++.h>
using namespace std;
#define debug(x) cerr<<#x<<" = "<<x
#define sp <<"  "
#define el <<endl
#define fgx cerr<<" ------------------------------------------------ "<<endl
#define LL long long
#define DB double
#define mpt make_pair
#define pb push_back
inline LL read(){
	LL nm=0; bool fh=true; char cw=getchar();
	for(;!isdigit(cw);cw=getchar()) fh^=(cw=='-');
	for(;isdigit(cw);cw=getchar()) nm=nm*10+(cw-'0');
	return fh?nm:-nm;
}
#define M 200200
#define INF 2000000000
int n,m,mx[M],a[M],fs[M],to[M],nt[M],tot,ind[M],oud[M],H[M],ans=-INF; bool vis[M];
inline void link(int x,int y){to[++tot]=y,nt[tot]=fs[x],fs[x]=tot;}
inline void dfs(int x){
	if(vis[x]) return; vis[x]=true,mx[x]=a[x];
	for(int i=fs[x];i;i=nt[i])
		dfs(to[i]),mx[x]=max(mx[x],mx[to[i]]),H[x]=max(H[x],mx[to[i]]);
}

int main(){
	n=read(),m=read();
	for(int i=1;i<=n;i++) a[i]=read();
	for(int i=1,x,y;i<=m;i++) x=read(),y=read(),link(x,y),++oud[x],++ind[y];
	for(int i=1;i<=n;i++) if(!ind[i]) dfs(i);
	for(int i=1;i<=n;i++) if(oud[i]) ans=max(ans,H[i]-a[i]);
	printf("%d\n",ans);return 0;
}

#include<bits/stdc++.h>
#include<iostream>
#include<string>
#include<cmath>
#include<cstdio>
#include<cctype>
#include<cstring>
#include<iomanip>
#include<cstdlib>
#include<ctime>
#include<set>
#include<map>
#include<utility>
#include<queue>
#include<vector>
#include<stack>
#include<sstream>
#include<algorithm>
#define forn(i,a,b)for(int i=(a),_b=(b);i<=_b;i++)
#define fore(i,b,a)for(int i=(b),_a=(a);i>=_a;i--)
#define rep(i,n)for(int i=0,_n=n;i<n;i++)
#define ll long long
#define pii pair<int,int>
#define vi vector<int>
#define vpii vector<pii>
#define m_p make_pair
#define re return
#define pb push_back
#define si set<int>
#define ld long double
#define X first
#define Y second
#define st string
#define ull unsigned long long
#define mod 1000000007
#define INF 1000000007
#define x1 XZVJDFADSPFOE
#define y1 GASDIJSLDAEJF
#define x2 DFDAJKVOHKWIW
#define y2 PSFSAODSXVNMQ
#define LLINF 0x3f3f3f3f3f3f3f3fLL
#define foreach(i,c) for(__typeof(c.begin())i=(c.begin());i!=(c).end();i++)
using namespace std;
inline void read(int &x)
{
	short negative=1;
    x=0;
    char c=getchar();
    while(c<'0' || c>'9')
    {
		if(c=='-')
			negative=-1;
		c=getchar();
	}
    while(c>='0' && c<='9')
        x=(x<<3)+(x<<1)+(c^48),c=getchar();
    x*=negative;
}
ll quickpower(ll n,ll k){
	ll ans=1;
	while(k){
		if(k%2){
			ans*=n;
			ans%=mod;
		}
		n*=n;
		n%=mod;
		k/=2;
	}
	return ans;
}
string int_to_string(int n)
{
	string s="";
	while(n)
	{
		int now=n%10;
		s+=now+'0';
		n/=10;
	}
	reverse(s.begin(),s.end());
	return s;
}
int string_to_int(string s)
{
	int n=0;
	rep(i,s.size())
	{
		n*=10;
		n+=s[i]-'0';
	}
	return n;
}
int n,m;
vector<int>v[200100];
ll a[200100];
bool used[200100];
ll can[200100];
void dfs(int u)
{
	used[u]=1;
	rep(i,v[u].size())
	{
		if(!used[v[u][i]])dfs(v[u][i]);
		can[u]=max(can[u],can[v[u][i]]);
		can[u]=max(can[u],a[v[u][i]]);
	}
}
int main()
{
	ios::sync_with_stdio(0);
	cin>>n>>m;
	rep(i,n)cin>>a[i];
	rep(i,m)
	{
		int x,y;
		cin>>x>>y;
		x--;
		y--;
		v[x].pb(y);
	}
	rep(i,n)can[i]=-1e18;
	rep(i,n)
	{
		if(!used[i])dfs(i);
	}
	ll ans=-1e18;
	rep(i,n)
	{
		ans=max(ans,can[i]-a[i]);
	}
	cout<<ans<<endl;
	return 0;
}