(22 . 3)(22 . 4)
 611775 ffa_ch20b_litmus_legacy_hashes "Support for certain ancient hash algos in Litmus."
 612395 ffa_ch20c_litmus_clearsigned   "Support for 'clearsigned' GPG texts in Litmus."
 612828 ffa_ch20d_litmus_nested_fix    "Fix for bug where nested 'clearsigned' sigs were rejected."
 629424 ffa_ch21a_bis_fix_ch15_gcd     "Fix for lethal flaw in Ch.15's Greatest Common Divisor."

(24 . 6)(24 . 4)

Questions?

http://webchat.freenode.net/?channels=#trilema&nick=from_ffa

Privmsg one of the people speaking and ask politely for 'voice'.
http://webchat.freenode.net/?channels=#asciilifeform&nick=from_ffa

(45 . 7)(45 . 7)
   --- Current 'deg. Kelvin' Version of FFA
   ----------------------------------------------------------------------------
   
   FFA_K_Version : constant Natural := 253;
   FFA_K_Version : constant Natural := 200;
   
   ----------------------------------------------------------------------------
   --- Fundamental Types and Sizes

(21 . 6)(21 . 7)
with FZ_Shift; use FZ_Shift;
with FZ_QShft; use FZ_QShft;
with FZ_Arith; use FZ_Arith;
with FZ_BitOp; use FZ_BitOp;
with FZ_Pred;  use FZ_Pred;


(36 . 15)(37 . 18)
      subtype Width is Word_Index range X'Range;
      
      -- Working buffers for GCD computation, initially equal to the inputs
      A      : FZ(Width) := X; -- GCD will appear in A in the end
      A      : FZ(Width) := X;
      B      : FZ(Width) := Y;
      
      -- Evenness (negation of lowest bit) of A and B respectively
      Ae, Be : WBool;
      
      -- Common power-of-2 factor
      -- Common power-of-2 factor: incremented when Ae and Be are both 1
      Twos   : Word := 0;
      
      -- This flag is set when A and B are BOTH ODD
      OO     : WBool;
      
      -- |A - B|
      D      : FZ(Width);
      
(53 . 35)(57 . 42)
      
   begin
      
      -- For convergence, requires number of shots equal to 2 * FZ_Bitness:
      for i in 1 .. 2 * FZ_Bitness(X) loop
      -- To converge, requires number of shots equal to (2 * FZ_Bitness) - 1:
      for i in 1 .. (2 * FZ_Bitness(X)) - 1 loop
         
         -- Whether A and B are currently BOTH ODD :
         OO := FZ_OddP(A) and FZ_OddP(B);
         
         -- D := |A - B|
         FZ_Sub_Abs(X => A, Y => B, Difference => D, Underflow => A_lt_B);
         
         -- IFF A,B both ODD, and A < B : B' := A ; otherwise no change :
         FZ_Mux(X => B, Y => A, Result => B, Sel => OO and A_lt_B);
         
         -- IFF A,B both ODD: A' := |A - B| ; otherwise no change :
         FZ_Mux(X => A, Y => D, Result => A, Sel => OO);
         
         -- If A is even, A := A >> 1; otherwise A := A
         -- If A is now EVEN: A := A >> 1; otherwise no change
         Ae := 1 - FZ_OddP(A);
         FZ_ShiftRight(A, A, WBit_Index(Ae));
         
         -- If B is even, B := B >> 1; otherwise B := B
         -- If B is now EVEN: B := B >> 1; otherwise no change
         Be := 1 - FZ_OddP(B);
         FZ_ShiftRight(B, B, WBit_Index(Be));
         
         -- If both A and B were even, increment the common power-of-two
         Twos := Twos + (Ae and Be);
         
         -- D := |A - B|
         FZ_Sub_Abs(X => A, Y => B, Difference => D, Underflow => A_lt_B);
         
         -- B' := min(A, B)
         FZ_Mux(X => B, Y => A, Result => B, Sel => A_lt_B);
         
         -- A' := |A - B|
         A := D;
         
      end loop;
      
      -- Normally, B will contain the GCD, but in the (N,0) N > 0 case -- A.
      -- The other variable will always equal 0. Hence, take Bitwise-OR(A,B):
      FZ_Or(X => A, Y => B, Result => A);
      
      -- Reintroduce the common power-of-2 factor stored in 'Twos'
      FZ_Quiet_ShiftLeft(N => A, ShiftedN => A, Count => Indices(Twos));
      
      -- Output final result
      -- Output final result -- the GCD.
      Result := A;
      
   end FZ_Greatest_Common_Divisor;