(60 . 41)(60 . 44)
                        Modulus  : in  FZ;
                        Result   : out FZ) is
      
      -- Working register for the squaring
      -- Working register for the squaring; initially is copy of Base
      B : FZ(Base'Range)     := Base;
      
      -- Register for cycling through the bits of E
      -- Copy of Exponent, for cycling through its bits
      E : FZ(Exponent'Range) := Exponent;
      
      -- Register for the Mux operation
      T : FZ(Result'Range);
      
      -- Buffer register for the Result
      R : FZ(Result'Range);
      
   begin
      -- Result := 1
      WBool_To_FZ(1, Result);
      WBool_To_FZ(1, R);
      
      -- For each bit of Result width:
      for i in 1 .. FZ_Bitness(Result) loop
      -- For each bit of R width:
      for i in 1 .. FZ_Bitness(R) loop
         
         -- T := Result * B mod Modulus
         FZ_Mod_Mul(X => Result, Y => B, Modulus => Modulus,
                    Product => T);
         FZ_Mod_Mul(X => R, Y => B, Modulus => Modulus, Product => T);
         
         -- Sel is the current low bit of E;
         --    When Sel=0 -> Result := Result;
         --    When Sel=1 -> Result := T
         FZ_Mux(X => Result, Y => T, Result => Result,
                Sel => FZ_OddP(E));
         FZ_Mux(X => R, Y => T, Result => R, Sel => FZ_OddP(E));
         
         -- Advance to the next bit of E
         FZ_ShiftRight(E, E, 1);
         
         -- B := B*B mod Modulus
         FZ_Mod_Mul(X => B, Y => B, Modulus => Modulus,
                    Product => B);
         FZ_Mod_Mul(X => B, Y => B, Modulus => Modulus, Product => B);
         
      end loop;
      
      -- Output the Result:
      Result := R;
      
   end FZ_Mod_Exp;
   pragma Inline_Always(FZ_Mod_Exp);