anchor.diff:                              | None -> None
   
                           {load with Load1Value = load1Value; Load2Value = load2Value})
  +
  +            let lc1ToLC4 =
  +                thisMarksLoads
  +                |> List.filter (fun load -> load.Category <> "SM" && (load.LoadCases = [] || (load.LoadCases |> List.contains 1)))
  +                |> List.filter (fun load -> load.Load1Value > 0.0)
  +                |> List.map (fun load -> {load with LoadCases = [4]})   
  +
  +            let lc4Loads =
  +                []
  +                |> List.append liveLoads
  +                |> List.append (this.DeadLoads liveLoadUNO liveLoadSpecialNotes)
  +                |> List.append additionalJoistLoads
  +                |> List.append lc1ToLC4
  +                |> List.map
  +                    (fun load ->
  +                        let load1Value = Math.Ceiling load.Load1Value
  +                        
  +                        let load2Value = load.Load2Value |> Option.map Math.Ceiling
  +
  +                        {load with Load1Value = load1Value; Load2Value = load2Value; LoadCases = [4]})
  +               
  +                
  +
  +            if requiresLc4Loads then
  +                lc4Loads
  +                |> List.append lc3Loads
  +            else
  +               lc3Loads
  +                
   
   
       type BOM = 
  
positive.code:                                  None, None, None, None, [3]) ]
              
  
          member this.LC3Loads (loadNotes :LoadNote list) (sds : float) =
                  let additionalJoistLoads =
                      this.AdditionalJoists
                      |> List.map (fun load -> {load with LoadCases = [3]})
  
                  let thisMarksLoads =
                      loadNotes                   
                      |> List.filter (fun note ->
                          match this.LoadNoteList with
                          | Some loadNoteList -> loadNoteList |> List.contains note.LoadNumber
                          | None -> false)
                      |> List.map (fun note -> note.Load)
                  
                   
                  let sds_From_UDLs_And_UTLs =
                      thisMarksLoads
                      |> List.filter (fun load -> load.Type = "U" && (load.Category = "DL" || load.Category = "TL") && (load.LoadCases = [] || (load.LoadCases |> List.contains 1)))
                      |> List.map (fun load ->
                          let categoryFactor = if load.Category = "DL" then 1.0 else 0.5
                          let load1Value = 0.14 * sds * load.Load1Value * categoryFactor
                          let load2Value =
                              match (load.Load2Value) with
                              | Some v -> Some (0.14 * sds * v * categoryFactor)
                              | None -> None
                          {load with Category = "SM"; Load1Value = load1Value; Load2Value = load2Value; LoadCases = [3]})
                  
                  let directLoadsToLC3 =
                      thisMarksLoads
                      |> List.filter (fun load -> load.Category <> "WL" && load.Category <> "SM" && (load.LoadCases = [] || (load.LoadCases |> List.contains 1)))
                      |> List.map (fun load -> {load with LoadCases = [3]})                 
                  
                  []
                  |> List.append sds_From_UDLs_And_UTLs
                  |> List.append [this.SDS sds]
                  |> List.append this.DeadLoads
                  |> List.append additionalJoistLoads
                  |> List.append directLoadsToLC3
                  |> List.map
  
negative.code:         let isLiveLoadNote (note: string) =
                  Regex.IsMatch(note, "[LS] *= *(\d+\.?\d*) *([Kk%]) *")
  
          
  
          let liveLoadUNO =
              let liveLoadNotes = generalNotes |> List.filter (fun note -> isLiveLoadNote note.Text)
              match liveLoadNotes with
              | [] -> "L = 0.0K"
              | _ -> liveLoadNotes.[0].Text
  
          let isInwardPressureNote (note : string) =
              Regex.IsMatch(note, "IP *= *(\d+\.?\d*) *([Kk%]) *")
  
          let inwardPressureUNO =
              let inwardPressureNotes = generalNotes |> List.filter (fun note -> isInwardPressureNote note.Text)
              match inwardPressureNotes with
              | [] -> "IP = 0.0K"
              | _ -> inwardPressureNotes.[0].Text
  
          let isSlopeLoadNote (note: string) =
              Regex.IsMatch(note, "SP *: *(\d+\.?\d*)/(\d+\.?\d*)")
  