Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Expose semantic layout and validate authored sheet-metal features

Yuechen Li96a4be189889
diff --git a/Aetheris.CLI.Tests/SheetMetalCliTests.cs b/Aetheris.CLI.Tests/SheetMetalCliTests.cs
index da4915f0..5e1d8225 100644
--- a/Aetheris.CLI.Tests/SheetMetalCliTests.cs
+++ b/Aetheris.CLI.Tests/SheetMetalCliTests.cs
@@ -15,7 +15,7 @@ public sealed class SheetMetalCliTests
{
var output=new StringWriter();var error=new StringWriter();var input=Path.Combine(RepoRoot,"testdata/step242/nist/CTC/nist_ctc_03_asme1_ap242-e2.stp");
var exit=CliRunner.Run(["sheetmetal","inspect",input,"--json"],output,error);Assert.Equal(0,exit);Assert.Empty(error.ToString());
- using var json=JsonDocument.Parse(output.ToString());var root=json.RootElement;Assert.True(root.GetProperty("success").GetBoolean());Assert.Equal("Partial",root.GetProperty("recognitionStatus").GetString());Assert.Equal(7,root.GetProperty("sheetMetal").GetProperty("bends").GetArrayLength());Assert.Equal("Partial",root.GetProperty("flatPattern").GetProperty("status").GetString());
+ using var json=JsonDocument.Parse(output.ToString());var root=json.RootElement;Assert.True(root.GetProperty("success").GetBoolean());Assert.Equal("Partial",root.GetProperty("recognitionStatus").GetString());Assert.Equal(7,root.GetProperty("sheetMetal").GetProperty("bends").GetArrayLength());Assert.Equal(17,root.GetProperty("sheetMetal").GetProperty("cuts").GetArrayLength());Assert.Equal("Partial",root.GetProperty("flatPattern").GetProperty("status").GetString());
}
[Fact]
@@ -67,8 +67,8 @@ public sealed class SheetMetalCliTests
var source=Path.Combine(RepoRoot,"testdata/step242/nist/CTC/nist_ctc_03_asme1_ap242-e2.stp");var intent=Path.Combine(RepoRoot,"docs/modules/sheetmetal/artifacts/m2/ctc03-idiomatic.firmament");
var output=new StringWriter();var error=new StringWriter();var recover=CliRunner.Run(["sheetmetal","recover",source,"--out-dir",dir,"--json"],output,error);
Assert.Equal(0,recover);Assert.Empty(error.ToString());Assert.Contains("Ambiguities:",File.ReadAllText(Path.Combine(dir,"reconstruction-brief.md")));Assert.True(File.Exists(Path.Combine(dir,"recovery-summary.json")));
- output.GetStringBuilder().Clear();var compare=CliRunner.Run(["sheetmetal","compare",source,intent,"--json"],output,error);Assert.Equal(0,compare);Assert.Empty(error.ToString());
- using var report=JsonDocument.Parse(output.ToString());Assert.True(report.RootElement.GetProperty("success").GetBoolean());Assert.Equal("NeedsReview",report.RootElement.GetProperty("comparison").GetProperty("status").GetString());Assert.Equal(7,report.RootElement.GetProperty("comparison").GetProperty("bends").GetArrayLength());
+ output.GetStringBuilder().Clear();var compare=CliRunner.Run(["sheetmetal","compare",source,intent,"--json"],output,error);Assert.Equal(2,compare);Assert.Empty(error.ToString());
+ using var report=JsonDocument.Parse(output.ToString());Assert.False(report.RootElement.GetProperty("success").GetBoolean());Assert.Equal("Fail",report.RootElement.GetProperty("comparison").GetProperty("status").GetString());Assert.Equal(7,report.RootElement.GetProperty("comparison").GetProperty("bends").GetArrayLength());Assert.Contains(report.RootElement.GetProperty("comparison").GetProperty("diagnostics").EnumerateArray(),x=>x.GetString()!.Contains("Feature count mismatch: source 17, intent 2",StringComparison.Ordinal));
}
finally{Directory.Delete(dir,true);}
}
diff --git a/Aetheris.CLI/CliRunner.cs b/Aetheris.CLI/CliRunner.cs
index 756ed361..101b392b 100644
--- a/Aetheris.CLI/CliRunner.cs
+++ b/Aetheris.CLI/CliRunner.cs
@@ -542,7 +542,7 @@ 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 exactValidation=flat.ExactBlankContour is null?null:PlanarContourKernel.Validate(flat.ExactBlankContour);
- 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}),reliefs=part.Reliefs?.Count??0,conceptPaths,templateInstantiations},flatPattern=new{flat.Status,flat.Bounds,bendLines=flat.BendLines.Count,cuts=flat.CutLoops.Count,reliefs=flat.ReliefLoops?.Count??0,exactBlank=flat.ExactBlankContour is not null,outerLoops=flat.ExactBlankContour is null?0:1,innerLoops=flat.ExactBlankContour?.InnerLoops.Count??0,connectedMaterialRegions=flat.ExactBlankContour is null?0:1,selfIntersects=exactValidation?.Diagnostics.Any(x=>x.Code=="planar-contour-self-intersection")??false,exactContoursValid=exactValidation?.IsValid??false,fallbackUsed=authoredSpec is not null&&flat.ExactBlankContour is 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}};
+ 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}),reliefs=part.Reliefs?.Count??0,semanticLayout=authoredSpec?.SemanticLayout,conceptPaths,templateInstantiations},flatPattern=new{flat.Status,flat.Bounds,bendLines=flat.BendLines.Count,cuts=flat.CutLoops.Count,reliefs=flat.ReliefLoops?.Count??0,exactBlank=flat.ExactBlankContour is not null,outerLoops=flat.ExactBlankContour is null?0:1,innerLoops=flat.ExactBlankContour?.InnerLoops.Count??0,connectedMaterialRegions=flat.ExactBlankContour is null?0:1,selfIntersects=exactValidation?.Diagnostics.Any(x=>x.Code=="planar-contour-self-intersection")??false,exactContoursValid=exactValidation?.IsValid??false,fallbackUsed=authoredSpec is not null&&flat.ExactBlankContour is 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,semanticResolve=authoredTimings?.SemanticResolveMilliseconds,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 allDiagnostics)stdout.WriteLine($" [{d.Severity}] {d.Code}: {d.Message}");
diff --git a/Aetheris.SheetMetal.Tests/SheetMetalM1Tests.cs b/Aetheris.SheetMetal.Tests/SheetMetalM1Tests.cs
index a7100292..3f0816d6 100644
--- a/Aetheris.SheetMetal.Tests/SheetMetalM1Tests.cs
+++ b/Aetheris.SheetMetal.Tests/SheetMetalM1Tests.cs
@@ -38,7 +38,7 @@ public sealed class SheetMetalM1Tests
var path=Path.Combine(RepoRoot,"testdata/step242/nist/CTC/nist_ctc_03_asme1_ap242-e2.stp");
var first=SheetMetalRecognizer.RecognizeStep(path);var second=SheetMetalRecognizer.RecognizeStep(path);
Assert.True(first.Thickness.IsPlausible,string.Join("\n",first.Diagnostics.Select(d=>d.Message)));Assert.True(first.Part is not null,$"t={first.Thickness.NominalThickness}; planar={first.Thickness.SourcePairs.Count(p=>p.Family=="Planar")}; closestPlanar={string.Join(",",first.Thickness.SourcePairs.Where(p=>p.Family=="Planar").OrderBy(p=>p.Residual).Take(10).Select(p=>$"{p.FaceA}-{p.FaceB}:{p.Separation}/r{p.Residual}"))}; admitted={string.Join(",",first.Thickness.SourcePairs.Where(p=>p.Admitted).Select(p=>$"{p.Family}:{p.FaceA}-{p.FaceB}:{p.Separation}"))}; diagnostics={string.Join(" | ",first.Diagnostics.Select(d=>d.Message))}");
- Assert.Equal(15,first.Part!.Regions.Count);Assert.Equal(7,first.Part.Bends.Count);Assert.Equal(2,first.Part.Features.Count);Assert.Equal(first.Part.StableId,second.Part!.StableId);
+ Assert.Equal(15,first.Part!.Regions.Count);Assert.Equal(7,first.Part.Bends.Count);Assert.Equal(17,first.Part.Features.Count);Assert.Equal(first.Part.StableId,second.Part!.StableId);
var flat1=SheetMetalFlattener.Flatten(first.Part);var flat2=SheetMetalFlattener.Flatten(second.Part);Assert.Equal(flat1.DeterministicHash,flat2.DeterministicHash);Assert.NotEqual(FlatPatternStatus.Unsupported,flat1.Status);
var validation=SheetMetalFlatPatternValidation.Validate(flat1);Assert.True(validation.Finite);Assert.True(validation.LoopsClosed);Assert.Empty(validation.Overlaps);
var flatBody=SheetMetalManufacturingArtifacts.BuildFlatBody(first.Part,flat1);Assert.True(flatBody.IsSuccess,string.Join("\n",flatBody.Diagnostics.Select(d=>d.Message)));Assert.NotNull(flatBody.Body);
diff --git a/Aetheris.SheetMetal.Tests/SheetMetalM2Tests.cs b/Aetheris.SheetMetal.Tests/SheetMetalM2Tests.cs
index f6d09569..f30dac9c 100644
--- a/Aetheris.SheetMetal.Tests/SheetMetalM2Tests.cs
+++ b/Aetheris.SheetMetal.Tests/SheetMetalM2Tests.cs
@@ -24,13 +24,14 @@ public sealed class SheetMetalM2Tests
}
[Fact]
- public void IdiomaticCtc_CompilesIndependentlyAndLocalizesHistoricalTrimDifferences()
+ public void HistoricalIdiomaticCtc_CompilesButNowHonestlyFailsRecoveredHoleParity()
{
var source=SheetMetalRecognizer.RecognizeStep(Ctc).Part!;var authored=SheetMetalFirmament.CompileFile(Intent);
Assert.True(authored.IsSuccess,string.Join('\n',authored.Diagnostics.Select(d=>d.Message)));Assert.Equal("MainDeck",authored.Part!.BaseRegionId);
Assert.Contains(authored.Part.Bends,b=>b.StableId=="FrontWallBend");Assert.Contains(authored.Part.Features,f=>f.StableId=="VentSlotLeft");
var comparison=SheetMetalIntentComparer.Compare(source,authored.Part);
- Assert.Equal(SheetMetalComparisonStatus.NeedsReview,comparison.Status);Assert.True(comparison.SourceToIntent.Maximum>0);Assert.All(comparison.Bends,b=>Assert.Equal(SheetMetalComparisonStatus.Pass,b.Status));Assert.All(comparison.Features,f=>Assert.Equal(SheetMetalComparisonStatus.Pass,f.Status));Assert.Equal(SheetMetalComparisonStatus.Fail,comparison.FlatPattern.Status);
+ Assert.Equal(SheetMetalComparisonStatus.Fail,comparison.Status);Assert.True(comparison.SourceToIntent.Maximum>0);Assert.All(comparison.Bends,b=>Assert.Equal(SheetMetalComparisonStatus.Pass,b.Status));
+ Assert.Contains(comparison.Diagnostics,x=>x.Contains("Feature count mismatch: source 17, intent 2",StringComparison.Ordinal));Assert.Equal(SheetMetalComparisonStatus.Fail,comparison.FlatPattern.Status);
}
[Fact]
diff --git a/Aetheris.SheetMetal.Tests/SheetMetalM8Tests.cs b/Aetheris.SheetMetal.Tests/SheetMetalM8Tests.cs
new file mode 100644
index 00000000..756267dc
--- /dev/null
+++ b/Aetheris.SheetMetal.Tests/SheetMetalM8Tests.cs
@@ -0,0 +1,105 @@
+using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Core.Step242;
+using Xunit;
+
+namespace Aetheris.SheetMetal.Tests;
+
+public sealed class SheetMetalM8Tests
+{
+ private static readonly string RepoRoot=FindRepoRoot();
+ private static string CtcStep=>Path.Combine(RepoRoot,"testdata/step242/nist/CTC/nist_ctc_03_asme1_ap242-e2.stp");
+ private static string CtcIntent=>Path.Combine(RepoRoot,"docs/modules/sheetmetal/artifacts/m8/ctc03-final.firmament");
+
+ [Fact]
+ public void Ctc03_RecoversEveryCircularAndProfileOpeningFromPairedPlanarSkins()
+ {
+ var recovered=SheetMetalRecognizer.RecognizeStep(CtcStep);var part=Assert.IsType<SheetMetalPartIr>(recovered.Part);
+ Assert.Equal(15,part.Features.Count(x=>x.Kind==SheetFeatureKind.CircularHole));
+ Assert.Equal(2,part.Features.Count(x=>x.Kind==SheetFeatureKind.Slot));
+ Assert.Contains(part.Features,x=>x.Diameter is { } d&&Math.Abs(d-4.7625)<1e-6);
+ Assert.Contains(part.Features,x=>x.Diameter is { } d&&Math.Abs(d-50.8)<1e-6);
+ }
+
+ [Fact]
+ public void Ctc03_FinalSemanticLayout_LowersAllOpeningsAndPartialTabFlangeWithoutSourceStep()
+ {
+ var isolated=Path.Combine(Path.GetTempPath(),$"ctc03-m8-{Guid.NewGuid():N}.firmament");
+ try
+ {
+ File.Copy(CtcIntent,isolated);var result=SheetMetalFirmament.CompileFile(isolated);
+ Assert.True(result.IsSuccess,string.Join('\n',result.Diagnostics.Select(x=>x.Message)));
+ Assert.Equal(15,result.Part!.Features.Count(x=>x.Kind==SheetFeatureKind.CircularHole));
+ Assert.Equal(2,result.Part.Features.Count(x=>x.Kind==SheetFeatureKind.Slot));
+ Assert.Equal(9,result.Spec!.SemanticLayout.Patterns.Count);Assert.Single(result.Spec.SemanticLayout.Tabs);
+ Assert.Equal(127,result.Part.Regions.Single(x=>x.StableId=="AngledServiceFlangeBendRegion").Cylinder!.AxisLength,8);
+ Assert.NotNull(result.FlatPattern!.ExactBlankContour);Assert.Equal(17,result.FlatPattern.CutLoops.Count);
+ Assert.True(BrepExportPreflight.Validate(result.Part.FormedBody!).IsValid);
+ }
+ finally{if(File.Exists(isolated))File.Delete(isolated);}
+ }
+
+ [Fact]
+ public void Ctc03_FinalSemanticLayout_HasCompleteFeatureParityAtComparisonTolerance()
+ {
+ var source=SheetMetalRecognizer.RecognizeStep(CtcStep).Part!;var intent=SheetMetalFirmament.CompileFile(CtcIntent).Part!;
+ var comparison=SheetMetalIntentComparer.Compare(source,intent);
+ Assert.Equal(17,comparison.Features.Count);Assert.All(comparison.Features,x=>Assert.Equal(SheetMetalComparisonStatus.Pass,x.Status));
+ Assert.All(comparison.Bends,x=>Assert.Equal(SheetMetalComparisonStatus.Pass,x.Status));
+ }
+
+ [Theory]
+ [InlineData("EqualSize", "10mm", "11mm", "sheetmetal-semantic-equal-size")]
+ [InlineData("EqualPitch", "10mm", "10mm", "sheetmetal-semantic-equal-pitch")]
+ [InlineData("Mirror", "10mm", "10mm", "sheetmetal-semantic-mirror")]
+ public void SemanticContracts_RejectStatedEngineeringContradictions(string kind,string firstDiameter,string secondDiameter,string code)
+ {
+ var secondX=kind=="EqualPitch"?"41mm":kind=="Mirror"?"81mm":"40mm";
+ var extra=kind=="EqualPitch"?"Axis: X; Pitch: 20mm;":kind=="Mirror"?"About: Panel.CenterX;":"";
+ var source=$$"""
+ SheetMetal Contradiction { Thickness: 1.5mm; Base Panel { Profile: Rectangle { Width: 100mm; Height: 60mm; }; }
+ Flange Lip { From: Panel.Rear; Height: 15mm; Angle: 90deg; Radius: 2mm; }
+ Hole Left { On: Panel; Center: (20mm, 20mm); Diameter: {{firstDiameter}}; }
+ Hole Right { On: Panel; Center: ({{secondX}}, 20mm); Diameter: {{secondDiameter}}; }
+ Require StatedIntent { Kind: {{kind}}; Members: [Left, Right]; {{extra}} }
+ }
+ """;
+ var result=SheetMetalFirmament.Compile(source);Assert.False(result.IsSuccess);Assert.Contains(result.Diagnostics,x=>x.Code==code);
+ }
+
+ [Fact]
+ public void SemanticLayout_GeneralizesToNonCtcPanelAndRetainsStablePaths()
+ {
+ var path=Path.Combine(RepoRoot,"fixtures/FirmamentV2/SheetMetal/m8-semantic-panel.firmament");var first=SheetMetalFirmament.CompileFile(path);var second=SheetMetalFirmament.CompileFile(path);
+ Assert.True(first.IsSuccess,string.Join('\n',first.Diagnostics.Select(x=>x.Message)));Assert.Equal(4,first.Part!.Features.Count);
+ var paths=SheetMetalConceptPaths.Inspect(first.Spec!,first.Part,first.FlatPattern).Select(x=>x.Path).ToArray();
+ Assert.Contains("PanelLayout.MountingHoles[0]",paths);Assert.Contains("PanelLayout.MountingHoles[3]",paths);
+ Assert.Equal(first.FlatPattern!.DeterministicHash,second.FlatPattern!.DeterministicHash);
+ }
+
+ [Theory]
+ [InlineData("Span: 0mm;")]
+ [InlineData("SpanOffset: 1mm;")]
+ public void PartialEdgeFlange_RejectsIncompleteOrDegenerateSpanIntent(string spanIntent)
+ {
+ var source=$$"""
+ SheetMetal InvalidSpan {
+ Thickness: 1mm;
+ Base Panel { Profile: Rectangle { Width: 100mm; Height: 60mm; }; }
+ Flange Lip { From: Panel.Rear; Height: 15mm; {{spanIntent}} Angle: 90deg; Radius: 2mm; }
+ }
+ """;
+ var result=SheetMetalFirmament.Compile(source);Assert.False(result.IsSuccess);
+ Assert.Contains(result.Diagnostics,x=>x.Code=="sheetmetal-flange-span-invalid");
+ }
+
+ [Fact]
+ public void Ctc03_FinalArtifacts_ExportAndReimportAsClosedBodies()
+ {
+ var result=SheetMetalFirmament.CompileFile(CtcIntent);Assert.True(result.IsSuccess);
+ var formed=Step242Exporter.ExportBody(result.Part!.FormedBody!);Assert.True(formed.IsSuccess);Assert.True(Step242Importer.ImportBody(formed.Value).IsSuccess);
+ var flatBody=SheetMetalManufacturingArtifacts.BuildFlatBody(result.Part,result.FlatPattern!);Assert.True(flatBody.IsSuccess,string.Join('\n',flatBody.Diagnostics.Select(x=>x.Message)));
+ var flat=Step242Exporter.ExportBody(flatBody.Body!);Assert.True(flat.IsSuccess);Assert.True(Step242Importer.ImportBody(flat.Value).IsSuccess);
+ }
+
+ 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.cs
index 2aafea14..bfda2051 100644
--- a/Aetheris.SheetMetal/SheetMetalAuthoredLowering.cs
+++ b/Aetheris.SheetMetal/SheetMetalAuthoredLowering.cs
@@ -20,14 +20,19 @@ public sealed record AuthoredSheetBaseSpec(string Name, double Width, double Dep
public sealed record AuthoredSheetFlangeSpec(
string Name, string ParentRegion, string EdgeName, double Length, double AngleRadians,
double InsideRadius, SheetBendDirection Direction, SheetCornerPolicy CornerPolicy,
- SheetReliefPolicy ReliefPolicy, double? ReliefWidth = null, double? ReliefDepth = null);
+ SheetReliefPolicy ReliefPolicy, double? ReliefWidth = null, double? ReliefDepth = null,
+ double? SpanLength = null, double SpanOffset = 0d);
public sealed record AuthoredSheetCutSpec(
string Name, string RegionName, SheetFeatureKind Kind, double X, double Y,
double? Diameter, double? Width, double? Length);
public sealed record SheetMetalConstructionSpec(
string Name, double Thickness, string? Material, double KFactor, AuthoredSheetBaseSpec Base,
IReadOnlyList<AuthoredSheetFlangeSpec> Flanges, IReadOnlyList<AuthoredSheetCutSpec> Cuts,
- SheetMetalProvenanceCategory Authority, bool LegacySyntax = false, string? SatisfiesConcept = null);
+ SheetMetalProvenanceCategory Authority, bool LegacySyntax = false, string? SatisfiesConcept = null)
+{
+ /// <summary>Compile-time semantic layout erased after it resolves exact authored cuts.</summary>
+ public SheetMetalSemanticLayout SemanticLayout { get; init; } = SheetMetalSemanticLayout.Empty;
+}
/// <summary>
/// Bounded high-level authored Sheet Metal compiler. It deliberately consumes only
@@ -90,11 +95,16 @@ internal static class AuthoredSheetMetalCompiler
var 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);
+ var hasSpan=Scalar(block.Body, "Span", "mm", out var spanLength);
+ var hasSpanOffset=Scalar(block.Body, "SpanOffset", "mm", out var spanOffset);
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);
+ if(hasSpan&&spanLength<=0)return Fail($"Flange '{block.Name}' Span must be positive when supplied.","sheetmetal-flange-span-invalid");
+ if(hasSpanOffset&&!hasSpan)return Fail($"Flange '{block.Name}' SpanOffset requires Span.","sheetmetal-flange-span-invalid");
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));
+ reliefWidth > 0 ? reliefWidth : null, reliefDepth > 0 ? reliefDepth : null,
+ spanLength > 0 ? spanLength : null, spanOffset));
}
if (flanges.Count == 0) return Fail("At least one Flange is required.");
var duplicate = flanges.GroupBy(f => (f.ParentRegion.ToLowerInvariant(), f.EdgeName.ToLowerInvariant())).FirstOrDefault(g => g.Count() > 1);
@@ -135,17 +145,26 @@ internal static class AuthoredSheetMetalCompiler
}
}
+ var semanticStarted=Stopwatch.GetTimestamp();
+ var semanticLayout=SheetMetalSemanticLayoutParser.Parse(source,baseSpec,flanges,cuts);
+ var semanticMs=Stopwatch.GetElapsedTime(semanticStarted).TotalMilliseconds;
+ if(!semanticLayout.IsSuccess)return new(false,null,null,null,semanticLayout.Diagnostics);
+ cuts.AddRange(semanticLayout.GeneratedCuts);
+ var duplicateCut=cuts.GroupBy(x=>x.Name,StringComparer.Ordinal).FirstOrDefault(x=>x.Count()>1);
+ if(duplicateCut is not null)return Fail($"Semantic feature path '{duplicateCut.Key}' is declared more than once.","sheetmetal-semantic-duplicate-feature");
+
var authority = Regex.IsMatch(source, @"\bIntent\s*:\s*Reconstructed\s*;", Rx)
? SheetMetalProvenanceCategory.Reconstructed : SheetMetalProvenanceCategory.Authored;
var concept=header.Groups["concept"].Success?header.Groups["concept"].Value:null;
- var spec = new SheetMetalConstructionSpec(header.Groups["name"].Value, thickness, material, k, baseSpec, flanges, cuts, authority, legacyBase.Success,concept);
+ var spec = new SheetMetalConstructionSpec(header.Groups["name"].Value, thickness, material, k, baseSpec, flanges, cuts, authority, legacyBase.Success,concept)
+ { SemanticLayout=semanticLayout.Layout };
if(concept is not null&&SheetMetalConceptContracts.Validate(source,spec) is { } conformanceFailure)
return Fail(conformanceFailure.Message,conformanceFailure.Code);
var parseMs=Stopwatch.GetElapsedTime(parseStarted).TotalMilliseconds;var formedStarted=Stopwatch.GetTimestamp();var lowered = AuthoredSheetMetalLowering.Lower(spec, sourcePath);var formedMs=Stopwatch.GetElapsedTime(formedStarted).TotalMilliseconds;
if (!lowered.IsSuccess || lowered.Part is null) return new(false, spec, null, null, lowered.Diagnostics);
var flatStarted=Stopwatch.GetTimestamp();var flat = SheetMetalFlattener.Flatten(lowered.Part);var flatMs=Stopwatch.GetElapsedTime(flatStarted).TotalMilliseconds;
diagnostics.AddRange(lowered.Diagnostics); diagnostics.AddRange(flat.Diagnostics);
- return new(flat.Status is not FlatPatternStatus.Unsupported and not FlatPatternStatus.Overlapping, spec, lowered.Part, flat, diagnostics,new(parseMs,formedMs,flatMs));
+ return new(flat.Status is not FlatPatternStatus.Unsupported and not FlatPatternStatus.Overlapping, spec, lowered.Part, flat, diagnostics,new(parseMs,formedMs,flatMs,semanticMs));
SheetMetalAuthoringResult Fail(string message, string code = "sheetmetal-firmament-invalid") =>
new(false, null, null, null, [new(code, SheetMetalDiagnosticSeverity.Error, message)]);
@@ -251,17 +270,38 @@ internal static class AuthoredSheetMetalLowering
else if (frames.TryGetValue(flange.ParentRegion, out var pf) && flange.EdgeName.Equals("Outer", StringComparison.OrdinalIgnoreCase)) { parentEdge = new(pf.OuterA, pf.OuterB, pf.Outward); parentNormal = pf.Normal; }
else continue;
progressed = true; pending.Remove(flange);
- var edge = parentEdge; var axis = Unit(edge.B - edge.A); var sign = flange.Direction == SheetBendDirection.Down ? -1d : 1d;
+ var edge = parentEdge; var axis = Unit(edge.B - edge.A);
+ if(flange.SpanLength is { } span)
+ {
+ var available=(edge.B-edge.A).Length;if(span>available+1e-8||Math.Abs(flange.SpanOffset)>(available-span)/2d+1e-8)
+ return Failure($"Flange '{flange.Name}' Span {span:G9} mm with offset {flange.SpanOffset:G9} mm does not fit parent edge length {available:G9} mm.","sheetmetal-flange-span-invalid");
+ var spanCenter=Mid(edge.A,edge.B)+axis*flange.SpanOffset;edge=new(spanCenter-axis*(span/2d),spanCenter+axis*(span/2d),edge.Outward);
+ }
+ var sign = flange.Direction == SheetBendDirection.Down ? -1d : 1d;
var rMid = flange.InsideRadius + t / 2d; var angle = flange.AngleRadians;
var tangentA = edge.A + edge.Outward * (rMid * Math.Sin(angle)) + parentNormal * (sign * rMid * (1 - Math.Cos(angle)));
var tangentB = edge.B + edge.Outward * (rMid * Math.Sin(angle)) + parentNormal * (sign * rMid * (1 - Math.Cos(angle)));
var direction = Unit(edge.Outward * Math.Cos(angle) + parentNormal * (sign * Math.Sin(angle)));
var normal = Unit(parentNormal * Math.Cos(angle) - edge.Outward * (sign * Math.Sin(angle)));
var frame = new RegionFrame(flange.Name, tangentA, tangentB, direction, normal, flange.Length); frames[flange.Name] = frame;
- var boundary = new[] { tangentA, tangentB, frame.OuterB, frame.OuterA };
+ IReadOnlyList<Point3D> boundary = [tangentA, tangentB, frame.OuterB, frame.OuterA];
+ var tabs=spec.SemanticLayout.Tabs.Where(x=>x.Region.Equals(flange.Name,StringComparison.OrdinalIgnoreCase)&&x.Edge.Equals("Outer",StringComparison.OrdinalIgnoreCase)).OrderByDescending(x=>x.Center).ToArray();
+ if(tabs.Length>0)
+ {
+ var points=new List<Point3D>{tangentA,tangentB,frame.OuterB};var cursor=(edge.B-edge.A).Length;
+ foreach(var tab in tabs)
+ {
+ var right=tab.Center+tab.Width/2d;var left=tab.Center-tab.Width/2d;
+ if(left< -1e-8||right>cursor+1e-8)return Failure($"Tab '{tab.Path}' does not fit '{flange.Name}.Outer'.","sheetmetal-tab-outside-edge");
+ if(right<cursor-1e-8)points.Add(frame.OuterA+axis*right);
+ points.Add(frame.OuterA+axis*right+direction*tab.Extension);points.Add(frame.OuterA+axis*left+direction*tab.Extension);
+ if(left>1e-8)points.Add(frame.OuterA+axis*left);cursor=left;
+ }
+ points.Add(frame.OuterA);boundary=points;
+ }
var plane = new SheetPlaneReference(tangentA, normal, axis, direction, true);
var flangeId=stableRegions[flange.Name];
- regions.Add(new(flangeId, SheetRegionKind.Planar, Developable("Authored planar flange."), plane, null, boundary, (edge.B-edge.A).Length * flange.Length, source, evidence));
+ regions.Add(new(flangeId, SheetRegionKind.Planar, Developable("Authored planar flange."), plane, null, boundary, (edge.B-edge.A).Length * flange.Length+tabs.Sum(x=>x.Width*x.Extension), source, evidence));
patches.Add(PlanePatch(flangeId, SheetRegionKind.Planar, boundary, normal, t));
var bendId = spec.LegacySyntax ? $"bend-{flange.EdgeName.ToLowerInvariant()}" : $"{flange.Name}Bend"; var bendRegionId = spec.LegacySyntax ? $"region-{flange.EdgeName.ToLowerInvariant()}-bend" : $"{flange.Name}BendRegion"; var centerA = edge.A + parentNormal * (sign * rMid); var center = Mid(centerA, edge.B + parentNormal * (sign * rMid));
diff --git a/Aetheris.SheetMetal/SheetMetalConceptContracts.cs b/Aetheris.SheetMetal/SheetMetalConceptContracts.cs
index aaad9004..86a5f4e0 100644
--- a/Aetheris.SheetMetal/SheetMetalConceptContracts.cs
+++ b/Aetheris.SheetMetal/SheetMetalConceptContracts.cs
@@ -22,6 +22,8 @@ internal static class SheetMetalConceptContracts
available[flange.Name]="SheetFlange";
available[flange.Name+"Bend"]="SheetBend";
}
+ foreach(var cut in spec.Cuts)available[cut.Name]="SheetCut";
+ foreach(var pattern in spec.SemanticLayout.Patterns)available[pattern.Name]="SheetPattern";
foreach(Match requirement in Regex.Matches(declaration.Groups["body"].Value,@"(?m)^\s*(?<name>[A-Za-z_][A-Za-z0-9_]*)\s*:\s*(?<type>[A-Za-z_][A-Za-z0-9_]*)\s*$",RegexOptions.CultureInvariant))
{
var name=requirement.Groups["name"].Value;var expected=requirement.Groups["type"].Value;
diff --git a/Aetheris.SheetMetal/SheetMetalConceptPaths.cs b/Aetheris.SheetMetal/SheetMetalConceptPaths.cs
index 6f554bf3..99afe34b 100644
--- a/Aetheris.SheetMetal/SheetMetalConceptPaths.cs
+++ b/Aetheris.SheetMetal/SheetMetalConceptPaths.cs
@@ -39,6 +39,14 @@ public static class SheetMetalConceptPaths
Add(cut.Name,"SheetCut",cut.Name,cut.Name,cut.Name,"authored cut declaration","FlatFeature","Cuttable");
Add($"{cut.RegionName}.{cut.Name}","SheetCut",$"{cut.RegionName}.{cut.Name}",cut.Name,cut.Name,"semantic owning-region cut path","FlatFeature","Cuttable");
}
+ foreach(var datum in spec.SemanticLayout.Datums)
+ Add(datum.Path,"SheetDatum",datum.Path,null,null,datum.Provenance,"PointCapable","StableSemanticIdentity");
+ foreach(var tab in spec.SemanticLayout.Tabs)
+ Add(tab.Path,"SheetTab",tab.Path,tab.Region,$"flat-{tab.Region}","exact outer-edge contour extension","EdgeFeature","ManufacturingContour","StableSemanticIdentity");
+ foreach(var pattern in spec.SemanticLayout.Patterns)
+ Add(pattern.Path,"SheetPattern",pattern.Path,null,null,"compile-time semantic feature pattern","EqualPitch","EqualSize","StableSemanticIdentity");
+ foreach(var constraint in spec.SemanticLayout.Constraints)
+ Add(constraint.Path,"SheetConstraint",constraint.Path,null,null,constraint.Detail,"ValidatedBeforeProfileLowering");
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();
diff --git a/Aetheris.SheetMetal/SheetMetalFirmament.cs b/Aetheris.SheetMetal/SheetMetalFirmament.cs
index 2f1d32e3..a73e6528 100644
--- a/Aetheris.SheetMetal/SheetMetalFirmament.cs
+++ b/Aetheris.SheetMetal/SheetMetalFirmament.cs
@@ -3,7 +3,11 @@ using Aetheris.Kernel.Firmament.FirmamentV2;
namespace Aetheris.SheetMetal;
-public sealed record SheetMetalAuthoringTimings(double ParseMilliseconds,double FormedLowerMilliseconds,double FlatLowerMilliseconds);
+public sealed record SheetMetalAuthoringTimings(
+ double ParseMilliseconds,
+ double FormedLowerMilliseconds,
+ double FlatLowerMilliseconds,
+ double SemanticResolveMilliseconds = 0d);
public sealed record SheetMetalAuthoringResult(
bool IsSuccess,
SheetMetalConstructionSpec? Spec,
@@ -26,7 +30,7 @@ public static class SheetMetalFirmament
{
if(source is null)return false;
var clean=Regex.Replace(source,@"//.*?$|#.*?$",string.Empty,RegexOptions.Multiline);
- return Regex.IsMatch(clean,@"^\s*SheetMetal\s+",RegexOptions.IgnoreCase|RegexOptions.CultureInvariant)
+ return Regex.IsMatch(clean,@"\bSheetMetal\s+[A-Za-z_]",RegexOptions.IgnoreCase|RegexOptions.CultureInvariant)
||Regex.IsMatch(clean,@"\bUse\s+SheetMetal\.ProductFamilies\s*;",RegexOptions.IgnoreCase|RegexOptions.CultureInvariant);
}
diff --git a/Aetheris.SheetMetal/SheetMetalRecognizer.cs b/Aetheris.SheetMetal/SheetMetalRecognizer.cs
index c02ab1ab..d3a917c9 100644
--- a/Aetheris.SheetMetal/SheetMetalRecognizer.cs
+++ b/Aetheris.SheetMetal/SheetMetalRecognizer.cs
@@ -274,14 +274,14 @@ public static class SheetMetalRecognizer
foreach(var face in new[]{pair.A,pair.B})foreach(var loopId in body.GetLoopIds(face.Id).Skip(1))
{
var edges=body.GetCoedgeIds(loopId).Select(body.GetCoedgeEdgeId).ToArray();
- if(edges.Length==1&&body.TryGetEdgeCurve(edges[0],out var curve)&&curve?.Circle3 is Circle3Curve circle)
+ if(TryCircularLoop(body,edges,tolerance,out var circle))
{
var center=ProjectToPlane(circle.Center,region.Plane);
- var id=$"feature-hole-f{face.Id.Value:D4}-e{edges[0].Value:D4}";
+ var id=$"feature-hole-f{face.Id.Value:D4}-e{edges.Min(e=>e.Value):D4}";
if(result.Any(f=>(f.Center-center).Length<=tolerance&&Math.Abs((f.Diameter??0)-2d*circle.Radius)<=tolerance))continue;
result.Add(new(id,SheetFeatureKind.CircularHole,region.StableId,center,2d*circle.Radius,[],
new("STEP/BRep loop","formed cut-boundary evidence",[face.Id.Value],edges.Select(e=>e.Value).ToArray(),sourcePath),
- [new(SheetEvidenceKind.Exact,"circular-inner-loop","Single closed circular edge on a recovered planar sheet skin.",2d*circle.Radius,null,[face.Id.Value])]));
+ [new(SheetEvidenceKind.Exact,"circular-inner-loop",edges.Length==1?"Single closed circular edge on a recovered planar sheet skin.":"Coaxial circular arcs form one closed circular inner loop on a recovered planar sheet skin.",2d*circle.Radius,null,[face.Id.Value])]));
}
else
{
@@ -297,6 +297,20 @@ public static class SheetMetalRecognizer
return result.OrderBy(f=>f.StableId,StringComparer.Ordinal).ToArray();
}
+ private static bool TryCircularLoop(BrepBody body,IReadOnlyList<EdgeId> edges,double tolerance,out Circle3Curve circle)
+ {
+ circle=default;if(edges.Count==0)return false;
+ var circles=new List<Circle3Curve>(edges.Count);
+ foreach(var edge in edges)
+ {
+ if(!body.TryGetEdgeCurve(edge,out var curve)||curve?.Circle3 is not Circle3Curve candidate)return false;
+ circles.Add(candidate);
+ }
+ var first=circles[0];var axis=first.Normal.ToVector();
+ if(circles.Skip(1).Any(x=>(x.Center-first.Center).Length>tolerance||Math.Abs(x.Radius-first.Radius)>tolerance||Math.Abs(Math.Abs(x.Normal.ToVector().Dot(axis))-1)>1e-8))return false;
+ circle=first;return true;
+ }
+
private static IReadOnlyList<FaceFacts> ExtractFacts(BrepBody body)
{
var result=new List<FaceFacts>();
diff --git a/Aetheris.SheetMetal/SheetMetalSemanticLayout.cs b/Aetheris.SheetMetal/SheetMetalSemanticLayout.cs
new file mode 100644
index 00000000..527521fd
--- /dev/null
+++ b/Aetheris.SheetMetal/SheetMetalSemanticLayout.cs
@@ -0,0 +1,222 @@
+using System.Globalization;
+using System.Text.RegularExpressions;
+
+namespace Aetheris.SheetMetal;
+
+public enum SheetMetalSemanticConstraintKind { RequiredMembers, EqualSize, EqualPitch, Mirror }
+
+public sealed record SheetMetalSemanticDatum(string Path,string Region,double X,double Y,string Provenance);
+
+public sealed record SheetMetalSemanticTab(string Path,string Region,string Edge,double Center,double Width,double Extension);
+
+public sealed record SheetMetalSemanticPattern(
+ string Path,string Name,string Region,SheetFeatureKind FeatureKind,int Count,double CenterX,double CenterY,
+ double PitchX,double PitchY,double? Diameter,double? Width,double? Length,IReadOnlyList<string> Members);
+
+public sealed record SheetMetalSemanticConstraint(
+ string Path,SheetMetalSemanticConstraintKind Kind,IReadOnlyList<string> Members,string Status,string Detail);
+
+public sealed record SheetMetalSemanticLayout(
+ IReadOnlyList<string> Structs,IReadOnlyList<SheetMetalSemanticDatum> Datums,IReadOnlyList<SheetMetalSemanticTab> Tabs,
+ IReadOnlyList<SheetMetalSemanticPattern> Patterns,IReadOnlyList<SheetMetalSemanticConstraint> Constraints)
+{
+ public static SheetMetalSemanticLayout Empty { get; } = new([],[],[],[],[]);
+}
+
+internal sealed record SheetMetalSemanticLayoutParseResult(
+ bool IsSuccess,SheetMetalSemanticLayout Layout,IReadOnlyList<AuthoredSheetCutSpec> GeneratedCuts,
+ IReadOnlyList<SheetMetalDiagnostic> Diagnostics);
+
+/// <summary>
+/// Bounded semantic-layout pass for authored sheet metal. It resolves named datums and
+/// regular feature patterns before exact cut profiles are lowered. This deliberately is
+/// not a general sketch solver: every supported relationship has direct, deterministic
+/// lowering and a compact engineering diagnostic.
+/// </summary>
+internal static class SheetMetalSemanticLayoutParser
+{
+ private const RegexOptions Rx=RegexOptions.IgnoreCase|RegexOptions.CultureInvariant|RegexOptions.Singleline;
+ private const string Number=@"[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)";
+ private sealed record Block(string Keyword,string Name,string Body,int Index,string? Struct);
+ private readonly record struct Point2(double X,double Y);
+
+ internal static SheetMetalSemanticLayoutParseResult Parse(
+ string source,AuthoredSheetBaseSpec baseSpec,IReadOnlyList<AuthoredSheetFlangeSpec> flanges,
+ IReadOnlyList<AuthoredSheetCutSpec> authoredCuts)
+ {
+ var diagnostics=new List<SheetMetalDiagnostic>();
+ var structs=StructBlocks(source);
+ var structNames=structs.Select(x=>x.Name).Distinct(StringComparer.Ordinal).OrderBy(x=>x,StringComparer.Ordinal).ToArray();
+ var datums=new List<SheetMetalSemanticDatum>();
+ var tabs=new List<SheetMetalSemanticTab>();
+ var patterns=new List<SheetMetalSemanticPattern>();
+ var generated=new List<AuthoredSheetCutSpec>();
+ var constraints=new List<SheetMetalSemanticConstraint>();
+ var regionSizes=RegionSizes(baseSpec,flanges);
+
+ foreach(var block in Blocks(source,"Datum",structs))
+ {
+ var region=Token(block.Body,"On");
+ if(region is null||!regionSizes.ContainsKey(region))return Fail("sheetmetal-semantic-datum-region",$"Datum '{Path(block)}' references unknown planar region '{region ?? "<missing>"}'.");
+ if(!TryPointExpression(block.Body,"At",region,regionSizes,datums,out var point,out var reason))return Fail("sheetmetal-semantic-datum-point",$"Datum '{Path(block)}' has invalid At expression: {reason}");
+ datums.Add(new(Path(block),region,point.X,point.Y,"resolved before exact profile lowering"));
+ }
+
+ foreach(var block in Blocks(source,"Tab",structs))
+ {
+ var on=TokenPath(block.Body,"On");var match=on is null?Match.Empty:Regex.Match(on,@"^(?<region>[A-Za-z_][A-Za-z0-9_]*)\.(?<edge>Outer)$",Rx);
+ if(!match.Success||!regionSizes.TryGetValue(match.Groups["region"].Value,out var size))return Fail("sheetmetal-tab-edge",$"Tab '{Path(block)}' requires On: <planar-region>.Outer.");
+ if(!Scalar(block.Body,"Center",out var center)||!Scalar(block.Body,"Width",out var width)||!Scalar(block.Body,"Extension",out var extension)||width<=0||extension<=0)
+ return Fail("sheetmetal-tab-profile",$"Tab '{Path(block)}' requires Center, positive Width, and positive Extension.");
+ if(center-width/2< -1e-8||center+width/2>size.Width+1e-8)return Fail("sheetmetal-tab-outside-edge",$"Tab '{Path(block)}' lies outside '{on}'.");
+ if(tabs.Any(x=>x.Region.Equals(match.Groups["region"].Value,StringComparison.OrdinalIgnoreCase)&&center-width/2<x.Center+x.Width/2-1e-8&&center+width/2>x.Center-x.Width/2+1e-8))
+ return Fail("sheetmetal-tab-overlap",$"Tab '{Path(block)}' overlaps another tab on '{on}'.");
+ tabs.Add(new(Path(block),match.Groups["region"].Value,match.Groups["edge"].Value,center,width,extension));
+ }
+
+ foreach(var block in Blocks(source,"Pattern",structs))
+ {
+ var path=Path(block);var region=Token(block.Body,"On");
+ if(region is null||!regionSizes.ContainsKey(region))return Fail("sheetmetal-semantic-pattern-region",$"Pattern '{path}' references unknown planar region '{region ?? "<missing>"}'.");
+ if(!Int(block.Body,"Count",out var count)||count<=0||count>1024)return Fail("sheetmetal-semantic-pattern-count",$"Pattern '{path}' requires Count between 1 and 1024.");
+ if(!Tuple(block.Body,"Pitch",out var pitch))return Fail("sheetmetal-semantic-pattern-pitch",$"Pattern '{path}' requires a two-dimensional Pitch.");
+ if(!TryPointExpression(block.Body,"Center",region,regionSizes,datums,out var center,out var reason))return Fail("sheetmetal-semantic-pattern-center",$"Pattern '{path}' has invalid Center expression: {reason}");
+ var circle=Regex.Match(block.Body,$@"\bFeature\s*:\s*(?:Circle|Hole)\s*\{{(?<body>[\s\S]*?)\}}\s*;?",Rx);
+ var slot=Regex.Match(block.Body,$@"\bFeature\s*:\s*(?:Slot|Rectangle)\s*\{{(?<body>[\s\S]*?)\}}\s*;?",Rx);
+ SheetFeatureKind kind;double? diameter=null,width=null,length=null;
+ if(circle.Success)
+ {
+ kind=SheetFeatureKind.CircularHole;
+ if(!Scalar(circle.Groups["body"].Value,"Diameter",out var d)||d<=0)return Fail("sheetmetal-semantic-pattern-profile",$"Circular Pattern '{path}' requires positive Diameter.");
+ diameter=d;
+ }
+ else if(slot.Success)
+ {
+ kind=SheetFeatureKind.Slot;
+ if(!Scalar(slot.Groups["body"].Value,"Width",out var w)||!Scalar(slot.Groups["body"].Value,"Length",out var l)||w<=0||l<=0)return Fail("sheetmetal-semantic-pattern-profile",$"Slot Pattern '{path}' requires positive Width and Length.");
+ width=w;length=l;
+ }
+ else return Fail("sheetmetal-semantic-pattern-profile",$"Pattern '{path}' requires a Circle/Hole or Slot/Rectangle Feature.");
+
+ var members=new List<string>();
+ for(var i=0;i<count;i++)
+ {
+ var member=$"{path}[{i}]";var offset=i-(count-1)/2d;
+ generated.Add(new(member,region,kind,center.X+offset*pitch.X,center.Y+offset*pitch.Y,diameter,width,length));members.Add(member);
+ }
+ patterns.Add(new(path,block.Name,region,kind,count,center.X,center.Y,pitch.X,pitch.Y,diameter,width,length,members));
+ constraints.Add(new($"{path}.EqualPitch",SheetMetalSemanticConstraintKind.EqualPitch,members,"Satisfied",$"generated at pitch ({pitch.X:G9} mm, {pitch.Y:G9} mm)"));
+ constraints.Add(new($"{path}.EqualSize",SheetMetalSemanticConstraintKind.EqualSize,members,"Satisfied","all members lower from one analytic feature specification"));
+ }
+
+ var combinedCuts=authoredCuts.Concat(generated).ToArray();
+ var duplicateCut=combinedCuts.GroupBy(x=>x.Name,StringComparer.Ordinal).FirstOrDefault(x=>x.Count()>1);
+ if(duplicateCut is not null)return Fail("sheetmetal-semantic-duplicate-feature",$"Semantic feature path '{duplicateCut.Key}' is declared more than once.");
+ var allCuts=combinedCuts.ToDictionary(x=>x.Name,StringComparer.Ordinal);
+ foreach(var block in Blocks(source,"Require",structs))
+ {
+ var path=Path(block);var kindToken=Token(block.Body,"Kind");var members=List(block.Body,"Members");
+ if(!Enum.TryParse<SheetMetalSemanticConstraintKind>(kindToken,true,out var kind))return Fail("sheetmetal-semantic-constraint-kind",$"Require '{path}' uses unsupported Kind '{kindToken ?? "<missing>"}'. Supported: RequiredMembers, EqualSize, EqualPitch, Mirror.");
+ if(members.Count==0)return Fail("sheetmetal-semantic-constraint-members",$"Require '{path}' must name Members.");
+ var missing=members.Where(x=>!allCuts.ContainsKey(x)).ToArray();
+ if(missing.Length>0)return Fail("sheetmetal-semantic-required-member",$"Require '{path}' references missing semantic feature(s): {string.Join(", ",missing)}.");
+ string detail;
+ switch(kind)
+ {
+ case SheetMetalSemanticConstraintKind.RequiredMembers:
+ detail=$"all {members.Count} required members exist";break;
+ case SheetMetalSemanticConstraintKind.EqualSize:
+ var first=allCuts[members[0]];
+ var mismatch=members.Skip(1).Select(x=>allCuts[x]).FirstOrDefault(x=>x.Kind!=first.Kind||!Near(x.Diameter,first.Diameter)||!Near(x.Width,first.Width)||!Near(x.Length,first.Length));
+ if(mismatch is not null)return Fail("sheetmetal-semantic-equal-size",$"Require '{path}' is contradicted by '{mismatch.Name}': feature kind or nominal size differs from '{first.Name}'.");
+ detail=$"{members.Count} members share kind and nominal size";break;
+ case SheetMetalSemanticConstraintKind.EqualPitch:
+ if(members.Count<2)return Fail("sheetmetal-semantic-equal-pitch",$"Require '{path}' needs at least two Members.");
+ var axis=Token(block.Body,"Axis");if(axis is not ("X" or "Y" or "x" or "y"))return Fail("sheetmetal-semantic-equal-pitch",$"Require '{path}' needs Axis: X or Axis: Y.");
+ if(!Scalar(block.Body,"Pitch",out var expectedPitch)||expectedPitch<=0)return Fail("sheetmetal-semantic-equal-pitch",$"Require '{path}' needs positive Pitch.");
+ var coordinates=members.Select(x=>axis.Equals("X",StringComparison.OrdinalIgnoreCase)?allCuts[x].X:allCuts[x].Y).ToArray();
+ for(var i=1;i<coordinates.Length;i++)if(Math.Abs(Math.Abs(coordinates[i]-coordinates[i-1])-expectedPitch)>1e-6)
+ return Fail("sheetmetal-semantic-equal-pitch",$"Require '{path}' declares {expectedPitch:G9} mm pitch, but spacing at member {i} is {Math.Abs(coordinates[i]-coordinates[i-1]):G9} mm.");
+ detail=$"{members.Count} members satisfy {expectedPitch:G9} mm {axis.ToUpperInvariant()} pitch";break;
+ case SheetMetalSemanticConstraintKind.Mirror:
+ if(members.Count!=2)return Fail("sheetmetal-semantic-mirror",$"Require '{path}' needs exactly two Members.");
+ var about=TokenPath(block.Body,"About");
+ if(about is null||!TryAxis(about,regionSizes,datums,out var horizontal,out var value))return Fail("sheetmetal-semantic-mirror",$"Require '{path}' needs About: <Region>.CenterX/CenterY or a named Datum path.");
+ var left=allCuts[members[0]];var right=allCuts[members[1]];var reflected=horizontal?left with { X=2*value-left.X }:left with { Y=2*value-left.Y };
+ if(Math.Abs(reflected.X-right.X)>1e-6||Math.Abs(reflected.Y-right.Y)>1e-6||left.Kind!=right.Kind||!Near(left.Diameter,right.Diameter)||!Near(left.Width,right.Width)||!Near(left.Length,right.Length))
+ return Fail("sheetmetal-semantic-mirror",$"Require '{path}' is contradicted: '{members[1]}' is not the size-preserving mirror of '{members[0]}' about '{about}'.");
+ detail=$"'{members[0]}' and '{members[1]}' mirror about {about}";break;
+ default:throw new InvalidOperationException();
+ }
+ constraints.Add(new(path,kind,members,"Satisfied",detail));
+ }
+
+ return new(true,new(structNames,datums.OrderBy(x=>x.Path,StringComparer.Ordinal).ToArray(),tabs.OrderBy(x=>x.Path,StringComparer.Ordinal).ToArray(),patterns.OrderBy(x=>x.Path,StringComparer.Ordinal).ToArray(),constraints.OrderBy(x=>x.Path,StringComparer.Ordinal).ToArray()),generated,diagnostics);
+
+ SheetMetalSemanticLayoutParseResult Fail(string code,string message)=>new(false,SheetMetalSemanticLayout.Empty,[],[new(code,SheetMetalDiagnosticSeverity.Error,message)]);
+ }
+
+ private static IReadOnlyDictionary<string,(double Width,double Height)> RegionSizes(AuthoredSheetBaseSpec baseSpec,IReadOnlyList<AuthoredSheetFlangeSpec> flanges)
+ {
+ var result=new Dictionary<string,(double Width,double Height)>(StringComparer.OrdinalIgnoreCase){{baseSpec.Name,(baseSpec.Width,baseSpec.Depth)}};
+ var pending=flanges.ToList();var guard=0;
+ while(pending.Count>0&&guard++<=flanges.Count)foreach(var flange in pending.ToArray())
+ {
+ if(!result.TryGetValue(flange.ParentRegion,out var parent))continue;
+ var width=flange.SpanLength??(flange.ParentRegion.Equals(baseSpec.Name,StringComparison.OrdinalIgnoreCase)
+ ? flange.EdgeName is "Front" or "Rear"?baseSpec.Width:baseSpec.Depth
+ : parent.Width);
+ result[flange.Name]=(width,flange.Length);pending.Remove(flange);
+ }
+ return result;
+ }
+
+ private static bool TryPointExpression(string body,string field,string region,IReadOnlyDictionary<string,(double Width,double Height)> sizes,IReadOnlyList<SheetMetalSemanticDatum> datums,out Point2 point,out string reason)
+ {
+ point=default;reason="expected `(xmm, ymm)`, `<Region>.Center`, or a named Datum path, optionally followed by `+ (dxmm, dymm)`";
+ var line=Regex.Match(body,$@"\b{Regex.Escape(field)}\s*:\s*(?<v>[^;]+)\s*;",Rx);if(!line.Success)return false;var value=line.Groups["v"].Value.Trim();
+ if(TupleValue(value,out point))return true;
+ var reference=Regex.Match(value,$@"^(?<path>[A-Za-z_][A-Za-z0-9_.]*)(?:\s*\+\s*(?<offset>\([^)]*\)))?$",Rx);if(!reference.Success)return false;
+ var path=reference.Groups["path"].Value;
+ if(path.EndsWith(".Center",StringComparison.OrdinalIgnoreCase))
+ {
+ var target=path[..^7];if(!target.Equals(region,StringComparison.OrdinalIgnoreCase)||!sizes.TryGetValue(target,out var size)){reason=$"'{path}' is not the center of owning region '{region}'";return false;}
+ point=new(size.Width/2,size.Height/2);
+ }
+ else
+ {
+ var datum=datums.FirstOrDefault(x=>x.Path.Equals(path,StringComparison.Ordinal)||x.Path.EndsWith("."+path,StringComparison.Ordinal));
+ if(datum is null||!datum.Region.Equals(region,StringComparison.OrdinalIgnoreCase)){reason=$"unknown datum '{path}' on region '{region}'";return false;}point=new(datum.X,datum.Y);
+ }
+ if(reference.Groups["offset"].Success){if(!TupleValue(reference.Groups["offset"].Value,out var offset))return false;point=new(point.X+offset.X,point.Y+offset.Y);}return true;
+ }
+
+ private static bool TryAxis(string path,IReadOnlyDictionary<string,(double Width,double Height)> sizes,IReadOnlyList<SheetMetalSemanticDatum> datums,out bool xAxis,out double value)
+ {
+ xAxis=true;value=0;
+ if(path.EndsWith(".CenterX",StringComparison.OrdinalIgnoreCase)){var region=path[..^8];if(!sizes.TryGetValue(region,out var size))return false;value=size.Width/2;return true;}
+ if(path.EndsWith(".CenterY",StringComparison.OrdinalIgnoreCase)){var region=path[..^8];if(!sizes.TryGetValue(region,out var size))return false;xAxis=false;value=size.Height/2;return true;}
+ var datum=datums.FirstOrDefault(x=>x.Path.Equals(path,StringComparison.Ordinal)||x.Path.EndsWith("."+path,StringComparison.Ordinal));if(datum is null)return false;value=datum.X;return true;
+ }
+
+ private static IReadOnlyList<Block> StructBlocks(string source)
+ {
+ var result=new List<Block>();foreach(Match match in Regex.Matches(source,@"\bConcept\s+Struct\s+(?<name>[A-Za-z_][A-Za-z0-9_]*)\s*\{",Rx))
+ {var open=source.IndexOf('{',match.Index);var close=Close(source,open);if(close>open)result.Add(new("Concept Struct",match.Groups["name"].Value,source[(open+1)..close],match.Index,null));}return result;
+ }
+ private static IReadOnlyList<Block> Blocks(string source,string keyword,IReadOnlyList<Block> structs)
+ {
+ var result=new List<Block>();foreach(Match match in Regex.Matches(source,$@"\b{Regex.Escape(keyword)}\s+(?<name>[A-Za-z_][A-Za-z0-9_]*)\s*\{{",Rx))
+ {var open=source.IndexOf('{',match.Index);var close=Close(source,open);if(close<=open)continue;var owner=structs.Where(x=>match.Index>x.Index&&match.Index<x.Index+x.Body.Length+(source.IndexOf('{',x.Index)-x.Index)+2).OrderByDescending(x=>x.Index).FirstOrDefault()?.Name;result.Add(new(keyword,match.Groups["name"].Value,source[(open+1)..close],match.Index,owner));}return result;
+ }
+ private static int Close(string source,int open){var depth=0;for(var i=open;i<source.Length;i++){if(source[i]=='{')depth++;else if(source[i]=='}'&&--depth==0)return i;}return -1;}
+ private static string Path(Block block)=>block.Struct is null?block.Name:$"{block.Struct}.{block.Name}";
+ private static string? Token(string text,string name){var m=Regex.Match(text,$@"\b{Regex.Escape(name)}\s*:\s*(?<v>[A-Za-z_][A-Za-z0-9_]*)\s*;",Rx);return m.Success?m.Groups["v"].Value:null;}
+ private static string? TokenPath(string text,string name){var m=Regex.Match(text,$@"\b{Regex.Escape(name)}\s*:\s*(?<v>[A-Za-z_][A-Za-z0-9_.]*)\s*;",Rx);return m.Success?m.Groups["v"].Value:null;}
+ private static IReadOnlyList<string> List(string text,string name){var m=Regex.Match(text,$@"\b{Regex.Escape(name)}\s*:\s*\[(?<v>[^]]*)\]\s*;",Rx);return m.Success?m.Groups["v"].Value.Split(',',StringSplitOptions.RemoveEmptyEntries|StringSplitOptions.TrimEntries):[];}
+ private static bool Scalar(string text,string name,out double value){var m=Regex.Match(text,$@"\b{Regex.Escape(name)}\s*:\s*(?<v>{Number})\s*mm\s*;",Rx);value=m.Success?double.Parse(m.Groups["v"].Value,CultureInfo.InvariantCulture):0;return m.Success;}
+ private static bool Int(string text,string name,out int value){var m=Regex.Match(text,$@"\b{Regex.Escape(name)}\s*:\s*(?<v>[0-9]+)\s*;",Rx);return int.TryParse(m.Groups["v"].Value,NumberStyles.None,CultureInfo.InvariantCulture,out value);}
+ private static bool Tuple(string text,string name,out Point2 point){var m=Regex.Match(text,$@"\b{Regex.Escape(name)}\s*:\s*(?<v>\([^;]+\))\s*;",Rx);return TupleValue(m.Groups["v"].Value,out point);}
+ private static bool TupleValue(string value,out Point2 point){var m=Regex.Match(value,$@"^\s*\(\s*(?<x>{Number})\s*mm\s*,\s*(?<y>{Number})\s*mm\s*\)\s*$",Rx);point=m.Success?new(double.Parse(m.Groups["x"].Value,CultureInfo.InvariantCulture),double.Parse(m.Groups["y"].Value,CultureInfo.InvariantCulture)):default;return m.Success;}
+ private static bool Near(double? a,double? b)=>a is null&&b is null||a is not null&&b is not null&&Math.Abs(a.Value-b.Value)<=1e-9;
+}
diff --git a/docs/modules/sheet-metal.md b/docs/modules/sheet-metal.md
index 81b990bc..9434302d 100644
--- a/docs/modules/sheet-metal.md
+++ b/docs/modules/sheet-metal.md
@@ -1,6 +1,6 @@
# Sheet Metal Module
-`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.
+`Aetheris.SheetMetal` includes a shared exact planar-contour contract, exact line/arc corner-relief removal on bounded authored cases, stable Sheet Metal Concept Paths, reusable templates, and an M8 bounded semantic-layout pass. Imported STEP recovery remains separate from authored construction.
## Construction architecture
@@ -22,6 +22,10 @@ The bounded kernel publishes line/line, line/arc, and arc/arc intersection; norm
## Authoring and Concept Paths
+M8 permits a `Concept Struct` to declare named `Datum`, regular `Pattern`, and bounded outer-edge `Tab` intent before the `SheetMetal` body. The compiler resolves those declarations into a `SheetMetalSemanticLayout`, validates required/equal-size/equal-pitch/mirror claims, generates stable feature members, and only then lowers exact formed and flat profiles. This is intentionally not a general sketch solver. `Span` and `SpanOffset` on a flange provide reusable partial-edge attachment.
+
+The resolved layout is visible in `aetheris sheetmetal inspect --json`; semantic paths are visible through `aetheris sheetmetal paths`.
+
```firmament
SheetMetal Tray {
Thickness: 1.2mm;
@@ -84,6 +88,8 @@ aetheris sheetmetal compare imported.step reconstructed.firmament
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.
+The [M8 CTC-03 evidence bundle](sheetmetal/artifacts/m8/README.md) records full opening recovery, semantic-layout authoring, independent regeneration, comparison, PMI evidence, generalization, timings, and the remaining outer-contour blocker.
+
## Bounded capability verdict
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/m8/README.md b/docs/modules/sheetmetal/artifacts/m8/README.md
new file mode 100644
index 00000000..142806cc
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m8/README.md
@@ -0,0 +1,48 @@
+# Sheet Metal M8 — CTC-03 intent recovery
+
+## Verdict: Meaningful progression
+
+M8 removes the previous missing-opening blocker. The canonical NIST CTC-03 STEP now recognizes 15 holes, two slots, seven bends, and 15 planar regions. The source-independent Firmament program regenerates the same opening inventory and all 17 opening comparisons pass. It also models the partial-span service flange and its 101.6 x 12.7 mm outer tab.
+
+This is not a full CTC-03 reconstruction. Several source outer-boundary trims remain simplified: wall-end chamfers/steps, the complex front and rear mounting-flange edges, and right-wall attachment cutbacks. Consequently the comparison remains `NeedsReview`, formed surface residuals remain material, and the flat outer contour fails. The isolated next blocker is reusable multi-segment local edge-profile authoring/lowering, not hole recognition.
+
+## Delivered mechanism
+
+The authored compiler now has a bounded semantic-layout pass between parsing and exact profile lowering:
+
+```text
+Concept / Concept Struct
+ -> Datum, Pattern, Tab, Require
+ -> resolved SheetMetalSemanticLayout
+ -> stable generated cut paths + validated constraints
+ -> exact formed profiles and PlanarContour2 flat blank
+```
+
+`Datum` names local workpoints. `Pattern` owns size, count, pitch, and generated member identities. `Tab` extends a bounded partial flange edge. `Require` validates required members and explicit equal-size, equal-pitch, or mirror claims. Pattern resolution also records equal-size and equal-pitch constraints automatically. The CLI exposes the resolved layout under `sheetMetal.semanticLayout` and reports `semanticResolve` timing.
+
+The M8 CTC program resolves three datums, nine patterns, one tab, 17 generated cuts, and 18 admitted pattern constraints. Stable paths include `Ctc03Layout.BaseFastenerPattern[0]` and `Ctc03Layout.ServiceInnerHoles[1]`.
+
+## Evidence map
+
+- [Final source](ctc03-final.firmament)
+- [Feature and missing-feature inventory](ctc03-feature-inventory.md)
+- [Semantic layout and real syntax](ctc03-semantic-layout.md)
+- [Formed and flat comparison](ctc03-comparison.md)
+- [PMI and datum audit](ctc03-pmi-parity.md)
+- [Iteration and LLM friction](ctc03-iteration-journal.md)
+- [Validation, performance, hashes, and code-quality verdict](validation-report.md)
+- [Independent formed STEP](ctc03-formed.step)
+- [Independent flat STEP](ctc03-flat.step)
+- [Independent flat SVG](ctc03-flat.svg)
+
+The non-CTC generalization fixture is [`m8-semantic-panel.firmament`](../../../../../fixtures/FirmamentV2/SheetMetal/m8-semantic-panel.firmament).
+
+## Direct architecture answers
+
+**Can Aetheris fully reconstruct CTC-03 as the actual manufactured part?** No. It now reconstructs the complete recognized bend/opening skeleton and the distinctive service tab, but not every manufactured edge trim.
+
+**Did the semantic sketch reduce reconstruction mistakes?** Yes. Named datums and regular patterns replaced repeated point edits; contradictions are rejected before topology construction; and the final feature comparison reached 17/17 pass without post-lowering feature matching hacks.
+
+**Did it generalize?** Yes, within its bounded scope. The independent semantic-panel fixture uses the same datum/pattern lowering and stable paths, and tests prove deterministic output.
+
+**Largest remaining blocker?** A reusable way to author, constrain, recognize, and lower irregular multi-segment flange-edge profiles while preserving correspondence through bends and flattening. Real vendor parts express tabs, notches, cutbacks, and chamfers as related edge intent; forcing those into raw polygons would recreate the coordinate-dump problem M8 was intended to avoid.
diff --git a/docs/modules/sheetmetal/artifacts/m8/ctc03-comparison.md b/docs/modules/sheetmetal/artifacts/m8/ctc03-comparison.md
new file mode 100644
index 00000000..5235f2a1
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m8/ctc03-comparison.md
@@ -0,0 +1,48 @@
+# CTC-03 formed and flat comparison
+
+Command:
+
+```text
+aetheris sheetmetal compare testdata/step242/nist/CTC/nist_ctc_03_asme1_ap242-e2.stp docs/modules/sheetmetal/artifacts/m8/ctc03-final.firmament --json
+```
+
+## Formed
+
+Overall status is `NeedsReview`.
+
+| Measure | Result |
+|---|---:|
+| Thickness residual | 0.0025400000 mm |
+| Source → intent RMS / p95 / max | 19.4627 / 52.4846 / 56.6946 mm |
+| Intent → source RMS / p95 / max | 6.66049 / 12.7357 / 19.0713 mm |
+| Bend matches | 7/7 Pass |
+| Opening matches | 17/17 Pass |
+
+Bend axis residual is at most 0.002542 mm; bend-axis angle residual is zero; bend-angle and radius residuals are numerical noise; all adjacency checks pass. The large global surface residual is not an unexplained opening error. It is localized to the simplified outer trims enumerated in the feature inventory.
+
+## Flat
+
+| Measure | Result |
+|---|---:|
+| Generated bounds | 404.751790441 x 612.597760706 mm |
+| Width residual | 0.00244728 mm |
+| Height residual | 12.7078196 mm |
+| Outer-contour RMS / p95 / max | 12.3763 / 19.0475 / 19.0475 mm |
+| Inner cuts | 17/17 Pass |
+| Bend-line count delta | 0 |
+| Overlap | none |
+| Generated exact contour | Valid |
+| Source comparison status | Fail |
+
+The generated blank is internally valid, connected, non-self-intersecting, and exact on the authored model. It is not tolerance-equivalent to the historical source outer blank because the remaining edge trims affect overall height and sampled contour positions.
+
+## Independent regeneration and reimport
+
+The final source reads no STEP path or recovered topology identifiers. Tests copy it into an isolated temporary directory before compilation. Generated formed and flat STEP files reimport as enclosed manifold bodies:
+
+| Artifact | Bodies / shells | Faces | Edges | Vertices | Supports |
+|---|---:|---:|---:|---:|---|
+| Formed | 1 / 1 | 99 | 218 | 138 | 70 plane, 29 cylinder |
+| Flat | 1 / 1 | 98 | 288 | 192 | 68 plane, 30 cylinder |
+
+DFM is `Warning`, caused only by the two front mounting holes having 0.7849 mm clearance to the simplified authored rectangle versus a 2.8575 mm bounded policy. Moving the holes would destroy source parity; exact mounting-flange contour support is the correct repair.
diff --git a/docs/modules/sheetmetal/artifacts/m8/ctc03-feature-inventory.md b/docs/modules/sheetmetal/artifacts/m8/ctc03-feature-inventory.md
new file mode 100644
index 00000000..a964c7a3
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m8/ctc03-feature-inventory.md
@@ -0,0 +1,37 @@
+# CTC-03 feature inventory
+
+Inventory is from a fresh CLI recognition of `testdata/step242/nist/CTC/nist_ctc_03_asme1_ap242-e2.stp`, AP242 entity inspection, and planar boundary evidence. `Recovered` means represented in semantic recovery/IR; `regenerated` means emitted from `ctc03-final.firmament` with the source STEP unavailable.
+
+| Feature family | Source | Recovered | Regenerated | Status |
+|---|---:|---:|---:|---|
+| Planar sheet regions | 15 | 15 | 15 | Pass by count/adjacency; some trims simplified |
+| Bends | 7 | 7 | 7 | 7/7 comparison pass |
+| Main-deck Ø15.875 holes | 4 | 4 | 4 | Pass |
+| Main-deck Ø50.8 opening | 1 | 1 | 1 | Pass |
+| Main-deck Ø38.1 opening | 1 | 1 | 1 | Pass |
+| Main-deck 19.05 x 88.9 slots | 2 | 2 | 2 | Pass |
+| Mounting-flange Ø11.1252 holes | 4 | 4 | 4 | Pass |
+| Service-flange Ø27.051 hole | 1 | 1 | 1 | Pass |
+| Service-flange Ø4.7625 holes | 4 | 4 | 4 | Pass |
+| Partial-span 45-degree service flange | 1, span 127 mm | 1 | 1 | Pass by bend/axis; surrounding right-wall trims simplified |
+| Service outer tab | 1, 101.6 x 12.7 mm | 1 | 1 | Present; participates in exact blank |
+| Automatic corner reliefs | four corner transitions | inferred | 4 bounded rectangular removals | Manufacturing interpretation; not source-trim parity |
+| Wall-end chamfers/steps | present on front/rear/left/right contours | boundary evidence | simplified | Missing exact trim parity |
+| Front/rear mounting-flange edge notches and cutbacks | present | boundary evidence | simplified rectangles | Missing exact trim parity |
+| Right-wall service attachment cutbacks | present | boundary evidence | partial-span attachment only | Missing exact trim parity |
+
+## Opening detail
+
+All 17 source opening matches pass. Center residuals are 0.000526–0.001270 mm and size residuals are below `3.57e-10` mm. Four base fasteners use 44.45 mm pitch; front/rear mounting pairs use 203.2 mm pitch; the two deck slots use 63.5 mm pitch; the service small-hole pairs use 38.1 mm pitch.
+
+## Missing-feature audit
+
+Nothing in the recognized opening inventory is absent. The remaining absent geometry is localized to outer boundaries:
+
+- base/wall corner cutbacks and stepped transitions;
+- front and rear wall end bands;
+- the 12–14 segment front/rear mounting-flange boundary shapes;
+- left-wall tapered ends;
+- right-wall chamfers and service-attachment cutbacks.
+
+These differences are explained but not accepted as equivalent. They drive the global formed and flat residuals and prevent a `Complete` verdict.
diff --git a/docs/modules/sheetmetal/artifacts/m8/ctc03-final.firmament b/docs/modules/sheetmetal/artifacts/m8/ctc03-final.firmament
new file mode 100644
index 00000000..6493aa2f
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m8/ctc03-final.firmament
@@ -0,0 +1,123 @@
+// M8 independent reconstruction of NIST CTC-03.
+// Construction reads no STEP, recovery provider, face ID, edge ID, or recovered polygon.
+// Dimensions below are source-derived unless explicitly described as a flattening policy.
+Concept Ctc03ManufacturedIntent {
+ MainDeck: SheetRegion
+ BaseFastenerPattern: SheetPattern
+ VentSlots: SheetPattern
+ RearMountHoles: SheetPattern
+ FrontMountHoles: SheetPattern
+ ServiceHole: SheetPattern
+ ServiceInnerHoles: SheetPattern
+ ServiceOuterHoles: SheetPattern
+ Flat: FlatPattern
+}
+
+Concept Struct Ctc03Layout {
+ // Named local workpoints isolate measured formed coordinates from feature generation.
+ Datum RearMountCenter { On: RearMountingFlange; At: (112.395mm, 25.40254mm); }
+ Datum FrontMountCenter { On: FrontMountingFlange; At: (112.395mm, 24.43226mm); }
+ Datum ServiceHoleCenter { On: AngledServiceFlange; At: (63.5mm, 30.735796052mm); }
+
+ // Source contour: the 127 mm partial flange grows a centered 101.6 x 12.7 mm tab.
+ Tab ServiceConnectorTab {
+ On: AngledServiceFlange.Outer;
+ Center: 63.5mm;
+ Width: 101.6mm;
+ Extension: 12.7mm;
+ }
+
+ // Four source-PMI Ø0.625 in holes at equal 1.75 in pitch.
+ Pattern BaseFastenerPattern {
+ On: MainDeck;
+ Feature: Circle { Diameter: 15.875mm; };
+ Center: MainDeck.Center + (82.55mm, -78.78826mm);
+ Count: 4;
+ Pitch: (0mm, 44.45mm);
+ }
+
+ Pattern LargeOpeningTwoInch {
+ On: MainDeck;
+ Feature: Circle { Diameter: 50.8mm; };
+ Center: MainDeck.Center + (-31.2674mm, 114.68354mm);
+ Count: 1;
+ Pitch: (0mm, 0mm);
+ }
+
+ Pattern LargeOpeningOnePointFiveInch {
+ On: MainDeck;
+ Feature: Circle { Diameter: 38.1mm; };
+ Center: MainDeck.Center + (57.6326mm, 89.28354mm);
+ Count: 1;
+ Pitch: (0mm, 0mm);
+ }
+
+ Pattern VentSlots {
+ On: MainDeck;
+ Feature: Slot { Length: 19.05mm; Width: 88.9mm; };
+ Center: MainDeck.Center + (-37.6174mm, -75.71486mm);
+ Count: 2;
+ Pitch: (63.5mm, 0mm);
+ }
+
+ Pattern RearMountHoles {
+ On: RearMountingFlange;
+ Feature: Circle { Diameter: 11.1252mm; };
+ Center: RearMountCenter;
+ Count: 2;
+ Pitch: (203.2mm, 0mm);
+ }
+
+ Pattern FrontMountHoles {
+ On: FrontMountingFlange;
+ Feature: Circle { Diameter: 11.1252mm; };
+ Center: FrontMountCenter;
+ Count: 2;
+ Pitch: (203.2mm, 0mm);
+ }
+
+ Pattern ServiceHole {
+ On: AngledServiceFlange;
+ Feature: Circle { Diameter: 27.051mm; };
+ Center: ServiceHoleCenter;
+ Count: 1;
+ Pitch: (0mm, 0mm);
+ }
+
+ Pattern ServiceInnerHoles {
+ On: AngledServiceFlange;
+ Feature: Circle { Diameter: 4.7625mm; };
+ Center: AngledServiceFlange.Center + (0mm, -7.491203948mm);
+ Count: 2;
+ Pitch: (38.1mm, 0mm);
+ }
+
+ Pattern ServiceOuterHoles {
+ On: AngledServiceFlange;
+ Feature: Circle { Diameter: 4.7625mm; };
+ Center: AngledServiceFlange.Center + (0mm, 24.258796052mm);
+ Count: 2;
+ Pitch: (38.1mm, 0mm);
+ }
+}
+
+SheetMetal Ctc03 : Ctc03ManufacturedIntent {
+ Intent: Reconstructed;
+ Thickness: 1.905mm;
+ KFactor: 0.5;
+ Material: "0.075 in nominal sheet";
+
+ Base MainDeck {
+ Profile: Rectangle { Width: 241.3mm; Height: 368.3mm; };
+ Origin: (-241.3mm, 58.08726mm, 76.2mm);
+ }
+
+ Flange FrontWall { From: MainDeck.Front; Height: 61.59254mm; Angle: 90deg; Radius: 6.35mm; Direction: Down; Relief: Auto; }
+ Flange RearWall { From: MainDeck.Rear; Height: 61.59254mm; Angle: 90deg; Radius: 6.35mm; Direction: Down; Relief: Auto; }
+ Flange LeftWall { From: MainDeck.Left; Height: 44.45mm; Angle: 90deg; Radius: 6.35mm; Direction: Up; Relief: Auto; }
+ Flange RightWall { From: MainDeck.Right; Height: 29.11094mm; Angle: 90deg; Radius: 6.35mm; Direction: Up; Relief: Auto; }
+
+ Flange FrontMountingFlange { From: FrontWall.Outer; Length: 30.77972mm; Angle: 90deg; Radius: 6.35mm; Direction: Up; }
+ Flange RearMountingFlange { From: RearWall.Outer; Length: 44.45mm; Angle: 90deg; Radius: 6.35mm; Direction: Up; }
+ Flange AngledServiceFlange { From: RightWall.Outer; Length: 48.514mm; Span: 127mm; SpanOffset: 2.3876mm; Angle: 45deg; Radius: 6.35mm; Direction: Down; }
+}
diff --git a/docs/modules/sheetmetal/artifacts/m8/ctc03-flat.step b/docs/modules/sheetmetal/artifacts/m8/ctc03-flat.step
new file mode 100644
index 00000000..c1d58050
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m8/ctc03-flat.step
@@ -0,0 +1,3396 @@
+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,248.351340352839,0));
+#7=VERTEX_POINT($,#6);
+#8=CARTESIAN_POINT($,(402.051790441049,261.051340352839,0));
+#9=VERTEX_POINT($,#8);
+#10=CARTESIAN_POINT($,(402.051790441049,248.351340352839,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($,(414.751790441049,261.051340352839,-0));
+#17=VERTEX_POINT($,#16);
+#18=CARTESIAN_POINT($,(402.051790441049,261.051340352839,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($,(414.751790441049,362.651340352839,-0));
+#25=VERTEX_POINT($,#24);
+#26=CARTESIAN_POINT($,(414.751790441049,261.051340352839,-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($,(402.051790441049,362.651340352839,0));
+#33=VERTEX_POINT($,#32);
+#34=CARTESIAN_POINT($,(414.751790441049,362.651340352839,-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($,(402.051790441049,375.351340352839,-0));
+#41=VERTEX_POINT($,#40);
+#42=CARTESIAN_POINT($,(402.051790441049,362.651340352839,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($,(353.537790441049,375.351340352839,0));
+#49=VERTEX_POINT($,#48);
+#50=CARTESIAN_POINT($,(402.051790441049,375.351340352839,-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($,(347.802420352839,375.351340352839,0));
+#57=VERTEX_POINT($,#56);
+#58=CARTESIAN_POINT($,(353.537790441049,375.351340352839,0));
+#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($,(347.802420352839,485.358740352839,-0));
+#65=VERTEX_POINT($,#64);
+#66=CARTESIAN_POINT($,(347.802420352839,375.351340352839,0));
+#67=DIRECTION($,(0,1,0));
+#68=VECTOR($,#67,1);
+#69=LINE($,#66,#68);
+#70=EDGE_CURVE($,#57,#65,#69,.T.);
+#71=ORIENTED_EDGE($,$,$,#70,.T.);
+#72=CARTESIAN_POINT($,(318.691480352839,485.358740352839,0));
+#73=VERTEX_POINT($,#72);
+#74=CARTESIAN_POINT($,(347.802420352839,485.358740352839,-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($,(307.22074017642,485.35874035284,0));
+#81=VERTEX_POINT($,#80);
+#82=CARTESIAN_POINT($,(318.691480352839,485.358740352839,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($,(307.22074017642,492.266701934679,-0));
+#89=VERTEX_POINT($,#88);
+#90=CARTESIAN_POINT($,(307.22074017642,485.35874035284,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($,(302.057092906805,487.103054665064,0));
+#97=VERTEX_POINT($,#96);
+#98=CARTESIAN_POINT($,(307.22074017642,492.266701934679,-0));
+#99=DIRECTION($,(-0.707106781186548,-0.707106781186548,0));
+#100=VECTOR($,#99,1);
+#101=LINE($,#98,#100);
+#102=EDGE_CURVE($,#89,#97,#101,.T.);
+#103=ORIENTED_EDGE($,$,$,#102,.T.);
+#104=CARTESIAN_POINT($,(300.710054488645,488.450093083225,0));
+#105=VERTEX_POINT($,#104);
+#106=CARTESIAN_POINT($,(302.057092906805,487.103054665064,0));
+#107=DIRECTION($,(-0.707106781186533,0.707106781186562,0));
+#108=VECTOR($,#107,1);
+#109=LINE($,#106,#108);
+#110=EDGE_CURVE($,#97,#105,#109,.T.);
+#111=ORIENTED_EDGE($,$,$,#110,.T.);
+#112=CARTESIAN_POINT($,(305.873701758259,493.613740352839,-0));
+#113=VERTEX_POINT($,#112);
+#114=CARTESIAN_POINT($,(300.710054488645,488.450093083225,0));
+#115=DIRECTION($,(0.707106781186544,0.707106781186551,0));
+#116=VECTOR($,#115,1);
+#117=LINE($,#114,#116);
+#118=EDGE_CURVE($,#105,#113,#117,.T.);
+#119=ORIENTED_EDGE($,$,$,#118,.T.);
+#120=CARTESIAN_POINT($,(298.96574017642,493.613740352839,0));
+#121=VERTEX_POINT($,#120);
+#122=CARTESIAN_POINT($,(305.873701758259,493.613740352839,-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($,(298.96574017642,505.084480529259,0));
+#129=VERTEX_POINT($,#128);
+#130=CARTESIAN_POINT($,(298.96574017642,493.613740352839,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($,(298.96574017642,566.677020529259,0));
+#137=VERTEX_POINT($,#136);
+#138=CARTESIAN_POINT($,(298.96574017642,505.084480529259,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($,(298.96574017642,578.147760705679,0));
+#145=VERTEX_POINT($,#144);
+#146=CARTESIAN_POINT($,(298.96574017642,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($,(298.96574017642,622.597760705679,-0));
+#153=VERTEX_POINT($,#152);
+#154=CARTESIAN_POINT($,(298.96574017642,578.147760705679,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($,(74.1757401764197,622.597760705679,-0));
+#161=VERTEX_POINT($,#160);
+#162=CARTESIAN_POINT($,(298.96574017642,622.597760705679,-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($,(74.1757401764197,578.147760705679,0));
+#169=VERTEX_POINT($,#168);
+#170=CARTESIAN_POINT($,(74.1757401764197,622.597760705679,-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($,(74.1757401764197,566.677020529259,0));
+#177=VERTEX_POINT($,#176);
+#178=CARTESIAN_POINT($,(74.1757401764197,578.147760705679,0));
+#179=DIRECTION($,(0,-1,0));
+#180=VECTOR($,#179,1);
+#181=LINE($,#178,#180);
+#182=EDGE_CURVE($,#169,#177,#181,.T.);
+#183=ORIENTED_EDGE($,$,$,#182,.T.);
+#184=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,0));
+#185=VERTEX_POINT($,#184);
+#186=CARTESIAN_POINT($,(74.1757401764197,566.677020529259,0));
+#187=DIRECTION($,(0,-1,0));
+#188=VECTOR($,#187,1);
+#189=LINE($,#186,#188);
+#190=EDGE_CURVE($,#177,#185,#189,.T.);
+#191=ORIENTED_EDGE($,$,$,#190,.T.);
+#192=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,0));
+#193=VERTEX_POINT($,#192);
+#194=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,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($,(67.2677785945802,493.613740352839,-0));
+#201=VERTEX_POINT($,#200);
+#202=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,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($,(72.4314258641949,488.450093083225,0));
+#209=VERTEX_POINT($,#208);
+#210=CARTESIAN_POINT($,(67.2677785945802,493.613740352839,-0));
+#211=DIRECTION($,(0.707106781186545,-0.70710678118655,0));
+#212=VECTOR($,#211,1);
+#213=LINE($,#210,#212);
+#214=EDGE_CURVE($,#201,#209,#213,.T.);
+#215=ORIENTED_EDGE($,$,$,#214,.T.);
+#216=CARTESIAN_POINT($,(71.0843874460345,487.103054665064,0));
+#217=VERTEX_POINT($,#216);
+#218=CARTESIAN_POINT($,(72.4314258641949,488.450093083225,0));
+#219=DIRECTION($,(-0.707106781186536,-0.707106781186559,0));
+#220=VECTOR($,#219,1);
+#221=LINE($,#218,#220);
+#222=EDGE_CURVE($,#209,#217,#221,.T.);
+#223=ORIENTED_EDGE($,$,$,#222,.T.);
+#224=CARTESIAN_POINT($,(65.9207401764197,492.266701934679,-0));
+#225=VERTEX_POINT($,#224);
+#226=CARTESIAN_POINT($,(71.0843874460345,487.103054665064,0));
+#227=DIRECTION($,(-0.707106781186545,0.70710678118655,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,485.35874035284,0));
+#233=VERTEX_POINT($,#232);
+#234=CARTESIAN_POINT($,(65.9207401764197,492.266701934679,-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($,(54.45,485.35874035284,0));
+#241=VERTEX_POINT($,#240);
+#242=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,0));
+#243=DIRECTION($,(-1,0,0));
+#244=VECTOR($,#243,1);
+#245=LINE($,#242,#244);
+#246=EDGE_CURVE($,#233,#241,#245,.T.);
+#247=ORIENTED_EDGE($,$,$,#246,.T.);
+#248=CARTESIAN_POINT($,(10,485.35874035284,-0));
+#249=VERTEX_POINT($,#248);
+#250=CARTESIAN_POINT($,(54.45,485.35874035284,0));
+#251=DIRECTION($,(-1,0,0));
+#252=VECTOR($,#251,1);
+#253=LINE($,#250,#252);
+#254=EDGE_CURVE($,#241,#249,#253,.T.);
+#255=ORIENTED_EDGE($,$,$,#254,.T.);
+#256=CARTESIAN_POINT($,(10,133.568740352839,-0));
+#257=VERTEX_POINT($,#256);
+#258=CARTESIAN_POINT($,(10,485.35874035284,-0));
+#259=DIRECTION($,(0,-1,0));
+#260=VECTOR($,#259,1);
+#261=LINE($,#258,#260);
+#262=EDGE_CURVE($,#249,#257,#261,.T.);
+#263=ORIENTED_EDGE($,$,$,#262,.T.);
+#264=CARTESIAN_POINT($,(54.45,133.568740352839,0));
+#265=VERTEX_POINT($,#264);
+#266=CARTESIAN_POINT($,(10,133.568740352839,-0));
+#267=DIRECTION($,(1,0,0));
+#268=VECTOR($,#267,1);
+#269=LINE($,#266,#268);
+#270=EDGE_CURVE($,#257,#265,#269,.T.);
+#271=ORIENTED_EDGE($,$,$,#270,.T.);
+#272=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,0));
+#273=VERTEX_POINT($,#272);
+#274=CARTESIAN_POINT($,(54.45,133.568740352839,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($,(65.9207401764197,126.660778771,-0));
+#281=VERTEX_POINT($,#280);
+#282=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,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($,(71.0843874460345,131.824426040615,0));
+#289=VERTEX_POINT($,#288);
+#290=CARTESIAN_POINT($,(65.9207401764197,126.660778771,-0));
+#291=DIRECTION($,(0.707106781186548,0.707106781186548,0));
+#292=VECTOR($,#291,1);
+#293=LINE($,#290,#292);
+#294=EDGE_CURVE($,#281,#289,#293,.T.);
+#295=ORIENTED_EDGE($,$,$,#294,.T.);
+#296=CARTESIAN_POINT($,(72.4314258641949,130.477387622454,0));
+#297=VERTEX_POINT($,#296);
+#298=CARTESIAN_POINT($,(71.0843874460345,131.824426040615,0));
+#299=DIRECTION($,(0.707106781186551,-0.707106781186544,0));
+#300=VECTOR($,#299,1);
+#301=LINE($,#298,#300);
+#302=EDGE_CURVE($,#289,#297,#301,.T.);
+#303=ORIENTED_EDGE($,$,$,#302,.T.);
+#304=CARTESIAN_POINT($,(67.2677785945801,125.313740352839,-0));
+#305=VERTEX_POINT($,#304);
+#306=CARTESIAN_POINT($,(72.4314258641949,130.477387622454,0));
+#307=DIRECTION($,(-0.707106781186548,-0.707106781186547,0));
+#308=VECTOR($,#307,1);
+#309=LINE($,#306,#308);
+#310=EDGE_CURVE($,#297,#305,#309,.T.);
+#311=ORIENTED_EDGE($,$,$,#310,.T.);
+#312=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,0));
+#313=VERTEX_POINT($,#312);
+#314=CARTESIAN_POINT($,(67.2677785945801,125.313740352839,-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($,(74.1757401764197,113.84300017642,0));
+#321=VERTEX_POINT($,#320);
+#322=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,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($,(74.1757401764197,52.2504601764197,0));
+#329=VERTEX_POINT($,#328);
+#330=CARTESIAN_POINT($,(74.1757401764197,113.84300017642,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($,(74.1757401764197,40.77972,0));
+#337=VERTEX_POINT($,#336);
+#338=CARTESIAN_POINT($,(74.1757401764197,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($,(74.1757401764197,10,-0));
+#345=VERTEX_POINT($,#344);
+#346=CARTESIAN_POINT($,(74.1757401764197,40.77972,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($,(298.96574017642,10,-0));
+#353=VERTEX_POINT($,#352);
+#354=CARTESIAN_POINT($,(74.1757401764197,10,-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($,(298.96574017642,40.77972,0));
+#361=VERTEX_POINT($,#360);
+#362=CARTESIAN_POINT($,(298.96574017642,10,-0));
+#363=DIRECTION($,(0,1,0));
+#364=VECTOR($,#363,1);
+#365=LINE($,#362,#364);
+#366=EDGE_CURVE($,#353,#361,#365,.T.);
+#367=ORIENTED_EDGE($,$,$,#366,.T.);
+#368=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,0));
+#369=VERTEX_POINT($,#368);
+#370=CARTESIAN_POINT($,(298.96574017642,40.77972,0));
+#371=DIRECTION($,(0,1,0));
+#372=VECTOR($,#371,1);
+#373=LINE($,#370,#372);
+#374=EDGE_CURVE($,#361,#369,#373,.T.);
+#375=ORIENTED_EDGE($,$,$,#374,.T.);
+#376=CARTESIAN_POINT($,(298.96574017642,113.84300017642,0));
+#377=VERTEX_POINT($,#376);
+#378=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,0));
+#379=DIRECTION($,(0,1,0));
+#380=VECTOR($,#379,1);
+#381=LINE($,#378,#380);
+#382=EDGE_CURVE($,#369,#377,#381,.T.);
+#383=ORIENTED_EDGE($,$,$,#382,.T.);
+#384=CARTESIAN_POINT($,(298.96574017642,125.313740352839,0));
+#385=VERTEX_POINT($,#384);
+#386=CARTESIAN_POINT($,(298.96574017642,113.84300017642,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($,(305.873701758259,125.313740352839,-0));
+#393=VERTEX_POINT($,#392);
+#394=CARTESIAN_POINT($,(298.96574017642,125.313740352839,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($,(300.710054488645,130.477387622454,0));
+#401=VERTEX_POINT($,#400);
+#402=CARTESIAN_POINT($,(305.873701758259,125.313740352839,-0));
+#403=DIRECTION($,(-0.707106781186546,0.707106781186549,0));
+#404=VECTOR($,#403,1);
+#405=LINE($,#402,#404);
+#406=EDGE_CURVE($,#393,#401,#405,.T.);
+#407=ORIENTED_EDGE($,$,$,#406,.T.);
+#408=CARTESIAN_POINT($,(302.057092906805,131.824426040615,0));
+#409=VERTEX_POINT($,#408);
+#410=CARTESIAN_POINT($,(300.710054488645,130.477387622454,0));
+#411=DIRECTION($,(0.707106781186548,0.707106781186548,0));
+#412=VECTOR($,#411,1);
+#413=LINE($,#410,#412);
+#414=EDGE_CURVE($,#401,#409,#413,.T.);
+#415=ORIENTED_EDGE($,$,$,#414,.T.);
+#416=CARTESIAN_POINT($,(307.22074017642,126.660778771,-0));
+#417=VERTEX_POINT($,#416);
+#418=CARTESIAN_POINT($,(302.057092906805,131.824426040615,0));
+#419=DIRECTION($,(0.707106781186549,-0.707106781186546,0));
+#420=VECTOR($,#419,1);
+#421=LINE($,#418,#420);
+#422=EDGE_CURVE($,#409,#417,#421,.T.);
+#423=ORIENTED_EDGE($,$,$,#422,.T.);
+#424=CARTESIAN_POINT($,(307.22074017642,133.568740352839,0));
+#425=VERTEX_POINT($,#424);
+#426=CARTESIAN_POINT($,(307.22074017642,126.660778771,-0));
+#427=DIRECTION($,(0,1,0));
+#428=VECTOR($,#427,1);
+#429=LINE($,#426,#428);
+#430=EDGE_CURVE($,#417,#425,#429,.T.);
+#431=ORIENTED_EDGE($,$,$,#430,.T.);
+#432=CARTESIAN_POINT($,(318.691480352839,133.568740352839,0));
+#433=VERTEX_POINT($,#432);
+#434=CARTESIAN_POINT($,(307.22074017642,133.568740352839,0));
+#435=DIRECTION($,(1,0,0));
+#436=VECTOR($,#435,1);
+#437=LINE($,#434,#436);
+#438=EDGE_CURVE($,#425,#433,#437,.T.);
+#439=ORIENTED_EDGE($,$,$,#438,.T.);
+#440=CARTESIAN_POINT($,(347.802420352839,133.568740352839,-0));
+#441=VERTEX_POINT($,#440);
+#442=CARTESIAN_POINT($,(318.691480352839,133.568740352839,0));
+#443=DIRECTION($,(1,0,0));
+#444=VECTOR($,#443,1);
+#445=LINE($,#442,#444);
+#446=EDGE_CURVE($,#433,#441,#445,.T.);
+#447=ORIENTED_EDGE($,$,$,#446,.T.);
+#448=CARTESIAN_POINT($,(347.802420352839,248.351340352839,0));
+#449=VERTEX_POINT($,#448);
+#450=CARTESIAN_POINT($,(347.802420352839,133.568740352839,-0));
+#451=DIRECTION($,(0,1,0));
+#452=VECTOR($,#451,1);
+#453=LINE($,#450,#452);
+#454=EDGE_CURVE($,#441,#449,#453,.T.);
+#455=ORIENTED_EDGE($,$,$,#454,.T.);
+#456=CARTESIAN_POINT($,(353.537790441049,248.351340352839,0));
+#457=VERTEX_POINT($,#456);
+#458=CARTESIAN_POINT($,(347.802420352839,248.351340352839,0));
+#459=DIRECTION($,(1,0,0));
+#460=VECTOR($,#459,1);
+#461=LINE($,#458,#460);
+#462=EDGE_CURVE($,#449,#457,#461,.T.);
+#463=ORIENTED_EDGE($,$,$,#462,.T.);
+#464=CARTESIAN_POINT($,(353.537790441049,248.351340352839,0));
+#465=DIRECTION($,(1,0,0));
+#466=VECTOR($,#465,1);
+#467=LINE($,#464,#466);
+#468=EDGE_CURVE($,#457,#7,#467,.T.);
+#469=ORIENTED_EDGE($,$,$,#468,.T.);
+#470=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,#423,#431,#439,#447,#455,#463,#469));
+#471=FACE_OUTER_BOUND('',#470,.T.);
+#472=CARTESIAN_POINT($,(277.05824017642,164.000480352839,0));
+#473=VERTEX_POINT($,#472);
+#474=CARTESIAN_POINT($,(261.18324017642,164.000480352839,0));
+#475=VERTEX_POINT($,#474);
+#476=CARTESIAN_POINT($,(269.12074017642,164.000480352839,0));
+#477=DIRECTION($,(0,0,1));
+#478=DIRECTION($,(1,0,0));
+#479=AXIS2_PLACEMENT_3D($,#476,#477,#478);
+#480=CIRCLE($,#479,7.9375);
+#481=TRIMMED_CURVE($,#480,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#482=EDGE_CURVE($,#473,#475,#481,.T.);
+#483=ORIENTED_EDGE($,$,$,#482,.F.);
+#484=CARTESIAN_POINT($,(269.12074017642,164.000480352839,0));
+#485=DIRECTION($,(0,0,1));
+#486=DIRECTION($,(1,0,0));
+#487=AXIS2_PLACEMENT_3D($,#484,#485,#486);
+#488=CIRCLE($,#487,7.9375);
+#489=TRIMMED_CURVE($,#488,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#490=EDGE_CURVE($,#475,#473,#489,.T.);
+#491=ORIENTED_EDGE($,$,$,#490,.F.);
+#492=EDGE_LOOP($,(#483,#491));
+#493=FACE_BOUND('',#492,.T.);
+#494=CARTESIAN_POINT($,(277.05824017642,208.450480352839,0));
+#495=VERTEX_POINT($,#494);
+#496=CARTESIAN_POINT($,(261.18324017642,208.450480352839,0));
+#497=VERTEX_POINT($,#496);
+#498=CARTESIAN_POINT($,(269.12074017642,208.450480352839,0));
+#499=DIRECTION($,(0,0,1));
+#500=DIRECTION($,(1,0,0));
+#501=AXIS2_PLACEMENT_3D($,#498,#499,#500);
+#502=CIRCLE($,#501,7.9375);
+#503=TRIMMED_CURVE($,#502,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#504=EDGE_CURVE($,#495,#497,#503,.T.);
+#505=ORIENTED_EDGE($,$,$,#504,.F.);
+#506=CARTESIAN_POINT($,(269.12074017642,208.450480352839,0));
+#507=DIRECTION($,(0,0,1));
+#508=DIRECTION($,(1,0,0));
+#509=AXIS2_PLACEMENT_3D($,#506,#507,#508);
+#510=CIRCLE($,#509,7.9375);
+#511=TRIMMED_CURVE($,#510,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#512=EDGE_CURVE($,#497,#495,#511,.T.);
+#513=ORIENTED_EDGE($,$,$,#512,.F.);
+#514=EDGE_LOOP($,(#505,#513));
+#515=FACE_BOUND('',#514,.T.);
+#516=CARTESIAN_POINT($,(277.05824017642,252.90048035284,0));
+#517=VERTEX_POINT($,#516);
+#518=CARTESIAN_POINT($,(261.18324017642,252.90048035284,0));
+#519=VERTEX_POINT($,#518);
+#520=CARTESIAN_POINT($,(269.12074017642,252.90048035284,0));
+#521=DIRECTION($,(0,0,1));
+#522=DIRECTION($,(1,0,0));
+#523=AXIS2_PLACEMENT_3D($,#520,#521,#522);
+#524=CIRCLE($,#523,7.9375);
+#525=TRIMMED_CURVE($,#524,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#526=EDGE_CURVE($,#517,#519,#525,.T.);
+#527=ORIENTED_EDGE($,$,$,#526,.F.);
+#528=CARTESIAN_POINT($,(269.12074017642,252.90048035284,0));
+#529=DIRECTION($,(0,0,1));
+#530=DIRECTION($,(1,0,0));
+#531=AXIS2_PLACEMENT_3D($,#528,#529,#530);
+#532=CIRCLE($,#531,7.9375);
+#533=TRIMMED_CURVE($,#532,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#534=EDGE_CURVE($,#519,#517,#533,.T.);
+#535=ORIENTED_EDGE($,$,$,#534,.F.);
+#536=EDGE_LOOP($,(#527,#535));
+#537=FACE_BOUND('',#536,.T.);
+#538=CARTESIAN_POINT($,(277.05824017642,297.350480352839,0));
+#539=VERTEX_POINT($,#538);
+#540=CARTESIAN_POINT($,(261.18324017642,297.350480352839,0));
+#541=VERTEX_POINT($,#540);
+#542=CARTESIAN_POINT($,(269.12074017642,297.350480352839,0));
+#543=DIRECTION($,(0,0,1));
+#544=DIRECTION($,(1,0,0));
+#545=AXIS2_PLACEMENT_3D($,#542,#543,#544);
+#546=CIRCLE($,#545,7.9375);
+#547=TRIMMED_CURVE($,#546,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#548=EDGE_CURVE($,#539,#541,#547,.T.);
+#549=ORIENTED_EDGE($,$,$,#548,.F.);
+#550=CARTESIAN_POINT($,(269.12074017642,297.350480352839,0));
+#551=DIRECTION($,(0,0,1));
+#552=DIRECTION($,(1,0,0));
+#553=AXIS2_PLACEMENT_3D($,#550,#551,#552);
+#554=CIRCLE($,#553,7.9375);
+#555=TRIMMED_CURVE($,#554,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#556=EDGE_CURVE($,#541,#539,#555,.T.);
+#557=ORIENTED_EDGE($,$,$,#556,.F.);
+#558=EDGE_LOOP($,(#549,#557));
+#559=FACE_BOUND('',#558,.T.);
+#560=CARTESIAN_POINT($,(90.5333401764198,16.34746,0));
+#561=VERTEX_POINT($,#560);
+#562=CARTESIAN_POINT($,(79.4081401764197,16.34746,0));
+#563=VERTEX_POINT($,#562);
+#564=CARTESIAN_POINT($,(84.9707401764198,16.34746,0));
+#565=DIRECTION($,(0,0,1));
+#566=DIRECTION($,(1,0,0));
+#567=AXIS2_PLACEMENT_3D($,#564,#565,#566);
+#568=CIRCLE($,#567,5.5626);
+#569=TRIMMED_CURVE($,#568,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#570=EDGE_CURVE($,#561,#563,#569,.T.);
+#571=ORIENTED_EDGE($,$,$,#570,.F.);
+#572=CARTESIAN_POINT($,(84.9707401764198,16.34746,0));
+#573=DIRECTION($,(0,0,1));
+#574=DIRECTION($,(1,0,0));
+#575=AXIS2_PLACEMENT_3D($,#572,#573,#574);
+#576=CIRCLE($,#575,5.5626);
+#577=TRIMMED_CURVE($,#576,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#578=EDGE_CURVE($,#563,#561,#577,.T.);
+#579=ORIENTED_EDGE($,$,$,#578,.F.);
+#580=EDGE_LOOP($,(#571,#579));
+#581=FACE_BOUND('',#580,.T.);
+#582=CARTESIAN_POINT($,(293.73334017642,16.34746,0));
+#583=VERTEX_POINT($,#582);
+#584=CARTESIAN_POINT($,(282.60814017642,16.34746,0));
+#585=VERTEX_POINT($,#584);
+#586=CARTESIAN_POINT($,(288.17074017642,16.34746,0));
+#587=DIRECTION($,(0,0,1));
+#588=DIRECTION($,(1,0,0));
+#589=AXIS2_PLACEMENT_3D($,#586,#587,#588);
+#590=CIRCLE($,#589,5.5626);
+#591=TRIMMED_CURVE($,#590,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#592=EDGE_CURVE($,#583,#585,#591,.T.);
+#593=ORIENTED_EDGE($,$,$,#592,.F.);
+#594=CARTESIAN_POINT($,(288.17074017642,16.34746,0));
+#595=DIRECTION($,(0,0,1));
+#596=DIRECTION($,(1,0,0));
+#597=AXIS2_PLACEMENT_3D($,#594,#595,#596);
+#598=CIRCLE($,#597,5.5626);
+#599=TRIMMED_CURVE($,#598,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#600=EDGE_CURVE($,#585,#583,#599,.T.);
+#601=ORIENTED_EDGE($,$,$,#600,.F.);
+#602=EDGE_LOOP($,(#593,#601));
+#603=FACE_BOUND('',#602,.T.);
+#604=CARTESIAN_POINT($,(263.25334017642,398.747280352839,0));
+#605=VERTEX_POINT($,#604);
+#606=CARTESIAN_POINT($,(225.15334017642,398.747280352839,0));
+#607=VERTEX_POINT($,#606);
+#608=CARTESIAN_POINT($,(244.20334017642,398.747280352839,0));
+#609=DIRECTION($,(0,0,1));
+#610=DIRECTION($,(1,0,0));
+#611=AXIS2_PLACEMENT_3D($,#608,#609,#610);
+#612=CIRCLE($,#611,19.05);
+#613=TRIMMED_CURVE($,#612,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#614=EDGE_CURVE($,#605,#607,#613,.T.);
+#615=ORIENTED_EDGE($,$,$,#614,.F.);
+#616=CARTESIAN_POINT($,(244.20334017642,398.747280352839,0));
+#617=DIRECTION($,(0,0,1));
+#618=DIRECTION($,(1,0,0));
+#619=AXIS2_PLACEMENT_3D($,#616,#617,#618);
+#620=CIRCLE($,#619,19.05);
+#621=TRIMMED_CURVE($,#620,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#622=EDGE_CURVE($,#607,#605,#621,.T.);
+#623=ORIENTED_EDGE($,$,$,#622,.F.);
+#624=EDGE_LOOP($,(#615,#623));
+#625=FACE_BOUND('',#624,.T.);
+#626=CARTESIAN_POINT($,(180.70334017642,424.147280352839,0));
+#627=VERTEX_POINT($,#626);
+#628=CARTESIAN_POINT($,(129.90334017642,424.147280352839,0));
+#629=VERTEX_POINT($,#628);
+#630=CARTESIAN_POINT($,(155.30334017642,424.147280352839,0));
+#631=DIRECTION($,(0,0,1));
+#632=DIRECTION($,(1,0,0));
+#633=AXIS2_PLACEMENT_3D($,#630,#631,#632);
+#634=CIRCLE($,#633,25.4);
+#635=TRIMMED_CURVE($,#634,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#636=EDGE_CURVE($,#627,#629,#635,.T.);
+#637=ORIENTED_EDGE($,$,$,#636,.F.);
+#638=CARTESIAN_POINT($,(155.30334017642,424.147280352839,0));
+#639=DIRECTION($,(0,0,1));
+#640=DIRECTION($,(1,0,0));
+#641=AXIS2_PLACEMENT_3D($,#638,#639,#640);
+#642=CIRCLE($,#641,25.4);
+#643=TRIMMED_CURVE($,#642,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#644=EDGE_CURVE($,#629,#627,#643,.T.);
+#645=ORIENTED_EDGE($,$,$,#644,.F.);
+#646=EDGE_LOOP($,(#637,#645));
+#647=FACE_BOUND('',#646,.T.);
+#648=CARTESIAN_POINT($,(293.73334017642,603.550300705679,0));
+#649=VERTEX_POINT($,#648);
+#650=CARTESIAN_POINT($,(282.60814017642,603.550300705679,0));
+#651=VERTEX_POINT($,#650);
+#652=CARTESIAN_POINT($,(288.17074017642,603.550300705679,0));
+#653=DIRECTION($,(0,0,1));
+#654=DIRECTION($,(1,0,0));
+#655=AXIS2_PLACEMENT_3D($,#652,#653,#654);
+#656=CIRCLE($,#655,5.5626);
+#657=TRIMMED_CURVE($,#656,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#658=EDGE_CURVE($,#649,#651,#657,.T.);
+#659=ORIENTED_EDGE($,$,$,#658,.F.);
+#660=CARTESIAN_POINT($,(288.17074017642,603.550300705679,0));
+#661=DIRECTION($,(0,0,1));
+#662=DIRECTION($,(1,0,0));
+#663=AXIS2_PLACEMENT_3D($,#660,#661,#662);
+#664=CIRCLE($,#663,5.5626);
+#665=TRIMMED_CURVE($,#664,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#666=EDGE_CURVE($,#651,#649,#665,.T.);
+#667=ORIENTED_EDGE($,$,$,#666,.F.);
+#668=EDGE_LOOP($,(#659,#667));
+#669=FACE_BOUND('',#668,.T.);
+#670=CARTESIAN_POINT($,(90.5333401764198,603.550300705679,0));
+#671=VERTEX_POINT($,#670);
+#672=CARTESIAN_POINT($,(79.4081401764197,603.550300705679,0));
+#673=VERTEX_POINT($,#672);
+#674=CARTESIAN_POINT($,(84.9707401764198,603.550300705679,0));
+#675=DIRECTION($,(0,0,1));
+#676=DIRECTION($,(1,0,0));
+#677=AXIS2_PLACEMENT_3D($,#674,#675,#676);
+#678=CIRCLE($,#677,5.5626);
+#679=TRIMMED_CURVE($,#678,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#680=EDGE_CURVE($,#671,#673,#679,.T.);
+#681=ORIENTED_EDGE($,$,$,#680,.F.);
+#682=CARTESIAN_POINT($,(84.9707401764198,603.550300705679,0));
+#683=DIRECTION($,(0,0,1));
+#684=DIRECTION($,(1,0,0));
+#685=AXIS2_PLACEMENT_3D($,#682,#683,#684);
+#686=CIRCLE($,#685,5.5626);
+#687=TRIMMED_CURVE($,#686,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#688=EDGE_CURVE($,#673,#671,#687,.T.);
+#689=ORIENTED_EDGE($,$,$,#688,.F.);
+#690=EDGE_LOOP($,(#681,#689));
+#691=FACE_BOUND('',#690,.T.);
+#692=CARTESIAN_POINT($,(397.799086493049,311.851340352839,0));
+#693=VERTEX_POINT($,#692);
+#694=CARTESIAN_POINT($,(370.748086493049,311.851340352839,0));
+#695=VERTEX_POINT($,#694);
+#696=CARTESIAN_POINT($,(384.273586493049,311.851340352839,0));
+#697=DIRECTION($,(0,0,1));
+#698=DIRECTION($,(1,0,0));
+#699=AXIS2_PLACEMENT_3D($,#696,#697,#698);
+#700=CIRCLE($,#699,13.5255);
+#701=TRIMMED_CURVE($,#700,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#702=EDGE_CURVE($,#693,#695,#701,.T.);
+#703=ORIENTED_EDGE($,$,$,#702,.F.);
+#704=CARTESIAN_POINT($,(384.273586493049,311.851340352839,0));
+#705=DIRECTION($,(0,0,1));
+#706=DIRECTION($,(1,0,0));
+#707=AXIS2_PLACEMENT_3D($,#704,#705,#706);
+#708=CIRCLE($,#707,13.5255);
+#709=TRIMMED_CURVE($,#708,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#710=EDGE_CURVE($,#695,#693,#709,.T.);
+#711=ORIENTED_EDGE($,$,$,#710,.F.);
+#712=EDGE_LOOP($,(#703,#711));
+#713=FACE_BOUND('',#712,.T.);
+#714=CARTESIAN_POINT($,(372.684836493049,292.801340352839,0));
+#715=VERTEX_POINT($,#714);
+#716=CARTESIAN_POINT($,(367.922336493049,292.801340352839,0));
+#717=VERTEX_POINT($,#716);
+#718=CARTESIAN_POINT($,(370.303586493049,292.801340352839,0));
+#719=DIRECTION($,(0,0,1));
+#720=DIRECTION($,(1,0,0));
+#721=AXIS2_PLACEMENT_3D($,#718,#719,#720);
+#722=CIRCLE($,#721,2.38125);
+#723=TRIMMED_CURVE($,#722,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#724=EDGE_CURVE($,#715,#717,#723,.T.);
+#725=ORIENTED_EDGE($,$,$,#724,.F.);
+#726=CARTESIAN_POINT($,(370.303586493049,292.801340352839,0));
+#727=DIRECTION($,(0,0,1));
+#728=DIRECTION($,(1,0,0));
+#729=AXIS2_PLACEMENT_3D($,#726,#727,#728);
+#730=CIRCLE($,#729,2.38125);
+#731=TRIMMED_CURVE($,#730,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#732=EDGE_CURVE($,#717,#715,#731,.T.);
+#733=ORIENTED_EDGE($,$,$,#732,.F.);
+#734=EDGE_LOOP($,(#725,#733));
+#735=FACE_BOUND('',#734,.T.);
+#736=CARTESIAN_POINT($,(372.684836493049,330.901340352839,0));
+#737=VERTEX_POINT($,#736);
+#738=CARTESIAN_POINT($,(367.922336493049,330.901340352839,0));
+#739=VERTEX_POINT($,#738);
+#740=CARTESIAN_POINT($,(370.303586493049,330.901340352839,0));
+#741=DIRECTION($,(0,0,1));
+#742=DIRECTION($,(1,0,0));
+#743=AXIS2_PLACEMENT_3D($,#740,#741,#742);
+#744=CIRCLE($,#743,2.38125);
+#745=TRIMMED_CURVE($,#744,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#746=EDGE_CURVE($,#737,#739,#745,.T.);
+#747=ORIENTED_EDGE($,$,$,#746,.F.);
+#748=CARTESIAN_POINT($,(370.303586493049,330.901340352839,0));
+#749=DIRECTION($,(0,0,1));
+#750=DIRECTION($,(1,0,0));
+#751=AXIS2_PLACEMENT_3D($,#748,#749,#750);
+#752=CIRCLE($,#751,2.38125);
+#753=TRIMMED_CURVE($,#752,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#754=EDGE_CURVE($,#739,#737,#753,.T.);
+#755=ORIENTED_EDGE($,$,$,#754,.F.);
+#756=EDGE_LOOP($,(#747,#755));
+#757=FACE_BOUND('',#756,.T.);
+#758=CARTESIAN_POINT($,(404.434836493049,292.801340352839,0));
+#759=VERTEX_POINT($,#758);
+#760=CARTESIAN_POINT($,(399.672336493049,292.801340352839,0));
+#761=VERTEX_POINT($,#760);
+#762=CARTESIAN_POINT($,(402.053586493049,292.801340352839,0));
+#763=DIRECTION($,(0,0,1));
+#764=DIRECTION($,(1,0,0));
+#765=AXIS2_PLACEMENT_3D($,#762,#763,#764);
+#766=CIRCLE($,#765,2.38125);
+#767=TRIMMED_CURVE($,#766,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#768=EDGE_CURVE($,#759,#761,#767,.T.);
+#769=ORIENTED_EDGE($,$,$,#768,.F.);
+#770=CARTESIAN_POINT($,(402.053586493049,292.801340352839,0));
+#771=DIRECTION($,(0,0,1));
+#772=DIRECTION($,(1,0,0));
+#773=AXIS2_PLACEMENT_3D($,#770,#771,#772);
+#774=CIRCLE($,#773,2.38125);
+#775=TRIMMED_CURVE($,#774,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#776=EDGE_CURVE($,#761,#759,#775,.T.);
+#777=ORIENTED_EDGE($,$,$,#776,.F.);
+#778=EDGE_LOOP($,(#769,#777));
+#779=FACE_BOUND('',#778,.T.);
+#780=CARTESIAN_POINT($,(404.434836493049,330.901340352839,0));
+#781=VERTEX_POINT($,#780);
+#782=CARTESIAN_POINT($,(399.672336493049,330.901340352839,0));
+#783=VERTEX_POINT($,#782);
+#784=CARTESIAN_POINT($,(402.053586493049,330.901340352839,0));
+#785=DIRECTION($,(0,0,1));
+#786=DIRECTION($,(1,0,0));
+#787=AXIS2_PLACEMENT_3D($,#784,#785,#786);
+#788=CIRCLE($,#787,2.38125);
+#789=TRIMMED_CURVE($,#788,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#790=EDGE_CURVE($,#781,#783,#789,.T.);
+#791=ORIENTED_EDGE($,$,$,#790,.F.);
+#792=CARTESIAN_POINT($,(402.053586493049,330.901340352839,0));
+#793=DIRECTION($,(0,0,1));
+#794=DIRECTION($,(1,0,0));
+#795=AXIS2_PLACEMENT_3D($,#792,#793,#794);
+#796=CIRCLE($,#795,2.38125);
+#797=TRIMMED_CURVE($,#796,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#798=EDGE_CURVE($,#783,#781,#797,.T.);
+#799=ORIENTED_EDGE($,$,$,#798,.F.);
+#800=EDGE_LOOP($,(#791,#799));
+#801=FACE_BOUND('',#800,.T.);
+#802=CARTESIAN_POINT($,(107.67834017642,189.298880352839,-0));
+#803=VERTEX_POINT($,#802);
+#804=CARTESIAN_POINT($,(126.72834017642,189.298880352839,0));
+#805=VERTEX_POINT($,#804);
+#806=CARTESIAN_POINT($,(107.67834017642,189.298880352839,-0));
+#807=DIRECTION($,(1,0,0));
+#808=VECTOR($,#807,1);
+#809=LINE($,#806,#808);
+#810=EDGE_CURVE($,#803,#805,#809,.T.);
+#811=ORIENTED_EDGE($,$,$,#810,.F.);
+#812=CARTESIAN_POINT($,(107.67834017642,278.198880352839,-0));
+#813=VERTEX_POINT($,#812);
+#814=CARTESIAN_POINT($,(107.67834017642,278.198880352839,-0));
+#815=DIRECTION($,(0,-1,0));
+#816=VECTOR($,#815,1);
+#817=LINE($,#814,#816);
+#818=EDGE_CURVE($,#813,#803,#817,.T.);
+#819=ORIENTED_EDGE($,$,$,#818,.F.);
+#820=CARTESIAN_POINT($,(126.72834017642,278.198880352839,-0));
+#821=VERTEX_POINT($,#820);
+#822=CARTESIAN_POINT($,(126.72834017642,278.198880352839,-0));
+#823=DIRECTION($,(-1,0,0));
+#824=VECTOR($,#823,1);
+#825=LINE($,#822,#824);
+#826=EDGE_CURVE($,#821,#813,#825,.T.);
+#827=ORIENTED_EDGE($,$,$,#826,.F.);
+#828=CARTESIAN_POINT($,(126.72834017642,189.298880352839,0));
+#829=DIRECTION($,(0,1,0));
+#830=VECTOR($,#829,1);
+#831=LINE($,#828,#830);
+#832=EDGE_CURVE($,#805,#821,#831,.T.);
+#833=ORIENTED_EDGE($,$,$,#832,.F.);
+#834=EDGE_LOOP($,(#811,#819,#827,#833));
+#835=FACE_BOUND('',#834,.T.);
+#836=CARTESIAN_POINT($,(171.17834017642,189.298880352839,-0));
+#837=VERTEX_POINT($,#836);
+#838=CARTESIAN_POINT($,(190.22834017642,189.298880352839,0));
+#839=VERTEX_POINT($,#838);
+#840=CARTESIAN_POINT($,(171.17834017642,189.298880352839,-0));
+#841=DIRECTION($,(1,0,0));
+#842=VECTOR($,#841,1);
+#843=LINE($,#840,#842);
+#844=EDGE_CURVE($,#837,#839,#843,.T.);
+#845=ORIENTED_EDGE($,$,$,#844,.F.);
+#846=CARTESIAN_POINT($,(171.17834017642,278.198880352839,-0));
+#847=VERTEX_POINT($,#846);
+#848=CARTESIAN_POINT($,(171.17834017642,278.198880352839,-0));
+#849=DIRECTION($,(0,-1,0));
+#850=VECTOR($,#849,1);
+#851=LINE($,#848,#850);
+#852=EDGE_CURVE($,#847,#837,#851,.T.);
+#853=ORIENTED_EDGE($,$,$,#852,.F.);
+#854=CARTESIAN_POINT($,(190.22834017642,278.198880352839,-0));
+#855=VERTEX_POINT($,#854);
+#856=CARTESIAN_POINT($,(190.22834017642,278.198880352839,-0));
+#857=DIRECTION($,(-1,0,0));
+#858=VECTOR($,#857,1);
+#859=LINE($,#856,#858);
+#860=EDGE_CURVE($,#855,#847,#859,.T.);
+#861=ORIENTED_EDGE($,$,$,#860,.F.);
+#862=CARTESIAN_POINT($,(190.22834017642,189.298880352839,0));
+#863=DIRECTION($,(0,1,0));
+#864=VECTOR($,#863,1);
+#865=LINE($,#862,#864);
+#866=EDGE_CURVE($,#839,#855,#865,.T.);
+#867=ORIENTED_EDGE($,$,$,#866,.F.);
+#868=EDGE_LOOP($,(#845,#853,#861,#867));
+#869=FACE_BOUND('',#868,.T.);
+#870=ADVANCED_FACE('',(#471,#493,#515,#537,#559,#581,#603,#625,#647,#669,#691,#713,#735,#757,#779,#801,#835,#869),#5,.T.);
+#871=CARTESIAN_POINT($,(0,0,1.905));
+#872=DIRECTION($,(0,0,1));
+#873=DIRECTION($,(1,0,0));
+#874=AXIS2_PLACEMENT_3D($,#871,#872,#873);
+#875=PLANE($,#874);
+#876=CARTESIAN_POINT($,(402.051790441049,248.351340352839,1.905));
+#877=VERTEX_POINT($,#876);
+#878=CARTESIAN_POINT($,(402.051790441049,261.051340352839,1.905));
+#879=VERTEX_POINT($,#878);
+#880=CARTESIAN_POINT($,(402.051790441049,248.351340352839,1.905));
+#881=DIRECTION($,(0,1,0));
+#882=VECTOR($,#881,1);
+#883=LINE($,#880,#882);
+#884=EDGE_CURVE($,#877,#879,#883,.T.);
+#885=ORIENTED_EDGE($,$,$,#884,.T.);
+#886=CARTESIAN_POINT($,(414.751790441049,261.051340352839,1.905));
+#887=VERTEX_POINT($,#886);
+#888=CARTESIAN_POINT($,(402.051790441049,261.051340352839,1.905));
+#889=DIRECTION($,(1,0,0));
+#890=VECTOR($,#889,1);
+#891=LINE($,#888,#890);
+#892=EDGE_CURVE($,#879,#887,#891,.T.);
+#893=ORIENTED_EDGE($,$,$,#892,.T.);
+#894=CARTESIAN_POINT($,(414.751790441049,362.651340352839,1.905));
+#895=VERTEX_POINT($,#894);
+#896=CARTESIAN_POINT($,(414.751790441049,261.051340352839,1.905));
+#897=DIRECTION($,(0,1,0));
+#898=VECTOR($,#897,1);
+#899=LINE($,#896,#898);
+#900=EDGE_CURVE($,#887,#895,#899,.T.);
+#901=ORIENTED_EDGE($,$,$,#900,.T.);
+#902=CARTESIAN_POINT($,(402.051790441049,362.651340352839,1.905));
+#903=VERTEX_POINT($,#902);
+#904=CARTESIAN_POINT($,(414.751790441049,362.651340352839,1.905));
+#905=DIRECTION($,(-1,0,0));
+#906=VECTOR($,#905,1);
+#907=LINE($,#904,#906);
+#908=EDGE_CURVE($,#895,#903,#907,.T.);
+#909=ORIENTED_EDGE($,$,$,#908,.T.);
+#910=CARTESIAN_POINT($,(402.051790441049,375.351340352839,1.905));
+#911=VERTEX_POINT($,#910);
+#912=CARTESIAN_POINT($,(402.051790441049,362.651340352839,1.905));
+#913=DIRECTION($,(0,1,0));
+#914=VECTOR($,#913,1);
+#915=LINE($,#912,#914);
+#916=EDGE_CURVE($,#903,#911,#915,.T.);
+#917=ORIENTED_EDGE($,$,$,#916,.T.);
+#918=CARTESIAN_POINT($,(353.537790441049,375.351340352839,1.905));
+#919=VERTEX_POINT($,#918);
+#920=CARTESIAN_POINT($,(402.051790441049,375.351340352839,1.905));
+#921=DIRECTION($,(-1,0,0));
+#922=VECTOR($,#921,1);
+#923=LINE($,#920,#922);
+#924=EDGE_CURVE($,#911,#919,#923,.T.);
+#925=ORIENTED_EDGE($,$,$,#924,.T.);
+#926=CARTESIAN_POINT($,(347.802420352839,375.351340352839,1.905));
+#927=VERTEX_POINT($,#926);
+#928=CARTESIAN_POINT($,(353.537790441049,375.351340352839,1.905));
+#929=DIRECTION($,(-1,0,0));
+#930=VECTOR($,#929,1);
+#931=LINE($,#928,#930);
+#932=EDGE_CURVE($,#919,#927,#931,.T.);
+#933=ORIENTED_EDGE($,$,$,#932,.T.);
+#934=CARTESIAN_POINT($,(347.802420352839,485.358740352839,1.905));
+#935=VERTEX_POINT($,#934);
+#936=CARTESIAN_POINT($,(347.802420352839,375.351340352839,1.905));
+#937=DIRECTION($,(0,1,0));
+#938=VECTOR($,#937,1);
+#939=LINE($,#936,#938);
+#940=EDGE_CURVE($,#927,#935,#939,.T.);
+#941=ORIENTED_EDGE($,$,$,#940,.T.);
+#942=CARTESIAN_POINT($,(318.691480352839,485.358740352839,1.905));
+#943=VERTEX_POINT($,#942);
+#944=CARTESIAN_POINT($,(347.802420352839,485.358740352839,1.905));
+#945=DIRECTION($,(-1,0,0));
+#946=VECTOR($,#945,1);
+#947=LINE($,#944,#946);
+#948=EDGE_CURVE($,#935,#943,#947,.T.);
+#949=ORIENTED_EDGE($,$,$,#948,.T.);
+#950=CARTESIAN_POINT($,(307.22074017642,485.35874035284,1.905));
+#951=VERTEX_POINT($,#950);
+#952=CARTESIAN_POINT($,(318.691480352839,485.358740352839,1.905));
+#953=DIRECTION($,(-1,0,0));
+#954=VECTOR($,#953,1);
+#955=LINE($,#952,#954);
+#956=EDGE_CURVE($,#943,#951,#955,.T.);
+#957=ORIENTED_EDGE($,$,$,#956,.T.);
+#958=CARTESIAN_POINT($,(307.22074017642,492.266701934679,1.905));
+#959=VERTEX_POINT($,#958);
+#960=CARTESIAN_POINT($,(307.22074017642,485.35874035284,1.905));
+#961=DIRECTION($,(0,1,0));
+#962=VECTOR($,#961,1);
+#963=LINE($,#960,#962);
+#964=EDGE_CURVE($,#951,#959,#963,.T.);
+#965=ORIENTED_EDGE($,$,$,#964,.T.);
+#966=CARTESIAN_POINT($,(302.057092906805,487.103054665064,1.905));
+#967=VERTEX_POINT($,#966);
+#968=CARTESIAN_POINT($,(307.22074017642,492.266701934679,1.905));
+#969=DIRECTION($,(-0.707106781186548,-0.707106781186548,0));
+#970=VECTOR($,#969,1);
+#971=LINE($,#968,#970);
+#972=EDGE_CURVE($,#959,#967,#971,.T.);
+#973=ORIENTED_EDGE($,$,$,#972,.T.);
+#974=CARTESIAN_POINT($,(300.710054488645,488.450093083225,1.905));
+#975=VERTEX_POINT($,#974);
+#976=CARTESIAN_POINT($,(302.057092906805,487.103054665064,1.905));
+#977=DIRECTION($,(-0.707106781186533,0.707106781186562,0));
+#978=VECTOR($,#977,1);
+#979=LINE($,#976,#978);
+#980=EDGE_CURVE($,#967,#975,#979,.T.);
+#981=ORIENTED_EDGE($,$,$,#980,.T.);
+#982=CARTESIAN_POINT($,(305.873701758259,493.613740352839,1.905));
+#983=VERTEX_POINT($,#982);
+#984=CARTESIAN_POINT($,(300.710054488645,488.450093083225,1.905));
+#985=DIRECTION($,(0.707106781186544,0.707106781186551,0));
+#986=VECTOR($,#985,1);
+#987=LINE($,#984,#986);
+#988=EDGE_CURVE($,#975,#983,#987,.T.);
+#989=ORIENTED_EDGE($,$,$,#988,.T.);
+#990=CARTESIAN_POINT($,(298.96574017642,493.613740352839,1.905));
+#991=VERTEX_POINT($,#990);
+#992=CARTESIAN_POINT($,(305.873701758259,493.613740352839,1.905));
+#993=DIRECTION($,(-1,0,0));
+#994=VECTOR($,#993,1);
+#995=LINE($,#992,#994);
+#996=EDGE_CURVE($,#983,#991,#995,.T.);
+#997=ORIENTED_EDGE($,$,$,#996,.T.);
+#998=CARTESIAN_POINT($,(298.96574017642,505.084480529259,1.905));
+#999=VERTEX_POINT($,#998);
+#1000=CARTESIAN_POINT($,(298.96574017642,493.613740352839,1.905));
+#1001=DIRECTION($,(0,1,0));
+#1002=VECTOR($,#1001,1);
+#1003=LINE($,#1000,#1002);
+#1004=EDGE_CURVE($,#991,#999,#1003,.T.);
+#1005=ORIENTED_EDGE($,$,$,#1004,.T.);
+#1006=CARTESIAN_POINT($,(298.96574017642,566.677020529259,1.905));
+#1007=VERTEX_POINT($,#1006);
+#1008=CARTESIAN_POINT($,(298.96574017642,505.084480529259,1.905));
+#1009=DIRECTION($,(0,1,0));
+#1010=VECTOR($,#1009,1);
+#1011=LINE($,#1008,#1010);
+#1012=EDGE_CURVE($,#999,#1007,#1011,.T.);
+#1013=ORIENTED_EDGE($,$,$,#1012,.T.);
+#1014=CARTESIAN_POINT($,(298.96574017642,578.147760705679,1.905));
+#1015=VERTEX_POINT($,#1014);
+#1016=CARTESIAN_POINT($,(298.96574017642,566.677020529259,1.905));
+#1017=DIRECTION($,(0,1,0));
+#1018=VECTOR($,#1017,1);
+#1019=LINE($,#1016,#1018);
+#1020=EDGE_CURVE($,#1007,#1015,#1019,.T.);
+#1021=ORIENTED_EDGE($,$,$,#1020,.T.);
+#1022=CARTESIAN_POINT($,(298.96574017642,622.597760705679,1.905));
+#1023=VERTEX_POINT($,#1022);
+#1024=CARTESIAN_POINT($,(298.96574017642,578.147760705679,1.905));
+#1025=DIRECTION($,(0,1,0));
+#1026=VECTOR($,#1025,1);
+#1027=LINE($,#1024,#1026);
+#1028=EDGE_CURVE($,#1015,#1023,#1027,.T.);
+#1029=ORIENTED_EDGE($,$,$,#1028,.T.);
+#1030=CARTESIAN_POINT($,(74.1757401764197,622.597760705679,1.905));
+#1031=VERTEX_POINT($,#1030);
+#1032=CARTESIAN_POINT($,(298.96574017642,622.597760705679,1.905));
+#1033=DIRECTION($,(-1,0,0));
+#1034=VECTOR($,#1033,1);
+#1035=LINE($,#1032,#1034);
+#1036=EDGE_CURVE($,#1023,#1031,#1035,.T.);
+#1037=ORIENTED_EDGE($,$,$,#1036,.T.);
+#1038=CARTESIAN_POINT($,(74.1757401764197,578.147760705679,1.905));
+#1039=VERTEX_POINT($,#1038);
+#1040=CARTESIAN_POINT($,(74.1757401764197,622.597760705679,1.905));
+#1041=DIRECTION($,(0,-1,0));
+#1042=VECTOR($,#1041,1);
+#1043=LINE($,#1040,#1042);
+#1044=EDGE_CURVE($,#1031,#1039,#1043,.T.);
+#1045=ORIENTED_EDGE($,$,$,#1044,.T.);
+#1046=CARTESIAN_POINT($,(74.1757401764197,566.677020529259,1.905));
+#1047=VERTEX_POINT($,#1046);
+#1048=CARTESIAN_POINT($,(74.1757401764197,578.147760705679,1.905));
+#1049=DIRECTION($,(0,-1,0));
+#1050=VECTOR($,#1049,1);
+#1051=LINE($,#1048,#1050);
+#1052=EDGE_CURVE($,#1039,#1047,#1051,.T.);
+#1053=ORIENTED_EDGE($,$,$,#1052,.T.);
+#1054=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,1.905));
+#1055=VERTEX_POINT($,#1054);
+#1056=CARTESIAN_POINT($,(74.1757401764197,566.677020529259,1.905));
+#1057=DIRECTION($,(0,-1,0));
+#1058=VECTOR($,#1057,1);
+#1059=LINE($,#1056,#1058);
+#1060=EDGE_CURVE($,#1047,#1055,#1059,.T.);
+#1061=ORIENTED_EDGE($,$,$,#1060,.T.);
+#1062=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,1.905));
+#1063=VERTEX_POINT($,#1062);
+#1064=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,1.905));
+#1065=DIRECTION($,(0,-1,0));
+#1066=VECTOR($,#1065,1);
+#1067=LINE($,#1064,#1066);
+#1068=EDGE_CURVE($,#1055,#1063,#1067,.T.);
+#1069=ORIENTED_EDGE($,$,$,#1068,.T.);
+#1070=CARTESIAN_POINT($,(67.2677785945802,493.613740352839,1.905));
+#1071=VERTEX_POINT($,#1070);
+#1072=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,1.905));
+#1073=DIRECTION($,(-1,0,0));
+#1074=VECTOR($,#1073,1);
+#1075=LINE($,#1072,#1074);
+#1076=EDGE_CURVE($,#1063,#1071,#1075,.T.);
+#1077=ORIENTED_EDGE($,$,$,#1076,.T.);
+#1078=CARTESIAN_POINT($,(72.4314258641949,488.450093083225,1.905));
+#1079=VERTEX_POINT($,#1078);
+#1080=CARTESIAN_POINT($,(67.2677785945802,493.613740352839,1.905));
+#1081=DIRECTION($,(0.707106781186545,-0.70710678118655,0));
+#1082=VECTOR($,#1081,1);
+#1083=LINE($,#1080,#1082);
+#1084=EDGE_CURVE($,#1071,#1079,#1083,.T.);
+#1085=ORIENTED_EDGE($,$,$,#1084,.T.);
+#1086=CARTESIAN_POINT($,(71.0843874460345,487.103054665064,1.905));
+#1087=VERTEX_POINT($,#1086);
+#1088=CARTESIAN_POINT($,(72.4314258641949,488.450093083225,1.905));
+#1089=DIRECTION($,(-0.707106781186536,-0.707106781186559,0));
+#1090=VECTOR($,#1089,1);
+#1091=LINE($,#1088,#1090);
+#1092=EDGE_CURVE($,#1079,#1087,#1091,.T.);
+#1093=ORIENTED_EDGE($,$,$,#1092,.T.);
+#1094=CARTESIAN_POINT($,(65.9207401764197,492.266701934679,1.905));
+#1095=VERTEX_POINT($,#1094);
+#1096=CARTESIAN_POINT($,(71.0843874460345,487.103054665064,1.905));
+#1097=DIRECTION($,(-0.707106781186545,0.70710678118655,0));
+#1098=VECTOR($,#1097,1);
+#1099=LINE($,#1096,#1098);
+#1100=EDGE_CURVE($,#1087,#1095,#1099,.T.);
+#1101=ORIENTED_EDGE($,$,$,#1100,.T.);
+#1102=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,1.905));
+#1103=VERTEX_POINT($,#1102);
+#1104=CARTESIAN_POINT($,(65.9207401764197,492.266701934679,1.905));
+#1105=DIRECTION($,(0,-1,0));
+#1106=VECTOR($,#1105,1);
+#1107=LINE($,#1104,#1106);
+#1108=EDGE_CURVE($,#1095,#1103,#1107,.T.);
+#1109=ORIENTED_EDGE($,$,$,#1108,.T.);
+#1110=CARTESIAN_POINT($,(54.45,485.35874035284,1.905));
+#1111=VERTEX_POINT($,#1110);
+#1112=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,1.905));
+#1113=DIRECTION($,(-1,0,0));
+#1114=VECTOR($,#1113,1);
+#1115=LINE($,#1112,#1114);
+#1116=EDGE_CURVE($,#1103,#1111,#1115,.T.);
+#1117=ORIENTED_EDGE($,$,$,#1116,.T.);
+#1118=CARTESIAN_POINT($,(10,485.35874035284,1.905));
+#1119=VERTEX_POINT($,#1118);
+#1120=CARTESIAN_POINT($,(54.45,485.35874035284,1.905));
+#1121=DIRECTION($,(-1,0,0));
+#1122=VECTOR($,#1121,1);
+#1123=LINE($,#1120,#1122);
+#1124=EDGE_CURVE($,#1111,#1119,#1123,.T.);
+#1125=ORIENTED_EDGE($,$,$,#1124,.T.);
+#1126=CARTESIAN_POINT($,(10,133.568740352839,1.905));
+#1127=VERTEX_POINT($,#1126);
+#1128=CARTESIAN_POINT($,(10,485.35874035284,1.905));
+#1129=DIRECTION($,(0,-1,0));
+#1130=VECTOR($,#1129,1);
+#1131=LINE($,#1128,#1130);
+#1132=EDGE_CURVE($,#1119,#1127,#1131,.T.);
+#1133=ORIENTED_EDGE($,$,$,#1132,.T.);
+#1134=CARTESIAN_POINT($,(54.45,133.568740352839,1.905));
+#1135=VERTEX_POINT($,#1134);
+#1136=CARTESIAN_POINT($,(10,133.568740352839,1.905));
+#1137=DIRECTION($,(1,0,0));
+#1138=VECTOR($,#1137,1);
+#1139=LINE($,#1136,#1138);
+#1140=EDGE_CURVE($,#1127,#1135,#1139,.T.);
+#1141=ORIENTED_EDGE($,$,$,#1140,.T.);
+#1142=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,1.905));
+#1143=VERTEX_POINT($,#1142);
+#1144=CARTESIAN_POINT($,(54.45,133.568740352839,1.905));
+#1145=DIRECTION($,(1,0,0));
+#1146=VECTOR($,#1145,1);
+#1147=LINE($,#1144,#1146);
+#1148=EDGE_CURVE($,#1135,#1143,#1147,.T.);
+#1149=ORIENTED_EDGE($,$,$,#1148,.T.);
+#1150=CARTESIAN_POINT($,(65.9207401764197,126.660778771,1.905));
+#1151=VERTEX_POINT($,#1150);
+#1152=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,1.905));
+#1153=DIRECTION($,(0,-1,0));
+#1154=VECTOR($,#1153,1);
+#1155=LINE($,#1152,#1154);
+#1156=EDGE_CURVE($,#1143,#1151,#1155,.T.);
+#1157=ORIENTED_EDGE($,$,$,#1156,.T.);
+#1158=CARTESIAN_POINT($,(71.0843874460345,131.824426040615,1.905));
+#1159=VERTEX_POINT($,#1158);
+#1160=CARTESIAN_POINT($,(65.9207401764197,126.660778771,1.905));
+#1161=DIRECTION($,(0.707106781186548,0.707106781186548,0));
+#1162=VECTOR($,#1161,1);
+#1163=LINE($,#1160,#1162);
+#1164=EDGE_CURVE($,#1151,#1159,#1163,.T.);
+#1165=ORIENTED_EDGE($,$,$,#1164,.T.);
+#1166=CARTESIAN_POINT($,(72.4314258641949,130.477387622454,1.905));
+#1167=VERTEX_POINT($,#1166);
+#1168=CARTESIAN_POINT($,(71.0843874460345,131.824426040615,1.905));
+#1169=DIRECTION($,(0.707106781186551,-0.707106781186544,0));
+#1170=VECTOR($,#1169,1);
+#1171=LINE($,#1168,#1170);
+#1172=EDGE_CURVE($,#1159,#1167,#1171,.T.);
+#1173=ORIENTED_EDGE($,$,$,#1172,.T.);
+#1174=CARTESIAN_POINT($,(67.2677785945801,125.313740352839,1.905));
+#1175=VERTEX_POINT($,#1174);
+#1176=CARTESIAN_POINT($,(72.4314258641949,130.477387622454,1.905));
+#1177=DIRECTION($,(-0.707106781186548,-0.707106781186547,0));
+#1178=VECTOR($,#1177,1);
+#1179=LINE($,#1176,#1178);
+#1180=EDGE_CURVE($,#1167,#1175,#1179,.T.);
+#1181=ORIENTED_EDGE($,$,$,#1180,.T.);
+#1182=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,1.905));
+#1183=VERTEX_POINT($,#1182);
+#1184=CARTESIAN_POINT($,(67.2677785945801,125.313740352839,1.905));
+#1185=DIRECTION($,(1,0,0));
+#1186=VECTOR($,#1185,1);
+#1187=LINE($,#1184,#1186);
+#1188=EDGE_CURVE($,#1175,#1183,#1187,.T.);
+#1189=ORIENTED_EDGE($,$,$,#1188,.T.);
+#1190=CARTESIAN_POINT($,(74.1757401764197,113.84300017642,1.905));
+#1191=VERTEX_POINT($,#1190);
+#1192=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,1.905));
+#1193=DIRECTION($,(0,-1,0));
+#1194=VECTOR($,#1193,1);
+#1195=LINE($,#1192,#1194);
+#1196=EDGE_CURVE($,#1183,#1191,#1195,.T.);
+#1197=ORIENTED_EDGE($,$,$,#1196,.T.);
+#1198=CARTESIAN_POINT($,(74.1757401764197,52.2504601764197,1.905));
+#1199=VERTEX_POINT($,#1198);
+#1200=CARTESIAN_POINT($,(74.1757401764197,113.84300017642,1.905));
+#1201=DIRECTION($,(0,-1,0));
+#1202=VECTOR($,#1201,1);
+#1203=LINE($,#1200,#1202);
+#1204=EDGE_CURVE($,#1191,#1199,#1203,.T.);
+#1205=ORIENTED_EDGE($,$,$,#1204,.T.);
+#1206=CARTESIAN_POINT($,(74.1757401764197,40.77972,1.905));
+#1207=VERTEX_POINT($,#1206);
+#1208=CARTESIAN_POINT($,(74.1757401764197,52.2504601764197,1.905));
+#1209=DIRECTION($,(0,-1,0));
+#1210=VECTOR($,#1209,1);
+#1211=LINE($,#1208,#1210);
+#1212=EDGE_CURVE($,#1199,#1207,#1211,.T.);
+#1213=ORIENTED_EDGE($,$,$,#1212,.T.);
+#1214=CARTESIAN_POINT($,(74.1757401764197,10,1.905));
+#1215=VERTEX_POINT($,#1214);
+#1216=CARTESIAN_POINT($,(74.1757401764197,40.77972,1.905));
+#1217=DIRECTION($,(0,-1,0));
+#1218=VECTOR($,#1217,1);
+#1219=LINE($,#1216,#1218);
+#1220=EDGE_CURVE($,#1207,#1215,#1219,.T.);
+#1221=ORIENTED_EDGE($,$,$,#1220,.T.);
+#1222=CARTESIAN_POINT($,(298.96574017642,10,1.905));
+#1223=VERTEX_POINT($,#1222);
+#1224=CARTESIAN_POINT($,(74.1757401764197,10,1.905));
+#1225=DIRECTION($,(1,0,0));
+#1226=VECTOR($,#1225,1);
+#1227=LINE($,#1224,#1226);
+#1228=EDGE_CURVE($,#1215,#1223,#1227,.T.);
+#1229=ORIENTED_EDGE($,$,$,#1228,.T.);
+#1230=CARTESIAN_POINT($,(298.96574017642,40.77972,1.905));
+#1231=VERTEX_POINT($,#1230);
+#1232=CARTESIAN_POINT($,(298.96574017642,10,1.905));
+#1233=DIRECTION($,(0,1,0));
+#1234=VECTOR($,#1233,1);
+#1235=LINE($,#1232,#1234);
+#1236=EDGE_CURVE($,#1223,#1231,#1235,.T.);
+#1237=ORIENTED_EDGE($,$,$,#1236,.T.);
+#1238=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,1.905));
+#1239=VERTEX_POINT($,#1238);
+#1240=CARTESIAN_POINT($,(298.96574017642,40.77972,1.905));
+#1241=DIRECTION($,(0,1,0));
+#1242=VECTOR($,#1241,1);
+#1243=LINE($,#1240,#1242);
+#1244=EDGE_CURVE($,#1231,#1239,#1243,.T.);
+#1245=ORIENTED_EDGE($,$,$,#1244,.T.);
+#1246=CARTESIAN_POINT($,(298.96574017642,113.84300017642,1.905));
+#1247=VERTEX_POINT($,#1246);
+#1248=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,1.905));
+#1249=DIRECTION($,(0,1,0));
+#1250=VECTOR($,#1249,1);
+#1251=LINE($,#1248,#1250);
+#1252=EDGE_CURVE($,#1239,#1247,#1251,.T.);
+#1253=ORIENTED_EDGE($,$,$,#1252,.T.);
+#1254=CARTESIAN_POINT($,(298.96574017642,125.313740352839,1.905));
+#1255=VERTEX_POINT($,#1254);
+#1256=CARTESIAN_POINT($,(298.96574017642,113.84300017642,1.905));
+#1257=DIRECTION($,(0,1,0));
+#1258=VECTOR($,#1257,1);
+#1259=LINE($,#1256,#1258);
+#1260=EDGE_CURVE($,#1247,#1255,#1259,.T.);
+#1261=ORIENTED_EDGE($,$,$,#1260,.T.);
+#1262=CARTESIAN_POINT($,(305.873701758259,125.313740352839,1.905));
+#1263=VERTEX_POINT($,#1262);
+#1264=CARTESIAN_POINT($,(298.96574017642,125.313740352839,1.905));
+#1265=DIRECTION($,(1,0,0));
+#1266=VECTOR($,#1265,1);
+#1267=LINE($,#1264,#1266);
+#1268=EDGE_CURVE($,#1255,#1263,#1267,.T.);
+#1269=ORIENTED_EDGE($,$,$,#1268,.T.);
+#1270=CARTESIAN_POINT($,(300.710054488645,130.477387622454,1.905));
+#1271=VERTEX_POINT($,#1270);
+#1272=CARTESIAN_POINT($,(305.873701758259,125.313740352839,1.905));
+#1273=DIRECTION($,(-0.707106781186546,0.707106781186549,0));
+#1274=VECTOR($,#1273,1);
+#1275=LINE($,#1272,#1274);
+#1276=EDGE_CURVE($,#1263,#1271,#1275,.T.);
+#1277=ORIENTED_EDGE($,$,$,#1276,.T.);
+#1278=CARTESIAN_POINT($,(302.057092906805,131.824426040615,1.905));
+#1279=VERTEX_POINT($,#1278);
+#1280=CARTESIAN_POINT($,(300.710054488645,130.477387622454,1.905));
+#1281=DIRECTION($,(0.707106781186548,0.707106781186548,0));
+#1282=VECTOR($,#1281,1);
+#1283=LINE($,#1280,#1282);
+#1284=EDGE_CURVE($,#1271,#1279,#1283,.T.);
+#1285=ORIENTED_EDGE($,$,$,#1284,.T.);
+#1286=CARTESIAN_POINT($,(307.22074017642,126.660778771,1.905));
+#1287=VERTEX_POINT($,#1286);
+#1288=CARTESIAN_POINT($,(302.057092906805,131.824426040615,1.905));
+#1289=DIRECTION($,(0.707106781186549,-0.707106781186546,0));
+#1290=VECTOR($,#1289,1);
+#1291=LINE($,#1288,#1290);
+#1292=EDGE_CURVE($,#1279,#1287,#1291,.T.);
+#1293=ORIENTED_EDGE($,$,$,#1292,.T.);
+#1294=CARTESIAN_POINT($,(307.22074017642,133.568740352839,1.905));
+#1295=VERTEX_POINT($,#1294);
+#1296=CARTESIAN_POINT($,(307.22074017642,126.660778771,1.905));
+#1297=DIRECTION($,(0,1,0));
+#1298=VECTOR($,#1297,1);
+#1299=LINE($,#1296,#1298);
+#1300=EDGE_CURVE($,#1287,#1295,#1299,.T.);
+#1301=ORIENTED_EDGE($,$,$,#1300,.T.);
+#1302=CARTESIAN_POINT($,(318.691480352839,133.568740352839,1.905));
+#1303=VERTEX_POINT($,#1302);
+#1304=CARTESIAN_POINT($,(307.22074017642,133.568740352839,1.905));
+#1305=DIRECTION($,(1,0,0));
+#1306=VECTOR($,#1305,1);
+#1307=LINE($,#1304,#1306);
+#1308=EDGE_CURVE($,#1295,#1303,#1307,.T.);
+#1309=ORIENTED_EDGE($,$,$,#1308,.T.);
+#1310=CARTESIAN_POINT($,(347.802420352839,133.568740352839,1.905));
+#1311=VERTEX_POINT($,#1310);
+#1312=CARTESIAN_POINT($,(318.691480352839,133.568740352839,1.905));
+#1313=DIRECTION($,(1,0,0));
+#1314=VECTOR($,#1313,1);
+#1315=LINE($,#1312,#1314);
+#1316=EDGE_CURVE($,#1303,#1311,#1315,.T.);
+#1317=ORIENTED_EDGE($,$,$,#1316,.T.);
+#1318=CARTESIAN_POINT($,(347.802420352839,248.351340352839,1.905));
+#1319=VERTEX_POINT($,#1318);
+#1320=CARTESIAN_POINT($,(347.802420352839,133.568740352839,1.905));
+#1321=DIRECTION($,(0,1,0));
+#1322=VECTOR($,#1321,1);
+#1323=LINE($,#1320,#1322);
+#1324=EDGE_CURVE($,#1311,#1319,#1323,.T.);
+#1325=ORIENTED_EDGE($,$,$,#1324,.T.);
+#1326=CARTESIAN_POINT($,(353.537790441049,248.351340352839,1.905));
+#1327=VERTEX_POINT($,#1326);
+#1328=CARTESIAN_POINT($,(347.802420352839,248.351340352839,1.905));
+#1329=DIRECTION($,(1,0,0));
+#1330=VECTOR($,#1329,1);
+#1331=LINE($,#1328,#1330);
+#1332=EDGE_CURVE($,#1319,#1327,#1331,.T.);
+#1333=ORIENTED_EDGE($,$,$,#1332,.T.);
+#1334=CARTESIAN_POINT($,(353.537790441049,248.351340352839,1.905));
+#1335=DIRECTION($,(1,0,0));
+#1336=VECTOR($,#1335,1);
+#1337=LINE($,#1334,#1336);
+#1338=EDGE_CURVE($,#1327,#877,#1337,.T.);
+#1339=ORIENTED_EDGE($,$,$,#1338,.T.);
+#1340=EDGE_LOOP($,(#885,#893,#901,#909,#917,#925,#933,#941,#949,#957,#965,#973,#981,#989,#997,#1005,#1013,#1021,#1029,#1037,#1045,#1053,#1061,#1069,#1077,#1085,#1093,#1101,#1109,#1117,#1125,#1133,#1141,#1149,#1157,#1165,#1173,#1181,#1189,#1197,#1205,#1213,#1221,#1229,#1237,#1245,#1253,#1261,#1269,#1277,#1285,#1293,#1301,#1309,#1317,#1325,#1333,#1339));
+#1341=FACE_OUTER_BOUND('',#1340,.T.);
+#1342=CARTESIAN_POINT($,(277.05824017642,164.000480352839,1.905));
+#1343=VERTEX_POINT($,#1342);
+#1344=CARTESIAN_POINT($,(261.18324017642,164.000480352839,1.905));
+#1345=VERTEX_POINT($,#1344);
+#1346=CARTESIAN_POINT($,(269.12074017642,164.000480352839,1.905));
+#1347=DIRECTION($,(0,0,1));
+#1348=DIRECTION($,(1,0,0));
+#1349=AXIS2_PLACEMENT_3D($,#1346,#1347,#1348);
+#1350=CIRCLE($,#1349,7.9375);
+#1351=TRIMMED_CURVE($,#1350,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1352=EDGE_CURVE($,#1343,#1345,#1351,.T.);
+#1353=ORIENTED_EDGE($,$,$,#1352,.F.);
+#1354=CARTESIAN_POINT($,(269.12074017642,164.000480352839,1.905));
+#1355=DIRECTION($,(0,0,1));
+#1356=DIRECTION($,(1,0,0));
+#1357=AXIS2_PLACEMENT_3D($,#1354,#1355,#1356);
+#1358=CIRCLE($,#1357,7.9375);
+#1359=TRIMMED_CURVE($,#1358,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1360=EDGE_CURVE($,#1345,#1343,#1359,.T.);
+#1361=ORIENTED_EDGE($,$,$,#1360,.F.);
+#1362=EDGE_LOOP($,(#1353,#1361));
+#1363=FACE_BOUND('',#1362,.T.);
+#1364=CARTESIAN_POINT($,(277.05824017642,208.450480352839,1.905));
+#1365=VERTEX_POINT($,#1364);
+#1366=CARTESIAN_POINT($,(261.18324017642,208.450480352839,1.905));
+#1367=VERTEX_POINT($,#1366);
+#1368=CARTESIAN_POINT($,(269.12074017642,208.450480352839,1.905));
+#1369=DIRECTION($,(0,0,1));
+#1370=DIRECTION($,(1,0,0));
+#1371=AXIS2_PLACEMENT_3D($,#1368,#1369,#1370);
+#1372=CIRCLE($,#1371,7.9375);
+#1373=TRIMMED_CURVE($,#1372,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1374=EDGE_CURVE($,#1365,#1367,#1373,.T.);
+#1375=ORIENTED_EDGE($,$,$,#1374,.F.);
+#1376=CARTESIAN_POINT($,(269.12074017642,208.450480352839,1.905));
+#1377=DIRECTION($,(0,0,1));
+#1378=DIRECTION($,(1,0,0));
+#1379=AXIS2_PLACEMENT_3D($,#1376,#1377,#1378);
+#1380=CIRCLE($,#1379,7.9375);
+#1381=TRIMMED_CURVE($,#1380,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1382=EDGE_CURVE($,#1367,#1365,#1381,.T.);
+#1383=ORIENTED_EDGE($,$,$,#1382,.F.);
+#1384=EDGE_LOOP($,(#1375,#1383));
+#1385=FACE_BOUND('',#1384,.T.);
+#1386=CARTESIAN_POINT($,(277.05824017642,252.90048035284,1.905));
+#1387=VERTEX_POINT($,#1386);
+#1388=CARTESIAN_POINT($,(261.18324017642,252.90048035284,1.905));
+#1389=VERTEX_POINT($,#1388);
+#1390=CARTESIAN_POINT($,(269.12074017642,252.90048035284,1.905));
+#1391=DIRECTION($,(0,0,1));
+#1392=DIRECTION($,(1,0,0));
+#1393=AXIS2_PLACEMENT_3D($,#1390,#1391,#1392);
+#1394=CIRCLE($,#1393,7.9375);
+#1395=TRIMMED_CURVE($,#1394,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1396=EDGE_CURVE($,#1387,#1389,#1395,.T.);
+#1397=ORIENTED_EDGE($,$,$,#1396,.F.);
+#1398=CARTESIAN_POINT($,(269.12074017642,252.90048035284,1.905));
+#1399=DIRECTION($,(0,0,1));
+#1400=DIRECTION($,(1,0,0));
+#1401=AXIS2_PLACEMENT_3D($,#1398,#1399,#1400);
+#1402=CIRCLE($,#1401,7.9375);
+#1403=TRIMMED_CURVE($,#1402,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1404=EDGE_CURVE($,#1389,#1387,#1403,.T.);
+#1405=ORIENTED_EDGE($,$,$,#1404,.F.);
+#1406=EDGE_LOOP($,(#1397,#1405));
+#1407=FACE_BOUND('',#1406,.T.);
+#1408=CARTESIAN_POINT($,(277.05824017642,297.350480352839,1.905));
+#1409=VERTEX_POINT($,#1408);
+#1410=CARTESIAN_POINT($,(261.18324017642,297.350480352839,1.905));
+#1411=VERTEX_POINT($,#1410);
+#1412=CARTESIAN_POINT($,(269.12074017642,297.350480352839,1.905));
+#1413=DIRECTION($,(0,0,1));
+#1414=DIRECTION($,(1,0,0));
+#1415=AXIS2_PLACEMENT_3D($,#1412,#1413,#1414);
+#1416=CIRCLE($,#1415,7.9375);
+#1417=TRIMMED_CURVE($,#1416,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1418=EDGE_CURVE($,#1409,#1411,#1417,.T.);
+#1419=ORIENTED_EDGE($,$,$,#1418,.F.);
+#1420=CARTESIAN_POINT($,(269.12074017642,297.350480352839,1.905));
+#1421=DIRECTION($,(0,0,1));
+#1422=DIRECTION($,(1,0,0));
+#1423=AXIS2_PLACEMENT_3D($,#1420,#1421,#1422);
+#1424=CIRCLE($,#1423,7.9375);
+#1425=TRIMMED_CURVE($,#1424,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1426=EDGE_CURVE($,#1411,#1409,#1425,.T.);
+#1427=ORIENTED_EDGE($,$,$,#1426,.F.);
+#1428=EDGE_LOOP($,(#1419,#1427));
+#1429=FACE_BOUND('',#1428,.T.);
+#1430=CARTESIAN_POINT($,(90.5333401764198,16.34746,1.905));
+#1431=VERTEX_POINT($,#1430);
+#1432=CARTESIAN_POINT($,(79.4081401764197,16.34746,1.905));
+#1433=VERTEX_POINT($,#1432);
+#1434=CARTESIAN_POINT($,(84.9707401764198,16.34746,1.905));
+#1435=DIRECTION($,(0,0,1));
+#1436=DIRECTION($,(1,0,0));
+#1437=AXIS2_PLACEMENT_3D($,#1434,#1435,#1436);
+#1438=CIRCLE($,#1437,5.5626);
+#1439=TRIMMED_CURVE($,#1438,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1440=EDGE_CURVE($,#1431,#1433,#1439,.T.);
+#1441=ORIENTED_EDGE($,$,$,#1440,.F.);
+#1442=CARTESIAN_POINT($,(84.9707401764198,16.34746,1.905));
+#1443=DIRECTION($,(0,0,1));
+#1444=DIRECTION($,(1,0,0));
+#1445=AXIS2_PLACEMENT_3D($,#1442,#1443,#1444);
+#1446=CIRCLE($,#1445,5.5626);
+#1447=TRIMMED_CURVE($,#1446,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1448=EDGE_CURVE($,#1433,#1431,#1447,.T.);
+#1449=ORIENTED_EDGE($,$,$,#1448,.F.);
+#1450=EDGE_LOOP($,(#1441,#1449));
+#1451=FACE_BOUND('',#1450,.T.);
+#1452=CARTESIAN_POINT($,(293.73334017642,16.34746,1.905));
+#1453=VERTEX_POINT($,#1452);
+#1454=CARTESIAN_POINT($,(282.60814017642,16.34746,1.905));
+#1455=VERTEX_POINT($,#1454);
+#1456=CARTESIAN_POINT($,(288.17074017642,16.34746,1.905));
+#1457=DIRECTION($,(0,0,1));
+#1458=DIRECTION($,(1,0,0));
+#1459=AXIS2_PLACEMENT_3D($,#1456,#1457,#1458);
+#1460=CIRCLE($,#1459,5.5626);
+#1461=TRIMMED_CURVE($,#1460,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1462=EDGE_CURVE($,#1453,#1455,#1461,.T.);
+#1463=ORIENTED_EDGE($,$,$,#1462,.F.);
+#1464=CARTESIAN_POINT($,(288.17074017642,16.34746,1.905));
+#1465=DIRECTION($,(0,0,1));
+#1466=DIRECTION($,(1,0,0));
+#1467=AXIS2_PLACEMENT_3D($,#1464,#1465,#1466);
+#1468=CIRCLE($,#1467,5.5626);
+#1469=TRIMMED_CURVE($,#1468,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1470=EDGE_CURVE($,#1455,#1453,#1469,.T.);
+#1471=ORIENTED_EDGE($,$,$,#1470,.F.);
+#1472=EDGE_LOOP($,(#1463,#1471));
+#1473=FACE_BOUND('',#1472,.T.);
+#1474=CARTESIAN_POINT($,(263.25334017642,398.747280352839,1.905));
+#1475=VERTEX_POINT($,#1474);
+#1476=CARTESIAN_POINT($,(225.15334017642,398.747280352839,1.905));
+#1477=VERTEX_POINT($,#1476);
+#1478=CARTESIAN_POINT($,(244.20334017642,398.747280352839,1.905));
+#1479=DIRECTION($,(0,0,1));
+#1480=DIRECTION($,(1,0,0));
+#1481=AXIS2_PLACEMENT_3D($,#1478,#1479,#1480);
+#1482=CIRCLE($,#1481,19.05);
+#1483=TRIMMED_CURVE($,#1482,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1484=EDGE_CURVE($,#1475,#1477,#1483,.T.);
+#1485=ORIENTED_EDGE($,$,$,#1484,.F.);
+#1486=CARTESIAN_POINT($,(244.20334017642,398.747280352839,1.905));
+#1487=DIRECTION($,(0,0,1));
+#1488=DIRECTION($,(1,0,0));
+#1489=AXIS2_PLACEMENT_3D($,#1486,#1487,#1488);
+#1490=CIRCLE($,#1489,19.05);
+#1491=TRIMMED_CURVE($,#1490,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1492=EDGE_CURVE($,#1477,#1475,#1491,.T.);
+#1493=ORIENTED_EDGE($,$,$,#1492,.F.);
+#1494=EDGE_LOOP($,(#1485,#1493));
+#1495=FACE_BOUND('',#1494,.T.);
+#1496=CARTESIAN_POINT($,(180.70334017642,424.147280352839,1.905));
+#1497=VERTEX_POINT($,#1496);
+#1498=CARTESIAN_POINT($,(129.90334017642,424.147280352839,1.905));
+#1499=VERTEX_POINT($,#1498);
+#1500=CARTESIAN_POINT($,(155.30334017642,424.147280352839,1.905));
+#1501=DIRECTION($,(0,0,1));
+#1502=DIRECTION($,(1,0,0));
+#1503=AXIS2_PLACEMENT_3D($,#1500,#1501,#1502);
+#1504=CIRCLE($,#1503,25.4);
+#1505=TRIMMED_CURVE($,#1504,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1506=EDGE_CURVE($,#1497,#1499,#1505,.T.);
+#1507=ORIENTED_EDGE($,$,$,#1506,.F.);
+#1508=CARTESIAN_POINT($,(155.30334017642,424.147280352839,1.905));
+#1509=DIRECTION($,(0,0,1));
+#1510=DIRECTION($,(1,0,0));
+#1511=AXIS2_PLACEMENT_3D($,#1508,#1509,#1510);
+#1512=CIRCLE($,#1511,25.4);
+#1513=TRIMMED_CURVE($,#1512,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1514=EDGE_CURVE($,#1499,#1497,#1513,.T.);
+#1515=ORIENTED_EDGE($,$,$,#1514,.F.);
+#1516=EDGE_LOOP($,(#1507,#1515));
+#1517=FACE_BOUND('',#1516,.T.);
+#1518=CARTESIAN_POINT($,(293.73334017642,603.550300705679,1.905));
+#1519=VERTEX_POINT($,#1518);
+#1520=CARTESIAN_POINT($,(282.60814017642,603.550300705679,1.905));
+#1521=VERTEX_POINT($,#1520);
+#1522=CARTESIAN_POINT($,(288.17074017642,603.550300705679,1.905));
+#1523=DIRECTION($,(0,0,1));
+#1524=DIRECTION($,(1,0,0));
+#1525=AXIS2_PLACEMENT_3D($,#1522,#1523,#1524);
+#1526=CIRCLE($,#1525,5.5626);
+#1527=TRIMMED_CURVE($,#1526,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1528=EDGE_CURVE($,#1519,#1521,#1527,.T.);
+#1529=ORIENTED_EDGE($,$,$,#1528,.F.);
+#1530=CARTESIAN_POINT($,(288.17074017642,603.550300705679,1.905));
+#1531=DIRECTION($,(0,0,1));
+#1532=DIRECTION($,(1,0,0));
+#1533=AXIS2_PLACEMENT_3D($,#1530,#1531,#1532);
+#1534=CIRCLE($,#1533,5.5626);
+#1535=TRIMMED_CURVE($,#1534,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1536=EDGE_CURVE($,#1521,#1519,#1535,.T.);
+#1537=ORIENTED_EDGE($,$,$,#1536,.F.);
+#1538=EDGE_LOOP($,(#1529,#1537));
+#1539=FACE_BOUND('',#1538,.T.);
+#1540=CARTESIAN_POINT($,(90.5333401764198,603.550300705679,1.905));
+#1541=VERTEX_POINT($,#1540);
+#1542=CARTESIAN_POINT($,(79.4081401764197,603.550300705679,1.905));
+#1543=VERTEX_POINT($,#1542);
+#1544=CARTESIAN_POINT($,(84.9707401764198,603.550300705679,1.905));
+#1545=DIRECTION($,(0,0,1));
+#1546=DIRECTION($,(1,0,0));
+#1547=AXIS2_PLACEMENT_3D($,#1544,#1545,#1546);
+#1548=CIRCLE($,#1547,5.5626);
+#1549=TRIMMED_CURVE($,#1548,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1550=EDGE_CURVE($,#1541,#1543,#1549,.T.);
+#1551=ORIENTED_EDGE($,$,$,#1550,.F.);
+#1552=CARTESIAN_POINT($,(84.9707401764198,603.550300705679,1.905));
+#1553=DIRECTION($,(0,0,1));
+#1554=DIRECTION($,(1,0,0));
+#1555=AXIS2_PLACEMENT_3D($,#1552,#1553,#1554);
+#1556=CIRCLE($,#1555,5.5626);
+#1557=TRIMMED_CURVE($,#1556,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1558=EDGE_CURVE($,#1543,#1541,#1557,.T.);
+#1559=ORIENTED_EDGE($,$,$,#1558,.F.);
+#1560=EDGE_LOOP($,(#1551,#1559));
+#1561=FACE_BOUND('',#1560,.T.);
+#1562=CARTESIAN_POINT($,(397.799086493049,311.851340352839,1.905));
+#1563=VERTEX_POINT($,#1562);
+#1564=CARTESIAN_POINT($,(370.748086493049,311.851340352839,1.905));
+#1565=VERTEX_POINT($,#1564);
+#1566=CARTESIAN_POINT($,(384.273586493049,311.851340352839,1.905));
+#1567=DIRECTION($,(0,0,1));
+#1568=DIRECTION($,(1,0,0));
+#1569=AXIS2_PLACEMENT_3D($,#1566,#1567,#1568);
+#1570=CIRCLE($,#1569,13.5255);
+#1571=TRIMMED_CURVE($,#1570,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1572=EDGE_CURVE($,#1563,#1565,#1571,.T.);
+#1573=ORIENTED_EDGE($,$,$,#1572,.F.);
+#1574=CARTESIAN_POINT($,(384.273586493049,311.851340352839,1.905));
+#1575=DIRECTION($,(0,0,1));
+#1576=DIRECTION($,(1,0,0));
+#1577=AXIS2_PLACEMENT_3D($,#1574,#1575,#1576);
+#1578=CIRCLE($,#1577,13.5255);
+#1579=TRIMMED_CURVE($,#1578,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1580=EDGE_CURVE($,#1565,#1563,#1579,.T.);
+#1581=ORIENTED_EDGE($,$,$,#1580,.F.);
+#1582=EDGE_LOOP($,(#1573,#1581));
+#1583=FACE_BOUND('',#1582,.T.);
+#1584=CARTESIAN_POINT($,(372.684836493049,292.801340352839,1.905));
+#1585=VERTEX_POINT($,#1584);
+#1586=CARTESIAN_POINT($,(367.922336493049,292.801340352839,1.905));
+#1587=VERTEX_POINT($,#1586);
+#1588=CARTESIAN_POINT($,(370.303586493049,292.801340352839,1.905));
+#1589=DIRECTION($,(0,0,1));
+#1590=DIRECTION($,(1,0,0));
+#1591=AXIS2_PLACEMENT_3D($,#1588,#1589,#1590);
+#1592=CIRCLE($,#1591,2.38125);
+#1593=TRIMMED_CURVE($,#1592,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1594=EDGE_CURVE($,#1585,#1587,#1593,.T.);
+#1595=ORIENTED_EDGE($,$,$,#1594,.F.);
+#1596=CARTESIAN_POINT($,(370.303586493049,292.801340352839,1.905));
+#1597=DIRECTION($,(0,0,1));
+#1598=DIRECTION($,(1,0,0));
+#1599=AXIS2_PLACEMENT_3D($,#1596,#1597,#1598);
+#1600=CIRCLE($,#1599,2.38125);
+#1601=TRIMMED_CURVE($,#1600,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1602=EDGE_CURVE($,#1587,#1585,#1601,.T.);
+#1603=ORIENTED_EDGE($,$,$,#1602,.F.);
+#1604=EDGE_LOOP($,(#1595,#1603));
+#1605=FACE_BOUND('',#1604,.T.);
+#1606=CARTESIAN_POINT($,(372.684836493049,330.901340352839,1.905));
+#1607=VERTEX_POINT($,#1606);
+#1608=CARTESIAN_POINT($,(367.922336493049,330.901340352839,1.905));
+#1609=VERTEX_POINT($,#1608);
+#1610=CARTESIAN_POINT($,(370.303586493049,330.901340352839,1.905));
+#1611=DIRECTION($,(0,0,1));
+#1612=DIRECTION($,(1,0,0));
+#1613=AXIS2_PLACEMENT_3D($,#1610,#1611,#1612);
+#1614=CIRCLE($,#1613,2.38125);
+#1615=TRIMMED_CURVE($,#1614,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1616=EDGE_CURVE($,#1607,#1609,#1615,.T.);
+#1617=ORIENTED_EDGE($,$,$,#1616,.F.);
+#1618=CARTESIAN_POINT($,(370.303586493049,330.901340352839,1.905));
+#1619=DIRECTION($,(0,0,1));
+#1620=DIRECTION($,(1,0,0));
+#1621=AXIS2_PLACEMENT_3D($,#1618,#1619,#1620);
+#1622=CIRCLE($,#1621,2.38125);
+#1623=TRIMMED_CURVE($,#1622,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1624=EDGE_CURVE($,#1609,#1607,#1623,.T.);
+#1625=ORIENTED_EDGE($,$,$,#1624,.F.);
+#1626=EDGE_LOOP($,(#1617,#1625));
+#1627=FACE_BOUND('',#1626,.T.);
+#1628=CARTESIAN_POINT($,(404.434836493049,292.801340352839,1.905));
+#1629=VERTEX_POINT($,#1628);
+#1630=CARTESIAN_POINT($,(399.672336493049,292.801340352839,1.905));
+#1631=VERTEX_POINT($,#1630);
+#1632=CARTESIAN_POINT($,(402.053586493049,292.801340352839,1.905));
+#1633=DIRECTION($,(0,0,1));
+#1634=DIRECTION($,(1,0,0));
+#1635=AXIS2_PLACEMENT_3D($,#1632,#1633,#1634);
+#1636=CIRCLE($,#1635,2.38125);
+#1637=TRIMMED_CURVE($,#1636,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1638=EDGE_CURVE($,#1629,#1631,#1637,.T.);
+#1639=ORIENTED_EDGE($,$,$,#1638,.F.);
+#1640=CARTESIAN_POINT($,(402.053586493049,292.801340352839,1.905));
+#1641=DIRECTION($,(0,0,1));
+#1642=DIRECTION($,(1,0,0));
+#1643=AXIS2_PLACEMENT_3D($,#1640,#1641,#1642);
+#1644=CIRCLE($,#1643,2.38125);
+#1645=TRIMMED_CURVE($,#1644,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1646=EDGE_CURVE($,#1631,#1629,#1645,.T.);
+#1647=ORIENTED_EDGE($,$,$,#1646,.F.);
+#1648=EDGE_LOOP($,(#1639,#1647));
+#1649=FACE_BOUND('',#1648,.T.);
+#1650=CARTESIAN_POINT($,(404.434836493049,330.901340352839,1.905));
+#1651=VERTEX_POINT($,#1650);
+#1652=CARTESIAN_POINT($,(399.672336493049,330.901340352839,1.905));
+#1653=VERTEX_POINT($,#1652);
+#1654=CARTESIAN_POINT($,(402.053586493049,330.901340352839,1.905));
+#1655=DIRECTION($,(0,0,1));
+#1656=DIRECTION($,(1,0,0));
+#1657=AXIS2_PLACEMENT_3D($,#1654,#1655,#1656);
+#1658=CIRCLE($,#1657,2.38125);
+#1659=TRIMMED_CURVE($,#1658,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1660=EDGE_CURVE($,#1651,#1653,#1659,.T.);
+#1661=ORIENTED_EDGE($,$,$,#1660,.F.);
+#1662=CARTESIAN_POINT($,(402.053586493049,330.901340352839,1.905));
+#1663=DIRECTION($,(0,0,1));
+#1664=DIRECTION($,(1,0,0));
+#1665=AXIS2_PLACEMENT_3D($,#1662,#1663,#1664);
+#1666=CIRCLE($,#1665,2.38125);
+#1667=TRIMMED_CURVE($,#1666,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1668=EDGE_CURVE($,#1653,#1651,#1667,.T.);
+#1669=ORIENTED_EDGE($,$,$,#1668,.F.);
+#1670=EDGE_LOOP($,(#1661,#1669));
+#1671=FACE_BOUND('',#1670,.T.);
+#1672=CARTESIAN_POINT($,(107.67834017642,189.298880352839,1.905));
+#1673=VERTEX_POINT($,#1672);
+#1674=CARTESIAN_POINT($,(126.72834017642,189.298880352839,1.905));
+#1675=VERTEX_POINT($,#1674);
+#1676=CARTESIAN_POINT($,(107.67834017642,189.298880352839,1.905));
+#1677=DIRECTION($,(1,0,0));
+#1678=VECTOR($,#1677,1);
+#1679=LINE($,#1676,#1678);
+#1680=EDGE_CURVE($,#1673,#1675,#1679,.T.);
+#1681=ORIENTED_EDGE($,$,$,#1680,.F.);
+#1682=CARTESIAN_POINT($,(107.67834017642,278.198880352839,1.905));
+#1683=VERTEX_POINT($,#1682);
+#1684=CARTESIAN_POINT($,(107.67834017642,278.198880352839,1.905));
+#1685=DIRECTION($,(0,-1,0));
+#1686=VECTOR($,#1685,1);
+#1687=LINE($,#1684,#1686);
+#1688=EDGE_CURVE($,#1683,#1673,#1687,.T.);
+#1689=ORIENTED_EDGE($,$,$,#1688,.F.);
+#1690=CARTESIAN_POINT($,(126.72834017642,278.198880352839,1.905));
+#1691=VERTEX_POINT($,#1690);
+#1692=CARTESIAN_POINT($,(126.72834017642,278.198880352839,1.905));
+#1693=DIRECTION($,(-1,0,0));
+#1694=VECTOR($,#1693,1);
+#1695=LINE($,#1692,#1694);
+#1696=EDGE_CURVE($,#1691,#1683,#1695,.T.);
+#1697=ORIENTED_EDGE($,$,$,#1696,.F.);
+#1698=CARTESIAN_POINT($,(126.72834017642,189.298880352839,1.905));
+#1699=DIRECTION($,(0,1,0));
+#1700=VECTOR($,#1699,1);
+#1701=LINE($,#1698,#1700);
+#1702=EDGE_CURVE($,#1675,#1691,#1701,.T.);
+#1703=ORIENTED_EDGE($,$,$,#1702,.F.);
+#1704=EDGE_LOOP($,(#1681,#1689,#1697,#1703));
+#1705=FACE_BOUND('',#1704,.T.);
+#1706=CARTESIAN_POINT($,(171.17834017642,189.298880352839,1.905));
+#1707=VERTEX_POINT($,#1706);
+#1708=CARTESIAN_POINT($,(190.22834017642,189.298880352839,1.905));
+#1709=VERTEX_POINT($,#1708);
+#1710=CARTESIAN_POINT($,(171.17834017642,189.298880352839,1.905));
+#1711=DIRECTION($,(1,0,0));
+#1712=VECTOR($,#1711,1);
+#1713=LINE($,#1710,#1712);
+#1714=EDGE_CURVE($,#1707,#1709,#1713,.T.);
+#1715=ORIENTED_EDGE($,$,$,#1714,.F.);
+#1716=CARTESIAN_POINT($,(171.17834017642,278.198880352839,1.905));
+#1717=VERTEX_POINT($,#1716);
+#1718=CARTESIAN_POINT($,(171.17834017642,278.198880352839,1.905));
+#1719=DIRECTION($,(0,-1,0));
+#1720=VECTOR($,#1719,1);
+#1721=LINE($,#1718,#1720);
+#1722=EDGE_CURVE($,#1717,#1707,#1721,.T.);
+#1723=ORIENTED_EDGE($,$,$,#1722,.F.);
+#1724=CARTESIAN_POINT($,(190.22834017642,278.198880352839,1.905));
+#1725=VERTEX_POINT($,#1724);
+#1726=CARTESIAN_POINT($,(190.22834017642,278.198880352839,1.905));
+#1727=DIRECTION($,(-1,0,0));
+#1728=VECTOR($,#1727,1);
+#1729=LINE($,#1726,#1728);
+#1730=EDGE_CURVE($,#1725,#1717,#1729,.T.);
+#1731=ORIENTED_EDGE($,$,$,#1730,.F.);
+#1732=CARTESIAN_POINT($,(190.22834017642,189.298880352839,1.905));
+#1733=DIRECTION($,(0,1,0));
+#1734=VECTOR($,#1733,1);
+#1735=LINE($,#1732,#1734);
+#1736=EDGE_CURVE($,#1709,#1725,#1735,.T.);
+#1737=ORIENTED_EDGE($,$,$,#1736,.F.);
+#1738=EDGE_LOOP($,(#1715,#1723,#1731,#1737));
+#1739=FACE_BOUND('',#1738,.T.);
+#1740=ADVANCED_FACE('',(#1341,#1363,#1385,#1407,#1429,#1451,#1473,#1495,#1517,#1539,#1561,#1583,#1605,#1627,#1649,#1671,#1705,#1739),#875,.T.);
+#1741=CARTESIAN_POINT($,(402.051790441049,248.351340352839,0));
+#1742=DIRECTION($,(1,0,0));
+#1743=DIRECTION($,(0,0,1));
+#1744=AXIS2_PLACEMENT_3D($,#1741,#1742,#1743);
+#1745=PLANE($,#1744);
+#1746=ORIENTED_EDGE($,$,$,#14,.T.);
+#1747=CARTESIAN_POINT($,(402.051790441049,261.051340352839,0));
+#1748=DIRECTION($,(0,0,1));
+#1749=VECTOR($,#1748,1);
+#1750=LINE($,#1747,#1749);
+#1751=EDGE_CURVE($,#9,#879,#1750,.T.);
+#1752=ORIENTED_EDGE($,$,$,#1751,.T.);
+#1753=ORIENTED_EDGE($,$,$,#884,.F.);
+#1754=CARTESIAN_POINT($,(402.051790441049,248.351340352839,0));
+#1755=DIRECTION($,(0,0,1));
+#1756=VECTOR($,#1755,1);
+#1757=LINE($,#1754,#1756);
+#1758=EDGE_CURVE($,#7,#877,#1757,.T.);
+#1759=ORIENTED_EDGE($,$,$,#1758,.F.);
+#1760=EDGE_LOOP($,(#1746,#1752,#1753,#1759));
+#1761=FACE_OUTER_BOUND('',#1760,.T.);
+#1762=ADVANCED_FACE('',(#1761),#1745,.T.);
+#1763=CARTESIAN_POINT($,(402.051790441049,261.051340352839,0));
+#1764=DIRECTION($,(0,-1,0));
+#1765=DIRECTION($,(0,0,1));
+#1766=AXIS2_PLACEMENT_3D($,#1763,#1764,#1765);
+#1767=PLANE($,#1766);
+#1768=ORIENTED_EDGE($,$,$,#22,.T.);
+#1769=CARTESIAN_POINT($,(414.751790441049,261.051340352839,-0));
+#1770=DIRECTION($,(0,0,1));
+#1771=VECTOR($,#1770,1);
+#1772=LINE($,#1769,#1771);
+#1773=EDGE_CURVE($,#17,#887,#1772,.T.);
+#1774=ORIENTED_EDGE($,$,$,#1773,.T.);
+#1775=ORIENTED_EDGE($,$,$,#892,.F.);
+#1776=ORIENTED_EDGE($,$,$,#1751,.F.);
+#1777=EDGE_LOOP($,(#1768,#1774,#1775,#1776));
+#1778=FACE_OUTER_BOUND('',#1777,.T.);
+#1779=ADVANCED_FACE('',(#1778),#1767,.T.);
+#1780=CARTESIAN_POINT($,(414.751790441049,261.051340352839,0));
+#1781=DIRECTION($,(1,0,0));
+#1782=DIRECTION($,(0,0,1));
+#1783=AXIS2_PLACEMENT_3D($,#1780,#1781,#1782);
+#1784=PLANE($,#1783);
+#1785=ORIENTED_EDGE($,$,$,#30,.T.);
+#1786=CARTESIAN_POINT($,(414.751790441049,362.651340352839,-0));
+#1787=DIRECTION($,(0,0,1));
+#1788=VECTOR($,#1787,1);
+#1789=LINE($,#1786,#1788);
+#1790=EDGE_CURVE($,#25,#895,#1789,.T.);
+#1791=ORIENTED_EDGE($,$,$,#1790,.T.);
+#1792=ORIENTED_EDGE($,$,$,#900,.F.);
+#1793=ORIENTED_EDGE($,$,$,#1773,.F.);
+#1794=EDGE_LOOP($,(#1785,#1791,#1792,#1793));
+#1795=FACE_OUTER_BOUND('',#1794,.T.);
+#1796=ADVANCED_FACE('',(#1795),#1784,.T.);
+#1797=CARTESIAN_POINT($,(414.751790441049,362.651340352839,0));
+#1798=DIRECTION($,(0,1,0));
+#1799=DIRECTION($,(0,0,1));
+#1800=AXIS2_PLACEMENT_3D($,#1797,#1798,#1799);
+#1801=PLANE($,#1800);
+#1802=ORIENTED_EDGE($,$,$,#38,.T.);
+#1803=CARTESIAN_POINT($,(402.051790441049,362.651340352839,0));
+#1804=DIRECTION($,(0,0,1));
+#1805=VECTOR($,#1804,1);
+#1806=LINE($,#1803,#1805);
+#1807=EDGE_CURVE($,#33,#903,#1806,.T.);
+#1808=ORIENTED_EDGE($,$,$,#1807,.T.);
+#1809=ORIENTED_EDGE($,$,$,#908,.F.);
+#1810=ORIENTED_EDGE($,$,$,#1790,.F.);
+#1811=EDGE_LOOP($,(#1802,#1808,#1809,#1810));
+#1812=FACE_OUTER_BOUND('',#1811,.T.);
+#1813=ADVANCED_FACE('',(#1812),#1801,.T.);
+#1814=CARTESIAN_POINT($,(402.051790441049,362.651340352839,0));
+#1815=DIRECTION($,(1,0,0));
+#1816=DIRECTION($,(0,0,1));
+#1817=AXIS2_PLACEMENT_3D($,#1814,#1815,#1816);
+#1818=PLANE($,#1817);
+#1819=ORIENTED_EDGE($,$,$,#46,.T.);
+#1820=CARTESIAN_POINT($,(402.051790441049,375.351340352839,-0));
+#1821=DIRECTION($,(0,0,1));
+#1822=VECTOR($,#1821,1);
+#1823=LINE($,#1820,#1822);
+#1824=EDGE_CURVE($,#41,#911,#1823,.T.);
+#1825=ORIENTED_EDGE($,$,$,#1824,.T.);
+#1826=ORIENTED_EDGE($,$,$,#916,.F.);
+#1827=ORIENTED_EDGE($,$,$,#1807,.F.);
+#1828=EDGE_LOOP($,(#1819,#1825,#1826,#1827));
+#1829=FACE_OUTER_BOUND('',#1828,.T.);
+#1830=ADVANCED_FACE('',(#1829),#1818,.T.);
+#1831=CARTESIAN_POINT($,(402.051790441049,375.351340352839,0));
+#1832=DIRECTION($,(0,1,0));
+#1833=DIRECTION($,(0,0,1));
+#1834=AXIS2_PLACEMENT_3D($,#1831,#1832,#1833);
+#1835=PLANE($,#1834);
+#1836=ORIENTED_EDGE($,$,$,#54,.T.);
+#1837=CARTESIAN_POINT($,(353.537790441049,375.351340352839,0));
+#1838=DIRECTION($,(0,0,1));
+#1839=VECTOR($,#1838,1);
+#1840=LINE($,#1837,#1839);
+#1841=EDGE_CURVE($,#49,#919,#1840,.T.);
+#1842=ORIENTED_EDGE($,$,$,#1841,.T.);
+#1843=ORIENTED_EDGE($,$,$,#924,.F.);
+#1844=ORIENTED_EDGE($,$,$,#1824,.F.);
+#1845=EDGE_LOOP($,(#1836,#1842,#1843,#1844));
+#1846=FACE_OUTER_BOUND('',#1845,.T.);
+#1847=ADVANCED_FACE('',(#1846),#1835,.T.);
+#1848=CARTESIAN_POINT($,(353.537790441049,375.351340352839,0));
+#1849=DIRECTION($,(0,1,0));
+#1850=DIRECTION($,(0,0,1));
+#1851=AXIS2_PLACEMENT_3D($,#1848,#1849,#1850);
+#1852=PLANE($,#1851);
+#1853=ORIENTED_EDGE($,$,$,#62,.T.);
+#1854=CARTESIAN_POINT($,(347.802420352839,375.351340352839,0));
+#1855=DIRECTION($,(0,0,1));
+#1856=VECTOR($,#1855,1);
+#1857=LINE($,#1854,#1856);
+#1858=EDGE_CURVE($,#57,#927,#1857,.T.);
+#1859=ORIENTED_EDGE($,$,$,#1858,.T.);
+#1860=ORIENTED_EDGE($,$,$,#932,.F.);
+#1861=ORIENTED_EDGE($,$,$,#1841,.F.);
+#1862=EDGE_LOOP($,(#1853,#1859,#1860,#1861));
+#1863=FACE_OUTER_BOUND('',#1862,.T.);
+#1864=ADVANCED_FACE('',(#1863),#1852,.T.);
+#1865=CARTESIAN_POINT($,(347.802420352839,375.351340352839,0));
+#1866=DIRECTION($,(1,0,0));
+#1867=DIRECTION($,(0,0,1));
+#1868=AXIS2_PLACEMENT_3D($,#1865,#1866,#1867);
+#1869=PLANE($,#1868);
+#1870=ORIENTED_EDGE($,$,$,#70,.T.);
+#1871=CARTESIAN_POINT($,(347.802420352839,485.358740352839,-0));
+#1872=DIRECTION($,(0,0,1));
+#1873=VECTOR($,#1872,1);
+#1874=LINE($,#1871,#1873);
+#1875=EDGE_CURVE($,#65,#935,#1874,.T.);
+#1876=ORIENTED_EDGE($,$,$,#1875,.T.);
+#1877=ORIENTED_EDGE($,$,$,#940,.F.);
+#1878=ORIENTED_EDGE($,$,$,#1858,.F.);
+#1879=EDGE_LOOP($,(#1870,#1876,#1877,#1878));
+#1880=FACE_OUTER_BOUND('',#1879,.T.);
+#1881=ADVANCED_FACE('',(#1880),#1869,.T.);
+#1882=CARTESIAN_POINT($,(347.802420352839,485.358740352839,0));
+#1883=DIRECTION($,(0,1,0));
+#1884=DIRECTION($,(0,0,1));
+#1885=AXIS2_PLACEMENT_3D($,#1882,#1883,#1884);
+#1886=PLANE($,#1885);
+#1887=ORIENTED_EDGE($,$,$,#78,.T.);
+#1888=CARTESIAN_POINT($,(318.691480352839,485.358740352839,0));
+#1889=DIRECTION($,(0,0,1));
+#1890=VECTOR($,#1889,1);
+#1891=LINE($,#1888,#1890);
+#1892=EDGE_CURVE($,#73,#943,#1891,.T.);
+#1893=ORIENTED_EDGE($,$,$,#1892,.T.);
+#1894=ORIENTED_EDGE($,$,$,#948,.F.);
+#1895=ORIENTED_EDGE($,$,$,#1875,.F.);
+#1896=EDGE_LOOP($,(#1887,#1893,#1894,#1895));
+#1897=FACE_OUTER_BOUND('',#1896,.T.);
+#1898=ADVANCED_FACE('',(#1897),#1886,.T.);
+#1899=CARTESIAN_POINT($,(318.691480352839,485.35874035284,0));
+#1900=DIRECTION($,(0,1,0));
+#1901=DIRECTION($,(0,0,1));
+#1902=AXIS2_PLACEMENT_3D($,#1899,#1900,#1901);
+#1903=PLANE($,#1902);
+#1904=ORIENTED_EDGE($,$,$,#86,.T.);
+#1905=CARTESIAN_POINT($,(307.22074017642,485.35874035284,0));
+#1906=DIRECTION($,(0,0,1));
+#1907=VECTOR($,#1906,1);
+#1908=LINE($,#1905,#1907);
+#1909=EDGE_CURVE($,#81,#951,#1908,.T.);
+#1910=ORIENTED_EDGE($,$,$,#1909,.T.);
+#1911=ORIENTED_EDGE($,$,$,#956,.F.);
+#1912=ORIENTED_EDGE($,$,$,#1892,.F.);
+#1913=EDGE_LOOP($,(#1904,#1910,#1911,#1912));
+#1914=FACE_OUTER_BOUND('',#1913,.T.);
+#1915=ADVANCED_FACE('',(#1914),#1903,.T.);
+#1916=CARTESIAN_POINT($,(307.22074017642,485.35874035284,0));
+#1917=DIRECTION($,(1,0,0));
+#1918=DIRECTION($,(0,0,1));
+#1919=AXIS2_PLACEMENT_3D($,#1916,#1917,#1918);
+#1920=PLANE($,#1919);
+#1921=ORIENTED_EDGE($,$,$,#94,.T.);
+#1922=CARTESIAN_POINT($,(307.22074017642,492.266701934679,-0));
+#1923=DIRECTION($,(0,0,1));
+#1924=VECTOR($,#1923,1);
+#1925=LINE($,#1922,#1924);
+#1926=EDGE_CURVE($,#89,#959,#1925,.T.);
+#1927=ORIENTED_EDGE($,$,$,#1926,.T.);
+#1928=ORIENTED_EDGE($,$,$,#964,.F.);
+#1929=ORIENTED_EDGE($,$,$,#1909,.F.);
+#1930=EDGE_LOOP($,(#1921,#1927,#1928,#1929));
+#1931=FACE_OUTER_BOUND('',#1930,.T.);
+#1932=ADVANCED_FACE('',(#1931),#1920,.T.);
+#1933=CARTESIAN_POINT($,(307.22074017642,492.266701934679,0));
+#1934=DIRECTION($,(-0.707106781186548,0.707106781186548,0));
+#1935=DIRECTION($,(0,0,1));
+#1936=AXIS2_PLACEMENT_3D($,#1933,#1934,#1935);
+#1937=PLANE($,#1936);
+#1938=ORIENTED_EDGE($,$,$,#102,.T.);
+#1939=CARTESIAN_POINT($,(302.057092906805,487.103054665064,0));
+#1940=DIRECTION($,(0,0,1));
+#1941=VECTOR($,#1940,1);
+#1942=LINE($,#1939,#1941);
+#1943=EDGE_CURVE($,#97,#967,#1942,.T.);
+#1944=ORIENTED_EDGE($,$,$,#1943,.T.);
+#1945=ORIENTED_EDGE($,$,$,#972,.F.);
+#1946=ORIENTED_EDGE($,$,$,#1926,.F.);
+#1947=EDGE_LOOP($,(#1938,#1944,#1945,#1946));
+#1948=FACE_OUTER_BOUND('',#1947,.T.);
+#1949=ADVANCED_FACE('',(#1948),#1937,.T.);
+#1950=CARTESIAN_POINT($,(302.057092906805,487.103054665064,0));
+#1951=DIRECTION($,(0.707106781186562,0.707106781186533,0));
+#1952=DIRECTION($,(0,0,1));
+#1953=AXIS2_PLACEMENT_3D($,#1950,#1951,#1952);
+#1954=PLANE($,#1953);
+#1955=ORIENTED_EDGE($,$,$,#110,.T.);
+#1956=CARTESIAN_POINT($,(300.710054488645,488.450093083225,0));
+#1957=DIRECTION($,(0,0,1));
+#1958=VECTOR($,#1957,1);
+#1959=LINE($,#1956,#1958);
+#1960=EDGE_CURVE($,#105,#975,#1959,.T.);
+#1961=ORIENTED_EDGE($,$,$,#1960,.T.);
+#1962=ORIENTED_EDGE($,$,$,#980,.F.);
+#1963=ORIENTED_EDGE($,$,$,#1943,.F.);
+#1964=EDGE_LOOP($,(#1955,#1961,#1962,#1963));
+#1965=FACE_OUTER_BOUND('',#1964,.T.);
+#1966=ADVANCED_FACE('',(#1965),#1954,.T.);
+#1967=CARTESIAN_POINT($,(300.710054488645,488.450093083225,0));
+#1968=DIRECTION($,(0.707106781186551,-0.707106781186544,0));
+#1969=DIRECTION($,(0,0,1));
+#1970=AXIS2_PLACEMENT_3D($,#1967,#1968,#1969);
+#1971=PLANE($,#1970);
+#1972=ORIENTED_EDGE($,$,$,#118,.T.);
+#1973=CARTESIAN_POINT($,(305.873701758259,493.613740352839,-0));
+#1974=DIRECTION($,(0,0,1));
+#1975=VECTOR($,#1974,1);
+#1976=LINE($,#1973,#1975);
+#1977=EDGE_CURVE($,#113,#983,#1976,.T.);
+#1978=ORIENTED_EDGE($,$,$,#1977,.T.);
+#1979=ORIENTED_EDGE($,$,$,#988,.F.);
+#1980=ORIENTED_EDGE($,$,$,#1960,.F.);
+#1981=EDGE_LOOP($,(#1972,#1978,#1979,#1980));
+#1982=FACE_OUTER_BOUND('',#1981,.T.);
+#1983=ADVANCED_FACE('',(#1982),#1971,.T.);
+#1984=CARTESIAN_POINT($,(305.873701758259,493.613740352839,0));
+#1985=DIRECTION($,(0,1,0));
+#1986=DIRECTION($,(0,0,1));
+#1987=AXIS2_PLACEMENT_3D($,#1984,#1985,#1986);
+#1988=PLANE($,#1987);
+#1989=ORIENTED_EDGE($,$,$,#126,.T.);
+#1990=CARTESIAN_POINT($,(298.96574017642,493.613740352839,0));
+#1991=DIRECTION($,(0,0,1));
+#1992=VECTOR($,#1991,1);
+#1993=LINE($,#1990,#1992);
+#1994=EDGE_CURVE($,#121,#991,#1993,.T.);
+#1995=ORIENTED_EDGE($,$,$,#1994,.T.);
+#1996=ORIENTED_EDGE($,$,$,#996,.F.);
+#1997=ORIENTED_EDGE($,$,$,#1977,.F.);
+#1998=EDGE_LOOP($,(#1989,#1995,#1996,#1997));
+#1999=FACE_OUTER_BOUND('',#1998,.T.);
+#2000=ADVANCED_FACE('',(#1999),#1988,.T.);
+#2001=CARTESIAN_POINT($,(298.96574017642,493.613740352839,0));
+#2002=DIRECTION($,(1,0,0));
+#2003=DIRECTION($,(0,0,1));
+#2004=AXIS2_PLACEMENT_3D($,#2001,#2002,#2003);
+#2005=PLANE($,#2004);
+#2006=ORIENTED_EDGE($,$,$,#134,.T.);
+#2007=CARTESIAN_POINT($,(298.96574017642,505.084480529259,0));
+#2008=DIRECTION($,(0,0,1));
+#2009=VECTOR($,#2008,1);
+#2010=LINE($,#2007,#2009);
+#2011=EDGE_CURVE($,#129,#999,#2010,.T.);
+#2012=ORIENTED_EDGE($,$,$,#2011,.T.);
+#2013=ORIENTED_EDGE($,$,$,#1004,.F.);
+#2014=ORIENTED_EDGE($,$,$,#1994,.F.);
+#2015=EDGE_LOOP($,(#2006,#2012,#2013,#2014));
+#2016=FACE_OUTER_BOUND('',#2015,.T.);
+#2017=ADVANCED_FACE('',(#2016),#2005,.T.);
+#2018=CARTESIAN_POINT($,(298.96574017642,505.084480529259,0));
+#2019=DIRECTION($,(1,0,0));
+#2020=DIRECTION($,(0,0,1));
+#2021=AXIS2_PLACEMENT_3D($,#2018,#2019,#2020);
+#2022=PLANE($,#2021);
+#2023=ORIENTED_EDGE($,$,$,#142,.T.);
+#2024=CARTESIAN_POINT($,(298.96574017642,566.677020529259,0));
+#2025=DIRECTION($,(0,0,1));
+#2026=VECTOR($,#2025,1);
+#2027=LINE($,#2024,#2026);
+#2028=EDGE_CURVE($,#137,#1007,#2027,.T.);
+#2029=ORIENTED_EDGE($,$,$,#2028,.T.);
+#2030=ORIENTED_EDGE($,$,$,#1012,.F.);
+#2031=ORIENTED_EDGE($,$,$,#2011,.F.);
+#2032=EDGE_LOOP($,(#2023,#2029,#2030,#2031));
+#2033=FACE_OUTER_BOUND('',#2032,.T.);
+#2034=ADVANCED_FACE('',(#2033),#2022,.T.);
+#2035=CARTESIAN_POINT($,(298.96574017642,566.677020529259,0));
+#2036=DIRECTION($,(1,0,0));
+#2037=DIRECTION($,(0,0,1));
+#2038=AXIS2_PLACEMENT_3D($,#2035,#2036,#2037);
+#2039=PLANE($,#2038);
+#2040=ORIENTED_EDGE($,$,$,#150,.T.);
+#2041=CARTESIAN_POINT($,(298.96574017642,578.147760705679,0));
+#2042=DIRECTION($,(0,0,1));
+#2043=VECTOR($,#2042,1);
+#2044=LINE($,#2041,#2043);
+#2045=EDGE_CURVE($,#145,#1015,#2044,.T.);
+#2046=ORIENTED_EDGE($,$,$,#2045,.T.);
+#2047=ORIENTED_EDGE($,$,$,#1020,.F.);
+#2048=ORIENTED_EDGE($,$,$,#2028,.F.);
+#2049=EDGE_LOOP($,(#2040,#2046,#2047,#2048));
+#2050=FACE_OUTER_BOUND('',#2049,.T.);
+#2051=ADVANCED_FACE('',(#2050),#2039,.T.);
+#2052=CARTESIAN_POINT($,(298.96574017642,578.147760705679,0));
+#2053=DIRECTION($,(1,0,0));
+#2054=DIRECTION($,(0,0,1));
+#2055=AXIS2_PLACEMENT_3D($,#2052,#2053,#2054);
+#2056=PLANE($,#2055);
+#2057=ORIENTED_EDGE($,$,$,#158,.T.);
+#2058=CARTESIAN_POINT($,(298.96574017642,622.597760705679,-0));
+#2059=DIRECTION($,(0,0,1));
+#2060=VECTOR($,#2059,1);
+#2061=LINE($,#2058,#2060);
+#2062=EDGE_CURVE($,#153,#1023,#2061,.T.);
+#2063=ORIENTED_EDGE($,$,$,#2062,.T.);
+#2064=ORIENTED_EDGE($,$,$,#1028,.F.);
+#2065=ORIENTED_EDGE($,$,$,#2045,.F.);
+#2066=EDGE_LOOP($,(#2057,#2063,#2064,#2065));
+#2067=FACE_OUTER_BOUND('',#2066,.T.);
+#2068=ADVANCED_FACE('',(#2067),#2056,.T.);
+#2069=CARTESIAN_POINT($,(298.96574017642,622.597760705679,0));
+#2070=DIRECTION($,(0,1,0));
+#2071=DIRECTION($,(0,0,1));
+#2072=AXIS2_PLACEMENT_3D($,#2069,#2070,#2071);
+#2073=PLANE($,#2072);
+#2074=ORIENTED_EDGE($,$,$,#166,.T.);
+#2075=CARTESIAN_POINT($,(74.1757401764197,622.597760705679,-0));
+#2076=DIRECTION($,(0,0,1));
+#2077=VECTOR($,#2076,1);
+#2078=LINE($,#2075,#2077);
+#2079=EDGE_CURVE($,#161,#1031,#2078,.T.);
+#2080=ORIENTED_EDGE($,$,$,#2079,.T.);
+#2081=ORIENTED_EDGE($,$,$,#1036,.F.);
+#2082=ORIENTED_EDGE($,$,$,#2062,.F.);
+#2083=EDGE_LOOP($,(#2074,#2080,#2081,#2082));
+#2084=FACE_OUTER_BOUND('',#2083,.T.);
+#2085=ADVANCED_FACE('',(#2084),#2073,.T.);
+#2086=CARTESIAN_POINT($,(74.1757401764197,622.597760705679,0));
+#2087=DIRECTION($,(-1,0,0));
+#2088=DIRECTION($,(0,0,1));
+#2089=AXIS2_PLACEMENT_3D($,#2086,#2087,#2088);
+#2090=PLANE($,#2089);
+#2091=ORIENTED_EDGE($,$,$,#174,.T.);
+#2092=CARTESIAN_POINT($,(74.1757401764197,578.147760705679,0));
+#2093=DIRECTION($,(0,0,1));
+#2094=VECTOR($,#2093,1);
+#2095=LINE($,#2092,#2094);
+#2096=EDGE_CURVE($,#169,#1039,#2095,.T.);
+#2097=ORIENTED_EDGE($,$,$,#2096,.T.);
+#2098=ORIENTED_EDGE($,$,$,#1044,.F.);
+#2099=ORIENTED_EDGE($,$,$,#2079,.F.);
+#2100=EDGE_LOOP($,(#2091,#2097,#2098,#2099));
+#2101=FACE_OUTER_BOUND('',#2100,.T.);
+#2102=ADVANCED_FACE('',(#2101),#2090,.T.);
+#2103=CARTESIAN_POINT($,(74.1757401764197,578.147760705679,0));
+#2104=DIRECTION($,(-1,0,0));
+#2105=DIRECTION($,(0,0,1));
+#2106=AXIS2_PLACEMENT_3D($,#2103,#2104,#2105);
+#2107=PLANE($,#2106);
+#2108=ORIENTED_EDGE($,$,$,#182,.T.);
+#2109=CARTESIAN_POINT($,(74.1757401764197,566.677020529259,0));
+#2110=DIRECTION($,(0,0,1));
+#2111=VECTOR($,#2110,1);
+#2112=LINE($,#2109,#2111);
+#2113=EDGE_CURVE($,#177,#1047,#2112,.T.);
+#2114=ORIENTED_EDGE($,$,$,#2113,.T.);
+#2115=ORIENTED_EDGE($,$,$,#1052,.F.);
+#2116=ORIENTED_EDGE($,$,$,#2096,.F.);
+#2117=EDGE_LOOP($,(#2108,#2114,#2115,#2116));
+#2118=FACE_OUTER_BOUND('',#2117,.T.);
+#2119=ADVANCED_FACE('',(#2118),#2107,.T.);
+#2120=CARTESIAN_POINT($,(74.1757401764197,566.677020529259,0));
+#2121=DIRECTION($,(-1,0,0));
+#2122=DIRECTION($,(0,0,1));
+#2123=AXIS2_PLACEMENT_3D($,#2120,#2121,#2122);
+#2124=PLANE($,#2123);
+#2125=ORIENTED_EDGE($,$,$,#190,.T.);
+#2126=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,0));
+#2127=DIRECTION($,(0,0,1));
+#2128=VECTOR($,#2127,1);
+#2129=LINE($,#2126,#2128);
+#2130=EDGE_CURVE($,#185,#1055,#2129,.T.);
+#2131=ORIENTED_EDGE($,$,$,#2130,.T.);
+#2132=ORIENTED_EDGE($,$,$,#1060,.F.);
+#2133=ORIENTED_EDGE($,$,$,#2113,.F.);
+#2134=EDGE_LOOP($,(#2125,#2131,#2132,#2133));
+#2135=FACE_OUTER_BOUND('',#2134,.T.);
+#2136=ADVANCED_FACE('',(#2135),#2124,.T.);
+#2137=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,0));
+#2138=DIRECTION($,(-1,0,0));
+#2139=DIRECTION($,(0,0,1));
+#2140=AXIS2_PLACEMENT_3D($,#2137,#2138,#2139);
+#2141=PLANE($,#2140);
+#2142=ORIENTED_EDGE($,$,$,#198,.T.);
+#2143=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,0));
+#2144=DIRECTION($,(0,0,1));
+#2145=VECTOR($,#2144,1);
+#2146=LINE($,#2143,#2145);
+#2147=EDGE_CURVE($,#193,#1063,#2146,.T.);
+#2148=ORIENTED_EDGE($,$,$,#2147,.T.);
+#2149=ORIENTED_EDGE($,$,$,#1068,.F.);
+#2150=ORIENTED_EDGE($,$,$,#2130,.F.);
+#2151=EDGE_LOOP($,(#2142,#2148,#2149,#2150));
+#2152=FACE_OUTER_BOUND('',#2151,.T.);
+#2153=ADVANCED_FACE('',(#2152),#2141,.T.);
+#2154=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,0));
+#2155=DIRECTION($,(0,1,0));
+#2156=DIRECTION($,(0,0,1));
+#2157=AXIS2_PLACEMENT_3D($,#2154,#2155,#2156);
+#2158=PLANE($,#2157);
+#2159=ORIENTED_EDGE($,$,$,#206,.T.);
+#2160=CARTESIAN_POINT($,(67.2677785945802,493.613740352839,-0));
+#2161=DIRECTION($,(0,0,1));
+#2162=VECTOR($,#2161,1);
+#2163=LINE($,#2160,#2162);
+#2164=EDGE_CURVE($,#201,#1071,#2163,.T.);
+#2165=ORIENTED_EDGE($,$,$,#2164,.T.);
+#2166=ORIENTED_EDGE($,$,$,#1076,.F.);
+#2167=ORIENTED_EDGE($,$,$,#2147,.F.);
+#2168=EDGE_LOOP($,(#2159,#2165,#2166,#2167));
+#2169=FACE_OUTER_BOUND('',#2168,.T.);
+#2170=ADVANCED_FACE('',(#2169),#2158,.T.);
+#2171=CARTESIAN_POINT($,(67.2677785945801,493.613740352839,0));
+#2172=DIRECTION($,(-0.70710678118655,-0.707106781186545,0));
+#2173=DIRECTION($,(0,0,1));
+#2174=AXIS2_PLACEMENT_3D($,#2171,#2172,#2173);
+#2175=PLANE($,#2174);
+#2176=ORIENTED_EDGE($,$,$,#214,.T.);
+#2177=CARTESIAN_POINT($,(72.4314258641949,488.450093083225,0));
+#2178=DIRECTION($,(0,0,1));
+#2179=VECTOR($,#2178,1);
+#2180=LINE($,#2177,#2179);
+#2181=EDGE_CURVE($,#209,#1079,#2180,.T.);
+#2182=ORIENTED_EDGE($,$,$,#2181,.T.);
+#2183=ORIENTED_EDGE($,$,$,#1084,.F.);
+#2184=ORIENTED_EDGE($,$,$,#2164,.F.);
+#2185=EDGE_LOOP($,(#2176,#2182,#2183,#2184));
+#2186=FACE_OUTER_BOUND('',#2185,.T.);
+#2187=ADVANCED_FACE('',(#2186),#2175,.T.);
+#2188=CARTESIAN_POINT($,(72.4314258641949,488.450093083225,0));
+#2189=DIRECTION($,(-0.707106781186559,0.707106781186536,0));
+#2190=DIRECTION($,(0,0,1));
+#2191=AXIS2_PLACEMENT_3D($,#2188,#2189,#2190);
+#2192=PLANE($,#2191);
+#2193=ORIENTED_EDGE($,$,$,#222,.T.);
+#2194=CARTESIAN_POINT($,(71.0843874460345,487.103054665064,0));
+#2195=DIRECTION($,(0,0,1));
+#2196=VECTOR($,#2195,1);
+#2197=LINE($,#2194,#2196);
+#2198=EDGE_CURVE($,#217,#1087,#2197,.T.);
+#2199=ORIENTED_EDGE($,$,$,#2198,.T.);
+#2200=ORIENTED_EDGE($,$,$,#1092,.F.);
+#2201=ORIENTED_EDGE($,$,$,#2181,.F.);
+#2202=EDGE_LOOP($,(#2193,#2199,#2200,#2201));
+#2203=FACE_OUTER_BOUND('',#2202,.T.);
+#2204=ADVANCED_FACE('',(#2203),#2192,.T.);
+#2205=CARTESIAN_POINT($,(71.0843874460345,487.103054665064,0));
+#2206=DIRECTION($,(0.70710678118655,0.707106781186545,0));
+#2207=DIRECTION($,(0,0,1));
+#2208=AXIS2_PLACEMENT_3D($,#2205,#2206,#2207);
+#2209=PLANE($,#2208);
+#2210=ORIENTED_EDGE($,$,$,#230,.T.);
+#2211=CARTESIAN_POINT($,(65.9207401764197,492.266701934679,-0));
+#2212=DIRECTION($,(0,0,1));
+#2213=VECTOR($,#2212,1);
+#2214=LINE($,#2211,#2213);
+#2215=EDGE_CURVE($,#225,#1095,#2214,.T.);
+#2216=ORIENTED_EDGE($,$,$,#2215,.T.);
+#2217=ORIENTED_EDGE($,$,$,#1100,.F.);
+#2218=ORIENTED_EDGE($,$,$,#2198,.F.);
+#2219=EDGE_LOOP($,(#2210,#2216,#2217,#2218));
+#2220=FACE_OUTER_BOUND('',#2219,.T.);
+#2221=ADVANCED_FACE('',(#2220),#2209,.T.);
+#2222=CARTESIAN_POINT($,(65.9207401764197,492.266701934679,0));
+#2223=DIRECTION($,(-1,0,0));
+#2224=DIRECTION($,(0,0,1));
+#2225=AXIS2_PLACEMENT_3D($,#2222,#2223,#2224);
+#2226=PLANE($,#2225);
+#2227=ORIENTED_EDGE($,$,$,#238,.T.);
+#2228=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,0));
+#2229=DIRECTION($,(0,0,1));
+#2230=VECTOR($,#2229,1);
+#2231=LINE($,#2228,#2230);
+#2232=EDGE_CURVE($,#233,#1103,#2231,.T.);
+#2233=ORIENTED_EDGE($,$,$,#2232,.T.);
+#2234=ORIENTED_EDGE($,$,$,#1108,.F.);
+#2235=ORIENTED_EDGE($,$,$,#2215,.F.);
+#2236=EDGE_LOOP($,(#2227,#2233,#2234,#2235));
+#2237=FACE_OUTER_BOUND('',#2236,.T.);
+#2238=ADVANCED_FACE('',(#2237),#2226,.T.);
+#2239=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,0));
+#2240=DIRECTION($,(0,1,0));
+#2241=DIRECTION($,(0,0,1));
+#2242=AXIS2_PLACEMENT_3D($,#2239,#2240,#2241);
+#2243=PLANE($,#2242);
+#2244=ORIENTED_EDGE($,$,$,#246,.T.);
+#2245=CARTESIAN_POINT($,(54.45,485.35874035284,0));
+#2246=DIRECTION($,(0,0,1));
+#2247=VECTOR($,#2246,1);
+#2248=LINE($,#2245,#2247);
+#2249=EDGE_CURVE($,#241,#1111,#2248,.T.);
+#2250=ORIENTED_EDGE($,$,$,#2249,.T.);
+#2251=ORIENTED_EDGE($,$,$,#1116,.F.);
+#2252=ORIENTED_EDGE($,$,$,#2232,.F.);
+#2253=EDGE_LOOP($,(#2244,#2250,#2251,#2252));
+#2254=FACE_OUTER_BOUND('',#2253,.T.);
+#2255=ADVANCED_FACE('',(#2254),#2243,.T.);
+#2256=CARTESIAN_POINT($,(54.45,485.35874035284,0));
+#2257=DIRECTION($,(0,1,0));
+#2258=DIRECTION($,(0,0,1));
+#2259=AXIS2_PLACEMENT_3D($,#2256,#2257,#2258);
+#2260=PLANE($,#2259);
+#2261=ORIENTED_EDGE($,$,$,#254,.T.);
+#2262=CARTESIAN_POINT($,(10,485.35874035284,-0));
+#2263=DIRECTION($,(0,0,1));
+#2264=VECTOR($,#2263,1);
+#2265=LINE($,#2262,#2264);
+#2266=EDGE_CURVE($,#249,#1119,#2265,.T.);
+#2267=ORIENTED_EDGE($,$,$,#2266,.T.);
+#2268=ORIENTED_EDGE($,$,$,#1124,.F.);
+#2269=ORIENTED_EDGE($,$,$,#2249,.F.);
+#2270=EDGE_LOOP($,(#2261,#2267,#2268,#2269));
+#2271=FACE_OUTER_BOUND('',#2270,.T.);
+#2272=ADVANCED_FACE('',(#2271),#2260,.T.);
+#2273=CARTESIAN_POINT($,(10,485.35874035284,0));
+#2274=DIRECTION($,(-1,0,0));
+#2275=DIRECTION($,(0,0,1));
+#2276=AXIS2_PLACEMENT_3D($,#2273,#2274,#2275);
+#2277=PLANE($,#2276);
+#2278=ORIENTED_EDGE($,$,$,#262,.T.);
+#2279=CARTESIAN_POINT($,(10,133.568740352839,-0));
+#2280=DIRECTION($,(0,0,1));
+#2281=VECTOR($,#2280,1);
+#2282=LINE($,#2279,#2281);
+#2283=EDGE_CURVE($,#257,#1127,#2282,.T.);
+#2284=ORIENTED_EDGE($,$,$,#2283,.T.);
+#2285=ORIENTED_EDGE($,$,$,#1132,.F.);
+#2286=ORIENTED_EDGE($,$,$,#2266,.F.);
+#2287=EDGE_LOOP($,(#2278,#2284,#2285,#2286));
+#2288=FACE_OUTER_BOUND('',#2287,.T.);
+#2289=ADVANCED_FACE('',(#2288),#2277,.T.);
+#2290=CARTESIAN_POINT($,(10,133.568740352839,0));
+#2291=DIRECTION($,(0,-1,0));
+#2292=DIRECTION($,(0,0,1));
+#2293=AXIS2_PLACEMENT_3D($,#2290,#2291,#2292);
+#2294=PLANE($,#2293);
+#2295=ORIENTED_EDGE($,$,$,#270,.T.);
+#2296=CARTESIAN_POINT($,(54.45,133.568740352839,0));
+#2297=DIRECTION($,(0,0,1));
+#2298=VECTOR($,#2297,1);
+#2299=LINE($,#2296,#2298);
+#2300=EDGE_CURVE($,#265,#1135,#2299,.T.);
+#2301=ORIENTED_EDGE($,$,$,#2300,.T.);
+#2302=ORIENTED_EDGE($,$,$,#1140,.F.);
+#2303=ORIENTED_EDGE($,$,$,#2283,.F.);
+#2304=EDGE_LOOP($,(#2295,#2301,#2302,#2303));
+#2305=FACE_OUTER_BOUND('',#2304,.T.);
+#2306=ADVANCED_FACE('',(#2305),#2294,.T.);
+#2307=CARTESIAN_POINT($,(54.45,133.568740352839,0));
+#2308=DIRECTION($,(0,-1,0));
+#2309=DIRECTION($,(0,0,1));
+#2310=AXIS2_PLACEMENT_3D($,#2307,#2308,#2309);
+#2311=PLANE($,#2310);
+#2312=ORIENTED_EDGE($,$,$,#278,.T.);
+#2313=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,0));
+#2314=DIRECTION($,(0,0,1));
+#2315=VECTOR($,#2314,1);
+#2316=LINE($,#2313,#2315);
+#2317=EDGE_CURVE($,#273,#1143,#2316,.T.);
+#2318=ORIENTED_EDGE($,$,$,#2317,.T.);
+#2319=ORIENTED_EDGE($,$,$,#1148,.F.);
+#2320=ORIENTED_EDGE($,$,$,#2300,.F.);
+#2321=EDGE_LOOP($,(#2312,#2318,#2319,#2320));
+#2322=FACE_OUTER_BOUND('',#2321,.T.);
+#2323=ADVANCED_FACE('',(#2322),#2311,.T.);
+#2324=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,0));
+#2325=DIRECTION($,(-1,0,0));
+#2326=DIRECTION($,(0,0,1));
+#2327=AXIS2_PLACEMENT_3D($,#2324,#2325,#2326);
+#2328=PLANE($,#2327);
+#2329=ORIENTED_EDGE($,$,$,#286,.T.);
+#2330=CARTESIAN_POINT($,(65.9207401764197,126.660778771,-0));
+#2331=DIRECTION($,(0,0,1));
+#2332=VECTOR($,#2331,1);
+#2333=LINE($,#2330,#2332);
+#2334=EDGE_CURVE($,#281,#1151,#2333,.T.);
+#2335=ORIENTED_EDGE($,$,$,#2334,.T.);
+#2336=ORIENTED_EDGE($,$,$,#1156,.F.);
+#2337=ORIENTED_EDGE($,$,$,#2317,.F.);
+#2338=EDGE_LOOP($,(#2329,#2335,#2336,#2337));
+#2339=FACE_OUTER_BOUND('',#2338,.T.);
+#2340=ADVANCED_FACE('',(#2339),#2328,.T.);
+#2341=CARTESIAN_POINT($,(65.9207401764197,126.660778771,0));
+#2342=DIRECTION($,(0.707106781186547,-0.707106781186547,0));
+#2343=DIRECTION($,(0,0,1));
+#2344=AXIS2_PLACEMENT_3D($,#2341,#2342,#2343);
+#2345=PLANE($,#2344);
+#2346=ORIENTED_EDGE($,$,$,#294,.T.);
+#2347=CARTESIAN_POINT($,(71.0843874460345,131.824426040615,0));
+#2348=DIRECTION($,(0,0,1));
+#2349=VECTOR($,#2348,1);
+#2350=LINE($,#2347,#2349);
+#2351=EDGE_CURVE($,#289,#1159,#2350,.T.);
+#2352=ORIENTED_EDGE($,$,$,#2351,.T.);
+#2353=ORIENTED_EDGE($,$,$,#1164,.F.);
+#2354=ORIENTED_EDGE($,$,$,#2334,.F.);
+#2355=EDGE_LOOP($,(#2346,#2352,#2353,#2354));
+#2356=FACE_OUTER_BOUND('',#2355,.T.);
+#2357=ADVANCED_FACE('',(#2356),#2345,.T.);
+#2358=CARTESIAN_POINT($,(71.0843874460345,131.824426040615,0));
+#2359=DIRECTION($,(-0.707106781186544,-0.707106781186551,0));
+#2360=DIRECTION($,(0,0,1));
+#2361=AXIS2_PLACEMENT_3D($,#2358,#2359,#2360);
+#2362=PLANE($,#2361);
+#2363=ORIENTED_EDGE($,$,$,#302,.T.);
+#2364=CARTESIAN_POINT($,(72.4314258641949,130.477387622454,0));
+#2365=DIRECTION($,(0,0,1));
+#2366=VECTOR($,#2365,1);
+#2367=LINE($,#2364,#2366);
+#2368=EDGE_CURVE($,#297,#1167,#2367,.T.);
+#2369=ORIENTED_EDGE($,$,$,#2368,.T.);
+#2370=ORIENTED_EDGE($,$,$,#1172,.F.);
+#2371=ORIENTED_EDGE($,$,$,#2351,.F.);
+#2372=EDGE_LOOP($,(#2363,#2369,#2370,#2371));
+#2373=FACE_OUTER_BOUND('',#2372,.T.);
+#2374=ADVANCED_FACE('',(#2373),#2362,.T.);
+#2375=CARTESIAN_POINT($,(72.4314258641949,130.477387622454,0));
+#2376=DIRECTION($,(-0.707106781186547,0.707106781186548,0));
+#2377=DIRECTION($,(0,0,1));
+#2378=AXIS2_PLACEMENT_3D($,#2375,#2376,#2377);
+#2379=PLANE($,#2378);
+#2380=ORIENTED_EDGE($,$,$,#310,.T.);
+#2381=CARTESIAN_POINT($,(67.2677785945801,125.313740352839,-0));
+#2382=DIRECTION($,(0,0,1));
+#2383=VECTOR($,#2382,1);
+#2384=LINE($,#2381,#2383);
+#2385=EDGE_CURVE($,#305,#1175,#2384,.T.);
+#2386=ORIENTED_EDGE($,$,$,#2385,.T.);
+#2387=ORIENTED_EDGE($,$,$,#1180,.F.);
+#2388=ORIENTED_EDGE($,$,$,#2368,.F.);
+#2389=EDGE_LOOP($,(#2380,#2386,#2387,#2388));
+#2390=FACE_OUTER_BOUND('',#2389,.T.);
+#2391=ADVANCED_FACE('',(#2390),#2379,.T.);
+#2392=CARTESIAN_POINT($,(67.2677785945801,125.313740352839,0));
+#2393=DIRECTION($,(0,-1,0));
+#2394=DIRECTION($,(0,0,1));
+#2395=AXIS2_PLACEMENT_3D($,#2392,#2393,#2394);
+#2396=PLANE($,#2395);
+#2397=ORIENTED_EDGE($,$,$,#318,.T.);
+#2398=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,0));
+#2399=DIRECTION($,(0,0,1));
+#2400=VECTOR($,#2399,1);
+#2401=LINE($,#2398,#2400);
+#2402=EDGE_CURVE($,#313,#1183,#2401,.T.);
+#2403=ORIENTED_EDGE($,$,$,#2402,.T.);
+#2404=ORIENTED_EDGE($,$,$,#1188,.F.);
+#2405=ORIENTED_EDGE($,$,$,#2385,.F.);
+#2406=EDGE_LOOP($,(#2397,#2403,#2404,#2405));
+#2407=FACE_OUTER_BOUND('',#2406,.T.);
+#2408=ADVANCED_FACE('',(#2407),#2396,.T.);
+#2409=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,0));
+#2410=DIRECTION($,(-1,0,0));
+#2411=DIRECTION($,(0,0,1));
+#2412=AXIS2_PLACEMENT_3D($,#2409,#2410,#2411);
+#2413=PLANE($,#2412);
+#2414=ORIENTED_EDGE($,$,$,#326,.T.);
+#2415=CARTESIAN_POINT($,(74.1757401764197,113.84300017642,0));
+#2416=DIRECTION($,(0,0,1));
+#2417=VECTOR($,#2416,1);
+#2418=LINE($,#2415,#2417);
+#2419=EDGE_CURVE($,#321,#1191,#2418,.T.);
+#2420=ORIENTED_EDGE($,$,$,#2419,.T.);
+#2421=ORIENTED_EDGE($,$,$,#1196,.F.);
+#2422=ORIENTED_EDGE($,$,$,#2402,.F.);
+#2423=EDGE_LOOP($,(#2414,#2420,#2421,#2422));
+#2424=FACE_OUTER_BOUND('',#2423,.T.);
+#2425=ADVANCED_FACE('',(#2424),#2413,.T.);
+#2426=CARTESIAN_POINT($,(74.1757401764197,113.84300017642,0));
+#2427=DIRECTION($,(-1,0,0));
+#2428=DIRECTION($,(0,0,1));
+#2429=AXIS2_PLACEMENT_3D($,#2426,#2427,#2428);
+#2430=PLANE($,#2429);
+#2431=ORIENTED_EDGE($,$,$,#334,.T.);
+#2432=CARTESIAN_POINT($,(74.1757401764197,52.2504601764197,0));
+#2433=DIRECTION($,(0,0,1));
+#2434=VECTOR($,#2433,1);
+#2435=LINE($,#2432,#2434);
+#2436=EDGE_CURVE($,#329,#1199,#2435,.T.);
+#2437=ORIENTED_EDGE($,$,$,#2436,.T.);
+#2438=ORIENTED_EDGE($,$,$,#1204,.F.);
+#2439=ORIENTED_EDGE($,$,$,#2419,.F.);
+#2440=EDGE_LOOP($,(#2431,#2437,#2438,#2439));
+#2441=FACE_OUTER_BOUND('',#2440,.T.);
+#2442=ADVANCED_FACE('',(#2441),#2430,.T.);
+#2443=CARTESIAN_POINT($,(74.1757401764197,52.2504601764197,0));
+#2444=DIRECTION($,(-1,0,0));
+#2445=DIRECTION($,(0,0,1));
+#2446=AXIS2_PLACEMENT_3D($,#2443,#2444,#2445);
+#2447=PLANE($,#2446);
+#2448=ORIENTED_EDGE($,$,$,#342,.T.);
+#2449=CARTESIAN_POINT($,(74.1757401764197,40.77972,0));
+#2450=DIRECTION($,(0,0,1));
+#2451=VECTOR($,#2450,1);
+#2452=LINE($,#2449,#2451);
+#2453=EDGE_CURVE($,#337,#1207,#2452,.T.);
+#2454=ORIENTED_EDGE($,$,$,#2453,.T.);
+#2455=ORIENTED_EDGE($,$,$,#1212,.F.);
+#2456=ORIENTED_EDGE($,$,$,#2436,.F.);
+#2457=EDGE_LOOP($,(#2448,#2454,#2455,#2456));
+#2458=FACE_OUTER_BOUND('',#2457,.T.);
+#2459=ADVANCED_FACE('',(#2458),#2447,.T.);
+#2460=CARTESIAN_POINT($,(74.1757401764197,40.77972,0));
+#2461=DIRECTION($,(-1,0,0));
+#2462=DIRECTION($,(0,0,1));
+#2463=AXIS2_PLACEMENT_3D($,#2460,#2461,#2462);
+#2464=PLANE($,#2463);
+#2465=ORIENTED_EDGE($,$,$,#350,.T.);
+#2466=CARTESIAN_POINT($,(74.1757401764197,10,-0));
+#2467=DIRECTION($,(0,0,1));
+#2468=VECTOR($,#2467,1);
+#2469=LINE($,#2466,#2468);
+#2470=EDGE_CURVE($,#345,#1215,#2469,.T.);
+#2471=ORIENTED_EDGE($,$,$,#2470,.T.);
+#2472=ORIENTED_EDGE($,$,$,#1220,.F.);
+#2473=ORIENTED_EDGE($,$,$,#2453,.F.);
+#2474=EDGE_LOOP($,(#2465,#2471,#2472,#2473));
+#2475=FACE_OUTER_BOUND('',#2474,.T.);
+#2476=ADVANCED_FACE('',(#2475),#2464,.T.);
+#2477=CARTESIAN_POINT($,(74.1757401764197,10,0));
+#2478=DIRECTION($,(0,-1,0));
+#2479=DIRECTION($,(0,0,1));
+#2480=AXIS2_PLACEMENT_3D($,#2477,#2478,#2479);
+#2481=PLANE($,#2480);
+#2482=ORIENTED_EDGE($,$,$,#358,.T.);
+#2483=CARTESIAN_POINT($,(298.96574017642,10,-0));
+#2484=DIRECTION($,(0,0,1));
+#2485=VECTOR($,#2484,1);
+#2486=LINE($,#2483,#2485);
+#2487=EDGE_CURVE($,#353,#1223,#2486,.T.);
+#2488=ORIENTED_EDGE($,$,$,#2487,.T.);
+#2489=ORIENTED_EDGE($,$,$,#1228,.F.);
+#2490=ORIENTED_EDGE($,$,$,#2470,.F.);
+#2491=EDGE_LOOP($,(#2482,#2488,#2489,#2490));
+#2492=FACE_OUTER_BOUND('',#2491,.T.);
+#2493=ADVANCED_FACE('',(#2492),#2481,.T.);
+#2494=CARTESIAN_POINT($,(298.96574017642,10,0));
+#2495=DIRECTION($,(1,0,0));
+#2496=DIRECTION($,(0,0,1));
+#2497=AXIS2_PLACEMENT_3D($,#2494,#2495,#2496);
+#2498=PLANE($,#2497);
+#2499=ORIENTED_EDGE($,$,$,#366,.T.);
+#2500=CARTESIAN_POINT($,(298.96574017642,40.77972,0));
+#2501=DIRECTION($,(0,0,1));
+#2502=VECTOR($,#2501,1);
+#2503=LINE($,#2500,#2502);
+#2504=EDGE_CURVE($,#361,#1231,#2503,.T.);
+#2505=ORIENTED_EDGE($,$,$,#2504,.T.);
+#2506=ORIENTED_EDGE($,$,$,#1236,.F.);
+#2507=ORIENTED_EDGE($,$,$,#2487,.F.);
+#2508=EDGE_LOOP($,(#2499,#2505,#2506,#2507));
+#2509=FACE_OUTER_BOUND('',#2508,.T.);
+#2510=ADVANCED_FACE('',(#2509),#2498,.T.);
+#2511=CARTESIAN_POINT($,(298.96574017642,40.77972,0));
+#2512=DIRECTION($,(1,0,0));
+#2513=DIRECTION($,(0,0,1));
+#2514=AXIS2_PLACEMENT_3D($,#2511,#2512,#2513);
+#2515=PLANE($,#2514);
+#2516=ORIENTED_EDGE($,$,$,#374,.T.);
+#2517=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,0));
+#2518=DIRECTION($,(0,0,1));
+#2519=VECTOR($,#2518,1);
+#2520=LINE($,#2517,#2519);
+#2521=EDGE_CURVE($,#369,#1239,#2520,.T.);
+#2522=ORIENTED_EDGE($,$,$,#2521,.T.);
+#2523=ORIENTED_EDGE($,$,$,#1244,.F.);
+#2524=ORIENTED_EDGE($,$,$,#2504,.F.);
+#2525=EDGE_LOOP($,(#2516,#2522,#2523,#2524));
+#2526=FACE_OUTER_BOUND('',#2525,.T.);
+#2527=ADVANCED_FACE('',(#2526),#2515,.T.);
+#2528=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,0));
+#2529=DIRECTION($,(1,0,0));
+#2530=DIRECTION($,(0,0,1));
+#2531=AXIS2_PLACEMENT_3D($,#2528,#2529,#2530);
+#2532=PLANE($,#2531);
+#2533=ORIENTED_EDGE($,$,$,#382,.T.);
+#2534=CARTESIAN_POINT($,(298.96574017642,113.84300017642,0));
+#2535=DIRECTION($,(0,0,1));
+#2536=VECTOR($,#2535,1);
+#2537=LINE($,#2534,#2536);
+#2538=EDGE_CURVE($,#377,#1247,#2537,.T.);
+#2539=ORIENTED_EDGE($,$,$,#2538,.T.);
+#2540=ORIENTED_EDGE($,$,$,#1252,.F.);
+#2541=ORIENTED_EDGE($,$,$,#2521,.F.);
+#2542=EDGE_LOOP($,(#2533,#2539,#2540,#2541));
+#2543=FACE_OUTER_BOUND('',#2542,.T.);
+#2544=ADVANCED_FACE('',(#2543),#2532,.T.);
+#2545=CARTESIAN_POINT($,(298.96574017642,113.84300017642,0));
+#2546=DIRECTION($,(1,0,0));
+#2547=DIRECTION($,(0,0,1));
+#2548=AXIS2_PLACEMENT_3D($,#2545,#2546,#2547);
+#2549=PLANE($,#2548);
+#2550=ORIENTED_EDGE($,$,$,#390,.T.);
+#2551=CARTESIAN_POINT($,(298.96574017642,125.313740352839,0));
+#2552=DIRECTION($,(0,0,1));
+#2553=VECTOR($,#2552,1);
+#2554=LINE($,#2551,#2553);
+#2555=EDGE_CURVE($,#385,#1255,#2554,.T.);
+#2556=ORIENTED_EDGE($,$,$,#2555,.T.);
+#2557=ORIENTED_EDGE($,$,$,#1260,.F.);
+#2558=ORIENTED_EDGE($,$,$,#2538,.F.);
+#2559=EDGE_LOOP($,(#2550,#2556,#2557,#2558));
+#2560=FACE_OUTER_BOUND('',#2559,.T.);
+#2561=ADVANCED_FACE('',(#2560),#2549,.T.);
+#2562=CARTESIAN_POINT($,(298.96574017642,125.313740352839,0));
+#2563=DIRECTION($,(0,-1,0));
+#2564=DIRECTION($,(0,0,1));
+#2565=AXIS2_PLACEMENT_3D($,#2562,#2563,#2564);
+#2566=PLANE($,#2565);
+#2567=ORIENTED_EDGE($,$,$,#398,.T.);
+#2568=CARTESIAN_POINT($,(305.873701758259,125.313740352839,-0));
+#2569=DIRECTION($,(0,0,1));
+#2570=VECTOR($,#2569,1);
+#2571=LINE($,#2568,#2570);
+#2572=EDGE_CURVE($,#393,#1263,#2571,.T.);
+#2573=ORIENTED_EDGE($,$,$,#2572,.T.);
+#2574=ORIENTED_EDGE($,$,$,#1268,.F.);
+#2575=ORIENTED_EDGE($,$,$,#2555,.F.);
+#2576=EDGE_LOOP($,(#2567,#2573,#2574,#2575));
+#2577=FACE_OUTER_BOUND('',#2576,.T.);
+#2578=ADVANCED_FACE('',(#2577),#2566,.T.);
+#2579=CARTESIAN_POINT($,(305.873701758259,125.313740352839,0));
+#2580=DIRECTION($,(0.707106781186549,0.707106781186546,0));
+#2581=DIRECTION($,(0,0,1));
+#2582=AXIS2_PLACEMENT_3D($,#2579,#2580,#2581);
+#2583=PLANE($,#2582);
+#2584=ORIENTED_EDGE($,$,$,#406,.T.);
+#2585=CARTESIAN_POINT($,(300.710054488645,130.477387622454,0));
+#2586=DIRECTION($,(0,0,1));
+#2587=VECTOR($,#2586,1);
+#2588=LINE($,#2585,#2587);
+#2589=EDGE_CURVE($,#401,#1271,#2588,.T.);
+#2590=ORIENTED_EDGE($,$,$,#2589,.T.);
+#2591=ORIENTED_EDGE($,$,$,#1276,.F.);
+#2592=ORIENTED_EDGE($,$,$,#2572,.F.);
+#2593=EDGE_LOOP($,(#2584,#2590,#2591,#2592));
+#2594=FACE_OUTER_BOUND('',#2593,.T.);
+#2595=ADVANCED_FACE('',(#2594),#2583,.T.);
+#2596=CARTESIAN_POINT($,(300.710054488645,130.477387622454,0));
+#2597=DIRECTION($,(0.707106781186548,-0.707106781186548,0));
+#2598=DIRECTION($,(0,0,1));
+#2599=AXIS2_PLACEMENT_3D($,#2596,#2597,#2598);
+#2600=PLANE($,#2599);
+#2601=ORIENTED_EDGE($,$,$,#414,.T.);
+#2602=CARTESIAN_POINT($,(302.057092906805,131.824426040615,0));
+#2603=DIRECTION($,(0,0,1));
+#2604=VECTOR($,#2603,1);
+#2605=LINE($,#2602,#2604);
+#2606=EDGE_CURVE($,#409,#1279,#2605,.T.);
+#2607=ORIENTED_EDGE($,$,$,#2606,.T.);
+#2608=ORIENTED_EDGE($,$,$,#1284,.F.);
+#2609=ORIENTED_EDGE($,$,$,#2589,.F.);
+#2610=EDGE_LOOP($,(#2601,#2607,#2608,#2609));
+#2611=FACE_OUTER_BOUND('',#2610,.T.);
+#2612=ADVANCED_FACE('',(#2611),#2600,.T.);
+#2613=CARTESIAN_POINT($,(302.057092906805,131.824426040615,0));
+#2614=DIRECTION($,(-0.707106781186546,-0.707106781186549,0));
+#2615=DIRECTION($,(0,0,1));
+#2616=AXIS2_PLACEMENT_3D($,#2613,#2614,#2615);
+#2617=PLANE($,#2616);
+#2618=ORIENTED_EDGE($,$,$,#422,.T.);
+#2619=CARTESIAN_POINT($,(307.22074017642,126.660778771,-0));
+#2620=DIRECTION($,(0,0,1));
+#2621=VECTOR($,#2620,1);
+#2622=LINE($,#2619,#2621);
+#2623=EDGE_CURVE($,#417,#1287,#2622,.T.);
+#2624=ORIENTED_EDGE($,$,$,#2623,.T.);
+#2625=ORIENTED_EDGE($,$,$,#1292,.F.);
+#2626=ORIENTED_EDGE($,$,$,#2606,.F.);
+#2627=EDGE_LOOP($,(#2618,#2624,#2625,#2626));
+#2628=FACE_OUTER_BOUND('',#2627,.T.);
+#2629=ADVANCED_FACE('',(#2628),#2617,.T.);
+#2630=CARTESIAN_POINT($,(307.22074017642,126.660778771,0));
+#2631=DIRECTION($,(1,0,0));
+#2632=DIRECTION($,(0,0,1));
+#2633=AXIS2_PLACEMENT_3D($,#2630,#2631,#2632);
+#2634=PLANE($,#2633);
+#2635=ORIENTED_EDGE($,$,$,#430,.T.);
+#2636=CARTESIAN_POINT($,(307.22074017642,133.568740352839,0));
+#2637=DIRECTION($,(0,0,1));
+#2638=VECTOR($,#2637,1);
+#2639=LINE($,#2636,#2638);
+#2640=EDGE_CURVE($,#425,#1295,#2639,.T.);
+#2641=ORIENTED_EDGE($,$,$,#2640,.T.);
+#2642=ORIENTED_EDGE($,$,$,#1300,.F.);
+#2643=ORIENTED_EDGE($,$,$,#2623,.F.);
+#2644=EDGE_LOOP($,(#2635,#2641,#2642,#2643));
+#2645=FACE_OUTER_BOUND('',#2644,.T.);
+#2646=ADVANCED_FACE('',(#2645),#2634,.T.);
+#2647=CARTESIAN_POINT($,(307.22074017642,133.568740352839,0));
+#2648=DIRECTION($,(0,-1,0));
+#2649=DIRECTION($,(0,0,1));
+#2650=AXIS2_PLACEMENT_3D($,#2647,#2648,#2649);
+#2651=PLANE($,#2650);
+#2652=ORIENTED_EDGE($,$,$,#438,.T.);
+#2653=CARTESIAN_POINT($,(318.691480352839,133.568740352839,0));
+#2654=DIRECTION($,(0,0,1));
+#2655=VECTOR($,#2654,1);
+#2656=LINE($,#2653,#2655);
+#2657=EDGE_CURVE($,#433,#1303,#2656,.T.);
+#2658=ORIENTED_EDGE($,$,$,#2657,.T.);
+#2659=ORIENTED_EDGE($,$,$,#1308,.F.);
+#2660=ORIENTED_EDGE($,$,$,#2640,.F.);
+#2661=EDGE_LOOP($,(#2652,#2658,#2659,#2660));
+#2662=FACE_OUTER_BOUND('',#2661,.T.);
+#2663=ADVANCED_FACE('',(#2662),#2651,.T.);
+#2664=CARTESIAN_POINT($,(318.691480352839,133.568740352839,0));
+#2665=DIRECTION($,(0,-1,0));
+#2666=DIRECTION($,(0,0,1));
+#2667=AXIS2_PLACEMENT_3D($,#2664,#2665,#2666);
+#2668=PLANE($,#2667);
+#2669=ORIENTED_EDGE($,$,$,#446,.T.);
+#2670=CARTESIAN_POINT($,(347.802420352839,133.568740352839,-0));
+#2671=DIRECTION($,(0,0,1));
+#2672=VECTOR($,#2671,1);
+#2673=LINE($,#2670,#2672);
+#2674=EDGE_CURVE($,#441,#1311,#2673,.T.);
+#2675=ORIENTED_EDGE($,$,$,#2674,.T.);
+#2676=ORIENTED_EDGE($,$,$,#1316,.F.);
+#2677=ORIENTED_EDGE($,$,$,#2657,.F.);
+#2678=EDGE_LOOP($,(#2669,#2675,#2676,#2677));
+#2679=FACE_OUTER_BOUND('',#2678,.T.);
+#2680=ADVANCED_FACE('',(#2679),#2668,.T.);
+#2681=CARTESIAN_POINT($,(347.802420352839,133.568740352839,0));
+#2682=DIRECTION($,(1,0,0));
+#2683=DIRECTION($,(0,0,1));
+#2684=AXIS2_PLACEMENT_3D($,#2681,#2682,#2683);
+#2685=PLANE($,#2684);
+#2686=ORIENTED_EDGE($,$,$,#454,.T.);
+#2687=CARTESIAN_POINT($,(347.802420352839,248.351340352839,0));
+#2688=DIRECTION($,(0,0,1));
+#2689=VECTOR($,#2688,1);
+#2690=LINE($,#2687,#2689);
+#2691=EDGE_CURVE($,#449,#1319,#2690,.T.);
+#2692=ORIENTED_EDGE($,$,$,#2691,.T.);
+#2693=ORIENTED_EDGE($,$,$,#1324,.F.);
+#2694=ORIENTED_EDGE($,$,$,#2674,.F.);
+#2695=EDGE_LOOP($,(#2686,#2692,#2693,#2694));
+#2696=FACE_OUTER_BOUND('',#2695,.T.);
+#2697=ADVANCED_FACE('',(#2696),#2685,.T.);
+#2698=CARTESIAN_POINT($,(347.802420352839,248.351340352839,0));
+#2699=DIRECTION($,(0,-1,0));
+#2700=DIRECTION($,(0,0,1));
+#2701=AXIS2_PLACEMENT_3D($,#2698,#2699,#2700);
+#2702=PLANE($,#2701);
+#2703=ORIENTED_EDGE($,$,$,#462,.T.);
+#2704=CARTESIAN_POINT($,(353.537790441049,248.351340352839,0));
+#2705=DIRECTION($,(0,0,1));
+#2706=VECTOR($,#2705,1);
+#2707=LINE($,#2704,#2706);
+#2708=EDGE_CURVE($,#457,#1327,#2707,.T.);
+#2709=ORIENTED_EDGE($,$,$,#2708,.T.);
+#2710=ORIENTED_EDGE($,$,$,#1332,.F.);
+#2711=ORIENTED_EDGE($,$,$,#2691,.F.);
+#2712=EDGE_LOOP($,(#2703,#2709,#2710,#2711));
+#2713=FACE_OUTER_BOUND('',#2712,.T.);
+#2714=ADVANCED_FACE('',(#2713),#2702,.T.);
+#2715=CARTESIAN_POINT($,(353.537790441049,248.351340352839,0));
+#2716=DIRECTION($,(0,-1,0));
+#2717=DIRECTION($,(0,0,1));
+#2718=AXIS2_PLACEMENT_3D($,#2715,#2716,#2717);
+#2719=PLANE($,#2718);
+#2720=ORIENTED_EDGE($,$,$,#468,.T.);
+#2721=ORIENTED_EDGE($,$,$,#1758,.T.);
+#2722=ORIENTED_EDGE($,$,$,#1338,.F.);
+#2723=ORIENTED_EDGE($,$,$,#2708,.F.);
+#2724=EDGE_LOOP($,(#2720,#2721,#2722,#2723));
+#2725=FACE_OUTER_BOUND('',#2724,.T.);
+#2726=ADVANCED_FACE('',(#2725),#2719,.T.);
+#2727=CARTESIAN_POINT($,(269.12074017642,164.000480352839,0));
+#2728=DIRECTION($,(0,0,1));
+#2729=DIRECTION($,(1,0,0));
+#2730=AXIS2_PLACEMENT_3D($,#2727,#2728,#2729);
+#2731=CYLINDRICAL_SURFACE($,#2730,7.9375);
+#2732=ORIENTED_EDGE($,$,$,#490,.T.);
+#2733=CARTESIAN_POINT($,(277.05824017642,164.000480352839,0));
+#2734=DIRECTION($,(0,0,1));
+#2735=VECTOR($,#2734,1);
+#2736=LINE($,#2733,#2735);
+#2737=EDGE_CURVE($,#473,#1343,#2736,.T.);
+#2738=ORIENTED_EDGE($,$,$,#2737,.T.);
+#2739=ORIENTED_EDGE($,$,$,#1360,.F.);
+#2740=CARTESIAN_POINT($,(261.18324017642,164.000480352839,0));
+#2741=DIRECTION($,(0,0,1));
+#2742=VECTOR($,#2741,1);
+#2743=LINE($,#2740,#2742);
+#2744=EDGE_CURVE($,#475,#1345,#2743,.T.);
+#2745=ORIENTED_EDGE($,$,$,#2744,.F.);
+#2746=EDGE_LOOP($,(#2732,#2738,#2739,#2745));
+#2747=FACE_OUTER_BOUND('',#2746,.T.);
+#2748=ADVANCED_FACE('',(#2747),#2731,.F.);
+#2749=CARTESIAN_POINT($,(269.12074017642,164.000480352839,0));
+#2750=DIRECTION($,(0,0,1));
+#2751=DIRECTION($,(1,0,0));
+#2752=AXIS2_PLACEMENT_3D($,#2749,#2750,#2751);
+#2753=CYLINDRICAL_SURFACE($,#2752,7.9375);
+#2754=ORIENTED_EDGE($,$,$,#482,.T.);
+#2755=ORIENTED_EDGE($,$,$,#2744,.T.);
+#2756=ORIENTED_EDGE($,$,$,#1352,.F.);
+#2757=ORIENTED_EDGE($,$,$,#2737,.F.);
+#2758=EDGE_LOOP($,(#2754,#2755,#2756,#2757));
+#2759=FACE_OUTER_BOUND('',#2758,.T.);
+#2760=ADVANCED_FACE('',(#2759),#2753,.F.);
+#2761=CARTESIAN_POINT($,(269.12074017642,208.450480352839,0));
+#2762=DIRECTION($,(0,0,1));
+#2763=DIRECTION($,(1,0,0));
+#2764=AXIS2_PLACEMENT_3D($,#2761,#2762,#2763);
+#2765=CYLINDRICAL_SURFACE($,#2764,7.9375);
+#2766=ORIENTED_EDGE($,$,$,#512,.T.);
+#2767=CARTESIAN_POINT($,(277.05824017642,208.450480352839,0));
+#2768=DIRECTION($,(0,0,1));
+#2769=VECTOR($,#2768,1);
+#2770=LINE($,#2767,#2769);
+#2771=EDGE_CURVE($,#495,#1365,#2770,.T.);
+#2772=ORIENTED_EDGE($,$,$,#2771,.T.);
+#2773=ORIENTED_EDGE($,$,$,#1382,.F.);
+#2774=CARTESIAN_POINT($,(261.18324017642,208.450480352839,0));
+#2775=DIRECTION($,(0,0,1));
+#2776=VECTOR($,#2775,1);
+#2777=LINE($,#2774,#2776);
+#2778=EDGE_CURVE($,#497,#1367,#2777,.T.);
+#2779=ORIENTED_EDGE($,$,$,#2778,.F.);
+#2780=EDGE_LOOP($,(#2766,#2772,#2773,#2779));
+#2781=FACE_OUTER_BOUND('',#2780,.T.);
+#2782=ADVANCED_FACE('',(#2781),#2765,.F.);
+#2783=CARTESIAN_POINT($,(269.12074017642,208.450480352839,0));
+#2784=DIRECTION($,(0,0,1));
+#2785=DIRECTION($,(1,0,0));
+#2786=AXIS2_PLACEMENT_3D($,#2783,#2784,#2785);
+#2787=CYLINDRICAL_SURFACE($,#2786,7.9375);
+#2788=ORIENTED_EDGE($,$,$,#504,.T.);
+#2789=ORIENTED_EDGE($,$,$,#2778,.T.);
+#2790=ORIENTED_EDGE($,$,$,#1374,.F.);
+#2791=ORIENTED_EDGE($,$,$,#2771,.F.);
+#2792=EDGE_LOOP($,(#2788,#2789,#2790,#2791));
+#2793=FACE_OUTER_BOUND('',#2792,.T.);
+#2794=ADVANCED_FACE('',(#2793),#2787,.F.);
+#2795=CARTESIAN_POINT($,(269.12074017642,252.90048035284,0));
+#2796=DIRECTION($,(0,0,1));
+#2797=DIRECTION($,(1,0,0));
+#2798=AXIS2_PLACEMENT_3D($,#2795,#2796,#2797);
+#2799=CYLINDRICAL_SURFACE($,#2798,7.9375);
+#2800=ORIENTED_EDGE($,$,$,#534,.T.);
+#2801=CARTESIAN_POINT($,(277.05824017642,252.90048035284,0));
+#2802=DIRECTION($,(0,0,1));
+#2803=VECTOR($,#2802,1);
+#2804=LINE($,#2801,#2803);
+#2805=EDGE_CURVE($,#517,#1387,#2804,.T.);
+#2806=ORIENTED_EDGE($,$,$,#2805,.T.);
+#2807=ORIENTED_EDGE($,$,$,#1404,.F.);
+#2808=CARTESIAN_POINT($,(261.18324017642,252.90048035284,0));
+#2809=DIRECTION($,(0,0,1));
+#2810=VECTOR($,#2809,1);
+#2811=LINE($,#2808,#2810);
+#2812=EDGE_CURVE($,#519,#1389,#2811,.T.);
+#2813=ORIENTED_EDGE($,$,$,#2812,.F.);
+#2814=EDGE_LOOP($,(#2800,#2806,#2807,#2813));
+#2815=FACE_OUTER_BOUND('',#2814,.T.);
+#2816=ADVANCED_FACE('',(#2815),#2799,.F.);
+#2817=CARTESIAN_POINT($,(269.12074017642,252.90048035284,0));
+#2818=DIRECTION($,(0,0,1));
+#2819=DIRECTION($,(1,0,0));
+#2820=AXIS2_PLACEMENT_3D($,#2817,#2818,#2819);
+#2821=CYLINDRICAL_SURFACE($,#2820,7.9375);
+#2822=ORIENTED_EDGE($,$,$,#526,.T.);
+#2823=ORIENTED_EDGE($,$,$,#2812,.T.);
+#2824=ORIENTED_EDGE($,$,$,#1396,.F.);
+#2825=ORIENTED_EDGE($,$,$,#2805,.F.);
+#2826=EDGE_LOOP($,(#2822,#2823,#2824,#2825));
+#2827=FACE_OUTER_BOUND('',#2826,.T.);
+#2828=ADVANCED_FACE('',(#2827),#2821,.F.);
+#2829=CARTESIAN_POINT($,(269.12074017642,297.350480352839,0));
+#2830=DIRECTION($,(0,0,1));
+#2831=DIRECTION($,(1,0,0));
+#2832=AXIS2_PLACEMENT_3D($,#2829,#2830,#2831);
+#2833=CYLINDRICAL_SURFACE($,#2832,7.9375);
+#2834=ORIENTED_EDGE($,$,$,#556,.T.);
+#2835=CARTESIAN_POINT($,(277.05824017642,297.350480352839,0));
+#2836=DIRECTION($,(0,0,1));
+#2837=VECTOR($,#2836,1);
+#2838=LINE($,#2835,#2837);
+#2839=EDGE_CURVE($,#539,#1409,#2838,.T.);
+#2840=ORIENTED_EDGE($,$,$,#2839,.T.);
+#2841=ORIENTED_EDGE($,$,$,#1426,.F.);
+#2842=CARTESIAN_POINT($,(261.18324017642,297.350480352839,0));
+#2843=DIRECTION($,(0,0,1));
+#2844=VECTOR($,#2843,1);
+#2845=LINE($,#2842,#2844);
+#2846=EDGE_CURVE($,#541,#1411,#2845,.T.);
+#2847=ORIENTED_EDGE($,$,$,#2846,.F.);
+#2848=EDGE_LOOP($,(#2834,#2840,#2841,#2847));
+#2849=FACE_OUTER_BOUND('',#2848,.T.);
+#2850=ADVANCED_FACE('',(#2849),#2833,.F.);
+#2851=CARTESIAN_POINT($,(269.12074017642,297.350480352839,0));
+#2852=DIRECTION($,(0,0,1));
+#2853=DIRECTION($,(1,0,0));
+#2854=AXIS2_PLACEMENT_3D($,#2851,#2852,#2853);
+#2855=CYLINDRICAL_SURFACE($,#2854,7.9375);
+#2856=ORIENTED_EDGE($,$,$,#548,.T.);
+#2857=ORIENTED_EDGE($,$,$,#2846,.T.);
+#2858=ORIENTED_EDGE($,$,$,#1418,.F.);
+#2859=ORIENTED_EDGE($,$,$,#2839,.F.);
+#2860=EDGE_LOOP($,(#2856,#2857,#2858,#2859));
+#2861=FACE_OUTER_BOUND('',#2860,.T.);
+#2862=ADVANCED_FACE('',(#2861),#2855,.F.);
+#2863=CARTESIAN_POINT($,(84.9707401764198,16.34746,0));
+#2864=DIRECTION($,(0,0,1));
+#2865=DIRECTION($,(1,0,0));
+#2866=AXIS2_PLACEMENT_3D($,#2863,#2864,#2865);
+#2867=CYLINDRICAL_SURFACE($,#2866,5.5626);
+#2868=ORIENTED_EDGE($,$,$,#578,.T.);
+#2869=CARTESIAN_POINT($,(90.5333401764198,16.34746,0));
+#2870=DIRECTION($,(0,0,1));
+#2871=VECTOR($,#2870,1);
+#2872=LINE($,#2869,#2871);
+#2873=EDGE_CURVE($,#561,#1431,#2872,.T.);
+#2874=ORIENTED_EDGE($,$,$,#2873,.T.);
+#2875=ORIENTED_EDGE($,$,$,#1448,.F.);
+#2876=CARTESIAN_POINT($,(79.4081401764197,16.34746,0));
+#2877=DIRECTION($,(0,0,1));
+#2878=VECTOR($,#2877,1);
+#2879=LINE($,#2876,#2878);
+#2880=EDGE_CURVE($,#563,#1433,#2879,.T.);
+#2881=ORIENTED_EDGE($,$,$,#2880,.F.);
+#2882=EDGE_LOOP($,(#2868,#2874,#2875,#2881));
+#2883=FACE_OUTER_BOUND('',#2882,.T.);
+#2884=ADVANCED_FACE('',(#2883),#2867,.F.);
+#2885=CARTESIAN_POINT($,(84.9707401764198,16.34746,0));
+#2886=DIRECTION($,(0,0,1));
+#2887=DIRECTION($,(1,0,0));
+#2888=AXIS2_PLACEMENT_3D($,#2885,#2886,#2887);
+#2889=CYLINDRICAL_SURFACE($,#2888,5.5626);
+#2890=ORIENTED_EDGE($,$,$,#570,.T.);
+#2891=ORIENTED_EDGE($,$,$,#2880,.T.);
+#2892=ORIENTED_EDGE($,$,$,#1440,.F.);
+#2893=ORIENTED_EDGE($,$,$,#2873,.F.);
+#2894=EDGE_LOOP($,(#2890,#2891,#2892,#2893));
+#2895=FACE_OUTER_BOUND('',#2894,.T.);
+#2896=ADVANCED_FACE('',(#2895),#2889,.F.);
+#2897=CARTESIAN_POINT($,(288.17074017642,16.34746,0));
+#2898=DIRECTION($,(0,0,1));
+#2899=DIRECTION($,(1,0,0));
+#2900=AXIS2_PLACEMENT_3D($,#2897,#2898,#2899);
+#2901=CYLINDRICAL_SURFACE($,#2900,5.5626);
+#2902=ORIENTED_EDGE($,$,$,#600,.T.);
+#2903=CARTESIAN_POINT($,(293.73334017642,16.34746,0));
+#2904=DIRECTION($,(0,0,1));
+#2905=VECTOR($,#2904,1);
+#2906=LINE($,#2903,#2905);
+#2907=EDGE_CURVE($,#583,#1453,#2906,.T.);
+#2908=ORIENTED_EDGE($,$,$,#2907,.T.);
+#2909=ORIENTED_EDGE($,$,$,#1470,.F.);
+#2910=CARTESIAN_POINT($,(282.60814017642,16.34746,0));
+#2911=DIRECTION($,(0,0,1));
+#2912=VECTOR($,#2911,1);
+#2913=LINE($,#2910,#2912);
+#2914=EDGE_CURVE($,#585,#1455,#2913,.T.);
+#2915=ORIENTED_EDGE($,$,$,#2914,.F.);
+#2916=EDGE_LOOP($,(#2902,#2908,#2909,#2915));
+#2917=FACE_OUTER_BOUND('',#2916,.T.);
+#2918=ADVANCED_FACE('',(#2917),#2901,.F.);
+#2919=CARTESIAN_POINT($,(288.17074017642,16.34746,0));
+#2920=DIRECTION($,(0,0,1));
+#2921=DIRECTION($,(1,0,0));
+#2922=AXIS2_PLACEMENT_3D($,#2919,#2920,#2921);
+#2923=CYLINDRICAL_SURFACE($,#2922,5.5626);
+#2924=ORIENTED_EDGE($,$,$,#592,.T.);
+#2925=ORIENTED_EDGE($,$,$,#2914,.T.);
+#2926=ORIENTED_EDGE($,$,$,#1462,.F.);
+#2927=ORIENTED_EDGE($,$,$,#2907,.F.);
+#2928=EDGE_LOOP($,(#2924,#2925,#2926,#2927));
+#2929=FACE_OUTER_BOUND('',#2928,.T.);
+#2930=ADVANCED_FACE('',(#2929),#2923,.F.);
+#2931=CARTESIAN_POINT($,(244.20334017642,398.747280352839,0));
+#2932=DIRECTION($,(0,0,1));
+#2933=DIRECTION($,(1,0,0));
+#2934=AXIS2_PLACEMENT_3D($,#2931,#2932,#2933);
+#2935=CYLINDRICAL_SURFACE($,#2934,19.05);
+#2936=ORIENTED_EDGE($,$,$,#622,.T.);
+#2937=CARTESIAN_POINT($,(263.25334017642,398.747280352839,0));
+#2938=DIRECTION($,(0,0,1));
+#2939=VECTOR($,#2938,1);
+#2940=LINE($,#2937,#2939);
+#2941=EDGE_CURVE($,#605,#1475,#2940,.T.);
+#2942=ORIENTED_EDGE($,$,$,#2941,.T.);
+#2943=ORIENTED_EDGE($,$,$,#1492,.F.);
+#2944=CARTESIAN_POINT($,(225.15334017642,398.747280352839,0));
+#2945=DIRECTION($,(0,0,1));
+#2946=VECTOR($,#2945,1);
+#2947=LINE($,#2944,#2946);
+#2948=EDGE_CURVE($,#607,#1477,#2947,.T.);
+#2949=ORIENTED_EDGE($,$,$,#2948,.F.);
+#2950=EDGE_LOOP($,(#2936,#2942,#2943,#2949));
+#2951=FACE_OUTER_BOUND('',#2950,.T.);
+#2952=ADVANCED_FACE('',(#2951),#2935,.F.);
+#2953=CARTESIAN_POINT($,(244.20334017642,398.747280352839,0));
+#2954=DIRECTION($,(0,0,1));
+#2955=DIRECTION($,(1,0,0));
+#2956=AXIS2_PLACEMENT_3D($,#2953,#2954,#2955);
+#2957=CYLINDRICAL_SURFACE($,#2956,19.05);
+#2958=ORIENTED_EDGE($,$,$,#614,.T.);
+#2959=ORIENTED_EDGE($,$,$,#2948,.T.);
+#2960=ORIENTED_EDGE($,$,$,#1484,.F.);
+#2961=ORIENTED_EDGE($,$,$,#2941,.F.);
+#2962=EDGE_LOOP($,(#2958,#2959,#2960,#2961));
+#2963=FACE_OUTER_BOUND('',#2962,.T.);
+#2964=ADVANCED_FACE('',(#2963),#2957,.F.);
+#2965=CARTESIAN_POINT($,(155.30334017642,424.147280352839,0));
+#2966=DIRECTION($,(0,0,1));
+#2967=DIRECTION($,(1,0,0));
+#2968=AXIS2_PLACEMENT_3D($,#2965,#2966,#2967);
+#2969=CYLINDRICAL_SURFACE($,#2968,25.4);
+#2970=ORIENTED_EDGE($,$,$,#644,.T.);
+#2971=CARTESIAN_POINT($,(180.70334017642,424.147280352839,0));
+#2972=DIRECTION($,(0,0,1));
+#2973=VECTOR($,#2972,1);
+#2974=LINE($,#2971,#2973);
+#2975=EDGE_CURVE($,#627,#1497,#2974,.T.);
+#2976=ORIENTED_EDGE($,$,$,#2975,.T.);
+#2977=ORIENTED_EDGE($,$,$,#1514,.F.);
+#2978=CARTESIAN_POINT($,(129.90334017642,424.147280352839,0));
+#2979=DIRECTION($,(0,0,1));
+#2980=VECTOR($,#2979,1);
+#2981=LINE($,#2978,#2980);
+#2982=EDGE_CURVE($,#629,#1499,#2981,.T.);
+#2983=ORIENTED_EDGE($,$,$,#2982,.F.);
+#2984=EDGE_LOOP($,(#2970,#2976,#2977,#2983));
+#2985=FACE_OUTER_BOUND('',#2984,.T.);
+#2986=ADVANCED_FACE('',(#2985),#2969,.F.);
+#2987=CARTESIAN_POINT($,(155.30334017642,424.147280352839,0));
+#2988=DIRECTION($,(0,0,1));
+#2989=DIRECTION($,(1,0,0));
+#2990=AXIS2_PLACEMENT_3D($,#2987,#2988,#2989);
+#2991=CYLINDRICAL_SURFACE($,#2990,25.4);
+#2992=ORIENTED_EDGE($,$,$,#636,.T.);
+#2993=ORIENTED_EDGE($,$,$,#2982,.T.);
+#2994=ORIENTED_EDGE($,$,$,#1506,.F.);
+#2995=ORIENTED_EDGE($,$,$,#2975,.F.);
+#2996=EDGE_LOOP($,(#2992,#2993,#2994,#2995));
+#2997=FACE_OUTER_BOUND('',#2996,.T.);
+#2998=ADVANCED_FACE('',(#2997),#2991,.F.);
+#2999=CARTESIAN_POINT($,(288.17074017642,603.550300705679,0));
+#3000=DIRECTION($,(0,0,1));
+#3001=DIRECTION($,(1,0,0));
+#3002=AXIS2_PLACEMENT_3D($,#2999,#3000,#3001);
+#3003=CYLINDRICAL_SURFACE($,#3002,5.5626);
+#3004=ORIENTED_EDGE($,$,$,#666,.T.);
+#3005=CARTESIAN_POINT($,(293.73334017642,603.550300705679,0));
+#3006=DIRECTION($,(0,0,1));
+#3007=VECTOR($,#3006,1);
+#3008=LINE($,#3005,#3007);
+#3009=EDGE_CURVE($,#649,#1519,#3008,.T.);
+#3010=ORIENTED_EDGE($,$,$,#3009,.T.);
+#3011=ORIENTED_EDGE($,$,$,#1536,.F.);
+#3012=CARTESIAN_POINT($,(282.60814017642,603.550300705679,0));
+#3013=DIRECTION($,(0,0,1));
+#3014=VECTOR($,#3013,1);
+#3015=LINE($,#3012,#3014);
+#3016=EDGE_CURVE($,#651,#1521,#3015,.T.);
+#3017=ORIENTED_EDGE($,$,$,#3016,.F.);
+#3018=EDGE_LOOP($,(#3004,#3010,#3011,#3017));
+#3019=FACE_OUTER_BOUND('',#3018,.T.);
+#3020=ADVANCED_FACE('',(#3019),#3003,.F.);
+#3021=CARTESIAN_POINT($,(288.17074017642,603.550300705679,0));
+#3022=DIRECTION($,(0,0,1));
+#3023=DIRECTION($,(1,0,0));
+#3024=AXIS2_PLACEMENT_3D($,#3021,#3022,#3023);
+#3025=CYLINDRICAL_SURFACE($,#3024,5.5626);
+#3026=ORIENTED_EDGE($,$,$,#658,.T.);
+#3027=ORIENTED_EDGE($,$,$,#3016,.T.);
+#3028=ORIENTED_EDGE($,$,$,#1528,.F.);
+#3029=ORIENTED_EDGE($,$,$,#3009,.F.);
+#3030=EDGE_LOOP($,(#3026,#3027,#3028,#3029));
+#3031=FACE_OUTER_BOUND('',#3030,.T.);
+#3032=ADVANCED_FACE('',(#3031),#3025,.F.);
+#3033=CARTESIAN_POINT($,(84.9707401764198,603.550300705679,0));
+#3034=DIRECTION($,(0,0,1));
+#3035=DIRECTION($,(1,0,0));
+#3036=AXIS2_PLACEMENT_3D($,#3033,#3034,#3035);
+#3037=CYLINDRICAL_SURFACE($,#3036,5.5626);
+#3038=ORIENTED_EDGE($,$,$,#688,.T.);
+#3039=CARTESIAN_POINT($,(90.5333401764198,603.550300705679,0));
+#3040=DIRECTION($,(0,0,1));
+#3041=VECTOR($,#3040,1);
+#3042=LINE($,#3039,#3041);
+#3043=EDGE_CURVE($,#671,#1541,#3042,.T.);
+#3044=ORIENTED_EDGE($,$,$,#3043,.T.);
+#3045=ORIENTED_EDGE($,$,$,#1558,.F.);
+#3046=CARTESIAN_POINT($,(79.4081401764197,603.550300705679,0));
+#3047=DIRECTION($,(0,0,1));
+#3048=VECTOR($,#3047,1);
+#3049=LINE($,#3046,#3048);
+#3050=EDGE_CURVE($,#673,#1543,#3049,.T.);
+#3051=ORIENTED_EDGE($,$,$,#3050,.F.);
+#3052=EDGE_LOOP($,(#3038,#3044,#3045,#3051));
+#3053=FACE_OUTER_BOUND('',#3052,.T.);
+#3054=ADVANCED_FACE('',(#3053),#3037,.F.);
+#3055=CARTESIAN_POINT($,(84.9707401764198,603.550300705679,0));
+#3056=DIRECTION($,(0,0,1));
+#3057=DIRECTION($,(1,0,0));
+#3058=AXIS2_PLACEMENT_3D($,#3055,#3056,#3057);
+#3059=CYLINDRICAL_SURFACE($,#3058,5.5626);
+#3060=ORIENTED_EDGE($,$,$,#680,.T.);
+#3061=ORIENTED_EDGE($,$,$,#3050,.T.);
+#3062=ORIENTED_EDGE($,$,$,#1550,.F.);
+#3063=ORIENTED_EDGE($,$,$,#3043,.F.);
+#3064=EDGE_LOOP($,(#3060,#3061,#3062,#3063));
+#3065=FACE_OUTER_BOUND('',#3064,.T.);
+#3066=ADVANCED_FACE('',(#3065),#3059,.F.);
+#3067=CARTESIAN_POINT($,(384.273586493049,311.851340352839,0));
+#3068=DIRECTION($,(0,0,1));
+#3069=DIRECTION($,(1,0,0));
+#3070=AXIS2_PLACEMENT_3D($,#3067,#3068,#3069);
+#3071=CYLINDRICAL_SURFACE($,#3070,13.5255);
+#3072=ORIENTED_EDGE($,$,$,#710,.T.);
+#3073=CARTESIAN_POINT($,(397.799086493049,311.851340352839,0));
+#3074=DIRECTION($,(0,0,1));
+#3075=VECTOR($,#3074,1);
+#3076=LINE($,#3073,#3075);
+#3077=EDGE_CURVE($,#693,#1563,#3076,.T.);
+#3078=ORIENTED_EDGE($,$,$,#3077,.T.);
+#3079=ORIENTED_EDGE($,$,$,#1580,.F.);
+#3080=CARTESIAN_POINT($,(370.748086493049,311.851340352839,0));
+#3081=DIRECTION($,(0,0,1));
+#3082=VECTOR($,#3081,1);
+#3083=LINE($,#3080,#3082);
+#3084=EDGE_CURVE($,#695,#1565,#3083,.T.);
+#3085=ORIENTED_EDGE($,$,$,#3084,.F.);
+#3086=EDGE_LOOP($,(#3072,#3078,#3079,#3085));
+#3087=FACE_OUTER_BOUND('',#3086,.T.);
+#3088=ADVANCED_FACE('',(#3087),#3071,.F.);
+#3089=CARTESIAN_POINT($,(384.273586493049,311.851340352839,0));
+#3090=DIRECTION($,(0,0,1));
+#3091=DIRECTION($,(1,0,0));
+#3092=AXIS2_PLACEMENT_3D($,#3089,#3090,#3091);
+#3093=CYLINDRICAL_SURFACE($,#3092,13.5255);
+#3094=ORIENTED_EDGE($,$,$,#702,.T.);
+#3095=ORIENTED_EDGE($,$,$,#3084,.T.);
+#3096=ORIENTED_EDGE($,$,$,#1572,.F.);
+#3097=ORIENTED_EDGE($,$,$,#3077,.F.);
+#3098=EDGE_LOOP($,(#3094,#3095,#3096,#3097));
+#3099=FACE_OUTER_BOUND('',#3098,.T.);
+#3100=ADVANCED_FACE('',(#3099),#3093,.F.);
+#3101=CARTESIAN_POINT($,(370.303586493049,292.801340352839,0));
+#3102=DIRECTION($,(0,0,1));
+#3103=DIRECTION($,(1,0,0));
+#3104=AXIS2_PLACEMENT_3D($,#3101,#3102,#3103);
+#3105=CYLINDRICAL_SURFACE($,#3104,2.38125);
+#3106=ORIENTED_EDGE($,$,$,#732,.T.);
+#3107=CARTESIAN_POINT($,(372.684836493049,292.801340352839,0));
+#3108=DIRECTION($,(0,0,1));
+#3109=VECTOR($,#3108,1);
+#3110=LINE($,#3107,#3109);
+#3111=EDGE_CURVE($,#715,#1585,#3110,.T.);
+#3112=ORIENTED_EDGE($,$,$,#3111,.T.);
+#3113=ORIENTED_EDGE($,$,$,#1602,.F.);
+#3114=CARTESIAN_POINT($,(367.922336493049,292.801340352839,0));
+#3115=DIRECTION($,(0,0,1));
+#3116=VECTOR($,#3115,1);
+#3117=LINE($,#3114,#3116);
+#3118=EDGE_CURVE($,#717,#1587,#3117,.T.);
+#3119=ORIENTED_EDGE($,$,$,#3118,.F.);
+#3120=EDGE_LOOP($,(#3106,#3112,#3113,#3119));
+#3121=FACE_OUTER_BOUND('',#3120,.T.);
+#3122=ADVANCED_FACE('',(#3121),#3105,.F.);
+#3123=CARTESIAN_POINT($,(370.303586493049,292.801340352839,0));
+#3124=DIRECTION($,(0,0,1));
+#3125=DIRECTION($,(1,0,0));
+#3126=AXIS2_PLACEMENT_3D($,#3123,#3124,#3125);
+#3127=CYLINDRICAL_SURFACE($,#3126,2.38125);
+#3128=ORIENTED_EDGE($,$,$,#724,.T.);
+#3129=ORIENTED_EDGE($,$,$,#3118,.T.);
+#3130=ORIENTED_EDGE($,$,$,#1594,.F.);
+#3131=ORIENTED_EDGE($,$,$,#3111,.F.);
+#3132=EDGE_LOOP($,(#3128,#3129,#3130,#3131));
+#3133=FACE_OUTER_BOUND('',#3132,.T.);
+#3134=ADVANCED_FACE('',(#3133),#3127,.F.);
+#3135=CARTESIAN_POINT($,(370.303586493049,330.901340352839,0));
+#3136=DIRECTION($,(0,0,1));
+#3137=DIRECTION($,(1,0,0));
+#3138=AXIS2_PLACEMENT_3D($,#3135,#3136,#3137);
+#3139=CYLINDRICAL_SURFACE($,#3138,2.38125);
+#3140=ORIENTED_EDGE($,$,$,#754,.T.);
+#3141=CARTESIAN_POINT($,(372.684836493049,330.901340352839,0));
+#3142=DIRECTION($,(0,0,1));
+#3143=VECTOR($,#3142,1);
+#3144=LINE($,#3141,#3143);
+#3145=EDGE_CURVE($,#737,#1607,#3144,.T.);
+#3146=ORIENTED_EDGE($,$,$,#3145,.T.);
+#3147=ORIENTED_EDGE($,$,$,#1624,.F.);
+#3148=CARTESIAN_POINT($,(367.922336493049,330.901340352839,0));
+#3149=DIRECTION($,(0,0,1));
+#3150=VECTOR($,#3149,1);
+#3151=LINE($,#3148,#3150);
+#3152=EDGE_CURVE($,#739,#1609,#3151,.T.);
+#3153=ORIENTED_EDGE($,$,$,#3152,.F.);
+#3154=EDGE_LOOP($,(#3140,#3146,#3147,#3153));
+#3155=FACE_OUTER_BOUND('',#3154,.T.);
+#3156=ADVANCED_FACE('',(#3155),#3139,.F.);
+#3157=CARTESIAN_POINT($,(370.303586493049,330.901340352839,0));
+#3158=DIRECTION($,(0,0,1));
+#3159=DIRECTION($,(1,0,0));
+#3160=AXIS2_PLACEMENT_3D($,#3157,#3158,#3159);
+#3161=CYLINDRICAL_SURFACE($,#3160,2.38125);
+#3162=ORIENTED_EDGE($,$,$,#746,.T.);
+#3163=ORIENTED_EDGE($,$,$,#3152,.T.);
+#3164=ORIENTED_EDGE($,$,$,#1616,.F.);
+#3165=ORIENTED_EDGE($,$,$,#3145,.F.);
+#3166=EDGE_LOOP($,(#3162,#3163,#3164,#3165));
+#3167=FACE_OUTER_BOUND('',#3166,.T.);
+#3168=ADVANCED_FACE('',(#3167),#3161,.F.);
+#3169=CARTESIAN_POINT($,(402.053586493049,292.801340352839,0));
+#3170=DIRECTION($,(0,0,1));
+#3171=DIRECTION($,(1,0,0));
+#3172=AXIS2_PLACEMENT_3D($,#3169,#3170,#3171);
+#3173=CYLINDRICAL_SURFACE($,#3172,2.38125);
+#3174=ORIENTED_EDGE($,$,$,#776,.T.);
+#3175=CARTESIAN_POINT($,(404.434836493049,292.801340352839,0));
+#3176=DIRECTION($,(0,0,1));
+#3177=VECTOR($,#3176,1);
+#3178=LINE($,#3175,#3177);
+#3179=EDGE_CURVE($,#759,#1629,#3178,.T.);
+#3180=ORIENTED_EDGE($,$,$,#3179,.T.);
+#3181=ORIENTED_EDGE($,$,$,#1646,.F.);
+#3182=CARTESIAN_POINT($,(399.672336493049,292.801340352839,0));
+#3183=DIRECTION($,(0,0,1));
+#3184=VECTOR($,#3183,1);
+#3185=LINE($,#3182,#3184);
+#3186=EDGE_CURVE($,#761,#1631,#3185,.T.);
+#3187=ORIENTED_EDGE($,$,$,#3186,.F.);
+#3188=EDGE_LOOP($,(#3174,#3180,#3181,#3187));
+#3189=FACE_OUTER_BOUND('',#3188,.T.);
+#3190=ADVANCED_FACE('',(#3189),#3173,.F.);
+#3191=CARTESIAN_POINT($,(402.053586493049,292.801340352839,0));
+#3192=DIRECTION($,(0,0,1));
+#3193=DIRECTION($,(1,0,0));
+#3194=AXIS2_PLACEMENT_3D($,#3191,#3192,#3193);
+#3195=CYLINDRICAL_SURFACE($,#3194,2.38125);
+#3196=ORIENTED_EDGE($,$,$,#768,.T.);
+#3197=ORIENTED_EDGE($,$,$,#3186,.T.);
+#3198=ORIENTED_EDGE($,$,$,#1638,.F.);
+#3199=ORIENTED_EDGE($,$,$,#3179,.F.);
+#3200=EDGE_LOOP($,(#3196,#3197,#3198,#3199));
+#3201=FACE_OUTER_BOUND('',#3200,.T.);
+#3202=ADVANCED_FACE('',(#3201),#3195,.F.);
+#3203=CARTESIAN_POINT($,(402.053586493049,330.901340352839,0));
+#3204=DIRECTION($,(0,0,1));
+#3205=DIRECTION($,(1,0,0));
+#3206=AXIS2_PLACEMENT_3D($,#3203,#3204,#3205);
+#3207=CYLINDRICAL_SURFACE($,#3206,2.38125);
+#3208=ORIENTED_EDGE($,$,$,#798,.T.);
+#3209=CARTESIAN_POINT($,(404.434836493049,330.901340352839,0));
+#3210=DIRECTION($,(0,0,1));
+#3211=VECTOR($,#3210,1);
+#3212=LINE($,#3209,#3211);
+#3213=EDGE_CURVE($,#781,#1651,#3212,.T.);
+#3214=ORIENTED_EDGE($,$,$,#3213,.T.);
+#3215=ORIENTED_EDGE($,$,$,#1668,.F.);
+#3216=CARTESIAN_POINT($,(399.672336493049,330.901340352839,0));
+#3217=DIRECTION($,(0,0,1));
+#3218=VECTOR($,#3217,1);
+#3219=LINE($,#3216,#3218);
+#3220=EDGE_CURVE($,#783,#1653,#3219,.T.);
+#3221=ORIENTED_EDGE($,$,$,#3220,.F.);
+#3222=EDGE_LOOP($,(#3208,#3214,#3215,#3221));
+#3223=FACE_OUTER_BOUND('',#3222,.T.);
+#3224=ADVANCED_FACE('',(#3223),#3207,.F.);
+#3225=CARTESIAN_POINT($,(402.053586493049,330.901340352839,0));
+#3226=DIRECTION($,(0,0,1));
+#3227=DIRECTION($,(1,0,0));
+#3228=AXIS2_PLACEMENT_3D($,#3225,#3226,#3227);
+#3229=CYLINDRICAL_SURFACE($,#3228,2.38125);
+#3230=ORIENTED_EDGE($,$,$,#790,.T.);
+#3231=ORIENTED_EDGE($,$,$,#3220,.T.);
+#3232=ORIENTED_EDGE($,$,$,#1660,.F.);
+#3233=ORIENTED_EDGE($,$,$,#3213,.F.);
+#3234=EDGE_LOOP($,(#3230,#3231,#3232,#3233));
+#3235=FACE_OUTER_BOUND('',#3234,.T.);
+#3236=ADVANCED_FACE('',(#3235),#3229,.F.);
+#3237=CARTESIAN_POINT($,(126.72834017642,189.298880352839,0));
+#3238=DIRECTION($,(-1,0,0));
+#3239=DIRECTION($,(0,0,1));
+#3240=AXIS2_PLACEMENT_3D($,#3237,#3238,#3239);
+#3241=PLANE($,#3240);
+#3242=ORIENTED_EDGE($,$,$,#832,.T.);
+#3243=CARTESIAN_POINT($,(126.72834017642,278.198880352839,-0));
+#3244=DIRECTION($,(0,0,1));
+#3245=VECTOR($,#3244,1);
+#3246=LINE($,#3243,#3245);
+#3247=EDGE_CURVE($,#821,#1691,#3246,.T.);
+#3248=ORIENTED_EDGE($,$,$,#3247,.T.);
+#3249=ORIENTED_EDGE($,$,$,#1702,.F.);
+#3250=CARTESIAN_POINT($,(126.72834017642,189.298880352839,0));
+#3251=DIRECTION($,(0,0,1));
+#3252=VECTOR($,#3251,1);
+#3253=LINE($,#3250,#3252);
+#3254=EDGE_CURVE($,#805,#1675,#3253,.T.);
+#3255=ORIENTED_EDGE($,$,$,#3254,.F.);
+#3256=EDGE_LOOP($,(#3242,#3248,#3249,#3255));
+#3257=FACE_OUTER_BOUND('',#3256,.T.);
+#3258=ADVANCED_FACE('',(#3257),#3241,.T.);
+#3259=CARTESIAN_POINT($,(126.72834017642,278.198880352839,0));
+#3260=DIRECTION($,(0,-1,0));
+#3261=DIRECTION($,(0,0,1));
+#3262=AXIS2_PLACEMENT_3D($,#3259,#3260,#3261);
+#3263=PLANE($,#3262);
+#3264=ORIENTED_EDGE($,$,$,#826,.T.);
+#3265=CARTESIAN_POINT($,(107.67834017642,278.198880352839,-0));
+#3266=DIRECTION($,(0,0,1));
+#3267=VECTOR($,#3266,1);
+#3268=LINE($,#3265,#3267);
+#3269=EDGE_CURVE($,#813,#1683,#3268,.T.);
+#3270=ORIENTED_EDGE($,$,$,#3269,.T.);
+#3271=ORIENTED_EDGE($,$,$,#1696,.F.);
+#3272=ORIENTED_EDGE($,$,$,#3247,.F.);
+#3273=EDGE_LOOP($,(#3264,#3270,#3271,#3272));
+#3274=FACE_OUTER_BOUND('',#3273,.T.);
+#3275=ADVANCED_FACE('',(#3274),#3263,.T.);
+#3276=CARTESIAN_POINT($,(107.67834017642,278.198880352839,0));
+#3277=DIRECTION($,(1,0,0));
+#3278=DIRECTION($,(0,0,1));
+#3279=AXIS2_PLACEMENT_3D($,#3276,#3277,#3278);
+#3280=PLANE($,#3279);
+#3281=ORIENTED_EDGE($,$,$,#818,.T.);
+#3282=CARTESIAN_POINT($,(107.67834017642,189.298880352839,-0));
+#3283=DIRECTION($,(0,0,1));
+#3284=VECTOR($,#3283,1);
+#3285=LINE($,#3282,#3284);
+#3286=EDGE_CURVE($,#803,#1673,#3285,.T.);
+#3287=ORIENTED_EDGE($,$,$,#3286,.T.);
+#3288=ORIENTED_EDGE($,$,$,#1688,.F.);
+#3289=ORIENTED_EDGE($,$,$,#3269,.F.);
+#3290=EDGE_LOOP($,(#3281,#3287,#3288,#3289));
+#3291=FACE_OUTER_BOUND('',#3290,.T.);
+#3292=ADVANCED_FACE('',(#3291),#3280,.T.);
+#3293=CARTESIAN_POINT($,(107.67834017642,189.298880352839,0));
+#3294=DIRECTION($,(0,1,0));
+#3295=DIRECTION($,(0,0,1));
+#3296=AXIS2_PLACEMENT_3D($,#3293,#3294,#3295);
+#3297=PLANE($,#3296);
+#3298=ORIENTED_EDGE($,$,$,#810,.T.);
+#3299=ORIENTED_EDGE($,$,$,#3254,.T.);
+#3300=ORIENTED_EDGE($,$,$,#1680,.F.);
+#3301=ORIENTED_EDGE($,$,$,#3286,.F.);
+#3302=EDGE_LOOP($,(#3298,#3299,#3300,#3301));
+#3303=FACE_OUTER_BOUND('',#3302,.T.);
+#3304=ADVANCED_FACE('',(#3303),#3297,.T.);
+#3305=CARTESIAN_POINT($,(190.22834017642,189.298880352839,0));
+#3306=DIRECTION($,(-1,0,0));
+#3307=DIRECTION($,(0,0,1));
+#3308=AXIS2_PLACEMENT_3D($,#3305,#3306,#3307);
+#3309=PLANE($,#3308);
+#3310=ORIENTED_EDGE($,$,$,#866,.T.);
+#3311=CARTESIAN_POINT($,(190.22834017642,278.198880352839,-0));
+#3312=DIRECTION($,(0,0,1));
+#3313=VECTOR($,#3312,1);
+#3314=LINE($,#3311,#3313);
+#3315=EDGE_CURVE($,#855,#1725,#3314,.T.);
+#3316=ORIENTED_EDGE($,$,$,#3315,.T.);
+#3317=ORIENTED_EDGE($,$,$,#1736,.F.);
+#3318=CARTESIAN_POINT($,(190.22834017642,189.298880352839,0));
+#3319=DIRECTION($,(0,0,1));
+#3320=VECTOR($,#3319,1);
+#3321=LINE($,#3318,#3320);
+#3322=EDGE_CURVE($,#839,#1709,#3321,.T.);
+#3323=ORIENTED_EDGE($,$,$,#3322,.F.);
+#3324=EDGE_LOOP($,(#3310,#3316,#3317,#3323));
+#3325=FACE_OUTER_BOUND('',#3324,.T.);
+#3326=ADVANCED_FACE('',(#3325),#3309,.T.);
+#3327=CARTESIAN_POINT($,(190.22834017642,278.198880352839,0));
+#3328=DIRECTION($,(0,-1,0));
+#3329=DIRECTION($,(0,0,1));
+#3330=AXIS2_PLACEMENT_3D($,#3327,#3328,#3329);
+#3331=PLANE($,#3330);
+#3332=ORIENTED_EDGE($,$,$,#860,.T.);
+#3333=CARTESIAN_POINT($,(171.17834017642,278.198880352839,-0));
+#3334=DIRECTION($,(0,0,1));
+#3335=VECTOR($,#3334,1);
+#3336=LINE($,#3333,#3335);
+#3337=EDGE_CURVE($,#847,#1717,#3336,.T.);
+#3338=ORIENTED_EDGE($,$,$,#3337,.T.);
+#3339=ORIENTED_EDGE($,$,$,#1730,.F.);
+#3340=ORIENTED_EDGE($,$,$,#3315,.F.);
+#3341=EDGE_LOOP($,(#3332,#3338,#3339,#3340));
+#3342=FACE_OUTER_BOUND('',#3341,.T.);
+#3343=ADVANCED_FACE('',(#3342),#3331,.T.);
+#3344=CARTESIAN_POINT($,(171.17834017642,278.198880352839,0));
+#3345=DIRECTION($,(1,0,0));
+#3346=DIRECTION($,(0,0,1));
+#3347=AXIS2_PLACEMENT_3D($,#3344,#3345,#3346);
+#3348=PLANE($,#3347);
+#3349=ORIENTED_EDGE($,$,$,#852,.T.);
+#3350=CARTESIAN_POINT($,(171.17834017642,189.298880352839,-0));
+#3351=DIRECTION($,(0,0,1));
+#3352=VECTOR($,#3351,1);
+#3353=LINE($,#3350,#3352);
+#3354=EDGE_CURVE($,#837,#1707,#3353,.T.);
+#3355=ORIENTED_EDGE($,$,$,#3354,.T.);
+#3356=ORIENTED_EDGE($,$,$,#1722,.F.);
+#3357=ORIENTED_EDGE($,$,$,#3337,.F.);
+#3358=EDGE_LOOP($,(#3349,#3355,#3356,#3357));
+#3359=FACE_OUTER_BOUND('',#3358,.T.);
+#3360=ADVANCED_FACE('',(#3359),#3348,.T.);
+#3361=CARTESIAN_POINT($,(171.17834017642,189.298880352839,0));
+#3362=DIRECTION($,(0,1,0));
+#3363=DIRECTION($,(0,0,1));
+#3364=AXIS2_PLACEMENT_3D($,#3361,#3362,#3363);
+#3365=PLANE($,#3364);
+#3366=ORIENTED_EDGE($,$,$,#844,.T.);
+#3367=ORIENTED_EDGE($,$,$,#3322,.T.);
+#3368=ORIENTED_EDGE($,$,$,#1714,.F.);
+#3369=ORIENTED_EDGE($,$,$,#3354,.F.);
+#3370=EDGE_LOOP($,(#3366,#3367,#3368,#3369));
+#3371=FACE_OUTER_BOUND('',#3370,.T.);
+#3372=ADVANCED_FACE('',(#3371),#3365,.T.);
+#3373=CLOSED_SHELL($,(#870,#1740,#1762,#1779,#1796,#1813,#1830,#1847,#1864,#1881,#1898,#1915,#1932,#1949,#1966,#1983,#2000,#2017,#2034,#2051,#2068,#2085,#2102,#2119,#2136,#2153,#2170,#2187,#2204,#2221,#2238,#2255,#2272,#2289,#2306,#2323,#2340,#2357,#2374,#2391,#2408,#2425,#2442,#2459,#2476,#2493,#2510,#2527,#2544,#2561,#2578,#2595,#2612,#2629,#2646,#2663,#2680,#2697,#2714,#2726,#2748,#2760,#2782,#2794,#2816,#2828,#2850,#2862,#2884,#2896,#2918,#2930,#2952,#2964,#2986,#2998,#3020,#3032,#3054,#3066,#3088,#3100,#3122,#3134,#3156,#3168,#3190,#3202,#3224,#3236,#3258,#3275,#3292,#3304,#3326,#3343,#3360,#3372));
+#3374=MANIFOLD_SOLID_BREP('sheetmetal-Ctc03 flat pattern',#3373);
+#3375=APPLICATION_CONTEXT('mechanical design');
+#3376=PRODUCT_CONTEXT('',#3375,'mechanical');
+#3377=PRODUCT('sheetmetal_Ctc03_flat','sheetmetal-Ctc03 flat pattern','',(#3376));
+#3378=PRODUCT_DEFINITION_FORMATION('','',#3377);
+#3379=PRODUCT_DEFINITION_CONTEXT('design',#3375,'design');
+#3380=PRODUCT_DEFINITION('','',#3378,#3379);
+#3381=PRODUCT_DEFINITION_SHAPE('','',#3380);
+#3382=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));
+#3383=(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.));
+#3384=(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT());
+#3385=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNIT_ASSIGNED_CONTEXT((#3382,#3383,#3384))REPRESENTATION_CONTEXT('3','3D'));
+#3386=SHAPE_REPRESENTATION('sheetmetal-Ctc03 flat pattern',(#3374),#3385);
+#3387=SHAPE_DEFINITION_REPRESENTATION(#3381,#3386);
+ENDSEC;
+END-ISO-10303-21;
diff --git a/docs/modules/sheetmetal/artifacts/m8/ctc03-flat.svg b/docs/modules/sheetmetal/artifacts/m8/ctc03-flat.svg
new file mode 100644
index 00000000..68654870
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m8/ctc03-flat.svg
@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="428.752mm" height="636.598mm" viewBox="0 0 428.752 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 386.246 L 404.052 373.546 L 416.752 373.546 L 416.752 271.946 L 404.052 271.946 L 404.052 259.246 L 355.538 259.246 L 355.538 386.246 L 404.052 386.246 Z"/>
+<path id="flat-AngledServiceFlangeBend" d="M 355.538 386.246 L 355.538 259.246 L 349.802 259.246 L 349.802 386.246 L 355.538 386.246 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>
+<path id="exact-blank-contour" d="M 404.052 386.246 L 404.052 373.546 L 416.752 373.546 L 416.752 271.946 L 404.052 271.946 L 404.052 259.246 L 355.538 259.246 L 349.802 259.246 L 349.802 149.239 L 320.691 149.239 L 309.221 149.239 L 309.221 142.331 L 304.057 147.495 L 302.71 146.148 L 307.874 140.984 L 300.966 140.984 L 300.966 129.513 L 300.966 67.921 L 300.966 56.45 L 300.966 12 L 76.176 12 L 76.176 56.45 L 76.176 67.921 L 76.176 129.513 L 76.176 140.984 L 69.268 140.984 L 74.431 146.148 L 73.084 147.495 L 67.921 142.331 L 67.921 149.239 L 56.45 149.239 L 12 149.239 L 12 501.029 L 56.45 501.029 L 67.921 501.029 L 67.921 507.937 L 73.084 502.773 L 74.431 504.12 L 69.268 509.284 L 76.176 509.284 L 76.176 520.755 L 76.176 582.347 L 76.176 593.818 L 76.176 624.598 L 300.966 624.598 L 300.966 593.818 L 300.966 582.347 L 300.966 520.755 L 300.966 509.284 L 307.874 509.284 L 302.71 504.12 L 304.057 502.773 L 309.221 507.937 L 309.221 501.029 L 320.691 501.029 L 349.802 501.029 L 349.802 386.246 L 355.538 386.246 L 404.052 386.246 Z" fill="none" stroke="#020617" stroke-width="0.7"/>
+<g id="cut-contours" fill="white" stroke="#dc2626" stroke-width="0.5">
+<path id="Ctc03Layout.BaseFastenerPattern[0]" d="M 279.058 470.597 A 7.938 7.938 0 0 0 263.183 470.597 A 7.938 7.938 0 0 0 279.058 470.597 Z"/>
+<path id="Ctc03Layout.BaseFastenerPattern[1]" d="M 279.058 426.147 A 7.938 7.938 0 0 0 263.183 426.147 A 7.938 7.938 0 0 0 279.058 426.147 Z"/>
+<path id="Ctc03Layout.BaseFastenerPattern[2]" d="M 279.058 381.697 A 7.938 7.938 0 0 0 263.183 381.697 A 7.938 7.938 0 0 0 279.058 381.697 Z"/>
+<path id="Ctc03Layout.BaseFastenerPattern[3]" d="M 279.058 337.247 A 7.938 7.938 0 0 0 263.183 337.247 A 7.938 7.938 0 0 0 279.058 337.247 Z"/>
+<path id="Ctc03Layout.FrontMountHoles[0]" d="M 92.533 618.25 A 5.563 5.563 0 0 0 81.408 618.25 A 5.563 5.563 0 0 0 92.533 618.25 Z"/>
+<path id="Ctc03Layout.FrontMountHoles[1]" d="M 295.733 618.25 A 5.563 5.563 0 0 0 284.608 618.25 A 5.563 5.563 0 0 0 295.733 618.25 Z"/>
+<path id="Ctc03Layout.LargeOpeningOnePointFiveInch[0]" d="M 265.253 235.85 A 19.05 19.05 0 0 0 227.153 235.85 A 19.05 19.05 0 0 0 265.253 235.85 Z"/>
+<path id="Ctc03Layout.LargeOpeningTwoInch[0]" d="M 182.703 210.45 A 25.4 25.4 0 0 0 131.903 210.45 A 25.4 25.4 0 0 0 182.703 210.45 Z"/>
+<path id="Ctc03Layout.RearMountHoles[0]" d="M 295.733 31.047 A 5.563 5.563 0 0 0 284.608 31.047 A 5.563 5.563 0 0 0 295.733 31.047 Z"/>
+<path id="Ctc03Layout.RearMountHoles[1]" d="M 92.533 31.047 A 5.563 5.563 0 0 0 81.408 31.047 A 5.563 5.563 0 0 0 92.533 31.047 Z"/>
+<path id="Ctc03Layout.ServiceHole[0]" d="M 399.799 322.746 A 13.526 13.526 0 0 0 372.748 322.746 A 13.526 13.526 0 0 0 399.799 322.746 Z"/>
+<path id="Ctc03Layout.ServiceInnerHoles[0]" d="M 374.685 341.796 A 2.381 2.381 0 0 0 369.922 341.796 A 2.381 2.381 0 0 0 374.685 341.796 Z"/>
+<path id="Ctc03Layout.ServiceInnerHoles[1]" d="M 374.685 303.696 A 2.381 2.381 0 0 0 369.922 303.696 A 2.381 2.381 0 0 0 374.685 303.696 Z"/>
+<path id="Ctc03Layout.ServiceOuterHoles[0]" d="M 406.435 341.796 A 2.381 2.381 0 0 0 401.672 341.796 A 2.381 2.381 0 0 0 406.435 341.796 Z"/>
+<path id="Ctc03Layout.ServiceOuterHoles[1]" d="M 406.435 303.696 A 2.381 2.381 0 0 0 401.672 303.696 A 2.381 2.381 0 0 0 406.435 303.696 Z"/>
+<path id="Ctc03Layout.VentSlots[0]" 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="Ctc03Layout.VentSlots[1]" 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="386.246" x2="352.67" y2="259.246"/>
+<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="320.546" width="24.5" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>
+<text x="356.67" y="322.746" 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 55dd154c6bb0</text>
+</svg>
diff --git a/docs/modules/sheetmetal/artifacts/m8/ctc03-formed.step b/docs/modules/sheetmetal/artifacts/m8/ctc03-formed.step
new file mode 100644
index 00000000..9545112e
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m8/ctc03-formed.step
@@ -0,0 +1,2802 @@
+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($,(-30.1625,96.774,78.105));
+#105=VERTEX_POINT($,#104);
+#106=CARTESIAN_POINT($,(-38.1,96.774,78.105));
+#107=DIRECTION($,(0,0,1));
+#108=DIRECTION($,(1,0,0));
+#109=AXIS2_PLACEMENT_3D($,#106,#107,#108);
+#110=CIRCLE($,#109,7.9375);
+#111=EDGE_CURVE($,#105,#105,#110,.T.);
+#112=ORIENTED_EDGE($,$,$,#111,.T.);
+#113=EDGE_LOOP($,(#112));
+#114=FACE_BOUND('',#113,.T.);
+#115=CARTESIAN_POINT($,(-30.1625,141.224,78.105));
+#116=VERTEX_POINT($,#115);
+#117=CARTESIAN_POINT($,(-38.1,141.224,78.105));
+#118=DIRECTION($,(0,0,1));
+#119=DIRECTION($,(1,0,0));
+#120=AXIS2_PLACEMENT_3D($,#117,#118,#119);
+#121=CIRCLE($,#120,7.9375);
+#122=EDGE_CURVE($,#116,#116,#121,.T.);
+#123=ORIENTED_EDGE($,$,$,#122,.T.);
+#124=EDGE_LOOP($,(#123));
+#125=FACE_BOUND('',#124,.T.);
+#126=CARTESIAN_POINT($,(-30.1625,185.674,78.105));
+#127=VERTEX_POINT($,#126);
+#128=CARTESIAN_POINT($,(-38.1,185.674,78.105));
+#129=DIRECTION($,(0,0,1));
+#130=DIRECTION($,(1,0,0));
+#131=AXIS2_PLACEMENT_3D($,#128,#129,#130);
+#132=CIRCLE($,#131,7.9375);
+#133=EDGE_CURVE($,#127,#127,#132,.T.);
+#134=ORIENTED_EDGE($,$,$,#133,.T.);
+#135=EDGE_LOOP($,(#134));
+#136=FACE_BOUND('',#135,.T.);
+#137=CARTESIAN_POINT($,(-30.1625,230.124,78.105));
+#138=VERTEX_POINT($,#137);
+#139=CARTESIAN_POINT($,(-38.1,230.124,78.105));
+#140=DIRECTION($,(0,0,1));
+#141=DIRECTION($,(1,0,0));
+#142=AXIS2_PLACEMENT_3D($,#139,#140,#141);
+#143=CIRCLE($,#142,7.9375);
+#144=EDGE_CURVE($,#138,#138,#143,.T.);
+#145=ORIENTED_EDGE($,$,$,#144,.T.);
+#146=EDGE_LOOP($,(#145));
+#147=FACE_BOUND('',#146,.T.);
+#148=CARTESIAN_POINT($,(-126.5174,356.9208,78.105));
+#149=VERTEX_POINT($,#148);
+#150=CARTESIAN_POINT($,(-151.9174,356.9208,78.105));
+#151=DIRECTION($,(0,0,1));
+#152=DIRECTION($,(1,0,0));
+#153=AXIS2_PLACEMENT_3D($,#150,#151,#152);
+#154=CIRCLE($,#153,25.4);
+#155=EDGE_CURVE($,#149,#149,#154,.T.);
+#156=ORIENTED_EDGE($,$,$,#155,.T.);
+#157=EDGE_LOOP($,(#156));
+#158=FACE_BOUND('',#157,.T.);
+#159=CARTESIAN_POINT($,(-43.9674,331.5208,78.105));
+#160=VERTEX_POINT($,#159);
+#161=CARTESIAN_POINT($,(-63.0174,331.5208,78.105));
+#162=DIRECTION($,(0,0,1));
+#163=DIRECTION($,(1,0,0));
+#164=AXIS2_PLACEMENT_3D($,#161,#162,#163);
+#165=CIRCLE($,#164,19.05);
+#166=EDGE_CURVE($,#160,#160,#165,.T.);
+#167=ORIENTED_EDGE($,$,$,#166,.T.);
+#168=EDGE_LOOP($,(#167));
+#169=FACE_BOUND('',#168,.T.);
+#170=CARTESIAN_POINT($,(-180.4924,210.9724,78.105));
+#171=VERTEX_POINT($,#170);
+#172=CARTESIAN_POINT($,(-199.5424,210.9724,78.105));
+#173=VERTEX_POINT($,#172);
+#174=CARTESIAN_POINT($,(-180.4924,210.9724,78.105));
+#175=DIRECTION($,(-1,0,0));
+#176=VECTOR($,#175,1);
+#177=LINE($,#174,#176);
+#178=EDGE_CURVE($,#171,#173,#177,.T.);
+#179=ORIENTED_EDGE($,$,$,#178,.F.);
+#180=CARTESIAN_POINT($,(-180.4924,122.0724,78.105));
+#181=VERTEX_POINT($,#180);
+#182=CARTESIAN_POINT($,(-180.4924,122.0724,78.105));
+#183=DIRECTION($,(0,1,0));
+#184=VECTOR($,#183,1);
+#185=LINE($,#182,#184);
+#186=EDGE_CURVE($,#181,#171,#185,.T.);
+#187=ORIENTED_EDGE($,$,$,#186,.F.);
+#188=CARTESIAN_POINT($,(-199.5424,122.0724,78.105));
+#189=VERTEX_POINT($,#188);
+#190=CARTESIAN_POINT($,(-199.5424,122.0724,78.105));
+#191=DIRECTION($,(1,0,0));
+#192=VECTOR($,#191,1);
+#193=LINE($,#190,#192);
+#194=EDGE_CURVE($,#189,#181,#193,.T.);
+#195=ORIENTED_EDGE($,$,$,#194,.F.);
+#196=CARTESIAN_POINT($,(-199.5424,210.9724,78.105));
+#197=DIRECTION($,(0,-1,0));
+#198=VECTOR($,#197,1);
+#199=LINE($,#196,#198);
+#200=EDGE_CURVE($,#173,#189,#199,.T.);
+#201=ORIENTED_EDGE($,$,$,#200,.F.);
+#202=EDGE_LOOP($,(#179,#187,#195,#201));
+#203=FACE_BOUND('',#202,.T.);
+#204=CARTESIAN_POINT($,(-116.9924,210.9724,78.105));
+#205=VERTEX_POINT($,#204);
+#206=CARTESIAN_POINT($,(-136.0424,210.9724,78.105));
+#207=VERTEX_POINT($,#206);
+#208=CARTESIAN_POINT($,(-116.9924,210.9724,78.105));
+#209=DIRECTION($,(-1,0,0));
+#210=VECTOR($,#209,1);
+#211=LINE($,#208,#210);
+#212=EDGE_CURVE($,#205,#207,#211,.T.);
+#213=ORIENTED_EDGE($,$,$,#212,.F.);
+#214=CARTESIAN_POINT($,(-116.9924,122.0724,78.105));
+#215=VERTEX_POINT($,#214);
+#216=CARTESIAN_POINT($,(-116.9924,122.0724,78.105));
+#217=DIRECTION($,(0,1,0));
+#218=VECTOR($,#217,1);
+#219=LINE($,#216,#218);
+#220=EDGE_CURVE($,#215,#205,#219,.T.);
+#221=ORIENTED_EDGE($,$,$,#220,.F.);
+#222=CARTESIAN_POINT($,(-136.0424,122.0724,78.105));
+#223=VERTEX_POINT($,#222);
+#224=CARTESIAN_POINT($,(-136.0424,122.0724,78.105));
+#225=DIRECTION($,(1,0,0));
+#226=VECTOR($,#225,1);
+#227=LINE($,#224,#226);
+#228=EDGE_CURVE($,#223,#215,#227,.T.);
+#229=ORIENTED_EDGE($,$,$,#228,.F.);
+#230=CARTESIAN_POINT($,(-136.0424,210.9724,78.105));
+#231=DIRECTION($,(0,-1,0));
+#232=VECTOR($,#231,1);
+#233=LINE($,#230,#232);
+#234=EDGE_CURVE($,#207,#223,#233,.T.);
+#235=ORIENTED_EDGE($,$,$,#234,.F.);
+#236=EDGE_LOOP($,(#213,#221,#229,#235));
+#237=FACE_BOUND('',#236,.T.);
+#238=ADVANCED_FACE('',(#103,#114,#125,#136,#147,#158,#169,#203,#237),#5,.T.);
+#239=CARTESIAN_POINT($,(-241.3,58.08726,76.2));
+#240=DIRECTION($,(-0,-0,-1));
+#241=DIRECTION($,(1,0,0));
+#242=AXIS2_PLACEMENT_3D($,#239,#240,#241);
+#243=PLANE($,#242);
+#244=CARTESIAN_POINT($,(-241.3,66.34226,76.2));
+#245=VERTEX_POINT($,#244);
+#246=CARTESIAN_POINT($,(-241.3,418.13226,76.2));
+#247=VERTEX_POINT($,#246);
+#248=CARTESIAN_POINT($,(-241.3,66.34226,76.2));
+#249=DIRECTION($,(0,1,0));
+#250=VECTOR($,#249,1);
+#251=LINE($,#248,#250);
+#252=EDGE_CURVE($,#245,#247,#251,.T.);
+#253=ORIENTED_EDGE($,$,$,#252,.T.);
+#254=CARTESIAN_POINT($,(-241.3,426.38726,76.2));
+#255=VERTEX_POINT($,#254);
+#256=CARTESIAN_POINT($,(-241.3,418.13226,76.2));
+#257=DIRECTION($,(0,1,0));
+#258=VECTOR($,#257,1);
+#259=LINE($,#256,#258);
+#260=EDGE_CURVE($,#247,#255,#259,.T.);
+#261=ORIENTED_EDGE($,$,$,#260,.T.);
+#262=CARTESIAN_POINT($,(-233.045,426.38726,76.2));
+#263=VERTEX_POINT($,#262);
+#264=CARTESIAN_POINT($,(-241.3,426.38726,76.2));
+#265=DIRECTION($,(1,0,0));
+#266=VECTOR($,#265,1);
+#267=LINE($,#264,#266);
+#268=EDGE_CURVE($,#255,#263,#267,.T.);
+#269=ORIENTED_EDGE($,$,$,#268,.T.);
+#270=CARTESIAN_POINT($,(-8.255,426.38726,76.2));
+#271=VERTEX_POINT($,#270);
+#272=CARTESIAN_POINT($,(-233.045,426.38726,76.2));
+#273=DIRECTION($,(1,0,0));
+#274=VECTOR($,#273,1);
+#275=LINE($,#272,#274);
+#276=EDGE_CURVE($,#263,#271,#275,.T.);
+#277=ORIENTED_EDGE($,$,$,#276,.T.);
+#278=CARTESIAN_POINT($,(-0,426.38726,76.2));
+#279=VERTEX_POINT($,#278);
+#280=CARTESIAN_POINT($,(-8.255,426.38726,76.2));
+#281=DIRECTION($,(1,0,0));
+#282=VECTOR($,#281,1);
+#283=LINE($,#280,#282);
+#284=EDGE_CURVE($,#271,#279,#283,.T.);
+#285=ORIENTED_EDGE($,$,$,#284,.T.);
+#286=CARTESIAN_POINT($,(0,418.13226,76.2));
+#287=VERTEX_POINT($,#286);
+#288=CARTESIAN_POINT($,(-0,426.38726,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($,(0,66.34226,76.2));
+#295=VERTEX_POINT($,#294);
+#296=CARTESIAN_POINT($,(0,418.13226,76.2));
+#297=DIRECTION($,(0,-1,0));
+#298=VECTOR($,#297,1);
+#299=LINE($,#296,#298);
+#300=EDGE_CURVE($,#287,#295,#299,.T.);
+#301=ORIENTED_EDGE($,$,$,#300,.T.);
+#302=CARTESIAN_POINT($,(-0,58.08726,76.2));
+#303=VERTEX_POINT($,#302);
+#304=CARTESIAN_POINT($,(0,66.34226,76.2));
+#305=DIRECTION($,(0,-1,0));
+#306=VECTOR($,#305,1);
+#307=LINE($,#304,#306);
+#308=EDGE_CURVE($,#295,#303,#307,.T.);
+#309=ORIENTED_EDGE($,$,$,#308,.T.);
+#310=CARTESIAN_POINT($,(-8.255,58.08726,76.2));
+#311=VERTEX_POINT($,#310);
+#312=CARTESIAN_POINT($,(-0,58.08726,76.2));
+#313=DIRECTION($,(-1,0,0));
+#314=VECTOR($,#313,1);
+#315=LINE($,#312,#314);
+#316=EDGE_CURVE($,#303,#311,#315,.T.);
+#317=ORIENTED_EDGE($,$,$,#316,.T.);
+#318=CARTESIAN_POINT($,(-233.045,58.08726,76.2));
+#319=VERTEX_POINT($,#318);
+#320=CARTESIAN_POINT($,(-8.255,58.08726,76.2));
+#321=DIRECTION($,(-1,0,0));
+#322=VECTOR($,#321,1);
+#323=LINE($,#320,#322);
+#324=EDGE_CURVE($,#311,#319,#323,.T.);
+#325=ORIENTED_EDGE($,$,$,#324,.T.);
+#326=CARTESIAN_POINT($,(-241.3,58.08726,76.2));
+#327=VERTEX_POINT($,#326);
+#328=CARTESIAN_POINT($,(-233.045,58.08726,76.2));
+#329=DIRECTION($,(-1,0,0));
+#330=VECTOR($,#329,1);
+#331=LINE($,#328,#330);
+#332=EDGE_CURVE($,#319,#327,#331,.T.);
+#333=ORIENTED_EDGE($,$,$,#332,.T.);
+#334=CARTESIAN_POINT($,(-241.3,58.08726,76.2));
+#335=DIRECTION($,(0,1,0));
+#336=VECTOR($,#335,1);
+#337=LINE($,#334,#336);
+#338=EDGE_CURVE($,#327,#245,#337,.T.);
+#339=ORIENTED_EDGE($,$,$,#338,.T.);
+#340=EDGE_LOOP($,(#253,#261,#269,#277,#285,#293,#301,#309,#317,#325,#333,#339));
+#341=FACE_OUTER_BOUND('',#340,.T.);
+#342=CARTESIAN_POINT($,(-30.1625,96.774,76.2));
+#343=VERTEX_POINT($,#342);
+#344=CARTESIAN_POINT($,(-38.1,96.774,76.2));
+#345=DIRECTION($,(0,0,1));
+#346=DIRECTION($,(1,0,0));
+#347=AXIS2_PLACEMENT_3D($,#344,#345,#346);
+#348=CIRCLE($,#347,7.9375);
+#349=EDGE_CURVE($,#343,#343,#348,.T.);
+#350=ORIENTED_EDGE($,$,$,#349,.T.);
+#351=EDGE_LOOP($,(#350));
+#352=FACE_BOUND('',#351,.T.);
+#353=CARTESIAN_POINT($,(-30.1625,141.224,76.2));
+#354=VERTEX_POINT($,#353);
+#355=CARTESIAN_POINT($,(-38.1,141.224,76.2));
+#356=DIRECTION($,(0,0,1));
+#357=DIRECTION($,(1,0,0));
+#358=AXIS2_PLACEMENT_3D($,#355,#356,#357);
+#359=CIRCLE($,#358,7.9375);
+#360=EDGE_CURVE($,#354,#354,#359,.T.);
+#361=ORIENTED_EDGE($,$,$,#360,.T.);
+#362=EDGE_LOOP($,(#361));
+#363=FACE_BOUND('',#362,.T.);
+#364=CARTESIAN_POINT($,(-30.1625,185.674,76.2));
+#365=VERTEX_POINT($,#364);
+#366=CARTESIAN_POINT($,(-38.1,185.674,76.2));
+#367=DIRECTION($,(0,0,1));
+#368=DIRECTION($,(1,0,0));
+#369=AXIS2_PLACEMENT_3D($,#366,#367,#368);
+#370=CIRCLE($,#369,7.9375);
+#371=EDGE_CURVE($,#365,#365,#370,.T.);
+#372=ORIENTED_EDGE($,$,$,#371,.T.);
+#373=EDGE_LOOP($,(#372));
+#374=FACE_BOUND('',#373,.T.);
+#375=CARTESIAN_POINT($,(-30.1625,230.124,76.2));
+#376=VERTEX_POINT($,#375);
+#377=CARTESIAN_POINT($,(-38.1,230.124,76.2));
+#378=DIRECTION($,(0,0,1));
+#379=DIRECTION($,(1,0,0));
+#380=AXIS2_PLACEMENT_3D($,#377,#378,#379);
+#381=CIRCLE($,#380,7.9375);
+#382=EDGE_CURVE($,#376,#376,#381,.T.);
+#383=ORIENTED_EDGE($,$,$,#382,.T.);
+#384=EDGE_LOOP($,(#383));
+#385=FACE_BOUND('',#384,.T.);
+#386=CARTESIAN_POINT($,(-126.5174,356.9208,76.2));
+#387=VERTEX_POINT($,#386);
+#388=CARTESIAN_POINT($,(-151.9174,356.9208,76.2));
+#389=DIRECTION($,(0,0,1));
+#390=DIRECTION($,(1,0,0));
+#391=AXIS2_PLACEMENT_3D($,#388,#389,#390);
+#392=CIRCLE($,#391,25.4);
+#393=EDGE_CURVE($,#387,#387,#392,.T.);
+#394=ORIENTED_EDGE($,$,$,#393,.T.);
+#395=EDGE_LOOP($,(#394));
+#396=FACE_BOUND('',#395,.T.);
+#397=CARTESIAN_POINT($,(-43.9674,331.5208,76.2));
+#398=VERTEX_POINT($,#397);
+#399=CARTESIAN_POINT($,(-63.0174,331.5208,76.2));
+#400=DIRECTION($,(0,0,1));
+#401=DIRECTION($,(1,0,0));
+#402=AXIS2_PLACEMENT_3D($,#399,#400,#401);
+#403=CIRCLE($,#402,19.05);
+#404=EDGE_CURVE($,#398,#398,#403,.T.);
+#405=ORIENTED_EDGE($,$,$,#404,.T.);
+#406=EDGE_LOOP($,(#405));
+#407=FACE_BOUND('',#406,.T.);
+#408=CARTESIAN_POINT($,(-199.5424,122.0724,76.2));
+#409=VERTEX_POINT($,#408);
+#410=CARTESIAN_POINT($,(-180.4924,122.0724,76.2));
+#411=VERTEX_POINT($,#410);
+#412=CARTESIAN_POINT($,(-199.5424,122.0724,76.2));
+#413=DIRECTION($,(1,0,0));
+#414=VECTOR($,#413,1);
+#415=LINE($,#412,#414);
+#416=EDGE_CURVE($,#409,#411,#415,.T.);
+#417=ORIENTED_EDGE($,$,$,#416,.T.);
+#418=CARTESIAN_POINT($,(-180.4924,210.9724,76.2));
+#419=VERTEX_POINT($,#418);
+#420=CARTESIAN_POINT($,(-180.4924,122.0724,76.2));
+#421=DIRECTION($,(0,1,0));
+#422=VECTOR($,#421,1);
+#423=LINE($,#420,#422);
+#424=EDGE_CURVE($,#411,#419,#423,.T.);
+#425=ORIENTED_EDGE($,$,$,#424,.T.);
+#426=CARTESIAN_POINT($,(-199.5424,210.9724,76.2));
+#427=VERTEX_POINT($,#426);
+#428=CARTESIAN_POINT($,(-180.4924,210.9724,76.2));
+#429=DIRECTION($,(-1,0,0));
+#430=VECTOR($,#429,1);
+#431=LINE($,#428,#430);
+#432=EDGE_CURVE($,#419,#427,#431,.T.);
+#433=ORIENTED_EDGE($,$,$,#432,.T.);
+#434=CARTESIAN_POINT($,(-199.5424,210.9724,76.2));
+#435=DIRECTION($,(0,-1,0));
+#436=VECTOR($,#435,1);
+#437=LINE($,#434,#436);
+#438=EDGE_CURVE($,#427,#409,#437,.T.);
+#439=ORIENTED_EDGE($,$,$,#438,.T.);
+#440=EDGE_LOOP($,(#417,#425,#433,#439));
+#441=FACE_BOUND('',#440,.T.);
+#442=CARTESIAN_POINT($,(-136.0424,122.0724,76.2));
+#443=VERTEX_POINT($,#442);
+#444=CARTESIAN_POINT($,(-116.9924,122.0724,76.2));
+#445=VERTEX_POINT($,#444);
+#446=CARTESIAN_POINT($,(-136.0424,122.0724,76.2));
+#447=DIRECTION($,(1,0,0));
+#448=VECTOR($,#447,1);
+#449=LINE($,#446,#448);
+#450=EDGE_CURVE($,#443,#445,#449,.T.);
+#451=ORIENTED_EDGE($,$,$,#450,.T.);
+#452=CARTESIAN_POINT($,(-116.9924,210.9724,76.2));
+#453=VERTEX_POINT($,#452);
+#454=CARTESIAN_POINT($,(-116.9924,122.0724,76.2));
+#455=DIRECTION($,(0,1,0));
+#456=VECTOR($,#455,1);
+#457=LINE($,#454,#456);
+#458=EDGE_CURVE($,#445,#453,#457,.T.);
+#459=ORIENTED_EDGE($,$,$,#458,.T.);
+#460=CARTESIAN_POINT($,(-136.0424,210.9724,76.2));
+#461=VERTEX_POINT($,#460);
+#462=CARTESIAN_POINT($,(-116.9924,210.9724,76.2));
+#463=DIRECTION($,(-1,0,0));
+#464=VECTOR($,#463,1);
+#465=LINE($,#462,#464);
+#466=EDGE_CURVE($,#453,#461,#465,.T.);
+#467=ORIENTED_EDGE($,$,$,#466,.T.);
+#468=CARTESIAN_POINT($,(-136.0424,210.9724,76.2));
+#469=DIRECTION($,(0,-1,0));
+#470=VECTOR($,#469,1);
+#471=LINE($,#468,#470);
+#472=EDGE_CURVE($,#461,#443,#471,.T.);
+#473=ORIENTED_EDGE($,$,$,#472,.T.);
+#474=EDGE_LOOP($,(#451,#459,#467,#473));
+#475=FACE_BOUND('',#474,.T.);
+#476=ADVANCED_FACE('',(#341,#352,#363,#374,#385,#396,#407,#441,#475),#243,.F.);
+#477=CARTESIAN_POINT($,(-233.045,49.83226,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($,(-233.045,49.83226,69.85));
+#483=VERTEX_POINT($,#482);
+#484=CARTESIAN_POINT($,(-8.255,49.83226,69.85));
+#485=VERTEX_POINT($,#484);
+#486=CARTESIAN_POINT($,(-233.045,49.83226,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($,(-8.255,49.83226,8.25746000000001));
+#493=VERTEX_POINT($,#492);
+#494=CARTESIAN_POINT($,(-8.255,49.83226,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($,(-233.045,49.83226,8.25746000000001));
+#501=VERTEX_POINT($,#500);
+#502=CARTESIAN_POINT($,(-8.255,49.83226,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($,(-233.045,49.83226,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($,(-233.045,51.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($,(-233.045,51.73726,8.25746000000001));
+#523=VERTEX_POINT($,#522);
+#524=CARTESIAN_POINT($,(-8.255,51.73726,8.25746000000001));
+#525=VERTEX_POINT($,#524);
+#526=CARTESIAN_POINT($,(-233.045,51.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($,(-8.255,51.73726,69.85));
+#533=VERTEX_POINT($,#532);
+#534=CARTESIAN_POINT($,(-8.255,51.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($,(-233.045,51.73726,69.85));
+#541=VERTEX_POINT($,#540);
+#542=CARTESIAN_POINT($,(-8.255,51.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($,(-233.045,51.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($,(-233.045,58.08726,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($,$,$,#22,.T.);
+#563=CARTESIAN_POINT($,(-8.255,58.08726,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($,#17,#485,#568,.T.);
+#570=ORIENTED_EDGE($,$,$,#569,.T.);
+#571=ORIENTED_EDGE($,$,$,#490,.F.);
+#572=CARTESIAN_POINT($,(-233.045,58.08726,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,#9,#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($,(-233.045,58.08726,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($,(-8.255,58.08726,69.85));
+#590=DIRECTION($,(-1,-0,-0));
+#591=DIRECTION($,(0,-1,0));
+#592=AXIS2_PLACEMENT_3D($,#589,#590,#591);
+#593=CIRCLE($,#592,6.35);
+#594=TRIMMED_CURVE($,#593,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#595=EDGE_CURVE($,#533,#311,#594,.T.);
+#596=ORIENTED_EDGE($,$,$,#595,.T.);
+#597=ORIENTED_EDGE($,$,$,#324,.T.);
+#598=CARTESIAN_POINT($,(-233.045,58.08726,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($,#319,#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($,(-8.255,434.64226,69.85));
+#610=DIRECTION($,(0,1,0));
+#611=DIRECTION($,(-1,0,0));
+#612=AXIS2_PLACEMENT_3D($,#609,#610,#611);
+#613=PLANE($,#612);
+#614=CARTESIAN_POINT($,(-8.255,434.64226,69.85));
+#615=VERTEX_POINT($,#614);
+#616=CARTESIAN_POINT($,(-233.045,434.64226,69.85));
+#617=VERTEX_POINT($,#616);
+#618=CARTESIAN_POINT($,(-8.255,434.64226,69.85));
+#619=DIRECTION($,(-1,0,0));
+#620=VECTOR($,#619,1);
+#621=LINE($,#618,#620);
+#622=EDGE_CURVE($,#615,#617,#621,.T.);
+#623=ORIENTED_EDGE($,$,$,#622,.T.);
+#624=CARTESIAN_POINT($,(-233.045,434.64226,8.25746000000001));
+#625=VERTEX_POINT($,#624);
+#626=CARTESIAN_POINT($,(-233.045,434.64226,69.85));
+#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($,(-8.255,434.64226,8.25746000000001));
+#633=VERTEX_POINT($,#632);
+#634=CARTESIAN_POINT($,(-233.045,434.64226,8.25746000000001));
+#635=DIRECTION($,(1,0,0));
+#636=VECTOR($,#635,1);
+#637=LINE($,#634,#636);
+#638=EDGE_CURVE($,#625,#633,#637,.T.);
+#639=ORIENTED_EDGE($,$,$,#638,.T.);
+#640=CARTESIAN_POINT($,(-8.255,434.64226,8.25746000000001));
+#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($,(-8.255,432.73726,69.85));
+#650=DIRECTION($,(-0,-1,-0));
+#651=DIRECTION($,(-1,0,0));
+#652=AXIS2_PLACEMENT_3D($,#649,#650,#651);
+#653=PLANE($,#652);
+#654=CARTESIAN_POINT($,(-8.255,432.73726,8.25746000000001));
+#655=VERTEX_POINT($,#654);
+#656=CARTESIAN_POINT($,(-233.045,432.73726,8.25746000000001));
+#657=VERTEX_POINT($,#656);
+#658=CARTESIAN_POINT($,(-8.255,432.73726,8.25746000000001));
+#659=DIRECTION($,(-1,0,0));
+#660=VECTOR($,#659,1);
+#661=LINE($,#658,#660);
+#662=EDGE_CURVE($,#655,#657,#661,.T.);
+#663=ORIENTED_EDGE($,$,$,#662,.T.);
+#664=CARTESIAN_POINT($,(-233.045,432.73726,69.85));
+#665=VERTEX_POINT($,#664);
+#666=CARTESIAN_POINT($,(-233.045,432.73726,8.25746000000001));
+#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($,(-8.255,432.73726,69.85));
+#673=VERTEX_POINT($,#672);
+#674=CARTESIAN_POINT($,(-233.045,432.73726,69.85));
+#675=DIRECTION($,(1,0,0));
+#676=VECTOR($,#675,1);
+#677=LINE($,#674,#676);
+#678=EDGE_CURVE($,#665,#673,#677,.T.);
+#679=ORIENTED_EDGE($,$,$,#678,.T.);
+#680=CARTESIAN_POINT($,(-8.255,432.73726,69.85));
+#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($,(-8.255,426.38726,69.85));
+#690=DIRECTION($,(-1,0,0));
+#691=DIRECTION($,(0,0,1));
+#692=AXIS2_PLACEMENT_3D($,#689,#690,#691);
+#693=CYLINDRICAL_SURFACE($,#692,8.255);
+#694=ORIENTED_EDGE($,$,$,#70,.T.);
+#695=CARTESIAN_POINT($,(-233.045,426.38726,69.85));
+#696=DIRECTION($,(-1,0,0));
+#697=DIRECTION($,(0,0,1));
+#698=AXIS2_PLACEMENT_3D($,#695,#696,#697);
+#699=CIRCLE($,#698,8.255);
+#700=TRIMMED_CURVE($,#699,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#701=EDGE_CURVE($,#65,#617,#700,.T.);
+#702=ORIENTED_EDGE($,$,$,#701,.T.);
+#703=ORIENTED_EDGE($,$,$,#622,.F.);
+#704=CARTESIAN_POINT($,(-8.255,426.38726,69.85));
+#705=DIRECTION($,(1,-0,-0));
+#706=DIRECTION($,(0,1,0));
+#707=AXIS2_PLACEMENT_3D($,#704,#705,#706);
+#708=CIRCLE($,#707,8.255);
+#709=TRIMMED_CURVE($,#708,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#710=EDGE_CURVE($,#615,#57,#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($,(-8.255,426.38726,69.85));
+#716=DIRECTION($,(-1,0,0));
+#717=DIRECTION($,(0,0,1));
+#718=AXIS2_PLACEMENT_3D($,#715,#716,#717);
+#719=CYLINDRICAL_SURFACE($,#718,6.34999999999999);
+#720=ORIENTED_EDGE($,$,$,#678,.F.);
+#721=CARTESIAN_POINT($,(-233.045,426.38726,69.85));
+#722=DIRECTION($,(1,-0,-0));
+#723=DIRECTION($,(0,1,0));
+#724=AXIS2_PLACEMENT_3D($,#721,#722,#723);
+#725=CIRCLE($,#724,6.35000000000002);
+#726=TRIMMED_CURVE($,#725,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#727=EDGE_CURVE($,#665,#263,#726,.T.);
+#728=ORIENTED_EDGE($,$,$,#727,.T.);
+#729=ORIENTED_EDGE($,$,$,#276,.T.);
+#730=CARTESIAN_POINT($,(-8.255,426.38726,69.85));
+#731=DIRECTION($,(-1,0,0));
+#732=DIRECTION($,(0,0,1));
+#733=AXIS2_PLACEMENT_3D($,#730,#731,#732);
+#734=CIRCLE($,#733,6.34999999999999);
+#735=TRIMMED_CURVE($,#734,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#736=EDGE_CURVE($,#271,#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($,(-247.65,418.13226,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($,(-247.65,418.13226,84.455));
+#747=VERTEX_POINT($,#746);
+#748=CARTESIAN_POINT($,(-247.65,66.34226,84.455));
+#749=VERTEX_POINT($,#748);
+#750=CARTESIAN_POINT($,(-247.65,418.13226,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($,(-247.65,66.34226,128.905));
+#757=VERTEX_POINT($,#756);
+#758=CARTESIAN_POINT($,(-247.65,66.34226,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($,(-247.65,418.13226,128.905));
+#765=VERTEX_POINT($,#764);
+#766=CARTESIAN_POINT($,(-247.65,66.34226,128.905));
+#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($,(-247.65,418.13226,128.905));
+#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($,(-249.555,418.13226,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($,(-249.555,418.13226,128.905));
+#787=VERTEX_POINT($,#786);
+#788=CARTESIAN_POINT($,(-249.555,66.34226,128.905));
+#789=VERTEX_POINT($,#788);
+#790=CARTESIAN_POINT($,(-249.555,418.13226,128.905));
+#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($,(-249.555,66.34226,84.455));
+#797=VERTEX_POINT($,#796);
+#798=CARTESIAN_POINT($,(-249.555,66.34226,128.905));
+#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($,(-249.555,418.13226,84.455));
+#805=VERTEX_POINT($,#804);
+#806=CARTESIAN_POINT($,(-249.555,66.34226,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($,(-249.555,418.13226,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($,(-241.3,418.13226,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($,$,$,#94,.T.);
+#827=CARTESIAN_POINT($,(-241.3,66.34226,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($,#89,#749,#832,.T.);
+#834=ORIENTED_EDGE($,$,$,#833,.T.);
+#835=ORIENTED_EDGE($,$,$,#754,.F.);
+#836=CARTESIAN_POINT($,(-241.3,418.13226,84.455));
+#837=DIRECTION($,(0,-1,0));
+#838=DIRECTION($,(-1,0,0));
+#839=AXIS2_PLACEMENT_3D($,#836,#837,#838);
+#840=CIRCLE($,#839,6.35000000000002);
+#841=TRIMMED_CURVE($,#840,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#842=EDGE_CURVE($,#747,#81,#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($,(-241.3,418.13226,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($,(-241.3,66.34226,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,#245,#858,.T.);
+#860=ORIENTED_EDGE($,$,$,#859,.T.);
+#861=ORIENTED_EDGE($,$,$,#252,.T.);
+#862=CARTESIAN_POINT($,(-241.3,418.13226,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($,#247,#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($,(6.35,66.34226,84.455));
+#874=DIRECTION($,(-1,0,0));
+#875=DIRECTION($,(0,1,0));
+#876=AXIS2_PLACEMENT_3D($,#873,#874,#875);
+#877=PLANE($,#876);
+#878=CARTESIAN_POINT($,(6.35,66.34226,84.455));
+#879=VERTEX_POINT($,#878);
+#880=CARTESIAN_POINT($,(6.35,418.13226,84.455));
+#881=VERTEX_POINT($,#880);
+#882=CARTESIAN_POINT($,(6.35,66.34226,84.455));
+#883=DIRECTION($,(0,1,0));
+#884=VECTOR($,#883,1);
+#885=LINE($,#882,#884);
+#886=EDGE_CURVE($,#879,#881,#885,.T.);
+#887=ORIENTED_EDGE($,$,$,#886,.T.);
+#888=CARTESIAN_POINT($,(6.35,418.13226,113.56594));
+#889=VERTEX_POINT($,#888);
+#890=CARTESIAN_POINT($,(6.35,418.13226,84.455));
+#891=DIRECTION($,(0,0,1));
+#892=VECTOR($,#891,1);
+#893=LINE($,#890,#892);
+#894=EDGE_CURVE($,#881,#889,#893,.T.);
+#895=ORIENTED_EDGE($,$,$,#894,.T.);
+#896=CARTESIAN_POINT($,(6.35,66.34226,113.56594));
+#897=VERTEX_POINT($,#896);
+#898=CARTESIAN_POINT($,(6.35,418.13226,113.56594));
+#899=DIRECTION($,(0,-1,0));
+#900=VECTOR($,#899,1);
+#901=LINE($,#898,#900);
+#902=EDGE_CURVE($,#889,#897,#901,.T.);
+#903=ORIENTED_EDGE($,$,$,#902,.T.);
+#904=CARTESIAN_POINT($,(6.35,66.34226,113.56594));
+#905=DIRECTION($,(-0,0,-1));
+#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($,(8.255,66.34226,84.455));
+#914=DIRECTION($,(1,-0,-0));
+#915=DIRECTION($,(0,1,0));
+#916=AXIS2_PLACEMENT_3D($,#913,#914,#915);
+#917=PLANE($,#916);
+#918=CARTESIAN_POINT($,(8.255,66.34226,113.56594));
+#919=VERTEX_POINT($,#918);
+#920=CARTESIAN_POINT($,(8.255,418.13226,113.56594));
+#921=VERTEX_POINT($,#920);
+#922=CARTESIAN_POINT($,(8.255,66.34226,113.56594));
+#923=DIRECTION($,(0,1,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,418.13226,84.455));
+#929=VERTEX_POINT($,#928);
+#930=CARTESIAN_POINT($,(8.255,418.13226,113.56594));
+#931=DIRECTION($,(-0,0,-1));
+#932=VECTOR($,#931,1);
+#933=LINE($,#930,#932);
+#934=EDGE_CURVE($,#921,#929,#933,.T.);
+#935=ORIENTED_EDGE($,$,$,#934,.T.);
+#936=CARTESIAN_POINT($,(8.255,66.34226,84.455));
+#937=VERTEX_POINT($,#936);
+#938=CARTESIAN_POINT($,(8.255,418.13226,84.455));
+#939=DIRECTION($,(0,-1,0));
+#940=VECTOR($,#939,1);
+#941=LINE($,#938,#940);
+#942=EDGE_CURVE($,#929,#937,#941,.T.);
+#943=ORIENTED_EDGE($,$,$,#942,.T.);
+#944=CARTESIAN_POINT($,(8.255,66.34226,84.455));
+#945=DIRECTION($,(0,0,1));
+#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($,(0,66.34226,84.455));
+#954=DIRECTION($,(0,1,0));
+#955=DIRECTION($,(0,0,-1));
+#956=AXIS2_PLACEMENT_3D($,#953,#954,#955);
+#957=CYLINDRICAL_SURFACE($,#956,6.34999999999999);
+#958=ORIENTED_EDGE($,$,$,#46,.T.);
+#959=CARTESIAN_POINT($,(0,418.13226,84.455));
+#960=DIRECTION($,(-0,-1,-0));
+#961=DIRECTION($,(0,0,-1));
+#962=AXIS2_PLACEMENT_3D($,#959,#960,#961);
+#963=CIRCLE($,#962,6.34999999999999);
+#964=TRIMMED_CURVE($,#963,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#965=EDGE_CURVE($,#41,#881,#964,.T.);
+#966=ORIENTED_EDGE($,$,$,#965,.T.);
+#967=ORIENTED_EDGE($,$,$,#886,.F.);
+#968=CARTESIAN_POINT($,(0,66.34226,84.455));
+#969=DIRECTION($,(0,1,0));
+#970=DIRECTION($,(1,0,0));
+#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,#33,#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($,(0,66.34226,84.455));
+#980=DIRECTION($,(0,1,0));
+#981=DIRECTION($,(0,0,-1));
+#982=AXIS2_PLACEMENT_3D($,#979,#980,#981);
+#983=CYLINDRICAL_SURFACE($,#982,8.255);
+#984=ORIENTED_EDGE($,$,$,#942,.F.);
+#985=CARTESIAN_POINT($,(0,418.13226,84.455));
+#986=DIRECTION($,(0,1,0));
+#987=DIRECTION($,(1,0,0));
+#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,#287,#990,.T.);
+#992=ORIENTED_EDGE($,$,$,#991,.T.);
+#993=ORIENTED_EDGE($,$,$,#300,.T.);
+#994=CARTESIAN_POINT($,(0,66.34226,84.455));
+#995=DIRECTION($,(-0,-1,-0));
+#996=DIRECTION($,(0,0,-1));
+#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($,#295,#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($,(-233.045,43.48226,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($,(-233.045,43.48226,1.90746000000001));
+#1011=VERTEX_POINT($,#1010);
+#1012=CARTESIAN_POINT($,(-8.255,43.48226,1.90746000000001));
+#1013=VERTEX_POINT($,#1012);
+#1014=CARTESIAN_POINT($,(-233.045,43.48226,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($,(-8.255,12.70254,1.90746000000001));
+#1021=VERTEX_POINT($,#1020);
+#1022=CARTESIAN_POINT($,(-8.255,43.48226,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($,(-233.045,12.70254,1.90746000000001));
+#1029=VERTEX_POINT($,#1028);
+#1030=CARTESIAN_POINT($,(-8.255,12.70254,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($,(-233.045,12.70254,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=CARTESIAN_POINT($,(-216.6874,19.05,1.90746000000001));
+#1045=VERTEX_POINT($,#1044);
+#1046=CARTESIAN_POINT($,(-222.25,19.05,1.90746000000001));
+#1047=DIRECTION($,(0,0,1));
+#1048=DIRECTION($,(1,0,0));
+#1049=AXIS2_PLACEMENT_3D($,#1046,#1047,#1048);
+#1050=CIRCLE($,#1049,5.5626);
+#1051=EDGE_CURVE($,#1045,#1045,#1050,.T.);
+#1052=ORIENTED_EDGE($,$,$,#1051,.T.);
+#1053=EDGE_LOOP($,(#1052));
+#1054=FACE_BOUND('',#1053,.T.);
+#1055=CARTESIAN_POINT($,(-13.4874,19.05,1.90746000000001));
+#1056=VERTEX_POINT($,#1055);
+#1057=CARTESIAN_POINT($,(-19.05,19.05,1.90746000000001));
+#1058=DIRECTION($,(0,0,1));
+#1059=DIRECTION($,(1,0,0));
+#1060=AXIS2_PLACEMENT_3D($,#1057,#1058,#1059);
+#1061=CIRCLE($,#1060,5.5626);
+#1062=EDGE_CURVE($,#1056,#1056,#1061,.T.);
+#1063=ORIENTED_EDGE($,$,$,#1062,.T.);
+#1064=EDGE_LOOP($,(#1063));
+#1065=FACE_BOUND('',#1064,.T.);
+#1066=ADVANCED_FACE('',(#1043,#1054,#1065),#1009,.T.);
+#1067=CARTESIAN_POINT($,(-233.045,43.48226,0.00246000000001));
+#1068=DIRECTION($,(-0,-0,-1));
+#1069=DIRECTION($,(1,0,0));
+#1070=AXIS2_PLACEMENT_3D($,#1067,#1068,#1069);
+#1071=PLANE($,#1070);
+#1072=CARTESIAN_POINT($,(-233.045,12.70254,0.00246000000001));
+#1073=VERTEX_POINT($,#1072);
+#1074=CARTESIAN_POINT($,(-8.255,12.70254,0.00246000000001));
+#1075=VERTEX_POINT($,#1074);
+#1076=CARTESIAN_POINT($,(-233.045,12.70254,0.00246000000001));
+#1077=DIRECTION($,(1,0,0));
+#1078=VECTOR($,#1077,1);
+#1079=LINE($,#1076,#1078);
+#1080=EDGE_CURVE($,#1073,#1075,#1079,.T.);
+#1081=ORIENTED_EDGE($,$,$,#1080,.T.);
+#1082=CARTESIAN_POINT($,(-8.255,43.48226,0.00246000000001));
+#1083=VERTEX_POINT($,#1082);
+#1084=CARTESIAN_POINT($,(-8.255,12.70254,0.00246000000001));
+#1085=DIRECTION($,(0,1,0));
+#1086=VECTOR($,#1085,1);
+#1087=LINE($,#1084,#1086);
+#1088=EDGE_CURVE($,#1075,#1083,#1087,.T.);
+#1089=ORIENTED_EDGE($,$,$,#1088,.T.);
+#1090=CARTESIAN_POINT($,(-233.045,43.48226,0.00246000000001));
+#1091=VERTEX_POINT($,#1090);
+#1092=CARTESIAN_POINT($,(-8.255,43.48226,0.00246000000001));
+#1093=DIRECTION($,(-1,0,0));
+#1094=VECTOR($,#1093,1);
+#1095=LINE($,#1092,#1094);
+#1096=EDGE_CURVE($,#1083,#1091,#1095,.T.);
+#1097=ORIENTED_EDGE($,$,$,#1096,.T.);
+#1098=CARTESIAN_POINT($,(-233.045,43.48226,0.00246000000001));
+#1099=DIRECTION($,(0,-1,0));
+#1100=VECTOR($,#1099,1);
+#1101=LINE($,#1098,#1100);
+#1102=EDGE_CURVE($,#1091,#1073,#1101,.T.);
+#1103=ORIENTED_EDGE($,$,$,#1102,.T.);
+#1104=EDGE_LOOP($,(#1081,#1089,#1097,#1103));
+#1105=FACE_OUTER_BOUND('',#1104,.T.);
+#1106=CARTESIAN_POINT($,(-216.6874,19.05,0.00246000000001));
+#1107=VERTEX_POINT($,#1106);
+#1108=CARTESIAN_POINT($,(-222.25,19.05,0.00246000000001));
+#1109=DIRECTION($,(0,0,1));
+#1110=DIRECTION($,(1,0,0));
+#1111=AXIS2_PLACEMENT_3D($,#1108,#1109,#1110);
+#1112=CIRCLE($,#1111,5.5626);
+#1113=EDGE_CURVE($,#1107,#1107,#1112,.T.);
+#1114=ORIENTED_EDGE($,$,$,#1113,.T.);
+#1115=EDGE_LOOP($,(#1114));
+#1116=FACE_BOUND('',#1115,.T.);
+#1117=CARTESIAN_POINT($,(-13.4874,19.05,0.00246000000001));
+#1118=VERTEX_POINT($,#1117);
+#1119=CARTESIAN_POINT($,(-19.05,19.05,0.00246000000001));
+#1120=DIRECTION($,(0,0,1));
+#1121=DIRECTION($,(1,0,0));
+#1122=AXIS2_PLACEMENT_3D($,#1119,#1120,#1121);
+#1123=CIRCLE($,#1122,5.5626);
+#1124=EDGE_CURVE($,#1118,#1118,#1123,.T.);
+#1125=ORIENTED_EDGE($,$,$,#1124,.T.);
+#1126=EDGE_LOOP($,(#1125));
+#1127=FACE_BOUND('',#1126,.T.);
+#1128=ADVANCED_FACE('',(#1105,#1116,#1127),#1071,.F.);
+#1129=CARTESIAN_POINT($,(-233.045,43.48226,8.25746000000001));
+#1130=DIRECTION($,(1,0,0));
+#1131=DIRECTION($,(0,1,0));
+#1132=AXIS2_PLACEMENT_3D($,#1129,#1130,#1131);
+#1133=CYLINDRICAL_SURFACE($,#1132,6.35);
+#1134=ORIENTED_EDGE($,$,$,#506,.F.);
+#1135=CARTESIAN_POINT($,(-8.255,43.48226,8.25746000000001));
+#1136=DIRECTION($,(-1,-0,-0));
+#1137=DIRECTION($,(0,1,0));
+#1138=AXIS2_PLACEMENT_3D($,#1135,#1136,#1137);
+#1139=CIRCLE($,#1138,6.35);
+#1140=TRIMMED_CURVE($,#1139,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1141=EDGE_CURVE($,#493,#1013,#1140,.T.);
+#1142=ORIENTED_EDGE($,$,$,#1141,.T.);
+#1143=ORIENTED_EDGE($,$,$,#1018,.F.);
+#1144=CARTESIAN_POINT($,(-233.045,43.48226,8.25746000000001));
+#1145=DIRECTION($,(1,0,0));
+#1146=DIRECTION($,(0,0.000000000000001,-1));
+#1147=AXIS2_PLACEMENT_3D($,#1144,#1145,#1146);
+#1148=CIRCLE($,#1147,6.35);
+#1149=TRIMMED_CURVE($,#1148,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1150=EDGE_CURVE($,#1011,#501,#1149,.T.);
+#1151=ORIENTED_EDGE($,$,$,#1150,.T.);
+#1152=EDGE_LOOP($,(#1134,#1142,#1143,#1151));
+#1153=FACE_OUTER_BOUND('',#1152,.T.);
+#1154=ADVANCED_FACE('',(#1153),#1133,.T.);
+#1155=CARTESIAN_POINT($,(-233.045,43.48226,8.25746000000001));
+#1156=DIRECTION($,(1,0,0));
+#1157=DIRECTION($,(0,1,0));
+#1158=AXIS2_PLACEMENT_3D($,#1155,#1156,#1157);
+#1159=CYLINDRICAL_SURFACE($,#1158,8.255);
+#1160=ORIENTED_EDGE($,$,$,#1096,.F.);
+#1161=CARTESIAN_POINT($,(-8.255,43.48226,8.25746000000001));
+#1162=DIRECTION($,(1,0,0));
+#1163=DIRECTION($,(0,0.000000000000001,-1));
+#1164=AXIS2_PLACEMENT_3D($,#1161,#1162,#1163);
+#1165=CIRCLE($,#1164,8.255);
+#1166=TRIMMED_CURVE($,#1165,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1167=EDGE_CURVE($,#1083,#525,#1166,.T.);
+#1168=ORIENTED_EDGE($,$,$,#1167,.T.);
+#1169=ORIENTED_EDGE($,$,$,#530,.F.);
+#1170=CARTESIAN_POINT($,(-233.045,43.48226,8.25746000000001));
+#1171=DIRECTION($,(-1,-0,-0));
+#1172=DIRECTION($,(0,1,0));
+#1173=AXIS2_PLACEMENT_3D($,#1170,#1171,#1172);
+#1174=CIRCLE($,#1173,8.255);
+#1175=TRIMMED_CURVE($,#1174,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1176=EDGE_CURVE($,#523,#1091,#1175,.T.);
+#1177=ORIENTED_EDGE($,$,$,#1176,.T.);
+#1178=EDGE_LOOP($,(#1160,#1168,#1169,#1177));
+#1179=FACE_OUTER_BOUND('',#1178,.T.);
+#1180=ADVANCED_FACE('',(#1179),#1159,.F.);
+#1181=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));
+#1182=DIRECTION($,(0,0,1));
+#1183=DIRECTION($,(-1,0,0));
+#1184=AXIS2_PLACEMENT_3D($,#1181,#1182,#1183);
+#1185=PLANE($,#1184);
+#1186=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));
+#1187=VERTEX_POINT($,#1186);
+#1188=CARTESIAN_POINT($,(-233.045,440.99226,1.90746000000001));
+#1189=VERTEX_POINT($,#1188);
+#1190=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));
+#1191=DIRECTION($,(-1,0,0));
+#1192=VECTOR($,#1191,1);
+#1193=LINE($,#1190,#1192);
+#1194=EDGE_CURVE($,#1187,#1189,#1193,.T.);
+#1195=ORIENTED_EDGE($,$,$,#1194,.T.);
+#1196=CARTESIAN_POINT($,(-233.045,485.44226,1.90746000000001));
+#1197=VERTEX_POINT($,#1196);
+#1198=CARTESIAN_POINT($,(-233.045,440.99226,1.90746000000001));
+#1199=DIRECTION($,(0,1,0));
+#1200=VECTOR($,#1199,1);
+#1201=LINE($,#1198,#1200);
+#1202=EDGE_CURVE($,#1189,#1197,#1201,.T.);
+#1203=ORIENTED_EDGE($,$,$,#1202,.T.);
+#1204=CARTESIAN_POINT($,(-8.255,485.44226,1.90746000000001));
+#1205=VERTEX_POINT($,#1204);
+#1206=CARTESIAN_POINT($,(-233.045,485.44226,1.90746000000001));
+#1207=DIRECTION($,(1,0,0));
+#1208=VECTOR($,#1207,1);
+#1209=LINE($,#1206,#1208);
+#1210=EDGE_CURVE($,#1197,#1205,#1209,.T.);
+#1211=ORIENTED_EDGE($,$,$,#1210,.T.);
+#1212=CARTESIAN_POINT($,(-8.255,485.44226,1.90746000000001));
+#1213=DIRECTION($,(0,-1,0));
+#1214=VECTOR($,#1213,1);
+#1215=LINE($,#1212,#1214);
+#1216=EDGE_CURVE($,#1205,#1187,#1215,.T.);
+#1217=ORIENTED_EDGE($,$,$,#1216,.T.);
+#1218=EDGE_LOOP($,(#1195,#1203,#1211,#1217));
+#1219=FACE_OUTER_BOUND('',#1218,.T.);
+#1220=CARTESIAN_POINT($,(-24.6126,466.3948,1.90746000000001));
+#1221=VERTEX_POINT($,#1220);
+#1222=CARTESIAN_POINT($,(-19.05,466.3948,1.90746000000001));
+#1223=DIRECTION($,(0,0,1));
+#1224=DIRECTION($,(-1,0,0));
+#1225=AXIS2_PLACEMENT_3D($,#1222,#1223,#1224);
+#1226=CIRCLE($,#1225,5.5626);
+#1227=EDGE_CURVE($,#1221,#1221,#1226,.T.);
+#1228=ORIENTED_EDGE($,$,$,#1227,.T.);
+#1229=EDGE_LOOP($,(#1228));
+#1230=FACE_BOUND('',#1229,.T.);
+#1231=CARTESIAN_POINT($,(-227.8126,466.3948,1.90746000000001));
+#1232=VERTEX_POINT($,#1231);
+#1233=CARTESIAN_POINT($,(-222.25,466.3948,1.90746000000001));
+#1234=DIRECTION($,(0,0,1));
+#1235=DIRECTION($,(-1,0,0));
+#1236=AXIS2_PLACEMENT_3D($,#1233,#1234,#1235);
+#1237=CIRCLE($,#1236,5.5626);
+#1238=EDGE_CURVE($,#1232,#1232,#1237,.T.);
+#1239=ORIENTED_EDGE($,$,$,#1238,.T.);
+#1240=EDGE_LOOP($,(#1239));
+#1241=FACE_BOUND('',#1240,.T.);
+#1242=ADVANCED_FACE('',(#1219,#1230,#1241),#1185,.T.);
+#1243=CARTESIAN_POINT($,(-8.255,440.99226,0.00246000000001));
+#1244=DIRECTION($,(-0,-0,-1));
+#1245=DIRECTION($,(-1,0,0));
+#1246=AXIS2_PLACEMENT_3D($,#1243,#1244,#1245);
+#1247=PLANE($,#1246);
+#1248=CARTESIAN_POINT($,(-8.255,485.44226,0.00246000000001));
+#1249=VERTEX_POINT($,#1248);
+#1250=CARTESIAN_POINT($,(-233.045,485.44226,0.00246000000001));
+#1251=VERTEX_POINT($,#1250);
+#1252=CARTESIAN_POINT($,(-8.255,485.44226,0.00246000000001));
+#1253=DIRECTION($,(-1,0,0));
+#1254=VECTOR($,#1253,1);
+#1255=LINE($,#1252,#1254);
+#1256=EDGE_CURVE($,#1249,#1251,#1255,.T.);
+#1257=ORIENTED_EDGE($,$,$,#1256,.T.);
+#1258=CARTESIAN_POINT($,(-233.045,440.99226,0.00246000000001));
+#1259=VERTEX_POINT($,#1258);
+#1260=CARTESIAN_POINT($,(-233.045,485.44226,0.00246000000001));
+#1261=DIRECTION($,(0,-1,0));
+#1262=VECTOR($,#1261,1);
+#1263=LINE($,#1260,#1262);
+#1264=EDGE_CURVE($,#1251,#1259,#1263,.T.);
+#1265=ORIENTED_EDGE($,$,$,#1264,.T.);
+#1266=CARTESIAN_POINT($,(-8.255,440.99226,0.00246000000001));
+#1267=VERTEX_POINT($,#1266);
+#1268=CARTESIAN_POINT($,(-233.045,440.99226,0.00246000000001));
+#1269=DIRECTION($,(1,0,0));
+#1270=VECTOR($,#1269,1);
+#1271=LINE($,#1268,#1270);
+#1272=EDGE_CURVE($,#1259,#1267,#1271,.T.);
+#1273=ORIENTED_EDGE($,$,$,#1272,.T.);
+#1274=CARTESIAN_POINT($,(-8.255,440.99226,0.00246000000001));
+#1275=DIRECTION($,(0,1,0));
+#1276=VECTOR($,#1275,1);
+#1277=LINE($,#1274,#1276);
+#1278=EDGE_CURVE($,#1267,#1249,#1277,.T.);
+#1279=ORIENTED_EDGE($,$,$,#1278,.T.);
+#1280=EDGE_LOOP($,(#1257,#1265,#1273,#1279));
+#1281=FACE_OUTER_BOUND('',#1280,.T.);
+#1282=CARTESIAN_POINT($,(-24.6126,466.3948,0.00246000000001));
+#1283=VERTEX_POINT($,#1282);
+#1284=CARTESIAN_POINT($,(-19.05,466.3948,0.00246000000001));
+#1285=DIRECTION($,(0,0,1));
+#1286=DIRECTION($,(-1,0,0));
+#1287=AXIS2_PLACEMENT_3D($,#1284,#1285,#1286);
+#1288=CIRCLE($,#1287,5.5626);
+#1289=EDGE_CURVE($,#1283,#1283,#1288,.T.);
+#1290=ORIENTED_EDGE($,$,$,#1289,.T.);
+#1291=EDGE_LOOP($,(#1290));
+#1292=FACE_BOUND('',#1291,.T.);
+#1293=CARTESIAN_POINT($,(-227.8126,466.3948,0.00246000000001));
+#1294=VERTEX_POINT($,#1293);
+#1295=CARTESIAN_POINT($,(-222.25,466.3948,0.00246000000001));
+#1296=DIRECTION($,(0,0,1));
+#1297=DIRECTION($,(-1,0,0));
+#1298=AXIS2_PLACEMENT_3D($,#1295,#1296,#1297);
+#1299=CIRCLE($,#1298,5.5626);
+#1300=EDGE_CURVE($,#1294,#1294,#1299,.T.);
+#1301=ORIENTED_EDGE($,$,$,#1300,.T.);
+#1302=EDGE_LOOP($,(#1301));
+#1303=FACE_BOUND('',#1302,.T.);
+#1304=ADVANCED_FACE('',(#1281,#1292,#1303),#1247,.F.);
+#1305=CARTESIAN_POINT($,(-8.255,440.99226,8.25746000000001));
+#1306=DIRECTION($,(-1,0,0));
+#1307=DIRECTION($,(0,-1,0));
+#1308=AXIS2_PLACEMENT_3D($,#1305,#1306,#1307);
+#1309=CYLINDRICAL_SURFACE($,#1308,6.35000000000002);
+#1310=ORIENTED_EDGE($,$,$,#638,.F.);
+#1311=CARTESIAN_POINT($,(-233.045,440.99226,8.25746000000001));
+#1312=DIRECTION($,(1,-0,-0));
+#1313=DIRECTION($,(0,-1,0));
+#1314=AXIS2_PLACEMENT_3D($,#1311,#1312,#1313);
+#1315=CIRCLE($,#1314,6.35000000000002);
+#1316=TRIMMED_CURVE($,#1315,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1317=EDGE_CURVE($,#625,#1189,#1316,.T.);
+#1318=ORIENTED_EDGE($,$,$,#1317,.T.);
+#1319=ORIENTED_EDGE($,$,$,#1194,.F.);
+#1320=CARTESIAN_POINT($,(-8.255,440.99226,8.25746000000001));
+#1321=DIRECTION($,(-1,0,0));
+#1322=DIRECTION($,(0,0,-1));
+#1323=AXIS2_PLACEMENT_3D($,#1320,#1321,#1322);
+#1324=CIRCLE($,#1323,6.35);
+#1325=TRIMMED_CURVE($,#1324,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1326=EDGE_CURVE($,#1187,#633,#1325,.T.);
+#1327=ORIENTED_EDGE($,$,$,#1326,.T.);
+#1328=EDGE_LOOP($,(#1310,#1318,#1319,#1327));
+#1329=FACE_OUTER_BOUND('',#1328,.T.);
+#1330=ADVANCED_FACE('',(#1329),#1309,.T.);
+#1331=CARTESIAN_POINT($,(-8.255,440.99226,8.25746000000001));
+#1332=DIRECTION($,(-1,0,0));
+#1333=DIRECTION($,(0,-1,0));
+#1334=AXIS2_PLACEMENT_3D($,#1331,#1332,#1333);
+#1335=CYLINDRICAL_SURFACE($,#1334,8.255);
+#1336=ORIENTED_EDGE($,$,$,#1272,.F.);
+#1337=CARTESIAN_POINT($,(-233.045,440.99226,8.25746000000001));
+#1338=DIRECTION($,(-1,0,0));
+#1339=DIRECTION($,(0,0,-1));
+#1340=AXIS2_PLACEMENT_3D($,#1337,#1338,#1339);
+#1341=CIRCLE($,#1340,8.255);
+#1342=TRIMMED_CURVE($,#1341,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1343=EDGE_CURVE($,#1259,#657,#1342,.T.);
+#1344=ORIENTED_EDGE($,$,$,#1343,.T.);
+#1345=ORIENTED_EDGE($,$,$,#662,.F.);
+#1346=CARTESIAN_POINT($,(-8.255,440.99226,8.25746000000001));
+#1347=DIRECTION($,(1,-0,-0));
+#1348=DIRECTION($,(0,-1,0));
+#1349=AXIS2_PLACEMENT_3D($,#1346,#1347,#1348);
+#1350=CIRCLE($,#1349,8.255);
+#1351=TRIMMED_CURVE($,#1350,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1352=EDGE_CURVE($,#655,#1267,#1351,.T.);
+#1353=ORIENTED_EDGE($,$,$,#1352,.T.);
+#1354=EDGE_LOOP($,(#1336,#1344,#1345,#1353));
+#1355=FACE_OUTER_BOUND('',#1354,.T.);
+#1356=ADVANCED_FACE('',(#1355),#1335,.F.);
+#1357=CARTESIAN_POINT($,(8.76783352130505,181.12486,119.403106478695));
+#1358=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1359=DIRECTION($,(0,1,0));
+#1360=AXIS2_PLACEMENT_3D($,#1357,#1358,#1359);
+#1361=PLANE($,#1360);
+#1362=CARTESIAN_POINT($,(8.76783352130505,181.12486,119.403106478695));
+#1363=VERTEX_POINT($,#1362);
+#1364=CARTESIAN_POINT($,(8.76783352130505,308.12486,119.403106478695));
+#1365=VERTEX_POINT($,#1364);
+#1366=CARTESIAN_POINT($,(8.76783352130505,181.12486,119.403106478695));
+#1367=DIRECTION($,(0,1,0));
+#1368=VECTOR($,#1367,1);
+#1369=LINE($,#1366,#1368);
+#1370=EDGE_CURVE($,#1363,#1365,#1369,.T.);
+#1371=ORIENTED_EDGE($,$,$,#1370,.T.);
+#1372=CARTESIAN_POINT($,(43.0724119037892,308.12486,153.707684861179));
+#1373=VERTEX_POINT($,#1372);
+#1374=CARTESIAN_POINT($,(8.76783352130505,308.12486,119.403106478695));
+#1375=DIRECTION($,(0.707106781186548,0,0.707106781186548));
+#1376=VECTOR($,#1375,1);
+#1377=LINE($,#1374,#1376);
+#1378=EDGE_CURVE($,#1365,#1373,#1377,.T.);
+#1379=ORIENTED_EDGE($,$,$,#1378,.T.);
+#1380=CARTESIAN_POINT($,(43.0724119037892,295.42486,153.707684861179));
+#1381=VERTEX_POINT($,#1380);
+#1382=CARTESIAN_POINT($,(43.0724119037892,308.12486,153.707684861179));
+#1383=DIRECTION($,(0,-1,0));
+#1384=VECTOR($,#1383,1);
+#1385=LINE($,#1382,#1384);
+#1386=EDGE_CURVE($,#1373,#1381,#1385,.T.);
+#1387=ORIENTED_EDGE($,$,$,#1386,.T.);
+#1388=CARTESIAN_POINT($,(52.0526680248584,295.42486,162.687940982248));
+#1389=VERTEX_POINT($,#1388);
+#1390=CARTESIAN_POINT($,(43.0724119037892,295.42486,153.707684861179));
+#1391=DIRECTION($,(0.707106781186548,0,0.707106781186547));
+#1392=VECTOR($,#1391,1);
+#1393=LINE($,#1390,#1392);
+#1394=EDGE_CURVE($,#1381,#1389,#1393,.T.);
+#1395=ORIENTED_EDGE($,$,$,#1394,.T.);
+#1396=CARTESIAN_POINT($,(52.0526680248584,193.82486,162.687940982248));
+#1397=VERTEX_POINT($,#1396);
+#1398=CARTESIAN_POINT($,(52.0526680248584,295.42486,162.687940982248));
+#1399=DIRECTION($,(0,-1,0));
+#1400=VECTOR($,#1399,1);
+#1401=LINE($,#1398,#1400);
+#1402=EDGE_CURVE($,#1389,#1397,#1401,.T.);
+#1403=ORIENTED_EDGE($,$,$,#1402,.T.);
+#1404=CARTESIAN_POINT($,(43.0724119037892,193.82486,153.707684861179));
+#1405=VERTEX_POINT($,#1404);
+#1406=CARTESIAN_POINT($,(52.0526680248584,193.82486,162.687940982248));
+#1407=DIRECTION($,(-0.707106781186548,0,-0.707106781186547));
+#1408=VECTOR($,#1407,1);
+#1409=LINE($,#1406,#1408);
+#1410=EDGE_CURVE($,#1397,#1405,#1409,.T.);
+#1411=ORIENTED_EDGE($,$,$,#1410,.T.);
+#1412=CARTESIAN_POINT($,(43.0724119037892,181.12486,153.707684861179));
+#1413=VERTEX_POINT($,#1412);
+#1414=CARTESIAN_POINT($,(43.0724119037892,193.82486,153.707684861179));
+#1415=DIRECTION($,(0,-1,0));
+#1416=VECTOR($,#1415,1);
+#1417=LINE($,#1414,#1416);
+#1418=EDGE_CURVE($,#1405,#1413,#1417,.T.);
+#1419=ORIENTED_EDGE($,$,$,#1418,.T.);
+#1420=CARTESIAN_POINT($,(43.0724119037892,181.12486,153.707684861179));
+#1421=DIRECTION($,(-0.707106781186548,0,-0.707106781186548));
+#1422=VECTOR($,#1421,1);
+#1423=LINE($,#1420,#1422);
+#1424=EDGE_CURVE($,#1413,#1363,#1423,.T.);
+#1425=ORIENTED_EDGE($,$,$,#1424,.T.);
+#1426=EDGE_LOOP($,(#1371,#1379,#1387,#1395,#1403,#1411,#1419,#1425));
+#1427=FACE_OUTER_BOUND('',#1426,.T.);
+#1428=CARTESIAN_POINT($,(30.501323334841,258.15036,141.136596292231));
+#1429=VERTEX_POINT($,#1428);
+#1430=CARTESIAN_POINT($,(30.501323334841,244.62486,141.136596292231));
+#1431=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1432=DIRECTION($,(0,1,0));
+#1433=AXIS2_PLACEMENT_3D($,#1430,#1431,#1432);
+#1434=CIRCLE($,#1433,13.5255);
+#1435=EDGE_CURVE($,#1429,#1429,#1434,.T.);
+#1436=ORIENTED_EDGE($,$,$,#1435,.T.);
+#1437=EDGE_LOOP($,(#1436));
+#1438=FACE_BOUND('',#1437,.T.);
+#1439=CARTESIAN_POINT($,(20.6230416016649,227.95611,131.258314559055));
+#1440=VERTEX_POINT($,#1439);
+#1441=CARTESIAN_POINT($,(20.6230416016649,225.57486,131.258314559055));
+#1442=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1443=DIRECTION($,(0,1,0));
+#1444=AXIS2_PLACEMENT_3D($,#1441,#1442,#1443);
+#1445=CIRCLE($,#1444,2.38125);
+#1446=EDGE_CURVE($,#1440,#1440,#1445,.T.);
+#1447=ORIENTED_EDGE($,$,$,#1446,.T.);
+#1448=EDGE_LOOP($,(#1447));
+#1449=FACE_BOUND('',#1448,.T.);
+#1450=CARTESIAN_POINT($,(20.6230416016649,266.05611,131.258314559055));
+#1451=VERTEX_POINT($,#1450);
+#1452=CARTESIAN_POINT($,(20.6230416016649,263.67486,131.258314559055));
+#1453=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1454=DIRECTION($,(0,1,0));
+#1455=AXIS2_PLACEMENT_3D($,#1452,#1453,#1454);
+#1456=CIRCLE($,#1455,2.38125);
+#1457=EDGE_CURVE($,#1451,#1451,#1456,.T.);
+#1458=ORIENTED_EDGE($,$,$,#1457,.T.);
+#1459=EDGE_LOOP($,(#1458));
+#1460=FACE_BOUND('',#1459,.T.);
+#1461=CARTESIAN_POINT($,(43.0736819043378,227.95611,153.708954861728));
+#1462=VERTEX_POINT($,#1461);
+#1463=CARTESIAN_POINT($,(43.0736819043378,225.57486,153.708954861728));
+#1464=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1465=DIRECTION($,(0,1,0));
+#1466=AXIS2_PLACEMENT_3D($,#1463,#1464,#1465);
+#1467=CIRCLE($,#1466,2.38125);
+#1468=EDGE_CURVE($,#1462,#1462,#1467,.T.);
+#1469=ORIENTED_EDGE($,$,$,#1468,.T.);
+#1470=EDGE_LOOP($,(#1469));
+#1471=FACE_BOUND('',#1470,.T.);
+#1472=CARTESIAN_POINT($,(43.0736819043378,266.05611,153.708954861728));
+#1473=VERTEX_POINT($,#1472);
+#1474=CARTESIAN_POINT($,(43.0736819043378,263.67486,153.708954861728));
+#1475=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1476=DIRECTION($,(0,1,0));
+#1477=AXIS2_PLACEMENT_3D($,#1474,#1475,#1476);
+#1478=CIRCLE($,#1477,2.38125);
+#1479=EDGE_CURVE($,#1473,#1473,#1478,.T.);
+#1480=ORIENTED_EDGE($,$,$,#1479,.T.);
+#1481=EDGE_LOOP($,(#1480));
+#1482=FACE_BOUND('',#1481,.T.);
+#1483=ADVANCED_FACE('',(#1427,#1438,#1449,#1460,#1471,#1482),#1361,.T.);
+#1484=CARTESIAN_POINT($,(10.1148719394654,181.12486,118.056068060535));
+#1485=DIRECTION($,(0.707106781186548,-0,-0.707106781186548));
+#1486=DIRECTION($,(0,1,0));
+#1487=AXIS2_PLACEMENT_3D($,#1484,#1485,#1486);
+#1488=PLANE($,#1487);
+#1489=CARTESIAN_POINT($,(44.4194503219496,181.12486,152.360646443019));
+#1490=VERTEX_POINT($,#1489);
+#1491=CARTESIAN_POINT($,(44.4194503219496,193.82486,152.360646443019));
+#1492=VERTEX_POINT($,#1491);
+#1493=CARTESIAN_POINT($,(44.4194503219496,181.12486,152.360646443019));
+#1494=DIRECTION($,(0,1,0));
+#1495=VECTOR($,#1494,1);
+#1496=LINE($,#1493,#1495);
+#1497=EDGE_CURVE($,#1490,#1492,#1496,.T.);
+#1498=ORIENTED_EDGE($,$,$,#1497,.T.);
+#1499=CARTESIAN_POINT($,(53.3997064430187,193.82486,161.340902564088));
+#1500=VERTEX_POINT($,#1499);
+#1501=CARTESIAN_POINT($,(44.4194503219496,193.82486,152.360646443019));
+#1502=DIRECTION($,(0.707106781186548,0,0.707106781186547));
+#1503=VECTOR($,#1502,1);
+#1504=LINE($,#1501,#1503);
+#1505=EDGE_CURVE($,#1492,#1500,#1504,.T.);
+#1506=ORIENTED_EDGE($,$,$,#1505,.T.);
+#1507=CARTESIAN_POINT($,(53.3997064430187,295.42486,161.340902564088));
+#1508=VERTEX_POINT($,#1507);
+#1509=CARTESIAN_POINT($,(53.3997064430187,193.82486,161.340902564088));
+#1510=DIRECTION($,(0,1,0));
+#1511=VECTOR($,#1510,1);
+#1512=LINE($,#1509,#1511);
+#1513=EDGE_CURVE($,#1500,#1508,#1512,.T.);
+#1514=ORIENTED_EDGE($,$,$,#1513,.T.);
+#1515=CARTESIAN_POINT($,(44.4194503219496,295.42486,152.360646443019));
+#1516=VERTEX_POINT($,#1515);
+#1517=CARTESIAN_POINT($,(53.3997064430187,295.42486,161.340902564088));
+#1518=DIRECTION($,(-0.707106781186548,0,-0.707106781186547));
+#1519=VECTOR($,#1518,1);
+#1520=LINE($,#1517,#1519);
+#1521=EDGE_CURVE($,#1508,#1516,#1520,.T.);
+#1522=ORIENTED_EDGE($,$,$,#1521,.T.);
+#1523=CARTESIAN_POINT($,(44.4194503219496,308.12486,152.360646443019));
+#1524=VERTEX_POINT($,#1523);
+#1525=CARTESIAN_POINT($,(44.4194503219496,295.42486,152.360646443019));
+#1526=DIRECTION($,(0,1,0));
+#1527=VECTOR($,#1526,1);
+#1528=LINE($,#1525,#1527);
+#1529=EDGE_CURVE($,#1516,#1524,#1528,.T.);
+#1530=ORIENTED_EDGE($,$,$,#1529,.T.);
+#1531=CARTESIAN_POINT($,(10.1148719394654,308.12486,118.056068060535));
+#1532=VERTEX_POINT($,#1531);
+#1533=CARTESIAN_POINT($,(44.4194503219496,308.12486,152.360646443019));
+#1534=DIRECTION($,(-0.707106781186547,0,-0.707106781186548));
+#1535=VECTOR($,#1534,1);
+#1536=LINE($,#1533,#1535);
+#1537=EDGE_CURVE($,#1524,#1532,#1536,.T.);
+#1538=ORIENTED_EDGE($,$,$,#1537,.T.);
+#1539=CARTESIAN_POINT($,(10.1148719394654,181.12486,118.056068060535));
+#1540=VERTEX_POINT($,#1539);
+#1541=CARTESIAN_POINT($,(10.1148719394654,308.12486,118.056068060535));
+#1542=DIRECTION($,(0,-1,0));
+#1543=VECTOR($,#1542,1);
+#1544=LINE($,#1541,#1543);
+#1545=EDGE_CURVE($,#1532,#1540,#1544,.T.);
+#1546=ORIENTED_EDGE($,$,$,#1545,.T.);
+#1547=CARTESIAN_POINT($,(10.1148719394654,181.12486,118.056068060535));
+#1548=DIRECTION($,(0.707106781186547,0,0.707106781186548));
+#1549=VECTOR($,#1548,1);
+#1550=LINE($,#1547,#1549);
+#1551=EDGE_CURVE($,#1540,#1490,#1550,.T.);
+#1552=ORIENTED_EDGE($,$,$,#1551,.T.);
+#1553=EDGE_LOOP($,(#1498,#1506,#1514,#1522,#1530,#1538,#1546,#1552));
+#1554=FACE_OUTER_BOUND('',#1553,.T.);
+#1555=CARTESIAN_POINT($,(31.8483617530013,258.15036,139.789557874071));
+#1556=VERTEX_POINT($,#1555);
+#1557=CARTESIAN_POINT($,(31.8483617530013,244.62486,139.789557874071));
+#1558=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1559=DIRECTION($,(0,1,0));
+#1560=AXIS2_PLACEMENT_3D($,#1557,#1558,#1559);
+#1561=CIRCLE($,#1560,13.5255);
+#1562=EDGE_CURVE($,#1556,#1556,#1561,.T.);
+#1563=ORIENTED_EDGE($,$,$,#1562,.T.);
+#1564=EDGE_LOOP($,(#1563));
+#1565=FACE_BOUND('',#1564,.T.);
+#1566=CARTESIAN_POINT($,(21.9700800198253,227.95611,129.911276140894));
+#1567=VERTEX_POINT($,#1566);
+#1568=CARTESIAN_POINT($,(21.9700800198253,225.57486,129.911276140894));
+#1569=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1570=DIRECTION($,(0,1,0));
+#1571=AXIS2_PLACEMENT_3D($,#1568,#1569,#1570);
+#1572=CIRCLE($,#1571,2.38125);
+#1573=EDGE_CURVE($,#1567,#1567,#1572,.T.);
+#1574=ORIENTED_EDGE($,$,$,#1573,.T.);
+#1575=EDGE_LOOP($,(#1574));
+#1576=FACE_BOUND('',#1575,.T.);
+#1577=CARTESIAN_POINT($,(21.9700800198253,266.05611,129.911276140894));
+#1578=VERTEX_POINT($,#1577);
+#1579=CARTESIAN_POINT($,(21.9700800198253,263.67486,129.911276140894));
+#1580=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1581=DIRECTION($,(0,1,0));
+#1582=AXIS2_PLACEMENT_3D($,#1579,#1580,#1581);
+#1583=CIRCLE($,#1582,2.38125);
+#1584=EDGE_CURVE($,#1578,#1578,#1583,.T.);
+#1585=ORIENTED_EDGE($,$,$,#1584,.T.);
+#1586=EDGE_LOOP($,(#1585));
+#1587=FACE_BOUND('',#1586,.T.);
+#1588=CARTESIAN_POINT($,(44.4207203224982,227.95611,152.361916443567));
+#1589=VERTEX_POINT($,#1588);
+#1590=CARTESIAN_POINT($,(44.4207203224982,225.57486,152.361916443567));
+#1591=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1592=DIRECTION($,(0,1,0));
+#1593=AXIS2_PLACEMENT_3D($,#1590,#1591,#1592);
+#1594=CIRCLE($,#1593,2.38125);
+#1595=EDGE_CURVE($,#1589,#1589,#1594,.T.);
+#1596=ORIENTED_EDGE($,$,$,#1595,.T.);
+#1597=EDGE_LOOP($,(#1596));
+#1598=FACE_BOUND('',#1597,.T.);
+#1599=CARTESIAN_POINT($,(44.4207203224982,266.05611,152.361916443567));
+#1600=VERTEX_POINT($,#1599);
+#1601=CARTESIAN_POINT($,(44.4207203224982,263.67486,152.361916443567));
+#1602=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1603=DIRECTION($,(0,1,0));
+#1604=AXIS2_PLACEMENT_3D($,#1601,#1602,#1603);
+#1605=CIRCLE($,#1604,2.38125);
+#1606=EDGE_CURVE($,#1600,#1600,#1605,.T.);
+#1607=ORIENTED_EDGE($,$,$,#1606,.T.);
+#1608=EDGE_LOOP($,(#1607));
+#1609=FACE_BOUND('',#1608,.T.);
+#1610=ADVANCED_FACE('',(#1554,#1565,#1576,#1587,#1598,#1609),#1488,.F.);
+#1611=CARTESIAN_POINT($,(14.605,181.12486,113.56594));
+#1612=DIRECTION($,(0,1,0));
+#1613=DIRECTION($,(-1,0,0));
+#1614=AXIS2_PLACEMENT_3D($,#1611,#1612,#1613);
+#1615=CYLINDRICAL_SURFACE($,#1614,8.255);
+#1616=CARTESIAN_POINT($,(6.35,181.12486,113.56594));
+#1617=VERTEX_POINT($,#1616);
+#1618=CARTESIAN_POINT($,(6.35,308.12486,113.56594));
+#1619=VERTEX_POINT($,#1618);
+#1620=CARTESIAN_POINT($,(6.35,181.12486,113.56594));
+#1621=DIRECTION($,(0,1,0));
+#1622=VECTOR($,#1621,1);
+#1623=LINE($,#1620,#1622);
+#1624=EDGE_CURVE($,#1617,#1619,#1623,.T.);
+#1625=ORIENTED_EDGE($,$,$,#1624,.T.);
+#1626=CARTESIAN_POINT($,(14.605,308.12486,113.56594));
+#1627=DIRECTION($,(0,1,0));
+#1628=DIRECTION($,(-1,0,0));
+#1629=AXIS2_PLACEMENT_3D($,#1626,#1627,#1628);
+#1630=CIRCLE($,#1629,8.255);
+#1631=TRIMMED_CURVE($,#1630,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(0.785398163397449)),.T.,.PARAMETER.);
+#1632=EDGE_CURVE($,#1619,#1365,#1631,.T.);
+#1633=ORIENTED_EDGE($,$,$,#1632,.T.);
+#1634=ORIENTED_EDGE($,$,$,#1370,.F.);
+#1635=CARTESIAN_POINT($,(14.605,181.12486,113.56594));
+#1636=DIRECTION($,(-0,-1,-0));
+#1637=DIRECTION($,(-0.707106781186547,0,0.707106781186548));
+#1638=AXIS2_PLACEMENT_3D($,#1635,#1636,#1637);
+#1639=CIRCLE($,#1638,8.255);
+#1640=TRIMMED_CURVE($,#1639,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(0.785398163397449)),.T.,.PARAMETER.);
+#1641=EDGE_CURVE($,#1363,#1617,#1640,.T.);
+#1642=ORIENTED_EDGE($,$,$,#1641,.T.);
+#1643=EDGE_LOOP($,(#1625,#1633,#1634,#1642));
+#1644=FACE_OUTER_BOUND('',#1643,.T.);
+#1645=ADVANCED_FACE('',(#1644),#1615,.T.);
+#1646=CARTESIAN_POINT($,(14.605,181.12486,113.56594));
+#1647=DIRECTION($,(0,1,0));
+#1648=DIRECTION($,(-1,0,0));
+#1649=AXIS2_PLACEMENT_3D($,#1646,#1647,#1648);
+#1650=CYLINDRICAL_SURFACE($,#1649,6.35);
+#1651=ORIENTED_EDGE($,$,$,#1545,.F.);
+#1652=CARTESIAN_POINT($,(8.25499999999999,308.12486,113.56594));
+#1653=VERTEX_POINT($,#1652);
+#1654=CARTESIAN_POINT($,(14.605,308.12486,113.56594));
+#1655=DIRECTION($,(-0,-1,-0));
+#1656=DIRECTION($,(-0.707106781186547,0,0.707106781186548));
+#1657=AXIS2_PLACEMENT_3D($,#1654,#1655,#1656);
+#1658=CIRCLE($,#1657,6.35000000000001);
+#1659=TRIMMED_CURVE($,#1658,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(0.78539816339745)),.T.,.PARAMETER.);
+#1660=EDGE_CURVE($,#1532,#1653,#1659,.T.);
+#1661=ORIENTED_EDGE($,$,$,#1660,.T.);
+#1662=CARTESIAN_POINT($,(8.255,181.12486,113.56594));
+#1663=VERTEX_POINT($,#1662);
+#1664=CARTESIAN_POINT($,(8.25499999999999,308.12486,113.56594));
+#1665=DIRECTION($,(0,-1,0));
+#1666=VECTOR($,#1665,1);
+#1667=LINE($,#1664,#1666);
+#1668=EDGE_CURVE($,#1653,#1663,#1667,.T.);
+#1669=ORIENTED_EDGE($,$,$,#1668,.T.);
+#1670=CARTESIAN_POINT($,(14.605,181.12486,113.56594));
+#1671=DIRECTION($,(0,1,0));
+#1672=DIRECTION($,(-1,0,0));
+#1673=AXIS2_PLACEMENT_3D($,#1670,#1671,#1672);
+#1674=CIRCLE($,#1673,6.35);
+#1675=TRIMMED_CURVE($,#1674,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(0.78539816339745)),.T.,.PARAMETER.);
+#1676=EDGE_CURVE($,#1663,#1540,#1675,.T.);
+#1677=ORIENTED_EDGE($,$,$,#1676,.T.);
+#1678=EDGE_LOOP($,(#1651,#1661,#1669,#1677));
+#1679=FACE_OUTER_BOUND('',#1678,.T.);
+#1680=ADVANCED_FACE('',(#1679),#1650,.F.);
+#1681=CARTESIAN_POINT($,(-241.3,58.08726,78.105));
+#1682=DIRECTION($,(-0,1,0));
+#1683=DIRECTION($,(1,0,0));
+#1684=AXIS2_PLACEMENT_3D($,#1681,#1682,#1683);
+#1685=PLANE($,#1684);
+#1686=ORIENTED_EDGE($,$,$,#14,.T.);
+#1687=CARTESIAN_POINT($,(-233.045,58.08726,78.105));
+#1688=DIRECTION($,(0,0,-1));
+#1689=VECTOR($,#1688,1);
+#1690=LINE($,#1687,#1689);
+#1691=EDGE_CURVE($,#9,#319,#1690,.T.);
+#1692=ORIENTED_EDGE($,$,$,#1691,.T.);
+#1693=ORIENTED_EDGE($,$,$,#332,.T.);
+#1694=CARTESIAN_POINT($,(-241.3,58.08726,76.2));
+#1695=DIRECTION($,(0,0,1));
+#1696=VECTOR($,#1695,1);
+#1697=LINE($,#1694,#1696);
+#1698=EDGE_CURVE($,#327,#7,#1697,.T.);
+#1699=ORIENTED_EDGE($,$,$,#1698,.T.);
+#1700=EDGE_LOOP($,(#1686,#1692,#1693,#1699));
+#1701=FACE_OUTER_BOUND('',#1700,.T.);
+#1702=ADVANCED_FACE('',(#1701),#1685,.T.);
+#1703=CARTESIAN_POINT($,(-8.255,58.08726,78.105));
+#1704=DIRECTION($,(-0,1,0));
+#1705=DIRECTION($,(1,0,0));
+#1706=AXIS2_PLACEMENT_3D($,#1703,#1704,#1705);
+#1707=PLANE($,#1706);
+#1708=ORIENTED_EDGE($,$,$,#30,.T.);
+#1709=CARTESIAN_POINT($,(0,58.08726,78.105));
+#1710=DIRECTION($,(0,0,-1));
+#1711=VECTOR($,#1710,1);
+#1712=LINE($,#1709,#1711);
+#1713=EDGE_CURVE($,#25,#303,#1712,.T.);
+#1714=ORIENTED_EDGE($,$,$,#1713,.T.);
+#1715=ORIENTED_EDGE($,$,$,#316,.T.);
+#1716=CARTESIAN_POINT($,(-8.255,58.08726,76.2));
+#1717=DIRECTION($,(0,0,1));
+#1718=VECTOR($,#1717,1);
+#1719=LINE($,#1716,#1718);
+#1720=EDGE_CURVE($,#311,#17,#1719,.T.);
+#1721=ORIENTED_EDGE($,$,$,#1720,.T.);
+#1722=EDGE_LOOP($,(#1708,#1714,#1715,#1721));
+#1723=FACE_OUTER_BOUND('',#1722,.T.);
+#1724=ADVANCED_FACE('',(#1723),#1707,.T.);
+#1725=CARTESIAN_POINT($,(0,58.08726,78.105));
+#1726=DIRECTION($,(-1,0,0));
+#1727=DIRECTION($,(0,1,0));
+#1728=AXIS2_PLACEMENT_3D($,#1725,#1726,#1727);
+#1729=PLANE($,#1728);
+#1730=ORIENTED_EDGE($,$,$,#38,.T.);
+#1731=CARTESIAN_POINT($,(0,66.34226,78.105));
+#1732=DIRECTION($,(0,0,-1));
+#1733=VECTOR($,#1732,1);
+#1734=LINE($,#1731,#1733);
+#1735=EDGE_CURVE($,#33,#295,#1734,.T.);
+#1736=ORIENTED_EDGE($,$,$,#1735,.T.);
+#1737=ORIENTED_EDGE($,$,$,#308,.T.);
+#1738=ORIENTED_EDGE($,$,$,#1713,.F.);
+#1739=EDGE_LOOP($,(#1730,#1736,#1737,#1738));
+#1740=FACE_OUTER_BOUND('',#1739,.T.);
+#1741=ADVANCED_FACE('',(#1740),#1729,.T.);
+#1742=CARTESIAN_POINT($,(0,418.13226,78.105));
+#1743=DIRECTION($,(-1,0,0));
+#1744=DIRECTION($,(0,1,0));
+#1745=AXIS2_PLACEMENT_3D($,#1742,#1743,#1744);
+#1746=PLANE($,#1745);
+#1747=ORIENTED_EDGE($,$,$,#54,.T.);
+#1748=CARTESIAN_POINT($,(0,426.38726,78.105));
+#1749=DIRECTION($,(0,0,-1));
+#1750=VECTOR($,#1749,1);
+#1751=LINE($,#1748,#1750);
+#1752=EDGE_CURVE($,#49,#279,#1751,.T.);
+#1753=ORIENTED_EDGE($,$,$,#1752,.T.);
+#1754=ORIENTED_EDGE($,$,$,#292,.T.);
+#1755=CARTESIAN_POINT($,(0,418.13226,76.2));
+#1756=DIRECTION($,(0,0,1));
+#1757=VECTOR($,#1756,1);
+#1758=LINE($,#1755,#1757);
+#1759=EDGE_CURVE($,#287,#41,#1758,.T.);
+#1760=ORIENTED_EDGE($,$,$,#1759,.T.);
+#1761=EDGE_LOOP($,(#1747,#1753,#1754,#1760));
+#1762=FACE_OUTER_BOUND('',#1761,.T.);
+#1763=ADVANCED_FACE('',(#1762),#1746,.T.);
+#1764=CARTESIAN_POINT($,(0,426.38726,78.105));
+#1765=DIRECTION($,(-0,-1,-0));
+#1766=DIRECTION($,(-1,0,0));
+#1767=AXIS2_PLACEMENT_3D($,#1764,#1765,#1766);
+#1768=PLANE($,#1767);
+#1769=ORIENTED_EDGE($,$,$,#62,.T.);
+#1770=CARTESIAN_POINT($,(-8.255,426.38726,78.105));
+#1771=DIRECTION($,(0,0,-1));
+#1772=VECTOR($,#1771,1);
+#1773=LINE($,#1770,#1772);
+#1774=EDGE_CURVE($,#57,#271,#1773,.T.);
+#1775=ORIENTED_EDGE($,$,$,#1774,.T.);
+#1776=ORIENTED_EDGE($,$,$,#284,.T.);
+#1777=ORIENTED_EDGE($,$,$,#1752,.F.);
+#1778=EDGE_LOOP($,(#1769,#1775,#1776,#1777));
+#1779=FACE_OUTER_BOUND('',#1778,.T.);
+#1780=ADVANCED_FACE('',(#1779),#1768,.T.);
+#1781=CARTESIAN_POINT($,(-233.045,426.38726,78.105));
+#1782=DIRECTION($,(-0,-1,-0));
+#1783=DIRECTION($,(-1,0,0));
+#1784=AXIS2_PLACEMENT_3D($,#1781,#1782,#1783);
+#1785=PLANE($,#1784);
+#1786=ORIENTED_EDGE($,$,$,#78,.T.);
+#1787=CARTESIAN_POINT($,(-241.3,426.38726,78.105));
+#1788=DIRECTION($,(0,0,-1));
+#1789=VECTOR($,#1788,1);
+#1790=LINE($,#1787,#1789);
+#1791=EDGE_CURVE($,#73,#255,#1790,.T.);
+#1792=ORIENTED_EDGE($,$,$,#1791,.T.);
+#1793=ORIENTED_EDGE($,$,$,#268,.T.);
+#1794=CARTESIAN_POINT($,(-233.045,426.38726,76.2));
+#1795=DIRECTION($,(0,0,1));
+#1796=VECTOR($,#1795,1);
+#1797=LINE($,#1794,#1796);
+#1798=EDGE_CURVE($,#263,#65,#1797,.T.);
+#1799=ORIENTED_EDGE($,$,$,#1798,.T.);
+#1800=EDGE_LOOP($,(#1786,#1792,#1793,#1799));
+#1801=FACE_OUTER_BOUND('',#1800,.T.);
+#1802=ADVANCED_FACE('',(#1801),#1785,.T.);
+#1803=CARTESIAN_POINT($,(-241.3,426.38726,78.105));
+#1804=DIRECTION($,(1,0,0));
+#1805=DIRECTION($,(0,-1,0));
+#1806=AXIS2_PLACEMENT_3D($,#1803,#1804,#1805);
+#1807=PLANE($,#1806);
+#1808=ORIENTED_EDGE($,$,$,#86,.T.);
+#1809=CARTESIAN_POINT($,(-241.3,418.13226,78.105));
+#1810=DIRECTION($,(0,0,-1));
+#1811=VECTOR($,#1810,1);
+#1812=LINE($,#1809,#1811);
+#1813=EDGE_CURVE($,#81,#247,#1812,.T.);
+#1814=ORIENTED_EDGE($,$,$,#1813,.T.);
+#1815=ORIENTED_EDGE($,$,$,#260,.T.);
+#1816=ORIENTED_EDGE($,$,$,#1791,.F.);
+#1817=EDGE_LOOP($,(#1808,#1814,#1815,#1816));
+#1818=FACE_OUTER_BOUND('',#1817,.T.);
+#1819=ADVANCED_FACE('',(#1818),#1807,.T.);
+#1820=CARTESIAN_POINT($,(-241.3,66.34226,78.105));
+#1821=DIRECTION($,(1,0,0));
+#1822=DIRECTION($,(0,-1,0));
+#1823=AXIS2_PLACEMENT_3D($,#1820,#1821,#1822);
+#1824=PLANE($,#1823);
+#1825=ORIENTED_EDGE($,$,$,#100,.T.);
+#1826=ORIENTED_EDGE($,$,$,#1698,.F.);
+#1827=ORIENTED_EDGE($,$,$,#338,.T.);
+#1828=CARTESIAN_POINT($,(-241.3,66.34226,76.2));
+#1829=DIRECTION($,(0,0,1));
+#1830=VECTOR($,#1829,1);
+#1831=LINE($,#1828,#1830);
+#1832=EDGE_CURVE($,#245,#89,#1831,.T.);
+#1833=ORIENTED_EDGE($,$,$,#1832,.T.);
+#1834=EDGE_LOOP($,(#1825,#1826,#1827,#1833));
+#1835=FACE_OUTER_BOUND('',#1834,.T.);
+#1836=ADVANCED_FACE('',(#1835),#1824,.T.);
+#1837=CARTESIAN_POINT($,(-8.255,49.83226,69.85));
+#1838=DIRECTION($,(1,-0,0));
+#1839=DIRECTION($,(0,-0,-1));
+#1840=AXIS2_PLACEMENT_3D($,#1837,#1838,#1839);
+#1841=PLANE($,#1840);
+#1842=ORIENTED_EDGE($,$,$,#498,.T.);
+#1843=CARTESIAN_POINT($,(-8.255,49.83226,8.25746000000001));
+#1844=DIRECTION($,(0,1,0));
+#1845=VECTOR($,#1844,1);
+#1846=LINE($,#1843,#1845);
+#1847=EDGE_CURVE($,#493,#525,#1846,.T.);
+#1848=ORIENTED_EDGE($,$,$,#1847,.T.);
+#1849=ORIENTED_EDGE($,$,$,#538,.T.);
+#1850=CARTESIAN_POINT($,(-8.255,51.73726,69.85));
+#1851=DIRECTION($,(0,-1,0));
+#1852=VECTOR($,#1851,1);
+#1853=LINE($,#1850,#1852);
+#1854=EDGE_CURVE($,#533,#485,#1853,.T.);
+#1855=ORIENTED_EDGE($,$,$,#1854,.T.);
+#1856=EDGE_LOOP($,(#1842,#1848,#1849,#1855));
+#1857=FACE_OUTER_BOUND('',#1856,.T.);
+#1858=ADVANCED_FACE('',(#1857),#1841,.T.);
+#1859=CARTESIAN_POINT($,(-233.045,49.83226,8.25746000000001));
+#1860=DIRECTION($,(-1,0,0));
+#1861=DIRECTION($,(0,0,1));
+#1862=AXIS2_PLACEMENT_3D($,#1859,#1860,#1861);
+#1863=PLANE($,#1862);
+#1864=ORIENTED_EDGE($,$,$,#512,.T.);
+#1865=CARTESIAN_POINT($,(-233.045,49.83226,69.85));
+#1866=DIRECTION($,(0,1,0));
+#1867=VECTOR($,#1866,1);
+#1868=LINE($,#1865,#1867);
+#1869=EDGE_CURVE($,#483,#541,#1868,.T.);
+#1870=ORIENTED_EDGE($,$,$,#1869,.T.);
+#1871=ORIENTED_EDGE($,$,$,#552,.T.);
+#1872=CARTESIAN_POINT($,(-233.045,51.73726,8.25746000000001));
+#1873=DIRECTION($,(0,-1,0));
+#1874=VECTOR($,#1873,1);
+#1875=LINE($,#1872,#1874);
+#1876=EDGE_CURVE($,#523,#501,#1875,.T.);
+#1877=ORIENTED_EDGE($,$,$,#1876,.T.);
+#1878=EDGE_LOOP($,(#1864,#1870,#1871,#1877));
+#1879=FACE_OUTER_BOUND('',#1878,.T.);
+#1880=ADVANCED_FACE('',(#1879),#1863,.T.);
+#1881=CARTESIAN_POINT($,(-8.255,58.08726,78.105));
+#1882=DIRECTION($,(1,0,0));
+#1883=DIRECTION($,(0,-0.707106781186548,-0.707106781186547));
+#1884=AXIS2_PLACEMENT_3D($,#1881,#1882,#1883);
+#1885=PLANE($,#1884);
+#1886=ORIENTED_EDGE($,$,$,#569,.T.);
+#1887=ORIENTED_EDGE($,$,$,#1854,.F.);
+#1888=ORIENTED_EDGE($,$,$,#595,.T.);
+#1889=ORIENTED_EDGE($,$,$,#1720,.T.);
+#1890=EDGE_LOOP($,(#1886,#1887,#1888,#1889));
+#1891=FACE_OUTER_BOUND('',#1890,.T.);
+#1892=ADVANCED_FACE('',(#1891),#1885,.T.);
+#1893=CARTESIAN_POINT($,(-233.045,49.83226,69.85));
+#1894=DIRECTION($,(-1,0,0));
+#1895=DIRECTION($,(0,0.707106781186548,0.707106781186547));
+#1896=AXIS2_PLACEMENT_3D($,#1893,#1894,#1895);
+#1897=PLANE($,#1896);
+#1898=ORIENTED_EDGE($,$,$,#578,.T.);
+#1899=ORIENTED_EDGE($,$,$,#1691,.T.);
+#1900=ORIENTED_EDGE($,$,$,#604,.T.);
+#1901=ORIENTED_EDGE($,$,$,#1869,.F.);
+#1902=EDGE_LOOP($,(#1898,#1899,#1900,#1901));
+#1903=FACE_OUTER_BOUND('',#1902,.T.);
+#1904=ADVANCED_FACE('',(#1903),#1897,.T.);
+#1905=CARTESIAN_POINT($,(-233.045,434.64226,69.85));
+#1906=DIRECTION($,(-1,-0,-0));
+#1907=DIRECTION($,(0,0,-1));
+#1908=AXIS2_PLACEMENT_3D($,#1905,#1906,#1907);
+#1909=PLANE($,#1908);
+#1910=ORIENTED_EDGE($,$,$,#630,.T.);
+#1911=CARTESIAN_POINT($,(-233.045,434.64226,8.25746000000001));
+#1912=DIRECTION($,(0,-1,0));
+#1913=VECTOR($,#1912,1);
+#1914=LINE($,#1911,#1913);
+#1915=EDGE_CURVE($,#625,#657,#1914,.T.);
+#1916=ORIENTED_EDGE($,$,$,#1915,.T.);
+#1917=ORIENTED_EDGE($,$,$,#670,.T.);
+#1918=CARTESIAN_POINT($,(-233.045,432.73726,69.85));
+#1919=DIRECTION($,(0,1,0));
+#1920=VECTOR($,#1919,1);
+#1921=LINE($,#1918,#1920);
+#1922=EDGE_CURVE($,#665,#617,#1921,.T.);
+#1923=ORIENTED_EDGE($,$,$,#1922,.T.);
+#1924=EDGE_LOOP($,(#1910,#1916,#1917,#1923));
+#1925=FACE_OUTER_BOUND('',#1924,.T.);
+#1926=ADVANCED_FACE('',(#1925),#1909,.T.);
+#1927=CARTESIAN_POINT($,(-8.255,434.64226,8.25746000000001));
+#1928=DIRECTION($,(1,0,-0));
+#1929=DIRECTION($,(0,0,1));
+#1930=AXIS2_PLACEMENT_3D($,#1927,#1928,#1929);
+#1931=PLANE($,#1930);
+#1932=ORIENTED_EDGE($,$,$,#644,.T.);
+#1933=CARTESIAN_POINT($,(-8.255,434.64226,69.85));
+#1934=DIRECTION($,(0,-1,0));
+#1935=VECTOR($,#1934,1);
+#1936=LINE($,#1933,#1935);
+#1937=EDGE_CURVE($,#615,#673,#1936,.T.);
+#1938=ORIENTED_EDGE($,$,$,#1937,.T.);
+#1939=ORIENTED_EDGE($,$,$,#684,.T.);
+#1940=CARTESIAN_POINT($,(-8.255,432.73726,8.25746000000001));
+#1941=DIRECTION($,(0,1,0));
+#1942=VECTOR($,#1941,1);
+#1943=LINE($,#1940,#1942);
+#1944=EDGE_CURVE($,#655,#633,#1943,.T.);
+#1945=ORIENTED_EDGE($,$,$,#1944,.T.);
+#1946=EDGE_LOOP($,(#1932,#1938,#1939,#1945));
+#1947=FACE_OUTER_BOUND('',#1946,.T.);
+#1948=ADVANCED_FACE('',(#1947),#1931,.T.);
+#1949=CARTESIAN_POINT($,(-233.045,426.38726,78.105));
+#1950=DIRECTION($,(-1,0,0));
+#1951=DIRECTION($,(0,0.707106781186548,-0.707106781186548));
+#1952=AXIS2_PLACEMENT_3D($,#1949,#1950,#1951);
+#1953=PLANE($,#1952);
+#1954=ORIENTED_EDGE($,$,$,#701,.T.);
+#1955=ORIENTED_EDGE($,$,$,#1922,.F.);
+#1956=ORIENTED_EDGE($,$,$,#727,.T.);
+#1957=ORIENTED_EDGE($,$,$,#1798,.T.);
+#1958=EDGE_LOOP($,(#1954,#1955,#1956,#1957));
+#1959=FACE_OUTER_BOUND('',#1958,.T.);
+#1960=ADVANCED_FACE('',(#1959),#1953,.T.);
+#1961=CARTESIAN_POINT($,(-8.255,434.64226,69.85));
+#1962=DIRECTION($,(1,0,0));
+#1963=DIRECTION($,(0,-0.707106781186548,0.707106781186548));
+#1964=AXIS2_PLACEMENT_3D($,#1961,#1962,#1963);
+#1965=PLANE($,#1964);
+#1966=ORIENTED_EDGE($,$,$,#710,.T.);
+#1967=ORIENTED_EDGE($,$,$,#1774,.T.);
+#1968=ORIENTED_EDGE($,$,$,#736,.T.);
+#1969=ORIENTED_EDGE($,$,$,#1937,.F.);
+#1970=EDGE_LOOP($,(#1966,#1967,#1968,#1969));
+#1971=FACE_OUTER_BOUND('',#1970,.T.);
+#1972=ADVANCED_FACE('',(#1971),#1965,.T.);
+#1973=CARTESIAN_POINT($,(-247.65,66.34226,84.455));
+#1974=DIRECTION($,(0,-1,0));
+#1975=DIRECTION($,(0,0,1));
+#1976=AXIS2_PLACEMENT_3D($,#1973,#1974,#1975);
+#1977=PLANE($,#1976);
+#1978=ORIENTED_EDGE($,$,$,#762,.T.);
+#1979=CARTESIAN_POINT($,(-247.65,66.34226,128.905));
+#1980=DIRECTION($,(-1,0,0));
+#1981=VECTOR($,#1980,1);
+#1982=LINE($,#1979,#1981);
+#1983=EDGE_CURVE($,#757,#789,#1982,.T.);
+#1984=ORIENTED_EDGE($,$,$,#1983,.T.);
+#1985=ORIENTED_EDGE($,$,$,#802,.T.);
+#1986=CARTESIAN_POINT($,(-249.555,66.34226,84.455));
+#1987=DIRECTION($,(1,0,0));
+#1988=VECTOR($,#1987,1);
+#1989=LINE($,#1986,#1988);
+#1990=EDGE_CURVE($,#797,#749,#1989,.T.);
+#1991=ORIENTED_EDGE($,$,$,#1990,.T.);
+#1992=EDGE_LOOP($,(#1978,#1984,#1985,#1991));
+#1993=FACE_OUTER_BOUND('',#1992,.T.);
+#1994=ADVANCED_FACE('',(#1993),#1977,.T.);
+#1995=CARTESIAN_POINT($,(-247.65,66.34226,128.905));
+#1996=DIRECTION($,(0,-0,1));
+#1997=DIRECTION($,(0,1,0));
+#1998=AXIS2_PLACEMENT_3D($,#1995,#1996,#1997);
+#1999=PLANE($,#1998);
+#2000=ORIENTED_EDGE($,$,$,#770,.T.);
+#2001=CARTESIAN_POINT($,(-247.65,418.13226,128.905));
+#2002=DIRECTION($,(-1,0,0));
+#2003=VECTOR($,#2002,1);
+#2004=LINE($,#2001,#2003);
+#2005=EDGE_CURVE($,#765,#787,#2004,.T.);
+#2006=ORIENTED_EDGE($,$,$,#2005,.T.);
+#2007=ORIENTED_EDGE($,$,$,#794,.T.);
+#2008=ORIENTED_EDGE($,$,$,#1983,.F.);
+#2009=EDGE_LOOP($,(#2000,#2006,#2007,#2008));
+#2010=FACE_OUTER_BOUND('',#2009,.T.);
+#2011=ADVANCED_FACE('',(#2010),#1999,.T.);
+#2012=CARTESIAN_POINT($,(-247.65,418.13226,128.905));
+#2013=DIRECTION($,(0,1,0));
+#2014=DIRECTION($,(0,0,-1));
+#2015=AXIS2_PLACEMENT_3D($,#2012,#2013,#2014);
+#2016=PLANE($,#2015);
+#2017=ORIENTED_EDGE($,$,$,#776,.T.);
+#2018=CARTESIAN_POINT($,(-247.65,418.13226,84.455));
+#2019=DIRECTION($,(-1,0,0));
+#2020=VECTOR($,#2019,1);
+#2021=LINE($,#2018,#2020);
+#2022=EDGE_CURVE($,#747,#805,#2021,.T.);
+#2023=ORIENTED_EDGE($,$,$,#2022,.T.);
+#2024=ORIENTED_EDGE($,$,$,#816,.T.);
+#2025=ORIENTED_EDGE($,$,$,#2005,.F.);
+#2026=EDGE_LOOP($,(#2017,#2023,#2024,#2025));
+#2027=FACE_OUTER_BOUND('',#2026,.T.);
+#2028=ADVANCED_FACE('',(#2027),#2016,.T.);
+#2029=CARTESIAN_POINT($,(-241.3,66.34226,78.105));
+#2030=DIRECTION($,(-0,-1,-0));
+#2031=DIRECTION($,(-0.707106781186549,0,0.707106781186546));
+#2032=AXIS2_PLACEMENT_3D($,#2029,#2030,#2031);
+#2033=PLANE($,#2032);
+#2034=ORIENTED_EDGE($,$,$,#833,.T.);
+#2035=ORIENTED_EDGE($,$,$,#1990,.F.);
+#2036=ORIENTED_EDGE($,$,$,#859,.T.);
+#2037=ORIENTED_EDGE($,$,$,#1832,.T.);
+#2038=EDGE_LOOP($,(#2034,#2035,#2036,#2037));
+#2039=FACE_OUTER_BOUND('',#2038,.T.);
+#2040=ADVANCED_FACE('',(#2039),#2033,.T.);
+#2041=CARTESIAN_POINT($,(-247.65,418.13226,84.455));
+#2042=DIRECTION($,(0,1,0));
+#2043=DIRECTION($,(0.707106781186549,0,-0.707106781186546));
+#2044=AXIS2_PLACEMENT_3D($,#2041,#2042,#2043);
+#2045=PLANE($,#2044);
+#2046=ORIENTED_EDGE($,$,$,#842,.T.);
+#2047=ORIENTED_EDGE($,$,$,#1813,.T.);
+#2048=ORIENTED_EDGE($,$,$,#868,.T.);
+#2049=ORIENTED_EDGE($,$,$,#2022,.F.);
+#2050=EDGE_LOOP($,(#2046,#2047,#2048,#2049));
+#2051=FACE_OUTER_BOUND('',#2050,.T.);
+#2052=ADVANCED_FACE('',(#2051),#2045,.T.);
+#2053=CARTESIAN_POINT($,(6.35,418.13226,84.455));
+#2054=DIRECTION($,(0,1,0));
+#2055=DIRECTION($,(0,0,1));
+#2056=AXIS2_PLACEMENT_3D($,#2053,#2054,#2055);
+#2057=PLANE($,#2056);
+#2058=ORIENTED_EDGE($,$,$,#894,.T.);
+#2059=CARTESIAN_POINT($,(6.35,418.13226,113.56594));
+#2060=DIRECTION($,(1,0,0));
+#2061=VECTOR($,#2060,1);
+#2062=LINE($,#2059,#2061);
+#2063=EDGE_CURVE($,#889,#921,#2062,.T.);
+#2064=ORIENTED_EDGE($,$,$,#2063,.T.);
+#2065=ORIENTED_EDGE($,$,$,#934,.T.);
+#2066=CARTESIAN_POINT($,(8.255,418.13226,84.455));
+#2067=DIRECTION($,(-1,0,0));
+#2068=VECTOR($,#2067,1);
+#2069=LINE($,#2066,#2068);
+#2070=EDGE_CURVE($,#929,#881,#2069,.T.);
+#2071=ORIENTED_EDGE($,$,$,#2070,.T.);
+#2072=EDGE_LOOP($,(#2058,#2064,#2065,#2071));
+#2073=FACE_OUTER_BOUND('',#2072,.T.);
+#2074=ADVANCED_FACE('',(#2073),#2057,.T.);
+#2075=CARTESIAN_POINT($,(6.35,418.13226,113.56594));
+#2076=DIRECTION($,(-0,0,1));
+#2077=DIRECTION($,(0,-1,0));
+#2078=AXIS2_PLACEMENT_3D($,#2075,#2076,#2077);
+#2079=PLANE($,#2078);
+#2080=ORIENTED_EDGE($,$,$,#902,.T.);
+#2081=CARTESIAN_POINT($,(6.35,66.34226,113.56594));
+#2082=DIRECTION($,(1,0,0));
+#2083=VECTOR($,#2082,1);
+#2084=LINE($,#2081,#2083);
+#2085=EDGE_CURVE($,#897,#919,#2084,.T.);
+#2086=ORIENTED_EDGE($,$,$,#2085,.T.);
+#2087=ORIENTED_EDGE($,$,$,#926,.T.);
+#2088=ORIENTED_EDGE($,$,$,#2063,.F.);
+#2089=EDGE_LOOP($,(#2080,#2086,#2087,#2088));
+#2090=FACE_OUTER_BOUND('',#2089,.T.);
+#2091=ADVANCED_FACE('',(#2090),#2079,.T.);
+#2092=CARTESIAN_POINT($,(6.35,66.34226,113.56594));
+#2093=DIRECTION($,(0,-1,-0));
+#2094=DIRECTION($,(-0,0,-1));
+#2095=AXIS2_PLACEMENT_3D($,#2092,#2093,#2094);
+#2096=PLANE($,#2095);
+#2097=ORIENTED_EDGE($,$,$,#908,.T.);
+#2098=CARTESIAN_POINT($,(6.35,66.34226,84.455));
+#2099=DIRECTION($,(1,0,0));
+#2100=VECTOR($,#2099,1);
+#2101=LINE($,#2098,#2100);
+#2102=EDGE_CURVE($,#879,#937,#2101,.T.);
+#2103=ORIENTED_EDGE($,$,$,#2102,.T.);
+#2104=ORIENTED_EDGE($,$,$,#948,.T.);
+#2105=ORIENTED_EDGE($,$,$,#2085,.F.);
+#2106=EDGE_LOOP($,(#2097,#2103,#2104,#2105));
+#2107=FACE_OUTER_BOUND('',#2106,.T.);
+#2108=ADVANCED_FACE('',(#2107),#2096,.T.);
+#2109=CARTESIAN_POINT($,(0,418.13226,78.105));
+#2110=DIRECTION($,(-0,1,0));
+#2111=DIRECTION($,(0.707106781186548,0,0.707106781186547));
+#2112=AXIS2_PLACEMENT_3D($,#2109,#2110,#2111);
+#2113=PLANE($,#2112);
+#2114=ORIENTED_EDGE($,$,$,#965,.T.);
+#2115=ORIENTED_EDGE($,$,$,#2070,.F.);
+#2116=ORIENTED_EDGE($,$,$,#991,.T.);
+#2117=ORIENTED_EDGE($,$,$,#1759,.T.);
+#2118=EDGE_LOOP($,(#2114,#2115,#2116,#2117));
+#2119=FACE_OUTER_BOUND('',#2118,.T.);
+#2120=ADVANCED_FACE('',(#2119),#2113,.T.);
+#2121=CARTESIAN_POINT($,(6.35,66.34226,84.455));
+#2122=DIRECTION($,(0,-1,-0));
+#2123=DIRECTION($,(-0.707106781186548,0,-0.707106781186547));
+#2124=AXIS2_PLACEMENT_3D($,#2121,#2122,#2123);
+#2125=PLANE($,#2124);
+#2126=ORIENTED_EDGE($,$,$,#974,.T.);
+#2127=ORIENTED_EDGE($,$,$,#1735,.T.);
+#2128=ORIENTED_EDGE($,$,$,#1000,.T.);
+#2129=ORIENTED_EDGE($,$,$,#2102,.F.);
+#2130=EDGE_LOOP($,(#2126,#2127,#2128,#2129));
+#2131=FACE_OUTER_BOUND('',#2130,.T.);
+#2132=ADVANCED_FACE('',(#2131),#2125,.T.);
+#2133=CARTESIAN_POINT($,(-8.255,43.48226,1.90746000000001));
+#2134=DIRECTION($,(1,0,0));
+#2135=DIRECTION($,(0,-1,0));
+#2136=AXIS2_PLACEMENT_3D($,#2133,#2134,#2135);
+#2137=PLANE($,#2136);
+#2138=ORIENTED_EDGE($,$,$,#1026,.T.);
+#2139=CARTESIAN_POINT($,(-8.255,12.70254,1.90746000000001));
+#2140=DIRECTION($,(0,0,-1));
+#2141=VECTOR($,#2140,1);
+#2142=LINE($,#2139,#2141);
+#2143=EDGE_CURVE($,#1021,#1075,#2142,.T.);
+#2144=ORIENTED_EDGE($,$,$,#2143,.T.);
+#2145=ORIENTED_EDGE($,$,$,#1088,.T.);
+#2146=CARTESIAN_POINT($,(-8.255,43.48226,0.00246000000001));
+#2147=DIRECTION($,(0,0,1));
+#2148=VECTOR($,#2147,1);
+#2149=LINE($,#2146,#2148);
+#2150=EDGE_CURVE($,#1083,#1013,#2149,.T.);
+#2151=ORIENTED_EDGE($,$,$,#2150,.T.);
+#2152=EDGE_LOOP($,(#2138,#2144,#2145,#2151));
+#2153=FACE_OUTER_BOUND('',#2152,.T.);
+#2154=ADVANCED_FACE('',(#2153),#2137,.T.);
+#2155=CARTESIAN_POINT($,(-8.255,12.70254,1.90746000000001));
+#2156=DIRECTION($,(-0,-1,-0));
+#2157=DIRECTION($,(-1,0,0));
+#2158=AXIS2_PLACEMENT_3D($,#2155,#2156,#2157);
+#2159=PLANE($,#2158);
+#2160=ORIENTED_EDGE($,$,$,#1034,.T.);
+#2161=CARTESIAN_POINT($,(-233.045,12.70254,1.90746000000001));
+#2162=DIRECTION($,(0,0,-1));
+#2163=VECTOR($,#2162,1);
+#2164=LINE($,#2161,#2163);
+#2165=EDGE_CURVE($,#1029,#1073,#2164,.T.);
+#2166=ORIENTED_EDGE($,$,$,#2165,.T.);
+#2167=ORIENTED_EDGE($,$,$,#1080,.T.);
+#2168=ORIENTED_EDGE($,$,$,#2143,.F.);
+#2169=EDGE_LOOP($,(#2160,#2166,#2167,#2168));
+#2170=FACE_OUTER_BOUND('',#2169,.T.);
+#2171=ADVANCED_FACE('',(#2170),#2159,.T.);
+#2172=CARTESIAN_POINT($,(-233.045,12.70254,1.90746000000001));
+#2173=DIRECTION($,(-1,0,0));
+#2174=DIRECTION($,(0,1,0));
+#2175=AXIS2_PLACEMENT_3D($,#2172,#2173,#2174);
+#2176=PLANE($,#2175);
+#2177=ORIENTED_EDGE($,$,$,#1040,.T.);
+#2178=CARTESIAN_POINT($,(-233.045,43.48226,1.90746000000001));
+#2179=DIRECTION($,(0,0,-1));
+#2180=VECTOR($,#2179,1);
+#2181=LINE($,#2178,#2180);
+#2182=EDGE_CURVE($,#1011,#1091,#2181,.T.);
+#2183=ORIENTED_EDGE($,$,$,#2182,.T.);
+#2184=ORIENTED_EDGE($,$,$,#1102,.T.);
+#2185=ORIENTED_EDGE($,$,$,#2165,.F.);
+#2186=EDGE_LOOP($,(#2177,#2183,#2184,#2185));
+#2187=FACE_OUTER_BOUND('',#2186,.T.);
+#2188=ADVANCED_FACE('',(#2187),#2176,.T.);
+#2189=CARTESIAN_POINT($,(-8.255,49.83226,8.25746000000001));
+#2190=DIRECTION($,(1,-0,0));
+#2191=DIRECTION($,(0,-0.707106781186547,-0.707106781186548));
+#2192=AXIS2_PLACEMENT_3D($,#2189,#2190,#2191);
+#2193=PLANE($,#2192);
+#2194=ORIENTED_EDGE($,$,$,#1141,.T.);
+#2195=ORIENTED_EDGE($,$,$,#2150,.F.);
+#2196=ORIENTED_EDGE($,$,$,#1167,.T.);
+#2197=ORIENTED_EDGE($,$,$,#1847,.F.);
+#2198=EDGE_LOOP($,(#2194,#2195,#2196,#2197));
+#2199=FACE_OUTER_BOUND('',#2198,.T.);
+#2200=ADVANCED_FACE('',(#2199),#2193,.T.);
+#2201=CARTESIAN_POINT($,(-233.045,43.48226,1.90746000000001));
+#2202=DIRECTION($,(-1,0,0));
+#2203=DIRECTION($,(0,0.707106781186547,0.707106781186548));
+#2204=AXIS2_PLACEMENT_3D($,#2201,#2202,#2203);
+#2205=PLANE($,#2204);
+#2206=ORIENTED_EDGE($,$,$,#1150,.T.);
+#2207=ORIENTED_EDGE($,$,$,#1876,.F.);
+#2208=ORIENTED_EDGE($,$,$,#1176,.T.);
+#2209=ORIENTED_EDGE($,$,$,#2182,.F.);
+#2210=EDGE_LOOP($,(#2206,#2207,#2208,#2209));
+#2211=FACE_OUTER_BOUND('',#2210,.T.);
+#2212=ADVANCED_FACE('',(#2211),#2205,.T.);
+#2213=CARTESIAN_POINT($,(-233.045,440.99226,1.90746000000001));
+#2214=DIRECTION($,(-1,0,0));
+#2215=DIRECTION($,(0,1,0));
+#2216=AXIS2_PLACEMENT_3D($,#2213,#2214,#2215);
+#2217=PLANE($,#2216);
+#2218=ORIENTED_EDGE($,$,$,#1202,.T.);
+#2219=CARTESIAN_POINT($,(-233.045,485.44226,1.90746000000001));
+#2220=DIRECTION($,(0,0,-1));
+#2221=VECTOR($,#2220,1);
+#2222=LINE($,#2219,#2221);
+#2223=EDGE_CURVE($,#1197,#1251,#2222,.T.);
+#2224=ORIENTED_EDGE($,$,$,#2223,.T.);
+#2225=ORIENTED_EDGE($,$,$,#1264,.T.);
+#2226=CARTESIAN_POINT($,(-233.045,440.99226,0.00246000000001));
+#2227=DIRECTION($,(0,0,1));
+#2228=VECTOR($,#2227,1);
+#2229=LINE($,#2226,#2228);
+#2230=EDGE_CURVE($,#1259,#1189,#2229,.T.);
+#2231=ORIENTED_EDGE($,$,$,#2230,.T.);
+#2232=EDGE_LOOP($,(#2218,#2224,#2225,#2231));
+#2233=FACE_OUTER_BOUND('',#2232,.T.);
+#2234=ADVANCED_FACE('',(#2233),#2217,.T.);
+#2235=CARTESIAN_POINT($,(-233.045,485.44226,1.90746000000001));
+#2236=DIRECTION($,(-0,1,0));
+#2237=DIRECTION($,(1,0,0));
+#2238=AXIS2_PLACEMENT_3D($,#2235,#2236,#2237);
+#2239=PLANE($,#2238);
+#2240=ORIENTED_EDGE($,$,$,#1210,.T.);
+#2241=CARTESIAN_POINT($,(-8.255,485.44226,1.90746000000001));
+#2242=DIRECTION($,(0,0,-1));
+#2243=VECTOR($,#2242,1);
+#2244=LINE($,#2241,#2243);
+#2245=EDGE_CURVE($,#1205,#1249,#2244,.T.);
+#2246=ORIENTED_EDGE($,$,$,#2245,.T.);
+#2247=ORIENTED_EDGE($,$,$,#1256,.T.);
+#2248=ORIENTED_EDGE($,$,$,#2223,.F.);
+#2249=EDGE_LOOP($,(#2240,#2246,#2247,#2248));
+#2250=FACE_OUTER_BOUND('',#2249,.T.);
+#2251=ADVANCED_FACE('',(#2250),#2239,.T.);
+#2252=CARTESIAN_POINT($,(-8.255,485.44226,1.90746000000001));
+#2253=DIRECTION($,(1,0,0));
+#2254=DIRECTION($,(0,-1,0));
+#2255=AXIS2_PLACEMENT_3D($,#2252,#2253,#2254);
+#2256=PLANE($,#2255);
+#2257=ORIENTED_EDGE($,$,$,#1216,.T.);
+#2258=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));
+#2259=DIRECTION($,(0,0,-1));
+#2260=VECTOR($,#2259,1);
+#2261=LINE($,#2258,#2260);
+#2262=EDGE_CURVE($,#1187,#1267,#2261,.T.);
+#2263=ORIENTED_EDGE($,$,$,#2262,.T.);
+#2264=ORIENTED_EDGE($,$,$,#1278,.T.);
+#2265=ORIENTED_EDGE($,$,$,#2245,.F.);
+#2266=EDGE_LOOP($,(#2257,#2263,#2264,#2265));
+#2267=FACE_OUTER_BOUND('',#2266,.T.);
+#2268=ADVANCED_FACE('',(#2267),#2256,.T.);
+#2269=CARTESIAN_POINT($,(-233.045,434.64226,8.25746000000001));
+#2270=DIRECTION($,(-1,-0,-0));
+#2271=DIRECTION($,(0,0.707106781186549,-0.707106781186546));
+#2272=AXIS2_PLACEMENT_3D($,#2269,#2270,#2271);
+#2273=PLANE($,#2272);
+#2274=ORIENTED_EDGE($,$,$,#1317,.T.);
+#2275=ORIENTED_EDGE($,$,$,#2230,.F.);
+#2276=ORIENTED_EDGE($,$,$,#1343,.T.);
+#2277=ORIENTED_EDGE($,$,$,#1915,.F.);
+#2278=EDGE_LOOP($,(#2274,#2275,#2276,#2277));
+#2279=FACE_OUTER_BOUND('',#2278,.T.);
+#2280=ADVANCED_FACE('',(#2279),#2273,.T.);
+#2281=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));
+#2282=DIRECTION($,(1,0,0));
+#2283=DIRECTION($,(0,-0.707106781186549,0.707106781186546));
+#2284=AXIS2_PLACEMENT_3D($,#2281,#2282,#2283);
+#2285=PLANE($,#2284);
+#2286=ORIENTED_EDGE($,$,$,#1326,.T.);
+#2287=ORIENTED_EDGE($,$,$,#1944,.F.);
+#2288=ORIENTED_EDGE($,$,$,#1352,.T.);
+#2289=ORIENTED_EDGE($,$,$,#2262,.F.);
+#2290=EDGE_LOOP($,(#2286,#2287,#2288,#2289));
+#2291=FACE_OUTER_BOUND('',#2290,.T.);
+#2292=ADVANCED_FACE('',(#2291),#2285,.T.);
+#2293=CARTESIAN_POINT($,(8.76783352130505,308.12486,119.403106478695));
+#2294=DIRECTION($,(-0,1,0));
+#2295=DIRECTION($,(0.707106781186548,0,0.707106781186548));
+#2296=AXIS2_PLACEMENT_3D($,#2293,#2294,#2295);
+#2297=PLANE($,#2296);
+#2298=ORIENTED_EDGE($,$,$,#1378,.T.);
+#2299=CARTESIAN_POINT($,(43.0724119037892,308.12486,153.707684861179));
+#2300=DIRECTION($,(0.707106781186548,0,-0.707106781186548));
+#2301=VECTOR($,#2300,1);
+#2302=LINE($,#2299,#2301);
+#2303=EDGE_CURVE($,#1373,#1524,#2302,.T.);
+#2304=ORIENTED_EDGE($,$,$,#2303,.T.);
+#2305=ORIENTED_EDGE($,$,$,#1537,.T.);
+#2306=CARTESIAN_POINT($,(10.1148719394654,308.12486,118.056068060535));
+#2307=DIRECTION($,(-0.707106781186549,0,0.707106781186546));
+#2308=VECTOR($,#2307,1);
+#2309=LINE($,#2306,#2308);
+#2310=EDGE_CURVE($,#1532,#1365,#2309,.T.);
+#2311=ORIENTED_EDGE($,$,$,#2310,.T.);
+#2312=EDGE_LOOP($,(#2298,#2304,#2305,#2311));
+#2313=FACE_OUTER_BOUND('',#2312,.T.);
+#2314=ADVANCED_FACE('',(#2313),#2297,.T.);
+#2315=CARTESIAN_POINT($,(43.0724119037892,308.12486,153.707684861179));
+#2316=DIRECTION($,(0.707106781186548,0,0.707106781186548));
+#2317=DIRECTION($,(0,-1,0));
+#2318=AXIS2_PLACEMENT_3D($,#2315,#2316,#2317);
+#2319=PLANE($,#2318);
+#2320=ORIENTED_EDGE($,$,$,#1386,.T.);
+#2321=CARTESIAN_POINT($,(43.0724119037892,295.42486,153.707684861179));
+#2322=DIRECTION($,(0.707106781186548,0,-0.707106781186548));
+#2323=VECTOR($,#2322,1);
+#2324=LINE($,#2321,#2323);
+#2325=EDGE_CURVE($,#1381,#1516,#2324,.T.);
+#2326=ORIENTED_EDGE($,$,$,#2325,.T.);
+#2327=ORIENTED_EDGE($,$,$,#1529,.T.);
+#2328=ORIENTED_EDGE($,$,$,#2303,.F.);
+#2329=EDGE_LOOP($,(#2320,#2326,#2327,#2328));
+#2330=FACE_OUTER_BOUND('',#2329,.T.);
+#2331=ADVANCED_FACE('',(#2330),#2319,.T.);
+#2332=CARTESIAN_POINT($,(43.0724119037892,295.42486,153.707684861179));
+#2333=DIRECTION($,(-0,1,0));
+#2334=DIRECTION($,(0.707106781186548,0,0.707106781186547));
+#2335=AXIS2_PLACEMENT_3D($,#2332,#2333,#2334);
+#2336=PLANE($,#2335);
+#2337=ORIENTED_EDGE($,$,$,#1394,.T.);
+#2338=CARTESIAN_POINT($,(52.0526680248584,295.42486,162.687940982248));
+#2339=DIRECTION($,(0.707106781186548,0,-0.707106781186548));
+#2340=VECTOR($,#2339,1);
+#2341=LINE($,#2338,#2340);
+#2342=EDGE_CURVE($,#1389,#1508,#2341,.T.);
+#2343=ORIENTED_EDGE($,$,$,#2342,.T.);
+#2344=ORIENTED_EDGE($,$,$,#1521,.T.);
+#2345=ORIENTED_EDGE($,$,$,#2325,.F.);
+#2346=EDGE_LOOP($,(#2337,#2343,#2344,#2345));
+#2347=FACE_OUTER_BOUND('',#2346,.T.);
+#2348=ADVANCED_FACE('',(#2347),#2336,.T.);
+#2349=CARTESIAN_POINT($,(52.0526680248584,295.42486,162.687940982248));
+#2350=DIRECTION($,(0.707106781186548,0,0.707106781186548));
+#2351=DIRECTION($,(0,-1,0));
+#2352=AXIS2_PLACEMENT_3D($,#2349,#2350,#2351);
+#2353=PLANE($,#2352);
+#2354=ORIENTED_EDGE($,$,$,#1402,.T.);
+#2355=CARTESIAN_POINT($,(52.0526680248584,193.82486,162.687940982248));
+#2356=DIRECTION($,(0.707106781186548,0,-0.707106781186548));
+#2357=VECTOR($,#2356,1);
+#2358=LINE($,#2355,#2357);
+#2359=EDGE_CURVE($,#1397,#1500,#2358,.T.);
+#2360=ORIENTED_EDGE($,$,$,#2359,.T.);
+#2361=ORIENTED_EDGE($,$,$,#1513,.T.);
+#2362=ORIENTED_EDGE($,$,$,#2342,.F.);
+#2363=EDGE_LOOP($,(#2354,#2360,#2361,#2362));
+#2364=FACE_OUTER_BOUND('',#2363,.T.);
+#2365=ADVANCED_FACE('',(#2364),#2353,.T.);
+#2366=CARTESIAN_POINT($,(52.0526680248584,193.82486,162.687940982248));
+#2367=DIRECTION($,(0,-1,-0));
+#2368=DIRECTION($,(-0.707106781186548,0,-0.707106781186547));
+#2369=AXIS2_PLACEMENT_3D($,#2366,#2367,#2368);
+#2370=PLANE($,#2369);
+#2371=ORIENTED_EDGE($,$,$,#1410,.T.);
+#2372=CARTESIAN_POINT($,(43.0724119037892,193.82486,153.707684861179));
+#2373=DIRECTION($,(0.707106781186548,0,-0.707106781186548));
+#2374=VECTOR($,#2373,1);
+#2375=LINE($,#2372,#2374);
+#2376=EDGE_CURVE($,#1405,#1492,#2375,.T.);
+#2377=ORIENTED_EDGE($,$,$,#2376,.T.);
+#2378=ORIENTED_EDGE($,$,$,#1505,.T.);
+#2379=ORIENTED_EDGE($,$,$,#2359,.F.);
+#2380=EDGE_LOOP($,(#2371,#2377,#2378,#2379));
+#2381=FACE_OUTER_BOUND('',#2380,.T.);
+#2382=ADVANCED_FACE('',(#2381),#2370,.T.);
+#2383=CARTESIAN_POINT($,(43.0724119037892,193.82486,153.707684861179));
+#2384=DIRECTION($,(0.707106781186548,0,0.707106781186548));
+#2385=DIRECTION($,(0,-1,0));
+#2386=AXIS2_PLACEMENT_3D($,#2383,#2384,#2385);
+#2387=PLANE($,#2386);
+#2388=ORIENTED_EDGE($,$,$,#1418,.T.);
+#2389=CARTESIAN_POINT($,(43.0724119037892,181.12486,153.707684861179));
+#2390=DIRECTION($,(0.707106781186548,0,-0.707106781186548));
+#2391=VECTOR($,#2390,1);
+#2392=LINE($,#2389,#2391);
+#2393=EDGE_CURVE($,#1413,#1490,#2392,.T.);
+#2394=ORIENTED_EDGE($,$,$,#2393,.T.);
+#2395=ORIENTED_EDGE($,$,$,#1497,.T.);
+#2396=ORIENTED_EDGE($,$,$,#2376,.F.);
+#2397=EDGE_LOOP($,(#2388,#2394,#2395,#2396));
+#2398=FACE_OUTER_BOUND('',#2397,.T.);
+#2399=ADVANCED_FACE('',(#2398),#2387,.T.);
+#2400=CARTESIAN_POINT($,(43.0724119037892,181.12486,153.707684861179));
+#2401=DIRECTION($,(0,-1,-0));
+#2402=DIRECTION($,(-0.707106781186548,0,-0.707106781186548));
+#2403=AXIS2_PLACEMENT_3D($,#2400,#2401,#2402);
+#2404=PLANE($,#2403);
+#2405=ORIENTED_EDGE($,$,$,#1424,.T.);
+#2406=CARTESIAN_POINT($,(8.76783352130505,181.12486,119.403106478695));
+#2407=DIRECTION($,(0.707106781186549,0,-0.707106781186546));
+#2408=VECTOR($,#2407,1);
+#2409=LINE($,#2406,#2408);
+#2410=EDGE_CURVE($,#1363,#1540,#2409,.T.);
+#2411=ORIENTED_EDGE($,$,$,#2410,.T.);
+#2412=ORIENTED_EDGE($,$,$,#1551,.T.);
+#2413=ORIENTED_EDGE($,$,$,#2393,.F.);
+#2414=EDGE_LOOP($,(#2405,#2411,#2412,#2413));
+#2415=FACE_OUTER_BOUND('',#2414,.T.);
+#2416=ADVANCED_FACE('',(#2415),#2404,.T.);
+#2417=CARTESIAN_POINT($,(6.35,181.12486,113.56594));
+#2418=DIRECTION($,(0,0,-1));
+#2419=DIRECTION($,(0,1,0));
+#2420=AXIS2_PLACEMENT_3D($,#2417,#2418,#2419);
+#2421=PLANE($,#2420);
+#2422=ORIENTED_EDGE($,$,$,#1624,.T.);
+#2423=CARTESIAN_POINT($,(6.35,308.12486,113.56594));
+#2424=DIRECTION($,(1,0,0));
+#2425=VECTOR($,#2424,1);
+#2426=LINE($,#2423,#2425);
+#2427=EDGE_CURVE($,#1619,#1653,#2426,.T.);
+#2428=ORIENTED_EDGE($,$,$,#2427,.T.);
+#2429=ORIENTED_EDGE($,$,$,#1668,.T.);
+#2430=CARTESIAN_POINT($,(8.255,181.12486,113.56594));
+#2431=DIRECTION($,(-1,0,0));
+#2432=VECTOR($,#2431,1);
+#2433=LINE($,#2430,#2432);
+#2434=EDGE_CURVE($,#1663,#1617,#2433,.T.);
+#2435=ORIENTED_EDGE($,$,$,#2434,.T.);
+#2436=EDGE_LOOP($,(#2422,#2428,#2429,#2435));
+#2437=FACE_OUTER_BOUND('',#2436,.T.);
+#2438=ADVANCED_FACE('',(#2437),#2421,.T.);
+#2439=CARTESIAN_POINT($,(6.35,308.12486,113.56594));
+#2440=DIRECTION($,(0,1,0));
+#2441=DIRECTION($,(0.382683432365089,0,0.923879532511287));
+#2442=AXIS2_PLACEMENT_3D($,#2439,#2440,#2441);
+#2443=PLANE($,#2442);
+#2444=ORIENTED_EDGE($,$,$,#1632,.T.);
+#2445=ORIENTED_EDGE($,$,$,#2310,.F.);
+#2446=ORIENTED_EDGE($,$,$,#1660,.T.);
+#2447=ORIENTED_EDGE($,$,$,#2427,.F.);
+#2448=EDGE_LOOP($,(#2444,#2445,#2446,#2447));
+#2449=FACE_OUTER_BOUND('',#2448,.T.);
+#2450=ADVANCED_FACE('',(#2449),#2443,.T.);
+#2451=CARTESIAN_POINT($,(8.76783352130505,181.12486,119.403106478695));
+#2452=DIRECTION($,(0,-1,-0));
+#2453=DIRECTION($,(-0.382683432365089,0,-0.923879532511287));
+#2454=AXIS2_PLACEMENT_3D($,#2451,#2452,#2453);
+#2455=PLANE($,#2454);
+#2456=ORIENTED_EDGE($,$,$,#1641,.T.);
+#2457=ORIENTED_EDGE($,$,$,#2434,.F.);
+#2458=ORIENTED_EDGE($,$,$,#1676,.T.);
+#2459=ORIENTED_EDGE($,$,$,#2410,.F.);
+#2460=EDGE_LOOP($,(#2456,#2457,#2458,#2459));
+#2461=FACE_OUTER_BOUND('',#2460,.T.);
+#2462=ADVANCED_FACE('',(#2461),#2455,.T.);
+#2463=CARTESIAN_POINT($,(-38.1,96.774,76.2));
+#2464=DIRECTION($,(0,0,1));
+#2465=DIRECTION($,(1,0,0));
+#2466=AXIS2_PLACEMENT_3D($,#2463,#2464,#2465);
+#2467=CYLINDRICAL_SURFACE($,#2466,7.9375);
+#2468=ORIENTED_EDGE($,$,$,#111,.T.);
+#2469=EDGE_LOOP($,(#2468));
+#2470=FACE_OUTER_BOUND('',#2469,.T.);
+#2471=ORIENTED_EDGE($,$,$,#349,.T.);
+#2472=EDGE_LOOP($,(#2471));
+#2473=FACE_BOUND('',#2472,.T.);
+#2474=ADVANCED_FACE('',(#2470,#2473),#2467,.F.);
+#2475=CARTESIAN_POINT($,(-38.1,141.224,76.2));
+#2476=DIRECTION($,(0,0,1));
+#2477=DIRECTION($,(1,0,0));
+#2478=AXIS2_PLACEMENT_3D($,#2475,#2476,#2477);
+#2479=CYLINDRICAL_SURFACE($,#2478,7.9375);
+#2480=ORIENTED_EDGE($,$,$,#122,.T.);
+#2481=EDGE_LOOP($,(#2480));
+#2482=FACE_OUTER_BOUND('',#2481,.T.);
+#2483=ORIENTED_EDGE($,$,$,#360,.T.);
+#2484=EDGE_LOOP($,(#2483));
+#2485=FACE_BOUND('',#2484,.T.);
+#2486=ADVANCED_FACE('',(#2482,#2485),#2479,.F.);
+#2487=CARTESIAN_POINT($,(-38.1,185.674,76.2));
+#2488=DIRECTION($,(0,0,1));
+#2489=DIRECTION($,(1,0,0));
+#2490=AXIS2_PLACEMENT_3D($,#2487,#2488,#2489);
+#2491=CYLINDRICAL_SURFACE($,#2490,7.9375);
+#2492=ORIENTED_EDGE($,$,$,#133,.T.);
+#2493=EDGE_LOOP($,(#2492));
+#2494=FACE_OUTER_BOUND('',#2493,.T.);
+#2495=ORIENTED_EDGE($,$,$,#371,.T.);
+#2496=EDGE_LOOP($,(#2495));
+#2497=FACE_BOUND('',#2496,.T.);
+#2498=ADVANCED_FACE('',(#2494,#2497),#2491,.F.);
+#2499=CARTESIAN_POINT($,(-38.1,230.124,76.2));
+#2500=DIRECTION($,(0,0,1));
+#2501=DIRECTION($,(1,0,0));
+#2502=AXIS2_PLACEMENT_3D($,#2499,#2500,#2501);
+#2503=CYLINDRICAL_SURFACE($,#2502,7.9375);
+#2504=ORIENTED_EDGE($,$,$,#144,.T.);
+#2505=EDGE_LOOP($,(#2504));
+#2506=FACE_OUTER_BOUND('',#2505,.T.);
+#2507=ORIENTED_EDGE($,$,$,#382,.T.);
+#2508=EDGE_LOOP($,(#2507));
+#2509=FACE_BOUND('',#2508,.T.);
+#2510=ADVANCED_FACE('',(#2506,#2509),#2503,.F.);
+#2511=CARTESIAN_POINT($,(-151.9174,356.9208,76.2));
+#2512=DIRECTION($,(0,0,1));
+#2513=DIRECTION($,(1,0,0));
+#2514=AXIS2_PLACEMENT_3D($,#2511,#2512,#2513);
+#2515=CYLINDRICAL_SURFACE($,#2514,25.4);
+#2516=ORIENTED_EDGE($,$,$,#155,.T.);
+#2517=EDGE_LOOP($,(#2516));
+#2518=FACE_OUTER_BOUND('',#2517,.T.);
+#2519=ORIENTED_EDGE($,$,$,#393,.T.);
+#2520=EDGE_LOOP($,(#2519));
+#2521=FACE_BOUND('',#2520,.T.);
+#2522=ADVANCED_FACE('',(#2518,#2521),#2515,.F.);
+#2523=CARTESIAN_POINT($,(-63.0174,331.5208,76.2));
+#2524=DIRECTION($,(0,0,1));
+#2525=DIRECTION($,(1,0,0));
+#2526=AXIS2_PLACEMENT_3D($,#2523,#2524,#2525);
+#2527=CYLINDRICAL_SURFACE($,#2526,19.05);
+#2528=ORIENTED_EDGE($,$,$,#166,.T.);
+#2529=EDGE_LOOP($,(#2528));
+#2530=FACE_OUTER_BOUND('',#2529,.T.);
+#2531=ORIENTED_EDGE($,$,$,#404,.T.);
+#2532=EDGE_LOOP($,(#2531));
+#2533=FACE_BOUND('',#2532,.T.);
+#2534=ADVANCED_FACE('',(#2530,#2533),#2527,.F.);
+#2535=CARTESIAN_POINT($,(-199.5424,122.0724,78.105));
+#2536=DIRECTION($,(-0,1,0));
+#2537=DIRECTION($,(1,0,0));
+#2538=AXIS2_PLACEMENT_3D($,#2535,#2536,#2537);
+#2539=PLANE($,#2538);
+#2540=ORIENTED_EDGE($,$,$,#194,.T.);
+#2541=CARTESIAN_POINT($,(-180.4924,122.0724,78.105));
+#2542=DIRECTION($,(0,0,-1));
+#2543=VECTOR($,#2542,1);
+#2544=LINE($,#2541,#2543);
+#2545=EDGE_CURVE($,#181,#411,#2544,.T.);
+#2546=ORIENTED_EDGE($,$,$,#2545,.T.);
+#2547=ORIENTED_EDGE($,$,$,#416,.F.);
+#2548=CARTESIAN_POINT($,(-199.5424,122.0724,76.2));
+#2549=DIRECTION($,(0,0,1));
+#2550=VECTOR($,#2549,1);
+#2551=LINE($,#2548,#2550);
+#2552=EDGE_CURVE($,#409,#189,#2551,.T.);
+#2553=ORIENTED_EDGE($,$,$,#2552,.T.);
+#2554=EDGE_LOOP($,(#2540,#2546,#2547,#2553));
+#2555=FACE_OUTER_BOUND('',#2554,.T.);
+#2556=ADVANCED_FACE('',(#2555),#2539,.T.);
+#2557=CARTESIAN_POINT($,(-180.4924,122.0724,78.105));
+#2558=DIRECTION($,(-1,0,0));
+#2559=DIRECTION($,(0,1,0));
+#2560=AXIS2_PLACEMENT_3D($,#2557,#2558,#2559);
+#2561=PLANE($,#2560);
+#2562=ORIENTED_EDGE($,$,$,#186,.T.);
+#2563=CARTESIAN_POINT($,(-180.4924,210.9724,78.105));
+#2564=DIRECTION($,(0,0,-1));
+#2565=VECTOR($,#2564,1);
+#2566=LINE($,#2563,#2565);
+#2567=EDGE_CURVE($,#171,#419,#2566,.T.);
+#2568=ORIENTED_EDGE($,$,$,#2567,.T.);
+#2569=ORIENTED_EDGE($,$,$,#424,.F.);
+#2570=ORIENTED_EDGE($,$,$,#2545,.F.);
+#2571=EDGE_LOOP($,(#2562,#2568,#2569,#2570));
+#2572=FACE_OUTER_BOUND('',#2571,.T.);
+#2573=ADVANCED_FACE('',(#2572),#2561,.T.);
+#2574=CARTESIAN_POINT($,(-180.4924,210.9724,78.105));
+#2575=DIRECTION($,(-0,-1,-0));
+#2576=DIRECTION($,(-1,0,0));
+#2577=AXIS2_PLACEMENT_3D($,#2574,#2575,#2576);
+#2578=PLANE($,#2577);
+#2579=ORIENTED_EDGE($,$,$,#178,.T.);
+#2580=CARTESIAN_POINT($,(-199.5424,210.9724,78.105));
+#2581=DIRECTION($,(0,0,-1));
+#2582=VECTOR($,#2581,1);
+#2583=LINE($,#2580,#2582);
+#2584=EDGE_CURVE($,#173,#427,#2583,.T.);
+#2585=ORIENTED_EDGE($,$,$,#2584,.T.);
+#2586=ORIENTED_EDGE($,$,$,#432,.F.);
+#2587=ORIENTED_EDGE($,$,$,#2567,.F.);
+#2588=EDGE_LOOP($,(#2579,#2585,#2586,#2587));
+#2589=FACE_OUTER_BOUND('',#2588,.T.);
+#2590=ADVANCED_FACE('',(#2589),#2578,.T.);
+#2591=CARTESIAN_POINT($,(-199.5424,210.9724,78.105));
+#2592=DIRECTION($,(1,0,0));
+#2593=DIRECTION($,(0,-1,0));
+#2594=AXIS2_PLACEMENT_3D($,#2591,#2592,#2593);
+#2595=PLANE($,#2594);
+#2596=ORIENTED_EDGE($,$,$,#200,.T.);
+#2597=ORIENTED_EDGE($,$,$,#2552,.F.);
+#2598=ORIENTED_EDGE($,$,$,#438,.F.);
+#2599=ORIENTED_EDGE($,$,$,#2584,.F.);
+#2600=EDGE_LOOP($,(#2596,#2597,#2598,#2599));
+#2601=FACE_OUTER_BOUND('',#2600,.T.);
+#2602=ADVANCED_FACE('',(#2601),#2595,.T.);
+#2603=CARTESIAN_POINT($,(-136.0424,122.0724,78.105));
+#2604=DIRECTION($,(-0,1,0));
+#2605=DIRECTION($,(1,0,0));
+#2606=AXIS2_PLACEMENT_3D($,#2603,#2604,#2605);
+#2607=PLANE($,#2606);
+#2608=ORIENTED_EDGE($,$,$,#228,.T.);
+#2609=CARTESIAN_POINT($,(-116.9924,122.0724,78.105));
+#2610=DIRECTION($,(0,0,-1));
+#2611=VECTOR($,#2610,1);
+#2612=LINE($,#2609,#2611);
+#2613=EDGE_CURVE($,#215,#445,#2612,.T.);
+#2614=ORIENTED_EDGE($,$,$,#2613,.T.);
+#2615=ORIENTED_EDGE($,$,$,#450,.F.);
+#2616=CARTESIAN_POINT($,(-136.0424,122.0724,76.2));
+#2617=DIRECTION($,(0,0,1));
+#2618=VECTOR($,#2617,1);
+#2619=LINE($,#2616,#2618);
+#2620=EDGE_CURVE($,#443,#223,#2619,.T.);
+#2621=ORIENTED_EDGE($,$,$,#2620,.T.);
+#2622=EDGE_LOOP($,(#2608,#2614,#2615,#2621));
+#2623=FACE_OUTER_BOUND('',#2622,.T.);
+#2624=ADVANCED_FACE('',(#2623),#2607,.T.);
+#2625=CARTESIAN_POINT($,(-116.9924,122.0724,78.105));
+#2626=DIRECTION($,(-1,0,0));
+#2627=DIRECTION($,(0,1,0));
+#2628=AXIS2_PLACEMENT_3D($,#2625,#2626,#2627);
+#2629=PLANE($,#2628);
+#2630=ORIENTED_EDGE($,$,$,#220,.T.);
+#2631=CARTESIAN_POINT($,(-116.9924,210.9724,78.105));
+#2632=DIRECTION($,(0,0,-1));
+#2633=VECTOR($,#2632,1);
+#2634=LINE($,#2631,#2633);
+#2635=EDGE_CURVE($,#205,#453,#2634,.T.);
+#2636=ORIENTED_EDGE($,$,$,#2635,.T.);
+#2637=ORIENTED_EDGE($,$,$,#458,.F.);
+#2638=ORIENTED_EDGE($,$,$,#2613,.F.);
+#2639=EDGE_LOOP($,(#2630,#2636,#2637,#2638));
+#2640=FACE_OUTER_BOUND('',#2639,.T.);
+#2641=ADVANCED_FACE('',(#2640),#2629,.T.);
+#2642=CARTESIAN_POINT($,(-116.9924,210.9724,78.105));
+#2643=DIRECTION($,(-0,-1,-0));
+#2644=DIRECTION($,(-1,0,0));
+#2645=AXIS2_PLACEMENT_3D($,#2642,#2643,#2644);
+#2646=PLANE($,#2645);
+#2647=ORIENTED_EDGE($,$,$,#212,.T.);
+#2648=CARTESIAN_POINT($,(-136.0424,210.9724,78.105));
+#2649=DIRECTION($,(0,0,-1));
+#2650=VECTOR($,#2649,1);
+#2651=LINE($,#2648,#2650);
+#2652=EDGE_CURVE($,#207,#461,#2651,.T.);
+#2653=ORIENTED_EDGE($,$,$,#2652,.T.);
+#2654=ORIENTED_EDGE($,$,$,#466,.F.);
+#2655=ORIENTED_EDGE($,$,$,#2635,.F.);
+#2656=EDGE_LOOP($,(#2647,#2653,#2654,#2655));
+#2657=FACE_OUTER_BOUND('',#2656,.T.);
+#2658=ADVANCED_FACE('',(#2657),#2646,.T.);
+#2659=CARTESIAN_POINT($,(-136.0424,210.9724,78.105));
+#2660=DIRECTION($,(1,0,0));
+#2661=DIRECTION($,(0,-1,0));
+#2662=AXIS2_PLACEMENT_3D($,#2659,#2660,#2661);
+#2663=PLANE($,#2662);
+#2664=ORIENTED_EDGE($,$,$,#234,.T.);
+#2665=ORIENTED_EDGE($,$,$,#2620,.F.);
+#2666=ORIENTED_EDGE($,$,$,#472,.F.);
+#2667=ORIENTED_EDGE($,$,$,#2652,.F.);
+#2668=EDGE_LOOP($,(#2664,#2665,#2666,#2667));
+#2669=FACE_OUTER_BOUND('',#2668,.T.);
+#2670=ADVANCED_FACE('',(#2669),#2663,.T.);
+#2671=CARTESIAN_POINT($,(-19.05,466.3948,0.00246000000001));
+#2672=DIRECTION($,(0,0,1));
+#2673=DIRECTION($,(-1,0,0));
+#2674=AXIS2_PLACEMENT_3D($,#2671,#2672,#2673);
+#2675=CYLINDRICAL_SURFACE($,#2674,5.5626);
+#2676=ORIENTED_EDGE($,$,$,#1227,.T.);
+#2677=EDGE_LOOP($,(#2676));
+#2678=FACE_OUTER_BOUND('',#2677,.T.);
+#2679=ORIENTED_EDGE($,$,$,#1289,.T.);
+#2680=EDGE_LOOP($,(#2679));
+#2681=FACE_BOUND('',#2680,.T.);
+#2682=ADVANCED_FACE('',(#2678,#2681),#2675,.F.);
+#2683=CARTESIAN_POINT($,(-222.25,466.3948,0.00246000000001));
+#2684=DIRECTION($,(0,0,1));
+#2685=DIRECTION($,(-1,0,0));
+#2686=AXIS2_PLACEMENT_3D($,#2683,#2684,#2685);
+#2687=CYLINDRICAL_SURFACE($,#2686,5.5626);
+#2688=ORIENTED_EDGE($,$,$,#1238,.T.);
+#2689=EDGE_LOOP($,(#2688));
+#2690=FACE_OUTER_BOUND('',#2689,.T.);
+#2691=ORIENTED_EDGE($,$,$,#1300,.T.);
+#2692=EDGE_LOOP($,(#2691));
+#2693=FACE_BOUND('',#2692,.T.);
+#2694=ADVANCED_FACE('',(#2690,#2693),#2687,.F.);
+#2695=CARTESIAN_POINT($,(-222.25,19.05,0.00246000000001));
+#2696=DIRECTION($,(0,0,1));
+#2697=DIRECTION($,(1,0,0));
+#2698=AXIS2_PLACEMENT_3D($,#2695,#2696,#2697);
+#2699=CYLINDRICAL_SURFACE($,#2698,5.5626);
+#2700=ORIENTED_EDGE($,$,$,#1051,.T.);
+#2701=EDGE_LOOP($,(#2700));
+#2702=FACE_OUTER_BOUND('',#2701,.T.);
+#2703=ORIENTED_EDGE($,$,$,#1113,.T.);
+#2704=EDGE_LOOP($,(#2703));
+#2705=FACE_BOUND('',#2704,.T.);
+#2706=ADVANCED_FACE('',(#2702,#2705),#2699,.F.);
+#2707=CARTESIAN_POINT($,(-19.05,19.05,0.00246000000001));
+#2708=DIRECTION($,(0,0,1));
+#2709=DIRECTION($,(1,0,0));
+#2710=AXIS2_PLACEMENT_3D($,#2707,#2708,#2709);
+#2711=CYLINDRICAL_SURFACE($,#2710,5.5626);
+#2712=ORIENTED_EDGE($,$,$,#1062,.T.);
+#2713=EDGE_LOOP($,(#2712));
+#2714=FACE_OUTER_BOUND('',#2713,.T.);
+#2715=ORIENTED_EDGE($,$,$,#1124,.T.);
+#2716=EDGE_LOOP($,(#2715));
+#2717=FACE_BOUND('',#2716,.T.);
+#2718=ADVANCED_FACE('',(#2714,#2717),#2711,.F.);
+#2719=CARTESIAN_POINT($,(31.8483617530013,244.62486,139.789557874071));
+#2720=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#2721=DIRECTION($,(0,1,0));
+#2722=AXIS2_PLACEMENT_3D($,#2719,#2720,#2721);
+#2723=CYLINDRICAL_SURFACE($,#2722,13.5255);
+#2724=ORIENTED_EDGE($,$,$,#1435,.T.);
+#2725=EDGE_LOOP($,(#2724));
+#2726=FACE_OUTER_BOUND('',#2725,.T.);
+#2727=ORIENTED_EDGE($,$,$,#1562,.T.);
+#2728=EDGE_LOOP($,(#2727));
+#2729=FACE_BOUND('',#2728,.T.);
+#2730=ADVANCED_FACE('',(#2726,#2729),#2723,.F.);
+#2731=CARTESIAN_POINT($,(21.9700800198253,225.57486,129.911276140894));
+#2732=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#2733=DIRECTION($,(0,1,0));
+#2734=AXIS2_PLACEMENT_3D($,#2731,#2732,#2733);
+#2735=CYLINDRICAL_SURFACE($,#2734,2.38125);
+#2736=ORIENTED_EDGE($,$,$,#1446,.T.);
+#2737=EDGE_LOOP($,(#2736));
+#2738=FACE_OUTER_BOUND('',#2737,.T.);
+#2739=ORIENTED_EDGE($,$,$,#1573,.T.);
+#2740=EDGE_LOOP($,(#2739));
+#2741=FACE_BOUND('',#2740,.T.);
+#2742=ADVANCED_FACE('',(#2738,#2741),#2735,.F.);
+#2743=CARTESIAN_POINT($,(21.9700800198253,263.67486,129.911276140894));
+#2744=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#2745=DIRECTION($,(0,1,0));
+#2746=AXIS2_PLACEMENT_3D($,#2743,#2744,#2745);
+#2747=CYLINDRICAL_SURFACE($,#2746,2.38125);
+#2748=ORIENTED_EDGE($,$,$,#1457,.T.);
+#2749=EDGE_LOOP($,(#2748));
+#2750=FACE_OUTER_BOUND('',#2749,.T.);
+#2751=ORIENTED_EDGE($,$,$,#1584,.T.);
+#2752=EDGE_LOOP($,(#2751));
+#2753=FACE_BOUND('',#2752,.T.);
+#2754=ADVANCED_FACE('',(#2750,#2753),#2747,.F.);
+#2755=CARTESIAN_POINT($,(44.4207203224982,225.57486,152.361916443567));
+#2756=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#2757=DIRECTION($,(0,1,0));
+#2758=AXIS2_PLACEMENT_3D($,#2755,#2756,#2757);
+#2759=CYLINDRICAL_SURFACE($,#2758,2.38125);
+#2760=ORIENTED_EDGE($,$,$,#1468,.T.);
+#2761=EDGE_LOOP($,(#2760));
+#2762=FACE_OUTER_BOUND('',#2761,.T.);
+#2763=ORIENTED_EDGE($,$,$,#1595,.T.);
+#2764=EDGE_LOOP($,(#2763));
+#2765=FACE_BOUND('',#2764,.T.);
+#2766=ADVANCED_FACE('',(#2762,#2765),#2759,.F.);
+#2767=CARTESIAN_POINT($,(44.4207203224982,263.67486,152.361916443567));
+#2768=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#2769=DIRECTION($,(0,1,0));
+#2770=AXIS2_PLACEMENT_3D($,#2767,#2768,#2769);
+#2771=CYLINDRICAL_SURFACE($,#2770,2.38125);
+#2772=ORIENTED_EDGE($,$,$,#1479,.T.);
+#2773=EDGE_LOOP($,(#2772));
+#2774=FACE_OUTER_BOUND('',#2773,.T.);
+#2775=ORIENTED_EDGE($,$,$,#1606,.T.);
+#2776=EDGE_LOOP($,(#2775));
+#2777=FACE_BOUND('',#2776,.T.);
+#2778=ADVANCED_FACE('',(#2774,#2777),#2771,.F.);
+#2779=CLOSED_SHELL($,(#238,#476,#516,#556,#582,#608,#648,#688,#714,#740,#780,#820,#846,#872,#912,#952,#978,#1004,#1066,#1128,#1154,#1180,#1242,#1304,#1330,#1356,#1483,#1610,#1645,#1680,#1702,#1724,#1741,#1763,#1780,#1802,#1819,#1836,#1858,#1880,#1892,#1904,#1926,#1948,#1960,#1972,#1994,#2011,#2028,#2040,#2052,#2074,#2091,#2108,#2120,#2132,#2154,#2171,#2188,#2200,#2212,#2234,#2251,#2268,#2280,#2292,#2314,#2331,#2348,#2365,#2382,#2399,#2416,#2438,#2450,#2462,#2474,#2486,#2498,#2510,#2522,#2534,#2556,#2573,#2590,#2602,#2624,#2641,#2658,#2670,#2682,#2694,#2706,#2718,#2730,#2742,#2754,#2766,#2778));
+#2780=MANIFOLD_SOLID_BREP('AetherisBody',#2779);
+#2781=APPLICATION_CONTEXT('mechanical design');
+#2782=PRODUCT_CONTEXT('',#2781,'mechanical');
+#2783=PRODUCT('AETHERIS','AetherisBody','',(#2782));
+#2784=PRODUCT_DEFINITION_FORMATION('','',#2783);
+#2785=PRODUCT_DEFINITION_CONTEXT('design',#2781,'design');
+#2786=PRODUCT_DEFINITION('','',#2784,#2785);
+#2787=PRODUCT_DEFINITION_SHAPE('','',#2786);
+#2788=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));
+#2789=(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.));
+#2790=(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT());
+#2791=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNIT_ASSIGNED_CONTEXT((#2788,#2789,#2790))REPRESENTATION_CONTEXT('3','3D'));
+#2792=SHAPE_REPRESENTATION('AetherisBody',(#2780),#2791);
+#2793=SHAPE_DEFINITION_REPRESENTATION(#2787,#2792);
+ENDSEC;
+END-ISO-10303-21;
diff --git a/docs/modules/sheetmetal/artifacts/m8/ctc03-iteration-journal.md b/docs/modules/sheetmetal/artifacts/m8/ctc03-iteration-journal.md
new file mode 100644
index 00000000..b43be5fb
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m8/ctc03-iteration-journal.md
@@ -0,0 +1,17 @@
+# M8 iteration journal and LLM friction
+
+| Interpretation | Feedback | Correction | Improvement |
+|---|---|---|---|
+| Historical recovery contained only two deck slots | CLI recognition exposed many cylindrical inner loops, but the recognizer required one closed circle edge | Admit multi-edge coaxial circular loops deterministically | Source inventory increased to 15 holes + 2 slots |
+| Service feature looked like a full-width flange | Boundary evidence showed a 127 mm attachment and an extended central outer tab | Add generic `Span`/`SpanOffset` and bounded `Tab` semantics | Correct bend length and distinctive tab without a recovered polygon |
+| Repeated holes were initially independent cuts | Semantic equality/pitch checks and comparison paths made duplication fragile | Use named `Pattern` declarations and generated stable members | 17/17 feature matches with fewer independent edits |
+| Feature centers mixed global and local frames | Named region datums and `Region.Center + offset` exposed the intended frame | Resolve datums before profile lowering | 45-degree service features lower correctly from local coordinates |
+| DFM suggested moving front mounting holes | Comparison showed source centers were already correct | Keep source positions; identify missing mounting-flange contour as cause | Avoided a locally “green” but source-wrong patch |
+
+## LLM friction
+
+**What did Codex repeatedly know semantically before she knew the final exact coordinates?** That the openings formed equal-size/equal-pitch groups; that front and rear mounting holes were paired about local flange frames; that the service cluster belonged to a partial 45-degree flange; and that a central connector tab modified its outer edge. Exact local origins and which side of each bend owned the coordinates came later from CLI evidence.
+
+**Which new construct helped most?** `Pattern`. It converts count, feature size, center, and pitch into stable members plus executable equality evidence. `Datum` was a close second because it separated recovered placement from feature definition.
+
+**What still feels awkward?** Irregular outer edges. The language can express a rectangle, a partial span, and one bounded tab, but related chamfers, end bands, notches, and step transitions still want either a giant coordinate profile or new semantic edge operations. A general sketch solver would be premature; a composable edge-profile MIR is the narrower next step.
diff --git a/docs/modules/sheetmetal/artifacts/m8/ctc03-pmi-parity.md b/docs/modules/sheetmetal/artifacts/m8/ctc03-pmi-parity.md
new file mode 100644
index 00000000..bd35a4b9
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m8/ctc03-pmi-parity.md
@@ -0,0 +1,15 @@
+# CTC-03 PMI and datum audit
+
+## Preserved source evidence
+
+The AP242 file contains six instantiated `DATUM_FEATURE` entities, datums labelled A–F, six instantiated `DATUM_SYSTEM` entities, eight `PLUS_MINUS_TOLERANCE` entities, six instantiated `POSITION_TOLERANCE` entities, nine dimensional-size entities, and one dimensional-location entity. The raw model contains 416 PMI-indicator occurrences recognized by the current CLI audit.
+
+Source dimensional evidence used during reconstruction includes nominal inch callouts for Ø0.438, Ø0.625, Ø2.000, Ø1.500, sheet thickness 0.075, and Ø1.065; the final Firmament stores their source-derived metric values. The source STEP remains the evidence authority and is not modified.
+
+## Inferred authored semantics
+
+The M8 program adds three construction datums (`RearMountCenter`, `FrontMountCenter`, and `ServiceHoleCenter`) and pattern relationships inferred from repeated geometry. These are authoring aids, not claims that the AP242 file explicitly named the same construction datums. Equal size and pitch constraints are likewise geometric/authoring interpretations.
+
+## Parity limitation
+
+The current importer detects and inventories PMI-bearing AP242 entities but does not lower the complete semantic GD&T graph into editable Firmament tolerance objects or export equivalent PMI on regenerated STEP. M8 therefore preserves source PMI as audited evidence and preserves nominal dimensions in the engineering program, but does **not** claim PMI/GD&T round-trip parity.
diff --git a/docs/modules/sheetmetal/artifacts/m8/ctc03-semantic-layout.md b/docs/modules/sheetmetal/artifacts/m8/ctc03-semantic-layout.md
new file mode 100644
index 00000000..0368c3ec
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m8/ctc03-semantic-layout.md
@@ -0,0 +1,79 @@
+# Semantic layout and Firmament syntax
+
+## Implemented boundary
+
+`SheetMetalSemanticLayoutParser` is a bounded compile-time IR builder, not a general constraint solver. It resolves local region coordinates before BRep construction. The result contains structs, datums, tabs, patterns, and constraint evidence. Generated pattern members become ordinary `AuthoredSheetCutSpec` values; tabs are consumed by exact planar flange-profile construction. The downstream formed and flat paths remain authoritative.
+
+Concept contracts expose `SheetRegion`, `SheetPattern`, and `FlatPattern`. Concept Paths include each semantic struct, datum, tab, pattern, constraint, and generated member. Thus inspectability survives semantic erasure into exact profiles.
+
+## Real working syntax
+
+```firmament
+Concept Struct Ctc03Layout {
+ Datum RearMountCenter {
+ On: RearMountingFlange;
+ At: (112.395mm, 25.40254mm);
+ }
+
+ Pattern BaseFastenerPattern {
+ On: MainDeck;
+ Feature: Circle { Diameter: 15.875mm; };
+ Center: MainDeck.Center + (82.55mm, -78.78826mm);
+ Count: 4;
+ Pitch: (0mm, 44.45mm);
+ }
+
+ Tab ServiceConnectorTab {
+ On: AngledServiceFlange.Outer;
+ Center: 63.5mm;
+ Width: 101.6mm;
+ Extension: 12.7mm;
+ }
+}
+```
+
+The service flange uses reusable partial-edge attachment syntax:
+
+```firmament
+Flange AngledServiceFlange {
+ From: RightWall.Outer;
+ Length: 48.514mm;
+ Span: 127mm;
+ SpanOffset: 2.3876mm;
+ Angle: 45deg;
+ Radius: 6.35mm;
+ Direction: Down;
+}
+```
+
+## Diagnostics proved by tests
+
+Deliberate contradictory sources are rejected before formed lowering:
+
+- Equal-size: `Require 'StatedIntent' is contradicted by 'Right': feature kind or nominal size differs from 'Left'.`
+- Equal-pitch: the diagnostic identifies the declared pitch and the first member spacing that differs.
+- Mirror: the diagnostic identifies the member that is not a size-preserving mirror about the declared datum/axis.
+- Required member: missing Concept members report `sheetmetal-semantic-required-member` with the absent semantic path.
+
+Diagnostic codes are stable: `sheetmetal-semantic-equal-size`, `sheetmetal-semantic-equal-pitch`, `sheetmetal-semantic-mirror`, and `sheetmetal-semantic-required-member`.
+
+## Why this reduced mistakes
+
+- The four deck holes are one diameter, center, count, and pitch declaration instead of four unrelated coordinates.
+- The service-hole groups share local flange coordinates, so the 45-degree formed placement is delegated to region lowering.
+- The two mounting pairs use named datum centers; changing a recovered center cannot silently leave one member behind.
+- Stable generated paths make the CLI comparison identify the intended pattern member rather than a transient face/edge ID.
+
+The improvement is real but bounded. Irregular wall and mounting-flange outer contours still lack a semantic edge-profile representation and would currently require awkward raw profile coordinates.
+
+## Complexity comparison
+
+Counts use nonblank/noncomment LOC, top-level/nested engineering declarations, and literal two-dimensional millimetre tuples.
+
+| Source | LOC | Declarations | Raw coordinate tuples | Semantic entities | Templates | Resolved constraints |
+|---|---:|---:|---:|---:|---:|---:|
+| M1 forensic recovery | 263 | 23 | 165 | 0 | 0 | 0 |
+| M2 idiomatic skeleton | 19 | 11 | 3 | 0 | 0 | 0 |
+| M8 final | 102 | 24 | 19 | 13 (3 datums, 9 patterns, 1 tab) | 0 | 18 |
+
+M8 is longer than the incomplete M2 skeleton because it contains the full opening intent. It is substantially less coordinate-heavy than the forensic representation. Templates were deliberately not used: CTC-03 is not a standard bounded product family, while the introduced constructs are generic.
diff --git a/docs/modules/sheetmetal/artifacts/m8/validation-report.md b/docs/modules/sheetmetal/artifacts/m8/validation-report.md
new file mode 100644
index 00000000..31cefae5
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m8/validation-report.md
@@ -0,0 +1,43 @@
+# M8 validation report
+
+## Real-path results
+
+- .NET SDK 10 detected; restore was satisfied during the clean solution build.
+- `dotnet build Aetheris.slnx --no-incremental`: pass, zero warnings, zero errors.
+- `dotnet test Aetheris.SheetMetal.Tests --no-restore`: pass, 58/58.
+- `dotnet test Aetheris.slnx --no-build --no-restore`: pass, 2,880/2,880 discovered tests across test-bearing projects. `Aetheris.FrictionLab.Tests` reports no discoverable tests, as before.
+- Final Firmament parses and compiles with the source STEP absent: pass.
+- Concept contract, Concept Struct resolution, Concept Paths, semantic constraints, Profiles, formed lowering, flattening, STEP export/reimport, DFM, and CLI inspect/compare: exercised by tests and CLI dogfood.
+- Non-CTC semantic-panel fixture: pass with deterministic stable paths.
+- `git diff --check`: pass (line-ending notices only; no whitespace errors).
+
+## CLI inspection
+
+Final authored recognition is `Complete`: 15 regions, seven bends, 17 cuts, nine patterns, three datums, one tab, and 18 resolved constraints. Exact flat status is `Valid`; DFM is `Warning` for the two localized front-hole edge-clearance findings documented in the comparison.
+
+One warm observational run on this machine measured:
+
+| Phase | Time |
+|---|---:|
+| Parse total | 33.2315 ms |
+| Semantic + constraint resolution | 19.5383 ms |
+| Formed/profile lower | 71.0012 ms |
+| Authored flat lower | 61.0412 ms |
+
+These are diagnostic timings, not benchmarks. Constraint resolution is included in `semanticResolve`; exact profile construction is included in `formedLower` and is not separately instrumented.
+
+## Determinism
+
+Repeated generation produced stable paths and these SHA-256 values:
+
+| Artifact | SHA-256 |
+|---|---|
+| `ctc03-final.firmament` | `B2EBD30F8D6BB2A6045F28D11AC5779C82D75EF82B56C666BB8A8A8310CD54C4` |
+| `ctc03-formed.step` | `8F4E1A6FA5E780B4EAC140FBDE63AEFCF3DC5463EFD9C0577DD94928030C409A` |
+| `ctc03-flat.step` | `948C3F69090B70E615C3ED60ABB9C6A66B86C88E687870C911FF19E03FA7AC6C` |
+| `ctc03-flat.svg` | `9DA3147DC841A5DF629D88A3576368496A78B71C0DB9DCD4E0C67659A1ED832D` |
+| Flat IR deterministic hash | `55dd154c6bb063a27f6055bbaeb9e0b29aac41ba99bf8735b21cae54969b71aa` |
+
+## Code quality
+
+Verdict: **acceptable bounded prototype**. The semantic IR, diagnostics, stable paths, non-CTC fixture, and real export/reimport tests are cleanly localized. Debt remains: the parser is regex/block based, `Tab` supports only the bounded outer-edge case, semantic and constraint timing share one bucket, and no general irregular edge-profile MIR exists. There is no CTC-specific compiler branch or generator.
diff --git a/fixtures/FirmamentV2/SheetMetal/m8-semantic-panel.firmament b/fixtures/FirmamentV2/SheetMetal/m8-semantic-panel.firmament
new file mode 100644
index 00000000..30d35765
--- /dev/null
+++ b/fixtures/FirmamentV2/SheetMetal/m8-semantic-panel.firmament
@@ -0,0 +1,23 @@
+Concept SemanticPanelIntent {
+ Panel: SheetRegion
+ MountingHoles: SheetPattern
+ Flat: FlatPattern
+}
+
+Concept Struct PanelLayout {
+ Datum MountingPatternCenter { On: Panel; At: Panel.Center; }
+ Pattern MountingHoles {
+ On: Panel;
+ Feature: Circle { Diameter: 6mm; };
+ Center: MountingPatternCenter;
+ Count: 4;
+ Pitch: (20mm, 0mm);
+ }
+}
+
+SheetMetal SemanticPanel : SemanticPanelIntent {
+ Thickness: 1.5mm;
+ KFactor: 0.42;
+ Base Panel { Profile: Rectangle { Width: 100mm; Height: 60mm; }; }
+ Flange RearLip { From: Panel.Rear; Height: 15mm; Angle: 90deg; Radius: 2mm; Direction: Up; }
+}