#include <bits/stdc++.h>
using namespace std;
const int NMAX = 100000 + 10;
int n = 0;
int idx = 0;
map<string, int> hosts;
vector<string> hosts_id;
vector<set<string>> paths;
vector<vector<long long>> hash_paths;
vector<long long> hash_paths_sum;
map<pair<int, long long>, vector<int>> cnt_path_partition;
vector<vector<int>> groups;
vector<vector<int>> groups_ans;
long long str_hash(string s) {
  long long p = 97;
  long long hash = 0, p_pow = 1;
  for (size_t i = 0; i < s.length(); ++i) {
    hash += (s[i] - '/' + 1) * p_pow;
    p_pow *= p;
  }
  return hash;
}
int main() {
  scanf("%d", &n);
  for (int i = 0; i < n; ++i) {
    string s;
    cin >> s;
    int sl = s.find("/", 7);
    string host = s.substr(0, sl);
    string path = "";
    if (sl != -1) {
      path = s.substr(sl + 1);
    }
    if (sl == s.size() - 1) {
      path = "/";
    }
    if (hosts.count(host) == 0) {
      hosts[host] = idx++;
      hosts_id.push_back(host);
      set<string> curset;
      paths.push_back(curset);
      vector<long long> tmp;
      hash_paths.push_back(tmp);
      hash_paths_sum.push_back(0);
    }
    paths[hosts[host]].insert(path);
  }
  for (map<string, int>::iterator it = hosts.begin(); it != hosts.end(); ++it) {
    for (set<string>::iterator path = paths[it->second].begin();
         path != paths[it->second].end(); ++path) {
      long long cur_hash = str_hash(*path);
      hash_paths[it->second].push_back(cur_hash);
      hash_paths_sum[it->second] += cur_hash;
    }
  }
  for (map<string, int>::iterator it = hosts.begin(); it != hosts.end(); ++it) {
    cnt_path_partition[make_pair(hash_paths[it->second].size(),
                                 hash_paths_sum[it->second])]
        .push_back(it->second);
  }
  for (map<pair<int, long long>, vector<int>>::iterator it =
           cnt_path_partition.begin();
       it != cnt_path_partition.end(); ++it) {
    for (int i = 0; i < it->second.size(); ++i) {
      int curhost = it->second[i];
      if (groups.empty()) {
        vector<int> gr;
        gr.push_back(curhost);
        groups.push_back(gr);
      } else {
        bool ishost = false;
        for (int g = 0; g < groups.size(); ++g) {
          if (paths[groups[g][0]] == paths[curhost]) {
            groups[g].push_back(curhost);
            ishost = true;
            break;
          }
        }
        if (!ishost) {
          vector<int> gr;
          gr.push_back(curhost);
          groups.push_back(gr);
        }
      }
    }
    for (int i = 0; i < groups.size(); ++i) {
      if (groups[i].size() > 1) {
        groups_ans.push_back(groups[i]);
      }
    }
    groups.clear();
  }
  cout << groups_ans.size() << endl;
  for (int i = 0; i < groups_ans.size(); ++i) {
    for (int j = 0; j < groups_ans[i].size(); ++j) {
      cout << hosts_id[groups_ans[i][j]] << " ";
    }
    cout << endl;
  }
  return 0;
}
