                 if useRelativeWinding {
                     isInside = windingCountImpliesContainment(windingCount, using: fillRule) && windingCountImpliesContainment(windingCount+1, using: fillRule)
                 }
-
                 v.intersectionInfo.isEntry = wasInside == false && isInside == true
                 v.intersectionInfo.isExit = wasInside == true && isInside == false
-                if v.intersectionInfo.isEntry || v.intersectionInfo.isExit {
-                    hasCrossing = true
-                }
-            }
-            if !hasCrossing {
-                // TODO: fix logic here, we should do this after we are done and use .isCrossing
-                nonCrossingComponents.append(self.path.subpaths[i])
             }
         }
     }

        self.lists = p.subpaths.map { self.createListFor(component: $0) }
    }
    
    fileprivate func markEntryExit(_ path: Path, _ nonCrossingComponents: inout [PathComponent], useRelativeWinding: Bool = false) {
        let fillRule: PathFillRule = useRelativeWinding ? .winding : .evenOdd
//        let fillRule = PathFillRule.winding
        for i in 0..<lists.count {
            
            // determine winding counts relative to the first vertex
            var relativeWindingCount = 0
            self.forEachVertexInComponent(atIndex: i) { v in

            pathComponents += nonCrossingComponents1.filter { path2.contains(anyPointOnComponent($0)) == true }
            pathComponents += nonCrossingComponents2.filter { path1.contains(anyPointOnComponent($0)) == true }
        }
        
        // handle components that have crossings (the main algorithm)
        var unvisitedCrossings: [Vertex] = []
        list1.forEachVertex {
            if $0.isCrossing && shouldMoveForwards(fromVertex: $0, forOperation: operation, isOnFirstCurve: true) {
