docs: def multiply_slow(x, y, prim=0x11b):
          '''Another equivalent (but even slower) way to compute multiplication in Galois Fields without using a precomputed look-up table.
          This is the form you will most often see in academic literature, by using the standard carry-less multiplication + modular reduction using an irreducible prime polynomial.'''
  
          ### Define bitwise carry-less operations as inner functions ###
          def cl_mult(x,y):
              '''Bitwise carry-less multiplication on integers'''
              z = 0
              i = 0
              while (y>>i) > 0:
                  if y & (1<<i):
                      z ^= x<<i
                  i += 1
              return z
  
          def bit_length(n):
              '''Compute the position of the most significant bit (1) of an integer. Equivalent to int.bit_length()'''
              bits = 0
              while n >> bits: bits += 1
              return bits
  
          def cl_div(dividend, divisor=None):
              '''Bitwise carry-less long division on integers and returns the remainder'''
              # Compute the position of the most significant bit for each integers
              dl1 = bit_length(dividend)
              dl2 = bit_length(divisor)
              # If the dividend is smaller than the divisor, just exit
              if dl1 < dl2:
                  return dividend
              # Else, align the most significant 1 of the divisor to the most significant 1 of the dividend (by shifting the divisor)
              for i in _range(dl1-dl2,-1,-1):
                  # Check that the dividend is divisible (useless for the first iteration but important for the next ones)
                  if dividend & (1 << i+dl2-1):
                      # If divisible, then shift the divisor to align the most significant bits and XOR (carry-less substraction)
                      dividend ^= divisor << i
              return dividend
  
          ### Main GF multiplication routine ###
  
          # Multiply the gf numbers
          result = cl_mult(x,y)
          # Then do a modular reduction (ie, remainder from the division) with an irreducible primitive polynomial so that it stays inside GF bounds
          if prim > 0:
              result = cl_div(result, prim)
  
          return result