Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Expose sheet metal concept paths and bounded curve utilities
Yuechen Li51d583b7d99e
diff --git a/Aetheris.CLI/CliRunner.cs b/Aetheris.CLI/CliRunner.csindex 9104edd1..7020f2e4 100644--- a/Aetheris.CLI/CliRunner.cs+++ b/Aetheris.CLI/CliRunner.cs@@ -158,7 +158,7 @@ public static class CliRunnerprivate const string ExperimentalPrismaticMapUsage = "Usage: aetheris experimental prismatic-map --case <case> --rows <N> --cols <N> --json";private const string FeaUsage = "Usage: aetheris fea <analysis.firmament> [--rotate <x,y,z-degrees>] [--out-dir <directory>] [--json]";private const string DrawingUsage = "Usage: aetheris drawing compile <drawing.firmament> --out-dir <directory> [--json]";- private const string SheetMetalUsage = "Usage: aetheris sheetmetal inspect <part.step|part.firmament> [--k-factor <0..1>] [--json] | aetheris sheetmetal recover <part.step> --out-dir <directory> [--json] | aetheris sheetmetal compare <part.step|part.firmament> <intent.firmament> [--json] | aetheris sheetmetal flatten <part.step|part.firmament> [--step <flat.step>] [--firmament <recovered.firmament>] [--svg <flat.svg>] [--k-factor <0..1>] [--json]";+ private const string SheetMetalUsage = "Usage: aetheris sheetmetal inspect <part.step|part.firmament> [--k-factor <0..1>] [--json] | aetheris sheetmetal paths <part.firmament> [--json] | aetheris sheetmetal recover <part.step> --out-dir <directory> [--json] | aetheris sheetmetal compare <part.step|part.firmament> <intent.firmament> [--json] | aetheris sheetmetal flatten <part.step|part.firmament> [--step <flat.step>] [--firmament <recovered.firmament>] [--svg <flat.svg>] [--k-factor <0..1>] [--json]";private const string ExperimentalLoopChamferCorpusUsage = "Usage: aetheris experimental loop-chamfer-corpus --out-dir <dir> [--json]";internal static readonly JsonSerializerOptions JsonOptions = new()@@ -500,7 +500,7 @@ public static class CliRunnerif(args.Length==0||IsHelpFlag(args[0])){WriteSheetMetalHelp(stdout);return args.Length==0?1:0;}if(args[0]=="recover")return RunSheetMetalRecover(args.Skip(1).ToArray(),stdout,stderr);if(args[0]=="compare")return RunSheetMetalCompare(args.Skip(1).ToArray(),stdout,stderr);- var operation=args[0];if(operation is not ("inspect" or "flatten")||args.Length<2){stderr.WriteLine(SheetMetalUsage);return 1;}+ var operation=args[0];if(operation is not ("inspect" or "flatten" or "paths")||args.Length<2){stderr.WriteLine(SheetMetalUsage);return 1;}var input=Path.GetFullPath(args[1]);string? output=null,flatStepOutput=null,firmamentOutput=null;var json=false;double? requestedK=null;for(var i=2;i<args.Length;i++){@@ -512,10 +512,10 @@ public static class CliRunnerstderr.WriteLine($"Unknown or invalid sheetmetal option '{args[i]}'.");stderr.WriteLine(SheetMetalUsage);return 1;}if(!File.Exists(input)){stderr.WriteLine($"Sheet Metal input was not found: {input}");return 1;}- SheetMetalPartIr? part;SheetThicknessRecognition? thickness=null;TimeSpan importTime=TimeSpan.Zero,recognitionTime=TimeSpan.Zero;SheetMetalAuthoringTimings? authoredTimings=null;IReadOnlyList<SheetMetalDiagnostic> recognitionDiagnostics;+ SheetMetalPartIr? part;SheetThicknessRecognition? thickness=null;TimeSpan importTime=TimeSpan.Zero,recognitionTime=TimeSpan.Zero;SheetMetalAuthoringTimings? authoredTimings=null;SheetMetalConstructionSpec? authoredSpec=null;IReadOnlyList<SheetMetalDiagnostic> recognitionDiagnostics;var source=File.ReadAllText(input);if(SheetMetalFirmament.LooksLikeSheetMetal(source)){- var authored=SheetMetalFirmament.Compile(source,input);part=authored.Part;authoredTimings=authored.Timings;recognitionDiagnostics=authored.Diagnostics;if(!authored.IsSuccess||part is null){WriteFailure(authored.Diagnostics);return 1;}+ var authored=SheetMetalFirmament.Compile(source,input);part=authored.Part;authoredSpec=authored.Spec;authoredTimings=authored.Timings;recognitionDiagnostics=authored.Diagnostics;if(!authored.IsSuccess||part is null){WriteFailure(authored.Diagnostics);return 1;}part=part with{FlatPatternPolicy=new(requestedK??part.FlatPatternPolicy.KFactor)};}else@@ -523,6 +523,15 @@ public static class CliRunnervar recognized=SheetMetalRecognizer.RecognizeStep(input,new(FlattenPolicy:new(requestedK??.5d)));part=recognized.Part;thickness=recognized.Thickness;importTime=recognized.ImportTime;recognitionTime=recognized.RecognitionTime;recognitionDiagnostics=recognized.Diagnostics;if(part is null){WriteFailure(recognitionDiagnostics);return 1;}}var k=requestedK??part.FlatPatternPolicy.KFactor;var flattenClock=Stopwatch.StartNew();var flat=SheetMetalFlattener.Flatten(part,new(k));flattenClock.Stop();var dfm=SheetMetalDfm.Evaluate(part,flat);+ var allDiagnostics=recognitionDiagnostics.Concat(flat.Diagnostics).GroupBy(x=>(x.Code,x.Severity,x.Message)).Select(x=>x.First()).ToArray();+ var conceptPaths=authoredSpec is null?Array.Empty<SheetMetalConceptPath>():SheetMetalConceptPaths.Inspect(authoredSpec,part,flat);+ if(operation=="paths")+ {+ if(authoredSpec is null){stderr.WriteLine("sheetmetal paths requires authored or reconstructed Firmament, not recovered STEP topology.");return 1;}+ if(json)stdout.WriteLine(JsonSerializer.Serialize(new{command="sheetmetal paths",success=true,input,paths=conceptPaths},JsonOptions));+ else foreach(var path in conceptPaths)stdout.WriteLine($"{path.Path} {path.Kind} [{string.Join(", ",path.Capabilities)}]");+ return 0;+ }if(operation=="flatten"){if(string.IsNullOrWhiteSpace(output)&&string.IsNullOrWhiteSpace(flatStepOutput)&&string.IsNullOrWhiteSpace(firmamentOutput)){stderr.WriteLine("sheetmetal flatten requires at least one of --step, --firmament, or --svg/--output.");return 1;}@@ -532,10 +541,10 @@ public static class CliRunner}var body=part.FormedBody;var supportFamilies=body?.Topology.Faces.GroupBy(f=>body.TryGetFaceSurfaceGeometry(f.Id,out var s)?s?.Kind.ToString()??"Unknown":"Unknown").OrderBy(g=>g.Key).ToDictionary(g=>g.Key,g=>g.Count());var pmiIndicators=Regex.Matches(source,"(DRAUGHTING_MODEL|GEOMETRIC_TOLERANCE|DATUM_FEATURE|ANNOTATION_OCCURRENCE|SHAPE_ASPECT)",RegexOptions.IgnoreCase).Count;- var report=new{command=$"sheetmetal {operation}",success=true,input,sourceAuthority=SheetMetalFirmament.LooksLikeSheetMetal(source)?(source.Contains("Intent: Reconstructed",StringComparison.OrdinalIgnoreCase)?"Firmament reconstructed engineering authority":source.Contains("RecoveredRegion",StringComparison.Ordinal)?"Firmament recovered sheet-metal semantics":"Firmament authored semantics"):"STEP formed BRep (not mutated)",recognitionStatus=part.RecognitionStatus,thickness=new{nominal=part.Thickness,tolerance=thickness?.Tolerance,evidencePairs=thickness?.SourcePairs.Count(p=>p.Admitted)??0,outlierFaces=thickness?.OutlierFaceIds.Count??0},geometry=new{bodies=body?.Topology.Bodies.Count()??0,shells=body?.Topology.Shells.Count()??0,faces=body?.Topology.Faces.Count()??0,edges=body?.Topology.Edges.Count()??0,vertices=body?.Topology.Vertices.Count()??0,supportFamilies,pmiIndicators},sheetMetal=new{baseRegion=part.BaseRegionId,regions=part.Regions.Select(r=>new{r.StableId,r.Kind,r.ApproximateArea,sourceFaces=r.Source.FaceIds}),bends=part.Bends.Select(b=>new{b.StableId,b.AxisOrigin,b.AxisDirection,angleDegrees=b.BendAngleRadians*180/Math.PI,b.InsideRadius,b.Direction,b.AdjacentRegionA,b.AdjacentRegionB,sourceFaces=b.Source.FaceIds}),cuts=part.Features.Select(f=>new{f.StableId,f.Kind,f.OwningRegionId,f.Diameter,sourceFaces=f.Source.FaceIds})},flatPattern=new{flat.Status,flat.Bounds,bendLines=flat.BendLines.Count,cuts=flat.CutLoops.Count,kFactor=flat.Policy.KFactor,flat.DeterministicHash,svg=output,step=flatStepOutput,firmament=firmamentOutput},dfm=new{dfm.Overall,findings=dfm.Findings},diagnostics=recognitionDiagnostics.Concat(flat.Diagnostics),timingsMilliseconds=new{parse=authoredTimings?.ParseMilliseconds,formedLower=authoredTimings?.FormedLowerMilliseconds,authoredFlatLower=authoredTimings?.FlatLowerMilliseconds,import=importTime.TotalMilliseconds,recognition=recognitionTime.TotalMilliseconds,flatten=flattenClock.Elapsed.TotalMilliseconds}};+ var report=new{command=$"sheetmetal {operation}",success=true,input,sourceAuthority=SheetMetalFirmament.LooksLikeSheetMetal(source)?(source.Contains("Intent: Reconstructed",StringComparison.OrdinalIgnoreCase)?"Firmament reconstructed engineering authority":source.Contains("RecoveredRegion",StringComparison.Ordinal)?"Firmament recovered sheet-metal semantics":"Firmament authored semantics"):"STEP formed BRep (not mutated)",recognitionStatus=part.RecognitionStatus,thickness=new{nominal=part.Thickness,tolerance=thickness?.Tolerance,evidencePairs=thickness?.SourcePairs.Count(p=>p.Admitted)??0,outlierFaces=thickness?.OutlierFaceIds.Count??0},geometry=new{bodies=body?.Topology.Bodies.Count()??0,shells=body?.Topology.Shells.Count()??0,faces=body?.Topology.Faces.Count()??0,edges=body?.Topology.Edges.Count()??0,vertices=body?.Topology.Vertices.Count()??0,supportFamilies,pmiIndicators},sheetMetal=new{baseRegion=part.BaseRegionId,regions=part.Regions.Select(r=>new{r.StableId,r.Kind,r.ApproximateArea,sourceFaces=r.Source.FaceIds}),bends=part.Bends.Select(b=>new{b.StableId,b.AxisOrigin,b.AxisDirection,angleDegrees=b.BendAngleRadians*180/Math.PI,b.InsideRadius,b.Direction,b.AdjacentRegionA,b.AdjacentRegionB,sourceFaces=b.Source.FaceIds}),cuts=part.Features.Select(f=>new{f.StableId,f.Kind,f.OwningRegionId,f.Diameter,sourceFaces=f.Source.FaceIds}),conceptPaths},flatPattern=new{flat.Status,flat.Bounds,bendLines=flat.BendLines.Count,cuts=flat.CutLoops.Count,exactBlank=flat.ExactBlankContour is not null,kFactor=flat.Policy.KFactor,flat.DeterministicHash,svg=output,step=flatStepOutput,firmament=firmamentOutput},dfm=new{dfm.Overall,findings=dfm.Findings},diagnostics=allDiagnostics,timingsMilliseconds=new{parse=authoredTimings?.ParseMilliseconds,formedLower=authoredTimings?.FormedLowerMilliseconds,authoredFlatLower=authoredTimings?.FlatLowerMilliseconds,import=importTime.TotalMilliseconds,recognition=recognitionTime.TotalMilliseconds,flatten=flattenClock.Elapsed.TotalMilliseconds}};if(json)stdout.WriteLine(JsonSerializer.Serialize(report,JsonOptions));else{- stdout.WriteLine($"Sheet Metal: {part.RecognitionStatus} ({report.sourceAuthority})");stdout.WriteLine($"Thickness: {part.Thickness:G8} mm{(thickness is null?" authored/recovered":$" ± {thickness.Tolerance:G4} mm, {thickness.SourcePairs.Count(p=>p.Admitted)} paired supports")}");stdout.WriteLine($"Regions: {part.Regions.Count} ({part.Regions.Count(r=>r.Kind==SheetRegionKind.Planar)} planar, {part.Regions.Count(r=>r.Kind==SheetRegionKind.CylindricalBend)} cylindrical)");stdout.WriteLine($"Bends: {part.Bends.Count}; cuts: {part.Features.Count}; base: {part.BaseRegionId}");foreach(var bend in part.Bends)stdout.WriteLine($" {bend.StableId}: {bend.BendAngleRadians*180/Math.PI:G5} deg, R{bend.InsideRadius:G6}, {bend.Direction}, {bend.AdjacentRegionA} -> {bend.AdjacentRegionB}");stdout.WriteLine($"Flat pattern: {flat.Status}; {(flat.Bounds is null?"no bounds":$"{flat.Bounds.Width:G8} x {flat.Bounds.Height:G8} mm")}; K={flat.Policy.KFactor:G4}; hash={flat.DeterministicHash}");if(flatStepOutput is not null)stdout.WriteLine($"STEP: {flatStepOutput}");if(firmamentOutput is not null)stdout.WriteLine($"Firmament: {firmamentOutput}");if(output is not null)stdout.WriteLine($"SVG: {output}");foreach(var d in recognitionDiagnostics.Concat(flat.Diagnostics))stdout.WriteLine($" [{d.Severity}] {d.Code}: {d.Message}");+ stdout.WriteLine($"Sheet Metal: {part.RecognitionStatus} ({report.sourceAuthority})");stdout.WriteLine($"Thickness: {part.Thickness:G8} mm{(thickness is null?" authored/recovered":$" ± {thickness.Tolerance:G4} mm, {thickness.SourcePairs.Count(p=>p.Admitted)} paired supports")}");stdout.WriteLine($"Regions: {part.Regions.Count} ({part.Regions.Count(r=>r.Kind==SheetRegionKind.Planar)} planar, {part.Regions.Count(r=>r.Kind==SheetRegionKind.CylindricalBend)} cylindrical)");stdout.WriteLine($"Bends: {part.Bends.Count}; cuts: {part.Features.Count}; base: {part.BaseRegionId}");foreach(var bend in part.Bends)stdout.WriteLine($" {bend.StableId}: {bend.BendAngleRadians*180/Math.PI:G5} deg, R{bend.InsideRadius:G6}, {bend.Direction}, {bend.AdjacentRegionA} -> {bend.AdjacentRegionB}");stdout.WriteLine($"Flat pattern: {flat.Status}; {(flat.Bounds is null?"no bounds":$"{flat.Bounds.Width:G8} x {flat.Bounds.Height:G8} mm")}; K={flat.Policy.KFactor:G4}; hash={flat.DeterministicHash}");if(flatStepOutput is not null)stdout.WriteLine($"STEP: {flatStepOutput}");if(firmamentOutput is not null)stdout.WriteLine($"Firmament: {firmamentOutput}");if(output is not null)stdout.WriteLine($"SVG: {output}");foreach(var d in allDiagnostics)stdout.WriteLine($" [{d.Severity}] {d.Code}: {d.Message}");}return flat.Status is FlatPatternStatus.Unsupported or FlatPatternStatus.Overlapping?2:0;void WriteFailure(IReadOnlyList<SheetMetalDiagnostic> ds){if(json)stdout.WriteLine(JsonSerializer.Serialize(new{command=$"sheetmetal {operation}",success=false,input,diagnostics=ds},JsonOptions));else foreach(var d in ds)stderr.WriteLine($"[{d.Severity}] {d.Code}: {d.Message}");}@@ -3637,6 +3646,7 @@ Model CanonicalPanel {stdout.WriteLine(SheetMetalUsage);stdout.WriteLine();stdout.WriteLine(" inspect Print a compact recognition, bend-evidence, flat-status, DFM, and timing summary.");+ stdout.WriteLine(" paths List stable authored Sheet Metal Concept Paths, capabilities, and formed/flat correspondence.");stdout.WriteLine(" recover Emit forensic summary JSON, editable recovered draft, and concise LLM/engineer reconstruction brief.");stdout.WriteLine(" compare Compare source and reconstructed intent with localized formed, bend, feature, and flat residuals.");stdout.WriteLine(" flatten Run recovery once and emit manufacturing and review artifacts from the same flat-pattern IR.");@@ -3648,6 +3658,7 @@ Model CanonicalPanel {stdout.WriteLine();stdout.WriteLine("Examples:");stdout.WriteLine(" aetheris sheetmetal inspect testdata/step242/nist/CTC/nist_ctc_03_asme1_ap242-e2.stp");+ stdout.WriteLine(" aetheris sheetmetal paths fixtures/FirmamentV2/SheetMetal/m3-electronics-tray.firmament");stdout.WriteLine(" aetheris sheetmetal recover part.step --out-dir artifacts/recovery --json");stdout.WriteLine(" aetheris sheetmetal compare part.step reconstructed.firmament --json");stdout.WriteLine(" aetheris sheetmetal flatten testdata/step242/nist/CTC/nist_ctc_03_asme1_ap242-e2.stp --step artifacts/ctc03-flat.step --firmament artifacts/ctc03-recovered.firmament --svg artifacts/ctc03-flat.svg");diff --git a/Aetheris.Kernel.Firmament.Tests/PlanarContour2Tests.cs b/Aetheris.Kernel.Firmament.Tests/PlanarContour2Tests.csnew file mode 100644index 00000000..02d9a915--- /dev/null+++ b/Aetheris.Kernel.Firmament.Tests/PlanarContour2Tests.cs@@ -0,0 +1,74 @@+using Aetheris.Kernel.Firmament.Materializer;++namespace Aetheris.Kernel.Firmament.Tests;++public sealed class PlanarContour2Tests+{+ [Fact]+ public void BoundedIntersectionAndSplit_RetainAnalyticKinds()+ {+ var horizontal = new LineArcLineSegment2D((0, 0), (10, 0));+ var vertical = new LineArcLineSegment2D((5, -5), (5, 5));+ var lineHit = Assert.Single(ProfileArrangementBuilder.IntersectBounded(horizontal, vertical).Intersections);+ Assert.Equal((5d, 0d), lineHit.Point);+ Assert.Equal(.5d, lineHit.FirstParameter, 12);++ var arc = new LineArcCircularArc2D((5, 0), 3, Math.PI, Math.PI);+ Assert.Equal(2, ProfileArrangementBuilder.IntersectBounded(horizontal, arc).Intersections.Count);+ var split = ProfileArrangementBuilder.SplitBounded(arc, .5d);+ Assert.All(split, curve => Assert.IsType<LineArcCircularArc2D>(curve));+ Assert.Equal(Math.PI / 2d, Assert.IsType<LineArcCircularArc2D>(split[0]).SweepAngleRadians, 12);+ }++ [Fact]+ public void ArcArcIntersection_IsBoundedByAuthoredSweeps()+ {+ var a = new LineArcCircularArc2D((0, 0), 5, 0, Math.PI);+ var b = new LineArcCircularArc2D((6, 0), 5, Math.PI, -Math.PI);+ var result = ProfileArrangementBuilder.IntersectBounded(a, b);+ Assert.Single(result.Intersections);+ Assert.False(result.IsCoincident);+ }++ [Fact]+ public void ConvexAndConcaveLineChains_OffsetWithExplicitSide()+ {+ var square = PlanarContourKernel.FromPolygon("Square", "XY", [(0, 0), (10, 0), (10, 10), (0, 10)], "test");+ var inset = PlanarContourKernel.Offset(square, 1, PlanarOffsetSide.Left);+ Assert.True(inset.Succeeded, string.Join('\n', inset.Diagnostics.Select(x => x.Message)));+ Assert.True(PlanarContourKernel.Validate(inset.Contour!).IsValid);++ var concave = PlanarContourKernel.FromPolygon("Concave", "XY", [(0, 0), (6, 0), (6, 2), (2, 2), (2, 6), (0, 6)], "test");+ var concaveInset = PlanarContourKernel.Offset(concave, .5, PlanarOffsetSide.Left);+ Assert.True(concaveInset.Succeeded, string.Join('\n', concaveInset.Diagnostics.Select(x => x.Message)));+ }++ [Fact]+ public void CollapsedArcOffset_IsTypedRejection()+ {+ var provenance = new ProfileSegmentProvenance("arc", "Circle", "test", "test", "XY");+ var contour = new PlanarContour2("Circle", "XY", new("Outer", true,+ [+ new("a", new LineArcCircularArc2D((0, 0), 1, 0, Math.PI), provenance),+ new("b", new LineArcCircularArc2D((0, 0), 1, Math.PI, Math.PI), provenance with { StableId = "arc-b" })+ ]), [], "test");+ var result = PlanarContourKernel.Offset(contour, 1, PlanarOffsetSide.Left);+ Assert.False(result.Succeeded);+ Assert.Contains(result.Diagnostics, x => x.Code == "planar-offset-collapsed-arc");+ }++ [Fact]+ public void OuterAndInnerWinding_AreValidated()+ {+ var clockwise = PlanarContourKernel.FromPolygon("ClockwiseNormalized", "XY", [(0, 0), (0, 4), (4, 4), (4, 0)], "test");+ Assert.True(PlanarContourKernel.Validate(clockwise).IsValid); // factory normalizes outer authority+ var reversed = clockwise with { OuterLoop = clockwise.OuterLoop with { Segments = clockwise.OuterLoop.Segments.Reverse().Select(Reverse).ToArray() } };+ var validation = PlanarContourKernel.Validate(reversed);+ Assert.False(validation.IsValid);+ Assert.Contains(validation.Diagnostics, x => x.Code == "planar-contour-winding");++ static PlanarContourSegment2 Reverse(PlanarContourSegment2 segment) => segment.Geometry is LineArcLineSegment2D line+ ? segment with { Geometry = new LineArcLineSegment2D(line.End, line.Start) }+ : throw new NotSupportedException();+ }+}diff --git a/Aetheris.Kernel.Firmament/Materializer/PlanarContour2.cs b/Aetheris.Kernel.Firmament/Materializer/PlanarContour2.csnew file mode 100644index 00000000..3fae68d5--- /dev/null+++ b/Aetheris.Kernel.Firmament/Materializer/PlanarContour2.cs@@ -0,0 +1,264 @@+namespace Aetheris.Kernel.Firmament.Materializer;++/// <summary>+/// Exact planar material contour shared by resolved Profiles and domain lowerers.+/// Topology is ordered and authored; this type is intentionally not a sketch solver+/// or an arbitrary boolean API.+/// </summary>+public sealed record PlanarContourSegment2(+ string StableId,+ LineArcProfileCurve2D Geometry,+ ProfileSegmentProvenance Provenance);++public sealed record PlanarContourLoop2(+ string StableId,+ bool IsOuter,+ IReadOnlyList<PlanarContourSegment2> Segments);++public sealed record PlanarContour2(+ string StableId,+ string PlaneFrame,+ PlanarContourLoop2 OuterLoop,+ IReadOnlyList<PlanarContourLoop2> InnerLoops,+ string Provenance)+{+ public IReadOnlyList<PlanarContourLoop2> Loops => [OuterLoop, .. InnerLoops];+}++public enum PlanarContourDiagnosticSeverity { Information, Warning, Error }+public sealed record PlanarContourDiagnostic(string Code, PlanarContourDiagnosticSeverity Severity, string Message, string? SubjectId = null);+public sealed record PlanarContourValidation(bool IsValid, IReadOnlyList<PlanarContourDiagnostic> Diagnostics);+public enum PlanarOffsetSide { Left, Right }+public sealed record PlanarContourOperationResult(PlanarContour2? Contour, IReadOnlyList<PlanarContourDiagnostic> Diagnostics)+{+ public bool Succeeded => Contour is not null && Diagnostics.All(x => x.Severity != PlanarContourDiagnosticSeverity.Error);+}++/// <summary>Bounded exact line/arc contour operations under known-topology authority.</summary>+public static class PlanarContourKernel+{+ private const double Tol = 1e-7;++ public static PlanarContour2 FromResolvedProfile(ResolvedProfile2D profile, string? provenance = null)+ {+ ArgumentNullException.ThrowIfNull(profile);+ var outer = profile.Loops.Single(x => x.IsOuter);+ PlanarContourLoop2 Convert(ResolvedProfileLoop2D loop) => new(loop.Name, loop.IsOuter,+ loop.Segments.Select(x => new PlanarContourSegment2(x.Provenance.StableId, x.Geometry, x.Provenance)).ToArray());+ return new(profile.Name, profile.PlaneFrame, Convert(outer), profile.Loops.Where(x => !x.IsOuter).Select(Convert).ToArray(), provenance ?? $"ResolvedProfile2D:{profile.Name}");+ }++ public static ResolvedProfile2D ToResolvedProfile(PlanarContour2 contour, string? name = null)+ {+ ArgumentNullException.ThrowIfNull(contour);+ ResolvedProfileLoop2D Convert(PlanarContourLoop2 loop) => new(loop.StableId, loop.IsOuter,+ loop.Segments.Select(x => new ResolvedProfileSegment2D(x.StableId, x.Geometry, x.Provenance)).ToArray());+ return new(name ?? contour.StableId, contour.PlaneFrame, contour.Loops.Select(Convert).ToArray());+ }++ public static PlanarContourValidation Validate(PlanarContour2 contour)+ {+ ArgumentNullException.ThrowIfNull(contour);+ var diagnostics = new List<PlanarContourDiagnostic>();+ var ids = new HashSet<string>(StringComparer.Ordinal);+ foreach (var loop in contour.Loops)+ {+ if (loop.Segments.Count == 0)+ {+ diagnostics.Add(new("planar-contour-empty-loop", PlanarContourDiagnosticSeverity.Error, $"Loop '{loop.StableId}' has no boundary segments.", loop.StableId));+ continue;+ }+ if (loop.Segments.Count == 1 && loop.Segments[0].Geometry is LineArcFullCircle2D circle)+ {+ if (!Finite(circle.Center) || !double.IsFinite(circle.Radius) || circle.Radius <= Tol)+ diagnostics.Add(new("planar-contour-invalid-circle", PlanarContourDiagnosticSeverity.Error, $"Loop '{loop.StableId}' has an invalid full circle.", loop.StableId));+ continue;+ }+ if (loop.Segments.Count < 2)+ diagnostics.Add(new("planar-contour-open-loop", PlanarContourDiagnosticSeverity.Error, $"Loop '{loop.StableId}' is not a closed bounded chain.", loop.StableId));+ for (var i = 0; i < loop.Segments.Count; i++)+ {+ var segment = loop.Segments[i];+ if (!ids.Add(segment.StableId)) diagnostics.Add(new("planar-contour-duplicate-id", PlanarContourDiagnosticSeverity.Error, $"Segment stable ID '{segment.StableId}' is duplicated.", segment.StableId));+ if (!TryEnds(segment.Geometry, out var start, out var end) || !Finite(start) || !Finite(end))+ {+ diagnostics.Add(new("planar-contour-unsupported-curve", PlanarContourDiagnosticSeverity.Error, $"Segment '{segment.StableId}' is not a finite bounded line or circular arc.", segment.StableId));+ continue;+ }+ var negligible = segment.Geometry is LineArcCircularArc2D boundedArc+ ? boundedArc.Radius <= Tol || Math.Abs(boundedArc.SweepAngleRadians) * boundedArc.Radius <= Tol+ : Distance(start, end) <= Tol;+ if (negligible)+ diagnostics.Add(new("planar-contour-zero-length", PlanarContourDiagnosticSeverity.Error, $"Segment '{segment.StableId}' has negligible length.", segment.StableId));+ var next = loop.Segments[(i + 1) % loop.Segments.Count];+ if (TryEnds(next.Geometry, out var nextStart, out _) && Distance(end, nextStart) > Tol)+ diagnostics.Add(new("planar-contour-endpoint-mismatch", PlanarContourDiagnosticSeverity.Error, $"Endpoint authority mismatch '{segment.StableId}' -> '{next.StableId}' ({Distance(end, nextStart):G6}).", segment.StableId));+ }+ for (var i = 0; i < loop.Segments.Count; i++) for (var j = i + 1; j < loop.Segments.Count; j++)+ {+ if (Adjacent(i, j, loop.Segments.Count)) continue;+ var hit = ProfileArrangementBuilder.IntersectBounded(loop.Segments[i].Geometry, loop.Segments[j].Geometry);+ if (hit.HasBoundedOverlap || hit.Intersections.Count > 0)+ {+ var detail=hit.Intersections.Count==0?"positive bounded coincident overlap":string.Join(", ",hit.Intersections.Select(x=>$"({x.Point.X:G6},{x.Point.Y:G6}) t={x.FirstParameter:G4}/{x.SecondParameter:G4}"));+ diagnostics.Add(new("planar-contour-self-intersection", PlanarContourDiagnosticSeverity.Error, $"Non-adjacent segments '{loop.Segments[i].StableId}' and '{loop.Segments[j].StableId}' intersect: {detail}.", loop.StableId));+ }+ }+ var area = SignedArea(loop);+ if (Math.Abs(area) <= Tol) diagnostics.Add(new("planar-contour-zero-area", PlanarContourDiagnosticSeverity.Error, $"Loop '{loop.StableId}' has negligible signed area.", loop.StableId));+ else if (loop.IsOuter && area < 0d || !loop.IsOuter && area > 0d)+ diagnostics.Add(new("planar-contour-winding", PlanarContourDiagnosticSeverity.Error, $"Loop '{loop.StableId}' winding must be {(loop.IsOuter ? "counter-clockwise" : "clockwise")}.", loop.StableId));+ }+ foreach (var inner in contour.InnerLoops)+ {+ var probe = PointAt(inner.Segments[0].Geometry, 0.5d);+ if (!PointInLoop(contour.OuterLoop, probe))+ diagnostics.Add(new("planar-contour-inner-outside", PlanarContourDiagnosticSeverity.Error, $"Inner loop '{inner.StableId}' is not inside outer loop '{contour.OuterLoop.StableId}'.", inner.StableId));+ }+ return new(!diagnostics.Any(x => x.Severity == PlanarContourDiagnosticSeverity.Error), diagnostics);+ }++ /// <summary>+ /// Offsets a known closed line/arc chain and resolves each neighboring support+ /// intersection as a miter. Collapsed arcs and ambiguous/self-intersecting results+ /// are rejected with typed diagnostics; no repair is applied.+ /// </summary>+ public static PlanarContourOperationResult Offset(PlanarContour2 contour, double distance, PlanarOffsetSide side)+ {+ ArgumentNullException.ThrowIfNull(contour);+ if (!double.IsFinite(distance) || distance <= Tol)+ return Fail("planar-offset-invalid-distance", "Offset distance must be finite and positive.", contour.StableId);+ if (contour.InnerLoops.Count > 0)+ return Fail("planar-offset-inner-loops-deferred", "One-call offset of a contour with inner loops is outside the bounded offset contract; offset each loop with an explicit side.", contour.StableId);+ var source = contour.OuterLoop.Segments;+ if (source.Count < 2 || source.Any(x => x.Geometry is not LineArcLineSegment2D and not LineArcCircularArc2D))+ return Fail("planar-offset-unsupported-curve", "Offset supports closed line/circular-arc chains.", contour.StableId);+ var signed = side == PlanarOffsetSide.Left ? distance : -distance;+ var supports = new List<LineArcProfileCurve2D>();+ foreach (var segment in source)+ {+ switch (segment.Geometry)+ {+ case LineArcLineSegment2D line:+ var dx = line.End.X - line.Start.X; var dy = line.End.Y - line.Start.Y; var length = Math.Sqrt(dx * dx + dy * dy);+ if (length <= Tol) return Fail("planar-offset-collapsed-segment", $"Segment '{segment.StableId}' is too short to offset.", segment.StableId);+ var n = (X: -dy / length * signed, Y: dx / length * signed);+ supports.Add(new LineArcLineSegment2D((line.Start.X + n.X, line.Start.Y + n.Y), (line.End.X + n.X, line.End.Y + n.Y)));+ break;+ case LineArcCircularArc2D arc:+ var radius = arc.Radius - Math.Sign(arc.SweepAngleRadians) * signed;+ if (radius <= Tol) return Fail("planar-offset-collapsed-arc", $"Offset collapses arc '{segment.StableId}' (result radius {radius:G6}).", segment.StableId);+ supports.Add(arc with { Radius = radius });+ break;+ }+ }+ var junctions = new (double X, double Y)[supports.Count];+ for (var i = 0; i < supports.Count; i++)+ {+ var previous = (i + supports.Count - 1) % supports.Count;+ var authoredVertex = TryEnds(source[i].Geometry, out var currentStart, out _) ? currentStart : default;+ var candidates = IntersectSupports(supports[previous], supports[i]);+ if (candidates.Count == 0) return Fail("planar-offset-disconnected-corner", $"Offset supports at corner '{source[i].StableId}' do not intersect.", source[i].StableId);+ junctions[i] = candidates.OrderBy(x => Distance(x, authoredVertex)).First();+ }+ var resultSegments = new List<PlanarContourSegment2>();+ for (var i = 0; i < supports.Count; i++)+ {+ var geometry = WithEndpoints(supports[i], junctions[i], junctions[(i + 1) % supports.Count]);+ if (geometry is null) return Fail("planar-offset-impossible-trim", $"Offset segment '{source[i].StableId}' could not be trimmed to its resolved corner intersections.", source[i].StableId);+ resultSegments.Add(source[i] with { StableId = $"{source[i].StableId}.offset", Geometry = geometry, Provenance = source[i].Provenance with { StableId = $"{source[i].Provenance.StableId}.offset", Derivation = $"offset:{side}:{distance:R}" } });+ }+ var result = contour with { StableId = $"{contour.StableId}.offset", OuterLoop = contour.OuterLoop with { StableId = $"{contour.OuterLoop.StableId}.offset", Segments = resultSegments }, Provenance = $"{contour.Provenance}; offset {side} {distance:R}" };+ var validation = Validate(result);+ return validation.IsValid ? new(result, validation.Diagnostics) : new(null, validation.Diagnostics.Prepend(new("planar-offset-invalid-result", PlanarContourDiagnosticSeverity.Error, "Offset result violates closed-contour topology; no repair was applied.", contour.StableId)).ToArray());+ }++ public static PlanarContour2 FromPolygon(string stableId, string frame, IReadOnlyList<(double X, double Y)> points, string provenance)+ {+ ArgumentNullException.ThrowIfNull(points);+ var clean = points.Aggregate(new List<(double X, double Y)>(), (list, point) => { if (list.Count == 0 || Distance(list[^1], point) > Tol) list.Add(point); return list; });+ if (clean.Count > 1 && Distance(clean[0], clean[^1]) <= Tol) clean.RemoveAt(clean.Count - 1);+ if (PolygonArea(clean) < 0d) clean.Reverse();+ var segments = clean.Select((point, index) => new PlanarContourSegment2($"{stableId}.edge{index:D3}", new LineArcLineSegment2D(point, clean[(index + 1) % clean.Count]), new($"{stableId}.edge{index:D3}", stableId, stableId, provenance, frame))).ToArray();+ return new(stableId, frame, new($"{stableId}.outer", true, segments), [], provenance);+ }++ private static PlanarContourOperationResult Fail(string code, string message, string subject) => new(null, [new(code, PlanarContourDiagnosticSeverity.Error, message, subject)]);+ private static bool Adjacent(int i, int j, int count) => j == i + 1 || i == 0 && j == count - 1;+ private static bool Finite((double X, double Y) p) => double.IsFinite(p.X) && double.IsFinite(p.Y);+ private static double Distance((double X, double Y) a, (double X, double Y) b) => Math.Sqrt((a.X - b.X) * (a.X - b.X) + (a.Y - b.Y) * (a.Y - b.Y));+ private static double PolygonArea(IReadOnlyList<(double X, double Y)> points) { var sum = 0d; for (var i = 0; i < points.Count; i++) { var q = points[(i + 1) % points.Count]; sum += points[i].X * q.Y - q.X * points[i].Y; } return sum / 2d; }+ private static double SignedArea(PlanarContourLoop2 loop) => loop.Segments.Sum(x => x.Geometry switch+ {+ LineArcLineSegment2D line => line.Start.X * line.End.Y - line.End.X * line.Start.Y,+ LineArcCircularArc2D arc => ArcArea(arc),+ LineArcFullCircle2D circle => 2d * Math.PI * circle.Radius * circle.Radius,+ _ => 0d+ }) / 2d;+ private static double ArcArea(LineArcCircularArc2D arc) { var a = arc.StartAngleRadians; var b = a + arc.SweepAngleRadians; return arc.Center.X * arc.Radius * (Math.Sin(b) - Math.Sin(a)) - arc.Center.Y * arc.Radius * (Math.Cos(b) - Math.Cos(a)) + arc.Radius * arc.Radius * (b - a); }+ private static bool TryEnds(LineArcProfileCurve2D curve, out (double X, double Y) start, out (double X, double Y) end)+ {+ switch (curve)+ {+ case LineArcLineSegment2D line: start = line.Start; end = line.End; return true;+ case LineArcCircularArc2D arc: start = PointAt(arc, 0d); end = PointAt(arc, 1d); return true;+ default: start = end = default; return false;+ }+ }+ private static (double X, double Y) PointAt(LineArcProfileCurve2D curve, double t) => curve switch+ {+ LineArcLineSegment2D line => (line.Start.X + (line.End.X - line.Start.X) * t, line.Start.Y + (line.End.Y - line.Start.Y) * t),+ LineArcCircularArc2D arc => (arc.Center.X + arc.Radius * Math.Cos(arc.StartAngleRadians + arc.SweepAngleRadians * t), arc.Center.Y + arc.Radius * Math.Sin(arc.StartAngleRadians + arc.SweepAngleRadians * t)),+ LineArcFullCircle2D circle => (circle.Center.X + circle.Radius * Math.Cos(2d * Math.PI * t), circle.Center.Y + circle.Radius * Math.Sin(2d * Math.PI * t)),+ _ => throw new NotSupportedException()+ };+ private static bool PointInLoop(PlanarContourLoop2 loop, (double X, double Y) point)+ {+ var samples = loop.Segments.SelectMany(x => x.Geometry switch+ {+ LineArcLineSegment2D line => new[] { line.Start },+ LineArcCircularArc2D arc => Enumerable.Range(0, Math.Max(2, (int)Math.Ceiling(Math.Abs(arc.SweepAngleRadians) / (Math.PI / 24d)))).Select(i => PointAt(arc, (double)i / Math.Max(2, (int)Math.Ceiling(Math.Abs(arc.SweepAngleRadians) / (Math.PI / 24d))))),+ LineArcFullCircle2D circle => Enumerable.Range(0, 96).Select(i => PointAt(circle, i / 96d)),+ _ => []+ }).ToArray();+ var inside = false; for (var i = 0; i < samples.Length; i++) { var a = samples[i]; var b = samples[(i + 1) % samples.Length]; if ((a.Y > point.Y) != (b.Y > point.Y) && point.X < (b.X - a.X) * (point.Y - a.Y) / (b.Y - a.Y) + a.X) inside = !inside; } return inside;+ }+ private static IReadOnlyList<(double X, double Y)> IntersectSupports(LineArcProfileCurve2D a, LineArcProfileCurve2D b)+ {+ if (a is LineArcLineSegment2D la && b is LineArcLineSegment2D lb)+ {+ var r = (X: la.End.X - la.Start.X, Y: la.End.Y - la.Start.Y); var s = (X: lb.End.X - lb.Start.X, Y: lb.End.Y - lb.Start.Y); var cross = r.X * s.Y - r.Y * s.X;+ if (Math.Abs(cross) <= Tol) return [];+ var d = (X: lb.Start.X - la.Start.X, Y: lb.Start.Y - la.Start.Y); var t = (d.X * s.Y - d.Y * s.X) / cross; return [(la.Start.X + t * r.X, la.Start.Y + t * r.Y)];+ }+ if (a is LineArcLineSegment2D lineA && b is LineArcCircularArc2D circleB) return LineCircleSupport(lineA, circleB);+ if (a is LineArcCircularArc2D circleA && b is LineArcLineSegment2D lineB) return LineCircleSupport(lineB, circleA);+ if (a is LineArcCircularArc2D ca && b is LineArcCircularArc2D cb)+ {+ var dx = cb.Center.X - ca.Center.X; var dy = cb.Center.Y - ca.Center.Y; var d = Math.Sqrt(dx * dx + dy * dy);+ if (d <= Tol || d > ca.Radius + cb.Radius + Tol || d < Math.Abs(ca.Radius - cb.Radius) - Tol) return [];+ var x = (ca.Radius * ca.Radius - cb.Radius * cb.Radius + d * d) / (2d * d); var h = Math.Sqrt(Math.Max(0d, ca.Radius * ca.Radius - x * x)); var px = ca.Center.X + x * dx / d; var py = ca.Center.Y + x * dy / d;+ return h <= Tol ? [(px, py)] : [(px - dy * h / d, py + dx * h / d), (px + dy * h / d, py - dx * h / d)];+ }+ return [];+ }+ private static IReadOnlyList<(double X, double Y)> LineCircleSupport(LineArcLineSegment2D line, LineArcCircularArc2D circle)+ {+ var dx = line.End.X - line.Start.X; var dy = line.End.Y - line.Start.Y; var fx = line.Start.X - circle.Center.X; var fy = line.Start.Y - circle.Center.Y; var aa = dx * dx + dy * dy; var bb = 2d * (fx * dx + fy * dy); var cc = fx * fx + fy * fy - circle.Radius * circle.Radius; var disc = bb * bb - 4d * aa * cc;+ if (disc < -Tol || aa <= Tol) return []; var root = Math.Sqrt(Math.Max(0d, disc)); var ts = root <= Tol ? new[] { -bb / (2d * aa) } : new[] { (-bb - root) / (2d * aa), (-bb + root) / (2d * aa) }; return ts.Select(t => (line.Start.X + t * dx, line.Start.Y + t * dy)).ToArray();+ }+ private static LineArcProfileCurve2D? WithEndpoints(LineArcProfileCurve2D support, (double X, double Y) start, (double X, double Y) end)+ {+ if (Distance(start, end) <= Tol) return null;+ if (support is LineArcLineSegment2D) return new LineArcLineSegment2D(start, end);+ if (support is LineArcCircularArc2D arc)+ {+ if (Math.Abs(Distance(start, arc.Center) - arc.Radius) > Tol * 10 || Math.Abs(Distance(end, arc.Center) - arc.Radius) > Tol * 10) return null;+ var a = Math.Atan2(start.Y - arc.Center.Y, start.X - arc.Center.X); var b = Math.Atan2(end.Y - arc.Center.Y, end.X - arc.Center.X); var sweep = b - a;+ if (arc.SweepAngleRadians > 0) while (sweep <= 0d) sweep += 2d * Math.PI; else while (sweep >= 0d) sweep -= 2d * Math.PI;+ if (Math.Abs(sweep) >= 2d * Math.PI - Tol) return null;+ return arc with { StartAngleRadians = a, SweepAngleRadians = sweep };+ }+ return null;+ }+}diff --git a/Aetheris.Kernel.Firmament/Materializer/ProfileArrangement2D.cs b/Aetheris.Kernel.Firmament/Materializer/ProfileArrangement2D.csindex b2f647d1..301b84d5 100644--- a/Aetheris.Kernel.Firmament/Materializer/ProfileArrangement2D.cs+++ b/Aetheris.Kernel.Firmament/Materializer/ProfileArrangement2D.cs@@ -33,6 +33,19 @@ public sealed record ProfileArrangementResult(RegionSet ?? (Region is null ? [] : [Region]);}+/// <summary>A bounded analytic intersection result. Parameters are normalized to each source curve.</summary>+public sealed record PlanarCurveIntersection2(+ (double X, double Y) Point,+ double FirstParameter,+ double SecondParameter,+ bool IsTangent);++public sealed record PlanarCurveIntersectionResult(+ IReadOnlyList<PlanarCurveIntersection2> Intersections,+ bool IsCoincident,+ bool HasBoundedOverlap,+ IReadOnlyList<string> Diagnostics);+public static class ProfileArrangementBuilder{private const double Tol = 1e-7;@@ -42,6 +55,45 @@ public static class ProfileArrangementBuilderprivate const double VertexTol = 1e-5;private const double SideSample = 1e-5;+ /// <summary>+ /// Shared bounded line/arc intersection entry point for Profile, Drawing, and+ /// Sheet Metal construction. It never extends a source curve implicitly.+ /// </summary>+ public static PlanarCurveIntersectionResult IntersectBounded(LineArcProfileCurve2D first, LineArcProfileCurve2D second)+ {+ ArgumentNullException.ThrowIfNull(first);+ ArgumentNullException.ThrowIfNull(second);+ var points = Intersections(first, second, out var coincident, out var tangent);+ var hits = new List<PlanarCurveIntersection2>();+ foreach (var point in points)+ if (OnCurve(first, point, out var a) && OnCurve(second, point, out var b))+ hits.Add(new(point, Math.Clamp(a, 0d, 1d), Math.Clamp(b, 0d, 1d), tangent));+ var diagnostics = coincident ? new[] { "planar-curve-coincident-support" } : [];+ return new(hits.OrderBy(x => x.FirstParameter).ThenBy(x => x.SecondParameter).ToArray(), coincident, coincident&&HasPositiveCoincidentOverlap(first,second), diagnostics);+ }++ /// <summary>Splits a bounded line or circular arc at a known normalized parameter.</summary>+ public static IReadOnlyList<LineArcProfileCurve2D> SplitBounded(LineArcProfileCurve2D curve, double parameter)+ {+ ArgumentNullException.ThrowIfNull(curve);+ if (!double.IsFinite(parameter) || parameter <= Tol || parameter >= 1d - Tol)+ throw new ArgumentOutOfRangeException(nameof(parameter), "Split parameter must lie strictly inside (0, 1).");+ if (curve is not LineArcLineSegment2D and not LineArcCircularArc2D)+ throw new NotSupportedException("Bounded split supports line segments and circular arcs.");+ return [Trim(curve, 0d, parameter), Trim(curve, parameter, 1d)];+ }++ /// <summary>Returns the exact bounded fragment on a normalized parameter interval.</summary>+ public static LineArcProfileCurve2D TrimBounded(LineArcProfileCurve2D curve, double fromParameter, double toParameter)+ {+ ArgumentNullException.ThrowIfNull(curve);+ if (!double.IsFinite(fromParameter) || !double.IsFinite(toParameter) || fromParameter < -Tol || toParameter > 1d + Tol || toParameter - fromParameter <= Tol)+ throw new ArgumentOutOfRangeException(nameof(fromParameter), "Trim interval must be a positive subset of [0, 1].");+ if (curve is not LineArcLineSegment2D and not LineArcCircularArc2D)+ throw new NotSupportedException("Bounded trim supports line segments and circular arcs.");+ return Trim(curve, Math.Clamp(fromParameter, 0d, 1d), Math.Clamp(toParameter, 0d, 1d));+ }+public static ProfileArrangementResult Compose(string frame,IReadOnlyList<PrismaticProfileOperation> active,diff --git a/Aetheris.SheetMetal.Tests/SheetMetalM3Tests.cs b/Aetheris.SheetMetal.Tests/SheetMetalM3Tests.csindex b3f3bacb..6d8309aa 100644--- a/Aetheris.SheetMetal.Tests/SheetMetalM3Tests.cs+++ b/Aetheris.SheetMetal.Tests/SheetMetalM3Tests.cs@@ -30,7 +30,7 @@ public sealed class SheetMetalM3Tests[InlineData("",SheetCornerPolicy.Open,null)][InlineData("Corner: Miter;",SheetCornerPolicy.Mitered,null)][InlineData("Relief: Rectangular;",SheetCornerPolicy.Relief,SheetReliefKind.Rectangular)]- [InlineData("Relief: Round;",SheetCornerPolicy.Relief,SheetReliefKind.Round)]+ [InlineData("Relief: Round;",SheetCornerPolicy.RoundRelief,SheetReliefKind.Round)]public void AdjacentCornerPolicies_AreTypedAndLowered(string policy,SheetCornerPolicy expected,SheetReliefKind? reliefKind){var source=$$"""diff --git a/Aetheris.SheetMetal.Tests/SheetMetalM4Tests.cs b/Aetheris.SheetMetal.Tests/SheetMetalM4Tests.csnew file mode 100644index 00000000..259b9be0--- /dev/null+++ b/Aetheris.SheetMetal.Tests/SheetMetalM4Tests.cs@@ -0,0 +1,106 @@+using Aetheris.Kernel.Firmament.Materializer;+using Xunit;++namespace Aetheris.SheetMetal.Tests;++public sealed class SheetMetalM4Tests+{+ private static readonly string RepoRoot=FindRepoRoot();+ [Fact]+ public void AuthoredFlatCarriesValidatedExactBlankRegionsAndAnalyticCut()+ {+ var result=SheetMetalFirmament.Compile("""+ SheetMetal ExactFlat { Thickness: 1mm; Base Main { Profile: Rectangle { Width: 60mm; Height: 40mm; }; }+ Flange FrontWall { From: Main.Front; Height: 12mm; Angle: 90deg; Radius: 1mm; }+ Hole Mount { On: Main; Center: (30mm, 20mm); Diameter: 4mm; }+ }+ """);+ Assert.True(result.IsSuccess,string.Join('\n',result.Diagnostics.Select(x=>x.Message)));+ var flat=result.FlatPattern!;Assert.True(flat.ExactBlankContour is not null,string.Join('\n',flat.Diagnostics.Select(x=>$"{x.Code}: {x.Message}")));var blankValidation=PlanarContourKernel.Validate(flat.ExactBlankContour!);Assert.True(blankValidation.IsValid,string.Join('\n',blankValidation.Diagnostics.Select(x=>$"{x.Code}: {x.Message}")));+ Assert.All(flat.Regions2D,x=>Assert.NotNull(x.ExactContour));+ var cut=Assert.Single(flat.CutLoops);Assert.NotNull(cut.ExactContour);Assert.All(cut.ExactContour!.OuterLoop.Segments,x=>Assert.IsType<LineArcCircularArc2D>(x.Geometry));+ Assert.True(SheetMetalFlatPatternValidation.Validate(flat).ExactContoursValid);+ Assert.True(SheetMetalManufacturingArtifacts.BuildFlatBody(result.Part!,flat).IsSuccess);+ Assert.Contains("exact-blank-contour",SheetMetalSvgRenderer.Render(flat),StringComparison.Ordinal);+ }++ [Theory]+ [InlineData("Rectangular",SheetCornerPolicy.RectangularRelief,typeof(LineArcLineSegment2D))]+ [InlineData("Round",SheetCornerPolicy.RoundRelief,typeof(LineArcCircularArc2D))]+ public void ReliefPoliciesCutExactBlankAndManufacturingBody(string relief,SheetCornerPolicy policy,Type expectedCurve)+ {+ var result=SheetMetalFirmament.Compile($$"""+ SheetMetal ReliefCase { Thickness: 1mm; Base Main { Profile: Rectangle { Width: 50mm; Height: 40mm; }; }+ Flange Front { From: Main.Front; Height: 12mm; Angle: 90deg; Radius: 1mm; Relief: {{relief}}; }+ Flange Right { From: Main.Right; Height: 12mm; Angle: 90deg; Radius: 1mm; Relief: {{relief}}; }+ }+ """);+ Assert.True(result.IsSuccess,string.Join('\n',result.Diagnostics.Select(x=>x.Message)));Assert.Equal(policy,Assert.Single(result.Part!.Corners!).Policy);+ var flat=result.FlatPattern!;var loop=Assert.Single(flat.ReliefLoops!);Assert.Contains(loop.ExactContour.OuterLoop.Segments,x=>x.Geometry.GetType()==expectedCurve);Assert.True(flat.ExactBlankContour is not null,string.Join('\n',flat.Diagnostics.Select(x=>$"{x.Code}: {x.Message}")));+ Assert.True(PlanarContourKernel.Validate(loop.ExactContour).IsValid);Assert.True(SheetMetalManufacturingArtifacts.BuildFlatBody(result.Part,flat).IsSuccess);+ }++ [Fact]+ public void CanonicalPathsExposeBaseFlangeNestedBendAndFlatCorrespondence()+ {+ var source="""+ SheetMetal Chained { Thickness: 1mm; Base Main { Profile: Rectangle { Width: 50mm; Height: 30mm; }; }+ Flange FrontWall { From: Main.Front; Height: 12mm; Angle: 90deg; Radius: 1mm; }+ Flange Lip { From: FrontWall.Outer; Height: 5mm; Angle: 45deg; Radius: 1mm; Direction: Down; }+ }+ """;+ var result=SheetMetalFirmament.Compile(source);Assert.True(result.IsSuccess,string.Join('\n',result.Diagnostics.Select(x=>x.Message)));+ var paths=SheetMetalConceptPaths.Inspect(result.Spec!,result.Part!,result.FlatPattern!);+ Assert.Contains(paths,x=>x.Path=="Main.Front"&&x.Capabilities.Contains("FlangeAttachable"));+ Assert.Contains(paths,x=>x.Path=="FrontWall.Outer"&&x.Capabilities.Contains("FlangeAttachable"));+ Assert.Contains(paths,x=>x.Path=="FrontWall.Bend"&&x.FormedId=="FrontWallBend");+ Assert.Contains(paths,x=>x.Path=="Flat.FrontWall.Bend"&&x.FlatId=="flat-FrontWallBend");+ }++ [Theory]+ [InlineData("Main.Center","sheetmetal-incompatible-edge-capability","PointCapable")]+ [InlineData("Main.InnerFace","sheetmetal-concept-member-not-exposed","Available public members")]+ [InlineData("Wall.InnerFace","sheetmetal-concept-member-not-exposed","Root, Outer, Left, Right")]+ public void InvalidSemanticMemberDiagnostics_TeachPublicSurface(string from,string code,string message)+ {+ var source=$$"""+ SheetMetal BadPath { Thickness: 1mm; Base Main { Profile: Rectangle { Width: 30mm; Height: 20mm; }; }+ Flange Wall { From: {{from}}; Height: 8mm; Angle: 90deg; Radius: 1mm; }+ }+ """;+ var result=SheetMetalFirmament.Compile(source);Assert.False(result.IsSuccess);Assert.Contains(result.Diagnostics,x=>x.Code==code&&x.Message.Contains(message,StringComparison.Ordinal));+ }++ [Fact]+ public void ModuleTemplatesLowerThroughOrdinarySemanticsAndKeepPathShape()+ {+ var policy=new SheetMetalTemplatePolicy(1.2,1.5,.42,"5052-H32",SheetCornerPolicy.Mitered,SheetReliefPolicy.None);+ var l=SheetMetalFirmament.Compile(SheetMetalTemplates.LBracket("L",new(40,30,12,policy)));+ var u=SheetMetalFirmament.Compile(SheetMetalTemplates.UChannel("U",new(50,30,15,policy)));+ var a=SheetMetalFirmament.Compile(SheetMetalTemplates.FourWallTray("TrayA",new(80,60,18,policy)));+ var b=SheetMetalFirmament.Compile(SheetMetalTemplates.FourWallTray("TrayB",new(120,90,25,policy)));+ Assert.True(l.IsSuccess);Assert.True(u.IsSuccess);Assert.True(a.IsSuccess,string.Join('\n',a.Diagnostics.Select(x=>x.Message)));Assert.True(b.IsSuccess);+ Assert.Single(l.Part!.Bends);Assert.Equal(2,u.Part!.Bends.Count);Assert.Equal(4,a.Part!.Bends.Count);Assert.NotNull(a.FlatPattern!.ExactBlankContour);+ var shapeA=SheetMetalConceptPaths.Inspect(a.Spec!,a.Part!,a.FlatPattern!).Select(x=>x.Path).ToArray();var shapeB=SheetMetalConceptPaths.Inspect(b.Spec!,b.Part!,b.FlatPattern!).Select(x=>x.Path).ToArray();+ Assert.Equal(shapeA,shapeB);Assert.Equal(SheetMetalDfmStatus.Pass,SheetMetalDfm.Evaluate(a.Part,a.FlatPattern).Overall);+ }++ [Fact]+ public void LlmPsuEnclosure_UsesOnlyHighLevelPathsAndProducesExactArtifacts()+ {+ var path=Path.Combine(RepoRoot,"fixtures/FirmamentV2/SheetMetal/m4-psu-enclosure.firmament");var source=File.ReadAllText(path);var result=SheetMetalFirmament.CompileFile(path);+ Assert.True(result.IsSuccess,string.Join('\n',result.Diagnostics.Select(x=>x.Message)));Assert.DoesNotContain("region-",source,StringComparison.OrdinalIgnoreCase);Assert.DoesNotContain("face-",source,StringComparison.OrdinalIgnoreCase);Assert.DoesNotContain("edge-",source,StringComparison.OrdinalIgnoreCase);+ Assert.Equal(5,result.Part!.Bends.Count);Assert.Equal(7,result.Part.Features.Count);Assert.True(result.FlatPattern!.ExactBlankContour is not null,string.Join('\n',result.FlatPattern.Diagnostics.Select(x=>$"{x.Code}: {x.Message}")));Assert.Equal(4,result.Part.Corners!.Count);Assert.Contains(result.Part.Corners,x=>x.Policy==SheetCornerPolicy.Mitered);Assert.Contains(result.Part.Corners,x=>x.Policy==SheetCornerPolicy.Open);+ var paths=SheetMetalConceptPaths.Inspect(result.Spec!,result.Part,result.FlatPattern);Assert.Contains(paths,x=>x.Path=="FrontWall.Outer");Assert.Contains(paths,x=>x.Path=="FrontLip.Bend");+ Assert.True(SheetMetalManufacturingArtifacts.BuildFlatBody(result.Part,result.FlatPattern).IsSuccess);+ }++ [Fact]+ public void SemanticDfmRepairFixture_ConvergesWithoutBrepIds()+ {+ var bad=SheetMetalFirmament.CompileFile(Path.Combine(RepoRoot,"fixtures/FirmamentV2/SheetMetal/m4-bad-tray-dfm.firmament"));var fixedPart=SheetMetalFirmament.CompileFile(Path.Combine(RepoRoot,"fixtures/FirmamentV2/SheetMetal/m4-fixed-tray-dfm.firmament"));Assert.True(bad.IsSuccess);Assert.True(fixedPart.IsSuccess);+ var before=SheetMetalDfm.Evaluate(bad.Part!,bad.FlatPattern);var after=SheetMetalDfm.Evaluate(fixedPart.Part!,fixedPart.FlatPattern);Assert.Equal(SheetMetalDfmStatus.Warning,before.Overall);Assert.Contains(before.Findings,x=>x.RuleId=="sheetmetal-dfm-corner-resolution"&&x.SuggestedFix is not null);Assert.Equal(SheetMetalDfmStatus.Pass,after.Overall);+ }++ private static string FindRepoRoot(){var dir=new DirectoryInfo(AppContext.BaseDirectory);while(dir is not null&&!File.Exists(Path.Combine(dir.FullName,"Aetheris.slnx")))dir=dir.Parent;return dir?.FullName??throw new InvalidOperationException("Repo root not found.");}+}diff --git a/Aetheris.SheetMetal/SheetMetalAuthoredLowering.cs b/Aetheris.SheetMetal/SheetMetalAuthoredLowering.csindex c0243c7d..1a8c089e 100644--- a/Aetheris.SheetMetal/SheetMetalAuthoredLowering.cs+++ b/Aetheris.SheetMetal/SheetMetalAuthoredLowering.cs@@ -66,11 +66,19 @@ internal static class AuthoredSheetMetalCompilervar flanges = new List<AuthoredSheetFlangeSpec>();foreach (var block in Blocks(source, "Flange")){- var from = Regex.Match(block.Body, @"\bFrom\s*:\s*(?<region>[A-Za-z_][A-Za-z0-9_]*)\.(?<edge>Left|Right|Front|Rear|Outer|Top)\s*;", Rx);+ var from = Regex.Match(block.Body, @"\bFrom\s*:\s*(?<region>[A-Za-z_][A-Za-z0-9_]*)\.(?<edge>[A-Za-z_][A-Za-z0-9_]*)\s*;", Rx);var hasLength = Scalar(block.Body, "Length", "mm", out var length) || Scalar(block.Body, "Height", "mm", out length);var hasRadius = Scalar(block.Body, "InsideRadius", "mm", out var radius) || Scalar(block.Body, "Radius", "mm", out radius);if (!from.Success || !hasLength || !Scalar(block.Body, "Angle", "deg", out var degrees) || !hasRadius)return Fail($"Flange '{block.Name}' requires From, Length/Height, Angle, and InsideRadius/Radius.");+ var parentName=from.Groups["region"].Value;var authoredMember=from.Groups["edge"].Value;+ if(parentName.Equals(baseSpec.Name,StringComparison.OrdinalIgnoreCase)&&authoredMember.Equals("Center",StringComparison.OrdinalIgnoreCase))+ return Fail($"`{parentName}.Center` has capability PointCapable; `Flange.From` requires FlangeAttachable SheetEdge. Available public edge members: Front, Right, Rear, Left.","sheetmetal-incompatible-edge-capability");+ var available=parentName.Equals(baseSpec.Name,StringComparison.OrdinalIgnoreCase)?SheetMetalConceptPaths.AvailableMembers("SheetRegion.Rectangle"):SheetMetalConceptPaths.AvailableMembers("SheetFlange");+ var allowed=parentName.Equals(baseSpec.Name,StringComparison.OrdinalIgnoreCase)+ ? new[]{"Front","Right","Rear","Left"}.Contains(authoredMember,StringComparer.OrdinalIgnoreCase)+ : new[]{"Outer","Top"}.Contains(authoredMember,StringComparer.OrdinalIgnoreCase);+ if(!allowed)return Fail($"`{parentName}.{authoredMember}` is not a FlangeAttachable public member. Available public members: {string.Join(", ",available)}.","sheetmetal-concept-member-not-exposed");var direction = Token(block.Body, "Direction")?.Equals("Down", StringComparison.OrdinalIgnoreCase) == true ? SheetBendDirection.Down : SheetBendDirection.Up;var corner = Token(block.Body, "Corner")?.ToLowerInvariant() switch{@@ -82,9 +90,9 @@ internal static class AuthoredSheetMetalCompilervar relief = reliefToken switch { "auto" => SheetReliefPolicy.Auto, "rectangular" or "rectangle" => SheetReliefPolicy.Rectangular, "round" => SheetReliefPolicy.Round, _ => SheetReliefPolicy.None };Scalar(block.Body, "ReliefWidth", "mm", out var reliefWidth);Scalar(block.Body, "ReliefDepth", "mm", out var reliefDepth);- if (length <= radius + thickness || radius < 0 || degrees is <= 0 or >= 180)- return Fail($"Flange '{block.Name}' has an invalid length, radius, or bend angle.");- flanges.Add(new(block.Name, from.Groups["region"].Value, NormalizeEdge(from.Groups["edge"].Value), length,+ if(radius<0||degrees is <=0 or >=180)return Fail($"Flange '{block.Name}' has an invalid radius or bend angle.");+ if(length<=radius+thickness)return Fail($"Flange '{block.Name}' length {length:G6} mm is not greater than inside radius + thickness ({radius+thickness:G6} mm). Increase `{block.Name}` Height/Length above {radius+thickness:G6} mm.",legacyBase.Success?"sheetmetal-firmament-invalid":SheetMetalDiagnosticCodes.FlangeBelowMinimum);+ flanges.Add(new(block.Name, parentName, NormalizeEdge(authoredMember), length,degrees * Math.PI / 180d, radius, direction, corner, relief,reliefWidth > 0 ? reliefWidth : null, reliefDepth > 0 ? reliefDepth : null));}@@ -300,12 +308,14 @@ internal static class AuthoredSheetMetalLoweringvar a = spec.Flanges.FirstOrDefault(f => f.ParentRegion.Equals(spec.Base.Name, StringComparison.OrdinalIgnoreCase) && f.EdgeName.Equals(edgeOrder[i], StringComparison.OrdinalIgnoreCase));var b = spec.Flanges.FirstOrDefault(f => f.ParentRegion.Equals(spec.Base.Name, StringComparison.OrdinalIgnoreCase) && f.EdgeName.Equals(edgeOrder[(i+1)%4], StringComparison.OrdinalIgnoreCase));if (a is null || b is null) continue;+ var reliefOwner=a.ReliefPolicy!=SheetReliefPolicy.None?a:b.ReliefPolicy!=SheetReliefPolicy.None?b:null;var policy = a.CornerPolicy == SheetCornerPolicy.Mitered && b.CornerPolicy == SheetCornerPolicy.Mitered ? SheetCornerPolicy.Mitered :- a.ReliefPolicy != SheetReliefPolicy.None || b.ReliefPolicy != SheetReliefPolicy.None ? SheetCornerPolicy.Relief : SheetCornerPolicy.Open;+ reliefOwner?.ReliefPolicy==SheetReliefPolicy.Round?SheetCornerPolicy.RoundRelief:+ reliefOwner is not null?SheetCornerPolicy.RectangularRelief:SheetCornerPolicy.Open;var id = $"corner-{a.Name}-{b.Name}"; string? reliefId = null;- if (policy == SheetCornerPolicy.Relief)+ if (policy is SheetCornerPolicy.RectangularRelief or SheetCornerPolicy.RoundRelief){- reliefId = $"relief-{a.Name}-{b.Name}"; var owner = a.ReliefPolicy != SheetReliefPolicy.None ? a : b;+ reliefId = $"relief-{a.Name}-{b.Name}"; var owner = reliefOwner!;var width = owner.ReliefWidth ?? Math.Max(t, 0.5 * t); var depth = owner.ReliefDepth ?? owner.InsideRadius + t;var kind = owner.ReliefPolicy == SheetReliefPolicy.Round ? SheetReliefKind.Round : SheetReliefKind.Rectangular;reliefs.Add(new(reliefId, kind, spec.Base.Name, id, width, depth, kind == SheetReliefKind.Round ? width/2 : null, owner.ReliefWidth is null || owner.ReliefDepth is null, source,diff --git a/Aetheris.SheetMetal/SheetMetalConceptPaths.cs b/Aetheris.SheetMetal/SheetMetalConceptPaths.csnew file mode 100644index 00000000..fb22fcba--- /dev/null+++ b/Aetheris.SheetMetal/SheetMetalConceptPaths.cs@@ -0,0 +1,49 @@+namespace Aetheris.SheetMetal;++public sealed record SheetMetalConceptPath(+ string Path,+ string Kind,+ IReadOnlyList<string> Capabilities,+ string StableId,+ string? FormedId,+ string? FlatId,+ string Provenance);++/// <summary>Canonical authored Sheet Metal public surface; geometry regeneration does not name it.</summary>+public static class SheetMetalConceptPaths+{+ public static IReadOnlyList<SheetMetalConceptPath> Inspect(SheetMetalConstructionSpec spec,SheetMetalPartIr part,SheetMetalFlatPatternIr? flat=null)+ {+ ArgumentNullException.ThrowIfNull(spec);ArgumentNullException.ThrowIfNull(part);+ var paths=new List<SheetMetalConceptPath>();+ void Add(string path,string kind,string stableId,string? formed,string? flatId,string provenance,params string[] capabilities)=>paths.Add(new(path,kind,capabilities,stableId,formed,flatId,provenance));+ var baseId=part.BaseRegionId;+ Add(spec.Base.Name,"SheetRegion",spec.Base.Name,baseId,$"flat-{baseId}","canonical rectangular authored region","Cuttable","PlanarRegion","FlatCorrespondent");+ foreach(var edge in new[]{"Front","Right","Rear","Left"})Add($"{spec.Base.Name}.{edge}","SheetEdge",$"{spec.Base.Name}.{edge}",baseId,$"flat-{baseId}","canonical rectangular edge","FlangeAttachable","BendBoundary","CornerAdjacent");+ Add($"{spec.Base.Name}.Center","Point2",$"{spec.Base.Name}.Center",baseId,$"flat-{baseId}","canonical rectangular center","PointCapable","CutPlacement");+ foreach(var flange in spec.Flanges)+ {+ var region=part.Regions.FirstOrDefault(x=>x.StableId.Equals(flange.Name,StringComparison.OrdinalIgnoreCase)||x.StableId.EndsWith($"{flange.EdgeName.ToLowerInvariant()}-flange",StringComparison.OrdinalIgnoreCase));+ var bend=part.Bends.FirstOrDefault(x=>x.AdjacentRegionB==region?.StableId);+ Add(flange.Name,"SheetFlange",flange.Name,region?.StableId,$"flat-{region?.StableId}","authored flange declaration","SheetRegion","Cuttable","FlatCorrespondent");+ Add($"{flange.Name}.Root","SheetEdge",$"{flange.Name}.Root",bend?.StableId,$"flat-{bend?.StableId}","flange root tangent edge","BendBoundary","CornerAdjacent");+ Add($"{flange.Name}.Outer","SheetEdge",$"{flange.Name}.Outer",region?.StableId,$"flat-{region?.StableId}","canonical flange free edge","FlangeAttachable","FreeEdge","CornerAdjacent");+ Add($"{flange.Name}.Left","SheetEdge",$"{flange.Name}.Left",region?.StableId,$"flat-{region?.StableId}","orientation-relative flange side","FreeEdge","CornerAdjacent");+ Add($"{flange.Name}.Right","SheetEdge",$"{flange.Name}.Right",region?.StableId,$"flat-{region?.StableId}","orientation-relative flange side","FreeEdge","CornerAdjacent");+ Add($"{flange.Name}.LeftCorner","SheetCorner",$"{flange.Name}.LeftCorner",region?.StableId,$"flat-{region?.StableId}","canonical flange endpoint","CornerAdjacent");+ Add($"{flange.Name}.RightCorner","SheetCorner",$"{flange.Name}.RightCorner",region?.StableId,$"flat-{region?.StableId}","canonical flange endpoint","CornerAdjacent");+ Add($"{flange.Name}.Bend","SheetBend",$"{flange.Name}.Bend",bend?.StableId,$"flat-{bend?.StableId}","authored flange bend","BendBoundary","FlatCorrespondent");+ }+ foreach(var cut in spec.Cuts)Add(cut.Name,"SheetCut",cut.Name,cut.Name,cut.Name,"authored cut declaration","FlatFeature","Cuttable");+ Add("Flat","FlatPattern",$"flat-{part.StableId}",null,flat?.StableId,"derived flat state","ManufacturingContour");+ foreach(var path in paths.Where(x=>x.FormedId is not null&&x.Path!="Flat").ToArray())Add($"Flat.{path.Path}","Flat"+path.Kind,$"Flat.{path.StableId}",path.FormedId,path.FlatId,"formed/flat semantic correspondence",[..path.Capabilities,"FlatState"]);+ return paths.OrderBy(x=>x.Path,StringComparer.Ordinal).ToArray();+ }++ public static IReadOnlyList<string> AvailableMembers(string conceptKind)=>conceptKind switch+ {+ "SheetRegion.Rectangle"=>["Front","Right","Rear","Left","Center"],+ "SheetFlange"=>["Root","Outer","Left","Right","LeftCorner","RightCorner","Bend"],+ _=>[]+ };+}diff --git a/Aetheris.SheetMetal/SheetMetalDfm.cs b/Aetheris.SheetMetal/SheetMetalDfm.csindex e1d1ea97..86753df6 100644--- a/Aetheris.SheetMetal/SheetMetalDfm.cs+++ b/Aetheris.SheetMetal/SheetMetalDfm.cs@@ -1,9 +1,12 @@+using Aetheris.Kernel.Firmament.Materializer;+namespace Aetheris.SheetMetal;public sealed record SheetMetalDfmPolicy(double MinimumInsideRadiusRatio = 1d,double MinimumHoleToBendDistanceFactor = 2d,- double MinimumEdgeDistanceFactor = 1.5d);+ double MinimumEdgeDistanceFactor = 1.5d,+ double MinimumFlangeBeyondTangentFactor = 1d);public enum SheetMetalDfmStatus { Pass, Warning, Fail, NotEvaluated }@@ -32,14 +35,18 @@ public static class SheetMetalDfm{var ratio=bend.InsideRadius/part.Thickness;var pass=ratio>=policy.MinimumInsideRadiusRatio;findings.Add(new("sheetmetal-dfm-inside-radius-ratio",pass?SheetMetalDfmStatus.Pass:SheetMetalDfmStatus.Warning,$"Inside-radius/thickness ratio {ratio:G4} {(pass?"meets":"is below")} the parameterized experimental policy {policy.MinimumInsideRadiusRatio:G4}.",bend.StableId,ratio,policy.MinimumInsideRadiusRatio));+ var flange=part.Regions.FirstOrDefault(r=>r.StableId==bend.AdjacentRegionB);var axisLength=part.Regions.Where(r=>r.Cylinder is not null).OrderBy(r=>Math.Abs(r.Cylinder!.InsideRadius-bend.InsideRadius)+(1-Math.Abs(r.Cylinder.AxisDirection.Dot(bend.AxisDirection)))*1000).FirstOrDefault()?.Cylinder?.AxisLength??0;var flangeLength=flange is null||axisLength<=0?double.NaN:flange.ApproximateArea/axisLength;var requiredFlange=bend.InsideRadius+part.Thickness*policy.MinimumFlangeBeyondTangentFactor;var flangePass=double.IsNaN(flangeLength)||flangeLength>=requiredFlange;+ findings.Add(new("sheetmetal-dfm-minimum-flange-length",double.IsNaN(flangeLength)?SheetMetalDfmStatus.NotEvaluated:flangePass?SheetMetalDfmStatus.Pass:SheetMetalDfmStatus.Warning,double.IsNaN(flangeLength)?$"'{bend.AdjacentRegionB}' flange length could not be derived.":$"'{bend.AdjacentRegionB}' tangent-to-edge length is {flangeLength:G4} mm; policy requires {requiredFlange:G4} mm.",bend.AdjacentRegionB,double.IsNaN(flangeLength)?null:flangeLength,requiredFlange,!flangePass?$"Increase {bend.AdjacentRegionB} Height/Length by at least {requiredFlange-flangeLength:G4} mm.":null));}foreach(var corner in part.Corners??[]){- var relief=(part.Reliefs??[]).FirstOrDefault(r=>r.CornerId==corner.StableId);var valid=corner.Policy!=SheetCornerPolicy.Relief||relief is not null&&relief.Width>=part.Thickness&&relief.Depth>=part.Thickness;- findings.Add(new("sheetmetal-dfm-corner-resolution",valid?SheetMetalDfmStatus.Pass:SheetMetalDfmStatus.Warning,valid?$"'{corner.StableId}' uses bounded {corner.Policy} corner resolution.":$"'{corner.StableId}' has insufficient or missing relief geometry.",corner.StableId,relief?.Width,part.Thickness,valid?null:$"Increase {corner.ReliefId??"the corner relief"} width and depth to at least {part.Thickness:G4} mm."));+ var relief=(part.Reliefs??[]).FirstOrDefault(r=>r.CornerId==corner.StableId);var requiresRelief=corner.Policy is SheetCornerPolicy.RectangularRelief or SheetCornerPolicy.RoundRelief;var minimumDepth=(part.Bends.Where(b=>b.AdjacentRegionB==corner.RegionA||b.AdjacentRegionB==corner.RegionB).Select(b=>b.InsideRadius).DefaultIfEmpty(0).Max()+part.Thickness);var valid=!requiresRelief||relief is not null&&relief.Width>=part.Thickness&&relief.Depth>=minimumDepth;+ findings.Add(new("sheetmetal-dfm-corner-resolution",valid?SheetMetalDfmStatus.Pass:SheetMetalDfmStatus.Warning,valid?$"'{corner.StableId}' uses bounded {corner.Policy} corner resolution.":$"'{corner.StableId}' has insufficient or missing relief geometry.",corner.StableId,relief?.Depth,requiresRelief?minimumDepth:part.Thickness,valid?null:$"Increase {corner.ReliefId??"the corner relief"} width to at least {part.Thickness:G4} mm and depth to at least {minimumDepth:G4} mm."));}if(flat is not null){+ var exactValid=flat.ExactBlankContour is not null&&SheetMetalFlatPatternValidation.Validate(flat).ExactContoursValid;findings.Add(new("sheetmetal-dfm-exact-blank-contour",exactValid?SheetMetalDfmStatus.Pass:SheetMetalDfmStatus.Fail,exactValid?"One validated exact analytic blank contour is authoritative.":"No validated exact analytic blank contour is available.",flat.StableId,null,null,exactValid?null:"Resolve the reported corner/contour topology before fabrication export."));+ foreach(var relief in part.Reliefs??[]){var flatRelief=(flat.ReliefLoops??[]).FirstOrDefault(x=>x.ReliefId==relief.StableId);var valid=flatRelief is not null&&PlanarContourKernel.Validate(flatRelief.ExactContour).IsValid;findings.Add(new("sheetmetal-dfm-exact-relief-topology",valid?SheetMetalDfmStatus.Pass:SheetMetalDfmStatus.Fail,valid?$"'{relief.StableId}' has exact {relief.Kind} line/arc removal geometry.":$"'{relief.StableId}' is missing valid exact flat relief geometry.",relief.StableId,relief.Depth,relief.Width,valid?null:$"Rebuild {relief.StableId} from its typed corner policy."));}findings.Add(new("sheetmetal-dfm-flat-overlap",flat.Status==FlatPatternStatus.Overlapping?SheetMetalDfmStatus.Fail:SheetMetalDfmStatus.Pass,flat.Status==FlatPatternStatus.Overlapping?"Flat material regions overlap.":"No planar-region overlap was detected.",flat.StableId,null,null));foreach(var cut in flat.CutLoops){diff --git a/Aetheris.SheetMetal/SheetMetalFlatPatternValidation.cs b/Aetheris.SheetMetal/SheetMetalFlatPatternValidation.csindex 629255ef..367f7051 100644--- a/Aetheris.SheetMetal/SheetMetalFlatPatternValidation.cs+++ b/Aetheris.SheetMetal/SheetMetalFlatPatternValidation.cs@@ -1,4 +1,5 @@using Aetheris.Kernel.Core.Math;+using Aetheris.Kernel.Firmament.Materializer;namespace Aetheris.SheetMetal;@@ -6,6 +7,7 @@ public sealed record SheetMetalFlatPatternValidationReport(bool Finite,bool LoopsClosed,bool FeaturesContained,+ bool ExactContoursValid,IReadOnlyList<(string A,string B)> Overlaps,FlatPatternStatus Status,IReadOnlyList<SheetMetalDiagnostic> Diagnostics);@@ -29,8 +31,14 @@ public static class SheetMetalFlatPatternValidationif(!contained)diagnostics.Add(new(SheetMetalDiagnosticCodes.FeatureMappingFailure,SheetMetalDiagnosticSeverity.Warning,"One or more cut loops are not contained by their owning flat region."));var bendLinesInside=flat.BendLines.All(b=>flat.Regions2D.Any(r=>PointInPolygon(b.Start,r.Boundary,true))&&flat.Regions2D.Any(r=>PointInPolygon(b.End,r.Boundary,true)));if(!bendLinesInside)diagnostics.Add(new(SheetMetalDiagnosticCodes.BendLineOutsideMaterial,SheetMetalDiagnosticSeverity.Error,"One or more bend-line endpoints lie outside recovered flat material."));- var status=!finite||!closed||slivers.Length>0||duplicateCuts.Length>0||!bendLinesInside?FlatPatternStatus.Unsupported:overlaps.Count>0?FlatPatternStatus.Overlapping:flat.Status;- return new(finite,closed,contained,overlaps,status,diagnostics);+ var exactContoursValid=true;+ foreach(var contour in new[]{flat.ExactBlankContour}.Concat(flat.Regions2D.Select(r=>r.ExactContour)).Concat(flat.CutLoops.Select(c=>c.ExactContour)).Concat((flat.ReliefLoops??[]).Select(r=>(PlanarContour2?)r.ExactContour)).OfType<PlanarContour2>())+ {+ var validation=PlanarContourKernel.Validate(contour);exactContoursValid&=validation.IsValid;+ diagnostics.AddRange(validation.Diagnostics.Where(x=>x.Severity==PlanarContourDiagnosticSeverity.Error).Select(x=>new SheetMetalDiagnostic(SheetMetalDiagnosticCodes.ImpossibleTopology,SheetMetalDiagnosticSeverity.Error,$"Exact contour '{contour.StableId}': {x.Code}: {x.Message}")));+ }+ var status=!finite||!closed||slivers.Length>0||duplicateCuts.Length>0||!bendLinesInside||!exactContoursValid?FlatPatternStatus.Unsupported:overlaps.Count>0?FlatPatternStatus.Overlapping:flat.Status;+ return new(finite,closed,contained,exactContoursValid,overlaps,status,diagnostics);}public static IReadOnlyList<(string A,string B)> FindOverlaps(IReadOnlyList<FlatRegion2D> regions)diff --git a/Aetheris.SheetMetal/SheetMetalFlattener.cs b/Aetheris.SheetMetal/SheetMetalFlattener.csindex db21ee08..dca64851 100644--- a/Aetheris.SheetMetal/SheetMetalFlattener.cs+++ b/Aetheris.SheetMetal/SheetMetalFlattener.cs@@ -1,6 +1,7 @@using System.Globalization;using System.Text;using Aetheris.Kernel.Core.Math;+using Aetheris.Kernel.Firmament.Materializer;namespace Aetheris.SheetMetal;@@ -55,15 +56,19 @@ public static class SheetMetalFlattenermappings[neighborId]=neighborMap;pending.Enqueue(neighborId);var shiftedStart=Add(seamStart,Scale(targetPerp,allowance));var shiftedEnd=Add(seamEnd,Scale(targetPerp,allowance));- bendRegions.Add(new($"flat-{bend.StableId}",bend.StableId,SheetRegionKind.CylindricalBend,[seamStart,seamEnd,shiftedEnd,shiftedStart],"exact neutral-axis cylindrical unroll"));+ var bendBoundary = new SheetPoint2[] { seamStart,seamEnd,shiftedEnd,shiftedStart };+ bendRegions.Add(new($"flat-{bend.StableId}",bend.StableId,SheetRegionKind.CylindricalBend,bendBoundary,"exact neutral-axis cylindrical unroll",Contour($"flat-{bend.StableId}",bendBoundary,"cylindrical neutral-axis unroll")));var centerShift=Scale(targetPerp,allowance/2d);bendLines.Add(new(bend.StableId,Add(seamStart,centerShift),Add(seamEnd,centerShift),bend.Direction,bend.BendAngleRadians,bend.InsideRadius,bend.Thickness,policy.KFactor,allowance));evidence.Add(new(SheetEvidenceKind.Derived,"bend-allowance","angle * (inside radius + K * thickness)",allowance,null,bend.Source.FaceIds));}}- var flatRegions=mappings.Values.OrderBy(m=>m.Region.StableId,StringComparer.Ordinal).Select(m=>new FlatRegion2D(- $"flat-{m.Region.StableId}",m.Region.StableId,SheetRegionKind.Planar,NormalizeSourcePolygon(m.Region.Boundary3D.Select(m.Map)),"exact ordered source-edge vertices through composed analytic plane-to-flat transform")).ToList();+ var flatRegions=mappings.Values.OrderBy(m=>m.Region.StableId,StringComparer.Ordinal).Select(m=>+ {+ var boundary=NormalizeSourcePolygon(m.Region.Boundary3D.Select(m.Map));+ return new FlatRegion2D($"flat-{m.Region.StableId}",m.Region.StableId,SheetRegionKind.Planar,boundary,"exact ordered source-edge vertices through composed analytic plane-to-flat transform",Contour($"flat-{m.Region.StableId}",boundary,"analytic plane-to-flat transform"));+ }).ToList();flatRegions.AddRange(bendRegions.OrderBy(r=>r.StableId,StringComparer.Ordinal));var cuts=new List<FlatCutLoop>();foreach(var feature in part.Features.OrderBy(f=>f.StableId,StringComparer.Ordinal))@@ -75,9 +80,16 @@ public static class SheetMetalFlattenervar c=mapping.Map(feature.Center);loop=Enumerable.Range(0,48).Select(i=>{var a=2*Math.PI*i/48d;return new SheetPoint2(c.X+diameter/2d*Math.Cos(a),c.Y+diameter/2d*Math.Sin(a));}).ToArray();}else loop=NormalizeSourcePolygon(feature.Boundary3D.Select(mapping.Map));- if(loop.Count>=3)cuts.Add(new(feature.StableId,feature.Kind,loop,feature.OwningRegionId));+ if(loop.Count>=3)+ {+ var exact=feature.Kind==SheetFeatureKind.CircularHole&&feature.Diameter is { } exactDiameter+ ? CircleContour(feature.StableId,mapping.Map(feature.Center),exactDiameter/2d)+ : Contour(feature.StableId,loop,"mapped exact feature boundary");+ cuts.Add(new(feature.StableId,feature.Kind,loop,feature.OwningRegionId,exact));+ }else diagnostics.Add(new(SheetMetalDiagnosticCodes.FeatureMappingFailure,SheetMetalDiagnosticSeverity.Warning,$"Feature '{feature.StableId}' did not yield a closed 2D loop."));}+ var flatReliefs=BuildReliefs(part,mappings);if(mappings.Count<planar.Count)diagnostics.Add(new(SheetMetalDiagnosticCodes.DisconnectedGraph,SheetMetalDiagnosticSeverity.Warning,$"Flattened {mappings.Count} of {planar.Count} planar regions in the base-region bend component."));var planarFlat=flatRegions.Where(r=>r.Kind==SheetRegionKind.Planar).ToArray();var overlaps=FindOverlaps(planarFlat);@@ -85,11 +97,18 @@ public static class SheetMetalFlattenervar allPoints=flatRegions.SelectMany(r=>r.Boundary).Concat(cuts.SelectMany(c=>c.Boundary)).ToArray();if(allPoints.Any(p=>!double.IsFinite(p.X)||!double.IsFinite(p.Y)))return Unsupported("Flat lowering produced non-finite coordinates.");var bounds=allPoints.Length==0?null:new FlatPatternBounds(allPoints.Min(p=>p.X),allPoints.Min(p=>p.Y),allPoints.Max(p=>p.X),allPoints.Max(p=>p.Y));- var boundary=part.Provenance.Contains("source-independent",StringComparison.OrdinalIgnoreCase)?StitchBoundary(flatRegions):ConvexHull(flatRegions.SelectMany(r=>r.Boundary));- if(part.Provenance.Contains("source-independent",StringComparison.OrdinalIgnoreCase)&&boundary.Count<3)diagnostics.Add(new(SheetMetalDiagnosticCodes.ImpossibleTopology,SheetMetalDiagnosticSeverity.Error,"Authored flat material regions could not be stitched into one outer contour."));+ var authored=part.Provenance.Contains("source-independent",StringComparison.OrdinalIgnoreCase);+ var exactBlank=authored?BuildExactBlank(part,flatRegions,flatReliefs,diagnostics):null;+ var boundary=exactBlank is not null?ContourVertices(exactBlank):authored?StitchBoundary(flatRegions):ConvexHull(flatRegions.SelectMany(r=>r.Boundary));+ if(authored&&exactBlank is null)diagnostics.Add(new(SheetMetalDiagnosticCodes.ExactBlankContour,SheetMetalDiagnosticSeverity.Warning,"Authored flat material regions contain a point-touch/open-corner topology that the exact single-loop contract rejects; compatibility boundary remains available."));+ if(exactBlank is not null)+ {+ var contourValidation=PlanarContourKernel.Validate(exactBlank);+ diagnostics.AddRange(contourValidation.Diagnostics.Where(x=>x.Severity==PlanarContourDiagnosticSeverity.Error).Select(x=>new SheetMetalDiagnostic(SheetMetalDiagnosticCodes.ImpossibleTopology,SheetMetalDiagnosticSeverity.Error,$"Exact blank contour: {x.Code}: {x.Message}")));+ }var status=overlaps.Count>0?FlatPatternStatus.Overlapping:(mappings.Count<planar.Count||part.RecognitionStatus==SheetMetalRecognitionStatus.Partial?FlatPatternStatus.Partial:FlatPatternStatus.Valid);- var hash=Hash(flatRegions,bendLines,cuts,policy,status);- return new($"flat-{part.StableId}",status,flatRegions,bendLines.OrderBy(b=>b.BendId,StringComparer.Ordinal).ToArray(),cuts,mappings.Values.OrderBy(m=>m.Region.StableId,StringComparer.Ordinal).Select(m=>m.Public()).ToArray(),boundary,bounds,policy,evidence,diagnostics,hash);+ var hash=Hash(flatRegions,bendLines,cuts,flatReliefs,policy,status);+ return new($"flat-{part.StableId}",status,flatRegions,bendLines.OrderBy(b=>b.BendId,StringComparer.Ordinal).ToArray(),cuts,mappings.Values.OrderBy(m=>m.Region.StableId,StringComparer.Ordinal).Select(m=>m.Public()).ToArray(),boundary,bounds,policy,evidence,diagnostics,hash,exactBlank,flatReliefs);SheetMetalFlatPatternIr Unsupported(string message)=>new($"flat-{part.StableId}",FlatPatternStatus.Unsupported,[],[],[],[],[],null,policy,[],[new(SheetMetalDiagnosticCodes.UnsupportedBendTopology,SheetMetalDiagnosticSeverity.Error,message)],SheetMetalRecognizer.StableHash(message));}@@ -144,6 +163,71 @@ public static class SheetMetalFlattenervar p=input.DistinctBy(x=>(Math.Round(x.X,9),Math.Round(x.Y,9))).OrderBy(x=>x.X).ThenBy(x=>x.Y).ToArray();if(p.Length<=2)return p;var lower=new List<SheetPoint2>();foreach(var x in p){while(lower.Count>=2&&Cross(lower[^2],lower[^1],x)<=1e-10)lower.RemoveAt(lower.Count-1);lower.Add(x);}var upper=new List<SheetPoint2>();foreach(var x in p.Reverse()){while(upper.Count>=2&&Cross(upper[^2],upper[^1],x)<=1e-10)upper.RemoveAt(upper.Count-1);upper.Add(x);}return lower.Take(lower.Count-1).Concat(upper.Take(upper.Count-1)).ToArray();}+ private static PlanarContour2 Contour(string id,IReadOnlyList<SheetPoint2> boundary,string provenance)=>PlanarContourKernel.FromPolygon(id,"XY",boundary.Select(p=>(p.X,p.Y)).ToArray(),$"SheetMetalFlatPatternIr:{provenance}");+ private static PlanarContour2 CircleContour(string id,SheetPoint2 center,double radius)+ {+ var c=(center.X,center.Y);var provenance=new ProfileSegmentProvenance($"{id}.circle",id,id,"SheetMetalFlatPatternIr:analytic circle","XY");+ return new(id,"XY",new($"{id}.outer",true,[new($"{id}.arc0",new LineArcCircularArc2D(c,radius,0,Math.PI),provenance),new($"{id}.arc1",new LineArcCircularArc2D(c,radius,Math.PI,Math.PI),provenance with { StableId=$"{id}.circle.1" })]),[],$"SheetMetalFlatPatternIr:analytic circle radius={radius:R}");+ }+ private static PlanarContour2? BuildExactBlank(SheetMetalPartIr part,IReadOnlyList<FlatRegion2D> regions,IReadOnlyList<FlatReliefLoop> reliefs,ICollection<SheetMetalDiagnostic> diagnostics)+ {+ var usable=regions.Where(x=>x.ExactContour is not null).OrderBy(x=>x.StableId,StringComparer.Ordinal).ToArray();+ if(usable.Length!=regions.Count)return null;+ var profiles=usable.ToDictionary(x=>x.StableId,x=>PlanarContourKernel.ToResolvedProfile(x.ExactContour!,x.StableId),StringComparer.Ordinal);+ foreach(var relief in reliefs)profiles[relief.ReliefId]=PlanarContourKernel.ToResolvedProfile(relief.ExactContour,relief.ReliefId);+ var operations=usable.Select((x,index)=>new PrismaticProfileOperation(x.StableId,index==0?PrismaticProfileIntent.Base:PrismaticProfileIntent.Add,x.StableId,0,1,"SheetMetalBlankRegion",x.SourceRegionId))+ .Concat(reliefs.Select(x=>new PrismaticProfileOperation(x.ReliefId,PrismaticProfileIntent.Remove,x.ReliefId,0,1,"SheetMetalCornerRelief",x.ReliefId))).ToArray();+ var composed=ProfileArrangementBuilder.Compose("XY",operations,profiles,$"sheetmetal-blank:{part.StableId}");+ if(composed.Region is null)+ {+ foreach(var message in composed.Arrangement.Diagnostics)diagnostics.Add(new(SheetMetalDiagnosticCodes.ExactBlankContour,SheetMetalDiagnosticSeverity.Warning,$"Exact blank composition: {message}"));+ return null;+ }+ var contour=PlanarContourKernel.FromResolvedProfile(composed.Region.Outer,$"SheetMetal exact material composition:{part.StableId}") with { StableId=$"flat-{part.StableId}.blank" };+ var validation=PlanarContourKernel.Validate(contour);+ if(validation.IsValid)return contour;+ foreach(var item in validation.Diagnostics)diagnostics.Add(new(SheetMetalDiagnosticCodes.ExactBlankContour,SheetMetalDiagnosticSeverity.Warning,$"Exact blank composition: {item.Code}: {item.Message}"));+ return null;+ }+ private static IReadOnlyList<SheetPoint2> ContourVertices(PlanarContour2 contour)=>contour.OuterLoop.Segments.Select(segment=>segment.Geometry switch+ {+ LineArcLineSegment2D line=>new SheetPoint2(line.Start.X,line.Start.Y),+ LineArcCircularArc2D arc=>new SheetPoint2(arc.Center.X+arc.Radius*Math.Cos(arc.StartAngleRadians),arc.Center.Y+arc.Radius*Math.Sin(arc.StartAngleRadians)),+ LineArcFullCircle2D circle=>new SheetPoint2(circle.Center.X+circle.Radius,circle.Center.Y),+ _=>default+ }).ToArray();+ private static IReadOnlyList<FlatReliefLoop> BuildReliefs(SheetMetalPartIr part,IReadOnlyDictionary<string,Mapping> mappings)+ {+ if(!mappings.TryGetValue(part.BaseRegionId,out var mapping))return [];+ var basePoints=mapping.Region.Boundary3D.Select(mapping.Map).ToArray();if(basePoints.Length<3)return [];+ var minX=basePoints.Min(p=>p.X);var maxX=basePoints.Max(p=>p.X);var minY=basePoints.Min(p=>p.Y);var maxY=basePoints.Max(p=>p.Y);var result=new List<FlatReliefLoop>();+ foreach(var corner in part.Corners??[])+ {+ var relief=(part.Reliefs??[]).FirstOrDefault(x=>x.CornerId==corner.StableId);if(relief is null)continue;+ var tokens=corner.VertexName.Split('-',StringSplitOptions.RemoveEmptyEntries|StringSplitOptions.TrimEntries);var right=tokens.Contains("Right",StringComparer.OrdinalIgnoreCase);var left=tokens.Contains("Left",StringComparer.OrdinalIgnoreCase);var front=tokens.Contains("Front",StringComparer.OrdinalIgnoreCase);var rear=tokens.Contains("Rear",StringComparer.OrdinalIgnoreCase);+ var c=new SheetPoint2(right?maxX:left?minX:(minX+maxX)/2,front?minY:rear?maxY:(minY+maxY)/2);var ix=right?-1d:1d;var iy=front?1d:-1d;+ PlanarContour2 contour;IReadOnlyList<SheetPoint2> sample;+ if(relief.Kind==SheetReliefKind.Round)+ {+ var radius=relief.Radius??relief.Width/2d;var inv=1/Math.Sqrt(2);var dir=(X:ix*inv,Y:iy*inv);var perp=(X:-dir.Y,Y:dir.X);var start=(X:c.X-dir.X*radius,Y:c.Y-dir.Y*radius);var end=(X:c.X+dir.X*Math.Max(radius,relief.Depth-radius),Y:c.Y+dir.Y*Math.Max(radius,relief.Depth-radius));+ var p0=(X:start.X+perp.X*radius,Y:start.Y+perp.Y*radius);var p1=(X:end.X+perp.X*radius,Y:end.Y+perp.Y*radius);var p2=(X:end.X-perp.X*radius,Y:end.Y-perp.Y*radius);var p3=(X:start.X-perp.X*radius,Y:start.Y-perp.Y*radius);var plus=Math.Atan2(perp.Y,perp.X);var minus=Math.Atan2(-perp.Y,-perp.X);var provenance=new ProfileSegmentProvenance($"{relief.StableId}.round",relief.StableId,corner.StableId,"exact round-ended bend relief","XY");+ contour=new(relief.StableId,"XY",new($"{relief.StableId}.outer",true,[new($"{relief.StableId}.side0",new LineArcLineSegment2D(p3,p2),provenance),new($"{relief.StableId}.end",new LineArcCircularArc2D(end,radius,minus,Math.PI),provenance with { StableId=$"{relief.StableId}.end" }),new($"{relief.StableId}.side1",new LineArcLineSegment2D(p1,p0),provenance with { StableId=$"{relief.StableId}.side1" }),new($"{relief.StableId}.start",new LineArcCircularArc2D(start,radius,plus,Math.PI),provenance with { StableId=$"{relief.StableId}.start" })]),[],$"{corner.StableId}: round relief width={relief.Width:R} depth={relief.Depth:R}");+ sample=Sample(contour);+ }+ else+ {+ var half=relief.Width/2d;var inv=1/Math.Sqrt(2);var dir=(X:ix*inv,Y:iy*inv);var perp=(X:-dir.Y,Y:dir.X);var start=(X:c.X-dir.X*relief.Width*2d,Y:c.Y-dir.Y*relief.Width*2d);var end=(X:c.X+dir.X*relief.Depth,Y:c.Y+dir.Y*relief.Depth);var points=new[]{new SheetPoint2(start.X-perp.X*half,start.Y-perp.Y*half),new SheetPoint2(end.X-perp.X*half,end.Y-perp.Y*half),new SheetPoint2(end.X+perp.X*half,end.Y+perp.Y*half),new SheetPoint2(start.X+perp.X*half,start.Y+perp.Y*half)};contour=Contour(relief.StableId,points,$"{corner.StableId}: rectangular diagonal relief width={relief.Width:R} depth={relief.Depth:R}");sample=points;+ }+ result.Add(new(relief.StableId,relief.Kind,sample,part.BaseRegionId,contour,relief.Width,relief.Depth));+ }+ return result;+ }+ private static IReadOnlyList<SheetPoint2> Sample(PlanarContour2 contour)=>contour.OuterLoop.Segments.SelectMany(segment=>segment.Geometry switch+ {+ LineArcLineSegment2D line=>new[]{new SheetPoint2(line.Start.X,line.Start.Y)},+ LineArcCircularArc2D arc=>Enumerable.Range(0,12).Select(i=>{var a=arc.StartAngleRadians+arc.SweepAngleRadians*i/12d;return new SheetPoint2(arc.Center.X+arc.Radius*Math.Cos(a),arc.Center.Y+arc.Radius*Math.Sin(a));}),+ _=>[]+ }).ToArray();private readonly record struct PointKey(long X,long Y){public static PointKey Of(SheetPoint2 p)=>new((long)Math.Round(p.X*1e8),(long)Math.Round(p.Y*1e8));}private readonly record struct SegmentKey(PointKey A,PointKey B){@@ -181,7 +265,7 @@ public static class SheetMetalFlattenerstatic bool PointInPolygonStrict(SheetPoint2 point,IReadOnlyList<SheetPoint2> polygon){var inside=false;for(var i=0;i<polygon.Count;i++){var a=polygon[i];var b=polygon[(i+1)%polygon.Count];if(Math.Abs(Cross(a,b,point))<1e-8&&point.X>=Math.Min(a.X,b.X)-1e-8&&point.X<=Math.Max(a.X,b.X)+1e-8&&point.Y>=Math.Min(a.Y,b.Y)-1e-8&&point.Y<=Math.Max(a.Y,b.Y)+1e-8)return false;if((a.Y>point.Y)!=(b.Y>point.Y)&&point.X<(b.X-a.X)*(point.Y-a.Y)/(b.Y-a.Y)+a.X)inside=!inside;}return inside;}static IEnumerable<SheetPoint2> InteriorProbes(IReadOnlyList<SheetPoint2> p){var sign=SignedArea(p)>=0?1d:-1d;for(var i=0;i<p.Count;i++){var a=p[i];var b=p[(i+1)%p.Count];var dx=b.X-a.X;var dy=b.Y-a.Y;var len=Math.Sqrt(dx*dx+dy*dy);if(len>1e-12)yield return new((a.X+b.X)/2-sign*dy/len*1e-6,(a.Y+b.Y)/2+sign*dx/len*1e-6);}}}- private static string Hash(IReadOnlyList<FlatRegion2D> regions,IReadOnlyList<FlatBendLine>bends,IReadOnlyList<FlatCutLoop>cuts,SheetMetalFlattenPolicy policy,FlatPatternStatus status){var sb=new StringBuilder().Append(status).Append('|').Append(Q(policy.KFactor));foreach(var r in regions.OrderBy(x=>x.StableId,StringComparer.Ordinal)){sb.Append('|').Append(r.StableId);foreach(var p in r.Boundary)sb.Append('|').Append(Q(p.X)).Append(',').Append(Q(p.Y));}foreach(var b in bends.OrderBy(x=>x.BendId,StringComparer.Ordinal))sb.Append('|').Append(b.BendId).Append(':').Append(b.Direction).Append(':').Append(Q(b.BendAngleRadians)).Append(':').Append(Q(b.BendAllowance));foreach(var c in cuts.OrderBy(x=>x.FeatureId,StringComparer.Ordinal))sb.Append('|').Append(c.FeatureId);return SheetMetalRecognizer.StableHash(sb.ToString());static string Q(double value)=>Math.Round(value,9,MidpointRounding.AwayFromZero).ToString("R",CultureInfo.InvariantCulture);}+ private static string Hash(IReadOnlyList<FlatRegion2D> regions,IReadOnlyList<FlatBendLine>bends,IReadOnlyList<FlatCutLoop>cuts,IReadOnlyList<FlatReliefLoop>reliefs,SheetMetalFlattenPolicy policy,FlatPatternStatus status){var sb=new StringBuilder().Append(status).Append('|').Append(Q(policy.KFactor));foreach(var r in regions.OrderBy(x=>x.StableId,StringComparer.Ordinal)){sb.Append('|').Append(r.StableId);foreach(var p in r.Boundary)sb.Append('|').Append(Q(p.X)).Append(',').Append(Q(p.Y));}foreach(var b in bends.OrderBy(x=>x.BendId,StringComparer.Ordinal))sb.Append('|').Append(b.BendId).Append(':').Append(b.Direction).Append(':').Append(Q(b.BendAngleRadians)).Append(':').Append(Q(b.BendAllowance));foreach(var c in cuts.OrderBy(x=>x.FeatureId,StringComparer.Ordinal))sb.Append('|').Append(c.FeatureId);foreach(var r in reliefs.OrderBy(x=>x.ReliefId,StringComparer.Ordinal))sb.Append('|').Append(r.ReliefId).Append(':').Append(r.Kind).Append(':').Append(Q(r.Width)).Append(':').Append(Q(r.Depth));return SheetMetalRecognizer.StableHash(sb.ToString());static string Q(double value)=>Math.Round(value,9,MidpointRounding.AwayFromZero).ToString("R",CultureInfo.InvariantCulture);}private static double Cross(SheetPoint2 a,SheetPoint2 b,SheetPoint2 c)=>(b.X-a.X)*(c.Y-a.Y)-(b.Y-a.Y)*(c.X-a.X);private static SheetPoint2 Add(SheetPoint2 a,SheetPoint2 b)=>new(a.X+b.X,a.Y+b.Y);private static SheetPoint2 Sub(SheetPoint2 a,SheetPoint2 b)=>new(a.X-b.X,a.Y-b.Y);private static SheetPoint2 Scale(SheetPoint2 a,double s)=>new(a.X*s,a.Y*s);private static double Dot(SheetPoint2 a,SheetPoint2 b)=>a.X*b.X+a.Y*b.Y;private static SheetPoint2 Normalize(SheetPoint2 a){var l=Math.Sqrt(Dot(a,a));return l<=1e-12?new(1,0):Scale(a,1/l);}private static Vector3D Normalize(Vector3D v)=>v.TryNormalize(out var n)?n:v;}diff --git a/Aetheris.SheetMetal/SheetMetalIr.cs b/Aetheris.SheetMetal/SheetMetalIr.csindex b8633657..5b35483e 100644--- a/Aetheris.SheetMetal/SheetMetalIr.cs+++ b/Aetheris.SheetMetal/SheetMetalIr.cs@@ -1,5 +1,6 @@using Aetheris.Kernel.Core.Brep;using Aetheris.Kernel.Core.Math;+using Aetheris.Kernel.Firmament.Materializer;using Aetheris.Surfacing;namespace Aetheris.SheetMetal;@@ -15,7 +16,7 @@ public enum SheetMetalIntentConfidence { StructuralFact, StrongCandidate, WeakCapublic enum SheetMetalProvenanceCategory { Authored, Recovered, Reconstructed }public enum SheetCornerKind { ClosedCorner, OpenCorner, ReliefCorner, OverlapCorner, MiteredCorner, Unknown }public enum SheetReliefKind { Rectangular, Round, Unknown }-public enum SheetCornerPolicy { Open, Mitered, Relief }+public enum SheetCornerPolicy { Open, Mitered, RectangularRelief, RoundRelief, Relief = RectangularRelief }public enum SheetReliefPolicy { None, Auto, Rectangular, Round }public enum SheetFlangeLengthMode { TangentToEdge }@@ -39,11 +40,13 @@ public static class SheetMetalDiagnosticCodespublic const string InvalidRelief = "sheetmetal-invalid-relief";public const string CutCrossesBend = "sheetmetal-cut-crosses-bend";public const string FormedBodyInvalid = "sheetmetal-formed-body-invalid";+ public const string ExactBlankContour = "sheetmetal-exact-blank-contour";+ public const string FlangeBelowMinimum = "sheetmetal-flange-below-minimum";public static IReadOnlyList<string> All { get; } =[NonConstantThickness, UnpairedFaces, NonDevelopable, AmbiguousBendAxis, UnsupportedBendTopology,InconsistentBendRadius, DisconnectedGraph, FlatOverlap, FeatureMappingFailure, InvalidRadius,DuplicateCut, BendLineOutsideMaterial, ZeroWidthSliver, DuplicateFlange, ImpossibleTopology,- InvalidRelief, CutCrossesBend, FormedBodyInvalid];+ InvalidRelief, CutCrossesBend, FormedBodyInvalid, ExactBlankContour, FlangeBelowMinimum];}public sealed record SheetMetalDiagnostic(@@ -220,7 +223,8 @@ public sealed record FlatRegion2D(string SourceRegionId,SheetRegionKind Kind,IReadOnlyList<SheetPoint2> Boundary,- string MappingKind);+ string MappingKind,+ PlanarContour2? ExactContour = null);public sealed record FlatBendLine(string BendId,@@ -237,7 +241,17 @@ public sealed record FlatCutLoop(string FeatureId,SheetFeatureKind Kind,IReadOnlyList<SheetPoint2> Boundary,- string SourceRegionId);+ string SourceRegionId,+ PlanarContour2? ExactContour = null);++public sealed record FlatReliefLoop(+ string ReliefId,+ SheetReliefKind Kind,+ IReadOnlyList<SheetPoint2> Boundary,+ string SourceRegionId,+ PlanarContour2 ExactContour,+ double Width,+ double Depth);public sealed record SourceToFlatMapping(string SourceRegionId,@@ -266,7 +280,9 @@ public sealed record SheetMetalFlatPatternIr(SheetMetalFlattenPolicy Policy,IReadOnlyList<SheetEvidence> Evidence,IReadOnlyList<SheetMetalDiagnostic> Diagnostics,- string DeterministicHash);+ string DeterministicHash,+ PlanarContour2? ExactBlankContour = null,+ IReadOnlyList<FlatReliefLoop>? ReliefLoops = null);public sealed record SheetMetalRecognitionResult(SheetMetalPartIr? Part,diff --git a/Aetheris.SheetMetal/SheetMetalManufacturingArtifacts.cs b/Aetheris.SheetMetal/SheetMetalManufacturingArtifacts.csindex b65f917f..43efabf4 100644--- a/Aetheris.SheetMetal/SheetMetalManufacturingArtifacts.cs+++ b/Aetheris.SheetMetal/SheetMetalManufacturingArtifacts.cs@@ -30,7 +30,7 @@ public static class SheetMetalManufacturingArtifacts{var region = materialRegions[index];var name = $"material_{index:D3}";- profiles[name] = Profile(name, region.Boundary, shift);+ profiles[name] = region.ExactContour is not null ? Profile(name,region.ExactContour,shift) : Profile(name, region.Boundary, shift);operations.Add(new(name, index == 0 ? PrismaticProfileIntent.Base : PrismaticProfileIntent.Add, name, 0, part.Thickness,region.Kind == SheetRegionKind.CylindricalBend ? "NeutralAxisBendStrip" : "FlatSheetRegion", region.SourceRegionId));}@@ -40,11 +40,16 @@ public static class SheetMetalManufacturingArtifactsif (cut.Boundary.Count < 3) continue;var name = $"cut_{index:D3}";var cutFeature=part.Features.FirstOrDefault(f=>f.StableId==cut.FeatureId);- profiles[name] = cutFeature is { Kind:SheetFeatureKind.CircularHole,Diameter:not null }+ profiles[name] = cut.ExactContour is not null ? Profile(name,cut.ExactContour,shift) : cutFeature is { Kind:SheetFeatureKind.CircularHole,Diameter:not null }? CircleProfile(name,new(cut.Boundary.Average(p=>p.X),cut.Boundary.Average(p=>p.Y)),cutFeature.Diameter.Value/2,shift): Profile(name, cut.Boundary, shift);operations.Add(new(name, PrismaticProfileIntent.Remove, name, 0, part.Thickness, "ThroughCut", cut.FeatureId, cut.FeatureId, cut.Kind.ToString()));}+ foreach(var relief in (flat.ReliefLoops??[]).OrderBy(x=>x.ReliefId,StringComparer.Ordinal))+ {+ var name=$"relief_{Safe(relief.ReliefId)}";profiles[name]=Profile(name,relief.ExactContour,shift);+ operations.Add(new(name,PrismaticProfileIntent.Remove,name,0,part.Thickness,"CornerRelief",relief.ReliefId,relief.ReliefId,relief.Kind.ToString()));+ }if (materialRegions.Length == 0) return Failure("Flat pattern contains no bounded material regions.");var placement = new PrismaticProfilePlacement("FlatPatternPlacement", 0, 0, 0, "XY", "+Z", "+X", true);@@ -146,6 +151,19 @@ public static class SheetMetalManufacturingArtifactsreturn new(name, "XY", [new("Outer", true, segments)]);}+ private static ResolvedProfile2D Profile(string name,PlanarContour2 contour,SheetPoint2 shift)+ {+ LineArcProfileCurve2D Shift(LineArcProfileCurve2D curve)=>curve switch+ {+ LineArcLineSegment2D line=>new LineArcLineSegment2D((Clean(line.Start.X+shift.X),Clean(line.Start.Y+shift.Y)),(Clean(line.End.X+shift.X),Clean(line.End.Y+shift.Y))),+ LineArcCircularArc2D arc=>arc with { Center=(Clean(arc.Center.X+shift.X),Clean(arc.Center.Y+shift.Y)) },+ LineArcFullCircle2D circle=>circle with { Center=(Clean(circle.Center.X+shift.X),Clean(circle.Center.Y+shift.Y)) },+ _=>throw new NotSupportedException("Flat manufacturing profiles support exact lines, arcs, and circles.")+ };+ ResolvedProfileLoop2D Loop(PlanarContourLoop2 loop,int loopIndex)=>new(loop.StableId,loop.IsOuter,loop.Segments.Select((segment,index)=>new ResolvedProfileSegment2D($"l{loopIndex:D2}s{index:D3}",Shift(segment.Geometry),segment.Provenance with { StableId=$"{name}:l{loopIndex:D2}s{index:D3}",Derivation=$"{segment.Provenance.Derivation}; flat manufacturing shift" })).ToArray());+ return new(name,contour.PlaneFrame,contour.Loops.Select(Loop).ToArray());+ }+private static ResolvedProfile2D CircleProfile(string name,SheetPoint2 center,double radius,SheetPoint2 shift){var c=(Clean(center.X+shift.X),Clean(center.Y+shift.Y));diff --git a/Aetheris.SheetMetal/SheetMetalModule.cs b/Aetheris.SheetMetal/SheetMetalModule.csindex 058ecee9..611d5e07 100644--- a/Aetheris.SheetMetal/SheetMetalModule.cs+++ b/Aetheris.SheetMetal/SheetMetalModule.cs@@ -6,7 +6,7 @@ namespace Aetheris.SheetMetal;public static class SheetMetalModule{public static readonly AetherisModuleId Id = new("Aetheris.SheetMetal");- public static readonly ModuleVersion Version = new(0, 4, 0);+ public static readonly ModuleVersion Version = new(0, 5, 0);public static AetherisModule Definition { get; } = new(Id,"Sheet Metal",Version,[Capability("SheetMetal.ConstantThickness", "Tolerance-bounded planar and coaxial cylindrical thickness recognition."),@@ -14,13 +14,16 @@ public static class SheetMetalModuleCapability("SheetMetal.FlatPattern", "Deterministic K-factor lowering to flat IR, AP242 solid, recovered Firmament intent, bend lines, and mapped cuts."),Capability("SheetMetal.AuthoredMultiFlange", "Source-independent rectangular base/flange graph with parent-flange continuation, arbitrary 0<angle<180 degree cylindrical bends, and Up/Down direction."),Capability("SheetMetal.ExactFormedBody", "Explicit stitched planar/cylindrical skins, thickness walls, and region-owned circular/profile cuts; closed-manifold AP242 without generic Boolean union."),- Capability("SheetMetal.StitchedAuthoredFlat", "Authored graph traversal, shared bend allowance, stitched outer contour, mapped cuts, physical flat AP242, and SVG."),- Capability("SheetMetal.CornerRelief", "Bounded adjacent-flange Open/Mitered/Relief semantics with deterministic automatic relief dimensions and correspondence."),+ Capability("SheetMetal.ExactPlanarContour", "Shared native line/arc/circle outer/inner contour IR with bounded intersection, trim, split, offset, composition, and manufacturing validation."),+ Capability("SheetMetal.StitchedAuthoredFlat", "Authored graph traversal, shared bend allowance, exact profile composition when admitted, mapped analytic cuts/reliefs, physical flat AP242, and SVG."),+ Capability("SheetMetal.CornerRelief", "Bounded adjacent-flange Open, Mitered, RectangularRelief, and RoundRelief semantics with deterministic automatic dimensions and correspondence."),+ Capability("SheetMetal.ConceptPaths", "Canonical base/flange/corner/bend and formed/flat public paths with typed capabilities and CLI inspection."),+ Capability("SheetMetal.Templates", "Module-owned LBracket, UChannel, and FourWallTray engineering-parameter generators using ordinary Sheet Metal lowering and DFM."),Capability("SheetMetal.IntentRecovery", "Two-layer forensic recovery and explicit human/LLM reconstructed authority with bounded nominal/grouping suggestions."),Capability("SheetMetal.IntentComparison", "Localized formed-boundary, bend, cut, and flat-pattern residuals under an explicit reconstruction policy."),Capability("SheetMetal.SourceEdgeFlat", "Ordered exact source-line vertices are preserved in flat regions when the recovered loop is valid; invalid loops retain deterministic hull fallback."),Capability("SheetMetal.CornerReliefEvidence", "Bounded corner relationships and proximity-gated relief candidates remain classified evidence, never silent authored truth."),- Capability("SheetMetal.DfmM3", "Parameterized radius, cut-to-bend, cut-to-edge, corner-resolution, and flat-overlap diagnostics with semantic subjects and bounded suggestions.")+ Capability("SheetMetal.DfmM4", "Parameterized radius, flange, cut, exact-blank, exact-relief, corner-resolution, and flat-overlap diagnostics with semantic subjects and bounded suggestions.")],["SheetMetal","ConstantThickness","Flattenable","HasFlatPattern","BendCapable"],["AuthoredSheetMetal<RegionBendGraph>","RecoveredSheetMetalEvidence<Part>"],diff --git a/Aetheris.SheetMetal/SheetMetalSvgRenderer.cs b/Aetheris.SheetMetal/SheetMetalSvgRenderer.csindex 7a2066ec..b95425f4 100644--- a/Aetheris.SheetMetal/SheetMetalSvgRenderer.cs+++ b/Aetheris.SheetMetal/SheetMetalSvgRenderer.cs@@ -1,5 +1,6 @@using System.Globalization;using System.Text;+using Aetheris.Kernel.Firmament.Materializer;namespace Aetheris.SheetMetal;@@ -10,11 +11,31 @@ public static class SheetMetalSvgRendererArgumentNullException.ThrowIfNull(flat);var b=flat.Bounds??new(0,0,100,100);const double margin=12;var width=Math.Max(1,b.Width)+2*margin;var height=Math.Max(1,b.Height)+2*margin;double x(double value)=>value-b.MinX+margin;double y(double value)=>height-(value-b.MinY+margin);string points(IEnumerable<SheetPoint2> p)=>string.Join(" ",p.Select(q=>$"{F(x(q.X))},{F(y(q.Y))}"));+ string path(PlanarContourLoop2 loop)+ {+ if(loop.Segments.Count==1&&loop.Segments[0].Geometry is LineArcFullCircle2D circle)+ {+ var left=(X:circle.Center.X-circle.Radius,Y:circle.Center.Y);var right=(X:circle.Center.X+circle.Radius,Y:circle.Center.Y);+ return $"M {F(x(left.X))} {F(y(left.Y))} A {F(circle.Radius)} {F(circle.Radius)} 0 1 0 {F(x(right.X))} {F(y(right.Y))} A {F(circle.Radius)} {F(circle.Radius)} 0 1 0 {F(x(left.X))} {F(y(left.Y))} Z";+ }+ var first=loop.Segments[0].Geometry switch{LineArcLineSegment2D l=>l.Start,LineArcCircularArc2D a=>(a.Center.X+a.Radius*Math.Cos(a.StartAngleRadians),a.Center.Y+a.Radius*Math.Sin(a.StartAngleRadians)),_=>(0d,0d)};+ var d=new StringBuilder($"M {F(x(first.Item1))} {F(y(first.Item2))}");+ foreach(var segment in loop.Segments)switch(segment.Geometry)+ {+ case LineArcLineSegment2D line:d.Append($" L {F(x(line.End.X))} {F(y(line.End.Y))}");break;+ case LineArcCircularArc2D arc:+ var endAngle=arc.StartAngleRadians+arc.SweepAngleRadians;var end=(X:arc.Center.X+arc.Radius*Math.Cos(endAngle),Y:arc.Center.Y+arc.Radius*Math.Sin(endAngle));+ d.Append($" A {F(arc.Radius)} {F(arc.Radius)} 0 {(Math.Abs(arc.SweepAngleRadians)>Math.PI?1:0)} {(arc.SweepAngleRadians>0?0:1)} {F(x(end.X))} {F(y(end.Y))}");break;+ }+ return d.Append(" Z").ToString();+ }var sb=new StringBuilder();sb.AppendLine("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");sb.AppendLine($"<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"{F(width)}mm\" height=\"{F(height)}mm\" viewBox=\"0 0 {F(width)} {F(height)}\">");sb.AppendLine("<rect width=\"100%\" height=\"100%\" fill=\"white\"/>");sb.AppendLine("<g id=\"sheet-regions\" fill=\"#dbeafe\" fill-opacity=\"0.55\" stroke=\"#0f172a\" stroke-width=\"0.45\">");- foreach(var r in flat.Regions2D.OrderBy(r=>r.StableId,StringComparer.Ordinal))if(r.Boundary.Count>=3)sb.AppendLine($"<polygon id=\"{Escape(r.StableId)}\" points=\"{points(r.Boundary)}\"/>");sb.AppendLine("</g>");- sb.AppendLine("<g id=\"cut-contours\" fill=\"white\" stroke=\"#dc2626\" stroke-width=\"0.5\">");foreach(var c in flat.CutLoops.OrderBy(c=>c.FeatureId,StringComparer.Ordinal))if(c.Boundary.Count>=3)sb.AppendLine($"<polygon id=\"{Escape(c.FeatureId)}\" points=\"{points(c.Boundary)}\"/>");sb.AppendLine("</g>");+ foreach(var r in flat.Regions2D.OrderBy(r=>r.StableId,StringComparer.Ordinal))if(r.ExactContour is not null)sb.AppendLine($"<path id=\"{Escape(r.StableId)}\" d=\"{path(r.ExactContour.OuterLoop)}\"/>");else if(r.Boundary.Count>=3)sb.AppendLine($"<polygon id=\"{Escape(r.StableId)}\" points=\"{points(r.Boundary)}\"/>");sb.AppendLine("</g>");+ if(flat.ExactBlankContour is not null)sb.AppendLine($"<path id=\"exact-blank-contour\" d=\"{path(flat.ExactBlankContour.OuterLoop)}\" fill=\"none\" stroke=\"#020617\" stroke-width=\"0.7\"/>");+ sb.AppendLine("<g id=\"cut-contours\" fill=\"white\" stroke=\"#dc2626\" stroke-width=\"0.5\">");foreach(var c in flat.CutLoops.OrderBy(c=>c.FeatureId,StringComparer.Ordinal))if(c.ExactContour is not null)sb.AppendLine($"<path id=\"{Escape(c.FeatureId)}\" d=\"{path(c.ExactContour.OuterLoop)}\"/>");else if(c.Boundary.Count>=3)sb.AppendLine($"<polygon id=\"{Escape(c.FeatureId)}\" points=\"{points(c.Boundary)}\"/>");sb.AppendLine("</g>");+ sb.AppendLine("<g id=\"corner-reliefs\" fill=\"white\" stroke=\"#ea580c\" stroke-width=\"0.5\">");foreach(var r in (flat.ReliefLoops??[]).OrderBy(r=>r.ReliefId,StringComparer.Ordinal))sb.AppendLine($"<path id=\"{Escape(r.ReliefId)}\" d=\"{path(r.ExactContour.OuterLoop)}\"/>");sb.AppendLine("</g>");var labels=new List<(double X,double Y,double Width,string Text)>();sb.AppendLine("<g id=\"bend-lines\" fill=\"none\" stroke=\"#2563eb\" stroke-width=\"0.45\" stroke-dasharray=\"3 2\">");foreach(var bend in flat.BendLines.OrderBy(b=>b.BendId,StringComparer.Ordinal)){var x1=x(bend.Start.X);var y1=y(bend.Start.Y);var x2=x(bend.End.X);var y2=y(bend.End.Y);sb.AppendLine($"<line x1=\"{F(x1)}\" y1=\"{F(y1)}\" x2=\"{F(x2)}\" y2=\"{F(y2)}\"/>");var label=$"{bend.Direction} {F(bend.BendAngleRadians*180/Math.PI)}° R{F(bend.InsideRadius)}";var dx=x2-x1;var dy=y2-y1;var length=Math.Sqrt(dx*dx+dy*dy);var nx=length<=1e-9?0d:-dy/length;var ny=length<=1e-9?-1d:dx/length;var lx=(x1+x2)/2+nx*4;var ly=(y1+y2)/2+ny*4;var labelWidth=Math.Max(18,label.Length*1.65);for(var attempt=0;attempt<8&&labels.Any(other=>Math.Abs(other.X-lx)<(other.Width+labelWidth)/2&&Math.Abs(other.Y-ly)<4.2);attempt++){lx+=nx*5;ly+=ny*5;}lx=Math.Clamp(lx,labelWidth/2+1,width-labelWidth/2-1);ly=Math.Clamp(ly,8,height-3);labels.Add((lx,ly,labelWidth,label));}sb.AppendLine("</g>");sb.AppendLine("<g id=\"bend-labels\" stroke=\"none\" font-family=\"Inter, 'Segoe UI', Arial, sans-serif\" font-size=\"3\" text-anchor=\"middle\" dominant-baseline=\"central\">");foreach(var label in labels){sb.AppendLine($"<rect x=\"{F(label.X-label.Width/2-.7)}\" y=\"{F(label.Y-2.2)}\" width=\"{F(label.Width+1.4)}\" height=\"4.4\" rx=\"0.8\" fill=\"white\" fill-opacity=\"0.88\"/>");sb.AppendLine($"<text x=\"{F(label.X)}\" y=\"{F(label.Y)}\" fill=\"#1d4ed8\">{Escape(label.Text)}</text>");}sb.AppendLine("</g>");diff --git a/Aetheris.SheetMetal/SheetMetalTemplates.cs b/Aetheris.SheetMetal/SheetMetalTemplates.csnew file mode 100644index 00000000..24996740--- /dev/null+++ b/Aetheris.SheetMetal/SheetMetalTemplates.cs@@ -0,0 +1,48 @@+using System.Globalization;+using System.Text;++namespace Aetheris.SheetMetal;++public sealed record SheetMetalTemplatePolicy(+ double Thickness,+ double InsideRadius,+ double KFactor = .42d,+ string? Material = null,+ SheetCornerPolicy CornerPolicy = SheetCornerPolicy.Open,+ SheetReliefPolicy ReliefPolicy = SheetReliefPolicy.Auto);+public sealed record LBracketSpec(double Width,double Depth,double FlangeHeight,SheetMetalTemplatePolicy Policy);+public sealed record UChannelSpec(double Width,double Depth,double WallHeight,SheetMetalTemplatePolicy Policy);+public sealed record FourWallTraySpec(double Width,double Depth,double WallHeight,SheetMetalTemplatePolicy Policy);++/// <summary>+/// Small module-owned reusable template surface. Expansion emits ordinary SheetMetal+/// declarations so lowering, DFM, correspondence, and Concept Paths are not bypassed.+/// </summary>+public static class SheetMetalTemplates+{+ public static string LBracket(string name,LBracketSpec spec)=>Emit(name,spec.Width,spec.Depth,spec.Policy,[new("Wall","Front",spec.FlangeHeight)]);+ public static string UChannel(string name,UChannelSpec spec)=>Emit(name,spec.Width,spec.Depth,spec.Policy,[new("LeftWall","Left",spec.WallHeight),new("RightWall","Right",spec.WallHeight)]);+ public static string FourWallTray(string name,FourWallTraySpec spec)=>Emit(name,spec.Width,spec.Depth,spec.Policy,+ [new("Front","Front",spec.WallHeight),new("Right","Right",spec.WallHeight),new("Rear","Rear",spec.WallHeight),new("Left","Left",spec.WallHeight)]);++ private static string Emit(string name,double width,double depth,SheetMetalTemplatePolicy policy,IReadOnlyList<(string Name,string Edge,double Height)> flanges)+ {+ Positive(width,nameof(width));Positive(depth,nameof(depth));Positive(policy.Thickness,nameof(policy.Thickness));Positive(policy.InsideRadius,nameof(policy.InsideRadius),allowZero:true);+ if(policy.KFactor is <0 or >1)throw new ArgumentOutOfRangeException(nameof(policy.KFactor));+ var b=new StringBuilder();b.Append("SheetMetal ").Append(Safe(name)).AppendLine(" {");+ b.Append(" Thickness: ").Append(N(policy.Thickness)).AppendLine("mm;");b.Append(" KFactor: ").Append(N(policy.KFactor)).AppendLine(";");+ if(!string.IsNullOrWhiteSpace(policy.Material))b.Append(" Material: \"").Append(policy.Material!.Replace("\"","\\\"",StringComparison.Ordinal)).AppendLine("\";");+ b.Append(" Base Base { Profile: Rectangle { Width: ").Append(N(width)).Append("mm; Height: ").Append(N(depth)).AppendLine("mm; }; }");+ foreach(var flange in flanges)+ {+ Positive(flange.Height,nameof(flange.Height));b.Append(" Flange ").Append(flange.Name).Append(" { From: Base.").Append(flange.Edge).Append("; Height: ").Append(N(flange.Height)).Append("mm; Angle: 90deg; Radius: ").Append(N(policy.InsideRadius)).Append("mm;");+ if(policy.CornerPolicy==SheetCornerPolicy.Mitered)b.Append(" Corner: Miter;");+ else if(policy.ReliefPolicy!=SheetReliefPolicy.None)b.Append(" Relief: ").Append(policy.ReliefPolicy switch{SheetReliefPolicy.Round=>"Round",SheetReliefPolicy.Rectangular=>"Rectangular",_=>"Auto"}).Append(';');+ b.AppendLine(" }");+ }+ b.AppendLine("}");return b.ToString();+ }+ private static string N(double value)=>value.ToString("R",CultureInfo.InvariantCulture);+ private static void Positive(double value,string name,bool allowZero=false){if(!double.IsFinite(value)||(allowZero?value<0:value<=0))throw new ArgumentOutOfRangeException(name);}+ private static string Safe(string value){if(string.IsNullOrWhiteSpace(value)||!char.IsLetter(value[0])&&value[0]!='_')throw new ArgumentException("Template instance name must be a Firmament identifier.",nameof(value));if(value.Any(c=>!char.IsLetterOrDigit(c)&&c!='_'))throw new ArgumentException("Template instance name must be a Firmament identifier.",nameof(value));return value;}+}diff --git a/docs/modules/sheet-metal.md b/docs/modules/sheet-metal.mdindex 3fbb52b9..81b990bc 100644--- a/docs/modules/sheet-metal.md+++ b/docs/modules/sheet-metal.md@@ -1,74 +1,89 @@# Sheet Metal Module-`Aetheris.SheetMetal` 0.4.0 adds bounded M3 source-independent construction while preserving the M1/M2 imported-recovery workflow. Clean authored or reconstructed Firmament is engineering authority; imported STEP participates only in recovery or post-generation comparison.+`Aetheris.SheetMetal` M4 adds a shared exact planar-contour contract, exact line/arc corner-relief removal on bounded authored cases, stable Sheet Metal Concept Paths, and a small reusable template surface. Imported STEP recovery remains separate from authored construction.## Construction architecture```textFirmament SheetMetal-> SheetMetalPartIr (region / bend / corner / relief graph)- -> explicit sheet topology lowering- -> planar skins + analytic cylindrical skins + thickness/cut walls- -> closed formed BRep -> AP242+ -> planar + analytic cylindrical formed topology -> closed BRep -> AP242SheetMetalPartIr- -> exact graph traversal using the same bend policy- -> planar regions + neutral-axis bend strips- -> stitched outer blank + mapped cuts- -> thickness-bearing flat AP242 / SVG+ -> exact graph traversal and neutral-axis bend strips+ -> shared line/arc profile arrangement+ -> PlanarContour2 outer blank + exact cut/relief loops+ -> thickness-bearing flat AP242 / analytic SVG```-The formed path constructs known sheet topology directly. It does not union flange solids with generic `BrepBoolean`. Every authored region, bend, cut, corner, and relief has a stable formed/flat correspondence entry.+`PlanarContour2` is shared with normal Firmament Profiles. It owns one ordered outer loop, ordered inner loops, a plane frame, stable IDs, and segment provenance. Supported native curves are line segments, bounded circular arcs, and full circles. Validation rejects open chains, endpoint mismatches, duplicate IDs, wrong winding, self-intersection, invalid inner-loop nesting, and zero-length/zero-area topology.-## Canonical syntax and semantics+The bounded kernel publishes line/line, line/arc, and arc/arc intersection; normalized-parameter split/trim; explicit-side line/arc offset with miter joins; and known-topology arrangement/stitching. It does not expose a universal arbitrary Boolean or silently polygonize analytic curves.++## Authoring and Concept Paths```firmamentSheetMetal Tray {Thickness: 1.2mm;KFactor: 0.42;Base Main { Profile: Rectangle { Width: 240mm; Height: 180mm; }; }- Flange Front { From: Main.Front; Height: 40mm; Angle: 90deg; Radius: 1.5mm; Direction: Up; Relief: Auto; }- Flange Lip { From: Front.Outer; Length: 15mm; Angle: 45deg; Radius: 1.5mm; Direction: Down; }+ Flange FrontWall { From: Main.Front; Height: 40mm; Angle: 90deg; Radius: 1.5mm; Corner: Miter; }+ Flange FrontLip { From: FrontWall.Outer; Height: 10mm; Angle: 90deg; Radius: 1.2mm; Direction: Down; }Cut Fan { On: Main; Profile: Circle { Diameter: 120mm; }; At: (120mm, 90mm); }}```-`Length` and `Height` are aliases for the canonical `TangentToEdge` dimension: distance on the resulting planar flange from the bend tangent line to its free edge. `InsideRadius`/`Radius` is the physical inside radius. `Up` rotates the parent outward direction toward its material-positive normal; `Down` rotates oppositely. Angles strictly between 0° and 180° are supported; ordinary bends retain exact plane and cylinder supports.+A rectangular authored base exposes `Front`, `Right`, `Rear`, `Left`, and `Center`. A flange exposes `Root`, `Outer`, `Left`, `Right`, `LeftCorner`, `RightCorner`, and `Bend`. `Outer` is `FlangeAttachable`; `Center` is `PointCapable`, so using `Main.Center` in `Flange.From` produces a capability diagnostic rather than a topology-ID failure.++Formed/flat correspondence uses the same semantic identity: `FrontWall.Bend` maps to `Flat.FrontWall.Bend`; `Main.Front` maps to `Flat.Main.Front`. Inspect the public surface with:++```text+aetheris sheetmetal paths part.firmament+aetheris sheetmetal paths part.firmament --json+```++Normal Firmament Profile paths continue to use the same resolved line/arc substrate (`Outline.South`, `Outline.East`, and so on); M4 contour operations accept ordinary `ResolvedProfile2D` values directly.++## Corners and reliefs-`KFactor` defines `neutral radius = inside radius + K * thickness` and `bend allowance = abs(angle) * neutral radius`. The formed and flat paths consume the same bend record and policy. The flat bend line is the neutral-axis centerline of the explicit bend strip.+- `Open`: deterministic bend-end clearance; exact composed outer blank on admitted topology.+- `Mitered`: symmetric authored setback, shared by formed bend/flange width and flat blank composition.+- `RectangularRelief`: exact diagonal line-loop removal with authored/derived width and depth.+- `RoundRelief`: exact round-ended line/arc removal with retained analytic arcs.-The bounded graph supports flanges from rectangular-base `Front/Rear/Left/Right` edges and from a previously generated flange's `Outer` (`Top`) edge. Duplicate edge ownership, disconnected parents, invalid bends, and cuts reaching a region boundary/bend zone are typed rejections.+Automatic relief uses width at least one thickness and depth `inside radius + thickness`. Derived values remain in relief evidence. Flat STEP and SVG consume the same exact removal contour. Formed construction consumes the same corner record to shorten bend/flange ends, but it does not yet materialize a curved round-relief wall through the formed skins; that is a documented remaining parity seam.-## Corners, reliefs, and cuts+Multiple reliefs combined with nested flange chains can still expose an unresolved angular-order/dangling-fragment rejection in the shared arrangement. The exact-blank result is then absent and `sheetmetal-exact-blank-contour` is reported; compatibility region output remains review-only. Fabrication DFM fails when no validated exact blank is available.-Adjacent base flanges receive deterministic end trimming. `Corner: Open` is the robust baseline. `Corner: Miter` selects the smaller symmetric miter setback but remains an open, non-welded seam. `Relief: Auto`, `Rectangular`, and `Round` create typed relief intent/provenance; the bounded formed topology realizes this as bend-end/open-corner material clearance. Auto width is at least one thickness and auto depth is `inside radius + thickness`. Closed overlap/gap seams, welded corners, arbitrary corner intersections, and a freestanding shop relief library remain deferred.+## Templates-Circular holes and axis-aligned rectangular/slot profile cuts are exact formed through-cuts and map to the same owning flat region. Cuts crossing bend zones are rejected rather than warped or silently split. SVG shows region material, cut contours, neutral-axis bend lines, direction, angle, and radius.+The module owns three bounded reusable generators:-## Authored fixtures and CTC-03+- `LBracket(LBracketSpec)`+- `UChannel(UChannelSpec)`+- `FourWallTray(FourWallTraySpec)`-- [`m3-l-bracket.firmament`](../../fixtures/FirmamentV2/SheetMetal/m3-l-bracket.firmament)-- [`m3-u-channel.firmament`](../../fixtures/FirmamentV2/SheetMetal/m3-u-channel.firmament)-- [`m3-electronics-tray.firmament`](../../fixtures/FirmamentV2/SheetMetal/m3-electronics-tray.firmament)-- [`ctc03-idiomatic.firmament`](sheetmetal/artifacts/m2/ctc03-idiomatic.firmament)+Their policy parameters include thickness, inside radius, K-factor, material, corner policy, and relief policy. Expansion emits ordinary Sheet Metal declarations, so the normal lowering, DFM, Concept Paths, correspondence, STEP, and SVG paths remain authoritative. Template specialization changes dimensions without changing path shape (`Base.Front`, `Front.Outer`, `Front.Bend`, and flat counterparts).-The CTC-03 source contains no `EvidenceSource`, `FromEvidence`, face IDs, or recovered polygons. It independently generates 15 semantic regions, seven exact bends, two cuts, a closed formed BRep, and a valid flat blank. Post-generation comparison classifies it `NeedsReview`: all seven bend axis/angle/radius/graph comparisons and both cuts pass, while historical local boundary trims and the accepted M2 flat outline are not yet reproduced closely enough. This is deliberately not presented as full source parity.+## DFM and manufacturing model-## Recovery remains separate+M4 validates exact blank/relief topology, relief width/depth, inside-radius ratio, minimum flange length, cut-to-bend distance, cut-to-edge distance, overlap, finite coordinates, loop closure, winding, zero-width regions, duplicate cuts, and bend-line containment. Deterministic findings include suggested numeric repairs but never auto-apply them.-Imported STEP still follows `STEP -> RecoveredSheetMetalEvidence -> recovered draft -> engineer/LLM reconstruction`. Recovered models may retain source-edge geometry and `Partial` status. That forensic dialect is distinct from the M3 clean authored dialect and remains useful for verification.+Flat bend lines carry semantic bend ID, exact 2D endpoints, direction, angle, inside radius, thickness, K-factor, and bend allowance. SVG uses semantic IDs and separate groups for sheet regions, exact blank, cuts, corner reliefs, and bend lines. A future DXF writer can serialize cut, bend-up, bend-down, and mark layers from the flat IR without reconstructing geometry.-## Commands+## Commands and fixtures```textaetheris build part.firmament --output part-formed.stepaetheris sheetmetal flatten part.firmament --step part-flat.step --svg part-flat.svg+aetheris sheetmetal inspect part.firmament --json+aetheris sheetmetal paths part.firmamentaetheris sheetmetal recover imported.step --out-dir recoveryaetheris sheetmetal compare imported.step reconstructed.firmament```-## Bounded capability+Canonical M4 dogfood is [`m4-psu-enclosure.firmament`](../../fixtures/FirmamentV2/SheetMetal/m4-psu-enclosure.firmament). The [M4 evidence bundle](sheetmetal/artifacts/m4/README.md) records exact-kernel scope, template/DFM evidence, CTC-03 comparison, timings, hashes, and remaining limits.-M3 proves common brackets, parallel channels, four-wall open-corner trays, parent-flange lips, circular/rectangular cuts, analytic cylindrical bends, deterministic correspondence, and physical formed/flat STEP. It does not claim hems, jogs, beads, lofted bends, stamping, springback, closed-corner overlap policy, universal brake sequencing, or commercial sheet-metal parity. The largest production blocker is a richer exact 2D contour/trim kernel for commercial corner seams, arbitrary profile/relief curves, and manufacturing-grade DXF/tooling workflows.+## Bounded capability verdict-See the [M1 bundle](sheetmetal/artifacts/m1/README.md), [M2 recovery bundle](sheetmetal/artifacts/m2/README.md), and [M3 evidence](sheetmetal/artifacts/m3/README.md).+M4 can generate production-like exact blanks for common line/arc brackets, channels, open/miter trays, nested lips, cuts, and individual rectangular/round relief cases without generic BRep Boolean. It is not yet commercial sheet-metal parity: the largest blocker is robust simultaneous multi-corner relief/seam resolution—including exact formed curved relief walls and hostile historical trim reconstruction—without arrangement ambiguity.diff --git a/docs/modules/sheetmetal/artifacts/m4/README.md b/docs/modules/sheetmetal/artifacts/m4/README.mdnew file mode 100644index 00000000..4195a5ab--- /dev/null+++ b/docs/modules/sheetmetal/artifacts/m4/README.md@@ -0,0 +1,41 @@+# AETHERIS-SHEETMETAL-M4 evidence++M4 reaches **meaningful bounded production capability**, not full commercial parity. The shared line/arc contour kernel, exact profile composition, stable semantic paths, template generators, and exact single-corner relief cases work through real formed/flat/STEP paths. CTC-03 remains `NeedsReview`, and simultaneous multi-corner relief plus nested-chain arrangement is the isolated next blocker.++## Delivered++- Shared `PlanarContour2` outer/inner loop IR with stable IDs, plane frame, native line/arc/circle geometry, and provenance.+- Public bounded intersection, split, trim, validation, explicit-side offset, and known-topology arrangement operations.+- Exact flat region, cut, relief, and (when admitted) composed blank contours; analytic arcs survive SVG and flat STEP.+- Typed `Open`, `Mitered`, `RectangularRelief`, and `RoundRelief` corner records.+- Canonical base/flange/formed/flat Concept Paths and `aetheris sheetmetal paths` inspection.+- Capability-aware invalid-member diagnostics.+- Module-owned `LBracket`, `UChannel`, and `FourWallTray` generators that emit ordinary Sheet Metal semantics.+- PSU enclosure authoring fixture and semantic-only DFM repair fixture.+- Exact-blank/relief and minimum-flange DFM rules with deterministic suggestions.++## Evidence map++- [Contour audit and API](contour-kernel.md)+- [Corner and relief behavior](corner-relief.md)+- [Concept Paths and authoring](concept-path-ergonomics.md)+- [Templates and dogfood](templates.md)+- [CTC-03 formed comparison](ctc03-formed-comparison.md)+- [CTC-03 flat comparison](ctc03-flat-comparison.md)+- [DFM](dfm-summary.md)+- [Validation, performance, determinism](validation-report.md)++Retained generated artifacts:++- `psu-enclosure-formed.step`, `psu-enclosure-flat.step`, `psu-enclosure-flat.svg`+- `ctc03-m4-formed.step`, `ctc03-m4-flat.step`, `ctc03-m4-flat.svg`++## Architecture verdict++**Does Aetheris now have a sufficiently exact 2D contour/corner kernel?** Yes for bounded common line/arc profiles, open/miter topology, individual rectangular/round corner reliefs, cuts, and ordinary exact blank composition. No for the full M4 ambition: multiple interacting relief removals on four-wall/nested hostile graphs can still be rejected by arrangement angular ordering, and curved formed relief walls are not yet emitted.++**Are Concept/Concept Path ergonomics good enough?** Yes for the current authored family. `Main.Front`, `FrontWall.Outer`, `FrontWall.Bend`, and their `Flat.*` counterparts are stable and inspectable; wrong members and capabilities produce useful diagnostics. The same resolved Profile/contour substrate is used outside Sheet Metal.++**Do templates demonstrate parameter-first authoring?** Yes. L brackets, U channels, and four-wall trays lower through ordinary semantics and preserve path shape across specializations. They are a C# module API today, not yet first-class generic declarations in Firmament source.++**Largest blocker:** robust multi-corner seam/relief arrangement and corresponding exact formed trim-wall materialization, especially when several corner removals meet nested flanges or ambiguous historical contours. This is narrower than M3’s generic “exact 2D kernel” blocker and is backed by typed `sheetmetal-exact-blank-contour` diagnostics on the M3 four-relief tray and CTC-03.diff --git a/docs/modules/sheetmetal/artifacts/m4/concept-path-ergonomics.md b/docs/modules/sheetmetal/artifacts/m4/concept-path-ergonomics.mdnew file mode 100644index 00000000..1936f120--- /dev/null+++ b/docs/modules/sheetmetal/artifacts/m4/concept-path-ergonomics.md@@ -0,0 +1,28 @@+# Concept Path ergonomics++Previous Sheet Metal parsing accepted `Main.Front` and `FrontWall.Outer` as strings but did not publish a domain public surface, inspect capabilities, map paths to flat state, or distinguish a hidden member from a capability mismatch.++M4 publishes `SheetMetalConceptPath` metadata:++- rectangular base: `Front`, `Right`, `Rear`, `Left`, `Center`;+- flange: `Root`, `Outer`, `Left`, `Right`, `LeftCorner`, `RightCorner`, `Bend`;+- formed/flat pairs such as `FrontWall.Bend` / `Flat.FrontWall.Bend`;+- capabilities including `FlangeAttachable`, `BendBoundary`, `FreeEdge`, `CornerAdjacent`, `Cuttable`, `PointCapable`, and `FlatCorrespondent`.++Examples of diagnostics:++```text+`Main.Center` has capability PointCapable; `Flange.From` requires FlangeAttachable SheetEdge.+Available public edge members: Front, Right, Rear, Left.++`FrontWall.InnerFace` is not a FlangeAttachable public member.+Available public members: Root, Outer, Left, Right, LeftCorner, RightCorner, Bend.+```++Inspection:++```text+aetheris sheetmetal paths fixtures/FirmamentV2/SheetMetal/m4-psu-enclosure.firmament+```++Path shape is tested stable across `FourWallTray` specializations with different dimensions. Normal Profile dogfood remains `Concept Path Outline` -> `Profile Plate From Outline`, and M4 tests convert/offset its ordinary `ResolvedProfile2D` line/arc semantics rather than introducing Sheet Metal path logic in the geometry kernel.diff --git a/docs/modules/sheetmetal/artifacts/m4/contour-kernel.md b/docs/modules/sheetmetal/artifacts/m4/contour-kernel.mdnew file mode 100644index 00000000..bc9d4ceb--- /dev/null+++ b/docs/modules/sheetmetal/artifacts/m4/contour-kernel.md@@ -0,0 +1,36 @@+# 2D profile audit and exact contour API++## Audit++Reusable machinery already existed in `Aetheris.Kernel.Firmament.Materializer`:++- `ResolvedProfile2D` and ordered line/arc loops;+- `ProfileArrangementBuilder` analytic line-line, line-circle, and circle-circle intersections;+- exact parameter splitting, classification, material-side reconstruction, and region composition;+- profile extrusion planning/materialization preserving planar and cylindrical support geometry;+- semantic per-segment provenance and normal Profile Concept Paths.++Sheet Metal duplicated point-polygon normalization, convex hull fallback, shared-edge cancellation, overlap checks, and circle sampling. M4 does not add a Sheet-Metal-only geometry engine. It publishes the reusable profile operations and introduces a shared contour contract over the existing native curves.++## Final API++`PlanarContour2` owns:++- `StableId`, `PlaneFrame`, and `Provenance`;+- one ordered `PlanarContourLoop2 OuterLoop`;+- ordered inner loops;+- ordered `PlanarContourSegment2` values with stable ID, `ProfileSegmentProvenance`, and native geometry.++Supported native geometry is `LineArcLineSegment2D`, `LineArcCircularArc2D`, and `LineArcFullCircle2D`. Ellipses and NURBS are not admitted.++Bounded operations:++- `ProfileArrangementBuilder.IntersectBounded` returns normalized parameters, tangent/coincident evidence, and positive bounded-overlap evidence;+- `SplitBounded` and `TrimBounded` retain native curve kinds;+- `PlanarContourKernel.Offset` handles explicit left/right line/arc chains with miter support intersections;+- `ProfileArrangementBuilder.Compose` remains the known-material-topology stitch/composition authority;+- `PlanarContourKernel.FromResolvedProfile` / `ToResolvedProfile` connect normal Profiles, Sheet Metal, Drawing-ready consumers, and future DXF serialization.++Validation checks finite support, closure, endpoint authority, segment ID uniqueness, non-adjacent bounded intersection/overlap, exact signed winding (outer CCW, inner CW), nonzero area, and inner-loop nesting. Impossible/collapsed offsets are typed rejections; no silent fix or generic BRep Boolean is used.++The compatibility point boundary remains in `SheetMetalFlatPatternIr` for older consumers, but authored flat regions/cuts/reliefs now carry exact contours and manufacturing output consumes them first.diff --git a/docs/modules/sheetmetal/artifacts/m4/corner-relief.md b/docs/modules/sheetmetal/artifacts/m4/corner-relief.mdnew file mode 100644index 00000000..b70bd90d--- /dev/null+++ b/docs/modules/sheetmetal/artifacts/m4/corner-relief.md@@ -0,0 +1,14 @@+# Corner and relief kernel++| Policy | Authored semantics | Flat topology | Formed topology | Typed failure mode |+|---|---|---|---|---|+| Open | Adjacent flanges retain deterministic clearance | Exact composed line blank when graph is admitted | Bend/flange axis length is shortened at the shared end | Consumed edge or unresolved point-touch |+| Mitered | Both neighbors request `Corner: Miter` | Symmetric setback participates in exact composition | Same setback shortens both bend/flange ends | Edge consumption / invalid pairing |+| RectangularRelief | Width/depth explicit or Auto | Exact diagonal four-line removal, subtracted before extrusion | Same corner record controls bend-end clearance | width < thickness, depth < radius+thickness, arrangement rejection |+| RoundRelief | Width/depth explicit or Auto; radius = width/2 | Exact round-ended line/arc removal; arcs survive STEP/SVG | Same corner record controls bend-end clearance | collapsed radius, invalid contour, arrangement rejection |++Auto values are width at least thickness and depth `inside radius + thickness`; derived values are retained in `SheetMetalReliefIr` evidence. Flat relief contours are separate `FlatReliefLoop` values and also participate in the composed exact blank.++The formed body remains a closed analytic BRep because bend/flange ends use the same corner setback. Curved relief wall faces are not yet cut through the formed planar skins. Consequently “same semantics” is true, while exact formed round-wall parity is deferred and not claimed.++One rectangular or round relief case passes exact blank validation and physical flat STEP. Four simultaneous relief removals in the legacy M3 tray and CTC-03 currently expose dangling/angular-order diagnostics. They retain valid compatibility artifacts but fail the new exact-blank DFM rule.diff --git a/docs/modules/sheetmetal/artifacts/m4/ctc03-flat-comparison.md b/docs/modules/sheetmetal/artifacts/m4/ctc03-flat-comparison.mdnew file mode 100644index 00000000..2d3eaf20--- /dev/null+++ b/docs/modules/sheetmetal/artifacts/m4/ctc03-flat-comparison.md@@ -0,0 +1,15 @@+# CTC-03 M4 flat comparison++CTC-03 M4 flat output is valid in the compatibility region model and exports physical STEP/SVG. The new strict exact-single-blank composition rejects this hostile multi-relief/nested graph with typed dangling-fragment/angular-order diagnostics, so CTC-03 remains fabrication `NeedsReview`.++M3 -> M4 comparison metrics are unchanged:++- generated size: `392.05179 x 612.59776 mm`;+- source dimension residuals: width `12.702447 mm`, height `12.707820 mm`;+- contour RMS / p95 / max: `52.776255 / 128.113679 / 128.113679 mm`;+- cuts: both `Pass`;+- bend-line count delta: `0`;+- overlap: `false`;+- comparison status: `Fail`, overall intent status `NeedsReview`.++This is an honest non-improvement in historical parity. M4 localizes the problem more sharply: exact line/arc removal works for bounded corner fixtures, while simultaneous CTC-03 corner removals and nested service/mounting flanges leave an unresolved arrangement graph. The retained M4 STEP/SVG are review artifacts, not approved tooling output.diff --git a/docs/modules/sheetmetal/artifacts/m4/ctc03-formed-comparison.md b/docs/modules/sheetmetal/artifacts/m4/ctc03-formed-comparison.mdnew file mode 100644index 00000000..403cd73b--- /dev/null+++ b/docs/modules/sheetmetal/artifacts/m4/ctc03-formed-comparison.md@@ -0,0 +1,14 @@+# CTC-03 M4 formed comparison++CTC-03 remains independently constructed from `docs/modules/sheetmetal/artifacts/m2/ctc03-idiomatic.firmament`; no source STEP, evidence provider, raw face ID, or recovered region polygon is required for construction.++M3 -> M4 numerical comparison is unchanged because M4 deliberately did not alter already-matching bend geometry or guess historical formed trim intent:++- source -> generated RMS / p95 / max: `45.806580 / 114.786558 / 128.117359 mm`;+- generated -> source RMS / p95 / max: `11.124620 / 18.102257 / 51.535585 mm`;+- thickness residual: `0.002540 mm`;+- all seven bend axis/angle/radius/adjacency comparisons: `Pass`;+- both vent cuts: `Pass` (center residual `0.001270 mm`);+- overall: `NeedsReview`.++M4 adds stable paths for every authored flange/root/outer/bend and exact per-relief intent, but it does not fabricate historical local wall/mounting-flange trim dimensions that are absent from source intent. Formed curved relief wall materialization remains deferred.diff --git a/docs/modules/sheetmetal/artifacts/m4/ctc03-m4-flat.step b/docs/modules/sheetmetal/artifacts/m4/ctc03-m4-flat.stepnew file mode 100644index 00000000..219dacc6--- /dev/null+++ b/docs/modules/sheetmetal/artifacts/m4/ctc03-m4-flat.step@@ -0,0 +1,2028 @@+ISO-10303-21;+HEADER;+FILE_DESCRIPTION(('Aetheris AP242 subset export'),'2;1');+FILE_NAME('aetheris_export.step','1970-01-01T00:00:00',('Aetheris'),('Aetheris'),'Aetheris.Kernel','Aetheris.Kernel','');+FILE_SCHEMA(('AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF'));+ENDSEC;+DATA;+#1=CARTESIAN_POINT($,(0,0,0));+#2=DIRECTION($,(0,0,-1));+#3=DIRECTION($,(1,0,0));+#4=AXIS2_PLACEMENT_3D($,#1,#2,#3);+#5=PLANE($,#4);+#6=CARTESIAN_POINT($,(402.051790441049,133.568740352839,0));+#7=VERTEX_POINT($,#6);+#8=CARTESIAN_POINT($,(402.051790441049,485.358740352839,-0));+#9=VERTEX_POINT($,#8);+#10=CARTESIAN_POINT($,(402.051790441049,133.568740352839,0));+#11=DIRECTION($,(0,1,0));+#12=VECTOR($,#11,1);+#13=LINE($,#10,#12);+#14=EDGE_CURVE($,#7,#9,#13,.T.);+#15=ORIENTED_EDGE($,$,$,#14,.T.);+#16=CARTESIAN_POINT($,(353.537790441049,485.358740352839,0));+#17=VERTEX_POINT($,#16);+#18=CARTESIAN_POINT($,(402.051790441049,485.358740352839,-0));+#19=DIRECTION($,(-1,0,0));+#20=VECTOR($,#19,1);+#21=LINE($,#18,#20);+#22=EDGE_CURVE($,#9,#17,#21,.T.);+#23=ORIENTED_EDGE($,$,$,#22,.T.);+#24=CARTESIAN_POINT($,(347.802420352839,485.358740352839,0));+#25=VERTEX_POINT($,#24);+#26=CARTESIAN_POINT($,(353.537790441049,485.358740352839,0));+#27=DIRECTION($,(-1,0,0));+#28=VECTOR($,#27,1);+#29=LINE($,#26,#28);+#30=EDGE_CURVE($,#17,#25,#29,.T.);+#31=ORIENTED_EDGE($,$,$,#30,.T.);+#32=CARTESIAN_POINT($,(318.691480352839,485.358740352839,0));+#33=VERTEX_POINT($,#32);+#34=CARTESIAN_POINT($,(347.802420352839,485.358740352839,0));+#35=DIRECTION($,(-1,0,0));+#36=VECTOR($,#35,1);+#37=LINE($,#34,#36);+#38=EDGE_CURVE($,#25,#33,#37,.T.);+#39=ORIENTED_EDGE($,$,$,#38,.T.);+#40=CARTESIAN_POINT($,(307.22074017642,485.35874035284,0));+#41=VERTEX_POINT($,#40);+#42=CARTESIAN_POINT($,(318.691480352839,485.358740352839,0));+#43=DIRECTION($,(-1,0,0));+#44=VECTOR($,#43,1);+#45=LINE($,#42,#44);+#46=EDGE_CURVE($,#33,#41,#45,.T.);+#47=ORIENTED_EDGE($,$,$,#46,.T.);+#48=CARTESIAN_POINT($,(307.22074017642,492.266701934679,-0));+#49=VERTEX_POINT($,#48);+#50=CARTESIAN_POINT($,(307.22074017642,485.35874035284,0));+#51=DIRECTION($,(0,1,0));+#52=VECTOR($,#51,1);+#53=LINE($,#50,#52);+#54=EDGE_CURVE($,#41,#49,#53,.T.);+#55=ORIENTED_EDGE($,$,$,#54,.T.);+#56=CARTESIAN_POINT($,(302.057092906805,487.103054665064,0));+#57=VERTEX_POINT($,#56);+#58=CARTESIAN_POINT($,(307.22074017642,492.266701934679,-0));+#59=DIRECTION($,(-0.707106781186548,-0.707106781186548,0));+#60=VECTOR($,#59,1);+#61=LINE($,#58,#60);+#62=EDGE_CURVE($,#49,#57,#61,.T.);+#63=ORIENTED_EDGE($,$,$,#62,.T.);+#64=CARTESIAN_POINT($,(300.710054488645,488.450093083225,0));+#65=VERTEX_POINT($,#64);+#66=CARTESIAN_POINT($,(302.057092906805,487.103054665064,0));+#67=DIRECTION($,(-0.707106781186533,0.707106781186562,0));+#68=VECTOR($,#67,1);+#69=LINE($,#66,#68);+#70=EDGE_CURVE($,#57,#65,#69,.T.);+#71=ORIENTED_EDGE($,$,$,#70,.T.);+#72=CARTESIAN_POINT($,(305.873701758259,493.613740352839,-0));+#73=VERTEX_POINT($,#72);+#74=CARTESIAN_POINT($,(300.710054488645,488.450093083225,0));+#75=DIRECTION($,(0.707106781186548,0.707106781186548,0));+#76=VECTOR($,#75,1);+#77=LINE($,#74,#76);+#78=EDGE_CURVE($,#65,#73,#77,.T.);+#79=ORIENTED_EDGE($,$,$,#78,.T.);+#80=CARTESIAN_POINT($,(298.96574017642,493.613740352839,0));+#81=VERTEX_POINT($,#80);+#82=CARTESIAN_POINT($,(305.873701758259,493.613740352839,-0));+#83=DIRECTION($,(-1,0,0));+#84=VECTOR($,#83,1);+#85=LINE($,#82,#84);+#86=EDGE_CURVE($,#73,#81,#85,.T.);+#87=ORIENTED_EDGE($,$,$,#86,.T.);+#88=CARTESIAN_POINT($,(298.96574017642,505.084480529259,0));+#89=VERTEX_POINT($,#88);+#90=CARTESIAN_POINT($,(298.96574017642,493.613740352839,0));+#91=DIRECTION($,(0,1,0));+#92=VECTOR($,#91,1);+#93=LINE($,#90,#92);+#94=EDGE_CURVE($,#81,#89,#93,.T.);+#95=ORIENTED_EDGE($,$,$,#94,.T.);+#96=CARTESIAN_POINT($,(298.96574017642,566.677020529259,0));+#97=VERTEX_POINT($,#96);+#98=CARTESIAN_POINT($,(298.96574017642,505.084480529259,0));+#99=DIRECTION($,(0,1,0));+#100=VECTOR($,#99,1);+#101=LINE($,#98,#100);+#102=EDGE_CURVE($,#89,#97,#101,.T.);+#103=ORIENTED_EDGE($,$,$,#102,.T.);+#104=CARTESIAN_POINT($,(298.96574017642,578.147760705679,0));+#105=VERTEX_POINT($,#104);+#106=CARTESIAN_POINT($,(298.96574017642,566.677020529259,0));+#107=DIRECTION($,(0,1,0));+#108=VECTOR($,#107,1);+#109=LINE($,#106,#108);+#110=EDGE_CURVE($,#97,#105,#109,.T.);+#111=ORIENTED_EDGE($,$,$,#110,.T.);+#112=CARTESIAN_POINT($,(298.96574017642,622.597760705679,-0));+#113=VERTEX_POINT($,#112);+#114=CARTESIAN_POINT($,(298.96574017642,578.147760705679,0));+#115=DIRECTION($,(0,1,0));+#116=VECTOR($,#115,1);+#117=LINE($,#114,#116);+#118=EDGE_CURVE($,#105,#113,#117,.T.);+#119=ORIENTED_EDGE($,$,$,#118,.T.);+#120=CARTESIAN_POINT($,(74.1757401764197,622.597760705679,-0));+#121=VERTEX_POINT($,#120);+#122=CARTESIAN_POINT($,(298.96574017642,622.597760705679,-0));+#123=DIRECTION($,(-1,0,0));+#124=VECTOR($,#123,1);+#125=LINE($,#122,#124);+#126=EDGE_CURVE($,#113,#121,#125,.T.);+#127=ORIENTED_EDGE($,$,$,#126,.T.);+#128=CARTESIAN_POINT($,(74.1757401764197,578.147760705679,0));+#129=VERTEX_POINT($,#128);+#130=CARTESIAN_POINT($,(74.1757401764197,622.597760705679,-0));+#131=DIRECTION($,(0,-1,0));+#132=VECTOR($,#131,1);+#133=LINE($,#130,#132);+#134=EDGE_CURVE($,#121,#129,#133,.T.);+#135=ORIENTED_EDGE($,$,$,#134,.T.);+#136=CARTESIAN_POINT($,(74.1757401764197,566.677020529259,0));+#137=VERTEX_POINT($,#136);+#138=CARTESIAN_POINT($,(74.1757401764197,578.147760705679,0));+#139=DIRECTION($,(0,-1,0));+#140=VECTOR($,#139,1);+#141=LINE($,#138,#140);+#142=EDGE_CURVE($,#129,#137,#141,.T.);+#143=ORIENTED_EDGE($,$,$,#142,.T.);+#144=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,0));+#145=VERTEX_POINT($,#144);+#146=CARTESIAN_POINT($,(74.1757401764197,566.677020529259,0));+#147=DIRECTION($,(0,-1,0));+#148=VECTOR($,#147,1);+#149=LINE($,#146,#148);+#150=EDGE_CURVE($,#137,#145,#149,.T.);+#151=ORIENTED_EDGE($,$,$,#150,.T.);+#152=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,0));+#153=VERTEX_POINT($,#152);+#154=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,0));+#155=DIRECTION($,(0,-1,0));+#156=VECTOR($,#155,1);+#157=LINE($,#154,#156);+#158=EDGE_CURVE($,#145,#153,#157,.T.);+#159=ORIENTED_EDGE($,$,$,#158,.T.);+#160=CARTESIAN_POINT($,(67.2677785945801,493.61374035284,-0));+#161=VERTEX_POINT($,#160);+#162=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,0));+#163=DIRECTION($,(-1,0,0));+#164=VECTOR($,#163,1);+#165=LINE($,#162,#164);+#166=EDGE_CURVE($,#153,#161,#165,.T.);+#167=ORIENTED_EDGE($,$,$,#166,.T.);+#168=CARTESIAN_POINT($,(72.4314258641949,488.450093083225,0));+#169=VERTEX_POINT($,#168);+#170=CARTESIAN_POINT($,(67.2677785945801,493.61374035284,-0));+#171=DIRECTION($,(0.707106781186549,-0.707106781186547,0));+#172=VECTOR($,#171,1);+#173=LINE($,#170,#172);+#174=EDGE_CURVE($,#161,#169,#173,.T.);+#175=ORIENTED_EDGE($,$,$,#174,.T.);+#176=CARTESIAN_POINT($,(71.0843874460345,487.103054665064,0));+#177=VERTEX_POINT($,#176);+#178=CARTESIAN_POINT($,(72.4314258641949,488.450093083225,0));+#179=DIRECTION($,(-0.707106781186536,-0.707106781186559,0));+#180=VECTOR($,#179,1);+#181=LINE($,#178,#180);+#182=EDGE_CURVE($,#169,#177,#181,.T.);+#183=ORIENTED_EDGE($,$,$,#182,.T.);+#184=CARTESIAN_POINT($,(65.9207401764197,492.266701934679,-0));+#185=VERTEX_POINT($,#184);+#186=CARTESIAN_POINT($,(71.0843874460345,487.103054665064,0));+#187=DIRECTION($,(-0.707106781186549,0.707106781186547,0));+#188=VECTOR($,#187,1);+#189=LINE($,#186,#188);+#190=EDGE_CURVE($,#177,#185,#189,.T.);+#191=ORIENTED_EDGE($,$,$,#190,.T.);+#192=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,0));+#193=VERTEX_POINT($,#192);+#194=CARTESIAN_POINT($,(65.9207401764197,492.266701934679,-0));+#195=DIRECTION($,(0,-1,0));+#196=VECTOR($,#195,1);+#197=LINE($,#194,#196);+#198=EDGE_CURVE($,#185,#193,#197,.T.);+#199=ORIENTED_EDGE($,$,$,#198,.T.);+#200=CARTESIAN_POINT($,(54.45,485.35874035284,0));+#201=VERTEX_POINT($,#200);+#202=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,0));+#203=DIRECTION($,(-1,0,0));+#204=VECTOR($,#203,1);+#205=LINE($,#202,#204);+#206=EDGE_CURVE($,#193,#201,#205,.T.);+#207=ORIENTED_EDGE($,$,$,#206,.T.);+#208=CARTESIAN_POINT($,(10,485.35874035284,-0));+#209=VERTEX_POINT($,#208);+#210=CARTESIAN_POINT($,(54.45,485.35874035284,0));+#211=DIRECTION($,(-1,0,0));+#212=VECTOR($,#211,1);+#213=LINE($,#210,#212);+#214=EDGE_CURVE($,#201,#209,#213,.T.);+#215=ORIENTED_EDGE($,$,$,#214,.T.);+#216=CARTESIAN_POINT($,(10,133.568740352839,-0));+#217=VERTEX_POINT($,#216);+#218=CARTESIAN_POINT($,(10,485.35874035284,-0));+#219=DIRECTION($,(0,-1,0));+#220=VECTOR($,#219,1);+#221=LINE($,#218,#220);+#222=EDGE_CURVE($,#209,#217,#221,.T.);+#223=ORIENTED_EDGE($,$,$,#222,.T.);+#224=CARTESIAN_POINT($,(54.45,133.568740352839,0));+#225=VERTEX_POINT($,#224);+#226=CARTESIAN_POINT($,(10,133.568740352839,-0));+#227=DIRECTION($,(1,0,0));+#228=VECTOR($,#227,1);+#229=LINE($,#226,#228);+#230=EDGE_CURVE($,#217,#225,#229,.T.);+#231=ORIENTED_EDGE($,$,$,#230,.T.);+#232=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,0));+#233=VERTEX_POINT($,#232);+#234=CARTESIAN_POINT($,(54.45,133.568740352839,0));+#235=DIRECTION($,(1,0,0));+#236=VECTOR($,#235,1);+#237=LINE($,#234,#236);+#238=EDGE_CURVE($,#225,#233,#237,.T.);+#239=ORIENTED_EDGE($,$,$,#238,.T.);+#240=CARTESIAN_POINT($,(65.9207401764197,126.660778771,-0));+#241=VERTEX_POINT($,#240);+#242=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,0));+#243=DIRECTION($,(0,-1,0));+#244=VECTOR($,#243,1);+#245=LINE($,#242,#244);+#246=EDGE_CURVE($,#233,#241,#245,.T.);+#247=ORIENTED_EDGE($,$,$,#246,.T.);+#248=CARTESIAN_POINT($,(71.0843874460345,131.824426040615,0));+#249=VERTEX_POINT($,#248);+#250=CARTESIAN_POINT($,(65.9207401764197,126.660778771,-0));+#251=DIRECTION($,(0.707106781186548,0.707106781186548,0));+#252=VECTOR($,#251,1);+#253=LINE($,#250,#252);+#254=EDGE_CURVE($,#241,#249,#253,.T.);+#255=ORIENTED_EDGE($,$,$,#254,.T.);+#256=CARTESIAN_POINT($,(72.4314258641949,130.477387622454,0));+#257=VERTEX_POINT($,#256);+#258=CARTESIAN_POINT($,(71.0843874460345,131.824426040615,0));+#259=DIRECTION($,(0.707106781186551,-0.707106781186544,0));+#260=VECTOR($,#259,1);+#261=LINE($,#258,#260);+#262=EDGE_CURVE($,#249,#257,#261,.T.);+#263=ORIENTED_EDGE($,$,$,#262,.T.);+#264=CARTESIAN_POINT($,(67.2677785945801,125.313740352839,-0));+#265=VERTEX_POINT($,#264);+#266=CARTESIAN_POINT($,(72.4314258641949,130.477387622454,0));+#267=DIRECTION($,(-0.707106781186548,-0.707106781186548,0));+#268=VECTOR($,#267,1);+#269=LINE($,#266,#268);+#270=EDGE_CURVE($,#257,#265,#269,.T.);+#271=ORIENTED_EDGE($,$,$,#270,.T.);+#272=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,0));+#273=VERTEX_POINT($,#272);+#274=CARTESIAN_POINT($,(67.2677785945801,125.313740352839,-0));+#275=DIRECTION($,(1,0,0));+#276=VECTOR($,#275,1);+#277=LINE($,#274,#276);+#278=EDGE_CURVE($,#265,#273,#277,.T.);+#279=ORIENTED_EDGE($,$,$,#278,.T.);+#280=CARTESIAN_POINT($,(74.1757401764197,113.84300017642,0));+#281=VERTEX_POINT($,#280);+#282=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,0));+#283=DIRECTION($,(0,-1,0));+#284=VECTOR($,#283,1);+#285=LINE($,#282,#284);+#286=EDGE_CURVE($,#273,#281,#285,.T.);+#287=ORIENTED_EDGE($,$,$,#286,.T.);+#288=CARTESIAN_POINT($,(74.1757401764197,52.2504601764197,0));+#289=VERTEX_POINT($,#288);+#290=CARTESIAN_POINT($,(74.1757401764197,113.84300017642,0));+#291=DIRECTION($,(0,-1,0));+#292=VECTOR($,#291,1);+#293=LINE($,#290,#292);+#294=EDGE_CURVE($,#281,#289,#293,.T.);+#295=ORIENTED_EDGE($,$,$,#294,.T.);+#296=CARTESIAN_POINT($,(74.1757401764197,40.77972,0));+#297=VERTEX_POINT($,#296);+#298=CARTESIAN_POINT($,(74.1757401764197,52.2504601764197,0));+#299=DIRECTION($,(0,-1,0));+#300=VECTOR($,#299,1);+#301=LINE($,#298,#300);+#302=EDGE_CURVE($,#289,#297,#301,.T.);+#303=ORIENTED_EDGE($,$,$,#302,.T.);+#304=CARTESIAN_POINT($,(74.1757401764197,10,-0));+#305=VERTEX_POINT($,#304);+#306=CARTESIAN_POINT($,(74.1757401764197,40.77972,0));+#307=DIRECTION($,(0,-1,0));+#308=VECTOR($,#307,1);+#309=LINE($,#306,#308);+#310=EDGE_CURVE($,#297,#305,#309,.T.);+#311=ORIENTED_EDGE($,$,$,#310,.T.);+#312=CARTESIAN_POINT($,(298.96574017642,10,-0));+#313=VERTEX_POINT($,#312);+#314=CARTESIAN_POINT($,(74.1757401764197,10,-0));+#315=DIRECTION($,(1,0,0));+#316=VECTOR($,#315,1);+#317=LINE($,#314,#316);+#318=EDGE_CURVE($,#305,#313,#317,.T.);+#319=ORIENTED_EDGE($,$,$,#318,.T.);+#320=CARTESIAN_POINT($,(298.96574017642,40.77972,0));+#321=VERTEX_POINT($,#320);+#322=CARTESIAN_POINT($,(298.96574017642,10,-0));+#323=DIRECTION($,(0,1,0));+#324=VECTOR($,#323,1);+#325=LINE($,#322,#324);+#326=EDGE_CURVE($,#313,#321,#325,.T.);+#327=ORIENTED_EDGE($,$,$,#326,.T.);+#328=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,0));+#329=VERTEX_POINT($,#328);+#330=CARTESIAN_POINT($,(298.96574017642,40.77972,0));+#331=DIRECTION($,(0,1,0));+#332=VECTOR($,#331,1);+#333=LINE($,#330,#332);+#334=EDGE_CURVE($,#321,#329,#333,.T.);+#335=ORIENTED_EDGE($,$,$,#334,.T.);+#336=CARTESIAN_POINT($,(298.96574017642,113.84300017642,0));+#337=VERTEX_POINT($,#336);+#338=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,0));+#339=DIRECTION($,(0,1,0));+#340=VECTOR($,#339,1);+#341=LINE($,#338,#340);+#342=EDGE_CURVE($,#329,#337,#341,.T.);+#343=ORIENTED_EDGE($,$,$,#342,.T.);+#344=CARTESIAN_POINT($,(298.96574017642,125.313740352839,0));+#345=VERTEX_POINT($,#344);+#346=CARTESIAN_POINT($,(298.96574017642,113.84300017642,0));+#347=DIRECTION($,(0,1,0));+#348=VECTOR($,#347,1);+#349=LINE($,#346,#348);+#350=EDGE_CURVE($,#337,#345,#349,.T.);+#351=ORIENTED_EDGE($,$,$,#350,.T.);+#352=CARTESIAN_POINT($,(305.873701758259,125.313740352839,-0));+#353=VERTEX_POINT($,#352);+#354=CARTESIAN_POINT($,(298.96574017642,125.313740352839,0));+#355=DIRECTION($,(1,0,0));+#356=VECTOR($,#355,1);+#357=LINE($,#354,#356);+#358=EDGE_CURVE($,#345,#353,#357,.T.);+#359=ORIENTED_EDGE($,$,$,#358,.T.);+#360=CARTESIAN_POINT($,(300.710054488645,130.477387622454,0));+#361=VERTEX_POINT($,#360);+#362=CARTESIAN_POINT($,(305.873701758259,125.313740352839,-0));+#363=DIRECTION($,(-0.707106781186547,0.707106781186549,0));+#364=VECTOR($,#363,1);+#365=LINE($,#362,#364);+#366=EDGE_CURVE($,#353,#361,#365,.T.);+#367=ORIENTED_EDGE($,$,$,#366,.T.);+#368=CARTESIAN_POINT($,(302.057092906805,131.824426040615,0));+#369=VERTEX_POINT($,#368);+#370=CARTESIAN_POINT($,(300.710054488645,130.477387622454,0));+#371=DIRECTION($,(0.707106781186548,0.707106781186548,0));+#372=VECTOR($,#371,1);+#373=LINE($,#370,#372);+#374=EDGE_CURVE($,#361,#369,#373,.T.);+#375=ORIENTED_EDGE($,$,$,#374,.T.);+#376=CARTESIAN_POINT($,(307.22074017642,126.660778771,-0));+#377=VERTEX_POINT($,#376);+#378=CARTESIAN_POINT($,(302.057092906805,131.824426040615,0));+#379=DIRECTION($,(0.707106781186547,-0.707106781186549,0));+#380=VECTOR($,#379,1);+#381=LINE($,#378,#380);+#382=EDGE_CURVE($,#369,#377,#381,.T.);+#383=ORIENTED_EDGE($,$,$,#382,.T.);+#384=CARTESIAN_POINT($,(307.22074017642,133.568740352839,0));+#385=VERTEX_POINT($,#384);+#386=CARTESIAN_POINT($,(307.22074017642,126.660778771,-0));+#387=DIRECTION($,(0,1,0));+#388=VECTOR($,#387,1);+#389=LINE($,#386,#388);+#390=EDGE_CURVE($,#377,#385,#389,.T.);+#391=ORIENTED_EDGE($,$,$,#390,.T.);+#392=CARTESIAN_POINT($,(318.691480352839,133.568740352839,0));+#393=VERTEX_POINT($,#392);+#394=CARTESIAN_POINT($,(307.22074017642,133.568740352839,0));+#395=DIRECTION($,(1,0,0));+#396=VECTOR($,#395,1);+#397=LINE($,#394,#396);+#398=EDGE_CURVE($,#385,#393,#397,.T.);+#399=ORIENTED_EDGE($,$,$,#398,.T.);+#400=CARTESIAN_POINT($,(347.802420352839,133.568740352839,0));+#401=VERTEX_POINT($,#400);+#402=CARTESIAN_POINT($,(318.691480352839,133.568740352839,0));+#403=DIRECTION($,(1,0,0));+#404=VECTOR($,#403,1);+#405=LINE($,#402,#404);+#406=EDGE_CURVE($,#393,#401,#405,.T.);+#407=ORIENTED_EDGE($,$,$,#406,.T.);+#408=CARTESIAN_POINT($,(353.537790441049,133.568740352839,0));+#409=VERTEX_POINT($,#408);+#410=CARTESIAN_POINT($,(347.802420352839,133.568740352839,0));+#411=DIRECTION($,(1,0,0));+#412=VECTOR($,#411,1);+#413=LINE($,#410,#412);+#414=EDGE_CURVE($,#401,#409,#413,.T.);+#415=ORIENTED_EDGE($,$,$,#414,.T.);+#416=CARTESIAN_POINT($,(353.537790441049,133.568740352839,0));+#417=DIRECTION($,(1,0,0));+#418=VECTOR($,#417,1);+#419=LINE($,#416,#418);+#420=EDGE_CURVE($,#409,#7,#419,.T.);+#421=ORIENTED_EDGE($,$,$,#420,.T.);+#422=EDGE_LOOP($,(#15,#23,#31,#39,#47,#55,#63,#71,#79,#87,#95,#103,#111,#119,#127,#135,#143,#151,#159,#167,#175,#183,#191,#199,#207,#215,#223,#231,#239,#247,#255,#263,#271,#279,#287,#295,#303,#311,#319,#327,#335,#343,#351,#359,#367,#375,#383,#391,#399,#407,#415,#421));+#423=FACE_OUTER_BOUND('',#422,.T.);+#424=CARTESIAN_POINT($,(107.67834017642,189.298880352839,-0));+#425=VERTEX_POINT($,#424);+#426=CARTESIAN_POINT($,(126.72834017642,189.298880352839,0));+#427=VERTEX_POINT($,#426);+#428=CARTESIAN_POINT($,(107.67834017642,189.298880352839,-0));+#429=DIRECTION($,(1,0,0));+#430=VECTOR($,#429,1);+#431=LINE($,#428,#430);+#432=EDGE_CURVE($,#425,#427,#431,.T.);+#433=ORIENTED_EDGE($,$,$,#432,.F.);+#434=CARTESIAN_POINT($,(107.67834017642,278.198880352839,-0));+#435=VERTEX_POINT($,#434);+#436=CARTESIAN_POINT($,(107.67834017642,278.198880352839,-0));+#437=DIRECTION($,(0,-1,0));+#438=VECTOR($,#437,1);+#439=LINE($,#436,#438);+#440=EDGE_CURVE($,#435,#425,#439,.T.);+#441=ORIENTED_EDGE($,$,$,#440,.F.);+#442=CARTESIAN_POINT($,(126.72834017642,278.198880352839,-0));+#443=VERTEX_POINT($,#442);+#444=CARTESIAN_POINT($,(126.72834017642,278.198880352839,-0));+#445=DIRECTION($,(-1,0,0));+#446=VECTOR($,#445,1);+#447=LINE($,#444,#446);+#448=EDGE_CURVE($,#443,#435,#447,.T.);+#449=ORIENTED_EDGE($,$,$,#448,.F.);+#450=CARTESIAN_POINT($,(126.72834017642,189.298880352839,0));+#451=DIRECTION($,(0,1,0));+#452=VECTOR($,#451,1);+#453=LINE($,#450,#452);+#454=EDGE_CURVE($,#427,#443,#453,.T.);+#455=ORIENTED_EDGE($,$,$,#454,.F.);+#456=EDGE_LOOP($,(#433,#441,#449,#455));+#457=FACE_BOUND('',#456,.T.);+#458=CARTESIAN_POINT($,(171.17834017642,189.298880352839,-0));+#459=VERTEX_POINT($,#458);+#460=CARTESIAN_POINT($,(190.22834017642,189.298880352839,0));+#461=VERTEX_POINT($,#460);+#462=CARTESIAN_POINT($,(171.17834017642,189.298880352839,-0));+#463=DIRECTION($,(1,0,0));+#464=VECTOR($,#463,1);+#465=LINE($,#462,#464);+#466=EDGE_CURVE($,#459,#461,#465,.T.);+#467=ORIENTED_EDGE($,$,$,#466,.F.);+#468=CARTESIAN_POINT($,(171.17834017642,278.198880352839,-0));+#469=VERTEX_POINT($,#468);+#470=CARTESIAN_POINT($,(171.17834017642,278.198880352839,-0));+#471=DIRECTION($,(0,-1,0));+#472=VECTOR($,#471,1);+#473=LINE($,#470,#472);+#474=EDGE_CURVE($,#469,#459,#473,.T.);+#475=ORIENTED_EDGE($,$,$,#474,.F.);+#476=CARTESIAN_POINT($,(190.22834017642,278.198880352839,-0));+#477=VERTEX_POINT($,#476);+#478=CARTESIAN_POINT($,(190.22834017642,278.198880352839,-0));+#479=DIRECTION($,(-1,0,0));+#480=VECTOR($,#479,1);+#481=LINE($,#478,#480);+#482=EDGE_CURVE($,#477,#469,#481,.T.);+#483=ORIENTED_EDGE($,$,$,#482,.F.);+#484=CARTESIAN_POINT($,(190.22834017642,189.298880352839,0));+#485=DIRECTION($,(0,1,0));+#486=VECTOR($,#485,1);+#487=LINE($,#484,#486);+#488=EDGE_CURVE($,#461,#477,#487,.T.);+#489=ORIENTED_EDGE($,$,$,#488,.F.);+#490=EDGE_LOOP($,(#467,#475,#483,#489));+#491=FACE_BOUND('',#490,.T.);+#492=ADVANCED_FACE('',(#423,#457,#491),#5,.T.);+#493=CARTESIAN_POINT($,(0,0,1.905));+#494=DIRECTION($,(0,0,1));+#495=DIRECTION($,(1,0,0));+#496=AXIS2_PLACEMENT_3D($,#493,#494,#495);+#497=PLANE($,#496);+#498=CARTESIAN_POINT($,(402.051790441049,133.568740352839,1.905));+#499=VERTEX_POINT($,#498);+#500=CARTESIAN_POINT($,(402.051790441049,485.358740352839,1.905));+#501=VERTEX_POINT($,#500);+#502=CARTESIAN_POINT($,(402.051790441049,133.568740352839,1.905));+#503=DIRECTION($,(0,1,0));+#504=VECTOR($,#503,1);+#505=LINE($,#502,#504);+#506=EDGE_CURVE($,#499,#501,#505,.T.);+#507=ORIENTED_EDGE($,$,$,#506,.T.);+#508=CARTESIAN_POINT($,(353.537790441049,485.358740352839,1.905));+#509=VERTEX_POINT($,#508);+#510=CARTESIAN_POINT($,(402.051790441049,485.358740352839,1.905));+#511=DIRECTION($,(-1,0,0));+#512=VECTOR($,#511,1);+#513=LINE($,#510,#512);+#514=EDGE_CURVE($,#501,#509,#513,.T.);+#515=ORIENTED_EDGE($,$,$,#514,.T.);+#516=CARTESIAN_POINT($,(347.802420352839,485.358740352839,1.905));+#517=VERTEX_POINT($,#516);+#518=CARTESIAN_POINT($,(353.537790441049,485.358740352839,1.905));+#519=DIRECTION($,(-1,0,0));+#520=VECTOR($,#519,1);+#521=LINE($,#518,#520);+#522=EDGE_CURVE($,#509,#517,#521,.T.);+#523=ORIENTED_EDGE($,$,$,#522,.T.);+#524=CARTESIAN_POINT($,(318.691480352839,485.358740352839,1.905));+#525=VERTEX_POINT($,#524);+#526=CARTESIAN_POINT($,(347.802420352839,485.358740352839,1.905));+#527=DIRECTION($,(-1,0,0));+#528=VECTOR($,#527,1);+#529=LINE($,#526,#528);+#530=EDGE_CURVE($,#517,#525,#529,.T.);+#531=ORIENTED_EDGE($,$,$,#530,.T.);+#532=CARTESIAN_POINT($,(307.22074017642,485.35874035284,1.905));+#533=VERTEX_POINT($,#532);+#534=CARTESIAN_POINT($,(318.691480352839,485.358740352839,1.905));+#535=DIRECTION($,(-1,0,0));+#536=VECTOR($,#535,1);+#537=LINE($,#534,#536);+#538=EDGE_CURVE($,#525,#533,#537,.T.);+#539=ORIENTED_EDGE($,$,$,#538,.T.);+#540=CARTESIAN_POINT($,(307.22074017642,492.266701934679,1.905));+#541=VERTEX_POINT($,#540);+#542=CARTESIAN_POINT($,(307.22074017642,485.35874035284,1.905));+#543=DIRECTION($,(0,1,0));+#544=VECTOR($,#543,1);+#545=LINE($,#542,#544);+#546=EDGE_CURVE($,#533,#541,#545,.T.);+#547=ORIENTED_EDGE($,$,$,#546,.T.);+#548=CARTESIAN_POINT($,(302.057092906805,487.103054665064,1.905));+#549=VERTEX_POINT($,#548);+#550=CARTESIAN_POINT($,(307.22074017642,492.266701934679,1.905));+#551=DIRECTION($,(-0.707106781186548,-0.707106781186548,0));+#552=VECTOR($,#551,1);+#553=LINE($,#550,#552);+#554=EDGE_CURVE($,#541,#549,#553,.T.);+#555=ORIENTED_EDGE($,$,$,#554,.T.);+#556=CARTESIAN_POINT($,(300.710054488645,488.450093083225,1.905));+#557=VERTEX_POINT($,#556);+#558=CARTESIAN_POINT($,(302.057092906805,487.103054665064,1.905));+#559=DIRECTION($,(-0.707106781186533,0.707106781186562,0));+#560=VECTOR($,#559,1);+#561=LINE($,#558,#560);+#562=EDGE_CURVE($,#549,#557,#561,.T.);+#563=ORIENTED_EDGE($,$,$,#562,.T.);+#564=CARTESIAN_POINT($,(305.873701758259,493.613740352839,1.905));+#565=VERTEX_POINT($,#564);+#566=CARTESIAN_POINT($,(300.710054488645,488.450093083225,1.905));+#567=DIRECTION($,(0.707106781186548,0.707106781186548,0));+#568=VECTOR($,#567,1);+#569=LINE($,#566,#568);+#570=EDGE_CURVE($,#557,#565,#569,.T.);+#571=ORIENTED_EDGE($,$,$,#570,.T.);+#572=CARTESIAN_POINT($,(298.96574017642,493.613740352839,1.905));+#573=VERTEX_POINT($,#572);+#574=CARTESIAN_POINT($,(305.873701758259,493.613740352839,1.905));+#575=DIRECTION($,(-1,0,0));+#576=VECTOR($,#575,1);+#577=LINE($,#574,#576);+#578=EDGE_CURVE($,#565,#573,#577,.T.);+#579=ORIENTED_EDGE($,$,$,#578,.T.);+#580=CARTESIAN_POINT($,(298.96574017642,505.084480529259,1.905));+#581=VERTEX_POINT($,#580);+#582=CARTESIAN_POINT($,(298.96574017642,493.613740352839,1.905));+#583=DIRECTION($,(0,1,0));+#584=VECTOR($,#583,1);+#585=LINE($,#582,#584);+#586=EDGE_CURVE($,#573,#581,#585,.T.);+#587=ORIENTED_EDGE($,$,$,#586,.T.);+#588=CARTESIAN_POINT($,(298.96574017642,566.677020529259,1.905));+#589=VERTEX_POINT($,#588);+#590=CARTESIAN_POINT($,(298.96574017642,505.084480529259,1.905));+#591=DIRECTION($,(0,1,0));+#592=VECTOR($,#591,1);+#593=LINE($,#590,#592);+#594=EDGE_CURVE($,#581,#589,#593,.T.);+#595=ORIENTED_EDGE($,$,$,#594,.T.);+#596=CARTESIAN_POINT($,(298.96574017642,578.147760705679,1.905));+#597=VERTEX_POINT($,#596);+#598=CARTESIAN_POINT($,(298.96574017642,566.677020529259,1.905));+#599=DIRECTION($,(0,1,0));+#600=VECTOR($,#599,1);+#601=LINE($,#598,#600);+#602=EDGE_CURVE($,#589,#597,#601,.T.);+#603=ORIENTED_EDGE($,$,$,#602,.T.);+#604=CARTESIAN_POINT($,(298.96574017642,622.597760705679,1.905));+#605=VERTEX_POINT($,#604);+#606=CARTESIAN_POINT($,(298.96574017642,578.147760705679,1.905));+#607=DIRECTION($,(0,1,0));+#608=VECTOR($,#607,1);+#609=LINE($,#606,#608);+#610=EDGE_CURVE($,#597,#605,#609,.T.);+#611=ORIENTED_EDGE($,$,$,#610,.T.);+#612=CARTESIAN_POINT($,(74.1757401764197,622.597760705679,1.905));+#613=VERTEX_POINT($,#612);+#614=CARTESIAN_POINT($,(298.96574017642,622.597760705679,1.905));+#615=DIRECTION($,(-1,0,0));+#616=VECTOR($,#615,1);+#617=LINE($,#614,#616);+#618=EDGE_CURVE($,#605,#613,#617,.T.);+#619=ORIENTED_EDGE($,$,$,#618,.T.);+#620=CARTESIAN_POINT($,(74.1757401764197,578.147760705679,1.905));+#621=VERTEX_POINT($,#620);+#622=CARTESIAN_POINT($,(74.1757401764197,622.597760705679,1.905));+#623=DIRECTION($,(0,-1,0));+#624=VECTOR($,#623,1);+#625=LINE($,#622,#624);+#626=EDGE_CURVE($,#613,#621,#625,.T.);+#627=ORIENTED_EDGE($,$,$,#626,.T.);+#628=CARTESIAN_POINT($,(74.1757401764197,566.677020529259,1.905));+#629=VERTEX_POINT($,#628);+#630=CARTESIAN_POINT($,(74.1757401764197,578.147760705679,1.905));+#631=DIRECTION($,(0,-1,0));+#632=VECTOR($,#631,1);+#633=LINE($,#630,#632);+#634=EDGE_CURVE($,#621,#629,#633,.T.);+#635=ORIENTED_EDGE($,$,$,#634,.T.);+#636=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,1.905));+#637=VERTEX_POINT($,#636);+#638=CARTESIAN_POINT($,(74.1757401764197,566.677020529259,1.905));+#639=DIRECTION($,(0,-1,0));+#640=VECTOR($,#639,1);+#641=LINE($,#638,#640);+#642=EDGE_CURVE($,#629,#637,#641,.T.);+#643=ORIENTED_EDGE($,$,$,#642,.T.);+#644=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,1.905));+#645=VERTEX_POINT($,#644);+#646=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,1.905));+#647=DIRECTION($,(0,-1,0));+#648=VECTOR($,#647,1);+#649=LINE($,#646,#648);+#650=EDGE_CURVE($,#637,#645,#649,.T.);+#651=ORIENTED_EDGE($,$,$,#650,.T.);+#652=CARTESIAN_POINT($,(67.2677785945801,493.61374035284,1.905));+#653=VERTEX_POINT($,#652);+#654=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,1.905));+#655=DIRECTION($,(-1,0,0));+#656=VECTOR($,#655,1);+#657=LINE($,#654,#656);+#658=EDGE_CURVE($,#645,#653,#657,.T.);+#659=ORIENTED_EDGE($,$,$,#658,.T.);+#660=CARTESIAN_POINT($,(72.4314258641949,488.450093083225,1.905));+#661=VERTEX_POINT($,#660);+#662=CARTESIAN_POINT($,(67.2677785945801,493.61374035284,1.905));+#663=DIRECTION($,(0.707106781186549,-0.707106781186547,0));+#664=VECTOR($,#663,1);+#665=LINE($,#662,#664);+#666=EDGE_CURVE($,#653,#661,#665,.T.);+#667=ORIENTED_EDGE($,$,$,#666,.T.);+#668=CARTESIAN_POINT($,(71.0843874460345,487.103054665064,1.905));+#669=VERTEX_POINT($,#668);+#670=CARTESIAN_POINT($,(72.4314258641949,488.450093083225,1.905));+#671=DIRECTION($,(-0.707106781186536,-0.707106781186559,0));+#672=VECTOR($,#671,1);+#673=LINE($,#670,#672);+#674=EDGE_CURVE($,#661,#669,#673,.T.);+#675=ORIENTED_EDGE($,$,$,#674,.T.);+#676=CARTESIAN_POINT($,(65.9207401764197,492.266701934679,1.905));+#677=VERTEX_POINT($,#676);+#678=CARTESIAN_POINT($,(71.0843874460345,487.103054665064,1.905));+#679=DIRECTION($,(-0.707106781186549,0.707106781186547,0));+#680=VECTOR($,#679,1);+#681=LINE($,#678,#680);+#682=EDGE_CURVE($,#669,#677,#681,.T.);+#683=ORIENTED_EDGE($,$,$,#682,.T.);+#684=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,1.905));+#685=VERTEX_POINT($,#684);+#686=CARTESIAN_POINT($,(65.9207401764197,492.266701934679,1.905));+#687=DIRECTION($,(0,-1,0));+#688=VECTOR($,#687,1);+#689=LINE($,#686,#688);+#690=EDGE_CURVE($,#677,#685,#689,.T.);+#691=ORIENTED_EDGE($,$,$,#690,.T.);+#692=CARTESIAN_POINT($,(54.45,485.35874035284,1.905));+#693=VERTEX_POINT($,#692);+#694=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,1.905));+#695=DIRECTION($,(-1,0,0));+#696=VECTOR($,#695,1);+#697=LINE($,#694,#696);+#698=EDGE_CURVE($,#685,#693,#697,.T.);+#699=ORIENTED_EDGE($,$,$,#698,.T.);+#700=CARTESIAN_POINT($,(10,485.35874035284,1.905));+#701=VERTEX_POINT($,#700);+#702=CARTESIAN_POINT($,(54.45,485.35874035284,1.905));+#703=DIRECTION($,(-1,0,0));+#704=VECTOR($,#703,1);+#705=LINE($,#702,#704);+#706=EDGE_CURVE($,#693,#701,#705,.T.);+#707=ORIENTED_EDGE($,$,$,#706,.T.);+#708=CARTESIAN_POINT($,(10,133.568740352839,1.905));+#709=VERTEX_POINT($,#708);+#710=CARTESIAN_POINT($,(10,485.35874035284,1.905));+#711=DIRECTION($,(0,-1,0));+#712=VECTOR($,#711,1);+#713=LINE($,#710,#712);+#714=EDGE_CURVE($,#701,#709,#713,.T.);+#715=ORIENTED_EDGE($,$,$,#714,.T.);+#716=CARTESIAN_POINT($,(54.45,133.568740352839,1.905));+#717=VERTEX_POINT($,#716);+#718=CARTESIAN_POINT($,(10,133.568740352839,1.905));+#719=DIRECTION($,(1,0,0));+#720=VECTOR($,#719,1);+#721=LINE($,#718,#720);+#722=EDGE_CURVE($,#709,#717,#721,.T.);+#723=ORIENTED_EDGE($,$,$,#722,.T.);+#724=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,1.905));+#725=VERTEX_POINT($,#724);+#726=CARTESIAN_POINT($,(54.45,133.568740352839,1.905));+#727=DIRECTION($,(1,0,0));+#728=VECTOR($,#727,1);+#729=LINE($,#726,#728);+#730=EDGE_CURVE($,#717,#725,#729,.T.);+#731=ORIENTED_EDGE($,$,$,#730,.T.);+#732=CARTESIAN_POINT($,(65.9207401764197,126.660778771,1.905));+#733=VERTEX_POINT($,#732);+#734=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,1.905));+#735=DIRECTION($,(0,-1,0));+#736=VECTOR($,#735,1);+#737=LINE($,#734,#736);+#738=EDGE_CURVE($,#725,#733,#737,.T.);+#739=ORIENTED_EDGE($,$,$,#738,.T.);+#740=CARTESIAN_POINT($,(71.0843874460345,131.824426040615,1.905));+#741=VERTEX_POINT($,#740);+#742=CARTESIAN_POINT($,(65.9207401764197,126.660778771,1.905));+#743=DIRECTION($,(0.707106781186548,0.707106781186548,0));+#744=VECTOR($,#743,1);+#745=LINE($,#742,#744);+#746=EDGE_CURVE($,#733,#741,#745,.T.);+#747=ORIENTED_EDGE($,$,$,#746,.T.);+#748=CARTESIAN_POINT($,(72.4314258641949,130.477387622454,1.905));+#749=VERTEX_POINT($,#748);+#750=CARTESIAN_POINT($,(71.0843874460345,131.824426040615,1.905));+#751=DIRECTION($,(0.707106781186551,-0.707106781186544,0));+#752=VECTOR($,#751,1);+#753=LINE($,#750,#752);+#754=EDGE_CURVE($,#741,#749,#753,.T.);+#755=ORIENTED_EDGE($,$,$,#754,.T.);+#756=CARTESIAN_POINT($,(67.2677785945801,125.313740352839,1.905));+#757=VERTEX_POINT($,#756);+#758=CARTESIAN_POINT($,(72.4314258641949,130.477387622454,1.905));+#759=DIRECTION($,(-0.707106781186548,-0.707106781186548,0));+#760=VECTOR($,#759,1);+#761=LINE($,#758,#760);+#762=EDGE_CURVE($,#749,#757,#761,.T.);+#763=ORIENTED_EDGE($,$,$,#762,.T.);+#764=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,1.905));+#765=VERTEX_POINT($,#764);+#766=CARTESIAN_POINT($,(67.2677785945801,125.313740352839,1.905));+#767=DIRECTION($,(1,0,0));+#768=VECTOR($,#767,1);+#769=LINE($,#766,#768);+#770=EDGE_CURVE($,#757,#765,#769,.T.);+#771=ORIENTED_EDGE($,$,$,#770,.T.);+#772=CARTESIAN_POINT($,(74.1757401764197,113.84300017642,1.905));+#773=VERTEX_POINT($,#772);+#774=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,1.905));+#775=DIRECTION($,(0,-1,0));+#776=VECTOR($,#775,1);+#777=LINE($,#774,#776);+#778=EDGE_CURVE($,#765,#773,#777,.T.);+#779=ORIENTED_EDGE($,$,$,#778,.T.);+#780=CARTESIAN_POINT($,(74.1757401764197,52.2504601764197,1.905));+#781=VERTEX_POINT($,#780);+#782=CARTESIAN_POINT($,(74.1757401764197,113.84300017642,1.905));+#783=DIRECTION($,(0,-1,0));+#784=VECTOR($,#783,1);+#785=LINE($,#782,#784);+#786=EDGE_CURVE($,#773,#781,#785,.T.);+#787=ORIENTED_EDGE($,$,$,#786,.T.);+#788=CARTESIAN_POINT($,(74.1757401764197,40.77972,1.905));+#789=VERTEX_POINT($,#788);+#790=CARTESIAN_POINT($,(74.1757401764197,52.2504601764197,1.905));+#791=DIRECTION($,(0,-1,0));+#792=VECTOR($,#791,1);+#793=LINE($,#790,#792);+#794=EDGE_CURVE($,#781,#789,#793,.T.);+#795=ORIENTED_EDGE($,$,$,#794,.T.);+#796=CARTESIAN_POINT($,(74.1757401764197,10,1.905));+#797=VERTEX_POINT($,#796);+#798=CARTESIAN_POINT($,(74.1757401764197,40.77972,1.905));+#799=DIRECTION($,(0,-1,0));+#800=VECTOR($,#799,1);+#801=LINE($,#798,#800);+#802=EDGE_CURVE($,#789,#797,#801,.T.);+#803=ORIENTED_EDGE($,$,$,#802,.T.);+#804=CARTESIAN_POINT($,(298.96574017642,10,1.905));+#805=VERTEX_POINT($,#804);+#806=CARTESIAN_POINT($,(74.1757401764197,10,1.905));+#807=DIRECTION($,(1,0,0));+#808=VECTOR($,#807,1);+#809=LINE($,#806,#808);+#810=EDGE_CURVE($,#797,#805,#809,.T.);+#811=ORIENTED_EDGE($,$,$,#810,.T.);+#812=CARTESIAN_POINT($,(298.96574017642,40.77972,1.905));+#813=VERTEX_POINT($,#812);+#814=CARTESIAN_POINT($,(298.96574017642,10,1.905));+#815=DIRECTION($,(0,1,0));+#816=VECTOR($,#815,1);+#817=LINE($,#814,#816);+#818=EDGE_CURVE($,#805,#813,#817,.T.);+#819=ORIENTED_EDGE($,$,$,#818,.T.);+#820=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,1.905));+#821=VERTEX_POINT($,#820);+#822=CARTESIAN_POINT($,(298.96574017642,40.77972,1.905));+#823=DIRECTION($,(0,1,0));+#824=VECTOR($,#823,1);+#825=LINE($,#822,#824);+#826=EDGE_CURVE($,#813,#821,#825,.T.);+#827=ORIENTED_EDGE($,$,$,#826,.T.);+#828=CARTESIAN_POINT($,(298.96574017642,113.84300017642,1.905));+#829=VERTEX_POINT($,#828);+#830=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,1.905));+#831=DIRECTION($,(0,1,0));+#832=VECTOR($,#831,1);+#833=LINE($,#830,#832);+#834=EDGE_CURVE($,#821,#829,#833,.T.);+#835=ORIENTED_EDGE($,$,$,#834,.T.);+#836=CARTESIAN_POINT($,(298.96574017642,125.313740352839,1.905));+#837=VERTEX_POINT($,#836);+#838=CARTESIAN_POINT($,(298.96574017642,113.84300017642,1.905));+#839=DIRECTION($,(0,1,0));+#840=VECTOR($,#839,1);+#841=LINE($,#838,#840);+#842=EDGE_CURVE($,#829,#837,#841,.T.);+#843=ORIENTED_EDGE($,$,$,#842,.T.);+#844=CARTESIAN_POINT($,(305.873701758259,125.313740352839,1.905));+#845=VERTEX_POINT($,#844);+#846=CARTESIAN_POINT($,(298.96574017642,125.313740352839,1.905));+#847=DIRECTION($,(1,0,0));+#848=VECTOR($,#847,1);+#849=LINE($,#846,#848);+#850=EDGE_CURVE($,#837,#845,#849,.T.);+#851=ORIENTED_EDGE($,$,$,#850,.T.);+#852=CARTESIAN_POINT($,(300.710054488645,130.477387622454,1.905));+#853=VERTEX_POINT($,#852);+#854=CARTESIAN_POINT($,(305.873701758259,125.313740352839,1.905));+#855=DIRECTION($,(-0.707106781186547,0.707106781186549,0));+#856=VECTOR($,#855,1);+#857=LINE($,#854,#856);+#858=EDGE_CURVE($,#845,#853,#857,.T.);+#859=ORIENTED_EDGE($,$,$,#858,.T.);+#860=CARTESIAN_POINT($,(302.057092906805,131.824426040615,1.905));+#861=VERTEX_POINT($,#860);+#862=CARTESIAN_POINT($,(300.710054488645,130.477387622454,1.905));+#863=DIRECTION($,(0.707106781186548,0.707106781186548,0));+#864=VECTOR($,#863,1);+#865=LINE($,#862,#864);+#866=EDGE_CURVE($,#853,#861,#865,.T.);+#867=ORIENTED_EDGE($,$,$,#866,.T.);+#868=CARTESIAN_POINT($,(307.22074017642,126.660778771,1.905));+#869=VERTEX_POINT($,#868);+#870=CARTESIAN_POINT($,(302.057092906805,131.824426040615,1.905));+#871=DIRECTION($,(0.707106781186547,-0.707106781186549,0));+#872=VECTOR($,#871,1);+#873=LINE($,#870,#872);+#874=EDGE_CURVE($,#861,#869,#873,.T.);+#875=ORIENTED_EDGE($,$,$,#874,.T.);+#876=CARTESIAN_POINT($,(307.22074017642,133.568740352839,1.905));+#877=VERTEX_POINT($,#876);+#878=CARTESIAN_POINT($,(307.22074017642,126.660778771,1.905));+#879=DIRECTION($,(0,1,0));+#880=VECTOR($,#879,1);+#881=LINE($,#878,#880);+#882=EDGE_CURVE($,#869,#877,#881,.T.);+#883=ORIENTED_EDGE($,$,$,#882,.T.);+#884=CARTESIAN_POINT($,(318.691480352839,133.568740352839,1.905));+#885=VERTEX_POINT($,#884);+#886=CARTESIAN_POINT($,(307.22074017642,133.568740352839,1.905));+#887=DIRECTION($,(1,0,0));+#888=VECTOR($,#887,1);+#889=LINE($,#886,#888);+#890=EDGE_CURVE($,#877,#885,#889,.T.);+#891=ORIENTED_EDGE($,$,$,#890,.T.);+#892=CARTESIAN_POINT($,(347.802420352839,133.568740352839,1.905));+#893=VERTEX_POINT($,#892);+#894=CARTESIAN_POINT($,(318.691480352839,133.568740352839,1.905));+#895=DIRECTION($,(1,0,0));+#896=VECTOR($,#895,1);+#897=LINE($,#894,#896);+#898=EDGE_CURVE($,#885,#893,#897,.T.);+#899=ORIENTED_EDGE($,$,$,#898,.T.);+#900=CARTESIAN_POINT($,(353.537790441049,133.568740352839,1.905));+#901=VERTEX_POINT($,#900);+#902=CARTESIAN_POINT($,(347.802420352839,133.568740352839,1.905));+#903=DIRECTION($,(1,0,0));+#904=VECTOR($,#903,1);+#905=LINE($,#902,#904);+#906=EDGE_CURVE($,#893,#901,#905,.T.);+#907=ORIENTED_EDGE($,$,$,#906,.T.);+#908=CARTESIAN_POINT($,(353.537790441049,133.568740352839,1.905));+#909=DIRECTION($,(1,0,0));+#910=VECTOR($,#909,1);+#911=LINE($,#908,#910);+#912=EDGE_CURVE($,#901,#499,#911,.T.);+#913=ORIENTED_EDGE($,$,$,#912,.T.);+#914=EDGE_LOOP($,(#507,#515,#523,#531,#539,#547,#555,#563,#571,#579,#587,#595,#603,#611,#619,#627,#635,#643,#651,#659,#667,#675,#683,#691,#699,#707,#715,#723,#731,#739,#747,#755,#763,#771,#779,#787,#795,#803,#811,#819,#827,#835,#843,#851,#859,#867,#875,#883,#891,#899,#907,#913));+#915=FACE_OUTER_BOUND('',#914,.T.);+#916=CARTESIAN_POINT($,(107.67834017642,189.298880352839,1.905));+#917=VERTEX_POINT($,#916);+#918=CARTESIAN_POINT($,(126.72834017642,189.298880352839,1.905));+#919=VERTEX_POINT($,#918);+#920=CARTESIAN_POINT($,(107.67834017642,189.298880352839,1.905));+#921=DIRECTION($,(1,0,0));+#922=VECTOR($,#921,1);+#923=LINE($,#920,#922);+#924=EDGE_CURVE($,#917,#919,#923,.T.);+#925=ORIENTED_EDGE($,$,$,#924,.F.);+#926=CARTESIAN_POINT($,(107.67834017642,278.198880352839,1.905));+#927=VERTEX_POINT($,#926);+#928=CARTESIAN_POINT($,(107.67834017642,278.198880352839,1.905));+#929=DIRECTION($,(0,-1,0));+#930=VECTOR($,#929,1);+#931=LINE($,#928,#930);+#932=EDGE_CURVE($,#927,#917,#931,.T.);+#933=ORIENTED_EDGE($,$,$,#932,.F.);+#934=CARTESIAN_POINT($,(126.72834017642,278.198880352839,1.905));+#935=VERTEX_POINT($,#934);+#936=CARTESIAN_POINT($,(126.72834017642,278.198880352839,1.905));+#937=DIRECTION($,(-1,0,0));+#938=VECTOR($,#937,1);+#939=LINE($,#936,#938);+#940=EDGE_CURVE($,#935,#927,#939,.T.);+#941=ORIENTED_EDGE($,$,$,#940,.F.);+#942=CARTESIAN_POINT($,(126.72834017642,189.298880352839,1.905));+#943=DIRECTION($,(0,1,0));+#944=VECTOR($,#943,1);+#945=LINE($,#942,#944);+#946=EDGE_CURVE($,#919,#935,#945,.T.);+#947=ORIENTED_EDGE($,$,$,#946,.F.);+#948=EDGE_LOOP($,(#925,#933,#941,#947));+#949=FACE_BOUND('',#948,.T.);+#950=CARTESIAN_POINT($,(171.17834017642,189.298880352839,1.905));+#951=VERTEX_POINT($,#950);+#952=CARTESIAN_POINT($,(190.22834017642,189.298880352839,1.905));+#953=VERTEX_POINT($,#952);+#954=CARTESIAN_POINT($,(171.17834017642,189.298880352839,1.905));+#955=DIRECTION($,(1,0,0));+#956=VECTOR($,#955,1);+#957=LINE($,#954,#956);+#958=EDGE_CURVE($,#951,#953,#957,.T.);+#959=ORIENTED_EDGE($,$,$,#958,.F.);+#960=CARTESIAN_POINT($,(171.17834017642,278.198880352839,1.905));+#961=VERTEX_POINT($,#960);+#962=CARTESIAN_POINT($,(171.17834017642,278.198880352839,1.905));+#963=DIRECTION($,(0,-1,0));+#964=VECTOR($,#963,1);+#965=LINE($,#962,#964);+#966=EDGE_CURVE($,#961,#951,#965,.T.);+#967=ORIENTED_EDGE($,$,$,#966,.F.);+#968=CARTESIAN_POINT($,(190.22834017642,278.198880352839,1.905));+#969=VERTEX_POINT($,#968);+#970=CARTESIAN_POINT($,(190.22834017642,278.198880352839,1.905));+#971=DIRECTION($,(-1,0,0));+#972=VECTOR($,#971,1);+#973=LINE($,#970,#972);+#974=EDGE_CURVE($,#969,#961,#973,.T.);+#975=ORIENTED_EDGE($,$,$,#974,.F.);+#976=CARTESIAN_POINT($,(190.22834017642,189.298880352839,1.905));+#977=DIRECTION($,(0,1,0));+#978=VECTOR($,#977,1);+#979=LINE($,#976,#978);+#980=EDGE_CURVE($,#953,#969,#979,.T.);+#981=ORIENTED_EDGE($,$,$,#980,.F.);+#982=EDGE_LOOP($,(#959,#967,#975,#981));+#983=FACE_BOUND('',#982,.T.);+#984=ADVANCED_FACE('',(#915,#949,#983),#497,.T.);+#985=CARTESIAN_POINT($,(402.051790441049,133.568740352839,0));+#986=DIRECTION($,(1,0,0));+#987=DIRECTION($,(0,0,1));+#988=AXIS2_PLACEMENT_3D($,#985,#986,#987);+#989=PLANE($,#988);+#990=ORIENTED_EDGE($,$,$,#14,.T.);+#991=CARTESIAN_POINT($,(402.051790441049,485.358740352839,-0));+#992=DIRECTION($,(0,0,1));+#993=VECTOR($,#992,1);+#994=LINE($,#991,#993);+#995=EDGE_CURVE($,#9,#501,#994,.T.);+#996=ORIENTED_EDGE($,$,$,#995,.T.);+#997=ORIENTED_EDGE($,$,$,#506,.F.);+#998=CARTESIAN_POINT($,(402.051790441049,133.568740352839,0));+#999=DIRECTION($,(0,0,1));+#1000=VECTOR($,#999,1);+#1001=LINE($,#998,#1000);+#1002=EDGE_CURVE($,#7,#499,#1001,.T.);+#1003=ORIENTED_EDGE($,$,$,#1002,.F.);+#1004=EDGE_LOOP($,(#990,#996,#997,#1003));+#1005=FACE_OUTER_BOUND('',#1004,.T.);+#1006=ADVANCED_FACE('',(#1005),#989,.T.);+#1007=CARTESIAN_POINT($,(402.051790441049,485.358740352839,0));+#1008=DIRECTION($,(0,1,0));+#1009=DIRECTION($,(0,0,1));+#1010=AXIS2_PLACEMENT_3D($,#1007,#1008,#1009);+#1011=PLANE($,#1010);+#1012=ORIENTED_EDGE($,$,$,#22,.T.);+#1013=CARTESIAN_POINT($,(353.537790441049,485.358740352839,0));+#1014=DIRECTION($,(0,0,1));+#1015=VECTOR($,#1014,1);+#1016=LINE($,#1013,#1015);+#1017=EDGE_CURVE($,#17,#509,#1016,.T.);+#1018=ORIENTED_EDGE($,$,$,#1017,.T.);+#1019=ORIENTED_EDGE($,$,$,#514,.F.);+#1020=ORIENTED_EDGE($,$,$,#995,.F.);+#1021=EDGE_LOOP($,(#1012,#1018,#1019,#1020));+#1022=FACE_OUTER_BOUND('',#1021,.T.);+#1023=ADVANCED_FACE('',(#1022),#1011,.T.);+#1024=CARTESIAN_POINT($,(353.537790441049,485.358740352839,0));+#1025=DIRECTION($,(0,1,0));+#1026=DIRECTION($,(0,0,1));+#1027=AXIS2_PLACEMENT_3D($,#1024,#1025,#1026);+#1028=PLANE($,#1027);+#1029=ORIENTED_EDGE($,$,$,#30,.T.);+#1030=CARTESIAN_POINT($,(347.802420352839,485.358740352839,0));+#1031=DIRECTION($,(0,0,1));+#1032=VECTOR($,#1031,1);+#1033=LINE($,#1030,#1032);+#1034=EDGE_CURVE($,#25,#517,#1033,.T.);+#1035=ORIENTED_EDGE($,$,$,#1034,.T.);+#1036=ORIENTED_EDGE($,$,$,#522,.F.);+#1037=ORIENTED_EDGE($,$,$,#1017,.F.);+#1038=EDGE_LOOP($,(#1029,#1035,#1036,#1037));+#1039=FACE_OUTER_BOUND('',#1038,.T.);+#1040=ADVANCED_FACE('',(#1039),#1028,.T.);+#1041=CARTESIAN_POINT($,(347.802420352839,485.358740352839,0));+#1042=DIRECTION($,(0,1,0));+#1043=DIRECTION($,(0,0,1));+#1044=AXIS2_PLACEMENT_3D($,#1041,#1042,#1043);+#1045=PLANE($,#1044);+#1046=ORIENTED_EDGE($,$,$,#38,.T.);+#1047=CARTESIAN_POINT($,(318.691480352839,485.358740352839,0));+#1048=DIRECTION($,(0,0,1));+#1049=VECTOR($,#1048,1);+#1050=LINE($,#1047,#1049);+#1051=EDGE_CURVE($,#33,#525,#1050,.T.);+#1052=ORIENTED_EDGE($,$,$,#1051,.T.);+#1053=ORIENTED_EDGE($,$,$,#530,.F.);+#1054=ORIENTED_EDGE($,$,$,#1034,.F.);+#1055=EDGE_LOOP($,(#1046,#1052,#1053,#1054));+#1056=FACE_OUTER_BOUND('',#1055,.T.);+#1057=ADVANCED_FACE('',(#1056),#1045,.T.);+#1058=CARTESIAN_POINT($,(318.691480352839,485.35874035284,0));+#1059=DIRECTION($,(0,1,0));+#1060=DIRECTION($,(0,0,1));+#1061=AXIS2_PLACEMENT_3D($,#1058,#1059,#1060);+#1062=PLANE($,#1061);+#1063=ORIENTED_EDGE($,$,$,#46,.T.);+#1064=CARTESIAN_POINT($,(307.22074017642,485.35874035284,0));+#1065=DIRECTION($,(0,0,1));+#1066=VECTOR($,#1065,1);+#1067=LINE($,#1064,#1066);+#1068=EDGE_CURVE($,#41,#533,#1067,.T.);+#1069=ORIENTED_EDGE($,$,$,#1068,.T.);+#1070=ORIENTED_EDGE($,$,$,#538,.F.);+#1071=ORIENTED_EDGE($,$,$,#1051,.F.);+#1072=EDGE_LOOP($,(#1063,#1069,#1070,#1071));+#1073=FACE_OUTER_BOUND('',#1072,.T.);+#1074=ADVANCED_FACE('',(#1073),#1062,.T.);+#1075=CARTESIAN_POINT($,(307.22074017642,485.35874035284,0));+#1076=DIRECTION($,(1,0,0));+#1077=DIRECTION($,(0,0,1));+#1078=AXIS2_PLACEMENT_3D($,#1075,#1076,#1077);+#1079=PLANE($,#1078);+#1080=ORIENTED_EDGE($,$,$,#54,.T.);+#1081=CARTESIAN_POINT($,(307.22074017642,492.266701934679,-0));+#1082=DIRECTION($,(0,0,1));+#1083=VECTOR($,#1082,1);+#1084=LINE($,#1081,#1083);+#1085=EDGE_CURVE($,#49,#541,#1084,.T.);+#1086=ORIENTED_EDGE($,$,$,#1085,.T.);+#1087=ORIENTED_EDGE($,$,$,#546,.F.);+#1088=ORIENTED_EDGE($,$,$,#1068,.F.);+#1089=EDGE_LOOP($,(#1080,#1086,#1087,#1088));+#1090=FACE_OUTER_BOUND('',#1089,.T.);+#1091=ADVANCED_FACE('',(#1090),#1079,.T.);+#1092=CARTESIAN_POINT($,(307.22074017642,492.266701934679,0));+#1093=DIRECTION($,(-0.707106781186548,0.707106781186548,0));+#1094=DIRECTION($,(0,0,1));+#1095=AXIS2_PLACEMENT_3D($,#1092,#1093,#1094);+#1096=PLANE($,#1095);+#1097=ORIENTED_EDGE($,$,$,#62,.T.);+#1098=CARTESIAN_POINT($,(302.057092906805,487.103054665064,0));+#1099=DIRECTION($,(0,0,1));+#1100=VECTOR($,#1099,1);+#1101=LINE($,#1098,#1100);+#1102=EDGE_CURVE($,#57,#549,#1101,.T.);+#1103=ORIENTED_EDGE($,$,$,#1102,.T.);+#1104=ORIENTED_EDGE($,$,$,#554,.F.);+#1105=ORIENTED_EDGE($,$,$,#1085,.F.);+#1106=EDGE_LOOP($,(#1097,#1103,#1104,#1105));+#1107=FACE_OUTER_BOUND('',#1106,.T.);+#1108=ADVANCED_FACE('',(#1107),#1096,.T.);+#1109=CARTESIAN_POINT($,(302.057092906805,487.103054665064,0));+#1110=DIRECTION($,(0.707106781186562,0.707106781186533,0));+#1111=DIRECTION($,(0,0,1));+#1112=AXIS2_PLACEMENT_3D($,#1109,#1110,#1111);+#1113=PLANE($,#1112);+#1114=ORIENTED_EDGE($,$,$,#70,.T.);+#1115=CARTESIAN_POINT($,(300.710054488645,488.450093083225,0));+#1116=DIRECTION($,(0,0,1));+#1117=VECTOR($,#1116,1);+#1118=LINE($,#1115,#1117);+#1119=EDGE_CURVE($,#65,#557,#1118,.T.);+#1120=ORIENTED_EDGE($,$,$,#1119,.T.);+#1121=ORIENTED_EDGE($,$,$,#562,.F.);+#1122=ORIENTED_EDGE($,$,$,#1102,.F.);+#1123=EDGE_LOOP($,(#1114,#1120,#1121,#1122));+#1124=FACE_OUTER_BOUND('',#1123,.T.);+#1125=ADVANCED_FACE('',(#1124),#1113,.T.);+#1126=CARTESIAN_POINT($,(300.710054488645,488.450093083225,0));+#1127=DIRECTION($,(0.707106781186548,-0.707106781186548,0));+#1128=DIRECTION($,(0,0,1));+#1129=AXIS2_PLACEMENT_3D($,#1126,#1127,#1128);+#1130=PLANE($,#1129);+#1131=ORIENTED_EDGE($,$,$,#78,.T.);+#1132=CARTESIAN_POINT($,(305.873701758259,493.613740352839,-0));+#1133=DIRECTION($,(0,0,1));+#1134=VECTOR($,#1133,1);+#1135=LINE($,#1132,#1134);+#1136=EDGE_CURVE($,#73,#565,#1135,.T.);+#1137=ORIENTED_EDGE($,$,$,#1136,.T.);+#1138=ORIENTED_EDGE($,$,$,#570,.F.);+#1139=ORIENTED_EDGE($,$,$,#1119,.F.);+#1140=EDGE_LOOP($,(#1131,#1137,#1138,#1139));+#1141=FACE_OUTER_BOUND('',#1140,.T.);+#1142=ADVANCED_FACE('',(#1141),#1130,.T.);+#1143=CARTESIAN_POINT($,(305.873701758259,493.613740352839,0));+#1144=DIRECTION($,(0,1,0));+#1145=DIRECTION($,(0,0,1));+#1146=AXIS2_PLACEMENT_3D($,#1143,#1144,#1145);+#1147=PLANE($,#1146);+#1148=ORIENTED_EDGE($,$,$,#86,.T.);+#1149=CARTESIAN_POINT($,(298.96574017642,493.613740352839,0));+#1150=DIRECTION($,(0,0,1));+#1151=VECTOR($,#1150,1);+#1152=LINE($,#1149,#1151);+#1153=EDGE_CURVE($,#81,#573,#1152,.T.);+#1154=ORIENTED_EDGE($,$,$,#1153,.T.);+#1155=ORIENTED_EDGE($,$,$,#578,.F.);+#1156=ORIENTED_EDGE($,$,$,#1136,.F.);+#1157=EDGE_LOOP($,(#1148,#1154,#1155,#1156));+#1158=FACE_OUTER_BOUND('',#1157,.T.);+#1159=ADVANCED_FACE('',(#1158),#1147,.T.);+#1160=CARTESIAN_POINT($,(298.96574017642,493.613740352839,0));+#1161=DIRECTION($,(1,0,0));+#1162=DIRECTION($,(0,0,1));+#1163=AXIS2_PLACEMENT_3D($,#1160,#1161,#1162);+#1164=PLANE($,#1163);+#1165=ORIENTED_EDGE($,$,$,#94,.T.);+#1166=CARTESIAN_POINT($,(298.96574017642,505.084480529259,0));+#1167=DIRECTION($,(0,0,1));+#1168=VECTOR($,#1167,1);+#1169=LINE($,#1166,#1168);+#1170=EDGE_CURVE($,#89,#581,#1169,.T.);+#1171=ORIENTED_EDGE($,$,$,#1170,.T.);+#1172=ORIENTED_EDGE($,$,$,#586,.F.);+#1173=ORIENTED_EDGE($,$,$,#1153,.F.);+#1174=EDGE_LOOP($,(#1165,#1171,#1172,#1173));+#1175=FACE_OUTER_BOUND('',#1174,.T.);+#1176=ADVANCED_FACE('',(#1175),#1164,.T.);+#1177=CARTESIAN_POINT($,(298.96574017642,505.084480529259,0));+#1178=DIRECTION($,(1,0,0));+#1179=DIRECTION($,(0,0,1));+#1180=AXIS2_PLACEMENT_3D($,#1177,#1178,#1179);+#1181=PLANE($,#1180);+#1182=ORIENTED_EDGE($,$,$,#102,.T.);+#1183=CARTESIAN_POINT($,(298.96574017642,566.677020529259,0));+#1184=DIRECTION($,(0,0,1));+#1185=VECTOR($,#1184,1);+#1186=LINE($,#1183,#1185);+#1187=EDGE_CURVE($,#97,#589,#1186,.T.);+#1188=ORIENTED_EDGE($,$,$,#1187,.T.);+#1189=ORIENTED_EDGE($,$,$,#594,.F.);+#1190=ORIENTED_EDGE($,$,$,#1170,.F.);+#1191=EDGE_LOOP($,(#1182,#1188,#1189,#1190));+#1192=FACE_OUTER_BOUND('',#1191,.T.);+#1193=ADVANCED_FACE('',(#1192),#1181,.T.);+#1194=CARTESIAN_POINT($,(298.96574017642,566.677020529259,0));+#1195=DIRECTION($,(1,0,0));+#1196=DIRECTION($,(0,0,1));+#1197=AXIS2_PLACEMENT_3D($,#1194,#1195,#1196);+#1198=PLANE($,#1197);+#1199=ORIENTED_EDGE($,$,$,#110,.T.);+#1200=CARTESIAN_POINT($,(298.96574017642,578.147760705679,0));+#1201=DIRECTION($,(0,0,1));+#1202=VECTOR($,#1201,1);+#1203=LINE($,#1200,#1202);+#1204=EDGE_CURVE($,#105,#597,#1203,.T.);+#1205=ORIENTED_EDGE($,$,$,#1204,.T.);+#1206=ORIENTED_EDGE($,$,$,#602,.F.);+#1207=ORIENTED_EDGE($,$,$,#1187,.F.);+#1208=EDGE_LOOP($,(#1199,#1205,#1206,#1207));+#1209=FACE_OUTER_BOUND('',#1208,.T.);+#1210=ADVANCED_FACE('',(#1209),#1198,.T.);+#1211=CARTESIAN_POINT($,(298.96574017642,578.147760705679,0));+#1212=DIRECTION($,(1,0,0));+#1213=DIRECTION($,(0,0,1));+#1214=AXIS2_PLACEMENT_3D($,#1211,#1212,#1213);+#1215=PLANE($,#1214);+#1216=ORIENTED_EDGE($,$,$,#118,.T.);+#1217=CARTESIAN_POINT($,(298.96574017642,622.597760705679,-0));+#1218=DIRECTION($,(0,0,1));+#1219=VECTOR($,#1218,1);+#1220=LINE($,#1217,#1219);+#1221=EDGE_CURVE($,#113,#605,#1220,.T.);+#1222=ORIENTED_EDGE($,$,$,#1221,.T.);+#1223=ORIENTED_EDGE($,$,$,#610,.F.);+#1224=ORIENTED_EDGE($,$,$,#1204,.F.);+#1225=EDGE_LOOP($,(#1216,#1222,#1223,#1224));+#1226=FACE_OUTER_BOUND('',#1225,.T.);+#1227=ADVANCED_FACE('',(#1226),#1215,.T.);+#1228=CARTESIAN_POINT($,(298.96574017642,622.597760705679,0));+#1229=DIRECTION($,(0,1,0));+#1230=DIRECTION($,(0,0,1));+#1231=AXIS2_PLACEMENT_3D($,#1228,#1229,#1230);+#1232=PLANE($,#1231);+#1233=ORIENTED_EDGE($,$,$,#126,.T.);+#1234=CARTESIAN_POINT($,(74.1757401764197,622.597760705679,-0));+#1235=DIRECTION($,(0,0,1));+#1236=VECTOR($,#1235,1);+#1237=LINE($,#1234,#1236);+#1238=EDGE_CURVE($,#121,#613,#1237,.T.);+#1239=ORIENTED_EDGE($,$,$,#1238,.T.);+#1240=ORIENTED_EDGE($,$,$,#618,.F.);+#1241=ORIENTED_EDGE($,$,$,#1221,.F.);+#1242=EDGE_LOOP($,(#1233,#1239,#1240,#1241));+#1243=FACE_OUTER_BOUND('',#1242,.T.);+#1244=ADVANCED_FACE('',(#1243),#1232,.T.);+#1245=CARTESIAN_POINT($,(74.1757401764197,622.597760705679,0));+#1246=DIRECTION($,(-1,0,0));+#1247=DIRECTION($,(0,0,1));+#1248=AXIS2_PLACEMENT_3D($,#1245,#1246,#1247);+#1249=PLANE($,#1248);+#1250=ORIENTED_EDGE($,$,$,#134,.T.);+#1251=CARTESIAN_POINT($,(74.1757401764197,578.147760705679,0));+#1252=DIRECTION($,(0,0,1));+#1253=VECTOR($,#1252,1);+#1254=LINE($,#1251,#1253);+#1255=EDGE_CURVE($,#129,#621,#1254,.T.);+#1256=ORIENTED_EDGE($,$,$,#1255,.T.);+#1257=ORIENTED_EDGE($,$,$,#626,.F.);+#1258=ORIENTED_EDGE($,$,$,#1238,.F.);+#1259=EDGE_LOOP($,(#1250,#1256,#1257,#1258));+#1260=FACE_OUTER_BOUND('',#1259,.T.);+#1261=ADVANCED_FACE('',(#1260),#1249,.T.);+#1262=CARTESIAN_POINT($,(74.1757401764197,578.147760705679,0));+#1263=DIRECTION($,(-1,0,0));+#1264=DIRECTION($,(0,0,1));+#1265=AXIS2_PLACEMENT_3D($,#1262,#1263,#1264);+#1266=PLANE($,#1265);+#1267=ORIENTED_EDGE($,$,$,#142,.T.);+#1268=CARTESIAN_POINT($,(74.1757401764197,566.677020529259,0));+#1269=DIRECTION($,(0,0,1));+#1270=VECTOR($,#1269,1);+#1271=LINE($,#1268,#1270);+#1272=EDGE_CURVE($,#137,#629,#1271,.T.);+#1273=ORIENTED_EDGE($,$,$,#1272,.T.);+#1274=ORIENTED_EDGE($,$,$,#634,.F.);+#1275=ORIENTED_EDGE($,$,$,#1255,.F.);+#1276=EDGE_LOOP($,(#1267,#1273,#1274,#1275));+#1277=FACE_OUTER_BOUND('',#1276,.T.);+#1278=ADVANCED_FACE('',(#1277),#1266,.T.);+#1279=CARTESIAN_POINT($,(74.1757401764197,566.677020529259,0));+#1280=DIRECTION($,(-1,0,0));+#1281=DIRECTION($,(0,0,1));+#1282=AXIS2_PLACEMENT_3D($,#1279,#1280,#1281);+#1283=PLANE($,#1282);+#1284=ORIENTED_EDGE($,$,$,#150,.T.);+#1285=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,0));+#1286=DIRECTION($,(0,0,1));+#1287=VECTOR($,#1286,1);+#1288=LINE($,#1285,#1287);+#1289=EDGE_CURVE($,#145,#637,#1288,.T.);+#1290=ORIENTED_EDGE($,$,$,#1289,.T.);+#1291=ORIENTED_EDGE($,$,$,#642,.F.);+#1292=ORIENTED_EDGE($,$,$,#1272,.F.);+#1293=EDGE_LOOP($,(#1284,#1290,#1291,#1292));+#1294=FACE_OUTER_BOUND('',#1293,.T.);+#1295=ADVANCED_FACE('',(#1294),#1283,.T.);+#1296=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,0));+#1297=DIRECTION($,(-1,0,0));+#1298=DIRECTION($,(0,0,1));+#1299=AXIS2_PLACEMENT_3D($,#1296,#1297,#1298);+#1300=PLANE($,#1299);+#1301=ORIENTED_EDGE($,$,$,#158,.T.);+#1302=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,0));+#1303=DIRECTION($,(0,0,1));+#1304=VECTOR($,#1303,1);+#1305=LINE($,#1302,#1304);+#1306=EDGE_CURVE($,#153,#645,#1305,.T.);+#1307=ORIENTED_EDGE($,$,$,#1306,.T.);+#1308=ORIENTED_EDGE($,$,$,#650,.F.);+#1309=ORIENTED_EDGE($,$,$,#1289,.F.);+#1310=EDGE_LOOP($,(#1301,#1307,#1308,#1309));+#1311=FACE_OUTER_BOUND('',#1310,.T.);+#1312=ADVANCED_FACE('',(#1311),#1300,.T.);+#1313=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,0));+#1314=DIRECTION($,(0,1,0));+#1315=DIRECTION($,(0,0,1));+#1316=AXIS2_PLACEMENT_3D($,#1313,#1314,#1315);+#1317=PLANE($,#1316);+#1318=ORIENTED_EDGE($,$,$,#166,.T.);+#1319=CARTESIAN_POINT($,(67.2677785945801,493.61374035284,-0));+#1320=DIRECTION($,(0,0,1));+#1321=VECTOR($,#1320,1);+#1322=LINE($,#1319,#1321);+#1323=EDGE_CURVE($,#161,#653,#1322,.T.);+#1324=ORIENTED_EDGE($,$,$,#1323,.T.);+#1325=ORIENTED_EDGE($,$,$,#658,.F.);+#1326=ORIENTED_EDGE($,$,$,#1306,.F.);+#1327=EDGE_LOOP($,(#1318,#1324,#1325,#1326));+#1328=FACE_OUTER_BOUND('',#1327,.T.);+#1329=ADVANCED_FACE('',(#1328),#1317,.T.);+#1330=CARTESIAN_POINT($,(67.2677785945801,493.613740352839,0));+#1331=DIRECTION($,(-0.707106781186547,-0.707106781186549,0));+#1332=DIRECTION($,(0,0,1));+#1333=AXIS2_PLACEMENT_3D($,#1330,#1331,#1332);+#1334=PLANE($,#1333);+#1335=ORIENTED_EDGE($,$,$,#174,.T.);+#1336=CARTESIAN_POINT($,(72.4314258641949,488.450093083225,0));+#1337=DIRECTION($,(0,0,1));+#1338=VECTOR($,#1337,1);+#1339=LINE($,#1336,#1338);+#1340=EDGE_CURVE($,#169,#661,#1339,.T.);+#1341=ORIENTED_EDGE($,$,$,#1340,.T.);+#1342=ORIENTED_EDGE($,$,$,#666,.F.);+#1343=ORIENTED_EDGE($,$,$,#1323,.F.);+#1344=EDGE_LOOP($,(#1335,#1341,#1342,#1343));+#1345=FACE_OUTER_BOUND('',#1344,.T.);+#1346=ADVANCED_FACE('',(#1345),#1334,.T.);+#1347=CARTESIAN_POINT($,(72.4314258641949,488.450093083225,0));+#1348=DIRECTION($,(-0.707106781186559,0.707106781186536,0));+#1349=DIRECTION($,(0,0,1));+#1350=AXIS2_PLACEMENT_3D($,#1347,#1348,#1349);+#1351=PLANE($,#1350);+#1352=ORIENTED_EDGE($,$,$,#182,.T.);+#1353=CARTESIAN_POINT($,(71.0843874460345,487.103054665064,0));+#1354=DIRECTION($,(0,0,1));+#1355=VECTOR($,#1354,1);+#1356=LINE($,#1353,#1355);+#1357=EDGE_CURVE($,#177,#669,#1356,.T.);+#1358=ORIENTED_EDGE($,$,$,#1357,.T.);+#1359=ORIENTED_EDGE($,$,$,#674,.F.);+#1360=ORIENTED_EDGE($,$,$,#1340,.F.);+#1361=EDGE_LOOP($,(#1352,#1358,#1359,#1360));+#1362=FACE_OUTER_BOUND('',#1361,.T.);+#1363=ADVANCED_FACE('',(#1362),#1351,.T.);+#1364=CARTESIAN_POINT($,(71.0843874460345,487.103054665064,0));+#1365=DIRECTION($,(0.707106781186547,0.707106781186549,0));+#1366=DIRECTION($,(0,0,1));+#1367=AXIS2_PLACEMENT_3D($,#1364,#1365,#1366);+#1368=PLANE($,#1367);+#1369=ORIENTED_EDGE($,$,$,#190,.T.);+#1370=CARTESIAN_POINT($,(65.9207401764197,492.266701934679,-0));+#1371=DIRECTION($,(0,0,1));+#1372=VECTOR($,#1371,1);+#1373=LINE($,#1370,#1372);+#1374=EDGE_CURVE($,#185,#677,#1373,.T.);+#1375=ORIENTED_EDGE($,$,$,#1374,.T.);+#1376=ORIENTED_EDGE($,$,$,#682,.F.);+#1377=ORIENTED_EDGE($,$,$,#1357,.F.);+#1378=EDGE_LOOP($,(#1369,#1375,#1376,#1377));+#1379=FACE_OUTER_BOUND('',#1378,.T.);+#1380=ADVANCED_FACE('',(#1379),#1368,.T.);+#1381=CARTESIAN_POINT($,(65.9207401764197,492.266701934679,0));+#1382=DIRECTION($,(-1,0,0));+#1383=DIRECTION($,(0,0,1));+#1384=AXIS2_PLACEMENT_3D($,#1381,#1382,#1383);+#1385=PLANE($,#1384);+#1386=ORIENTED_EDGE($,$,$,#198,.T.);+#1387=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,0));+#1388=DIRECTION($,(0,0,1));+#1389=VECTOR($,#1388,1);+#1390=LINE($,#1387,#1389);+#1391=EDGE_CURVE($,#193,#685,#1390,.T.);+#1392=ORIENTED_EDGE($,$,$,#1391,.T.);+#1393=ORIENTED_EDGE($,$,$,#690,.F.);+#1394=ORIENTED_EDGE($,$,$,#1374,.F.);+#1395=EDGE_LOOP($,(#1386,#1392,#1393,#1394));+#1396=FACE_OUTER_BOUND('',#1395,.T.);+#1397=ADVANCED_FACE('',(#1396),#1385,.T.);+#1398=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,0));+#1399=DIRECTION($,(0,1,0));+#1400=DIRECTION($,(0,0,1));+#1401=AXIS2_PLACEMENT_3D($,#1398,#1399,#1400);+#1402=PLANE($,#1401);+#1403=ORIENTED_EDGE($,$,$,#206,.T.);+#1404=CARTESIAN_POINT($,(54.45,485.35874035284,0));+#1405=DIRECTION($,(0,0,1));+#1406=VECTOR($,#1405,1);+#1407=LINE($,#1404,#1406);+#1408=EDGE_CURVE($,#201,#693,#1407,.T.);+#1409=ORIENTED_EDGE($,$,$,#1408,.T.);+#1410=ORIENTED_EDGE($,$,$,#698,.F.);+#1411=ORIENTED_EDGE($,$,$,#1391,.F.);+#1412=EDGE_LOOP($,(#1403,#1409,#1410,#1411));+#1413=FACE_OUTER_BOUND('',#1412,.T.);+#1414=ADVANCED_FACE('',(#1413),#1402,.T.);+#1415=CARTESIAN_POINT($,(54.45,485.35874035284,0));+#1416=DIRECTION($,(0,1,0));+#1417=DIRECTION($,(0,0,1));+#1418=AXIS2_PLACEMENT_3D($,#1415,#1416,#1417);+#1419=PLANE($,#1418);+#1420=ORIENTED_EDGE($,$,$,#214,.T.);+#1421=CARTESIAN_POINT($,(10,485.35874035284,-0));+#1422=DIRECTION($,(0,0,1));+#1423=VECTOR($,#1422,1);+#1424=LINE($,#1421,#1423);+#1425=EDGE_CURVE($,#209,#701,#1424,.T.);+#1426=ORIENTED_EDGE($,$,$,#1425,.T.);+#1427=ORIENTED_EDGE($,$,$,#706,.F.);+#1428=ORIENTED_EDGE($,$,$,#1408,.F.);+#1429=EDGE_LOOP($,(#1420,#1426,#1427,#1428));+#1430=FACE_OUTER_BOUND('',#1429,.T.);+#1431=ADVANCED_FACE('',(#1430),#1419,.T.);+#1432=CARTESIAN_POINT($,(10,485.35874035284,0));+#1433=DIRECTION($,(-1,0,0));+#1434=DIRECTION($,(0,0,1));+#1435=AXIS2_PLACEMENT_3D($,#1432,#1433,#1434);+#1436=PLANE($,#1435);+#1437=ORIENTED_EDGE($,$,$,#222,.T.);+#1438=CARTESIAN_POINT($,(10,133.568740352839,-0));+#1439=DIRECTION($,(0,0,1));+#1440=VECTOR($,#1439,1);+#1441=LINE($,#1438,#1440);+#1442=EDGE_CURVE($,#217,#709,#1441,.T.);+#1443=ORIENTED_EDGE($,$,$,#1442,.T.);+#1444=ORIENTED_EDGE($,$,$,#714,.F.);+#1445=ORIENTED_EDGE($,$,$,#1425,.F.);+#1446=EDGE_LOOP($,(#1437,#1443,#1444,#1445));+#1447=FACE_OUTER_BOUND('',#1446,.T.);+#1448=ADVANCED_FACE('',(#1447),#1436,.T.);+#1449=CARTESIAN_POINT($,(10,133.568740352839,0));+#1450=DIRECTION($,(0,-1,0));+#1451=DIRECTION($,(0,0,1));+#1452=AXIS2_PLACEMENT_3D($,#1449,#1450,#1451);+#1453=PLANE($,#1452);+#1454=ORIENTED_EDGE($,$,$,#230,.T.);+#1455=CARTESIAN_POINT($,(54.45,133.568740352839,0));+#1456=DIRECTION($,(0,0,1));+#1457=VECTOR($,#1456,1);+#1458=LINE($,#1455,#1457);+#1459=EDGE_CURVE($,#225,#717,#1458,.T.);+#1460=ORIENTED_EDGE($,$,$,#1459,.T.);+#1461=ORIENTED_EDGE($,$,$,#722,.F.);+#1462=ORIENTED_EDGE($,$,$,#1442,.F.);+#1463=EDGE_LOOP($,(#1454,#1460,#1461,#1462));+#1464=FACE_OUTER_BOUND('',#1463,.T.);+#1465=ADVANCED_FACE('',(#1464),#1453,.T.);+#1466=CARTESIAN_POINT($,(54.45,133.568740352839,0));+#1467=DIRECTION($,(0,-1,0));+#1468=DIRECTION($,(0,0,1));+#1469=AXIS2_PLACEMENT_3D($,#1466,#1467,#1468);+#1470=PLANE($,#1469);+#1471=ORIENTED_EDGE($,$,$,#238,.T.);+#1472=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,0));+#1473=DIRECTION($,(0,0,1));+#1474=VECTOR($,#1473,1);+#1475=LINE($,#1472,#1474);+#1476=EDGE_CURVE($,#233,#725,#1475,.T.);+#1477=ORIENTED_EDGE($,$,$,#1476,.T.);+#1478=ORIENTED_EDGE($,$,$,#730,.F.);+#1479=ORIENTED_EDGE($,$,$,#1459,.F.);+#1480=EDGE_LOOP($,(#1471,#1477,#1478,#1479));+#1481=FACE_OUTER_BOUND('',#1480,.T.);+#1482=ADVANCED_FACE('',(#1481),#1470,.T.);+#1483=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,0));+#1484=DIRECTION($,(-1,0,0));+#1485=DIRECTION($,(0,0,1));+#1486=AXIS2_PLACEMENT_3D($,#1483,#1484,#1485);+#1487=PLANE($,#1486);+#1488=ORIENTED_EDGE($,$,$,#246,.T.);+#1489=CARTESIAN_POINT($,(65.9207401764197,126.660778771,-0));+#1490=DIRECTION($,(0,0,1));+#1491=VECTOR($,#1490,1);+#1492=LINE($,#1489,#1491);+#1493=EDGE_CURVE($,#241,#733,#1492,.T.);+#1494=ORIENTED_EDGE($,$,$,#1493,.T.);+#1495=ORIENTED_EDGE($,$,$,#738,.F.);+#1496=ORIENTED_EDGE($,$,$,#1476,.F.);+#1497=EDGE_LOOP($,(#1488,#1494,#1495,#1496));+#1498=FACE_OUTER_BOUND('',#1497,.T.);+#1499=ADVANCED_FACE('',(#1498),#1487,.T.);+#1500=CARTESIAN_POINT($,(65.9207401764197,126.660778771,0));+#1501=DIRECTION($,(0.707106781186547,-0.707106781186547,0));+#1502=DIRECTION($,(0,0,1));+#1503=AXIS2_PLACEMENT_3D($,#1500,#1501,#1502);+#1504=PLANE($,#1503);+#1505=ORIENTED_EDGE($,$,$,#254,.T.);+#1506=CARTESIAN_POINT($,(71.0843874460345,131.824426040615,0));+#1507=DIRECTION($,(0,0,1));+#1508=VECTOR($,#1507,1);+#1509=LINE($,#1506,#1508);+#1510=EDGE_CURVE($,#249,#741,#1509,.T.);+#1511=ORIENTED_EDGE($,$,$,#1510,.T.);+#1512=ORIENTED_EDGE($,$,$,#746,.F.);+#1513=ORIENTED_EDGE($,$,$,#1493,.F.);+#1514=EDGE_LOOP($,(#1505,#1511,#1512,#1513));+#1515=FACE_OUTER_BOUND('',#1514,.T.);+#1516=ADVANCED_FACE('',(#1515),#1504,.T.);+#1517=CARTESIAN_POINT($,(71.0843874460345,131.824426040615,0));+#1518=DIRECTION($,(-0.707106781186544,-0.707106781186551,0));+#1519=DIRECTION($,(0,0,1));+#1520=AXIS2_PLACEMENT_3D($,#1517,#1518,#1519);+#1521=PLANE($,#1520);+#1522=ORIENTED_EDGE($,$,$,#262,.T.);+#1523=CARTESIAN_POINT($,(72.4314258641949,130.477387622454,0));+#1524=DIRECTION($,(0,0,1));+#1525=VECTOR($,#1524,1);+#1526=LINE($,#1523,#1525);+#1527=EDGE_CURVE($,#257,#749,#1526,.T.);+#1528=ORIENTED_EDGE($,$,$,#1527,.T.);+#1529=ORIENTED_EDGE($,$,$,#754,.F.);+#1530=ORIENTED_EDGE($,$,$,#1510,.F.);+#1531=EDGE_LOOP($,(#1522,#1528,#1529,#1530));+#1532=FACE_OUTER_BOUND('',#1531,.T.);+#1533=ADVANCED_FACE('',(#1532),#1521,.T.);+#1534=CARTESIAN_POINT($,(72.4314258641949,130.477387622454,0));+#1535=DIRECTION($,(-0.707106781186547,0.707106781186547,0));+#1536=DIRECTION($,(0,0,1));+#1537=AXIS2_PLACEMENT_3D($,#1534,#1535,#1536);+#1538=PLANE($,#1537);+#1539=ORIENTED_EDGE($,$,$,#270,.T.);+#1540=CARTESIAN_POINT($,(67.2677785945801,125.313740352839,-0));+#1541=DIRECTION($,(0,0,1));+#1542=VECTOR($,#1541,1);+#1543=LINE($,#1540,#1542);+#1544=EDGE_CURVE($,#265,#757,#1543,.T.);+#1545=ORIENTED_EDGE($,$,$,#1544,.T.);+#1546=ORIENTED_EDGE($,$,$,#762,.F.);+#1547=ORIENTED_EDGE($,$,$,#1527,.F.);+#1548=EDGE_LOOP($,(#1539,#1545,#1546,#1547));+#1549=FACE_OUTER_BOUND('',#1548,.T.);+#1550=ADVANCED_FACE('',(#1549),#1538,.T.);+#1551=CARTESIAN_POINT($,(67.2677785945801,125.313740352839,0));+#1552=DIRECTION($,(0,-1,0));+#1553=DIRECTION($,(0,0,1));+#1554=AXIS2_PLACEMENT_3D($,#1551,#1552,#1553);+#1555=PLANE($,#1554);+#1556=ORIENTED_EDGE($,$,$,#278,.T.);+#1557=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,0));+#1558=DIRECTION($,(0,0,1));+#1559=VECTOR($,#1558,1);+#1560=LINE($,#1557,#1559);+#1561=EDGE_CURVE($,#273,#765,#1560,.T.);+#1562=ORIENTED_EDGE($,$,$,#1561,.T.);+#1563=ORIENTED_EDGE($,$,$,#770,.F.);+#1564=ORIENTED_EDGE($,$,$,#1544,.F.);+#1565=EDGE_LOOP($,(#1556,#1562,#1563,#1564));+#1566=FACE_OUTER_BOUND('',#1565,.T.);+#1567=ADVANCED_FACE('',(#1566),#1555,.T.);+#1568=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,0));+#1569=DIRECTION($,(-1,0,0));+#1570=DIRECTION($,(0,0,1));+#1571=AXIS2_PLACEMENT_3D($,#1568,#1569,#1570);+#1572=PLANE($,#1571);+#1573=ORIENTED_EDGE($,$,$,#286,.T.);+#1574=CARTESIAN_POINT($,(74.1757401764197,113.84300017642,0));+#1575=DIRECTION($,(0,0,1));+#1576=VECTOR($,#1575,1);+#1577=LINE($,#1574,#1576);+#1578=EDGE_CURVE($,#281,#773,#1577,.T.);+#1579=ORIENTED_EDGE($,$,$,#1578,.T.);+#1580=ORIENTED_EDGE($,$,$,#778,.F.);+#1581=ORIENTED_EDGE($,$,$,#1561,.F.);+#1582=EDGE_LOOP($,(#1573,#1579,#1580,#1581));+#1583=FACE_OUTER_BOUND('',#1582,.T.);+#1584=ADVANCED_FACE('',(#1583),#1572,.T.);+#1585=CARTESIAN_POINT($,(74.1757401764197,113.84300017642,0));+#1586=DIRECTION($,(-1,0,0));+#1587=DIRECTION($,(0,0,1));+#1588=AXIS2_PLACEMENT_3D($,#1585,#1586,#1587);+#1589=PLANE($,#1588);+#1590=ORIENTED_EDGE($,$,$,#294,.T.);+#1591=CARTESIAN_POINT($,(74.1757401764197,52.2504601764197,0));+#1592=DIRECTION($,(0,0,1));+#1593=VECTOR($,#1592,1);+#1594=LINE($,#1591,#1593);+#1595=EDGE_CURVE($,#289,#781,#1594,.T.);+#1596=ORIENTED_EDGE($,$,$,#1595,.T.);+#1597=ORIENTED_EDGE($,$,$,#786,.F.);+#1598=ORIENTED_EDGE($,$,$,#1578,.F.);+#1599=EDGE_LOOP($,(#1590,#1596,#1597,#1598));+#1600=FACE_OUTER_BOUND('',#1599,.T.);+#1601=ADVANCED_FACE('',(#1600),#1589,.T.);+#1602=CARTESIAN_POINT($,(74.1757401764197,52.2504601764197,0));+#1603=DIRECTION($,(-1,0,0));+#1604=DIRECTION($,(0,0,1));+#1605=AXIS2_PLACEMENT_3D($,#1602,#1603,#1604);+#1606=PLANE($,#1605);+#1607=ORIENTED_EDGE($,$,$,#302,.T.);+#1608=CARTESIAN_POINT($,(74.1757401764197,40.77972,0));+#1609=DIRECTION($,(0,0,1));+#1610=VECTOR($,#1609,1);+#1611=LINE($,#1608,#1610);+#1612=EDGE_CURVE($,#297,#789,#1611,.T.);+#1613=ORIENTED_EDGE($,$,$,#1612,.T.);+#1614=ORIENTED_EDGE($,$,$,#794,.F.);+#1615=ORIENTED_EDGE($,$,$,#1595,.F.);+#1616=EDGE_LOOP($,(#1607,#1613,#1614,#1615));+#1617=FACE_OUTER_BOUND('',#1616,.T.);+#1618=ADVANCED_FACE('',(#1617),#1606,.T.);+#1619=CARTESIAN_POINT($,(74.1757401764197,40.77972,0));+#1620=DIRECTION($,(-1,0,0));+#1621=DIRECTION($,(0,0,1));+#1622=AXIS2_PLACEMENT_3D($,#1619,#1620,#1621);+#1623=PLANE($,#1622);+#1624=ORIENTED_EDGE($,$,$,#310,.T.);+#1625=CARTESIAN_POINT($,(74.1757401764197,10,-0));+#1626=DIRECTION($,(0,0,1));+#1627=VECTOR($,#1626,1);+#1628=LINE($,#1625,#1627);+#1629=EDGE_CURVE($,#305,#797,#1628,.T.);+#1630=ORIENTED_EDGE($,$,$,#1629,.T.);+#1631=ORIENTED_EDGE($,$,$,#802,.F.);+#1632=ORIENTED_EDGE($,$,$,#1612,.F.);+#1633=EDGE_LOOP($,(#1624,#1630,#1631,#1632));+#1634=FACE_OUTER_BOUND('',#1633,.T.);+#1635=ADVANCED_FACE('',(#1634),#1623,.T.);+#1636=CARTESIAN_POINT($,(74.1757401764197,10,0));+#1637=DIRECTION($,(0,-1,0));+#1638=DIRECTION($,(0,0,1));+#1639=AXIS2_PLACEMENT_3D($,#1636,#1637,#1638);+#1640=PLANE($,#1639);+#1641=ORIENTED_EDGE($,$,$,#318,.T.);+#1642=CARTESIAN_POINT($,(298.96574017642,10,-0));+#1643=DIRECTION($,(0,0,1));+#1644=VECTOR($,#1643,1);+#1645=LINE($,#1642,#1644);+#1646=EDGE_CURVE($,#313,#805,#1645,.T.);+#1647=ORIENTED_EDGE($,$,$,#1646,.T.);+#1648=ORIENTED_EDGE($,$,$,#810,.F.);+#1649=ORIENTED_EDGE($,$,$,#1629,.F.);+#1650=EDGE_LOOP($,(#1641,#1647,#1648,#1649));+#1651=FACE_OUTER_BOUND('',#1650,.T.);+#1652=ADVANCED_FACE('',(#1651),#1640,.T.);+#1653=CARTESIAN_POINT($,(298.96574017642,10,0));+#1654=DIRECTION($,(1,0,0));+#1655=DIRECTION($,(0,0,1));+#1656=AXIS2_PLACEMENT_3D($,#1653,#1654,#1655);+#1657=PLANE($,#1656);+#1658=ORIENTED_EDGE($,$,$,#326,.T.);+#1659=CARTESIAN_POINT($,(298.96574017642,40.77972,0));+#1660=DIRECTION($,(0,0,1));+#1661=VECTOR($,#1660,1);+#1662=LINE($,#1659,#1661);+#1663=EDGE_CURVE($,#321,#813,#1662,.T.);+#1664=ORIENTED_EDGE($,$,$,#1663,.T.);+#1665=ORIENTED_EDGE($,$,$,#818,.F.);+#1666=ORIENTED_EDGE($,$,$,#1646,.F.);+#1667=EDGE_LOOP($,(#1658,#1664,#1665,#1666));+#1668=FACE_OUTER_BOUND('',#1667,.T.);+#1669=ADVANCED_FACE('',(#1668),#1657,.T.);+#1670=CARTESIAN_POINT($,(298.96574017642,40.77972,0));+#1671=DIRECTION($,(1,0,0));+#1672=DIRECTION($,(0,0,1));+#1673=AXIS2_PLACEMENT_3D($,#1670,#1671,#1672);+#1674=PLANE($,#1673);+#1675=ORIENTED_EDGE($,$,$,#334,.T.);+#1676=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,0));+#1677=DIRECTION($,(0,0,1));+#1678=VECTOR($,#1677,1);+#1679=LINE($,#1676,#1678);+#1680=EDGE_CURVE($,#329,#821,#1679,.T.);+#1681=ORIENTED_EDGE($,$,$,#1680,.T.);+#1682=ORIENTED_EDGE($,$,$,#826,.F.);+#1683=ORIENTED_EDGE($,$,$,#1663,.F.);+#1684=EDGE_LOOP($,(#1675,#1681,#1682,#1683));+#1685=FACE_OUTER_BOUND('',#1684,.T.);+#1686=ADVANCED_FACE('',(#1685),#1674,.T.);+#1687=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,0));+#1688=DIRECTION($,(1,0,0));+#1689=DIRECTION($,(0,0,1));+#1690=AXIS2_PLACEMENT_3D($,#1687,#1688,#1689);+#1691=PLANE($,#1690);+#1692=ORIENTED_EDGE($,$,$,#342,.T.);+#1693=CARTESIAN_POINT($,(298.96574017642,113.84300017642,0));+#1694=DIRECTION($,(0,0,1));+#1695=VECTOR($,#1694,1);+#1696=LINE($,#1693,#1695);+#1697=EDGE_CURVE($,#337,#829,#1696,.T.);+#1698=ORIENTED_EDGE($,$,$,#1697,.T.);+#1699=ORIENTED_EDGE($,$,$,#834,.F.);+#1700=ORIENTED_EDGE($,$,$,#1680,.F.);+#1701=EDGE_LOOP($,(#1692,#1698,#1699,#1700));+#1702=FACE_OUTER_BOUND('',#1701,.T.);+#1703=ADVANCED_FACE('',(#1702),#1691,.T.);+#1704=CARTESIAN_POINT($,(298.96574017642,113.84300017642,0));+#1705=DIRECTION($,(1,0,0));+#1706=DIRECTION($,(0,0,1));+#1707=AXIS2_PLACEMENT_3D($,#1704,#1705,#1706);+#1708=PLANE($,#1707);+#1709=ORIENTED_EDGE($,$,$,#350,.T.);+#1710=CARTESIAN_POINT($,(298.96574017642,125.313740352839,0));+#1711=DIRECTION($,(0,0,1));+#1712=VECTOR($,#1711,1);+#1713=LINE($,#1710,#1712);+#1714=EDGE_CURVE($,#345,#837,#1713,.T.);+#1715=ORIENTED_EDGE($,$,$,#1714,.T.);+#1716=ORIENTED_EDGE($,$,$,#842,.F.);+#1717=ORIENTED_EDGE($,$,$,#1697,.F.);+#1718=EDGE_LOOP($,(#1709,#1715,#1716,#1717));+#1719=FACE_OUTER_BOUND('',#1718,.T.);+#1720=ADVANCED_FACE('',(#1719),#1708,.T.);+#1721=CARTESIAN_POINT($,(298.96574017642,125.313740352839,0));+#1722=DIRECTION($,(0,-1,0));+#1723=DIRECTION($,(0,0,1));+#1724=AXIS2_PLACEMENT_3D($,#1721,#1722,#1723);+#1725=PLANE($,#1724);+#1726=ORIENTED_EDGE($,$,$,#358,.T.);+#1727=CARTESIAN_POINT($,(305.873701758259,125.313740352839,-0));+#1728=DIRECTION($,(0,0,1));+#1729=VECTOR($,#1728,1);+#1730=LINE($,#1727,#1729);+#1731=EDGE_CURVE($,#353,#845,#1730,.T.);+#1732=ORIENTED_EDGE($,$,$,#1731,.T.);+#1733=ORIENTED_EDGE($,$,$,#850,.F.);+#1734=ORIENTED_EDGE($,$,$,#1714,.F.);+#1735=EDGE_LOOP($,(#1726,#1732,#1733,#1734));+#1736=FACE_OUTER_BOUND('',#1735,.T.);+#1737=ADVANCED_FACE('',(#1736),#1725,.T.);+#1738=CARTESIAN_POINT($,(305.873701758259,125.313740352839,0));+#1739=DIRECTION($,(0.707106781186549,0.707106781186547,0));+#1740=DIRECTION($,(0,0,1));+#1741=AXIS2_PLACEMENT_3D($,#1738,#1739,#1740);+#1742=PLANE($,#1741);+#1743=ORIENTED_EDGE($,$,$,#366,.T.);+#1744=CARTESIAN_POINT($,(300.710054488645,130.477387622454,0));+#1745=DIRECTION($,(0,0,1));+#1746=VECTOR($,#1745,1);+#1747=LINE($,#1744,#1746);+#1748=EDGE_CURVE($,#361,#853,#1747,.T.);+#1749=ORIENTED_EDGE($,$,$,#1748,.T.);+#1750=ORIENTED_EDGE($,$,$,#858,.F.);+#1751=ORIENTED_EDGE($,$,$,#1731,.F.);+#1752=EDGE_LOOP($,(#1743,#1749,#1750,#1751));+#1753=FACE_OUTER_BOUND('',#1752,.T.);+#1754=ADVANCED_FACE('',(#1753),#1742,.T.);+#1755=CARTESIAN_POINT($,(300.710054488645,130.477387622454,0));+#1756=DIRECTION($,(0.707106781186548,-0.707106781186548,0));+#1757=DIRECTION($,(0,0,1));+#1758=AXIS2_PLACEMENT_3D($,#1755,#1756,#1757);+#1759=PLANE($,#1758);+#1760=ORIENTED_EDGE($,$,$,#374,.T.);+#1761=CARTESIAN_POINT($,(302.057092906805,131.824426040615,0));+#1762=DIRECTION($,(0,0,1));+#1763=VECTOR($,#1762,1);+#1764=LINE($,#1761,#1763);+#1765=EDGE_CURVE($,#369,#861,#1764,.T.);+#1766=ORIENTED_EDGE($,$,$,#1765,.T.);+#1767=ORIENTED_EDGE($,$,$,#866,.F.);+#1768=ORIENTED_EDGE($,$,$,#1748,.F.);+#1769=EDGE_LOOP($,(#1760,#1766,#1767,#1768));+#1770=FACE_OUTER_BOUND('',#1769,.T.);+#1771=ADVANCED_FACE('',(#1770),#1759,.T.);+#1772=CARTESIAN_POINT($,(302.057092906805,131.824426040615,0));+#1773=DIRECTION($,(-0.707106781186549,-0.707106781186547,0));+#1774=DIRECTION($,(0,0,1));+#1775=AXIS2_PLACEMENT_3D($,#1772,#1773,#1774);+#1776=PLANE($,#1775);+#1777=ORIENTED_EDGE($,$,$,#382,.T.);+#1778=CARTESIAN_POINT($,(307.22074017642,126.660778771,-0));+#1779=DIRECTION($,(0,0,1));+#1780=VECTOR($,#1779,1);+#1781=LINE($,#1778,#1780);+#1782=EDGE_CURVE($,#377,#869,#1781,.T.);+#1783=ORIENTED_EDGE($,$,$,#1782,.T.);+#1784=ORIENTED_EDGE($,$,$,#874,.F.);+#1785=ORIENTED_EDGE($,$,$,#1765,.F.);+#1786=EDGE_LOOP($,(#1777,#1783,#1784,#1785));+#1787=FACE_OUTER_BOUND('',#1786,.T.);+#1788=ADVANCED_FACE('',(#1787),#1776,.T.);+#1789=CARTESIAN_POINT($,(307.22074017642,126.660778771,0));+#1790=DIRECTION($,(1,0,0));+#1791=DIRECTION($,(0,0,1));+#1792=AXIS2_PLACEMENT_3D($,#1789,#1790,#1791);+#1793=PLANE($,#1792);+#1794=ORIENTED_EDGE($,$,$,#390,.T.);+#1795=CARTESIAN_POINT($,(307.22074017642,133.568740352839,0));+#1796=DIRECTION($,(0,0,1));+#1797=VECTOR($,#1796,1);+#1798=LINE($,#1795,#1797);+#1799=EDGE_CURVE($,#385,#877,#1798,.T.);+#1800=ORIENTED_EDGE($,$,$,#1799,.T.);+#1801=ORIENTED_EDGE($,$,$,#882,.F.);+#1802=ORIENTED_EDGE($,$,$,#1782,.F.);+#1803=EDGE_LOOP($,(#1794,#1800,#1801,#1802));+#1804=FACE_OUTER_BOUND('',#1803,.T.);+#1805=ADVANCED_FACE('',(#1804),#1793,.T.);+#1806=CARTESIAN_POINT($,(307.22074017642,133.568740352839,0));+#1807=DIRECTION($,(0,-1,0));+#1808=DIRECTION($,(0,0,1));+#1809=AXIS2_PLACEMENT_3D($,#1806,#1807,#1808);+#1810=PLANE($,#1809);+#1811=ORIENTED_EDGE($,$,$,#398,.T.);+#1812=CARTESIAN_POINT($,(318.691480352839,133.568740352839,0));+#1813=DIRECTION($,(0,0,1));+#1814=VECTOR($,#1813,1);+#1815=LINE($,#1812,#1814);+#1816=EDGE_CURVE($,#393,#885,#1815,.T.);+#1817=ORIENTED_EDGE($,$,$,#1816,.T.);+#1818=ORIENTED_EDGE($,$,$,#890,.F.);+#1819=ORIENTED_EDGE($,$,$,#1799,.F.);+#1820=EDGE_LOOP($,(#1811,#1817,#1818,#1819));+#1821=FACE_OUTER_BOUND('',#1820,.T.);+#1822=ADVANCED_FACE('',(#1821),#1810,.T.);+#1823=CARTESIAN_POINT($,(318.691480352839,133.568740352839,0));+#1824=DIRECTION($,(0,-1,0));+#1825=DIRECTION($,(0,0,1));+#1826=AXIS2_PLACEMENT_3D($,#1823,#1824,#1825);+#1827=PLANE($,#1826);+#1828=ORIENTED_EDGE($,$,$,#406,.T.);+#1829=CARTESIAN_POINT($,(347.802420352839,133.568740352839,0));+#1830=DIRECTION($,(0,0,1));+#1831=VECTOR($,#1830,1);+#1832=LINE($,#1829,#1831);+#1833=EDGE_CURVE($,#401,#893,#1832,.T.);+#1834=ORIENTED_EDGE($,$,$,#1833,.T.);+#1835=ORIENTED_EDGE($,$,$,#898,.F.);+#1836=ORIENTED_EDGE($,$,$,#1816,.F.);+#1837=EDGE_LOOP($,(#1828,#1834,#1835,#1836));+#1838=FACE_OUTER_BOUND('',#1837,.T.);+#1839=ADVANCED_FACE('',(#1838),#1827,.T.);+#1840=CARTESIAN_POINT($,(347.802420352839,133.568740352839,0));+#1841=DIRECTION($,(0,-1,0));+#1842=DIRECTION($,(0,0,1));+#1843=AXIS2_PLACEMENT_3D($,#1840,#1841,#1842);+#1844=PLANE($,#1843);+#1845=ORIENTED_EDGE($,$,$,#414,.T.);+#1846=CARTESIAN_POINT($,(353.537790441049,133.568740352839,0));+#1847=DIRECTION($,(0,0,1));+#1848=VECTOR($,#1847,1);+#1849=LINE($,#1846,#1848);+#1850=EDGE_CURVE($,#409,#901,#1849,.T.);+#1851=ORIENTED_EDGE($,$,$,#1850,.T.);+#1852=ORIENTED_EDGE($,$,$,#906,.F.);+#1853=ORIENTED_EDGE($,$,$,#1833,.F.);+#1854=EDGE_LOOP($,(#1845,#1851,#1852,#1853));+#1855=FACE_OUTER_BOUND('',#1854,.T.);+#1856=ADVANCED_FACE('',(#1855),#1844,.T.);+#1857=CARTESIAN_POINT($,(353.537790441049,133.568740352839,0));+#1858=DIRECTION($,(0,-1,0));+#1859=DIRECTION($,(0,0,1));+#1860=AXIS2_PLACEMENT_3D($,#1857,#1858,#1859);+#1861=PLANE($,#1860);+#1862=ORIENTED_EDGE($,$,$,#420,.T.);+#1863=ORIENTED_EDGE($,$,$,#1002,.T.);+#1864=ORIENTED_EDGE($,$,$,#912,.F.);+#1865=ORIENTED_EDGE($,$,$,#1850,.F.);+#1866=EDGE_LOOP($,(#1862,#1863,#1864,#1865));+#1867=FACE_OUTER_BOUND('',#1866,.T.);+#1868=ADVANCED_FACE('',(#1867),#1861,.T.);+#1869=CARTESIAN_POINT($,(126.72834017642,189.298880352839,0));+#1870=DIRECTION($,(-1,0,0));+#1871=DIRECTION($,(0,0,1));+#1872=AXIS2_PLACEMENT_3D($,#1869,#1870,#1871);+#1873=PLANE($,#1872);+#1874=ORIENTED_EDGE($,$,$,#454,.T.);+#1875=CARTESIAN_POINT($,(126.72834017642,278.198880352839,-0));+#1876=DIRECTION($,(0,0,1));+#1877=VECTOR($,#1876,1);+#1878=LINE($,#1875,#1877);+#1879=EDGE_CURVE($,#443,#935,#1878,.T.);+#1880=ORIENTED_EDGE($,$,$,#1879,.T.);+#1881=ORIENTED_EDGE($,$,$,#946,.F.);+#1882=CARTESIAN_POINT($,(126.72834017642,189.298880352839,0));+#1883=DIRECTION($,(0,0,1));+#1884=VECTOR($,#1883,1);+#1885=LINE($,#1882,#1884);+#1886=EDGE_CURVE($,#427,#919,#1885,.T.);+#1887=ORIENTED_EDGE($,$,$,#1886,.F.);+#1888=EDGE_LOOP($,(#1874,#1880,#1881,#1887));+#1889=FACE_OUTER_BOUND('',#1888,.T.);+#1890=ADVANCED_FACE('',(#1889),#1873,.T.);+#1891=CARTESIAN_POINT($,(126.72834017642,278.198880352839,0));+#1892=DIRECTION($,(0,-1,0));+#1893=DIRECTION($,(0,0,1));+#1894=AXIS2_PLACEMENT_3D($,#1891,#1892,#1893);+#1895=PLANE($,#1894);+#1896=ORIENTED_EDGE($,$,$,#448,.T.);+#1897=CARTESIAN_POINT($,(107.67834017642,278.198880352839,-0));+#1898=DIRECTION($,(0,0,1));+#1899=VECTOR($,#1898,1);+#1900=LINE($,#1897,#1899);+#1901=EDGE_CURVE($,#435,#927,#1900,.T.);+#1902=ORIENTED_EDGE($,$,$,#1901,.T.);+#1903=ORIENTED_EDGE($,$,$,#940,.F.);+#1904=ORIENTED_EDGE($,$,$,#1879,.F.);+#1905=EDGE_LOOP($,(#1896,#1902,#1903,#1904));+#1906=FACE_OUTER_BOUND('',#1905,.T.);+#1907=ADVANCED_FACE('',(#1906),#1895,.T.);+#1908=CARTESIAN_POINT($,(107.67834017642,278.198880352839,0));+#1909=DIRECTION($,(1,0,0));+#1910=DIRECTION($,(0,0,1));+#1911=AXIS2_PLACEMENT_3D($,#1908,#1909,#1910);+#1912=PLANE($,#1911);+#1913=ORIENTED_EDGE($,$,$,#440,.T.);+#1914=CARTESIAN_POINT($,(107.67834017642,189.298880352839,-0));+#1915=DIRECTION($,(0,0,1));+#1916=VECTOR($,#1915,1);+#1917=LINE($,#1914,#1916);+#1918=EDGE_CURVE($,#425,#917,#1917,.T.);+#1919=ORIENTED_EDGE($,$,$,#1918,.T.);+#1920=ORIENTED_EDGE($,$,$,#932,.F.);+#1921=ORIENTED_EDGE($,$,$,#1901,.F.);+#1922=EDGE_LOOP($,(#1913,#1919,#1920,#1921));+#1923=FACE_OUTER_BOUND('',#1922,.T.);+#1924=ADVANCED_FACE('',(#1923),#1912,.T.);+#1925=CARTESIAN_POINT($,(107.67834017642,189.298880352839,0));+#1926=DIRECTION($,(0,1,0));+#1927=DIRECTION($,(0,0,1));+#1928=AXIS2_PLACEMENT_3D($,#1925,#1926,#1927);+#1929=PLANE($,#1928);+#1930=ORIENTED_EDGE($,$,$,#432,.T.);+#1931=ORIENTED_EDGE($,$,$,#1886,.T.);+#1932=ORIENTED_EDGE($,$,$,#924,.F.);+#1933=ORIENTED_EDGE($,$,$,#1918,.F.);+#1934=EDGE_LOOP($,(#1930,#1931,#1932,#1933));+#1935=FACE_OUTER_BOUND('',#1934,.T.);+#1936=ADVANCED_FACE('',(#1935),#1929,.T.);+#1937=CARTESIAN_POINT($,(190.22834017642,189.298880352839,0));+#1938=DIRECTION($,(-1,0,0));+#1939=DIRECTION($,(0,0,1));+#1940=AXIS2_PLACEMENT_3D($,#1937,#1938,#1939);+#1941=PLANE($,#1940);+#1942=ORIENTED_EDGE($,$,$,#488,.T.);+#1943=CARTESIAN_POINT($,(190.22834017642,278.198880352839,-0));+#1944=DIRECTION($,(0,0,1));+#1945=VECTOR($,#1944,1);+#1946=LINE($,#1943,#1945);+#1947=EDGE_CURVE($,#477,#969,#1946,.T.);+#1948=ORIENTED_EDGE($,$,$,#1947,.T.);+#1949=ORIENTED_EDGE($,$,$,#980,.F.);+#1950=CARTESIAN_POINT($,(190.22834017642,189.298880352839,0));+#1951=DIRECTION($,(0,0,1));+#1952=VECTOR($,#1951,1);+#1953=LINE($,#1950,#1952);+#1954=EDGE_CURVE($,#461,#953,#1953,.T.);+#1955=ORIENTED_EDGE($,$,$,#1954,.F.);+#1956=EDGE_LOOP($,(#1942,#1948,#1949,#1955));+#1957=FACE_OUTER_BOUND('',#1956,.T.);+#1958=ADVANCED_FACE('',(#1957),#1941,.T.);+#1959=CARTESIAN_POINT($,(190.22834017642,278.198880352839,0));+#1960=DIRECTION($,(0,-1,0));+#1961=DIRECTION($,(0,0,1));+#1962=AXIS2_PLACEMENT_3D($,#1959,#1960,#1961);+#1963=PLANE($,#1962);+#1964=ORIENTED_EDGE($,$,$,#482,.T.);+#1965=CARTESIAN_POINT($,(171.17834017642,278.198880352839,-0));+#1966=DIRECTION($,(0,0,1));+#1967=VECTOR($,#1966,1);+#1968=LINE($,#1965,#1967);+#1969=EDGE_CURVE($,#469,#961,#1968,.T.);+#1970=ORIENTED_EDGE($,$,$,#1969,.T.);+#1971=ORIENTED_EDGE($,$,$,#974,.F.);+#1972=ORIENTED_EDGE($,$,$,#1947,.F.);+#1973=EDGE_LOOP($,(#1964,#1970,#1971,#1972));+#1974=FACE_OUTER_BOUND('',#1973,.T.);+#1975=ADVANCED_FACE('',(#1974),#1963,.T.);+#1976=CARTESIAN_POINT($,(171.17834017642,278.198880352839,0));+#1977=DIRECTION($,(1,0,0));+#1978=DIRECTION($,(0,0,1));+#1979=AXIS2_PLACEMENT_3D($,#1976,#1977,#1978);+#1980=PLANE($,#1979);+#1981=ORIENTED_EDGE($,$,$,#474,.T.);+#1982=CARTESIAN_POINT($,(171.17834017642,189.298880352839,-0));+#1983=DIRECTION($,(0,0,1));+#1984=VECTOR($,#1983,1);+#1985=LINE($,#1982,#1984);+#1986=EDGE_CURVE($,#459,#951,#1985,.T.);+#1987=ORIENTED_EDGE($,$,$,#1986,.T.);+#1988=ORIENTED_EDGE($,$,$,#966,.F.);+#1989=ORIENTED_EDGE($,$,$,#1969,.F.);+#1990=EDGE_LOOP($,(#1981,#1987,#1988,#1989));+#1991=FACE_OUTER_BOUND('',#1990,.T.);+#1992=ADVANCED_FACE('',(#1991),#1980,.T.);+#1993=CARTESIAN_POINT($,(171.17834017642,189.298880352839,0));+#1994=DIRECTION($,(0,1,0));+#1995=DIRECTION($,(0,0,1));+#1996=AXIS2_PLACEMENT_3D($,#1993,#1994,#1995);+#1997=PLANE($,#1996);+#1998=ORIENTED_EDGE($,$,$,#466,.T.);+#1999=ORIENTED_EDGE($,$,$,#1954,.T.);+#2000=ORIENTED_EDGE($,$,$,#958,.F.);+#2001=ORIENTED_EDGE($,$,$,#1986,.F.);+#2002=EDGE_LOOP($,(#1998,#1999,#2000,#2001));+#2003=FACE_OUTER_BOUND('',#2002,.T.);+#2004=ADVANCED_FACE('',(#2003),#1997,.T.);+#2005=CLOSED_SHELL($,(#492,#984,#1006,#1023,#1040,#1057,#1074,#1091,#1108,#1125,#1142,#1159,#1176,#1193,#1210,#1227,#1244,#1261,#1278,#1295,#1312,#1329,#1346,#1363,#1380,#1397,#1414,#1431,#1448,#1465,#1482,#1499,#1516,#1533,#1550,#1567,#1584,#1601,#1618,#1635,#1652,#1669,#1686,#1703,#1720,#1737,#1754,#1771,#1788,#1805,#1822,#1839,#1856,#1868,#1890,#1907,#1924,#1936,#1958,#1975,#1992,#2004));+#2006=MANIFOLD_SOLID_BREP('sheetmetal-Ctc03 flat pattern',#2005);+#2007=APPLICATION_CONTEXT('mechanical design');+#2008=PRODUCT_CONTEXT('',#2007,'mechanical');+#2009=PRODUCT('sheetmetal_Ctc03_flat','sheetmetal-Ctc03 flat pattern','',(#2008));+#2010=PRODUCT_DEFINITION_FORMATION('','',#2009);+#2011=PRODUCT_DEFINITION_CONTEXT('design',#2007,'design');+#2012=PRODUCT_DEFINITION('','',#2010,#2011);+#2013=PRODUCT_DEFINITION_SHAPE('','',#2012);+#2014=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));+#2015=(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.));+#2016=(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT());+#2017=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNIT_ASSIGNED_CONTEXT((#2014,#2015,#2016))REPRESENTATION_CONTEXT('3','3D'));+#2018=SHAPE_REPRESENTATION('sheetmetal-Ctc03 flat pattern',(#2006),#2017);+#2019=SHAPE_DEFINITION_REPRESENTATION(#2013,#2018);+ENDSEC;+END-ISO-10303-21;diff --git a/docs/modules/sheetmetal/artifacts/m4/ctc03-m4-flat.svg b/docs/modules/sheetmetal/artifacts/m4/ctc03-m4-flat.svgnew file mode 100644index 00000000..8f3a8619--- /dev/null+++ b/docs/modules/sheetmetal/artifacts/m4/ctc03-m4-flat.svg@@ -0,0 +1,57 @@+<?xml version="1.0" encoding="UTF-8"?>+<svg xmlns="http://www.w3.org/2000/svg" width="416.052mm" height="636.598mm" viewBox="0 0 416.052 636.598">+<rect width="100%" height="100%" fill="white"/>+<g id="sheet-regions" fill="#dbeafe" fill-opacity="0.55" stroke="#0f172a" stroke-width="0.45">+<path id="flat-AngledServiceFlange" d="M 404.052 501.029 L 404.052 149.239 L 355.538 149.239 L 355.538 501.029 L 404.052 501.029 Z"/>+<path id="flat-AngledServiceFlangeBend" d="M 355.538 501.029 L 355.538 149.239 L 349.802 149.239 L 349.802 501.029 L 355.538 501.029 Z"/>+<path id="flat-FrontMountingFlange" d="M 76.176 624.598 L 300.966 624.598 L 300.966 593.818 L 76.176 593.818 L 76.176 624.598 Z"/>+<path id="flat-FrontMountingFlangeBend" d="M 76.176 593.818 L 300.966 593.818 L 300.966 582.347 L 76.176 582.347 L 76.176 593.818 Z"/>+<path id="flat-FrontWall" d="M 76.176 582.347 L 300.966 582.347 L 300.966 520.755 L 76.176 520.755 L 76.176 582.347 Z"/>+<path id="flat-FrontWallBend" d="M 76.176 520.755 L 300.966 520.755 L 300.966 509.284 L 76.176 509.284 L 76.176 520.755 Z"/>+<path id="flat-LeftWall" d="M 12 149.239 L 12 501.029 L 56.45 501.029 L 56.45 149.239 L 12 149.239 Z"/>+<path id="flat-LeftWallBend" d="M 56.45 149.239 L 56.45 501.029 L 67.921 501.029 L 67.921 149.239 L 56.45 149.239 Z"/>+<path id="flat-MainDeck" d="M 67.921 509.284 L 76.176 509.284 L 300.966 509.284 L 309.221 509.284 L 309.221 501.029 L 309.221 149.239 L 309.221 140.984 L 300.966 140.984 L 76.176 140.984 L 67.921 140.984 L 67.921 149.239 L 67.921 501.029 L 67.921 509.284 Z"/>+<path id="flat-RearMountingFlange" d="M 300.966 12 L 76.176 12 L 76.176 56.45 L 300.966 56.45 L 300.966 12 Z"/>+<path id="flat-RearMountingFlangeBend" d="M 300.966 56.45 L 76.176 56.45 L 76.176 67.921 L 300.966 67.921 L 300.966 56.45 Z"/>+<path id="flat-RearWall" d="M 300.966 67.921 L 76.176 67.921 L 76.176 129.513 L 300.966 129.513 L 300.966 67.921 Z"/>+<path id="flat-RearWallBend" d="M 300.966 129.513 L 76.176 129.513 L 76.176 140.984 L 300.966 140.984 L 300.966 129.513 Z"/>+<path id="flat-RightWall" d="M 349.802 501.029 L 349.802 149.239 L 320.691 149.239 L 320.691 501.029 L 349.802 501.029 Z"/>+<path id="flat-RightWallBend" d="M 320.691 501.029 L 320.691 149.239 L 309.221 149.239 L 309.221 501.029 L 320.691 501.029 Z"/>+</g>+<g id="cut-contours" fill="white" stroke="#dc2626" stroke-width="0.5">+<path id="VentSlotLeft" d="M 109.678 445.299 L 128.728 445.299 L 128.728 356.399 L 109.678 356.399 L 109.678 445.299 Z"/>+<path id="VentSlotRight" d="M 173.178 445.299 L 192.228 445.299 L 192.228 356.399 L 173.178 356.399 L 173.178 445.299 Z"/>+</g>+<g id="corner-reliefs" fill="white" stroke="#ea580c" stroke-width="0.5">+<path id="relief-FrontWall-RightWall" d="M 312.588 511.305 L 304.057 502.773 L 302.71 504.12 L 311.241 512.652 L 312.588 511.305 Z"/>+<path id="relief-LeftWall-FrontWall" d="M 65.9 512.652 L 74.431 504.12 L 73.084 502.773 L 64.553 511.305 L 65.9 512.652 Z"/>+<path id="relief-RearWall-LeftWall" d="M 64.553 138.963 L 73.084 147.495 L 74.431 146.148 L 65.9 137.616 L 64.553 138.963 Z"/>+<path id="relief-RightWall-RearWall" d="M 311.241 137.616 L 302.71 146.148 L 304.057 147.495 L 312.588 138.963 L 311.241 137.616 Z"/>+</g>+<g id="bend-lines" fill="none" stroke="#2563eb" stroke-width="0.45" stroke-dasharray="3 2">+<line x1="352.67" y1="501.029" x2="352.67" y2="149.239"/>+<line x1="76.176" y1="588.083" x2="300.966" y2="588.083"/>+<line x1="76.176" y1="515.019" x2="300.966" y2="515.019"/>+<line x1="62.185" y1="149.239" x2="62.185" y2="501.029"/>+<line x1="300.966" y1="62.185" x2="76.176" y2="62.185"/>+<line x1="300.966" y1="135.249" x2="76.176" y2="135.249"/>+<line x1="314.956" y1="501.029" x2="314.956" y2="149.239"/>+</g>+<g id="bend-labels" stroke="none" font-family="Inter, 'Segoe UI', Arial, sans-serif" font-size="3" text-anchor="middle" dominant-baseline="central">+<rect x="344.42" y="322.934" width="24.5" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>+<text x="356.67" y="325.134" fill="#1d4ed8">Down 45° R6.35</text>+<rect x="177.971" y="589.883" width="21.2" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>+<text x="188.571" y="592.083" fill="#1d4ed8">Up 90° R6.35</text>+<rect x="176.321" y="516.819" width="24.5" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>+<text x="188.571" y="519.019" fill="#1d4ed8">Down 90° R6.35</text>+<rect x="47.585" y="322.934" width="21.2" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>+<text x="58.185" y="325.134" fill="#1d4ed8">Up 90° R6.35</text>+<rect x="177.971" y="55.985" width="21.2" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>+<text x="188.571" y="58.185" fill="#1d4ed8">Up 90° R6.35</text>+<rect x="176.321" y="129.049" width="24.5" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>+<text x="188.571" y="131.249" fill="#1d4ed8">Down 90° R6.35</text>+<rect x="308.356" y="322.934" width="21.2" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>+<text x="318.956" y="325.134" fill="#1d4ed8">Up 90° R6.35</text>+</g>+<text x="4" y="6" font-family="sans-serif" font-size="3" fill="#334155">Valid · K=0.5 · SHA-256 dfeb1228747e</text>+</svg>diff --git a/docs/modules/sheetmetal/artifacts/m4/ctc03-m4-formed.step b/docs/modules/sheetmetal/artifacts/m4/ctc03-m4-formed.stepnew file mode 100644index 00000000..3a98f166--- /dev/null+++ b/docs/modules/sheetmetal/artifacts/m4/ctc03-m4-formed.step@@ -0,0 +1,2108 @@+ISO-10303-21;+HEADER;+FILE_DESCRIPTION(('Aetheris AP242 subset export'),'2;1');+FILE_NAME('aetheris_export.step','1970-01-01T00:00:00',('Aetheris'),('Aetheris'),'Aetheris.Kernel','Aetheris.Kernel','');+FILE_SCHEMA(('AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF'));+ENDSEC;+DATA;+#1=CARTESIAN_POINT($,(-241.3,58.08726,78.105));+#2=DIRECTION($,(0,0,1));+#3=DIRECTION($,(1,0,0));+#4=AXIS2_PLACEMENT_3D($,#1,#2,#3);+#5=PLANE($,#4);+#6=CARTESIAN_POINT($,(-241.3,58.08726,78.105));+#7=VERTEX_POINT($,#6);+#8=CARTESIAN_POINT($,(-233.045,58.08726,78.105));+#9=VERTEX_POINT($,#8);+#10=CARTESIAN_POINT($,(-241.3,58.08726,78.105));+#11=DIRECTION($,(1,0,0));+#12=VECTOR($,#11,1);+#13=LINE($,#10,#12);+#14=EDGE_CURVE($,#7,#9,#13,.T.);+#15=ORIENTED_EDGE($,$,$,#14,.T.);+#16=CARTESIAN_POINT($,(-8.255,58.08726,78.105));+#17=VERTEX_POINT($,#16);+#18=CARTESIAN_POINT($,(-233.045,58.08726,78.105));+#19=DIRECTION($,(1,0,0));+#20=VECTOR($,#19,1);+#21=LINE($,#18,#20);+#22=EDGE_CURVE($,#9,#17,#21,.T.);+#23=ORIENTED_EDGE($,$,$,#22,.T.);+#24=CARTESIAN_POINT($,(0,58.08726,78.105));+#25=VERTEX_POINT($,#24);+#26=CARTESIAN_POINT($,(-8.255,58.08726,78.105));+#27=DIRECTION($,(1,0,0));+#28=VECTOR($,#27,1);+#29=LINE($,#26,#28);+#30=EDGE_CURVE($,#17,#25,#29,.T.);+#31=ORIENTED_EDGE($,$,$,#30,.T.);+#32=CARTESIAN_POINT($,(0,66.34226,78.105));+#33=VERTEX_POINT($,#32);+#34=CARTESIAN_POINT($,(0,58.08726,78.105));+#35=DIRECTION($,(0,1,0));+#36=VECTOR($,#35,1);+#37=LINE($,#34,#36);+#38=EDGE_CURVE($,#25,#33,#37,.T.);+#39=ORIENTED_EDGE($,$,$,#38,.T.);+#40=CARTESIAN_POINT($,(0,418.13226,78.105));+#41=VERTEX_POINT($,#40);+#42=CARTESIAN_POINT($,(0,66.34226,78.105));+#43=DIRECTION($,(0,1,0));+#44=VECTOR($,#43,1);+#45=LINE($,#42,#44);+#46=EDGE_CURVE($,#33,#41,#45,.T.);+#47=ORIENTED_EDGE($,$,$,#46,.T.);+#48=CARTESIAN_POINT($,(0,426.38726,78.105));+#49=VERTEX_POINT($,#48);+#50=CARTESIAN_POINT($,(0,418.13226,78.105));+#51=DIRECTION($,(0,1,0));+#52=VECTOR($,#51,1);+#53=LINE($,#50,#52);+#54=EDGE_CURVE($,#41,#49,#53,.T.);+#55=ORIENTED_EDGE($,$,$,#54,.T.);+#56=CARTESIAN_POINT($,(-8.255,426.38726,78.105));+#57=VERTEX_POINT($,#56);+#58=CARTESIAN_POINT($,(0,426.38726,78.105));+#59=DIRECTION($,(-1,0,0));+#60=VECTOR($,#59,1);+#61=LINE($,#58,#60);+#62=EDGE_CURVE($,#49,#57,#61,.T.);+#63=ORIENTED_EDGE($,$,$,#62,.T.);+#64=CARTESIAN_POINT($,(-233.045,426.38726,78.105));+#65=VERTEX_POINT($,#64);+#66=CARTESIAN_POINT($,(-8.255,426.38726,78.105));+#67=DIRECTION($,(-1,0,0));+#68=VECTOR($,#67,1);+#69=LINE($,#66,#68);+#70=EDGE_CURVE($,#57,#65,#69,.T.);+#71=ORIENTED_EDGE($,$,$,#70,.T.);+#72=CARTESIAN_POINT($,(-241.3,426.38726,78.105));+#73=VERTEX_POINT($,#72);+#74=CARTESIAN_POINT($,(-233.045,426.38726,78.105));+#75=DIRECTION($,(-1,0,0));+#76=VECTOR($,#75,1);+#77=LINE($,#74,#76);+#78=EDGE_CURVE($,#65,#73,#77,.T.);+#79=ORIENTED_EDGE($,$,$,#78,.T.);+#80=CARTESIAN_POINT($,(-241.3,418.13226,78.105));+#81=VERTEX_POINT($,#80);+#82=CARTESIAN_POINT($,(-241.3,426.38726,78.105));+#83=DIRECTION($,(0,-1,0));+#84=VECTOR($,#83,1);+#85=LINE($,#82,#84);+#86=EDGE_CURVE($,#73,#81,#85,.T.);+#87=ORIENTED_EDGE($,$,$,#86,.T.);+#88=CARTESIAN_POINT($,(-241.3,66.34226,78.105));+#89=VERTEX_POINT($,#88);+#90=CARTESIAN_POINT($,(-241.3,418.13226,78.105));+#91=DIRECTION($,(0,-1,0));+#92=VECTOR($,#91,1);+#93=LINE($,#90,#92);+#94=EDGE_CURVE($,#81,#89,#93,.T.);+#95=ORIENTED_EDGE($,$,$,#94,.T.);+#96=CARTESIAN_POINT($,(-241.3,66.34226,78.105));+#97=DIRECTION($,(0,-1,0));+#98=VECTOR($,#97,1);+#99=LINE($,#96,#98);+#100=EDGE_CURVE($,#89,#7,#99,.T.);+#101=ORIENTED_EDGE($,$,$,#100,.T.);+#102=EDGE_LOOP($,(#15,#23,#31,#39,#47,#55,#63,#71,#79,#87,#95,#101));+#103=FACE_OUTER_BOUND('',#102,.T.);+#104=CARTESIAN_POINT($,(-116.9924,210.9724,78.105));+#105=VERTEX_POINT($,#104);+#106=CARTESIAN_POINT($,(-136.0424,210.9724,78.105));+#107=VERTEX_POINT($,#106);+#108=CARTESIAN_POINT($,(-116.9924,210.9724,78.105));+#109=DIRECTION($,(-1,0,0));+#110=VECTOR($,#109,1);+#111=LINE($,#108,#110);+#112=EDGE_CURVE($,#105,#107,#111,.T.);+#113=ORIENTED_EDGE($,$,$,#112,.F.);+#114=CARTESIAN_POINT($,(-116.9924,122.0724,78.105));+#115=VERTEX_POINT($,#114);+#116=CARTESIAN_POINT($,(-116.9924,122.0724,78.105));+#117=DIRECTION($,(0,1,0));+#118=VECTOR($,#117,1);+#119=LINE($,#116,#118);+#120=EDGE_CURVE($,#115,#105,#119,.T.);+#121=ORIENTED_EDGE($,$,$,#120,.F.);+#122=CARTESIAN_POINT($,(-136.0424,122.0724,78.105));+#123=VERTEX_POINT($,#122);+#124=CARTESIAN_POINT($,(-136.0424,122.0724,78.105));+#125=DIRECTION($,(1,0,0));+#126=VECTOR($,#125,1);+#127=LINE($,#124,#126);+#128=EDGE_CURVE($,#123,#115,#127,.T.);+#129=ORIENTED_EDGE($,$,$,#128,.F.);+#130=CARTESIAN_POINT($,(-136.0424,210.9724,78.105));+#131=DIRECTION($,(0,-1,0));+#132=VECTOR($,#131,1);+#133=LINE($,#130,#132);+#134=EDGE_CURVE($,#107,#123,#133,.T.);+#135=ORIENTED_EDGE($,$,$,#134,.F.);+#136=EDGE_LOOP($,(#113,#121,#129,#135));+#137=FACE_BOUND('',#136,.T.);+#138=CARTESIAN_POINT($,(-180.4924,210.9724,78.105));+#139=VERTEX_POINT($,#138);+#140=CARTESIAN_POINT($,(-199.5424,210.9724,78.105));+#141=VERTEX_POINT($,#140);+#142=CARTESIAN_POINT($,(-180.4924,210.9724,78.105));+#143=DIRECTION($,(-1,0,0));+#144=VECTOR($,#143,1);+#145=LINE($,#142,#144);+#146=EDGE_CURVE($,#139,#141,#145,.T.);+#147=ORIENTED_EDGE($,$,$,#146,.F.);+#148=CARTESIAN_POINT($,(-180.4924,122.0724,78.105));+#149=VERTEX_POINT($,#148);+#150=CARTESIAN_POINT($,(-180.4924,122.0724,78.105));+#151=DIRECTION($,(0,1,0));+#152=VECTOR($,#151,1);+#153=LINE($,#150,#152);+#154=EDGE_CURVE($,#149,#139,#153,.T.);+#155=ORIENTED_EDGE($,$,$,#154,.F.);+#156=CARTESIAN_POINT($,(-199.5424,122.0724,78.105));+#157=VERTEX_POINT($,#156);+#158=CARTESIAN_POINT($,(-199.5424,122.0724,78.105));+#159=DIRECTION($,(1,0,0));+#160=VECTOR($,#159,1);+#161=LINE($,#158,#160);+#162=EDGE_CURVE($,#157,#149,#161,.T.);+#163=ORIENTED_EDGE($,$,$,#162,.F.);+#164=CARTESIAN_POINT($,(-199.5424,210.9724,78.105));+#165=DIRECTION($,(0,-1,0));+#166=VECTOR($,#165,1);+#167=LINE($,#164,#166);+#168=EDGE_CURVE($,#141,#157,#167,.T.);+#169=ORIENTED_EDGE($,$,$,#168,.F.);+#170=EDGE_LOOP($,(#147,#155,#163,#169));+#171=FACE_BOUND('',#170,.T.);+#172=ADVANCED_FACE('',(#103,#137,#171),#5,.T.);+#173=CARTESIAN_POINT($,(-241.3,58.08726,76.2));+#174=DIRECTION($,(-0,-0,-1));+#175=DIRECTION($,(1,0,0));+#176=AXIS2_PLACEMENT_3D($,#173,#174,#175);+#177=PLANE($,#176);+#178=CARTESIAN_POINT($,(-241.3,66.34226,76.2));+#179=VERTEX_POINT($,#178);+#180=CARTESIAN_POINT($,(-241.3,418.13226,76.2));+#181=VERTEX_POINT($,#180);+#182=CARTESIAN_POINT($,(-241.3,66.34226,76.2));+#183=DIRECTION($,(0,1,0));+#184=VECTOR($,#183,1);+#185=LINE($,#182,#184);+#186=EDGE_CURVE($,#179,#181,#185,.T.);+#187=ORIENTED_EDGE($,$,$,#186,.T.);+#188=CARTESIAN_POINT($,(-241.3,426.38726,76.2));+#189=VERTEX_POINT($,#188);+#190=CARTESIAN_POINT($,(-241.3,418.13226,76.2));+#191=DIRECTION($,(0,1,0));+#192=VECTOR($,#191,1);+#193=LINE($,#190,#192);+#194=EDGE_CURVE($,#181,#189,#193,.T.);+#195=ORIENTED_EDGE($,$,$,#194,.T.);+#196=CARTESIAN_POINT($,(-233.045,426.38726,76.2));+#197=VERTEX_POINT($,#196);+#198=CARTESIAN_POINT($,(-241.3,426.38726,76.2));+#199=DIRECTION($,(1,0,0));+#200=VECTOR($,#199,1);+#201=LINE($,#198,#200);+#202=EDGE_CURVE($,#189,#197,#201,.T.);+#203=ORIENTED_EDGE($,$,$,#202,.T.);+#204=CARTESIAN_POINT($,(-8.255,426.38726,76.2));+#205=VERTEX_POINT($,#204);+#206=CARTESIAN_POINT($,(-233.045,426.38726,76.2));+#207=DIRECTION($,(1,0,0));+#208=VECTOR($,#207,1);+#209=LINE($,#206,#208);+#210=EDGE_CURVE($,#197,#205,#209,.T.);+#211=ORIENTED_EDGE($,$,$,#210,.T.);+#212=CARTESIAN_POINT($,(-0,426.38726,76.2));+#213=VERTEX_POINT($,#212);+#214=CARTESIAN_POINT($,(-8.255,426.38726,76.2));+#215=DIRECTION($,(1,0,0));+#216=VECTOR($,#215,1);+#217=LINE($,#214,#216);+#218=EDGE_CURVE($,#205,#213,#217,.T.);+#219=ORIENTED_EDGE($,$,$,#218,.T.);+#220=CARTESIAN_POINT($,(0,418.13226,76.2));+#221=VERTEX_POINT($,#220);+#222=CARTESIAN_POINT($,(-0,426.38726,76.2));+#223=DIRECTION($,(0,-1,0));+#224=VECTOR($,#223,1);+#225=LINE($,#222,#224);+#226=EDGE_CURVE($,#213,#221,#225,.T.);+#227=ORIENTED_EDGE($,$,$,#226,.T.);+#228=CARTESIAN_POINT($,(0,66.34226,76.2));+#229=VERTEX_POINT($,#228);+#230=CARTESIAN_POINT($,(0,418.13226,76.2));+#231=DIRECTION($,(0,-1,0));+#232=VECTOR($,#231,1);+#233=LINE($,#230,#232);+#234=EDGE_CURVE($,#221,#229,#233,.T.);+#235=ORIENTED_EDGE($,$,$,#234,.T.);+#236=CARTESIAN_POINT($,(-0,58.08726,76.2));+#237=VERTEX_POINT($,#236);+#238=CARTESIAN_POINT($,(0,66.34226,76.2));+#239=DIRECTION($,(0,-1,0));+#240=VECTOR($,#239,1);+#241=LINE($,#238,#240);+#242=EDGE_CURVE($,#229,#237,#241,.T.);+#243=ORIENTED_EDGE($,$,$,#242,.T.);+#244=CARTESIAN_POINT($,(-8.255,58.08726,76.2));+#245=VERTEX_POINT($,#244);+#246=CARTESIAN_POINT($,(-0,58.08726,76.2));+#247=DIRECTION($,(-1,0,0));+#248=VECTOR($,#247,1);+#249=LINE($,#246,#248);+#250=EDGE_CURVE($,#237,#245,#249,.T.);+#251=ORIENTED_EDGE($,$,$,#250,.T.);+#252=CARTESIAN_POINT($,(-233.045,58.08726,76.2));+#253=VERTEX_POINT($,#252);+#254=CARTESIAN_POINT($,(-8.255,58.08726,76.2));+#255=DIRECTION($,(-1,0,0));+#256=VECTOR($,#255,1);+#257=LINE($,#254,#256);+#258=EDGE_CURVE($,#245,#253,#257,.T.);+#259=ORIENTED_EDGE($,$,$,#258,.T.);+#260=CARTESIAN_POINT($,(-241.3,58.08726,76.2));+#261=VERTEX_POINT($,#260);+#262=CARTESIAN_POINT($,(-233.045,58.08726,76.2));+#263=DIRECTION($,(-1,0,0));+#264=VECTOR($,#263,1);+#265=LINE($,#262,#264);+#266=EDGE_CURVE($,#253,#261,#265,.T.);+#267=ORIENTED_EDGE($,$,$,#266,.T.);+#268=CARTESIAN_POINT($,(-241.3,58.08726,76.2));+#269=DIRECTION($,(0,1,0));+#270=VECTOR($,#269,1);+#271=LINE($,#268,#270);+#272=EDGE_CURVE($,#261,#179,#271,.T.);+#273=ORIENTED_EDGE($,$,$,#272,.T.);+#274=EDGE_LOOP($,(#187,#195,#203,#211,#219,#227,#235,#243,#251,#259,#267,#273));+#275=FACE_OUTER_BOUND('',#274,.T.);+#276=CARTESIAN_POINT($,(-136.0424,122.0724,76.2));+#277=VERTEX_POINT($,#276);+#278=CARTESIAN_POINT($,(-116.9924,122.0724,76.2));+#279=VERTEX_POINT($,#278);+#280=CARTESIAN_POINT($,(-136.0424,122.0724,76.2));+#281=DIRECTION($,(1,0,0));+#282=VECTOR($,#281,1);+#283=LINE($,#280,#282);+#284=EDGE_CURVE($,#277,#279,#283,.T.);+#285=ORIENTED_EDGE($,$,$,#284,.T.);+#286=CARTESIAN_POINT($,(-116.9924,210.9724,76.2));+#287=VERTEX_POINT($,#286);+#288=CARTESIAN_POINT($,(-116.9924,122.0724,76.2));+#289=DIRECTION($,(0,1,0));+#290=VECTOR($,#289,1);+#291=LINE($,#288,#290);+#292=EDGE_CURVE($,#279,#287,#291,.T.);+#293=ORIENTED_EDGE($,$,$,#292,.T.);+#294=CARTESIAN_POINT($,(-136.0424,210.9724,76.2));+#295=VERTEX_POINT($,#294);+#296=CARTESIAN_POINT($,(-116.9924,210.9724,76.2));+#297=DIRECTION($,(-1,0,0));+#298=VECTOR($,#297,1);+#299=LINE($,#296,#298);+#300=EDGE_CURVE($,#287,#295,#299,.T.);+#301=ORIENTED_EDGE($,$,$,#300,.T.);+#302=CARTESIAN_POINT($,(-136.0424,210.9724,76.2));+#303=DIRECTION($,(0,-1,0));+#304=VECTOR($,#303,1);+#305=LINE($,#302,#304);+#306=EDGE_CURVE($,#295,#277,#305,.T.);+#307=ORIENTED_EDGE($,$,$,#306,.T.);+#308=EDGE_LOOP($,(#285,#293,#301,#307));+#309=FACE_BOUND('',#308,.T.);+#310=CARTESIAN_POINT($,(-199.5424,122.0724,76.2));+#311=VERTEX_POINT($,#310);+#312=CARTESIAN_POINT($,(-180.4924,122.0724,76.2));+#313=VERTEX_POINT($,#312);+#314=CARTESIAN_POINT($,(-199.5424,122.0724,76.2));+#315=DIRECTION($,(1,0,0));+#316=VECTOR($,#315,1);+#317=LINE($,#314,#316);+#318=EDGE_CURVE($,#311,#313,#317,.T.);+#319=ORIENTED_EDGE($,$,$,#318,.T.);+#320=CARTESIAN_POINT($,(-180.4924,210.9724,76.2));+#321=VERTEX_POINT($,#320);+#322=CARTESIAN_POINT($,(-180.4924,122.0724,76.2));+#323=DIRECTION($,(0,1,0));+#324=VECTOR($,#323,1);+#325=LINE($,#322,#324);+#326=EDGE_CURVE($,#313,#321,#325,.T.);+#327=ORIENTED_EDGE($,$,$,#326,.T.);+#328=CARTESIAN_POINT($,(-199.5424,210.9724,76.2));+#329=VERTEX_POINT($,#328);+#330=CARTESIAN_POINT($,(-180.4924,210.9724,76.2));+#331=DIRECTION($,(-1,0,0));+#332=VECTOR($,#331,1);+#333=LINE($,#330,#332);+#334=EDGE_CURVE($,#321,#329,#333,.T.);+#335=ORIENTED_EDGE($,$,$,#334,.T.);+#336=CARTESIAN_POINT($,(-199.5424,210.9724,76.2));+#337=DIRECTION($,(0,-1,0));+#338=VECTOR($,#337,1);+#339=LINE($,#336,#338);+#340=EDGE_CURVE($,#329,#311,#339,.T.);+#341=ORIENTED_EDGE($,$,$,#340,.T.);+#342=EDGE_LOOP($,(#319,#327,#335,#341));+#343=FACE_BOUND('',#342,.T.);+#344=ADVANCED_FACE('',(#275,#309,#343),#177,.F.);+#345=CARTESIAN_POINT($,(-233.045,49.83226,69.85));+#346=DIRECTION($,(0,-1,0));+#347=DIRECTION($,(1,0,0));+#348=AXIS2_PLACEMENT_3D($,#345,#346,#347);+#349=PLANE($,#348);+#350=CARTESIAN_POINT($,(-233.045,49.83226,69.85));+#351=VERTEX_POINT($,#350);+#352=CARTESIAN_POINT($,(-8.255,49.83226,69.85));+#353=VERTEX_POINT($,#352);+#354=CARTESIAN_POINT($,(-233.045,49.83226,69.85));+#355=DIRECTION($,(1,0,0));+#356=VECTOR($,#355,1);+#357=LINE($,#354,#356);+#358=EDGE_CURVE($,#351,#353,#357,.T.);+#359=ORIENTED_EDGE($,$,$,#358,.T.);+#360=CARTESIAN_POINT($,(-8.255,49.83226,8.25746000000001));+#361=VERTEX_POINT($,#360);+#362=CARTESIAN_POINT($,(-8.255,49.83226,69.85));+#363=DIRECTION($,(0,-0,-1));+#364=VECTOR($,#363,1);+#365=LINE($,#362,#364);+#366=EDGE_CURVE($,#353,#361,#365,.T.);+#367=ORIENTED_EDGE($,$,$,#366,.T.);+#368=CARTESIAN_POINT($,(-233.045,49.83226,8.25746000000001));+#369=VERTEX_POINT($,#368);+#370=CARTESIAN_POINT($,(-8.255,49.83226,8.25746000000001));+#371=DIRECTION($,(-1,0,0));+#372=VECTOR($,#371,1);+#373=LINE($,#370,#372);+#374=EDGE_CURVE($,#361,#369,#373,.T.);+#375=ORIENTED_EDGE($,$,$,#374,.T.);+#376=CARTESIAN_POINT($,(-233.045,49.83226,8.25746000000001));+#377=DIRECTION($,(0,0,1));+#378=VECTOR($,#377,1);+#379=LINE($,#376,#378);+#380=EDGE_CURVE($,#369,#351,#379,.T.);+#381=ORIENTED_EDGE($,$,$,#380,.T.);+#382=EDGE_LOOP($,(#359,#367,#375,#381));+#383=FACE_OUTER_BOUND('',#382,.T.);+#384=ADVANCED_FACE('',(#383),#349,.T.);+#385=CARTESIAN_POINT($,(-233.045,51.73726,69.85));+#386=DIRECTION($,(-0,1,-0));+#387=DIRECTION($,(1,0,0));+#388=AXIS2_PLACEMENT_3D($,#385,#386,#387);+#389=PLANE($,#388);+#390=CARTESIAN_POINT($,(-233.045,51.73726,8.25746000000001));+#391=VERTEX_POINT($,#390);+#392=CARTESIAN_POINT($,(-8.255,51.73726,8.25746000000001));+#393=VERTEX_POINT($,#392);+#394=CARTESIAN_POINT($,(-233.045,51.73726,8.25746000000001));+#395=DIRECTION($,(1,0,0));+#396=VECTOR($,#395,1);+#397=LINE($,#394,#396);+#398=EDGE_CURVE($,#391,#393,#397,.T.);+#399=ORIENTED_EDGE($,$,$,#398,.T.);+#400=CARTESIAN_POINT($,(-8.255,51.73726,69.85));+#401=VERTEX_POINT($,#400);+#402=CARTESIAN_POINT($,(-8.255,51.73726,8.25746000000001));+#403=DIRECTION($,(0,0,1));+#404=VECTOR($,#403,1);+#405=LINE($,#402,#404);+#406=EDGE_CURVE($,#393,#401,#405,.T.);+#407=ORIENTED_EDGE($,$,$,#406,.T.);+#408=CARTESIAN_POINT($,(-233.045,51.73726,69.85));+#409=VERTEX_POINT($,#408);+#410=CARTESIAN_POINT($,(-8.255,51.73726,69.85));+#411=DIRECTION($,(-1,0,0));+#412=VECTOR($,#411,1);+#413=LINE($,#410,#412);+#414=EDGE_CURVE($,#401,#409,#413,.T.);+#415=ORIENTED_EDGE($,$,$,#414,.T.);+#416=CARTESIAN_POINT($,(-233.045,51.73726,69.85));+#417=DIRECTION($,(0,-0,-1));+#418=VECTOR($,#417,1);+#419=LINE($,#416,#418);+#420=EDGE_CURVE($,#409,#391,#419,.T.);+#421=ORIENTED_EDGE($,$,$,#420,.T.);+#422=EDGE_LOOP($,(#399,#407,#415,#421));+#423=FACE_OUTER_BOUND('',#422,.T.);+#424=ADVANCED_FACE('',(#423),#389,.F.);+#425=CARTESIAN_POINT($,(-233.045,58.08726,69.85));+#426=DIRECTION($,(1,0,0));+#427=DIRECTION($,(0,0,1));+#428=AXIS2_PLACEMENT_3D($,#425,#426,#427);+#429=CYLINDRICAL_SURFACE($,#428,8.255);+#430=ORIENTED_EDGE($,$,$,#22,.T.);+#431=CARTESIAN_POINT($,(-8.255,58.08726,69.85));+#432=DIRECTION($,(1,0,0));+#433=DIRECTION($,(0,0,1));+#434=AXIS2_PLACEMENT_3D($,#431,#432,#433);+#435=CIRCLE($,#434,8.255);+#436=TRIMMED_CURVE($,#435,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#437=EDGE_CURVE($,#17,#353,#436,.T.);+#438=ORIENTED_EDGE($,$,$,#437,.T.);+#439=ORIENTED_EDGE($,$,$,#358,.F.);+#440=CARTESIAN_POINT($,(-233.045,58.08726,69.85));+#441=DIRECTION($,(-1,-0,-0));+#442=DIRECTION($,(0,-1,0));+#443=AXIS2_PLACEMENT_3D($,#440,#441,#442);+#444=CIRCLE($,#443,8.255);+#445=TRIMMED_CURVE($,#444,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#446=EDGE_CURVE($,#351,#9,#445,.T.);+#447=ORIENTED_EDGE($,$,$,#446,.T.);+#448=EDGE_LOOP($,(#430,#438,#439,#447));+#449=FACE_OUTER_BOUND('',#448,.T.);+#450=ADVANCED_FACE('',(#449),#429,.T.);+#451=CARTESIAN_POINT($,(-233.045,58.08726,69.85));+#452=DIRECTION($,(1,0,0));+#453=DIRECTION($,(0,0,1));+#454=AXIS2_PLACEMENT_3D($,#451,#452,#453);+#455=CYLINDRICAL_SURFACE($,#454,6.34999999999999);+#456=ORIENTED_EDGE($,$,$,#414,.F.);+#457=CARTESIAN_POINT($,(-8.255,58.08726,69.85));+#458=DIRECTION($,(-1,-0,-0));+#459=DIRECTION($,(0,-1,0));+#460=AXIS2_PLACEMENT_3D($,#457,#458,#459);+#461=CIRCLE($,#460,6.35);+#462=TRIMMED_CURVE($,#461,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#463=EDGE_CURVE($,#401,#245,#462,.T.);+#464=ORIENTED_EDGE($,$,$,#463,.T.);+#465=ORIENTED_EDGE($,$,$,#258,.T.);+#466=CARTESIAN_POINT($,(-233.045,58.08726,69.85));+#467=DIRECTION($,(1,0,0));+#468=DIRECTION($,(0,0,1));+#469=AXIS2_PLACEMENT_3D($,#466,#467,#468);+#470=CIRCLE($,#469,6.34999999999999);+#471=TRIMMED_CURVE($,#470,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#472=EDGE_CURVE($,#253,#409,#471,.T.);+#473=ORIENTED_EDGE($,$,$,#472,.T.);+#474=EDGE_LOOP($,(#456,#464,#465,#473));+#475=FACE_OUTER_BOUND('',#474,.T.);+#476=ADVANCED_FACE('',(#475),#455,.F.);+#477=CARTESIAN_POINT($,(-8.255,434.64226,69.85));+#478=DIRECTION($,(0,1,0));+#479=DIRECTION($,(-1,0,0));+#480=AXIS2_PLACEMENT_3D($,#477,#478,#479);+#481=PLANE($,#480);+#482=CARTESIAN_POINT($,(-8.255,434.64226,69.85));+#483=VERTEX_POINT($,#482);+#484=CARTESIAN_POINT($,(-233.045,434.64226,69.85));+#485=VERTEX_POINT($,#484);+#486=CARTESIAN_POINT($,(-8.255,434.64226,69.85));+#487=DIRECTION($,(-1,0,0));+#488=VECTOR($,#487,1);+#489=LINE($,#486,#488);+#490=EDGE_CURVE($,#483,#485,#489,.T.);+#491=ORIENTED_EDGE($,$,$,#490,.T.);+#492=CARTESIAN_POINT($,(-233.045,434.64226,8.25746000000001));+#493=VERTEX_POINT($,#492);+#494=CARTESIAN_POINT($,(-233.045,434.64226,69.85));+#495=DIRECTION($,(0,0,-1));+#496=VECTOR($,#495,1);+#497=LINE($,#494,#496);+#498=EDGE_CURVE($,#485,#493,#497,.T.);+#499=ORIENTED_EDGE($,$,$,#498,.T.);+#500=CARTESIAN_POINT($,(-8.255,434.64226,8.25746000000001));+#501=VERTEX_POINT($,#500);+#502=CARTESIAN_POINT($,(-233.045,434.64226,8.25746000000001));+#503=DIRECTION($,(1,0,0));+#504=VECTOR($,#503,1);+#505=LINE($,#502,#504);+#506=EDGE_CURVE($,#493,#501,#505,.T.);+#507=ORIENTED_EDGE($,$,$,#506,.T.);+#508=CARTESIAN_POINT($,(-8.255,434.64226,8.25746000000001));+#509=DIRECTION($,(0,0,1));+#510=VECTOR($,#509,1);+#511=LINE($,#508,#510);+#512=EDGE_CURVE($,#501,#483,#511,.T.);+#513=ORIENTED_EDGE($,$,$,#512,.T.);+#514=EDGE_LOOP($,(#491,#499,#507,#513));+#515=FACE_OUTER_BOUND('',#514,.T.);+#516=ADVANCED_FACE('',(#515),#481,.T.);+#517=CARTESIAN_POINT($,(-8.255,432.73726,69.85));+#518=DIRECTION($,(-0,-1,-0));+#519=DIRECTION($,(-1,0,0));+#520=AXIS2_PLACEMENT_3D($,#517,#518,#519);+#521=PLANE($,#520);+#522=CARTESIAN_POINT($,(-8.255,432.73726,8.25746000000001));+#523=VERTEX_POINT($,#522);+#524=CARTESIAN_POINT($,(-233.045,432.73726,8.25746000000001));+#525=VERTEX_POINT($,#524);+#526=CARTESIAN_POINT($,(-8.255,432.73726,8.25746000000001));+#527=DIRECTION($,(-1,0,0));+#528=VECTOR($,#527,1);+#529=LINE($,#526,#528);+#530=EDGE_CURVE($,#523,#525,#529,.T.);+#531=ORIENTED_EDGE($,$,$,#530,.T.);+#532=CARTESIAN_POINT($,(-233.045,432.73726,69.85));+#533=VERTEX_POINT($,#532);+#534=CARTESIAN_POINT($,(-233.045,432.73726,8.25746000000001));+#535=DIRECTION($,(0,0,1));+#536=VECTOR($,#535,1);+#537=LINE($,#534,#536);+#538=EDGE_CURVE($,#525,#533,#537,.T.);+#539=ORIENTED_EDGE($,$,$,#538,.T.);+#540=CARTESIAN_POINT($,(-8.255,432.73726,69.85));+#541=VERTEX_POINT($,#540);+#542=CARTESIAN_POINT($,(-233.045,432.73726,69.85));+#543=DIRECTION($,(1,0,0));+#544=VECTOR($,#543,1);+#545=LINE($,#542,#544);+#546=EDGE_CURVE($,#533,#541,#545,.T.);+#547=ORIENTED_EDGE($,$,$,#546,.T.);+#548=CARTESIAN_POINT($,(-8.255,432.73726,69.85));+#549=DIRECTION($,(0,0,-1));+#550=VECTOR($,#549,1);+#551=LINE($,#548,#550);+#552=EDGE_CURVE($,#541,#523,#551,.T.);+#553=ORIENTED_EDGE($,$,$,#552,.T.);+#554=EDGE_LOOP($,(#531,#539,#547,#553));+#555=FACE_OUTER_BOUND('',#554,.T.);+#556=ADVANCED_FACE('',(#555),#521,.F.);+#557=CARTESIAN_POINT($,(-8.255,426.38726,69.85));+#558=DIRECTION($,(-1,0,0));+#559=DIRECTION($,(0,0,1));+#560=AXIS2_PLACEMENT_3D($,#557,#558,#559);+#561=CYLINDRICAL_SURFACE($,#560,8.255);+#562=ORIENTED_EDGE($,$,$,#70,.T.);+#563=CARTESIAN_POINT($,(-233.045,426.38726,69.85));+#564=DIRECTION($,(-1,0,0));+#565=DIRECTION($,(0,0,1));+#566=AXIS2_PLACEMENT_3D($,#563,#564,#565);+#567=CIRCLE($,#566,8.255);+#568=TRIMMED_CURVE($,#567,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#569=EDGE_CURVE($,#65,#485,#568,.T.);+#570=ORIENTED_EDGE($,$,$,#569,.T.);+#571=ORIENTED_EDGE($,$,$,#490,.F.);+#572=CARTESIAN_POINT($,(-8.255,426.38726,69.85));+#573=DIRECTION($,(1,-0,-0));+#574=DIRECTION($,(0,1,0));+#575=AXIS2_PLACEMENT_3D($,#572,#573,#574);+#576=CIRCLE($,#575,8.255);+#577=TRIMMED_CURVE($,#576,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#578=EDGE_CURVE($,#483,#57,#577,.T.);+#579=ORIENTED_EDGE($,$,$,#578,.T.);+#580=EDGE_LOOP($,(#562,#570,#571,#579));+#581=FACE_OUTER_BOUND('',#580,.T.);+#582=ADVANCED_FACE('',(#581),#561,.T.);+#583=CARTESIAN_POINT($,(-8.255,426.38726,69.85));+#584=DIRECTION($,(-1,0,0));+#585=DIRECTION($,(0,0,1));+#586=AXIS2_PLACEMENT_3D($,#583,#584,#585);+#587=CYLINDRICAL_SURFACE($,#586,6.34999999999999);+#588=ORIENTED_EDGE($,$,$,#546,.F.);+#589=CARTESIAN_POINT($,(-233.045,426.38726,69.85));+#590=DIRECTION($,(1,-0,-0));+#591=DIRECTION($,(0,1,0));+#592=AXIS2_PLACEMENT_3D($,#589,#590,#591);+#593=CIRCLE($,#592,6.35000000000002);+#594=TRIMMED_CURVE($,#593,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#595=EDGE_CURVE($,#533,#197,#594,.T.);+#596=ORIENTED_EDGE($,$,$,#595,.T.);+#597=ORIENTED_EDGE($,$,$,#210,.T.);+#598=CARTESIAN_POINT($,(-8.255,426.38726,69.85));+#599=DIRECTION($,(-1,0,0));+#600=DIRECTION($,(0,0,1));+#601=AXIS2_PLACEMENT_3D($,#598,#599,#600);+#602=CIRCLE($,#601,6.34999999999999);+#603=TRIMMED_CURVE($,#602,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#604=EDGE_CURVE($,#205,#541,#603,.T.);+#605=ORIENTED_EDGE($,$,$,#604,.T.);+#606=EDGE_LOOP($,(#588,#596,#597,#605));+#607=FACE_OUTER_BOUND('',#606,.T.);+#608=ADVANCED_FACE('',(#607),#587,.F.);+#609=CARTESIAN_POINT($,(-247.65,418.13226,84.455));+#610=DIRECTION($,(1,0,0));+#611=DIRECTION($,(0,-1,0));+#612=AXIS2_PLACEMENT_3D($,#609,#610,#611);+#613=PLANE($,#612);+#614=CARTESIAN_POINT($,(-247.65,418.13226,84.455));+#615=VERTEX_POINT($,#614);+#616=CARTESIAN_POINT($,(-247.65,66.34226,84.455));+#617=VERTEX_POINT($,#616);+#618=CARTESIAN_POINT($,(-247.65,418.13226,84.455));+#619=DIRECTION($,(0,-1,0));+#620=VECTOR($,#619,1);+#621=LINE($,#618,#620);+#622=EDGE_CURVE($,#615,#617,#621,.T.);+#623=ORIENTED_EDGE($,$,$,#622,.T.);+#624=CARTESIAN_POINT($,(-247.65,66.34226,128.905));+#625=VERTEX_POINT($,#624);+#626=CARTESIAN_POINT($,(-247.65,66.34226,84.455));+#627=DIRECTION($,(0,0,1));+#628=VECTOR($,#627,1);+#629=LINE($,#626,#628);+#630=EDGE_CURVE($,#617,#625,#629,.T.);+#631=ORIENTED_EDGE($,$,$,#630,.T.);+#632=CARTESIAN_POINT($,(-247.65,418.13226,128.905));+#633=VERTEX_POINT($,#632);+#634=CARTESIAN_POINT($,(-247.65,66.34226,128.905));+#635=DIRECTION($,(0,1,0));+#636=VECTOR($,#635,1);+#637=LINE($,#634,#636);+#638=EDGE_CURVE($,#625,#633,#637,.T.);+#639=ORIENTED_EDGE($,$,$,#638,.T.);+#640=CARTESIAN_POINT($,(-247.65,418.13226,128.905));+#641=DIRECTION($,(0,0,-1));+#642=VECTOR($,#641,1);+#643=LINE($,#640,#642);+#644=EDGE_CURVE($,#633,#615,#643,.T.);+#645=ORIENTED_EDGE($,$,$,#644,.T.);+#646=EDGE_LOOP($,(#623,#631,#639,#645));+#647=FACE_OUTER_BOUND('',#646,.T.);+#648=ADVANCED_FACE('',(#647),#613,.T.);+#649=CARTESIAN_POINT($,(-249.555,418.13226,84.455));+#650=DIRECTION($,(-1,-0,-0));+#651=DIRECTION($,(0,-1,0));+#652=AXIS2_PLACEMENT_3D($,#649,#650,#651);+#653=PLANE($,#652);+#654=CARTESIAN_POINT($,(-249.555,418.13226,128.905));+#655=VERTEX_POINT($,#654);+#656=CARTESIAN_POINT($,(-249.555,66.34226,128.905));+#657=VERTEX_POINT($,#656);+#658=CARTESIAN_POINT($,(-249.555,418.13226,128.905));+#659=DIRECTION($,(0,-1,0));+#660=VECTOR($,#659,1);+#661=LINE($,#658,#660);+#662=EDGE_CURVE($,#655,#657,#661,.T.);+#663=ORIENTED_EDGE($,$,$,#662,.T.);+#664=CARTESIAN_POINT($,(-249.555,66.34226,84.455));+#665=VERTEX_POINT($,#664);+#666=CARTESIAN_POINT($,(-249.555,66.34226,128.905));+#667=DIRECTION($,(0,0,-1));+#668=VECTOR($,#667,1);+#669=LINE($,#666,#668);+#670=EDGE_CURVE($,#657,#665,#669,.T.);+#671=ORIENTED_EDGE($,$,$,#670,.T.);+#672=CARTESIAN_POINT($,(-249.555,418.13226,84.455));+#673=VERTEX_POINT($,#672);+#674=CARTESIAN_POINT($,(-249.555,66.34226,84.455));+#675=DIRECTION($,(0,1,0));+#676=VECTOR($,#675,1);+#677=LINE($,#674,#676);+#678=EDGE_CURVE($,#665,#673,#677,.T.);+#679=ORIENTED_EDGE($,$,$,#678,.T.);+#680=CARTESIAN_POINT($,(-249.555,418.13226,84.455));+#681=DIRECTION($,(0,0,1));+#682=VECTOR($,#681,1);+#683=LINE($,#680,#682);+#684=EDGE_CURVE($,#673,#655,#683,.T.);+#685=ORIENTED_EDGE($,$,$,#684,.T.);+#686=EDGE_LOOP($,(#663,#671,#679,#685));+#687=FACE_OUTER_BOUND('',#686,.T.);+#688=ADVANCED_FACE('',(#687),#653,.F.);+#689=CARTESIAN_POINT($,(-241.3,418.13226,84.455));+#690=DIRECTION($,(0,-1,0));+#691=DIRECTION($,(0,0,-1));+#692=AXIS2_PLACEMENT_3D($,#689,#690,#691);+#693=CYLINDRICAL_SURFACE($,#692,6.34999999999999);+#694=ORIENTED_EDGE($,$,$,#94,.T.);+#695=CARTESIAN_POINT($,(-241.3,66.34226,84.455));+#696=DIRECTION($,(-0,1,-0));+#697=DIRECTION($,(0,0,-1));+#698=AXIS2_PLACEMENT_3D($,#695,#696,#697);+#699=CIRCLE($,#698,6.34999999999999);+#700=TRIMMED_CURVE($,#699,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#701=EDGE_CURVE($,#89,#617,#700,.T.);+#702=ORIENTED_EDGE($,$,$,#701,.T.);+#703=ORIENTED_EDGE($,$,$,#622,.F.);+#704=CARTESIAN_POINT($,(-241.3,418.13226,84.455));+#705=DIRECTION($,(0,-1,0));+#706=DIRECTION($,(-1,0,0));+#707=AXIS2_PLACEMENT_3D($,#704,#705,#706);+#708=CIRCLE($,#707,6.35000000000002);+#709=TRIMMED_CURVE($,#708,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#710=EDGE_CURVE($,#615,#81,#709,.T.);+#711=ORIENTED_EDGE($,$,$,#710,.T.);+#712=EDGE_LOOP($,(#694,#702,#703,#711));+#713=FACE_OUTER_BOUND('',#712,.T.);+#714=ADVANCED_FACE('',(#713),#693,.T.);+#715=CARTESIAN_POINT($,(-241.3,418.13226,84.455));+#716=DIRECTION($,(0,-1,0));+#717=DIRECTION($,(0,0,-1));+#718=AXIS2_PLACEMENT_3D($,#715,#716,#717);+#719=CYLINDRICAL_SURFACE($,#718,8.255);+#720=ORIENTED_EDGE($,$,$,#678,.F.);+#721=CARTESIAN_POINT($,(-241.3,66.34226,84.455));+#722=DIRECTION($,(0,-1,0));+#723=DIRECTION($,(-1,0,0));+#724=AXIS2_PLACEMENT_3D($,#721,#722,#723);+#725=CIRCLE($,#724,8.255);+#726=TRIMMED_CURVE($,#725,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#727=EDGE_CURVE($,#665,#179,#726,.T.);+#728=ORIENTED_EDGE($,$,$,#727,.T.);+#729=ORIENTED_EDGE($,$,$,#186,.T.);+#730=CARTESIAN_POINT($,(-241.3,418.13226,84.455));+#731=DIRECTION($,(-0,1,-0));+#732=DIRECTION($,(0,0,-1));+#733=AXIS2_PLACEMENT_3D($,#730,#731,#732);+#734=CIRCLE($,#733,8.255);+#735=TRIMMED_CURVE($,#734,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#736=EDGE_CURVE($,#181,#673,#735,.T.);+#737=ORIENTED_EDGE($,$,$,#736,.T.);+#738=EDGE_LOOP($,(#720,#728,#729,#737));+#739=FACE_OUTER_BOUND('',#738,.T.);+#740=ADVANCED_FACE('',(#739),#719,.F.);+#741=CARTESIAN_POINT($,(6.35,66.34226,84.455));+#742=DIRECTION($,(-1,0,0));+#743=DIRECTION($,(0,1,0));+#744=AXIS2_PLACEMENT_3D($,#741,#742,#743);+#745=PLANE($,#744);+#746=CARTESIAN_POINT($,(6.35,66.34226,84.455));+#747=VERTEX_POINT($,#746);+#748=CARTESIAN_POINT($,(6.35,418.13226,84.455));+#749=VERTEX_POINT($,#748);+#750=CARTESIAN_POINT($,(6.35,66.34226,84.455));+#751=DIRECTION($,(0,1,0));+#752=VECTOR($,#751,1);+#753=LINE($,#750,#752);+#754=EDGE_CURVE($,#747,#749,#753,.T.);+#755=ORIENTED_EDGE($,$,$,#754,.T.);+#756=CARTESIAN_POINT($,(6.35,418.13226,113.56594));+#757=VERTEX_POINT($,#756);+#758=CARTESIAN_POINT($,(6.35,418.13226,84.455));+#759=DIRECTION($,(0,0,1));+#760=VECTOR($,#759,1);+#761=LINE($,#758,#760);+#762=EDGE_CURVE($,#749,#757,#761,.T.);+#763=ORIENTED_EDGE($,$,$,#762,.T.);+#764=CARTESIAN_POINT($,(6.35,66.34226,113.56594));+#765=VERTEX_POINT($,#764);+#766=CARTESIAN_POINT($,(6.35,418.13226,113.56594));+#767=DIRECTION($,(0,-1,0));+#768=VECTOR($,#767,1);+#769=LINE($,#766,#768);+#770=EDGE_CURVE($,#757,#765,#769,.T.);+#771=ORIENTED_EDGE($,$,$,#770,.T.);+#772=CARTESIAN_POINT($,(6.35,66.34226,113.56594));+#773=DIRECTION($,(-0,0,-1));+#774=VECTOR($,#773,1);+#775=LINE($,#772,#774);+#776=EDGE_CURVE($,#765,#747,#775,.T.);+#777=ORIENTED_EDGE($,$,$,#776,.T.);+#778=EDGE_LOOP($,(#755,#763,#771,#777));+#779=FACE_OUTER_BOUND('',#778,.T.);+#780=ADVANCED_FACE('',(#779),#745,.T.);+#781=CARTESIAN_POINT($,(8.255,66.34226,84.455));+#782=DIRECTION($,(1,-0,-0));+#783=DIRECTION($,(0,1,0));+#784=AXIS2_PLACEMENT_3D($,#781,#782,#783);+#785=PLANE($,#784);+#786=CARTESIAN_POINT($,(8.255,66.34226,113.56594));+#787=VERTEX_POINT($,#786);+#788=CARTESIAN_POINT($,(8.255,418.13226,113.56594));+#789=VERTEX_POINT($,#788);+#790=CARTESIAN_POINT($,(8.255,66.34226,113.56594));+#791=DIRECTION($,(0,1,0));+#792=VECTOR($,#791,1);+#793=LINE($,#790,#792);+#794=EDGE_CURVE($,#787,#789,#793,.T.);+#795=ORIENTED_EDGE($,$,$,#794,.T.);+#796=CARTESIAN_POINT($,(8.255,418.13226,84.455));+#797=VERTEX_POINT($,#796);+#798=CARTESIAN_POINT($,(8.255,418.13226,113.56594));+#799=DIRECTION($,(-0,0,-1));+#800=VECTOR($,#799,1);+#801=LINE($,#798,#800);+#802=EDGE_CURVE($,#789,#797,#801,.T.);+#803=ORIENTED_EDGE($,$,$,#802,.T.);+#804=CARTESIAN_POINT($,(8.255,66.34226,84.455));+#805=VERTEX_POINT($,#804);+#806=CARTESIAN_POINT($,(8.255,418.13226,84.455));+#807=DIRECTION($,(0,-1,0));+#808=VECTOR($,#807,1);+#809=LINE($,#806,#808);+#810=EDGE_CURVE($,#797,#805,#809,.T.);+#811=ORIENTED_EDGE($,$,$,#810,.T.);+#812=CARTESIAN_POINT($,(8.255,66.34226,84.455));+#813=DIRECTION($,(0,0,1));+#814=VECTOR($,#813,1);+#815=LINE($,#812,#814);+#816=EDGE_CURVE($,#805,#787,#815,.T.);+#817=ORIENTED_EDGE($,$,$,#816,.T.);+#818=EDGE_LOOP($,(#795,#803,#811,#817));+#819=FACE_OUTER_BOUND('',#818,.T.);+#820=ADVANCED_FACE('',(#819),#785,.F.);+#821=CARTESIAN_POINT($,(0,66.34226,84.455));+#822=DIRECTION($,(0,1,0));+#823=DIRECTION($,(0,0,-1));+#824=AXIS2_PLACEMENT_3D($,#821,#822,#823);+#825=CYLINDRICAL_SURFACE($,#824,6.34999999999999);+#826=ORIENTED_EDGE($,$,$,#46,.T.);+#827=CARTESIAN_POINT($,(0,418.13226,84.455));+#828=DIRECTION($,(-0,-1,-0));+#829=DIRECTION($,(0,0,-1));+#830=AXIS2_PLACEMENT_3D($,#827,#828,#829);+#831=CIRCLE($,#830,6.34999999999999);+#832=TRIMMED_CURVE($,#831,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#833=EDGE_CURVE($,#41,#749,#832,.T.);+#834=ORIENTED_EDGE($,$,$,#833,.T.);+#835=ORIENTED_EDGE($,$,$,#754,.F.);+#836=CARTESIAN_POINT($,(0,66.34226,84.455));+#837=DIRECTION($,(0,1,0));+#838=DIRECTION($,(1,0,0));+#839=AXIS2_PLACEMENT_3D($,#836,#837,#838);+#840=CIRCLE($,#839,6.35);+#841=TRIMMED_CURVE($,#840,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#842=EDGE_CURVE($,#747,#33,#841,.T.);+#843=ORIENTED_EDGE($,$,$,#842,.T.);+#844=EDGE_LOOP($,(#826,#834,#835,#843));+#845=FACE_OUTER_BOUND('',#844,.T.);+#846=ADVANCED_FACE('',(#845),#825,.T.);+#847=CARTESIAN_POINT($,(0,66.34226,84.455));+#848=DIRECTION($,(0,1,0));+#849=DIRECTION($,(0,0,-1));+#850=AXIS2_PLACEMENT_3D($,#847,#848,#849);+#851=CYLINDRICAL_SURFACE($,#850,8.255);+#852=ORIENTED_EDGE($,$,$,#810,.F.);+#853=CARTESIAN_POINT($,(0,418.13226,84.455));+#854=DIRECTION($,(0,1,0));+#855=DIRECTION($,(1,0,0));+#856=AXIS2_PLACEMENT_3D($,#853,#854,#855);+#857=CIRCLE($,#856,8.255);+#858=TRIMMED_CURVE($,#857,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#859=EDGE_CURVE($,#797,#221,#858,.T.);+#860=ORIENTED_EDGE($,$,$,#859,.T.);+#861=ORIENTED_EDGE($,$,$,#234,.T.);+#862=CARTESIAN_POINT($,(0,66.34226,84.455));+#863=DIRECTION($,(-0,-1,-0));+#864=DIRECTION($,(0,0,-1));+#865=AXIS2_PLACEMENT_3D($,#862,#863,#864);+#866=CIRCLE($,#865,8.255);+#867=TRIMMED_CURVE($,#866,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#868=EDGE_CURVE($,#229,#805,#867,.T.);+#869=ORIENTED_EDGE($,$,$,#868,.T.);+#870=EDGE_LOOP($,(#852,#860,#861,#869));+#871=FACE_OUTER_BOUND('',#870,.T.);+#872=ADVANCED_FACE('',(#871),#851,.F.);+#873=CARTESIAN_POINT($,(-233.045,43.48226,1.90746000000001));+#874=DIRECTION($,(0,0,1));+#875=DIRECTION($,(1,0,0));+#876=AXIS2_PLACEMENT_3D($,#873,#874,#875);+#877=PLANE($,#876);+#878=CARTESIAN_POINT($,(-233.045,43.48226,1.90746000000001));+#879=VERTEX_POINT($,#878);+#880=CARTESIAN_POINT($,(-8.255,43.48226,1.90746000000001));+#881=VERTEX_POINT($,#880);+#882=CARTESIAN_POINT($,(-233.045,43.48226,1.90746000000001));+#883=DIRECTION($,(1,0,0));+#884=VECTOR($,#883,1);+#885=LINE($,#882,#884);+#886=EDGE_CURVE($,#879,#881,#885,.T.);+#887=ORIENTED_EDGE($,$,$,#886,.T.);+#888=CARTESIAN_POINT($,(-8.255,12.70254,1.90746000000001));+#889=VERTEX_POINT($,#888);+#890=CARTESIAN_POINT($,(-8.255,43.48226,1.90746000000001));+#891=DIRECTION($,(0,-1,0));+#892=VECTOR($,#891,1);+#893=LINE($,#890,#892);+#894=EDGE_CURVE($,#881,#889,#893,.T.);+#895=ORIENTED_EDGE($,$,$,#894,.T.);+#896=CARTESIAN_POINT($,(-233.045,12.70254,1.90746000000001));+#897=VERTEX_POINT($,#896);+#898=CARTESIAN_POINT($,(-8.255,12.70254,1.90746000000001));+#899=DIRECTION($,(-1,0,0));+#900=VECTOR($,#899,1);+#901=LINE($,#898,#900);+#902=EDGE_CURVE($,#889,#897,#901,.T.);+#903=ORIENTED_EDGE($,$,$,#902,.T.);+#904=CARTESIAN_POINT($,(-233.045,12.70254,1.90746000000001));+#905=DIRECTION($,(0,1,0));+#906=VECTOR($,#905,1);+#907=LINE($,#904,#906);+#908=EDGE_CURVE($,#897,#879,#907,.T.);+#909=ORIENTED_EDGE($,$,$,#908,.T.);+#910=EDGE_LOOP($,(#887,#895,#903,#909));+#911=FACE_OUTER_BOUND('',#910,.T.);+#912=ADVANCED_FACE('',(#911),#877,.T.);+#913=CARTESIAN_POINT($,(-233.045,43.48226,0.00246000000001));+#914=DIRECTION($,(-0,-0,-1));+#915=DIRECTION($,(1,0,0));+#916=AXIS2_PLACEMENT_3D($,#913,#914,#915);+#917=PLANE($,#916);+#918=CARTESIAN_POINT($,(-233.045,12.70254,0.00246000000001));+#919=VERTEX_POINT($,#918);+#920=CARTESIAN_POINT($,(-8.255,12.70254,0.00246000000001));+#921=VERTEX_POINT($,#920);+#922=CARTESIAN_POINT($,(-233.045,12.70254,0.00246000000001));+#923=DIRECTION($,(1,0,0));+#924=VECTOR($,#923,1);+#925=LINE($,#922,#924);+#926=EDGE_CURVE($,#919,#921,#925,.T.);+#927=ORIENTED_EDGE($,$,$,#926,.T.);+#928=CARTESIAN_POINT($,(-8.255,43.48226,0.00246000000001));+#929=VERTEX_POINT($,#928);+#930=CARTESIAN_POINT($,(-8.255,12.70254,0.00246000000001));+#931=DIRECTION($,(0,1,0));+#932=VECTOR($,#931,1);+#933=LINE($,#930,#932);+#934=EDGE_CURVE($,#921,#929,#933,.T.);+#935=ORIENTED_EDGE($,$,$,#934,.T.);+#936=CARTESIAN_POINT($,(-233.045,43.48226,0.00246000000001));+#937=VERTEX_POINT($,#936);+#938=CARTESIAN_POINT($,(-8.255,43.48226,0.00246000000001));+#939=DIRECTION($,(-1,0,0));+#940=VECTOR($,#939,1);+#941=LINE($,#938,#940);+#942=EDGE_CURVE($,#929,#937,#941,.T.);+#943=ORIENTED_EDGE($,$,$,#942,.T.);+#944=CARTESIAN_POINT($,(-233.045,43.48226,0.00246000000001));+#945=DIRECTION($,(0,-1,0));+#946=VECTOR($,#945,1);+#947=LINE($,#944,#946);+#948=EDGE_CURVE($,#937,#919,#947,.T.);+#949=ORIENTED_EDGE($,$,$,#948,.T.);+#950=EDGE_LOOP($,(#927,#935,#943,#949));+#951=FACE_OUTER_BOUND('',#950,.T.);+#952=ADVANCED_FACE('',(#951),#917,.F.);+#953=CARTESIAN_POINT($,(-233.045,43.48226,8.25746000000001));+#954=DIRECTION($,(1,0,0));+#955=DIRECTION($,(0,1,0));+#956=AXIS2_PLACEMENT_3D($,#953,#954,#955);+#957=CYLINDRICAL_SURFACE($,#956,6.35);+#958=ORIENTED_EDGE($,$,$,#374,.F.);+#959=CARTESIAN_POINT($,(-8.255,43.48226,8.25746000000001));+#960=DIRECTION($,(-1,-0,-0));+#961=DIRECTION($,(0,1,0));+#962=AXIS2_PLACEMENT_3D($,#959,#960,#961);+#963=CIRCLE($,#962,6.35);+#964=TRIMMED_CURVE($,#963,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#965=EDGE_CURVE($,#361,#881,#964,.T.);+#966=ORIENTED_EDGE($,$,$,#965,.T.);+#967=ORIENTED_EDGE($,$,$,#886,.F.);+#968=CARTESIAN_POINT($,(-233.045,43.48226,8.25746000000001));+#969=DIRECTION($,(1,0,0));+#970=DIRECTION($,(0,0.000000000000001,-1));+#971=AXIS2_PLACEMENT_3D($,#968,#969,#970);+#972=CIRCLE($,#971,6.35);+#973=TRIMMED_CURVE($,#972,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#974=EDGE_CURVE($,#879,#369,#973,.T.);+#975=ORIENTED_EDGE($,$,$,#974,.T.);+#976=EDGE_LOOP($,(#958,#966,#967,#975));+#977=FACE_OUTER_BOUND('',#976,.T.);+#978=ADVANCED_FACE('',(#977),#957,.T.);+#979=CARTESIAN_POINT($,(-233.045,43.48226,8.25746000000001));+#980=DIRECTION($,(1,0,0));+#981=DIRECTION($,(0,1,0));+#982=AXIS2_PLACEMENT_3D($,#979,#980,#981);+#983=CYLINDRICAL_SURFACE($,#982,8.255);+#984=ORIENTED_EDGE($,$,$,#942,.F.);+#985=CARTESIAN_POINT($,(-8.255,43.48226,8.25746000000001));+#986=DIRECTION($,(1,0,0));+#987=DIRECTION($,(0,0.000000000000001,-1));+#988=AXIS2_PLACEMENT_3D($,#985,#986,#987);+#989=CIRCLE($,#988,8.255);+#990=TRIMMED_CURVE($,#989,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#991=EDGE_CURVE($,#929,#393,#990,.T.);+#992=ORIENTED_EDGE($,$,$,#991,.T.);+#993=ORIENTED_EDGE($,$,$,#398,.F.);+#994=CARTESIAN_POINT($,(-233.045,43.48226,8.25746000000001));+#995=DIRECTION($,(-1,-0,-0));+#996=DIRECTION($,(0,1,0));+#997=AXIS2_PLACEMENT_3D($,#994,#995,#996);+#998=CIRCLE($,#997,8.255);+#999=TRIMMED_CURVE($,#998,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#1000=EDGE_CURVE($,#391,#937,#999,.T.);+#1001=ORIENTED_EDGE($,$,$,#1000,.T.);+#1002=EDGE_LOOP($,(#984,#992,#993,#1001));+#1003=FACE_OUTER_BOUND('',#1002,.T.);+#1004=ADVANCED_FACE('',(#1003),#983,.F.);+#1005=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));+#1006=DIRECTION($,(0,0,1));+#1007=DIRECTION($,(-1,0,0));+#1008=AXIS2_PLACEMENT_3D($,#1005,#1006,#1007);+#1009=PLANE($,#1008);+#1010=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));+#1011=VERTEX_POINT($,#1010);+#1012=CARTESIAN_POINT($,(-233.045,440.99226,1.90746000000001));+#1013=VERTEX_POINT($,#1012);+#1014=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));+#1015=DIRECTION($,(-1,0,0));+#1016=VECTOR($,#1015,1);+#1017=LINE($,#1014,#1016);+#1018=EDGE_CURVE($,#1011,#1013,#1017,.T.);+#1019=ORIENTED_EDGE($,$,$,#1018,.T.);+#1020=CARTESIAN_POINT($,(-233.045,485.44226,1.90746000000001));+#1021=VERTEX_POINT($,#1020);+#1022=CARTESIAN_POINT($,(-233.045,440.99226,1.90746000000001));+#1023=DIRECTION($,(0,1,0));+#1024=VECTOR($,#1023,1);+#1025=LINE($,#1022,#1024);+#1026=EDGE_CURVE($,#1013,#1021,#1025,.T.);+#1027=ORIENTED_EDGE($,$,$,#1026,.T.);+#1028=CARTESIAN_POINT($,(-8.255,485.44226,1.90746000000001));+#1029=VERTEX_POINT($,#1028);+#1030=CARTESIAN_POINT($,(-233.045,485.44226,1.90746000000001));+#1031=DIRECTION($,(1,0,0));+#1032=VECTOR($,#1031,1);+#1033=LINE($,#1030,#1032);+#1034=EDGE_CURVE($,#1021,#1029,#1033,.T.);+#1035=ORIENTED_EDGE($,$,$,#1034,.T.);+#1036=CARTESIAN_POINT($,(-8.255,485.44226,1.90746000000001));+#1037=DIRECTION($,(0,-1,0));+#1038=VECTOR($,#1037,1);+#1039=LINE($,#1036,#1038);+#1040=EDGE_CURVE($,#1029,#1011,#1039,.T.);+#1041=ORIENTED_EDGE($,$,$,#1040,.T.);+#1042=EDGE_LOOP($,(#1019,#1027,#1035,#1041));+#1043=FACE_OUTER_BOUND('',#1042,.T.);+#1044=ADVANCED_FACE('',(#1043),#1009,.T.);+#1045=CARTESIAN_POINT($,(-8.255,440.99226,0.00246000000001));+#1046=DIRECTION($,(-0,-0,-1));+#1047=DIRECTION($,(-1,0,0));+#1048=AXIS2_PLACEMENT_3D($,#1045,#1046,#1047);+#1049=PLANE($,#1048);+#1050=CARTESIAN_POINT($,(-8.255,485.44226,0.00246000000001));+#1051=VERTEX_POINT($,#1050);+#1052=CARTESIAN_POINT($,(-233.045,485.44226,0.00246000000001));+#1053=VERTEX_POINT($,#1052);+#1054=CARTESIAN_POINT($,(-8.255,485.44226,0.00246000000001));+#1055=DIRECTION($,(-1,0,0));+#1056=VECTOR($,#1055,1);+#1057=LINE($,#1054,#1056);+#1058=EDGE_CURVE($,#1051,#1053,#1057,.T.);+#1059=ORIENTED_EDGE($,$,$,#1058,.T.);+#1060=CARTESIAN_POINT($,(-233.045,440.99226,0.00246000000001));+#1061=VERTEX_POINT($,#1060);+#1062=CARTESIAN_POINT($,(-233.045,485.44226,0.00246000000001));+#1063=DIRECTION($,(0,-1,0));+#1064=VECTOR($,#1063,1);+#1065=LINE($,#1062,#1064);+#1066=EDGE_CURVE($,#1053,#1061,#1065,.T.);+#1067=ORIENTED_EDGE($,$,$,#1066,.T.);+#1068=CARTESIAN_POINT($,(-8.255,440.99226,0.00246000000001));+#1069=VERTEX_POINT($,#1068);+#1070=CARTESIAN_POINT($,(-233.045,440.99226,0.00246000000001));+#1071=DIRECTION($,(1,0,0));+#1072=VECTOR($,#1071,1);+#1073=LINE($,#1070,#1072);+#1074=EDGE_CURVE($,#1061,#1069,#1073,.T.);+#1075=ORIENTED_EDGE($,$,$,#1074,.T.);+#1076=CARTESIAN_POINT($,(-8.255,440.99226,0.00246000000001));+#1077=DIRECTION($,(0,1,0));+#1078=VECTOR($,#1077,1);+#1079=LINE($,#1076,#1078);+#1080=EDGE_CURVE($,#1069,#1051,#1079,.T.);+#1081=ORIENTED_EDGE($,$,$,#1080,.T.);+#1082=EDGE_LOOP($,(#1059,#1067,#1075,#1081));+#1083=FACE_OUTER_BOUND('',#1082,.T.);+#1084=ADVANCED_FACE('',(#1083),#1049,.F.);+#1085=CARTESIAN_POINT($,(-8.255,440.99226,8.25746000000001));+#1086=DIRECTION($,(-1,0,0));+#1087=DIRECTION($,(0,-1,0));+#1088=AXIS2_PLACEMENT_3D($,#1085,#1086,#1087);+#1089=CYLINDRICAL_SURFACE($,#1088,6.35000000000002);+#1090=ORIENTED_EDGE($,$,$,#506,.F.);+#1091=CARTESIAN_POINT($,(-233.045,440.99226,8.25746000000001));+#1092=DIRECTION($,(1,-0,-0));+#1093=DIRECTION($,(0,-1,0));+#1094=AXIS2_PLACEMENT_3D($,#1091,#1092,#1093);+#1095=CIRCLE($,#1094,6.35000000000002);+#1096=TRIMMED_CURVE($,#1095,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#1097=EDGE_CURVE($,#493,#1013,#1096,.T.);+#1098=ORIENTED_EDGE($,$,$,#1097,.T.);+#1099=ORIENTED_EDGE($,$,$,#1018,.F.);+#1100=CARTESIAN_POINT($,(-8.255,440.99226,8.25746000000001));+#1101=DIRECTION($,(-1,0,0));+#1102=DIRECTION($,(0,0,-1));+#1103=AXIS2_PLACEMENT_3D($,#1100,#1101,#1102);+#1104=CIRCLE($,#1103,6.35);+#1105=TRIMMED_CURVE($,#1104,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#1106=EDGE_CURVE($,#1011,#501,#1105,.T.);+#1107=ORIENTED_EDGE($,$,$,#1106,.T.);+#1108=EDGE_LOOP($,(#1090,#1098,#1099,#1107));+#1109=FACE_OUTER_BOUND('',#1108,.T.);+#1110=ADVANCED_FACE('',(#1109),#1089,.T.);+#1111=CARTESIAN_POINT($,(-8.255,440.99226,8.25746000000001));+#1112=DIRECTION($,(-1,0,0));+#1113=DIRECTION($,(0,-1,0));+#1114=AXIS2_PLACEMENT_3D($,#1111,#1112,#1113);+#1115=CYLINDRICAL_SURFACE($,#1114,8.255);+#1116=ORIENTED_EDGE($,$,$,#1074,.F.);+#1117=CARTESIAN_POINT($,(-233.045,440.99226,8.25746000000001));+#1118=DIRECTION($,(-1,0,0));+#1119=DIRECTION($,(0,0,-1));+#1120=AXIS2_PLACEMENT_3D($,#1117,#1118,#1119);+#1121=CIRCLE($,#1120,8.255);+#1122=TRIMMED_CURVE($,#1121,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#1123=EDGE_CURVE($,#1061,#525,#1122,.T.);+#1124=ORIENTED_EDGE($,$,$,#1123,.T.);+#1125=ORIENTED_EDGE($,$,$,#530,.F.);+#1126=CARTESIAN_POINT($,(-8.255,440.99226,8.25746000000001));+#1127=DIRECTION($,(1,-0,-0));+#1128=DIRECTION($,(0,-1,0));+#1129=AXIS2_PLACEMENT_3D($,#1126,#1127,#1128);+#1130=CIRCLE($,#1129,8.255);+#1131=TRIMMED_CURVE($,#1130,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#1132=EDGE_CURVE($,#523,#1069,#1131,.T.);+#1133=ORIENTED_EDGE($,$,$,#1132,.T.);+#1134=EDGE_LOOP($,(#1116,#1124,#1125,#1133));+#1135=FACE_OUTER_BOUND('',#1134,.T.);+#1136=ADVANCED_FACE('',(#1135),#1115,.F.);+#1137=CARTESIAN_POINT($,(8.76783352130505,66.34226,119.403106478695));+#1138=DIRECTION($,(-0.707106781186548,0,0.707106781186548));+#1139=DIRECTION($,(0,1,0));+#1140=AXIS2_PLACEMENT_3D($,#1137,#1138,#1139);+#1141=PLANE($,#1140);+#1142=CARTESIAN_POINT($,(8.76783352130505,66.34226,119.403106478695));+#1143=VERTEX_POINT($,#1142);+#1144=CARTESIAN_POINT($,(8.76783352130505,418.13226,119.403106478695));+#1145=VERTEX_POINT($,#1144);+#1146=CARTESIAN_POINT($,(8.76783352130505,66.34226,119.403106478695));+#1147=DIRECTION($,(0,1,0));+#1148=VECTOR($,#1147,1);+#1149=LINE($,#1146,#1148);+#1150=EDGE_CURVE($,#1143,#1145,#1149,.T.);+#1151=ORIENTED_EDGE($,$,$,#1150,.T.);+#1152=CARTESIAN_POINT($,(43.0724119037892,418.13226,153.707684861179));+#1153=VERTEX_POINT($,#1152);+#1154=CARTESIAN_POINT($,(8.76783352130505,418.13226,119.403106478695));+#1155=DIRECTION($,(0.707106781186548,0,0.707106781186548));+#1156=VECTOR($,#1155,1);+#1157=LINE($,#1154,#1156);+#1158=EDGE_CURVE($,#1145,#1153,#1157,.T.);+#1159=ORIENTED_EDGE($,$,$,#1158,.T.);+#1160=CARTESIAN_POINT($,(43.0724119037892,66.34226,153.707684861179));+#1161=VERTEX_POINT($,#1160);+#1162=CARTESIAN_POINT($,(43.0724119037892,418.13226,153.707684861179));+#1163=DIRECTION($,(0,-1,0));+#1164=VECTOR($,#1163,1);+#1165=LINE($,#1162,#1164);+#1166=EDGE_CURVE($,#1153,#1161,#1165,.T.);+#1167=ORIENTED_EDGE($,$,$,#1166,.T.);+#1168=CARTESIAN_POINT($,(43.0724119037892,66.34226,153.707684861179));+#1169=DIRECTION($,(-0.707106781186548,0,-0.707106781186548));+#1170=VECTOR($,#1169,1);+#1171=LINE($,#1168,#1170);+#1172=EDGE_CURVE($,#1161,#1143,#1171,.T.);+#1173=ORIENTED_EDGE($,$,$,#1172,.T.);+#1174=EDGE_LOOP($,(#1151,#1159,#1167,#1173));+#1175=FACE_OUTER_BOUND('',#1174,.T.);+#1176=ADVANCED_FACE('',(#1175),#1141,.T.);+#1177=CARTESIAN_POINT($,(10.1148719394654,66.34226,118.056068060535));+#1178=DIRECTION($,(0.707106781186548,-0,-0.707106781186548));+#1179=DIRECTION($,(0,1,0));+#1180=AXIS2_PLACEMENT_3D($,#1177,#1178,#1179);+#1181=PLANE($,#1180);+#1182=CARTESIAN_POINT($,(44.4194503219496,66.34226,152.360646443019));+#1183=VERTEX_POINT($,#1182);+#1184=CARTESIAN_POINT($,(44.4194503219496,418.13226,152.360646443019));+#1185=VERTEX_POINT($,#1184);+#1186=CARTESIAN_POINT($,(44.4194503219496,66.34226,152.360646443019));+#1187=DIRECTION($,(0,1,0));+#1188=VECTOR($,#1187,1);+#1189=LINE($,#1186,#1188);+#1190=EDGE_CURVE($,#1183,#1185,#1189,.T.);+#1191=ORIENTED_EDGE($,$,$,#1190,.T.);+#1192=CARTESIAN_POINT($,(10.1148719394654,418.13226,118.056068060535));+#1193=VERTEX_POINT($,#1192);+#1194=CARTESIAN_POINT($,(44.4194503219496,418.13226,152.360646443019));+#1195=DIRECTION($,(-0.707106781186547,0,-0.707106781186548));+#1196=VECTOR($,#1195,1);+#1197=LINE($,#1194,#1196);+#1198=EDGE_CURVE($,#1185,#1193,#1197,.T.);+#1199=ORIENTED_EDGE($,$,$,#1198,.T.);+#1200=CARTESIAN_POINT($,(10.1148719394654,66.34226,118.056068060535));+#1201=VERTEX_POINT($,#1200);+#1202=CARTESIAN_POINT($,(10.1148719394654,418.13226,118.056068060535));+#1203=DIRECTION($,(0,-1,0));+#1204=VECTOR($,#1203,1);+#1205=LINE($,#1202,#1204);+#1206=EDGE_CURVE($,#1193,#1201,#1205,.T.);+#1207=ORIENTED_EDGE($,$,$,#1206,.T.);+#1208=CARTESIAN_POINT($,(10.1148719394654,66.34226,118.056068060535));+#1209=DIRECTION($,(0.707106781186547,0,0.707106781186548));+#1210=VECTOR($,#1209,1);+#1211=LINE($,#1208,#1210);+#1212=EDGE_CURVE($,#1201,#1183,#1211,.T.);+#1213=ORIENTED_EDGE($,$,$,#1212,.T.);+#1214=EDGE_LOOP($,(#1191,#1199,#1207,#1213));+#1215=FACE_OUTER_BOUND('',#1214,.T.);+#1216=ADVANCED_FACE('',(#1215),#1181,.F.);+#1217=CARTESIAN_POINT($,(14.605,66.34226,113.56594));+#1218=DIRECTION($,(0,1,0));+#1219=DIRECTION($,(-1,0,0));+#1220=AXIS2_PLACEMENT_3D($,#1217,#1218,#1219);+#1221=CYLINDRICAL_SURFACE($,#1220,8.255);+#1222=ORIENTED_EDGE($,$,$,#770,.F.);+#1223=CARTESIAN_POINT($,(14.605,418.13226,113.56594));+#1224=DIRECTION($,(0,1,0));+#1225=DIRECTION($,(-1,0,0));+#1226=AXIS2_PLACEMENT_3D($,#1223,#1224,#1225);+#1227=CIRCLE($,#1226,8.255);+#1228=TRIMMED_CURVE($,#1227,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(0.785398163397449)),.T.,.PARAMETER.);+#1229=EDGE_CURVE($,#757,#1145,#1228,.T.);+#1230=ORIENTED_EDGE($,$,$,#1229,.T.);+#1231=ORIENTED_EDGE($,$,$,#1150,.F.);+#1232=CARTESIAN_POINT($,(14.605,66.34226,113.56594));+#1233=DIRECTION($,(-0,-1,-0));+#1234=DIRECTION($,(-0.707106781186547,0,0.707106781186548));+#1235=AXIS2_PLACEMENT_3D($,#1232,#1233,#1234);+#1236=CIRCLE($,#1235,8.255);+#1237=TRIMMED_CURVE($,#1236,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(0.785398163397449)),.T.,.PARAMETER.);+#1238=EDGE_CURVE($,#1143,#765,#1237,.T.);+#1239=ORIENTED_EDGE($,$,$,#1238,.T.);+#1240=EDGE_LOOP($,(#1222,#1230,#1231,#1239));+#1241=FACE_OUTER_BOUND('',#1240,.T.);+#1242=ADVANCED_FACE('',(#1241),#1221,.T.);+#1243=CARTESIAN_POINT($,(14.605,66.34226,113.56594));+#1244=DIRECTION($,(0,1,0));+#1245=DIRECTION($,(-1,0,0));+#1246=AXIS2_PLACEMENT_3D($,#1243,#1244,#1245);+#1247=CYLINDRICAL_SURFACE($,#1246,6.35);+#1248=ORIENTED_EDGE($,$,$,#1206,.F.);+#1249=CARTESIAN_POINT($,(14.605,418.13226,113.56594));+#1250=DIRECTION($,(-0,-1,-0));+#1251=DIRECTION($,(-0.707106781186547,0,0.707106781186548));+#1252=AXIS2_PLACEMENT_3D($,#1249,#1250,#1251);+#1253=CIRCLE($,#1252,6.35000000000001);+#1254=TRIMMED_CURVE($,#1253,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(0.78539816339745)),.T.,.PARAMETER.);+#1255=EDGE_CURVE($,#1193,#789,#1254,.T.);+#1256=ORIENTED_EDGE($,$,$,#1255,.T.);+#1257=ORIENTED_EDGE($,$,$,#794,.F.);+#1258=CARTESIAN_POINT($,(14.605,66.34226,113.56594));+#1259=DIRECTION($,(0,1,0));+#1260=DIRECTION($,(-1,0,0));+#1261=AXIS2_PLACEMENT_3D($,#1258,#1259,#1260);+#1262=CIRCLE($,#1261,6.35);+#1263=TRIMMED_CURVE($,#1262,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(0.78539816339745)),.T.,.PARAMETER.);+#1264=EDGE_CURVE($,#787,#1201,#1263,.T.);+#1265=ORIENTED_EDGE($,$,$,#1264,.T.);+#1266=EDGE_LOOP($,(#1248,#1256,#1257,#1265));+#1267=FACE_OUTER_BOUND('',#1266,.T.);+#1268=ADVANCED_FACE('',(#1267),#1247,.F.);+#1269=CARTESIAN_POINT($,(-241.3,58.08726,78.105));+#1270=DIRECTION($,(-0,1,0));+#1271=DIRECTION($,(1,0,0));+#1272=AXIS2_PLACEMENT_3D($,#1269,#1270,#1271);+#1273=PLANE($,#1272);+#1274=ORIENTED_EDGE($,$,$,#14,.T.);+#1275=CARTESIAN_POINT($,(-233.045,58.08726,78.105));+#1276=DIRECTION($,(0,0,-1));+#1277=VECTOR($,#1276,1);+#1278=LINE($,#1275,#1277);+#1279=EDGE_CURVE($,#9,#253,#1278,.T.);+#1280=ORIENTED_EDGE($,$,$,#1279,.T.);+#1281=ORIENTED_EDGE($,$,$,#266,.T.);+#1282=CARTESIAN_POINT($,(-241.3,58.08726,76.2));+#1283=DIRECTION($,(0,0,1));+#1284=VECTOR($,#1283,1);+#1285=LINE($,#1282,#1284);+#1286=EDGE_CURVE($,#261,#7,#1285,.T.);+#1287=ORIENTED_EDGE($,$,$,#1286,.T.);+#1288=EDGE_LOOP($,(#1274,#1280,#1281,#1287));+#1289=FACE_OUTER_BOUND('',#1288,.T.);+#1290=ADVANCED_FACE('',(#1289),#1273,.T.);+#1291=CARTESIAN_POINT($,(-8.255,58.08726,78.105));+#1292=DIRECTION($,(-0,1,0));+#1293=DIRECTION($,(1,0,0));+#1294=AXIS2_PLACEMENT_3D($,#1291,#1292,#1293);+#1295=PLANE($,#1294);+#1296=ORIENTED_EDGE($,$,$,#30,.T.);+#1297=CARTESIAN_POINT($,(0,58.08726,78.105));+#1298=DIRECTION($,(0,0,-1));+#1299=VECTOR($,#1298,1);+#1300=LINE($,#1297,#1299);+#1301=EDGE_CURVE($,#25,#237,#1300,.T.);+#1302=ORIENTED_EDGE($,$,$,#1301,.T.);+#1303=ORIENTED_EDGE($,$,$,#250,.T.);+#1304=CARTESIAN_POINT($,(-8.255,58.08726,76.2));+#1305=DIRECTION($,(0,0,1));+#1306=VECTOR($,#1305,1);+#1307=LINE($,#1304,#1306);+#1308=EDGE_CURVE($,#245,#17,#1307,.T.);+#1309=ORIENTED_EDGE($,$,$,#1308,.T.);+#1310=EDGE_LOOP($,(#1296,#1302,#1303,#1309));+#1311=FACE_OUTER_BOUND('',#1310,.T.);+#1312=ADVANCED_FACE('',(#1311),#1295,.T.);+#1313=CARTESIAN_POINT($,(0,58.08726,78.105));+#1314=DIRECTION($,(-1,0,0));+#1315=DIRECTION($,(0,1,0));+#1316=AXIS2_PLACEMENT_3D($,#1313,#1314,#1315);+#1317=PLANE($,#1316);+#1318=ORIENTED_EDGE($,$,$,#38,.T.);+#1319=CARTESIAN_POINT($,(0,66.34226,78.105));+#1320=DIRECTION($,(0,0,-1));+#1321=VECTOR($,#1320,1);+#1322=LINE($,#1319,#1321);+#1323=EDGE_CURVE($,#33,#229,#1322,.T.);+#1324=ORIENTED_EDGE($,$,$,#1323,.T.);+#1325=ORIENTED_EDGE($,$,$,#242,.T.);+#1326=ORIENTED_EDGE($,$,$,#1301,.F.);+#1327=EDGE_LOOP($,(#1318,#1324,#1325,#1326));+#1328=FACE_OUTER_BOUND('',#1327,.T.);+#1329=ADVANCED_FACE('',(#1328),#1317,.T.);+#1330=CARTESIAN_POINT($,(0,418.13226,78.105));+#1331=DIRECTION($,(-1,0,0));+#1332=DIRECTION($,(0,1,0));+#1333=AXIS2_PLACEMENT_3D($,#1330,#1331,#1332);+#1334=PLANE($,#1333);+#1335=ORIENTED_EDGE($,$,$,#54,.T.);+#1336=CARTESIAN_POINT($,(0,426.38726,78.105));+#1337=DIRECTION($,(0,0,-1));+#1338=VECTOR($,#1337,1);+#1339=LINE($,#1336,#1338);+#1340=EDGE_CURVE($,#49,#213,#1339,.T.);+#1341=ORIENTED_EDGE($,$,$,#1340,.T.);+#1342=ORIENTED_EDGE($,$,$,#226,.T.);+#1343=CARTESIAN_POINT($,(0,418.13226,76.2));+#1344=DIRECTION($,(0,0,1));+#1345=VECTOR($,#1344,1);+#1346=LINE($,#1343,#1345);+#1347=EDGE_CURVE($,#221,#41,#1346,.T.);+#1348=ORIENTED_EDGE($,$,$,#1347,.T.);+#1349=EDGE_LOOP($,(#1335,#1341,#1342,#1348));+#1350=FACE_OUTER_BOUND('',#1349,.T.);+#1351=ADVANCED_FACE('',(#1350),#1334,.T.);+#1352=CARTESIAN_POINT($,(0,426.38726,78.105));+#1353=DIRECTION($,(-0,-1,-0));+#1354=DIRECTION($,(-1,0,0));+#1355=AXIS2_PLACEMENT_3D($,#1352,#1353,#1354);+#1356=PLANE($,#1355);+#1357=ORIENTED_EDGE($,$,$,#62,.T.);+#1358=CARTESIAN_POINT($,(-8.255,426.38726,78.105));+#1359=DIRECTION($,(0,0,-1));+#1360=VECTOR($,#1359,1);+#1361=LINE($,#1358,#1360);+#1362=EDGE_CURVE($,#57,#205,#1361,.T.);+#1363=ORIENTED_EDGE($,$,$,#1362,.T.);+#1364=ORIENTED_EDGE($,$,$,#218,.T.);+#1365=ORIENTED_EDGE($,$,$,#1340,.F.);+#1366=EDGE_LOOP($,(#1357,#1363,#1364,#1365));+#1367=FACE_OUTER_BOUND('',#1366,.T.);+#1368=ADVANCED_FACE('',(#1367),#1356,.T.);+#1369=CARTESIAN_POINT($,(-233.045,426.38726,78.105));+#1370=DIRECTION($,(-0,-1,-0));+#1371=DIRECTION($,(-1,0,0));+#1372=AXIS2_PLACEMENT_3D($,#1369,#1370,#1371);+#1373=PLANE($,#1372);+#1374=ORIENTED_EDGE($,$,$,#78,.T.);+#1375=CARTESIAN_POINT($,(-241.3,426.38726,78.105));+#1376=DIRECTION($,(0,0,-1));+#1377=VECTOR($,#1376,1);+#1378=LINE($,#1375,#1377);+#1379=EDGE_CURVE($,#73,#189,#1378,.T.);+#1380=ORIENTED_EDGE($,$,$,#1379,.T.);+#1381=ORIENTED_EDGE($,$,$,#202,.T.);+#1382=CARTESIAN_POINT($,(-233.045,426.38726,76.2));+#1383=DIRECTION($,(0,0,1));+#1384=VECTOR($,#1383,1);+#1385=LINE($,#1382,#1384);+#1386=EDGE_CURVE($,#197,#65,#1385,.T.);+#1387=ORIENTED_EDGE($,$,$,#1386,.T.);+#1388=EDGE_LOOP($,(#1374,#1380,#1381,#1387));+#1389=FACE_OUTER_BOUND('',#1388,.T.);+#1390=ADVANCED_FACE('',(#1389),#1373,.T.);+#1391=CARTESIAN_POINT($,(-241.3,426.38726,78.105));+#1392=DIRECTION($,(1,0,0));+#1393=DIRECTION($,(0,-1,0));+#1394=AXIS2_PLACEMENT_3D($,#1391,#1392,#1393);+#1395=PLANE($,#1394);+#1396=ORIENTED_EDGE($,$,$,#86,.T.);+#1397=CARTESIAN_POINT($,(-241.3,418.13226,78.105));+#1398=DIRECTION($,(0,0,-1));+#1399=VECTOR($,#1398,1);+#1400=LINE($,#1397,#1399);+#1401=EDGE_CURVE($,#81,#181,#1400,.T.);+#1402=ORIENTED_EDGE($,$,$,#1401,.T.);+#1403=ORIENTED_EDGE($,$,$,#194,.T.);+#1404=ORIENTED_EDGE($,$,$,#1379,.F.);+#1405=EDGE_LOOP($,(#1396,#1402,#1403,#1404));+#1406=FACE_OUTER_BOUND('',#1405,.T.);+#1407=ADVANCED_FACE('',(#1406),#1395,.T.);+#1408=CARTESIAN_POINT($,(-241.3,66.34226,78.105));+#1409=DIRECTION($,(1,0,0));+#1410=DIRECTION($,(0,-1,0));+#1411=AXIS2_PLACEMENT_3D($,#1408,#1409,#1410);+#1412=PLANE($,#1411);+#1413=ORIENTED_EDGE($,$,$,#100,.T.);+#1414=ORIENTED_EDGE($,$,$,#1286,.F.);+#1415=ORIENTED_EDGE($,$,$,#272,.T.);+#1416=CARTESIAN_POINT($,(-241.3,66.34226,76.2));+#1417=DIRECTION($,(0,0,1));+#1418=VECTOR($,#1417,1);+#1419=LINE($,#1416,#1418);+#1420=EDGE_CURVE($,#179,#89,#1419,.T.);+#1421=ORIENTED_EDGE($,$,$,#1420,.T.);+#1422=EDGE_LOOP($,(#1413,#1414,#1415,#1421));+#1423=FACE_OUTER_BOUND('',#1422,.T.);+#1424=ADVANCED_FACE('',(#1423),#1412,.T.);+#1425=CARTESIAN_POINT($,(-8.255,49.83226,69.85));+#1426=DIRECTION($,(1,-0,0));+#1427=DIRECTION($,(0,-0,-1));+#1428=AXIS2_PLACEMENT_3D($,#1425,#1426,#1427);+#1429=PLANE($,#1428);+#1430=ORIENTED_EDGE($,$,$,#366,.T.);+#1431=CARTESIAN_POINT($,(-8.255,49.83226,8.25746000000001));+#1432=DIRECTION($,(0,1,0));+#1433=VECTOR($,#1432,1);+#1434=LINE($,#1431,#1433);+#1435=EDGE_CURVE($,#361,#393,#1434,.T.);+#1436=ORIENTED_EDGE($,$,$,#1435,.T.);+#1437=ORIENTED_EDGE($,$,$,#406,.T.);+#1438=CARTESIAN_POINT($,(-8.255,51.73726,69.85));+#1439=DIRECTION($,(0,-1,0));+#1440=VECTOR($,#1439,1);+#1441=LINE($,#1438,#1440);+#1442=EDGE_CURVE($,#401,#353,#1441,.T.);+#1443=ORIENTED_EDGE($,$,$,#1442,.T.);+#1444=EDGE_LOOP($,(#1430,#1436,#1437,#1443));+#1445=FACE_OUTER_BOUND('',#1444,.T.);+#1446=ADVANCED_FACE('',(#1445),#1429,.T.);+#1447=CARTESIAN_POINT($,(-233.045,49.83226,8.25746000000001));+#1448=DIRECTION($,(-1,0,0));+#1449=DIRECTION($,(0,0,1));+#1450=AXIS2_PLACEMENT_3D($,#1447,#1448,#1449);+#1451=PLANE($,#1450);+#1452=ORIENTED_EDGE($,$,$,#380,.T.);+#1453=CARTESIAN_POINT($,(-233.045,49.83226,69.85));+#1454=DIRECTION($,(0,1,0));+#1455=VECTOR($,#1454,1);+#1456=LINE($,#1453,#1455);+#1457=EDGE_CURVE($,#351,#409,#1456,.T.);+#1458=ORIENTED_EDGE($,$,$,#1457,.T.);+#1459=ORIENTED_EDGE($,$,$,#420,.T.);+#1460=CARTESIAN_POINT($,(-233.045,51.73726,8.25746000000001));+#1461=DIRECTION($,(0,-1,0));+#1462=VECTOR($,#1461,1);+#1463=LINE($,#1460,#1462);+#1464=EDGE_CURVE($,#391,#369,#1463,.T.);+#1465=ORIENTED_EDGE($,$,$,#1464,.T.);+#1466=EDGE_LOOP($,(#1452,#1458,#1459,#1465));+#1467=FACE_OUTER_BOUND('',#1466,.T.);+#1468=ADVANCED_FACE('',(#1467),#1451,.T.);+#1469=CARTESIAN_POINT($,(-8.255,58.08726,78.105));+#1470=DIRECTION($,(1,0,0));+#1471=DIRECTION($,(0,-0.707106781186548,-0.707106781186547));+#1472=AXIS2_PLACEMENT_3D($,#1469,#1470,#1471);+#1473=PLANE($,#1472);+#1474=ORIENTED_EDGE($,$,$,#437,.T.);+#1475=ORIENTED_EDGE($,$,$,#1442,.F.);+#1476=ORIENTED_EDGE($,$,$,#463,.T.);+#1477=ORIENTED_EDGE($,$,$,#1308,.T.);+#1478=EDGE_LOOP($,(#1474,#1475,#1476,#1477));+#1479=FACE_OUTER_BOUND('',#1478,.T.);+#1480=ADVANCED_FACE('',(#1479),#1473,.T.);+#1481=CARTESIAN_POINT($,(-233.045,49.83226,69.85));+#1482=DIRECTION($,(-1,0,0));+#1483=DIRECTION($,(0,0.707106781186548,0.707106781186547));+#1484=AXIS2_PLACEMENT_3D($,#1481,#1482,#1483);+#1485=PLANE($,#1484);+#1486=ORIENTED_EDGE($,$,$,#446,.T.);+#1487=ORIENTED_EDGE($,$,$,#1279,.T.);+#1488=ORIENTED_EDGE($,$,$,#472,.T.);+#1489=ORIENTED_EDGE($,$,$,#1457,.F.);+#1490=EDGE_LOOP($,(#1486,#1487,#1488,#1489));+#1491=FACE_OUTER_BOUND('',#1490,.T.);+#1492=ADVANCED_FACE('',(#1491),#1485,.T.);+#1493=CARTESIAN_POINT($,(-233.045,434.64226,69.85));+#1494=DIRECTION($,(-1,-0,-0));+#1495=DIRECTION($,(0,0,-1));+#1496=AXIS2_PLACEMENT_3D($,#1493,#1494,#1495);+#1497=PLANE($,#1496);+#1498=ORIENTED_EDGE($,$,$,#498,.T.);+#1499=CARTESIAN_POINT($,(-233.045,434.64226,8.25746000000001));+#1500=DIRECTION($,(0,-1,0));+#1501=VECTOR($,#1500,1);+#1502=LINE($,#1499,#1501);+#1503=EDGE_CURVE($,#493,#525,#1502,.T.);+#1504=ORIENTED_EDGE($,$,$,#1503,.T.);+#1505=ORIENTED_EDGE($,$,$,#538,.T.);+#1506=CARTESIAN_POINT($,(-233.045,432.73726,69.85));+#1507=DIRECTION($,(0,1,0));+#1508=VECTOR($,#1507,1);+#1509=LINE($,#1506,#1508);+#1510=EDGE_CURVE($,#533,#485,#1509,.T.);+#1511=ORIENTED_EDGE($,$,$,#1510,.T.);+#1512=EDGE_LOOP($,(#1498,#1504,#1505,#1511));+#1513=FACE_OUTER_BOUND('',#1512,.T.);+#1514=ADVANCED_FACE('',(#1513),#1497,.T.);+#1515=CARTESIAN_POINT($,(-8.255,434.64226,8.25746000000001));+#1516=DIRECTION($,(1,0,-0));+#1517=DIRECTION($,(0,0,1));+#1518=AXIS2_PLACEMENT_3D($,#1515,#1516,#1517);+#1519=PLANE($,#1518);+#1520=ORIENTED_EDGE($,$,$,#512,.T.);+#1521=CARTESIAN_POINT($,(-8.255,434.64226,69.85));+#1522=DIRECTION($,(0,-1,0));+#1523=VECTOR($,#1522,1);+#1524=LINE($,#1521,#1523);+#1525=EDGE_CURVE($,#483,#541,#1524,.T.);+#1526=ORIENTED_EDGE($,$,$,#1525,.T.);+#1527=ORIENTED_EDGE($,$,$,#552,.T.);+#1528=CARTESIAN_POINT($,(-8.255,432.73726,8.25746000000001));+#1529=DIRECTION($,(0,1,0));+#1530=VECTOR($,#1529,1);+#1531=LINE($,#1528,#1530);+#1532=EDGE_CURVE($,#523,#501,#1531,.T.);+#1533=ORIENTED_EDGE($,$,$,#1532,.T.);+#1534=EDGE_LOOP($,(#1520,#1526,#1527,#1533));+#1535=FACE_OUTER_BOUND('',#1534,.T.);+#1536=ADVANCED_FACE('',(#1535),#1519,.T.);+#1537=CARTESIAN_POINT($,(-233.045,426.38726,78.105));+#1538=DIRECTION($,(-1,0,0));+#1539=DIRECTION($,(0,0.707106781186548,-0.707106781186548));+#1540=AXIS2_PLACEMENT_3D($,#1537,#1538,#1539);+#1541=PLANE($,#1540);+#1542=ORIENTED_EDGE($,$,$,#569,.T.);+#1543=ORIENTED_EDGE($,$,$,#1510,.F.);+#1544=ORIENTED_EDGE($,$,$,#595,.T.);+#1545=ORIENTED_EDGE($,$,$,#1386,.T.);+#1546=EDGE_LOOP($,(#1542,#1543,#1544,#1545));+#1547=FACE_OUTER_BOUND('',#1546,.T.);+#1548=ADVANCED_FACE('',(#1547),#1541,.T.);+#1549=CARTESIAN_POINT($,(-8.255,434.64226,69.85));+#1550=DIRECTION($,(1,0,0));+#1551=DIRECTION($,(0,-0.707106781186548,0.707106781186548));+#1552=AXIS2_PLACEMENT_3D($,#1549,#1550,#1551);+#1553=PLANE($,#1552);+#1554=ORIENTED_EDGE($,$,$,#578,.T.);+#1555=ORIENTED_EDGE($,$,$,#1362,.T.);+#1556=ORIENTED_EDGE($,$,$,#604,.T.);+#1557=ORIENTED_EDGE($,$,$,#1525,.F.);+#1558=EDGE_LOOP($,(#1554,#1555,#1556,#1557));+#1559=FACE_OUTER_BOUND('',#1558,.T.);+#1560=ADVANCED_FACE('',(#1559),#1553,.T.);+#1561=CARTESIAN_POINT($,(-247.65,66.34226,84.455));+#1562=DIRECTION($,(0,-1,0));+#1563=DIRECTION($,(0,0,1));+#1564=AXIS2_PLACEMENT_3D($,#1561,#1562,#1563);+#1565=PLANE($,#1564);+#1566=ORIENTED_EDGE($,$,$,#630,.T.);+#1567=CARTESIAN_POINT($,(-247.65,66.34226,128.905));+#1568=DIRECTION($,(-1,0,0));+#1569=VECTOR($,#1568,1);+#1570=LINE($,#1567,#1569);+#1571=EDGE_CURVE($,#625,#657,#1570,.T.);+#1572=ORIENTED_EDGE($,$,$,#1571,.T.);+#1573=ORIENTED_EDGE($,$,$,#670,.T.);+#1574=CARTESIAN_POINT($,(-249.555,66.34226,84.455));+#1575=DIRECTION($,(1,0,0));+#1576=VECTOR($,#1575,1);+#1577=LINE($,#1574,#1576);+#1578=EDGE_CURVE($,#665,#617,#1577,.T.);+#1579=ORIENTED_EDGE($,$,$,#1578,.T.);+#1580=EDGE_LOOP($,(#1566,#1572,#1573,#1579));+#1581=FACE_OUTER_BOUND('',#1580,.T.);+#1582=ADVANCED_FACE('',(#1581),#1565,.T.);+#1583=CARTESIAN_POINT($,(-247.65,66.34226,128.905));+#1584=DIRECTION($,(0,-0,1));+#1585=DIRECTION($,(0,1,0));+#1586=AXIS2_PLACEMENT_3D($,#1583,#1584,#1585);+#1587=PLANE($,#1586);+#1588=ORIENTED_EDGE($,$,$,#638,.T.);+#1589=CARTESIAN_POINT($,(-247.65,418.13226,128.905));+#1590=DIRECTION($,(-1,0,0));+#1591=VECTOR($,#1590,1);+#1592=LINE($,#1589,#1591);+#1593=EDGE_CURVE($,#633,#655,#1592,.T.);+#1594=ORIENTED_EDGE($,$,$,#1593,.T.);+#1595=ORIENTED_EDGE($,$,$,#662,.T.);+#1596=ORIENTED_EDGE($,$,$,#1571,.F.);+#1597=EDGE_LOOP($,(#1588,#1594,#1595,#1596));+#1598=FACE_OUTER_BOUND('',#1597,.T.);+#1599=ADVANCED_FACE('',(#1598),#1587,.T.);+#1600=CARTESIAN_POINT($,(-247.65,418.13226,128.905));+#1601=DIRECTION($,(0,1,0));+#1602=DIRECTION($,(0,0,-1));+#1603=AXIS2_PLACEMENT_3D($,#1600,#1601,#1602);+#1604=PLANE($,#1603);+#1605=ORIENTED_EDGE($,$,$,#644,.T.);+#1606=CARTESIAN_POINT($,(-247.65,418.13226,84.455));+#1607=DIRECTION($,(-1,0,0));+#1608=VECTOR($,#1607,1);+#1609=LINE($,#1606,#1608);+#1610=EDGE_CURVE($,#615,#673,#1609,.T.);+#1611=ORIENTED_EDGE($,$,$,#1610,.T.);+#1612=ORIENTED_EDGE($,$,$,#684,.T.);+#1613=ORIENTED_EDGE($,$,$,#1593,.F.);+#1614=EDGE_LOOP($,(#1605,#1611,#1612,#1613));+#1615=FACE_OUTER_BOUND('',#1614,.T.);+#1616=ADVANCED_FACE('',(#1615),#1604,.T.);+#1617=CARTESIAN_POINT($,(-241.3,66.34226,78.105));+#1618=DIRECTION($,(-0,-1,-0));+#1619=DIRECTION($,(-0.707106781186549,0,0.707106781186546));+#1620=AXIS2_PLACEMENT_3D($,#1617,#1618,#1619);+#1621=PLANE($,#1620);+#1622=ORIENTED_EDGE($,$,$,#701,.T.);+#1623=ORIENTED_EDGE($,$,$,#1578,.F.);+#1624=ORIENTED_EDGE($,$,$,#727,.T.);+#1625=ORIENTED_EDGE($,$,$,#1420,.T.);+#1626=EDGE_LOOP($,(#1622,#1623,#1624,#1625));+#1627=FACE_OUTER_BOUND('',#1626,.T.);+#1628=ADVANCED_FACE('',(#1627),#1621,.T.);+#1629=CARTESIAN_POINT($,(-247.65,418.13226,84.455));+#1630=DIRECTION($,(0,1,0));+#1631=DIRECTION($,(0.707106781186549,0,-0.707106781186546));+#1632=AXIS2_PLACEMENT_3D($,#1629,#1630,#1631);+#1633=PLANE($,#1632);+#1634=ORIENTED_EDGE($,$,$,#710,.T.);+#1635=ORIENTED_EDGE($,$,$,#1401,.T.);+#1636=ORIENTED_EDGE($,$,$,#736,.T.);+#1637=ORIENTED_EDGE($,$,$,#1610,.F.);+#1638=EDGE_LOOP($,(#1634,#1635,#1636,#1637));+#1639=FACE_OUTER_BOUND('',#1638,.T.);+#1640=ADVANCED_FACE('',(#1639),#1633,.T.);+#1641=CARTESIAN_POINT($,(6.35,418.13226,84.455));+#1642=DIRECTION($,(0,1,0));+#1643=DIRECTION($,(0,0,1));+#1644=AXIS2_PLACEMENT_3D($,#1641,#1642,#1643);+#1645=PLANE($,#1644);+#1646=ORIENTED_EDGE($,$,$,#762,.T.);+#1647=CARTESIAN_POINT($,(6.35,418.13226,113.56594));+#1648=DIRECTION($,(1,0,0));+#1649=VECTOR($,#1648,1);+#1650=LINE($,#1647,#1649);+#1651=EDGE_CURVE($,#757,#789,#1650,.T.);+#1652=ORIENTED_EDGE($,$,$,#1651,.T.);+#1653=ORIENTED_EDGE($,$,$,#802,.T.);+#1654=CARTESIAN_POINT($,(8.255,418.13226,84.455));+#1655=DIRECTION($,(-1,0,0));+#1656=VECTOR($,#1655,1);+#1657=LINE($,#1654,#1656);+#1658=EDGE_CURVE($,#797,#749,#1657,.T.);+#1659=ORIENTED_EDGE($,$,$,#1658,.T.);+#1660=EDGE_LOOP($,(#1646,#1652,#1653,#1659));+#1661=FACE_OUTER_BOUND('',#1660,.T.);+#1662=ADVANCED_FACE('',(#1661),#1645,.T.);+#1663=CARTESIAN_POINT($,(6.35,66.34226,113.56594));+#1664=DIRECTION($,(0,-1,-0));+#1665=DIRECTION($,(-0,0,-1));+#1666=AXIS2_PLACEMENT_3D($,#1663,#1664,#1665);+#1667=PLANE($,#1666);+#1668=ORIENTED_EDGE($,$,$,#776,.T.);+#1669=CARTESIAN_POINT($,(6.35,66.34226,84.455));+#1670=DIRECTION($,(1,0,0));+#1671=VECTOR($,#1670,1);+#1672=LINE($,#1669,#1671);+#1673=EDGE_CURVE($,#747,#805,#1672,.T.);+#1674=ORIENTED_EDGE($,$,$,#1673,.T.);+#1675=ORIENTED_EDGE($,$,$,#816,.T.);+#1676=CARTESIAN_POINT($,(8.255,66.34226,113.56594));+#1677=DIRECTION($,(-1,0,0));+#1678=VECTOR($,#1677,1);+#1679=LINE($,#1676,#1678);+#1680=EDGE_CURVE($,#787,#765,#1679,.T.);+#1681=ORIENTED_EDGE($,$,$,#1680,.T.);+#1682=EDGE_LOOP($,(#1668,#1674,#1675,#1681));+#1683=FACE_OUTER_BOUND('',#1682,.T.);+#1684=ADVANCED_FACE('',(#1683),#1667,.T.);+#1685=CARTESIAN_POINT($,(0,418.13226,78.105));+#1686=DIRECTION($,(-0,1,0));+#1687=DIRECTION($,(0.707106781186548,0,0.707106781186547));+#1688=AXIS2_PLACEMENT_3D($,#1685,#1686,#1687);+#1689=PLANE($,#1688);+#1690=ORIENTED_EDGE($,$,$,#833,.T.);+#1691=ORIENTED_EDGE($,$,$,#1658,.F.);+#1692=ORIENTED_EDGE($,$,$,#859,.T.);+#1693=ORIENTED_EDGE($,$,$,#1347,.T.);+#1694=EDGE_LOOP($,(#1690,#1691,#1692,#1693));+#1695=FACE_OUTER_BOUND('',#1694,.T.);+#1696=ADVANCED_FACE('',(#1695),#1689,.T.);+#1697=CARTESIAN_POINT($,(6.35,66.34226,84.455));+#1698=DIRECTION($,(0,-1,-0));+#1699=DIRECTION($,(-0.707106781186548,0,-0.707106781186547));+#1700=AXIS2_PLACEMENT_3D($,#1697,#1698,#1699);+#1701=PLANE($,#1700);+#1702=ORIENTED_EDGE($,$,$,#842,.T.);+#1703=ORIENTED_EDGE($,$,$,#1323,.T.);+#1704=ORIENTED_EDGE($,$,$,#868,.T.);+#1705=ORIENTED_EDGE($,$,$,#1673,.F.);+#1706=EDGE_LOOP($,(#1702,#1703,#1704,#1705));+#1707=FACE_OUTER_BOUND('',#1706,.T.);+#1708=ADVANCED_FACE('',(#1707),#1701,.T.);+#1709=CARTESIAN_POINT($,(-8.255,43.48226,1.90746000000001));+#1710=DIRECTION($,(1,0,0));+#1711=DIRECTION($,(0,-1,0));+#1712=AXIS2_PLACEMENT_3D($,#1709,#1710,#1711);+#1713=PLANE($,#1712);+#1714=ORIENTED_EDGE($,$,$,#894,.T.);+#1715=CARTESIAN_POINT($,(-8.255,12.70254,1.90746000000001));+#1716=DIRECTION($,(0,0,-1));+#1717=VECTOR($,#1716,1);+#1718=LINE($,#1715,#1717);+#1719=EDGE_CURVE($,#889,#921,#1718,.T.);+#1720=ORIENTED_EDGE($,$,$,#1719,.T.);+#1721=ORIENTED_EDGE($,$,$,#934,.T.);+#1722=CARTESIAN_POINT($,(-8.255,43.48226,0.00246000000001));+#1723=DIRECTION($,(0,0,1));+#1724=VECTOR($,#1723,1);+#1725=LINE($,#1722,#1724);+#1726=EDGE_CURVE($,#929,#881,#1725,.T.);+#1727=ORIENTED_EDGE($,$,$,#1726,.T.);+#1728=EDGE_LOOP($,(#1714,#1720,#1721,#1727));+#1729=FACE_OUTER_BOUND('',#1728,.T.);+#1730=ADVANCED_FACE('',(#1729),#1713,.T.);+#1731=CARTESIAN_POINT($,(-8.255,12.70254,1.90746000000001));+#1732=DIRECTION($,(-0,-1,-0));+#1733=DIRECTION($,(-1,0,0));+#1734=AXIS2_PLACEMENT_3D($,#1731,#1732,#1733);+#1735=PLANE($,#1734);+#1736=ORIENTED_EDGE($,$,$,#902,.T.);+#1737=CARTESIAN_POINT($,(-233.045,12.70254,1.90746000000001));+#1738=DIRECTION($,(0,0,-1));+#1739=VECTOR($,#1738,1);+#1740=LINE($,#1737,#1739);+#1741=EDGE_CURVE($,#897,#919,#1740,.T.);+#1742=ORIENTED_EDGE($,$,$,#1741,.T.);+#1743=ORIENTED_EDGE($,$,$,#926,.T.);+#1744=ORIENTED_EDGE($,$,$,#1719,.F.);+#1745=EDGE_LOOP($,(#1736,#1742,#1743,#1744));+#1746=FACE_OUTER_BOUND('',#1745,.T.);+#1747=ADVANCED_FACE('',(#1746),#1735,.T.);+#1748=CARTESIAN_POINT($,(-233.045,12.70254,1.90746000000001));+#1749=DIRECTION($,(-1,0,0));+#1750=DIRECTION($,(0,1,0));+#1751=AXIS2_PLACEMENT_3D($,#1748,#1749,#1750);+#1752=PLANE($,#1751);+#1753=ORIENTED_EDGE($,$,$,#908,.T.);+#1754=CARTESIAN_POINT($,(-233.045,43.48226,1.90746000000001));+#1755=DIRECTION($,(0,0,-1));+#1756=VECTOR($,#1755,1);+#1757=LINE($,#1754,#1756);+#1758=EDGE_CURVE($,#879,#937,#1757,.T.);+#1759=ORIENTED_EDGE($,$,$,#1758,.T.);+#1760=ORIENTED_EDGE($,$,$,#948,.T.);+#1761=ORIENTED_EDGE($,$,$,#1741,.F.);+#1762=EDGE_LOOP($,(#1753,#1759,#1760,#1761));+#1763=FACE_OUTER_BOUND('',#1762,.T.);+#1764=ADVANCED_FACE('',(#1763),#1752,.T.);+#1765=CARTESIAN_POINT($,(-8.255,49.83226,8.25746000000001));+#1766=DIRECTION($,(1,-0,0));+#1767=DIRECTION($,(0,-0.707106781186547,-0.707106781186548));+#1768=AXIS2_PLACEMENT_3D($,#1765,#1766,#1767);+#1769=PLANE($,#1768);+#1770=ORIENTED_EDGE($,$,$,#965,.T.);+#1771=ORIENTED_EDGE($,$,$,#1726,.F.);+#1772=ORIENTED_EDGE($,$,$,#991,.T.);+#1773=ORIENTED_EDGE($,$,$,#1435,.F.);+#1774=EDGE_LOOP($,(#1770,#1771,#1772,#1773));+#1775=FACE_OUTER_BOUND('',#1774,.T.);+#1776=ADVANCED_FACE('',(#1775),#1769,.T.);+#1777=CARTESIAN_POINT($,(-233.045,43.48226,1.90746000000001));+#1778=DIRECTION($,(-1,0,0));+#1779=DIRECTION($,(0,0.707106781186547,0.707106781186548));+#1780=AXIS2_PLACEMENT_3D($,#1777,#1778,#1779);+#1781=PLANE($,#1780);+#1782=ORIENTED_EDGE($,$,$,#974,.T.);+#1783=ORIENTED_EDGE($,$,$,#1464,.F.);+#1784=ORIENTED_EDGE($,$,$,#1000,.T.);+#1785=ORIENTED_EDGE($,$,$,#1758,.F.);+#1786=EDGE_LOOP($,(#1782,#1783,#1784,#1785));+#1787=FACE_OUTER_BOUND('',#1786,.T.);+#1788=ADVANCED_FACE('',(#1787),#1781,.T.);+#1789=CARTESIAN_POINT($,(-233.045,440.99226,1.90746000000001));+#1790=DIRECTION($,(-1,0,0));+#1791=DIRECTION($,(0,1,0));+#1792=AXIS2_PLACEMENT_3D($,#1789,#1790,#1791);+#1793=PLANE($,#1792);+#1794=ORIENTED_EDGE($,$,$,#1026,.T.);+#1795=CARTESIAN_POINT($,(-233.045,485.44226,1.90746000000001));+#1796=DIRECTION($,(0,0,-1));+#1797=VECTOR($,#1796,1);+#1798=LINE($,#1795,#1797);+#1799=EDGE_CURVE($,#1021,#1053,#1798,.T.);+#1800=ORIENTED_EDGE($,$,$,#1799,.T.);+#1801=ORIENTED_EDGE($,$,$,#1066,.T.);+#1802=CARTESIAN_POINT($,(-233.045,440.99226,0.00246000000001));+#1803=DIRECTION($,(0,0,1));+#1804=VECTOR($,#1803,1);+#1805=LINE($,#1802,#1804);+#1806=EDGE_CURVE($,#1061,#1013,#1805,.T.);+#1807=ORIENTED_EDGE($,$,$,#1806,.T.);+#1808=EDGE_LOOP($,(#1794,#1800,#1801,#1807));+#1809=FACE_OUTER_BOUND('',#1808,.T.);+#1810=ADVANCED_FACE('',(#1809),#1793,.T.);+#1811=CARTESIAN_POINT($,(-233.045,485.44226,1.90746000000001));+#1812=DIRECTION($,(-0,1,0));+#1813=DIRECTION($,(1,0,0));+#1814=AXIS2_PLACEMENT_3D($,#1811,#1812,#1813);+#1815=PLANE($,#1814);+#1816=ORIENTED_EDGE($,$,$,#1034,.T.);+#1817=CARTESIAN_POINT($,(-8.255,485.44226,1.90746000000001));+#1818=DIRECTION($,(0,0,-1));+#1819=VECTOR($,#1818,1);+#1820=LINE($,#1817,#1819);+#1821=EDGE_CURVE($,#1029,#1051,#1820,.T.);+#1822=ORIENTED_EDGE($,$,$,#1821,.T.);+#1823=ORIENTED_EDGE($,$,$,#1058,.T.);+#1824=ORIENTED_EDGE($,$,$,#1799,.F.);+#1825=EDGE_LOOP($,(#1816,#1822,#1823,#1824));+#1826=FACE_OUTER_BOUND('',#1825,.T.);+#1827=ADVANCED_FACE('',(#1826),#1815,.T.);+#1828=CARTESIAN_POINT($,(-8.255,485.44226,1.90746000000001));+#1829=DIRECTION($,(1,0,0));+#1830=DIRECTION($,(0,-1,0));+#1831=AXIS2_PLACEMENT_3D($,#1828,#1829,#1830);+#1832=PLANE($,#1831);+#1833=ORIENTED_EDGE($,$,$,#1040,.T.);+#1834=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));+#1835=DIRECTION($,(0,0,-1));+#1836=VECTOR($,#1835,1);+#1837=LINE($,#1834,#1836);+#1838=EDGE_CURVE($,#1011,#1069,#1837,.T.);+#1839=ORIENTED_EDGE($,$,$,#1838,.T.);+#1840=ORIENTED_EDGE($,$,$,#1080,.T.);+#1841=ORIENTED_EDGE($,$,$,#1821,.F.);+#1842=EDGE_LOOP($,(#1833,#1839,#1840,#1841));+#1843=FACE_OUTER_BOUND('',#1842,.T.);+#1844=ADVANCED_FACE('',(#1843),#1832,.T.);+#1845=CARTESIAN_POINT($,(-233.045,434.64226,8.25746000000001));+#1846=DIRECTION($,(-1,-0,-0));+#1847=DIRECTION($,(0,0.707106781186549,-0.707106781186546));+#1848=AXIS2_PLACEMENT_3D($,#1845,#1846,#1847);+#1849=PLANE($,#1848);+#1850=ORIENTED_EDGE($,$,$,#1097,.T.);+#1851=ORIENTED_EDGE($,$,$,#1806,.F.);+#1852=ORIENTED_EDGE($,$,$,#1123,.T.);+#1853=ORIENTED_EDGE($,$,$,#1503,.F.);+#1854=EDGE_LOOP($,(#1850,#1851,#1852,#1853));+#1855=FACE_OUTER_BOUND('',#1854,.T.);+#1856=ADVANCED_FACE('',(#1855),#1849,.T.);+#1857=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));+#1858=DIRECTION($,(1,0,0));+#1859=DIRECTION($,(0,-0.707106781186549,0.707106781186546));+#1860=AXIS2_PLACEMENT_3D($,#1857,#1858,#1859);+#1861=PLANE($,#1860);+#1862=ORIENTED_EDGE($,$,$,#1106,.T.);+#1863=ORIENTED_EDGE($,$,$,#1532,.F.);+#1864=ORIENTED_EDGE($,$,$,#1132,.T.);+#1865=ORIENTED_EDGE($,$,$,#1838,.F.);+#1866=EDGE_LOOP($,(#1862,#1863,#1864,#1865));+#1867=FACE_OUTER_BOUND('',#1866,.T.);+#1868=ADVANCED_FACE('',(#1867),#1861,.T.);+#1869=CARTESIAN_POINT($,(8.76783352130505,418.13226,119.403106478695));+#1870=DIRECTION($,(-0,1,0));+#1871=DIRECTION($,(0.707106781186548,0,0.707106781186548));+#1872=AXIS2_PLACEMENT_3D($,#1869,#1870,#1871);+#1873=PLANE($,#1872);+#1874=ORIENTED_EDGE($,$,$,#1158,.T.);+#1875=CARTESIAN_POINT($,(43.0724119037892,418.13226,153.707684861179));+#1876=DIRECTION($,(0.707106781186548,0,-0.707106781186548));+#1877=VECTOR($,#1876,1);+#1878=LINE($,#1875,#1877);+#1879=EDGE_CURVE($,#1153,#1185,#1878,.T.);+#1880=ORIENTED_EDGE($,$,$,#1879,.T.);+#1881=ORIENTED_EDGE($,$,$,#1198,.T.);+#1882=CARTESIAN_POINT($,(10.1148719394654,418.13226,118.056068060535));+#1883=DIRECTION($,(-0.707106781186549,0,0.707106781186546));+#1884=VECTOR($,#1883,1);+#1885=LINE($,#1882,#1884);+#1886=EDGE_CURVE($,#1193,#1145,#1885,.T.);+#1887=ORIENTED_EDGE($,$,$,#1886,.T.);+#1888=EDGE_LOOP($,(#1874,#1880,#1881,#1887));+#1889=FACE_OUTER_BOUND('',#1888,.T.);+#1890=ADVANCED_FACE('',(#1889),#1873,.T.);+#1891=CARTESIAN_POINT($,(43.0724119037892,418.13226,153.707684861179));+#1892=DIRECTION($,(0.707106781186548,0,0.707106781186548));+#1893=DIRECTION($,(0,-1,0));+#1894=AXIS2_PLACEMENT_3D($,#1891,#1892,#1893);+#1895=PLANE($,#1894);+#1896=ORIENTED_EDGE($,$,$,#1166,.T.);+#1897=CARTESIAN_POINT($,(43.0724119037892,66.34226,153.707684861179));+#1898=DIRECTION($,(0.707106781186548,0,-0.707106781186548));+#1899=VECTOR($,#1898,1);+#1900=LINE($,#1897,#1899);+#1901=EDGE_CURVE($,#1161,#1183,#1900,.T.);+#1902=ORIENTED_EDGE($,$,$,#1901,.T.);+#1903=ORIENTED_EDGE($,$,$,#1190,.T.);+#1904=ORIENTED_EDGE($,$,$,#1879,.F.);+#1905=EDGE_LOOP($,(#1896,#1902,#1903,#1904));+#1906=FACE_OUTER_BOUND('',#1905,.T.);+#1907=ADVANCED_FACE('',(#1906),#1895,.T.);+#1908=CARTESIAN_POINT($,(43.0724119037892,66.34226,153.707684861179));+#1909=DIRECTION($,(0,-1,-0));+#1910=DIRECTION($,(-0.707106781186548,0,-0.707106781186548));+#1911=AXIS2_PLACEMENT_3D($,#1908,#1909,#1910);+#1912=PLANE($,#1911);+#1913=ORIENTED_EDGE($,$,$,#1172,.T.);+#1914=CARTESIAN_POINT($,(8.76783352130505,66.34226,119.403106478695));+#1915=DIRECTION($,(0.707106781186549,0,-0.707106781186546));+#1916=VECTOR($,#1915,1);+#1917=LINE($,#1914,#1916);+#1918=EDGE_CURVE($,#1143,#1201,#1917,.T.);+#1919=ORIENTED_EDGE($,$,$,#1918,.T.);+#1920=ORIENTED_EDGE($,$,$,#1212,.T.);+#1921=ORIENTED_EDGE($,$,$,#1901,.F.);+#1922=EDGE_LOOP($,(#1913,#1919,#1920,#1921));+#1923=FACE_OUTER_BOUND('',#1922,.T.);+#1924=ADVANCED_FACE('',(#1923),#1912,.T.);+#1925=CARTESIAN_POINT($,(6.35,418.13226,113.56594));+#1926=DIRECTION($,(0,1,0));+#1927=DIRECTION($,(0.382683432365089,0,0.923879532511287));+#1928=AXIS2_PLACEMENT_3D($,#1925,#1926,#1927);+#1929=PLANE($,#1928);+#1930=ORIENTED_EDGE($,$,$,#1229,.T.);+#1931=ORIENTED_EDGE($,$,$,#1886,.F.);+#1932=ORIENTED_EDGE($,$,$,#1255,.T.);+#1933=ORIENTED_EDGE($,$,$,#1651,.F.);+#1934=EDGE_LOOP($,(#1930,#1931,#1932,#1933));+#1935=FACE_OUTER_BOUND('',#1934,.T.);+#1936=ADVANCED_FACE('',(#1935),#1929,.T.);+#1937=CARTESIAN_POINT($,(8.76783352130505,66.34226,119.403106478695));+#1938=DIRECTION($,(0,-1,-0));+#1939=DIRECTION($,(-0.382683432365089,0,-0.923879532511287));+#1940=AXIS2_PLACEMENT_3D($,#1937,#1938,#1939);+#1941=PLANE($,#1940);+#1942=ORIENTED_EDGE($,$,$,#1238,.T.);+#1943=ORIENTED_EDGE($,$,$,#1680,.F.);+#1944=ORIENTED_EDGE($,$,$,#1264,.T.);+#1945=ORIENTED_EDGE($,$,$,#1918,.F.);+#1946=EDGE_LOOP($,(#1942,#1943,#1944,#1945));+#1947=FACE_OUTER_BOUND('',#1946,.T.);+#1948=ADVANCED_FACE('',(#1947),#1941,.T.);+#1949=CARTESIAN_POINT($,(-136.0424,122.0724,78.105));+#1950=DIRECTION($,(-0,1,0));+#1951=DIRECTION($,(1,0,0));+#1952=AXIS2_PLACEMENT_3D($,#1949,#1950,#1951);+#1953=PLANE($,#1952);+#1954=ORIENTED_EDGE($,$,$,#128,.T.);+#1955=CARTESIAN_POINT($,(-116.9924,122.0724,78.105));+#1956=DIRECTION($,(0,0,-1));+#1957=VECTOR($,#1956,1);+#1958=LINE($,#1955,#1957);+#1959=EDGE_CURVE($,#115,#279,#1958,.T.);+#1960=ORIENTED_EDGE($,$,$,#1959,.T.);+#1961=ORIENTED_EDGE($,$,$,#284,.F.);+#1962=CARTESIAN_POINT($,(-136.0424,122.0724,76.2));+#1963=DIRECTION($,(0,0,1));+#1964=VECTOR($,#1963,1);+#1965=LINE($,#1962,#1964);+#1966=EDGE_CURVE($,#277,#123,#1965,.T.);+#1967=ORIENTED_EDGE($,$,$,#1966,.T.);+#1968=EDGE_LOOP($,(#1954,#1960,#1961,#1967));+#1969=FACE_OUTER_BOUND('',#1968,.T.);+#1970=ADVANCED_FACE('',(#1969),#1953,.T.);+#1971=CARTESIAN_POINT($,(-116.9924,122.0724,78.105));+#1972=DIRECTION($,(-1,0,0));+#1973=DIRECTION($,(0,1,0));+#1974=AXIS2_PLACEMENT_3D($,#1971,#1972,#1973);+#1975=PLANE($,#1974);+#1976=ORIENTED_EDGE($,$,$,#120,.T.);+#1977=CARTESIAN_POINT($,(-116.9924,210.9724,78.105));+#1978=DIRECTION($,(0,0,-1));+#1979=VECTOR($,#1978,1);+#1980=LINE($,#1977,#1979);+#1981=EDGE_CURVE($,#105,#287,#1980,.T.);+#1982=ORIENTED_EDGE($,$,$,#1981,.T.);+#1983=ORIENTED_EDGE($,$,$,#292,.F.);+#1984=ORIENTED_EDGE($,$,$,#1959,.F.);+#1985=EDGE_LOOP($,(#1976,#1982,#1983,#1984));+#1986=FACE_OUTER_BOUND('',#1985,.T.);+#1987=ADVANCED_FACE('',(#1986),#1975,.T.);+#1988=CARTESIAN_POINT($,(-116.9924,210.9724,78.105));+#1989=DIRECTION($,(-0,-1,-0));+#1990=DIRECTION($,(-1,0,0));+#1991=AXIS2_PLACEMENT_3D($,#1988,#1989,#1990);+#1992=PLANE($,#1991);+#1993=ORIENTED_EDGE($,$,$,#112,.T.);+#1994=CARTESIAN_POINT($,(-136.0424,210.9724,78.105));+#1995=DIRECTION($,(0,0,-1));+#1996=VECTOR($,#1995,1);+#1997=LINE($,#1994,#1996);+#1998=EDGE_CURVE($,#107,#295,#1997,.T.);+#1999=ORIENTED_EDGE($,$,$,#1998,.T.);+#2000=ORIENTED_EDGE($,$,$,#300,.F.);+#2001=ORIENTED_EDGE($,$,$,#1981,.F.);+#2002=EDGE_LOOP($,(#1993,#1999,#2000,#2001));+#2003=FACE_OUTER_BOUND('',#2002,.T.);+#2004=ADVANCED_FACE('',(#2003),#1992,.T.);+#2005=CARTESIAN_POINT($,(-136.0424,210.9724,78.105));+#2006=DIRECTION($,(1,0,0));+#2007=DIRECTION($,(0,-1,0));+#2008=AXIS2_PLACEMENT_3D($,#2005,#2006,#2007);+#2009=PLANE($,#2008);+#2010=ORIENTED_EDGE($,$,$,#134,.T.);+#2011=ORIENTED_EDGE($,$,$,#1966,.F.);+#2012=ORIENTED_EDGE($,$,$,#306,.F.);+#2013=ORIENTED_EDGE($,$,$,#1998,.F.);+#2014=EDGE_LOOP($,(#2010,#2011,#2012,#2013));+#2015=FACE_OUTER_BOUND('',#2014,.T.);+#2016=ADVANCED_FACE('',(#2015),#2009,.T.);+#2017=CARTESIAN_POINT($,(-199.5424,122.0724,78.105));+#2018=DIRECTION($,(-0,1,0));+#2019=DIRECTION($,(1,0,0));+#2020=AXIS2_PLACEMENT_3D($,#2017,#2018,#2019);+#2021=PLANE($,#2020);+#2022=ORIENTED_EDGE($,$,$,#162,.T.);+#2023=CARTESIAN_POINT($,(-180.4924,122.0724,78.105));+#2024=DIRECTION($,(0,0,-1));+#2025=VECTOR($,#2024,1);+#2026=LINE($,#2023,#2025);+#2027=EDGE_CURVE($,#149,#313,#2026,.T.);+#2028=ORIENTED_EDGE($,$,$,#2027,.T.);+#2029=ORIENTED_EDGE($,$,$,#318,.F.);+#2030=CARTESIAN_POINT($,(-199.5424,122.0724,76.2));+#2031=DIRECTION($,(0,0,1));+#2032=VECTOR($,#2031,1);+#2033=LINE($,#2030,#2032);+#2034=EDGE_CURVE($,#311,#157,#2033,.T.);+#2035=ORIENTED_EDGE($,$,$,#2034,.T.);+#2036=EDGE_LOOP($,(#2022,#2028,#2029,#2035));+#2037=FACE_OUTER_BOUND('',#2036,.T.);+#2038=ADVANCED_FACE('',(#2037),#2021,.T.);+#2039=CARTESIAN_POINT($,(-180.4924,122.0724,78.105));+#2040=DIRECTION($,(-1,0,0));+#2041=DIRECTION($,(0,1,0));+#2042=AXIS2_PLACEMENT_3D($,#2039,#2040,#2041);+#2043=PLANE($,#2042);+#2044=ORIENTED_EDGE($,$,$,#154,.T.);+#2045=CARTESIAN_POINT($,(-180.4924,210.9724,78.105));+#2046=DIRECTION($,(0,0,-1));+#2047=VECTOR($,#2046,1);+#2048=LINE($,#2045,#2047);+#2049=EDGE_CURVE($,#139,#321,#2048,.T.);+#2050=ORIENTED_EDGE($,$,$,#2049,.T.);+#2051=ORIENTED_EDGE($,$,$,#326,.F.);+#2052=ORIENTED_EDGE($,$,$,#2027,.F.);+#2053=EDGE_LOOP($,(#2044,#2050,#2051,#2052));+#2054=FACE_OUTER_BOUND('',#2053,.T.);+#2055=ADVANCED_FACE('',(#2054),#2043,.T.);+#2056=CARTESIAN_POINT($,(-180.4924,210.9724,78.105));+#2057=DIRECTION($,(-0,-1,-0));+#2058=DIRECTION($,(-1,0,0));+#2059=AXIS2_PLACEMENT_3D($,#2056,#2057,#2058);+#2060=PLANE($,#2059);+#2061=ORIENTED_EDGE($,$,$,#146,.T.);+#2062=CARTESIAN_POINT($,(-199.5424,210.9724,78.105));+#2063=DIRECTION($,(0,0,-1));+#2064=VECTOR($,#2063,1);+#2065=LINE($,#2062,#2064);+#2066=EDGE_CURVE($,#141,#329,#2065,.T.);+#2067=ORIENTED_EDGE($,$,$,#2066,.T.);+#2068=ORIENTED_EDGE($,$,$,#334,.F.);+#2069=ORIENTED_EDGE($,$,$,#2049,.F.);+#2070=EDGE_LOOP($,(#2061,#2067,#2068,#2069));+#2071=FACE_OUTER_BOUND('',#2070,.T.);+#2072=ADVANCED_FACE('',(#2071),#2060,.T.);+#2073=CARTESIAN_POINT($,(-199.5424,210.9724,78.105));+#2074=DIRECTION($,(1,0,0));+#2075=DIRECTION($,(0,-1,0));+#2076=AXIS2_PLACEMENT_3D($,#2073,#2074,#2075);+#2077=PLANE($,#2076);+#2078=ORIENTED_EDGE($,$,$,#168,.T.);+#2079=ORIENTED_EDGE($,$,$,#2034,.F.);+#2080=ORIENTED_EDGE($,$,$,#340,.F.);+#2081=ORIENTED_EDGE($,$,$,#2066,.F.);+#2082=EDGE_LOOP($,(#2078,#2079,#2080,#2081));+#2083=FACE_OUTER_BOUND('',#2082,.T.);+#2084=ADVANCED_FACE('',(#2083),#2077,.T.);+#2085=CLOSED_SHELL($,(#172,#344,#384,#424,#450,#476,#516,#556,#582,#608,#648,#688,#714,#740,#780,#820,#846,#872,#912,#952,#978,#1004,#1044,#1084,#1110,#1136,#1176,#1216,#1242,#1268,#1290,#1312,#1329,#1351,#1368,#1390,#1407,#1424,#1446,#1468,#1480,#1492,#1514,#1536,#1548,#1560,#1582,#1599,#1616,#1628,#1640,#1662,#1684,#1696,#1708,#1730,#1747,#1764,#1776,#1788,#1810,#1827,#1844,#1856,#1868,#1890,#1907,#1924,#1936,#1948,#1970,#1987,#2004,#2016,#2038,#2055,#2072,#2084));+#2086=MANIFOLD_SOLID_BREP('AetherisBody',#2085);+#2087=APPLICATION_CONTEXT('mechanical design');+#2088=PRODUCT_CONTEXT('',#2087,'mechanical');+#2089=PRODUCT('AETHERIS','AetherisBody','',(#2088));+#2090=PRODUCT_DEFINITION_FORMATION('','',#2089);+#2091=PRODUCT_DEFINITION_CONTEXT('design',#2087,'design');+#2092=PRODUCT_DEFINITION('','',#2090,#2091);+#2093=PRODUCT_DEFINITION_SHAPE('','',#2092);+#2094=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));+#2095=(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.));+#2096=(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT());+#2097=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNIT_ASSIGNED_CONTEXT((#2094,#2095,#2096))REPRESENTATION_CONTEXT('3','3D'));+#2098=SHAPE_REPRESENTATION('AetherisBody',(#2086),#2097);+#2099=SHAPE_DEFINITION_REPRESENTATION(#2093,#2098);+ENDSEC;+END-ISO-10303-21;diff --git a/docs/modules/sheetmetal/artifacts/m4/dfm-summary.md b/docs/modules/sheetmetal/artifacts/m4/dfm-summary.mdnew file mode 100644index 00000000..d888fa23--- /dev/null+++ b/docs/modules/sheetmetal/artifacts/m4/dfm-summary.md@@ -0,0 +1,14 @@+# M4 DFM summary++New/strengthened rules:++- exact analytic blank must exist and pass contour validation;+- exact rectangular/round relief topology must exist;+- relief width `>= thickness`;+- relief depth `>= inside radius + thickness`;+- minimum tangent-to-edge flange length;+- existing inside-radius ratio, cut-to-bend, cut-to-edge, overlap, duplicate-cut, bend-line containment, and zero-width checks remain active.++Suggestions are structured and numeric (`increase relief depth to 2.7 mm`, `increase flange Height/Length by X`) and are never auto-applied. Findings use semantic subjects such as `corner-Front-Right`, `FrontWall`, and `relief-Front-Right`.++Template output uses normal `SheetMetalDfm.Evaluate`; no template duplicates DFM logic. The deliberate bad/fixed tray pair demonstrates semantic-only repair. The PSU enclosure passes. The four-relief M3 tray and CTC-03 fail the strict exact-blank rule, correctly preventing M4 from presenting compatibility boundaries as fabrication authority.diff --git a/docs/modules/sheetmetal/artifacts/m4/psu-enclosure-flat.step b/docs/modules/sheetmetal/artifacts/m4/psu-enclosure-flat.stepnew file mode 100644index 00000000..76b1e98d--- /dev/null+++ b/docs/modules/sheetmetal/artifacts/m4/psu-enclosure-flat.step@@ -0,0 +1,1752 @@+ISO-10303-21;+HEADER;+FILE_DESCRIPTION(('Aetheris AP242 subset export'),'2;1');+FILE_NAME('aetheris_export.step','1970-01-01T00:00:00',('Aetheris'),('Aetheris'),'Aetheris.Kernel','Aetheris.Kernel','');+FILE_SCHEMA(('AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF'));+ENDSEC;+DATA;+#1=CARTESIAN_POINT($,(0,0,0));+#2=DIRECTION($,(0,0,-1));+#3=DIRECTION($,(1,0,0));+#4=AXIS2_PLACEMENT_3D($,#1,#2,#3);+#5=PLANE($,#4);+#6=CARTESIAN_POINT($,(50.847875838897,10,0));+#7=VERTEX_POINT($,#6);+#8=CARTESIAN_POINT($,(226.047875838897,10,-0));+#9=VERTEX_POINT($,#8);+#10=CARTESIAN_POINT($,(50.847875838897,10,0));+#11=DIRECTION($,(1,0,0));+#12=VECTOR($,#11,1);+#13=LINE($,#10,#12);+#14=EDGE_CURVE($,#7,#9,#13,.T.);+#15=ORIENTED_EDGE($,$,$,#14,.T.);+#16=CARTESIAN_POINT($,(226.047875838897,20,0));+#17=VERTEX_POINT($,#16);+#18=CARTESIAN_POINT($,(226.047875838897,10,-0));+#19=DIRECTION($,(0,1,0));+#20=VECTOR($,#19,1);+#21=LINE($,#18,#20);+#22=EDGE_CURVE($,#9,#17,#21,.T.);+#23=ORIENTED_EDGE($,$,$,#22,.T.);+#24=CARTESIAN_POINT($,(226.047875838897,22.6766369408585,0));+#25=VERTEX_POINT($,#24);+#26=CARTESIAN_POINT($,(226.047875838897,20,0));+#27=DIRECTION($,(0,1,0));+#28=VECTOR($,#27,1);+#29=LINE($,#26,#28);+#30=EDGE_CURVE($,#17,#25,#29,.T.);+#31=ORIENTED_EDGE($,$,$,#30,.T.);+#32=CARTESIAN_POINT($,(226.047875838897,57.6766369408585,0));+#33=VERTEX_POINT($,#32);+#34=CARTESIAN_POINT($,(226.047875838897,22.6766369408585,0));+#35=DIRECTION($,(0,1,0));+#36=VECTOR($,#35,1);+#37=LINE($,#34,#36);+#38=EDGE_CURVE($,#25,#33,#37,.T.);+#39=ORIENTED_EDGE($,$,$,#38,.T.);+#40=CARTESIAN_POINT($,(226.047875838897,60.8245127797555,0));+#41=VERTEX_POINT($,#40);+#42=CARTESIAN_POINT($,(226.047875838897,57.6766369408585,0));+#43=DIRECTION($,(0,1,0));+#44=VECTOR($,#43,1);+#45=LINE($,#42,#44);+#46=EDGE_CURVE($,#33,#41,#45,.T.);+#47=ORIENTED_EDGE($,$,$,#46,.T.);+#48=CARTESIAN_POINT($,(228.147875838897,60.8245127797555,-0));+#49=VERTEX_POINT($,#48);+#50=CARTESIAN_POINT($,(226.047875838897,60.8245127797555,0));+#51=DIRECTION($,(1,0,0));+#52=VECTOR($,#51,1);+#53=LINE($,#50,#52);+#54=EDGE_CURVE($,#41,#49,#53,.T.);+#55=ORIENTED_EDGE($,$,$,#54,.T.);+#56=CARTESIAN_POINT($,(228.147875838897,62.9245127797555,0));+#57=VERTEX_POINT($,#56);+#58=CARTESIAN_POINT($,(228.147875838897,60.8245127797555,-0));+#59=DIRECTION($,(0,1,0));+#60=VECTOR($,#59,1);+#61=LINE($,#58,#60);+#62=EDGE_CURVE($,#49,#57,#61,.T.);+#63=ORIENTED_EDGE($,$,$,#62,.T.);+#64=CARTESIAN_POINT($,(231.295751677794,62.9245127797555,0));+#65=VERTEX_POINT($,#64);+#66=CARTESIAN_POINT($,(228.147875838897,62.9245127797555,0));+#67=DIRECTION($,(1,0,0));+#68=VECTOR($,#67,1);+#69=LINE($,#66,#68);+#70=EDGE_CURVE($,#57,#65,#69,.T.);+#71=ORIENTED_EDGE($,$,$,#70,.T.);+#72=CARTESIAN_POINT($,(266.295751677794,62.9245127797555,-0));+#73=VERTEX_POINT($,#72);+#74=CARTESIAN_POINT($,(231.295751677794,62.9245127797555,0));+#75=DIRECTION($,(1,0,0));+#76=VECTOR($,#75,1);+#77=LINE($,#74,#76);+#78=EDGE_CURVE($,#65,#73,#77,.T.);+#79=ORIENTED_EDGE($,$,$,#78,.T.);+#80=CARTESIAN_POINT($,(266.295751677794,178.124512779755,-0));+#81=VERTEX_POINT($,#80);+#82=CARTESIAN_POINT($,(266.295751677794,62.9245127797555,-0));+#83=DIRECTION($,(0,1,0));+#84=VECTOR($,#83,1);+#85=LINE($,#82,#84);+#86=EDGE_CURVE($,#73,#81,#85,.T.);+#87=ORIENTED_EDGE($,$,$,#86,.T.);+#88=CARTESIAN_POINT($,(231.295751677794,178.124512779755,0));+#89=VERTEX_POINT($,#88);+#90=CARTESIAN_POINT($,(266.295751677794,178.124512779755,-0));+#91=DIRECTION($,(-1,0,0));+#92=VECTOR($,#91,1);+#93=LINE($,#90,#92);+#94=EDGE_CURVE($,#81,#89,#93,.T.);+#95=ORIENTED_EDGE($,$,$,#94,.T.);+#96=CARTESIAN_POINT($,(228.147875838897,178.124512779755,0));+#97=VERTEX_POINT($,#96);+#98=CARTESIAN_POINT($,(231.295751677794,178.124512779755,0));+#99=DIRECTION($,(-1,0,0));+#100=VECTOR($,#99,1);+#101=LINE($,#98,#100);+#102=EDGE_CURVE($,#89,#97,#101,.T.);+#103=ORIENTED_EDGE($,$,$,#102,.T.);+#104=CARTESIAN_POINT($,(228.147875838897,180.824512779755,-0));+#105=VERTEX_POINT($,#104);+#106=CARTESIAN_POINT($,(228.147875838897,178.124512779755,0));+#107=DIRECTION($,(0,1,0));+#108=VECTOR($,#107,1);+#109=LINE($,#106,#108);+#110=EDGE_CURVE($,#97,#105,#109,.T.);+#111=ORIENTED_EDGE($,$,$,#110,.T.);+#112=CARTESIAN_POINT($,(225.447875838897,180.824512779755,0));+#113=VERTEX_POINT($,#112);+#114=CARTESIAN_POINT($,(228.147875838897,180.824512779755,-0));+#115=DIRECTION($,(-1,0,0));+#116=VECTOR($,#115,1);+#117=LINE($,#114,#116);+#118=EDGE_CURVE($,#105,#113,#117,.T.);+#119=ORIENTED_EDGE($,$,$,#118,.T.);+#120=CARTESIAN_POINT($,(225.447875838897,183.972388618652,0));+#121=VERTEX_POINT($,#120);+#122=CARTESIAN_POINT($,(225.447875838897,180.824512779755,0));+#123=DIRECTION($,(0,1,0));+#124=VECTOR($,#123,1);+#125=LINE($,#122,#124);+#126=EDGE_CURVE($,#113,#121,#125,.T.);+#127=ORIENTED_EDGE($,$,$,#126,.T.);+#128=CARTESIAN_POINT($,(225.447875838897,218.972388618652,-0));+#129=VERTEX_POINT($,#128);+#130=CARTESIAN_POINT($,(225.447875838897,183.972388618652,0));+#131=DIRECTION($,(0,1,0));+#132=VECTOR($,#131,1);+#133=LINE($,#130,#132);+#134=EDGE_CURVE($,#121,#129,#133,.T.);+#135=ORIENTED_EDGE($,$,$,#134,.T.);+#136=CARTESIAN_POINT($,(50.847875838897,218.972388618652,-0));+#137=VERTEX_POINT($,#136);+#138=CARTESIAN_POINT($,(225.447875838897,218.972388618652,-0));+#139=DIRECTION($,(-1,0,0));+#140=VECTOR($,#139,1);+#141=LINE($,#138,#140);+#142=EDGE_CURVE($,#129,#137,#141,.T.);+#143=ORIENTED_EDGE($,$,$,#142,.T.);+#144=CARTESIAN_POINT($,(50.847875838897,183.972388618652,0));+#145=VERTEX_POINT($,#144);+#146=CARTESIAN_POINT($,(50.847875838897,218.972388618652,-0));+#147=DIRECTION($,(0,-1,0));+#148=VECTOR($,#147,1);+#149=LINE($,#146,#148);+#150=EDGE_CURVE($,#137,#145,#149,.T.);+#151=ORIENTED_EDGE($,$,$,#150,.T.);+#152=CARTESIAN_POINT($,(50.847875838897,180.824512779755,0));+#153=VERTEX_POINT($,#152);+#154=CARTESIAN_POINT($,(50.847875838897,183.972388618652,0));+#155=DIRECTION($,(0,-1,0));+#156=VECTOR($,#155,1);+#157=LINE($,#154,#156);+#158=EDGE_CURVE($,#145,#153,#157,.T.);+#159=ORIENTED_EDGE($,$,$,#158,.T.);+#160=CARTESIAN_POINT($,(48.147875838897,180.824512779755,-0));+#161=VERTEX_POINT($,#160);+#162=CARTESIAN_POINT($,(50.847875838897,180.824512779755,0));+#163=DIRECTION($,(-1,0,0));+#164=VECTOR($,#163,1);+#165=LINE($,#162,#164);+#166=EDGE_CURVE($,#153,#161,#165,.T.);+#167=ORIENTED_EDGE($,$,$,#166,.T.);+#168=CARTESIAN_POINT($,(48.147875838897,178.124512779755,0));+#169=VERTEX_POINT($,#168);+#170=CARTESIAN_POINT($,(48.147875838897,180.824512779755,-0));+#171=DIRECTION($,(0,-1,0));+#172=VECTOR($,#171,1);+#173=LINE($,#170,#172);+#174=EDGE_CURVE($,#161,#169,#173,.T.);+#175=ORIENTED_EDGE($,$,$,#174,.T.);+#176=CARTESIAN_POINT($,(45,178.124512779755,0));+#177=VERTEX_POINT($,#176);+#178=CARTESIAN_POINT($,(48.147875838897,178.124512779755,0));+#179=DIRECTION($,(-1,0,0));+#180=VECTOR($,#179,1);+#181=LINE($,#178,#180);+#182=EDGE_CURVE($,#169,#177,#181,.T.);+#183=ORIENTED_EDGE($,$,$,#182,.T.);+#184=CARTESIAN_POINT($,(10,178.124512779755,-0));+#185=VERTEX_POINT($,#184);+#186=CARTESIAN_POINT($,(45,178.124512779755,0));+#187=DIRECTION($,(-1,0,0));+#188=VECTOR($,#187,1);+#189=LINE($,#186,#188);+#190=EDGE_CURVE($,#177,#185,#189,.T.);+#191=ORIENTED_EDGE($,$,$,#190,.T.);+#192=CARTESIAN_POINT($,(10,63.5245127797555,-0));+#193=VERTEX_POINT($,#192);+#194=CARTESIAN_POINT($,(10,178.124512779755,-0));+#195=DIRECTION($,(0,-1,0));+#196=VECTOR($,#195,1);+#197=LINE($,#194,#196);+#198=EDGE_CURVE($,#185,#193,#197,.T.);+#199=ORIENTED_EDGE($,$,$,#198,.T.);+#200=CARTESIAN_POINT($,(45,63.5245127797555,0));+#201=VERTEX_POINT($,#200);+#202=CARTESIAN_POINT($,(10,63.5245127797555,-0));+#203=DIRECTION($,(1,0,0));+#204=VECTOR($,#203,1);+#205=LINE($,#202,#204);+#206=EDGE_CURVE($,#193,#201,#205,.T.);+#207=ORIENTED_EDGE($,$,$,#206,.T.);+#208=CARTESIAN_POINT($,(48.147875838897,63.5245127797555,0));+#209=VERTEX_POINT($,#208);+#210=CARTESIAN_POINT($,(45,63.5245127797555,0));+#211=DIRECTION($,(1,0,0));+#212=VECTOR($,#211,1);+#213=LINE($,#210,#212);+#214=EDGE_CURVE($,#201,#209,#213,.T.);+#215=ORIENTED_EDGE($,$,$,#214,.T.);+#216=CARTESIAN_POINT($,(48.147875838897,60.8245127797555,-0));+#217=VERTEX_POINT($,#216);+#218=CARTESIAN_POINT($,(48.147875838897,63.5245127797555,0));+#219=DIRECTION($,(0,-1,0));+#220=VECTOR($,#219,1);+#221=LINE($,#218,#220);+#222=EDGE_CURVE($,#209,#217,#221,.T.);+#223=ORIENTED_EDGE($,$,$,#222,.T.);+#224=CARTESIAN_POINT($,(50.847875838897,60.8245127797555,0));+#225=VERTEX_POINT($,#224);+#226=CARTESIAN_POINT($,(48.147875838897,60.8245127797555,-0));+#227=DIRECTION($,(1,0,0));+#228=VECTOR($,#227,1);+#229=LINE($,#226,#228);+#230=EDGE_CURVE($,#217,#225,#229,.T.);+#231=ORIENTED_EDGE($,$,$,#230,.T.);+#232=CARTESIAN_POINT($,(50.847875838897,57.6766369408585,0));+#233=VERTEX_POINT($,#232);+#234=CARTESIAN_POINT($,(50.847875838897,60.8245127797555,0));+#235=DIRECTION($,(0,-1,0));+#236=VECTOR($,#235,1);+#237=LINE($,#234,#236);+#238=EDGE_CURVE($,#225,#233,#237,.T.);+#239=ORIENTED_EDGE($,$,$,#238,.T.);+#240=CARTESIAN_POINT($,(50.847875838897,22.6766369408585,0));+#241=VERTEX_POINT($,#240);+#242=CARTESIAN_POINT($,(50.847875838897,57.6766369408585,0));+#243=DIRECTION($,(0,-1,0));+#244=VECTOR($,#243,1);+#245=LINE($,#242,#244);+#246=EDGE_CURVE($,#233,#241,#245,.T.);+#247=ORIENTED_EDGE($,$,$,#246,.T.);+#248=CARTESIAN_POINT($,(50.847875838897,20,0));+#249=VERTEX_POINT($,#248);+#250=CARTESIAN_POINT($,(50.847875838897,22.6766369408585,0));+#251=DIRECTION($,(0,-1,0));+#252=VECTOR($,#251,1);+#253=LINE($,#250,#252);+#254=EDGE_CURVE($,#241,#249,#253,.T.);+#255=ORIENTED_EDGE($,$,$,#254,.T.);+#256=CARTESIAN_POINT($,(50.847875838897,20,0));+#257=DIRECTION($,(0,-1,0));+#258=VECTOR($,#257,1);+#259=LINE($,#256,#258);+#260=EDGE_CURVE($,#249,#7,#259,.T.);+#261=ORIENTED_EDGE($,$,$,#260,.T.);+#262=EDGE_LOOP($,(#15,#23,#31,#39,#47,#55,#63,#71,#79,#87,#95,#103,#111,#119,#127,#135,#143,#151,#159,#167,#175,#183,#191,#199,#207,#215,#223,#231,#239,#247,#255,#261));+#263=FACE_OUTER_BOUND('',#262,.T.);+#264=CARTESIAN_POINT($,(61.147875838897,75.8245127797555,0));+#265=VERTEX_POINT($,#264);+#266=CARTESIAN_POINT($,(65.147875838897,75.8245127797555,0));+#267=VERTEX_POINT($,#266);+#268=CARTESIAN_POINT($,(63.147875838897,75.8245127797555,0));+#269=DIRECTION($,(0,0,1));+#270=DIRECTION($,(1,0,0));+#271=AXIS2_PLACEMENT_3D($,#268,#269,#270);+#272=CIRCLE($,#271,2);+#273=TRIMMED_CURVE($,#272,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);+#274=EDGE_CURVE($,#265,#267,#273,.T.);+#275=ORIENTED_EDGE($,$,$,#274,.T.);+#276=ORIENTED_EDGE($,$,$,#274,.F.);+#277=EDGE_LOOP($,(#275,#276));+#278=FACE_BOUND('',#277,.T.);+#279=CARTESIAN_POINT($,(211.147875838897,75.8245127797555,0));+#280=VERTEX_POINT($,#279);+#281=CARTESIAN_POINT($,(215.147875838897,75.8245127797555,0));+#282=VERTEX_POINT($,#281);+#283=CARTESIAN_POINT($,(213.147875838897,75.8245127797555,0));+#284=DIRECTION($,(0,0,1));+#285=DIRECTION($,(1,0,0));+#286=AXIS2_PLACEMENT_3D($,#283,#284,#285);+#287=CIRCLE($,#286,2);+#288=TRIMMED_CURVE($,#287,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);+#289=EDGE_CURVE($,#280,#282,#288,.T.);+#290=ORIENTED_EDGE($,$,$,#289,.T.);+#291=ORIENTED_EDGE($,$,$,#289,.F.);+#292=EDGE_LOOP($,(#290,#291));+#293=FACE_BOUND('',#292,.T.);+#294=CARTESIAN_POINT($,(61.147875838897,165.824512779755,0));+#295=VERTEX_POINT($,#294);+#296=CARTESIAN_POINT($,(65.147875838897,165.824512779755,0));+#297=VERTEX_POINT($,#296);+#298=CARTESIAN_POINT($,(63.147875838897,165.824512779755,0));+#299=DIRECTION($,(0,0,1));+#300=DIRECTION($,(1,0,0));+#301=AXIS2_PLACEMENT_3D($,#298,#299,#300);+#302=CIRCLE($,#301,2);+#303=TRIMMED_CURVE($,#302,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);+#304=EDGE_CURVE($,#295,#297,#303,.T.);+#305=ORIENTED_EDGE($,$,$,#304,.T.);+#306=ORIENTED_EDGE($,$,$,#304,.F.);+#307=EDGE_LOOP($,(#305,#306));+#308=FACE_BOUND('',#307,.T.);+#309=CARTESIAN_POINT($,(211.147875838897,165.824512779755,0));+#310=VERTEX_POINT($,#309);+#311=CARTESIAN_POINT($,(215.147875838897,165.824512779755,0));+#312=VERTEX_POINT($,#311);+#313=CARTESIAN_POINT($,(213.147875838897,165.824512779755,0));+#314=DIRECTION($,(0,0,1));+#315=DIRECTION($,(1,0,0));+#316=AXIS2_PLACEMENT_3D($,#313,#314,#315);+#317=CIRCLE($,#316,2);+#318=TRIMMED_CURVE($,#317,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);+#319=EDGE_CURVE($,#310,#312,#318,.T.);+#320=ORIENTED_EDGE($,$,$,#319,.T.);+#321=ORIENTED_EDGE($,$,$,#319,.F.);+#322=EDGE_LOOP($,(#320,#321));+#323=FACE_BOUND('',#322,.T.);+#324=CARTESIAN_POINT($,(132.647875838897,117.824512779755,0));+#325=VERTEX_POINT($,#324);+#326=CARTESIAN_POINT($,(143.647875838897,117.824512779755,0));+#327=VERTEX_POINT($,#326);+#328=CARTESIAN_POINT($,(132.647875838897,117.824512779755,0));+#329=DIRECTION($,(1,0,0));+#330=VECTOR($,#329,1);+#331=LINE($,#328,#330);+#332=EDGE_CURVE($,#325,#327,#331,.T.);+#333=ORIENTED_EDGE($,$,$,#332,.F.);+#334=CARTESIAN_POINT($,(115.647875838897,117.824512779755,0));+#335=VERTEX_POINT($,#334);+#336=CARTESIAN_POINT($,(115.647875838897,117.824512779755,0));+#337=DIRECTION($,(1,0,0));+#338=VECTOR($,#337,1);+#339=LINE($,#336,#338);+#340=EDGE_CURVE($,#335,#325,#339,.T.);+#341=ORIENTED_EDGE($,$,$,#340,.F.);+#342=CARTESIAN_POINT($,(87.647875838897,117.824512779755,-0));+#343=VERTEX_POINT($,#342);+#344=CARTESIAN_POINT($,(87.647875838897,117.824512779755,-0));+#345=DIRECTION($,(1,0,0));+#346=VECTOR($,#345,1);+#347=LINE($,#344,#346);+#348=EDGE_CURVE($,#343,#335,#347,.T.);+#349=ORIENTED_EDGE($,$,$,#348,.F.);+#350=CARTESIAN_POINT($,(87.647875838897,123.824512779755,-0));+#351=VERTEX_POINT($,#350);+#352=CARTESIAN_POINT($,(87.647875838897,123.824512779755,-0));+#353=DIRECTION($,(0,-1,0));+#354=VECTOR($,#353,1);+#355=LINE($,#352,#354);+#356=EDGE_CURVE($,#351,#343,#355,.T.);+#357=ORIENTED_EDGE($,$,$,#356,.F.);+#358=CARTESIAN_POINT($,(115.647875838897,123.824512779755,0));+#359=VERTEX_POINT($,#358);+#360=CARTESIAN_POINT($,(115.647875838897,123.824512779755,0));+#361=DIRECTION($,(-1,0,0));+#362=VECTOR($,#361,1);+#363=LINE($,#360,#362);+#364=EDGE_CURVE($,#359,#351,#363,.T.);+#365=ORIENTED_EDGE($,$,$,#364,.F.);+#366=CARTESIAN_POINT($,(132.647875838897,123.824512779755,0));+#367=VERTEX_POINT($,#366);+#368=CARTESIAN_POINT($,(132.647875838897,123.824512779755,0));+#369=DIRECTION($,(-1,0,0));+#370=VECTOR($,#369,1);+#371=LINE($,#368,#370);+#372=EDGE_CURVE($,#367,#359,#371,.T.);+#373=ORIENTED_EDGE($,$,$,#372,.F.);+#374=CARTESIAN_POINT($,(143.647875838897,123.824512779755,0));+#375=VERTEX_POINT($,#374);+#376=CARTESIAN_POINT($,(143.647875838897,123.824512779755,0));+#377=DIRECTION($,(-1,0,0));+#378=VECTOR($,#377,1);+#379=LINE($,#376,#378);+#380=EDGE_CURVE($,#375,#367,#379,.T.);+#381=ORIENTED_EDGE($,$,$,#380,.F.);+#382=CARTESIAN_POINT($,(160.647875838897,123.824512779755,0));+#383=VERTEX_POINT($,#382);+#384=CARTESIAN_POINT($,(160.647875838897,123.824512779755,0));+#385=DIRECTION($,(-1,0,0));+#386=VECTOR($,#385,1);+#387=LINE($,#384,#386);+#388=EDGE_CURVE($,#383,#375,#387,.T.);+#389=ORIENTED_EDGE($,$,$,#388,.F.);+#390=CARTESIAN_POINT($,(188.647875838897,123.824512779755,-0));+#391=VERTEX_POINT($,#390);+#392=CARTESIAN_POINT($,(188.647875838897,123.824512779755,-0));+#393=DIRECTION($,(-1,0,0));+#394=VECTOR($,#393,1);+#395=LINE($,#392,#394);+#396=EDGE_CURVE($,#391,#383,#395,.T.);+#397=ORIENTED_EDGE($,$,$,#396,.F.);+#398=CARTESIAN_POINT($,(188.647875838897,117.824512779755,-0));+#399=VERTEX_POINT($,#398);+#400=CARTESIAN_POINT($,(188.647875838897,117.824512779755,-0));+#401=DIRECTION($,(0,1,0));+#402=VECTOR($,#401,1);+#403=LINE($,#400,#402);+#404=EDGE_CURVE($,#399,#391,#403,.T.);+#405=ORIENTED_EDGE($,$,$,#404,.F.);+#406=CARTESIAN_POINT($,(160.647875838897,117.824512779755,0));+#407=VERTEX_POINT($,#406);+#408=CARTESIAN_POINT($,(160.647875838897,117.824512779755,0));+#409=DIRECTION($,(1,0,0));+#410=VECTOR($,#409,1);+#411=LINE($,#408,#410);+#412=EDGE_CURVE($,#407,#399,#411,.T.);+#413=ORIENTED_EDGE($,$,$,#412,.F.);+#414=CARTESIAN_POINT($,(143.647875838897,117.824512779755,0));+#415=DIRECTION($,(1,0,0));+#416=VECTOR($,#415,1);+#417=LINE($,#414,#416);+#418=EDGE_CURVE($,#327,#407,#417,.T.);+#419=ORIENTED_EDGE($,$,$,#418,.F.);+#420=EDGE_LOOP($,(#333,#341,#349,#357,#365,#373,#381,#389,#397,#405,#413,#419));+#421=FACE_BOUND('',#420,.T.);+#422=ADVANCED_FACE('',(#263,#278,#293,#308,#323,#421),#5,.T.);+#423=CARTESIAN_POINT($,(0,0,1.2));+#424=DIRECTION($,(0,0,1));+#425=DIRECTION($,(1,0,0));+#426=AXIS2_PLACEMENT_3D($,#423,#424,#425);+#427=PLANE($,#426);+#428=CARTESIAN_POINT($,(50.847875838897,10,1.2));+#429=VERTEX_POINT($,#428);+#430=CARTESIAN_POINT($,(226.047875838897,10,1.2));+#431=VERTEX_POINT($,#430);+#432=CARTESIAN_POINT($,(50.847875838897,10,1.2));+#433=DIRECTION($,(1,0,0));+#434=VECTOR($,#433,1);+#435=LINE($,#432,#434);+#436=EDGE_CURVE($,#429,#431,#435,.T.);+#437=ORIENTED_EDGE($,$,$,#436,.T.);+#438=CARTESIAN_POINT($,(226.047875838897,20,1.2));+#439=VERTEX_POINT($,#438);+#440=CARTESIAN_POINT($,(226.047875838897,10,1.2));+#441=DIRECTION($,(0,1,0));+#442=VECTOR($,#441,1);+#443=LINE($,#440,#442);+#444=EDGE_CURVE($,#431,#439,#443,.T.);+#445=ORIENTED_EDGE($,$,$,#444,.T.);+#446=CARTESIAN_POINT($,(226.047875838897,22.6766369408585,1.2));+#447=VERTEX_POINT($,#446);+#448=CARTESIAN_POINT($,(226.047875838897,20,1.2));+#449=DIRECTION($,(0,1,0));+#450=VECTOR($,#449,1);+#451=LINE($,#448,#450);+#452=EDGE_CURVE($,#439,#447,#451,.T.);+#453=ORIENTED_EDGE($,$,$,#452,.T.);+#454=CARTESIAN_POINT($,(226.047875838897,57.6766369408585,1.2));+#455=VERTEX_POINT($,#454);+#456=CARTESIAN_POINT($,(226.047875838897,22.6766369408585,1.2));+#457=DIRECTION($,(0,1,0));+#458=VECTOR($,#457,1);+#459=LINE($,#456,#458);+#460=EDGE_CURVE($,#447,#455,#459,.T.);+#461=ORIENTED_EDGE($,$,$,#460,.T.);+#462=CARTESIAN_POINT($,(226.047875838897,60.8245127797555,1.2));+#463=VERTEX_POINT($,#462);+#464=CARTESIAN_POINT($,(226.047875838897,57.6766369408585,1.2));+#465=DIRECTION($,(0,1,0));+#466=VECTOR($,#465,1);+#467=LINE($,#464,#466);+#468=EDGE_CURVE($,#455,#463,#467,.T.);+#469=ORIENTED_EDGE($,$,$,#468,.T.);+#470=CARTESIAN_POINT($,(228.147875838897,60.8245127797555,1.2));+#471=VERTEX_POINT($,#470);+#472=CARTESIAN_POINT($,(226.047875838897,60.8245127797555,1.2));+#473=DIRECTION($,(1,0,0));+#474=VECTOR($,#473,1);+#475=LINE($,#472,#474);+#476=EDGE_CURVE($,#463,#471,#475,.T.);+#477=ORIENTED_EDGE($,$,$,#476,.T.);+#478=CARTESIAN_POINT($,(228.147875838897,62.9245127797555,1.2));+#479=VERTEX_POINT($,#478);+#480=CARTESIAN_POINT($,(228.147875838897,60.8245127797555,1.2));+#481=DIRECTION($,(0,1,0));+#482=VECTOR($,#481,1);+#483=LINE($,#480,#482);+#484=EDGE_CURVE($,#471,#479,#483,.T.);+#485=ORIENTED_EDGE($,$,$,#484,.T.);+#486=CARTESIAN_POINT($,(231.295751677794,62.9245127797555,1.2));+#487=VERTEX_POINT($,#486);+#488=CARTESIAN_POINT($,(228.147875838897,62.9245127797555,1.2));+#489=DIRECTION($,(1,0,0));+#490=VECTOR($,#489,1);+#491=LINE($,#488,#490);+#492=EDGE_CURVE($,#479,#487,#491,.T.);+#493=ORIENTED_EDGE($,$,$,#492,.T.);+#494=CARTESIAN_POINT($,(266.295751677794,62.9245127797555,1.2));+#495=VERTEX_POINT($,#494);+#496=CARTESIAN_POINT($,(231.295751677794,62.9245127797555,1.2));+#497=DIRECTION($,(1,0,0));+#498=VECTOR($,#497,1);+#499=LINE($,#496,#498);+#500=EDGE_CURVE($,#487,#495,#499,.T.);+#501=ORIENTED_EDGE($,$,$,#500,.T.);+#502=CARTESIAN_POINT($,(266.295751677794,178.124512779755,1.2));+#503=VERTEX_POINT($,#502);+#504=CARTESIAN_POINT($,(266.295751677794,62.9245127797555,1.2));+#505=DIRECTION($,(0,1,0));+#506=VECTOR($,#505,1);+#507=LINE($,#504,#506);+#508=EDGE_CURVE($,#495,#503,#507,.T.);+#509=ORIENTED_EDGE($,$,$,#508,.T.);+#510=CARTESIAN_POINT($,(231.295751677794,178.124512779755,1.2));+#511=VERTEX_POINT($,#510);+#512=CARTESIAN_POINT($,(266.295751677794,178.124512779755,1.2));+#513=DIRECTION($,(-1,0,0));+#514=VECTOR($,#513,1);+#515=LINE($,#512,#514);+#516=EDGE_CURVE($,#503,#511,#515,.T.);+#517=ORIENTED_EDGE($,$,$,#516,.T.);+#518=CARTESIAN_POINT($,(228.147875838897,178.124512779755,1.2));+#519=VERTEX_POINT($,#518);+#520=CARTESIAN_POINT($,(231.295751677794,178.124512779755,1.2));+#521=DIRECTION($,(-1,0,0));+#522=VECTOR($,#521,1);+#523=LINE($,#520,#522);+#524=EDGE_CURVE($,#511,#519,#523,.T.);+#525=ORIENTED_EDGE($,$,$,#524,.T.);+#526=CARTESIAN_POINT($,(228.147875838897,180.824512779755,1.2));+#527=VERTEX_POINT($,#526);+#528=CARTESIAN_POINT($,(228.147875838897,178.124512779755,1.2));+#529=DIRECTION($,(0,1,0));+#530=VECTOR($,#529,1);+#531=LINE($,#528,#530);+#532=EDGE_CURVE($,#519,#527,#531,.T.);+#533=ORIENTED_EDGE($,$,$,#532,.T.);+#534=CARTESIAN_POINT($,(225.447875838897,180.824512779755,1.2));+#535=VERTEX_POINT($,#534);+#536=CARTESIAN_POINT($,(228.147875838897,180.824512779755,1.2));+#537=DIRECTION($,(-1,0,0));+#538=VECTOR($,#537,1);+#539=LINE($,#536,#538);+#540=EDGE_CURVE($,#527,#535,#539,.T.);+#541=ORIENTED_EDGE($,$,$,#540,.T.);+#542=CARTESIAN_POINT($,(225.447875838897,183.972388618652,1.2));+#543=VERTEX_POINT($,#542);+#544=CARTESIAN_POINT($,(225.447875838897,180.824512779755,1.2));+#545=DIRECTION($,(0,1,0));+#546=VECTOR($,#545,1);+#547=LINE($,#544,#546);+#548=EDGE_CURVE($,#535,#543,#547,.T.);+#549=ORIENTED_EDGE($,$,$,#548,.T.);+#550=CARTESIAN_POINT($,(225.447875838897,218.972388618652,1.2));+#551=VERTEX_POINT($,#550);+#552=CARTESIAN_POINT($,(225.447875838897,183.972388618652,1.2));+#553=DIRECTION($,(0,1,0));+#554=VECTOR($,#553,1);+#555=LINE($,#552,#554);+#556=EDGE_CURVE($,#543,#551,#555,.T.);+#557=ORIENTED_EDGE($,$,$,#556,.T.);+#558=CARTESIAN_POINT($,(50.847875838897,218.972388618652,1.2));+#559=VERTEX_POINT($,#558);+#560=CARTESIAN_POINT($,(225.447875838897,218.972388618652,1.2));+#561=DIRECTION($,(-1,0,0));+#562=VECTOR($,#561,1);+#563=LINE($,#560,#562);+#564=EDGE_CURVE($,#551,#559,#563,.T.);+#565=ORIENTED_EDGE($,$,$,#564,.T.);+#566=CARTESIAN_POINT($,(50.847875838897,183.972388618652,1.2));+#567=VERTEX_POINT($,#566);+#568=CARTESIAN_POINT($,(50.847875838897,218.972388618652,1.2));+#569=DIRECTION($,(0,-1,0));+#570=VECTOR($,#569,1);+#571=LINE($,#568,#570);+#572=EDGE_CURVE($,#559,#567,#571,.T.);+#573=ORIENTED_EDGE($,$,$,#572,.T.);+#574=CARTESIAN_POINT($,(50.847875838897,180.824512779755,1.2));+#575=VERTEX_POINT($,#574);+#576=CARTESIAN_POINT($,(50.847875838897,183.972388618652,1.2));+#577=DIRECTION($,(0,-1,0));+#578=VECTOR($,#577,1);+#579=LINE($,#576,#578);+#580=EDGE_CURVE($,#567,#575,#579,.T.);+#581=ORIENTED_EDGE($,$,$,#580,.T.);+#582=CARTESIAN_POINT($,(48.147875838897,180.824512779755,1.2));+#583=VERTEX_POINT($,#582);+#584=CARTESIAN_POINT($,(50.847875838897,180.824512779755,1.2));+#585=DIRECTION($,(-1,0,0));+#586=VECTOR($,#585,1);+#587=LINE($,#584,#586);+#588=EDGE_CURVE($,#575,#583,#587,.T.);+#589=ORIENTED_EDGE($,$,$,#588,.T.);+#590=CARTESIAN_POINT($,(48.147875838897,178.124512779755,1.2));+#591=VERTEX_POINT($,#590);+#592=CARTESIAN_POINT($,(48.147875838897,180.824512779755,1.2));+#593=DIRECTION($,(0,-1,0));+#594=VECTOR($,#593,1);+#595=LINE($,#592,#594);+#596=EDGE_CURVE($,#583,#591,#595,.T.);+#597=ORIENTED_EDGE($,$,$,#596,.T.);+#598=CARTESIAN_POINT($,(45,178.124512779755,1.2));+#599=VERTEX_POINT($,#598);+#600=CARTESIAN_POINT($,(48.147875838897,178.124512779755,1.2));+#601=DIRECTION($,(-1,0,0));+#602=VECTOR($,#601,1);+#603=LINE($,#600,#602);+#604=EDGE_CURVE($,#591,#599,#603,.T.);+#605=ORIENTED_EDGE($,$,$,#604,.T.);+#606=CARTESIAN_POINT($,(10,178.124512779755,1.2));+#607=VERTEX_POINT($,#606);+#608=CARTESIAN_POINT($,(45,178.124512779755,1.2));+#609=DIRECTION($,(-1,0,0));+#610=VECTOR($,#609,1);+#611=LINE($,#608,#610);+#612=EDGE_CURVE($,#599,#607,#611,.T.);+#613=ORIENTED_EDGE($,$,$,#612,.T.);+#614=CARTESIAN_POINT($,(10,63.5245127797555,1.2));+#615=VERTEX_POINT($,#614);+#616=CARTESIAN_POINT($,(10,178.124512779755,1.2));+#617=DIRECTION($,(0,-1,0));+#618=VECTOR($,#617,1);+#619=LINE($,#616,#618);+#620=EDGE_CURVE($,#607,#615,#619,.T.);+#621=ORIENTED_EDGE($,$,$,#620,.T.);+#622=CARTESIAN_POINT($,(45,63.5245127797555,1.2));+#623=VERTEX_POINT($,#622);+#624=CARTESIAN_POINT($,(10,63.5245127797555,1.2));+#625=DIRECTION($,(1,0,0));+#626=VECTOR($,#625,1);+#627=LINE($,#624,#626);+#628=EDGE_CURVE($,#615,#623,#627,.T.);+#629=ORIENTED_EDGE($,$,$,#628,.T.);+#630=CARTESIAN_POINT($,(48.147875838897,63.5245127797555,1.2));+#631=VERTEX_POINT($,#630);+#632=CARTESIAN_POINT($,(45,63.5245127797555,1.2));+#633=DIRECTION($,(1,0,0));+#634=VECTOR($,#633,1);+#635=LINE($,#632,#634);+#636=EDGE_CURVE($,#623,#631,#635,.T.);+#637=ORIENTED_EDGE($,$,$,#636,.T.);+#638=CARTESIAN_POINT($,(48.147875838897,60.8245127797555,1.2));+#639=VERTEX_POINT($,#638);+#640=CARTESIAN_POINT($,(48.147875838897,63.5245127797555,1.2));+#641=DIRECTION($,(0,-1,0));+#642=VECTOR($,#641,1);+#643=LINE($,#640,#642);+#644=EDGE_CURVE($,#631,#639,#643,.T.);+#645=ORIENTED_EDGE($,$,$,#644,.T.);+#646=CARTESIAN_POINT($,(50.847875838897,60.8245127797555,1.2));+#647=VERTEX_POINT($,#646);+#648=CARTESIAN_POINT($,(48.147875838897,60.8245127797555,1.2));+#649=DIRECTION($,(1,0,0));+#650=VECTOR($,#649,1);+#651=LINE($,#648,#650);+#652=EDGE_CURVE($,#639,#647,#651,.T.);+#653=ORIENTED_EDGE($,$,$,#652,.T.);+#654=CARTESIAN_POINT($,(50.847875838897,57.6766369408585,1.2));+#655=VERTEX_POINT($,#654);+#656=CARTESIAN_POINT($,(50.847875838897,60.8245127797555,1.2));+#657=DIRECTION($,(0,-1,0));+#658=VECTOR($,#657,1);+#659=LINE($,#656,#658);+#660=EDGE_CURVE($,#647,#655,#659,.T.);+#661=ORIENTED_EDGE($,$,$,#660,.T.);+#662=CARTESIAN_POINT($,(50.847875838897,22.6766369408585,1.2));+#663=VERTEX_POINT($,#662);+#664=CARTESIAN_POINT($,(50.847875838897,57.6766369408585,1.2));+#665=DIRECTION($,(0,-1,0));+#666=VECTOR($,#665,1);+#667=LINE($,#664,#666);+#668=EDGE_CURVE($,#655,#663,#667,.T.);+#669=ORIENTED_EDGE($,$,$,#668,.T.);+#670=CARTESIAN_POINT($,(50.847875838897,20,1.2));+#671=VERTEX_POINT($,#670);+#672=CARTESIAN_POINT($,(50.847875838897,22.6766369408585,1.2));+#673=DIRECTION($,(0,-1,0));+#674=VECTOR($,#673,1);+#675=LINE($,#672,#674);+#676=EDGE_CURVE($,#663,#671,#675,.T.);+#677=ORIENTED_EDGE($,$,$,#676,.T.);+#678=CARTESIAN_POINT($,(50.847875838897,20,1.2));+#679=DIRECTION($,(0,-1,0));+#680=VECTOR($,#679,1);+#681=LINE($,#678,#680);+#682=EDGE_CURVE($,#671,#429,#681,.T.);+#683=ORIENTED_EDGE($,$,$,#682,.T.);+#684=EDGE_LOOP($,(#437,#445,#453,#461,#469,#477,#485,#493,#501,#509,#517,#525,#533,#541,#549,#557,#565,#573,#581,#589,#597,#605,#613,#621,#629,#637,#645,#653,#661,#669,#677,#683));+#685=FACE_OUTER_BOUND('',#684,.T.);+#686=CARTESIAN_POINT($,(61.147875838897,75.8245127797555,1.2));+#687=VERTEX_POINT($,#686);+#688=CARTESIAN_POINT($,(65.147875838897,75.8245127797555,1.2));+#689=VERTEX_POINT($,#688);+#690=CARTESIAN_POINT($,(63.147875838897,75.8245127797555,1.2));+#691=DIRECTION($,(0,0,1));+#692=DIRECTION($,(1,0,0));+#693=AXIS2_PLACEMENT_3D($,#690,#691,#692);+#694=CIRCLE($,#693,2);+#695=TRIMMED_CURVE($,#694,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);+#696=EDGE_CURVE($,#687,#689,#695,.T.);+#697=ORIENTED_EDGE($,$,$,#696,.T.);+#698=ORIENTED_EDGE($,$,$,#696,.F.);+#699=EDGE_LOOP($,(#697,#698));+#700=FACE_BOUND('',#699,.T.);+#701=CARTESIAN_POINT($,(211.147875838897,75.8245127797555,1.2));+#702=VERTEX_POINT($,#701);+#703=CARTESIAN_POINT($,(215.147875838897,75.8245127797555,1.2));+#704=VERTEX_POINT($,#703);+#705=CARTESIAN_POINT($,(213.147875838897,75.8245127797555,1.2));+#706=DIRECTION($,(0,0,1));+#707=DIRECTION($,(1,0,0));+#708=AXIS2_PLACEMENT_3D($,#705,#706,#707);+#709=CIRCLE($,#708,2);+#710=TRIMMED_CURVE($,#709,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);+#711=EDGE_CURVE($,#702,#704,#710,.T.);+#712=ORIENTED_EDGE($,$,$,#711,.T.);+#713=ORIENTED_EDGE($,$,$,#711,.F.);+#714=EDGE_LOOP($,(#712,#713));+#715=FACE_BOUND('',#714,.T.);+#716=CARTESIAN_POINT($,(61.147875838897,165.824512779755,1.2));+#717=VERTEX_POINT($,#716);+#718=CARTESIAN_POINT($,(65.147875838897,165.824512779755,1.2));+#719=VERTEX_POINT($,#718);+#720=CARTESIAN_POINT($,(63.147875838897,165.824512779755,1.2));+#721=DIRECTION($,(0,0,1));+#722=DIRECTION($,(1,0,0));+#723=AXIS2_PLACEMENT_3D($,#720,#721,#722);+#724=CIRCLE($,#723,2);+#725=TRIMMED_CURVE($,#724,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);+#726=EDGE_CURVE($,#717,#719,#725,.T.);+#727=ORIENTED_EDGE($,$,$,#726,.T.);+#728=ORIENTED_EDGE($,$,$,#726,.F.);+#729=EDGE_LOOP($,(#727,#728));+#730=FACE_BOUND('',#729,.T.);+#731=CARTESIAN_POINT($,(211.147875838897,165.824512779755,1.2));+#732=VERTEX_POINT($,#731);+#733=CARTESIAN_POINT($,(215.147875838897,165.824512779755,1.2));+#734=VERTEX_POINT($,#733);+#735=CARTESIAN_POINT($,(213.147875838897,165.824512779755,1.2));+#736=DIRECTION($,(0,0,1));+#737=DIRECTION($,(1,0,0));+#738=AXIS2_PLACEMENT_3D($,#735,#736,#737);+#739=CIRCLE($,#738,2);+#740=TRIMMED_CURVE($,#739,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);+#741=EDGE_CURVE($,#732,#734,#740,.T.);+#742=ORIENTED_EDGE($,$,$,#741,.T.);+#743=ORIENTED_EDGE($,$,$,#741,.F.);+#744=EDGE_LOOP($,(#742,#743));+#745=FACE_BOUND('',#744,.T.);+#746=CARTESIAN_POINT($,(132.647875838897,117.824512779755,1.2));+#747=VERTEX_POINT($,#746);+#748=CARTESIAN_POINT($,(143.647875838897,117.824512779755,1.2));+#749=VERTEX_POINT($,#748);+#750=CARTESIAN_POINT($,(132.647875838897,117.824512779755,1.2));+#751=DIRECTION($,(1,0,0));+#752=VECTOR($,#751,1);+#753=LINE($,#750,#752);+#754=EDGE_CURVE($,#747,#749,#753,.T.);+#755=ORIENTED_EDGE($,$,$,#754,.F.);+#756=CARTESIAN_POINT($,(115.647875838897,117.824512779755,1.2));+#757=VERTEX_POINT($,#756);+#758=CARTESIAN_POINT($,(115.647875838897,117.824512779755,1.2));+#759=DIRECTION($,(1,0,0));+#760=VECTOR($,#759,1);+#761=LINE($,#758,#760);+#762=EDGE_CURVE($,#757,#747,#761,.T.);+#763=ORIENTED_EDGE($,$,$,#762,.F.);+#764=CARTESIAN_POINT($,(87.647875838897,117.824512779755,1.2));+#765=VERTEX_POINT($,#764);+#766=CARTESIAN_POINT($,(87.647875838897,117.824512779755,1.2));+#767=DIRECTION($,(1,0,0));+#768=VECTOR($,#767,1);+#769=LINE($,#766,#768);+#770=EDGE_CURVE($,#765,#757,#769,.T.);+#771=ORIENTED_EDGE($,$,$,#770,.F.);+#772=CARTESIAN_POINT($,(87.647875838897,123.824512779755,1.2));+#773=VERTEX_POINT($,#772);+#774=CARTESIAN_POINT($,(87.647875838897,123.824512779755,1.2));+#775=DIRECTION($,(0,-1,0));+#776=VECTOR($,#775,1);+#777=LINE($,#774,#776);+#778=EDGE_CURVE($,#773,#765,#777,.T.);+#779=ORIENTED_EDGE($,$,$,#778,.F.);+#780=CARTESIAN_POINT($,(115.647875838897,123.824512779755,1.2));+#781=VERTEX_POINT($,#780);+#782=CARTESIAN_POINT($,(115.647875838897,123.824512779755,1.2));+#783=DIRECTION($,(-1,0,0));+#784=VECTOR($,#783,1);+#785=LINE($,#782,#784);+#786=EDGE_CURVE($,#781,#773,#785,.T.);+#787=ORIENTED_EDGE($,$,$,#786,.F.);+#788=CARTESIAN_POINT($,(132.647875838897,123.824512779755,1.2));+#789=VERTEX_POINT($,#788);+#790=CARTESIAN_POINT($,(132.647875838897,123.824512779755,1.2));+#791=DIRECTION($,(-1,0,0));+#792=VECTOR($,#791,1);+#793=LINE($,#790,#792);+#794=EDGE_CURVE($,#789,#781,#793,.T.);+#795=ORIENTED_EDGE($,$,$,#794,.F.);+#796=CARTESIAN_POINT($,(143.647875838897,123.824512779755,1.2));+#797=VERTEX_POINT($,#796);+#798=CARTESIAN_POINT($,(143.647875838897,123.824512779755,1.2));+#799=DIRECTION($,(-1,0,0));+#800=VECTOR($,#799,1);+#801=LINE($,#798,#800);+#802=EDGE_CURVE($,#797,#789,#801,.T.);+#803=ORIENTED_EDGE($,$,$,#802,.F.);+#804=CARTESIAN_POINT($,(160.647875838897,123.824512779755,1.2));+#805=VERTEX_POINT($,#804);+#806=CARTESIAN_POINT($,(160.647875838897,123.824512779755,1.2));+#807=DIRECTION($,(-1,0,0));+#808=VECTOR($,#807,1);+#809=LINE($,#806,#808);+#810=EDGE_CURVE($,#805,#797,#809,.T.);+#811=ORIENTED_EDGE($,$,$,#810,.F.);+#812=CARTESIAN_POINT($,(188.647875838897,123.824512779755,1.2));+#813=VERTEX_POINT($,#812);+#814=CARTESIAN_POINT($,(188.647875838897,123.824512779755,1.2));+#815=DIRECTION($,(-1,0,0));+#816=VECTOR($,#815,1);+#817=LINE($,#814,#816);+#818=EDGE_CURVE($,#813,#805,#817,.T.);+#819=ORIENTED_EDGE($,$,$,#818,.F.);+#820=CARTESIAN_POINT($,(188.647875838897,117.824512779755,1.2));+#821=VERTEX_POINT($,#820);+#822=CARTESIAN_POINT($,(188.647875838897,117.824512779755,1.2));+#823=DIRECTION($,(0,1,0));+#824=VECTOR($,#823,1);+#825=LINE($,#822,#824);+#826=EDGE_CURVE($,#821,#813,#825,.T.);+#827=ORIENTED_EDGE($,$,$,#826,.F.);+#828=CARTESIAN_POINT($,(160.647875838897,117.824512779755,1.2));+#829=VERTEX_POINT($,#828);+#830=CARTESIAN_POINT($,(160.647875838897,117.824512779755,1.2));+#831=DIRECTION($,(1,0,0));+#832=VECTOR($,#831,1);+#833=LINE($,#830,#832);+#834=EDGE_CURVE($,#829,#821,#833,.T.);+#835=ORIENTED_EDGE($,$,$,#834,.F.);+#836=CARTESIAN_POINT($,(143.647875838897,117.824512779755,1.2));+#837=DIRECTION($,(1,0,0));+#838=VECTOR($,#837,1);+#839=LINE($,#836,#838);+#840=EDGE_CURVE($,#749,#829,#839,.T.);+#841=ORIENTED_EDGE($,$,$,#840,.F.);+#842=EDGE_LOOP($,(#755,#763,#771,#779,#787,#795,#803,#811,#819,#827,#835,#841));+#843=FACE_BOUND('',#842,.T.);+#844=ADVANCED_FACE('',(#685,#700,#715,#730,#745,#843),#427,.T.);+#845=CARTESIAN_POINT($,(50.847875838897,10,0));+#846=DIRECTION($,(0,-1,0));+#847=DIRECTION($,(0,0,1));+#848=AXIS2_PLACEMENT_3D($,#845,#846,#847);+#849=PLANE($,#848);+#850=ORIENTED_EDGE($,$,$,#14,.T.);+#851=CARTESIAN_POINT($,(226.047875838897,10,-0));+#852=DIRECTION($,(0,0,1));+#853=VECTOR($,#852,1);+#854=LINE($,#851,#853);+#855=EDGE_CURVE($,#9,#431,#854,.T.);+#856=ORIENTED_EDGE($,$,$,#855,.T.);+#857=ORIENTED_EDGE($,$,$,#436,.F.);+#858=CARTESIAN_POINT($,(50.847875838897,10,0));+#859=DIRECTION($,(0,0,1));+#860=VECTOR($,#859,1);+#861=LINE($,#858,#860);+#862=EDGE_CURVE($,#7,#429,#861,.T.);+#863=ORIENTED_EDGE($,$,$,#862,.F.);+#864=EDGE_LOOP($,(#850,#856,#857,#863));+#865=FACE_OUTER_BOUND('',#864,.T.);+#866=ADVANCED_FACE('',(#865),#849,.T.);+#867=CARTESIAN_POINT($,(226.047875838897,10,0));+#868=DIRECTION($,(1,0,0));+#869=DIRECTION($,(0,0,1));+#870=AXIS2_PLACEMENT_3D($,#867,#868,#869);+#871=PLANE($,#870);+#872=ORIENTED_EDGE($,$,$,#22,.T.);+#873=CARTESIAN_POINT($,(226.047875838897,20,0));+#874=DIRECTION($,(0,0,1));+#875=VECTOR($,#874,1);+#876=LINE($,#873,#875);+#877=EDGE_CURVE($,#17,#439,#876,.T.);+#878=ORIENTED_EDGE($,$,$,#877,.T.);+#879=ORIENTED_EDGE($,$,$,#444,.F.);+#880=ORIENTED_EDGE($,$,$,#855,.F.);+#881=EDGE_LOOP($,(#872,#878,#879,#880));+#882=FACE_OUTER_BOUND('',#881,.T.);+#883=ADVANCED_FACE('',(#882),#871,.T.);+#884=CARTESIAN_POINT($,(226.047875838897,20,0));+#885=DIRECTION($,(1,0,0));+#886=DIRECTION($,(0,0,1));+#887=AXIS2_PLACEMENT_3D($,#884,#885,#886);+#888=PLANE($,#887);+#889=ORIENTED_EDGE($,$,$,#30,.T.);+#890=CARTESIAN_POINT($,(226.047875838897,22.6766369408585,0));+#891=DIRECTION($,(0,0,1));+#892=VECTOR($,#891,1);+#893=LINE($,#890,#892);+#894=EDGE_CURVE($,#25,#447,#893,.T.);+#895=ORIENTED_EDGE($,$,$,#894,.T.);+#896=ORIENTED_EDGE($,$,$,#452,.F.);+#897=ORIENTED_EDGE($,$,$,#877,.F.);+#898=EDGE_LOOP($,(#889,#895,#896,#897));+#899=FACE_OUTER_BOUND('',#898,.T.);+#900=ADVANCED_FACE('',(#899),#888,.T.);+#901=CARTESIAN_POINT($,(226.047875838897,22.6766369408585,0));+#902=DIRECTION($,(1,0,0));+#903=DIRECTION($,(0,0,1));+#904=AXIS2_PLACEMENT_3D($,#901,#902,#903);+#905=PLANE($,#904);+#906=ORIENTED_EDGE($,$,$,#38,.T.);+#907=CARTESIAN_POINT($,(226.047875838897,57.6766369408585,0));+#908=DIRECTION($,(0,0,1));+#909=VECTOR($,#908,1);+#910=LINE($,#907,#909);+#911=EDGE_CURVE($,#33,#455,#910,.T.);+#912=ORIENTED_EDGE($,$,$,#911,.T.);+#913=ORIENTED_EDGE($,$,$,#460,.F.);+#914=ORIENTED_EDGE($,$,$,#894,.F.);+#915=EDGE_LOOP($,(#906,#912,#913,#914));+#916=FACE_OUTER_BOUND('',#915,.T.);+#917=ADVANCED_FACE('',(#916),#905,.T.);+#918=CARTESIAN_POINT($,(226.047875838897,57.6766369408585,0));+#919=DIRECTION($,(1,0,0));+#920=DIRECTION($,(0,0,1));+#921=AXIS2_PLACEMENT_3D($,#918,#919,#920);+#922=PLANE($,#921);+#923=ORIENTED_EDGE($,$,$,#46,.T.);+#924=CARTESIAN_POINT($,(226.047875838897,60.8245127797555,0));+#925=DIRECTION($,(0,0,1));+#926=VECTOR($,#925,1);+#927=LINE($,#924,#926);+#928=EDGE_CURVE($,#41,#463,#927,.T.);+#929=ORIENTED_EDGE($,$,$,#928,.T.);+#930=ORIENTED_EDGE($,$,$,#468,.F.);+#931=ORIENTED_EDGE($,$,$,#911,.F.);+#932=EDGE_LOOP($,(#923,#929,#930,#931));+#933=FACE_OUTER_BOUND('',#932,.T.);+#934=ADVANCED_FACE('',(#933),#922,.T.);+#935=CARTESIAN_POINT($,(226.047875838897,60.8245127797555,0));+#936=DIRECTION($,(0,-1,0));+#937=DIRECTION($,(0,0,1));+#938=AXIS2_PLACEMENT_3D($,#935,#936,#937);+#939=PLANE($,#938);+#940=ORIENTED_EDGE($,$,$,#54,.T.);+#941=CARTESIAN_POINT($,(228.147875838897,60.8245127797555,-0));+#942=DIRECTION($,(0,0,1));+#943=VECTOR($,#942,1);+#944=LINE($,#941,#943);+#945=EDGE_CURVE($,#49,#471,#944,.T.);+#946=ORIENTED_EDGE($,$,$,#945,.T.);+#947=ORIENTED_EDGE($,$,$,#476,.F.);+#948=ORIENTED_EDGE($,$,$,#928,.F.);+#949=EDGE_LOOP($,(#940,#946,#947,#948));+#950=FACE_OUTER_BOUND('',#949,.T.);+#951=ADVANCED_FACE('',(#950),#939,.T.);+#952=CARTESIAN_POINT($,(228.147875838897,60.8245127797555,0));+#953=DIRECTION($,(1,0,0));+#954=DIRECTION($,(0,0,1));+#955=AXIS2_PLACEMENT_3D($,#952,#953,#954);+#956=PLANE($,#955);+#957=ORIENTED_EDGE($,$,$,#62,.T.);+#958=CARTESIAN_POINT($,(228.147875838897,62.9245127797555,0));+#959=DIRECTION($,(0,0,1));+#960=VECTOR($,#959,1);+#961=LINE($,#958,#960);+#962=EDGE_CURVE($,#57,#479,#961,.T.);+#963=ORIENTED_EDGE($,$,$,#962,.T.);+#964=ORIENTED_EDGE($,$,$,#484,.F.);+#965=ORIENTED_EDGE($,$,$,#945,.F.);+#966=EDGE_LOOP($,(#957,#963,#964,#965));+#967=FACE_OUTER_BOUND('',#966,.T.);+#968=ADVANCED_FACE('',(#967),#956,.T.);+#969=CARTESIAN_POINT($,(228.147875838897,62.9245127797555,0));+#970=DIRECTION($,(0,-1,0));+#971=DIRECTION($,(0,0,1));+#972=AXIS2_PLACEMENT_3D($,#969,#970,#971);+#973=PLANE($,#972);+#974=ORIENTED_EDGE($,$,$,#70,.T.);+#975=CARTESIAN_POINT($,(231.295751677794,62.9245127797555,0));+#976=DIRECTION($,(0,0,1));+#977=VECTOR($,#976,1);+#978=LINE($,#975,#977);+#979=EDGE_CURVE($,#65,#487,#978,.T.);+#980=ORIENTED_EDGE($,$,$,#979,.T.);+#981=ORIENTED_EDGE($,$,$,#492,.F.);+#982=ORIENTED_EDGE($,$,$,#962,.F.);+#983=EDGE_LOOP($,(#974,#980,#981,#982));+#984=FACE_OUTER_BOUND('',#983,.T.);+#985=ADVANCED_FACE('',(#984),#973,.T.);+#986=CARTESIAN_POINT($,(231.295751677794,62.9245127797555,0));+#987=DIRECTION($,(0,-1,0));+#988=DIRECTION($,(0,0,1));+#989=AXIS2_PLACEMENT_3D($,#986,#987,#988);+#990=PLANE($,#989);+#991=ORIENTED_EDGE($,$,$,#78,.T.);+#992=CARTESIAN_POINT($,(266.295751677794,62.9245127797555,-0));+#993=DIRECTION($,(0,0,1));+#994=VECTOR($,#993,1);+#995=LINE($,#992,#994);+#996=EDGE_CURVE($,#73,#495,#995,.T.);+#997=ORIENTED_EDGE($,$,$,#996,.T.);+#998=ORIENTED_EDGE($,$,$,#500,.F.);+#999=ORIENTED_EDGE($,$,$,#979,.F.);+#1000=EDGE_LOOP($,(#991,#997,#998,#999));+#1001=FACE_OUTER_BOUND('',#1000,.T.);+#1002=ADVANCED_FACE('',(#1001),#990,.T.);+#1003=CARTESIAN_POINT($,(266.295751677794,62.9245127797555,0));+#1004=DIRECTION($,(1,0,0));+#1005=DIRECTION($,(0,0,1));+#1006=AXIS2_PLACEMENT_3D($,#1003,#1004,#1005);+#1007=PLANE($,#1006);+#1008=ORIENTED_EDGE($,$,$,#86,.T.);+#1009=CARTESIAN_POINT($,(266.295751677794,178.124512779755,-0));+#1010=DIRECTION($,(0,0,1));+#1011=VECTOR($,#1010,1);+#1012=LINE($,#1009,#1011);+#1013=EDGE_CURVE($,#81,#503,#1012,.T.);+#1014=ORIENTED_EDGE($,$,$,#1013,.T.);+#1015=ORIENTED_EDGE($,$,$,#508,.F.);+#1016=ORIENTED_EDGE($,$,$,#996,.F.);+#1017=EDGE_LOOP($,(#1008,#1014,#1015,#1016));+#1018=FACE_OUTER_BOUND('',#1017,.T.);+#1019=ADVANCED_FACE('',(#1018),#1007,.T.);+#1020=CARTESIAN_POINT($,(266.295751677794,178.124512779755,0));+#1021=DIRECTION($,(0,1,0));+#1022=DIRECTION($,(0,0,1));+#1023=AXIS2_PLACEMENT_3D($,#1020,#1021,#1022);+#1024=PLANE($,#1023);+#1025=ORIENTED_EDGE($,$,$,#94,.T.);+#1026=CARTESIAN_POINT($,(231.295751677794,178.124512779755,0));+#1027=DIRECTION($,(0,0,1));+#1028=VECTOR($,#1027,1);+#1029=LINE($,#1026,#1028);+#1030=EDGE_CURVE($,#89,#511,#1029,.T.);+#1031=ORIENTED_EDGE($,$,$,#1030,.T.);+#1032=ORIENTED_EDGE($,$,$,#516,.F.);+#1033=ORIENTED_EDGE($,$,$,#1013,.F.);+#1034=EDGE_LOOP($,(#1025,#1031,#1032,#1033));+#1035=FACE_OUTER_BOUND('',#1034,.T.);+#1036=ADVANCED_FACE('',(#1035),#1024,.T.);+#1037=CARTESIAN_POINT($,(231.295751677794,178.124512779755,0));+#1038=DIRECTION($,(0,1,0));+#1039=DIRECTION($,(0,0,1));+#1040=AXIS2_PLACEMENT_3D($,#1037,#1038,#1039);+#1041=PLANE($,#1040);+#1042=ORIENTED_EDGE($,$,$,#102,.T.);+#1043=CARTESIAN_POINT($,(228.147875838897,178.124512779755,0));+#1044=DIRECTION($,(0,0,1));+#1045=VECTOR($,#1044,1);+#1046=LINE($,#1043,#1045);+#1047=EDGE_CURVE($,#97,#519,#1046,.T.);+#1048=ORIENTED_EDGE($,$,$,#1047,.T.);+#1049=ORIENTED_EDGE($,$,$,#524,.F.);+#1050=ORIENTED_EDGE($,$,$,#1030,.F.);+#1051=EDGE_LOOP($,(#1042,#1048,#1049,#1050));+#1052=FACE_OUTER_BOUND('',#1051,.T.);+#1053=ADVANCED_FACE('',(#1052),#1041,.T.);+#1054=CARTESIAN_POINT($,(228.147875838897,178.124512779755,0));+#1055=DIRECTION($,(1,0,0));+#1056=DIRECTION($,(0,0,1));+#1057=AXIS2_PLACEMENT_3D($,#1054,#1055,#1056);+#1058=PLANE($,#1057);+#1059=ORIENTED_EDGE($,$,$,#110,.T.);+#1060=CARTESIAN_POINT($,(228.147875838897,180.824512779755,-0));+#1061=DIRECTION($,(0,0,1));+#1062=VECTOR($,#1061,1);+#1063=LINE($,#1060,#1062);+#1064=EDGE_CURVE($,#105,#527,#1063,.T.);+#1065=ORIENTED_EDGE($,$,$,#1064,.T.);+#1066=ORIENTED_EDGE($,$,$,#532,.F.);+#1067=ORIENTED_EDGE($,$,$,#1047,.F.);+#1068=EDGE_LOOP($,(#1059,#1065,#1066,#1067));+#1069=FACE_OUTER_BOUND('',#1068,.T.);+#1070=ADVANCED_FACE('',(#1069),#1058,.T.);+#1071=CARTESIAN_POINT($,(228.147875838897,180.824512779755,0));+#1072=DIRECTION($,(0,1,0));+#1073=DIRECTION($,(0,0,1));+#1074=AXIS2_PLACEMENT_3D($,#1071,#1072,#1073);+#1075=PLANE($,#1074);+#1076=ORIENTED_EDGE($,$,$,#118,.T.);+#1077=CARTESIAN_POINT($,(225.447875838897,180.824512779755,0));+#1078=DIRECTION($,(0,0,1));+#1079=VECTOR($,#1078,1);+#1080=LINE($,#1077,#1079);+#1081=EDGE_CURVE($,#113,#535,#1080,.T.);+#1082=ORIENTED_EDGE($,$,$,#1081,.T.);+#1083=ORIENTED_EDGE($,$,$,#540,.F.);+#1084=ORIENTED_EDGE($,$,$,#1064,.F.);+#1085=EDGE_LOOP($,(#1076,#1082,#1083,#1084));+#1086=FACE_OUTER_BOUND('',#1085,.T.);+#1087=ADVANCED_FACE('',(#1086),#1075,.T.);+#1088=CARTESIAN_POINT($,(225.447875838897,180.824512779755,0));+#1089=DIRECTION($,(1,0,0));+#1090=DIRECTION($,(0,0,1));+#1091=AXIS2_PLACEMENT_3D($,#1088,#1089,#1090);+#1092=PLANE($,#1091);+#1093=ORIENTED_EDGE($,$,$,#126,.T.);+#1094=CARTESIAN_POINT($,(225.447875838897,183.972388618652,0));+#1095=DIRECTION($,(0,0,1));+#1096=VECTOR($,#1095,1);+#1097=LINE($,#1094,#1096);+#1098=EDGE_CURVE($,#121,#543,#1097,.T.);+#1099=ORIENTED_EDGE($,$,$,#1098,.T.);+#1100=ORIENTED_EDGE($,$,$,#548,.F.);+#1101=ORIENTED_EDGE($,$,$,#1081,.F.);+#1102=EDGE_LOOP($,(#1093,#1099,#1100,#1101));+#1103=FACE_OUTER_BOUND('',#1102,.T.);+#1104=ADVANCED_FACE('',(#1103),#1092,.T.);+#1105=CARTESIAN_POINT($,(225.447875838897,183.972388618652,0));+#1106=DIRECTION($,(1,0,0));+#1107=DIRECTION($,(0,0,1));+#1108=AXIS2_PLACEMENT_3D($,#1105,#1106,#1107);+#1109=PLANE($,#1108);+#1110=ORIENTED_EDGE($,$,$,#134,.T.);+#1111=CARTESIAN_POINT($,(225.447875838897,218.972388618652,-0));+#1112=DIRECTION($,(0,0,1));+#1113=VECTOR($,#1112,1);+#1114=LINE($,#1111,#1113);+#1115=EDGE_CURVE($,#129,#551,#1114,.T.);+#1116=ORIENTED_EDGE($,$,$,#1115,.T.);+#1117=ORIENTED_EDGE($,$,$,#556,.F.);+#1118=ORIENTED_EDGE($,$,$,#1098,.F.);+#1119=EDGE_LOOP($,(#1110,#1116,#1117,#1118));+#1120=FACE_OUTER_BOUND('',#1119,.T.);+#1121=ADVANCED_FACE('',(#1120),#1109,.T.);+#1122=CARTESIAN_POINT($,(225.447875838897,218.972388618652,0));+#1123=DIRECTION($,(0,1,0));+#1124=DIRECTION($,(0,0,1));+#1125=AXIS2_PLACEMENT_3D($,#1122,#1123,#1124);+#1126=PLANE($,#1125);+#1127=ORIENTED_EDGE($,$,$,#142,.T.);+#1128=CARTESIAN_POINT($,(50.847875838897,218.972388618652,-0));+#1129=DIRECTION($,(0,0,1));+#1130=VECTOR($,#1129,1);+#1131=LINE($,#1128,#1130);+#1132=EDGE_CURVE($,#137,#559,#1131,.T.);+#1133=ORIENTED_EDGE($,$,$,#1132,.T.);+#1134=ORIENTED_EDGE($,$,$,#564,.F.);+#1135=ORIENTED_EDGE($,$,$,#1115,.F.);+#1136=EDGE_LOOP($,(#1127,#1133,#1134,#1135));+#1137=FACE_OUTER_BOUND('',#1136,.T.);+#1138=ADVANCED_FACE('',(#1137),#1126,.T.);+#1139=CARTESIAN_POINT($,(50.847875838897,218.972388618652,0));+#1140=DIRECTION($,(-1,0,0));+#1141=DIRECTION($,(0,0,1));+#1142=AXIS2_PLACEMENT_3D($,#1139,#1140,#1141);+#1143=PLANE($,#1142);+#1144=ORIENTED_EDGE($,$,$,#150,.T.);+#1145=CARTESIAN_POINT($,(50.847875838897,183.972388618652,0));+#1146=DIRECTION($,(0,0,1));+#1147=VECTOR($,#1146,1);+#1148=LINE($,#1145,#1147);+#1149=EDGE_CURVE($,#145,#567,#1148,.T.);+#1150=ORIENTED_EDGE($,$,$,#1149,.T.);+#1151=ORIENTED_EDGE($,$,$,#572,.F.);+#1152=ORIENTED_EDGE($,$,$,#1132,.F.);+#1153=EDGE_LOOP($,(#1144,#1150,#1151,#1152));+#1154=FACE_OUTER_BOUND('',#1153,.T.);+#1155=ADVANCED_FACE('',(#1154),#1143,.T.);+#1156=CARTESIAN_POINT($,(50.847875838897,183.972388618652,0));+#1157=DIRECTION($,(-1,0,0));+#1158=DIRECTION($,(0,0,1));+#1159=AXIS2_PLACEMENT_3D($,#1156,#1157,#1158);+#1160=PLANE($,#1159);+#1161=ORIENTED_EDGE($,$,$,#158,.T.);+#1162=CARTESIAN_POINT($,(50.847875838897,180.824512779755,0));+#1163=DIRECTION($,(0,0,1));+#1164=VECTOR($,#1163,1);+#1165=LINE($,#1162,#1164);+#1166=EDGE_CURVE($,#153,#575,#1165,.T.);+#1167=ORIENTED_EDGE($,$,$,#1166,.T.);+#1168=ORIENTED_EDGE($,$,$,#580,.F.);+#1169=ORIENTED_EDGE($,$,$,#1149,.F.);+#1170=EDGE_LOOP($,(#1161,#1167,#1168,#1169));+#1171=FACE_OUTER_BOUND('',#1170,.T.);+#1172=ADVANCED_FACE('',(#1171),#1160,.T.);+#1173=CARTESIAN_POINT($,(50.847875838897,180.824512779755,0));+#1174=DIRECTION($,(0,1,0));+#1175=DIRECTION($,(0,0,1));+#1176=AXIS2_PLACEMENT_3D($,#1173,#1174,#1175);+#1177=PLANE($,#1176);+#1178=ORIENTED_EDGE($,$,$,#166,.T.);+#1179=CARTESIAN_POINT($,(48.147875838897,180.824512779755,-0));+#1180=DIRECTION($,(0,0,1));+#1181=VECTOR($,#1180,1);+#1182=LINE($,#1179,#1181);+#1183=EDGE_CURVE($,#161,#583,#1182,.T.);+#1184=ORIENTED_EDGE($,$,$,#1183,.T.);+#1185=ORIENTED_EDGE($,$,$,#588,.F.);+#1186=ORIENTED_EDGE($,$,$,#1166,.F.);+#1187=EDGE_LOOP($,(#1178,#1184,#1185,#1186));+#1188=FACE_OUTER_BOUND('',#1187,.T.);+#1189=ADVANCED_FACE('',(#1188),#1177,.T.);+#1190=CARTESIAN_POINT($,(48.147875838897,180.824512779755,0));+#1191=DIRECTION($,(-1,0,0));+#1192=DIRECTION($,(0,0,1));+#1193=AXIS2_PLACEMENT_3D($,#1190,#1191,#1192);+#1194=PLANE($,#1193);+#1195=ORIENTED_EDGE($,$,$,#174,.T.);+#1196=CARTESIAN_POINT($,(48.147875838897,178.124512779755,0));+#1197=DIRECTION($,(0,0,1));+#1198=VECTOR($,#1197,1);+#1199=LINE($,#1196,#1198);+#1200=EDGE_CURVE($,#169,#591,#1199,.T.);+#1201=ORIENTED_EDGE($,$,$,#1200,.T.);+#1202=ORIENTED_EDGE($,$,$,#596,.F.);+#1203=ORIENTED_EDGE($,$,$,#1183,.F.);+#1204=EDGE_LOOP($,(#1195,#1201,#1202,#1203));+#1205=FACE_OUTER_BOUND('',#1204,.T.);+#1206=ADVANCED_FACE('',(#1205),#1194,.T.);+#1207=CARTESIAN_POINT($,(48.147875838897,178.124512779755,0));+#1208=DIRECTION($,(0,1,0));+#1209=DIRECTION($,(0,0,1));+#1210=AXIS2_PLACEMENT_3D($,#1207,#1208,#1209);+#1211=PLANE($,#1210);+#1212=ORIENTED_EDGE($,$,$,#182,.T.);+#1213=CARTESIAN_POINT($,(45,178.124512779755,0));+#1214=DIRECTION($,(0,0,1));+#1215=VECTOR($,#1214,1);+#1216=LINE($,#1213,#1215);+#1217=EDGE_CURVE($,#177,#599,#1216,.T.);+#1218=ORIENTED_EDGE($,$,$,#1217,.T.);+#1219=ORIENTED_EDGE($,$,$,#604,.F.);+#1220=ORIENTED_EDGE($,$,$,#1200,.F.);+#1221=EDGE_LOOP($,(#1212,#1218,#1219,#1220));+#1222=FACE_OUTER_BOUND('',#1221,.T.);+#1223=ADVANCED_FACE('',(#1222),#1211,.T.);+#1224=CARTESIAN_POINT($,(45,178.124512779755,0));+#1225=DIRECTION($,(0,1,0));+#1226=DIRECTION($,(0,0,1));+#1227=AXIS2_PLACEMENT_3D($,#1224,#1225,#1226);+#1228=PLANE($,#1227);+#1229=ORIENTED_EDGE($,$,$,#190,.T.);+#1230=CARTESIAN_POINT($,(10,178.124512779755,-0));+#1231=DIRECTION($,(0,0,1));+#1232=VECTOR($,#1231,1);+#1233=LINE($,#1230,#1232);+#1234=EDGE_CURVE($,#185,#607,#1233,.T.);+#1235=ORIENTED_EDGE($,$,$,#1234,.T.);+#1236=ORIENTED_EDGE($,$,$,#612,.F.);+#1237=ORIENTED_EDGE($,$,$,#1217,.F.);+#1238=EDGE_LOOP($,(#1229,#1235,#1236,#1237));+#1239=FACE_OUTER_BOUND('',#1238,.T.);+#1240=ADVANCED_FACE('',(#1239),#1228,.T.);+#1241=CARTESIAN_POINT($,(10,178.124512779755,0));+#1242=DIRECTION($,(-1,0,0));+#1243=DIRECTION($,(0,0,1));+#1244=AXIS2_PLACEMENT_3D($,#1241,#1242,#1243);+#1245=PLANE($,#1244);+#1246=ORIENTED_EDGE($,$,$,#198,.T.);+#1247=CARTESIAN_POINT($,(10,63.5245127797555,-0));+#1248=DIRECTION($,(0,0,1));+#1249=VECTOR($,#1248,1);+#1250=LINE($,#1247,#1249);+#1251=EDGE_CURVE($,#193,#615,#1250,.T.);+#1252=ORIENTED_EDGE($,$,$,#1251,.T.);+#1253=ORIENTED_EDGE($,$,$,#620,.F.);+#1254=ORIENTED_EDGE($,$,$,#1234,.F.);+#1255=EDGE_LOOP($,(#1246,#1252,#1253,#1254));+#1256=FACE_OUTER_BOUND('',#1255,.T.);+#1257=ADVANCED_FACE('',(#1256),#1245,.T.);+#1258=CARTESIAN_POINT($,(10,63.5245127797555,0));+#1259=DIRECTION($,(0,-1,0));+#1260=DIRECTION($,(0,0,1));+#1261=AXIS2_PLACEMENT_3D($,#1258,#1259,#1260);+#1262=PLANE($,#1261);+#1263=ORIENTED_EDGE($,$,$,#206,.T.);+#1264=CARTESIAN_POINT($,(45,63.5245127797555,0));+#1265=DIRECTION($,(0,0,1));+#1266=VECTOR($,#1265,1);+#1267=LINE($,#1264,#1266);+#1268=EDGE_CURVE($,#201,#623,#1267,.T.);+#1269=ORIENTED_EDGE($,$,$,#1268,.T.);+#1270=ORIENTED_EDGE($,$,$,#628,.F.);+#1271=ORIENTED_EDGE($,$,$,#1251,.F.);+#1272=EDGE_LOOP($,(#1263,#1269,#1270,#1271));+#1273=FACE_OUTER_BOUND('',#1272,.T.);+#1274=ADVANCED_FACE('',(#1273),#1262,.T.);+#1275=CARTESIAN_POINT($,(45,63.5245127797555,0));+#1276=DIRECTION($,(0,-1,0));+#1277=DIRECTION($,(0,0,1));+#1278=AXIS2_PLACEMENT_3D($,#1275,#1276,#1277);+#1279=PLANE($,#1278);+#1280=ORIENTED_EDGE($,$,$,#214,.T.);+#1281=CARTESIAN_POINT($,(48.147875838897,63.5245127797555,0));+#1282=DIRECTION($,(0,0,1));+#1283=VECTOR($,#1282,1);+#1284=LINE($,#1281,#1283);+#1285=EDGE_CURVE($,#209,#631,#1284,.T.);+#1286=ORIENTED_EDGE($,$,$,#1285,.T.);+#1287=ORIENTED_EDGE($,$,$,#636,.F.);+#1288=ORIENTED_EDGE($,$,$,#1268,.F.);+#1289=EDGE_LOOP($,(#1280,#1286,#1287,#1288));+#1290=FACE_OUTER_BOUND('',#1289,.T.);+#1291=ADVANCED_FACE('',(#1290),#1279,.T.);+#1292=CARTESIAN_POINT($,(48.147875838897,63.5245127797555,0));+#1293=DIRECTION($,(-1,0,0));+#1294=DIRECTION($,(0,0,1));+#1295=AXIS2_PLACEMENT_3D($,#1292,#1293,#1294);+#1296=PLANE($,#1295);+#1297=ORIENTED_EDGE($,$,$,#222,.T.);+#1298=CARTESIAN_POINT($,(48.147875838897,60.8245127797555,-0));+#1299=DIRECTION($,(0,0,1));+#1300=VECTOR($,#1299,1);+#1301=LINE($,#1298,#1300);+#1302=EDGE_CURVE($,#217,#639,#1301,.T.);+#1303=ORIENTED_EDGE($,$,$,#1302,.T.);+#1304=ORIENTED_EDGE($,$,$,#644,.F.);+#1305=ORIENTED_EDGE($,$,$,#1285,.F.);+#1306=EDGE_LOOP($,(#1297,#1303,#1304,#1305));+#1307=FACE_OUTER_BOUND('',#1306,.T.);+#1308=ADVANCED_FACE('',(#1307),#1296,.T.);+#1309=CARTESIAN_POINT($,(48.147875838897,60.8245127797555,0));+#1310=DIRECTION($,(0,-1,0));+#1311=DIRECTION($,(0,0,1));+#1312=AXIS2_PLACEMENT_3D($,#1309,#1310,#1311);+#1313=PLANE($,#1312);+#1314=ORIENTED_EDGE($,$,$,#230,.T.);+#1315=CARTESIAN_POINT($,(50.847875838897,60.8245127797555,0));+#1316=DIRECTION($,(0,0,1));+#1317=VECTOR($,#1316,1);+#1318=LINE($,#1315,#1317);+#1319=EDGE_CURVE($,#225,#647,#1318,.T.);+#1320=ORIENTED_EDGE($,$,$,#1319,.T.);+#1321=ORIENTED_EDGE($,$,$,#652,.F.);+#1322=ORIENTED_EDGE($,$,$,#1302,.F.);+#1323=EDGE_LOOP($,(#1314,#1320,#1321,#1322));+#1324=FACE_OUTER_BOUND('',#1323,.T.);+#1325=ADVANCED_FACE('',(#1324),#1313,.T.);+#1326=CARTESIAN_POINT($,(50.847875838897,60.8245127797555,0));+#1327=DIRECTION($,(-1,0,0));+#1328=DIRECTION($,(0,0,1));+#1329=AXIS2_PLACEMENT_3D($,#1326,#1327,#1328);+#1330=PLANE($,#1329);+#1331=ORIENTED_EDGE($,$,$,#238,.T.);+#1332=CARTESIAN_POINT($,(50.847875838897,57.6766369408585,0));+#1333=DIRECTION($,(0,0,1));+#1334=VECTOR($,#1333,1);+#1335=LINE($,#1332,#1334);+#1336=EDGE_CURVE($,#233,#655,#1335,.T.);+#1337=ORIENTED_EDGE($,$,$,#1336,.T.);+#1338=ORIENTED_EDGE($,$,$,#660,.F.);+#1339=ORIENTED_EDGE($,$,$,#1319,.F.);+#1340=EDGE_LOOP($,(#1331,#1337,#1338,#1339));+#1341=FACE_OUTER_BOUND('',#1340,.T.);+#1342=ADVANCED_FACE('',(#1341),#1330,.T.);+#1343=CARTESIAN_POINT($,(50.847875838897,57.6766369408585,0));+#1344=DIRECTION($,(-1,0,0));+#1345=DIRECTION($,(0,0,1));+#1346=AXIS2_PLACEMENT_3D($,#1343,#1344,#1345);+#1347=PLANE($,#1346);+#1348=ORIENTED_EDGE($,$,$,#246,.T.);+#1349=CARTESIAN_POINT($,(50.847875838897,22.6766369408585,0));+#1350=DIRECTION($,(0,0,1));+#1351=VECTOR($,#1350,1);+#1352=LINE($,#1349,#1351);+#1353=EDGE_CURVE($,#241,#663,#1352,.T.);+#1354=ORIENTED_EDGE($,$,$,#1353,.T.);+#1355=ORIENTED_EDGE($,$,$,#668,.F.);+#1356=ORIENTED_EDGE($,$,$,#1336,.F.);+#1357=EDGE_LOOP($,(#1348,#1354,#1355,#1356));+#1358=FACE_OUTER_BOUND('',#1357,.T.);+#1359=ADVANCED_FACE('',(#1358),#1347,.T.);+#1360=CARTESIAN_POINT($,(50.847875838897,22.6766369408585,0));+#1361=DIRECTION($,(-1,0,0));+#1362=DIRECTION($,(0,0,1));+#1363=AXIS2_PLACEMENT_3D($,#1360,#1361,#1362);+#1364=PLANE($,#1363);+#1365=ORIENTED_EDGE($,$,$,#254,.T.);+#1366=CARTESIAN_POINT($,(50.847875838897,20,0));+#1367=DIRECTION($,(0,0,1));+#1368=VECTOR($,#1367,1);+#1369=LINE($,#1366,#1368);+#1370=EDGE_CURVE($,#249,#671,#1369,.T.);+#1371=ORIENTED_EDGE($,$,$,#1370,.T.);+#1372=ORIENTED_EDGE($,$,$,#676,.F.);+#1373=ORIENTED_EDGE($,$,$,#1353,.F.);+#1374=EDGE_LOOP($,(#1365,#1371,#1372,#1373));+#1375=FACE_OUTER_BOUND('',#1374,.T.);+#1376=ADVANCED_FACE('',(#1375),#1364,.T.);+#1377=CARTESIAN_POINT($,(50.847875838897,20,0));+#1378=DIRECTION($,(-1,0,0));+#1379=DIRECTION($,(0,0,1));+#1380=AXIS2_PLACEMENT_3D($,#1377,#1378,#1379);+#1381=PLANE($,#1380);+#1382=ORIENTED_EDGE($,$,$,#260,.T.);+#1383=ORIENTED_EDGE($,$,$,#862,.T.);+#1384=ORIENTED_EDGE($,$,$,#682,.F.);+#1385=ORIENTED_EDGE($,$,$,#1370,.F.);+#1386=EDGE_LOOP($,(#1382,#1383,#1384,#1385));+#1387=FACE_OUTER_BOUND('',#1386,.T.);+#1388=ADVANCED_FACE('',(#1387),#1381,.T.);+#1389=CARTESIAN_POINT($,(63.147875838897,75.8245127797555,0));+#1390=DIRECTION($,(0,0,1));+#1391=DIRECTION($,(1,0,0));+#1392=AXIS2_PLACEMENT_3D($,#1389,#1390,#1391);+#1393=CYLINDRICAL_SURFACE($,#1392,2);+#1394=ORIENTED_EDGE($,$,$,#274,.T.);+#1395=CARTESIAN_POINT($,(65.147875838897,75.8245127797555,0));+#1396=DIRECTION($,(0,0,1));+#1397=VECTOR($,#1396,1);+#1398=LINE($,#1395,#1397);+#1399=EDGE_CURVE($,#267,#689,#1398,.T.);+#1400=ORIENTED_EDGE($,$,$,#1399,.T.);+#1401=ORIENTED_EDGE($,$,$,#696,.F.);+#1402=CARTESIAN_POINT($,(61.147875838897,75.8245127797555,0));+#1403=DIRECTION($,(0,0,1));+#1404=VECTOR($,#1403,1);+#1405=LINE($,#1402,#1404);+#1406=EDGE_CURVE($,#265,#687,#1405,.T.);+#1407=ORIENTED_EDGE($,$,$,#1406,.F.);+#1408=EDGE_LOOP($,(#1394,#1400,#1401,#1407));+#1409=FACE_OUTER_BOUND('',#1408,.T.);+#1410=ADVANCED_FACE('',(#1409),#1393,.F.);+#1411=CARTESIAN_POINT($,(63.147875838897,75.8245127797555,0));+#1412=DIRECTION($,(0,0,1));+#1413=DIRECTION($,(1,0,0));+#1414=AXIS2_PLACEMENT_3D($,#1411,#1412,#1413);+#1415=CYLINDRICAL_SURFACE($,#1414,2);+#1416=ORIENTED_EDGE($,$,$,#274,.F.);+#1417=ORIENTED_EDGE($,$,$,#1406,.T.);+#1418=ORIENTED_EDGE($,$,$,#696,.T.);+#1419=ORIENTED_EDGE($,$,$,#1399,.F.);+#1420=EDGE_LOOP($,(#1416,#1417,#1418,#1419));+#1421=FACE_OUTER_BOUND('',#1420,.T.);+#1422=ADVANCED_FACE('',(#1421),#1415,.F.);+#1423=CARTESIAN_POINT($,(213.147875838897,75.8245127797555,0));+#1424=DIRECTION($,(0,0,1));+#1425=DIRECTION($,(1,0,0));+#1426=AXIS2_PLACEMENT_3D($,#1423,#1424,#1425);+#1427=CYLINDRICAL_SURFACE($,#1426,2);+#1428=ORIENTED_EDGE($,$,$,#289,.T.);+#1429=CARTESIAN_POINT($,(215.147875838897,75.8245127797555,0));+#1430=DIRECTION($,(0,0,1));+#1431=VECTOR($,#1430,1);+#1432=LINE($,#1429,#1431);+#1433=EDGE_CURVE($,#282,#704,#1432,.T.);+#1434=ORIENTED_EDGE($,$,$,#1433,.T.);+#1435=ORIENTED_EDGE($,$,$,#711,.F.);+#1436=CARTESIAN_POINT($,(211.147875838897,75.8245127797555,0));+#1437=DIRECTION($,(0,0,1));+#1438=VECTOR($,#1437,1);+#1439=LINE($,#1436,#1438);+#1440=EDGE_CURVE($,#280,#702,#1439,.T.);+#1441=ORIENTED_EDGE($,$,$,#1440,.F.);+#1442=EDGE_LOOP($,(#1428,#1434,#1435,#1441));+#1443=FACE_OUTER_BOUND('',#1442,.T.);+#1444=ADVANCED_FACE('',(#1443),#1427,.F.);+#1445=CARTESIAN_POINT($,(213.147875838897,75.8245127797555,0));+#1446=DIRECTION($,(0,0,1));+#1447=DIRECTION($,(1,0,0));+#1448=AXIS2_PLACEMENT_3D($,#1445,#1446,#1447);+#1449=CYLINDRICAL_SURFACE($,#1448,2);+#1450=ORIENTED_EDGE($,$,$,#289,.F.);+#1451=ORIENTED_EDGE($,$,$,#1440,.T.);+#1452=ORIENTED_EDGE($,$,$,#711,.T.);+#1453=ORIENTED_EDGE($,$,$,#1433,.F.);+#1454=EDGE_LOOP($,(#1450,#1451,#1452,#1453));+#1455=FACE_OUTER_BOUND('',#1454,.T.);+#1456=ADVANCED_FACE('',(#1455),#1449,.F.);+#1457=CARTESIAN_POINT($,(63.147875838897,165.824512779755,0));+#1458=DIRECTION($,(0,0,1));+#1459=DIRECTION($,(1,0,0));+#1460=AXIS2_PLACEMENT_3D($,#1457,#1458,#1459);+#1461=CYLINDRICAL_SURFACE($,#1460,2);+#1462=ORIENTED_EDGE($,$,$,#304,.T.);+#1463=CARTESIAN_POINT($,(65.147875838897,165.824512779755,0));+#1464=DIRECTION($,(0,0,1));+#1465=VECTOR($,#1464,1);+#1466=LINE($,#1463,#1465);+#1467=EDGE_CURVE($,#297,#719,#1466,.T.);+#1468=ORIENTED_EDGE($,$,$,#1467,.T.);+#1469=ORIENTED_EDGE($,$,$,#726,.F.);+#1470=CARTESIAN_POINT($,(61.147875838897,165.824512779755,0));+#1471=DIRECTION($,(0,0,1));+#1472=VECTOR($,#1471,1);+#1473=LINE($,#1470,#1472);+#1474=EDGE_CURVE($,#295,#717,#1473,.T.);+#1475=ORIENTED_EDGE($,$,$,#1474,.F.);+#1476=EDGE_LOOP($,(#1462,#1468,#1469,#1475));+#1477=FACE_OUTER_BOUND('',#1476,.T.);+#1478=ADVANCED_FACE('',(#1477),#1461,.F.);+#1479=CARTESIAN_POINT($,(63.147875838897,165.824512779755,0));+#1480=DIRECTION($,(0,0,1));+#1481=DIRECTION($,(1,0,0));+#1482=AXIS2_PLACEMENT_3D($,#1479,#1480,#1481);+#1483=CYLINDRICAL_SURFACE($,#1482,2);+#1484=ORIENTED_EDGE($,$,$,#304,.F.);+#1485=ORIENTED_EDGE($,$,$,#1474,.T.);+#1486=ORIENTED_EDGE($,$,$,#726,.T.);+#1487=ORIENTED_EDGE($,$,$,#1467,.F.);+#1488=EDGE_LOOP($,(#1484,#1485,#1486,#1487));+#1489=FACE_OUTER_BOUND('',#1488,.T.);+#1490=ADVANCED_FACE('',(#1489),#1483,.F.);+#1491=CARTESIAN_POINT($,(213.147875838897,165.824512779755,0));+#1492=DIRECTION($,(0,0,1));+#1493=DIRECTION($,(1,0,0));+#1494=AXIS2_PLACEMENT_3D($,#1491,#1492,#1493);+#1495=CYLINDRICAL_SURFACE($,#1494,2);+#1496=ORIENTED_EDGE($,$,$,#319,.T.);+#1497=CARTESIAN_POINT($,(215.147875838897,165.824512779755,0));+#1498=DIRECTION($,(0,0,1));+#1499=VECTOR($,#1498,1);+#1500=LINE($,#1497,#1499);+#1501=EDGE_CURVE($,#312,#734,#1500,.T.);+#1502=ORIENTED_EDGE($,$,$,#1501,.T.);+#1503=ORIENTED_EDGE($,$,$,#741,.F.);+#1504=CARTESIAN_POINT($,(211.147875838897,165.824512779755,0));+#1505=DIRECTION($,(0,0,1));+#1506=VECTOR($,#1505,1);+#1507=LINE($,#1504,#1506);+#1508=EDGE_CURVE($,#310,#732,#1507,.T.);+#1509=ORIENTED_EDGE($,$,$,#1508,.F.);+#1510=EDGE_LOOP($,(#1496,#1502,#1503,#1509));+#1511=FACE_OUTER_BOUND('',#1510,.T.);+#1512=ADVANCED_FACE('',(#1511),#1495,.F.);+#1513=CARTESIAN_POINT($,(213.147875838897,165.824512779755,0));+#1514=DIRECTION($,(0,0,1));+#1515=DIRECTION($,(1,0,0));+#1516=AXIS2_PLACEMENT_3D($,#1513,#1514,#1515);+#1517=CYLINDRICAL_SURFACE($,#1516,2);+#1518=ORIENTED_EDGE($,$,$,#319,.F.);+#1519=ORIENTED_EDGE($,$,$,#1508,.T.);+#1520=ORIENTED_EDGE($,$,$,#741,.T.);+#1521=ORIENTED_EDGE($,$,$,#1501,.F.);+#1522=EDGE_LOOP($,(#1518,#1519,#1520,#1521));+#1523=FACE_OUTER_BOUND('',#1522,.T.);+#1524=ADVANCED_FACE('',(#1523),#1517,.F.);+#1525=CARTESIAN_POINT($,(132.647875838897,117.824512779755,0));+#1526=DIRECTION($,(0,1,0));+#1527=DIRECTION($,(0,0,1));+#1528=AXIS2_PLACEMENT_3D($,#1525,#1526,#1527);+#1529=PLANE($,#1528);+#1530=ORIENTED_EDGE($,$,$,#332,.T.);+#1531=CARTESIAN_POINT($,(143.647875838897,117.824512779755,0));+#1532=DIRECTION($,(0,0,1));+#1533=VECTOR($,#1532,1);+#1534=LINE($,#1531,#1533);+#1535=EDGE_CURVE($,#327,#749,#1534,.T.);+#1536=ORIENTED_EDGE($,$,$,#1535,.T.);+#1537=ORIENTED_EDGE($,$,$,#754,.F.);+#1538=CARTESIAN_POINT($,(132.647875838897,117.824512779755,0));+#1539=DIRECTION($,(0,0,1));+#1540=VECTOR($,#1539,1);+#1541=LINE($,#1538,#1540);+#1542=EDGE_CURVE($,#325,#747,#1541,.T.);+#1543=ORIENTED_EDGE($,$,$,#1542,.F.);+#1544=EDGE_LOOP($,(#1530,#1536,#1537,#1543));+#1545=FACE_OUTER_BOUND('',#1544,.T.);+#1546=ADVANCED_FACE('',(#1545),#1529,.T.);+#1547=CARTESIAN_POINT($,(143.647875838897,117.824512779755,0));+#1548=DIRECTION($,(0,1,0));+#1549=DIRECTION($,(0,0,1));+#1550=AXIS2_PLACEMENT_3D($,#1547,#1548,#1549);+#1551=PLANE($,#1550);+#1552=ORIENTED_EDGE($,$,$,#418,.T.);+#1553=CARTESIAN_POINT($,(160.647875838897,117.824512779755,0));+#1554=DIRECTION($,(0,0,1));+#1555=VECTOR($,#1554,1);+#1556=LINE($,#1553,#1555);+#1557=EDGE_CURVE($,#407,#829,#1556,.T.);+#1558=ORIENTED_EDGE($,$,$,#1557,.T.);+#1559=ORIENTED_EDGE($,$,$,#840,.F.);+#1560=ORIENTED_EDGE($,$,$,#1535,.F.);+#1561=EDGE_LOOP($,(#1552,#1558,#1559,#1560));+#1562=FACE_OUTER_BOUND('',#1561,.T.);+#1563=ADVANCED_FACE('',(#1562),#1551,.T.);+#1564=CARTESIAN_POINT($,(160.647875838897,117.824512779755,0));+#1565=DIRECTION($,(0,1,0));+#1566=DIRECTION($,(0,0,1));+#1567=AXIS2_PLACEMENT_3D($,#1564,#1565,#1566);+#1568=PLANE($,#1567);+#1569=ORIENTED_EDGE($,$,$,#412,.T.);+#1570=CARTESIAN_POINT($,(188.647875838897,117.824512779755,-0));+#1571=DIRECTION($,(0,0,1));+#1572=VECTOR($,#1571,1);+#1573=LINE($,#1570,#1572);+#1574=EDGE_CURVE($,#399,#821,#1573,.T.);+#1575=ORIENTED_EDGE($,$,$,#1574,.T.);+#1576=ORIENTED_EDGE($,$,$,#834,.F.);+#1577=ORIENTED_EDGE($,$,$,#1557,.F.);+#1578=EDGE_LOOP($,(#1569,#1575,#1576,#1577));+#1579=FACE_OUTER_BOUND('',#1578,.T.);+#1580=ADVANCED_FACE('',(#1579),#1568,.T.);+#1581=CARTESIAN_POINT($,(188.647875838897,117.824512779755,0));+#1582=DIRECTION($,(-1,0,0));+#1583=DIRECTION($,(0,0,1));+#1584=AXIS2_PLACEMENT_3D($,#1581,#1582,#1583);+#1585=PLANE($,#1584);+#1586=ORIENTED_EDGE($,$,$,#404,.T.);+#1587=CARTESIAN_POINT($,(188.647875838897,123.824512779755,-0));+#1588=DIRECTION($,(0,0,1));+#1589=VECTOR($,#1588,1);+#1590=LINE($,#1587,#1589);+#1591=EDGE_CURVE($,#391,#813,#1590,.T.);+#1592=ORIENTED_EDGE($,$,$,#1591,.T.);+#1593=ORIENTED_EDGE($,$,$,#826,.F.);+#1594=ORIENTED_EDGE($,$,$,#1574,.F.);+#1595=EDGE_LOOP($,(#1586,#1592,#1593,#1594));+#1596=FACE_OUTER_BOUND('',#1595,.T.);+#1597=ADVANCED_FACE('',(#1596),#1585,.T.);+#1598=CARTESIAN_POINT($,(188.647875838897,123.824512779755,0));+#1599=DIRECTION($,(0,-1,0));+#1600=DIRECTION($,(0,0,1));+#1601=AXIS2_PLACEMENT_3D($,#1598,#1599,#1600);+#1602=PLANE($,#1601);+#1603=ORIENTED_EDGE($,$,$,#396,.T.);+#1604=CARTESIAN_POINT($,(160.647875838897,123.824512779755,0));+#1605=DIRECTION($,(0,0,1));+#1606=VECTOR($,#1605,1);+#1607=LINE($,#1604,#1606);+#1608=EDGE_CURVE($,#383,#805,#1607,.T.);+#1609=ORIENTED_EDGE($,$,$,#1608,.T.);+#1610=ORIENTED_EDGE($,$,$,#818,.F.);+#1611=ORIENTED_EDGE($,$,$,#1591,.F.);+#1612=EDGE_LOOP($,(#1603,#1609,#1610,#1611));+#1613=FACE_OUTER_BOUND('',#1612,.T.);+#1614=ADVANCED_FACE('',(#1613),#1602,.T.);+#1615=CARTESIAN_POINT($,(160.647875838897,123.824512779755,0));+#1616=DIRECTION($,(0,-1,0));+#1617=DIRECTION($,(0,0,1));+#1618=AXIS2_PLACEMENT_3D($,#1615,#1616,#1617);+#1619=PLANE($,#1618);+#1620=ORIENTED_EDGE($,$,$,#388,.T.);+#1621=CARTESIAN_POINT($,(143.647875838897,123.824512779755,0));+#1622=DIRECTION($,(0,0,1));+#1623=VECTOR($,#1622,1);+#1624=LINE($,#1621,#1623);+#1625=EDGE_CURVE($,#375,#797,#1624,.T.);+#1626=ORIENTED_EDGE($,$,$,#1625,.T.);+#1627=ORIENTED_EDGE($,$,$,#810,.F.);+#1628=ORIENTED_EDGE($,$,$,#1608,.F.);+#1629=EDGE_LOOP($,(#1620,#1626,#1627,#1628));+#1630=FACE_OUTER_BOUND('',#1629,.T.);+#1631=ADVANCED_FACE('',(#1630),#1619,.T.);+#1632=CARTESIAN_POINT($,(143.647875838897,123.824512779755,0));+#1633=DIRECTION($,(0,-1,0));+#1634=DIRECTION($,(0,0,1));+#1635=AXIS2_PLACEMENT_3D($,#1632,#1633,#1634);+#1636=PLANE($,#1635);+#1637=ORIENTED_EDGE($,$,$,#380,.T.);+#1638=CARTESIAN_POINT($,(132.647875838897,123.824512779755,0));+#1639=DIRECTION($,(0,0,1));+#1640=VECTOR($,#1639,1);+#1641=LINE($,#1638,#1640);+#1642=EDGE_CURVE($,#367,#789,#1641,.T.);+#1643=ORIENTED_EDGE($,$,$,#1642,.T.);+#1644=ORIENTED_EDGE($,$,$,#802,.F.);+#1645=ORIENTED_EDGE($,$,$,#1625,.F.);+#1646=EDGE_LOOP($,(#1637,#1643,#1644,#1645));+#1647=FACE_OUTER_BOUND('',#1646,.T.);+#1648=ADVANCED_FACE('',(#1647),#1636,.T.);+#1649=CARTESIAN_POINT($,(132.647875838897,123.824512779755,0));+#1650=DIRECTION($,(0,-1,0));+#1651=DIRECTION($,(0,0,1));+#1652=AXIS2_PLACEMENT_3D($,#1649,#1650,#1651);+#1653=PLANE($,#1652);+#1654=ORIENTED_EDGE($,$,$,#372,.T.);+#1655=CARTESIAN_POINT($,(115.647875838897,123.824512779755,0));+#1656=DIRECTION($,(0,0,1));+#1657=VECTOR($,#1656,1);+#1658=LINE($,#1655,#1657);+#1659=EDGE_CURVE($,#359,#781,#1658,.T.);+#1660=ORIENTED_EDGE($,$,$,#1659,.T.);+#1661=ORIENTED_EDGE($,$,$,#794,.F.);+#1662=ORIENTED_EDGE($,$,$,#1642,.F.);+#1663=EDGE_LOOP($,(#1654,#1660,#1661,#1662));+#1664=FACE_OUTER_BOUND('',#1663,.T.);+#1665=ADVANCED_FACE('',(#1664),#1653,.T.);+#1666=CARTESIAN_POINT($,(115.647875838897,123.824512779755,0));+#1667=DIRECTION($,(0,-1,0));+#1668=DIRECTION($,(0,0,1));+#1669=AXIS2_PLACEMENT_3D($,#1666,#1667,#1668);+#1670=PLANE($,#1669);+#1671=ORIENTED_EDGE($,$,$,#364,.T.);+#1672=CARTESIAN_POINT($,(87.647875838897,123.824512779755,-0));+#1673=DIRECTION($,(0,0,1));+#1674=VECTOR($,#1673,1);+#1675=LINE($,#1672,#1674);+#1676=EDGE_CURVE($,#351,#773,#1675,.T.);+#1677=ORIENTED_EDGE($,$,$,#1676,.T.);+#1678=ORIENTED_EDGE($,$,$,#786,.F.);+#1679=ORIENTED_EDGE($,$,$,#1659,.F.);+#1680=EDGE_LOOP($,(#1671,#1677,#1678,#1679));+#1681=FACE_OUTER_BOUND('',#1680,.T.);+#1682=ADVANCED_FACE('',(#1681),#1670,.T.);+#1683=CARTESIAN_POINT($,(87.647875838897,123.824512779755,0));+#1684=DIRECTION($,(1,0,0));+#1685=DIRECTION($,(0,0,1));+#1686=AXIS2_PLACEMENT_3D($,#1683,#1684,#1685);+#1687=PLANE($,#1686);+#1688=ORIENTED_EDGE($,$,$,#356,.T.);+#1689=CARTESIAN_POINT($,(87.647875838897,117.824512779755,-0));+#1690=DIRECTION($,(0,0,1));+#1691=VECTOR($,#1690,1);+#1692=LINE($,#1689,#1691);+#1693=EDGE_CURVE($,#343,#765,#1692,.T.);+#1694=ORIENTED_EDGE($,$,$,#1693,.T.);+#1695=ORIENTED_EDGE($,$,$,#778,.F.);+#1696=ORIENTED_EDGE($,$,$,#1676,.F.);+#1697=EDGE_LOOP($,(#1688,#1694,#1695,#1696));+#1698=FACE_OUTER_BOUND('',#1697,.T.);+#1699=ADVANCED_FACE('',(#1698),#1687,.T.);+#1700=CARTESIAN_POINT($,(87.647875838897,117.824512779755,0));+#1701=DIRECTION($,(0,1,0));+#1702=DIRECTION($,(0,0,1));+#1703=AXIS2_PLACEMENT_3D($,#1700,#1701,#1702);+#1704=PLANE($,#1703);+#1705=ORIENTED_EDGE($,$,$,#348,.T.);+#1706=CARTESIAN_POINT($,(115.647875838897,117.824512779755,0));+#1707=DIRECTION($,(0,0,1));+#1708=VECTOR($,#1707,1);+#1709=LINE($,#1706,#1708);+#1710=EDGE_CURVE($,#335,#757,#1709,.T.);+#1711=ORIENTED_EDGE($,$,$,#1710,.T.);+#1712=ORIENTED_EDGE($,$,$,#770,.F.);+#1713=ORIENTED_EDGE($,$,$,#1693,.F.);+#1714=EDGE_LOOP($,(#1705,#1711,#1712,#1713));+#1715=FACE_OUTER_BOUND('',#1714,.T.);+#1716=ADVANCED_FACE('',(#1715),#1704,.T.);+#1717=CARTESIAN_POINT($,(115.647875838897,117.824512779755,0));+#1718=DIRECTION($,(0,1,0));+#1719=DIRECTION($,(0,0,1));+#1720=AXIS2_PLACEMENT_3D($,#1717,#1718,#1719);+#1721=PLANE($,#1720);+#1722=ORIENTED_EDGE($,$,$,#340,.T.);+#1723=ORIENTED_EDGE($,$,$,#1542,.T.);+#1724=ORIENTED_EDGE($,$,$,#762,.F.);+#1725=ORIENTED_EDGE($,$,$,#1710,.F.);+#1726=EDGE_LOOP($,(#1722,#1723,#1724,#1725));+#1727=FACE_OUTER_BOUND('',#1726,.T.);+#1728=ADVANCED_FACE('',(#1727),#1721,.T.);+#1729=CLOSED_SHELL($,(#422,#844,#866,#883,#900,#917,#934,#951,#968,#985,#1002,#1019,#1036,#1053,#1070,#1087,#1104,#1121,#1138,#1155,#1172,#1189,#1206,#1223,#1240,#1257,#1274,#1291,#1308,#1325,#1342,#1359,#1376,#1388,#1410,#1422,#1444,#1456,#1478,#1490,#1512,#1524,#1546,#1563,#1580,#1597,#1614,#1631,#1648,#1665,#1682,#1699,#1716,#1728));+#1730=MANIFOLD_SOLID_BREP('sheetmetal-PsuEnclosure flat pattern',#1729);+#1731=APPLICATION_CONTEXT('mechanical design');+#1732=PRODUCT_CONTEXT('',#1731,'mechanical');+#1733=PRODUCT('sheetmetal_PsuEnclosure_flat','sheetmetal-PsuEnclosure flat pattern','',(#1732));+#1734=PRODUCT_DEFINITION_FORMATION('','',#1733);+#1735=PRODUCT_DEFINITION_CONTEXT('design',#1731,'design');+#1736=PRODUCT_DEFINITION('','',#1734,#1735);+#1737=PRODUCT_DEFINITION_SHAPE('','',#1736);+#1738=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));+#1739=(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.));+#1740=(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT());+#1741=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNIT_ASSIGNED_CONTEXT((#1738,#1739,#1740))REPRESENTATION_CONTEXT('3','3D'));+#1742=SHAPE_REPRESENTATION('sheetmetal-PsuEnclosure flat pattern',(#1730),#1741);+#1743=SHAPE_DEFINITION_REPRESENTATION(#1737,#1742);+ENDSEC;+END-ISO-10303-21;diff --git a/docs/modules/sheetmetal/artifacts/m4/psu-enclosure-flat.svg b/docs/modules/sheetmetal/artifacts/m4/psu-enclosure-flat.svgnew file mode 100644index 00000000..4d0c9c07--- /dev/null+++ b/docs/modules/sheetmetal/artifacts/m4/psu-enclosure-flat.svg@@ -0,0 +1,49 @@+<?xml version="1.0" encoding="UTF-8"?>+<svg xmlns="http://www.w3.org/2000/svg" width="280.296mm" height="232.972mm" viewBox="0 0 280.296 232.972">+<rect width="100%" height="100%" fill="white"/>+<g id="sheet-regions" fill="#dbeafe" fill-opacity="0.55" stroke="#0f172a" stroke-width="0.45">+<path id="flat-FrontLip" d="M 52.848 220.972 L 228.048 220.972 L 228.048 210.972 L 52.848 210.972 L 52.848 220.972 Z"/>+<path id="flat-FrontLipBend" d="M 52.848 210.972 L 228.048 210.972 L 228.048 208.296 L 52.848 208.296 L 52.848 210.972 Z"/>+<path id="flat-FrontWall" d="M 52.848 208.296 L 228.048 208.296 L 228.048 173.296 L 52.848 173.296 L 52.848 208.296 Z"/>+<path id="flat-FrontWallBend" d="M 52.848 173.296 L 228.048 173.296 L 228.048 170.148 L 52.848 170.148 L 52.848 173.296 Z"/>+<path id="flat-LeftWall" d="M 12 52.848 L 12 167.448 L 47 167.448 L 47 52.848 L 12 52.848 Z"/>+<path id="flat-LeftWallBend" d="M 47 52.848 L 47 167.448 L 50.148 167.448 L 50.148 52.848 L 47 52.848 Z"/>+<path id="flat-Main" d="M 50.148 170.148 L 52.848 170.148 L 228.048 170.148 L 230.148 170.148 L 230.148 168.048 L 230.148 52.848 L 230.148 50.148 L 227.448 50.148 L 52.848 50.148 L 50.148 50.148 L 50.148 52.848 L 50.148 167.448 L 50.148 170.148 Z"/>+<path id="flat-RearWall" d="M 227.448 12 L 52.848 12 L 52.848 47 L 227.448 47 L 227.448 12 Z"/>+<path id="flat-RearWallBend" d="M 227.448 47 L 52.848 47 L 52.848 50.148 L 227.448 50.148 L 227.448 47 Z"/>+<path id="flat-RightWall" d="M 268.296 168.048 L 268.296 52.848 L 233.296 52.848 L 233.296 168.048 L 268.296 168.048 Z"/>+<path id="flat-RightWallBend" d="M 233.296 168.048 L 233.296 52.848 L 230.148 52.848 L 230.148 168.048 L 233.296 168.048 Z"/>+</g>+<path id="exact-blank-contour" d="M 52.848 220.972 L 228.048 220.972 L 228.048 210.972 L 228.048 208.296 L 228.048 173.296 L 228.048 170.148 L 230.148 170.148 L 230.148 168.048 L 233.296 168.048 L 268.296 168.048 L 268.296 52.848 L 233.296 52.848 L 230.148 52.848 L 230.148 50.148 L 227.448 50.148 L 227.448 47 L 227.448 12 L 52.848 12 L 52.848 47 L 52.848 50.148 L 50.148 50.148 L 50.148 52.848 L 47 52.848 L 12 52.848 L 12 167.448 L 47 167.448 L 50.148 167.448 L 50.148 170.148 L 52.848 170.148 L 52.848 173.296 L 52.848 208.296 L 52.848 210.972 L 52.848 220.972 Z" fill="none" stroke="#020617" stroke-width="0.7"/>+<g id="cut-contours" fill="white" stroke="#dc2626" stroke-width="0.5">+<path id="MountFL" d="M 67.148 155.148 A 2 2 0 0 0 63.148 155.148 A 2 2 0 0 0 67.148 155.148 Z"/>+<path id="MountFR" d="M 217.148 155.148 A 2 2 0 0 0 213.148 155.148 A 2 2 0 0 0 217.148 155.148 Z"/>+<path id="MountRL" d="M 67.148 65.148 A 2 2 0 0 0 63.148 65.148 A 2 2 0 0 0 67.148 65.148 Z"/>+<path id="MountRR" d="M 217.148 65.148 A 2 2 0 0 0 213.148 65.148 A 2 2 0 0 0 217.148 65.148 Z"/>+<path id="VentCenter" d="M 117.648 113.148 L 162.648 113.148 L 162.648 107.148 L 117.648 107.148 L 117.648 113.148 Z"/>+<path id="VentLeft" d="M 89.648 113.148 L 134.648 113.148 L 134.648 107.148 L 89.648 107.148 L 89.648 113.148 Z"/>+<path id="VentRight" d="M 145.648 113.148 L 190.648 113.148 L 190.648 107.148 L 145.648 107.148 L 145.648 113.148 Z"/>+</g>+<g id="corner-reliefs" fill="white" stroke="#ea580c" stroke-width="0.5">+</g>+<g id="bend-lines" fill="none" stroke="#2563eb" stroke-width="0.45" stroke-dasharray="3 2">+<line x1="52.848" y1="209.634" x2="228.048" y2="209.634"/>+<line x1="52.848" y1="171.722" x2="228.048" y2="171.722"/>+<line x1="48.574" y1="52.848" x2="48.574" y2="167.448"/>+<line x1="227.448" y1="48.574" x2="52.848" y2="48.574"/>+<line x1="231.722" y1="168.048" x2="231.722" y2="52.848"/>+</g>+<g id="bend-labels" stroke="none" font-family="Inter, 'Segoe UI', Arial, sans-serif" font-size="3" text-anchor="middle" dominant-baseline="central">+<rect x="129.023" y="211.434" width="22.85" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>+<text x="140.448" y="213.634" fill="#1d4ed8">Down 90° R1.2</text>+<rect x="130.673" y="173.522" width="19.55" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>+<text x="140.448" y="175.722" fill="#1d4ed8">Up 90° R1.5</text>+<rect x="34.799" y="107.948" width="19.55" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>+<text x="44.574" y="110.148" fill="#1d4ed8">Up 90° R1.5</text>+<rect x="130.373" y="42.374" width="19.55" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>+<text x="140.148" y="44.574" fill="#1d4ed8">Up 90° R1.5</text>+<rect x="225.947" y="108.248" width="19.55" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>+<text x="235.722" y="110.448" fill="#1d4ed8">Up 90° R1.5</text>+</g>+<text x="4" y="6" font-family="sans-serif" font-size="3" fill="#334155">Valid · K=0.42 · SHA-256 da104ebd017d</text>+</svg>diff --git a/docs/modules/sheetmetal/artifacts/m4/psu-enclosure-formed.step b/docs/modules/sheetmetal/artifacts/m4/psu-enclosure-formed.stepnew file mode 100644index 00000000..2a64394f--- /dev/null+++ b/docs/modules/sheetmetal/artifacts/m4/psu-enclosure-formed.step@@ -0,0 +1,1980 @@+ISO-10303-21;+HEADER;+FILE_DESCRIPTION(('Aetheris AP242 subset export'),'2;1');+FILE_NAME('aetheris_export.step','1970-01-01T00:00:00',('Aetheris'),('Aetheris'),'Aetheris.Kernel','Aetheris.Kernel','');+FILE_SCHEMA(('AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF'));+ENDSEC;+DATA;+#1=CARTESIAN_POINT($,(0,0,1.2));+#2=DIRECTION($,(0,0,1));+#3=DIRECTION($,(1,0,0));+#4=AXIS2_PLACEMENT_3D($,#1,#2,#3);+#5=PLANE($,#4);+#6=CARTESIAN_POINT($,(-0,-0,1.2));+#7=VERTEX_POINT($,#6);+#8=CARTESIAN_POINT($,(2.7,0,1.2));+#9=VERTEX_POINT($,#8);+#10=CARTESIAN_POINT($,(-0,-0,1.2));+#11=DIRECTION($,(1,0,0));+#12=VECTOR($,#11,1);+#13=LINE($,#10,#12);+#14=EDGE_CURVE($,#7,#9,#13,.T.);+#15=ORIENTED_EDGE($,$,$,#14,.T.);+#16=CARTESIAN_POINT($,(177.9,0,1.2));+#17=VERTEX_POINT($,#16);+#18=CARTESIAN_POINT($,(2.7,0,1.2));+#19=DIRECTION($,(1,0,0));+#20=VECTOR($,#19,1);+#21=LINE($,#18,#20);+#22=EDGE_CURVE($,#9,#17,#21,.T.);+#23=ORIENTED_EDGE($,$,$,#22,.T.);+#24=CARTESIAN_POINT($,(180,0,1.2));+#25=VERTEX_POINT($,#24);+#26=CARTESIAN_POINT($,(177.9,0,1.2));+#27=DIRECTION($,(1,0,0));+#28=VECTOR($,#27,1);+#29=LINE($,#26,#28);+#30=EDGE_CURVE($,#17,#25,#29,.T.);+#31=ORIENTED_EDGE($,$,$,#30,.T.);+#32=CARTESIAN_POINT($,(180,2.1,1.2));+#33=VERTEX_POINT($,#32);+#34=CARTESIAN_POINT($,(180,0,1.2));+#35=DIRECTION($,(0,1,0));+#36=VECTOR($,#35,1);+#37=LINE($,#34,#36);+#38=EDGE_CURVE($,#25,#33,#37,.T.);+#39=ORIENTED_EDGE($,$,$,#38,.T.);+#40=CARTESIAN_POINT($,(180,117.3,1.2));+#41=VERTEX_POINT($,#40);+#42=CARTESIAN_POINT($,(180,2.1,1.2));+#43=DIRECTION($,(0,1,0));+#44=VECTOR($,#43,1);+#45=LINE($,#42,#44);+#46=EDGE_CURVE($,#33,#41,#45,.T.);+#47=ORIENTED_EDGE($,$,$,#46,.T.);+#48=CARTESIAN_POINT($,(180,120,1.2));+#49=VERTEX_POINT($,#48);+#50=CARTESIAN_POINT($,(180,117.3,1.2));+#51=DIRECTION($,(0,1,0));+#52=VECTOR($,#51,1);+#53=LINE($,#50,#52);+#54=EDGE_CURVE($,#41,#49,#53,.T.);+#55=ORIENTED_EDGE($,$,$,#54,.T.);+#56=CARTESIAN_POINT($,(177.3,120,1.2));+#57=VERTEX_POINT($,#56);+#58=CARTESIAN_POINT($,(180,120,1.2));+#59=DIRECTION($,(-1,0,0));+#60=VECTOR($,#59,1);+#61=LINE($,#58,#60);+#62=EDGE_CURVE($,#49,#57,#61,.T.);+#63=ORIENTED_EDGE($,$,$,#62,.T.);+#64=CARTESIAN_POINT($,(2.69999999999999,120,1.2));+#65=VERTEX_POINT($,#64);+#66=CARTESIAN_POINT($,(177.3,120,1.2));+#67=DIRECTION($,(-1,0,0));+#68=VECTOR($,#67,1);+#69=LINE($,#66,#68);+#70=EDGE_CURVE($,#57,#65,#69,.T.);+#71=ORIENTED_EDGE($,$,$,#70,.T.);+#72=CARTESIAN_POINT($,(0,120,1.2));+#73=VERTEX_POINT($,#72);+#74=CARTESIAN_POINT($,(2.69999999999999,120,1.2));+#75=DIRECTION($,(-1,0,0));+#76=VECTOR($,#75,1);+#77=LINE($,#74,#76);+#78=EDGE_CURVE($,#65,#73,#77,.T.);+#79=ORIENTED_EDGE($,$,$,#78,.T.);+#80=CARTESIAN_POINT($,(0,117.3,1.2));+#81=VERTEX_POINT($,#80);+#82=CARTESIAN_POINT($,(0,120,1.2));+#83=DIRECTION($,(0,-1,0));+#84=VECTOR($,#83,1);+#85=LINE($,#82,#84);+#86=EDGE_CURVE($,#73,#81,#85,.T.);+#87=ORIENTED_EDGE($,$,$,#86,.T.);+#88=CARTESIAN_POINT($,(0,2.7,1.2));+#89=VERTEX_POINT($,#88);+#90=CARTESIAN_POINT($,(0,117.3,1.2));+#91=DIRECTION($,(0,-1,0));+#92=VECTOR($,#91,1);+#93=LINE($,#90,#92);+#94=EDGE_CURVE($,#81,#89,#93,.T.);+#95=ORIENTED_EDGE($,$,$,#94,.T.);+#96=CARTESIAN_POINT($,(0,2.7,1.2));+#97=DIRECTION($,(0,-1,0));+#98=VECTOR($,#97,1);+#99=LINE($,#96,#98);+#100=EDGE_CURVE($,#89,#7,#99,.T.);+#101=ORIENTED_EDGE($,$,$,#100,.T.);+#102=EDGE_LOOP($,(#15,#23,#31,#39,#47,#55,#63,#71,#79,#87,#95,#101));+#103=FACE_OUTER_BOUND('',#102,.T.);+#104=CARTESIAN_POINT($,(17,15,1.2));+#105=VERTEX_POINT($,#104);+#106=CARTESIAN_POINT($,(15,15,1.2));+#107=DIRECTION($,(0,0,1));+#108=DIRECTION($,(1,0,0));+#109=AXIS2_PLACEMENT_3D($,#106,#107,#108);+#110=CIRCLE($,#109,2);+#111=EDGE_CURVE($,#105,#105,#110,.T.);+#112=ORIENTED_EDGE($,$,$,#111,.T.);+#113=EDGE_LOOP($,(#112));+#114=FACE_BOUND('',#113,.T.);+#115=CARTESIAN_POINT($,(167,15,1.2));+#116=VERTEX_POINT($,#115);+#117=CARTESIAN_POINT($,(165,15,1.2));+#118=DIRECTION($,(0,0,1));+#119=DIRECTION($,(1,0,0));+#120=AXIS2_PLACEMENT_3D($,#117,#118,#119);+#121=CIRCLE($,#120,2);+#122=EDGE_CURVE($,#116,#116,#121,.T.);+#123=ORIENTED_EDGE($,$,$,#122,.T.);+#124=EDGE_LOOP($,(#123));+#125=FACE_BOUND('',#124,.T.);+#126=CARTESIAN_POINT($,(17,105,1.2));+#127=VERTEX_POINT($,#126);+#128=CARTESIAN_POINT($,(15,105,1.2));+#129=DIRECTION($,(0,0,1));+#130=DIRECTION($,(1,0,0));+#131=AXIS2_PLACEMENT_3D($,#128,#129,#130);+#132=CIRCLE($,#131,2);+#133=EDGE_CURVE($,#127,#127,#132,.T.);+#134=ORIENTED_EDGE($,$,$,#133,.T.);+#135=EDGE_LOOP($,(#134));+#136=FACE_BOUND('',#135,.T.);+#137=CARTESIAN_POINT($,(167,105,1.2));+#138=VERTEX_POINT($,#137);+#139=CARTESIAN_POINT($,(165,105,1.2));+#140=DIRECTION($,(0,0,1));+#141=DIRECTION($,(1,0,0));+#142=AXIS2_PLACEMENT_3D($,#139,#140,#141);+#143=CIRCLE($,#142,2);+#144=EDGE_CURVE($,#138,#138,#143,.T.);+#145=ORIENTED_EDGE($,$,$,#144,.T.);+#146=EDGE_LOOP($,(#145));+#147=FACE_BOUND('',#146,.T.);+#148=CARTESIAN_POINT($,(84.5,63,1.2));+#149=VERTEX_POINT($,#148);+#150=CARTESIAN_POINT($,(39.5,63,1.2));+#151=VERTEX_POINT($,#150);+#152=CARTESIAN_POINT($,(84.5,63,1.2));+#153=DIRECTION($,(-1,0,0));+#154=VECTOR($,#153,1);+#155=LINE($,#152,#154);+#156=EDGE_CURVE($,#149,#151,#155,.T.);+#157=ORIENTED_EDGE($,$,$,#156,.F.);+#158=CARTESIAN_POINT($,(84.5,57,1.2));+#159=VERTEX_POINT($,#158);+#160=CARTESIAN_POINT($,(84.5,57,1.2));+#161=DIRECTION($,(0,1,0));+#162=VECTOR($,#161,1);+#163=LINE($,#160,#162);+#164=EDGE_CURVE($,#159,#149,#163,.T.);+#165=ORIENTED_EDGE($,$,$,#164,.F.);+#166=CARTESIAN_POINT($,(39.5,57,1.2));+#167=VERTEX_POINT($,#166);+#168=CARTESIAN_POINT($,(39.5,57,1.2));+#169=DIRECTION($,(1,0,0));+#170=VECTOR($,#169,1);+#171=LINE($,#168,#170);+#172=EDGE_CURVE($,#167,#159,#171,.T.);+#173=ORIENTED_EDGE($,$,$,#172,.F.);+#174=CARTESIAN_POINT($,(39.5,63,1.2));+#175=DIRECTION($,(0,-1,0));+#176=VECTOR($,#175,1);+#177=LINE($,#174,#176);+#178=EDGE_CURVE($,#151,#167,#177,.T.);+#179=ORIENTED_EDGE($,$,$,#178,.F.);+#180=EDGE_LOOP($,(#157,#165,#173,#179));+#181=FACE_BOUND('',#180,.T.);+#182=CARTESIAN_POINT($,(112.5,63,1.2));+#183=VERTEX_POINT($,#182);+#184=CARTESIAN_POINT($,(67.5,63,1.2));+#185=VERTEX_POINT($,#184);+#186=CARTESIAN_POINT($,(112.5,63,1.2));+#187=DIRECTION($,(-1,0,0));+#188=VECTOR($,#187,1);+#189=LINE($,#186,#188);+#190=EDGE_CURVE($,#183,#185,#189,.T.);+#191=ORIENTED_EDGE($,$,$,#190,.F.);+#192=CARTESIAN_POINT($,(112.5,57,1.2));+#193=VERTEX_POINT($,#192);+#194=CARTESIAN_POINT($,(112.5,57,1.2));+#195=DIRECTION($,(0,1,0));+#196=VECTOR($,#195,1);+#197=LINE($,#194,#196);+#198=EDGE_CURVE($,#193,#183,#197,.T.);+#199=ORIENTED_EDGE($,$,$,#198,.F.);+#200=CARTESIAN_POINT($,(67.5,57,1.2));+#201=VERTEX_POINT($,#200);+#202=CARTESIAN_POINT($,(67.5,57,1.2));+#203=DIRECTION($,(1,0,0));+#204=VECTOR($,#203,1);+#205=LINE($,#202,#204);+#206=EDGE_CURVE($,#201,#193,#205,.T.);+#207=ORIENTED_EDGE($,$,$,#206,.F.);+#208=CARTESIAN_POINT($,(67.5,63,1.2));+#209=DIRECTION($,(0,-1,0));+#210=VECTOR($,#209,1);+#211=LINE($,#208,#210);+#212=EDGE_CURVE($,#185,#201,#211,.T.);+#213=ORIENTED_EDGE($,$,$,#212,.F.);+#214=EDGE_LOOP($,(#191,#199,#207,#213));+#215=FACE_BOUND('',#214,.T.);+#216=CARTESIAN_POINT($,(140.5,63,1.2));+#217=VERTEX_POINT($,#216);+#218=CARTESIAN_POINT($,(95.5,63,1.2));+#219=VERTEX_POINT($,#218);+#220=CARTESIAN_POINT($,(140.5,63,1.2));+#221=DIRECTION($,(-1,0,0));+#222=VECTOR($,#221,1);+#223=LINE($,#220,#222);+#224=EDGE_CURVE($,#217,#219,#223,.T.);+#225=ORIENTED_EDGE($,$,$,#224,.F.);+#226=CARTESIAN_POINT($,(140.5,57,1.2));+#227=VERTEX_POINT($,#226);+#228=CARTESIAN_POINT($,(140.5,57,1.2));+#229=DIRECTION($,(0,1,0));+#230=VECTOR($,#229,1);+#231=LINE($,#228,#230);+#232=EDGE_CURVE($,#227,#217,#231,.T.);+#233=ORIENTED_EDGE($,$,$,#232,.F.);+#234=CARTESIAN_POINT($,(95.5,57,1.2));+#235=VERTEX_POINT($,#234);+#236=CARTESIAN_POINT($,(95.5,57,1.2));+#237=DIRECTION($,(1,0,0));+#238=VECTOR($,#237,1);+#239=LINE($,#236,#238);+#240=EDGE_CURVE($,#235,#227,#239,.T.);+#241=ORIENTED_EDGE($,$,$,#240,.F.);+#242=CARTESIAN_POINT($,(95.5,63,1.2));+#243=DIRECTION($,(0,-1,0));+#244=VECTOR($,#243,1);+#245=LINE($,#242,#244);+#246=EDGE_CURVE($,#219,#235,#245,.T.);+#247=ORIENTED_EDGE($,$,$,#246,.F.);+#248=EDGE_LOOP($,(#225,#233,#241,#247));+#249=FACE_BOUND('',#248,.T.);+#250=ADVANCED_FACE('',(#103,#114,#125,#136,#147,#181,#215,#249),#5,.T.);+#251=CARTESIAN_POINT($,(0,0,0));+#252=DIRECTION($,(-0,-0,-1));+#253=DIRECTION($,(1,0,0));+#254=AXIS2_PLACEMENT_3D($,#251,#252,#253);+#255=PLANE($,#254);+#256=CARTESIAN_POINT($,(0,2.7,0));+#257=VERTEX_POINT($,#256);+#258=CARTESIAN_POINT($,(0,117.3,0));+#259=VERTEX_POINT($,#258);+#260=CARTESIAN_POINT($,(0,2.7,0));+#261=DIRECTION($,(0,1,0));+#262=VECTOR($,#261,1);+#263=LINE($,#260,#262);+#264=EDGE_CURVE($,#257,#259,#263,.T.);+#265=ORIENTED_EDGE($,$,$,#264,.T.);+#266=CARTESIAN_POINT($,(0,120,-0));+#267=VERTEX_POINT($,#266);+#268=CARTESIAN_POINT($,(0,117.3,0));+#269=DIRECTION($,(0,1,0));+#270=VECTOR($,#269,1);+#271=LINE($,#268,#270);+#272=EDGE_CURVE($,#259,#267,#271,.T.);+#273=ORIENTED_EDGE($,$,$,#272,.T.);+#274=CARTESIAN_POINT($,(2.7,120,0));+#275=VERTEX_POINT($,#274);+#276=CARTESIAN_POINT($,(0,120,-0));+#277=DIRECTION($,(1,0,0));+#278=VECTOR($,#277,1);+#279=LINE($,#276,#278);+#280=EDGE_CURVE($,#267,#275,#279,.T.);+#281=ORIENTED_EDGE($,$,$,#280,.T.);+#282=CARTESIAN_POINT($,(177.3,120,0));+#283=VERTEX_POINT($,#282);+#284=CARTESIAN_POINT($,(2.7,120,0));+#285=DIRECTION($,(1,0,0));+#286=VECTOR($,#285,1);+#287=LINE($,#284,#286);+#288=EDGE_CURVE($,#275,#283,#287,.T.);+#289=ORIENTED_EDGE($,$,$,#288,.T.);+#290=CARTESIAN_POINT($,(180,120,-0));+#291=VERTEX_POINT($,#290);+#292=CARTESIAN_POINT($,(177.3,120,0));+#293=DIRECTION($,(1,0,0));+#294=VECTOR($,#293,1);+#295=LINE($,#292,#294);+#296=EDGE_CURVE($,#283,#291,#295,.T.);+#297=ORIENTED_EDGE($,$,$,#296,.T.);+#298=CARTESIAN_POINT($,(180,117.3,0));+#299=VERTEX_POINT($,#298);+#300=CARTESIAN_POINT($,(180,120,-0));+#301=DIRECTION($,(0,-1,0));+#302=VECTOR($,#301,1);+#303=LINE($,#300,#302);+#304=EDGE_CURVE($,#291,#299,#303,.T.);+#305=ORIENTED_EDGE($,$,$,#304,.T.);+#306=CARTESIAN_POINT($,(180,2.09999999999999,0));+#307=VERTEX_POINT($,#306);+#308=CARTESIAN_POINT($,(180,117.3,0));+#309=DIRECTION($,(0,-1,0));+#310=VECTOR($,#309,1);+#311=LINE($,#308,#310);+#312=EDGE_CURVE($,#299,#307,#311,.T.);+#313=ORIENTED_EDGE($,$,$,#312,.T.);+#314=CARTESIAN_POINT($,(180,0,-0));+#315=VERTEX_POINT($,#314);+#316=CARTESIAN_POINT($,(180,2.09999999999999,0));+#317=DIRECTION($,(0,-1,0));+#318=VECTOR($,#317,1);+#319=LINE($,#316,#318);+#320=EDGE_CURVE($,#307,#315,#319,.T.);+#321=ORIENTED_EDGE($,$,$,#320,.T.);+#322=CARTESIAN_POINT($,(177.9,0,0));+#323=VERTEX_POINT($,#322);+#324=CARTESIAN_POINT($,(180,0,-0));+#325=DIRECTION($,(-1,0,0));+#326=VECTOR($,#325,1);+#327=LINE($,#324,#326);+#328=EDGE_CURVE($,#315,#323,#327,.T.);+#329=ORIENTED_EDGE($,$,$,#328,.T.);+#330=CARTESIAN_POINT($,(2.69999999999999,0,0));+#331=VERTEX_POINT($,#330);+#332=CARTESIAN_POINT($,(177.9,0,0));+#333=DIRECTION($,(-1,0,0));+#334=VECTOR($,#333,1);+#335=LINE($,#332,#334);+#336=EDGE_CURVE($,#323,#331,#335,.T.);+#337=ORIENTED_EDGE($,$,$,#336,.T.);+#338=CARTESIAN_POINT($,(0,0,0));+#339=VERTEX_POINT($,#338);+#340=CARTESIAN_POINT($,(2.69999999999999,0,0));+#341=DIRECTION($,(-1,0,0));+#342=VECTOR($,#341,1);+#343=LINE($,#340,#342);+#344=EDGE_CURVE($,#331,#339,#343,.T.);+#345=ORIENTED_EDGE($,$,$,#344,.T.);+#346=CARTESIAN_POINT($,(0,0,0));+#347=DIRECTION($,(0,1,0));+#348=VECTOR($,#347,1);+#349=LINE($,#346,#348);+#350=EDGE_CURVE($,#339,#257,#349,.T.);+#351=ORIENTED_EDGE($,$,$,#350,.T.);+#352=EDGE_LOOP($,(#265,#273,#281,#289,#297,#305,#313,#321,#329,#337,#345,#351));+#353=FACE_OUTER_BOUND('',#352,.T.);+#354=CARTESIAN_POINT($,(17,15,0));+#355=VERTEX_POINT($,#354);+#356=CARTESIAN_POINT($,(15,15,0));+#357=DIRECTION($,(0,0,1));+#358=DIRECTION($,(1,0,0));+#359=AXIS2_PLACEMENT_3D($,#356,#357,#358);+#360=CIRCLE($,#359,2);+#361=EDGE_CURVE($,#355,#355,#360,.T.);+#362=ORIENTED_EDGE($,$,$,#361,.T.);+#363=EDGE_LOOP($,(#362));+#364=FACE_BOUND('',#363,.T.);+#365=CARTESIAN_POINT($,(167,15,0));+#366=VERTEX_POINT($,#365);+#367=CARTESIAN_POINT($,(165,15,0));+#368=DIRECTION($,(0,0,1));+#369=DIRECTION($,(1,0,0));+#370=AXIS2_PLACEMENT_3D($,#367,#368,#369);+#371=CIRCLE($,#370,2);+#372=EDGE_CURVE($,#366,#366,#371,.T.);+#373=ORIENTED_EDGE($,$,$,#372,.T.);+#374=EDGE_LOOP($,(#373));+#375=FACE_BOUND('',#374,.T.);+#376=CARTESIAN_POINT($,(17,105,0));+#377=VERTEX_POINT($,#376);+#378=CARTESIAN_POINT($,(15,105,0));+#379=DIRECTION($,(0,0,1));+#380=DIRECTION($,(1,0,0));+#381=AXIS2_PLACEMENT_3D($,#378,#379,#380);+#382=CIRCLE($,#381,2);+#383=EDGE_CURVE($,#377,#377,#382,.T.);+#384=ORIENTED_EDGE($,$,$,#383,.T.);+#385=EDGE_LOOP($,(#384));+#386=FACE_BOUND('',#385,.T.);+#387=CARTESIAN_POINT($,(167,105,0));+#388=VERTEX_POINT($,#387);+#389=CARTESIAN_POINT($,(165,105,0));+#390=DIRECTION($,(0,0,1));+#391=DIRECTION($,(1,0,0));+#392=AXIS2_PLACEMENT_3D($,#389,#390,#391);+#393=CIRCLE($,#392,2);+#394=EDGE_CURVE($,#388,#388,#393,.T.);+#395=ORIENTED_EDGE($,$,$,#394,.T.);+#396=EDGE_LOOP($,(#395));+#397=FACE_BOUND('',#396,.T.);+#398=CARTESIAN_POINT($,(39.5,57,0));+#399=VERTEX_POINT($,#398);+#400=CARTESIAN_POINT($,(84.5,57,-0));+#401=VERTEX_POINT($,#400);+#402=CARTESIAN_POINT($,(39.5,57,0));+#403=DIRECTION($,(1,0,0));+#404=VECTOR($,#403,1);+#405=LINE($,#402,#404);+#406=EDGE_CURVE($,#399,#401,#405,.T.);+#407=ORIENTED_EDGE($,$,$,#406,.T.);+#408=CARTESIAN_POINT($,(84.5,63,-0));+#409=VERTEX_POINT($,#408);+#410=CARTESIAN_POINT($,(84.5,57,-0));+#411=DIRECTION($,(0,1,0));+#412=VECTOR($,#411,1);+#413=LINE($,#410,#412);+#414=EDGE_CURVE($,#401,#409,#413,.T.);+#415=ORIENTED_EDGE($,$,$,#414,.T.);+#416=CARTESIAN_POINT($,(39.5,63,-0));+#417=VERTEX_POINT($,#416);+#418=CARTESIAN_POINT($,(84.5,63,-0));+#419=DIRECTION($,(-1,0,0));+#420=VECTOR($,#419,1);+#421=LINE($,#418,#420);+#422=EDGE_CURVE($,#409,#417,#421,.T.);+#423=ORIENTED_EDGE($,$,$,#422,.T.);+#424=CARTESIAN_POINT($,(39.5,63,-0));+#425=DIRECTION($,(0,-1,0));+#426=VECTOR($,#425,1);+#427=LINE($,#424,#426);+#428=EDGE_CURVE($,#417,#399,#427,.T.);+#429=ORIENTED_EDGE($,$,$,#428,.T.);+#430=EDGE_LOOP($,(#407,#415,#423,#429));+#431=FACE_BOUND('',#430,.T.);+#432=CARTESIAN_POINT($,(67.5,57,0));+#433=VERTEX_POINT($,#432);+#434=CARTESIAN_POINT($,(112.5,57,-0));+#435=VERTEX_POINT($,#434);+#436=CARTESIAN_POINT($,(67.5,57,0));+#437=DIRECTION($,(1,0,0));+#438=VECTOR($,#437,1);+#439=LINE($,#436,#438);+#440=EDGE_CURVE($,#433,#435,#439,.T.);+#441=ORIENTED_EDGE($,$,$,#440,.T.);+#442=CARTESIAN_POINT($,(112.5,63,-0));+#443=VERTEX_POINT($,#442);+#444=CARTESIAN_POINT($,(112.5,57,-0));+#445=DIRECTION($,(0,1,0));+#446=VECTOR($,#445,1);+#447=LINE($,#444,#446);+#448=EDGE_CURVE($,#435,#443,#447,.T.);+#449=ORIENTED_EDGE($,$,$,#448,.T.);+#450=CARTESIAN_POINT($,(67.5,63,-0));+#451=VERTEX_POINT($,#450);+#452=CARTESIAN_POINT($,(112.5,63,-0));+#453=DIRECTION($,(-1,0,0));+#454=VECTOR($,#453,1);+#455=LINE($,#452,#454);+#456=EDGE_CURVE($,#443,#451,#455,.T.);+#457=ORIENTED_EDGE($,$,$,#456,.T.);+#458=CARTESIAN_POINT($,(67.5,63,-0));+#459=DIRECTION($,(0,-1,0));+#460=VECTOR($,#459,1);+#461=LINE($,#458,#460);+#462=EDGE_CURVE($,#451,#433,#461,.T.);+#463=ORIENTED_EDGE($,$,$,#462,.T.);+#464=EDGE_LOOP($,(#441,#449,#457,#463));+#465=FACE_BOUND('',#464,.T.);+#466=CARTESIAN_POINT($,(95.5,57,0));+#467=VERTEX_POINT($,#466);+#468=CARTESIAN_POINT($,(140.5,57,-0));+#469=VERTEX_POINT($,#468);+#470=CARTESIAN_POINT($,(95.5,57,0));+#471=DIRECTION($,(1,0,0));+#472=VECTOR($,#471,1);+#473=LINE($,#470,#472);+#474=EDGE_CURVE($,#467,#469,#473,.T.);+#475=ORIENTED_EDGE($,$,$,#474,.T.);+#476=CARTESIAN_POINT($,(140.5,63,-0));+#477=VERTEX_POINT($,#476);+#478=CARTESIAN_POINT($,(140.5,57,-0));+#479=DIRECTION($,(0,1,0));+#480=VECTOR($,#479,1);+#481=LINE($,#478,#480);+#482=EDGE_CURVE($,#469,#477,#481,.T.);+#483=ORIENTED_EDGE($,$,$,#482,.T.);+#484=CARTESIAN_POINT($,(95.5,63,-0));+#485=VERTEX_POINT($,#484);+#486=CARTESIAN_POINT($,(140.5,63,-0));+#487=DIRECTION($,(-1,0,0));+#488=VECTOR($,#487,1);+#489=LINE($,#486,#488);+#490=EDGE_CURVE($,#477,#485,#489,.T.);+#491=ORIENTED_EDGE($,$,$,#490,.T.);+#492=CARTESIAN_POINT($,(95.5,63,-0));+#493=DIRECTION($,(0,-1,0));+#494=VECTOR($,#493,1);+#495=LINE($,#492,#494);+#496=EDGE_CURVE($,#485,#467,#495,.T.);+#497=ORIENTED_EDGE($,$,$,#496,.T.);+#498=EDGE_LOOP($,(#475,#483,#491,#497));+#499=FACE_BOUND('',#498,.T.);+#500=ADVANCED_FACE('',(#353,#364,#375,#386,#397,#431,#465,#499),#255,.F.);+#501=CARTESIAN_POINT($,(2.7,-1.5,2.7));+#502=DIRECTION($,(0,1,0));+#503=DIRECTION($,(1,0,0));+#504=AXIS2_PLACEMENT_3D($,#501,#502,#503);+#505=PLANE($,#504);+#506=CARTESIAN_POINT($,(2.7,-1.5,2.7));+#507=VERTEX_POINT($,#506);+#508=CARTESIAN_POINT($,(177.9,-1.5,2.7));+#509=VERTEX_POINT($,#508);+#510=CARTESIAN_POINT($,(2.7,-1.5,2.7));+#511=DIRECTION($,(1,0,0));+#512=VECTOR($,#511,1);+#513=LINE($,#510,#512);+#514=EDGE_CURVE($,#507,#509,#513,.T.);+#515=ORIENTED_EDGE($,$,$,#514,.T.);+#516=CARTESIAN_POINT($,(177.9,-1.5,37.7));+#517=VERTEX_POINT($,#516);+#518=CARTESIAN_POINT($,(177.9,-1.5,2.7));+#519=DIRECTION($,(0,-0,1));+#520=VECTOR($,#519,1);+#521=LINE($,#518,#520);+#522=EDGE_CURVE($,#509,#517,#521,.T.);+#523=ORIENTED_EDGE($,$,$,#522,.T.);+#524=CARTESIAN_POINT($,(2.69999999999999,-1.5,37.7));+#525=VERTEX_POINT($,#524);+#526=CARTESIAN_POINT($,(177.9,-1.5,37.7));+#527=DIRECTION($,(-1,0,0));+#528=VECTOR($,#527,1);+#529=LINE($,#526,#528);+#530=EDGE_CURVE($,#517,#525,#529,.T.);+#531=ORIENTED_EDGE($,$,$,#530,.T.);+#532=CARTESIAN_POINT($,(2.69999999999999,-1.5,37.7));+#533=DIRECTION($,(0,0,-1));+#534=VECTOR($,#533,1);+#535=LINE($,#532,#534);+#536=EDGE_CURVE($,#525,#507,#535,.T.);+#537=ORIENTED_EDGE($,$,$,#536,.T.);+#538=EDGE_LOOP($,(#515,#523,#531,#537));+#539=FACE_OUTER_BOUND('',#538,.T.);+#540=ADVANCED_FACE('',(#539),#505,.T.);+#541=CARTESIAN_POINT($,(2.7,-2.7,2.7));+#542=DIRECTION($,(-0,-1,-0));+#543=DIRECTION($,(1,0,0));+#544=AXIS2_PLACEMENT_3D($,#541,#542,#543);+#545=PLANE($,#544);+#546=CARTESIAN_POINT($,(2.7,-2.7,37.7));+#547=VERTEX_POINT($,#546);+#548=CARTESIAN_POINT($,(177.9,-2.7,37.7));+#549=VERTEX_POINT($,#548);+#550=CARTESIAN_POINT($,(2.7,-2.7,37.7));+#551=DIRECTION($,(1,0,0));+#552=VECTOR($,#551,1);+#553=LINE($,#550,#552);+#554=EDGE_CURVE($,#547,#549,#553,.T.);+#555=ORIENTED_EDGE($,$,$,#554,.T.);+#556=CARTESIAN_POINT($,(177.9,-2.7,2.7));+#557=VERTEX_POINT($,#556);+#558=CARTESIAN_POINT($,(177.9,-2.7,37.7));+#559=DIRECTION($,(0,0,-1));+#560=VECTOR($,#559,1);+#561=LINE($,#558,#560);+#562=EDGE_CURVE($,#549,#557,#561,.T.);+#563=ORIENTED_EDGE($,$,$,#562,.T.);+#564=CARTESIAN_POINT($,(2.69999999999999,-2.7,2.7));+#565=VERTEX_POINT($,#564);+#566=CARTESIAN_POINT($,(177.9,-2.7,2.7));+#567=DIRECTION($,(-1,0,0));+#568=VECTOR($,#567,1);+#569=LINE($,#566,#568);+#570=EDGE_CURVE($,#557,#565,#569,.T.);+#571=ORIENTED_EDGE($,$,$,#570,.T.);+#572=CARTESIAN_POINT($,(2.69999999999999,-2.7,2.7));+#573=DIRECTION($,(0,-0,1));+#574=VECTOR($,#573,1);+#575=LINE($,#572,#574);+#576=EDGE_CURVE($,#565,#547,#575,.T.);+#577=ORIENTED_EDGE($,$,$,#576,.T.);+#578=EDGE_LOOP($,(#555,#563,#571,#577));+#579=FACE_OUTER_BOUND('',#578,.T.);+#580=ADVANCED_FACE('',(#579),#545,.F.);+#581=CARTESIAN_POINT($,(2.7,0,2.7));+#582=DIRECTION($,(1,0,0));+#583=DIRECTION($,(0,0,-1));+#584=AXIS2_PLACEMENT_3D($,#581,#582,#583);+#585=CYLINDRICAL_SURFACE($,#584,1.5);+#586=ORIENTED_EDGE($,$,$,#22,.T.);+#587=CARTESIAN_POINT($,(177.9,0,2.7));+#588=DIRECTION($,(-1,-0,-0));+#589=DIRECTION($,(0,0,-1));+#590=AXIS2_PLACEMENT_3D($,#587,#588,#589);+#591=CIRCLE($,#590,1.5);+#592=TRIMMED_CURVE($,#591,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#593=EDGE_CURVE($,#17,#509,#592,.T.);+#594=ORIENTED_EDGE($,$,$,#593,.T.);+#595=ORIENTED_EDGE($,$,$,#514,.F.);+#596=CARTESIAN_POINT($,(2.7,0,2.7));+#597=DIRECTION($,(1,0,0));+#598=DIRECTION($,(0,-1,-0));+#599=AXIS2_PLACEMENT_3D($,#596,#597,#598);+#600=CIRCLE($,#599,1.5);+#601=TRIMMED_CURVE($,#600,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#602=EDGE_CURVE($,#507,#9,#601,.T.);+#603=ORIENTED_EDGE($,$,$,#602,.T.);+#604=EDGE_LOOP($,(#586,#594,#595,#603));+#605=FACE_OUTER_BOUND('',#604,.T.);+#606=ADVANCED_FACE('',(#605),#585,.T.);+#607=CARTESIAN_POINT($,(2.7,0,2.7));+#608=DIRECTION($,(1,0,0));+#609=DIRECTION($,(0,0,-1));+#610=AXIS2_PLACEMENT_3D($,#607,#608,#609);+#611=CYLINDRICAL_SURFACE($,#610,2.7);+#612=ORIENTED_EDGE($,$,$,#570,.F.);+#613=CARTESIAN_POINT($,(177.9,0,2.7));+#614=DIRECTION($,(1,0,0));+#615=DIRECTION($,(0,-1,-0));+#616=AXIS2_PLACEMENT_3D($,#613,#614,#615);+#617=CIRCLE($,#616,2.7);+#618=TRIMMED_CURVE($,#617,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#619=EDGE_CURVE($,#557,#323,#618,.T.);+#620=ORIENTED_EDGE($,$,$,#619,.T.);+#621=ORIENTED_EDGE($,$,$,#336,.T.);+#622=CARTESIAN_POINT($,(2.7,0,2.7));+#623=DIRECTION($,(-1,-0,-0));+#624=DIRECTION($,(0,0,-1));+#625=AXIS2_PLACEMENT_3D($,#622,#623,#624);+#626=CIRCLE($,#625,2.7);+#627=TRIMMED_CURVE($,#626,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#628=EDGE_CURVE($,#331,#565,#627,.T.);+#629=ORIENTED_EDGE($,$,$,#628,.T.);+#630=EDGE_LOOP($,(#612,#620,#621,#629));+#631=FACE_OUTER_BOUND('',#630,.T.);+#632=ADVANCED_FACE('',(#631),#611,.F.);+#633=CARTESIAN_POINT($,(181.5,2.1,2.7));+#634=DIRECTION($,(-1,0,0));+#635=DIRECTION($,(0,1,0));+#636=AXIS2_PLACEMENT_3D($,#633,#634,#635);+#637=PLANE($,#636);+#638=CARTESIAN_POINT($,(181.5,2.1,2.7));+#639=VERTEX_POINT($,#638);+#640=CARTESIAN_POINT($,(181.5,117.3,2.7));+#641=VERTEX_POINT($,#640);+#642=CARTESIAN_POINT($,(181.5,2.1,2.7));+#643=DIRECTION($,(0,1,0));+#644=VECTOR($,#643,1);+#645=LINE($,#642,#644);+#646=EDGE_CURVE($,#639,#641,#645,.T.);+#647=ORIENTED_EDGE($,$,$,#646,.T.);+#648=CARTESIAN_POINT($,(181.5,117.3,37.7));+#649=VERTEX_POINT($,#648);+#650=CARTESIAN_POINT($,(181.5,117.3,2.7));+#651=DIRECTION($,(0,0,1));+#652=VECTOR($,#651,1);+#653=LINE($,#650,#652);+#654=EDGE_CURVE($,#641,#649,#653,.T.);+#655=ORIENTED_EDGE($,$,$,#654,.T.);+#656=CARTESIAN_POINT($,(181.5,2.1,37.7));+#657=VERTEX_POINT($,#656);+#658=CARTESIAN_POINT($,(181.5,117.3,37.7));+#659=DIRECTION($,(0,-1,0));+#660=VECTOR($,#659,1);+#661=LINE($,#658,#660);+#662=EDGE_CURVE($,#649,#657,#661,.T.);+#663=ORIENTED_EDGE($,$,$,#662,.T.);+#664=CARTESIAN_POINT($,(181.5,2.1,37.7));+#665=DIRECTION($,(0,0,-1));+#666=VECTOR($,#665,1);+#667=LINE($,#664,#666);+#668=EDGE_CURVE($,#657,#639,#667,.T.);+#669=ORIENTED_EDGE($,$,$,#668,.T.);+#670=EDGE_LOOP($,(#647,#655,#663,#669));+#671=FACE_OUTER_BOUND('',#670,.T.);+#672=ADVANCED_FACE('',(#671),#637,.T.);+#673=CARTESIAN_POINT($,(182.7,2.1,2.7));+#674=DIRECTION($,(1,-0,-0));+#675=DIRECTION($,(0,1,0));+#676=AXIS2_PLACEMENT_3D($,#673,#674,#675);+#677=PLANE($,#676);+#678=CARTESIAN_POINT($,(182.7,2.1,37.7));+#679=VERTEX_POINT($,#678);+#680=CARTESIAN_POINT($,(182.7,117.3,37.7));+#681=VERTEX_POINT($,#680);+#682=CARTESIAN_POINT($,(182.7,2.1,37.7));+#683=DIRECTION($,(0,1,0));+#684=VECTOR($,#683,1);+#685=LINE($,#682,#684);+#686=EDGE_CURVE($,#679,#681,#685,.T.);+#687=ORIENTED_EDGE($,$,$,#686,.T.);+#688=CARTESIAN_POINT($,(182.7,117.3,2.7));+#689=VERTEX_POINT($,#688);+#690=CARTESIAN_POINT($,(182.7,117.3,37.7));+#691=DIRECTION($,(0,0,-1));+#692=VECTOR($,#691,1);+#693=LINE($,#690,#692);+#694=EDGE_CURVE($,#681,#689,#693,.T.);+#695=ORIENTED_EDGE($,$,$,#694,.T.);+#696=CARTESIAN_POINT($,(182.7,2.09999999999999,2.7));+#697=VERTEX_POINT($,#696);+#698=CARTESIAN_POINT($,(182.7,117.3,2.7));+#699=DIRECTION($,(0,-1,0));+#700=VECTOR($,#699,1);+#701=LINE($,#698,#700);+#702=EDGE_CURVE($,#689,#697,#701,.T.);+#703=ORIENTED_EDGE($,$,$,#702,.T.);+#704=CARTESIAN_POINT($,(182.7,2.09999999999999,2.7));+#705=DIRECTION($,(0,0,1));+#706=VECTOR($,#705,1);+#707=LINE($,#704,#706);+#708=EDGE_CURVE($,#697,#679,#707,.T.);+#709=ORIENTED_EDGE($,$,$,#708,.T.);+#710=EDGE_LOOP($,(#687,#695,#703,#709));+#711=FACE_OUTER_BOUND('',#710,.T.);+#712=ADVANCED_FACE('',(#711),#677,.F.);+#713=CARTESIAN_POINT($,(180,2.1,2.7));+#714=DIRECTION($,(0,1,0));+#715=DIRECTION($,(0,0,-1));+#716=AXIS2_PLACEMENT_3D($,#713,#714,#715);+#717=CYLINDRICAL_SURFACE($,#716,1.5);+#718=ORIENTED_EDGE($,$,$,#46,.T.);+#719=CARTESIAN_POINT($,(180,117.3,2.7));+#720=DIRECTION($,(-0,-1,-0));+#721=DIRECTION($,(0,0,-1));+#722=AXIS2_PLACEMENT_3D($,#719,#720,#721);+#723=CIRCLE($,#722,1.5);+#724=TRIMMED_CURVE($,#723,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#725=EDGE_CURVE($,#41,#641,#724,.T.);+#726=ORIENTED_EDGE($,$,$,#725,.T.);+#727=ORIENTED_EDGE($,$,$,#646,.F.);+#728=CARTESIAN_POINT($,(180,2.1,2.7));+#729=DIRECTION($,(0,1,0));+#730=DIRECTION($,(1,0,-0));+#731=AXIS2_PLACEMENT_3D($,#728,#729,#730);+#732=CIRCLE($,#731,1.5);+#733=TRIMMED_CURVE($,#732,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#734=EDGE_CURVE($,#639,#33,#733,.T.);+#735=ORIENTED_EDGE($,$,$,#734,.T.);+#736=EDGE_LOOP($,(#718,#726,#727,#735));+#737=FACE_OUTER_BOUND('',#736,.T.);+#738=ADVANCED_FACE('',(#737),#717,.T.);+#739=CARTESIAN_POINT($,(180,2.1,2.7));+#740=DIRECTION($,(0,1,0));+#741=DIRECTION($,(0,0,-1));+#742=AXIS2_PLACEMENT_3D($,#739,#740,#741);+#743=CYLINDRICAL_SURFACE($,#742,2.7);+#744=ORIENTED_EDGE($,$,$,#702,.F.);+#745=CARTESIAN_POINT($,(180,117.3,2.7));+#746=DIRECTION($,(0,1,0));+#747=DIRECTION($,(1,0,-0));+#748=AXIS2_PLACEMENT_3D($,#745,#746,#747);+#749=CIRCLE($,#748,2.69999999999999);+#750=TRIMMED_CURVE($,#749,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#751=EDGE_CURVE($,#689,#299,#750,.T.);+#752=ORIENTED_EDGE($,$,$,#751,.T.);+#753=ORIENTED_EDGE($,$,$,#312,.T.);+#754=CARTESIAN_POINT($,(180,2.1,2.7));+#755=DIRECTION($,(-0,-1,-0));+#756=DIRECTION($,(0,0,-1));+#757=AXIS2_PLACEMENT_3D($,#754,#755,#756);+#758=CIRCLE($,#757,2.7);+#759=TRIMMED_CURVE($,#758,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#760=EDGE_CURVE($,#307,#697,#759,.T.);+#761=ORIENTED_EDGE($,$,$,#760,.T.);+#762=EDGE_LOOP($,(#744,#752,#753,#761));+#763=FACE_OUTER_BOUND('',#762,.T.);+#764=ADVANCED_FACE('',(#763),#743,.F.);+#765=CARTESIAN_POINT($,(177.3,121.5,2.7));+#766=DIRECTION($,(0,-1,0));+#767=DIRECTION($,(-1,0,0));+#768=AXIS2_PLACEMENT_3D($,#765,#766,#767);+#769=PLANE($,#768);+#770=CARTESIAN_POINT($,(177.3,121.5,2.7));+#771=VERTEX_POINT($,#770);+#772=CARTESIAN_POINT($,(2.69999999999999,121.5,2.7));+#773=VERTEX_POINT($,#772);+#774=CARTESIAN_POINT($,(177.3,121.5,2.7));+#775=DIRECTION($,(-1,0,0));+#776=VECTOR($,#775,1);+#777=LINE($,#774,#776);+#778=EDGE_CURVE($,#771,#773,#777,.T.);+#779=ORIENTED_EDGE($,$,$,#778,.T.);+#780=CARTESIAN_POINT($,(2.7,121.5,37.7));+#781=VERTEX_POINT($,#780);+#782=CARTESIAN_POINT($,(2.69999999999999,121.5,2.7));+#783=DIRECTION($,(0,0,1));+#784=VECTOR($,#783,1);+#785=LINE($,#782,#784);+#786=EDGE_CURVE($,#773,#781,#785,.T.);+#787=ORIENTED_EDGE($,$,$,#786,.T.);+#788=CARTESIAN_POINT($,(177.3,121.5,37.7));+#789=VERTEX_POINT($,#788);+#790=CARTESIAN_POINT($,(2.7,121.5,37.7));+#791=DIRECTION($,(1,0,0));+#792=VECTOR($,#791,1);+#793=LINE($,#790,#792);+#794=EDGE_CURVE($,#781,#789,#793,.T.);+#795=ORIENTED_EDGE($,$,$,#794,.T.);+#796=CARTESIAN_POINT($,(177.3,121.5,37.7));+#797=DIRECTION($,(0,0,-1));+#798=VECTOR($,#797,1);+#799=LINE($,#796,#798);+#800=EDGE_CURVE($,#789,#771,#799,.T.);+#801=ORIENTED_EDGE($,$,$,#800,.T.);+#802=EDGE_LOOP($,(#779,#787,#795,#801));+#803=FACE_OUTER_BOUND('',#802,.T.);+#804=ADVANCED_FACE('',(#803),#769,.T.);+#805=CARTESIAN_POINT($,(177.3,122.7,2.7));+#806=DIRECTION($,(-0,1,-0));+#807=DIRECTION($,(-1,0,0));+#808=AXIS2_PLACEMENT_3D($,#805,#806,#807);+#809=PLANE($,#808);+#810=CARTESIAN_POINT($,(177.3,122.7,37.7));+#811=VERTEX_POINT($,#810);+#812=CARTESIAN_POINT($,(2.7,122.7,37.7));+#813=VERTEX_POINT($,#812);+#814=CARTESIAN_POINT($,(177.3,122.7,37.7));+#815=DIRECTION($,(-1,0,0));+#816=VECTOR($,#815,1);+#817=LINE($,#814,#816);+#818=EDGE_CURVE($,#811,#813,#817,.T.);+#819=ORIENTED_EDGE($,$,$,#818,.T.);+#820=CARTESIAN_POINT($,(2.7,122.7,2.7));+#821=VERTEX_POINT($,#820);+#822=CARTESIAN_POINT($,(2.7,122.7,37.7));+#823=DIRECTION($,(0,0,-1));+#824=VECTOR($,#823,1);+#825=LINE($,#822,#824);+#826=EDGE_CURVE($,#813,#821,#825,.T.);+#827=ORIENTED_EDGE($,$,$,#826,.T.);+#828=CARTESIAN_POINT($,(177.3,122.7,2.7));+#829=VERTEX_POINT($,#828);+#830=CARTESIAN_POINT($,(2.7,122.7,2.7));+#831=DIRECTION($,(1,0,0));+#832=VECTOR($,#831,1);+#833=LINE($,#830,#832);+#834=EDGE_CURVE($,#821,#829,#833,.T.);+#835=ORIENTED_EDGE($,$,$,#834,.T.);+#836=CARTESIAN_POINT($,(177.3,122.7,2.7));+#837=DIRECTION($,(0,0,1));+#838=VECTOR($,#837,1);+#839=LINE($,#836,#838);+#840=EDGE_CURVE($,#829,#811,#839,.T.);+#841=ORIENTED_EDGE($,$,$,#840,.T.);+#842=EDGE_LOOP($,(#819,#827,#835,#841));+#843=FACE_OUTER_BOUND('',#842,.T.);+#844=ADVANCED_FACE('',(#843),#809,.F.);+#845=CARTESIAN_POINT($,(177.3,120,2.7));+#846=DIRECTION($,(-1,0,0));+#847=DIRECTION($,(0,0,-1));+#848=AXIS2_PLACEMENT_3D($,#845,#846,#847);+#849=CYLINDRICAL_SURFACE($,#848,1.5);+#850=ORIENTED_EDGE($,$,$,#70,.T.);+#851=CARTESIAN_POINT($,(2.69999999999999,120,2.7));+#852=DIRECTION($,(1,-0,-0));+#853=DIRECTION($,(0,0,-1));+#854=AXIS2_PLACEMENT_3D($,#851,#852,#853);+#855=CIRCLE($,#854,1.5);+#856=TRIMMED_CURVE($,#855,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#857=EDGE_CURVE($,#65,#773,#856,.T.);+#858=ORIENTED_EDGE($,$,$,#857,.T.);+#859=ORIENTED_EDGE($,$,$,#778,.F.);+#860=CARTESIAN_POINT($,(177.3,120,2.7));+#861=DIRECTION($,(-1,0,0));+#862=DIRECTION($,(0,1,-0));+#863=AXIS2_PLACEMENT_3D($,#860,#861,#862);+#864=CIRCLE($,#863,1.5);+#865=TRIMMED_CURVE($,#864,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#866=EDGE_CURVE($,#771,#57,#865,.T.);+#867=ORIENTED_EDGE($,$,$,#866,.T.);+#868=EDGE_LOOP($,(#850,#858,#859,#867));+#869=FACE_OUTER_BOUND('',#868,.T.);+#870=ADVANCED_FACE('',(#869),#849,.T.);+#871=CARTESIAN_POINT($,(177.3,120,2.7));+#872=DIRECTION($,(-1,0,0));+#873=DIRECTION($,(0,0,-1));+#874=AXIS2_PLACEMENT_3D($,#871,#872,#873);+#875=CYLINDRICAL_SURFACE($,#874,2.7);+#876=ORIENTED_EDGE($,$,$,#834,.F.);+#877=CARTESIAN_POINT($,(2.69999999999999,120,2.7));+#878=DIRECTION($,(-1,0,0));+#879=DIRECTION($,(0,1,-0));+#880=AXIS2_PLACEMENT_3D($,#877,#878,#879);+#881=CIRCLE($,#880,2.69999999999999);+#882=TRIMMED_CURVE($,#881,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#883=EDGE_CURVE($,#821,#275,#882,.T.);+#884=ORIENTED_EDGE($,$,$,#883,.T.);+#885=ORIENTED_EDGE($,$,$,#288,.T.);+#886=CARTESIAN_POINT($,(177.3,120,2.7));+#887=DIRECTION($,(1,-0,-0));+#888=DIRECTION($,(0,0,-1));+#889=AXIS2_PLACEMENT_3D($,#886,#887,#888);+#890=CIRCLE($,#889,2.7);+#891=TRIMMED_CURVE($,#890,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#892=EDGE_CURVE($,#283,#829,#891,.T.);+#893=ORIENTED_EDGE($,$,$,#892,.T.);+#894=EDGE_LOOP($,(#876,#884,#885,#893));+#895=FACE_OUTER_BOUND('',#894,.T.);+#896=ADVANCED_FACE('',(#895),#875,.F.);+#897=CARTESIAN_POINT($,(-1.5,117.3,2.7));+#898=DIRECTION($,(1,0,0));+#899=DIRECTION($,(0,-1,0));+#900=AXIS2_PLACEMENT_3D($,#897,#898,#899);+#901=PLANE($,#900);+#902=CARTESIAN_POINT($,(-1.5,117.3,2.7));+#903=VERTEX_POINT($,#902);+#904=CARTESIAN_POINT($,(-1.5,2.7,2.7));+#905=VERTEX_POINT($,#904);+#906=CARTESIAN_POINT($,(-1.5,117.3,2.7));+#907=DIRECTION($,(0,-1,0));+#908=VECTOR($,#907,1);+#909=LINE($,#906,#908);+#910=EDGE_CURVE($,#903,#905,#909,.T.);+#911=ORIENTED_EDGE($,$,$,#910,.T.);+#912=CARTESIAN_POINT($,(-1.5,2.7,37.7));+#913=VERTEX_POINT($,#912);+#914=CARTESIAN_POINT($,(-1.5,2.7,2.7));+#915=DIRECTION($,(-0,0,1));+#916=VECTOR($,#915,1);+#917=LINE($,#914,#916);+#918=EDGE_CURVE($,#905,#913,#917,.T.);+#919=ORIENTED_EDGE($,$,$,#918,.T.);+#920=CARTESIAN_POINT($,(-1.5,117.3,37.7));+#921=VERTEX_POINT($,#920);+#922=CARTESIAN_POINT($,(-1.5,2.7,37.7));+#923=DIRECTION($,(0,1,0));+#924=VECTOR($,#923,1);+#925=LINE($,#922,#924);+#926=EDGE_CURVE($,#913,#921,#925,.T.);+#927=ORIENTED_EDGE($,$,$,#926,.T.);+#928=CARTESIAN_POINT($,(-1.5,117.3,37.7));+#929=DIRECTION($,(0,0,-1));+#930=VECTOR($,#929,1);+#931=LINE($,#928,#930);+#932=EDGE_CURVE($,#921,#903,#931,.T.);+#933=ORIENTED_EDGE($,$,$,#932,.T.);+#934=EDGE_LOOP($,(#911,#919,#927,#933));+#935=FACE_OUTER_BOUND('',#934,.T.);+#936=ADVANCED_FACE('',(#935),#901,.T.);+#937=CARTESIAN_POINT($,(-2.7,117.3,2.7));+#938=DIRECTION($,(-1,-0,-0));+#939=DIRECTION($,(0,-1,0));+#940=AXIS2_PLACEMENT_3D($,#937,#938,#939);+#941=PLANE($,#940);+#942=CARTESIAN_POINT($,(-2.7,117.3,37.7));+#943=VERTEX_POINT($,#942);+#944=CARTESIAN_POINT($,(-2.7,2.7,37.7));+#945=VERTEX_POINT($,#944);+#946=CARTESIAN_POINT($,(-2.7,117.3,37.7));+#947=DIRECTION($,(0,-1,0));+#948=VECTOR($,#947,1);+#949=LINE($,#946,#948);+#950=EDGE_CURVE($,#943,#945,#949,.T.);+#951=ORIENTED_EDGE($,$,$,#950,.T.);+#952=CARTESIAN_POINT($,(-2.7,2.7,2.7));+#953=VERTEX_POINT($,#952);+#954=CARTESIAN_POINT($,(-2.7,2.7,37.7));+#955=DIRECTION($,(0,0,-1));+#956=VECTOR($,#955,1);+#957=LINE($,#954,#956);+#958=EDGE_CURVE($,#945,#953,#957,.T.);+#959=ORIENTED_EDGE($,$,$,#958,.T.);+#960=CARTESIAN_POINT($,(-2.7,117.3,2.7));+#961=VERTEX_POINT($,#960);+#962=CARTESIAN_POINT($,(-2.7,2.7,2.7));+#963=DIRECTION($,(0,1,0));+#964=VECTOR($,#963,1);+#965=LINE($,#962,#964);+#966=EDGE_CURVE($,#953,#961,#965,.T.);+#967=ORIENTED_EDGE($,$,$,#966,.T.);+#968=CARTESIAN_POINT($,(-2.7,117.3,2.7));+#969=DIRECTION($,(-0,0,1));+#970=VECTOR($,#969,1);+#971=LINE($,#968,#970);+#972=EDGE_CURVE($,#961,#943,#971,.T.);+#973=ORIENTED_EDGE($,$,$,#972,.T.);+#974=EDGE_LOOP($,(#951,#959,#967,#973));+#975=FACE_OUTER_BOUND('',#974,.T.);+#976=ADVANCED_FACE('',(#975),#941,.F.);+#977=CARTESIAN_POINT($,(0,117.3,2.7));+#978=DIRECTION($,(0,-1,0));+#979=DIRECTION($,(0,0,-1));+#980=AXIS2_PLACEMENT_3D($,#977,#978,#979);+#981=CYLINDRICAL_SURFACE($,#980,1.5);+#982=ORIENTED_EDGE($,$,$,#94,.T.);+#983=CARTESIAN_POINT($,(0,2.7,2.7));+#984=DIRECTION($,(-0,1,-0));+#985=DIRECTION($,(0,0,-1));+#986=AXIS2_PLACEMENT_3D($,#983,#984,#985);+#987=CIRCLE($,#986,1.5);+#988=TRIMMED_CURVE($,#987,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#989=EDGE_CURVE($,#89,#905,#988,.T.);+#990=ORIENTED_EDGE($,$,$,#989,.T.);+#991=ORIENTED_EDGE($,$,$,#910,.F.);+#992=CARTESIAN_POINT($,(0,117.3,2.7));+#993=DIRECTION($,(0,-1,0));+#994=DIRECTION($,(-1,0,-0));+#995=AXIS2_PLACEMENT_3D($,#992,#993,#994);+#996=CIRCLE($,#995,1.5);+#997=TRIMMED_CURVE($,#996,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#998=EDGE_CURVE($,#903,#81,#997,.T.);+#999=ORIENTED_EDGE($,$,$,#998,.T.);+#1000=EDGE_LOOP($,(#982,#990,#991,#999));+#1001=FACE_OUTER_BOUND('',#1000,.T.);+#1002=ADVANCED_FACE('',(#1001),#981,.T.);+#1003=CARTESIAN_POINT($,(0,117.3,2.7));+#1004=DIRECTION($,(0,-1,0));+#1005=DIRECTION($,(0,0,-1));+#1006=AXIS2_PLACEMENT_3D($,#1003,#1004,#1005);+#1007=CYLINDRICAL_SURFACE($,#1006,2.7);+#1008=ORIENTED_EDGE($,$,$,#966,.F.);+#1009=CARTESIAN_POINT($,(0,2.7,2.7));+#1010=DIRECTION($,(0,-1,0));+#1011=DIRECTION($,(-1,0,-0));+#1012=AXIS2_PLACEMENT_3D($,#1009,#1010,#1011);+#1013=CIRCLE($,#1012,2.7);+#1014=TRIMMED_CURVE($,#1013,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#1015=EDGE_CURVE($,#953,#257,#1014,.T.);+#1016=ORIENTED_EDGE($,$,$,#1015,.T.);+#1017=ORIENTED_EDGE($,$,$,#264,.T.);+#1018=CARTESIAN_POINT($,(0,117.3,2.7));+#1019=DIRECTION($,(-0,1,-0));+#1020=DIRECTION($,(0,0,-1));+#1021=AXIS2_PLACEMENT_3D($,#1018,#1019,#1020);+#1022=CIRCLE($,#1021,2.7);+#1023=TRIMMED_CURVE($,#1022,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#1024=EDGE_CURVE($,#259,#961,#1023,.T.);+#1025=ORIENTED_EDGE($,$,$,#1024,.T.);+#1026=EDGE_LOOP($,(#1008,#1016,#1017,#1025));+#1027=FACE_OUTER_BOUND('',#1026,.T.);+#1028=ADVANCED_FACE('',(#1027),#1007,.F.);+#1029=CARTESIAN_POINT($,(2.7,-3.9,40.1));+#1030=DIRECTION($,(0,0,1));+#1031=DIRECTION($,(1,0,0));+#1032=AXIS2_PLACEMENT_3D($,#1029,#1030,#1031);+#1033=PLANE($,#1032);+#1034=CARTESIAN_POINT($,(2.7,-3.9,40.1));+#1035=VERTEX_POINT($,#1034);+#1036=CARTESIAN_POINT($,(177.9,-3.9,40.1));+#1037=VERTEX_POINT($,#1036);+#1038=CARTESIAN_POINT($,(2.7,-3.9,40.1));+#1039=DIRECTION($,(1,0,0));+#1040=VECTOR($,#1039,1);+#1041=LINE($,#1038,#1040);+#1042=EDGE_CURVE($,#1035,#1037,#1041,.T.);+#1043=ORIENTED_EDGE($,$,$,#1042,.T.);+#1044=CARTESIAN_POINT($,(177.9,-13.9,40.1));+#1045=VERTEX_POINT($,#1044);+#1046=CARTESIAN_POINT($,(177.9,-3.9,40.1));+#1047=DIRECTION($,(0,-1,0));+#1048=VECTOR($,#1047,1);+#1049=LINE($,#1046,#1048);+#1050=EDGE_CURVE($,#1037,#1045,#1049,.T.);+#1051=ORIENTED_EDGE($,$,$,#1050,.T.);+#1052=CARTESIAN_POINT($,(2.7,-13.9,40.1));+#1053=VERTEX_POINT($,#1052);+#1054=CARTESIAN_POINT($,(177.9,-13.9,40.1));+#1055=DIRECTION($,(-1,0,0));+#1056=VECTOR($,#1055,1);+#1057=LINE($,#1054,#1056);+#1058=EDGE_CURVE($,#1045,#1053,#1057,.T.);+#1059=ORIENTED_EDGE($,$,$,#1058,.T.);+#1060=CARTESIAN_POINT($,(2.7,-13.9,40.1));+#1061=DIRECTION($,(0,1,0));+#1062=VECTOR($,#1061,1);+#1063=LINE($,#1060,#1062);+#1064=EDGE_CURVE($,#1053,#1035,#1063,.T.);+#1065=ORIENTED_EDGE($,$,$,#1064,.T.);+#1066=EDGE_LOOP($,(#1043,#1051,#1059,#1065));+#1067=FACE_OUTER_BOUND('',#1066,.T.);+#1068=ADVANCED_FACE('',(#1067),#1033,.T.);+#1069=CARTESIAN_POINT($,(2.7,-3.9,38.9));+#1070=DIRECTION($,(-0,-0,-1));+#1071=DIRECTION($,(1,0,0));+#1072=AXIS2_PLACEMENT_3D($,#1069,#1070,#1071);+#1073=PLANE($,#1072);+#1074=CARTESIAN_POINT($,(2.7,-13.9,38.9));+#1075=VERTEX_POINT($,#1074);+#1076=CARTESIAN_POINT($,(177.9,-13.9,38.9));+#1077=VERTEX_POINT($,#1076);+#1078=CARTESIAN_POINT($,(2.7,-13.9,38.9));+#1079=DIRECTION($,(1,0,0));+#1080=VECTOR($,#1079,1);+#1081=LINE($,#1078,#1080);+#1082=EDGE_CURVE($,#1075,#1077,#1081,.T.);+#1083=ORIENTED_EDGE($,$,$,#1082,.T.);+#1084=CARTESIAN_POINT($,(177.9,-3.9,38.9));+#1085=VERTEX_POINT($,#1084);+#1086=CARTESIAN_POINT($,(177.9,-13.9,38.9));+#1087=DIRECTION($,(0,1,0));+#1088=VECTOR($,#1087,1);+#1089=LINE($,#1086,#1088);+#1090=EDGE_CURVE($,#1077,#1085,#1089,.T.);+#1091=ORIENTED_EDGE($,$,$,#1090,.T.);+#1092=CARTESIAN_POINT($,(2.69999999999999,-3.9,38.9));+#1093=VERTEX_POINT($,#1092);+#1094=CARTESIAN_POINT($,(177.9,-3.9,38.9));+#1095=DIRECTION($,(-1,0,0));+#1096=VECTOR($,#1095,1);+#1097=LINE($,#1094,#1096);+#1098=EDGE_CURVE($,#1085,#1093,#1097,.T.);+#1099=ORIENTED_EDGE($,$,$,#1098,.T.);+#1100=CARTESIAN_POINT($,(2.69999999999999,-3.9,38.9));+#1101=DIRECTION($,(0,-1,0));+#1102=VECTOR($,#1101,1);+#1103=LINE($,#1100,#1102);+#1104=EDGE_CURVE($,#1093,#1075,#1103,.T.);+#1105=ORIENTED_EDGE($,$,$,#1104,.T.);+#1106=EDGE_LOOP($,(#1083,#1091,#1099,#1105));+#1107=FACE_OUTER_BOUND('',#1106,.T.);+#1108=ADVANCED_FACE('',(#1107),#1073,.F.);+#1109=CARTESIAN_POINT($,(2.7,-3.9,37.7));+#1110=DIRECTION($,(1,0,0));+#1111=DIRECTION($,(0,1,0));+#1112=AXIS2_PLACEMENT_3D($,#1109,#1110,#1111);+#1113=CYLINDRICAL_SURFACE($,#1112,2.4);+#1114=ORIENTED_EDGE($,$,$,#530,.F.);+#1115=CARTESIAN_POINT($,(177.9,-3.9,37.7));+#1116=DIRECTION($,(1,0,0));+#1117=DIRECTION($,(0,1,0));+#1118=AXIS2_PLACEMENT_3D($,#1115,#1116,#1117);+#1119=CIRCLE($,#1118,2.4);+#1120=TRIMMED_CURVE($,#1119,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#1121=EDGE_CURVE($,#517,#1037,#1120,.T.);+#1122=ORIENTED_EDGE($,$,$,#1121,.T.);+#1123=ORIENTED_EDGE($,$,$,#1042,.F.);+#1124=CARTESIAN_POINT($,(2.7,-3.9,37.7));+#1125=DIRECTION($,(-1,-0,-0));+#1126=DIRECTION($,(0,0,1));+#1127=AXIS2_PLACEMENT_3D($,#1124,#1125,#1126);+#1128=CIRCLE($,#1127,2.4);+#1129=TRIMMED_CURVE($,#1128,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#1130=EDGE_CURVE($,#1035,#525,#1129,.T.);+#1131=ORIENTED_EDGE($,$,$,#1130,.T.);+#1132=EDGE_LOOP($,(#1114,#1122,#1123,#1131));+#1133=FACE_OUTER_BOUND('',#1132,.T.);+#1134=ADVANCED_FACE('',(#1133),#1113,.T.);+#1135=CARTESIAN_POINT($,(2.7,-3.9,37.7));+#1136=DIRECTION($,(1,0,0));+#1137=DIRECTION($,(0,1,0));+#1138=AXIS2_PLACEMENT_3D($,#1135,#1136,#1137);+#1139=CYLINDRICAL_SURFACE($,#1138,1.2);+#1140=ORIENTED_EDGE($,$,$,#1098,.F.);+#1141=CARTESIAN_POINT($,(177.9,-3.9,37.7));+#1142=DIRECTION($,(-1,-0,-0));+#1143=DIRECTION($,(0,0,1));+#1144=AXIS2_PLACEMENT_3D($,#1141,#1142,#1143);+#1145=CIRCLE($,#1144,1.2);+#1146=TRIMMED_CURVE($,#1145,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#1147=EDGE_CURVE($,#1085,#549,#1146,.T.);+#1148=ORIENTED_EDGE($,$,$,#1147,.T.);+#1149=ORIENTED_EDGE($,$,$,#554,.F.);+#1150=CARTESIAN_POINT($,(2.7,-3.9,37.7));+#1151=DIRECTION($,(1,0,0));+#1152=DIRECTION($,(0,1,0));+#1153=AXIS2_PLACEMENT_3D($,#1150,#1151,#1152);+#1154=CIRCLE($,#1153,1.2);+#1155=TRIMMED_CURVE($,#1154,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);+#1156=EDGE_CURVE($,#547,#1093,#1155,.T.);+#1157=ORIENTED_EDGE($,$,$,#1156,.T.);+#1158=EDGE_LOOP($,(#1140,#1148,#1149,#1157));+#1159=FACE_OUTER_BOUND('',#1158,.T.);+#1160=ADVANCED_FACE('',(#1159),#1139,.F.);+#1161=CARTESIAN_POINT($,(0,0,1.2));+#1162=DIRECTION($,(-0,1,0));+#1163=DIRECTION($,(1,0,0));+#1164=AXIS2_PLACEMENT_3D($,#1161,#1162,#1163);+#1165=PLANE($,#1164);+#1166=ORIENTED_EDGE($,$,$,#14,.T.);+#1167=CARTESIAN_POINT($,(2.7,0,1.2));+#1168=DIRECTION($,(0,0,-1));+#1169=VECTOR($,#1168,1);+#1170=LINE($,#1167,#1169);+#1171=EDGE_CURVE($,#9,#331,#1170,.T.);+#1172=ORIENTED_EDGE($,$,$,#1171,.T.);+#1173=ORIENTED_EDGE($,$,$,#344,.T.);+#1174=CARTESIAN_POINT($,(0,0,0));+#1175=DIRECTION($,(0,0,1));+#1176=VECTOR($,#1175,1);+#1177=LINE($,#1174,#1176);+#1178=EDGE_CURVE($,#339,#7,#1177,.T.);+#1179=ORIENTED_EDGE($,$,$,#1178,.T.);+#1180=EDGE_LOOP($,(#1166,#1172,#1173,#1179));+#1181=FACE_OUTER_BOUND('',#1180,.T.);+#1182=ADVANCED_FACE('',(#1181),#1165,.T.);+#1183=CARTESIAN_POINT($,(177.9,0,1.2));+#1184=DIRECTION($,(-0,1,0));+#1185=DIRECTION($,(1,0,0));+#1186=AXIS2_PLACEMENT_3D($,#1183,#1184,#1185);+#1187=PLANE($,#1186);+#1188=ORIENTED_EDGE($,$,$,#30,.T.);+#1189=CARTESIAN_POINT($,(180,0,1.2));+#1190=DIRECTION($,(0,0,-1));+#1191=VECTOR($,#1190,1);+#1192=LINE($,#1189,#1191);+#1193=EDGE_CURVE($,#25,#315,#1192,.T.);+#1194=ORIENTED_EDGE($,$,$,#1193,.T.);+#1195=ORIENTED_EDGE($,$,$,#328,.T.);+#1196=CARTESIAN_POINT($,(177.9,0,0));+#1197=DIRECTION($,(0,0,1));+#1198=VECTOR($,#1197,1);+#1199=LINE($,#1196,#1198);+#1200=EDGE_CURVE($,#323,#17,#1199,.T.);+#1201=ORIENTED_EDGE($,$,$,#1200,.T.);+#1202=EDGE_LOOP($,(#1188,#1194,#1195,#1201));+#1203=FACE_OUTER_BOUND('',#1202,.T.);+#1204=ADVANCED_FACE('',(#1203),#1187,.T.);+#1205=CARTESIAN_POINT($,(180,0,1.2));+#1206=DIRECTION($,(-1,0,0));+#1207=DIRECTION($,(0,1,0));+#1208=AXIS2_PLACEMENT_3D($,#1205,#1206,#1207);+#1209=PLANE($,#1208);+#1210=ORIENTED_EDGE($,$,$,#38,.T.);+#1211=CARTESIAN_POINT($,(180,2.1,1.2));+#1212=DIRECTION($,(0,0,-1));+#1213=VECTOR($,#1212,1);+#1214=LINE($,#1211,#1213);+#1215=EDGE_CURVE($,#33,#307,#1214,.T.);+#1216=ORIENTED_EDGE($,$,$,#1215,.T.);+#1217=ORIENTED_EDGE($,$,$,#320,.T.);+#1218=ORIENTED_EDGE($,$,$,#1193,.F.);+#1219=EDGE_LOOP($,(#1210,#1216,#1217,#1218));+#1220=FACE_OUTER_BOUND('',#1219,.T.);+#1221=ADVANCED_FACE('',(#1220),#1209,.T.);+#1222=CARTESIAN_POINT($,(180,117.3,1.2));+#1223=DIRECTION($,(-1,0,0));+#1224=DIRECTION($,(0,1,0));+#1225=AXIS2_PLACEMENT_3D($,#1222,#1223,#1224);+#1226=PLANE($,#1225);+#1227=ORIENTED_EDGE($,$,$,#54,.T.);+#1228=CARTESIAN_POINT($,(180,120,1.2));+#1229=DIRECTION($,(0,0,-1));+#1230=VECTOR($,#1229,1);+#1231=LINE($,#1228,#1230);+#1232=EDGE_CURVE($,#49,#291,#1231,.T.);+#1233=ORIENTED_EDGE($,$,$,#1232,.T.);+#1234=ORIENTED_EDGE($,$,$,#304,.T.);+#1235=CARTESIAN_POINT($,(180,117.3,0));+#1236=DIRECTION($,(0,0,1));+#1237=VECTOR($,#1236,1);+#1238=LINE($,#1235,#1237);+#1239=EDGE_CURVE($,#299,#41,#1238,.T.);+#1240=ORIENTED_EDGE($,$,$,#1239,.T.);+#1241=EDGE_LOOP($,(#1227,#1233,#1234,#1240));+#1242=FACE_OUTER_BOUND('',#1241,.T.);+#1243=ADVANCED_FACE('',(#1242),#1226,.T.);+#1244=CARTESIAN_POINT($,(180,120,1.2));+#1245=DIRECTION($,(-0,-1,-0));+#1246=DIRECTION($,(-1,0,0));+#1247=AXIS2_PLACEMENT_3D($,#1244,#1245,#1246);+#1248=PLANE($,#1247);+#1249=ORIENTED_EDGE($,$,$,#62,.T.);+#1250=CARTESIAN_POINT($,(177.3,120,1.2));+#1251=DIRECTION($,(0,0,-1));+#1252=VECTOR($,#1251,1);+#1253=LINE($,#1250,#1252);+#1254=EDGE_CURVE($,#57,#283,#1253,.T.);+#1255=ORIENTED_EDGE($,$,$,#1254,.T.);+#1256=ORIENTED_EDGE($,$,$,#296,.T.);+#1257=ORIENTED_EDGE($,$,$,#1232,.F.);+#1258=EDGE_LOOP($,(#1249,#1255,#1256,#1257));+#1259=FACE_OUTER_BOUND('',#1258,.T.);+#1260=ADVANCED_FACE('',(#1259),#1248,.T.);+#1261=CARTESIAN_POINT($,(2.7,120,1.2));+#1262=DIRECTION($,(-0,-1,-0));+#1263=DIRECTION($,(-1,0,0));+#1264=AXIS2_PLACEMENT_3D($,#1261,#1262,#1263);+#1265=PLANE($,#1264);+#1266=ORIENTED_EDGE($,$,$,#78,.T.);+#1267=CARTESIAN_POINT($,(0,120,1.2));+#1268=DIRECTION($,(0,0,-1));+#1269=VECTOR($,#1268,1);+#1270=LINE($,#1267,#1269);+#1271=EDGE_CURVE($,#73,#267,#1270,.T.);+#1272=ORIENTED_EDGE($,$,$,#1271,.T.);+#1273=ORIENTED_EDGE($,$,$,#280,.T.);+#1274=CARTESIAN_POINT($,(2.7,120,0));+#1275=DIRECTION($,(0,0,1));+#1276=VECTOR($,#1275,1);+#1277=LINE($,#1274,#1276);+#1278=EDGE_CURVE($,#275,#65,#1277,.T.);+#1279=ORIENTED_EDGE($,$,$,#1278,.T.);+#1280=EDGE_LOOP($,(#1266,#1272,#1273,#1279));+#1281=FACE_OUTER_BOUND('',#1280,.T.);+#1282=ADVANCED_FACE('',(#1281),#1265,.T.);+#1283=CARTESIAN_POINT($,(0,120,1.2));+#1284=DIRECTION($,(1,0,0));+#1285=DIRECTION($,(0,-1,0));+#1286=AXIS2_PLACEMENT_3D($,#1283,#1284,#1285);+#1287=PLANE($,#1286);+#1288=ORIENTED_EDGE($,$,$,#86,.T.);+#1289=CARTESIAN_POINT($,(0,117.3,1.2));+#1290=DIRECTION($,(0,0,-1));+#1291=VECTOR($,#1290,1);+#1292=LINE($,#1289,#1291);+#1293=EDGE_CURVE($,#81,#259,#1292,.T.);+#1294=ORIENTED_EDGE($,$,$,#1293,.T.);+#1295=ORIENTED_EDGE($,$,$,#272,.T.);+#1296=ORIENTED_EDGE($,$,$,#1271,.F.);+#1297=EDGE_LOOP($,(#1288,#1294,#1295,#1296));+#1298=FACE_OUTER_BOUND('',#1297,.T.);+#1299=ADVANCED_FACE('',(#1298),#1287,.T.);+#1300=CARTESIAN_POINT($,(0,2.7,1.2));+#1301=DIRECTION($,(1,0,0));+#1302=DIRECTION($,(0,-1,0));+#1303=AXIS2_PLACEMENT_3D($,#1300,#1301,#1302);+#1304=PLANE($,#1303);+#1305=ORIENTED_EDGE($,$,$,#100,.T.);+#1306=ORIENTED_EDGE($,$,$,#1178,.F.);+#1307=ORIENTED_EDGE($,$,$,#350,.T.);+#1308=CARTESIAN_POINT($,(0,2.7,0));+#1309=DIRECTION($,(0,0,1));+#1310=VECTOR($,#1309,1);+#1311=LINE($,#1308,#1310);+#1312=EDGE_CURVE($,#257,#89,#1311,.T.);+#1313=ORIENTED_EDGE($,$,$,#1312,.T.);+#1314=EDGE_LOOP($,(#1305,#1306,#1307,#1313));+#1315=FACE_OUTER_BOUND('',#1314,.T.);+#1316=ADVANCED_FACE('',(#1315),#1304,.T.);+#1317=CARTESIAN_POINT($,(177.9,-1.5,2.7));+#1318=DIRECTION($,(1,0,0));+#1319=DIRECTION($,(0,-0,1));+#1320=AXIS2_PLACEMENT_3D($,#1317,#1318,#1319);+#1321=PLANE($,#1320);+#1322=ORIENTED_EDGE($,$,$,#522,.T.);+#1323=CARTESIAN_POINT($,(177.9,-1.5,37.7));+#1324=DIRECTION($,(0,-1,0));+#1325=VECTOR($,#1324,1);+#1326=LINE($,#1323,#1325);+#1327=EDGE_CURVE($,#517,#549,#1326,.T.);+#1328=ORIENTED_EDGE($,$,$,#1327,.T.);+#1329=ORIENTED_EDGE($,$,$,#562,.T.);+#1330=CARTESIAN_POINT($,(177.9,-2.7,2.7));+#1331=DIRECTION($,(0,1,0));+#1332=VECTOR($,#1331,1);+#1333=LINE($,#1330,#1332);+#1334=EDGE_CURVE($,#557,#509,#1333,.T.);+#1335=ORIENTED_EDGE($,$,$,#1334,.T.);+#1336=EDGE_LOOP($,(#1322,#1328,#1329,#1335));+#1337=FACE_OUTER_BOUND('',#1336,.T.);+#1338=ADVANCED_FACE('',(#1337),#1321,.T.);+#1339=CARTESIAN_POINT($,(2.7,-1.5,37.7));+#1340=DIRECTION($,(-1,-0,-0));+#1341=DIRECTION($,(0,0,-1));+#1342=AXIS2_PLACEMENT_3D($,#1339,#1340,#1341);+#1343=PLANE($,#1342);+#1344=ORIENTED_EDGE($,$,$,#536,.T.);+#1345=CARTESIAN_POINT($,(2.7,-1.5,2.7));+#1346=DIRECTION($,(0,-1,0));+#1347=VECTOR($,#1346,1);+#1348=LINE($,#1345,#1347);+#1349=EDGE_CURVE($,#507,#565,#1348,.T.);+#1350=ORIENTED_EDGE($,$,$,#1349,.T.);+#1351=ORIENTED_EDGE($,$,$,#576,.T.);+#1352=CARTESIAN_POINT($,(2.7,-2.7,37.7));+#1353=DIRECTION($,(0,1,0));+#1354=VECTOR($,#1353,1);+#1355=LINE($,#1352,#1354);+#1356=EDGE_CURVE($,#547,#525,#1355,.T.);+#1357=ORIENTED_EDGE($,$,$,#1356,.T.);+#1358=EDGE_LOOP($,(#1344,#1350,#1351,#1357));+#1359=FACE_OUTER_BOUND('',#1358,.T.);+#1360=ADVANCED_FACE('',(#1359),#1343,.T.);+#1361=CARTESIAN_POINT($,(177.9,0,1.2));+#1362=DIRECTION($,(1,0,0));+#1363=DIRECTION($,(0,-0.707106781186548,0.707106781186547));+#1364=AXIS2_PLACEMENT_3D($,#1361,#1362,#1363);+#1365=PLANE($,#1364);+#1366=ORIENTED_EDGE($,$,$,#593,.T.);+#1367=ORIENTED_EDGE($,$,$,#1334,.F.);+#1368=ORIENTED_EDGE($,$,$,#619,.T.);+#1369=ORIENTED_EDGE($,$,$,#1200,.T.);+#1370=EDGE_LOOP($,(#1366,#1367,#1368,#1369));+#1371=FACE_OUTER_BOUND('',#1370,.T.);+#1372=ADVANCED_FACE('',(#1371),#1365,.T.);+#1373=CARTESIAN_POINT($,(2.7,-1.5,2.7));+#1374=DIRECTION($,(-1,-0,-0));+#1375=DIRECTION($,(0,0.707106781186548,-0.707106781186547));+#1376=AXIS2_PLACEMENT_3D($,#1373,#1374,#1375);+#1377=PLANE($,#1376);+#1378=ORIENTED_EDGE($,$,$,#602,.T.);+#1379=ORIENTED_EDGE($,$,$,#1171,.T.);+#1380=ORIENTED_EDGE($,$,$,#628,.T.);+#1381=ORIENTED_EDGE($,$,$,#1349,.F.);+#1382=EDGE_LOOP($,(#1378,#1379,#1380,#1381));+#1383=FACE_OUTER_BOUND('',#1382,.T.);+#1384=ADVANCED_FACE('',(#1383),#1377,.T.);+#1385=CARTESIAN_POINT($,(181.5,117.3,2.7));+#1386=DIRECTION($,(0,1,0));+#1387=DIRECTION($,(0,0,1));+#1388=AXIS2_PLACEMENT_3D($,#1385,#1386,#1387);+#1389=PLANE($,#1388);+#1390=ORIENTED_EDGE($,$,$,#654,.T.);+#1391=CARTESIAN_POINT($,(181.5,117.3,37.7));+#1392=DIRECTION($,(1,0,0));+#1393=VECTOR($,#1392,1);+#1394=LINE($,#1391,#1393);+#1395=EDGE_CURVE($,#649,#681,#1394,.T.);+#1396=ORIENTED_EDGE($,$,$,#1395,.T.);+#1397=ORIENTED_EDGE($,$,$,#694,.T.);+#1398=CARTESIAN_POINT($,(182.7,117.3,2.7));+#1399=DIRECTION($,(-1,0,0));+#1400=VECTOR($,#1399,1);+#1401=LINE($,#1398,#1400);+#1402=EDGE_CURVE($,#689,#641,#1401,.T.);+#1403=ORIENTED_EDGE($,$,$,#1402,.T.);+#1404=EDGE_LOOP($,(#1390,#1396,#1397,#1403));+#1405=FACE_OUTER_BOUND('',#1404,.T.);+#1406=ADVANCED_FACE('',(#1405),#1389,.T.);+#1407=CARTESIAN_POINT($,(181.5,117.3,37.7));+#1408=DIRECTION($,(-0,0,1));+#1409=DIRECTION($,(0,-1,0));+#1410=AXIS2_PLACEMENT_3D($,#1407,#1408,#1409);+#1411=PLANE($,#1410);+#1412=ORIENTED_EDGE($,$,$,#662,.T.);+#1413=CARTESIAN_POINT($,(181.5,2.1,37.7));+#1414=DIRECTION($,(1,0,0));+#1415=VECTOR($,#1414,1);+#1416=LINE($,#1413,#1415);+#1417=EDGE_CURVE($,#657,#679,#1416,.T.);+#1418=ORIENTED_EDGE($,$,$,#1417,.T.);+#1419=ORIENTED_EDGE($,$,$,#686,.T.);+#1420=ORIENTED_EDGE($,$,$,#1395,.F.);+#1421=EDGE_LOOP($,(#1412,#1418,#1419,#1420));+#1422=FACE_OUTER_BOUND('',#1421,.T.);+#1423=ADVANCED_FACE('',(#1422),#1411,.T.);+#1424=CARTESIAN_POINT($,(181.5,2.1,37.7));+#1425=DIRECTION($,(0,-1,0));+#1426=DIRECTION($,(0,0,-1));+#1427=AXIS2_PLACEMENT_3D($,#1424,#1425,#1426);+#1428=PLANE($,#1427);+#1429=ORIENTED_EDGE($,$,$,#668,.T.);+#1430=CARTESIAN_POINT($,(181.5,2.1,2.7));+#1431=DIRECTION($,(1,0,0));+#1432=VECTOR($,#1431,1);+#1433=LINE($,#1430,#1432);+#1434=EDGE_CURVE($,#639,#697,#1433,.T.);+#1435=ORIENTED_EDGE($,$,$,#1434,.T.);+#1436=ORIENTED_EDGE($,$,$,#708,.T.);+#1437=ORIENTED_EDGE($,$,$,#1417,.F.);+#1438=EDGE_LOOP($,(#1429,#1435,#1436,#1437));+#1439=FACE_OUTER_BOUND('',#1438,.T.);+#1440=ADVANCED_FACE('',(#1439),#1428,.T.);+#1441=CARTESIAN_POINT($,(180,117.3,1.2));+#1442=DIRECTION($,(-0,1,0));+#1443=DIRECTION($,(0.707106781186548,0,0.707106781186547));+#1444=AXIS2_PLACEMENT_3D($,#1441,#1442,#1443);+#1445=PLANE($,#1444);+#1446=ORIENTED_EDGE($,$,$,#725,.T.);+#1447=ORIENTED_EDGE($,$,$,#1402,.F.);+#1448=ORIENTED_EDGE($,$,$,#751,.T.);+#1449=ORIENTED_EDGE($,$,$,#1239,.T.);+#1450=EDGE_LOOP($,(#1446,#1447,#1448,#1449));+#1451=FACE_OUTER_BOUND('',#1450,.T.);+#1452=ADVANCED_FACE('',(#1451),#1445,.T.);+#1453=CARTESIAN_POINT($,(181.5,2.1,2.7));+#1454=DIRECTION($,(0,-1,-0));+#1455=DIRECTION($,(-0.707106781186548,0,-0.707106781186547));+#1456=AXIS2_PLACEMENT_3D($,#1453,#1454,#1455);+#1457=PLANE($,#1456);+#1458=ORIENTED_EDGE($,$,$,#734,.T.);+#1459=ORIENTED_EDGE($,$,$,#1215,.T.);+#1460=ORIENTED_EDGE($,$,$,#760,.T.);+#1461=ORIENTED_EDGE($,$,$,#1434,.F.);+#1462=EDGE_LOOP($,(#1458,#1459,#1460,#1461));+#1463=FACE_OUTER_BOUND('',#1462,.T.);+#1464=ADVANCED_FACE('',(#1463),#1457,.T.);+#1465=CARTESIAN_POINT($,(2.7,121.5,2.7));+#1466=DIRECTION($,(-1,0,0));+#1467=DIRECTION($,(0,0,1));+#1468=AXIS2_PLACEMENT_3D($,#1465,#1466,#1467);+#1469=PLANE($,#1468);+#1470=ORIENTED_EDGE($,$,$,#786,.T.);+#1471=CARTESIAN_POINT($,(2.7,121.5,37.7));+#1472=DIRECTION($,(0,1,0));+#1473=VECTOR($,#1472,1);+#1474=LINE($,#1471,#1473);+#1475=EDGE_CURVE($,#781,#813,#1474,.T.);+#1476=ORIENTED_EDGE($,$,$,#1475,.T.);+#1477=ORIENTED_EDGE($,$,$,#826,.T.);+#1478=CARTESIAN_POINT($,(2.7,122.7,2.7));+#1479=DIRECTION($,(0,-1,0));+#1480=VECTOR($,#1479,1);+#1481=LINE($,#1478,#1480);+#1482=EDGE_CURVE($,#821,#773,#1481,.T.);+#1483=ORIENTED_EDGE($,$,$,#1482,.T.);+#1484=EDGE_LOOP($,(#1470,#1476,#1477,#1483));+#1485=FACE_OUTER_BOUND('',#1484,.T.);+#1486=ADVANCED_FACE('',(#1485),#1469,.T.);+#1487=CARTESIAN_POINT($,(2.7,121.5,37.7));+#1488=DIRECTION($,(0,0,1));+#1489=DIRECTION($,(1,0,0));+#1490=AXIS2_PLACEMENT_3D($,#1487,#1488,#1489);+#1491=PLANE($,#1490);+#1492=ORIENTED_EDGE($,$,$,#794,.T.);+#1493=CARTESIAN_POINT($,(177.3,121.5,37.7));+#1494=DIRECTION($,(0,1,0));+#1495=VECTOR($,#1494,1);+#1496=LINE($,#1493,#1495);+#1497=EDGE_CURVE($,#789,#811,#1496,.T.);+#1498=ORIENTED_EDGE($,$,$,#1497,.T.);+#1499=ORIENTED_EDGE($,$,$,#818,.T.);+#1500=ORIENTED_EDGE($,$,$,#1475,.F.);+#1501=EDGE_LOOP($,(#1492,#1498,#1499,#1500));+#1502=FACE_OUTER_BOUND('',#1501,.T.);+#1503=ADVANCED_FACE('',(#1502),#1491,.T.);+#1504=CARTESIAN_POINT($,(177.3,121.5,37.7));+#1505=DIRECTION($,(1,-0,0));+#1506=DIRECTION($,(0,0,-1));+#1507=AXIS2_PLACEMENT_3D($,#1504,#1505,#1506);+#1508=PLANE($,#1507);+#1509=ORIENTED_EDGE($,$,$,#800,.T.);+#1510=CARTESIAN_POINT($,(177.3,121.5,2.7));+#1511=DIRECTION($,(0,1,0));+#1512=VECTOR($,#1511,1);+#1513=LINE($,#1510,#1512);+#1514=EDGE_CURVE($,#771,#829,#1513,.T.);+#1515=ORIENTED_EDGE($,$,$,#1514,.T.);+#1516=ORIENTED_EDGE($,$,$,#840,.T.);+#1517=ORIENTED_EDGE($,$,$,#1497,.F.);+#1518=EDGE_LOOP($,(#1509,#1515,#1516,#1517));+#1519=FACE_OUTER_BOUND('',#1518,.T.);+#1520=ADVANCED_FACE('',(#1519),#1508,.T.);+#1521=CARTESIAN_POINT($,(2.7,120,1.2));+#1522=DIRECTION($,(-1,0,0));+#1523=DIRECTION($,(0,0.707106781186548,0.707106781186547));+#1524=AXIS2_PLACEMENT_3D($,#1521,#1522,#1523);+#1525=PLANE($,#1524);+#1526=ORIENTED_EDGE($,$,$,#857,.T.);+#1527=ORIENTED_EDGE($,$,$,#1482,.F.);+#1528=ORIENTED_EDGE($,$,$,#883,.T.);+#1529=ORIENTED_EDGE($,$,$,#1278,.T.);+#1530=EDGE_LOOP($,(#1526,#1527,#1528,#1529));+#1531=FACE_OUTER_BOUND('',#1530,.T.);+#1532=ADVANCED_FACE('',(#1531),#1525,.T.);+#1533=CARTESIAN_POINT($,(177.3,121.5,2.7));+#1534=DIRECTION($,(1,-0,0));+#1535=DIRECTION($,(0,-0.707106781186548,-0.707106781186547));+#1536=AXIS2_PLACEMENT_3D($,#1533,#1534,#1535);+#1537=PLANE($,#1536);+#1538=ORIENTED_EDGE($,$,$,#866,.T.);+#1539=ORIENTED_EDGE($,$,$,#1254,.T.);+#1540=ORIENTED_EDGE($,$,$,#892,.T.);+#1541=ORIENTED_EDGE($,$,$,#1514,.F.);+#1542=EDGE_LOOP($,(#1538,#1539,#1540,#1541));+#1543=FACE_OUTER_BOUND('',#1542,.T.);+#1544=ADVANCED_FACE('',(#1543),#1537,.T.);+#1545=CARTESIAN_POINT($,(-1.5,2.7,2.7));+#1546=DIRECTION($,(0,-1,0));+#1547=DIRECTION($,(-0,0,1));+#1548=AXIS2_PLACEMENT_3D($,#1545,#1546,#1547);+#1549=PLANE($,#1548);+#1550=ORIENTED_EDGE($,$,$,#918,.T.);+#1551=CARTESIAN_POINT($,(-1.5,2.7,37.7));+#1552=DIRECTION($,(-1,0,0));+#1553=VECTOR($,#1552,1);+#1554=LINE($,#1551,#1553);+#1555=EDGE_CURVE($,#913,#945,#1554,.T.);+#1556=ORIENTED_EDGE($,$,$,#1555,.T.);+#1557=ORIENTED_EDGE($,$,$,#958,.T.);+#1558=CARTESIAN_POINT($,(-2.7,2.7,2.7));+#1559=DIRECTION($,(1,0,0));+#1560=VECTOR($,#1559,1);+#1561=LINE($,#1558,#1560);+#1562=EDGE_CURVE($,#953,#905,#1561,.T.);+#1563=ORIENTED_EDGE($,$,$,#1562,.T.);+#1564=EDGE_LOOP($,(#1550,#1556,#1557,#1563));+#1565=FACE_OUTER_BOUND('',#1564,.T.);+#1566=ADVANCED_FACE('',(#1565),#1549,.T.);+#1567=CARTESIAN_POINT($,(-1.5,2.7,37.7));+#1568=DIRECTION($,(0,-0,1));+#1569=DIRECTION($,(0,1,0));+#1570=AXIS2_PLACEMENT_3D($,#1567,#1568,#1569);+#1571=PLANE($,#1570);+#1572=ORIENTED_EDGE($,$,$,#926,.T.);+#1573=CARTESIAN_POINT($,(-1.5,117.3,37.7));+#1574=DIRECTION($,(-1,0,0));+#1575=VECTOR($,#1574,1);+#1576=LINE($,#1573,#1575);+#1577=EDGE_CURVE($,#921,#943,#1576,.T.);+#1578=ORIENTED_EDGE($,$,$,#1577,.T.);+#1579=ORIENTED_EDGE($,$,$,#950,.T.);+#1580=ORIENTED_EDGE($,$,$,#1555,.F.);+#1581=EDGE_LOOP($,(#1572,#1578,#1579,#1580));+#1582=FACE_OUTER_BOUND('',#1581,.T.);+#1583=ADVANCED_FACE('',(#1582),#1571,.T.);+#1584=CARTESIAN_POINT($,(-1.5,117.3,37.7));+#1585=DIRECTION($,(0,1,0));+#1586=DIRECTION($,(0,0,-1));+#1587=AXIS2_PLACEMENT_3D($,#1584,#1585,#1586);+#1588=PLANE($,#1587);+#1589=ORIENTED_EDGE($,$,$,#932,.T.);+#1590=CARTESIAN_POINT($,(-1.5,117.3,2.7));+#1591=DIRECTION($,(-1,0,0));+#1592=VECTOR($,#1591,1);+#1593=LINE($,#1590,#1592);+#1594=EDGE_CURVE($,#903,#961,#1593,.T.);+#1595=ORIENTED_EDGE($,$,$,#1594,.T.);+#1596=ORIENTED_EDGE($,$,$,#972,.T.);+#1597=ORIENTED_EDGE($,$,$,#1577,.F.);+#1598=EDGE_LOOP($,(#1589,#1595,#1596,#1597));+#1599=FACE_OUTER_BOUND('',#1598,.T.);+#1600=ADVANCED_FACE('',(#1599),#1588,.T.);+#1601=CARTESIAN_POINT($,(0,2.7,1.2));+#1602=DIRECTION($,(-0,-1,-0));+#1603=DIRECTION($,(-0.707106781186548,0,0.707106781186547));+#1604=AXIS2_PLACEMENT_3D($,#1601,#1602,#1603);+#1605=PLANE($,#1604);+#1606=ORIENTED_EDGE($,$,$,#989,.T.);+#1607=ORIENTED_EDGE($,$,$,#1562,.F.);+#1608=ORIENTED_EDGE($,$,$,#1015,.T.);+#1609=ORIENTED_EDGE($,$,$,#1312,.T.);+#1610=EDGE_LOOP($,(#1606,#1607,#1608,#1609));+#1611=FACE_OUTER_BOUND('',#1610,.T.);+#1612=ADVANCED_FACE('',(#1611),#1605,.T.);+#1613=CARTESIAN_POINT($,(-1.5,117.3,2.7));+#1614=DIRECTION($,(0,1,0));+#1615=DIRECTION($,(0.707106781186548,0,-0.707106781186547));+#1616=AXIS2_PLACEMENT_3D($,#1613,#1614,#1615);+#1617=PLANE($,#1616);+#1618=ORIENTED_EDGE($,$,$,#998,.T.);+#1619=ORIENTED_EDGE($,$,$,#1293,.T.);+#1620=ORIENTED_EDGE($,$,$,#1024,.T.);+#1621=ORIENTED_EDGE($,$,$,#1594,.F.);+#1622=EDGE_LOOP($,(#1618,#1619,#1620,#1621));+#1623=FACE_OUTER_BOUND('',#1622,.T.);+#1624=ADVANCED_FACE('',(#1623),#1617,.T.);+#1625=CARTESIAN_POINT($,(177.9,-3.9,40.1));+#1626=DIRECTION($,(1,0,0));+#1627=DIRECTION($,(0,-1,0));+#1628=AXIS2_PLACEMENT_3D($,#1625,#1626,#1627);+#1629=PLANE($,#1628);+#1630=ORIENTED_EDGE($,$,$,#1050,.T.);+#1631=CARTESIAN_POINT($,(177.9,-13.9,40.1));+#1632=DIRECTION($,(0,0,-1));+#1633=VECTOR($,#1632,1);+#1634=LINE($,#1631,#1633);+#1635=EDGE_CURVE($,#1045,#1077,#1634,.T.);+#1636=ORIENTED_EDGE($,$,$,#1635,.T.);+#1637=ORIENTED_EDGE($,$,$,#1090,.T.);+#1638=CARTESIAN_POINT($,(177.9,-3.9,38.9));+#1639=DIRECTION($,(0,0,1));+#1640=VECTOR($,#1639,1);+#1641=LINE($,#1638,#1640);+#1642=EDGE_CURVE($,#1085,#1037,#1641,.T.);+#1643=ORIENTED_EDGE($,$,$,#1642,.T.);+#1644=EDGE_LOOP($,(#1630,#1636,#1637,#1643));+#1645=FACE_OUTER_BOUND('',#1644,.T.);+#1646=ADVANCED_FACE('',(#1645),#1629,.T.);+#1647=CARTESIAN_POINT($,(177.9,-13.9,40.1));+#1648=DIRECTION($,(-0,-1,-0));+#1649=DIRECTION($,(-1,0,0));+#1650=AXIS2_PLACEMENT_3D($,#1647,#1648,#1649);+#1651=PLANE($,#1650);+#1652=ORIENTED_EDGE($,$,$,#1058,.T.);+#1653=CARTESIAN_POINT($,(2.7,-13.9,40.1));+#1654=DIRECTION($,(0,0,-1));+#1655=VECTOR($,#1654,1);+#1656=LINE($,#1653,#1655);+#1657=EDGE_CURVE($,#1053,#1075,#1656,.T.);+#1658=ORIENTED_EDGE($,$,$,#1657,.T.);+#1659=ORIENTED_EDGE($,$,$,#1082,.T.);+#1660=ORIENTED_EDGE($,$,$,#1635,.F.);+#1661=EDGE_LOOP($,(#1652,#1658,#1659,#1660));+#1662=FACE_OUTER_BOUND('',#1661,.T.);+#1663=ADVANCED_FACE('',(#1662),#1651,.T.);+#1664=CARTESIAN_POINT($,(2.7,-13.9,40.1));+#1665=DIRECTION($,(-1,0,0));+#1666=DIRECTION($,(0,1,0));+#1667=AXIS2_PLACEMENT_3D($,#1664,#1665,#1666);+#1668=PLANE($,#1667);+#1669=ORIENTED_EDGE($,$,$,#1064,.T.);+#1670=CARTESIAN_POINT($,(2.7,-3.9,40.1));+#1671=DIRECTION($,(0,0,-1));+#1672=VECTOR($,#1671,1);+#1673=LINE($,#1670,#1672);+#1674=EDGE_CURVE($,#1035,#1093,#1673,.T.);+#1675=ORIENTED_EDGE($,$,$,#1674,.T.);+#1676=ORIENTED_EDGE($,$,$,#1104,.T.);+#1677=ORIENTED_EDGE($,$,$,#1657,.F.);+#1678=EDGE_LOOP($,(#1669,#1675,#1676,#1677));+#1679=FACE_OUTER_BOUND('',#1678,.T.);+#1680=ADVANCED_FACE('',(#1679),#1668,.T.);+#1681=CARTESIAN_POINT($,(177.9,-1.5,37.7));+#1682=DIRECTION($,(1,0,0));+#1683=DIRECTION($,(0,-0.707106781186548,0.707106781186547));+#1684=AXIS2_PLACEMENT_3D($,#1681,#1682,#1683);+#1685=PLANE($,#1684);+#1686=ORIENTED_EDGE($,$,$,#1121,.T.);+#1687=ORIENTED_EDGE($,$,$,#1642,.F.);+#1688=ORIENTED_EDGE($,$,$,#1147,.T.);+#1689=ORIENTED_EDGE($,$,$,#1327,.F.);+#1690=EDGE_LOOP($,(#1686,#1687,#1688,#1689));+#1691=FACE_OUTER_BOUND('',#1690,.T.);+#1692=ADVANCED_FACE('',(#1691),#1685,.T.);+#1693=CARTESIAN_POINT($,(2.7,-3.9,40.1));+#1694=DIRECTION($,(-1,0,0));+#1695=DIRECTION($,(0,0.707106781186548,-0.707106781186547));+#1696=AXIS2_PLACEMENT_3D($,#1693,#1694,#1695);+#1697=PLANE($,#1696);+#1698=ORIENTED_EDGE($,$,$,#1130,.T.);+#1699=ORIENTED_EDGE($,$,$,#1356,.F.);+#1700=ORIENTED_EDGE($,$,$,#1156,.T.);+#1701=ORIENTED_EDGE($,$,$,#1674,.F.);+#1702=EDGE_LOOP($,(#1698,#1699,#1700,#1701));+#1703=FACE_OUTER_BOUND('',#1702,.T.);+#1704=ADVANCED_FACE('',(#1703),#1697,.T.);+#1705=CARTESIAN_POINT($,(15,15,0));+#1706=DIRECTION($,(0,0,1));+#1707=DIRECTION($,(1,0,0));+#1708=AXIS2_PLACEMENT_3D($,#1705,#1706,#1707);+#1709=CYLINDRICAL_SURFACE($,#1708,2);+#1710=ORIENTED_EDGE($,$,$,#111,.T.);+#1711=EDGE_LOOP($,(#1710));+#1712=FACE_OUTER_BOUND('',#1711,.T.);+#1713=ORIENTED_EDGE($,$,$,#361,.T.);+#1714=EDGE_LOOP($,(#1713));+#1715=FACE_BOUND('',#1714,.T.);+#1716=ADVANCED_FACE('',(#1712,#1715),#1709,.F.);+#1717=CARTESIAN_POINT($,(165,15,0));+#1718=DIRECTION($,(0,0,1));+#1719=DIRECTION($,(1,0,0));+#1720=AXIS2_PLACEMENT_3D($,#1717,#1718,#1719);+#1721=CYLINDRICAL_SURFACE($,#1720,2);+#1722=ORIENTED_EDGE($,$,$,#122,.T.);+#1723=EDGE_LOOP($,(#1722));+#1724=FACE_OUTER_BOUND('',#1723,.T.);+#1725=ORIENTED_EDGE($,$,$,#372,.T.);+#1726=EDGE_LOOP($,(#1725));+#1727=FACE_BOUND('',#1726,.T.);+#1728=ADVANCED_FACE('',(#1724,#1727),#1721,.F.);+#1729=CARTESIAN_POINT($,(15,105,0));+#1730=DIRECTION($,(0,0,1));+#1731=DIRECTION($,(1,0,0));+#1732=AXIS2_PLACEMENT_3D($,#1729,#1730,#1731);+#1733=CYLINDRICAL_SURFACE($,#1732,2);+#1734=ORIENTED_EDGE($,$,$,#133,.T.);+#1735=EDGE_LOOP($,(#1734));+#1736=FACE_OUTER_BOUND('',#1735,.T.);+#1737=ORIENTED_EDGE($,$,$,#383,.T.);+#1738=EDGE_LOOP($,(#1737));+#1739=FACE_BOUND('',#1738,.T.);+#1740=ADVANCED_FACE('',(#1736,#1739),#1733,.F.);+#1741=CARTESIAN_POINT($,(165,105,0));+#1742=DIRECTION($,(0,0,1));+#1743=DIRECTION($,(1,0,0));+#1744=AXIS2_PLACEMENT_3D($,#1741,#1742,#1743);+#1745=CYLINDRICAL_SURFACE($,#1744,2);+#1746=ORIENTED_EDGE($,$,$,#144,.T.);+#1747=EDGE_LOOP($,(#1746));+#1748=FACE_OUTER_BOUND('',#1747,.T.);+#1749=ORIENTED_EDGE($,$,$,#394,.T.);+#1750=EDGE_LOOP($,(#1749));+#1751=FACE_BOUND('',#1750,.T.);+#1752=ADVANCED_FACE('',(#1748,#1751),#1745,.F.);+#1753=CARTESIAN_POINT($,(39.5,57,1.2));+#1754=DIRECTION($,(-0,1,0));+#1755=DIRECTION($,(1,0,0));+#1756=AXIS2_PLACEMENT_3D($,#1753,#1754,#1755);+#1757=PLANE($,#1756);+#1758=ORIENTED_EDGE($,$,$,#172,.T.);+#1759=CARTESIAN_POINT($,(84.5,57,1.2));+#1760=DIRECTION($,(0,0,-1));+#1761=VECTOR($,#1760,1);+#1762=LINE($,#1759,#1761);+#1763=EDGE_CURVE($,#159,#401,#1762,.T.);+#1764=ORIENTED_EDGE($,$,$,#1763,.T.);+#1765=ORIENTED_EDGE($,$,$,#406,.F.);+#1766=CARTESIAN_POINT($,(39.5,57,0));+#1767=DIRECTION($,(0,0,1));+#1768=VECTOR($,#1767,1);+#1769=LINE($,#1766,#1768);+#1770=EDGE_CURVE($,#399,#167,#1769,.T.);+#1771=ORIENTED_EDGE($,$,$,#1770,.T.);+#1772=EDGE_LOOP($,(#1758,#1764,#1765,#1771));+#1773=FACE_OUTER_BOUND('',#1772,.T.);+#1774=ADVANCED_FACE('',(#1773),#1757,.T.);+#1775=CARTESIAN_POINT($,(84.5,57,1.2));+#1776=DIRECTION($,(-1,0,0));+#1777=DIRECTION($,(0,1,0));+#1778=AXIS2_PLACEMENT_3D($,#1775,#1776,#1777);+#1779=PLANE($,#1778);+#1780=ORIENTED_EDGE($,$,$,#164,.T.);+#1781=CARTESIAN_POINT($,(84.5,63,1.2));+#1782=DIRECTION($,(0,0,-1));+#1783=VECTOR($,#1782,1);+#1784=LINE($,#1781,#1783);+#1785=EDGE_CURVE($,#149,#409,#1784,.T.);+#1786=ORIENTED_EDGE($,$,$,#1785,.T.);+#1787=ORIENTED_EDGE($,$,$,#414,.F.);+#1788=ORIENTED_EDGE($,$,$,#1763,.F.);+#1789=EDGE_LOOP($,(#1780,#1786,#1787,#1788));+#1790=FACE_OUTER_BOUND('',#1789,.T.);+#1791=ADVANCED_FACE('',(#1790),#1779,.T.);+#1792=CARTESIAN_POINT($,(84.5,63,1.2));+#1793=DIRECTION($,(-0,-1,-0));+#1794=DIRECTION($,(-1,0,0));+#1795=AXIS2_PLACEMENT_3D($,#1792,#1793,#1794);+#1796=PLANE($,#1795);+#1797=ORIENTED_EDGE($,$,$,#156,.T.);+#1798=CARTESIAN_POINT($,(39.5,63,1.2));+#1799=DIRECTION($,(0,0,-1));+#1800=VECTOR($,#1799,1);+#1801=LINE($,#1798,#1800);+#1802=EDGE_CURVE($,#151,#417,#1801,.T.);+#1803=ORIENTED_EDGE($,$,$,#1802,.T.);+#1804=ORIENTED_EDGE($,$,$,#422,.F.);+#1805=ORIENTED_EDGE($,$,$,#1785,.F.);+#1806=EDGE_LOOP($,(#1797,#1803,#1804,#1805));+#1807=FACE_OUTER_BOUND('',#1806,.T.);+#1808=ADVANCED_FACE('',(#1807),#1796,.T.);+#1809=CARTESIAN_POINT($,(39.5,63,1.2));+#1810=DIRECTION($,(1,0,0));+#1811=DIRECTION($,(0,-1,0));+#1812=AXIS2_PLACEMENT_3D($,#1809,#1810,#1811);+#1813=PLANE($,#1812);+#1814=ORIENTED_EDGE($,$,$,#178,.T.);+#1815=ORIENTED_EDGE($,$,$,#1770,.F.);+#1816=ORIENTED_EDGE($,$,$,#428,.F.);+#1817=ORIENTED_EDGE($,$,$,#1802,.F.);+#1818=EDGE_LOOP($,(#1814,#1815,#1816,#1817));+#1819=FACE_OUTER_BOUND('',#1818,.T.);+#1820=ADVANCED_FACE('',(#1819),#1813,.T.);+#1821=CARTESIAN_POINT($,(67.5,57,1.2));+#1822=DIRECTION($,(-0,1,0));+#1823=DIRECTION($,(1,0,0));+#1824=AXIS2_PLACEMENT_3D($,#1821,#1822,#1823);+#1825=PLANE($,#1824);+#1826=ORIENTED_EDGE($,$,$,#206,.T.);+#1827=CARTESIAN_POINT($,(112.5,57,1.2));+#1828=DIRECTION($,(0,0,-1));+#1829=VECTOR($,#1828,1);+#1830=LINE($,#1827,#1829);+#1831=EDGE_CURVE($,#193,#435,#1830,.T.);+#1832=ORIENTED_EDGE($,$,$,#1831,.T.);+#1833=ORIENTED_EDGE($,$,$,#440,.F.);+#1834=CARTESIAN_POINT($,(67.5,57,0));+#1835=DIRECTION($,(0,0,1));+#1836=VECTOR($,#1835,1);+#1837=LINE($,#1834,#1836);+#1838=EDGE_CURVE($,#433,#201,#1837,.T.);+#1839=ORIENTED_EDGE($,$,$,#1838,.T.);+#1840=EDGE_LOOP($,(#1826,#1832,#1833,#1839));+#1841=FACE_OUTER_BOUND('',#1840,.T.);+#1842=ADVANCED_FACE('',(#1841),#1825,.T.);+#1843=CARTESIAN_POINT($,(112.5,57,1.2));+#1844=DIRECTION($,(-1,0,0));+#1845=DIRECTION($,(0,1,0));+#1846=AXIS2_PLACEMENT_3D($,#1843,#1844,#1845);+#1847=PLANE($,#1846);+#1848=ORIENTED_EDGE($,$,$,#198,.T.);+#1849=CARTESIAN_POINT($,(112.5,63,1.2));+#1850=DIRECTION($,(0,0,-1));+#1851=VECTOR($,#1850,1);+#1852=LINE($,#1849,#1851);+#1853=EDGE_CURVE($,#183,#443,#1852,.T.);+#1854=ORIENTED_EDGE($,$,$,#1853,.T.);+#1855=ORIENTED_EDGE($,$,$,#448,.F.);+#1856=ORIENTED_EDGE($,$,$,#1831,.F.);+#1857=EDGE_LOOP($,(#1848,#1854,#1855,#1856));+#1858=FACE_OUTER_BOUND('',#1857,.T.);+#1859=ADVANCED_FACE('',(#1858),#1847,.T.);+#1860=CARTESIAN_POINT($,(112.5,63,1.2));+#1861=DIRECTION($,(-0,-1,-0));+#1862=DIRECTION($,(-1,0,0));+#1863=AXIS2_PLACEMENT_3D($,#1860,#1861,#1862);+#1864=PLANE($,#1863);+#1865=ORIENTED_EDGE($,$,$,#190,.T.);+#1866=CARTESIAN_POINT($,(67.5,63,1.2));+#1867=DIRECTION($,(0,0,-1));+#1868=VECTOR($,#1867,1);+#1869=LINE($,#1866,#1868);+#1870=EDGE_CURVE($,#185,#451,#1869,.T.);+#1871=ORIENTED_EDGE($,$,$,#1870,.T.);+#1872=ORIENTED_EDGE($,$,$,#456,.F.);+#1873=ORIENTED_EDGE($,$,$,#1853,.F.);+#1874=EDGE_LOOP($,(#1865,#1871,#1872,#1873));+#1875=FACE_OUTER_BOUND('',#1874,.T.);+#1876=ADVANCED_FACE('',(#1875),#1864,.T.);+#1877=CARTESIAN_POINT($,(67.5,63,1.2));+#1878=DIRECTION($,(1,0,0));+#1879=DIRECTION($,(0,-1,0));+#1880=AXIS2_PLACEMENT_3D($,#1877,#1878,#1879);+#1881=PLANE($,#1880);+#1882=ORIENTED_EDGE($,$,$,#212,.T.);+#1883=ORIENTED_EDGE($,$,$,#1838,.F.);+#1884=ORIENTED_EDGE($,$,$,#462,.F.);+#1885=ORIENTED_EDGE($,$,$,#1870,.F.);+#1886=EDGE_LOOP($,(#1882,#1883,#1884,#1885));+#1887=FACE_OUTER_BOUND('',#1886,.T.);+#1888=ADVANCED_FACE('',(#1887),#1881,.T.);+#1889=CARTESIAN_POINT($,(95.5,57,1.2));+#1890=DIRECTION($,(-0,1,0));+#1891=DIRECTION($,(1,0,0));+#1892=AXIS2_PLACEMENT_3D($,#1889,#1890,#1891);+#1893=PLANE($,#1892);+#1894=ORIENTED_EDGE($,$,$,#240,.T.);+#1895=CARTESIAN_POINT($,(140.5,57,1.2));+#1896=DIRECTION($,(0,0,-1));+#1897=VECTOR($,#1896,1);+#1898=LINE($,#1895,#1897);+#1899=EDGE_CURVE($,#227,#469,#1898,.T.);+#1900=ORIENTED_EDGE($,$,$,#1899,.T.);+#1901=ORIENTED_EDGE($,$,$,#474,.F.);+#1902=CARTESIAN_POINT($,(95.5,57,0));+#1903=DIRECTION($,(0,0,1));+#1904=VECTOR($,#1903,1);+#1905=LINE($,#1902,#1904);+#1906=EDGE_CURVE($,#467,#235,#1905,.T.);+#1907=ORIENTED_EDGE($,$,$,#1906,.T.);+#1908=EDGE_LOOP($,(#1894,#1900,#1901,#1907));+#1909=FACE_OUTER_BOUND('',#1908,.T.);+#1910=ADVANCED_FACE('',(#1909),#1893,.T.);+#1911=CARTESIAN_POINT($,(140.5,57,1.2));+#1912=DIRECTION($,(-1,0,0));+#1913=DIRECTION($,(0,1,0));+#1914=AXIS2_PLACEMENT_3D($,#1911,#1912,#1913);+#1915=PLANE($,#1914);+#1916=ORIENTED_EDGE($,$,$,#232,.T.);+#1917=CARTESIAN_POINT($,(140.5,63,1.2));+#1918=DIRECTION($,(0,0,-1));+#1919=VECTOR($,#1918,1);+#1920=LINE($,#1917,#1919);+#1921=EDGE_CURVE($,#217,#477,#1920,.T.);+#1922=ORIENTED_EDGE($,$,$,#1921,.T.);+#1923=ORIENTED_EDGE($,$,$,#482,.F.);+#1924=ORIENTED_EDGE($,$,$,#1899,.F.);+#1925=EDGE_LOOP($,(#1916,#1922,#1923,#1924));+#1926=FACE_OUTER_BOUND('',#1925,.T.);+#1927=ADVANCED_FACE('',(#1926),#1915,.T.);+#1928=CARTESIAN_POINT($,(140.5,63,1.2));+#1929=DIRECTION($,(-0,-1,-0));+#1930=DIRECTION($,(-1,0,0));+#1931=AXIS2_PLACEMENT_3D($,#1928,#1929,#1930);+#1932=PLANE($,#1931);+#1933=ORIENTED_EDGE($,$,$,#224,.T.);+#1934=CARTESIAN_POINT($,(95.5,63,1.2));+#1935=DIRECTION($,(0,0,-1));+#1936=VECTOR($,#1935,1);+#1937=LINE($,#1934,#1936);+#1938=EDGE_CURVE($,#219,#485,#1937,.T.);+#1939=ORIENTED_EDGE($,$,$,#1938,.T.);+#1940=ORIENTED_EDGE($,$,$,#490,.F.);+#1941=ORIENTED_EDGE($,$,$,#1921,.F.);+#1942=EDGE_LOOP($,(#1933,#1939,#1940,#1941));+#1943=FACE_OUTER_BOUND('',#1942,.T.);+#1944=ADVANCED_FACE('',(#1943),#1932,.T.);+#1945=CARTESIAN_POINT($,(95.5,63,1.2));+#1946=DIRECTION($,(1,0,0));+#1947=DIRECTION($,(0,-1,0));+#1948=AXIS2_PLACEMENT_3D($,#1945,#1946,#1947);+#1949=PLANE($,#1948);+#1950=ORIENTED_EDGE($,$,$,#246,.T.);+#1951=ORIENTED_EDGE($,$,$,#1906,.F.);+#1952=ORIENTED_EDGE($,$,$,#496,.F.);+#1953=ORIENTED_EDGE($,$,$,#1938,.F.);+#1954=EDGE_LOOP($,(#1950,#1951,#1952,#1953));+#1955=FACE_OUTER_BOUND('',#1954,.T.);+#1956=ADVANCED_FACE('',(#1955),#1949,.T.);+#1957=CLOSED_SHELL($,(#250,#500,#540,#580,#606,#632,#672,#712,#738,#764,#804,#844,#870,#896,#936,#976,#1002,#1028,#1068,#1108,#1134,#1160,#1182,#1204,#1221,#1243,#1260,#1282,#1299,#1316,#1338,#1360,#1372,#1384,#1406,#1423,#1440,#1452,#1464,#1486,#1503,#1520,#1532,#1544,#1566,#1583,#1600,#1612,#1624,#1646,#1663,#1680,#1692,#1704,#1716,#1728,#1740,#1752,#1774,#1791,#1808,#1820,#1842,#1859,#1876,#1888,#1910,#1927,#1944,#1956));+#1958=MANIFOLD_SOLID_BREP('AetherisBody',#1957);+#1959=APPLICATION_CONTEXT('mechanical design');+#1960=PRODUCT_CONTEXT('',#1959,'mechanical');+#1961=PRODUCT('AETHERIS','AetherisBody','',(#1960));+#1962=PRODUCT_DEFINITION_FORMATION('','',#1961);+#1963=PRODUCT_DEFINITION_CONTEXT('design',#1959,'design');+#1964=PRODUCT_DEFINITION('','',#1962,#1963);+#1965=PRODUCT_DEFINITION_SHAPE('','',#1964);+#1966=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));+#1967=(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.));+#1968=(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT());+#1969=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNIT_ASSIGNED_CONTEXT((#1966,#1967,#1968))REPRESENTATION_CONTEXT('3','3D'));+#1970=SHAPE_REPRESENTATION('AetherisBody',(#1958),#1969);+#1971=SHAPE_DEFINITION_REPRESENTATION(#1965,#1970);+ENDSEC;+END-ISO-10303-21;diff --git a/docs/modules/sheetmetal/artifacts/m4/templates.md b/docs/modules/sheetmetal/artifacts/m4/templates.mdnew file mode 100644index 00000000..45460329--- /dev/null+++ b/docs/modules/sheetmetal/artifacts/m4/templates.md@@ -0,0 +1,29 @@+# Templates and LLM authoring dogfood++## Reusable templates++`SheetMetalTemplates` exposes:++- `LBracketSpec(Width, Depth, FlangeHeight, Policy)`;+- `UChannelSpec(Width, Depth, WallHeight, Policy)`;+- `FourWallTraySpec(Width, Depth, WallHeight, Policy)`.++`SheetMetalTemplatePolicy` owns thickness, inside radius, K-factor, material, corner policy, and relief policy. Each generator emits ordinary Sheet Metal source and therefore uses normal lowering, DFM, Concept Paths, correspondence, STEP, and SVG. Tested path shape is identical between two tray specializations.++## PSU enclosure++[`m4-psu-enclosure.firmament`](../../../../../fixtures/FirmamentV2/SheetMetal/m4-psu-enclosure.firmament) is 18 noncomment, nonblank source lines with one base, five flanges, four mounting holes, and three vent cuts. It uses `Main.Front`, `Main.Right`, `Main.Rear`, `Main.Left`, and nested `FrontWall.Outer`; it contains no raw region/face/edge/BRep IDs.++Real-path result:++- 11 semantic regions, five bends, seven cuts, four base corners;+- both Mitered and Open corner policies;+- validated exact composed blank;+- valid formed and flat STEP;+- flat size `256.2957516778 x 208.9723886187 mm`;+- deterministic flat hash `da104ebd017d4915b3d10e3a372d59794823caa8aa4d96def08fbb1cd85f5d91`;+- DFM `Pass`.++## Repair dogfood++`m4-bad-tray-dfm.firmament` deliberately declares relief width `0.6 mm` and depth `1 mm` at thickness `1.2 mm`, radius `1.5 mm`. The semantic finding requires width `>= 1.2 mm` and depth `>= 2.7 mm` and supplies a numeric suggestion. `m4-fixed-tray-dfm.firmament` applies those values and changes overall DFM from `Warning` to `Pass` without any BRep inspection.diff --git a/docs/modules/sheetmetal/artifacts/m4/validation-report.md b/docs/modules/sheetmetal/artifacts/m4/validation-report.mdnew file mode 100644index 00000000..3f824f25--- /dev/null+++ b/docs/modules/sheetmetal/artifacts/m4/validation-report.md@@ -0,0 +1,34 @@+# M4 validation report++Environment: .NET SDK `10.0.302`, Windows x64.++## Tests and builds++- `dotnet test Aetheris.SheetMetal.Tests/Aetheris.SheetMetal.Tests.csproj`: 33 passed.+- focused Firmament contour/Concept Path tests: 16 passed.+- `dotnet build Aetheris.slnx --no-restore`: succeeded, 0 warnings, 0 errors.+- `dotnet test Aetheris.slnx --no-build --no-restore`: 2,851 passed across discovered test projects; `Aetheris.FrictionLab.Tests` contains no discoverable tests.+- CLI real paths exercised: `sheetmetal paths`, `sheetmetal inspect`, `sheetmetal flatten --step --svg`, `build`, and `sheetmetal compare`.++## Performance samples (warm CLI process measurements, milliseconds)++| Fixture | Parse | Formed lower | Initial flat lower | Reflatten | Exact single blank | DFM |+|---|---:|---:|---:|---:|---|---|+| L bracket | 8.98 | 53.47 | 56.51 | 0.49 | yes | Pass |+| M3 electronics tray (four reliefs) | 9.32 | 59.24 | 59.02 | 1.53 | no | Fail |+| CTC-03 | 9.41 | 59.95 | 58.46 | 2.43 | no | Fail |++No optimization campaign was needed; exact arrangement is small for these fixtures.++## Determinism++- L bracket: `de2501e789274aa295a7d778c7e8a88a8281cf0d6b29b79e33f06f58572502b4`+- M3 tray: `450fc03780a32a440b697fa6e7567dfe0e85aec8a6c03e1bb16ee4b59d2e2117`+- CTC-03: `dfeb1228747e38e88bdd9e6e0149fbc79db7474fc335035b3a0d65976d9c2ef8`+- PSU enclosure: `da104ebd017d4915b3d10e3a372d59794823caa8aa4d96def08fbb1cd85f5d91`++Repeated flattening retains hashes. Concept Path shape is stable across dimension/radius/cut changes and tray template specializations. Segment and relief ordering is ordinal/stable-ID based.++## DXF seam++The flat IR now separates exact cut contours, exact relief contours, bend lines with up/down direction and policy, and semantic IDs. Future DXF can map cut, bend-up, bend-down, and mark/etch layers as serialization. Full DXF is intentionally not implemented.diff --git a/fixtures/FirmamentV2/SheetMetal/m4-bad-tray-dfm.firmament b/fixtures/FirmamentV2/SheetMetal/m4-bad-tray-dfm.firmamentnew file mode 100644index 00000000..dd4139ec--- /dev/null+++ b/fixtures/FirmamentV2/SheetMetal/m4-bad-tray-dfm.firmament@@ -0,0 +1,8 @@+// Deliberately DFM-invalid: exact topology compiles, semantic DFM identifies the repair.+SheetMetal BadTrayDfm {+ Thickness: 1.2mm;+ KFactor: 0.42;+ Base Main { Profile: Rectangle { Width: 80mm; Height: 60mm; }; }+ Flange Front { From: Main.Front; Height: 12mm; Angle: 90deg; Radius: 1.5mm; Relief: Rectangular; ReliefWidth: 0.6mm; ReliefDepth: 1mm; }+ Flange Right { From: Main.Right; Height: 12mm; Angle: 90deg; Radius: 1.5mm; Relief: Rectangular; ReliefWidth: 0.6mm; ReliefDepth: 1mm; }+}diff --git a/fixtures/FirmamentV2/SheetMetal/m4-fixed-tray-dfm.firmament b/fixtures/FirmamentV2/SheetMetal/m4-fixed-tray-dfm.firmamentnew file mode 100644index 00000000..816ba32f--- /dev/null+++ b/fixtures/FirmamentV2/SheetMetal/m4-fixed-tray-dfm.firmament@@ -0,0 +1,8 @@+// Repair from semantic DFM suggestion: width >= thickness, depth >= radius + thickness.+SheetMetal FixedTrayDfm {+ Thickness: 1.2mm;+ KFactor: 0.42;+ Base Main { Profile: Rectangle { Width: 80mm; Height: 60mm; }; }+ Flange Front { From: Main.Front; Height: 12mm; Angle: 90deg; Radius: 1.5mm; Relief: Rectangular; ReliefWidth: 1.2mm; ReliefDepth: 2.7mm; }+ Flange Right { From: Main.Right; Height: 12mm; Angle: 90deg; Radius: 1.5mm; Relief: Rectangular; ReliefWidth: 1.2mm; ReliefDepth: 2.7mm; }+}diff --git a/fixtures/FirmamentV2/SheetMetal/m4-psu-enclosure.firmament b/fixtures/FirmamentV2/SheetMetal/m4-psu-enclosure.firmamentnew file mode 100644index 00000000..e5baf6b8--- /dev/null+++ b/fixtures/FirmamentV2/SheetMetal/m4-psu-enclosure.firmament@@ -0,0 +1,19 @@+// M4 LLM-authoring dogfood: semantic paths only; no region, face, edge, or BRep IDs.+SheetMetal PsuEnclosure {+ Thickness: 1.2mm;+ Material: "5052-H32 Aluminum";+ KFactor: 0.42;+ Base Main { Profile: Rectangle { Width: 180mm; Height: 120mm; }; }+ Flange FrontWall { From: Main.Front; Height: 35mm; Angle: 90deg; Radius: 1.5mm; Corner: Miter; }+ Flange RightWall { From: Main.Right; Height: 35mm; Angle: 90deg; Radius: 1.5mm; Corner: Miter; }+ Flange RearWall { From: Main.Rear; Height: 35mm; Angle: 90deg; Radius: 1.5mm; Corner: Open; }+ Flange LeftWall { From: Main.Left; Height: 35mm; Angle: 90deg; Radius: 1.5mm; Corner: Open; }+ Flange FrontLip { From: FrontWall.Outer; Height: 10mm; Angle: 90deg; Radius: 1.2mm; Direction: Down; }+ Hole MountFL { On: Main; Center: (15mm, 15mm); Diameter: 4mm; }+ Hole MountFR { On: Main; Center: (165mm, 15mm); Diameter: 4mm; }+ Hole MountRL { On: Main; Center: (15mm, 105mm); Diameter: 4mm; }+ Hole MountRR { On: Main; Center: (165mm, 105mm); Diameter: 4mm; }+ Cut VentLeft { On: Main; Profile: Slot { Length: 45mm; Width: 6mm; }; At: (62mm, 60mm); }+ Cut VentCenter { On: Main; Profile: Slot { Length: 45mm; Width: 6mm; }; At: (90mm, 60mm); }+ Cut VentRight { On: Main; Profile: Slot { Length: 45mm; Width: 6mm; }; At: (118mm, 60mm); }+}