anchor.diff:              aesAlg.Key <- key
               aesAlg.IV <- iv
               aesAlg.Padding <- PaddingMode.Zeros
  -        
   
               // Create a decrytor to perform the stream transform.
               use decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV)
  
positive.code:         with | _ -> [||]
  
  
      let getDecryptedCollection secrets cryptokeys collection = 
          try
              collection
              |> fetchFullCollection secrets.username secrets.password 
  
negative.code:         
      let getRecordField (r: 'record) (field : Reflection.PropertyInfo) =
          Microsoft.FSharp.Reflection.FSharpValue.GetRecordField(r,field) |> unbox
         
      // Encoding schemes
  
      let random = new Random()
      
      let base32Chars     = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
      let base32'8'9Chars = "ABCDEFGHIJK8MN9PQRSTUVWXYZ234567"
      let base64Chars     = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890+/"
      let base64urlChars  = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-_"
  
      let doBase32'8'9 (s : string) = 
          s.ToUpper().ToCharArray() 
          |> Array.map (fun x -> match x with | 'L' -> '9' | 'O' -> '9' | _ -> x )
          |> fun cs -> new string(cs)
  
      let undoBase32'8'9 (s : string) = 
          s.ToUpper().ToCharArray() 
          |> Array.map (fun x -> match x with | '8' -> 'L' | '9' -> 'O' | _ -> x )
          |> fun cs -> new string(cs)
      
      let generateWeaveGUID() = 
          [| for i in [0 .. 11] do yield base64urlChars.Substring(random.Next(63), 1) |]
          |> Array.fold (fun r s -> r + s) ""
          |> (WeaveGUID)
  
  
      // https://bitbucket.org/devinmartin/base32/src/90d7d530beea52a2a82b187728a06404794600b9/Base32/Base32Encoder.cs?at=default
      let base32Decode (s' : string) = 
          let s = 
              s'.ToUpper().ToCharArray() 
              |> Array.filter (fun x -> if x = '=' then false else true) 
              |> fun cs -> new string(cs)        
          let encodedBitCount = 5
          let byteBitCount = 8
          if isSubset base32Chars s then       
              let outputBuffer = Array.create (s.Length * encodedBitCount / byteBitCount) 0uy
              let mutable workingByte = 0uy
              let mutable bitsRemaining = byteBitCount
              let mutable mask = 0
              let mutable arrayIndex = 0
              for c in s.ToCharArray() do 
                  let value = base32Chars.IndexOf c
                  if bitsRemaining > encodedBitCount then
                      mask <- value <<< (bitsRemaining - encodedBitCount)
                      workingByte <- (workingByte ||| (byte) mask)
  