using namespace std;
const int NMAX = 2e5 + 11;
int n, a[NMAX], seg[4 * NMAX];
void build(int a[], int v, int tl, int tr)
{
    if (tl == tr)
        seg[v] = a[tl];
    else
    {
        int tm = (tl + tr) / 2;
        build(a, 2 * v, tl, tm);
        build(a, 2 * v + 1, tm + 1, tr);
        seg[v] = seg[2 * v] & seg[2 * v + 1];
    }
}
int query(int v, int tl, int tr, int ql, int qr)
{
    if (ql > qr)
        return -1;
    if (ql == tl and qr == tr)
        return seg[v];
    else
    {
        int tm = (tl + tr) / 2;
        return query(2 * v, tl, tm, ql, min(tm, qr)) &
               query(2 * v + 1, tm + 1, tr, max(tm + 1, ql), qr);
    }
}
int main(void)
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int t, k, ans, l, r;
    cin >> t;
    while (t--)
    {
        cin >> n >> k;
        for (int i = 0; i < n; ++i)
            cin >> a[i];
        memset(seg, 0, sizeof(seg));
        build(a, 1, 0, n - 1);
        for (int i = 0; i < n; ++i)
        {
            l = i - k;
            r = i + k;
            if (k >= n / 2)
                ans = query(1, 0, n - 1, 0, n - 1);
            else if (0 <= l and r < n)
                ans = query(1, 0, n - 1, l, r);
            else
            {
                if (l < 0)
                {
                    ans = query(1, 0, n - 1, 0, r) &
                          query(1, 0, n - 1, n + l, n - 1);
                }
                if (r >= n)
                {
                    ans = query(1, 0, n - 1, l, n - 1) &
                          query(1, 0, n - 1, 0, r - n);
                }
            }
            cout << ans << " ";
        }
        cout << endl;
    }
    return 0;
}

using namespace std;
const int CMAX = 26;
struct node
{
    int cnt;
    node *children[CMAX];
};
struct trie
{
    node *root;
    trie() { root = new node(); }
    void insert(string s)
    {
        node *cur = root;
        for (auto c : s)
        {
            int j = c - 'a';
            if (cur->children[j] == nullptr)
                cur->children[j] = new node();
            cur = cur->children[j];
            cur->cnt += 1;
        }
    }
    int query(string prefix)
    {
        node *cur = root;
        for (auto c : prefix)
        {
            int j = c - 'a';
            if (cur->children[j] == nullptr)
                return 0;
            cur = cur->children[j];
        }
        return cur->cnt;
    }
};
int main(void)
{
    int n, q;
    string s;
    trie t;
    cin >> n >> q;
    while (n--)
    {
        cin >> s;
        t.insert(s);
    }
    while (q--)
    {
        cin >> s;
        cout << t.query(s) << endl;
    }
    return 0;
}

using namespace std;
string ans[6] = {"1/6", "1/3", "1/2", "2/3", "5/6", "1/1"};
int main(void)
{
    int y, w, x;
    cin >> y >> w;
    x = 6 - max(y, w) + 1;
    cout << ans[x - 1] << endl;
    return 0;
}

using namespace std;
using pii = pair<int, int>;
const int NMAX = 1e3 + 11;
pii a[NMAX];
int main(void)
{
    int n, ai;
    cin >> n;
    for (int i = 1; i <= n; ++i)
    {
        cin >> ai;
        a[i - 1] = {ai, i};
    }
    sort(a, a + n);
    if (a[0].first == a[n - 1].first)
        cout << "Exemplary pages." << endl;
    else
    {
        int diff = a[n - 1].first - a[0].first;
        if (diff % 2 == 0)
        {
            bool recoverable = false;
            int normal = a[0].first + diff / 2;
            if (n == 2)
                recoverable = true;
            else if (n == 3 and a[1].first == normal)
                recoverable = true;
            else if (n >= 4 and a[1].first == normal and
                     a[n - 2].first == normal)
                recoverable = true;
            if (recoverable)
                cout << diff / 2 << " ml. from cup #" << a[0].second
                     << " to cup #" << a[n - 1].second << "." << endl;
            else
                cout << "Unrecoverable configuration." << endl;
        }
        else
            cout << "Unrecoverable configuration." << endl;
    }
    return 0;
}

using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
int const NMAX = 3e5 + 11;
int n, m, visited[NMAX], dp[NMAX][26];
vi g[NMAX], order;
string ch;
bool dfs1(int u)
{
    if (visited[u] == 1)
        return false;
    if (visited[u] == 2)
        return true;
    visited[u] = 1;
    for (auto v : g[u])
        if (not dfs1(v))
            return false;
    visited[u] = 2;
    order.push_back(u);
    return true;
}
bool toposort(void)
{
    memset(visited, 0, sizeof(visited));
    for (int u = 0; u < n; ++u)
        if (not visited[u] and not dfs1(u))
            return false;
    return true;
}
void dfs2(int u)
{
    if (visited[u])
        return;
    for (auto v : g[u])
    {
        dfs2(v);
        for (int c = 0; c < 26; ++c)
            dp[u][c] = max(dp[u][c], dp[v][c]);
    }
    visited[u] = true;
    dp[u][ch[u] - 'a']++;
}
int solve(void)
{
    int ans = 0;
    memset(visited, 0, sizeof(visited));
    reverse(order.begin(), order.end());
    for (auto u : order)
    {
        if (not visited[u])
        {
            dfs2(u);
            ans = max(ans, *max_element(dp[u], dp[u] + 26));
        }
    }
    return ans;
}
int main(void)
{
    ios_base::sync_with_stdio(false), cin.tie(NULL);
    int u, v;
    cin >> n >> m >> ch;
    for (int i = 0; i < m; ++i)
    {
        cin >> u >> v, u--, v--;
        g[u].push_back(v);
    }
    if (toposort())
        cout << solve() << endl;
    else
        cout << -1 << endl;
    return 0;
}

using namespace std;
using ii = pair<int, int>;
int const NMAX = 1e2 + 11;
int const CMAX = 26;
int n, m;
bool mem[NMAX][NMAX][CMAX], vis[NMAX][NMAX][CMAX];
vector<ii> g[NMAX];
bool dp(int u, int v, int c)
{
    auto &ans = mem[u][v][c];
    if (vis[u][v][c])
        return ans;
    else
    {
        vis[u][v][c] = true;
        return ans = any_of(g[u].begin(), g[u].end(), [c, v](ii uc) {
                   auto [up, cp] = uc;
                   return cp >= c and not dp(v, up, cp);
               });
    }
}
int main(void)
{
    ios_base::sync_with_stdio(false), cin.tie(NULL);
    int u, v;
    char c;
    cin >> n >> m;
    for (int i = 0; i < m; ++i)
    {
        cin >> u >> v >> c, --u, --v, c -= 'a';
        g[u].emplace_back(v, (int)c);
    }
    for (int u = 0; u < n; ++u)
    {
        for (int v = 0; v < n; ++v)
            cout << (dp(u, v, 0) ? 'A' : 'B');
        cout << endl;
    }
    return 0;
}

using namespace std;
string line;
int pos;
map<int, string> ip_to_name;
bool is_char(char c) { return 'a' <= c and c <= 'z'; }
bool is_digit(char c) { return '0' <= c and c <= '9'; }
string parse_name(void)
{
    string name;
    while (is_char(line[pos]))
    {
        name += line[pos];
        ++pos;
    }
    ++pos;
    return name;
}
int parse_ip(void)
{
    int i = 0, ip[4], ans = 0;
    string cnum;
    while (is_digit(line[pos]) or line[pos] == '.')
    {
        if (line[pos] == '.')
        {
            ip[i] = stoi(cnum);
            ++i;
            cnum = string();
        }
        else
            cnum += line[pos];
        ++pos;
    }
    ip[i] = stoi(cnum);
    for (int i = 0; i < 4; ++i)
        ans += ip[i] * pow(256, 4 - (i + 1));
    return ans;
}
int main(void)
{
    string name;
    int n, m, ip;
    cin >> n >> m;
    cin.ignore();
    for (int i = 0; i < n; ++i)
    {
        pos = 0;
        getline(cin, line);
        name = parse_name();
        ip = parse_ip();
        ip_to_name[ip] = name;
    }
    for (int i = 0; i < m; ++i)
    {
        pos = 0;
        getline(cin, line);
        name = parse_name();
        ip = parse_ip();
        cout << line << " #" << ip_to_name[ip] << endl;
    }
    return 0;
}

using namespace std;
const int NMAX = 600 + 11;
int n, k, dist[NMAX];
bool simulate(int max_dist)
{
    int dist_left = max_dist, stops = 0;
    for (int i = 0; i < n + 1; ++i)
    {
        if (dist_left >= dist[i])
            dist_left -= dist[i];
        else
        {
            ++stops;
            dist_left = max_dist - dist[i];
        }
        if (stops > k or dist_left < 0)
            return false;
    }
    return true;
}
int binary_search(int l, int r)
{
    while (l < r)
    {
        int mid = (l + r) / 2;
        if (simulate(mid))
            r = mid;
        else
            l = mid + 1;
    }
    return l;
}
int main(void)
{
    int sum;
    while (cin >> n >> k)
    {
        sum = 0;
        for (int i = 0; i < n + 1; ++i)
        {
            cin >> dist[i];
            sum += dist[i];
        }
        cout << binary_search(0, sum) << endl;
    }
    return 0;
}

using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
int main(void)
{
    int n;
    cin >> n;
    vector<ii> diff;
    for (int i = 0; i < n; ++i)
    {
        ll ai, sq;
        cin >> ai;
        sq = round(sqrt(ai));
        diff.emplace_back(abs(ai - sq * sq), ai);
    }
    sort(diff.begin(), diff.end());
    ll ans = 0;
    for (int i = 0; i < n / 2; ++i)
        ans += diff[i].first;
    for (int i = n / 2; i < n; ++i)
        ans += (diff[i].first != 0 ? 0 : 1 + !diff[i].second);
    cout << ans << endl;
    return 0;
}

using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
int solve1(vi a)
{
    int n = (int)a.size(), ans = 0;
    for (int l = 0; l < n - 1; ++l)
        for (int r = l + 1; r < n; ++r)
            if (accumulate(a.begin() + l, a.begin() + r + 1, 0) == 0)
                ans = max(ans, (r - l + 1));
    return ans;
}
vi prefix_sum(vi a)
{
    int n = (int)a.size();
    vi pa(n);
    for (int i = 0; i < n; ++i)
        pa[i] = a[i] + (i == 0 ? 0 : pa[i - 1]);
    return pa;
}
int solve2(vi a)
{
    int n = (int)a.size(), ans = 0;
    vi pa = prefix_sum(a);
    auto sum = [&pa](int l, int r) { return pa[r] - (l == 0 ? 0 : pa[l - 1]); };
    for (int l = 0; l < n - 1; ++l)
        for (int r = l + 1; r < n; ++r)
            if (sum(l, r) == 0)
                ans = max(ans, (r - l + 1));
    return ans;
}
int solve3(vi a)
{
    int n = (int)a.size(), ans = 0;
    map<int, int> sum_ix;
    sum_ix[0] = -1;
    int ps = 0;
    for (int i = 0; i < n; ++i)
    {
        ps += a[i];
        if (sum_ix.find(ps) == sum_ix.end())
            sum_ix[ps] = i;
        else
            ans = max(ans, i - sum_ix[ps]);
    }
    return ans;
}
int main(void)
{
    int n;
    string s;
    cin >> n >> s;
    vi a(n);
    transform(s.begin(), s.end(), a.begin(), [](char c) { return c == '0' ? -1 : +1; });
    cout << solve3(a) << endl;
    return 0;
}