update format

Author: lrvideckis

library/data_structures_[l,r)/seg_tree_uncommon/find_first.hpp

@@ -42,8 +42,8 @@ int find_first_in_range(int l, int r, auto f, int tl,
   if (r <= tl || tr <= l) return r;
   if (l <= tl && tr <= r)
     return f(tree[v], tl, tr)
-      ? find_first_in_subtree(f, tl, tr, v)
-      : r;
+             ? find_first_in_subtree(f, tl, tr, v)
+             : r;
   int tm = split(tl, tr);
   push(tl, tm, tr, v);
   int res = find_first_in_range(l, r, f, tl, tm, 2 * v);

library/data_structures_[l,r)/seg_tree_uncommon/find_last.hpp

@@ -42,8 +42,8 @@ int find_last_in_range(int l, int r, auto f, int tl,
   if (r <= tl || tr <= l) return l - 1;
   if (l <= tl && tr <= r)
     return f(tree[v], tl, tr)
-      ? find_last_in_subtree(f, tl, tr, v)
-      : l - 1;
+             ? find_last_in_subtree(f, tl, tr, v)
+             : l - 1;
   int tm = split(tl, tr);
   push(tl, tm, tr, v);
   int res = find_last_in_range(l, r, f, tm, tr, 2 * v + 1);

library/data_structures_[l,r)/seg_tree_uncommon/kth_smallest_query.hpp

@@ -27,7 +27,7 @@ struct kth_smallest {
     if (tr - tl == 1) return tl;
     int tm = tl + (tr - tl) / 2;
     int left_count = pst.tree[pst.tree[vr].lch].sum -
-      pst.tree[pst.tree[vl].lch].sum;
+                     pst.tree[pst.tree[vl].lch].sum;
     if (left_count >= k)
       return query(k, tl, tm, pst.tree[vl].lch,
         pst.tree[vr].lch);

library/data_structures_[l,r)/seg_tree_uncommon/merge_sort_tree.hpp

@@ -21,9 +21,9 @@ struct merge_sort_tree {
     if (r <= tl || tr <= l) return 0;
     if (l <= tl && tr <= r)
       return ranges::lower_bound(tree[v], vr) -
-        ranges::lower_bound(tree[v], vl);
+             ranges::lower_bound(tree[v], vl);
     int tm = split(tl, tr);
     return query(l, r, vl, vr, tl, tm, 2 * v) +
-      query(l, r, vl, vr, tm, tr, 2 * v + 1);
+           query(l, r, vl, vr, tm, tr, 2 * v + 1);
   }
 };

library/data_structures_[l,r)/seg_tree_uncommon/persistent.hpp

@@ -47,6 +47,6 @@ struct PST {
     if (l <= tl && tr <= r) return tree[v].sum;
     int tm = tl + (tr - tl) / 2;
     return query(l, r, tl, tm, tree[v].lch) +
-      query(l, r, tm, tr, tree[v].rch);
+           query(l, r, tm, tr, tree[v].rch);
   }
 };

library/data_structures_[l,r)/uncommon/mode_query.hpp

@@ -53,15 +53,15 @@ struct mode_query {
     for (int i = l / b * b + b - 1; i >= l; i--) {
       int idx = index_into_index[i];
       if (idx + res.second < sz(index[a[i]]) &&
-        index[a[i]][idx + res.second] < r)
+          index[a[i]][idx + res.second] < r)
         res = {a[i], cnt[a[i]] + res.second};
       cnt[a[i]]--;
     }
     rep(i, (r - 1) / b * b, r) cnt[a[i]]++;
     rep(i, (r - 1) / b * b, r) {
       int idx = index_into_index[i];
       if (idx >= res.second &&
-        index[a[i]][idx - res.second] >= l)
+          index[a[i]][idx - res.second] >= l)
         res = {a[i], cnt[a[i]] + res.second};
       cnt[a[i]]--;
     }

library/data_structures_[l,r)/uncommon/permutation_tree.hpp

@@ -20,7 +20,7 @@ struct perm_tree {
   vector<vi> ch;
   bool touches(int u, int v) {
     return p[u].mn_num == p[v].mn_num + p[v].len ||
-      p[v].mn_num == p[u].mn_num + p[u].len;
+           p[v].mn_num == p[u].mn_num + p[u].len;
   }
   int allocate(int mn_i, int mn_v, int ln, bool join,
     const vi& chs) {

library/data_structures_[l,r]/linear_rmq.hpp

@@ -23,16 +23,16 @@ template<class T, class F> struct linear_rmq {
     rep(i, 0, n + 1) {
       int prev = 0;
       while (sz(st) > 1 &&
-        (i == n || !cmp(a[st.back()], a[i]))) {
+             (i == n || !cmp(a[st.back()], a[i]))) {
         head[prev] = st.back();
         auto j = end(st)[-2] + 1u, k = bit_floor(i ^ j);
         in[st.back()] = prev = i & -k, asc[j] |= k;
         st.pop_back();
       }
       st.push_back(head[prev] = i);
     }
-    rep(i, 1, n) asc[i] =
-      (asc[i] | asc[i - 1]) & -(in[i] & -in[i]);
+    rep(i, 1, n)
+      asc[i] = (asc[i] | asc[i - 1]) & -(in[i] & -in[i]);
   }
   int idx(int l, int r) {
     if (unsigned j = in[l] ^ in[r]) {

library/graphs/hopcroft_karp.hpp

@@ -47,7 +47,7 @@ struct hopcroft_karp {
         for (int v : g[u]) {
           int w = to_l[v];
           if (w == -1 ||
-            (level[u] + 1 == level[w] && dfs(dfs, w))) {
+              (level[u] + 1 == level[w] && dfs(dfs, w))) {
             to_r[u] = v;
             to_l[v] = u;
             return 1;
@@ -56,8 +56,8 @@ struct hopcroft_karp {
         level[u] = INT_MAX;
         return 0;
       };
-      rep(i, 0, lsz) m_sz +=
-        (to_r[i] == -1 && dfs(dfs, i));
+      rep(i, 0, lsz)
+        m_sz += (to_r[i] == -1 && dfs(dfs, i));
     }
   }
 };

library/math/count_paths/count_paths_rectangle.hpp

@@ -24,10 +24,10 @@ array<vl, 2> get_right_and_top(vl left, vl bottom) {
       rep(i, 0, sz(dp)) dp[i] =
         bottom[i] * t[sz(dp) - 1 - i].inv_fact % mod;
       vl tmp_res = conv(dp, tr);
-      rep(i, 0, sz(res)) res[i] =
-        (res[i] +
-          tmp_res[i + sz(bottom) - 1] * t[i].inv_fact) %
-        mod;
+      rep(i, 0, sz(res))
+        res[i] = (res[i] + tmp_res[i + sz(bottom) - 1] *
+                             t[i].inv_fact) %
+                 mod;
     }
     swap(left, bottom);
   }