#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <vector>
#include <cassert>
#include <algorithm>
#include <functional>
using namespace std;
unsigned long long L;

int main(){
  cin >> L;

  long long result = 1LL;
  for(int i=1; i<12; i++){
    result = result*(L-i)/i;
  }
  cout << result;
}

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;

// s.find_by_order(index);
// s.order_of_key(value);

#define int long long
#define all(a) a.begin(), a.end()
#define dl '\n'
#define why (int)1000000007
//#define why (int)998244353

typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> indexed_set;

int inf = 1e18;
double pi = 3.141592653589;
int mod = why;
int fast_power(int base, int power)
{
  int result = 1;
  while (power) {
    if (power % 2)
      result = (result * base) % mod;
    base = (base * base) % mod;
    power /= 2;
  }
  return result;
}

int inverse(int base) { return fast_power(base, mod - 2); }
int test = 1;

int printNcR(int n, int r)
{
  long long p = 1, k = 1;
  if (n - r < r)
    r = n - r;

  if (r != 0) {
    while (r) {
      p *= n;
      k *= r;
      long long m = __gcd(p, k);
      p /= m;
      k /= m;

      n--;
      r--;
    }
  }

  else
    p = 1;
  return p;
}

const pair<int, int> dir[] = {{0, -1}, {-1, 0}, {1, 0}, {0, 1}};

const int N = 2e5 + 5;

vector<int> adj[N];
vector<int> vis(N);

void solve()
{
  int n;
  cin >> n;
  cout << printNcR(n - 1, 11);
}

signed main()
{
  // #ifndef ONLINE_JUDGE
  //   freopen("input.txt", "r", stdin);
  //   freopen("output.txt", "w", stdout);
  // #endif
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  int t = 1;
  // cin >> t;
  while (t--) {
    // cout << "Case #" << test++ << ": ";
    solve();
  }
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll t = 1,n,m,k,q,l,r,a[809][809],b[809][809],c[809][809],u,v,x,y,z,mod = 1e9 + 7;
string s;
struct st{ll x,y; /*bool operator < (const st &a) const{return x < a.x;};*/};
bool cmp(const st &a,const st &b){return a.x < b.x;}
inline ll read(){
	ll s = 0,w = 1;
	char ch = getchar();
	while (ch > '9' || ch < '0'){ if (ch == '-') w = -1; ch = getchar();}
	while (ch <= '9' && ch >= '0') s = (s << 1) + (s << 3) + (ch ^ 48),ch = getchar();
	return s * w;
}
ll qp(ll x,ll y){
	ll a = 1,b = x;
	while (y){
		if (y & 1) a = a * b % mod;
		b = b * b % mod,y >>= 1;
	}
	return a;
}
bool judge(ll x){
	for (ll i = 1;i <= n;i += 1) for (ll j = 1;j <= n;j += 1) c[i][j] = a[i][j] <= x;
	for (ll i = 1;i <= n;i += 1) for (ll j = 1;j <= n;j += 1) b[i][j] = b[i - 1][j] + b[i][j - 1] - b[i - 1][j - 1] + c[i][j];
	for (ll i = 1;i <= n - k + 1;i += 1) for (ll j = 1;j <= n - k + 1;j += 1)
		if (b[i + k - 1][j + k - 1] - b[i - 1][j + k - 1] - b[i + k - 1][j - 1] + b[i - 1][j - 1] >= (k * k + 1) / 2){
			return 1;
		}
	return 0;
}
int main(){//t = read();
while (t --){
	n = read(),k = read();
	for (ll i = 1;i <= n;i += 1) for (ll j = 1;j <= n;j += 1) a[i][j] = read();
	ll l = 0,r = 1e9,ans = 1e9;
	while (l <= r){
		ll mid = (l + r) >> 1;
		if (judge(mid)) r = mid - 1,ans = mid;
		else l = mid + 1;
	}
	cout<<ans;
}
	return 0;
}

// Author:   old_school
// Created:  20.02.2021 17:30:29

#include<bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization ("unroll-loops")
using namespace std;
#define lld               long long int
#define ld                long double
#define pb                push_back
#define ppb               pop_back
#define mp                make_pair
#define F                 first
#define S                 second
#define nl                '\n'
#define all(c)            (c).begin(),(c).end()
#define rall(c)           (c).rbegin(),(c).rend()
#define sz(c)             (c).size()
#define tr(x,a)           for(auto &a : x)
#define psnt(x,a)         (x).find(a)!=(x).end()
#define vpsnt(x,a)        find(all(x),a)!=(x).end()
#define MOD               1000000007
#define tod               100005
#define pi                3.1415926536
#define itr(i,a,b)        for(lld i=a;i<=b;i++)
#define itrn(i,a,b)       for(lld i=a;i>=b;i--)
#define iot(n)            for(lld i=0;i<n;i++)
#define pls(n,arr)        lld arr[n]; iot(n)  cin>>arr[i];
#define bye               fflush(stdout)

typedef pair<lld,lld>     pii;
typedef pair<string,lld>  psi;

template <typename T>
bool mycomp(T x,T y){
   return (x==y);  //give your condition here
}
bool paircomp(const pair<lld,lld> &x,const pair<lld,lld> &y){
return x.second<y.second;
}
vector<pair<lld,pair<lld,lld> > > adj[tod];
void dijkstra(lld V,lld source,lld dist[]){
    priority_queue<pair<lld,lld> ,vector<pair<lld,lld> >,greater<pair<lld,lld> > > pq; //minheap
    for(lld i=0;i<=V;i++)
       dist[i]=-1;
    dist[source]=0;
    pq.push(make_pair(dist[source],source));
    while(!pq.empty()){
        lld u=pq.top().second;
        pq.pop();
        for(auto &p:adj[u]){
            lld v=p.first,weight=p.second.first,lx=p.second.second;
            lld z=dist[u]/lx;
               lld ex=0;
               if(dist[u]%lx){
               	 z++;
               }
               z*=lx;
               ex=z-dist[u];
            if (dist[v]==-1)
            {
                dist[v] = dist[u] + ex+weight;
                pq.push(make_pair(dist[v], v));

            }
            else if(dist[v]>dist[u]+ex+weight){
                dist[v]=dist[u]+ex+weight;
                pq.push(make_pair(dist[v], v));
            }
        }
    }
}
void solve(){
   lld n,m,x,y; cin>>n>>m>>x>>y;
   iot(m){
   	lld a,b,t,k; cin>>a>>b>>t>>k;
   	adj[a].pb({b,{t,k}});
   	adj[b].pb({a,{t,k}});
   }
   lld dist[n+1];
   dijkstra(n,x,dist);
   cout<<dist[y];
}
int main(){
       ios_base::sync_with_stdio(false);
             cin.tie(0);
            cout.tie(0);
      lld t=1;// cin>>t;
      while(t--){
            solve();
            cout<<endl;
      }
}


/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author NikuKyabe
 */

#include <iostream>
#include <fstream>

#include <bits/stdc++.h>

#define int long long
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define FOR(i, a, b) for (int i = (a), i##_len = (b); i < i##_len; ++i)
#define REV(i, a, b) for (int i = (b) - 1; i >= (a); --i)
#define CLR(a, b) memset((a), (b), sizeof(a))
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define INF 1001001001001001001l
#define MOD 1000000007
#define fcout cout << fixed << setprecision(12)

using namespace std;

typedef pair<int, int> P;
template<class T>
using M =vector<vector<T>>;

class CPOW {
public:
	void solve(std::istream& cin, std::ostream& cout) {
       int a,b,c;
       cin >> a >> b >> c;

       if(c % 2 == 0){
            a = abs(a);
            b = abs(b);
       }
       if(a > b){
           cout << ">" << endl;
       }
       else if(a < b){
           cout << "<" << endl;
       }
       else{
           cout << "=" << endl;
       }
	}
};

signed main() {
	CPOW solver;
	std::istream& in(std::cin);
	std::ostream& out(std::cout);
	solver.solve(in, out);
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

int main(){
  int A, B, C;
  while(scanf("%d%d%d", &A, &B, &C) > 0){
    if(C%2 == 0){
      A = abs(A);
      B = abs(B);
    }

    if(A > B) printf(">");
    if(A < B) printf("<");
    if(A == B) printf("=");
    printf("\n");
  }
}


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

int main() {
	int N, K; cin >> N >> K;

	cout << N * (N + 1) * 50 * K + K * (K + 1) / 2 * N << endl;
}

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,k;
    cin>>n>>k;
    int sum=0;
    int i,j;
    for(i=1;i<=n;i++)
    {
    for(j=1;j<=k;j++)
    {
        sum=sum+(100*i)+j;
    }
    }
    cout<<sum<<endl;
    return 0;
}


#include<bits/stdc++.h>
#define forn(i, n) for (int i = 0; i < n; i++)
#define form(i, n) for (int i = n-1; i >=0; i--)
#define forx(i,x,n) for (int i = x; i < n; i++)
#define all(x) (x).begin(), (x).end()
#define sz(a) int(a.size())
#define pb push_back
#define ll long long
#define srt(a) sort(a.begin(), a.end());
#define pl pair<long long,long long>
#define pi pair<int, int>
#define fi first
#define se second
#define ve vector
using namespace std;
const int inf = 1e9;

int main() {
    ios_base::sync_with_stdio(false); cin.tie(nullptr);
    int n, m, k, l; cin >> n >> m;
    ve<int> c(n); forn(i, n) cin >> c[i];
    multiset<int> a; set<int> b;
    forn(i, m+1) { b.insert(i); }
    forn(i, m) {
        a.insert(c[i]); b.erase(c[i]);
    }
    int R = *b.begin();
    forx(i, m, n) {
        a.insert(c[i]);
        a.erase(a.find(c[i - m]));
        if (a.count(c[i-m])==0) b.insert(c[i - m]);
        b.erase(c[i]);
        R = min(R, *b.begin());
    }
    cout << R;

}

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(ll i=0,endrep=(n); i<endrep; ++i)
#define rep1(i,n) for(ll i=1,endrep=(n); i<=endrep; ++i)
#define revrep(i,n) for(ll i=(ll)(n)-1; i>=0; --i)
inline constexpr ll Inf = (1ULL << 60) -123456789;
#define fastio cin.tie(0); ios_base::sync_with_stdio(false); cout<<fixed<<setprecision(10);
#define newl '\n'
#define YN(e) ((e)?"Yes":"No")
#define all(a) begin(a),end(a)
#define rall(a) rbegin(a),rend(a)
#define delif(c,pred) (c).erase(remove_if(all(c),(pred)), end(c))
template <class T,class U> bool updmax(T& a, U b) { if(b>a){ a=b; return true;} return false;}
template <class T,class U> bool updmin(T& a, U b) { if(b<a){ a=b; return true;} return false;}
inline constexpr int Mod = 1000000007;
//inline constexpr int Mod = 998244353;
#define dbg(a) cerr << #a << ": " << a << endl;
#define dbgs(s) cerr << #s << endl;
#define dbg1(a,n) cerr<<#a<<": "; rep(i,n) cerr<<a[i]<<" "; cerr<<endl;
#define dbg2(m,h,w) cerr<<#m<<":"<<endl; rep(i,h){ rep(j,w)cerr<<m[i][j]<<" "; cerr<<endl; }
template <class T, class U> ostream& operator << (ostream& os, pair<T,U> v) {os<<v.first<<","<<v.second;return os;}
template <class T, size_t N> ostream& operator << (ostream& os, array<T,N> v) {rep(i,N)os<<v[i]<<(i+1<(ll)N?" ":"");return os;}
int rng(int n) { return rand()/(RAND_MAX+1.0)*n; }

int main() {
    fastio;
    ll ans{};
    ll a,b,c;
    cin >> a >> b >> c;
  ans = 21-a-b-c;
    cout << ans << endl;
}


#include<bits/stdc++.h>
#define rep(i , a , b) for(int i = a ; i <= b ; i ++)
#define fi first
#define se second
using namespace std;
const int N = 1e3 + 10;
int mp[N][N] , vis[N][N];
vector<int>G[N][30];
signed main()
{
	int n , m ;
	cin >> n >> m ;
	rep(i , 1 , m)
	{
		int u , v;
		char ch;
		cin >> u >> v >> ch;
		G[u][ch - 'a'].push_back(v);
		G[v][ch - 'a'].push_back(u);
		mp[u][v] = mp[v][u] = 1;
	}
	queue<pair<pair<int , int> , int>>que;
	int res = 1e9;
	que.push(make_pair(make_pair(1 , n) , 0));
	vis[1][n] = 1;
	while(!que.empty())
	{
		pair<pair<int , int> , int>q = que.front();
		que.pop();
		int x = q.fi.fi , y = q.fi.se , z = q.se;
		if(z > res) break ;
		if(x == y) res = min(res , z);
		if(mp[x][y]) res = min(res , z + 1);
		rep(k , 0 , 25)
		{
			for(auto i : G[x][k])
			{
				for(auto j : G[y][k])
				{
					if(vis[i][j]) continue ;
					vis[i][j] = 1;
					que.push(make_pair(make_pair(i , j) , z + 2));
				}
			}
		}
	}
	if(res == 1e9) res = -1;
	cout << res << '\n';
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+1e5,M=1e3+10;
int n,m;
vector<int>e[N];
vector<int>f[M][26];
int a,b;
char c[5];
int d[N];
int cal(int x,int y){
	return x*1001+y;
}
queue<int>q;
int main(){
	scanf("%d%d",&n,&m);
	memset(d,-1,sizeof d);
	for(int i=1;i<=n;++i){
		d[cal(i,i)]=0;
		q.push(cal(i,i));
	}
	for(int i=1;i<=m;++i){
		scanf("%d%d%s",&a,&b,c);
		if(a!=b){
			d[cal(a,b)]=1;
			q.push(cal(a,b));
			d[cal(b,a)]=1;
			q.push(cal(b,a));
		}
		int v=c[0]-'a';
		f[a][v].push_back(b);
		f[b][v].push_back(a);
	}
	for(int i=1;i<=n;++i){
		for(int j=0;j<26;++j){
			for(auto &x:f[i][j]){
				for(int k=1;k<=n;++k){
					for(auto &y:f[k][j]){//i-x k-y
						e[cal(i,k)].push_back(cal(x,y));
						e[cal(i,k)].push_back(cal(y,x));
						e[cal(i,y)].push_back(cal(k,x));
						e[cal(i,y)].push_back(cal(x,k));
					}
				}
			}
		}
	}
	while(!q.empty()){
		int x=q.front();q.pop();
		//printf("(%d,%d):%d\n",x/1001,x%1001,d[x]);
		for(auto &y:e[x]){
			if(d[y]==-1){
				d[y]=d[x]+2;
				q.push(y);
			}
		}
	}
	printf("%d\n",d[cal(1,n)]);
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
long long INF = 1LL<<60;
using ll = long long;
using vll = vector<ll>;
using mll = map<ll, ll>;
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#define all(x) (x).begin(),(x).end()
template<class T>bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }

//* calculate x^n mod something in O(log n) -- recursive version
ll my_pow(ll x, ll n){
    if(n == 0) return 1;
    ll res = my_pow(x*x , n/2);
    if(n & 1) res = res * x ;
    return res;
}

void solve(long long N){
    rep(A, 1, 38){
        rep(B, 1, 26){
            ll tmp = my_pow(3, A) + my_pow(5, B);
            if(tmp == N){
                cout << A << " " << B << endl;
                return;
            }
        }
    }
    cout << -1 << endl;
}

int main(){
    long long N;
    scanf("%lld",&N);
    solve(N);
    return 0;
}

#include <iostream>
#include <cmath>
#include <stdio.h>
#include <string.h>
#include <bits/stdc++.h>
#include <vector>
#include <array>
#include <tuple>
using namespace std;

int main(){
  long long N;
  cin >> N;
  long long p, S;
  S=N;
  p=1;
  for (int i=0; i<=60; i++){
    S=min(N/p+i+N%p, S);
    p=2*p;
  }
  cout << S << endl;
}


#include<bits/stdc++.h>

using namespace::std;

long mat[10000][10000];

class Advertisement{
    public:
        void set_val(int x,int y,int inr);
        long get_height();
        long get_width();
        long obtain_patch(long mode);
        long a;
        long b;
        long c;
        long d;
        long s;
        long r;
        long mode1;
        long mode2;
        long mode3;
        long mode4;
};

void Advertisement::set_val(int x,int y,int inr){
    a = x;
    b = y;
    c = x+1;
    d = y+1;
    r = inr;
    mode1 = 1;
    mode2 = 1;
    mode3 = 1;
    mode4 = 1;
    mat[a][b] = 1;
    s = 1;
}

long Advertisement::obtain_patch(long mode){ //mode:1->left 2->right 3->upper 4->lower
    if(mode == 1){
        if(a-1<0 || mode1 != 1){
            return -1;
        }else{
            for(int i=b;i<d;i++){
                if(mat[a-1][i] != 0){
                    mode1 = -1;
                    return -1;
                }
            }
            for(int i=b;i<d;i++){
                mat[a-1][i] = 1;
            }
            s += get_height();
            a-=1;
        }
    }else if(mode == 2){
        if(c>9999 || mode2 != 1){
            return -1;
        }else{
            for(int i=b;i<d;i++){
                if(mat[c][i] != 0){
                    mode2 = -1;
                    return -1;
                }
            }
            for(int i=b;i<d;i++){
                mat[c][i] = 1;
            }
            s += get_height();
            c+=1;
        }
    }else if(mode == 3){
        if(b-1<0 || mode3 != 1){
            return -1;
        }else{
            for(int i=a;i<c;i++){
                if(mat[i][b-1] != 0){
                    mode3 = -1;
                    return -1;
                }
            }
            for(int i=a;i<c;i++){
                mat[i][b-1] = 1;
            }
            s += get_width();
            b-=1;
        }
    }else{
        if(d>9999 || mode4 != 1){
            return -1;
        }else{
            for(int i=a;i<c;i++){
                if(mat[i][d] != 0){
                    mode4 = -1;
                    return -1;
                }
            }
            for(int i=a;i<c;i++){
                mat[i][d] = 1;
            }
            s += get_width();
            d+=1;
        }
    }
    return 0;
}

long Advertisement::get_width(){
    return d-b;
}

long Advertisement::get_height(){
    return c-a;
}

int main(){
    long n;
    cin >> n;
    long x,y,r;
    Advertisement *ad = new Advertisement[n];
    for(int i=0;i<n;i++){
        cin >> x >> y >> r;
        ad[i].set_val(x,y,r);
    }
    clock_t start,time;
    start = clock();
    bool notstop = true;
    while(notstop){
        for(int i=0;i<n && notstop;i++){
            for(int j=1;j<5 && notstop;j++){
                time = clock();
                if((double)(time-start)/CLOCKS_PER_SEC > 4.8){
                    notstop = false;
                }
                ad[i].obtain_patch(j);
            }
        }
    }

    for(int i=0;i<n;i++){
        cout << ad[i].a << ' ' << ad[i].b << ' ' << ad[i].c << ' ' << ad[i].d << ' ' << endl;
    }
}

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

typedef long long ll;
typedef unsigned long long ull;

#define mp make_pair
#define fr first
#define sc second

int n;
int x[202],y[202],r[202];

struct A{
	int a[202],b[202],c[202],d[202];
	void out(){
		for(int i=0;i<n;i++){
			printf("%d %d %d %d\n",a[i],b[i],c[i],d[i]);
		}
	}
};

int main(){
	scanf("%d",&n);
	for(int i=0;i<n;i++)scanf("%d%d%d",&x[i],&y[i],&r[i]);

	A ans;
	for(int i=0;i<n;i++){
		ans.a[i]=x[i]; ans.c[i]=x[i]+1;
		ans.b[i]=y[i]; ans.d[i]=y[i]+1;
	}
	ans.out();
}


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

typedef long long ll;
typedef unsigned long ul;

int main() {
    int n; //木の頂点の数
    scanf("%d", &n);
    vector<int> p(n, -1), c(n, 1), d(n, 0);
    // p[i]: iの親
    // c[i]: iを根とする部分木の濃度
    // d[i]: iに進んだ時に獲得できる個数
    vector<vector<int>> ch(n);
    // ch[i]: iの子
    rep(i, n - 1) {
        scanf("%d", &p[i + 1]);
        p[i + 1]--;
        ch[p[i + 1]].push_back(i + 1);
    }
    rep(i, n - 1) {
        c[p[n - 1 - i]] += c[n - 1 - i];
    }
    for (int i = n - 1; i >= 0; i--) {
        int epp = 0; //偶数個の木に進んで得するとき取れる数
        int epm = 0; //偶数個の木に進んで得するとき取られる数
        int emp = 0; //偶数個の木に進んで損するとき取れる数
        int emm = 0; //偶数個の木に進んで損するとき取られる数
        vector<pair<int, int>> od(0);
        //奇数個の木に進んだとき(取られる-取れる, 取れる);
        rep(j, ch[i].size()) {
            int u = ch[i][j];
            if (c[u] % 2) {
                od.push_back(make_pair(c[u] - d[u] * 2, d[u]));
            } else {
                if (d[u] > c[u] - d[u]) {
                    epp += d[u];
                    epm += c[u] - d[u];
                } else {
                    emp += d[u];
                    emm += c[u] - d[u];
                }
            }
        }
        if (od.size() == 0) {
            d[i] += epp + emp;
        } else {
            d[i] += epp;
            if (od.size() % 2) {
                d[i] += emm;
            } else {
                d[i] += emp;
            }
            sort(od.begin(), od.end());
            rep(j, od.size()) {
                if (j % 2) {
                    d[i] += od[j].first + od[j].second;
                } else {
                    d[i] += od[j].second;
                }
            }
        }
    }
    printf("%d\n", n - d[0]);
    //rep(i, n) cout << d[i] << " "; cout << "\n";
}

#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define R cin>>
#define ll long long
#define ln cout<<'\n'
#define in(a) insert(a)
#define pb(a) push_back(a)
#define pd(a) printf("%.10f\n",a)
#define mem(a) memset(a,0,sizeof(a))
#define all(c) (c).begin(),(c).end()
#define iter(c) __typeof((c).begin())
#define rrep(i,n) for(ll i=(ll)(n)-1;i>=0;i--)
#define REP(i,m,n) for(ll i=(ll)(m);i<(ll)(n);i++)
#define rep(i,n) REP(i,0,n)
#define tr(it,c) for(iter(c) it=(c).begin();it!=(c).end();it++)
ll check(ll n,ll m,ll x,ll y){return x>=0&&x<n&&y>=0&&y<m;}void pr(){ln;}
template<class A,class...B>void pr(const A &a,const B&...b){cout<<a<<(sizeof...(b)?" ":"");pr(b...);}
template<class A>void PR(A a,ll n){rep(i,n)cout<<(i?" ":"")<<a[i];ln;}
const ll MAX=1e9+7,MAXL=1LL<<61,dx[8]={-1,0,1,0,-1,-1,1,1},dy[8]={0,1,0,-1,-1,1,1,-1};
typedef pair<ll,ll> P;

void Main() {
  ll n;
  R n;
  ll a[n],b[n];
  rep(i,n) R a[i];
  rep(i,n) R b[i];
  ll Ma=0,ans=0;
  rep(i,n) {
    Ma=max(Ma,a[i]);
    ans=max(ans,Ma*b[i]);
    pr(ans);
  }
}

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


#include<iostream>
#include<string>
#include<iomanip>
#include<cmath>
#include<vector>
#include<algorithm>
#include<utility>

using namespace std;

#define int long long
#define endl "\n"

constexpr long long INF = (long long)1e18;
constexpr long long MOD = 1'000'000'007;

struct fast_io {
	fast_io(){
		std::cin.tie(nullptr);
		std::ios::sync_with_stdio(false);
	};
} fio;

signed main(){
	cout<<fixed<<setprecision(10);

	int N;
	int a = 0, b = 0;
	vector<int> T;
	vector<int> dp;

	cin>>N;

	T.resize(N);
	dp.resize(110000, INF);
	dp[0] = 0;

	for(int i = 0; i < N; i++){
		cin>>T[i];
	}

	for(int i = 0; i < N; i++){
		vector<int> ndp(110000, INF);

		for(int j = (int)dp.size()-1; j >= 0; j--){
			if(j+T[i] < dp.size()) {
				ndp[j+T[i]] = min(ndp[j+T[i]], dp[j]);
			}

			ndp[j] = min(dp[j] + T[i], ndp[j]);
		}

		swap(ndp, dp);
		// cout<<endl;
		// cout<<"====== "<<i<<" T = "<<T[i]<<endl;
		// for(int i = 0; i <= 20; i++){
			// cout<<i<<" <><> "<<dp[i]<<" "<<endl;
		// }
		// cout<<endl;
	}

	int ans = INF;
	for(int i = 0; i < dp.size(); i++){
		ans = min(ans, max(dp[i], i));
	}

	cout<<ans<<endl;

	// sort(T.begin(), T.end(), greater<int>());

	// for(int i = 0; i < N; i++){
		// if(a < b) {
			// a += T[i];
		// } else {
			// b += T[i];
		// }
	// }

	// cout<<max(a, b)<<endl;;

	return 0;
}

#include<bits/stdc++.h>
#include<cmath>
#define pb push_back
#define ld long double
#define mp make_pair
#define vl vector<ll>
#define vd vector<double>
#define vld vector<long double>
#define ll long long int
#define pl pair<ll, ll>
#define all(a) a.begin(), a.end()
#define forr(i, n) for(ll i=0; i<n; i++)
#define forr1(i, n) for(ll i=1; i<=n; i++)
using namespace std;
const ld PI =3.1415926535897923846;
const ll MOD = 1000000007;
const ll N=998244353;
ll power(ll x,ll n){ll res=1;while(n>0){if(n&1) res=res*x%MOD;x=x*x%MOD;n>>=1;}return res;}
ll modinverse(ll a){return power(a, MOD-2);}
ll n, m;
vl a, b;
int dp[1001][1001];
ll ans(ll ind1, ll ind2)
{
	if(ind1==n||ind2==m)
		return max(n-ind1, m-ind2);
	if(dp[ind1][ind2]!=-1) return dp[ind1][ind2];
	if(a[ind1]==b[ind2])
	{
		// either take these
		return dp[ind1][ind2]=min({
			ans(ind1+1, ind2+1),
			1+ans(ind1+1, ind2),
			1+ans(ind1, ind2+1),
		});
	}
	else
	{
		return dp[ind1][ind2]=min({
			1+ans(ind1+1, ind2+1),
			1+ans(ind1+1, ind2),
			1+ans(ind1, ind2+1),
		});
	}
}
void solve()
{
    cin>>n>>m;
    a.resize(n);
    b.resize(m);
    forr(i, n)
    {
    	cin>>a[i];
    }
    forr(i, m)
    {
    	cin>>b[i];
    }
    forr(i, n+1) forr(j, m+1) dp[i][j]=-1;
    cout<<ans(0, 0)<<endl;
}
int main()
{
	#ifndef ONLINE_JUDGE
        // for getting input from input.txt
        freopen("input.txt", "r", stdin);
        // for writing output to output.txt
        freopen("output.txt", "w", stdout);
    #endif
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    ll test=1;
    //cin>>test;
    while(test--)
    {
        solve();
    }
    cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC << "ms\n";
}


#include<bits/stdc++.h>
using namespace std;
int main()
{
    long long int a,b,res,ans;
    cin >>a>>b;
    ans=(2*a)+100;
    if(b<=ans)
    {
        res=ans-b;
    }
    cout<<res<<endl;

    return 0;
}

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

void solve(){
    int a,b;
    cin>>a>>b;
    cout<<2*a+100-b;

}

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


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

vector<long long> base_n(long long n, long long M){
    vector<long long> basen;
    while(M>0){
        basen.push_back(M%n);
        M/=n;
    }
    return basen;
}

int check(long long n, long long M, string X){
    vector<long long> basen = base_n(n,M);
    int ketasuu = basen.size();
    if(ketasuu>X.size()){
        return 1;
    }else if(ketasuu<X.size()){
        return 0;
    }else if(ketasuu==X.size()){
        for(int j=0;j<X.size();j++){
            if(basen[ketasuu-j-1]>X[j]-'0'){
                return 1;
            }else if(basen[ketasuu-j-1]<X[j]-'0'){
                return 0;
            }
        }
        return 2;
    }
    return -1;
}

int main(){
    string X;
    long long M;
    cin >> X >> M;
    int digit_max = 0;
    for(int i=0;i<X.size();i++){
        digit_max = max(digit_max, X[i] - '0');
    }
    long long ans = 0;
    long long start = digit_max;
    long long right = M+1;
    long long left = start;
    long long mid = (left+right)/2;
    if(X.size()==1){
        if((X[0] - '0')<=M){
            ans=1;
        }else{
            ans=0;
        }
    }
    else{
        while(left+1<right){
            mid = (left+right)/2;
            //cout << mid << endl;
            if(check(mid,M,X)==1){
                left = mid;
            }else if(check(mid,M,X)==0){
                right = mid;
            }else if(check(mid,M,X)==2){
                left = mid;
            }
        }
        ans = left-start;
    }
    cout << ans << endl;
}


#include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>

using namespace std;

typedef long long ll;

#define MOD 1000000007

ll getXOR(ll BITree[], ll index) {
  ll ans = 0;
  index += 1;
  while (index > 0) {
    ans ^= BITree[index];
    index -= index & (-index);
  }
  return ans;
}

void updateBIT(ll BITree[], ll n, ll index, ll val) {
  index = index + 1;
  while (index <= n) {
    BITree[index] ^= val;
    index += index & (-index);
  }
}

ll* constructBITree(ll arr[], ll n) {
  ll* BITree = new ll[n + 1];
  for (ll i = 1; i <= n; i++) BITree[i] = 0;
  for (ll i = 0; i < n; i++) updateBIT(BITree, n, i, arr[i]);

  return BITree;
}

ll rangeXor(ll BITree[], ll l, ll r) {
  return getXOR(BITree, r) ^ getXOR(BITree, l - 1);
}

int main() {
  int n, q;
  cin >> n >> q;
  ll a[n];
  for (int i = 0; i < n; ++i) {
    cin >> a[i];
  }
  ll* BITree = constructBITree(a, n);
  while (q--) {
    ll t, x, y;
    cin >> t >> x >> y;
    if (t == 1) {
      x--;
      a[x] ^= y;
      updateBIT(BITree, n, x, y);
    } else {
      x--, y--;
      cout << rangeXor(BITree, x, y) << "\n";
    }
  }
  return 0;
}

#include <bits/stdc++.h>

typedef long long int ll;
typedef long double ld;
typedef unsigned long long int ull;
typedef long int li;

#define fastio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define test ll t; cin >> t; while(t--)
const long long int cons = 300005;
const long long int N = 100005;
const long long int MOD = 1000000007;
// const long long int MOD = 998244353;
const long long int const_INT_MAX = 1000000000000000000;
const long long int const_INT_MIN = -1 * 1000000000000000000;

using namespace std;
// to sort pair vector in reverse order
bool sortinrev(const pair<ll,ll> &a, const pair<ll,ll> &b){
    return (a.first > b.first);
}
// to sort pair vector according to the second elements
bool sortbysec(const pair<ll,ll> &a, const pair<ll,ll> &b){
    return (a.second < b.second);
}
// to sort pair vector according to the second elements in reverse order
bool sortbysecinrev(const pair<ll,ll> &a, const pair<ll,ll> &b){
    return (a.second > b.second);
}
ll lcm(ll x, ll y){
    return (ll)((x * y) / __gcd(x, y));
}
map<ll, ll> primeFact(ll n){
    map<ll, ll> mp;
    while(n % 2 == 0){
       mp[2]++;
       n = n / 2;
    }
    for(ll i=3;i<=sqrt(n);i+=2){
        while(n % i == 0){
            mp[i]++;
            n = n / i;
        }
    }
    if(n > 2){
        mp[n]++;
    }
    return mp;
}
ll mod_expo(ll x, ll y, ll p){
    // reference from GFG
    ll res = 1;
    if((x + p) % p == 0){
        res = 0;
    }
    else {
        x = (x + p) % p;
        while (y > 0){
            if (y & 1){
                res = (res*x + p) % p;
            }
            y = y>>1;
            x = (x*x + p) % p;
        }
    }
    return res;
}
struct Segtree {
    ll siz;
    vector<ll> ar;
    ll oper(ll a, ll b){
        return (ll)(a ^ b);
    }
    void init(ll n){
        siz = 1;
        while(siz < n){
            siz = siz * 2;
        }
        ar.assign(2 * siz, (ll)(0));
    }
    ll query(ll v, ll l, ll r, ll l_bound, ll r_bound){
        if(l >= r_bound || r <= l_bound){return 0;}
        if(l >= l_bound && r <= r_bound){return ar[v];}

        ll mid = l + (r - l) / 2;
        return oper(query(v*2+1, l, mid, l_bound, r_bound), query(v*2+2, mid, r, l_bound, r_bound));
    }
    void update(ll v, ll l, ll r, ll pos, ll val){
        if(!(r - (l + 1))){
            ar[v] = val;
        }
        else {
            ll mid = l + (r - l) / 2;
            if(pos < mid){
                update(v*2+1, l, mid, pos, val);
            }
            else {
                update(v*2+2, mid, r, pos, val);
            }
            ar[v] = oper(ar[v*2+1], ar[v*2+2]);
        }
    }
};
int main(){
    #ifdef n00bie_1004_local
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
    fastio
    /* ll p = MOD;
    InverseofNumber(p);
    InverseofFactorial(p);
    factorial(p); */
    ll n, q; cin >> n >> q; ll a[n];
    Segtree seg; seg.init(n);
    for(ll i=0;i<n;i++){
        cin >> a[i];
        seg.update(0, 0, n, i, a[i]);
    }
    for(ll i=0;i<q;i++){
        ll typ; cin >> typ;
        if(!(typ - 1)){
            ll x, y; cin >> x >> y; x--;
            a[x] ^= y;
            seg.update(0, 0, n, x, a[x]);
        }
        else if(!(typ - 2)){
            ll l, r; cin >> l >> r; l--;
            ll ans = seg.query(0, 0, n, l, r);
            cout << ans << "\n";
        }
    }
}


#include <bits/stdc++.h>

using namespace std;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;

#define REP(i, n, m) for(ll i=n; i<(ll)m; ++i)
#define IREP(i, n, m) for(ll i=n-1; i>=m; --i)
#define rep(i, n) REP(i, 0, n)
#define irep(i, n) IREP(i, n, 0)
#define all(v) v.begin(), v.end()
#define vprint(v) for(auto e:v){cout<<e<<" ";};cout<<endl;
#define vvprint(vv) for(auto v:vv){vprint(v)};

class FenwickTree{
    public:
        ll size;
        vll v;

        FenwickTree(ll n){
            this->size = n;
            ll m = 1;
            while(n>m) m *= 2;
            this->v = vll(m, 0);
        }

        ll _get(ll x){
            ll lsb = x & -x;
            ll r = x - lsb;
            if(r>0) return this->v[x-1] + _get(r);
            return this->v[x-1];
        }

        ll get(ll left, ll right){
            if(left<=0) return _get(right+1);
            return _get(right+1) - _get(left);
        }

        void update(ll x, ll e){
            this->v[x] += e;
            if(x==this->v.size()-1) return;
            ll lsb = (x+1) & -(x+1);
            update(x+lsb, e);
        }
};

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

    ll N, M, Q;
    cin >> N >> M >> Q;
    vll T(Q), X(Q), Y(Q);
    rep(i, Q) cin >> T[i] >> X[i] >> Y[i];

    vll a(N, 0), b(M, 0);

    vvll ua(Q, vll(2, -1)), ub(Q, vll(2, -1));
    rep(i, Q){
        if(T[i]==1){
            ua[i] = {a[X[i]-1], Y[i]};
            a[X[i]-1] = Y[i];
        }
        else{
            ub[i] = {b[X[i]-1], Y[i]};
            b[X[i]-1] = Y[i];
        }
    }

    FenwickTree fa(Q+1), fb(Q+1), ca(Q+1), cb(Q+1);
    ca.update(0, N);
    cb.update(0, M);
    set<ll> ys = set<ll>(all(Y));
    ys.insert(0);
    vll sys;
    for(ll y : ys) sys.push_back(y);
    unordered_map<ll, ll> y_idx;
    rep(i, sys.size()) y_idx[sys[i]] = i;

    ll t = 0;
    rep(i, Q){
        if(T[i]==1){
            ll da = fb.get(0, y_idx[ua[i][1]]) - fb.get(0, y_idx[ua[i][0]]);
            t += cb.get(0, y_idx[ua[i][1]]) * ua[i][1] - da - cb.get(0, y_idx[ua[i][0]]) * ua[i][0];
            fa.update(y_idx[ua[i][0]], -ua[i][0]);
            fa.update(y_idx[ua[i][1]], ua[i][1]);
            ca.update(y_idx[ua[i][0]], -1);
            ca.update(y_idx[ua[i][1]], 1);
        }
        else{
            ll db = fa.get(0, y_idx[ub[i][1]]) - fa.get(0, y_idx[ub[i][0]]);
            t += ca.get(0, y_idx[ub[i][1]]) * ub[i][1] - db - ca.get(0, y_idx[ub[i][0]]) * ub[i][0];
            fb.update(y_idx[ub[i][0]], -ub[i][0]);
            fb.update(y_idx[ub[i][1]], ub[i][1]);
            cb.update(y_idx[ub[i][0]], -1);
            cb.update(y_idx[ub[i][1]], 1);
        }
        cout << t << endl;
    }
}

//#include <atcoder/all>
#include <bits/stdc++.h>
#include <cassert>
#include <numeric>
using namespace std;
//using namespace atcoder;
typedef  long long LONG;
const int MOD = 1000000007;

int gcd(int x, int y) {
	if (x % y == 0) {
		return y;
	}
	else {
		return gcd(y, x % y);
		//x%y==0でないときはユーグリットの互除法を使って再帰的に関数を呼び出す。
	}
}
LONG pow2(long long x, long long n) {
	long long ret = 1;
	while (n > 0) {
		if (n & 1) ret = ret * x % MOD;  // n の最下位bitが 1 ならば x^(2^i) をかける
		x = x * x % MOD;
		n >>= 1;  // n を1bit 左にずらす
	}
	return (int)ret;
}
void printVector(const vector<int>& vec) {
	for (int value : vec) {
		cout << value << " ";
	}
	cout << endl;
}
LONG t(LONG N, LONG i) {
	return N - abs(i);
}
int count(vector<int>&a, int s) {
	int result = 0;
	for (int i = 0; i < a.size(); i++) {
		if (a[i] == s) {
			result++;
		}
	}
	return result;
}

LONG kaizyo(int N) {
	LONG result = 1;
	LONG mod = 998244353;

	for (LONG i = 2; i <= N; i++) {
		result *= i;
		result = result % mod;
	}
	return result;
}
class Point {
public:
	int x;
	int y;
};
LONG stock[3500][3500];
LONG test(int N, int task) {
	LONG mod = 998244353;
	if (N < task)return 0;
	if (N < 0)return 0;
	if (task == 0) {
		if (N == 0) {
			return 1;
		}
		else {
			return 0;
		}

	}

	if (stock[N][task] > 0)return stock[N][task];
	stock[N][task] = (test(N - 1, task - 1) + test(N, task * 2)) % mod;

	return stock[N][task] % mod;
}
class DP {
public:
	DP() {

	}
	DP(int a, int b) {
		other = a;
		path = b;

	}
	int other;
	int path;
};

void dp(vector<vector<DP>>& list, vector<int> &able, int pos, int limit) {
	for (int i = 0; i < list[pos].size(); i++) {
		if (list[pos][i].path <= limit) {
			if (able[list[pos][i].other] == 0) {
				able[list[pos][i].other] = 1;
				dp(list, able, list[pos][i].other, limit);
			}
		}
	}
}
int main() {
	LONG a, b, x, y;
	cin >> a >> b >> x >> y;
	if (y > 2*x) {
		if (b >= a) {
			cout << (b - a)*2*x + x;
			return 0;
		}
		else {
			cout << (a - b - 1)*2*x + x;
			return 0;

		}

	}
	if (b >= a) {
		cout << (b - a)*y + x;
		return 0;
	}
	else {
		cout << (a - b - 1)*y + x;
		return 0;

	}

	return 0;

}


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

int main(){

vector<int> a(200100);
int n;
cin >> n;
int k=0;
for(int i=0; i<n; i++){
    int p;
    cin >> p;
    a[p]++;
    while(k<200010){
        if(a[k]==0) {
            cout << k << endl;
            break;
        }
        else k++;
    }
}

/*
for(int i=0; i<n; i++){
    for(int j=0; j<200100; j++){
        if(a[j]==0) {
            cout << a[j] << endl;
            break;
        }
    }
}
*/

}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int sz = 2e5+5;

typedef pair <int,int> pii;
#define x first
#define y second

int w[sz], b[sz], p[sz], g[sz];
bitset <sz> vis;

int main() {
   int n;
   cin >> n;
   for(int i=1; i<=n; i++) scanf("%d", &w[i]);
   for(int i=1; i<=n; i++) scanf("%d", &b[i]);
   for(int i=1; i<=n; i++) scanf("%d", &p[i]);

   for(int i=1; i<=n; i++) {
      if(p[i] == i) {
         vis[i] = 1;
         continue;
      }
      if(b[p[i]] >= w[i]) {
         puts("-1");
         exit(0);
      }
      g[p[i]] = i;
   }

   vector <pii> ans;
   for(int i=1; i<=n; i++) {
      if(vis[i]) continue;
      vector <int> now;
      int u = i;
      while(!vis[u]) {
         vis[u] = 1;
         now.push_back(u);
         u = g[u];
      }
      int smol = 0;
      for(int j=0; j<now.size(); j++) {
         int p1 = now[j], p2 = now[smol];
         if(b[p[p1]] < b[p[p2]]) smol = j;
      }
      rotate(now.begin(), now.begin()+smol, now.end());
      for(int j=1; j<now.size(); j++) ans.emplace_back(now[j-1], now[j]);
   }

   printf("%d\n", ans.size());
   for(auto &p : ans) printf("%d %d\n", p.x, p.y);
}


#include <bits/stdc++.h>
using namespace std;
using ll         = long long;
constexpr ll MOD = 1000000007;
#define REP(i, n) for (ll i = 0; i < (n); i++)
#define REP2(i, x, n) for (ll i = x; i < (n); i++)
#define PR(x) cout << (x) << "\n"
#define PS(x) cout << (x) << " "
#define PRYES(x) PR((x) ? "Yes" : "No")
const long long INF          = numeric_limits<long long>::max();
template <class T> using arr = vector<vector<T> >;
using vint                   = vector<int>;
using vll                    = vector<ll>;
// SourceTest用出力マクロ
#ifdef SOURCE_TEST
#define SPR(x) PR(x)
#define SPS(x) PS(x)
#define STRACE(var) cout << #var << "=" << var << endl;
#else
#define SPR(x) \
    {}
#define SPS(x) \
    {}
#define STRACE(var) \
    {}
#endif
int main() {
    ll n;
    cin >> n;
    PR(n >= 0 ? n : 0);
    return 0;
}

#include <bits/stdc++.h>

using namespace std;

int main()
{
    long long  a,b,c;
    cin>>a;
    if(a>=0)
    {
           printf("%d\n",a);
    }
    else
    {
           printf("0\n");
    }

}


#include <iostream>
#include <cstdio>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <climits>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <set>
using namespace std;

#define lson 2*i
#define rson 2*i+1
#define LS l,mid,lson
#define RS mid+1,r,rson
#define UP(i,x,y) for(i=x;i<=y;i++)
#define DOWN(i,x,y) for(i=x;i>=y;i--)
#define MEM(a,x) memset(a,x,sizeof(a))
#define W(a) while(a)
#define gcd(a,b) __gcd(a,b)
#define ll long long
#define MAX 1000005
#define MOD 1000000007
#define EXP 1e-8
#define lowbit(x) (x&-x)
const ll INF = 0x1fffffffffffffff;
ll gcd(ll p,ll q){return q==0?p:gcd(q,p%q);}
ll qpow(ll p,ll q){ll f=1;while(q){if(q&1)f=f*p;p=p*p;q>>=1;}return f;}
void chmin(ll& a, ll b){ if(a > b) a = b; }
void chmax(ll& a, ll b){ if(a < b) a = b; }

ll dp[105][105];
int main () {
    int n; ll x, a[105] = {0}, ans = INF;
    cin >> n >> x;
    for (int i = 0; i < n; i++) cin >>a[i];

    for (int num = 1; num <= n; ++num) {
        // select num obj
        for (int j = 0; j < 105; ++j) for (int  k = 0; k < 105; ++k) dp[j][k] = -INF;
        dp[0][0] = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = num-1; j >= 0; --j) {
                for (int k = 0; k < num; ++k) {
                    if (dp[j][k] != -INF) {
                        chmax(dp[j+1][(k + a[i]) % num], a[i] + dp[j][k]);
                    }
                }
            }
        }
        if (dp[num][x % num] != -INF)
            chmin(ans, (x - dp[num][x % num]) / num);
    }
    cout << ans <<endl;
    return 0;
}

#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <algorithm>
#include <cassert>
#include <cfloat>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;

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

#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define repLRE(i, l, r) for (ll i = (l); i <= (r); ++i)
#define rrepLRE(i, l, r) for (ll i = (l); i >= (r); --i)
#define Sort(v) sort(v.begin(), v.end())
#define rSort(v) sort(v.rbegin(), v.rend())
#define Reverse(v) reverse(v.begin(), v.end())
#define Lower_bound(v, y) \
  distance(v.begin(), lower_bound(v.begin(), v.end(), y))
#define Upper_bound(v, y) \
  distance(v.begin(), upper_bound(v.begin(), v.end(), y))

using ll = long long;
using ull = unsigned long long;
using P = pair<ll, ll>;
using T = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vP = vector<P>;
using vT = vector<T>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vvP = vector<vector<P>>;
using dqll = deque<ll>;

ll dx[9] = {-1, 1, 0, 0, -1, -1, 1, 1, 0};
ll dy[9] = {0, 0, -1, 1, -1, 1, -1, 1, 0};

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;
}

/* Macros reg. ends here */

const ll INF = 1LL << 50;

int main() {
  // ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
  cout << fixed << setprecision(15);

  ll n, x;
  cin >> n >> x;

  vvvll dp(n + 1, vvll(n + 1, vll(n + 1, -1)));
  repLRE(i, 1, n) dp[0][i][0] = 0;
  rep(_, n) {
    ll a;
    cin >> a;
    vvvll ndp = dp;
    rep(i, n) repLRE(j, 1, n) rep(k, j) {
      if (dp[i][j][k] != -1) {
        ll ni = i + 1;
        ll nk = (dp[i][j][k] + a) % j;
        chmax(ndp[ni][j][nk], dp[i][j][k] + a);
      }
    }
    swap(ndp, dp);
  }

  ll ans = x;
  repLRE(i, 1, n) rep(k, i) {
    ll v = x - dp[i][i][k];
    if (dp[i][i][k] != -1 && v % i == 0) {
      ll tmp = v/i;
      chmin(ans, tmp);
    }
  }

  cout << ans << endl;

  return 0;
}


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

#define ll long long
#define ld long double
#define u unsigned
#define endl '\n'
#define mod 1000000007
#define quick ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);

void solve(){
   ll n;
   cin>>n;
   unordered_set<ll> s;
   for(ll a=2;a*a<=n;a++){
       ll val = a*a;
       while(val<=n){
           s.insert(val);
           val*=a;
       }
   }
   cout<<n - s.size()<<endl;
}

int main() {

  quick;
  int t=1;
//   cin>>t;

  while(t--){

      solve();
  }

}

//雪花飄飄北風嘯嘯
//天地一片蒼茫

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/rope>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
#define ll long long
#define ii pair<ll,ll>
#define iii pair<ii,ll>
#define fi first
#define se second
#define endl '\n'
#define debug(x) cout << #x << " is " << x << endl

#define pub push_back
#define pob pop_back
#define puf push_front
#define pof pop_front
#define lb lower_bound
#define up upper_bound

#define rep(x,start,end) for(auto x=(start)-((start)>(end));x!=(end)-((start)>(end));((start)<(end)?x++:x--))
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()

#define indexed_set tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update>
//change less to less_equal for non distinct pbds, but erase will bug

mt19937 rng(chrono::system_clock::now().time_since_epoch().count());

indexed_set s;

int main(){
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin.exceptions(ios::badbit | ios::failbit);

	ll p=2;
	while (p<40){
		ll b=2;
		while (true){
			ll curr=1;
			rep(x,0,p){
				curr*=b;
				if (curr>1e10) goto die;
			}
			s.insert(curr);
			b++;
		}
		die:;
		p++;
	}

	ll n;
	cin>>n;
	cout<<n-s.order_of_key(n+1)<<endl;
}


#include <bits/stdc++.h>
#define LL long long
#define PII pair<int, int>
#define PLL pair<LL, LL>
#define all_of(v) (v).begin(), (v).end()
#define sort_unique(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define fi first
#define se second
const int MAXN = 101;
//const LL INF = (LL) 1e9 + 8763;
//const LL MOD = (LL) 1e9 + 7;
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

int n, mod, k, ans[MAXN], dp[MAXN][MAXN*MAXN*MAXN];

inline int add(int x, int y) {
	int sum = x + y;
	if (sum >= mod) sum -= mod;
	return sum;
}

void solve() {
	cin >> n >> k >> mod;

	int bound = n * (n + 1) / 2 * k;
	dp[0][0] = 1;
	for (int i = 1; i <= n; i++) {
		for (int r = 0; r < i; r++) {
			int sum = 0;
			for (int j = r; j <= bound; j += i) {
				sum = add(sum, dp[i - 1][j]);
				if (j - (k + 1) * i >= 0) {
					sum = add(sum, -dp[i - 1][j - (k + 1) * i] + mod);
				}
				dp[i][j] = sum;
			}
		}
	}

	for (int i = 1; i <= n; i++) {
		int a = i - 1, b = n - i;
		for (int j = 0; j <= bound; j++) {
//			cout << "At " << i << ' ' << j << " -> " << dp[a][j] << ' ' << dp[b][j] << '\n';
			if (dp[a][j] == 0 || dp[b][j] == 0) continue;
			ans[i] = (ans[i] + (LL) dp[a][j] * dp[b][j] % mod * (k + 1) % mod) % mod;
		}
		ans[i] = (ans[i] - 1 + mod) % mod;
	}

	for (int i = 1; i <= n; i++) {
		cout << ans[i] << "\n";
	}
}

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

	int tc = 1;
//	cin >> tc;
	for (int i = 1; i <= tc; i++) {
		solve();
	}

	return 0;
}

#include <bits/stdc++.h>
#define INF32 2147483647
#define INF64 9223372036854775807
#define rep(i, l, n) for(int i = l, i##_end = n; i < i##_end; ++i)
#define rrep(i, n, l) for(int i = ((int)(n)-1), i##_end = l; i >= i##_end; --i)
#define erep(i, n) for(auto &i : n)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
using namespace std;
using ll = long long;
using ull = unsigned long long;
using P = pair<int, int>;
using vi = vector<int>;
using vii = vector<vi>;
template<class S, class T>
bool chmax(S &a, const T &b) {
  if(a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template<class S, class T>
bool chmin(S &a, const T &b) {
  if(b < a) {
    a = b;
    return 1;
  }
  return 0;
}

int main() {
  // 1. input
  ll A, B, C;
  cin >> A >> B >> C;

  bool isEven = !(C % 2);

  // 2.
  char ans = '>';
  if(A == B || (A == -B && isEven)) ans = '=';
  else if((isEven && abs(A) < abs(B)) ||
          (!isEven && ((A <= 0 && 0 <= B) || (A < 0 && B < 0 && A > B))))
    ans = '<';

  // 3. output
  cout << ans << endl;
  return 0;
}


#include<bits/stdc++.h>
using namespace std;
using ll=long long;
static const ll mod=998244353;
ll N,M;
ll sum[5005];
ll POW[5005];
ll POWM[5005];
void init(){
for(ll i=0;i<5005;i++)POW[i]=1;
  for(ll i=0;i<5005;i++){
    ll x=0;
    for(ll j=0;j<M;j++){
    x=(x+POW[j])%mod;POW[j]=(j*POW[j])%mod;
    }sum[i]=x;
  }
POWM[0]=1;for(ll i=0;i<5005;i++)POWM[i+1]=(M*POWM[i])%mod;
}
int main(){
  cin>>N>>M;init();
  ll ans=N*POWM[N];
  for(ll n1=1;n1<N;n1++)
    for(ll n2=n1+1;n2<=N;n2++)
      ans=(ans+mod-(POWM[N-n2+n1-1]*sum[n2-n1-1])%mod)%mod;
  cout<<ans<<endl;
  return 0;
}

#include<iostream>
#include<cstring>
#include<cstdio>
#include<climits>
#include<algorithm>
#include<queue>
#include<vector>
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define int long long
#define mod 998244353
using namespace std;
inline int read(){
	int f=1,ans=0; char c=getchar();
	while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
	while(c>='0'&&c<='9'){ans=ans*10+c-'0';c=getchar();}
	return f*ans;
}
const int MAXN=111;
int f[2][MAXN][MAXN*MAXN],N,fac[MAXN],ifac[MAXN],inv[MAXN],A[MAXN],sum;
int binom(int a,int b){return fac[a]*ifac[b]%mod*ifac[a-b]%mod;}
signed main(){
	//freopen("9.in","r",stdin);
	N=read(); for(int i=1;i<=N;i++) A[i]=read();
	fac[0]=fac[1]=inv[1]=ifac[0]=ifac[1]=1; for(int i=2;i<MAXN;i++) fac[i]=fac[i-1]*i%mod,inv[i]=(mod-mod/i)*inv[mod%i]%mod,ifac[i]=ifac[i-1]*inv[i]%mod;
	int cur=0; f[0][0][0]=1;
	for(int i=1;i<=N;i++){
		cur^=1; memset(f[cur],0,sizeof(f[cur]));
		for(int j=0;j<i;j++) for(int k=0;k<=sum;k++) f[cur][j][k]=f[cur^1][j][k];
		for(int j=0;j<i;j++) for(int k=0;k<=sum;k++) if(f[cur^1][j][k]) f[cur][j+1][k+A[i]]+=f[cur^1][j][k],f[cur][j+1][k+A[i]]%=mod;
		sum+=A[i];
	}
	if(sum&1){printf("0\n");return 0;}
	int Ans=0;
	for(int i=1;i<=N;i++) Ans+=f[cur][i][sum/2]*fac[i]%mod*fac[N-i]%mod,Ans%=mod;
	printf("%lld\n",Ans); return 0;
}


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

typedef long long ll;
typedef unsigned long long int ull;
#define pii pair<ll,ll>
#define vi vector<ll>
#define vii vector<pii>
#define endl "\n"
#define pb push_back
#define sq(a) ((a)*(a))
#define sz(x) (ll)(x).size()
#define all(x) (x).begin(), (x).end()
#define rall(a) (a).rbegin(),(a).rend()
#define x first
#define y second
#define debug(x) cerr<<#x<<'='<<(x)<<endl;
#define debugv(v) cerr<<#v<<" : "; for(auto x:v) cerr<<x<<' '; cerr<<endl;
#define output(x) cout<<(x ? "YES" : "NO")<<endl;
#define Output(x) cout<<(x ? "Yes" : "No")<<endl;
#define MOD (1000000007)
#define MOD2 (998244353)
#define PI acos(-1)
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);

ll gcd(ll a, ll b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}

ll exp(ll x,ll n,ll mod)
{
    ll result=1;
    while(n)
    {
        if(n & 1)
            result=(result * x)%mod;
        x=(x*x)%mod;
        n>>=1;
    }
    return result;
}

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

    int mn=101;
    for(int i=0;i<4;i++)
    {
    	int x;cin>>x;
    	mn=min(mn,x);
    }

    cout<<mn<<endl;

    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++)
#define P pair<ll,ll>
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 main(){
  int a,b,c,d;
  cin>>a>>b>>c>>d;
  cout<<min(min(a,b),min(c,d))<<endl;
}


#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
using namespace std;
//#include<boost/multiprecision/cpp_int.hpp>
//#include<boost/multiprecision/cpp_dec_float.hpp>
//namespace mp=boost::multiprecision;
//#define mulint mp::cpp_int
//#define mulfloat mp::cpp_dec_float_100
struct __INIT{__INIT(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);}} __init;
#define max3(a,b,c) max(a,max(b,c))
#define min3(a,b,c) min(a,min(b,c))
constexpr int MOD=1000000007;
//constexpr int MOD=998244353;
#define INF (1<<30)
#define LINF (lint)(1LL<<56)
#define endl "\n"
#define rep(i,n) for(lint (i)=0;(i)<(n);(i)++)
#define reprev(i,n) for(lint (i)=(n-1);(i)>=0;(i)--)
#define Flag(x) (1<<(x))
#define Flagcount(x) __builtin_popcountll(x)
#define pint pair<int,int>
#define pdouble pair<double,double>
#define plint pair<lint,lint>
#define fi first
#define se second
typedef long long lint;
int dx[8]={1,1,0,-1,-1,-1,0,1};
int dy[8]={0,1,1,1,0,-1,-1,-1};
const int MAX_N=2e5+5;
//struct edge{lint to,num;};
//vector<int> bucket[MAX_N/1000];

int main(void){
    int N;
    cin >> N;
    lint A[N],B[N];
    rep(i,N) cin >> A[i];
    rep(i,N) cin >> B[i];
    lint ans=accumulate(A,A+N,0LL);
    int n=N/2;
    lint odd[n],even[N];
    for(int i=0;i<N;i+=2) even[i/2]=B[i]-A[i];
    for(int i=1;i<N;i+=2) odd[i/2]=B[i]-A[i];
    sort(odd,odd+n,greater<lint>());
    sort(even,even+n,greater<lint>());
    rep(i,n){
        if(odd[i]+even[i]>0) ans+=odd[i]+even[i];
    }
    cout << ans << endl;
}

#include<iostream>
#include<vector>
using namespace std;
typedef long long li;
#define minimize(a,b) (a>(b)?a=(b),1:0)
#define rep(i,n) for(int i=0;i<(n);i++)
#define df 0
template<class T> void print(const T& t){ cout << t << "\n"; }
template<class T, class... Ts> void print(const T& t, const Ts&... ts) { cout << t; if (sizeof...(ts)) cout << " "; print(ts...); }

// Container コンテナ型, map以外
template< template<class ...> class Ctn,class T>
std::ostream& operator<<(std::ostream& os,const Ctn<T>& v){
  auto itr=v.begin();
  while(itr!=v.end()){
    if(itr!=v.begin())cout << " ";
    cout << *(itr++);
  }
  return os;
};

void makea(vector<vector<li>>& c,vector<li>& a){
  int n=c.size();
  rep(i,n-1){
    a[i]=c[i+1][0]-c[0][0];
  }
}
void makeb(vector<vector<li>>& c,vector<li>& b){
  int n=c.size();
  rep(j,n-1){
    b[j]=c[0][j+1]-c[0][0];
  }
}
int judgea(vector<vector<li>>& c,vector<li>& a){
  int n=c.size();
  rep(i,n-1){
    rep(j,n){
      if(a[i]!=c[i+1][j]-c[0][j]) return 0;
    }
  }
  return 1;
}
int judgeb(vector<vector<li>>& c,vector<li>& b){
  int n=c.size();
  rep(j,n-1){
    rep(i,n){
      if(b[j]!=c[i][j+1]-c[i][0]) return 0;
    }
  }
  return 1;
}
pair<li,int> mini(vector<li>& a){
  int n=a.size();
  int it=0;
  li m=0;
  rep(i,n){
    if(minimize(m,a[i])) it=i+1;
  }
  return {m,it};
}

int main(){
  int n; cin >>n;
  vector<vector<li>> c(n,vector<li>(n));
  rep(i,n) rep(j,n) cin >>c[i][j];
  if(n==1){
    print("Yes");
    print(0);
    print(c[0]);
    return 0;
  }
  vector<li> a(n-1,0),b(n-1,0);
  makea(c,a);
  if(df)print(a);
  makeb(c,b);
  if(df)print(b);
  if(!judgea(c,a)){
    print("No");
    return 0;
  }
  if(!judgeb(c,b)){
    print("No");
    return 0;
  }
  if(df)print(1);
  pair<li,int> ma=mini(a),mb=mini(b);
  li aa=c[ma.second][mb.second]-ma.first;
  li bb=-mb.first;
  vector<li> ansa(n,aa),ansb(n,bb);
  rep(i,n-1){
    ansa[i+1]=aa+a[i];
    ansb[i+1]=bb+b[i];
  }
  print("Yes");
  print(ansa);
  print(ansb);
}


#include <bits/stdc++.h>
using namespace std;
// #define LOCAL // 提出時はコメントアウト
#define DEBUG_

typedef long long ll;
const double EPS = 1e-9;
const ll INF = ((1LL<<62)-(1LL<<31));
typedef vector<ll> vecl;
typedef pair<ll, ll> pairl;
template<typename T> using uset = unordered_set<T>;
template<typename T, typename U> using mapv = map<T,vector<U>>;
template<typename T, typename U> using umap = unordered_map<T,U>;

#define ALL(v) v.begin(), v.end()
#define REP(i, x, n) for(int i = x; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define sz(x) (ll)x.size()
ll llceil(ll a,ll b) { return (a+b-1)/b; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> vector<vector<T>> genarr(ll n, ll m, T init) { return vector<vector<T>>(n,vector<T>(m,init)); }

///// DEBUG
#define DUMPOUT cerr
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
template<typename T>istream&operator>>(istream&is,vector<T>&vec){for(T&x:vec)is>>x;return is;}
template<typename T,typename U>ostream&operator<<(ostream&os,pair<T,U>&pair_var){os<<"("<<pair_var.first<<", "<<pair_var.second<<")";return os;}
template<typename T>ostream&operator<<(ostream&os,const vector<T>&vec){os<<"{";for(int i=0;i<vec.size();i++){os<<vec[i]<<(i+1==vec.size()?"":", ");}
os<<"}";return os;}
template<typename T,typename U>ostream&operator<<(ostream&os,map<T,U>&map_var){os<<"{";repi(itr,map_var){os<<*itr;itr++;if(itr!=map_var.end())os<<", ";itr--;}
os<<"}";return os;}
template<typename T>ostream&operator<<(ostream&os,set<T>&set_var){os<<"{";repi(itr,set_var){os<<*itr;itr++;if(itr!=set_var.end())os<<", ";itr--;}
os<<"}";return os;}
void dump_func(){DUMPOUT<<endl;}
template<class Head,class...Tail>void dump_func(Head&&head,Tail&&...tail){DUMPOUT<<head;if(sizeof...(Tail)>0){DUMPOUT<<", ";}
dump_func(std::move(tail)...);}
#ifndef LOCAL
#undef DEBUG_
#endif
#ifdef DEBUG_
#define DEB
#define dump(...)                                                          \
DUMPOUT << "  " << string(#__VA_ARGS__) << ": "                            \
        << "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]"        \
        << endl                                                            \
        << "    ",                                                         \
    dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif

//////////

#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")

int solve(ostringstream &cout) {
    #ifdef LOCAL
    ifstream in("../../Atcoder/input.txt");
    cin.rdbuf(in.rdbuf());
    #endif

    ll A,B;
    cin>>A>>B;

    ll N = B - A + 1;
    vecl P = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71};
    while (sz(P) > 0 && N < P.back()) P.pop_back();

    ll U = 1LL<<sz(P);
    auto dp = genarr(N+1,U+1,0LL);

    dp[0][0] = 1;
    ll ans = 0;
    rep(i,N) {
        ll x = i + A;
        ll mask = 0;
        rep(j,sz(P)) {
            if (x % P[j]) continue;
            mask += 1LL<<j;
            // if (S & (1LL<<j)) ok = false;
        }
        rep(S,U) {
            bool ok = true;
            rep(j,sz(P)) if ((mask & (1LL<<j)) && (S & (1LL<<j))) ok = false;
            if (ok) dp[i+1][S | mask] += dp[i][S];
            dp[i+1][S] += dp[i][S];
        }
        if (i == N-1) {
            rep(S,U) ans += dp[i+1][S];
        }
    }

    cout << ans << endl;

    return 0;
}

int main() {
    ostringstream oss;
    int res = solve(oss);

    cout << oss.str();
    return res;
}

#include <iostream>
main(){int H,W,A,P,K=1e5;for(std::cin>>H>>W;std::cin>>A;P+=A)K=std::min(A,K);std::cout<<P-K*H*W;}


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

#define ll          long long
#define ld          long double
#define pb          push_back
#define nl          '\n'
#define X           first
#define Y           second
#define nimble      ios::sync_with_stdio(0);cin.tie(0);
#define all(v)      (v).begin(),(v).end()
#define _sz(x)      (int)x.size()
#define rep(i,a,b)  for(int i=a;i<b;i++)
#define repr(i,b,a) for(int i=b;i>=a;i--)
#define preci(x)    fixed<<setprecision(x)
#define tc          int tt=1;cin>>tt;while(tt--)

#define TRACE
#ifdef TRACE
#define see(...) __f(#__VA_ARGS__,__VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
	cerr<<name<<" : "<<arg1<<nl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
    const char* comma=strchr(names+1,',');
    cerr.write(names,comma-names)<<" : "<<arg1<<" | ";
    __f(comma+1, args...);
}
#else
#endif

int inf=0x3f3f3f3f;
ll infl=0x3f3f3f3f3f3f3f3fLL;
ld infd=1.0/0.0;
const ll MOD=1e9+7;// 998244353 // = (119<<23)+1
const ld pi=2*acos(0.0);

int main(){
    nimble;
    int n,k;
    cin>>n>>k;
    vector<vector<ll>> ct(n,vector<ll>(n));
    rep(i,0,n)
        rep(j,0,n)
            cin>>ct[i][j];
    vector<int> p;
    rep(i,1,n)
        p.pb(i);
    int cnt=0;
    do{
        ll cst=0;
        int in=0;
        rep(i,0,_sz(p)){
            cst+=ct[in][p[i]];
            in=p[i];
            if(i==_sz(p)-1)
                cst+=ct[0][p[i]];
        }
        if(cst==k)
            cnt++;
    }while(next_permutation(all(p)));
    cout<<cnt;
    return 0;
}

#define _USE_MATH_DEFINES
#include <iostream>
#include <sstream>
#include <string>
#include <list>
#include <vector>
#include <queue>
#include <algorithm>
#include <climits>
#include <cstring>
#include <cmath>
#include <stack>
#include <iomanip>
#include <tuple>
#include <functional>
#include <cfloat>
#include <map>
#include <set>
#include <array>
#include <stdio.h>
#include <string.h>
#include <random>
#include <cassert>
using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
using namespace std;
#define int long long
#define CONTAINS_VEC(v,n) (find((v).begin(), (v).end(), (n)) != (v).end())
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
#define ARY_SORT(a, size) sort((a), (a)+(size))
#define REMOVE(v,a) (v.erase(remove((v).begin(), (v).end(), (a)), (v).end()))
#define REVERSE(v) (reverse((v).begin(), (v).end()))
#define ARY_REVERSE(v,a) (reverse((v), (v)+(a)))
#define REP(i, n) for (int (i)=0; (i) < (n); (i)++)
#define REPE(i, n) for (int (i)=0; (i) <= (n); (i)++)
#define CONTAINS_MAP(m, a) ((m).find((a)) != m.end())
#define CONTAINS_SET(m, a) ((m).find((a)) != m.end())
void YesNo(bool b) { cout << (b ? "Yes" : "No") << endl; exit(0); }
void Yes() { cout << "Yes" << endl; exit(0); }
void No() { cout << "No" << endl; exit(0); }

signed main()
{
	char s, t;
	cin >> s;
	cin >> t;
	if (s == 'Y')
	{
		cout << (char)(t + ('A' - 'a')) << endl;
	}
	else
	{
		cout << t << endl;
	}

}


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

#define fo(i, x, y) for (int i = (x); i <= (y); ++i)
#define fd(i, x, y) for (int i = (x); i >= (y); --i)

typedef long long ll;

const int maxn = 2e5 + 5;

int n;
ll a[maxn], s[maxn];

int getint()
{
	char ch;
	int res = 0, p;
	while (!isdigit(ch = getchar()) && (ch ^ '-'));
	p = ch == '-'? ch = getchar(), -1 : 1;
	while (isdigit(ch))
		res = (res << 3) + (res << 1) + (ch ^ 48), ch = getchar();
	return res * p;
}

int main()
{
	//freopen("t.in", "r", stdin);
	n = getint();
	fo(i, 1, n) a[i] = getint(), s[i] = s[i - 1] + a[i];
	ll sum = 0, mx = 0;
	fo(i, 1, n)
	{
		mx = max(mx, a[i]);
		sum += s[i];
		printf("%lld\n", sum + mx * i);
	}
	return 0;
}

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
// --------------------------------------------------------
template <class T>
bool chmax(T& a, const T b) {
    if(a < b) {
        a = b;
        return 1;
    }
    return 0;
}
template <class T>
bool chmin(T& a, const T b) {
    if(b < a) {
        a = b;
        return 1;
    }
    return 0;
}
#define FOR(i, l, r) for(int i = (l); i < (r); ++i)
#define RFOR(i, l, r) for(int i = (r)-1; (l) <= i; --i)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
#define MIN(c) *min_element(ALL(c))
#define MAX(c) *max_element(ALL(c))
#define SUM(c) accumulate(ALL(c), 0)
#define SUMLL(c) accumulate(ALL(c), 0LL)
#define SZ(c) ((int)(c).size())
#define CIN(c) cin >> (c)
#define COUT(c) cout << (c) << '\n'
#define debug(x) cerr << #x << " = " << (x) << '\n';
using P = pair<ll, ll>;
using VP = vector<P>;
using VVP = vector<VP>;
using VS = vector<string>;
using VI = vector<int>;
using VVI = vector<VI>;
using VLL = vector<ll>;
using VVLL = vector<VLL>;
using VB = vector<bool>;
using VVB = vector<VB>;
using VD = vector<double>;
using VVD = vector<VD>;
static const double EPS = 1e-10;
static const double PI = acos(-1.0);
static const ll MOD = 1000000007;
// static const ll MOD = 998244353;
static const int INF = (1 << 30) - 1;  // 1073741824 - 1
// static const ll INF = (1LL << 60) - 1;  // 4611686018427387904 - 1

const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
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; }

// メモ化意味あんのかなぁ？？わかんないからコンテスト終わったらメモ化実験する
double dp[101][101][101];
int n;
bool found[101][101][101];
double rec(int a, int b, int c) {
    if(a < 0 || b < 0 || c < 0) {
        return 0;
    }
    if(a >= 100 || b >= 100 || c >= 100) return 1 / 3;
    if(found[a][b][c]) return dp[a][b][c];
    double val = 1;
    double total = a + b + c;
    val += rec(a + 1, b, c) * (a / total);
    val += rec(a, b + 1, c) * (b / total);
    val += rec(a, b, c + 1) * (c / total);

    found[a][b][c] = true;
    dp[a][b][c] = val;
    return val;
}
int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);

    int a, b, c;
    cin >> a >> b >> c;

    double ans = rec(a, b, c);
    cout << fixed << setprecision(15) << ans << endl;
    return 0;
}


#include <bits/stdc++.h>
#define clr(x) memset(x,0,sizeof(x))
#define For(i,a,b) for (int i=(a);i<=(b);i++)
#define Fod(i,b,a) for (int i=(b);i>=(a);i--)
#define fi first
#define se second
#define kill _z_kill
#define y0 _z_y0
#define y1 _z_y1
#define x0 _z_x0
#define x1 _z_x1
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
using namespace std;
typedef long long LL;
typedef unsigned long long ull;
typedef unsigned uint;
typedef long double LD;
typedef vector <int> vi;
typedef pair <int,int> pii;
void enable_comma(){}
string tostring(char c){
	string s="";
	s+=c;
	return s;
}
string tostring(string s){
	return "\""+s+"\"";
}
string tostring(const char *c){
	return tostring((string)c);
}
string tostring(long long x){
	if (x<0)
		return "-"+tostring(-x);
	if (x>9)
		return tostring(x/10)+tostring(char('0'+x%10));
	else
		return tostring(char('0'+x));
}
string tostring(int x){
	return tostring((long long)x);
}
string tostring(unsigned long long x){
	if (x>9)
		return tostring((long long)(x/10))+tostring(char('0'+x%10));
	else
		return tostring(char('0'+x));
}
string tostring(unsigned x){
	return tostring((long long)x);
}
string tostring(double x){
	static char res[114];
	sprintf(res,"%lf",x);
	string s=tostring(res);
	return s.substr(1,(int)s.size()-2);
}
string tostring(long double x){
	return tostring((double)x);
}
template <class A,class B> string tostring(pair <A,B> p){
	return "("+tostring(p.fi)+","+tostring(p.se)+")";
}
template <class T> string tostring(T v){
	string res="";
	for (auto p : v)
		res+=(res.size()?",":"{")+tostring(p);
	return res.size()?res+"}":"{}";
}
template <class A> string tostring(A* a,int L,int R){
	return tostring(vector <A>(a+L,a+R+1));
};
template <class A> string tostring(A a,int L,int R){
	return tostring(a.data(),L,R);
}
string tostrings(){
	return "";
}
template <typename Head,typename... Tail>
string tostrings(Head H,Tail... T){
	return tostring(H)+" "+tostrings(T...);
}
#define User_Time ((double)clock()/CLOCKS_PER_SEC)
#ifdef zzd
	#define outval(x) cerr<<#x" = "<<tostring(x)<<endl
	#define outvals(...) cerr<<"["<<#__VA_ARGS__<<"]: "<<\
								tostrings(__VA_ARGS__)<<endl
	#define outtag(x) cerr<<"--------------"#x"---------------"<<endl
	#define outsign(x) cerr<<"<"#x">"<<endl
	#define outarr(a,L,R) cerr<<#a"["<<(L)<<".."<<(R)<<"] = "<<\
								tostring(a,L,R)<<endl
#else
	#define outval(x) enable_comma()
	#define outvals(...) enable_comma()
	#define outtag(x) enable_comma()
	#define outsign(x) enable_comma()
	#define outarr(a,L,R) enable_comma()
#endif
#ifdef ONLINE_JUDGE
	#ifdef assert
		#undef assert
	#endif
	#define assert(x) (!(x)?\
			cout<<"Assertion failed!"<<endl<<\
			"function: "<<__FUNCTION__<<endl<<\
			"line: "<<__LINE__<<endl<<\
			"expression: "<<#x<<endl,exit(3),0:1)
#endif
LL read(){
	LL x=0,f=0;
	char ch=getchar();
	while (!isdigit(ch))
		f=ch=='-',ch=getchar();
	while (isdigit(ch))
		x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	return f?-x:x;
}
template <class T> void ckmax(T &x,const T y){
	if (x<y)
		x=y;
}
template <class T> void ckmin(T &x,const T y){
	if (x>y)
		x=y;
}
//int Pow(int x,int y){
//	int ans=1;
//	for (;y;y>>=1,x=(LL)x*x%mod)
//		if (y&1)
//			ans=(LL)ans*x%mod;
//	return ans;
//}
//void Add(int &x,int y){
//	if ((x+=y)>=mod)
//		x-=mod;
//}
//void Del(int &x,int y){
//	if ((x-=y)<0)
//		x+=mod;
//}
//int Add(int x){
//	return x>=mod?x-mod:x;
//}
//int Del(int x){
//	return x<0?x+mod:x;
//}
//int md(LL x){
//	return (x%mod+mod)%mod;
//}
const int N=100005;
int n;
int a[N];
void solve(){
	n=read();
	For(i,1,n)
		a[i]=read();
	sort(a+1,a+n+1);
	if (n&1){
		puts("Second");
	}
	else {
		LL s0=0,s1=0;
		For(i,1,n){
			if (i&1)
				s0+=a[i];
			else
				s1+=a[i];
		}
		if (s0==s1)
			puts("Second");
		else
			puts("First");
	}
}
int main(){
	int T=read();
	while (T--)
		solve();
	return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define IOS              ios_base::sync_with_stdio(false);cin.tie(0), cout.tie(0);
#define print(a)         for(int i=0;i<(a.size());i++){cout<<a[i]<<"\n";}
#define sortt(a)         sort(a.begin(),a.end())
#define rep(i,a,b)       for(int i=a;i<b;i++)
#define int              long long
#define pb               push_back
#define PQ               priority_queue
#define F                first
#define S                second
#define mod              1000000007
#define endl             "\n"
const int N=1000005;
int calc(int n)
{
    vector<int>v1,v2;
    while(n>0)
    {
        int x=n%10;
        v1.pb(x);
        v2.pb(x);
        n=n/10;
    }
    sortt(v1);
    sort(v2.begin(),v2.end(),greater<int>());
    int maxx=0;
    int minn=0;
    int c=v2.size();
    for(int i=0;i<v2.size();i++)
    {
        if(v2[i]==0)
        {
            c--;
            continue;
        }
        maxx+=v2[i]*powl(10,c-1);
        c--;
    }
    c=v1.size();
    for(int i=0;i<v1.size();i++)
    {
        minn+=v1[i]*powl(10,c-1);
        c--;
    }
    return maxx-minn;
}
void solve()
{
    int n,k; cin>>n>>k;
    int x=n;
    while(k--)
    {
        x=calc(x);
    }
    cout<<x<<endl;
}

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

    IOS;
    int t=1;
    // cin>>t;
    while(t--)
    {
        solve();
    }
    return 0;
}


#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <vector>
#include <string>
#include <cmath>
#include <queue>
#include <deque>

using namespace std;

typedef long long ll;
typedef vector<ll> vll;
typedef tuple<ll, ll, ll> tplll;
typedef pair<ll, ll> pll;

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

const ll MOD = 1e9 + 7;

ll modpow(ll a, ll b) {
	if (b == 0) return 1;
	return modpow(a * a % MOD, b / 2) * (b & 1 ? a : 1) % MOD;
}

ll modulo(ll a) {
	a %= MOD; a += MOD; a %= MOD;
	return a;
}

void show_v( const vll l) {
    for (auto x: l) {
        cout << x << " ";
    }
    cout << endl;
}

void show_vpll( const vector<pair<ll, ll>> l) {
    for (auto x: l) {
        cout << get<0>(x) << ":" << get<1>(x) << " ";
    }
    cout << endl;
}

bool comp_tp( const tplll &lhs, const tplll &rhs )
{
    if (std::get<0>(lhs) != std::get<0>(rhs)) return std::get<0>(lhs) < std::get<0>(rhs);
    if (std::get<1>(lhs) != std::get<1>(rhs)) return std::get<1>(lhs) < std::get<1>(rhs);
    return std::get<2>(lhs) < std::get<2>(rhs);
}
bool comp_pll( const pll &lhs, const pll &rhs )
{
    if (std::get<0>(lhs) != std::get<0>(rhs)) return std::get<0>(lhs) < std::get<0>(rhs);
    if (std::get<1>(lhs) != std::get<1>(rhs)) return std::get<1>(lhs) < std::get<1>(rhs);
    else return true;
}

vll all_divisors(ll x, bool with_self=true, bool do_sort=false){
    // ex: 100 -> [2,50,4,25,5,20,10,(100 if self=true)]
    vll ret;
    for (ll i = 2; i < (ll)sqrt(x) + 1; i++) {
        if (x % i == 0) {
            ret.push_back(i);
            if (x != i*i) {
                ret.push_back(x/i);
            }
        }
    }
    if (with_self) {ret.push_back(x);}
    if (do_sort) {sort(ret.begin(), ret.end());}
    return ret;
}
unordered_map<ll, ll> prime_factors(ll x) {
    unordered_map<ll, ll> ret;
    for (ll i=2; i < sqrt(x) + 2; i++) {
        if (x % i != 0) { continue; }
        ll tmp = 0;
        while(x % i == 0) {
            tmp++;
            x = x/i;
        }
        ret[i] = tmp;
    }

    if (x != 1) {ret[x] = 1;}
    return ret;
}

long long extGCD(long long a, long long b, long long &x, long long &y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    long long d = extGCD(b, a%b, y, x);
    y -= a/b * x;
    return d;
}

ll comb(ll m, ll n) {
    if (m < n) {return 0;}
    if (n == 0) { return 1;}
    if (n == 1) { return m;}

    ll ret = 1;
    rep(i, n) {ret *= m-i;}
    rep(i, n) {ret /= i+1;}

    return ret % 3;
}

ll lucas(ll m, ll n) {
    if (m < n) {return 0;}
    if (n == 0) { return 1;}
    if (n == 1) { return m;}

    ll ret = 1;
    // cout << m << n << endl;
    while (m > 0) {
        auto c = m % 3;
        auto d = n % 3;
        ret *= comb(c, d);
        ret %= 3;
        m /= 3;
        n /= 3;
        // cout << ret << endl;
    }

    return ret % 3;
}

int main()
{
    ll n;
    cin >> n;
    vector<ll> cn(n);
    string s;
    cin >> s;
    rep(i, n) {
        char c = s[i];
        if (c == 'B') cn[i] = 0;
        if (c == 'W') cn[i] = 1;
        if (c == 'R') cn[i] = 2;
    }

    // cout << "ll" << endl;
    ll ans = 0;
    // show_v(cn);
    rep(i, n) {
        ans += lucas(n-1, i) * cn[i] + 3;
        // cout << lucas(n-1, i) * cn[i] << endl;
        ans %= 3;
    }

    if (n % 2 == 0) { ans = 3 - (ans% 3);}
    ans %= 3;

    // cout << ans << endl;
    if (ans == 0) cout << 'B' << endl;
    if (ans == 1) cout << 'W' << endl;
    if (ans == 2) cout << 'R' << endl;
    return 0;
}


#include <string>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <sstream>
#include <queue>
#include <deque>
#include <bitset>
#include <iterator>
#include <list>
#include <stack>
#include <map>
#include <set>
#include <functional>
#include <numeric>
#include <utility>
#include <limits>
#include <time.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include<unordered_set>
#include<climits>
//#include<bits/stdc++.h>
using namespace std;
using namespace std;
#define fast ios_base::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL)
/*******  All Required define Pre-Processors and typedef Constants *******/
#define SCD(t) scanf("%d",&t)
#define SCLD(t) scanf("%ld",&t)
#define SCLLD(t) scanf("%lld",&t)
#define SCC(t) scanf("%c",&t)
#define SCS(t) scanf("%s",t)
#define SCF(t) scanf("%f",&t)
#define SCLF(t) scanf("%lf",&t)
#define MEM(a, b) memset(a, (b), sizeof(a))
#define FOR(i, j, k, in) for (int i=j ; i<k ; i+=in)
#define RFOR(i, j, k, in) for (int i=j ; i>=k ; i-=in)
#define REP(i, j) FOR(i, 0, j, 1)
#define RREP(i, j) RFOR(i, j, 0, 1)
#define all(cont) cont.begin(), cont.end()
#define rall(cont) cont.end(), cont.begin()
#define FOREACH(it, l) for (auto it = l.begin(); it != l.end(); it++)
#define IN(A, B, C) assert( B <= A && A <= C)

#define REP1(m,n) for(int i=m;i<=(n);i++)
#define REP2(m,n) for(int j=m;j<=(n);j++)
#define REP3(m,n) for(int i=0;i<(n);i++)
#define REP4(m,n) for(int i=n;i>=0;i--)
#define MP make_pair
#define PB push_back
#define INF (int)1e9
#define EPS 1e-9
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define read(type) readInt<type>()
const double pi = acos(-1.0);
#define pnl printf("\n")
#define pns printf("@\t")
#define pns1(s) printf("%s",s)
#define pn(l) printf("%d\t",l)
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef map<int, int> MPII;
typedef set<int> SETI;
typedef multiset<int> MSETI;
typedef long int int32;
typedef unsigned long int uint32;
typedef long long int int64;
typedef unsigned long long int  uint64;
//int min_coin = INT_MAX;

int main()
{
	fast;
#ifndef ONLINE_JUDGE
	freopen("input2.txt", "r", stdin);
	freopen("output2.txt", "w", stdout);
#endif

	int  a, b, c, mid_ele; //preprocess();
	cin >> a >> b >> c;

	int last_ele = max(a, max(b, c));
	int first_ele = min(a, min(b, c));
	if (last_ele == a && first_ele == b)
		mid_ele = c;
	else if (last_ele == b && first_ele == c)
		mid_ele = a;
	else
		mid_ele = b;
	string s;
	if (mid_ele - first_ele != last_ele - mid_ele)
		cout << "No" << endl;
	else
		cout << "Yes";

	/*cout << "hello World" << endl;
	fprintf(stdout, "\nTIME: %.3lf sec\n", (double)clock() / (CLOCKS_PER_SEC));*/

	return 0;
}//end main*=1

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int a,b,c;
    cin>>a>>b>>c;
    vector<int>v;
    v.push_back(a);
    v.push_back(b);
    v.push_back(c);
    sort(v.begin(),v.end());
    if(v[2]-v[1]==v[1]-v[0])
        cout<<"Yes";
    else
        cout<<"No";
}


//#pragma GCC optimize ("O2")
//#pragma GCC target ("avx2")
//#include<bits/stdc++.h>
//#include<atcoder/all>
//using namespace atcoder;

#include<cstdio>

using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please

ll dph[2000], dphw[4000], *naname = dphw + 2000;
const int mod = 1e9 + 7;

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

	int H = 0, W = 0;
	char c;
	while ((c = getchar_unlocked()) >= '0') H = H * 10 + c - '0';
	while ((c = getchar_unlocked()) >= '0') W = W * 10 + c - '0';

	getchar_unlocked();
	dph[0] = 1;
	naname[0] = 1;
	ll w = 1;
	ll tmp = 1;
	rep1(i, W - 1) {
		tmp = w;
		if (getchar_unlocked() == '.') {
			dph[i] = w;
			naname[i] = w;
			w = w * 2 % mod;
		}
		else {
			dph[i] = 0;
			naname[i] = 0;
			w = 0;
		}
	}
	getchar_unlocked();

	rep1(i, H - 1) {
		if (getchar_unlocked() == '.') {
			tmp = dph[0];
			w = tmp;
			dph[0] = (tmp + dph[0]) % mod;
			naname[-i] = (tmp + naname[-i]) % mod;
		}
		else {
			w = 0;
			dph[0] = 0;
			naname[-i] = 0;
		}
		if (!(i & 7)) {
			rep1(j, W - 1) {
				if (getchar_unlocked() == '.') {
					tmp = w + dph[j] + naname[j - i];
					w += tmp - ll(double(w + tmp) / mod) * mod;
					dph[j] += tmp - ll(double(dph[j] + tmp) / mod) * mod;
					naname[j - i] += tmp - ll(double(tmp + naname[j - i]) / mod) * mod;
				}
				else {
					w = 0;
					dph[j] = 0;
					naname[j - i] = 0;
				}
			}
		}
		else {
			rep1(j, W - 1) {
				if (!(j & 7)) {
					if (getchar_unlocked() == '.') {
						tmp = w + dph[j] + naname[j - i];
						w += tmp - ll(double(w + tmp) / mod) * mod;
						dph[j] += tmp - ll(double(dph[j] + tmp) / mod) * mod;
						naname[j - i] += tmp - ll(double(tmp + naname[j - i]) / mod) * mod;
					}
					else {
						w = 0;
						dph[j] = 0;
						naname[j - i] = 0;
					}
				}
				else {
					if (getchar_unlocked() == '.') {
						tmp = w + dph[j] + naname[j - i];
						w = w + tmp;
						dph[j] = tmp + dph[j];
						naname[j - i] = tmp + naname[j - i];
					}
					else {
						w = 0;
						dph[j] = 0;
						naname[j - i] = 0;
					}
				}
			}
		}
		getchar_unlocked();
	}

	printf("%lld\n", tmp % mod);

	Would you please return 0;
}

#include<bits/stdc++.h>
#include<iostream>
#include<map>
#include<math.h>
#include<string>
#include<string.h>
#include<vector>
#include<queue>
#include<algorithm>
#include<set>
#include<stack>
#define _GLIBCXX_DEBUG
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
using namespace std;
using ll=long long;
const ll INF=5000000000000;
const ll dx[8]={1,0,-1,0,1,1,-1,-1};
const ll dy[8]={0,1,0,-1,1,-1,1,-1};
ll mod(ll x,ll m){return x & m;}
ll modinv(ll a,ll m){ll b=m,u=1,v=0;while(b){ll t=a/b;a-=t*b;swap(a,b);u-=t*v;swap(u,v);}u%=m;if(u<0){u+=m;}return u;}
ll modpow(ll a,ll n,ll m){ll res=1;while(n>0){if(n&1){res=res*a%m;}a=a*a%m;n>>=1;}return res;}
ll npow(ll a,ll n){ll res=1;while(n>0){if(n&1){res=res*a;}a=a*a;n>>=1;}return res;}
ll yaku(ll x){ll cnt=0;for(int i=1;i*i<=x;i++){if(x%i==0){if(i==x/i){cnt++;}else{cnt+=2;}}}return cnt;}
ll modwaru(ll a, ll b, ll m){a%=m;return a*modinv(b,m)%m;}
ll gcd(ll x, ll y){if(x%y==0){return y;}else{return gcd(y, x % y);}}
ll lcm(ll a, ll b){return a/gcd(a, b)*b;}
struct UnionFind{vector<ll>par;UnionFind(ll N):par(N){for(ll i=0;i<N;i++)par[i]=i;}ll root(ll x){if(par[x]==x){return x;}return par[x]=root(par[x]);}void unite(ll x,ll y){ ll rx=root(x);ll ry=root(y);if(rx==ry){return;}par[rx]=ry;}bool same(ll x,ll y){ll rx=root(x);ll ry=root(y);return rx==ry;}};

int main(){
    ll H, W, M = 1000000007;
    cin >> H >> W;
    vector<vector<char>> S(H, vector<char>(W));
    for(int i = 0; i < H; i++){
        for(int j = 0; j < W; j++) cin >> S[i][j];
    }
    vector<vector<ll>> dp(H + 1, vector<ll>(W + 1, 0)), tate(H + 1, vector<ll>(W + 1, 0)), yoko(H + 1, vector<ll>(W + 1, 0)), naname(H + 1, vector<ll>(W + 1, 0));
    dp[1][1] = 1;
    for(int i = 1; i <= H; i++){
        for(int j = 1; j <= W; j++){
            if(S[i - 1][j - 1] == '#') continue;
            tate[i][j] += tate[i - 1][j] + dp[i - 1][j];
            yoko[i][j] += yoko[i][j - 1] + dp[i][j - 1];
            naname[i][j] += naname[i - 1][j - 1] + dp[i - 1][j - 1];
            dp[i][j] += tate[i][j] + yoko[i][j] + naname[i][j];
            tate[i][j] %= M;
            yoko[i][j] %= M;
            naname[i][j] %= M;
            dp[i][j] %= M;
        }
    }
    cout << dp[H][W] << endl;
}


#include<bits/stdc++.h>
#define N 5000005
using namespace std;
int read() {
	int x=0,f=1;char c=getchar();
	while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
	while('0'<=c&&c<='9'){x=x*10+c-'0';c=getchar();}
	return x*f;
}
int n,a[N],b[N],ans;
bool tag[2005];
int main() {
	n = read();
	for(int i=1; i<=n; ++i)a[i] = read();
	for(int i=1; i<=n; ++i) {
		for(int j=1; j<=sqrt(a[i]); ++j) {
			if(a[i]%j == 0)b[++b[0]] = j,b[++b[0]] = a[i]/j;
		}
	}
	sort(b+1,b+b[0]+1);
	b[0] = unique(b+1,b+b[0]+1)-b-1;
	for(int i=1; i<=b[0]; ++i) {
		int x = b[i],now = 0,id,suc;
		memset(tag,0,sizeof(tag));
		for(int j=1; j<=n; ++j)if(a[j]%x == 0){suc = now = a[j];id = j+1;tag[j] = 1;break;}
		for(int j=id; j<=n; ++j) {
			if(a[j]%x == 0)now = __gcd(now,a[j]),tag[j] = 1;
		}
		if(now == x)suc = 1;
		else suc = 0;
		for(int j=1; j<=n; ++j)if(now > a[j])suc = 0;
		ans += suc;
	}
	cout << ans;
}

#include <algorithm>
#include <iostream>
#include <unordered_map>
#include <vector>

using namespace std;
int main() {
  int n;
  cin >> n;

  vector<int> a(n);
  for (int i = 0; i < n; ++i)
    cin >> a[i];
  int lo = *min_element(a.begin(), a.end());

  unordered_map<int, int> memo;
  for (int ai : a) {
    for (int j = 1; j * j <= ai && j < lo; ++j) {
      if (ai % j == 0) {
        memo[j] = __gcd(ai, memo[j]);
        if (ai / j < lo)
          memo[ai / j] = __gcd(ai, memo[ai / j]);
      }
    }
  }

  int ans = 1;
  for (auto [factor, terminal] : memo)
    if (factor == terminal)
      ans++;

  cout << ans;
}


#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 int         long long
#define ull         unsigned long long
#define ll          long long
#define M           998244353
#define pb          push_back
#define p_q         priority_queue
#define pii         pair<ll,ll>
#define vi          vector<ll>
#define vii         vector<pii>
#define mi          map<ll,ll>
#define mii         map<pii,ll>
#define all(a)      (a).begin(),(a).end()
#define sz(x)       (ll)x.size()
#define endl        '\n'
#define gcd(a,b)    __gcd((a),(b))
#define lcm(a,b)    ((a)*(b)) / gcd((a),(b))
#define ios         ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define mp          make_pair
#define lb          lower_bound
#define ub          upper_bound
#define F           first
#define S           second
#define rep(i, begin, end) for (int i=begin;i<end;i++)
#define repd(i, begin, end) for (int i=end-1;i>=begin;i--)
#define ini(a,n,b)  for(ll int i=0;i<n;i++) a[i]=0;
#define cset(a)     __builtin_popcountll(a)
#define hell        1000000007
#define re          resize
#define ordered_set tree<ll, null_type,less<ll>, rb_tree_tag,tree_order_statistics_node_update >
const int INF=1e18;

int powm(int a,int b,int mod)
{
  int res=1;
  while(b)
  {
    if(b&1)
    res=(res*a)%mod;
      a=(a*a)%mod;
      b>>=1;
  }

  return res;
}

int pow(int a,int b)
{
  int res=1;
  while(b)
  {
    if(b&1)
    res=(res*a);
      a=(a*a);
      b>>=1;
  }

  return res;
}

const int N = 100005;

ll dis[N];
vector<pair<int,pair<int,int> > > v[N];

signed main(void)
{ios
    #ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);freopen("answer.txt", "w", stdout);
    #endif

    int tests=1;
    // cin>>tests;
    while(tests--)
    {
       int n,m,x,y;
    cin>>n>>m>>x>>y;
    for(int i=1;i<=n;++i)
        dis[i] = INF;
    dis[x] = 0;
    for(int i=0;i<m;++i)
    {
        int x,y,t,k;
        cin>>x>>y>>t>>k;
        v[x].pb({y,{t,k}});
        v[y].pb({x,{t,k}});
    }
    set<pii> s;
    s.insert({0ll,x});
    while(!s.empty())
    {
        auto j = *s.begin();
        int x=j.F,y=j.S;
        s.erase(s.begin());
        for(auto p:v[y])
        {
            int j=p.F,k=p.S.F,l=p.S.S;
            ll u = ceil(x*1.0/l)*l;
            if(dis[j] > u + k)
            {
                s.erase({dis[j],j*1ll});
                dis[j] = u+k;
                s.insert({dis[j],j*1ll});
            }
        }
    }
    if(dis[y] == INF)
        dis[y] = -1;
    cout<<dis[y]<<endl;
    }

}

#define LOCAL
#define _USE_MATH_DEFINES
#include <array>
#include <cassert>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <iomanip>
#include <string>
#include <sstream>
#include <vector>
#include <queue>
#include <stack>
#include <list>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <complex>
#include <cmath>
#include <numeric>
#include <bitset>
#include <functional>
#include <random>
#include <ctime>

using namespace std;

template <typename A, typename B>
ostream& operator <<(ostream& out, const pair<A, B>& a) {
  out << "(" << a.first << "," << a.second << ")";
  return out;
}
template <typename T, size_t N>
ostream& operator <<(ostream& out, const array<T, N>& a) {
  out << "["; bool first = true;
  for (auto& v : a) { out << (first ? "" : ", "); out << v; first = 0;} out << "]";
  return out;
}
template <typename T>
ostream& operator <<(ostream& out, const vector<T>& a) {
  out << "["; bool first = true;
  for (auto& v : a) { out << (first ? "" : ", "); out << v; first = 0;} out << "]";
  return out;
}
template <typename T, class Cmp>
ostream& operator <<(ostream& out, const set<T, Cmp>& a) {
  out << "{"; bool first = true;
  for (auto& v : a) { out << (first ? "" : ", "); out << v; first = 0;} out << "}";
  return out;
}
template <typename U, typename T, class Cmp>
ostream& operator <<(ostream& out, const map<U, T, Cmp>& a) {
  out << "{"; bool first = true;
  for (auto& p : a) { out << (first ? "" : ", "); out << p.first << ":" << p.second; first = 0;} out << "}";
  return out;
}
#ifdef LOCAL
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
#else
#define trace(...) 42
#endif
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
  cerr << name << ": " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
  const char* comma = strchr(names + 1, ',');
  cerr.write(names, comma - names) << ": " << arg1 << " |";
  __f(comma + 1, args...);
}

typedef long long int64;
typedef pair<int, int> ii;
#define SZ(x) (int)((x).size())
template <typename T> static constexpr T inf = numeric_limits<T>::max() / 2;
const int MOD = 1e9 + 7;
mt19937 mrand(random_device{}());
int rnd(int x) { return mrand() % x; }

struct fast_ios {
  fast_ios() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(10);
  };
} fast_ios_;

typedef complex<double> point;

int main() {
  int n;
  cin >> n;
  point u, v;
  double x, y;
  cin >> x >> y;
  u = {x, y};
  cin >> x >> y;
  v = {x, y};
  point c = (u + v) / 2.0;
  u -= c;
  v -= c;

  double theta = 2 * M_PI / n;
  point ret = point{cos(theta), sin(theta)} * u + c;
  cout << ret.real() << " " << ret.imag() << endl;
  return 0;
}


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

ll GCD(ll a,ll b){ return b?GCD(b,a%b):a; }

ll A,B;
int E[73][73];

int pN;
int I[38];
ll G[38];
int dp1[1<<19], dp2[1<<19];
int dp3[1<<19];

ll solve(){
  rep(i,pN) G[i]=0;
  rep(i,pN) rep(j,pN) if(!E[I[i]][I[j]]) G[i]|=(1ll<<j);
  int N1=(pN+1)/2, N2=pN/2;
  ll N1mask = (1ll<<N1)-1;
  rep(i,1<<N1) dp1[i]=0;
  rep(i,1<<N2) dp2[i]=0;
  dp1[0]=dp2[0]=1;
  rep(d,N1) rep(p,1<<N1) if(!(p&(1<<d))) if(!(p&G[d])) dp1[p|(1<<d)]+=dp1[p];
  rep(d,N2) rep(p,1<<N2) if(!(p&(1<<d))) if(!(p&(G[d+N1]>>N1))) dp2[p|(1<<d)]+=dp2[p];
  rep(d,N2) rep(p,1<<N2) if(!(p&(1<<d))) dp2[p|(1<<d)]+=dp2[p];
  ll ans=0;
  rep(p,1<<N1){
    int mask = (1ll<<N2)-1;
    rep(d,N1) if(p&(1ll<<d)) mask &= ~(G[d]>>N1);
    dp3[p] = mask;
    ans += dp1[p]*dp2[mask];
  }
  return ans;
}

ll solve2(int x){
  int N1=(pN+1)/2, N2=pN/2;
  ll N1mask = (1ll<<N1)-1;
  ll allMask = 0; rep(d,pN) if(!E[I[d]][x]) allMask |= (1ll<<d);
  ll ans=0;
  rep(p,1<<N1) if(!(p&allMask)){
    ll mask = dp3[p] & ~(allMask>>N1);
    ans += dp1[p]*dp2[mask];
  }
  return ans;
}

int main(){
  cin>>A>>B;
  int N = B-A+1;
  rep(i,N) rep(j,N) E[i][j]=((GCD(A+i,A+j)==1)?1:0);

  pN=0;
  rep(i,N) if((A+i)%2==1) I[pN++]=i;
  ll ans = solve();
  rep(i,N) if((A+i)%2==0) ans += solve2(i);
  cout<<ans<<endl;
  return 0;
}

#include <cstdio>
#include <cassert>
long long A,B,ans,tmp;
long long a[105];
long long g[105][105];
bool fp[105];
long long gcd(long long a,long long b)
{
    if(b==0)
        return a;
    return gcd(b,a%b);
}
void dfs(long long now,int p)
{
    if(now==B+1)
    {
        ans++;
        return;
    }
    dfs(now+1,p);
    if(!fp[now-A])
    {
        for(int i=0;i<p;i++)
        {
            if(g[now-A][a[i]-A]!=1)
                return;
        }
        a[p]=now;
        dfs(now+1,p+1);
    }
}
int main()
{
    scanf("%lld%lld",&A,&B);
    for(long long i=A;i<=B;i++)
        for(long long j=A;j<=B;j++)
            g[i-A][j-A]=gcd(i,j);
    for(long long i=A;i<=B;i++)
    {
        fp[i-A]=true;
        for(long long j=A;j<=B;j++)
            if(i!=j&&g[i-A][j-A]!=1)
            {
                fp[i-A]=false;
                break;
            }
    }
    tmp=1;
    for(long long i=A;i<=B;i++)
        if(fp[i-A])
            tmp*=2;
    dfs(A,0);
    printf("%lld\n",ans*tmp);
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const ll INF=0x3f3f3f3f3f3f3f;
const double pi=3.1415926535897932384626;
inline ll read(){
	ll x=0,f=1;
	char ch=getchar();
	while(ch<'0'||ch>'9'){
		if(ch=='-') f=-1;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9'){
		x=(x<<1)+(x<<3)+(ch^48);
		ch=getchar();
	}
	return x*f;
}
const int maxn=2e5+5;
ll k,ans,a[maxn],sum[maxn];
int main(){
	k=read();
	for(int i=1;i<=k;++i){
		int x=sqrt(i);
		for(int j=1;j<=x;++j){
			if(i%j==0){
				++a[i];
				if(i/j!=j) ++a[i];
			}
		}
	}
	for(int i=1;i<=k;++i) sum[i]=sum[i-1]+a[i];
	for(int i=1;i<=k;++i) ans+=sum[k/i];
	printf("%lld\n",ans);
	return 0;
}

#include <iostream>

using namespace std;
int main(){
    int i,j,k,x,cnt = 0; cin >> x;
    for(i=1;i<=x;i++){
        for(j=1;j<=x;j++){
            if(i*j>x) break;
            for(k=1;k<=x;k++){
                if(i*j*k>x) break;
                cnt++;
            }
        }
    }
    cout << cnt << endl;
}


#include<bits/stdc++.h>
using namespace std;
#define int long long
#define TEST int t; cin>>t; while(t--)
#define pb push_back
#define pii pair <int, int>
#define vi vector <int>
#define ff first
#define ss second
#define vpii vector <pair <int, int>>
#define vvi vector <vector <int> >
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define endl "\n"
#define MAX 1e18
#define MIN INT_MIN
#define mod 1000000007

int lcm(int a, int b) {return (a * b) / (__gcd(a, b));}
//----------------------------------SEIVE---------------------------------------------//
vector<int>prime;
bitset<1000030>vis;
void seive()
{

  vis.set();
  vis[0] = false;
  vis[1] = false;
  vis[2] = true;
  prime.pb(2);

  for (int i = 3; i <= 1000030; i += 2)

    if (vis[i] == 1)
    {
      prime.pb(i);
      for (int j = i * i; j <= 1000030; j += i)
      {
        vis[j] = 0;
      }
    }

}
//----------------------------------SEIVE---------------------------------------------//

// bool isPrime(int n)
// {
//   if (n < 2) return false;
//   if (n < 4) return true;
//   if (!(n & 1))   return false;
//   if (n % 3 == 0) return false;

//   int lim = sqrt(n);
//   for (int i = 5; i <= lim; i += 6)
//     if (n % i == 0 || n % (i + 2) == 0)
//       return false;

//   return true;
// }

// map<int, int> primeFact(int n) {
//   map<int, int> mp;
//   while (n % 2 == 0) {
//     mp[2]++;
//     n = n / 2;
//   }
//   for (int i = 3; i <= sqrt(n); i += 2) {
//     while (n % i == 0) {
//       mp[i]++;
//       n = n / i;
//     }
//   }
//   if (n > 2) {
//     mp[n]++;
//   }
//   return mp;
// }

// int binomialCoeff(int n, int k)
// {
//   if (k > n)return 0;
//   int C[n + 1][k + 1];
//   int i, j;
//   for (i = 0; i <= n; i++) {
//     for (j = 0; j <= min(i, k); j++) {
//       if (j == 0 || j == i)
//         C[i][j] = 1;
//       else
//         C[i][j] = (C[i - 1][j - 1] % (mod) + C[i - 1][j] % (mod)) % (mod);
//     }
//   }

//   return C[n][k];
// }

// int countDivisors(int n) {
//   int cnt = 0;
//   for (int i = 1; i <= sqrt(n); i++) {
//     if (n % i == 0) {
//       if (n / i == i)cnt++;
//       else {
//         cnt += 2;
//       }
//     }
//   }
//   return cnt;
// }

// int reverse_number(int n) {
//   int rev = 0, r;
//   while (n != 0) {
//     r = n % 10;
//     rev = rev * 10 + r;
//     n /= 10;
//   }
//   return rev;
// }

// int perfectSquare(int n) {
//   int h = n & 0xF;
//   if (h > 9)return 0;
//   if (h != 2 && h != 3 && h != 5 && h != 6 && h != 7 && h != 8) {
//     int x = (int)floor(sqrt((double)n) + 0.5);
//     return x * x == n;
//   }
//   return 0;
// }

void solve() {

  int n;
  cin >> n;
  int m;
  cin >> m;
  int c1 = 0;
  int o = 0;
  for (int i = 0; i < n; i++) {
    string s; cin >> s;
    c1 = 0;
    for (auto p : s) {
      if (p == '1')c1++;
    }
    if (c1 & 1)o++;
  }
  cout << o*(n - o) << endl;

}
signed main()
{
// #ifndef ONLINE_JUDGE
//   freopen("input.txt", "r", stdin);
//   freopen("output.txt", "w", stdout);
// #endif
  mt19937_64 rnd(chrono::system_clock::now().time_since_epoch().count());
  ios_base :: sync_with_stdio(0);
  cin.tie(0);
  //seive();

  //TEST
  solve();

}

#define nl                  "\n"
#define ll                  long long
#define ull                 unsigned long long
#define pb                  push_back
#define SIZE(a)             (int)a.size()
#define SORT(v)             sort(v.begin(),v.end())
#define RSORT(v)            sort(v.rbegin(),v.rend())
#define REV(v)              reverse(v.begin(),v.end())
#define ff                  first
#define ss                  second
#define sq(a)               ((a)*(a))
#define For(i,a,b)          for(i=a;i<=b;i++)
#define Rof(i,a,b)          for(i=a;i>=b;i--)
#define Rep(i,b)            for(i=0;i<b;i++)
#define MOD                 1000000007
#define PI                  acos(-1.0)
#define eps                 1e-9
#define Linf                2e18
#define inf                 1<<30
#define MX5                 100005
#define MX6                 1000006
#define MX3                 1005
#define GCD(a,b)            __gcd(a,b)
#define Abs(a)              abs(a)
#define input(a,b)          scanf("%lld%lld",&a,&b)
#define in1(a)              scanf("%lld",&a)
#define output(a)           printf("%lld\n",a);
#define mem(a)              memset(a,-1,sizeof(a)) // complexity O(n)
#define clr(a)              memset(a,0,sizeof (a))
#define mk                  make_pair
#define pLL                 pair<ll,ll>
#define invcos(a)           (acos(a)*(180/3.14159265))
#define rtan(a)             (tan(a*3.14159265/180.0))
#define pip                 printf("pip")
#define Case(x)             printf("Case %lld: ",x)
#define timelimit           1.0*clock()/CLOCKS_PER_SEC
#define pc_one              __builtin_popcount
#define pcl_one             __builtin_popcountl
#define pcll_one            __builtin_popcountll
#define parity              __builtin_parity
#define parityl             __builtin_parityl
#define parityll            __builtin_parityll
#define infile              freopen("input.txt","r",stdin)
#define outfile             freopen("output.txt","w",stdout)
#define debug(x)            cerr << #x << " is " << x << endl
#define fast                ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(0);
//const ll Linf=2e18;
///4direction ->        int del_x[]={-1,0,1,0},del_y[]={0,1,0,-1};
///8direction ->        int del_x[]={-1,0,1,0,1,-1,-1,1},del_y[]={0,1,0,-1,-1,-1,1,1};

#include <bits/stdc++.h>
/*#include <iomanip>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>*/
using namespace std;
/*using namespace __gnu_pbds;

typedef tree<
int,
null_type,
less<int>,
rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
*/
ll bigmod(ll n, ll p) {if (p == 0) return 1; if (p == 1)return (n + MOD) % MOD; if (p % 2)return (bigmod(n, p - 1) * n + MOD) % MOD; else {ll x = bigmod(n, p / 2); return (x * x + MOD) % MOD;}}
ll modinverse(ll n) {return bigmod(n, MOD - 2) % MOD;}
bool check_2s_power(ll a) {return (pcll_one(a) == 1 ? true : false);}
ll check_Bit(ll n,ll k){ if(n & (1LL << k)) return true; return false; }
ll setBit(ll n, ll k){ return (n | (1LL << k)); }
ll clearBit(ll n,ll k){ return (n & (~(1LL << k))); }
ll toggleBit(ll n,ll k){ return (n ^ (1LL << k)); }

/*----------------------Graph Moves----------------*/
//const int fx[]={+1,-1,+0,+0};
//const int fy[]={+0,+0,+1,-1};
//const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1};   // Kings Move
//const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1};  // Kings Move
//const int fx[]={-2, -2, -1, -1,  1,  1,  2,  2};  // Knights Move
//const int fy[]={-1,  1, -2,  2, -2,  2, -1,  1}; // Knights Move
/*------------------------------------------------*/

int main()
{
    ll i,j,n,m,milse=0,milenai=0;
    string s,p;
    input(n,m);
    cin >> s;
    n--;
    vector<string>v(n);
    Rep(i,n)
    {
        cin >> p;
        ll counter=0;
        Rep(j,m)
        {
            if(s[j]!=p[j]) counter++;
        }
        //cout << counter << endl;
        if(counter%2) milenai++;
    }
    milse=n+1-milenai;
    output(milse*milenai);
}


#include<iostream>
#include<string>
#include<vector>
#include<set>
#include<functional>
#include<map>
#include<cmath>
#include <iterator>
#include<algorithm>
#include<queue>
#include<cstdlib>
#include<stdio.h>
#include<assert.h>
#include<sstream>
#define ff first
#define ss second
#define rep(i,a,b) for(i=a;i<b;i++)
#define uniq(v) (v).erase(unique(all(v)),(v).end())
#define pb push_back
#define pf pop_front
#define sz(x) (int)((x).size())
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define endl "\n"
using namespace std;
#define MOD 1000000007
#define vl vector<ll>
#define vpl vector<pair<ll,ll>>
typedef  long long int ll;
template<typename T, typename T1>T amax(T& a, T1 b) { if (b > a)a = b; return a; }
template<typename T, typename T1>T amin(T& a, T1 b) { if (b < a)a = b; return a; }
/*void binpow(long long a,long long n)
{
    int res = 1;
    while (n)
    {
        if (n & 1)
        {
            res = (res * a )%MOD;
            n--;
        }
        else
        {
            a = (a * a) % MOD;
            n = n / 2;
        }
    }
    cout << res<< endl;
}*/

int32_t main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(NULL);
    cout.tie(NULL);
    ll x; ll y;
    cin >> x >> y;
    cout << (abs(y - x )< 3 ? "Yes" : "No");

}

#include <bits/stdc++.h>

using namespace std;

int main()
{
   int t = 1;
   //cin>>t;
   while(t--){
       long long k;
       cin>>k;
       long long n;
       cin>>n;
       vector<long long> all;
       long long cur =0;
       for(long long i=1;i<=100;i++){
           cur+=k;
           if(cur>=100){
               all.push_back(i);
               cur-=100;
           }
       }

       long long es = n/all.size();
       //cout<<es<<endl;
       cur=(100*es);
       long long rem=n-es*all.size();
       if(rem!=0)
       cur+=all[rem-1];
       //cout<<cur<<endl;
       //cout<<(100+k)*cur<<endl;
       long long num = ((100+k)*cur)/100 -1;
       cout<<num<<endl;
   }

   return 0;
}