Rename constants from _underscore to CAPS

4 files changed, 116 insertions, 116 deletions

diff --git a/src/arch/avx2.h b/src/arch/avx2.h
index b1a7ab7..8d53f8f 100644
--- a/src/arch/avx2.h
+++ b/src/arch/avx2.h
@@ -16,7 +16,7 @@
 #define solved static_cube( \
     0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
 
-_static void
+STATIC void
 pieces(cube_t *cube, uint8_t c[static 8], uint8_t e[static 12])
 {
         uint8_t aux[32];
@@ -26,7 +26,7 @@ pieces(cube_t *cube, uint8_t c[static 8], uint8_t e[static 12])
         memcpy(e, aux+16, 12);
 }
 
-_static_inline bool
+STATIC_INLINE bool
 equal(cube_t c1, cube_t c2)
 {
         int32_t mask;
@@ -38,7 +38,7 @@ equal(cube_t c1, cube_t c2)
         return mask == ~0;
 }
 
-_static_inline cube_t
+STATIC_INLINE cube_t
 invertco(cube_t c)
 {
         cube_t co, shleft, shright, summed, newco, cleanco, ret;
@@ -54,7 +54,7 @@ invertco(cube_t c)
         return ret;
 }
 
-_static_inline cube_t
+STATIC_INLINE cube_t
 compose_epcpeo(cube_t c1, cube_t c2)
 {
         cube_t b, s, eo2;
@@ -74,13 +74,13 @@ compose_epcpeo(cube_t c1, cube_t c2)
         return s;
 }
 
-_static_inline cube_t
+STATIC_INLINE cube_t
 compose_edges(cube_t c1, cube_t c2)
 {
         return compose_epcpeo(c1, c2);
 }
 
-_static_inline cube_t
+STATIC_INLINE cube_t
 compose_corners(cube_t c1, cube_t c2)
 {
         /*
@@ -91,7 +91,7 @@ compose_corners(cube_t c1, cube_t c2)
         return compose(c1, c2);
 }
 
-_static_inline cube_t
+STATIC_INLINE cube_t
 compose(cube_t c1, cube_t c2)
 {
         cube_t s, co1, co2, aux, auy1, auy2, auz1, auz2;
@@ -114,7 +114,7 @@ compose(cube_t c1, cube_t c2)
         return s;
 }
 
-_static_inline cube_t
+STATIC_INLINE cube_t
 cleanaftershuffle(cube_t c)
 {
         __m256i b;
@@ -127,7 +127,7 @@ cleanaftershuffle(cube_t c)
         return _mm256_andnot_si256(b, c);
 }
 
-_static_inline cube_t
+STATIC_INLINE cube_t
 inverse(cube_t c)
 {
         /* Method taken from Andrew Skalski's vcube[1]. The addition sequence
@@ -166,7 +166,7 @@ inverse(cube_t c)
         return invertco(ret);
 }
 
-_static_inline int64_t
+STATIC_INLINE int64_t
 coord_co(cube_t c)
 {
         cube_t co;
@@ -182,7 +182,7 @@ coord_co(cube_t c)
         return ret;
 }
 
-_static_inline int64_t
+STATIC_INLINE int64_t
 coord_csep(cube_t c)
 {
         cube_t cp, shifted;
@@ -195,13 +195,13 @@ coord_csep(cube_t c)
         return mask & 0x7F;
 }
 
-_static_inline int64_t
+STATIC_INLINE int64_t
 coord_cocsep(cube_t c)
 {
         return (coord_co(c) << 7) + coord_csep(c);
 }
 
-_static_inline int64_t
+STATIC_INLINE int64_t
 coord_eo(cube_t c)
 {
         cube_t eo, shifted;
@@ -214,7 +214,7 @@ coord_eo(cube_t c)
         return mask >> 17;
 }
 
-_static_inline int64_t
+STATIC_INLINE int64_t
 coord_esep(cube_t c)
 {
         cube_t ep;
@@ -229,8 +229,8 @@ coord_esep(cube_t c)
         for (i = 0, j = 0; i < 12; i++, mem[i/8 + 2] >>= 8) {
                 e = mem[i/8 + 2];
 
-                bit1 = (e & _esepbit1) >> 2;
-                bit2 = (e & _esepbit2) >> 3;
+                bit1 = (e & ESEPBIT_1) >> 2;
+                bit2 = (e & ESEPBIT_2) >> 3;
                 is1 = (1 - bit2) * bit1;
 
                 ret1 += bit2 * binomial[11-i][k];
@@ -245,19 +245,19 @@ coord_esep(cube_t c)
         return ret1 * 70 + ret2;
 }
 
-_static_inline void
+STATIC_INLINE void
 copy_corners(cube_t *dest, cube_t src)
 {
         *dest = _mm256_blend_epi32(*dest, src, 0x0F);
 }
 
-_static_inline void
+STATIC_INLINE void
 copy_edges(cube_t *dest, cube_t src)
 {
         *dest = _mm256_blend_epi32(*dest, src, 0xF0);
 }
 
-_static_inline void
+STATIC_INLINE void
 set_eo(cube_t *cube, int64_t eo)
 {
         int64_t eo12, eotop, eobot;
@@ -282,7 +282,7 @@ set_eo(cube_t *cube, int64_t eo)
         *cube = _mm256_or_si256(*cube, veo);
 }
 
-_static_inline cube_t
+STATIC_INLINE cube_t
 invcoord_esep(int64_t esep)
 {
         cube_t eee, ret;
diff --git a/src/arch/common.h b/src/arch/common.h
index d8d2305..346403b 100644
--- a/src/arch/common.h
+++ b/src/arch/common.h
@@ -1,26 +1,26 @@
-_static void pieces(cube_t *, uint8_t [static 8], uint8_t [static 12]);
-_static_inline bool equal(cube_t, cube_t);
-_static_inline cube_t invertco(cube_t);
-_static_inline cube_t compose_epcpeo(cube_t, cube_t);
-_static_inline cube_t compose_edges(cube_t, cube_t);
-_static_inline cube_t compose_corners(cube_t, cube_t);
-_static_inline cube_t compose(cube_t, cube_t);
-_static_inline cube_t inverse(cube_t);
+STATIC void pieces(cube_t *, uint8_t [static 8], uint8_t [static 12]);
+STATIC_INLINE bool equal(cube_t, cube_t);
+STATIC_INLINE cube_t invertco(cube_t);
+STATIC_INLINE cube_t compose_epcpeo(cube_t, cube_t);
+STATIC_INLINE cube_t compose_edges(cube_t, cube_t);
+STATIC_INLINE cube_t compose_corners(cube_t, cube_t);
+STATIC_INLINE cube_t compose(cube_t, cube_t);
+STATIC_INLINE cube_t inverse(cube_t);
 
-_static_inline int64_t coord_co(cube_t);
-_static_inline int64_t coord_csep(cube_t);
-_static_inline int64_t coord_cocsep(cube_t);
-_static_inline int64_t coord_eo(cube_t);
-_static_inline int64_t coord_esep(cube_t);
+STATIC_INLINE int64_t coord_co(cube_t);
+STATIC_INLINE int64_t coord_csep(cube_t);
+STATIC_INLINE int64_t coord_cocsep(cube_t);
+STATIC_INLINE int64_t coord_eo(cube_t);
+STATIC_INLINE int64_t coord_esep(cube_t);
 
-_static_inline void copy_corners(cube_t *, cube_t);
-_static_inline void copy_edges(cube_t *, cube_t);
-_static_inline void set_eo(cube_t *, int64_t);
-_static_inline cube_t invcoord_esep(int64_t);
+STATIC_INLINE void copy_corners(cube_t *, cube_t);
+STATIC_INLINE void copy_edges(cube_t *, cube_t);
+STATIC_INLINE void set_eo(cube_t *, int64_t);
+STATIC_INLINE cube_t invcoord_esep(int64_t);
 
-_static_inline void invcoord_esep_array(int64_t, int64_t, uint8_t[static 12]);
+STATIC_INLINE void invcoord_esep_array(int64_t, int64_t, uint8_t[static 12]);
 
-_static_inline void
+STATIC_INLINE void
 invcoord_esep_array(int64_t set1, int64_t set2, uint8_t mem[static 12])
 {
         int64_t bit1, bit2, i, j, jj, k, l, s, v, w, is1;
diff --git a/src/arch/neon.h b/src/arch/neon.h
index b6734b7..dee0eba 100644
--- a/src/arch/neon.h
+++ b/src/arch/neon.h
@@ -4,8 +4,8 @@
 #define _ep_neon vcombine_u8(vdupq_n_u8(0x0F), vdupq_n_u8(0x0F))
 #define _eo_neon vcombine_u8(vdupq_n_u8(0x10), vdupq_n_u8(0x10))
 
-_static_inline uint8x16_t compose_edges_slim(uint8x16_t, uint8x16_t);
-_static_inline uint8x16_t compose_corners_slim(uint8x16_t, uint8x16_t);
+STATIC_INLINE uint8x16_t compose_edges_slim(uint8x16_t, uint8x16_t);
+STATIC_INLINE uint8x16_t compose_corners_slim(uint8x16_t, uint8x16_t);
 
 // static cube
 #define static_cube(c_ufr, c_ubl, c_dfl, c_dbr, c_ufl, c_ubr, c_dfr, c_dbl, \
@@ -26,7 +26,7 @@ _static_inline uint8x16_t compose_corners_slim(uint8x16_t, uint8x16_t);
 #define solved static_cube(     \
         0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
 
-_static void
+STATIC void
 pieces(cube_t *cube, uint8_t c[static 8], uint8_t e[static 12])
 {
         // First 8 bytes of the corner vector are copied from the c array
@@ -39,7 +39,7 @@ pieces(cube_t *cube, uint8_t c[static 8], uint8_t e[static 12])
         vst1_lane_u32((uint32_t *)(e + 8), vreinterpret_u32_u8(vget_high_u8(cube->edge)), 0);
 }
 
-_static_inline bool
+STATIC_INLINE bool
 equal(cube_t c1, cube_t c2)
 {
         uint8x16_t cmp_corner, cmp_edge;
@@ -62,7 +62,7 @@ equal(cube_t c1, cube_t c2)
         return vgetq_lane_u64(cmp_result, 0) == ~0ULL && vgetq_lane_u64(cmp_result, 1) == ~0ULL;
 }
 
-_static_inline cube_t
+STATIC_INLINE cube_t
 invertco(cube_t c)
 {
         cube_t ret;
@@ -80,7 +80,7 @@ invertco(cube_t c)
         return ret;
 }
 
-_static_inline cube_t
+STATIC_INLINE cube_t
 compose_edges(cube_t c1, cube_t c2)
 {
         cube_t ret = {0};
@@ -88,7 +88,7 @@ compose_edges(cube_t c1, cube_t c2)
         return ret;
 }
 
-_static_inline cube_t 
+STATIC_INLINE cube_t
 compose_corners(cube_t c1, cube_t c2)
 {
         cube_t ret = {0};
@@ -96,12 +96,12 @@ compose_corners(cube_t c1, cube_t c2)
         return ret;
 }
 
-_static_inline uint8x16_t 
+STATIC_INLINE uint8x16_t
 compose_edges_slim(uint8x16_t edge1, uint8x16_t edge2)
 {
         // Masks
-        uint8x16_t p_bits = vdupq_n_u8(_pbits);
-        uint8x16_t eo_bit = vdupq_n_u8(_eobit);
+        uint8x16_t p_bits = vdupq_n_u8(PBITS);
+        uint8x16_t eo_bit = vdupq_n_u8(EOBIT);
 
         // Find the index and permutation
         uint8x16_t p = vandq_u8(edge2, p_bits);
@@ -120,14 +120,14 @@ compose_edges_slim(uint8x16_t edge1, uint8x16_t edge2)
         return ret;
 }
 
-_static_inline uint8x16_t 
+STATIC_INLINE uint8x16_t
 compose_corners_slim(uint8x16_t corner1, uint8x16_t corner2)
 {
         // Masks
-        uint8x16_t p_bits = vdupq_n_u8(_pbits);
-        uint8x16_t cobits = vdupq_n_u8(_cobits);
-        uint8x16_t cobits2 = vdupq_n_u8(_cobits2);
-        uint8x16_t twist_cw = vdupq_n_u8(_ctwist_cw);
+        uint8x16_t p_bits = vdupq_n_u8(PBITS);
+        uint8x16_t cobits = vdupq_n_u8(COBITS);
+        uint8x16_t cobits2 = vdupq_n_u8(COBITS_2);
+        uint8x16_t twist_cw = vdupq_n_u8(CTWIST_CW);
 
         // Find the index and permutation
         uint8x16_t p = vandq_u8(corner2, p_bits);
@@ -148,7 +148,7 @@ compose_corners_slim(uint8x16_t corner1, uint8x16_t corner2)
         return ret;
 }
 
-_static_inline cube_t 
+STATIC_INLINE cube_t
 compose(cube_t c1, cube_t c2)
 {
         cube_t ret = {0};
@@ -159,7 +159,7 @@ compose(cube_t c1, cube_t c2)
         return ret;
 }
 
-_static_inline cube_t 
+STATIC_INLINE cube_t
 inverse(cube_t cube)
 {
         uint8_t i, piece, orien;
@@ -180,16 +180,16 @@ inverse(cube_t cube)
         for (i = 0; i < 12; i++)
         {
                 piece = edges[i];
-                orien = piece & _eobit;
-                edge_result[piece & _pbits] = i | orien;
+                orien = piece & EOBIT;
+                edge_result[piece & PBITS] = i | orien;
         }
 
         // Process the corners
         for (i = 0; i < 8; i++)
         {
                 piece = corners[i];
-                orien = ((piece << 1) | (piece >> 1)) & _cobits2;
-                corner_result[piece & _pbits] = i | orien;
+                orien = ((piece << 1) | (piece >> 1)) & COBITS_2;
+                corner_result[piece & PBITS] = i | orien;
         }
 
         // Copy the results back to the NEON vectors
@@ -199,7 +199,7 @@ inverse(cube_t cube)
         return ret;
 }
 
-_static_inline int64_t 
+STATIC_INLINE int64_t
 coord_co(cube_t c)
 {
         // Temp array to store the NEON vector
@@ -210,12 +210,12 @@ coord_co(cube_t c)
         int64_t ret;
 
         for (ret = 0, i = 0, p = 1; i < 7; i++, p *= 3)
-                ret += p * (mem[i] >> _coshift);
+                ret += p * (mem[i] >> COSHIFT);
 
         return ret;
 }
 
-_static_inline int64_t
+STATIC_INLINE int64_t
 coord_csep(cube_t c)
 {
         // Temp array to store the NEON vector
@@ -225,19 +225,19 @@ coord_csep(cube_t c)
         int64_t ret = 0;
         int i, p;
         for (ret = 0, i = 0, p = 1; i < 7; i++, p *= 2)
-                ret += p * ((mem[i] & _csepbit) >> 2);
+                ret += p * ((mem[i] & CSEPBIT) >> 2);
 
         return ret;
         return 0;
 }
 
-_static_inline int64_t
+STATIC_INLINE int64_t
 coord_cocsep(cube_t c)
 {
         return (coord_co(c) << 7) + coord_csep(c);
 }
 
-_static_inline int64_t 
+STATIC_INLINE int64_t
 coord_eo(cube_t c)
 {
         int64_t ret = 0;
@@ -249,13 +249,13 @@ coord_eo(cube_t c)
 
         for (int i = 1; i < 12; i++, p *= 2)
         {
-                ret += p * (mem[i] >> _eoshift);
+                ret += p * (mem[i] >> EOSHIFT);
         }
 
         return ret;
 }
 
-_static_inline int64_t 
+STATIC_INLINE int64_t
 coord_esep(cube_t c)
 {
         int64_t i, j, jj, k, l, ret1, ret2, bit1, bit2, is1;
@@ -266,8 +266,8 @@ coord_esep(cube_t c)
 
         for (i = 0, j = 0, k = 4, l = 4, ret1 = 0, ret2 = 0; i < 12; i++)
         {
-                bit1 = (mem[i] & _esepbit1) >> 2;
-                bit2 = (mem[i] & _esepbit2) >> 3;
+                bit1 = (mem[i] & ESEPBIT_1) >> 2;
+                bit2 = (mem[i] & ESEPBIT_2) >> 3;
                 is1 = (1 - bit2) * bit1;
 
                 ret1 += bit2 * binomial[11 - i][k];
@@ -282,19 +282,19 @@ coord_esep(cube_t c)
         return ret1 * 70 + ret2;
 }
 
-_static_inline void
+STATIC_INLINE void
 copy_corners(cube_t *dst, cube_t src)
 {
         dst->corner = src.corner;
 }
 
-_static_inline void
+STATIC_INLINE void
 copy_edges(cube_t *dst, cube_t src)
 {
         dst->edge = src.edge;
 }
 
-_static_inline void
+STATIC_INLINE void
 set_eo(cube_t *cube, int64_t eo)
 {
         // Temp array to store the NEON vector
@@ -306,16 +306,16 @@ set_eo(cube_t *cube, int64_t eo)
         {
                 flip = eo % 2;
                 sum += flip;
-                mem[i] = (mem[i] & ~_eobit) | (_eobit * flip);
+                mem[i] = (mem[i] & ~EOBIT) | (EOBIT * flip);
         }
-        mem[0] = (mem[0] & ~_eobit) | (_eobit * (sum % 2));
+        mem[0] = (mem[0] & ~EOBIT) | (EOBIT * (sum % 2));
 
         // Copy the results back to the NEON vector
         cube->edge = vld1q_u8(mem);
         return;
 }
 
-_static_inline cube_t
+STATIC_INLINE cube_t
 invcoord_esep(int64_t esep)
 {
         cube_t ret;
diff --git a/src/arch/portable.h b/src/arch/portable.h
index f6e5301..fdadb02 100644
--- a/src/arch/portable.h
+++ b/src/arch/portable.h
@@ -9,14 +9,14 @@
 #define solved static_cube( \
     0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
 
-_static void
+STATIC void
 pieces(cube_t *cube, uint8_t c[static 8], uint8_t e[static 12])
 {
         memcpy(c, cube->corner, 8);
         memcpy(e, cube->edge, 12);
 }
 
-_static_inline bool
+STATIC_INLINE bool
 equal(cube_t c1, cube_t c2)
 {
         uint8_t i;
@@ -31,7 +31,7 @@ equal(cube_t c1, cube_t c2)
         return ret;
 }
 
-_static_inline cube_t
+STATIC_INLINE cube_t
 invertco(cube_t c)
 {
         uint8_t i, piece, orien;
@@ -40,44 +40,44 @@ invertco(cube_t c)
         ret = c;
         for (i = 0; i < 8; i++) {
                 piece = c.corner[i];
-                orien = ((piece << 1) | (piece >> 1)) & _cobits2;
-                ret.corner[i] = (piece & _pbits) | orien;
+                orien = ((piece << 1) | (piece >> 1)) & COBITS_2;
+                ret.corner[i] = (piece & PBITS) | orien;
         }
 
         return ret;
 }
 
-_static_inline void
+STATIC_INLINE void
 compose_edges_inplace(cube_t c1, cube_t c2, cube_t *ret)
 {
         uint8_t i, piece1, piece2, p, orien;
 
         for (i = 0; i < 12; i++) {
                 piece2 = c2.edge[i];
-                p = piece2 & _pbits;
+                p = piece2 & PBITS;
                 piece1 = c1.edge[p];
-                orien = (piece2 ^ piece1) & _eobit;
-                ret->edge[i] = (piece1 & _pbits) | orien;
+                orien = (piece2 ^ piece1) & EOBIT;
+                ret->edge[i] = (piece1 & PBITS) | orien;
         }
 }
 
-_static_inline void
+STATIC_INLINE void
 compose_corners_inplace(cube_t c1, cube_t c2, cube_t *ret)
 {
         uint8_t i, piece1, piece2, p, orien, aux, auy;
 
         for (i = 0; i < 8; i++) {
                 piece2 = c2.corner[i];
-                p = piece2 & _pbits;
+                p = piece2 & PBITS;
                 piece1 = c1.corner[p];
-                aux = (piece2 & _cobits) + (piece1 & _cobits);
-                auy = (aux + _ctwist_cw) >> 2;
-                orien = (aux + auy) & _cobits2;
-                ret->corner[i] = (piece1 & _pbits) | orien;
+                aux = (piece2 & COBITS) + (piece1 & COBITS);
+                auy = (aux + CTWIST_CW) >> 2;
+                orien = (aux + auy) & COBITS_2;
+                ret->corner[i] = (piece1 & PBITS) | orien;
         }
 }
 
-_static_inline cube_t
+STATIC_INLINE cube_t
 compose_edges(cube_t c1, cube_t c2)
 {
         cube_t ret = zero;
@@ -87,7 +87,7 @@ compose_edges(cube_t c1, cube_t c2)
         return ret;
 }
 
-_static_inline cube_t
+STATIC_INLINE cube_t
 compose_corners(cube_t c1, cube_t c2)
 {
         cube_t ret = zero;
@@ -97,7 +97,7 @@ compose_corners(cube_t c1, cube_t c2)
         return ret;
 }
 
-_static_inline cube_t
+STATIC_INLINE cube_t
 compose(cube_t c1, cube_t c2)
 {
         cube_t ret = zero;
@@ -116,27 +116,27 @@ inverse(cube_t cube)
 
         for (i = 0; i < 12; i++) {
                 piece = cube.edge[i];
-                orien = piece & _eobit;
-                ret.edge[piece & _pbits] = i | orien;
+                orien = piece & EOBIT;
+                ret.edge[piece & PBITS] = i | orien;
         }
 
         for (i = 0; i < 8; i++) {
                 piece = cube.corner[i];
-                orien = ((piece << 1) | (piece >> 1)) & _cobits2;
-                ret.corner[piece & _pbits] = i | orien;
+                orien = ((piece << 1) | (piece >> 1)) & COBITS_2;
+                ret.corner[piece & PBITS] = i | orien;
         }
 
         return ret;
 }
 
-_static_inline int64_t
+STATIC_INLINE int64_t
 coord_co(cube_t c)
 {
         int i, p;
         int64_t ret;
 
         for (ret = 0, i = 0, p = 1; i < 7; i++, p *= 3)
-                ret += p * (c.corner[i] >> _coshift);
+                ret += p * (c.corner[i] >> COSHIFT);
 
         return ret;
 }
@@ -148,32 +148,32 @@ Ignoring the last bit, we have a value up to 2^7, but not all values are
 possible. Encoding this as a number from 0 to C(8,4) would save about 40%
 of space, but we are not going to use this coordinate in large tables.
 */
-_static_inline int64_t
+STATIC_INLINE int64_t
 coord_csep(cube_t c)
 {
         int i, p;
         int64_t ret;
 
         for (ret = 0, i = 0, p = 1; i < 7; i++, p *= 2)
-                ret += p * ((c.corner[i] & _csepbit) >> 2);
+                ret += p * ((c.corner[i] & CSEPBIT) >> 2);
 
         return ret;
 }
 
-_static_inline int64_t
+STATIC_INLINE int64_t
 coord_cocsep(cube_t c)
 {
         return (coord_co(c) << 7) + coord_csep(c);
 }
 
-_static_inline int64_t
+STATIC_INLINE int64_t
 coord_eo(cube_t c)
 {
         int i, p;
         int64_t ret;
 
         for (ret = 0, i = 1, p = 1; i < 12; i++, p *= 2)
-                ret += p * (c.edge[i] >> _eoshift);
+                ret += p * (c.edge[i] >> EOSHIFT);
 
         return ret;
 }
@@ -182,24 +182,24 @@ coord_eo(cube_t c)
 We encode the edge separation as a number from 0 to C(12,4)*C(8,4).
 It can be seen as the composition of two "subset index" coordinates.
 */
-_static_inline int64_t
+STATIC_INLINE int64_t
 coord_esep(cube_t c)
 {
         int64_t i, j, jj, k, l, ret1, ret2, bit1, bit2, is1;
 
         for (i = 0, j = 0, k = 4, l = 4, ret1 = 0, ret2 = 0; i < 12; i++) {
                 /* Simple version:
-                if (c.edge[i] & _esepbit2) {
+                if (c.edge[i] & ESEPBIT_2) {
                         ret1 += binomial[11-i][k--];
                 } else {
-                        if (c.edge[i] & _esepbit1)
+                        if (c.edge[i] & ESEPBIT_1)
                                 ret2 += binomial[7-j][l--];
                         j++;
                 }
                 */
 
-                bit1 = (c.edge[i] & _esepbit1) >> 2;
-                bit2 = (c.edge[i] & _esepbit2) >> 3;
+                bit1 = (c.edge[i] & ESEPBIT_1) >> 2;
+                bit2 = (c.edge[i] & ESEPBIT_2) >> 3;
                 is1 = (1 - bit2) * bit1;
 
                 ret1 += bit2 * binomial[11-i][k];
@@ -214,19 +214,19 @@ coord_esep(cube_t c)
         return ret1 * 70 + ret2;
 }
 
-_static_inline void
+STATIC_INLINE void
 copy_corners(cube_t *dest, cube_t src)
 {
         memcpy(&dest->corner, src.corner, sizeof(src.corner));
 }
 
-_static_inline void
+STATIC_INLINE void
 copy_edges(cube_t *dest, cube_t src)
 {
         memcpy(&dest->edge, src.edge, sizeof(src.edge));
 }
 
-_static_inline void
+STATIC_INLINE void
 set_eo(cube_t *cube, int64_t eo)
 {
         uint8_t i, sum, flip;
@@ -234,12 +234,12 @@ set_eo(cube_t *cube, int64_t eo)
         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[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_t
+STATIC_INLINE cube_t
 invcoord_esep(int64_t esep)
 {
         cube_t ret;