anchor.diff:                  let br = binDataLookup.BinaryReader(vertRels.[modVertIndex].RefPointIdx, el.Usage)
                   let idx = br.ReadBytes(4)
                   bw.Write(idx) 
  -            | _ -> failwithf "Unsupported type for blend index: %A" el.Type
  +            | _ -> failwithf "Unsupported type for raw blend index: %A" el.Type
           let rbBlendWeight (binDataLookup:ModDB.BinaryLookupHelper) (vertRels:MeshRelation.VertRel[]) (modm:Mesh) (modVertIndex: int) (el:SDXVertexElement) (bw:BinaryWriter) =
               match el.Type with
               | SDXVertexDeclType.Color 
               | SDXVertexDeclType.UByte4N -> 
                   let br = binDataLookup.BinaryReader(vertRels.[modVertIndex].RefPointIdx, el.Usage)
                   bw.Write(br.ReadBytes(4))
  -            | _ -> failwithf "Unsupported type for blend weight: %A" el.Type
  +            | _ -> failwithf "Unsupported type for raw blend weight: %A" el.Type
   
           let private writeMeshBI (mesh:Mesh) (idx:int) (bw:BinaryWriter) =
               if (idx > mesh.BlendIndices.Length) then
  
positive.code:                 // convert normal to 4 byte rep
                  let srcNrm = modm.Normals.[modNrmIndex]
                  write4ByteVector srcNrm bw
              | _ -> failwithf "Unsupported type for normal: %A" el.Type
  
          let rbNormal (binDataLookup:ModDB.BinaryLookupHelper) (vertRels:MeshRelation.VertRel[]) (_: int) (modVertIndex: int) (el:SDXVertexElement) (bw:BinaryWriter) =
              match el.Type with
  
negative.code:             let wgt = mesh.BlendWeights.[idx]
  
              let buf = [| byte (round(wgt.X * 255.f)); byte (round (wgt.Y * 255.f)) ; byte (round (wgt.Z * 255.f)); byte (round (wgt.W * 255.f)) |]
              // weights must sum to 255
  //            let sum = Array.sum buf
  //            if (sum <> (byte 255)) then
  //                log.Error "weights do not sum to 255 for idx %A: %A, %A; basevec: %A" idx buf sum wgt
              bw.Write(buf)
  
          let private writeMeshBWF4 (mesh:Mesh) (idx:int) (bw:BinaryWriter) =
              if (idx > mesh.BlendWeights.Length) then
                  failwithf "oops: invalid blend-weight index: %A of %A" idx mesh.BlendWeights.Length
              let wgt = mesh.BlendWeights.[idx]
              bw.Write(wgt.X)
              bw.Write(wgt.Y)
              bw.Write(wgt.Z)
              bw.Write(wgt.W)
  
          let modmBlendIndex (vertRels:MeshRelation.VertRel[]) (modm:Mesh) (modVertIndex: int) (el:SDXVertexElement) (bw:BinaryWriter) =
              match el.Type with
              | SDXVertexDeclType.Ubyte4 -> writeMeshBI modm modVertIndex bw
              | _ -> failwithf "Unsupported type for mod blend index: %A" el.Type
  
          let refmBlendIndex (vertRels:MeshRelation.VertRel[]) (refm:Mesh) (modVertIndex: int) (el:SDXVertexElement) (bw:BinaryWriter) =
              match el.Type with
              | SDXVertexDeclType.Color 
              | SDXVertexDeclType.Ubyte4 ->
                  let refVertIndex = vertRels.[modVertIndex].RefPointIdx
                  writeMeshBI refm refVertIndex bw
              | _ -> failwithf "Unsupported type for ref blend index: %A" el.Type
  
          let modmBlendWeight (vertRels:MeshRelation.VertRel[]) (modm:Mesh) (modVertIndex: int) (el:SDXVertexElement) (bw:BinaryWriter) =
              match el.Type with
              | SDXVertexDeclType.Color 
              | SDXVertexDeclType.UByte4N -> writeMeshBW modm modVertIndex bw
              | _ -> failwithf "Unsupported type for mod blend weight: %A" el.Type
  
          let refmBlendWeight (vertRels:MeshRelation.VertRel[]) (refm:Mesh) (modVertIndex: int) (el:SDXVertexElement) (bw:BinaryWriter) =
              match el.Type with
  