anchor.diff:          let! prefixPart = listOfLength prefixPartLength (constant fillerValue)
           let! randomPart = listOfLength randomPartLength (constant 0)
           let! suffixPart = listOfLength suffixPartLength (constant fillerValue)
  -        let row = [prefixPart; randomPart; suffixPart] |> Seq.concat |> Seq.toList
  -        return row
  +        return List.concat [prefixPart; randomPart; suffixPart]
       }
   
   let randomlySprinkleOnesIntoSolutionRows solutionRows startIdx randomRowIdxs =
  
positive.code:     genPartitionedSolution numCols 0 numCols
  
  let makePartitions partitionLengths =
      let loop (tuples, currentStartIdx) partitionLength =
          let startIdx = currentStartIdx
          let endIdx = currentStartIdx + partitionLength
          let tuple = (startIdx, endIdx)
          (Seq.concat [tuples; Seq.singleton tuple], endIdx)
      let (tuples, _) = Seq.fold loop (Seq.empty, 0) partitionLengths
      tuples
  
  let genPartitionLengths numCols numSolutions =
      gen {
          let! partitionLengths =
              listOfLength <| numSolutions - 1 <| choose (1, numCols / 2)
              |> suchThat (fun xs -> Seq.sum xs < numCols)
          return Seq.concat [partitionLengths; Seq.singleton (numCols - Seq.sum partitionLengths) |> Seq.toList]
      }
  
  let genPartitions numCols numSolutions =
  
negative.code:             | 0 -> (numZeros + 1, numOnes)
              | 1 -> (numZeros, numOnes + 1)
              | _ -> (numZeros, numOnes)
          let numZeros, numOnes = Seq.fold innerLoop (0, 0) solution.RowIndexes
          let p1 = numOnes = 1 |@ makeLabel1 colIndex numOnes
          let p2 = numZeros = expectedNumZerosPerColumn |@ makeLabel2 colIndex numZeros
          let p3 = p1 .&. p2
  