@Xark Thanks for looking at this!

Hmm, some Interesting questions...

Regarding BYTE cube vs hypercube code, I moved your test into a small separate function which makes it much easier to understand the assembly generated (but I had to "fight" the optimizer that wanted to inline it).  You can see that it uses *almost* the exact same code for cube and hypercube (only difference is using the low word or high word of previous multiply for 2nd MUL.  This explains why the time is identical.

byte cube(byte b)
{
    return b * b * b;
}

byte hypercube(byte b)
{
    return b * b * b * b;
}

000000be <_Z4cubeh>:
      be:       88 9f           mul     r24, r24
      c0:       90 2d           mov     r25, r0
      c2:       11 24           eor     r1, r1
      c4:       98 9f           mul     r25, r24
      c6:       80 2d           mov     r24, r0
      c8:       11 24           eor     r1, r1
      ca:       08 95           ret

000000cc <_Z9hypercubeh>:
      cc:       88 9f           mul     r24, r24
      ce:       80 2d           mov     r24, r0
      d0:       11 24           eor     r1, r1
      d2:       88 9f           mul     r24, r24
      d4:       80 2d           mov     r24, r0
      d6:       11 24           eor     r1, r1
      d8:       08 95           ret

Similarly, for the UINT *2 *3 and *4 cases, here is what the compiler generates:

000000da <_Z6times2j>:
      da:       88 0f           add     r24, r24
      dc:       99 1f           adc     r25, r25
      de:       08 95           ret

000000e0 <_Z6times3j>:
      e0:       9c 01           movw    r18, r24
      e2:       22 0f           add     r18, r18
      e4:       33 1f           adc     r19, r19
      e6:       82 0f           add     r24, r18
      e8:       93 1f           adc     r25, r19
      ea:       08 95           ret

000000ec <_Z6times4j>:
      ec:       88 0f           add     r24, r24
      ee:       99 1f           adc     r25, r25
      f0:       88 0f           add     r24, r24
      f2:       99 1f           adc     r25, r25
      f4:       08 95           ret

So kind of makes sense that *4 is twice as many ops as *2, either "v + v"  or  "(v+v) + (v+v)".  For the *3 case the compiler does (v+v)+v (which needed temp registers, so slower).

I suspect the remaining questions have very similar answers.  Benchmarks can be "subtle". :-)