Formatting rule changed

Author: hitonanode

README.md

@@ -37,5 +37,5 @@ Except such snippets, the programs written by the owner of the repo is under the
 Settings of `clang-format`:
 
 ```
-{ BasedOnStyle: LLVM, IndentWidth: 4, AccessModifierOffset: -4, AllowShortBlocksOnASingleLine: true, AllowShortCaseLabelsOnASingleLine: true, AllowShortFunctionsOnASingleLine: All, AllowShortIfStatementsOnASingleLine: true, AllowShortLoopsOnASingleLine: true, AlwaysBreakBeforeMultilineStrings: false, AlwaysBreakTemplateDeclarations: false, ColumnLimit: 120 }
+{ BasedOnStyle: LLVM, IndentWidth: 4, AccessModifierOffset: -4, AllowShortBlocksOnASingleLine: true, AllowShortCaseLabelsOnASingleLine: true, AllowShortFunctionsOnASingleLine: All, AllowShortIfStatementsOnASingleLine: true, AllowShortLoopsOnASingleLine: true, AlwaysBreakBeforeMultilineStrings: false, AlwaysBreakTemplateDeclarations: false, ColumnLimit: 110 }
 ```

tree/centroid_decomposition.hpp

@@ -6,7 +6,7 @@
 // CUT begin
 /*
 (Recursive) Centroid Decomposition
-Verification: Codeforces #190 Div.1 C <https://codeforces.com/contest/321/submission/59093583>
+Verification: Codeforces #190 Div.1 C https://codeforces.com/contest/321/submission/59093583
 
 fix_root(int r): Build information of the tree which `r` belongs to.
 detect_centroid(int r): Enumerate centroid(s) of the tree which `r` belongs to.

tree/eulertour.hpp

@@ -20,7 +20,8 @@ struct PreorderEulerTour {
         subtree_end[now] = vis_order.size();
     }
     PreorderEulerTour() = default;
-    PreorderEulerTour(const std::vector<std::vector<int>> &to, int root) : V(to.size()), root(root), edges(to) {
+    PreorderEulerTour(const std::vector<std::vector<int>> &to, int root)
+        : V(to.size()), root(root), edges(to) {
         assert(root >= 0 and root < V);
         subtree_begin.resize(V);
         subtree_end.resize(V);

tree/heavy_light_decomposition.hpp

@@ -9,23 +9,24 @@
 
 // CUT begin
 // Heavy-Light Decomposition of trees
-// Based on <http://beet-aizu.hatenablog.com/entry/2017/12/12/235950>
+// Based on http://beet-aizu.hatenablog.com/entry/2017/12/12/235950
 struct HeavyLightDecomposition {
     int V;
     int k;
     int nb_heavy_path;
     std::vector<std::vector<int>> e;
-    std::vector<int> par;                        // par[i] = parent of vertex i (Default: -1)
-    std::vector<int> depth;                      // depth[i] = distance between root and vertex i
-    std::vector<int> subtree_sz;                 // subtree_sz[i] = size of subtree whose root is i
-    std::vector<int> heavy_child;                // heavy_child[i] = child of vertex i on heavy path (Default: -1)
-    std::vector<int> tree_id;                    // tree_id[i] = id of tree vertex i belongs to
+    std::vector<int> par;         // par[i] = parent of vertex i (Default: -1)
+    std::vector<int> depth;       // depth[i] = distance between root and vertex i
+    std::vector<int> subtree_sz;  // subtree_sz[i] = size of subtree whose root is i
+    std::vector<int> heavy_child; // heavy_child[i] = child of vertex i on heavy path (Default: -1)
+    std::vector<int> tree_id;     // tree_id[i] = id of tree vertex i belongs to
     std::vector<int> aligned_id, aligned_id_inv; // aligned_id[i] =  aligned id for vertex i (consecutive on heavy edges)
-    std::vector<int> head;                       // head[i] = id of vertex on heavy path of vertex i, nearest to root
-    std::vector<int> head_ids;                   // consist of head vertex id's
-    std::vector<int> heavy_path_id;              // heavy_path_id[i] = heavy_path_id for vertex [i]
+    std::vector<int> head;          // head[i] = id of vertex on heavy path of vertex i, nearest to root
+    std::vector<int> head_ids;      // consist of head vertex id's
+    std::vector<int> heavy_path_id; // heavy_path_id[i] = heavy_path_id for vertex [i]
 
-    HeavyLightDecomposition(int sz = 0) : V(sz), k(0), nb_heavy_path(0), e(sz), par(sz), depth(sz), subtree_sz(sz), heavy_child(sz), tree_id(sz, -1), aligned_id(sz), aligned_id_inv(sz), head(sz), heavy_path_id(sz, -1) {}
+    HeavyLightDecomposition(int sz = 0)
+        : V(sz), k(0), nb_heavy_path(0), e(sz), par(sz), depth(sz), subtree_sz(sz), heavy_child(sz), tree_id(sz, -1), aligned_id(sz), aligned_id_inv(sz), head(sz), heavy_path_id(sz, -1) {}
     void add_edge(int u, int v) {
         e[u].emplace_back(v);
         e[v].emplace_back(u);

tree/tree_isomorphism.hpp

@@ -9,9 +9,9 @@ using namespace std;
 // CUT begin
 // Tree isomorphism with hashing （ハッシュによる木の同型判定）
 // Dependence: ModInt or ModIntRuntime
-// Reference: <https://snuke.hatenablog.com/entry/2017/02/03/054210>
-// Verified: <https://atcoder.jp/contests/nikkei2019-2-final/submissions/9044698> (ModInt)
-//           <https://atcoder.jp/contests/nikkei2019-2-final/submissions/9044745> (ModIntRuntime)
+// Reference: https://snuke.hatenablog.com/entry/2017/02/03/054210
+// Verified: https://atcoder.jp/contests/nikkei2019-2-final/submissions/9044698 (ModInt)
+//           https://atcoder.jp/contests/nikkei2019-2-final/submissions/9044745 (ModIntRuntime)
 using mint = ModInt<1000000007>;
 // using mint = ModIntRuntime;
 // int ModIntRuntime::mod = 1000000007;
@@ -27,7 +27,7 @@ struct UndirectedTree {
     }
 
     static uint64_t splitmix64(uint64_t x) {
-        // <https://codeforces.com/blog/entry/62393> <http://xorshift.di.unimi.it/splitmix64.c>
+        // https://codeforces.com/blog/entry/62393 http://xorshift.di.unimi.it/splitmix64.c
         x += 0x9e3779b97f4a7c15;
         x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
         x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
@@ -39,7 +39,9 @@ struct UndirectedTree {
     }
 
     static void add_hash(DoubleHash &l, const DoubleHash &r) { l.first += r.first, l.second += r.second; }
-    static DoubleHash subtract_hash(const DoubleHash &l, const DoubleHash &r) { return {l.first - r.first, l.second - r.second}; }
+    static DoubleHash subtract_hash(const DoubleHash &l, const DoubleHash &r) {
+        return {l.first - r.first, l.second - r.second};
+    }
 
     vector<DoubleHash> hash;         // hash of the tree, each node regarded as root
     vector<DoubleHash> hash_subtree; // hash of the subtree