#include <bits/stdc++.h>
#define F first
#define S second
#define endl '\n'

using namespace std;

class UnionFind{
private:
  vector<int> p, w, sz;
  vector<bool> used;
public:
  UnionFind(int n){
    w.resize(n + 1, 1);
    sz.resize(n + 1, 1);
    used.resize(n + 1, false);
    p.resize(n + 1);
    for (int i = 0; i <= n; i++)
      p[i] = i;
  }
  int find(int x){
    if (p[x] == x)
      return x;
    return p[x] = find(p[x]);
  }
  bool join(int x, int y){
    used[x] = true;
    used[y] = true;
    x = find(x);
    y = find(y);
    if (x == y)
      return false;
    if (w[x] > w[y])
      swap(x, y);
    p[x] = y;
    sz[y] += sz[x];
    if (w[x] == w[y])
      w[y]++;
    return true;
  }
  bool isSame(int x, int y){
    return find(x) == find(y);
  }
  bool isUsed(int x){
    return used[x];
  }
  int size(int x){
    return sz[find(x)];
  }
};
string charToBin(char c){
  int x;
  if(c>='0' and c<='9')
    x = c-'0';
  else
    x = (c-'A') + 10;
  string ret;
  for(int i=3; i>=0; i--)
    ret += ('0' + ((x>>i)&1));
  return ret;
}
typedef pair<int, int> pii;
vector<pii> splitSegments(string &s){
  int i = 0, n = s.size();
  vector<pii> ans;
  while(i < n){
    while(i<n and s[i]=='0')
      i++;
    if(i == n)
      break;
    int j = i;
    while(j<n and s[j]=='1')
      j++;
    ans.emplace_back(i, j-1);
    i = j;
  }
  return ans;
}
const int MAXN = (1<<12) + 10;
string v[MAXN];
int main() {
  ios_base::sync_with_stdio(false); cin.tie(NULL);
  int n, m;
  cin >> n >> m;

  for(int i=0; i<n; i++){
    string s;
    cin >> s;
    for(char c: s)
      v[i] += charToBin(c);
  }
  UnionFind uf(m);
  int ans = 0;
  for(int line=0; line<n; line++){
    string s = v[line];
    vector<pii> segments = splitSegments(s);
    UnionFind newUF(m);
    for(auto [l, r]: segments){
      set<int> st;
      for(int i=l; i<=r; i++){
        if(uf.isUsed(i))
          st.insert(uf.find(i));
        newUF.join(i, l);
      }
      if(st.empty()){
        ans++;
      }else{
        ans -= (st.size()-1);
      }
    }
    map<int, vector<int>> mp;
    for(int i=0; i<m; i++){
      if(newUF.isUsed(i))
        mp[uf.find(i)].push_back(i);
    }
    for(auto [_, vt] : mp){
      int sz = vt.size();
      for(int i=1; i<sz; i++)
        newUF.join(vt[i], vt[0]);
    }
    uf = newUF;
  }

  cout << ans << endl;
  return 0;
}


#include <bits/stdc++.h>
#define F first
#define S second
#define endl '\n'

using namespace std;

class UnionFind{
private:
  vector<int> p, w, sz;
public:
  UnionFind(int n){
    w.resize(n + 1, 1);
    sz.resize(n + 1, 1);
    p.resize(n + 1);
    for (int i = 0; i <= n; i++)
      p[i] = i;
  }
  int find(int x){
    if (p[x] == x)
      return x;
    return p[x] = find(p[x]);
  }
  bool join(int x, int y){
    x = find(x);
    y = find(y);
    if (x == y)
      return false;
    if (w[x] > w[y])
      swap(x, y);
    p[x] = y;
    sz[y] += sz[x];
    if (w[x] == w[y])
      w[y]++;
    return true;
  }
  bool isSame(int x, int y){
    return find(x) == find(y);
  }
  int size(int x){
    return sz[find(x)];
  }
};
string charToBin(char c){
  int x;
  if(c>='0' and c<='9')
    x = c-'0';
  else
    x = (c-'A') + 10;
  string ret;
  for(int i=3; i>=0; i--)
    ret += ('0' + ((x>>i)&1));
  return ret;
}

typedef pair<int, int> pii;
vector<pii> splitSegments(string &s){
  int i = 0, n = s.size();
  vector<pii> ans;
  while(i < n){
    while(i<n and s[i]=='0')
      i++;
    if(i == n)
      break;
    int j = i;
    while(j<n and s[j]=='1')
      j++;
    ans.emplace_back(i, j-1);
    i = j;
  }
  return ans;
}
const int MAXM = (2<<14) + 10;

int dad[MAXM];
int last[MAXM];

int main() {
  ios_base::sync_with_stdio(false); cin.tie(NULL);
  int n, m;
  cin >> n >> m;

  int ans = 0;
  UnionFind uf(m);
  string lastS(m, '0');
  for(int line=0; line<n; line++){
    string aux, s;
    cin >> aux;
    for(char c: aux)
      s += charToBin(c);

    vector<pii> segments = splitSegments(s);
    UnionFind newUF(m);
    for(int i=0; i<m; i++){
      dad[i] = -1;
      last[i] = -1;
    }

    for(int i=0; i<m; i++){
      if(s[i] == '1'){
        dad[i] = uf.find(i);
        ans += (lastS[i] == '0');
      }
    }

    for(int i=0; i<m; i++){
      if(dad[i] != -1){
        if(last[dad[i]] != -1)
          newUF.join(i, last[dad[i]]);
        last[dad[i]] = i;
      }
    }

    for(auto [l, r]: segments){
      for(int i=l; i<=r; i++)
        ans -= newUF.join(i, l);
    }
    uf = newUF;
    lastS = s;
  }

  cout << ans << endl;
  return 0;
}


#include <bits/stdc++.h>
#define F first
#define S second
#define endl '\n'

using namespace std;

class UnionFind{
private:
  vector<int> p, w, sz;
public:
  void init(int n){
    w.assign(n + 1, 1);
    sz.assign(n + 1, 1);
    p.resize(n + 1);
    for (int i = 0; i <= n; i++)
      p[i] = i;
  }
  int find(int x){
    if (p[x] == x)
      return x;
    return p[x] = find(p[x]);
  }
  bool join(int x, int y){
    x = find(x);
    y = find(y);
    if (x == y)
      return false;
    if (w[x] > w[y])
      swap(x, y);
    p[x] = y;
    sz[y] += sz[x];
    if (w[x] == w[y])
      w[y]++;
    return true;
  }
  bool isSame(int x, int y){
    return find(x) == find(y);
  }
  int size(int x){
    return sz[find(x)];
  }
};
void charToBin(string &s, char &c){
  int x;
  if(c>='0' and c<='9')
    x = c-'0';
  else
    x = (c-'A') + 10;
  for(int i=3; i>=0; i--)
    s += ('0' + ((x>>i)&1));
}
typedef pair<int, int> pii;
void splitSegments(string &s, vector<pii> &ans){
  int i = 0, n = s.size();
  while(i < n){
    while(i<n and s[i]=='0')
      i++;
    if(i == n)
      break;
    int j = i;
    while(j<n and s[j]=='1')
      j++;
    ans.emplace_back(i, j-1);
    i = j;
  }
}
const int MAXM = (2<<14) + 10;

int dad[MAXM];
int last[MAXM];

int main() {
  ios_base::sync_with_stdio(false); cin.tie(NULL);
  int n, m;
  cin >> n >> m;

  int ans = 0;
  UnionFind uf, newUF;
  uf.init(m);
  string lastS(m, '0');
  for(int line=0; line<n; line++){
    string aux, s;
    cin >> aux;
    for(char c: aux)
      charToBin(s, c);

    vector<pii> segments;
    splitSegments(s, segments);
    for(int i=0; i<m; i++){
      dad[i] = -1;
      last[i] = -1;
    }

    for(int i=0; i<m; i++){
      if(s[i] == '1'){
        dad[i] = uf.find(i);
        ans += (lastS[i] == '0');
      }
    }
    newUF.init(m);
    for(int i=0; i<m; i++){
      if(dad[i] != -1){
        if(last[dad[i]] != -1)
          newUF.join(i, last[dad[i]]);
        last[dad[i]] = i;
      }
    }

    for(auto [l, r]: segments){
      for(int i=l; i<=r; i++)
        ans -= newUF.join(i, l);
    }
    swap(uf, newUF);
    lastS = s;
  }

  cout << ans << endl;
  return 0;
}


#include <bits/stdc++.h>
#define F first
#define S second
#define endl '\n'

using namespace std;

class UnionFind{
private:
  vector<int> p, w, sz;
  vector<bool> used;
public:
  UnionFind(int n){
    w.resize(n + 1, 1);
    sz.resize(n + 1, 1);
    used.resize(n + 1, false);
    p.resize(n + 1);
    for (int i = 0; i <= n; i++)
      p[i] = i;
  }
  int find(int x){
    if (p[x] == x)
      return x;
    return p[x] = find(p[x]);
  }
  bool join(int x, int y){
    used[x] = true;
    used[y] = true;
    x = find(x);
    y = find(y);
    if (x == y)
      return false;
    if (w[x] > w[y])
      swap(x, y);
    p[x] = y;
    sz[y] += sz[x];
    if (w[x] == w[y])
      w[y]++;
    return true;
  }
  bool isSame(int x, int y){
    return find(x) == find(y);
  }
  bool isUsed(int x){
    return used[x];
  }
  int size(int x){
    return sz[find(x)];
  }
};
string charToBin(char c){
  int x;
  if(c>='0' and c<='9')
    x = c-'0';
  else
    x = (c-'A') + 10;
  string ret;
  for(int i=3; i>=0; i--)
    ret += ('0' + ((x>>i)&1));
  return ret;
}
typedef pair<int, int> pii;
vector<pii> splitSegments(string &s){
  int i = 0, n = s.size();
  vector<pii> ans;
  while(i < n){
    while(i<n and s[i]=='0')
      i++;
    if(i == n)
      break;
    int j = i;
    while(j<n and s[j]=='1')
      j++;
    ans.emplace_back(i, j-1);
    i = j;
  }
  return ans;
}

int main() {
  ios_base::sync_with_stdio(false); cin.tie(NULL);
  int n, m;
  cin >> n >> m;

  int ans = 0;
  UnionFind uf(m);
  string lastS(m, '0');
  for(int line=0; line<n; line++){
    string aux, s;
    cin >> aux;
    for(char c: aux)
      s += charToBin(c);

    vector<pii> segments = splitSegments(s);
    UnionFind newUF(m);
    vector<vector<int>> mp(m);
    for(int i=0; i<m; i++){
      if(s[i] == '1'){
        mp[uf.find(i)].push_back(i);
        ans += (lastS[i] == '0');
      }
    }
    for(int i=0; i<m; i++){
      auto &vt = mp[i];
      for(int j=0; j<(int)vt.size(); j++)
        newUF.join(vt[j], vt[0]);
    }

    for(auto [l, r]: segments){
      for(int i=l; i<=r; i++)
        ans -= newUF.join(i, l);
    }
    uf = newUF;
    lastS = s;
  }

  cout << ans << endl;
  return 0;
}


#include <bits/stdc++.h>
#define F first
#define S second
#define endl '\n'

using namespace std;

class UnionFind{
private:
  vector<int> p, w, sz;
public:
  UnionFind(int n){
    w.resize(n + 1, 1);
    sz.resize(n + 1, 1);
    p.resize(n + 1);
    for (int i = 0; i <= n; i++)
      p[i] = i;
  }
  int find(int x){
    if (p[x] == x)
      return x;
    return p[x] = find(p[x]);
  }
  bool join(int x, int y){
    x = find(x);
    y = find(y);
    if (x == y)
      return false;
    if (w[x] > w[y])
      swap(x, y);
    p[x] = y;
    sz[y] += sz[x];
    if (w[x] == w[y])
      w[y]++;
    return true;
  }
  bool isSame(int x, int y){
    return find(x) == find(y);
  }
  int size(int x){
    return sz[find(x)];
  }
};
void charToBin(string &s, char &c){
  int x;
  if(c>='0' and c<='9')
    x = c-'0';
  else
    x = (c-'A') + 10;
  for(int i=3; i>=0; i--)
    s += ('0' + ((x>>i)&1));
}
typedef pair<int, int> pii;
vector<pii> splitSegments(string &s){
  int i = 0, n = s.size();
  vector<pii> ans;
  while(i < n){
    while(i<n and s[i]=='0')
      i++;
    if(i == n)
      break;
    int j = i;
    while(j<n and s[j]=='1')
      j++;
    ans.emplace_back(i, j-1);
    i = j;
  }
  return ans;
}
const int MAXM = (2<<14) + 10;

int dad[MAXM];
int last[MAXM];

int main() {
  ios_base::sync_with_stdio(false); cin.tie(NULL);
  int n, m;
  cin >> n >> m;

  int ans = 0;
  UnionFind uf(m);
  string lastS(m, '0');
  for(int line=0; line<n; line++){
    string aux, s;
    cin >> aux;
    for(char c: aux)
      charToBin(s, c);

    vector<pii> segments = splitSegments(s);
    UnionFind newUF(m);
    for(int i=0; i<m; i++){
      dad[i] = -1;
      last[i] = -1;
    }

    for(int i=0; i<m; i++){
      if(s[i] == '1'){
        dad[i] = uf.find(i);
        ans += (lastS[i] == '0');
      }
    }

    for(int i=0; i<m; i++){
      if(last[dad[i]] != -1)
        newUF.join(i, last[dad[i]]);
      last[dad[i]] = i;
    }

    for(auto [l, r]: segments){
      for(int i=l; i<=r; i++)
        ans -= newUF.join(i, l);
    }
    uf = newUF;
    lastS = s;
  }

  cout << ans << endl;
  return 0;
}


#include <bits/stdc++.h>
#define F first
#define S second
#define endl '\n'

using namespace std;

class UnionFind{
private:
  vector<int> p, w, sz;
public:
  UnionFind(int n){
    w.resize(n + 1, 1);
    sz.resize(n + 1, 1);
    p.resize(n + 1);
    for (int i = 0; i <= n; i++)
      p[i] = i;
  }
  int find(int x){
    if (p[x] == x)
      return x;
    return p[x] = find(p[x]);
  }
  bool join(int x, int y){
    x = find(x);
    y = find(y);
    if (x == y)
      return false;
    if (w[x] > w[y])
      swap(x, y);
    p[x] = y;
    sz[y] += sz[x];
    if (w[x] == w[y])
      w[y]++;
    return true;
  }
  bool isSame(int x, int y){
    return find(x) == find(y);
  }
  int size(int x){
    return sz[find(x)];
  }
};
void charToBin(string &s, char &c){
  int x;
  if(c>='0' and c<='9')
    x = c-'0';
  else
    x = (c-'A') + 10;
  for(int i=3; i>=0; i--)
    s += ('0' + ((x>>i)&1));
}
typedef pair<int, int> pii;
vector<pii> splitSegments(string &s){
  int i = 0, n = s.size();
  vector<pii> ans;
  while(i < n){
    while(i<n and s[i]=='0')
      i++;
    if(i == n)
      break;
    int j = i;
    while(j<n and s[j]=='1')
      j++;
    ans.emplace_back(i, j-1);
    i = j;
  }
  return ans;
}

vector<int> mp[(2<<14) + 10];

int main() {
  ios_base::sync_with_stdio(false); cin.tie(NULL);
  int n, m;
  cin >> n >> m;

  int ans = 0;
  UnionFind uf(m);
  string lastS(m, '0');
  for(int line=0; line<n; line++){
    string aux, s;
    cin >> aux;
    for(char c: aux)
      charToBin(s, c);

    vector<pii> segments = splitSegments(s);
    UnionFind newUF(m);
    for(int i=0; i<m; i++)
      mp[i].clear();

    for(int i=0; i<m; i++){
      if(s[i] == '1'){
        mp[uf.find(i)].push_back(i);
        ans += (lastS[i] == '0');
      }
    }

    for(int i=0; i<m; i++){
      auto &vt = mp[i];
      for(int j=0; j<(int)vt.size(); j++)
        newUF.join(vt[j], vt[0]);
    }

    for(auto [l, r]: segments){
      for(int i=l; i<=r; i++)
        ans -= newUF.join(i, l);
    }
    uf = newUF;
    lastS = s;
  }

  cout << ans << endl;
  return 0;
}


#include <bits/stdc++.h>
#define F first
#define S second
#define endl '\n'

using namespace std;

class UnionFind{
private:
  vector<int> p, w, sz;
public:
  UnionFind(int n){
    w.resize(n + 1, 1);
    sz.resize(n + 1, 1);
    p.resize(n + 1);
    for (int i = 0; i <= n; i++)
      p[i] = i;
  }
  int find(int x){
    if (p[x] == x)
      return x;
    return p[x] = find(p[x]);
  }
  bool join(int x, int y){
    x = find(x);
    y = find(y);
    if (x == y)
      return false;
    if (w[x] > w[y])
      swap(x, y);
    p[x] = y;
    sz[y] += sz[x];
    if (w[x] == w[y])
      w[y]++;
    return true;
  }
  bool isSame(int x, int y){
    return find(x) == find(y);
  }
  int size(int x){
    return sz[find(x)];
  }
};
string charToBin(char c){
  int x;
  if(c>='0' and c<='9')
    x = c-'0';
  else
    x = (c-'A') + 10;
  string ret;
  for(int i=3; i>=0; i--)
    ret += ('0' + ((x>>i)&1));
  return ret;
}

typedef pair<int, int> pii;
vector<pii> splitSegments(string &s){
  int i = 0, n = s.size();
  vector<pii> ans;
  while(i < n){
    while(i<n and s[i]=='0')
      i++;
    if(i == n)
      break;
    int j = i;
    while(j<n and s[j]=='1')
      j++;
    ans.emplace_back(i, j-1);
    i = j;
  }
  return ans;
}
const int MAXM = (2<<14) + 10;

int dad[MAXM];
int last[MAXM];

int main() {
  ios_base::sync_with_stdio(false); cin.tie(NULL);
  int n, m;
  cin >> n >> m;

  int ans = 0;
  UnionFind uf(m);
  string lastS(m, '0');
  for(int line=0; line<n; line++){
    string aux, s;
    cin >> aux;
    for(char c: aux)
      s += charToBin(c);

    vector<pii> segments = splitSegments(s);
    UnionFind newUF(m);
    for(int i=0; i<m; i++){
      dad[i] = -1;
      last[i] = -1;
    }

    for(int i=0; i<m; i++){
      if(s[i] == '1'){
        dad[i] = uf.find(i);
        ans += (lastS[i] == '0');
      }
    }

    for(int i=0; i<m; i++){
      if(dad[i] != -1){
        if(last[dad[i]] != -1)
          newUF.join(i, last[dad[i]]);
        last[dad[i]] = i;
      }
    }

    for(pii &p: segments){
      for(int i=p.F; i<=p.S; i++)
        ans -= newUF.join(i, p.F);
    }
    uf = newUF;
    lastS = s;
  }

  cout << ans << endl;
  return 0;
}


#include <bits/stdc++.h>
#define F first
#define S second
#define endl '\n'

using namespace std;

class UnionFind{
private:
  vector<int> p, w, sz;
  vector<bool> used;
public:
  UnionFind(int n){
    w.resize(n + 1, 1);
    sz.resize(n + 1, 1);
    used.resize(n + 1, false);
    p.resize(n + 1);
    for (int i = 0; i <= n; i++)
      p[i] = i;
  }
  int find(int x){
    if (p[x] == x)
      return x;
    return p[x] = find(p[x]);
  }
  bool join(int x, int y){
    used[x] = true;
    used[y] = true;
    x = find(x);
    y = find(y);
    if (x == y)
      return false;
    if (w[x] > w[y])
      swap(x, y);
    p[x] = y;
    sz[y] += sz[x];
    if (w[x] == w[y])
      w[y]++;
    return true;
  }
  bool isSame(int x, int y){
    return find(x) == find(y);
  }
  bool isUsed(int x){
    return used[x];
  }
  int size(int x){
    return sz[find(x)];
  }
};
string charToBin(char c){
  int x;
  if(c>='0' and c<='9')
    x = c-'0';
  else
    x = (c-'A') + 10;
  string ret;
  for(int i=3; i>=0; i--)
    ret += ('0' + ((x>>i)&1));
  return ret;
}
typedef pair<int, int> pii;
vector<pii> splitSegments(string &s){
  int i = 0, n = s.size();
  vector<pii> ans;
  while(i < n){
    while(i<n and s[i]=='0')
      i++;
    if(i == n)
      break;
    int j = i;
    while(j<n and s[j]=='1')
      j++;
    ans.emplace_back(i, j-1);
    i = j;
  }
  return ans;
}

int main() {
  ios_base::sync_with_stdio(false); cin.tie(NULL);
  int n, m;
  cin >> n >> m;

  int ans = 0;
  UnionFind uf(m);
  string lastS(m, '0');
  for(int line=0; line<n; line++){
    string aux, s;
    cin >> aux;
    for(char c: aux)
      s += charToBin(c);

    vector<pii> segments = splitSegments(s);
    UnionFind newUF(m);
    map<int, vector<int>> mp;
    for(int i=0; i<m; i++){
      if(s[i] == '1'){
        mp[uf.find(i)].push_back(i);
        ans += (lastS[i] == '0');
      }
    }
    for(auto [_, vt] : mp){
      int sz = vt.size();
      for(int i=0; i<sz; i++)
        newUF.join(vt[i], vt[0]);
    }

    for(auto [l, r]: segments){
      for(int i=l; i<=r; i++)
        ans -= newUF.join(i, l);
    }
    uf = newUF;
    lastS = s;
  }

  cout << ans << endl;
  return 0;
}


#include <bits/stdc++.h>
#define F first
#define S second
#define endl '\n'

using namespace std;

class UnionFind{
private:
  vector<int> p, w, sz;
  vector<bool> used;
public:
  UnionFind(int n){
    w.resize(n + 1, 1);
    sz.resize(n + 1, 1);
    used.resize(n + 1, false);
    p.resize(n + 1);
    for (int i = 0; i <= n; i++)
      p[i] = i;
  }
  int find(int x){
    if (p[x] == x)
      return x;
    return p[x] = find(p[x]);
  }
  bool join(int x, int y){
    used[x] = true;
    used[y] = true;
    x = find(x);
    y = find(y);
    if (x == y)
      return false;
    if (w[x] > w[y])
      swap(x, y);
    p[x] = y;
    sz[y] += sz[x];
    if (w[x] == w[y])
      w[y]++;
    return true;
  }
  bool isSame(int x, int y){
    return find(x) == find(y);
  }
  bool isUsed(int x){
    return used[x];
  }
  int size(int x){
    return sz[find(x)];
  }
};
string charToBin(char c){
  int x;
  if(c>='0' and c<='9')
    x = c-'0';
  else
    x = (c-'A') + 10;
  string ret;
  for(int i=3; i>=0; i--)
    ret += ('0' + ((x>>i)&1));
  return ret;
}
typedef pair<int, int> pii;
vector<pii> splitSegments(string &s){
  int i = 0, n = s.size();
  vector<pii> ans;
  while(i < n){
    while(i<n and s[i]=='0')
      i++;
    if(i == n)
      break;
    int j = i;
    while(j<n and s[j]=='1')
      j++;
    ans.emplace_back(i, j-1);
    i = j;
  }
  return ans;
}
const int MAXN = (1<<12) + 10;
string v[MAXN];
int main() {
  ios_base::sync_with_stdio(false); cin.tie(NULL);
  int n, m;
  cin >> n >> m;

  for(int i=0; i<n; i++){
    string s;
    cin >> s;
    for(char c: s)
      v[i] += charToBin(c);
  }
  UnionFind uf(m);
  int ans = 0;
  for(int line=0; line<n; line++){
    string s = v[line];
    vector<pii> segments = splitSegments(s);
    UnionFind newUF(m);
    for(auto [l, r]: segments){
      set<int> st;
      for(int i=l; i<=r; i++){
        if(uf.isUsed(i))
          st.insert(uf.find(i));
        newUF.join(i, l);
      }
      if(st.empty()){
        ans++;
      }else{
        ans -= (st.size()-1);
      }
    }
    map<int, vector<int>> mp;
    for(int i=0; i<m; i++){
      if(s[i] == '1')
        mp[uf.find(i)].push_back(i);
    }
    for(auto [_, vt] : mp){
      int sz = vt.size();
      for(int i=1; i<sz; i++)
        ans -= newUF.join(vt[i], vt[0]);
    }
    uf = newUF;
  }

  cout << ans << endl;
  return 0;
}


#include <bits/stdc++.h>
#define fi first
#define se second
#define sz(v) ((int)v.size())
#define all(v) (v).begin(), (v).end()
#define get(t,x) (s[t][(x)/4]>>(3-(x)%4)&1)
#define pb push_back
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
int n,m;
int a[2][17000];
int par[40000];
bool chk[40000],used[40000];
char s[2][17000];
int pn(int u){return par[u]==u?u:(par[u]=pn(par[u]));}
void us(int a,int b){
	a=pn(a),b=pn(b);
	par[b]=a;
}
int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	int i,j,k,t,ans=0;
	cin>>n>>m;
	for(i=0;i<n;i++) {
		k=i%2;t=1-k;
		cin>>s[k];
		for(j=0;j<m/4;j++) {
			if('A'<=s[k][j])s[k][j]+=10-'A';
			else s[k][j]-='0';
		}
		for(j=0;j<m;j++) {
			if(get(k,j)&&get(t,j)) {
				a[k][j]=a[t][j];
				chk[a[t][j]]=true;
			} else a[k][j]=0;
		}
		for(j=0;j<m;j++) {
			if(get(t,j)&&!chk[a[t][j]]) {
				ans++;
				chk[a[t][j]]=true;
				used[a[t][j]]=false;
			}
		}
		for(j=0;j+1<m;j++) {
			if(get(k,j)&&a[k][j]) {
				if(get(k,j+1)) {
					if(a[k][j+1])us(a[k][j],a[k][j+1]);
					else a[k][j+1]=a[k][j];
				}
			}
		}
		for(j=m-1;j>0;j--) {
			if(get(k,j)&&a[k][j]) {
				if(get(k,j-1)) {
					if(a[k][j-1])us(a[k][j],a[k][j-1]);
					else a[k][j-1]=a[k][j];
				}
			}
		}
		int last=1;
		for(j=0;j<m;j++) {
			if(get(k,j)&&!a[k][j]) {
				if(j&&get(k,j-1)&&a[k][j-1])a[k][j]=a[k][j-1];
				else {
					while(used[last])last++;
					a[k][j]=last;
					par[a[k][j]]=a[k][j];
					used[last]=true;
				}
			}
		}
		for(j=1;j<=m+m;j++)used[j]=false;
		for(j=0;j<m;j++) {
			a[k][j]=pn(a[k][j]);
			used[a[k][j]]=true;
			chk[a[k][j]]=false;
		}
	}
	for(j=0;j<m;j++) {
		if(get(k,j)&&!chk[a[k][j]]) {
			ans++;
			chk[a[k][j]]=true;
		}
	}
	cout<<ans;
	return 0;
}


#include <bits/stdc++.h>
#define fi first
#define se second
#define sz(v) ((int)v.size())
#define all(v) (v).begin(), (v).end()
#define get(t,x) (s[t][(x)/4]>>(3-(x)%4)&1)
#define pb push_back
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
int n,m;
int a[2][17000];
int par[17000];
int ST[30000],STC;
bool chk[17000];
char s[2][17000];
int pn(int u){return par[u]==u?u:(par[u]=pn(par[u]));}
void us(int a,int b){
	a=pn(a),b=pn(b);
	par[b]=a;
}
int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	int i,j,k,t,ans=0;
	cin>>n>>m;
	for(i=1;i<=m+m;i++)ST[++STC]=i;
	for(i=0;i<n;i++) {
		k=i%2;t=1-k;
		cin>>s[k];
		for(j=0;j<m/4;j++) {
			if('A'<=s[k][j])s[k][j]+=10-'A';
			else s[k][j]-='0';
		}
		for(j=0;j<m;j++) {
			if(get(k,j)&&get(t,j)) {
				a[k][j]=a[t][j];
				chk[a[t][j]]=true;
			} else a[k][j]=0;
		}
		for(j=0;j<m;j++) {
			if(get(t,j)&&!chk[a[t][j]]) {
				ans++;
				chk[a[t][j]]=true;
				ST[++STC]=a[t][j];
			}
		}
		for(j=0;j+1<m;j++) {
			if(get(k,j)&&a[k][j]) {
				if(get(k,j+1)) {
					if(a[k][j+1])us(a[k][j],a[k][j+1]);
					else a[k][j+1]=a[k][j];
				}
			}
		}
		for(j=m-1;j>0;j--) {
			if(get(k,j)&&a[k][j]) {
				if(get(k,j-1)) {
					if(a[k][j-1])us(a[k][j],a[k][j-1]);
					else a[k][j-1]=a[k][j];
				}
			}
		}
		for(j=0;j<m;j++) {
			if(get(k,j)&&!a[k][j]) {
				if(j&&get(k,j-1)&&a[k][j-1])a[k][j]=a[k][j-1];
				else {
					a[k][j]=ST[STC--];
					par[a[k][j]]=a[k][j];
				}
			}
		}
		for(j=0;j<m;j++) {
			a[k][j]=pn(a[k][j]);
			chk[a[k][j]]=false;
		}
	}
	for(j=0;j<m;j++) {
		if(get(k,j)&&!chk[a[k][j]]) {
			ans++;
			chk[a[k][j]]=true;
		}
	}
	cout<<ans;
	return 0;
}


#include <bits/stdc++.h>
#define fi first
#define se second
#define sz(v) ((int)v.size())
#define all(v) (v).begin(), (v).end()
#define get(t,x) (s[t][(x)/4]>>(3-(x)%4)&1)
#define pb push_back
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
int n,m;
int a[2][17000];
int par[40000];
int ST[40000],STC;
bool chk[40000];
char s[2][17000];
int pn(int u){return par[u]==u?u:(par[u]=pn(par[u]));}
void us(int a,int b){
	a=pn(a),b=pn(b);
	par[b]=a;
}
int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	int i,j,k,t,ans=0;
	cin>>n>>m;
	for(i=1;i<=m+m;i++)ST[++STC]=i;
	for(i=0;i<n;i++) {
		k=i%2;t=1-k;
		cin>>s[k];
		for(j=0;j<m/4;j++) {
			if('A'<=s[k][j])s[k][j]+=10-'A';
			else s[k][j]-='0';
		}
		for(j=0;j<m;j++) {
			if(get(k,j)&&get(t,j)) {
				a[k][j]=a[t][j];
				chk[a[t][j]]=true;
			} else a[k][j]=0;
		}
		for(j=0;j<m;j++) {
			if(get(t,j)&&!chk[a[t][j]]) {
				ans++;
				chk[a[t][j]]=true;
				ST[++STC]=a[t][j];
			}
		}
		for(j=0;j+1<m;j++) {
			if(get(k,j)&&a[k][j]) {
				if(get(k,j+1)) {
					if(a[k][j+1])us(a[k][j],a[k][j+1]);
					else a[k][j+1]=a[k][j];
				}
			}
		}
		for(j=m-1;j>0;j--) {
			if(get(k,j)&&a[k][j]) {
				if(get(k,j-1)) {
					if(a[k][j-1])us(a[k][j],a[k][j-1]);
					else a[k][j-1]=a[k][j];
				}
			}
		}
		for(j=0;j<m;j++) {
			if(get(k,j)&&!a[k][j]) {
				if(j&&get(k,j-1)&&a[k][j-1])a[k][j]=a[k][j-1];
				else {
					a[k][j]=ST[STC--];
					par[a[k][j]]=a[k][j];
				}
			}
		}
		for(j=0;j<m;j++) {
			a[k][j]=pn(a[k][j]);
			chk[a[k][j]]=false;
		}
	}
	for(j=0;j<m;j++) {
		if(get(k,j)&&!chk[a[k][j]]) {
			ans++;
			chk[a[k][j]]=true;
		}
	}
	cout<<ans;
	return 0;
}


#include <bits/stdc++.h>
#define fi first
#define se second
#define sz(v) ((int)v.size())
#define all(v) (v).begin(), (v).end()
#define get(t,x) (s[t][(x)/4]>>(3-(x)%4)&1)
#define pb push_back
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
int n,m;
int a[2][17000];
int par[17000];
int ST[40000],STC;
bool chk[17000];
char s[2][17000];
int pn(int u){return par[u]==u?u:(par[u]=pn(par[u]));}
void us(int a,int b){
	a=pn(a),b=pn(b);
	par[b]=a;
}
int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	int i,j,k,t,ans=0;
	cin>>n>>m;
	for(i=1;i<=m+m;i++)ST[++STC]=i;
	for(i=0;i<n;i++) {
		k=i%2;t=1-k;
		cin>>s[k];
		for(j=0;j<m/4;j++) {
			if('A'<=s[k][j])s[k][j]+=10-'A';
			else s[k][j]-='0';
		}
		for(j=0;j<m;j++) {
			if(get(k,j)&&get(t,j)) {
				a[k][j]=a[t][j];
				chk[a[t][j]]=true;
			} else a[k][j]=0;
		}
		for(j=0;j<m;j++) {
			if(get(t,j)&&!chk[a[t][j]]) {
				ans++;
				chk[a[t][j]]=true;
				ST[++STC]=a[t][j];
			}
		}
		for(j=0;j+1<m;j++) {
			if(get(k,j)&&a[k][j]) {
				if(get(k,j+1)) {
					if(a[k][j+1])us(a[k][j],a[k][j+1]);
					else a[k][j+1]=a[k][j];
				}
			}
		}
		for(j=m-1;j>0;j--) {
			if(get(k,j)&&a[k][j]) {
				if(get(k,j-1)) {
					if(a[k][j-1])us(a[k][j],a[k][j-1]);
					else a[k][j-1]=a[k][j];
				}
			}
		}
		for(j=0;j<m;j++) {
			if(get(k,j)&&!a[k][j]) {
				if(j&&get(k,j-1)&&a[k][j-1])a[k][j]=a[k][j-1];
				else {
					a[k][j]=ST[STC--];
					par[a[k][j]]=a[k][j];
				}
			}
		}
		for(j=0;j<m;j++) {
			a[k][j]=pn(a[k][j]);
			chk[a[k][j]]=false;
		}
	}
	for(j=0;j<m;j++) {
		if(get(k,j)&&!chk[a[k][j]]) {
			ans++;
			chk[a[k][j]]=true;
		}
	}
	cout<<ans;
	return 0;
}


#include<bits/stdc++.h>
#define LL long long
#define PB push_back
using namespace std;
const int MAXN = (1 << 14) + 5;
int n, m, ans;
int xx[MAXN], yy[MAXN], *x = xx, *y = yy;
char s[MAXN];
int fxx[MAXN], fyy[MAXN], *fx = fxx, *fy = fyy;
int find(int x, int *fy){
	return x == fy[x] ? x : fy[x] = find(fy[x], fy);
}
void uni(int x, int y){
	//printf("uni %d %d\n", x, y);
	x = find(x, fx); y = find(y, fx);
	fx[x] = y;
}
struct Node{
	int v, next;
}vec[MAXN];
int head[MAXN], tot;
int main(){
	//freopen("in.txt", "r", stdin);
	scanf("%d%d", &n, &m);
	for(int i = 0; i < m; i++) fy[i] = i;
	for(int i = 0; i < n; i++){
		scanf("%s", s);
		for(int j = 0; j < m >> 2; j++){
			int k = s[j] <= '9' ? s[j] - '0' : s[j] - 'A' + 10;
			x[j << 2] = k >> 3;
			x[j << 2 | 1] = k >> 2 & 1;
			x[j << 2 | 2] = k >> 1 & 1;
			x[j << 2 | 3] = k & 1;
		}

		memset(head, 0, sizeof(head));
		tot = 0;
		for(int j = 0; j < m; j++){
			fx[j] = j;
			if(x[j]){
				int p = find(j, fy);
				++tot;
				vec[tot].v = j;
				vec[tot].next = head[p];
				head[p] = tot;
			}
		}
		for(int j = 0; j < m; j++){
			if(fy[j] == j && y[j] && !head[j]) ans++;
			for(int p = head[j]; p; p = vec[p].next){
				uni(vec[p].v, vec[head[j]].v);
			}
			if(j && x[j] && x[j - 1]) uni(j, j - 1);
		}

		swap(x, y);
		swap(fx, fy);
	}
	for(int j = 0; j < m; j++){
		if(fy[j] == j && y[j]) ans++;
	}

	cout << ans << endl;
	return 0;
}


#include<bits/stdc++.h>
#define LL long long
#define PB push_back
using namespace std;
const int MAXN = (1 << 14) + 5;
int n, m, ans;
int xx[MAXN], yy[MAXN], *x = xx, *y = yy;
char s[MAXN];
int fxx[MAXN], fyy[MAXN], *fx = fxx, *fy = fyy;
int find(int x, int *fy){
	return x == fy[x] ? x : fy[x] = find(fy[x], fy);
}
void uni(int x, int y){
	//printf("uni %d %d\n", x, y);
	x = find(x, fx); y = find(y, fx);
	fx[x] = y;
}
struct Node{
	int v, next;
}vec[MAXN];
int head[MAXN], tot;
int main(){
	//freopen("in.txt", "r", stdin);
	scanf("%d%d", &n, &m);
	for(int i = 0; i < m; i++) fy[i] = i;
	for(int i = 0; i < n; i++){
		scanf("%s", s);
		for(int j = 0; j < m >> 2; j++){
			int k = s[j] <= '9' ? s[j] - '0' : s[j] - 'A' + 10;
			x[j << 2] = k >> 3;
			x[j << 2 | 1] = k >> 2 & 1;
			x[j << 2 | 2] = k >> 1 & 1;
			x[j << 2 | 3] = k & 1;
		}

		memset(head, 0, sizeof(head));
		tot = 0;
		for(int j = 0; j < m; j++){
			fx[j] = j;
			if(x[j]){
				int p = find(j, fy);
				++tot;
				vec[tot].v = j;
				vec[tot].next = head[p];
				head[p] = tot;
			}
		}
		for(int j = 0; j < m; j++){
			if(fy[j] == j && y[j] && !head[j]) ans++;
			for(int p = head[j]; p; p = vec[p].next){
				uni(vec[p].v, vec[head[j]].v);
			}
			if(j && x[j] && x[j - 1]) uni(j, j - 1);
		}

		swap(x, y);
		swap(fx, fy);
	}
	for(int j = 0; j < m; j++){
		if(fy[j] == j && y[j]) ans++;
	}

	cout << ans << endl;
	return 0;


// By Hacheylight

#include <map>
#include <set>
#include <ctime>
#include <queue>
#include <stack>
#include <cmath>
#include <vector>
#include <bitset>
#include <cstdio>
#include <cctype>
#include <string>
#include <numeric>
#include <cstring>
#include <cassert>
#include <climits>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std ;
//#define int long long
#define rep(i, a, b) for (int i = (a); i <= (b); i++)
#define per(i, a, b) for (int i = (a); i >= (b); i--)
#define loop(it, v) for (auto it = v.begin(); it != v.end(); it++)
#define cont(i, x) for (int i = head[x]; i; i = e[i].nxt)
#define clr(a) memset(a, 0, sizeof(a))
#define ass(a, sum) memset(a, sum, sizeof(a))
#define lowbit(x) (x & -x)
#define all(x) x.begin(), x.end()
#define SC(t, x) static_cast <t> (x)
#define ub upper_bound
#define lb lower_bound
#define pqueue priority_queue
#define mp make_pair
#define pb push_back
#define pof pop_front
#define pob pop_back
#define fi first
#define se second
#define y1 y1_
#define Pi acos(-1.0)
#define iv inline void
#define enter cout << endl
#define siz(x) ((int)x.size())
#define file(x) freopen(x".in", "r", stdin),freopen(x".out", "w", stdout)
typedef long double ld ;
typedef long long ll ;
typedef unsigned long long ull ;
typedef pair <int, int> pii ;
typedef pair <ll, int> pli ;
typedef pair<int, pii> tri ;
typedef vector <int> vi ;
typedef vector <pii> vii ;
typedef vector <vi> vvi ;
typedef vector <string> vst ;
typedef queue <int> qi ;
typedef queue <pii> qii ;
typedef set <int> si ;
typedef map <int, int> mii ;
typedef map <string, int> msi ;
const int N = (1 << 14) + 10 ;
const int INF = 0x3f3f3f3f ;
const int iinf = 1 << 30 ;
const ll linf = 2e18 ;
const int mod = 1000000007 ;
const double eps = 1e-7 ;
void douout(double x){ printf("%lf\n", x + 0.0000000001) ; }
template <class T> void print(T a) { cout << a << endl ; exit(0) ; }
template <class T> void chmin(T &a, T b) { if (a > b) a = b ; }
template <class T> void chmax(T &a, T b) { if (a < b) a = b ; }
void add(int &a, int b) { a = a + b < mod ? a + b : a + b - mod ; }
void sub(int &a, int b) { a = (a - b + mod) % mod ; }
void mul(int &a, int b) { a = (ll) a * b % mod ; }
int addv(int a, int b) { return (a += b) >= mod ? a -= mod : a ; }
int subv(int a, int b) { return (a -= b) < 0 ? a += mod : a ; }
int mulv(int a, int b) { return (ll) a * b % mod ; }
int read() {
    int f = 1, x = 0 ;
    char ch = getchar() ;
    while (!isdigit(ch)) { if (ch == '-') f = -1 ; ch = getchar() ; }
    while (isdigit(ch)) { x = x * 10 + ch -'0' ; ch = getchar() ; }
    return x * f ;
}
int pw(int a, int b) {
    int s = 1 ;
    for (; b; b >>= 1, a = (ll) a * a % mod)
    if (b & 1) s = (ll) s * a % mod ;
    return s ;
}

int n, m, ans ;
int xx[N], yy[N], *x = xx, *y = yy ;
char s[N] ;
int fxx[N], fyy[N], *fx = fxx, *fy = fyy ;

int find(int x, int *fy) {
	return x == fy[x] ? x : fy[x] = find(fy[x], fy) ;
}

void uni(int x, int y) {
	x = find(x, fx) ;
	y = find(y, fx) ;
	fx[x] = y ;
}

struct Node{
	int v, nxt ;
}vec[N] ;

int head[N], tot ;

signed main() {
	scanf("%d%d", &n, &m) ;
	rep(i, 0, m - 1) fy[i] = i ;
	rep(i, 0, n - 1) {
		scanf("%s", s) ;
		rep(j, 0, (m / 2) - 1) {
			int k = s[j] <= '9' ? s[j] - '0' : s[j] - 'A' + 10 ;
			x[j << 2] = k >> 3 ;
			x[j << 2 | 1] = k >> 2 & 1 ;
			x[j << 2 | 2] = k >> 1 & 1 ;
			x[j << 2 | 3] = k & 1 ;
		}
		clr(head) ; tot = 0 ;
		rep(j, 0, m - 1) {
			fx[j] = j ;
			if (x[j]) {
				int p = find(j, fy) ;
				++tot ;
				vec[tot].v = j ;
				vec[tot].nxt = head[p] ;
				head[p] = tot ;
			}
		}
		rep(j, 0, m - 1) {
			if (fy[j] == j && y[j] && !head[j]) ans++ ;
			for(int p = head[j]; p; p = vec[p].nxt) {
				uni(vec[p].v, vec[head[j]].v) ;
			}
			if (j && x[j] && x[j - 1]) uni(j, j - 1) ;
		}
		swap(x, y) ;
		swap(fx, fy) ;
	}
	rep(j, 0, m - 1)
	if (fy[j] == j && y[j]) ans++ ;
	printf("%lld\n", ans) ;
	return 0 ;
}


#include<bits/stdc++.h>
#define REP(i,j,k) for(int i=j;i<k;++i)
#define RREP(i,j,k) for(int i=(int)j-1;i>=k;--i)
#define int long long
#define pb emplace_back
#define P pair<int,int>
#define F first
#define S second
#define ALL(x) x.begin(),x.end()
#define sz(a) (int)(a).size()
#define MX (1<<14+5)
#define oo 1e18
#define L d*2
#define R d*2+1
#define mid (l+r>>1)
#define Ls l,mid,d*2
#define Rs mid+1,r,d*2+1
#define MIN(x,y) (x=min(x,(y)))
#define MAX(x,y) (x=max(x,(y)))
#define mo (int)(1e9+7)
#define IOS cin.tie(0) ,cout.tie(0), cout.sync_with_stdio(0)
using namespace std;
int n,m,p[2*MX],a,ans;
char c;
int find(int x){ return p[x]==x?x:p[x]=find(p[x]);}
main(){
	IOS;
	cin>>n>>m;
	REP(i,0,n){
		REP(j,1,m+1) p[(i%2)*MX+j] = 0;
		REP(j,0,m/4){
			cin>>c;
			if(c>'9') a = c-'A'+10;
			else a = c-'0';
			REP(k,1,5) if(a&(1<<(4-k))){
				int x = (i%2)*MX+j*4+k, y = (1^(i%2))*MX+j*4+k;
				p[x] = x;
				if(p[x-1]) p[x-1] = p[x];
				if(p[y]) p[find(y)] = p[x];
			}
		}
		REP(j,1,m+1) if(p[(1^(i%2))*MX+j]){
			int x = find((1^(i%2))*MX+j);
			if(x==0) continue;
			if(i%2 && x<=MX) ans++,p[x] = 0;
			else if(i%2==0 && x>MX) ans++,p[x] = 0;
		}
	}
	REP(j,1,m+1) if(p[(1^(n%2))*MX+j]){
		int x = find((1^(n%2))*MX+j);
		if(x==0) continue;
		if(n%2 && x<=MX) ans++,p[x] = 0;
		else if(n%2==0 && x>MX) ans++,p[x] = 0;
	}
	cout<<ans;
}


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

int par[(1 << 14) + 1];
int root(int x)
{
    return par[x] == 0 ? x : (par[x] = root(par[x]));
}
bool merge(int x, int y)
{
    x = root(x);
    y = root(y);
    if(x == y)
        return 0;
    par[x] = y;
    return 1;
}

int tmp[(1 << 14) + 1];
bool used[(1 << 14) + 1];
int mem[2][1 << 14];

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

    vector<int> v(m);
    for(int i = 0; i < m; i++)
        v[i] = i + 1;

    int res = 0;
    for(int i = 0; i <= n; i++)
    {
        int x = i % 2;
        int y = 1 - i % 2;

        if(i == n)
        {
            for(int j = 0; j < m; j++)
                mem[x][j] = 0;
        }
        else
        {
            for(int j = 0; j < m / 4; j++)
            {
                char c;
                while(1)
                {
                    c = getchar();
                    if(isalnum(c))
                        break;
                }

                int t;
                if(isdigit(c))
                    t = c - '0';
                else
                    t = c - 'A' + 10;

                for(int k = 0; k < 4; k++)
                {
                    if(t & (1 << (3 - k)))
                        mem[x][4 * j + k] = 1;
                    else
                        mem[x][4 * j + k] = 0;
                }
            }
        }

        memset(tmp, 0, sizeof tmp);
        for(int j = 0; j < m; j++)
        {
            int r = root(mem[y][j]);
            if(r && tmp[r] != -1)
            {
                if(mem[x][j])
                    tmp[r] = -1;
                else
                    tmp[r] = 1;
            }
        }

        for(int j = 1; j <= m; j++)
            if(tmp[j] == 1)
                res++;

        for(int j = 0; j < m; j++)
        {
            int r = root(mem[y][j]);
            if(tmp[r] == 1 && used[mem[y][j]])
            {
                v.push_back(mem[y][j]);
                used[mem[y][j]] = 0;
            }
        }

        for(int j = 0; j < m; j++)
        {
            if(!mem[x][j])
                continue;

            if(mem[y][j])
                mem[x][j] = mem[y][j];
            else
            {
                mem[x][j] = v.back();
                used[v.back()] = 1;
                v.pop_back();
            }

            if(j > 0 && mem[x][j - 1])
                merge(mem[x][j - 1], mem[x][j]);
        }
    }

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


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

int par[(2 << 14) + 1];
int root(int x)
{
    return par[x] == 0 ? x : (par[x] = root(par[x]));
}
bool merge(int x, int y)
{
    x = root(x);
    y = root(y);
    if(x == y)
        return 0;
    par[x] = y;
    return 1;
}

int tmp[(2 << 14) + 1];
bool used[(2 << 14) + 1];
int mem[2][1 << 14];

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

    vector<int> v;
    for(int i = 1; i <= 2 * m; i++)
        v.push_back(i);

    int res = 0;
    for(int i = 0; i <= n; i++)
    {
        int x = i % 2;
        int y = 1 - i % 2;

        if(i == n)
        {
            for(int j = 0; j < m; j++)
                mem[x][j] = 0;
        }
        else
        {
            for(int j = 0; j < m / 4; j++)
            {
                char c;
                while(1)
                {
                    c = getchar();
                    if(isalnum(c))
                        break;
                }

                int t;
                if(isdigit(c))
                    t = c - '0';
                else
                    t = c - 'A' + 10;

                for(int k = 0; k < 4; k++)
                {
                    if(t & (1 << (3 - k)))
                        mem[x][4 * j + k] = 1;
                    else
                        mem[x][4 * j + k] = 0;
                }
            }
        }

        memset(tmp, 0, sizeof tmp);
        for(int j = 0; j < m; j++)
        {
            int r = root(mem[y][j]);
            if(r && tmp[r] != -1)
            {
                if(mem[x][j])
                    tmp[r] = -1;
                else
                    tmp[r] = 1;
            }
        }

        for(int j = 1; j <= 2 * m; j++)
            if(tmp[j] == 1)
                res++;

        for(int j = 0; j < m; j++)
        {
            int r = root(mem[y][j]);
            if(tmp[r] == 1 && used[mem[y][j]])
            {
                v.push_back(mem[y][j]);
                used[mem[y][j]] = 0;
            }
        }

        for(int j = 0; j < m; j++)
        {
            if(!mem[x][j])
                continue;

            if(mem[y][j])
                mem[x][j] = mem[y][j];
            else
            {
                assert(!v.empty());
                mem[x][j] = v.back();
                used[v.back()] = 1;
                v.pop_back();
            }

            if(j > 0 && mem[x][j - 1])
                merge(mem[x][j - 1], mem[x][j]);
        }
    }

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


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

int par[(1 << 14) + 1];
int root(int x)
{
    return par[x] == 0 ? x : (par[x] = root(par[x]));
}
bool merge(int x, int y)
{
    x = root(x);
    y = root(y);
    if(x == y)
        return 0;
    par[x] = y;
    return 1;
}

bool used[(1 << 14) + 1];
int tmp[(1 << 14) + 1];
int mem[2][1 << 14];

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

    vector<int> v;
    for(int i = 1; i <= m; i++)
        v.push_back(i);

    int res = 0;
    for(int i = 0; i <= n; i++)
    {
        int x = i % 2;
        int y = 1 - i % 2;

        if(i == n)
        {
            for(int j = 0; j < m; j++)
                mem[x][j] = 0;
        }
        else
        {
            for(int j = 0; j < m / 4; j++)
            {
                char c;
                while(1)
                {
                    c = getchar();
                    if(isalnum(c))
                        break;
                }

                int t;
                if(isdigit(c))
                    t = c - '0';
                else
                    t = c - 'A' + 10;

                for(int k = 0; k < 4; k++)
                {
                    if(t & (1 << (3 - k)))
                        mem[x][4 * j + k] = 1;
                    else
                        mem[x][4 * j + k] = 0;
                }
            }
        }

        memset(tmp, 0, sizeof tmp);
        for(int j = 0; j < m; j++)
        {
            int r = root(mem[y][j]);
            assert(mem[y][j] == r);
            if(r && tmp[r] != -1)
            {
                if(mem[x][j])
                    tmp[r] = -1;
                else
                    tmp[r] = 1;
            }
        }

        for(int j = 1; j <= m; j++)
        {
            if(tmp[j] == 1)
            {
                res++;
                used[j] = 0;
                v.push_back(j);
            }
        }

        for(int j = 0; j < m; j++)
        {
            if(!mem[x][j])
                continue;

            if(mem[y][j])
                mem[x][j] = mem[y][j];
            else
            {
                assert(!v.empty());
                mem[x][j] = v.back();
                used[v.back()] = 1;
                par[v.back()] = 0;
                v.pop_back();
            }

            if(j > 0 && mem[x][j - 1])
                merge(mem[x][j - 1], mem[x][j]);
        }

        for(int j = 0; j < m; j++)
        {
            int r = root(mem[x][j]);
            if(r && mem[x][j] != r)
            {
                if(used[mem[x][j]])
                {
                    used[mem[x][j]] = 0;
                    v.push_back(mem[x][j]);
                }
                mem[x][j] = r;
            }
        }
    }

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


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

int par[(1 << 14) + 1];
int root(int x)
{
    return par[x] == 0 ? x : (par[x] = root(par[x]));
}
bool merge(int x, int y)
{
    x = root(x);
    y = root(y);
    if(x == y)
        return 0;
    par[x] = y;
    return 1;
}

bool used[(1 << 14) + 1];
int tmp[(1 << 14) + 1];
int mem[2][1 << 14];

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

    vector<int> v;
    for(int i = 1; i <= m; i++)
        v.push_back(i);

    int res = 0;
    for(int i = 0; i <= n; i++)
    {
        int x = i % 2;
        int y = 1 - i % 2;

        if(i == n)
        {
            for(int j = 0; j < m; j++)
                mem[x][j] = 0;
        }
        else
        {
            for(int j = 0; j < m / 4; j++)
            {
                char c;
                while(1)
                {
                    c = getchar();
                    if(isalnum(c))
                        break;
                }

                int t;
                if(isdigit(c))
                    t = c - '0';
                else
                    t = c - 'A' + 10;

                for(int k = 0; k < 4; k++)
                {
                    if(t & (1 << (3 - k)))
                        mem[x][4 * j + k] = 1;
                    else
                        mem[x][4 * j + k] = 0;
                }
            }
        }

        memset(tmp, 0, sizeof tmp);
        for(int j = 0; j < m; j++)
        {
            int r = root(mem[y][j]);
            if(r && tmp[r] != -1)
            {
                if(mem[x][j])
                    tmp[r] = -1;
                else
                    tmp[r] = 1;
            }
        }

        for(int j = 1; j <= m; j++)
        {
            if(tmp[j] == 1)
            {
                res++;
                used[j] = 0;
                par[j] = 0;
                v.push_back(j);
            }
        }

        for(int j = 0; j < m; j++)
        {
            if(!mem[x][j])
                continue;

            if(mem[y][j])
                mem[x][j] = mem[y][j];
            else
            {
                assert(!v.empty());
                mem[x][j] = v.back();
                used[v.back()] = 1;
                par[v.back()] = 0;
                v.pop_back();
            }

            if(j > 0 && mem[x][j - 1])
                merge(mem[x][j - 1], mem[x][j]);
        }

        for(int j = 0; j < m; j++)
        {
            int r = root(mem[x][j]);
            if(r && mem[x][j] != r)
            {
                if(used[mem[x][j]])
                {
                    used[mem[x][j]] = 0;
                    par[mem[x][j]] = 0;
                    v.push_back(mem[x][j]);
                }
                mem[x][j] = r;
            }
        }
    }

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


#include<iostream>
#include<vector>
#include<set>
#include<queue>
#include<map>
#include<algorithm>
#include<cstring>
#include<string>
#include<cassert>
#include<cmath>
#include<climits>
#include<iomanip>
#include<stack>
#include<unordered_map>
#include<bitset>
#include<limits>
#include<complex>
#include<array>
#include<numeric>
#include<functional>

using namespace std;
#define ll long long
#define ull unsigned long long
#define rrep(i,m,n) for(ll (i)=(ll)(m);(i)>=(ll)(n);(i)--)
#define rep(i,m,n) for(ll (i)=(ll)(m);i<(ll)(n);i++)
#define REP(i,n) rep(i,0,n)
#define FOR(i,c) for(decltype((c).begin())i=(c).begin();i!=(c).end();++i)
#define all(hoge) (hoge).begin(),(hoge).end()
typedef pair<ll, ll> P;
constexpr long double m_pi = 3.1415926535897932L;
constexpr ll MOD = 1000000007;
constexpr ll INF = 1LL << 62;
constexpr long double EPS = 1e-10;
template<typename T> using vector2 = vector<vector<T>>;
template<typename T> using vector3 = vector<vector2<T>>;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
string operator*(const string& s, int k) {
	if (k == 0) return "";
	string p = (s + s) * (k / 2);
	if (k % 2 == 1) p += s;
	return p;
}

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

struct Edge {//グラフ
	int to, rev; ll cap;
	Edge(int _to, ll _cap, int _rev) {
		to = _to; cap = _cap; rev = _rev;
	}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph& G, int from, int to, ll cap, bool revFlag, ll revCap) {//最大フロー求める Ford-fulkerson
	G[from].push_back(Edge(to, cap, (ll)G[to].size() + (from == to)));
	if (revFlag)G[to].push_back(Edge(from, revCap, (ll)G[from].size() - 1));//最小カットの場合逆辺は0にする
}

ll max_flow_dfs(Graph& G, ll v, ll t, ll f, vector<bool>& used)
{
	if (v == t)
		return f;
	used[v] = true;
	for (int i = 0; i < G[v].size(); ++i) {
		Edge& e = G[v][i];
		if (!used[e.to] && e.cap > 0) {
			ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
			if (d > 0) {
				e.cap -= d;
				G[e.to][e.rev].cap += d;
				return d;
			}
		}
	}
	return 0;
}
//二分グラフの最大マッチングを求めたりも出来る　また二部グラフの最大独立集合は頂点数-最大マッチングのサイズ
ll max_flow(Graph& G, ll s, ll t)//O(V(V+E))
{
	ll flow = 0;
	for (;;) {
		vector<bool> used(G.size());
		REP(i, used.size())used[i] = false;
		ll f = max_flow_dfs(G, s, t, INF, used);
		if (f == 0) {
			return flow;
		}
		flow += f;
	}
}

void BellmanFord(Graph& G, ll s, Array& d, Array& negative) {//O(|E||V|)
	d.resize(G.size());
	negative.resize(G.size());
	REP(i, d.size())d[i] = INF;
	REP(i, d.size())negative[i] = false;
	d[s] = 0;
	REP(k, G.size() - 1) {
		REP(i, G.size()) {
			REP(j, G[i].size()) {
				if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
					d[G[i][j].to] = d[i] + G[i][j].cap;
				}
			}
		}
	}
	REP(k, G.size() - 1) {
		REP(i, G.size()) {
			REP(j, G[i].size()) {
				if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
					d[G[i][j].to] = d[i] + G[i][j].cap;
					negative[G[i][j].to] = true;
				}
				if (negative[i] == true)negative[G[i][j].to] = true;
			}
		}
	}
}
void Dijkstra(Graph& G, ll s, Array& d) {//O(|E|log|V|)
	d.resize(G.size());
	REP(i, d.size())d[i] = INF;
	d[s] = 0;
	priority_queue<P, vector<P>, greater<P>> q;
	q.push(make_pair(0, s));
	while (!q.empty()) {
		P a = q.top();
		q.pop();
		if (d[a.second] < a.first)continue;
		REP(i, G[a.second].size()) {
			Edge e = G[a.second][i];
			if (d[e.to] > d[a.second] + e.cap) {
				d[e.to] = d[a.second] + e.cap;
				q.push(make_pair(d[e.to], e.to));
			}
		}
	}
}
void WarshallFloyd(Graph& G, Matrix& d) {//O(V^3)
	d.resize(G.size());
	REP(i, d.size())d[i].resize(G.size());
	REP(i, d.size()) {
		REP(j, d[i].size()) {
			d[i][j] = ((i != j) ? INF : 0);
		}
	}
	REP(i, G.size()) {
		REP(j, G[i].size()) {
			chmin(d[i][G[i][j].to], G[i][j].cap);
		}
	}
	REP(i, G.size()) {
		REP(j, G.size()) {
			REP(k, G.size()) {
				chmin(d[j][k], d[j][i] + d[i][k]);
			}
		}
	}
}
bool tsort(Graph& graph, Array& order) {//トポロジカルソートO(E+V)
	int n = graph.size(), k = 0;
	Array in(n);
	for (auto& es : graph)
		for (auto& e : es)in[e.to]++;
	priority_queue<ll, Array, greater<ll>> que;
	REP(i, n)
		if (in[i] == 0)que.push(i);
	while (que.size()) {
		int v = que.top();
		que.pop();
		order.push_back(v);
		for (auto& e : graph[v])
			if (--in[e.to] == 0)que.push(e.to);
	}
	if (order.size() != n)return false;
	else return true;
}
class Lca {
public:
	const int n = 0;
	const int log2_n = 0;
	std::vector<std::vector<int>> parent;
	std::vector<int> depth;

	Lca() {}

	Lca(const Graph& g, int root)
		: n(g.size()), log2_n(log2(n) + 1), parent(log2_n, std::vector<int>(n)), depth(n) {
		dfs(g, root, -1, 0);
		for (int k = 0; k + 1 < log2_n; k++) {
			for (int v = 0; v < (int)g.size(); v++) {
				if (parent[k][v] < 0)
					parent[k + 1][v] = -1;
				else
					parent[k + 1][v] = parent[k][parent[k][v]];
			}
		}
	}

	void dfs(const Graph& g, int v, int p, int d) {
		parent[0][v] = p;
		depth[v] = d;
		for (auto& e : g[v]) {
			if (e.to != p) dfs(g, e.to, v, d + 1);
		}
	}

	int get(int u, int v) {
		if (depth[u] > depth[v]) std::swap(u, v);
		for (int k = 0; k < log2_n; k++) {
			if ((depth[v] - depth[u]) >> k & 1) {
				v = parent[k][v];
			}
		}
		if (u == v) return u;
		for (int k = log2_n - 1; k >= 0; k--) {
			if (parent[k][u] != parent[k][v]) {
				u = parent[k][u];
				v = parent[k][v];
			}
		}
		return parent[0][u];
	}
};

class UnionFind {
	vector<int> data;
	ll _num;
public:
	UnionFind(int size) : data(size, -1), _num(size) { }
	bool merge(int x, int y) {//xとyの集合を統合する
		x = root(x); y = root(y);
		if (x != y) {
			if (data[y] < data[x]) swap(x, y);
			data[x] += data[y]; data[y] = x;
		}
		_num -= (x != y);
		return x != y;
	}
	bool same(int x, int y) {//xとyが同じ集合か返す
		return root(x) == root(y);
	}
	int root(int x) {//xのルートを返す
		return data[x] < 0 ? x : data[x] = root(data[x]);
	}
	ll size(int x) {//xの集合のサイズを返す
		return -data[root(x)];
	}
	ll num() {//集合の数を返す
		return _num;
	}
};

template<typename T, typename F>
class SegmentTree {
private:
	T identity;
	F merge;
	ll n;
	vector<T> dat;
public:
	SegmentTree(F f, T id, vector<T> v) :merge(f), identity(id) {
		int _n = v.size();
		n = 1;
		while (n < _n)n *= 2;
		dat.resize(2 * n - 1, identity);
		REP(i, _n)dat[n + i - 1] = v[i];
		for (int i = n - 2; i >= 0; i--)dat[i] = merge(dat[i * 2 + 1], dat[i * 2 + 2]);
	}
	SegmentTree(F f, T id, int _n) :merge(f), identity(id) {
		n = 1;
		while (n < _n)n *= 2;
		dat.resize(2 * n - 1, identity);
	}
	void set_val(int i, T x) {
		i += n - 1;
		dat[i] = x;
		while (i > 0) {
			i = (i - 1) / 2;
			dat[i] = merge(dat[i * 2 + 1], dat[i * 2 + 2]);
		}
	}
	T query(int l, int r) {
		T left = identity, right = identity;
		l += n - 1; r += n - 1;
		while (l < r) {
			if ((l & 1) == 0)left = merge(left, dat[l]);
			if ((r & 1) == 0)right = merge(dat[r - 1], right);
			l = l / 2;
			r = (r - 1) / 2;
		}
		return merge(left, right);
	}
};

template< typename T >
class FenwickTree {
	vector< T > data;
	int n;
	int p;
public:
	FenwickTree(int n) :n(n) {
		data.resize(n + 1LL, 0);
		p = 1;
		while (p < data.size())p *= 2;
	}
	T sum(int k) {
		T ret = 0;
		for (; k > 0; k -= k & -k) ret += data[k];
		return (ret);
	}

	T sum(int a, int b) { return sum(b) - sum(a); }//[a,b)

	void add(int k, T x) {
		for (++k; k <= n; k += k & -k) data[k] += x;
	}

	int lower_bound(ll w) {
		if (w <= 0)return -1;
		int x = 0;
		for (int k = p / 2; k > 0; k /= 2) {
			if (x + k <= n && data[x + k] < w)w -= data[x + k], x += k;
		}
		return x;
	}
};

//約数求める //約数
void divisor(ll n, vector<ll>& ret) {
	for (ll i = 1; i * i <= n; i++) {
		if (n % i == 0) {
			ret.push_back(i);
			if (i * i != n) ret.push_back(n / i);
		}
	}
	sort(ret.begin(), ret.end());
}

void prime_factorization(ll n, vector<P>& ret) {
	for (ll i = 2; i * i <= n; i++) {
		if (n % i == 0) {
			ret.push_back({ i,0 });
			while (n % i == 0) {
				n /= i;
				ret[ret.size() - 1].second++;
			}
		}
	}
	if (n != 1)ret.push_back({ n,1 });
}

inline ll mod_pow(ll x, ll n, ll mod) {
	ll res = 1;
	while (n > 0) {
		if (n & 1) res = res * x % mod;
		x = x * x % mod;
		n >>= 1;
	}
	return res;
}

inline ll mod_inv(ll x, ll mod) {
	return mod_pow(x, mod - 2, mod);
}

class Combination {
public:
	Array fact;
	Array fact_inv;
	ll mod;
	//if n >= mod use lucas
	ll nCr(ll n, ll r) {
		if (n < r)return 0;
		if (n < mod)return ((fact[n] * fact_inv[r] % mod) * fact_inv[n - r]) % mod;

		ll ret = 1;
		while (n || r) {
			ll _n = n % mod, _r = r % mod;
			n /= mod; r /= mod;
			(ret *= nCr(_n, _r)) %= mod;
		}
		return ret;
	}
	ll nPr(ll n, ll r) {
		return (fact[n] * fact_inv[n - r]) % mod;
	}
	ll nHr(ll n, ll r) {
		return nCr(r + n - 1, r);
	}
	Combination(ll _n, ll _mod) {
		mod = _mod;
		ll n = min(_n + 1, mod);
		fact.resize(n);
		fact[0] = 1;
		REP(i, n - 1) {
			fact[i + 1] = (fact[i] * (i + 1LL)) % mod;
		}
		fact_inv.resize(n);
		fact_inv[n - 1] = mod_inv(fact[n - 1], mod);
		for (int i = n - 1; i > 0; i--) {
			fact_inv[i - 1] = fact_inv[i] * i % mod;
		}
	}
};

ll popcount(ll x) {
	x = (x & 0x5555555555555555) + (x >> 1 & 0x5555555555555555);
	x = (x & 0x3333333333333333) + (x >> 2 & 0x3333333333333333);
	x = (x & 0x0F0F0F0F0F0F0F0F) + (x >> 4 & 0x0F0F0F0F0F0F0F0F);
	x = (x & 0x00FF00FF00FF00FF) + (x >> 8 & 0x00FF00FF00FF00FF);
	x = (x & 0x0000FFFF0000FFFF) + (x >> 16 & 0x0000FFFF0000FFFF);
	x = (x & 0x00000000FFFFFFFF) + (x >> 32 & 0x00000000FFFFFFFF);

	return x;
}

template<typename T, typename E, typename F, typename G, typename H, typename P>
class LazySegmentTree {
private:
	const T identity_t;
	const E identity_e;
	F f_tt;
	G f_te;
	H f_ee;
	P f_ep;//区間に比例する場合
	vector<T> dat;
	vector<E> lazy;
	int n;
	void eval(int k, int len) {
		if (lazy[k] == identity_e)return;
		if (k < n - 1) {
			lazy[2 * k + 1] = f_ee(lazy[2 * k + 1], lazy[k]);
			lazy[2 * k + 2] = f_ee(lazy[2 * k + 2], lazy[k]);
		}
		dat[k] = f_te(dat[k], f_ep(lazy[k], len));
		lazy[k] = identity_e;
	}
	void update(int a, int b, E x, int k, int l, int r) {
		eval(k, r - l);
		if (a <= l && r <= b) {
			lazy[k] = f_ee(lazy[k], x);
			eval(k, r - l);
		}
		else if (a < r && l < b) {
			update(a, b, x, k * 2 + 1, l, (l + r) / 2);
			update(a, b, x, k * 2 + 2, (l + r) / 2, r);
			dat[k] = f_tt(dat[2 * k + 1], dat[2 * k + 2]);
		}
	}
	T query(int a, int b, int k, int l, int r) {
		eval(k, r - l);
		if (r <= a || b <= l)return identity_t;
		else if (a <= l && r <= b)return dat[k];
		else {
			T vl = query(a, b, 2 * k + 1, l, (l + r) / 2);
			T vr = query(a, b, 2 * k + 2, (l + r) / 2, r);
			return f_tt(vl, vr);
		}
	}
public:
	LazySegmentTree(vector<T> v, T id_t, E id_e, F f, G g, H h, P p) :
		identity_t(id_t), identity_e(id_e), f_tt(f), f_te(g), f_ee(h), f_ep(p) {
		n = 1;
		while (n < v.size())n *= 2;
		dat.resize(2 * n - 1, identity_t);
		lazy.resize(2 * n - 1, identity_e);
		REP(i, v.size())dat[n + i - 1] = v[i];
		for (int i = n - 2; i >= 0; i--)dat[i] = f_tt(dat[i * 2 + 1], dat[i * 2 + 2]);

	}
	void update(int a, int b, E x) { update(a, b, x, 0, 0, n); }
	T query(int a, int b) { return query(a, b, 0, 0, n); }
};

Matrix mIdentity(ll n) {
	Matrix A(n, Array(n));
	for (int i = 0; i < n; ++i) A[i][i] = 1;
	return A;
}

Matrix mMul(const Matrix& A, const Matrix& B,ll M) {
	Matrix C(A.size(), Array(B[0].size()));
	for (int i = 0; i < C.size(); ++i)
		for (int k = 0; k < A[i].size(); ++k)
			for (int j = 0; j < C[i].size(); ++j)
				(C[i][j] += (A[i][k] % M) * (B[k][j] % M)) %= M;
	return C;
}
// O( n^3 log e )
Matrix mPow(const Matrix& A, ll e , ll M) {
	return e == 0 ? mIdentity(A.size()) :
		e % 2 == 0 ? mPow(mMul(A, A, M), e / 2, M) : mMul(A, mPow(A, e - 1, M), M);
}

template<ll mod, ll root>//特殊な素数と原始根　998244353のとき3
class NTT {
private:
	template<typename T>
	inline void bit_reverse(vector<T>& a) {
		int n = a.size();
		int i = 0;
		for (int j = 1; j < n - 1; ++j) {
			for (int k = n >> 1; k > (i ^= k); k >>= 1);
			if (j < i) swap(a[i], a[j]);
		}
	}
	void _ntt(vector<long long>& a, int sign) {
		const int n = a.size();
		assert((n ^ (n & -n)) == 0); //n = 2^k

		long long tmp = (mod - 1) * mod_pow((ll)n, mod - 2, mod) % mod; // -1/n
		long long h = mod_pow(root, tmp, mod); // ^n√g
		if (sign == -1) h = mod_pow(h, mod - 2, mod);

		bit_reverse(a);

		for (ll m = 1; m < n; m <<= 1) {
			const ll m2 = 2 * m;
			long long _base = mod_pow((ll)h, (ll)(n / m2), mod);
			long long _w = 1;
			for (int x = 0; x < m; ++x) {
				for (ll s = x; s < n; s += m2) {
					long long u = a[s];
					long long d = (a[s + m] * _w) % mod;
					a[s] = (u + d) % mod;
					a[s + m] = (u - d + mod) % mod;
				}
				_w = (_w * _base) % mod;
			}
		}
	}

	void ntt(vector<long long>& input) { _ntt(input, 1); }

	void intt(vector<long long>& input) {
		_ntt(input, -1);
		const long long n_inv = mod_pow((ll)input.size(), mod - 2, mod);
		for (auto& x : input) x = (x * n_inv) % mod;
	}
public:
	// 畳み込み演算を行う
	vector<long long> convolution(const vector<long long>& a, const vector<long long>& b) {
		int result_size = a.size() + b.size() - 1;
		int n = 1; while (n < result_size) n <<= 1;

		vector<long long> _a = a, _b = b;
		_a.resize(n, 0);
		_b.resize(n, 0);

		ntt(_a);
		ntt(_b);
		for (int i = 0; i < n; ++i) _a[i] = (_a[i] * _b[i]) % mod;

		intt(_a);

		_a.resize(result_size);
		return _a;
	}
};

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

	constexpr ll mod = 998244353;

	ll n, m;
	cin >> n >> m;
	vector<bitset<2 << 14>> a(n);
	REP(i, n) {
		string s;
		cin >> s;
		REP(j, m / 4) {
			int tmp;
			if (s[j] <= '9' && s[j] >= '0')tmp = s[j] - '0';
			else tmp = s[j] - 'A' + 10;
			REP(k, 4) {
				if (tmp & (1 << k))a[i][4 * j + 3 - k] = 1;
			}
		}
	}
	int ans = 0;
	REP(i, n)REP(j, m) {
		if (a[i][j] == 0)continue;
		ans++;
		queue<pair<int, int>> que;
		que.push({ i,j });
		while (que.size()) {
			auto [x, y] = que.front();
			que.pop();
			a[x][y] = 0;
			if (x != 0 && a[x - 1][y] == 1)que.push({ x - 1,y });
			if (x != n - 1 && a[x + 1][y] == 1)que.push({ x + 1,y });
			if (y != 0 && a[x][y - 1] == 1)que.push({ x,y - 1 });
			if (y != m - 1 && a[x][y + 1] == 1)que.push({ x,y + 1 });
		}
	}
	cout << ans << "\n";

	return 0;
}


#include<iostream>
#include<vector>
#include<set>
#include<queue>
#include<map>
#include<algorithm>
#include<cstring>
#include<string>
#include<cassert>
#include<cmath>
#include<climits>
#include<iomanip>
#include<stack>
#include<unordered_map>
#include<bitset>
#include<limits>
#include<complex>
#include<array>
#include<numeric>
#include<functional>

using namespace std;
#define ll long long
#define ull unsigned long long
#define rrep(i,m,n) for(ll (i)=(ll)(m);(i)>=(ll)(n);(i)--)
#define rep(i,m,n) for(ll (i)=(ll)(m);i<(ll)(n);i++)
#define REP(i,n) rep(i,0,n)
#define FOR(i,c) for(decltype((c).begin())i=(c).begin();i!=(c).end();++i)
#define all(hoge) (hoge).begin(),(hoge).end()
typedef pair<ll, ll> P;
constexpr long double m_pi = 3.1415926535897932L;
constexpr ll MOD = 1000000007;
constexpr ll INF = 1LL << 62;
constexpr long double EPS = 1e-10;
template<typename T> using vector2 = vector<vector<T>>;
template<typename T> using vector3 = vector<vector2<T>>;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
string operator*(const string& s, int k) {
	if (k == 0) return "";
	string p = (s + s) * (k / 2);
	if (k % 2 == 1) p += s;
	return p;
}

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

struct Edge {//グラフ
	int to, rev; ll cap;
	Edge(int _to, ll _cap, int _rev) {
		to = _to; cap = _cap; rev = _rev;
	}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph& G, int from, int to, ll cap, bool revFlag, ll revCap) {//最大フロー求める Ford-fulkerson
	G[from].push_back(Edge(to, cap, (ll)G[to].size() + (from == to)));
	if (revFlag)G[to].push_back(Edge(from, revCap, (ll)G[from].size() - 1));//最小カットの場合逆辺は0にする
}

ll max_flow_dfs(Graph& G, ll v, ll t, ll f, vector<bool>& used)
{
	if (v == t)
		return f;
	used[v] = true;
	for (int i = 0; i < G[v].size(); ++i) {
		Edge& e = G[v][i];
		if (!used[e.to] && e.cap > 0) {
			ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
			if (d > 0) {
				e.cap -= d;
				G[e.to][e.rev].cap += d;
				return d;
			}
		}
	}
	return 0;
}
//二分グラフの最大マッチングを求めたりも出来る　また二部グラフの最大独立集合は頂点数-最大マッチングのサイズ
ll max_flow(Graph& G, ll s, ll t)//O(V(V+E))
{
	ll flow = 0;
	for (;;) {
		vector<bool> used(G.size());
		REP(i, used.size())used[i] = false;
		ll f = max_flow_dfs(G, s, t, INF, used);
		if (f == 0) {
			return flow;
		}
		flow += f;
	}
}

void BellmanFord(Graph& G, ll s, Array& d, Array& negative) {//O(|E||V|)
	d.resize(G.size());
	negative.resize(G.size());
	REP(i, d.size())d[i] = INF;
	REP(i, d.size())negative[i] = false;
	d[s] = 0;
	REP(k, G.size() - 1) {
		REP(i, G.size()) {
			REP(j, G[i].size()) {
				if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
					d[G[i][j].to] = d[i] + G[i][j].cap;
				}
			}
		}
	}
	REP(k, G.size() - 1) {
		REP(i, G.size()) {
			REP(j, G[i].size()) {
				if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
					d[G[i][j].to] = d[i] + G[i][j].cap;
					negative[G[i][j].to] = true;
				}
				if (negative[i] == true)negative[G[i][j].to] = true;
			}
		}
	}
}
void Dijkstra(Graph& G, ll s, Array& d) {//O(|E|log|V|)
	d.resize(G.size());
	REP(i, d.size())d[i] = INF;
	d[s] = 0;
	priority_queue<P, vector<P>, greater<P>> q;
	q.push(make_pair(0, s));
	while (!q.empty()) {
		P a = q.top();
		q.pop();
		if (d[a.second] < a.first)continue;
		REP(i, G[a.second].size()) {
			Edge e = G[a.second][i];
			if (d[e.to] > d[a.second] + e.cap) {
				d[e.to] = d[a.second] + e.cap;
				q.push(make_pair(d[e.to], e.to));
			}
		}
	}
}
void WarshallFloyd(Graph& G, Matrix& d) {//O(V^3)
	d.resize(G.size());
	REP(i, d.size())d[i].resize(G.size());
	REP(i, d.size()) {
		REP(j, d[i].size()) {
			d[i][j] = ((i != j) ? INF : 0);
		}
	}
	REP(i, G.size()) {
		REP(j, G[i].size()) {
			chmin(d[i][G[i][j].to], G[i][j].cap);
		}
	}
	REP(i, G.size()) {
		REP(j, G.size()) {
			REP(k, G.size()) {
				chmin(d[j][k], d[j][i] + d[i][k]);
			}
		}
	}
}
bool tsort(Graph& graph, Array& order) {//トポロジカルソートO(E+V)
	int n = graph.size(), k = 0;
	Array in(n);
	for (auto& es : graph)
		for (auto& e : es)in[e.to]++;
	priority_queue<ll, Array, greater<ll>> que;
	REP(i, n)
		if (in[i] == 0)que.push(i);
	while (que.size()) {
		int v = que.top();
		que.pop();
		order.push_back(v);
		for (auto& e : graph[v])
			if (--in[e.to] == 0)que.push(e.to);
	}
	if (order.size() != n)return false;
	else return true;
}
class Lca {
public:
	const int n = 0;
	const int log2_n = 0;
	std::vector<std::vector<int>> parent;
	std::vector<int> depth;

	Lca() {}

	Lca(const Graph& g, int root)
		: n(g.size()), log2_n(log2(n) + 1), parent(log2_n, std::vector<int>(n)), depth(n) {
		dfs(g, root, -1, 0);
		for (int k = 0; k + 1 < log2_n; k++) {
			for (int v = 0; v < (int)g.size(); v++) {
				if (parent[k][v] < 0)
					parent[k + 1][v] = -1;
				else
					parent[k + 1][v] = parent[k][parent[k][v]];
			}
		}
	}

	void dfs(const Graph& g, int v, int p, int d) {
		parent[0][v] = p;
		depth[v] = d;
		for (auto& e : g[v]) {
			if (e.to != p) dfs(g, e.to, v, d + 1);
		}
	}

	int get(int u, int v) {
		if (depth[u] > depth[v]) std::swap(u, v);
		for (int k = 0; k < log2_n; k++) {
			if ((depth[v] - depth[u]) >> k & 1) {
				v = parent[k][v];
			}
		}
		if (u == v) return u;
		for (int k = log2_n - 1; k >= 0; k--) {
			if (parent[k][u] != parent[k][v]) {
				u = parent[k][u];
				v = parent[k][v];
			}
		}
		return parent[0][u];
	}
};

class UnionFind {
	vector<int> data;
	ll _num;
public:
	UnionFind(int size) : data(size, -1), _num(size) { }
	bool merge(int x, int y) {//xとyの集合を統合する
		x = root(x); y = root(y);
		if (x != y) {
			if (data[y] < data[x]) swap(x, y);
			data[x] += data[y]; data[y] = x;
		}
		_num -= (x != y);
		return x != y;
	}
	bool same(int x, int y) {//xとyが同じ集合か返す
		return root(x) == root(y);
	}
	int root(int x) {//xのルートを返す
		return data[x] < 0 ? x : data[x] = root(data[x]);
	}
	ll size(int x) {//xの集合のサイズを返す
		return -data[root(x)];
	}
	ll num() {//集合の数を返す
		return _num;
	}
};

template<typename T, typename F>
class SegmentTree {
private:
	T identity;
	F merge;
	ll n;
	vector<T> dat;
public:
	SegmentTree(F f, T id, vector<T> v) :merge(f), identity(id) {
		int _n = v.size();
		n = 1;
		while (n < _n)n *= 2;
		dat.resize(2 * n - 1, identity);
		REP(i, _n)dat[n + i - 1] = v[i];
		for (int i = n - 2; i >= 0; i--)dat[i] = merge(dat[i * 2 + 1], dat[i * 2 + 2]);
	}
	SegmentTree(F f, T id, int _n) :merge(f), identity(id) {
		n = 1;
		while (n < _n)n *= 2;
		dat.resize(2 * n - 1, identity);
	}
	void set_val(int i, T x) {
		i += n - 1;
		dat[i] = x;
		while (i > 0) {
			i = (i - 1) / 2;
			dat[i] = merge(dat[i * 2 + 1], dat[i * 2 + 2]);
		}
	}
	T query(int l, int r) {
		T left = identity, right = identity;
		l += n - 1; r += n - 1;
		while (l < r) {
			if ((l & 1) == 0)left = merge(left, dat[l]);
			if ((r & 1) == 0)right = merge(dat[r - 1], right);
			l = l / 2;
			r = (r - 1) / 2;
		}
		return merge(left, right);
	}
};

template< typename T >
class FenwickTree {
	vector< T > data;
	int n;
	int p;
public:
	FenwickTree(int n) :n(n) {
		data.resize(n + 1LL, 0);
		p = 1;
		while (p < data.size())p *= 2;
	}
	T sum(int k) {
		T ret = 0;
		for (; k > 0; k -= k & -k) ret += data[k];
		return (ret);
	}

	T sum(int a, int b) { return sum(b) - sum(a); }//[a,b)

	void add(int k, T x) {
		for (++k; k <= n; k += k & -k) data[k] += x;
	}

	int lower_bound(ll w) {
		if (w <= 0)return -1;
		int x = 0;
		for (int k = p / 2; k > 0; k /= 2) {
			if (x + k <= n && data[x + k] < w)w -= data[x + k], x += k;
		}
		return x;
	}
};

//約数求める //約数
void divisor(ll n, vector<ll>& ret) {
	for (ll i = 1; i * i <= n; i++) {
		if (n % i == 0) {
			ret.push_back(i);
			if (i * i != n) ret.push_back(n / i);
		}
	}
	sort(ret.begin(), ret.end());
}

void prime_factorization(ll n, vector<P>& ret) {
	for (ll i = 2; i * i <= n; i++) {
		if (n % i == 0) {
			ret.push_back({ i,0 });
			while (n % i == 0) {
				n /= i;
				ret[ret.size() - 1].second++;
			}
		}
	}
	if (n != 1)ret.push_back({ n,1 });
}

inline ll mod_pow(ll x, ll n, ll mod) {
	ll res = 1;
	while (n > 0) {
		if (n & 1) res = res * x % mod;
		x = x * x % mod;
		n >>= 1;
	}
	return res;
}

inline ll mod_inv(ll x, ll mod) {
	return mod_pow(x, mod - 2, mod);
}

class Combination {
public:
	Array fact;
	Array fact_inv;
	ll mod;
	//if n >= mod use lucas
	ll nCr(ll n, ll r) {
		if (n < r)return 0;
		if (n < mod)return ((fact[n] * fact_inv[r] % mod) * fact_inv[n - r]) % mod;

		ll ret = 1;
		while (n || r) {
			ll _n = n % mod, _r = r % mod;
			n /= mod; r /= mod;
			(ret *= nCr(_n, _r)) %= mod;
		}
		return ret;
	}
	ll nPr(ll n, ll r) {
		return (fact[n] * fact_inv[n - r]) % mod;
	}
	ll nHr(ll n, ll r) {
		return nCr(r + n - 1, r);
	}
	Combination(ll _n, ll _mod) {
		mod = _mod;
		ll n = min(_n + 1, mod);
		fact.resize(n);
		fact[0] = 1;
		REP(i, n - 1) {
			fact[i + 1] = (fact[i] * (i + 1LL)) % mod;
		}
		fact_inv.resize(n);
		fact_inv[n - 1] = mod_inv(fact[n - 1], mod);
		for (int i = n - 1; i > 0; i--) {
			fact_inv[i - 1] = fact_inv[i] * i % mod;
		}
	}
};

ll popcount(ll x) {
	x = (x & 0x5555555555555555) + (x >> 1 & 0x5555555555555555);
	x = (x & 0x3333333333333333) + (x >> 2 & 0x3333333333333333);
	x = (x & 0x0F0F0F0F0F0F0F0F) + (x >> 4 & 0x0F0F0F0F0F0F0F0F);
	x = (x & 0x00FF00FF00FF00FF) + (x >> 8 & 0x00FF00FF00FF00FF);
	x = (x & 0x0000FFFF0000FFFF) + (x >> 16 & 0x0000FFFF0000FFFF);
	x = (x & 0x00000000FFFFFFFF) + (x >> 32 & 0x00000000FFFFFFFF);

	return x;
}

template<typename T, typename E, typename F, typename G, typename H, typename P>
class LazySegmentTree {
private:
	const T identity_t;
	const E identity_e;
	F f_tt;
	G f_te;
	H f_ee;
	P f_ep;//区間に比例する場合
	vector<T> dat;
	vector<E> lazy;
	int n;
	void eval(int k, int len) {
		if (lazy[k] == identity_e)return;
		if (k < n - 1) {
			lazy[2 * k + 1] = f_ee(lazy[2 * k + 1], lazy[k]);
			lazy[2 * k + 2] = f_ee(lazy[2 * k + 2], lazy[k]);
		}
		dat[k] = f_te(dat[k], f_ep(lazy[k], len));
		lazy[k] = identity_e;
	}
	void update(int a, int b, E x, int k, int l, int r) {
		eval(k, r - l);
		if (a <= l && r <= b) {
			lazy[k] = f_ee(lazy[k], x);
			eval(k, r - l);
		}
		else if (a < r && l < b) {
			update(a, b, x, k * 2 + 1, l, (l + r) / 2);
			update(a, b, x, k * 2 + 2, (l + r) / 2, r);
			dat[k] = f_tt(dat[2 * k + 1], dat[2 * k + 2]);
		}
	}
	T query(int a, int b, int k, int l, int r) {
		eval(k, r - l);
		if (r <= a || b <= l)return identity_t;
		else if (a <= l && r <= b)return dat[k];
		else {
			T vl = query(a, b, 2 * k + 1, l, (l + r) / 2);
			T vr = query(a, b, 2 * k + 2, (l + r) / 2, r);
			return f_tt(vl, vr);
		}
	}
public:
	LazySegmentTree(vector<T> v, T id_t, E id_e, F f, G g, H h, P p) :
		identity_t(id_t), identity_e(id_e), f_tt(f), f_te(g), f_ee(h), f_ep(p) {
		n = 1;
		while (n < v.size())n *= 2;
		dat.resize(2 * n - 1, identity_t);
		lazy.resize(2 * n - 1, identity_e);
		REP(i, v.size())dat[n + i - 1] = v[i];
		for (int i = n - 2; i >= 0; i--)dat[i] = f_tt(dat[i * 2 + 1], dat[i * 2 + 2]);

	}
	void update(int a, int b, E x) { update(a, b, x, 0, 0, n); }
	T query(int a, int b) { return query(a, b, 0, 0, n); }
};

Matrix mIdentity(ll n) {
	Matrix A(n, Array(n));
	for (int i = 0; i < n; ++i) A[i][i] = 1;
	return A;
}

Matrix mMul(const Matrix& A, const Matrix& B,ll M) {
	Matrix C(A.size(), Array(B[0].size()));
	for (int i = 0; i < C.size(); ++i)
		for (int k = 0; k < A[i].size(); ++k)
			for (int j = 0; j < C[i].size(); ++j)
				(C[i][j] += (A[i][k] % M) * (B[k][j] % M)) %= M;
	return C;
}
// O( n^3 log e )
Matrix mPow(const Matrix& A, ll e , ll M) {
	return e == 0 ? mIdentity(A.size()) :
		e % 2 == 0 ? mPow(mMul(A, A, M), e / 2, M) : mMul(A, mPow(A, e - 1, M), M);
}

template<ll mod, ll root>//特殊な素数と原始根　998244353のとき3
class NTT {
private:
	template<typename T>
	inline void bit_reverse(vector<T>& a) {
		int n = a.size();
		int i = 0;
		for (int j = 1; j < n - 1; ++j) {
			for (int k = n >> 1; k > (i ^= k); k >>= 1);
			if (j < i) swap(a[i], a[j]);
		}
	}
	void _ntt(vector<long long>& a, int sign) {
		const int n = a.size();
		assert((n ^ (n & -n)) == 0); //n = 2^k

		long long tmp = (mod - 1) * mod_pow((ll)n, mod - 2, mod) % mod; // -1/n
		long long h = mod_pow(root, tmp, mod); // ^n√g
		if (sign == -1) h = mod_pow(h, mod - 2, mod);

		bit_reverse(a);

		for (ll m = 1; m < n; m <<= 1) {
			const ll m2 = 2 * m;
			long long _base = mod_pow((ll)h, (ll)(n / m2), mod);
			long long _w = 1;
			for (int x = 0; x < m; ++x) {
				for (ll s = x; s < n; s += m2) {
					long long u = a[s];
					long long d = (a[s + m] * _w) % mod;
					a[s] = (u + d) % mod;
					a[s + m] = (u - d + mod) % mod;
				}
				_w = (_w * _base) % mod;
			}
		}
	}

	void ntt(vector<long long>& input) { _ntt(input, 1); }

	void intt(vector<long long>& input) {
		_ntt(input, -1);
		const long long n_inv = mod_pow((ll)input.size(), mod - 2, mod);
		for (auto& x : input) x = (x * n_inv) % mod;
	}
public:
	// 畳み込み演算を行う
	vector<long long> convolution(const vector<long long>& a, const vector<long long>& b) {
		int result_size = a.size() + b.size() - 1;
		int n = 1; while (n < result_size) n <<= 1;

		vector<long long> _a = a, _b = b;
		_a.resize(n, 0);
		_b.resize(n, 0);

		ntt(_a);
		ntt(_b);
		for (int i = 0; i < n; ++i) _a[i] = (_a[i] * _b[i]) % mod;

		intt(_a);

		_a.resize(result_size);
		return _a;
	}
};

bool a[2 << 12][2 << 14];
int main() {
	ios::sync_with_stdio(false);
	std::cin.tie(0);
	std::cout.tie(0);

	constexpr ll mod = 998244353;

	ll n, m;
	cin >> n >> m;
	REP(i, n) {
		string s;
		cin >> s;
		REP(j, m / 4) {
			int tmp;
			if (s[j] <= '9' && s[j] >= '0')tmp = s[j] - '0';
			else tmp = s[j] - 'A' + 10;
			REP(k, 4) {
				if (tmp & (1 << k))a[i][4 * j + 3 - k] = 1;
			}
		}
	}
	int ans = 0;
	REP(i, n)REP(j, m) {
		if (a[i][j] == 0)continue;
		ans++;
		queue<pair<int, int>> que;
		que.push({ i,j });
		while (que.size()) {
			auto [x, y] = que.front();
			que.pop();
			a[x][y] = 0;
			if (x != 0 && a[x - 1][y] == 1)que.push({ x - 1,y });
			if (x != n - 1 && a[x + 1][y] == 1)que.push({ x + 1,y });
			if (y != 0 && a[x][y - 1] == 1)que.push({ x,y - 1 });
			if (y != m - 1 && a[x][y + 1] == 1)que.push({ x,y + 1 });
		}
	}
	cout << ans << "\n";

	return 0;
}


#include<iostream>
#include<vector>
#include<set>
#include<queue>
#include<map>
#include<algorithm>
#include<cstring>
#include<string>
#include<cassert>
#include<cmath>
#include<climits>
#include<iomanip>
#include<stack>
#include<unordered_map>
#include<bitset>
#include<limits>
#include<complex>
#include<array>
#include<numeric>
#include<functional>

using namespace std;
#define ll long long
#define ull unsigned long long
#define rrep(i,m,n) for(ll (i)=(ll)(m);(i)>=(ll)(n);(i)--)
#define rep(i,m,n) for(ll (i)=(ll)(m);i<(ll)(n);i++)
#define REP(i,n) rep(i,0,n)
#define FOR(i,c) for(decltype((c).begin())i=(c).begin();i!=(c).end();++i)
#define all(hoge) (hoge).begin(),(hoge).end()
typedef pair<ll, ll> P;
constexpr long double m_pi = 3.1415926535897932L;
constexpr ll MOD = 1000000007;
constexpr ll INF = 1LL << 62;
constexpr long double EPS = 1e-10;
template<typename T> using vector2 = vector<vector<T>>;
template<typename T> using vector3 = vector<vector2<T>>;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
string operator*(const string& s, int k) {
	if (k == 0) return "";
	string p = (s + s) * (k / 2);
	if (k % 2 == 1) p += s;
	return p;
}

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

struct Edge {//グラフ
	int to, rev; ll cap;
	Edge(int _to, ll _cap, int _rev) {
		to = _to; cap = _cap; rev = _rev;
	}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph& G, int from, int to, ll cap, bool revFlag, ll revCap) {//最大フロー求める Ford-fulkerson
	G[from].push_back(Edge(to, cap, (ll)G[to].size() + (from == to)));
	if (revFlag)G[to].push_back(Edge(from, revCap, (ll)G[from].size() - 1));//最小カットの場合逆辺は0にする
}

ll max_flow_dfs(Graph& G, ll v, ll t, ll f, vector<bool>& used)
{
	if (v == t)
		return f;
	used[v] = true;
	for (int i = 0; i < G[v].size(); ++i) {
		Edge& e = G[v][i];
		if (!used[e.to] && e.cap > 0) {
			ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
			if (d > 0) {
				e.cap -= d;
				G[e.to][e.rev].cap += d;
				return d;
			}
		}
	}
	return 0;
}
//二分グラフの最大マッチングを求めたりも出来る　また二部グラフの最大独立集合は頂点数-最大マッチングのサイズ
ll max_flow(Graph& G, ll s, ll t)//O(V(V+E))
{
	ll flow = 0;
	for (;;) {
		vector<bool> used(G.size());
		REP(i, used.size())used[i] = false;
		ll f = max_flow_dfs(G, s, t, INF, used);
		if (f == 0) {
			return flow;
		}
		flow += f;
	}
}

void BellmanFord(Graph& G, ll s, Array& d, Array& negative) {//O(|E||V|)
	d.resize(G.size());
	negative.resize(G.size());
	REP(i, d.size())d[i] = INF;
	REP(i, d.size())negative[i] = false;
	d[s] = 0;
	REP(k, G.size() - 1) {
		REP(i, G.size()) {
			REP(j, G[i].size()) {
				if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
					d[G[i][j].to] = d[i] + G[i][j].cap;
				}
			}
		}
	}
	REP(k, G.size() - 1) {
		REP(i, G.size()) {
			REP(j, G[i].size()) {
				if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
					d[G[i][j].to] = d[i] + G[i][j].cap;
					negative[G[i][j].to] = true;
				}
				if (negative[i] == true)negative[G[i][j].to] = true;
			}
		}
	}
}
void Dijkstra(Graph& G, ll s, Array& d) {//O(|E|log|V|)
	d.resize(G.size());
	REP(i, d.size())d[i] = INF;
	d[s] = 0;
	priority_queue<P, vector<P>, greater<P>> q;
	q.push(make_pair(0, s));
	while (!q.empty()) {
		P a = q.top();
		q.pop();
		if (d[a.second] < a.first)continue;
		REP(i, G[a.second].size()) {
			Edge e = G[a.second][i];
			if (d[e.to] > d[a.second] + e.cap) {
				d[e.to] = d[a.second] + e.cap;
				q.push(make_pair(d[e.to], e.to));
			}
		}
	}
}
void WarshallFloyd(Graph& G, Matrix& d) {//O(V^3)
	d.resize(G.size());
	REP(i, d.size())d[i].resize(G.size());
	REP(i, d.size()) {
		REP(j, d[i].size()) {
			d[i][j] = ((i != j) ? INF : 0);
		}
	}
	REP(i, G.size()) {
		REP(j, G[i].size()) {
			chmin(d[i][G[i][j].to], G[i][j].cap);
		}
	}
	REP(i, G.size()) {
		REP(j, G.size()) {
			REP(k, G.size()) {
				chmin(d[j][k], d[j][i] + d[i][k]);
			}
		}
	}
}
bool tsort(Graph& graph, Array& order) {//トポロジカルソートO(E+V)
	int n = graph.size(), k = 0;
	Array in(n);
	for (auto& es : graph)
		for (auto& e : es)in[e.to]++;
	priority_queue<ll, Array, greater<ll>> que;
	REP(i, n)
		if (in[i] == 0)que.push(i);
	while (que.size()) {
		int v = que.top();
		que.pop();
		order.push_back(v);
		for (auto& e : graph[v])
			if (--in[e.to] == 0)que.push(e.to);
	}
	if (order.size() != n)return false;
	else return true;
}
class Lca {
public:
	const int n = 0;
	const int log2_n = 0;
	std::vector<std::vector<int>> parent;
	std::vector<int> depth;

	Lca() {}

	Lca(const Graph& g, int root)
		: n(g.size()), log2_n(log2(n) + 1), parent(log2_n, std::vector<int>(n)), depth(n) {
		dfs(g, root, -1, 0);
		for (int k = 0; k + 1 < log2_n; k++) {
			for (int v = 0; v < (int)g.size(); v++) {
				if (parent[k][v] < 0)
					parent[k + 1][v] = -1;
				else
					parent[k + 1][v] = parent[k][parent[k][v]];
			}
		}
	}

	void dfs(const Graph& g, int v, int p, int d) {
		parent[0][v] = p;
		depth[v] = d;
		for (auto& e : g[v]) {
			if (e.to != p) dfs(g, e.to, v, d + 1);
		}
	}

	int get(int u, int v) {
		if (depth[u] > depth[v]) std::swap(u, v);
		for (int k = 0; k < log2_n; k++) {
			if ((depth[v] - depth[u]) >> k & 1) {
				v = parent[k][v];
			}
		}
		if (u == v) return u;
		for (int k = log2_n - 1; k >= 0; k--) {
			if (parent[k][u] != parent[k][v]) {
				u = parent[k][u];
				v = parent[k][v];
			}
		}
		return parent[0][u];
	}
};

class UnionFind {
	vector<int> data;
	ll _num;
public:
	UnionFind(int size) : data(size, -1), _num(size) { }
	bool merge(int x, int y) {//xとyの集合を統合する
		x = root(x); y = root(y);
		if (x != y) {
			if (data[y] < data[x]) swap(x, y);
			data[x] += data[y]; data[y] = x;
		}
		_num -= (x != y);
		return x != y;
	}
	bool same(int x, int y) {//xとyが同じ集合か返す
		return root(x) == root(y);
	}
	int root(int x) {//xのルートを返す
		return data[x] < 0 ? x : data[x] = root(data[x]);
	}
	ll size(int x) {//xの集合のサイズを返す
		return -data[root(x)];
	}
	ll num() {//集合の数を返す
		return _num;
	}
};

template<typename T, typename F>
class SegmentTree {
private:
	T identity;
	F merge;
	ll n;
	vector<T> dat;
public:
	SegmentTree(F f, T id, vector<T> v) :merge(f), identity(id) {
		int _n = v.size();
		n = 1;
		while (n < _n)n *= 2;
		dat.resize(2 * n - 1, identity);
		REP(i, _n)dat[n + i - 1] = v[i];
		for (int i = n - 2; i >= 0; i--)dat[i] = merge(dat[i * 2 + 1], dat[i * 2 + 2]);
	}
	SegmentTree(F f, T id, int _n) :merge(f), identity(id) {
		n = 1;
		while (n < _n)n *= 2;
		dat.resize(2 * n - 1, identity);
	}
	void set_val(int i, T x) {
		i += n - 1;
		dat[i] = x;
		while (i > 0) {
			i = (i - 1) / 2;
			dat[i] = merge(dat[i * 2 + 1], dat[i * 2 + 2]);
		}
	}
	T query(int l, int r) {
		T left = identity, right = identity;
		l += n - 1; r += n - 1;
		while (l < r) {
			if ((l & 1) == 0)left = merge(left, dat[l]);
			if ((r & 1) == 0)right = merge(dat[r - 1], right);
			l = l / 2;
			r = (r - 1) / 2;
		}
		return merge(left, right);
	}
};

template< typename T >
class FenwickTree {
	vector< T > data;
	int n;
	int p;
public:
	FenwickTree(int n) :n(n) {
		data.resize(n + 1LL, 0);
		p = 1;
		while (p < data.size())p *= 2;
	}
	T sum(int k) {
		T ret = 0;
		for (; k > 0; k -= k & -k) ret += data[k];
		return (ret);
	}

	T sum(int a, int b) { return sum(b) - sum(a); }//[a,b)

	void add(int k, T x) {
		for (++k; k <= n; k += k & -k) data[k] += x;
	}

	int lower_bound(ll w) {
		if (w <= 0)return -1;
		int x = 0;
		for (int k = p / 2; k > 0; k /= 2) {
			if (x + k <= n && data[x + k] < w)w -= data[x + k], x += k;
		}
		return x;
	}
};

//約数求める //約数
void divisor(ll n, vector<ll>& ret) {
	for (ll i = 1; i * i <= n; i++) {
		if (n % i == 0) {
			ret.push_back(i);
			if (i * i != n) ret.push_back(n / i);
		}
	}
	sort(ret.begin(), ret.end());
}

void prime_factorization(ll n, vector<P>& ret) {
	for (ll i = 2; i * i <= n; i++) {
		if (n % i == 0) {
			ret.push_back({ i,0 });
			while (n % i == 0) {
				n /= i;
				ret[ret.size() - 1].second++;
			}
		}
	}
	if (n != 1)ret.push_back({ n,1 });
}

inline ll mod_pow(ll x, ll n, ll mod) {
	ll res = 1;
	while (n > 0) {
		if (n & 1) res = res * x % mod;
		x = x * x % mod;
		n >>= 1;
	}
	return res;
}

inline ll mod_inv(ll x, ll mod) {
	return mod_pow(x, mod - 2, mod);
}

class Combination {
public:
	Array fact;
	Array fact_inv;
	ll mod;
	//if n >= mod use lucas
	ll nCr(ll n, ll r) {
		if (n < r)return 0;
		if (n < mod)return ((fact[n] * fact_inv[r] % mod) * fact_inv[n - r]) % mod;

		ll ret = 1;
		while (n || r) {
			ll _n = n % mod, _r = r % mod;
			n /= mod; r /= mod;
			(ret *= nCr(_n, _r)) %= mod;
		}
		return ret;
	}
	ll nPr(ll n, ll r) {
		return (fact[n] * fact_inv[n - r]) % mod;
	}
	ll nHr(ll n, ll r) {
		return nCr(r + n - 1, r);
	}
	Combination(ll _n, ll _mod) {
		mod = _mod;
		ll n = min(_n + 1, mod);
		fact.resize(n);
		fact[0] = 1;
		REP(i, n - 1) {
			fact[i + 1] = (fact[i] * (i + 1LL)) % mod;
		}
		fact_inv.resize(n);
		fact_inv[n - 1] = mod_inv(fact[n - 1], mod);
		for (int i = n - 1; i > 0; i--) {
			fact_inv[i - 1] = fact_inv[i] * i % mod;
		}
	}
};

ll popcount(ll x) {
	x = (x & 0x5555555555555555) + (x >> 1 & 0x5555555555555555);
	x = (x & 0x3333333333333333) + (x >> 2 & 0x3333333333333333);
	x = (x & 0x0F0F0F0F0F0F0F0F) + (x >> 4 & 0x0F0F0F0F0F0F0F0F);
	x = (x & 0x00FF00FF00FF00FF) + (x >> 8 & 0x00FF00FF00FF00FF);
	x = (x & 0x0000FFFF0000FFFF) + (x >> 16 & 0x0000FFFF0000FFFF);
	x = (x & 0x00000000FFFFFFFF) + (x >> 32 & 0x00000000FFFFFFFF);

	return x;
}

template<typename T, typename E, typename F, typename G, typename H, typename P>
class LazySegmentTree {
private:
	const T identity_t;
	const E identity_e;
	F f_tt;
	G f_te;
	H f_ee;
	P f_ep;//区間に比例する場合
	vector<T> dat;
	vector<E> lazy;
	int n;
	void eval(int k, int len) {
		if (lazy[k] == identity_e)return;
		if (k < n - 1) {
			lazy[2 * k + 1] = f_ee(lazy[2 * k + 1], lazy[k]);
			lazy[2 * k + 2] = f_ee(lazy[2 * k + 2], lazy[k]);
		}
		dat[k] = f_te(dat[k], f_ep(lazy[k], len));
		lazy[k] = identity_e;
	}
	void update(int a, int b, E x, int k, int l, int r) {
		eval(k, r - l);
		if (a <= l && r <= b) {
			lazy[k] = f_ee(lazy[k], x);
			eval(k, r - l);
		}
		else if (a < r && l < b) {
			update(a, b, x, k * 2 + 1, l, (l + r) / 2);
			update(a, b, x, k * 2 + 2, (l + r) / 2, r);
			dat[k] = f_tt(dat[2 * k + 1], dat[2 * k + 2]);
		}
	}
	T query(int a, int b, int k, int l, int r) {
		eval(k, r - l);
		if (r <= a || b <= l)return identity_t;
		else if (a <= l && r <= b)return dat[k];
		else {
			T vl = query(a, b, 2 * k + 1, l, (l + r) / 2);
			T vr = query(a, b, 2 * k + 2, (l + r) / 2, r);
			return f_tt(vl, vr);
		}
	}
public:
	LazySegmentTree(vector<T> v, T id_t, E id_e, F f, G g, H h, P p) :
		identity_t(id_t), identity_e(id_e), f_tt(f), f_te(g), f_ee(h), f_ep(p) {
		n = 1;
		while (n < v.size())n *= 2;
		dat.resize(2 * n - 1, identity_t);
		lazy.resize(2 * n - 1, identity_e);
		REP(i, v.size())dat[n + i - 1] = v[i];
		for (int i = n - 2; i >= 0; i--)dat[i] = f_tt(dat[i * 2 + 1], dat[i * 2 + 2]);

	}
	void update(int a, int b, E x) { update(a, b, x, 0, 0, n); }
	T query(int a, int b) { return query(a, b, 0, 0, n); }
};

Matrix mIdentity(ll n) {
	Matrix A(n, Array(n));
	for (int i = 0; i < n; ++i) A[i][i] = 1;
	return A;
}

Matrix mMul(const Matrix& A, const Matrix& B,ll M) {
	Matrix C(A.size(), Array(B[0].size()));
	for (int i = 0; i < C.size(); ++i)
		for (int k = 0; k < A[i].size(); ++k)
			for (int j = 0; j < C[i].size(); ++j)
				(C[i][j] += (A[i][k] % M) * (B[k][j] % M)) %= M;
	return C;
}
// O( n^3 log e )
Matrix mPow(const Matrix& A, ll e , ll M) {
	return e == 0 ? mIdentity(A.size()) :
		e % 2 == 0 ? mPow(mMul(A, A, M), e / 2, M) : mMul(A, mPow(A, e - 1, M), M);
}

template<ll mod, ll root>//特殊な素数と原始根　998244353のとき3
class NTT {
private:
	template<typename T>
	inline void bit_reverse(vector<T>& a) {
		int n = a.size();
		int i = 0;
		for (int j = 1; j < n - 1; ++j) {
			for (int k = n >> 1; k > (i ^= k); k >>= 1);
			if (j < i) swap(a[i], a[j]);
		}
	}
	void _ntt(vector<long long>& a, int sign) {
		const int n = a.size();
		assert((n ^ (n & -n)) == 0); //n = 2^k

		long long tmp = (mod - 1) * mod_pow((ll)n, mod - 2, mod) % mod; // -1/n
		long long h = mod_pow(root, tmp, mod); // ^n√g
		if (sign == -1) h = mod_pow(h, mod - 2, mod);

		bit_reverse(a);

		for (ll m = 1; m < n; m <<= 1) {
			const ll m2 = 2 * m;
			long long _base = mod_pow((ll)h, (ll)(n / m2), mod);
			long long _w = 1;
			for (int x = 0; x < m; ++x) {
				for (ll s = x; s < n; s += m2) {
					long long u = a[s];
					long long d = (a[s + m] * _w) % mod;
					a[s] = (u + d) % mod;
					a[s + m] = (u - d + mod) % mod;
				}
				_w = (_w * _base) % mod;
			}
		}
	}

	void ntt(vector<long long>& input) { _ntt(input, 1); }

	void intt(vector<long long>& input) {
		_ntt(input, -1);
		const long long n_inv = mod_pow((ll)input.size(), mod - 2, mod);
		for (auto& x : input) x = (x * n_inv) % mod;
	}
public:
	// 畳み込み演算を行う
	vector<long long> convolution(const vector<long long>& a, const vector<long long>& b) {
		int result_size = a.size() + b.size() - 1;
		int n = 1; while (n < result_size) n <<= 1;

		vector<long long> _a = a, _b = b;
		_a.resize(n, 0);
		_b.resize(n, 0);

		ntt(_a);
		ntt(_b);
		for (int i = 0; i < n; ++i) _a[i] = (_a[i] * _b[i]) % mod;

		intt(_a);

		_a.resize(result_size);
		return _a;
	}
};

class UnionFind2 {
public:
	vector<int> data;
	ll _num;
public:
	UnionFind2(int size) : data(size, -1), _num(size) { }
	bool merge(int x, int y) {//xとyの集合を統合する
		x = root(x); y = root(y);
		if (x != y) {
			if (x < y) swap(x, y);
			data[x] += data[y]; data[y] = x;
		}
		_num -= (x != y);
		return x != y;
	}
	bool same(int x, int y) {//xとyが同じ集合か返す
		return root(x) == root(y);
	}
	int root(int x) {//xのルートを返す
		return data[x] < 0 ? x : data[x] = root(data[x]);
	}
	ll size(int x) {//xの集合のサイズを返す
		return -data[root(x)];
	}
	ll num() {//集合の数を返す
		return _num;
	}
};

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

	constexpr ll mod = 998244353;

	ll n, m;
	cin >> n >> m;
	bitset<1 << 14> p;
	UnionFind2 uni(1 << 15);
	ll ans = 0;
	REP(i, n) {
		string s;
		bitset<1 << 14> v;
		cin >> s;
		REP(j, m / 4) {
			int tmp;
			if (s[j] <= '9' && s[j] >= '0')tmp = s[j] - '0';
			else tmp = s[j] - 'A' + 10;
			REP(k, 4) {
				if (tmp & (1 << k)) {
					ans++;
					v[4 * j + 3 - k] = 1;
				}
			}
		}
		REP(j, m - 1) {
			if (v[j] == 1 && v[j + 1] == 1)ans--, uni.merge((1 << 14) + j, (1 << 14) + j + 1);
		}
		REP(j, m) {
			if (v[j] == 1 && p[j] == 1 && uni.merge(j, (1 << 14) + j) == true)ans--;
		}
		p = v;
		REP(j, m) if (v[j] == 1)uni.data[j] = uni.data[j + (1 << 14)] - (1 << 14);
		REP(j, m)uni.data[j + (1 << 14)] = -1;
	}
	cout << ans << "\n";

	return 0;
}