anchor.diff:                              for j = 0 to l.[1] - 1 do
                                   for k = 0 to l.[2] - 1 do
                                       for l = 0 to l.[3] - 1 do
  -                                        arr.[i,j,k,l] <- read isPrimitive r ef "item"
  +                                        arr.[i,j,k,l] <- read isPrimitive r ep "item"
   
                           array
                       | _ -> failwith "impossible array rank"
  
positive.code:                 // register new object with deserializer cache
                  r.EarlyRegisterArray array
  
                  if ef.TypeKind = TypeKind.Primitive then //&& keepEndianness then
                      r.Formatter.ReadToPrimitiveArray "data" array
  //                    Stream.WriteToArray(r.BinaryReader.BaseStream, array)
  
                      array
                  else
                      let isPrimitive = ef.TypeKind <= TypeKind.Primitive
  
                      match rank with
                      | 1 -> 
                          let arr = fastUnbox<'T []> array
                          for i = 0 to l.[0] - 1 do
                              arr.[i] <- read isPrimitive r ef "item"
  
                          array
                      | 2 -> 
                          let arr = fastUnbox<'T [,]> array
                          for i = 0 to l.[0] - 1 do
                              for j = 0 to l.[1] - 1 do
                                  arr.[i,j] <- read isPrimitive r ef "item"
  
                          array
                      | 3 ->
  
negative.code:                     lengths.[d] <- x.GetLength d
                      w.Formatter.WriteInt32 (string d) lengths.[d]
  
                  if ep.TypeKind = TypeKind.Primitive then
                      w.Formatter.WritePrimitiveArray "data" x
  //                    // block copy without bothering with endianness && keepEndianness
  //                    Stream.ReadFromArray(w.BinaryWriter.BaseStream, x)
                  else
                      let isPrimitive = isPrimitive ep
                               
                      match rank with
                      | 1 ->
                          let x = fastUnbox<'T []> x
                          for i = 0 to x.Length - 1 do
                              write isPrimitive w ep "item" x.[i]
                      | 2 -> 
                          let x = fastUnbox<'T [,]> x
                          for i = 0 to lengths.[0] - 1 do
                              for j = 0 to lengths.[1] - 1 do
                                  write isPrimitive w ep "item" x.[i,j]
                      | 3 ->
                          let x = fastUnbox<'T [,,]> x
                          for i = 0 to lengths.[0] - 1 do
                              for j = 0 to lengths.[1] - 1 do
                                  for k = 0 to lengths.[2] - 1 do
                                      write isPrimitive w ep "item" x.[i,j,k]
                      | 4 ->
                          let x = fastUnbox<'T [,,,]> x
                          for i = 0 to lengths.[0] - 1 do
                              for j = 0 to lengths.[1] - 1 do
                                  for k = 0 to lengths.[2] - 1 do
                                      for l = 0 to lengths.[3] - 1 do
                                          write isPrimitive w ep "item" x.[i,j,k,l]
  
                      | _ -> failwith "impossible array rank"
  
  