actually I like these var names better

Author: lrvideckis

library/data_structures/uncommon/linear_rmq.hpp

@@ -24,8 +24,8 @@ template<class T, class F> struct linear_rmq {
       while (sz(st) > 1 &&
         (i == n || !cmp(a[st.back()], a[i]))) {
         head[prev] = st.back();
-        auto k = end(st)[-2] + 1u, b = bit_floor(k ^ i);
-        in[st.back()] = prev = i & -b, asc[k] |= b;
+        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);
@@ -34,12 +34,12 @@ template<class T, class F> struct linear_rmq {
       (asc[i] | asc[i - 1]) & -(in[i] & -in[i]);
   }
   int idx(int l, int r) { // [l, r]
-    if (unsigned i = in[l] ^ in[r]; i) {
-      i = asc[l] & asc[r] & -bit_floor(i);
-      if (unsigned b = asc[l] ^ i; b)
-        b = bit_floor(b), l = head[(in[l] & -b) | b];
-      if (unsigned b = asc[r] ^ i; b)
-        b = bit_floor(b), r = head[(in[r] & -b) | b];
+    if (unsigned j = in[l] ^ in[r]; j) {
+      j = asc[l] & asc[r] & -bit_floor(j);
+      if (unsigned k = asc[l] ^ j; k)
+        k = bit_floor(k), l = head[(in[l] & -k) | k];
+      if (unsigned k = asc[r] ^ j; k)
+        k = bit_floor(k), r = head[(in[r] & -k) | k];
     }
     return cmp(a[l], a[r]) ? l : r;
   }

library/trees/linear_kth_par.hpp

@@ -41,8 +41,8 @@ template<int KAPPA = 2> struct linear_kth_par {
   int kth_par(int v, int k) {
     assert(0 <= k && k <= d[v]);
     int anc_d = d[v] - k;
-    if (unsigned b = k / (KAPPA + 1); b)
-      b = bit_floor(b), v = jmp[(pos[v] & -b) | b];
+    if (unsigned j = k / (KAPPA + 1); j)
+      j = bit_floor(j), v = jmp[(pos[v] & -j) | j];
     return v = leaf[v], lad[v][d[v] - anc_d];
   }
 };

library/trees/linear_lca.hpp

@@ -28,12 +28,12 @@ struct linear_lca {
     for (auto [v, p] : order) asc[v] = asc[p] | lsb(in[v]);
   }
   int lca(int u, int v) {
-    if (unsigned i = in[u] ^ in[v]; i) {
-      i = asc[u] & asc[v] & -bit_floor(i);
-      if (unsigned b = asc[u] ^ i; b)
-        b = bit_floor(b), u = head[(in[u] & -b) | b];
-      if (unsigned b = asc[v] ^ i; b)
-        b = bit_floor(b), v = head[(in[v] & -b) | b];
+    if (unsigned j = in[u] ^ in[v]; j) {
+      j = asc[u] & asc[v] & -bit_floor(j);
+      if (unsigned k = asc[u] ^ j; k)
+        k = bit_floor(k), u = head[(in[u] & -k) | k];
+      if (unsigned k = asc[v] ^ j; k)
+        k = bit_floor(k), v = head[(in[v] & -k) | k];
     }
     return d[u] < d[v] ? u : v;
   }