#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

// Структура за управление на непресичащи се множества (DSU)
struct DSU {
    vector<int> parent;
    
    DSU(int n) {
        parent.resize(n);
        for (int i = 0; i < n; i++) {
            parent[i] = i;
        }
    }

    int find(int i) {
        if (parent[i] == i)
            return i;
        return parent[i] = find(parent[i]);
    }

    void unite(int i, int j) {
        int root_i = find(i);
        int root_j = find(j);
        if (root_i != root_j) {
            parent[root_j] = root_i;
        }
    }
};

int main() {
    // Оптимизация за бърз вход/изход
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int n;
    if (!(cin >> n)) return 0;

    // 2^200 е число с 201 бита, 210 е напълно достатъчно
    const int MAX_BITS = 210;
    DSU dsu(MAX_BITS);
    vector<bool> present(MAX_BITS, false);

    for (int i = 0; i < n; i++) {
        string s;
        cin >> s;
        
        if (s == "0") continue; // 0 не вдига никакви битове

        // Прехвърляме голямото число в база 10^9 за супер бързо деление
        vector<uint32_t> b;
        b.reserve(8);
        int len = s.length();
        for (int j = len; j > 0; j -= 9) {
            int start = max(0, j - 9);
            uint32_t val = 0;
            for(int k = start; k < j; k++) {
                val = val * 10 + (s[k] - '0');
            }
            b.push_back(val);
        }

        int bit_pos = 0;
        int first_bit = -1;

        // Извличаме битовете, като делим масива на 2
        while (!b.empty()) {
            if (b[0] % 2 != 0) { // Ако последната цифра е нечетна, текущият бит е 1
                present[bit_pos] = true;
                if (first_bit == -1) {
                    first_bit = bit_pos;
                } else {
                    dsu.unite(first_bit, bit_pos);
                }
            }
            
            // Делим цялото число (в база 10^9) на 2
            uint32_t rem = 0;
            for (int j = (int)b.size() - 1; j >= 0; j--) {
                uint64_t cur = b[j] + rem * 1000000000ull;
                b[j] = cur / 2;
                rem = cur % 2;
            }
            
            // Премахваме водещите нули
            while (!b.empty() && b.back() == 0) {
                b.pop_back();
            }
            
            bit_pos++;
        }
    }

    // Намираме най-голямата компонента на свързаност
    vector<int> comp_size(MAX_BITS, 0);
    int max_bits = 0;
    
    for (int bit = 0; bit < MAX_BITS; bit++) {
        if (present[bit]) {
            int root = dsu.find(bit);
            comp_size[root]++;
            max_bits = max(max_bits, comp_size[root]);
        }
    }

    cout << max_bits << "\n";

    return 0;
}