anchor.diff:          let x = i - ((i >>> 1) &&& 0x55555555u);
           let y = (x &&& 0x33333333u) + ((x >>> 2) &&& 0x33333333u);
           (((y + (y >>> 4)) &&& 0x0F0F0F0Fu) * 0x01010101u) >>> 24;
  -
  -    let (+) (Natural left) (Natural right) : Natural =
  -        let rightpad (l:uint32 list) n =
  -            List.init (n - l.Length) (fun i -> 0u) @ l
  -
  -        let leftpad l n =
  -            l @ List.init (n - l.Length) (fun i -> 0u)
  -
  -        let len = Math.Max( left.Length, right.Length )
  -        let l = rightpad left len
  -        let r = rightpad right len
  -        let s = rightpad (List.map2 (fun x y -> x + y) l r) (len+1)
  -        let o = leftpad (List.map2 (fun  x y -> if x >= ( System.UInt32.MaxValue - y ) then 1u else 0u) l r) (len+1)
  -        let n = List.map2 (fun x y -> x + y ) s o
  -
  -        Natural( if 0u = n.Head then n.Tail else n )
  -        
  -    let (<<<) (Natural left) (right:uint32) : Natural =
  -        let msb = 0x80000000u
  -
  -        let shift1 (l:uint32 list) =
  -            let s = 0u :: (List.map (fun x -> x <<< 1) l)
  -            let o = (List.map (fun x -> if (msb &&& x) > 0u then 1u else 0u) l) @ [0u]
  -            let n = List.map2 (fun x y -> x ||| y) s o
  -            if 0u = n.Head then n.Tail else n
  -
  -        let rec shift (l:uint32 list) n =
  -            match n with
  -            | 0u -> l
  -            | x -> shift1 (shift l (n-1u))
  -
  -        let rDiv = right / 32u
  -        let rMod = right % 32u
  -
  -        let l = left @ (List.init (int(rDiv)) (fun i -> 0u))
  -        Natural( shift l rMod )
  -
  -    let (>>>) (Natural left) (right:uint32) : Natural =
  -        let msb = 0x80000000u
  -
  -        let rec chomp l n =
  -            match l with
  -            | [] -> [0u]
  -            | _ ->
  -                match n with
  -                | 0u -> l
  -                | x -> chomp (List.rev l |> List.tail |> List.rev) (n-1u)
  -
  -        let shift1 (l:uint32 list) =
  -            let s = (List.map (fun x -> x >>> 1) l) @ [0u]
  -            let o = 0u :: (List.map (fun x -> if (1u &&& x) > 0u then msb else 0u) l)
  -            let n = List.map2 (fun x y -> x ||| y) s o
  -            chomp (if 0u = n.Head then n.Tail else n) 1u
  -
  -        let rec shift (l:uint32 list) n =
  -            match n with
  -            | 0u -> l
  -            | x -> shift1 (shift l (n-1u))
  -
  -        let rDiv = right / 32u
  -        let rMod = right % 32u
  -
  -        let l = chomp left rDiv
  -        Natural( shift l rMod )
   
       let (*) (Natural left) (Natural right) : Natural =
           let leftbitcount = 
  
positive.code:             List.map NumberOfSetBits right
              |> List.sum
  
          let l = if leftbitcount > rightbitcount then left else right
          let r = if leftbitcount > rightbitcount then right else left
  
          Natural([])
negative.code: 
  module Types = 
      type public Natural = Natural of uint32 list
          with
              static member Zero
                  with get() = [0u]
  
              static member (+) ((Natural left), (Natural right)) : Natural =
                  let rightpad (l:uint32 list) n =
                      List.init (n - l.Length) (fun i -> 0u) @ l
  
                  let leftpad l n =
                      l @ List.init (n - l.Length) (fun i -> 0u)
  
                  let len = Math.Max( left.Length, right.Length )
                  let l = rightpad left len
                  let r = rightpad right len
                  let s = rightpad (List.map2 (fun x y -> x + y) l r) (len+1)
                  let o = leftpad (List.map2 (fun  x y -> if x >= ( System.UInt32.MaxValue - y ) then 1u else 0u) l r) (len+1)
                  let n = List.map2 (fun x y -> x + y ) s o
  
                  Natural( if 0u = n.Head then n.Tail else n )
  
              static member (<<<) ((Natural left), (right:uint32)) : Natural =
                  let msb = 0x80000000u
  
                  let shift1 (l:uint32 list) =
                      let s = 0u :: (List.map (fun x -> x <<< 1) l)
                      let o = (List.map (fun x -> if (msb &&& x) > 0u then 1u else 0u) l) @ [0u]
                      let n = List.map2 (fun x y -> x ||| y) s o
                      if 0u = n.Head then n.Tail else n
  
                  let rec shift (l:uint32 list) n =
                      match n with
                      | 0u -> l
                      | x -> shift1 (shift l (n-1u))
  
                  let rDiv = right / 32u
                  let rMod = right % 32u
  
                  let l = left @ (List.init (int(rDiv)) (fun i -> 0u))
                  Natural( shift l rMod )
  
              static member (>>>) ((Natural left), (right:uint32)) : Natural =
                  let msb = 0x80000000u
  
                  let rec chomp l n =
                      match l with
                      | [] -> [0u]
                      | _ ->
                          match n with
                          | 0u -> l
                          | x -> chomp (List.rev l |> List.tail |> List.rev) (n-1u)
  
                  let shift1 (l:uint32 list) =
                      let s = (List.map (fun x -> x >>> 1) l) @ [0u]
                      let o = 0u :: (List.map (fun x -> if (1u &&& x) > 0u then msb else 0u) l)
                      let n = List.map2 (fun x y -> x ||| y) s o
                      chomp (if 0u = n.Head then n.Tail else n) 1u
  
                  let rec shift (l:uint32 list) n =
                      match n with
                      | 0u -> l
                      | x -> shift1 (shift l (n-1u))
  
                  let rDiv = right / 32u
                  let rMod = right % 32u
  
                  let l = chomp left rDiv
                  Natural( shift l rMod )
  
      let inline private value (Natural n) = n
  
  