refactor Blake and Blake2

src/commonMain/kotlin/com/infendro/hash/blake/Blake-224.kt

@@ -43,12 +43,25 @@ object `Blake-224` : HashFunction() {
     )
 
     override fun hash(value: UByteArray): UByteArray {
+        val l = value.size.toULong() * 8UL
         val h = initial.copyOf()
         var t = 0U
-        val l = value.size.toULong() * 8UL
 
-        // padding
-        val paddedValue = buildList {
+        val blocks = pad(value)
+            .chunked(64) { it.toUByteArray() }
+        for (block in blocks) {
+            t += minOf(l - t, 512UL).toUInt()
+            compress(h, block, t)
+        }
+
+        return h.sliceArray(0..6).toUByteArray()
+    }
+
+    private fun pad(
+        value: UByteArray,
+    ): UByteArray {
+        val l = value.size.toULong() * 8UL
+        return buildList {
             addAll(value)
             add(0x80U)
             while (size % 64 != 56) {
@@ -56,56 +69,39 @@ object `Blake-224` : HashFunction() {
             }
             addAll(l.toUByteArray())
         }.toUByteArray()
-
-        // compress
-        val blocks = paddedValue
-            .chunked(64) { it.toUByteArray() }
-        for (block in blocks) {
-            t += minOf(l - t, 512UL).toUInt()
-
-            val m = block.toUIntArray()
-            compress(h, m, t)
-        }
-
-        return h.sliceArray(0..6).toUByteArray()
     }
 
     private fun compress(
         h: UIntArray,
-        m: UIntArray,
+        block: UByteArray,
         t: UInt,
     ) {
-        // initialization
+        val m = block.toUIntArray()
         val v = UIntArray(16)
         for (i in 0..<8) v[i] = h[i]
         for (i in 0..<4) v[i + 8] = c[i]
         for (i in 0..<2) v[i + 12] = c[i + 4] xor t
         for (i in 0..<2) v[i + 14] = c[i + 6]
 
-        // rounds
-        for (r in 0..<14) {
+        repeat(14) { r ->
             val s = sigma[r % 10]
 
-            // column
             g(v, 0, 4, 8, 12, m[s[0]] xor c[s[1]], m[s[1]] xor c[s[0]])
             g(v, 1, 5, 9, 13, m[s[2]] xor c[s[3]], m[s[3]] xor c[s[2]])
             g(v, 2, 6, 10, 14, m[s[4]] xor c[s[5]], m[s[5]] xor c[s[4]])
             g(v, 3, 7, 11, 15, m[s[6]] xor c[s[7]], m[s[7]] xor c[s[6]])
 
-            // diagonal
             g(v, 0, 5, 10, 15, m[s[8]] xor c[s[9]], m[s[9]] xor c[s[8]])
             g(v, 1, 6, 11, 12, m[s[10]] xor c[s[11]], m[s[11]] xor c[s[10]])
             g(v, 2, 7, 8, 13, m[s[12]] xor c[s[13]], m[s[13]] xor c[s[12]])
             g(v, 3, 4, 9, 14, m[s[14]] xor c[s[15]], m[s[15]] xor c[s[14]])
         }
 
-        // finalization
         for (i in 0..7) {
             h[i] = h[i] xor v[i] xor v[i + 8]
         }
     }
 
-    // round function
     private fun g(
         v: UIntArray,
         a: Int,