#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 MAXN 100005
# define INF 1000000000
# define md 1000000007
typedef long long ll;
typedef long l;
typedef tree<ll, null_type, less_equal<ll>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;
//find_by_order;used in orsered_set
// order_of_key;
# define vl vector<l>
# define vll vector<ll>
# define sl set<l>
# define sll set<ll>
# define sc set<char>
# define usl unordered_set<l>
# define usll unordered_set<ll>
# define usc unordered_set<char>
# define ml map<l,l>
# define mll map<ll,ll>
# define mcl map<char,ll>
# define umll unorderd_map<long long int,long long int>
# define umci unordered_map<char,int>
#define pll pair<ll,ll>
# define fori(i,range) for(l i=0;i<range;i++)
# define forl(i,range) for(ll i=0;i<range;i++)
# define f first
# define s second
#define pb push_back
#define db pop_back
#define MP make_pair
#define MT make_tuple

static mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

// 2-D vector with both size--> vector<vector<int> > a(n, vector<int>(m));
// (long int)(1e-7 + pow(n, 1.0 / k)); to find n^(1/k);
// in map and set time to search,insert and delete a element is logn

ll hcf(ll a,ll b)
{
	if(!a) return(b);
	else return(hcf(b%a,a));
}

ll findGCD(vector<ll>arr, ll n)
{
    ll result = arr[0];
    for (ll i = 1; i < n; i++)
    {
        result = hcf(arr[i], result);

        if(result == 1)
        {
           return 1;
        }
    }
    return result;
}

ll lcm(ll a,ll b){
	return((a*b)/hcf(a,b));

}
#define pie 3.141592653589793238462643383279

bool sortbysec(ll a,ll b)
{
    return (a>b);
}

vll primeFactors(ll n)
{
    vll ans;
    while (n % 2 == 0) {ans.pb(2);n = n / 2;}
    for (ll i = 3; i <= sqrt(n); i = i + 2) {
        while (n % i == 0) {ans.pb(i);n = n / i;}}
    if (n > 2)ans.pb(n);return ans;
}
void show(vector<ll>v,ll n)
{
    for(ll i=0;i<n;i++)
    {
        cout<<v[i]<<' ';
    }
}
int isPrime(ll n)
{
    // Corner cases
    if (n <= 1)  return 100;
    if (n <= 3)  return 0;

    // This is checked so that we can skip
    // middle five numbers in below loop
    // time complexity root of n
    if (n%2 == 0 || n%3 == 0)
    {
        if(n%2==0)
        {
            return n/2;
        }
        else{
            return n/3;
        }
    }

    for (ll i=5; i*i<=n; i=i+6)
        if (n%i == 0 || n%(i+2) == 0)
        {
            if(n%i==0)
            {
                return n/i;
            }
            else{
                return n/(i+2);
            }
        }

    return 0;
}

bool isPowerOfTwo(ll x)
    {
    return (x && !(x & (x - 1)));
    }
ll powM(ll x, ll y, ll m) {	//returns (a^b)%m ( ^ is exponent )
	ll ans = 1, r = 1;
	x %= m;
	while (r > 0 && r <= y)
	{
		if (r & y)
		{
			ans *= x;
			ans %= m;
		}
		r <<= 1;
		x *= x;
		x %= m;
	}
	return ans;
}
map<ll, ll> factorize(ll n) {	//returns map containing factor and multiplicity, Eg: 60 = {{2,2},{3,1},{5,1}}
	map<ll, ll> ans;
	for (ll i = 2; i * i <= n; i++) {
		while (n % i == 0) {
			ans[i]++;
			n /= i;
		}
	}
	if (n > 1) {
		ans[n]++;
		n = 1;
	}
	return ans;
}
ll dp[100002];

int main()

{
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
        //freopen("input.txt","r",stdin);
        //freopen("output.txt","w",stdout);
       ll n,i,a=0,j,b=0;
       cin>>n;
       vll v(n);
       forl(i,n)cin>>v[i];
       for(i=0;i<n;i++)
       {  b=0;
           for(j=i;j<n;j++)
           {
               b+=v[j];
               if(b>100*((j-i)+1))
               {
                   a=max(a,(j-i)+1);
               }
           }
       }
       cout<<a;

        return 0;
}


#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
# define MAXN 100005
# define INF 1000000000
# define md 1000000007
typedef long long ll;
typedef long l;
typedef tree<ll, null_type, less_equal<ll>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;
//find_by_order;used in orsered_set
// order_of_key;
# define vl vector<l>
# define vll vector<ll>
# define sl set<l>
# define sll set<ll>
# define sc set<char>
# define usl unordered_set<l>
# define usll unordered_set<ll>
# define usc unordered_set<char>
# define ml map<l,l>
# define mll map<ll,ll>
# define mcl map<char,ll>
# define umll unorderd_map<long long int,long long int>
# define umci unordered_map<char,int>
#define pll pair<ll,ll>
# define fori(i,range) for(l i=0;i<range;i++)
# define forl(i,range) for(ll i=0;i<range;i++)
# define f first
# define s second
#define pb push_back
#define db pop_back
#define MP make_pair
#define MT make_tuple

static mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

// 2-D vector with both size--> vector<vector<int> > a(n, vector<int>(m));
// (long int)(1e-7 + pow(n, 1.0 / k)); to find n^(1/k);
// in map and set time to search,insert and delete a element is logn

ll hcf(ll a,ll b)
{
	if(!a) return(b);
	else return(hcf(b%a,a));
}

ll findGCD(vector<ll>arr, ll n)
{
    ll result = arr[0];
    for (ll i = 1; i < n; i++)
    {
        result = hcf(arr[i], result);

        if(result == 1)
        {
           return 1;
        }
    }
    return result;
}

ll lcm(ll a,ll b){
	return((a*b)/hcf(a,b));

}
#define pie 3.141592653589793238462643383279

bool sortbysec(ll a,ll b)
{
    return (a>b);
}

vll primeFactors(ll n)
{
    vll ans;
    while (n % 2 == 0) {ans.pb(2);n = n / 2;}
    for (ll i = 3; i <= sqrt(n); i = i + 2) {
        while (n % i == 0) {ans.pb(i);n = n / i;}}
    if (n > 2)ans.pb(n);return ans;
}
void show(vector<ll>v,ll n)
{
    for(ll i=0;i<n;i++)
    {
        cout<<v[i]<<' ';
    }
}
int isPrime(ll n)
{
    // Corner cases
    if (n <= 1)  return 100;
    if (n <= 3)  return 0;

    // This is checked so that we can skip
    // middle five numbers in below loop
    // time complexity root of n
    if (n%2 == 0 || n%3 == 0)
    {
        if(n%2==0)
        {
            return n/2;
        }
        else{
            return n/3;
        }
    }

    for (ll i=5; i*i<=n; i=i+6)
        if (n%i == 0 || n%(i+2) == 0)
        {
            if(n%i==0)
            {
                return n/i;
            }
            else{
                return n/(i+2);
            }
        }

    return 0;
}

bool isPowerOfTwo(ll x)
    {
    return (x && !(x & (x - 1)));
    }
ll powM(ll x, ll y, ll m) {	//returns (a^b)%m ( ^ is exponent )
	ll ans = 1, r = 1;
	x %= m;
	while (r > 0 && r <= y)
	{
		if (r & y)
		{
			ans *= x;
			ans %= m;
		}
		r <<= 1;
		x *= x;
		x %= m;
	}
	return ans;
}
map<ll, ll> factorize(ll n) {	//returns map containing factor and multiplicity, Eg: 60 = {{2,2},{3,1},{5,1}}
	map<ll, ll> ans;
	for (ll i = 2; i * i <= n; i++) {
		while (n % i == 0) {
			ans[i]++;
			n /= i;
		}
	}
	if (n > 1) {
		ans[n]++;
		n = 1;
	}
	return ans;
}
ll dp[100002];

int main()

{
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
        //freopen("input.txt","r",stdin);
        //freopen("output.txt","w",stdout);
       ll n,i,a=0,j,b=0;
       cin>>n;
       vll v(n);
       forl(i,n)cin>>v[i];
       for(i=0;i<n;i++)
       {  b=0;
           for(j=0;j<n;j++)
           {
               b+=v[j];
               if(b>100*((j-i)+1))
               {
                   a=max(a,(j-i)+1);
               }
           }
       }
       cout<<a;

        return 0;
}


#include <iostream>

using namespace std;
int slideWindow(int i, int j, int sum, int *arr);
int main()
{
    int n(0), sum(0);
    cin >> n;
    int r[n];
    for (size_t i(0); i<n;++i)
    {
        cin >>r[i];
        sum += r[i];
    }
    int ans = slideWindow(0, n-1, sum, r);
    cout << max(ans,0) << endl;
    return 0;
}
int slideWindow(int i, int j, int sum, int *arr)
{
    int r(0);
    while (i<=j)
    {
        if (sum > (j-i+1)*100) break;
        else if(arr[i]<arr[j]) { sum -=arr[i++];  }
        else if(arr[i]>arr[j]){ sum -=arr[j--]; }
        else {
            int a = slideWindow(i+1, j, sum-arr[i], arr);
            int b = slideWindow(i, j-1, sum-arr[j], arr);
            return max(a,b);
        }
    }
    return (j-i+1);
}


#include <iostream>

using namespace std;
int main()
{
    int n(0), sum(0);
    cin >> n;
    int r[n];
    for (size_t i(0); i<n;++i)
    {
        cin >>r[i];
        sum += r[i];
    }
    int i(0);
    int j(n-1);
    while (i<=j)
    {
        if (sum > (j-i+1)*100) break;
        if(r[i]<r[j]) { sum -=r[i++];  }
        else { sum -=r[j--]; }
    }
    cout << max((j-i+1),0) << endl;
    return 0;
}


#include <iostream>

using namespace std;
int main()
{
    int n(0), sum(0);
    cin >> n;
    int r[n];
    for (size_t i(0); i<n;++i)
    {
        cin >>r[i];
        sum += r[i];
    }
    int i(0);
    int j(n-1);
    while (i<=j)
    {
        if (sum > (j-i+1)*100) break;
        if(r[i]<r[j]) { ++i; }
        else { --j; }
    }
    cout << max((j-i+1),0) << endl;
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n(0), sum(0);
    cin >> n;
    int r[n];
    for (size_t i(0); i<n;++i)
    {
        cin >>r[i];
        sum += r[i];
    }
    int i(0);
    int j(n-1);
    while (i<=j)
    {
        if (sum > (j-i+1)*100) break;
        if(r[i]<r[j]) { i++; }
        else { j--; }
    }
    cout << max((j-i+1),0) << endl;
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n(0);
    cin >> n;
    int p[n+1]={};
    int a[n];
    int maxL(0);
    for (int i=0;i<n;++i)
    {
        cin >> a[i];
        p[i+1] = p[i]+a[i];
        for (int j=0;j<= i;++j)
        {
            if (p[i+1]-p[j]>(i+1-j)*100) {
               maxL=max(i+1-j, maxL);
            }
        }
    }
    cout << maxL;
    return 0;
}


#include <iostream>

using namespace std;
int main()
{
    int n(0), sum(0);
    cin >> n;
    int r[n];
    for (size_t i(0); i<n;++i)
    {
        cin >>r[i];
        sum += r[i];
    }
    int i(0);
    int j(n-1);
    while (i<=j)
    {
        if (sum > (j-i+1)*100) break;
        if(r[i]<r[j]) { sum -=r[i++];  }
        if(r[j]<r[i]) { sum -=r[j--];  }
        else
        {
            if(r[j-1]>r[i+1]) sum -=r[i++];
            else sum -=r[j--];
        }
    }
    cout << max((j-i+1),0) << endl;
    return 0;
}


#include <iostream>

using namespace std;
int slideWindow(int i, int j, int sum, int *arr);
int main()
{
    int n(0), sum(0);
    cin >> n;
    int r[n];
    for (size_t i(0); i<n;++i)
    {
        cin >>r[i];
        sum += r[i];
    }
    int ans = slideWindow(0, n-1, sum, r);
    cout << max(ans,0) << endl;
    return 0;
}
int slideWindow(int i, int j, int sum, int *arr)
{
    int r(0);
    while (i<=j)
    {
        if (sum > (j-i+1)*100) break;
        else if(arr[i]<arr[j]) { sum -=arr[i++];  }
        else if(arr[i]>arr[j]){ sum -=arr[j--]; }
        else {
            int a = slideWindow(++i, j, sum-arr[i], arr);
            int b = slideWindow(i, --j, sum-arr[i], arr);
            return max(a,b);
        }
    }
    return (j-i+1);
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ll long long
#define pb push_back
#define oset tree <ll, null_type, greater<ll>, rb_tree_tag, tree_order_statistics_node_update>
using namespace __gnu_pbds;
using namespace std;
const ll INF = 1e10;

int main() {
	ll n;
	cin >> n;
	vector <ll> a(n + 2, 0);
	vector <ll> pre(n + 2, 0);
	for (int i1 = 1; i1 <= n; i1++) cin >> a[i1];
	for (int i1 = 1; i1 <= n; i1++){
		pre[i1] = pre[i1 - 1] + a[i1];
	}

	/*for (int i1 = 1; i1 <= n; i1++) cout << pre[i1] << " ";
	cout << endl;	*/
	ll ans = 0;
	for (int i1 = 1; i1 <= n; i1++){
		for (int i2 = 1; i2 <= n; i2++){
			/*cout << i1 << " " << i2 << " : " << pre[i2 + i1 - 1] - pre[i2 - 1] << endl;*/
			if (i1 + i2 - 1 > n) break;
			if (pre[i2 + i1 - 1] - pre[i2 - 1] > 100*i1) {ans = i1; break;}
		}
	}
	cout << ans << endl;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ll long long
#define pb push_back
#define oset tree <ll, null_type, greater<ll>, rb_tree_tag, tree_order_statistics_node_update>
using namespace __gnu_pbds;
using namespace std;
const ll INF = 1e10;

int main() {
	ll n;
	cin >> n;
	vector <ll> a(n + 2, 0);
	vector <ll> pre(n + 2, 0);
	for (int i1 = 1; i1 <= n; i1++) cin >> a[i1];
	for (int i1 = 1; i1 <= n; i1++){
		pre[i1] = pre[i1 - 1] + a[i1];
	}

	/*for (int i1 = 1; i1 <= n; i1++) cout << pre[i1] << " ";
	cout << endl;	*/
	ll ans = 0;
	for (int i1 = 1; i1 <= n; i1++){
		for (int i2 = 1; i2 <= n; i2++){
			/*cout << i1 << " " << i2 << " : " << pre[i2 + i1 - 1] - pre[i2 - 1] << endl;*/
			if (i1 + i2 - 1 >= n) break;
			if (pre[i2 + i1 - 1] - pre[i2 - 1] >= 100*i1) {ans = i1; break;}
		}
	}
	cout << ans << endl;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ll long long
#define pb push_back
#define oset tree <ll, null_type, greater<ll>, rb_tree_tag, tree_order_statistics_node_update>
using namespace __gnu_pbds;
using namespace std;
const ll INF = 1e10;

int main() {
	ll n;
	cin >> n;
	vector <ll> a(n + 2, 0);
	vector <ll> pre(n + 2, 0);
	for (int i1 = 1; i1 <= n; i1++) cin >> a[i1];
	for (int i1 = 1; i1 <= n; i1++){
		pre[i1] = pre[i1 - 1] + a[i1];
	}

	/*for (int i1 = 1; i1 <= n; i1++) cout << pre[i1] << " ";
	cout << endl;	*/
	ll ans = 0;
	for (int i1 = 1; i1 <= n; i1++){
		for (int i2 = 1; i2 <= n; i2++){
			/*cout << i1 << " " << i2 << " : " << pre[i2 + i1 - 1] - pre[i2 - 1] << endl;*/
			if (i1 + i2 - 1 >= n) break;
			if (pre[i2 + i1 - 1] - pre[i2 - 1] > 100*i1) {ans = i1; break;}
		}
	}
	cout << ans << endl;
}


#include <iostream>
#include <vector>
#include <cstdio>
#include <string>
#include <set>
#include <algorithm>
#include <unordered_map>
#include <map>
#include <unordered_set>
#include <algorithm>
#include <cmath>
#include <iomanip>
using namespace std;
typedef long long li;
typedef long double ld;
const li MAX = 5002;
using namespace std;
li n, cnt[MAX], pref[MAX];
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin >> n;
	for (int i = 0; i < n; i++) {
		li a;
		cin >> a;
		pref[i + 1]+= a;
	}
	li ans = 0;
	for (int i = 1; i <= 5000; i++) {
		pref[i] += pref[i - 1];
	}
	for (int i = 0; i <= n; i++) {
		for (int j = 0; j <= i; j++) {
			if (j == 0 && pref[i] > 100 * (i + 1)) ans = max(ans, li(i + 1));
			else if (pref[i] - pref[j - 1] > 100 * (i - j + 1)) ans = max(ans, li(i - j + 1));
		}
	}
	cout << ans << "\n";
//	system("pause");
	return 0;
}


#include <iostream>
#include <vector>
#include <cstdio>
#include <string>
#include <set>
#include <algorithm>
#include <unordered_map>
#include <map>
#include <unordered_set>
#include <algorithm>
#include <cmath>
#include <iomanip>
using namespace std;
typedef long long li;
typedef long double ld;
const li MAX = 5012;
using namespace std;
li n, cnt[MAX], pref[MAX];
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin >> n;
	for (int i = 0; i < n; i++) {
		li a;
		cin >> a;
		pref[i + 1]+= a;
	}
	li ans = 0;
	for (int i = 1; i <= 5000; i++) {
		pref[i] += pref[i - 1];
	}
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= i; j++) ans = max(ans, li(i - j + 1));
	}
	cout << ans << "\n";
//	system("pause");
	return 0;
}


#include <iostream>
#include <vector>
#include <cstdio>
#include <string>
#include <set>
#include <algorithm>
#include <unordered_map>
#include <map>
#include <unordered_set>
#include <algorithm>
#include <cmath>
#include <iomanip>
using namespace std;
typedef long long li;
typedef long double ld;
const li MAX = 5012;
using namespace std;
li n, cnt[MAX], pref[MAX];
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin >> n;
	for (int i = 0; i < n; i++) {
		li a;
		cin >> a;
		pref[i + 1]+= a;
	}
	li ans = 0;
	for (int i = 1; i <= 5000; i++) {
		pref[i] += pref[i - 1];
	}
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= i; j++) if (pref[i] - pref[j - 1] > 100 * (i - j + 1))ans = max(ans, li(i - j + 1));
	}
	cout << ans << "\n";
//	system("pause");
	return 0;
}


#include <iostream>
#include <vector>
#include <cstdio>
#include <string>
#include <set>
#include <algorithm>
#include <unordered_map>
#include <map>
#include <unordered_set>
#include <algorithm>
#include <cmath>
#include <iomanip>
using namespace std;
typedef long long li;
typedef long double ld;
const li MAX = 5002;
using namespace std;
li n, cnt[MAX], pref[MAX];
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin >> n;
	for (int i = 0; i < n; i++) {
		li a;
		cin >> a;
		pref[i + 1]+= a;
	}
	li ans = 0;
	for (int i = 1; i <= 5000; i++) {
		pref[i] += pref[i - 1];
	}
	for (int i = 0; i <= 5000; i++) {
		for (int j = 0; j <= i; j++) {
			if (j == 0 && pref[i] > 100 * (i + 1)) ans = max(ans, li(i + 1));
			else if (pref[i] - pref[j - 1] > 100 * (i - j + 1)) ans = max(ans, li(i - j + 1));
		}
	}
	cout << ans << "\n";
//	system("pause");
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
using vi = vector<i64>;
using vvi = vector<vi>;

int main() {
    int n;
    cin >> n;
    vi ok(n), as(n);
    for (int i = 0; i < n; i++) {
        cin >> as[i];
    }

    for (int i = 0; i < n; i++) {
        int sum = as[i];
        for (int j = i + 1; j < n; j++) {
            sum += as[j];
            if (sum > 100 * (j - i)) {
                ok[j] = 1;
            }
        }
    }

    int ans = 0;
    int cnt = 0;
    for (int i = 0; i < n; i++) {
        if (ok[i]) {
            cnt++;
        } else {
            ans = max(ans, cnt);
            cnt = 0;
        }
    }
    cout << max(ans, cnt) << endl;
}


#include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
using vi = vector<i64>;
using vvi = vector<vi>;

int main() {
    int n;
    cin >> n;
    vi ok(n), as(n);
    for (int i = 0; i < n; i++) {
        cin >> as[i];
    }

    for (int i = 0; i < n; i++) {
        int sum = 0;
        for (int j = i; j < n; j++) {
            sum += as[j];
            if (sum > 100 * (j - i + 1)) {
                ok[j] = 1;
            }
        }
    }

    int cnt = 0;
    for (int i = 0; i < n; i++) {
        if (ok[i]) cnt++;
    }
    cout << cnt << endl;
}


#include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
using vi = vector<i64>;
using vvi = vector<vi>;

int main() {
    int n;
    cin >> n;
    vi as(n);
    for (int i = 0; i < n; i++) {
        cin >> as[i];
    }

    int ans = 0;
    for (int i = 0; i < n; i++) {
        int sum = 0;
        for (int j = i; j < n; j++) {
            sum += as[j];
            if (sum > 100 * (j - i + 1)) {
                ans = max(ans, j - i + 1);
            }
        }
    }

    cout << ans << endl;
}


#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <algorithm>
#include <cmath>
#include <set>
#include <queue>
//#define endl '\n'

using namespace std;

typedef long long ll;
typedef vector<ll> vi;
typedef vector<vector<ll>> vvi;
typedef vector<bool> vb;
typedef pair<ll, ll> pi;
typedef map<ll, ll> mi;
typedef vector<pi> vpi;
typedef set<pi> spi;
typedef set<ll> si;

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

vi tree;

void build(vi &arr, ll ind, ll l, ll r) {
	if (l == r) {
		tree[ind] = arr[l];
		return;
	}
	ll mid = (l + r) / 2;
	build(arr, ind * 2, l, mid);
	build(arr, ind * 2+1, mid+1, r);
	tree[ind] = max(tree[ind * 2], tree[ind * 2 + 1]);
}
ll getMax(ll ind, ll tl, ll tr, ll l, ll r) {
	if (l > r)
		return 0;
	if (l == tl && r == tr)
		return tree[ind];
	ll tm = (tl + tr) / 2;
	ll a = getMax(ind * 2, tl, tm, l, min(r, tm));
	ll b = getMax(ind * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
	return max(a, b);
}

int main()
{
	ll n;
	cin >> n;
	vi arr(n);
	vi sum(n);
	for (int i = 0; i < n; i++)	{
		cin >> arr[i];
		if (i == 0)	{
			sum[i] = arr[i];
		}
		else {
			sum[i] = sum[i - 1] + arr[i];
		}
	}

	for (int len = n; len >= 1; len--) {
		for (int i = 0; i + len - 1 < n; i++) {
			ll ans = 0;
			if (i == 0) {
				ans = sum[len - 1];
			}
			else {
				ans = sum[i + len - 1] - sum[i - 1];
			}
			if (ans >= n * 100) {
				cout << len;
				return 0;
			}
		}
	}
	cout << 0;
	return 0;
}


#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <algorithm>
#include <cmath>
#include <set>
#include <queue>
//#define endl '\n'

using namespace std;

typedef long long ll;
typedef vector<ll> vi;
typedef vector<vector<ll>> vvi;
typedef vector<bool> vb;
typedef pair<ll, ll> pi;
typedef map<ll, ll> mi;
typedef vector<pi> vpi;
typedef set<pi> spi;
typedef set<ll> si;

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

vi tree;

void build(vi &arr, ll ind, ll l, ll r) {
	if (l == r) {
		tree[ind] = arr[l];
		return;
	}
	ll mid = (l + r) / 2;
	build(arr, ind * 2, l, mid);
	build(arr, ind * 2+1, mid+1, r);
	tree[ind] = max(tree[ind * 2], tree[ind * 2 + 1]);
}
ll getMax(ll ind, ll tl, ll tr, ll l, ll r) {
	if (l > r)
		return 0;
	if (l == tl && r == tr)
		return tree[ind];
	ll tm = (tl + tr) / 2;
	ll a = getMax(ind * 2, tl, tm, l, min(r, tm));
	ll b = getMax(ind * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
	return max(a, b);
}

int main()
{
	ll n;
	cin >> n;
	vi arr(n);
	vi sum(n);
	for (int i = 0; i < n; i++)	{
		cin >> arr[i];
		if (i == 0)	{
			sum[i] = arr[i];
		}
		else {
			sum[i] = sum[i - 1] + arr[i];
		}
	}

	for (int len = n; len >= 1; len--) {
		for (int i = 0; i + len - 1 < n; i++) {
			ll ans = 0;
			if (i == 0) {
				ans = sum[len - 1];
			}
			else {
				ans = sum[i + len - 1] - sum[i - 1];
			}
			if (ans > len * 100) {
				cout << len;
				return 0;
			}
		}
	}
	cout << 0;
	return 0;
}


#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <algorithm>
#include <cmath>
#include <set>
#include <queue>
//#define endl '\n'

using namespace std;

typedef long long ll;
typedef vector<ll> vi;
typedef vector<vector<ll>> vvi;
typedef vector<bool> vb;
typedef pair<ll, ll> pi;
typedef map<ll, ll> mi;
typedef vector<pi> vpi;
typedef set<pi> spi;
typedef set<ll> si;

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

vi tree;

void build(vi &arr, ll ind, ll l, ll r) {
	if (l == r) {
		tree[ind] = arr[l];
		return;
	}
	ll mid = (l + r) / 2;
	build(arr, ind * 2, l, mid);
	build(arr, ind * 2+1, mid+1, r);
	tree[ind] = max(tree[ind * 2], tree[ind * 2 + 1]);
}
ll getMax(ll ind, ll tl, ll tr, ll l, ll r) {
	if (l > r)
		return 0;
	if (l == tl && r == tr)
		return tree[ind];
	ll tm = (tl + tr) / 2;
	ll a = getMax(ind * 2, tl, tm, l, min(r, tm));
	ll b = getMax(ind * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
	return max(a, b);
}

int main()
{
	ll n;
	cin >> n;
	vi arr(n);
	vi sum(n);
	for (int i = 0; i < n; i++)	{
		cin >> arr[i];
		if (i == 0)	{
			sum[i] = arr[i];
		}
		else {
			sum[i] = sum[i - 1] + arr[i];
		}
	}

	for (int len = n; len >= 1; len--) {
		for (int i = 0; i + len - 1 < n; i++) {
			ll ans = 0;
			if (i == 0) {
				ans = sum[len - 1];
			}
			else {
				ans = sum[i + len - 1] - sum[i - 1];
			}
			if (ans >= len * 100) {
				cout << len;
				return 0;
			}
		}
	}
	cout << 0;
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main()
{
	int n,m=0,max=0;
	cin>>n;
	int a[n+1];
	for(int i=1;i<=n;i++)
	{ cin>>a[i];
		if(a[i]>100*i)
			m++;
		else if(a[i]<=100*i && m!=0)
		{	if(m>max)
			max=m;
			m=0;
		}
	}
	cout<<max;
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
#define loop(i,a,b) for(i=a;i<b;i++)
#define loope(i,a,b) for(i=a;i<=b;i++)
#define rloop(i,a,b) for(i=a;i>b;i--)
#define rloope(i,a,b) for(i=a;i>=b;i--)
#define Mx 1e9
#define Mn -1e9
#define wh(k) while(k--)
#define Ct(a) cout<<a;
#define Cn(a) cin>>a;

int main()
{
int n,i,j,max=0,sm=0;
cin>>n;
int a[n];
loop(i,0,n)
cin>>a[i];
loop(i,0,n)
{loop(j,i,n)
{sm+=a[j];
if(sm>(j-i+1)*100 && (j-i+1)>max)
max=j-i+1;
}
sm=0;
}
//if(max>0)
cout<<max;
//else
//cout<<"0";

return 0;}


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

typedef long long LL;
typedef unsigned long long ULL;

const int PI = 3.141592653589793238;
const int inf = 1000111222;
const int mod = 1000000007;
const int N = 100007;

int n, ar[N], res;

int main() {

	ios_base :: sync_with_stdio(0);
	cin.tie(0); cout.tie(0);

	cin >> n;
	for (int i = 0; i < n; i++)
		cin >> ar[i];
	for (int i = 0; i < n; i++) {
		int curr = 0;
		for (int j = i; j < n; j++) {
			curr += ar[j];
			if (curr > 100 * (j - i + 1))
				res = max(res, j - i + 1);
		}
	}
	cout << res << "\n";
	return 0;
}


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

typedef long long LL;
typedef unsigned long long ULL;

const int PI = 3.141592653589793238;
const int inf = 1000111222;
const int mod = 1000000007;
const int N = 100007;

int n, ar[N], res;

int main() {

	ios_base :: sync_with_stdio(0);
	cin.tie(0); cout.tie(0);

	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> ar[i];
		ar[i] /= 100;
	}
	for (int i = 0; i < n; i++) {
		int curr = 0;
		int t = 0, j;
		for (j = i; j < n; j++) {
			curr += ar[j];
			t++;
			if (curr < t) break;
		}
		res = max(res, j - i);
	}
	cout << res << "\n";
	return 0;
}


#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <climits>
#define en "\n"
#define pr pair
#define mp make_pair
#define vc vector
#define rs resize
#define ll int
#define all(a) a.begin(),a.end()
#define sr stable_sort
#define ct cout
#define CT cout
#define cn cin
#define rv reverse
#define qa " "
#define rt return
#define fr(n) for(int i=0;i<n;i++)
#define lol(A,X) lower_bound((A).begin(),A.end(),X)-A.begin()
using namespace std;
int main() {
	cin.tie(0); cout.tie(0); ios_base::sync_with_stdio(false);
	ll n;
	cn >> n;
	vc<ll>a(n+1);
	vc<ll>s(n + 1);
	ll p = 0;
	for (int i = 1; i <= n; i++) {
		cn >> a[i];
		p += a[i];
		s[i] = p;
	}
	ll c = 0;
	for (int i = 1; i <= n; i++) {
		ll l = 0, r = n - i;
		while (r - l > 1) {
			ll m = (r + l) / 2;
			ll q = s[i + m] - s[i - 1];
			if (100 * (m+1) <= q) {
				l = m;
			} else {
				r = m;
			}
		}
		ll q = s[r] - s[i - 1];
		if (100 * (r) < q) {
			q = r - i + 1;
			c = max(c, q);
		}
	}
	ct << c;
}


#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <climits>
#define en "\n"
#define pr pair
#define mp make_pair
#define vc vector
#define rs resize
#define ll int
#define all(a) a.begin(),a.end()
#define sr stable_sort
#define ct cout
#define CT cout
#define cn cin
#define rv reverse
#define qa " "
#define rt return
#define fr(n) for(int i=0;i<n;i++)
#define lol(A,X) lower_bound((A).begin(),A.end(),X)-A.begin()
using namespace std;
int main() {
	cin.tie(0); cout.tie(0); ios_base::sync_with_stdio(false);
	ll n;
	cn >> n;
	vc<ll>a(n);
	for (int i = 0; i < n; i++) {
		cn >> a[i];
	}
	ll c = 0;
	for (int i = 0; i < n; i++) {
		ll s = 0;
		ll t = 0;
		for (int j = i; j < n; j++) {
			s += a[j];
			t++;
			if (t * 100 < s) {
				c = max(j - i + 1,c);
			}
		}
	}
	ct << c;
}


#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <climits>
#define en "\n"
#define pr pair
#define mp make_pair
#define vc vector
#define rs resize
#define ll int
#define all(a) a.begin(),a.end()
#define sr stable_sort
#define ct cout
#define CT cout
#define cn cin
#define rv reverse
#define qa " "
#define rt return
#define fr(n) for(int i=0;i<n;i++)
#define lol(A,X) lower_bound((A).begin(),A.end(),X)-A.begin()
using namespace std;
int main() {
	cin.tie(0); cout.tie(0); ios_base::sync_with_stdio(false);
	ll n;
	cn >> n;
	vc<ll>a(n+1);
	vc<ll>s(n + 1);
	ll p = 0;
	for (int i = 1; i <= n; i++) {
		cn >> a[i];
		p += a[i];
		s[i] = p;
	}
	ll c = 0;
	for (int i = 1; i <= n; i++) {
		ll l = 0, r = n - i;
		while (r - l > 1) {
			ll m = (r + l) / 2;
			ll q = s[i + m] - s[i - 1];
			if (100 * (m+1) < q) {
				l = m;
			} else {
				r = m;
			}
		}
		c = max(c, r - i);
	}
	if (c != 0) {
		c++;
	}
	ct << c;
}


#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <climits>
#define en "\n"
#define pr pair
#define mp make_pair
#define vc vector
#define rs resize
#define ll int
#define all(a) a.begin(),a.end()
#define sr stable_sort
#define ct cout
#define CT cout
#define cn cin
#define rv reverse
#define qa " "
#define rt return
#define fr(n) for(int i=0;i<n;i++)
#define lol(A,X) lower_bound((A).begin(),A.end(),X)-A.begin()
using namespace std;
int main() {
	cin.tie(0); cout.tie(0); ios_base::sync_with_stdio(false);
	ll n;
	cn >> n;
	vc<ll>a(n+1);
	vc<ll>s(n + 1);
	ll p = 0;
	for (int i = 1; i <= n; i++) {
		cn >> a[i];
		p += a[i];
		s[i] = p;
	}
	ll c = 0;
	for (int i = 1; i <= n; i++) {
		ll l = i, r = n + 1;
		while (r - l > 1) {
			ll m = (r + l) / 2;
			ll q = s[m] - s[i - 1];
			ll j = m - i + 1;
			if (100 * j < q) {
				l = m;
			} else {
				r = m;
			}
		}
		ll q = s[l] - s[i - 1];
		ll j = l - i + 1;
		if (100 * (j) < q) {
			q = l - i + 1;
			c = max(c, q);
		}
	}
	ct << c;
}


#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <climits>
#define en "\n"
#define pr pair
#define mp make_pair
#define vc vector
#define rs resize
#define ll int
#define all(a) a.begin(),a.end()
#define sr stable_sort
#define ct cout
#define CT cout
#define cn cin
#define rv reverse
#define qa " "
#define rt return
#define fr(n) for(int i=0;i<n;i++)
#define lol(A,X) lower_bound((A).begin(),A.end(),X)-A.begin()
using namespace std;
int main() {
	cin.tie(0); cout.tie(0); ios_base::sync_with_stdio(false);
	ll n;
	cn >> n;
	vc<ll>a(n+1);
	vc<ll>s(n + 1);
	ll p = 0;
	for (int i = 1; i <= n; i++) {
		cn >> a[i];
		p += a[i];
		s[i] = p;
	}
	ll c = 0;
	for (int i = 1; i <= n; i++) {
		ll l = 0, r = n - i;
		while (r - l > 1) {
			ll m = (r + l) / 2;
			ll q = s[i + m] - s[i - 1];
			if (100 * (m+1) < q) {
				l = m;
			} else {
				r = m;
			}
		}
		ll q = s[i + r] - s[i - 1];
		if (100 * (r) < q) {
			q = r - i + 1;
			c = max(c, q);
		}
	}
	ct << c;
}


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

int main() {
	// your code goes here
	int n;cin>>n;
	int a[n];for(int i=0;i<n;i++)cin>>a[i];
	int res=0;
	for(int i=0;i<n;i++)
	{
	    int sm=0;
	    for(int j=i;j<n;j++)
	    {
	        sm+=a[j];
	        if(sm>100*(j-i+1))res=max(res,j-i+1);
	    }
	}
	cout<<res;
	return 0;
}


//Author- Vaibhav singh
//will be expert soon
// *#####################################################################################*
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define YES cout<<"YES"<<"\n";
#define NO cout<<"NO"<<"\n";
#define yes cout<<"yes"<<"\n";
#define no cout<<"no"<<"\n";
#define No cout<<"No"<<"\n";
#define Yes cout<<"Yes"<<"\n";
#define f(i,a) for(i=0;i<a;i++)
#define fo(i,a) for(i=1;i<=n;i++)
#define fa(i,a) for(auto i:a)
#define r(i,a) for(auto i=a.rbegin();i!=a.rend();i++)
#define en cout<<"\n";
#define ull unsigned long long int
#define o(x) cout<<x<<"\n";
#define o1(x) cout<<x<<" ";
#define pb push_back
#define F first
#define in insert
#define mp make_pair
#define S second
#define mp make_pair
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);
#define test ll t;cin>>t;while(t-->0)
const ll Mod = 998244353;
#define mod 1000000007
#define re return 0;
// *#######################################################################################*
// *#########################################################################################*
    //      ll ans=0,b[5000005]={0},a[5000005],i,n,x=0;

int main()
{

      fast

       ll n;
       cin>>n;

      ll i,ans=0,x=0,y=0,mn=0;

      ll a[n];

      fo(i,n)
      {
            cin>>a[i];
             mn+=a[i];
               x+=100;
               if(mn>x)
               {
                     ans++;
               }
      }

      o(ans)

	re
}


//Author- Vaibhav singh
//will be expert soon
// *#####################################################################################*
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define YES cout<<"YES"<<"\n";
#define NO cout<<"NO"<<"\n";
#define yes cout<<"yes"<<"\n";
#define no cout<<"no"<<"\n";
#define No cout<<"No"<<"\n";
#define Yes cout<<"Yes"<<"\n";
#define f(i,a) for(i=0;i<a;i++)
#define fo(i,a) for(i=1;i<=n;i++)
#define fa(i,a) for(auto i:a)
#define r(i,a) for(auto i=a.rbegin();i!=a.rend();i++)
#define en cout<<"\n";
#define ull unsigned long long int
#define o(x) cout<<x<<"\n";
#define o1(x) cout<<x<<" ";
#define pb push_back
#define F first
#define in insert
#define mp make_pair
#define S second
#define mp make_pair
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);
#define test ll t;cin>>t;while(t-->0)
const ll Mod = 998244353;
#define mod 1000000007
#define re return 0;
// *#######################################################################################*
// *#########################################################################################*
    //      ll ans=0,b[5000005]={0},a[5000005],i,n,x=0;

int main()
{

      fast

       ll n;
       cin>>n;

      ll i,ans=0,x=0,y=0,mn=0;

      ll a[n];

      fo(i,n)
      {
            cin>>a[i];
             mn+=a[i];
               x+=100;
               //o1(mn)o1(x)
               if(mn>=x)
               {
                     ans++;
               }
      }

      o(ans)

	re
}


#include <iostream>
#include <stack>
#include <vector>
#include <fstream>
#include <algorithm>

using namespace std;

int main() {

	int n;
	cin >> n;

	vector<int> r(n);
	for (int i = 0; i < n; ++i) {
		cin >> r[i];
	}

	vector<vector<int>> dp(n, vector<int>());
	for (int i = 0; i < n; i++) {
		dp[i].resize(i + 1);
	}

	dp[0][0] = r[0];
	long long sum = 0;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j <= i; j++) {
			if (i == j) {
				dp[i][i] = r[i];
			}
			else {
				dp[i][j] = dp[i - 1][j] + r[i];
			}
		}
	}

	int ans = 0;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j <= i; j++) {
			if (dp[i][j] > (i - j + 1) * 100) {
				ans = max(ans, (i - j + 1));
			}
		}

	}
	cout << ans;

	//system("pause");
	return 0;
}


#include <iostream>
#include <stack>
#include <vector>

using namespace std;

int main() {
	int n;
	cin >> n;

	vector<int> r(n);
	for (int i = 0; i < n; ++i) {
		cin >> r[i];
	}

	long long sum = 0;
	int ans = 0;
	for (int i = 0; i < n; i++) {
		sum += r[i];
		if (sum > (i + 1) * 100) {
			ans = i + 1;
		}
	}
	cout << ans;

	//system("pause");
	return 0;
}


#include <iostream>
#include <stack>
#include <vector>
#include <fstream>
#include <algorithm>

using namespace std;

int main() {

	int n;
	cin >> n;

	vector<int> r(n);
	for (int i = 0; i < n; ++i) {
		cin >> r[i];
	}

	vector<vector<int>> dp(n, vector<int>());
	for (int i = 0; i < n; i++) {
		dp[i].resize(i + 1);
	}

	dp[0][0] = r[0];
	long long sum = 0;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j <= i; j++) {
			if (i == j) {
				dp[i][i] = r[i];
			}
			else {
				dp[i][j] = dp[i - 1][j] + r[i];
			}
		}
	}

	int ans = 0;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j <= i; j++) {
			if (dp[i][j] > (i + 1) * 100) {
				ans = max(ans, (i - j + 1));
			}
		}

	}
	cout << ans;

	//system("pause");
	return 0;
}


#include <iostream>
using namespace std;
int a[5001] , n , maxi , sum , dif;
 int ri , rj;

int main()
{
    bool ok=0;
    int i , j ;

    cin>>n;
    for (i=1 ; i<=n ; i++)
    {
        cin>>a[i];
        sum=a[i];
        if (a[i]>=100)
        maxi=max(1 , maxi);
        for (j=i-1 ; j>=1 ; j--)
        {
            sum+=a[j];
            if (sum>(i-j+1)*100)
                maxi=max(maxi,i-j+1);
        }
    }
    cout<<maxi;
    return 0;
}


#include <iostream>
using namespace std;
int a[5001] , n , maxi , sum , dif;
int main()
{

    int i , j ;
    cin>>n;
    for (i=1 ; i<=n ; i++)
        cin>>a[i];
    sum=a[1];
    for (i=1 ; i<n ; i++)
     {
        for (j=1+i ; j<=n ; j++)
        {
        dif=j-i;
        sum+=a[j];
        if (dif>maxi)
        if (sum>100*dif)
                maxi=dif;

        }
        sum=0;

     }
    cout<<maxi;
    return 0;
}


#include <iostream>
using namespace std;
int a[5001] , n , maxi , sum , dif;
 int ri , rj;

int main()
{
    bool ok=0;
    int i , j ;
    cin>>n;
    for (i=1 ; i<=n ; i++)
         {
                cin>>a[i];
                if (a[i]>100)
               maxi=1;
         }
    sum=a[1];
    for (i=1 ; i<n ; i++)
     {
        for (j=1+i ; j<=n ; j++)
        {
        dif=j-i+1;
        sum+=a[j];
        if (dif>maxi)
        if (sum>100*dif)
            maxi=dif;

        }
        sum=0;

     }
    cout<<maxi;
    return 0;
}


#include <iostream>
using namespace std;
int a[5001] , n , maxi , sum , dif;
 int ri , rj;

int main()
{
    bool ok=0;
    int i , j ;
    cin>>n;
    for (i=1 ; i<=n ; i++)
         {
                cin>>a[i];
                if (a[i]>=100)
               maxi=1;
         }
    sum=a[1];
    for (i=1 ; i<n ; i++)
     {
        for (j=1+i ; j<=n ; j++)
        {
        dif=j-i+1;
        sum+=a[j];
        if (dif>maxi)
        if (sum>=100*dif)
            maxi=dif;

        }
        sum=0;

     }
    cout<<maxi;
    return 0;
}


#include <iostream>
using namespace std;
int a[5001] , n , maxi , sum , dif;
int main()
{

    int i , j ;
    cin>>n;
    for (i=1 ; i<=n ; i++)
        cin>>a[i];
    sum=a[1];
    for (i=1 ; i<n ; i++)
     {
        for (j=1+i ; j<=n ; j++)
        {
        dif=j-i;
        sum+=a[j];
        if (dif>maxi)
        if (sum>=100*dif)
                maxi=dif;

        }
        sum=0;

     }
    cout<<maxi;
    return 0;
}


#include <iostream>
using namespace std;
int a[5001] , n , maxi , sum , dif;
 int ri , rj;

int main()
{
    bool ok=0;
    int i , j ;
    cin>>n;
    for (i=1 ; i<=n ; i++)
         {
                cin>>a[i];
                if (a[i]>=100)
               maxi=1;
         }
    sum=a[1];
    for (i=1 ; i<n ; i++)
     {
        for (j=1+i ; j<=n ; j++)
        {
        dif=j-i+1;
        sum+=a[j];
        if (dif>maxi)
        if (sum>100*dif)
            maxi=dif;

        }
        sum=0;

     }
    cout<<maxi;
    return 0;
}


#include <iostream>
using namespace std;
int a[5001] , n , maxi , sum , dif;
int main()
{
    bool ok=0;
    int i , j ;
    cin>>n;
    for (i=1 ; i<=n ; i++)
            cin>>a[i];
    sum=a[1];
    for (i=1 ; i<n ; i++)
     {
        for (j=1+i ; j<=n ; j++)
        {
        dif=j-i+1;
        sum+=a[j];
        if (dif>maxi)
        if (sum>100*dif)
                    maxi=dif;

        }
        sum=0;

     }
    cout<<maxi;
    return 0;
}


#include <iostream>
using namespace std;
int a[5001] , n , maxi , sum , dif;
 int ri , rj;

int main()
{
    bool ok=0;
    int i , j ;
    cin>>n;
    for (i=1 ; i<=n ; i++)
            cin>>a[i];
    sum=a[1];
    for (i=1 ; i<n ; i++)
     {
        for (j=1+i ; j<=n ; j++)
        {
        dif=j-i+1;
        sum+=a[j];
        if (dif>maxi)
        if (sum>100*dif)
            maxi=dif;

        }
        sum=0;

     }
    cout<<maxi;
    return 0;
}


#include <iostream>
using namespace std;
int a[5001] , n , maxi , sum , dif;
 int ri , rj;

int main()
{
    bool ok=0;
    int i , j ;

    cin>>n;
    for (i=1 ; i<=n ; i++)
    {
        cin>>a[i];
        sum=a[i];
        if (a[i]>=100)
        maxi=max(1 , maxi);
        for (j=i-1 ; j>=0 ; j--)
        {
            sum+=a[j];
            if (sum>(i-j+1)*100)
                maxi=max(maxi,i-j+1);
        }
    }
    cout<<maxi;
    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define SPEED ios_base::sync_with_stdio(false); cin.tie(NULL);
#define FOR(i, a, b) for (ll i = a; i < b; ++i)
#define RFOR(i, b, a) for (ll i = b; i >= a; --i)
#define ALL(x) x.begin(), x.end()
#define DEBUG(args...) { string _s = #args; replace(ALL(_s), ' ', '\0');\
replace(ALL(_s), ',', ' ');\
stringstream _ss(_s); istream_iterator<string> _it(_ss); _debug(_it, args);}
#define endl "\n"
#define F first
#define S second
#define pb(x) push_back(x)a
#define mp(x, y) make_pair(x, y)

using namespace std;
using namespace __gnu_pbds;

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

void _debug(istream_iterator<string>) {}
template<typename T, typename... Args>
void _debug(istream_iterator<string> it, T first, Args... args) {
    cerr << ">> " << *it << " : " << first << endl; _debug(++it, args...);
}
template <typename T1, typename T2>
inline ostream& operator << (ostream& out, const pair<T1, T2>& p) {
    return out << "(" << p.F << ", " << p.S << ")";
}
template<typename T>
inline ostream& operator << (ostream& out, const vector<T>& v) {
    if (v.empty()) return out << "[]";
    else { out << '['; for (auto& e : v) { out << e << ", "; } return out << "\b\b]"; }
}
template<typename T>
inline ostream& operator << (ostream& out, const set<T>& s) {
    if (s.empty()) return out << "{}";
    else { out << '{'; for (auto& e : s) { out << e << ", "; } return out << "\b\b}"; }
}
template<typename T>
inline ostream& operator << (ostream& out, const unordered_set<T>& s) {
    return out << set<T>(ALL(s));
}
template<typename T1, typename T2>
inline ostream& operator << (ostream& out, const map<T1, T2>& m) {
    if (m.empty()) return out << "{}";
    out << '{'; for (auto& p : m) { out << p << ", "; } return out << "\b\b}";
}
template<typename T1, typename T2>
inline ostream& operator << (ostream& out, const unordered_map<T1, T2>& m) {
    return out << map<T1, T2>(ALL(m));
}
template<typename T>
inline ostream& operator << (ostream& out, const ordered_set<T>& s) {
    return out << set<T>(ALL(s));
}

typedef long long ll;
typedef long double ld;
typedef vector<long long> vll;
typedef pair<ll, ll> pll;
typedef vector<pair<ll, ll>> vpll;
typedef unordered_map<ll, ll> STll;
/************************************** MAIN PROGRAM ********************************************/

int main()
{
    //freopen("input.txt", "r", stdin);
    SPEED
    int n;
    cin >> n;
    vector<int> a(n);
    for (auto &e : a) {
        cin >> e;
    }
    int ans = 0;
    for (int i = 0; i < n; ++i) {
        int sum = 0;
        for (int j = i; j < n; ++j) {
            int len = j - i + 1;
            sum += a[j];
            if (sum >= 100 * len) {
                ans = max(ans, len);
            }
        }
    }
    cout <<ans;
}
/************************************** END OF PROGRAM ******************************************/
/** Stuff you should look for:
 * int overflow, array bounds, over-counting
 * special cases (n=1?), set/unordered_set TLE, multi-set/set error
 * do something instead of nothing and stay organized
 */


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define SPEED ios_base::sync_with_stdio(false); cin.tie(NULL);
#define FOR(i, a, b) for (ll i = a; i < b; ++i)
#define RFOR(i, b, a) for (ll i = b; i >= a; --i)
#define ALL(x) x.begin(), x.end()
#define DEBUG(args...) { string _s = #args; replace(ALL(_s), ' ', '\0');\
replace(ALL(_s), ',', ' ');\
stringstream _ss(_s); istream_iterator<string> _it(_ss); _debug(_it, args);}
#define endl "\n"
#define F first
#define S second
#define pb(x) push_back(x)a
#define mp(x, y) make_pair(x, y)

using namespace std;
using namespace __gnu_pbds;

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

void _debug(istream_iterator<string>) {}
template<typename T, typename... Args>
void _debug(istream_iterator<string> it, T first, Args... args) {
    cerr << ">> " << *it << " : " << first << endl; _debug(++it, args...);
}
template <typename T1, typename T2>
inline ostream& operator << (ostream& out, const pair<T1, T2>& p) {
    return out << "(" << p.F << ", " << p.S << ")";
}
template<typename T>
inline ostream& operator << (ostream& out, const vector<T>& v) {
    if (v.empty()) return out << "[]";
    else { out << '['; for (auto& e : v) { out << e << ", "; } return out << "\b\b]"; }
}
template<typename T>
inline ostream& operator << (ostream& out, const set<T>& s) {
    if (s.empty()) return out << "{}";
    else { out << '{'; for (auto& e : s) { out << e << ", "; } return out << "\b\b}"; }
}
template<typename T>
inline ostream& operator << (ostream& out, const unordered_set<T>& s) {
    return out << set<T>(ALL(s));
}
template<typename T1, typename T2>
inline ostream& operator << (ostream& out, const map<T1, T2>& m) {
    if (m.empty()) return out << "{}";
    out << '{'; for (auto& p : m) { out << p << ", "; } return out << "\b\b}";
}
template<typename T1, typename T2>
inline ostream& operator << (ostream& out, const unordered_map<T1, T2>& m) {
    return out << map<T1, T2>(ALL(m));
}
template<typename T>
inline ostream& operator << (ostream& out, const ordered_set<T>& s) {
    return out << set<T>(ALL(s));
}

typedef long long ll;
typedef long double ld;
typedef vector<long long> vll;
typedef pair<ll, ll> pll;
typedef vector<pair<ll, ll>> vpll;
typedef unordered_map<ll, ll> STll;
/************************************** MAIN PROGRAM ********************************************/

int main()
{
    //freopen("input.txt", "r", stdin);
    SPEED
    int n;
    cin >> n;
    vector<int> a(n);
    for (auto &e : a) {
        cin >> e;
    }
    int ans = 0;
    for (int i = 0; i < n; ++i) {
        int sum = 0;
        for (int j = i; j < n; ++j) {
            int len = j - i + 1;
            sum += a[j];
            if (sum > 100 * len) {
                ans = max(ans, len);
            }
        }
    }
    cout <<ans;
}
/************************************** END OF PROGRAM ******************************************/
/** Stuff you should look for:
 * int overflow, array bounds, over-counting
 * special cases (n=1?), set/unordered_set TLE, multi-set/set error
 * do something instead of nothing and stay organized
 */


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define SPEED ios_base::sync_with_stdio(false); cin.tie(NULL);
#define FOR(i, a, b) for (ll i = a; i < b; ++i)
#define RFOR(i, b, a) for (ll i = b; i >= a; --i)
#define ALL(x) x.begin(), x.end()
#define DEBUG(args...) { string _s = #args; replace(ALL(_s), ' ', '\0');\
replace(ALL(_s), ',', ' ');\
stringstream _ss(_s); istream_iterator<string> _it(_ss); _debug(_it, args);}
#define endl "\n"
#define F first
#define S second
#define pb(x) push_back(x)a
#define mp(x, y) make_pair(x, y)

using namespace std;
using namespace __gnu_pbds;

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

void _debug(istream_iterator<string>) {}
template<typename T, typename... Args>
void _debug(istream_iterator<string> it, T first, Args... args) {
    cerr << ">> " << *it << " : " << first << endl; _debug(++it, args...);
}
template <typename T1, typename T2>
inline ostream& operator << (ostream& out, const pair<T1, T2>& p) {
    return out << "(" << p.F << ", " << p.S << ")";
}
template<typename T>
inline ostream& operator << (ostream& out, const vector<T>& v) {
    if (v.empty()) return out << "[]";
    else { out << '['; for (auto& e : v) { out << e << ", "; } return out << "\b\b]"; }
}
template<typename T>
inline ostream& operator << (ostream& out, const set<T>& s) {
    if (s.empty()) return out << "{}";
    else { out << '{'; for (auto& e : s) { out << e << ", "; } return out << "\b\b}"; }
}
template<typename T>
inline ostream& operator << (ostream& out, const unordered_set<T>& s) {
    return out << set<T>(ALL(s));
}
template<typename T1, typename T2>
inline ostream& operator << (ostream& out, const map<T1, T2>& m) {
    if (m.empty()) return out << "{}";
    out << '{'; for (auto& p : m) { out << p << ", "; } return out << "\b\b}";
}
template<typename T1, typename T2>
inline ostream& operator << (ostream& out, const unordered_map<T1, T2>& m) {
    return out << map<T1, T2>(ALL(m));
}
template<typename T>
inline ostream& operator << (ostream& out, const ordered_set<T>& s) {
    return out << set<T>(ALL(s));
}

typedef long long ll;
typedef long double ld;
typedef vector<long long> vll;
typedef pair<ll, ll> pll;
typedef vector<pair<ll, ll>> vpll;
typedef unordered_map<ll, ll> STll;
/************************************** MAIN PROGRAM ********************************************/

int main()
{
    //freopen("input.txt", "r", stdin);
    SPEED
    int n;
    cin >> n;
    vector<int> a(n);
    for (auto &e : a) {
        cin >> e;
    }
    int ans = 0;
    for (int i = 0; i < n; ++i) {
        int sum = 0;
        for (int j = i; j < n; ++j) {
            int len = j - i;
            sum += a[j];
            if (sum >= 100 * len) {
                ans = max(ans, len);
            }
        }
    }
    cout <<ans;
}
/************************************** END OF PROGRAM ******************************************/
/** Stuff you should look for:
 * int overflow, array bounds, over-counting
 * special cases (n=1?), set/unordered_set TLE, multi-set/set error
 * do something instead of nothing and stay organized
 */


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

int main()
{
    int  n;
    cin>>n;
    int arr[n+1];
    for(int i=0;i<n;i++) cin>>arr[i];
    for(int i=n;i>=1;i--)
    {
        for(int j=0;j<=n-i;j++)
        {
            int sum=0;
            for(int k=j;k<j+i;k++)
            {
                sum+=arr[k];
            }
            if(sum>i*100)
            {
                cout<<i<<endl;
                return 0;
            }
        }
    }

    cout<<0<<endl;
}


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

int main()
{
    int  n;
    scanf("%d",&n);
    int arr[n+1];
    for(int i=0;i<n;i++) scanf("%d",&arr[i]);
    //for(int i=1;i<n;i++) arr[i]+=arr[i-1];
    for(int i=n;i>=1;i--)
    {
        for(int j=0;j<=n-i;j++)
        {
            int sum=0;
            for(int k=j;k<j+i;k++)
            {
                sum+=arr[k];
            }
            //sum=arr[j+i-1]-arr[j];
            //if(j==0) sum=arr[j+i-1];
            if(sum>i*100)
            {
                printf("%d\n",i);
                return 0;
            }
        }
    }

    printf("0\n");
}


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

int main()
{
    int  n;
    cin>>n;
    int arr[n+1];
    for(int i=0;i<n;i++) cin>>arr[i];
    for(int i=1;i<n;i++) arr[i]+=arr[i-1];
    for(int i=n;i>=1;i--)
    {
        for(int j=0;j<=n-i;j++)
        {
            int sum=0;
            sum=arr[j+i-1]-arr[j-1];
            if(j==0) sum=arr[j+i-1];
            if(sum>i*100)
            {
                cout<<i<<endl;
                return 0;
            }
        }
    }

    cout<<0<<endl;
}


#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
using namespace std;
#define ll long long
#define MAXN 5000 + 7
int a[MAXN];
int n;
int main(){
    scanf("%d",&n);
    for(int i = 1; i <= n; i++)
        cin >> a[i];
    int sum = 0 , maxx = 0;
    for(int i = 1; i <= n; i++){
        sum += a[i];
        if(sum > 100 * i)
            maxx = max(maxx , i);
    }
    printf("%d\n",maxx);
    return 0;
}


#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<set>
#include<map>
using namespace std;
const int MAXN = 5010;
int n , a[MAXN];

int main(){
    cin >> n;
    for(int i = 1; i <= n; i++)
        cin >> a[i];
    int maxn = 0;
    for(int i = 1; i <= n; i++){
        int sum = 0;
        for(int j = i; j <= n; j++){
            sum += a[j];
            if(sum > 100 * (j - i + 1)){
                maxn = max(maxn , j - i + 1);
            }
        }
    }
    cout << maxn << endl;
    return 0;
}


#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<set>
#include<map>
using namespace std;
const int MAXN = 100010;
int n , a[MAXN];

int main(){
    scanf("%d" , &n);
    for(int i = 1; i <= n; i++)
        scanf("%d" , &a[i]);
    int sum = 0 , maxn = 0;
    for(int i = 1; i <= n; i++){
        sum += a[i];
        if(sum > 100 * i)
            maxn = max(maxn , i);
    }
    printf("%d\n" , maxn);
    return 0;
}


#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
using namespace std;
#define ll long long
#define MAXN 5000 + 7
int a[MAXN];
int n;
int main(){
    scanf("%d",&n);
    for(int i = 1; i <= n; i++)
        cin >> a[i];
    int sum = 0 , maxx = 0;
    for(int i = 1; i <= n; i++){
        sum += a[i];
        if(sum > 100 * i)
            maxx = i;
    }
    printf("%d\n",maxx);
    return 0;
}


#include <bits/stdc++.h>
#define pb push_back
#define all(a) a.begin(),a.end()
#define forn(i,n) for(int i=0;i<int(n);i++)
#define forr(i,n) for(int i=int(n-1);i>=0;i--)
#define fora(i,a,b) for(int i=int(a);i<=int(b);i++)
#define forb(i,a,b) for(int i=int(a);i>=int(b);i--)
#define mod 1000000007
using namespace std;
using ll=long long int;
typedef vector<int> vi;
typedef pair<int,int> pi;
typedef vector<ll> vii;
typedef pair<ll ,ll> pii;
template<typename T>
string ts(T v)
{
	string res="{";
	bool r=true;
	for(const auto &x:v)
	{
		if(!r)res+=",";
		r=false;
		res+=to_string(x);
	}
	res+="}";
	return res;
}
void solve()
{
	int n;
	cin>>n;
	int arr[n],best=0;
	forn(i,n)cin>>arr[i];
	for(int i=0;i<n;i++)
	{
		int s=0;
		for(int j=0;j<=i;j++)
		{
			int t=i-j+1;
			s+=arr[j];
			if(100*t<s)best=max(best,i-j+1);
		}
	}
	cout<<best<<endl;
}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    solve();
    return 0;
}


#include <bits/stdc++.h>
#define pb push_back
#define all(a) a.begin(),a.end()
#define forn(i,n) for(int i=0;i<int(n);i++)
#define forr(i,n) for(int i=int(n-1);i>=0;i--)
#define fora(i,a,b) for(int i=int(a);i<=int(b);i++)
#define forb(i,a,b) for(int i=int(a);i>=int(b);i--)
#define mod 1000000007
using namespace std;
using ll=long long int;
typedef vector<int> vi;
typedef pair<int,int> pi;
typedef vector<ll> vii;
typedef pair<ll ,ll> pii;
template<typename T>
string ts(T v)
{
	string res="{";
	bool r=true;
	for(const auto &x:v)
	{
		if(!r)res+=",";
		r=false;
		res+=to_string(x);
	}
	res+="}";
	return res;
}
void solve()
{
	int n;
	cin>>n;
	int arr[n],best=0;
	forn(i,n)cin>>arr[i];
	for(int i=0;i<n;i++)
	{
		int s=0;
		for(int j=i;j<n;j++)
		{
			int t=j-i+1;
			s+=arr[j];
			if(100*t<s)best=max(best,j-i+1);
		}
	}
	cout<<best<<endl;
}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    solve();
    return 0;
}


#include <bits/stdc++.h>
#define pb push_back
#define all(a) a.begin(),a.end()
#define forn(i,n) for(int i=0;i<int(n);i++)
#define forr(i,n) for(int i=int(n-1);i>=0;i--)
#define fora(i,a,b) for(int i=int(a);i<=int(b);i++)
#define forb(i,a,b) for(int i=int(a);i>=int(b);i--)
#define mod 1000000007
using namespace std;
using ll=long long int;
typedef vector<int> vi;
typedef pair<int,int> pi;
typedef vector<ll> vii;
typedef pair<ll ,ll> pii;
template<typename T>
string ts(T v)
{
	string res="{";
	bool r=true;
	for(const auto &x:v)
	{
		if(!r)res+=",";
		r=false;
		res+=to_string(x);
	}
	res+="}";
	return res;
}
void solve()
{
	int n;
	cin>>n;
	int arr[n],best=0;
	forn(i,n)cin>>arr[i];
	for(int i=0;i<n;i++)
	{
		int s=0;
		for(int j=0;j<=i;j++)
		{
			int t=i-j+1;
			s+=arr[j];
			if(100*t<=s)best=max(best,i-j+1);
		}
	}
	cout<<best<<endl;
}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    solve();
    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/trie_policy.hpp>
#include <ext/rope> //header with rope
#include <bits/stdtr1c++.h>//for rope

using namespace __gnu_pbds;
using namespace std;
using namespace __gnu_cxx; //namespace with rope and some additional stuff
typedef long long ll;
typedef unsigned long long ull;

#define     FASTER                  ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define     OUT                     freopen("out.txt","w",stdout);
#define     lop1(i,n)               for(int i=1;i<=n;i++)
#define     lop0(i,n)               for(int i=0;i<n;i++)
#define     lop(i,a,n)              for(int i=a;i<=n;i++)
#define     sf1(n)                  cin >> n;
#define     sf2(a,b)                cin >> a >> b;
#define     sf3(a,b,c)              cin >> a >> b >> c;
#define     sf(n)                   scanf("%d",&n)
#define     sff(a,b)                scanf("%d %d",&a,&b)
#define     sfff(a,b,c)             scanf("%d %d %d",&a,&b,&c)
#define     sl(n)                   scanf("%lld",&n)
#define     sll(a,b)                scanf("%lld %lld",&a,&b)
#define     slll(a,b,c)             scanf("%lld %lld %lld",&a,&b,&c)
#define     pf(n)                   cout << n << endl;
#define     pl(n)                   printf("%I64d\n",n)
#define     ARPR(ara,s,e)           for(int i=s;i<=e;i++){  cout << ara[i]  << " "; }   cout << '\n';
#define     bug(s)                  cerr << s << '\n';
#define     bug1(s,a)               cerr << s << "      " << a << '\n';
#define     bug2(s,a,b)             cerr << s << "      " << a << "     " << b << '\n';
#define     bug3(s,a,b,c)           cerr << s << "      " << a << "     " << b << "     " << c <<'\n';
#define     bug4(s,a,b,c,d)         cerr << s << "      " << a << "     " << b << "     " << c << "     " << d <<'\n';

#define     all(v)                  v.begin(),v.end()
#define     mem(ara,vl)             memset(ara,vl,sizeof(ara))
#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     MAX                     100
#define     max3(a,b,c)             max(a,max(b,c))
#define     max4(a,b,c,d)           max(a,max3(b,c,d))
#define     min3(a,b,c)             min(a,min(b,c))
#define     min4(a,b,c,d)           min(a,min3(b,c,d))
#define     pii                     pair<int,int>
#define     pll                     pair<ll,ll>
#define     F                       first
#define     S                       second
#define     PI                      acos(-1.00)
#define     eps                     1e-9
#define     Mod                     10000007
#define     inf                     9e18
#define     pb                      push_back
#define     MP(x,y)                 make_pair(x,y)
#define     oc(a)                   __builtin_popcountll(a)

//SET PRECIOSION   cout << fixed ;  cout << setprecision(n) << ans << endl;

/// Ordered SET
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
typedef tree<int, null_type, less_equal<int>, rb_tree_tag,tree_order_statistics_node_update> ordered_multiset;
typedef trie<string,null_type,trie_string_access_traits<>,pat_trie_tag,trie_prefix_search_node_update> pref_trie;

///

ll big_mod(ll a,ll b, ll c){    if(b==0)    return 1;   if(b%2==0)  {   ll d=big_mod(a,b/2,c);      return ((d*d)%c);      }     return (((a%c)*big_mod(a,b-1,c))%c);}
double distance(double x1, double y1, double x2, double y2) {    double xx  = (x1-x2) * (x1-x2);     double yy  = (y1-y2) * (y1-y2);     return sqrt(xx+yy); }

int dx4[]={ 0,-1, 0, 1};
int dy4[]={-1, 0, 1, 0};

int dx8[]={1, 1, 2, 2,-1,-1,-2,-2};
int dy8[]={2,-2, 1,-1, 2,-2, 1,-1};

int Set(int n,int pos){ return n = n | (1<<pos);}
int reset(int n, int pos){ return n = n & ~(1<<pos);}
bool check(int n, int pos){ return (bool) (n & (1<<pos));}

int main()
{
    FASTER
    int n;
    sf1(n);
    int ara[n+3];
    ara[0]=0;
    lop1(i,n)
    {
        sf1(ara[i]);
        ara[i] += ara[i-1];
    }
    int ans = 0;
    for(int i=0;i<=n;i++)
    {
        for(int j=i+1;j<=n;j++)
        {
            int a = ara[j] - ara[i];
            //bug2("A",a,j-i+1);
            if(a>((j-i)*100))ans = max(ans,j-i);
        }
    }
    pf(ans);
    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/trie_policy.hpp>
#include <ext/rope> //header with rope
#include <bits/stdtr1c++.h>//for rope

using namespace __gnu_pbds;
using namespace std;
using namespace __gnu_cxx; //namespace with rope and some additional stuff
typedef long long ll;
typedef unsigned long long ull;

#define     FASTER                  ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define     OUT                     freopen("out.txt","w",stdout);
#define     lop1(i,n)               for(int i=1;i<=n;i++)
#define     lop0(i,n)               for(int i=0;i<n;i++)
#define     lop(i,a,n)              for(int i=a;i<=n;i++)
#define     sf1(n)                  cin >> n;
#define     sf2(a,b)                cin >> a >> b;
#define     sf3(a,b,c)              cin >> a >> b >> c;
#define     sf(n)                   scanf("%d",&n)
#define     sff(a,b)                scanf("%d %d",&a,&b)
#define     sfff(a,b,c)             scanf("%d %d %d",&a,&b,&c)
#define     sl(n)                   scanf("%lld",&n)
#define     sll(a,b)                scanf("%lld %lld",&a,&b)
#define     slll(a,b,c)             scanf("%lld %lld %lld",&a,&b,&c)
#define     pf(n)                   cout << n << endl;
#define     pl(n)                   printf("%I64d\n",n)
#define     ARPR(ara,s,e)           for(int i=s;i<=e;i++){  cout << ara[i]  << " "; }   cout << '\n';
#define     bug(s)                  cerr << s << '\n';
#define     bug1(s,a)               cerr << s << "      " << a << '\n';
#define     bug2(s,a,b)             cerr << s << "      " << a << "     " << b << '\n';
#define     bug3(s,a,b,c)           cerr << s << "      " << a << "     " << b << "     " << c <<'\n';
#define     bug4(s,a,b,c,d)         cerr << s << "      " << a << "     " << b << "     " << c << "     " << d <<'\n';

#define     all(v)                  v.begin(),v.end()
#define     mem(ara,vl)             memset(ara,vl,sizeof(ara))
#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     MAX                     100
#define     max3(a,b,c)             max(a,max(b,c))
#define     max4(a,b,c,d)           max(a,max3(b,c,d))
#define     min3(a,b,c)             min(a,min(b,c))
#define     min4(a,b,c,d)           min(a,min3(b,c,d))
#define     pii                     pair<int,int>
#define     pll                     pair<ll,ll>
#define     F                       first
#define     S                       second
#define     PI                      acos(-1.00)
#define     eps                     1e-9
#define     Mod                     10000007
#define     inf                     9e18
#define     pb                      push_back
#define     MP(x,y)                 make_pair(x,y)
#define     oc(a)                   __builtin_popcountll(a)

//SET PRECIOSION   cout << fixed ;  cout << setprecision(n) << ans << endl;

/// Ordered SET
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
typedef tree<int, null_type, less_equal<int>, rb_tree_tag,tree_order_statistics_node_update> ordered_multiset;
typedef trie<string,null_type,trie_string_access_traits<>,pat_trie_tag,trie_prefix_search_node_update> pref_trie;

///

ll big_mod(ll a,ll b, ll c){    if(b==0)    return 1;   if(b%2==0)  {   ll d=big_mod(a,b/2,c);      return ((d*d)%c);      }     return (((a%c)*big_mod(a,b-1,c))%c);}
double distance(double x1, double y1, double x2, double y2) {    double xx  = (x1-x2) * (x1-x2);     double yy  = (y1-y2) * (y1-y2);     return sqrt(xx+yy); }

int dx4[]={ 0,-1, 0, 1};
int dy4[]={-1, 0, 1, 0};

int dx8[]={1, 1, 2, 2,-1,-1,-2,-2};
int dy8[]={2,-2, 1,-1, 2,-2, 1,-1};

int Set(int n,int pos){ return n = n | (1<<pos);}
int reset(int n, int pos){ return n = n & ~(1<<pos);}
bool check(int n, int pos){ return (bool) (n & (1<<pos));}

int main()
{
    FASTER
    ll n;
    sf1(n);
    ll ara[n+3];
    ara[0] = 0;
    lop1(i,n)sf1(ara[i]);
    for(int i=1;i<=n;i++)ara[i] += ara[i-1];
    ll ans = 0;
    ll l = 1,h=n,m;
    while(l<=h)
    {
        m = (l+h)/2;
        //bug1("M",m);
        ll b = 0;
        for(ll i=0;i<=n-m;i++)
        {
            ll a = ara[i+m] - ara[i];
            b = max(a,b);
        }
        if(b> m*100LL)
        {
            ans = max(ans,m);
            l = m + 1;
        }
        else h = m - 1;
    }
    pf(ans);
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    long long n,i,r,t=0,tm=0;
    cin>>n;
    for(i=1;i<=n;i++)
    {
        cin>>r;
        if(r/100!=0)
            t+=r/100;
        else
        {
            if(t>tm)
                tm=t;
        }
    }
    if(t>tm)
        tm=t;
    cout<<tm;
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    long long n,i,r,t=0,tm=0;
    cin>>n;
    for(i=1;i<=n;i++)
    {
        cin>>r;
        if(r/100!=0)
            t+=r/100;
        else
        {
            if(t>tm)
                tm=t;
            t=0;
        }
    }
    if(t>tm)
        tm=t;
    cout<<tm;
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    long long n,i,r,t=0,tm=0;
    cin>>n;
    for(i=1;i<=n;i++)
    {
        cin>>r;
        if(r/100!=0)
            t+=r/100;
        else
        {
            if(t>tm)
                tm=t;
            t=1;
        }
    }
    if(t>tm)
        tm=t;
    cout<<tm;
    return 0;
}


#include <iostream>

using namespace std;

int v[5001];

int main()
{
    int n,i,t=0,tm=0;
    cin>>n;
    for(i=1;i<=n;i++)
        cin>>v[i];
    for(i=2;i<=n;i++)
        v[i]+=v[i-1];
    cout<<(v[n]-1)/100;
    return 0;
}


#include <iostream>

using namespace std;

int v[5001];

int main()
{
    int n,i,s,maxx=0,j;
    cin>>n;
    for(i=1; i<=n; i++)
    {
        cin>>v[i];
        s=v[i];
        if(v[i]>=100)
            maxx=max(maxx,1);
        for(j=i-1;j>=1;j--)
        {
            s+=v[j];
            if(s>(i-j+1)*100)
                maxx=max(maxx,i-j+1);
        }
    }
    cout<<maxx;
    return 0;
}


#include <iostream>

using namespace std;

int v[5001];

int main()
{
    int n,i,s,maxx=0;
    cin>>n;
    for(i=1; i<=n; i++)
    {
        cin>>v[i];
        s=v[i];
        if(v[i]>=100)
            maxx=max(maxx,1);
        for(j=i-1;j>=1;j--)
        {
            s+=v[j];
            if(s>(i-j+1)*100)
                maxx=max(maxx,i-j+1);
        }
    }
    cout<<maxx;
    return 0;
}


#include <bits/stdc++.h>
#define ll   long long int
#define endl '\n'
#define M    1000000007
#define D    998244353
#define PI   3.14159265
#define N    200001
using namespace std;

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int tests=1;
    //cin>>tests;
    while(tests-->0)
    {
         int n,ans=0;
         cin>>n;
         int r[n+1];
         r[0]=0;
         for(int i=1;i<=n;i++)
         {
             cin>>r[i];
             r[i]=r[i]+r[i-1];
         }
         for(int i=1;i<=n;i++)
         {
             int c=0;
             for(int j=0;j<i;j++)
             {
                 int sum=r[i]-r[j];
                 if(sum>100*(i-j))
                 {
                     c=(i-j);
                     break;
                 }
            }
            ans=max(c,ans);
         }
         cout<<ans<<endl;
    }
    return 0;
}


#include <bits/stdc++.h>
#include <algorithm>
#include <vector>
#define ll long long int
#define M 1000000007
using namespace std;

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int t=1;
    //cin>>t;
    while(t-->0)
    {
       int n,best=0,sum=0,c;
       cin>>n;
       int r[n],s[n+1];
       for(int i=0;i<n;i++)
       {
           cin>>r[i];
           s[i]=sum;
           sum+=r[i];
       }
       s[n]=sum;
       for(int i=0;i<n;i++)
       {
           c=0;
           for(int j=i+1;j<n;j++)
           {
               if((s[j]-s[i])>100*(j-i))
                c=max(c,j-i);
           }
           best=max(best,c);
       }
       cout<<best<<endl;
    }
    return 0;
}


#include <bits/stdc++.h>
#include <algorithm>
#include <vector>
#define ll long long int
#define M 1000000007
using namespace std;

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int t=1;
    //cin>>t;
    while(t-->0)
    {
       int n,best=0,sum=0,c=0;
       cin>>n;
       int r[n],s[n];
       for(int i=0;i<n;i++)
       {
           cin>>r[i];
           s[i]=sum;
           sum+=r[i];
       }
       s[n-1]=sum;
       for(int i=0;i<n;i++)
       {
           for(int j=i+1;j<n;j++)
           {
               if((s[j]-s[i])>100*(j-i))
                c=max(c,j-i);
           }
           best=max(best,c);
       }
       cout<<best<<endl;
    }
    return 0;
}


#include <iostream>
#include <vector>

using namespace std;

int main() {
    int n, t = 0;
    cin >> n;
    vector <int> a(n, 0);
    vector <long long int> b(n + 1, 0);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        b[i + 1] = b[i] + a[i];
    }
    for (int i = 1; i < n; i++)
        for (int j = i + 1; j <= n; j++)
            if ((b[j] - b[i - 1]) > 100 * (j - i + 1) && (j - i + 1) >= t) {
                t = j - i + 1;
            }
    cout << t << endl;
    return 0;
}


#include <iostream>
#include <vector>

using namespace std;

int main() {
    int n, t = 0;
    long long int s = 0;
    cin >> n;
    vector <int> a(n, 0);
    vector <long long int> b(n + 1, 0);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        b[i + 1] = b[i] + a[i];
    }
    for (int i = 1; i < n; i++)
        for (int j = i + 1; j <= n; j++)
            if ((b[j] - b[i - 1]) > 100 * (j - i) && (b[j] - b[i - 1]) >= s && (j - i) >= t) {
                s = b[j] - b[i - 1];
                t = j - i;
            }
    cout << t << endl;
    return 0;
}


#include <iostream>
#include <vector>

using namespace std;

int main() {
    int n, t = 0;
    cin >> n;
    vector <int> a(n, 0);
    vector <long long int> b(n + 1, 0);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        b[i + 1] = b[i] + a[i];
    }
    for (int i = 1; i < n; i++)
        for (int j = i + 1; j <= n; j++)
            if ((b[j] - b[i - 1]) > 100 * (j - i) && (j - i) >= t) {
                t = j - i;
            }
    cout << t << endl;
    return 0;
}


#include <iostream>
#include <vector>

using namespace std;

int main() {
    int n, t = 0;
    cin >> n;
    vector <int> a(n, 0);
    vector <long long int> b(n + 1, 0);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        b[i + 1] = b[i] + a[i];
    }
    for (int i = 1; i <= n; i++)
        for (int j = i; j <= n; j++)
            if ((b[j] - b[i - 1]) > 100 * (j - i + 1) && (j - i + 1) >= t) {
                t = j - i + 1;
            }
    cout << t << endl;
    return 0;
}


#include <iostream>
#include <vector>

using namespace std;

int main() {
    int n, t = 0;
    long int s = 0;
    cin >> n;
    vector <int> a(n, 0);
    vector <int> b(n + 1);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        b[i + 1] = b[i] + a[i];
    }
    for (int i = 1; i < n; i++)
        for (int j = i + 1; j <= n; j++)
            if ((b[j] - b[i - 1]) > 100 * (j - i) && (b[j] - b[i - 1]) > s) {
                s = b[j] - b[i - 1];
                t = j - i;
            }
    cout << t << endl;
    return 0;
}


#include <iostream>
#include <vector>

using namespace std;

int main() {
    int n, t = 0;
    long long int s = 0;
    cin >> n;
    vector <int> a(n, 0);
    vector <long long int> b(n + 1, 0);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        b[i + 1] = b[i] + a[i];
    }
    for (int i = 1; i < n; i++)
        for (int j = i + 1; j <= n; j++)
            if ((b[j] - b[i - 1]) > 100 * (j - i) && (b[j] - b[i - 1]) > s) {
                s = b[j] - b[i - 1];
                t = j - i;
            }
    cout << t << endl;
    return 0;
}


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

int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	//code here;
	ll n; cin>>n;
	ll ar[n];
	for(ll i=0;i<n;i++) cin>>ar[i];
	ll l=1,h=n,ans=0;
	while(l<=h) {
		ll mid=(l+h)/2,sum=0,i;
		for(i=0;i<mid;i++) sum+=ar[i];
		if(sum>100*mid) {
			ans=max(ans,mid);
			l=h+1;
			continue;
		}
		for(i=mid;i<n;i++) {
			sum+=ar[i]-ar[i-mid];
			if(sum>100*mid) break;
		}
		if(i<n) {
			ans=max(ans,mid);
			l=h+1;
		} else h=mid-1;
	}
	cout<<ans<<endl;
	return 0;
}


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

int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	//code here;
	ll n; cin>>n;
	ll ar[n],j=n;
	for(ll i=0;i<n;i++) cin>>ar[i];
	while(j>=1) {
		ll sum=0;
		for(ll i=0;i<j;i++) sum+=ar[i];
		if(sum>100*j) {
			cout<<j<<endl;
			return 0;
		}
		for(ll i=j;i<n;i++) {
			sum+=ar[i]-ar[i-j];
			if(sum>100*j) {
				cout<<j<<endl;
				return 0;
			}
		}
		j--;
	}
	cout<<"0"<<endl;
	return 0;
}


#include<iostream>
#include<string>
#include<string.h>
#include<cstring>
#include<math.h>
#include<iomanip>
#include<vector>
#include<cmath>
#include<algorithm>
#include<numeric>
#include<cctype>
#include<utility>
#include<set>
#include<map>
#include<sstream>
#include<iterator>
#include<limits>
#include<map>
#include<deque>
#include<stack>
#include<queue>
using namespace std;
#define pb push_back
#define ff(i,a,b) for(int i=a;i<b;++i)
#define ffl(i,a,b) for(long long i=a;i<b;++i)
#define all(v) v.begin(), v.end()
#define X first
#define Y second
#define mp make_pair
typedef long long ll;
typedef std::vector<int> vec;
typedef std::vector<long long> vecl;
typedef map<int,int> mii;
typedef map<ll,ll> mll;
typedef std::pair<int,int> pii;
typedef pair<ll,ll> pll;
const int md = 1000000007;
#define pi 3.141592653589793238462643383279

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

 	int tt{},T{};
 	//cin>>tt;T=tt;
    tt=1;
 	while(tt--){
        //cout<<"------------- #"<<T-tt<<endl;
        int n{},m{},ans{},k{},a{},b{},c{},f{};

        cin>>n;
        vec v(n);
        int z[n]{};
        ff(i,0,n){
            cin>>a;
            v[i]=a-100;
            if(i==0){
                z[i]=v[i];
            }else{
                z[i]=z[i-1]+v[i];
            }
            if(z[i]>0)ans=1;
        }
        ff(i,0,n-1){
            ff(j,i+1,n){
                a=i-1;
                if(a<0)a=0;
                if(z[j]-z[a]>0){
                    ans=max(ans,j-a+1);
                }
            }
        }
        cout<<ans<<"\n";

    }

	return 0;
}


#include<iostream>
#include<string>
#include<string.h>
#include<cstring>
#include<math.h>
#include<iomanip>
#include<vector>
#include<cmath>
#include<algorithm>
#include<numeric>
#include<cctype>
#include<utility>
#include<set>
#include<map>
#include<sstream>
#include<iterator>
#include<limits>
#include<map>
#include<deque>
#include<stack>
#include<queue>
using namespace std;
#define pb push_back
#define ff(i,a,b) for(int i=a;i<b;++i)
#define ffl(i,a,b) for(long long i=a;i<b;++i)
#define all(v) v.begin(), v.end()
#define X first
#define Y second
#define mp make_pair
typedef long long ll;
typedef std::vector<int> vec;
typedef std::vector<long long> vecl;
typedef map<int,int> mii;
typedef map<ll,ll> mll;
typedef std::pair<int,int> pii;
typedef pair<ll,ll> pll;
const int md = 1000000007;
#define pi 3.141592653589793238462643383279

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

 	int tt{},T{};
 	//cin>>tt;T=tt;
    tt=1;
 	while(tt--){
        //cout<<"------------- #"<<T-tt<<endl;
        int n{},m{},ans{},k{},a{},b{},c{},f{};

        cin>>n;
        vec v(n);
        int z[n]{};
        ff(i,0,n){
            cin>>a;
            v[i]=a-100;
            if(i==0){
                z[i]=v[i];
            }else{
                z[i]=z[i-1]+v[i];
            }
            if(v[i]>0)ans=1;
        }
        ff(i,0,n-1){
            ff(j,i+1,n){
                a=i-1;
                if(a<0)a=0;
                if(z[j]-z[a]>0){
                    ans=max(ans,j-a+1);
                }
            }
        }
        cout<<ans<<"\n";

    }

	return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <cmath>
#include <set>
#include <map>
#include <cstdio>
#include <stdlib.h>
#include <stack>
#include <numeric>
#include <bitset>
#include <cctype>
#include <list>
#include <assert.h>
#include <random>
#include <unordered_map>
#include <ctime>
typedef long long ll;
#define MAX 100125
using namespace std;
#define INF 2147483647
#define infL (1LL<<60)
#define inf (1<<30)
#define MOD 1000000007
#define EPS 1e-9
#define Gr 9.8
#define PI acos(-1)
#define REP(i,n) for(int (i)=0;(i)<(int)(n);(i)++)
#define REQ(i,n) for(int (i)=1;(i)<=(int)(n);(i)++)
#define lch (rt<<1)
#define rch (rt<<1|1)
bool debug = 1;
int n,m,k;
int dx[4] = {0,1,0,-1}, dy[4] = {1,0,-1,0};
ll ln, lk, lm;

bool ft[MAX];
vector<int> mp[MAX], vp, Ans;
int dg[MAX], col[MAX], cnt, fri[MAX], tfi[MAX], tim[MAX];
void dfs(int x, int pa) {
    col[x]=cnt;
    vp.push_back(x);
    for(int c:mp[x]) if (!ft[c] && c!=pa) {
//        fri[x]++; fri[c]++;
        if(col[c]==0) dfs(c,x);
    }
}
struct uz {
    int a,b, id;
    uz(){}
    uz(int a, int b, int id) : a(a),b(b),id(id){}
    bool operator < (const uz &o) const{
        if ((ll)a*o.b == (ll)b*o.a) return id<o.id;
        return (ll)a*o.b < (ll)b*o.a;
    }
};
uz tuz = uz(-1, 1, 0);

void cal() {
    set<uz> s;
    for(int x : vp) {
        s.insert(uz(fri[x], dg[x], x));
        tfi[x]=fri[x];
    }
    int whe = -1, T=1;
    while(!s.empty()) {
        if (tuz < *s.begin()) {
            tuz = *s.begin();
            whe = T;
        }
        auto u = *s.begin();
        tim[u.id] = T++;
        s.erase(s.begin());
        for(int c : mp[u.id]) if (col[c]==cnt && tim[c]==0) {
            s.erase(s.find(uz(tfi[c], dg[c], c)));
            tfi[c]--;
            s.insert(uz(tfi[c], dg[c], c));
        }
    }
    if (whe == -1) return;
    Ans.clear();
    for(int c : vp) if (tim[c] >= whe) Ans.push_back(c);
}
int main() {
    scanf("%d%d%d", &n,  &m, &k);
    REP(i,k) {
        int x; scanf("%d", &x); ft[x]=1;
    }
    for(int i=0,a,b;i<m;i++) {
        scanf("%d%d", &a, &b);
        mp[a].push_back(b);
        mp[b].push_back(a);
        dg[a]++; dg[b]++;
        if (!ft[a] && !ft[b]) {
            fri[a]++; fri[b]++;
        }
    }
    REQ(i,n) if (!ft[i] && col[i]==0) {
        cnt++; vp.clear();
        dfs(i, 0); cal();
    }
    printf("%d\n", Ans.size());
    for(int c: Ans) printf("%d ",c);
    return 0;
}


#include<bits/stdc++.h>
#define ll long long
#define ss second
#define ff first
#define pb push_back
using namespace std;

const int N = 1e6 + 69;

int n,m,k,x,y,ind;
double ans;

double mez[N];

int fix[N],A[N];

vector<int>gr[N],v;

set< pair<double,int> > S;

void dfs(int x){

    fix[x] = 1;

    for(int i=0;i<gr[x].size();i++){
        int to = gr[x][i];
        if(A[to])mez[x]--;
        if(fix[to])continue;
        dfs(to);
    }

    if(!A[x])
    S.insert({mez[x]/(double)gr[x].size(),x});
}

int main(){

    cin>>n>>m>>k;
    for(int i=1;i<=k;i++){
        cin>>x;
        A[x] = 1;
    }

    for(int i=0;i<m;i++){
        cin>>x>>y;
        gr[x].pb(y); mez[x]++;
        gr[y].pb(x); mez[y]++;
    }

    for(int i=1;i<=n;i++){
        if(fix[i])continue;
        dfs(i);
    }

    for(int i=1;i<=n;i++){
        fix[i] = 0;
    }

    while(S.size()){

        pair<double,int> p = *S.begin();

        int x = p.ss;
        double val = p.ff;
        //cout<<val<<endl;
        if(ans<val){
            ind = v.size();
            ans = val;
        }

        v.pb(x);
        fix[x] = 1;
        S.erase({mez[x]/gr[x].size(),x});
        for(int i=0;i<gr[x].size();i++){
            int to = gr[x][i];
            if(A[to] || fix[to])continue;
            S.erase({mez[to]/(double)gr[to].size(),to});
            mez[to]--;
            S.insert({mez[to]/(double)gr[to].size(),to});
        }

    }

    cout<<v.size()-ind<<endl;
    for(int i=ind;i<v.size();i++){
        cout<<v[i]<<" ";
    }
}


#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vec<T>>;
template<class T> bool chmin(T& a,T b){if(a>b) {a = b; return true;} return false;}
template<class T> bool chmax(T& a,T b){if(a<b) {a = b; return true;} return false;}
#define all(x) (x).begin(),(x).end()
#define debug(x)  cerr << #x << " = " << (x) << endl;

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    int N,M,K;
    cin >> N >> M >> K;
    set<int> s;
    for(int i=0;i<K;i++){
        int a;
        cin >> a;
        a--;
        s.insert(a);
    }
    vec<int> deg(N);
    vvec<int> g(N);
    for(int i=0;i<M;i++){
        int a,b;
        cin >> a >> b;
        a--,b--;
        g[a].push_back(b);
        g[b].push_back(a);
        deg[a]++,deg[b]++;
    }
    struct state{
        ll a,b;
        int id;
        bool operator<(const state& r)const{
            return a*r.b>b*r.a;
        }
    };
    priority_queue<state> Q;
    vec<int> cnt(N);
    for(int i=0;i<N;i++) if(!s.count(i)){
        for(auto& x:g[i]) if(!s.count(x)) cnt[i]++;
        Q.push({cnt[i],deg[i],i});
    }
    vec<int> list;
    vec<int> removed(N);
    int ti = 0;
    double val = 0;
    int loop = 0;
    while(!Q.empty()){
        auto [a,b,id] = Q.top(); Q.pop();
        if(removed[id]) continue;
        removed[id] = 1;
        if(chmax(val,1.0*a/b)){
            ti = loop;
        }
        for(auto& c:g[id]) if(!s.count(c)){
            cnt[c]--;
            Q.push({cnt[c],deg[c],c});
        }
        list.push_back(id);
        loop++;
    }
    vec<int> ans;
    int n = list.size();
    cout << n-ti << "\n";
    for(int i=n-1;i>=ti;i--) cout << list[i]+1 << (i!=ti? " ":"\n");
}


#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vec<T>>;
template<class T> bool chmin(T& a,T b){if(a>b) {a = b; return true;} return false;}
template<class T> bool chmax(T& a,T b){if(a<b) {a = b; return true;} return false;}
#define all(x) (x).begin(),(x).end()
#define debug(x)  cerr << #x << " = " << (x) << endl;

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    int N,M,K;
    cin >> N >> M >> K;
    set<int> s;
    for(int i=0;i<K;i++){
        int a;
        cin >> a;
        a--;
        s.insert(a);
    }
    vec<int> deg(N);
    vvec<int> g(N);
    for(int i=0;i<M;i++){
        int a,b;
        cin >> a >> b;
        a--,b--;
        g[a].push_back(b);
        g[b].push_back(a);
        deg[a]++,deg[b]++;
    }
    struct state{
        ll a,b;
        int id;
        bool operator<(const state& r)const{
            return a*r.b>b*r.a;
        }
    };
    priority_queue<state> Q;
    vec<int> cnt(N);
    for(int i=0;i<N;i++) if(!s.count(i)){
        for(auto& x:g[i]) if(!s.count(x)) cnt[i]++;
        Q.push({cnt[i],deg[i],i});
    }
    vec<int> list;
    vec<int> removed(N);
    int ti = 0;
    double val = 0;
    int loop = 0;
    while(!Q.empty()){
        auto [a,b,id] = Q.top(); Q.pop();
        if(removed[id]) continue;
        removed[id] = 1;
        if(chmax(val,1.0*a/b)){
            ti = loop;
        }
        for(auto& c:g[id]) if(!s.count(c)){
            cnt[c]--;
            Q.push({cnt[c],deg[c],c});
        }
        list.push_back(id);
        loop++;
    }
    vec<int> ans;
    int n = list.size();
    cerr << n-ti << "\n";
    for(int i=n-1;i>=ti;i--) cout << list[i]+1 << (i!=ti? " ":"\n");
}


#include <bits/stdc++.h>
using namespace std;
const int maxn=1e5+5;
int degree[maxn];
bool visited[maxn];
vector<int> g[maxn];
int removeIndex[maxn];
class node
{
public:
	int id,bad;
	node(){}
	node(int id,int bad)
	{
		this->id=id;
		this->bad=bad;
	}
	bool operator < (const node& other) const
	{
		return (bad*degree[other.id]<other.bad*degree[id]);
	}
};

int32_t main()
{
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  int n,m,k;
  cin>>n>>m>>k;
  vector<bool> fort(n+1,false);
  for(int i=0;i<k;i++)
  {
  	int id;
  	cin>>id;
  	fort[id]=true;
  }
  vector<node> allNodes(n+1);
  for(int i=1;i<=n;i++)
  	allNodes[i].id=i,allNodes[i].bad=0;
  for(int i=0;i<m;i++)
  {
  	int u,v;
  	cin>>u>>v;
  	g[u].push_back(v);
  	g[v].push_back(u);
  	degree[u]++;
  	degree[v]++;
  	if(fort[u]) allNodes[v].bad++;
  	if(fort[v]) allNodes[u].bad++;
  }
  int num=1,den=1,id=0;
  int rem=0;
  priority_queue <node> pq;
  for(int i=1;i<=n;i++) if(!fort[i]) pq.push(allNodes[i]);
  for(int i=1;i<=n;i++) if(fort[i]) visited[i]=true;
  while(pq.size())
  {
  	node curr=pq.top();
  	pq.pop();
  	if(visited[curr.id]) continue;
  	visited[curr.id]=true;
  	removeIndex[rem++]=curr.id;
  	int tn=curr.bad,td=degree[curr.id];
  	if (num*td>den*tn) {num=tn; den=td; id=rem-1;}
  	for(auto&itr:g[curr.id])
  	{
  		allNodes[itr].bad++;
  		if(!visited[itr])
  		{
  			pq.push(allNodes[itr]);
  		}
  	}
  }
  vector<int> result;
  for(int i=id;i<rem;i++) result.push_back(removeIndex[i]);
  cout<<result.size()<<'\n';
	for(auto&itr:result) cout<<itr<<' ';
	cout<<'\n';

  return 0;
}


#include <bits/stdc++.h>
#define int long long int
using namespace std;
const int maxn=1e5+5;
int degree[maxn];
bool visited[maxn];
vector<int> g[maxn];
int removeIndex[maxn];
class node
{
public:
	int id,bad;
	node(){}
	node(int id,int bad)
	{
		this->id=id;
		this->bad=bad;
	}
	bool operator < (const node& other) const
	{
		return (bad*degree[other.id]<other.bad*degree[id]);
	}
};

int32_t main()
{
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  int n,m,k;
  cin>>n>>m>>k;
  vector<bool> fort(n+1,false);
  for(int i=0;i<k;i++)
  {
  	int id;
  	cin>>id;
  	fort[id]=true;
  }
  vector<node> allNodes(n+1);
  for(int i=1;i<=n;i++)
  	allNodes[i].id=i,allNodes[i].bad=0;
  for(int i=0;i<m;i++)
  {
  	int u,v;
  	cin>>u>>v;
  	g[u].push_back(v);
  	g[v].push_back(u);
  	degree[u]++;
  	degree[v]++;
  	if(fort[u]) allNodes[v].bad++;
  	if(fort[v]) allNodes[u].bad++;
  }
  int num=1,den=1,id=0;
  int rem=0;
  priority_queue <node> pq;
  for(int i=1;i<=n;i++) if(!fort[i]) pq.push(allNodes[i]);
  for(int i=1;i<=n;i++) if(fort[i]) visited[i]=true;
  while(pq.size())
  {
  	node curr=pq.top();
  	pq.pop();
  	if(visited[curr.id]) continue;
  	visited[curr.id]=true;
  	removeIndex[rem++]=curr.id;
  	int tn=curr.bad,td=degree[curr.id];
  	if (num*td>den*tn) {num=tn; den=td; id=rem-1;}
  	for(auto&itr:g[curr.id])
  	{
  		allNodes[itr].bad++;
  		if(!visited[itr])
  		{
  			pq.push(allNodes[itr]);
  		}
  	}
  }
  vector<int> result;
  for(int i=id;i<rem;i++) result.push_back(removeIndex[i]);
  cout<<result.size()<<'\n';
	for(auto&itr:result) cout<<itr<<' ';
	cout<<'\n';

  return 0;
}


#include <bits/stdc++.h>
using namespace std;
const int maxn=1e5+5;
int degree[maxn];
bool visited[maxn];
vector<int> g[maxn];
int removeIndex[maxn];
class node
{
public:
	int id,bad;
	node(){}
	node(int id,int bad)
	{
		this->id=id;
		this->bad=bad;
	}
	bool operator < (const node& other) const
	{
		return (bad*degree[other.id]<other.bad*degree[id]);
	}
};

int32_t main()
{
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  int n,m,k;
  cin>>n>>m>>k;
  vector<bool> fort(n+1,false);
  for(int i=0;i<k;i++)
  {
  	int id;
  	cin>>id;
  	fort[id]=true;
  }
  vector<node> allNodes(n+1);
  for(int i=1;i<=n;i++)
  	allNodes[i].id=i,allNodes[i].bad=0;
  for(int i=0;i<m;i++)
  {
  	int u,v;
  	cin>>u>>v;
  	g[u].push_back(v);
  	g[v].push_back(u);
  	degree[u]++;
  	degree[v]++;
  	if(fort[u]) allNodes[v].bad++;
  	if(fort[v]) allNodes[u].bad++;
  }
  int num=1,den=1,id=-1;
  int rem=0;
  priority_queue <node> pq;
  for(int i=1;i<=n;i++) if(!fort[i]) pq.push(allNodes[i]);
  for(int i=1;i<=n;i++) if(fort[i]) visited[i]=true;
  while(pq.size())
  {
  	node curr=pq.top();
  	pq.pop();
  	if(visited[curr.id]) continue;
  	visited[curr.id]=true;
  	removeIndex[rem++]=curr.id;
  	int tn=curr.bad,td=degree[curr.id];
  	if (num*td>den*tn) {num=tn; den=td; id=rem-1;}
  	for(auto&itr:g[curr.id])
  	{
  		allNodes[itr].bad++;
  		if(!visited[itr])
  		{
  			pq.push(allNodes[itr]);
  		}
  	}
  }
  vector<int> result;
  for(int i=id;i<rem;i++) result.push_back(removeIndex[i]);
  cout<<result.size()<<'\n';
	for(auto&itr:result) cout<<itr<<' ';
	cout<<'\n';

  return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ll long long int
#define ordered_set tree < ll ,  null_type ,  less<ll> ,  rb_tree_tag ,  tree_order_statistics_node_update >
//added two more functions to set
//(1)*(set.find_by_order(k))[kth element in the sorted set]
//(2)set.order_of_key(k)[count of elements strictly less than k]
typedef vector< int > vi;
typedef vector< ll > lvi;
typedef vector< vi > vvi;
typedef vector< lvi > lvvi;
typedef pair< int,int > ii;
typedef pair< ll,ll > lii;
#define sz(a) int((a).size())
#define pb push_back
#define all(c) (c).begin(),(c).end()
#define tr(c,i) for(auto i = (c).begin(); i != (c).end(); i++)//remember i is an iterator
#define present(c,x) ((c).find(x) != (c).end())//for sets,maps,multimaps
#define cpresent(c,x) (find(all(c),x) != (c).end())//for vectors
#define tc(t) int (t); cin>>(t);while((t)--)
#define ff first
#define ss second
#define mp make_pair
#define ld long double
#define ull unsigned long long int
#define mod 1000000007
vvi adj;
vi mark,flaw;
ll n,m,k;
ld d[200000];
ld pr=0.0000000001;
bool visited[200000];
void dks()
{
	priority_queue<pair<ld,int>,vector<pair<ld,int>>,greater<pair<ld,int>>> pq;
	for(int i=1;i<=n;i++)
	{
		if(!mark[i])
		{
			if(adj[i].size()==0)
			{
				mark[i]=1;
				continue;
				// cout<<"1\n";
				// cout<<i<<endl;
				// return ;
			}
			ld val=((ld)(adj[i].size()-flaw[i])/(ld)adj[i].size());
			pq.push({val,i});
			d[i]=val;
		}
	}
	ld ans=-1;
	vi v1;
	// cout<<"YES\n";
	while(!pq.empty())
	{
		ld val=pq.top().ff;
		int idx=pq.top().ss;
		pq.pop();
		if(val-d[idx]>pr || mark[idx]) continue;//basically value not equal to d[idx]
		mark[idx]=1;
		// visited[idx]=true;
		// cout<<val<<"  "<<idx<<endl;
		if(val>ans)
		{
			ans=val;
			v1.clear();
		}
		v1.pb(idx);
		for(auto next:adj[idx])
		{
			if(mark[next]) continue;
			// if(visited[next]) continue;
			ld val1=d[next]-((ld)1/(ld)adj[next].size());
			d[next]=val1;
			pq.push({val1,next});
		}
	}
	// cout<<"YES\n";
	cout<<v1.size()<<endl;
	for(int i=0;i<(int)v1.size();i++)
	{
		cout<<v1[i]<<" ";
	}
	cout<<endl;
}
int main()
{
	// ios_base::sync_with_stdio(false);
 //    cin.tie(NULL);
	cin>>n>>m>>k;
	// cout<<"YES\n";
	adj.resize(n+2);
	mark.resize(n+2);
	flaw.resize(n+2,0);
	for(int i=0;i<k;i++)
	{
		int x;
		cin>>x;
		mark[x]=1;
	}
	// cout<<"YES\n";
	for(int i=0;i<m;i++)
	{
		int x,y;
		cin>>x>>y;
		adj[x].pb(y);
		adj[y].pb(x);
	}
	// cout<<"YES\n";
	for(int i=1;i<=n;i++)
	{
		if(mark[i])
		{
			for(auto next:adj[i])
			{
				if(!mark[next])
				flaw[next]++;
			}
		}
	}
	// cout<<"YES\n";
	dks();
	// cout<<"YES1\n";
	return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ll long long int
#define ordered_set tree < ll ,  null_type ,  less<ll> ,  rb_tree_tag ,  tree_order_statistics_node_update >
//added two more functions to set
//(1)*(set.find_by_order(k))[kth element in the sorted set]
//(2)set.order_of_key(k)[count of elements strictly less than k]
typedef vector< int > vi;
typedef vector< ll > lvi;
typedef vector< vi > vvi;
typedef vector< lvi > lvvi;
typedef pair< int,int > ii;
typedef pair< ll,ll > lii;
#define sz(a) int((a).size())
#define pb push_back
#define all(c) (c).begin(),(c).end()
#define tr(c,i) for(auto i = (c).begin(); i != (c).end(); i++)//remember i is an iterator
#define present(c,x) ((c).find(x) != (c).end())//for sets,maps,multimaps
#define cpresent(c,x) (find(all(c),x) != (c).end())//for vectors
#define tc(t) int (t); cin>>(t);while((t)--)
#define ff first
#define ss second
#define mp make_pair
#define ld long double
#define ull unsigned long long int
#define mod 1000000007
vvi adj;
vi mark,flaw;
ll n,m,k;
ld d[200000];
ld pr=0.0000000001;
bool visited[200000];
void dks()
{
	priority_queue<pair<ld,int>,vector<pair<ld,int>>,greater<pair<ld,int>>> pq;
	for(int i=1;i<=n;i++)
	{
		if(!mark[i])
		{
			if(adj[i].size()==0)
			{
				continue;
				// cout<<"1\n";
				// cout<<i<<endl;
				// return ;
			}
			ld val=((ld)(adj[i].size()-flaw[i])/(ld)adj[i].size());
			pq.push({val,i});
			d[i]=val;
		}
	}
	ll ans=-1;
	vi v1;
	// cout<<"YES\n";
	while(!pq.empty())
	{
		ld val=pq.top().ff;
		int idx=pq.top().ss;
		pq.pop();
		if(val-d[idx]>pr) continue;
		visited[idx]=true;
		// cout<<val<<"  "<<idx<<endl;
		if(val>ans)
		{
			ans=val;
			v1.clear();
		}
		v1.pb(idx);
		for(auto next:adj[idx])
		{
			if(mark[next]) continue;
			if(visited[next]) continue;
			ld val1=d[next]-((ld)1/(ld)adj[next].size());
			d[next]=val1;
			pq.push({val1,next});
		}
	}
	// cout<<"YES\n";
	cout<<v1.size()<<endl;
	for(int i=0;i<(int)v1.size();i++)
	{
		cout<<v1[i]<<" ";
	}
	cout<<endl;
}
int main()
{
	// ios_base::sync_with_stdio(false);
 //    cin.tie(NULL);
	cin>>n>>m>>k;
	// cout<<"YES\n";
	adj.resize(n+2);
	mark.resize(n+2);
	flaw.resize(n+2,0);
	for(int i=0;i<k;i++)
	{
		int x;
		cin>>x;
		mark[x]=1;
	}
	// cout<<"YES\n";
	for(int i=0;i<m;i++)
	{
		int x,y;
		cin>>x>>y;
		adj[x].pb(y);
		adj[y].pb(x);
	}
	// cout<<"YES\n";
	for(int i=1;i<=n;i++)
	{
		if(mark[i])
		{
			for(auto next:adj[i])
			{
				if(!mark[next])
				flaw[next]++;
			}
		}
	}
	// cout<<"YES\n";
	dks();
	// cout<<"YES1\n";
	return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ll long long int
#define ordered_set tree < ll ,  null_type ,  less<ll> ,  rb_tree_tag ,  tree_order_statistics_node_update >
//added two more functions to set
//(1)*(set.find_by_order(k))[kth element in the sorted set]
//(2)set.order_of_key(k)[count of elements strictly less than k]
typedef vector< int > vi;
typedef vector< ll > lvi;
typedef vector< vi > vvi;
typedef vector< lvi > lvvi;
typedef pair< int,int > ii;
typedef pair< ll,ll > lii;
#define sz(a) int((a).size())
#define pb push_back
#define all(c) (c).begin(),(c).end()
#define tr(c,i) for(auto i = (c).begin(); i != (c).end(); i++)//remember i is an iterator
#define present(c,x) ((c).find(x) != (c).end())//for sets,maps,multimaps
#define cpresent(c,x) (find(all(c),x) != (c).end())//for vectors
#define tc(t) int (t); cin>>(t);while((t)--)
#define ff first
#define ss second
#define mp make_pair
#define ld long double
#define ull unsigned long long int
#define mod 1000000007
vvi adj;
vi mark,flaw;
ll n,m,k;
ld d[200000];
ld pr=0.0000000001;
bool visited[200000];
void dks()
{
	priority_queue<pair<ld,int>,vector<pair<ld,int>>,greater<pair<ld,int>>> pq;
	for(int i=1;i<=n;i++)
	{
		if(!mark[i])
		{
			if(adj[i].size()==0)
			{
				cout<<"1\n";
				cout<<i<<endl;
				return ;
			}
			ld val=((ld)(adj[i].size()-flaw[i])/(ld)adj[i].size());
			pq.push({val,i});
			d[i]=val;
		}
	}
	ll ans=-1;
	vi v1;
	// cout<<"YES\n";
	while(!pq.empty())
	{
		ld val=pq.top().ff;
		int idx=pq.top().ss;
		pq.pop();
		if(val-d[idx]>pr) continue;
		visited[idx]=true;
		// cout<<val<<"  "<<idx<<endl;
		if(val>ans)
		{
			ans=val;
			v1.clear();
		}
		v1.pb(idx);
		for(auto next:adj[idx])
		{
			if(mark[next]) continue;
			if(visited[next]) continue;
			ld val1=d[next]-((ld)1/(ld)adj[next].size());
			d[next]=val1;
			pq.push({val1,next});
		}
	}
	// cout<<"YES\n";
	cout<<v1.size()<<endl;
	for(int i=0;i<(int)v1.size();i++)
	{
		cout<<v1[i]<<" ";
	}
	cout<<endl;
}
int main()
{
	// ios_base::sync_with_stdio(false);
 //    cin.tie(NULL);
	cin>>n>>m>>k;
	// cout<<"YES\n";
	adj.resize(n+2);
	mark.resize(n+2);
	flaw.resize(n+2,0);
	for(int i=0;i<k;i++)
	{
		int x;
		cin>>x;
		mark[x]=1;
	}
	// cout<<"YES\n";
	for(int i=0;i<m;i++)
	{
		int x,y;
		cin>>x>>y;
		adj[x].pb(y);
		adj[y].pb(x);
	}
	// cout<<"YES\n";
	for(int i=1;i<=n;i++)
	{
		if(mark[i])
		{
			for(auto next:adj[i])
			{
				if(!mark[next])
				flaw[next]++;
			}
		}
	}
	// cout<<"YES\n";
	dks();
	// cout<<"YES1\n";
	return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ll long long int
#define ordered_set tree < ll ,  null_type ,  less<ll> ,  rb_tree_tag ,  tree_order_statistics_node_update >
//added two more functions to set
//(1)*(set.find_by_order(k))[kth element in the sorted set]
//(2)set.order_of_key(k)[count of elements strictly less than k]
typedef vector< int > vi;
typedef vector< ll > lvi;
typedef vector< vi > vvi;
typedef vector< lvi > lvvi;
typedef pair< int,int > ii;
typedef pair< ll,ll > lii;
#define sz(a) int((a).size())
#define pb push_back
#define all(c) (c).begin(),(c).end()
#define tr(c,i) for(auto i = (c).begin(); i != (c).end(); i++)//remember i is an iterator
#define present(c,x) ((c).find(x) != (c).end())//for sets,maps,multimaps
#define cpresent(c,x) (find(all(c),x) != (c).end())//for vectors
#define tc(t) int (t); cin>>(t);while((t)--)
#define ff first
#define ss second
#define mp make_pair
#define ld long double
#define ull unsigned long long int
#define mod 1000000007
vvi adj;
vi mark,flaw;
ll n,m,k;
ld d[200000];
ld pr=0.00000001;
bool visited[200000];
void dks()
{
	priority_queue<pair<ld,int>,vector<pair<ld,int>>,greater<pair<ld,int>>> pq;
	for(int i=1;i<=n;i++)
	{
		if(!mark[i])
		{
			if(adj[i].size()==0)
			{
				cout<<"1\n";
				cout<<i<<endl;
				return ;
			}
			ld val=((ld)(adj[i].size()-flaw[i])/(ld)adj[i].size());
			pq.push({val,i});
			d[i]=val;
		}
	}
	ll ans=-1;
	vi v1;
	// cout<<"YES\n";
	while(!pq.empty())
	{
		ld val=pq.top().ff;
		int idx=pq.top().ss;
		pq.pop();
		if(val>d[idx]) continue;
		visited[idx]=true;
		// cout<<val<<"  "<<idx<<endl;
		if(val>ans)
		{
			ans=val;
			v1.clear();
		}
		v1.pb(idx);
		for(auto next:adj[idx])
		{
			if(mark[next]) continue;
			if(visited[next]) continue;
			ld val1=d[next]-((ld)1/(ld)adj[next].size());
			d[next]=val1;
			pq.push({val1,next});
		}
	}
	// cout<<"YES\n";
	cout<<v1.size()<<endl;
	for(int i=0;i<(int)v1.size();i++)
	{
		cout<<v1[i]<<" ";
	}
	cout<<endl;
}
int main()
{
	// ios_base::sync_with_stdio(false);
 //    cin.tie(NULL);
	cin>>n>>m>>k;
	// cout<<"YES\n";
	adj.resize(n+2);
	mark.resize(n+2);
	flaw.resize(n+2,0);
	for(int i=0;i<k;i++)
	{
		int x;
		cin>>x;
		mark[x]=1;
	}
	// cout<<"YES\n";
	for(int i=0;i<m;i++)
	{
		int x,y;
		cin>>x>>y;
		adj[x].pb(y);
		adj[y].pb(x);
	}
	// cout<<"YES\n";
	for(int i=1;i<=n;i++)
	{
		if(mark[i])
		{
			for(auto next:adj[i])
			{
				if(!mark[next])
				flaw[next]++;
			}
		}
	}
	// cout<<"YES\n";
	dks();
	// cout<<"YES1\n";
	return 0;
}