anchor.diff:                  let negated =
                       match operand with
                       | { OrFormulas = [ {Literals = [ lit] } ] } -> 
  -                        { OrFormulas = [ {Literals = [ { lit with IsNegated = not lit.IsNegated } ] } ] }
  +                        [ {Literals = [ { lit with IsNegated = not lit.IsNegated } ] } ]
  +                        |> FrameworkRestriction.FromOrList
                       |  _ -> failwithf "a general NOT is not implemted jet (and shouldn't be emitted for now)"
                   negated, next
               else
  
positive.code:                     else
                          workDone, andFormula :: reworkedOrFormulas
                      ) (false, [])
              if workDone then removeNegatedLiteralsWhichOccurSinglePositive { OrFormulas = reworked }
              else fr
          /// (>= net40-full) && (< net46) && (>= net20) can be simplified to (< net46) && (>= net40-full) because (>= net40-full) is a subset of (>= net20)
          // NOTE: This optimization is kind of dangerous as future frameworks might make it invalid
  
negative.code:                         |> Seq.exists (fun otherLiteral ->
                              h.RawFormular.IsSubsetOf otherLiteral.RawFormular)
                          |> not
                      | _ -> true)
              if newOrList.Length < fr.OrFormulas.Length then
                  FrameworkRestriction.WithOrListInternal newOrList fr
              else fr
  
          /// ((>= net20) && (>= net40)) || (>= net20) can be simplified to (>= net20) because any AND clause with (>= net20) can be removed.
          let removeUneccessaryOrClauses (fr:FrameworkRestriction) =
  