5 files changed, 203 insertions, 180 deletions

diff --git a/src/constants.h b/src/constants.h
index 00061bd..1a5453c 100644
--- a/src/constants.h
+++ b/src/constants.h
@@ -1,9 +1,13 @@
-#define _2p11  2048U
-#define _2p12  4096U
-#define _3p7   2187U
-#define _3p8   6561U
-#define _12c4  495U
-#define _8c4   70U
+#define _bit_u8(i)  (UINT8_C(1) << (uint8_t)(i))
+#define _bit_u32(i) (UINT32_C(1) << (uint32_t)(i))
+#define _bit_u64(i) (UINT64_C(1) << (uint64_t)(i))
+
+#define _2p11  INT64_C(2048)
+#define _2p12  INT64_C(4096)
+#define _3p7   INT64_C(2187)
+#define _3p8   INT64_C(6561)
+#define _12c4  INT64_C(495)
+#define _8c4   INT64_C(70)
 
 _static int64_t binomial[12][12] = {
         {1,  0,  0,   0,   0,   0,   0,   0,   0,  0,  0, 0},
@@ -20,111 +24,111 @@ _static int64_t binomial[12][12] = {
         {1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1},
 };
 
-#define _move_U  0U
-#define _move_U2 1U
-#define _move_U3 2U
-#define _move_D  3U
-#define _move_D2 4U
-#define _move_D3 5U
-#define _move_R  6U
-#define _move_R2 7U
-#define _move_R3 8U
-#define _move_L  9U
-#define _move_L2 10U
-#define _move_L3 11U
-#define _move_F  12U
-#define _move_F2 13U
-#define _move_F3 14U
-#define _move_B  15U
-#define _move_B2 16U
-#define _move_B3 17U
+#define _move_U  UINT8_C(0)
+#define _move_U2 UINT8_C(1)
+#define _move_U3 UINT8_C(2)
+#define _move_D  UINT8_C(3)
+#define _move_D2 UINT8_C(4)
+#define _move_D3 UINT8_C(5)
+#define _move_R  UINT8_C(6)
+#define _move_R2 UINT8_C(7)
+#define _move_R3 UINT8_C(8)
+#define _move_L  UINT8_C(9)
+#define _move_L2 UINT8_C(10)
+#define _move_L3 UINT8_C(11)
+#define _move_F  UINT8_C(12)
+#define _move_F2 UINT8_C(13)
+#define _move_F3 UINT8_C(14)
+#define _move_B  UINT8_C(15)
+#define _move_B2 UINT8_C(16)
+#define _move_B3 UINT8_C(17)
 
-#define _trans_UFr 0
-#define _trans_ULr 1
-#define _trans_UBr 2
-#define _trans_URr 3
-#define _trans_DFr 4
-#define _trans_DLr 5
-#define _trans_DBr 6
-#define _trans_DRr 7
-#define _trans_RUr 8
-#define _trans_RFr 9
-#define _trans_RDr 10
-#define _trans_RBr 11
-#define _trans_LUr 12
-#define _trans_LFr 13
-#define _trans_LDr 14
-#define _trans_LBr 15
-#define _trans_FUr 16
-#define _trans_FRr 17
-#define _trans_FDr 18
-#define _trans_FLr 19
-#define _trans_BUr 20
-#define _trans_BRr 21
-#define _trans_BDr 22
-#define _trans_BLr 23
+#define _trans_UFr UINT8_C(0)
+#define _trans_ULr UINT8_C(1)
+#define _trans_UBr UINT8_C(2)
+#define _trans_URr UINT8_C(3)
+#define _trans_DFr UINT8_C(4)
+#define _trans_DLr UINT8_C(5)
+#define _trans_DBr UINT8_C(6)
+#define _trans_DRr UINT8_C(7)
+#define _trans_RUr UINT8_C(8)
+#define _trans_RFr UINT8_C(9)
+#define _trans_RDr UINT8_C(10)
+#define _trans_RBr UINT8_C(11)
+#define _trans_LUr UINT8_C(12)
+#define _trans_LFr UINT8_C(13)
+#define _trans_LDr UINT8_C(14)
+#define _trans_LBr UINT8_C(15)
+#define _trans_FUr UINT8_C(16)
+#define _trans_FRr UINT8_C(17)
+#define _trans_FDr UINT8_C(18)
+#define _trans_FLr UINT8_C(19)
+#define _trans_BUr UINT8_C(20)
+#define _trans_BRr UINT8_C(21)
+#define _trans_BDr UINT8_C(22)
+#define _trans_BLr UINT8_C(23)
 
-#define _trans_UFm 24
-#define _trans_ULm 25
-#define _trans_UBm 26
-#define _trans_URm 27
-#define _trans_DFm 28
-#define _trans_DLm 29
-#define _trans_DBm 30
-#define _trans_DRm 31
-#define _trans_RUm 32
-#define _trans_RFm 33
-#define _trans_RDm 34
-#define _trans_RBm 35
-#define _trans_LUm 36
-#define _trans_LFm 37
-#define _trans_LDm 38
-#define _trans_LBm 39
-#define _trans_FUm 40
-#define _trans_FRm 41
-#define _trans_FDm 42
-#define _trans_FLm 43
-#define _trans_BUm 44
-#define _trans_BRm 45
-#define _trans_BDm 46
-#define _trans_BLm 47
+#define _trans_UFm UINT8_C(24)
+#define _trans_ULm UINT8_C(25)
+#define _trans_UBm UINT8_C(26)
+#define _trans_URm UINT8_C(27)
+#define _trans_DFm UINT8_C(28)
+#define _trans_DLm UINT8_C(29)
+#define _trans_DBm UINT8_C(30)
+#define _trans_DRm UINT8_C(31)
+#define _trans_RUm UINT8_C(32)
+#define _trans_RFm UINT8_C(33)
+#define _trans_RDm UINT8_C(34)
+#define _trans_RBm UINT8_C(35)
+#define _trans_LUm UINT8_C(36)
+#define _trans_LFm UINT8_C(37)
+#define _trans_LDm UINT8_C(38)
+#define _trans_LBm UINT8_C(39)
+#define _trans_FUm UINT8_C(40)
+#define _trans_FRm UINT8_C(41)
+#define _trans_FDm UINT8_C(42)
+#define _trans_FLm UINT8_C(43)
+#define _trans_BUm UINT8_C(44)
+#define _trans_BRm UINT8_C(45)
+#define _trans_BDm UINT8_C(46)
+#define _trans_BLm UINT8_C(47)
 
-#define _c_ufr      0U
-#define _c_ubl      1U
-#define _c_dfl      2U
-#define _c_dbr      3U
-#define _c_ufl      4U
-#define _c_ubr      5U
-#define _c_dfr      6U
-#define _c_dbl      7U
+#define _c_ufr      UINT8_C(0)
+#define _c_ubl      UINT8_C(1)
+#define _c_dfl      UINT8_C(2)
+#define _c_dbr      UINT8_C(3)
+#define _c_ufl      UINT8_C(4)
+#define _c_ubr      UINT8_C(5)
+#define _c_dfr      UINT8_C(6)
+#define _c_dbl      UINT8_C(7)
 
-#define _e_uf       0U
-#define _e_ub       1U
-#define _e_db       2U
-#define _e_df       3U
-#define _e_ur       4U
-#define _e_ul       5U
-#define _e_dl       6U
-#define _e_dr       7U
-#define _e_fr       8U
-#define _e_fl       9U
-#define _e_bl       10U
-#define _e_br       11U
+#define _e_uf       UINT8_C(0)
+#define _e_ub       UINT8_C(1)
+#define _e_db       UINT8_C(2)
+#define _e_df       UINT8_C(3)
+#define _e_ur       UINT8_C(4)
+#define _e_ul       UINT8_C(5)
+#define _e_dl       UINT8_C(6)
+#define _e_dr       UINT8_C(7)
+#define _e_fr       UINT8_C(8)
+#define _e_fl       UINT8_C(9)
+#define _e_bl       UINT8_C(10)
+#define _e_br       UINT8_C(11)
 
-#define _eoshift    4U
-#define _coshift    5U
+#define _eoshift    UINT8_C(4)
+#define _coshift    UINT8_C(5)
 
-#define _pbits      0xFU
-#define _esepbit1   0x4U
-#define _esepbit2   0x8U
-#define _csepbit    0x4U
-#define _eobit      0x10U
-#define _cobits     0xF0U
-#define _cobits2    0x60U
-#define _ctwist_cw  0x20U
-#define _ctwist_ccw 0x40U
-#define _eflip      0x10U
-#define _error      0xFFU
+#define _pbits      UINT8_C(0xF)
+#define _esepbit1   UINT8_C(0x4)
+#define _esepbit2   UINT8_C(0x8)
+#define _csepbit    UINT8_C(0x4)
+#define _eobit      UINT8_C(0x10)
+#define _cobits     UINT8_C(0xF0)
+#define _cobits2    UINT8_C(0x60)
+#define _ctwist_cw  UINT8_C(0x20)
+#define _ctwist_ccw UINT8_C(0x40)
+#define _eflip      UINT8_C(0x10)
+#define _error      UINT8_C(0xFF)
 
 _static cube_t zero = { .corner = {0}, .edge = {0} };
 _static cube_t solved = {
diff --git a/src/cube_avx2.h b/src/cube_avx2.h
index ad4aadb..233afed 100644
--- a/src/cube_avx2.h
+++ b/src/cube_avx2.h
@@ -1,10 +1,12 @@
 typedef __m256i cube_fast_t;
 
-#define _co2_avx2 _mm256_set_epi64x(0, 0, 0, 0x6060606060606060)
-#define _cocw_avx2 _mm256_set_epi64x(0, 0, 0, 0x2020202020202020)
-#define _cp_avx2 _mm256_set_epi64x(0, 0, 0, 0x0707070707070707)
-#define _ep_avx2 _mm256_set_epi64x(0x0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0, 0)
-#define _eo_avx2 _mm256_set_epi64x(0x10101010, 0x1010101010101010, 0, 0)
+#define _co2_avx2 _mm256_set_epi64x(0, 0, 0, INT64_C(0x6060606060606060))
+#define _cocw_avx2 _mm256_set_epi64x(0, 0, 0, INT64_C(0x2020202020202020))
+#define _cp_avx2 _mm256_set_epi64x(0, 0, 0, INT64_C(0x0707070707070707))
+#define _ep_avx2 \
+    _mm256_set_epi64x(INT64_C(0x0F0F0F0F), INT64_C(0x0F0F0F0F0F0F0F0F), 0, 0)
+#define _eo_avx2 \
+    _mm256_set_epi64x(INT64_C(0x10101010), INT64_C(0x1010101010101010), 0, 0)
 
 _static_inline cube_fast_t fastcube(
     uint8_t, uint8_t, uint8_t, uint8_t, uint8_t,
@@ -194,9 +196,9 @@ coord_fast_co(cube_fast_t c)
         co = _mm256_and_si256(c, _co2_avx2);
         _mm256_storeu_si256((__m256i *)mem, co);
 
-        mem[0] >>= 5L;
-        for (i = 0, ret = 0, p = 1; i < 7; i++, mem[0] >>= 8L, p *= 3)
-                ret += (mem[0] & 3L) * p;
+        mem[0] >>= 5;
+        for (i = 0, ret = 0, p = 1; i < 7; i++, mem[0] >>= 8, p *= 3)
+                ret += (mem[0] & 3) * p;
 
         return ret;
 }
@@ -242,14 +244,14 @@ coord_fast_esep(cube_fast_t c)
         ep = _mm256_and_si256(c, _ep_avx2);
         _mm256_storeu_si256((__m256i *)mem, ep);
 
-        mem[3] <<= 8L;
+        mem[3] <<= 8;
         ret1 = ret2 = 0;
         k = l = 4;
-        for (i = 0, j = 0; i < 12; i++, mem[i/8 + 2] >>= 8L) {
+        for (i = 0, j = 0; i < 12; i++, mem[i/8 + 2] >>= 8) {
                 e = mem[i/8 + 2];
 
-                bit1 = (e & _esepbit1) >> 2L;
-                bit2 = (e & _esepbit2) >> 3L;
+                bit1 = (e & _esepbit1) >> 2;
+                bit2 = (e & _esepbit2) >> 3;
                 is1 = (1 - bit2) * bit1;
 
                 ret1 += bit2 * binomial[11-i][k];
@@ -305,8 +307,8 @@ _static_inline cube_fast_t
 invcoord_fast_esep(int64_t esep)
 {
         cube_fast_t eee, ret;
-        int64_t i, j, jj, k, l, s, v, w, is1, set1, set2;
-        uint8_t bit2, bit1, mem[32];
+        int64_t bit1, bit2, i, j, jj, k, l, s, v, w, is1, set1, set2;
+        uint8_t mem[32];
         uint8_t slice[3] = {0};
 
         set1 = esep % 70;
@@ -327,7 +329,7 @@ invcoord_fast_esep(int64_t esep)
                 j += (1-bit2);
                 s = 2*bit2 + (1-bit2)*bit1;
 
-                mem[i+16] = (slice[s]++) | (s << 2);
+                mem[i+16] = (slice[s]++) | (uint8_t)(s << 2);
         }
 
         ret = cubetofast(solved);
diff --git a/src/cube_portable.h b/src/cube_portable.h
index d62661a..2999d8a 100644
--- a/src/cube_portable.h
+++ b/src/cube_portable.h
@@ -143,7 +143,7 @@ compose_corners_inplace(cube_fast_t c1, cube_fast_t c2, cube_fast_t *ret)
                 p = piece2 & _pbits;
                 piece1 = c1.corner[p];
                 aux = (piece2 & _cobits) + (piece1 & _cobits);
-                auy = (aux + _ctwist_cw) >> 2U;
+                auy = (aux + _ctwist_cw) >> 2;
                 orien = (aux + auy) & _cobits2;
                 ret->corner[i] = (piece1 & _pbits) | orien;
         }
@@ -206,7 +206,7 @@ coord_fast_csep(cube_fast_t c)
         int64_t ret;
 
         for (ret = 0, i = 0, p = 1; i < 7; i++, p *= 2)
-                ret += p * ((c.corner[i] & _csepbit) >> 2U);
+                ret += p * ((c.corner[i] & _csepbit) >> 2);
 
         return ret;
 }
@@ -249,8 +249,8 @@ coord_fast_esep(cube_fast_t c)
                 }
                 */
 
-                bit1 = (c.edge[i] & _esepbit1) >> 2U;
-                bit2 = (c.edge[i] & _esepbit2) >> 3U;
+                bit1 = (c.edge[i] & _esepbit1) >> 2;
+                bit2 = (c.edge[i] & _esepbit2) >> 3;
                 is1 = (1 - bit2) * bit1;
 
                 ret1 += bit2 * binomial[11-i][k];
@@ -280,22 +280,21 @@ copy_edges_fast(cube_fast_t *dest, cube_fast_t src)
 _static_inline void
 set_eo_fast(cube_fast_t *cube, int64_t eo)
 {
-        int i, sum, flip;
+        uint8_t i, sum, flip;
 
         for (sum = 0, i = 1; i < 12; i++, eo >>= 1) {
                 flip = eo % 2;
                 sum += flip;
                 cube->edge[i] = (cube->edge[i] & ~_eobit) | (_eobit * flip);
         }
-        cube->edge[0] = (cube->edge[0] & ~_eobit) | (_eobit * (sum%2));
+        cube->edge[0] = (cube->edge[0] & ~_eobit) | (_eobit * (sum % 2));
 }
 
 _static_inline cube_fast_t
 invcoord_fast_esep(int64_t esep)
 {
         cube_fast_t ret;
-        int64_t i, j, jj, k, l, s, v, w, is1, set1, set2;
-        uint8_t bit2, bit1;
+        int64_t bit1, bit2, i, j, jj, k, l, s, v, w, is1, set1, set2;
         uint8_t slice[3] = {0};
 
         ret = cubetofast(solved);
@@ -317,7 +316,7 @@ invcoord_fast_esep(int64_t esep)
                 j += (1-bit2);
                 s = 2*bit2 + (1-bit2)*bit1;
 
-                ret.edge[i] = (slice[s]++) | (s << 2);
+                ret.edge[i] = (slice[s]++) | (uint8_t)(s << 2);
         }
 
         return ret;
diff --git a/src/cube_routines.h b/src/cube_routines.h
index 1585e67..fb19355 100644
--- a/src/cube_routines.h
+++ b/src/cube_routines.h
@@ -422,8 +422,9 @@ _static int
 writepiece_LST(uint8_t piece, char *buf)
 {
         char digits[3];
-        int i, len = 0;
+        int i, len;
 
+        len = 0;
         while (piece != 0) {
                 digits[len++] = (piece % 10) + '0';
                 piece /= 10;
@@ -473,7 +474,8 @@ writecube_H48(cube_t cube, char *buf)
 _static void
 writecube_LST(cube_t cube, char *buf)
 {
-        int i, ptr;
+        int i;
+        size_t ptr;
         uint8_t piece;
 
         ptr = 0;
diff --git a/src/solve_h48.h b/src/solve_h48.h
index ecb0863..abf7a86 100644
--- a/src/solve_h48.h
+++ b/src/solve_h48.h
@@ -1,18 +1,23 @@
-#define COCSEP_CLASSES        3393U
-#define COCSEP_TABLESIZE      (_3p7 << 7ULL)
-#define COCSEP_VISITEDSIZE    ((COCSEP_TABLESIZE + 7ULL) / 8ULL)
-#define COCSEP_FULLSIZE       (4*(COCSEP_TABLESIZE + 12))
+#define COCSEP_CLASSES        ((size_t)3393)
+#define COCSEP_TABLESIZE      ((size_t)_3p7 << (size_t)7)
+#define COCSEP_VISITEDSIZE    ((COCSEP_TABLESIZE + (size_t)7) / (size_t)8)
+#define COCSEP_FULLSIZE       ((size_t)4 * (COCSEP_TABLESIZE + (size_t)12))
 
-#define ESEP_MAX(h)           ((COCSEP_CLASSES * _12c4 * _8c4) << (h))
-#define ESEP_TABLESIZE(h, k)  (ESEP_MAX((h)) / (8U / (k)))
+#define ESEP_NOEO             (COCSEP_CLASSES * (size_t)_12c4 * (size_t)_8c4)
+#define ESEP_MAX(h)           (ESEP_NOEO << (size_t)(h))
+#define ESEP_TABLESIZE(h, k)  (ESEP_MAX((h)) / ((size_t)8 / (size_t)(k)))
 
-#define H48_ESIZE(h)          ((_12c4 * _8c4) << (h))
+#define COCLASS_MASK          (UINT32_C(0xFFFF) << UINT32_C(16))
+#define COCLASS(x)            (((x) & COCLASS_MASK) >> UINT32_C(16))
+#define TTREP_MASK            (UINT32_C(0xFF) << UINT32_C(8))
+#define TTREP(x)              (((x) & TTREP_MASK) >> UINT32_C(8))
+#define H48_ESIZE(h)          ((_12c4 * _8c4) << (int64_t)(h))
 
-#define _esep_ind(i)          (i / 8ULL)
-#define _esep_shift(i)        (4ULL * (i % 8ULL))
-#define _esep_mask(i)         (((1ULL << 4ULL) - 1ULL) << _esep_shift(i))
-#define _visited_ind(i)       (i / 8ULL)
-#define _visited_mask(i)      (1ULL << (i % 8ULL))
+#define ESEP_IND(i)           ((uint32_t)(i) / UINT32_C(8))
+#define ESEP_SHIFT(i)         (UINT32_C(4) * ((uint32_t)(i) % UINT32_C(8)))
+#define ESEP_MASK(i)          ((_bit_u32(4) - (uint32_t)(1)) << ESEP_SHIFT(i))
+#define VISITED_IND(i)        ((uint32_t)(i) / UINT32_C(8))
+#define VISITED_MASK(i)       (UINT32_C(1) << ((uint32_t)(i) % UINT32_C(8)))
 
 typedef struct {
         cube_fast_t cube;
@@ -59,8 +64,8 @@ coord_h48(cube_fast_t c, const uint32_t *cocsepdata, uint8_t h)
 
         cocsep = coord_fast_cocsep(c);
         data = cocsepdata[cocsep];
-        coclass = (data & (0xFFFFU << 16U)) >> 16U;
-        ttrep = (data & (0xFFU << 8U)) >> 8U;
+        coclass = (int64_t)COCLASS(data);
+        ttrep = (int64_t)TTREP(data);
 
         return coord_h48_edges(c, coclass, ttrep, h);
 }
@@ -69,13 +74,14 @@ _static_inline int64_t
 coord_h48_edges(cube_fast_t c, int64_t coclass, uint8_t t, uint8_t h)
 {
         cube_fast_t d;
-        int64_t esep, eo;
+        int64_t esep, eo, edges;
 
         d = transform_edges(c, t);
         esep = coord_fast_esep(d);
         eo = coord_fast_eo(d);
+        edges = (esep << (int64_t)h) + (eo >> (11 - (int64_t)h));
 
-        return (coclass * H48_ESIZE(h)) + (esep << h) + (eo >> (11-h));
+        return coclass * H48_ESIZE(h) + edges;
 }
 
 /*
@@ -85,15 +91,17 @@ returned cube is a transformed cube of one that gives the correct value.
 */
 _static_inline cube_fast_t
 invcoord_h48(int64_t i, const cube_fast_t *crep, uint8_t h) {
-        cube_fast_t ret; int64_t coclass, ee, esep, eo;
+        cube_fast_t ret;
+        int64_t hh, coclass, ee, esep, eo;
 
         DBG_ASSERT(h <= 11, cubetofast(zero),
             "invcoord_h48: h must be between 0 and 11\n");
 
+        hh = (int64_t)h;
         coclass = i / H48_ESIZE(h);
         ee = i % H48_ESIZE(h);
-        esep = ee >> h;
-        eo = (ee & ((1<<h)-1)) << (11-h);
+        esep = ee >> hh;
+        eo = (ee & ((1 << hh) - 1)) << (11 - hh);
 
         ret = invcoord_fast_esep(esep);
         copy_corners_fast(&ret, crep[coclass]);
@@ -123,7 +131,7 @@ gendata_cocsep(void *buf, uint64_t *selfsim, cube_fast_t *rep)
 
         buf32 = (uint32_t *)buf;
         info = buf32 + COCSEP_TABLESIZE;
-        memset(buf32, 0xFFU, sizeof(uint32_t) * COCSEP_TABLESIZE);
+        memset(buf32, 0xFF, sizeof(uint32_t) * COCSEP_TABLESIZE);
         memset(selfsim, 0, sizeof(uint64_t) * COCSEP_CLASSES);
 
         arg = (dfsarg_cocsep_t) {
@@ -145,10 +153,10 @@ gendata_cocsep(void *buf, uint64_t *selfsim, cube_fast_t *rep)
         }
 
         info[0] = (uint32_t)n;
-        info[1] = 9U; /* Known max pruning value */
+        info[1] = 9; /* Known max pruning value */
         DBG_ASSERT(n == COCSEP_CLASSES, 0,
             "cocsep: computed %" PRIu16 " symmetry classes, "
-            "expected %" PRIu16 "\n", n, COCSEP_CLASSES);
+            "expected %zu\n", n, COCSEP_CLASSES);
 
         DBG_LOG("cocsep data computed\n");
         DBG_LOG("Symmetry classes: %" PRIu32 "\n", info[0]);
@@ -163,33 +171,37 @@ gendata_cocsep(void *buf, uint64_t *selfsim, cube_fast_t *rep)
 _static uint32_t
 gendata_cocsep_dfs(dfsarg_cocsep_t *arg)
 {
-        uint8_t m, tinv, olddepth;
-        uint32_t cc;
+        uint8_t m, tinv;
+        uint32_t cc, class, ttrep, depth, olddepth;
         uint64_t t, is;
-        int64_t i, ii;
+        int64_t i, j;
         cube_fast_t d;
         dfsarg_cocsep_t nextarg;
 
         i = coord_fast_cocsep(arg->cube);
-        olddepth = (uint8_t)(arg->buf32[i] & 0xFFU);
+        olddepth = (uint8_t)(arg->buf32[i] & 0xFF);
         if (olddepth < arg->depth || get_visited(arg->visited, i))
                 return 0;
         set_visited(arg->visited, i);
 
         if (arg->depth == arg->maxdepth) {
-                if ((arg->buf32[i] & 0xFFU) != 0xFFU)
+                if ((arg->buf32[i] & 0xFF) != 0xFF)
                         return 0;
 
                 for (t = 0, cc = 0; t < 48; t++) {
                         d = transform_corners(arg->cube, t);
-                        ii = coord_fast_cocsep(d);
-                        is = (i == ii);
+                        j = coord_fast_cocsep(d);
+                        is = (i == j);
                         arg->selfsim[*arg->n] |= is << t;
-                        set_visited(arg->visited, ii);
+                        set_visited(arg->visited, j);
                         tinv = inverse_trans(t);
-                        cc += (arg->buf32[ii] & 0xFFU) == 0xFFU;
-                        arg->buf32[ii] =
-                            (*arg->n << 16U) | (tinv << 8U) | arg->depth;
+                        olddepth = (uint8_t)(arg->buf32[j] & 0xFF);
+                        cc += olddepth == 0xFF;
+
+                        class = (uint32_t)(*arg->n) << 16;
+                        ttrep = (uint32_t)tinv << 8;
+                        depth = (uint32_t)arg->depth;
+                        arg->buf32[j] = class | ttrep | depth;
                 }
                 arg->rep[*arg->n] = arg->cube;
                 (*arg->n)++;
@@ -217,16 +229,17 @@ gendata_h48(void *buf, uint8_t h, uint8_t maxdepth)
         const int k = 4; /* TODO: other cases? */
         uint32_t j, *buf32, *info, *cocsepdata;
         bfsarg_esep_t arg;
-        int64_t sc, cc, tot;
+        int64_t sc, cc, tot, esep_max;
         uint64_t selfsim[COCSEP_CLASSES];
         cube_fast_t crep[COCSEP_CLASSES];
-        size_t cocsepsize;
+        size_t cocsepsize, infosize;
 
+        esep_max = (int64_t)ESEP_MAX(h);
         cocsepsize = gendata_cocsep(buf, selfsim, crep);
         cocsepdata = (uint32_t *)buf;
-        buf32 = cocsepdata + cocsepsize/4;
+        buf32 = cocsepdata + cocsepsize / 4;
         info = buf32 + (ESEP_TABLESIZE(h, k) / sizeof(uint32_t));
-        memset(buf32, 0xFFU, ESEP_TABLESIZE(h, k));
+        memset(buf32, 0xFF, ESEP_TABLESIZE(h, k));
 
         sc = coord_h48(cubetofast(solved), cocsepdata, h);
         set_esep_pval(buf32, sc, 0);
@@ -240,7 +253,7 @@ gendata_h48(void *buf, uint8_t h, uint8_t maxdepth)
         };
         for (
                 tot = 1, arg.depth = 1, cc = 0;
-                tot < ESEP_MAX(h) && arg.depth <= maxdepth;
+                tot < esep_max && arg.depth <= maxdepth;
                 arg.depth++
         ) {
                 DBG_LOG("esep: generating depth %" PRIu8 "\n", arg.depth);
@@ -251,6 +264,7 @@ gendata_h48(void *buf, uint8_t h, uint8_t maxdepth)
         }
 
         info[0] = arg.depth-1;
+        infosize = 4 * (size_t)(info[0] + 2);
 
         DBG_LOG("h48 pruning table computed\n");
         DBG_LOG("Maximum pruning value: %" PRIu32 "\n", info[0]);
@@ -258,7 +272,7 @@ gendata_h48(void *buf, uint8_t h, uint8_t maxdepth)
         for (j = 0; j <= info[0]; j++)
                 DBG_LOG("%" PRIu8 ":\t%" PRIu32 "\n", j, info[j+1]);
 
-        return COCSEP_FULLSIZE + ESEP_TABLESIZE(h, k) + 4*(info[0]+2);
+        return cocsepsize + ESEP_TABLESIZE(h, k) + infosize;
 }
 
 _static uint64_t
@@ -266,10 +280,12 @@ gendata_esep_bfs(bfsarg_esep_t *arg)
 {
         uint8_t c, m, x;
         uint32_t cc;
-        uint64_t i, j, k, t, cocsep_coord, sim;
+        int64_t i, j, k, t, cocsep_coord, sim, esep_max;
         cube_fast_t cube, moved, transd;
 
-        for (i = 0, cc = 0; i < ESEP_MAX(arg->h); i++) {
+        esep_max = (uint64_t)ESEP_MAX(arg->h);
+
+        for (i = 0, cc = 0; i < esep_max; i++) {
                 c = get_esep_pval(arg->buf32, i);
                 if (c != arg->depth - 1)
                         continue;
@@ -288,9 +304,9 @@ gendata_esep_bfs(bfsarg_esep_t *arg)
                         set_esep_pval(arg->buf32, j, arg->depth);
                         cc += x != arg->depth;
                         cocsep_coord = j / H48_ESIZE(arg->h);
-                        sim = arg->selfsim[cocsep_coord] >> 1ULL;
-                        for (t = 1; t < 48 && sim; t++, sim >>= 1ULL) {
-                                if (!(sim & 1ULL))
+                        sim = arg->selfsim[cocsep_coord] >> 1;
+                        for (t = 1; t < 48 && sim; t++, sim >>= 1) {
+                                if (!(sim & 1))
                                         continue;
                                 transd = transform(moved, t);
                                 k = coord_h48(transd, arg->cocsepdata, arg->h);
@@ -308,23 +324,23 @@ gendata_esep_bfs(bfsarg_esep_t *arg)
 
 _static_inline bool get_visited(const uint8_t *a, int64_t i)
 {
-        return a[_visited_ind(i)] & _visited_mask(i);
+        return a[VISITED_IND(i)] & VISITED_MASK(i);
 }
 
 _static_inline void set_visited(uint8_t *a, int64_t i)
 {
-        a[_visited_ind(i)] |= _visited_mask(i);
+        a[VISITED_IND(i)] |= VISITED_MASK(i);
 }
 
 _static_inline uint8_t
 get_esep_pval(const uint32_t *buf32, int64_t i)
 {
-        return (buf32[_esep_ind(i)] & _esep_mask(i)) >> _esep_shift(i);
+        return (buf32[ESEP_IND(i)] & ESEP_MASK(i)) >> ESEP_SHIFT(i);
 }
 
 _static_inline void
 set_esep_pval(uint32_t *buf32, int64_t i, uint8_t val)
 {
-        buf32[_esep_ind(i)] =
-            (buf32[_esep_ind(i)] & (~_esep_mask(i))) | (val << _esep_shift(i));
+        buf32[ESEP_IND(i)] =
+            (buf32[ESEP_IND(i)] & (~ESEP_MASK(i))) | (val << ESEP_SHIFT(i));
 }