Problem p02589 (C++)

Buggy submission (status: Runtime Error):
#include <bits/stdc++.h>
using namespace std;
/*
#if __has_include(<boost/multiprecision/cpp_int.hpp>)
        #include <boost/multiprecision/cpp_int.hpp>
        #include <boost/multiprecision/cpp_dec_float.hpp>
        using bll = boost::multiprecision::cpp_int;
        using bdouble =
boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>>; using
namespace boost::multiprecision; #endif
*/
#ifdef LOCAL_TEST
#define BOOST_STACKTRACE_USE_ADDR2LINE
#define BOOST_STACKTRACE_ADDR2LINE_LOCATION                                    \
  / usr / local / opt / binutils / bin / addr2line
#define _GNU_SOURCE 1
#include <boost/stacktrace.hpp>
namespace std {
template <typename T> class dvector : public std::vector<T> {
public:
  dvector() : std::vector<T>() {}
  explicit dvector(size_t n, const T &value = T()) : std::vector<T>(n, value) {}
  dvector(const std::vector<T> &v) : std::vector<T>(v) {}
  dvector(const std::initializer_list<T> il) : std::vector<T>(il) {}
  dvector(const std::string::iterator first, const std::string::iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::iterator first,
          const typename std::vector<T>::iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::reverse_iterator first,
          const typename std::vector<T>::reverse_iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::const_iterator first,
          const typename std::vector<T>::const_iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::const_reverse_iterator first,
          const typename std::vector<T>::const_reverse_iterator last)
      : std::vector<T>(first, last) {}
  T &operator[](size_t n) {
    try {
      return this->at(n);
    } catch (const std::exception &e) {
      std::cerr << boost::stacktrace::stacktrace() << '\n';
      return this->at(n);
    }
  }
  const T &operator[](size_t n) const {
    try {
      return this->at(n);
    } catch (const std::exception &e) {
      std::cerr << boost::stacktrace::stacktrace() << '\n';
      return this->at(n);
    }
  }
};
} // namespace std
class dbool {
private:
  bool boolvalue;

public:
  dbool() : boolvalue(false) {}
  dbool(bool b) : boolvalue(b) {}
  operator bool &() { return boolvalue; }
  operator const bool &() const { return boolvalue; }
};
#define vector dvector
#define bool dbool
class SIGFPE_exception : std::exception {};
class SIGSEGV_exception : std::exception {};
void catch_SIGFPE([[maybe_unused]] int e) {
  std::cerr << boost::stacktrace::stacktrace() << '\n';
  throw SIGFPE_exception();
}
void catch_SIGSEGV([[maybe_unused]] int e) {
  std::cerr << boost::stacktrace::stacktrace() << '\n';
  throw SIGSEGV_exception();
}
signed convertedmain();
signed main() {
  signal(SIGFPE, catch_SIGFPE);
  signal(SIGSEGV, catch_SIGSEGV);
  return convertedmain();
}
#define main() convertedmain()
#endif
#ifdef LOCAL_DEV
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::vector<T> &v) {
  for (size_t i = 0; i < v.size(); ++i) {
    s << v[i];
    if (i < v.size() - 1)
      s << "\t";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s,
                         const std::vector<std::vector<T>> &vv) {
  s << "\\\n";
  for (size_t i = 0; i < vv.size(); ++i) {
    s << vv[i] << "\n";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<T> &v) {
  for (size_t i = 0; i < v.size(); ++i) {
    s << v[i];
    if (i < v.size() - 1)
      s << "\t";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::set<T> &se) {
  s << "{ ";
  for (auto itr = se.begin(); itr != se.end(); ++itr) {
    s << (*itr) << "\t";
  }
  s << "}";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::multiset<T> &se) {
  s << "{ ";
  for (auto itr = se.begin(); itr != se.end(); ++itr) {
    s << (*itr) << "\t";
  }
  s << "}";
  return s;
}
template <typename T, size_t N>
std::ostream &operator<<(std::ostream &s, const std::array<T, N> &a) {
  s << "{ ";
  for (size_t i = 0; i < N; ++i) {
    s << a[i] << "\t";
  }
  s << "}";
  return s;
}
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &s, const std::map<T1, T2> &m) {
  s << "{\n";
  for (auto itr = m.begin(); itr != m.end(); ++itr) {
    s << "\t" << (*itr).first << " : " << (*itr).second << "\n";
  }
  s << "}";
  return s;
}
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &s, const std::pair<T1, T2> &p) {
  return s << "(" << p.first << ", " << p.second << ")";
}
void debug_impl() { std::cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_impl(Head head, Tail... tail) {
  std::cerr << " " << head << (sizeof...(tail) ? "," : "");
  debug_impl(tail...);
}
#define debug(...)                                                             \
  do {                                                                         \
    std::cerr << "(" << #__VA_ARGS__ << ") =";                                 \
    debug_impl(__VA_ARGS__);                                                   \
  } while (false)
#else
#define debug(...)                                                             \
  do {                                                                         \
  } while (false)
#endif
// #define int long long
using ll = long long;
// constexpr int INF = (ll)1e9 + 7;//INT_MAX=(1<<31)-1=2147483647
constexpr ll INF = (ll)1e18; //(1LL<<63)-1=9223372036854775807
constexpr ll MOD = (ll)1e9 + 7;
constexpr double EPS = 1e-9;
constexpr ll dx[4] = {1, 0, -1, 0};
constexpr ll dy[4] = {0, 1, 0, -1};
constexpr ll dx8[8] = {1, 0, -1, 0, 1, 1, -1, -1};
constexpr ll dy8[8] = {0, 1, 0, -1, 1, -1, 1, -1};
#define rep(i, n) for (ll i = 0, i##_length = (n); i < i##_length; ++i)
#define repeq(i, n) for (ll i = 1, i##_length = (n); i <= i##_length; ++i)
#define rrep(i, n) for (ll i = (n)-1; i >= 0; --i)
#define rrepeq(i, n) for (ll i = (n); i >= 1; --i)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
void p() { std::cout << '\n'; }
template <typename Head, typename... Tail> void p(Head head, Tail... tail) {
  std::cout << head << (sizeof...(tail) ? " " : "");
  p(tail...);
}
template <typename T> inline void pv(std::vector<T> &v) {
  for (ll i = 0, N = v.size(); i < N; i++)
    std::cout << v[i] << " \n"[i == N - 1];
}
template <typename T> inline bool chmax(T &a, T b) {
  return a < b && (a = b, true);
}
template <typename T> inline bool chmin(T &a, T b) {
  return a > b && (a = b, true);
}
template <typename T> inline void uniq(std::vector<T> &v) {
  v.erase(std::unique(v.begin(), v.end()), v.end());
}

/*-----8<-----template-----8<-----*/

template <ll char_size> class TrieNode {
public:
  ll nxt[char_size];

  ll exist;
  vector<ll> accept;

  TrieNode() : exist(0) { memset(nxt, -1, sizeof(nxt)); }
};

/*
あるノードの配下の全てのノードには自身に対応する文字列に共通するプレフィックスがあり,
ルートには空の文字列が対応している。

計算量：
　add O(|S|)
　query O(|S|)

exist は子供以下に追加された文字列の個数,
accept はそのノードにマッチする全ての追加された文字列の番号が格納される。

Trie< char_size, margin >():
　文字列の種類数 char_size, 開始文字が margin のトライ木を作成する。
add(S): 文字列 S をトライ木に追加する
query(S, f): 文字列 S のプレフィックスに一致する文字列を検索する。
　一致した文字列ごとに関数 f が呼び出される。
size(): ノード数を返す
count(): 存在する文字列の個数を返す
*/
template <ll char_size, ll margin> class Trie {
public:
  using Node = TrieNode<char_size>;

  vector<Node> nodes;
  ll root;

  Trie() : root(0) { nodes.push_back(Node()); }

  void update_direct(ll node, ll id) { nodes[node].accept.push_back(id); }

  void update_child(ll node, [[maybe_unused]] ll child,
                    [[maybe_unused]] ll id) {
    ++nodes[node].exist;
  }

  void add(const string &str, ll str_index, ll node_index, ll id) {
    if (str_index == (ll)str.size()) {
      update_direct(node_index, id);
    } else {
      const ll c = str[str_index] - margin;
      if (nodes[node_index].nxt[c] == -1) {
        nodes[node_index].nxt[c] = (ll)nodes.size();
        nodes.push_back(Node());
      }
      add(str, str_index + 1, nodes[node_index].nxt[c], id);
      update_child(node_index, nodes[node_index].nxt[c], id);
    }
  }

  void add(const string &str, ll id) { add(str, 0, 0, id); }

  void add(const string &str) { add(str, nodes[0].exist); }

  template <typename F>
  void query(const string &str, const F &f, ll str_index, ll node_index) {
    for (auto &idx : nodes[node_index].accept)
      f(idx);
    if (str_index == (ll)str.size()) {
      return;
    } else {
      const ll c = str[str_index] - margin;
      if (nodes[node_index].nxt[c] == -1)
        return;
      query(str, f, str_index + 1, nodes[node_index].nxt[c]);
    }
  }

  template <typename F> void query(const string &str, const F &f) {
    query(str, f, 0, 0);
  }

  ll count() const { return (nodes[0].exist); }

  size_t size() const { return nodes.size(); }
};

/*-----8<-----library-----8<-----*/

void solve() {

  ll N;
  cin >> N;
  vector<string> a(N);
  rep(i, N) {
    cin >> a[i];
    reverse(all(a[i]));
  }

  sort(a.begin(), a.end(),
       [](const string &x, const string &y) { return x.size() > y.size(); });

  vector<vector<ll>> pos(N, vector<ll>(26, -INF));
  rep(i, N) { rep(j, a[i].size()) chmax(pos[i][a[i][j] - 'a'], j); }

  Trie<26, 'a'> trie;
  rep(i, N) {
    if (a[i].size() == (size_t)1)
      continue;
    string t = a[i].substr(0, a[i].size() - 1);
    trie.add(t);
  }

  ll ans = 0;
  rep(i, N) {
    if (a[i].size() == (size_t)1)
      continue;
    // index = trie木に追加した単語のindex
    auto update = [&](ll index) {
      debug(i, index);
      if (index == i)
        return;
      ll x = a[index].back() - 'a';
      if (pos[i][x] >= (ll)(a[index].size()) - 1)
        ans++;
    };
    // Sのi文字目から一致する単語それぞれに対して関数 update が呼ばれる
    debug(a[i]);
    trie.query(a[i], update, 0, 0);
  }
  debug(ans);

  vector<ll> c(26, 0);
  rep(i, N) {
    if (a[i].size() != (size_t)1)
      continue;
    c[a[i][0] - 'a']++;
  }
  rep(i, N) {
    if (a[i].size() == (size_t)1)
      continue;
    vector<ll> t(26, false);
    rep(j, a[i].size()) t[a[i][j] - 'a'] = true;
    rep(j, 26) {
      if (t[j])
        ans += c[j];
    }
  }
  p(ans);
}

#define BEGIN_STACK_EXTEND                                                     \
  long long size = 2048 * 1024 * 1024;                                         \
  void *stack_extend_memory_ = malloc(size);                                   \
  void *stack_extend_origin_memory_;                                           \
  char *stack_extend_dummy_memory_ = (char *)alloca(                           \
      (1 + (int)(((long long)stack_extend_memory_) & 127)) * 16);              \
  *stack_extend_dummy_memory_ = 0;                                             \
  asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp"                            \
               : "=b"(stack_extend_origin_memory_)                             \
               : "a"((char *)stack_extend_memory_ + (size)-1024));
#define END_STACK_EXTEND                                                       \
  asm volatile("mov %%rax, %%rsp" ::"a"(stack_extend_origin_memory_));         \
  free(stack_extend_memory_);

signed main() {
  BEGIN_STACK_EXTEND
  std::cin.tie(0);
  ios::sync_with_stdio(false);
  // ll Q; cin >> Q; while(Q--)solve();
  solve();
  END_STACK_EXTEND
  return 0;
}


Fixed submission:
#include <bits/stdc++.h>
using namespace std;
/*
#if __has_include(<boost/multiprecision/cpp_int.hpp>)
        #include <boost/multiprecision/cpp_int.hpp>
        #include <boost/multiprecision/cpp_dec_float.hpp>
        using bll = boost::multiprecision::cpp_int;
        using bdouble =
boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>>; using
namespace boost::multiprecision; #endif
*/
#ifdef LOCAL_TEST
#define BOOST_STACKTRACE_USE_ADDR2LINE
#define BOOST_STACKTRACE_ADDR2LINE_LOCATION                                    \
  / usr / local / opt / binutils / bin / addr2line
#define _GNU_SOURCE 1
#include <boost/stacktrace.hpp>
namespace std {
template <typename T> class dvector : public std::vector<T> {
public:
  dvector() : std::vector<T>() {}
  explicit dvector(size_t n, const T &value = T()) : std::vector<T>(n, value) {}
  dvector(const std::vector<T> &v) : std::vector<T>(v) {}
  dvector(const std::initializer_list<T> il) : std::vector<T>(il) {}
  dvector(const std::string::iterator first, const std::string::iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::iterator first,
          const typename std::vector<T>::iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::reverse_iterator first,
          const typename std::vector<T>::reverse_iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::const_iterator first,
          const typename std::vector<T>::const_iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::const_reverse_iterator first,
          const typename std::vector<T>::const_reverse_iterator last)
      : std::vector<T>(first, last) {}
  T &operator[](size_t n) {
    try {
      return this->at(n);
    } catch (const std::exception &e) {
      std::cerr << boost::stacktrace::stacktrace() << '\n';
      return this->at(n);
    }
  }
  const T &operator[](size_t n) const {
    try {
      return this->at(n);
    } catch (const std::exception &e) {
      std::cerr << boost::stacktrace::stacktrace() << '\n';
      return this->at(n);
    }
  }
};
} // namespace std
class dbool {
private:
  bool boolvalue;

public:
  dbool() : boolvalue(false) {}
  dbool(bool b) : boolvalue(b) {}
  operator bool &() { return boolvalue; }
  operator const bool &() const { return boolvalue; }
};
#define vector dvector
#define bool dbool
class SIGFPE_exception : std::exception {};
class SIGSEGV_exception : std::exception {};
void catch_SIGFPE([[maybe_unused]] int e) {
  std::cerr << boost::stacktrace::stacktrace() << '\n';
  throw SIGFPE_exception();
}
void catch_SIGSEGV([[maybe_unused]] int e) {
  std::cerr << boost::stacktrace::stacktrace() << '\n';
  throw SIGSEGV_exception();
}
signed convertedmain();
signed main() {
  signal(SIGFPE, catch_SIGFPE);
  signal(SIGSEGV, catch_SIGSEGV);
  return convertedmain();
}
#define main() convertedmain()
#endif
#ifdef LOCAL_DEV
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::vector<T> &v) {
  for (size_t i = 0; i < v.size(); ++i) {
    s << v[i];
    if (i < v.size() - 1)
      s << "\t";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s,
                         const std::vector<std::vector<T>> &vv) {
  s << "\\\n";
  for (size_t i = 0; i < vv.size(); ++i) {
    s << vv[i] << "\n";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<T> &v) {
  for (size_t i = 0; i < v.size(); ++i) {
    s << v[i];
    if (i < v.size() - 1)
      s << "\t";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::set<T> &se) {
  s << "{ ";
  for (auto itr = se.begin(); itr != se.end(); ++itr) {
    s << (*itr) << "\t";
  }
  s << "}";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::multiset<T> &se) {
  s << "{ ";
  for (auto itr = se.begin(); itr != se.end(); ++itr) {
    s << (*itr) << "\t";
  }
  s << "}";
  return s;
}
template <typename T, size_t N>
std::ostream &operator<<(std::ostream &s, const std::array<T, N> &a) {
  s << "{ ";
  for (size_t i = 0; i < N; ++i) {
    s << a[i] << "\t";
  }
  s << "}";
  return s;
}
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &s, const std::map<T1, T2> &m) {
  s << "{\n";
  for (auto itr = m.begin(); itr != m.end(); ++itr) {
    s << "\t" << (*itr).first << " : " << (*itr).second << "\n";
  }
  s << "}";
  return s;
}
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &s, const std::pair<T1, T2> &p) {
  return s << "(" << p.first << ", " << p.second << ")";
}
void debug_impl() { std::cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_impl(Head head, Tail... tail) {
  std::cerr << " " << head << (sizeof...(tail) ? "," : "");
  debug_impl(tail...);
}
#define debug(...)                                                             \
  do {                                                                         \
    std::cerr << "(" << #__VA_ARGS__ << ") =";                                 \
    debug_impl(__VA_ARGS__);                                                   \
  } while (false)
#else
#define debug(...)                                                             \
  do {                                                                         \
  } while (false)
#endif
// #define int long long
using ll = long long;
// constexpr int INF = (ll)1e9 + 7;//INT_MAX=(1<<31)-1=2147483647
constexpr ll INF = (ll)1e18; //(1LL<<63)-1=9223372036854775807
constexpr ll MOD = (ll)1e9 + 7;
constexpr double EPS = 1e-9;
constexpr ll dx[4] = {1, 0, -1, 0};
constexpr ll dy[4] = {0, 1, 0, -1};
constexpr ll dx8[8] = {1, 0, -1, 0, 1, 1, -1, -1};
constexpr ll dy8[8] = {0, 1, 0, -1, 1, -1, 1, -1};
#define rep(i, n) for (ll i = 0, i##_length = (n); i < i##_length; ++i)
#define repeq(i, n) for (ll i = 1, i##_length = (n); i <= i##_length; ++i)
#define rrep(i, n) for (ll i = (n)-1; i >= 0; --i)
#define rrepeq(i, n) for (ll i = (n); i >= 1; --i)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
void p() { std::cout << '\n'; }
template <typename Head, typename... Tail> void p(Head head, Tail... tail) {
  std::cout << head << (sizeof...(tail) ? " " : "");
  p(tail...);
}
template <typename T> inline void pv(std::vector<T> &v) {
  for (ll i = 0, N = v.size(); i < N; i++)
    std::cout << v[i] << " \n"[i == N - 1];
}
template <typename T> inline bool chmax(T &a, T b) {
  return a < b && (a = b, true);
}
template <typename T> inline bool chmin(T &a, T b) {
  return a > b && (a = b, true);
}
template <typename T> inline void uniq(std::vector<T> &v) {
  v.erase(std::unique(v.begin(), v.end()), v.end());
}

/*-----8<-----template-----8<-----*/

template <ll char_size> class TrieNode {
public:
  ll nxt[char_size];

  ll exist;
  vector<ll> accept;

  TrieNode() : exist(0) { memset(nxt, -1, sizeof(nxt)); }
};

/*
あるノードの配下の全てのノードには自身に対応する文字列に共通するプレフィックスがあり,
ルートには空の文字列が対応している。

計算量：
　add O(|S|)
　query O(|S|)

exist は子供以下に追加された文字列の個数,
accept はそのノードにマッチする全ての追加された文字列の番号が格納される。

Trie< char_size, margin >():
　文字列の種類数 char_size, 開始文字が margin のトライ木を作成する。
add(S): 文字列 S をトライ木に追加する
query(S, f): 文字列 S のプレフィックスに一致する文字列を検索する。
　一致した文字列ごとに関数 f が呼び出される。
size(): ノード数を返す
count(): 存在する文字列の個数を返す
*/
template <ll char_size, ll margin> class Trie {
public:
  using Node = TrieNode<char_size>;

  vector<Node> nodes;
  ll root;

  Trie() : root(0) { nodes.push_back(Node()); }

  void update_direct(ll node, ll id) { nodes[node].accept.push_back(id); }

  void update_child(ll node, [[maybe_unused]] ll child,
                    [[maybe_unused]] ll id) {
    ++nodes[node].exist;
  }

  void add(const string &str, ll str_index, ll node_index, ll id) {
    if (str_index == (ll)str.size()) {
      update_direct(node_index, id);
    } else {
      const ll c = str[str_index] - margin;
      if (nodes[node_index].nxt[c] == -1) {
        nodes[node_index].nxt[c] = (ll)nodes.size();
        nodes.push_back(Node());
      }
      add(str, str_index + 1, nodes[node_index].nxt[c], id);
      update_child(node_index, nodes[node_index].nxt[c], id);
    }
  }

  void add(const string &str, ll id) { add(str, 0, 0, id); }

  void add(const string &str) { add(str, nodes[0].exist); }

  template <typename F>
  void query(const string &str, const F &f, ll str_index, ll node_index) {
    for (auto &idx : nodes[node_index].accept)
      f(idx);
    if (str_index == (ll)str.size()) {
      return;
    } else {
      const ll c = str[str_index] - margin;
      if (nodes[node_index].nxt[c] == -1)
        return;
      query(str, f, str_index + 1, nodes[node_index].nxt[c]);
    }
  }

  template <typename F> void query(const string &str, const F &f) {
    query(str, f, 0, 0);
  }

  ll count() const { return (nodes[0].exist); }

  size_t size() const { return nodes.size(); }
};

/*-----8<-----library-----8<-----*/

void solve() {

  ll N;
  cin >> N;
  vector<string> a(N);
  rep(i, N) {
    cin >> a[i];
    reverse(all(a[i]));
  }

  sort(a.begin(), a.end(),
       [](const string &x, const string &y) { return x.size() > y.size(); });

  vector<vector<ll>> pos(N, vector<ll>(26, -INF));
  rep(i, N) { rep(j, a[i].size()) chmax(pos[i][a[i][j] - 'a'], j); }

  Trie<26, 'a'> trie;
  rep(i, N) {
    if (a[i].size() == (size_t)1)
      continue;
    string t = a[i].substr(0, a[i].size() - 1);
    trie.add(t);
  }

  ll ans = 0;
  rep(i, N) {
    if (a[i].size() == (size_t)1)
      continue;
    // index = trie木に追加した単語のindex
    auto update = [&](ll index) {
      debug(i, index);
      if (index == i)
        return;
      ll x = a[index].back() - 'a';
      if (pos[i][x] >= (ll)(a[index].size()) - 1)
        ans++;
    };
    // Sのi文字目から一致する単語それぞれに対して関数 update が呼ばれる
    debug(a[i]);
    trie.query(a[i], update, 0, 0);
  }
  debug(ans);

  vector<ll> c(26, 0);
  rep(i, N) {
    if (a[i].size() != (size_t)1)
      continue;
    c[a[i][0] - 'a']++;
  }
  rep(i, N) {
    if (a[i].size() == (size_t)1)
      continue;
    vector<ll> t(26, false);
    rep(j, a[i].size()) t[a[i][j] - 'a'] = true;
    rep(j, 26) {
      if (t[j])
        ans += c[j];
    }
  }
  p(ans);
}

#define BEGIN_STACK_EXTEND                                                     \
  long long size = 1024LL * 1024LL * 1024LL * 2;                               \
  void *stack_extend_memory_ = malloc(size);                                   \
  void *stack_extend_origin_memory_;                                           \
  char *stack_extend_dummy_memory_ = (char *)alloca(                           \
      (1 + (int)(((long long)stack_extend_memory_) & 127)) * 16);              \
  *stack_extend_dummy_memory_ = 0;                                             \
  asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp"                            \
               : "=b"(stack_extend_origin_memory_)                             \
               : "a"((char *)stack_extend_memory_ + (size)-1024));
#define END_STACK_EXTEND                                                       \
  asm volatile("mov %%rax, %%rsp" ::"a"(stack_extend_origin_memory_));         \
  free(stack_extend_memory_);

signed main() {
  BEGIN_STACK_EXTEND
  std::cin.tie(0);
  ios::sync_with_stdio(false);
  // ll Q; cin >> Q; while(Q--)solve();
  solve();
  END_STACK_EXTEND
  return 0;
}