anchor.diff:          |]
   
       static let timeZones = TimeZoneInfo.GetSystemTimeZones() |> Seq.toArray
  +    static let zeroIfZero n v = if n = 0 then 0 else v
   
       static member TimeZoneInfo = Arb.generate<int> |> Gen.map (fun i -> timeZones.[abs i % timeZones.Length]) |> Arb.fromGen
       static member BigInt = Arb.generate<byte []> |> Gen.map (fun bs -> System.Numerics.BigInteger(bs)) |> Arb.fromGen
  -    static member Array2D<'T> () = Arb.generate<'T> |> Gen.array2DOf |> Arb.fromGen
  +    
       static member Type =
           let rec genTy () = gen {
               let! i = Arb.generate<int>
  
positive.code:             gen {
                  let chooseSqrtOfSize = Gen.choose(0, n |> float |> sqrt |> sqrt |> int)
                  let! N = chooseSqrtOfSize
                  let! M = chooseSqrtOfSize
                  let! K = chooseSqrtOfSize
                  let! L = chooseSqrtOfSize
                  let g = Arb.generate<'T>
                  let! seed = Gen.arrayOfLength (N*M*K*L) g
                  return Array4D.init N M K L (fun n m k l -> seed.[n + m * N + k * N * M + l * N * M * K])
  
negative.code: 
          Arb.fromGen (genTy ())
  
      static member Array2D<'T> () = 
          let mkSized (n : int) =
              gen {
                  // sqrt is good enough here
                  let chooseSqrtOfSize = Gen.choose(0, n |> float |> sqrt |> int)
                  let! N = chooseSqrtOfSize
                  let! M = chooseSqrtOfSize |> Gen.map (zeroIfZero N)
                  let g = Arb.generate<'T>
                  let! seed = Gen.arrayOfLength (N*M) g
                  return Array2D.init N M (fun n m -> seed.[n + m * N])
              }
  
          mkSized |> Gen.sized |> Arb.fromGen
  
      static member Array3D<'T> () =
          let mkSized (n : int) =
              gen {
                  let chooseSqrtOfSize = Gen.choose(0, n |> float |> sqrt |> int)
                  let! N = chooseSqrtOfSize
                  let! M = chooseSqrtOfSize |> Gen.map (zeroIfZero N)
                  let! K = chooseSqrtOfSize |> Gen.map (zeroIfZero M)
                  let g = Arb.generate<'T>
                  let! seed = Gen.arrayOfLength (N*M*K) g
                  return Array3D.init N M K (fun n m k -> seed.[n + m * N + k * N * M])
  