             case .none: return nil
             }
         case let .regions(left, right): return left.union(right)
-        case let .segments(loops):
-            let forward = loops.filter { self.area.sign == $0.solid.area.sign }
-            let backward = loops.filter { self.area.sign != $0.solid.area.sign }
-            return ShapeRegion(solids: forward.enumerated().filter { arg in !forward.enumerated().contains { $0.0 != arg.0 && $0.1.solid._contains(arg.1.solid) } }.map { arg in ShapeRegion.Solid(components: [arg.1.solid] + backward.filter { arg.1.solid._contains($0.solid) }.map { $0.solid }) })
+        case let .segments(forward, backward): return ShapeRegion(solids: forward.enumerated().flatMap { arg in forward.enumerated().contains { $0.0 != arg.0 && $0.1.solid._contains(arg.1.solid) } ? nil : ShapeRegion.Solid(solid: arg.1.solid, holes: backward.flatMap { arg.1.solid._contains($0.solid) ? $0.solid : nil }) })
         }
     }
     fileprivate func _intersection(_ other: Shape.Component) -> ShapeRegion {

            if superset {
                let self_holes = ShapeRegion(solids: self.holes.flatMap { ShapeRegion.Solid(solid: $0) })
                let a = self_holes.union(ShapeRegion(solid: other))
                cache.subtracting[other.cacheId] = [ShapeRegion.Solid(components: [self.solid] + a.solids.map { $0.solid })] + a.solids.flatMap { $0.holes.map { ShapeRegion.Solid(solid: $0) } }
            } else if let subtracting = _subtracting {
                let self_holes = ShapeRegion(solids: self.holes.flatMap { ShapeRegion.Solid(solid: $0) })
                let other_holes = ShapeRegion(solids: other.holes.flatMap { ShapeRegion.Solid(solid: $0) })

                    case .subset: return .overlap(.superset)
                    }
                case let .regions(lhs, rhs): return .regions(rhs, lhs)
                case let .segments(forward, backward): return self.area.sign == other.area.sign ? .segments(forward, backward) : .segments(backward, forward)
                }
            } else {
                let intersectTable = ConstructiveSolidResult.Table(self, other)
                if intersectTable.looping_left.count != 0 || intersectTable.looping_right.count != 0 {
                    constructiveSolidResultCache[other.cacheId] = .regions(ShapeRegion(solids: self.breakLoop(intersectTable.looping_left)), ShapeRegion(solids: other.breakLoop(intersectTable.looping_right)))
                } else {
                    
                    if intersectTable.graph.count == 0 {
                        constructiveSolidResultCache[other.cacheId] = .overlap(intersectTable.overlap)
                    } else {
                        let segments = createSegments(other, intersectTable.graph)
                        let forward = segments.filter { self.area.sign == $0.solid.area.sign }
                        let backward = segments.filter { self.area.sign != $0.solid.area.sign }
                        constructiveSolidResultCache[other.cacheId] = .segments(forward, backward)
                    }
                }
            }
